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/pagemap.h>
19 #include <linux/init.h>
20 #include <linux/string.h>
21 #include <linux/blkdev.h>
22 #include <linux/slab.h>
23 #include <linux/vfs.h>
24 #include <linux/mutex.h>
25 #include <uapi/linux/cramfs_fs.h>
26 #include <asm/uaccess.h>
31 * cramfs super-block data in memory
33 struct cramfs_sb_info
{
41 static inline struct cramfs_sb_info
*CRAMFS_SB(struct super_block
*sb
)
46 static const struct super_operations cramfs_ops
;
47 static const struct inode_operations cramfs_dir_inode_operations
;
48 static const struct file_operations cramfs_directory_operations
;
49 static const struct address_space_operations cramfs_aops
;
51 static DEFINE_MUTEX(read_mutex
);
54 /* These macros may change in future, to provide better st_ino semantics. */
55 #define OFFSET(x) ((x)->i_ino)
57 static unsigned long cramino(const struct cramfs_inode
*cino
, unsigned int offset
)
65 * The file mode test fixes buggy mkcramfs implementations where
66 * cramfs_inode->offset is set to a non zero value for entries
67 * which did not contain data, like devices node and fifos.
69 switch (cino
->mode
& S_IFMT
) {
73 return cino
->offset
<< 2;
80 static struct inode
*get_cramfs_inode(struct super_block
*sb
,
81 const struct cramfs_inode
*cramfs_inode
, unsigned int offset
)
84 static struct timespec zerotime
;
86 inode
= iget_locked(sb
, cramino(cramfs_inode
, offset
));
88 return ERR_PTR(-ENOMEM
);
89 if (!(inode
->i_state
& I_NEW
))
92 switch (cramfs_inode
->mode
& S_IFMT
) {
94 inode
->i_fop
= &generic_ro_fops
;
95 inode
->i_data
.a_ops
= &cramfs_aops
;
98 inode
->i_op
= &cramfs_dir_inode_operations
;
99 inode
->i_fop
= &cramfs_directory_operations
;
102 inode
->i_op
= &page_symlink_inode_operations
;
103 inode
->i_data
.a_ops
= &cramfs_aops
;
106 init_special_inode(inode
, cramfs_inode
->mode
,
107 old_decode_dev(cramfs_inode
->size
));
110 inode
->i_mode
= cramfs_inode
->mode
;
111 i_uid_write(inode
, cramfs_inode
->uid
);
112 i_gid_write(inode
, cramfs_inode
->gid
);
114 /* if the lower 2 bits are zero, the inode contains data */
115 if (!(inode
->i_ino
& 3)) {
116 inode
->i_size
= cramfs_inode
->size
;
117 inode
->i_blocks
= (cramfs_inode
->size
- 1) / 512 + 1;
120 /* Struct copy intentional */
121 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= zerotime
;
122 /* inode->i_nlink is left 1 - arguably wrong for directories,
123 but it's the best we can do without reading the directory
124 contents. 1 yields the right result in GNU find, even
125 without -noleaf option. */
127 unlock_new_inode(inode
);
133 * We have our own block cache: don't fill up the buffer cache
134 * with the rom-image, because the way the filesystem is set
135 * up the accesses should be fairly regular and cached in the
136 * page cache and dentry tree anyway..
138 * This also acts as a way to guarantee contiguous areas of up to
139 * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to
140 * worry about end-of-buffer issues even when decompressing a full
143 #define READ_BUFFERS (2)
144 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
145 #define NEXT_BUFFER(_ix) ((_ix) ^ 1)
148 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
149 * data that takes up more space than the original and with unlucky
152 #define BLKS_PER_BUF_SHIFT (2)
153 #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT)
154 #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_CACHE_SIZE)
156 static unsigned char read_buffers
[READ_BUFFERS
][BUFFER_SIZE
];
157 static unsigned buffer_blocknr
[READ_BUFFERS
];
158 static struct super_block
* buffer_dev
[READ_BUFFERS
];
159 static int next_buffer
;
162 * Returns a pointer to a buffer containing at least LEN bytes of
163 * filesystem starting at byte offset OFFSET into the filesystem.
165 static void *cramfs_read(struct super_block
*sb
, unsigned int offset
, unsigned int len
)
167 struct address_space
*mapping
= sb
->s_bdev
->bd_inode
->i_mapping
;
168 struct page
*pages
[BLKS_PER_BUF
];
169 unsigned i
, blocknr
, buffer
;
170 unsigned long devsize
;
175 blocknr
= offset
>> PAGE_CACHE_SHIFT
;
176 offset
&= PAGE_CACHE_SIZE
- 1;
178 /* Check if an existing buffer already has the data.. */
179 for (i
= 0; i
< READ_BUFFERS
; i
++) {
180 unsigned int blk_offset
;
182 if (buffer_dev
[i
] != sb
)
184 if (blocknr
< buffer_blocknr
[i
])
186 blk_offset
= (blocknr
- buffer_blocknr
[i
]) << PAGE_CACHE_SHIFT
;
187 blk_offset
+= offset
;
188 if (blk_offset
+ len
> BUFFER_SIZE
)
190 return read_buffers
[i
] + blk_offset
;
193 devsize
= mapping
->host
->i_size
>> PAGE_CACHE_SHIFT
;
195 /* Ok, read in BLKS_PER_BUF pages completely first. */
196 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
197 struct page
*page
= NULL
;
199 if (blocknr
+ i
< devsize
) {
200 page
= read_mapping_page(mapping
, blocknr
+ i
, NULL
);
201 /* synchronous error? */
208 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
209 struct page
*page
= pages
[i
];
211 wait_on_page_locked(page
);
212 if (!PageUptodate(page
)) {
213 /* asynchronous error */
214 page_cache_release(page
);
220 buffer
= next_buffer
;
221 next_buffer
= NEXT_BUFFER(buffer
);
222 buffer_blocknr
[buffer
] = blocknr
;
223 buffer_dev
[buffer
] = sb
;
225 data
= read_buffers
[buffer
];
226 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
227 struct page
*page
= pages
[i
];
229 memcpy(data
, kmap(page
), PAGE_CACHE_SIZE
);
231 page_cache_release(page
);
233 memset(data
, 0, PAGE_CACHE_SIZE
);
234 data
+= PAGE_CACHE_SIZE
;
236 return read_buffers
[buffer
] + offset
;
239 static void cramfs_kill_sb(struct super_block
*sb
)
241 struct cramfs_sb_info
*sbi
= CRAMFS_SB(sb
);
242 kill_block_super(sb
);
246 static int cramfs_remount(struct super_block
*sb
, int *flags
, char *data
)
253 static int cramfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
256 struct cramfs_super super
;
257 unsigned long root_offset
;
258 struct cramfs_sb_info
*sbi
;
261 sb
->s_flags
|= MS_RDONLY
;
263 sbi
= kzalloc(sizeof(struct cramfs_sb_info
), GFP_KERNEL
);
268 /* Invalidate the read buffers on mount: think disk change.. */
269 mutex_lock(&read_mutex
);
270 for (i
= 0; i
< READ_BUFFERS
; i
++)
271 buffer_blocknr
[i
] = -1;
273 /* Read the first block and get the superblock from it */
274 memcpy(&super
, cramfs_read(sb
, 0, sizeof(super
)), sizeof(super
));
275 mutex_unlock(&read_mutex
);
277 /* Do sanity checks on the superblock */
278 if (super
.magic
!= CRAMFS_MAGIC
) {
279 /* check for wrong endianness */
280 if (super
.magic
== CRAMFS_MAGIC_WEND
) {
282 pr_err("wrong endianness\n");
286 /* check at 512 byte offset */
287 mutex_lock(&read_mutex
);
288 memcpy(&super
, cramfs_read(sb
, 512, sizeof(super
)), sizeof(super
));
289 mutex_unlock(&read_mutex
);
290 if (super
.magic
!= CRAMFS_MAGIC
) {
291 if (super
.magic
== CRAMFS_MAGIC_WEND
&& !silent
)
292 pr_err("wrong endianness\n");
294 pr_err("wrong magic\n");
299 /* get feature flags first */
300 if (super
.flags
& ~CRAMFS_SUPPORTED_FLAGS
) {
301 pr_err("unsupported filesystem features\n");
305 /* Check that the root inode is in a sane state */
306 if (!S_ISDIR(super
.root
.mode
)) {
307 pr_err("root is not a directory\n");
310 /* correct strange, hard-coded permissions of mkcramfs */
311 super
.root
.mode
|= (S_IRUSR
| S_IXUSR
| S_IRGRP
| S_IXGRP
| S_IROTH
| S_IXOTH
);
313 root_offset
= super
.root
.offset
<< 2;
314 if (super
.flags
& CRAMFS_FLAG_FSID_VERSION_2
) {
315 sbi
->size
=super
.size
;
316 sbi
->blocks
=super
.fsid
.blocks
;
317 sbi
->files
=super
.fsid
.files
;
323 sbi
->magic
=super
.magic
;
324 sbi
->flags
=super
.flags
;
325 if (root_offset
== 0)
326 pr_info("empty filesystem");
327 else if (!(super
.flags
& CRAMFS_FLAG_SHIFTED_ROOT_OFFSET
) &&
328 ((root_offset
!= sizeof(struct cramfs_super
)) &&
329 (root_offset
!= 512 + sizeof(struct cramfs_super
))))
331 pr_err("bad root offset %lu\n", root_offset
);
335 /* Set it all up.. */
336 sb
->s_op
= &cramfs_ops
;
337 root
= get_cramfs_inode(sb
, &super
.root
, 0);
339 return PTR_ERR(root
);
340 sb
->s_root
= d_make_root(root
);
346 static int cramfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
348 struct super_block
*sb
= dentry
->d_sb
;
349 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
351 buf
->f_type
= CRAMFS_MAGIC
;
352 buf
->f_bsize
= PAGE_CACHE_SIZE
;
353 buf
->f_blocks
= CRAMFS_SB(sb
)->blocks
;
356 buf
->f_files
= CRAMFS_SB(sb
)->files
;
358 buf
->f_fsid
.val
[0] = (u32
)id
;
359 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
360 buf
->f_namelen
= CRAMFS_MAXPATHLEN
;
365 * Read a cramfs directory entry.
367 static int cramfs_readdir(struct file
*file
, struct dir_context
*ctx
)
369 struct inode
*inode
= file_inode(file
);
370 struct super_block
*sb
= inode
->i_sb
;
374 /* Offset within the thing. */
375 if (ctx
->pos
>= inode
->i_size
)
378 /* Directory entries are always 4-byte aligned */
382 buf
= kmalloc(CRAMFS_MAXPATHLEN
, GFP_KERNEL
);
386 while (offset
< inode
->i_size
) {
387 struct cramfs_inode
*de
;
388 unsigned long nextoffset
;
394 mutex_lock(&read_mutex
);
395 de
= cramfs_read(sb
, OFFSET(inode
) + offset
, sizeof(*de
)+CRAMFS_MAXPATHLEN
);
396 name
= (char *)(de
+1);
399 * Namelengths on disk are shifted by two
400 * and the name padded out to 4-byte boundaries
403 namelen
= de
->namelen
<< 2;
404 memcpy(buf
, name
, namelen
);
405 ino
= cramino(de
, OFFSET(inode
) + offset
);
407 mutex_unlock(&read_mutex
);
408 nextoffset
= offset
+ sizeof(*de
) + namelen
;
418 if (!dir_emit(ctx
, buf
, namelen
, ino
, mode
>> 12))
421 ctx
->pos
= offset
= nextoffset
;
428 * Lookup and fill in the inode data..
430 static struct dentry
* cramfs_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
432 unsigned int offset
= 0;
433 struct inode
*inode
= NULL
;
436 mutex_lock(&read_mutex
);
437 sorted
= CRAMFS_SB(dir
->i_sb
)->flags
& CRAMFS_FLAG_SORTED_DIRS
;
438 while (offset
< dir
->i_size
) {
439 struct cramfs_inode
*de
;
442 int dir_off
= OFFSET(dir
) + offset
;
444 de
= cramfs_read(dir
->i_sb
, dir_off
, sizeof(*de
)+CRAMFS_MAXPATHLEN
);
445 name
= (char *)(de
+1);
447 /* Try to take advantage of sorted directories */
448 if (sorted
&& (dentry
->d_name
.name
[0] < name
[0]))
451 namelen
= de
->namelen
<< 2;
452 offset
+= sizeof(*de
) + namelen
;
454 /* Quick check that the name is roughly the right length */
455 if (((dentry
->d_name
.len
+ 3) & ~3) != namelen
)
460 inode
= ERR_PTR(-EIO
);
467 if (namelen
!= dentry
->d_name
.len
)
469 retval
= memcmp(dentry
->d_name
.name
, name
, namelen
);
473 inode
= get_cramfs_inode(dir
->i_sb
, de
, dir_off
);
476 /* else (retval < 0) */
481 mutex_unlock(&read_mutex
);
483 return ERR_CAST(inode
);
484 d_add(dentry
, inode
);
488 static int cramfs_readpage(struct file
*file
, struct page
* page
)
490 struct inode
*inode
= page
->mapping
->host
;
495 maxblock
= (inode
->i_size
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
499 if (page
->index
< maxblock
) {
500 struct super_block
*sb
= inode
->i_sb
;
501 u32 blkptr_offset
= OFFSET(inode
) + page
->index
*4;
502 u32 start_offset
, compr_len
;
504 start_offset
= OFFSET(inode
) + maxblock
*4;
505 mutex_lock(&read_mutex
);
507 start_offset
= *(u32
*) cramfs_read(sb
, blkptr_offset
-4,
509 compr_len
= (*(u32
*) cramfs_read(sb
, blkptr_offset
, 4) -
511 mutex_unlock(&read_mutex
);
515 else if (unlikely(compr_len
> (PAGE_CACHE_SIZE
<< 1))) {
516 pr_err("bad compressed blocksize %u\n",
520 mutex_lock(&read_mutex
);
521 bytes_filled
= cramfs_uncompress_block(pgdata
,
523 cramfs_read(sb
, start_offset
, compr_len
),
525 mutex_unlock(&read_mutex
);
526 if (unlikely(bytes_filled
< 0))
531 memset(pgdata
+ bytes_filled
, 0, PAGE_CACHE_SIZE
- bytes_filled
);
532 flush_dcache_page(page
);
534 SetPageUptodate(page
);
540 ClearPageUptodate(page
);
546 static const struct address_space_operations cramfs_aops
= {
547 .readpage
= cramfs_readpage
555 * A directory can only readdir
557 static const struct file_operations cramfs_directory_operations
= {
558 .llseek
= generic_file_llseek
,
559 .read
= generic_read_dir
,
560 .iterate
= cramfs_readdir
,
563 static const struct inode_operations cramfs_dir_inode_operations
= {
564 .lookup
= cramfs_lookup
,
567 static const struct super_operations cramfs_ops
= {
568 .remount_fs
= cramfs_remount
,
569 .statfs
= cramfs_statfs
,
572 static struct dentry
*cramfs_mount(struct file_system_type
*fs_type
,
573 int flags
, const char *dev_name
, void *data
)
575 return mount_bdev(fs_type
, flags
, dev_name
, data
, cramfs_fill_super
);
578 static struct file_system_type cramfs_fs_type
= {
579 .owner
= THIS_MODULE
,
581 .mount
= cramfs_mount
,
582 .kill_sb
= cramfs_kill_sb
,
583 .fs_flags
= FS_REQUIRES_DEV
,
585 MODULE_ALIAS_FS("cramfs");
587 static int __init
init_cramfs_fs(void)
591 rv
= cramfs_uncompress_init();
594 rv
= register_filesystem(&cramfs_fs_type
);
596 cramfs_uncompress_exit();
600 static void __exit
exit_cramfs_fs(void)
602 cramfs_uncompress_exit();
603 unregister_filesystem(&cramfs_fs_type
);
606 module_init(init_cramfs_fs
)
607 module_exit(exit_cramfs_fs
)
608 MODULE_LICENSE("GPL");