diff options
Diffstat (limited to 'perl-install/partition_table.pm')
| -rw-r--r-- | perl-install/partition_table.pm | 673 |
1 files changed, 511 insertions, 162 deletions
diff --git a/perl-install/partition_table.pm b/perl-install/partition_table.pm index a7d06fb21..c1f90c566 100644 --- a/perl-install/partition_table.pm +++ b/perl-install/partition_table.pm @@ -1,125 +1,244 @@ -package partition_table; +package partition_table; # $Id$ -use diagnostics; -use strict; -use vars qw(@ISA %EXPORT_TAGS @EXPORT_OK @important_types); +#use diagnostics; +#use strict; +#use vars qw(@ISA %EXPORT_TAGS @EXPORT_OK @important_types @important_types2 @fields2save); +use Data::Dumper; @ISA = qw(Exporter); %EXPORT_TAGS = ( - types => [ qw(type2name type2fs name2type fs2type isExtended isExt2 isSwap isDos isWin isPrimary isNfs) ], + types => [ qw(type2name type2fs name2type fs2type isExtended isExt2 isReiserfs isTrueFS isSwap isDos isWin isFat isSunOS isOtherAvailableFS isPrimary isNfs isSupermount isRAID isMDRAID isHFS isNT isMountableRW isApplePartMap isLoopback) ], ); @EXPORT_OK = map { @$_ } values %EXPORT_TAGS; -use common qw(:common :system); +use common qw(:common :system :functional); use partition_table_raw; +use log; -@important_types = ("Linux native", "Linux swap", "DOS FAT16"); +@important_types = ('Linux native', arch() =~ /i.86/ ? 'ReiserFS' : (), 'Linux swap', 'Win98 FAT32'); +@important_types2 = ('Linux RAID'); + +@fields2save = qw(primary extended totalsectors isDirty needKernelReread); + my %types = ( - 0 => "Empty", - 1 => "DOS 12-bit FAT", - 2 => "XENIX root", - 3 => "XENIX usr", - 4 => "DOS 16-bit <32M", - 5 => "Extended", - 6 => "DOS FAT16", - 7 => "OS/2 HPFS", # or QNX? - 8 => "AIX", - 9 => "AIX bootable", - 10 => "OS/2 Boot Manager", - 0xb => "Win98 FAT32", - 0xc => "Win98 FAT32 0xb", - 0xe => "Win98 FAT32 0xc", - 0x12 => "Compaq setup", - 0x40 => "Venix 80286", - 0x51 => "Novell?", - 0x52 => "Microport", # or CPM? - 0x63 => "GNU HURD", # or System V/386? - 0x64 => "Novell Netware 286", - 0x65 => "Novell Netware 386", - 0x75 => "PC/IX", - 0x80 => "Old MINIX", # Minix 1.4a and earlier - - 0x81 => "Linux/MINIX", # Minix 1.4b and later - 0x82 => "Linux swap", - 0x83 => "Linux native", - - 0x93 => "Amoeba", - 0x94 => "Amoeba BBT", # (bad block table) - 0xa5 => "BSD/386", - 0xb7 => "BSDI fs", - 0xb8 => "BSDI swap", - 0xc7 => "Syrinx", - 0xdb => "CP/M", # or Concurrent DOS? - 0xe1 => "DOS access", - 0xe3 => "DOS R/O", - 0xf2 => "DOS secondary", - 0xff => "BBT" # (bad track table) + 0x0 => 'Empty', +arch() =~ /^ppc/ ? ( + 0x401 => 'Apple Partition', + 0x402 => 'Apple HFS Partition', +) : arch() =~ /^i.86/ ? ( + 0x183 => 'ReiserFS', +) : arch() =~ /^sparc/ ? ( + 0x1 => 'SunOS boot', + 0x2 => 'SunOS root', + 0x3 => 'SunOS swap', + 0x4 => 'SunOS usr', + 0x5 => 'Whole disk', + 0x6 => 'SunOS stand', + 0x7 => 'SunOS var', + 0x8 => 'SunOS home', +) : ( + 0x1 => 'DOS 12-bit FAT', + 0x2 => 'XENIX root', + 0x3 => 'XENIX /usr', + 0x4 => 'DOS 16-bit FAT (up to 32M)', + 0x5 => 'DOS 3.3+ Extended Partition', + 0x6 => 'DOS FAT16', + 0x7 => 'NTFS (or HPFS)', + 0x8 => 'OS/2 (v1.0-1.3 only) / AIX boot partition / SplitDrive / Commodore DOS / DELL partition spanning multiple drives / QNX 1.x and 2.x ("qny")', +), + 0x9 => 'AIX data partition / Coherent filesystem / QNX 1.x and 2.x ("qnz")', + 0xa => 'OS/2 Boot Manager / Coherent swap partition / OPUS', + 0xb => 'Win98 FAT32', + 0xc => 'Win98 FAT32, LBA-mapped', + 0xe => 'Win95: DOS 16-bit FAT, LBA-mapped', + 0xf => 'Win95: Extended partition, LBA-mapped', + 0x10 => 'OPUS (?)', + 0x11 => 'Hidden DOS 12-bit FAT', + 0x12 => 'Compaq config partition', + 0x14 => 'Hidden DOS 16-bit FAT <32M', + 0x16 => 'Hidden DOS 16-bit FAT >=32M', + 0x17 => 'Hidden IFS (e.g., HPFS)', + 0x18 => 'AST Windows swapfile', + 0x1b => 'Hidden WIN95 OSR2 32-bit FAT', + 0x1c => 'Hidden WIN95 OSR2 32-bit FAT, LBA-mapped', + 0x1e => 'Hidden FAT95', + 0x22 => 'Used for Oxygen Extended Partition Table by ekstazya@sprint.ca.', + 0x24 => 'NEC DOS 3.x', + 0x38 => 'THEOS ver 3.2 2gb partition', + 0x39 => 'THEOS ver 4 spanned partition', + 0x3a => 'THEOS ver 4 4gb partition', + 0x3b => 'THEOS ver 4 extended partition', + 0x3c => 'PartitionMagic recovery partition', + 0x40 => 'Venix 80286', + 0x41 => 'Linux/MINIX (sharing disk with DRDOS) / Personal RISC Boot / PPC PReP (Power PC Reference Platform) Boot', + 0x42 => 'Linux swap (sharing disk with DRDOS) / SFS (Secure Filesystem) / W2K marker', + 0x43 => 'Linux native (sharing disk with DRDOS)', + 0x45 => 'EUMEL/Elan', + 0x46 => 'EUMEL/Elan 0x46', + 0x47 => 'EUMEL/Elan 0x47', + 0x48 => 'EUMEL/Elan 0x48', + 0x4d => 'QNX4.x', + 0x4e => 'QNX4.x 2nd part', + 0x4f => 'QNX4.x 3rd part / Oberon partition', + 0x50 => 'OnTrack Disk Manager (older versions) RO', + 0x51 => 'OnTrack Disk Manager RW (DM6 Aux1) / Novell', + 0x52 => 'CP/M / Microport SysV/AT', + 0x53 => 'Disk Manager 6.0 Aux3', + 0x54 => 'Disk Manager 6.0 Dynamic Drive Overlay', + 0x55 => 'EZ-Drive', + 0x56 => 'Golden Bow VFeature Partitioned Volume. / DM converted to EZ-BIOS', + 0x57 => 'DrivePro', + 0x5c => 'Priam EDisk', + 0x61 => 'SpeedStor', + 0x63 => 'Unix System V (SCO, ISC Unix, UnixWare, ...), Mach, GNU Hurd', + 0x64 => 'PC-ARMOUR protected partition / Novell Netware 2.xx', + 0x65 => 'Novell Netware 3.xx or 4.xx', + 0x67 => 'Novell', + 0x68 => 'Novell 0x68', + 0x69 => 'Novell 0x69', + 0x70 => 'DiskSecure Multi-Boot', + 0x75 => 'IBM PC/IX', + 0x80 => 'MINIX until 1.4a', + 0x81 => 'MINIX since 1.4b, early Linux / Mitac disk manager', + 0x82 => 'Linux swap', + 0x83 => 'Linux native', + 0x84 => 'OS/2 hidden C: drive / Hibernation partition', + 0x85 => 'Linux extended partition', + 0x86 => 'Old Linux RAID partition superblock / NTFS volume set', + 0x87 => 'NTFS volume set', + 0x8a => 'Linux Kernel Partition (used by AiR-BOOT)', + 0x8e => 'Linux Logical Volume Manager partition', + 0x93 => 'Amoeba', + 0x94 => 'Amoeba bad block table', + 0x99 => 'DCE376 logical drive', + 0xa0 => 'IBM Thinkpad hibernation partition / Phoenix NoteBIOS Power Management "Save-to-Disk" partition', + 0xa5 => 'BSD/386, 386BSD, NetBSD, FreeBSD', + 0xa6 => 'OpenBSD', + 0xa7 => 'NEXTSTEP', + 0xa9 => 'NetBSD', + 0xaa => 'Olivetti Fat 12 1.44Mb Service Partition', + 0xb7 => 'BSDI filesystem', + 0xb8 => 'BSDI swap partition', + 0xbe => 'Solaris boot partition', + 0xc0 => 'CTOS / REAL/32 secure small partition', + 0xc1 => 'DRDOS/secured (FAT-12)', + 0xc4 => 'DRDOS/secured (FAT-16, < 32M)', + 0xc6 => 'DRDOS/secured (FAT-16, >= 32M) / Windows NT corrupted FAT16 volume/stripe set', + 0xc7 => 'Windows NT corrupted NTFS volume/stripe set / Syrinx boot', + 0xcb => 'reserved for DRDOS/secured (FAT32)', + 0xcc => 'reserved for DRDOS/secured (FAT32, LBA)', + 0xcd => 'CTOS Memdump?', + 0xce => 'reserved for DRDOS/secured (FAT16, LBA)', + 0xd0 => 'REAL/32 secure big partition', + 0xd1 => 'Old Multiuser DOS secured FAT12', + 0xd4 => 'Old Multiuser DOS secured FAT16 <32M', + 0xd5 => 'Old Multiuser DOS secured extended partition', + 0xd6 => 'Old Multiuser DOS secured FAT16 >=32M', + 0xd8 => 'CP/M-86', + 0xdb => 'Digital Research CP/M, Concurrent CP/M, Concurrent DOS / CTOS (Convergent Technologies OS -Unisys) / KDG Telemetry SCPU boot', + 0xdd => 'Hidden CTOS Memdump?', + 0xe1 => 'DOS access or SpeedStor 12-bit FAT extended partition', + 0xe3 => 'DOS R/O or SpeedStor', + 0xe4 => 'SpeedStor 16-bit FAT extended partition < 1024 cyl.', + 0xeb => 'BeOS', + 0xee => 'Indication that this legacy MBR is followed by an EFI header', + 0xef => 'Partition that contains an EFI file system', + 0xf1 => 'SpeedStor', + 0xf2 => 'DOS 3.3+ secondary partition', + 0xf4 => 'SpeedStor large partition / Prologue single-volume partition', + 0xf5 => 'Prologue multi-volume partition', + 0xfd => 'Linux RAID', + 0xfe => 'SpeedStor > 1024 cyl. or LANstep / IBM PS/2 IML (Initial Microcode Load) partition, located at the end of the disk. / Windows NT Disk Administrator hidden partition / Linux Logical Volume Manager partition (old)', + 0xff => 'Xenix Bad Block Table', ); my %type2fs = ( +arch() =~ /^ppc/ ? ( + 0x07 => 'hpfs', +) : ( + 0x07 => 'ntfs', +), +arch() !~ /sparc/ ? ( 0x01 => 'vfat', 0x04 => 'vfat', 0x05 => 'ignore', 0x06 => 'vfat', - 0x07 => 'hpfs', +) : ( + 0x01 => 'ufs', + 0x02 => 'ufs', + 0x04 => 'ufs', + 0x06 => 'ufs', + 0x07 => 'ufs', + 0x08 => 'ufs', +), 0x0b => 'vfat', 0x0c => 'vfat', 0x0e => 'vfat', + 0x1b => 'vfat', + 0x1c => 'vfat', + 0x1e => 'vfat', 0x82 => 'swap', 0x83 => 'ext2', - nfs => 'nfs', # hack + 0x183=> 'reiserfs', + 0x402 => 'hfs', + nfs => 'nfs', #- hack ); + my %types_rev = reverse %types; my %fs2type = reverse %type2fs; 1; -sub type2name($) { $types{$_[0]} } +sub important_types { + $::expert and return sort values %types; + @important_types, $::beginner ? () : @important_types2; +} + +sub type2name($) { $types{$_[0]} || $_[0] } sub type2fs($) { $type2fs{$_[0]} } -sub name2type($) { $types_rev{$_[0]} } sub fs2type($) { $fs2type{$_[0]} } +sub name2type($) { + local ($_) = @_; + /0x(.*)/ ? hex $1 : $types_rev{$_} || $_; +} -sub isExtended($) { $_[0]->{type} == 5 } -sub isSwap($) { $type2fs{$_[0]->{type}} eq 'swap' } -sub isExt2($) { $type2fs{$_[0]->{type}} eq 'ext2' } -sub isDos($) { $ {{ 1=>1, 4=>1, 6=>1 }}{$_[0]->{type}} } -sub isWin($) { $ {{ 0xb=>1, 0xc=>1, 0xe=>1 }}{$_[0]->{type}} } -sub isNfs($) { $_[0]->{type} eq 'nfs' } # small hack +sub isWholedisk($) { arch() =~ /^sparc/ && $_[0]{type} == 5 } +sub isExtended($) { arch() !~ /^sparc/ && ($_[0]{type} == 5 || $_[0]{type} == 0xf || $_[0]{type} == 0x85) } +sub isRAID($) { $_[0]{type} == 0xfd } +sub isMDRAID { $_[0]{device} =~ /^md/ } +sub isSwap($) { $type2fs{$_[0]{type}} eq 'swap' } +sub isExt2($) { $type2fs{$_[0]{type}} eq 'ext2' } +sub isReiserfs($) { $type2fs{$_[0]{type}} eq 'reiserfs' } +sub isDos($) { arch() !~ /^sparc/ && $ {{ 1=>1, 4=>1, 6=>1 }}{$_[0]{type}} } +sub isWin($) { $ {{ 0xb=>1, 0xc=>1, 0xe=>1, 0x1b=>1, 0x1c=>1, 0x1e=>1 }}{$_[0]{type}} } +sub isFat($) { isDos($_[0]) || isWin($_[0]) } +sub isSunOS($) { arch() =~ /sparc/ && $ {{ 0x1=>1, 0x2=>1, 0x4=>1, 0x6=>1, 0x7=>1, 0x8=>1 }}{$_[0]{type}} } +sub isSolaris($) { 0; } #- hack to search for getting the difference ? TODO +sub isOtherAvailableFS($) { isFat($_[0]) || isSunOS($_[0]) } #- other OS that linux can access its filesystem +sub isNfs($) { $_[0]{type} eq 'nfs' } #- small hack +sub isNT($) { arch() !~ /^sparc/ && $_[0]{type} == 0x7 } +sub isSupermount($) { $_[0]{type} eq 'supermount' } +sub isHFS($) { $type2fs{$_[0]{type}} eq 'hfs' } +sub isHiddenMacPart { defined $_[0]{isMap} } +sub isLoopback { defined $_[0]{loopback_file} } +sub isTrueFS { isExt2($_[0]) || isReiserfs($_[0]) } +sub isMountableRW { isTrueFS($_[0]) || isOtherAvailableFS($_[0]) } sub isPrimary($$) { my ($part, $hd) = @_; - foreach (@{$hd->{primary}->{raw}}) { $part eq $_ and return 1; } + foreach (@{$hd->{primary}{raw}}) { $part eq $_ and return 1; } 0; } -sub cylinder_size($) { - my ($hd) = @_; - $hd->{geom}->{sectors} * $hd->{geom}->{heads}; -} - -sub adjustStart($$) { - my ($hd, $part) = @_; - my $end = $part->{start} + $part->{size}; - - $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}; -} -sub adjustEnd($$) { +sub adjustStartAndEnd($$) { my ($hd, $part) = @_; - my $end = $part->{start} + $part->{size}; - $end = round_down($end, cylinder_size($hd)); - $part->{size} = $end - $part->{start}; -} -sub adjustStartAndEnd($$) { - &adjustStart; - &adjustEnd; + $hd->adjustStart($part); + $hd->adjustEnd($part); } sub verifyNotOverlap($$) { @@ -131,58 +250,171 @@ sub verifyInside($$) { $b->{start} <= $a->{start} && $a->{start} + $a->{size} <= $b->{start} + $b->{size}; } +sub verifyParts_ { + foreach my $i (@_) { + foreach (@_) { + next if !$i || !$_ || $i == $_ || isWholedisk($i); #- avoid testing twice on whole disk for simplicity :-) + isWholedisk($_) ? + verifyInside($i, $_) || cdie sprintf("partitions sector #$i->{start} (%dMB) is not inside whole disk (%dMB)!", $i->{size} >> 11, $_->{size} >> 11) : + verifyNotOverlap($i, $_) || cdie sprintf("partitions sector #$i->{start} (%dMB) and sector #$_->{start} (%dMB) are overlapping!", $i->{size} >> 11, $_->{size} >> 11); + } + } +} +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 assign_device_numbers($) { my ($hd) = @_; - my $i = 1; foreach (@{$hd->{primary}->{raw}}, map { $_->{normal} } @{$hd->{extended}}) { - $_->{device} = $hd->{prefix} . $i++; + my $i = 1; + $_->{device} = $hd->{prefix} . $i++ foreach @{$hd->{primary}{raw}}, + map { $_->{normal} } @{$hd->{extended} || []}; + + #- 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($_) } @{$hd->{primary}{normal}}; + + $i = ord 'C'; + $c->{device_windobe} = chr($i++) if $c; + $_->{device_windobe} = chr($i++) foreach grep { isFat($_) } 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 &&= isTrueFS($_) || isSwap($_); + $has_win_lba ||= $_->{type} == 0xc || $_->{type} == 0xe; + } + $l->{start} = $hd->{primary}{extended}{start} = $start; + $l->{size} = $hd->{primary}{extended}{size} = $end - $start; + $hd->{primary}{extended}{type} = $only_linux ? 0x85 : $has_win_lba ? 0xf : 0x5 if !$::expert; + } + unless (@{$hd->{extended} || []} || !$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) = @_; + + foreach (@{$hd->{extended} || []}) { + $_->{normal} == $part or next; + $_->{size} = $part->{size} + $part->{start} - $_->{start}; + last; } } sub get_normal_parts($) { my ($hd) = @_; - @{$hd->{primary}->{normal} || []}, map { $_->{normal} } @{$hd->{extended} || []} + #- HACK !! + $hd->{raid} and return grep {$_} @{$hd->{raid}}; + $hd->{loopback} and return grep {$_} @{$hd->{loopback}}; + + @{$hd->{primary}{normal} || []}, map { $_->{normal} } @{$hd->{extended} || []} +} + +sub get_holes($) { + my ($hd) = @_; + + my $start = arch() eq "alpha" ? 2048 : 1; + + map { + my $current = $start; + $start = $_->{start} + $_->{size}; + { start => $current, size => $_->{start} - $current } + } sort { $a->{start} <=> $b->{start} } grep { !isWholedisk($_) } get_normal_parts($hd), { start => $hd->{totalsectors}, size => 0 }; } 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 = arch() =~ /^sparc/ ? ('sun', 'bsd', 'unknown') : ('dos', 'bsd', 'sun', 'mac', 'unknown'); + foreach ('empty', @parttype) { + /unknown/ and die "unknown partition table format"; + eval { + 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); + } - my $pt = partition_table_raw::read($hd, $sector) or return; - - my @extended = grep { isExtended($_) } @$pt; + my @extended = $hd->hasExtended ? grep { isExtended($_) } @$pt : (); my @normal = grep { $_->{size} && $_->{type} && !isExtended($_) } @$pt; @extended > 1 and die "more than one extended partition"; - foreach (@normal, @extended) { - $_->{rootDevice} = $hd->{device}; - } - { raw => $pt, extended => $extended[0], normal => \@normal }; + $_->{rootDevice} = $hd->{device} foreach @normal, @extended; + { raw => $pt, extended => $extended[0], normal => \@normal, info => $info }; } sub read($;$) { my ($hd, $clearall) = @_; - my $pt = $clearall ? { raw => [ {}, {}, {}, {} ] } : read_one($hd, 0) || return 0; - + if ($clearall) { + partition_table_raw::zero_MBR_and_dirty($hd); + return 1; + } + my $pt = read_one($hd, 0) or return 0; $hd->{primary} = $pt; - $hd->{extended} = undef; - $clearall and return $hd->{isDirty} = 1; - - my @l = (@{$pt->{normal}}, $pt->{extended}); - foreach my $i (@l) { foreach (@l) { - $i != $_ and verifyNotOverlap($i, $_) || die "partitions $i->{device} and $_->{device} are overlapping!"; - }} - + undef $hd->{extended}; + verifyPrimary($pt); eval { $pt->{extended} and read_extended($hd, $pt->{extended}) || return 0; }; die "extended partition: $@" if $@; + assign_device_numbers($hd); + remove_empty_extended($hd); 1; } -sub read_extended($$) { +sub read_extended { my ($hd, $extended) = @_; my $pt = read_one($hd, $extended->{start}) or return 0; @@ -192,49 +424,69 @@ sub read_extended($$) { @{$hd->{extended}} > 100 and die "oops, seems like we're looping here :( (or you have more than 100 extended partitions!)"; @{$pt->{normal}} <= 1 or die "more than one normal partition in extended partition"; - @{$pt->{normal}} >= 1 or die "no normal partition in extended partition"; - $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}; - - verifyInside($pt->{normal}, $extended) or die "partition $pt->{normal}->{device} is not inside its extended partition"; + @{$pt->{normal}} >= 1 or cdie "no normal partition in extended partition"; + $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}; + $pt->{extended}{start} += $hd->{primary}{extended}{start}; read_extended($hd, $pt->{extended}) or return 0; } 1; } -# give a hard drive hd, write the partition data +# write the partition table sub write($) { my ($hd) = @_; + $hd->{isDirty} or return; - # set first primary partition active if no primary partitions are marked as active. - for ($hd->{primary}->{raw}) { - (grep { $_->{local_start} = $_->{start}; $_->{active} ||= 0 } @$_) or $_->[0]->{active} = 0x80; + #- set first primary partition active if no primary partitions are marked as active. + for ($hd->{primary}{raw}) { + (grep { $_->{local_start} = $_->{start}; $_->{active} ||= 0 } @$_) or $_->[0]{active} = 0x80; } - partition_table_raw::write($hd, 0, $hd->{primary}->{raw}) or die "writing of partition table failed"; - 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}; + #- last chance for verification, this make sure if an error is detected, + #- it will never be writed back on partition table. + verifyParts($hd); - partition_table_raw::write($hd, $_->{start}, $_->{raw}) or die "writing of partition table failed"; + $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; + $hd->{hasBeenDirty} = 1; #- used in undo (to know if undo should believe isDirty or not) - # now sync disk and re-read the partition table - sync(); - partition_table_raw::kernel_read($hd); + #- now sync disk and re-read the partition table + if ($hd->{needKernelReread}) { + sync(); + $hd->kernel_read; + $hd->{needKernelReread} = 0; + } } sub active($$) { my ($hd, $part) = @_; - foreach (@{$hd->{primary}->{normal}}) { $_->{active} = 0; } - $part->{active} = 0x80; + $_->{active} = 0 foreach @{$hd->{primary}{normal}}; + $part->{active} = 0x80; + $hd->{isDirty} = 1; } @@ -243,63 +495,120 @@ sub remove($$) { my ($hd, $part) = @_; my $i; - # first search it in the primary partitions - $i = 0; foreach (@{$hd->{primary}->{normal}}) { + #- first search it in the primary partitions + $i = 0; foreach (@{$hd->{primary}{normal}}) { if ($_ eq $part) { - splice(@{$hd->{primary}->{normal}}, $i, 1); - %$_ = (); + splice(@{$hd->{primary}{normal}}, $i, 1); + %$_ = (); #- blank it - return $hd->{isDirty} = 1; + return $hd->{isDirty} = $hd->{needKernelReread} = 1; } $i++; } - # otherwise search it in extended partitions - my $last = $hd->{primary}->{extended}; - $i = 0; foreach (@{$hd->{extended}}) { - if ($_->{normal} eq $part) { - %{$last->{extended}} = $_->{extended} ? %{$_->{extended}} : (); - splice(@{$hd->{extended}}, $i, 1); - - return $hd->{isDirty} = 1; - } - $last = $_; - $i++; + + my ($first, $second, $third) = map { $_->{normal} } @{$hd->{extended} || []}; + if ($third && $first eq $part) { + die "Can't 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); + + return $hd->{isDirty} = $hd->{needKernelReread} = 1; } 0; } # create of partition at starting at `start', of size `size' and of type `type' (nice comment, uh?) -# !be carefull!, no verification is done (start -> start+size must be free) -sub add($$) { +sub add_primary($$) { my ($hd, $part) = @_; - $part->{notFormatted} = 1; - $part->{isFormatted} = 0; - $part->{rootDevice} = $hd->{device}; - $hd->{isDirty} = 1; - adjustStartAndEnd($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 + raw_add($hd->{primary}{raw}, $part); + } + push @{$hd->{primary}{normal}}, $part; #- really do it +} - if (is_empty_array_ref($hd->{primary}->{normal})) { - raw_add($hd->{primary}->{raw}, $part); - @{$hd->{primary}->{normal}} = $part; - } else { - foreach (@{$hd->{extended}}) { - $_->{normal} and next; - raw_add($_->{raw}, $part); - $_->{normal} = $part; - return; +sub add_extended { + arch() =~ /^sparc/ and die _("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't 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 +_("You have a hole in your partition table but I can't 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}}, { 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}, $hd->{totalsectors} - $part->{start}) : + ($hd->{primary}, -1) : #- -1 size will be computed by adjust_main_extended (top(@{$hd->{extended}}), $part->{size}); - my %ext = ( type => 5, start => $part->{start}, size => $ext_size ); - + my %ext = ( type => $extended_type || 5, start => $part->{start}, size => $ext_size ); + 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, $primaryOrExtended, $forceNoAdjust) = @_; - $part->{start}++; $part->{size}--; # let it start after the extended partition sector - adjustStartAndEnd($hd, $part); + get_normal_parts($hd) >= ($hd->{device} =~ /^sd/ ? 15 : 63) and cdie "maximum number of partitions handled by linux reached"; + + $part->{notFormatted} = 1; + $part->{isFormatted} = 0; + $part->{rootDevice} = $hd->{device}; + $hd->{isDirty} = $hd->{needKernelReread} = 1; + $part->{start} ||= 1 if arch() !~ /^sparc/; #- starting at sector 0 is not allowed + adjustStartAndEnd($hd, $part) unless $forceNoAdjust; + + my $e = $hd->{primary}{extended}; + + if (arch() =~ /^sparc/ || + $primaryOrExtended eq 'Primary' || + $primaryOrExtended !~ /Extended/ && is_empty_array_ref($hd->{primary}{normal})) { + eval { add_primary($hd, $part) }; + return unless $@; + } + eval { add_extended($hd, $part, $primaryOrExtended) } if $hd->hasExtended; #- try adding extended + if ($@ || !$hd->hasExtended) { + eval { add_primary($hd, $part) }; + die $@ if $@; #- send the add extended error which should be better } } @@ -308,7 +617,7 @@ sub next($$) { my ($hd, $part) = @_; first( - sort { $a->{start} <=> $b->{start} } + sort { $a->{start} <=> $b->{start} } grep { $_->{start} >= $part->{start} + $part->{size} } get_normal_parts($hd) ); @@ -319,8 +628,12 @@ sub next_start($$) { $next ? $next->{start} : $hd->{totalsectors}; } - -sub raw_add($$) { +sub can_raw_add { + my ($hd) = @_; + $_->{size} || $_->{type} or return 1 foreach @{$hd->{primary}{raw}}; + 0; +} +sub raw_add { my ($raw, $part) = @_; foreach (@$raw) { @@ -331,3 +644,39 @@ sub raw_add($$) { die "raw_add: partition table already full"; } +sub load($$;$) { + my ($hd, $file, $force) = @_; + + local *F; + open F, $file or die _("Error reading file %s", $file); + + my $h; + { + local $/ = "\0"; + eval <F>; + } + $@ and die _("Restoring from file %s failed: %s", $file, $@); + + ref $h eq 'ARRAY' or die _("Bad backup file"); + + my %h; @h{@fields2save} = @$h; + + $h{totalsectors} == $hd->{totalsectors} or $force or cdie "bad totalsectors"; + + #- unsure we don't modify totalsectors + local $hd->{totalsectors}; + + @{$hd}{@fields2save} = @$h; + + delete @$_{qw(isMounted isFormatted notFormatted toFormat toFormatUnsure)} foreach get_normal_parts($hd); + $hd->{isDirty} = $hd->{needKernelReread} = 1; +} + +sub save($$) { + my ($hd, $file) = @_; + my @h = @{$hd}{@fields2save}; + local *F; + open F, ">$file" + and print F Data::Dumper->Dump([\@h], ['$h']), "\0" + or die _("Error writing to file %s", $file); +} |