init/initramfs.c

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