cramdisk-1.0/ 40755 0 0 0 5546040772 11503 5ustar rootsystemcramdisk-1.0/makefsz100755 0 0 3031 5545255615 13166 0ustar rootsystem#!/bin/bash # # makefsz /dev/device {fs.z|-} [blocks] # # Compresses a filesystem image, suitable for use by the cramdisk # code in the kernel. # # The idea here is that you build a filesystem on a small # partition, and then use this program to convert that partition # into an optimally compressed filesystem image. This is done by # tarring the contents of the partition, wiping the partition # clean, untarring back onto the partition, and then dd'ing the # partition through gzip. # # Specify the output file name, or `-' for stdout. # # The optional `blocks' parameter specifies the size of the # partition, 4Mb by default. # # The default filesystem type is minix, because it has the least # overhead. However, if you want to use a different type (to get # atime/ctime/>14 char names, etc), just change the fstype variable # below. # fstype=minix [ $# -lt 2 -o $# -gt 3 ] && { echo "Usage: `basename $0` /dev/device {fs.z|-} [blocks]" exit 1 } [ ! -b "$1" ] && { echo "$1 is not a block device" exit 2 } [ ! -d /mnt ] && { mkdir /mnt || { echo "couldn't create mount point /mnt" exit 3 } } fs=$2 [ "$fs" = - ] && fs= dir=`pwd` blocks=${3:-4096} mount -t $fstype $1 /mnt && { cd /mnt tar -cf /tmp/temp.tar --exclude lost+found . || { echo "couldn't tar files from $1" exit 4 } cd / umount $1 dd if=/dev/zero of=$1 bs=1024 count=$blocks mkfs.$fstype $1 $blocks 1>&2 mount -t $fstype $1 /mnt cd /mnt tar -xpf /tmp/temp.tar rm /tmp/temp.tar cd $dir umount $1 eval "dd if=$1 bs=1024 count=$blocks | gzip -9 ${fs:+>}$fs" } cramdisk-1.0/writefsz100755 0 0 1670 5526667657 13426 0ustar rootsystem#!/bin/bash # # writefsz {fs.z|-} [blocks] # # This script writes the specified compressed file system image to # /dev/fd0. It assumes that you've already done a `make zdisk' in # order to put a kernel on the disk. The `blocks' parameter # specifies how big the ramdisk is to be. By default, it's 4096 # blocks, or 4Mb. Specify either the compressed file system, or use # `-' for stdin. # kernel=/usr/src/linux/zImage [ $# -lt 1 -o $# -gt 2 ] && { echo "Usage: `basename $0` {fs.z|-} [blocks]" exit 1 } [ "$1" != - -a ! -f "$1" ] && { echo "`basename $0`: $1 not found" exit 2 } fs=$1 [ "$fs" = - ] && fs= [ ! -f $kernel ] && { echo "`basename $0`: $kernel not found" exit 3 } start=`ls -s $kernel | awk '{print $1}'` rdev -r /dev/fd0 ${2:-4096} && { rdev -R /dev/fd0 1 rdev /dev/fd0 /dev/fd0 echo $start | awk '{printf"%c%c",$1%256,$1/256}' | dd of=/dev/fd0 bs=1 count=2 seek=502 dd ${fs:+if=}$fs of=/dev/fd0 bs=1024 seek=$start } cramdisk-1.0/cramon100755 0 0 1203 5526667755 13017 0ustar rootsystem#!/bin/bash # # cramon [blocks] # # Set the boot parameters on a floppy kernel image. This sets the # size of the ramdisk, the root device, sets the video mode to ask, # root flags to read-only, and the start of the cramdisk to the block # following the kernel image. # # The optional argument `blocks' specifies the size of the ramdisk to # create on boot. The default is 4Mb. # kernel=/usr/src/linux/zImage start=`ls -s $kernel | awk '{print $1}'` rdev -r /dev/fd0 ${1:-4096} && { rdev -R /dev/fd0 1 rdev /dev/fd0 /dev/fd0 rdev -v /dev/fd0 -3 echo $start | awk '{printf"%c%c",$1%256,$1/256}' | dd of=/dev/fd0 bs=1 count=2 seek=502 } cramdisk-1.0/README100644 0 0 36613 5546041640 12504 0ustar rootsystem+-------------- | Installation. +-------------- Apply the patch to the kernel source (if you are not running 1pl3, you may need to do a little manual patching, although it should patch anything above pl15b cleanly): (cd /usr/src/linux ; patch -s -p0) < diff-1.03 Do a `make config' and specify the minimum necessary for your hardware setup (eg, no need to include sound support on an emergency boot disk). Do a `make dep' to set up all the dependencies - if nothing breaks, pop a floppy into /dev/fd0 and do a `make zdisk'. +------------- | Quick Start. +------------- For more detailed instruction on what's going on, see the next section. If you want a compressed ramdisk right now, read on. 1. Build a bootable disk as outlined above. 2. Unmount your swap partition (no swap? See next section): swapoff -a 3. Create a 4Mb minix filesystem on your swap device: mkfs.minix /dev/ 4096 4. Mount the new filesystem: mount -t minix /dev/ /mnt 5. Copy the files you want onto the new partition. At a bare minimum, you'll probably want /mnt/etc/{init,inittab,getty} /mnt/bin/sh /mnt/sbin/{mkfs*,fsck*,fdisk,dd,mount,umount} Don't forget the shared libs if the programs you copy use them. Don't forget to adjust startup files as needed (etc/rc, etc/inittab, etc/fstab). Of course, you can fit a lot more than this on the disk. I've included a list of the contents of my bootdisk at the end of this document. 6. Unmount the partition: umount /dev/ 7. Write the filesystem to the floppy: makefsz /dev/ - | writefsz - 8. Reboot. +-------------------------------------------------------------- | On the Care and Feeding of the Compressed RAMDISK (CRAMDISK). +-------------------------------------------------------------- CRAMDISK is a modified ramdisk loader. The normal ramdisk loads a minix filesystem from one of two spots on the floppy, setting the root dev to the ramdisk after a successful load. In this way, a self contained Linux system can live on a single floppy. The major drawback to this scheme is that the useable space on a ramdisk is limited to the size of the filesystem that can be placed on a floppy. This is either 1.4Mb or 928k, depending on where the filesystem image is located on the floppy (assuming 3.5", less for 5.25"). If you have built an emergency boot disk, you will know how difficult it is to stuff enough utilities into 1.2Mb to recover from a major crash. The ramdisk is also constrained to use the minix filesystem. CRAMDISK circumvents these problems by allowing the user to create a filesystem, compress it with gzip, and write it to a floppy disk along with a pointer to its starting position. When booted, the kernel creates a ramdisk in the normal manner, and then decompresses the filesystem image, writing it to the ramdisk. This allows any filesystem type to be used in the ramdisk, and a ramdisk of any size. Of course, the decompressed filesystem must match the size of the ramdisk - if the image is too large, the decompress will fail, too small and precious RAM will be wasted. The code uses the word at offset 502 in the boot block to determine whether or not to attempt to load a compressed file system. This offset is better known as SWAPDEV, although for a kernel configured with CRAMDISK, a non zero value in this field is the starting block of the fs image. It doesn't appear to be used in current versions of the kernel, which is why I reassigned its use. However, I've been told that it will be used in upcoming releases. This shouldn't be a problem, as it would be unwise for an emergency bootdisk to use a default value for a resource like swap space. The upshot is that if you compile the code with CRAMDISK configured, offset 502 is the starting point of the fs image; without CRAMDISK configured, it contains SWAPDEV. CRAMDISK increases the kernel size by about 8K. Building a compressed file system image --------------------------------------- The intent here is to build a filesystem that contains as many useful programs as will fit on a floppy disk. The final tally will depend on the compressibility of the programs you put in the filesystem. My bootdisk has 3.5Mb of programs in a 4Mb filesystem, which compresses to about 1.1Mb. This leaves 557k free on the ramdisk, although I have a number of shell functions for killing selected portions - for example, removing the networking stuff leaves about 1.2Mb free on the ramdisk. The first thing to do is find a place in which to build the filesystem. If you have a spare partition, you're set. If not, you can temporarily reuse the swap partition, or as a last resort, use the loop patches from Werner Almesberger/Theodore Ts'o to mount a file. The advantage of using a partition is that you can boot from it to check that it is actually bootable. Decide on the type of filesystem you want to create. I personally use minix because it has a low overhead. Create a filesystem on the device you are using. This means determining what size fs you want to build. I normally use a 4Mb fs because a) I have only 8Mb and b) the most I can cram onto a floppy is about 3.7Mb. However, this depends on the compressibility of the programs you use in the filesystem. Note that if you have sufficient RAM, there is no reason you can't create a larger filesystem containing a lot of free space. The unsused portion of the fs will occupy very little of the floppy because of the compression. Mount the filesystem and copy the files you want onto it. Since this is to be a bootable image, you will need /bin/sh, /etc/init and support files. Choices after the essentials will differ depending on what the disk is to be used for. After copying the disk repair utilities I needed to the filesystem for my disk, I found I had enough space left to build a general purpose Linux disk, so as well as fsck*, mkfs*, dd, bpe, etc, I added text utilities (less, sort, head, wc, etc), general system stuff (ls, touch, mkdir, ps), communications (rz, sz, minicom, getty), networking (ftp, telnet, rlogin), compression (gzip) and interpreters (awk, perl). This pretty much gives me linux on a disk. I can use this as a system recovery tool, to show linux to newbies, or to evaluate how well linux will run on new hardware. Some tips: I found it best to use shared libraries. A program can be checked for shared lib usage with `ldd progname' - no output means the file is statically linked (ie, doesn't use shared libraries). Generally recompiling (without -g in the link phase) will generate a shared library version, and is usually worth it - for example, it shaves 77k off tar. Try to find versions of the programs you want to use that are small in size. pdksh weighs in at 200k less than bash, yet contains most of the functionality. If you are building on a partition, don't forget to try actually booting from this partition. This will ensure that you have configured the startup files correctly. When you're happy with the contents of the filesystem, compress it. The included script `makefsz' will do this for you, but here are the steps: 1. Mount the filesystem and tar everything off. 2. Unmount the filesystem. 3. Wipe the partition clean (dd if=/dev/zero). 4. Make a file system on the partition. 5. Remount the filesystem. 6. Untar onto the filesystem. 7. Unmount the filesystem. 8. Pipe the filesystem image through gzip. The purpose of scrubbing the partition and then reinstalling the files with tar is to make sure that all unused space on the filesystem is zero-filled. This ensures that compression will be optimum. makefsz take two parameters, a third being optional. The first is the block device on which the filesystem you built lives. (If you used a file via the loop fs patches, you will need to do the compression by hand - refer to the above list of steps.) The second is the name of the file in which the compressed file system is to be saved. Use `-' to send the output to stdout. The third parameter is the size of the filesystem on the block device. If not supplied, makefsz assumes 4Mb. Installing a compressed file system image ----------------------------------------- Once you have a compressed fs, it needs to copied to the floppy disk, and the kernel informed on where to find it. The script `writefsz' does this, and takes one or two parameters. The first is the filename of the image, or `-' for stdin. The optional second argument is the size of the ramdisk to create on boot. This must match the size of the compressed image. By default, this is 4Mb. writefsz performs the following steps: 1. Set the size of the ramdisk (4Mb by default). 2. Mark the root filesystem as read-only. 3. Set the root device to /dev/fd0. 4. Set the pointer to the image to the block following the kernel. 5. Write the fs image to the block following the kernel. WARNING: writefsz examines /usr/src/linux/zImage to find out where on the floppy to start writing the image. If zImage is not that same kernel as is on the floppy, you will need to write the fs image by hand. Upgrading the kernel -------------------- Provided that a new kernel has the same number of blocks as the previous one, it can be written over the older kernel without having to rewrite the compressed file system image. After the new kernel is written to the floppy, simply used `cramon' to configure it. cramon takes one optional argument, the size of the ramdisk (4Mb by default). For the simple case, the kernel upgrade would be done as follows: $ make zdisk $ cramon If the new kernel does not have the same number of blocks, you will have to copy the compressed image off, update the kernel, and then copy the image back on. You can use the command `readfsz' to get a copy of the image, so your kernel upgrade would go something like: $ readfsz /tmp/cram $ make zdisk $ writefsz /tmp/cram Be aware that there is no information stored anywhere on how long the image is, so that readfsz will copy from the start of the image to the end of the disk, even if the image isn't that long. Consequently, if your kernel has grown by a few K, writefsz will not be able to write back all the information that readfsz got. As long as the kernel hasn't grown to the point where it really is forcing the end of the image off the floppy, there is no problem with writefsz not writing everything. If the kernel size really has blown out, you will have to decompress the image and delete some files (see the next section). NOTE: readfsz assumes the existence of the command `hexdump'. Updating the filesystem ----------------------- The filesystem is effectively set in stone after you compress it and write it to the floppy - you cannot mount it and tweak it if necessary. This is not a bad thing for a boot disk - it makes sure that you get it configured correctly before committing to it. Because of this, doing the initial build on a partition is advantageous as it allows you to boot from it, revealing any weaknesses. However, there are times when you wish to update the filesystem - a change in network configuration, or the size needs to be adjusted, etc. Extracting the filesystem is fairly straightforward. As for the initial build, you will need a partition (or a file and the loop fs patches). There is no need to run mkfs on the partition, just put the floppy in the drive and run: $ readfsz - | gzip -d > /dev/ As noted above, readfsz will read junk from the end of the disk, and gzip will notice this, but will ignore it. Now just mount the partition as normal, and perform whatever maintenance is required. When done, unmount the partition and update the floppy with: $ makefsz /dev/ - | writefsz - +----------------- | Assigning blame. +----------------- Inspired by the kernel compressing code by Hannu Savolainen and Nick Holloway, which used code from gzip by Jean-loup Gailly and Mark Adler. Multi page malloc and support code by Richard Lyons (me). Please send bugs/suggestions to me at rick@razorback.brisnet.org.au or pclink@qus102.qld.npb.telecom.com.au. +------------------ | Sample file list. +------------------ This is a list of the files on my bootdisk. Some of them are links (eg /bin/sh, /bin/ksh), and the /dev directory is not included. This is just to give an idea of how complete a filesystem can fit on a floppy. /bin /etc/protocols /usr/bin/sleep /bin/ksh /home /usr/bin/minicom /bin/sh /home/rick /usr/bin/who /bin/cat /home/guest /usr/bin/hexdump /bin/chmod /lib /usr/bin/od /bin/chown /lib/libc.so.4.4.1 /usr/bin/setleds /bin/cp /lib/libc.so.4 /usr/bin/setmetamode /bin/dd /lib/libm.so.4.4.1 /usr/tmp /bin/df /lib/libm.so.4 /usr/lib /bin/du /mnt /usr/lib/terminfo /bin/bpe /proc /usr/lib/terminfo/c /bin/gunzip /sbin /usr/lib/terminfo/c/console /bin/zcat /sbin/dirdump /usr/lib/terminfo/v /bin/login /sbin/e2fsck /usr/lib/terminfo/v/vt100 /bin/mv /sbin/fsck.ext2 /usr/lib/terminfo/v/vt100-am /bin/free /sbin/mke2fs /usr/lib/terminfo/v/vt100am /bin/touch /sbin/mkfs.ext2 /usr/lib/runscript /bin/ln /sbin/mklost+found /usr/lib/minirc.dfl /bin/ls /sbin/tune2fs /usr/log /bin/mkdir /sbin/getty /usr/net /bin/mknod /sbin/uugetty /usr/net/bin /bin/ps /sbin/fsck /usr/net/bin/ftp /bin/pstree /sbin/fsck.minix /usr/net/bin/ping /bin/passwd /sbin/fsck.msdos /usr/net/bin/rcp /bin/top /sbin/mkfs /usr/net/bin/rlogin /bin/rm /sbin/mkfs.minix /usr/net/bin/telnet /bin/sed /sbin/mkdosfs /usr/net/bin/arp /bin/stty /sbin/mkfs.msdos /usr/net/bin/dip /bin/hostname /sbin/dosfsck /usr/net/bin/finger /bin/w /sbin/shutdown /usr/net/bin/host /bin/tar /sbin/update /usr/net/bin/ifconfig /bin/gzip /sbin/bdflush /usr/net/bin/iflink /bin/false /sbin/mkswap /usr/net/bin/ifsetup /bin/true /sbin/mount /usr/net/bin/named /bin/tload /sbin/umount /usr/net/bin/named-xfer /bin/uptime /sbin/swapoff /usr/net/bin/named.reload /bin/su /sbin/swapon /usr/net/bin/named.restart /bin/head /sbin/fdisk /usr/net/bin/netstat /bin/tail /sbin/sync /usr/net/bin/route /bin/uniq /sbin/fastboot /usr/net/bin/rsh /bin/sort /sbin/fasthalt /usr/net/bin/ruptime /bin/date /sbin/halt /usr/net/bin/rwho /etc /sbin/telinit /usr/net/bin/tftp /etc/init /sbin/selection /usr/net/daemons /etc/brc /sbin/fuser /usr/net/daemons/fingerd /etc/rc /tmp /usr/net/daemons/ftpd /etc/default /usr /usr/net/daemons/inetd /etc/default/getty.tty1 /usr/bin /usr/net/daemons/mountd /etc/default/uugetty.ttyS1 /usr/bin/elvis /usr/net/daemons/nfsd /etc/fstab /usr/bin/ex /usr/net/daemons/pcnfsd /etc/gettydefs /usr/bin/input /usr/net/daemons/rlogind /etc/group /usr/bin/vi /usr/net/daemons/routed /etc/inittab /usr/bin/view /usr/net/daemons/rshd /etc/issue /usr/bin/awk /usr/net/daemons/rwhod /etc/passwd /usr/bin/grep /usr/net/daemons/syslogd /etc/utmp /usr/bin/egrep /usr/net/daemons/tcpd /etc/reboot /usr/bin/fgrep /usr/net/daemons/telnetd /etc/termcap /usr/bin/rz /usr/net/daemons/tftpd /etc/fastboot /usr/bin/sz /usr/net/etc /etc/services /usr/bin/perl /usr/net/etc/inetd.conf /etc/hosts /usr/bin/less /usr/net/etc/rc.net /etc/host.conf /usr/bin/strings /usr/net/etc/rc.net1 /etc/networks /usr/bin/wc /usr/net/etc/hosts /etc/resolv.conf /usr/bin/diff /usr/net/etc/host.conf /etc/mtab /usr/bin/find /usr/net/etc/networks /etc/profile /usr/bin/tr /usr/net/etc/resolv.conf /usr/net/etc/services /usr/spool /var /usr/net/etc/protocols /usr/spool/uucp /.profile cramdisk-1.0/readfsz100755 0 0 1413 5527201510 13147 0ustar rootsystem#!/bin/bash # # readfsz {fs.z|-} # # This script reads the compressed file system image from # /dev/fd0. It tries to extract the starting block from the # kernel image, and if successful, writes the image to the # specified file (or stdout if the filename is `-'). Note # that there is no way to determine how big the image is, # so the output will be from the starting block to the end of # the disk. # [ $# -ne 1 ] && { echo "Usage: `basename $0` {fs.z|-}" exit 1 } [ "$1" != - -a ! -f "$1" ] && { echo "`basename $0`: $1 not found" exit 2 } fs=$1 [ "$fs" = - ] && fs= start=`dd if=/dev/fd0 bs=1 count=2 skip=502 | hexdump -e '"%d"'` [ -z "$start" ] && { echo "`basename $0`: couldn't find start of CRAM" exit 4 } dd if=/dev/fd0 ${fs:+of=}$fs bs=1024 skip=$start cramdisk-1.0/diff-1.03100644 0 0 35650 5545215622 13040 0ustar rootsystem--- ./config.in.orig Sun Mar 13 10:17:37 1994 +++ ./config.in Sat Mar 26 19:15:19 1994 @@ -12,6 +12,7 @@ bool 'Limit memory to low 16MB' CONFIG_MAX_16M n bool 'System V IPC' CONFIG_SYSVIPC y bool 'Use -m486 flag for 486-specific optimizations' CONFIG_M486 y +bool 'Compressed RAMDISK support' CONFIG_CRAMDISK y * * Program binary formats * --- ./drivers/block/Makefile.orig Mon Mar 7 00:08:21 1994 +++ ./drivers/block/Makefile Sat Mar 26 19:15:20 1994 @@ -24,6 +24,13 @@ OBJS := ll_rw_blk.o floppy.o ramdisk.o genhd.o SRCS := ll_rw_blk.c floppy.c ramdisk.c genhd.c +ifdef CONFIG_CRAMDISK +COMP=../../zBoot +CFLAGS := $(CFLAGS) -I$(COMP) -DSTDC_HEADERS -DDYN_ALLOC -Dnear= +OBJS := $(OBJS) cramdisk.o inflate.o unzip.o +SRCS := $(SRCS) cramdisk.c $(COMP)/inflate.c $(COMP)/unzip.c +endif + ifdef CONFIG_CDU31A OBJS := $(OBJS) cdu31a.o SRCS := $(SRCS) cdu31a.c @@ -57,9 +64,15 @@ sync dep: - $(CPP) -M $(SRCS) > .depend + $(CPP) -M $(CFLAGS) $(SRCS) > .depend dummy: + +inflate.o: $(COMP)/inflate.c + $(CC) $(CFLAGS) -c $< + +unzip.o: $(COMP)/unzip.c + $(CC) $(CFLAGS) -c $< # # include a dependency file if one exists --- ./drivers/block/blk.h.orig Sat Jan 29 22:55:06 1994 +++ ./drivers/block/blk.h Sat Mar 26 19:15:20 1994 @@ -88,6 +88,8 @@ extern void rd_load(void); extern long rd_init(long mem_start, int length); extern int ramdisk_size; +extern void crd_load(void); +extern int start_cram; extern unsigned long xd_init(unsigned long mem_start, unsigned long mem_end); --- /dev/null Sat Mar 26 19:15:20 1994 +++ ./drivers/block/cramdisk.c Sat Mar 26 19:21:28 1994 @@ -0,0 +1,467 @@ +/* + * linux/kernel/blk_drv/cramdisk.c + * + * Written/adapted by Richard Lyons, 1FEB94 + * + * Bugs/suggestions to rick@razorback.brisnet.org.au or + * pclink@qus102.qld.npb.telecom.com.au. + * + * Parts of this file are copyright Jean-loup Gailly. + * Parts of this file are not copyright Mark Adler. + * + * This file implements the ability to load a compressed + * filesystem image into a ramdisk. The boot code uses + * the word located at 0x1F6 (dec 502, previously swapdev) + * to locate the start of the compressed image, and loads + * the decompressed image into a previously allocated + * ramdisk. + */ + +#include "blk.h" +#include "gzip.h" +#include "lzw.h" + +#define EOF -1 +#define MAJOR_NR MEM_MAJOR +#define RAMDISK_MINOR 1 + +extern char *rd_start; +extern int rd_length; + +DECLARE(uch, inbuf, INBUFSIZ); +DECLARE(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); +DECLARE(uch, window, WSIZE); +DECLARE(ulg, crc_32_tab, 256); + +#define fcalloc(a,b) malloc((a) * (b)) +#define fcfree(p) free(p) +#define to_stdout 0 + +void *malloc(size_t size); +void free(void *p); + +unsigned int insize; +unsigned int inptr; + +unsigned char *output_data; +unsigned long output_ptr; +unsigned int outcnt; + +int method, exit_code, part_nb, last_member; +int test = 0; +int force = 0; +int verbose = 1; +long bytes_out; + +void makecrc(void); +void allocbufs(void); +void freebufs(void); +local int get_method(int in); +void (*work)(int inf, int outf); + +/* + * We end up here if *(0x1F6) is non-zero. Assuming it to + * point to the start of a compressed filesystem image, we + * allocate the memory to do the decompression and try + * loading it. If the load succeeded, set the root dev to + * the ramdisk. + */ + +void crd_load(void) +{ + exit_code = OK; + test = 0; + part_nb = 0; + allocbufs(); + clear_bufs(); + makecrc(); + printk("CRAMDISK: decompressing image"); + if (get_method(0) < 0) + return; + work(0, 0); + printk("done.\n"); + freebufs(); + invalidate_buffers(ROOT_DEV); + if (exit_code == OK) + ROOT_DEV = ((MEM_MAJOR << 8) | RAMDISK_MINOR); +} + +/* + * The buffers are dynamically allocated, otherwise we'd + * end up with an 83k hole in the kernel that gets used + * exactly once. Since kmalloc can't (yet) allocate + * more than 4k at a blow, we use a customised malloc(); + * see below. + */ + +void +allocbufs(void) +{ + ALLOC(uch, inbuf, INBUFSIZ); + ALLOC(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); + ALLOC(uch, window, WSIZE); + ALLOC(ulg, crc_32_tab, 256); +} + +void +freebufs(void) +{ + FREE(crc_32_tab); + FREE(window); + FREE(outbuf); + FREE(inbuf); +} + + +/* =========================================================================== + * Clear input and output buffers + */ +void clear_bufs() +{ + output_data = rd_start; + outcnt = output_ptr = 0; + insize = inptr = 0; + bytes_out = 0L; +} + +/* + * Code to compute the CRC-32 table. Borrowed from + * gzip-1.0.3/makecrc.c. + */ + +void +makecrc(void) +{ +/* Not copyrighted 1990 Mark Adler */ + + unsigned long c; /* crc shift register */ + unsigned long e; /* polynomial exclusive-or pattern */ + int i; /* counter for all possible eight bit values */ + int k; /* byte being shifted into crc apparatus */ + + /* terms of polynomial defining this crc (except x^32): */ + static int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + + /* Make exclusive-or pattern from polynomial */ + e = 0; + for (i = 0; i < sizeof(p)/sizeof(int); i++) + e |= 1L << (31 - p[i]); + + crc_32_tab[0] = 0; + + for (i = 1; i < 256; i++) + { + c = 0; + for (k = i | 256; k != 1; k >>= 1) + { + c = c & 1 ? (c >> 1) ^ e : c >> 1; + if (k & 1) + c ^= e; + } + crc_32_tab[i] = c; + } +} + +/* =========================================================================== + * Run a set of bytes through the crc shift register. If s is a NULL + * pointer, then initialize the crc shift register contents instead. + * Return the current crc in either case. + */ +ulg updcrc(s, n) + uch *s; /* pointer to bytes to pump through */ + unsigned n; /* number of bytes in s[] */ +{ + register ulg c; /* temporary variable */ + + static ulg crc = (ulg)0xffffffffL; /* shift register contents */ + + if (s == NULL) { + c = 0xffffffffL; + } else { + c = crc; + while (n--) { + c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8); + } + } + crc = c; + return c ^ 0xffffffffL; /* (instead of ~c for 64-bit machines) */ +} + +void +error(char *s) +{ + printk("%s", s); + exit_code = ERROR; +} + +/* ======================================================================== + * Check the magic number of the input file and update ofname if an + * original name was given and to_stdout is not set. + * Return the compression method, -1 for error, -2 for warning. + * Set inptr to the offset of the next byte to be processed. + * This function may be called repeatedly for an input file consisting + * of several contiguous gzip'ed members. + * IN assertions: there is at least one remaining compressed member. + * If the member is a zip file, it must be the only one. + */ +local int get_method(in) + int in; /* input file descriptor */ +{ + uch flags; + char magic[2]; /* magic header */ + + magic[0] = (char)get_byte(); + magic[1] = (char)get_byte(); + + method = -1; /* unknown yet */ + part_nb++; /* number of parts in gzip file */ + last_member = 0; + /* assume multiple members in gzip file except for record oriented I/O */ + + if (memcmp(magic, GZIP_MAGIC, 2) == 0 + || memcmp(magic, OLD_GZIP_MAGIC, 2) == 0) { + + work = unzip; + method = (int)get_byte(); + flags = (uch)get_byte(); + if ((flags & ENCRYPTED) != 0) { + error("Input is encrypted\n"); + exit_code = ERROR; + return -1; + } + if ((flags & CONTINUATION) != 0) { + error("Multi part input\n"); + exit_code = ERROR; + if (force <= 1) return -1; + } + if ((flags & RESERVED) != 0) { + error("Input has invalid flags\n"); + exit_code = ERROR; + if (force <= 1) return -1; + } + (ulg)get_byte(); /* Get timestamp */ + ((ulg)get_byte()) << 8; + ((ulg)get_byte()) << 16; + ((ulg)get_byte()) << 24; + + (void)get_byte(); /* Ignore extra flags for the moment */ + (void)get_byte(); /* Ignore OS type for the moment */ + + if ((flags & CONTINUATION) != 0) { + unsigned part = (unsigned)get_byte(); + part |= ((unsigned)get_byte())<<8; + if (verbose) { + error("Input is not part number 1\n"); + } + } + if ((flags & EXTRA_FIELD) != 0) { + unsigned len = (unsigned)get_byte(); + len |= ((unsigned)get_byte())<<8; + while (len--) (void)get_byte(); + } + + /* Get original file name if it was truncated */ + if ((flags & ORIG_NAME) != 0) { + if (to_stdout || part_nb > 1) { + /* Discard the old name */ + while (get_byte() != 0) /* null */ ; + } else { + } /* to_stdout */ + } /* orig_name */ + + /* Discard file comment if any */ + if ((flags & COMMENT) != 0) { + while (get_byte() != 0) /* null */ ; + } + + } else if (memcmp(magic, PKZIP_MAGIC, 2) == 0 && inptr == 2 + && memcmp(inbuf, PKZIP_MAGIC, 4) == 0) { + /* To simplify the code, we support a zip file when alone only. + * We are thus guaranteed that the entire local header fits in inbuf. + */ + inptr = 0; + work = unzip; + if (check_zipfile(in) == -1) return -1; + /* check_zipfile may get ofname from the local header */ + last_member = 1; + + } else if (memcmp(magic, PACK_MAGIC, 2) == 0) { + error("packed input"); + } else if (memcmp(magic, LZW_MAGIC, 2) == 0) { + error("compressed input"); + last_member = 1; + } + if (method == -1) { + error("Corrupted input\n"); + if (exit_code != ERROR) exit_code = part_nb == 1 ? ERROR : WARNING; + return part_nb == 1 ? -1 : -2; + } + return method; +} + +/* + * Read the fs image off the floppy. We arrange to read in + * the next 15 blocks every 8k, so that the hardware is kept + * busy while the kernel decompresses the image. An I/O + * error after a successful read is treated as an EOF for the + * image. + */ + +int +fill_inbuf(void) +{ + struct buffer_head *bh; + + if (exit_code != OK) + return EOF; + insize = 0; + while (insize + BLOCK_SIZE <= INBUFSIZ) { + if ((insize % (8 * BLOCK_SIZE)) == 0) +#ifdef BUF_CLEAN + bh = breada(ROOT_DEV, start_cram, BLOCK_SIZE, 0, PAGE_SIZE); +#else + bh = breada(ROOT_DEV, start_cram, start_cram + 1, start_cram + 2, start_cram + 3, + start_cram + 4, start_cram + 5, start_cram + 6, start_cram + 7, + start_cram + 8, start_cram + 9, start_cram + 10, start_cram + 11, + start_cram + 12, start_cram + 13, start_cram + 14, start_cram + 15, + -1); +#endif + else + bh = bread(ROOT_DEV, start_cram, BLOCK_SIZE); + if (!bh) { + if (insize) + break; + error("CRAMDISK: I/O error while reading compressed image\n"); + return EOF; + } + memcpy(inbuf + insize, bh->b_data, BLOCK_SIZE); + brelse(bh); + insize += BLOCK_SIZE; + ++start_cram; + } + printk("."); + inptr = 1; + return *inbuf; +} + +/* =========================================================================== + * Write the output window window[0..outcnt-1] and update crc and bytes_out. + * (Used for the decompressed data only.) + */ +void flush_window() +{ + if (outcnt == 0) + return; + if (output_ptr + outcnt > rd_length) + error("CRAMDISK: compressed image too long\n"); + else { + updcrc(window, outcnt); + + memcpy(output_data + output_ptr, (char *)window, outcnt); + + bytes_out += (ulg)outcnt; + output_ptr += (ulg)outcnt; + } + outcnt = 0; +} + + +typedef struct { + unsigned long start; + unsigned long pages; +} chain; + +#define MAX_MISSES (PAGE_SIZE/sizeof(chain)) + +static void +free_chain(chain *p) +{ + unsigned long start; + unsigned long pages; + + start = p->start; + pages = p->pages; + while (pages--) { + free_page(start); + start += PAGE_SIZE; + } +} + +/* + * kmalloc() can't allocate more than a page at a time, which is a + * bit limiting for the decompressor, which requires a number of + * 32k buffers. The following malloc() searches the free page + * list for contiguous pages, collecting as many as necessary to + * satisfy the requested allocation. Note that it depends on + * __get_free_page() returning adjacent pages. High/low or low/high + * order doesn't matter, but it will not search the list for a + * page adjoining a currently allocated one. This is not really a + * drawback for cramdisk, since it gets called before any user + * processes (and hence page permutation) get started. + * + * The array that contains the allocated pages that don't satisfy + * the request (the misses array) is dynamically allocated since + * kernel stack is limited. + * + * The prealloc of the misses page reduces the number of free + * pages. I tried not getting a page until a miss occured, but + * the code was unaesthetic. Besides, if memory is so limited + * that one page makes a difference, there are other things to + * worry about. + */ + + +void * +malloc(size_t size) +{ + int nr_pages; + unsigned long page; + chain hit; + chain *misses; + int misscnt; + + nr_pages = (size + sizeof(hit.pages) + PAGE_SIZE - 1) / PAGE_SIZE; + if ((misses = (chain *)__get_free_page(GFP_KERNEL)) == 0) + return 0; + misses[0].start = (unsigned long)misses; + misses[0].pages = 1; + misscnt = 1; + if ((hit.start = __get_free_page(GFP_KERNEL)) != 0) { + hit.pages = 1; + while (hit.pages < nr_pages) { + if (!(page = __get_free_page(GFP_KERNEL))) + break; + if (page == hit.start - PAGE_SIZE) + hit.start = page; + else if (page != hit.start + (hit.pages * PAGE_SIZE)) { + if (misscnt == MAX_MISSES) { + free_page(page); + break; + } + misses[misscnt++] = hit; + hit.start = page; + hit.pages = 0; + } + ++hit.pages; + } + } + while (misscnt--) + free_chain(misses + misscnt); + if (hit.pages == nr_pages) { + *(unsigned long *)hit.start = hit.pages; + return (void *)(hit.start + sizeof(hit.pages)); + } + if (hit.pages) + free_chain(&hit); + return 0; +} + +void +free(void *p) +{ + chain hit; + + hit.start = (unsigned long)p - sizeof(hit.pages); + hit.pages = *(unsigned long *)hit.start; + free_chain(&hit); +} --- ./drivers/block/ramdisk.c.orig Sat Mar 26 19:12:26 1994 +++ ./drivers/block/ramdisk.c Sat Mar 26 19:15:20 1994 @@ -180,4 +180,8 @@ ROOT_DEV = ((MEM_MAJOR << 8) | RAMDISK_MINOR); return; } +#ifdef CONFIG_CRAMDISK + if (start_cram) + crd_load(); +#endif } --- ./init/main.c.orig Tue Feb 8 00:07:01 1994 +++ ./init/main.c Sat Mar 26 19:15:19 1994 @@ -110,6 +110,7 @@ #define DRIVE_INFO (*(struct drive_info_struct *) (PARAM+0x80)) #define SCREEN_INFO (*(struct screen_info *) (PARAM+0)) #define MOUNT_ROOT_RDONLY (*(unsigned short *) (PARAM+0x1F2)) +#define START_CRAM (*(unsigned short *) (PARAM+0x1F6)) #define RAMDISK_SIZE (*(unsigned short *) (PARAM+0x1F8)) #define ORIG_ROOT_DEV (*(unsigned short *) (PARAM+0x1FC)) #define AUX_DEVICE_INFO (*(unsigned char *) (PARAM+0x1FF)) @@ -144,6 +145,7 @@ struct screen_info screen_info; unsigned char aux_device_present; +int start_cram; int ramdisk_size; int root_mountflags = 0; @@ -362,6 +364,7 @@ memory_end = (1<<20) + (EXT_MEM_K<<10); memory_end &= PAGE_MASK; ramdisk_size = RAMDISK_SIZE; + start_cram = START_CRAM; copy_options(command_line,COMMAND_LINE); #ifdef CONFIG_MAX_16M if (memory_end > 16*1024*1024)