1 // SPDX-License-Identifier: GPL-2.0
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 <uapi/linux/cramfs_fs.h>
8 #include <linux/initrd.h>
9 #include <linux/string.h>
10 #include <linux/string_choices.h>
11 #include <linux/slab.h>
12
13 #include "do_mounts.h"
14 #include "../fs/squashfs/squashfs_fs.h"
15
16 #include <linux/decompress/generic.h>
17
18 static struct file *in_file, *out_file;
19 static loff_t in_pos, out_pos;
20
prompt_ramdisk(char * str)21 static int __init prompt_ramdisk(char *str)
22 {
23 pr_warn("ignoring the deprecated prompt_ramdisk= option\n");
24 return 1;
25 }
26 __setup("prompt_ramdisk=", prompt_ramdisk);
27
28 int __initdata rd_image_start; /* starting block # of image */
29
ramdisk_start_setup(char * str)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(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 * squashfs
51 * gzip
52 * bzip2
53 * lzma
54 * xz
55 * lzo
56 * lz4
57 */
58 static int __init
identify_ramdisk_image(struct file * file,loff_t pos,decompress_fn * decompressor)59 identify_ramdisk_image(struct file *file, loff_t pos,
60 decompress_fn *decompressor)
61 {
62 const int size = 512;
63 struct minix_super_block *minixsb;
64 struct romfs_super_block *romfsb;
65 struct cramfs_super *cramfsb;
66 struct squashfs_super_block *squashfsb;
67 int nblocks = -1;
68 unsigned char *buf;
69 const char *compress_name;
70 unsigned long n;
71 int start_block = rd_image_start;
72
73 buf = kmalloc(size, GFP_KERNEL);
74 if (!buf)
75 return -ENOMEM;
76
77 minixsb = (struct minix_super_block *) buf;
78 romfsb = (struct romfs_super_block *) buf;
79 cramfsb = (struct cramfs_super *) buf;
80 squashfsb = (struct squashfs_super_block *) buf;
81 memset(buf, 0xe5, size);
82
83 /*
84 * Read block 0 to test for compressed kernel
85 */
86 pos = start_block * BLOCK_SIZE;
87 kernel_read(file, buf, size, &pos);
88
89 *decompressor = decompress_method(buf, size, &compress_name);
90 if (compress_name) {
91 printk(KERN_NOTICE "RAMDISK: %s image found at block %d\n",
92 compress_name, start_block);
93 if (!*decompressor)
94 printk(KERN_EMERG
95 "RAMDISK: %s decompressor not configured!\n",
96 compress_name);
97 nblocks = 0;
98 goto done;
99 }
100
101 /* romfs is at block zero too */
102 if (romfsb->word0 == ROMSB_WORD0 &&
103 romfsb->word1 == ROMSB_WORD1) {
104 printk(KERN_NOTICE
105 "RAMDISK: romfs filesystem found at block %d\n",
106 start_block);
107 nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;
108 goto done;
109 }
110
111 if (cramfsb->magic == CRAMFS_MAGIC) {
112 printk(KERN_NOTICE
113 "RAMDISK: cramfs filesystem found at block %d\n",
114 start_block);
115 nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
116 goto done;
117 }
118
119 /* squashfs is at block zero too */
120 if (le32_to_cpu(squashfsb->s_magic) == SQUASHFS_MAGIC) {
121 printk(KERN_NOTICE
122 "RAMDISK: squashfs filesystem found at block %d\n",
123 start_block);
124 nblocks = (le64_to_cpu(squashfsb->bytes_used) + BLOCK_SIZE - 1)
125 >> BLOCK_SIZE_BITS;
126 goto done;
127 }
128
129 /*
130 * Read 512 bytes further to check if cramfs is padded
131 */
132 pos = start_block * BLOCK_SIZE + 0x200;
133 kernel_read(file, buf, size, &pos);
134
135 if (cramfsb->magic == CRAMFS_MAGIC) {
136 printk(KERN_NOTICE
137 "RAMDISK: cramfs filesystem found at block %d\n",
138 start_block);
139 nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
140 goto done;
141 }
142
143 /*
144 * Read block 1 to test for minix and ext2 superblock
145 */
146 pos = (start_block + 1) * BLOCK_SIZE;
147 kernel_read(file, buf, size, &pos);
148
149 /* Try minix */
150 if (minixsb->s_magic == MINIX_SUPER_MAGIC ||
151 minixsb->s_magic == MINIX_SUPER_MAGIC2) {
152 printk(KERN_NOTICE
153 "RAMDISK: Minix filesystem found at block %d\n",
154 start_block);
155 nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;
156 goto done;
157 }
158
159 /* Try ext2 */
160 n = ext2_image_size(buf);
161 if (n) {
162 printk(KERN_NOTICE
163 "RAMDISK: ext2 filesystem found at block %d\n",
164 start_block);
165 nblocks = n;
166 goto done;
167 }
168
169 printk(KERN_NOTICE
170 "RAMDISK: Couldn't find valid RAM disk image starting at %d.\n",
171 start_block);
172
173 done:
174 kfree(buf);
175 return nblocks;
176 }
177
nr_blocks(struct file * file)178 static unsigned long nr_blocks(struct file *file)
179 {
180 struct inode *inode = file->f_mapping->host;
181
182 if (!S_ISBLK(inode->i_mode))
183 return 0;
184 return i_size_read(inode) >> 10;
185 }
186
rd_load_image(char * from)187 int __init rd_load_image(char *from)
188 {
189 int res = 0;
190 unsigned long rd_blocks, devblocks, nr_disks;
191 int nblocks, i;
192 char *buf = NULL;
193 unsigned short rotate = 0;
194 decompress_fn decompressor = NULL;
195 char rotator[4] = { '|' , '/' , '-' , '\\' };
196
197 out_file = filp_open("/dev/ram", O_RDWR, 0);
198 if (IS_ERR(out_file))
199 goto out;
200
201 in_file = filp_open(from, O_RDONLY, 0);
202 if (IS_ERR(in_file))
203 goto noclose_input;
204
205 in_pos = rd_image_start * BLOCK_SIZE;
206 nblocks = identify_ramdisk_image(in_file, in_pos, &decompressor);
207 if (nblocks < 0)
208 goto done;
209
210 if (nblocks == 0) {
211 if (crd_load(decompressor) == 0)
212 goto successful_load;
213 goto done;
214 }
215
216 /*
217 * NOTE NOTE: nblocks is not actually blocks but
218 * the number of kibibytes of data to load into a ramdisk.
219 */
220 rd_blocks = nr_blocks(out_file);
221 if (nblocks > rd_blocks) {
222 printk("RAMDISK: image too big! (%dKiB/%ldKiB)\n",
223 nblocks, rd_blocks);
224 goto done;
225 }
226
227 /*
228 * OK, time to copy in the data
229 */
230 if (strcmp(from, "/initrd.image") == 0)
231 devblocks = nblocks;
232 else
233 devblocks = nr_blocks(in_file);
234
235 if (devblocks == 0) {
236 printk(KERN_ERR "RAMDISK: could not determine device size\n");
237 goto done;
238 }
239
240 buf = kmalloc(BLOCK_SIZE, GFP_KERNEL);
241 if (!buf) {
242 printk(KERN_ERR "RAMDISK: could not allocate buffer\n");
243 goto done;
244 }
245
246 nr_disks = (nblocks - 1) / devblocks + 1;
247 pr_notice("RAMDISK: Loading %dKiB [%ld disk%s] into ram disk... ",
248 nblocks, nr_disks, str_plural(nr_disks));
249 for (i = 0; i < nblocks; i++) {
250 if (i && (i % devblocks == 0)) {
251 pr_cont("done disk #1.\n");
252 rotate = 0;
253 fput(in_file);
254 break;
255 }
256 kernel_read(in_file, buf, BLOCK_SIZE, &in_pos);
257 kernel_write(out_file, buf, BLOCK_SIZE, &out_pos);
258 if (!IS_ENABLED(CONFIG_S390) && !(i % 16)) {
259 pr_cont("%c\b", rotator[rotate & 0x3]);
260 rotate++;
261 }
262 }
263 pr_cont("done.\n");
264
265 successful_load:
266 res = 1;
267 done:
268 fput(in_file);
269 noclose_input:
270 fput(out_file);
271 out:
272 kfree(buf);
273 init_unlink("/dev/ram");
274 return res;
275 }
276
rd_load_disk(int n)277 int __init rd_load_disk(int n)
278 {
279 create_dev("/dev/root", ROOT_DEV);
280 create_dev("/dev/ram", MKDEV(RAMDISK_MAJOR, n));
281 return rd_load_image("/dev/root");
282 }
283
284 static int exit_code;
285 static int decompress_error;
286
compr_fill(void * buf,unsigned long len)287 static long __init compr_fill(void *buf, unsigned long len)
288 {
289 long r = kernel_read(in_file, buf, len, &in_pos);
290 if (r < 0)
291 printk(KERN_ERR "RAMDISK: error while reading compressed data");
292 else if (r == 0)
293 printk(KERN_ERR "RAMDISK: EOF while reading compressed data");
294 return r;
295 }
296
compr_flush(void * window,unsigned long outcnt)297 static long __init compr_flush(void *window, unsigned long outcnt)
298 {
299 long written = kernel_write(out_file, window, outcnt, &out_pos);
300 if (written != outcnt) {
301 if (decompress_error == 0)
302 printk(KERN_ERR
303 "RAMDISK: incomplete write (%ld != %ld)\n",
304 written, outcnt);
305 decompress_error = 1;
306 return -1;
307 }
308 return outcnt;
309 }
310
error(char * x)311 static void __init error(char *x)
312 {
313 printk(KERN_ERR "%s\n", x);
314 exit_code = 1;
315 decompress_error = 1;
316 }
317
crd_load(decompress_fn deco)318 static int __init crd_load(decompress_fn deco)
319 {
320 int result;
321
322 if (!deco) {
323 pr_emerg("Invalid ramdisk decompression routine. "
324 "Select appropriate config option.\n");
325 panic("Could not decompress initial ramdisk image.");
326 }
327
328 result = deco(NULL, 0, compr_fill, compr_flush, NULL, NULL, error);
329 if (decompress_error)
330 result = 1;
331 return result;
332 }
333