The Loopback Root Filesystem HOWTO by Andrew M. Bishop, amb@gedanken.demon.co.uk v1.1.2, 23 Mar 2000 v1.1.5, 26 Sep 2000 Kent Robotti This HOWTO explains how to use the Linux loopback device to create a Linux native filesystem format installation that can be run from a DOS partition without re-partitioning. Other uses of this same technique are also discussed. ______________________________________________________________________ Table of Contents 1. Introduction 1.1 Copyright 1.2 Revision History 2. Principles of Loopback Devices and Ramdisks 2.1 Loopback Devices 2.2 Ramdisk Devices 2.3 The Initial Ramdisk Device 2.4 The Root Filesystem 2.5 The Linux Boot Sequence 3. How To Create a Loopback Root Device 3.1 Requirements 3.2 Creating the Linux Kernel 3.3 Creating the Initial Ramdisk Device 3.4 Creating The Root Device 3.5 Creating the Swap Device 3.6 Creating the MSDOS Directory 3.7 Creating a DOS boot Floppy 3.8 Booting from DOS hard drive 4. Booting the System 4.1 Possible Problems With Solutions 4.2 Reference Documents 5. Other Loopback Root Device Possibilities 5.1 DOS Hard-disk Only Installation 5.2 LILO Booted Installation 5.3 SYSLINUX Booted Installation 5.4 NTFS Installation 5.5 Installing Linux without Re-partitioning 5.6 Booting From a Non-bootable device 5.7 Resizing a loop linux system 5.8 Loop encrypted filesystem 5.9 LoopLinux distribution ______________________________________________________________________ 1. Introduction 1.1. Copyright The Loopback Root Filesystem HOWTO Copyright (C) 1998,99 Andrew M. Bishop (amb@gedanken.demon.co.uk). This documentation is free documentation; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. The GNU General Public License is available from http://www.fsf.org/ or, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA 1.2. Revision History Version 1.0.0 Initial Version (June 1998) Version 1.0.1-1.0.3 Slight Modifications, kernel version changes, typos etc. (1998 July 1999) Version 1.1-1.1.1 Added Copyright Information and Re-Submitted (September 1999) Version 1.1.2-1.1.5 Included my experience in creating a loop linux system. Added loop encrypted filesystem info. Kent Robotti (9-26-2000) 2. Principles of Loopback Devices and Ramdisks First I will describe some of the general principles that are used in the setting up of a loopback filesystem as the root device. 2.1. Loopback Devices A loopback device in Linux is a virtual device that can be used like any other media device. Examples of normal media devices are hard disk partitions like /dev/hda1, /dev/hda2, /dev/sda1, or entire disks like the floppy disk /dev/fd0 etc. They are all devices that can be used to hold a files and directory structures. They can be formatted with the filesystem that is required (ext2fs, msdos, ntfs etc.) and then mounted. The loopback filesystem associates a file on another filesystem as a complete device. This can then be formatted and mounted just like any of the other devices listed above. To do this the device called /dev/loop0 or /dev/loop1 etc is associated with the file and then this new virtual device is mounted. 2.2. Ramdisk Devices In Linux it is also possible to have another type of virtual device mounted as a filesystem, this is the ramdisk device. In this case the device does not refer to any physical hardware, but to a portion of memory that is set aside for the purpose. The memory that is allocated is never swapped out to disk, but remains in the disk cache. A ramdisk can be created at any time by writing to the ramdisk device /dev/ram0 or /dev/ram1 etc. This can then be formatted and mounted in the same way that the loopback device is. When a ramdisk is used to boot from (as is often done on Linux installation disks or rescue disks) then the disk image (the entire contents of the disk as a single file) can be stored on the boot floppy in a compressed form. This is automatically recognised by the kernel when it boots and is uncompressed into the ramdisk before it is mounted. 2.3. The Initial Ramdisk Device The initial ramdisk device in Linux is another important mechanism that we need to be able to use a loopback device as a the root filesystem. When the initial ramdisk is used the filesystem image is copied into memory and mounted so that the files on it can be accessed. A program on this ramdisk (called /linuxrc) is run and when it is finished a different device is mounted as the root filesystem. The old ramdisk is still present though and is mounted on the directory /initrd if present or available through the device /dev/initrd. This is unusual behaviour since the normal boot sequence boots from the designated root partition and keeps on running. With the initial ramdisk option the root partition is allowed to change before the main boot sequence is started. 2.4. The Root Filesystem: The root filesystem is the device that is mounted first so that it appears as the directory called / after booting. There are a number of complications about the root filesystem that are due to the fact that it contains all files. When booting the rc scripts are run, these are either the files in /etc/rc.d or /etc/rc?.d depending on the version of the /etc/init program. When the system has booted it is not possible to unmount the root partition or change it since all programs will be using it to some extent. This is why the initial ramdisk is so useful because it can be used so that the final root partition is not the same as the one that is loaded at boot time. 2.5. The Linux Boot Sequence: To show how the initial ramdisk operates in the boot sequence, the order of events is listed below. 1. The kernel is loaded into memory, this is performed by a boot loader like LILO, LOADLIN, or SYSLINUX. You can see the Loading... message as this happens. 2. The ramdisk image is loaded into memory, again this is performed by LILO, LOADLIN, etc. You can see the Loading... message again as this happens. 3. The kernel is initialised, including parsing the command line options and setting of the ramdisk as the root device. 4. The program /linuxrc is run on the initial ramdisk. 5. The root device is changed to that specified in the kernel parameter 'root=/dev/xxxx'. 6. The init program /sbin/init is run which will perform the user configurable boot sequence. This is just a simplified version of what happens, but is sufficient to explain how the kernel starts up and where the initial ramdisk is used. 3. How To Create a Loopback Root Device: Now that the general principles are explained the method of creating the loopback device can be explained. 3.1. Requirements To create the loopback root device will require a number of things. * A working Linux system. * A way to copy large files onto the target DOS partition. Most important is access to an installed Linux system. This is because the loop device can only be created under Linux. This will mean that it is not possible to bootstrap a working system from nothing. The requirements of the Linux system that you use is that you can compile a kernel on it. Once the loopback device is created it will be a large file. I have used an 80 MB files, but while this was sufficient for an X terminal it may not be enough if you want to use it for much else. This file must be copied onto the DOS partition, so either a network or a lot of floppy disks must be used. The software that you will require includes * LOADLIN version 1.6a or above: ftp://ftp.suse.com/pub/loadlin/update-1.6a "loadlin.exe.gz" ftp://elserv.ffm.fgan.de/pub/linux/loadlin-1.6/update-1.6a * A version of mount that supports loopback devices * A version of the kernel that supports the required options. All of these should be standard for recent Linux installations. 3.2. Creating the Linux Kernel: I created the loopback device using Linux kernel version 2.2.14, other versions should also work, but they must have at least the options listed below enabled. The kernel options that you will need to enable are the following: * RAM disk support (CONFIG_BLK_DEV_RAM). * Initial RAM disk (initrd) support (CONFIG_BLK_DEV_INITRD). * Loop device support (CONFIG_BLK_DEV_LOOP). * fat fs support (CONFIG_FAT_FS). * msdos fs support (CONFIG_MSDOS_FS). The first two are for the RAM disk device itself and the initial ram disk device. The next one is the loop back filesystem option. The last two are the msdos filesystem support which is required to mount the DOS partitition. Compiling a kernel without modules is the easiest option, although if you do want modules then it should be possible although I have not tried it. If modules are used then you should make sure that you have the options above compiled in and not as modules themselves. Once the kernel is configured it should be compiled to produce a zImage file (make zImage or make bzImage). This file will be /usr/src/linux/arch/i386/boot/zImage or bzImage when compiled. 3.3. Creating the Initial Ramdisk Device The initial ramdisk is most easily created as a loopback device from the start. You will need to do this as root, the commands that you need to execute are listed below. 1. Create a mount point for the initial ramdisk (an empty directory). # mkdir -p /mnt/initrd 2. Create an empty file of the size required. Here I have used 1200kb, you may need less or more depending on the contents, (the size is the last parameter). # dd if=/dev/zero of=initrd bs=1k count=1200 3. Make an ext2 filesystem on the empty file. # mke2fs -i4096 -m0 -F initrd 4. Mount the file onto the mount point, this uses the loopback device. # mount initrd /mnt/initrd -t ext2 -o loop 5. Change to the mounted loopback device. # cd /mnt/initrd 6. Create the files that are required. See "Contents Of The Initial Ramdisk" below. 7. Move out of the mounted loopback device. # cd .. 8. Unmount the device. # umount /mnt/initrd 9. Compress initrd with gzip. # gzip -9 initrd Contents Of The Initial Ramdisk: The files that you will need on the ramdisk are the minimum requirements to be able to execute any commands. * /linuxrc The script that is run to mount the dos/win partition (see below). * /lib/* The dynamic linker and the libraries that the programs need. * /bin/* A shell interpreter (ash because it is smaller than bash. The mount and losetup programs for handling the DOS disk and setting up the loopback devices. * /dev/* The devices that will be used. You need a /dev/hda[1-15] for IDE hard drives or /dev/sda[1-15] for SCSI, to mount your dos/win system, and a /dev/loop0 for the loopback device. * /mnt An empty directory to mount the dos/win partition on. The initial ramdisk = initrd.gz contents are listed below. drwxr-xr-x root/root 0 2000-09-26 14:34:49 bin/ -rwxr-xr-x root/root 52925 2000-08-06 13:22:55 bin/mount -rwxr-xr-x root/root 14297 2000-03-21 09:08:26 bin/losetup -rwxr-xr-x root/root 86300 2000-08-19 01:54:09 bin/ash drwxr-xr-x root/root 0 2000-09-26 14:22:34 dev/ brw-rw---- root/disk 7,0 2000-09-26 14:22:09 dev/loop0 brw-rw---- root/disk 7,1 2000-09-26 14:22:10 dev/loop1 brw-rw---- root/disk 3,1 2000-09-26 14:22:26 dev/hda1 crw--w--w- root/tty 4,0 2000-09-26 14:22:34 dev/tty0 drwxr-xr-x root/root 0 2000-09-26 14:21:58 lib/ -rwxr-xr-x root/root 73632 2000-05-03 19:20:40 lib/ld-2.1.3.so lrwxrwxrwx root/root 0 2000-09-26 14:21:56 lib/ld-linux.so.2 -> ld-2.1.3.so lrwxrwxrwx root/root 0 2000-09-26 14:21:58 lib/libc.so.6 -> libc-2.1.3.so -rwxr-xr-x root/root 888596 2000-05-03 19:20:41 lib/libc-2.1.3.so -rwxr-xr-x root/root 776 2000-09-26 14:27:08 linuxrc drwxr-xr-x root/root 0 2000-09-26 14:26:44 mnt/ Since my dos/win partition is on /dev/hda1, i only put that hard drive device in /dev above. You can copy the needed devices from your linux system to /mnt/initrd/dev or make them with 'mknod'. # cp -a /dev/{hda1,loop0,loop1,tty0} /mnt/initrd/dev The /linuxrc file on the initial ramdisk is required to do all of the preparations so that the loopback device can be used for the root partition when it exits. The example below tries to mount /dev/hda1 as a vfat = Win9x partition and if it succeeds then sets up the files /mnt/looplnx/looplnx.img as /dev/loop0 and /mnt/looplnx/swap.img as /dev/loop1. The above would be c:\looplnx\looplnx.img and c:\looplnx\swap.img on your dos/win system. This is the linuxrc shell script... #!/bin/ash echo "INITRD: Trying to mount /dev/hda1 as type vfat..." >/dev/tty0 options="uid=0,gid=0,umask=022,noexec,quiet" if /bin/mount -n -t vfat -o $options /dev/hda1 /mnt; then echo "INITRD: Mounted OK!" >/dev/tty0 /bin/losetup /dev/loop0 /mnt/looplnx/looplnx.img /bin/losetup /dev/loop1 /mnt/looplnx/swap.img exit 0 else echo "INITRD: Mount failed!" >/dev/tty0 exit 1 fi The above assumes you want to mount a Win9x system, if you want to mount a dos system put -t msdos instead of -t vfat for mount. The first device /dev/loop0 will become the root device and the second one /dev/loop1 will become the swap space. If you want to be able to write to the DOS partition as a non-root user when you have finished then you should use options="uid=0,gid=0,umask=000,noexec,quiet" instead. This will map all accesses to the DOS partition to root and set the permissions appropriately. 3.4. Creating The Root Device: The root device that you will be using is the file looplnx.img. You will need to create this in the same way that the initial ramdisk was created, but bigger. You can install any Linux installation that you like onto this disk. For example, create a 300mb image called looplnx.img and put a ext2 filesystem on it. # dd if=/dev/zero of=looplnx.img bs=1M count=300 # mke2fs -F looplnx.img Or if you want to put a reiserfs filesystem on it. # mkreiserfs -f looplnx.img A reiserfs filesystem will require more space than ext2 because it needs to create a journal, you have to figure out what you'll need when you create looplnx.img above with dd. You can then mount looplnx.img under /mnt/loop and put what you want in it. # mkdir -p /mnt/loop # mount -t ext2 -o loop looplnx.img /mnt/loop The easiest way might be to copy an existing Linux installation into it. An alternative is to install a new Linux installation onto it. The looplnx.img image you create above must be big enough to hold whatever you want to put in it. You can see the used size of your linux system like this. # df -h Filesystem Size Used Avail Use% Mounted on /dev/hda2 1.5G 150M 1.3G 16% / To copy the current linux system to the looplnx.img image mounted under the /mnt/loop directory, you can use cp or tar. # cp -x -a / /mnt/loop # tar cvl / | tar xpf - -C /mnt/loop Assuming that you have done this, there are some minor changes that you must make. The /etc/fstab file must reference the root partition and the swap using the two loopback devices that are setup on the initial ramdisk. The /mnt/loop/etc/fstab file should have this for the / partition. /dev/loop0 / ext2 defaults 0 1 /dev/loop1 none swap sw 0 0 The above assumes it's a ext2 partition, if it were a 'reiserfs' or 'ext3' partition. /dev/loop0 / reiserfs defaults 0 0 /dev/loop0 / ext3 defaults 0 0 This will ensure that when the real root device is used the kernel will not be confused about where the root device is. It will also allow the swap space to be added in the same way a swap partition is normally used. You should remove any other reference to a root disk device or swap partition. If you want to be able to read the DOS partition after Linux has started then you will need to make a number of extra small changes. Create a directory called /initrd, this is where the initial ramdisk will be mounted once the loopback root filesystem is mounted. # mkdir /mnt/loop/initrd Yow can create a symbolic link called /DOS that points to /initrd/mnt where the real DOS/WIN partition will be mounted. # cd /mnt/loop ; ln -sf initrd/mnt DOS Add a line into the rc file that mounts the disks. This should run the command mount -f -t msdos /dev/hda1 /initrd/mnt, this will create a 'fake' mount of the DOS partition so that all programs (like df) will know that the DOS partition is mounted and where to find it. If you used different options in the /linuxrc file that obviously you should use them here also. You can put this in /mnt/loop/etc/rc.d/rc.local etc. if [ -d /initrd/mnt ]; then mount -f -t vfat /dev/hda1 /initrd/mnt fi When done unmount the looplnx.img image that's mounted under /mnt/loop. # umount /mnt/loop There is no need to have a Linux kernel on this root device since that is already loaded earlier. If you are using modules however then you should include them on this device as normal. 3.5. Creating the Swap Device: The root device that you will be using is the file swap.img. The swap device is very simple to create. Create an empty file as was done for the initial ramdisk and then run mkswap swap.img to intialise it. # dd if=/dev/zero of=swap.img bs=1M count=8 # mkswap swap.img The size of the swap space will depend on what you plan to do with the installed system, but I would recommend between 8MB and the amount of RAM that you have. 3.6. Creating the MSDOS Directory: The files that are going to be used need to be moved onto the DOS partition. * LOOPLNX.IMG The disk image that will become the root device. * SWAP.IMG The swap space. Create a c:\looplnx directory and put looplnx.img and swap.img in it. C:\ mkdir looplnx 3.7. Creating a DOS boot floppy: The boot floppy that is used is just a normal DOS format bootable floppy. This is created like this from DOS. Put a floppy in the drive. C:\ format a: /s /q Onto this disk you will need to create an AUTOEXEC.BAT file (as below) and copy the kernel, compressed initial ramdisk and LOADLIN executable. * AUTOEXEC.BAT The DOS automatically executed batch file. * LOADLIN.EXE The LOADLIN program executable. * ZIMAGE The Linux kernel. * INITRD.GZ The compressed initial ramdisk image. The AUTOEXEC.BAT file should contain just one line as below. \loadlin \zImage initrd=\initrd.gz root=700 ro This specifies the kernel image to use, the initial ramdisk image, the root device after the initial ramdisk has finished and that the root partition is to be mounted read-only. 3.8. Booting from DOS hard drive: You can boot c:\looplnx\looplnx.img from the hard drive using loadlin. c:\looplnx> loadlin zimage initrd=initrd.gz root=700 ro You should be able to put root=700 or root=/dev/loop0, they're the same device, but some kernels may not work with /dev/loop0. 4. Booting the System: To boot from this new root device all that is required is that the floppy disk prepared as described above is inserted for the PC to boot from. You will see the following sequence of events. 1. DOS boots 2. AUTOEXEC.BAT starts 3. LOADLIN is run 4. The Linux kernel is copied into memory 5. The initial ramdisk is copied into memory 6. The Linux kernel is started running 7. The /linuxrc file on the initial ramdisk is run 8. The DOS partition is mounted and the root and swap devices set up 9. The boot sequence continues from the loopback device When this is complete you can remove the boot floppy and use the Linux system. 4.1. Possible Problems With Solutions There are a number of stages where this process could fail, I will try to explain what they are and what to check. DOS booting is easy to recognise by the message that it prints MS-DOS Starting ... on the screen. If this is not seen then the floopy disk is either not-bootable or the PC is not bootable from the floppy disk drive. When the AUTOEXEC.BAT file is run the commands in it should be echoed to the screen by default. In this case there is just the single line in the file that starts LOADLIN. When LOADLIN executes it will do two very visible things, firstly it will load the kernel into memory, secondly it will copy the ramdisk into memory. Both of these are indicated by a Loading... message. The kernel starts by uncompressing itself, this can give crc errors if the kernel image is corrupted. Then it will start running the initialisation sequence which is very verbose with diagnostic messages. Loading of the initial ramdisk device is also visible during this phase. When the /linuxrc file is run there is no diagnostic messages, but you can add these yourself as an aid to debugging. If this stage fails to set up the loopback device as the root device then you may see a message that there is no root device and the kernel aborts. The normal boot sequence of the new root device will now continue and this is quite verbose. There may be problems about the root device being mounted read-write, but the LOADLIN command line option 'ro' should stop that. Other problems that can occur are that the boot sequence is confused about where the root device is, this is probably due to a problem with /etc/fstab. When the boot sequence has completed, the remaining problem is that programs are confused about whether the DOS partition is mounted or not. This is why it is a good idea to use the fake mount command described earlier. This makes life a lot easier if you want to access the files on the DOS device. 4.2. Reference Documents The documents that I used to create my first loopback root filesystem were: * The Linux kernel source, in particular init/main.c * The Linux kernel documentation, in particular Documentation/initrd.txt and Documentation/ramdisk.txt. * The LILO documentation. * The LOADLIN documentation 5. Other Loopback Root Device Possibilities Once the principle of booting a filesystem in a file on a DOS partition has been established there are many other things that you can now do. 5.1. DOS Hard-disk Only Installation If it is possible to boot Linux from a file on a DOS harddisk by using a boot floppy then it is obviously also possible to do it using the harddisk itself. A configuration boot menu can be used to give the option of running LOADLIN from within the AUTOEXEC.BAT. This will give a much faster boot sequence, but is otherwise identical. 5.2. LILO Booted Installation Using LOADLIN is only one option for booting a Linux kernel. There is also LILO that does much the same but without needing DOS. In this case the DOS format floppy disk can be replaced by an ext2fs format one. Otherwise the details are very similar, with the kernel and the initial ramdisk being files on that disk. The reason that I chose the LOADLIN method is that the arguments that need to be given to LILO are slightly more complex. Also it is more obvious to a casual observer what the floppy disk is since it can be read under DOS. You can make a lilo boot floppy that will boot a loop linux system, like this. Format a floppy to 1.44mb with fdformat or superformat. # fdformat -n /dev/fd0u1440 # superformat -f /dev/fd0u1440 Create a ext2 filesystem on the floppy. # mke2fs -m0 /dev/fd0u1440 Have lilo the boot loader installed, you should have /boot/boot.b from the lilo package on your system. Create a lilo.conf file with this in it. boot = /dev/fd0 backup = /dev/null prompt compact vga = normal image = /boot/kernel label = linux read-only image = /boot/kernel label = looplinux append="root=700 ro" initrd = /boot/initrd.gz Mount the floppy and do these things below. # mount -t ext2 /dev/fd0 /mnt/floppy # rmdir /mnt/floppy/lost+found # mkdir -p /mnt/floppy/boot # mkdir /mnt/floppy/dev # mkdir /mnt/floppy/etc # mkdir /mnt/floppy/tmp # cp -a /dev/null /mnt/floppy/dev # cp -a /dev/fd0 /mnt/floppy/dev # cp /boot/boot.b /mnt/floppy/boot # cp lilo.conf /mnt/floppy/etc Copy a kernel = zImage or bzImage to the floppy, also copy initrd.gz to the floppy. # cp zImage /mnt/floppy/boot/kernel # cp initrd.gz /mnt/floppy/boot Run lilo on the floppy. # lilo -v -r /mnt/floppy Unmount the floppy, it should be ready to boot now! # umount /mnt/floppy At the LILO boot prompt do this to boot the loop linux system. boot: looplinux If you want to use the kernel on the floppy to boot a linux system that's on it's own partition, tell lilo where it is 'root=/dev/xxxx'. boot: linux root=/dev/hda2 5.3. SYSLINUX Booted Installation: ftp://ftp.kernel.org/pub/linux/utils/boot/syslinux You can make a SYSLINUX boot floppy that will boot a loop linux system, like this. Format a floppy to 1.44mb with fdformat or superformat. # fdformat -n /dev/fd0u1440 # superformat -f /dev/fd0u1440 If you use superformat above it will call mformat to put a dos filesystem on the floppy, so you don't need to use mkdosfs below if you have mformat. Create a dos filesystem on the floppy. # mkdosfs /dev/fd0u1440 Create a syslinux.cfg file with this in it. PROMPT 1 LABEL looplinux KERNEL kernel APPEND vga=normal initrd=initrd.gz root=700 ro LABEL linux KERNEL kernel APPEND vga=normal load_ramdisk=0 ro Mount the floppy. # mount -t msdos /dev/fd0 /mnt/floppy Copy a kernel = zImage or bzImage to the floppy, also copy initrd.gz and syslinux.cfg to the floppy. # cp zImage /mnt/floppy/kernel # cp initrd.gz /mnt/floppy # cp syslinux.cfg /mnt/floppy Unmount the floppy and run syslinux on it. # umount /mnt/floppy # syslinux /dev/fd0u1440 It should be ready to boot now! At the SYSLINUX boot prompt do this to boot the loop linux system. boot: looplinux If you want to use the kernel on the floppy to boot a linux system that's on it's own partition, tell where it is 'root=/dev/xxxx'. boot: linux root=/dev/hda2 You can get syslinux here... ftp://ftp.kernel.org/pub/linux/utils/boot/syslinux 5.4. NTFS Installation I have tried the NTFS method, and have had no problems with it. The NTFS filesystem driver is not a standard kernel option in version 2.0.x, but is available as a patch from http://www.informatik.hu- berlin.de/~loewis/ntfs/. In version 2.2.x the NTFS driver is included as standard in the kernel. The only change for the NTFS option is in the initial ramdisk = initrd.gz, the file /linuxrc needs to mount a file system of type ntfs rather than msdos or vfat. 5.5. Installing Linux without Re-partitioning The process of installing Linux on a PC from a standard distribution requires booting from a floppy disk and re-partitioning the disk. This stage could instead be accomplished by a boot floppy that creates an empty loopback device and swap file. This would allow the installation to proceed as normal, but it would install into the loopback device rather than a partition. This could be used as an alternative to a UMSDOS installation, it would be more efficient in disk usage since the minimum allocation unit in the ext2 filesystem is 1kB instead of up to 32kB on a DOS partition. It can also be used on VFAT and NTFS formatted disks which are otherwise a problem. 5.6. Booting From a Non-bootable device This method can also be used to boot a Linux system from a device that is not normally bootable. * CD-Rom * Zip Disks * Parallel port disk drives Obviously there are many other devices that could be used, NFS root filesystems are already included in the kernel as an option, but the method described here might also be used instead. 5.7. Resizing a loop linux system: You can enlarge or reduce the size of a loop linux image, you would use 'ext2resize' to do this. For example, if you want to enlarge the loop linux image. First get the size of the loop linux image 'looplnx.img'. # du -m looplnx.img "Show size in megabytes!" 300 looplnx.img It says the size is 300mb, i want to add 100mb to it. # dd if=/dev/zero of=looplnx.img bs=1M seek=300 count=100 seek=300 means find the point that's 300mb into the image, and count=100 means add 100mb to that point, total 400mb. Run ext2resize on the enlarged 400mb image, it will resize the ext2 filesystem on it to fill the image. # ext2resize looplnx.img For example, if you want to reduce the loop linux image. Run ext2resize on the image and have it rezize the 300mb ext2 filesystem on it to 200mb. # ext2resize looplnx.img 200m Run 'dd' on the 300mb image to reduce it to 200mb. # dd if=/dev/zero of=looplnx.img bs=1M seek=200 count=0 seek=200 means find the point that's 200mb into the image, and count=0 means add nothing to that point, total 200mb. The above is a little confusing, if you make a mistake you'll loose whatever is on the loop linux image. I just mention the above so you'll know it's possible to resize a ext2 filesystem, whether it's on a image or a partition. If you wanted to resize a image with a reiserfs filesystem on it, you would use 'resize_reiserfs'. For example, if you want to enlarge the loop linux image. First get the size of the loop linux image 'looplnx.img'. # du -m looplnx.img "Show size in megabytes!" 300 looplnx.img It says the size is 300mb, i want to add 100mb to it. # dd if=/dev/zero of=looplnx.img bs=1M seek=300 count=100 # resize_reiserfs -s+100M -f looplnx.img For example, if you want to reduce the 300mb loop linux image to 200mb. Run resize_reiserfs on the image and have it rezize the 300mb reiserfs filesystem on it to 200mb. # resize_reiserfs -s-100M -f looplnx.img Run 'dd' on the 300mb image to reduce it to 200mb. # dd if=/dev/zero of=looplnx.img bs=1M seek=200 count=0 This is the ext2resize homepage... http://ext2resize.sourceforge.net http://ext2resize.sourceforge.net/devel.html Get ext2resize v1.1.14 or later. 5.8. Loop encrypted filesystem: http://www.kerneli.org You can encrypt the ext2 filesystem on the loop image, so a password is required to mount it. You need to patch the kernel source to have this ability. 1. Download the latest international crypto patch from here, in the v2.2 or v2.4 directory. ftp://ftp.kerneli.org/pub/kerneli patch-int-2.x.x.gz For example, if you have kernel source 2.2.16 you would need 'patch-int-2.2.16.gz' etc. 2. Put the patch in /usr/src/linux and apply it like this. /usr/src/linux# gzip -dc patch-int-2.x.x.gz | patch -p1 3. Configure the kernel. /usr/src/linux# make config Answer y to this option, otherwise you won't be presented with the crypto options. Prompt for development and/or incomplete code/drivers (CONFIG_EXPERIMENTAL) y Chose a cyper method you only need one (you can chose as many as you want) i chose 'serpent' because it's supposed to be good. Crypto options Crypto ciphers CONFIG_CIPHERS y Blowfish cipher (EXPERIMENTAL) CONFIG_CIPHER_BLOWFISH n DES cipher (EXPERIMENTAL) CONFIG_CIPHER_DES n DFC cipher (EXPERIMENTAL) CONFIG_CIPHER_DFC n IDEA cipher (EXPERIMENTAL) CONFIG_CIPHER_IDEA n MARS cipher (EXPERIMENTAL) CONFIG_CIPHER_MARS n RC5 cipher (EXPERIMENTAL) CONFIG_CIPHER_RC5 n RC6 cipher (EXPERIMENTAL) CONFIG_CIPHER_RC6 n Rijndael cipher (EXPERIMENTAL) CONFIG_CIPHER_RIJNDAEL n Serpent cipher (EXPERIMENTAL) CONFIG_CIPHER_SERPENT y Digest algorithms CONFIG_DIGEST n Additional Block Devices Loopback device support CONFIG_BLK_DEV_LOOP y Use relative block numbers as basis for transfer functions (RECOMMENDED) CONFIG_BLK_DEV_LOOP_USE_REL_BLOCK y General encryption support (EXPERIMENTAL) CONFIG_BLK_DEV_LOOP_GEN y CAST 128 encryption (EXPERIMENTAL) CONFIG_BLK_DEV_LOOP_CAST n Twofish encryption (EXPERIMENTAL) CONFIG_BLK_DEV_LOOP_FISH2 n 4. Compile the kernel. /usr/src/linux# make dep clean zImage (Or bzImage) 5. Create a 10mb test file like this. # dd if=/dev/zero of=cryptfile bs=1M count=10 6. Run losetup on it and enter a password. # losetup -e serpent /dev/loop0 cryptfile You only have one chance to enter the password, you won't be able to see what you type in. Passphrase: secret 7. Create a ext2 filesystem on cryptfile. # mke2fs /dev/loop0 8. Deactivate the loop device. # losetup -d /dev/loop0 9. Now whenever you want to mount cryptfile, you have to do this. # losetup -e serpent /dev/loop0 cryptfile Passphrase: secret 10. Mount the encrypted ext2 filesystem on cryptfile. # mount -t ext2 /dev/loop0 /mnt/loop 11. When you're done unmount and deactivate /dev/loop0. # umount /dev/loop0 # losetup -d /dev/loop0 You need a version of 'losetup' and 'mount' that recognizes the crypto options (blowfish serpent etc). There's a patch included with the patch-int-2.x.x.gz patch, in /usr/src/linux/Documentation/crypto/util-linux-2.x.patch. You need to apply it to 'losetup' and 'mount' from the util-linux-2.x.tar.gz package. util-linux-2.x# patch -p1 < util-linux-2.x.patch # configure # make If the patch is named util-linux-2.10m.patch, it means it will work with 'mount' and 'losetup' from util-linux-2.10m.tar.gz and possibly later etc. 5.9. LoopLinux distribution: LoopLinux is a small linux distribution that can be installed on and run from a dos/win9x system. LoopLinux distribution home site... http://www.tux.org/pub/people/kent-robotti/looplinux/index.html ftp://ftp.tux.org/pub/people/kent-robotti/looplinux End! ---------------------------------------------------------------------------