AUTHOR: (original) Thomas Foecking <thomas@foecking.de> and
Christian Hesse <mail@earthworm.de>
(updates) Jimmy Anderson <jimmy.anderson1056@gmail.com>
DATE: 2011-03-12
LICENSE: GNU Free Documentation License Version 1.2
SYNOPSIS: Easy Bootable CD of your LFS
DESCRIPTION:
With a little effort, a bootable CD/DVD can be created from an LFS system.
The CD created by this hint could be used as a rescue CD, an LFS build
system, or for whatever other purpose the user can concoct.
Briefly the bootable CD provides a root filesystem that is
sourced mostly by the (read only) CD contents but with a few
certain directories overlayed by ram and thus writable.
Briefly, the procedure is: a CD bootloader is
added to the LFS system, a kernel and a ramdisk is created, which
when booted, mounts the LFS system (written on CD) as the root filesystem
and then overlays portions of it with a ram based filesystem which
allows the user to 'write' to some portions of the CD based file system.
This hint does not create a "live CD". The end result of this hint is a
LFS system that runs off of CD but with only a few directories
being 'writable' by the user and with (except for /tmp) only a
small (few megabytes) amount of writable space. /tmp will be overlayed
by a tmpfs file system and (typically) have 100's of megabytes of space.
If instead, a live CD is desired, the LFS LiveCD project, or one of
the other Live CD projects may be a more appropriate resource to use.
The value of this 'bootable CD' is that it is simple to do, and
easy to modify and fix.
The instructions in this hint have been tested with X86 LFS 6.6 & 6.7.
It probably will work with other current LFS books as well. It also
works for building a PowerPC bootable CD. This hint assumes 32bit cpu.
Note that the instructions in this hint are executed as root. As such, it is
possible that a mistyped or misunderstood instruction could destroy the
data and/or OS on your system. It is prudent to back up any important
data on your system before attempting to use this hint to create a bootable
CD. Ideally, you should perform this task on a system which is only
used by you and which you can easily reinstall without difficulty. That
way, any mistakes you make will not affect others and will have minimal
impact on you. Fair notice...
ATTACHMENTS:
None
PREREQUISITES:
Familiarity with building LFS. The build system must have a writable
CDROM drive and the tool set required to create (mkisofs) ISO images
and write them to CDs. If your system has the 'genisoimage' tool
instead of mkisofs, that will work fine also.
HINT:
Contents
--------
1. What do you need and what is the idea?
2. Configure & compile Kernel, add packages, other tweaks
3. Add bootloader.
4. Move /etc /var /root /home to /fake/needwrite and make symlinks
5. Create boot script which mounts the ramdisk
6. Tweaks for running with CD as root fs.
7. Create initial ramdisk
8. (Optional) compress /usr
9. Create initial ramdisk
9a. Burn the Boot CD
10. Reboot and enjoy
1. What do you need and what is the idea?
--------------------------------------
What do you need?
First of all you need to build an LFS system, which you want to burn
on CD. You may want to have a LFS CD for creating new LFS systems
on other computers. Whatever your ideas are, you'll first have to
create this special system on your LFS partition.
(e.g. I have created a LFS system with xfree86 and windowmaker;
now I can boot from CD and create new LFS systems without missing
xfree86 & windowmaker)
- another linux/unix system to create some stuff and burn the CD
- CD-R(W) drive to burn your LFS system and boot image on CD
- 1 CD-R + 1 CD-RW is very recommended for saving money
- obtain some additional software:
(x86) syslinux: (contains isolinux to boot the LFS kernel on CD)
ftp://www.kernel.org/pub/linux/utils/boot/syslinux/syslinux-4.03.tar.gz
(PowerPC) yaboot: (bootloader for PowerPC)
http://yaboot.ozlabs.org/releases/yaboot-1.3.16.tar.gz
Download either syslinux (x86) or yaboot (PowerPC) as appropriate
for your architecture and put the source in $LFS/sources for later
use.
What is the idea?
- Create kernel with ramdisk and initrd support
- Move /etc /var /root /home to /fake/needwrite
- Set symlinks
/etc -> /fake/needwrite/etc
/var -> /fake/needwrite/var
/... -> /fake/needwrite/...
- Mount /dev/ram0 to /fake/ramdisk
- Copy /fake/needwrite/* to /fake/ramdisk/
- Remount /dev/ram0 to /fake/needwrite
We'll have read-write access on /etc /var /root /home
because they point to /fake/needwrite which is then a ramdisk
You are able to do the most things from the other linux/unix
system by setting LFS to your LFS mountpoint. LFS=/path/to/lfs
e.g.:
export LFS=/mnt/lfs
Don't forget to set LFS again when you do a reboot!
2. Build LFS system, configure & compile Kernel
--------------------------
Do this step in the chroot environment.
The first step is to build your LFS system as is described in
the LFS book. While in the chroot environment, you will configure &
build the kernel. When configuring your kernel, make sure that the
following kernel configuration settings are enabled
(as builtins, not as modules).
You need initrd support!
"General setup --->"
"<*> Initial RAM filesystem and RAM disk ..."
You need ramdisk support!
"Block devices --->"
"<*> RAM block device support"
"(16384) Default RAM disk size"
"[*] Initial RAM disk (initrd) support"
You need ext2 file system support!
"File systems --->"
"<*> Second extended fs support"
You need ISO 9660 CDROM file system support!
"File systems --->"
"<*> ISO 9660 CDROM file system support"
You may need to compress your file system (to fit on CD), and to do so
will need squashfs also. It may not be required but it is best to
just go ahead and enable it anyway while we are building our
kernel to keep things simple.
(If compressing) You need squashfs file system support!
"File systems --->"
"<*> Squashfs file system support"
Then compile and install your kernel & modules just
as is described in the LFS book.
Copy the newly built kernel and associated .config file to /boot:
cp .config /boot/lfskernel.config
#
# on x86 do:
cp arch/i386/boot/bzImage /boot/lfskernel && cp System.map /boot/
#
# on a PowerPC do:
cp vmlinux /boot/lfskernel && cp System.map /boot/
Set all the configuration settings described in the LFS book
as appropriate for your system. Especially important is that you
set your LFS system root password (or remove it entirely). If
you don't, you will not be able to login when you boot your CD.
Space will be tight on a CD (not so much on a DVD) so remove any
files and directories that are no longer needed. $LFS/tools
is no longer needed and should be removed. If you won't need the
files in $LFS/sources when running on the CD, some or all of
those can be removed to reduce the size of the image.
The /usr file system can (optionally) be compressed (later) to free up
space. Compressing it will reduce the size by a couple hundred megabytes
or so.
Using BLFS (or other techniques) add any additional packages that
you require in your LFS system.
You will not be able to create directories or files in most portions
of the filesystem so think ahead about what you will need to do
and add whatever directories or files that you might need later when
running on the CD. For example, maybe create /mnt/lfs and it's
associated /tools symlink.
#
mkdir /mnt/lfs
ln -sv /mnt/lfs/tools /
#
At this point, it might be wise to save off a copy of your LFS system
in case you screw up and want to start over again at this point.
3. Install the bootloader (isolinux or yaboot)
-------------------------------
Do this step in the chroot environment.
We also need a bootloader on the CD to boot the kernel and ramdisk.
isolinux will be used for the bootloader for X86 machines.
yaboot will be used for PowerPC MACs. On PowerPC machines
that don't use openfirmware, yaboot is not used and you can skip
building it. For those machines, you will have to figure out the
boot loader installation yourself.
# On an X86 machine do:
#------------------- copy and paste ------------------------------
#
# Unpack, install and configure isolinux
#
cd /sources
zcat syslinux-4.03.tar.gz | tar x
mkdir /isolinux
cp syslinux-4.03/core/isolinux.bin /isolinux/
rm -fr syslinux-4.03
#
# If all files associated with the boot process should be in one
# directory we have to move kernel and the Rest of /boot to /isolinux.
#
mv /boot/* /isolinux
#
# Now we create a symlink from boot to isolinux.
#
cd /
rmdir boot
ln -s isolinux boot
#
# Kernel & co can now be found in /boot again.
# But isolinux still needs a config-file, so we create it now:
#
cat > /isolinux/isolinux.cfg << "EOF"
default bootcd
prompt 1
timeout 40
label bootcd
kernel lfskernel
append initrd=initrd.gz root=/dev/ram0 init=/linuxrc ramdisk_size=16384
label initrdshell
kernel lfskernel
append initrd=initrd.gz root=/dev/ram0 init=/bin/bash ramdisk_size=16384
EOF
#
# isolinux is now installed completely.
#
#------------------- end copy and paste ---------------------------
# It's a bit more lengthy on a PowerPC machine. Do:
#------------------- copy and paste ------------------------------
#
mkdir -p /ppc/mac
mkdir -p /ppc/ppc32
#
# If it isn't already installed, build and install yaboot.
#
cd /sources
tar xvfz yaboot-1.3.16.tar.gz
cd yaboot-1.3.16
sed -i 's%/usr/local%/usr%' man/*
make PREFIX=/usr
make PREFIX=/usr install
cd ..
cp /usr/lib/yaboot/yaboot /ppc/mac
#
# Create an open firmware configuration file.
#
cat > /ppc/mac/ofboot.b << "EOF"
<CHRP-BOOT>
<COMPATIBLE>
MacRISC MacRISC2 MacRISC3 MacRISC4
</COMPATIBLE>
<DESCRIPTION>
LFS CD PPC bootloader
</DESCRIPTION>
<BOOT-SCRIPT>
" screen" output
load-base release-load-area
boot cd:,\ppc\mac\yaboot conf=cd:,\ppc\ppc32\yaboot.conf
</BOOT-SCRIPT>
<OS-BADGE-ICONS>
1010
f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8
f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f80000000000000000000000000000f8
f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffff
</OS-BADGE-ICONS>
</CHRP-BOOT>
EOF
#
# Create a yaboot message file
#
cat > /ppc/ppc32/yaboot.msg << "EOF"
MacRISC type machine...
____________________________________________________
GNU/Linux LFS PPC - 32bit
EOF
#
# Create a yaboot configuration file.
#
cat > /ppc/ppc32/yaboot.conf << "EOF"
message=/ppc/ppc32/yaboot.msg
delay=20
init-message = "\nWelcome to LFS bootCD 2 \nHit <TAB> for boot options.\n\n"
timeout=150
default=bootcd
#enablecdboot
#enableofboot
#enablenetboot
image=/boot/lfskernel
label=bootcd
initrd=/boot/initrd.gz
append="rootdelay=2 init=/linuxrc root=/dev/ram0 ramdisk_size=16384"
read-write
pause-after
image=/boot/lfskernel
label=initrdshell
initrd=/boot/initrd.gz
append="rootdelay=2 init=/bin/bash root=/dev/ram0 ramdisk_size=16384"
read-write
pause-after
EOF
#
#------------------- end copy and paste ---------------------------
4. Move /etc /var /root /home to /fake/needwrite
--------------------------------------------------
Do this step in the chroot environment.
This step will all directories needing write access to /fake/needwrite
and create symlinks from their original locations.
#------------------- copy and paste ------------------------------
#
# move directories
#
mkdir -p /fake/{needwrite,ramdisk}
cd /
mv etc/ var/ root/ home/ fake/needwrite/
#
# create symlinks so that everything seems to be as before
#
ln -s fake/needwrite/etc etc
ln -s fake/needwrite/var var
ln -s fake/needwrite/root root
ln -s fake/needwrite/home home
ls -l
#
# You should see the following symlinks.
#
# etc -> fake/needwrite/etc
# home -> fake/needwrite/home
# root -> fake/needwrite/root
# var -> fake/needwrite/var
#
#------------------- end copy and paste ---------------------------
5. Create boot script which mounts the ramdisk
--------------------------------------------
Do this step in the chroot environment.
Ok, we have /etc /var /root /home linked to
/fake/needwrite which is first read-only.
To be able to login (and to run services on runlevel x
which need write access to /etc /var /root or /home)
we must call a script from our /etc/rc.d/init.d/ directory which
creates a ramdisk to /fake/needwrite with write access.
The following script creates a ramdisk to /fake/ramdisk and
will copy everything of /fake/needwrite to /fake/ramdisk.
Then it remounts the ramdisk to /fake/needwrite.
#------------------- copy and paste ------------------------------
#
cat > /etc/rc.d/init.d/create_ramdisk << "EOF"
#!/bin/sh
dev_ram=/dev/ram0
dir_ramdisk=/fake/ramdisk
dir_needwrite=/fake/needwrite
source /etc/rc.d/init.d/functions
case "$1" in
start)
echo -n "Creating ext2fs on $dev_ram ... "
/sbin/mke2fs -m 0 -i 1024 -q $dev_ram > /dev/null 2>&1
evaluate_retval
sleep 1
echo -n "Mounting ramdisk on $dir_ramdisk ... "
mount -n $dev_ram $dir_ramdisk
evaluate_retval
sleep 1
echo -n "Copying files to ramdisk ... "
cp -dpR $dir_needwrite/* $dir_ramdisk > /dev/null 2>&1
evaluate_retval
sleep 1
echo -n "Remount ramdisk to $dir_needwrite ... "
umount -n $dir_ramdisk > /dev/null 2>&1
sleep 1
mount -n $dev_ram $dir_needwrite
sleep 1
;;
*)
echo "Usage: $0 {start}"
exit 1
;;
esac
EOF
chmod 0755 /etc/rc.d/init.d/create_ramdisk
#
# create_ramdisk should be the first script excecuted by init,
# so we set this link:
# /etc/rc.d/rcsysinit.d/S00create_ramdisk -> ../init.d/create_ramdisk
#
cd /etc/rc.d/rcsysinit.d
ln -s ../init.d/create_ramdisk S00create_ramdisk
#
#------------------- end copy and paste ---------------------------
6. Configure LFS to run from CD
----------------------
Do this step in the chroot environment.
Since the root filesystem will be mounted from our startup script,
we have to change /etc/fstab of LFS. Delete all entries you don't need.
(e.g. all /dev/hd*) and add /tmp as a tmpfs file system. Also, the
startup scripts need to be tweaked for running on a CD (file systems
don't need to be checked or remounted rw). And since the startup
script runs before the device nodes have been populated, we have to
manually create some device nodes for it.
#------------------- copy and paste ------------------------------
#
cat > /etc/fstab << "EOF"
# Begin /etc/fstab for a bootable CD
# file system mount-point type options dump fsck
# order
#/dev/EDITME / EDITME defaults 1 1
#/dev/EDITME swap swap pri=1 0 0
proc /proc proc defaults 0 0
sysfs /sys sysfs defaults 0 0
devpts /dev/pts devpts gid=4,mode=620 0 0
tmpfs /dev/shm tmpfs defaults 0 0
tmp /tmp tmpfs defaults 0 0
# End /etc/fstab
EOF
#
#
# Remove file system check.
#
rm -f /etc/rc.d/rcsysinit.d/S30checkfs
#
# Disable remounting of / as rw in S40mountfs
#
cd /etc/rc.d/init.d
cp -f mountfs origmountfs
grep -v 'remount' origmountfs >mountfs
chmod 0755 mountfs
#
# Ensure that /dev/loop0 exists (compressed /usr requires it).
mknod /lib/udev/devices/loop0 b 7 0
#
#------------------- end copy and paste ---------------------------
7. Create initial ramdisk
----------------------
If you are chrooted into your LFS system, exit from chroot and return
to your host system. Unmount any virtual file systems that are mounted
into the $LFS tree.
To ensure that everything is in a good state for the remainder of this
procedure, it may be best to simply shutdown and restart your host system.
Make sure LFS is set after rebooting!!
export LFS=/mnt/lfs
#------------------- copy and paste ------------------------------
# Add device nodes that will be needed before /dev has been
# populated
#
mknod $LFS/dev/ram0 b 1 0
#
#------------------- end copy and paste ---------------------------
Now we create the initrd image file and filesystem.
#------------------- copy and paste ------------------------------
#
#
dd if=/dev/zero of=$LFS/boot/initrd bs=1024 count=8192
mke2fs -m 0 -i 1024 -F $LFS/boot/initrd
#
mount -o loop $LFS/boot/initrd $LFS/mnt
cd $LFS/mnt
mkdir bin lib dev proc mnt
#
mknod $LFS/mnt/dev/ram0 b 1 0
mknod $LFS/mnt/dev/null c 1 3
mknod $LFS/mnt/dev/zero c 1 5
mknod $LFS/mnt/dev/console c 5 1
mknod $LFS/mnt/dev/ttyS0 c 4 64
mknod $LFS/mnt/dev/sr0 b 11 0
mknod $LFS/mnt/dev/sr1 b 11 1
mknod $LFS/mnt/dev/sda b 8 0
mknod $LFS/mnt/dev/sdb b 16 0
mknod $LFS/mnt/dev/sdc b 32 0
mknod $LFS/mnt/dev/sdd b 48 0
mknod $LFS/mnt/dev/hda b 3 0
mknod $LFS/mnt/dev/hdb b 3 64
mknod $LFS/mnt/dev/hdc b 22 0
mknod $LFS/mnt/dev/hdd b 22 64
mknod $LFS/mnt/dev/hde b 33 0
#
cp $LFS/bin/{bash,mount,grep,umount,echo} $LFS/mnt/bin/
cp $LFS/usr/bin/test $LFS/mnt/bin/
cp $LFS/usr/sbin/chroot $LFS/mnt/bin/
cp $LFS/sbin/pivot_root $LFS/mnt/bin/
ln -s bash $LFS/mnt/bin/sh
ln -s test $LFS/mnt/bin/[
#
cp $LFS/lib/{libncursesw.so.5,libdl.so.2,} $LFS/mnt/lib/
cp $LFS/lib/{libc.so.6,libreadline.so.6} $LFS/mnt/lib/
cp $LFS/lib/{libhistory.so.6,libblkid.so.1,libuuid.so.1} $LFS/mnt/lib/
if [ -f $LFS/lib/ld-linux.so.2 ]
then
cp -f $LFS/lib/ld-linux.so.2 $LFS/mnt/lib/
fi
if [ -f $LFS/lib/ld.so.1 ]
then
cp -f $LFS/lib/ld.so.1 $LFS/mnt/lib/
fi
#
#
# cat, sleep & mknod are optional, but often useful to have when something
# gos wrong so put them in the initrd also.
#
cp $LFS/bin/{cat,sleep,mknod} $LFS/mnt/bin/
#
# The first program executed by the kernel is /linuxrc. As it does not
# exist we create it. Our script will find the CD in the correct
# CD-ROM drive and then mount it as rootfs / and run /sbin/init 3.
#
#
cat > $LFS/mnt/linuxrc << "EOF"
#!/bin/sh
#ID is the volume id / label of the LFS boot CD that will be looked for.
EOF
echo "ID=\"LFS_$(date +%Y%m%d)\"" >> $LFS/mnt/linuxrc
cat >> $LFS/mnt/linuxrc << "EOF"
TMP_MOUNT="/mnt"
PATH="/bin:/sbin:/usr/bin:/usr/sbin"
#this script searches for cdrom devices and then tries to find
#the LFS boot CD in order to mount it as / (rootfs)
#you need following programs:
#- /bin/sh (e.g. bash)
#- echo
#- [ (which is linked to test)
#- mount
#- umount
#- grep
#- pivot_root
#- chroot
#you need following devices:
#- /dev/hd*, /dev/sd*, /dev/sr* or /dev/cdrom*
#- /dev/null
#you need following directories:
#- /proc
#- $TMP_MOUNT
CHECK_TYPE="try_mount"
if [ ! -d "/proc/" ]; then
mkdir /proc
fi
mount -n proc /proc -t proc
#1. Create a list of possible cdrom devices.
CDROM_LIST="/dev/sr0 /dev/sr1 /dev/cdrom /dev/hda /dev/hdb /dev/hdc /dev/hdd
/dev/hde /dev/sda /dev/sdb"
#2. now we try to find the LFS boot CD (we use ID as identification)
LFS_CDROM_DEVICE=""
echo "Using $CHECK_TYPE"
for cdrom_device in $CDROM_LIST
do
echo -n "Checking $cdrom_device ... "
if [ "$CHECK_TYPE" = "try_mount" ]; then
mount -n -t iso9660 $cdrom_device $TMP_MOUNT > /dev/null 2>&1
media_found=$?
fi
if [ $media_found -eq 0 ]; then
echo -n "media found"
if [ "$CHECK_TYPE" = "try_mount" ]; then
[ -e "$TMP_MOUNT/$ID" ]
media_lfs=$?
fi
if [ "$CHECK_TYPE" = "try_mount" ]; then
umount -n $cdrom_device > /dev/null 2>&1
fi
if [ $media_lfs -eq 0 ]; then
echo ", LFS boot CD found. Ready!"
LFS_CDROM_DEVICE="$cdrom_device"
break;
else
echo ", not LFS boot CD."
fi
else
echo "no media "
fi
done
#3. mount LFS CD as / (root fs)
if [ "$LFS_CDROM_DEVICE" = "" ]; then
echo "No LFS boot CD found!!! You will have to fix this to continue"
echo "do: mount -n -o ro -t iso9660 'your cd device' $TMP_MOUNT"
echo "Then exit shell to continue"
bash
else
echo "Booting from $LFS_CDROM_DEVICE ... "
mount -n -o ro -t iso9660 $LFS_CDROM_DEVICE $TMP_MOUNT
fi
cd $TMP_MOUNT
pivot_root . mnt
umount -n /mnt/proc >/dev/null 2>&1
exec chroot . sh -c 'umount -n /mnt >/dev/null 2>&1;\
exec -a init.new /sbin/init 3'\
<dev/console >dev/console 2>&1
EOF
#
# To make this script executable run
#
chmod 0755 $LFS/mnt/linuxrc
#
# Ok, that's it. Unmount the image and compress it.
#
cd $LFS/
umount $LFS/mnt
gzip $LFS/boot/initrd
#
#------------------- end copy and paste ---------------------------
8) (Optional) compress /usr.
This step is optional. It's only needed if your media is
too small or if you just want to minimize the size of the ISO
file.
Before you go further, check the size of your LFS tree:
du -h $LFS/
Verify that it will fit on your media (approx 700MB for a CD..)
If it will not fit, and there isn't anything that can easily
be removed to make it fit, you can compress the /usr file
system to reduce the size by a couple hundred megabytes.
To compress your $LFS/usr directory, use mksquashfs to create
a 'squashed' version of $LFS/usr, remove the original $LFS/usr
and modify $LFS/etc/fstab to mount the squashed /usr during
system startup.
The kernel squashfs support does not universally work with
any squashfs filesystems. Make sure you are using
a version of squashfs tools (likely version 4 or better...)
which creates squashfs files that are compatible with your
kernel.
chroot is in /usr and must be moved to /sbin if compression
is used.
#------------------- copy and paste ------------------------------
mv $LFS/usr/sbin/chroot $LFS/sbin/chroot
mksquashfs $LFS/usr $LFS/usr.sqsh
rm -fr $LFS/usr/*
cat >> $LFS/etc/fstab << "EOF"
/usr.sqsh /usr squashfs loop,ro 0 0
EOF
#------------------- end copy and paste ---------------------------
9. Create Boot CD ISO Image
----------------
If you have a CD-RW you may want to use it for testing. When
your system boots quite good from CD-RW you can burn it on a CD-R.
(I give you this advice, because I got the clue after burning
about 10 CD-Rs that didn't work ;-)
Because linuxrc must be able to identify the CD you have to create a
file called "LFS_YYYYMMDD".
#------------------- copy and paste ------------------------------
touch $LFS/LFS_$(date +%Y%m%d)
#------------------- end copy and paste ---------------------------
Now create the ISO image of your bootable CD.
# On a X86 do this:
#------------------- copy and paste ------------------------------
#
cd $LFS/
rm -f lfsbootcd.iso
mkisofs -R -l -L -D -b isolinux/isolinux.bin -c isolinux/boot.cat \
-no-emul-boot -boot-load-size 4 -boot-info-table -V "LFS_$(date +%Y%m%d)" \
$LFS >lfsbootcd.iso
#
#------------------- end copy and paste ---------------------------
# On a powerpc do this:
#------------------- copy and paste ------------------------------
#
# Create a mapping file.
#
cat > $LFS/boot/map.hfs << "EOF"
# ext. xlate creator type comment
.b Raw 'chrp' 'tbxi' "bootstrap"
yaboot Raw 'unix' 'boot' "bootstrap"
.conf Ascii 'unix' 'text' "config"
.msg Ascii 'unix' 'text' "text"
* Raw '????' '????' "unknown"
EOF
#
#
#
rm -f lfsbootcd.iso
mkisofs -r -V "LFS_$(date +%Y%m%d)" -iso-level 4 -chrp-boot -hfs \
-part -probe -no-desktop \
-hfs-bless $LFS/ppc/mac -map $LFS/boot/map.hfs \
-b ppc/mac/yaboot -no-emul-boot \
-hide-rr-moved -o lfsbootcd.iso $LFS
#
#------------------- end copy and paste ---------------------------
9a) Burn the ISO image
The ISO image lfsbootcd.iso is complete. Either use your favorite
CD burning tools to burn it or use the cdrecord utility as such:
Note!
dev=0,0,0 is the device number of your CD-Writer
Check your SCSI devices with "cdrecord -scanbus"
speed=4 should be changed to (max) speed of your CD-Writer.
If you are using a CD-RW add blank=fast to the cdrecord-command!
cat lfsbootcd.iso |cdrecord -v -eject dev=0,0,0 speed=4 -
10. Reboot and enjoy
----------------
Reboot and let your Bios boot from CD. (On PowerPC press the
and hold the 'c' key after reset).
/tmp will have lots of free space (approx 1/2 of your RAM).
The remaining 'writable' directories (/home and such) will
have about 10meg of free space for you to use.
Enjoy the kernel messages and login prompt ;-)
------------------------------------------------------------------
ACKNOWLEDGEMENTS:
Special thanks for bug reports and help to:
David Maus <oneyed@gmx.de>
CHANGELOG:
[2002-11-19]
* Initial hint.
Thomas Foecking <thomas@foecking.de>
Christian Hesse <mail@earthworm.de>
[2011-03-12]
Updated: Jimmy Anderson <jimmy.anderson1057@gmail.com>
Updated to current LFS, added /usr/compression and
building for PowerPC. Adjusted hint format to template.