<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook V3.1//EN">
<article>
<artheader>
   <title>Lilo mini-Howto</title>
   <author>
      <firstname>Cameron</firstname>
      <surname>Spitzer</surname>
      <affiliation>
         <address>
            <email>cls@truffula.sj.ca.us</email>
         </address>
      </affiliation>
   </author>
   <author>
      <firstname>Alessandro</firstname>
      <surname>Rubini</surname>
      <affiliation>
         <address>
            <email>rubini@linux.it</email>
         </address>
      </affiliation>
   </author>
      
   <revhistory>
      <revision>
         <revnumber>v2.02</revnumber>
         <date>16 August 1998</date>
         <authorinitials>cs, ar</authorinitials>
      </revision>
      <revision>
         <revnumber>v2.03</revnumber>
         <date>7 November 1999</date>
         <authorinitials>dlr, ar</authorinitials>
         <revremark>changed linuxdoc to docbook, added preface</revremark>
      </revision>
   </revhistory>
   <abstract>
      <para>
LILO is the most used <emphasis>Li</emphasis>nux
<emphasis>Lo</emphasis>ader for the x86 flavour of Linux; I'll call it
Lilo rather than LILO here because I don't appreciate uppercase.  This
file describes some typical Lilo installations.  It's intended as a
supplement to the Lilo User's Guide.  I think examples are informative
even if your setup isn't much like mine.  I hope this saves you trouble.
Since Lilo's own documentation is very good, who's interested in the
details is referred to <filename class="directory">
/usr/doc/lilo*</filename>
      </para>
   </abstract>
</artheader>

<sect1>
<title>Copyright and Licensing Information</title>
<para>
Copyright &copy; 1998 Cameron Spitzer and Alessandro Rubini.  This
material may be distributed only subject to the terms and conditions set
forth in the Open Publication License, v0.4 or later (the latest version
is presently available at <ulink
url="http://www.opencontent.org/openpub/">http://www.opencontent.org/openpub/</ulink>).
</para>
<para>
Note that neither of the OPL "Options" apply to this document.  This
document may be freely reformatted, freely distributed, and freely
modified and translated according to the terms presented in the Open
Publication License.
</para>
</sect1>

<sect1>
<title>Preface</title>
<para>
This document has not being maintained since Aug 1998.  In June 1999
Cameron set up a web site to handle Lilo issues, aiming to help
updating this document, so plese visit <ulink
url="http://judi.greens.org/lilo/">http://judi.greens.org/lilo/</ulink>.
Since I (Alessandro) haven't heard back from Cameron ever since, I
took the chance to add this Preface when the document has been
converted from LinuxDoc to DocBook (two sgml ``variants'') by Deb
Richardson, in order to include it in the OSWG corpus.
</para>
<para>
While the document may still include interesting information, I don't
think it serves the community's need any more. Current issues with
Lilo are related to very big disks, modern hardware and BIOSes,
multiple-booting with other Operating Systems and I've absolutely no
experience with any of them. As the document has been sitting there
unmodified for 15 months, I felt urged to add this note.  If you are
willing to take over maintainance or otherwise help, please get in touch
with Cameron and either the LDP (<ulink
url="http://www.linuxdoc.org">http://www.linuxdoc.org</ulink>) or the
OSWG (<ulink url="http://www.oswg.org">http://www.oswg.org</ulink>) --
the latter is probably your best bet, as they demonstrated some interest
in this specific document.
</para>
</sect1>

<sect1>
<title>Introduction</title>
<para>
Although the documentation found in Lilo's sources (the one installed in
<filename class="directory">/usr/doc/lilo</filename> -version) is very
comprehensive, most Linux users experience some trouble in building
their own <filename>/etc/lilo.conf</filename> file. This document is
meant to support them by giving the minimal information and by showing
five sample installations:
</para>

<itemizedlist>

<listitem><para>The first example is the classical ``Linux and other''
installation.</para></listitem>

<listitem><para>The next one shows how to install Lilo on a hard drive
connected as <literal>/dev/hdc</literal> that will boot as
<literal>/dev/hda</literal>.  This is usually needed when you install a
new Linux drive from your own running system. This also tells how to
boot from SCSI disks when your BIOS is modern enough.</para></listitem>

<listitem><para>The third example shows how to boot a Linux system whose
root partition can't be accessed by the BIOS.</para></listitem>

<listitem><para>The next sample file is used to access huge disks, that
neither the BIOS nor DOS can access easily (this one is somehow
outdated).</para></listitem>

<listitem><para>The last example shows how to restore a damaged disk, if
the damage resulted from installing another operating
system).</para></listitem>

</itemizedlist>

<para>
The last three examples are by Cameron, who wrote the original
document.  Alessandro, who took over maintainance for a while, doesn't
run anything but Linux, so he can't check nor update them by himself.
Feel free to send feedback through Cameron's web site (<ulink
url="http://judi.greens.org/lilo/">http://judi.greens.org/lilo/</ulink>)
or to send email to either of us.
</para>
</sect1>

<sect1>
<title>Background Information and Standard Installation</title>
<para>
When Lilo boots the system, it uses BIOS calls to load the Linux kernel
off the disk (IDE drive, floppy or whatever). Therefore, the kernel must
live in some place that can be accessed by the bios. 
</para>
<para>
At boot time, Lilo is not able to read filesystem data, and any pathname
you put in <filename>/etc/lilo.conf</filename> is resolved at
installation time (when you invoke <filename>/sbin/lilo</filename>).
Installation time is when the program builds the tables that list which
sectors are used by the files used to load the operating system. As a
consequence, all of these files must live in a partition that can be
accessed by the BIOS (the files are usually located in the <filename
class="directory">/boot</filename> directory, this means that only the
root partition of your Linux system needs to be accessed via the BIOS).
</para>
<para>
Another consequence of being BIOS-based is that you must reinstall the
loader (i.e., you must reinvoke <filename>/sbin/lilo</filename>) any
time you modify the Lilo setup. Whenever you recompile your kernel and
overwrite your old image you must reinstall Lilo. 
</para>
 
<sect2>
<title>Where Should I Install Lilo?</title>
<para>
The <command>boot=</command> directive in
<filename>/etc/lilo.conf</filename> tells Lilo where it should place its
primary boot loader. In general, you can either specify the master boot
record (<filename class="directory">/dev/hda</filename>) or the root
partition of your Linux installation (is usually is <filename
class="directory">/dev/hda1</filename> or <filename
class="directory">/dev/hda2</filename>).
</para>
<para>
If you have another operating system installed in your hard drive, you'd
better install Lilo to the root partition instead of the MBR. In this
case, you must mark the partition as ``bootable'' using the
<command>a</command> command of <command>fdisk</command> or the
<command>b</command> command of <command>cfdisk</command>. If you don't
overwrite the master boot sector you'll find it easier to uninstall
Linux and Lilo if needed.
</para>
</sect2>

<sect2>
<title>How Should I Configure my IDE Hard Drives?</title>
<para>
I personally don't use LBA or LARGE settings in the BIOS (but I only
run Linux); they are horrible kludges forced on by design deficiencies
in the PC world. This requires that the kernel lives in the first 1024
cylinders, but this is not a problem as long as you partition your
hard drives and keep root small (as you should do anyways).
</para>
<para>
If your hard disk already carries another operating system, you won't
be able to modify the BIOS settings, or the old system won't work any
more. All recent Lilo distribution are able to deal with LBA and LARGE
disk settings.
</para>
<para>
Note that the <literal>linear</literal> keyword in <filename
class="directory">/etc/lilo.conf</filename> can help in dealing with
geometry problems. The keyword instructs Lilo to use linear sector
addresses instead of sector/head/cylinder tuples.  Conversion to 3D
addresses is delayed to run-time, therefore making the setup more immune
to geometry problems.
</para>
<para>
If you have more than one hard disk and some of them are only used by
Linux and are not involved in the boot process, you can tell your BIOS
that they are not installed. Your system will boot more quickly and
Linux will autodetect all the disks in no time. I often switch disks
in my computers, but I never touch the BIOS configuration.
</para>
</sect2>

<sect2>
<title>How Can I Interact at Boot Time?</title>
<para>
When you see the Lilo prompt, you can hit the <keycap>Tab</keycap> key
to show the list of possible choices. If Lilo is not configured to be
interactive, press and hold the <keycap>Alt</keycap> or
<keycap>Shift</keycap> key before the
<computeroutput>LILO</computeroutput> message appears.
</para>
<para>
If you choose to boot a Linux kernel, you can add command-line
arguments after the name of the system you choose. The kernel accepts
many command-line arguments. All the arguments are listed in the
<citetitle pubwork="article">BootPrompt-HOWTO</citetitle> by Paul
Gortmaker, and I won't replicate it here. A few command line arguments,
however, are particularly important and worth describing here:
</para>

<itemizedlist>

<listitem><para><command>root=</command>: you can tell the Linux kernel
to mount as root a different partition than the one appearing in
<filename>lilo.conf</filename>.  For example, my system has a tiny
partition hosting a minimal Linux installation, and I've been able to
boot the system after destroying my root partition by mistake.
</para></listitem>

<listitem><para><command>init=</command>: version 1.3.43 and newer of
the Linux kernel can execute another command instead of
<command>/sbin/init</command>, as specified on the
command line. If you experience bad problems during the boot process,
you can access the bare system by specifying
<command>init=/bin/sh</command> (when you are at the shell prompt you
most likely will need to mount your disks: try <command>mount -w -n -o
remount /; mount -a</command>, and remember to <command>umount
-a</command> before turning off the computer).</para></listitem>


<listitem><para><command><replaceable>number</replaceable></command>: by
specifying a number on the kernel command line, you instruct
<command>init</command> to enter a specific run-level (the default is
usually 3 or 2, according to the distribution you chose).  Refer to the
<command>init</command> documentation, to
<filename>/etc/inittab</filename> and to <filename>/etc/rc*.d</filename>
to probe further.</para></listitem> 
 
</itemizedlist>
</sect2>

<sect2>
<title>How Can I Uninstall Lilo?</title>
<para>
When Lilo overwrites a boot sector, it saves a backup copy in
<filename>/boot/boot.<replaceable>xxyy</replaceable></filename>, where
<replaceable>xxyy</replaceable> are the major and minor numbers of the
device, in hex. You can see the major and minor numbers of your disk or
partition by running <command>ls <option>-l</option>
/dev/<replaceable>device</replaceable></command>. For example, the first
sector of <filename class="directory">/dev/hda</filename> (major 3,
minor 0) will be saved in <filename>/boot/boot.0300</filename>,
installing Lilo on <filename class="directory">/dev/fd0</filename>
creates <filename>/boot/boot.0200</filename> and installing on <filename
class="directory">/dev/sdb3</filename>> (major 8, minor 19) creates
<filename>/boot/boot.0813</filename>. Note that Lilo won't create the
file if there is already one so you don't need to care about the backup
copy whenever you reinstall Lilo (for example, after recompiling your
kernel). The backup copies found in <filename
class="directory">/boot/</filename> are always the snapshot of the
situation before installing any Lilo. 
</para>
<para>
If you ever need to uninstall Lilo (for example, in the unfortunate case
you need to uninstall Linux), you just need to restore the original boot
sector. If Lilo is installed in <filename
class="directory">/dev/hda</filename>, just do <command>dd
if=/boot/boot.0300 of=/dev/hda bs=446 count=1</command> (I personally
just do <command>cat /boot/boot.0300 > /dev/hda</command>, but this is
not safe, as this will restore the original partition table as well,
which you might have modified in the meanwhile). This command is much
easier to run than trying <command>fdisk /mbr</command> from a DOS
shell: it allows you to cleanly remove Linux from a disk without ever
booting anything but Linux. After removing Lilo remember to run Linux'
<command>fdisk</command> to destroy any Linux partition (DOS'
<command>fdisk</command> is unable to remove non-dos partitions).
</para>
<para>
If you installed Lilo on your root partition (e.g., <filename
class="directory">/dev/hda2</filename>), nothing special needs to be
done to uninstall Lilo.  Just run Linux' <command>fdisk</command> to
remove Linux partitions from the partition table. You must also mark the
DOS partition as bootable.
</para>
</sect2>
</sect1>

<sect1>
<title>The Simple Configuration</title>
<para>
Most Lilo installations use a configuration file like the
following one:
</para>

<programlisting>
boot = /dev/hda   # or your root partition
delay = 10        # delay, in tenth of a second (so you can interact)
vga = 0           # optional. Use "vga=1" to get 80x50
#linear           # try "linear" in case of geometry problems.

image = /boot/vmlinux  # your zImage file
  root = /dev/hda1     # your root partition
  label = Linux        # or any fancy name
  read-only            # mount root read-only

other = /dev/hda4   # your dos partition, if any
  table = /dev/hda  # the current partition table
  label = dos       # or any non-fancy name
</programlisting>

<para>
You can have multiple ``image'' and ``other'' sections if you want. It's
not uncommon to have several kernel images configured in your
<filename>lilo.conf</filename>, at least if you keep up to date with
kernel development.
</para>

<sect2>
<title>How to Deal with Big Kernels</title>
<para>
If you compile a ``zImage'' kernel and it is too big to fit in half a
megabyte (this is commong with new 2.1 kernels), you should build a
``big zImage'' instead: <command>make bzImage</command>. To boot a big
kernel image nothing special is needed, but you need version 18 or
newer of Lilo. If your installation is older, you should upgrade your
Lilo package.
</para>
</sect2>

<sect2>
<title>Other Sources of Information</title>
<para>
In addition to the Lilo docs, there are a number of mini-howto's that
can be useful for your needs. All of them are called
<filename>Linux+<replaceable>foobarOS</replaceable></filename>, for some
<replaceable>foobarOS</replaceable>, they deal with coexistence of Linux
and other operationg system(s). Also, <citetitle
pubwork="article">Multiboot-with-LILO</citetitle> describes how the
various Windows flavours can be made to coexist with Linux.
</para>
<para>
If you need some information about partitioning (how are partition
tables stored on disk, what are the partition tipes, and other
low-level information) you should check Andries Brouwer's site, at
<ulink
url="http://www.win.tue.nl/~aeb/">http://www.win.tue.nl/~aeb/</ulink>.
</para>
</sect2>
</sect1>

<sect1>
<title>Installing <literal>hdc</literal> to Boot as <literal>hda</literal> and Using <command>bios=</command></title>
<para>
Lilo allows to map the kernel image from one disk and instruct the BIOS
to retrieve it from another disk. For example, it's common for me to
install Linux on a disk I connect to <literal>hdc</literal> (master disk
of secondary controller) and boot it as a standalong system on the
primary IDE controller of another computer. I copied the installation
floppy to a tiny partition, so I can run <command>chroot</command> in a
virtual console to install <literal>hdc</literal> while I use the system
to do something else. 
</para>
<para>
The <filename>lilo.conf</filename> file I use to install Lilo looks like: 
</para>

<programlisting>
# This file must be used from a system running off /dev/hdc
boot = /dev/hdc   # overwrite MBR of hdc
disk = /dev/hdc	  # tell how hdc will look like:
   bios = 0x80    #  the bios will see it as first drive
delay = 0
vga = 0

image = /boot/vmlinux  # this is on /dev/hdc1
  root = /dev/hda1     # but at boot it will be hda1
  label = Linux
  read-only
</programlisting>

<para>
This configuration file must be read by a Lilo running off <filename
class="directory">/dev/hdc1</filename>.  The Lilo maps that get written
the boot sector (<filename class="directory">/dev/hdc</filename>) must
refer to the files in <filename class="directory">/boot</filename>
(currently installed as <literal>hdc</literal>); such files will be
accessed under hda when this disk will be booted as a standalone
system.
</para>
<para>
I call this configuration file
<filename>/mnt/etc/lilo.conf.hdc</filename> (<filename
class="directory">/mnt</filename> is where <literal>hdc</literal> is
mounted during the installation. I install Lilo by invoking <command>cd
/mnt; chroot . sbin/lilo -C /etc/lilo.conf.hdc</command>. Refer to the
manual page for <command>chroot</command> if this looks magic.
</para>
<para>
The <command>bios=</command> directive in <filename>lilo.conf</filename>
is used to tell Lilo what the BIOS thinks of your devices. BIOS calls
identify floppy disks and hard drives with a number: 0x00 and 0x01
select the floppy drives, 0x80 and the following numbers select hard
disks (old BIOSes can only access two disks). The meaning of
<command>bios = 0x80</command> in the previous sample file is therefore
``use 0x80 in your BIOS calls for <filename
class="directory">/dev/hdc</filename>.
</para>
<para>
This Lilo directive can be handy in other situations, for example when
your BIOS is able to boot from SCSI disks instead of IDE ones. When
both IDE and SCSI devices are there, Lilo can't tell whether 0x80 will
refer to one or the other because the user is able to choose it in the
BIOS configuration menus, and the BIOS can't be accessed while Linux
is running.
</para>
<para>
By default, Lilo assumes that IDE drives are mapped first by the BIOS,
but this can be overridden by using instructions like these in
<filename>/etc/lilo.conf</filename>:
</para>

<programlisting>
disk = /dev/sda
  bios = 0x80
</programlisting>

</sect1>

<sect1>
<title>Using Lilo When the BIOS Can't See the Root Partition</title>
<para>
I have two IDE drives, and a SCSI drive.  The SCSI drive can't be seen
from BIOS.  The Linux Loader, Lilo, uses BIOS calls and can only see
drives that BIOS can see.  My stupid AMI BIOS will only boot from
<medialabel class="disk">A:</medialabel> or <medialabel
class="disk">C:</medialabel> My root file system is on a partition on
the SCSI drive. 
</para>
<para>
The solution consists in storing the kernel, map file, and chain
loader in a Linux partition on the first IDE.  Notice that it is not
necessary to keep your kernel on your root partition.
</para>
<para>
The second partition on my first IDE (<filename
class="directory">/dev/hda2</filename>, the Linux partition used to boot
the system) is mounted on <filename class="directory">/u2</filename>.
Here is the <filename>/etc/lilo.conf</filename> file I used.
</para>

<programlisting>
#  Install Lilo on the Master Boot Record
#  on the first IDE.
#
boot = /dev/hda
#  /sbin/lilo (the installer) copies the Lilo boot record
#  from the following file to the MBR location.
install = /u2/etc/lilo/boot.b
#
#  I wrote a verbose boot menu.  Lilo finds it here.
message = /u2/etc/lilo/message
#  The installer will build the following file. It tells
#  the boot-loader where the blocks of the kernels are.
map = /u2/etc/lilo/map
compact
prompt
#  Wait 10 seconds, then boot the 1.2.1 kernel by default.
timeout = 100
#  The kernel is stored where BIOS can see it by doing this:
#      cp -p /usr/src/linux/arch/i386/boot/zImage /u2/z1.2.1
image = /u2/z1.2.1
	label = 1.2.1
#  Lilo tells the kernel to mount the first SCSI partition
#  as root.  BIOS does not have to be able to see it.
	root = /dev/sda1
#  This partition will be checked and remounted by /etc/rc.d/rc.S
	read-only
#  I kept an old Slackware kernel lying around in case I built a
#  kernel that doesn't work.  I actually needed this once.
image = /u2/z1.0.9
	label = 1.0.9
	root = /dev/sda1
	read-only
#  My DR-DOS 6 partition.
other = /dev/hda1
        loader=/u2/etc/lilo/chain.b
        label = dos
        alias = m
</programlisting>
</sect1>

<sect1>
<title>Accessing Huge Disks When the BIOS Can't</title>
<para>
The system in my office has a 1GB IDE drive.  The BIOS can only see
the first 504 MB of the IDE.  (Where MB means 2**10 bytes, not 10**6
bytes.)  So I have MS-DOS on a 350 MB partition <filename
class="directory">/dev/hda1</filename> and my Linux root on a 120 MB
partition <filename class="directory">/dev/hda2</filename>.
</para>
<para>
MS-DOS was unable to install itself correctly when the drive was
fresh.  Novell DOS 7 had the same problem.  Luckily for me, "Options
by IBM" forgot to put the "OnTrack" diskette in the box with the
drive.  The drive was supposed to come with a product called "OnTrack
Disk Manager."  If you only have MSDOS, I guess you have to use it.
</para>
<para>
So I made a partition table with Linux' fdisk.  MSDOS-6.2 refused to
install itself in <filename class="directory">/dev/hda1</filename>.  It
said something like ``this release of MS-DOS is for new installations.
Your computer already has MS-DOS so you need to get an upgrade release
from your dealer.'' Actually, the disk was brand new.
</para>
<para>
What a crock!  So I ran Linux' <command>fdisk</command> again and
deleted partition 1 from the table.  This satisfied MS-DOS 6.2 which
proceeded to create the exact same partition 1 I had just deleted and
installed itself.  MS-DOS 6.2 wrote its Master Boot Record on the drive,
but it couldn't boot.
</para>
<para>
Luckily I had a Slackware kernel on floppy (made by the Slackware
installation program <command>setup</command>), so I booted Linux and
wrote Lilo over MS-DOS' broken MBR.  This works.  Here is the
<filename>/etc/lilo.conf</filename> file I used:
</para>

<programlisting>
boot = /dev/hda
map = /lilo-map
delay = 100
ramdisk = 0             # Turns off ramdisk in Slackware kernel
timeout = 100
prompt
disk = /dev/hda		# BIOS only sees first 500 MB.
   bios = 0x80          # specifies the first IDE.
   sectors = 63         # get the numbers from your drive's docs.
   heads = 16
   cylinders = 2100
image = /vmlinuz
  append = "hd=2100,16,63"
  root = /dev/hda2
  label = linux
  read-only
  vga = extended
other = /dev/hda1
  label = msdos
  table = /dev/hda
  loader = /boot/chain.b
</programlisting>

<para>
After I installed these systems, I verified that the partition
containing the <filename>zImage</filename>, <filename>boot.b</filename>,
<filename>map</filename>, <filename>chain.b</filename>, and message
files can use an MS-DOS file system, as long as it is not "stackered" or
"doublespaced."  So I could have made the DOS partition on <filename
class="directory">/dev/hda1</filename> 500 MB.
</para>
<para>
I have also learned that "OnTrack" would have written a partition
table starting a few dozen bytes into the drive, instead of at the
beginning, and it is possible to hack the Linux IDE driver to work
around this problem.  But installing would have been impossible with
the precompiled Slackware kernel.  Eventually, IBM sent me an
"OnTrack" diskette.  I called OnTrack's technical support.  They told
me Linux is broken because Linux doesn't use BIOS.  I gave their
diskette away.
</para>
</sect1>

<sect1>
<title>Booting from a Rescue Floppy</title>
<para>
Next, I installed Windows-95 on my office system.  It blew away my nice
Lilo MBR, but it left my Linux partitions alone.  Kernels take a long
time to load from floppy, so I made a floppy with a working Lilo setup
on it, which could boot my kernel from the IDE.
</para>
<para>
I made the lilo floppy like so:
</para>

<programlisting>
  fdformat /dev/fd0H1440      #  lay tracks on virgin diskette
  mkfs -t minix /dev/fd0 1440 #  make file system of type minix
  mount /dev/fd0 /mnt         #  mount in the standard tmp mount point
  cp -p /boot/chain.b /mnt    #  copy the chain loader over
  lilo -C /etc/lilo.flop      #  install Lilo and the map on the diskette.
  umount /mnt
</programlisting>

<para>
Notice that the diskette <emphasis>must be mounted when you run the
installer</emphasis> so that Lilo can write its map file properly.
</para>
<para>
This file is <filename>/etc/lilo.flop</filename>.  It's almost the same
as the last one: 
</para>

<programlisting>
#  Makes a floppy that can boot kernels from HD.
boot = /dev/fd0
map = /mnt/lilo-map
delay = 100
ramdisk = 0
timeout = 100
prompt
disk = /dev/hda     # 1 GB IDE, BIOS only sees first 500 MB.
   bios=0x80
   sectors = 63
   heads = 16
   cylinders = 2100
image = /vmlinuz
  append = "hd=2100,16,63"
  root = /dev/hda2
  label = linux
  read-only
  vga = extended
other = /dev/hda1
  label = msdos
  table = /dev/hda
  loader = /mnt/chain.b
</programlisting>

<para>
Finally, I needed MS-DOS 6.2 on my office system, but I didn't want to
touch the first drive.  I added a SCSI controller and drive, made an
msdos file system on it with Linux' mkdosfs, and Windows-95 sees it as
<medialabel class="disk">D:</medialabel>.   But of course MSDOS will not
boot off of <medialabel class="disk">D:</medialabel>.  This is not a
problem when you have Lilo.  I added the following to the
<filename>lilo.conf</filename> in Example 2.  
</para>

<programlisting>
other = /dev/sda1
  label = d6.2
  table = /dev/sda
  loader = /boot/any_d.b
</programlisting>

<para>
With this modification MSDOS-6.2 runs, and it thinks it is on
<medialabel class="disk">C:</medialabel> and Windows-95 is on
<medialabel class="disk">D:</medialabel>.
</para>
</sect1>

</article>


