diff options
Diffstat (limited to 'perl-install/partition_table')
| -rw-r--r-- | perl-install/partition_table/bsd.pm | 30 | ||||
| -rw-r--r-- | perl-install/partition_table/dmcrypt.pm | 41 | ||||
| -rw-r--r-- | perl-install/partition_table/dos.pm | 306 | ||||
| -rw-r--r-- | perl-install/partition_table/empty.pm | 14 | ||||
| -rw-r--r-- | perl-install/partition_table/gpt.pm | 342 | ||||
| -rw-r--r-- | perl-install/partition_table/lvm.pm | 38 | ||||
| -rw-r--r-- | perl-install/partition_table/lvm_PV.pm | 43 | ||||
| -rw-r--r-- | perl-install/partition_table/mac.pm | 77 | ||||
| -rw-r--r-- | perl-install/partition_table/raw.pm | 235 | ||||
| -rw-r--r-- | perl-install/partition_table/readonly.pm | 20 | ||||
| -rw-r--r-- | perl-install/partition_table/sun.pm | 52 |
11 files changed, 764 insertions, 434 deletions
diff --git a/perl-install/partition_table/bsd.pm b/perl-install/partition_table/bsd.pm index d08cd57aa..ec2a2edf4 100644 --- a/perl-install/partition_table/bsd.pm +++ b/perl-install/partition_table/bsd.pm @@ -1,4 +1,4 @@ -package partition_table::bsd; # $Id$ +package partition_table::bsd; use diagnostics; use strict; @@ -12,11 +12,11 @@ use partition_table; use c; #- very bad and rough handling :( -my %typeToDos = ( +my %pt_typeToDos = ( 8 => 0x83, 1 => 0x82, ); -my %typeFromDos = reverse %typeToDos; +my %pt_typeFromDos = reverse %pt_typeToDos; my ($main_format, $main_fields) = list2kv( I => 'magic', @@ -52,13 +52,16 @@ my ($main_format, $main_fields) = list2kv( ); $main_format = join '', @$main_format; -my @fields = qw(size start fsize type frag cpg); +my @fields = qw(size start fsize pt_type frag cpg); my $format = "I I I C C S"; my $magic = 0x82564557; my $nb_primary = 8; my $offset = 0x40; -sub read($$) { + +sub use_pt_type { 1 } + +sub read_one { my ($hd, $sector) = @_; my $tmp; @@ -73,7 +76,7 @@ sub read($$) { my $size = psizeof($format); my @pt = map { my %h; @h{@fields} = unpack $format, $_; - $h{type} = $typeToDos{$h{type}} || $h{type}; + fs::type::set_pt_type(\%h, $pt_typeToDos{$h{pt_type}} || $h{pt_type}); \%h; } $info{partitions} =~ /(.{$size})/g; @@ -85,9 +88,9 @@ sub read($$) { } # write the partition table (and extended ones) -# for each entry, it uses fields: start, size, type, active +# for each entry, it uses fields: start, size, pt_type, active sub write($$$;$) { - my ($hd, $sector, $pt, $info) = @_; + my ($hd, $_handle, $sector, $pt, $info) = @_; #- handle testing for writing partition table on file only! my $F; @@ -105,7 +108,7 @@ sub write($$$;$) { @$pt == $nb_primary or die "partition table does not have $nb_primary entries"; $info->{partitions} = join '', map { - local $_->{type} = $typeFromDos{$_->{type}} || $_->{type}; + local $_->{pt_type} = $pt_typeFromDos{$_->{pt_type}} || $_->{pt_type}; pack $format, @$_{@fields}; } @$pt; @@ -124,7 +127,7 @@ sub info { dtype => $hd->{device} =~ /^sd/ ? $dtype_scsi : $dtype_ST506, secsize => $common::SECTORSIZE, ncylinders => $hd->{geom}{cylinders}, - secpercyl => $hd->cylinder_size(), + secpercyl => $hd->cylinder_size, secprtunit => $hd->{geom}{totalsectors}, rpm => 3600, interleave => 1, @@ -137,9 +140,10 @@ sub info { }; } -sub clear_raw { - my ($hd) = @_; - { raw => [ ({}) x $nb_primary ], info => info($hd) }; +sub initialize { + my ($class, $hd) = @_; + $hd->{primary} = { raw => [ ({}) x $nb_primary ], info => info($hd) }; + bless $hd, $class; } sub first_usable_sector { 2048 } diff --git a/perl-install/partition_table/dmcrypt.pm b/perl-install/partition_table/dmcrypt.pm new file mode 100644 index 000000000..eb35eb41c --- /dev/null +++ b/perl-install/partition_table/dmcrypt.pm @@ -0,0 +1,41 @@ +package partition_table::dmcrypt; + +# dmcrypt on full disk + +use diagnostics; +use strict; + +our @ISA = qw(partition_table::readonly); + +use common; +use partition_table::readonly; +use fs::type; + +sub _parts { + my ($hd) = @_; + + my $part = { size => $hd->{totalsectors}, device => $hd->{device} }; + add2hash($part, fs::type::type_name2subpart('Encrypted')); + + require fs; + fs::get_major_minor([$part]); # to allow is_same_hd() in fs::dmcrypt + + [ $part ]; +} + +sub read_primary { + my ($hd) = @_; + + my $type = fs::type::type_subpart_from_magic($hd); + + $type && $type->{type_name} eq 'Encrypted' or return; + + partition_table::dmcrypt->initialize($hd); + 1; +} + +sub initialize { + my ($class, $hd) = @_; + + partition_table::readonly::initialize($class, $hd, _parts($hd)); +} diff --git a/perl-install/partition_table/dos.pm b/perl-install/partition_table/dos.pm index e448ad841..aa020131a 100644 --- a/perl-install/partition_table/dos.pm +++ b/perl-install/partition_table/dos.pm @@ -1,4 +1,4 @@ -package partition_table::dos; # $Id$ +package partition_table::dos; use diagnostics; use strict; @@ -6,55 +6,219 @@ use vars qw(@ISA); @ISA = qw(partition_table::raw); +use Time::HiRes qw(usleep); use common; use partition_table::raw; use partition_table; +use fs::proc_partitions; +use fs::type; use c; -my @fields = qw(active start_head start_sec start_cyl type end_head end_sec end_cyl start size); +=head1 SYNOPSYS + +Read/write MBR partition tables + +=head1 Functions + +=over + +=cut + +my @fields = qw(active start_head start_sec start_cyl pt_type end_head end_sec end_cyl start size); my $format = "C8 V2"; my $magic = "\x55\xAA"; my $nb_primary = 4; my $offset = $common::SECTORSIZE - length($magic) - $nb_primary * common::psizeof($format); +sub use_pt_type { 1 } sub hasExtended { 1 } +sub geometry_to_string { + my ($geom) = @_; + "$geom->{cylinders}/$geom->{heads}/$geom->{sectors}"; +} + sub last_usable_sector { my ($hd) = @_; - #- do not use totalsectors, see gi/docs/Partition-ends-after-end-of-disk.txt for more + #- do not use totalsectors, see docs/Partition-ends-after-end-of-disk.txt for more $hd->{geom}{sectors} * $hd->{geom}{heads} * $hd->{geom}{cylinders}; } -sub compute_CHS($$) { - my ($hd, $e) = @_; - my @l = qw(cyl head sec); - @$e{map { "start_$_" } @l} = $e->{start} || $e->{type} ? CHS2rawCHS($hd, sector2CHS($hd, $e->{start})) : (0,0,0); - @$e{map { "end_$_" } @l} = $e->{start} || $e->{type} ? CHS2rawCHS($hd, sector2CHS($hd, $e->{start} + $e->{size} - 1)) : (0,0,0); - 1; +my $two_TB = 2 * 1024 * 1024 * 2048; +sub max_partition_start { $two_TB - 1 } +sub max_partition_size { $two_TB - 1 } + +sub get_rawCHS { + my ($part) = @_; + + exists $part->{start_cyl} or internal_error("get_rawCHS $part->{device}"); + + [ $part->{start_cyl}, $part->{start_head}, $part->{start_sec} ], + [ $part->{end_cyl}, $part->{end_head}, $part->{end_sec} ]; +} +sub set_rawCHS { + my ($part, $raw_chs_start, $raw_chs_end) = @_; + ($part->{start_cyl}, $part->{start_head}, $part->{start_sec}) = @$raw_chs_start; + ($part->{end_cyl}, $part->{end_head}, $part->{end_sec}) = @$raw_chs_end; +} + +sub compute_CHS { + my ($hd, $part) = @_; + my ($chs_start, $chs_end) = CHS_from_part_linear($hd->{geom}, $part); + set_rawCHS($part, $chs_start ? CHS2rawCHS($hd->{geom}, $chs_start) : [0,0,0], + $chs_end ? CHS2rawCHS($hd->{geom}, $chs_end) : [0,0,0]); +} + +sub CHS_from_part_rawCHS { + my ($part) = @_; + + $part->{start} || $part->{pt_type} or return; + + my ($raw_chs_start, $raw_chs_end) = get_rawCHS($part); + rawCHS2CHS($raw_chs_start), rawCHS2CHS($raw_chs_end); +} + +sub CHS_from_part_linear { + my ($geom, $part) = @_; + + $part->{start} || $part->{pt_type} or return; + + sector2CHS($geom, $part->{start}), sector2CHS($geom, $part->{start} + $part->{size} - 1); +} + +sub rawCHS2CHS { + my ($chs) = @_; + my ($c, $h, $s) = @$chs; + [ $c | (($s & 0xc0) << 2), $h, ($s & 0x3f) - 1 ]; } sub CHS2rawCHS { - my ($hd, $c, $h, $s) = @_; + my ($geom, $chs) = @_; + my ($c, $h, $s) = @$chs; if ($c > 1023) { #- no way to have a #cylinder >= 1024 $c = 1023; - $h = $hd->{geom}{heads} - 1; - $s = $hd->{geom}{sectors}; + $h = $geom->{heads} - 1; + $s = $geom->{sectors} - 1; } - ($c & 0xff, $h, $s | (($c >> 2) & 0xc0)); + [ $c & 0xff, $h, ($s + 1) | (($c >> 2) & 0xc0) ]; } -# returns (cylinder, head, sector) +=item sector2CHS($geom, $start) + +returns (cylinder, head, sector) + +=cut + sub sector2CHS { - my ($hd, $start) = @_; + my ($geom, $start) = @_; my ($s, $h); - ($start, $s) = divide($start, $hd->{geom}{sectors}); - ($start, $h) = divide($start, $hd->{geom}{heads}); - ($start, $h, $s + 1); + ($start, $s) = divide($start, $geom->{sectors}); + ($start, $h) = divide($start, $geom->{heads}); + [ $start, $h, $s ]; +} + +sub is_geometry_valid_for_the_partition_table { + my ($hd, $geom, $no_log) = @_; + + every { + my ($chs_start_v1, $chs_end_v1) = map { join(',', @$_) } CHS_from_part_rawCHS($_) or next; + my ($chs_start_v2, $chs_end_v2) = map { join(',', @$_) } map { [ min($_->[0], 1023), $_->[1], $_->[2] ] } CHS_from_part_linear($geom, $_); + if (!$no_log) { + $chs_start_v1 eq $chs_start_v2 or log::l("is_geometry_valid_for_the_partition_table failed for ($_->{device}, $_->{start}): $chs_start_v1 vs $chs_start_v2 with geometry " . geometry_to_string($geom)); + $chs_end_v1 eq $chs_end_v2 or log::l("is_geometry_valid_for_the_partition_table failed for ($_->{device}, " . ($_->{start} + $_->{size} - 1) . "): $chs_end_v1 vs $chs_end_v2 with geometry " . geometry_to_string($geom)); + } + $chs_start_v1 eq $chs_start_v2 && $chs_end_v1 eq $chs_end_v2; + } @{$hd->{primary}{normal} || []}; +} + +#- from parted, thanks! +my @valid_nb_sectors = (63, 61, 48, 32, 16); +my @valid_nb_heads = (255, 240, 192, 128, 96, 64, 61, 32, 17, 16); + +sub guess_geometry_from_partition_table { + my ($hd) = @_; + + my @chss = map { CHS_from_part_rawCHS($_) } @{$hd->{primary}{normal} || []} or return { empty => 1 }; + my ($nb_heads, $nb_sectors) = (max(map { $_->[1] } @chss) + 1, max(map { $_->[2] } @chss) + 1); + my $geom = { sectors => $nb_sectors, heads => $nb_heads }; + partition_table::raw::compute_nb_cylinders($geom, $hd->{totalsectors}); + log::l("guess_geometry_from_partition_table $hd->{device}: " . geometry_to_string($geom)); + + member($geom->{sectors}, @valid_nb_sectors) or return { invalid => 1 }; + $geom; +} + +sub geometry_from_edd { + my ($hd, $edd_dir) = @_; + + my $sectors = cat_("$edd_dir/legacy_sectors_per_track") or return; + my $heads = cat_("$edd_dir/legacy_max_head") or return; + + my $geom = { sectors => 0 + $sectors, heads => 1 + $heads, from_edd => 1 }; + is_geometry_valid_for_the_partition_table($hd, $geom, 0) or return; + partition_table::raw::compute_nb_cylinders($geom, $hd->{totalsectors}); + + log::l("geometry_from_edd $hd->{device} $hd->{volume_id}: " . geometry_to_string($geom)); + + $geom; +} + + +sub try_every_geometry { + my ($hd) = @_; + + my $geom = {}; + foreach (@valid_nb_sectors) { + $geom->{sectors} = $_; + foreach (@valid_nb_heads) { + $geom->{heads} = $_; + if (is_geometry_valid_for_the_partition_table($hd, $geom, 1)) { + partition_table::raw::compute_nb_cylinders($geom, $hd->{totalsectors}); + log::l("try_every_geometry $hd->{device}: found " . geometry_to_string($geom)); + return $geom; + } + } + } + log::l("$hd->{device}: argh! no geometry exists for this partition table"); + undef; +} + +sub set_best_geometry_for_the_partition_table { + my ($hd) = @_; + + my $guessed_geom = guess_geometry_from_partition_table($hd); + if ($guessed_geom->{empty}) { + log::l("$hd->{device}: would need looking at BIOS info to find out geometry") if !$hd->{geom}{from_edd}; + return; + } + my $default_ok = is_geometry_valid_for_the_partition_table($hd, $hd->{geom}, 0); + if ($guessed_geom->{invalid}) { + log::l("$hd->{device}: no valid geometry guessed from partition table"); + $default_ok and return; + $guessed_geom = try_every_geometry($hd) or return; + } + + if ($guessed_geom->{heads} == $hd->{geom}{heads} && $guessed_geom->{sectors} == $hd->{geom}{sectors}) { + # cool! + } else { + my $guessed_ok = is_geometry_valid_for_the_partition_table($hd, $guessed_geom, 0); + if ($default_ok && $guessed_ok) { + #- oh my!? + log::l("$hd->{device}: both guessed and default are valid??? " . geometry_to_string($hd->{geom}) . " vs " . geometry_to_string($guessed_geom)); + } elsif ($default_ok) { + log::l("$hd->{device}: keeping default geometry " . geometry_to_string($hd->{geom})); + } elsif ($guessed_ok) { + log::l("$hd->{device}: using guessed geometry " . geometry_to_string($guessed_geom) . " instead of " . geometry_to_string($hd->{geom})); + put_in_hash($hd->{geom}, $guessed_geom); + } else { + log::l("$hd->{device}: argh! no valid geometry found"); + } + } } -sub read { +sub read_one { my ($hd, $sector) = @_; my $tmp; @@ -63,7 +227,10 @@ 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; + $h{pt_type} = 'BIOS_GRUB' if $h{pt_type} == 0 && $h{size} > 0; + fs::type::set_pt_type(\%h, $h{pt_type}); \%h; } (1..$nb_primary); @@ -71,13 +238,32 @@ sub read { sysread $F, $tmp, length $magic or die "error reading magic number on disk $hd->{device}"; $tmp eq $magic or die "bad magic number on disk $hd->{device}"; + if ($hd->{current_pt_table_type} ne "dos") { + # libparted may have ignored it because of overlapping partitions or other error + # while it is actually a partition table. + $hd->{fs_type_from_magic} and die "unpartitionned disk"; + my $primary = partition_table::raw::pt_info_to_primary($hd, [ @pt ]); + foreach my $i (@{$primary->{normal}}) { + if ($i->{active} && $i->{active} != 0x80 || + $hd->{totalsectors} && $i->{start} > $hd->{totalsectors}) { + die "Invalid DOS partition table"; + } + } + } + [ @pt ]; } -# write the partition table (and extended ones) -# for each entry, it uses fields: start, size, type, active -sub write($$$;$) { - my ($hd, $sector, $pt) = @_; +=item start_write($hd) + +Prepare to write the partition table (and extended ones) + +=cut + +sub start_write { + my ($hd) = @_; + + log::l("partition::dos::write $hd->{device}"); #- handle testing for writing partition table on file only! my $F; @@ -86,6 +272,27 @@ sub write($$$;$) { open $F, ">$file" or die "error opening test file $file"; } else { $F = partition_table::raw::openit($hd, 2) or die "error opening device $hd->{device} for writing"; + if ($hd->{was_hybrid_iso}) { + log::l("partition::dos::start_write erasing hybrid iso9660 signature"); + c::lseek_sector(fileno($F), 0, 0x8001) or return 0; + syswrite $F, "\0\0\0\0\0", 5 or return 0; + $hd->{was_hybrid_iso} = 0; + } + } + $F; +} + +=item start_write($hd, $F, $sector, $pt) + +Write the partition table (and extended ones). +For each entry, it uses fields: start, size, pt_type, active + +=cut + +sub write { + my ($hd, $F, $sector, $pt) = @_; + + if (!$::testing) { c::lseek_sector(fileno($F), $sector, $offset) or return 0; } @@ -93,13 +300,60 @@ sub write($$$;$) { foreach (@$pt) { compute_CHS($hd, $_); local $_->{start} = $_->{local_start} || 0; - $_->{active} ||= 0; $_->{type} ||= 0; $_->{size} ||= 0; #- for no warning + $_->{active} ||= 0; $_->{pt_type} ||= 0; $_->{size} ||= 0; #- for no warning syswrite $F, pack($format, @$_{@fields}), psizeof($format) or return 0; } syswrite $F, $magic, length $magic or return 0; 1; } -sub clear_raw { { raw => [ ({}) x $nb_primary ] } } +sub end_write { + my ($hd, $F) = @_; + close $F; +} + +sub need_to_tell_kernel { + my ($hd) = @_; + # Whenever udevd receives a change event for a raw disk device it is watching, it asks the kernel to + # rescan the partition table on that device by calling the BLKRRPART ioctl. This is only successful + # if none of the partitions on that device are currently mounted. So if any partitions are mounted, + # we need to tell the kernel what has changed ourselves. + # The udev/rules.d/60-block.rules file causes the raw disk devices to be watched by udev. This file is + # not present in the cut-down system used to run the classic installer, so we always need to tell the + # kernel in that case. + # diskdrake will not let the user delete an individual partition that is mounted, but will let the + # user clear all partitions. So initialize() records if any partitions were mounted and we take note + # of that here. + return 1 if ! -e '/usr/lib/udev/rules.d/60-block.rules' || delete $hd->{hadMountedPartitions} || any { $_->{isMounted} } partition_table::get_normal_parts($hd); + + # No further actions must be performed until the kernel has been informed of the changes. There is + # no easy way to check that udevd has received the uevent and called the BLKRRPART ioctl, so do it + # the hard way. + my $tries = 0; + do { + usleep(100000); + log::l("checking that udevd has informed the kernel of partition table changes"); + eval { fs::proc_partitions::compare($hd) }; + return 0 if !$@; + $tries++; + } while $tries < 5; + + # We don't expect to get here, but fail safe if so. + log::l("udevd failed to inform kernel of partition table changes"); + $hd->{rebootNeeded} = 1; + 1; +} + +sub empty_raw { { raw => [ ({}) x $nb_primary ] } } + +sub initialize { + my ($class, $hd) = @_; + # Remember whether any existing partitions are mounted, for use by need_to_tell_kernel(). + $hd->{hadMountedPartitions} = 1 if any { $_->{isMounted} } partition_table::get_normal_parts($hd); + # Remember whether this was a hybrid ISO so we can wipe the iso9660 signature. + $hd->{was_hybrid_iso} = 1 if $hd->{primary}{is_hybrid_iso}; + $hd->{primary} = empty_raw(); + bless $hd, $class; +} 1; diff --git a/perl-install/partition_table/empty.pm b/perl-install/partition_table/empty.pm index 596088619..fe4ad4317 100644 --- a/perl-install/partition_table/empty.pm +++ b/perl-install/partition_table/empty.pm @@ -1,7 +1,7 @@ -package partition_table::empty; # $Id$ +package partition_table::empty; #- this is a mainly dummy partition table. If we find it's empty, we just call - -#- zero_MBR which will take care of bless'ing us to the partition table type best +#- ->clear which will take care of bless'ing us to the partition table type best #- suited @@ -17,7 +17,7 @@ use partition_table; use c; -sub read($$) { +sub read_one { my ($hd, $sector) = @_; my $tmp; @@ -25,12 +25,12 @@ sub read($$) { c::lseek_sector(fileno($F), $sector, 0) or die "reading of partition in sector $sector failed"; #- check magic number - sysread $F, $tmp, 512 or die "error reading magic number on disk $hd->{device}"; - $tmp eq substr($tmp, 0, 1) x 512 or die "bad magic number on disk $hd->{device}"; + sysread $F, $tmp, 1024 or die "error reading magic number on disk $hd->{device}"; + $tmp eq substr($tmp, 0, 1) x 1024 or die "bad magic number on disk $hd->{device}"; - partition_table::raw::zero_MBR($hd); + partition_table::initialize($hd); - $hd->{primary}{raw}; + $hd->{primary}{raw}, $hd->{primary}{info}; } 1; diff --git a/perl-install/partition_table/gpt.pm b/perl-install/partition_table/gpt.pm index 4b78f193c..af5509f27 100644 --- a/perl-install/partition_table/gpt.pm +++ b/perl-install/partition_table/gpt.pm @@ -1,4 +1,4 @@ -package partition_table::gpt; # $Id$ +package partition_table::gpt; use diagnostics; use strict; @@ -6,258 +6,156 @@ use vars qw(@ISA); @ISA = qw(partition_table::raw); -use common; +use fs::type; use partition_table::raw; -use partition_table::dos; -use partition_table; use c; -my %gpt_types = ( - 0x00 => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", - 0x82 => "\x6d\xfd\x57\x06\xab\xa4\xc4\x43\x84\xe5\x09\x33\xc8\x4b\x4f\x4f", - 0x83 => "\xA2\xA0\xD0\xEB\xE5\xB9\x33\x44\x87\xC0\x68\xB6\xB7\x26\x99\xC7", - 0x8e => "\x79\xd3\xd6\xe6\x07\xf5\xc2\x44\xa2\x3c\x23\x8f\x2a\x3d\xf9\x28", - 0xfd => "\x0f\x88\x9d\xa1\xfc\x05\x3b\x4d\xa0\x06\x74\x3f\x0f\x84\x91\x1e", - 0xef => "\x28\x73\x2A\xC1\x1F\xF8\xd2\x11\xBA\x4B\x00\xA0\xC9\x3E\xC9\x3B", - # legacy_partition_table => "\x41\xEE\x4D\x02\xE7\x33\xd3\x11\x9D\x69\x00\x08\xC7\x81\xF3\x9F" - # PARTITION_MSFT_RESERVED_GUID "\x16\xE3\xC9\xE3\x5C\x0B\xB8\x4D\x81\x7D\xF9\x2D\xF0\x02\x15\xAE" - #PARTITION_RESERVED_GUID "\x39\x33\xa6\x8d\x07\x00\xc0\x60\xc4\x36\x08\x3a\xc8\x23\x09\x08" -); - -my $current_revision = 0x00010200; -my ($main_format, $main_fields) = list2kv( - a8 => 'magic', - V => 'revision', - V => 'headerSize', - V => 'headerCRC32', - a4 => 'blank1', - Q => 'myLBA', - Q => 'alternateLBA', - Q => 'firstUsableLBA', - Q => 'lastUsableLBA', - a16 => 'guid', - Q => 'partitionEntriesLBA', - V => 'nbPartitions', - V => 'partitionEntrySize', - V => 'partitionEntriesCRC32', -); - -my ($partitionEntry_format, $partitionEntry_fields) = list2kv( - a16 => 'gpt_type', - a16 => 'guid', - Q => 'start', - Q => 'ending', - a8 => 'efi_attributes', - a72 => 'name', -); - -my ($guid_format, $guid_fields) = list2kv( - N => 'time_low', - n => 'time_mid', - n => 'time_hi_and_version', - n => 'clock_seq', - a6 => 'node', -); - -$_ = join('', @$_) foreach $main_format, $partitionEntry_format, $guid_format; - -my $magic = "EFI PART"; - -sub generate_guid { - my $tmp; - open(my $F, devices::make("random")) or die "Could not open /dev/random for GUID generation"; - read $F, $tmp, psizeof($guid_format); - - my %guid; @guid{@$guid_fields} = unpack $guid_format, $tmp; - $guid{clock_seq} = ($guid{clock_seq} & 0x3fff) | 0x8000; - $guid{time_hi_and_version} = ($guid{time_hi_and_version} & 0x0fff) | 0x4000; - pack($guid_format, @guid{@$guid_fields}); -} +=head1 SYNOPSYS -sub crc32 { - my ($buffer) = @_; +Read/write GUID partition tables (GPT) - my $crc = 0xFFFFFFFF; - foreach (unpack "C*", $buffer) { - my $subcrc = ($crc ^ $_) & 0xFF; - for (my $j = 8; $j > 0; $j--) { - my $b = $subcrc & 1; - $subcrc = ($subcrc >> 1) & 0x7FFFFFFF; - $subcrc = $subcrc ^ 0xEDB88320 if $b; - } - $crc = ($crc >> 8) ^ $subcrc; - } - $crc ^ 0xFFFFFFFF; -} +See https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs for a list of exitings GUIDs -sub compute_headerCRC32 { - my ($info) = @_; - local $info->{headerCRC32} = 0; - crc32(pack($main_format, @$info{@$main_fields})); -} +=head1 Functions -sub read_header { - my ($sector, $F) = @_; - my $tmp; +=over - c::lseek_sector(fileno($F), $sector, 0) or die "reading of partition in sector $sector failed"; +=cut +my $nb_primary = 128; - sysread $F, $tmp, psizeof($main_format) or die "error while reading partition table in sector $sector"; - my %info; @info{@$main_fields} = unpack $main_format, $tmp; - - $info{magic} eq $magic or die "bad magic number"; - $info{myLBA} == $sector or die "myLBA is not the same"; - $info{headerSize} == psizeof($main_format) or die "bad partition table header size"; - $info{partitionEntrySize} == psizeof($partitionEntry_format) or die "bad partitionEntrySize"; - $info{revision} <= $current_revision or log::l("oops, this is a new GPT revision ($info{revision} > $current_revision)"); - $info{headerCRC32} == compute_headerCRC32(\%info) or die "bad partition table checksum"; - \%info -} +sub first_usable_sector { 34 } -sub read_partitionEntries { - my ($info, $F) = @_; - my $tmp; - - c::lseek_sector(fileno($F), $info->{partitionEntriesLBA}, 0) or die "can't seek to sector partitionEntriesLBA"; - sysread $F, $tmp, psizeof($partitionEntry_format) * $info->{nbPartitions} or die "error while reading partition table in sector $info->{partitionEntriesLBA}"; - $info->{partitionEntriesCRC32} == crc32($tmp) or die "bad partition entries checksum"; - - c::lseek_sector(fileno($F), $info->{partitionEntriesLBA}, 0) or die "can't seek to sector partitionEntriesLBA"; - my %gpt_types_rev = reverse %gpt_types; - my @pt = - map { - 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{type} = $gpt_types_rev{$h{gpt_type}}; - $h{type} = 0x100 if !defined $h{type}; - \%h; - } (1 .. $info->{nbPartitions}); - \@pt; +sub last_usable_sector { + my ($hd) = @_; + #- do not use totalsectors because backup GPT is at end + $hd->{totalsectors} - 33; } -sub read { - my ($hd, $sector) = @_; - - my $l = partition_table::dos::read($hd, $sector); - my @l = grep { $_->{size} && $_->{type} && !partition_table::isExtended($_) } @$l; - @l == 1 or die "bad PMBR"; - $l[0]{type} == 0xee or die "bad PMBR"; - my $myLBA = $l[0]{start}; - - my $F = partition_table::raw::openit($hd) or die "failed to open device"; - my $info1 = eval { read_header($myLBA, $F) }; - my $info2 = eval { read_header($info1->{alternateLBA} || $l[0]{start} + $l[0]{size} - 1, $F) }; #- what about using $hd->{totalsectors} ??? - my $info = $info1 || { %$info2, myLBA => $info2->{alternateLBA}, alternateLBA => $info2->{myLBA}, partitionEntriesLBA => $info2->{alternateLBA} + 1 } or die; - my $pt = $info1 && $info2 ? - eval { $info1 && read_partitionEntries($info1, $F) } || read_partitionEntries($info2, $F) : - read_partitionEntries($info, $F); - $hd->raw_removed($pt); - - $pt, $info; +my %parted_mapping = ( + 'linux-swap(v1)' => 'swap', + 'ntfs' => 'ntfs-3g', + 'fat16' => 'vfat', + 'fat32' => 'vfat', + ); +my %rev_parted_mapping = reverse %parted_mapping; +# prefer 'fat32' over 'fat16': +$rev_parted_mapping{vfat} = 'fat32'; + +sub read_one { + my ($hd, $_sector) = @_; + + $hd->{current_pt_table_type} eq "gpt" or die "$hd->{device} not a GPT disk ($hd->{file})"; + + my @pt; + foreach (c::get_disk_partitions($hd->{file})) { + # compatibility with MBR partitions tables: + $_->{pt_type} = 0x82 if $_->{fs_type} eq 'swap'; + $_->{pt_type} = 0x0b if $_->{fs_type} eq 'vfat'; + $_->{pt_type} = 0x83 if $_->{fs_type} =~ /^ext/; + + # fix detecting ESP (special case are they're detected through pt_type): + if ($_->{flag} eq 'ESP') { + $_->{pt_type} = 0xef; + } elsif ($_->{flag} eq 'BIOS_GRUB') { + $_->{fs_type} = $_->{flag}; # hack to prevent it to land in hd->{raw} + $_->{pt_type} = $_->{flag}; # hack... + } elsif ($_->{flag} eq 'LVM') { + $_->{pt_type} = 0x8e; + } elsif ($_->{flag} eq 'RAID') { + $_->{pt_type} = 0xfd; + } elsif ($_->{flag} eq 'RECOVERY') { + $_->{pt_type} = 0x12; + } + $_->{fs_type} = $parted_mapping{$_->{fs_type}} if $parted_mapping{$_->{fs_type}}; + + @pt[$_->{part_number}-1] = $_; + } + + for (my $part_number = 1; $part_number < $nb_primary; $part_number++) { + next if exists($pt[$part_number-1]); + $pt[$part_number-1] = { part_number => $part_number }; + } + + \@pt; } -# write the partition table (and extended ones) -# for each entry, it uses fields: start, size, type, active sub write { - my ($hd, $sector, $pt, $info) = @_; + my ($hd, $_handle, $_sector, $pt, $_info) = @_; + + my $ped_disk; + my $partitions_killed; - foreach (@$pt) { - $_->{ending} = $_->{start} + $_->{size} - 1; - $_->{guid} ||= generate_guid(); - $_->{gpt_type} = $gpt_types{$_->{type}} || $_->{gpt_type} || $gpt_types{0x83}; + # Initialize the disk if current partition table is not gpt + if ($hd->{current_pt_table_type} ne "gpt") { + $ped_disk = c::disk_open($hd->{file}, "gpt") or die "failed to create new partition table on $hd->{file}"; + $partitions_killed = 1; + } else { + $ped_disk = c::disk_open($hd->{file}) or die "failed to open partition table on $hd->{file}"; } - my $partitionEntries = join('', map { - pack($partitionEntry_format, @$_{@$partitionEntry_fields}) - } (@$pt, ({}) x ($info->{nbPartitions} - @$pt))); - - $info->{partitionEntriesCRC32} = crc32($partitionEntries); - $info->{headerCRC32} = compute_headerCRC32($info); - - my $info2 = { %$info, - myLBA => $info->{alternateLBA}, alternateLBA => $info->{myLBA}, - partitionEntriesLBA => $info->{alternateLBA} - psizeof($partitionEntry_format) * $info->{nbPartitions} / 512, - }; - $info2->{headerCRC32} = compute_headerCRC32($info2); - - { - # write the PMBR - my $pmbr = partition_table::dos::clear_raw(); - $pmbr->{raw}[0] = { type => 0xee, local_start => $info->{myLBA}, size => $info->{alternateLBA} - $info->{myLBA} + 1 }; - partition_table::dos::write($hd, $sector, $pmbr->{raw}); + + foreach (@{$hd->{will_tell_kernel}}) { + my ($action, $part_number, $o_start, $o_size) = @$_; + my ($part) = grep { $_->{start} == $o_start && $_->{size} == $o_size } @$pt; + log::l("GPT partitioning: ($action, $part_number, $o_start, $o_size)"); + if ($action eq 'add') { + local $part->{fs_type} = $rev_parted_mapping{$part->{fs_type}} if $rev_parted_mapping{$part->{fs_type}}; + c::disk_add_partition($ped_disk, $o_start, $o_size, $part->{fs_type}) or die "failed to add partition #$part_number on $hd->{file}"; + my $flag; + if (isESP($part)) { + $flag = 'ESP'; + } elsif (isBIOS_GRUB($part)) { + $flag = 'BIOS_GRUB'; + } elsif (isRawLVM($part)) { + $flag = 'LVM'; + } elsif (isRawRAID($part)) { + $flag = 'RAID'; + } + if ($flag) { + c::set_partition_flag($ped_disk, $part_number, $flag) + or die "failed to set type '$flag' for $part->{file} on $part->{mntpoint}"; + } + } elsif ($action eq 'del' && !$partitions_killed) { + c::disk_del_partition($ped_disk, $part_number) or die "failed to del partition #$part_number on $hd->{file}"; + } elsif ($action eq 'init' && !$partitions_killed) { + c::disk_delete_all($ped_disk) or die "failed to delete all partitions on $hd->{file}"; + } } - my $F = partition_table::raw::openit($hd, 2) or die "error opening device $hd->{device} for writing"; - - c::lseek_sector(fileno($F), $info->{myLBA}, 0) or return 0; - #- pad with 0's - syswrite $F, pack($main_format, @$info{@$main_fields}) . "\0" x 512, 512 or return 0; + # Commit changes to the disk and inform the kernel + my $commit_level = c::disk_commit($ped_disk); + # Updating the kernel partition table will fail if any of the deleted partitions were mounted + $hd->{rebootNeeded} = 1 if $commit_level < 2; + $commit_level; +} - c::lseek_sector(fileno($F), $info->{alternateLBA}, 0) or return 0; - #- pad with 0's - syswrite $F, pack($main_format, @$info2{@$main_fields}) . "\0" x 512, 512 or return 0; +=item need_to_tell_kernel($hd) - c::lseek_sector(fileno($F), $info->{partitionEntriesLBA}, 0) or return 0; - syswrite $F, $partitionEntries or return 0; - - c::lseek_sector(fileno($F), $info2->{partitionEntriesLBA}, 0) or return 0; - syswrite $F, $partitionEntries or return 0; +Hint partition_table::write() that telling the kernel to reread the +partition_table is not needed if we already succeeded in that - common::sync(); - 1; -} +=cut -sub raw_removed { - my ($_hd, $raw) = @_; - @$raw = grep { $_->{size} && $_->{type} } @$raw; -} -sub can_raw_add { +sub need_to_tell_kernel { my ($hd) = @_; - @{$hd->{primary}{raw}} < $hd->{primary}{info}{nbPartitions}; + # If we failed, try again (partion_table::tell_kernel() will unmount some partitions first) + $hd->{rebootNeeded}; } -sub raw_add { - my ($hd, $raw, $part) = @_; - $hd->can_raw_add or die "raw_add: partition table already full"; - push @$raw, $part; + +sub initialize { + my ($class, $hd) = @_; + # part_number starts at 1 + my @raw = map { +{ part_number => $_ + 1 } } 0..$nb_primary-2; + $hd->{primary} = { raw => \@raw }; + bless $hd, $class; } +sub can_add { &can_raw_add } sub adjustStart {} sub adjustEnd {} -sub first_usable_sector { - my ($hd) = @_; - $hd->{primary}{info}{firstUsableLBA}; -} -sub last_usable_sector { - my ($hd) = @_; - $hd->{primary}{info}{lastUsableLBA} + 1; -} +=back -sub info { - my ($hd) = @_; - my $nb_sect = 32; - - #- build a default suitable partition table, - #- checksum will be built when writing on disk. - { - magic => $magic, - revision => $current_revision, - headerSize => psizeof($main_format), - myLBA => 1, - alternateLBA => $hd->{totalsectors} - 1, - firstUsableLBA => $nb_sect + 2, - lastUsableLBA => $hd->{totalsectors} - $nb_sect - 2, - guid => generate_guid(), - partitionEntriesLBA => 2, - nbPartitions => $nb_sect * 512 / psizeof($partitionEntry_format), - partitionEntrySize => psizeof($partitionEntry_format), - }; -} - -sub clear_raw { - my ($hd) = @_; - { raw => [], info => info($hd) }; -} +=cut 1; diff --git a/perl-install/partition_table/lvm.pm b/perl-install/partition_table/lvm.pm new file mode 100644 index 000000000..920507fa5 --- /dev/null +++ b/perl-install/partition_table/lvm.pm @@ -0,0 +1,38 @@ +package partition_table::lvm; + +# LVM on full disk + +use diagnostics; +use strict; + +our @ISA = qw(partition_table::readonly); + +use common; +use partition_table::readonly; +use fs::type; + +sub _parts { + my ($hd) = @_; + + my $part = { size => $hd->{totalsectors}, device => $hd->{device} }; + add2hash($part, fs::type::type_name2subpart('Linux Logical Volume Manager')); + + [ $part ]; +} + +sub read_primary { + my ($hd) = @_; + + my $type = fs::type::type_subpart_from_magic($hd); + + $type && $type->{type_name} eq 'Linux Logical Volume Manager' or return; + + partition_table::lvm->initialize($hd); + 1; +} + +sub initialize { + my ($class, $hd) = @_; + + partition_table::readonly::initialize($class, $hd, _parts($hd)); +} diff --git a/perl-install/partition_table/lvm_PV.pm b/perl-install/partition_table/lvm_PV.pm deleted file mode 100644 index c2ff30fb6..000000000 --- a/perl-install/partition_table/lvm_PV.pm +++ /dev/null @@ -1,43 +0,0 @@ -package partition_table::lvm; # $Id$ - -use diagnostics; -use strict; - -our @ISA = qw(partition_table::raw); - -use partition_table::raw; -use c; - -my $magic = "HM\1\0"; -my $offset = 0; - - -#- Allows people having PVs on unpartitioned disks to install -#- (but no way to create such beasts) -#- -#- another way to handle them would be to ignore those disks, -#- but this would make those hds unshown in diskdrake, -#- disallowing to zero_MBR, clearing this PV - - -sub read { - my ($hd, $sector) = @_; - - my $F = partition_table::raw::openit($hd) or die "failed to open device"; - c::lseek_sector(fileno($F), $sector, $offset) or die "reading of partition in sector $sector failed"; - - sysread $F, my $tmp, length $magic or die "error reading magic number on disk $hd->{file}"; - $tmp eq $magic or die "bad magic number on disk $hd->{file}"; - - []; -} - -sub write { - die "ERROR: should not be writing raw disk lvm PV!!"; -} - -sub clear_raw { - die "ERROR: should not be creating new raw disk lvm PV!!"; -} - -1; diff --git a/perl-install/partition_table/mac.pm b/perl-install/partition_table/mac.pm index 942136bf1..78e5469cd 100644 --- a/perl-install/partition_table/mac.pm +++ b/perl-install/partition_table/mac.pm @@ -1,17 +1,18 @@ -package partition_table::mac; # $Id$ +package partition_table::mac; use diagnostics; #use strict; - fixed other PPC code to comply, but program bails on empty partition table - sbenedict -use vars qw(@ISA $freepart $bootstrap_part $macos_part); +use vars qw(@ISA $freepart $bootstrap_part $macos_part $new_bootstrap); @ISA = qw(partition_table::raw); use common; +use fs::type; use partition_table::raw; use partition_table; use c; -my %typeToDos = ( +my %_typeToDos = ( "Apple_partition_map" => 0x401, "Apple_Bootstrap" => 0x401, "Apple_Driver43" => 0x401, @@ -25,7 +26,6 @@ my %typeToDos = ( "Apple_UNIX_SVR2" => 0x483, "Apple_Free" => 0x0, ); -my %typeFromDos = reverse %typeToDos; my ($bz_format, $bz_fields) = list2kv( @@ -79,6 +79,8 @@ $p_format = join '', @$p_format; my $magic = 0x4552; my $pmagic = 0x504D; +sub use_pt_type { 1 } + sub first_usable_sector { 1 } sub adjustStart($$) { @@ -96,14 +98,14 @@ sub adjustEnd($$) { my ($_hd, $_part) = @_; } -sub read($$) { +sub read_one { my ($hd, $sector) = @_; my $tmp; my $F = partition_table::raw::openit($hd) or die "failed to open device"; c::lseek_sector(fileno($F), $sector, 0) or die "reading of partition in sector $sector failed"; - sysread $F, $tmp, psizeof($bz_format) or die "error while reading bz \(Block Zero\) in sector $sector"; + sysread $F, $tmp, psizeof($bz_format) or die "error while reading bz (Block Zero) in sector $sector"; my %info; @info{@$bz_fields} = unpack $bz_format, $tmp; foreach (1 .. $info{bzDrvrCnt}) { @@ -140,7 +142,7 @@ sub read($$) { $h{start} = ($h{pPBlockStart} * $info{bzBlkSize}) / 512; if ($h{pType} =~ /^Apple_UNIX_SVR2/i) { - $h{pName} =~ /swap/i ? ($h{type} = 0x82) : ($h{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) { @@ -149,10 +151,10 @@ sub read($$) { $freepart = { start => $h{start}, size => $h{size}/2048, hd => $hd, part => "/dev/$hd->{device}" . ($i+1) }; log::l("free apple partition found on drive /dev/$freepart->{hd}{device}, block $freepart->{start}, size $freepart->{size}"); } - $h{type} = 0x0; + $h{pt_type} = 0x0; $h{pName} = 'Extra'; } elsif ($h{pType} =~ /^Apple_HFS/i) { - $h{type} = 0x402; + fs::type::set_pt_type(\%h, 0x402); if (defined $macos_part) { #- swag at identifying MacOS - 1st HFS partition } else { @@ -160,10 +162,10 @@ sub read($$) { log::l("found MacOS at partition $macos_part"); } } elsif ($h{pType} =~ /^Apple_Partition_Map/i) { - $h{type} = 0x401; + $h{pt_type} = 0x401; $h{isMap} = 1; } elsif ($h{pType} =~ /^Apple_Bootstrap/i) { - $h{type} = 0x401; + $h{pt_type} = 0x401; $h{isBoot} = 1; if (defined $bootstrap_part) { #found a bootstrap already - use it, but log the find @@ -173,9 +175,9 @@ sub read($$) { log::l("found apple bootstrap at partition $bootstrap_part"); } } else { - $h{type} = 0x401; + $h{pt_type} = 0x401; $h{isDriver} = 1; - }; + } # Let's see if this partition is a driver. foreach (@{$info{ddMap}}) { @@ -185,13 +187,13 @@ sub read($$) { } \%h; } [ $part ]; - }; + } [ @pt ], \%info; } sub write($$$;$) { - my ($hd, $sector, $pt, $info) = @_; + my ($hd, $_handle, $sector, $pt, $info) = @_; #- handle testing for writing partition table on file only! my $F; @@ -219,24 +221,24 @@ sub write($$$;$) { if ($last->{start} + $last->{size} < $part->{start}) { #There is a gap between partitions. Fill it and move on. push @partstowrite, { - type => 0x0, + pt_type => 0x0, start => $last->{start} + $last->{size}, size => $part->{start} - ($last->{start} + $last->{size}), }; } push @partstowrite, $part; - }; + } # now, fill a gap at the end if there is one. if ($last->{start} + $last->{size} < $hd->{totalsectors}) { push @partstowrite, { - type => 0x0, + pt_type => 0x0, start => $last->{start} + $last->{size}, size => $hd->{totalsectors} - ($last->{start} + $last->{size}), }; } - # Since we didn't create any new drivers, let's try and match up our driver records with out partitons and see if any are missing. + # Since we did not create any new drivers, let's try and match up our driver records with out partitons and see if any are missing. $info->{bzDrvrCnt} = 0; my @ddstowrite; foreach my $dd (@{$info->{ddMap}}) { @@ -282,52 +284,52 @@ sub write($$$;$) { $_->{pBootArgs} = "\0"; $_->{pReserved} = "\0"; - if ($_->{type} == 0x402) { + if ($_->{pt_type} == 0x402) { $_->{pType} = "Apple_HFS"; $_->{pName} = "MacOS"; $_->{pFlags} = 0x4000037F; - } elsif ($_->{type} == 0x401 && $_->{start} == 1) { + } elsif ($_->{pt_type} == 0x401 && $_->{start} == 1) { $_->{pType} = "Apple_Partition_Map"; $_->{pName} = "Apple"; $_->{pFlags} = 0x33; - } elsif ($_->{type} == 0x401) { + } elsif ($_->{pt_type} == 0x401) { $_->{pType} = "Apple_Bootstrap"; $_->{pName} = "bootstrap"; $_->{pFlags} = 0x33; $_->{isBoot} = 1; log::l("writing a bootstrap at /dev/$_->{device}"); - $install_steps_interactive::new_bootstrap = 1 if !(defined $partition_table::mac::bootstrap_part); + $new_bootstrap = 1 if !(defined $bootstrap_part); $bootstrap_part = "/dev/" . $_->{device}; - } elsif ($_->{type} == 0x82) { + } elsif (isSwap($_)) { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "swap"; $_->{pFlags} = 0x33; - } elsif ($_->{type} == 0x83) { + } elsif ($_->{fs_type} eq 'ext2') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux Native"; $_->{pFlags} = 0x33; - } elsif ($_->{type} == 0x183) { + } elsif ($_->{fs_type} eq 'reiserfs') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux ReiserFS"; $_->{pFlags} = 0x33; - } elsif ($_->{type} == 0x283) { + } elsif ($_->{fs_type} eq 'xfs') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux XFS"; $_->{pFlags} = 0x33; - } elsif ($_->{type} == 0x383) { + } elsif ($_->{fs_type} eq 'jfs') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux JFS"; $_->{pFlags} = 0x33; - } elsif ($_->{type} == 0x483) { + } elsif ($_->{fs_type} eq 'ext3') { $_->{pType} = "Apple_UNIX_SVR2"; $_->{pName} = "Linux ext3"; $_->{pFlags} = 0x33; - } elsif ($_->{type} == 0x0) { + } elsif ($_->{pt_type} == 0x0) { $_->{pType} = "Apple_Free"; $_->{pName} = "Extra"; $_->{pFlags} = 0x31; } - }; + } $_->{pMapEntry} = @partstowrite; syswrite $F, pack($p_format, @$_{@$p_fields}), psizeof($p_format) or return 0; } @@ -355,20 +357,20 @@ sub info { $info; } -sub clear_raw { - my ($hd) = @_; +sub initialize { + my ($class, $hd) = @_; my @oldraw = @{$hd->{primary}{raw}}; my $pt = { raw => [ ({}) x 63 ], info => info($hd) }; #- handle special case for partition 1 which is the partition map. $pt->{raw}[0] = { - type => 0x401, + pt_type => 0x401, start => 1, size => 63, isMap => 1, }; # $pt->{raw}[1] = { -# type => 0x0, +# pt_type => 0x0, # start => 64, # size => $hd->{totalsectors} - 64, # isMap => 0, @@ -384,10 +386,11 @@ sub clear_raw { push @{$pt->{normal}}, $pt->{raw}[$i]; $i++; } - }; + } @{$pt->{info}{ddMap}} = @{$hd->{primary}{info}{ddMap}}; - $pt; + $hd->{primary} = $pt; + bless $hd, $class; } 1; diff --git a/perl-install/partition_table/raw.pm b/perl-install/partition_table/raw.pm index 0b06848ac..453a19c6c 100644 --- a/perl-install/partition_table/raw.pm +++ b/perl-install/partition_table/raw.pm @@ -1,4 +1,4 @@ -package partition_table::raw; # $Id$ +package partition_table::raw; use diagnostics; use strict; @@ -6,20 +6,36 @@ use strict; use common; use devices; use detect_devices; +use fs::type; use log; use c; my @MBR_signatures = ( -if_(arch() =~ /ppc/, - map { [ 'yaboot', 0, "PM", 0x200 * $_ + 0x10, "bootstrap\0" ] } 0 .. 61 -), [ 'empty', 0, "\0\0\0\0" ], [ 'grub', 0, "\xEBG", 0x17d, "stage1 \0" ], [ 'grub', 0, "\xEBH", 0x17e, "stage1 \0" ], [ 'grub', 0, "\xEBH", 0x18a, "stage1 \0" ], - [ 'grub', 0, "\xEBH", 0x181, "GRUB \0" ], + sub { my ($F) = @_; + #- standard grub has no good magic (Mageia's grub is patched to have "GRUB" at offset 6) + #- so scanning a range of possible places where grub can have its string + #- 0x176 found on Conectiva 10 + my ($min, $max, $magic) = (0x176, 0x181, "GRUB \0"); + my $tmp; + sysseek($F, 0, 0) && sysread($F, $tmp, $max + length($magic)) or return; + substr($tmp, 0, 2) eq "\xEBH" or return; + index($tmp, $magic, $min) >= 0 && "grub"; + }, + sub { my ($F) = @_; + #- similar to grub-legacy, grub2 doesn't seem to have good magic + #- so scanning a range of possible places where grub can have its string + my ($min, $max, $magic) = (0x176, 0x188, "GRUB"); + my $tmp; + sysseek($F, 0, 0) && sysread($F, $tmp, $max + length($magic)) or return; + index($tmp, $magic, $min) >= 0 && "grub2"; + }, [ 'lilo', 0x2, "LILO" ], [ 'lilo', 0x6, "LILO" ], + [ 'lilo', 0x6 + 0x40, "LILO" ], #- when relocated in lilo's bsect_update(), variable "space" on paragraph boundary gives 0x40 [ 'grub', 0x6, "GRUB" ], [ 'osbs', 0x2, "OSBS" ], #- http://www.prz.tu-berlin.de/~wolf/os-bs.html [ 'pqmagic', 0xef, "PQV" ], @@ -44,7 +60,9 @@ if_(arch() =~ /ppc/, sub typeOfMBR($) { typeFromMagic(devices::make($_[0]), @MBR_signatures) } sub typeOfMBR_($) { typeFromMagic($_[0], @MBR_signatures) } +sub use_pt_type { 0 } sub hasExtended { 0 } +sub set_best_geometry_for_the_partition_table {} sub cylinder_size($) { my ($hd) = @_; @@ -55,19 +73,13 @@ sub last_usable_sector { my ($hd) = @_; $hd->{totalsectors}; } +# no limit +sub max_partition_start { 1e99 } +sub max_partition_size { 1e99 } -#- default method for starting a partition, only head size or twice -#- is allowed for starting a partition after a cylinder boundarie. -sub adjustStart($$) { - my ($hd, $part) = @_; - my $end = $part->{start} + $part->{size}; +#- default method for starting a partition +sub adjustStart($$) {} - $part->{start} = round_up($part->{start}, - $part->{start} % cylinder_size($hd) < 2 * $hd->{geom}{sectors} ? - $hd->{geom}{sectors} : cylinder_size($hd)); - $part->{size} = $end - $part->{start}; - $part->{size} > 0 or die "adjustStart get a too small partition to handle correctly"; -} #- adjusting end to match a cylinder boundary, two methods are used and must #- match at the end, else something is wrong and nothing will be done on #- partition table. @@ -88,41 +100,109 @@ sub adjustEnd($$) { $part->{size} > 0 or internal_error("adjustEnd get a too small partition to handle correctly"); } -sub get_geometry($) { +sub compute_nb_cylinders { + my ($geom, $totalsectors) = @_; + if ($geom->{heads} && $geom->{sectors}) { + $geom->{cylinders} = int $totalsectors / $geom->{heads} / $geom->{sectors}; + } +} + +sub keep_non_duplicates { + my %l; + $l{$_->[0]}++ foreach @_; + map { @$_ } grep { $l{$_->[0]} == 1 } @_; +} + +sub get_geometries { + my (@hds) = @_; + + @hds = grep { + if ($_->{bus} =~ /dmraid/) { + sysopen(my $F, $_->{file}, 0); + my $total = c::total_sectors(fileno $F); + my %geom; + $geom{heads} = 255; + $geom{sectors} = 63; + $geom{start} = 1; + compute_nb_cylinders(\%geom, $total); + $geom{totalcylinders} = $geom{cylinders}; + log::l("Fake geometry on " . $_->{file} . ": heads=$geom{heads} sectors=$geom{sectors} cylinders=$geom{cylinders} start=$geom{start}"); + add2hash_($_, { totalsectors => $total, geom => \%geom }); + 1; + } elsif (my $h = get_geometry($_->{file})) { + add2hash_($_, $h); + 1; + } else { + log::l("An error occurred while getting the geometry of block device $_->{file}: $!"); + 0; + } + } @hds; + + my %id2hd = keep_non_duplicates(map { + my $F = openit($_) or log::l("failed to open device $_->{device}"); + my $tmp; + if ($F && c::lseek_sector(fileno($F), 0, 0x1b8) && sysread($F, $tmp, 4)) { + [ sprintf('0x%08x', unpack('V', $tmp)), $_ ]; + } else { + (); + } + } @hds); + + + my %id2edd = keep_non_duplicates(map { [ scalar(chomp_(cat_("$_/mbr_signature"))), $_ ] } glob("/sys/firmware/edd/int13_dev*")); + + log::l("id2hd: " . join(' ', map_each { "$::a=>$::b->{device}" } %id2hd)); + log::l("id2edd: " . join(' ', map_each { "$::a=>$::b" } %id2edd)); + + foreach my $id (keys %id2hd) { + my $hd = $id2hd{$id}; + $hd->{volume_id} = $id; + + if (my $edd_dir = $id2edd{$id}) { + $hd->{bios_from_edd} = $1 if $edd_dir =~ /int13_dev(.*)/; + + require partition_table::dos; + my $geom = partition_table::dos::geometry_from_edd($hd, $edd_dir); + $hd->{geom} = $geom if $geom; + } + } + + @hds; +} + +sub get_geometry { my ($dev) = @_; + sysopen(my $F, $dev, 0) or return; + + my $total = c::total_sectors(fileno $F); + my $g = ""; + my %geom; + if (ioctl($F, c::HDIO_GETGEO(), $g)) { + @geom{qw(heads sectors cylinders start)} = unpack "CCSL", $g; + log::l("HDIO_GETGEO on $dev succeeded: heads=$geom{heads} sectors=$geom{sectors} cylinders=$geom{cylinders} start=$geom{start}"); + $geom{totalcylinders} = $geom{cylinders}; - sysopen(my $F, $dev, 0) or return; - ioctl($F, c::HDIO_GETGEO(), $g) or return; - my %geom; @geom{qw(heads sectors cylinders start)} = unpack "CCSL", $g; - $geom{totalcylinders} = $geom{cylinders}; - - my $total; - #- $geom{cylinders} is no good (only a ushort, that means less than 2^16 => at best 512MB) - if ($total = c::total_sectors(fileno $F)) { - $geom{cylinders} = int $total / $geom{heads} / $geom{sectors}; - } else { - $total = $geom{heads} * $geom{sectors} * $geom{cylinders} + #- $geom{cylinders} is no good (only a ushort, that means less than 2^16 => at best 512MB) + if ($total) { + compute_nb_cylinders(\%geom, $total); + } else { + $total = $geom{heads} * $geom{sectors} * $geom{cylinders}; + } } - { geom => \%geom, totalsectors => $total }; + { totalsectors => $total, if_($geom{heads}, geom => \%geom) }; } sub openit { - my ($hd, $mode) = @_; - my $F; sysopen($F, $hd->{file}, $mode || 0) and $F; + my ($hd, $o_mode) = @_; + my $F; sysopen($F, $hd->{file}, $o_mode || 0) && $F; } -# cause kernel to re-read partition table -sub kernel_read($) { +sub can_add { my ($hd) = @_; - common::sync(); - my $F = openit($hd) or return 0; - common::sync(); sleep(1); - $hd->{rebootNeeded} = !ioctl($F, c::BLKRRPART(), 0); - common::sync(); - close $F; - common::sync(); sleep(1); + !$_->{size} && !$_->{pt_type} || isExtended($_) and return 1 foreach @{$hd->{primary}{raw}}; + 0; } sub raw_removed { @@ -130,69 +210,100 @@ sub raw_removed { } sub can_raw_add { my ($hd) = @_; - $_->{size} || $_->{type} or return 1 foreach @{$hd->{primary}{raw}}; + $_->{size} || $_->{pt_type} or return 1 foreach @{$hd->{primary}{raw}}; 0; } sub raw_add { my ($_hd, $raw, $part) = @_; foreach (@$raw) { - $_->{size} || $_->{type} and next; + $_->{size} || $_->{pt_type} and next; $_ = $part; return; } die "raw_add: partition table already full"; } -sub zero_MBR { +sub zero_MBR { &partition_table::initialize } #- deprecated + +#- deprecated +sub zero_MBR_and_dirty { my ($hd) = @_; - #- force the standard partition type for the architecture - my $type = arch() =~ /ia64/ ? 'gpt' : arch() eq "alpha" ? "bsd" : arch() =~ /^sparc/ ? "sun" : arch() eq "ppc" ? "mac" : "dos"; - #- override standard mac type on PPC for IBM machines to dos - $type = "dos" if arch() =~ /ppc/ && detect_devices::get_mac_model() =~ /^IBM/; - require "partition_table/$type.pm"; - bless $hd, "partition_table::$type"; - $hd->{primary} = $hd->clear_raw(); - delete $hd->{extended}; + fsedit::partition_table_clear_and_initialize([], $hd); +} + +#- by default, we assume the kernel doesn't automatically reread partition table: +sub need_to_tell_kernel { + my ($_hd) = @_; + 1; } -sub zero_MBR_and_dirty { +sub read_primary { my ($hd) = @_; - zero_MBR($hd); - $hd->{isDirty} = $hd->{needKernelReread} = 1; + my ($pt, $info) = eval { $hd->read_one(0) }; + $pt or return; + my $primary = partition_table::raw::pt_info_to_primary($hd, $pt, $info); + $primary->{is_hybrid_iso} = $hd->{current_pt_table_type} eq 'dos' && $hd->{fs_type_from_magic} eq 'iso9660'; + $hd->{primary} = $primary; + undef $hd->{extended}; + partition_table::verifyPrimary($primary); + 1; +} + +sub pt_info_to_primary { + my ($hd, $pt, $info) = @_; + + my @extended = $hd->hasExtended ? grep { isExtended($_) } @$pt : (); + my @normal = grep { $_->{size} && !isEmpty($_) && !isExtended($_) } @$pt; + my $nb_special_empty = int(grep { $_->{size} && isEmpty($_) } @$pt); + + @extended > 1 and die "more than one extended partition"; + + put_in_hash($_, partition_table::hd2minimal_part($hd)) foreach @normal, @extended; + { raw => $pt, extended => $extended[0], normal => \@normal, info => $info, nb_special_empty => $nb_special_empty }; } #- ugly stuff needed mainly for Western Digital IDE drives #- try writing what we've just read, yells if it fails #- testing on last sector of head #0 (unused in 99% cases) #- -#- return false if the device can't be written to (especially for Smartmedia) +#- return false if the device cannot be written to (especially for Smartmedia) sub test_for_bad_drives { my ($hd) = @_; - log::l("test_for_bad_drives($hd->{file})"); - my $sector = $hd->{geom}{sectors} - 1; + my $sector = $hd->{geom} ? $hd->{geom}{sectors} - 1 : 0; + log::l("test_for_bad_drives($hd->{file} on sector #$sector)"); sub error { die "$_[0] error: $_[1]" } - my $F = openit($hd, 2) or error(openit($hd) ? 'write' : 'read', "can't open device"); + my $F = openit($hd, $::testing ? 0 : 2) or error(openit($hd) ? 'write' : 'read', "cannot open device"); my $seek = sub { c::lseek_sector(fileno($F), $sector, 0) or error('read', "seeking to sector $sector failed"); }; my $tmp; - &$seek; sysread $F, $tmp, $SECTORSIZE or error('read', "can't even read ($!)"); + &$seek; sysread $F, $tmp, $SECTORSIZE or error('read', "cannot even read ($!)"); return if $hd->{readonly} || $::testing; - &$seek; syswrite $F, $tmp or error('write', "can't even write ($!)"); + &$seek; syswrite $F, $tmp or error('write', "cannot even write ($!)"); my $tmp2; - &$seek; sysread $F, $tmp2, $SECTORSIZE or die "test_for_bad_drives: can't even read again ($!)"; + &$seek; sysread $F, $tmp2, $SECTORSIZE or die "test_for_bad_drives: cannot even read again ($!)"; $tmp eq $tmp2 or die -N("Something bad is happening on your drive. +N("Something bad is happening on your hard disk drive. A test to check the integrity of data has failed. It means writing anything on the disk will end up with random, corrupted data."); } +sub start_write { + my ($_hd) = @_; + 1; +} + +sub end_write { + my ($_hd, $_handle) = @_; + 1; +} + 1; diff --git a/perl-install/partition_table/readonly.pm b/perl-install/partition_table/readonly.pm new file mode 100644 index 000000000..ee3624f88 --- /dev/null +++ b/perl-install/partition_table/readonly.pm @@ -0,0 +1,20 @@ +package partition_table::readonly; + +use diagnostics; +use strict; + +our @ISA = qw(partition_table::raw); + +use common; +use partition_table::raw; +use fs::type; + +sub initialize { + my ($class, $hd, $parts) = @_; + + $hd->{readonly} = $hd->{getting_rid_of_readonly_allowed} = 1; + $hd->{primary} = { normal => $parts }; + delete $hd->{extended}; + + bless $hd, $class; +} diff --git a/perl-install/partition_table/sun.pm b/perl-install/partition_table/sun.pm index bcae6d296..e665d0168 100644 --- a/perl-install/partition_table/sun.pm +++ b/perl-install/partition_table/sun.pm @@ -1,4 +1,4 @@ -package partition_table::sun; # $Id$ +package partition_table::sun; use diagnostics; use strict; @@ -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( @@ -32,13 +33,14 @@ my ($main_format, $main_fields) = list2kv( ); $main_format = join '', @$main_format; -my ($fields1, $fields2) = ([ qw(type flags) ], [ qw(start_cylinder size) ]); +my ($fields1, $fields2) = ([ qw(pt_type flags) ], [ qw(start_cylinder size) ]); my ($format1, $format2) = ("xCxC", "N2"); -my ($size1, $size2) = map { psizeof($_) } ($format1, $format2); my $magic = 0xDABE; my $nb_primary = 8; my $offset = 0; +sub use_pt_type { 1 } + sub adjustStart($$) { my ($hd, $part) = @_; my $end = $part->{start} + $part->{size}; @@ -47,15 +49,15 @@ sub adjustStart($$) { #- note that if start sector is on the first cylinder, it is adjusted #- to 0 and it is valid, cylinder 0 bug is from bad define for sparc #- compilation of mke2fs combined with a blind kernel... - $part->{start} = round_down($part->{start}, $hd->cylinder_size()); + $part->{start} = round_down($part->{start}, $hd->cylinder_size); $part->{size} = $end - $part->{start}; - $part->{size} = $hd->cylinder_size() if $part->{size} <= 0; + $part->{size} = $hd->cylinder_size if $part->{size} <= 0; } sub adjustEnd($$) { my ($hd, $part) = @_; my $end = $part->{start} + $part->{size}; - my $end2 = round_up($end, $hd->cylinder_size()); - $end2 = $hd->{geom}{cylinders} * $hd->cylinder_size() if $end2 > $hd->{geom}{cylinders} * $hd->cylinder_size(); + my $end2 = round_up($end, $hd->cylinder_size); + $end2 = $hd->{geom}{cylinders} * $hd->cylinder_size if $end2 > $hd->{geom}{cylinders} * $hd->cylinder_size; $part->{size} = $end2 - $part->{start}; } @@ -66,12 +68,12 @@ sub compute_crc($) { my @l2b = unpack "n256", $tmp; my $crc = 0; - map { $crc ^= $_ } @l2b; + $crc ^= $_ foreach @l2b; $crc; } -sub read($$) { +sub read_one { my ($hd, $sector) = @_; my $tmp; @@ -93,10 +95,11 @@ 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 = { 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 * $_] }; - $h->{start} = $sector + $h->{start_cylinder} * $hd->cylinder_size(); - $h->{type} && $h->{size} or $h->{$_} = 0 foreach keys %$h; + 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; } @@ -106,7 +109,7 @@ sub read($$) { # @h{@$fields1} = unpack $format1, $_[0]; # @h{@$fields2} = unpack $format2, $_[1]; # $h{start} = $sector + $h{start_cylinder} * $hd->cylinder_size(); -# $h{type} && $h{size} or $h{$_} = 0 foreach keys %h; +# $h{pt_type} && $h{size} or $h{$_} = 0 foreach keys %h; # \%h; # } [ grep { $_ } split /(.{$size1})/o, $info{infos} ], [ grep { $_ } split /(.{$size2})/o, $info{partitions} ]; @@ -114,9 +117,9 @@ sub read($$) { } # write the partition table (and extended ones) -# for each entry, it uses fields: start, size, type, active +# for each entry, it uses fields: start, size, pt_type, active sub write($$$;$) { - my ($hd, $sector, $pt, $info) = @_; + my ($hd, $_handle, $sector, $pt, $info) = @_; # my ($csize, $wdsize) = (0, 0); #- handle testing for writing partition table on file only! @@ -130,12 +133,12 @@ sub write($$$;$) { } ($info->{infos}, $info->{partitions}) = map { join '', @$_ } list2kv map { - $_->{start} % $hd->cylinder_size() == 0 or die "partition not at beginning of cylinder"; -# $csize += $_->{size} if $_->{type} != 5; -# $wdsize += $_->{size} if $_->{type} == 5; + $_->{start} % $hd->cylinder_size == 0 or die "partition not at beginning of cylinder"; +# $csize += $_->{size} if $_->{pt_type} != 5; +# $wdsize += $_->{size} if $_->{pt_type} == 5; $_->{flags} |= 0x10 if $_->{mntpoint} eq '/'; - $_->{flags} |= 0x01 if partition_table::isSwap($_); - local $_->{start_cylinder} = $_->{start} / $hd->cylinder_size() - $sector; + $_->{flags} |= 0x01 if !isSwap($_); + local $_->{start_cylinder} = $_->{start} / $hd->cylinder_size - $sector; pack($format1, @$_{@$fields1}), pack($format2, @$_{@$fields2}); } @$pt; # $csize == $wdsize or die "partitions are not using whole disk space"; @@ -183,19 +186,20 @@ sub info { $info; } -sub clear_raw { +sub initialize { my ($hd) = @_; my $pt = { raw => [ ({}) x $nb_primary ], info => info($hd) }; #- handle special case for partition 2 which is whole disk. $pt->{raw}[2] = { - type => 5, #- the whole disk type. + pt_type => 5, #- the whole disk type. flags => 0, start_cylinder => 0, - size => $hd->{geom}{cylinders} * $hd->cylinder_size(), + size => $hd->{geom}{cylinders} * $hd->cylinder_size, }; - $pt; + $hd->{primary} = $pt; + bless $hd, 'partition::sun'; } 1; |