/* * mkcramfs - make a cramfs file system * * Copyright (C) 1999-2002 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 *//* * If you change the disk format of cramfs, please update fs/cramfs/README. */#include <sys/types.h>#include <stdio.h>#include <sys/stat.h>#include <unistd.h>#include <sys/mman.h>#include <fcntl.h>#include <dirent.h>#include <stdlib.h>#include <errno.h>#include <string.h>#include <stdarg.h>#include <linux/cramfs_fs.h>#include <zlib.h>/* Exit codes used by mkfs-type programs */#define MKFS_OK          0	/* No errors */#define MKFS_ERROR       8	/* Operational error */#define MKFS_USAGE       16	/* Usage or syntax error *//* The kernel only supports PAD_SIZE of 0 and 512. */#define PAD_SIZE 512/* The kernel assumes PAGE_CACHE_SIZE as block size. */#define PAGE_CACHE_SIZE (4096)/* * The longest filename 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 CRAMFS_MAXPATHLEN (252 bytes) when written to cramfs. * * Old versions of mkcramfs generated corrupted filesystems if any input * filenames exceeded CRAMFS_MAXPATHLEN (252 bytes), however old * versions of cramfsck seem to have been able to detect the corruption. */#define MAX_INPUT_NAMELEN 255/* * 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. */#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 */ )static const char *progname = "mkcramfs";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. * * If opt_verbose is 1, be verbose.  If it is higher, be even more verbose. */static u32 opt_edition = 0;static int opt_errors = 0;static int opt_holes = 0;static int opt_pad = 0;static int opt_verbose = 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;/* In-core version of inode / directory entry. */struct entry {	/* stats */	unsigned char *name;	unsigned int mode, size, uid, gid;	/* these are only used for non-empty files */	char *path;		/* always null except non-empty files */	int fd;			/* temporarily open files while mmapped */	/* 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;};/* 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"		" -v         be more verbose\n"		" -z         make explicit holes (requires >= 2.3.39)\n"		" dirname    root of the directory tree to be compressed\n"		" outfile    output file\n", progname, PAD_SIZE);	exit(status);}static void die(int status, int syserr, const char *fmt, ...){	va_list arg_ptr;	int save = errno;	fflush(0);	va_start(arg_ptr, fmt);	fprintf(stderr, "%s: ", progname);	vfprintf(stderr, fmt, arg_ptr);	if (syserr) {		fprintf(stderr, ": %s", strerror(save));	}	fprintf(stderr, "\n");	va_end(arg_ptr);	exit(status);}static void map_entry(struct entry *entry){	if (entry->path) {		entry->fd = open(entry->path, O_RDONLY);		if (entry->fd < 0) {			die(MKFS_ERROR, 1, "open failed: %s", entry->path);		}		entry->uncompressed = mmap(NULL, entry->size, PROT_READ, MAP_PRIVATE, entry->fd, 0);		if (entry->uncompressed == MAP_FAILED) {			die(MKFS_ERROR, 1, "mmap failed: %s", entry->path);		}	}}static void unmap_entry(struct entry *entry){	if (entry->path) {		if (munmap(entry->uncompressed, entry->size) < 0) {			die(MKFS_ERROR, 1, "munmap failed: %s", entry->path);		}		close(entry->fd);	}}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->path || orig->uncompressed))	{		map_entry(orig);		map_entry(newfile);		if (!memcmp(orig->uncompressed, newfile->uncompressed, orig->size))		{			newfile->same = orig;			unmap_entry(newfile);			unmap_entry(orig);			return 1;		}		unmap_entry(newfile);		unmap_entry(orig);	}	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->path || 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) {		die(MKFS_ERROR, 1, "malloc failed");	}	memcpy(path, name, len);	endpath = path + len;	*endpath = '/';	endpath++;	/* read in the directory and sort */	dircount = scandir(name, &dirlist, 0, cramsort);	if (dircount < 0) {		die(MKFS_ERROR, 1, "scandir failed: %s", name);	}	/* 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) {			die(MKFS_ERROR, 0,				"very long (%u bytes) filename found: %s\n"				"please increase MAX_INPUT_NAMELEN in mkcramfs.c and recompile",				namelen, dirent->d_name);		}		memcpy(endpath, dirent->d_name, namelen + 1);		if (lstat(path, &st) < 0) {			warn_skip = 1;			continue;		}		entry = calloc(1, sizeof(struct entry));		if (!entry) {			die(MKFS_ERROR, 1, "calloc failed");		}		entry->name = strdup(dirent->d_name);		if (!entry->name) {			die(MKFS_ERROR, 1, "strdup failed");		}		/* truncate multi-byte UTF-8 filenames on character boundary */		if (namelen > CRAMFS_MAXPATHLEN) {			namelen = CRAMFS_MAXPATHLEN;			warn_namelen = 1;			/* the first lost byte must not be a trail byte */			while ((entry->name[namelen] & 0xc0) == 0x80) {				namelen--;				/* are we reasonably certain it was UTF-8 ? */				if (entry->name[namelen] < 0x80 || !namelen) {					die(MKFS_ERROR, 0, "cannot truncate filenames not encoded in UTF-8");				}			}			entry->name[namelen] = '\0';		}		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)) {			if (entry->size) {				if (access(path, R_OK) < 0) {					warn_skip = 1;					continue;				}				entry->path = strdup(path);				if (!entry->path) {					die(MKFS_ERROR, 1, "strdup failed");				}				if ((entry->size >= 1 << CRAMFS_SIZE_WIDTH)) {					warn_size = 1;					entry->size = (1 << CRAMFS_SIZE_WIDTH) - 1;				}			}		} else if (S_ISLNK(st.st_mode)) {			entry->uncompressed = malloc(entry->size);			if (!entry->uncompressed) {				die(MKFS_ERROR, 1, "malloc failed");			}			if (readlink(path, entry->uncompressed, entry->size) < 0) {				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 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {			entry->size = st.st_rdev;			if (entry->size & -(1<<CRAMFS_SIZE_WIDTH))				warn_dev = 1;		} else {			die(MKFS_ERROR, 0, "bogus file type: %s", entry->name);		}		if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {			int blocks = ((entry->size - 1) / blksize + 1);			/* block pointers & data expansion allowance + data */			if (entry->size)				*fslen_ub += (4+26)*blocks + entry->size + 3;		}		/* 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;	offset += opt_pad;	/* 0 if no padding */	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);	if ((offset & 3) != 0) {		die(MKFS_ERROR, 0, "illegal offset of %lu bytes", offset);	}	if (offset >= (1 << (2 + CRAMFS_OFFSET_WIDTH))) {		die(MKFS_ERROR, 0, "filesystem too big");	}	inode->offset = (offset >> 2);}/* * TODO: Does this work for chars >= 0x80?  Most filesystems use UTF-8 * encoding for filenames, whereas the console is a single-byte * character set like iso-latin-1. */static void print_node(struct entry *e){	char info[10];	char type = '?';	if (S_ISREG(e->mode)) type = 'f';	else if (S_ISDIR(e->mode)) type = 'd';	else if (S_ISLNK(e->mode)) type = 'l';	else if (S_ISCHR(e->mode)) type = 'c';	else if (S_ISBLK(e->mode)) type = 'b';	else if (S_ISFIFO(e->mode)) type = 'p';