backport diskdrake from 2010.1, remove ext4 support

10 files changed, 622 insertions, 198 deletions

diff --git a/perl-install/fs/any.pm b/perl-install/fs/any.pm
index 35be4a1c0..65ca02403 100644
--- a/perl-install/fs/any.pm
+++ b/perl-install/fs/any.pm
@@ -1,4 +1,4 @@
-package fs::any; # $Id: any.pm 240142 2008-03-20 01:18:10Z blino $
+package fs::any; # $Id: any.pm 269745 2010-06-02 11:21:42Z pterjan $
 
 use diagnostics;
 use strict;
@@ -97,11 +97,8 @@ sub prepare_minimal_root {
     eval { fs::mount::mount('none', "$::prefix/sys", 'sysfs') };
     eval { fs::mount::usbfs($::prefix) };
 
-    #- needed by lilo
-    if (-d '/dev/mapper' && !$::local_install) {
-	my @vgs = map { $_->{VG_name} } @{$all_hds->{lvms}};
-	-e "/dev/$_" and cp_af("/dev/$_", "$::prefix/dev") foreach 'mapper', @vgs;
-    }
+    # copy all needed devices, for bootloader install and mkinitrd
+    cp_af("/dev", "$::prefix");
 }
 
 sub getAvailableSpace {
diff --git a/perl-install/fs/dmcrypt.pm b/perl-install/fs/dmcrypt.pm
index e2d67b37a..0b9c58337 100644
--- a/perl-install/fs/dmcrypt.pm
+++ b/perl-install/fs/dmcrypt.pm
@@ -16,10 +16,8 @@ sub _crypttab() { "$::prefix/etc/crypttab" }
 sub init() {
     whereis_binary('cryptsetup') or die "cryptsetup not installed";
 
-    eval { modules::load('dm-crypt', 'cbc', 'sha256_generic', arch() =~ /i.86/ ? 'aes-i586' : 'aes') };
+    eval { modules::load('dm-crypt', 'cbc', 'sha256_generic', if_(arch() =~ /i.86/, 'aes-i586'), if_( arch() =~ /x86_64/, 'aes-x86_64'), 'aes_generic') };
     devices::init_device_mapper();
-    if ($::isInstall) {
-    }
     1;
 }
 my $initialized;
@@ -80,6 +78,7 @@ sub open_part {
 	_run_or_die('luksOpen', devices::make($part->{device}), 
 				$part->{dm_name}, '--key-file', $_[0]);
     });
+    run_program::run('udevadm', 'settle') unless $::isInstall;
 
     my $active_dmcrypt = _parse_dmsetup_table($part->{dm_name}, 
 					      run_program::get_stdout('dmsetup', 'table', $part->{dm_name}));
@@ -110,8 +109,11 @@ sub get_existing {
 sub _get_existing_one {
     my ($fstab, $active_dmcrypt) = @_;
 
+    my $p = fs::wild_device::to_subpart("/dev/mapper/$active_dmcrypt->{name}");
+
     my $part = { device => "mapper/$active_dmcrypt->{name}", size => $active_dmcrypt->{size}, 
-		 options => 'noatime', dmcrypt_name => $active_dmcrypt->{name} };
+		 options => 'noatime', dmcrypt_name => $active_dmcrypt->{name},
+		 major => $p->{major}, minor => $p->{minor} };
 
     if (my $raw_part = find { fs::get::is_same_hd($active_dmcrypt, $_) } @$fstab) {
 	$part->{rootDevice} = $raw_part->{device};
@@ -126,7 +128,7 @@ sub _get_existing_one {
     }
     fs::type::set_isFormatted($part, to_bool($part->{fs_type}));
     
-    $part->{fs_type} or fs::type::set_fs_type($part, 'ext3');
+    $part->{fs_type} or fs::type::set_fs_type($part, defaultFS());
 
     log::l("dmcrypt: found $part->{device} type $part->{fs_type} with rootDevice $part->{rootDevice}");
 
@@ -146,7 +148,7 @@ sub _parse_dmsetup_table {
 }
 
 sub active_dm() {
-    run_program::run('udevadm', 'settle');
+    run_program::run('udevadm', 'settle') unless $::isInstall;
 
     map {
 	my $name = s/(.*?):\s*// && $1;
diff --git a/perl-install/fs/dmraid.pm b/perl-install/fs/dmraid.pm
index 319e48aa5..a744f01af 100644
--- a/perl-install/fs/dmraid.pm
+++ b/perl-install/fs/dmraid.pm
@@ -1,4 +1,4 @@
-package fs::dmraid; # $Id: dmraid.pm 247256 2008-10-01 13:07:51Z pixel $
+package fs::dmraid; # $Id: dmraid.pm 265309 2010-01-27 00:28:23Z pterjan $
 
 use diagnostics;
 use strict;
@@ -40,10 +40,26 @@ sub check {
 }
 
 sub _raid_devices_raw() {
+    # get the real vg names, needed for ddf1, and safer than begins_with for raid10
+    log::l("_raid_devices_raw");
+    my %vgs;
+    my %pv2vg = map {
+	log::l("got: $_");
+	my %l; @l{qw(name size stride level status subsets devs spares)} = split(':');
+	$vgs{$l{name}} = 1 if defined $l{spares};
+	if(/freeing device "(.*)", path "(.*)"/ && defined $vgs{$1}) {
+	    log::l("$2 => $1");
+	    { $2 => $1 };
+        }
+    } call_dmraid('-d', '-s', '-c', '-c');
     map {
 	chomp;
 	log::l("got: $_");
 	my %l; @l{qw(pv format vg level status size)} = split(':');
+	if(defined $l{size} && defined $l{vg} && defined $pv2vg{$l{pv}} && !defined $vgs{$l{vg}}) {
+	    log::l("using $pv2vg{$l{pv}} instead of $l{vg}");
+	    $l{vg} = $pv2vg{$l{pv}};
+	}
 	if_(defined $l{size}, \%l);
     } call_dmraid('-r', '-c', '-c');
 }
diff --git a/perl-install/fs/format.pm b/perl-install/fs/format.pm
index fcb40dd78..9d328964b 100644
--- a/perl-install/fs/format.pm
+++ b/perl-install/fs/format.pm
@@ -1,4 +1,4 @@
-package fs::format; # $Id: format.pm 245954 2008-09-18 14:18:46Z pixel $
+package fs::format; # $Id: format.pm 268842 2010-05-17 06:54:44Z pterjan $
 
 use diagnostics;
 use strict;
@@ -13,7 +13,7 @@ use log;
 my %cmds = (
     ext2     => [ 'e2fsprogs', 'mkfs.ext2', '-F' ],
     ext3     => [ 'e2fsprogs', 'mkfs.ext3', '-F' ],
-    ext4dev     => [ 'e2fsprogs', 'mkfs.ext3', '-F', '-I', '256' ], # FIXME: enable more options once we've better mkfs support
+    ext4     => [ 'e2fsprogs', 'mkfs.ext4', '-F' ],
     reiserfs => [ 'reiserfsprogs', 'mkfs.reiserfs', '-ff' ],
     reiser4  => [ 'reiser4progs', 'mkfs.reiser4', '-f', '-y' ],
     xfs      => [ 'xfsprogs', 'mkfs.xfs', '-f', '-q' ],
@@ -24,19 +24,46 @@ my %cmds = (
     swap     => [ 'util-linux-ng', 'mkswap' ],
     ntfs     => [ 'ntfsprogs', 'mkntfs', '--fast' ],
    'ntfs-3g' => [ 'ntfsprogs', 'mkntfs', '--fast' ],
+    btrfs    => [ 'btrfs-progs', 'mkfs.btrfs' ],
+    nilfs2   => [ 'nilfs-utils', 'mkfs.nilfs2' ],
 );
 
 my %LABELs = ( #- option, length, handled_by_mount
     ext2     => [ '-L', 16, 1 ],
     ext3     => [ '-L', 16, 1 ],
-    ext4dev     => [ '-L', 16, 1 ],
+    ext4     => [ '-L', 16, 1 ],
     reiserfs => [ '-l', 16, 1 ],
+    reiser4  => [ '-L', 16, 1 ],
     xfs      => [ '-L', 12, 1 ],
     jfs      => [ '-L', 16, 1 ],
     hfs      => [ '-l', 27, 0 ],
     dos      => [ '-n', 11, 0 ],
     vfat     => [ '-n', 11, 0 ],
     swap     => [ '-L', 15, 1 ],
+    ntfs     => [ '-L', 128, 0 ],
+   'ntfs-3g' => [ '-L', 128, 0 ],
+    btrfs    => [ '-L', 256, 1 ],
+    nilfs2   => [ '-L', 16, 1],
+);
+
+my %edit_LABEL = ( # package, command, option
+# If option is defined, run <command> <option> <label> <device>
+# If no option, run <command> <device> <label>
+    ext2     => [ 'e2fsprogs', 'tune2fs', '-L' ],
+    ext3     => [ 'e2fsprogs', 'tune2fs', '-L' ],
+    ext4     => [ 'e2fsprogs', 'tune2fs', '-L' ],
+    reiserfs => [ 'reiserfsprogs', 'reiserfstune', '-l' ],
+#    reiser4
+    xfs      => [ 'xfsprogs', 'xfs_admin', '-L' ],
+    jfs      => [ 'jfsutils', 'jfs_tune', '-L' ],
+#    hfs
+    dos      => [ 'mtools', 'mlabel', '-i' ],
+    vfat     => [ 'mtools', 'mlabel', '-i' ],
+#    swap     => [ 'util-linux-ng', 'mkswap' ],
+    ntfs     => [ 'ntfsprogs', 'ntfslabel' ],
+   'ntfs-3g' => [ 'ntfsprogs', 'ntfslabel' ],
+#    btrfs
+#    nilfs2
 );
 
 sub package_needed_for_partition_type {
@@ -50,13 +77,25 @@ sub known_type {
     to_bool($cmds{$part->{fs_type}});
 }
 
-sub check_package_is_installed {
+sub check_package_is_installed_format {
     my ($do_pkgs, $fs_type) = @_;
 
     my ($pkg, $binary) = @{$cmds{$fs_type} || return};
     whereis_binary($binary) || $do_pkgs->ensure_binary_is_installed($pkg, $binary); #- ensure_binary_is_installed checks binary chrooted, whereas we run the binary non-chrooted (pb for Mandriva One)
 }
 
+sub check_package_is_installed_label {
+    my ($do_pkgs, $fs_type) = @_;
+
+    my ($pkg, $binary) = @{$edit_LABEL{$fs_type} || return};
+    whereis_binary($binary) || $do_pkgs->ensure_binary_is_installed($pkg, $binary); #- ensure_binary_is_installed checks binary chrooted, whereas we run the binary non-chrooted (pb for Mandriva One)
+}
+
+sub canEditLabel {
+    my ($part) = @_;
+    to_bool($edit_LABEL{$part->{fs_type}});
+}
+
 sub part {
     my ($all_hds, $part, $wait_message) = @_;
     if (isRAID($part)) {
@@ -72,6 +111,30 @@ sub part {
     }
 }
 
+sub write_label {
+    my ($part) = @_;
+
+    $part->{device_LABEL_changed} or return;
+    maybeFormatted($part) or return;
+
+    if ($part->{encrypt_key}) {
+	fs::mount::set_loop($part);
+    }
+
+    my $dev = $part->{real_device} || $part->{device};
+    my ($_pkg, $cmd, @first_options) = @{$edit_LABEL{$part->{fs_type}} || die N("I do not know how to set label on %s with type %s", $part->{device}, $part->{fs_type})};
+    my @args;
+    if ($cmd eq 'mlabel') {
+      @args = ($cmd, @first_options, devices::make($dev), '::' . $part->{device_LABEL});
+    } elsif (defined $first_options[0]) {
+      @args = ($cmd, @first_options, $part->{device_LABEL}, devices::make($dev));
+    } else {
+      @args = ($cmd, devices::make($dev), $part->{device_LABEL});
+    }
+    run_program::raw({ timeout => 'never' }, @args) or die N("setting label on %s failed, is it formatted?", $dev);
+    delete $part->{device_LABEL_changed};
+}
+
 sub part_raw {
     my ($part, $wait_message) = @_;
 
@@ -88,7 +151,7 @@ sub part_raw {
 
     my $fs_type = $part->{fs_type};
 
-    if (member($fs_type, qw(ext2 ext3 ext4dev))) {
+    if (member($fs_type, qw(ext2 ext3 ext4))) {
 	push @options, "-m", "0" if $part->{mntpoint} =~ m|^/home|;
     } elsif (isDos($part)) {
 	$fs_type = 'dos';
@@ -96,40 +159,41 @@ sub part_raw {
         push @options, '-l', "Untitled";
     } elsif (isAppleBootstrap($part)) {
 	push @options, '-l', 'bootstrap';
-    } elsif (member($fs_type, 'swap', 'ext2', 'ext3')) {
+    }
+
+    # Preserve UUID
+    if (member($fs_type, 'swap', 'ext2', 'ext3', 'ext4')) {
 	push @options, '-U', $part->{device_UUID} if $part->{device_UUID};
+    } elsif ($fs_type eq 'reiserfs') {
+	push @options, '-u', $part->{device_UUID} if $part->{device_UUID};
     }
 
     if ($part->{device_LABEL}) {
-	if ($LABELs{$fs_type}) {
-	    my ($option, $length, $handled_by_mount) = @{$LABELs{$fs_type}};
-	    if (length $part->{device_LABEL} > $length) {
-		my $short = substr($part->{device_LABEL}, 0, $length);
-		log::l("shortening LABEL $part->{device_LABEL} to $short");
-		$part->{device_LABEL} = $short;
-	    }
-	    delete $part->{prefer_device_LABEL}
-	      if !$handled_by_mount || $part->{mntpoint} eq '/' && !member($fs_type, qw(ext2 ext3 ext4dev));
-
-	    push @options, $option, $part->{device_LABEL};
-	} else {
-	    log::l("dropping LABEL=$part->{device_LABEL} since we don't know how to set labels for fs_type $part->{fs_type}");
-	    delete $part->{device_LABEL};
-	    delete $part->{prefer_device_LABEL};
-	}
+	push @options, @{$LABELs{$fs_type}}[0], $part->{device_LABEL};
     }
 
     my ($_pkg, $cmd, @first_options) = @{$cmds{$fs_type} || die N("I do not know how to format %s in type %s", $part->{device}, $part->{fs_type})};
 
     my @args = ($cmd, @first_options, @options, devices::make($dev));
 
-    if ($cmd eq 'mkfs.ext3' && $wait_message) {
+    if ($cmd =~ /^mkfs.ext[34]$/ && $wait_message) {
 	mkfs_ext3($wait_message, @args) or die N("%s formatting of %s failed", $fs_type, $dev);
     } else {
 	run_program::raw({ timeout => 'never' }, @args) or die N("%s formatting of %s failed", $fs_type, $dev);
     }
 
-    if (member($fs_type, qw(ext3 ext4dev))) {
+    delete $part->{device_LABEL_changed};
+
+    # Preserve UUID on fs where we couldn't enforce it while formatting
+    if ($fs_type eq 'jfs') {
+	run_program::raw('jfs_tune', '-U', devices::make($dev));
+    } elsif ($fs_type eq 'xfs') {
+	run_program::raw('xfs_admin', '-U', devices::make($dev));
+    } elsif ($fs_type eq 'btrfs') {
+	#FIXME
+    }
+    
+    if (member($fs_type, qw(ext3 ext4))) {
 	disable_forced_fsck($dev);
     }
 
@@ -166,6 +230,28 @@ sub disable_forced_fsck {
     run_program::run("tune2fs", "-c0", "-i0", devices::make($dev));
 }
 
+sub clean_label {
+    my ($part) = @_;
+    if ($part->{device_LABEL}) {
+	my $fs_type = $part->{fs_type};
+	if ($LABELs{$fs_type}) {
+	    my ($option, $length, $handled_by_mount) = @{$LABELs{$fs_type}};
+	    if (length $part->{device_LABEL} > $length) {
+		my $short = substr($part->{device_LABEL}, 0, $length);
+		log::l("shortening LABEL $part->{device_LABEL} to $short");
+		$part->{device_LABEL} = $short;
+	    }
+	    delete $part->{prefer_device_LABEL}
+	      if !$handled_by_mount || $part->{mntpoint} eq '/' && !member($fs_type, qw(ext2 ext3 ext4));
+	} else {
+	    log::l("dropping LABEL=$part->{device_LABEL} since we don't know how to set labels for fs_type $fs_type");
+	    delete $part->{device_LABEL};
+	    delete $part->{prefer_device_LABEL};
+	    delete $part->{device_LABEL_changed};
+	}
+    }
+}
+
 sub formatMount_part {
     my ($part, $all_hds, $fstab, $wait_message) = @_;
 
@@ -175,12 +261,17 @@ sub formatMount_part {
     if (my $p = fs::get::up_mount_point($part->{mntpoint}, $fstab)) {
 	formatMount_part($p, $all_hds, $fstab, $wait_message) if !fs::type::carry_root_loopback($part);
     }
+
+    clean_label($part);
+
     if ($part->{toFormat}) {
 	fs::format::part($all_hds, $part, $wait_message);
+    } else {
+	fs::format::write_label($part);
     }
 
     #- setting user_xattr on /home (or "/" if no /home)
-    if (!$part->{isMounted} && member($part->{fs_type}, qw(ext3 ext4dev))
+    if (!$part->{isMounted} && member($part->{fs_type}, qw(ext2 ext3 ext4))
 	  && ($part->{mntpoint} eq '/home' ||
 		!fs::get::has_mntpoint('/home', $all_hds) && $part->{mntpoint} eq '/')) {
 	run_program::run('tune2fs', '-o', 'user_xattr', devices::make($part->{real_device} || $part->{device}));
@@ -191,7 +282,7 @@ sub formatMount_part {
 
 sub formatMount_all {
     my ($all_hds, $fstab, $wait_message) = @_;
-    formatMount_part($_, $all_hds, $fstab, $wait_message) 
+    formatMount_part($_, $all_hds, $fstab, $wait_message)
       foreach sort { isLoopback($a) ? 1 : isSwap($a) ? -1 : 0 } grep { $_->{mntpoint} } @$fstab;
 
     #- ensure the link is there
diff --git a/perl-install/fs/mount.pm b/perl-install/fs/mount.pm
index 80baee577..3c0696b75 100644
--- a/perl-install/fs/mount.pm
+++ b/perl-install/fs/mount.pm
@@ -1,4 +1,4 @@
-package fs::mount; # $Id: mount.pm 250965 2009-01-08 08:17:26Z pixel $
+package fs::mount; # $Id: mount.pm 267516 2010-04-12 16:40:47Z pterjan $
 
 use diagnostics;
 use strict;
@@ -35,7 +35,7 @@ sub mount {
     $fs or log::l("not mounting $dev partition"), return;
 
     {
-	my @fs_modules = qw(ext3 ext4dev hfs jfs nfs ntfs romfs reiserfs ufs xfs vfat);
+	my @fs_modules = qw(btrfs ext3 ext4 hfs jfs nilfs2 nfs ntfs romfs reiserfs ufs xfs vfat);
 	my @types = (qw(ext2 proc sysfs usbfs usbdevfs iso9660 devfs devpts auto ntfs-3g), @fs_modules);
 
 	push @types, 'smb', 'cifs', 'davfs2' if !$::isInstall;
@@ -72,6 +72,12 @@ sub mount {
 	fsck_jfs($dev, $o_wait_message);
     } elsif ($fs eq 'ext2' && !$b_rdonly) {
 	fsck_ext2($dev, $o_wait_message);
+    } elsif ($fs eq 'davfs2') {
+	require fs::remote::davfs;
+	# We have to store credentials in davfs2 secret file before mounting
+	fs::remote::davfs::mountpoint_credentials_save($where, \@mount_opt);
+	# username and password options should be handled by /etc/davfs2/secrets file
+	@mount_opt = grep { !/^(username|password)=/ } @mount_opt;
     }
 
     push @mount_opt, 'ro' if $b_rdonly;
@@ -172,7 +178,7 @@ sub part {
 	    }
 	    mount($dev, $mntpoint, $fs_type, $b_rdonly, $options, $o_wait_message);
 
-	    if ($options =~ /usrquota|grpquota/ && member($part->{fs_type}, qw(ext3 ext4dev))) {
+	    if ($options =~ /usrquota|grpquota/ && member($part->{fs_type}, qw(ext3 ext4))) {
 		if (! find { -e "$mntpoint/$_" } qw(aquota.user aquota.group quota.user quota.group)) {
 		    #- quotacheck will create aquota.user and/or aquota.group,
 		    #- needed for quotas on ext3/ext4.
@@ -216,7 +222,7 @@ sub umount_all {
     log::l("unmounting all filesystems");
 
     foreach (sort { $b->{mntpoint} cmp $a->{mntpoint} } 
-	       grep { $_->{mntpoint} && !$_->{real_mntpoint} } @$fstab) {
+	       grep { $_->{mntpoint} && !$_->{real_mntpoint} || isSwap($_) } @$fstab) {
 	umount_part($_);
     }
 }
diff --git a/perl-install/fs/mount_options.pm b/perl-install/fs/mount_options.pm
index 58c2b3d1b..8b8cc0bff 100644
--- a/perl-install/fs/mount_options.pm
+++ b/perl-install/fs/mount_options.pm
@@ -1,4 +1,4 @@
-package fs::mount_options; # $Id: mount_options.pm 250965 2009-01-08 08:17:26Z pixel $
+package fs::mount_options; # $Id: mount_options.pm 268841 2010-05-17 06:52:12Z pterjan $
 
 use diagnostics;
 use strict;
@@ -12,7 +12,7 @@ sub list() {
     my %non_defaults = (
 			sync => 'async', noatime => 'atime', noauto => 'auto', ro => 'rw', 
 			user => 'nouser', nodev => 'dev', noexec => 'exec', nosuid => 'suid',
-			user_xattr => 'nouser_xattr',
+			user_xattr => 'nouser_xattr', acl => 'noacl',
 		       );
     my @user_implies = qw(noexec nodev nosuid);
     \%non_defaults, \@user_implies;
@@ -32,10 +32,9 @@ sub unpack {
 		  nfs => [ qw(rsize=8192 wsize=8192) ],
 		  cifs => [ qw(username= password=) ],
 		  davfs2 => [ qw(username= password= uid= gid=) ],
-		  ext4dev => [ qw(extents) ],
 		  reiserfs => [ 'notail' ],
 		 );
-    push @{$per_fs{$_}}, 'usrquota', 'grpquota' foreach 'ext2', 'ext3', 'ext4dev', 'xfs';
+    push @{$per_fs{$_}}, 'usrquota', 'grpquota' foreach 'ext2', 'ext3', 'ext4', 'xfs';
 
     while (my ($fs, $l) = each %per_fs) {
 	$part->{fs_type} eq $fs || $part->{fs_type} eq 'auto' && member($fs, @auto_fs) or next;
@@ -43,7 +42,6 @@ sub unpack {
     }
 
     $non_defaults->{relatime} = 1 if isTrueLocalFS($part) || $part->{fs_type} eq 'ntfs-3g';
-    $non_defaults->{encrypted} = 1;
 
     my $defaults = { reverse %$non_defaults };
     my %options = map { $_ => '' } keys %$non_defaults;
@@ -111,8 +109,7 @@ sub pack {
 # update me on each util-linux new release:
 sub help() {
     (
-
-	'encrypted' => N("Use an encrypted file system"),
+	'acl' => N("Enable Posix Access Control Lists"),
 
 	'flush' => N("Flush write cache on file close"),
 
@@ -226,16 +223,13 @@ sub set_default {
 			      }) if $part->{is_removable};
 
 	put_in_hash($options, {
-			       'umask=0' => $opts{security} <= 3,
+			       'umask=0' => $opts{security} <= 1,
 			       'iocharset=' => $opts{iocharset}, 'codepage=' => $opts{codepage},
 			      });
     }
-    if ($part->{fs_type} eq 'ext4dev') {
-	put_in_hash($options, { extents => 1 });
-    }
     if ($part->{fs_type} eq 'ntfs') {
 	put_in_hash($options, { ro => 1, 'nls=' => $opts{iocharset},
-				'umask=0' => $opts{security} < 3, 'umask=0022' => $opts{security} < 4,
+				'umask=0' => $opts{security} < 1, 'umask=0022' => $opts{security} < 2,
 			      });
     }
     if (fs::type::can_be_this_fs_type($part, 'iso9660')) {
@@ -245,10 +239,8 @@ sub set_default {
 	$options->{notail} = 1;
 	$options->{user_xattr} = 1;
     }
-    if ($part->{fs_type} eq 'ext3') {
-        $options->{user_xattr} = 1;
-        put_in_hash($options, { acl => 1 }) ;
-
+    if (member($part->{fs_type}, qw(ext2 ext3 ext4))) {
+	$options->{acl} = 1;
     }
     if (isLoopback($part) && !isSwap($part)) { #- no need for loop option for swap files
 	$options->{loop} = 1;
diff --git a/perl-install/fs/mount_point.pm b/perl-install/fs/mount_point.pm
index be1c51c72..5854d4ebe 100644
--- a/perl-install/fs/mount_point.pm
+++ b/perl-install/fs/mount_point.pm
@@ -1,4 +1,4 @@
-package fs::mount_point; # $Id: mount_point.pm 243679 2008-07-29 11:55:58Z tv $
+package fs::mount_point; # $Id: mount_point.pm 269270 2010-05-24 09:55:20Z pterjan $
 
 use diagnostics;
 use strict;
@@ -15,7 +15,7 @@ sub guess_mount_point {
 	     '/boot' => 'vmlinuz',
 	     '/tmp'  => '.X11-unix',
 	     '/usr'  => 'src',
-	     '/var'  => 'catman',
+	     '/var'  => 'spool',
 	    );
 
     my $handle = any::inspect($part, $prefix) or return;
@@ -47,15 +47,15 @@ sub suggest_mount_points {
 sub suggest_mount_points_always {
     my ($fstab) = @_;
 
-    my @win = grep { isFat_or_NTFS($_) && maybeFormatted($_) && !$_->{is_removable} && $_->{pt_type} != 0x12 } @$fstab;
+    my @win = grep { isFat_or_NTFS($_) && !$_->{isMounted} && maybeFormatted($_) && !$_->{is_removable} && $_->{pt_type} != 0x12 && !isRecovery($_)} @$fstab;
     log::l("win parts: ", join ",", map { $_->{device} } @win) if @win;
     if (@win == 1) {
 	#- Suggest /boot/efi on ia64.
-	$win[0]{mntpoint} = arch() =~ /ia64/ ? "/boot/efi" : "/mnt/windows";
+	$win[0]{mntpoint} = arch() =~ /ia64/ ? "/boot/efi" : "/media/windows";
     } else {
 	my %w; foreach (@win) {
 	    my $v = $w{$_->{device_windobe}}++;
-	    $_->{mntpoint} = $_->{unsafeMntpoint} = "/mnt/win_" . lc($_->{device_windobe}) . ($v ? $v+1 : ''); #- lc cuz of StartOffice(!) cf dadou
+	    $_->{mntpoint} = $_->{unsafeMntpoint} = "/media/win_" . lc($_->{device_windobe}) . ($v ? $v+1 : ''); #- lc cuz of StartOffice(!) cf dadou
 	}
     }
 
@@ -80,8 +80,8 @@ sub validate_mount_points {
 	$m{$m} and die N("Duplicate mount point %s", $m);
 	$m{$m} = 1;
 
-	#- in case the type does not correspond, force it to ext3
-	fs::type::set_fs_type($_, 'ext3') if !isTrueFS($_) && !isOtherAvailableFS($_);
+	#- in case the type does not correspond, force it to default fs (ext4 currently)
+	fs::type::set_fs_type($_, defaultFS()) if !isTrueFS($_) && !isOtherAvailableFS($_);
     }
     1;
 }
diff --git a/perl-install/fs/partitioning_wizard.pm b/perl-install/fs/partitioning_wizard.pm
index c79ea7717..110759d04 100644
--- a/perl-install/fs/partitioning_wizard.pm
+++ b/perl-install/fs/partitioning_wizard.pm
@@ -1,4 +1,4 @@
-package fs::partitioning_wizard; # $Id: partitioning_wizard.pm 244422 2008-08-27 16:41:21Z tv $
+package fs::partitioning_wizard; # $Id: partitioning_wizard.pm 269969 2010-06-09 13:01:09Z pterjan $
 
 use diagnostics;
 use strict;
@@ -11,6 +11,8 @@ use fs::type;
 use fs::mount_point;
 use partition_table;
 use partition_table::raw;
+use partition_table::dos;
+use POSIX qw(ceil);
 
 #- unit of $mb is mega bytes, min and max are in sectors, this
 #- function is used to convert back to sectors count the size of
@@ -29,7 +31,7 @@ sub to_Mb {
 
 sub partition_with_diskdrake {
     my ($in, $all_hds, $fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab) = @_;
-    my $ok; 
+    my $ok;
 
     do {
 	$ok = 1;
@@ -45,13 +47,14 @@ sub partition_with_diskdrake {
 	    diskdrake::interactive::main($in, $all_hds, $do_force_reload);
 	}
 	my @fstab = fs::get::fstab($all_hds);
-	
-	unless (fs::get::root_(\@fstab)) {
+
+	unless ($root = fs::get::root_(\@fstab)) {
 	    $ok = 0;
 	    $in->ask_okcancel(N("Partitioning"), N("You must have a root partition.
 For this, create a partition (or click on an existing one).
 Then choose action ``Mount point'' and set it to `/'"), 1) or return;
 	}
+
 	if (!any { isSwap($_) } @fstab) {
 	    $ok &&= $in->ask_okcancel('', N("You do not have a swap partition.\n\nContinue anyway?"));
 	}
@@ -64,22 +67,28 @@ Then choose action ``Mount point'' and set it to `/'"), 1) or return;
 }
 
 sub partitionWizardSolutions {
-    my ($in, $all_hds, $all_fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab) = @_;
+    my ($in, $all_hds, $all_fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab, $target) = @_;
     my $hds = $all_hds->{hds};
-    my $fstab = [ fs::get::fstab($all_hds) ];
+    my $fstab;
+    my $full_fstab = [ fs::get::fstab($all_hds) ];
+    if ($target) {
+        $hds = [ $target ];
+        $fstab = [ grep { $_->{rootDevice} eq $target->{device} } fs::get::fstab($all_hds) ];
+    } else {
+        $fstab = $full_fstab;
+    }
+
     my @wizlog;
     my (%solutions);
 
-    my $min_linux = MB(400);
-    my $max_linux = MB(2000);
+    my $min_linux = MB(600);
     my $min_swap = MB(50);
-    my $max_swap = MB(300);
     my $min_freewin = MB(100);
 
     # each solution is a [ score, text, function ], where the function retunrs true if succeeded
 
     my @hds_rw = grep { !$_->{readonly} } @$hds;
-    my @hds_can_add = grep { $_->can_add } @hds_rw;
+    my @hds_can_add = grep { $_->{type} ne 'hd' || $_->can_add } @hds_rw;
     if (fs::get::hds_free_space(@hds_can_add) > $min_linux) {
 	$solutions{free_space} = [ 30, N("Use free space"), sub { fsedit::auto_allocate($all_hds, $partitions); 1 } ];
     } else { 
@@ -91,67 +100,82 @@ sub partitionWizardSolutions {
 
     if (my @truefs = grep { isTrueLocalFS($_) } @$fstab) {
 	#- value twice the ext2 partitions
-	$solutions{existing_part} = [ 20 + @truefs + @$fstab, N("Use existing partitions"), sub { fs::mount_point::ask_mount_points($in, $fstab, $all_hds) } ];
+	$solutions{existing_part} = [ 20 + @truefs + @$fstab, N("Use existing partitions"), sub { fs::mount_point::ask_mount_points($in, $full_fstab, $all_hds) } ];
     } else {
 	push @wizlog, N("There is no existing partition to use");
     }
 
-    my @fats = grep { $_->{fs_type} eq 'vfat' } @$fstab;
-    fs::df($_) foreach @fats;
-    if (my @ok_forloopback = sort { $b->{free} <=> $a->{free} } grep { $_->{free} > $min_linux + $min_swap + $min_freewin } @fats) {
-	$solutions{loopback} = 
-	  [ -10 - @fats, N("Use the Microsoft Windows® partition for loopback"), 
-	    sub { 
-		my ($s_root, $s_swap);
-		my $part = $in->ask_from_listf('', N("Which partition do you want to use for Linux4Win?"), \&partition_table::description, \@ok_forloopback) or return;
-		$max_swap = $min_swap + 1 if $part->{free} - $max_swap < $min_linux;
-		$in->ask_from('', N("Choose the sizes"), [ 
-		   { label => N("Root partition size in MB: "), val => \$s_root, min => to_Mb($min_linux), max => to_Mb(min($part->{free} - $max_swap, $max_linux)), type => 'range' },
-		   { label => N("Swap partition size in MB: "), val => \$s_swap, min => to_Mb($min_swap),  max => to_Mb($max_swap), type => 'range' },
-		]) or return;
-		push @{$part->{loopback}}, 
-		  { fs_type => 'ext3', loopback_file => '/lnx4win/linuxsys.img', mntpoint => '/',    size => $s_root * 2048, loopback_device => $part, notFormatted => 1 },
-		  { fs_type => 'swap', loopback_file => '/lnx4win/swapfile',     mntpoint => 'swap', size => $s_swap * 2048, loopback_device => $part, notFormatted => 1 };
-		fsedit::recompute_loopbacks($all_hds);
-		1;
-	    } ];
-    } else {
-	push @wizlog, N("There is no FAT partition to use as loopback (or not enough space left)") .
-	  (@fats ? "\nFAT partitions:" . join('', map { "\n  $_->{device} $_->{free} (" . ($min_linux + $min_swap + $min_freewin) . ")" } @fats) : '');
-    }
-
-    
     if (my @ok_for_resize_fat = grep { isFat_or_NTFS($_) && !fs::get::part2hd($_, $all_hds)->{readonly}
-					 && fs::type::part2type_name($_) !~ /^Hidden/ } @$fstab) {
-	$solutions{resize_fat} = 
-	  [ 20 - @ok_for_resize_fat, N("Use the free space on a Microsoft Windows® partition"),
-	    sub {
-		my $part = $in->ask_from_listf_raw({ messages => N("Which partition do you want to resize?"),
-						    interactive_help_id => 'resizeFATChoose',
-						  }, \&partition_table::description, \@ok_for_resize_fat) or return;
-		my $hd = fs::get::part2hd($part, $all_hds);
-		my $resize_fat = eval {
-		    my $pkg = $part->{fs_type} eq 'vfat' ? do { 
-			require resize_fat::main;
-			'resize_fat::main';
-		    } : do {
-			require diskdrake::resize_ntfs;
-			'diskdrake::resize_ntfs';
-		    };
-		    $pkg->new($part->{device}, devices::make($part->{device}));
-		};
-		$@ and die N("The FAT resizer is unable to handle your partition, 
-the following error occurred: %s", formatError($@));
-		my $min_win = do {
-		    my $_w = $in->wait_message(N("Resizing"), N("Computing the size of the Microsoft Windows® partition"));
-		    $resize_fat->min_size;
-		};
-		#- 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_win += partition_table::raw::cylinder_size($hd);
-
-		$part->{size} > $min_linux + $min_swap + $min_freewin + $min_win or die N("Your Microsoft Windows® partition is too fragmented. Please reboot your computer under Microsoft Windows®, run the ``defrag'' utility, then restart the Mandriva Linux installation.");
-		$in->ask_okcancel('', formatAlaTeX(
+					 && !isRecovery($_) && $_->{size} > $min_linux + $min_swap + $min_freewin } @$fstab) {
+        @ok_for_resize_fat = map {
+            my $part = $_;
+            my $hd = fs::get::part2hd($part, $all_hds);
+            my $resize_fat = eval {
+                my $pkg = $part->{fs_type} eq 'vfat' ? do { 
+                    require resize_fat::main;
+                    'resize_fat::main';
+                } : do {
+                    require diskdrake::resize_ntfs;
+                    'diskdrake::resize_ntfs';
+                };
+                $pkg->new($part->{device}, devices::make($part->{device}));
+            };
+            if ($@) {
+                log::l("The FAT resizer is unable to handle $part->{device} partition%s", formatError($@));
+                undef $part;
+            }
+            if ($part) {
+                my $min_win = eval {
+                    my $_w = $in->wait_message(N("Resizing"), N("Computing the size of the Microsoft Windows® partition"));
+                    $resize_fat->min_size + $min_freewin;
+                };
+                if ($@) {
+                    log::l("The FAT resizer is unable to get minimal size for $part->{device} partition %s", formatError($@));
+                    undef $part;
+                } else {
+                    my $min_linux_all = $min_linux + $min_swap;
+                    #- 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_win += partition_table::raw::cylinder_size($hd);
+
+                    if ($part->{size} <= $min_linux_all + $min_win) {
+#                die N("Your Microsoft Windows® partition is too fragmented. Please reboot your computer under Microsoft Windows®, run the ``defrag'' utility, then restart the Mandriva Linux installation.");
+                        undef $part;
+                    } else {
+                        $part->{resize_fat} = $resize_fat;
+                        $part->{min_win} = $min_win;
+                        $part->{min_linux} = $min_linux_all;
+                        #- try to keep at least 1GB free for Windows
+                        #- try to use from 6GB to 10% free space for Linux
+                        my $suggested_size = max(
+                            $part->{min_win} + 1 * MB(1024),
+                            min(
+                                $part->{size} - int(0.1 * ($part->{size} - $part->{min_win})),
+                                $part->{size} - 6 * MB(1024),
+                            ),
+                        );
+                        $part->{req_size} = max(min($suggested_size, $part->{size} - $part->{min_linux}), $part->{min_win});
+                    }
+                }
+            }
+            $part || ();
+        } @ok_for_resize_fat;
+	if (@ok_for_resize_fat) {
+            $solutions{resize_fat} =
+                [ 20 - @ok_for_resize_fat, N("Use the free space on a Microsoft Windows® partition"),
+                  sub {
+                      my $part;
+                      if (!$in->isa('interactive::gtk')) {
+                          $part = $in->ask_from_listf_raw({ messages => N("Which partition do you want to resize?"),
+                                                               interactive_help_id => 'resizeFATChoose',
+                                                             }, \&partition_table::description, \@ok_for_resize_fat) or return;
+                          $part->{size} > $part->{min_linux} + $part->{min_win} or die N("Your Microsoft Windows® partition is too fragmented. Please reboot your computer under Microsoft Windows®, run the ``defrag'' utility, then restart the Mandriva Linux installation.");
+                      } else {
+                          $part = top(grep { $_->{req_size} } @ok_for_resize_fat);
+                      }
+                      my $resize_fat = $part->{resize_fat};
+                      my $hd = fs::get::part2hd($part, $all_hds);
+                      $in->ask_okcancel('', formatAlaTeX(
                                             #-PO: keep the double empty lines between sections, this is formatted a la LaTeX
                                             N("WARNING!
 
@@ -164,49 +188,58 @@ Be careful: this operation is dangerous. If you have not already done so, you fi
 
 When sure, press %s.", N("Next")))) or return;
 
-		my $mb_size = to_Mb($part->{size});
-		$in->ask_from(N("Partitionning"), N("Which size do you want to keep for Microsoft Windows® on partition %s?", partition_table::description($part)), [
-                   { label => N("Size"), val => \$mb_size, min => to_Mb($min_win), max => to_Mb($part->{size} - $min_linux - $min_swap), type => 'range' },
-                ]) or return;
-
-		my $oldsize = $part->{size};
-		$part->{size} = from_Mb($mb_size, $min_win, $part->{size});
-
-		$hd->adjustEnd($part);
-
-		eval { 
-		    my $_w = $in->wait_message(N("Resizing"), N("Resizing Microsoft Windows® partition"));
-		    $resize_fat->resize($part->{size});
-		};
-		if (my $err = $@) {
-		    $part->{size} = $oldsize;
-		    die N("FAT resizing failed: %s", formatError($err));
-		}
-
-		$in->ask_warn('', N("To ensure data integrity after resizing the partition(s), 
+                      my $oldsize = $part->{size};
+                      if (!$in->isa('interactive::gtk')) {
+                          my $mb_size = to_Mb($part->{req_size});
+                          my $max_win = $part->{size} - $part->{min_linux};
+                          $in->ask_from(N("Partitionning"), N("Which size do you want to keep for Microsoft Windows® on partition %s?", partition_table::description($part)), [
+                                        { label => N("Size"), val => \$mb_size, min => to_Mb($part->{min_win}), max => to_Mb($max_win), type => 'range' },
+                                    ]) or return;
+                          $part->{req_size} = from_Mb($mb_size, $part->{min_win}, $part->{max_win});
+                      }
+                      $part->{size} = $part->{req_size};
+
+                      $hd->adjustEnd($part);
+
+                      eval {
+                          my $_w = $in->wait_message(N("Resizing"), N("Resizing Microsoft Windows® partition"));
+                          $resize_fat->resize($part->{size});
+                      };
+                      if (my $err = $@) {
+                          $part->{size} = $oldsize;
+                          die N("FAT resizing failed: %s", formatError($err));
+                      }
+
+                      $in->ask_warn('', N("To ensure data integrity after resizing the partition(s),
 filesystem checks will be run on your next boot into Microsoft Windows®")) if $part->{fs_type} ne 'vfat';
 
-		set_isFormatted($part, 1);
-		partition_table::will_tell_kernel($hd, resize => $part); #- down-sizing, write_partitions is not needed
-		partition_table::adjust_local_extended($hd, $part);
-		partition_table::adjust_main_extended($hd);
+                      set_isFormatted($part, 1);
+                      partition_table::will_tell_kernel($hd, resize => $part); #- down-sizing, write_partitions is not needed
+                      partition_table::adjust_local_extended($hd, $part);
+                      partition_table::adjust_main_extended($hd);
 
-		fsedit::auto_allocate($all_hds, $partitions);
-		1;
-	    } ];
+                      fsedit::auto_allocate($all_hds, $partitions);
+                      1;
+                  }, \@ok_for_resize_fat ];
+        }
     } else {
 	push @wizlog, N("There is no FAT partition to resize (or not enough space left)");
     }
 
     if (@$fstab && @hds_rw) {
 	$solutions{wipe_drive} =
-	  [ 10, fsedit::is_one_big_fat_or_NT($hds) ? N("Remove Microsoft Windows®") : N("Erase and use entire disk"), 
+	  [ 10, fsedit::is_one_big_fat_or_NT($hds) ? N("Remove Microsoft Windows®") : N("Erase and use entire disk"),
 	    sub {
-		my $hd = $in->ask_from_listf_raw({ messages => N("You have more than one hard drive, which one do you install linux on?"),
-						  title => N("Partitioning"),
-						  interactive_help_id => 'takeOverHdChoose',
-						},
-						\&partition_table::description, \@hds_rw) or return;
+                my $hd;
+                if (!$in->isa('interactive::gtk')) {
+                    $hd = $in->ask_from_listf_raw({ messages => N("You have more than one hard drive, which one do you install linux on?"),
+                                                       title => N("Partitioning"),
+                                                       interactive_help_id => 'takeOverHdChoose',
+                                                     },
+                                                     \&partition_table::description, \@hds_rw) or return;
+                } else {
+                    $hd = $target;
+                }
 		$in->ask_okcancel_({ messages => N("ALL existing partitions and their data will be lost on drive %s", partition_table::description($hd)),
 				    title => N("Partitioning"),
 				    interactive_help_id => 'takeOverHdConfirm' }) or return;
@@ -223,7 +256,7 @@ filesystem checks will be run on your next boot into Microsoft Windows®")) if $
     }
 
     $solutions{fdisk} =
-      [ -10, N("Use fdisk"), sub { 
+      [ -10, N("Use fdisk"), sub {
 	    $in->enter_console;
 	    foreach (@$hds) {
 		print "\n" x 10, N("You can now partition %s.
@@ -234,7 +267,7 @@ When you are done, do not forget to save using `w'", partition_table::descriptio
 			$pid = fork() or exec "pdisk", devices::make($_->{device});
 		} else {
 			$pid = fork() or exec "fdisk", devices::make($_->{device});
-		}			
+		}
 		waitpid($pid, 0);
 	    }
 	    $in->leave_console;
@@ -250,34 +283,308 @@ sub warn_reboot_needed {
     $in->ask_warn(N("Partitioning"), N("You need to reboot for the partition table modifications to take place"));
 }
 
-sub main {
-    my ($o, $all_hds, $fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab, $b_nodiskdrake) = @_;
+sub create_display_box {
+    my ($kind, $resize, $fill_empty, $button) = @_;
+    my @parts = fs::get::hds_fstab_and_holes($kind->{val});
+
+    my $totalsectors = $kind->{val}{totalsectors};
+
+    my $width = 540;
+    my $minwidth = 40;
+
+    my $display_box = ugtk2::gtkset_size_request(Gtk2::HBox->new(0,0), -1, 26);
+
+    my $sep_count = @parts - 1;
+    #- ratio used to compute initial partition pixel width (each partition should be > min_width)
+    #- though, the pixel/sectors ratio can not be the same for all the partitions
+    my $initial_ratio = $totalsectors ? ($width - @parts * $minwidth - $sep_count) / $totalsectors : 1;
+
+    my $vbox = Gtk2::VBox->new;
+
+    my $part_sep;
+    my $desc;
+
+    my $last = $resize && $resize->[-1];
+
+    foreach my $entry (@parts) {
+	my $part_info = Gtk2::Label->new($entry->{device_LABEL});
+	my @colorized_fs_types = qw(ext2 ext3 ext4 xfs swap vfat ntfs ntfs-3g);
+        my $part_widget = Gtk2::EventBox->new;
+        $entry->{width} = int($entry->{size} * $initial_ratio) + $minwidth;
+        if ($last && $last->{device} eq $entry->{device}) {
+            #- entry is the last resizable partition
+
+            my $ratio;
+            my $update_ratio = sub { $ratio = $entry->{width} / $entry->{size} };
+            $update_ratio->();
+
+            $part_widget->set_name("PART_vfat");
+            $part_info->set_size_request(ceil($ratio * $entry->{min_win}), 0);
+
+            my $mdv_widget = gtkadd(gtkset_name(Gtk2::EventBox->new, "PART_new"),
+                                    gtkset_size_request(gtknew("Image", file => "small-logo"),
+                                                        $ratio * MB(600), 0));
+
+            my $hpane = Gtk2::HPaned->new;
+            $hpane->add1($part_widget);
+            $hpane->child1_shrink(0);
+            $hpane->add2($mdv_widget);
+            $hpane->child2_shrink(0);
+            $hpane->set_position(ceil($ratio * $entry->{req_size}));
+            ugtk2::gtkset_size_request($hpane, $entry->{width}, 0);
+            ugtk2::gtkpack__($display_box, $hpane);
+
+            my $add_part_size_info = sub {
+                my ($name, $label) = @_;
+                ugtk2::gtkpack__($desc,
+                                 gtkadd(gtkset_name(Gtk2::EventBox->new, $name),
+                                        Gtk2::Label->new(" " x 4)),
+                                 gtkset_size_request(gtkset_alignment($label, 0, 0.5),
+                                                     150, 20));
+            };
+            $desc = Gtk2::HBox->new(0,0);
+
+            my $win_size_label = Gtk2::Label->new;
+            $add_part_size_info->("PART_vfat", $win_size_label);
+
+            my $mdv_size_label = Gtk2::Label->new;
+            $add_part_size_info->("PART_new", $mdv_size_label);
+
+            my $update_size_labels = sub {
+                $win_size_label->set_label(" Windows (" . formatXiB($entry->{req_size}, 512) . ")");
+                $mdv_size_label->set_label(" Mandriva (" . formatXiB($entry->{size} - $entry->{req_size}, 512) . ")");
+                0;
+            };
+            my $update_req_size = sub {
+                $entry->{req_size} = int($hpane->get_position / $ratio);
+                $update_size_labels->();
+            };
+            my $button_activate = sub {
+                $button->activate;
+                0;
+            };
+            $hpane->signal_connect('size-allocate' => sub {
+                my (undef, $alloc) = @_;
+                $entry->{width} = $alloc->width;
+                $update_ratio->();
+                0;
+            });
+            $update_size_labels->();
+            $hpane->signal_connect('motion-notify-event' => $update_req_size);
+            $hpane->signal_connect('move-handle' => $update_req_size);
+            $hpane->signal_connect('button-press-event' => $button_activate);
+            $vbox->signal_connect('button-press-event' => $button_activate);
+            $button->signal_connect('focus-in-event' => sub {
+                $hpane->grab_focus;
+                0;
+            });
+        } else {
+            if ($fill_empty && isEmpty($entry)) {
+                $part_info = gtknew("Image", file => "small-logo");
+                $part_widget->set_name("PART_new");
+            } else {
+                $part_widget->set_name("PART_" . (isEmpty($entry) ? 'empty' :
+                                         $entry->{fs_type} && member($entry->{fs_type}, @colorized_fs_types) ? $entry->{fs_type} :
+                                         'other'));
+            }
+            $part_widget->set_size_request($entry->{width}, 0);
+            ugtk2::gtkpack($display_box, $part_widget);
+        }
+	$part_widget->add($part_info);
 
-    my %solutions = partitionWizardSolutions($o, $all_hds, $fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab);
+	$part_sep = gtkadd(Gtk2::EventBox->new,
+                     gtkset_size_request(Gtk2::Label->new("."), 1, 0));
+	gtkpack__($display_box, $part_sep);
+    }
+    $display_box->remove($part_sep) if $part_sep;
+    unless ($resize || $fill_empty) {
+        my @types = (N_("Ext2/3/4"), N_("XFS"), N_("Swap"), arch() =~ /sparc/ ? N_("SunOS") : arch() eq "ppc" ? N_("HFS") : N_("Windows"),
+                    N_("Other"), N_("Empty"));
+        my %name2fs_type = ('Ext2/3/4' => 'ext3', 'XFS' => 'xfs', Swap => 'swap', Other => 'other', "Windows" => 'vfat', HFS => 'hfs');
+        $desc = ugtk2::gtkpack(Gtk2::HBox->new,
+                map {
+                     my $t = $name2fs_type{$_};
+                     my $ev = Gtk2::EventBox->new;
+		     my $w = Gtk2::Label->new(translate($_));
+	             $ev->add($w);
+		     $ev->set_name('PART_' . ($t || 'empty'));
+                     $ev;
+                } @types);
+    }
 
-    delete $solutions{diskdrake} if $b_nodiskdrake;
+    $vbox->add($display_box);
+    $vbox->add($desc) if $desc;
 
-    my @solutions = sort { $b->[0] <=> $a->[0] } values %solutions;
+    $vbox;
+}
 
-    my @sol = grep { $_->[0] >= 0 } @solutions;
+sub display_choices {
+    my ($o, $contentbox, $mainw, %solutions) = @_;
+    my @solutions = sort { $solutions{$b}[0] <=> $solutions{$a}[0] } keys %solutions;
+    my @sol = grep { $solutions{$_}[0] >= 0 } @solutions;
 
-    log::l(''  . "solutions found: " . join('', map { $_->[1] } @sol) . 
-	   " (all solutions found: " . join('', map { $_->[1] } @solutions) . ")");
+    log::l(''  . "solutions found: " . join('', map { $solutions{$_}[1] } @sol) .
+           " (all solutions found: " . join('', map { $solutions{$_}[1] } @solutions) . ")");
 
     @solutions = @sol if @sol > 1;
     log::l("solutions: ", int @solutions);
     @solutions or $o->ask_warn(N("Partitioning"), N("I can not find any room for installing")), die 'already displayed';
 
-    log::l('HERE: ', join(',', map { $_->[1] } @solutions));
+    log::l('HERE: ', join(',', map { $solutions{$_}[1] } @solutions));
+
+    $contentbox->foreach(sub { $contentbox->remove($_[0]) });
+
+    $mainw->{kind}{display_box} ||= create_display_box($mainw->{kind});
+    ugtk2::gtkpack2__($contentbox, $mainw->{kind}{display_box});
+    ugtk2::gtkpack__($contentbox, gtknew('Label',
+                                         text => N("The DrakX Partitioning wizard found the following solutions:"),
+                                         alignment => [0, 0]));
+
+    my $choicesbox = gtknew('VBox');
+    my $oldbutton;
+    my $sep;
+    foreach my $s (@solutions) {
+        my $item;
+        my $vbox = gtknew('VBox');
+        my $button = gtknew('RadioButton', child => $vbox);
+        if ($s eq 'free_space') {
+            $item = create_display_box($mainw->{kind}, undef, 1);
+        } elsif ($s eq 'resize_fat') {
+            $item = create_display_box($mainw->{kind}, $solutions{$s}[3], undef, $button);
+        } elsif ($s eq 'existing_part') {
+        } elsif ($s eq 'wipe_drive') {
+            $item = Gtk2::EventBox->new;
+            my $b2 = gtknew("Image", file => "small-logo");
+            $item->add($b2);
+            $item->set_size_request(540,26);
+            $item->set_name("PART_new");
+        } elsif ($s eq 'diskdrake') {
+        } else {
+            log::l($s);
+            next;
+        }
+        ugtk2::gtkpack($vbox, 
+                       gtknew('Label',
+                              text => $solutions{$s}[1],
+                              alignment => [0, 0]));
+        ugtk2::gtkpack($vbox, $item) if defined($item);
+        $button->set_group($oldbutton->get_group) if $oldbutton;
+        $oldbutton = $button;
+        $button->signal_connect('toggled', sub { $mainw->{sol} = $solutions{$s} if $_[0]->get_active });
+        ugtk2::gtkpack2__($choicesbox, $button);
+        $sep = gtknew('HSeparator');
+        ugtk2::gtkpack2__($choicesbox, $sep);
+    }
+    $choicesbox->remove($sep);
+    ugtk2::gtkadd($contentbox, $choicesbox);
+    $mainw->{sol} = $solutions{@solutions[0]};
+}
+
+sub main {
+    my ($o, $all_hds, $fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab, $b_nodiskdrake) = @_;
+
     my $sol;
-    $o->ask_from_({ 
-		    title => N("Partitioning"),
-		    interactive_help_id => 'doPartitionDisks',
-		  },
-		  [
-                      { label => N("The DrakX Partitioning wizard found the following solutions:"),  title => $::isInstall },
-                      { val => \$sol, list => \@solutions, format => sub { $_[0][1] }, type => 'list' },
-                  ]);
+
+    if ($o->isa('interactive::gtk')) {
+        require mygtk2;
+        mygtk2->import(qw(gtknew));
+        require ugtk2;
+        ugtk2->import(qw(:wrappers));
+
+        my $mainw = ugtk2->new(N("Partitioning"), %$o, if__($::main_window, transient => $::main_window));
+        $mainw->{box_allow_grow} = 1;
+
+        mygtk2::set_main_window_size($mainw->{rwindow});
+
+        require diskdrake::hd_gtk;
+        diskdrake::hd_gtk::load_theme();
+
+        my $mainbox = Gtk2::VBox->new;
+
+        my @kinds = map { diskdrake::hd_gtk::hd2kind($_) } sort { $a->{is_removable} <=> $b->{is_removable} } @{$all_hds->{hds} };
+        push @kinds, map { diskdrake::hd_gtk::raid2kind($_) } @{$all_hds->{raids}};
+        push @kinds, map { diskdrake::hd_gtk::lvm2kind($_) } @{$all_hds->{lvms}};
+
+        my $hdchoice = Gtk2::HBox->new;
+
+        my $hdchoicelabel = Gtk2::Label->new(N("Here is the content of your disk drive "));
+
+        my $combobox = Gtk2::ComboBox->new_text;
+        foreach (@kinds) {
+            my $info = $_->{val}{info} || $_->{val}{device};
+            $info =~ s|^(?:.*/)?(.{24}).*|$1|;
+            $info .= " (" . formatXiB($_->{val}{totalsectors}, 512) . ")" if $_->{val}{totalsectors};
+            $combobox->append_text($info);
+        }
+        $combobox->set_active(0);
+
+        ugtk2::gtkpack2__($hdchoice, $hdchoicelabel);
+        $hdchoice->add($combobox);
+
+        ugtk2::gtkpack2__($mainbox, $hdchoice);
+
+        my $contentbox = Gtk2::VBox->new(0, 12);
+
+        my $scroll = Gtk2::ScrolledWindow->new;
+        $scroll->set_policy('never', 'automatic'),
+        my $vp = Gtk2::Viewport->new;
+        $vp->set_shadow_type('none');
+        $vp->add($contentbox);
+        $scroll->add($vp);
+        $mainbox->add($scroll);
+
+        my $kind = @kinds[$combobox->get_active];
+        my %solutions = partitionWizardSolutions($o, $all_hds, $fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab, diskdrake::hd_gtk::kind2hd($kind));
+        delete $solutions{diskdrake} if $b_nodiskdrake;
+        $mainw->{kind} = $kind;
+        display_choices($o, $contentbox, $mainw, %solutions);
+
+        $combobox->signal_connect("changed", sub {        
+            $mainw->{kind} = @kinds[$combobox->get_active];
+            my %solutions = partitionWizardSolutions($o, $all_hds, $fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab, diskdrake::hd_gtk::kind2hd($mainw->{kind}));
+            delete $solutions{diskdrake} if $b_nodiskdrake;
+            display_choices($o, $contentbox, $mainw, %solutions);
+            $mainw->{window}->show_all;
+        });
+
+        my @more_buttons = (
+            if_($::isInstall, 
+            [ gtknew('Install_Button',
+                     text => N("Help"),
+                     clicked => sub { interactive::gtk::display_help($o, {interactive_help_id => 'doPartitionDisks' }, $mainw) }),
+              undef, 1 ]),
+            );
+        my $buttons_pack = $mainw->create_okcancel(N("Next"), undef, '', @more_buttons);
+        $mainbox->pack_end($buttons_pack, 0, 0, 0);
+        ugtk2::gtkadd($mainw->{window}, $mainbox);
+        $mainw->{window}->show_all;
+
+        $mainw->main;
+
+        $sol=$mainw->{sol};
+    } else {
+        my %solutions = partitionWizardSolutions($o, $all_hds, $fstab, $manual_fstab, $partitions, $partitioning_flags, $skip_mtab);
+
+        delete $solutions{diskdrake} if $b_nodiskdrake;
+
+        my @solutions = sort { $b->[0] <=> $a->[0] } values %solutions;
+
+        my @sol = grep { $_->[0] >= 0 } @solutions;
+        log::l(''  . "solutions found: " . join('', map { $_->[1] } @sol) . 
+               " (all solutions found: " . join('', map { $_->[1] } @solutions) . ")");
+        @solutions = @sol if @sol > 1;
+        log::l("solutions: ", int @solutions);
+        @solutions or $o->ask_warn(N("Partitioning"), N("I can not find any room for installing")), die 'already displayed';
+        log::l('HERE: ', join(',', map { $_->[1] } @solutions));
+        $o->ask_from_({ 
+            title => N("Partitioning"),
+            interactive_help_id => 'doPartitionDisks',
+                      },
+                      [
+                       { label => N("The DrakX Partitioning wizard found the following solutions:"),  title => $::isInstall },
+                       { val => \$sol, list => \@solutions, format => sub { $_[0][1] }, type => 'list' },
+                      ]);
+    }
     log::l("partitionWizard calling solution $sol->[1]");
     my $ok = eval { $sol->[2]->() };
     if (my $err = $@) {
diff --git a/perl-install/fs/type.pm b/perl-install/fs/type.pm
index 0e17bbd00..bb90bdfe1 100644
--- a/perl-install/fs/type.pm
+++ b/perl-install/fs/type.pm
@@ -1,4 +1,4 @@
-package fs::type; # $Id: type.pm 257105 2009-04-27 15:22:01Z pterjan $
+package fs::type; # $Id: type.pm 269283 2010-05-24 15:31:58Z pterjan $
 
 use diagnostics;
 use strict;
@@ -9,8 +9,8 @@ use devices;
 
 our @ISA = qw(Exporter);
 our @EXPORT = qw(
-   isEmpty isExtended isTrueLocalFS isTrueFS isDos isSwap isOtherAvailableFS isRawLVM isRawRAID isRAID isLVM isMountableRW isNonMountable isPartOfLVM isPartOfRAID isPartOfLoopback isLoopback isMounted isBusy isSpecial isApple isAppleBootstrap isWholedisk isFat_or_NTFS
-   maybeFormatted set_isFormatted
+   isEmpty isExtended isTrueLocalFS isTrueFS isDos isSwap isOtherAvailableFS isRawLVM isRawRAID isRawLUKS isRAID isLVM isLUKS isMountableRW isNonMountable isPartOfLVM isPartOfRAID isPartOfLoopback isLoopback isMounted isBusy isSpecial isApple isAppleBootstrap isWholedisk isFat_or_NTFS isRecovery
+   maybeFormatted set_isFormatted defaultFS
 );
 
 
@@ -22,6 +22,7 @@ my (%type_name2pt_type, %type_name2fs_type, %fs_type2pt_type, %pt_type2fs_type,
   0x82 => 'swap',     'Linux swap',
   0x83 => 'ext2',     'Linux native',
   0x83 => 'ext3',     'Journalised FS: ext3',
+  0x83 => 'ext4',     'Journalised FS: ext4',
   0x83 => 'reiserfs', 'Journalised FS: ReiserFS',
 if_(arch() =~ /ppc|i.86|ia64|x86_64/, 
   0x83 => 'xfs',      'Journalised FS: XFS',
@@ -120,8 +121,9 @@ if_(arch() !~ /ppc/,
   0x81 => '',         'Minix / old Linux',
  if_(!$::isInstall,
   0x83 => 'reiser4',  'Journalised FS: Reiser4',
-  0x83 => 'ext4dev',  'Journalised FS: ext4',
+  0x83 => 'nilfs2',   'NILFS2',
  ),
+  0x83 => 'btrfs',    'Btrfs',
   0x84 => '',         'OS/2 hidden C: drive',
   0x86 => '',         'NTFS volume set (0x86)',
   0x87 => '',         'NTFS volume set (0x87)',
@@ -183,7 +185,7 @@ if_(arch() !~ /ppc/,
 sub type_names { 
     my ($expert, $o_hd) = @_;
     my @l = @{$type_names{important}};
-    push @l, @{$type_names{non_fs_type}};
+    push @l, grep { $_ ne 'Encrypted' } @{$type_names{non_fs_type}};
     push @l, sort @{$type_names{other}} if $expert;
     if ($o_hd && !$o_hd->use_pt_type) {
 	warn "$_ => $type_name2fs_type{$_}\n" foreach @l;
@@ -270,19 +272,19 @@ sub fs_type_from_magic {
     }
 }
 
-sub call_vol_id {
+sub call_blkid {
     my ($part) = @_;
 
     my %h = map {
 	if_(/(.*?)=(.*)/, $1 => $2);
-    } run_program::get_stdout('vol_id', '2>', '/dev/null', devices::make($part->{device}));
+    } run_program::get_stdout('blkid', '2>', '/dev/null', '-o', 'udev', '-p', devices::make($part->{device}));
 
     \%h;
 }
 
 sub type_subpart_from_magic { 
     my ($part) = @_;
-    my $ids = call_vol_id($part);
+    my $ids = call_blkid($part);
 
     my $p;
     if ($ids->{ID_FS_USAGE} eq 'raid') {
@@ -297,19 +299,21 @@ sub type_subpart_from_magic {
 	$p = type_name2subpart('Encrypted');
     } elsif (my $fs_type = $ids->{ID_FS_TYPE}) {
 	$fs_type = 'ntfs-3g' if $fs_type eq 'ntfs';
-	$p = fs_type2subpart($fs_type) or log::l("unknown filesystem $fs_type returned by vol_id");
+	$p = fs_type2subpart($fs_type) or log::l("unknown filesystem $fs_type returned by blkid");
     }
 
     if ($p) {
 	$part->{fs_type_from_magic} = $p->{fs_type};
 	$p->{device_LABEL} = $ids->{ID_FS_LABEL} if $ids->{ID_FS_LABEL};
 	$p->{device_UUID} = $ids->{ID_FS_UUID} if $ids->{ID_FS_UUID};
-	log::l("vol_id gave: $p->{fs_type} $p->{device_UUID} $p->{device_LABEL}");
+	log::l("blkid gave: $p->{fs_type} $p->{device_UUID} $p->{device_LABEL}");
     }
     $p;
 }
 
-sub true_local_fs_types() { qw(ext3 ext2 ext4dev reiserfs reiser4 xfs jfs) }
+sub defaultFS { 'ext4' }
+
+sub true_local_fs_types() { qw(btrfs ext3 ext2 ext4 reiserfs reiser4 xfs jfs) }
 
 sub isEmpty { !$_[0]{fs_type} && $_[0]{pt_type} == 0 }
 sub isEfi { arch() =~ /ia64/ && $_[0]{pt_type} == 0xef }
@@ -323,6 +327,14 @@ sub isDos { arch() !~ /^sparc/ && ${{ 1 => 1, 4 => 1, 6 => 1 }}{$_[0]{pt_type}}
 sub isFat_or_NTFS { member($_[0]{fs_type}, 'vfat', 'ntfs', 'ntfs-3g') }
 sub isApple { $_[0]{pt_type} == 0x401 && defined $_[0]{isDriver} }
 sub isAppleBootstrap { $_[0]{pt_type} == 0x401 && defined $_[0]{isBoot} }
+sub isRecovery { 
+    isFat_or_NTFS($_[0]) && ($_[0]{type_name} =~ /^Hidden/ ||
+        member($_[0]{device_LABEL} , 
+            # Extracted from /usr/share/hal/fdi/policy/10osvendor/20-storage-methods.fdi
+            # Hopefuly we'll ask to hal/udev someday
+            'RECOVERY', 'PQSERVICE', 'HP_RECOVERY', 'Recovery Partition', 'DellUtility', 'DellRestore', 'IBM_SERVICE', 'SERVICEV001', 'SERVICEV002')
+    )
+}
 
 sub isTrueFS { isTrueLocalFS($_[0]) || member($_[0]{fs_type}, qw(nfs)) }
 sub isTrueLocalFS { member($_[0]{fs_type}, true_local_fs_types()) }
@@ -341,9 +353,10 @@ sub isNonMountable {
 sub isPartOfLVM { defined $_[0]{lvm} }
 sub isPartOfRAID { defined $_[0]{raid} }
 sub isPartOfLoopback { defined $_[0]{loopback} }
-sub isRAID { $_[0]{device} =~ /^md/ }
+sub isRAID { $_[0]{device} =~ /^md/ && defined $_[0]{level} }
 sub isUBD { $_[0]{device} =~ /^ubd/ } #- should be always true during an $::uml_install
 sub isLVM { $_[0]{VG_name} || $_[0]{lv_name} }
+sub isLUKS { defined $_[0]{dmcrypt_name} }
 sub isLoopback { defined $_[0]{loopback_file} }
 sub isMounted { $_[0]{isMounted} }
 sub isBusy { isMounted($_[0]) || isPartOfRAID($_[0]) || isPartOfLVM($_[0]) || $_[0]{dm_active} || isPartOfLoopback($_[0]) }
diff --git a/perl-install/fs/wild_device.pm b/perl-install/fs/wild_device.pm
index f2383b6db..efb48d9d7 100644
--- a/perl-install/fs/wild_device.pm
+++ b/perl-install/fs/wild_device.pm
@@ -1,4 +1,4 @@
-package fs::wild_device; # $Id: wild_device.pm 250502 2008-12-16 10:25:09Z pixel $
+package fs::wild_device; # $Id: wild_device.pm 268572 2010-05-11 16:42:46Z pterjan $
 
 use diagnostics;
 use strict;
@@ -44,7 +44,7 @@ sub to_subpart {
 		($part{major}, $part{minor}) = unmakedev($rdev);
 	    }
 
-	    my $symlink = readlink("$::prefix$dev");
+	    my $symlink = readlink("$::prefix$dev") unless $dev =~ m!mapper/!;
 	    $dev =~ s!/u?dev/!!;
 
 	    if ($symlink && $symlink !~ m!^/!) {