If the boot device is a local hard disk, the sector loaded is the MBR - Master Boot Record - which then loads the boot sector into memory and passes control of the boot process to it. Up to this point, the boot process is OS and disk-format independent.

The first-stage boot-loader (installed via the MBR) then locates the second-stage boot-loader (normally GRUB when booting under DICE), and loads and runs that which, in turn, loads and runs the kernel (passing control to that kernel).

The Install Process and the role of InstallRoot

• installation from customised CD, and
• installation over the network via a network boot environment (normally PXE)

Both methods involve an initial BIOS utility to select the boot method, followed by the loading of the relevant type of SYSLINUX boot-loader - which then prompts for installation method or version, and goes on to load the kernel image and hand control over to it.

Once the kernel is loaded and run, it starts the installroot process - which prompts for the type of installation required (source media or OS version), and the machine configuration and installation begins.

During the DICE install phase, GRUB is not used - instead, a SYSLINUX image is loaded (the isolinux boot loader, isolinux.bin, directly from the CD - or the pxelinux boot-loader, pxelinux.0, over the network). The version of isolinux.bin on CD is copied from /usr/lib/syslinux/isolinux.bin (provided by the Redhat RPM syslinux-3.10), and is part of the CD image created by the BuildInstallRoot process.

Install procedure from CD

ISOLINUX

A program to boot Linux kernels off a CD-ROM using the El Torito boot standard in "no emulation" mode, making the entire filesystem available. It is based on the SYSLINUX boot loader for MS-DOS floppies.

1. system powers on, and BIOS is run
2. F12 interrupts boot process, and BIOS "Boot Device Menu" is displayed
3. "CD-ROM" selected from boot options
4. isolinux boot-loader, isolinux.bin, is loaded from CD
   (it displays the header "ISOLINUX <version> <date>...")
5. isolinux boot-loader runs (behaviour dictated by isolinux.cfg) and presents LCFG boot options
   (displaying the header "LCFG (ng)...", and options contained in boot.msg)
6. "cd" selected from boot options
7. boot loader loads compressed vmlinux (/boot/vmlinuz) image.
8. boot loader unpacks and runs the kernel
   (displaying the message "Uncompressing Linux... Ok, booting the kernel")

  -b	isolinux/isolinux.bin
  -c	isolinux/boot.cat

The BIOS, by means of interrupts (INT 13, INT 19), accesses the "Booting Catalog" in the CD-ROM header and verifies the existence of a boot image on the CD ROM. If verified, it reads the Initial/Default Entry and boots from the disk image specified in this entry which points to isolinux.bin (details of how this happens need not concern us here!). The default behaviour when booting from a CD is to redirect boot floppy access requests to the CD - but the use of ISOLINUX makes this unnecessary.

Once the isolinux boot-loader has loaded, it parses the config file /isolinux/isolinux.cfg (supplied on CD, and created as part of the BuildInstallRoot process) to find out what install options are available, and how to implement them (as already mentioned, ISOLINUX can read all the files on an ISO9660 format CD).

serial 0 9600
default cd
prompt 1
timeout 600
display boot.msg

label cd
  kernel vmlinuz
  append root=/dev/hdc sushell=/etc/rc_install ramdisk_size=8192
...

...
Type one of the following :-

    <CR>         boot off CD
    cd           boot off CD
    serial       boot off CD (serial console)
    floppy       boot off CD (IP configuration via floppy)
    rescue       boot off CD (drops to shell)
    disk         boot off hard disk
    hd[a-c]      boot off hd[a-c]
    ...

The boot-loader (isolinux) then loads the (customised) compressed kernel image (/isolinux/vmlinuz) into memory (retained as /boot/vmlinuz after install). The customised kernel is generated by the Managed Platform Unit.

NOTE: the ramdisk image (/boot/initrd-<version-build-OS>.img) is not needed for CD install, but is used via PXE (to load drivers necessary to boot the system).

Once the kernel is loaded into memory, the boot-loader hands control of the boot process to it:

Uncompressing Linux... Ok. Booting the kernel

If the boot fails, PXELINUX (unlike SYSLINUX) will not wait forever - if it has not received any input for approximately five minutes after displaying an error message, it will reset the machine. This allows an unattended machine to recover in case it tried to boot from a unresponsive server.

Overview

1. system powers on, and BIOS is run
2. F12 interrupts boot process, and BIOS "Boot Device Menu" is displayed
3. "Integrated NIC" selected from boot options
4. pxelinux boot-loader, pxelinux.0, is loaded from TFTP server ("PXELINUX <version> <date>")...
5. pxelinux boot-loader runs (behaviour dictated by pxelinux.cfg/81D4) and displays LCFG boot options offered via lcfgbootblurb.
6. "<OS version>" selected from boot options
7. boot loader loads compressed vmlinux (/boot/vmlinuz) and initrd.gz images.
8. boot loader unpacks kernel and ram disk images, and runs the kernel ("Uncompressing Linux... Ok, booting the kernel")

The PXELINUX boot-loader /tftpboot/pxelinux.0 is downloaded via TFTP from DHCP/TFTP server (the ".0" extension is recognised by PXELINUX as a PXE bootstrap program file).

Behaviour of this boot-loader is controlled by associated configuration information, which pxelinux.0 looks for in a filename determined by the IP address of the client it is running on. The current default is to use /tftpboot/pxelinux.cfg/81D7 (for anything on 129.215):

default fc5
timeout 100
prompt 1
display lcfgbootblurb
allowoptions 1

label fc5
  kernel /kernel-pxe-install-fc5/vmlinuz
  append initrd=/kernel-pxe-install-fc5/initrd.gz rw NFS_DIR=/export/linux/installroot/fc5
...

...
fc3:- boot to the fc3 install system
fc5:- boot to the fc5 install system
fc6:- boot to the fc6 install system
fc664:- boot to the fc6 (x86_64) install system
fc3serial:- boot to the fc3 install system with serial console
fc5serial:- boot to the fc5 install system with serial console
fc6serial:- boot to the fc6 install system with serial console
fc664serial:- boot to the fc6 (x86_64) install system with serial console

If the default is taken, or "fc5" is selected, the boot-loader loads /kernel-pxe-install-fc5/vmlinuz and /kernel-pxe-install-fc5/initrd.gz (which contains required drivers, especially all the network drivers), also setting the NFS root directory, NFS_DIR=/export/linux/installroot/fc5.

Once the kernel is loaded into memory, the boot-loader hands control of the boot process to it:

Uncompressing Linux... Ok. Booting the kernel

When the kernel is loaded, it immediately initializes and configures the memory and the various hardware attached to the system, including all processors, I/O subsystems, and storage devices. The kernel then creates a root device, mounts the root partition read-only, and frees any unused memory.

At this point, the kernel is loaded into memory and operational. However, since there are no user applications that allow meaningful input to the system, not much can be done with it. In order to set up the user environment, the kernel executes the /sbin/init program.

The /sbin/init program then co-ordinates the rest of the boot process (via /etc/inittab) and configures the environment. [RHL9]

Once the kernel is running and has access to a filesystem, the init process runs, and the /etc/inittab file is consulted - which (in the install case) contains an instruction to start a single-user shell and wait until it exits:

S0:S:wait:/sbin/sulogin

However, there does not appear to be a similar setting in the corresponding pxelinux.cfg/81D4 file, so how is this set when using PXELINUX?

The sulogin program is run first, rather than /etc/rc_install directly, so that job control is available (and ^C!). The root account is given a null password so that the user isn't prompted for a password by sulogin (no password is requested if /etc/passwd doesn't exist).

Once this is done, it hands over to the installroot (effectively the rc_install script), issuing a message to this effect:

INIT: version 2.86 booting

----------  University of Edinburgh LCFG installroot  ----------
Version:              0.99.35
Date:                 17/02/06 15:40

• LoadLocalCFG()
• MakeDevRW(), MakeVarRW(), & MakeEtcRW()
• InitLoopback()
• LoadKeys()
• Nsswitch()
• SetTZ()
• Depmod()
• ModProbeClass()
• ProbeforSCSIDisk()
• ProbeforIDEDisk()
• ProbeforRAIDDisk()
• ProbeforEtherModule(), ProbeforEther(), & ProbeforEtherPCMCIA()
• LoadFloppyIP() & MountFloppy()
• LoadUSBDiskIP(), MountUSBDisk(), & UnMountUSBDisk()
• ConfigureResolver()
• SetHostname()
• CreateEtcHosts()
• DownloadProfile()
• ReadLCFGURL() & ValidateURL()
• DoReboot()

After issuing a banner giving version and date for the current installroot (as mentioned above), some initial configuration is carried out, and the above subroutines are called as required:

1. The installroot build date is displayed (contained in /build.timestamp at install time).

2. LoadLocalCFG() is called to set environment variables such as locale and timezone, which are set from /etc/installparams.default (and over-ridden by /etc/installparams, if present).

3. Output device is then determined (for example, /dev/console or /dev/tty2)

4. MakeDevRW() is called to create a writeable filesystem in RAM disk, and mounted under /dev. Contents are then copied (via rsync) from the RO location (the boot image) to the writeable directory.

5. /proc & /sys are also created, just after /dev, to allow other configuration tools to communicate with the kernel (for example, the dynamic device management utility, udev).

6. InitLoopback() is called to configure the loopback interface (via ifconfig) and made available (via "route add").

7. The other writeable filesystem locations (/var, and /etc) are created by calling MakeVarRW() & MakeEtcRW(), populated (using rsync), and then remounted (the remainder of the filesystem is still mounted RO from CD, or over the network).

8. The kernel keymap for the console is loaded (via loadkeys) by LoadKeys(). This uses $KEYS_LOCALE, which was loaded from /etc/installparams.

9. Access methods for various services are set up from NssSwitch(), via nsswitch.conf. Other than hosts (which has the option of using DNS), all services are set to use local files.

10. SetTZ() is called, and timezone is set using $DEFAULT_TZ from /etc/installparams (loaded earlier).

11. Explicit kernel module dependencies are set up by DepMod(), which creates /etc/modules.conf (using entries supplied in the rc_install script).

12. Once the module dependencies have been analysed, various modules are loaded into the kernel by ModProbeClass(USB), and then ProbeforSCSIDisk(), ProbeforIDEDisk(), & ProbeforRAIDDisk().

13. ProbeforEther() then tests to see if a configured ethernet network card is present (as determined by ifconfig), and if not, the relevant kernel modules (as determined by kmodule or kudzu) are loaded by ProbeforEtherModule() and a configured ethernet network interface is again tested for. If not found, ProbeforEtherPCMCIA() is called to test for a PCMCIA card.

14. If $LCFG_RESCUE has been defined (selecting the "rescue" option from the boot menu does this), the system drops to a shell. Note that this is done before the install methods are called.

15. If the network configuration above failed (no ethernet card found), the install process finishes and the system drops to a shell.

1. The currently configured hostname is displayed

2. If CD booting "with IP configuration via floppy" was requested at boot time (which sets $LCFG_FLOPPY), then LoadFloppyIP() is called to check for IP configuration information supplied in the file ip.cfg on the floppy.

3. Otherwise, if $LCFG_USBDISK is defined, LoadUSBDiskIP() is called to start D-BUS (system-wide message bus) and HAL (Hardware Abstraction Layer) daemons and check if /media/usbdisk appears, it also sources ip.cfg (if present on USB disk) to load network values.

4. If IP configuration information is not already available (for example, if $DHCP_IPADDR has not been given a value from user-supplied ip.cfg file on floppy or USB device) IP information is requested from a local DHCP server (via /sbin/dhclient, which broadcasts a DHCP request on all local networks and saves the response), having configured each network interface "up" if required (although no hostname is set).

   The server-based configuration information in held in /etc/dhcpd.conf. As well as the host name and IP address, this file contains information such as the network-mounted root filesystem, and location of host profiles.

   The response from the DHCP server is saved in /tmp/dhcp_response, the location of which is determined via /etc/dhclient.conf, which explicitly calls /sbin/dhclient-lcfg-script (would normally default to /sbin/dhclient-script), and this creates the above file based on the DHCP response.

   The /sbin/dhclient-lcfg-script expects instantiated variables which it uses to set LCFG DHCP variables in the response file: /sbin/dhclient exports these to the environment before calling the /sbin/dhclient-lcfg-script. Drop to shell if this fails, otherwise source saved DHCP response - which sets various DHCP variables, including $DHCP_IPADDR, $DHCP_LCFGURL & $DHCP_INTERFACE.

5. Add IP, netmask, and broadcast address to $DHCP_INTERFACE (from dhclient output).
   Add route to local subnet.
   Add default gateway.

6. Next, ConfigureResolver() is called to configure the resolver by creating /etc/resolv.conf and /etc/hesiod.conf, constructing the entries using DHCP variables.

7. Then SetHostname() is called to set hostname (via /bin/ipcalc and IP address, which sets $HOSTNAME), dropping to shell if this fails.

8. The /etc/hosts file is generated by CreateEtcHosts(), containing localhost entry and one for $DHCP_IPADDR.

1. DownloadProfile() is called and, if $DHCP_LCFGURL has been defined (usually http://lcfghost.inf.ed.ac.uk/profiles) and validated by ValidateURL(), it uses "/usr/lib/lcfg/components/client install $DHCP_LCFGURL /" to download the XML to the /var/lcfg/conf/profile/xml directory (note that no hostname is specified - this is determined automagically by lcfghost)
   How is the hostname determined?

2. Prompt for "(I)nstall, (D)ebug, (S)hell, (P)atchup, (R)eboot".
   (The "Debug" option can be used to single-step through the install process.)

3. Assuming "Install" is chosen, the install component (/usr/lib/lcfg/components/install) is run - which calls each component with the "install" method. Components (other than "install") available at installroot time are:
   • auth
   • client
   • dns
   • file
   • fstab
   • grub
   • hardware
   • init
   • kernel
   • logserver
   • network
   • ngeneric
   • nsswitch
   • rpmcache
   • updaterpms
   (the above list is not in execution order).

4. DoReboot() is called to reboot on completion.

• LoadProfile (defined in ngeneric) is called, which uses "qxprof -e install" to export selected resources to the environment variables. (Note that the name "LoadProfile" is a bit of a misnomer - "LoadResources" might have been better.)

Note that the install resources (including install.installmethods) are defined in install.h, which is part of the lcfg/core/include/lcfg/defaults structure.
How does this get pulled in? Presumably it's #included in another header file somewhere? (It's certainly #included from lcfg/core/include/lcfg/defaults.h.)

- once the install methods have been identified (as defined by the install.installmethods resource, which is used to set $LCFG_install_installmethods via "qxprof -e"):

% qxprof install.installmethods
installmethods=
  setctx 
  lcfguser
  lcfggroup
  loadctx
  gettime
  mk_etcfiles
  logserver
  fstab_disks
  mkdir_rpm
  mkdir_lcfgconf
  mkdir_dev
  mkdir_vartmp
  mkdir_etc
  mk_retcfiles
  nsswitch
  auth
  fstab
  hardware
  get_rpmcfg
  copydev
  mkvarlib
  updaterpms
  network
  dns
  grub
  kernel
  setctxnormal
  setctxbase
  clienttarget
  init
  settz_root
  setclock
  configclock
  mkloginstalldir
  loginstall
  umountd
  end
%

• an implicit command
• an explicit command
• a call to a component

An implicit command:

• The install.installmethods resource includes the "lcfguser" method.
• There is a corresponding "imethod_lcfguser" resource, which holds the command to be executed (namely "%oneshot% "echo lcfg:x:980:980:LCFG user:/tmp:/bin/false >> /etc/passwd"").
• The imethod_lcfguser resource is exported to the environment ($LCFG_install_imethod_lcfguser, via "qxprof -e install").
• The command to execute has no command-specific key to match, but does match the general "%oneshot%" key in the install component's 'install' method, and just passes all parameters to be evaluated.

An explicit command:

• The install.installmethods resource includes the "configclock" method.
• There is a corresponding "imethod_configclock" resource, which holds the command to be executed (namely "%configclock% /root").
• The imethod_configclock resource is exported to the environment ($LCFG_install_imethod_configclock, via "qxprof -e install").
• The command to execute is explicitly matched by the install component's 'install' method (using the "%configclock%" key) and runs the "ConfigClock()" subroutine.

A component call:

• The install.installmethods resource includes the "auth" method.
• There is a corresponding "imethod_auth" resource, which holds the command to be executed (namely "auth install /root").
• The imethod_auth resource is exported to the environment ($LCFG_install_imethod_auth, via "qxprof -e install").
• In this example, the command to execute is a component, and - as it doesn't match any of the explicit keys - the component (with parameters) is invoked by the install component's 'install' method using /usr/bin/om plus the environment variable $LCFG_install_imethod_auth.

setctx:

• sets install context to "true"

lcfguser

• creates lcfg entry in passwd file

lcfggroup

• creates lcfg entry in group file

loadctx *

• gets initial profile (load the install context)
  More explanation needed?

gettime

• gets time from NTP servers
  (%gettime% invokes GetTime() with supplied parameters).

mk_etcfiles

• creates /etc/fstab & /etc/mtab

logserver *

• runs 'start' method of logserver component, which starts an HTTP daemon to serve log files and other information about LCFG components.

fstab_disks *

• calls AddDisk(disk, /root)
  - partitions disk according to fstab.partitions_disk resource
  - creates swap or makes ext2/ext3 filesystems as defined by fstab.type_partition resources
  - make specified mount points and mount filesystems.

mkdir_rpm

• creates [/root]/var/lib/rpm directory, to contain RPM management info.

mkdir_lcfgconf

• creates [/root]/var/lcfg/conf directory, to contain LCFG configuration info.

mkdir_dev

• creates [/root]/dev" devices directory only.

mkdir_vartmp

• creates [/root]/var/tmp directory only.

mkdir_etc

• creates [/root]/etc directory only.

mk_retcfiles

• creates /root/etc/fstab & /root/etc/mtab.

nsswitch *

• calls LoadProfile from ngeneric
  - populates the environment with the relevant resources.
• calls BuildNSSwitch(/root)
  - uses $LCFG_nsswitch_maps & $LCFG_nsswitch_mods_$key to build /etc/nsswitch.conf.

auth *

• calls LoadProfile() from ngeneric
  - populates the environment with the relevant resources.
• calls PasswdGroup()
  - writes lcfg user and group entry to /etc/passwd & /etc/group respectively (this must be done before packages are installed on the new machine so that files are installed with the correct ownership). The root password is supplied via sxprof.

fstab *

• calls LoadProfile() from ngeneric
  - populates the environment with the relevant resources.
• copies across template fstab.disk files
• calls Buildfstab(/root)
  - creates /etc/fstab entries for each disk in fstab.disks resource.
• calls MkMountPoint()
  - make mount-point for each filesystem type in fstab.entries resource.
• removes all auto-generated (kudzu/updfstab/hald) entries from /etc/fstab (these will be picked up later).

hardware *

• calls LoadProfile() from ngeneric
  - populates the environment with the relevant resources.
• calls UpdateModuleConf(/root)
  - adds relevant hardware entries to /etc/modprobe.conf using 'sxprof'.
• calls RequestReboot() when /etc/modprobe.conf has changed.

get_rpmcfg

• fetches list of base install (RPMs) after initial install...

/var/lcfg/conf/profile/dbm/
/var/lcfg/conf/profile/ngcomponents.pl
/var/lcfg/conf/profile/rpmcfg/
/var/lcfg/conf/profile/xml/

- and also appropriate versions of diceinstallbase-fc5-develop in the dbm, rpmcfg, and xml directories.

copydev

• copies device files to /root/dev.

mkvarlib

• creates RPM database directory.

updaterpms *

• calls LoadProfile() from ngeneric:
  - populates the environment with the relevant resources.
• runs "/bin/rpm -r /root --initdb" to initialise (create new) RPM database.
• calls UpdateRPMs(/root):
  - using updaterpms.rpmcfg resource, runs /usr/sbin/updaterpms (plus various flags), and then "/bin/rpm --rebuilddb" to rebuild RPM database.
  (runs /usr/sbin/updatepkgs if SunOS)
  - RequestReboot() from ngeneric, which issues reboot message via lcfgmsg.
  - "om kernel configure", which makes sure kernel (file) configuration is up to date.

network *

• calls LoadProfile() from ngeneric
  - populates the environment with the relevant resources.
• calls ConfigureNetwork(/root):
  - rebuilds /etc/sysconfig/network file
  - for each interface in network.interfaces resource, rebuilds /etc/sysconfig/network-scripts/ifcfg-interface file
  - rebuilds /etc/hosts
  - requests reboot via RequestReboot()

dns *

• calls LoadProfile() from ngeneric:
  - populates the environment with the relevant resources.
• creates minimal /etc/resolv.conf file using $DHCP_DOMAINSERVERS & dns.installservers resource

grub *

• calls LoadProfile() from ngeneric:
  - populates the environment with the relevant resources.
• creates configuration files & directories using grub.grubconfdir, grub.localconf, grub.pxegrubconfdir, grub.pxegrubbin, & grub.grubfiles resources.

kernel *

• calls MakeLinks():
  - creates kernel link in /boot
  - creates initrd link (if required)

setctxnormal

• resets install context by zeroing .context file in /var/lcfg/conf/profile/context

setctxbase

• sets installbase context to "true" in .context file.

clienttarget *

• uses rdxprof to read and convert profile (via local file URL, rather than fetching it via HTTP)

init

• calls LoadProfile() from ngeneric:
  - populates the environment with the relevant resources.
• BuildInittab(/root)
  - uses sxprof to generate [/root]/etc/inittab from supplied template
  - runs /sbin/telinit q to force init to re-read inittab.

settz_root

• calls SetTZ(/root)
  - calls LoadProfile() from ngeneric
  - links timezone file to /etc/localtime

setclock

• calls SetClock()
  - sets the hardware clock from current system time

configclock

• calls ConfigClock(/root)
  - sets /etc/sysconfig/clock

mkloginstalldir

• creates install log directory

loginstall

• populates install log directory with contents of /var/lcfg/log

umountd

• unmounts all filesystems

end

• displays final message

And Finally...