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 #include <linux/module.h>
16 #include <linux/pagemap.h>
17 #include <linux/init.h>
18 #include <linux/string.h>
19 #include <linux/blkdev.h>
20 #include <linux/cramfs_fs.h>
21 #include <linux/slab.h>
22 #include <linux/cramfs_fs_sb.h>
23 #include <linux/buffer_head.h>
24 #include <linux/vfs.h>
25 #include <linux/mutex.h>
26 #include <asm/semaphore.h>
28 #include <asm/uaccess.h>
30 static struct super_operations cramfs_ops
;
31 static struct inode_operations cramfs_dir_inode_operations
;
32 static const struct file_operations cramfs_directory_operations
;
33 static const struct address_space_operations cramfs_aops
;
35 static DEFINE_MUTEX(read_mutex
);
38 /* These two macros may change in future, to provide better st_ino
40 #define CRAMINO(x) (((x)->offset && (x)->size)?(x)->offset<<2:1)
41 #define OFFSET(x) ((x)->i_ino)
44 static int cramfs_iget5_test(struct inode
*inode
, void *opaque
)
46 struct cramfs_inode
*cramfs_inode
= opaque
;
48 if (inode
->i_ino
!= CRAMINO(cramfs_inode
))
49 return 0; /* does not match */
51 if (inode
->i_ino
!= 1)
54 /* all empty directories, char, block, pipe, and sock, share inode #1 */
56 if ((inode
->i_mode
!= cramfs_inode
->mode
) ||
57 (inode
->i_gid
!= cramfs_inode
->gid
) ||
58 (inode
->i_uid
!= cramfs_inode
->uid
))
59 return 0; /* does not match */
61 if ((S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) &&
62 (inode
->i_rdev
!= old_decode_dev(cramfs_inode
->size
)))
63 return 0; /* does not match */
65 return 1; /* matches */
68 static int cramfs_iget5_set(struct inode
*inode
, void *opaque
)
70 static struct timespec zerotime
;
71 struct cramfs_inode
*cramfs_inode
= opaque
;
72 inode
->i_mode
= cramfs_inode
->mode
;
73 inode
->i_uid
= cramfs_inode
->uid
;
74 inode
->i_size
= cramfs_inode
->size
;
75 inode
->i_blocks
= (cramfs_inode
->size
- 1) / 512 + 1;
76 inode
->i_gid
= cramfs_inode
->gid
;
77 /* Struct copy intentional */
78 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= zerotime
;
79 inode
->i_ino
= CRAMINO(cramfs_inode
);
80 /* inode->i_nlink is left 1 - arguably wrong for directories,
81 but it's the best we can do without reading the directory
82 contents. 1 yields the right result in GNU find, even
83 without -noleaf option. */
84 if (S_ISREG(inode
->i_mode
)) {
85 inode
->i_fop
= &generic_ro_fops
;
86 inode
->i_data
.a_ops
= &cramfs_aops
;
87 } else if (S_ISDIR(inode
->i_mode
)) {
88 inode
->i_op
= &cramfs_dir_inode_operations
;
89 inode
->i_fop
= &cramfs_directory_operations
;
90 } else if (S_ISLNK(inode
->i_mode
)) {
91 inode
->i_op
= &page_symlink_inode_operations
;
92 inode
->i_data
.a_ops
= &cramfs_aops
;
96 init_special_inode(inode
, inode
->i_mode
,
97 old_decode_dev(cramfs_inode
->size
));
102 static struct inode
*get_cramfs_inode(struct super_block
*sb
,
103 struct cramfs_inode
* cramfs_inode
)
105 struct inode
*inode
= iget5_locked(sb
, CRAMINO(cramfs_inode
),
106 cramfs_iget5_test
, cramfs_iget5_set
,
108 if (inode
&& (inode
->i_state
& I_NEW
)) {
109 unlock_new_inode(inode
);
115 * We have our own block cache: don't fill up the buffer cache
116 * with the rom-image, because the way the filesystem is set
117 * up the accesses should be fairly regular and cached in the
118 * page cache and dentry tree anyway..
120 * This also acts as a way to guarantee contiguous areas of up to
121 * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to
122 * worry about end-of-buffer issues even when decompressing a full
125 #define READ_BUFFERS (2)
126 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
127 #define NEXT_BUFFER(_ix) ((_ix) ^ 1)
130 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
131 * data that takes up more space than the original and with unlucky
134 #define BLKS_PER_BUF_SHIFT (2)
135 #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT)
136 #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_CACHE_SIZE)
138 static unsigned char read_buffers
[READ_BUFFERS
][BUFFER_SIZE
];
139 static unsigned buffer_blocknr
[READ_BUFFERS
];
140 static struct super_block
* buffer_dev
[READ_BUFFERS
];
141 static int next_buffer
;
144 * Returns a pointer to a buffer containing at least LEN bytes of
145 * filesystem starting at byte offset OFFSET into the filesystem.
147 static void *cramfs_read(struct super_block
*sb
, unsigned int offset
, unsigned int len
)
149 struct address_space
*mapping
= sb
->s_bdev
->bd_inode
->i_mapping
;
150 struct page
*pages
[BLKS_PER_BUF
];
151 unsigned i
, blocknr
, buffer
, unread
;
152 unsigned long devsize
;
157 blocknr
= offset
>> PAGE_CACHE_SHIFT
;
158 offset
&= PAGE_CACHE_SIZE
- 1;
160 /* Check if an existing buffer already has the data.. */
161 for (i
= 0; i
< READ_BUFFERS
; i
++) {
162 unsigned int blk_offset
;
164 if (buffer_dev
[i
] != sb
)
166 if (blocknr
< buffer_blocknr
[i
])
168 blk_offset
= (blocknr
- buffer_blocknr
[i
]) << PAGE_CACHE_SHIFT
;
169 blk_offset
+= offset
;
170 if (blk_offset
+ len
> BUFFER_SIZE
)
172 return read_buffers
[i
] + blk_offset
;
175 devsize
= mapping
->host
->i_size
>> PAGE_CACHE_SHIFT
;
177 /* Ok, read in BLKS_PER_BUF pages completely first. */
179 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
180 struct page
*page
= NULL
;
182 if (blocknr
+ i
< devsize
) {
183 page
= read_mapping_page(mapping
, blocknr
+ i
, NULL
);
184 /* synchronous error? */
191 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
192 struct page
*page
= pages
[i
];
194 wait_on_page_locked(page
);
195 if (!PageUptodate(page
)) {
196 /* asynchronous error */
197 page_cache_release(page
);
203 buffer
= next_buffer
;
204 next_buffer
= NEXT_BUFFER(buffer
);
205 buffer_blocknr
[buffer
] = blocknr
;
206 buffer_dev
[buffer
] = sb
;
208 data
= read_buffers
[buffer
];
209 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
210 struct page
*page
= pages
[i
];
212 memcpy(data
, kmap(page
), PAGE_CACHE_SIZE
);
214 page_cache_release(page
);
216 memset(data
, 0, PAGE_CACHE_SIZE
);
217 data
+= PAGE_CACHE_SIZE
;
219 return read_buffers
[buffer
] + offset
;
222 static void cramfs_put_super(struct super_block
*sb
)
224 kfree(sb
->s_fs_info
);
225 sb
->s_fs_info
= NULL
;
228 static int cramfs_remount(struct super_block
*sb
, int *flags
, char *data
)
234 static int cramfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
237 struct cramfs_super super
;
238 unsigned long root_offset
;
239 struct cramfs_sb_info
*sbi
;
242 sb
->s_flags
|= MS_RDONLY
;
244 sbi
= kzalloc(sizeof(struct cramfs_sb_info
), GFP_KERNEL
);
249 /* Invalidate the read buffers on mount: think disk change.. */
250 mutex_lock(&read_mutex
);
251 for (i
= 0; i
< READ_BUFFERS
; i
++)
252 buffer_blocknr
[i
] = -1;
254 /* Read the first block and get the superblock from it */
255 memcpy(&super
, cramfs_read(sb
, 0, sizeof(super
)), sizeof(super
));
256 mutex_unlock(&read_mutex
);
258 /* Do sanity checks on the superblock */
259 if (super
.magic
!= CRAMFS_MAGIC
) {
260 /* check at 512 byte offset */
261 mutex_lock(&read_mutex
);
262 memcpy(&super
, cramfs_read(sb
, 512, sizeof(super
)), sizeof(super
));
263 mutex_unlock(&read_mutex
);
264 if (super
.magic
!= CRAMFS_MAGIC
) {
266 printk(KERN_ERR
"cramfs: wrong magic\n");
271 /* get feature flags first */
272 if (super
.flags
& ~CRAMFS_SUPPORTED_FLAGS
) {
273 printk(KERN_ERR
"cramfs: unsupported filesystem features\n");
277 /* Check that the root inode is in a sane state */
278 if (!S_ISDIR(super
.root
.mode
)) {
279 printk(KERN_ERR
"cramfs: root is not a directory\n");
282 root_offset
= super
.root
.offset
<< 2;
283 if (super
.flags
& CRAMFS_FLAG_FSID_VERSION_2
) {
284 sbi
->size
=super
.size
;
285 sbi
->blocks
=super
.fsid
.blocks
;
286 sbi
->files
=super
.fsid
.files
;
292 sbi
->magic
=super
.magic
;
293 sbi
->flags
=super
.flags
;
294 if (root_offset
== 0)
295 printk(KERN_INFO
"cramfs: empty filesystem");
296 else if (!(super
.flags
& CRAMFS_FLAG_SHIFTED_ROOT_OFFSET
) &&
297 ((root_offset
!= sizeof(struct cramfs_super
)) &&
298 (root_offset
!= 512 + sizeof(struct cramfs_super
))))
300 printk(KERN_ERR
"cramfs: bad root offset %lu\n", root_offset
);
304 /* Set it all up.. */
305 sb
->s_op
= &cramfs_ops
;
306 root
= get_cramfs_inode(sb
, &super
.root
);
309 sb
->s_root
= d_alloc_root(root
);
317 sb
->s_fs_info
= NULL
;
321 static int cramfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
323 struct super_block
*sb
= dentry
->d_sb
;
325 buf
->f_type
= CRAMFS_MAGIC
;
326 buf
->f_bsize
= PAGE_CACHE_SIZE
;
327 buf
->f_blocks
= CRAMFS_SB(sb
)->blocks
;
330 buf
->f_files
= CRAMFS_SB(sb
)->files
;
332 buf
->f_namelen
= CRAMFS_MAXPATHLEN
;
337 * Read a cramfs directory entry.
339 static int cramfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
341 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
342 struct super_block
*sb
= inode
->i_sb
;
347 /* Offset within the thing. */
348 offset
= filp
->f_pos
;
349 if (offset
>= inode
->i_size
)
351 /* Directory entries are always 4-byte aligned */
355 buf
= kmalloc(256, GFP_KERNEL
);
360 while (offset
< inode
->i_size
) {
361 struct cramfs_inode
*de
;
362 unsigned long nextoffset
;
368 mutex_lock(&read_mutex
);
369 de
= cramfs_read(sb
, OFFSET(inode
) + offset
, sizeof(*de
)+256);
370 name
= (char *)(de
+1);
373 * Namelengths on disk are shifted by two
374 * and the name padded out to 4-byte boundaries
377 namelen
= de
->namelen
<< 2;
378 memcpy(buf
, name
, namelen
);
381 mutex_unlock(&read_mutex
);
382 nextoffset
= offset
+ sizeof(*de
) + namelen
;
392 error
= filldir(dirent
, buf
, namelen
, offset
, ino
, mode
>> 12);
397 filp
->f_pos
= offset
;
405 * Lookup and fill in the inode data..
407 static struct dentry
* cramfs_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
409 unsigned int offset
= 0;
412 mutex_lock(&read_mutex
);
413 sorted
= CRAMFS_SB(dir
->i_sb
)->flags
& CRAMFS_FLAG_SORTED_DIRS
;
414 while (offset
< dir
->i_size
) {
415 struct cramfs_inode
*de
;
419 de
= cramfs_read(dir
->i_sb
, OFFSET(dir
) + offset
, sizeof(*de
)+256);
420 name
= (char *)(de
+1);
422 /* Try to take advantage of sorted directories */
423 if (sorted
&& (dentry
->d_name
.name
[0] < name
[0]))
426 namelen
= de
->namelen
<< 2;
427 offset
+= sizeof(*de
) + namelen
;
429 /* Quick check that the name is roughly the right length */
430 if (((dentry
->d_name
.len
+ 3) & ~3) != namelen
)
435 mutex_unlock(&read_mutex
);
436 return ERR_PTR(-EIO
);
442 if (namelen
!= dentry
->d_name
.len
)
444 retval
= memcmp(dentry
->d_name
.name
, name
, namelen
);
448 struct cramfs_inode entry
= *de
;
449 mutex_unlock(&read_mutex
);
450 d_add(dentry
, get_cramfs_inode(dir
->i_sb
, &entry
));
453 /* else (retval < 0) */
457 mutex_unlock(&read_mutex
);
462 static int cramfs_readpage(struct file
*file
, struct page
* page
)
464 struct inode
*inode
= page
->mapping
->host
;
465 u32 maxblock
, bytes_filled
;
468 maxblock
= (inode
->i_size
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
470 if (page
->index
< maxblock
) {
471 struct super_block
*sb
= inode
->i_sb
;
472 u32 blkptr_offset
= OFFSET(inode
) + page
->index
*4;
473 u32 start_offset
, compr_len
;
475 start_offset
= OFFSET(inode
) + maxblock
*4;
476 mutex_lock(&read_mutex
);
478 start_offset
= *(u32
*) cramfs_read(sb
, blkptr_offset
-4, 4);
479 compr_len
= (*(u32
*) cramfs_read(sb
, blkptr_offset
, 4) - start_offset
);
480 mutex_unlock(&read_mutex
);
484 else if (compr_len
> (PAGE_CACHE_SIZE
<< 1))
485 printk(KERN_ERR
"cramfs: bad compressed blocksize %u\n", compr_len
);
487 mutex_lock(&read_mutex
);
488 bytes_filled
= cramfs_uncompress_block(pgdata
,
490 cramfs_read(sb
, start_offset
, compr_len
),
492 mutex_unlock(&read_mutex
);
496 memset(pgdata
+ bytes_filled
, 0, PAGE_CACHE_SIZE
- bytes_filled
);
498 flush_dcache_page(page
);
499 SetPageUptodate(page
);
504 static const struct address_space_operations cramfs_aops
= {
505 .readpage
= cramfs_readpage
513 * A directory can only readdir
515 static const struct file_operations cramfs_directory_operations
= {
516 .llseek
= generic_file_llseek
,
517 .read
= generic_read_dir
,
518 .readdir
= cramfs_readdir
,
521 static struct inode_operations cramfs_dir_inode_operations
= {
522 .lookup
= cramfs_lookup
,
525 static struct super_operations cramfs_ops
= {
526 .put_super
= cramfs_put_super
,
527 .remount_fs
= cramfs_remount
,
528 .statfs
= cramfs_statfs
,
531 static int cramfs_get_sb(struct file_system_type
*fs_type
,
532 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
534 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, cramfs_fill_super
,
538 static struct file_system_type cramfs_fs_type
= {
539 .owner
= THIS_MODULE
,
541 .get_sb
= cramfs_get_sb
,
542 .kill_sb
= kill_block_super
,
543 .fs_flags
= FS_REQUIRES_DEV
,
546 static int __init
init_cramfs_fs(void)
550 rv
= cramfs_uncompress_init();
553 rv
= register_filesystem(&cramfs_fs_type
);
555 cramfs_uncompress_exit();
559 static void __exit
exit_cramfs_fs(void)
561 cramfs_uncompress_exit();
562 unregister_filesystem(&cramfs_fs_type
);
565 module_init(init_cramfs_fs
)
566 module_exit(exit_cramfs_fs
)
567 MODULE_LICENSE("GPL");