Create your own SL4 and SL5 LiveCD

IMPORTANT: This description is valid for SL4 and SL5 only. For SL6 LiveCD please see Create your own SL6 LiveCD

Introduction

The build scripts provided here should allow you to build your own Scientific Linux Live CD. This scripts (with some modifications) are also used to build the CentOS 4 Live CD. You can either install Scientific Linux on a normal PC and use this system as a build system for your livecd. Or you can build the LiveCD in a chroot environment as described below.

WARNING: Do not run the build script on your PC ! Only run it on a special build PC or in the chroot environment !! The build scripts will change the system and will/can make your system unusable.

Some parts of the following description are taken from How to make a CentOS 4 Live CD. You will need root access for many of these steps (for chroot and mount) but it is designed to not impact your main install. The build is done in a single directory.

No special livecd kernel is required. The standard Scientific Linux kernel can be used. You just have to install the unionfs and squashfs kernel modules for SL4 and aufs kernel modules for as SL5 as described below.

Downloads

Download my build scripts from http://www.livecd.ethz.ch/download/build:
You need squashfs and unionfs support. Here you find RPMS and SRPMS of unionfs/aufs and squashfs:
http://www.livecd.ethz.ch/download/RPMS
http://www.livecd.ethz.ch/download/SRPMS

Repository

The build scripts are also available from a subversion repository. The complete repository can be found at https://svn.iac.ethz.ch/pub/livecd. The development branch is in https://svn.iac.ethz.ch/pub/livecd/trunk.
Or you can access the repository by WebSVN under https://svn.iac.ethz.ch/websvn/pub/wsvn/livecd.

An anonymous subversion checkout of the trunk can be done with

svn co https://svn.iac.ethz.ch/pub/livecd/trunk/SL4_SL5 livecd-trunk

Prepare a chroot environment

Start with a working Scientific Linux 4/5 system. You will need a working yum setup.
Make a new directory to build in, for example
```
LIVE=/scratch/livecd
mkdir -p $LIVE
```
You need about 4 GB free space in the directory $LIVE to build a live CD having the size of 700 MB.
Make some subdirectories
```
cd $LIVE
mkdir dev proc sys etc tmp 
```
Create some files to avoid error messages later
```
touch etc/fstab etc/mtab
```
Mount some virtual filesystems. If you reboot, you will have to redo this step
```
mount --bind /dev dev
mount null -t proc proc
mount null -t sysfs sys 
```
Copy your existing yum.conf and /etc/yum.repos.d directroy into the new etc directory:
```
cp -a /etc/yum.conf $LIVE/etc 
cp -a /etc/yum.repos.d $LIVE/etc/
```
Create directory for rpm transaction lock:
```
mkdir -p $LIVE/var/lock/rpm
```

Install the system with yum like this:

yum -c $LIVE/etc/yum.conf --installroot=$LIVE install yum rootfiles shadow-utils \
bind-utils gnupg vim-enhanced vixie-cron crontabs passwd which kudzu dhclient \
pciutils eject alsa-utils mkisofs wget kernel grub

This should install around 130 packages for a total of about 110-150 MB.

Enable the use of shadow passwords

cd $LIVE
sed -i "s|\*|x|" etc/passwd
sed -i "s|^root::|root:x:|" etc/passwd
cat etc/passwd | cut -d":" -f 1 | while read u; do echo "$u:*:12345:0:99999:1:::"; done >> etc/shadow
chmod 600 etc/shadow

And for /etc/gshadow

cp -a etc/group etc/gshadow
sed -i "s|:x:|::|" etc/gshadow
sed -i "s|:[0-9]\+:|::|" etc/gshadow
chmod 600 etc/gshadow

To allow choosing different keyboard layouts install

yum -c $LIVE/etc/yum.conf --installroot=$LIVE install kbd system-config-keyboard

To install a basic graphical environment (x-server, login manager, windows manager)

yum -c $LIVE/etc/yum.conf --installroot=$LIVE install system-config-display gdm xterm icewm

Without the package "system-config-display", the x-server will be not correctly configured !

Install further rpms using yum, for example to add KDE

yum -c $LIVE/etc/yum.conf --installroot=$LIVE install kdeartwork kdebase \
kdegraphics kdelibs kdemultimedia kdenetwork kdepim kdesdk kdeutils

You will have to play around until you find which packages you need.
For example to access remote Linux systems you may want to add openssh client
```
yum -c $LIVE/etc/yum.conf --installroot=$LIVE install openssh-clients
```
You can make any changes you would like to have on your Live CD now or you can do this later also in chroot.
Copy resolv.conf to the chroot (so yum will work in the chroot)
```
cp /etc/resolv.conf $LIVE/etc 
```

Copy your networking configuration file

cp /etc/sysconfig/network $LIVE/etc/sysconfig/

You may want to copy other system config files, like

cp /etc/sysconfig/i18n $LIVE/etc/sysconfig/
cp /etc/sysconfig/authconfig $LIVE/etc/sysconfig/
cp /etc/sysconfig/kernel $LIVE/etc/sysconfig/
cp /etc/sysconfig/clock $LIVE/etc/sysconfig/

Work in chroot environment

Switch to chroot of $LIVE
```
umount $LIVE/proc
chroot $LIVE
```
Mount /proc in chroot again:
```
mount -t proc proc /proc
```
To leave chroot and unmount /proc in advance, type
```
umount /proc
exit
```

In case of SL4: Install squashfs and unionfs

Since build script version livecd-2.0.0 or newer, no special livecd kernel is required anymore. The standard Scientific Linux kernel can be used. If not yet done, install the kernel in $LIVE:
```
yum -c $LIVE/etc/yum.conf --installroot=$LIVE install kernel
```
Now you have to install the unionfs and squashfs kernel-modules for the installed kernel.
Install the kernel modules and related packges in chroot.

Starting with kernel version 2.6.9-89.0.9.EL unionfs and squashfs are now part of SL4, just run

chroot $LIVE
yum install squashfs kernel-module-squashfs 
yum install unionfs kernel-module-unionfs

If you run another kernel, you can rebuild squashfs and unionfs RPMS from the SRPMS: http://www.livecd.ethz.ch/download/SRPMS/4x. The usage of rpmbuild is described in the spec files.

In case of SL5: Install squashfs-tools and aufs kernel modules

In case of SL5 squashfs is included in the kernel. You only have to install the squashfs-tools, which are part of SL5:
```
chroot $LIVE
yum install squashfs-tools
```
Aufs (another union file system) seems to be more stable than unionfs. Aufs can be compiled against the SL5 kernel whereas the SL4 kernel is too old. Prebuild aufs RPMs for SL5 kernels can be found here http://www.livecd.ethz.ch/download/RPMS/5x
Starting with kernel version 2.6.18-128.1.1.el5 aufs is now part of SL5, just run
```
yum install aufs
```
to install aufs and the related kernel module.
If you run another kernel, you can rebuild aufs RPMS from the SRPMS: http://www.livecd.ethz.ch/download/SRPMS/5x. The usage of rpmbuild for aufs is described in the aufs.spec file.

Run the build scripts

Download the latest build scripts (livecd-x.x.tar.gz) from here http://www.livecd.ethz.ch/download/build
Copy the tarball to chroot, for example into the folder build
```
mkdir $LIVE/build
cp livecd-x.x.x.tar.gz $LIVE/build
```
chroot into the image
```
chroot $LIVE 
```
Unpack the scripts in chroot
```
cd /build
tar xfvz livecd-x.x.x.tar.gz
```
Change to the livecd build script directory
```
cd /build/livecd-x.x.x
```
Change the configuration in the file livecd.conf:
```
vi livecd.conf
```
You have to specify the kernel version that you have installed inside chroot environement. Assuming you kernel is 2.6.9-42.0.3.EL change in livecd.conf:
```
KERNEL="2.6.9-42.0.3.EL"
```
And you have to define the OS_RELEASE in livecd.conf. For SL4, RHEL4, CentOS4 set
```
OS_RELEASE=4
```
For SL5, RHEL5, CentOS5 set
```
OS_RELEASE=5
```
Please note: Before livecd-2.9.0 you had to define the OS_RELEASE with an option passing to build-livecd.sh, see:
```
build-livecd.sh -h
```
In addition you can set the OS update release. For example for SL 5.3 set
```
OS_UPDATE=3
```
You can define more in livecd.conf, For example, in order to set the default runlevel of your LiveCD to 3, change in livecd.conf
```
RUNLEVEL=3
```
Or if you want to add some extra boot parameters
```
EXTRA_BOOT_OPTIONS="kb=us nopasswd"
```
Now run the build script
WARNING: Always run the scripts in the chroot environment !!
```
./build-livecd.sh 
```
The creation of the compressed images, particularly usr.mo, will take some time.
If everything goes well, you should get the LiveCD ISO created in /tmp/livecd.iso or $LIVE/tmp/livecd.iso, respectively.
For more information about the build scripts see also the README file provided within the tarball.

Test the ISO image

You can burn this ISO image to a CD or DVD ROM. However, it is much easier to test it with qemu
For example get qemu from here: http://dag.wieers.com/packages/qemu. Take the rpm for el4.

How to run qemu (see also man qemu):

qemu -m 256 -cdrom livecd.iso
qemu -m 256 -full-screen -cdrom livecd.iso

Escape full screen in qemu with ALT+CTRL+f
Or alternatively you can use VMware Player or VMware Server.

Last modified: Thursday, 30-Jun-2011 17:23:41 CEST by Urs Beyerle