[net-next-2.6.git] / init / initramfs.c

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/syscalls.h>
#include <linux/utime.h>

static __initdata char *message;
static void __init error(char *x)
{
	if (!message)
		message = x;
}

/* link hash */

#define N_ALIGN(len) ((((len) + 1) & ~3) + 2)

static __initdata struct hash {
	int ino, minor, major;
	mode_t mode;
	struct hash *next;
	char name[N_ALIGN(PATH_MAX)];
} *head[32];

static inline int hash(int major, int minor, int ino)
{
	unsigned long tmp = ino + minor + (major << 3);
	tmp += tmp >> 5;
	return tmp & 31;
}

static char __init *find_link(int major, int minor, int ino,
			      mode_t mode, char *name)
{
	struct hash **p, *q;
	for (p = head + hash(major, minor, ino); *p; p = &(*p)->next) {
		if ((*p)->ino != ino)
			continue;
		if ((*p)->minor != minor)
			continue;
		if ((*p)->major != major)
			continue;
		if (((*p)->mode ^ mode) & S_IFMT)
			continue;
		return (*p)->name;
	}
	q = kmalloc(sizeof(struct hash), GFP_KERNEL);
	if (!q)
		panic("can't allocate link hash entry");
	q->major = major;
	q->minor = minor;
	q->ino = ino;
	q->mode = mode;
	strcpy(q->name, name);
	q->next = NULL;
	*p = q;
	return NULL;
}

static void __init free_hash(void)
{
	struct hash **p, *q;
	for (p = head; p < head + 32; p++) {
		while (*p) {
			q = *p;
			*p = q->next;
			kfree(q);
		}
	}
}

static long __init do_utime(char __user *filename, time_t mtime)
{
	struct timespec t[2];

	t[0].tv_sec = mtime;
	t[0].tv_nsec = 0;
	t[1].tv_sec = mtime;
	t[1].tv_nsec = 0;

	return do_utimes(AT_FDCWD, filename, t, AT_SYMLINK_NOFOLLOW);
}

static __initdata LIST_HEAD(dir_list);
struct dir_entry {
	struct list_head list;
	char *name;
	time_t mtime;
};

static void __init dir_add(const char *name, time_t mtime)
{
	struct dir_entry *de = kmalloc(sizeof(struct dir_entry), GFP_KERNEL);
	if (!de)
		panic("can't allocate dir_entry buffer");
	INIT_LIST_HEAD(&de->list);
	de->name = kstrdup(name, GFP_KERNEL);
	de->mtime = mtime;
	list_add(&de->list, &dir_list);
}

static void __init dir_utime(void)
{
	struct dir_entry *de, *tmp;
	list_for_each_entry_safe(de, tmp, &dir_list, list) {
		list_del(&de->list);
		do_utime(de->name, de->mtime);
		kfree(de->name);
		kfree(de);
	}
}

static __initdata time_t mtime;

/* cpio header parsing */

static __initdata unsigned long ino, major, minor, nlink;
static __initdata mode_t mode;
static __initdata unsigned long body_len, name_len;
static __initdata uid_t uid;
static __initdata gid_t gid;
static __initdata unsigned rdev;

static void __init parse_header(char *s)
{
	unsigned long parsed[12];
	char buf[9];
	int i;

	buf[8] = '\0';
	for (i = 0, s += 6; i < 12; i++, s += 8) {
		memcpy(buf, s, 8);
		parsed[i] = simple_strtoul(buf, NULL, 16);
	}
	ino = parsed[0];
	mode = parsed[1];
	uid = parsed[2];
	gid = parsed[3];
	nlink = parsed[4];
	mtime = parsed[5];
	body_len = parsed[6];
	major = parsed[7];
	minor = parsed[8];
	rdev = new_encode_dev(MKDEV(parsed[9], parsed[10]));
	name_len = parsed[11];
}

/* FSM */

static __initdata enum state {
	Start,
	Collect,
	GotHeader,
	SkipIt,
	GotName,
	CopyFile,
	GotSymlink,
	Reset
} state, next_state;

static __initdata char *victim;
static __initdata unsigned count;
static __initdata loff_t this_header, next_header;

static __initdata int dry_run;

static inline void __init eat(unsigned n)
{
	victim += n;
	this_header += n;
	count -= n;
}

static __initdata char *vcollected;
static __initdata char *collected;
static __initdata int remains;
static __initdata char *collect;

static void __init read_into(char *buf, unsigned size, enum state next)
{
	if (count >= size) {
		collected = victim;
		eat(size);
		state = next;
	} else {
		collect = collected = buf;
		remains = size;
		next_state = next;
		state = Collect;
	}
}

static __initdata char *header_buf, *symlink_buf, *name_buf;

static int __init do_start(void)
{
	read_into(header_buf, 110, GotHeader);
	return 0;
}

static int __init do_collect(void)
{
	unsigned n = remains;
	if (count < n)
		n = count;
	memcpy(collect, victim, n);
	eat(n);
	collect += n;
	if ((remains -= n) != 0)
		return 1;
	state = next_state;
	return 0;
}

static int __init do_header(void)
{
	if (memcmp(collected, "070707", 6)==0) {
		error("incorrect cpio method used: use -H newc option");
		return 1;
	}
	if (memcmp(collected, "070701", 6)) {
		error("no cpio magic");
		return 1;
	}
	parse_header(collected);
	next_header = this_header + N_ALIGN(name_len) + body_len;
	next_header = (next_header + 3) & ~3;
	if (dry_run) {
		read_into(name_buf, N_ALIGN(name_len), GotName);
		return 0;
	}
	state = SkipIt;
	if (name_len <= 0 || name_len > PATH_MAX)
		return 0;
	if (S_ISLNK(mode)) {
		if (body_len > PATH_MAX)
			return 0;
		collect = collected = symlink_buf;
		remains = N_ALIGN(name_len) + body_len;
		next_state = GotSymlink;
		state = Collect;
		return 0;
	}
	if (S_ISREG(mode) || !body_len)
		read_into(name_buf, N_ALIGN(name_len), GotName);
	return 0;
}

static int __init do_skip(void)
{
	if (this_header + count < next_header) {
		eat(count);
		return 1;
	} else {
		eat(next_header - this_header);
		state = next_state;
		return 0;
	}
}

static int __init do_reset(void)
{
	while(count && *victim == '\0')
		eat(1);
	if (count && (this_header & 3))
		error("broken padding");
	return 1;
}

static int __init maybe_link(void)
{
	if (nlink >= 2) {
		char *old = find_link(major, minor, ino, mode, collected);
		if (old)
			return (sys_link(old, collected) < 0) ? -1 : 1;
	}
	return 0;
}

static void __init clean_path(char *path, mode_t mode)
{
	struct stat st;

	if (!sys_newlstat(path, &st) && (st.st_mode^mode) & S_IFMT) {
		if (S_ISDIR(st.st_mode))
			sys_rmdir(path);
		else
			sys_unlink(path);
	}
}

static __initdata int wfd;

static int __init do_name(void)
{
	state = SkipIt;
	next_state = Reset;
	if (strcmp(collected, "TRAILER!!!") == 0) {
		free_hash();
		return 0;
	}
	if (dry_run)
		return 0;
	clean_path(collected, mode);
	if (S_ISREG(mode)) {
		int ml = maybe_link();
		if (ml >= 0) {
			int openflags = O_WRONLY|O_CREAT;
			if (ml != 1)
				openflags |= O_TRUNC;
			wfd = sys_open(collected, openflags, mode);

			if (wfd >= 0) {
				sys_fchown(wfd, uid, gid);
				sys_fchmod(wfd, mode);
				vcollected = kstrdup(collected, GFP_KERNEL);
				state = CopyFile;
			}
		}
	} else if (S_ISDIR(mode)) {
		sys_mkdir(collected, mode);
		sys_chown(collected, uid, gid);
		sys_chmod(collected, mode);
		dir_add(collected, mtime);
	} else if (S_ISBLK(mode) || S_ISCHR(mode) ||
		   S_ISFIFO(mode) || S_ISSOCK(mode)) {
		if (maybe_link() == 0) {
			sys_mknod(collected, mode, rdev);
			sys_chown(collected, uid, gid);
			sys_chmod(collected, mode);
			do_utime(collected, mtime);
		}
	}
	return 0;
}

static int __init do_copy(void)
{
	if (count >= body_len) {
		sys_write(wfd, victim, body_len);
		sys_close(wfd);
		do_utime(vcollected, mtime);
		kfree(vcollected);
		eat(body_len);
		state = SkipIt;
		return 0;
	} else {
		sys_write(wfd, victim, count);
		body_len -= count;
		eat(count);
		return 1;
	}
}

static int __init do_symlink(void)
{
	collected[N_ALIGN(name_len) + body_len] = '\0';
	clean_path(collected, 0);
	sys_symlink(collected + N_ALIGN(name_len), collected);
	sys_lchown(collected, uid, gid);
	do_utime(collected, mtime);
	state = SkipIt;
	next_state = Reset;
	return 0;
}

static __initdata int (*actions[])(void) = {
	[Start]		= do_start,
	[Collect]	= do_collect,
	[GotHeader]	= do_header,
	[SkipIt]	= do_skip,
	[GotName]	= do_name,
	[CopyFile]	= do_copy,
	[GotSymlink]	= do_symlink,
	[Reset]		= do_reset,
};

static int __init write_buffer(char *buf, unsigned len)
{
	count = len;
	victim = buf;

	while (!actions[state]())
		;
	return len - count;
}

#if defined CONFIG_RD_GZIP || defined CONFIG_RD_BZIP2 || defined CONFIG_RD_LZMA
static int __init flush_buffer(void *bufv, unsigned len)
{
	char *buf = (char *) bufv;
	int written;
	int origLen = len;
	if (message)
		return -1;
	while ((written = write_buffer(buf, len)) < len && !message) {
		char c = buf[written];
		if (c == '0') {
			buf += written;
			len -= written;
			state = Start;
		} else if (c == 0) {
			buf += written;
			len -= written;
			state = Reset;
		} else
			error("junk in compressed archive");
	}
	return origLen;
}
#endif

static unsigned my_inptr;   /* index of next byte to be processed in inbuf */

#include <linux/decompress/bunzip2.h>
#include <linux/decompress/unlzma.h>
#include <linux/decompress/inflate.h>

static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)
{
	int written;
	dry_run = check_only;
	header_buf = kmalloc(110, GFP_KERNEL);
	symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);
	name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);

	if (!header_buf || !symlink_buf || !name_buf)
		panic("can't allocate buffers");

	state = Start;
	this_header = 0;
	message = NULL;
	while (!message && len) {
		loff_t saved_offset = this_header;
		if (*buf == '0' && !(this_header & 3)) {
			state = Start;
			written = write_buffer(buf, len);
			buf += written;
			len -= written;
			continue;
		}
		if (!*buf) {
			buf++;
			len--;
			this_header++;
			continue;
		}
		this_header = 0;
#ifdef CONFIG_RD_GZIP
		if (!gunzip(buf, len, NULL, flush_buffer, NULL,
			    &my_inptr, error) &&
		    message == NULL)
			goto ok;
#endif

#ifdef CONFIG_RD_BZIP2
		message = NULL; /* Zero out message, or else cpio will
				   think an error has already occured */
		if (!bunzip2(buf, len, NULL, flush_buffer, NULL,
			     &my_inptr, error) &&
		    message == NULL) {
			goto ok;
		}
#endif

#ifdef CONFIG_RD_LZMA
		message = NULL; /* Zero out message, or else cpio will
				   think an error has already occured */
		if (!unlzma(buf, len, NULL, flush_buffer, NULL,
			    &my_inptr, error) &&
		    message == NULL) {
			goto ok;
		}
#endif
#if defined CONFIG_RD_GZIP || defined CONFIG_RD_BZIP2 || defined CONFIG_RD_LZMA
ok:
#endif
		if (state != Reset)
			error("junk in compressed archive");
		this_header = saved_offset + my_inptr;
		buf += my_inptr;
		len -= my_inptr;
	}
	dir_utime();
	kfree(name_buf);
	kfree(symlink_buf);
	kfree(header_buf);
	return message;
}

static int __initdata do_retain_initrd;

static int __init retain_initrd_param(char *str)
{
	if (*str)
		return 0;
	do_retain_initrd = 1;
	return 1;
}
__setup("retain_initrd", retain_initrd_param);

extern char __initramfs_start[], __initramfs_end[];
#include <linux/initrd.h>
#include <linux/kexec.h>

static void __init free_initrd(void)
{
#ifdef CONFIG_KEXEC
	unsigned long crashk_start = (unsigned long)__va(crashk_res.start);
	unsigned long crashk_end   = (unsigned long)__va(crashk_res.end);
#endif
	if (do_retain_initrd)
		goto skip;

#ifdef CONFIG_KEXEC
	/*
	 * If the initrd region is overlapped with crashkernel reserved region,
	 * free only memory that is not part of crashkernel region.
	 */
	if (initrd_start < crashk_end && initrd_end > crashk_start) {
		/*
		 * Initialize initrd memory region since the kexec boot does
		 * not do.
		 */
		memset((void *)initrd_start, 0, initrd_end - initrd_start);
		if (initrd_start < crashk_start)
			free_initrd_mem(initrd_start, crashk_start);
		if (initrd_end > crashk_end)
			free_initrd_mem(crashk_end, initrd_end);
	} else
#endif
		free_initrd_mem(initrd_start, initrd_end);
skip:
	initrd_start = 0;
	initrd_end = 0;
}

static int __init populate_rootfs(void)
{
	char *err = unpack_to_rootfs(__initramfs_start,
			 __initramfs_end - __initramfs_start, 0);
	if (err)
		panic(err);
	if (initrd_start) {
#ifdef CONFIG_BLK_DEV_RAM
		int fd;
		printk(KERN_INFO "checking if image is initramfs...");
		err = unpack_to_rootfs((char *)initrd_start,
			initrd_end - initrd_start, 1);
		if (!err) {
			printk(" it is\n");
			unpack_to_rootfs((char *)initrd_start,
				initrd_end - initrd_start, 0);
			free_initrd();
			return 0;
		}
		printk("it isn't (%s); looks like an initrd\n", err);
		fd = sys_open("/initrd.image", O_WRONLY|O_CREAT, 0700);
		if (fd >= 0) {
			sys_write(fd, (char *)initrd_start,
					initrd_end - initrd_start);
			sys_close(fd);
			free_initrd();
		}
#else
		printk(KERN_INFO "Unpacking initramfs...");
		err = unpack_to_rootfs((char *)initrd_start,
			initrd_end - initrd_start, 0);
		if (err)
			panic(err);
		printk(" done\n");
		free_initrd();
#endif
	}
	return 0;
}
rootfs_initcall(populate_rootfs);
Commit	Line	Data
1da177e4 LT	1	#include <linux/init.h>
	2	#include <linux/fs.h>
	3	#include <linux/slab.h>
	4	#include <linux/types.h>
	5	#include <linux/fcntl.h>
	6	#include <linux/delay.h>
	7	#include <linux/string.h>
	8	#include <linux/syscalls.h>
889d51a1	9	#include <linux/utime.h>
1da177e4 LT	10
	11	static __initdata char *message;
	12	static void __init error(char *x)
	13	{
	14	if (!message)
	15	message = x;
	16	}
	17
1da177e4 LT	18	/* link hash */
1da177e4 LT	19
6a050da4 MH	20	#define N_ALIGN(len) ((((len) + 1) & ~3) + 2)
6a050da4 MH	21
1da177e4 LT	22	static __initdata struct hash {
1da177e4 LT	23	int ino, minor, major;
2139a7fb	24	mode_t mode;
1da177e4	25	struct hash *next;
6a050da4	26	char name[N_ALIGN(PATH_MAX)];
1da177e4 LT	27	} *head[32];
	28
	29	static inline int hash(int major, int minor, int ino)
	30	{
	31	unsigned long tmp = ino + minor + (major << 3);
	32	tmp += tmp >> 5;
	33	return tmp & 31;
	34	}
	35
2139a7fb PA	36	static char __init *find_link(int major, int minor, int ino,
2139a7fb PA	37	mode_t mode, char *name)
1da177e4 LT	38	{
	39	struct hash *p, q;
	40	for (p = head + hash(major, minor, ino); p; p = &(p)->next) {
	41	if ((*p)->ino != ino)
	42	continue;
	43	if ((*p)->minor != minor)
	44	continue;
	45	if ((*p)->major != major)
	46	continue;
2139a7fb PA	47	if (((*p)->mode ^ mode) & S_IFMT)
2139a7fb PA	48	continue;
1da177e4 LT	49	return (*p)->name;
1da177e4 LT	50	}
3265e66b	51	q = kmalloc(sizeof(struct hash), GFP_KERNEL);
1da177e4 LT	52	if (!q)
1da177e4 LT	53	panic("can't allocate link hash entry");
1da177e4	54	q->major = major;
2139a7fb PA	55	q->minor = minor;
	56	q->ino = ino;
	57	q->mode = mode;
6a050da4	58	strcpy(q->name, name);
1da177e4 LT	59	q->next = NULL;
	60	*p = q;
	61	return NULL;
	62	}
	63
	64	static void __init free_hash(void)
	65	{
	66	struct hash *p, q;
	67	for (p = head; p < head + 32; p++) {
	68	while (*p) {
	69	q = *p;
	70	*p = q->next;
3265e66b	71	kfree(q);
1da177e4 LT	72	}
	73	}
	74	}
	75
889d51a1 NL	76	static long __init do_utime(char __user *filename, time_t mtime)
	77	{
	78	struct timespec t[2];
	79
	80	t[0].tv_sec = mtime;
	81	t[0].tv_nsec = 0;
	82	t[1].tv_sec = mtime;
	83	t[1].tv_nsec = 0;
	84
	85	return do_utimes(AT_FDCWD, filename, t, AT_SYMLINK_NOFOLLOW);
	86	}
	87
	88	static __initdata LIST_HEAD(dir_list);
	89	struct dir_entry {
	90	struct list_head list;
	91	char *name;
	92	time_t mtime;
	93	};
	94
	95	static void __init dir_add(const char *name, time_t mtime)
	96	{
	97	struct dir_entry *de = kmalloc(sizeof(struct dir_entry), GFP_KERNEL);
	98	if (!de)
	99	panic("can't allocate dir_entry buffer");
	100	INIT_LIST_HEAD(&de->list);
	101	de->name = kstrdup(name, GFP_KERNEL);
	102	de->mtime = mtime;
	103	list_add(&de->list, &dir_list);
	104	}
	105
	106	static void __init dir_utime(void)
	107	{
	108	struct dir_entry de, tmp;
	109	list_for_each_entry_safe(de, tmp, &dir_list, list) {
	110	list_del(&de->list);
	111	do_utime(de->name, de->mtime);
	112	kfree(de->name);
	113	kfree(de);
	114	}
	115	}
	116
	117	static __initdata time_t mtime;
	118
1da177e4 LT	119	/* cpio header parsing */
	120
	121	static __initdata unsigned long ino, major, minor, nlink;
	122	static __initdata mode_t mode;
	123	static __initdata unsigned long body_len, name_len;
	124	static __initdata uid_t uid;
	125	static __initdata gid_t gid;
	126	static __initdata unsigned rdev;
	127
	128	static void __init parse_header(char *s)
	129	{
	130	unsigned long parsed[12];
	131	char buf[9];
	132	int i;
	133
	134	buf[8] = '\0';
	135	for (i = 0, s += 6; i < 12; i++, s += 8) {
	136	memcpy(buf, s, 8);
	137	parsed[i] = simple_strtoul(buf, NULL, 16);
	138	}
	139	ino = parsed[0];
	140	mode = parsed[1];
	141	uid = parsed[2];
	142	gid = parsed[3];
	143	nlink = parsed[4];
889d51a1	144	mtime = parsed[5];
1da177e4 LT	145	body_len = parsed[6];
	146	major = parsed[7];
	147	minor = parsed[8];
	148	rdev = new_encode_dev(MKDEV(parsed[9], parsed[10]));
	149	name_len = parsed[11];
	150	}
	151
	152	/* FSM */
	153
	154	static __initdata enum state {
	155	Start,
	156	Collect,
	157	GotHeader,
	158	SkipIt,
	159	GotName,
	160	CopyFile,
	161	GotSymlink,
	162	Reset
	163	} state, next_state;
	164
	165	static __initdata char *victim;
	166	static __initdata unsigned count;
	167	static __initdata loff_t this_header, next_header;
	168
	169	static __initdata int dry_run;
	170
b0a5ab93	171	static inline void __init eat(unsigned n)
1da177e4 LT	172	{
	173	victim += n;
	174	this_header += n;
	175	count -= n;
	176	}
	177
889d51a1	178	static __initdata char *vcollected;
1da177e4 LT	179	static __initdata char *collected;
	180	static __initdata int remains;
	181	static __initdata char *collect;
	182
	183	static void __init read_into(char *buf, unsigned size, enum state next)
	184	{
	185	if (count >= size) {
	186	collected = victim;
	187	eat(size);
	188	state = next;
	189	} else {
	190	collect = collected = buf;
	191	remains = size;
	192	next_state = next;
	193	state = Collect;
	194	}
	195	}
	196
	197	static __initdata char header_buf, symlink_buf, *name_buf;
	198
	199	static int __init do_start(void)
	200	{
	201	read_into(header_buf, 110, GotHeader);
	202	return 0;
	203	}
	204
	205	static int __init do_collect(void)
	206	{
	207	unsigned n = remains;
	208	if (count < n)
	209	n = count;
	210	memcpy(collect, victim, n);
	211	eat(n);
	212	collect += n;
	213	if ((remains -= n) != 0)
	214	return 1;
	215	state = next_state;
	216	return 0;
	217	}
	218
	219	static int __init do_header(void)
	220	{
2e591bbc AV	221	if (memcmp(collected, "070707", 6)==0) {
	222	error("incorrect cpio method used: use -H newc option");
	223	return 1;
	224	}
1da177e4 LT	225	if (memcmp(collected, "070701", 6)) {
	226	error("no cpio magic");
	227	return 1;
	228	}
	229	parse_header(collected);
	230	next_header = this_header + N_ALIGN(name_len) + body_len;
	231	next_header = (next_header + 3) & ~3;
	232	if (dry_run) {
	233	read_into(name_buf, N_ALIGN(name_len), GotName);
	234	return 0;
	235	}
	236	state = SkipIt;
	237	if (name_len <= 0 \|\| name_len > PATH_MAX)
	238	return 0;
	239	if (S_ISLNK(mode)) {
	240	if (body_len > PATH_MAX)
	241	return 0;
	242	collect = collected = symlink_buf;
	243	remains = N_ALIGN(name_len) + body_len;
	244	next_state = GotSymlink;
	245	state = Collect;
	246	return 0;
	247	}
	248	if (S_ISREG(mode) \|\| !body_len)
	249	read_into(name_buf, N_ALIGN(name_len), GotName);
	250	return 0;
	251	}
	252
	253	static int __init do_skip(void)
	254	{
	255	if (this_header + count < next_header) {
	256	eat(count);
	257	return 1;
	258	} else {
	259	eat(next_header - this_header);
	260	state = next_state;
	261	return 0;
	262	}
	263	}
	264
	265	static int __init do_reset(void)
	266	{
	267	while(count && *victim == '\0')
	268	eat(1);
	269	if (count && (this_header & 3))
	270	error("broken padding");
	271	return 1;
	272	}
	273
	274	static int __init maybe_link(void)
	275	{
	276	if (nlink >= 2) {
2139a7fb	277	char *old = find_link(major, minor, ino, mode, collected);
1da177e4 LT	278	if (old)
	279	return (sys_link(old, collected) < 0) ? -1 : 1;
	280	}
	281	return 0;
	282	}
	283
2139a7fb PA	284	static void __init clean_path(char *path, mode_t mode)
	285	{
	286	struct stat st;
	287
	288	if (!sys_newlstat(path, &st) && (st.st_mode^mode) & S_IFMT) {
	289	if (S_ISDIR(st.st_mode))
	290	sys_rmdir(path);
	291	else
	292	sys_unlink(path);
	293	}
	294	}
	295
1da177e4 LT	296	static __initdata int wfd;
	297
	298	static int __init do_name(void)
	299	{
	300	state = SkipIt;
	301	next_state = Reset;
	302	if (strcmp(collected, "TRAILER!!!") == 0) {
	303	free_hash();
	304	return 0;
	305	}
	306	if (dry_run)
	307	return 0;
2139a7fb	308	clean_path(collected, mode);
1da177e4	309	if (S_ISREG(mode)) {
2139a7fb PA	310	int ml = maybe_link();
	311	if (ml >= 0) {
	312	int openflags = O_WRONLY\|O_CREAT;
	313	if (ml != 1)
	314	openflags \|= O_TRUNC;
	315	wfd = sys_open(collected, openflags, mode);
	316
1da177e4 LT	317	if (wfd >= 0) {
	318	sys_fchown(wfd, uid, gid);
	319	sys_fchmod(wfd, mode);
889d51a1	320	vcollected = kstrdup(collected, GFP_KERNEL);
1da177e4 LT	321	state = CopyFile;
	322	}
	323	}
	324	} else if (S_ISDIR(mode)) {
	325	sys_mkdir(collected, mode);
	326	sys_chown(collected, uid, gid);
	327	sys_chmod(collected, mode);
889d51a1	328	dir_add(collected, mtime);
1da177e4 LT	329	} else if (S_ISBLK(mode) \|\| S_ISCHR(mode) \|\|
	330	S_ISFIFO(mode) \|\| S_ISSOCK(mode)) {
	331	if (maybe_link() == 0) {
	332	sys_mknod(collected, mode, rdev);
	333	sys_chown(collected, uid, gid);
	334	sys_chmod(collected, mode);
889d51a1	335	do_utime(collected, mtime);
1da177e4 LT	336	}
	337	}
	338	return 0;
	339	}
	340
	341	static int __init do_copy(void)
	342	{
	343	if (count >= body_len) {
	344	sys_write(wfd, victim, body_len);
	345	sys_close(wfd);
889d51a1 NL	346	do_utime(vcollected, mtime);
889d51a1 NL	347	kfree(vcollected);
1da177e4 LT	348	eat(body_len);
	349	state = SkipIt;
	350	return 0;
	351	} else {
	352	sys_write(wfd, victim, count);
	353	body_len -= count;
	354	eat(count);
	355	return 1;
	356	}
	357	}
	358
	359	static int __init do_symlink(void)
	360	{
	361	collected[N_ALIGN(name_len) + body_len] = '\0';
2139a7fb	362	clean_path(collected, 0);
1da177e4 LT	363	sys_symlink(collected + N_ALIGN(name_len), collected);
1da177e4 LT	364	sys_lchown(collected, uid, gid);
889d51a1	365	do_utime(collected, mtime);
1da177e4 LT	366	state = SkipIt;
	367	next_state = Reset;
	368	return 0;
	369	}
	370
	371	static __initdata int (*actions[])(void) = {
	372	[Start] = do_start,
	373	[Collect] = do_collect,
	374	[GotHeader] = do_header,
	375	[SkipIt] = do_skip,
	376	[GotName] = do_name,
	377	[CopyFile] = do_copy,
	378	[GotSymlink] = do_symlink,
	379	[Reset] = do_reset,
	380	};
	381
	382	static int __init write_buffer(char *buf, unsigned len)
	383	{
	384	count = len;
	385	victim = buf;
	386
	387	while (!actions[state]())
	388	;
	389	return len - count;
	390	}
	391
a26ee60f	392	#if defined CONFIG_RD_GZIP \|\| defined CONFIG_RD_BZIP2 \|\| defined CONFIG_RD_LZMA
30d65dbf	393	static int __init flush_buffer(void *bufv, unsigned len)
1da177e4	394	{
30d65dbf	395	char buf = (char ) bufv;
1da177e4	396	int written;
30d65dbf	397	int origLen = len;
1da177e4	398	if (message)
30d65dbf	399	return -1;
1da177e4 LT	400	while ((written = write_buffer(buf, len)) < len && !message) {
	401	char c = buf[written];
	402	if (c == '0') {
	403	buf += written;
	404	len -= written;
	405	state = Start;
	406	} else if (c == 0) {
	407	buf += written;
	408	len -= written;
	409	state = Reset;
	410	} else
	411	error("junk in compressed archive");
	412	}
30d65dbf	413	return origLen;
1da177e4	414	}
a26ee60f	415	#endif
1da177e4	416
30d65dbf	417	static unsigned my_inptr; /* index of next byte to be processed in inbuf */
1da177e4	418
30d65dbf AK	419	#include <linux/decompress/bunzip2.h>
	420	#include <linux/decompress/unlzma.h>
	421	#include <linux/decompress/inflate.h>
1da177e4 LT	422
	423	static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)
	424	{
	425	int written;
	426	dry_run = check_only;
3265e66b TP	427	header_buf = kmalloc(110, GFP_KERNEL);
	428	symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL);
	429	name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL);
30d65dbf AK	430
30d65dbf AK	431	if (!header_buf \|\| !symlink_buf \|\| !name_buf)
1da177e4	432	panic("can't allocate buffers");
30d65dbf	433
1da177e4 LT	434	state = Start;
	435	this_header = 0;
	436	message = NULL;
	437	while (!message && len) {
	438	loff_t saved_offset = this_header;
	439	if (*buf == '0' && !(this_header & 3)) {
	440	state = Start;
	441	written = write_buffer(buf, len);
	442	buf += written;
	443	len -= written;
	444	continue;
	445	}
	446	if (!*buf) {
	447	buf++;
	448	len--;
	449	this_header++;
	450	continue;
	451	}
	452	this_header = 0;
a26ee60f	453	#ifdef CONFIG_RD_GZIP
30d65dbf AK	454	if (!gunzip(buf, len, NULL, flush_buffer, NULL,
	455	&my_inptr, error) &&
	456	message == NULL)
	457	goto ok;
a26ee60f	458	#endif
30d65dbf AK	459
	460	#ifdef CONFIG_RD_BZIP2
	461	message = NULL; /* Zero out message, or else cpio will
	462	think an error has already occured */
	463	if (!bunzip2(buf, len, NULL, flush_buffer, NULL,
	464	&my_inptr, error) &&
	465	message == NULL) {
	466	goto ok;
	467	}
	468	#endif
	469
	470	#ifdef CONFIG_RD_LZMA
	471	message = NULL; /* Zero out message, or else cpio will
	472	think an error has already occured */
	473	if (!unlzma(buf, len, NULL, flush_buffer, NULL,
	474	&my_inptr, error) &&
	475	message == NULL) {
	476	goto ok;
	477	}
	478	#endif
a26ee60f	479	#if defined CONFIG_RD_GZIP \|\| defined CONFIG_RD_BZIP2 \|\| defined CONFIG_RD_LZMA
30d65dbf	480	ok:
a26ee60f	481	#endif
1da177e4	482	if (state != Reset)
30d65dbf AK	483	error("junk in compressed archive");
	484	this_header = saved_offset + my_inptr;
	485	buf += my_inptr;
	486	len -= my_inptr;
1da177e4	487	}
889d51a1	488	dir_utime();
3265e66b TP	489	kfree(name_buf);
	490	kfree(symlink_buf);
	491	kfree(header_buf);
1da177e4 LT	492	return message;
	493	}
	494
0a7b35cb MN	495	static int __initdata do_retain_initrd;
	496
	497	static int __init retain_initrd_param(char *str)
	498	{
	499	if (*str)
	500	return 0;
	501	do_retain_initrd = 1;
	502	return 1;
	503	}
	504	__setup("retain_initrd", retain_initrd_param);
	505
1da177e4	506	extern char __initramfs_start[], __initramfs_end[];
1da177e4	507	#include <linux/initrd.h>
9c15e852	508	#include <linux/kexec.h>
0f3d2bd5 JB	509
	510	static void __init free_initrd(void)
	511	{
9c15e852 HM	512	#ifdef CONFIG_KEXEC
	513	unsigned long crashk_start = (unsigned long)__va(crashk_res.start);
	514	unsigned long crashk_end = (unsigned long)__va(crashk_res.end);
0a7b35cb MN	515	#endif
	516	if (do_retain_initrd)
	517	goto skip;
9c15e852	518
0a7b35cb	519	#ifdef CONFIG_KEXEC
9c15e852 HM	520	/*
	521	* If the initrd region is overlapped with crashkernel reserved region,
	522	* free only memory that is not part of crashkernel region.
	523	*/
	524	if (initrd_start < crashk_end && initrd_end > crashk_start) {
	525	/*
	526	* Initialize initrd memory region since the kexec boot does
	527	* not do.
	528	*/
	529	memset((void *)initrd_start, 0, initrd_end - initrd_start);
	530	if (initrd_start < crashk_start)
	531	free_initrd_mem(initrd_start, crashk_start);
	532	if (initrd_end > crashk_end)
	533	free_initrd_mem(crashk_end, initrd_end);
	534	} else
	535	#endif
	536	free_initrd_mem(initrd_start, initrd_end);
0a7b35cb	537	skip:
0f3d2bd5 JB	538	initrd_start = 0;
	539	initrd_end = 0;
	540	}
	541
9a9e0d68	542	static int __init populate_rootfs(void)
1da177e4 LT	543	{
	544	char *err = unpack_to_rootfs(__initramfs_start,
	545	__initramfs_end - __initramfs_start, 0);
	546	if (err)
	547	panic(err);
1da177e4	548	if (initrd_start) {
340e48e6	549	#ifdef CONFIG_BLK_DEV_RAM
1da177e4 LT	550	int fd;
	551	printk(KERN_INFO "checking if image is initramfs...");
	552	err = unpack_to_rootfs((char *)initrd_start,
	553	initrd_end - initrd_start, 1);
	554	if (!err) {
	555	printk(" it is\n");
	556	unpack_to_rootfs((char *)initrd_start,
	557	initrd_end - initrd_start, 0);
0f3d2bd5	558	free_initrd();
8d610dd5	559	return 0;
1da177e4 LT	560	}
1da177e4 LT	561	printk("it isn't (%s); looks like an initrd\n", err);
33644c5e	562	fd = sys_open("/initrd.image", O_WRONLY\|O_CREAT, 0700);
1da177e4 LT	563	if (fd >= 0) {
	564	sys_write(fd, (char *)initrd_start,
	565	initrd_end - initrd_start);
	566	sys_close(fd);
0f3d2bd5	567	free_initrd();
1da177e4	568	}
340e48e6 ZP	569	#else
	570	printk(KERN_INFO "Unpacking initramfs...");
	571	err = unpack_to_rootfs((char *)initrd_start,
	572	initrd_end - initrd_start, 0);
	573	if (err)
	574	panic(err);
	575	printk(" done\n");
	576	free_initrd();
	577	#endif
1da177e4	578	}
8d610dd5	579	return 0;
1da177e4	580	}
8d610dd5	581	rootfs_initcall(populate_rootfs);