bzip2/lzma: config and initramfs support for bzip2/lzma decompression
[linux-3.10.git] / init / do_mounts_rd.c
1
2 #include <linux/kernel.h>
3 #include <linux/fs.h>
4 #include <linux/minix_fs.h>
5 #include <linux/ext2_fs.h>
6 #include <linux/romfs_fs.h>
7 #include <linux/cramfs_fs.h>
8 #include <linux/initrd.h>
9 #include <linux/string.h>
10
11 #include "do_mounts.h"
12
13 #include <linux/decompress/generic.h>
14
15 #include <linux/decompress/bunzip2.h>
16 #include <linux/decompress/unlzma.h>
17 #include <linux/decompress/inflate.h>
18
19 int __initdata rd_prompt = 1;/* 1 = prompt for RAM disk, 0 = don't prompt */
20
21 static int __init prompt_ramdisk(char *str)
22 {
23         rd_prompt = simple_strtol(str,NULL,0) & 1;
24         return 1;
25 }
26 __setup("prompt_ramdisk=", prompt_ramdisk);
27
28 int __initdata rd_image_start;          /* starting block # of image */
29
30 static int __init ramdisk_start_setup(char *str)
31 {
32         rd_image_start = simple_strtol(str,NULL,0);
33         return 1;
34 }
35 __setup("ramdisk_start=", ramdisk_start_setup);
36
37 static int __init crd_load(int in_fd, int out_fd, decompress_fn deco);
38
39 /*
40  * This routine tries to find a RAM disk image to load, and returns the
41  * number of blocks to read for a non-compressed image, 0 if the image
42  * is a compressed image, and -1 if an image with the right magic
43  * numbers could not be found.
44  *
45  * We currently check for the following magic numbers:
46  *      minix
47  *      ext2
48  *      romfs
49  *      cramfs
50  *      gzip
51  */
52 static int __init 
53 identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
54 {
55         const int size = 512;
56         struct minix_super_block *minixsb;
57         struct ext2_super_block *ext2sb;
58         struct romfs_super_block *romfsb;
59         struct cramfs_super *cramfsb;
60         int nblocks = -1;
61         unsigned char *buf;
62
63         buf = kmalloc(size, GFP_KERNEL);
64         if (!buf)
65                 return -1;
66
67         minixsb = (struct minix_super_block *) buf;
68         ext2sb = (struct ext2_super_block *) buf;
69         romfsb = (struct romfs_super_block *) buf;
70         cramfsb = (struct cramfs_super *) buf;
71         memset(buf, 0xe5, size);
72
73         /*
74          * Read block 0 to test for gzipped kernel
75          */
76         sys_lseek(fd, start_block * BLOCK_SIZE, 0);
77         sys_read(fd, buf, size);
78
79 #ifdef CONFIG_RD_GZIP
80         /*
81          * If it matches the gzip magic numbers, return 0
82          */
83         if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
84                 printk(KERN_NOTICE
85                        "RAMDISK: Compressed image found at block %d\n",
86                        start_block);
87                 *decompressor = gunzip;
88                 nblocks = 0;
89                 goto done;
90         }
91 #endif
92
93 #ifdef CONFIG_RD_BZIP2
94         /*
95          * If it matches the bzip2 magic numbers, return -1
96          */
97         if (buf[0] == 0x42 && (buf[1] == 0x5a)) {
98                 printk(KERN_NOTICE
99                        "RAMDISK: Bzipped image found at block %d\n",
100                        start_block);
101                 *decompressor = bunzip2;
102                 nblocks = 0;
103                 goto done;
104         }
105 #endif
106
107 #ifdef CONFIG_RD_LZMA
108         /*
109          * If it matches the lzma magic numbers, return -1
110          */
111         if (buf[0] == 0x5d && (buf[1] == 0x00)) {
112                 printk(KERN_NOTICE
113                        "RAMDISK: Lzma image found at block %d\n",
114                        start_block);
115                 *decompressor = unlzma;
116                 nblocks = 0;
117                 goto done;
118         }
119 #endif
120
121         /* romfs is at block zero too */
122         if (romfsb->word0 == ROMSB_WORD0 &&
123             romfsb->word1 == ROMSB_WORD1) {
124                 printk(KERN_NOTICE
125                        "RAMDISK: romfs filesystem found at block %d\n",
126                        start_block);
127                 nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
128                 goto done;
129         }
130
131         if (cramfsb->magic == CRAMFS_MAGIC) {
132                 printk(KERN_NOTICE
133                        "RAMDISK: cramfs filesystem found at block %d\n",
134                        start_block);
135                 nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
136                 goto done;
137         }
138
139         /*
140          * Read block 1 to test for minix and ext2 superblock
141          */
142         sys_lseek(fd, (start_block+1) * BLOCK_SIZE, 0);
143         sys_read(fd, buf, size);
144
145         /* Try minix */
146         if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
147             minixsb->s_magic == MINIX_SUPER_MAGIC2) {
148                 printk(KERN_NOTICE
149                        "RAMDISK: Minix filesystem found at block %d\n",
150                        start_block);
151                 nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
152                 goto done;
153         }
154
155         /* Try ext2 */
156         if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
157                 printk(KERN_NOTICE
158                        "RAMDISK: ext2 filesystem found at block %d\n",
159                        start_block);
160                 nblocks = le32_to_cpu(ext2sb->s_blocks_count) <<
161                         le32_to_cpu(ext2sb->s_log_block_size);
162                 goto done;
163         }
164
165         printk(KERN_NOTICE
166                "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
167                start_block);
168         
169 done:
170         sys_lseek(fd, start_block * BLOCK_SIZE, 0);
171         kfree(buf);
172         return nblocks;
173 }
174
175 int __init rd_load_image(char *from)
176 {
177         int res = 0;
178         int in_fd, out_fd;
179         unsigned long rd_blocks, devblocks;
180         int nblocks, i, disk;
181         char *buf = NULL;
182         unsigned short rotate = 0;
183         decompress_fn decompressor = NULL;
184 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
185         char rotator[4] = { '|' , '/' , '-' , '\\' };
186 #endif
187
188         out_fd = sys_open("/dev/ram", O_RDWR, 0);
189         if (out_fd < 0)
190                 goto out;
191
192         in_fd = sys_open(from, O_RDONLY, 0);
193         if (in_fd < 0)
194                 goto noclose_input;
195
196         nblocks = identify_ramdisk_image(in_fd, rd_image_start, &decompressor);
197         if (nblocks < 0)
198                 goto done;
199
200         if (nblocks == 0) {
201                 if (crd_load(in_fd, out_fd, decompressor) == 0)
202                         goto successful_load;
203                 goto done;
204         }
205
206         /*
207          * NOTE NOTE: nblocks is not actually blocks but
208          * the number of kibibytes of data to load into a ramdisk.
209          * So any ramdisk block size that is a multiple of 1KiB should
210          * work when the appropriate ramdisk_blocksize is specified
211          * on the command line.
212          *
213          * The default ramdisk_blocksize is 1KiB and it is generally
214          * silly to use anything else, so make sure to use 1KiB
215          * blocksize while generating ext2fs ramdisk-images.
216          */
217         if (sys_ioctl(out_fd, BLKGETSIZE, (unsigned long)&rd_blocks) < 0)
218                 rd_blocks = 0;
219         else
220                 rd_blocks >>= 1;
221
222         if (nblocks > rd_blocks) {
223                 printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
224                        nblocks, rd_blocks);
225                 goto done;
226         }
227                 
228         /*
229          * OK, time to copy in the data
230          */
231         if (sys_ioctl(in_fd, BLKGETSIZE, (unsigned long)&devblocks) < 0)
232                 devblocks = 0;
233         else
234                 devblocks >>= 1;
235
236         if (strcmp(from, "/initrd.image") == 0)
237                 devblocks = nblocks;
238
239         if (devblocks == 0) {
240                 printk(KERN_ERR "RAMDISK: could not determine device size\n");
241                 goto done;
242         }
243
244         buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
245         if (!buf) {
246                 printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
247                 goto done;
248         }
249
250         printk(KERN_NOTICE "RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
251                 nblocks, ((nblocks-1)/devblocks)+1, nblocks>devblocks ? "s" : "");
252         for (i = 0, disk = 1; i < nblocks; i++) {
253                 if (i && (i % devblocks == 0)) {
254                         printk("done disk #%d.\n", disk++);
255                         rotate = 0;
256                         if (sys_close(in_fd)) {
257                                 printk("Error closing the disk.\n");
258                                 goto noclose_input;
259                         }
260                         change_floppy("disk #%d", disk);
261                         in_fd = sys_open(from, O_RDONLY, 0);
262                         if (in_fd < 0)  {
263                                 printk("Error opening disk.\n");
264                                 goto noclose_input;
265                         }
266                         printk("Loading disk #%d... ", disk);
267                 }
268                 sys_read(in_fd, buf, BLOCK_SIZE);
269                 sys_write(out_fd, buf, BLOCK_SIZE);
270 #if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
271                 if (!(i % 16)) {
272                         printk("%c\b", rotator[rotate & 0x3]);
273                         rotate++;
274                 }
275 #endif
276         }
277         printk("done.\n");
278
279 successful_load:
280         res = 1;
281 done:
282         sys_close(in_fd);
283 noclose_input:
284         sys_close(out_fd);
285 out:
286         kfree(buf);
287         sys_unlink("/dev/ram");
288         return res;
289 }
290
291 int __init rd_load_disk(int n)
292 {
293         if (rd_prompt)
294                 change_floppy("root floppy disk to be loaded into RAM disk");
295         create_dev("/dev/root", ROOT_DEV);
296         create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));
297         return rd_load_image("/dev/root");
298 }
299
300 static int exit_code;
301 static int decompress_error;
302 static int crd_infd, crd_outfd;
303
304 static int __init compr_fill(void *buf, unsigned int len)
305 {
306         int r = sys_read(crd_infd, buf, len);
307         if (r < 0)
308                 printk(KERN_ERR "RAMDISK: error while reading compressed data");
309         else if (r == 0)
310                 printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
311         return r;
312 }
313
314 static int __init compr_flush(void *window, unsigned int outcnt)
315 {
316         int written = sys_write(crd_outfd, window, outcnt);
317         if (written != outcnt) {
318                 if (decompress_error == 0)
319                         printk(KERN_ERR
320                                "RAMDISK: incomplete write (%d != %d)\n",
321                                written, outcnt);
322                 decompress_error = 1;
323                 return -1;
324         }
325         return outcnt;
326 }
327
328 static void __init error(char *x)
329 {
330         printk(KERN_ERR "%s\n", x);
331         exit_code = 1;
332         decompress_error = 1;
333 }
334
335 static int __init crd_load(int in_fd, int out_fd, decompress_fn deco)
336 {
337         int result;
338         crd_infd = in_fd;
339         crd_outfd = out_fd;
340         result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
341         if (decompress_error)
342                 result = 1;
343         return result;
344 }