1 #include <linux/init.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/dirent.h>
9 #include <linux/syscalls.h>
10 #include <linux/utime.h>
12 static __initdata
char *message
;
13 static void __init
error(char *x
)
21 #define N_ALIGN(len) ((((len) + 1) & ~3) + 2)
23 static __initdata
struct hash
{
24 int ino
, minor
, major
;
27 char name
[N_ALIGN(PATH_MAX
)];
30 static inline int hash(int major
, int minor
, int ino
)
32 unsigned long tmp
= ino
+ minor
+ (major
<< 3);
37 static char __init
*find_link(int major
, int minor
, int ino
,
38 mode_t mode
, char *name
)
41 for (p
= head
+ hash(major
, minor
, ino
); *p
; p
= &(*p
)->next
) {
44 if ((*p
)->minor
!= minor
)
46 if ((*p
)->major
!= major
)
48 if (((*p
)->mode
^ mode
) & S_IFMT
)
52 q
= kmalloc(sizeof(struct hash
), GFP_KERNEL
);
54 panic("can't allocate link hash entry");
59 strcpy(q
->name
, name
);
65 static void __init
free_hash(void)
68 for (p
= head
; p
< head
+ 32; p
++) {
77 static long __init
do_utime(char __user
*filename
, time_t mtime
)
86 return do_utimes(AT_FDCWD
, filename
, t
, AT_SYMLINK_NOFOLLOW
);
89 static __initdata
LIST_HEAD(dir_list
);
91 struct list_head list
;
96 static void __init
dir_add(const char *name
, time_t mtime
)
98 struct dir_entry
*de
= kmalloc(sizeof(struct dir_entry
), GFP_KERNEL
);
100 panic("can't allocate dir_entry buffer");
101 INIT_LIST_HEAD(&de
->list
);
102 de
->name
= kstrdup(name
, GFP_KERNEL
);
104 list_add(&de
->list
, &dir_list
);
107 static void __init
dir_utime(void)
109 struct dir_entry
*de
, *tmp
;
110 list_for_each_entry_safe(de
, tmp
, &dir_list
, list
) {
112 do_utime(de
->name
, de
->mtime
);
118 static __initdata
time_t mtime
;
120 /* cpio header parsing */
122 static __initdata
unsigned long ino
, major
, minor
, nlink
;
123 static __initdata mode_t mode
;
124 static __initdata
unsigned long body_len
, name_len
;
125 static __initdata uid_t uid
;
126 static __initdata gid_t gid
;
127 static __initdata
unsigned rdev
;
129 static void __init
parse_header(char *s
)
131 unsigned long parsed
[12];
136 for (i
= 0, s
+= 6; i
< 12; i
++, s
+= 8) {
138 parsed
[i
] = simple_strtoul(buf
, NULL
, 16);
146 body_len
= parsed
[6];
149 rdev
= new_encode_dev(MKDEV(parsed
[9], parsed
[10]));
150 name_len
= parsed
[11];
155 static __initdata
enum state
{
166 static __initdata
char *victim
;
167 static __initdata
unsigned count
;
168 static __initdata loff_t this_header
, next_header
;
170 static inline void __init
eat(unsigned n
)
177 static __initdata
char *vcollected
;
178 static __initdata
char *collected
;
179 static __initdata
int remains
;
180 static __initdata
char *collect
;
182 static void __init
read_into(char *buf
, unsigned size
, enum state next
)
189 collect
= collected
= buf
;
196 static __initdata
char *header_buf
, *symlink_buf
, *name_buf
;
198 static int __init
do_start(void)
200 read_into(header_buf
, 110, GotHeader
);
204 static int __init
do_collect(void)
206 unsigned n
= remains
;
209 memcpy(collect
, victim
, n
);
212 if ((remains
-= n
) != 0)
218 static int __init
do_header(void)
220 if (memcmp(collected
, "070707", 6)==0) {
221 error("incorrect cpio method used: use -H newc option");
224 if (memcmp(collected
, "070701", 6)) {
225 error("no cpio magic");
228 parse_header(collected
);
229 next_header
= this_header
+ N_ALIGN(name_len
) + body_len
;
230 next_header
= (next_header
+ 3) & ~3;
232 if (name_len
<= 0 || name_len
> PATH_MAX
)
235 if (body_len
> PATH_MAX
)
237 collect
= collected
= symlink_buf
;
238 remains
= N_ALIGN(name_len
) + body_len
;
239 next_state
= GotSymlink
;
243 if (S_ISREG(mode
) || !body_len
)
244 read_into(name_buf
, N_ALIGN(name_len
), GotName
);
248 static int __init
do_skip(void)
250 if (this_header
+ count
< next_header
) {
254 eat(next_header
- this_header
);
260 static int __init
do_reset(void)
262 while(count
&& *victim
== '\0')
264 if (count
&& (this_header
& 3))
265 error("broken padding");
269 static int __init
maybe_link(void)
272 char *old
= find_link(major
, minor
, ino
, mode
, collected
);
274 return (sys_link(old
, collected
) < 0) ? -1 : 1;
279 static void __init
clean_path(char *path
, mode_t mode
)
283 if (!sys_newlstat(path
, &st
) && (st
.st_mode
^mode
) & S_IFMT
) {
284 if (S_ISDIR(st
.st_mode
))
291 static __initdata
int wfd
;
293 static int __init
do_name(void)
297 if (strcmp(collected
, "TRAILER!!!") == 0) {
301 clean_path(collected
, mode
);
303 int ml
= maybe_link();
305 int openflags
= O_WRONLY
|O_CREAT
;
307 openflags
|= O_TRUNC
;
308 wfd
= sys_open(collected
, openflags
, mode
);
311 sys_fchown(wfd
, uid
, gid
);
312 sys_fchmod(wfd
, mode
);
313 vcollected
= kstrdup(collected
, GFP_KERNEL
);
317 } else if (S_ISDIR(mode
)) {
318 sys_mkdir(collected
, mode
);
319 sys_chown(collected
, uid
, gid
);
320 sys_chmod(collected
, mode
);
321 dir_add(collected
, mtime
);
322 } else if (S_ISBLK(mode
) || S_ISCHR(mode
) ||
323 S_ISFIFO(mode
) || S_ISSOCK(mode
)) {
324 if (maybe_link() == 0) {
325 sys_mknod(collected
, mode
, rdev
);
326 sys_chown(collected
, uid
, gid
);
327 sys_chmod(collected
, mode
);
328 do_utime(collected
, mtime
);
334 static int __init
do_copy(void)
336 if (count
>= body_len
) {
337 sys_write(wfd
, victim
, body_len
);
339 do_utime(vcollected
, mtime
);
345 sys_write(wfd
, victim
, count
);
352 static int __init
do_symlink(void)
354 collected
[N_ALIGN(name_len
) + body_len
] = '\0';
355 clean_path(collected
, 0);
356 sys_symlink(collected
+ N_ALIGN(name_len
), collected
);
357 sys_lchown(collected
, uid
, gid
);
358 do_utime(collected
, mtime
);
364 static __initdata
int (*actions
[])(void) = {
366 [Collect
] = do_collect
,
367 [GotHeader
] = do_header
,
370 [CopyFile
] = do_copy
,
371 [GotSymlink
] = do_symlink
,
375 static int __init
write_buffer(char *buf
, unsigned len
)
380 while (!actions
[state
]())
385 static void __init
flush_buffer(char *buf
, unsigned len
)
390 while ((written
= write_buffer(buf
, len
)) < len
&& !message
) {
391 char c
= buf
[written
];
401 error("junk in compressed archive");
409 #define OF(args) args
412 #define memzero(s, n) memset ((s), 0, (n))
415 typedef unsigned char uch
;
416 typedef unsigned short ush
;
417 typedef unsigned long ulg
;
419 #define WSIZE 0x8000 /* window size--must be a power of two, and */
420 /* at least 32K for zip's deflate method */
425 static unsigned insize
; /* valid bytes in inbuf */
426 static unsigned inptr
; /* index of next byte to be processed in inbuf */
427 static unsigned outcnt
; /* bytes in output buffer */
428 static long bytes_out
;
430 #define get_byte() (inptr < insize ? inbuf[inptr++] : -1)
432 /* Diagnostic functions (stubbed out) */
433 #define Assert(cond,msg)
440 #define STATIC static
443 static void __init
flush_window(void);
444 static void __init
error(char *m
);
446 #define NO_INFLATE_MALLOC
448 #include "../lib/inflate.c"
450 /* ===========================================================================
451 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
452 * (Used for the decompressed data only.)
454 static void __init
flush_window(void)
456 ulg c
= crc
; /* temporary variable */
460 flush_buffer(window
, outcnt
);
462 for (n
= 0; n
< outcnt
; n
++) {
464 c
= crc_32_tab
[((int)c
^ ch
) & 0xff] ^ (c
>> 8);
467 bytes_out
+= (ulg
)outcnt
;
471 static char * __init
unpack_to_rootfs(char *buf
, unsigned len
)
474 header_buf
= kmalloc(110, GFP_KERNEL
);
475 symlink_buf
= kmalloc(PATH_MAX
+ N_ALIGN(PATH_MAX
) + 1, GFP_KERNEL
);
476 name_buf
= kmalloc(N_ALIGN(PATH_MAX
), GFP_KERNEL
);
477 window
= kmalloc(WSIZE
, GFP_KERNEL
);
478 if (!window
|| !header_buf
|| !symlink_buf
|| !name_buf
)
479 panic("can't allocate buffers");
483 while (!message
&& len
) {
484 loff_t saved_offset
= this_header
;
485 if (*buf
== '0' && !(this_header
& 3)) {
487 written
= write_buffer(buf
, len
);
502 outcnt
= 0; /* bytes in output buffer */
504 crc
= (ulg
)0xffffffffL
; /* shift register contents */
508 error("junk in gzipped archive");
509 this_header
= saved_offset
+ inptr
;
521 static int __initdata do_retain_initrd
;
523 static int __init
retain_initrd_param(char *str
)
527 do_retain_initrd
= 1;
530 __setup("retain_initrd", retain_initrd_param
);
532 extern char __initramfs_start
[], __initramfs_end
[];
533 #include <linux/initrd.h>
534 #include <linux/kexec.h>
536 static void __init
free_initrd(void)
539 unsigned long crashk_start
= (unsigned long)__va(crashk_res
.start
);
540 unsigned long crashk_end
= (unsigned long)__va(crashk_res
.end
);
542 if (do_retain_initrd
)
547 * If the initrd region is overlapped with crashkernel reserved region,
548 * free only memory that is not part of crashkernel region.
550 if (initrd_start
< crashk_end
&& initrd_end
> crashk_start
) {
552 * Initialize initrd memory region since the kexec boot does
555 memset((void *)initrd_start
, 0, initrd_end
- initrd_start
);
556 if (initrd_start
< crashk_start
)
557 free_initrd_mem(initrd_start
, crashk_start
);
558 if (initrd_end
> crashk_end
)
559 free_initrd_mem(crashk_end
, initrd_end
);
562 free_initrd_mem(initrd_start
, initrd_end
);
568 #define BUF_SIZE 1024
569 static void __init
clean_rootfs(void)
573 struct linux_dirent64
*dirp
;
576 fd
= sys_open("/", O_RDONLY
, 0);
580 buf
= kzalloc(BUF_SIZE
, GFP_KERNEL
);
588 count
= sys_getdents64(fd
, dirp
, BUF_SIZE
);
594 ret
= sys_newlstat(dirp
->d_name
, &st
);
597 if (S_ISDIR(st
.st_mode
))
598 sys_rmdir(dirp
->d_name
);
600 sys_unlink(dirp
->d_name
);
603 count
-= dirp
->d_reclen
;
604 dirp
= (void *)dirp
+ dirp
->d_reclen
;
607 memset(buf
, 0, BUF_SIZE
);
608 count
= sys_getdents64(fd
, dirp
, BUF_SIZE
);
615 static int __init
populate_rootfs(void)
617 char *err
= unpack_to_rootfs(__initramfs_start
,
618 __initramfs_end
- __initramfs_start
);
622 #ifdef CONFIG_BLK_DEV_RAM
624 printk(KERN_INFO
"checking if image is initramfs...");
625 err
= unpack_to_rootfs((char *)initrd_start
,
626 initrd_end
- initrd_start
);
633 unpack_to_rootfs(__initramfs_start
,
634 __initramfs_end
- __initramfs_start
);
636 printk("it isn't (%s); looks like an initrd\n", err
);
637 fd
= sys_open("/initrd.image", O_WRONLY
|O_CREAT
, 0700);
639 sys_write(fd
, (char *)initrd_start
,
640 initrd_end
- initrd_start
);
645 printk(KERN_INFO
"Unpacking initramfs...");
646 err
= unpack_to_rootfs((char *)initrd_start
,
647 initrd_end
- initrd_start
);
656 rootfs_initcall(populate_rootfs
);