home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / sbin / update-grub < prev    next >
Encoding:
Text File  |  2007-05-06  |  35.3 KB  |  1,309 lines
  1. #!/bin/bash
  2. #
  3. # Insert a list of installed kernels in a grub config file
  4. #   Copyright 2001 Wichert Akkerman <wichert@linux.com>
  5. #
  6. # This file is free software; you can redistribute it and/or modify it
  7. # under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful, but
  12. # WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14. # General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19. #
  20. # Contributors:
  21. #    Jason Thomas <jason@debian.org>
  22. #    David B.Harris <dbarclay10@yahoo.ca>
  23. #    Marc Haber <mh@zugschlus.de>
  24. #    Crispin Flowerday <crispin@zeus.com>
  25.  
  26. # Abort on errors
  27. set -e
  28.  
  29. host_os=`uname -s | tr '[A-Z]' '[a-z]'`
  30.  
  31. abort() {
  32.     message=$@
  33.  
  34.     echo >&2
  35.     printf '%s\n' "$message" >&2
  36.     echo >&2
  37.     exit 1
  38. }
  39.  
  40. find_grub_dir ()
  41. {
  42.     echo  -n "Searching for GRUB installation directory ... " >&2
  43.  
  44.     for d in $grub_dirs ; do
  45.         if [ -d "$d" ] ; then
  46.             grub_dir="$d"
  47.             break
  48.         fi
  49.     done
  50.     
  51.     if [ -z "$grub_dir" ] ; then
  52.         abort "No GRUB directory found.
  53.  To create a template run 'mkdir /boot/grub' first.
  54.  To install grub, install it manually or try the 'grub-install' command.
  55.  ### Warning, grub-install is used to change your MBR. ###"
  56.     else
  57.         echo "found: $grub_dir" >&2
  58.     fi
  59.  
  60.     echo $grub_dir
  61. }
  62.  
  63. find_device ()
  64. {
  65.     mount_point=$1
  66.  
  67.     # Autodetect current root device
  68.     device=
  69.     if [ -f /etc/fstab ] ; then
  70.         while read DEV MNT FOO; do
  71.             if `echo "$DEV" | grep -q "^#"`; then
  72.                 continue
  73.             fi
  74.             if [ "$MNT" = "$mount_point" ]; then
  75.                 device="$DEV";
  76.             fi
  77.         done < /etc/fstab
  78.     fi
  79.  
  80.     if [ -n "$device" ] ; then
  81.         case "$device" in
  82.             LABEL=* | UUID=*)
  83.                 device=`readlink -f "$(findfs $device)"`
  84.             ;;
  85.             *)
  86.                 device=`readlink -f "$device"`
  87.             ;;
  88.         esac
  89.     fi
  90.  
  91.     echo $device
  92. }
  93.  
  94. find_root_device ()
  95. {
  96.     device=$(find_device "/")
  97.  
  98.     if [ -z "$device" ]; then
  99.         echo "Cannot determine root device.  Assuming /dev/hda1" >&2
  100.         echo "This error is probably caused by an invalid /etc/fstab" >&2
  101.         device=/dev/hda1
  102.     fi
  103.  
  104.     echo $device
  105. }
  106.  
  107. # Usage: convert_raid1 os_device
  108. # Checks if os_device is a software raid1.
  109. # If so, converts to first physical device in array.
  110. convert_raid1 ()
  111. {
  112.     case $1 in
  113.         /dev/md[0-9])
  114.             : ;; # Continue
  115.         *)
  116.             return 1 ;;
  117.     esac
  118.  
  119.     [ -x /sbin/mdadm ] || return 1
  120.  
  121.     # Check that the raid device is raid1
  122.     raidlevel=$(mdadm -D -b $1 | grep "^ARRAY" | \
  123.             sed "s/^.*level=//" | cut -d" " -f1)
  124.     [ "$raidlevel" = "raid1" ] || return 1
  125.     
  126.     # Take only the first device that makes up the raid
  127.     raiddev=$(mdadm -D $1 | grep -A1 "Number" | grep "dev" \
  128.                           | sed "s/^.*\(\/dev\/.*\)$/\1/")
  129.     [ -n "$raiddev" ] || return 1
  130.  
  131.     echo $raiddev
  132.     return 0
  133. }
  134.  
  135. # Usage: convert os_device
  136. # Convert an OS device to the corresponding GRUB drive.
  137. # This part is OS-specific.
  138. convert () {
  139.     # First, check if the device file exists.
  140.     if test -e "$1"; then
  141.         :
  142.     else
  143.         echo "$1: Not found or not a block device." 1>&2
  144.         exit 1
  145.     fi
  146.  
  147.     host_os=`uname -s | tr '[[:upper:]]' '[[:lower:]]'`
  148.  
  149.     # Break the device name into the disk part and the partition part.
  150.     case "$host_os" in
  151.     linux)
  152.         tmp_disk=`echo "$1" | sed -e 's%\([sh]d[[:lower:]]\)[0-9]*$%\1%' \
  153.                   -e 's%\(fd[0-9]*\)$%\1%' \
  154.                   -e 's%/part[0-9]*$%/disc%' \
  155.                   -e 's%\(c[0-7]d[0-9]*\).*$%\1%'`
  156.         tmp_part=`echo "$1" | sed -e 's%.*/[sh]d[[:lower:]]\([0-9]*\)$%\1%' \
  157.                   -e 's%.*/fd[0-9]*$%%' \
  158.                   -e 's%.*/floppy/[0-9]*$%%' \
  159.                   -e 's%.*/\(disc\|part\([0-9]*\)\)$%\2%' \
  160.                   -e 's%.*c[0-7]d[0-9]*p*%%'`
  161.     ;;
  162.     gnu)
  163.         tmp_disk=`echo "$1" | sed 's%\([sh]d[0-9]*\).*%\1%'`
  164.         tmp_part=`echo "$1" | sed "s%$tmp_disk%%"` ;;
  165.     freebsd|*/kfreebsd)
  166.         tmp_disk=`echo "$1" | sed 's%r\{0,1\}\([saw]d[0-9]*\).*$%\1%' \
  167.                 | sed 's%r\{0,1\}\(da[0-9]*\).*$%\1%'`
  168.         tmp_part=`echo "$1" \
  169.                 | sed "s%.*/r\{0,1\}[saw]d[0-9]\(s[0-9]*[a-h]\)%\1%" \
  170.                    | sed "s%.*/r\{0,1\}da[0-9]\(s[0-9]*[a-h]\)%\1%"`
  171.     ;;
  172.     netbsd|*/knetbsd)
  173.         tmp_disk=`echo "$1" | sed 's%r\{0,1\}\([sw]d[0-9]*\).*$%r\1d%' \
  174.                 | sed 's%r\{0,1\}\(fd[0-9]*\).*$%r\1a%'`
  175.         tmp_part=`echo "$1" \
  176.                 | sed "s%.*/r\{0,1\}[sw]d[0-9]\([abe-p]\)%\1%"`
  177.     ;;
  178.     *)
  179.         echo "update-grub does not support your OS yet." 1>&2
  180.         exit 1 ;;
  181.     esac
  182.  
  183.     # Get the drive name.
  184.     tmp_drive=`grep -v '^#' $device_map | grep "$tmp_disk *$" \
  185.             | sed 's%.*\(([hf]d[0-9][a-z0-9,]*)\).*%\1%'`
  186.  
  187.     # If not found, print an error message and exit.
  188.     if test "x$tmp_drive" = x; then
  189.         echo "$1 does not have any corresponding BIOS drive." 1>&2
  190.         exit 1
  191.     fi
  192.  
  193.     if test "x$tmp_part" != x; then
  194.         # If a partition is specified, we need to translate it into the
  195.         # GRUB's syntax.
  196.         case "$host_os" in
  197.         linux)
  198.               echo "$tmp_drive" | sed "s%)$%,`expr $tmp_part - 1`)%" ;;
  199.         gnu)
  200.               if echo $tmp_part | grep "^s" >/dev/null; then
  201.                 tmp_pc_slice=`echo $tmp_part \
  202.                     | sed "s%s\([0-9]*\)[a-z]*$%\1%"`
  203.                 tmp_drive=`echo "$tmp_drive" \
  204.                     | sed "s%)%,\`expr "$tmp_pc_slice" - 1\`)%"`
  205.               fi
  206.               if echo $tmp_part | grep "[a-z]$" >/dev/null; then
  207.                 tmp_bsd_partition=`echo "$tmp_part" \
  208.                     | sed "s%[^a-z]*\([a-z]\)$%\1%"`
  209.                 tmp_drive=`echo "$tmp_drive" \
  210.                     | sed "s%)%,$tmp_bsd_partition)%"`
  211.               fi
  212.               echo "$tmp_drive" ;;
  213.         freebsd|*/kfreebsd)
  214.               if echo $tmp_part | grep "^s" >/dev/null; then
  215.                 tmp_pc_slice=`echo $tmp_part \
  216.                     | sed "s%s\([0-9]*\)[a-h]*$%\1%"`
  217.                 tmp_drive=`echo "$tmp_drive" \
  218.                     | sed "s%)%,\`expr "$tmp_pc_slice" - 1\`)%"`
  219.               fi
  220.               if echo $tmp_part | grep "[a-h]$" >/dev/null; then
  221.                 tmp_bsd_partition=`echo "$tmp_part" \
  222.                     | sed "s%s\{0,1\}[0-9]*\([a-h]\)$%\1%"`
  223.                 tmp_drive=`echo "$tmp_drive" \
  224.                     | sed "s%)%,$tmp_bsd_partition)%"`
  225.               fi
  226.               echo "$tmp_drive" ;;
  227.         netbsd|*/knetbsd)
  228.               if echo $tmp_part | grep "^[abe-p]$" >/dev/null; then
  229.                 tmp_bsd_partition=`echo "$tmp_part" \
  230.                     | sed "s%\([a-p]\)$%\1%"`
  231.                 tmp_drive=`echo "$tmp_drive" \
  232.                     | sed "s%)%,$tmp_bsd_partition)%"`
  233.               fi
  234.               echo "$tmp_drive" ;;
  235.         esac
  236.     else
  237.         # If no partition is specified, just print the drive name.
  238.         echo "$tmp_drive"
  239.     fi
  240. }
  241.  
  242. # Usage: convert_default os_device
  243. # Convert an OS device to the corresponding GRUB drive.
  244. # Calls OS-specific convert, and returns a default of
  245. # (hd0,0) if anything goes wrong
  246. convert_default () {
  247.     # Check if device is software raid1 array
  248.     if tmp_dev=$(convert_raid1 $1 2>/dev/null) ; then
  249.         : # Use device returned by convert_raid1
  250.     else
  251.         tmp_dev=$1
  252.     fi
  253.  
  254.     if tmp=$(convert $tmp_dev 2>/dev/null) ; then
  255.         echo $tmp
  256.     else
  257.         echo "(hd0,0)"
  258.     fi
  259. }
  260.  
  261. is_removable () {
  262.     removabledevice="$(echo "$1" | sed -e 's%\([sh]d[a-z]\)[0-9]*$%\1%' -e 's%\(fd[0-9]*\)$%\1%' -e 's%/part[0-9]*$%/disc%' -e 's%\(c[0-7]d[0-9]*\).*$%\1%' -e 's%^/dev/%%g')"
  263.         if [ -e "/sys/block/$removabledevice/removable" ]; then
  264.                 if [ "$(cat /sys/block/$removabledevice/removable)" != "0" ]; then
  265.                         echo "/dev/$removabledevice"
  266.                         return
  267.                 fi
  268.         fi
  269.     echo ""
  270. }
  271.  
  272. ## Configuration Options
  273. # directory's to look for the grub installation and the menu file
  274. grub_dirs="/boot/grub /boot/boot/grub"
  275.  
  276. # The grub installation directory
  277. grub_dir=$(find_grub_dir)
  278.  
  279. # Full path to the menu.lst
  280. menu_file_basename=menu.lst
  281. menu_file=$grub_dir/$menu_file_basename
  282.  
  283. # the device for the / filesystem
  284. root_device=$(find_root_device)
  285.  
  286. # the device for the /boot filesystem
  287. boot_device=$(find_device "/boot")
  288.  
  289. # Full path to the device.map
  290. device_map=$grub_dir/device.map
  291.  
  292. # Enable crashdump menu alternative
  293. crashdump="0"
  294.  
  295. # Default kernel options, overidden by the kopt statement in the menufile.
  296. kopt="root=$(awk '$2 == "/" {print $1}' /etc/fstab) ro"
  297.  
  298. # Title
  299. title="Linux Mint"
  300.  
  301. # should update-grub remember the default entry
  302. updatedefaultentry="false"
  303.  
  304. # Drive(in GRUB terms) where the kernel is located. Overridden by the
  305. # kopt statement in menufile.
  306. # if we don't have a device.map then we can't use the convert function.
  307. check_removable=""
  308. if test -f "$device_map" ; then
  309.     if test -z "$boot_device" ; then
  310.         grub_root_device=$(convert_default "$root_device")
  311.         check_removable="$(is_removable "$root_device")"
  312.     else
  313.         grub_root_device=$(convert_default "$boot_device")
  314.         check_removable="$(is_removable "$boot_device")"
  315.     fi
  316. else
  317.     grub_root_device="(hd0,0)"
  318. fi
  319.  
  320. # If the root/boot device is on a removable target, we need to override
  321. # the grub_root_device to (hd0,X). This is a requirement since the BIOS
  322. # will change device mapping dynamically if we switch boot device.
  323.  
  324. if test -n "$check_removable" ; then
  325.     grub_root_device="$(echo "$grub_root_device" | sed -e 's/d.*,/d0,/g')"
  326. fi
  327.  
  328. # should grub create the alternative boot options in the menu
  329.     alternative="true"
  330.  
  331. # should grub lock the alternative boot options in the menu
  332.     lockalternative="false"
  333.  
  334. # additional options to use with the default boot option, but not with the
  335. # alternatives
  336.     defoptions="quiet splash"
  337.  
  338. # should grub lock the old kernels
  339.     lockold="false"
  340.  
  341. # Xen hypervisor options to use with the default Xen boot option
  342.     xenhopt=""
  343.  
  344. # Xen Linux kernel options to use with the default Xen boot option
  345.     xenkopt="console=tty0"
  346.  
  347. # options to use with the alternative boot options
  348.     altoptions="(recovery mode) single"
  349.  
  350. # controls howmany kernels are listed in the config file,
  351. # this does not include the alternative kernels
  352.     howmany="all"
  353.  
  354. # should grub create a memtest86 entry
  355.     memtest86="true"
  356.  
  357. # stores the command line arguments
  358.     command_line_arguments=$1
  359.  
  360. # does this version of grub support the quiet option?
  361. if [ -f ${grub_dir}/installed-version ] && dpkg --compare-versions `cat ${grub_dir}/installed-version` ge 0.97-11ubuntu4; then
  362.     supports_quiet=true
  363. else
  364.     supports_quiet=false
  365. fi
  366.  
  367. # read user configuration
  368. if test -f "/etc/default/grub" ; then
  369.     . /etc/default/grub
  370. fi
  371.  
  372. # Default options to use in a new config file. This will only be used if $menu_file
  373. # doesn't already exist. Only edit the lines between the two "EOF"s. The others are
  374. # part of the script.
  375. newtemplate=$(tempfile)
  376. cat > "$newtemplate" <<EOF
  377. # $menu_file_basename - See: grub(8), info grub, update-grub(8)
  378. #            grub-install(8), grub-floppy(8),
  379. #            grub-md5-crypt, /usr/share/doc/grub
  380. #            and /usr/share/doc/grub-doc/.
  381.  
  382. ## default num
  383. # Set the default entry to the entry number NUM. Numbering starts from 0, and
  384. # the entry number 0 is the default if the command is not used.
  385. #
  386. # You can specify 'saved' instead of a number. In this case, the default entry
  387. # is the entry saved with the command 'savedefault'.
  388. # WARNING: If you are using dmraid do not change this entry to 'saved' or your
  389. # array will desync and will not let you boot your system.
  390. default        0
  391.  
  392. ## timeout sec
  393. # Set a timeout, in SEC seconds, before automatically booting the default entry
  394. # (normally the first entry defined).
  395. timeout        3
  396.  
  397. ## hiddenmenu
  398. # Hides the menu by default (press ESC to see the menu)
  399. hiddenmenu
  400.  
  401. # Pretty colours
  402. #color cyan/blue white/blue
  403.  
  404. ## password ['--md5'] passwd
  405. # If used in the first section of a menu file, disable all interactive editing
  406. # control (menu entry editor and command-line)  and entries protected by the
  407. # command 'lock'
  408. # e.g. password topsecret
  409. #      password --md5 \$1\$gLhU0/\$aW78kHK1QfV3P2b2znUoe/
  410. # password topsecret
  411.  
  412. #
  413. # examples
  414. #
  415. # title        Windows 95/98/NT/2000
  416. # root        (hd0,0)
  417. # makeactive
  418. # chainloader    +1
  419. #
  420. # title        Linux
  421. # root        (hd0,1)
  422. # kernel    /vmlinuz root=/dev/hda2 ro
  423. #
  424.  
  425. #
  426. # Put static boot stanzas before and/or after AUTOMAGIC KERNEL LIST
  427.  
  428. EOF
  429. ## End Configuration Options
  430.  
  431.  
  432. # Make sure we use the standard sorting order
  433. LC_COLLATE=C
  434. # Magic markers we use
  435. start="### BEGIN AUTOMAGIC KERNELS LIST"
  436. end="### END DEBIAN AUTOMAGIC KERNELS LIST"
  437.  
  438. startopt="## ## Start Default Options ##"
  439. endopt="## ## End Default Options ##"
  440.  
  441. # Extract options from config file
  442. ExtractMenuOpt()
  443. {
  444.     opt=$1
  445.  
  446.     sed -ne "/^$start\$/,/^$end\$/ {
  447.         /^$startopt\$/,/^$endopt\$/ {
  448.             /^# $opt=/ {
  449.                 s/^# $opt=\(.*\)\$/\1/
  450.                 p
  451.             }
  452.         }
  453.     }" $menu
  454. }
  455.  
  456. GetMenuOpts()
  457. {
  458.     opt=$1
  459.  
  460.     sed -ne "/^$start\$/,/^$end\$/ {
  461.         /^$startopt\$/,/^$endopt\$/ {
  462.             /^# $opt=/ {
  463.                 p
  464.             }
  465.         }
  466.     }" $menu
  467. }
  468.  
  469. ExtractMenuOpts()
  470. {
  471.     opt=$1
  472.  
  473.     GetMenuOpts $opt | sed "s/^# $opt=\(.*\)\$/\1=\"\2\"/"
  474. }
  475.  
  476. GetMenuOpt()
  477. {
  478.     opt=$1
  479.     value=$2
  480.  
  481.     [ -z "$(GetMenuOpts "$opt")" ] || value=$(ExtractMenuOpt "$opt")
  482.  
  483.     echo $value
  484. }
  485.  
  486. # Compares two version strings A and B
  487. # Returns -1 if A<B
  488. #          0 if A==B
  489. #          1 if A>B
  490. # This compares version numbers of the form
  491. # 2.4.14.2 > 2.4.14
  492. # 2.4.14random = 2.4.14-random > 2.4.14-ac10 > 2.4.14 > 2.4.14-pre2 > 
  493. # 2.4.14-pre1 > 2.4.13-ac99
  494. CompareVersions()
  495. {  
  496.         #Changes the line something-x.y.z into somthing-x.y.z.q
  497.     #This is to ensure that kernels with a .q is treated as higher than the ones without               
  498.         #First a space is put after the version number
  499.         v1=$(echo $1 | sed -e 's!^\(.*-\([0-9]\+\.\)\{2,3\}[0-9]\+\)\(.*\)!\1 \3!g')
  500.     v2=$(echo $2 | sed -e 's!^\(.*-\([0-9]\+\.\)\{2,3\}[0-9]\+\)\(.*\)!\1 \3!g')
  501.     #If the version number only has 3 digits then put in another .0
  502.         v1=$(echo $v1 | sed -e 's!^\(.*-\([0-9]\+\.\)\{2\}[0-9]\+\)\( .*\)!\1.0 \3!g')
  503.         v2=$(echo $v2 | sed -e 's!^\(.*-\([0-9]\+\.\)\{2\}[0-9]\+\)\( .*\)!\1.0 \3!g')
  504.           
  505.     # Then split the version number and remove any '.' 's or dashes
  506.     v1=$(echo $v1 | sed -e 's![-\.]\+! !g' -e 's!\([0-9]\)\([[:alpha:]]\)!\1 \2!')
  507.     v2=$(echo $v2 | sed -e 's![-\.]\+! !g' -e 's!\([0-9]\)\([[:alpha:]]\)!\1 \2!')
  508.  
  509.     # we weight different kernel suffixes here
  510.     # ac   = 50
  511.     # pre  = -50
  512.     # rc   = -40
  513.     # test = -60
  514.     # others are given 99
  515.     v1=$(echo $v1 | sed -e 's! k7! 786 !g' -e 's! ac! 50 !g' -e 's! rc! -40 !g' -e 's! pre! -50 !g' -e 's! test! -60 !g' -e 's![^-0-9 ]\+!99!g')
  516.  
  517.     v2=$(echo $v2 | sed -e 's! k7! 786 !g' -e 's! ac! 50 !g' -e 's! rc! -40 !g' -e 's! pre! -50 !g' -e 's! test! -60 !g' -e 's![^-0-9 ]\+!99!g')
  518.  
  519.     result=0; v1finished=0; v2finished=0;
  520.     while [ $result -eq 0 ] && [ $v1finished -eq 0 ] && [ $v2finished -eq 0 ];
  521.     do
  522.         if [ "$v1" = "" ]; then
  523.             v1comp=0; v1finished=1
  524.         else
  525.             set -- $v1; v1comp=$1; shift; v1=$*
  526.         fi
  527.  
  528.         if [ "$v2" = "" ]; then
  529.             v2comp=0; v2finished=1
  530.         else
  531.             set -- $v2; v2comp=$1; shift; v2=$*
  532.         fi
  533.         
  534.         set +e
  535.         result=`expr $v1comp - $v2comp` 
  536.         result=`expr substr $result 1 2`
  537.         set -e
  538.  
  539.         if   [ $result -gt 0 ]; then result=1
  540.         elif [ $result -lt 0 ]; then result=-1    
  541.         fi    
  542.     done
  543.  
  544.     # finally return the result
  545.     echo $result
  546. }
  547.  
  548. # looks in the directory specified for an initrd image with the version specified
  549. FindInitrdName()
  550. {
  551.     # strip trailing slashes
  552.     directory=$(echo $1 | sed -e 's#/*$##')
  553.     version=$2
  554.  
  555.     # initrd
  556.     # initrd.img
  557.     # initrd-lvm
  558.     # .*.gz
  559.  
  560.     initrdName=""
  561.     names="initrd initrd.img initrd-lvm"
  562.     compressed="gz"
  563.  
  564.     for n in $names ; do
  565.         # make sure we haven't already found it
  566.         if [ -z "$initrdName" ] ; then
  567.             if [ -f "$directory/$n$version" ] ; then
  568.                 initrdName="$n$version"
  569.                 break
  570.             else
  571.                 for c in $compressed ; do
  572.                     if [ -f "$directory/$n$version.$c" ] ; then
  573.                         initrdName="$n$version.$c"
  574.                         break
  575.                     fi
  576.                 done
  577.             fi
  578.         else
  579.             break
  580.         fi
  581.     done
  582.  
  583.     # return the result
  584.     echo $initrdName
  585. }
  586.  
  587. FindXenHypervisorVersions ()
  588. {
  589.     version=$1
  590.  
  591.     if [ -f "/var/lib/linux-image-$version/xen-versions" ]; then
  592.         ret="$(cat /var/lib/linux-image-$version/xen-versions)"
  593.     fi
  594.  
  595.     echo $ret
  596. }
  597.  
  598. get_kernel_opt()
  599. {
  600.     kernel_version=$1
  601.  
  602.     version=$(echo $kernel_version | sed 's/^[^0-9]*//')
  603.     version=$(echo $version | sed 's/[-\+\.]/_/g')
  604.     if [ -n "$version" ] ; then
  605.         while [ -n "$version" ] ; do
  606.             currentOpt="$(eval "echo \${kopt_$version}")"
  607.             if [ -n "$currentOpt" ] ; then
  608.                 break
  609.             fi
  610.  
  611.             oldversion="$version"
  612.             version=$(echo $version | sed 's/_\?[^_]*$//')
  613.             if [ "$version" = "$oldversion" ] ; then
  614.                 # Break infinite loop, if the version isn't what we expect
  615.                 break
  616.             fi
  617.         done
  618.     fi
  619.  
  620.     if [ -z "$currentOpt" ] ; then
  621.             currentOpt=$kopt
  622.     fi
  623.  
  624.     echo $currentOpt
  625. }
  626.  
  627. write_kernel_entry()
  628. {
  629.     local kernel_version; kernel_version=$1; shift
  630.     local recovery_desc; recovery_desc=$1; shift
  631.     local lock_alternative; lock_alternative=$1; shift
  632.     local grub_root_device; grub_root_device=$1; shift
  633.     local kernel; kernel=$1; shift
  634.     local kernel_options; kernel_options=$1; shift
  635.     local recovery_suffix; recovery_suffix=$1; shift
  636.     local initrd; initrd=$1; shift
  637.     local savedefault; savedefault=$1; shift
  638.     local lockold; lockold=$1; shift
  639.     local hypervisor
  640.     if [ -n "$1" ]; then
  641.         # Hypervisor.
  642.         hypervisor=$1; shift
  643.         local hypervisor_image; hypervisor_image=$1; shift
  644.         local hypervisor_version; hypervisor_version=$1; shift
  645.         local hypervisor_options; hypervisor_options=$1; shift
  646.     fi
  647.  
  648.     echo -n "title        " >> $buffer
  649.  
  650.     if [ -n "$hypervisor" ]; then
  651.         echo -n "$hypervisor $hypervisor_version / " >> $buffer
  652.     fi
  653.  
  654.     echo -n "$title" >> $buffer
  655.     if [ -n "$kernel_version" ]; then
  656.         echo -n ", " >> $buffer
  657.         # memtest86 is not strictly a kernel
  658.         if ! echo "$kernel_version" | grep -q ^memtest86; then
  659.             echo -n "kernel " >> $buffer
  660.         fi
  661.         echo -n "$kernel_version" >> $buffer
  662.     fi
  663.     if [ -n "$recovery_desc" ]; then
  664.         echo -n " $recovery_desc" >> $buffer
  665.     fi
  666.     echo >> $buffer
  667.  
  668.     # lock the alternative options
  669.     if test x"$lock_alternative" = x"true" ; then
  670.         echo "lock" >> $buffer
  671.     fi
  672.     # lock the old entries
  673.     if test x"$lockold" = x"true" ; then
  674.     echo "lock" >> $buffer
  675.     fi
  676.  
  677.     echo "root        $grub_root_device" >> $buffer
  678.  
  679.     echo -n "kernel        "  >> $buffer
  680.     if [ -n "$hypervisor" ]; then
  681.         echo -n "$hypervisor_image" >> $buffer
  682.         if [ -n "$hypervisor_options" ]; then
  683.             echo -n " $hypervisor_options"  >> $buffer
  684.         fi
  685.         echo >> $buffer
  686.         echo -n "module        "  >> $buffer
  687.     fi
  688.     echo -n "$kernel"  >> $buffer
  689.     if [ -n "$kernel_options" ]; then
  690.         echo -n " $kernel_options"  >> $buffer
  691.     fi
  692.     if [ -n "$recovery_desc" ]; then
  693.         echo -n " $recovery_suffix"  >> $buffer
  694.     fi
  695.     echo >> $buffer
  696.  
  697.     if [ -n "$initrd" ]; then
  698.         if [ -n "$hypervisor" ]; then
  699.             echo -n "module        " >> $buffer
  700.         else
  701.             echo -n "initrd        " >> $buffer
  702.         fi
  703.         echo "$initrd" >> $buffer
  704.     fi
  705.  
  706.     if [ ! -n "$recovery_desc" -a x"$supports_quiet" = x"true" ]; then
  707.         echo "quiet" >> $buffer
  708.     fi
  709.  
  710.     if test x"$savedefault" = x"true" ; then
  711.         echo "savedefault" >> $buffer
  712.     fi
  713.     echo >> $buffer
  714. }
  715.  
  716. convert_kopt_to_uuid()
  717. {
  718.     local kopt; kopt=$1
  719.  
  720.     convert=false
  721.     root=$(echo "$kopt" | sed 's/.*root=//;s/ .*//')
  722.     case "$root" in
  723.         UUID=*|LABEL=*)
  724.             ;;
  725.         /dev/disk/*)
  726.             ;;
  727.         /dev/mapper/*)
  728.             ;;
  729.         /dev/evms/[hs]d[a-z][0-9]*)
  730.             convert=:
  731.             ;;
  732.         /dev/evms/*)
  733.             ;;
  734.         /dev/md[0-9]*)
  735.             ;;
  736.         /dev/*)
  737.             convert=:
  738.             ;;
  739.     esac
  740.     if $convert; then
  741.         if [ -L "$DEV" ] && readlink "$DEV" | grep -q "^/dev/mapper/"
  742.         then
  743.             :
  744.         elif [ -b "$root" ]; then
  745.             uuid=$(/sbin/vol_id -u "$root" || true)
  746.             if [ -n "$uuid" ]; then
  747.                 kopt=$(echo "$kopt" | sed "s/\(.*root=\)[^ ]*/\1UUID=$uuid/")
  748.             fi
  749.         fi
  750.     fi
  751.  
  752.     echo "$kopt"
  753. }
  754.  
  755.  
  756. echo -n "Testing for an existing GRUB $menu_file_basename file ... " >&2
  757.  
  758. # Test if our menu file exists
  759. if [ -f "$menu_file" ] ; then
  760.     menu="$menu_file"
  761.     rm -f $newtemplate
  762.     unset newtemplate
  763.     echo "found: $menu_file" >&2
  764.     cp -f "$menu_file" "$menu_file~"
  765. else
  766.     # if not ask user if they want us to create one
  767.     menu="$menu_file"
  768.     echo >&2
  769.     echo >&2
  770.     echo -n "Could not find $menu_file file. " >&2
  771.     if [ "-y" = "$command_line_arguments" ] ; then
  772.         echo >&2
  773.         echo "Generating $menu_file" >&2
  774.         answer=y
  775.     else
  776.         echo -n "Would you like $menu_file generated for you? " >&2
  777.         echo -n "(y/N) " >&2
  778.         read answer
  779.     fi
  780.  
  781.     case "$answer" in
  782.         y* | Y*)
  783.         cat "$newtemplate" > $menu_file
  784.         rm -f $newtemplate
  785.         unset newtemplate
  786.         ;;
  787.         *)
  788.         abort "Not creating $menu_file as you wish"
  789.         ;;
  790.     esac
  791. fi
  792.  
  793. # Extract the crashdump var
  794. crashdump=$(GetMenuOpt "crashdump" "$crashdump")
  795.  
  796. # Extract the kernel options to use
  797. kopt=$(GetMenuOpt "kopt" "$kopt")
  798.  
  799. # Update the root device to mount-by-UUID
  800. kopt=$(convert_kopt_to_uuid "$kopt")
  801.  
  802. # Extract options for specific kernels
  803. opts="$(ExtractMenuOpts "\(kopt_[[:alnum:]_]\+\)")"
  804. test -z "$opts" || eval "$opts"
  805. CustomKopts=$(GetMenuOpts "\(kopt_[[:alnum:]_]\+\)" | \
  806.     grep -v "^# kopt_2_6=" || true)
  807.  
  808. # Set the kernel 2.6 option only for fresh install (but convert it to
  809. # mount-by-UUID on upgrade)
  810. test -z "$kopt_2_6" && test -z "$(GetMenuOpt "kopt" "")" && \
  811.     kopt_2_6="root=$root_device ro"
  812. test -n "$kopt_2_6" && kopt_2_6=$(convert_kopt_to_uuid "$kopt_2_6")
  813.  
  814. # Extract the grub root
  815. grub_root_device=$(GetMenuOpt "groot" "$grub_root_device")
  816.  
  817. # Extract the old recovery value
  818. alternative=$(GetMenuOpt "recovery" "$alternative")
  819.  
  820. # Extract the alternative value
  821. alternative=$(GetMenuOpt "alternative" "$alternative")
  822.  
  823. # Extract the lockalternative value
  824. lockalternative=$(GetMenuOpt "lockalternative" "$lockalternative")
  825.  
  826. # Extract the additional default options
  827. # Check nonaltoptions too for compatibility with Ubuntu <= 5.10
  828. defoptions=$(GetMenuOpt "nonaltoptions" "$defoptions")
  829. defoptions=$(GetMenuOpt "defoptions" "$defoptions")
  830.  
  831. # Extract the lockold value
  832. lockold=$(GetMenuOpt "lockold" "$lockold")
  833.  
  834. # Extract Xen hypervisor options
  835. xenhopt=$(GetMenuOpt "xenhopt" "$xenhopt")
  836.  
  837. # Extract Xen Linux kernel options
  838. xenkopt=$(GetMenuOpt "xenkopt" "$xenkopt")
  839.  
  840. # Extract the howmany value
  841. howmany=$(GetMenuOpt "howmany" "$howmany")
  842.  
  843. # Extract the memtest86 value
  844. memtest86=$(GetMenuOpt "memtest86" "$memtest86")
  845.  
  846.  
  847. # Extract the updatedefaultentry option
  848. updatedefaultentry=$(GetMenuOpt "updatedefaultentry" "$updatedefaultentry")
  849.  
  850.  
  851. # Generate the menu options we want to insert
  852. buffer=$(tempfile)
  853. echo $start >> $buffer
  854. echo "## lines between the AUTOMAGIC KERNELS LIST markers will be modified" >> $buffer
  855. echo "## by the debian update-grub script except for the default options below" >> $buffer
  856. echo >> $buffer
  857. echo "## DO NOT UNCOMMENT THEM, Just edit them to your needs" >> $buffer
  858. echo >> $buffer
  859. echo "## ## Start Default Options ##" >> $buffer
  860.  
  861. echo "## default kernel options" >> $buffer
  862. echo "## default kernel options for automagic boot options" >> $buffer
  863. echo "## If you want special options for specific kernels use kopt_x_y_z" >> $buffer
  864. echo "## where x.y.z is kernel version. Minor versions can be omitted." >> $buffer
  865. echo "## e.g. kopt=root=/dev/hda1 ro" >> $buffer
  866. echo "##      kopt_2_6_8=root=/dev/hdc1 ro" >> $buffer
  867. echo "##      kopt_2_6_8_2_686=root=/dev/hdc2 ro" >> $buffer
  868. echo "# kopt=$kopt" >> $buffer
  869. if [ -n "$kopt_2_6" ] && [ "$kopt" != "$kopt_2_6" ]; then
  870.     echo "# kopt_2_6=$kopt_2_6" >> $buffer
  871. fi
  872. if [ -n "$CustomKopts" ] ; then
  873.     echo "$CustomKopts" >> $buffer
  874. fi
  875. echo >> $buffer
  876.  
  877. echo "## Setup crashdump menu entries" >> $buffer
  878. echo "## e.g. crashdump=1" >> $buffer
  879. echo "# crashdump=$crashdump" >> $buffer
  880. echo >> $buffer
  881.  
  882. echo "## default grub root device" >> $buffer
  883. echo "## e.g. groot=(hd0,0)" >> $buffer
  884. echo "# groot=$grub_root_device" >> $buffer
  885. echo >> $buffer
  886.  
  887. echo "## should update-grub create alternative automagic boot options" >> $buffer
  888. echo "## e.g. alternative=true" >> $buffer
  889. echo "##      alternative=false" >> $buffer
  890. echo "# alternative=$alternative" >> $buffer
  891. echo >> $buffer
  892.  
  893. echo "## should update-grub lock alternative automagic boot options" >> $buffer
  894. echo "## e.g. lockalternative=true" >> $buffer
  895. echo "##      lockalternative=false" >> $buffer
  896. echo "# lockalternative=$lockalternative" >> $buffer
  897. echo >> $buffer
  898.  
  899. echo "## additional options to use with the default boot option, but not with the" >> $buffer
  900. echo "## alternatives" >> $buffer
  901. echo "## e.g. defoptions=vga=791 resume=/dev/hda5" >> $buffer
  902. echo "# defoptions=$defoptions" >> $buffer
  903. echo >> $buffer
  904.  
  905. echo "## should update-grub lock old automagic boot options" >> $buffer
  906. echo "## e.g. lockold=false" >> $buffer
  907. echo "##      lockold=true" >> $buffer
  908. echo "# lockold=$lockold" >> $buffer
  909. echo >> $buffer
  910.  
  911. echo "## Xen hypervisor options to use with the default Xen boot option" >> $buffer
  912. echo "# xenhopt=$xenhopt" >> $buffer
  913. echo >> $buffer
  914.  
  915. echo "## Xen Linux kernel options to use with the default Xen boot option" >> $buffer
  916. echo "# xenkopt=$xenkopt" >> $buffer
  917. echo >> $buffer
  918.  
  919. echo "## altoption boot targets option" >> $buffer
  920. echo "## multiple altoptions lines are allowed" >> $buffer
  921. echo "## e.g. altoptions=(extra menu suffix) extra boot options" >> $buffer
  922. echo "##      altoptions=(recovery) single" >> $buffer
  923.  
  924. if ! grep -q "^# altoptions" $menu ; then
  925.     echo "# altoptions=$altoptions" >> $buffer
  926. else
  927.     grep "^# altoptions" $menu >> $buffer
  928. fi
  929. echo >> $buffer
  930.  
  931. echo "## controls how many kernels should be put into the $menu_file_basename" >> $buffer
  932. echo "## only counts the first occurence of a kernel, not the" >> $buffer
  933. echo "## alternative kernel options" >> $buffer
  934. echo "## e.g. howmany=all" >> $buffer
  935. echo "##      howmany=7" >> $buffer
  936. echo "# howmany=$howmany" >> $buffer
  937. echo >> $buffer
  938.  
  939.  
  940. echo "## should update-grub create memtest86 boot option" >> $buffer
  941. echo "## e.g. memtest86=true" >> $buffer
  942. echo "##      memtest86=false" >> $buffer
  943. echo "# memtest86=$memtest86" >> $buffer
  944. echo >> $buffer
  945.  
  946. echo "## should update-grub adjust the value of the default booted system" >> $buffer
  947. echo "## can be true or false" >> $buffer
  948. echo "# updatedefaultentry=$updatedefaultentry" >> $buffer
  949. echo >> $buffer
  950.  
  951. echo "## ## End Default Options ##" >> $buffer
  952. echo >> $buffer
  953.  
  954. echo -n "Searching for splash image ... " >&2
  955. current_splash=`grep '^splashimage=' ${menu_file} || true`
  956. splashimage_path="splashimage=${grub_root_device}${grub_dir##${boot_device:+/boot}}/splash.xpm.gz"
  957. if [ `sed -e "/^$start/,/^$end/d" $menu_file | grep -c '^splashimage='` != "0" ] ; then
  958.        #checks for splashscreen defined outside the autoupdated part
  959.        splashimage=$(grep '^splashimage=' ${menu_file})
  960.        echo "found: ${splashimage##*=}" >&2
  961.        echo >&2  
  962. elif [ -f "${grub_dir}/splash.xpm.gz" ]  && [ "$current_splash" = "" ]; then
  963.        echo "found: /boot/grub/splash.xpm.gz" >&2
  964.        echo "$splashimage_path" >> $buffer
  965.        echo >> $buffer
  966. elif [ -f "${grub_dir}/splash.xpm.gz" ]  && [ "$current_splash" = "$splashimage_path" ]; then
  967.        echo "found: /boot/grub/splash.xpm.gz" >&2
  968.        echo "$splashimage_path" >> $buffer
  969.        echo >> $buffer
  970. elif [ "$current_splash" != "" ] && [ "$current_splash" != "$splashimage_path" ]; then
  971.        echo "found but preserving previous setting: $(grep '^splashimage=' ${menu_file})" >&2
  972.        echo "$current_splash" >> $buffer
  973.        echo >> $buffer
  974. else
  975.        echo "none found, skipping ..." >&2
  976. fi
  977.  
  978.  
  979. xenKernels=""
  980. for ver in `grep -l CONFIG_XEN_PRIVILEGED_GUEST=y /boot/config* | sed -e s%/boot/config-%%`; do
  981.   # ver is a kernel version
  982.   kern="/boot/vmlinuz-$ver"
  983.   if [ -r $kern ] ; then
  984.        newerKernels=""
  985.        for i in $xenKernels ; do
  986.                 res=$(CompareVersions "$kern" "$i")
  987.                 if [ "$kern" != "" ] && [ "$res" -gt 0 ] ; then
  988.                         newerKernels="$newerKernels $kern $i"
  989.                         kern=""
  990.                 else
  991.                         newerKernels="$newerKernels $i"
  992.                 fi
  993.         done
  994.         if [ "$kern" != "" ] ; then
  995.                 newerKernels="$newerKernels $kern"
  996.         fi
  997.         xenKernels="$newerKernels"
  998.     fi
  999. done
  1000.  
  1001. sortedKernels=""
  1002. for kern in $(/bin/ls -1vr /boot | grep -v "dpkg-*" | grep -v "xen" | grep "^vmlinuz-") ; do
  1003.     # found a kernel
  1004.         if `echo "$xenKernels" | grep -q "$kern "` ; then
  1005.           continue
  1006.         fi
  1007.         # not a Xen kernel
  1008.         kern="/boot/$kern"
  1009.     newerKernels=""
  1010.     for i in $sortedKernels ; do
  1011.         res=$(CompareVersions "$kern" "$i")
  1012.         if [ "$kern" != "" ] && [ "$res" -gt 0 ] ; then
  1013.         newerKernels="$newerKernels $kern $i"
  1014.          kern=""
  1015.         else
  1016.         newerKernels="$newerKernels $i"
  1017.         fi
  1018.     done
  1019.     if [ "$kern" != "" ] ; then
  1020.         newerKernels="$newerKernels $kern"
  1021.     fi
  1022.     sortedKernels="$newerKernels"
  1023. done
  1024.  
  1025. if test -f "/boot/vmlinuz.old" ; then
  1026.     sortedKernels="/boot/vmlinuz.old $sortedKernels"
  1027. fi
  1028. if test -f "/boot/vmlinuz" ; then
  1029.     sortedKernels="/boot/vmlinuz $sortedKernels"
  1030. fi
  1031.  
  1032. hypervisors=""
  1033. for hyp in /boot/xen-*.gz; do
  1034.     if [ ! -h "$hyp" ] && [ -f "$hyp" ]; then
  1035.     hypervisors="$hypervisors `basename "$hyp"`"
  1036.     fi
  1037. done
  1038.  
  1039. # figure out where grub looks for the kernels at boot time
  1040. kernel_dir=/boot
  1041. if [ -n "$boot_device" ] ; then
  1042.     kernel_dir=
  1043. fi
  1044.  
  1045. #Finding the value the default line
  1046. use_grub_set_default="false"
  1047. if test "$updatedefaultentry" = "true" ; then
  1048.     defaultEntryNumber=$(sed -ne 's/^[[:blank:]]*default[[:blank:]]*\(.*\).*/\1/p' $menu)
  1049.  
  1050.     if [ "$defaultEntryNumber" = "saved" ] ; then
  1051.         defaultEntryNumber=$(sed 'q' "$grub_dir/default")
  1052.         use_grub_set_default="true"       
  1053.     fi
  1054.     
  1055.     if test -n "$defaultEntryNumber"; then    
  1056.         defaultEntryNumberPlusOne=$(expr $defaultEntryNumber \+ 1);
  1057.         defaultEntry=$(grep "^[[:blank:]]*title" $menu | sed -ne "${defaultEntryNumberPlusOne}p" | sed -ne ";s/^[[:blank:]]*title[[:blank:]]*//p")
  1058.         defaultEntry=$(echo $defaultEntry | sed -e "s/[[:blank:]]*$//") # don't trust trailing blanks    
  1059.     else
  1060.         notChangeDefault="yes"
  1061.     fi
  1062. else
  1063.         notChangeDefault="yes"
  1064. fi
  1065.  
  1066. ## heres where we start writing out the kernel entries
  1067. counter=0
  1068.  
  1069. # Xen entries first.
  1070. for kern in $xenKernels ; do
  1071.     counter=$(($counter + 1))
  1072.     if test ! x"$howmany" = x"all" ; then
  1073.         if [ $counter -gt $howmany ] ; then
  1074.             break
  1075.         fi
  1076.     fi
  1077.  
  1078.     kernelName=$(basename $kern)
  1079.     kernelVersion=$(echo $kernelName | sed -e 's/vmlinuz//')
  1080.  
  1081.     initrdName=$(FindInitrdName "/boot" "$kernelVersion")
  1082.     initrd=""
  1083.  
  1084.     kernel=$kernel_dir/$kernelName
  1085.     if [ -n "$initrdName" ] ; then
  1086.         initrd=$kernel_dir/$initrdName
  1087.     fi
  1088.  
  1089.     kernelVersion=$(echo $kernelVersion | sed -e 's/^-//')
  1090.     currentOpt=$(get_kernel_opt $kernelVersion)
  1091.  
  1092.     hypervisorVersions=$(FindXenHypervisorVersions "$kernelVersion")
  1093.  
  1094.     found=
  1095.     for hypervisorVersion in $hypervisorVersions; do
  1096.         hypervisor="$kernel_dir/xen-$hypervisorVersion.gz"
  1097.         if [ -e "$hypervisor" ]; then
  1098.             found=1
  1099.  
  1100.             echo "Found Xen hypervisor $hypervisorVersion,  kernel: $kernel"
  1101.  
  1102.             write_kernel_entry "$kernelVersion" '' '' "$grub_root_device" \
  1103.               "$kernel" "$currentOpt $xenkopt" '' "$initrd" true '' \
  1104.               Xen "$hypervisor" "$hypervisorVersion" "$xenhopt"
  1105.         fi
  1106.     done
  1107.  
  1108.     if [ -z $found ]; then
  1109.         for hypervisor in $hypervisors; do
  1110.             hypVersion=`basename "$hypervisor" .gz | sed s%xen-%%`
  1111.         
  1112.             echo "Found Xen hypervisor $hypVersion,  kernel: $kernel"
  1113.  
  1114.             write_kernel_entry "$kernelVersion" '' '' "$grub_root_device" \
  1115.               "$kernel" "$currentOpt $xenkopt" '' "$initrd" true '' \
  1116.               Xen "$kernel_dir/$hypervisor" "$hypVersion" "$xenhopt"
  1117.         done
  1118.     fi
  1119. done
  1120.  
  1121. for kern in $sortedKernels ; do
  1122.     counter=$(($counter + 1))
  1123.     if test ! x"$howmany" = x"all" ; then
  1124.         if [ $counter -gt $howmany ] ; then 
  1125.             break
  1126.         fi
  1127.     fi
  1128.     kernelName=$(basename $kern)
  1129.     kernelVersion=$(echo $kernelName | sed -e 's/vmlinuz//')
  1130.     initrdName=$(FindInitrdName "/boot" "$kernelVersion")
  1131.     initrd=""
  1132.  
  1133.     kernel=$kernel_dir/$kernelName
  1134.     if [ -n "$initrdName" ] ; then
  1135.         initrd=$kernel_dir/$initrdName
  1136.     fi
  1137.  
  1138.     echo "Found kernel: $kernel" >&2
  1139.  
  1140.     if [ "$kernelName" = "vmlinuz" ]; then
  1141.         if [ -L "/boot/$kernelName" ]; then
  1142.             kernelVersion=`readlink -f "/boot/$kernelName"`
  1143.             kernelVersion=$(echo $kernelVersion | sed -e 's/.*vmlinuz-//')
  1144.             kernelVersion="$kernelVersion Default"
  1145.         else
  1146.             kernelVersion="Default"
  1147.         fi
  1148.     fi
  1149.     if [ "$kernelName" = "vmlinuz.old" ]; then
  1150.         if [ -L "/boot/$kernelName" ]; then
  1151.             kernelVersion=`readlink -f "/boot/$kernelName"`
  1152.             kernelVersion=$(echo $kernelVersion | sed -e 's/.*vmlinuz-//')
  1153.             kernelVersion="$kernelVersion Previous"
  1154.         else
  1155.             kernelVersion="Previous"
  1156.         fi
  1157.     fi
  1158.     kernelVersion=$(echo $kernelVersion | sed -e 's/^-//')
  1159.     
  1160.     currentOpt=$(get_kernel_opt $kernelVersion)
  1161.  
  1162.     do_lockold=$lockold
  1163.     # do not lockold for the first entry
  1164.     [ $counter -eq 1 ] && do_lockold=false
  1165.  
  1166.     write_kernel_entry "$kernelVersion" "" "" "$grub_root_device" "$kernel" \
  1167.         "$currentOpt $defoptions" "" "$initrd" "true" "$do_lockold"
  1168.  
  1169.     # insert the alternative boot options
  1170.     if test ! x"$alternative" = x"false" ; then
  1171.         # for each altoptions line do this stuff
  1172.         sed -ne 's/# altoptions=\(.*\)/\1/p' $buffer | while read line; do
  1173.             descr=$(echo $line | sed -ne 's/\(([^)]*)\)[[:space:]]\(.*\)/\1/p')
  1174.             suffix=$(echo $line | sed -ne 's/\(([^)]*)\)[[:space:]]\(.*\)/\2/p')
  1175.  
  1176.             test x"$lockalternative" = x"true" && do_lockold=false
  1177.             write_kernel_entry "$kernelVersion" "$descr" "$lockalternative" \
  1178.                 "$grub_root_device" "$kernel" "$currentOpt" "$suffix" "$initrd" \
  1179.                 "false" "$do_lockold"
  1180.         done
  1181.     fi
  1182.  
  1183.     if [ "$crashdump" = "1" ] ; then
  1184.         test x"$lockalternative" = x"true" && do_lockold=false
  1185.         write_kernel_entry "$kernelVersion" "(crashdump mode)" "$lockalternative" \
  1186.             "$grub_root_device" "$kernel" "$currentOpt" "crashkernel=64M@16M" "$initrd" \
  1187.             "false" "$do_lockold"
  1188.     fi
  1189. done
  1190.  
  1191. grub2name="/boot/grub/core.img"
  1192. if test -f $grub2name ; then
  1193.     echo "Found GRUB 2: $grub2name" >&2
  1194.     cat >> $buffer << EOF
  1195. title        Chainload into GRUB 2
  1196. root        $grub_root_device
  1197. kernel        $grub2name
  1198. savedefault
  1199.  
  1200. EOF
  1201. fi
  1202.     
  1203. memtest86names="memtest86 memtest86+"
  1204.  
  1205. if test ! x"$memtest86" = x"false" ; then
  1206.     for name in $memtest86names ; do
  1207.         if test -f "/boot/$name.bin" ; then
  1208.             kernelVersion="$name"
  1209.             kernel="$kernel_dir/$name.bin"
  1210.             currentOpt=
  1211.             initrd=
  1212.  
  1213.             echo "Found kernel: $kernel" >&2
  1214.  
  1215.             write_kernel_entry "$kernelVersion" "" "" "$grub_root_device" \
  1216.             "$kernel" "$currentOpt" "" "$initrd" "false" ""
  1217.         fi
  1218.     done
  1219. fi
  1220.  
  1221. echo $end >> $buffer
  1222.  
  1223. echo -n "Updating $menu ... " >&2
  1224. # Insert the new options into the menu
  1225. if ! grep -q "^$start" $menu ; then
  1226.     cat $buffer >> $menu
  1227.     rm -f $buffer
  1228. else
  1229.     umask 077
  1230.     sed -e "/^$start/,/^$end/{
  1231.     /^$start/r $buffer
  1232.     d
  1233.     }
  1234.     " $menu > $menu.new
  1235.     cat $menu.new > $menu
  1236.     rm -f $buffer $menu.new
  1237. fi
  1238.  
  1239. # Function to update the default value
  1240. set_default_value() {
  1241.     if [ "$use_grub_set_default" = "true" ] ; then
  1242.     grub-set-default $1
  1243.     else
  1244.     value="$1"
  1245.     newmenu=$(tempfile)
  1246.     sed -e "s/^[[:blank:]]*default[[:blank:]]*[[:digit:]]*\(.*\)/default         ${value}\1/;b" $menu > $newmenu
  1247.     cat $newmenu > $menu
  1248.     rm -f $newmenu
  1249.     unset newmenu
  1250.     fi
  1251. }
  1252.  
  1253. #Updating the default number
  1254. if test -z "$notChangeDefault"; then
  1255.     newDefaultNumberPlusOne=$(grep "^[[:blank:]]*title[[:blank:]]*" $menu | grep -n "${defaultEntry}" | cut -f1 -d ":" | sed -ne "1p")
  1256.     if test -z "$newDefaultNumberPlusOne"; then
  1257.         echo "Previous default entry removed, resetting to 0">&2
  1258.         set_default_value "0"
  1259.     elif test -z "$defaultEntry"; then
  1260.         echo "Value of default value matches no entry, resetting to 0" >&2
  1261.         set_default_value "0"
  1262.     else
  1263.         if test "$newDefaultNumberPlusOne" = "1"; then
  1264.             newDefaultNumber="0"
  1265.         else
  1266.             newDefaultNumber=$(expr $newDefaultNumberPlusOne - 1)
  1267.         fi
  1268.         echo "Updating the default booting kernel">&2
  1269.         set_default_value "$newDefaultNumber"
  1270.     fi
  1271. fi
  1272.  
  1273. # Function to update the default value
  1274. set_default_value() {
  1275.     if [ "$use_grub_set_default" = "true" ] ; then
  1276.     grub-set-default $1
  1277.     else
  1278.     value="$1"
  1279.     newmenu=$(tempfile)
  1280.     sed -e "s/^[[:blank:]]*default[[:blank:]]*[[:digit:]]*\(.*\)/default         ${value}\1/;b" $menu > $newmenu
  1281.     cat $newmenu > $menu
  1282.     rm -f $newmenu
  1283.     unset newmenu
  1284.     fi
  1285. }
  1286.  
  1287. #Updating the default number
  1288. if test -z "$notChangeDefault"; then
  1289.     newDefaultNumberPlusOne=$(grep "^[[:blank:]]*title[[:blank:]]*" $menu | grep -n "${defaultEntry}" | cut -f1 -d ":" | sed -ne "1p")
  1290.     if test -z "$newDefaultNumberPlusOne"; then
  1291.         echo "Previous default entry removed, resetting to 0">&2
  1292.         set_default_value "0"
  1293.     elif test -z "$defaultEntry"; then
  1294.         echo "Value of default value matches no entry, resetting to 0" >&2
  1295.         set_default_value "0"
  1296.     else
  1297.         if test "$newDefaultNumberPlusOne" = "1"; then
  1298.             newDefaultNumber="0"
  1299.         else
  1300.             newDefaultNumber=$(expr $newDefaultNumberPlusOne - 1)
  1301.         fi
  1302.         echo "Updating the default booting kernel">&2
  1303.         set_default_value "$newDefaultNumber"
  1304.     fi
  1305. fi
  1306.  
  1307. echo "done" >&2
  1308. echo >&2
  1309.