#! /usr/bin/perl # OriginalAuthor : Manoj Srivastava ( srivasta@pilgrim.umass.edu ) # # Customized for Ubuntu by: Ben Collins #use strict; #for debugging use Cwd 'abs_path'; $|=1; # Predefined values: my $version = "=V"; my $link_in_boot = ""; # Should be empty, mostly my $no_symlink = ""; # Should be empty, mostly my $reverse_symlink = ""; # Should be empty, mostly my $do_symlink = "Yes"; # target machine defined my $do_boot_enable = "Yes"; # target machine defined my $do_bootfloppy = "Yes"; # target machine defined my $do_bootloader = "Yes"; # target machine defined my $move_image = ''; # target machine defined my $kimage = "=K"; # Should be empty, mostly my $loader = "=L"; # lilo, silo, quik, palo, vmelilo, nettrom, arcboot or delo my $image_dir = "/boot"; # where the image is located my $clobber_modules = ''; # target machine defined my $relative_links = ""; # target machine defined my $initrd = "YES"; # initrd kernel my $do_initrd = ''; # Normally we do not my $use_hard_links = ''; # hardlinks do not work across fs boundaries my $postinst_hook = ''; #Normally we do not my $postrm_hook = ''; #Normally we do not my $preinst_hook = ''; #Normally we do not my $prerm_hook = ''; #Normally we do not my $minimal_swap = ''; # Do not swap symlinks my $ignore_depmod_err = ''; # normally we do not my $kernel_arch = "=B"; my $ramdisk = "/usr/sbin/update-initramfs"; # List of tools to create initial ram fs. my $notifier = "/usr/share/update-notifier/notify-reboot-required"; my $package_name = "linux-image-$version"; my $explicit_do_loader = 'Yes'; my $Loader = "NoLOADER"; # $Loader = "LILO" if $loader =~ /^lilo/io; $Loader = "SILO" if $loader =~ /^silo/io; $Loader = "QUIK" if $loader =~ /^quik/io; $Loader = "yaboot" if $loader =~ /^yaboot/io; $Loader = "PALO" if $loader =~ /^palo/io; $Loader = "NETTROM" if $loader =~ /^nettrom/io; $Loader = "VMELILO" if $loader =~ /^vmelilo/io; $Loader = "ZIPL" if $loader =~ /^zipl/io; $Loader = "ELILO" if $loader =~ /^elilo/io; $Loader = "ARCBOOT" if $loader =~ /^arcboot/io; $Loader = "DELO" if $loader =~ /^delo/io; # This should not point to /tmp, because of security risks. my $temp_file_name = "/var/log/$loader" . "_log.$$"; #known variables my $image_dest = "/"; my $realimageloc = "/$image_dir/"; my $have_conffile = ""; my $silent_modules = ''; my $silent_loader = ''; my $warn_reboot = 'Yes'; # Warn that we are installing a version of # the kernel we are running my $modules_base = '/lib/modules'; my $CONF_LOC = '/etc/kernel-img.conf'; # Ignore all invocations except when called on to configure. exit 0 unless $ARGV[0] =~ /configure/; my $DEBUG = 0; # Do some preliminary sanity checks here to ensure we actually have an # valid image dir chdir('/') or die "could not chdir to /:$!\n"; die "Internal Error: ($image_dir) is not a directory!\n" unless -d $image_dir; # remove multiple leading slashes; make sure there is at least one. $realimageloc =~ s|^/*|/|o; $realimageloc =~ s|/+|/|o; die "Internal Error: ($realimageloc) is not a directory!\n" unless -d $realimageloc; if (-r "$CONF_LOC" && -f "$CONF_LOC" ) { if (open(CONF, "$CONF_LOC")) { while () { chomp; s/\#.*$//g; next if /^\s*$/; $do_symlink = "" if /^\s*do_symlinks\s*=\s*(no|false|0)\s*$/ig; $no_symlink = "" if /^\s*no_symlinks\s*=\s*(no|false|0)\s*$/ig; $reverse_symlink = "" if /^\s*reverse_symlink\s*=\s*(no|false|0)\s*$/ig; $link_in_boot = "" if /^\s*image_in_boot\s*=\s*(no|false|0)\s*$/ig; $link_in_boot = "" if /^\s*link_in_boot\s*=\s*(no|false|0)\s*$/ig; $move_image = "" if /^\s*move_image\s*=\s*(no|false|0)\s*$/ig; $clobber_modules = '' if /^\s*clobber_modules\s*=\s*(no|false|0)\s*$/ig; $do_boot_enable = '' if /^\s*do_boot_enable\s*=\s*(no|false|0)\s*$/ig; $do_bootfloppy = '' if /^\s*do_bootfloppy\s*=\s*(no|false|0)\s*$/ig; $relative_links = '' if /^\s*relative_links \s*=\s*(no|false|0)\s*$/ig; $do_bootloader = '' if /^\s*do_bootloader\s*=\s*(no|false|0)\s*$/ig; $explicit_do_loader = '' if /^\s*do_bootloader\s*=\s*(no|false|0)\s*$/ig; $do_initrd = '' if /^\s*do_initrd\s*=\s*(no|false|0)\s*$/ig; $use_hard_links = '' if /^\s*use_hard_links\s*=\s*(no|false|0)\s*$/ig; $silent_modules = '' if /^\s*silent_modules\s*=\s*(no|false|0)\s*$/ig; $silent_loader = '' if /^\s*silent_loader\s*=\s*(no|false|0)\s*$/ig; $warn_reboot = '' if /^\s*warn_reboot\s*=\s*(no|false|0)\s*$/ig; $minimal_swap = '' if /^\s*minimal_swap\s*=\s*(no|false|0)\s*$/ig; $ignore_depmod_err = '' if /^\s*ignore_depmod_err\s*=\s*(no|false|0)\s*$/ig; $do_symlink = "Yes" if /^\s*do_symlinks\s*=\s*(yes|true|1)\s*$/ig; $no_symlink = "Yes" if /^\s*no_symlinks\s*=\s*(yes|true|1)\s*$/ig; $reverse_symlink = "Yes" if /^\s*reverse_symlinks\s*=\s*(yes|true|1)\s*$/ig; $link_in_boot = "Yes" if /^\s*image_in_boot\s*=\s*(yes|true|1)\s*$/ig; $link_in_boot = "Yes" if /^\s*link_in_boot\s*=\s*(yes|true|1)\s*$/ig; $move_image = "Yes" if /^\s*move_image\s*=\s*(yes|true|1)\s*$/ig; $clobber_modules = "Yes" if /^\s*clobber_modules\s*=\s*(yes|true|1)\s*$/ig; $do_boot_enable = "Yes" if /^\s*do_boot_enable\s*=\s*(yes|true|1)\s*$/ig; $do_bootfloppy = "Yes" if /^\s*do_bootfloppy\s*=\s*(yes|true|1)\s*$/ig; $do_bootloader = "Yes" if /^\s*do_bootloader\s*=\s*(yes|true|1)\s*$/ig; $explicit_do_loader = "YES" if /^\s*do_bootloader\s*=\s*(yes|true|1)\s*$/ig; $relative_links = "Yes" if /^\s*relative_links\s*=\s*(yes|true|1)\s*$/ig; $do_initrd = "Yes" if /^\s*do_initrd\s*=\s*(yes|true|1)\s*$/ig; $use_hard_links = "Yes" if /^\s*use_hard_links\s*=\s*(yes|true|1)\s*$/ig; $silent_modules = 'Yes' if /^\s*silent_modules\s*=\s*(yes|true|1)\s*$/ig; $silent_loader = 'Yes' if /^\s*silent_loader\s*=\s*(yes|true|1)\s*$/ig; $warn_reboot = 'Yes' if /^\s*warn_reboot\s*=\s*(yes|true|1)\s*$/ig; $minimal_swap = 'Yes' if /^\s*minimal_swap\s*=\s*(yes|true|1)\s*$/ig; $ignore_depmod_err = 'Yes' if /^\s*ignore_depmod_err\s*=\s*(yes|true|1)\s*$/ig; $image_dest = "$1" if /^\s*image_dest\s*=\s*(\S+)/ig; $postinst_hook = "$1" if /^\s*postinst_hook\s*=\s*(\S+)/ig; $postrm_hook = "$1" if /^\s*postrm_hook\s*=\s*(\S+)/ig; $preinst_hook = "$1" if /^\s*preinst_hook\s*=\s*(\S+)/ig; $prerm_hook = "$1" if /^\s*prerm_hook\s*=\s*(\S+)/ig; $ramdisk = "$1" if /^\s*ramdisk\s*=\s*(.+)$/ig; } close CONF; $have_conffile = "Yes"; } } # For some versions of kernel-package, we had this warning in the # postinst, but the rules did not really interpolate the value in. # Here is a sanity check. my $pattern = "=" . "I"; $initrd=~ s/^$pattern$//; if ($link_in_boot) { $image_dest = "/$image_dir/"; # same as realimageloc } # Tack on at least one trainling / $image_dest = "$image_dest/"; $image_dest =~ s|^/*|/|o; $image_dest =~ s|/+$|/|o; if (! -d "$image_dest") { die "Expected Image Destination dir ($image_dest) to be a valid directory!\n"; } # sanity if (!($do_bootfloppy || $do_bootloader)) { $do_boot_enable = ''; } if ($do_symlink && $no_symlink) { warn "Both do_symlinks and no_symlinks options enabled; disabling no_symlinks\n"; $no_symlink = 0; } # most of our work is done in $image_dest (nominally /) chdir("$image_dest") or die "could not chdir to $image_dest:$!\n"; # Paranoid check to make sure that the correct value is put in there if (! $kimage) { $kimage = "vmlinuz"; } # Hmm. empty elsif ($kimage =~ m/^b?uImage$/o) { $kimage = "vmlinuz"; } # these produce vmlinuz elsif ($kimage =~ m/^b?zImage$/o) { $kimage = "vmlinuz"; } # these produce vmlinuz elsif ($kimage =~ m/^[iI]mage$/o) { my $nop = $kimage; } elsif ($kimage =~ m/^vmlinux$/o) { my $nop = $kimage; } else { $kimage = "vmlinuz"; } # Default $ENV{KERNEL_ARCH}=$kernel_arch if $kernel_arch; die "Internal Error: Could not find image (" . $realimageloc . "$kimage-$version)\n" unless -e $realimageloc . "$kimage-$version"; # search for the boot loader in the path my $loader_exec; ($loader_exec = $loader) =~ s|.*/||; my ($loaderloc) = grep -x, map "$_/$loader_exec", map { length($_) ? $_ : "." } split /:/, $ENV{PATH}; ###################################################################### ###################################################################### ########### Test whether a relative symlinkwould be OK ####### ###################################################################### ###################################################################### sub test_relative { my %params = @_; my $cwd; die "Internal Error: Missing Required paramater 'Old Dir' " unless $params{'Old Dir'}; die "Internal Error: Missing Required paramater New Dir' " unless $params{'New Dir'}; die "Internal Error: No such dir $params{'Old Dir'} " unless -d $params{'Old Dir'}; die "Internal Error: No such dir $params{'New Dir'} " unless -d $params{'New Dir'}; warn "Test relative: testing $params{'Old Dir'} -> $params{'New Dir'}" if $DEBUG; chomp($cwd = `pwd`); chdir ($params{'New Dir'}) or die "Could not chdir to $params{'New Dir'}:$!"; my $ok = 0; $params{'Old Dir'} =~ s|^/*||o; if (-d $params{'Old Dir'} ) { if (defined $params{'Test File'}) { if (-e $params{'Old Dir'} . $params{'Test File'}) { $ok = 1; } } else { $ok = 1; # well, backward compatibility } } chdir ($cwd) or die "Could not chdir to $params{'New Dir'}:$!"; return $ok; } ###################################################################### ###################################################################### ############ ###################################################################### ###################################################################### # sub CanonicalizePath { # my $path = join '/', @_; # my @work = split '/', $path; # my @out; # my $is_absolute; # if (@work && $work[0] eq "") { # $is_absolute = 1; shift @work; # } # while (@work) { # my $seg = shift @work; # if ($seg eq "." || $seg eq "") { # } # elsif ($seg eq "..") { # if (@out && $out[-1] ne "..") { # pop @out; # } # else { # # Leading "..", or "../..", etc. # push @out, $seg; # } # } # else { # push @out, $seg; # } # } # unshift @out, "" if $is_absolute; # return join('/', @out); # } ###################################################################### ###################################################################### ############ ###################################################################### ###################################################################### sub spath { my %params = @_; die "Missing Required paramater 'Old'" unless $params{'Old'}; die "Missing Required paramater 'New'" unless $params{'New'}; my @olddir = split '/', `readlink -q -m $params{'Old'}`; my @newdir = split '/', `readlink -q -m $params{'New'}`; my @outdir = @olddir; my $out = ''; my $i; for ($i = 0; $i <= $#olddir && $i <= $#newdir; $i++) { $out++ if ($olddir[$i] ne $newdir[$i]); shift @outdir unless $out; unshift @outdir, ".." if $out; } if ($#newdir > $#olddir) { for ($i=0; $i < $#newdir; $i++) { unshift @outdir, ".."; } } return join ('/', @outdir); } ###################################################################### ###################################################################### ############ ###################################################################### ###################################################################### # This routine actually moves the kernel image # From: $realimageloc/$kimage-$version (/boot/vmlinuz-2.6.12) # To: $image_dest/$kimage-$version (/vmlinuz-2.6.12) # Note that the image is moved to a versioned destination, but ordinary # symlinks we create otherwise are not normally versioned sub really_move_image { my $src_dir = $_[0]; my $target = $_[1]; my $dest_dir = $_[2]; warn "Really move image: src_dir=$src_dir, target=$target,\n destdir=$dest_dir" if $DEBUG; if (-e "$target") { # we should be in dir $dest_dir == $image_dest /, normally rename("$target", "$target.$$") || die "failed to move " . $dest_dir . "$target:$!"; warn "mv $target $target.$$" if $DEBUG; } warn "mv -f $src_dir$target $target" if $DEBUG; my $ret = system("mv -f " . $src_dir . "$target " . " $target"); if ($ret) { die("Failed to move " . $src_dir . "$target to " . $dest_dir . "$target.\n"); } # Ok, now we may clobber the previous .old files if (-e "$target.$$") { rename("$target.$$", "$target.old") || die "failed to move " . $dest_dir . "$target:$!"; warn "mv $target.$$ $target " if $DEBUG; } } # Normally called after really_move_image; and only called if we asked for # reversed link this routine reverses the symbolic link that is notmally # created. Since the real kernel image has been moved over to # $image_dest/$kimage-$version. So, this routine links # From: $image_dest/$kimage-$version (/vmlinuz-2.6.12) # To: $realimageloc/$kimage-$version (/boot/vmlinuz-2.6.12) sub really_reverse_link { my $src_dir = $_[0]; my $link_name = $_[1]; my $dest_dir = $_[2]; warn "Really reverse link: src_dir=$src_dir, link name=$link_name\n" . "\tdestdir=$dest_dir" if $DEBUG; my $Old = $dest_dir; if (test_relative ('Old Dir' => $Old, 'New Dir' => $src_dir, 'Test File' => "$link_name")) { $Old =~ s|^/*||o; } # Special case is they are in the same dir my $rel_path = spath('Old' => "$Old", 'New' => "$src_dir" ); $Old ="" if $rel_path =~ m/^\s*$/o; if ($use_hard_links =~ m/YES/i) { link($Old . "$link_name", $src_dir . "$link_name") || die("Failed to link " . $dest_dir . "$link_name to " . $src_dir . "$link_name .\n"); warn "ln " . $Old . "$link_name " . $src_dir . "$link_name" if $DEBUG; } else { symlink($Old . "$link_name", $src_dir . "$link_name") || die("Failed to symbolic-link " . $dest_dir . "$link_name to " . $src_dir . "$link_name : $!\n"); warn "ln -s " . $Old . "$link_name " . $src_dir . "$link_name" if $DEBUG; } } # This routine is invoked if there is a symbolic link in place # in $image_dest/$kimage -- so a symlink exists in the destination. # What we are trying to determine is if we need to move the symbolic link over # to the the .old location sub move_p { my $kimage = $_[0]; # Name of the symbolic link my $image_dest = $_[1]; # The directory the links goes into my $image_name = $_[2]; my $src_dir = $_[3]; my $force_move = 0; warn "Move?: kimage=$kimage, image_dest=$image_dest, \n" . "\timage_name=$image_name, src_dir=$src_dir" if $DEBUG; if ($no_symlink || $reverse_symlink) { # we do not want links, yet we have a symbolic link here! warn "found a symbolic link in " . $image_dest . "$kimage \n" . "even though no_symlink is defined\n" if $no_symlink; warn "found a symbolic link in " . $image_dest . "$kimage \n" . "even though reverse_symlink is defined\n" if $reverse_symlink; # make sure we change this state of affairs $force_move = 1; return $force_move; } warn "DEBUG: OK. We found symlink, and we should have a symlink here.\n" if $DEBUG; my $vmlinuz_target = readlink "$kimage"; my $real_target = ''; my $target = `readlink -q -m "${realimageloc}${kimage-$version}"`; $real_target = abs_path($vmlinuz_target) if defined($vmlinuz_target); if (!defined($vmlinuz_target) || ! -f "$real_target") { # what, a dangling symlink? warn "The link " . $image_dest . "$kimage is a dangling link" . "to $real_target\n"; $force_move = 1; return $force_move; } warn "DEBUG: The link $kimage points to ($vmlinuz_target)\n" if $DEBUG; warn "DEBUG: ($vmlinuz_target) is really ($real_target)\n" if $DEBUG; my $cwd; chomp ($cwd=`pwd`); if ($vmlinuz_target !~ m|^/|o) { $vmlinuz_target = $cwd . "/" . $vmlinuz_target; $vmlinuz_target =~ s|/+|/|o; } $vmlinuz_target = `readlink -q -m $vmlinuz_target`; if ("$vmlinuz_target" ne "$target") { warn "DEBUG: We need to handle this.\n" if $DEBUG; if ($minimal_swap) { warn "DEBUG: Minimal swap.\n" if $DEBUG; if (-l "$kimage.old") { warn "DEBUG: There is an old link at $kimage.old\n" if $DEBUG; my $old_target = readlink "$kimage.old"; my $real_old_target = ''; $real_old_target=abs_path($old_target) if defined ($old_target); if ($real_old_target && -f "$real_old_target") { if ($old_target !~ m|^/|o) { $old_target = $cwd . "/" . $old_target; $old_target =~ s|/+|/|o; } $old_target = `readlink -q -m $old_target`; if ("$old_target" ne "$target") { $force_move = 1; warn "DEBUG: Old link ($old_target) does not point to us ($target)\n" if $DEBUG; } else { # The .old points to the current warn "$kimage.old --> $target -- doing nothing"; $force_move = 0; } } else { warn "DEBUG: Well, the old link does not exist -- so we move\n" if $DEBUG; $force_move = 1; } } else { warn "DEBUG: No .old link -- OK to move\n" if $DEBUG; $force_move = 1; } } else { warn "DEBUG: ok, minimal swap is no-- so we move.\n" if $DEBUG; $force_move = 1; } } else { # already have proper link warn "$kimage($vmlinuz_target) points to $target ($real_target) -- doing nothing"; $force_move = 0; } return $force_move; } # This routine moves the symbolic link around (/vmlinuz -> /vmlinuz.old) # It pays attention to whether we should the fact whether we should be using # hard links or not. sub really_move_link { my $kimage = $_[0]; # Name of the symbolic link my $image_dest = $_[1]; # The directory the links goes into my $image_name = $_[2]; my $src_dir = $_[3]; warn "really_move_link: kimage=$kimage, image_dest=$image_dest\n" . "\t image_name=$image_name, src_dir=$src_dir" if $DEBUG; # don't clobber $kimage.old quite yet rename("$kimage", "$kimage.$$") || die "failed to move " . $image_dest . "$kimage:$!"; warn "mv $kimage $kimage.$$" if $DEBUG; my $Old = $src_dir; my $cwd; chomp($cwd=`pwd`); if (test_relative ('Old Dir' => $Old, 'New Dir' => $cwd, 'Test File' => "$image_name")) { $Old =~ s|^/*||o; } # Special case is they are in the same dir my $rel_path = spath('Old' => "$Old", 'New' => "$cwd" ); $Old ="" if $rel_path =~ m/^\s*$/o; if ($use_hard_links =~ m/YES/i) { warn "ln ${Old}${image_name} $kimage" if $DEBUG; if (! link("${Old}${image_name}", "$kimage")) { rename("$kimage.$$", "$kimage"); die("Failed to link ${Old}${image_name} to " . "${image_dest}${kimage}.\n"); } } else { warn "ln -s ${Old}${image_name} $kimage" if $DEBUG; if (! symlink("${Old}${image_name}", "$kimage")) { rename("$kimage.$$", "$kimage"); die("Failed to symbolic-link ${Old}${image_name} to " . "${image_dest}${kimage}: $!\n"); } } # Ok, now we may clobber the previous .old file if (-l "$kimage.old" || ! -e "$kimage.old" ) { rename("$kimage.$$", "$kimage.old"); warn "mv $kimage.$$ $kimage.old" if $DEBUG; } else { warn "$kimage.old is not a symlink, not clobbering\n"; warn "rm $kimage.$$"; unlink "$kimage.$$" if $DEBUG; } } # This routine handles a request to do symlinks, but there is no # symlink file already there. Either we are supposed to use copy, or we are # installing on a pristine system, or the user does not want symbolic links at # all. We use a configuration file to tell the last two cases apart, creating # a config file if needed. sub handle_missing_link { my $kimage = $_[0]; # Name of the symbolic link my $image_dest = $_[1]; # The directory the links goes into my $image_name = $_[2]; my $src_dir = $_[3]; warn "handle_missing_link: kimage=$kimage, image_dest=$image_dest\n" . "\t image_name=$image_name, src_dir=$src_dir" if $DEBUG; if ($no_symlink) { warn "cp -a --backup=t $realimageloc$image_name $kimage" if $DEBUG; my $ret = system("cp -a --backup=t " . $realimageloc . "$image_name " . " $kimage"); if ($ret) { die("Failed to copy " . $realimageloc . "$image_name to " . $image_dest . "$kimage .\n"); } } elsif ($reverse_symlink) { warn "mv -f $realimageloc$image_name $kimage" if $DEBUG; my $ret = system("mv -f " . $realimageloc . "$image_name " . "$kimage"); if ($ret) { die("Failed to move " . $realimageloc . "$image_name to " . $image_dest . "$kimage .\n"); } } else { if (! $have_conffile) { my $ret; my $answer=''; $do_symlink = "Yes"; if (open(CONF, ">$CONF_LOC")) { print CONF "# Kernel Image management overrides\n"; print CONF "# See kernel-img.conf(5) for details\n"; if ($loader =~ /palo/i) { print CONF "link_in_boot = Yes\n"; print CONF "do_symlinks = Yes\n"; print CONF "relative_links = Yes\n"; print CONF "do_bootloader = No\n"; } else { print CONF "do_symlinks = $do_symlink\n"; } close CONF; } $have_conffile = "Yes"; } } if (! $no_symlink && $do_symlink =~ /Yes/i) { my $Old = $realimageloc; my $New = $image_dest; my $Name = "$image_name"; my $Link_Dest = "$kimage"; if ($reverse_symlink) { $Old = $image_dest; $New = $realimageloc; $Name = "$kimage"; $Link_Dest = $realimageloc . "$image_name"; } if (test_relative ('Old Dir' => $Old, 'New Dir' => $New, 'Test File' => $Name)) { $Old =~ s|^/*||o; } # Special case is they are in the same dir my $rel_path = spath('Old' => "$Old", 'New' => "$New" ); $Old ="" if $rel_path =~ m/^\s*$/o; symlink($Old . "$Name", "$Link_Dest") || die("Failed to symbolic-link ${Old}$Name to $Link_Dest: $!\n"); warn "ln -s ${Old}$Name $Link_Dest" if $DEBUG; } } # This routine handles the rest of the cases, where the user has requested # non-traditional handling, like using cp, or reverse symlinks, or hard links. sub handle_non_symlinks { my $kimage = $_[0]; # Name of the symbolic link my $image_dest = $_[1]; # The directory the links goes into my $image_name = $_[2]; my $src_dir = $_[3]; warn "handle_non_link: kimage=$kimage, image_dest=$image_dest\n" . "\t image_name=$image_name, src_dir=$src_dir" if $DEBUG; # Save the current image. We do this in all four cases rename("$kimage", "$kimage.$$") || die "failed to move " . $image_dest . "$kimage:$!"; warn "mv $kimage $kimage.$$" if $DEBUG; ##,#### # case One #`#### if ($no_symlink) { # Maybe /$image_dest is on a dos system? warn "cp -a --backup=t $realimageloc$image_name $kimage" if $DEBUG; my $ret = system("cp -a --backup=t " . $realimageloc . "$image_name " . "$kimage"); if ($ret) { if (-e "$kimage.$$") { rename("$kimage.$$", "$kimage"); warn "mv $kimage.$$ $kimage" if $DEBUG; } die("Failed to copy " . $realimageloc . "$image_name to " . $image_dest . "$kimage .\n"); } } ##,#### # case Two #`#### elsif ($reverse_symlink) { # Maybe /$image_dest is on a dos system? warn "mv -f $realimageloc$image_name $kimage" if $DEBUG; my $ret = system("mv -f " . $realimageloc . "$image_name " . $image_dest . "$kimage"); if ($ret) { if (-e "$kimage.$$") { rename("$kimage.$$", "$kimage"); warn "mv $kimage.$$ $kimage" if $DEBUG; } die("Failed to move " . $realimageloc . "$image_name to " . $image_dest . "$kimage .\n"); } my $Old = $image_dest; if (test_relative ('Old Dir' => $Old, 'New Dir' => $realimageloc, 'Test File' => "$kimage")) { $Old =~ s|^/*||o; } # Special case is they are in the same dir my $rel_path = spath('Old' => "$Old", 'New' => "$realimageloc" ); $Old ="" if $rel_path =~ m/^\s*$/o; if ($use_hard_links =~ m/YES/i) { warn "ln " . $Old . "$kimage " . $realimageloc . "$image_name" if $DEBUG; if (! link($Old . "$kimage", $realimageloc . "$image_name")) { warn "Could not link " . $image_dest . "$kimage to $image_name :$!"; } } else { warn "ln -s " . $Old . "$kimage " . $realimageloc . "$image_name" if $DEBUG; if (! symlink($Old . "$kimage", $realimageloc . "$image_name")) { warn "Could not symlink " . $image_dest . "$kimage to $image_name :$!"; } } } ##,#### # case Three #`#### elsif ($use_hard_links =~ m/YES/i ) { # Ok then. this ought to be a hard link, and hence fair game # don't clobber $kimage.old quite yet my $Old = $realimageloc; my $cwd; chomp($cwd=`pwd`); if (test_relative ('Old Dir' => $Old, 'New Dir' => $cwd, 'Test File' => "$image_name")) { $Old =~ s|^/*||o; } # Special case is they are in the same dir my $rel_path = spath('Old' => "$Old", 'New' => "$cwd" ); $Old ="" if $rel_path =~ m/^\s*$/o; warn "ln " . $Old . "$image_name " . "$kimage" if $DEBUG; if (! link($Old . "$image_name", "$kimage")) { warn "mv $kimage.$$ $kimage" if $DEBUG; rename("$kimage.$$", "$kimage"); die("Failed to link " . $realimageloc . "$image_name to " . $image_dest . "$kimage .\n"); } } ##,#### # case Four #`#### else { # We just use cp warn "cp -a --backup=t $realimageloc$image_name $kimage" if $DEBUG; my $ret = system("cp -a --backup=t " . $realimageloc . "$image_name " . "$kimage"); if ($ret) { if (-e "$kimage.$$") { warn "mv $kimage.$$ $kimage" if $DEBUG; rename("$kimage.$$", "$kimage"); } die("Failed to copy " . $realimageloc . "$image_name to " . $image_dest . "$kimage .\n"); } } # Ok, now we may clobber the previous .old file warn "mv $kimage.$$ $kimage.old if -e $kimage.$$" if $DEBUG; rename("$kimage.$$", "$kimage.old") if -e "$kimage.$$"; } # This routine is responsible for setting up the symbolic links # So, the actual kernel image lives in # $realimageloc/$image_name (/boot/vmlinuz-2.6.12). # This routine creates symbolic links in $image_dest/$kimage (/vmlinuz) sub image_magic { my $kimage = $_[0]; # Name of the symbolic link my $image_dest = $_[1]; # The directory the links goes into my $image_name = "$kimage-$version"; my $src_dir = $realimageloc; warn "image_magic: kimage=$kimage, image_dest=$image_dest\n" . "\t image_name=$image_name, src_dir=$src_dir" if $DEBUG; # Well, in any case, if the destination (the symlink we are trying # to create) is a directory, we should do nothing, except throw a # diagnostic. if (-d "$kimage" ) { die ("Hmm. $kimage is a directory, which I did not expect. I am\n" . "trying to create a symbolic link with that name linked to \n" . "$image_dest . Since a directory exists here, my assumptions \n" . "are way off, and I am aborting.\n" ); exit (3); } if ($move_image) { # Maybe $image_dest is in on dos, or something? # source dir, link name, dest dir really_move_image( $realimageloc, $image_name, $image_dest); really_reverse_link($realimageloc, $image_name, $image_dest) if $reverse_symlink; return; } if (-l "$kimage") { # There is a symbolic link warn "DEBUG: There is a symlink for $kimage\n" if $DEBUG; my $force_move = move_p($kimage, $image_dest, $image_name, $src_dir); if ($force_move) { really_move_link($kimage, $image_dest, $image_name, $src_dir); } } elsif (! -e "$kimage") { # Hmm. Pristine system? How can that be? Installing from scratch? # Or maybe the user does not want a symbolic link here. # Possibly they do not want a link here. (we should be in / # here[$image_dest, really] handle_missing_link($kimage, $image_dest, $image_name, $src_dir); } elsif (-e "$kimage" ) { # OK, $kimage exists -- but is not a link handle_non_symlinks($kimage, $image_dest, $image_name, $src_dir); } } ###################################################################### ###################################################################### ###################################################################### ###################################################################### # We may not have any modules installed if ( -d "$modules_base/$version" ) { print STDERR "Running depmod.\n"; my $ret = system("depmod -a $version"); if ($ret) { print STDERR "Failed to run depmod\n"; exit(1); } } sub find_initrd_tool { my $hostversion = shift; my $version = shift; print STDERR "Finding valid ramdisk creators.\n"; my @ramdisks = grep { my $args = "$_ " . "--supported-host-version=$hostversion " . "--supported-target-version=$version " . "1>/dev/null 2>&1" ; system($args) == 0; } split (/[:,\s]+/, $ramdisk); } # The initrd symlink should probably be in the same dir that the # symlinks are in if ($initrd) { my $success = 0; # Update-initramfs is called slightly different than mkinitrd and # mkinitramfs. XXX It should really be made compatible with this stuff # some how. my $upgrading = 1; if (! defined $ARGV[1] || ! $ARGV[1] || $ARGV[1] =~ m//og) { $upgrading = 0; } my $ret = system("$ramdisk " . ($upgrading ? "-u" : "-c") . " -k " . $version . " >&2"); $success = 1 unless $ret; die "Failed to create initrd image.\n" unless $success; if (! defined $ARGV[1] || ! $ARGV[1] || $ARGV[1] =~ m//og) { image_magic("initrd.img", $image_dest); } else { if (! -e "initrd.img") { handle_missing_link("initrd.img", $image_dest, "initrd.img-$version", $realimageloc); } else { print STDERR "Not updating initrd symbolic links since we are being updated/reinstalled \n"; print STDERR "($ARGV[1] was configured last, according to dpkg)\n"; } } if ($initrd && -l "initrd" ) { unlink "initrd"; } if ($initrd && -l "$image_dir/initrd" && ! $link_in_boot) { unlink "$image_dir/initrd"; } } else { # Not making an initrd emage if (-l "initrd.img") { # Ooh, last image was an initrd image? in any case, we should move it. my $target = readlink "initrd.img"; my $real_target = ''; $real_target = abs_path($target) if defined ($target); if (!defined($target) || ! -f "$real_target") { # Eh. dangling link. can safely be removed. unlink("initrd.img"); } else { if (-l "initrd.img.old" || ! -e "initrd.img.old" ) { rename("initrd.img", "initrd.img.old"); } else { warn "initrd.img.old is not a symlink, not clobbering\n"; unlink("initrd.img"); } } } } # Warn of a reboot if (-x $notifier) { system($notifier); } # Let programs know not to hibernate if the kernel that would be used for # resume-from-hibernate is likely to differ from the currently running kernel. system("mountpoint -q /var/run"); if ($? eq 0) { system("touch /var/run/do-not-hibernate"); } # Only change the symlinks if we are not being upgraded if (! defined $ARGV[1] || ! $ARGV[1] || $ARGV[1] =~ m//og) { image_magic($kimage, $image_dest); } else { if (! -e "$kimage") { handle_missing_link($kimage, $image_dest, "$kimage-$version", $realimageloc); } else { print STDERR "Not updating image symbolic links since we are being updated/reinstalled \n"; print STDERR "($ARGV[1] was configured last, according to dpkg)\n"; } } # We used to have System.* files in / if (-e "/System.map" || -e "/System.old") { unlink '/System.map' if -e '/System.map'; unlink '/System.old' if -e '/System.old'; } # creating some info about kernel and initrd if ($DEBUG) { my $ksize=sprintf("%.0f",(stat($realimageloc . "$kimage-$version"))[7]/1024)."kB"; my $initrdsize=''; if ($initrd) { $initrdsize=sprintf("%.0f",(stat($realimageloc . "initrd.img-$version"))[7]/1024)."kB"; } print STDERR <<"EOMSG"; A new kernel image has been installed at $realimageloc$kimage-$version (Size: $ksize) Symbolic links, unless otherwise specified, can be found in $image_dest EOMSG ; if ($initrd) { print STDERR <<"EOMSGA"; Initial rootdisk image: ${realimageloc}initrd.img-$version (Size: $initrdsize) EOMSGA ; } } # set the env var stem $ENV{'STEM'} = "linux"; sub exec_script { my $type = shift; my $script = shift; print STDERR "Running $type hook script $script.\n"; system ("$script $version $realimageloc$kimage-$version") && print STDERR "User $type hook script [$script] "; if ($?) { if ($? == -1) { print STDERR "failed to execute: $!\n"; } elsif ($? & 127) { printf STDERR "died with signal %d, %s coredump\n", ($? & 127), ($? & 128) ? 'with' : 'without'; } else { printf STDERR "exited with value %d\n", $? >> 8; } exit $? >> 8; } } sub run_hook { my $type = shift; my $script = shift; if ($script =~ m,^/,) { # Full path provided for the hook script if (-x "$script") { &exec_script($type,$script); } else { die "The provided $type hook script [$script] could not be run.\n"; } } else { # Look for it in a safe path for my $path ('/bin', '/sbin', '/usr/bin', '/usr/sbin') { if (-x "$path/$script") { &exec_script($type, "$path/$script"); return 0; } } # No luck print STDERR "Could not find $type hook script [$script].\n"; die "Looked in: '/bin', '/sbin', '/usr/bin', '/usr/sbin'\n"; } } my $options; for (@ARGV) { s,','\\'',g; $options .= " '$_'"; } $ENV{'DEB_MAINT_PARAMS'}="$options"; ## Run user hook script here, if any if ($postinst_hook) { &run_hook("postinst", $postinst_hook); } if (-d "/etc/kernel/postinst.d") { print STDERR "Examining /etc/kernel/postinst.d.\n"; system ("run-parts --verbose --exit-on-error --arg=$version " . "--arg=$realimageloc$kimage-$version " . "/etc/kernel/postinst.d") && die "Failed to process /etc/kernel/postinst.d"; } if (-d "/etc/kernel/postinst.d/$version") { print STDERR "Examining /etc/kernel/postinst.d/$version.\n"; system ("run-parts --verbose --exit-on-error --arg=$version " . "--arg=$realimageloc$kimage-$version " . "/etc/kernel/postinst.d/$version") && die "Failed to process /etc/kernel/postinst.d/$version"; } LOADER: { last unless $do_boot_enable; # Exit if explicitly asked to last if $loader =~ /silo/i; # SILO does not have to be executed. last if $loader =~ /yaboot/i; # yaboot does not have to be executed. last if $loader =~ /milo/i; # MILO does not have to be executed. last if $loader =~ /nettrom/i; # NETTROM does not have to be executed. last if $loader =~ /arcboot/i; # ARCBOOT does not have to be executed. last if $loader =~ /delo/i; # DELO does not have to be executed. last if $loader =~ /quik/i; # maintainer asked quik invocation to be ignored last unless $loaderloc; last unless -x $loaderloc; last unless $do_bootloader; if (-T "/etc/$loader.conf") { # Trust and use the existing lilo.conf. print STDERR "You already have a $Loader configuration in /etc/$loader.conf\n"; my $ret = &run_lilo(); exit $ret if $ret; } } sub run_lilo (){ my $ret; # Try and figure out if the user really wants lilo to be run -- # since the default is to run the boot laoder, which is ! grub -- but # the user may be using grub now, and not changed the default. # So, if the user has explicitly asked for the loader to be run, or # if there is no postinst hook, or if there is no grub installed -- # we are OK. Or else, we ask. if ($explicit_do_loader || (! ($postinst_hook && -x '/usr/sbin/grub'))) { print STDERR "Running boot loader as requested\n"; } else { print STDERR "Ok, not running $loader\n"; } if ($loader =~ /^lilo/io or $loader =~ /vmelilo/io) { print STDERR "Testing $loader.conf ... \n"; unlink $temp_file_name; # security $ret = system("$loaderloc -t >$temp_file_name 2>&1"); if ($ret) { print STDERR "Boot loader test failed\n"; return $ret; } unlink "$temp_file_name"; print STDERR "Testing successful.\n"; print STDERR "Installing the "; print STDERR "partition " if $loader =~ /^lilo/io; print STDERR "boot sector... \n"; } print STDERR "Running $loaderloc ... \n"; if ($loader =~ /^elilo/io) { $ret = system("$loaderloc 2>&1 | tee $temp_file_name"); } else { $ret = system("$loaderloc >$temp_file_name 2>&1"); } if ($ret) { print STDERR "Boot loader failed to run\n"; return $ret; } unlink $temp_file_name; print STDERR "Installation successful.\n"; return 0; } exit 0; __END__