diff options
Diffstat (limited to 'perl-install/partition_table.pm')
| -rw-r--r-- | perl-install/partition_table.pm | 828 |
1 files changed, 387 insertions, 441 deletions
diff --git a/perl-install/partition_table.pm b/perl-install/partition_table.pm index 9e6118385..09c8f74d9 100644 --- a/perl-install/partition_table.pm +++ b/perl-install/partition_table.pm @@ -1,300 +1,77 @@ -package partition_table; # $Id$ +package partition_table; use diagnostics; use strict; -use vars qw(@ISA %EXPORT_TAGS @EXPORT_OK @important_types @important_types2 @fields2save @bad_types); - -@ISA = qw(Exporter); -%EXPORT_TAGS = ( - types => [ qw(type2name type2fs name2type fs2type isExtended isExt2 isThisFs isTrueFS isSwap isDos isWin isFat isFat_or_NTFS isSunOS isOtherAvailableFS isPrimary isRawLVM isRawRAID isRAID isLVM isMountableRW isNonMountable isPartOfLVM isPartOfRAID isPartOfLoopback isLoopback isMounted isBusy isSpecial maybeFormatted isApple isAppleBootstrap isEfi) ], -); -@EXPORT_OK = map { @$_ } values %EXPORT_TAGS; - use common; +use fs::type; use partition_table::raw; use detect_devices; use log; -@important_types = ('Linux native', 'Linux swap', - if_(arch() =~ /i.86/, 'Journalised FS: ext3', 'Journalised FS: ReiserFS', 'Journalised FS: JFS', 'Journalised FS: XFS', 'DOS FAT16', 'FAT32'), - if_(arch() =~ /ia64/, 'Journalised FS: ext3', 'Journalised FS: ReiserFS', 'Journalised FS: XFS', 'FAT32'), - if_(arch() =~ /x86_64/, 'Journalised FS: ext3', 'Journalised FS: ReiserFS', 'FAT32'), - if_(arch() =~ /ppc/, 'Journalised FS: ext3', 'Journalised FS: ReiserFS', 'Journalised FS: JFS', 'Journalised FS: XFS', 'Apple HFS Partition', 'Apple Bootstrap')); -@important_types2 = ('Linux RAID', 'Linux Logical Volume Manager partition'); - -@fields2save = qw(primary extended totalsectors isDirty needKernelReread); - -@bad_types = ('Empty', 'DOS 3.3+ Extended Partition', 'Win95: Extended partition, LBA-mapped', 'Linux extended partition'); - -my %types = ( - 0x0 => 'Empty', -if_(arch() =~ /^ppc/, - 0x183 => 'Journalised FS: ReiserFS', - 0x283 => 'Journalised FS: XFS', - 0x383 => 'Journalised FS: JFS', - 0x483 => 'Journalised FS: ext3', - 0x401 => 'Apple Partition', - 0x401 => 'Apple Bootstrap', - 0x402 => 'Apple HFS Partition', -), if_(arch() =~ /^i.86/, - 0x107 => 'NTFS', - 0x183 => 'Journalised FS: ReiserFS', - 0x283 => 'Journalised FS: XFS', - 0x383 => 'Journalised FS: JFS', - 0x483 => 'Journalised FS: ext3', -), if_(arch() =~ /^ia64/, - 0x100 => 'Various', - 0x183 => 'Journalised FS: ReiserFS', - 0x283 => 'Journalised FS: XFS', - 0x483 => 'Journalised FS: ext3', -), if_(arch() =~ /^x86_64/, - 0x183 => 'Journalised FS: ReiserFS', - 0x483 => 'Journalised FS: ext3', -), if_(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', -), if_(arch() =~ /^i.86/, - 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 => '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/HP 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', - 0x35 => 'JFS (OS/2)', - 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 => 'Windows Dynamic Partition', - 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 => 'EFI GPT', - 0xef => 'EFI (FAT-12/16/32)', - 0xf1 => 'SpeedStor 0xf1', - 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', -) : ( - 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', - 0xef => 'vfat', - 0x107 => 'ntfs', - 0x183 => 'reiserfs', - 0x283 => 'xfs', - 0x383 => 'jfs', - 0x483 => 'ext3', - 0x401 => 'apple', - 0x402 => 'hfs', -); - -my %types_rev = reverse %types; -my %fs2type = reverse %type2fs; +=head1 SYNOPSYS +B<partition_table> enables to read & write partitions on various partition schemes (DOS, GPT, BSD, ...) -1; +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. -sub important_types() { - my @l = (@important_types, if_($::expert, @important_types2, sort values %types)); - difference2(\@l, \@bad_types); -} - -sub type2fs { $type2fs{$_[0]{type}} || $_[0]{type} } -sub fs2type { $fs2type{$_[0]} || $_[0] } -sub type2name { $types{$_[0]} || $_[0] } -sub name2type { - local ($_) = @_; - /0x(.*)/ ? hex $1 : $types_rev{$_} || $_; -} - -sub isEfi { arch() =~ /ia64/ && $_[0]{type} == 0xef } -sub isWholedisk { arch() =~ /^sparc/ && $_[0]{type} == 5 } -sub isExtended { arch() !~ /^sparc/ && ($_[0]{type} == 5 || $_[0]{type} == 0xf || $_[0]{type} == 0x85) } -sub isRawLVM { $_[0]{type} == 0x8e } -sub isRawRAID { $_[0]{type} == 0xfd } -sub isSwap { type2fs($_[0]) eq 'swap' } -sub isExt2 { type2fs($_[0]) eq 'ext2' } -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 isFat_or_NTFS { isDos($_[0]) || isWin($_[0]) || $_[0]{type} == 0x107 } -sub isSunOS { arch() =~ /sparc/ && ${{ 0x1 => 1, 0x2 => 1, 0x4 => 1, 0x6 => 1, 0x7 => 1, 0x8 => 1 }}{$_[0]{type}} } -sub isApple { type2fs($_[0]) eq 'apple' && defined $_[0]{isDriver} } -sub isAppleBootstrap { type2fs($_[0]) eq 'apple' && defined $_[0]{isBoot} } -sub isHiddenMacPart { defined $_[0]{isMap} } - -sub isThisFs { type2fs($_[1]) eq $_[0] } -sub isTrueFS { member(type2fs($_[0]), qw(ext2 reiserfs xfs jfs ext3)) } - -sub isOtherAvailableFS { isEfi($_[0]) || isFat_or_NTFS($_[0]) || isSunOS($_[0]) || isThisFs('hfs', $_[0]) } #- other OS that linux can access its filesystem -sub isMountableRW { (isTrueFS($_[0]) || isOtherAvailableFS($_[0])) && !isThisFs('ntfs', $_[0]) } -sub isNonMountable { - my ($part) = @_; - isRawRAID($part) || isRawLVM($part) || isThisFs("ntfs", $part) && !$part->{isFormatted} && $part->{notFormatted}; +=head1 Functions + +=over + +=cut + + +sub hd2minimal_part { + my ($hd) = @_; + { + rootDevice => $hd->{device}, + if_($hd->{usb_media_type}, is_removable => 1), + }; } -sub isPartOfLVM { defined $_[0]{lvm} } -sub isPartOfRAID { defined $_[0]{raid} } -sub isPartOfLoopback { defined $_[0]{loopback} } -sub isRAID { $_[0]{device} =~ /^md/ } -sub isUBD { $_[0]{device} =~ /^ubd/ } #- should be always true during an $::uml_install -sub isLVM { $_[0]{VG_name} } -sub isLoopback { defined $_[0]{loopback_file} } -sub isMounted { $_[0]{isMounted} } -sub isBusy { isMounted($_[0]) || isPartOfRAID($_[0]) || isPartOfLVM($_[0]) || isPartOfLoopback($_[0]) } -sub isSpecial { isRAID($_[0]) || isLVM($_[0]) || isLoopback($_[0]) || isUBD($_[0]) } -sub maybeFormatted { $_[0]{isFormatted} || !$_[0]{notFormatted} } +=item description($hd) + +Works for both hard disk drives and partitions ;p +=cut -#- works for both hard drives and partitions ;p sub description { my ($hd) = @_; my $win = $hd->{device_windobe}; - sprintf "%s%s (%s%s%s%s)", + sprintf "%s%s (%s)", $hd->{device}, $win && " [$win:]", - formatXiB($hd->{totalsectors} || $hd->{size}, 512), - $hd->{info} && ", $hd->{info}", - $hd->{mntpoint} && ", " . $hd->{mntpoint}, - $hd->{type} && ", " . type2name($hd->{type}); + join(', ', + grep { $_ } + formatXiB($hd->{totalsectors} || $hd->{size}, 512), + $hd->{info}, $hd->{mntpoint}, $hd->{fs_type}); } -sub isPrimary { - my ($part, $hd) = @_; - foreach (@{$hd->{primary}{raw}}) { $part eq $_ and return 1 } - 0; +=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); } @@ -311,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 @@ -334,44 +107,49 @@ 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} = _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->{prefix} before $_->{start}, skipping device..."); - $i++; - } - $_->{device} = $hd->{prefix} . $i; - $_->{devfs_device} = $hd->{devfs_prefix} . '/part' . $i; - $start = $_->{start} + $_->{size}; - $i++; - } - } else { + { foreach (@{$hd->{primary}{raw}}) { - $_->{device} = $hd->{prefix} . $i; - $_->{devfs_device} = $hd->{devfs_prefix} . '/part' . $i; + $_->{part_number} = $i; + compute_device_name($_, $hd); $i++; } foreach (map { $_->{normal} } @{$hd->{extended} || []}) { - my $dev = $hd->{prefix} . $i; - push @{$hd->{partitionsRenumbered}}, [ $_->{device}, $dev ] if $_->{device} && $dev ne $_->{device}; - $_->{device} = $dev; - $_->{devfs_device} = $hd->{devfs_prefix} . '/part' . $i; + 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++; } } @@ -381,14 +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 :( #- - #- isFat_or_NTFS isn't true for 0x7 partitions, only for 0x107. - #- alas 0x107 is not set correctly at this stage - #- solution: don't bother with 0x7 vs 0x107 here - my ($c, @others) = grep { isFat_or_NTFS($_) || $_->{type} == 0x7 } @{$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($_) || $_->{type} == 0x7 } map { $_->{normal} } @{$hd->{extended}}; + $_->{device_windobe} = chr($i++) foreach grep { isnormal_Fat_or_NTFS($_) } map { $_->{normal} } @{$hd->{extended}}; $_->{device_windobe} = chr($i++) foreach @others; } @@ -419,13 +194,14 @@ sub adjust_main_extended { 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; + $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}; } @@ -446,7 +222,7 @@ sub adjust_local_extended { sub get_normal_parts { my ($hd) = @_; - @{$hd->{primary}{normal} || []}, map { $_->{normal} } @{$hd->{extended} || []} + @{$hd->{primary}{normal} || []}, map { $_->{normal} } @{$hd->{extended} || []}; } sub get_normal_parts_and_holes { @@ -455,70 +231,130 @@ sub get_normal_parts_and_holes { 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, type => 0, rootDevice => $hd->{device} }; + 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 => $last - $start, type => 0, rootDevice => $hd->{device} }; - grep { $_->{type} || $_->{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, 'lvm_PV', '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::lvm_PV - # 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); + } 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; +} + + +=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} && $_->{type} && !isExtended($_) } @$pt; - my $nb_special_empty = int(grep { $_->{size} && $_->{type} == 0 } @$pt); + will_tell_kernel($hd, 'init'); +} + +=item read_primary($hd) - @extended > 1 and die "more than one extended partition"; +Identify the partition table type of $hd and return a blessed $pt of type partition_table::TYPE. - $_->{rootDevice} = $hd->{device} foreach @normal, @extended; - { raw => $pt, extended => $extended[0], normal => \@normal, info => $info, nb_special_empty => $nb_special_empty }; +=cut + +sub read_primary { + my ($hd) = @_; + + #- 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; - $pt->{extended} and read_extended($hd, $pt->{extended}, \$need_removing_empty_extended) || 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 #- (windows XP generates such partition tables) @@ -530,13 +366,26 @@ sub read { assign_device_numbers($hd); remove_empty_extended($hd); + + $hd->set_best_geometry_for_the_partition_table; 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; @@ -570,11 +419,134 @@ sub read_extended { } } -# write the partition table +=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) { + ($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 '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 ]; + } + $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 = $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); + } 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) { + # 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} = !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: ") . $!); + } + } +} + +=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}}) { @@ -589,44 +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 ($hd->{needKernelReread} && ref($hd->{needKernelReread}) eq 'ARRAY' && $::isStandalone) { - #- we've only been adding partitions. Try special add_partition (using BLKPG_ADD_PARTITION) - my $F = partition_table::raw::openit($hd) or goto force_reread; - - foreach (@{$hd->{needKernelReread}}) { - c::add_partition(fileno $F, $_->{start}, $_->{size}, $_->{device} =~ /(\d+)$/) - or goto force_reread; - } - } elsif ($hd->{needKernelReread}) { - force_reread: - #- now sync disk and re-read the partition table - common::sync(); - 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->kernel_read; - foreach (@magic_parts) { - syscall_('mount', $_->{real_mntpoint}, type2fs($_), c::MS_MGC_VAL()) or log::l(N("mount failed: ") . $!); + 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) if $hd->need_to_tell_kernel(); } } - $hd->{needKernelReread} = 0; + # 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 { @@ -637,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; @@ -646,18 +609,20 @@ sub remove { #- 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 $hd->{isDirty} = $hd->{needKernelReread} = 1; + return 1; } $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}; + die "Cannot handle removing hda5 when hda6 is not the second partition" if $second->{start} > $third->{start}; } #- otherwise search it in extended partitions @@ -668,12 +633,20 @@ sub remove { remove_empty_extended($hd); assign_device_numbers($hd); - return $hd->{isDirty} = $hd->{needKernelReread} = 1; + 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 `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) = @_; @@ -687,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't 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; @@ -705,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't 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."); } } @@ -717,13 +688,13 @@ The only solution is to move your primary partitions to have the hole next to th $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 }; + 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 = (type => $extended_type || 5, start => $part->{start}, size => $ext_size); + my %ext = (pt_type => $extended_type || 5, start => $part->{start}, size => $ext_size); $hd->raw_add($ext->{raw}, \%ext); $ext->{extended} = \%ext; @@ -738,18 +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"; - $part->{notFormatted} = 1; - $part->{isFormatted} = 0; - $part->{rootDevice} = $hd->{device}; - $part->{start} ||= 1 if arch() !~ /^sparc/; #- starting at sector 0 is not allowed + set_isFormatted($part, 0); + put_in_hash($part, hd2minimal_part($hd)); + $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 !$@; @@ -763,11 +732,17 @@ sub add { } success: assign_device_numbers($hd); - $hd->{isDirty} = 1; - push @{$hd->{needKernelReread} ||= []}, $part if !$hd->{needKernelReread} || ref($hd->{needKernelReread}) eq 'ARRAY' + #- 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) = @_; @@ -780,40 +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) = @_; - - open(my $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"; +=back - #- unsure we don't modify totalsectors - local $hd->{totalsectors}; +=cut - @$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}; - require Data::Dumper; - eval { output($file, Data::Dumper->Dump([\@h], ['$h']), "\0") } - or die \N("Error writing to file %s", $file); -} +1; |