linuxrc boot | /etc/init.d/boot | /etc/init.d/boot.ramdisk

ariane Boot Sequence

ariane boots in two stages. First runs the linuxrc script from the initial ramdisk which doesn't have anything to do with the ariane system itself. Only after this has succesfully done the work of installing ariane into a ramdisk, the ariane boot happens.

linuxrc boot

This is where the whole thing starts. After the linux kernel and initial ramdisk is loaded the kernel mounts the initial ramdisk as root directory "/" and executes the script linuxrc in single process mode with root permissons. This script is required to do anything what the target system needs for it's boot.

1. Read the kernel's boot prompt parameters and convert them into environment variables.

2. Locate the source device (the device with the linux.tgz archive) by trying to mount the devices /dev/sda1, /dev/hda ... /dev/hdf in that order. The first device that can be mounted and has the directory bootcode in it's root directory is considered to be the source device.

3. If the previous step didn't return a usable device wait for 5 seconds, then try again to access /dev/sda1. The delay of 5 seconds should give the kernel enough time to recognize a USB memory device as /dev/sda1 if it didn't already do this.

4. If there's still no source device fail by starting an akanga shell.

5. Otherwise accept linux.cgz or linux.tgz in the device's package directoy as target archive and call /sbin/ariane/loadimage to install it into /dev/ram7:

1. Allocate 128MB of RAM for the ramdisk device /dev/ram7 which is formatted as ext2 filesystem.

2. The target image is unpacked into the ramdisk either using tar or cpio.

3. The target's system /etc/fstab is replaced by another one which uses /dev/ram7 as root device.

4. The files /var/log/messages, /var/log/wtmp and /var/run/wtmp are created inside the installed target system.

5. The kernel's boot prompt parameters are written to /var/adm/boot.conf.

6. If the boot parameter ki (short for "keep initrd") is "yes" the directory /initrd is created inside the unpacked image to keep the ramdisk available after it's not longer used.

7. If the just unpacked system conatins the script /sbin/linuxrc it's run inside the target system.

8. If the kernel's boot parameter shell is "target" an interactive bash is started inside the target system.

9. Finally /dev/ram7's device number is written to /proc/sys/kernel/real-root-dev.
6. After the target system has been installed an akanga shell is started inside the initial ramdisk if the kernel's boot parameter shell is either "yes" or "debug".

There are perhaps some things to notice here:

1. The whole bootup sequence is based on giotto. This is old fashioned and while I was working on it I noticed some comments in the kernel documentation that this old style will be discontinued in the future. It does however still work, at least to boot ariane.

2. The boot process till here doesn't know anything about ariane. It will unpack and start any linux.cgz or linux.tgz found on an IDE CD-ROM in the /bootcode directory as long as it fits into a ramdisk of 128MB.

3. The shell boot parameter may be a comma spearated list of values, e.g. giving "shell=debug,target" will give you the target's system shell (bash) and the debug shell.

The following things happen in the installed ariane system.

/etc/init.d/boot

This is the main boot script. it's executed before init does anything else. The important things it does are

1. Determine the system's root device (the device which is mounted as"/"). If this is not /dev/ram7 the script assumes that the root device is a real device like a harddisk (you can install ariane on a harddisk) and runs an fsck on it.

2. The swap partitions (if any) are activated.

3. The CD-ROM drive is located and linked to /dev/cdrom using the kernel's boot messages.

4. /etc/keymap.gz is installed as the system's key map and /etc/ttyfont.gz is used for the character font. If you didn't already notice, ariane comes with a German keymap as default.

5. The hostname option is read from /etc/options.conf and set as the system's hostname.

6. If ariane boots in a ramdisk (see above) and it's not a hibernation boot, the script /etc/init.d/boot.ramdisk is called and finally (after boot.ramdisk has been done or not) /etc/init.d/boot.local and /etc/boot.local are executed if they exist.

/etc/init.d/boot.ramdisk

This script is only executed if ariane runs inside a ramdisk (more precise: if it finds that it is running on the device /dev/ram7) and it's not a hibernation boot. It's called from /etc/init.d/boot.

The boot.ramdisk script determines if ariane was booted from PXE or a CD-ROM. This is done by checking if it finds either the ip or tftpserver parameter set. For the ip parameter is doesn't matter if it was supplied by pxelinux or by the user at the boot loader prompt.

1. Assign /var/adm/boot.conf as configuration options file for this script.

2. If it's not a PXE boot ariane tries to mount the devices /dev/sda1 (USB memory device if there are no other SCSI devices), /dev/fd0 and /dev/cdrom. For each device ariane checks if the device has the directory bootcode in it's root. The search stops with the first device matching this condition. If the boot device could be found ariane appends the file /bootcode/boot.conf to it's options file.

3. Check again if the modified options file contains an ip parameter. If yes PXE boot is considered.

4. If it's still not a PXE boot:

1. Load any package files set with the install option from the boot devices /bootcode directory.

2. Check if the config option is set. If it's "yes" then load configuration files from the boot devices /etc directory. Otherwise (and if the value is not "no") consider the config option's value as name of the directory which contains the configuration files to load.

3. If the script /bootcode/boot.ramdisk exists, copy it to /var/adm/boot.ramdisk for later execution.
5. If it's a PXE boot:

1. If no ipnumber is assigned inside the ip parameter then ariane detects the available network cards, loads their drivers and tries to obtain an IP-number with DHCP.

2. If an IP-number was neither set nor obtained in the previous step or no tftpserver was assigned boot.ramdisk terminates here with an error message.

3. Check on which network card the IP-number was assigned by activating each card trying to ping the given tftpserver. The first interface that returns the ping packets becomes the PXE card and the first network card in /etc/module.conf. Again, if no card was found usable boot.ramdisk terminates with an error message.

4. Fetch the file boot.conf from the TFTP server's root directory and append it to the boot options file.

5. Fetch each package given in the install option the package is loaded from the TFTP server's root directory and installed when all packages have been retrieved.

6. Check the config option, if it's "yes" the system's configurations files are loaded from the TFTP server's /etc directory. Otherwise (if the option's value is not "no") the config value is used as directory on the TFTP server from which the files should be loaded.

7. Fetch the file boot.ramdisk from the TFTP server's root directory for later execution as /var/adm/boot.ramdisk.
6. Check if the keymap option is set. If yes activate the keymap and modify the link to /etc/keymap.gz.

7. Run network card autodetection and update the system's /etc/module.conf. The cardlist boot parameter can be set to "no" to disable autodetection or to a comma separated list of network modules in cases where the network cards can not be autodetected. In case of a PXE boot the PXE card remains eth0.

8. Check if the dhcp option is set to either "yes" or the name of network card. If yes, then set DHCP in the system's option file (in case of "dhcp=yes" DHCP is set on eth0). Otherwise the system's option file is not changed.

9. Check if the setip option is set to either "yes" or a static interface configuration in the form "ipnum/mask". If the value is "yes" and an IP configuration was obtained by either a kernel boot option, a boot.conf option or a PXE boot this IP-number is configured as eth0's static IP number in the target system's option file. If a static IP configuration is found this one is set.

10. Run /var/adm/boot.ramdisk (fetched earlier from the installation source) if it exists.