#!/bin/sh # $Id: mkinitrd_command_generator.sh,v 1.45 2011/02/17 09:27:05 eha Exp eha $ # Copyright 2013 Patrick J. Volkerding, Sebeka, Minnesota, USA # Copyright 2008, 2009, 2010, 2011 Eric Hameleers, Eindhoven, Netherlands # Contact: # Copyright 2008, 2009 PiterPUNK, Sao Paulo, SP, Brazil # Contact: # All rights reserved. # # Permission to use, copy, modify, and distribute this software for # any purpose with or without fee is hereby granted, provided that # the above copyright notice and this permission notice appear in all # copies. # # THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED # WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. # IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT # OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF # SUCH DAMAGE. # ----------------------------------------------------------------------------- # # Create an initrd which fits the system. # Take into account the use of LVM/LUKS/RAID. # Find out about any hardware drivers the system may need in an initrd when # booting from a generic lightweight kernel. # # ----------------------------------------------------------------------------- # The script's revision number will be displayed in the help text: REV=$( echo "$Revision: 1.45 $" | cut -d' ' -f2 ) # Define some essential parameter values: USING_LVM="" USING_LUKS="" USING_RAID="" MLIST="" REALDEV="" # The device that contains the LUKS volume BASEDEV="" # Lowest level device (raw block device or RAID volume) FSTAB=${FSTAB:-"/etc/fstab"} # so we can test with alternate fstab files # These are needed by -c and -i options: SOURCE_TREE=${SOURCE_TREE:-"/boot/initrd-tree"} CLEAR_TREE=${CLEAR_TREE:-1} KEYMAP=${KEYMAP:-"us"} UDEV=${UDEV:-1} # ARM devices need more time: case "$( uname -m )" in arm*) WAIT_DEFAULT=4;; *) WAIT_DEFAULT=1;; esac WAIT=${WAIT:-$WAIT_DEFAULT} # A basic explanation of the commandline parameters: basic_usage() { cat <<-EOT *** $(basename $0) revision $REV *** Usage: $(basename $0) [ options ] [ kernel_filename ] Options: -a <"additional params"> Additional parameters to pass to mkinitrd. -c | --conf Show a suitable mkinitrd configuration file. -h | --help Show this help. -i | --interactive Navigate through menus instead of using commandline arguments. --longhelp Show more detailed information/examples. -k Use specific kernel version. -m <"additional mods"> Additional modules to pass to mkinitrd, separated by colons (:). -l | --lilo Only show lilo.conf section (requires a kernel_filename). -r | --run Only show 'mkinitrd' command. EOT } # More of a tutorial here: extended_usage() { cat <<-EOT This script is useful in situations where you require an initrd image to boot your computer. For instance, when booting a kernel that does not have support for your storage or root filesystem built in (such as the Slackware 'generic' kernels'). * When you run the script without parameters, it will examine your running system, your current kernel version and will output an example of a 'mkinitrd' commandline that you can use to generate an initrd image containing enough driver support to boot the computer. * You can make it more specific: when you add the filename of a kernel as parameter to the script, it will determine the kernel version from that kernel, and also give an example of the lines that you should add to your '/etc/lilo.conf' file. * If you want your initrd image to have a custom name instead of the default '/boot/initrd.gz' you can add it as another parameter to the script, as follows: $(basename $0) -a "-o /boot/custom.gz" The arguments to the '-a' parameter will be used as additional arguments to the 'mkinitrd' command. * If you need additional modules in the initrd image, apart from what the script determines, you can pass then to the script using the '-m' parameter as follows: $(basename $0) -m "uhci-hcd:usbhid:hid_generic" The above example adds support for USB keyboards to the initrd - you may need that if you have encrypted your root partition and need to enter a passphrase using a USB keyboard. * Instead of copying and pasting the script's output, you can create an initrd by directly executing the output, like in this example: EOT echo " \$($(basename $0) --run /boot/vmlinuz-generic-smp-2.6.35.11-smp)" cat <<-EOT That used the '-r' or '--run' switch to make the script only write the 'mkinitrd' commandline to the terminal. * When you want to add a section for a specific kernel to '/etc/lilo.conf' directly, use the '-l' or '--lilo' switch and use a command like in this example: EOT echo " $(basename $0) --lilo /boot/vmlinuz-generic-smp-2.6.35.11-smp >>/etc/lilo.conf" cat <<-EOT That command will result in the following lines being added to your '/etc/lilo.conf' file (example for my hardware): # Linux bootable partition config begins # initrd created with 'mkinitrd -c -k 2.6.35.11-smp -m ata_generic:pata_amd:mbcache:jbd:ext3 -f ext3 -r /dev/hda7' image = /boot/vmlinuz-generic-smp-2.6.35.11-smp initrd = /boot/initrd.gz root = /dev/hda7 label = 2.6.35.11-smp read-only # Linux bootable partition config ends The last two examples show how easy it is to configure your computer for the use of an initrd if you need one. The only thing left to do afterwards is running 'lilo'. EOT } # Find the device that holds the root partition: get_root_device() { if [ -e $FSTAB ]; then RD=$(cat $FSTAB |tr '\t' ' ' |grep -v '^ *#' |tr -s ' ' |grep ' / ' |cut -f1 -d' ') if [ "$(echo $RD | cut -f1 -d=)" = "LABEL" -o "$(echo $RD | cut -f1 -d=)" = "UUID" ]; then DKEY=$(echo $RD | cut -f1 -d=) # The value can be LABEL=foo or LABEL='foo' or LABEL="foo" DVAL=$(echo $RD | cut -f2 -d= | tr -d "'\042") RD=$(/sbin/blkid | grep -w $DKEY | grep -w $DVAL | cut -f1 -d:) fi else RD=$(grep -m1 "^/dev/.*[[:blank:]]/[[:blank:]]" /proc/mounts | cut -f1 -d' ') fi echo $RD } # Get the root fs information: get_rootfs_type() { if $(type blkid 1>/dev/null 2>&1) ; then blkid -s TYPE -o value $ROOTDEV elif $(type vol_id 1>/dev/null 2>&1) ; then vol_id $ROOTDEV | grep ID_FS_TYPE | cut -f2 -d= else # As a fallback, use: cat $FSTAB |tr '\t' ' ' |grep -v '^ *#' |tr -s ' ' |grep ' / ' |cut -f3 -d' ' fi } # Add the module(s) needed for the root filesystem: add_rootfs_module() { local FSMOD FSMOD=$(/sbin/modprobe --set-version $KVER --show-depends ${ROOTFS} 2>/dev/null | while read LINE; do echo $(basename $(echo $LINE | cut -d' ' -f2) .ko ) done) if [ -n "$FSMOD" ]; then [ -n "$MLIST" ] && echo "$MLIST:$(echo $FSMOD | tr ' ' ':')" \ || echo $FSMOD | tr ' ' ':' fi } # Determine the list of kernel modules needed to support the root device: determine_blockdev_drivers() { # Walk the /sys tree to find kernel modules that are # required for our storage devices. # Thanks to PiterPUNK for help with this code. local MLIST MLIST=$(for i in $(find /sys/block/*/ -name "device" -print0 | xargs -0 -i'{}' readlink -f '{}' | sort -u); do /sbin/udevadm info --query=all --path=$i --attribute-walk | \ sed -ne 's/^[[:blank:]]\+DRIVER[S]*=="\([^"]\+\)"$/\1/p' | \ xargs -I@ /sbin/modprobe --set-version $KVER --show-depends @ \ 2>/dev/null | grep -v "builtin " | \ while read LINE ; do echo $(basename $(echo $LINE | cut -d' ' -f2) .ko ) done done) MLIST=$( echo $MLIST | tr ' ' ':' ) echo $MLIST } # Search for USB keyboards: function add_usb_keyboard() { local USBMOD if cat /proc/bus/input/devices | sed -e 's/^$/\$/g' | \ tr "\n$" " \n" | grep -q " Phys=.*usb.* .*Handlers=.*kbd.*B:"; then USBMOD="xhci-pci:ohci-pci:ehci-pci:xhci-hcd:uhci-hcd:ehci-hcd:hid:usbhid:i2c-hid:hid_generic:hid-cherry:hid-logitech:hid-logitech-dj:hid-logitech-hidpp:hid-lenovo:hid-microsoft:hid_multitouch" [ -n "$MLIST" ] && MLIST="$MLIST:$USBMOD" \ || MLIST="$USBMOD" fi echo $MLIST } # Determine what USB Host Controller is in use function add_usb_hcd() { local USBMOD for i in $(ls -Ld /sys/module/*_hcd/drivers/* 2> /dev/null); do if ls -L $i | grep -q "[0-9a-f]*:" ; then USBMOD=$( echo $i | cut -f4 -d/ | tr "_" "-") [ -n "$MLIST" ] && MLIST="$MLIST:$USBMOD" \ || MLIST="$USBMOD" fi done echo $MLIST } # Is the root partition on a (combination of) LVM/LUKS volume? check_luks_lvm_raid() { if $( lvdisplay -c $ROOTDEV 1>/dev/null 2>/dev/null ); then # Our root partition is on a LV: USING_LVM=1 # Search the Physical Volume of our Logical Volume: MYVG=$( echo $(lvdisplay -c $ROOTDEV 2>/dev/null) | cut -d: -f2 ) for LINE in $(pvdisplay -c) ; do VG=$(echo $LINE | cut -d: -f2) [ "$VG" = "$MYVG" ] && break done PV=$(echo $LINE | cut -d: -f1) # Check if there is a LUKS device underneath: if $( cryptsetup status $PV 1>/dev/null 2>/dev/null ) ; then # Our root partition's LV is on a LUKS volume: USING_LUKS=1 REALDEV=$( cryptsetup status $PV | grep 'device: ' | tr -d ' ' | cut -d: -f2 ) BASEDEV=$REALDEV else BASEDEV=$PV fi elif $( cryptsetup status $ROOTDEV 1>/dev/null 2>/dev/null ) ; then # Our root device is on a LUKS volume: USING_LUKS=1 REALDEV=$( cryptsetup status $ROOTDEV | grep 'device: ' | tr -d ' ' | cut -d: -f2 ) ROOTDEV=$(basename $ROOTDEV) # Check for LVM: for LV in $(lvdisplay -c 2>/dev/null | tr -d ' ' | cut -f1 -d:) ; do # Note: cryptsetup shows the real device, whereas # lvdisplay requires the /dev//... symlink to the real device. if [ "$(readlink $LV)" = "$REALDEV" ]; then REALDEV=$LV break fi done if $( lvdisplay -c $REALDEV 1>/dev/null 2>/dev/null ); then # Our root partition's LUKS device is on a LV: USING_LVM=1 # Search the Physical Volume of our Logical Volume: MYVG=$( echo $(lvdisplay -c $REALDEV 2>/dev/null) | cut -d: -f2 ) for LINE in $(pvdisplay -c) ; do VG=$(echo $LINE | cut -d: -f2) [ "$VG" = "$MYVG" ] && break done PV=$(echo $LINE | cut -d: -f1) BASEDEV=$PV else BASEDEV=$REALDEV fi else BASEDEV=$ROOTDEV fi # Finally, we should check if base device is # a real block device or a RAID volume: for MD in $(cat /proc/mdstat | grep -w active | cut -d' ' -f1) ; do if [ "$BASEDEV" = "/dev/$MD" ]; then USING_RAID=1 break fi done } # Before we start [ -x /bin/id ] && CMD_ID="/bin/id" || CMD_ID="/usr/bin/id" if [ "$($CMD_ID -u)" != "0" ]; then echo "You need to be root to run $(basename $0)." exit 1 fi # Parse the commandline parameters: while [ ! -z "$1" ]; do case $1 in --longhelp) basic_usage extended_usage exit 0 ;; -a) MKINIT_PARAMS="$2" shift 2 ;; -c|--conf) [ -n "$EMIT" ] && { echo "Do not mix incompatible parameters!"; exit 1; } EMIT="conf" shift ;; -h|--help) basic_usage exit 0 ;; -i|--interactive) INTERACTIVE=1 shift ;; -k) KVER=$2 shift 2 ;; -m) MKINIT_MODS=$2 shift 2 ;; -l|--lilo) [ -n "$EMIT" ] && { echo "Do not mix incompatible parameters!"; exit 1; } EMIT="lilo" shift ;; -L|--fromlilo) FROMLILO=1 shift ;; -r|--run) [ -n "$EMIT" ] && { echo "Do not mix incompatible parameters!"; exit 1; } EMIT="run" shift ;; -R|--rootdev) ROOTDEV=$2 shift 2 ;; -*) echo "Unsupported parameter '$1'!" exit 1 ;; *) # Everything else but switches (which start with '-') follows: if [ -f $1 ]; then KFILE=$1 # Construction of KFILE's full filename: KFILEPATH=$(cd $(dirname $KFILE) && pwd) if [ -L $KFILE ]; then KFILE=$(readlink $KFILE) else KFILE=$(basename $KFILE) fi KFILE=${KFILEPATH}/$KFILE if [ -z "$(file $KFILE | grep -E 'Linux kernel x86 boot|x86 boot sector')" ]; then echo "File '$KFILE' does not look like it is a kernel file!" exit 1 fi else echo "File $1 not found!" exit 1 fi shift ;; esac done # Determine what to show as output (other options may have set EMIT already) EMIT=${EMIT:-"all"} # An EMIT value of 'lilo' requires a kernel filename as script parameter: if [ "$EMIT" = "lilo" ]; then if [ -z "$KFILE" ]; then echo "A kernel_filename is required with the '-l|--lilo' option!" exit 1 fi fi # Determine kernel version to use, # and check if modules for this kernel are actually present: if [ -z "$KVER" ]; then if [ -n "$KFILE" ]; then KVER="$(strings $KFILE | grep '([^ ]*@[^ ]*) #' | cut -f1 -d' ')" else KVER="$(uname -r)" fi fi if [ ! -d /lib/modules/$KVER ]; then echo "Modules for kernel $KVER aren't installed." exit 1 fi # Determine whether the user passed an alternate filename for the initrd: if [ -n "$MKINIT_PARAMS" ]; then SRCHLIST="$MKINIT_PARAMS" for ELEM in $MKINIT_PARAMS ; do SRCHLIST=$(echo $SRCHLIST | cut -d' ' -f2-) # cut ELEM from the list if [ "$ELEM" = "-o" ]; then IMGFILE=$(echo $SRCHLIST | cut -d' ' -f1) break fi done fi IMGFILE=${IMGFILE:-"/boot/initrd.gz"} # Get information about the root device / root filesystem: ROOTDEV=${ROOTDEV:-$(get_root_device)} ROOTFS=$(get_rootfs_type) # Determine the list of kernel modules needed to support the root device: MLIST=$(determine_blockdev_drivers) # Check if we are running in a kvm guest with virtio block device driver # (add all virtio modules, we sort out the doubles later): if echo $MLIST | grep -q "virtio"; then MLIST="$MLIST:virtio:virtio_balloon:virtio_blk:virtio_ring:virtio_pci:virtio_net" fi # Determine if a USB keyboard is in use and include usbhid and hid_generic # to module list MLIST=$(add_usb_keyboard) # If we use any USB module, try to determine the Host Controller if echo $MLIST | grep -q "usb"; then MLIST=$(add_usb_hcd) fi # Check what combination of LUKS/LVM/RAID we have to support: # This sets values for USING_LUKS, USING_LVM, USING_RAID, REALDEV and BASEDEV. check_luks_lvm_raid # This is the interactive part: if [ "$INTERACTIVE" = "1" ]; then if [ "$FROMLILO" != "1" ]; then dialog --stdout --title "WELCOME TO MKINITRD COMMAND GENERATOR" --msgbox "\ The main goal of this utility is to create a good initrd to \ fit your needs. It can detect what kernel you are running, \ what is your root device, root filesystem, if you use encryption, \ LVM, RAID, etc. \ \n\n\ Usually the probed values are OK and they will be the \ defaults in all subsequent dialogs, but maybe you want \ to change something. \n\ If in doubt, leave the defaults." 0 0 KVER=$( ls -d1 --indicator-style=none /lib/modules/* | \ awk -F/ -vVER=$KVER '{ if ( VER == $NF ) { ONOFF="on" } else { ONOFF="off" } ; printf("%s \"\" %s\n",$NF,ONOFF) }' | \ xargs dialog --stdout --title "CHOOSE KERNEL VERSION" \ --default-item $KVER --radiolist "\ Please, select the kernel version you want to create this initrd for." 0 0 4 ) [ -z "$KVER" ] && exit 1 OLDROOTDEV=$ROOTDEV ROOTDEV=$( dialog --stdout --title "SELECT ROOT DEVICE" --inputbox "\ Enter your root device. Root device is the one where your '/' filesystem \ is mounted." 0 0 "$ROOTDEV" ) [ -z "$ROOTDEV" ] && exit 1 # We need to re-check our defaults in case the user changed the default # value for ROOTDEV: [ "$OLDROOTDEV" != "$ROOTDEV" ] && check_luks_lvm_raid ROOTFS=$(get_rootfs_type) ROOTFS=$( dialog --stdout --title "SELECT ROOT FILESYSTEM" --inputbox "\ Enter the type of your root filesystem." 0 0 "$ROOTFS" ) [ -z "$ROOTFS" ] && exit 1 fi MLIST=$(add_rootfs_module) LLR=$( dialog --stdout --title "LVM/LUKS/RAID" --checklist "\ Do you use some of those in your root filesystem? \ If this is the case, please select one or more options." 12 45 3 \ "LVM" "Logical Volume Manager" $([ "$USING_LVM" = "1" ] && echo on || echo off) \ "LUKS" "Linux Unified Key Setup" $([ "$USING_LUKS" = "1" ] && echo on || echo off) \ "RAID" "Linux Software RAID" $([ "$USING_RAID" = "1" ] && echo on || echo off)) if [ "$?" != "0" ]; then exit 1 fi echo $LLR | grep -q LUKS && USING_LUKS="1" echo $LLR | grep -q LVM && USING_LVM="1" echo $LLR | grep -q RAID && USING_RAID="1" if [ "$USING_LUKS" = "1" ]; then REALDEV=$( dialog --stdout --title "LUKS ROOT DEVICE" --inputbox "\ Please, enter your LUKS root device:" 0 0 "$REALDEV" ) [ -z "$REALDEV" ] && exit 1 fi fi # Step out of the interactive loop for a moment. The next block needs to be # executed in all cases. # We need to 'undouble' the MLIST array. Some people report that walking the # /sys tree produces duplicate modules in the list. # The awk command elimitates doubles without changing the order: MLIST=$( echo $MLIST | tr ':' '\n' | awk '!x[$0]++' | tr '\n' ' ' ) MLIST=$( echo $MLIST | tr ' ' ':' ) MLIST=$(echo ${MLIST%:}) # To weed out a trailing ':' which was reported once. # Back to the interactive part: if [ "$INTERACTIVE" = "1" ]; then MLIST=$( dialog --stdout --title "INITRD'S MODULE LIST" --inputbox "\ The list here shows all modules needed to support your root filesystem \ and boot from it. But you can change the list to use some alternative \ or additional modules. If you don't know what to do, the default is safe." \ 0 0 "$MLIST" ) if [ "$?" != "0" ]; then exit 1 fi EXTRA=$( dialog --stdout --title "EXTRA CONFIGURATION" --checklist "\ Now is your chance for some additional configuration. All of these \ configurations are optional and you can stick to the defaults." 11 72 3 \ "KEYMAP" "Select keyboard layout (default: US)" \ $([ $USING_LUKS = 1 ] && echo on || echo off) \ "RESUMEDEV" "Select device for 'suspend-to-disk' feature" off \ "UDEV" "Use UDEV in the initrd for device configuration" $(test $UDEV -eq 1 && echo on || echo off) \ "WAIT" "Add delay to allow detection of slow disks at boot" $(test $WAIT -gt $WAIT_DEFAULT && echo on || echo off) ) if [ "$?" != "0" ]; then exit 1 fi if echo $EXTRA | grep -q KEYMAP ; then KEYMAP=$( dialog --stdout --title "KEYBOARD LAYOUT SELECTION" \ --cancel-label "Skip" \ --menu "You may select one of the following keyboard layouts. \ If you do not select a keyboard map, 'us.map' \ (the US keyboard layout) is the default. Use the UP/DOWN \ arrow keys and PageUp/PageDown to scroll \ through the whole list of choices." \ 22 55 11 \ "qwerty/us.map" "" \ "azerty/azerty.map" "" \ "azerty/be-latin1.map" "" \ "azerty/fr-latin0.map" "" \ "azerty/fr-latin1.map" "" \ "azerty/fr-latin9.map" "" \ "azerty/fr-old.map" "" \ "azerty/fr-pc.map" "" \ "azerty/fr.map" "" \ "azerty/wangbe.map" "" \ "azerty/wangbe2.map" "" \ "dvorak/ANSI-dvorak.map" "" \ "dvorak/dvorak-l.map" "" \ "dvorak/dvorak-r.map" "" \ "dvorak/dvorak.map" "" \ "dvorak/no-dvorak.map" "" \ "fgGIod/tr_f-latin5.map" "" \ "fgGIod/trf-fgGIod.map" "" \ "olpc/es-olpc.map" "" \ "olpc/pt-olpc.map" "" \ "qwerty/bg-cp1251.map" "" \ "qwerty/bg-cp855.map" "" \ "qwerty/bg_bds-cp1251.map" "" \ "qwerty/bg_bds-utf8.map" "" \ "qwerty/bg_pho-cp1251.map" "" \ "qwerty/bg_pho-utf8.map" "" \ "qwerty/br-abnt.map" "" \ "qwerty/br-abnt2.map" "" \ "qwerty/br-latin1-abnt2.map" "" \ "qwerty/br-latin1-us.map" "" \ "qwerty/by-cp1251.map" "" \ "qwerty/by.map" "" \ "qwerty/bywin-cp1251.map" "" \ "qwerty/cf.map" "" \ "qwerty/cz-cp1250.map" "" \ "qwerty/cz-lat2-prog.map" "" \ "qwerty/cz-lat2.map" "" \ "qwerty/cz-qwerty.map" "" \ "qwerty/defkeymap.map" "" \ "qwerty/defkeymap_V1.0.map" "" \ "qwerty/dk-latin1.map" "" \ "qwerty/dk.map" "" \ "qwerty/emacs.map" "" \ "qwerty/emacs2.map" "" \ "qwerty/es-cp850.map" "" \ "qwerty/es.map" "" \ "qwerty/et-nodeadkeys.map" "" \ "qwerty/et.map" "" \ "qwerty/fi-latin1.map" "" \ "qwerty/fi-latin9.map" "" \ "qwerty/fi-old.map" "" \ "qwerty/fi.map" "" \ "qwerty/gr-pc.map" "" \ "qwerty/gr.map" "" \ "qwerty/hu101.map" "" \ "qwerty/il-heb.map" "" \ "qwerty/il-phonetic.map" "" \ "qwerty/il.map" "" \ "qwerty/is-latin1-us.map" "" \ "qwerty/is-latin1.map" "" \ "qwerty/it-ibm.map" "" \ "qwerty/it.map" "" \ "qwerty/it2.map" "" \ "qwerty/jp106.map" "" \ "qwerty/kazakh.map" "" \ "qwerty/kyrgyz.map" "" \ "qwerty/la-latin1.map" "" \ "qwerty/lt.baltic.map" "" \ "qwerty/lt.l4.map" "" \ "qwerty/lt.map" "" \ "qwerty/mk-cp1251.map" "" \ "qwerty/mk-utf.map" "" \ "qwerty/mk.map" "" \ "qwerty/mk0.map" "" \ "qwerty/nl.map" "" \ "qwerty/nl2.map" "" \ "qwerty/no-latin1.map" "" \ "qwerty/no.map" "" \ "qwerty/pc110.map" "" \ "qwerty/pl.map" "" \ "qwerty/pl1.map" "" \ "qwerty/pl2.map" "" \ "qwerty/pl3.map" "" \ "qwerty/pl4.map" "" \ "qwerty/pt-latin1.map" "" \ "qwerty/pt-latin9.map" "" \ "qwerty/pt.map" "" \ "qwerty/ro.map" "" \ "qwerty/ro_std.map" "" \ "qwerty/ru-cp1251.map" "" \ "qwerty/ru-ms.map" "" \ "qwerty/ru-yawerty.map" "" \ "qwerty/ru.map" "" \ "qwerty/ru1.map" "" \ "qwerty/ru2.map" "" \ "qwerty/ru3.map" "" \ "qwerty/ru4.map" "" \ "qwerty/ru_win.map" "" \ "qwerty/ruwin_alt-CP1251.map" "" \ "qwerty/ruwin_alt-KOI8-R.map" "" \ "qwerty/ruwin_alt-UTF-8.map" "" \ "qwerty/ruwin_cplk-CP1251.map" "" \ "qwerty/ruwin_cplk-KOI8-R.map" "" \ "qwerty/ruwin_cplk-UTF-8.map" "" \ "qwerty/ruwin_ct_sh-CP1251.map" "" \ "qwerty/ruwin_ct_sh-KOI8-R.map" "" \ "qwerty/ruwin_ct_sh-UTF-8.map" "" \ "qwerty/ruwin_ctrl-CP1251.map" "" \ "qwerty/ruwin_ctrl-KOI8-R.map" "" \ "qwerty/ruwin_ctrl-UTF-8.map" "" \ "qwerty/se-fi-ir209.map" "" \ "qwerty/se-fi-lat6.map" "" \ "qwerty/se-ir209.map" "" \ "qwerty/se-lat6.map" "" \ "qwerty/se-latin1.map" "" \ "qwerty/sk-prog-qwerty.map" "" \ "qwerty/sk-qwerty.map" "" \ "qwerty/speakup-jfw.map" "" \ "qwerty/speakupmap.map" "" \ "qwerty/sr-cy.map" "" \ "qwerty/sv-latin1.map" "" \ "qwerty/tr_q-latin5.map" "" \ "qwerty/tralt.map" "" \ "qwerty/trf.map" "" \ "qwerty/trq.map" "" \ "qwerty/ttwin_alt-UTF-8.map.gz" "" \ "qwerty/ttwin_cplk-UTF-8.map.gz" "" \ "qwerty/ttwin_ct_sh-UTF-8.map.gz" "" \ "qwerty/ttwin_ctrl-UTF-8.map.gz" "" \ "qwerty/ua-cp1251.map.gz" "" \ "qwerty/ua-utf-ws.map" "" \ "qwerty/ua-utf.map" "" \ "qwerty/ua-ws.map" "" \ "qwerty/ua.map" "" \ "qwerty/uk.map" "" \ "qwerty/us-acentos.map" "" \ "qwerty/us.map" "" \ "qwertz/croat.map" "" \ "qwertz/cz-us-qwertz.map" "" \ "qwertz/cz.map" "" \ "qwertz/de-latin1-nodeadkeys.map" "" \ "qwertz/de-latin1.map" "" \ "qwertz/de.map" "" \ "qwertz/de_CH-latin1.map" "" \ "qwertz/fr_CH-latin1.map" "" \ "qwertz/fr_CH.map" "" \ "qwertz/hu.map" "" \ "qwertz/sg-latin1-lk450.map" "" \ "qwertz/sg-latin1.map" "" \ "qwertz/sg.map" "" \ "qwertz/sk-prog-qwertz.map" "" \ "qwertz/sk-qwertz.map" "" \ "qwertz/slovene.map" "" ) [ -n "$KEYMAP" ] && KEYMAP=$(basename $KEYMAP .map) fi if echo $EXTRA | grep -q UDEV ; then UDEV=1 fi if echo $EXTRA | grep -q RESUMEDEV ; then # Print information about swap partitions: FREERAM=$(free -k | grep "^Mem:" | tr -s ' ' | cut -d' ' -f2) SWPINFO="" for SWPDEV in $(grep -w swap $FSTAB | cut -d' ' -f1) ; do SWPINFO="$SWPINFO $SWPDEV Linux swap partition $(fdisk -s $SWPDEV) KB \\n" [ $(fdisk -s $SWPDEV) -gt $FREERAM ] && RESUMEDEV=$SWPDEV done FREERAM=$(free -m | grep "^Mem:" | tr -s ' ' | cut -d' ' -f2) RESUMEDEV=$( dialog --stdout --no-collapse --title "HIBERNATE RESUME DEVICE" --inputbox "\ When using suspend-to-disk feature (hibernate), your computer's RAM is copied \ to a swap device when it shuts down. The kernel will resume from that RAM \ image at boot. This means that the swap partition must not be smaller than \ the amount of RAM you have ($FREERAM MB). \n\ $SWPINFO \n\ Please specify a swap partition to be used for hibernation:" \ 0 0 "$RESUMEDEV") [ -z "$RESUMEDEV" ] && exit 1 fi if echo $EXTRA | grep -q WAIT ; then WAIT=$( dialog --stdout --title "WAIT FOR ROOT DEVICE" --inputbox "\ Some block devices are too slow to be detected properly at boot. USB storage \ devices and some disk arrays have this 'feature'. To make your machine \ boot properly, you can add some delay here, to wait until all your disks are \ probed and detected. The time is in seconds:" 0 0 "$WAIT") [ -z "$WAIT" ] && exit 1 fi IMGFILE=$( dialog --stdout --title "INITRD IMAGE NAME" --inputbox "\ Enter your initrd image filename." 0 0 "$IMGFILE" ) [ -z "$IMGFILE" ] && exit 1 else MLIST=$(add_rootfs_module) fi # Add any modules passed along on the commandline: if [ -n "$MKINIT_MODS" ]; then [ -n "$MLIST" ] && MLIST="$MLIST:$(echo $MKINIT_MODS | tr ' ' ':')" \ || MLIST="$(echo $MKINIT_MODS | tr ' ' ':')" fi # Constructing the mkinitrd command: MKINIT="mkinitrd -c -k $KVER -f $ROOTFS -r $ROOTDEV" # If we have a module list, add them: if ! [ -z "$MLIST" -o "$MLIST" = ":" ]; then MKINIT="$MKINIT -m $MLIST" fi # Deal with LUKS/LVM/RAID: if [ "$USING_LUKS" = "1" ]; then MKINIT="$MKINIT -C $REALDEV" fi if [ "$USING_LVM" = "1" ]; then MKINIT="$MKINIT -L" fi if [ "$USING_RAID" = "1" ]; then MKINIT="$MKINIT -R" fi if [ -n "$RESUMEDEV" ]; then # Add hibernation partition: MKINIT="$MKINIT -h $RESUMEDEV" fi if [ -n "$KEYMAP" -a "$KEYMAP" != "us" ]; then # Add non-us keyboard mapping: MKINIT="$MKINIT -l $KEYMAP" fi if [ $UDEV -eq 1 ]; then # Add UDEV support: MKINIT="$MKINIT -u" fi if [ -n "$WAIT" -a $WAIT -ne $WAIT_DEFAULT ]; then # Add non-default wait time: MKINIT="$MKINIT -w $WAIT" fi if ! echo "$MKINIT_PARAMS" | grep -q -- '-o ' ; then # Add default output filename: MKINIT="$MKINIT -o $IMGFILE" fi if [ -n "$MKINIT_PARAMS" ]; then # Add user-supplied additional parameters: MKINIT="$MKINIT $MKINIT_PARAMS" fi # Notify the user: if [ "$EMIT" = "all" ]; then cat <<-EOT # # $(basename $0) revision $REV # # This script will now make a recommendation about the command to use # in case you require an initrd image to boot a kernel that does not # have support for your storage or root filesystem built in # (such as the Slackware 'generic' kernels'). # A suitable 'mkinitrd' command will be: $MKINIT EOT elif [ "$EMIT" = "run" ]; then echo "$MKINIT" elif [ "$EMIT" = "conf" ]; then cat <<-EOT SOURCE_TREE="$SOURCE_TREE" CLEAR_TREE="$CLEAR_TREE" OUTPUT_IMAGE="$IMGFILE" KERNEL_VERSION="$KVER" KEYMAP="$KEYMAP" MODULE_LIST="$(echo $MLIST | cut -f2 -d\ )" LUKSDEV="$REALDEV" ROOTDEV="$ROOTDEV" ROOTFS="$ROOTFS" RESUMEDEV="$RESUMEDEV" RAID="$USING_RAID" LVM="$USING_LVM" UDEV="$UDEV" WAIT="$WAIT" EOT fi if [ -n "$KFILE" ]; then if [ "$EMIT" = "all" ]; then cat <<-EOT # An entry in 'etc/lilo.conf' for kernel '$KFILE' would look like this: EOT fi if [ "$EMIT" = "all" -o "$EMIT" = "lilo" ]; then # Compensate for the syntax used for the LUKS-on-LVM case: [ "$(basename $ROOTDEV)" = "$ROOTDEV" ] && BASE="/dev/mapper/" || BASE="" cat <<-EOT # Linux bootable partition config begins # initrd created with '$MKINIT' image = $KFILE initrd = $IMGFILE root = $BASE$ROOTDEV label = $KVER read-only # Linux bootable partition config ends EOT fi fi