[GitHub/mt8127/android_kernel_alcatel_ttab.git] / init / initramfs.c

/*
 * Many of the syscalls used in this file expect some of the arguments
 * to be __user pointers not __kernel pointers.  To limit the sparse
 * noise, turn off sparse checking for this file.
 */
#ifdef __CHECKER__
#undef __CHECKER__
#warning "Sparse checking disabled for this file"
#endif

#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/dirent.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;
	umode_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,
			      umode_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 *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 umode_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 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;
	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, umode_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;
	}
	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);
				if (body_len)
					sys_ftruncate(wfd, body_len);
				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;
}

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;
}

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

#include <linux/decompress/generic.h>

static char * __init unpack_to_rootfs(char *buf, unsigned len)
{
	int written, res;
	decompress_fn decompress;
	const char *compress_name;
	static __initdata char msg_buf[64];

	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;
		decompress = decompress_method(buf, len, &compress_name);
		if (decompress) {
			res = decompress(buf, len, NULL, flush_buffer, NULL,
				   &my_inptr, error);
			if (res)
				error("decompressor failed");
		} else if (compress_name) {
			if (!message) {
				snprintf(msg_buf, sizeof msg_buf,
					 "compression method %s not configured",
					 compress_name);
				message = msg_buf;
			}
		} else
			error("junk in compressed archive");
		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[];
extern unsigned long __initramfs_size;
#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;
}

#ifdef CONFIG_BLK_DEV_RAM
#define BUF_SIZE 1024
static void __init clean_rootfs(void)
{
	int fd;
	void *buf;
	struct linux_dirent64 *dirp;
	int num;

	fd = sys_open("/", O_RDONLY, 0);
	WARN_ON(fd < 0);
	if (fd < 0)
		return;
	buf = kzalloc(BUF_SIZE, GFP_KERNEL);
	WARN_ON(!buf);
	if (!buf) {
		sys_close(fd);
		return;
	}

	dirp = buf;
	num = sys_getdents64(fd, dirp, BUF_SIZE);
	while (num > 0) {
		while (num > 0) {
			struct stat st;
			int ret;

			ret = sys_newlstat(dirp->d_name, &st);
			WARN_ON_ONCE(ret);
			if (!ret) {
				if (S_ISDIR(st.st_mode))
					sys_rmdir(dirp->d_name);
				else
					sys_unlink(dirp->d_name);
			}

			num -= dirp->d_reclen;
			dirp = (void *)dirp + dirp->d_reclen;
		}
		dirp = buf;
		memset(buf, 0, BUF_SIZE);
		num = sys_getdents64(fd, dirp, BUF_SIZE);
	}

	sys_close(fd);
	kfree(buf);
}
#endif

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