initramfs.c 14.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6 7 8 9 10 11
/*
 * 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

Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15 16 17 18
#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>
19
#include <linux/dirent.h>
Linus Torvalds's avatar
Linus Torvalds committed
20
#include <linux/syscalls.h>
21
#include <linux/utime.h>
22
#include <linux/file.h>
Linus Torvalds's avatar
Linus Torvalds committed
23

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
static ssize_t __init xwrite(int fd, const char *p, size_t count)
{
	ssize_t out = 0;

	/* sys_write only can write MAX_RW_COUNT aka 2G-4K bytes at most */
	while (count) {
		ssize_t rv = sys_write(fd, p, count);

		if (rv < 0) {
			if (rv == -EINTR || rv == -EAGAIN)
				continue;
			return out ? out : rv;
		} else if (rv == 0)
			break;

		p += rv;
		out += rv;
		count -= rv;
	}

	return out;
}

Linus Torvalds's avatar
Linus Torvalds committed
47 48 49 50 51 52 53 54 55
static __initdata char *message;
static void __init error(char *x)
{
	if (!message)
		message = x;
}

/* link hash */

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

Linus Torvalds's avatar
Linus Torvalds committed
58 59
static __initdata struct hash {
	int ino, minor, major;
60
	umode_t mode;
Linus Torvalds's avatar
Linus Torvalds committed
61
	struct hash *next;
62
	char name[N_ALIGN(PATH_MAX)];
Linus Torvalds's avatar
Linus Torvalds committed
63 64 65 66 67 68 69 70 71
} *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;
}

72
static char __init *find_link(int major, int minor, int ino,
73
			      umode_t mode, char *name)
Linus Torvalds's avatar
Linus Torvalds committed
74 75 76 77 78 79 80 81 82
{
	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;
83 84
		if (((*p)->mode ^ mode) & S_IFMT)
			continue;
Linus Torvalds's avatar
Linus Torvalds committed
85 86
		return (*p)->name;
	}
87
	q = kmalloc(sizeof(struct hash), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
88 89 90
	if (!q)
		panic("can't allocate link hash entry");
	q->major = major;
91 92 93
	q->minor = minor;
	q->ino = ino;
	q->mode = mode;
94
	strcpy(q->name, name);
Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98 99 100 101 102 103 104 105 106
	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;
107
			kfree(q);
Linus Torvalds's avatar
Linus Torvalds committed
108 109 110 111
		}
	}
}

112
static long __init do_utime(char *filename, time64_t mtime)
113
{
114
	struct timespec64 t[2];
115 116 117 118 119 120 121 122 123 124 125 126 127

	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;
128
	time64_t mtime;
129 130
};

131
static void __init dir_add(const char *name, time64_t mtime)
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
{
	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);
	}
}

153
static __initdata time64_t mtime;
154

Linus Torvalds's avatar
Linus Torvalds committed
155 156 157
/* cpio header parsing */

static __initdata unsigned long ino, major, minor, nlink;
158
static __initdata umode_t mode;
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
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];
180
	mtime = parsed[5]; /* breaks in y2106 */
Linus Torvalds's avatar
Linus Torvalds committed
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
	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;
202
static unsigned long byte_count __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
203 204
static __initdata loff_t this_header, next_header;

Al Viro's avatar
Al Viro committed
205
static inline void __init eat(unsigned n)
Linus Torvalds's avatar
Linus Torvalds committed
206 207 208
{
	victim += n;
	this_header += n;
209
	byte_count -= n;
Linus Torvalds's avatar
Linus Torvalds committed
210 211
}

212
static __initdata char *vcollected;
Linus Torvalds's avatar
Linus Torvalds committed
213
static __initdata char *collected;
214
static long remains __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
215 216 217 218
static __initdata char *collect;

static void __init read_into(char *buf, unsigned size, enum state next)
{
219
	if (byte_count >= size) {
Linus Torvalds's avatar
Linus Torvalds committed
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
		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)
{
241
	unsigned long n = remains;
242 243
	if (byte_count < n)
		n = byte_count;
Linus Torvalds's avatar
Linus Torvalds committed
244 245 246 247 248 249 250 251 252 253 254
	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)
{
255 256 257 258
	if (memcmp(collected, "070707", 6)==0) {
		error("incorrect cpio method used: use -H newc option");
		return 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
	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)
{
285 286
	if (this_header + byte_count < next_header) {
		eat(byte_count);
Linus Torvalds's avatar
Linus Torvalds committed
287 288 289 290 291 292 293 294 295 296
		return 1;
	} else {
		eat(next_header - this_header);
		state = next_state;
		return 0;
	}
}

static int __init do_reset(void)
{
297
	while (byte_count && *victim == '\0')
Linus Torvalds's avatar
Linus Torvalds committed
298
		eat(1);
299
	if (byte_count && (this_header & 3))
Linus Torvalds's avatar
Linus Torvalds committed
300 301 302 303 304 305 306
		error("broken padding");
	return 1;
}

static int __init maybe_link(void)
{
	if (nlink >= 2) {
307
		char *old = find_link(major, minor, ino, mode, collected);
Linus Torvalds's avatar
Linus Torvalds committed
308 309 310 311 312 313
		if (old)
			return (sys_link(old, collected) < 0) ? -1 : 1;
	}
	return 0;
}

314
static void __init clean_path(char *path, umode_t fmode)
315
{
316
	struct kstat st;
317

318 319
	if (!vfs_lstat(path, &st) && (st.mode ^ fmode) & S_IFMT) {
		if (S_ISDIR(st.mode))
320 321 322 323 324 325
			sys_rmdir(path);
		else
			sys_unlink(path);
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
326 327 328 329 330 331 332 333 334 335
static __initdata int wfd;

static int __init do_name(void)
{
	state = SkipIt;
	next_state = Reset;
	if (strcmp(collected, "TRAILER!!!") == 0) {
		free_hash();
		return 0;
	}
336
	clean_path(collected, mode);
Linus Torvalds's avatar
Linus Torvalds committed
337
	if (S_ISREG(mode)) {
338 339 340 341 342 343 344
		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);

Linus Torvalds's avatar
Linus Torvalds committed
345 346 347
			if (wfd >= 0) {
				sys_fchown(wfd, uid, gid);
				sys_fchmod(wfd, mode);
348 349
				if (body_len)
					sys_ftruncate(wfd, body_len);
350
				vcollected = kstrdup(collected, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354 355 356 357
				state = CopyFile;
			}
		}
	} else if (S_ISDIR(mode)) {
		sys_mkdir(collected, mode);
		sys_chown(collected, uid, gid);
		sys_chmod(collected, mode);
358
		dir_add(collected, mtime);
Linus Torvalds's avatar
Linus Torvalds committed
359 360 361 362 363 364
	} 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);
365
			do_utime(collected, mtime);
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370 371 372
		}
	}
	return 0;
}

static int __init do_copy(void)
{
373
	if (byte_count >= body_len) {
374 375
		if (xwrite(wfd, victim, body_len) != body_len)
			error("write error");
Linus Torvalds's avatar
Linus Torvalds committed
376
		sys_close(wfd);
377 378
		do_utime(vcollected, mtime);
		kfree(vcollected);
Linus Torvalds's avatar
Linus Torvalds committed
379 380 381 382
		eat(body_len);
		state = SkipIt;
		return 0;
	} else {
383
		if (xwrite(wfd, victim, byte_count) != byte_count)
384
			error("write error");
385 386
		body_len -= byte_count;
		eat(byte_count);
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390 391 392 393
		return 1;
	}
}

static int __init do_symlink(void)
{
	collected[N_ALIGN(name_len) + body_len] = '\0';
394
	clean_path(collected, 0);
Linus Torvalds's avatar
Linus Torvalds committed
395 396
	sys_symlink(collected + N_ALIGN(name_len), collected);
	sys_lchown(collected, uid, gid);
397
	do_utime(collected, mtime);
Linus Torvalds's avatar
Linus Torvalds committed
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
	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,
};

414
static long __init write_buffer(char *buf, unsigned long len)
Linus Torvalds's avatar
Linus Torvalds committed
415
{
416
	byte_count = len;
Linus Torvalds's avatar
Linus Torvalds committed
417 418 419 420
	victim = buf;

	while (!actions[state]())
		;
421
	return len - byte_count;
Linus Torvalds's avatar
Linus Torvalds committed
422 423
}

424
static long __init flush_buffer(void *bufv, unsigned long len)
Linus Torvalds's avatar
Linus Torvalds committed
425
{
426
	char *buf = (char *) bufv;
427 428
	long written;
	long origLen = len;
Linus Torvalds's avatar
Linus Torvalds committed
429
	if (message)
430
		return -1;
Linus Torvalds's avatar
Linus Torvalds committed
431 432 433 434 435 436 437 438 439 440 441 442 443
	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");
	}
444
	return origLen;
Linus Torvalds's avatar
Linus Torvalds committed
445 446
}

447
static unsigned long my_inptr; /* index of next byte to be processed in inbuf */
Linus Torvalds's avatar
Linus Torvalds committed
448

449
#include <linux/decompress/generic.h>
Linus Torvalds's avatar
Linus Torvalds committed
450

451
static char * __init unpack_to_rootfs(char *buf, unsigned long len)
Linus Torvalds's avatar
Linus Torvalds committed
452
{
453
	long written;
454
	decompress_fn decompress;
455 456
	const char *compress_name;
	static __initdata char msg_buf[64];
457

458 459 460
	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);
461 462

	if (!header_buf || !symlink_buf || !name_buf)
Linus Torvalds's avatar
Linus Torvalds committed
463
		panic("can't allocate buffers");
464

Linus Torvalds's avatar
Linus Torvalds committed
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
	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;
484
		decompress = decompress_method(buf, len, &compress_name);
485
		pr_debug("Detected %s compressed data\n", compress_name);
486
		if (decompress) {
487
			int res = decompress(buf, len, NULL, flush_buffer, NULL,
488
				   &my_inptr, error);
489 490 491
			if (res)
				error("decompressor failed");
		} else if (compress_name) {
492 493 494 495 496 497
			if (!message) {
				snprintf(msg_buf, sizeof msg_buf,
					 "compression method %s not configured",
					 compress_name);
				message = msg_buf;
			}
498 499
		} else
			error("junk in compressed archive");
Linus Torvalds's avatar
Linus Torvalds committed
500
		if (state != Reset)
501 502 503 504
			error("junk in compressed archive");
		this_header = saved_offset + my_inptr;
		buf += my_inptr;
		len -= my_inptr;
Linus Torvalds's avatar
Linus Torvalds committed
505
	}
506
	dir_utime();
507 508 509
	kfree(name_buf);
	kfree(symlink_buf);
	kfree(header_buf);
Linus Torvalds's avatar
Linus Torvalds committed
510 511 512
	return message;
}

513 514 515 516 517 518 519 520 521 522 523
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);

524 525
extern char __initramfs_start[];
extern unsigned long __initramfs_size;
Linus Torvalds's avatar
Linus Torvalds committed
526
#include <linux/initrd.h>
527
#include <linux/kexec.h>
528 529 530

static void __init free_initrd(void)
{
531
#ifdef CONFIG_KEXEC_CORE
532 533
	unsigned long crashk_start = (unsigned long)__va(crashk_res.start);
	unsigned long crashk_end   = (unsigned long)__va(crashk_res.end);
534 535 536
#endif
	if (do_retain_initrd)
		goto skip;
537

538
#ifdef CONFIG_KEXEC_CORE
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
	/*
	 * 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);
556
skip:
557 558 559 560
	initrd_start = 0;
	initrd_end = 0;
}

561
#ifdef CONFIG_BLK_DEV_RAM
562 563 564 565 566 567
#define BUF_SIZE 1024
static void __init clean_rootfs(void)
{
	int fd;
	void *buf;
	struct linux_dirent64 *dirp;
568
	int num;
569

570
	fd = sys_open("/", O_RDONLY, 0);
571 572 573 574 575 576 577 578 579 580 581
	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;
582 583 584
	num = sys_getdents64(fd, dirp, BUF_SIZE);
	while (num > 0) {
		while (num > 0) {
585
			struct kstat st;
586 587
			int ret;

588
			ret = vfs_lstat(dirp->d_name, &st);
589 590
			WARN_ON_ONCE(ret);
			if (!ret) {
591
				if (S_ISDIR(st.mode))
592 593 594 595 596
					sys_rmdir(dirp->d_name);
				else
					sys_unlink(dirp->d_name);
			}

597
			num -= dirp->d_reclen;
598 599 600 601
			dirp = (void *)dirp + dirp->d_reclen;
		}
		dirp = buf;
		memset(buf, 0, BUF_SIZE);
602
		num = sys_getdents64(fd, dirp, BUF_SIZE);
603 604 605 606 607
	}

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

610
static int __init populate_rootfs(void)
Linus Torvalds's avatar
Linus Torvalds committed
611
{
612
	/* Load the built in initramfs */
613
	char *err = unpack_to_rootfs(__initramfs_start, __initramfs_size);
Linus Torvalds's avatar
Linus Torvalds committed
614
	if (err)
615
		panic("%s", err); /* Failed to decompress INTERNAL initramfs */
616
	/* If available load the bootloader supplied initrd */
617
	if (initrd_start && !IS_ENABLED(CONFIG_INITRAMFS_FORCE)) {
618
#ifdef CONFIG_BLK_DEV_RAM
Linus Torvalds's avatar
Linus Torvalds committed
619
		int fd;
620
		printk(KERN_INFO "Trying to unpack rootfs image as initramfs...\n");
Linus Torvalds's avatar
Linus Torvalds committed
621
		err = unpack_to_rootfs((char *)initrd_start,
622
			initrd_end - initrd_start);
Linus Torvalds's avatar
Linus Torvalds committed
623
		if (!err) {
624
			free_initrd();
625
			goto done;
626 627
		} else {
			clean_rootfs();
628
			unpack_to_rootfs(__initramfs_start, __initramfs_size);
Linus Torvalds's avatar
Linus Torvalds committed
629
		}
630 631
		printk(KERN_INFO "rootfs image is not initramfs (%s)"
				"; looks like an initrd\n", err);
632
		fd = sys_open("/initrd.image",
633
			      O_WRONLY|O_CREAT, 0700);
Linus Torvalds's avatar
Linus Torvalds committed
634
		if (fd >= 0) {
635 636 637 638 639 640 641
			ssize_t written = xwrite(fd, (char *)initrd_start,
						initrd_end - initrd_start);

			if (written != initrd_end - initrd_start)
				pr_err("/initrd.image: incomplete write (%zd != %ld)\n",
				       written, initrd_end - initrd_start);

Linus Torvalds's avatar
Linus Torvalds committed
642
			sys_close(fd);
643
			free_initrd();
Linus Torvalds's avatar
Linus Torvalds committed
644
		}
645
	done:
646
		/* empty statement */;
647
#else
648
		printk(KERN_INFO "Unpacking initramfs...\n");
649
		err = unpack_to_rootfs((char *)initrd_start,
650
			initrd_end - initrd_start);
651 652
		if (err)
			printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err);
653 654
		free_initrd();
#endif
Linus Torvalds's avatar
Linus Torvalds committed
655
	}
656 657 658 659 660 661 662
	flush_delayed_fput();
	/*
	 * Try loading default modules from initramfs.  This gives
	 * us a chance to load before device_initcalls.
	 */
	load_default_modules();

663
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
664
}
665
rootfs_initcall(populate_rootfs);