Linux.Desktop.Hacks [Electronic resources] نسخه متنی

Hack 74. Clone Your Linux Install

Deploy a single installation of Linux across
many computers.

Cloning is simply a method by which some data is copied exactly, from
one medium to another. This can be a physical CD being copied into a
CD image (such as an ISO image) or, in the case of this hack, copying
a hard-disk partition into a file that can be stored for archival
purposes or deployed to several machines. The use of cloning is very
widespread on the Internet, with CDs and floppies being distributed
as images that are just a bit-for-bit copy of the original medium.
Cloning can also be used to move your Linux system to a larger hard
drive.

9.6.1. Create an Image

Linux systems generally have
a utility installed called dd (data dump) that
can accept an input from a device and pipe the output as an exact
copy of the original to another device or a file. This is the tool
you should use when creating a cloned image of an installation.

First, you need to find out which partition on the hard disk contains
the root filesystem. You can do this using the
mount command:

foo@bar:~# mount

It should give some output similar to the following:

/dev/hda1 on / type ext3 (rw,noatime)
none on /proc type proc (rw)
none on /sys type sysfs (rw)

The entry you're looking for is the one mounted on
the root filesystem, /. In this case, it is
/dev/hda1. Now that you know the device for the
root partition, you can use dd to clone the
partition. However, it is very unwise to start trying to clone a
partition while it is still mounted, because processes that are
currently running on the box constantly change the data and the image
produced will be inconsistent. The best method is to enter
single-user mode when you boot your system, then run a command to
remount the root filesystem as read-only. (Other methods are
available for doing this; you could use a Knoppix boot CD and log in
via a virtual terminal to run your commands, for example.)

To boot into single-user mode, you need to add the kernel argument
single on startup. You can find details on how to
add kernel arguments to your bootloader in [Hack #1]. If you use this method, you
cannot simply unmount the root partition, as it contains the binary
for dd, which you need to perform the hack. Also
while a partition is being cloned, you cannot write the resulting
image to anywhere on that partition, because the write process will
change the partition while you are copying it. So, you need to find
another partition to which you can write the image (it
doesn't have to be a Linux partition, but it must
have more free space than the size of the partition you are cloning).
As such, create a mount point for the partition to which you are
going to write the image (/mnt/foo in this
example):

foo@bar:~# mkdir /mnt/foo

Then mount your destination partition on that mount point so that you
can write the image to it. Another option is to use an external USB
hard-disk drive and load the usb_storage module to
read it. Most systems have the usb_storage module
already compiled, but if yours doesn't, you need to
compile it [Hack #88] . You need to
have the option under Device DriversUSB
supportUSB Mass Storage support set to
"Compile as a module." If you have
the module loaded, it appears as a SCSI device which can be mounted:

foo@bar:~# modprobe usb_storage
foo@bar:~# mount /dev/sda1 /mnt/foo

Finally, you need to sync and remount the root partition as read-only
so that things cannot change when you are creating the image:

foo@bar:~# sync
foo@bar:~# mount -o remount,ro /

Now you are ready to create the image. The following command copies
the contents of /dev/hda1 and places it as an
image file called image.bin on the filesystem
mounted on /mnt/foo:

foo@bar:~# dd if=/dev/hda1 of=/mnt/foo/image.bin

The dd command takes two arguments:
if= and of=. The
if= argument points to the device or file from
which it is to take its input (i.e., the device you are cloning), and
of= points to the device or file where you want to
dump the clone. Depending on the size of your root partition, this
could take a very long time, indeed. Go have a cup of coffee or tea,
or watch television. When it's finished, it should
tell you how many in and out records it has read and written. If it
says "Input/Output error,"
something's gone wrong (such as a bad block on the
hard disk), but all is not lost. A tool called
dd_rescue will skip over the bad blocks and
clone as much of the filesystem as possible. You can read more about
this tool at http://www.oreillynet.com/pub/wlg/5205.

9.6.2. Restore the Image

Now you should have a large file called
image.bin in the root directory of
/dev/sda1 (or whichever partition you mounted on
/mnt/foo). At this point, you should unmount the
disk to which you wrote the image. If you used an external USB drive,
you can plug it into any computer onto which you want to clone this
Linux install.

To restore the image, you literally do the commands in reverse. You
need a Linux boot CD of some sort (such as Knoppix, SUSE, Ubuntu, or
Red Hat) and boot into a recovery mode, or gain access to a shell
(Ctrl-Alt-F2 when you are in the installation portion of a
distribution). Then you can load the usb_storage
module again, and mount the external hard disk:

foo@bar:~# mkdir /foo
foo@bar:~# modprobe usb_storage
foo@bar:~# mount /dev/sda1 /foo

Now you need to partition the disk on the new machine using
fdisk or a similar partitioning tool. A root
partition and a swap partition are required. Assuming that the root
partition is the first partition on the disk and the swap is the
second, you need to format the swap partition using the following
command:

foo@bar:~# mkswap /dev/hda2

It isn't necessary to write a filesystem to the root
partition, because the image is providing a filesystem. At this point
you can load the image file onto the hard disk using the
dd command again:

foo@bar:~# dd if=/foo/image.bin of=/dev/hda1

As you can see, the command just reverses the source and destination
of the input and output. When this is finished, you need to mount the
partition and chroot into it so that you are
"inside" the Linux installation:

foo@bar:~# mkdir /install
foo@bar:~# mount /dev/hda1 /install
foo@bar:~# chroot /install /bin/bash

The last line tells the system to pretend the root directory is
/install, and run the bash shell upon entering
it. Now you need to sort out the bootloader for the system. Most
systems use either LILO or GRUB. In the case of LILO, you need to run
lilo in the chrooted
environment. This will write the
necessary code to the master boot record:

foo@bar:~# lilo

With GRUB you need to run grub-install:

foo@bar:~# grub-install /dev/hda

If all has gone well, you can exit the chroot
environment and reboot the system. It should boot up as normal.

George Wright