RAID Boot

Revision as of 09:40, 4 July 2007

diazepam online cheap tramadol wellbutrin online jazz ringtones rivotril online free mtv ringtones cheap lipitor cheap celexa ativan online nokia ringtones norco online free motorola ringtones cheap ultram ultram online online norco free mono ringtones cheap celexa didrex online free online pharmacy propecia online cheap phentermine viagra online cheap vicodin sildenafil lisinopril online sharp ringtones levitra online free funny ringtones hydrocodone valium free cool ringtones cheap clonazepam cyclobenzaprine online verizon ringtones buy hgh cheap ambien sony ringtones cialis online free cingular ringtones cheap cialis cheap prozac qwest ringtones didrex online punk ringtones free jazz ringtones free ringtones but ultracet flexeril online nokia ringtones ativan online viagra online midi ringtones sony ericsson ringtones real ringtones cheap adipex free funny ringtones free punk ringtones cheap tenuate meridia online kyocera ringtones free sprint ringtones meridia order tenuate clomid online cheap ambien sonyericsson ringtones clomid online music ringtones free ericsson ringtones levitra online free wwe ringtones free kyocera ringtones nexium online mp3 ringtones hgh online xanax online sagem ringtones cheap xenical alprazolam free music ringtones zanaflex online verizon ringtones nextel ringtones tracfone ringtones diethylpropion online albuterol online tramadol online free samsung ringtones mp3 ringtones wwe ringtones cheap soma sharp ringtones order lisinopril paxil online motorola ringtones free samsung ringtones vigrx sildenafil online paxil online zanaflex online cheap rivotril diethylpropion online free sprint ringtones polyphonic ringtones free sagem ringtones nexium online free cingular ringtones cheap cyclobenzaprine cheap pharmacy online free alltel ringtones free sonyericsson ringtones free sony ericsson ringtones diazepam online vicodin lipitor online vigrx online mtv ringtones soma online lorazepam online real ringtones cheap zyban buy albuterol free ericsson ringtones cheap lorazepam zoloft adipex buy wellbutrin free alltel ringtones cool ringtones nextel ringtones zoloft clonazepam online cheap valium fioricet online midi ringtones cheap xanax polyphonic ringtones hoodia online cheap lortab alprazolam online hydrocodone online cheap lortab cheap ultracet free ringtones free mono ringtones cheap carisoprodol sony ringtones order ortho tracfone ringtones cheap phentermine ortho online cheap xenical order prozac carisoprodol online propecia online but flexeril qwest ringtones fioricet online cheap hoodia zyban online Historically, when the kernel booted, it used a mechanism called 'autodetect' to identify partitions which are used in RAID arrays: it assumed that all partitions of type 0xfd are so used. It then attempted to automatically assemble and start these arrays.

This approach can cause problems in several situations (imagine moving part of an old array onto another machine before wiping and repurposing it: reboot and watch in horror as the piece of dead array gets assembled as part of the running RAID array, ruining it); kernel autodetect is correspondingly deprecated.

The recommended approach now is to use the initramfs system.

This system is documented in more detail than you're likely to care about in the file Documentation/filesystems/ramfs-rootfs-initramfs.txt in the kernel source tree, but in brief it allows you to store in the kernel image a nonswappable in-memory filesystem (the 'rootfs') which is uncompressed as the root filesystem as the kernel boots; the kernel runs /init and leaves it to find the root filesystem, chroot into it, and execute the real /sbin/init. It's sort of like the old initrd system, only your image never gets out of sync with the kernel, it's much easier to build the image (the kernel build system can put it together for you), the kernel can always find it, and there's no overcomplicated scheme for switching to the real root filesystem: you can just chroot.

This approach provides a great deal of flexibility: you can get your root filesystem from LVM layered over a RAID array stored on a dozen network block devices on machines in Gautemala, San Diego, and Tokyo if you really need to (although that particular combination might be a bit slow without careful use of 'write-mostly'). I've even heard that some people have a C compiler on there, and recompile third-party modules for the running kernel on the fly from the source code!

But this flexibility comes with a price, and getting the thing working in the first place is a bit tricky. If init isn't PID 1, you're in trouble; if you've left anything in the rootfs before chrooting, you've lost the memory it was in forever: if you mess up population you've got a useless kernel image; and populating it is sort of like working on an embedded system, because unless you want a 20Mb kernel image you'd better use small tools, like busybox, and preferably a small libc, like uClibc.

But it's useful if you want to mount RAID arrays before booting: e.g., examining the partitions and assembling arrays with a defined UUID, while leaving you with enough emergency repair facilities to figure out what's wrong if assembly fails.

mdadm comes with such a script, but choice is good, so here's another. It has a number of improvements over the mdadm variation:

• It handles LVM2 as well as md (obviously if you boot off RAID you still have to boot off RAID1, but /boot can be a RAID1 filesystem of its own now, with / in LVM, on RAID, or both at once; you don't even need md on the machine anymore)
• You can leave lvm or mdadm off the image if you don't need them, so you can use the same initramfs for many machines, only some of which use RAID or LVMed root filesystems
• It fscks / before mounting it
• If anything goes wrong, it drops you into an emergency shell in the rootfs, where you have all the power of ash with hardly any builtin commands, lvm and mdadm to diagnose your problem!
• it supports a number of arguments: 'rescue', to drop into /bin/ash instead of init after mounting the real root filesystem, 'emergency', to drop into a shell on the initramfs before doing anything, and 'trace', to turn on shell tracing early in the init script execution, so if something's failing with a bizarre error message, you can tell what it is. It also supports numeric arguments 1 to 5, `single' and `-b', which just get passed down to init.
• It supports root= and init= arguments, although for arcane reasons to do with LILO suckage you need to pass the root argument as `root=LABEL=/dev/some/device', or LILO will helpfully transform it into a device number, which is rarely useful if the device name is, say, /dev/emergency-volume-group/root. It gets the default volume group name from a file `vgname' which you have to arrange to put on the initramfs (sticking it in the usr/ subdirectory in the kernel tree will do). It also supports root-type= and root-options= arguments, so you can mount root with noatime or force filesystem detection should you need to.

The default VG name, root device name, mount options and filesystem type are all derived from the entry for / in /etc/fstab. This will generally do the right thing, unless your root filesystem isn't on LVM and you use a name like /dev/disk/by-label/root: the initramfs doesn't have udev on it and so won't understand such labels. You could fix this by passing the root= argument or by having a second fstab used just for the initramfs: both will work.

• It doesn't waste memory. initramfs isn't like initrd: if you just chroot into the new root filesystem, the data in the initramfs stays around, in nonswappable kernel memory. And it's not gzipped by that point, either!

The downsides:

• It needs busybox 1.2 or later, and a 2.6.12 kernel with sysfs and hotplug support; this is because it populates /dev with the `mdev' mini-udev tool inside busybox, and switches root filesystems with the `switch_root' tool, which chroots only after erasing the entire contents of the initramfs (taking great care not to recurse off that filesystem!)
• If you link against uClibc you'll need mdadm 2.5.2 or later: earlier versions will crash.
• if you link against uClibc (recommended), you need a CVS uClibc too (i.e., one newer than 0.9.27).
• It doesn't try to e.g. set up the network: changing the script to do that isn't likely to be terribly difficult.
• You need an /etc/mdadm.conf (if using md) and an /etc/lvm/lvm.conf, both taken by default from the system you built the kernel on: personally I'd recommend a really simple one with no device= lines, like

DEVICE partitions
ARRAY /dev/md0 UUID=some:long:uuid:here
ARRAY /dev/md1 UUID=another:long:uuid:here
ARRAY /dev/md2 UUID=yetanother:long:uuid:here
...

(I might change this to use --homehost in future, whereupon you'd only need to provide a file giving the hostname; but --homehost isn't widely-enough available yet, and I haven't tried it myself.)

Here's the init script:

#!/bin/ash
#
# init --- locate and mount root filesystem
#          By Nix <nix@esperi.org.uk>.
#
#          Placed in the public domain.
#

export PATH=/sbin:/bin

/bin/mount -t proc proc /proc
/bin/mount -t sysfs sysfs /sys
CMDLINE=`cat /proc/cmdline`

# Populate /dev from /sys

/bin/mount -t tmpfs tmpfs /dev
/sbin/mdev -s

# Locate the root filesystem's fstab entry; collapse spaces and tabs in it:
# extract its significant components. (There are three raw tabs in the next
# line, each next to a single space.)

FSENT=`sed -n '/[ 	]\/[ 	]/ { s,[ 	][ 	]*, ,g; p; }' < /etc/fstab`
ROOT="`echo $FSENT | tr ' ' '\n' | sed -n '1p'`"
TYPE="`echo $FSENT | tr ' ' '\n' | sed -n '3p'`"
OPTS="`echo $FSENT | tr ' ' '\n' | sed -n '4p'`"

# Parse arguments, engaging trace mode or dropping to rescue or emergency shells
# as needed. If there is a forced init program, root filesystem, root fs type or
# root fs options, accept the forcing.

INIT_ARGS=

for param in $CMDLINE; do
    case "$param" in
        init=*) eval "$param";;
	-b|single|s|S|[1-5]) INIT_ARGS="$INIT_ARGS $param";;
        trace) echo "Tracing init script.";
               set -x;;
        rescue) echo "Rescue boot mode: invoking ash.";
                init=/bin/ash;
                INIT_ARGS="-";;
        emergency) echo "Emergency boot mode. Dropping to a minimal shell.";
                   echo "Reboot with Ctrl-Alt-Delete.";
                   exec /bin/sh;;
        root=LABEL=*) ROOT=$(echo $1 | cut -d= -f3-);;
        root-type=*) TYPE=$(echo $1 | cut -d= -f2-);;
        root-options=*) OPTS=$(echo $1 | cut -d= -f2-);;
    esac
done

# Assemble the RAID arrays. We enable all that we can find, because we can't
# be sure which of them are needed to assemble the VG on which the root
# filesystem is located (if any). If you have RAID arrays which span devices
# which are not yet accessible, you'll probably want to add --no-degraded here,
# or build the initramfs with an mdadm.conf that does not mention the arrays
# you don't want assembled at this point.
#
# Perhaps we want to avoid starting degraded arrays no matter what, but I'd
# prefer my system to boot even if a drive fails.

if [ -x /sbin/mdadm ]; then
    /sbin/mdadm --assemble --scan --auto=md
fi

# If there are two slashes in the root filesystem location after the
# leading slash (e.g. /dev/raid/root), we assume that the middle
# component is the name of the volume group. Otherwise, we assume that
# no VG is involved.

VGNAME=
if [ "`echo $ROOT | sed 's,^/,,' | tr '/' '\n' | wc -l`" -eq 3 ]; then
    VGNAME="`echo $ROOT | sed 's,^/,,' | tr '/' '\n' | sed -n '2p'`"
fi

FAILED=

# Scan for volume groups. We activate only the group on which the
# root filesystem is stored; the other groups may span devices which
# are not yet accessible.

if [ -x /sbin/lvm -a -n $VGNAME ]; then
    /sbin/lvm vgscan --ignorelockingfailure --mknodes