Linux Bootdisk HOWTO (part 2/2)

Linux Bootdisk HOWTO (part 2/2)

Post by Graham Chapma » Wed, 03 Jan 1996 04:00:00

Archive-name: linux/howto/bootdisk/part2
Last-modified: 25 Jun 95


*** The `Linux Bootdisk HOWTO' is posted automatically by the
*** Linux HOWTO coordinator, Greg Hankins <>.  Please
*** direct any comments or questions about this HOWTO to the author,
*** Graham Chapman <>.

- --- BEGIN Linux Bootdisk HOWTO part 2/2 ---

  4.2.  Shell Scripts to Build Diskettes

  These shell scripts are provided as examples only. I no longer use
  them because I now use and recommend Scott Burkett's Bootkit package
  to manage rescue diskette contents and creation. Bootkit is based on
  these scripts, and does essentially the same thing, but it is much
  tidier, nicer and easier to use. However, the sample shell scripts
  here will still provide working diskettes.

  There are two shell scripts:

  o  mkroot - builds a root or boot/root diskette.

  o  mkutil - builds a utility diskette.

  Both are currently configured to run in the parent directory of
  boot_disk and util_disk, each of which contains everything to be
  copied to it's diskette. Note that these shell scripts will *NOT*
  automatically set up and copy all the files for you - you work out
  which files are needed, set up the directories and copy the files to
  those directories. The shell scripts are samples which will copy the
  contents of those directories. Note that they are primitive shell
  scripts and are not meant for the novice user.

  The scripts both contain configuration variables at the start which
  allow them to be easily configured to run anywhere.  First, set up the
  model directories and copy all the required files into them. To see
  what directories and files are needed, have a look at the sample
  directory listings in the previous sections.

  Check the configuration variables in the shell scripts and change them
  as required before running the scripts.

  4.2.1.  mkroot - Make Root or Boot/Root Diskette

  # mkroot: make a boot/boot disk - creates a boot/root diskette
  #       by building a file system on it, then mounting it and
  #       copying required files from a model.
  #       Note: the model to copy from from must dirst be set up,
  #       then change the configuration variables below to suit
  #       your system.
  # usage: mkroot [nokernel]
  #       if the parameter is omitted, then the kernel and LILO
  #       are copied.

  # Copyright (c) Graham Chapman 1995. All rights reserved.
  # Permission is granted for this material to be freely
  # used and distributed, provided the source is acknowledged.
  # No warranty of any kind is provided. You use this material
  # at your own risk.

  # Configuration variables...
  BOOTDISKDIR=./boot_disk       # name of boot disk directory
  MOUNTPOINT=./mnt              # temporary mount point for diskette
  LILODIR=/sbin                 # directory containing lilo
  LILOBOOT=/boot/boot.b         # lilo boot sector
  LILOMSG=./lilo.msg            # lilo message to display at boot time
  LILOCONFIG=./lilo.conf        # lilo parms for boot/root diskette
  DISKETTEDEV=/dev/fd0          # device name of diskette drive

  echo $0: create boot/root diskette
  echo Warning: data on diskette will be overwritten!
  echo Insert diskette in $DISKETTEDEV and and press any key...
  read anything

  if [ $? -ne 0 ]
          echo mke2fs failed

  if [ $? -ne 0 ]
          echo mount failed

  # copy the directories containing files
  for i in bin etc lib
          cp -dpr $BOOTDISKDIR/$i $MOUNTPOINT

  # copy dev *without* trying to copy the files in it

  # create empty directories required
  mkdir $MOUNTPOINT/proc
  mkdir $MOUNTPOINT/tmp
  mkdir $MOUNTPOINT/mnt
  mkdir $MOUNTPOINT/usr

  # copy the kernel
  if [ "$1" != "nokernel" ]
          echo "Copying kernel"
          cp $BOOTDISKDIR/zImage $MOUNTPOINT
          echo kernel copied

          # setup lilo
          $LILODIR/lilo -C $LILOCONFIG
          echo LILO installed

  umount $MOUNTPOINT

  echo Root diskette complete

  4.2.2.  mkutil - Make Utility Diskette

  # mkutil: make a utility diskette - creates a utility diskette
  #       by building a file system on it, then mounting it and
  #       copying required files from a model.
  #       Note: the model to copy from from must first be set up,
  #       then change the configuration variables below to suit
  #       your system.

  # Copyright (c) Graham Chapman 1995. All rights reserved.
  # Permission is granted for this material to be freely
  # used and distributed, provided the source is acknowledged.
  # No warranty of any kind is provided. You use this material
  # at your own risk.

  # Configuration variables...
  UTILDISKDIR=./util_disk       # name of directory containing model
  MOUNTPOINT=./mnt              # temporary mount point for diskette
  DISKETTEDEV=/dev/fd0          # device name of diskette drive

  echo $0: create utility diskette
  echo Warning: data on diskette will be overwritten!
  echo Insert diskette in $DISKETTEDEV and and press any key...
  read anything

  if [ $? -ne 0 ]
          echo mke2fs failed

  # Any file system type would do here
  if [ $? -ne 0 ]
          echo mount failed

  # copy the directories containing files

  umount $MOUNTPOINT

  echo Utility diskette complete

  5.  FAQ

  5.1.  Q. How can I make a boot disk with a XXX driver?

  The easiest way is to obtain a Slackware kernel from your nearest
  Slackware mirror site. Slackware kernels are generic kernels which
  atttempt to include drivers for as many devices as possible, so if you
  have a SCSI or IDE controller, chances are that a driver for it is
  included in the Slackware kernel.

  Go to the a1 directory and select either IDE or SCSI kernel depending
  on the type of controller you have. Check the xxxxkern.cfg file for
  the selected kernel to see the drivers which have been included in
  that kernel. If the device you want is in that list, then the
  corresponding kernel should boot your computer. Download the
  xxxxkern.tgz file and copy it to your boot diskette as described above
  in the section on making boot disks.

  You must then check the root device in the kernel, using the rdev

               rdev zImage

  Rdev will then display the current root device in the kernel. If this
  is not the same as the root device you want, then use rdev to change
  it.  For example, the kernel I tried was set to /dev/sda2, but my root
  scsi partition is /dev/sda8. To use a root diskette, you would have to
  use the command:

               rdev zImage /dev/fd0

  If you want to know how to set up a Slackware root disk as well,
  that's outside the scope of this HOWTO, so I suggest you check the
  Linux Install Guide or get the Slackware distribution. See the section
  in this HOWTO titled "References".

  5.2.  Q. How do I update my boot floppy with a new kernel?

  Just copy the kernel to your boot diskette using the dd command for a
  boot diskette without a filesystem, or the cp command for a boot/root
  disk. Refer to the section in this HOWTO titled "Boot" for details on
  creating a boot disk. The description applies equally to updating a
  kernel on a boot disk.

  5.3.  Q. How do I remove LILO so that I can use DOS to boot again?

  This is not really a Bootdisk topic, but it is asked so often, so: the
  answer is, use the DOS command:

               FDISK /MBR

  MBR stands for Master Boot Record, and it replaces the boot sector
  with a clean DOS one, without affecting the partition table. Some
  purists disagree with this, but even the author of LILO, Werner
  Almesberger, suggests it. It is easy, and it works.

  You can also use the dd command to copy the backup saved by LILO to
  the boot sector - refer to the LILO documentation if you wish to do

  5.4.  Q. How can I boot if I've lost my kernel AND my boot disk?

  If you don't have a boot disk standing by, then probably the easiest
  method is to obtain a Slackware kernel for your disk controller type
  (IDE or SCSI) as described above for "How do I make a boot disk with a
  XXX driver?". You can then boot your computer using this kernel, then
  repair whatever damage there is.

  The kernel you get may not have the root device set to the disk type
  and partition you want. For example, Slackware's generic scsi kernel
  has the root device set to /dev/sda2, whereas my root Linux partition
  happens to be /dev/sda8. In this case the root device in the kernel
  will have to be changed.

  You can still change the root device and ramdisk settings in the
  kernel even if all you have is a kernel, and some other operating
  system, such as DOS.

  Rdev changes kernel settings by changing the values at fixed offsets
  in the kernel file, so you can do the same if you have a hex editor
  available on whatever systems you do still have running - for example,
  Norton Utilities Disk Editor under DOS.  You then need to check and if
  necessary change the values in the kernel at the following offsets:

       0x01F8  Low byte of RAMDISK size
       0x01F9  High byte of RAMDISK size
       0x01FC  Root minor device number - see below
       0X01FD  Root major device number - see below

  The ramdisk size is the number of blocks of ramdisk to create.  If you
  want to boot from a root diskette then set this to decimal 1440, which
  is 0x05A0, thus set offset 0x01F8 to 0xA0 and offset 0x01F9 to 0x05.
  This will allocate enough space for a 1.4Mb diskette.

  The major and minor device numbers must be set to the device you want
  to mount your root filesystem on. Some useful values to select from

       device          major minor
       /dev/fd0            2     0   1st floppy drive
       /dev/hda1           3     1   partition 1 on 1st IDE drive
       /dev/sda1           8     1   partition 1 on 1st scsi drive
       /dev/sda8           8     8   partition 8 on 1st scsi drive

  Once you have set these values then you can write the file to a
  diskette using either Norton Utilities Disk Editor, or a program
  called rawrite.exe. This program is included in several distributions,
  including the SLS and Slackware distributions.  It is a DOS program
  which writes a file to the "raw" disk, starting at the boot sector,
  instead of writing it to the file system. If you use Norton Utilities,
  then you must write the file to a physical disk starting at the
  beginning of the disk.

  5.5.  Q. How can I make extra copies of boot/root diskettes?

  It is never desirable to have just one set of rescue disks - 2 or 3
  should be kept in case one is unreadable.

  The easiest way of making copies of any diskettes, including bootable
  and utility diskettes, is to use the dd command to copy the contents
  of the original diskette to a file on your hard drive, and then use
  the same command to copy the file back to a new diskette.  Note that
  you do not need to, and should not, mount the diskettes, because dd
  uses the raw device interface.

  To copy the original, enter the command:

               dd if=devicename of=filename
               where   devicename the device name of the diskette
               and     filename the name of the file where you
                       want to copy to

  For example, to copy from /dev/fd0 to a temporary file called
  /tmp/diskette.copy, I would enter the command:

               dd if=/dev/fd0 of=/tmp/diskette.copy

  Omitting the "count" parameter, as we have done here, means that the
  whole diskette of 2880 (for a high-density) blocks will be copied.

  To copy the resulting file back to a new diskette, insert the new
  diskette and enter the reverse command:

               dd if=filename of=devicename

  Note that the above discussion assumes that you have only one diskette
  drive. If you have two of the same type, then you can copy diskettes
  using a command like:

               dd if=/dev/fd0 of=/dev/fd1

  5.6.  Q. How can I boot without typing in "ahaxxxx=nn,nn,nn" every

  Where a disk device cannot be autodetected it is necessary to supply
  the kernel with a command device parameter string, such as:


  This parameter string can be supplied in several ways using LILO:

  o  By entering it on the command line every time the system is booted
     via LILO. This is boring, though.

  o  By using the LILO "lock" keyword to make it store the command line
     as the default command line, so that LILO will use the same options
     every time it boots.

  o  By using the APPEND statement in the lilo config file. Note that
     the parameter string must be enclosed in quotes.

  For example, a sample command line using the above parameter string
  would be:

               zImage  aha152x=0x340,11,3,1 root=/dev/sda1 lock

  This would pass the device parameter string through, and also ask the
  kernel to set the root device to /dev/sda1 and save the whole command
  line and reuse it for all future boots.

  A sample APPEND statement is:

               APPEND = "aha152x=0x340,11,3,1"

  Note that the parameter string must NOT be enclosed in quotes on the
  command line, but it MUST be enclosed in quotes in the APPEND

  Note also that for the parameter string to be acted on, the kernel
  must contain the driver for that disk type. If it does not, then there
  is nothing listening for the parameter string, and you will have to
  rebuild the kernel to include the required driver. For details on
  rebuilding the kernel, cd to /usr/src/linux and read the README, and
  read the Linux FAQ and Installation HOWTO. Alternatively you could
  obtain a generic kernel for the disk type and install that.

  Readers are strongly urged to read the LILO documentation before
  experimenting with LILO installation. Incautious use of the "BOOT"
  statement can damage partitions.

  5.7.  Q. How can I create an oversize ramdisk filesystem?

  An oversize ramdisk filesystem is a filesystem in a ramdisk larger
  than the size of the root disk it was loaded from. This can be
  extremely useful when using Ftape, which requires exclusive use of the
  floppy disk controller (see the Ftape HOWTO for details.)

  Two things are required: create an oversize file system on the root
  diskette, and then patch the kernel so that it will not try to load
  blocks off the end of the diskette.

  To create an oversize filesystem, two methods are possible:

  o  Use the "blocks" e2fsck parameter to specify the size of filesystem
     that you eventually want in the ramdisk. For example:

               mke2fs /dev/fd0 3000

  will create a filesystem on the diskette of 3000 1Kb blocks. The
  diskette only has 1440 blocks, but mke2fs does not care about this.
  E2fs will care about it if you try to use more than 1440 blocks of
  data (allowing for blocks used as inodes and reserved etc), but up to
  this point it is quite safe. You will soon find out if you try to load
  too much on the diskette because an I/O error will result.

  o  Create a partition on your hard disk as large as the filesystem you
     want on the ramdisk. Then create a filesystem on it and load in the
     files you want. Then use dd to copy only the first 1440 blocks to
     diskette, and then check that there was nothing in the uncopied
     part of the filesystem. For example:

               dd if=/dev/hdb of=/dev/fd0 bs=1024 count=1440
               dd if=/dev/hdb of=tailpart bs=1024 skip=1440
               cmp -l tailparm /dev/zero

  Of the two, I prefer the first method - it appears easier and safer.

  The second thing required to get an oversized filesystem is to get the
  kernel to stop loading at the end of the physical diskette when it
  tries to load the root diskette into ramdisk. To do this, a simple
  patch can be applied to the ramdisk driver, which should be found in
  /usr/src/linux/drivers/block/ramdisk.c. The following patch has been
  contributed by Bruce Elliot. It is for kernel version 1.2.0, but it
  should be fairly easy to apply to later versions. Even if the patch
  will not apply, the code is not complex, so the patch could easily be
  modified until it worked.

  X--- ramdisk.c~ Mon Jan 23 13:04:09 1995
  X+++ ramdisk.c  Mon May 29 00:54:52 1995
  X@@ -113,6 +113,7 @@
  X               (struct ext2_super_block *)&sb;
  X       int             block, tries;
  X       int             i = 1;
  X+      int             fblocks;
  X       int             nblocks;
  X       char            *cp;
  X@@ -168,12 +169,16 @@
  X                                       nblocks, rd_length >> BLOCK_SIZE_BITS);
  X                       return;
  X               }
  X-              printk("RAMDISK: Loading %d blocks into RAM disk", nblocks);
  X+              fblocks = blk_size[MAJOR(ROOT_DEV)][MINOR(ROOT_DEV)];
  X+              if (fblocks > nblocks)
  X+                      fblocks = nblocks;
  X+              printk("RAMDISK: Loading %d blocks into %d block filesystem "
  X+                                      "in RAM disk", fblocks, nblocks);
  X               /* We found an image file system.  Load it into core! */
  X               cp = rd_start;
  X-              while (nblocks) {
  X-                      if (nblocks > 2)
  X+              while (fblocks) {
  X+                      if (fblocks > 2)
  X                               bh = breada(ROOT_DEV, block, BLOCK_SIZE, 0,  PAGE_SIZE);
  X                       else
  X                               bh = bread(ROOT_DEV, block, BLOCK_SIZE);
  X@@ -184,7 +189,7 @@
  X                       }
  X                       (void) memcpy(cp, bh->b_data, BLOCK_SIZE);
  X                       brelse(bh);
  X-                      if (!(nblocks-- & 15)) printk(".");
  X+                      if (!(fblocks-- & 15)) printk(".");
  X                       cp += BLOCK_SIZE;
  X                       block++;
  X                       i++;

  With this patch, the kernel stops loading at the end of the physical
  diskette, leaving a filesystem larger than the disk.

  Some warnings: I have been able to create stable ramdisk filesystems
  in this fashion of 3500 blocks, but if I try 3600 or more then the
  kernel collapses with an error something like "fixup table corrupt".
  I have not been able to track down why, but obviously something is
  overflowing. Up to 3500 blocks, though, I have had no problems.

  5.8.  Q. At boot time, I get error A: cannot execute B. Why?

  There are several cases of program names being hardcoded in various
  utilities. These cases do not occur everywhere, but they may explain
  why an executable apparently cannot be found on your system even
  though you can see that it is there. You can find out if a given
  program has the name of another hardcoded by using the "strings"
  command and piping the output through grep.

  Known examples of hardcoding are:

  o  Shutdown in some versions has /etc/reboot hardcoded, so reboot must
     be placed in the /etc directory.

  o  Init has caused problems for at least one person, with the kernel
     being unable to find init.

     To fix these problems, either move the programs to the correct
     directory, or change configuration files (e.g. inittab) to point to
     the correct directory. If in doubt, put programs in the same
     directories as they are on your hard disk, and use the same inittab
     and /etc/rc.d files as they appear on your hard disk.

  6.  References

  In this section, vvv is used in package names in place of the version,
  to avoid referring here to specific versions. When retrieving a
  package, always get the latest version unless you have good reasons
  for not doing so.

  6.1.  LILO - Linux Loader

  Written by Werner Almesberger. Excellent boot loader, and the
  documentation includes information on the boot sector contents and the
  early stages of the boot process.

  Ftp from: /pub/linux/packages/lilo/lilo.vvv.tar.gz
  also on sunsite and mirror sites.

  6.2.  Linux FAQ and HOWTOs

  These are available from many sources. Look at the usenet newsgroups
  news.answers and comp.os.linux.announce.

  Ftp from:

  o  FAQ is in /pub/linux/docs/faqs/linux-faq

  o  HOWTOs are in /pub/Linux/docs/HOWTO

  For WWW, start at the Linux documentation home page:

  If desperate, send mail to:


  with the word "help" in the message, then follow the mailed

  Note: if you haven't read the Linux FAQ and related documents such as
  the Linux Installation HOWTO and the Linux Install Guide, then you
  should not be trying to build boot diskettes.

  6.3.  Rescue Packages

  6.3.1.  Bootkit

  Written by Scott Burkett. Bootkit provides a flexible menu-driven
  framework for managing rescue disk creation and contents. It uses the
  Dialog package to provide nice menus, and a straight-forward directory
  tree to contain definitions of rescue disk contents. The package
  includes samples of the main files needed. The package aims to provide
  only the framework; it is up to the user to work out what to put on
  the disks and set up the config files accordingly.  For those users
  who don't mind doing this, it is a good choice.  I use this package

  Ftp from: /pub/Linux/system/Recovery/Bootkit-

  6.3.2.  CatRescue

  Written by Oleg Kibirev. This package concentrates on saving space on
  the rescue diskettes by extensive use of compression, and by
  implementing executables as shells scripts. The doco includes some
  tips on what to do in various disaster situations.

  Ftp from:

  6.3.3.  Rescue Shell Scripts

  Written by Thomas Heiling. This contains shell scripts to produce boot
  and boot/root diskettes. It has some dependencies on specific versions
  of other software such as LILO, and so might need some effort to
  convert to your system, but it might be useful as a starting point if
  you wanted more comprehensive shell scripts than are provided in this

  Ftp from:

  6.3.4.  SAR - Search and Rescue

  Written by Karel Kubat. SAR produces a rescue diskette, using several
  techniques to minimize the space required on the diskette.  The manual
  includes a description of the Linux boot/login process.

  Ftp from:

  The manual is available via WWW from:

  6.4.  Slackware Distribution

  Apart from being one of the more popular Linux distributions around,
  it is also a good place to get a generic kernel. It is available from
  almost everywhere, so there is little point in putting addresses here.

- --- END Linux Bootdisk HOWTO part 2/2 ---

Version: 2.6.2
Comment: finger for public key