1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/init.h> 3 #include <linux/fs.h> 4 #include <linux/slab.h> 5 #include <linux/types.h> 6 #include <linux/fcntl.h> 7 #include <linux/delay.h> 8 #include <linux/string.h> 9 #include <linux/dirent.h> 10 #include <linux/syscalls.h> 11 #include <linux/utime.h> 12 #include <linux/file.h> 13 #include <linux/memblock.h> 14 15 static ssize_t __init xwrite(int fd, const char *p, size_t count) 16 { 17 ssize_t out = 0; 18 19 /* sys_write only can write MAX_RW_COUNT aka 2G-4K bytes at most */ 20 while (count) { 21 ssize_t rv = ksys_write(fd, p, count); 22 23 if (rv < 0) { 24 if (rv == -EINTR || rv == -EAGAIN) 25 continue; 26 return out ? out : rv; 27 } else if (rv == 0) 28 break; 29 30 p += rv; 31 out += rv; 32 count -= rv; 33 } 34 35 return out; 36 } 37 38 static __initdata char *message; 39 static void __init error(char *x) 40 { 41 if (!message) 42 message = x; 43 } 44 45 /* link hash */ 46 47 #define N_ALIGN(len) ((((len) + 1) & ~3) + 2) 48 49 static __initdata struct hash { 50 int ino, minor, major; 51 umode_t mode; 52 struct hash *next; 53 char name[N_ALIGN(PATH_MAX)]; 54 } *head[32]; 55 56 static inline int hash(int major, int minor, int ino) 57 { 58 unsigned long tmp = ino + minor + (major << 3); 59 tmp += tmp >> 5; 60 return tmp & 31; 61 } 62 63 static char __init *find_link(int major, int minor, int ino, 64 umode_t mode, char *name) 65 { 66 struct hash **p, *q; 67 for (p = head + hash(major, minor, ino); *p; p = &(*p)->next) { 68 if ((*p)->ino != ino) 69 continue; 70 if ((*p)->minor != minor) 71 continue; 72 if ((*p)->major != major) 73 continue; 74 if (((*p)->mode ^ mode) & S_IFMT) 75 continue; 76 return (*p)->name; 77 } 78 q = kmalloc(sizeof(struct hash), GFP_KERNEL); 79 if (!q) 80 panic("can't allocate link hash entry"); 81 q->major = major; 82 q->minor = minor; 83 q->ino = ino; 84 q->mode = mode; 85 strcpy(q->name, name); 86 q->next = NULL; 87 *p = q; 88 return NULL; 89 } 90 91 static void __init free_hash(void) 92 { 93 struct hash **p, *q; 94 for (p = head; p < head + 32; p++) { 95 while (*p) { 96 q = *p; 97 *p = q->next; 98 kfree(q); 99 } 100 } 101 } 102 103 static long __init do_utime(char *filename, time64_t mtime) 104 { 105 struct timespec64 t[2]; 106 107 t[0].tv_sec = mtime; 108 t[0].tv_nsec = 0; 109 t[1].tv_sec = mtime; 110 t[1].tv_nsec = 0; 111 112 return do_utimes(AT_FDCWD, filename, t, AT_SYMLINK_NOFOLLOW); 113 } 114 115 static __initdata LIST_HEAD(dir_list); 116 struct dir_entry { 117 struct list_head list; 118 char *name; 119 time64_t mtime; 120 }; 121 122 static void __init dir_add(const char *name, time64_t mtime) 123 { 124 struct dir_entry *de = kmalloc(sizeof(struct dir_entry), GFP_KERNEL); 125 if (!de) 126 panic("can't allocate dir_entry buffer"); 127 INIT_LIST_HEAD(&de->list); 128 de->name = kstrdup(name, GFP_KERNEL); 129 de->mtime = mtime; 130 list_add(&de->list, &dir_list); 131 } 132 133 static void __init dir_utime(void) 134 { 135 struct dir_entry *de, *tmp; 136 list_for_each_entry_safe(de, tmp, &dir_list, list) { 137 list_del(&de->list); 138 do_utime(de->name, de->mtime); 139 kfree(de->name); 140 kfree(de); 141 } 142 } 143 144 static __initdata time64_t mtime; 145 146 /* cpio header parsing */ 147 148 static __initdata unsigned long ino, major, minor, nlink; 149 static __initdata umode_t mode; 150 static __initdata unsigned long body_len, name_len; 151 static __initdata uid_t uid; 152 static __initdata gid_t gid; 153 static __initdata unsigned rdev; 154 155 static void __init parse_header(char *s) 156 { 157 unsigned long parsed[12]; 158 char buf[9]; 159 int i; 160 161 buf[8] = '\0'; 162 for (i = 0, s += 6; i < 12; i++, s += 8) { 163 memcpy(buf, s, 8); 164 parsed[i] = simple_strtoul(buf, NULL, 16); 165 } 166 ino = parsed[0]; 167 mode = parsed[1]; 168 uid = parsed[2]; 169 gid = parsed[3]; 170 nlink = parsed[4]; 171 mtime = parsed[5]; /* breaks in y2106 */ 172 body_len = parsed[6]; 173 major = parsed[7]; 174 minor = parsed[8]; 175 rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); 176 name_len = parsed[11]; 177 } 178 179 /* FSM */ 180 181 static __initdata enum state { 182 Start, 183 Collect, 184 GotHeader, 185 SkipIt, 186 GotName, 187 CopyFile, 188 GotSymlink, 189 Reset 190 } state, next_state; 191 192 static __initdata char *victim; 193 static unsigned long byte_count __initdata; 194 static __initdata loff_t this_header, next_header; 195 196 static inline void __init eat(unsigned n) 197 { 198 victim += n; 199 this_header += n; 200 byte_count -= n; 201 } 202 203 static __initdata char *vcollected; 204 static __initdata char *collected; 205 static long remains __initdata; 206 static __initdata char *collect; 207 208 static void __init read_into(char *buf, unsigned size, enum state next) 209 { 210 if (byte_count >= size) { 211 collected = victim; 212 eat(size); 213 state = next; 214 } else { 215 collect = collected = buf; 216 remains = size; 217 next_state = next; 218 state = Collect; 219 } 220 } 221 222 static __initdata char *header_buf, *symlink_buf, *name_buf; 223 224 static int __init do_start(void) 225 { 226 read_into(header_buf, 110, GotHeader); 227 return 0; 228 } 229 230 static int __init do_collect(void) 231 { 232 unsigned long n = remains; 233 if (byte_count < n) 234 n = byte_count; 235 memcpy(collect, victim, n); 236 eat(n); 237 collect += n; 238 if ((remains -= n) != 0) 239 return 1; 240 state = next_state; 241 return 0; 242 } 243 244 static int __init do_header(void) 245 { 246 if (memcmp(collected, "070707", 6)==0) { 247 error("incorrect cpio method used: use -H newc option"); 248 return 1; 249 } 250 if (memcmp(collected, "070701", 6)) { 251 error("no cpio magic"); 252 return 1; 253 } 254 parse_header(collected); 255 next_header = this_header + N_ALIGN(name_len) + body_len; 256 next_header = (next_header + 3) & ~3; 257 state = SkipIt; 258 if (name_len <= 0 || name_len > PATH_MAX) 259 return 0; 260 if (S_ISLNK(mode)) { 261 if (body_len > PATH_MAX) 262 return 0; 263 collect = collected = symlink_buf; 264 remains = N_ALIGN(name_len) + body_len; 265 next_state = GotSymlink; 266 state = Collect; 267 return 0; 268 } 269 if (S_ISREG(mode) || !body_len) 270 read_into(name_buf, N_ALIGN(name_len), GotName); 271 return 0; 272 } 273 274 static int __init do_skip(void) 275 { 276 if (this_header + byte_count < next_header) { 277 eat(byte_count); 278 return 1; 279 } else { 280 eat(next_header - this_header); 281 state = next_state; 282 return 0; 283 } 284 } 285 286 static int __init do_reset(void) 287 { 288 while (byte_count && *victim == '\0') 289 eat(1); 290 if (byte_count && (this_header & 3)) 291 error("broken padding"); 292 return 1; 293 } 294 295 static void __init clean_path(char *path, umode_t fmode) 296 { 297 struct kstat st; 298 299 if (!vfs_lstat(path, &st) && (st.mode ^ fmode) & S_IFMT) { 300 if (S_ISDIR(st.mode)) 301 ksys_rmdir(path); 302 else 303 ksys_unlink(path); 304 } 305 } 306 307 static int __init maybe_link(void) 308 { 309 if (nlink >= 2) { 310 char *old = find_link(major, minor, ino, mode, collected); 311 if (old) { 312 clean_path(collected, 0); 313 return (ksys_link(old, collected) < 0) ? -1 : 1; 314 } 315 } 316 return 0; 317 } 318 319 static __initdata int wfd; 320 321 static int __init do_name(void) 322 { 323 state = SkipIt; 324 next_state = Reset; 325 if (strcmp(collected, "TRAILER!!!") == 0) { 326 free_hash(); 327 return 0; 328 } 329 clean_path(collected, mode); 330 if (S_ISREG(mode)) { 331 int ml = maybe_link(); 332 if (ml >= 0) { 333 int openflags = O_WRONLY|O_CREAT; 334 if (ml != 1) 335 openflags |= O_TRUNC; 336 wfd = ksys_open(collected, openflags, mode); 337 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); 344 state = CopyFile; 345 } 346 } 347 } 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); 352 } else if (S_ISBLK(mode) || S_ISCHR(mode) || 353 S_ISFIFO(mode) || S_ISSOCK(mode)) { 354 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); 359 } 360 } 361 return 0; 362 } 363 364 static int __init do_copy(void) 365 { 366 if (byte_count >= body_len) { 367 if (xwrite(wfd, victim, body_len) != body_len) 368 error("write error"); 369 ksys_close(wfd); 370 do_utime(vcollected, mtime); 371 kfree(vcollected); 372 eat(body_len); 373 state = SkipIt; 374 return 0; 375 } else { 376 if (xwrite(wfd, victim, byte_count) != byte_count) 377 error("write error"); 378 body_len -= byte_count; 379 eat(byte_count); 380 return 1; 381 } 382 } 383 384 static int __init do_symlink(void) 385 { 386 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); 391 state = SkipIt; 392 next_state = Reset; 393 return 0; 394 } 395 396 static __initdata int (*actions[])(void) = { 397 [Start] = do_start, 398 [Collect] = do_collect, 399 [GotHeader] = do_header, 400 [SkipIt] = do_skip, 401 [GotName] = do_name, 402 [CopyFile] = do_copy, 403 [GotSymlink] = do_symlink, 404 [Reset] = do_reset, 405 }; 406 407 static long __init write_buffer(char *buf, unsigned long len) 408 { 409 byte_count = len; 410 victim = buf; 411 412 while (!actions[state]()) 413 ; 414 return len - byte_count; 415 } 416 417 static long __init flush_buffer(void *bufv, unsigned long len) 418 { 419 char *buf = (char *) bufv; 420 long written; 421 long origLen = len; 422 if (message) 423 return -1; 424 while ((written = write_buffer(buf, len)) < len && !message) { 425 char c = buf[written]; 426 if (c == '0') { 427 buf += written; 428 len -= written; 429 state = Start; 430 } else if (c == 0) { 431 buf += written; 432 len -= written; 433 state = Reset; 434 } else 435 error("junk within compressed archive"); 436 } 437 return origLen; 438 } 439 440 static unsigned long my_inptr; /* index of next byte to be processed in inbuf */ 441 442 #include <linux/decompress/generic.h> 443 444 static char * __init unpack_to_rootfs(char *buf, unsigned long len) 445 { 446 long written; 447 decompress_fn decompress; 448 const char *compress_name; 449 static __initdata char msg_buf[64]; 450 451 header_buf = kmalloc(110, GFP_KERNEL); 452 symlink_buf = kmalloc(PATH_MAX + N_ALIGN(PATH_MAX) + 1, GFP_KERNEL); 453 name_buf = kmalloc(N_ALIGN(PATH_MAX), GFP_KERNEL); 454 455 if (!header_buf || !symlink_buf || !name_buf) 456 panic("can't allocate buffers"); 457 458 state = Start; 459 this_header = 0; 460 message = NULL; 461 while (!message && len) { 462 loff_t saved_offset = this_header; 463 if (*buf == '0' && !(this_header & 3)) { 464 state = Start; 465 written = write_buffer(buf, len); 466 buf += written; 467 len -= written; 468 continue; 469 } 470 if (!*buf) { 471 buf++; 472 len--; 473 this_header++; 474 continue; 475 } 476 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 if (res) 483 error("decompressor failed"); 484 } else if (compress_name) { 485 if (!message) { 486 snprintf(msg_buf, sizeof msg_buf, 487 "compression method %s not configured", 488 compress_name); 489 message = msg_buf; 490 } 491 } else 492 error("invalid magic at start of compressed archive"); 493 if (state != Reset) 494 error("junk at the end of compressed archive"); 495 this_header = saved_offset + my_inptr; 496 buf += my_inptr; 497 len -= my_inptr; 498 } 499 dir_utime(); 500 kfree(name_buf); 501 kfree(symlink_buf); 502 kfree(header_buf); 503 return message; 504 } 505 506 static int __initdata do_retain_initrd; 507 508 static int __init retain_initrd_param(char *str) 509 { 510 if (*str) 511 return 0; 512 do_retain_initrd = 1; 513 return 1; 514 } 515 __setup("retain_initrd", retain_initrd_param); 516 517 #ifdef CONFIG_ARCH_HAS_KEEPINITRD 518 static int __init keepinitrd_setup(char *__unused) 519 { 520 do_retain_initrd = 1; 521 return 1; 522 } 523 __setup("keepinitrd", keepinitrd_setup); 524 #endif 525 526 extern char __initramfs_start[]; 527 extern unsigned long __initramfs_size; 528 #include <linux/initrd.h> 529 #include <linux/kexec.h> 530 531 void __weak free_initrd_mem(unsigned long start, unsigned long end) 532 { 533 #ifdef CONFIG_ARCH_KEEP_MEMBLOCK 534 unsigned long aligned_start = ALIGN_DOWN(start, PAGE_SIZE); 535 unsigned long aligned_end = ALIGN(end, PAGE_SIZE); 536 537 memblock_free(__pa(aligned_start), aligned_end - aligned_start); 538 #endif 539 540 free_reserved_area((void *)start, (void *)end, POISON_FREE_INITMEM, 541 "initrd"); 542 } 543 544 #ifdef CONFIG_KEXEC_CORE 545 static bool __init kexec_free_initrd(void) 546 { 547 unsigned long crashk_start = (unsigned long)__va(crashk_res.start); 548 unsigned long crashk_end = (unsigned long)__va(crashk_res.end); 549 550 /* 551 * If the initrd region is overlapped with crashkernel reserved region, 552 * free only memory that is not part of crashkernel region. 553 */ 554 if (initrd_start >= crashk_end || initrd_end <= crashk_start) 555 return false; 556 557 /* 558 * Initialize initrd memory region since the kexec boot does not do. 559 */ 560 memset((void *)initrd_start, 0, initrd_end - initrd_start); 561 if (initrd_start < crashk_start) 562 free_initrd_mem(initrd_start, crashk_start); 563 if (initrd_end > crashk_end) 564 free_initrd_mem(crashk_end, initrd_end); 565 return true; 566 } 567 #else 568 static inline bool kexec_free_initrd(void) 569 { 570 return false; 571 } 572 #endif /* CONFIG_KEXEC_CORE */ 573 574 #ifdef CONFIG_BLK_DEV_RAM 575 #define BUF_SIZE 1024 576 static void __init clean_rootfs(void) 577 { 578 int fd; 579 void *buf; 580 struct linux_dirent64 *dirp; 581 int num; 582 583 fd = ksys_open("/", O_RDONLY, 0); 584 WARN_ON(fd < 0); 585 if (fd < 0) 586 return; 587 buf = kzalloc(BUF_SIZE, GFP_KERNEL); 588 WARN_ON(!buf); 589 if (!buf) { 590 ksys_close(fd); 591 return; 592 } 593 594 dirp = buf; 595 num = ksys_getdents64(fd, dirp, BUF_SIZE); 596 while (num > 0) { 597 while (num > 0) { 598 struct kstat st; 599 int ret; 600 601 ret = vfs_lstat(dirp->d_name, &st); 602 WARN_ON_ONCE(ret); 603 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 dirp = (void *)dirp + dirp->d_reclen; 612 } 613 dirp = buf; 614 memset(buf, 0, BUF_SIZE); 615 num = ksys_getdents64(fd, dirp, BUF_SIZE); 616 } 617 618 ksys_close(fd); 619 kfree(buf); 620 } 621 #else 622 static inline void clean_rootfs(void) 623 { 624 } 625 #endif /* CONFIG_BLK_DEV_RAM */ 626 627 #ifdef CONFIG_BLK_DEV_RAM 628 static void __init populate_initrd_image(char *err) 629 { 630 ssize_t written; 631 int fd; 632 633 unpack_to_rootfs(__initramfs_start, __initramfs_size); 634 635 printk(KERN_INFO "rootfs image is not initramfs (%s); looks like an initrd\n", 636 err); 637 fd = ksys_open("/initrd.image", O_WRONLY | O_CREAT, 0700); 638 if (fd < 0) 639 return; 640 641 written = xwrite(fd, (char *)initrd_start, initrd_end - initrd_start); 642 if (written != initrd_end - initrd_start) 643 pr_err("/initrd.image: incomplete write (%zd != %ld)\n", 644 written, initrd_end - initrd_start); 645 ksys_close(fd); 646 } 647 #else 648 static void __init populate_initrd_image(char *err) 649 { 650 printk(KERN_EMERG "Initramfs unpacking failed: %s\n", err); 651 } 652 #endif /* CONFIG_BLK_DEV_RAM */ 653 654 static int __init populate_rootfs(void) 655 { 656 /* Load the built in initramfs */ 657 char *err = unpack_to_rootfs(__initramfs_start, __initramfs_size); 658 if (err) 659 panic("%s", err); /* Failed to decompress INTERNAL initramfs */ 660 661 if (!initrd_start || IS_ENABLED(CONFIG_INITRAMFS_FORCE)) 662 goto done; 663 664 if (IS_ENABLED(CONFIG_BLK_DEV_RAM)) 665 printk(KERN_INFO "Trying to unpack rootfs image as initramfs...\n"); 666 else 667 printk(KERN_INFO "Unpacking initramfs...\n"); 668 669 err = unpack_to_rootfs((char *)initrd_start, initrd_end - initrd_start); 670 if (err) { 671 clean_rootfs(); 672 populate_initrd_image(err); 673 } 674 675 done: 676 /* 677 * If the initrd region is overlapped with crashkernel reserved region, 678 * free only memory that is not part of crashkernel region. 679 */ 680 if (!do_retain_initrd && initrd_start && !kexec_free_initrd()) 681 free_initrd_mem(initrd_start, initrd_end); 682 initrd_start = 0; 683 initrd_end = 0; 684 685 flush_delayed_fput(); 686 return 0; 687 } 688 rootfs_initcall(populate_rootfs); 689