1 files changed, 239 insertions, 95 deletions

diff --git a/perl-install/partition_table.pm b/perl-install/partition_table.pm
index d67508384..230cdc6a3 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,6 +9,20 @@ use partition_table::raw;
 use detect_devices;
 use log;
 
+=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 {
     my ($hd) = @_;
@@ -18,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};
@@ -32,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);
 }
@@ -51,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
@@ -74,7 +107,7 @@ sub verifyParts {
 }
 sub verifyPrimary {
     my ($pt) = @_;
-    $_->{start} > 0 || arch() =~ /^sparc/ || die "partition must NOT start at sector 0" foreach @{$pt->{normal}};
+    $_->{start} > 0 || die "partition must NOT start at sector 0" foreach @{$pt->{normal}};
     verifyParts_(@{$pt->{normal}}, $pt->{extended});
 }
 
@@ -95,24 +128,7 @@ 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->{device} 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);
@@ -141,11 +157,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;
 }
 
@@ -221,26 +237,50 @@ 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 => min($last - $start, $hd->max_partition_size), %$minimal_hole } if $start < $hd->max_partition_start;
     grep { !isEmpty($_) || $_->{size} >= $hd->cylinder_size } @l;
 }
 
-sub _default_type {
+
+=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) = @_;
 
-    arch() =~ /ia64/ ? 'gpt' : 
-      arch() eq "alpha" ? "bsd" : 
-      arch() =~ /^sparc/ ? "sun" : 
-      arch() eq "ppc" && detect_devices::get_mac_model() !~ /^IBM/ ? "mac" : 
-	$hd->{totalsectors} > 4 * 1024 * 1024 * 2048 ? 'lvm' : "dos"; #- default to LVM on full disk when >4TB
+    # 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';
+    $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 $type = $o_type || _default_type($hd);
+    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);
@@ -251,39 +291,58 @@ sub initialize {
         partition_table::dos::compute_CHS($hd, $part);
 	$hd->{primary}{raw}[0] = $part;
     }
+
+    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.
+
+=cut
+
 sub read_primary {
     my ($hd) = @_;
 
-    #- 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!
-	my @parttype = (
-	  if_(arch() =~ /^ia64/, 'gpt'),
-          # gpt must be tried before dos as it presents a fake compatibility mbr
-	  arch() =~ /^sparc/ ? ('sun', 'bsd') : ('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");
-		    return 1;
-		}
-	}
+    #- 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) = @_;
     read_primary($hd) or return 0;
@@ -308,6 +367,14 @@ 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) = @_;
 
@@ -348,12 +415,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) {
@@ -363,48 +443,61 @@ 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) {
-	# only keep the last action on the partition number
-	# that way we do not del/add the same partition, and this helps udev :)
-	foreach (reverse(uniq_ { $_->[1] } reverse @$tell_kernel)) {
+	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) 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);
+	$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) {
@@ -413,7 +506,39 @@ 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;
@@ -432,18 +557,18 @@ 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;
 
     if (my $tell_kernel = delete $hd->{will_tell_kernel}) {
@@ -451,7 +576,7 @@ sub write {
 	    fs::dmraid::call_dmraid('-an');
 	    fs::dmraid::call_dmraid('-ay');
 	} else {
-	    tell_kernel($hd, $tell_kernel);
+	    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
@@ -467,8 +592,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;
@@ -489,7 +618,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
@@ -501,12 +630,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) = @_;
 
@@ -520,15 +656,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;
@@ -538,7 +672,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.");
 	}
     }
@@ -571,17 +705,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} =~ /^(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 !$@;
@@ -595,10 +728,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) = @_;
 
@@ -614,4 +754,8 @@ sub next_start {
     $next ? $next->{start} : $hd->last_usable_sector;
 }
 
+=back
+
+=cut
+
 1;