1.1. Introduction

When creating tiny-sized and embedded Linux systems, every byte of the storage device (floppy, flash disk, etc.) is very important, so compression is used everywhere possible. Also, compressed file systems are frequently needed for archiving purposes. For huge public archives, as well as for personal media archives, this is essential.

SquashFS brings all this to a new level. It is a read-only file system that lets you compress whole file systems or single directories, write them to other devices/partitions or to ordinary files, and then mount them directly (if a device) or using a loopback device (if it is a file). The modular, compact system design of SquashFS is bliss. For archiving purposes, SquashFS gives you a lot more flexibility and performance speed than a .tar.gz archive.

SquashFS is distributed as a Linux kernel source patch (which enables SquashFS read support in your kernel), and the mksquashfs tool, which creates squashed file systems (in a file or on a block device).

1.2. Overview of SquashFS

• Data, inodes and directories are compressed

• SquashFS stores full uid/gids (32 bits), and file creation time

• Files up to 2^32 bytes are supported; file systems can be up to 2^32 bytes

• Inode and directory data are highly compacted, and packed on byte boundaries; each compressed inode is on average 8 bytes in length (the exact length varies on file type, i.e. regular file, directory, symbolic link, and block/character device inodes have different sizes)

• SquashFS can use block sizes up to 32K, which achieves greater compression ratios than the normal 4K block size

• File duplicates are detected and removed

• Both big and little endian architectures are supported; SquashFS can mount file systems created on different byte-order machines

1.3. Making it clear

To make further chapters clear, the basic steps of getting SquashFS working that we will discuss are:

1. Patching and recompiling the Linux kernel to enable SquashFS support

2. Compiling the mksquashfs tool

3. Creating a compressed file system with mksquashfs

4. Testing: mounting a squashed file system to a temporary location

5. Modifying the fstab or startup scripts of your Linux system to mount the squashed file system at boot time

2.1. Acquiring SquashFS

The SquashFS home site is located at http://squashfs.sourceforge.net/. The current release is 1.3r2. You can always get the latest version at the SquashFS SourceForge project page.

2.2. Preparing a SquashFS-capable kernel

In order to read SquashFS, you need it supported in your kernel - just as if it was a reiserfs or ext3 file system. You have to make sure there is an appropriate patch for your kernel version - it should be located in linux-2.x.y subdirectory of the SquashFS source tree. Also, remember that in most cases you will need a clean (original) Linux kernel source from kernel.org. If your kernel source is from a distro vendor, it may be already pre-patched with custom vendor patches, and patching with a SquashFS patch may raise errors, as SquashFS patches are made against original Linux kernels.

With the 2.x.y kernel source and a proper 2.x.y SquashFS patch present, all you have to do is (we'll assume that you have your Linux kernel source in /usr/src/linux and that you have the SquashFS source in /usr/src/squashfs):

Change to the SquashFS source directory and copy the kernel patch (we'll assume it's named squashfs1.3r2-patch as of the 1.3r2 release) to /usr/src/linux.

	bash# cd /usr/src/squashfs
	bash# cp linux-2.x.y/squashfs1.3r2-patch /usr/src/linux

Go into the directory /usr/src/linux:

	bash# cd /usr/src/linux

Patch the Linux kernel:

	bash# patch -p1 < squashfs1.3r2-patch

Configure your kernel:

	bash# make menuconfig

In the "File systems" section, make sure you enable "Squashed filesystem." If you want to be able to mount the squashed file system via a loopback device in future, you should enable "Loopback device support" in the "Block devices" section.

Now you may compile the kernel and modules:

	bash# make dep && make bzImage && make modules && make modules_install

Install your new kernel (name it bzImage-sqsh for convenience, if you like):

	bash# cp arch/i386/boot/bzImage /boot/bzImage-sqsh

Modify your boot loader's configuration file to include your new kernel and install the boot loader. Now you may reboot with your new kernel. When it boots, check that everything went fine:

	bash# cat /proc/filesystems

You should see the squashfs line among other file systems. This means you have successfully enabled SquashFS in your kernel.

2.3. Compiling mksquashfs

Now you need to compile mksquashfs - the tool for creating squashed file systems.

	bash# cd /usr/src/squashfs/squashfs-tools

Compile and install mksquashfs:

	bash# make
	bash# cp mksquashfs /usr/sbin

If everything went fine, typing mksquashfs at the Bash prompt should print it's "usage" message.

3.1. Using mksquashfs

The mksquashfs tool can be used for creating new squashed file systems, as well as for appending new data to existing squashed file systems.

The general format for mksquashfs from the command-line is:

	bash# mksquashfs source1 source2 ... destination [options] [-e files to exclude]

source items can be files and directories with mixed relative/absolute paths; destination can be regular files (thus, you will have a file system image on your disk), or a block device, such as /dev/fd0 or /dev/hda3.

When the new files are added to the new file system or appended to an existing one, mksquashfs will automatically rename files with duplicate names: if two or more files named text will appear in the same resulting directory, the second file will be renamed to text_1, third one to text_2 and so on. Additionally, duplicate files will be removed, so there will be only one physical instance.

If destination has a pre-existing SquashFS file system on it, by default, the new source items will be appended to existing root directory. Examine the options table below to force mksquashfs to overwrite the whole destination and/or change the way new source items are added.

If a single source file or directory is given, it becomes the root in a newly created file system. If two or more source files and/or directories are given, they will all become sub-items in the root of the new file system.

Files to exclude can be used to specify which files and/or directories you want to omit from the new file system that is to be created. The usage of this option will be described later.

See the next section for more details about mksquashfs options.

3.2. Command-line options

All possible options for mksquashfs are shown in the table below.

In most cases, you should leave all compression/block options by default, as they allow mksquashfs to achieve the best possible compression ratios.

4.1. Basic steps

In order to squash a directory (say, /some/dir), and output to a regular file (thus, producing a file system image), you need to perform the following operations:

	bash# mksquashfs /some/dir dir.sqsh

mksquashfs will perform the squashing and print the resulting number of inodes and size of data written, as well as the average compression ratio. Now you have your /some/dir directory image in the dir.sqsh file. You can now use the mount command to mount it using a loopback device:

	bash# mkdir /mnt/dir
	bash# mount dir.sqsh /mnt/dir -t squashfs -o loop

To check if you have what's expected:

	bash# ls /mnt/dir

If you want to output the file system directly into a device (say, your floppy at /dev/fd0):

	#bash mksquashfs /some/dir /dev/fd0

Then just mount the device:

	bash# mount /dev/fd0 /mnt/floppy -t squashfs

And check if it's okay:

	bash# ls /mnt/floppy

4.2. Squashing file systems

Operations described here correspond to most cases where a read-only compressed file system can be used, whether you want it to be on a block device or in a file. This could be anything from large FTP/HTTP-served archives that don't change often, to having a squashed /usr partition and anything alike with these.

	bash# mksquashfs /var/arch /var/arch.sqsh
	bash# mkdir /mnt/tmp
	bash# mount /var/arch.sqsh /mnt/tmp -t squashfs -o loop
	bash# ls /mnt/tmp

	/var/arch.sqsh	/var/arch	squashfs	ro,defaults	0 0

	bash# umount /mnt/tmp
	bash# mount /var/arch

	bash# ls /var/arch

	/dev/hda7	/var/arch	reiserfs	defaults	0 0

	bash# mksquashfs /var/arch /var/arch.sqsh
	bash# mkdir /mnt/tmp
	bash# mount /var/arch.sqsh /mnt/tmp -t squashfs -o loop
	bash# ls /mnt/tmp

	bash# umount /dev/hda7
	bash# dd if=/var/arch.sqsh of=/dev/hda7

	/dev/hda6	/var/arch	squashfs	ro,defaults	0 0

	bash# mount /var/arch
	bash# ls /var/arch

	bash# rm /var/arch.sqsh

4.3. Creating tiny/embedded systems

By saying "tiny/embedded", I mean Linux systems that are being built for booting from floppy disks, IDE/USB flash disks, iso9660 CD-ROMs, small-sized hard drives and the like. Whether you want to have your whole root file system on a single media (a single partition, a single floppy), or have a modular system (several floppies or disk partitions), the procedure is almost identical. Creating such Linux systems themselves is out of scope of this HOWTO - there are dedicated HOWTOs and guides for this (like the Bootdisk HOWTO and Linux From Scratch - visit www.tldp.org to retrieve these documents).

	bash# cd /home/user
	bash# mksquashfs floppylinux root.sqsh -e usr
	bash# mksquashfs floppylinux/usr usr.sqsh

	bash# mount /mnt/floppy
	bash# cp root.sqsh /mnt/floppy/boot

	bash# dd if=usr.sqsh of=/dev/fd0

	bash# mksquashfs / /tmp/root.sqsh -e /proc /tmp/root.sqsh