This commit was manufactured by cvs2svn to create branch

'unlabeled-1.1.1'.

1 files changed, 104 insertions, 310 deletions

diff --git a/perl-install/fs.pm b/perl-install/fs.pm
index 3d9628071..cf29fe014 100644
--- a/perl-install/fs.pm
+++ b/perl-install/fs.pm
@@ -3,7 +3,7 @@ package fs;
 use diagnostics;
 use strict;
 
-use common qw(:common :file :system :functional);
+use common qw(:common :file :system);
 use log;
 use devices;
 use partition_table qw(:types);
@@ -12,40 +12,24 @@ use nfs;
 use swap;
 use detect_devices;
 use commands;
-use modules;
-use raid;
-use loopback;
 
 1;
 
-sub add_options(\$@) {
-    my ($option, @options) = @_;
-    my %l; @l{split(',', $$option), @options} = (); delete $l{defaults};
-    $$option = join(',', keys %l) || "defaults";
-}
 
 sub read_fstab($) {
     my ($file) = @_;
 
     local *F;
     open F, $file or return;
-
+    
     map {
-	my ($dev, @l) = split;
+	my ($dev, $mntpoint, @l) = split ' ';
 	$dev =~ s,/(tmp|dev)/,,;
-	{ device => $dev, mntpoint => $l[0], type => $l[1], options => $l[2] }
+	while (@l > 4) { $mntpoint .= " " . shift @l; }
+	{ device => $dev, mntpoint => $mntpoint, type => $l[0], options => $l[1] }
     } <F>;
 }
 
-sub up_mount_point {
-    my ($mntpoint, $fstab) = @_;
-    while (1) {
-	$mntpoint = dirname($mntpoint);
-	$mntpoint ne "." or return;
-	$_->{mntpoint} eq $mntpoint and return $_ foreach @$fstab;
-    }
-}
-
 sub check_mounted($) {
     my ($fstab) = @_;
 
@@ -55,7 +39,7 @@ sub check_mounted($) {
     open H, "/proc/swaps";
     foreach (<F>, <G>, <H>) {
 	foreach my $p (@$fstab) {
-	    /$p->{device}\s+([^\s]*)\s+/ and $p->{realMntpoint} = $1, $p->{isMounted} = $p->{isFormatted} = 1;
+	    /$p->{device}\s/ and $p->{isMounted} = 1;
 	}
     }
 }
@@ -68,202 +52,94 @@ sub get_mntpoints_from_fstab($) {
 	    $p->{device} eq $_->{device} or next;
 	    $p->{mntpoint} ||= $_->{mntpoint};
 	    $p->{options} ||= $_->{options};
-	    $_->{type} ne 'auto' && $_->{type} ne type2fs($p->{type}) and
+	    $_->{type} ne 'auto' && $_->{type} ne type2fs($p->{type}) and 
 		log::l("err, fstab and partition table do not agree for $_->{device} type: " . (type2fs($p->{type}) || type2name($p->{type})) . " vs $_->{type}");
 	}
     }
 }
 
-#- mke2fs -b (1024|2048|4096) -c -i(1024 > 262144) -N (1 > 100000000) -m (0-100%) -L volume-label
-#- tune2fs
-sub format_ext2($@) {
-    my ($dev, @options) = @_;
-
-    $dev =~ m,(rd|ida)/, and push @options, qw(-b 4096 -R stride=16); #- For RAID only.
-    push @options, qw(-b 1024 -O none) if arch() =~ /alpha/;
-
-    run_program::run("mke2fs", @options, devices::make($dev)) or die _("%s formatting of %s failed", "ext2", $dev);
-}
-
-sub format_reiserfs($@) {
-    my ($dev, @options) = @_;
-
-    run_program::run("mkreiserfs", "-f", @options, devices::make($dev)) or die _("%s formatting of %s failed", "reiserfs", $dev);
-}
+sub format_ext2($;$) {
+    my ($dev, $bad_blocks) = @_;
+    my @options;
 
-sub format_dos($@) {
-    my ($dev, @options) = @_;
+    $dev =~ m,(rd|ida)/, and push @options, qw(-b 4096 -R stride=16); # For RAID only. 
+    $bad_blocks and push @options, "-c";
 
-    run_program::run("mkdosfs", @options, devices::make($dev)) or die _("%s formatting of %s failed", "dos", $dev);
+    run_program::run("mke2fs", devices::make($dev), @options) or die "ext2 formatting of $dev failed";
 }
 
-sub format_hfs($@) {
-    my ($dev, @options) = @_;
+sub format_dos($;$) {
+    my ($dev, $bad_blocks) = @_;
 
-    run_program::run("hformat", @options, devices::make($dev)) or die _("%s formatting of %s failed", "HFS", $dev);
+    run_program::run("mkdosfs", devices::make($dev), $bad_blocks ? "-c" : ()) or die "dos formatting of $dev failed";
 }
 
-sub real_format_part {
-    my ($part) = @_;
+sub format_part($;$) {
+    my ($part, $bad_blocks) = @_;
 
     $part->{isFormatted} and return;
 
-    my @options = $part->{toFormatCheck} ? "-c" : ();
-    log::l("formatting device $part->{device} (type ", type2name($part->{type}), ")");
-
     if (isExt2($part)) {
-	push @options, "-F" if isLoopback($part);
-	format_ext2($part->{device}, @options);
-    } elsif (isReiserfs($part)) {
-        format_reiserfs($part->{device}, @options);
+	format_ext2($part->{device}, $bad_blocks);
     } elsif (isDos($part)) {
-        format_dos($part->{device}, @options);
-    } elsif (isWin($part)) {
-        format_dos($part->{device}, @options, '-F', 32);
-    } elsif (isHFS($part)) {
-        format_hfs($part->{device}, @options, '-l', "Untitled");
+        format_dos($part->{device}, $bad_blocks);
     } elsif (isSwap($part)) {
-	my $check_blocks = grep { /^-c$/ } @options;
-        swap::make($part->{device}, $check_blocks);
+        swap::make($part->{device}, $bad_blocks);
     } else {
-	die _("I don't know how to format %s in type %s", $_->{device}, type2name($_->{type}));
+	die "don't know how to format $_->{device} in type " . type2name($_->{type});
     }
     $part->{isFormatted} = 1;
 }
-sub format_part {
-    my ($raid, $part, $prefix) = @_;
-    if (raid::is($part)) {
-	raid::format_part($raid, $part);
-    } elsif (isLoopback($part)) {
-	loopback::format_part($part, $prefix);
-    } else {
-	real_format_part($part);
-    }
-}
-
-sub formatMount_part {
-    my ($part, $raid, $fstab, $prefix, $callback) = @_;
-
-    if (isLoopback($part)) {
-	formatMount_part($part->{device}, $raid, $fstab, $prefix, $callback);
-    }
-    if (my $p = up_mount_point($part->{mntpoint}, $fstab)) {
-	formatMount_part($p, $raid, $fstab, $prefix, $callback) unless loopback::carryRootLoopback($part);
-    }
-
-    if ($part->{toFormat}) {
-	$callback->($part) if $callback;
-	format_part($raid, $part, $prefix);
-    }
-    mount_part($part, $prefix);
-}
-
-sub formatMount_all {
-    my ($raid, $fstab, $prefix, $callback) = @_;
-    formatMount_part($_, $raid, $fstab, $prefix, $callback) 
-      foreach sort { isLoopback($a) ? 1 : isSwap($a) ? -1 : 0 } grep { $_->{mntpoint} } @$fstab;
-
-    #- ensure the link is there
-    loopback::carryRootCreateSymlink($_, $prefix) foreach @$fstab;
-
-    #- for fun :)
-    #- that way, when install exits via ctrl-c, it gives hand to partition
-    eval {
-	local $SIG{__DIE__} = 'ignore';
-	my ($type, $major, $minor) = devices::entry(fsedit::get_root($fstab)->{device});
-	output "/proc/sys/kernel/real-root-dev", makedev($major, $minor);
-    };
-}
 
 sub mount($$$;$) {
-    my ($dev, $where, $fs, $rdonly) = @_;
+    my ($dev, $where, $fs, $rdonly) = @_; 
     log::l("mounting $dev on $where as type $fs");
-
+  
+    $::testing and return;
+    
     -d $where or commands::mkdir_('-p', $where);
-
+    
     if ($fs eq 'nfs') {
 	log::l("calling nfs::mount($dev, $where)");
-	nfs::mount($dev, $where) or die _("nfs mount failed");
+	nfs::mount($dev, $where) or die "nfs mount failed";
     } elsif ($fs eq 'smb') {
 	die "no smb yet...";
-    } else {
-	$dev = devices::make($dev) if $fs ne 'proc';
-
-	my $flag = c::MS_MGC_VAL();
-	$flag |= c::MS_RDONLY() if $rdonly;
-	my $mount_opt = "";
-
-	if ($fs eq 'vfat') {
-	    $mount_opt = 'check=relaxed';
-	    eval { modules::load('vfat') }; #- try using vfat
-	    eval { modules::load('msdos') } if $@; #- otherwise msdos...
-	} elsif ($fs eq 'ufs') {
-	    eval { modules::load('ufs') };
-	} elsif ($fs eq 'reiserfs') {
-	    #- could be better if we knew if there is a /boot or not
-	    #- without knowing it, / is forced to be mounted with notail
-	    $mount_opt = 'notail' if $where =~ m|/(boot)?$|;
-	    eval { modules::load('reiserfs') };
-	} elsif ($fs eq 'romfs') {
-	    eval { modules::load('romfs') };
-	}
-
-	$where =~ s|/$||;
-	log::l("calling mount($dev, $where, $fs, $flag, $mount_opt)");
-	syscall_('mount', $dev, $where, $fs, $flag, $mount_opt) or die _("mount failed: ") . "$!";
     }
+    $dev = devices::make($dev);
+  
+    my $flag = 0;#c::MS_MGC_VAL();
+    $flag |= c::MS_RDONLY() if $rdonly;
+    my $mount_opt = $fs eq 'vfat' ? "check=relaxed" : "";
+  
+    log::l("calling mount($dev, $where, $fs, $flag, $mount_opt)");
+    syscall_('mount', $dev, $where, $fs, $flag, $mount_opt) or die "mount failed: $!";
+
     local *F;
-    open F, ">>/etc/mtab" or return; #- fail silently, must be read-only /etc
+    open F, ">>/etc/mtab" or return; # fail silently, must be read-only /etc
     print F "$dev $where $fs defaults 0 0\n";
 }
 
-#- takes the mount point to umount (can also be the device)
-sub umount($) {
+# takes the mount point to umount (can also be the device)
+sub umount($) { 
     my ($mntpoint) = @_;
-    log::l("calling umount($mntpoint)");
-    syscall_('umount', $mntpoint) or die _("error unmounting %s: %s", $mntpoint, "$!");
+    syscall_('umount', $mntpoint) or die "error unmounting $mntpoint: $!";;
 
-    my @mtab = cat_('/etc/mtab'); #- don't care about error, if we can't read, we won't manage to write... (and mess mtab)
+    my @mtab = cat_('/etc/mtab'); # don't care about error, if we can't read, we won't manage to write... (and mess mtab)
     local *F;
     open F, ">/etc/mtab" or return;
     foreach (@mtab) { print F $_ unless /(^|\s)$mntpoint\s/; }
 }
 
-sub mount_part($;$$) {
-    my ($part, $prefix, $rdonly) = @_;
-
-    if ($part->{realMntpoint} eq "/tmp/hdimage") {
-	my $dir = "$prefix$part->{mntpoint}";
-	$dir =~ s|/+$||;
-	log::l("special hd case ($dir)");
-	rmdir $dir;
-	symlink "/tmp/hdimage", $dir;
-	return;
-    }
-    #- root carrier's link can't be mounted
-    loopback::carryRootCreateSymlink($part, $prefix);
-
-    return if $part->{isMounted};
-
-    unless ($::testing) {
-	if (isSwap($part)) {
-	    swap::swapon(isLoopback($part) ? $prefix . loopback::file($part) : $part->{device});
-	} else {
-	    $part->{mntpoint} or die "missing mount point";
-
-	    my $dev = $part->{device};
-	    my $mntpoint = ($prefix || '') . $part->{mntpoint};
-	    if (isLoopback($part)) {
-		eval { modules::load('loop') };
-		$dev = $part->{real_device} = devices::set_loop($prefix . loopback::file($part)) || die;
-	    } elsif (loopback::carryRootLoopback($part)) {
-		$mntpoint = "/initrd/loopfs";
-	    }
-	    mount(devices::make($dev), $mntpoint, type2fs($part->{type}), $rdonly);
-	    rmdir "$mntpoint/lost+found";
-	}
-    }
-    $part->{isMounted} = $part->{isFormatted} = 1; #- assume that if mount works, partition is formatted
+sub mount_part($;$) {
+    my ($part, $prefix) = @_;
+    
+    $part->{isMounted} and return;
+    $part->{mntpoint} or die "missing mount point";
+    
+    isSwap($part) ?
+	swap::swapon($part->{device}) :
+	mount(devices::make($part->{device}), ($prefix || '') . $part->{mntpoint}, type2fs($part->{type}), 0);
+    $part->{isMounted} = 1;
 }
 
 sub umount_part($;$) {
@@ -271,27 +147,20 @@ sub umount_part($;$) {
 
     $part->{isMounted} or return;
 
-    unless ($::testing) {
-	if (isSwap($part)) {
-	    swap::swapoff($part->{device});
-	} elsif (loopback::carryRootLoopback($part)) {
-	    umount("/initrd/loopfs");
-	} else {
-	    umount(($prefix || '') . $part->{mntpoint} || devices::make($part->{device}));
-	    c::del_loop(delete $part->{real_device}) if isLoopback($part);
-	}
-    }
+    isSwap($part) ?
+      swap::swapoff($part->{device}) :
+      umount(($prefix || '') . ($part->{mntpoint} || "/dev/$part->{device}"));
     $part->{isMounted} = 0;
 }
 
-sub mount_all($;$$) {
+sub mount_all($;$) {
     my ($fstab, $prefix) = @_;
 
     log::l("mounting all filesystems");
 
-    #- order mount by alphabetical ordre, that way / < /home < /home/httpd...
-    foreach (sort { $a->{mntpoint} cmp $b->{mntpoint} } grep { $_->{mntpoint} } @$fstab) {
-	mount_part($_, $prefix);
+    # order mount by alphabetical ordre, that way / < /home < /home/httpd...
+    foreach (sort { $a->{mntpoint} cmp $b->{mntpoint} } @$fstab) {
+	$_->{mntpoint} and mount_part($_, $prefix);
     }
 }
 
@@ -305,147 +174,72 @@ sub umount_all($;$) {
     }
 }
 
-sub df {
-    my ($part, $prefix) = @_;
-    my $dir = "/tmp/tmp_fs_df";
-
-    return $part->{free} if exists $part->{free};
-
-    if ($part->{isMounted}) {
-	$dir = ($prefix || '') . $part->{mntpoint};
-    } elsif ($part->{notFormatted} && !$part->{isFormatted}) {
-	return; #- won't even try!
-    } else {
-	mkdir $dir;
-	eval { mount($part->{device}, $dir, type2fs($part->{type}), 'readonly') };
-	if ($@) {
-	    unlink $dir;
-	    return;
-	}
-    }
-    my (undef, $free) = common::df($dir);
+# do some stuff before calling write_fstab
+sub write($$) {
+    my ($prefix, $fstab) = @_;
+    my @cd_drives = detect_devices::cdroms();
 
-    if (!$part->{isMounted}) {
-	umount($dir);
-	unlink($dir)
-    }
+    log::l("scanning /proc/mounts for iso9660 filesystems");
+    unshift @cd_drives, grep { $_->{type} eq 'iso9660' } read_fstab("/proc/mounts");
+    log::l("found cdrom drive(s) " . join(', ', map { $_->{device} } @cd_drives));
 
-    $part->{free} = 2 * $free if defined $free;
-    $part->{free};
-}
+    # cd-rom rooted installs have the cdrom mounted on /dev/root which 
+    # is not what we want to symlink to /dev/cdrom.                    
+    my $cddev = first(grep { $_ ne 'root' } map { $_->{device} } @cd_drives);
 
-#- do some stuff before calling write_fstab
-sub write($$$$) {
-    my ($prefix, $fstab, $manualFstab, $useSupermount) = @_;
-    $fstab = [ @{$fstab||[]}, @{$manualFstab||[]} ];
+    $::testing and return 1;
 
     log::l("resetting /etc/mtab");
     local *F;
     open F, "> $prefix/etc/mtab" or die "error resetting $prefix/etc/mtab";
 
-    my ($floppy) = detect_devices::floppies();
-
-    my @to_add = (
-       $useSupermount ?
-       [ split ' ', "/mnt/floppy /mnt/floppy supermount fs=vfat,dev=/dev/$floppy 0 0" ] :
-       [ split ' ', "/dev/$floppy /mnt/floppy auto sync,user,noauto,nosuid,nodev 0 0" ],
-       [ split ' ', 'none /proc proc defaults 0 0' ],
-       [ split ' ', 'none /dev/pts devpts mode=0620 0 0' ],
-       (map_index {
-	   my $i = $::i ? $::i + 1 : '';
-	   mkdir "$prefix/mnt/cdrom$i", 0755;#- or log::l("failed to mkdir $prefix/mnt/cdrom$i: $!");
-	   symlinkf $_->{device}, "$prefix/dev/cdrom$i" or log::l("failed to symlink $prefix/dev/cdrom$i: $!");
-	   chown 0, 22, "$prefix/dev/$_->{device}";
-	   $useSupermount ?
-	     [ "/mnt/cdrom$i", "/mnt/cdrom$i", "supermount", "fs=iso9660,dev=/dev/cdrom$i", 0, 0 ] :
-	     [ "/dev/cdrom$i", "/mnt/cdrom$i", "auto", "user,noauto,nosuid,exec,nodev,ro", 0, 0 ];
-       } detect_devices::cdroms()),
-       (map_index { #- for zip drives, the right partition is the 4th by default.
-	   my $i = $::i ? $::i + 1 : '';
-	   mkdir "$prefix/mnt/zip$i", 0755 or log::l("failed to mkdir $prefix/mnt/zip$i: $!");
-	   symlinkf "$_->{device}4", "$prefix/dev/zip$i" or log::l("failed to symlink $prefix/dev/zip$i: $!");
-	   $useSupermount ?
-	     [ "/mnt/zip$i", "/mnt/zip$i", "supermount", "fs=vfat,dev=/dev/zip$i", 0, 0 ] :
-	     [ "/dev/zip$i", "/mnt/zip$i", "auto", "user,noauto,nosuid,exec,nodev", 0, 0 ];
-       } detect_devices::zips()));
-    write_fstab($fstab, $prefix, @to_add);
+    if ($cddev) {
+	mkdir "$prefix/mnt/cdrom", 0755 or log::l("failed to mkdir $prefix/mnt/cdrom: $!");
+	symlink $cddev, "$prefix/dev/cdrom" or log::l("failed to symlink $prefix/dev/cdrom: $!");
+    }
+    write_fstab($fstab, $prefix, $cddev);
 }
 
+
 sub write_fstab($;$$) {
-    my ($fstab, $prefix, @to_add) = @_;
+    my ($fstab, $prefix, $cddev) = @_;
     $prefix ||= '';
 
-    #- get the list of devices and mntpoint to remove existing entries
-    #- and @to_add take precedence over $fstab to handle removable device
-    #- if they are mounted OR NOT during install.
-    my @new = grep { $_ ne 'none' } map { @$_[0,1] } @to_add;
-    my %new; @new{@new} = undef;
-
-    require fsedit;
-    unshift @to_add,
-      grep { 
-	  my $b = !exists $new{$_->[0]} && !exists $new{$_->[1]};
-	  #- keep in mind the new line for fstab.
-	  @new{@$_[0,1]} = undef;
-	  $b
-      } map {
+    my @to_add = 
+      map {
 	  my ($dir, $options, $freq, $passno) = qw(/dev/ defaults 0 0);
-	  $options = $_->{options} || $options;
-
-	  isTrueFS($_) and ($freq, $passno) = (1, ($_->{mntpoint} eq '/') ? 1 : 2);
-	  isNfs($_) and $dir = '', $options = $_->{options} || 'ro,nosuid,rsize=8192,wsize=8192';
-	  isFat($_) and $options = $_->{options} || "user,exec,umask=0";
-
-	  require fsedit;
-	  isReiserfs($_) && $_ == fsedit::get_root($fstab, 'boot') and add_options($options, "notail");
+	  $options ||= $_->{options};
 
-	  my $dev = isLoopback($_) ?
-	    ($_->{mntpoint} eq '/' ? "/initrd/loopfs$_->{loopback_file}" : loopback::file($_)) :
-	    ($_->{device} =~ /^\// ? $_->{device} : "$dir$_->{device}");
-	      
-	  local $_->{mntpoint} = do { 
-	      $passno = 0;
-	      "/initrd/loopfs";
-	  } if loopback::carryRootLoopback($_);
+	  isExt2($_) and ($freq, $passno) = (1, ($_->{mntpoint} eq '/') ? 1 : 2);
+	  isNfs($_) and ($dir, $options) = ('', 'ro');
+	  
+	  [ "$dir$_->{device}", $_->{mntpoint}, type2fs($_->{type}), $options, $freq, $passno ];
 
-	  add_options($options, "loop") if isLoopback($_) && !isSwap($_); #- no need for loop option for swap files
-
-	  eval { devices::make("$prefix/$dev") } if $dir && !isLoopback($_);
-	  mkdir "$prefix/$_->{mntpoint}", 0755 if $_->{mntpoint} && !isSwap($_);
+      } grep { $_->{mntpoint} && type2fs($_->{type}) } @$fstab;
 
-	  [ $dev, $_->{mntpoint}, type2fs($_->{type}), $options, $freq, $passno ];
+    {
+      push @to_add, [ split ' ', '/dev/fd0 /mnt/floppy auto sync,user,noauto,nosuid,nodev,unhide 0 0' ];
+      push @to_add, [ split ' ', '/dev/cdrom /mnt/cdrom auto user,noauto,nosuid,exec,nodev,ro 0 0' ] if $cddev;
+      push @to_add, [ split ' ', 'none /proc proc defaults 0 0' ];
+      push @to_add, [ split ' ', 'none /dev/pts devpts mode=0620 0 0' ];
+    }
 
-      } grep { $_->{mntpoint} && type2fs($_->{type}) } @$fstab;
+    # get the list of devices and mntpoint
+    my @new = grep { $_ ne 'none' } map { @$_[0,1] } @to_add;
+    my %new; @new{@new} = undef;
 
-    push @to_add,
-      grep { !exists $new{$_->[0]} && !exists $new{$_->[1]} }
-      map { [ split ] } cat_("$prefix/etc/fstab");
+    my @current = cat_("$prefix/etc/fstab");
 
     log::l("writing $prefix/etc/fstab");
     local *F;
     open F, "> $prefix/etc/fstab" or die "error writing $prefix/etc/fstab";
-    print F join(" ", @$_), "\n" foreach sort { $a->[1] cmp $b->[1] } @to_add;
-}
-
-sub merge_fstabs {
-    my ($fstab, $manualFstab) = @_;
-    my %l; $l{$_->{device}} = $_ foreach @$manualFstab;
-    %$_ = (%$_, %{$l{$_->{device}} || next}) foreach @$fstab;
+    foreach (@current) {
+	my ($a, $b) = split;
+	# if we find one line of fstab containing either the same device or mntpoint, do not write it
+	exists $new{$a} || exists $new{$b} and next;
+	print F $_;
+    }
+    foreach (@to_add) {
+	print F join(" ", @$_), "\n";
+    }
 }
-
-#sub check_mount_all_fstab($;$) {
-#    my ($fstab, $prefix) = @_;
-#    $prefix ||= '';
-#
-#    foreach (sort { ($a->{mntpoint} || '') cmp ($b->{mntpoint} || '') } @$fstab) {
-#	 #- avoid unwanted mount in fstab.
-#	 next if ($_->{device} =~ /none/ || $_->{type} =~ /nfs|smbfs|ncpfs|proc/ || $_->{options} =~ /noauto|ro/);
-#
-#	 #- TODO fsck
-#
-#	 eval { mount(devices::make($_->{device}), $prefix . $_->{mntpoint}, $_->{type}, 0); };
-#	 if ($@) {
-#	     log::l("unable to mount partition $_->{device} on $prefix/$_->{mntpoint}");
-#	 }
-#    }
-#}