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