summaryrefslogtreecommitdiffstats
path: root/perl-install/partition_table
diff options
context:
space:
mode:
Diffstat (limited to 'perl-install/partition_table')
-rw-r--r--perl-install/partition_table/bsd.pm28
-rw-r--r--perl-install/partition_table/dmcrypt.pm41
-rw-r--r--perl-install/partition_table/dos.pm305
-rw-r--r--perl-install/partition_table/empty.pm14
-rw-r--r--perl-install/partition_table/gpt.pm342
-rw-r--r--perl-install/partition_table/lvm.pm38
-rw-r--r--perl-install/partition_table/lvm_PV.pm43
-rw-r--r--perl-install/partition_table/mac.pm72
-rw-r--r--perl-install/partition_table/raw.pm229
-rw-r--r--perl-install/partition_table/readonly.pm20
-rw-r--r--perl-install/partition_table/sun.pm33
11 files changed, 754 insertions, 411 deletions
diff --git a/perl-install/partition_table/bsd.pm b/perl-install/partition_table/bsd.pm
index e6af4e997..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;
@@ -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 cb687e6b0..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,56 +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, $chs) = @_;
+ 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 read {
+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_one {
my ($hd, $sector) = @_;
my $tmp;
@@ -64,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);
@@ -72,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;
@@ -87,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;
}
@@ -94,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 bb1cb82a4..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 6311a7da5..000000000
--- a/perl-install/partition_table/lvm_PV.pm
+++ /dev/null
@@ -1,43 +0,0 @@
-package partition_table::lvm_PV; # $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 2a8fe8df5..78e5469cd 100644
--- a/perl-install/partition_table/mac.pm
+++ b/perl-install/partition_table/mac.pm
@@ -1,12 +1,13 @@
-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;
@@ -78,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($$) {
@@ -95,7 +98,7 @@ sub adjustEnd($$) {
my ($_hd, $_part) = @_;
}
-sub read($$) {
+sub read_one {
my ($hd, $sector) = @_;
my $tmp;
@@ -139,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) {
@@ -148,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 {
@@ -159,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
@@ -172,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}}) {
@@ -184,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;
@@ -218,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}}) {
@@ -281,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;
}
@@ -354,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,
@@ -383,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 d8bcf8954..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,24 +100,98 @@ 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 {
@@ -113,74 +199,111 @@ sub openit {
my $F; sysopen($F, $hd->{file}, $o_mode || 0) && $F;
}
+sub can_add {
+ my ($hd) = @_;
+ !$_->{size} && !$_->{pt_type} || isExtended($_) and return 1 foreach @{$hd->{primary}{raw}};
+ 0;
+}
+
sub raw_removed {
my ($_hd, $_raw) = @_;
}
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);
}
-sub zero_MBR_and_dirty {
- my ($hd) = @_;
- my @parts = (partition_table::get_normal_parts($hd), if_($hd->{primary}{extended}, $hd->{primary}{extended}));
- partition_table::will_tell_kernel($hd, del => $_) foreach @parts;
- zero_MBR($hd);
+#- by default, we assume the kernel doesn't automatically reread partition table:
+sub need_to_tell_kernel {
+ my ($_hd) = @_;
+ 1;
+}
+
+sub read_primary {
+ my ($hd) = @_;
+
+ 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, $::testing ? 0 : 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 951a4b471..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,12 +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 $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};
@@ -70,7 +73,7 @@ sub compute_crc($) {
$crc;
}
-sub read($$) {
+sub read_one {
my ($hd, $sector) = @_;
my $tmp;
@@ -92,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 * $_] };
+ fs::type::set_pt_type($h, $infos_up[2 * $_]);
$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;
push @pt, $h;
}
@@ -105,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} ];
@@ -113,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,10 +134,10 @@ 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;
+# $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;
@@ -182,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,
};
- $pt;
+ $hd->{primary} = $pt;
+ bless $hd, 'partition::sun';
}
1;
generated by cgit v1.2.1 (git 2.21.0) at 2025-10-23 06:28:27 +0000