home *** CD-ROM | disk | FTP | other *** search
/ PC World 1999 August / PCWorld_1999-08_cd.bin / doc / HOWTO / mini / Loopback-Root-FS < prev    next >
Text File  |  1998-07-22  |  24KB  |  859 lines
  1.   The Loopback Root Filesystem HOWTO
  2.   by Andrew M. Bishop, amb@gedanken.demon.co.uk
  3.   v1.0.0, 12 June 1998
  4.  
  5.   This HOWTO explains how to use the Linux loopback device to create a
  6.   Linux native filesystem format installation that can be run from a DOS
  7.   partition without re-partitioning.  Other uses of this same technique
  8.   are also discussed.
  9.   ______________________________________________________________________
  10.  
  11.   Table of Contents
  12.  
  13.  
  14.   1. Principles of Loopback Devices and Ramdisks
  15.  
  16.      1.1 Loopback Devices
  17.      1.2 Ramdisk Devices
  18.      1.3 The Initial Ramdisk Device
  19.      1.4 The Root Filesystem
  20.      1.5 The Linux Boot Sequence
  21.  
  22.   2. How To Create a Loopback Root Device
  23.  
  24.      2.1 Requirements
  25.      2.2 Creating the Linux Kernel
  26.      2.3 Creating the Initial Ramdisk Device
  27.      2.4 Creating The Root Device
  28.      2.5 Creating the Swap Device
  29.      2.6 Creating the MSDOS Directory
  30.      2.7 Creating the Boot Floppy
  31.  
  32.   3. Booting the System
  33.  
  34.      3.1 Possible Problems With Solutions
  35.      3.2 Reference Documents
  36.  
  37.   4. Other Loopback Root Device Possibilities
  38.  
  39.      4.1 DOS Hard-disk Only Installation
  40.      4.2 LILO Booted Installation
  41.      4.3 VFAT / NTFS Installation
  42.      4.4 Installing Linux without Re-partitioning
  43.      4.5 Booting From a Non-bootable device
  44.  
  45.  
  46.   ______________________________________________________________________
  47.  
  48.   1.  Principles of Loopback Devices and Ramdisks
  49.  
  50.   First I will describe some of the general principles that are used in
  51.   the setting up of a loopback filesystem as the root device.
  52.  
  53.  
  54.  
  55.   1.1.  Loopback Devices
  56.  
  57.   A loopback device in Linux is a virtual device that can be used like
  58.   any other media device.
  59.  
  60.  
  61.   Examples of normal media devices are hard disk partitions like
  62.   /dev/hda1, /dev/hda2, /dev/sda1, or entire disks like the floppy disk
  63.   /dev/fd0 etc.  They are all devices that can be used to hold a files
  64.   and directory structures.  They can be formatted with the filesystem
  65.   that is required (ext2fs, msdos, ntfs etc.) and then mounted.
  66.  
  67.   The loopback filesystem associates a file on another filesystem as a
  68.   complete device.  This can then be formatted and mounted just like any
  69.   of the other devices listed above.  To do this the device called
  70.   /dev/loop0 or /dev/loop1 etc is associated with the file and then this
  71.   new virtual device is mounted.
  72.  
  73.  
  74.  
  75.   1.2.  Ramdisk Devices
  76.  
  77.   In Linux it is also possible to have another type of virtual device
  78.   mounted as a filesystem, this is the ramdisk device.
  79.  
  80.  
  81.   In this case the device does not refer to any physical hardware, but
  82.   to a portion of memory that is set aside for the purpose.  The memory
  83.   that is allocated is never swapped out to disk, but remains in the
  84.   disk cache.
  85.  
  86.  
  87.   A ramdisk can be created at any time by writing to the ramdisk device
  88.   /dev/ram0 or /dev/ram1 etc.  This can then be formatted and mounted in
  89.   the same way that the loopback device is.
  90.  
  91.  
  92.   When a ramdisk is used to boot from (as is often done on Linux
  93.   installation disks or rescue disks) then the disk image (the entire
  94.   contents of the disk as a single file) can be stored on the boot
  95.   floppy in a compressed form.  This is automatically recognised by the
  96.   kernel when it boots and is uncompressed into the ramdisk before it is
  97.   mounted.
  98.  
  99.  
  100.  
  101.   1.3.  The Initial Ramdisk Device
  102.  
  103.   The initial ramdisk device in Linux is another important mechanism
  104.   that we need to be able to use a loopback device as a the root
  105.   filesystem.
  106.  
  107.  
  108.   When the initial ramdisk is used the filesystem image is copied into
  109.   memory and mounted so that the files on it can be accessed.  A program
  110.   on this ramdisk (called /linuxrc) is run and when it is finished a
  111.   different device is mounted as the root filesystem.  The old ramdisk
  112.   is still present though and is mounted on the directory /initrd if
  113.   present or available through the device /dev/initrd.
  114.  
  115.  
  116.   This is unusual behaviour since the normal boot sequence boots from
  117.   the designated root partition and keeps on running.  With the initial
  118.   ramdisk option the root partition is allowed to change before the main
  119.   boot sequence is started.
  120.  
  121.  
  122.  
  123.   1.4.  The Root Filesystem
  124.  
  125.   The root filesystem is the device that is mounted first so that it
  126.   appears as the directory called / after booting.
  127.  
  128.  
  129.   There are a number of complications about the root filesystem that are
  130.   due to the fact that it contains all files.  When booting the rc
  131.   scripts are run, these are either the files in /etc/rc.d or /etc/rc?.d
  132.   depending on the version of the /etc/init program.
  133.   When the system has booted it is not possible to unmount the root
  134.   partition or change it since all programs will be using it to some
  135.   extent.  This is why the initial ramdisk is so useful because it can
  136.   be used so that the final root partition is not the same as the one
  137.   that is loaded at boot time.
  138.  
  139.  
  140.  
  141.   1.5.  The Linux Boot Sequence
  142.  
  143.   To show how the initial ramdisk operates in the boot sequence, the
  144.   order of events is listed below.
  145.  
  146.  
  147.  
  148.   1. The kernel is loaded into memory, this is performed by LILO or
  149.      LOADLIN.  You can see the Loading... message as this happens.
  150.  
  151.   2. The ramdisk image is loaded into memory, again this is performed by
  152.      LILO or LOADLIN. You can see the Loading... message again as this
  153.      happens.
  154.  
  155.   3. The kernel is initialised, including parsing the command line
  156.      options and setting of the ramdisk as the root device.
  157.  
  158.   4. The program /linuxrc is run on the initial ramdisk.
  159.  
  160.   5. The root device is changed to that specified in the kernel
  161.      parameter.
  162.  
  163.   6. The init program /etc/init is run which will perform the user
  164.      configurable boot sequence.
  165.  
  166.   This is just a simplified version of what happens, but is sufficient
  167.   to explain how the kernel starts up and where the initial ramdisk is
  168.   used.
  169.  
  170.  
  171.  
  172.   2.  How To Create a Loopback Root Device
  173.  
  174.   Now that the general principles are explained the method of creating
  175.   the loopback device can be explained.
  176.  
  177.  
  178.  
  179.   2.1.  Requirements
  180.  
  181.   To create the loopback root device will require a number of things.
  182.  
  183.  
  184.  
  185.   ╖  A working Linux system.
  186.  
  187.   ╖  A way to copy large files onto the target DOS partition.
  188.  
  189.   Most important is access to an installed Linux system.  This is
  190.   because the loop device can only be created under Linux.  This will
  191.   mean that it is not possible to bootstrap a working system from
  192.   nothing.  The requirements of the Linux system that you use is that
  193.   you can compile a kernel on it.
  194.  
  195.  
  196.   Once the loopback device is created it will be a large file.  I have
  197.   used an 80 MB files, but while this was sufficient for an X terminal
  198.   it may not be enough if you want to use it for much else.  This file
  199.   must be copied onto the DOS partition, so either a network or a lot of
  200.   floppy disks must be used.
  201.  
  202.  
  203.   The software that you will require includes
  204.  
  205.  
  206.   ╖  LOADLIN version 1.6 or above
  207.  
  208.   ╖  A version of mount that supports loopback devices
  209.  
  210.   ╖  A version of the kernel that supports the required options.
  211.  
  212.   All of these should be standard for recent Linux installations.
  213.  
  214.  
  215.  
  216.   2.2.  Creating the Linux Kernel
  217.  
  218.   I created the loopback device using Linux kernel version 2.0.31, other
  219.   versions should also work, but they must have at least the options
  220.   listed below.
  221.  
  222.  
  223.   The kernel options that you will need to enable are the following:
  224.  
  225.   ╖  RAM disk support (CONFIG_BLK_DEV_RAM).
  226.  
  227.   ╖  Initial RAM disk (initrd) support (CONFIG_BLK_DEV_INITRD).
  228.  
  229.   ╖  Loop device support (CONFIG_BLK_DEV_LOOP).
  230.  
  231.   ╖  fat fs support (CONFIG_FAT_FS).
  232.  
  233.   ╖  msdos fs support (CONFIG_MSDOS_FS).
  234.  
  235.   The first two are for the RAM disk device itself and the initial ram
  236.   disk device.  The next one is the loop back filesystem option.  The
  237.   last two are the msdos filesystem support which is required to mount
  238.   the DOS partitition.
  239.  
  240.  
  241.   Compiling a kernel without modules is the easiest option, although if
  242.   you do want modules then it should be possible although I have not
  243.   tried it.  If modules are used then you should have the options above
  244.   compiled in and not as modules themselves.
  245.  
  246.  
  247.   The kernel source code itself will need to be changed in one very
  248.   simple way.  The version 2.0.34 kernel as supplied does not allow the
  249.   loopback device to be used as the root filesystem.  One very small
  250.   kernel patch can make this possible.
  251.  
  252.   The file /init/main.c needs to have a single line added to it as shown
  253.   by the modified version below.  The line that says "loop", 0x0700 is
  254.   the one that was added.
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.   static void parse_root_dev(char * line)
  266.   {
  267.           int base = 0;
  268.           static struct dev_name_struct {
  269.                   const char *name;
  270.                   const int num;
  271.           } devices[] = {
  272.                   { "nfs",     0x00ff },
  273.                   { "loop",    0x0700 },
  274.                   { "hda",     0x0300 },
  275.  
  276.   ...
  277.  
  278.                   { "sonycd",  0x1800 },
  279.                   { NULL, 0 }
  280.           };
  281.  
  282.   ...
  283.  
  284.   }
  285.  
  286.  
  287.  
  288.  
  289.   Once the kernel is configured it should be compiled to produce a
  290.   zImage file (make zImage).  This file will be arch/i386/boot/zImage
  291.   when compiled.
  292.  
  293.  
  294.  
  295.   2.3.  Creating the Initial Ramdisk Device
  296.  
  297.   The initial ramdisk is most easily created as a loopback device from
  298.   the start.  You will need to do this as root, the commands that you
  299.   need to execute are listed below, they are assumed to be run from
  300.   root's home directory (/root).
  301.  
  302.  
  303.  
  304.  
  305.        mkdir /root/initrd
  306.        dd if=/dev/zero of=initrd.img bs=1k count=1024
  307.        mke2fs -i 1024 -b 1024 -m 5 -F -v initrd.img
  308.        mount initrd.img /root/initrd -t ext2 -o loop
  309.        cd initrd
  310.        [create the files]
  311.        cd ..
  312.        umount /root/initrd
  313.        gzip -c -9 initrd.img > initrdgz.img
  314.  
  315.  
  316.  
  317.  
  318.   There are a number of steps to this, but they can be described as
  319.   follows.
  320.  
  321.   1. Create a mount point for the initial ramdisk (an empty directory).
  322.  
  323.   2. Create an empty file of the size required.  Here I have used
  324.      1024kB, you may need less or more depending on the contents, (the
  325.      size is the last parameter).
  326.  
  327.   3. Make an ext2 filesystem on the empty file.
  328.  
  329.   4. Mount the file onto the mount point, this uses the loopback device.
  330.  
  331.   5. Change to the mounted loopback device.
  332.  
  333.   6. Create the files that are required (see below for details).
  334.  
  335.   7. Move out of the mounted loopback device.
  336.  
  337.   8. Unmount the device.
  338.  
  339.   9. Create a compressed version for use later.
  340.  
  341.   Contents Of The Initial Ramdisk
  342.  
  343.   The files that you will need on the ramdisk are the minimum
  344.   requirements to be able to execute any commands.
  345.  
  346.  
  347.   ╖  /linuxrc The script that is run to mount the msdos file system (see
  348.      below).
  349.  
  350.   ╖  /lib/* The dynamic linker and the libraries that the programs need.
  351.  
  352.   ╖  /etc/* The cache used by the dynamic linker (not strictly needed,
  353.      but does stop it complaining).
  354.  
  355.   ╖  /bin/* A shell interpreter (ash because it is smaller than bash.
  356.      The mount and losetup programs for handling the DOS disk and
  357.      setting up the loopback devices.
  358.  
  359.   ╖  /dev/* The devices that will be used.  You need /dev/zero for ld-
  360.      linux.so, /dev/hda* to mount the msdos disk and /dev/loop* for the
  361.      lopback device.
  362.  
  363.   ╖  /mnt An empty directory to mount the msdos disk on.
  364.  
  365.   The initial ramdisk that I used is listed below, the contents come to
  366.   about 800kB when the overhead of the filesystem are taken into
  367.   account.
  368.  
  369.  
  370.  
  371.  
  372.  
  373.  
  374.  
  375.  
  376.  
  377.  
  378.  
  379.  
  380.  
  381.  
  382.  
  383.  
  384.  
  385.  
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396.  
  397.   total 18
  398.   drwxr-xr-x   2 root     root         1024 Jun  2 13:57 bin
  399.   drwxr-xr-x   2 root     root         1024 Jun  2 13:47 dev
  400.   drwxr-xr-x   2 root     root         1024 May 20 07:43 etc
  401.   drwxr-xr-x   2 root     root         1024 May 27 07:57 lib
  402.   -rwxr-xr-x   1 root     root          964 Jun  3 08:47 linuxrc
  403.   drwxr-xr-x   2 root     root        12288 May 27 08:08 lost+found
  404.   drwxr-xr-x   2 root     root         1024 Jun  2 14:16 mnt
  405.  
  406.   ./bin:
  407.   total 168
  408.   -rwxr-xr-x   1 root     root        60880 May 27 07:56 ash
  409.   -rwxr-xr-x   1 root     root         5484 May 27 07:56 losetup
  410.   -rwsr-xr-x   1 root     root        28216 May 27 07:56 mount
  411.   lrwxrwxrwx   1 root     root            3 May 27 08:08 sh -> ash
  412.  
  413.   ./dev:
  414.   total 0
  415.   brw-r--r--   1 root     root       3,   0 May 20 07:43 hda
  416.   brw-r--r--   1 root     root       3,   1 May 20 07:43 hda1
  417.   brw-r--r--   1 root     root       3,   2 Jun  2 13:46 hda2
  418.   brw-r--r--   1 root     root       3,   3 Jun  2 13:46 hda3
  419.   brw-r--r--   1 root     root       7,   0 May 20 07:43 loop0
  420.   brw-r--r--   1 root     root       7,   1 Jun  2 13:47 loop1
  421.   crw-r--r--   1 root     root       1,   3 May 20 07:42 null
  422.   crw-r--r--   1 root     root       5,   0 May 20 07:43 tty
  423.   crw-r--r--   1 root     root       4,   1 May 20 07:43 tty1
  424.   crw-r--r--   1 root     root       1,   5 May 20 07:42 zero
  425.  
  426.   ./etc:
  427.   total 3
  428.   -rw-r--r--   1 root     root         2539 May 20 07:43 ld.so.cache
  429.  
  430.   ./lib:
  431.   total 649
  432.   lrwxrwxrwx   1 root     root           18 May 27 08:08 ld-linux.so.1 -> ld-linux.so.1.7.14
  433.   -rwxr-xr-x   1 root     root        21367 May 20 07:44 ld-linux.so.1.7.14
  434.   lrwxrwxrwx   1 root     root           14 May 27 08:08 libc.so.5 -> libc.so.5.3.12
  435.   -rwxr-xr-x   1 root     root       583795 May 20 07:44 libc.so.5.3.12
  436.  
  437.   ./lost+found:
  438.   total 0
  439.  
  440.   ./mnt:
  441.   total 0
  442.  
  443.  
  444.  
  445.  
  446.   The only complex steps about this are the devices in dev.  Use the
  447.   mknod program to create them, use the existing devices in /dev as a
  448.   template to get the required parameters.
  449.  
  450.  
  451.   The /linuxrc file
  452.  
  453.   The /linuxrc file on the initial ramdisk is required to do all of the
  454.   preparations so that the loopback device can be used for the root
  455.   partition when it exits.
  456.  
  457.   The example below tries to mount /dev/hda1 as an msdos partition and
  458.   if it succeeds then sets up the files /linux/linuxdsk.img as
  459.   /dev/loop0 and /linux/linuxswp.img as /dev/loop1.
  460.  
  461.  
  462.  
  463.        #!/bin/sh
  464.  
  465.        echo INITRD: Trying to mount /dev/hda1 as msdos
  466.  
  467.        if /bin/mount -n -t msdos /dev/hda1 /mnt; then
  468.  
  469.           echo INITRD: Mounted OK
  470.           /bin/losetup /dev/loop0 /mnt/linux/linuxdsk.img
  471.           /bin/losetup /dev/loop1 /mnt/linux/linuxswp.img
  472.           exit 0
  473.  
  474.        else
  475.  
  476.           echo INITRD: Mount failed
  477.           exit 1
  478.  
  479.        fi
  480.  
  481.  
  482.  
  483.  
  484.   The first device /dev/loop0 will become the root device and the second
  485.   one /dev/loop1 will become the swap space.
  486.  
  487.  
  488.   If you want to be able to write to the DOS partition as a non-root
  489.   user when you have finished then you should use mount -n -t msdos
  490.   /dev/hda1 /mnt -o uid=0,gid=0,umask=000 instead.  This will map all
  491.   accesses to the DOS partition to root and set the permissions
  492.   appropriately.
  493.  
  494.  
  495.  
  496.   2.4.  Creating The Root Device
  497.  
  498.   The root device that you will be using is the file linuxdsk.img.  You
  499.   will need to create this in the same way that the initial ramdisk was
  500.   created, but bigger.  You can install any Linux installation that you
  501.   like onto this disk.
  502.  
  503.  
  504.   The easiest way might be to copy an existing Linux installation into
  505.   it.  An alternative is to install a new Linux installation onto it.
  506.  
  507.  
  508.   Assuming that you have done this, there are some minor changes that
  509.   you must make.
  510.  
  511.  
  512.   The /etc/fstab file must reference the root partition and the swap
  513.   using the two loopback devices that are setup on the initial ramdisk.
  514.  
  515.  
  516.  
  517.  
  518.        /dev/loop0     /      ext2   defaults 1 1
  519.        /dev/loop1     swap   swap   defaults 1 1
  520.  
  521.  
  522.  
  523.  
  524.   This will ensure that when the real root device is used the kernel
  525.   will not be confused about where the root device is.  It will also
  526.   allow the swap space to be added in the same way a swap partition is
  527.   normally used.  You should remove any other reference to a root disk
  528.   device or swap partition.
  529.   If you want to be able to read the DOS partition after Linux has
  530.   started then you will need to make a number of extra small changes.
  531.  
  532.  
  533.   Create a directory called /initrd, this is where the initial ramdisk
  534.   will be mounted once the loopback root filesystem is mounted.
  535.  
  536.   Create a symbolic link called /DOS that points to /initrd/mnt where
  537.   the real DOS parition will be mounted.
  538.  
  539.   Add a line into the rc file that mounts the disks.  This should run
  540.   the command mount -f -t msdos /dev/hda1 /initrd/mnt, this will create
  541.   a 'fake' mount of the DOS partition so that all programs (like df)
  542.   will know that the DOS partition is mounted and where to find it.  If
  543.   you used different options in the /linuxrc file that obviously you
  544.   should use them here also.
  545.  
  546.  
  547.   There is no need to have a Linux kernel on this root device since that
  548.   is already loaded earlier.  If you are using modules however then you
  549.   should include them on this device as normal.
  550.  
  551.  
  552.  
  553.   2.5.  Creating the Swap Device
  554.  
  555.   The root device that you will be using is the file linuxswap.img.  The
  556.   swap device is very simple to create.  Create an empty file as was
  557.   done for the initial ramdisk and then run mkswap linuxswap.img to
  558.   intialise it.
  559.  
  560.  
  561.   The size of the swap space will depend on what you plan to do with the
  562.   installed system, but I would recommend between 8MB and the amount of
  563.   RAM that you have.
  564.  
  565.  
  566.  
  567.   2.6.  Creating the MSDOS Directory
  568.  
  569.   The files that are going to be used need to be moved onto the DOS
  570.   partition.
  571.  
  572.  
  573.   The files that are required in the DOS directory called C:\LINUX are
  574.   the following:
  575.  
  576.  
  577.   ╖  LINUXDSK.IMG The disk image that will become the root device.
  578.  
  579.   ╖  LINUXSWP.IMG The swap space.
  580.  
  581.  
  582.   2.7.  Creating the Boot Floppy
  583.  
  584.   The boot floppy that is used is just a normal DOS format bootable
  585.   floppy.
  586.  
  587.   This is created using format a: /s from DOS.
  588.  
  589.  
  590.   Onto this disk you will need to create an AUTOEXEC.BAT file (as below)
  591.   and copy the kernel, compressed initial ramdisk and LOADLIN
  592.   executable.
  593.  
  594.  
  595.   ╖  AUTOEXEC.BAT The DOS automatically executed batch file.
  596.  
  597.   ╖  LOADLIN.EXE The LOADLIN program executable.
  598.  
  599.   ╖  ZIMAGE The Linux kernel.
  600.  
  601.   ╖  INITRDGZ.IMG The compressed initial ramdisk image.
  602.  
  603.   The AUTOEXEC.BAT file should contain just one line as below.
  604.  
  605.  
  606.  
  607.        \loadlin \zImage initrd=\initrdgz.img root=/dev/loop0 ro
  608.  
  609.  
  610.  
  611.  
  612.   This specifies the kernel image to use, the initial ramdisk image, the
  613.   root device after the initial ramdisk has finished and that the root
  614.   partition is to be mounted read-only.
  615.  
  616.  
  617.   3.  Booting the System
  618.  
  619.   To boot from this new root device all that is required is that the
  620.   floppy disk prepared as described above is inserted for the PC to boot
  621.   from.
  622.  
  623.  
  624.   You will see the following sequence of events.
  625.  
  626.   1. DOS boots
  627.  
  628.   2. AUTOEXEC.BAT starts
  629.  
  630.   3. LOADLIN is run
  631.  
  632.   4. The Linux kernel is copied into memory
  633.  
  634.   5. The initial ramdisk is copied into memory
  635.  
  636.   6. The Linux kernel is started running
  637.  
  638.   7. The /linuxrc file on the initial ramdisk is run
  639.  
  640.   8. The DOS partition is mounted and the root and swap devices set up
  641.  
  642.   9. The boot sequence continues from the loopback device
  643.  
  644.   When this is complete you can remove the boot floppy and use the Linux
  645.   system.
  646.  
  647.  
  648.   3.1.  Possible Problems With Solutions
  649.  
  650.   There are a number of stages where this process could fail, I will try
  651.   to explain what they are and what to check.
  652.  
  653.  
  654.   DOS booting is easy to recognise by the message that it prints MS-DOS
  655.   Starting ... on the screen.  If this is not seen then the floopy disk
  656.   is either not-bootable or the PC is not bootable from the floppy disk
  657.   drive.
  658.  
  659.  
  660.  
  661.   When the AUTOEXEC.BAT file is run the commands in it should be echoed
  662.   to the screen by default.  In this case there is just the single line
  663.   in the file that starts LOADLIN.
  664.  
  665.  
  666.   When LOADLIN executes it will do two very visible things, firstly it
  667.   will load the kernel into memory, secondly it will copy the ramdisk
  668.   into memory.  Both of these are indicated by a Loading... message.
  669.  
  670.  
  671.   The kernel starts by uncompressing itself, this can give crc errors if
  672.   the kernel image is corrupted.  Then it will start running the
  673.   initialisation sequence which is very verbose with diagnostic
  674.   messages.  Loading of the initial ramdisk device is also visible
  675.   during this phase.
  676.  
  677.  
  678.   When the /linuxrc file is run there is no diagnostic messages, but you
  679.   can add these yourself as an aid to debugging.  If this stage fails to
  680.   set up the loopback device as the root device then you may see a
  681.   message that there is no root device and the kernel aborts.
  682.  
  683.  
  684.   The normal boot sequence of the new root device will now continue and
  685.   this is quite verbose.  There may be problems about the root device
  686.   being mounted read-write, but the LOADLIN command line option 'ro'
  687.   should stop that.  Other problems that can occur are that the boot
  688.   sequence is confused about where the root device is, this is probably
  689.   due to a problem with /etc/fstab.
  690.  
  691.  
  692.   When the boot sequence has completed, the remaining problem is that
  693.   programs are confused about whether the DOS partition is mounted or
  694.   not.  This is why it is a good idea to use the fake mount command
  695.   described earlier.  This makes life a lot easier if you want to access
  696.   the files on the DOS device.
  697.  
  698.  
  699.  
  700.   3.2.  Reference Documents
  701.  
  702.   The documents that I used to create my first loopback root filesystem
  703.   were:
  704.  
  705.  
  706.  
  707.   ╖  The Linux kernel source, in particular init/main.c
  708.  
  709.   ╖  The Linux kernel documentation, in particular
  710.      Documentation/initrd.txt and Documentation/ramdisk.txt.
  711.  
  712.   ╖  The LILO documentation.
  713.  
  714.   ╖  The LOADLIN documentation
  715.  
  716.  
  717.  
  718.   4.  Other Loopback Root Device Possibilities
  719.  
  720.   Once the principle of booting a filesystem in a file on a DOS
  721.   partition has been established there are many other things that you
  722.   can now do.
  723.  
  724.  
  725.  
  726.  
  727.   4.1.  DOS Hard-disk Only Installation
  728.  
  729.   If it is possible to boot Linux from a file on a DOS harddisk by using
  730.   a boot floppy then it is obviously also possible to do it using the
  731.   harddisk itself.
  732.  
  733.   A configuration boot menu can be used to give the option of running
  734.   LOADLIN from within the AUTOEXEC.BAT.  This will give a much faster
  735.   boot sequence, but is otherwise identical.
  736.  
  737.  
  738.  
  739.   4.2.  LILO Booted Installation
  740.  
  741.   Using LOADLIN is only one option for booting a Linux kernel.  There is
  742.   also LILO that does much the same but without needing DOS.
  743.  
  744.   In this case the DOS format floppy disk can be replaced by an ext2fs
  745.   format one.  Otherwise the details are very similar, with the kernel
  746.   and the initial ramdisk being files on that disk.
  747.  
  748.   The reason that I chose the LOADLIN method is that the arguments that
  749.   need to be given to LILO are slightly more complex.  Also it is more
  750.   obvious to a casual observer what the floppy disk is since it can be
  751.   read under DOS.
  752.  
  753.  
  754.  
  755.   4.3.  VFAT / NTFS Installation
  756.  
  757.   I have tried the NTFS method, and have had no problems with it.  The
  758.   NTFS filesystem driver is not a standard kernel option, but you must
  759.   use the patch from Martin von L÷wis which is available from his web
  760.   page.  http://www.informatik.hu-berlin.de/~loewis/ntfs/.  This is
  761.   alpha software and requires a patch to the kernel which is not quite
  762.   trivial but not too difficult.
  763.  
  764.   The only changes for the VFAT or NTFS options are in the initial
  765.   ramdisk, the file /linuxrc needs to mount a file system of type vfat
  766.   or ntfs rather that msdos.
  767.  
  768.   I know of no reason why this should not also work on a VFAT partition.
  769.  
  770.  
  771.  
  772.   4.4.  Installing Linux without Re-partitioning
  773.  
  774.   The process of installing Linux on a PC from a standard distribution
  775.   requires booting from a floppy disk and re-partitioning the disk.
  776.   This stage could instead be accomplished by a boot floppy that creates
  777.   an empty loopback device and swap file.  This would allow the
  778.   installation to proceed as normal, but it would install into the
  779.   loopback device rather than a partition.
  780.  
  781.   This could be used as an alternative to a UMSDOS installation, it
  782.   would be more efficient in disk usage since the minimum allocation
  783.   unit in the ext2 filesystem is 1kB instead of up to 32kB on a DOS
  784.   partition.  It can also be used on VFAT and NTFS formatted disks which
  785.   are otherwise a problem.
  786.  
  787.  
  788.  
  789.   4.5.  Booting From a Non-bootable device
  790.  
  791.   This method can also be used to boot a Linux system from a device that
  792.   is not normally bootable.
  793.   ╖  CD-Rom
  794.  
  795.   ╖  Zip Disks
  796.  
  797.   ╖  Parallel port disk drives
  798.  
  799.   Obviously there are many other devices that could be used, NFS root
  800.   filesystems are already included in the kernel as an option, but the
  801.   method described here might also be used instead.
  802.  
  803.  
  804.  
  805.  
  806.  
  807.  
  808.  
  809.  
  810.  
  811.  
  812.  
  813.  
  814.  
  815.  
  816.  
  817.  
  818.  
  819.  
  820.  
  821.  
  822.  
  823.  
  824.  
  825.  
  826.  
  827.  
  828.  
  829.  
  830.  
  831.  
  832.  
  833.  
  834.  
  835.  
  836.  
  837.  
  838.  
  839.  
  840.  
  841.  
  842.  
  843.  
  844.  
  845.  
  846.  
  847.  
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854.  
  855.  
  856.  
  857.  
  858.  
  859.