Introduction

This document shows how to convert a running system with standard partition types, into a system running a Raid 1 array.  The principals in this document can be adapted to those of Raid 5 or other types of raid array.

Please note, this document is based on using the raid functionality within Linux, and not hardware raid.  Of course, hardware raid is much preferred, since it's faster.  However, software raid within Linux is pretty good, and an excellent alternative if you don't want to purchase a hardware raid controller.

This example is using a virtual machine that I created in VMware.  The steps are the same, but I used 2 x 8GB disks for testing and writing the procedure.  My live system is running 2 x 160GB disks and was created using these procedures.

Please note, I won't be held responsible for data loss.  This is your responsibility, not mine, so make sure you have backed up all your important data.

Also, you need to make sure that you have the mdadm package installed, otherwise none of this will work!

Pre-Conversion

This is how my partitions looked like before the conversion:

So that you understand my partition layout, this is what each partition is:

I've gone for a more complicated setup, because I want to show more flexibility.  The test machine, was effectively a server, which is why /home doesn't exist as being separate, as I wasn't intending to use it as a desktop system.  Normally, a default Mandriva system, would be something like this:

of course, this can vary depending on how you partitioned it when you set the machine up.  You need to know this information before you can continue, otherwise you'll never be able to boot your system correctly.  Look at your /etc/fstab file for information on your partitions.

Now, install your second hard disk if you haven't done already.  This should become /dev/sdb if you're using SATA/SCSI and /dev/hdb if it's IDE (depending on which IDE controller you attach it to).  Easiest way to find out is using this command after booting the system normally:

and it will show all disks attached to the system.  I would recommend disconnecting all USB and externally attached disks while you do this, so that you don't get confused on which hard disk is what.

Once your system is booted normally (don't boot from Live CD, boot system normally), I would suggest one of two things.  Either initiate the runlevel 3 sequence, or stop X.  These can be done as follows:

or stopping X:

Installing mdadm

If you don't have this already, make sure you install it.  Check if it's installed:

if no results:

and then continue with the following section.

Creating the partitions

First, we need to ensure the disk was detected.  If you do this before, then you can skip this, otherwise, verify using:

and you should have /dev/sda and /dev/sdb (depending on your hard disks installed).  Now, we have to change the partition types on the first disk, so:

and toggle each of the partitions.  As you know, in my example, I have six partitions, one of which is an extended partition (/dev/sda4) of which you do not touch.  This is important.  You only do the partitions I marked out above, so:

and when in fdisk, to toggle the partitions, you do:

to change to Linux raid auto-detect.  Do this for each of the other partitions, except the extended partition.  To save afterwards and exit, press:

and you'll be back at the prompt.  You may find an error message about the partition table being updated next time you reboot because it's currently in use.  Don't worry about this.  The changes we're making is to ensure that the sizes of partitions on /dev/sda is the same as on /dev/sdb.  And don't reboot yet, else we'll have big problems!  This is what my partition table looks like now I made those amendments:

as you can see, I left /dev/sda4 as it was.  You have to, it's normal.  The next step is to make /dev/sdb the same.  You could just use fdisk and do this manually, but it would take a while.  Here is a command to make it almost instantaneous:

neat eh!  Now, ensure it's absolutely identical:

and compare all the numbers.

Creating Arrays

Since /dev/sda is in use, we cannot add this to the array yet, so we will build the array with /dev/sda offline, and only /dev/sdb active.  This is how:

Now, the filesystems need to be created on /dev/sdb.  In my example here, all mine were ext3, but change this for the appropriate command if you use reiserfs, etc:

Copying Data

Now, we have to activate those partitions so that we can use them, so:

It's important to ensure that / is mounted to /mnt/array.  As you know from my example, /dev/sda3 was /, but on /dev/sdb this would be /dev/sdb3, and since it's now in a raid array, we don't access the partition directly as /dev/sdb3, but as /dev/md2.

Now, copy the data across:

and mount the other partitions and copy the data:

Boot Configuration

We need to ensure that we set the system to reboot from the array, otherwise we'll have problems getting our system up and running.  The mount points in /etc/fstab, should be something like this:

of course, my /etc/fstab has other info too, but I've just put what's relevant for the raid setup.

And copy this file to /mnt/array/etc:

Now, edit /boot/grub/grub.conf (sometimes menu.lst) so that it boots from the array as well, here is my entry:

now, copy this file into /mnt/array:

substitute grub.conf with menu.lst if your system uses this.  We now need a configuration file for the raid array, so create /etc/mdadm.conf:

this is enough to ensure the system will boot successfully once we've successfully completed adding /dev/sda to the array.  Copy this file to /mnt/array/etc as well:

and the final step is to reinstall the boot loader so that it's written to both the MBR's on each disk:

please note (hd0,1) is pointing to /dev/sda2 as I had /boot as a separate mount point.  Otherwise, you specify your / partition instead.

Finishing Touches

Insert your Mandriva CD1 or DVD and reboot using rescue mode:

exit to the prompt when you get a menu screen of options, we'll do the rest of the steps manually.  First we have to activate the array we created, which means we need a /etc/mdadm.conf (you did this already, but we're booted from CD now!):

note again, I didn't put the /dev/sdax partitions, because the disk isn't prepared yet.  Activate the array using:

this will scan the config file you just created and activate the array for the partitions on /dev/sdb.  In case this didn't work, you might need to do this step first:

if you need more than this, just add one, ensuring that the last number increases just like the mdx number increases.

Now, mount the partitions:

check and verify that all the filesystem looks good, and that we have everything.  Now, let's delete the partitions on /dev/sda, as we need to create these from scratch:

you'll see I deleted the extended partition.  It also deleted the 5 and 6 partition too at the same time.  Verify the disk is empty:

and we'll use the sfdisk command like before to ensure the partition table on /dev/sdb is the same on /dev/sda:

and then verify again with:

and make sure all the numbers match up.  Now, let's add /dev/sda to the array:

they will add, now check the status of the array building process using:

and wait until this has finished before continuing.  It can take a while if your disks are large, be patient :-).  Now, we need to chroot the environment to ensure the kernel can boot our system:

Mandriva uses initrd, which is why we need to do these next steps.  Otherwise, you won't be able to boot your system.  This is simple enough.  First, check your /boot directory for the kernel and initrd.  We have to rename the initrd so that we can create a new one.  I'm working with the Mandriva 2007 default kernel of kernel-2.6.17-5mdv and the initrd-2.6.17-5mdv.img files, so:

check your /boot/grub/grub.conf (or menu.lst) file to ensure that you are working with the right kernel - in case you have multiple kernels installed.  Or, you'll have to repeat this process for all of them.  Now, create the initrd:

the first part is the filename of the initrd that we renamed before, and the second is the kernel version.

After all this has been done, you can safely reboot the system:

umount /mnt/array/proc /mnt/array/boot /mnt/array/usr /mnt/array/var /mnt/array

or alternatively, replace reboot with:

if you want to shut down the system.  When you boot the system, you'll find you are now booted with the arrays, and all should be working perfectly fine.