booting" -- Technical Information" "

This article discusses the events that take place while booting the COHERENT system. You do not need to read this article to know how to boot COHERENT, as all booting details are handled by COHERENT automatically. However, if you are interested in the details, or want to tailor the system to your needs, it will help.

Two I/O devices are involved in booting. The first device is called the _b_o_o_t device; it contains the program necessary to invoke the COHERENT system and start it running. The second device is called the _r_o_o_t device; it contains the root file system after the system is running. In most cases, these two devices are the same physical device.

Initial Startup

This program, called the bootstrap or secondary boot, is very small (only 512 bytes), so it cannot do very much. Therefore, its main purpose is to read in a larger, more complex program called the tertiary boot, or /tboot. It is /tboot that actually performs the work of loading the COHERENT system into memory.

If the secondary boot does not find a file called /tboot, it print a `?' to prompt for the boot image you want it to load. This indicates a severe error because it means that the tertiary boot can not be found.

If the secondary boot finds /tboot, it loads it into memory and lets it take over booting. The first thing /tboot does is search for a file called /autoboot in the root directory of the device being booted. If /tboot finds /autoboot, it first pauses for five seconds, so you can abort the process and boot another kernel if you wish. If you do not abort booting within five seconds, /tboot then loads /autoboot into memory and runs it. If, however, /tboot cannot find /autoboot, it prompts you to type the name of the COHERENT image to boot, usually /coherent. You can type the commands dir or ls if you do not remember the name of the image you wish to boot. Note that /autoboot is usually a link to /coherent.

If you need to find the file name of the kernel you are now running (usually //ccoohheerreenntt), use the program fifo(), which is kept in library libmisc. See the Lexicon entry libmisc for details.

After it loads the system image /autoboot from the root device, the system initializes all devices, as well as starting the _i_d_l_e process and program /etc/init. The idle process uses any leftover computer time.

init controls the operation of the system from this point on. It first executes the command /etc/brc (i.e., ``boot run commands''), which can run commands like fsck. brc can request a reboot, remain in single- user mode, or enter multi-user mode automatically. init then calls the _s_h_e_l_l to handle commands from the system console. The shell responds by prompting with ##, and expects regular commands. At this point, the system is in _s_i_n_g_l_e_-_u_s_e_r _m_o_d_e, which means that no other users can log in to the system. The shell is running in superuser mode and only the console's user is logged in.

At this point, you can enter commands to the system in a normal fashion. One difference from normal, multi-user operation is that the system is in single-user mode, to allow special processing to take place before other users log in. Being in single-user mode gives you the opportunity to run fsck to check the file system and perform other administrative tasks before other users log into the system.

When administrative activities are finished, you should type &&lltt;;ccttrrll--DD&&ggtt;;. This terminates single-user operation; iinniitt then opens the system to other users.

The file /etc/rc contains shell commands that the system executes just before making the system available to other users. This file typically includes commands to delete temporary files and mount standard devices. It also performs any installation-specific commands you require. As system administrator, you maintain this file. You must be sure that it is properly updated and never removed.

One command that must be included in //eettcc//rrcc is //eettcc//uuppddaattee, which periodically calls sync() to update buffered data to the disk.

init also maintains the file /etc/utmp, which notes users' login and logout.

Features of the Master Bootstrap

The bootstrap can be configured in three ways:

11..

No active partition. With this configuration, you have the greatest degree of flexibility. When you boot your system, the following prompt appears on the screen:

     Select Partition 0-7

This means that you must press the number key that corresponds to the partition that holds the root partition of the operating system you wish to boot. (For example, if you wish to boot COHERENT and its root partition is on partition 2, then press the `2' key in response to this prompt.) If you have one hard drive, only partitions 0 through 3 are relevant to you. The bootstrap waits indefinitely until you tell it what to boot.

22..

COHERENT is active partition. Under this configuration, the system will automatically boot COHERENT unless you press the number key that represents the root partition of another operating system (e.g., MS-DOS) while the A-drive light is on.

33..

MS-DOS (or another operating system) is active partition. Under this configuration, the system automatically boots MS-DOS unless you hit the number key that represents the root partition of another operating system (e.g., COHERENT) while the A-drive light is on.

Files Used During Startup

//eettcc//ddrrvvlldd..aallll

Device tables to load. This usually names the keyboard driver to use, should you be using the keyboard driver vtnkb.

//eettcc//iinniitt

Initiate a process on each terminal line, call login when appropriate.

//eettcc//bbrrcc

Shell commands for booting.

//eettcc//cchheecckklliisstt

List of partitions for ffsscckk to check.

//bbiinn//sshh

Bourne shell.

//bbiinn//kksshh

Korn shell.

//bbiinn//llooggiinn

This file holds the program that controls logging in.

//eettcc//ggeettttyy

This file holds the executable program that permits a user to log in on a port.

//eettcc//llooggmmssgg

This file holds the text of the login prompt.

//eettcc//mmoottdd

This file holds the message of the day.

//eettcc//mmoouunntt..aallll

Shell script to mount partitions.

//eettcc//rrcc

This file holds a series of shell commands that coherent executes when it enters multi-user startup.

//eettcc//ttttyyss

This file is holds information about terminals. Its contents are read by getty to ensure that it sets the port to the correct baud rate and terminal type.

//eettcc//uuttmmpp

This file holds information about who is logged in right now. It is read by the command who.

Building a Bootable Floppy Disk

The following details the steps required to build a version of COHERENT that can be booted off a floppy disk. Note that the following describes an extremely minimal configuration, which can be used only in single-user mode.

11.. Format the Floppy Disk

To begin, format the floppy disk with the command /etc/fdformat. After you format the floppy disk, use the command /etc/mkfs command to write a blank file system onto it.

22.. Write a Bootstrap to the Floppy Disk

To make the floppy disk bootable, you must copy a special program, or bootstrap, into the first sector (or _b_o_o_t _b_l_o_c_k) of the floppy disk. (This is the same program that is called the _s_e_c_o_n_d_a_r_y _b_o_o_t in the above sections.) If a floppy disk is to be bootable, a set of instructions must be present in the boot block that tell the system the name of the kernel -- that is, the file on the floppy disk to be loaded and executed.

To write the bootstrap to the floppy disk, you must copy it to the device that the floppy disk is in. This ensures that the bootstrap is copied to the first sector, or boot block, of the floppy disk. For example, to copy the bootstrap for a 1.2-megabyte floppy disk in floppy drive 0 (or A), type the command:

     cp /conf/boot.fha /dev/fha0

To copy the bootstrap for a 1.44-megabyte floppy disk to floppy drive 0, type the command:

     cp /conf/boot.fva /dev/fva0

33.. WWrriittee TTeerrttiiaarryy BBoooott

After you have copied the boot sector, you must mount the floppy device and copy /tboot to it. To mount a 1.44-megabyte floppy disk to floppy drive 0, type the command:

     /etc/mount /dev/fva0 /f0

Copy /tboot with the following command:

     cp /tboot /f0

Warning: Never mount the floppy disk before you copy the bootstrap to it!

See the Lexicon article on ffllooppppyy ddiisskkss for the table of floppy disk devices to use with the above commands.

44.. Copy the Necessary Files

Once the bootstrap is properly written to the floppy disk, it is now time to copy the essential files to it. Type the following commands:

     mkdir /f0/etc
     mkdir /f0/dev
     mkdir /f0/bin
     mkdir /f0/tmp
     cp /tboot /coherent /coherent.sym /f0
     cp /etc/init /etc/brc /etc/profile /f0/etc
     cp /dev/* /f0/dev
     cp /bin/sh /bin/sync /f0/bin

If you are using either of the loadable keyboard drivers nkt or vtnkb, also execute the following commands:

     mkdir /f0/drv
     mkdir /f0/conf
     mkdir /f0/conf/kbd
     cp /etc/drvld.all /f0/etc
     cp /drv/* /f0/drv
     cp /conf/kbd/* /f0/conf/kbd

The above files will let you run COHERENT in single- user mode, which is all that you need when you boot COHERENT from a floppy disk.

Note that the files /etc/brc and /etc/drvld.all are scripts that you must modify to suit your needs. The file /etc/brc is a key file in the booting process, so be prepared to modify its contents. The significance of this will be reviewed in depth in the next section.

Warning: After you have finished copying files to the floppy disk, execute the command umount to unmount the floppy disk. If you do not, the files will be damaged or lost!

55.. The Boot Sequence, Modifications To Make the Disk Work

When the computer system powers up and accesses the floppy disk, it reads the boot sector of the disk, which in turn looks for the file /tboot and executes it. /tboot looks for the kernel named /autoboot, reads it, and executes it. If /tboot cannot find /autoboot, it prompts you to type the name of the kernel to boot.

The kernel loads and invokes /etc/init which, in part, looks for and executes the statements in /etc/brc, which, in turn, typically loads loadable drivers and runs /etc/fsck to check the file systems. If you wish to run fsck on the floppy disk, you must copy it from the hard drive.

What is truly important is the exit status of /etc/brc. If its exit status is not zero, the system remains in single-user mode. If its exit status is zero, the system attempts to enter multiuser mode.

The above-listed files are the bare minimum for a single-user floppy disk. To build a floppy disk with the minimum files needed, your /etc/brc file should look like this:

     /etc/drvld.all
     exit 1

This forces an exit status of one and causes COHERENT to spawn a single-user shell, /bin/sh.

From the shell prompt, you can do whatever you wish, but you are limited to the commands and functions copied to the floppy disk.

/etc/brc is not the only file that may need modification. The kernel (//ccoohheerreenntt or //aauuttoobboooott) must have the values rootdev and pipedev patched for the floppy disk's major and minor device numbers. This patching can be done with the commands /bin/db or /conf/patch.

To patch the kernel on the floppy disk mounted on /f0 for a 5.25-inch, high-density disk as the root and pipe device, type:

     /conf/patch /f0/coherent rootdev=makedev\(4,14\)
     /conf/patch /f0/coherent pipedev=makedev\(4,14\)

For a 3.5-inch, high-density disk, type:

     /conf/patch /f0/coherent rootdev=makedev\(4,15\)
     /conf/patch /f0/coherent pipedev=makedev\(4,15\)

Uses of a Bootable Floppy Disk

Multiuser-mode floppy disks can also be built for the fun of seeing such a system run from a floppy disk. The capacity of such a system is limited, of course, but it can be done.

See Also

• Administering COHERENT,
• boot,
• libmisc,
• tboot
A

Notes

A If you still wish to shuffle your disk's partition table, be sure to change the name of the root device within the kernel before you change the partition table.