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).
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, http://www.ucolick.org/~sutin/libretto.html, 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,
http://www.torque.net/~campbell/, 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,
jay@cimedia.com 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
http://www.geocities.com/SiliconValley/Haven/5112/). 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
http://www.users.fast.net/~rodsmith/rhjol-technical.html).
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:
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
ftp://ftp.redhat.com/pub/redhat/redhat-5.0/SRPMS/) 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.
If you wish to use the precompiled binaries:
/tmp/llbin.tar.gz (the HTML version
of this document,
http://ecg.mit.edu/george/libretto.html, contains
a link to the archive here).
cd /tmp
tar xfvz llbin.tar.gz
/tmp/libretto and
its subdirectories. Once you have unpacked the archive, you can delete
/tmp/llbin.tar.gz.)
If you wish to create the binaries from sources:
/usr/src/linux/.config) in another directory.
rpm -i /tmp/libretto/usr/src/kernel-2.0.32-2.src.rpm
/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.
/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.
make clean
make dep
make zImage
cp /usr/src/linux/arch/i386/boot/zImage /tmp/libretto/boot/vmlinuz
cp /usr/src/linux/System.map /tmp/libretto/boot/System.map
rdev /tmp/libretto/boot/vmlinuz /dev/sda1
rdev -s /tmp/libretto/boot/vmlinuz /dev/sda2
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.
/tmp/libretto:
make modules
make PREFIX=/tmp/libretto modules_install
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
ftp://ftp.redhat.com/pub/redhat/non-free/xforms-080-1.i386.rpm.
If you skip this step, you can always compile cardinfo later if
you want it -- see the PCMCIA HOWTO for details.
pcmcia-cs package:
cd /usr/src/pcmcia-cs
make config
/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.
/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:
/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.
/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.)
make clean
make dep
make zImage
cp /usr/src/linux/arch/i386/boot/zImage /tmp/libretto/stage2/boot/vmlinuz
cp /usr/src/linux/System.map /tmp/libretto/stage2/boot/System.map
rdev /tmp/libretto/stage2/boot/vmlinuz /dev/hda2
rdev -s /tmp/libretto/stage2/boot/vmlinuz /dev/hda3
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.)
/tmp/libretto/stage2:
make modules
make PREFIX=/tmp/libretto/stage2 modules_install
pcmcia-cs package:
cd /usr/src/pcmcia-cs
make config
/tmp/libretto/stage2 as the alternate target
install directory; the other questions should be answered as for stage 1.
/tmp/libretto/stage2:
make all
make install
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''.
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,
jwiggins@comp.uark.edu, has written an excellent guide for the next
steps, Installing Linux on ZIP disk using ppa ZIP Drive Mini-Howto,
http://comp.uark.edu/~jwiggins/linuxZIP. 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/ld.so.cache 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.
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.
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,
http://bmrc.berkeley.edu/people/chaffee/fat32.html, 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 ....)
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).
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.)
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.)
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.
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.
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:
boot=/dev/hda2
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
image=/boot/vmlinuz
label=linux
root=/dev/hda2
read-only
other=/dev/hda1
label=win95
loader=/boot/chain.b
table=/dev/hda
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:
boot=/dev/hda2
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
other=/dev/hda1
label=win95
loader=/boot/chain.b
table=/dev/hda
image=/boot/vmlinuz
label=linux
root=/dev/hda2
read-only
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:
/sbin/lilo
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
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.
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.
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.
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.
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.