initramfs.c 14.8 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8
#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>
9
#include <linux/dirent.h>
Linus Torvalds's avatar
Linus Torvalds committed
10
#include <linux/syscalls.h>
11
#include <linux/utime.h>
12
#include <linux/file.h>
13
#include <linux/memblock.h>
Linus Torvalds's avatar
Linus Torvalds committed
14

15 16 17 18 19 20
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) {
21
		ssize_t rv = ksys_write(fd, p, count);
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

		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
38 39 40 41 42 43 44 45 46
static __initdata char *message;
static void __init error(char *x)
{
	if (!message)
		message = x;
}

/* link hash */

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

Linus Torvalds's avatar
Linus Torvalds committed
49 50
static __initdata struct hash {
	int ino, minor, major;
Al Viro's avatar
Al Viro committed
51
	umode_t mode;
Linus Torvalds's avatar
Linus Torvalds committed
52
	struct hash *next;
53
	char name[N_ALIGN(PATH_MAX)];
Linus Torvalds's avatar
Linus Torvalds committed
54 55 56 57 58 59 60 61 62
} *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;
}

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

103
static long __init do_utime(char *filename, time64_t mtime)
104
{
105
	struct timespec64 t[2];
106 107 108 109 110 111 112 113 114 115 116 117 118

	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;
119
	time64_t mtime;
120 121
};

122
static void __init dir_add(const char *name, time64_t mtime)
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
{
	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);
	}
}

144
static __initdata time64_t mtime;
145

Linus Torvalds's avatar
Linus Torvalds committed
146 147 148
/* cpio header parsing */

static __initdata unsigned long ino, major, minor, nlink;
Al Viro's avatar
Al Viro committed
149
static __initdata umode_t mode;
Linus Torvalds's avatar
Linus Torvalds committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
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];
171
	mtime = parsed[5]; /* breaks in y2106 */
Linus Torvalds's avatar
Linus Torvalds committed
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
	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;
193
static unsigned long byte_count __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
194 195
static __initdata loff_t this_header, next_header;

Al Viro's avatar
Al Viro committed
196
static inline void __init eat(unsigned n)
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199
{
	victim += n;
	this_header += n;
200
	byte_count -= n;
Linus Torvalds's avatar
Linus Torvalds committed
201 202
}

203
static __initdata char *vcollected;
Linus Torvalds's avatar
Linus Torvalds committed
204
static __initdata char *collected;
205
static long remains __initdata;
Linus Torvalds's avatar
Linus Torvalds committed
206 207 208 209
static __initdata char *collect;

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

static int __init do_reset(void)
{
288
	while (byte_count && *victim == '\0')
Linus Torvalds's avatar
Linus Torvalds committed
289
		eat(1);
290
	if (byte_count && (this_header & 3))
Linus Torvalds's avatar
Linus Torvalds committed
291 292 293 294
		error("broken padding");
	return 1;
}

295
static void __init clean_path(char *path, umode_t fmode)
296
{
297
	struct kstat st;
298

299 300
	if (!vfs_lstat(path, &st) && (st.mode ^ fmode) & S_IFMT) {
		if (S_ISDIR(st.mode))
301
			ksys_rmdir(path);
302
		else
303
			ksys_unlink(path);
304 305 306
	}
}

307 308 309 310 311 312 313 314 315 316 317 318
static int __init maybe_link(void)
{
	if (nlink >= 2) {
		char *old = find_link(major, minor, ino, mode, collected);
		if (old) {
			clean_path(collected, 0);
			return (ksys_link(old, collected) < 0) ? -1 : 1;
		}
	}
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
319 320 321 322 323 324 325 326 327 328
static __initdata int wfd;

static int __init do_name(void)
{
	state = SkipIt;
	next_state = Reset;
	if (strcmp(collected, "TRAILER!!!") == 0) {
		free_hash();
		return 0;
	}
329
	clean_path(collected, mode);
Linus Torvalds's avatar
Linus Torvalds committed
330
	if (S_ISREG(mode)) {
331 332 333 334 335
		int ml = maybe_link();
		if (ml >= 0) {
			int openflags = O_WRONLY|O_CREAT;
			if (ml != 1)
				openflags |= O_TRUNC;
336
			wfd = ksys_open(collected, openflags, mode);
337

Linus Torvalds's avatar
Linus Torvalds committed
338
			if (wfd >= 0) {
339
				ksys_fchown(wfd, uid, gid);
340
				ksys_fchmod(wfd, mode);
341
				if (body_len)
342
					ksys_ftruncate(wfd, body_len);
343
				vcollected = kstrdup(collected, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346 347
				state = CopyFile;
			}
		}
	} else if (S_ISDIR(mode)) {
348
		ksys_mkdir(collected, mode);
349
		ksys_chown(collected, uid, gid);
350
		ksys_chmod(collected, mode);
351
		dir_add(collected, mtime);
Linus Torvalds's avatar
Linus Torvalds committed
352 353 354
	} else if (S_ISBLK(mode) || S_ISCHR(mode) ||
		   S_ISFIFO(mode) || S_ISSOCK(mode)) {
		if (maybe_link() == 0) {
355
			ksys_mknod(collected, mode, rdev);
356
			ksys_chown(collected, uid, gid);
357
			ksys_chmod(collected, mode);
358
			do_utime(collected, mtime);
Linus Torvalds's avatar
Linus Torvalds committed
359 360 361 362 363 364 365
		}
	}
	return 0;
}

static int __init do_copy(void)
{
366
	if (byte_count >= body_len) {
367 368
		if (xwrite(wfd, victim, body_len) != body_len)
			error("write error");
369
		ksys_close(wfd);
370 371
		do_utime(vcollected, mtime);
		kfree(vcollected);
Linus Torvalds's avatar
Linus Torvalds committed
372 373 374 375
		eat(body_len);
		state = SkipIt;
		return 0;
	} else {
376
		if (xwrite(wfd, victim, byte_count) != byte_count)
377
			error("write error");
378 379
		body_len -= byte_count;
		eat(byte_count);
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384 385 386
		return 1;
	}
}

static int __init do_symlink(void)
{
	collected[N_ALIGN(name_len) + body_len] = '\0';
387
	clean_path(collected, 0);
388
	ksys_symlink(collected + N_ALIGN(name_len), collected);
389
	ksys_lchown(collected, uid, gid);
390
	do_utime(collected, mtime);
Linus Torvalds's avatar
Linus Torvalds committed
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
	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,
};

407
static long __init write_buffer(char *buf, unsigned long len)
Linus Torvalds's avatar
Linus Torvalds committed
408
{
409
	byte_count = len;
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413
	victim = buf;

	while (!actions[state]())
		;
414
	return len - byte_count;
Linus Torvalds's avatar
Linus Torvalds committed
415 416
}

417
static long __init flush_buffer(void *bufv, unsigned long len)
Linus Torvalds's avatar
Linus Torvalds committed
418
{
419
	char *buf = (char *) bufv;
420 421
	long written;
	long origLen = len;
Linus Torvalds's avatar
Linus Torvalds committed
422
	if (message)
423
		return -1;
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426 427 428 429 430 431 432 433 434
	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
435
			error("junk within compressed archive");
Linus Torvalds's avatar
Linus Torvalds committed
436
	}
437
	return origLen;
Linus Torvalds's avatar
Linus Torvalds committed
438 439
}

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

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

444
static char * __init unpack_to_rootfs(char *buf, unsigned long len)
Linus Torvalds's avatar
Linus Torvalds committed
445
{
446
	long written;
447
	decompress_fn decompress;
448 449
	const char *compress_name;
	static __initdata char msg_buf[64];
450

451 452 453
	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);
454 455

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

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

506 507 508 509 510 511 512 513 514 515 516
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);

517 518 519 520 521 522 523 524 525
#ifdef CONFIG_ARCH_HAS_KEEPINITRD
static int __init keepinitrd_setup(char *__unused)
{
	do_retain_initrd = 1;
	return 1;
}
__setup("keepinitrd", keepinitrd_setup);
#endif

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

531 532
void __weak free_initrd_mem(unsigned long start, unsigned long end)
{
533 534 535 536 537 538 539
#ifdef CONFIG_ARCH_KEEP_MEMBLOCK
	unsigned long aligned_start = ALIGN_DOWN(start, PAGE_SIZE);
	unsigned long aligned_end = ALIGN(end, PAGE_SIZE);

	memblock_free(__pa(aligned_start), aligned_end - aligned_start);
#endif

540 541
	free_reserved_area((void *)start, (void *)end, POISON_FREE_INITMEM,
			"initrd");
542 543
}

544
#ifdef CONFIG_KEXEC_CORE
545 546
static bool kexec_free_initrd(void)
{
547 548 549 550 551 552 553
	unsigned long crashk_start = (unsigned long)__va(crashk_res.start);
	unsigned long crashk_end   = (unsigned long)__va(crashk_res.end);

	/*
	 * If the initrd region is overlapped with crashkernel reserved region,
	 * free only memory that is not part of crashkernel region.
	 */
554 555 556 557 558 559 560 561 562 563 564 565
	if (initrd_start >= crashk_end || initrd_end <= crashk_start)
		return false;

	/*
	 * 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);
	return true;
566
}
567 568 569 570 571 572
#else
static inline bool kexec_free_initrd(void)
{
	return false;
}
#endif /* CONFIG_KEXEC_CORE */
573

574
#ifdef CONFIG_BLK_DEV_RAM
575 576 577 578 579 580
#define BUF_SIZE 1024
static void __init clean_rootfs(void)
{
	int fd;
	void *buf;
	struct linux_dirent64 *dirp;
581
	int num;
582

583
	fd = ksys_open("/", O_RDONLY, 0);
584 585 586 587 588 589
	WARN_ON(fd < 0);
	if (fd < 0)
		return;
	buf = kzalloc(BUF_SIZE, GFP_KERNEL);
	WARN_ON(!buf);
	if (!buf) {
590
		ksys_close(fd);
591 592 593 594
		return;
	}

	dirp = buf;
595
	num = ksys_getdents64(fd, dirp, BUF_SIZE);
596 597
	while (num > 0) {
		while (num > 0) {
598
			struct kstat st;
599 600
			int ret;

601
			ret = vfs_lstat(dirp->d_name, &st);
602 603
			WARN_ON_ONCE(ret);
			if (!ret) {
604
				if (S_ISDIR(st.mode))
605
					ksys_rmdir(dirp->d_name);
606
				else
607
					ksys_unlink(dirp->d_name);
608 609
			}

610
			num -= dirp->d_reclen;
611 612 613 614
			dirp = (void *)dirp + dirp->d_reclen;
		}
		dirp = buf;
		memset(buf, 0, BUF_SIZE);
615
		num = ksys_getdents64(fd, dirp, BUF_SIZE);
616 617
	}

618
	ksys_close(fd);
619 620
	kfree(buf);
}
621 622 623 624 625
#else
static inline void clean_rootfs(void)
{
}
#endif /* CONFIG_BLK_DEV_RAM */
626

627
#ifdef CONFIG_BLK_DEV_RAM
628
static void __init populate_initrd_image(char *err)
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
{
	ssize_t written;
	int fd;

	unpack_to_rootfs(__initramfs_start, __initramfs_size);

	printk(KERN_INFO "rootfs image is not initramfs (%s); looks like an initrd\n",
			err);
	fd = ksys_open("/initrd.image", O_WRONLY | O_CREAT, 0700);
	if (fd < 0)
		return;

	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);
	ksys_close(fd);
}
647
#else
648
static void __init populate_initrd_image(char *err)
649 650 651
{
	printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err);
}
652 653
#endif /* CONFIG_BLK_DEV_RAM */

Guillaume Tucker's avatar
Guillaume Tucker committed
654 655
/* Some random comment here to create a new git base - v28 */

656
static int __init populate_rootfs(void)
Linus Torvalds's avatar
Linus Torvalds committed
657
{
658
	/* Load the built in initramfs */
659
	char *err = unpack_to_rootfs(__initramfs_start, __initramfs_size);
Linus Torvalds's avatar
Linus Torvalds committed
660
	if (err)
661
		panic("%s", err); /* Failed to decompress INTERNAL initramfs */
662

663 664 665 666 667
#if 1 /* Noise to test the kernelci automatic bisection */
	printk(KERN_EMERG "*** Random lines from the Zen of Python ***\n");
	printk(KERN_EMERG "Simple is better than complex.\n");
#endif

668 669 670 671
	if (!initrd_start || IS_ENABLED(CONFIG_INITRAMFS_FORCE))
		goto done;

	if (IS_ENABLED(CONFIG_BLK_DEV_RAM))
672
		printk(KERN_INFO "Trying to unpack rootfs image as initramfs...\n");
673 674
	else
		printk(KERN_INFO "Unpacking initramfs...\n");
675

676 677
	err = unpack_to_rootfs((char *)initrd_start, initrd_end - initrd_start);
	if (err) {
678
		clean_rootfs();
679
		populate_initrd_image(err);
Linus Torvalds's avatar
Linus Torvalds committed
680
	}
681

682
done:
683 684 685 686
	/*
	 * If the initrd region is overlapped with crashkernel reserved region,
	 * free only memory that is not part of crashkernel region.
	 */
687
	if (!do_retain_initrd && initrd_start && !kexec_free_initrd())
688 689 690 691
		free_initrd_mem(initrd_start, initrd_end);
	initrd_start = 0;
	initrd_end = 0;

692
	flush_delayed_fput();
693
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
694
}
695
rootfs_initcall(populate_rootfs);