summaryrefslogtreecommitdiffstats
path: root/perl-install/diskdrake/interactive.pm
diff options
context:
space:
mode:
Diffstat (limited to 'perl-install/diskdrake/interactive.pm')
-rw-r--r--perl-install/diskdrake/interactive.pm657
1 files changed, 451 insertions, 206 deletions
diff --git a/perl-install/diskdrake/interactive.pm b/perl-install/diskdrake/interactive.pm
index de4b0e8f5..59e79782c 100644
--- a/perl-install/diskdrake/interactive.pm
+++ b/perl-install/diskdrake/interactive.pm
@@ -1,9 +1,11 @@
-package diskdrake::interactive; # $Id$
+package diskdrake::interactive;
use diagnostics;
use strict;
use utf8;
+use lib qw(/usr/lib/libDrakX); # for perl_checker
+use MDK::Common; # for perl_checker
use common;
use fs::type;
use fs::loopback;
@@ -20,19 +22,16 @@ use raid;
use any;
use log;
-
-=begin
-
=head1 SYNOPSYS
-struct part {
+ struct part {
int active # one of { 0 | 0x80 } x86 only, primary only
int start # in sectors
int size # in sectors
int pt_type # 0x82, 0x83, 0x6 ...
string fs_type # 'ext2', 'nfs', ...
string type_name # 'Linux RAID', 'Linux Logical Volume Manager', ...
-
+
int part_number # 1 for hda1...
string device # 'hda5', 'sdc1' ...
string device_LABEL # volume label. LABEL=xxx or /dev/disk/by-label/xxx can be used in fstab instead of the device
@@ -41,7 +40,8 @@ struct part {
bool prefer_device_UUID # should the {device_UUID} or the {device} be used in fstab
bool prefer_device # should the {device} be used in fstab
bool faked_device # false if {device} is a real device, true for nfs/smb/dav/none devices. If the field does not exist, we do not know
-
+ bool device_LABEL_changed # true if device_LABEL is different from the one on the disk
+
string rootDevice # 'sda', 'hdc' ... (can also be a VG_name)
string real_mntpoint # directly on real /, '/tmp/hdimage' ...
string mntpoint # '/', '/usr' ...
@@ -49,86 +49,96 @@ struct part {
string device_windobe # 'C', 'D' ...
string encrypt_key # [0-9A-Za-z./]{20,}
string comment # comment to have in fstab
- string volume_label #
-
+ string volume_label #
+
bool is_removable # is the partition on a removable drive
bool isMounted
-
+
bool isFormatted
- bool notFormatted
+ bool notFormatted
# isFormatted means the device is formatted
# !isFormatted && notFormatted means the device is not formatted
# !isFormatted && !notFormatted means we do not know which state we're in
-
+
string raid # for partitions of type isRawRAID and which isPartOfRAID, the raid device
string lvm # partition used as a PV for the VG with {lvm} as VG_name #-#
loopback loopback[] # loopback living on this partition
-
+
+ string dmcrypt_key
+ string dm_name
+ bool dm_active
+
# internal
string real_device # '/dev/loop0', '/dev/loop1' ... (used for encrypted loopback)
-
+
# internal CHS (Cylinder/Head/Sector)
- int start_cyl, start_head, start_sec, end_cyl, end_head, end_sec,
+ int start_cyl, start_head, start_sec, end_cyl, end_head, end_sec,
}
-struct part_allocate inherits part {
+ struct part_allocate inherits part {
int maxsize # in sectors (alike "size")
int min_hd_size # in sectors (do not allocate if the drive is smaller than the given size)
- int ratio #
+ int ratio #
string hd # 'hda', 'hdc'
string parts # for creating raid partitions. eg: 'foo bar' where 'foo' and 'bar' are mntpoint
}
-struct part_raid inherits part {
+ struct part_raid inherits part {
string chunk-size # in KiB, usually '64'
string level # one of { 0, 1, 4, 5, 'linear' }
string UUID
-
+
part disks[]
-
+
# invalid: active, start, rootDevice, device_windobe?, CHS
}
-struct part_loopback inherits part {
+ struct part_dmcrypt inherits part {
+ string dmcrypt_name
+
+ # rootDevice is special here: it is the device hosting the dm
+}
+
+ struct part_loopback inherits part {
string loopback_file # absolute file name which is relative to the partition
part loopback_device # where the loopback file live
-
+
# device is special here: it is the absolute filename of the loopback file.
-
+
# invalid: active, start, rootDevice, device_windobe, CHS
}
-struct part_lvm inherits part {
+ struct part_lvm inherits part {
# invalid: active, start, device_windobe, CHS
string lv_name
}
-struct partition_table_elem {
+ struct partition_table_elem {
part normal[] #
part extended # the main/next extended
part raw[4] # primary partitions
}
-struct geom {
- int heads
+ struct geom {
+ int heads
int sectors
int cylinders
int totalcylinders # for SUN, forget it
int start # always 0, forget it
}
-struct hd {
+ struct hd {
int totalsectors # size in sectors
string device # 'hda', 'sdc' ...
string device_alias # 'cdrom', 'floppy' ...
string media_type # one of { 'hd', 'cdrom', 'fd', 'tape' }
string capacity # contain of the strings of { 'burner', 'DVD' }
string info # name of the hd, eg: 'QUANTUM ATLAS IV 9 WLS'
-
+
bool readonly # is it allowed to modify the partition table
bool getting_rid_of_readonly_allowed # is it forbidden to write because the partition table is badly handled, or is it because we MUST not change the partition table
- bool isDirty # does it need to be written to the disk
+ bool isDirty # does it need to be written to the disk
list will_tell_kernel # list of actions to tell to the kernel so that it knows the new partition table
bool rebootNeeded # happens when a kernel reread failed
list partitionsRenumbered # happens when you
@@ -136,45 +146,48 @@ struct hd {
# - add an extended partition which is the first extended partition
list allPartitionsRenumbered # used to update bootloader configuration
int bus, id
-
+
+ bool is_removable # is it a removable drive
+
partition_table_elem primary
partition_table_elem extended[]
-
+
geom geom
-
+
# internal
string prefix # for some RAID arrays device=>c0d0 and prefix=>c0d0p
string file # '/dev/hda' ...
}
-struct hd_lvm inherits hd {
+ struct hd_lvm inherits hd {
int PE_size # block size (granularity, similar to cylinder size on x86)
string VG_name # VG name
-
+
part_lvm disks[]
-
+
# invalid: bus, id, extended, geom
}
-struct raw_hd inherits hd {
+ struct raw_hd inherits hd {
string fs_type # 'ext2', 'nfs', ...
string mntpoint # '/', '/usr' ...
string options # 'defaults', 'noauto'
-
+
# invalid: isDirty, will_tell_kernel, rebootNeeded, primary, extended
}
-struct all_hds {
+ struct all_hds {
hd hds[]
hd_lvm lvms[]
part_raid raids[]
+ part_dmcrypt dmcrypts[]
part_loopback loopbacks[]
raw_hd raw_hds[]
raw_hd nfss[]
raw_hd smbs[]
raw_hd davs[]
raw_hd special[]
-
+
# internal: if fstab_to_string($all_hds) eq current_fstab then no need to save
string current_fstab
}
@@ -192,12 +205,12 @@ sub main {
}
my ($current_part, $current_hd);
-
+
while (1) {
my $choose_txt = $current_part ? N_("Choose another partition") : N_("Choose a partition");
my $parts_and_holes = [ fs::get::fstab_and_holes($all_hds) ];
my $choose_part = sub {
- $current_part = $in->ask_from_listf('diskdrake', translate($choose_txt),
+ $current_part = $in->ask_from_listf('diskdrake', translate($choose_txt),
sub {
my $hd = fs::get::part2hd($_[0] || return, $all_hds);
format_part_info_short($hd, $_[0]);
@@ -209,33 +222,33 @@ sub main {
return if !$current_part;
my %actions = my @actions = (
- if_($current_part,
+ if_($current_part,
(map { my $s = $_; $_ => sub { $diskdrake::interactive::{$s}($in, $current_hd, $current_part, $all_hds) } } part_possible_actions($in, $current_hd, $current_part, $all_hds)),
'____________________________' => sub {},
),
if_(@$parts_and_holes > 1, $choose_txt => $choose_part),
if_($current_hd,
(map { my $s = $_; $_ => sub { $diskdrake::interactive::{$s}($in, $current_hd, $all_hds) } } hd_possible_actions_interactive($in, $current_hd, $all_hds)),
- ),
+ ),
(map { my $s = $_; $_ => sub { $diskdrake::interactive::{$s}($in, $all_hds) } } general_possible_actions($in, $all_hds)),
);
my ($actions) = list2kv(@actions);
my $a;
if ($current_part) {
$in->ask_from_({
- cancel => N("Exit"),
+ cancel => N("Exit"),
title => 'diskdrake',
messages => format_part_info($current_hd, $current_part),
},
[ { val => \$a, list => $actions, format => \&translate, type => 'list', sort => 0, gtk => { use_boxradio => 0 } } ]) or last;
my $v = eval { $actions{$a}() };
if (my $err = $@) {
- $in->ask_warn(N("Error"), formatError($err));
+ $in->ask_warn(N("Error"), formatError($err));
}
if ($v eq 'force_reload') {
$all_hds = $do_force_reload->();
}
- $current_hd = $current_part = '' if !is_part_existing($current_part, $all_hds);
+ $current_hd = $current_part = '' if !is_part_existing($current_part, $all_hds);
} else {
$choose_part->();
}
@@ -256,7 +269,7 @@ sub main {
################################################################################
sub general_possible_actions {
my ($_in, $_all_hds) = @_;
- $::expert ? N_("Toggle to normal mode") : N_("Toggle to expert mode");
+ if_($::isInstall, N_("More"));
}
sub Done {
@@ -272,16 +285,19 @@ sub Done {
$in->ask_yesorno(N("Quit without saving"), N("Quit without writing the partition table?"), 1) or return;
}
}
+ foreach (@{$all_hds->{raids}}) {
+ raid::make($all_hds->{raids}, $_);
+ }
if (!$::isInstall) {
my $new = fs::fstab_to_string($all_hds);
- if ($new ne $all_hds->{current_fstab} && $in->ask_yesorno(N("Confirmation"), N("Do you want to save /etc/fstab modifications"), 1)) {
+ if ($new ne $all_hds->{current_fstab} && $in->ask_yesorno(N("Confirmation"), N("Do you want to save the /etc/fstab modifications?"), 1)) {
$all_hds->{current_fstab} = $new;
fs::write_fstab($all_hds);
}
update_bootloader_for_renumbered_partitions($in, $all_hds);
if (any { $_->{rebootNeeded} } @{$all_hds->{hds}}) {
- $in->ask_warn(N("Partitioning"), N("You need to reboot for the partition table modifications to take place"));
+ $in->ask_warn(N("Partitioning"), N("You need to reboot for the partition table modifications to take effect"));
tell_wm_and_reboot();
}
}
@@ -296,17 +312,29 @@ Quit anyway?", $part->{device}, $part->{mntpoint})) or return if $::isStandalone
################################################################################
# per-hd actions
################################################################################
-sub hd_possible_actions {
- my ($_in, $hd, $_all_hds) = @_;
- (
- if_(!$hd->{readonly} || $hd->{getting_rid_of_readonly_allowed}, N_("Clear all")),
+sub hd_possible_actions_base {
+ my ($hd) = @_;
+ (
+ if_(!$hd->{readonly} || $hd->{getting_rid_of_readonly_allowed}, N_("Clear all")),
if_(!$hd->{readonly} && $::isInstall, N_("Auto allocate")),
- if_($::isInstall, N_("More")),
);
}
+
+sub hd_possible_actions_extra {
+ my ($_hd) = @_;
+ $::expert ? N_("Normal mode") : N_("Expert mode");
+}
+
+
+sub hd_possible_actions {
+ my ($_in, $hd, $_all_hds) = @_;
+ hd_possible_actions_base($hd);
+ hd_possible_actions_extra($hd);
+}
+
sub hd_possible_actions_interactive {
my ($_in, $_hd, $_all_hds) = @_;
- &hd_possible_actions, N_("Hard drive information");
+ &hd_possible_actions, N_("Hard disk drive information");
}
sub Clear_all {
@@ -316,6 +344,7 @@ sub Clear_all {
foreach (@parts) {
RemoveFromLVM($in, $hd, $_, $all_hds) if isPartOfLVM($_);
RemoveFromRAID($in, $hd, $_, $all_hds) if isPartOfRAID($_);
+ RemoveFromDm($in, $hd, $_, $all_hds) if $_->{dm_active};
}
if (isLVM($hd)) {
lvm::lv_delete($hd, $_) foreach @parts;
@@ -324,29 +353,30 @@ sub Clear_all {
$hd->{getting_rid_of_readonly_allowed} = 0; #- we don't need this flag anymore
fsedit::partition_table_clear_and_initialize($all_hds->{lvms}, $hd, $in);
}
+ fsedit::init_mntpnt_suggestions($all_hds, $hd, 1);
}
sub Auto_allocate {
my ($in, $hd, $all_hds) = @_;
- my $suggestions = partitions_suggestions($in) or return;
+ my $suggestions = partitions_suggestions($in, $all_hds, $hd) or return;
my %all_hds_ = %$all_hds;
$all_hds_{hds} = [ sort { $a == $hd ? -1 : 1 } fs::get::hds($all_hds) ];
- eval { fsedit::auto_allocate(\%all_hds_, $suggestions) };
+ eval { fsedit::auto_allocate(\%all_hds_, $suggestions, $hd) };
if ($@) {
$@ =~ /partition table already full/ or die;
- $in->ask_warn("", [
+ $in->ask_warn("", [
N("All primary partitions are used"),
- N("I can not add any more partitions"),
+ N("I cannot add any more partitions"),
N("To have more partitions, please delete one to be able to create an extended partition"),
]);
}
}
sub More {
- my ($in, $hd) = @_;
+ my ($in, $_hd) = @_;
my $r;
$in->ask_from(N("More"), '',
@@ -365,24 +395,31 @@ sub Hd_info {
# per-part actions
################################################################################
+sub is_LVM_resizable {
+ my ($part) = @_;
+ member($part->{fs_type}, qw(btrfs ext3 ext4 nilfs2 reiserfs xfs));
+}
sub part_possible_actions {
my ($_in, $hd, $part, $all_hds) = @_;
$part or return;
my %actions = my @l = (
+ N_("View") => '!isSwap && !isNonMountable && maybeFormatted',
N_("Mount point") => '$part->{real_mntpoint} || (!isBusy && !isSwap && !isNonMountable)',
N_("Type") => '!isBusy && $::expert && (!readonly || $part->{pt_type} == 0x83)',
N_("Options") => '!isSwap($part) && !isNonMountable && $::expert',
- N_("Label") => '!isNonMountable && $::expert',
- N_("Resize") => '!isBusy && !readonly && !isSpecial || isLVM($hd) && LVM_resizable',
- N_("Format") => '!isBusy && !readonly && ($::expert || $::isStandalone)',
+ N_("Label") => '!isNonMountable && $::expert && fs::format::canEditLabel($part)',
+ N_("Resize") => '!isBusy && !readonly && !isSpecial || isLVM($hd) && is_LVM_resizable',
+ N_("Format") => '!isBusy && isFormatable && (!readonly && ($::expert || $::isStandalone) || fs::type::isRawLUKS($part))',
N_("Mount") => '!isBusy && (hasMntpoint || isSwap) && maybeFormatted && ($::expert || $::isStandalone)',
N_("Add to RAID") => '!isBusy && isRawRAID && (!isSpecial || isRAID)',
N_("Add to LVM") => '!isBusy && isRawLVM',
+ N_("Use") => '!isBusy && fs::type::isRawLUKS($part) && !$part->{notFormatted}',
N_("Unmount") => '!$part->{real_mntpoint} && isMounted',
N_("Delete") => '!isBusy && !readonly',
N_("Remove from RAID") => 'isPartOfRAID',
N_("Remove from LVM") => 'isPartOfLVM',
+ N_("Remove from dm") => '$part->{dm_active}',
N_("Modify RAID") => 'canModifyRAID',
N_("Use for loopback") => '!$part->{real_mntpoint} && isMountableRW && !isSpecial && hasMntpoint && maybeFormatted && $::expert',
);
@@ -391,30 +428,43 @@ sub part_possible_actions {
my %macros = (
readonly => '$hd->{readonly}',
hasMntpoint => '$part->{mntpoint}',
- LVM_resizable => '$part->{fs_type} eq "reiserfs" || (isMounted ? $part->{fs_type} eq "xfs" : member($part->{fs_type}, qw(ext3 ext4dev)))',
canModifyRAID => 'isPartOfRAID($part) && !isMounted(fs::get::device2part($part->{raid}, $all_hds->{raids}))',
);
if (isEmpty($part)) {
if_(!$hd->{readonly}, N_("Create"));
} elsif ($part->{pt_type} == 0xbf && detect_devices::is_xbox()) {
#- XBox OS partitions, do not allow anything
- return;
+ return;
} else {
- grep {
+ grep {
my $cond = $actions{$_};
while (my ($k, $v) = each %macros) {
$cond =~ s/$k/qq(($v))/e;
}
$cond =~ s/(^|[^:\$]) \b ([a-z]\w{3,}) \b ($|[\s&\)])/$1 . $2 . '($part)' . $3/exg;
- eval $cond;
+ my $res = eval $cond;
+ if (my $err = $@) {
+ warn "ERROR: Bogus condition for '$actions{$_}': $err\n";
+ }
+ $res;
} @$actions_names;
}
}
-#- in case someone use diskdrake only to create partitions,
+sub View {
+ my ($in, $_hd, $part, $_all_hds) = @_;
+ my $handle = any::inspect($part, $::prefix);
+ if ($handle) {
+ $in->ask_directory({ 'directory' => $handle->{dir} });
+ } else {
+ $in->ask_warn(N("Error"), N("Failed to mount partition"));
+ }
+}
+
+#- in case someone use diskdrake only to create partitions,
#- ie without assigning a mount point,
#- do not suggest mount points anymore
-my $do_suggest_mount_point = 1;
+my $do_suggest_mount_point = $::isInstall;
sub Create {
my ($in, $hd, $part, $all_hds) = @_;
@@ -425,7 +475,7 @@ sub Create {
$part->{mntpoint} = '' if !$do_suggest_mount_point;
} else {
$part->{size} = $part->{maxsize};
- fs::type::suggest_fs_type($part, 'ext3');
+ fs::type::suggest_fs_type($part, defaultFS());
}
if (isLVM($hd)) {
lvm::suggest_lv_name($hd, $part);
@@ -438,46 +488,69 @@ sub Create {
my $type_name = fs::type::part2type_name($part);
my $mb_size = to_Mb($part->{size});
my $has_startsector = ($::expert || arch() !~ /i.86/) && !isLVM($hd);
+ my $use_dmcrypt;
+ my $requested_type;
$in->ask_from(N("Create a new partition"), '',
[
{ label => N("Create a new partition"), title => 1 },
if_($has_startsector,
- { label => N("Start sector: "), val => \$part->{start}, min => $def_start, max => ($max - min_partition_size($hd)),
+ { label => N("Start sector: "), val => \$part->{start}, min => $def_start, max => ($max - min_partition_size($hd)),
type => 'range', SpinButton => $::expert, changed => sub { $mb_size = min($mb_size, to_Mb($max - $part->{start})) } },
),
- { label => N("Size in MB: "), val => \$mb_size, min => to_Mb(min_partition_size($hd)), max => to_Mb($def_size),
+ { label => N("Size in MB: "), val => \$mb_size, min => to_Mb(min_partition_size($hd)), max => to_Mb($def_size),
type => 'range', SpinButton => $::expert, changed => sub { $part->{start} = min($part->{start}, $max - $mb_size * 2048) } },
- { label => N("Filesystem type: "), val => \$type_name, list => [ fs::type::type_names($::expert, $hd) ],
- sort => 0, if_($::expert, gtk => { wrap_width => 4 }) },
+ { label => N("Filesystem type: "), val => \$type_name, list => [ fs::type::type_names($::expert, $hd) ],
+ sort => 0, if_($::expert, gtk => { wrap_width => 2 }, do_not_ellipsize => 1) },
{ label => N("Mount point: "), val => \$part->{mntpoint}, list => [ fsedit::suggestions_mntpoint($all_hds), '' ],
+ if_(isLVM($hd), changed => sub {
+ undef $part->{lv_name};
+ lvm::suggest_lv_name($hd, $part);
+ }), type => 'combo', not_edit => 0,
disabled => sub { my $p = fs::type::type_name2subpart($type_name); isSwap($p) || isNonMountable($p) }, type => 'combo', not_edit => 0,
},
if_($::expert && $hd->hasExtended,
{ label => N("Preference: "), val => \$primaryOrExtended, list => [ '', "Extended", "Primary", if_($::expert, "Extended_0x85") ] },
),
- if_($::expert && isLVM($hd),
+ if_(isLVM($hd),
{ label => N("Logical volume name "), val => \$part->{lv_name}, list => [ qw(root swap usr home var), '' ], sort => 0, not_edit => 0 },
),
+ { label => N("Encrypt partition"), type => 'bool', val => \$use_dmcrypt, disabled => sub { $part->{mntpoint} eq "/boot" } },
+ { label => N("Encryption key "), val => \$part->{dmcrypt_key}, disabled => sub { !$use_dmcrypt }, hidden => 1, weakness_check => 1 },
+ { label => N("Encryption key (again)"), val => \$part->{dmcrypt_key2}, disabled => sub { !$use_dmcrypt }, hidden => 1 },
], complete => sub {
$part->{size} = from_Mb($mb_size, min_partition_size($hd), $max - $part->{start}); #- need this to be able to get back the approximation of using MB
- put_in_hash($part, fs::type::type_name2subpart($type_name));
$do_suggest_mount_point = 0 if !$part->{mntpoint};
+ put_in_hash($part, fs::type::type_name2subpart($type_name));
$part->{mntpoint} = '' if isNonMountable($part);
$part->{mntpoint} = 'swap' if isSwap($part);
fs::mount_options::set_default($part, ignore_is_removable => 1);
+ # if user asked to encrypt the partition, use dm-crypt and create requested fs inside
+ if ($use_dmcrypt) {
+ my $err;
+ $err = N("The encryption keys do not match") unless $part->{dmcrypt_key} eq $part->{dmcrypt_key2};
+ $err = N("Missing encryption key") unless $part->{dmcrypt_key};
+ if ($err) {
+ $in->ask_warn(N("Error"), $err);
+ return 1;
+ }
+ $requested_type = $type_name;
+ $type_name = 'Encrypted';
+ }
+
+ put_in_hash($part, fs::type::type_name2subpart($type_name));
check($in, $hd, $part, $all_hds) or return 1;
$migrate_files = need_migration($in, $part->{mntpoint}) or return 1;
-
+
my $seen;
- eval {
+ eval {
catch_cdie { fsedit::add($hd, $part, $all_hds, { force => 1, primaryOrExtended => $primaryOrExtended }) }
sub { $seen = 1; $in->ask_okcancel('', formatError($@)) };
};
if (my $err = $@) {
if ($err =~ /raw_add/ && $hd->hasExtended && !$hd->{primary}{extended}) {
- $in->ask_warn(N("Error"), N("You can not create a new partition
+ $in->ask_warn(N("Error"), N("You cannot create a new partition
(since you reached the maximal number of primary partitions).
First remove a primary partition and create an extended partition."));
return 0;
@@ -490,9 +563,26 @@ First remove a primary partition and create an extended partition."));
},
) or return;
+ if ($use_dmcrypt) {
+ write_partitions($in, $hd) or return;
+ # Initialize it and format it
+ dmcrypt_format($in, $hd, $part, $all_hds);
+ my $p = find { $part->{dm_name} eq $_->{dmcrypt_name} } @{$all_hds->{dmcrypts}};
+ my $p2 = fs::type::type_name2subpart($requested_type);
+ $p->{fs_type} = $p2->{fs_type};
+ $p->{type_name} = $requested_type;
+ $p->{mntpoint} = $part->{mntpoint};
+ $part->{mntpoint} = '';
+ if ($::isStandalone) {
+ fs::format::check_package_is_installed_format($in->do_pkgs, $p->{fs_type}) or log::l("Missing package");
+ }
+ _format_raw($in, $p, $all_hds, isRawLVM($p));
+ }
+
warn_if_renumbered($in, $hd);
if ($migrate_files eq 'migrate') {
+ # FIXME check encrypt case
format_($in, $hd, $part, $all_hds) or return;
migrate_files($in, $hd, $part);
fs::mount::part($part);
@@ -501,6 +591,11 @@ First remove a primary partition and create an extended partition."));
sub Delete {
my ($in, $hd, $part, $all_hds) = @_;
+ if (fs::type::isLUKS($part)) {
+ my $p = find { $_->{dm_name} eq $part->{dmcrypt_name} } partition_table::get_normal_parts($hd);
+ RemoveFromDm($in, $hd, $p, $all_hds);
+ $part = $p;
+ }
if (isRAID($part)) {
raid::delete($all_hds->{raids}, $part);
} elsif (isLVM($hd)) {
@@ -515,9 +610,6 @@ sub Delete {
delete $part->{loopback_device}{loopback} if @$l == 0;
fsedit::recompute_loopbacks($all_hds);
} else {
- if (arch() =~ /ppc/) {
- undef $partition_table::mac::bootstrap_part if isAppleBootstrap($part) && ($part->{device} = $partition_table::mac::bootstrap_part);
- }
partition_table::remove($hd, $part);
warn_if_renumbered($in, $hd);
}
@@ -527,41 +619,50 @@ sub Type {
my ($in, $hd, $part) = @_;
my $warned;
- my $warn = sub {
- $warned = 1;
- ask_alldatawillbelost($in, $part, N_("After changing type of partition %s, all data on this partition will be lost"));
+ my $warn = sub {
+ $warned = 1;
+ if (maybeFormatted($part)) {
+ ask_alldatawillbelost($in, $part, N_("After changing type of partition %s, all data on this partition will be lost"));
+ } else {
+ 1;
+ }
};
- #- for ext2, warn after choosing as ext2->ext3 can be achieved without loosing any data :)
- $part->{fs_type} eq 'ext2' || $part->{fs_type} =~ /ntfs/ or $warn->() or return;
+ #- for ext2/ext3, warn after choosing as ext2->ext3 and ext*->ext4 can be achieved without loosing any data :)
+ member($part->{fs_type}, qw(ext2 ext3)) || $part->{fs_type} =~ /ntfs/ or $warn->() or return;
my @types = fs::type::type_names($::expert, $hd);
#- when readonly, Type() is allowed only when changing {fs_type} but not {pt_type}
- #- eg: switching between ext2, ext3, ext4dev, reiserfs...
+ #- eg: switching between ext2, ext3, ext4, reiserfs...
@types = grep { fs::type::type_name2pt_type($_) == $part->{pt_type} } @types if $hd->{readonly};
my $type_name = fs::type::part2type_name($part);
$in->ask_from_({ title => N("Change partition type") },
[
{ label => N("Which filesystem do you want?"), title => 1 },
- { label => N("Type"), val => \$type_name, list => \@types, sort => 0,
- focus => sub { 1 }, not_edit => 1, gtk => { wrap_width => 4 } } ]) or return;
+ { label => N("Type"), val => \$type_name, type => 'list', list => \@types, sort => 1, do_not_ellipsize => 1,
+ focus => sub { 1 }, not_edit => 1, gtk => { wrap_width => 2 } } ]) or return;
my $type = $type_name && fs::type::type_name2subpart($type_name);
- if (member($type->{fs_type}, qw(ext2 ext3 ext4dev))) {
+ if ($part->{fs_type} eq 'ext2' && $type->{fs_type} eq 'ext3') {
my $_w = $in->wait_message(N("Please wait"), N("Switching from %s to %s", 'ext2', $type->{fs_type}));
if (run_program::run("tune2fs", "-j", devices::make($part->{device}))) {
put_in_hash($part, $type);
set_isFormatted($part, 1); #- assume that if tune2fs works, partition is formatted
#- disable the fsck (do not do it together with -j in case -j fails?)
- fs::format::disable_forced_fsck($part->{device});
+ fs::format::disable_forced_fsck($part->{device});
return;
}
+ } elsif (member($part->{fs_type}, qw(ext2 ext3)) && $type->{fs_type} eq 'ext4') {
+ # FIXME enable some nice flags
+ put_in_hash($part, $type);
+ return;
} elsif ($type->{fs_type} =~ /ntfs/ && $part->{fs_type} =~ /ntfs/) {
if ($type->{fs_type} eq 'ntfs-3g') {
+ local $::prefix = ''; # For draklive-install
$in->do_pkgs->ensure_binary_is_installed('ntfs-3g', 'mount.ntfs-3g') or return;
}
put_in_hash($part, $type);
@@ -576,13 +677,26 @@ sub Type {
}
sub Label {
- my ($in, $_hd, $part) = @_;
- $in->ask_from(N("Which volume label?"), '',
+ my ($in, $hd, $part) = @_;
+ my $new_label = $part->{device_LABEL} || "";
- [
+ write_partitions($in, $hd) or return;
+
+ $in->ask_from(N("Set volume label"),
+ maybeFormatted($part) ?
+ N("Beware, this will be written to disk as soon as you validate!")
+ : N("Beware, this will be written to disk only after formatting!"),
+ [
{ label => N("Which volume label?"), title => 1 },
- { label => N("Label:"), val => \$part->{device_LABEL} } ]) or return;
- $part->{prefer_device_LABEL} = to_bool($part->{device_LABEL});
+ { label => N("Label:"), val => \$new_label } ]) or return;
+
+ fs::format::check_package_is_installed_label($in->do_pkgs, $part->{fs_type}) or return;
+ $part->{prefer_device_LABEL} = to_bool($part->{device_LABEL}) && !isLVM($part);
+ return if $new_label eq $part->{device_LABEL};
+ $part->{device_LABEL} = $new_label;
+ $part->{device_LABEL_changed} = 1;
+ fs::format::clean_label($part);
+ fs::format::write_label($part);
}
sub Mount_point {
@@ -600,8 +714,8 @@ sub Mount_point {
$in->ask_from_({
callbacks => {
complete => sub {
- !isPartOfLoopback($part) || $mntpoint or $in->ask_warn(N("Error"),
-N("Can not unset mount point as this partition is used for loop back.
+ !isPartOfLoopback($part) || $mntpoint or $in->ask_warn(N("Error"),
+N("Cannot unset mount point as this partition is used for loop back.
Remove the loopback first")), return 1;
$part->{mntpoint} eq $mntpoint || check_mntpoint($in, $mntpoint, $part, $all_hds) or return 1;
$migrate_files = need_migration($in, $mntpoint) or return 1;
@@ -610,8 +724,8 @@ Remove the loopback first")), return 1;
},
[
{ label => $msg, title => 1 },
- { label => N("Mount point"), val => \$mntpoint,
- list => [ uniq(if_($mntpoint, $mntpoint), fsedit::suggestions_mntpoint($all_hds), '') ],
+ { label => N("Mount point"), val => \$mntpoint,
+ list => [ uniq(if_($mntpoint, $mntpoint), fsedit::suggestions_mntpoint($all_hds), '') ],
focus => sub { 1 },
not_edit => 0 } ],
) or return;
@@ -632,8 +746,8 @@ sub Mount_point_raw_hd {
'',
[
{ label => N("Where do you want to mount %s?", $part->{device}), title => 1 },
- { label => N("Mount point"), val => \$mntpoint,
- list => [ if_($mntpoint, $mntpoint), '', @propositions ],
+ { label => N("Mount point"), val => \$mntpoint,
+ list => [ if_($mntpoint, $mntpoint), '', @propositions ],
not_edit => 0 } ],
complete => sub {
$part->{mntpoint} eq $mntpoint || check_mntpoint($in, $mntpoint, $part, $all_hds) or return 1;
@@ -643,10 +757,36 @@ sub Mount_point_raw_hd {
$part->{mntpoint} = $mntpoint;
}
+#- side-effects: mounts the fs
+sub _get_dir_for_online_resize {
+ my ($part) = @_;
+ my $dir = "/tmp/tmp_resize_" . $part->{fs_type} . ".$$";
+ if ($part->{isMounted}) {
+ $dir = ($::prefix || '') . $part->{mntpoint};
+ } else {
+ mkdir_p($dir);
+ fs::mount::mount(devices::make($part->{device}), $dir, $part->{fs_type});
+ }
+ return $dir;
+}
+
+sub _set_min_size_from_avail_space {
+ my ($part, $min) = @_;
+ if (defined(my $free = fs::df($part))) {
+ $$min = max($$min, $part->{size} - $free);
+ }
+}
+
sub Resize {
my ($in, $hd, $part) = @_;
- my (%nice_resize);
- my ($min, $max) = (min_partition_size($hd), max_partition_resize($hd, $part));
+ my (%nice_resize, $online_resize);
+ my $low_part = $part;
+
+ if (isLUKS($part)) {
+ $low_part = find { $_->{dm_name} eq $part->{dmcrypt_name} } partition_table::get_normal_parts($hd);
+ }
+
+ my ($min, $max) = (min_partition_size($hd), max_partition_resize($hd, $low_part));
if (maybeFormatted($part)) {
# here we may have a non-formatted or a formatted partition
@@ -660,8 +800,8 @@ sub Resize {
require resize_fat::main;
$nice_resize{fat} = resize_fat::main->new($part->{device}, devices::make($part->{device}));
$min = max($min, $nice_resize{fat}->min_size);
- $max = min($max, $nice_resize{fat}->max_size);
- } elsif (member($part->{fs_type}, qw(ext2 ext3 ext4dev))) {
+ $max = min($max, $nice_resize{fat}->max_size);
+ } elsif (member($part->{fs_type}, qw(ext2 ext3 ext4))) {
write_partitions($in, $hd) or return;
require diskdrake::resize_ext2;
if ($nice_resize{ext2} = diskdrake::resize_ext2->new($part->{device}, devices::make($part->{device}))) {
@@ -669,6 +809,9 @@ sub Resize {
} else {
delete $nice_resize{ext2};
}
+ } elsif ($part->{fs_type} eq 'f2fs') {
+ $min = $part->{size}; #- ensure the user can only increase
+ $nice_resize{f2fs} = 1;
} elsif ($part->{fs_type} =~ /ntfs/) {
write_partitions($in, $hd) or return;
require diskdrake::resize_ntfs;
@@ -677,17 +820,27 @@ sub Resize {
$min = $nice_resize{ntfs}->min_size or delete $nice_resize{ntfs};
} elsif ($part->{fs_type} eq 'reiserfs') {
write_partitions($in, $hd) or return;
+ $nice_resize{reiserfs} = 1;
if ($part->{isMounted}) {
- $nice_resize{reiserfs} = 1;
$min = $part->{size}; #- ensure the user can only increase
- } elsif (defined(my $free = fs::df($part))) {
- $nice_resize{reiserfs} = 1;
- $min = max($min, $part->{size} - $free);
+ } else {
+ _set_min_size_from_avail_space($part, \$min);
}
- } elsif ($part->{fs_type} eq 'xfs' && isLVM($hd) && $::isStandalone && $part->{isMounted}) {
+ } elsif ($part->{fs_type} eq 'xfs') {
$min = $part->{size}; #- ensure the user can only increase
- $nice_resize{xfs} = 1;
+ $online_resize = $part->{fs_type};
+ } elsif (member($part->{fs_type}, qw(btrfs nilfs2))) {
+ $online_resize = $part->{fs_type};
}
+
+ # Btrf, nilfs2 && XFS only support online resizing
+ # (Ext3/4 too but we can resize it offline so we don't care - though growing online is interesting)
+ if ($online_resize) {
+ write_partitions($in, $hd) or return;
+ $nice_resize{$online_resize} = 1;
+ _set_min_size_from_avail_space($part, \$min);
+ }
+
#- make sure that even after normalizing the size to cylinder boundaries, the minimun will be saved,
#- this save at least a cylinder (less than 8Mb).
$min += partition_table::raw::cylinder_size($hd);
@@ -696,7 +849,7 @@ sub Resize {
#- for these, we have tools to resize partition table
#- without losing data (or at least we hope so :-)
if (%nice_resize) {
- ask_alldatamaybelost($in, $part, N_("All data on this partition should be backed-up")) or return;
+ ask_alldatamaybelost($in, $part, N_("All data on this partition should be backed up")) or return;
} else {
ask_alldatawillbelost($in, $part, N_("After resizing partition %s, all data on this partition will be lost")) or return;
}
@@ -704,7 +857,7 @@ sub Resize {
my $mb_size = to_Mb($part->{size});
my ($gmin, $gmax) = (to_Mb($min), to_Mb($max));
- $in->ask_from(N("Resize"), '', [
+ $in->ask_from(N("Resize"), '', [
{ label => N("Choose the new size"), title => 1 },
{ label => N("New size in MB: "), val => \$mb_size, min => $gmin, max => $gmax, type => 'range', SpinButton => $::expert },
{ label => N("Minimum size: %s MB", $gmin) },
@@ -716,8 +869,8 @@ sub Resize {
$part->{size} == $size and return;
my $oldsize = $part->{size};
- $part->{size} = $size;
- $hd->adjustEnd($part);
+ $low_part->{size} = $part->{size} = $size;
+ $hd->adjustEnd($low_part);
undef $@;
my $_b = before_leaving { $@ and $part->{size} = $oldsize };
@@ -726,12 +879,19 @@ sub Resize {
my ($write_partitions) = @_;
if (isLVM($hd)) {
- lvm::lv_resize($part, $oldsize);
+ lvm::lv_resize($low_part, $oldsize);
} else {
- partition_table::will_tell_kernel($hd, resize => $part);
- partition_table::adjust_local_extended($hd, $part);
+ if ($write_partitions && isLUKS($part)) {
+ run_program::run('cryptsetup', 'luksClose', $part->{dmcrypt_name}) or die("Failed to resize partition, maybe it is mounted");
+ }
+ partition_table::will_tell_kernel($hd, resize => $low_part);
+ partition_table::adjust_local_extended($hd, $low_part);
partition_table::adjust_main_extended($hd);
- write_partitions($in, $hd) or return if $write_partitions && %nice_resize;
+ write_partitions($in, $hd) or return if $write_partitions && (%nice_resize || isLUKS($part));
+ if ($write_partitions && isLUKS($part)) {
+ require fs::dmcrypt;
+ fs::dmcrypt::open_part([], $low_part);
+ }
}
1;
};
@@ -749,14 +909,34 @@ sub Resize {
log::l("ntfs resize to $part->{size} sectors");
$nice_resize{ntfs}->resize($part->{size});
$wait = undef;
- $in->ask_warn(N("Warning"), N("To ensure data integrity after resizing the partition(s),
+ $in->ask_warn(N("Warning"), N("To ensure data integrity after resizing the partition(s),
filesystem checks will be run on your next boot into Microsoft Windows®"));
} elsif ($nice_resize{reiserfs}) {
log::l("reiser resize to $part->{size} sectors");
run_program::run_or_die('resize_reiserfs', '-f', '-q', '-s' . int($part->{size}/2) . 'K', devices::make($part->{device}));
- } elsif ($nice_resize{xfs}) {
- #- happens only with mounted LVM, see above
- run_program::run_or_die("xfs_growfs", $part->{mntpoint});
+ } elsif ($online_resize) {
+ my $dir = _get_dir_for_online_resize($part);
+ my @cmd;
+ if ($nice_resize{btrfs}) {
+ # FIXME: only works for a FS on a single device. Multi-device FS would need to specify the device to enlarge
+ @cmd = (qw(btrfs filesystem resize), $part->{size}*512, $dir);
+ } elsif ($nice_resize{nilfs2}) {
+ @cmd = ('nilfs-resize', devices::make($part->{device}), $part->{size}*512);
+ } elsif ($nice_resize{xfs}) {
+ @cmd = ("xfs_growfs", $dir);
+ } else {
+ die("I don't know how to proceed");
+ }
+ if (!run_program::run(@cmd)) {
+ $nice_resize{$part->{fs_type}} = undef;
+ }
+ # umount after online resize if it was mounted on demand:
+ if (!$part->{isMounted}) {
+ fs::mount::umount($dir);
+ unlink($dir);
+ }
+ } elsif ($nice_resize{f2fs}) {
+ run_program::run_or_die("resize.f2fs", devices::make($part->{device}));
}
if (%nice_resize) {
@@ -764,11 +944,12 @@ filesystem checks will be run on your next boot into Microsoft Windows®"));
} else {
set_isFormatted($part, 0);
partition_table::verifyParts($hd) if !isLVM($hd);
- $part->{mntpoint} = '' if isNonMountable($part); #- mainly for ntfs, which we can not format
+ $part->{mntpoint} = '' if isNonMountable($part); #- mainly for ntfs, which we cannot format
}
$adjust->(0) if $size < $oldsize;
}
+
sub Format {
my ($in, $hd, $part, $all_hds) = @_;
format_($in, $hd, $part, $all_hds);
@@ -786,6 +967,45 @@ sub Mount {
$w->set($msg);
});
}
+
+sub dmcrypt_open {
+ my ($in, $_hd, $part, $all_hds) = @_;
+ $part->{dm_name} ||= do {
+ my $s = $part->{device};
+ $s =~ s/\W/_/g;
+ "crypt_$s";
+ };
+
+ if (!$part->{dmcrypt_key}) {
+ $in->ask_from_({
+ title => N("Filesystem encryption key"),
+ messages => N("Enter your filesystem encryption key"),
+ }, [ { label => N("Encryption key"), val => \$part->{dmcrypt_key},
+ hidden => 1, focus => sub { 1 } } ]) or return;
+ }
+
+ eval { require fs::dmcrypt; fs::dmcrypt::open_part($all_hds->{dmcrypts}, $part) };
+ if ($@) {
+ delete $part->{dmcrypt_key};
+ die(($? >> 8) == 255 ? N("Invalid key") : $@);
+ }
+ detect_lvms_on_dmcrypt($all_hds);
+}
+
+# Detect LVMs on top of dmcrypt
+sub detect_lvms_on_dmcrypt {
+ my ($all_hds) = @_,
+ require File::Temp;
+ require fs::dmcrypt;
+ my (undef, $tmp_file) = File::Temp::mkstemp('/tmp/crypttab.XXXXXXX');
+ fs::dmcrypt::save_crypttab_($all_hds, $tmp_file);
+ require lvm;
+ lvm::detect_during_install();
+ $all_hds->{lvms} = [ fsedit::lvms($all_hds) ];
+ fs::dmcrypt::read_crypttab_($all_hds, $tmp_file);
+ rm_rf($tmp_file);
+}
+
sub Add2RAID {
my ($in, $_hd, $part, $all_hds) = @_;
my $raids = $all_hds->{raids};
@@ -806,6 +1026,7 @@ sub Add2RAID {
sub Add2LVM {
my ($in, $hd, $part, $all_hds) = @_;
my $lvms = $all_hds->{lvms};
+ my @lvm_names = map { $_->{VG_name} } @$lvms;
write_partitions($in, $_) or return foreach isRAID($part) ? @{$all_hds->{hds}} : $hd;
my $lvm = $in->ask_from_listf_(N("Add to LVM"), N("Choose an existing LVM to add to"),
@@ -814,11 +1035,27 @@ sub Add2LVM {
require lvm;
if (!ref $lvm) {
# create new lvm
- # FIXME: when mdv2006 is out: remove the question mark from the dialog title
- my $name = $in->ask_from_entry(N("LVM name?"), N("LVM name?")) or return;
+ my $n; my $str = "vg-mga";
+ while (member("$str$n", @lvm_names)) {
+ $n++;
+ }
+
+ my $name = "$str$n";
+ $in->ask_from_({ title => N("LVM name"),
+ messages => N("Enter a name for the new LVM volume group"),
+ focus_first => 1,
+ ok_disabled => sub { !$name },
+ validate => sub {
+ member($name, @lvm_names) or return 1;
+ $in->ask_warn(N("Error"), N("\"%s\" already exists", $name));
+ return 0;
+ } },
+ [ { label => N("LVM name"), val => \$name } ]) or return;
+
$lvm = new lvm($name);
push @$lvms, $lvm;
}
+ my $_w = $in->wait_message(N("Please wait"), N("Setting up LVM"));
raid::make($all_hds->{raids}, $part) if isRAID($part);
lvm::check($in->do_pkgs) if $::isStandalone;
lvm::add_to_VG($part, $lvm);
@@ -827,10 +1064,15 @@ sub Unmount {
my ($_in, $_hd, $part) = @_;
fs::mount::umount_part($part);
}
-sub RemoveFromRAID {
+sub RemoveFromRAID {
my ($_in, $_hd, $part, $all_hds) = @_;
raid::removeDisk($all_hds->{raids}, $part);
}
+sub RemoveFromDm {
+ my ($_in, $_hd, $part, $all_hds) = @_;
+ require fs::dmcrypt;
+ fs::dmcrypt::close_part($all_hds->{dmcrypts}, $part);
+}
sub RemoveFromLVM {
my ($in, $_hd, $part, $all_hds) = @_;
isPartOfLVM($part) or die;
@@ -849,7 +1091,7 @@ Do you want to move used physical extents on this volume to other volumes?", $pa
$all_hds->{lvms} = $other_lvms;
}
}
-sub ModifyRAID {
+sub ModifyRAID {
my ($in, $_hd, $part, $all_hds) = @_;
modifyRAID($in, $all_hds->{raids}, fs::get::device2part($part->{raid}, $all_hds->{raids}));
}
@@ -858,14 +1100,14 @@ sub Loopback {
write_partitions($in, $hd) or return;
- my $handle = any::inspect($real_part) or $in->ask_warn(N("Error"), N("This partition can not be used for loopback")), return;
+ my $handle = any::inspect($real_part) or $in->ask_warn(N("Error"), N("This partition cannot be used for loopback")), return;
my ($min, $max) = (1, fs::loopback::getFree($handle->{dir}, $real_part));
$max = min($max, 1 << (31 - 9)) if $real_part->{fs_type} eq 'vfat'; #- FAT does not handle file size bigger than 2GB
my $part = { maxsize => $max, size => 0, loopback_device => $real_part, notFormatted => 1 };
if (!fsedit::suggest_part($part, $all_hds)) {
$part->{size} = $part->{maxsize};
- fs::type::suggest_fs_type($part, 'ext3');
+ fs::type::suggest_fs_type($part, defaultFS());
}
delete $part->{mntpoint}; # we do not want the suggested mntpoint
@@ -895,7 +1137,7 @@ sub Loopback {
}
sub Options {
- my ($in, $hd, $part, $all_hds) = @_;
+ my ($in, $_hd, $part, $_all_hds) = @_;
my @simple_options = qw(users noauto username= password=);
@@ -911,13 +1153,13 @@ sub Options {
relatime => sub { $options->{noatime} = 0 },
noatime => sub { $options->{relatime} = 0 },
);
-
+
$in->ask_from(N("Mount options"),
'',
- [
+ [
{ label => N("Mount options"), title => 1 },
- (map {
+ (map {
{ label => $_, text => scalar warp_text(formatAlaTeX($help{$_}), 60), val => \$options->{$_}, hidden => scalar(/password/),
advanced => !$part->{rootDevice} && !member($_, @simple_options), if_(!/=$/, type => 'bool'),
if_($callbacks{$_}, changed => $callbacks{$_}),
@@ -929,27 +1171,6 @@ sub Options {
if (($options->{usrquota} || $options->{grpquota}) && !$::isInstall) {
$in->do_pkgs->ensure_binary_is_installed('quota', 'quotacheck');
}
- if ($options->{encrypted}) {
- # modify $part->{options} for the check
- local $part->{options};
- fs::mount_options::pack($part, $options, $unknown);
- if (!check($in, $hd, $part, $all_hds)) {
- $options->{encrypted} = 0;
- } elsif (!$part->{encrypt_key} && !isSwap($part)) {
- if (my ($encrypt_key, $encrypt_algo) = choose_encrypt_key($in, $options, '')) {
- $options->{'encryption='} = $encrypt_algo;
- $part->{encrypt_key} = $encrypt_key;
- } else {
- $options->{encrypted} = 0;
- }
- }
- #- don't be sure of anything
- set_isFormatted($part, 0);
- $part->{notFormatted} = 0;
- } else {
- delete $options->{'encryption='};
- delete $part->{encrypt_key};
- }
}) or return;
fs::mount_options::pack($part, $options, $unknown);
@@ -957,20 +1178,22 @@ sub Options {
}
-{
- no strict;
- *{'Toggle to normal mode'} = sub() { $::expert = 0 };
- *{'Toggle to expert mode'} = sub() { $::expert = 1 };
+{
+ no strict;
+ *{'Normal mode'} = sub() { $::expert = 0 };
+ *{'Expert mode'} = sub() { $::expert = 1 };
*{'Clear all'} = \&Clear_all;
*{'Auto allocate'} = \&Auto_allocate;
*{'Mount point'} = \&Mount_point;
*{'Modify RAID'} = \&ModifyRAID;
*{'Add to RAID'} = \&Add2RAID;
- *{'Remove from RAID'} = \&RemoveFromRAID;
+ *{'Remove from RAID'} = \&RemoveFromRAID;
+ *{Use} = \&dmcrypt_open;
+ *{'Remove from dm'} = \&RemoveFromDm;
*{'Add to LVM'} = \&Add2LVM;
- *{'Remove from LVM'} = \&RemoveFromLVM;
+ *{'Remove from LVM'} = \&RemoveFromLVM;
*{'Use for loopback'} = \&Loopback;
- *{'Hard drive information'} = \&Hd_info;
+ *{'Hard disk drive information'} = \&Hd_info;
}
@@ -989,7 +1212,7 @@ sub modifyRAID {
$in->ask_from(N("Options"), '',
[
{ label => N("device"), val => \$new_device, list => [ $md_part->{device}, raid::free_mds($raids) ], sort => 0 },
-{ label => N("level"), val => \$md_part->{level}, list => [ qw(0 1 4 5 6 linear) ] },
+{ label => N("level"), val => \$md_part->{level}, list => [ qw(0 1 4 5 6 10 linear) ] },
{ label => N("chunk size in KiB"), val => \$md_part->{'chunk-size'} },
],
) or return;
@@ -1007,7 +1230,7 @@ sub ask_alldatamaybelost {
#- here we may have a non-formatted or a formatted partition
#- -> doing as if it was formatted
- $in->ask_okcancel(N("Read carefully!"),
+ $in->ask_okcancel(N("Read carefully"),
[ N("Be careful: this operation is dangerous."), sprintf(translate($msg), $part->{device}) ], 1);
}
sub ask_alldatawillbelost {
@@ -1017,13 +1240,14 @@ sub ask_alldatawillbelost {
#- here we may have a non-formatted or a formatted partition
#- -> doing as if it was formatted
- $in->ask_okcancel(N("Read carefully!"), sprintf(translate($msg), $part->{device}), 1);
+ $in->ask_okcancel(N("Read carefully"), sprintf(translate($msg), $part->{device}), 1);
}
sub partitions_suggestions {
- my ($in) = @_;
- my $t = $::expert ?
- $in->ask_from_list_(N("Type"), N("What type of partitioning?"), [ keys %fsedit::suggestions ]) :
+ my ($in, $all_hds, $hd) = @_;
+ fsedit::init_mntpnt_suggestions($all_hds, $hd);
+ my $t = $::expert ?
+ $in->ask_from_list_(N("Partitioning Type"), N("What type of partitioning?"), [ keys %fsedit::suggestions ]) :
'simple';
$fsedit::suggestions{$t};
}
@@ -1036,14 +1260,14 @@ sub check_type {
return;
}
if ($::isStandalone && $type->{fs_type} && fs::format::known_type($type)) {
- fs::format::check_package_is_installed($in->do_pkgs, $type->{fs_type}) or return;
+ fs::format::check_package_is_installed_format($in->do_pkgs, $type->{fs_type}) or return;
}
1;
}
sub check_mntpoint {
my ($in, $mntpoint, $part, $all_hds) = @_;
my $seen;
- eval {
+ eval {
catch_cdie { fsedit::check_mntpoint($mntpoint, $part, $all_hds) }
sub { $seen = 1; $in->ask_okcancel(N("Error"), formatError($@)) };
};
@@ -1061,7 +1285,7 @@ sub check {
sub check_rebootNeeded {
my ($_in, $hd) = @_;
- $hd->{rebootNeeded} and die N("You'll need to reboot before the modification can take place");
+ $hd->{rebootNeeded} and die N("You'll need to reboot before the modification can take effect");
}
sub write_partitions {
@@ -1070,7 +1294,7 @@ sub write_partitions {
$hd->{isDirty} or return 1;
isLVM($hd) and return 1;
- $in->ask_okcancel(N("Read carefully!"), N("Partition table of drive %s is going to be written to disk!", $hd->{device}), 1) or return;
+ $in->ask_okcancel(N("Read carefully"), N("Partition table of drive %s is going to be written to disk", $hd->{device}), 1) or return;
partition_table::write($hd) if !$::testing;
check_rebootNeeded($in, $hd) if !$b_skip_check_rebootNeeded;
# fix resizing's failures due to udev's race when writing the partition table
@@ -1081,14 +1305,21 @@ sub write_partitions {
sub ensure_we_have_encrypt_key_if_needed {
my ($in, $part) = @_;
- if ($part->{options} =~ /encrypted/ && !$part->{encrypt_key}) {
- my ($options, $unknown) = fs::mount_options::unpack($part);
- $part->{encrypt_key} = choose_encrypt_key($in, $options, 'skip_encrypt_algo') or return;
- fs::mount_options::pack($part, $options, $unknown);
+ if (fs::type::isRawLUKS($part)) {
+ $part->{dmcrypt_key} ||= choose_encrypt_key($in, {}, 'skip_encrypt_algo') or return;
}
1;
}
+sub dmcrypt_format {
+ my ($in, $_hd, $part, $_all_hds) = @_;
+ my $_wait = $in->wait_message(N("Please wait"), N("Formatting partition %s", $part->{device}));
+ require fs::dmcrypt;
+ fs::dmcrypt::format_part($part);
+ # we open it now:
+ &dmcrypt_open;
+}
+
sub format_ {
my ($in, $hd, $part, $all_hds) = @_;
@@ -1096,15 +1327,25 @@ sub format_ {
write_partitions($in, $_) or return foreach isRAID($part) ? @{$all_hds->{hds}} : $hd;
ask_alldatawillbelost($in, $part, N_("After formatting partition %s, all data on this partition will be lost")) or return;
+
+ if (fs::type::isRawLUKS($part)) {
+ return &dmcrypt_format;
+ }
if ($::isStandalone) {
- fs::format::check_package_is_installed($in->do_pkgs, $part->{fs_type}) or return;
+ fs::format::check_package_is_installed_format($in->do_pkgs, $part->{fs_type}) or return;
}
- if ($::expert && !member($part->{fs_type}, 'reiserfs', 'xfs')) {
- $part->{toFormatCheck} = $in->ask_yesorno(N("Confirmation"), N("Check bad blocks?"));
+ _format_raw($in, $part, $all_hds);
+}
+
+sub _format_raw {
+ my ($in, $part, $all_hds, $o_skip) = @_;
+ if ($::expert && isBlockCheckable($part)) {
+ $part->{toFormatCheck} = $in->ask_yesorno(N("Confirmation"), N("Check for bad blocks?"));
}
$part->{isFormatted} = 0; #- force format;
+ # Wait for the newly created device to appear before formatting it
my ($_w, $wait_message) = $in->wait_message_with_progress_bar;
- fs::format::part($all_hds, $part, $wait_message);
+ fs::format::part($all_hds, $part, $wait_message) if !$o_skip;
1;
}
@@ -1119,12 +1360,12 @@ sub need_migration {
(%s)
You can either choose to move the files into the partition that will be mounted there or leave them where they are (which results in hiding them by the contents of the mounted partition)",
- $mntpoint, formatList(5, @l)),
+ $mntpoint, formatList(5, @l)),
[ { val => \$choice, list => \@choices, type => 'list', format => sub { translate($_[0]) } } ]) or return;
$choice eq $choices[0] ? 'migrate' : 'hide';
} else {
'hide';
- }
+ }
}
sub migrate_files {
@@ -1134,11 +1375,11 @@ sub migrate_files {
my $handle = any::inspect($part, '', 'rw');
my @l = glob_("$part->{mntpoint}/*");
foreach (@l) {
- $wait->set(N("Copying %s", $_));
+ $wait->set(N("Copying %s", $_));
system("cp", "-a", $_, $handle->{dir}) == 0 or die "copying failed";
}
foreach (@l) {
- $wait->set(N("Removing %s", $_));
+ $wait->set(N("Removing %s", $_));
system("rm", "-rf", $_) == 0 or die "removing files failed";
}
}
@@ -1150,7 +1391,7 @@ sub warn_if_renumbered {
push @{$hd->{allPartitionsRenumbered}}, @$l;
- my @l = map {
+ my @l = map {
my ($old, $new) = @$_;
N("partition %s is now known as %s", $old, $new) } @$l;
$in->ask_warn(N("Warning"), join("\n", N("Partitions have been renumbered: "), @l));
@@ -1179,26 +1420,20 @@ sub format_part_info {
$info .= N("Mount point: ") . "$part->{mntpoint}\n" if $part->{mntpoint};
$info .= N("Device: ") . "$part->{device}\n" if $part->{device} && !isLoopback($part);
- $info .= N("Volume label: ") . "$part->{device_LABEL}\n" if $part->{device_LABEL} && $::expert;
+ $info .= N("Volume label: ") . "$part->{device_LABEL}\n" if $part->{device_LABEL};
$info .= N("UUID: ") . "$part->{device_UUID}\n" if $::expert && $part->{device_UUID};
$info .= N("DOS drive letter: %s (just a guess)\n", $part->{device_windobe}) if $part->{device_windobe};
- if (arch() eq "ppc") {
- my $pType = $part->{pType};
- $pType =~ s/[^A-Za-z0-9_]//g;
- $info .= N("Type: ") . $pType . ($::expert ? sprintf " (0x%x)", $part->{pt_type} : '') . "\n";
- if (defined $part->{pName}) {
- my $pName = $part->{pName};
- $pName =~ s/[^A-Za-z0-9_]//g;
- $info .= N("Name: ") . $pName . "\n";
- }
- } elsif (isEmpty($part)) {
+ if (isEmpty($part)) {
$info .= N("Empty") . "\n";
} else {
$info .= N("Type: ") . (fs::type::part2type_name($part) || $part->{fs_type}) . ($::expert ? sprintf " (0x%x)", $part->{pt_type} : '') . "\n";
}
$info .= N("Start: sector %s\n", $part->{start}) if $::expert && !isSpecial($part) && !isLVM($hd);
- $info .= N("Size: %s", formatXiB($part->{size}, 512));
- $info .= sprintf " (%s%%)", int 100 * $part->{size} / $hd->{totalsectors} if $hd->{totalsectors};
+ if ($hd->{totalsectors}) {
+ $info .= N("Size: %s (%s%% of disk)", formatXiB($part->{size}, 512), int 100 * $part->{size} / $hd->{totalsectors});
+ } else {
+ $info .= N("Size: %s", formatXiB($part->{size}, 512));
+ }
$info .= N(", %s sectors", $part->{size}) if $::expert;
$info .= "\n";
$info .= N("Cylinder %d to %d\n", $part->{start} / $hd->cylinder_size, ($part->{start} + $part->{size} - 1) / $hd->cylinder_size) if ($::expert || isEmpty($part)) && !isSpecial($part) && !isLVM($hd) && $hd->cylinder_size;
@@ -1207,6 +1442,14 @@ sub format_part_info {
$info .= N("Not formatted\n") if !$part->{isFormatted} && $part->{notFormatted};
$info .= N("Mounted\n") if $part->{isMounted};
$info .= N("RAID %s\n", $part->{raid}) if isPartOfRAID($part);
+ if (fs::type::isRawLUKS($part) || fs::type::isLUKS($part)) {
+ $info .= N("Encrypted") . "\n";
+ if (fs::type::isRawLUKS($part)) {
+ $info .= ($part->{dm_active} && $part->{dm_name} ? N(" (mapped on %s)", $part->{dm_name}) :
+ $part->{dm_name} ? N(" (to map on %s)", $part->{dm_name}) :
+ N(" (inactive)")) . "\n";
+ }
+ }
if (isPartOfLVM($part)) {
$info .= sprintf "LVM %s\n", $part->{lvm};
$info .= sprintf "Used physical extents %d / %d\n", lvm::pv_physical_extents($part);
@@ -1231,7 +1474,7 @@ sub format_part_info {
$info;
}
-sub format_part_info_short {
+sub format_part_info_short {
my ($hd, $part) = @_;
isEmpty($part) ? N("Free space on %s (%s)", $hd->{device}, formatXiB($part->{size}, 512))
: partition_table::description($part);
@@ -1250,6 +1493,8 @@ sub format_hd_info {
$info .= N("LVM-disks %s\n", join ", ", map { $_->{device} } @{$hd->{disks}}) if isLVM($hd) && $hd->{disks};
$info .= N("Partition table type: %s\n", $1) if $::expert && ref($hd) =~ /_([^_]+)$/;
$info .= N("on channel %d id %d\n", $hd->{channel}, $hd->{id}) if $::expert && exists $hd->{channel};
+ # restrict the length of the lines
+ $info =~ s/(.{60}).*/$1.../mg;
$info;
}
@@ -1292,15 +1537,15 @@ sub choose_encrypt_key {
$in->ask_from_(
{
- title => N("Filesystem encryption key"),
+ title => N("Filesystem encryption key"),
messages => N("Choose your filesystem encryption key"),
- callbacks => {
+ callbacks => {
complete => sub {
length $encrypt_key < 6 and $in->ask_warn(N("Warning"), N("This encryption key is too simple (must be at least %d characters long)", 6)), return 1,0;
$encrypt_key eq $encrypt_key2 or $in->ask_warn(N("Error"), [ N("The encryption keys do not match"), N("Please try again") ]), return 1,1;
return 0;
} } }, [
-{ label => N("Encryption key"), val => \$encrypt_key, hidden => 1 },
+{ label => N("Encryption key"), val => \$encrypt_key, hidden => 1, focus => sub { 1 } },
{ label => N("Encryption key (again)"), val => \$encrypt_key2, hidden => 1 },
if_(!$skip_encrypt_algo,
{ label => N("Encryption algorithm"), type => 'list', val => \$encrypt_algo, list => \@algorithms },
@@ -1316,7 +1561,7 @@ sub tell_wm_and_reboot() {
if (!$wm) {
system('reboot');
- } else {
+ } else {
any::ask_window_manager_to_logout_then_do($wm, $pid, 'reboot');
}
}
generated by cgit v1.2.1 (git 2.21.0) at 2025-10-23 20:26:04 +0000