add mes5-2.6.33 branch

1 files changed, 613 insertions, 0 deletions

diff --git a/perl-install/partition_table.pm b/perl-install/partition_table.pm
new file mode 100644
index 000000000..86795e8e6
--- /dev/null
+++ b/perl-install/partition_table.pm
@@ -0,0 +1,613 @@
+package partition_table; # $Id: partition_table.pm 245972 2008-09-18 17:00:11Z pixel $
+
+use diagnostics;
+use strict;
+
+use common;
+use fs::type;
+use partition_table::raw;
+use detect_devices;
+use log;
+
+
+sub hd2minimal_part {
+    my ($hd) = @_;
+    { 
+	rootDevice => $hd->{device}, 
+	if_($hd->{usb_media_type}, is_removable => 1),
+    };
+}
+
+#- works for both hard drives and partitions ;p
+sub description {
+    my ($hd) = @_;
+    my $win = $hd->{device_windobe};
+
+    sprintf "%s%s (%s)", 
+      $hd->{device}, 
+      $win && " [$win:]", 
+	join(', ', 
+	     grep { $_ } 
+	       formatXiB($hd->{totalsectors} || $hd->{size}, 512),
+	       $hd->{info}, $hd->{mntpoint}, $hd->{fs_type});
+}
+
+sub adjustStartAndEnd {
+    my ($hd, $part) = @_;
+
+    $hd->adjustStart($part);
+    $hd->adjustEnd($part);
+}
+
+sub verifyNotOverlap {
+    my ($a, $b) = @_;
+    $a->{start} + $a->{size} <= $b->{start} || $b->{start} + $b->{size} <= $a->{start};
+}
+sub verifyInside {
+    my ($a, $b) = @_;
+    $b->{start} <= $a->{start} && $a->{start} + $a->{size} <= $b->{start} + $b->{size};
+}
+
+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($_)) {
+		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
+	    } else {
+		verifyNotOverlap($i, $_) or
+		  cdie sprintf("partitions sector #$i->{start} (%s) and sector #$_->{start} (%s) are overlapping!",
+			       formatXiB($i->{size}, 512), formatXiB($_->{size}, 512));
+	    }
+	}
+    }
+}
+sub verifyParts {
+    my ($hd) = @_;
+    verifyParts_(get_normal_parts($hd));
+}
+sub verifyPrimary {
+    my ($pt) = @_;
+    $_->{start} > 0 || arch() =~ /^sparc/ || 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} = _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 {
+    my ($hd) = @_;
+
+    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);
+	    $i++;
+	}
+	foreach (map { $_->{normal} } @{$hd->{extended} || []}) {
+	    my $dev = _compute_device_name($hd, $i);
+	    my $renumbered = $_->{device} && $dev ne $_->{device};
+	    if ($renumbered) {
+		require fs::mount;
+		eval { fs::mount::umount_part($_) }; #- at least try to umount it
+		will_tell_kernel($hd, del => $_, 'delay_del');
+		push @{$hd->{partitionsRenumbered}}, [ $_->{device}, $dev ];
+	    }
+	    $_->{part_number} = $i;
+	    compute_device_name($_, $hd);
+	    if ($renumbered) {
+		will_tell_kernel($hd, add => $_, 'delay_add');
+	    }
+	    $i++;
+	}
+    }
+
+    #- try to figure what the windobe drive letter could be!
+    #
+    #- 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}};
+
+    $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 @others;
+}
+
+sub remove_empty_extended {
+    my ($hd) = @_;
+    my $last = $hd->{primary}{extended} or return;
+    @{$hd->{extended}} = grep {
+	if ($_->{normal}) {
+	    $last = $_;
+	} else {
+	    %{$last->{extended}} = $_->{extended} ? %{$_->{extended}} : ();
+	}
+	$_->{normal};
+    } @{$hd->{extended}};
+    adjust_main_extended($hd);
+}
+
+sub adjust_main_extended {
+    my ($hd) = @_;
+
+    if (!is_empty_array_ref $hd->{extended}) {
+	my ($l, @l) = @{$hd->{extended}};
+
+	# the first is a special case, must recompute its real size
+	my $start = round_down($l->{normal}{start} - 1, $hd->{geom}{sectors});
+	my $end = $l->{normal}{start} + $l->{normal}{size};
+	my $only_linux = 1; my $has_win_lba = 0;
+	foreach (map { $_->{normal} } $l, @l) {
+	    $start = min($start, $_->{start});
+	    $end = max($end, $_->{start} + $_->{size});
+	    $only_linux &&= isTrueLocalFS($_) || isSwap($_);
+	    $has_win_lba ||= $_->{pt_type} == 0xc || $_->{pt_type} == 0xe;
+	}
+	$l->{start} = $hd->{primary}{extended}{start} = $start;
+	$l->{size} = $hd->{primary}{extended}{size} = $end - $start;
+    }
+    if (!@{$hd->{extended} || []} && $hd->{primary}{extended}) {
+	will_tell_kernel($hd, del => $hd->{primary}{extended});
+	%{$hd->{primary}{extended}} = (); #- modify the raw entry
+	delete $hd->{primary}{extended};
+    }
+    verifyParts($hd); #- verify everything is all right
+}
+
+sub adjust_local_extended {
+    my ($hd, $part) = @_;
+
+    my $extended = find { $_->{normal} == $part } @{$hd->{extended} || []} or return;
+    $extended->{size} = $part->{size} + $part->{start} - $extended->{start};
+
+    #- must write it there too because values are not shared
+    my $prev = find { $_->{extended}{start} == $extended->{start} } @{$hd->{extended} || []} or return;
+    $prev->{extended}{size} = $part->{size} + $part->{start} - $prev->{extended}{start};
+}
+
+sub get_normal_parts {
+    my ($hd) = @_;
+
+    @{$hd->{primary}{normal} || []}, map { $_->{normal} } @{$hd->{extended} || []};
+}
+
+sub get_normal_parts_and_holes {
+    my ($hd) = @_;
+    my ($start, $last) = ($hd->first_usable_sector, $hd->last_usable_sector);
+
+    ref($hd) or print("get_normal_parts_and_holes: bad hd" . backtrace(), "\n");
+
+    my $minimal_hole = put_in_hash({ pt_type => 0 }, hd2minimal_part($hd));
+
+    my @l = map {
+	my $current = $start;
+	$start = $_->{start} + $_->{size};
+	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);
+
+    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 {
+    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
+}
+
+sub initialize {
+    my ($hd, $o_type) = @_;
+
+    my $type = $o_type || _default_type($hd);
+
+    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;
+    }
+}
+
+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'),
+	  arch() =~ /^sparc/ ? ('sun', 'bsd') : ('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;
+		}
+	}
+    0;
+}
+
+sub read {
+    my ($hd) = @_;
+    read_primary($hd) or return 0;
+    eval {
+	my $need_removing_empty_extended;
+	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
+	    #- (windows XP generates such partition tables)
+	    remove_empty_extended($hd); #- includes adjust_main_extended
+	}
+	
+    }; 
+    die "extended partition: $@" if $@;
+
+    assign_device_numbers($hd);
+    remove_empty_extended($hd);
+
+    $hd->set_best_geometry_for_the_partition_table;
+    1;
+}
+
+sub read_extended {
+    my ($hd, $extended, $need_removing_empty_extended) = @_;
+
+    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;
+    @{$hd->{extended}} > 100 and die "oops, seems like we're looping here :(  (or you have more than 100 extended partitions!)";
+
+    if (@{$pt->{normal}} == 0) {
+	$$need_removing_empty_extended = 1;
+	delete $pt->{normal};
+	print "need_removing_empty_extended\n";
+    } elsif (@{$pt->{normal}} > 1) {
+	die "more than one normal partition in extended partition";
+    } else {
+	$pt->{normal} = $pt->{normal}[0];
+	#- in case of extended partitions, the start sector is local to the partition or to the first extended_part!
+	$pt->{normal}{start} += $pt->{start};
+
+	#- the following verification can broke an existing partition table that is
+	#- correctly read by fdisk or cfdisk. maybe the extended partition can be
+	#- recomputed to get correct size.
+	if (!verifyInside($pt->{normal}, $extended)) {
+	    $extended->{size} = $pt->{normal}{start} + $pt->{normal}{size};
+	    verifyInside($pt->{normal}, $extended) or die "partition $pt->{normal}{device} is not inside its extended partition";
+	}
+    }
+
+    if ($pt->{extended}) {
+	$pt->{extended}{start} += $hd->{primary}{extended}{start};
+	return read_extended($hd, $pt->{extended}, $need_removing_empty_extended);
+    } else {
+	1;
+    }
+}
+
+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);
+    } else {
+	my $part_number;
+	if ($o_part) {
+	    ($part_number) = $o_part->{device} =~ /(\d+)$/ or
+	      #- do not die, it occurs when we zero_MBR_and_dirty a raw_lvm_PV
+	      log::l("ERROR: will_tell_kernel bad device " . description($o_part)), return;
+	}
+
+	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 tell_kernel {
+    my ($hd, $tell_kernel) = @_;
+
+    my $F = partition_table::raw::openit($hd);
+
+    my $force_reboot = any { $_->[0] eq 'force_reboot' } @$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)) {
+	    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);
+	    } elsif ($action eq 'del') {
+		$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) {
+	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=$hd->{rebootNeeded}");
+
+	foreach (@magic_parts) {
+	    syscall_('mount', $_->{real_mntpoint}, $_->{fs_type}, c::MS_MGC_VAL()) or log::l(N("mount failed: ") . $!);
+	}
+    }
+}
+
+# write the partition table
+sub write {
+    my ($hd) = @_;
+    $hd->{isDirty} or return;
+    $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}}) {
+	foreach (@l) { 
+	    $_->{local_start} = $_->{start}; 
+	    $_->{active} ||= 0;
+	}
+	$l[0]{active} = 0x80 if !any { $_->{active} } @l;
+    }
+
+    #- last chance for verification, this make sure if an error is detected,
+    #- 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";
+
+    #- 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->{isDirty} = 0;
+
+    if (my $tell_kernel = delete $hd->{will_tell_kernel}) {
+	if (fs::type::is_dmraid($hd)) {
+	    fs::dmraid::call_dmraid('-an');
+	    fs::dmraid::call_dmraid('-ay');
+	} else {
+	    tell_kernel($hd, $tell_kernel);
+	}
+    }
+}
+
+sub active {
+    my ($hd, $part) = @_;
+
+    $_->{active} = 0 foreach @{$hd->{primary}{normal}};
+    $part->{active} = 0x80;
+    $hd->{isDirty} = 1;
+}
+
+
+# remove a normal partition from hard drive hd
+sub remove {
+    my ($hd, $part) = @_;
+    my $i;
+
+    #- first search it in the primary partitions
+    $i = 0; foreach (@{$hd->{primary}{normal}}) {
+	if ($_ eq $part) {
+	    will_tell_kernel($hd, del => $_);
+
+	    splice(@{$hd->{primary}{normal}}, $i, 1);
+	    %$_ = (); #- blank it
+
+	    $hd->raw_removed($hd->{primary}{raw});
+	    return 1;
+	}
+	$i++;
+    }
+
+    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};
+    }      
+
+    #- otherwise search it in extended partitions
+    foreach (@{$hd->{extended} || []}) {
+	$_->{normal} eq $part or next;
+
+	delete $_->{normal}; #- remove it
+	remove_empty_extended($hd);
+	assign_device_numbers($hd);
+
+	will_tell_kernel($hd, del => $part);
+	return 1;
+    }
+    0;
+}
+
+# create of partition at starting at `start', of size `size' and of type `pt_type' (nice comment, uh?)
+sub add_primary {
+    my ($hd, $part) = @_;
+
+    {
+	local $hd->{primary}{normal}; #- save it to fake an addition of $part, that way add_primary do not modify $hd if it fails
+	push @{$hd->{primary}{normal}}, $part;
+	adjust_main_extended($hd); #- verify
+	$hd->raw_add($hd->{primary}{raw}, $part);
+    }
+    push @{$hd->{primary}{normal}}, $part; #- really do it
+}
+
+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;
+	my $end = $e->{start} + $e->{size};
+	my $start = min($e->{start}, $part->{start});
+	$end = max($end, $part->{start} + $part->{size}) - $start;
+
+	{ #- faking a resizing of the main extended partition to test for problems
+	    local $e->{start} = $start;
+	    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.
+The only solution is to move your primary partitions to have the hole next to the extended partitions.");
+	}
+    }
+
+    if ($e && $part->{start} < $e->{start}) {
+	my $l = first(@{$hd->{extended}});
+
+	#- the first is a special case, must recompute its real size
+	$l->{start} = round_down($l->{normal}{start} - 1, $hd->cylinder_size);
+	$l->{size} = $l->{normal}{start} + $l->{normal}{size} - $l->{start};
+	my $ext = { %$l };
+	unshift @{$hd->{extended}}, { pt_type => 5, raw => [ $part, $ext, {}, {} ], normal => $part, extended => $ext };
+	#- size will be autocalculated :)
+    } else {
+	my ($ext, $ext_size) = is_empty_array_ref($hd->{extended}) ?
+	  ($hd->{primary}, -1) : #- -1 size will be computed by adjust_main_extended
+	  (top(@{$hd->{extended}}), $part->{size});
+	my %ext = (pt_type => $extended_type || 5, start => $part->{start}, size => $ext_size);
+
+	$hd->raw_add($ext->{raw}, \%ext);
+	$ext->{extended} = \%ext;
+	push @{$hd->{extended}}, { %ext, raw => [ $part, {}, {}, {} ], normal => $part };
+    }
+    $part->{start}++; $part->{size}--; #- let it start after the extended partition sector
+    adjustStartAndEnd($hd, $part);
+
+    adjust_main_extended($hd);
+}
+
+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";
+
+    set_isFormatted($part, 0);
+    put_in_hash($part, hd2minimal_part($hd));
+    $part->{start} ||= 1 if arch() !~ /^sparc/; #- 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' ||
+	$b_primaryOrExtended !~ /Extended/ && @{$hd->{primary}{normal} || []} < $nb_primaries) {
+	eval { add_primary($hd, $part) };
+	goto success if !$@;
+    }
+    if ($hd->hasExtended) {
+	eval { add_extended($hd, $part, $b_primaryOrExtended) };
+	goto success if !$@;
+    }
+    {
+	add_primary($hd, $part);
+    }
+  success:
+    assign_device_numbers($hd);
+    will_tell_kernel($hd, add => $part);
+}
+
+# search for the next partition
+sub next {
+    my ($hd, $part) = @_;
+
+    first(
+	  sort { $a->{start} <=> $b->{start} }
+	  grep { $_->{start} >= $part->{start} + $part->{size} }
+	  get_normal_parts($hd)
+	 );
+}
+sub next_start {
+    my ($hd, $part) = @_;
+    my $next = &next($hd, $part);
+    $next ? $next->{start} : $hd->last_usable_sector;
+}
+
+1;