1096 lines
30 KiB
Bash
Executable File
1096 lines
30 KiB
Bash
Executable File
#!/bin/bash
|
|
#
|
|
# Insert a list of installed kernels in a grub config file
|
|
# Copyright 2001 Wichert Akkerman <wichert@linux.com>
|
|
# Copyright (C) 2007,2008 Free Software Foundation, Inc.
|
|
#
|
|
# This file is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with GRUB. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# Contributors:
|
|
# Jason Thomas <jason@debian.org>
|
|
# David B.Harris <dbarclay10@yahoo.ca>
|
|
# Marc Haber <mh+debian-packages@zugschlus.de>
|
|
# Crispin Flowerday <crispin@zeus.com>
|
|
|
|
# Abort on errors
|
|
set -e
|
|
|
|
host_os=`uname -s | tr '[A-Z]' '[a-z]'`
|
|
|
|
abort() {
|
|
message=$@
|
|
|
|
echo >&2
|
|
echo -e "$message" >&2
|
|
echo >&2
|
|
exit 1
|
|
}
|
|
|
|
find_grub_dir ()
|
|
{
|
|
echo -n "Searching for GRUB installation directory ... " >&2
|
|
|
|
for d in /boot/grub /boot/boot/grub ; do
|
|
if [ -d "$d" ] ; then
|
|
grub_dir="$d"
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [ -z "$grub_dir" ] ; then
|
|
abort "No GRUB directory found.\n To create a template run 'mkdir /boot/grub' first.\n To install grub, install it manually or try the 'grub-install' command.\n ### Warning, grub-install is used to change your MBR. ###"
|
|
else
|
|
echo "found: $grub_dir" >&2
|
|
fi
|
|
|
|
echo $grub_dir
|
|
}
|
|
|
|
# This function was borrowed from grub2/util/update-grub_lib.in
|
|
make_system_path_relative_to_its_root ()
|
|
{
|
|
path=$1
|
|
# abort if file doesn't exist
|
|
if test -e $path ; then : ;else
|
|
return 1
|
|
fi
|
|
|
|
# canonicalize
|
|
if path=`readlink -f $path` ; then : ; else
|
|
return 1
|
|
fi
|
|
|
|
# if not a directory, climb up to the directory containing it
|
|
if test -d $path ; then
|
|
dir=$path
|
|
else
|
|
dir=`echo $path | sed -e "s,/[^/]*$,,g"`
|
|
fi
|
|
|
|
num=`stat -c %d $dir`
|
|
|
|
# this loop sets $dir to the root directory of the filesystem we're inspecting
|
|
while : ; do
|
|
parent=`readlink -f $dir/..`
|
|
if [ "x`stat -c %d $parent`" = "x$num" ] ; then : ; else
|
|
# $parent is another filesystem; we found it.
|
|
break
|
|
fi
|
|
if [ "x$dir" = "x/" ] ; then
|
|
# / is our root.
|
|
break
|
|
fi
|
|
dir=$parent
|
|
done
|
|
|
|
# This function never prints trailing slashes (so that its output can be
|
|
# appended a slash unconditionally). Each slash in $dir is considered a
|
|
# preceding slash, and therefore the root directory is an empty string.
|
|
if [ "$dir" = "/" ] ; then
|
|
dir=""
|
|
fi
|
|
|
|
echo $path | sed -e "s,^$dir,,g"
|
|
}
|
|
|
|
# The grub installation directory
|
|
grub_dir=$(find_grub_dir)
|
|
|
|
# Full path to the device.map
|
|
device_map=$grub_dir/device.map
|
|
|
|
find_device ()
|
|
{
|
|
if ! test -e ${device_map} ; then
|
|
echo quit | grub --batch --no-floppy --device-map=${device_map} > /dev/null
|
|
fi
|
|
grub-probe --device-map=${device_map} -t device $1 2> /dev/null
|
|
}
|
|
|
|
# Usage: convert_raid1 os_device
|
|
# Checks if os_device is a software raid1.
|
|
# If so, converts to first physical device in array.
|
|
convert_raid1 ()
|
|
{
|
|
case $1 in
|
|
/dev/md[0-9] | /dev/md/[0-9])
|
|
: ;; # Continue
|
|
*)
|
|
return 1 ;;
|
|
esac
|
|
|
|
[ -x /sbin/mdadm ] || return 1
|
|
|
|
# Check that the raid device is raid1
|
|
raidlevel=$(mdadm -D -b $1 | grep "^ARRAY" | \
|
|
sed "s/^.*level=//" | cut -d" " -f1)
|
|
[ "$raidlevel" = "raid1" ] || return 1
|
|
|
|
# Take only the first device that makes up the raid
|
|
raiddev=$(mdadm -D $1 | grep -A1 "Number" | grep "dev" \
|
|
| sed "s/^.*\(\/dev\/.*\)$/\1/")
|
|
[ -n "$raiddev" ] || return 1
|
|
|
|
echo $raiddev
|
|
return 0
|
|
}
|
|
|
|
# Usage: convert os_device
|
|
# Convert an OS device to the corresponding GRUB drive.
|
|
convert () {
|
|
if ! test -e ${device_map} ; then
|
|
echo quit | grub --batch --no-floppy --device-map=${device_map} > /dev/null
|
|
fi
|
|
GRUB_LEGACY_0_BASED_PARTITIONS=1 grub-probe --device-map=${device_map} -t drive -d "$1" 2> /dev/null || {
|
|
echo "warning: grub-probe can't find drive for $1." >&2
|
|
tmp_map=$(mktemp -t device.map.XXXXXXXX)
|
|
grub-mkdevicemap --device-map=${tmp_map} --no-floppy >/dev/null 2>&1 || true
|
|
GRUB_LEGACY_0_BASED_PARTITIONS=1 grub-probe --device-map=${tmp_map} -t drive -d "$1" || {
|
|
rm -f ${tmp_map}
|
|
return 1
|
|
}
|
|
echo "Please check ${device_map}, you might have to regenerate it with grub-mkdevicemap." >&2
|
|
rm -f ${tmp_map}
|
|
}
|
|
}
|
|
|
|
# Usage: convert_default os_device
|
|
# Convert an OS device to the corresponding GRUB drive.
|
|
convert_default () {
|
|
# Check if device is software raid1 array
|
|
if tmp_dev=$(convert_raid1 $1 2>/dev/null) ; then
|
|
: # Use device returned by convert_raid1
|
|
else
|
|
tmp_dev=$1
|
|
fi
|
|
|
|
convert $tmp_dev
|
|
}
|
|
|
|
## Configuration Options
|
|
|
|
# Full path to the menu.lst
|
|
menu_file_basename=menu.lst
|
|
menu_file=$grub_dir/$menu_file_basename
|
|
|
|
# Full path to the default file
|
|
default_file_basename=default
|
|
default_file=$grub_dir/$default_file_basename
|
|
|
|
# the device for the / filesystem
|
|
root_device=$(find_device "/")
|
|
|
|
# loop-AES arranges things so that /dev/loop/X can be our root device, but
|
|
# the initrds that Linux uses don't like that.
|
|
case ${root_device} in
|
|
/dev/loop/*|/dev/loop[0-9])
|
|
root_device=`losetup ${root_device} | sed -e "s/^[^(]*(\([^)]\+\)).*/\1/"`
|
|
;;
|
|
esac
|
|
|
|
# the device for the /boot filesystem
|
|
boot_device=$(find_device "/boot")
|
|
|
|
# where grub looks for the kernels at boot time
|
|
kernel_dir=`make_system_path_relative_to_its_root /boot`
|
|
|
|
# the "-t abstraction" check is a workaround untill #484297 is fixed
|
|
if abstraction=`grub-probe -t abstraction --device ${root_device} 2> /dev/null` && [ "$abstraction" = "" ] && \
|
|
root_uuid=`grub-probe --device-map=${device_map} --device ${root_device} --target=fs_uuid 2> /dev/null` && \
|
|
test -e "/dev/disk/by-uuid/${root_uuid}" ; then
|
|
linux_root_device=UUID=${root_uuid}
|
|
else
|
|
linux_root_device=${root_device}
|
|
fi
|
|
|
|
# Default kernel options, overidden by the kopt statement in the menufile.
|
|
kopt="root=$linux_root_device ro"
|
|
|
|
# Title
|
|
title=$(lsb_release --short --description 2>/dev/null) || title="Ubuntu"
|
|
|
|
# should update-grub remember the default entry
|
|
updatedefaultentry="false"
|
|
|
|
# Drive(in GRUB terms) where the kernel is located. Overridden by the
|
|
# groot statement in menufile.
|
|
grub_root_device=$(convert_default "$boot_device")
|
|
|
|
# should grub create the alternative boot options in the menu
|
|
alternative="true"
|
|
|
|
# should grub lock the alternative boot options in the menu
|
|
lockalternative="false"
|
|
|
|
# additional options to use with the default boot option, but not with the
|
|
# alternatives
|
|
defoptions="quiet splash"
|
|
|
|
# should grub lock the old kernels
|
|
lockold="false"
|
|
|
|
# Xen hypervisor options to use with the default Xen boot option
|
|
xenhopt=""
|
|
|
|
# Xen Linux kernel options to use with the default Xen boot option
|
|
xenkopt="console=tty0"
|
|
|
|
# options to use with the alternative boot options
|
|
altoptions="(recovery mode) single"
|
|
|
|
# controls howmany kernels are listed in the config file,
|
|
# this does not include the alternative kernels
|
|
howmany="all"
|
|
|
|
# should grub create a memtest86 entry
|
|
memtest86="true"
|
|
|
|
# should grub add "savedefault" to default boot options
|
|
savedefault="false"
|
|
|
|
# stores the command line arguments
|
|
command_line_arguments=$1
|
|
|
|
# does this version of grub support the quiet option?
|
|
if [ -f ${grub_dir}/installed-version ] && dpkg --compare-versions `cat ${grub_dir}/installed-version` ge 0.97-11ubuntu4; then
|
|
supports_quiet=true
|
|
else
|
|
supports_quiet=false
|
|
fi
|
|
|
|
# read user configuration
|
|
if test -f "/etc/default/grub" ; then
|
|
. /etc/default/grub
|
|
fi
|
|
|
|
# Default options to use in a new config file. This will only be used if $menu_file
|
|
# doesn't already exist. Only edit the lines between the two "EOF"s. The others are
|
|
# part of the script.
|
|
newtemplate=$(tempfile)
|
|
cat > "$newtemplate" <<EOF
|
|
# $menu_file_basename - See: grub(8), info grub, update-grub(8)
|
|
# grub-install(8), grub-floppy(8),
|
|
# grub-md5-crypt, /usr/share/doc/grub
|
|
# and /usr/share/doc/grub-legacy-doc/.
|
|
|
|
## default num
|
|
# Set the default entry to the entry number NUM. Numbering starts from 0, and
|
|
# the entry number 0 is the default if the command is not used.
|
|
#
|
|
# You can specify 'saved' instead of a number. In this case, the default entry
|
|
# is the entry saved with the command 'savedefault'.
|
|
# WARNING: If you are using dmraid do not change this entry to 'saved' or your
|
|
# array will desync and will not let you boot your system.
|
|
default 0
|
|
|
|
## timeout sec
|
|
# Set a timeout, in SEC seconds, before automatically booting the default entry
|
|
# (normally the first entry defined).
|
|
timeout 5
|
|
|
|
# Pretty colours
|
|
color cyan/blue white/blue
|
|
|
|
## password ['--md5'] passwd
|
|
# If used in the first section of a menu file, disable all interactive editing
|
|
# control (menu entry editor and command-line) and entries protected by the
|
|
# command 'lock'
|
|
# e.g. password topsecret
|
|
# password --md5 \$1\$gLhU0/\$aW78kHK1QfV3P2b2znUoe/
|
|
# password topsecret
|
|
|
|
#
|
|
# examples
|
|
#
|
|
# title Windows 95/98/NT/2000
|
|
# root (hd0,0)
|
|
# makeactive
|
|
# chainloader +1
|
|
#
|
|
# title Linux
|
|
# root (hd0,1)
|
|
# kernel /vmlinuz root=/dev/hda2 ro
|
|
#
|
|
|
|
#
|
|
# Put static boot stanzas before and/or after AUTOMAGIC KERNEL LIST
|
|
|
|
EOF
|
|
## End Configuration Options
|
|
|
|
echo -n "Searching for default file ... " >&2
|
|
if [ -f "$default_file" ] ; then
|
|
echo "found: $default_file" >&2
|
|
else
|
|
echo "Generating $default_file file and setting the default boot entry to 0" >&2
|
|
if [ -f /usr/lib/grub-legacy/grub-set-default ] ; then
|
|
/usr/lib/grub-legacy/grub-set-default 0
|
|
else
|
|
grub-set-default 0
|
|
fi
|
|
fi
|
|
|
|
# Make sure we use the standard sorting order
|
|
LC_COLLATE=C
|
|
# Magic markers we use
|
|
start="### BEGIN AUTOMAGIC KERNELS LIST"
|
|
end="### END DEBIAN AUTOMAGIC KERNELS LIST"
|
|
|
|
startopt="## ## Start Default Options ##"
|
|
endopt="## ## End Default Options ##"
|
|
|
|
# Extract options from config file
|
|
ExtractMenuOpt()
|
|
{
|
|
opt=$1
|
|
|
|
sed -ne "/^$start\$/,/^$end\$/ {
|
|
/^$startopt\$/,/^$endopt\$/ {
|
|
/^# $opt=/ {
|
|
s/^# $opt=\(.*\)\$/\1/
|
|
p
|
|
}
|
|
}
|
|
}" $menu
|
|
}
|
|
|
|
GetMenuOpts()
|
|
{
|
|
opt=$1
|
|
|
|
sed -ne "/^$start\$/,/^$end\$/ {
|
|
/^$startopt\$/,/^$endopt\$/ {
|
|
/^# $opt=/ {
|
|
p
|
|
}
|
|
}
|
|
}" $menu
|
|
}
|
|
|
|
ExtractMenuOpts()
|
|
{
|
|
opt=$1
|
|
|
|
GetMenuOpts $opt | sed "s/^# $opt=\(.*\)\$/\1=\"\2\"/"
|
|
}
|
|
|
|
GetMenuOpt()
|
|
{
|
|
opt=$1
|
|
value=$2
|
|
|
|
[ -z "$(GetMenuOpts "$opt")" ] || value=$(ExtractMenuOpt "$opt")
|
|
|
|
echo $value
|
|
}
|
|
|
|
# Compares two version strings A and B
|
|
# Returns -1 if A<B
|
|
# 0 if A==B
|
|
# 1 if A>B
|
|
# This compares version numbers of the form
|
|
# 2.4.14.2 > 2.4.14
|
|
# 2.4.14random = 2.4.14-random > 2.4.14-ac10 > 2.4.14 > 2.4.14-pre2 >
|
|
# 2.4.14-pre1 > 2.4.13-ac99
|
|
CompareVersions()
|
|
{
|
|
local sedexp="s,.*/vmlinu[zx]-,,g;s/[._-]\(pre\|rc\|test\|git\|trunk\)/~\1/g"
|
|
local a=`echo $1 | sed -e "$sedexp"`
|
|
local b=`echo $2 | sed -e "$sedexp"`
|
|
if [ "$a" = "$b" ] ; then
|
|
echo 0
|
|
elif dpkg --compare-versions "$a" gt "$b" ; then
|
|
echo 1
|
|
else
|
|
echo -1
|
|
fi
|
|
}
|
|
|
|
# looks in the directory specified for an initrd image with the version specified
|
|
FindInitrdName()
|
|
{
|
|
# strip trailing slashes
|
|
directory=$(echo $1 | sed -e 's#/*$##')
|
|
version=$2
|
|
|
|
# initrd
|
|
# initrd.img
|
|
# initrd-lvm
|
|
# .*.gz
|
|
|
|
initrdName=""
|
|
names="initrd initrd.img initrd-lvm"
|
|
compressed="gz"
|
|
|
|
for n in $names ; do
|
|
# make sure we haven't already found it
|
|
if [ -z "$initrdName" ] ; then
|
|
if [ -f "$directory/$n$version" ] ; then
|
|
initrdName="$n$version"
|
|
break
|
|
else
|
|
for c in $compressed ; do
|
|
if [ -f "$directory/$n$version.$c" ] ; then
|
|
initrdName="$n$version.$c"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
else
|
|
break
|
|
fi
|
|
done
|
|
|
|
# return the result
|
|
echo $initrdName
|
|
}
|
|
|
|
FindXenHypervisorVersions ()
|
|
{
|
|
version=$1
|
|
|
|
if [ -f "/var/lib/linux-image-$version/xen-versions" ]; then
|
|
ret="$(cat /var/lib/linux-image-$version/xen-versions)"
|
|
fi
|
|
|
|
echo $ret
|
|
}
|
|
|
|
get_kernel_opt()
|
|
{
|
|
kernel_version=$1
|
|
|
|
version=$(echo $kernel_version | sed 's/^[^0-9]*//')
|
|
version=$(echo $version | sed 's/[-\+\.]/_/g')
|
|
if [ -n "$version" ] ; then
|
|
while [ -n "$version" ] ; do
|
|
currentOpt="$(eval "echo \${kopt_$version}")"
|
|
if [ -n "$currentOpt" ] ; then
|
|
break
|
|
fi
|
|
version=$(echo $version | sed 's/_\?[^_]*$//')
|
|
done
|
|
fi
|
|
|
|
if [ -z "$currentOpt" ] ; then
|
|
currentOpt=$kopt
|
|
fi
|
|
|
|
echo $currentOpt
|
|
}
|
|
|
|
write_kernel_entry()
|
|
{
|
|
local kernel_version; kernel_version=$1; shift
|
|
local recovery_desc; recovery_desc=$1; shift
|
|
local lock_alternative; lock_alternative=$1; shift
|
|
local grub_root_device; grub_root_device=$1; shift
|
|
local kernel; kernel=$1; shift
|
|
local kernel_options; kernel_options=$1; shift
|
|
local recovery_suffix; recovery_suffix=$1; shift
|
|
local initrd; initrd=$1; shift
|
|
local savedefault; savedefault=$1; shift
|
|
local lockold; lockold=$1; shift
|
|
local hypervisor
|
|
if [ -n "$1" ]; then
|
|
# Hypervisor.
|
|
hypervisor=$1; shift
|
|
local hypervisor_image; hypervisor_image=$1; shift
|
|
local hypervisor_version; hypervisor_version=$1; shift
|
|
local hypervisor_options; hypervisor_options=$1; shift
|
|
fi
|
|
|
|
local grub_root_type
|
|
case "$grub_root_device" in
|
|
[^A-Za-z0-9]*) grub_root_type='root' ;;
|
|
*) grub_root_type='uuid' ;;
|
|
esac
|
|
|
|
echo -n "title " >> $buffer
|
|
|
|
if [ -n "$hypervisor" ]; then
|
|
echo -n "$hypervisor $hypervisor_version / " >> $buffer
|
|
fi
|
|
|
|
echo -n "$title" >> $buffer
|
|
if [ -n "$kernel_version" ]; then
|
|
echo -n ", " >> $buffer
|
|
# memtest86 is not strictly a kernel
|
|
if ! echo "$kernel_version" | grep -q ^memtest86; then
|
|
echo -n "kernel " >> $buffer
|
|
fi
|
|
echo -n "$kernel_version" >> $buffer
|
|
fi
|
|
if [ -n "$recovery_desc" ]; then
|
|
echo -n " $recovery_desc" >> $buffer
|
|
fi
|
|
echo >> $buffer
|
|
|
|
# lock the alternative options
|
|
if test x"$lock_alternative" = x"true" ; then
|
|
echo "lock" >> $buffer
|
|
fi
|
|
# lock the old entries
|
|
if test x"$lockold" = x"true" ; then
|
|
echo "lock" >> $buffer
|
|
fi
|
|
|
|
echo "$grub_root_type $grub_root_device" >> $buffer
|
|
|
|
echo -n "kernel " >> $buffer
|
|
if [ -n "$hypervisor" ]; then
|
|
echo -n "$hypervisor_image" >> $buffer
|
|
if [ -n "$hypervisor_options" ]; then
|
|
echo -n " $hypervisor_options" >> $buffer
|
|
fi
|
|
echo >> $buffer
|
|
echo -n "module " >> $buffer
|
|
fi
|
|
echo -n "$kernel" >> $buffer
|
|
if [ -n "$kernel_options" ]; then
|
|
echo -n " $kernel_options" >> $buffer
|
|
fi
|
|
if [ -n "$recovery_desc" ]; then
|
|
echo -n " $recovery_suffix" >> $buffer
|
|
fi
|
|
echo >> $buffer
|
|
|
|
if [ -n "$initrd" ]; then
|
|
if [ -n "$hypervisor" ]; then
|
|
echo -n "module " >> $buffer
|
|
else
|
|
echo -n "initrd " >> $buffer
|
|
fi
|
|
echo "$initrd" >> $buffer
|
|
fi
|
|
|
|
if [ ! -n "$recovery_desc" -a x"$supports_quiet" = x"true" ]; then
|
|
echo "quiet" >> $buffer
|
|
fi
|
|
|
|
if test x"$savedefault" = x"true" ; then
|
|
echo "savedefault" >> $buffer
|
|
fi
|
|
echo >> $buffer
|
|
}
|
|
|
|
|
|
echo -n "Testing for an existing GRUB $menu_file_basename file ... " >&2
|
|
|
|
# Test if our menu file exists
|
|
if [ -f "$menu_file" ] ; then
|
|
menu="$menu_file"
|
|
rm -f $newtemplate
|
|
unset newtemplate
|
|
echo "found: $menu_file" >&2
|
|
cp -f "$menu_file" "$menu_file~"
|
|
else
|
|
# if not ask user if they want us to create one
|
|
menu="$menu_file"
|
|
echo >&2
|
|
echo >&2
|
|
if [ "-y" = "$command_line_arguments" ] ; then
|
|
echo "Warning: ignoring deprecated -y option." >&2
|
|
fi
|
|
echo >&2
|
|
echo "Generating $menu_file" >&2
|
|
cat "$newtemplate" > $menu_file
|
|
rm -f $newtemplate
|
|
unset newtemplate
|
|
fi
|
|
|
|
# Extract the kernel options to use
|
|
kopt=$(GetMenuOpt "kopt" "$kopt")
|
|
|
|
# Set the kernel 2.6 option only for fresh install
|
|
test -z "$(GetMenuOpt "kopt" "")" && kopt_2_6="root=$linux_root_device ro"
|
|
|
|
# Extract options for specific kernels
|
|
opts="$(ExtractMenuOpts "\(kopt_[[:alnum:]_]\+\)")"
|
|
test -z "$opts" || eval "$opts"
|
|
CustomKopts=$(GetMenuOpts "\(kopt_[[:alnum:]_]\+\)")
|
|
|
|
# Extract the grub root
|
|
grub_root_device=$(GetMenuOpt "groot" "$grub_root_device")
|
|
|
|
# Extract the old recovery value
|
|
alternative=$(GetMenuOpt "recovery" "$alternative")
|
|
|
|
# Extract the alternative value
|
|
alternative=$(GetMenuOpt "alternative" "$alternative")
|
|
|
|
# Extract the lockalternative value
|
|
lockalternative=$(GetMenuOpt "lockalternative" "$lockalternative")
|
|
|
|
# Extract the additional default options
|
|
defoptions=$(GetMenuOpt "defoptions" "$defoptions")
|
|
|
|
# Extract the lockold value
|
|
lockold=$(GetMenuOpt "lockold" "$lockold")
|
|
|
|
# Extract Xen hypervisor options
|
|
xenhopt=$(GetMenuOpt "xenhopt" "$xenhopt")
|
|
|
|
# Extract Xen Linux kernel options
|
|
xenkopt=$(GetMenuOpt "xenkopt" "$xenkopt")
|
|
|
|
# Extract the howmany value
|
|
howmany=$(GetMenuOpt "howmany" "$howmany")
|
|
|
|
# Extract the memtest86 value
|
|
memtest86=$(GetMenuOpt "memtest86" "$memtest86")
|
|
|
|
|
|
# Extract the updatedefaultentry option
|
|
updatedefaultentry=$(GetMenuOpt "updatedefaultentry" "$updatedefaultentry")
|
|
|
|
# Extract the savedefault option
|
|
savedefault=$(GetMenuOpt "savedefault" "$savedefault")
|
|
|
|
# Generate the menu options we want to insert
|
|
buffer=$(tempfile)
|
|
echo $start >> $buffer
|
|
echo "## lines between the AUTOMAGIC KERNELS LIST markers will be modified" >> $buffer
|
|
echo "## by the debian update-grub script except for the default options below" >> $buffer
|
|
echo >> $buffer
|
|
echo "## DO NOT UNCOMMENT THEM, Just edit them to your needs" >> $buffer
|
|
echo >> $buffer
|
|
echo "## ## Start Default Options ##" >> $buffer
|
|
|
|
echo "## default kernel options" >> $buffer
|
|
echo "## default kernel options for automagic boot options" >> $buffer
|
|
echo "## If you want special options for specific kernels use kopt_x_y_z" >> $buffer
|
|
echo "## where x.y.z is kernel version. Minor versions can be omitted." >> $buffer
|
|
echo "## e.g. kopt=root=/dev/hda1 ro" >> $buffer
|
|
echo "## kopt_2_6_8=root=/dev/hdc1 ro" >> $buffer
|
|
echo "## kopt_2_6_8_2_686=root=/dev/hdc2 ro" >> $buffer
|
|
echo "# kopt=$kopt" >> $buffer
|
|
if [ -n "$CustomKopts" ] ; then
|
|
echo "$CustomKopts" >> $buffer
|
|
elif [ -n "$kopt_2_6" ] && [ "$kopt" != "$kopt_2_6" ]; then
|
|
echo "# kopt_2_6=$kopt_2_6" >> $buffer
|
|
fi
|
|
echo >> $buffer
|
|
|
|
echo "## default grub root device" >> $buffer
|
|
echo "## e.g. groot=(hd0,0)" >> $buffer
|
|
echo "# groot=$grub_root_device" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## should update-grub create alternative automagic boot options" >> $buffer
|
|
echo "## e.g. alternative=true" >> $buffer
|
|
echo "## alternative=false" >> $buffer
|
|
echo "# alternative=$alternative" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## should update-grub lock alternative automagic boot options" >> $buffer
|
|
echo "## e.g. lockalternative=true" >> $buffer
|
|
echo "## lockalternative=false" >> $buffer
|
|
echo "# lockalternative=$lockalternative" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## additional options to use with the default boot option, but not with the" >> $buffer
|
|
echo "## alternatives" >> $buffer
|
|
echo "## e.g. defoptions=vga=791 resume=/dev/hda5" >> $buffer
|
|
echo "# defoptions=$defoptions" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## should update-grub lock old automagic boot options" >> $buffer
|
|
echo "## e.g. lockold=false" >> $buffer
|
|
echo "## lockold=true" >> $buffer
|
|
echo "# lockold=$lockold" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## Xen hypervisor options to use with the default Xen boot option" >> $buffer
|
|
echo "# xenhopt=$xenhopt" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## Xen Linux kernel options to use with the default Xen boot option" >> $buffer
|
|
echo "# xenkopt=$xenkopt" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## altoption boot targets option" >> $buffer
|
|
echo "## multiple altoptions lines are allowed" >> $buffer
|
|
echo "## e.g. altoptions=(extra menu suffix) extra boot options" >> $buffer
|
|
echo "## altoptions=(recovery) single" >> $buffer
|
|
|
|
if ! grep -q "^# altoptions" $menu ; then
|
|
echo "# altoptions=$altoptions" >> $buffer
|
|
else
|
|
grep "^# altoptions" $menu >> $buffer
|
|
fi
|
|
echo >> $buffer
|
|
|
|
echo "## controls how many kernels should be put into the $menu_file_basename" >> $buffer
|
|
echo "## only counts the first occurence of a kernel, not the" >> $buffer
|
|
echo "## alternative kernel options" >> $buffer
|
|
echo "## e.g. howmany=all" >> $buffer
|
|
echo "## howmany=7" >> $buffer
|
|
echo "# howmany=$howmany" >> $buffer
|
|
echo >> $buffer
|
|
|
|
|
|
echo "## should update-grub create memtest86 boot option" >> $buffer
|
|
echo "## e.g. memtest86=true" >> $buffer
|
|
echo "## memtest86=false" >> $buffer
|
|
echo "# memtest86=$memtest86" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## should update-grub adjust the value of the default booted system" >> $buffer
|
|
echo "## can be true or false" >> $buffer
|
|
echo "# updatedefaultentry=$updatedefaultentry" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## should update-grub add savedefault to the default options" >> $buffer
|
|
echo "## can be true or false" >> $buffer
|
|
echo "# savedefault=$savedefault" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo "## ## End Default Options ##" >> $buffer
|
|
echo >> $buffer
|
|
|
|
echo -n "Searching for splash image ... " >&2
|
|
current_splash=`grep '^splashimage=' ${menu_file} || true`
|
|
grub_dir_rel=`make_system_path_relative_to_its_root $grub_dir`
|
|
splashimage_path="splashimage=${grub_root_device}/${grub_dir_rel##${kernel_dir}}/splash.xpm.gz"
|
|
if [ `sed -e "/^$start/,/^$end/d" $menu_file | grep -c '^splashimage='` != "0" ] ; then
|
|
#checks for splashscreen defined outside the autoupdated part
|
|
splashimage=$(grep '^splashimage=' ${menu_file})
|
|
echo "found: ${splashimage##*=}" >&2
|
|
echo >&2
|
|
elif [ -f "${grub_dir}/splash.xpm.gz" ] && [ "$current_splash" = "" ]; then
|
|
echo "found: /boot/grub/splash.xpm.gz" >&2
|
|
echo "$splashimage_path" >> $buffer
|
|
echo >> $buffer
|
|
elif [ -f "${grub_dir}/splash.xpm.gz" ] && [ "$current_splash" = "$splashimage_path" ]; then
|
|
echo "found: /boot/grub/splash.xpm.gz" >&2
|
|
echo "$splashimage_path" >> $buffer
|
|
echo >> $buffer
|
|
elif [ "$current_splash" != "" ] && [ "$current_splash" != "$splashimage_path" ]; then
|
|
echo "found but preserving previous setting: $(grep '^splashimage=' ${menu_file})" >&2
|
|
echo "$current_splash" >> $buffer
|
|
echo >> $buffer
|
|
else
|
|
echo "none found, skipping ..." >&2
|
|
fi
|
|
|
|
xen0Kernels=""
|
|
# First kernels with xen0 support.
|
|
for ver in `grep -l CONFIG_XEN=y /boot/config* | sed -e s%/boot/config-%%`; do
|
|
if ! grep -q CONFIG_XEN_PRIVILEGED_GUEST=y /boot/config-$ver ; then
|
|
continue
|
|
fi
|
|
# ver is a kernel version
|
|
kern="/boot/vmlinuz-$ver"
|
|
if [ -r $kern ] ; then
|
|
newerKernels=""
|
|
for i in $xen0Kernels ; do
|
|
res=$(CompareVersions "$kern" "$i")
|
|
if [ "$kern" != "" ] && [ "$res" -gt 0 ] ; then
|
|
newerKernels="$newerKernels $kern $i"
|
|
kern=""
|
|
else
|
|
newerKernels="$newerKernels $i"
|
|
fi
|
|
done
|
|
if [ "$kern" != "" ] ; then
|
|
newerKernels="$newerKernels $kern"
|
|
fi
|
|
xen0Kernels="$newerKernels"
|
|
fi
|
|
done
|
|
|
|
sortedKernels=""
|
|
for kern in $(/bin/ls -1vr /boot | grep -v "dpkg-*" | grep "^vmlinuz-") ; do
|
|
kern="/boot/$kern"
|
|
newerKernels=""
|
|
for i in $sortedKernels ; do
|
|
res=$(CompareVersions "$kern" "$i")
|
|
if [ "$kern" != "" ] && [ "$res" -gt 0 ] ; then
|
|
newerKernels="$newerKernels $kern $i"
|
|
kern=""
|
|
else
|
|
newerKernels="$newerKernels $i"
|
|
fi
|
|
done
|
|
if [ "$kern" != "" ] ; then
|
|
newerKernels="$newerKernels $kern"
|
|
fi
|
|
sortedKernels="$newerKernels"
|
|
done
|
|
|
|
if test -f "/boot/vmlinuz.old" ; then
|
|
sortedKernels="/boot/vmlinuz.old $sortedKernels"
|
|
fi
|
|
if test -f "/boot/vmlinuz" ; then
|
|
sortedKernels="/boot/vmlinuz $sortedKernels"
|
|
fi
|
|
|
|
hypervisors=""
|
|
for hyp in /boot/xen-*.gz; do
|
|
if [ ! -h "$hyp" ] && [ -f "$hyp" ]; then
|
|
hypervisors="$hypervisors `basename "$hyp"`"
|
|
fi
|
|
done
|
|
|
|
#Finding the value the default line
|
|
use_grub_set_default="false"
|
|
if test "$updatedefaultentry" = "true" ; then
|
|
defaultEntryNumber=$(sed -ne 's/^[[:blank:]]*default[[:blank:]]*\(.*\).*/\1/p' $menu)
|
|
|
|
if [ "$defaultEntryNumber" = "saved" ] ; then
|
|
defaultEntryNumber=$(sed 'q' "$grub_dir/default")
|
|
use_grub_set_default="true"
|
|
fi
|
|
|
|
if test -n "$defaultEntryNumber"; then
|
|
defaultEntryNumberPlusOne=$(expr $defaultEntryNumber \+ 1);
|
|
defaultEntry=$(grep "^[[:blank:]]*title" $menu | sed -ne "${defaultEntryNumberPlusOne}p" | sed -ne ";s/^[[:blank:]]*title[[:blank:]]*//p")
|
|
defaultEntry=$(echo $defaultEntry | sed -e "s/[[:blank:]]*$//") # don't trust trailing blanks
|
|
else
|
|
notChangeDefault="yes"
|
|
fi
|
|
else
|
|
notChangeDefault="yes"
|
|
fi
|
|
|
|
## heres where we start writing out the kernel entries
|
|
counter=0
|
|
|
|
case "$grub_root_device" in
|
|
[^A-Za-z0-9]*) grub_root_type='root' ;;
|
|
*) grub_root_type='uuid' ;;
|
|
esac
|
|
|
|
grub2name="${kernel_dir}/grub/core.img"
|
|
if [ "$LET_US_TRY_GRUB_2" = "true" ] \
|
|
&& test -f /boot/grub/core.img ; then
|
|
echo "Found GRUB 2: $grub2name" >&2
|
|
cat >> $buffer << EOF
|
|
title Chainload into GRUB 2
|
|
$grub_root_type $grub_root_device
|
|
kernel $grub2name
|
|
|
|
title `echo ───────────────────────────────────────────────────────────────────── | iconv -f utf-8 -t cp437`
|
|
root
|
|
|
|
title When you have verified GRUB 2 works, you can use this command to
|
|
root
|
|
|
|
title complete the upgrade: upgrade-from-grub-legacy
|
|
root
|
|
|
|
title `echo ───────────────────────────────────────────────────────────────────── | iconv -f utf-8 -t cp437`
|
|
root
|
|
|
|
EOF
|
|
fi
|
|
|
|
|
|
# Xen entries first.
|
|
for kern in $xen0Kernels ; do
|
|
if test ! x"$howmany" = x"all" ; then
|
|
if [ $counter -gt $howmany ] ; then
|
|
break
|
|
fi
|
|
fi
|
|
|
|
kernelName=$(basename $kern)
|
|
kernelVersion=$(echo $kernelName | sed -e 's/vmlinuz//')
|
|
|
|
initrdName=$(FindInitrdName "/boot" "$kernelVersion")
|
|
initrd=""
|
|
|
|
kernel=$kernel_dir/$kernelName
|
|
if [ -n "$initrdName" ] ; then
|
|
initrd=$kernel_dir/$initrdName
|
|
fi
|
|
|
|
kernelVersion=$(echo $kernelVersion | sed -e 's/^-//')
|
|
currentOpt=$(get_kernel_opt $kernelVersion)
|
|
|
|
hypervisorVersions=$(FindXenHypervisorVersions "$kernelVersion")
|
|
|
|
found=
|
|
for hypervisorVersion in $hypervisorVersions; do
|
|
hypervisor="$kernel_dir/xen-$hypervisorVersion.gz"
|
|
if [ -e "$hypervisor" ]; then
|
|
found=1
|
|
|
|
echo "Found Xen hypervisor $hypervisorVersion, kernel: $kernel" >&2
|
|
|
|
write_kernel_entry "$kernelVersion" '' '' "$grub_root_device" \
|
|
"$kernel" "$currentOpt $xenkopt" '' "$initrd" "$savedefault" '' \
|
|
Xen "$hypervisor" "$hypervisorVersion" "$xenhopt"
|
|
counter=$(($counter + 1))
|
|
fi
|
|
done
|
|
|
|
if [ -z $found ]; then
|
|
for hypervisor in $hypervisors; do
|
|
hypVersion=`basename "$hypervisor" .gz | sed s%xen-%%`
|
|
|
|
echo "Found Xen hypervisor $hypVersion, kernel: $kernel" >&2
|
|
|
|
write_kernel_entry "$kernelVersion" '' '' "$grub_root_device" \
|
|
"$kernel" "$currentOpt $xenkopt" '' "$initrd" "$savedefault" '' \
|
|
Xen "$kernel_dir/$hypervisor" "$hypVersion" "$xenhopt"
|
|
counter=$(($counter + 1))
|
|
done
|
|
fi
|
|
done
|
|
|
|
for kern in $sortedKernels ; do
|
|
counter=$(($counter + 1))
|
|
if test ! x"$howmany" = x"all" ; then
|
|
if [ $counter -gt $howmany ] ; then
|
|
break
|
|
fi
|
|
fi
|
|
kernelName=$(basename $kern)
|
|
kernelVersion=$(echo $kernelName | sed -e 's/vmlinuz//')
|
|
initrdName=$(FindInitrdName "/boot" "$kernelVersion")
|
|
initrd=""
|
|
|
|
kernel=$kernel_dir/$kernelName
|
|
if [ -n "$initrdName" ] ; then
|
|
initrd=$kernel_dir/$initrdName
|
|
fi
|
|
|
|
echo "Found kernel: $kernel" >&2
|
|
|
|
if [ "$kernelName" = "vmlinuz" ]; then
|
|
if [ -L "/boot/$kernelName" ]; then
|
|
kernelVersion=`readlink -f "/boot/$kernelName"`
|
|
kernelVersion=$(echo $kernelVersion | sed -e 's/.*vmlinuz-//')
|
|
kernelVersion="$kernelVersion Default"
|
|
else
|
|
kernelVersion="Default"
|
|
fi
|
|
fi
|
|
if [ "$kernelName" = "vmlinuz.old" ]; then
|
|
if [ -L "/boot/$kernelName" ]; then
|
|
kernelVersion=`readlink -f "/boot/$kernelName"`
|
|
kernelVersion=$(echo $kernelVersion | sed -e 's/.*vmlinuz-//')
|
|
kernelVersion="$kernelVersion Previous"
|
|
else
|
|
kernelVersion="Previous"
|
|
fi
|
|
fi
|
|
kernelVersion=$(echo $kernelVersion | sed -e 's/^-//')
|
|
|
|
currentOpt=$(get_kernel_opt $kernelVersion)
|
|
|
|
do_lockold=$lockold
|
|
# do not lockold for the first entry
|
|
[ $counter -eq 1 ] && do_lockold=false
|
|
|
|
write_kernel_entry "$kernelVersion" "" "" "$grub_root_device" "$kernel" \
|
|
"$currentOpt $defoptions" "" "$initrd" "$savedefault" "$do_lockold"
|
|
|
|
# insert the alternative boot options
|
|
if test ! x"$alternative" = x"false" ; then
|
|
# for each altoptions line do this stuff
|
|
sed -ne 's/# altoptions=\(.*\)/\1/p' $buffer | while read line; do
|
|
descr=$(echo $line | sed -ne 's/\(([^)]*)\)[[:space:]]\(.*\)/\1/p')
|
|
suffix=$(echo $line | sed -ne 's/\(([^)]*)\)[[:space:]]\(.*\)/\2/p')
|
|
|
|
test x"$lockalternative" = x"true" && do_lockold=false
|
|
write_kernel_entry "$kernelVersion" "$descr" "$lockalternative" \
|
|
"$grub_root_device" "$kernel" "$currentOpt" "$suffix" "$initrd" \
|
|
"$savedefault" "$do_lockold"
|
|
|
|
done
|
|
fi
|
|
done
|
|
|
|
memtest86names="memtest86 memtest86+"
|
|
|
|
if test ! x"$memtest86" = x"false" ; then
|
|
for name in $memtest86names ; do
|
|
if test -f "/boot/$name.bin" ; then
|
|
kernelVersion="$name"
|
|
kernel="$kernel_dir/$name.bin"
|
|
currentOpt=
|
|
initrd=
|
|
|
|
echo "Found kernel: $kernel" >&2
|
|
|
|
write_kernel_entry "$kernelVersion" "" "" "$grub_root_device" \
|
|
"$kernel" "$currentOpt" "" "$initrd" "false" ""
|
|
fi
|
|
done
|
|
fi
|
|
|
|
echo $end >> $buffer
|
|
|
|
echo -n "Updating $menu ... " >&2
|
|
# Insert the new options into the menu
|
|
if ! grep -q "^$start" $menu ; then
|
|
cat $buffer >> $menu
|
|
rm -f $buffer
|
|
else
|
|
umask 077
|
|
sed -e "/^$start/,/^$end/{
|
|
/^$start/r $buffer
|
|
d
|
|
}
|
|
" $menu > $menu.new
|
|
cat $menu.new > $menu
|
|
rm -f $buffer $menu.new
|
|
fi
|
|
|
|
# Function to update the default value
|
|
set_default_value() {
|
|
if [ "$use_grub_set_default" = "true" ] ; then
|
|
if [ -f /usr/lib/grub-legacy/grub-set-default ] ; then
|
|
/usr/lib/grub-legacy/grub-set-default $1
|
|
else
|
|
grub-set-default $1
|
|
fi
|
|
else
|
|
value="$1"
|
|
newmenu=$(tempfile)
|
|
sed -e "s/^[[:blank:]]*default[[:blank:]]*[[:digit:]]*\(.*\)/default ${value}\1/;b" $menu > $newmenu
|
|
cat $newmenu > $menu
|
|
rm -f $newmenu
|
|
unset newmenu
|
|
fi
|
|
}
|
|
|
|
#Updating the default number
|
|
if [ "$LET_US_TRY_GRUB_2" = "true" ] && test -f /boot/grub/core.img ; then
|
|
set_default_value "0"
|
|
elif test -z "$notChangeDefault"; then
|
|
newDefaultNumberPlusOne=$(grep "^[[:blank:]]*title[[:blank:]]*" $menu | grep -n "${defaultEntry}" | cut -f1 -d ":" | sed -ne "1p")
|
|
if test -z "$newDefaultNumberPlusOne"; then
|
|
echo "Previous default entry removed, resetting to 0">&2
|
|
set_default_value "0"
|
|
elif test -z "$defaultEntry"; then
|
|
echo "Value of default value matches no entry, resetting to 0" >&2
|
|
set_default_value "0"
|
|
else
|
|
if test "$newDefaultNumberPlusOne" = "1"; then
|
|
newDefaultNumber="0"
|
|
else
|
|
newDefaultNumber=$(expr $newDefaultNumberPlusOne - 1)
|
|
fi
|
|
echo "Updating the default booting kernel">&2
|
|
set_default_value "$newDefaultNumber"
|
|
fi
|
|
fi
|
|
|
|
echo "done" >&2
|
|
echo >&2
|