diff -Nuar linux-xip/Documentation/Configure.help linux-00/Documentation/Configure.help --- linux-xip/Documentation/Configure.help Wed Feb 26 09:20:12 2003 +++ linux-00/Documentation/Configure.help Wed Feb 26 09:22:41 2003 @@ -14552,6 +14552,40 @@ If unsure, say N. +Use linear addressing for cramfs +CONFIG_CRAMFS_LINEAR + This option tells the cramfs driver to load data directly from a linear + adressed memory range (usually non volatile memory like flash) instead + of going through the block device layer. This saves some memory since + no intermediate buffering is necessary. + + This is also a prerequisite for XIP of binaries stored on the filesystem. + + The location of the cramfs image in memory is board dependent. Therefore, + if you say Y, you must know the proper physical address where to store + the cramfs image and specify it using the physaddr=0x******** mount + option (for example: "mount -t cramfs -o physaddr=0x100000 none /mnt"). + + If unsure, say N. + +Support XIP on linear cramfs +CONFIG_CRAMFS_LINEAR_XIP + You must say Y to this option if you want to be able to run applications + directly from non-volatile memory. XIP applications are marked by + setting the sticky bit (ie, "chmod +t "). A cramfs file system + then needs to be created using mkcramfs (with XIP cramfs support + in it). Applications marked for XIP execution will not be compressed + since they have to run directly from flash. + +Root file system on linear cramfs +CONFIG_ROOT_CRAMFS_LINEAR + Say Y if you have enabled linear cramfs, and you want to be able to use + the linear cramfs image as a root file system. To actually have the + kernel mount this cramfs image as a root file system, you must also pass + the command line parameter "root=/dev/null rootflags=physaddr=0x********" + to the kernel (replace 0x******** with the physical address location + of the linear cramfs image to boot with). + CMS file system support CONFIG_CMS_FS Read only support for CMS minidisk file systems found on IBM diff -Nuar linux-xip/fs/Config.in linux-00/fs/Config.in --- linux-xip/fs/Config.in Wed Feb 26 09:19:46 2003 +++ linux-00/fs/Config.in Wed Feb 26 09:22:41 2003 @@ -44,6 +44,9 @@ int 'JFFS2 debugging verbosity (0 = quiet, 2 = noisy)' CONFIG_JFFS2_FS_DEBUG 0 fi tristate 'Compressed ROM file system support' CONFIG_CRAMFS +dep_mbool ' Use linear addressing for cramfs' CONFIG_CRAMFS_LINEAR $CONFIG_CRAMFS +dep_bool ' Support XIP on linear cramfs' CONFIG_CRAMFS_LINEAR_XIP $CONFIG_CRAMFS_LINEAR +dep_bool ' Root file system on linear cramfs' CONFIG_ROOT_CRAMFS_LINEAR $CONFIG_CRAMFS_LINEAR $CONFIG_CRAMFS bool 'Virtual memory file system support (former shm fs)' CONFIG_TMPFS define_bool CONFIG_RAMFS y diff -Nuar linux-xip/fs/cramfs/inode.c linux-00/fs/cramfs/inode.c --- linux-xip/fs/cramfs/inode.c Wed Feb 26 09:19:46 2003 +++ linux-00/fs/cramfs/inode.c Wed Feb 26 09:48:17 2003 @@ -11,15 +11,50 @@ * The actual compression is based on zlib, see the other files. */ +/* Linear Addressing code + * + * Copyright (C) 2000 Shane Nay. + * + * Allows you to have a linearly addressed cramfs filesystem. + * Saves the need for buffer, and the munging of the buffer. + * Savings a bit over 32k with default PAGE_SIZE, BUFFER_SIZE + * etc. Usefull on embedded platform with ROM :-). + * + * Downsides- Currently linear addressed cramfs partitions + * don't co-exist with block cramfs partitions. + * + */ + +/* + * 28-Dec-2000: XIP mode for linear cramfs + * Copyright (C) 2000 Robert Leslie + * + * This program is free software; 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + #include #include #include #include #include +#include #include #include #include #include +#include #include @@ -28,6 +63,8 @@ #define CRAMFS_SB_BLOCKS u.cramfs_sb.blocks #define CRAMFS_SB_FILES u.cramfs_sb.files #define CRAMFS_SB_FLAGS u.cramfs_sb.flags +#define CRAMFS_SB_LINEAR_PHYS_ADDR u.cramfs_sb.linear_phys_addr +#define CRAMFS_SB_LINEAR_VIRT_ADDR u.cramfs_sb.linear_virt_addr static struct super_operations cramfs_ops; static struct inode_operations cramfs_dir_inode_operations; @@ -42,6 +79,74 @@ #define CRAMINO(x) ((x)->offset?(x)->offset<<2:1) #define OFFSET(x) ((x)->i_ino) + +#ifdef CONFIG_CRAMFS_LINEAR_XIP + +static int cramfs_mmap(struct file *file, struct vm_area_struct *vma) +{ + unsigned long address, length; + struct inode *inode = file->f_dentry->d_inode; + struct super_block *sb = inode->i_sb; + + /* this is only used in the case of read-only maps for XIP */ + + if (vma->vm_flags & VM_WRITE) + return generic_file_mmap(file, vma); + + if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) + return -EINVAL; + + address = PAGE_ALIGN(sb->CRAMFS_SB_LINEAR_PHYS_ADDR + OFFSET(inode)); + address += vma->vm_pgoff << PAGE_SHIFT; + + length = vma->vm_end - vma->vm_start; + + if (length > inode->i_size) + length = inode->i_size; + + length = PAGE_ALIGN(length); + + +#if 0 + /* Doing the following makes it slower and more broken. bdl */ + /* + * Accessing memory above the top the kernel knows about or + * through a file pointer that was marked O_SYNC will be + * done non-cached. + */ + vma->vm_page_prot = + __pgprot((pgprot_val(vma->vm_page_prot) & ~_CACHE_MASK) + | _CACHE_UNCACHED); +#endif + + /* + * Don't dump addresses that are not real memory to a core file. + */ + vma->vm_flags |= VM_IO; + flush_tlb_page(vma, address); + if (remap_page_range(vma->vm_start, address, length, + vma->vm_page_prot)) + return -EAGAIN; + +#ifdef DEBUG_CRAMFS_XIP + printk("cramfs_mmap: mapped %s at 0x%08lx, length %lu to vma 0x%08lx" + ", page_prot 0x%08lx\n", + file->f_dentry->d_name.name, address, length, + vma->vm_start, pgprot_val(vma->vm_page_prot)); +#endif + + return 0; +} + +static struct file_operations cramfs_linear_xip_fops = { + read: generic_file_read, + mmap: cramfs_mmap, +}; + +#define CRAMFS_INODE_IS_XIP(x) ((x)->i_mode & S_ISVTX) + +#endif + static struct inode *get_cramfs_inode(struct super_block *sb, struct cramfs_inode * cramfs_inode) { struct inode * inode = new_inode(sb); @@ -60,7 +165,11 @@ without -noleaf option. */ insert_inode_hash(inode); if (S_ISREG(inode->i_mode)) { +#ifdef CONFIG_CRAMFS_LINEAR_XIP + inode->i_fop = CRAMFS_INODE_IS_XIP(inode) ? &cramfs_linear_xip_fops : &generic_ro_fops; +#else inode->i_fop = &generic_ro_fops; +#endif inode->i_data.a_ops = &cramfs_aops; } else if (S_ISDIR(inode->i_mode)) { inode->i_op = &cramfs_dir_inode_operations; @@ -76,6 +185,17 @@ return inode; } +#ifdef CONFIG_CRAMFS_LINEAR +/* + * Return a pointer to the block in the linearly addressed cramfs image. + */ +static void *cramfs_read(struct super_block *sb, unsigned int offset, unsigned int len) +{ + if (!len) + return NULL; + return (void*)(sb->CRAMFS_SB_LINEAR_VIRT_ADDR + offset); +} +#else /* Not linear addressing - aka regular block mode. */ /* * We have our own block cache: don't fill up the buffer cache * with the rom-image, because the way the filesystem is set @@ -186,23 +306,65 @@ } return read_buffers[buffer] + offset; } - +#endif /* !CONFIG_CRAMFS_LINEAR */ static struct super_block * cramfs_read_super(struct super_block *sb, void *data, int silent) { +#ifndef CONFIG_CRAMFS_LINEAR int i; +#else + char *p; +#endif struct cramfs_super super; unsigned long root_offset; struct super_block * retval = NULL; - set_blocksize(sb->s_dev, PAGE_CACHE_SIZE); sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; +#ifndef CONFIG_CRAMFS_LINEAR + + set_blocksize(sb->s_dev, PAGE_CACHE_SIZE); + /* Invalidate the read buffers on mount: think disk change.. */ for (i = 0; i < READ_BUFFERS; i++) buffer_blocknr[i] = -1; +#else + + /* + * The physical location of the cramfs image is specified as + * a mount parameter. This parameter is mandatory for obvious + * reasons. Some validation is made on the phys address but this + * is not exhaustive and we count on the fact that someone using + * this feature is supposed to know what he/she's doing. + */ + if (!data || !(p = strstr((char *)data, "physaddr="))) { + printk(KERN_ERR "cramfs: unknown physical address for linear cramfs image\n"); + goto out; + } + sb->CRAMFS_SB_LINEAR_PHYS_ADDR = simple_strtoul(p + 9, NULL, 0); + if (sb->CRAMFS_SB_LINEAR_PHYS_ADDR & (PAGE_SIZE-1)) { + printk(KERN_ERR "cramfs: physical address 0x%lx for linear cramfs isn't aligned to a page boundary\n", + sb->CRAMFS_SB_LINEAR_PHYS_ADDR); + goto out; + } + if (sb->CRAMFS_SB_LINEAR_PHYS_ADDR == 0) { + printk(KERN_ERR "cramfs: physical address for linear cramfs image can't be 0\n"); + goto out; + } + printk(KERN_INFO "cramfs: checking physical address 0x%lx for linear cramfs image\n", + sb->CRAMFS_SB_LINEAR_PHYS_ADDR); + + /* Map only one page for now. Will remap it when fs size is known. */ + sb->CRAMFS_SB_LINEAR_VIRT_ADDR = + ioremap(sb->CRAMFS_SB_LINEAR_PHYS_ADDR, PAGE_SIZE); + if (!sb->CRAMFS_SB_LINEAR_VIRT_ADDR) { + printk(KERN_ERR "cramfs: ioremap of the linear cramfs image failed\n"); + goto out; + } +#endif + down(&read_mutex); /* Read the first block and get the superblock from it */ memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super)); @@ -254,8 +416,26 @@ /* Set it all up.. */ sb->s_op = &cramfs_ops; sb->s_root = d_alloc_root(get_cramfs_inode(sb, &super.root)); + +#ifdef CONFIG_CRAMFS_LINEAR + /* Remap the whole filesystem now */ + iounmap(sb->CRAMFS_SB_LINEAR_VIRT_ADDR); + printk(KERN_INFO "cramfs: linear cramfs image appears to be %lu KB in size\n", + sb->CRAMFS_SB_SIZE/1024); + sb->CRAMFS_SB_LINEAR_VIRT_ADDR = + ioremap(sb->CRAMFS_SB_LINEAR_PHYS_ADDR, sb->CRAMFS_SB_SIZE); + if (!sb->CRAMFS_SB_LINEAR_VIRT_ADDR) { + printk(KERN_ERR "cramfs: ioremap of the linear cramfs image failed\n"); + goto out; + } +#endif + retval = sb; out: +#ifdef CONFIG_CRAMFS_LINEAR + if (!retval && sb->CRAMFS_SB_LINEAR_VIRT_ADDR) + iounmap(sb->CRAMFS_SB_LINEAR_VIRT_ADDR); +#endif return retval; } @@ -317,8 +497,10 @@ namelen--; } error = filldir(dirent, name, namelen, offset, CRAMINO(de), de->mode >> 12); - if (error) + if (error) { + printk("error %d\n", error); break; + } offset = nextoffset; filp->f_pos = offset; @@ -390,26 +572,44 @@ bytes_filled = 0; if (page->index < maxblock) { struct super_block *sb = inode->i_sb; - u32 blkptr_offset = OFFSET(inode) + page->index*4; + u32 blkptr_offset; u32 start_offset, compr_len; - start_offset = OFFSET(inode) + maxblock*4; - down(&read_mutex); - if (page->index) - start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4, 4); - compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) - start_offset); - up(&read_mutex); - pgdata = kmap(page); - if (compr_len == 0) - ; /* hole */ - else { +#ifdef CONFIG_CRAMFS_LINEAR_XIP + if(CRAMFS_INODE_IS_XIP(inode)) { + blkptr_offset = + PAGE_ALIGN(OFFSET(inode)) + + page->index * PAGE_CACHE_SIZE; + down(&read_mutex); + memcpy(page_address(page), + cramfs_read(sb, blkptr_offset, PAGE_CACHE_SIZE), + PAGE_CACHE_SIZE); + up(&read_mutex); + bytes_filled = PAGE_CACHE_SIZE; + pgdata = kmap(page); + } else { +#endif + blkptr_offset = OFFSET(inode) + page->index*4; + start_offset = OFFSET(inode) + maxblock*4; down(&read_mutex); - bytes_filled = cramfs_uncompress_block(pgdata, - PAGE_CACHE_SIZE, - cramfs_read(sb, start_offset, compr_len), - compr_len); + if (page->index) + start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4, 4); + compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) - start_offset); up(&read_mutex); + pgdata = kmap(page); + if (compr_len == 0) + ; /* hole */ + else { + down(&read_mutex); + bytes_filled = cramfs_uncompress_block(pgdata, + PAGE_CACHE_SIZE, + cramfs_read(sb, start_offset, compr_len), + compr_len); + up(&read_mutex); + } +#ifdef CONFIG_CRAMFS_LINEAR_XIP } +#endif } else pgdata = kmap(page); memset(pgdata + bytes_filled, 0, PAGE_CACHE_SIZE - bytes_filled); @@ -444,7 +644,11 @@ statfs: cramfs_statfs, }; +#ifndef CONFIG_CRAMFS_LINEAR static DECLARE_FSTYPE_DEV(cramfs_fs_type, "cramfs", cramfs_read_super); +#else +static DECLARE_FSTYPE(cramfs_fs_type, "cramfs", cramfs_read_super, 0); +#endif static int __init init_cramfs_fs(void) { diff -Nuar linux-xip/include/linux/cramfs_fs_sb.h linux-00/include/linux/cramfs_fs_sb.h --- linux-xip/include/linux/cramfs_fs_sb.h Wed Feb 26 09:19:46 2003 +++ linux-00/include/linux/cramfs_fs_sb.h Wed Feb 26 09:22:41 2003 @@ -10,6 +10,10 @@ unsigned long blocks; unsigned long files; unsigned long flags; +#ifdef CONFIG_CRAMFS_LINEAR + unsigned long linear_phys_addr; + char * linear_virt_addr; +#endif }; #endif diff -Nuar linux-xip/init/do_mounts.c linux-00/init/do_mounts.c --- linux-xip/init/do_mounts.c Wed Feb 26 09:20:12 2003 +++ linux-00/init/do_mounts.c Wed Mar 5 15:53:30 2003 @@ -130,7 +130,7 @@ { "add", 0x1c30 }, { "ade", 0x1c40 }, { "fd", 0x0200 }, - { "md", 0x0900 }, + { "md", 0x0900 }, { "xda", 0x0d00 }, { "xdb", 0x0d40 }, { "ram", 0x0100 }, @@ -358,6 +358,15 @@ } #endif +#ifdef CONFIG_ROOT_CRAMFS_LINEAR +static int __init mount_linear_cramfs_root(void) +{ + if ( sys_mount("/dev/root","/root","cramfs",root_mountflags,root_mount_data) == 0) + return 1; + return 0; +} +#endif + static int __init create_dev(char *name, kdev_t dev, char *devfs_name) { void *handle; @@ -711,6 +720,18 @@ static void __init mount_root(void) { +#ifdef CONFIG_ROOT_CRAMFS_LINEAR + if (ROOT_DEV == MKDEV(0, 0)) { + if (mount_linear_cramfs_root()) { + sys_chdir("/root"); + ROOT_DEV = current->fs->pwdmnt->mnt_sb->s_dev; + printk("VFS: Mounted root (linear cramfs filesystem).\n"); + return; + } + printk(KERN_ERR "VFS: Unable to mount linear cramfs root, trying floppy.\n"); + ROOT_DEV = MKDEV(FLOPPY_MAJOR, 0); + } +#endif #ifdef CONFIG_ROOT_NFS if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) { if (mount_nfs_root()) { diff -Nuar linux-xip/scripts/cramfs/GNUmakefile linux-00/scripts/cramfs/GNUmakefile --- linux-xip/scripts/cramfs/GNUmakefile Wed Dec 31 16:00:00 1969 +++ linux-00/scripts/cramfs/GNUmakefile Wed Feb 26 09:22:08 2003 @@ -0,0 +1,12 @@ +CC = gcc +CFLAGS = -W -Wall -O2 -g +CPPFLAGS = -I../../include +LDLIBS = -lz +PROGS = mkcramfs cramfsck + +all: $(PROGS) + +distclean clean: + rm -f $(PROGS) + +.PHONY: all clean diff -Nuar linux-xip/scripts/cramfs/cramfsck.c linux-00/scripts/cramfs/cramfsck.c --- linux-xip/scripts/cramfs/cramfsck.c Wed Dec 31 16:00:00 1969 +++ linux-00/scripts/cramfs/cramfsck.c Wed Feb 26 09:22:08 2003 @@ -0,0 +1,588 @@ +/* + * cramfsck - check a cramfs file system + * + * Copyright (C) 2000-2001 Transmeta Corporation + * + * This program is free software; 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * 1999/12/03: Linus Torvalds (cramfs tester and unarchive program) + * 2000/06/03: Daniel Quinlan (CRC and length checking program) + * 2000/06/04: Daniel Quinlan (merged programs, added options, support + * for special files, preserve permissions and + * ownership, cramfs superblock v2, bogus mode + * test, pathname length test, etc.) + * 2000/06/06: Daniel Quinlan (support for holes, pretty-printing, + * symlink size test) + * 2000/07/11: Daniel Quinlan (file length tests, start at offset 0 or 512, + * fsck-compatible exit codes) + * 2000/07/15: Daniel Quinlan (initial support for block devices) + */ + +/* compile-time options */ +#define INCLUDE_FS_TESTS /* include cramfs checking and extraction */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define _LINUX_STRING_H_ +#include +#include +#include + +static const char *progname = "cramfsck"; + +static int fd; /* ROM image file descriptor */ +static char *filename; /* ROM image filename */ +struct cramfs_super *super; /* just find the cramfs superblock once */ +static int opt_verbose = 0; /* 1 = verbose (-v), 2+ = very verbose (-vv) */ +#ifdef INCLUDE_FS_TESTS +static int opt_extract = 0; /* extract cramfs (-x) */ +char *extract_dir = NULL; /* extraction directory (-x) */ + +unsigned long start_inode = 1 << 28; /* start of first non-root inode */ +unsigned long end_inode = 0; /* end of the directory structure */ +unsigned long start_data = 1 << 28; /* start of the data (256 MB = max) */ +unsigned long end_data = 0; /* end of the data */ +/* true? cramfs_super < start_inode < end_inode <= start_data <= end_data */ +static uid_t euid; /* effective UID */ + +#define PAD_SIZE 512 +#define PAGE_CACHE_SIZE (4096) + +/* Guarantee access to at least 8kB at a time */ +#define ROMBUFFER_BITS 13 +#define ROMBUFFERSIZE (1 << ROMBUFFER_BITS) +#define ROMBUFFERMASK (ROMBUFFERSIZE-1) +static char read_buffer[ROMBUFFERSIZE * 2]; +static unsigned long read_buffer_block = ~0UL; + +/* Uncompressing data structures... */ +static char outbuffer[PAGE_CACHE_SIZE*2]; +z_stream stream; + +#endif /* INCLUDE_FS_TESTS */ + +/* Input status of 0 to print help and exit without an error. */ +static void usage(int status) +{ + FILE *stream = status ? stderr : stdout; + + fprintf(stream, "usage: %s [-hv] [-x dir] file\n" + " -h print this help\n" + " -x dir extract into dir\n" + " -v be more verbose\n" + " file file to test\n", progname); + + exit(status); +} + +#ifdef INCLUDE_FS_TESTS +void print_node(char type, struct cramfs_inode *i, char *name) +{ + char info[10]; + + if (S_ISCHR(i->mode) || (S_ISBLK(i->mode))) { + /* major/minor numbers can be as high as 2^12 or 4096 */ + snprintf(info, 10, "%4d,%4d", major(i->size), minor(i->size)); + } + else { + /* size be as high as 2^24 or 16777216 */ + snprintf(info, 10, "%9d", i->size); + } + + printf("%c %04o %s %5d:%-3d %s\n", + type, i->mode & ~S_IFMT, info, i->uid, i->gid, name); +} + +/* + * Create a fake "blocked" access + */ +static void *romfs_read(unsigned long offset) +{ + unsigned int block = offset >> ROMBUFFER_BITS; + if (block != read_buffer_block) { + read_buffer_block = block; + lseek(fd, block << ROMBUFFER_BITS, SEEK_SET); + read(fd, read_buffer, ROMBUFFERSIZE * 2); + } + return read_buffer + (offset & ROMBUFFERMASK); +} + +static struct cramfs_inode *cramfs_iget(struct cramfs_inode * i) +{ + struct cramfs_inode *inode = malloc(sizeof(struct cramfs_inode)); + *inode = *i; + return inode; +} + +static struct cramfs_inode *iget(unsigned int ino) +{ + return cramfs_iget(romfs_read(ino)); +} + +void iput(struct cramfs_inode *inode) +{ + free(inode); +} + +/* + * Return the offset of the root directory, + * or 0 if none. + */ +static struct cramfs_inode *read_super(void) +{ + unsigned long offset; + + offset = super->root.offset << 2; + if (super->magic != CRAMFS_MAGIC) + return NULL; + if (memcmp(super->signature, CRAMFS_SIGNATURE, sizeof(super->signature)) != 0) + return NULL; + if (offset < sizeof(super)) + return NULL; + return cramfs_iget(&super->root); +} + +static int uncompress_block(void *src, int len) +{ + int err; + + stream.next_in = src; + stream.avail_in = len; + + stream.next_out = (unsigned char *) outbuffer; + stream.avail_out = PAGE_CACHE_SIZE*2; + + inflateReset(&stream); + + err = inflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + fprintf(stderr, "%s: error %d while decompressing! %p(%d)\n", + filename, err, src, len); + exit(4); + } + return stream.total_out; +} + +static void change_file_status(char *path, struct cramfs_inode *i) +{ + struct utimbuf epoch = { 0, 0 }; + + if (euid == 0) { + if (lchown(path, i->uid, i->gid) < 0) { + perror(path); + exit(8); + } + if (S_ISLNK(i->mode)) + return; + if ((S_ISUID | S_ISGID) & i->mode) { + if (chmod(path, i->mode) < 0) { + perror(path); + exit(8); + } + } + } + if (S_ISLNK(i->mode)) + return; + if (utime(path, &epoch) < 0) { + perror(path); + exit(8); + } +} + +static void do_symlink(char *path, struct cramfs_inode *i) +{ + unsigned long offset = i->offset << 2; + unsigned long curr = offset + 4; + unsigned long next = *(u32 *) romfs_read(offset); + unsigned long size; + + if (next > end_data) { + end_data = next; + } + + size = uncompress_block(romfs_read(curr), next - curr); + if (size != i->size) { + fprintf(stderr, "%s: size error in symlink `%s'\n", + filename, path); + exit(4); + } + outbuffer[size] = 0; + if (opt_verbose) { + char *str; + + str = malloc(strlen(outbuffer) + strlen(path) + 5); + strcpy(str, path); + strncat(str, " -> ", 4); + strncat(str, outbuffer, size); + + print_node('l', i, str); + if (opt_verbose > 1) { + printf(" uncompressing block at %ld to %ld (%ld)\n", curr, next, next - curr); + } + } + if (opt_extract) { + symlink(outbuffer, path); + change_file_status(path, i); + } +} + +static void do_special_inode(char *path, struct cramfs_inode *i) +{ + dev_t devtype = 0; + char type; + + if (S_ISCHR(i->mode)) { + devtype = i->size; + type = 'c'; + } + else if (S_ISBLK(i->mode)) { + devtype = i->size; + type = 'b'; + } + else if (S_ISFIFO(i->mode)) + type = 'p'; + else if (S_ISSOCK(i->mode)) + type = 's'; + else { + fprintf(stderr, "%s: bogus mode on `%s' (%o)\n", filename, path, i->mode); + exit(4); + } + + if (opt_verbose) { + print_node(type, i, path); + } + + if (opt_extract) { + if (mknod(path, i->mode, devtype) < 0) { + perror(path); + exit(8); + } + change_file_status(path, i); + } +} + +static void do_uncompress(int fd, unsigned long offset, unsigned long size) +{ + unsigned long curr = offset + 4 * ((size + PAGE_CACHE_SIZE - 1) / PAGE_CACHE_SIZE); + + do { + unsigned long out = PAGE_CACHE_SIZE; + unsigned long next = *(u32 *) romfs_read(offset); + + if (next > end_data) { + end_data = next; + } + + offset += 4; + if (curr == next) { + if (opt_verbose > 1) { + printf(" hole at %ld (%d)\n", curr, PAGE_CACHE_SIZE); + } + if (size < PAGE_CACHE_SIZE) + out = size; + memset(outbuffer, 0x00, out); + } + else { + if (opt_verbose > 1) { + printf(" uncompressing block at %ld to %ld (%ld)\n", curr, next, next - curr); + } + out = uncompress_block(romfs_read(curr), next - curr); + } + if (size >= PAGE_CACHE_SIZE) { + if (out != PAGE_CACHE_SIZE) { + fprintf(stderr, "%s: Non-block (%ld) bytes\n", filename, out); + exit(4); + } + } else { + if (out != size) { + fprintf(stderr, "%s: Non-size (%ld vs %ld) bytes\n", filename, out, size); + exit(4); + } + } + size -= out; + if (opt_extract) { + write(fd, outbuffer, out); + } + curr = next; + } while (size); +} + +static void expand_fs(int pathlen, char *path, struct cramfs_inode *inode) +{ + if (S_ISDIR(inode->mode)) { + int count = inode->size; + unsigned long offset = inode->offset << 2; + char *newpath = malloc(pathlen + 256); + + if (count > 0 && offset < start_inode) { + start_inode = offset; + } + /* XXX - need to check end_inode for empty case? */ + memcpy(newpath, path, pathlen); + newpath[pathlen] = '/'; + pathlen++; + if (opt_verbose) { + print_node('d', inode, path); + } + if (opt_extract) { + mkdir(path, inode->mode); + change_file_status(path, inode); + } + while (count > 0) { + struct cramfs_inode *child = iget(offset); + int size; + int newlen = child->namelen << 2; + + size = sizeof(struct cramfs_inode) + newlen; + count -= size; + + offset += sizeof(struct cramfs_inode); + + memcpy(newpath + pathlen, romfs_read(offset), newlen); + newpath[pathlen + newlen] = 0; + if ((pathlen + newlen) - strlen(newpath) > 3) { + fprintf(stderr, "%s: invalid cramfs--bad path length\n", filename); + exit(4); + } + expand_fs(strlen(newpath), newpath, child); + + offset += newlen; + + if (offset > end_inode) { + end_inode = offset; + } + } + return; + } + if (S_ISREG(inode->mode)) { + int fd = 0; + unsigned long offset = inode->offset << 2; + + if (offset > 0 && offset < start_data) { + start_data = offset; + } + if (opt_verbose) { + print_node('f', inode, path); + } + if (opt_extract) { + fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, inode->mode); + } + if (inode->size) { + do_uncompress(fd, offset, inode->size); + } + if (opt_extract) { + close(fd); + change_file_status(path, inode); + } + return; + } + if (S_ISLNK(inode->mode)) { + unsigned long offset = inode->offset << 2; + + if (offset < start_data) { + start_data = offset; + } + do_symlink(path, inode); + return; + } + else { + do_special_inode(path, inode); + return; + } +} +#endif /* INCLUDE_FS_TESTS */ + +int main(int argc, char **argv) +{ + void *buf; + size_t length; + struct stat st; + u32 crc_old, crc_new; +#ifdef INCLUDE_FS_TESTS + struct cramfs_inode *root; +#endif /* INCLUDE_FS_TESTS */ + int c; /* for getopt */ + int start = 0; + + if (argc) + progname = argv[0]; + + /* command line options */ + while ((c = getopt(argc, argv, "hx:v")) != EOF) { + switch (c) { + case 'h': + usage(0); + case 'x': +#ifdef INCLUDE_FS_TESTS + opt_extract = 1; + extract_dir = malloc(strlen(optarg) + 1); + strcpy(extract_dir, optarg); + break; +#else /* not INCLUDE_FS_TESTS */ + fprintf(stderr, "%s: compiled without -x support\n", + progname); + exit(16); +#endif /* not INCLUDE_FS_TESTS */ + case 'v': + opt_verbose++; + break; + } + } + + if ((argc - optind) != 1) + usage(16); + filename = argv[optind]; + + /* find the physical size of the file or block device */ + if (lstat(filename, &st) < 0) { + perror(filename); + exit(8); + } + fd = open(filename, O_RDONLY); + if (fd < 0) { + perror(filename); + exit(8); + } + if (S_ISBLK(st.st_mode)) { + if (ioctl(fd, BLKGETSIZE, &length) < 0) { + fprintf(stderr, "%s: warning--unable to determine filesystem size \n", filename); + exit(4); + } + length = length * 512; + } + else if (S_ISREG(st.st_mode)) { + length = st.st_size; + } + else { + fprintf(stderr, "%s is not a block device or file\n", filename); + exit(8); + } + + if (length < sizeof(struct cramfs_super)) { + fprintf(stderr, "%s: invalid cramfs--file length too short\n", filename); + exit(4); + } + + if (S_ISBLK(st.st_mode)) { + /* nasty because mmap of block devices fails */ + buf = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + read(fd, buf, length); + } + else { + /* nice and easy */ + buf = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); + } + + /* XXX - this could be cleaner... */ + if (((struct cramfs_super *) buf)->magic == CRAMFS_MAGIC) { + start = 0; + super = (struct cramfs_super *) buf; + } + else if (length >= (PAD_SIZE + sizeof(struct cramfs_super)) && + ((((struct cramfs_super *) (buf + PAD_SIZE))->magic == CRAMFS_MAGIC))) + { + start = PAD_SIZE; + super = (struct cramfs_super *) (buf + PAD_SIZE); + } + else { + fprintf(stderr, "%s: invalid cramfs--wrong magic\n", filename); + exit(4); + } + + if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) { + /* length test */ + if (length < super->size) { + fprintf(stderr, "%s: invalid cramfs--file length too short\n", filename); + exit(4); + } + else if (length > super->size) { + fprintf(stderr, "%s: warning--file length too long, padded image?\n", filename); + } + + /* CRC test */ + crc_old = super->fsid.crc; + super->fsid.crc = crc32(0L, Z_NULL, 0); + crc_new = crc32(0L, Z_NULL, 0); + crc_new = crc32(crc_new, (unsigned char *) buf+start, super->size - start); + if (crc_new != crc_old) { + fprintf(stderr, "%s: invalid cramfs--crc error\n", filename); + exit(4); + } + } + else { + fprintf(stderr, "%s: warning--old cramfs image, no CRC\n", + filename); + } + +#ifdef INCLUDE_FS_TESTS + super = (struct cramfs_super *) malloc(sizeof(struct cramfs_super)); + if (((struct cramfs_super *) buf)->magic == CRAMFS_MAGIC) { + memcpy(super, buf, sizeof(struct cramfs_super)); + } + else if (length >= (PAD_SIZE + sizeof(struct cramfs_super)) && + ((((struct cramfs_super *) (buf + PAD_SIZE))->magic == CRAMFS_MAGIC))) + { + memcpy(super, (buf + PAD_SIZE), sizeof(struct cramfs_super)); + } + + munmap(buf, length); + + /* file format test, uses fake "blocked" accesses */ + root = read_super(); + umask(0); + euid = geteuid(); + if (!root) { + fprintf(stderr, "%s: invalid cramfs--bad superblock\n", + filename); + exit(4); + } + stream.next_in = NULL; + stream.avail_in = 0; + inflateInit(&stream); + + if (!extract_dir) { + extract_dir = "root"; + } + + expand_fs(strlen(extract_dir), extract_dir, root); + inflateEnd(&stream); + + if (start_data != 1 << 28 && end_inode != start_data) { + fprintf(stderr, "%s: invalid cramfs--directory data end (%ld) != file data start (%ld)\n", filename, end_inode, start_data); + exit(4); + } + if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) { + if (end_data > super->size) { + fprintf(stderr, "%s: invalid cramfs--invalid file data offset\n", filename); + exit(4); + } + } +#endif /* INCLUDE_FS_TESTS */ + + exit(0); +} diff -Nuar linux-xip/scripts/cramfs/mkcramfs.c linux-00/scripts/cramfs/mkcramfs.c --- linux-xip/scripts/cramfs/mkcramfs.c Wed Dec 31 16:00:00 1969 +++ linux-00/scripts/cramfs/mkcramfs.c Tue Apr 22 17:07:58 2003 @@ -0,0 +1,822 @@ +/* + * mkcramfs - make a cramfs file system + * + * Copyright (C) 1999-2001 Transmeta Corporation + * + * This program is free software; 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define PAD_SIZE 512 /* only 0 and 512 supported by kernel */ + +static const char *progname = "mkcramfs"; + +/* N.B. If you change the disk format of cramfs, please update fs/cramfs/README. */ + +/* Input status of 0 to print help and exit without an error. */ +static void usage(int status) +{ + FILE *stream = status ? stderr : stdout; + + fprintf(stream, "usage: %s [-h] [-e edition] [-i file] [-n name] dirname outfile\n" + " -h print this help\n" + " -E make all warnings errors (non-zero exit status)\n" + " -e edition set edition number (part of fsid)\n" + " -i file insert a file image into the filesystem (requires >= 2.4.0)\n" + " -n name set name of cramfs filesystem\n" + " -p pad by %d bytes for boot code\n" + " -s sort directory entries (old option, ignored)\n" + " -x make marked files eXecute In Place\n" + " -z make explicit holes (requires >= 2.3.39)\n" + " dirname root of the filesystem to be compressed\n" + " outfile output file\n", progname, PAD_SIZE); + + exit(status); +} + +#define PAGE_SIZE (4096) +#define PAGE_ALIGN(x) (((x) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)) +#define ROM_OFFSET 0 +#define ROM_ALIGN(x) (PAGE_ALIGN((x) + ROM_OFFSET) - ROM_OFFSET) +#define PAGE_CACHE_SIZE (4096) +/* The kernel assumes PAGE_CACHE_SIZE as block size. */ +static unsigned int blksize = PAGE_CACHE_SIZE; +static long total_blocks = 0, total_nodes = 1; /* pre-count the root node */ +static int image_length = 0; + +/* + * If opt_holes is set, then mkcramfs can create explicit holes in the + * data, which saves 26 bytes per hole (which is a lot smaller a + * saving than most most filesystems). + * + * Note that kernels up to at least 2.3.39 don't support cramfs holes, + * which is why this is turned off by default. + */ +static int opt_edition = 0; +static int opt_errors = 0; +static int opt_holes = 0; +static int opt_xip = 0; +static int opt_pad = 0; +static char *opt_image = NULL; +static char *opt_name = NULL; + +static int warn_dev, warn_gid, warn_namelen, warn_skip, warn_size, warn_uid; + +#ifndef MIN +# define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b)) +#endif + +/* In-core version of inode / directory entry. */ +struct entry { + /* stats */ + char *name; + unsigned int mode, size, uid, gid; + + /* FS data */ + void *uncompressed; + /* points to other identical file */ + struct entry *same; + unsigned int offset; /* pointer to compressed data in archive */ + unsigned int dir_offset; /* Where in the archive is the directory entry? */ + + /* organization */ + struct entry *child; /* null for non-directories and empty directories */ + struct entry *next; +}; + +/* + * The longest file name component to allow for in the input directory tree. + * Ext2fs (and many others) allow up to 255 bytes. A couple of filesystems + * allow longer (e.g. smbfs 1024), but there isn't much use in supporting + * >255-byte names in the input directory tree given that such names get + * truncated to 255 bytes when written to cramfs. + */ +#define MAX_INPUT_NAMELEN 255 + +static int find_identical_file(struct entry *orig,struct entry *newfile) +{ + if(orig==newfile) return 1; + if(!orig) return 0; + if(orig->size==newfile->size && orig->uncompressed && !memcmp(orig->uncompressed,newfile->uncompressed,orig->size)) { + newfile->same=orig; + return 1; + } + return find_identical_file(orig->child,newfile) || + find_identical_file(orig->next,newfile); +} + +static void eliminate_doubles(struct entry *root,struct entry *orig) { + if(orig) { + if(orig->size && orig->uncompressed) + find_identical_file(root,orig); + eliminate_doubles(root,orig->child); + eliminate_doubles(root,orig->next); + } +} + +/* + * We define our own sorting function instead of using alphasort which + * uses strcoll and changes ordering based on locale information. + */ +static int cramsort (const void *a, const void *b) +{ + return strcmp ((*(const struct dirent **) a)->d_name, + (*(const struct dirent **) b)->d_name); +} + +static unsigned int parse_directory(struct entry *root_entry, const char *name, struct entry **prev, loff_t *fslen_ub) +{ + struct dirent **dirlist; + int totalsize = 0, dircount, dirindex; + char *path, *endpath; + size_t len = strlen(name); + + /* Set up the path. */ + /* TODO: Reuse the parent's buffer to save memcpy'ing and duplication. */ + path = malloc(len + 1 + MAX_INPUT_NAMELEN + 1); + if (!path) { + perror(NULL); + exit(8); + } + memcpy(path, name, len); + endpath = path + len; + *endpath = '/'; + endpath++; + + /* read in the directory and sort */ + dircount = scandir(name, &dirlist, 0, cramsort); + + if (dircount < 0) { + perror(name); + exit(8); + } + + /* process directory */ + for (dirindex = 0; dirindex < dircount; dirindex++) { + struct dirent *dirent; + struct entry *entry; + struct stat st; + int size; + size_t namelen; + + dirent = dirlist[dirindex]; + + /* Ignore "." and ".." - we won't be adding them to the archive */ + if (dirent->d_name[0] == '.') { + if (dirent->d_name[1] == '\0') + continue; + if (dirent->d_name[1] == '.') { + if (dirent->d_name[2] == '\0') + continue; + } + } + namelen = strlen(dirent->d_name); + if (namelen > MAX_INPUT_NAMELEN) { + fprintf(stderr, + "Very long (%u bytes) filename `%s' found.\n" + " Please increase MAX_INPUT_NAMELEN in mkcramfs.c and recompile. Exiting.\n", + namelen, dirent->d_name); + exit(8); + } + memcpy(endpath, dirent->d_name, namelen + 1); + + if (lstat(path, &st) < 0) { + perror(endpath); + warn_skip = 1; + continue; + } + entry = calloc(1, sizeof(struct entry)); + if (!entry) { + perror(NULL); + exit(8); + } + entry->name = strdup(dirent->d_name); + if (!entry->name) { + perror(NULL); + exit(8); + } + if (namelen > 255) { + /* Can't happen when reading from ext2fs. */ + + /* TODO: we ought to avoid chopping in half + multi-byte UTF8 characters. */ + entry->name[namelen = 255] = '\0'; + warn_namelen = 1; + } + entry->mode = st.st_mode; + entry->size = st.st_size; + entry->uid = st.st_uid; + if (entry->uid >= 1 << CRAMFS_UID_WIDTH) + warn_uid = 1; + entry->gid = st.st_gid; + if (entry->gid >= 1 << CRAMFS_GID_WIDTH) + /* TODO: We ought to replace with a default + gid instead of truncating; otherwise there + are security problems. Maybe mode should + be &= ~070. Same goes for uid once Linux + supports >16-bit uids. */ + warn_gid = 1; + size = sizeof(struct cramfs_inode) + ((namelen + 3) & ~3); + *fslen_ub += size; + if (S_ISDIR(st.st_mode)) { + entry->size = parse_directory(root_entry, path, &entry->child, fslen_ub); + } else if (S_ISREG(st.st_mode)) { + /* TODO: We ought to open files in do_compress, one + at a time, instead of amassing all these memory + maps during parse_directory (which don't get used + until do_compress anyway). As it is, we tend to + get EMFILE errors (especially if mkcramfs is run + by non-root). + + While we're at it, do analagously for symlinks + (which would just save a little memory). */ + int fd = open(path, O_RDONLY); + if (fd < 0) { + perror(path); + warn_skip = 1; + continue; + } + if (entry->size) { + if ((entry->size >= 1 << CRAMFS_SIZE_WIDTH)) { + warn_size = 1; + entry->size = (1 << CRAMFS_SIZE_WIDTH) - 1; + } + + entry->uncompressed = mmap(NULL, entry->size, PROT_READ, MAP_PRIVATE, fd, 0); + if (-1 == (int) (long) entry->uncompressed) { + perror("mmap"); + exit(8); + } + } + close(fd); + } else if (S_ISLNK(st.st_mode)) { + entry->uncompressed = malloc(entry->size); + if (!entry->uncompressed) { + perror(NULL); + exit(8); + } + if (readlink(path, entry->uncompressed, entry->size) < 0) { + perror(path); + warn_skip = 1; + continue; + } + } else if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) { + /* maybe we should skip sockets */ + entry->size = 0; + } else { + entry->size = st.st_rdev; + if (entry->size & -(1<size - 1) / blksize + 1); + + /* block pointers & data expansion allowance + data */ + if(entry->size) + *fslen_ub += (4+26)*blocks + entry->size + 3; + } + + if (opt_xip && entry->mode & S_ISVTX) { + /* worse case, depending on where the offsets falls, + * a single XIP entry could expand the sizeof the + * file system by 8k, since we're aligning the start + * and end on page boundary. + */ + *fslen_ub += 2*PAGE_CACHE_SIZE; + } + + /* Link it into the list */ + *prev = entry; + prev = &entry->next; + totalsize += size; + } + free(path); + free(dirlist); /* allocated by scandir() with malloc() */ + return totalsize; +} + +/* Returns sizeof(struct cramfs_super), which includes the root inode. */ +static unsigned int write_superblock(struct entry *root, char *base, int size) +{ + struct cramfs_super *super = (struct cramfs_super *) base; + unsigned int offset = sizeof(struct cramfs_super) + image_length; + + if (opt_pad) { + offset += opt_pad; + } + + super->magic = CRAMFS_MAGIC; + super->flags = CRAMFS_FLAG_FSID_VERSION_2 | CRAMFS_FLAG_SORTED_DIRS; + if (opt_holes) + super->flags |= CRAMFS_FLAG_HOLES; + if (image_length > 0) + super->flags |= CRAMFS_FLAG_SHIFTED_ROOT_OFFSET; + super->size = size; + memcpy(super->signature, CRAMFS_SIGNATURE, sizeof(super->signature)); + + super->fsid.crc = crc32(0L, Z_NULL, 0); + super->fsid.edition = opt_edition; + super->fsid.blocks = total_blocks; + super->fsid.files = total_nodes; + + memset(super->name, 0x00, sizeof(super->name)); + if (opt_name) + strncpy(super->name, opt_name, sizeof(super->name)); + else + strncpy(super->name, "Compressed", sizeof(super->name)); + + super->root.mode = root->mode; + super->root.uid = root->uid; + super->root.gid = root->gid; + super->root.size = root->size; + super->root.offset = offset >> 2; + + return offset; +} + +static void set_data_offset(struct entry *entry, char *base, unsigned long offset) +{ + struct cramfs_inode *inode = (struct cramfs_inode *) (base + entry->dir_offset); +#ifdef DEBUG + assert ((offset & 3) == 0); +#endif /* DEBUG */ + if (offset >= (1 << (2 + CRAMFS_OFFSET_WIDTH))) { + fprintf(stderr, "filesystem too big. Exiting.\n"); + exit(8); + } + inode->offset = (offset >> 2); +} + + +/* + * We do a width-first printout of the directory + * entries, using a stack to remember the directories + * we've seen. + */ +#define MAXENTRIES (100) +static unsigned int write_directory_structure(struct entry *entry, char *base, unsigned int offset) +{ + int stack_entries = 0; + struct entry *entry_stack[MAXENTRIES]; + + for (;;) { + int dir_start = stack_entries; + while (entry) { + struct cramfs_inode *inode = (struct cramfs_inode *) (base + offset); + size_t len = strlen(entry->name); + + entry->dir_offset = offset; + + inode->mode = entry->mode; + inode->uid = entry->uid; + inode->gid = entry->gid; + inode->size = entry->size; + inode->offset = 0; + /* Non-empty directories, regfiles and symlinks will + write over inode->offset later. */ + + offset += sizeof(struct cramfs_inode); + total_nodes++; /* another node */ + memcpy(base + offset, entry->name, len); + /* Pad up the name to a 4-byte boundary */ + while (len & 3) { + *(base + offset + len) = '\0'; + len++; + } + inode->namelen = len >> 2; + offset += len; + + /* TODO: this may get it wrong for chars >= 0x80. + Most filesystems use UTF8 encoding for filenames, + whereas the console is a single-byte character + set like iso-latin-1. */ + printf(" %s\n", entry->name); + if (entry->child) { + if (stack_entries >= MAXENTRIES) { + fprintf(stderr, "Exceeded MAXENTRIES. Raise this value in mkcramfs.c and recompile. Exiting.\n"); + exit(8); + } + entry_stack[stack_entries] = entry; + stack_entries++; + } + entry = entry->next; + } + + /* + * Reverse the order the stack entries pushed during + * this directory, for a small optimization of disk + * access in the created fs. This change makes things + * `ls -UR' order. + */ + { + struct entry **lo = entry_stack + dir_start; + struct entry **hi = entry_stack + stack_entries; + struct entry *tmp; + + while (lo < --hi) { + tmp = *lo; + *lo++ = *hi; + *hi = tmp; + } + } + + /* Pop a subdirectory entry from the stack, and recurse. */ + if (!stack_entries) + break; + stack_entries--; + entry = entry_stack[stack_entries]; + + set_data_offset(entry, base, offset); + printf("'%s':\n", entry->name); + entry = entry->child; + } + return offset; +} + +static int is_zero(char const *begin, unsigned len) +{ + if (opt_holes) + /* Returns non-zero iff the first LEN bytes from BEGIN are + all NULs. */ + return (len-- == 0 || + (begin[0] == '\0' && + (len-- == 0 || + (begin[1] == '\0' && + (len-- == 0 || + (begin[2] == '\0' && + (len-- == 0 || + (begin[3] == '\0' && + memcmp(begin, begin + 4, len) == 0)))))))); + else + /* Never create holes. */ + return 0; +} + +static unsigned int do_xip(char *base, unsigned int offset, + char const *name, char *uncompressed, + unsigned int size) +{ + unsigned int start, end; + + /* align to page boundary */ + + start = ROM_ALIGN(offset); + memset(base + offset, 0, start - offset); + + memcpy(base + start, uncompressed, size); + + /* pad to page boundary */ + + end = ROM_ALIGN(start + size); + memset(base + start + size, 0, end - (start + size)); + + printf("XIP (%u+%u bytes)\toffset %u\t%s\n", + size, (end - offset) - size, offset, name); + + return end; +} + + +/* + * One 4-byte pointer per block and then the actual blocked + * output. The first block does not need an offset pointer, + * as it will start immediately after the pointer block; + * so the i'th pointer points to the end of the i'th block + * (i.e. the start of the (i+1)'th block or past EOF). + * + * Note that size > 0, as a zero-sized file wouldn't ever + * have gotten here in the first place. + */ +static unsigned int do_compress(char *base, unsigned int offset, char const *name, char *uncompressed, unsigned int size) +{ + unsigned long original_size = size; + unsigned long original_offset = offset; + unsigned long new_size; + unsigned long blocks = (size - 1) / blksize + 1; + unsigned long curr = offset + 4 * blocks; + int change; + + total_blocks += blocks; + + do { + unsigned long len = 2 * blksize; + unsigned int input = size; + if (input > blksize) + input = blksize; + size -= input; + if (!is_zero (uncompressed, input)) { + compress(base + curr, &len, uncompressed, input); + curr += len; + } + uncompressed += input; + + if (len > blksize*2) { + /* (I don't think this can happen with zlib.) */ + printf("AIEEE: block \"compressed\" to > 2*blocklength (%ld)\n", len); + exit(8); + } + + *(u32 *) (base + offset) = curr; + offset += 4; + } while (size); + + curr = (curr + 3) & ~3; + new_size = curr - original_offset; + /* TODO: Arguably, original_size in these 2 lines should be + st_blocks * 512. But if you say that then perhaps + administrative data should also be included in both. */ + change = new_size - original_size; + printf("%6.2f%% (%+d bytes)\toffset %lu\t%s\n", + (change * 100) / (double) original_size, change, original_offset, name); + + return curr; +} + + +/* + * Traverse the entry tree, writing data for every item that has + * non-null entry->compressed (i.e. every symlink and non-empty + * regfile). + */ +static unsigned int write_data(struct entry *entry, char *base, unsigned int offset) +{ + do { + if (entry->uncompressed) { + if(entry->same) { + set_data_offset(entry, base, entry->same->offset); + entry->offset=entry->same->offset; + } else { + set_data_offset(entry, base, offset); + entry->offset=offset; + if (entry->mode & S_ISVTX) + offset = do_xip(base, offset, entry->name, entry->uncompressed, entry->size); + else + offset = do_compress(base, offset, entry->name, entry->uncompressed, entry->size); + } + } + else if (entry->child) + offset = write_data(entry->child, base, offset); + entry=entry->next; + } while (entry); + return offset; +} + +static unsigned int write_file(char *file, char *base, unsigned int offset) +{ + int fd; + char *buf; + + fd = open(file, O_RDONLY); + if (fd < 0) { + perror(file); + exit(8); + } + buf = mmap(NULL, image_length, PROT_READ, MAP_PRIVATE, fd, 0); + memcpy(base + offset, buf, image_length); + munmap(buf, image_length); + close (fd); + /* Pad up the image_length to a 4-byte boundary */ + while (image_length & 3) { + *(base + offset + image_length) = '\0'; + image_length++; + } + return (offset + image_length); +} + +/* + * Maximum size fs you can create is roughly 256MB. (The last file's + * data must begin within 256MB boundary but can extend beyond that.) + * + * Note that if you want it to fit in a ROM then you're limited to what the + * hardware and kernel can support (64MB?). + */ +#define MAXFSLEN ((((1 << CRAMFS_OFFSET_WIDTH) - 1) << 2) /* offset */ \ + + (1 << CRAMFS_SIZE_WIDTH) - 1 /* filesize */ \ + + (1 << CRAMFS_SIZE_WIDTH) * 4 / PAGE_CACHE_SIZE /* block pointers */ ) + + +/* + * Usage: + * + * mkcramfs directory-name outfile + * + * where "directory-name" is simply the root of the directory + * tree that we want to generate a compressed filesystem out + * of. + */ +int main(int argc, char **argv) +{ + struct stat st; /* used twice... */ + struct entry *root_entry; + char *rom_image; + ssize_t offset, written; + int fd; + /* initial guess (upper-bound) of required filesystem size */ + loff_t fslen_ub = sizeof(struct cramfs_super); + char const *dirname, *outfile; + u32 crc = crc32(0L, Z_NULL, 0); + int c; /* for getopt */ + + total_blocks = 0; + + if (argc) + progname = argv[0]; + + /* command line options */ + while ((c = getopt(argc, argv, "hEe:i:n:psxz")) != EOF) { + switch (c) { + case 'h': + usage(0); + case 'E': + opt_errors = 1; + break; + case 'e': + opt_edition = atoi(optarg); + break; + case 'i': + opt_image = optarg; + if (lstat(opt_image, &st) < 0) { + perror(opt_image); + exit(16); + } + image_length = st.st_size; /* may be padded later */ + fslen_ub += (image_length + 3); /* 3 is for padding */ + break; + case 'n': + opt_name = optarg; + break; + case 'p': + opt_pad = PAD_SIZE; + fslen_ub += PAD_SIZE; + break; + case 's': + /* old option, ignored */ + break; + case 'x': + opt_xip = 1; + break; + case 'z': + opt_holes = 1; + break; + } + } + + if ((argc - optind) != 2) + usage(16); + dirname = argv[optind]; + outfile = argv[optind + 1]; + + if (stat(dirname, &st) < 0) { + perror(dirname); + exit(16); + } + fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666); + + root_entry = calloc(1, sizeof(struct entry)); + if (!root_entry) { + perror(NULL); + exit(8); + } + root_entry->mode = st.st_mode; + root_entry->uid = st.st_uid; + root_entry->gid = st.st_gid; + + root_entry->size = parse_directory(root_entry, dirname, &root_entry->child, &fslen_ub); + + /* always allocate a multiple of blksize bytes because that's + what we're going to write later on */ + fslen_ub = ((fslen_ub - 1) | (blksize - 1)) + 1; + + if (fslen_ub > MAXFSLEN) { + fprintf(stderr, + "warning: guestimate of required size (upper bound) is %LdMB, but maximum image size is %uMB. We might die prematurely.\n", + fslen_ub >> 20, + MAXFSLEN >> 20); + fslen_ub = MAXFSLEN; + } + + /* find duplicate files. TODO: uses the most inefficient algorithm + possible. */ + eliminate_doubles(root_entry,root_entry); + + /* TODO: Why do we use a private/anonymous mapping here + followed by a write below, instead of just a shared mapping + and a couple of ftruncate calls? Is it just to save us + having to deal with removing the file afterwards? If we + really need this huge anonymous mapping, we ought to mmap + in smaller chunks, so that the user doesn't need nn MB of + RAM free. If the reason is to be able to write to + un-mmappable block devices, then we could try shared mmap + and revert to anonymous mmap if the shared mmap fails. */ + rom_image = mmap(NULL, fslen_ub?fslen_ub:1, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + + if (-1 == (int) (long) rom_image) { + perror("ROM image map"); + exit(8); + } + + /* Skip the first opt_pad bytes for boot loader code */ + offset = opt_pad; + memset(rom_image, 0x00, opt_pad); + + /* Skip the superblock and come back to write it later. */ + offset += sizeof(struct cramfs_super); + + /* Insert a file image. */ + if (opt_image) { + printf("Including: %s\n", opt_image); + offset = write_file(opt_image, rom_image, offset); + } + + offset = write_directory_structure(root_entry->child, rom_image, offset); + printf("Directory data: %d bytes\n", offset); + + offset = write_data(root_entry, rom_image, offset); + + /* We always write a multiple of blksize bytes, so that + losetup works. */ + offset = ((offset - 1) | (blksize - 1)) + 1; + printf("Everything: %d kilobytes\n", offset >> 10); + + /* Write the superblock now that we can fill in all of the fields. */ + write_superblock(root_entry, rom_image+opt_pad, offset); + printf("Super block: %d bytes\n", sizeof(struct cramfs_super)); + + /* Put the checksum in. */ + crc = crc32(crc, (rom_image+opt_pad), (offset-opt_pad)); + ((struct cramfs_super *) (rom_image+opt_pad))->fsid.crc = crc; + printf("CRC: %x\n", crc); + + /* Check to make sure we allocated enough space. */ + if (fslen_ub < offset) { + fprintf(stderr, "not enough space allocated for ROM image (%Ld allocated, %d used)\n", + fslen_ub, offset); + exit(8); + } + + written = write(fd, rom_image, offset); + if (written < 0) { + perror("ROM image"); + exit(8); + } + if (offset != written) { + fprintf(stderr, "ROM image write failed (%d %d)\n", written, offset); + exit(8); + } + + /* (These warnings used to come at the start, but they scroll off the + screen too quickly.) */ + if (warn_namelen) /* (can't happen when reading from ext2fs) */ + fprintf(stderr, /* bytes, not chars: think UTF8. */ + "warning: filenames truncated to 255 bytes.\n"); + if (warn_skip) + fprintf(stderr, "warning: files were skipped due to errors.\n"); + if (warn_size) + fprintf(stderr, + "warning: file sizes truncated to %luMB (minus 1 byte).\n", + 1L << (CRAMFS_SIZE_WIDTH - 20)); + if (warn_uid) /* (not possible with current Linux versions) */ + fprintf(stderr, + "warning: uids truncated to %u bits. (This may be a security concern.)\n", + CRAMFS_UID_WIDTH); + if (warn_gid) + fprintf(stderr, + "warning: gids truncated to %u bits. (This may be a security concern.)\n", + CRAMFS_GID_WIDTH); + if (warn_dev) + fprintf(stderr, + "WARNING: device numbers truncated to %u bits. This almost certainly means\n" + "that some device files will be wrong.\n", + CRAMFS_OFFSET_WIDTH); + if (opt_errors && + (warn_namelen||warn_skip||warn_size||warn_uid||warn_gid||warn_dev)) + exit(8); + return 0; +}