FakeRaidHowto

Revision 29 as of 2006-02-01 07:57:37

Clear message

How to configure Ubuntu to access a hardware fakeRAID

This page is a work in progress. I have spent the last week getting Ubuntu Breezy preview installed on my Via SATA fakeRAID and finally have the system dual booting WinXP and Ubuntu Linux on a RAID-0 ( stripe ) between two 36 gig 10,000rpm WD Raptor hard drives. I thought I would create a howto to describe how I did it so that others may benefit from my work.

What is it?

In the last year or two a number of hardware products have come on the market claiming to be IDE or SATA RAID controllers. Virtually all of them are not really hardware RAID controllers. Instead they are simply a multi-channel disk controller that has special BIOS and drivers for the OS to perform the software RAID functions. This has the effect of giving the appearence of a hardware RAID, because the RAID configuration is set up using a BIOS setup screen and the system can be booted from the RAID.

Under Windows, you must supply a driver floppy to the setup process so Windows can access the RAID. Under Linux, the hardware is seen for what it is, which is simply a multi-channel IDE/SATA controller. What this means is that if you have multiple disks configured as a RAID, Linux sees individual disks. This page describes how to get Linux to see the RAID as one disk, and boot from it. In my case, I use a RAID-0 configuration, but this should also apply to RAID-1 and RAID-5.

Background

In recent years there has been a trend to try and pull a bunch of code out of the kernel and into EarlyUserSpace. This includes stuff like nfsroot configuration, md software RAID, lvm, conventional partition/disklabel support, and so on. Early user space is set up in the form of an initramfs which the boot loader loads with the kernel, and this contains user mode utilities to detect and configure the hardware, mount the correct root device, and boot the rest of the system.

Hardware fakeRAID falls into this category of operation. A device driver in the kernel called device mapper is configured by user mode utilities to access software RAIDs and partitions. If you want to be able to use a fakeRAID for your root filesystem, your initramfs must be configured to detect the fakeRAID and configure the kernel mapper to access it.

The How To

The key areas of work that needs done are:

  1. Installing Ubuntu
  2. Installing lilo or grub
  3. Configuring the initramfs to boot the system

Installing Ubuntu

Install dmraid

The standard setup and LiveCDs do not yet contain support for fakeRAID. I used the LiveCD to boot up, and used the package manager to download the dmraid package from the universe repository. You will need to enable packages from Universe in the settings of Synaptic to see the package. If you are using the DVD you may also need to get the gparted package, which you will need for partitioning your RAID.

Partition the raid system

You can use gparted to create and delete partitions as you see fit, but at this time, it can not refresh the partition table after it modifies it, so you will need to change the partitions, then manually run dmraid -ay from the command prompt to detect the new partitions, and then refresh gparted before you can format the partition.

I needed to resize my existing NTFS partition to make space for Ubuntu. (If you don't need to do this, skip to the next paragraph.) Gparted currently can not do this on the mapper device so I had to use the ntfsresize program from the command line. Note that ntfsresize only resizes the filesystem, not the partition, so you have to do that manually. Use ntfsresize to shrink the filesystem, note the new size of the filesystem in sectors, then fire up fdisk. Switch fdisk to sector mode with the 'u' command. Use the 'p' command to print the current partition table. Delete the partition that you just resized and recreate it with the same starting sector. Use the new size of the filesystem in sectors to compute the ending sector of the partition. Don't forget to set the partition type to the value it was before. Now you should be able to create a new partition with the free space.

Start gparted and create the partitions you want for your setup. To begin, use the selector on the upper right to choose the device dmraid has created for your fakeRAID. In my case, this was /dev/mapper/via_hfciifae, with an additional device /dev/mapper/via_hfciifae1 assigned to my already-created NTFS partion. DMRAID will attempt to assign a meaningful name reflecting the controller you are using (e.g., and nvRAID user may see /dev/mapper/nvidia_bggfdgec or the like).

After selecting the unused space, I created an extended partition with 3 logical partitions inside. I made a 50 meg partition for /boot, a 1 gig partition for swap, and the rest for the root. Once you have set up the partitions you want, apply the changes and exit gparted. If you apply changes more than once (e.g., do this in more than one step, or change your mind while working), you should exit gparted, refresh the partition table using the command gparted -ay, and open gparted again to continue your work.

Format your new partitions

Now format your filesystem for each partition. In my case I used fdisk and ran a mke2fs on /dev/mapper/via_hfciifae5 and mkreiserfs on /dev/mapper/via_hfciifae7.

Alternatively, you can do this using the GUI in gparted. Run dmraid -ay again to refresh the partition table for gparted and then open gparted again. You will see that the new partitions are designated as "unknown type", because they are not formatted. You can use gparted to format them by right-clicking each partion and selecting "convert" and the appropriate format. Before you exit, make a note of the device mapping for each new partition (you will need this later). Apply the changes and exit. You can also see these mappings with the command dmraid -r.

In my case I had the following mappings:

via_hfciifae  -- the raw raid volume
via_hfciifae1 -- the NTFS partition
via_hfciifae5 -- /boot
via_hfciifae6 -- swap
via_hfciifae7 -- /

Mount the temporary system

Next, I created a temporary file structure to hold my new installation while I construct it, I and mounted two sets of directories to it: a) Mounted the new partitions I had created for / and /boot (so could install packages to them). b) Mounted the currently running, /dev, /proc, and /sys filesystems, so I could use these to simulate a running system within my temporary file structure.

mkdir /target
mount -t reiserfs /dev/mapper/via_hfciifae7 /target
mkdir /target/boot
mount -t ext2 /dev/mapper/via_hfciifae5 /target/boot
mkdir /target/dev
mount --bind /dev /target/dev
mkdir /target/proc
mount -t proc proc /target/proc
mkdir /target/sys
mount -t sysfs sysfs /target/sys

Install the base system

Now we install the base system. debootstrap installs all base packages and does it setup. Afterwards you need to install some additional packages:

cd /target

apt-get install debootstrap
# install debootstrap to install the base system at the next point

# install base system
debootstrap breezy /target  ## instead of breezy can be any distribution selected

# copy sources list
cp /etc/apt/sources.list etc/apt

# copy resolv.conf
cp /etc/resolv.conf /target/etc

# run in the now installed system
chroot /target

# install ubuntu-base (and other packaged)
apt-get update
apt-get install ubuntu-base linux-k7 ubuntu-desktop dmraid grub
# change grub to lilo if you use lilo
# change k7 to your processor architecture if you don't know, use linux-386.

# the system is installed now.

Installing Grub

To install grub you need to install the grub package.

Now you need to run the grub shell. The command grub-install doesn't work, because the device mapping is not known to grub.

cp /lib/grub/<your-cpu-arch>-pc/stage1 /boot/grub/
cp /lib/grub/<your-cpu-arch>-pc/stage2 /boot/grub/
# grub needs these files to setup itself correctly

grub
# you are now in the grub shell

device (hd0) /dev/mapper/via_hfciifae
# this says grub which mapping the BIOS has

# setting the geometry may not be
# mandatory for you. Only specify it if things
# do not work.  The three numbers describe
# the drive in terms of cylinders, heads,
# and sectors per track.

geometry (hd0) 9001 255 63

# the root command complained about bad cylinder numbers without this
# so I gave it this command to tell it the right geometry
# according to fdisk (fdisk -l /dev/mapper/via_hfciifae)

root (hd0,4)
# select the root partition (note "4" is my boot partition number minus 1)

setup (hd0)
# install grub

quit

If you have installed grub after installing the linux-... package, run now update-grub to add your linux kernel to the boot options.

Edit the created menu.lst file as follows:

a) Correct the path to the linux root. update-grub configures hda1 as root because it can't find your current root-device. Put the correct device name for your linux root (e.g. root=/dev/mapper/via_hfciifae7) in the places where you update-grub defaulted to root=/dev/hda1. Make sure you change this each of the multiple alternatives sections as well as in the Automagic defaults section. (Note that the Automagic defaults section is nested and therefore uses ## to indicate comments and # to indicate the defaults, so don't "un-comment" the default lines when you edit them).

b) If necessary, correct the grub root. In places, you will see other lines that also refer to "root", but use syntax such as root (hd0,1) instead of a path. These refer to the "root" for grub's purposes, (stay with me now) which is actually your /boot. Also, grub's syntax uses partition numbering beginning with zero. So, if you have a separate /boot partition, these lines will show root (hd0,4) -- (the same information we used while working with grub interactively earlier). Change this both for the Automagic defaults as well as for each alternative, including the memtest option.

c) An additional edit is required if you are using a separate /boot partition. The path to the linux root must be relative to the grub "root" (your /boot). So if you are using a separate boot partition, the paths in grub's menu.lst file that help grub locate the linux kernel and initrd will not begin with "/boot/", and you should delete that portion of the path. If you are not using a separate boot partition, you can leave these paths alone.

d) Finally, to add a Windows-Boot to your menu.lst you can use and change the following lines:

title Windows XP 
  rootnoverify (hd0,0)
  chainloader +1

Configuring the initramfs

For the kernel to recognize the RAID you have to run the dmraid utility to configure the mapper device. To do this, we need to add dmraid to the initramfs. Debian and Ubuntu supports for this mkinitramfs to add dmraid we need to add some scripts and hooks:

Create a file as /etc/mkinitramfs/scripts/local-top/dmraid . (If you are lazy or don't like to keyboard, you can open this how-to in the browser and copy the text.)

PREREQ=""

prereqs()
{
        echo "$PREREQ"
}

case $1 in
# get pre-requisites
prereqs)
        prereqs
        exit 0
        ;;
esac

modprobe -q dm-mod

/sbin/dmraid -ay

Create a file as /etc/mkinitramfs/hooks/dmraid

PREREQ=""

prereqs()
{
        echo "$PREREQ"
}

case $1 in
# get pre-requisites
prereqs)
        prereqs
        exit 0
        ;;
esac

. /usr/share/initramfs-tools/hook-functions

copy_exec /sbin/dmraid /sbin

exit 0

Mark both of these new initramfs scripts as executable:

chmod +x /etc/mkinitramfs/hooks/dmraid
chmod +x /etc/mkinitramfs/scripts/local-top/dmraid

Add the line dm-mod to the file /etc/mkinitramfs/modules. Make sure the file ends with a newline.

Now the big moment -- use initramfs to update the initrd file. Below, I show the kernel I installed at that time, but stuff following "img-" and following "-c -k " must reflect the version YOU are using (e.g., "2.6.12-10-amd64-k8-smp" or whatever). Two commands

rm /boot/initrd.img-2.6.12-9-k7
update-initramfs -c -k 2.6.12-9-k7

Now you can reboot your computer and use your new system.

Setup your system

Now you need to setup some settings:

Use base-config new to configure system defaults.

[http://samokk.is-a-geek.com/wordpress/2006/01/15/running-ubuntu-gnulinux-on-a-fakeraid1-mirroring-array/ Running Ubuntu On a Fakeraid/1 array] describes how to adapt this HOWTO to a FakeRAID/1 (mirroring) array.


CategoryDocumentation CategoryHardware