1 files changed, 286 insertions, 151 deletions

diff --git a/perl-install/partition_table.pm b/perl-install/partition_table.pm
index 651de92fe..09c8f74d9 100644
--- a/perl-install/partition_table.pm
+++ b/perl-install/partition_table.pm
@@ -1,4 +1,4 @@
-package partition_table; # $Id$
+package partition_table;
 
 use diagnostics;
 use strict;
@@ -9,7 +9,19 @@ use partition_table::raw;
 use detect_devices;
 use log;
 
-our @fields2save = qw(primary extended totalsectors isDirty will_tell_kernel);
+=head1 SYNOPSYS
+
+B<partition_table> enables to read & write partitions on various partition schemes (DOS, GPT, BSD, ...)
+
+It holds base partition table management methods, it manages
+appriopriate partition_table_XXX object according to what has been read
+as XXX partition table type.
+
+=head1 Functions
+
+=over
+
+=cut
 
 
 sub hd2minimal_part {
@@ -20,7 +32,12 @@ sub hd2minimal_part {
     };
 }
 
-#- works for both hard drives and partitions ;p
+=item description($hd)
+
+Works for both hard disk drives and partitions ;p
+
+=cut
+
 sub description {
     my ($hd) = @_;
     my $win = $hd->{device_windobe};
@@ -34,9 +51,27 @@ sub description {
 	       $hd->{info}, $hd->{mntpoint}, $hd->{fs_type});
 }
 
+=item align_to_MB_boundaries($part)
+
+Align partition start to the next MB boundary
+
+=cut
+
+sub align_to_MB_boundaries {
+    my ($part) = @_;
+
+    my $end = $part->{start} + $part->{size};
+    $part->{start} = round_up($part->{start}, MB(1));
+    $part->{size} = $end - $part->{start};
+}
+
 sub adjustStartAndEnd {
     my ($hd, $part) = @_;
 
+    # always align partition start to MB boundaries
+    # (this accounts for devices with non-512 physical sector sizes):
+    align_to_MB_boundaries($part);
+
     $hd->adjustStart($part);
     $hd->adjustEnd($part);
 }
@@ -53,12 +88,8 @@ sub verifyInside {
 sub verifyParts_ {
     foreach my $i (@_) {
 	foreach (@_) {
-	    next if !$i || !$_ || $i == $_ || isWholedisk($i) || isExtended($i); #- avoid testing twice for simplicity :-)
-	    if (isWholedisk($_)) {
-		verifyInside($i, $_) or
-		  cdie sprintf("partition sector #$i->{start} (%s) is not inside whole disk (%s)!",
-			       formatXiB($i->{size}, 512), formatXiB($_->{size}, 512));
-	    } elsif (isExtended($_)) {
+	    next if !$i || !$_ || $i == $_ || isExtended($i); #- avoid testing twice for simplicity :-)
+	    if (isExtended($_)) {
 		verifyNotOverlap($i, $_) or
 		  log::l(sprintf("warning partition sector #$i->{start} (%s) is overlapping with extended partition!",
 				 formatXiB($i->{size}, 512))); #- only warning for this one is acceptable
@@ -76,14 +107,21 @@ sub verifyParts {
 }
 sub verifyPrimary {
     my ($pt) = @_;
-    $_->{start} > 0 || arch() =~ /^sparc/ || die "partition must NOT start at sector 0" foreach @{$pt->{normal}};
+    if (!$pt->{is_hybrid_iso}) {
+        $_->{start} > 0 || die "partition must NOT start at sector 0" foreach @{$pt->{normal}};
+    }
     verifyParts_(@{$pt->{normal}}, $pt->{extended});
 }
 
 sub compute_device_name {
     my ($part, $hd) = @_;
-    $part->{device} = $hd->{prefix} . $part->{part_number};
-    $part->{devfs_device} = $hd->{devfs_prefix} . '/part' . $part->{part_number};
+    $part->{device} = _compute_device_name($hd, $part->{part_number});
+}
+
+sub _compute_device_name {
+    my ($hd, $nb) = @_;
+    my $prefix = $hd->{prefix} || devices::prefix_for_dev($hd->{device});
+    $prefix . $nb;
 }
 
 sub assign_device_numbers {
@@ -92,31 +130,14 @@ sub assign_device_numbers {
     my $i = 1;
     my $start = 1; 
     
-    #- on PPC we need to assign device numbers to the holes too - big FUN!
-    #- not if it's an IBM machine using a DOS partition table though
-    if (arch() =~ /ppc/ && detect_devices::get_mac_model() !~ /^IBM/) {
-	#- first sort the normal parts
-	$hd->{primary}{normal} = [ sort { $a->{start} <=> $b->{start} } @{$hd->{primary}{normal}} ];
-    
-	#- now loop through them, assigning partition numbers - reserve one for the holes
-	foreach (@{$hd->{primary}{normal}}) {
-	    if ($_->{start} > $start) {
-		log::l("PPC: found a hole on $hd->{prefix} before $_->{start}, skipping device..."); 
-		$i++;
-	    }
-	    $_->{part_number} = $i;
-	    compute_device_name($_, $hd);
-	    $start = $_->{start} + $_->{size};
-	    $i++;
-	}
-    } else {
+    {
 	foreach (@{$hd->{primary}{raw}}) {
 	    $_->{part_number} = $i;
 	    compute_device_name($_, $hd);
 	    $i++;
 	}
 	foreach (map { $_->{normal} } @{$hd->{extended} || []}) {
-	    my $dev = $hd->{prefix} . $i;
+	    my $dev = _compute_device_name($hd, $i);
 	    my $renumbered = $_->{device} && $dev ne $_->{device};
 	    if ($renumbered) {
 		require fs::mount;
@@ -138,11 +159,11 @@ sub assign_device_numbers {
     #- first verify there's at least one primary dos partition, otherwise it
     #- means it is a secondary disk and all will be false :(
     #-
-    my ($c, @others) = grep { isFat_or_NTFS($_) } @{$hd->{primary}{normal}};
+    my ($c, @others) = grep { isnormal_Fat_or_NTFS($_) } @{$hd->{primary}{normal}};
 
     $i = ord 'C';
     $c->{device_windobe} = chr($i++) if $c;
-    $_->{device_windobe} = chr($i++) foreach grep { isFat_or_NTFS($_) } map { $_->{normal} } @{$hd->{extended}};
+    $_->{device_windobe} = chr($i++) foreach grep { isnormal_Fat_or_NTFS($_) } map { $_->{normal} } @{$hd->{extended}};
     $_->{device_windobe} = chr($i++) foreach @others;
 }
 
@@ -218,64 +239,121 @@ sub get_normal_parts_and_holes {
 	my $hole = { start => $current, size => $_->{start} - $current, %$minimal_hole };
 	put_in_hash($hole, hd2minimal_part($hd));
 	$hole, $_;
-    } sort { $a->{start} <=> $b->{start} } grep { !isWholedisk($_) } get_normal_parts($hd);
+    } sort { $a->{start} <=> $b->{start} } get_normal_parts($hd);
 
-    push @l, { start => $start, size => $last - $start, %$minimal_hole };
+    push @l, { start => $start, size => min($last - $start, $hd->max_partition_size), %$minimal_hole } if $start < $hd->max_partition_start;
     grep { !isEmpty($_) || $_->{size} >= $hd->cylinder_size } @l;
 }
 
-sub read_one($$) {
-    my ($hd, $sector) = @_;
-    my ($pt, $info);
-
-    #- it can be safely considered that the first sector is used to probe the partition table
-    #- but other sectors (typically for extended partition ones) have to match this type!
-    if (!$sector) {
-	my @parttype = (
-	  if_(arch() =~ /^ia64/, 'gpt'),
-	  arch() =~ /^sparc/ ? ('sun', 'bsd') : ('dos', 'bsd', 'sun', 'mac'),
-	);
-	foreach ('empty', @parttype, 'unknown') {
-	    /unknown/ and die "unknown partition table format on disk " . $hd->{file};
-	    eval {
-		# perl_checker: require partition_table::bsd
-		# perl_checker: require partition_table::dos
-		# perl_checker: require partition_table::empty
-		# perl_checker: require partition_table::gpt
-		# perl_checker: require partition_table::mac
-		# perl_checker: require partition_table::sun
-		require "partition_table/$_.pm";
-		bless $hd, "partition_table::$_";
-		($pt, $info) = $hd->read($sector);
-		log::l("found a $_ partition table on $hd->{file} at sector $sector");
-	    };
-	    $@ or last;
-	}
-    } else {
-	#- keep current blessed object for that, this means it is neccessary to read sector 0 before.
-	($pt, $info) = $hd->read($sector);
+
+=item default_type($hd)
+
+Returns the default type of $hd ('gpt' or 'dos' depending on whether we're running under UEFI or
+whether the disk size is too big for a MBR partition table.
+
+=cut
+
+sub default_type {
+    my ($hd) = @_;
+
+    # default to GPT on UEFI systems and disks > 2TB
+    is_uefi() || $hd->{totalsectors} > 2 * 1024 * 1024 * 2048 ? 'gpt' : "dos";
+}
+
+sub _get_disk_type {
+    my ($hd) = @_;
+    my $current = c::get_disk_type($hd->{file});
+    $current = 'dos' if $current eq 'msdos';
+    # When a disk contains a FS directly (no partition table) parted calls it loop
+    $current = '' if $current eq 'loop';
+    $hd->{current_pt_table_type} = $current;
+}
+
+=item initialize($hd, $o_type)
+
+Initialize a $hd object.
+
+Expect $hd->{file} to point to the raw device disk.
+
+The optional $o_type parameter enables to override the detected disk type (eg: 'dos', 'gpt', ...).
+
+=cut
+
+sub initialize {
+    my ($hd, $o_type) = @_;
+
+    my $current = _get_disk_type($hd);
+    my $type = $o_type || $current || default_type($hd);
+    $hd->{pt_table_type} = $type;
+
+    require "partition_table/$type.pm";
+    "partition_table::$type"->initialize($hd);
+
+    delete $hd->{extended};
+    if (detect_devices::is_xbox()) {
+        my $part = { start => 1, size => 15632048, pt_type => 0x0bf, isFormatted => 1 };
+        partition_table::dos::compute_CHS($hd, $part);
+	$hd->{primary}{raw}[0] = $part;
     }
 
-    my @extended = $hd->hasExtended ? grep { isExtended($_) } @$pt : ();
-    my @normal = grep { $_->{size} && !isEmpty($_) && !isExtended($_) } @$pt;
-    my $nb_special_empty = int(grep { $_->{size} && isEmpty($_) } @$pt);
+    will_tell_kernel($hd, 'init');
+}
+
+=item read_primary($hd)
+
+Identify the partition table type of $hd and return a blessed $pt of type partition_table::TYPE.
 
-    @extended > 1 and die "more than one extended partition";
+=cut
+
+sub read_primary {
+    my ($hd) = @_;
 
-    put_in_hash($_, hd2minimal_part($hd)) foreach @normal, @extended;
-    { raw => $pt, extended => $extended[0], normal => \@normal, info => $info, nb_special_empty => $nb_special_empty };
+    #- The libparted ped_disk_probe() function opens the raw device for R/W, which causes a
+    #- change event to be sent for every partition when the raw device is closed again. So
+    #- be careful not to call this function more than once. (mga#15752)
+    _get_disk_type($hd);
+
+    my @parttype = (
+      # gpt must be tried before dos as it presents a fake compatibility mbr
+      'gpt', 'lvm', 'dmcrypt', 'dos', 'bsd', 'sun', 'mac',
+    );
+    foreach ('empty', @parttype, 'unknown') {
+        /unknown/ and die "unknown partition table format on disk " . $hd->{file};
+
+        # perl_checker: require partition_table::bsd
+        # perl_checker: require partition_table::dos
+        # perl_checker: require partition_table::empty
+        # perl_checker: require partition_table::dmcrypt
+        # perl_checker: require partition_table::lvm
+        # perl_checker: require partition_table::gpt
+        # perl_checker: require partition_table::mac
+        # perl_checker: require partition_table::sun
+        require "partition_table/$_.pm";
+        bless $hd, "partition_table::$_";
+        if ($hd->read_primary) {
+            log::l("found a $_ partition table on $hd->{file} at sector 0");
+            #- Don't rely on the type returned by libparted - use what we have discovered.
+            $hd->{pt_table_type} = $_ if $_ ne 'empty';
+            return 1;
+        }
+    }
+    0;
 }
 
+
+=item read($hd)
+
+Read the partition table of $hd.
+
+=cut
+
 sub read {
     my ($hd) = @_;
-    my $pt = read_one($hd, 0) or return 0;
-    $hd->{primary} = $pt;
-    undef $hd->{extended};
-    verifyPrimary($pt);
+    read_primary($hd) or return 0;
     eval {
 	my $need_removing_empty_extended;
-	if ($pt->{extended}) {
-	    read_extended($hd, $pt->{extended}, \$need_removing_empty_extended) or return 0;
+	if ($hd->{primary}{extended}) {
+	    read_extended($hd, $hd->{primary}{extended}, \$need_removing_empty_extended) or return 0;
 	}
 	if ($need_removing_empty_extended) {
 	    #- special case when hda5 is empty, it must be skipped
@@ -293,10 +371,21 @@ sub read {
     1;
 }
 
+=item read_extended($hd, $extended, $need_removing_empty_extended)
+
+Actually load the partition list from the blessed $pt of type partition_table::TYPE.
+
+It uses partition_table::TYPE::read_one()
+
+=cut
+
 sub read_extended {
     my ($hd, $extended, $need_removing_empty_extended) = @_;
 
-    my $pt = read_one($hd, $extended->{start}) or return 0;
+    my $pt = do {
+	my ($pt, $info) = $hd->read_one($extended->{start}) or return 0;
+	partition_table::raw::pt_info_to_primary($hd, $pt, $info);
+    };
     $pt = { %$extended, %$pt };
 
     push @{$hd->{extended}}, $pt;
@@ -330,12 +419,25 @@ sub read_extended {
     }
 }
 
+=item will_tell_kernel($hd, $action, $o_part, $o_delay)
+
+Rembmer the actions to perform on the partition table that the kernel will later be made aware of.
+
+=cut
+
 sub will_tell_kernel {
     my ($hd, $action, $o_part, $o_delay) = @_;
 
     if ($action eq 'resize') {
 	will_tell_kernel($hd, del => $o_part);
 	will_tell_kernel($hd, add => $o_part);
+    } elsif ($action eq 'init') {
+	# We will tell the kernel to reread the partition table, so no need to remember
+	# previous changes.
+	delete $hd->{will_tell_kernel};
+	delete $hd->{will_tell_kerneldelay_add};
+	delete $hd->{will_tell_kerneldelay_del};
+	push @{$hd->{will_tell_kernel} ||= []}, [ $action, () ];
     } else {
 	my $part_number;
 	if ($o_part) {
@@ -345,47 +447,62 @@ sub will_tell_kernel {
 	}
 
 	my @para =
-	  $action eq 'force_reboot' ? () :
 	  $action eq 'add' ? ($part_number, $o_part->{start}, $o_part->{size}) :
 	  $action eq 'del' ? $part_number :
 	  internal_error("unknown action $action");
 
 	push @{$hd->{'will_tell_kernel' . ($o_delay || '')} ||= []}, [ $action, @para ];
     }
-    if (!$o_delay) {
-	foreach my $delay ('delay_del', 'delay_add') {
-	    my $l = delete $hd->{"will_tell_kernel$delay"} or next;
-	    push @{$hd->{will_tell_kernel} ||= []}, @$l;
-	}
-    }
     $hd->{isDirty} = 1;
 }
 
+sub will_tell_kernel_delayed {
+    my ($hd) = @_;
+    foreach my $delay ('delay_del', 'delay_add') {
+	my $l = delete $hd->{"will_tell_kernel$delay"} or next;
+	push @{$hd->{will_tell_kernel} ||= []}, @$l;
+    }
+}
+
+=item tell_kernel($hd, $tell_kernel)
+
+Tell the kernel that the partition layout has changed.
+
+Take a list of [$action, $part_number, $o_start, $o_size].
+Action can be either 'add' or 'del'.
+Size is not needed when deleting a partition.
+
+eg: ['add', '3', '5000', '1000']
+
+=cut
+
 sub tell_kernel {
     my ($hd, $tell_kernel) = @_;
 
     my $F = partition_table::raw::openit($hd);
 
-    my $force_reboot = any { $_->[0] eq 'force_reboot' } @$tell_kernel;
+    my $force_reboot = $hd->{rebootNeeded} || any { $_->[0] eq 'init' } @$tell_kernel;
     if (!$force_reboot) {
 	foreach (@$tell_kernel) {
 	    my ($action, $part_number, $o_start, $o_size) = @$_;
 	    
 	    if ($action eq 'add') {
-		$force_reboot ||= !c::add_partition(fileno $F, $part_number, $o_start, $o_size);
+		$force_reboot ||= !c::add_partition(fileno($F), $part_number, $o_start, $o_size);
 	    } elsif ($action eq 'del') {
-		$force_reboot ||= !c::del_partition(fileno $F, $part_number);
+		$force_reboot ||= !c::del_partition(fileno($F), $part_number);
 	    }
-	    log::l("tell kernel $action ($hd->{device} $part_number $o_start $o_size), rebootNeeded is now " . bool2text($hd->{rebootNeeded}));
+	    log::l("tell kernel $action ($hd->{device} $part_number $o_start $o_size) force_reboot=$force_reboot rebootNeeded=$hd->{rebootNeeded}");
 	}
     }
+
     if ($force_reboot) {
+	# FIXME Handle LVM/dmcrypt/RAID
 	my @magic_parts = grep { $_->{isMounted} && $_->{real_mntpoint} } get_normal_parts($hd);
 	foreach (@magic_parts) {
 	    syscall_('umount', $_->{real_mntpoint}) or log::l(N("error unmounting %s: %s", $_->{real_mntpoint}, $!));
 	}
-	$hd->{rebootNeeded} = !ioctl($F, c::BLKRRPART(), 0);
-	log::l("tell kernel force_reboot ($hd->{device}), rebootNeeded is now $hd->{rebootNeeded}.");
+	$hd->{rebootNeeded} = !c::tell_kernel_to_reread_partition_table($hd->{file});
+	log::l("tell kernel force_reboot ($hd->{device}), rebootNeeded=$hd->{rebootNeeded}");
 
 	foreach (@magic_parts) {
 	    syscall_('mount', $_->{real_mntpoint}, $_->{fs_type}, c::MS_MGC_VAL()) or log::l(N("mount failed: ") . $!);
@@ -393,11 +510,43 @@ sub tell_kernel {
     }
 }
 
-# write the partition table
+=item write($hd)
+
+Write the partition table
+
+The partition_table_XXX object is expected to provide three functions to
+support writing the partition table:
+
+=over
+
+=item * start_write()
+
+start_write() is called once at the beginning to initiate the write operation,
+
+=item * write()
+
+write() is then called one or more times (depending on whether there are any
+extended partitions),
+
+=item * end_write().
+
+and end_write() is called once to complete the write operation.
+
+=back
+
+For partition table types that support extended partitions (e.g.  DOS),
+start_write() is expected to return a file handle to the raw device which is
+then passed to write() and end_write(), allowing the entire table to be written
+before closing the raw device. For partition table types that don't support
+extended partitions, this is optional, and the entire write operation can be
+performed in the single call to write().
+
+=cut
+
 sub write {
     my ($hd) = @_;
     $hd->{isDirty} or return;
-    $hd->{readonly} and die "a read-only partition table should not be dirty!";
+    $hd->{readonly} and internal_error("a read-only partition table should not be dirty ($hd->{device})!");
 
     #- set first primary partition active if no primary partitions are marked as active.
     if (my @l = @{$hd->{primary}{raw}}) {
@@ -412,24 +561,31 @@ sub write {
     #- it will never be writed back on partition table.
     verifyParts($hd);
 
-    $hd->write(0, $hd->{primary}{raw}, $hd->{primary}{info}) or die "writing of partition table failed";
-
+    my $handle = $hd->start_write();
+    $hd->write($handle, 0, $hd->{primary}{raw}, $hd->{primary}{info}) or die "writing of partition table failed";
     #- should be fixed but a extended exist with no real extended partition, that blanks mbr!
-    if (arch() !~ /^sparc/) {
 	foreach (@{$hd->{extended}}) {
 	    # in case of extended partitions, the start sector must be local to the partition
 	    $_->{normal}{local_start} = $_->{normal}{start} - $_->{start};
 	    $_->{extended} and $_->{extended}{local_start} = $_->{extended}{start} - $hd->{primary}{extended}{start};
 
-	    $hd->write($_->{start}, $_->{raw}) or die "writing of partition table failed";
+	    $hd->write($handle, $_->{start}, $_->{raw}) or die "writing of partition table failed";
 	}
-    }
+    $hd->end_write($handle);
+    $hd->{current_pt_table_type} = $hd->{pt_table_type};
     $hd->{isDirty} = 0;
-    $hd->{hasBeenDirty} = 1; #- used in undo (to know if undo should believe isDirty or not)
 
     if (my $tell_kernel = delete $hd->{will_tell_kernel}) {
-	tell_kernel($hd, $tell_kernel);
+	if (fs::type::is_dmraid($hd)) {
+	    fs::dmraid::call_dmraid('-an');
+	    fs::dmraid::call_dmraid('-ay');
+	} else {
+	    tell_kernel($hd, $tell_kernel) if $hd->need_to_tell_kernel();
+	}
     }
+    # get major/minor again after writing the partition table so that we got them for dynamic devices
+    # (eg: for SCSI like devices with kernel-2.6.28+):
+    fs::get_major_minor([ get_normal_parts($hd) ]);
 }
 
 sub active {
@@ -440,8 +596,12 @@ sub active {
     $hd->{isDirty} = 1;
 }
 
+=item remove($hd, $part)
+
+Remove a normal partition from hard disk drive $hd
+
+=cut
 
-# remove a normal partition from hard drive hd
 sub remove {
     my ($hd, $part) = @_;
     my $i;
@@ -462,7 +622,7 @@ sub remove {
 
     my ($first, $second, $third) = map { $_->{normal} } @{$hd->{extended} || []};
     if ($third && $first eq $part) {
-	die "Can not handle removing hda5 when hda6 is not the second partition" if $second->{start} > $third->{start};
+	die "Cannot handle removing hda5 when hda6 is not the second partition" if $second->{start} > $third->{start};
     }      
 
     #- otherwise search it in extended partitions
@@ -474,12 +634,19 @@ sub remove {
 	assign_device_numbers($hd);
 
 	will_tell_kernel($hd, del => $part);
+	#- schedule renumbering after deleting the partition
+	will_tell_kernel_delayed($hd);
 	return 1;
     }
     0;
 }
 
-# create of partition at starting at `start', of size `size' and of type `pt_type' (nice comment, uh?)
+=item add_primary($hd, $part)
+
+Create of partition at starting at `start', of size `size' and of type `pt_type'
+
+=cut
+
 sub add_primary {
     my ($hd, $part) = @_;
 
@@ -493,15 +660,13 @@ sub add_primary {
 }
 
 sub add_extended {
-    arch() =~ /^sparc|ppc/ and die N("Extended partition not supported on this platform");
-
     my ($hd, $part, $extended_type) = @_;
     $extended_type =~ s/Extended_?//;
 
     my $e = $hd->{primary}{extended};
 
     if ($e && !verifyInside($part, $e)) {
-	#-die "sorry, can not add outside the main extended partition" unless $::unsafe;
+	#-die "sorry, cannot add outside the main extended partition" unless $::unsafe;
 	my $end = $e->{start} + $e->{size};
 	my $start = min($e->{start}, $part->{start});
 	$end = max($end, $part->{start} + $part->{size}) - $start;
@@ -511,7 +676,7 @@ sub add_extended {
 	    local $e->{size} = $end - $start;
 	    eval { verifyPrimary($hd->{primary}) };
 	    $@ and die
-N("You have a hole in your partition table but I can not use it.
+N("You have a hole in your partition table but I cannot use it.
 The only solution is to move your primary partitions to have the hole next to the extended partitions.");
 	}
     }
@@ -544,17 +709,16 @@ The only solution is to move your primary partitions to have the hole next to th
 sub add {
     my ($hd, $part, $b_primaryOrExtended, $b_forceNoAdjust) = @_;
 
-    get_normal_parts($hd) >= ($hd->{device} =~ /^rd/ ? 7 : $hd->{device} =~ /^(sd|ida|cciss|ataraid)/ ? 15 : 63) and cdie "maximum number of partitions handled by linux reached";
+    get_normal_parts($hd) >= ($hd->{device} =~ /^rd/ ? 7 : $hd->{device} =~ /^(ida|cciss)/ ? 15 : 63) and cdie "maximum number of partitions handled by linux reached";
 
     set_isFormatted($part, 0);
     put_in_hash($part, hd2minimal_part($hd));
-    $part->{start} ||= 1 if arch() !~ /^sparc/; #- starting at sector 0 is not allowed
+    $part->{start} ||= 1; #- starting at sector 0 is not allowed
     adjustStartAndEnd($hd, $part) unless $b_forceNoAdjust;
 
     my $nb_primaries = $hd->{device} =~ /^rd/ ? 3 : 1;
 
-    if (arch() =~ /^sparc|ppc/ ||
-	$b_primaryOrExtended eq 'Primary' ||
+    if ($b_primaryOrExtended eq 'Primary' ||
 	$b_primaryOrExtended !~ /Extended/ && @{$hd->{primary}{normal} || []} < $nb_primaries) {
 	eval { add_primary($hd, $part) };
 	goto success if !$@;
@@ -568,10 +732,17 @@ sub add {
     }
   success:
     assign_device_numbers($hd);
+    #- schedule renumbering before adding the partition
+    will_tell_kernel_delayed($hd);
     will_tell_kernel($hd, add => $part);
 }
 
-# search for the next partition
+=item next($hd, $part)
+
+Search for the next partition
+
+=cut
+
 sub next {
     my ($hd, $part) = @_;
 
@@ -584,47 +755,11 @@ sub next {
 sub next_start {
     my ($hd, $part) = @_;
     my $next = &next($hd, $part);
-    $next ? $next->{start} : $hd->{totalsectors};
+    $next ? $next->{start} : $hd->last_usable_sector;
 }
 
-sub load {
-    my ($hd, $file, $b_force) = @_;
+=back
 
-    my $F;
-    if (ref $file) {
-	$F = $file;
-    } else {
-	open($F, $file) or die N("Error reading file %s", $file);
-    }
-
-    my $h;
-    {
-	local $/ = "\0";
-	eval <$F>;
-    }
-    $@ and die N("Restoring from file %s failed: %s", $file, $@);
-
-    ref($h) eq 'ARRAY' or die N("Bad backup file");
-
-    my %h; @h{@fields2save} = @$h;
-
-    $h{totalsectors} == $hd->{totalsectors} or $b_force or cdie "bad totalsectors";
-
-    #- unsure we do not modify totalsectors
-    local $hd->{totalsectors};
-
-    @$hd{@fields2save} = @$h;
-
-    delete @$_{qw(isMounted isFormatted notFormatted toFormat toFormatUnsure)} foreach get_normal_parts($hd);
-    will_tell_kernel($hd, 'force_reboot'); #- just like undo, do not force write_partitions so that user can see the new partition table but can still discard it
-}
-
-sub save {
-    my ($hd, $file) = @_;
-    my @h = @$hd{@fields2save};
-    require Data::Dumper;
-    eval { output($file, Data::Dumper->Dump([\@h], ['$h']), "\0") }
-      or die N("Error writing to file %s", $file);
-}
+=cut
 
 1;