blob: dd3634e4c967983f2024221b33c34b81e51ad2ad [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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#include <linux/module.h>
15#include <linux/fs.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>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080025#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#include <asm/uaccess.h>
28
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -080029static const struct super_operations cramfs_ops;
Arjan van de Ven754661f2007-02-12 00:55:38 -080030static const struct inode_operations cramfs_dir_inode_operations;
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080031static const struct file_operations cramfs_directory_operations;
Christoph Hellwigf5e54d62006-06-28 04:26:44 -070032static const struct address_space_operations cramfs_aops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Ingo Molnar353ab6e2006-03-26 01:37:12 -080034static DEFINE_MUTEX(read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36
37/* These two macros may change in future, to provide better st_ino
38 semantics. */
Dave Johnsonff3aea02006-03-06 15:42:36 -080039#define CRAMINO(x) (((x)->offset && (x)->size)?(x)->offset<<2:1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#define OFFSET(x) ((x)->i_ino)
41
Dave Johnsona97c9bf2005-09-06 15:17:40 -070042
43static int cramfs_iget5_test(struct inode *inode, void *opaque)
Linus Torvalds1da177e2005-04-16 15:20:36 -070044{
Dave Johnsona97c9bf2005-09-06 15:17:40 -070045 struct cramfs_inode *cramfs_inode = opaque;
Al Viro82d63fc2008-08-20 14:09:24 -070046 return inode->i_ino == CRAMINO(cramfs_inode) && inode->i_ino != 1;
Dave Johnsona97c9bf2005-09-06 15:17:40 -070047}
48
49static int cramfs_iget5_set(struct inode *inode, void *opaque)
50{
51 struct cramfs_inode *cramfs_inode = opaque;
52 inode->i_ino = CRAMINO(cramfs_inode);
53 return 0;
54}
55
56static struct inode *get_cramfs_inode(struct super_block *sb,
57 struct cramfs_inode * cramfs_inode)
58{
59 struct inode *inode = iget5_locked(sb, CRAMINO(cramfs_inode),
60 cramfs_iget5_test, cramfs_iget5_set,
61 cramfs_inode);
Al Viro82d63fc2008-08-20 14:09:24 -070062 static struct timespec zerotime;
63
Dave Johnsona97c9bf2005-09-06 15:17:40 -070064 if (inode && (inode->i_state & I_NEW)) {
Al Viro82d63fc2008-08-20 14:09:24 -070065 inode->i_mode = cramfs_inode->mode;
66 inode->i_uid = cramfs_inode->uid;
67 inode->i_size = cramfs_inode->size;
68 inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1;
69 inode->i_gid = cramfs_inode->gid;
70 /* Struct copy intentional */
71 inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime;
72 /* inode->i_nlink is left 1 - arguably wrong for directories,
73 but it's the best we can do without reading the directory
74 contents. 1 yields the right result in GNU find, even
75 without -noleaf option. */
76 if (S_ISREG(inode->i_mode)) {
77 inode->i_fop = &generic_ro_fops;
78 inode->i_data.a_ops = &cramfs_aops;
79 } else if (S_ISDIR(inode->i_mode)) {
80 inode->i_op = &cramfs_dir_inode_operations;
81 inode->i_fop = &cramfs_directory_operations;
82 } else if (S_ISLNK(inode->i_mode)) {
83 inode->i_op = &page_symlink_inode_operations;
84 inode->i_data.a_ops = &cramfs_aops;
85 } else {
Al Viro82d63fc2008-08-20 14:09:24 -070086 init_special_inode(inode, inode->i_mode,
87 old_decode_dev(cramfs_inode->size));
88 }
Dave Johnsona97c9bf2005-09-06 15:17:40 -070089 unlock_new_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 }
91 return inode;
92}
93
Al Viro82d63fc2008-08-20 14:09:24 -070094static void cramfs_drop_inode(struct inode *inode)
95{
96 if (inode->i_ino == 1)
97 generic_delete_inode(inode);
98 else
99 generic_drop_inode(inode);
100}
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102/*
103 * We have our own block cache: don't fill up the buffer cache
104 * with the rom-image, because the way the filesystem is set
105 * up the accesses should be fairly regular and cached in the
106 * page cache and dentry tree anyway..
107 *
108 * This also acts as a way to guarantee contiguous areas of up to
109 * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to
110 * worry about end-of-buffer issues even when decompressing a full
111 * page cache.
112 */
113#define READ_BUFFERS (2)
114/* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
115#define NEXT_BUFFER(_ix) ((_ix) ^ 1)
116
117/*
118 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
119 * data that takes up more space than the original and with unlucky
120 * alignment.
121 */
122#define BLKS_PER_BUF_SHIFT (2)
123#define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT)
124#define BUFFER_SIZE (BLKS_PER_BUF*PAGE_CACHE_SIZE)
125
126static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE];
127static unsigned buffer_blocknr[READ_BUFFERS];
128static struct super_block * buffer_dev[READ_BUFFERS];
129static int next_buffer;
130
131/*
132 * Returns a pointer to a buffer containing at least LEN bytes of
133 * filesystem starting at byte offset OFFSET into the filesystem.
134 */
135static void *cramfs_read(struct super_block *sb, unsigned int offset, unsigned int len)
136{
137 struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
138 struct page *pages[BLKS_PER_BUF];
Andi Drebes6bbfb072007-10-18 03:06:54 -0700139 unsigned i, blocknr, buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 unsigned long devsize;
141 char *data;
142
143 if (!len)
144 return NULL;
145 blocknr = offset >> PAGE_CACHE_SHIFT;
146 offset &= PAGE_CACHE_SIZE - 1;
147
148 /* Check if an existing buffer already has the data.. */
149 for (i = 0; i < READ_BUFFERS; i++) {
150 unsigned int blk_offset;
151
152 if (buffer_dev[i] != sb)
153 continue;
154 if (blocknr < buffer_blocknr[i])
155 continue;
156 blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_CACHE_SHIFT;
157 blk_offset += offset;
158 if (blk_offset + len > BUFFER_SIZE)
159 continue;
160 return read_buffers[i] + blk_offset;
161 }
162
163 devsize = mapping->host->i_size >> PAGE_CACHE_SHIFT;
164
165 /* Ok, read in BLKS_PER_BUF pages completely first. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 for (i = 0; i < BLKS_PER_BUF; i++) {
167 struct page *page = NULL;
168
169 if (blocknr + i < devsize) {
Nick Piggin6fe69002007-05-06 14:49:04 -0700170 page = read_mapping_page_async(mapping, blocknr + i,
171 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 /* synchronous error? */
173 if (IS_ERR(page))
174 page = NULL;
175 }
176 pages[i] = page;
177 }
178
179 for (i = 0; i < BLKS_PER_BUF; i++) {
180 struct page *page = pages[i];
181 if (page) {
182 wait_on_page_locked(page);
183 if (!PageUptodate(page)) {
184 /* asynchronous error */
185 page_cache_release(page);
186 pages[i] = NULL;
187 }
188 }
189 }
190
191 buffer = next_buffer;
192 next_buffer = NEXT_BUFFER(buffer);
193 buffer_blocknr[buffer] = blocknr;
194 buffer_dev[buffer] = sb;
195
196 data = read_buffers[buffer];
197 for (i = 0; i < BLKS_PER_BUF; i++) {
198 struct page *page = pages[i];
199 if (page) {
200 memcpy(data, kmap(page), PAGE_CACHE_SIZE);
201 kunmap(page);
202 page_cache_release(page);
203 } else
204 memset(data, 0, PAGE_CACHE_SIZE);
205 data += PAGE_CACHE_SIZE;
206 }
207 return read_buffers[buffer] + offset;
208}
209
210static void cramfs_put_super(struct super_block *sb)
211{
212 kfree(sb->s_fs_info);
213 sb->s_fs_info = NULL;
214}
215
216static int cramfs_remount(struct super_block *sb, int *flags, char *data)
217{
218 *flags |= MS_RDONLY;
219 return 0;
220}
221
222static int cramfs_fill_super(struct super_block *sb, void *data, int silent)
223{
224 int i;
225 struct cramfs_super super;
226 unsigned long root_offset;
227 struct cramfs_sb_info *sbi;
228 struct inode *root;
229
230 sb->s_flags |= MS_RDONLY;
231
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700232 sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 if (!sbi)
234 return -ENOMEM;
235 sb->s_fs_info = sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
237 /* Invalidate the read buffers on mount: think disk change.. */
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800238 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 for (i = 0; i < READ_BUFFERS; i++)
240 buffer_blocknr[i] = -1;
241
242 /* Read the first block and get the superblock from it */
243 memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super));
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800244 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
246 /* Do sanity checks on the superblock */
247 if (super.magic != CRAMFS_MAGIC) {
Andi Drebesac8d35c2007-10-16 23:27:12 -0700248 /* check for wrong endianess */
249 if (super.magic == CRAMFS_MAGIC_WEND) {
250 if (!silent)
251 printk(KERN_ERR "cramfs: wrong endianess\n");
252 goto out;
253 }
254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 /* check at 512 byte offset */
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800256 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 memcpy(&super, cramfs_read(sb, 512, sizeof(super)), sizeof(super));
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800258 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (super.magic != CRAMFS_MAGIC) {
Andi Drebesac8d35c2007-10-16 23:27:12 -0700260 if (super.magic == CRAMFS_MAGIC_WEND && !silent)
261 printk(KERN_ERR "cramfs: wrong endianess\n");
262 else if (!silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 printk(KERN_ERR "cramfs: wrong magic\n");
264 goto out;
265 }
266 }
267
268 /* get feature flags first */
269 if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) {
270 printk(KERN_ERR "cramfs: unsupported filesystem features\n");
271 goto out;
272 }
273
274 /* Check that the root inode is in a sane state */
275 if (!S_ISDIR(super.root.mode)) {
276 printk(KERN_ERR "cramfs: root is not a directory\n");
277 goto out;
278 }
279 root_offset = super.root.offset << 2;
280 if (super.flags & CRAMFS_FLAG_FSID_VERSION_2) {
281 sbi->size=super.size;
282 sbi->blocks=super.fsid.blocks;
283 sbi->files=super.fsid.files;
284 } else {
285 sbi->size=1<<28;
286 sbi->blocks=0;
287 sbi->files=0;
288 }
289 sbi->magic=super.magic;
290 sbi->flags=super.flags;
291 if (root_offset == 0)
292 printk(KERN_INFO "cramfs: empty filesystem");
293 else if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
294 ((root_offset != sizeof(struct cramfs_super)) &&
295 (root_offset != 512 + sizeof(struct cramfs_super))))
296 {
297 printk(KERN_ERR "cramfs: bad root offset %lu\n", root_offset);
298 goto out;
299 }
300
301 /* Set it all up.. */
302 sb->s_op = &cramfs_ops;
303 root = get_cramfs_inode(sb, &super.root);
304 if (!root)
305 goto out;
306 sb->s_root = d_alloc_root(root);
307 if (!sb->s_root) {
308 iput(root);
309 goto out;
310 }
311 return 0;
312out:
313 kfree(sbi);
314 sb->s_fs_info = NULL;
315 return -EINVAL;
316}
317
David Howells726c3342006-06-23 02:02:58 -0700318static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319{
David Howells726c3342006-06-23 02:02:58 -0700320 struct super_block *sb = dentry->d_sb;
Coly Li94ea77a2009-04-02 16:59:33 -0700321 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
David Howells726c3342006-06-23 02:02:58 -0700322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 buf->f_type = CRAMFS_MAGIC;
324 buf->f_bsize = PAGE_CACHE_SIZE;
325 buf->f_blocks = CRAMFS_SB(sb)->blocks;
326 buf->f_bfree = 0;
327 buf->f_bavail = 0;
328 buf->f_files = CRAMFS_SB(sb)->files;
329 buf->f_ffree = 0;
Coly Li94ea77a2009-04-02 16:59:33 -0700330 buf->f_fsid.val[0] = (u32)id;
331 buf->f_fsid.val[1] = (u32)(id >> 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 buf->f_namelen = CRAMFS_MAXPATHLEN;
333 return 0;
334}
335
336/*
337 * Read a cramfs directory entry.
338 */
339static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
340{
Josef Sipek352d8af2006-12-08 02:36:58 -0800341 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 struct super_block *sb = inode->i_sb;
343 char *buf;
344 unsigned int offset;
345 int copied;
346
347 /* Offset within the thing. */
348 offset = filp->f_pos;
349 if (offset >= inode->i_size)
350 return 0;
351 /* Directory entries are always 4-byte aligned */
352 if (offset & 3)
353 return -EINVAL;
354
Andi Drebes4176ed52007-10-18 03:06:55 -0700355 buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 if (!buf)
357 return -ENOMEM;
358
359 copied = 0;
360 while (offset < inode->i_size) {
361 struct cramfs_inode *de;
362 unsigned long nextoffset;
363 char *name;
364 ino_t ino;
365 mode_t mode;
366 int namelen, error;
367
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800368 mutex_lock(&read_mutex);
Andi Drebes4176ed52007-10-18 03:06:55 -0700369 de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 name = (char *)(de+1);
371
372 /*
373 * Namelengths on disk are shifted by two
374 * and the name padded out to 4-byte boundaries
375 * with zeroes.
376 */
377 namelen = de->namelen << 2;
378 memcpy(buf, name, namelen);
379 ino = CRAMINO(de);
380 mode = de->mode;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800381 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 nextoffset = offset + sizeof(*de) + namelen;
383 for (;;) {
384 if (!namelen) {
385 kfree(buf);
386 return -EIO;
387 }
388 if (buf[namelen-1])
389 break;
390 namelen--;
391 }
392 error = filldir(dirent, buf, namelen, offset, ino, mode >> 12);
393 if (error)
394 break;
395
396 offset = nextoffset;
397 filp->f_pos = offset;
398 copied++;
399 }
400 kfree(buf);
401 return 0;
402}
403
404/*
405 * Lookup and fill in the inode data..
406 */
407static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
408{
409 unsigned int offset = 0;
410 int sorted;
411
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800412 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS;
414 while (offset < dir->i_size) {
415 struct cramfs_inode *de;
416 char *name;
417 int namelen, retval;
418
Andi Drebes4176ed52007-10-18 03:06:55 -0700419 de = cramfs_read(dir->i_sb, OFFSET(dir) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 name = (char *)(de+1);
421
422 /* Try to take advantage of sorted directories */
423 if (sorted && (dentry->d_name.name[0] < name[0]))
424 break;
425
426 namelen = de->namelen << 2;
427 offset += sizeof(*de) + namelen;
428
429 /* Quick check that the name is roughly the right length */
430 if (((dentry->d_name.len + 3) & ~3) != namelen)
431 continue;
432
433 for (;;) {
434 if (!namelen) {
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800435 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 return ERR_PTR(-EIO);
437 }
438 if (name[namelen-1])
439 break;
440 namelen--;
441 }
442 if (namelen != dentry->d_name.len)
443 continue;
444 retval = memcmp(dentry->d_name.name, name, namelen);
445 if (retval > 0)
446 continue;
447 if (!retval) {
448 struct cramfs_inode entry = *de;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800449 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 d_add(dentry, get_cramfs_inode(dir->i_sb, &entry));
451 return NULL;
452 }
453 /* else (retval < 0) */
454 if (sorted)
455 break;
456 }
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800457 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 d_add(dentry, NULL);
459 return NULL;
460}
461
462static int cramfs_readpage(struct file *file, struct page * page)
463{
464 struct inode *inode = page->mapping->host;
David VomLehn98310e52009-04-02 16:59:15 -0700465 u32 maxblock;
466 int bytes_filled;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 void *pgdata;
468
469 maxblock = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
470 bytes_filled = 0;
David VomLehn98310e52009-04-02 16:59:15 -0700471 pgdata = kmap(page);
472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 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;
477
478 start_offset = OFFSET(inode) + maxblock*4;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800479 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 if (page->index)
David VomLehn98310e52009-04-02 16:59:15 -0700481 start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4,
482 4);
483 compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) -
484 start_offset);
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800485 mutex_unlock(&read_mutex);
David VomLehn98310e52009-04-02 16:59:15 -0700486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 if (compr_len == 0)
488 ; /* hole */
David VomLehn98310e52009-04-02 16:59:15 -0700489 else if (unlikely(compr_len > (PAGE_CACHE_SIZE << 1))) {
490 pr_err("cramfs: bad compressed blocksize %u\n",
491 compr_len);
492 goto err;
493 } else {
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800494 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 bytes_filled = cramfs_uncompress_block(pgdata,
496 PAGE_CACHE_SIZE,
497 cramfs_read(sb, start_offset, compr_len),
498 compr_len);
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800499 mutex_unlock(&read_mutex);
David VomLehn98310e52009-04-02 16:59:15 -0700500 if (unlikely(bytes_filled < 0))
501 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 }
David VomLehn98310e52009-04-02 16:59:15 -0700503 }
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 memset(pgdata + bytes_filled, 0, PAGE_CACHE_SIZE - bytes_filled);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 flush_dcache_page(page);
David VomLehn98310e52009-04-02 16:59:15 -0700507 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 SetPageUptodate(page);
509 unlock_page(page);
510 return 0;
David VomLehn98310e52009-04-02 16:59:15 -0700511
512err:
513 kunmap(page);
514 ClearPageUptodate(page);
515 SetPageError(page);
516 unlock_page(page);
517 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518}
519
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700520static const struct address_space_operations cramfs_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 .readpage = cramfs_readpage
522};
523
524/*
525 * Our operations:
526 */
527
528/*
529 * A directory can only readdir
530 */
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800531static const struct file_operations cramfs_directory_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 .llseek = generic_file_llseek,
533 .read = generic_read_dir,
534 .readdir = cramfs_readdir,
535};
536
Arjan van de Ven754661f2007-02-12 00:55:38 -0800537static const struct inode_operations cramfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 .lookup = cramfs_lookup,
539};
540
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800541static const struct super_operations cramfs_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 .put_super = cramfs_put_super,
543 .remount_fs = cramfs_remount,
544 .statfs = cramfs_statfs,
Al Viro82d63fc2008-08-20 14:09:24 -0700545 .drop_inode = cramfs_drop_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546};
547
David Howells454e2392006-06-23 02:02:57 -0700548static int cramfs_get_sb(struct file_system_type *fs_type,
549 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
David Howells454e2392006-06-23 02:02:57 -0700551 return get_sb_bdev(fs_type, flags, dev_name, data, cramfs_fill_super,
552 mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553}
554
555static struct file_system_type cramfs_fs_type = {
556 .owner = THIS_MODULE,
557 .name = "cramfs",
558 .get_sb = cramfs_get_sb,
559 .kill_sb = kill_block_super,
560 .fs_flags = FS_REQUIRES_DEV,
561};
562
563static int __init init_cramfs_fs(void)
564{
Alexey Dobriyan50d44ed2006-09-29 02:01:04 -0700565 int rv;
566
567 rv = cramfs_uncompress_init();
568 if (rv < 0)
569 return rv;
570 rv = register_filesystem(&cramfs_fs_type);
571 if (rv < 0)
572 cramfs_uncompress_exit();
573 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574}
575
576static void __exit exit_cramfs_fs(void)
577{
578 cramfs_uncompress_exit();
579 unregister_filesystem(&cramfs_fs_type);
580}
581
582module_init(init_cramfs_fs)
583module_exit(exit_cramfs_fs)
584MODULE_LICENSE("GPL");