Ertuğrul Erata
203 lines
6.2 KiB
Bash
203 lines
6.2 KiB
Bash
#!/bin/bash
|
|
#
|
|
# Stefan Seyfried, SUSE Linux Products GmbH 2006, GPL v2
|
|
# mostly taken from the powersave project.
|
|
|
|
GRUBONCE="/usr/sbin/grubonce"
|
|
GRUBDEFAULT="/boot/grub/default"
|
|
GRUBDEFSAVE="/run/suspend.grubonce.default"
|
|
|
|
#####################################################################
|
|
# gets a list of available kernels from /boot/grub/menu.lst
|
|
# kernels are in the array $KERNELS, output to stdout to be eval-ed.
|
|
getkernels()
|
|
{
|
|
# DEBUG "Running getkernels()" INFO
|
|
local MENU_LST="/boot/grub/menu.lst"
|
|
local I DUMMY MNT ROOTDEV
|
|
declare -i I=0 J=-1
|
|
|
|
# we need the root partition later to decide if this is the kernel to select
|
|
while read ROOTDEV MNT DUMMY; do
|
|
[ "$ROOTDEV" = "rootfs" ] && continue # not what we are searching for
|
|
if [ "$MNT" = "/" ]; then
|
|
break
|
|
fi
|
|
done < /proc/mounts
|
|
|
|
# build an array KERNELS with all the kernels in /boot/grub/menu.lst
|
|
# the array MENU_ENTRIES contains the corresponding menu entry numbers
|
|
# DEFAULT_BOOT contains the default entry.
|
|
while read LINE; do
|
|
case $LINE in
|
|
title*)
|
|
let J++ # increase for every menu entry, even for non-linux
|
|
# DEBUG "Found grub menu entry #${J}: '${LINE}'" INFO
|
|
;;
|
|
default*)
|
|
DUMMY=($LINE) # "default 0 #maybe a comment"
|
|
echo "DEFAULT_BOOT=${DUMMY[1]}" # ^^[0]^^ 1 ^^[2]^ 3 ^^[4]^^
|
|
# DEBUG "Default boot entry is '${DUMMY[1]}'" INFO
|
|
;;
|
|
kernel*noresume*)
|
|
# we probably found the "failsafe" kernel that won't resume...
|
|
echo " Skipping grub entry #${J}, because it has the noresume option" >&2
|
|
;;
|
|
kernel*root=*)
|
|
local ROOT
|
|
ROOT=${LINE#*root=}
|
|
DUMMY=($ROOT)
|
|
ROOT=${DUMMY[0]}
|
|
if [ "$(echo $ROOT | grep LABEL)" ]; then
|
|
LABEL=`echo $ROOT | cut -d"=" -f2`
|
|
ROOT=`readlink -f /dev/disk/by-label/$LABEL`
|
|
elif [ "$(echo $ROOT | grep UUID)" ]; then
|
|
UUID=`echo $ROOT | cut -d"=" -f2`
|
|
ROOT=`readlink -f /dev/disk/by-uuid/$UUID`
|
|
fi
|
|
if [ "$(stat -Lc '%t:%T' $ROOT)" != "$(stat -Lc '%t:%T' $ROOTDEV)" ]; then
|
|
echo " Skipping grub entry #${J}, because its root= parameter ($ROOT)" >&2
|
|
echo " does not match the current root device ($ROOTDEV)." >&2
|
|
continue
|
|
fi
|
|
DUMMY=($LINE) # kernel (hd0,1)/boot/latestkernel-ABC root=/dev/hda2
|
|
echo "KERNELS[$I]='${DUMMY[1]##*/}'" # latestkernel-ABC
|
|
echo "MENU_ENTRIES[$I]=$J"
|
|
# DEBUG "Found kernel entry #${I}: '${DUMMY[1]##*/}'" INFO
|
|
let I++
|
|
;;
|
|
kernel*)
|
|
# a kernel without "root="? We better skip that one...
|
|
echo " Skipping grub entry #${J}, because it has no root= option" >&2
|
|
;;
|
|
*) ;;
|
|
esac
|
|
done < $MENU_LST
|
|
}
|
|
|
|
#############################################################
|
|
# runs grubonce from the grub package to select which kernel
|
|
# to boot on next startup
|
|
grub-once()
|
|
{
|
|
if [ -x "$GRUBONCE" ]; then
|
|
rm -f "$GRUBDEFSAVE"
|
|
if [ -e "$GRUBDEFAULT" ]; then
|
|
echo " saving original $GRUBDEFAULT"
|
|
cp "$GRUBDEFAULT" "$GRUBDEFSAVE"
|
|
fi
|
|
echo " running '$GRUBONCE $1'"
|
|
$GRUBONCE $1
|
|
else
|
|
echo "WARNING: $GRUBONCE not found, not preparing bootloader"
|
|
fi
|
|
}
|
|
|
|
#############################################################
|
|
# restore grub default after (eventually failed) resume
|
|
grub-once-restore()
|
|
{
|
|
echo "INFO: running grub-once-restore"
|
|
rm -f "$GRUBDEFAULT"
|
|
if [ -e "$GRUBDEFSAVE" ]; then
|
|
echo " restoring original $GRUBDEFAULT"
|
|
mv "$GRUBDEFSAVE" "$GRUBDEFAULT"
|
|
fi
|
|
}
|
|
|
|
#############################################################################
|
|
# try to find a kernel image that matches the actually running kernel.
|
|
# We need this, if more than one kernel is installed. This works reasonably
|
|
# well with grub, if all kernels are named "kernel-`uname -r`" and are
|
|
# located in /boot. If they are not, good luck ;-)
|
|
find-kernel-entry()
|
|
{
|
|
NEXT_BOOT=-1
|
|
ARCH=`uname -m`
|
|
declare -i I=0
|
|
# DEBUG "running kernel: $RUNNING" DIAG
|
|
while [ -n "${KERNELS[$I]}" ]; do
|
|
BOOTING="${KERNELS[$I]}"
|
|
if IMAGE=`readlink /boot/$BOOTING` && [ -e "/boot/${IMAGE##*/}" ]; then
|
|
# DEBUG "Found kernel symlink $BOOTING => $IMAGE" INFO
|
|
BOOTING=$IMAGE
|
|
fi
|
|
case $ARCH in
|
|
ppc*) BOOTING="${BOOTING#*vmlinux-}" ;;
|
|
*) BOOTING="${BOOTING#*kernel-}" ;;
|
|
esac
|
|
if [ "$RUNNING" == "$BOOTING" ]; then
|
|
NEXT_BOOT=${MENU_ENTRIES[$I]}
|
|
echo " running kernel is grub menu entry $NEXT_BOOT (${KERNELS[$I]})"
|
|
break
|
|
fi
|
|
let I++
|
|
done
|
|
# if we have not found a kernel, issue a warning.
|
|
# if we have found a kernel, we'll do "grub-once" later, after
|
|
# prepare_suspend finished.
|
|
if [ $NEXT_BOOT -eq -1 ]; then
|
|
echo "WARNING: no kernelfile matching the running kernel found"
|
|
fi
|
|
}
|
|
|
|
#############################################################################
|
|
# if we did not find a kernel (or BOOT_LOADER is not GRUB) check,
|
|
# if the running kernel is still the one that will (probably) be booted for
|
|
# resume (default entry in menu.lst or, if there is none, the kernel file
|
|
# /boot/latestkernel points to.)
|
|
# This will only work, if you use "original" SUSE kernels.
|
|
# you can always override with the config variable set to "yes"
|
|
prepare-grub()
|
|
{
|
|
echo "INFO: running prepare-grub"
|
|
eval `getkernels`
|
|
RUNNING=`uname -r`
|
|
find-kernel-entry
|
|
|
|
RET=0
|
|
|
|
if [ $NEXT_BOOT -eq -1 ]; then
|
|
# which kernel is booted with the default entry?
|
|
BOOTING="${KERNELS[$DEFAULT_BOOT]}"
|
|
# if there is no default entry (no menu.lst?) we fall back to
|
|
# the default of /boot/latestkernel.
|
|
[ -z "$BOOTING" ] && BOOTING="latestkernel"
|
|
if IMAGE=`readlink /boot/$BOOTING` && [ -e "/boot/${IMAGE##*/}" ]; then
|
|
BOOTING=$IMAGE
|
|
fi
|
|
BOOTING="${BOOTING#*kernel-}"
|
|
echo "running kernel: '$RUNNING', probably booting kernel: '$BOOTING'"
|
|
if [ "$BOOTING" != "$RUNNING" ]; then
|
|
echo "ERROR: kernel version mismatch, cannot suspend to disk"
|
|
echo "running: $RUNNING booting: $BOOTING" >> $INHIBIT
|
|
RET=1
|
|
fi
|
|
else
|
|
# set the bootloader to the running kernel
|
|
echo " preparing boot-loader: selecting entry $NEXT_BOOT, kernel /boot/$BOOTING"
|
|
T1=`date +"%s%N"`
|
|
sync; sync; sync # this is needed to speed up grub-once on reiserfs
|
|
T2=`date +"%s%N"`
|
|
echo " grub-once: `grub-once $NEXT_BOOT`"
|
|
T3=`date +"%s%N"`
|
|
S=$(((T2-T1)/100000000)); S="$((S/10)).${S:0-1}"
|
|
G=$(((T3-T2)/100000000)); G="$((G/10)).${G:0-1}"
|
|
echo " time needed for sync: $S seconds, time needed for grub: $G seconds."
|
|
fi
|
|
|
|
return $RET
|
|
}
|
|
|
|
|
|
###### main()
|
|
|
|
case $1 in
|
|
hibernate)
|
|
prepare-grub
|
|
;;
|
|
thaw)
|
|
grub-once-restore
|
|
;;
|
|
esac
|