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