Next Previous Contents

4. Installing Red Hat Linux 5.0

The tricky part of the installation, based on my reading, was expected to be at the beginning. The Libretto comes with an external PCMCIA floppy drive, which is bootable, but Red Hat Linux (RHL) needs to read a second floppy after booting if the installation requires PCMCIA services, and this isn't possible (because the kernel on the boot floppy can't read another floppy).

4.1 Installation strategies

So, you say, why not copy the files needed from the CD-ROM to the Windows partition (while still running Windows, that is), defragment and repartition the drive, and then do a hard-drive installation? This sounds plausible, and I was ready to try it, until I noticed that I would still need the second floppy in order to do a hard-drive installation.

At this point I seriously considered building a Linux boot floppy with MSDOS file system support so that I could continue with this approach. It might have worked -- and I would be pleased to hear from anyone who does this successfully. It's the only reasonable way I can think of to bootstrap Linux on the Libretto without the use of a second PC (except to compile the kernel for the boot floppy -- but if a suitable kernel were available for downloading, it would be possible to transfer it to a floppy using the rawrite utility under DOS or Windows).

I might have been tempted to remove the Libretto's hard drive, install it in another PC, and do the installation there, using the method described in Linux on the Libretto,, except that the necessary 2.5-inch to 3.5-inch adapters are extraordinarily hard to find. (Grant Taylor notes that these are available from Dexis Computer in Minneapolis, +1 612 944 7670.) The downside of this approach, even given the adapter and an attitude of reckless abandon towards Toshiba's warranty, is that upgrades may be equally difficult. On the other hand, if you've decided to replace your drive with a larger one -- why not?

Keith Packard's advice -- to build a minimal root partition using a parallel-port Zip drive attached to another PC -- seemed much the better course. I didn't have a Zip drive, so I bought a Zip Plus (this is the new model, with both parallel and SCSI interfaces) at the local computer megaoutlet. An hour later, I realized this was a mistake: the Zip Plus is not compatible with the original Zip, which is the only one supported by the Linux ppa module. (This may be changing: if you are considering buying a Zip drive, you may want to take a look at David Campbell's PPA page,, for more recent information. As of June 1998, an alpha release of a Zip Plus driver is available for testing.) Fortunately, exchanging drives was no problem.

After writing this HOWTO, I received several suggestions for other installation strategies. Jay Soffian, wrote that he had successfully used a Backpack (parallel-port) CD-ROM drive to install RHL 5.0, first defragmenting and repartitioning using FIPS (see below), then running autoboot.bat (on the RHL CD-ROM) from DOS mode. If you have one of these CD-ROM drives, this sounds like a significantly easier approach than what I describe below.

Another possibility I haven't had a chance to try yet is to make a custom initrd.gz, as Victor Gvirtsman has done (see Victor's idea is to copy loadlin.exe and vmlinuz from the RHL CD, and Victor's initrd.gz, to the DOS/Windows partition of the Libretto, and then to use loadlin to bootstrap Linux for an installation using a PCMCIA CD-ROM, hard drive, or network card. This didn't work for me; the problem I encountered was that at least one shared library appears to be missing, so that cardmgr (the PCMCIA card services daemon) could not be started. This looks like a problem that should be fairly easy to fix. The process of creating a custom RHL boot floppy, which doesn't appear to be documented by Red Hat anywhere, is described clearly and in detail by Rod Smith (see

4.2 Preparation using another Linux PC

If you decide to take this route, as I did, you will need not only a parallel-port Zip drive, but also root (superuser) access to another PC that is running Linux. I refer to this as ``the desktop PC'' below.

In outline, we will:

Begin collecting files

Make a directory for miscellaneous files to be transferred to the Libretto, and make several subdirectories within it:

mkdir /tmp/libretto
cd /tmp/libretto
mkdir -p boot lib/modules stage2/boot stage2/lib/modules usr/src

Obtain the latest kernel source RPM from Red Hat's FTP server (in or one of its mirrors if possible. Otherwise, you can use the copy from the SRPMS directory on RHL 5.0 CD-ROM 2. The file you need has a name of the form kernel-version.src.rpm; do not confuse this with kernel-source-version.i386.rpm, which does not contain the pcmcia-cs sources. Save a copy of this file in the /tmp/libretto/usr/src directory if you would like to be able to build new kernels on the Libretto itself later on.

Next, we need kernel and module binaries. You can download the necessary binaries from my web site, or you may create them from the Linux sources.

Using kernel and module binaries

If you wish to use the precompiled binaries:

  1. Download the Libretto Linux binary archive and save it as /tmp/llbin.tar.gz (the HTML version of this document,, contains a link to the archive here).
  2. Unpack the archive by
    cd /tmp
    tar xfvz llbin.tar.gz
    (The contents of the archive will be unpacked into /tmp/libretto and its subdirectories. Once you have unpacked the archive, you can delete /tmp/llbin.tar.gz.)

Creating kernel and module binaries from sources (optional)

If you wish to create the binaries from sources:

  1. If you have previously created a custom kernel for your desktop PC, make a backup copy of your kernel configuration file (/usr/src/linux/.config) in another directory.
  2. If you have not already done so, install the sources from the SRPM by
    rpm -i /tmp/libretto/usr/src/kernel-2.0.32-2.src.rpm
    (Your SRPM may have a later version number.) The sources will be unpacked into directories named /usr/src/linux-linuxversion and /usr/src/pcmcia-cs-pcmciaversion. Make symbolic links to these directories, named /usr/src/linux and /usr/src/pcmcia-cs respectively.
  3. Download the stage 1 kernel configuration file (see the HTML version of this file for a link), and install it as /usr/src/linux/.config. If you make changes in .config, be sure to include support for kernel modules (since PCMCIA support is available only as modules). Since the stage 1 kernel will be using the Zip drive for the root file system, include ppa support directly in the kernel (not as a module). Note that it is not possible to include parallel printer or plip support in the stage 1 kernel, since either would interfere with use of the root file system in this case.
  4. Build the stage 1 kernel by:
    make clean
    make dep
    make zImage
    cp /usr/src/linux/arch/i386/boot/zImage /tmp/libretto/boot/vmlinuz
    cp /usr/src/linux/ /tmp/libretto/boot/
    rdev /tmp/libretto/boot/vmlinuz /dev/sda1
    rdev -s /tmp/libretto/boot/vmlinuz /dev/sda2
    Depending on the speed of your desktop PC, the make commands may take anywhere from a few minutes to an hour or more. The rdev commands set the root and swap partitions to be used by the stage 1 kernel; these correspond to the partitions on the Zip drive.
  5. Make a set of modules (excluding the PCMCIA modules), and install them in /tmp/libretto:
    make modules
    make PREFIX=/tmp/libretto modules_install
  6. (Optional) You may wish to obtain the XForms library, so that you can compile cardinfo (an X11-based utility that displays information about whatever is in the PCMCIA slot of the Libretto (and of its port replicator, if connected). This utility is compiled automatically while building the PCMCIA kernel modules, provided that the XForms library has been installed. This library is available from Red Hat's FTP server and its mirrors, but (because of distribution restrictions) is not included on the RHL CD-ROMs. If you want it, download and install

    If you skip this step, you can always compile cardinfo later if you want it -- see the PCMCIA HOWTO for details.

  7. Configure the pcmcia-cs package:
    cd /usr/src/pcmcia-cs
    make config
    The configuration process is interactive. Accept the default responses, except that you should specify /tmp/libretto as the alternate target install directory, and you should enter 2 (read from the Linux source tree) when asked to set kernel-specific options. Here is a sample of the output of make config, including my responses to prompts:
    Linux PCMCIA Configuration Script
    The default responses for each question are correct for most users.
    Consult the PCMCIA-HOWTO for additional info about each option.
    Linux source directory [/usr/src/linux]: 
    Alternate target install directory []: /tmp/libretto
    C compiler name [gcc]: 
    Linker name [ld]: 
    Compiler flags for debugging []: 
    Build 'trusting' versions of card utilities (y/n) [n]: 
    The PCMCIA drivers need to be compiled to match the kernel they
    will be used with, or some or all of the modules may fail to load.
    If you are not sure what to do, please consult the PCMCIA-HOWTO.
    How would you like to set kernel-specific options?
        1 - Read from the currently running kernel
        2 - Read from the Linux source tree
        3 - Set each option by hand (experts only!)
    Enter option (1-3) [1]: 2
    Kernel configuration options:
        Symmetric multiprocessing support is disabled.
        PCI BIOS support is disabled.
        Advanced Power Management (APM) support is enabled.
        SCSI support is enabled.
        Networking support is enabled.
         IPv6 support is disabled.
         Radio network interface support is disabled.
         Token Ring device support is disabled.
        Module version checking is enabled.
        PCMCIA IDE device support is enabled.
        DEC Alpha UDB target platform is disabled.
    The kernel source tree is version 2.0.32.
    The current kernel build date is Fri Feb 13 06:56:32 EST 1998.
    WARNING: the source tree has a build date of Wed Feb 18 17:45:16 EST 1998.
       Did you forget to install your new kernel?!?
    Your module utilities are version 2.1.55.
    It looks like you have a System V init file setup.
    X Windows include files found.
    /usr/X11/lib/libforms.a found.
  8. Now compile the PCMCIA modules and install them in /tmp/libretto:
    make all
    make install

This completes the compilation of the stage 1 kernel and modules. The stage 2 kernel and modules are compiled using a similar procedure:

  1. Download the stage 2 kernel configuration file (see the HTML version of this file for a link), and install it as /usr/src/linux/.config. Once again, if you make changes in .config, be sure to include support for kernel modules (since PCMCIA support is available only as modules). Since the stage 2 kernel will be using the internal drive for the root file system, ppa support may be included as a module rather than being compiled directly into the kernel. By selecting modular ppa, plip, and parallel printer support, as is the default for the stage 2 kernel, the parallel port can be shared between these devices, which is not possible if any of them is compiled as part of the kernel itself.
  2. Save a copy of the stage 2 kernel configuration file in /tmp/libretto/stage2/config. (This will eventually be installed in /usr/src/linux/.config on the Libretto, so that you can use it as a base for building a new kernel there if you need to do so in the future.)
  3. Build the stage 2 kernel by:
    make clean
    make dep
    make zImage
    cp /usr/src/linux/arch/i386/boot/zImage /tmp/libretto/stage2/boot/vmlinuz
    cp /usr/src/linux/ /tmp/libretto/stage2/boot/
    rdev /tmp/libretto/stage2/boot/vmlinuz /dev/hda2
    rdev -s /tmp/libretto/stage2/boot/vmlinuz /dev/hda3
    Again, the make commands may take anywhere from a few minutes to an hour or more. The rdev commands set the root and swap partitions to be used by the stage 2 kernel; these correspond to the Linux partitions to be created on the Libretto's internal drive. (If your desktop PC does not have any IDE drives, these rdev commands will fail unless you first create /dev/hda2 and /dev/hda3; use /dev/MAKEDEV to do so if necessary.)
  4. Make a set of modules (excluding the PCMCIA modules), and install them in /tmp/libretto/stage2:
    make modules
    make PREFIX=/tmp/libretto/stage2 modules_install
  5. Configure the pcmcia-cs package:
    cd /usr/src/pcmcia-cs
    make config
    This time, specify /tmp/libretto/stage2 as the alternate target install directory; the other questions should be answered as for stage 1.
  6. Now compile the PCMCIA modules and install them in /tmp/libretto/stage2:
    make all
    make install

Creating boot diskettes

Insert a blank diskette in your desktop PC's diskette drive, and type:

cp /tmp/libretto/boot/vmlinuz /dev/fd0

Label this diskette ``Libretto stage 1 boot''.

Insert a second blank floppy in your diskette drive, and type:

cp /tmp/libretto/stage2/boot/vmlinuz /dev/fd0

Label this diskette ``Libretto stage 2 boot''.

Creating a root Zip disk

The Zip drive should be installed on your desktop PC for this step. If the kernel running on your desktop PC doesn't include ppa support, you may need to make a new kernel for your desktop PC as well. In this case, ppa support can be added as a module (since you won't need to use the Zip drive to mount the root partition there). If you use a parallel printer or PLIP on your desktop PC, support for these should be disabled or compiled as modules, since either will otherwise interfere with access to the Zip drive.

My desktop PC has a regular SCSI disk (sda) and a SCSI Jaz drive (sdb), so the Zip drive is recognized as sdc. Note the name that your Linux kernel associates with your Zip drive when your desktop PC is rebooting.

Prepare the Zip disk by creating root and swap partitions using fdisk:

fdisk /dev/sdc

(replacing /dev/sdc with the device name for the Zip drive on your system) to obtain the following partition table:

Disk /dev/sdc: 64 heads, 32 sectors, 96 cylinders
Units = cylinders of 2048 * 512 bytes

   Device Boot   Begin    Start      End   Blocks   Id  System
/dev/sdc1            1        1       81    82928   83  Linux native
/dev/sdc2           82       82       96    15360   82  Linux swap

Be very careful to partition the Zip disk and not your system disk! Check the partition table carefully (using fdisk's p command) before writing it to the disk and exiting. Next, format these partitions:

mke2fs -c /dev/sdc1
mkswap -c /dev/sdc2 15360

The mke2fs shows its progress as it runs, taking about half an hour on my system (this might be significantly faster on a machine that supports one of the faster ppa modes, but my desktop PC's parallel port was restricted to 4-bit mode). The mkswap command took around 10 minutes, I think, and gave no evidence of activity until it finished. Be patient!

Next, make a mount point for the Zip disk's root partition and mount it:

mkdir /zip
mount /dev/sdc1 /zip -t ext2

John Wiggins,, has written an excellent guide for the next steps, Installing Linux on ZIP disk using ppa ZIP Drive Mini-Howto, I wrote a script, install-to-zip, that automates much of the task of building a Linux root partition on a Zip disk. The script installs the RHL ``base'' set of RPMs on the Zip disk, creates an initial etc/ and an initial etc/fstab, copies the files in /tmp/libretto (created above) into the appropriate places in the Zip disk's file system, creates a PCMCIA configuration file (etc/sysconfig/pcmcia), and makes a link for the Libretto's pointing device from dev/psaux to dev/mouse.

Mount the first CD-ROM from the Red Hat Linux 5.0 set, and go into its RedHat/RPMS directory (or make a directory on your hard drive and fill it with the RPMs from Red Hat's FTP site). Run install-to-zip from within this directory. On my desktop PC, install-to-zip takes about 45 minutes to run, because the Zip drive is slo-o-o-o-ow, at least in nibble mode. While waiting for this to finish on the desktop PC, you can go ahead to the next step on the Libretto.

4.3 Partitioning the Libretto's hard drive

Although it is possible (indeed, if you use this approach, necessary) to run Linux from an external Zip disk attached to the Libretto, this is only a preparatory step on the way to running Linux from the Libretto's internal disk. As in most Linux installations, we will need to create partitions on this disk for Linux.

An important point to remember is that the Libretto uses the last few cylinders of its hard drive to store its state when it goes into ``hibernation'' (suspend) mode. On the Libretto 50 and 70, with a maximum of 32 Mb of RAM, this region covers the last 18 cylinders. (The Libretto 20 and 30 can have at most 20 Mb RAM, and their hibernation region is reported to be proportionately smaller; presumably the 100CT, with a maximum of 64 Mb RAM, will have a larger suspend area.) The BIOS of the Libretto 50 and 70 (and presumably later models) hides these from software such as fdisk, and reports only the number of cylinders available for file systems. (Thus fdisk on the Libretto 70 reports that the total disk space is 1516 Mb.) If your Libretto is a different model, it would be a good idea to use DOS/Windows fdisk to check the partition size before changing anything, and then to avoid using any cylinders other than those already allocated. If you move your hard drive to another machine to install Linux, be aware that these ``hidden'' cylinders will appear, but they must not be used. It's also important to be sure that LBA (logical block addressing) is enabled on your second machine (as on the Libretto) if you use this approach.

The IBM DDLA-21620 disk used in the Libretto 70 has 3152 cylinders, 16 heads, and 63 sectors. LBA remaps each set of 4 physical cylinders into 1 logical cylinder, so that (if removed and installed in another machine with LBA enabled) the disk appears to have 788 cylinders, 64 heads, and 63 sectors. Within the Libretto 70, the BIOS hides the last 18 logical cylinders, so that the disk appears to have 770 cylinders, 64 heads, and 63 sectors.

Shrinking the Windows partition

Before you do anything to your Libretto's hard drive, you should prepare a Windows 95 emergency boot diskette in case of problems, and back up the system software and any of your own files. There is very little chance that you will need these diskettes as a result of installing Linux on your Libretto, but (paraphrasing Jerry Pournelle) if you ever do need them, you will need them badly.

To repartition the Libretto's disk, you can use either FIPS (a DOS utility included with RHL, or available by FTP from any of the Linux archive sites), or a commercial application such as Partition Magic. Of course, if you don't need to play reversi occasionally, you can simply delete the Windows partition :-). (In fact, it is probably a good idea to retain a small Windows partition so that you can read and write floppy disks, and tune up the power-saving features of the Libretto to your liking.)

The disk of the Libretto 70 is large enough that the notorious Windows FAT32 file system might be an issue. Mine was delivered with a FAT16 file system, which FIPS can handle without difficulty. If you have succumbed to the temptation to convert yours to FAT32 format (a possibility offered to you by Windows fdisk), you will probably need to use Partition Magic rather than FIPS (but look at Linux FAT32 Support,, for the latest news on a revised FIPS and on adding FAT32 support to the Linux kernel).

Read the documentation for your chosen repartitioning utility and follow its instructions to the letter. I squeezed my Windows 95 FAT16 partition down to an even 500 Mb. (This should leave enough room to install reversi from my old Windows 3.0 disks ....)

4.4 Booting Linux on the Libretto

Once install-to-zip has finished on the desktop PC, we're ready to boot Linux on the Libretto for the first time. Shut down the desktop PC and the Libretto. Move the Zip drive, with the disk created by install-to-zip, from the desktop PC to the Libretto's port replicator, attach the port replicator and the floppy drive to the Libretto, load the ``Libretto stage 1 boot'' diskette you made earlier, and turn on the Libretto.

If all goes as it should, the Libretto should boot Linux from the diskette, and continue running from the Zip drive. If Linux boots, but stops with a kernel panic when attempting to mount the root partition, this is probably the result of not properly setting the root device on the diskette using rdev (see above). Other error messages while booting may be ignored for now.

Once you see the localhost login: prompt, you are ready to proceed. Log in as root (at this point, there is no password).

4.5 Creating partitions for Linux

Now we can create Linux root and swap partitions on the Libretto's hard drive. Type:

fdisk /dev/hda

On my Libretto, after having reduced the size of the Windows partition, fdisk reported that the partition table looked like this:

Disk /dev/hda: 64 heads, 63 sectors, 770 cylinders
Units = cylinders of 4032 * 512 bytes

   Device Boot   Begin    Start     End   Blocks   Id  System
/dev/hda1   *        1        1     254   512032+   6  DOS 16-bit >=32M

I created a single large partition for Linux, and a (slightly under) 32 Mb Linux swap partition:

/dev/hda2          255      255     754  1008000   83  Linux native
/dev/hda3          755      755     770    32256   82  Linux swap

You may wish to make a smaller root partition, and then create additional partitions for /home, /tmp, and possibly others as well. This strategy has definite advantages, particularly for a multi-user machine; the drawback is that you must know at the outset how much space each partition will require, and this is not always easy to estimate.

Check your partition table carefully using fdisk's p command before committing it to disk and exiting from fdisk. Now format the partitions you have created. In my case, I did this:

mke2fs -c /dev/hda2
mkswap -c /dev/hda3 32256

(The number at the end of the mkswap command should match the size of the swap partition you have created, as reported by fdisk. If you created additional partitions, format them using mke2fs as above.)

4.6 Installing Linux on the hard drive

Now we are ready to begin the main installation process. At this point it should be possible to mount the newly created ext2fs file system:

mount /linux

(Read /etc/fstab to see why this works.)

Transferring the Zip disk contents to the hard drive

The install-to-zip script created a small install-from-zip script that will replicate the contents of the Zip disk on the Libretto's hard drive, so this step is easy:

sh /tmp/install-from-zip

This script will take about 20 minutes or so to complete; when it does, log out.

Booting from the stage 2 diskette

At this point, it should be possible to boot from the ``Libretto stage 2 boot'' diskette. Use the halt command to shut down Linux gracefully. If your BIOS is suitably configured, this command will power down the Libretto after halting; otherwise, power it down manually.

Unload the Zip disk, insert the ``Libretto stage 2 boot'' diskette, and reboot. If this doesn't work, the rdev commands may not have been correct; you can run the correct commands on your desktop PC if necessary. It is also possible that the install-from-zip script may not have completed successfully. In any case, do not continue until you are able to boot successfully from the stage 2 diskette.

Installing LILO (optional)

If all has gone well so far, you may install LILO so that it will be possible to boot directly from the hard drive without needing a boot diskette. First, examine /etc/lilo.conf, which should look like this:


This configuration will cause LILO to boot Linux by default (i.e., if you do not type ``win95'' within 5 seconds after the LILO boot: prompt appears). If you prefer to boot Windows 95 by default, for whatever reason, edit /etc/lilo.conf, rearranging the stanzas like this:


If any of this is unfamiliar, review the LILO documentation before continuing, or skip the rest of this section and continue booting using the stage 2 diskette for now.

If you are satisfied with /etc/lilo.conf and wish to install LILO, type:


This command installs LILO at the beginning of the Linux partition (it does not modify the master boot record, so if you have second thoughts, you should still be able to boot Windows 95 by removing the Linux boot diskette and rebooting in the usual way).

To allow LILO to control the boot process, use fdisk's a command to make /dev/hda2 (the Linux root partition) bootable, and mark /dev/hda1 (the Windows 95 partition) as non-bootable. My partition table looks like this, viewed using fdisk's p command:

Disk /dev/hda: 64 heads, 63 sectors, 770 cylinders
Units = cylinders of 4032 * 512 bytes

   Device Boot   Begin    Start      End   Blocks   Id  System
/dev/hda1            1        1      254   512032+   6  DOS 16-bit >=32M
/dev/hda2   *      255      255      754  1008000   83  Linux native
/dev/hda3          755      755      770    32256   82  Linux swap

Uninstalling LILO

If for any reason you wish to return to the status quo ante (booting Windows 95 unless a Linux boot floppy is loaded), boot Linux and use fdisk to mark the Windows 95 partition as bootable once again.

4.7 Access to other file systems under Linux

The Windows partition

The install-from-zip script makes the Windows partition accessible in the /dos directory. Windows 95 long filenames appear correctly. All users can read files in the /dos directory; root permissions are needed in order to create, modify, or delete files there.


It does not appear to be possible to read diskettes under Linux, since Linux does not use the BIOS to access diskettes and the only access appears to be via the BIOS (Toshiba has not released information about the interface). Of course, you can always copy files between the diskette drive and the Windows partition while running Windows, and read or write files on the Windows partition while running Linux, as noted above. I have not yet investigated the possibility of access to diskettes via dosemu under Linux.

Zip disks

If you have formatted partition 1 of a Zip disk as a Linux ext2 file system, you may mount it using the command

mount /zip

If you have a DOS- or Windows-formatted Zip disk, you can mount it using the command

mount /dev/sda4 /zip -t vfat

(Root permissions are required in this case.)

Always unmount a Zip disk using

umount /zip

before removing it from the drive or turning the drive off.

All users can mount and unmount Zip disks, and read files in the /zip directory; root permissions are needed to create, modify, or delete files in the /zip directory.


If you have a supported PCMCIA SCSI adapter and a compatible CD-ROM drive, it is easy to read CD-ROMs under Linux. Attach the CD-ROM drive to the adapter, turn on the drive, and load a CD-ROM into the drive. Boot Linux and log in as root, then insert the SCSI adapter into the PCMCIA slot of the Libretto.

You should hear two beeps at the same pitch (the first signals that a PCMCIA device has been inserted, and the second indicates that it has been successfully configured). If the second beep is at a lower pitch than the first, the device was not configured successfully. If you have logged into the first virtual console, you will also see detailed status messages; on my Libretto, this report appears when I plug in my Adaptec SCSI adapter and Sony PRD-650 CD-ROM drive:

aha152x: processing commandline: ok
aha152x: BIOS test: passed, detected 1 controller(s)
aha152x0: vital data: PORTBASE=0x340, IRQ=9, SCSI ID=7, reconnect=enabled,
 parity=enabled, synchronous=disabled, delay=100, extended translation=disabled
aha152x: trying software interrupt, ok.
scsi1 : Adaptec 152x SCSI driver; $Revision: 1.18 $
scsi : 2 hosts.
  Vendor: SONY      Model: Discman PRD-650  Rev: 1.00
  Type:   CD-ROM                            ANSI SCSI revision: 02
Detected scsi CD-ROM sr0 at scsi1, channel 0, id 3, lun 0
Disc change detected.

Once the hardware has been recognized, type

mount /cdrom

and the CD-ROM contents should be readable within the /cdrom directory. Before changing CD-ROMs, type

umount /cdrom

Always unmount the CD-ROM in this way before removing the SCSI adapter or turning the CD-ROM drive off.

4.8 Completing the RHL 5.0 installation

At this point, you should have a Libretto that runs either Linux or Windows 95 from its internal disk (possibly requiring a Linux boot floppy to run Linux, if you skipped the last section above). We have only a bare-bones Linux installation so far, however.

Unfortunately, Red Hat does not support any easy way to bootstrap a more complete Linux installation on a running (minimal) Linux PC. (The usual way requires booting from a floppy, which, as we have seen, doesn't work for the Libretto.) There is, however, an easy way to install nearly everything in RHL 5.0 on a Libretto 70 with very little effort, provided that you have a supported PCMCIA SCSI adapter with an attached CD-ROM drive as described above: simply mount the RHL 5.0 CD-ROM 1 on /cdrom as above, then type:

cd /cdrom/RedHat/RPMS
rpm -i -h -v --nodeps *

Depending on the speed of your CD-ROM drive, this command will require between 20 minutes and an hour to complete. When it is finished, update the RPM dependency database using the command:

rpm --rebuilddb

On a Libretto 50, you will need to be selective in determining which RPMs to install, since there will not be enough room for all of them unless you have reduced the size of the Windows 95 partition severely.

If you don't have a PCMCIA CD-ROM drive

There are many alternatives to the procedure described above. A simple (though somewhat time-consuming) solution is to copy the RPMs from the RHL CD-ROM to Zip disks and then to install them using the same procedure as above. Use your desktop PC to repartition and reformat additional Zip disks as needed (you do not need to create a swap partition as we did for the root disk, but you should format partition 1 as an ext2 file system before using a new Zip disk). Copy up to 100 Mb of RPMs onto each Zip disk, and use ``mount /zip'' on the Libretto to make a Zip disk accessible.

Next Previous Contents