xref: /openbmc/linux/fs/cramfs/inode.c (revision 4365d0d6)
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 
CRAMFS_SB(struct super_block * sb)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 
cramino(const struct cramfs_inode * cino,unsigned int offset)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 
get_cramfs_inode(struct super_block * sb,const struct cramfs_inode * cramfs_inode,unsigned int offset)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(cramfs_inode, offset));
97 	if (!inode)
98 		return ERR_PTR(-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(cramfs_inode->size));
123 	}
124 
125 	inode->i_mode = cramfs_inode->mode;
126 	i_uid_write(inode, cramfs_inode->uid);
127 	i_gid_write(inode, 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->i_mtime = inode->i_atime = inode_set_ctime_to_ts(inode,
137 								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  */
cramfs_blkdev_read(struct super_block * sb,unsigned int offset,unsigned int len)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(sb->s_bdev) >> PAGE_SHIFT;
215 
216 	/* Ok, read in BLKS_PER_BUF pages completely first. */
217 	file_ra_state_init(&ra, mapping);
218 	page_cache_sync_readahead(mapping, &ra, NULL, 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, blocknr + i, NULL);
225 			/* synchronous error? */
226 			if (IS_ERR(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(data, page, 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  */
cramfs_direct_read(struct super_block * sb,unsigned int offset,unsigned int len)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  */
cramfs_read(struct super_block * sb,unsigned int offset,unsigned int len)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  */
cramfs_get_block_range(struct inode * inode,u32 pgoff,u32 * pages)288 static u32 cramfs_get_block_range(struct inode *inode, u32 pgoff, u32 *pages)
289 {
290 	struct cramfs_sb_info *sbi = CRAMFS_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  */
cramfs_last_page_is_shared(struct inode * inode)329 static bool cramfs_last_page_is_shared(struct inode *inode)
330 {
331 	struct cramfs_sb_info *sbi = CRAMFS_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(tail_data, 0, PAGE_SIZE - partial) ? true : false;
344 }
345 
cramfs_physmem_mmap(struct file * file,struct vm_area_struct * vma)346 static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma)
347 {
348 	struct inode *inode = file_inode(file);
349 	struct cramfs_sb_info *sbi = CRAMFS_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);
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, vma->vm_start, address >> PAGE_SHIFT,
403 				      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(address + off, PFN_DEV);
416 			vmf = vmf_insert_mixed(vma, vma->vm_start + off, pfn);
417 			if (vmf & VM_FAULT_ERROR)
418 				ret = vm_fault_to_errno(vmf, 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 
cramfs_physmem_mmap(struct file * file,struct vm_area_struct * vma)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 
cramfs_physmem_get_unmapped_area(struct file * file,unsigned long addr,unsigned long len,unsigned long pgoff,unsigned long flags)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 
cramfs_physmem_mmap_capabilities(struct file * file)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 
cramfs_kill_sb(struct super_block * sb)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(sb->s_mtd, 0, sbi->mtd_point_size);
494 		put_mtd_device(sb->s_mtd);
495 		sb->s_mtd = NULL;
496 	} else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV) && sb->s_bdev) {
497 		sync_blockdev(sb->s_bdev);
498 		bdev_release(sb->s_bdev_handle);
499 	}
500 	kfree(sbi);
501 }
502 
cramfs_reconfigure(struct fs_context * fc)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 
cramfs_read_super(struct super_block * sb,struct fs_context * fc,struct cramfs_super * super)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(&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(&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 
cramfs_finalize_super(struct super_block * sb,struct cramfs_inode * cramfs_root)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_root, 0);
599 	if (IS_ERR(root))
600 		return PTR_ERR(root);
601 	sb->s_root = d_make_root(root);
602 	if (!sb->s_root)
603 		return -ENOMEM;
604 	return 0;
605 }
606 
cramfs_blkdev_fill_super(struct super_block * sb,struct fs_context * fc)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(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);
623 	if (err)
624 		return err;
625 	return cramfs_finalize_super(sb, &super.root);
626 }
627 
cramfs_mtd_fill_super(struct super_block * sb,struct fs_context * fc)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(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(sb->s_mtd, 0, PAGE_SIZE, &sbi->mtd_point_size,
641 			&sbi->linear_virt_addr, &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);
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(sb->s_mtd, 0, PAGE_SIZE);
658 	err = mtd_point(sb->s_mtd, 0, sbi->size, &sbi->mtd_point_size,
659 			&sbi->linear_virt_addr, &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, &super.root);
667 }
668 
cramfs_statfs(struct dentry * dentry,struct kstatfs * buf)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(sb->s_bdev->bd_dev);
676 	else if (sb->s_dev)
677 		id = huge_encode_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(id);
687 	buf->f_namelen = CRAMFS_MAXPATHLEN;
688 	return 0;
689 }
690 
691 /*
692  * Read a cramfs directory entry.
693  */
cramfs_readdir(struct file * file,struct dir_context * ctx)694 static int cramfs_readdir(struct file *file, struct dir_context *ctx)
695 {
696 	struct inode *inode = file_inode(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, 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(de, OFFSET(inode) + offset);
733 		mode = de->mode;
734 		mutex_unlock(&read_mutex);
735 		nextoffset = offset + sizeof(*de) + namelen;
736 		for (;;) {
737 			if (!namelen) {
738 				kfree(buf);
739 				return -EIO;
740 			}
741 			if (buf[namelen-1])
742 				break;
743 			namelen--;
744 		}
745 		if (!dir_emit(ctx, buf, namelen, ino, mode >> 12))
746 			break;
747 
748 		ctx->pos = offset = nextoffset;
749 	}
750 	kfree(buf);
751 	return 0;
752 }
753 
754 /*
755  * Lookup and fill in the inode data..
756  */
cramfs_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)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(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(dir->i_sb, dir_off, 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(-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(dentry->d_name.name, name, namelen);
797 		if (retval > 0)
798 			continue;
799 		if (!retval) {
800 			inode = get_cramfs_inode(dir->i_sb, de, dir_off);
801 			break;
802 		}
803 		/* else (retval < 0) */
804 		if (sorted)
805 			break;
806 	}
807 out:
808 	mutex_unlock(&read_mutex);
809 	return d_splice_alias(inode, dentry);
810 }
811 
cramfs_read_folio(struct file * file,struct folio * folio)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, blkptr_offset, 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, block_start, 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, blkptr_offset - 4, 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, block_start, 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(&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(pgdata,
899 				 PAGE_SIZE,
900 				 cramfs_read(sb, block_start, block_len),
901 				 block_len);
902 		}
903 		mutex_unlock(&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 
cramfs_get_tree(struct fs_context * fc)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, cramfs_mtd_fill_super);
954 		if (!ret)
955 			return 0;
956 	}
957 	if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV))
958 		ret = get_tree_bdev(fc, 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  */
cramfs_init_fs_context(struct fs_context * fc)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 
init_cramfs_fs(void)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 
exit_cramfs_fs(void)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