<!doctype linuxdoc system>

<article>

<title>SRM Firmware Howto</title>
<author><url url="mailto:davidm@azstarnet.com" name="David Mosberger">
</author>
<date>v0.5, 17 August 1996
<abstract>
This document describes how to boot Linux/Alpha using the SRM
firmware, which is the firmware normally used to boot DEC Unix.
Generally, it is preferable to use MILO instead of aboot since MILO is
perfectly adapted to the needs of Linux.  However, MILO is not always
available for a particular system and MILO does not presently have the
ability to boot over the network.  In either case, using the SRM
console may be  the right solution.
</abstract>

<toc>

<p> Unless you're interested in technical details, you may want to
skip right to Section <ref id="aboot">.

<sect>How Does SRM Boot an OS?

<p> All versions of SRM can boot from SCSI disks and the versions for
recent platforms, such as the Noname or AlphaStations can boot from
floppy disks as well.  Network booting via <tt/bootp/ is supported.
Note that older SRM versions (notably the one for the Jensen)
<em/cannot/ boot from floppy disks.  Also, booting from IDE disk
drives is unsupported.

<p> Booting Linux with SRM is a two step process: first, SRM loads and
transfers control to the secondary bootstrap loader.  Then the
secondary bootstrap loader sets up the environment for Linux, reads
the kernel image from a disk filesystem and finally transfers control
to Linux.

<p> Currently, there are two secondary bootstrap loaders for Linux:
the <em/raw/ loader that comes with the Linux kernel and <tt/aboot/
which is distributed separately.  These two loaders are described in
more detail below.


<sect1>Loading The Secondary Bootstrap Loader

<p> SRM knows nothing about filesystems or disk-partitions.  It simply
expects that the secondary bootstrap loader occupies a consecutive
range of physical disk sector, starting from a given offset.  The
information on the size of the secondary bootstrap loader and the
offset of its first disk sector is stored in the first 512 byte
sector.  Specifically, the long integer at offset 480 stores the
<em/size/ of the secondary bootstrap loader (in 512-byte blocks) and
the long at offset 488 gives the <em/sector number/ at which the
secondary bootstrap loader starts.  The first sector also stores a
flag-word at offset 496 which is always 0 and a checksum at offset
504.  The checksum is simply the sum of the first 63 long integers in
the first sector.

<p> If the checksum in the first sector is correct, SRM goes ahead and
reads the <em/size/ sectors starting from the sector given in the
<em/sector number/ field and places them in <em/virtual/ memory at
address <tt/0x20000000/.  If the reading completes successfully,
SRM performs a jump to address <tt/0x20000000/.

<sect>The Raw Loader

<p> The sources for this loader can be found in directory

<tscreen><verb>
	linux/arch/alpha/boot
</verb></tscreen>

of the Linux kernel source distribution.  It loads the Linux kernel by
reading <tt/START&lowbar;SIZE/ bytes starting at disk offset
<tt/BOOT&lowbar;SIZE+512/ (also in bytes).  The constants
<tt/START&lowbar;SIZE/ and <tt/BOOT&lowbar;SIZE/ are defined in
<tt>linux/include/asm-alpha/system.h</tt>.  <tt/START&lowbar;SIZE/
must be at least as big as the kernel image (i.e., the size of the
<tt/.text/, <tt/.data/, and <tt/.bss/ segments).  Similarly,
<tt/BOOT&lowbar;SIZE/ must be at least as big as the image of the raw
bootstrap loader.  Both constants should be an integer multiple of the
sector size, which is 512 bytes.  The default values are currently
2MB for <tt/START&lowbar;SIZE/ and 16KB for <tt/BOOT&lowbar;SIZE/.
Note that if you want to boot from a 1.44MB floppy disk, you have to
reduce <tt/START&lowbar;SIZE/ to 1400KB and make sure that the kernel
you want to boot is no bigger than that.

<p> To build a raw loader, simply type <tt/make rawboot/ in
<tt>/usr/src/linux</tt>.  This should produce the following files in
<tt>arch/alpha/boot</tt>:

<descrip>
<tag><tt>tools/lxboot</tt>:</tag> The first
	sector on the disk.  It contains the offset and size of
	the next file in the format described above.
<tag><tt>tools/bootlx</tt>:</tag> The raw boot loader that
	will load the file below.
<tag><tt>vmlinux.nh</tt>:</tag> The raw kernel image consisting of
	the <tt/.text/, <tt/.data/, and <tt/.bss/ segments of the
	object file in <tt>/usr/src/linux/vmlinux</tt>.  The
	extension <tt/.nh/ indicates that this file has no object-file
	header.
</descrip>

<p> The concatenation of these three files should be written to the
disk from which you want to boot.  For example, to boot from a floppy,
insert an empty floppy disk in, say, <tt>/dev/fd0</tt> and then type:
<tscreen><verb>
cat tools/lxboot tools/bootlx vmlinux >/dev/fd0
</verb></tscreen>

<p> You can then shutdown the system and boot from the floppy by
issueing the command <tt/boot dva0/.


<sect>The aboot Loader<label id="aboot">

<p> When using the SRM firmware, <tt/aboot/ is the preferred way of
booting Linux.  It supports:

<itemize>
<item> direct booting from various filesystems (<tt/ext2/, <tt/ISO9660/, and
	<tt/UFS/, the DEC Unix filesystem)
<item> booting of executable object files (both ELF and ECOFF)
<item> booting compressed kernels
<item> network booting (using bootp)
<item> partition tables in DEC Unix format (which is
	compatible with BSD Unix partition tables)
<item> interactive booting and default configurations for
	SRM consoles that cannot pass long option strings
</itemize>


<sect1>Getting and Building aboot

<p> The latest sources for <tt/aboot/ are available in <url
url="ftp://ftp.azstarnet.com/pub/linux/axp/aboot" name="this ftp
directory">.  The description in this manual applies to <tt/aboot/
version 0.5 or newer.

<p> Once you downloaded and extracted the latest tar file, take a look
at the <tt/README/ and <tt/INSTALL/ files for installation hints.  In
particular, be sure to adjust the variables in <tt/Makefile/ and in
<tt>include/config.h</tt> to match your environment.  Normally, you
won't need to change anything when building under Linux, but it is
always a good idea to double check.  If you're satisfied with the
configuration, simply type <tt/make/ to build it (if you're not
building under Linux, be advised that <tt/aboot/ requires GNU
<tt/make/).

After running <tt/make/, the <tt/aboot/ directory should contain the
following files:

<descrip>
<tag>aboot</tag> This is the actual <tt/aboot/ executable (either an
	ECOFF or ELF object file).
<tag>bootlx</tag> Same as above, but it contains only the text, data
	and bss segments---that is, this file is not an object file.
<tag>sdisklabel/writeboot</tag> Utility to install <tt/aboot/ on a
	hard disk.
<tag>tools/e2writeboot</tag> Utility to install <tt/aboot/ on an ext2
	filesystem (usually used for floppies only).
<tag>tools/isomarkboot</tag> Utility to install <tt/aboot/ on a iso9660
	filesystem (used by CD-ROM distributors).
<tag>tools/abootconf</tag> Utility to configure an installed <tt/aboot/.
</descrip>

<sect1>Floppy Installation

<p> The bootloader can be installed on a floppy using the
<tt/e2writeboot/ command (note: this can't be done on a Jensen since
its firmware does <em/not/ support booting from floppy).  This command
requires that the disk is not overly fragmented as it needs to find
enough contiguous file blocks to store the entire <tt/aboot/ image
(currently about 90KB).  If <tt/e2writeboot/ fails because of this,
reformat the floppy and try again (e.g., with <tt/fdformat(1)/).  For
example, the following steps install <tt/aboot/ on floppy disk
assuming the floppy is in drive <tt>/dev/fd0</tt>:

<tscreen><verb>
fdformat /dev/fd0
mke2fs /dev/fd0
e2writeboot /dev/fd0 bootlx
</verb></tscreen>


<sect1>Harddisk Installation

<p> Since the <tt/e2writeboot/ command may fail on highly fragmented
disks and since reformatting a harddisk is not without pain, it is
generally safer to install <tt/aboot/ on a harddisk using the
<tt/swriteboot/ command.  <tt/swriteboot/ requires that the first few
sectors are reserved for booting purposes.  We suggest that the disk
be partitioned such that the first partition starts at an offset of
2048 sectors.  This leaves 1MB of space for storing <tt/aboot/.  On
a properly partitioned disk, it is then possible to install <tt/aboot/
as follows (assuming the disk is <tt>/dev/sda</tt>):

<tscreen><verb>
swriteboot /dev/sda bootlx
</verb></tscreen>

On a Jensen, you will want to leave some more space, since you need to
write a kernel to this place, too---2MB should be sufficient when
using compressed kernels.  Use <tt/swriteboot/ as described in Section
<ref id="booting"> to write <tt/bootlx/ together with the Linux
kernel.

<sect1>CD-ROM Installation

<p> To make a CD-ROM bootable by SRM, simply build <tt/aboot/ as
described above.  Then, make sure that the <tt/bootlx/ file is present
on the iso9660 filesystem (e.g., copy <tt/bootlx/ to the directory
that is the filesystem master, then run <tt/mkisofs/ on that
directory).  After that, all that remains to be done is to mark the
filesystem as SRM bootable.  This is achieved with a command of the
form:

<tscreen><verb>
isomarkboot filesystem bootlx
</verb></tscreen>

The command above assumes that <tt/filesystem/ is a file containing
the iso9660 filesystem and that <tt/bootlx/ has been copied into the
root directory of that filesystem.  That's it!


<sect1>Building the Linux Kernel<label id="Building Linux">

<p> A bootable Linux kernel can be built with the following steps.  During
the <tt/make config/, be sure to answer "yes" to the question whether you
want to boot the kernel via SRM.

<tscreen><verb>
cd /usr/src/linux
make config
make dep
make boot
</verb></tscreen>

<p> The last command will build the file
<tt>arch/alpha/boot/vmlinux.gz</tt> which can then be copied to the
disk from which you want to boot from.  In our floppy disk example
above, this would entail:

<tscreen><verb>
mount /dev/fd0 /mnt
cp arch/alpha/boot/vmlinux.gz /mnt
umount /mnt
</verb></tscreen>


<sect1> Booting Linux<label id="booting">

<p> With the SRM firmware and <tt/aboot/ installed, Linux is generally
booted with a command of the form:

<tscreen>
<tt/boot/ <it/devicename/ <tt/-fi/ <it/filename/ <tt/-fl/ <it/flags/
</tscreen>

<p> The <it/filename/ and <it/flags/ arguments are optional.  If they
are not specified, SRM uses the default values stored in environment
variables <tt/BOOT&lowbar;OSFILE/ and <tt/BOOT&lowbar;OSFLAGS/.  The
syntax and meaning of these two arguments is described in more detail
below.


<sect2>Boot Filename

<p> The filename argument takes the form:
<quote>
&lsqb;<em/n//&rsqb;<em/filename/
</quote>

<em/n/ is a single digit in the range 1..8 that gives the partition
number from which to boot from.  <em/filename/ is the path of the file
you want boot.  For example to boot from the second partition of SCSI
device 6, you would enter:

<tscreen><verb>
boot dka600 -file 2/vmlinux.gz
</verb></tscreen>

Or to boot from floppy drive 0, you'd enter:

<tscreen><verb>
boot dva0 -file vmlinux.gz
</verb></tscreen>

<p> If a disk has no partition table , <tt/aboot/ pretends the disk
contains one <tt/ext2/ partition starting at the first diskblock.
This allows booting from floppy disks.

<p> As a special case, partition number 0 is used to request booting
from a disk that does not (yet) contain a file system.  When
specifying "partition" number 0, <tt/aboot/ assumes that the Linux
kernel is stored right behind the <tt/aboot/ image.  Such a layout
can be achieved with the <tt/swriteboot/ command.  For example, to
setup a filesystem-less boot from <tt>/dev/sda</tt>, one could use
the command:

<tscreen><verb>
swriteboot /dev/sda bootlx vmlinux.gz
</verb></tscreen>

<p> Booting a system in this way is not normally necessary.  The
reason this feature exists is to make it possible to get Linux
installed on a systems that can't boot from a floppy disk (e.g., the
Jensen).


<sect2>Boot Flags

<p>A number of bootflags can be specified.  The syntax is:
<tscreen><verb>
-flags "options..."
</verb></tscreen>

Where "options..." is any combination the following options (separated
by blanks).  There are many more bootoptions, depending on what
drivers your kernel has installed.  The options listed below are
therefore just examples to illustrate the general idea:

<descrip>

<tag/load&lowbar;ramdisk=1/
Copy root file system from a (floppy) disk to the RAM disk
before starting the system.  The RAM disk will be used in
lieu of the root device.  This is useful to bootstrap Linux
on a system with only one floppy drive.

<tag/floppy=<em/str//
Sets floppy configuration to <em/str/.

<tag/root=<em/dev// Select device <em/dev/ as the root-file
system. The device can be specified as a major/minor hex number (e.g.,
0x802 for /dev/sda2) or one of a few canonical names (e.g.,
<tt>/dev/fd0</tt>, <tt>/dev/sda2</tt>).

<tag/single/
Boot system in single user mode.

<tag/kgdb/ Enable kernel-gdb (works only if <tt/CONFIG&lowbar;KGDB/ is
enabled; a second Alpha system needs to be connected over the serial
port in order to make this work)

</descrip>

<p> Some SRM implementations (e.g., the one for the Jensen) are
handicapped and allow only short option strings (e.g., at most 8
characters).  In such a case, <tt/aboot/ can be booted with the
single-character boot flag "i".  With this flag, <tt/aboot/ will
prompt the user to interacively enter a boot option string of up to
256 characters.  For example:

<tscreen><verb>
boot dka0 -fl i
aboot> 3/vmlinux.gz root=/dev/sda3 single
</verb></tscreen>

Since booting in that manner quickly becomes tedious, <tt/aboot/
allows to define short-hands for frequently used commandlines.  In
particular, a single digit option (0-9) requests that <tt/aboot/ uses
the corresponding option string stored in file
<tt>/etc/aboot.conf</tt>.  A sample <tt/aboot.conf/ is shown below:

<tscreen><verb>
#
# aboot default configurations
#
0:3/vmlinux.gz root=/dev/sda3
1:3/vmlinux.gz root=/dev/sda3 single
2:3/vmlinux.new.gz root=/dev/sda3
3:3/vmlinux root=/dev/sda3
8:- root=/dev/sda3            # fs-less boot of raw kernel
9:0/vmlinux.gz root=/dev/sda3 # fs-less boot of (compressed) ECOFF kernel
-
</verb></tscreen>

With this configuration file, the command

<tscreen><verb>
boot dka0 -fl 1
</verb></tscreen>

corresponds exactly to the boot command shown above.  It is quite easy
to forget what number corresponds to what option string.  To alleviate
this problem, boot with option "h" and <tt/aboot/ will print the
contents of <tt>/etc/aboot.conf</tt> before issueing the prompt for
the full option string.

Finally, whenever <tt/aboot/ prompts for an option string, it is
possible to enter one of the single character flags ("i", "h", or
"0"-"9") to get the same effect as if that flag had been specified in
the boot command line.  For example, you could boot with flag "i" and
then type "h" (followed by return) to remind yourself of the contents of
<tt>/etc/aboot.conf</tt>

<sect3>Selecting the Partition of /etc/aboot.conf

<p> When installed on a harddisk, <tt/aboot/ needs to know what
partition to search for the <tt>/etc/aboot.conf</tt> file.  A newly
compiled <tt/aboot/ will search the <em/second/ partition (e.g.,
<tt>/dev/sda2</tt>).  Since it would be inconvenient to have to
recompile <tt/aboot/ just to change the partition number,
<tt/abootconf/ allows to directly modify an installed <tt/aboot/.
Specifically, if you want to change <tt/aboot/ to use the <em/third/
partition on disk <tt>/dev/sda</tt>, you'd use the command:

<tscreen><verb>
abootconf /dev/sda 3
</verb></tscreen>

You can verify the current setting by simply omitting the partition
number.  That is: <tt>abootconf /dev/sda</tt> will print the currently
selected partition number.  Note that <tt/aboot/ does have to be
installed already for this command to succeed.  Also, when installing
a new <tt/aboot/, the partition number will fall back to the default
(i.e., it will be necessary to rerun <tt/abootconf/).

Since <tt/aboot/ version 0.5, it is also possible to select the
<tt>aboot.conf</tt> partition via the boot command line. This can be
done with a command line of the form <it/a/<tt/:/<it/b/ where <it/a/
is the partition that holds <tt>/etc/aboot.conf</tt> and <it/b/ is a
single-letter option as described above (<tt/0/-<tt/9/, <tt/i/, or
<tt/h/). For example, if you type <tt/boot -fl "3:h" dka100/ the
system boots from SCSI ID 1, loads <tt>/etc/aboot.conf</tt> from the
third partition, prints its contents on the screen and waits for you
to enter the boot options.


<sect1>Booting Over the Network<label id="Network Booting">

<p> Two prelimenary steps are necessary before Linux can be booted via
a network.  First, you need to set the SRM environment variables to
enable booting via the bootp protocol and second you need to setup
another machine as the your boot server.  Please refer to the SRM
documentation that came with your machine for information on how to
enable bootp.  Setting up the boot server is obviously dependent on
what operating system that machine is running, but typically it
involves starting the program <tt/bootpd/ in the background after
configuring the <tt>/etc/bootptab</tt> file.  The <tt/bootptab/ file
has one entry describing each client that is allowed to boot from
the server.  For example, if you want to boot the machine
<tt/myhost.cs.arizona.edu/, then an entry of the following form would
be needed:

<tscreen><verb>
myhost.cs.arizona.edu:\
	:hd=/remote/:bf=vmlinux.bootp:\
	:ht=ethernet:ha=08012B1C51F8:hn:vm=rfc1048:\
	:ip=192.12.69.254:bs=auto:
</verb></tscreen>

This entry assumes that the machine's Ethernet address is
<tt/08012B1C51F8/ and that its IP address is 192.12.69.254.  The
Ethernet address can be found with the <tt/show device/ command of the
SRM console or, if Linux is running, with the <tt/ifconfig/ command.
The entry also defines that if the client does not specify otherwise,
the file that will be booted is <tt/vmlinux.bootp/ in directory
<tt>/remote</tt>.  For more information on configuring <tt/bootpd/,
please refer to its man page.

Next, build <tt/aboot/ with with the command <tt/make netboot/.  Make
sure the kernel that you want to boot has been built already.  By
default, the <tt/aboot/ <tt/Makefile/ uses the kernel in
<tt>/usr/src/linux/arch/alpha/boot/vmlinux.gz</tt> (edit the
<tt/Makefile/ if you want to use a different path).  The result of
<tt/make netboot/ is a file called <tt/vmlinux.bootp/ which contains
<tt/aboot/ <em/and/ the Linux kernel, ready for network booting.

Finally, copy <tt/vmlinux.bootp/ to the bootsever's directory.  In the
example above, you'd copy it into <tt>/remote/vmlinux.bootp</tt>.
Next, power up the client machine and boot it, specifying the Ethernet
adapter as the boot device.  Typically, SRM calls the first Ethernet
adapter <tt/ewa0/, so to boot from that device, you'd use the command:

<tscreen><verb>
boot ewa0
</verb></tscreen>

The <tt/-fi/ and <tt/-fl/ options can be used as usual.  In
particular, you can ask <tt/aboot/ to prompt for Linux kernel
arguments by specifying the option <tt/-fl i/.

<sect>Sharing a Disk With DEC Unix

<p> Unfortunately, DEC Unix doesn't know anything about Linux, so
sharing a single disk between the two OSes is not entirely trivial.
However, it is not a difficult task if you heed the tips in this
section.  The section assumes you are using <tt/aboot/ version 0.5 or
newer.

<sect1>Partitioning the disk

<p> First and foremost: <em/never/ use any of the Linux partitioning
programs (<tt/minlabel/ or <tt/fdisk/) on a disk that is also used by
DEC Unix.  The Linux <tt/minlabel/ program uses the same partition
table format as DEC Unix <tt/disklabel/, but there are some
incompatibilities in the data that <tt/minlabel/ fills in, so DEC Unix
will simply refuse to accept a partition table generated by
<tt/minlabel/.  To setup a Linux <tt/ext2/ partition under DEC Unix,
you'll have to change the disktab entry for your disk.  For the
purpose of this discussion, let's assume that you have an rz26 disk (a
common 1GB drive) on which you want to install Linux.  The disktab
entry under DEC Unix v3.2 looks like this (see file
<tt>/etc/disktab</tt>):

<tscreen><verb>
rz26|RZ26|DEC RZ26 Winchester:\
        :ty=winchester:dt=SCSI:ns#57:nt#14:nc#2570:\
        :oa#0:pa#131072:ba#8192:fa#1024:\
        :ob#131072:pb#262144:bb#8192:fb#1024:\
        :oc#0:pc#2050860:bc#8192:fc#1024:\
        :od#393216:pd#552548:bd#8192:fd#1024:\
        :oe#945764:pe#552548:be#8192:fe#1024:\
        :of#1498312:pf#552548:bf#8192:ff#1024:\
        :og#393216:pg#819200:bg#8192:fg#1024:\
        :oh#1212416:ph#838444:bh#8192:fh#1024:
</verb></tscreen>

The interesting fields here are <tt/o/<it/?/, and <tt/p/<it/?/, where
<it/?/ is a letter in the range <tt/a/-<tt/h/ (first through 8-th
partition).  The <tt/o/ value gives the starting offset of the
partition (in sectors) and the <tt/p/ value gives the size of the
partition (also in sectors).  See <tt/disktab(4)/ for more info.  Note
that DEC Unix likes to define overlapping partitions.  For the entry
above, the partition layout looks like this (you can verify this by
adding up the various <tt/o/ and <tt/p/ values):

<tscreen><verb>
  a    	b      	  d    	      e	     	  f
|---|-------|-----------|-----------|-----------|

                        c
|-----------------------------------------------|

                     g                 h
            |-----------------|-----------------|
</verb></tscreen>

DEC Unix insists that partition <tt/a/ starts at offset 0 and that
partition <tt/c/ spans the entire disk.  Other than that, you can
setup the partition table any way you like.

Let's suppose you have DEC Unix using partition <tt/g/ and want to
install Linux on partition <tt/h/ with partition <tt/b/ being a
(largish) swap partition.  To get this layout without destroying the
existing DEC Unix partition, you need to set the partition types
explicitly.  You can do this by adding a <tt/t/ field for each
partition.  In our case, we add the following line to the above
disktab entry.

<tscreen><verb>
	:ta=unused:tb=swap:tg=4.2BSD:th=resrvd8:
</verb></tscreen>

Now why do we mark partition <tt/h/ as "reservd8" instead of "ext2"?
Well, DEC Unix doesn't know about Linux.  It so happens that partition
type "ext2" corresponds to a numeric value of 8, and DEC Unix uses the
string "reservd8" for that value.  Thus, in DEC Unix speak, "reservd8"
means "ext2".  OK, this was the hard part.  Now we just need to
install the updated disktab entry on the disk.  Let's assume the disk
has SCSI id 5.  In this case, we'd do:

<tscreen><verb>
disklabel -rw /dev/rrz5c rz26
</verb></tscreen>

You can verify that everything is all right by reading back the
disklabel with <tt>disklabel -r /dev/rrz5c</tt>.  At this point, you
may want to reboot DEC Unix and make sure the existing DEC Unix
partition is still alive and well.  If that is the case, you can shut
down the machine and start with the Linux installation.  Be sure to
skip the disk partitioning step during the install.  Since we already
installed a good partition table, you should be able to proceed and
select the 8th partition as the Linux root partition and the 2nd
partition as the swap partition.  If the disk is, say, the second SCSI
disk in the machine, then the device name for these partitions would
be <tt>/dev/sdb8</tt> and <tt>/dev/sdb2</tt>, respectively (note that
Linux uses letters to name the drives and numbers to name the
partitions, which is exactly reversed from what DEC Unix does; the
Linux scheme makes more sense, of course ;-).


<sect1>Installing <tt/aboot/

<p> <em/First big caveat/: with the SRM firmware, you can boot one and
only one operating system per disk.  For this reason, it is generally
best to have at least two SCSI disks in a machine that you want to
dualboot between Linux and DEC Unix.  Of course, you could also boot
Linux from a floppy if speed doesn't matter or over the network, if
you have a <tt/bootp/-capable server.  But in this section we assume
you want to boot Linux from a disk that contains one or more DEC Unix
partitions.

<em/Second big caveat/: installing <tt/aboot/ on a disk shared with
DEC Unix renders the first and third partition unusable (since those
<em/must/ have a starting offset of 0).  For this reason, we recommend
that you change the size of partition <tt/a/ to something that is just
big enough to hold <tt/aboot/ (1MB should be plenty).

Once these two caveats are taken care of, installing <tt/aboot/ is
almost as easy as usual: since partition <tt/a/ and <tt/c/ will
overlap with <tt/aboot/, we need to tell <tt/swriteboot/ that this is
indeed OK.  We can do this under Linux with a command line of the
following form (again, assuming we're trying to install <tt/aboot/ on
the second SCSI disk):

<tscreen><verb>
swriteboot -f1 -f3 /dev/sdb bootlx
</verb></tscreen>

The <tt/-f1/ means that we want to force writing <tt/bootlx/ even
though it overlaps with partition 1.  The corresponding applies for
partition 3.

This is it.  You should now be able to shutdown the system and boot
Linux from the harddisk.  In our example, the SRM command line to do
this would be:

<tscreen><verb>
boot dka5 -fi 8/vmlinux.gz -fl root=/dev/sdb8
</verb></tscreen>

</article>
