home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-2 / Inter.Net 55-2.iso / Mandrake / mdkinst / usr / bin / perl-install / fs.pm < prev    next >
Encoding:
Perl POD Document  |  2000-01-12  |  8.8 KB  |  313 lines
  1. package fs;
  2.  
  3.  
  4.  
  5.  
  6. use common qw(:common :file :system :functional);
  7. use log;
  8. use devices;
  9. use partition_table qw(:types);
  10. use run_program;
  11. use nfs;
  12. use swap;
  13. use detect_devices;
  14. use commands;
  15. use modules;
  16.  
  17. 1;
  18.  
  19. sub read_fstab($) {
  20.     my ($file) = @_;
  21.  
  22.     local *F;
  23.     open F, $file or return;
  24.  
  25.     map {
  26.     my ($dev, @l) = split;
  27.     $dev =~ s,/(tmp|dev)/,,;
  28.     { device => $dev, mntpoint => $l[0], type => $l[1], options => $l[2] }
  29.     } <F>;
  30. }
  31.  
  32. sub check_mounted($) {
  33.     my ($fstab) = @_;
  34.  
  35.     local (*F, *G, *H);
  36.     open F, "/etc/mtab";
  37.     open G, "/proc/mounts";
  38.     open H, "/proc/swaps";
  39.     foreach (<F>, <G>, <H>) {
  40.     foreach my $p (@$fstab) {
  41.         /$p->{device}\s+([^\s]*)\s+/ and $p->{realMntpoint} = $1, $p->{isMounted} = $p->{isFormatted} = 1;
  42.     }
  43.     }
  44. }
  45.  
  46. sub get_mntpoints_from_fstab($) {
  47.     my ($fstab) = @_;
  48.  
  49.     foreach (read_fstab('/etc/fstab')) {
  50.     foreach my $p (@$fstab) {
  51.         $p->{device} eq $_->{device} or next;
  52.         $p->{mntpoint} ||= $_->{mntpoint};
  53.         $p->{options} ||= $_->{options};
  54.         $_->{type} ne 'auto' && $_->{type} ne type2fs($p->{type}) and
  55.         log::l("err, fstab and partition table do not agree for $_->{device} type: " . (type2fs($p->{type}) || type2name($p->{type})) . " vs $_->{type}");
  56.     }
  57.     }
  58. }
  59.  
  60.  
  61.  
  62. sub format_ext2($@) {
  63.     my ($dev, @options) = @_;
  64.  
  65.     $dev =~ m,(rd|ida)/, and push @options, qw(-b 4096 -R stride=16); 
  66.  
  67.     run_program::run("mke2fs", devices::make($dev), @options) or die _("%s formatting of %s failed", "ext2", $dev);
  68. }
  69.  
  70. sub format_dos($@) {
  71.     my ($dev, @options) = @_;
  72.  
  73.     run_program::run("mkdosfs", devices::make($dev), @options) or die _("%s formatting of %s failed", "dos", $dev);
  74. }
  75.  
  76. sub format_part($;$@) {
  77.     my ($part, @options) = @_;
  78.  
  79.     $part->{isFormatted} and return;
  80.  
  81.     log::l("formatting device $part->{device} (type ", type2name($part->{type}), ")");
  82.  
  83.     if (isExt2($part)) {
  84.     format_ext2($part->{device}, @options);
  85.     } elsif (isDos($part)) {
  86.         format_dos($part->{device}, @options);
  87.     } elsif (isWin($part)) {
  88.         format_dos($part->{device}, @options, '-F', 32);
  89.     } elsif (isSwap($part)) {
  90.     my $check_blocks = grep { /^-c$/ } @options;
  91.         swap::make($part->{device}, $check_blocks);
  92.     } else {
  93.     die _("don't know how to format %s in type %s", $_->{device}, type2name($_->{type}));
  94.     }
  95.     $part->{isFormatted} = 1;
  96. }
  97.  
  98. sub mount($$$;$) {
  99.     my ($dev, $where, $fs, $rdonly) = @_;
  100.     log::l("mounting $dev on $where as type $fs");
  101.  
  102.     -d $where or commands::mkdir_('-p', $where);
  103.  
  104.     if ($fs eq 'nfs') {
  105.     log::l("calling nfs::mount($dev, $where)");
  106.     nfs::mount($dev, $where) or die _("nfs mount failed");
  107.     } elsif ($fs eq 'smb') {
  108.     die "no smb yet...";
  109.     } else {
  110.     $dev = devices::make($dev) if $fs ne 'proc';
  111.  
  112.     my $flag = 0;#c::MS_MGC_VAL();
  113.     $flag |= c::MS_RDONLY() if $rdonly;
  114.     my $mount_opt = "";
  115.  
  116.     if ($fs eq 'vfat') {
  117.         $mount_opt = "check=relaxed";
  118.         eval { modules::load('vfat') }; 
  119.         eval { modules::load('msdos') } if $@; 
  120.     }
  121.  
  122.     log::l("calling mount($dev, $where, $fs, $flag, $mount_opt)");
  123.     syscall_('mount', $dev, $where, $fs, $flag, $mount_opt) or die _("mount failed: ") . "$!";
  124.     }
  125.     local *F;
  126.     open F, ">>/etc/mtab" or return; 
  127.     print F "$dev $where $fs defaults 0 0\n";
  128. }
  129.  
  130.  
  131. sub umount($) {
  132.     my ($mntpoint) = @_;
  133.     log::l("calling umount($mntpoint)");
  134.     syscall_('umount', $mntpoint) or die _("error unmounting %s: %s", $mntpoint, "$!");
  135.  
  136.     my @mtab = cat_('/etc/mtab'); 
  137.     local *F;
  138.     open F, ">/etc/mtab" or return;
  139.     foreach (@mtab) { print F $_ unless /(^|\s)$mntpoint\s/; }
  140. }
  141.  
  142. sub mount_part($;$$) {
  143.     my ($part, $prefix, $rdonly) = @_;
  144.  
  145.     $part->{isMounted} and return;
  146.  
  147.     if (isSwap($part)) {
  148.     swap::swapon($part->{device});
  149.     } else {
  150.     $part->{mntpoint} or die "missing mount point";
  151.     mount(devices::make($part->{device}), ($prefix || '') . $part->{mntpoint}, type2fs($part->{type}), $rdonly);
  152.     }
  153.     $part->{isMounted} = $part->{isFormatted} = 1; 
  154. }
  155.  
  156. sub umount_part($;$) {
  157.     my ($part, $prefix) = @_;
  158.  
  159.     $part->{isMounted} or return;
  160.  
  161.     isSwap($part) ?
  162.       swap::swapoff($part->{device}) :
  163.       umount(($prefix || '') . ($part->{mntpoint} || devices::make($part->{device})));
  164.     $part->{isMounted} = 0;
  165. }
  166.  
  167. sub mount_all($;$$) {
  168.     my ($fstab, $prefix, $hd_dev) = @_; 
  169.  
  170.     log::l("mounting all filesystems");
  171.  
  172.     $hd_dev ||= cat_("/proc/mounts") =~ m|/tmp/(\S+)\s+/tmp/hdimage| unless $::isStandalone;
  173.  
  174.     
  175.     foreach (grep { $_->{mntpoint} } sort { ($a->{mntpoint} || '') cmp ($b->{mntpoint} || '') } @$fstab) {
  176.     if ($hd_dev && $_->{device} eq $hd_dev) {
  177.         my $dir = "$prefix$_->{mntpoint}";
  178.         $dir =~ s|/+$||;
  179.         log::l("special hd case ($dir)");
  180.         rmdir $dir;
  181.         symlink "/tmp/hdimage", $dir;
  182.     } else {
  183.       mount_part($_, $prefix);
  184.       }
  185.     }
  186. }
  187.  
  188. sub umount_all($;$) {
  189.     my ($fstab, $prefix) = @_;
  190.  
  191.     log::l("unmounting all filesystems");
  192.  
  193.     foreach (sort { $b->{mntpoint} cmp $a->{mntpoint} } @$fstab) {
  194.     $_->{mntpoint} and umount_part($_, $prefix);
  195.     }
  196. }
  197.  
  198.  
  199. sub write($$$$) {
  200.     my ($prefix, $fstab, $manualFstab, $useSupermount) = @_;
  201.     $fstab = [ @{$fstab||[]}, @{$manualFstab||[]} ];
  202.  
  203.     log::l("resetting /etc/mtab");
  204.     local *F;
  205.     open F, "> $prefix/etc/mtab" or die "error resetting $prefix/etc/mtab";
  206.  
  207.     my @to_add = (
  208.        $useSupermount ?
  209.        [ split ' ', '/mnt/floppy /mnt/floppy supermount fs=vfat,dev=/dev/fd0 0 0' ] :
  210.        [ split ' ', '/dev/fd0 /mnt/floppy auto sync,user,noauto,nosuid,nodev,unhide 0 0' ],
  211.        [ split ' ', 'none /proc proc defaults 0 0' ],
  212.        [ split ' ', 'none /dev/pts devpts mode=0620 0 0' ],
  213.        (map_index {
  214.        my $i = $::i ? $::i + 1 : '';
  215.        mkdir "$prefix/mnt/cdrom$i", 0755;
  216.        symlinkf $_->{device}, "$prefix/dev/cdrom$i" or log::l("failed to symlink $prefix/dev/cdrom$i: $!");
  217.        chown 0, 22, "$prefix/dev/$_->{device}";
  218.        $useSupermount ?
  219.          [ "/mnt/cdrom$i", "/mnt/cdrom$i", "supermount", "fs=iso9660,dev=/dev/cdrom$i", 0, 0 ] :
  220.          [ "/dev/cdrom$i", "/mnt/cdrom$i", "auto", "user,noauto,nosuid,exec,nodev,ro", 0, 0 ];
  221.        } detect_devices::cdroms()),
  222.        (map_index { 
  223.        my $i = $::i ? $::i + 1 : '';
  224.        mkdir "$prefix/mnt/zip$i", 0755 or log::l("failed to mkdir $prefix/mnt/zip$i: $!");
  225.        symlinkf "$_->{device}4", "$prefix/dev/zip$i" or log::l("failed to symlink $prefix/dev/zip$i: $!");
  226.        $useSupermount ?
  227.          [ "/mnt/zip$i", "/mnt/zip$i", "supermount", "fs=vfat,dev=/dev/zip$i", 0, 0 ] :
  228.          [ "/dev/zip$i", "/mnt/zip$i", "auto", "user,noauto,nosuid,exec,nodev", 0, 0 ];
  229.        } detect_devices::zips()));
  230.     write_fstab($fstab, $prefix, @to_add);
  231. }
  232.  
  233. sub write_fstab($;$$) {
  234.     my ($fstab, $prefix, @to_add) = @_;
  235.     $prefix ||= '';
  236.  
  237.     
  238.     
  239.     
  240.     my @new = grep { $_ ne 'none' } map { @$_[0,1] } @to_add;
  241.     my %new; @new{@new} = undef;
  242.  
  243.     unshift @to_add,
  244.       map {
  245.       my ($dir, $options, $freq, $passno) = qw(/dev/ defaults 0 0);
  246.       $options = $_->{options} || $options;
  247.  
  248.       isExt2($_) and ($freq, $passno) = (1, ($_->{mntpoint} eq '/') ? 1 : 2);
  249.       isNfs($_) and $dir = '', $options ||= 'ro,nosuid,rsize=8192,wsize=8192';
  250.  
  251.       
  252.       @new{($_->{mntpoint}, "$dir$_->{device}")} = undef;
  253.  
  254.       
  255.       eval { devices::make("$prefix/$dir$_->{device}") } if $_->{device} && $dir;
  256.       mkdir "$prefix/$_->{mntpoint}", 0755 if $_->{mntpoint} && !isSwap($_);
  257.  
  258.       [ ( $_->{device} =~ /^\// ? $_->{device} : "$dir$_->{device}" ),
  259.         $_->{mntpoint}, type2fs($_->{type}), $options, $freq, $passno ];
  260.  
  261.       } grep { $_->{mntpoint} && type2fs($_->{type}) && !isFat($_) &&
  262.          ! exists $new{$_->{mntpoint}} && ! exists $new{"/dev/$_->{device}"} } @$fstab;
  263.  
  264.     
  265.     
  266.     
  267.     unshift @to_add,
  268.       map_index {
  269.       my $i = $::i ? $::i + 1 : '';
  270.       my $device = $_->{device} =~ /^\/dev\/(.*)$/ ? $1 : $_->{device};
  271.       my $mntpoint = $_->{mntpoint} ? $_->{mntpoint} : "/mnt/DOS_$device";
  272.  
  273.       
  274.       @new{($mntpoint, "/dev/$device")} = undef;
  275.  
  276.       mkdir "$prefix/$mntpoint", 0755 or log::l("failed to mkdir $prefix/$mntpoint: $!");
  277.       eval { devices::make("$prefix/dev/$device") };
  278.  
  279.       [ "/dev/$device", $mntpoint, "vfat", "user,exec,conv=auto", 0, 0 ];
  280.       } grep { isFat($_) &&
  281.          ! exists $new{"/dev/$_->{device}"} } @$fstab;
  282.  
  283.     my @current = cat_("$prefix/etc/fstab");
  284.  
  285.     log::l("writing $prefix/etc/fstab");
  286.     local *F;
  287.     open F, "> $prefix/etc/fstab" or die "error writing $prefix/etc/fstab";
  288.     foreach (@current) {
  289.     my ($a, $b) = split;
  290.     
  291.     exists $new{$a} || exists $new{$b} and next;
  292.     print F $_;
  293.     }
  294.     print F join(" ", @$_), "\n" foreach @to_add;
  295. }
  296.  
  297. sub check_mount_all_fstab($;$) {
  298.     my ($fstab, $prefix) = @_;
  299.     $prefix ||= '';
  300.  
  301.     foreach (sort { ($a->{mntpoint} || '') cmp ($b->{mntpoint} || '') } @$fstab) {
  302.     
  303.     next if ($_->{device} =~ /none/ || $_->{type} =~ /nfs|smbfs|ncpfs|proc/ || $_->{options} =~ /noauto|ro/);
  304.  
  305.     
  306.  
  307.     eval { mount(devices::make($_->{device}), $prefix . $_->{mntpoint}, $_->{type}, 0); };
  308.     if ($@) {
  309.         log::l("unable to mount partition $_->{device} on $prefix/$_->{mntpoint}");
  310.     }
  311.     }
  312. }
  313.