2 * Compressed rom filesystem for Linux.
4 * Copyright (C) 1999 Linus Torvalds.
6 * This file is released under the GPL.
10 * These are the VFS interfaces to the compressed rom filesystem.
11 * The actual compression is based on zlib, see the other files.
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/module.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/slab.h>
28 #include <linux/vfs.h>
29 #include <linux/mutex.h>
30 #include <uapi/linux/cramfs_fs.h>
31 #include <linux/uaccess.h>
36 * cramfs super-block data in memory
38 struct cramfs_sb_info
{
44 void *linear_virt_addr
;
45 resource_size_t linear_phys_addr
;
46 size_t mtd_point_size
;
49 static inline struct cramfs_sb_info
*CRAMFS_SB(struct super_block
*sb
)
54 static const struct super_operations cramfs_ops
;
55 static const struct inode_operations cramfs_dir_inode_operations
;
56 static const struct file_operations cramfs_directory_operations
;
57 static const struct file_operations cramfs_physmem_fops
;
58 static const struct address_space_operations cramfs_aops
;
60 static DEFINE_MUTEX(read_mutex
);
63 /* These macros may change in future, to provide better st_ino semantics. */
64 #define OFFSET(x) ((x)->i_ino)
66 static unsigned long cramino(const struct cramfs_inode
*cino
, unsigned int offset
)
74 * The file mode test fixes buggy mkcramfs implementations where
75 * cramfs_inode->offset is set to a non zero value for entries
76 * which did not contain data, like devices node and fifos.
78 switch (cino
->mode
& S_IFMT
) {
82 return cino
->offset
<< 2;
89 static struct inode
*get_cramfs_inode(struct super_block
*sb
,
90 const struct cramfs_inode
*cramfs_inode
, unsigned int offset
)
93 static struct timespec zerotime
;
95 inode
= iget_locked(sb
, cramino(cramfs_inode
, offset
));
97 return ERR_PTR(-ENOMEM
);
98 if (!(inode
->i_state
& I_NEW
))
101 switch (cramfs_inode
->mode
& S_IFMT
) {
103 inode
->i_fop
= &generic_ro_fops
;
104 inode
->i_data
.a_ops
= &cramfs_aops
;
105 if (IS_ENABLED(CONFIG_CRAMFS_MTD
) &&
106 CRAMFS_SB(sb
)->flags
& CRAMFS_FLAG_EXT_BLOCK_POINTERS
&&
107 CRAMFS_SB(sb
)->linear_phys_addr
)
108 inode
->i_fop
= &cramfs_physmem_fops
;
111 inode
->i_op
= &cramfs_dir_inode_operations
;
112 inode
->i_fop
= &cramfs_directory_operations
;
115 inode
->i_op
= &page_symlink_inode_operations
;
116 inode_nohighmem(inode
);
117 inode
->i_data
.a_ops
= &cramfs_aops
;
120 init_special_inode(inode
, cramfs_inode
->mode
,
121 old_decode_dev(cramfs_inode
->size
));
124 inode
->i_mode
= cramfs_inode
->mode
;
125 i_uid_write(inode
, cramfs_inode
->uid
);
126 i_gid_write(inode
, cramfs_inode
->gid
);
128 /* if the lower 2 bits are zero, the inode contains data */
129 if (!(inode
->i_ino
& 3)) {
130 inode
->i_size
= cramfs_inode
->size
;
131 inode
->i_blocks
= (cramfs_inode
->size
- 1) / 512 + 1;
134 /* Struct copy intentional */
135 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= zerotime
;
136 /* inode->i_nlink is left 1 - arguably wrong for directories,
137 but it's the best we can do without reading the directory
138 contents. 1 yields the right result in GNU find, even
139 without -noleaf option. */
141 unlock_new_inode(inode
);
147 * We have our own block cache: don't fill up the buffer cache
148 * with the rom-image, because the way the filesystem is set
149 * up the accesses should be fairly regular and cached in the
150 * page cache and dentry tree anyway..
152 * This also acts as a way to guarantee contiguous areas of up to
153 * BLKS_PER_BUF*PAGE_SIZE, so that the caller doesn't need to
154 * worry about end-of-buffer issues even when decompressing a full
157 * Note: This is all optimized away at compile time when
158 * CONFIG_CRAMFS_BLOCKDEV=n.
160 #define READ_BUFFERS (2)
161 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
162 #define NEXT_BUFFER(_ix) ((_ix) ^ 1)
165 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
166 * data that takes up more space than the original and with unlucky
169 #define BLKS_PER_BUF_SHIFT (2)
170 #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT)
171 #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_SIZE)
173 static unsigned char read_buffers
[READ_BUFFERS
][BUFFER_SIZE
];
174 static unsigned buffer_blocknr
[READ_BUFFERS
];
175 static struct super_block
*buffer_dev
[READ_BUFFERS
];
176 static int next_buffer
;
179 * Populate our block cache and return a pointer to it.
181 static void *cramfs_blkdev_read(struct super_block
*sb
, unsigned int offset
,
184 struct address_space
*mapping
= sb
->s_bdev
->bd_inode
->i_mapping
;
185 struct page
*pages
[BLKS_PER_BUF
];
186 unsigned i
, blocknr
, buffer
;
187 unsigned long devsize
;
192 blocknr
= offset
>> PAGE_SHIFT
;
193 offset
&= PAGE_SIZE
- 1;
195 /* Check if an existing buffer already has the data.. */
196 for (i
= 0; i
< READ_BUFFERS
; i
++) {
197 unsigned int blk_offset
;
199 if (buffer_dev
[i
] != sb
)
201 if (blocknr
< buffer_blocknr
[i
])
203 blk_offset
= (blocknr
- buffer_blocknr
[i
]) << PAGE_SHIFT
;
204 blk_offset
+= offset
;
205 if (blk_offset
+ len
> BUFFER_SIZE
)
207 return read_buffers
[i
] + blk_offset
;
210 devsize
= mapping
->host
->i_size
>> PAGE_SHIFT
;
212 /* Ok, read in BLKS_PER_BUF pages completely first. */
213 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
214 struct page
*page
= NULL
;
216 if (blocknr
+ i
< devsize
) {
217 page
= read_mapping_page(mapping
, blocknr
+ i
, NULL
);
218 /* synchronous error? */
225 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
226 struct page
*page
= pages
[i
];
229 wait_on_page_locked(page
);
230 if (!PageUptodate(page
)) {
231 /* asynchronous error */
238 buffer
= next_buffer
;
239 next_buffer
= NEXT_BUFFER(buffer
);
240 buffer_blocknr
[buffer
] = blocknr
;
241 buffer_dev
[buffer
] = sb
;
243 data
= read_buffers
[buffer
];
244 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
245 struct page
*page
= pages
[i
];
248 memcpy(data
, kmap(page
), PAGE_SIZE
);
252 memset(data
, 0, PAGE_SIZE
);
255 return read_buffers
[buffer
] + offset
;
259 * Return a pointer to the linearly addressed cramfs image in memory.
261 static void *cramfs_direct_read(struct super_block
*sb
, unsigned int offset
,
264 struct cramfs_sb_info
*sbi
= CRAMFS_SB(sb
);
268 if (len
> sbi
->size
|| offset
> sbi
->size
- len
)
269 return page_address(ZERO_PAGE(0));
270 return sbi
->linear_virt_addr
+ offset
;
274 * Returns a pointer to a buffer containing at least LEN bytes of
275 * filesystem starting at byte offset OFFSET into the filesystem.
277 static void *cramfs_read(struct super_block
*sb
, unsigned int offset
,
280 struct cramfs_sb_info
*sbi
= CRAMFS_SB(sb
);
282 if (IS_ENABLED(CONFIG_CRAMFS_MTD
) && sbi
->linear_virt_addr
)
283 return cramfs_direct_read(sb
, offset
, len
);
284 else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV
))
285 return cramfs_blkdev_read(sb
, offset
, len
);
291 * For a mapping to be possible, we need a range of uncompressed and
292 * contiguous blocks. Return the offset for the first block and number of
293 * valid blocks for which that is true, or zero otherwise.
295 static u32
cramfs_get_block_range(struct inode
*inode
, u32 pgoff
, u32
*pages
)
297 struct cramfs_sb_info
*sbi
= CRAMFS_SB(inode
->i_sb
);
299 u32
*blockptrs
, first_block_addr
;
302 * We can dereference memory directly here as this code may be
303 * reached only when there is a direct filesystem image mapping
304 * available in memory.
306 blockptrs
= (u32
*)(sbi
->linear_virt_addr
+ OFFSET(inode
) + pgoff
* 4);
307 first_block_addr
= blockptrs
[0] & ~CRAMFS_BLK_FLAGS
;
310 u32 block_off
= i
* (PAGE_SIZE
>> CRAMFS_BLK_DIRECT_PTR_SHIFT
);
311 u32 expect
= (first_block_addr
+ block_off
) |
312 CRAMFS_BLK_FLAG_DIRECT_PTR
|
313 CRAMFS_BLK_FLAG_UNCOMPRESSED
;
314 if (blockptrs
[i
] != expect
) {
315 pr_debug("range: block %d/%d got %#x expects %#x\n",
316 pgoff
+i
, pgoff
+ *pages
- 1,
317 blockptrs
[i
], expect
);
322 } while (++i
< *pages
);
325 return first_block_addr
<< CRAMFS_BLK_DIRECT_PTR_SHIFT
;
331 * Return true if the last page of a file in the filesystem image contains
332 * some other data that doesn't belong to that file. It is assumed that the
333 * last block is CRAMFS_BLK_FLAG_DIRECT_PTR | CRAMFS_BLK_FLAG_UNCOMPRESSED
334 * (verified by cramfs_get_block_range() and directly accessible in memory.
336 static bool cramfs_last_page_is_shared(struct inode
*inode
)
338 struct cramfs_sb_info
*sbi
= CRAMFS_SB(inode
->i_sb
);
339 u32 partial
, last_page
, blockaddr
, *blockptrs
;
342 partial
= offset_in_page(inode
->i_size
);
345 last_page
= inode
->i_size
>> PAGE_SHIFT
;
346 blockptrs
= (u32
*)(sbi
->linear_virt_addr
+ OFFSET(inode
));
347 blockaddr
= blockptrs
[last_page
] & ~CRAMFS_BLK_FLAGS
;
348 blockaddr
<<= CRAMFS_BLK_DIRECT_PTR_SHIFT
;
349 tail_data
= sbi
->linear_virt_addr
+ blockaddr
+ partial
;
350 return memchr_inv(tail_data
, 0, PAGE_SIZE
- partial
) ? true : false;
353 static int cramfs_physmem_mmap(struct file
*file
, struct vm_area_struct
*vma
)
355 struct inode
*inode
= file_inode(file
);
356 struct cramfs_sb_info
*sbi
= CRAMFS_SB(inode
->i_sb
);
357 unsigned int pages
, max_pages
, offset
;
358 unsigned long address
, pgoff
= vma
->vm_pgoff
;
359 char *bailout_reason
;
362 ret
= generic_file_readonly_mmap(file
, vma
);
367 * Now try to pre-populate ptes for this vma with a direct
368 * mapping avoiding memory allocation when possible.
371 /* Could COW work here? */
372 bailout_reason
= "vma is writable";
373 if (vma
->vm_flags
& VM_WRITE
)
376 max_pages
= (inode
->i_size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
377 bailout_reason
= "beyond file limit";
378 if (pgoff
>= max_pages
)
380 pages
= min(vma_pages(vma
), max_pages
- pgoff
);
382 offset
= cramfs_get_block_range(inode
, pgoff
, &pages
);
383 bailout_reason
= "unsuitable block layout";
386 address
= sbi
->linear_phys_addr
+ offset
;
387 bailout_reason
= "data is not page aligned";
388 if (!PAGE_ALIGNED(address
))
391 /* Don't map the last page if it contains some other data */
392 if (pgoff
+ pages
== max_pages
&& cramfs_last_page_is_shared(inode
)) {
393 pr_debug("mmap: %s: last page is shared\n",
394 file_dentry(file
)->d_name
.name
);
399 bailout_reason
= "no suitable block remaining";
403 if (pages
== vma_pages(vma
)) {
405 * The entire vma is mappable. remap_pfn_range() will
406 * make it distinguishable from a non-direct mapping
407 * in /proc/<pid>/maps by substituting the file offset
408 * with the actual physical address.
410 ret
= remap_pfn_range(vma
, vma
->vm_start
, address
>> PAGE_SHIFT
,
411 pages
* PAGE_SIZE
, vma
->vm_page_prot
);
414 * Let's create a mixed map if we can't map it all.
415 * The normal paging machinery will take care of the
416 * unpopulated ptes via cramfs_readpage().
419 vma
->vm_flags
|= VM_MIXEDMAP
;
420 for (i
= 0; i
< pages
&& !ret
; i
++) {
421 unsigned long off
= i
* PAGE_SIZE
;
422 pfn_t pfn
= phys_to_pfn_t(address
+ off
, PFN_DEV
);
423 ret
= vm_insert_mixed(vma
, vma
->vm_start
+ off
, pfn
);
428 pr_debug("mapped %s[%lu] at 0x%08lx (%u/%lu pages) "
429 "to vma 0x%08lx, page_prot 0x%llx\n",
430 file_dentry(file
)->d_name
.name
, pgoff
,
431 address
, pages
, vma_pages(vma
), vma
->vm_start
,
432 (unsigned long long)pgprot_val(vma
->vm_page_prot
));
436 pr_debug("%s[%lu]: direct mmap impossible: %s\n",
437 file_dentry(file
)->d_name
.name
, pgoff
, bailout_reason
);
438 /* Didn't manage any direct map, but normal paging is still possible */
442 #else /* CONFIG_MMU */
444 static int cramfs_physmem_mmap(struct file
*file
, struct vm_area_struct
*vma
)
446 return vma
->vm_flags
& (VM_SHARED
| VM_MAYSHARE
) ? 0 : -ENOSYS
;
449 static unsigned long cramfs_physmem_get_unmapped_area(struct file
*file
,
450 unsigned long addr
, unsigned long len
,
451 unsigned long pgoff
, unsigned long flags
)
453 struct inode
*inode
= file_inode(file
);
454 struct super_block
*sb
= inode
->i_sb
;
455 struct cramfs_sb_info
*sbi
= CRAMFS_SB(sb
);
456 unsigned int pages
, block_pages
, max_pages
, offset
;
458 pages
= (len
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
459 max_pages
= (inode
->i_size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
460 if (pgoff
>= max_pages
|| pages
> max_pages
- pgoff
)
463 offset
= cramfs_get_block_range(inode
, pgoff
, &block_pages
);
464 if (!offset
|| block_pages
!= pages
)
466 addr
= sbi
->linear_phys_addr
+ offset
;
467 pr_debug("get_unmapped for %s ofs %#lx siz %lu at 0x%08lx\n",
468 file_dentry(file
)->d_name
.name
, pgoff
*PAGE_SIZE
, len
, addr
);
472 static unsigned int cramfs_physmem_mmap_capabilities(struct file
*file
)
474 return NOMMU_MAP_COPY
| NOMMU_MAP_DIRECT
|
475 NOMMU_MAP_READ
| NOMMU_MAP_EXEC
;
478 #endif /* CONFIG_MMU */
480 static const struct file_operations cramfs_physmem_fops
= {
481 .llseek
= generic_file_llseek
,
482 .read_iter
= generic_file_read_iter
,
483 .splice_read
= generic_file_splice_read
,
484 .mmap
= cramfs_physmem_mmap
,
486 .get_unmapped_area
= cramfs_physmem_get_unmapped_area
,
487 .mmap_capabilities
= cramfs_physmem_mmap_capabilities
,
491 static void cramfs_kill_sb(struct super_block
*sb
)
493 struct cramfs_sb_info
*sbi
= CRAMFS_SB(sb
);
495 if (IS_ENABLED(CCONFIG_CRAMFS_MTD
) && sb
->s_mtd
) {
496 if (sbi
&& sbi
->mtd_point_size
)
497 mtd_unpoint(sb
->s_mtd
, 0, sbi
->mtd_point_size
);
499 } else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV
) && sb
->s_bdev
) {
500 kill_block_super(sb
);
505 static int cramfs_remount(struct super_block
*sb
, int *flags
, char *data
)
512 static int cramfs_read_super(struct super_block
*sb
,
513 struct cramfs_super
*super
, int silent
)
515 struct cramfs_sb_info
*sbi
= CRAMFS_SB(sb
);
516 unsigned long root_offset
;
518 /* We don't know the real size yet */
519 sbi
->size
= PAGE_SIZE
;
521 /* Read the first block and get the superblock from it */
522 mutex_lock(&read_mutex
);
523 memcpy(super
, cramfs_read(sb
, 0, sizeof(*super
)), sizeof(*super
));
524 mutex_unlock(&read_mutex
);
526 /* Do sanity checks on the superblock */
527 if (super
->magic
!= CRAMFS_MAGIC
) {
528 /* check for wrong endianness */
529 if (super
->magic
== CRAMFS_MAGIC_WEND
) {
531 pr_err("wrong endianness\n");
535 /* check at 512 byte offset */
536 mutex_lock(&read_mutex
);
538 cramfs_read(sb
, 512, sizeof(*super
)),
540 mutex_unlock(&read_mutex
);
541 if (super
->magic
!= CRAMFS_MAGIC
) {
542 if (super
->magic
== CRAMFS_MAGIC_WEND
&& !silent
)
543 pr_err("wrong endianness\n");
545 pr_err("wrong magic\n");
550 /* get feature flags first */
551 if (super
->flags
& ~CRAMFS_SUPPORTED_FLAGS
) {
552 pr_err("unsupported filesystem features\n");
556 /* Check that the root inode is in a sane state */
557 if (!S_ISDIR(super
->root
.mode
)) {
558 pr_err("root is not a directory\n");
561 /* correct strange, hard-coded permissions of mkcramfs */
562 super
->root
.mode
|= 0555;
564 root_offset
= super
->root
.offset
<< 2;
565 if (super
->flags
& CRAMFS_FLAG_FSID_VERSION_2
) {
566 sbi
->size
= super
->size
;
567 sbi
->blocks
= super
->fsid
.blocks
;
568 sbi
->files
= super
->fsid
.files
;
574 sbi
->magic
= super
->magic
;
575 sbi
->flags
= super
->flags
;
576 if (root_offset
== 0)
577 pr_info("empty filesystem");
578 else if (!(super
->flags
& CRAMFS_FLAG_SHIFTED_ROOT_OFFSET
) &&
579 ((root_offset
!= sizeof(struct cramfs_super
)) &&
580 (root_offset
!= 512 + sizeof(struct cramfs_super
))))
582 pr_err("bad root offset %lu\n", root_offset
);
589 static int cramfs_finalize_super(struct super_block
*sb
,
590 struct cramfs_inode
*cramfs_root
)
594 /* Set it all up.. */
595 sb
->s_flags
|= SB_RDONLY
;
596 sb
->s_op
= &cramfs_ops
;
597 root
= get_cramfs_inode(sb
, cramfs_root
, 0);
599 return PTR_ERR(root
);
600 sb
->s_root
= d_make_root(root
);
606 static int cramfs_blkdev_fill_super(struct super_block
*sb
, void *data
,
609 struct cramfs_sb_info
*sbi
;
610 struct cramfs_super super
;
613 sbi
= kzalloc(sizeof(struct cramfs_sb_info
), GFP_KERNEL
);
618 /* Invalidate the read buffers on mount: think disk change.. */
619 for (i
= 0; i
< READ_BUFFERS
; i
++)
620 buffer_blocknr
[i
] = -1;
622 err
= cramfs_read_super(sb
, &super
, silent
);
625 return cramfs_finalize_super(sb
, &super
.root
);
628 static int cramfs_mtd_fill_super(struct super_block
*sb
, void *data
,
631 struct cramfs_sb_info
*sbi
;
632 struct cramfs_super super
;
635 sbi
= kzalloc(sizeof(struct cramfs_sb_info
), GFP_KERNEL
);
640 /* Map only one page for now. Will remap it when fs size is known. */
641 err
= mtd_point(sb
->s_mtd
, 0, PAGE_SIZE
, &sbi
->mtd_point_size
,
642 &sbi
->linear_virt_addr
, &sbi
->linear_phys_addr
);
643 if (err
|| sbi
->mtd_point_size
!= PAGE_SIZE
) {
644 pr_err("unable to get direct memory access to mtd:%s\n",
646 return err
? : -ENODATA
;
649 pr_info("checking physical address %pap for linear cramfs image\n",
650 &sbi
->linear_phys_addr
);
651 err
= cramfs_read_super(sb
, &super
, silent
);
655 /* Remap the whole filesystem now */
656 pr_info("linear cramfs image on mtd:%s appears to be %lu KB in size\n",
657 sb
->s_mtd
->name
, sbi
->size
/1024);
658 mtd_unpoint(sb
->s_mtd
, 0, PAGE_SIZE
);
659 err
= mtd_point(sb
->s_mtd
, 0, sbi
->size
, &sbi
->mtd_point_size
,
660 &sbi
->linear_virt_addr
, &sbi
->linear_phys_addr
);
661 if (err
|| sbi
->mtd_point_size
!= sbi
->size
) {
662 pr_err("unable to get direct memory access to mtd:%s\n",
664 return err
? : -ENODATA
;
667 return cramfs_finalize_super(sb
, &super
.root
);
670 static int cramfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
672 struct super_block
*sb
= dentry
->d_sb
;
676 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
678 id
= huge_encode_dev(sb
->s_dev
);
680 buf
->f_type
= CRAMFS_MAGIC
;
681 buf
->f_bsize
= PAGE_SIZE
;
682 buf
->f_blocks
= CRAMFS_SB(sb
)->blocks
;
685 buf
->f_files
= CRAMFS_SB(sb
)->files
;
687 buf
->f_fsid
.val
[0] = (u32
)id
;
688 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
689 buf
->f_namelen
= CRAMFS_MAXPATHLEN
;
694 * Read a cramfs directory entry.
696 static int cramfs_readdir(struct file
*file
, struct dir_context
*ctx
)
698 struct inode
*inode
= file_inode(file
);
699 struct super_block
*sb
= inode
->i_sb
;
703 /* Offset within the thing. */
704 if (ctx
->pos
>= inode
->i_size
)
707 /* Directory entries are always 4-byte aligned */
711 buf
= kmalloc(CRAMFS_MAXPATHLEN
, GFP_KERNEL
);
715 while (offset
< inode
->i_size
) {
716 struct cramfs_inode
*de
;
717 unsigned long nextoffset
;
723 mutex_lock(&read_mutex
);
724 de
= cramfs_read(sb
, OFFSET(inode
) + offset
, sizeof(*de
)+CRAMFS_MAXPATHLEN
);
725 name
= (char *)(de
+1);
728 * Namelengths on disk are shifted by two
729 * and the name padded out to 4-byte boundaries
732 namelen
= de
->namelen
<< 2;
733 memcpy(buf
, name
, namelen
);
734 ino
= cramino(de
, OFFSET(inode
) + offset
);
736 mutex_unlock(&read_mutex
);
737 nextoffset
= offset
+ sizeof(*de
) + namelen
;
747 if (!dir_emit(ctx
, buf
, namelen
, ino
, mode
>> 12))
750 ctx
->pos
= offset
= nextoffset
;
757 * Lookup and fill in the inode data..
759 static struct dentry
*cramfs_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
761 unsigned int offset
= 0;
762 struct inode
*inode
= NULL
;
765 mutex_lock(&read_mutex
);
766 sorted
= CRAMFS_SB(dir
->i_sb
)->flags
& CRAMFS_FLAG_SORTED_DIRS
;
767 while (offset
< dir
->i_size
) {
768 struct cramfs_inode
*de
;
771 int dir_off
= OFFSET(dir
) + offset
;
773 de
= cramfs_read(dir
->i_sb
, dir_off
, sizeof(*de
)+CRAMFS_MAXPATHLEN
);
774 name
= (char *)(de
+1);
776 /* Try to take advantage of sorted directories */
777 if (sorted
&& (dentry
->d_name
.name
[0] < name
[0]))
780 namelen
= de
->namelen
<< 2;
781 offset
+= sizeof(*de
) + namelen
;
783 /* Quick check that the name is roughly the right length */
784 if (((dentry
->d_name
.len
+ 3) & ~3) != namelen
)
789 inode
= ERR_PTR(-EIO
);
796 if (namelen
!= dentry
->d_name
.len
)
798 retval
= memcmp(dentry
->d_name
.name
, name
, namelen
);
802 inode
= get_cramfs_inode(dir
->i_sb
, de
, dir_off
);
805 /* else (retval < 0) */
810 mutex_unlock(&read_mutex
);
812 return ERR_CAST(inode
);
813 d_add(dentry
, inode
);
817 static int cramfs_readpage(struct file
*file
, struct page
*page
)
819 struct inode
*inode
= page
->mapping
->host
;
824 maxblock
= (inode
->i_size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
828 if (page
->index
< maxblock
) {
829 struct super_block
*sb
= inode
->i_sb
;
830 u32 blkptr_offset
= OFFSET(inode
) + page
->index
* 4;
831 u32 block_ptr
, block_start
, block_len
;
832 bool uncompressed
, direct
;
834 mutex_lock(&read_mutex
);
835 block_ptr
= *(u32
*) cramfs_read(sb
, blkptr_offset
, 4);
836 uncompressed
= (block_ptr
& CRAMFS_BLK_FLAG_UNCOMPRESSED
);
837 direct
= (block_ptr
& CRAMFS_BLK_FLAG_DIRECT_PTR
);
838 block_ptr
&= ~CRAMFS_BLK_FLAGS
;
842 * The block pointer is an absolute start pointer,
843 * shifted by 2 bits. The size is included in the
844 * first 2 bytes of the data block when compressed,
845 * or PAGE_SIZE otherwise.
847 block_start
= block_ptr
<< CRAMFS_BLK_DIRECT_PTR_SHIFT
;
849 block_len
= PAGE_SIZE
;
850 /* if last block: cap to file length */
851 if (page
->index
== maxblock
- 1)
853 offset_in_page(inode
->i_size
);
856 cramfs_read(sb
, block_start
, 2);
861 * The block pointer indicates one past the end of
862 * the current block (start of next block). If this
863 * is the first block then it starts where the block
864 * pointer table ends, otherwise its start comes
865 * from the previous block's pointer.
867 block_start
= OFFSET(inode
) + maxblock
* 4;
869 block_start
= *(u32
*)
870 cramfs_read(sb
, blkptr_offset
- 4, 4);
871 /* Beware... previous ptr might be a direct ptr */
872 if (unlikely(block_start
& CRAMFS_BLK_FLAG_DIRECT_PTR
)) {
873 /* See comments on earlier code. */
874 u32 prev_start
= block_start
;
875 block_start
= prev_start
& ~CRAMFS_BLK_FLAGS
;
876 block_start
<<= CRAMFS_BLK_DIRECT_PTR_SHIFT
;
877 if (prev_start
& CRAMFS_BLK_FLAG_UNCOMPRESSED
) {
878 block_start
+= PAGE_SIZE
;
881 cramfs_read(sb
, block_start
, 2);
882 block_start
+= 2 + block_len
;
885 block_start
&= ~CRAMFS_BLK_FLAGS
;
886 block_len
= block_ptr
- block_start
;
891 else if (unlikely(block_len
> 2*PAGE_SIZE
||
892 (uncompressed
&& block_len
> PAGE_SIZE
))) {
893 mutex_unlock(&read_mutex
);
894 pr_err("bad data blocksize %u\n", block_len
);
896 } else if (uncompressed
) {
898 cramfs_read(sb
, block_start
, block_len
),
900 bytes_filled
= block_len
;
902 bytes_filled
= cramfs_uncompress_block(pgdata
,
904 cramfs_read(sb
, block_start
, block_len
),
907 mutex_unlock(&read_mutex
);
908 if (unlikely(bytes_filled
< 0))
912 memset(pgdata
+ bytes_filled
, 0, PAGE_SIZE
- bytes_filled
);
913 flush_dcache_page(page
);
915 SetPageUptodate(page
);
921 ClearPageUptodate(page
);
927 static const struct address_space_operations cramfs_aops
= {
928 .readpage
= cramfs_readpage
936 * A directory can only readdir
938 static const struct file_operations cramfs_directory_operations
= {
939 .llseek
= generic_file_llseek
,
940 .read
= generic_read_dir
,
941 .iterate_shared
= cramfs_readdir
,
944 static const struct inode_operations cramfs_dir_inode_operations
= {
945 .lookup
= cramfs_lookup
,
948 static const struct super_operations cramfs_ops
= {
949 .remount_fs
= cramfs_remount
,
950 .statfs
= cramfs_statfs
,
953 static struct dentry
*cramfs_mount(struct file_system_type
*fs_type
, int flags
,
954 const char *dev_name
, void *data
)
956 struct dentry
*ret
= ERR_PTR(-ENOPROTOOPT
);
958 if (IS_ENABLED(CONFIG_CRAMFS_MTD
)) {
959 ret
= mount_mtd(fs_type
, flags
, dev_name
, data
,
960 cramfs_mtd_fill_super
);
964 if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV
)) {
965 ret
= mount_bdev(fs_type
, flags
, dev_name
, data
,
966 cramfs_blkdev_fill_super
);
971 static struct file_system_type cramfs_fs_type
= {
972 .owner
= THIS_MODULE
,
974 .mount
= cramfs_mount
,
975 .kill_sb
= cramfs_kill_sb
,
976 .fs_flags
= FS_REQUIRES_DEV
,
978 MODULE_ALIAS_FS("cramfs");
980 static int __init
init_cramfs_fs(void)
984 rv
= cramfs_uncompress_init();
987 rv
= register_filesystem(&cramfs_fs_type
);
989 cramfs_uncompress_exit();
993 static void __exit
exit_cramfs_fs(void)
995 cramfs_uncompress_exit();
996 unregister_filesystem(&cramfs_fs_type
);
999 module_init(init_cramfs_fs
)
1000 module_exit(exit_cramfs_fs
)
1001 MODULE_LICENSE("GPL");