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 <asm/semaphore.h>
27 #include <asm/uaccess.h>
29 static struct super_operations cramfs_ops
;
30 static struct inode_operations cramfs_dir_inode_operations
;
31 static struct file_operations cramfs_directory_operations
;
32 static struct address_space_operations cramfs_aops
;
34 static DECLARE_MUTEX(read_mutex
);
37 /* These two macros may change in future, to provide better st_ino
39 #define CRAMINO(x) ((x)->offset?(x)->offset<<2:1)
40 #define OFFSET(x) ((x)->i_ino)
43 static int cramfs_iget5_test(struct inode
*inode
, void *opaque
)
45 struct cramfs_inode
*cramfs_inode
= opaque
;
47 if (inode
->i_ino
!= CRAMINO(cramfs_inode
))
48 return 0; /* does not match */
50 if (inode
->i_ino
!= 1)
53 /* all empty directories, char, block, pipe, and sock, share inode #1 */
55 if ((inode
->i_mode
!= cramfs_inode
->mode
) ||
56 (inode
->i_gid
!= cramfs_inode
->gid
) ||
57 (inode
->i_uid
!= cramfs_inode
->uid
))
58 return 0; /* does not match */
60 if ((S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) &&
61 (inode
->i_rdev
!= old_decode_dev(cramfs_inode
->size
)))
62 return 0; /* does not match */
64 return 1; /* matches */
67 static int cramfs_iget5_set(struct inode
*inode
, void *opaque
)
69 struct cramfs_inode
*cramfs_inode
= opaque
;
70 inode
->i_ino
= CRAMINO(cramfs_inode
);
74 static struct inode
*get_cramfs_inode(struct super_block
*sb
,
75 struct cramfs_inode
* cramfs_inode
)
77 struct inode
*inode
= iget5_locked(sb
, CRAMINO(cramfs_inode
),
78 cramfs_iget5_test
, cramfs_iget5_set
,
80 static struct timespec zerotime
;
82 if (inode
&& (inode
->i_state
& I_NEW
)) {
83 inode
->i_mode
= cramfs_inode
->mode
;
84 inode
->i_uid
= cramfs_inode
->uid
;
85 inode
->i_size
= cramfs_inode
->size
;
86 inode
->i_blocks
= (cramfs_inode
->size
- 1) / 512 + 1;
87 inode
->i_blksize
= PAGE_CACHE_SIZE
;
88 inode
->i_gid
= cramfs_inode
->gid
;
89 /* Struct copy intentional */
90 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= zerotime
;
91 inode
->i_ino
= CRAMINO(cramfs_inode
);
92 /* inode->i_nlink is left 1 - arguably wrong for directories,
93 but it's the best we can do without reading the directory
94 contents. 1 yields the right result in GNU find, even
95 without -noleaf option. */
96 if (S_ISREG(inode
->i_mode
)) {
97 inode
->i_fop
= &generic_ro_fops
;
98 inode
->i_data
.a_ops
= &cramfs_aops
;
99 } else if (S_ISDIR(inode
->i_mode
)) {
100 inode
->i_op
= &cramfs_dir_inode_operations
;
101 inode
->i_fop
= &cramfs_directory_operations
;
102 } else if (S_ISLNK(inode
->i_mode
)) {
103 inode
->i_op
= &page_symlink_inode_operations
;
104 inode
->i_data
.a_ops
= &cramfs_aops
;
108 init_special_inode(inode
, inode
->i_mode
,
109 old_decode_dev(cramfs_inode
->size
));
111 unlock_new_inode(inode
);
117 * We have our own block cache: don't fill up the buffer cache
118 * with the rom-image, because the way the filesystem is set
119 * up the accesses should be fairly regular and cached in the
120 * page cache and dentry tree anyway..
122 * This also acts as a way to guarantee contiguous areas of up to
123 * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to
124 * worry about end-of-buffer issues even when decompressing a full
127 #define READ_BUFFERS (2)
128 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
129 #define NEXT_BUFFER(_ix) ((_ix) ^ 1)
132 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
133 * data that takes up more space than the original and with unlucky
136 #define BLKS_PER_BUF_SHIFT (2)
137 #define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT)
138 #define BUFFER_SIZE (BLKS_PER_BUF*PAGE_CACHE_SIZE)
140 static unsigned char read_buffers
[READ_BUFFERS
][BUFFER_SIZE
];
141 static unsigned buffer_blocknr
[READ_BUFFERS
];
142 static struct super_block
* buffer_dev
[READ_BUFFERS
];
143 static int next_buffer
;
146 * Returns a pointer to a buffer containing at least LEN bytes of
147 * filesystem starting at byte offset OFFSET into the filesystem.
149 static void *cramfs_read(struct super_block
*sb
, unsigned int offset
, unsigned int len
)
151 struct address_space
*mapping
= sb
->s_bdev
->bd_inode
->i_mapping
;
152 struct page
*pages
[BLKS_PER_BUF
];
153 unsigned i
, blocknr
, buffer
, unread
;
154 unsigned long devsize
;
159 blocknr
= offset
>> PAGE_CACHE_SHIFT
;
160 offset
&= PAGE_CACHE_SIZE
- 1;
162 /* Check if an existing buffer already has the data.. */
163 for (i
= 0; i
< READ_BUFFERS
; i
++) {
164 unsigned int blk_offset
;
166 if (buffer_dev
[i
] != sb
)
168 if (blocknr
< buffer_blocknr
[i
])
170 blk_offset
= (blocknr
- buffer_blocknr
[i
]) << PAGE_CACHE_SHIFT
;
171 blk_offset
+= offset
;
172 if (blk_offset
+ len
> BUFFER_SIZE
)
174 return read_buffers
[i
] + blk_offset
;
177 devsize
= mapping
->host
->i_size
>> PAGE_CACHE_SHIFT
;
179 /* Ok, read in BLKS_PER_BUF pages completely first. */
181 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
182 struct page
*page
= NULL
;
184 if (blocknr
+ i
< devsize
) {
185 page
= read_cache_page(mapping
, blocknr
+ i
,
186 (filler_t
*)mapping
->a_ops
->readpage
,
188 /* synchronous error? */
195 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
196 struct page
*page
= pages
[i
];
198 wait_on_page_locked(page
);
199 if (!PageUptodate(page
)) {
200 /* asynchronous error */
201 page_cache_release(page
);
207 buffer
= next_buffer
;
208 next_buffer
= NEXT_BUFFER(buffer
);
209 buffer_blocknr
[buffer
] = blocknr
;
210 buffer_dev
[buffer
] = sb
;
212 data
= read_buffers
[buffer
];
213 for (i
= 0; i
< BLKS_PER_BUF
; i
++) {
214 struct page
*page
= pages
[i
];
216 memcpy(data
, kmap(page
), PAGE_CACHE_SIZE
);
218 page_cache_release(page
);
220 memset(data
, 0, PAGE_CACHE_SIZE
);
221 data
+= PAGE_CACHE_SIZE
;
223 return read_buffers
[buffer
] + offset
;
226 static void cramfs_put_super(struct super_block
*sb
)
228 kfree(sb
->s_fs_info
);
229 sb
->s_fs_info
= NULL
;
232 static int cramfs_remount(struct super_block
*sb
, int *flags
, char *data
)
238 static int cramfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
241 struct cramfs_super super
;
242 unsigned long root_offset
;
243 struct cramfs_sb_info
*sbi
;
246 sb
->s_flags
|= MS_RDONLY
;
248 sbi
= kmalloc(sizeof(struct cramfs_sb_info
), GFP_KERNEL
);
252 memset(sbi
, 0, sizeof(struct cramfs_sb_info
));
254 /* Invalidate the read buffers on mount: think disk change.. */
256 for (i
= 0; i
< READ_BUFFERS
; i
++)
257 buffer_blocknr
[i
] = -1;
259 /* Read the first block and get the superblock from it */
260 memcpy(&super
, cramfs_read(sb
, 0, sizeof(super
)), sizeof(super
));
263 /* Do sanity checks on the superblock */
264 if (super
.magic
!= CRAMFS_MAGIC
) {
265 /* check at 512 byte offset */
267 memcpy(&super
, cramfs_read(sb
, 512, sizeof(super
)), sizeof(super
));
269 if (super
.magic
!= CRAMFS_MAGIC
) {
271 printk(KERN_ERR
"cramfs: wrong magic\n");
276 /* get feature flags first */
277 if (super
.flags
& ~CRAMFS_SUPPORTED_FLAGS
) {
278 printk(KERN_ERR
"cramfs: unsupported filesystem features\n");
282 /* Check that the root inode is in a sane state */
283 if (!S_ISDIR(super
.root
.mode
)) {
284 printk(KERN_ERR
"cramfs: root is not a directory\n");
287 root_offset
= super
.root
.offset
<< 2;
288 if (super
.flags
& CRAMFS_FLAG_FSID_VERSION_2
) {
289 sbi
->size
=super
.size
;
290 sbi
->blocks
=super
.fsid
.blocks
;
291 sbi
->files
=super
.fsid
.files
;
297 sbi
->magic
=super
.magic
;
298 sbi
->flags
=super
.flags
;
299 if (root_offset
== 0)
300 printk(KERN_INFO
"cramfs: empty filesystem");
301 else if (!(super
.flags
& CRAMFS_FLAG_SHIFTED_ROOT_OFFSET
) &&
302 ((root_offset
!= sizeof(struct cramfs_super
)) &&
303 (root_offset
!= 512 + sizeof(struct cramfs_super
))))
305 printk(KERN_ERR
"cramfs: bad root offset %lu\n", root_offset
);
309 /* Set it all up.. */
310 sb
->s_op
= &cramfs_ops
;
311 root
= get_cramfs_inode(sb
, &super
.root
);
314 sb
->s_root
= d_alloc_root(root
);
322 sb
->s_fs_info
= NULL
;
326 static int cramfs_statfs(struct super_block
*sb
, struct kstatfs
*buf
)
328 buf
->f_type
= CRAMFS_MAGIC
;
329 buf
->f_bsize
= PAGE_CACHE_SIZE
;
330 buf
->f_blocks
= CRAMFS_SB(sb
)->blocks
;
333 buf
->f_files
= CRAMFS_SB(sb
)->files
;
335 buf
->f_namelen
= CRAMFS_MAXPATHLEN
;
340 * Read a cramfs directory entry.
342 static int cramfs_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
344 struct inode
*inode
= filp
->f_dentry
->d_inode
;
345 struct super_block
*sb
= inode
->i_sb
;
350 /* Offset within the thing. */
351 offset
= filp
->f_pos
;
352 if (offset
>= inode
->i_size
)
354 /* Directory entries are always 4-byte aligned */
358 buf
= kmalloc(256, GFP_KERNEL
);
363 while (offset
< inode
->i_size
) {
364 struct cramfs_inode
*de
;
365 unsigned long nextoffset
;
372 de
= cramfs_read(sb
, OFFSET(inode
) + offset
, sizeof(*de
)+256);
373 name
= (char *)(de
+1);
376 * Namelengths on disk are shifted by two
377 * and the name padded out to 4-byte boundaries
380 namelen
= de
->namelen
<< 2;
381 memcpy(buf
, name
, namelen
);
385 nextoffset
= offset
+ sizeof(*de
) + namelen
;
395 error
= filldir(dirent
, buf
, namelen
, offset
, ino
, mode
>> 12);
400 filp
->f_pos
= offset
;
408 * Lookup and fill in the inode data..
410 static struct dentry
* cramfs_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
412 unsigned int offset
= 0;
416 sorted
= CRAMFS_SB(dir
->i_sb
)->flags
& CRAMFS_FLAG_SORTED_DIRS
;
417 while (offset
< dir
->i_size
) {
418 struct cramfs_inode
*de
;
422 de
= cramfs_read(dir
->i_sb
, OFFSET(dir
) + offset
, sizeof(*de
)+256);
423 name
= (char *)(de
+1);
425 /* Try to take advantage of sorted directories */
426 if (sorted
&& (dentry
->d_name
.name
[0] < name
[0]))
429 namelen
= de
->namelen
<< 2;
430 offset
+= sizeof(*de
) + namelen
;
432 /* Quick check that the name is roughly the right length */
433 if (((dentry
->d_name
.len
+ 3) & ~3) != namelen
)
439 return ERR_PTR(-EIO
);
445 if (namelen
!= dentry
->d_name
.len
)
447 retval
= memcmp(dentry
->d_name
.name
, name
, namelen
);
451 struct cramfs_inode entry
= *de
;
453 d_add(dentry
, get_cramfs_inode(dir
->i_sb
, &entry
));
456 /* else (retval < 0) */
465 static int cramfs_readpage(struct file
*file
, struct page
* page
)
467 struct inode
*inode
= page
->mapping
->host
;
468 u32 maxblock
, bytes_filled
;
471 maxblock
= (inode
->i_size
+ PAGE_CACHE_SIZE
- 1) >> PAGE_CACHE_SHIFT
;
473 if (page
->index
< maxblock
) {
474 struct super_block
*sb
= inode
->i_sb
;
475 u32 blkptr_offset
= OFFSET(inode
) + page
->index
*4;
476 u32 start_offset
, compr_len
;
478 start_offset
= OFFSET(inode
) + maxblock
*4;
481 start_offset
= *(u32
*) cramfs_read(sb
, blkptr_offset
-4, 4);
482 compr_len
= (*(u32
*) cramfs_read(sb
, blkptr_offset
, 4) - start_offset
);
489 bytes_filled
= cramfs_uncompress_block(pgdata
,
491 cramfs_read(sb
, start_offset
, compr_len
),
497 memset(pgdata
+ bytes_filled
, 0, PAGE_CACHE_SIZE
- bytes_filled
);
499 flush_dcache_page(page
);
500 SetPageUptodate(page
);
505 static struct address_space_operations cramfs_aops
= {
506 .readpage
= cramfs_readpage
514 * A directory can only readdir
516 static struct file_operations cramfs_directory_operations
= {
517 .llseek
= generic_file_llseek
,
518 .read
= generic_read_dir
,
519 .readdir
= cramfs_readdir
,
522 static struct inode_operations cramfs_dir_inode_operations
= {
523 .lookup
= cramfs_lookup
,
526 static struct super_operations cramfs_ops
= {
527 .put_super
= cramfs_put_super
,
528 .remount_fs
= cramfs_remount
,
529 .statfs
= cramfs_statfs
,
532 static struct super_block
*cramfs_get_sb(struct file_system_type
*fs_type
,
533 int flags
, const char *dev_name
, void *data
)
535 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)
548 cramfs_uncompress_init();
549 return register_filesystem(&cramfs_fs_type
);
552 static void __exit
exit_cramfs_fs(void)
554 cramfs_uncompress_exit();
555 unregister_filesystem(&cramfs_fs_type
);
558 module_init(init_cramfs_fs
)
559 module_exit(exit_cramfs_fs
)
560 MODULE_LICENSE("GPL");