1 | /* |
2 | * Compressed rom filesystem for Linux. |
3 | * |
4 | * Copyright (C) 1999 Linus Torvalds. |
5 | * |
6 | * This file is released under the GPL. |
7 | */ |
8 | |
9 | /* |
10 | * These are the VFS interfaces to the compressed rom filesystem. |
11 | * The actual compression is based on zlib, see the other files. |
12 | */ |
13 | |
14 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
15 | |
16 | #include <linux/module.h> |
17 | #include <linux/fs.h> |
18 | #include <linux/file.h> |
19 | #include <linux/pagemap.h> |
20 | #include <linux/pfn_t.h> |
21 | #include <linux/ramfs.h> |
22 | #include <linux/init.h> |
23 | #include <linux/string.h> |
24 | #include <linux/blkdev.h> |
25 | #include <linux/mtd/mtd.h> |
26 | #include <linux/mtd/super.h> |
27 | #include <linux/fs_context.h> |
28 | #include <linux/slab.h> |
29 | #include <linux/vfs.h> |
30 | #include <linux/mutex.h> |
31 | #include <uapi/linux/cramfs_fs.h> |
32 | #include <linux/uaccess.h> |
33 | |
34 | #include "internal.h" |
35 | |
36 | /* |
37 | * cramfs super-block data in memory |
38 | */ |
39 | struct cramfs_sb_info { |
40 | unsigned long magic; |
41 | unsigned long size; |
42 | unsigned long blocks; |
43 | unsigned long files; |
44 | unsigned long flags; |
45 | void *linear_virt_addr; |
46 | resource_size_t linear_phys_addr; |
47 | size_t mtd_point_size; |
48 | }; |
49 | |
50 | static inline struct cramfs_sb_info *CRAMFS_SB(struct super_block *sb) |
51 | { |
52 | return sb->s_fs_info; |
53 | } |
54 | |
55 | static const struct super_operations cramfs_ops; |
56 | static const struct inode_operations cramfs_dir_inode_operations; |
57 | static const struct file_operations cramfs_directory_operations; |
58 | static const struct file_operations cramfs_physmem_fops; |
59 | static const struct address_space_operations cramfs_aops; |
60 | |
61 | static DEFINE_MUTEX(read_mutex); |
62 | |
63 | |
64 | /* These macros may change in future, to provide better st_ino semantics. */ |
65 | #define OFFSET(x) ((x)->i_ino) |
66 | |
67 | static unsigned long cramino(const struct cramfs_inode *cino, unsigned int offset) |
68 | { |
69 | if (!cino->offset) |
70 | return offset + 1; |
71 | if (!cino->size) |
72 | return offset + 1; |
73 | |
74 | /* |
75 | * The file mode test fixes buggy mkcramfs implementations where |
76 | * cramfs_inode->offset is set to a non zero value for entries |
77 | * which did not contain data, like devices node and fifos. |
78 | */ |
79 | switch (cino->mode & S_IFMT) { |
80 | case S_IFREG: |
81 | case S_IFDIR: |
82 | case S_IFLNK: |
83 | return cino->offset << 2; |
84 | default: |
85 | break; |
86 | } |
87 | return offset + 1; |
88 | } |
89 | |
90 | static struct inode *get_cramfs_inode(struct super_block *sb, |
91 | const struct cramfs_inode *cramfs_inode, unsigned int offset) |
92 | { |
93 | struct inode *inode; |
94 | static struct timespec64 zerotime; |
95 | |
96 | inode = iget_locked(sb, cramino(cino: cramfs_inode, offset)); |
97 | if (!inode) |
98 | return ERR_PTR(error: -ENOMEM); |
99 | if (!(inode->i_state & I_NEW)) |
100 | return inode; |
101 | |
102 | switch (cramfs_inode->mode & S_IFMT) { |
103 | case S_IFREG: |
104 | inode->i_fop = &generic_ro_fops; |
105 | inode->i_data.a_ops = &cramfs_aops; |
106 | if (IS_ENABLED(CONFIG_CRAMFS_MTD) && |
107 | CRAMFS_SB(sb)->flags & CRAMFS_FLAG_EXT_BLOCK_POINTERS && |
108 | CRAMFS_SB(sb)->linear_phys_addr) |
109 | inode->i_fop = &cramfs_physmem_fops; |
110 | break; |
111 | case S_IFDIR: |
112 | inode->i_op = &cramfs_dir_inode_operations; |
113 | inode->i_fop = &cramfs_directory_operations; |
114 | break; |
115 | case S_IFLNK: |
116 | inode->i_op = &page_symlink_inode_operations; |
117 | inode_nohighmem(inode); |
118 | inode->i_data.a_ops = &cramfs_aops; |
119 | break; |
120 | default: |
121 | init_special_inode(inode, cramfs_inode->mode, |
122 | old_decode_dev(val: cramfs_inode->size)); |
123 | } |
124 | |
125 | inode->i_mode = cramfs_inode->mode; |
126 | i_uid_write(inode, uid: cramfs_inode->uid); |
127 | i_gid_write(inode, gid: cramfs_inode->gid); |
128 | |
129 | /* if the lower 2 bits are zero, the inode contains data */ |
130 | if (!(inode->i_ino & 3)) { |
131 | inode->i_size = cramfs_inode->size; |
132 | inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1; |
133 | } |
134 | |
135 | /* Struct copy intentional */ |
136 | inode_set_mtime_to_ts(inode, |
137 | ts: inode_set_atime_to_ts(inode, ts: inode_set_ctime_to_ts(inode, ts: zerotime))); |
138 | /* inode->i_nlink is left 1 - arguably wrong for directories, |
139 | but it's the best we can do without reading the directory |
140 | contents. 1 yields the right result in GNU find, even |
141 | without -noleaf option. */ |
142 | |
143 | unlock_new_inode(inode); |
144 | |
145 | return inode; |
146 | } |
147 | |
148 | /* |
149 | * We have our own block cache: don't fill up the buffer cache |
150 | * with the rom-image, because the way the filesystem is set |
151 | * up the accesses should be fairly regular and cached in the |
152 | * page cache and dentry tree anyway.. |
153 | * |
154 | * This also acts as a way to guarantee contiguous areas of up to |
155 | * BLKS_PER_BUF*PAGE_SIZE, so that the caller doesn't need to |
156 | * worry about end-of-buffer issues even when decompressing a full |
157 | * page cache. |
158 | * |
159 | * Note: This is all optimized away at compile time when |
160 | * CONFIG_CRAMFS_BLOCKDEV=n. |
161 | */ |
162 | #define READ_BUFFERS (2) |
163 | /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */ |
164 | #define NEXT_BUFFER(_ix) ((_ix) ^ 1) |
165 | |
166 | /* |
167 | * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed" |
168 | * data that takes up more space than the original and with unlucky |
169 | * alignment. |
170 | */ |
171 | #define BLKS_PER_BUF_SHIFT (2) |
172 | #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT) |
173 | #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_SIZE) |
174 | |
175 | static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE]; |
176 | static unsigned buffer_blocknr[READ_BUFFERS]; |
177 | static struct super_block *buffer_dev[READ_BUFFERS]; |
178 | static int next_buffer; |
179 | |
180 | /* |
181 | * Populate our block cache and return a pointer to it. |
182 | */ |
183 | static void *cramfs_blkdev_read(struct super_block *sb, unsigned int offset, |
184 | unsigned int len) |
185 | { |
186 | struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping; |
187 | struct file_ra_state ra = {}; |
188 | struct page *pages[BLKS_PER_BUF]; |
189 | unsigned i, blocknr, buffer; |
190 | unsigned long devsize; |
191 | char *data; |
192 | |
193 | if (!len) |
194 | return NULL; |
195 | blocknr = offset >> PAGE_SHIFT; |
196 | offset &= PAGE_SIZE - 1; |
197 | |
198 | /* Check if an existing buffer already has the data.. */ |
199 | for (i = 0; i < READ_BUFFERS; i++) { |
200 | unsigned int blk_offset; |
201 | |
202 | if (buffer_dev[i] != sb) |
203 | continue; |
204 | if (blocknr < buffer_blocknr[i]) |
205 | continue; |
206 | blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_SHIFT; |
207 | blk_offset += offset; |
208 | if (blk_offset > BUFFER_SIZE || |
209 | blk_offset + len > BUFFER_SIZE) |
210 | continue; |
211 | return read_buffers[i] + blk_offset; |
212 | } |
213 | |
214 | devsize = bdev_nr_bytes(bdev: sb->s_bdev) >> PAGE_SHIFT; |
215 | |
216 | /* Ok, read in BLKS_PER_BUF pages completely first. */ |
217 | file_ra_state_init(ra: &ra, mapping); |
218 | page_cache_sync_readahead(mapping, ra: &ra, NULL, index: blocknr, BLKS_PER_BUF); |
219 | |
220 | for (i = 0; i < BLKS_PER_BUF; i++) { |
221 | struct page *page = NULL; |
222 | |
223 | if (blocknr + i < devsize) { |
224 | page = read_mapping_page(mapping, index: blocknr + i, NULL); |
225 | /* synchronous error? */ |
226 | if (IS_ERR(ptr: page)) |
227 | page = NULL; |
228 | } |
229 | pages[i] = page; |
230 | } |
231 | |
232 | buffer = next_buffer; |
233 | next_buffer = NEXT_BUFFER(buffer); |
234 | buffer_blocknr[buffer] = blocknr; |
235 | buffer_dev[buffer] = sb; |
236 | |
237 | data = read_buffers[buffer]; |
238 | for (i = 0; i < BLKS_PER_BUF; i++) { |
239 | struct page *page = pages[i]; |
240 | |
241 | if (page) { |
242 | memcpy_from_page(to: data, page, offset: 0, PAGE_SIZE); |
243 | put_page(page); |
244 | } else |
245 | memset(data, 0, PAGE_SIZE); |
246 | data += PAGE_SIZE; |
247 | } |
248 | return read_buffers[buffer] + offset; |
249 | } |
250 | |
251 | /* |
252 | * Return a pointer to the linearly addressed cramfs image in memory. |
253 | */ |
254 | static void *cramfs_direct_read(struct super_block *sb, unsigned int offset, |
255 | unsigned int len) |
256 | { |
257 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb); |
258 | |
259 | if (!len) |
260 | return NULL; |
261 | if (len > sbi->size || offset > sbi->size - len) |
262 | return page_address(ZERO_PAGE(0)); |
263 | return sbi->linear_virt_addr + offset; |
264 | } |
265 | |
266 | /* |
267 | * Returns a pointer to a buffer containing at least LEN bytes of |
268 | * filesystem starting at byte offset OFFSET into the filesystem. |
269 | */ |
270 | static void *cramfs_read(struct super_block *sb, unsigned int offset, |
271 | unsigned int len) |
272 | { |
273 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb); |
274 | |
275 | if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sbi->linear_virt_addr) |
276 | return cramfs_direct_read(sb, offset, len); |
277 | else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) |
278 | return cramfs_blkdev_read(sb, offset, len); |
279 | else |
280 | return NULL; |
281 | } |
282 | |
283 | /* |
284 | * For a mapping to be possible, we need a range of uncompressed and |
285 | * contiguous blocks. Return the offset for the first block and number of |
286 | * valid blocks for which that is true, or zero otherwise. |
287 | */ |
288 | static u32 cramfs_get_block_range(struct inode *inode, u32 pgoff, u32 *pages) |
289 | { |
290 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb: inode->i_sb); |
291 | int i; |
292 | u32 *blockptrs, first_block_addr; |
293 | |
294 | /* |
295 | * We can dereference memory directly here as this code may be |
296 | * reached only when there is a direct filesystem image mapping |
297 | * available in memory. |
298 | */ |
299 | blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode) + pgoff * 4); |
300 | first_block_addr = blockptrs[0] & ~CRAMFS_BLK_FLAGS; |
301 | i = 0; |
302 | do { |
303 | u32 block_off = i * (PAGE_SIZE >> CRAMFS_BLK_DIRECT_PTR_SHIFT); |
304 | u32 expect = (first_block_addr + block_off) | |
305 | CRAMFS_BLK_FLAG_DIRECT_PTR | |
306 | CRAMFS_BLK_FLAG_UNCOMPRESSED; |
307 | if (blockptrs[i] != expect) { |
308 | pr_debug("range: block %d/%d got %#x expects %#x\n" , |
309 | pgoff+i, pgoff + *pages - 1, |
310 | blockptrs[i], expect); |
311 | if (i == 0) |
312 | return 0; |
313 | break; |
314 | } |
315 | } while (++i < *pages); |
316 | |
317 | *pages = i; |
318 | return first_block_addr << CRAMFS_BLK_DIRECT_PTR_SHIFT; |
319 | } |
320 | |
321 | #ifdef CONFIG_MMU |
322 | |
323 | /* |
324 | * Return true if the last page of a file in the filesystem image contains |
325 | * some other data that doesn't belong to that file. It is assumed that the |
326 | * last block is CRAMFS_BLK_FLAG_DIRECT_PTR | CRAMFS_BLK_FLAG_UNCOMPRESSED |
327 | * (verified by cramfs_get_block_range() and directly accessible in memory. |
328 | */ |
329 | static bool cramfs_last_page_is_shared(struct inode *inode) |
330 | { |
331 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb: inode->i_sb); |
332 | u32 partial, last_page, blockaddr, *blockptrs; |
333 | char *tail_data; |
334 | |
335 | partial = offset_in_page(inode->i_size); |
336 | if (!partial) |
337 | return false; |
338 | last_page = inode->i_size >> PAGE_SHIFT; |
339 | blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode)); |
340 | blockaddr = blockptrs[last_page] & ~CRAMFS_BLK_FLAGS; |
341 | blockaddr <<= CRAMFS_BLK_DIRECT_PTR_SHIFT; |
342 | tail_data = sbi->linear_virt_addr + blockaddr + partial; |
343 | return memchr_inv(p: tail_data, c: 0, PAGE_SIZE - partial) ? true : false; |
344 | } |
345 | |
346 | static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma) |
347 | { |
348 | struct inode *inode = file_inode(f: file); |
349 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb: inode->i_sb); |
350 | unsigned int pages, max_pages, offset; |
351 | unsigned long address, pgoff = vma->vm_pgoff; |
352 | char *bailout_reason; |
353 | int ret; |
354 | |
355 | ret = generic_file_readonly_mmap(file, vma); |
356 | if (ret) |
357 | return ret; |
358 | |
359 | /* |
360 | * Now try to pre-populate ptes for this vma with a direct |
361 | * mapping avoiding memory allocation when possible. |
362 | */ |
363 | |
364 | /* Could COW work here? */ |
365 | bailout_reason = "vma is writable" ; |
366 | if (vma->vm_flags & VM_WRITE) |
367 | goto bailout; |
368 | |
369 | max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; |
370 | bailout_reason = "beyond file limit" ; |
371 | if (pgoff >= max_pages) |
372 | goto bailout; |
373 | pages = min(vma_pages(vma), max_pages - pgoff); |
374 | |
375 | offset = cramfs_get_block_range(inode, pgoff, pages: &pages); |
376 | bailout_reason = "unsuitable block layout" ; |
377 | if (!offset) |
378 | goto bailout; |
379 | address = sbi->linear_phys_addr + offset; |
380 | bailout_reason = "data is not page aligned" ; |
381 | if (!PAGE_ALIGNED(address)) |
382 | goto bailout; |
383 | |
384 | /* Don't map the last page if it contains some other data */ |
385 | if (pgoff + pages == max_pages && cramfs_last_page_is_shared(inode)) { |
386 | pr_debug("mmap: %pD: last page is shared\n" , file); |
387 | pages--; |
388 | } |
389 | |
390 | if (!pages) { |
391 | bailout_reason = "no suitable block remaining" ; |
392 | goto bailout; |
393 | } |
394 | |
395 | if (pages == vma_pages(vma)) { |
396 | /* |
397 | * The entire vma is mappable. remap_pfn_range() will |
398 | * make it distinguishable from a non-direct mapping |
399 | * in /proc/<pid>/maps by substituting the file offset |
400 | * with the actual physical address. |
401 | */ |
402 | ret = remap_pfn_range(vma, addr: vma->vm_start, pfn: address >> PAGE_SHIFT, |
403 | size: pages * PAGE_SIZE, vma->vm_page_prot); |
404 | } else { |
405 | /* |
406 | * Let's create a mixed map if we can't map it all. |
407 | * The normal paging machinery will take care of the |
408 | * unpopulated ptes via cramfs_read_folio(). |
409 | */ |
410 | int i; |
411 | vm_flags_set(vma, VM_MIXEDMAP); |
412 | for (i = 0; i < pages && !ret; i++) { |
413 | vm_fault_t vmf; |
414 | unsigned long off = i * PAGE_SIZE; |
415 | pfn_t pfn = phys_to_pfn_t(addr: address + off, PFN_DEV); |
416 | vmf = vmf_insert_mixed(vma, addr: vma->vm_start + off, pfn); |
417 | if (vmf & VM_FAULT_ERROR) |
418 | ret = vm_fault_to_errno(vm_fault: vmf, foll_flags: 0); |
419 | } |
420 | } |
421 | |
422 | if (!ret) |
423 | pr_debug("mapped %pD[%lu] at 0x%08lx (%u/%lu pages) " |
424 | "to vma 0x%08lx, page_prot 0x%llx\n" , file, |
425 | pgoff, address, pages, vma_pages(vma), vma->vm_start, |
426 | (unsigned long long)pgprot_val(vma->vm_page_prot)); |
427 | return ret; |
428 | |
429 | bailout: |
430 | pr_debug("%pD[%lu]: direct mmap impossible: %s\n" , |
431 | file, pgoff, bailout_reason); |
432 | /* Didn't manage any direct map, but normal paging is still possible */ |
433 | return 0; |
434 | } |
435 | |
436 | #else /* CONFIG_MMU */ |
437 | |
438 | static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma) |
439 | { |
440 | return is_nommu_shared_mapping(vma->vm_flags) ? 0 : -ENOSYS; |
441 | } |
442 | |
443 | static unsigned long cramfs_physmem_get_unmapped_area(struct file *file, |
444 | unsigned long addr, unsigned long len, |
445 | unsigned long pgoff, unsigned long flags) |
446 | { |
447 | struct inode *inode = file_inode(file); |
448 | struct super_block *sb = inode->i_sb; |
449 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb); |
450 | unsigned int pages, block_pages, max_pages, offset; |
451 | |
452 | pages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT; |
453 | max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; |
454 | if (pgoff >= max_pages || pages > max_pages - pgoff) |
455 | return -EINVAL; |
456 | block_pages = pages; |
457 | offset = cramfs_get_block_range(inode, pgoff, &block_pages); |
458 | if (!offset || block_pages != pages) |
459 | return -ENOSYS; |
460 | addr = sbi->linear_phys_addr + offset; |
461 | pr_debug("get_unmapped for %pD ofs %#lx siz %lu at 0x%08lx\n" , |
462 | file, pgoff*PAGE_SIZE, len, addr); |
463 | return addr; |
464 | } |
465 | |
466 | static unsigned int cramfs_physmem_mmap_capabilities(struct file *file) |
467 | { |
468 | return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | |
469 | NOMMU_MAP_READ | NOMMU_MAP_EXEC; |
470 | } |
471 | |
472 | #endif /* CONFIG_MMU */ |
473 | |
474 | static const struct file_operations cramfs_physmem_fops = { |
475 | .llseek = generic_file_llseek, |
476 | .read_iter = generic_file_read_iter, |
477 | .splice_read = filemap_splice_read, |
478 | .mmap = cramfs_physmem_mmap, |
479 | #ifndef CONFIG_MMU |
480 | .get_unmapped_area = cramfs_physmem_get_unmapped_area, |
481 | .mmap_capabilities = cramfs_physmem_mmap_capabilities, |
482 | #endif |
483 | }; |
484 | |
485 | static void cramfs_kill_sb(struct super_block *sb) |
486 | { |
487 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb); |
488 | |
489 | generic_shutdown_super(sb); |
490 | |
491 | if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sb->s_mtd) { |
492 | if (sbi && sbi->mtd_point_size) |
493 | mtd_unpoint(mtd: sb->s_mtd, from: 0, len: sbi->mtd_point_size); |
494 | put_mtd_device(mtd: sb->s_mtd); |
495 | sb->s_mtd = NULL; |
496 | } else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV) && sb->s_bdev) { |
497 | sync_blockdev(bdev: sb->s_bdev); |
498 | bdev_release(handle: sb->s_bdev_handle); |
499 | } |
500 | kfree(objp: sbi); |
501 | } |
502 | |
503 | static int cramfs_reconfigure(struct fs_context *fc) |
504 | { |
505 | sync_filesystem(fc->root->d_sb); |
506 | fc->sb_flags |= SB_RDONLY; |
507 | return 0; |
508 | } |
509 | |
510 | static int cramfs_read_super(struct super_block *sb, struct fs_context *fc, |
511 | struct cramfs_super *super) |
512 | { |
513 | struct cramfs_sb_info *sbi = CRAMFS_SB(sb); |
514 | unsigned long root_offset; |
515 | bool silent = fc->sb_flags & SB_SILENT; |
516 | |
517 | /* We don't know the real size yet */ |
518 | sbi->size = PAGE_SIZE; |
519 | |
520 | /* Read the first block and get the superblock from it */ |
521 | mutex_lock(&read_mutex); |
522 | memcpy(super, cramfs_read(sb, 0, sizeof(*super)), sizeof(*super)); |
523 | mutex_unlock(lock: &read_mutex); |
524 | |
525 | /* Do sanity checks on the superblock */ |
526 | if (super->magic != CRAMFS_MAGIC) { |
527 | /* check for wrong endianness */ |
528 | if (super->magic == CRAMFS_MAGIC_WEND) { |
529 | if (!silent) |
530 | errorfc(fc, "wrong endianness" ); |
531 | return -EINVAL; |
532 | } |
533 | |
534 | /* check at 512 byte offset */ |
535 | mutex_lock(&read_mutex); |
536 | memcpy(super, |
537 | cramfs_read(sb, 512, sizeof(*super)), |
538 | sizeof(*super)); |
539 | mutex_unlock(lock: &read_mutex); |
540 | if (super->magic != CRAMFS_MAGIC) { |
541 | if (super->magic == CRAMFS_MAGIC_WEND && !silent) |
542 | errorfc(fc, "wrong endianness" ); |
543 | else if (!silent) |
544 | errorfc(fc, "wrong magic" ); |
545 | return -EINVAL; |
546 | } |
547 | } |
548 | |
549 | /* get feature flags first */ |
550 | if (super->flags & ~CRAMFS_SUPPORTED_FLAGS) { |
551 | errorfc(fc, "unsupported filesystem features" ); |
552 | return -EINVAL; |
553 | } |
554 | |
555 | /* Check that the root inode is in a sane state */ |
556 | if (!S_ISDIR(super->root.mode)) { |
557 | errorfc(fc, "root is not a directory" ); |
558 | return -EINVAL; |
559 | } |
560 | /* correct strange, hard-coded permissions of mkcramfs */ |
561 | super->root.mode |= 0555; |
562 | |
563 | root_offset = super->root.offset << 2; |
564 | if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) { |
565 | sbi->size = super->size; |
566 | sbi->blocks = super->fsid.blocks; |
567 | sbi->files = super->fsid.files; |
568 | } else { |
569 | sbi->size = 1<<28; |
570 | sbi->blocks = 0; |
571 | sbi->files = 0; |
572 | } |
573 | sbi->magic = super->magic; |
574 | sbi->flags = super->flags; |
575 | if (root_offset == 0) |
576 | infofc(fc, "empty filesystem" ); |
577 | else if (!(super->flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) && |
578 | ((root_offset != sizeof(struct cramfs_super)) && |
579 | (root_offset != 512 + sizeof(struct cramfs_super)))) |
580 | { |
581 | errorfc(fc, "bad root offset %lu" , root_offset); |
582 | return -EINVAL; |
583 | } |
584 | |
585 | return 0; |
586 | } |
587 | |
588 | static int cramfs_finalize_super(struct super_block *sb, |
589 | struct cramfs_inode *cramfs_root) |
590 | { |
591 | struct inode *root; |
592 | |
593 | /* Set it all up.. */ |
594 | sb->s_flags |= SB_RDONLY; |
595 | sb->s_time_min = 0; |
596 | sb->s_time_max = 0; |
597 | sb->s_op = &cramfs_ops; |
598 | root = get_cramfs_inode(sb, cramfs_inode: cramfs_root, offset: 0); |
599 | if (IS_ERR(ptr: root)) |
600 | return PTR_ERR(ptr: root); |
601 | sb->s_root = d_make_root(root); |
602 | if (!sb->s_root) |
603 | return -ENOMEM; |
604 | return 0; |
605 | } |
606 | |
607 | static int cramfs_blkdev_fill_super(struct super_block *sb, struct fs_context *fc) |
608 | { |
609 | struct cramfs_sb_info *sbi; |
610 | struct cramfs_super super; |
611 | int i, err; |
612 | |
613 | sbi = kzalloc(size: sizeof(struct cramfs_sb_info), GFP_KERNEL); |
614 | if (!sbi) |
615 | return -ENOMEM; |
616 | sb->s_fs_info = sbi; |
617 | |
618 | /* Invalidate the read buffers on mount: think disk change.. */ |
619 | for (i = 0; i < READ_BUFFERS; i++) |
620 | buffer_blocknr[i] = -1; |
621 | |
622 | err = cramfs_read_super(sb, fc, super: &super); |
623 | if (err) |
624 | return err; |
625 | return cramfs_finalize_super(sb, cramfs_root: &super.root); |
626 | } |
627 | |
628 | static int cramfs_mtd_fill_super(struct super_block *sb, struct fs_context *fc) |
629 | { |
630 | struct cramfs_sb_info *sbi; |
631 | struct cramfs_super super; |
632 | int err; |
633 | |
634 | sbi = kzalloc(size: sizeof(struct cramfs_sb_info), GFP_KERNEL); |
635 | if (!sbi) |
636 | return -ENOMEM; |
637 | sb->s_fs_info = sbi; |
638 | |
639 | /* Map only one page for now. Will remap it when fs size is known. */ |
640 | err = mtd_point(mtd: sb->s_mtd, from: 0, PAGE_SIZE, retlen: &sbi->mtd_point_size, |
641 | virt: &sbi->linear_virt_addr, phys: &sbi->linear_phys_addr); |
642 | if (err || sbi->mtd_point_size != PAGE_SIZE) { |
643 | pr_err("unable to get direct memory access to mtd:%s\n" , |
644 | sb->s_mtd->name); |
645 | return err ? : -ENODATA; |
646 | } |
647 | |
648 | pr_info("checking physical address %pap for linear cramfs image\n" , |
649 | &sbi->linear_phys_addr); |
650 | err = cramfs_read_super(sb, fc, super: &super); |
651 | if (err) |
652 | return err; |
653 | |
654 | /* Remap the whole filesystem now */ |
655 | pr_info("linear cramfs image on mtd:%s appears to be %lu KB in size\n" , |
656 | sb->s_mtd->name, sbi->size/1024); |
657 | mtd_unpoint(mtd: sb->s_mtd, from: 0, PAGE_SIZE); |
658 | err = mtd_point(mtd: sb->s_mtd, from: 0, len: sbi->size, retlen: &sbi->mtd_point_size, |
659 | virt: &sbi->linear_virt_addr, phys: &sbi->linear_phys_addr); |
660 | if (err || sbi->mtd_point_size != sbi->size) { |
661 | pr_err("unable to get direct memory access to mtd:%s\n" , |
662 | sb->s_mtd->name); |
663 | return err ? : -ENODATA; |
664 | } |
665 | |
666 | return cramfs_finalize_super(sb, cramfs_root: &super.root); |
667 | } |
668 | |
669 | static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf) |
670 | { |
671 | struct super_block *sb = dentry->d_sb; |
672 | u64 id = 0; |
673 | |
674 | if (sb->s_bdev) |
675 | id = huge_encode_dev(dev: sb->s_bdev->bd_dev); |
676 | else if (sb->s_dev) |
677 | id = huge_encode_dev(dev: sb->s_dev); |
678 | |
679 | buf->f_type = CRAMFS_MAGIC; |
680 | buf->f_bsize = PAGE_SIZE; |
681 | buf->f_blocks = CRAMFS_SB(sb)->blocks; |
682 | buf->f_bfree = 0; |
683 | buf->f_bavail = 0; |
684 | buf->f_files = CRAMFS_SB(sb)->files; |
685 | buf->f_ffree = 0; |
686 | buf->f_fsid = u64_to_fsid(v: id); |
687 | buf->f_namelen = CRAMFS_MAXPATHLEN; |
688 | return 0; |
689 | } |
690 | |
691 | /* |
692 | * Read a cramfs directory entry. |
693 | */ |
694 | static int cramfs_readdir(struct file *file, struct dir_context *ctx) |
695 | { |
696 | struct inode *inode = file_inode(f: file); |
697 | struct super_block *sb = inode->i_sb; |
698 | char *buf; |
699 | unsigned int offset; |
700 | |
701 | /* Offset within the thing. */ |
702 | if (ctx->pos >= inode->i_size) |
703 | return 0; |
704 | offset = ctx->pos; |
705 | /* Directory entries are always 4-byte aligned */ |
706 | if (offset & 3) |
707 | return -EINVAL; |
708 | |
709 | buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL); |
710 | if (!buf) |
711 | return -ENOMEM; |
712 | |
713 | while (offset < inode->i_size) { |
714 | struct cramfs_inode *de; |
715 | unsigned long nextoffset; |
716 | char *name; |
717 | ino_t ino; |
718 | umode_t mode; |
719 | int namelen; |
720 | |
721 | mutex_lock(&read_mutex); |
722 | de = cramfs_read(sb, OFFSET(inode) + offset, len: sizeof(*de)+CRAMFS_MAXPATHLEN); |
723 | name = (char *)(de+1); |
724 | |
725 | /* |
726 | * Namelengths on disk are shifted by two |
727 | * and the name padded out to 4-byte boundaries |
728 | * with zeroes. |
729 | */ |
730 | namelen = de->namelen << 2; |
731 | memcpy(buf, name, namelen); |
732 | ino = cramino(cino: de, OFFSET(inode) + offset); |
733 | mode = de->mode; |
734 | mutex_unlock(lock: &read_mutex); |
735 | nextoffset = offset + sizeof(*de) + namelen; |
736 | for (;;) { |
737 | if (!namelen) { |
738 | kfree(objp: buf); |
739 | return -EIO; |
740 | } |
741 | if (buf[namelen-1]) |
742 | break; |
743 | namelen--; |
744 | } |
745 | if (!dir_emit(ctx, name: buf, namelen, ino, type: mode >> 12)) |
746 | break; |
747 | |
748 | ctx->pos = offset = nextoffset; |
749 | } |
750 | kfree(objp: buf); |
751 | return 0; |
752 | } |
753 | |
754 | /* |
755 | * Lookup and fill in the inode data.. |
756 | */ |
757 | static struct dentry *cramfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) |
758 | { |
759 | unsigned int offset = 0; |
760 | struct inode *inode = NULL; |
761 | int sorted; |
762 | |
763 | mutex_lock(&read_mutex); |
764 | sorted = CRAMFS_SB(sb: dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS; |
765 | while (offset < dir->i_size) { |
766 | struct cramfs_inode *de; |
767 | char *name; |
768 | int namelen, retval; |
769 | int dir_off = OFFSET(dir) + offset; |
770 | |
771 | de = cramfs_read(sb: dir->i_sb, offset: dir_off, len: sizeof(*de)+CRAMFS_MAXPATHLEN); |
772 | name = (char *)(de+1); |
773 | |
774 | /* Try to take advantage of sorted directories */ |
775 | if (sorted && (dentry->d_name.name[0] < name[0])) |
776 | break; |
777 | |
778 | namelen = de->namelen << 2; |
779 | offset += sizeof(*de) + namelen; |
780 | |
781 | /* Quick check that the name is roughly the right length */ |
782 | if (((dentry->d_name.len + 3) & ~3) != namelen) |
783 | continue; |
784 | |
785 | for (;;) { |
786 | if (!namelen) { |
787 | inode = ERR_PTR(error: -EIO); |
788 | goto out; |
789 | } |
790 | if (name[namelen-1]) |
791 | break; |
792 | namelen--; |
793 | } |
794 | if (namelen != dentry->d_name.len) |
795 | continue; |
796 | retval = memcmp(p: dentry->d_name.name, q: name, size: namelen); |
797 | if (retval > 0) |
798 | continue; |
799 | if (!retval) { |
800 | inode = get_cramfs_inode(sb: dir->i_sb, cramfs_inode: de, offset: dir_off); |
801 | break; |
802 | } |
803 | /* else (retval < 0) */ |
804 | if (sorted) |
805 | break; |
806 | } |
807 | out: |
808 | mutex_unlock(lock: &read_mutex); |
809 | return d_splice_alias(inode, dentry); |
810 | } |
811 | |
812 | static int cramfs_read_folio(struct file *file, struct folio *folio) |
813 | { |
814 | struct page *page = &folio->page; |
815 | struct inode *inode = page->mapping->host; |
816 | u32 maxblock; |
817 | int bytes_filled; |
818 | void *pgdata; |
819 | |
820 | maxblock = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; |
821 | bytes_filled = 0; |
822 | pgdata = kmap_local_page(page); |
823 | |
824 | if (page->index < maxblock) { |
825 | struct super_block *sb = inode->i_sb; |
826 | u32 blkptr_offset = OFFSET(inode) + page->index * 4; |
827 | u32 block_ptr, block_start, block_len; |
828 | bool uncompressed, direct; |
829 | |
830 | mutex_lock(&read_mutex); |
831 | block_ptr = *(u32 *) cramfs_read(sb, offset: blkptr_offset, len: 4); |
832 | uncompressed = (block_ptr & CRAMFS_BLK_FLAG_UNCOMPRESSED); |
833 | direct = (block_ptr & CRAMFS_BLK_FLAG_DIRECT_PTR); |
834 | block_ptr &= ~CRAMFS_BLK_FLAGS; |
835 | |
836 | if (direct) { |
837 | /* |
838 | * The block pointer is an absolute start pointer, |
839 | * shifted by 2 bits. The size is included in the |
840 | * first 2 bytes of the data block when compressed, |
841 | * or PAGE_SIZE otherwise. |
842 | */ |
843 | block_start = block_ptr << CRAMFS_BLK_DIRECT_PTR_SHIFT; |
844 | if (uncompressed) { |
845 | block_len = PAGE_SIZE; |
846 | /* if last block: cap to file length */ |
847 | if (page->index == maxblock - 1) |
848 | block_len = |
849 | offset_in_page(inode->i_size); |
850 | } else { |
851 | block_len = *(u16 *) |
852 | cramfs_read(sb, offset: block_start, len: 2); |
853 | block_start += 2; |
854 | } |
855 | } else { |
856 | /* |
857 | * The block pointer indicates one past the end of |
858 | * the current block (start of next block). If this |
859 | * is the first block then it starts where the block |
860 | * pointer table ends, otherwise its start comes |
861 | * from the previous block's pointer. |
862 | */ |
863 | block_start = OFFSET(inode) + maxblock * 4; |
864 | if (page->index) |
865 | block_start = *(u32 *) |
866 | cramfs_read(sb, offset: blkptr_offset - 4, len: 4); |
867 | /* Beware... previous ptr might be a direct ptr */ |
868 | if (unlikely(block_start & CRAMFS_BLK_FLAG_DIRECT_PTR)) { |
869 | /* See comments on earlier code. */ |
870 | u32 prev_start = block_start; |
871 | block_start = prev_start & ~CRAMFS_BLK_FLAGS; |
872 | block_start <<= CRAMFS_BLK_DIRECT_PTR_SHIFT; |
873 | if (prev_start & CRAMFS_BLK_FLAG_UNCOMPRESSED) { |
874 | block_start += PAGE_SIZE; |
875 | } else { |
876 | block_len = *(u16 *) |
877 | cramfs_read(sb, offset: block_start, len: 2); |
878 | block_start += 2 + block_len; |
879 | } |
880 | } |
881 | block_start &= ~CRAMFS_BLK_FLAGS; |
882 | block_len = block_ptr - block_start; |
883 | } |
884 | |
885 | if (block_len == 0) |
886 | ; /* hole */ |
887 | else if (unlikely(block_len > 2*PAGE_SIZE || |
888 | (uncompressed && block_len > PAGE_SIZE))) { |
889 | mutex_unlock(lock: &read_mutex); |
890 | pr_err("bad data blocksize %u\n" , block_len); |
891 | goto err; |
892 | } else if (uncompressed) { |
893 | memcpy(pgdata, |
894 | cramfs_read(sb, block_start, block_len), |
895 | block_len); |
896 | bytes_filled = block_len; |
897 | } else { |
898 | bytes_filled = cramfs_uncompress_block(dst: pgdata, |
899 | PAGE_SIZE, |
900 | src: cramfs_read(sb, offset: block_start, len: block_len), |
901 | srclen: block_len); |
902 | } |
903 | mutex_unlock(lock: &read_mutex); |
904 | if (unlikely(bytes_filled < 0)) |
905 | goto err; |
906 | } |
907 | |
908 | memset(pgdata + bytes_filled, 0, PAGE_SIZE - bytes_filled); |
909 | flush_dcache_page(page); |
910 | kunmap_local(pgdata); |
911 | SetPageUptodate(page); |
912 | unlock_page(page); |
913 | return 0; |
914 | |
915 | err: |
916 | kunmap_local(pgdata); |
917 | ClearPageUptodate(page); |
918 | SetPageError(page); |
919 | unlock_page(page); |
920 | return 0; |
921 | } |
922 | |
923 | static const struct address_space_operations cramfs_aops = { |
924 | .read_folio = cramfs_read_folio |
925 | }; |
926 | |
927 | /* |
928 | * Our operations: |
929 | */ |
930 | |
931 | /* |
932 | * A directory can only readdir |
933 | */ |
934 | static const struct file_operations cramfs_directory_operations = { |
935 | .llseek = generic_file_llseek, |
936 | .read = generic_read_dir, |
937 | .iterate_shared = cramfs_readdir, |
938 | }; |
939 | |
940 | static const struct inode_operations cramfs_dir_inode_operations = { |
941 | .lookup = cramfs_lookup, |
942 | }; |
943 | |
944 | static const struct super_operations cramfs_ops = { |
945 | .statfs = cramfs_statfs, |
946 | }; |
947 | |
948 | static int cramfs_get_tree(struct fs_context *fc) |
949 | { |
950 | int ret = -ENOPROTOOPT; |
951 | |
952 | if (IS_ENABLED(CONFIG_CRAMFS_MTD)) { |
953 | ret = get_tree_mtd(fc, fill_super: cramfs_mtd_fill_super); |
954 | if (!ret) |
955 | return 0; |
956 | } |
957 | if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) |
958 | ret = get_tree_bdev(fc, fill_super: cramfs_blkdev_fill_super); |
959 | return ret; |
960 | } |
961 | |
962 | static const struct fs_context_operations cramfs_context_ops = { |
963 | .get_tree = cramfs_get_tree, |
964 | .reconfigure = cramfs_reconfigure, |
965 | }; |
966 | |
967 | /* |
968 | * Set up the filesystem mount context. |
969 | */ |
970 | static int cramfs_init_fs_context(struct fs_context *fc) |
971 | { |
972 | fc->ops = &cramfs_context_ops; |
973 | return 0; |
974 | } |
975 | |
976 | static struct file_system_type cramfs_fs_type = { |
977 | .owner = THIS_MODULE, |
978 | .name = "cramfs" , |
979 | .init_fs_context = cramfs_init_fs_context, |
980 | .kill_sb = cramfs_kill_sb, |
981 | .fs_flags = FS_REQUIRES_DEV, |
982 | }; |
983 | MODULE_ALIAS_FS("cramfs" ); |
984 | |
985 | static int __init init_cramfs_fs(void) |
986 | { |
987 | int rv; |
988 | |
989 | rv = cramfs_uncompress_init(); |
990 | if (rv < 0) |
991 | return rv; |
992 | rv = register_filesystem(&cramfs_fs_type); |
993 | if (rv < 0) |
994 | cramfs_uncompress_exit(); |
995 | return rv; |
996 | } |
997 | |
998 | static void __exit exit_cramfs_fs(void) |
999 | { |
1000 | cramfs_uncompress_exit(); |
1001 | unregister_filesystem(&cramfs_fs_type); |
1002 | } |
1003 | |
1004 | module_init(init_cramfs_fs) |
1005 | module_exit(exit_cramfs_fs) |
1006 | MODULE_LICENSE("GPL" ); |
1007 | |