diff options
| author | Pascal Rigaux <pixel@mandriva.com> | 2004-07-27 10:31:34 +0000 |
|---|---|---|
| committer | Pascal Rigaux <pixel@mandriva.com> | 2004-07-27 10:31:34 +0000 |
| commit | 0306ad0100b9d40606d723706f909438a27dfac1 (patch) | |
| tree | 232eab774506632a3796a5a36cf09771aa614e64 /perl-install | |
| parent | 54a662b712a584c66a9f5762d264cce50acbb6ab (diff) | |
| download | drakx-backup-do-not-use-0306ad0100b9d40606d723706f909438a27dfac1.tar drakx-backup-do-not-use-0306ad0100b9d40606d723706f909438a27dfac1.tar.gz drakx-backup-do-not-use-0306ad0100b9d40606d723706f909438a27dfac1.tar.bz2 drakx-backup-do-not-use-0306ad0100b9d40606d723706f909438a27dfac1.tar.xz drakx-backup-do-not-use-0306ad0100b9d40606d723706f909438a27dfac1.zip | |
- add field {fs_type} partially replacing {pt_type}
{pt_type} is always a number, {fs_type} is always a string
- introduce set_isFormatted()
(to ensure {notFormatted} but also {fs_type_from_magic} and {bad_fs_type_magic} are updated)
- don't use 0x483 for ext3 anymore (same for reiserfs...),
the type_name gives both a pt_type and a fs_type
- many accessors from partition_table removed (type2fs(), fs2pt_type())
- remove isThisFs() (not useful anymore since we can use directly {fs_type})
- remove isFat() (inline the function)
- other isXXX() from partition_table are moved to fs::type
- part2name() is now fs::type::part2type_name
- name2pt_type() is now fs::type::type_name2subpart()
- partition_table::important_types() is now fs::type::type_names()
- fsedit::typeOfPart() is now fs::type::fs_type_from_magic()
- no need to truncate type_name since they are shorter
Diffstat (limited to 'perl-install')
25 files changed, 599 insertions, 531 deletions
diff --git a/perl-install/any.pm b/perl-install/any.pm index fa335a9af..d6ce4ee2f 100644 --- a/perl-install/any.pm +++ b/perl-install/any.pm @@ -8,7 +8,8 @@ use strict; #-###################################################################################### use common; use detect_devices; -use partition_table qw(:types); +use partition_table; +use fs::type; use fsedit; use fs; use lang; @@ -265,7 +266,7 @@ sub setupBootloader__general { if ($prev_clean_tmp != $clean_tmp) { if ($clean_tmp && !fsedit::has_mntpoint('/tmp', $all_hds)) { - push @{$all_hds->{special}}, { device => 'none', mntpoint => '/tmp', pt_type => 'tmpfs' }; + push @{$all_hds->{special}}, { device => 'none', mntpoint => '/tmp', fs_type => 'tmpfs' }; } else { @{$all_hds->{special}} = grep { $_->{mntpoint} ne '/tmp' } @{$all_hds->{special}}; } @@ -481,7 +482,7 @@ sub inspect { $dir = ''; } else { mkdir $dir, 0700; - eval { fs::mount($part->{device}, $dir, type2fs($part, 'skip'), !$b_rw) }; + eval { fs::mount($part->{device}, $dir, $part->{fs_type}, !$b_rw) }; $@ and return; } my $h = before_leaving { diff --git a/perl-install/bootloader.pm b/perl-install/bootloader.pm index 62ae0e16e..8481d0445 100644 --- a/perl-install/bootloader.pm +++ b/perl-install/bootloader.pm @@ -8,7 +8,8 @@ use vars qw(%vga_modes); #- misc imports #-###################################################################################### use common; -use partition_table qw(:types); +use partition_table; +use fs::type; use log; use any; use fsedit; @@ -583,7 +584,7 @@ sub suggest { my $root = '/dev/' . (isLoopback($root_part) ? 'loop7' : $root_part->{device}); my $boot = fsedit::get_root($fstab, 'boot')->{device}; #- PPC xfs module requires enlarged initrd - my $xfsroot = isThisFs("xfs", $root_part); + my $xfsroot = $root_part->{fs_type} eq 'xfs'; my ($onmbr, $unsafe) = $bootloader->{crushMbr} ? (1, 0) : suggest_onmbr($hds->[0]); add2hash_($bootloader, arch() =~ /ppc/ ? @@ -692,7 +693,7 @@ wait for default boot. } elsif (arch() !~ /ia64/) { #- search for dos (or windows) boot partition. Don't look in extended partitions! my @windows_boot_parts = - grep { isFat_or_NTFS($_) && isFat_or_NTFS({ pt_type => fsedit::typeOfPart($_->{device}) }) } + grep { isFat_or_NTFS($_) && member(fs::type::fs_type_from_magic($_), 'vfat', 'ntfs') } map { @{$_->{primary}{normal}} } @$hds; each_index { add_entry($bootloader, @@ -910,7 +911,10 @@ sub write_lilo { my $fstab = [ fsedit::get_fstab(@$hds) ]; (my $part, $file) = fsedit::file2part($fstab, $file); my %hds = map_index { $_ => "hd$::i" } map { $_->{device} } - sort { isFat($b) <=> isFat($a) || $a->{device} cmp $b->{device} } @$fstab; + sort { + my ($a_is_fat, $b_is_fat) = ($a->{fs_type} eq 'vfat', $b->{fs_type} eq 'vfat'); + $a_is_fat <=> $b_is_fat || $a->{device} cmp $b->{device}; + } @$fstab; $hds{$part->{device}} . ":" . $file; } else { $file @@ -1208,8 +1212,8 @@ sub install { my ($bootloader, $hds) = @_; if (my $part = fs::device2part($bootloader->{boot}, [ fsedit::get_fstab(@$hds) ])) { - die N("You can't install the bootloader on a %s partition\n", partition_table::type2fs($part)) - if isThisFs('xfs', $part); + die N("You can't install the bootloader on a %s partition\n", $part->{fs_type}) + if $part->{fs_type} eq 'xfs'; } $bootloader->{keytable} = keytable($bootloader->{keytable}); action($bootloader, 'install', $hds); diff --git a/perl-install/diskdrake/dav.pm b/perl-install/diskdrake/dav.pm index 23652413a..51b6699a1 100644 --- a/perl-install/diskdrake/dav.pm +++ b/perl-install/diskdrake/dav.pm @@ -35,7 +35,7 @@ points, select \"New\".")) }, sub create { my ($in, $all_hds) = @_; - my $dav = { pt_type => 'davfs' }; + my $dav = { fs_type => 'davfs' }; ask_server($in, $dav, $all_hds) or return; push @{$all_hds->{davs}}, $dav; config($in, $dav, $all_hds); diff --git a/perl-install/diskdrake/hd_gtk.pm b/perl-install/diskdrake/hd_gtk.pm index 8479c3f3e..8aff39d06 100644 --- a/perl-install/diskdrake/hd_gtk.pm +++ b/perl-install/diskdrake/hd_gtk.pm @@ -5,8 +5,8 @@ use strict; use common; use ugtk2 qw(:helpers :wrappers :create); -use partition_table qw(:types); -use partition_table::raw; +use partition_table; +use fs::type; use detect_devices; use diskdrake::interactive; use run_program; @@ -292,7 +292,7 @@ sub create_buttons4partitions { last; } }); - $w->set_name("PART_" . part2name($entry)); + $w->set_name("PART_" . fs::type::part2type_name($entry)); $w->set_size_request($entry->{size} * $ratio + $minwidth, 0); gtkpack__($kind->{display_box}, $w); $w->grab_focus if $current_entry && fsedit::are_same_partitions($current_entry, $entry); @@ -325,12 +325,12 @@ sub hd2kind { sub filesystems_button_box() { my @types = (N_("Ext2"), N_("Journalised FS"), N_("Swap"), arch() =~ /sparc/ ? N_("SunOS") : arch() eq "ppc" ? N_("HFS") : N_("Windows"), N_("Other"), N_("Empty")); - my %name2pt_type = (Ext2 => 0x83, 'Journalised FS' => 0x483, Swap => 0x82, Other => 1, "Windows" => 0xb, HFS => 0x402); + my %name2fs_type = (Ext2 => 'ext2', 'Journalised FS' => 'ext3', Swap => 'swap', Other => 'other', "Windows" => 'vfat', HFS => 'hfs'); gtkpack(Gtk2::HBox->new(0,0), N("Filesystem types:"), map { my $w = Gtk2::Button->new(translate($_)); - my $t = $name2pt_type{$_}; + my $t = $name2fs_type{$_}; $w->signal_connect(clicked => sub { try_('', \&createOrChangeType, $t, current_hd(), current_part()) }); $w->can_focus(0); $w->set_name($_); @@ -339,20 +339,20 @@ sub filesystems_button_box() { } sub createOrChangeType { - my ($in, $pt_type, $hd, $part, $all_hds) = @_; + my ($in, $fs_type, $hd, $part, $all_hds) = @_; $part ||= !fsedit::get_fstab($hd) && { pt_type => 0, start => 1, size => $hd->{totalsectors} - 1 }; $part or return; - if ($pt_type == 1) { + if ($fs_type eq 'other') { $in->ask_warn('', N("Use ``%s'' instead", $part->{pt_type} ? N("Type") : N("Create"))); - } elsif (!$pt_type) { + } elsif (!$fs_type) { $in->ask_warn('', N("Use ``%s'' instead", N("Delete"))) if $part->{pt_type}; } elsif ($part->{pt_type}) { - return if $pt_type == $part->{pt_type}; + return if $fs_type eq $part->{fs_type}; $in->ask_warn('', isBusy($part) ? N("Use ``Unmount'' first") : N("Use ``%s'' instead", N("Type"))); } else { - $part->{pt_type} = $pt_type; + fs::type::set_fs_type($part, $fs_type); diskdrake::interactive::Create($in, $hd, $part, $all_hds); } } diff --git a/perl-install/diskdrake/interactive.pm b/perl-install/diskdrake/interactive.pm index f4e73c885..7d0068d29 100644 --- a/perl-install/diskdrake/interactive.pm +++ b/perl-install/diskdrake/interactive.pm @@ -4,7 +4,8 @@ use diagnostics; use strict; use common; -use partition_table qw(:types); +use fs::type; +use partition_table; use partition_table::raw; use detect_devices; use run_program; @@ -26,6 +27,7 @@ struct part { int start # in sectors int size # in sectors int pt_type # 0x82, 0x83, 0x6 ... + string fs_type # 'ext2', 'nfs', ... string device # 'hda5', 'sdc1' ... string devfs_device # 'ide/host0/bus0/target0/lun0/part5', ... string prefer_devfs_name # should the {devfs_device} or the {device} be used in fstab @@ -144,7 +146,7 @@ struct hd_lvm inherits hd { } struct raw_hd inherits hd { - string pt_type # 0x82, 0x83, 'nfs', ... + string fs_type # 'ext2', 'nfs', ... string mntpoint # '/', '/usr' ... string options # 'defaults', 'noauto' @@ -411,9 +413,9 @@ sub part_possible_actions { my %actions = my @l = ( N_("Mount point") => '($part->{real_mntpoint} && common::usingRamdisk()) || (!isBusy && !isSwap && !isNonMountable)', - N_("Type") => '!isBusy && $::expert && (!readonly || ($part->{pt_type} & 0xff) == 0x83)', + N_("Type") => '!isBusy && $::expert && (!readonly || $part->{pt_type} == 0x83)', N_("Options") => '$::expert', - N_("Resize") => '!isBusy && !readonly && !isSpecial || isLVM($hd) && isMounted && isThisFs("xfs", $part)', + N_("Resize") => '!isBusy && !readonly && !isSpecial || isLVM($hd) && isMounted && $part->{fs_type} eq "xfs"', N_("Move") => '!isBusy && !readonly && !isSpecial && $::expert && 0', # disable for the moment N_("Format") => '!isBusy && !readonly && ($::expert || $::isStandalone)', N_("Mount") => '!isBusy && (hasMntpoint || isSwap) && maybeFormatted && ($::expert || $::isStandalone)', @@ -453,14 +455,14 @@ sub Create { $part->{maxsize} = $part->{size}; $part->{size} = 0; if (!fsedit::suggest_part($part, $all_hds)) { $part->{size} = $part->{maxsize}; - $part->{pt_type} ||= 0x483; + fs::type::suggest_fs_type($part, 'ext3'); } #- update adjustment for start and size, take into account the minimum partition size #- including one less sector for start due to a capacity to increase the adjustement by #- one. my ($primaryOrExtended, $migrate_files); - my $type_name = part2name($part); + my $type_name = fs::type::part2type_name($part); my $mb_size = $part->{size} >> 11; my $has_startsector = ($::expert || arch() !~ /i.86/) && !isLVM($hd); @@ -470,9 +472,9 @@ sub Create { { label => N("Start sector: "), val => \$part->{start}, min => $def_start, max => ($max - min_partition_size($hd)), type => 'range' }, ), { label => N("Size in MB: "), val => \$mb_size, min => min_partition_size($hd) >> 11, max => $def_size >> 11, type => 'range' }, - { label => N("Filesystem type: "), val => \$type_name, list => [ partition_table::important_types() ], sort => 0 }, + { label => N("Filesystem type: "), val => \$type_name, list => [ fs::type::type_names() ], sort => 0 }, { label => N("Mount point: "), val => \$part->{mntpoint}, list => [ fsedit::suggestions_mntpoint($all_hds), '' ], - disabled => sub { my $p = { pt_type => name2pt_type($type_name) }; isSwap($p) || isNonMountable($p) }, type => 'combo', not_edit => 0, + disabled => sub { my $p = fs::type::type_name2subpart($type_name); isSwap($p) || isNonMountable($p) }, type => 'combo', not_edit => 0, }, if_($::expert && $hd->hasExtended, { label => N("Preference: "), val => \$primaryOrExtended, list => [ '', "Extended", "Primary", if_($::expert, "Extended_0x85") ] }, @@ -492,7 +494,7 @@ sub Create { } }, complete => sub { $part->{size} = from_Mb($mb_size, min_partition_size($hd), $max - $part->{start}); #- need this to be able to get back the approximation of using MB - $part->{pt_type} = name2pt_type($type_name); + put_in_hash($part, fs::type::type_name2subpart($type_name)); $part->{mntpoint} = '' if isNonMountable($part); $part->{mntpoint} = 'swap' if isSwap($part); fs::set_default_options($part); @@ -559,27 +561,28 @@ sub Type { my $warn = sub { ask_alldatawillbelost($in, $part, N_("After changing type of partition %s, all data on this partition will be lost")) }; #- for ext2, warn after choosing as ext2->ext3 can be achieved without loosing any data :) - isExt2($part) or $warn->() or return; + $part->{fs_type} eq 'ext2' or $warn->() or return; - my @types = partition_table::important_types(); + my @types = fs::type::type_names(); - #- when readonly, Type() is allowed only when changing between various { 0x83, 0x183, ... } - @types = grep { (name2pt_type($_) & 0xff) == 0x83 } @types if $hd->{readonly}; + #- when readonly, Type() is allowed only when changing {fs_type} but not {pt_type} + #- eg: switching between ext2, ext3, reiserfs... + @types = grep { fs::type::type_name2pt_type($_) == $part->{pt_type} } @types if $hd->{readonly}; - my $type_name = part2name($part); + my $type_name = fs::type::part2type_name($part); $in->ask_from_({ title => N("Change partition type"), messages => N("Which filesystem do you want?"), focus_first => 1, }, [ { label => N("Type"), val => \$type_name, list => \@types, sort => 0, not_edit => !$::expert } ]) or return; - my $pt_type = $type_name && name2pt_type($type_name); + my $type = $type_name && fs::type::type_name2subpart($type_name); - if (isExt2($part) && isThisFs('ext3', { pt_type => $pt_type })) { + if (member($type->{fs_type}, 'ext2', 'ext3')) { my $_w = $in->wait_message('', N("Switching from ext2 to ext3")); if (run_program::run("tune2fs", "-j", devices::make($part->{device}))) { - $part->{pt_type} = $pt_type; - $part->{isFormatted} = 1; #- assume that if tune2fs works, partition is formatted + put_in_hash($part, $type); + set_isFormatted($part, 1); #- assume that if tune2fs works, partition is formatted #- disable the fsck (don't do it together with -j in case -j fails?) fs::format::disable_forced_fsck($part->{device}); @@ -587,10 +590,10 @@ sub Type { } } #- either we switch to non-ext3 or switching losslessly to ext3 failed - !isExt2($part) or $warn->() or return; + $part->{fs_type} ne 'ext2' or $warn->() or return; - if (defined $pt_type) { - check_pt_type($in, $pt_type, $hd, $part) and fsedit::change_pt_type($pt_type, $hd, $part); + if (defined $type) { + check_type($in, $type, $hd, $part) and fsedit::change_type($type, $hd, $part); } } @@ -657,7 +660,7 @@ sub Resize { # here we may have a non-formatted or a formatted partition # -> doing as if it was formatted - if (isFat($part)) { + if ($part->{fs_type} eq 'vfat') { write_partitions($in, $hd) or return; #- try to resize without losing data my $_w = $in->wait_message(N("Resizing"), N("Computing FAT filesystem bounds")); @@ -666,7 +669,7 @@ sub Resize { $nice_resize{fat} = resize_fat::main->new($part->{device}, devices::make($part->{device})); $min = max($min, $nice_resize{fat}->min_size); $max = min($max, $nice_resize{fat}->max_size); - } elsif (isExt2($part) || isThisFs('ext3', $part)) { + } elsif (member($part->{fs_type}, 'ext2', 'ext3')) { write_partitions($in, $hd) or return; my $dev = devices::make($part->{device}); my $r = run_program::get_stdout('dumpe2fs', $dev); @@ -678,18 +681,18 @@ sub Resize { $min = max($min, ($block_count - $free_block) * ($block_size / 512)); $nice_resize{ext2} = $dev; } - } elsif (isThisFs('ntfs', $part)) { + } elsif ($part->{fs_type} eq 'ntfs') { write_partitions($in, $hd) or return; require diskdrake::resize_ntfs; $nice_resize{ntfs} = diskdrake::resize_ntfs->new($part->{device}, devices::make($part->{device})); $min = $nice_resize{ntfs}->min_size or delete $nice_resize{ntfs}; - } elsif (isThisFs("reiserfs", $part)) { + } elsif ($part->{fs_type} eq 'reiserfs') { write_partitions($in, $hd) or return; if (defined(my $free = fs::df($part))) { $nice_resize{reiserfs} = 1; $min = max($min, $part->{size} - $free); } - } elsif (isThisFs('xfs', $part) && isLVM($hd) && $::isStandalone && isMounted($part)) { + } elsif ($part->{fs_type} eq 'xfs' && isLVM($hd) && $::isStandalone && $part->{isMounted}) { $min = $part->{size}; #- ensure the user can only increase $nice_resize{xfs} = 1; } @@ -764,10 +767,9 @@ filesystem checks will be run on your next boot into Windows(TM)")); } if (%nice_resize) { - $part->{isFormatted} = 1; + set_isFormatted($part, 1); } else { - $part->{notFormatted} = 1; - $part->{isFormatted} = 0; + set_isFormatted($part, 0); partition_table::verifyParts($hd); $part->{mntpoint} = '' if isNonMountable($part); #- mainly for ntfs, which we can't format } @@ -866,20 +868,20 @@ sub Loopback { my $handle = any::inspect($real_part) or $in->ask_warn('', N("This partition can't be used for loopback")), return; my ($min, $max) = (1, loopback::getFree($handle->{dir}, $real_part)); - $max = min($max, 1 << (31 - 9)) if isFat($real_part); #- FAT doesn't handle file size bigger than 2GB + $max = min($max, 1 << (31 - 9)) if $real_part->{fs_type} eq 'vfat'; #- FAT doesn't handle file size bigger than 2GB my $part = { maxsize => $max, size => 0, loopback_device => $real_part, notFormatted => 1 }; if (!fsedit::suggest_part($part, $all_hds)) { $part->{size} = $part->{maxsize}; - $part->{pt_type} ||= 0x483; + fs::type::suggest_fs_type($part, 'ext3'); } delete $part->{mntpoint}; # we don't want the suggested mntpoint - my $type_name = part2name($part); + my $type_name = fs::type::part2type_name($part); my $mb_size = $part->{size} >> 11; $in->ask_from(N("Loopback"), '', [ { label => N("Loopback file name: "), val => \$part->{loopback_file} }, { label => N("Size in MB: "), val => \$mb_size, min => $min >> 11, max => $max >> 11, type => 'range' }, - { label => N("Filesystem type: "), val => \$type_name, list => [ partition_table::important_types() ], not_edit => !$::expert, sort => 0 }, + { label => N("Filesystem type: "), val => \$type_name, list => [ fs::type::type_names() ], not_edit => !$::expert, sort => 0 }, ], complete => sub { $part->{loopback_file} or $in->ask_warn('', N("Give a file name")), return 1, 0; @@ -894,7 +896,7 @@ sub Loopback { } 0; }) or return; - $part->{pt_type} = name2pt_type($type_name); + put_in_hash($part, fs::type::type_name2subpart($type_name)); push @{$real_part->{loopback}}, $part; fsedit::recompute_loopbacks($all_hds); } @@ -1018,21 +1020,20 @@ sub partitions_suggestions { $fsedit::suggestions{$t}; } -sub check_pt_type { - my ($in, $pt_type, $hd, $part) = @_; - eval { fsedit::check_pt_type($pt_type, $hd, $part) }; +sub check_type { + my ($in, $type, $hd, $part) = @_; + eval { fsedit::check_fs_type($type->{fs_type}, $hd, $part) }; if (my $err = $@) { $in->ask_warn('', formatError($err)); return; } if ($::isStandalone) { - if (my $pkg = fsedit::package_needed_for_partition_type({ pt_type => $pt_type })) { - my $fs = type2fs({ pt_type => $pt_type }); - if (!-x "/sbin/mkfs.$fs") { + if (my $pkg = fsedit::package_needed_for_partition_type($type)) { + if (!-x "/sbin/mkfs.$type->{fs_type}") { $in->ask_yesorno('', N("The package %s is needed. Install it?", $pkg), 1) or return; $in->do_pkgs->install($pkg); } - -x "/sbin/mkfs.$fs" or $in->ask_warn('', "Mandatory package $pkg is missing"), return; + -x "/sbin/mkfs.$type->{fs_type}" or $in->ask_warn('', "Mandatory package $pkg is missing"), return; } } 1; @@ -1052,7 +1053,7 @@ sub check_mntpoint { } sub check { my ($in, $hd, $part, $all_hds) = @_; - check_pt_type($in, $part->{pt_type}, $hd, $part) && + check_type($in, $part, $hd, $part) && check_mntpoint($in, $part->{mntpoint}, $hd, $part, $all_hds); } @@ -1157,17 +1158,16 @@ sub format_part_info { $info .= N("Volume label: ") . "$part->{device_LABEL}\n" if $part->{device_LABEL} && $::expert; $info .= N("DOS drive letter: %s (just a guess)\n", $part->{device_windobe}) if $part->{device_windobe}; if (arch() eq "ppc") { - my $new_value = $part->{pType}; - $new_value =~ s/[^A-Za-z0-9_]//g; - $info .= N("Type: ") . $new_value . ($::expert ? sprintf " (0x%x)", $part->{pt_type} : '') . "\n"; - if (defined $part->{pName}) { - $new_value = $part->{pName}; - $new_value =~ s/[^A-Za-z0-9_]//g; - $info .= N("Name: ") . $new_value . "\n"; - } + my $pType = $part->{pType}; + $pType =~ s/[^A-Za-z0-9_]//g; + $info .= N("Type: ") . $pType . ($::expert ? sprintf " (0x%x)", $part->{pt_type} : '') . "\n"; + if (defined $part->{pName}) { + my $pName = $part->{pName}; + $pName =~ s/[^A-Za-z0-9_]//g; + $info .= N("Name: ") . $pName . "\n"; + } } elsif ($part->{pt_type}) { - my $type_name = substr(part2name($part), 0, 40); # limit the length - $info .= N("Type: ") . $type_name . ($::expert ? sprintf " (0x%x)", $part->{pt_type} : '') . "\n"; + $info .= N("Type: ") . (fs::type::part2type_name($part) || $part->{fs_type}) . ($::expert ? sprintf " (0x%x)", $part->{pt_type} : '') . "\n"; } else { $info .= N("Empty") . "\n"; } @@ -1232,8 +1232,7 @@ sub format_raw_hd_info { $info .= N("Mount point: ") . "$raw_hd->{mntpoint}\n" if $raw_hd->{mntpoint}; $info .= format_hd_info($raw_hd); if ($raw_hd->{pt_type}) { - my $type_name = substr(part2name($raw_hd), 0, 40); # limit the length - $info .= N("Type: ") . $type_name . "\n"; + $info .= N("Type: ") . (fs::type::part2type_name($raw_hd) || $raw_hd->{fs_type}) . "\n"; } if (my $s = $raw_hd->{options}) { $s =~ s/password=([^\s,]*)/'password=' . ('x' x length($1))/e; diff --git a/perl-install/diskdrake/removable.pm b/perl-install/diskdrake/removable.pm index 905f6a2c4..d2c7ad32c 100644 --- a/perl-install/diskdrake/removable.pm +++ b/perl-install/diskdrake/removable.pm @@ -43,11 +43,11 @@ sub mount_point { sub type { my ($in, $raw_hd) = @_; my @fs = ('auto', fs::auto_fs()); - my $pt_type = $raw_hd->{pt_type}; + my $fs_type = $raw_hd->{fs_type}; $in->ask_from(N("Change type"), N("Which filesystem do you want?"), - [ { label => N("Type"), val => \$pt_type, list => [@fs], not_edit => !$::expert } ]) or return; - $raw_hd->{pt_type} = $pt_type; + [ { label => N("Type"), val => \$fs_type, list => [@fs], not_edit => !$::expert } ]) or return; + $raw_hd->{fs_type} = $fs_type; } 1; diff --git a/perl-install/fs.pm b/perl-install/fs.pm index efd1502db..4614d7d20 100644 --- a/perl-install/fs.pm +++ b/perl-install/fs.pm @@ -8,7 +8,7 @@ use MDK::Common::Various; use common; use log; use devices; -use partition_table qw(:types); +use fs::type; use run_program; use detect_devices; use modules; @@ -46,12 +46,11 @@ sub read_fstab { $options = 'defaults' if $options eq 'rw'; # clean-up for mtab read - my $pt_type = fs2pt_type($fs_type); - if ($pt_type eq 'supermount') { + if ($fs_type eq 'supermount') { # normalize this bloody supermount $options = join(",", 'supermount', grep { if (/fs=(.*)/) { - $pt_type = $1; + $fs_type = $1; 0; } elsif (/dev=(.*)/) { $dev = $1; @@ -62,15 +61,15 @@ sub read_fstab { 1; } } split(',', $options)); - } elsif ($pt_type eq 'smb') { + } elsif ($fs_type eq 'smb') { # prefering type "smbfs" over "smb" - $pt_type = 'smbfs'; + $fs_type = 'smbfs'; } $mntpoint =~ s/\\040/ /g; $dev =~ s/\\040/ /g; my $h = { - mntpoint => $mntpoint, pt_type => $pt_type, + mntpoint => $mntpoint, fs_type => $fs_type, options => $options, comment => $comment, if_(member('keep_freq_passno', @reading_options), freq => $freq, passno => $passno), }; @@ -110,16 +109,15 @@ sub merge_fstabs { $p->{mntpoint} = $p2->{mntpoint} if delete $p->{unsafeMntpoint}; - $p->{pt_type} = $p2->{pt_type} if $p2->{pt_type} && !$loose; + $p->{fs_type} = $p2->{fs_type} if $p2->{fs_type} && !$loose; $p->{options} = $p2->{options} if $p2->{options} && !$loose; #- important to get isMounted property else DrakX may try to mount already mounted partitions :-( add2hash($p, $p2); $p->{device_alias} ||= $p2->{device_alias} || $p2->{device} if $p->{device} ne $p2->{device} && $p2->{device} !~ m|/|; - $p->{pt_type} && $p2->{pt_type} && $p->{pt_type} ne $p2->{pt_type} && type2fs($p) ne type2fs($p2) && - $p->{pt_type} ne 'auto' && $p2->{pt_type} ne 'auto' and - log::l("err, fstab and partition table do not agree for $p->{device} type: " . - (type2fs($p) || part2name($p)) . " vs ", (type2fs($p2) || part2name($p2))); + $p->{fs_type} && $p2->{fs_type} && $p->{fs_type} ne $p2->{fs_type} + && $p->{fs_type} ne 'auto' && $p2->{fs_type} ne 'auto' and + log::l("err, fstab and partition table do not agree for $p->{device} type: $p->{fs_type} vs $p2->{fs_type}"); } @l; } @@ -180,9 +178,9 @@ sub add2all_hds { foreach (@l) { my $s = - isThisFs('nfs', $_) ? 'nfss' : - isThisFs('smbfs', $_) ? 'smbs' : - isThisFs('davfs', $_) ? 'davs' : + $_->{fs_type} eq 'nfs' ? 'nfss' : + $_->{fs_type} eq 'smbfs' ? 'smbs' : + $_->{fs_type} eq 'davfs' ? 'davs' : isTrueLocalFS($_) || isSwap($_) || isOtherAvailableFS($_) ? '' : 'special'; push @{$all_hds->{$s}}, $_ if $s; @@ -200,9 +198,9 @@ sub merge_info_from_mtab { my ($fstab) = @_; my @l1 = map { my $l = $_; - my %l = (pt_type => fs2pt_type('swap')); - $l{$_} = $l->{$_} foreach qw(device major minor); - \%l; + my $h = fs::type::fs_type2subpart('swap'); + $h->{$_} = $l->{$_} foreach qw(device major minor); + $h; } read_fstab('', '/proc/swaps'); my @l2 = map { read_fstab('', $_) } '/etc/mtab', '/proc/mounts'; @@ -216,7 +214,8 @@ sub merge_info_from_mtab { $_->{mntpoint} = common::usingRamdisk() && "/mnt/hd"; #- remap for hd install. } } - $_->{isMounted} = $_->{isFormatted} = 1; + $_->{isMounted} = 1; + set_isFormatted($_, 1); delete $_->{options}; } merge_fstabs('loose', $fstab, @l1, @l2); @@ -255,7 +254,7 @@ sub prepare_write_fstab { my $device = isLoopback($_) ? ($_->{mntpoint} eq '/' ? "/initrd/loopfs" : $_->{loopback_device}{mntpoint}) . $_->{loopback_file} : - part2device($o_prefix, $_->{prefer_devfs_name} ? $_->{devfs_device} : $_->{device}, $_->{pt_type}); + part2device($o_prefix, $_->{prefer_devfs_name} ? $_->{devfs_device} : $_->{device}, $_->{fs_type}); my $real_mntpoint = $_->{mntpoint} || ${{ '/tmp/hdimage' => '/mnt/hd' }}{$_->{real_mntpoint}}; mkdir_p("$o_prefix$real_mntpoint") if $real_mntpoint =~ m|^/|; @@ -275,7 +274,7 @@ sub prepare_write_fstab { my $options = $_->{options}; - if (isThisFs('smbfs', $_) && $options =~ /password=/ && !$b_keep_smb_credentials) { + if ($_->{fs_type} eq 'smbfs' && $options =~ /password=/ && !$b_keep_smb_credentials) { require network::smb; if (my ($opts, $smb_credentials) = network::smb::fstab_entry_to_credentials($_)) { $options = $opts; @@ -283,7 +282,7 @@ sub prepare_write_fstab { } } - my $fs_type = type2fs($_, 'auto'); + my $fs_type = $_->{fs_type} || 'auto'; my $dev = $_->{prefer_device_LABEL} ? 'LABEL=' . $_->{device_LABEL} : @@ -309,7 +308,7 @@ sub prepare_write_fstab { } else { () } - } grep { $_->{device} && ($_->{mntpoint} || $_->{real_mntpoint}) && $_->{pt_type} && ($_->{isFormatted} || !$_->{notFormatted}) } @$fstab; + } grep { $_->{device} && ($_->{mntpoint} || $_->{real_mntpoint}) && $_->{fs_type} && ($_->{isFormatted} || !$_->{notFormatted}) } @$fstab; join('', map { $_->[1] } sort { $a->[0] cmp $b->[0] } @l), \@smb_credentials; } @@ -331,8 +330,8 @@ sub write_fstab { } sub part2device { - my ($prefix, $dev, $pt_type) = @_; - $dev eq 'none' || member($pt_type, qw(nfs smbfs davfs)) ? + my ($prefix, $dev, $fs_type) = @_; + $dev eq 'none' || member($fs_type, qw(nfs smbfs davfs)) ? $dev : do { my $dir = $dev =~ m!^(/|LABEL=)! ? '' : '/dev/'; @@ -373,13 +372,13 @@ sub mount_options_unpack { push @{$per_fs{$_}}, 'usrquota', 'grpquota' foreach 'ext2', 'ext3', 'xfs'; while (my ($fs, $l) = each %per_fs) { - isThisFs($fs, $part) || $part->{pt_type} eq 'auto' && member($fs, @auto_fs) or next; + $part->{fs_type} eq $fs || $part->{fs_type} eq 'auto' && member($fs, @auto_fs) or next; $non_defaults->{$_} = 1 foreach @$l; } $non_defaults->{encrypted} = 1 if !$part->{isFormatted} || isSwap($part); - $non_defaults->{supermount} = 1 if $part->{pt_type} =~ /:/ || member(type2fs($part), 'auto', @auto_fs); + $non_defaults->{supermount} = 1 if $part->{fs_type} =~ /:/ || member($part->{fs_type}, 'auto', @auto_fs); my $defaults = { reverse %$non_defaults }; my %options = map { $_ => '' } keys %$non_defaults; @@ -489,7 +488,7 @@ sub rationalize_options { my ($options, $unknown) = mount_options_unpack($part); - if (!isThisFs('reiserfs', $part)) { + if ($part->{fs_type} ne 'reiserfs') { $options->{notail} = 0; } @@ -504,8 +503,8 @@ sub set_default_options { if ($part->{is_removable}) { $options->{supermount} = $opts{useSupermount} && !($opts{useSupermount} eq 'magicdev' && $part->{media_type} eq 'cdrom'); - $part->{pt_type} = !$options->{supermount} ? 'auto' : - $part->{media_type} eq 'cdrom' ? 'udf:iso9660' : 'ext2:vfat'; + $part->{fs_type} = !$options->{supermount} ? 'auto' : + $part->{media_type} eq 'cdrom' ? 'udf:iso9660' : 'ext2:vfat'; } if ($part->{media_type} eq 'cdrom') { @@ -524,15 +523,15 @@ sub set_default_options { #- news spool to speed up news servers). $options->{noatime} = detect_devices::isLaptop(); } - if (isThisFs('nfs', $part)) { + if ($part->{fs_type} eq 'nfs') { put_in_hash($options, { nosuid => 1, 'rsize=8192,wsize=8192' => 1, soft => 1, }); } - if (isThisFs('smbfs', $part)) { + if ($part->{fs_type} eq 'smbfs') { add2hash($options, { 'username=' => '%' }) if !$options->{'credentials='}; } - if (isFat($part) || member('vfat', split(':', $part->{pt_type})) || isThisFs('auto', $part)) { + if (member('vfat', split(':', $part->{fs_type})) || $part->{fs_type} eq 'auto') { put_in_hash($options, { user => 1, noexec => 0, @@ -543,15 +542,15 @@ sub set_default_options { 'iocharset=' => $opts{iocharset}, 'codepage=' => $opts{codepage}, }); } - if (isThisFs('ntfs', $part)) { + if ($part->{fs_type} eq 'ntfs') { put_in_hash($options, { ro => 1, 'nls=' => $opts{iocharset}, 'umask=0' => $opts{security} < 3, 'umask=0022' => $opts{security} < 4, }); } - if (member('iso9660', split(':', $part->{pt_type})) || isThisFs('auto', $part)) { + if (member('iso9660', split(':', $part->{fs_type})) || $part->{fs_type} eq 'auto') { put_in_hash($options, { user => 1, noexec => 0, 'iocharset=' => $opts{iocharset} }); } - if (isThisFs('reiserfs', $part)) { + if ($part->{fs_type} eq 'reiserfs') { $options->{notail} = 1; } if (isLoopback($part) && !isSwap($part)) { #- no need for loop option for swap files @@ -607,13 +606,13 @@ sub get_raw_hds { get_major_minor(@{$all_hds->{raw_hds}}); my @fstab = read_fstab($prefix, '/etc/fstab', 'keep_default'); - $all_hds->{nfss} = [ grep { isThisFs('nfs', $_) } @fstab ]; - $all_hds->{smbs} = [ grep { isThisFs('smbfs', $_) } @fstab ]; - $all_hds->{davs} = [ grep { isThisFs('davfs', $_) } @fstab ]; + $all_hds->{nfss} = [ grep { $_->{fs_type} eq 'nfs' } @fstab ]; + $all_hds->{smbs} = [ grep { $_->{fs_type} eq 'smbfs' } @fstab ]; + $all_hds->{davs} = [ grep { $_->{fs_type} eq 'davfs' } @fstab ]; $all_hds->{special} = [ - (grep { isThisFs('tmpfs', $_) } @fstab), - { device => 'none', mntpoint => '/proc', pt_type => 'proc' }, - { device => 'none', mntpoint => '/dev/pts', pt_type => 'devpts', options => 'mode=0620' }, + (grep { $_->{fs_type} eq 'tmpfs' } @fstab), + { device => 'none', mntpoint => '/proc', fs_type => 'proc' }, + { device => 'none', mntpoint => '/dev/pts', fs_type => 'devpts', options => 'mode=0620' }, ]; } @@ -676,7 +675,7 @@ sub mount { $dev = part2device('', $dev, $fs); - $fs ne 'skip' or log::l("not mounting $dev partition"), return; + $fs or log::l("not mounting $dev partition"), return; my @fs_modules = qw(vfat hfs romfs ufs reiserfs xfs jfs ext3); @@ -791,11 +790,12 @@ sub mount_part { $mntpoint = "/initrd/loopfs"; } my $dev = $part->{real_device} || $part->{device}; - mount($dev, $mntpoint, type2fs($part, 'skip'), $b_rdonly, $part->{options}, $o_wait_message); + mount($dev, $mntpoint, $part->{fs_type}, $b_rdonly, $part->{options}, $o_wait_message); rmdir "$mntpoint/lost+found"; } } - $part->{isMounted} = $part->{isFormatted} = 1; #- assume that if mount works, partition is formatted + $part->{isMounted} = 1; + set_isFormatted($part, 1); #- assume that if mount works, partition is formatted } sub umount_part { @@ -841,10 +841,9 @@ sub df { return; #- won't even try! } else { mkdir_p($dir); - eval { mount($part->{device}, $dir, type2fs($part, 'skip'), 'readonly') }; + eval { mount($part->{device}, $dir, $part->{fs_type}, 'readonly') }; if ($@) { - $part->{notFormatted} = 1; - $part->{isFormatted} = 0; + set_isFormatted($part, 0); unlink $dir; return; } diff --git a/perl-install/fs/format.pm b/perl-install/fs/format.pm index a3a33f0c4..d41a98ccc 100644 --- a/perl-install/fs/format.pm +++ b/perl-install/fs/format.pm @@ -1,9 +1,12 @@ package fs::format; +use diagnostics; +use strict; + use run_program; use common; +use fs::type; use log; -use partition_table qw(:types); my %cmds = ( ext2 => 'mke2fs -F', @@ -44,9 +47,9 @@ sub part_raw { my $dev = $part->{real_device} || $part->{device}; my @options = if_($part->{toFormatCheck}, "-c"); - log::l("formatting device $dev (type ", part2name($part), ")"); + log::l("formatting device $dev (type $part->{fs_type})"); - my $fs_type = type2fs($part); + my $fs_type = $part->{fs_type}; if ($fs_type eq 'ext2' || $fs_type eq 'ext3') { push @options, "-m", "0" if $part->{mntpoint} =~ m|^/home|; @@ -58,7 +61,7 @@ sub part_raw { push @options, '-l', 'bootstrap'; } - my $cmd = $cmds{$fs_type} or die N("I don't know how to format %s in type %s", $part->{device}, part2name($part)); + my $cmd = $cmds{$fs_type} or die N("I don't know how to format %s in type %s", $part->{device}, $part->{fs_type}); run_program::raw({ timeout => 60 * 60 }, split(' ', $cmd), @options, devices::make($dev)) or die N("%s formatting of %s failed", $fs_type, $dev); @@ -66,7 +69,7 @@ sub part_raw { disable_forced_fsck($dev); } - $part->{isFormatted} = 1; + set_isFormatted($part, 1); } sub disable_forced_fsck { diff --git a/perl-install/fs/type.pm b/perl-install/fs/type.pm new file mode 100644 index 000000000..90d2f3ad0 --- /dev/null +++ b/perl-install/fs/type.pm @@ -0,0 +1,334 @@ +package fs::type; # $Id$ + +use diagnostics; +use strict; + +use common; + + +our @ISA = qw(Exporter); +our @EXPORT = qw( + isExtended isTrueLocalFS isTrueFS isDos isSwap isSunOS isOtherAvailableFS isRawLVM isRawRAID isRAID isLVM isMountableRW isNonMountable isPartOfLVM isPartOfRAID isPartOfLoopback isLoopback isMounted isBusy isSpecial isApple isAppleBootstrap isWholedisk isHiddenMacPart isFat_or_NTFS + maybeFormatted set_isFormatted +); + + +my (%type_name2pt_type, %type_name2fs_type, %fs_type2pt_type, %pt_type2fs_type, %type_names); + +{ + my @list_types = ( + important => [ + 0x82 => 'swap', 'Linux swap', + 0x83 => 'ext2', 'Linux native', + 0x83 => 'ext3', 'Journalised FS: ext3', + 0x83 => 'reiserfs', 'Journalised FS: ReiserFS', +if_(arch() =~ /ppc|i.86|ia64/, + 0x83 => 'xfs', 'Journalised FS: XFS', +), +if_(arch() =~ /ppc|i.86/, + 0x83 => 'jfs', 'Journalised FS: JFS', +), +if_(arch() =~ /i.86|ia64|x86_64/, + 0x0b => 'vfat', 'FAT32', +), +if_(arch() =~ /ppc/, + 0x401 => 'apple', 'Apple Bootstrap', + 0x402 => 'hfs', 'Apple HFS Partition', +), + ], + + less_important => [ + 0x8e => '', 'Linux Logical Volume Manager', + 0xfd => '', 'Linux RAID', + ], + + special => [ + 0x0 => '', 'Empty', + 0x05 => '', 'Extended', + 0x0f => '', 'W95 Extended (LBA)', + 0x85 => '', 'Linux extended', + ], + + backward_compatibility => [ + 0x183 => 'reiserfs', 'reiserfs (deprecated)', + 0x283 => 'xfs', 'xfs (deprecated)', + 0x383 => 'jfs', 'jfs (deprecated)', + 0x483 => 'ext3', 'ext3 (deprecated)', + ], + + other => [ + if_(arch() =~ /^ia64/, + 0x100 => '', 'Various', +), if_(arch() =~ /^ppc/, + 0x401 => 'apple', 'Apple Partition', +), if_(arch() =~ /^sparc/, + 0x01 => 'ufs', 'SunOS boot', + 0x02 => 'ufs', 'SunOS root', + 0x03 => 'ufs', 'SunOS swap', + 0x04 => 'ufs', 'SunOS usr', + 0x05 => 'ufs', 'Whole disk', + 0x06 => 'ufs', 'SunOS stand', + 0x07 => 'ufs', 'SunOS var', + 0x08 => 'ufs', 'SunOS home', +), if_(arch() =~ /^i.86/, + 0x01 => 'vfat', 'FAT12', + 0x02 => '', 'XENIX root', + 0x03 => '', 'XENIX usr', + 0x04 => 'vfat', 'FAT16 <32M', + 0x06 => 'vfat', 'FAT16', + 0x07 => (arch() =~ /^ppc/ ? 'hpfs' : 'ntfs'), 'NTFS (or HPFS)', + 0x08 => '', 'AIX', +), + 0x09 => '', 'AIX bootable', + 0x0a => '', 'OS/2 Boot Manager', + 0x0c => 'vfat', 'W95 FAT32 (LBA)', + 0x0e => 'vfat', 'W95 FAT16 (LBA)', + 0x10 => '', 'OPUS', + 0x11 => '', 'Hidden FAT12', + 0x12 => '', 'Compaq diagnostics', + 0x14 => '', 'Hidden FAT16 <32M', + 0x16 => '', 'Hidden FAT16', + 0x17 => 'ntfs', 'Hidden HPFS/NTFS', + 0x18 => '', 'AST SmartSleep', + 0x1b => 'vfat', 'Hidden W95 FAT32', + 0x1c => 'vfat', 'Hidden W95 FAT32 (LBA)', + 0x1e => 'vfat', 'Hidden W95 FAT16 (LBA)', + 0x24 => '', 'NEC DOS', + 0x39 => '', 'Plan 9', + 0x3c => '', 'PartitionMagic recovery', + 0x40 => '', 'Venix 80286', + 0x41 => '', 'PPC PReP Boot', + 0x42 => '', 'SFS', + 0x4d => '', 'QNX4.x', + 0x4e => '', 'QNX4.x 2nd part', + 0x4f => '', 'QNX4.x 3rd part', + 0x50 => '', 'OnTrack DM', + 0x51 => '', 'OnTrack DM6 Aux1', + 0x52 => '', 'CP/M', + 0x53 => '', 'OnTrack DM6 Aux3', + 0x54 => '', 'OnTrackDM6', + 0x55 => '', 'EZ-Drive', + 0x56 => '', 'Golden Bow', + 0x5c => '', 'Priam Edisk', + 0x61 => '', 'SpeedStor', + 0x63 => '', 'GNU HURD or SysV', + 0x64 => '', 'Novell Netware 286', + 0x65 => '', 'Novell Netware 386', + 0x70 => '', 'DiskSecure Multi-Boot', + 0x75 => '', 'PC/IX', + 0x80 => '', 'Old Minix', + 0x81 => '', 'Minix / old Linux', + 0x84 => '', 'OS/2 hidden C: drive', + 0x86 => '', 'NTFS volume set', + 0x87 => '', 'NTFS volume set ', + 0x93 => '', 'Amoeba', + 0x94 => '', 'Amoeba BBT', + 0x9f => '', 'BSD/OS', + 0xa0 => '', 'IBM Thinkpad hibernation', + 0xa5 => '', 'FreeBSD', + 0xa6 => '', 'OpenBSD', + 0xa7 => '', 'NeXTSTEP', + 0xa8 => '', 'Darwin UFS', + 0xa9 => '', 'NetBSD', + 0xab => '', 'Darwin boot', + 0xb7 => '', 'BSDI fs', + 0xb8 => '', 'BSDI swap', + 0xbb => '', 'Boot Wizard hidden', + 0xbe => '', 'Solaris boot', + 0xc1 => '', 'DRDOS/sec (FAT-12)', + 0xc4 => '', 'DRDOS/sec (FAT-16 < 32M)', + 0xc6 => '', 'DRDOS/sec (FAT-16)', + 0xc7 => '', 'Syrinx', + 0xda => '', 'Non-FS data', + 0xdb => '', 'CP/M / CTOS / ...', + 0xde => '', 'Dell Utility', + 0xdf => '', 'BootIt', + 0xe1 => '', 'SpeedStor (FAT-12)', + 0xe3 => '', 'DOS R/O', + 0xe4 => '', 'SpeedStor (FAT-16)', + 0xeb => 'befs', 'BeOS fs', + 0xee => '', 'EFI GPT', + 0xef => 'vfat', 'EFI (FAT-12/16/32)', + 0xf0 => '', 'Linux/PA-RISC boot', + 0xf4 => '', 'SpeedStor (large part.)', + 0xf2 => '', 'DOS secondary', + 0xfe => '', 'LANstep', + 0xff => '', 'BBT', + ], + ); + + foreach (group_by2(@list_types)) { + my ($name, $l) = @$_; + for (my $i = 0; defined $l->[$i]; $i += 3) { + my $pt_type = $l->[$i]; + my $fs_type = $l->[$i + 1]; + my $type_name = $l->[$i + 2]; + !exists $type_name2fs_type{$type_name} or internal_error("'$type_name' is not unique"); + $type_name2fs_type{$type_name} = $fs_type; + $type_name2pt_type{$type_name} = $pt_type; + + $fs_type2pt_type{$fs_type} ||= $pt_type; + $pt_type2fs_type{$pt_type} ||= $fs_type; + push @{$type_names{$name}}, $type_name; + } + } +} + + +sub type_names() { + my @l = @{$type_names{important}}; + push @l, @{$type_names{less_important}}, sort @{$type_names{other}} if $::expert; + @l; +} + +sub type_name2subpart { + my ($name) = @_; + exists $type_name2fs_type{$name} && + { fs_type => $type_name2fs_type{$name}, pt_type => $type_name2pt_type{$name} }; +} + +sub part2type_name { + my ($part) = @_; + my @names = keys %type_name2fs_type; + if (exists $part->{pt_type}) { + @names = grep { $part->{pt_type} eq $type_name2pt_type{$_} } @names; + } + if ($part->{fs_type}) { + @names = grep { $part->{fs_type} eq $type_name2fs_type{$_} } @names; + } + + if (@names > 1) { + log::l("ERROR: (part2type_name) multiple match for $part->{pt_type} $part->{fs_type}"); + } + first(@names); +} +sub type_name2pt_type { + local ($_) = @_; + /0x(.*)/ ? hex $1 : $type_name2pt_type{$_} || $_; +} + + +sub pt_type2subpart { + my ($pt_type) = @_; + my $fs_type = $pt_type2fs_type{$pt_type}; + { pt_type => $pt_type, if_($fs_type, fs_type => $fs_type) }; +} +sub fs_type2subpart { + my ($fs_type) = @_; + my $pt_type = $fs_type2pt_type{$fs_type}; + { fs_type => $fs_type, if_($pt_type, pt_type => $pt_type) }; +} +sub set_fs_type { + my ($part, $fs_type) = @_; + put_in_hash($part, fs_type2subpart($fs_type)); +} +sub set_pt_type { + my ($part, $pt_type) = @_; + put_in_hash($part, pt_type2subpart($pt_type)); +} +sub suggest_fs_type { + my ($part, $fs_type) = @_; + set_fs_type($part, $fs_type) if !$part->{pt_type} && !$part->{fs_type}; +} +sub set_type_subpart { + my ($part, $subpart) = @_; + if (exists $subpart->{pt_type} && exists $subpart->{fs_type}) { + $part->{fs_type} = $subpart->{fs_type}; + $part->{pt_type} = $subpart->{pt_type}; + } elsif (exists $subpart->{pt_type}) { + set_pt_type($part, $subpart->{pt_type}); + } elsif (exists $subpart->{fs_type}) { + set_pt_type($part, $subpart->{fs_type}); + } else { + log::l("ERROR: (set_type_subpart) subpart has no type"); + } +} + + +my @partitions_signatures = ( + [ 'Linux Logical Volume Manager', 0, "HM\1\0" ], + [ 'ext2', 0x438, "\x53\xEF" ], + [ 'reiserfs', 0x10034, "ReIsErFs" ], + [ 'reiserfs', 0x10034, "ReIsEr2Fs" ], + [ 'xfs', 0, 'XFSB', 0x200, 'XAGF', 0x400, 'XAGI' ], + [ 'jfs', 0x8000, 'JFS1' ], + [ 'swap', 4086, "SWAP-SPACE" ], + [ 'swap', 4086, "SWAPSPACE2" ], + [ 'ntfs', 0x1FE, "\x55\xAA", 0x3, "NTFS" ], + [ 'FAT32', 0x1FE, "\x55\xAA", 0x52, "FAT32" ], +if_(arch() !~ /^sparc/, + [ 'FAT16', 0x1FE, "\x55\xAA", 0x36, "FAT" ], +), +); + +sub fs_type_from_magic { + my ($part) = @_; + if (exists $part->{fs_type_from_magic}) { + $part->{fs_type_from_magic}; + } else { + my $type = type_subpart_from_magic($part); + $type && $type->{fs_type}; + } +} + +sub type_subpart_from_magic { + my ($part) = @_; + my $dev = devices::make($part->{device}); + my $t = typeFromMagic($dev, @partitions_signatures) or return; + + my $p = type_name2subpart($t) || fs_type2subpart($t) || internal_error("unknown name/fs $t"); + if ($p->{fs_type} eq 'ext2') { + #- there is no magic to differentiate ext3 and ext2. Using libext2fs + #- to check if it has a journal + $p->{fs_type} = 'ext3' if c::is_ext3($dev); + } + $part->{fs_type_from_magic} = $p->{fs_type}; + $p; +} + + +sub isEfi { arch() =~ /ia64/ && $_[0]{pt_type} == 0xef } +sub isWholedisk { arch() =~ /^sparc/ && $_[0]{pt_type} == 5 } +sub isExtended { arch() !~ /^sparc/ && ($_[0]{pt_type} == 5 || $_[0]{pt_type} == 0xf || $_[0]{pt_type} == 0x85) } +sub isRawLVM { $_[0]{pt_type} == 0x8e } +sub isRawRAID { $_[0]{pt_type} == 0xfd } +sub isSwap { $_[0]{fs_type} eq 'swap' } +sub isDos { arch() !~ /^sparc/ && ${{ 1 => 1, 4 => 1, 6 => 1 }}{$_[0]{pt_type}} } +sub isFat_or_NTFS { member($_[0]{fs_type}, 'vfat', 'ntfs') } +sub isSunOS { arch() =~ /sparc/ && ${{ 0x1 => 1, 0x2 => 1, 0x4 => 1, 0x6 => 1, 0x7 => 1, 0x8 => 1 }}{$_[0]{pt_type}} } +sub isApple { $_[0]{fs_type} eq 'apple' && defined $_[0]{isDriver} } +sub isAppleBootstrap { $_[0]{fs_type} eq 'apple' && defined $_[0]{isBoot} } +sub isHiddenMacPart { defined $_[0]{isMap} } + +sub isTrueFS { isTrueLocalFS($_[0]) || member($_[0]{fs_type}, qw(nfs)) } +sub isTrueLocalFS { member($_[0]{fs_type}, qw(ext2 reiserfs xfs jfs ext3)) } + +sub isOtherAvailableFS { isEfi($_[0]) || isFat_or_NTFS($_[0]) || isSunOS($_[0]) || $_[0]{fs_type} eq 'hfs' } #- other OS that linux can access its filesystem +sub isMountableRW { (isTrueFS($_[0]) || isOtherAvailableFS($_[0])) && $_[0]{fs_type} ne 'ntfs' } +sub isNonMountable { + my ($part) = @_; + isRawRAID($part) || isRawLVM($part) || $part->{fs_type} eq 'ntfs' && !$part->{isFormatted} && $part->{notFormatted}; +} + +sub isPartOfLVM { defined $_[0]{lvm} } +sub isPartOfRAID { defined $_[0]{raid} } +sub isPartOfLoopback { defined $_[0]{loopback} } +sub isRAID { $_[0]{device} =~ /^md/ } +sub isUBD { $_[0]{device} =~ /^ubd/ } #- should be always true during an $::uml_install +sub isLVM { $_[0]{VG_name} } +sub isLoopback { defined $_[0]{loopback_file} } +sub isMounted { $_[0]{isMounted} } +sub isBusy { isMounted($_[0]) || isPartOfRAID($_[0]) || isPartOfLVM($_[0]) || isPartOfLoopback($_[0]) } +sub isSpecial { isRAID($_[0]) || isLVM($_[0]) || isLoopback($_[0]) || isUBD($_[0]) } + +sub maybeFormatted { + my ($part) = @_; + $part->{isFormatted} || !$part->{notFormatted} && !$part->{bad_fs_type_magic}; +} +sub set_isFormatted { + my ($part, $val) = @_; + $part->{isFormatted} = $val; + $part->{notFormatted} = !$val; + delete $part->{bad_fs_type_magic}; + delete $part->{fs_type_from_magic}; +} diff --git a/perl-install/fsedit.pm b/perl-install/fsedit.pm index 0c5d8fe4b..c3bb56d6f 100644 --- a/perl-install/fsedit.pm +++ b/perl-install/fsedit.pm @@ -8,8 +8,9 @@ use vars qw(%suggestions); #- misc imports #-###################################################################################### use common; -use partition_table qw(:types); +use partition_table; use partition_table::raw; +use fs::type; use detect_devices; use fsedit; use devices; @@ -19,21 +20,21 @@ use fs; %suggestions = ( N_("simple") => [ - { mntpoint => "/", size => 300 << 11, pt_type =>0x483, ratio => 5, maxsize => 6000 << 11 }, - { mntpoint => "swap", size => 64 << 11, pt_type => 0x82, ratio => 1, maxsize => 500 << 11 }, - { mntpoint => "/home", size => 300 << 11, pt_type =>0x483, ratio => 3 }, + { mntpoint => "/", size => 300 << 11, fs_type => 'ext3', ratio => 5, maxsize => 6000 << 11 }, + { mntpoint => "swap", size => 64 << 11, fs_type => 'swap', ratio => 1, maxsize => 500 << 11 }, + { mntpoint => "/home", size => 300 << 11, fs_type => 'ext3', ratio => 3 }, ], N_("with /usr") => [ - { mntpoint => "/", size => 250 << 11, pt_type =>0x483, ratio => 1, maxsize => 2000 << 11 }, - { mntpoint => "swap", size => 64 << 11, pt_type => 0x82, ratio => 1, maxsize => 500 << 11 }, - { mntpoint => "/usr", size => 300 << 11, pt_type =>0x483, ratio => 4, maxsize => 4000 << 11 }, - { mntpoint => "/home", size => 100 << 11, pt_type =>0x483, ratio => 3 }, + { mntpoint => "/", size => 250 << 11, fs_type => 'ext3', ratio => 1, maxsize => 2000 << 11 }, + { mntpoint => "swap", size => 64 << 11, fs_type => 'swap', ratio => 1, maxsize => 500 << 11 }, + { mntpoint => "/usr", size => 300 << 11, fs_type => 'ext3', ratio => 4, maxsize => 4000 << 11 }, + { mntpoint => "/home", size => 100 << 11, fs_type => 'ext3', ratio => 3 }, ], N_("server") => [ - { mntpoint => "/", size => 150 << 11, pt_type =>0x483, ratio => 1, maxsize => 800 << 11 }, - { mntpoint => "swap", size => 64 << 11, pt_type => 0x82, ratio => 2, maxsize => 800 << 11 }, - { mntpoint => "/usr", size => 300 << 11, pt_type =>0x483, ratio => 4, maxsize => 4000 << 11 }, - { mntpoint => "/var", size => 200 << 11, pt_type =>0x483, ratio => 3 }, - { mntpoint => "/home", size => 150 << 11, pt_type =>0x483, ratio => 3 }, - { mntpoint => "/tmp", size => 150 << 11, pt_type =>0x483, ratio => 2, maxsize => 1000 << 11 }, + { mntpoint => "/", size => 150 << 11, fs_type => 'ext3', ratio => 1, maxsize => 800 << 11 }, + { mntpoint => "swap", size => 64 << 11, fs_type => 'swap', ratio => 2, maxsize => 800 << 11 }, + { mntpoint => "/usr", size => 300 << 11, fs_type => 'ext3', ratio => 4, maxsize => 4000 << 11 }, + { mntpoint => "/var", size => 200 << 11, fs_type => 'ext3', ratio => 3 }, + { mntpoint => "/home", size => 150 << 11, fs_type => 'ext3', ratio => 3 }, + { mntpoint => "/tmp", size => 150 << 11, fs_type => 'ext3', ratio => 2, maxsize => 1000 << 11 }, ], ); foreach (values %suggestions) { @@ -48,33 +49,6 @@ my @suggestions_mntpoints = ( #- RedHat also has /usr/local and /opt ); -my @partitions_signatures = ( - [ 0x8e, 0, "HM\1\0" ], - [ 0x83, 0x438, "\x53\xEF" ], - [ 0x183, 0x10034, "ReIsErFs" ], - [ 0x183, 0x10034, "ReIsEr2Fs" ], - [ 0x283, 0, 'XFSB', 0x200, 'XAGF', 0x400, 'XAGI' ], - [ 0x383, 0x8000, 'JFS1' ], - [ 0x82, 4086, "SWAP-SPACE" ], - [ 0x82, 4086, "SWAPSPACE2" ], - [ 0x107, 0x1FE, "\x55\xAA", 0x3, "NTFS" ], - [ 0xc, 0x1FE, "\x55\xAA", 0x52, "FAT32" ], -if_(arch() !~ /^sparc/, - [ 0x6, 0x1FE, "\x55\xAA", 0x36, "FAT" ], -), -); - -sub typeOfPart { - my $dev = devices::make($_[0]); - my $t = typeFromMagic($dev, @partitions_signatures); - if ($t == 0x83) { - #- there is no magic to differentiate ext3 and ext2. Using libext2fs - #- to check if it has a journal - $t = 0x483 if c::is_ext3($dev); - } - $t; -} - #-###################################################################################### #- Functions #-###################################################################################### @@ -113,10 +87,10 @@ sub raids { my @raw_mdparts = map { /([^\[]+)/ } split ' ', $mdparts; - my $pt_type = typeOfPart("md$nb"); - log::l("RAID: found md$nb (raid $level) chunks $chunks ", if_($pt_type, "type $pt_type "), "with parts ", join(", ", @raw_mdparts)); - $raids[$nb] = { 'chunk-size' => $chunks, pt_type => $pt_type || 0x83, raw_mdparts => \@raw_mdparts, - device => "md$nb", notFormatted => !$pt_type, level => $level }; + my $fs_type = fs::type::fs_type_from_magic({ device => "md$nb" }); + log::l("RAID: found md$nb (raid $level) chunks $chunks ", if_($fs_type, "type $fs_type "), "with parts ", join(", ", @raw_mdparts)); + $raids[$nb] = { 'chunk-size' => $chunks, fs_type => $fs_type || 'ext2', raw_mdparts => \@raw_mdparts, + device => "md$nb", notFormatted => !$fs_type, level => $level }; } my %devname2part = map { $_->{dev} => { %$_, device => $_->{dev} } } devices::read_proc_partitions_raw(); @@ -127,7 +101,7 @@ sub raids { my $mdpart = $devname2part{$_} || { device => $_ }; if (my $part = find { is_same_hd($mdpart, $_) } @parts, @raids) { $part->{raid} = $::i; - $part->{pt_type} = 0xfd; + fs::type::set_pt_type($part, 0xfd); delete $part->{mntpoint}; $part; } else { @@ -205,8 +179,9 @@ sub hds { if ($hd->{readonly}) { log::l("using /proc/partitions since diskdrake failed :("); use_proc_partitions($hd); - } elsif (exists $hd->{usb_description} && ($hd->{pt_type} ||= typeOfPart($hd->{device}))) { + } elsif (exists $hd->{usb_description} && fs::type::fs_type_from_magic($hd)) { #- non partitioned drive + $hd->{fs_type} = fs::type::fs_type_from_magic($hd); push @raw_hds, $hd; next; } elsif ($o_ask_before_blanking && $o_ask_before_blanking->($hd->{device}, $err)) { @@ -223,19 +198,18 @@ sub hds { my @parts = partition_table::get_normal_parts($hd); - # special case for Various type - $_->{pt_type} = typeOfPart($_->{device}) || 0x100 foreach grep { $_->{pt_type} == 0x100 } @parts; - - #- special case for type overloading (eg: reiserfs is 0x183) - foreach (grep { isExt2($_) || $_->{pt_type} == 0x7 || $_->{pt_type} == 0x17 } @parts) { - my $wanted_pt_type = $_->{pt_type} == 0x17 ? 0x7 : $_->{pt_type}; - my $pt_type = typeOfPart($_->{device}); - $_->{pt_type} = $pt_type if ($pt_type & 0xff) == $wanted_pt_type || $pt_type && $hd->isa('partition_table::gpt'); + # checking the magic of the filesystem, don't rely on pt_type + foreach (grep { member($_->{fs_type}, 'vfat', 'ntfs', 'ext2') || $_->{pt_type} == 0x100 } @parts) { + if (my $fs_type = fs::type::fs_type_from_magic($_)) { + $_->{fs_type} = $fs_type; + } else { + $_->{bad_fs_type_magic} = 1; + } } foreach (@parts) { my $label = - member(type2fs($_), qw(ext2 ext3)) ? + member($_->{fs_type}, qw(ext2 ext3)) ? c::get_ext2_label(devices::make($_->{device})) : ''; $_->{device_LABEL} = $label if $label; @@ -310,8 +284,8 @@ sub read_proc_partitions { $part->{device} = $dev; $part->{size} *= 2; # from KB to sectors - $part->{pt_type} = typeOfPart($dev); $part->{start} = $prev_part ? $prev_part->{start} + $prev_part->{size} : 0; + put_in_hash($part, fs::type::type_subpart_from_magic($part)); $prev_part = $part; delete $part->{dev}; # cleanup } @@ -345,7 +319,7 @@ sub is_same_hd { #- are_same_partitions() do not look at the device name since things may have changed sub are_same_partitions { my ($part1, $part2) = @_; - foreach ('start', 'size', 'pt_type', 'rootDevice') { + foreach ('start', 'size', 'pt_type', 'fs_type', 'rootDevice') { $part1->{$_} eq $part2->{$_} or return; } 1; @@ -358,7 +332,7 @@ sub get_fstab { #- get normal partition that should be visible for working on. sub get_visible_fstab { - grep { $_ && !partition_table::isWholedisk($_) && !partition_table::isHiddenMacPart($_) } + grep { $_ && !isWholedisk($_) && !isHiddenMacPart($_) } map { partition_table::get_normal_parts($_) } @_; } @@ -482,6 +456,11 @@ sub suggest_part { my ($part, $all_hds, $o_suggestions) = @_; my $suggestions = $o_suggestions || $suggestions{server} || $suggestions{simple}; + #- suggestions now use {fs_type}, but still keep compatibility + foreach (@$suggestions) { + fs::type::set_pt_type($_, $_->{pt_type}) if !exists $_->{fs_type}; + } + my $has_swap = any { isSwap($_) } get_all_fstab($all_hds); my @local_suggestions = @@ -492,13 +471,13 @@ sub suggest_part { my ($best) = grep { !$_->{maxsize} || $part->{size} <= $_->{maxsize} } grep { $_->{size} <= ($part->{maxsize} || $part->{size}) } - grep { !$part->{pt_type} || $part->{pt_type} == $_->{pt_type} || isTrueFS($part) && isTrueFS($_) } + grep { !$part->{fs_type} || $part->{fs_type} eq $_->{fs_type} || isTrueFS($part) && isTrueFS($_) } @local_suggestions; defined $best or return; #- sorry no suggestion :( $part->{mntpoint} = $best->{mntpoint}; - $part->{pt_type} = $best->{pt_type} if !(isTrueFS($best) && isTrueFS($part)); + fs::type::set_type_subpart($part, $best) if !isTrueFS($best) || !isTrueFS($part); $part->{size} = computeSize($part, $best, $all_hds, \@local_suggestions); foreach ('options', 'lv_name', 'encrypt_key') { $part->{$_} = $best->{$_} if $best->{$_}; @@ -526,11 +505,11 @@ sub get_root_ { } sub get_root { &get_root_ || {} } -#- do this before modifying $part->{pt_type} -sub check_pt_type { - my ($pt_type, $_hd, $part) = @_; - isThisFs("jfs", { pt_type => $pt_type }) && $part->{size} < 16 << 11 and die N("You can't use JFS for partitions smaller than 16MB"); - isThisFs("reiserfs", { pt_type => $pt_type }) && $part->{size} < 32 << 11 and die N("You can't use ReiserFS for partitions smaller than 32MB"); +#- do this before modifying $part->{fs_type} +sub check_fs_type { + my ($fs_type, $_hd, $part) = @_; + $fs_type eq "jfs" && $part->{size} < 16 << 11 and die N("You can't use JFS for partitions smaller than 16MB"); + $fs_type eq "reiserfs" && $part->{size} < 32 << 11 and die N("You can't use ReiserFS for partitions smaller than 32MB"); } sub package_needed_for_partition_type { @@ -540,7 +519,7 @@ sub package_needed_for_partition_type { xfs => 'xfsprogs', jfs => 'jfsprogs', ); - $l{type2fs($part)}; + $l{$part->{fs_type}}; } #- you can do this before modifying $part->{mntpoint} @@ -655,7 +634,7 @@ sub auto_allocate_raids { my %h = %$md; delete @h{'hd', 'parts'}; - put_in_hash($part, \%h); # mntpoint, level, chunk-size, pt_type + put_in_hash($part, \%h); # mntpoint, level, chunk-size, fs_type raid::updateSize($part); } } @@ -769,16 +748,15 @@ sub move { } } -sub change_pt_type { - my ($pt_type, $hd, $part) = @_; - $pt_type != $part->{pt_type} or return; - check_pt_type($pt_type, $hd, $part); +sub change_type { + my ($type, $hd, $part) = @_; + $type->{pt_type} != $part->{pt_type} || $type->{fs_type} ne $part->{fs_type} or return; + check_fs_type($type->{fs_type}, $hd, $part); $hd->{isDirty} = 1; $part->{mntpoint} = '' if isSwap($part) && $part->{mntpoint} eq "swap"; - $part->{mntpoint} = '' if isRawLVM({ pt_type => $pt_type }) || isRawRAID({ pt_type => $pt_type }); - $part->{pt_type} = $pt_type; - $part->{notFormatted} = 1; - $part->{isFormatted} = 0; + $part->{mntpoint} = '' if isRawLVM($type) || isRawRAID($type); + set_isFormatted($part, 0); + fs::type::set_type_subpart($part, $type); fs::rationalize_options($part); 1; } @@ -792,7 +770,8 @@ sub rescuept($) { local $_; while (<$F>) { my ($st, $si, $id) = /start=\s*(\d+),\s*size=\s*(\d+),\s*Id=\s*(\d+)/ or next; - my $part = { start => $st, size => $si, pt_type => hex($id) }; + my $part = { start => $st, size => $si }; + fs::type::set_pt_type($part, hex($id)); if (isExtended($part)) { $ext = $part; } else { diff --git a/perl-install/install2.pm b/perl-install/install2.pm index 8d785cae7..0ffa83454 100644 --- a/perl-install/install2.pm +++ b/perl-install/install2.pm @@ -17,7 +17,7 @@ use keyboard; use mouse; use fsedit; use devices; -use partition_table qw(:types); +use partition_table; use modules; use detect_devices; use run_program; diff --git a/perl-install/install_any.pm b/perl-install/install_any.pm index 66511f2e1..fdfe55111 100644 --- a/perl-install/install_any.pm +++ b/perl-install/install_any.pm @@ -16,8 +16,8 @@ use vars qw(@ISA %EXPORT_TAGS @EXPORT_OK $boot_medium $current_medium $asked_med use MDK::Common::System; use common; use run_program; -use partition_table qw(:types); -use partition_table::raw; +use fs::type; +use partition_table; use devices; use fsedit; use modules; @@ -801,7 +801,7 @@ sub g_auto_install { require pkgs; $o->{default_packages} = pkgs::selected_leaves($::o->{packages}); - my @fields = qw(mntpoint pt_type size); + my @fields = qw(mntpoint fs_type size); $o->{partitions} = [ map { my %l; @l{@fields} = @$_{@fields}; \%l } grep { $_->{mntpoint} } @{$::o->{fstab}} ]; exists $::o->{$_} and $o->{$_} = $::o->{$_} foreach qw(locale authentication mouse netc timezone superuser intf keyboard users partitioning isUpgrade manualFstab nomouseprobe crypto security security_user libsafe netcnx useSupermount autoExitInstall X services); #- TODO modules bootloader @@ -988,7 +988,9 @@ sub loadO { #- handle backward compatibility for things that changed foreach (@{$o->{partitions} || []}, @{$o->{manualFstab} || []}) { - $_->{pt_type} ||= $_->{type}; + if (my $pt_type = delete $_->{type}) { + fs::type::set_pt_type($_, $pt_type); + } } $o; @@ -1118,7 +1120,7 @@ sub getHds { $o->{fstab} = [ fsedit::get_really_all_fstab($all_hds) ]; fs::merge_info_from_mtab($o->{fstab}); - my @win = grep { isFat_or_NTFS($_) && isFat_or_NTFS({ pt_type => fsedit::typeOfPart($_->{device}) }) } @{$o->{fstab}}; + my @win = grep { isFat_or_NTFS($_) && maybeFormatted($_) } @{$o->{fstab}}; log::l("win parts: ", join ",", map { $_->{device} } @win) if @win; if (@win == 1) { #- Suggest /boot/efi on ia64. @@ -1130,7 +1132,7 @@ sub getHds { } } - my @sunos = grep { isSunOS($_) && part2name($_) =~ /root/i } @{$o->{fstab}}; #- take only into account root partitions. + my @sunos = grep { $_->{pt_type} == 2 } @{$o->{fstab}}; #- take only into account root partitions. if (@sunos) { my $v = ''; map { $_->{mntpoint} = $_->{unsafeMntpoint} = "/mnt/sunos" . ($v && ++$v) } @sunos; diff --git a/perl-install/install_interactive.pm b/perl-install/install_interactive.pm index e86c10bb6..79d768736 100644 --- a/perl-install/install_interactive.pm +++ b/perl-install/install_interactive.pm @@ -4,8 +4,9 @@ use diagnostics; use strict; use common; -use partition_table qw(:types); +use partition_table; use partition_table::raw; +use fs::type; use detect_devices; use install_steps; use install_any; @@ -107,7 +108,7 @@ sub partitionWizardSolutions { push @wizlog, N("There is no existing partition to use"); } - my @fats = grep { isFat($_) } @$fstab; + my @fats = grep { $_->{fs_type} eq 'vfat' } @$fstab; fs::df($_) foreach @fats; if (my @ok_forloopback = sort { $b->{free} <=> $a->{free} } grep { $_->{free} > $min_linux + $min_swap + $min_freewin } @fats) { $solutions{loopback} = @@ -121,8 +122,8 @@ sub partitionWizardSolutions { { label => N("Swap partition size in MB: "), val => \$s_swap, min => $min_swap >> 11, max => $max_swap >> 11, type => 'range' }, ]) or return; push @{$part->{loopback}}, - { pt_type =>0x483, loopback_file => '/lnx4win/linuxsys.img', mntpoint => '/', size => $s_root << 11, loopback_device => $part, notFormatted => 1 }, - { pt_type => 0x82, loopback_file => '/lnx4win/swapfile', mntpoint => 'swap', size => $s_swap << 11, loopback_device => $part, notFormatted => 1 }; + { fs_type => 'ext3', loopback_file => '/lnx4win/linuxsys.img', mntpoint => '/', size => $s_root << 11, loopback_device => $part, notFormatted => 1 }, + { fs_type => 'swap', loopback_file => '/lnx4win/swapfile', mntpoint => 'swap', size => $s_swap << 11, loopback_device => $part, notFormatted => 1 }; fsedit::recompute_loopbacks($all_hds); 1; } ]; @@ -141,7 +142,7 @@ sub partitionWizardSolutions { }, \&partition_table::description, \@ok_for_resize_fat) or return; my $hd = fsedit::part2hd($part, $all_hds); my $resize_fat = eval { - my $pkg = isFat($part) ? do { + my $pkg = $part->{fs_type} eq 'vfat' ? do { require resize_fat::main; 'resize_fat::main'; } : do { @@ -192,9 +193,9 @@ When sure, press Ok."))) or return; } $o->ask_warn('', N("To ensure data integrity after resizing the partition(s), -filesystem checks will be run on your next boot into Windows(TM)")) if !isFat($part); +filesystem checks will be run on your next boot into Windows(TM)")) if $part->{fs_type} ne 'vfat'; - $part->{isFormatted} = 1; + set_isFormatted($part, 1); partition_table::will_tell_kernel($hd, resize => $part); #- down-sizing, write_partitions is not needed partition_table::adjust_local_extended($hd, $part); partition_table::adjust_main_extended($hd); diff --git a/perl-install/install_steps.pm b/perl-install/install_steps.pm index 645f3fe0d..6cef62347 100644 --- a/perl-install/install_steps.pm +++ b/perl-install/install_steps.pm @@ -9,8 +9,9 @@ use vars qw(@filesToSaveForUpgrade @filesNewerToUseAfterUpgrade); #-###################################################################################### use common; use install_any qw(:all); -use partition_table qw(:types); +use partition_table; use detect_devices; +use fs::type; use modules; use run_program; use lang; @@ -215,7 +216,7 @@ sub doPartitionDisksAfter { cat_("/proc/mounts") =~ m|(\S+)\s+/tmp/nfsimage| && !any { $_->{mntpoint} eq "/mnt/nfs" } @{$o->{all_hds}{nfss}} and - push @{$o->{all_hds}{nfss}}, { pt_type => 'nfs', mntpoint => "/mnt/nfs", device => $1, options => "noauto,ro,nosuid,soft,rsize=8192,wsize=8192" }; + push @{$o->{all_hds}{nfss}}, { fs_type => 'nfs', mntpoint => "/mnt/nfs", device => $1, options => "noauto,ro,nosuid,soft,rsize=8192,wsize=8192" }; } #------------------------------------------------------------------------------ @@ -243,7 +244,7 @@ sub ask_mntpoint_s {#-}}} $m{$m} = 1; #- in case the type does not correspond, force it to ext3 - $_->{pt_type} = 0x483 if $m =~ m|^/| && !isTrueFS($_) && !isOtherAvailableFS($_); + fs::type::set_fs_type($_, 'ext3') if $m =~ m|^/| && !isTrueFS($_) && !isOtherAvailableFS($_); } 1; } @@ -266,10 +267,8 @@ sub choosePartitionsToFormat($$) { $_->{$::recovery ? 'toFormat' : 'toFormatUnsure'} ||= member($_->{mntpoint}, '/', '/usr'); if (!$_->{toFormat}) { - my $t = fsedit::typeOfPart($_->{device}); - $_->{toFormatUnsure} ||= - #- if detected dos/win, it's not precise enough to just compare the types (too many of them) - (!$t || isOtherAvailableFS({ pt_type => $t }) ? !isOtherAvailableFS($_) : $t != $_->{pt_type}); + my $fs_type = fs::type::fs_type_from_magic($_); + $_->{toFormatUnsure} ||= !$fs_type || $fs_type ne $_->{fs_type}; } } } diff --git a/perl-install/install_steps_interactive.pm b/perl-install/install_steps_interactive.pm index 8be4fa5fe..6f0e0f68e 100644 --- a/perl-install/install_steps_interactive.pm +++ b/perl-install/install_steps_interactive.pm @@ -12,8 +12,8 @@ use vars qw(@ISA $new_bootstrap); #- misc imports #-###################################################################################### use common; -use partition_table qw(:types); -use partition_table::raw; +use partition_table; +use fs::type; use install_steps; use install_interactive; use install_any; @@ -286,7 +286,9 @@ sub doPartitionDisks { log::l("creating bootstrap partition on drive /dev/$freepart->{hd}{device}, block $freepart->{start}"); $partition_table::mac::bootstrap_part = $freepart->{part}; log::l("bootstrap now at $partition_table::mac::bootstrap_part"); - fsedit::add($freepart->{hd}, { start => $freepart->{start}, size => 1 << 11, pt_type => 0x401, mntpoint => '' }, $o->{all_hds}, { force => 1, primaryOrExtended => 'Primary' }); + my $p = { start => $freepart->{start}, size => 1 << 11, mntpoint => '' }; + fs::type::set_pt_type($p, 0x401); + fsedit::add($freepart->{hd}, $p, $o->{all_hds}, { force => 1, primaryOrExtended => 'Primary' }); $new_bootstrap = 1; } else { $o->ask_warn('', N("No free space for 1MB bootstrap! Install will continue, but to boot your system, you'll need to create the bootstrap partition in DiskDrake")); @@ -335,7 +337,7 @@ sub choosePartitionsToFormat { ({ text => partition_table::description($e), type => 'bool', val => \$e->{toFormatTmp} - }, if_(!isLoopback($_) && !isThisFs("reiserfs", $_) && !isThisFs("xfs", $_) && !isThisFs("jfs", $_), { + }, if_(!isLoopback($_) && !member($_->{fs_type}, 'reiserfs', 'xfs', 'jfs'), { text => partition_table::description($e), type => 'bool', advanced => 1, disabled => sub { !$e->{toFormatTmp} }, val => \$e->{toFormatCheck} @@ -344,7 +346,7 @@ sub choosePartitionsToFormat { #- ok now we can really set toFormat foreach (@l) { $_->{toFormat} = delete $_->{toFormatTmp}; - $_->{isFormatted} = 0; + set_isFormatted($_, 0); } } @@ -1251,7 +1253,7 @@ sub miscellaneous { require security::level; security::level::level_choose($o, \$o->{security}, \$o->{libsafe}, \$o->{security_user}); - if ($o->{security} > 2 && find { isFat($_) } @{$o->{fstab}}) { + if ($o->{security} > 2 && find { $_->{fs_type} eq 'vfat' } @{$o->{fstab}}) { $o->ask_okcancel('', N("In this security level, access to the files in the Windows partition is restricted to the administrator.")) or goto &miscellaneous; } diff --git a/perl-install/loopback.pm b/perl-install/loopback.pm index 64dbe079e..bdb580a8b 100644 --- a/perl-install/loopback.pm +++ b/perl-install/loopback.pm @@ -8,7 +8,7 @@ use strict; #-###################################################################################### use MDK::Common::System; use common; -use partition_table qw(:types); +use fs::type; use fs; use fsedit; use log; diff --git a/perl-install/lvm.pm b/perl-install/lvm.pm index 2d2a6d0e7..e63daa1ff 100644 --- a/perl-install/lvm.pm +++ b/perl-install/lvm.pm @@ -10,6 +10,7 @@ use common; use modules; use fsedit; use devices; +use fs::type; use run_program; #- for partition_table_xxx emulation @@ -92,10 +93,10 @@ sub get_lvs { [ map { my $device = "$lvm->{VG_name}/$_"; - my $pt_type = -e "/dev/$device" && fsedit::typeOfPart($device); + my $fs_type = -e "/dev/$device" && fs::type::fs_type_from_magic({ device => $device }); { device => $device, - pt_type => $pt_type || 0x83, + fs_type => $fs_type || 'ext2', size => get_lv_size($device) } } @l ]; @@ -117,8 +118,7 @@ sub vg_destroy { lvm_cmd_or_die('vgremove', $lvm->{VG_name}); foreach (@{$lvm->{disks}}) { delete $_->{lvm}; - $_->{isFormatted} = 0; - $_->{notFormatted} = 1; + set_isFormatted($_, 0); } } @@ -138,8 +138,7 @@ sub lv_create { $lv->{device} = "$lvm->{VG_name}/$lv->{lv_name}"; lvm_cmd_or_die('lvcreate', '--size', int($lv->{size} / 2) . 'k', '-n', $lv->{lv_name}, $lvm->{VG_name}); $lv->{size} = get_lv_size($lv->{device}); #- the created size is smaller than asked size - $lv->{notFormatted} = 1; - $lv->{isFormatted} = 0; + set_isFormatted($lv, 0); push @$list, $lv; } diff --git a/perl-install/network/smbnfs.pm b/perl-install/network/smbnfs.pm index d9b53aedb..9e587a10f 100644 --- a/perl-install/network/smbnfs.pm +++ b/perl-install/network/smbnfs.pm @@ -35,8 +35,8 @@ sub to_fullstring { $class->to_dev($e) . ($comment ? " ($comment)" : ''); } sub to_fstab_entry_raw { - my ($class, $e, $pt_type) = @_; - my $fs_entry = { device => $class->to_dev($e), pt_type => $pt_type }; + my ($class, $e, $fs_type) = @_; + my $fs_entry = { device => $class->to_dev($e), fs_type => $fs_type }; fs::set_default_options($fs_entry); $fs_entry; } diff --git a/perl-install/partition_table.pm b/perl-install/partition_table.pm index 812ed4826..e9bdfb4fc 100644 --- a/perl-install/partition_table.pm +++ b/perl-install/partition_table.pm @@ -2,272 +2,15 @@ package partition_table; # $Id$ use diagnostics; use strict; -use vars qw(@ISA %EXPORT_TAGS @EXPORT_OK @important_types @important_types2 @fields2save @bad_types); - -@ISA = qw(Exporter); -%EXPORT_TAGS = ( - types => [ qw(part2name type2fs name2pt_type fs2pt_type isExtended isExt2 isThisFs isTrueLocalFS isTrueFS isSwap isDos isWin isFat isFat_or_NTFS isSunOS isOtherAvailableFS isPrimary isRawLVM isRawRAID isRAID isLVM isMountableRW isNonMountable isPartOfLVM isPartOfRAID isPartOfLoopback isLoopback isMounted isBusy isSpecial maybeFormatted isApple isAppleBootstrap isEfi) ], -); -@EXPORT_OK = map { @$_ } values %EXPORT_TAGS; - use common; +use fs::type; use partition_table::raw; use detect_devices; +use fs::type; use log; -@important_types = ('Linux native', 'Linux swap', 'Journalised FS: ext3', 'Journalised FS: ReiserFS', - if_(arch() =~ /ppc/, 'Journalised FS: JFS', 'Journalised FS: XFS', 'Apple HFS Partition', 'Apple Bootstrap'), - if_(arch() =~ /i.86/, 'Journalised FS: JFS', 'Journalised FS: XFS', 'FAT32'), - if_(arch() =~ /ia64/, 'Journalised FS: XFS', 'FAT32'), - if_(arch() =~ /x86_64/, 'FAT32'), - ); -@important_types2 = ('Linux RAID', 'Linux Logical Volume Manager'); - -@fields2save = qw(primary extended totalsectors isDirty will_tell_kernel); - -@bad_types = ('Empty', 'Extended', 'W95 Extended (LBA)', 'Linux extended'); - -my %pt_type2name = ( - 0x0 => 'Empty', -if_(arch() =~ /^ppc/, - 0x183 => 'Journalised FS: ReiserFS', - 0x283 => 'Journalised FS: XFS', - 0x383 => 'Journalised FS: JFS', - 0x483 => 'Journalised FS: ext3', - 0x401 => 'Apple Partition', - 0x401 => 'Apple Bootstrap', - 0x402 => 'Apple HFS Partition', -), if_(arch() =~ /^i.86/, - 0x107 => 'NTFS', - 0x183 => 'Journalised FS: ReiserFS', - 0x283 => 'Journalised FS: XFS', - 0x383 => 'Journalised FS: JFS', - 0x483 => 'Journalised FS: ext3', -), if_(arch() =~ /^ia64/, - 0x100 => 'Various', - 0x183 => 'Journalised FS: ReiserFS', - 0x283 => 'Journalised FS: XFS', - 0x483 => 'Journalised FS: ext3', -), if_(arch() =~ /^x86_64/, - 0x183 => 'Journalised FS: ReiserFS', - 0x483 => 'Journalised FS: ext3', -), if_(arch() =~ /^sparc/, - 0x01 => 'SunOS boot', - 0x02 => 'SunOS root', - 0x03 => 'SunOS swap', - 0x04 => 'SunOS usr', - 0x05 => 'Whole disk', - 0x06 => 'SunOS stand', - 0x07 => 'SunOS var', - 0x08 => 'SunOS home', -), if_(arch() =~ /^i.86/, - 0x01 => 'FAT12', - 0x02 => 'XENIX root', - 0x03 => 'XENIX usr', - 0x04 => 'FAT16 <32M', - 0x05 => 'Extended', - 0x06 => 'FAT16', - 0x07 => 'NTFS (or HPFS)', - 0x08 => 'AIX', -), - 0x09 => 'AIX bootable', - 0x0a => 'OS/2 Boot Manager', - 0x0b => 'FAT32', - 0x0c => 'W95 FAT32 (LBA)', - 0x0e => 'W95 FAT16 (LBA)', - 0x0f => 'W95 Extended (LBA)', - 0x10 => 'OPUS', - 0x11 => 'Hidden FAT12', - 0x12 => 'Compaq diagnostics', - 0x14 => 'Hidden FAT16 <32M', - 0x16 => 'Hidden FAT16', - 0x17 => 'Hidden HPFS/NTFS', - 0x18 => 'AST SmartSleep', - 0x1b => 'Hidden W95 FAT32', - - 0x1c => 'Hidden W95 FAT32 (LBA)', - 0x1e => 'Hidden W95 FAT16 (LBA)', - 0x24 => 'NEC DOS', - 0x39 => 'Plan 9', - 0x3c => 'PartitionMagic recovery', - 0x40 => 'Venix 80286', - 0x41 => 'PPC PReP Boot', - 0x42 => 'SFS', - 0x4d => 'QNX4.x', - 0x4e => 'QNX4.x 2nd part', - 0x4f => 'QNX4.x 3rd part', - - 0x50 => 'OnTrack DM', - 0x51 => 'OnTrack DM6 Aux1', - 0x52 => 'CP/M', - 0x53 => 'OnTrack DM6 Aux3', - 0x54 => 'OnTrackDM6', - 0x55 => 'EZ-Drive', - 0x56 => 'Golden Bow', - 0x5c => 'Priam Edisk', - 0x61 => 'SpeedStor', - 0x63 => 'GNU HURD or SysV', - 0x64 => 'Novell Netware 286', - 0x65 => 'Novell Netware 386', - 0x70 => 'DiskSecure Multi-Boot', - 0x75 => 'PC/IX', - 0x80 => 'Old Minix', - 0x81 => 'Minix / old Linux', - - - 0x82 => 'Linux swap', - 0x83 => 'Linux native', - - 0x84 => 'OS/2 hidden C: drive', - 0x85 => 'Linux extended', - 0x86 => 'NTFS volume set', - 0x87 => 'NTFS volume set', - 0x8e => 'Linux Logical Volume Manager', - 0x93 => 'Amoeba', - 0x94 => 'Amoeba BBT', - 0x9f => 'BSD/OS', - 0xa0 => 'IBM Thinkpad hibernation', - 0xa5 => 'FreeBSD', - 0xa6 => 'OpenBSD', - 0xa7 => 'NeXTSTEP', - 0xa8 => 'Darwin UFS', - 0xa9 => 'NetBSD', - 0xab => 'Darwin boot', - 0xb7 => 'BSDI fs', - 0xb8 => 'BSDI swap', - 0xbb => 'Boot Wizard hidden', - 0xbe => 'Solaris boot', - 0xc1 => 'DRDOS/sec (FAT-12)', - 0xc4 => 'DRDOS/sec (FAT-16 < 32M)', - 0xc6 => 'DRDOS/sec (FAT-16)', - 0xc7 => 'Syrinx', - 0xda => 'Non-FS data', - 0xdb => 'CP/M / CTOS / ...', - 0xde => 'Dell Utility', - 0xdf => 'BootIt', - 0xe1 => 'DOS access', - 0xe3 => 'DOS R/O', - 0xe4 => 'SpeedStor', - 0xeb => 'BeOS fs', - 0xee => 'EFI GPT', - 0xef => 'EFI (FAT-12/16/32)', - 0xf0 => 'Linux/PA-RISC boot', - 0xf1 => 'SpeedStor', - 0xf4 => 'SpeedStor', - 0xf2 => 'DOS secondary', - 0xfd => 'Linux RAID', - 0xfe => 'LANstep', - 0xff => 'BBT', -); - -my %pt_type2fs = ( -arch() =~ /^ppc/ ? ( - 0x07 => 'hpfs', -) : ( - 0x07 => 'ntfs', -), -arch() !~ /sparc/ ? ( - 0x01 => 'vfat', - 0x04 => 'vfat', - 0x05 => 'ignore', - 0x06 => 'vfat', -) : ( - 0x01 => 'ufs', - 0x02 => 'ufs', - 0x04 => 'ufs', - 0x06 => 'ufs', - 0x07 => 'ufs', - 0x08 => 'ufs', -), - 0x0b => 'vfat', - 0x0c => 'vfat', - 0x0e => 'vfat', - 0x1b => 'vfat', - 0x1c => 'vfat', - 0x1e => 'vfat', - 0x82 => 'swap', - 0x83 => 'ext2', - 0xeb => 'befs', - 0xef => 'vfat', - 0x107 => 'ntfs', - 0x183 => 'reiserfs', - 0x283 => 'xfs', - 0x383 => 'jfs', - 0x483 => 'ext3', - 0x401 => 'apple', - 0x402 => 'hfs', -); - -my %name2pt_type = reverse %pt_type2name; -my %fs2pt_type = reverse %pt_type2fs; - - foreach (@important_types, @important_types2, @bad_types) { - exists $name2pt_type{$_} or die "unknown $_\n"; - } - - -1; - -sub important_types() { - my @l = (@important_types, if_($::expert, @important_types2, sort values %pt_type2name)); - difference2(\@l, \@bad_types); -} - -sub type2fs { - my ($part, $o_default) = @_; - my $pt_type = $part->{pt_type}; - $pt_type2fs{$pt_type} || $pt_type =~ /^(\d+)$/ && $o_default || $pt_type; -} -sub fs2pt_type { $fs2pt_type{$_[0]} || $_[0] } -sub part2name { - my ($part) = @_; - $pt_type2name{$part->{pt_type}} || $part->{pt_type}; -} -sub name2pt_type { - local ($_) = @_; - /0x(.*)/ ? hex $1 : $name2pt_type{$_} || $_; -} -#sub name2type { { pt_type => name2pt_type($_[0]) } } - -sub isEfi { arch() =~ /ia64/ && $_[0]{pt_type} == 0xef } -sub isWholedisk { arch() =~ /^sparc/ && $_[0]{pt_type} == 5 } -sub isExtended { arch() !~ /^sparc/ && ($_[0]{pt_type} == 5 || $_[0]{pt_type} == 0xf || $_[0]{pt_type} == 0x85) } -sub isRawLVM { $_[0]{pt_type} == 0x8e } -sub isRawRAID { $_[0]{pt_type} == 0xfd } -sub isSwap { type2fs($_[0]) eq 'swap' } -sub isExt2 { type2fs($_[0]) eq 'ext2' } -sub isDos { arch() !~ /^sparc/ && ${{ 1 => 1, 4 => 1, 6 => 1 }}{$_[0]{pt_type}} } -sub isWin { ${{ 0xb => 1, 0xc => 1, 0xe => 1, 0x1b => 1, 0x1c => 1, 0x1e => 1 }}{$_[0]{pt_type}} } -sub isFat { isDos($_[0]) || isWin($_[0]) } -sub isFat_or_NTFS { isDos($_[0]) || isWin($_[0]) || $_[0]{pt_type} == 0x107 } -sub isSunOS { arch() =~ /sparc/ && ${{ 0x1 => 1, 0x2 => 1, 0x4 => 1, 0x6 => 1, 0x7 => 1, 0x8 => 1 }}{$_[0]{pt_type}} } -sub isApple { type2fs($_[0]) eq 'apple' && defined $_[0]{isDriver} } -sub isAppleBootstrap { type2fs($_[0]) eq 'apple' && defined $_[0]{isBoot} } -sub isHiddenMacPart { defined $_[0]{isMap} } - -sub isThisFs { type2fs($_[1]) eq $_[0] } -sub isTrueFS { isTrueLocalFS($_[0]) || member(type2fs($_[0]), qw(nfs)) } -sub isTrueLocalFS { member(type2fs($_[0]), qw(ext2 reiserfs xfs jfs ext3)) } - -sub isOtherAvailableFS { isEfi($_[0]) || isFat_or_NTFS($_[0]) || isSunOS($_[0]) || isThisFs('hfs', $_[0]) } #- other OS that linux can access its filesystem -sub isMountableRW { (isTrueFS($_[0]) || isOtherAvailableFS($_[0])) && !isThisFs('ntfs', $_[0]) } -sub isNonMountable { - my ($part) = @_; - isRawRAID($part) || isRawLVM($part) || isThisFs("ntfs", $part) && !$part->{isFormatted} && $part->{notFormatted}; -} - -sub isPartOfLVM { defined $_[0]{lvm} } -sub isPartOfRAID { defined $_[0]{raid} } -sub isPartOfLoopback { defined $_[0]{loopback} } -sub isRAID { $_[0]{device} =~ /^md/ } -sub isUBD { $_[0]{device} =~ /^ubd/ } #- should be always true during an $::uml_install -sub isLVM { $_[0]{VG_name} } -sub isLoopback { defined $_[0]{loopback_file} } -sub isMounted { $_[0]{isMounted} } -sub isBusy { isMounted($_[0]) || isPartOfRAID($_[0]) || isPartOfLVM($_[0]) || isPartOfLoopback($_[0]) } -sub isSpecial { isRAID($_[0]) || isLVM($_[0]) || isLoopback($_[0]) || isUBD($_[0]) } -sub maybeFormatted { $_[0]{isFormatted} || !$_[0]{notFormatted} } +our @fields2save = qw(primary extended totalsectors isDirty will_tell_kernel); #- works for both hard drives and partitions ;p @@ -281,7 +24,7 @@ sub description { formatXiB($hd->{totalsectors} || $hd->{size}, 512), $hd->{info} && ", $hd->{info}", $hd->{mntpoint} && ", " . $hd->{mntpoint}, - $hd->{pt_type} && ", " . part2name($hd); + $hd->{fs_type} && ", $hd->{fs_type}"; } sub isPrimary { @@ -388,14 +131,11 @@ sub assign_device_numbers { #- first verify there's at least one primary dos partition, otherwise it #- means it is a secondary disk and all will be false :( #- - #- isFat_or_NTFS isn't true for 0x7 partitions, only for 0x107. - #- alas 0x107 is not set correctly at this stage - #- solution: don't bother with 0x7 vs 0x107 here - my ($c, @others) = grep { isFat_or_NTFS($_) || $_->{pt_type} == 0x7 || $_->{pt_type} == 0x17 } @{$hd->{primary}{normal}}; + my ($c, @others) = grep { isFat_or_NTFS($_) } @{$hd->{primary}{normal}}; $i = ord 'C'; $c->{device_windobe} = chr($i++) if $c; - $_->{device_windobe} = chr($i++) foreach grep { isFat_or_NTFS($_) || $_->{pt_type} == 0x7 || $_->{pt_type} == 0x17 } map { $_->{normal} } @{$hd->{extended}}; + $_->{device_windobe} = chr($i++) foreach grep { isFat_or_NTFS($_) } map { $_->{normal} } @{$hd->{extended}}; $_->{device_windobe} = chr($i++) foreach @others; } @@ -634,7 +374,7 @@ sub tell_kernel { log::l("tell kernel force_reboot, rebootNeeded is now $hd->{rebootNeeded}."); foreach (@magic_parts) { - syscall_('mount', $_->{real_mntpoint}, type2fs($_), c::MS_MGC_VAL()) or log::l(N("mount failed: ") . $!); + syscall_('mount', $_->{real_mntpoint}, $_->{fs_type}, c::MS_MGC_VAL()) or log::l(N("mount failed: ") . $!); } } } @@ -792,8 +532,7 @@ sub add { get_normal_parts($hd) >= ($hd->{device} =~ /^rd/ ? 7 : $hd->{device} =~ /^(sd|ida|cciss|ataraid)/ ? 15 : 63) and cdie "maximum number of partitions handled by linux reached"; - $part->{notFormatted} = 1; - $part->{isFormatted} = 0; + set_isFormatted($part, 0); $part->{rootDevice} = $hd->{device}; $part->{start} ||= 1 if arch() !~ /^sparc/; #- starting at sector 0 is not allowed adjustStartAndEnd($hd, $part) unless $b_forceNoAdjust; @@ -868,3 +607,5 @@ sub save { eval { output($file, Data::Dumper->Dump([\@h], ['$h']), "\0") } or die N("Error writing to file %s", $file); } + +1; diff --git a/perl-install/partition_table/bsd.pm b/perl-install/partition_table/bsd.pm index cdf18e6d1..0e2421c25 100644 --- a/perl-install/partition_table/bsd.pm +++ b/perl-install/partition_table/bsd.pm @@ -73,7 +73,7 @@ sub read($$) { my $size = psizeof($format); my @pt = map { my %h; @h{@fields} = unpack $format, $_; - $h{pt_type} = $pt_typeToDos{$h{pt_type}} || $h{pt_type}; + fs::type::set_pt_type(\%h, $pt_typeToDos{$h{pt_type}} || $h{pt_type}); \%h; } $info{partitions} =~ /(.{$size})/g; diff --git a/perl-install/partition_table/dos.pm b/perl-install/partition_table/dos.pm index 38cdf60ed..8c30e6558 100644 --- a/perl-install/partition_table/dos.pm +++ b/perl-install/partition_table/dos.pm @@ -185,7 +185,9 @@ sub read { my @pt = map { sysread $F, $tmp, psizeof($format) or die "error while reading partition table in sector $sector"; - my %h; @h{@fields} = unpack $format, $tmp; + my %h; + @h{@fields} = unpack $format, $tmp; + fs::type::set_pt_type(\%h, $h{pt_type}); \%h; } (1..$nb_primary); diff --git a/perl-install/partition_table/gpt.pm b/perl-install/partition_table/gpt.pm index 2f1506bbd..423d73a7a 100644 --- a/perl-install/partition_table/gpt.pm +++ b/perl-install/partition_table/gpt.pm @@ -130,8 +130,8 @@ sub read_partitionEntries { sysread $F, $tmp, psizeof($partitionEntry_format) or die "error while reading partition table in sector $info->{partitionEntriesLBA}"; my %h; @h{@$partitionEntry_fields} = unpack $partitionEntry_format, $tmp; $h{size} = $h{ending} - $h{start} + 1; - $h{pt_type} = $gpt_types_rev{$h{gpt_type}}; - $h{pt_type} = 0x100 if !defined $h{pt_type}; + my $pt_type = $gpt_types_rev{$h{gpt_type}}; + fs::type::set_pt_type(\%h, defined $pt_type ? $pt_type : 0x100); \%h; } (1 .. $info->{nbPartitions}); \@pt; diff --git a/perl-install/partition_table/mac.pm b/perl-install/partition_table/mac.pm index 219b6434d..4b60710bb 100644 --- a/perl-install/partition_table/mac.pm +++ b/perl-install/partition_table/mac.pm @@ -7,6 +7,7 @@ use vars qw(@ISA $freepart $bootstrap_part $macos_part); @ISA = qw(partition_table::raw); use common; +use fs::type; use partition_table::raw; use partition_table; use c; @@ -139,7 +140,7 @@ sub read($$) { $h{start} = ($h{pPBlockStart} * $info{bzBlkSize}) / 512; if ($h{pType} =~ /^Apple_UNIX_SVR2/i) { - $h{pName} =~ /swap/i ? ($h{pt_type} = 0x82) : ($h{pt_type} = 0x83); + $h{fs_type} = $h{pName} =~ /swap/i ? 'swap' : 'ext2'; } elsif ($h{pType} =~ /^Apple_Free/i) { #- need to locate a 1MB partition to setup a bootstrap on if ($freepart && $freepart->{size} >= 1) { @@ -151,7 +152,7 @@ sub read($$) { $h{pt_type} = 0x0; $h{pName} = 'Extra'; } elsif ($h{pType} =~ /^Apple_HFS/i) { - $h{pt_type} = 0x402; + fs::type::set_pt_type(\%h, 0x402); if (defined $macos_part) { #- swag at identifying MacOS - 1st HFS partition } else { @@ -297,27 +298,27 @@ sub write($$$;$) { log::l("writing a bootstrap at /dev/$_->{device}"); $install_steps_interactive::new_bootstrap = 1 if !(defined $partition_table::mac::bootstrap_part); $bootstrap_part = "/dev/" . $_->{device}; - } elsif ($_->{pt_type} == 0x82) { + } elsif (isSwap($_)) { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "swap"; $_->{pFlags} = 0x33; - } elsif ($_->{pt_type} == 0x83) { + } elsif ($_->{fs_type} eq 'ext2') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux Native"; $_->{pFlags} = 0x33; - } elsif ($_->{pt_type} == 0x183) { + } elsif ($_->{fs_type} eq 'reiserfs') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux ReiserFS"; $_->{pFlags} = 0x33; - } elsif ($_->{pt_type} == 0x283) { + } elsif ($_->{fs_type} eq 'xfs') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux XFS"; $_->{pFlags} = 0x33; - } elsif ($_->{pt_type} == 0x383) { + } elsif ($_->{fs_type} eq 'jfs') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux JFS"; $_->{pFlags} = 0x33; - } elsif ($_->{pt_type} == 0x483) { + } elsif ($_->{fs_type} eq 'ext3') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux ext3"; $_->{pFlags} = 0x33; diff --git a/perl-install/partition_table/sun.pm b/perl-install/partition_table/sun.pm index 7c8a6beb9..54e734ca8 100644 --- a/perl-install/partition_table/sun.pm +++ b/perl-install/partition_table/sun.pm @@ -9,6 +9,7 @@ use vars qw(@ISA); use common; use partition_table::raw; use partition_table; +use fs::type; use c; my ($main_format, $main_fields) = list2kv( @@ -92,8 +93,9 @@ sub read($$) { my @infos_up = unpack $format1 x $nb_primary, $info{infos}; my @partitions_up = unpack $format2 x $nb_primary, $info{partitions}; foreach (0..$nb_primary-1) { - my $h = { pt_type => $infos_up[2 * $_], flag => $infos_up[1 + 2 * $_], + my $h = { flag => $infos_up[1 + 2 * $_], start_cylinder => $partitions_up[2 * $_], size => $partitions_up[1 + 2 * $_] }; + fs::type::set_pt_type($h, $infos_up[2 * $_]); $h->{start} = $sector + $h->{start_cylinder} * $hd->cylinder_size; $h->{pt_type} && $h->{size} or $h->{$_} = 0 foreach keys %$h; push @pt, $h; @@ -133,7 +135,7 @@ sub write($$$;$) { # $csize += $_->{size} if $_->{pt_type} != 5; # $wdsize += $_->{size} if $_->{pt_type} == 5; $_->{flags} |= 0x10 if $_->{mntpoint} eq '/'; - $_->{flags} |= 0x01 if partition_table::isSwap($_); + $_->{flags} |= 0x01 if !isSwap($_); local $_->{start_cylinder} = $_->{start} / $hd->cylinder_size - $sector; pack($format1, @$_{@$fields1}), pack($format2, @$_{@$fields2}); } @$pt; diff --git a/perl-install/raid.pm b/perl-install/raid.pm index 8b03e3375..d91f3984b 100644 --- a/perl-install/raid.pm +++ b/perl-install/raid.pm @@ -7,7 +7,7 @@ use strict; #- misc imports #-###################################################################################### use common; -use partition_table qw(:types); +use fs::type; use run_program; use devices; use modules; @@ -23,7 +23,7 @@ sub nb { sub new { my ($raids, @parts) = @_; my $nb = @$raids; - $raids->[$nb] = { 'chunk-size' => "64k", pt_type => 0x483, disks => [ @parts ], device => "md$nb", notFormatted => 1, level => 1 }; + $raids->[$nb] = { 'chunk-size' => "64k", fs_type => 'ext3', disks => [ @parts ], device => "md$nb", notFormatted => 1, level => 1 }; foreach my $part (@parts) { $part->{raid} = $nb; delete $part->{mntpoint}; @@ -36,7 +36,7 @@ sub add { my ($raids, $part, $nb) = @_; $nb = nb($nb); $raids->[$nb]{isMounted} and die N("Can't add a partition to _formatted_ RAID md%d", $nb); inactivate_and_dirty($raids->[$nb]); - $part->{notFormatted} = 1; $part->{isFormatted} = 0; + set_isFormatted($part, 0); $part->{raid} = $nb; delete $part->{mntpoint}; push @{$raids->[$nb]{disks}}, $part; @@ -145,7 +145,7 @@ sub format_part { make($raids, $part); fs::format::part_raw($part); - $_->{isFormatted} = 1 foreach @{$part->{disks}}; + set_isFormatted($_, 1) foreach @{$part->{disks}}; } sub verify { @@ -171,7 +171,7 @@ sub prepare_prefixed { sub inactivate_and_dirty { my ($part) = @_; run_program::run("raidstop", devices::make($part->{device})); - $part->{notFormatted} = 1; $part->{isFormatted} = 0; + set_isFormatted($part, 0); } sub active_mds() { |