blob: 1e7a33028d33908807d776d05840637cfd7e4f22 [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
Al Viro77b8a752010-06-04 21:19:01 -040042static void setup_inode(struct inode *inode, struct cramfs_inode * cramfs_inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070043{
Al Viro77b8a752010-06-04 21:19:01 -040044 static struct timespec zerotime;
45 inode->i_mode = cramfs_inode->mode;
46 inode->i_uid = cramfs_inode->uid;
47 inode->i_size = cramfs_inode->size;
48 inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1;
49 inode->i_gid = cramfs_inode->gid;
50 /* Struct copy intentional */
51 inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime;
52 /* inode->i_nlink is left 1 - arguably wrong for directories,
53 but it's the best we can do without reading the directory
54 contents. 1 yields the right result in GNU find, even
55 without -noleaf option. */
56 if (S_ISREG(inode->i_mode)) {
57 inode->i_fop = &generic_ro_fops;
58 inode->i_data.a_ops = &cramfs_aops;
59 } else if (S_ISDIR(inode->i_mode)) {
60 inode->i_op = &cramfs_dir_inode_operations;
61 inode->i_fop = &cramfs_directory_operations;
62 } else if (S_ISLNK(inode->i_mode)) {
63 inode->i_op = &page_symlink_inode_operations;
64 inode->i_data.a_ops = &cramfs_aops;
65 } else {
66 init_special_inode(inode, inode->i_mode,
67 old_decode_dev(cramfs_inode->size));
68 }
Dave Johnsona97c9bf2005-09-06 15:17:40 -070069}
70
71static struct inode *get_cramfs_inode(struct super_block *sb,
72 struct cramfs_inode * cramfs_inode)
73{
Al Viro77b8a752010-06-04 21:19:01 -040074 struct inode *inode;
75 if (CRAMINO(cramfs_inode) == 1) {
76 inode = new_inode(sb);
77 if (inode) {
78 inode->i_ino = 1;
79 setup_inode(inode, cramfs_inode);
Al Viro82d63fc2008-08-20 14:09:24 -070080 }
Al Viro77b8a752010-06-04 21:19:01 -040081 } else {
82 inode = iget_locked(sb, CRAMINO(cramfs_inode));
Alexander Shishkinb845ff82010-08-17 17:08:35 +030083 if (inode && (inode->i_state & I_NEW)) {
Al Viro77b8a752010-06-04 21:19:01 -040084 setup_inode(inode, cramfs_inode);
85 unlock_new_inode(inode);
86 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 }
88 return inode;
89}
90
91/*
92 * We have our own block cache: don't fill up the buffer cache
93 * with the rom-image, because the way the filesystem is set
94 * up the accesses should be fairly regular and cached in the
95 * page cache and dentry tree anyway..
96 *
97 * This also acts as a way to guarantee contiguous areas of up to
98 * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to
99 * worry about end-of-buffer issues even when decompressing a full
100 * page cache.
101 */
102#define READ_BUFFERS (2)
103/* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
104#define NEXT_BUFFER(_ix) ((_ix) ^ 1)
105
106/*
107 * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
108 * data that takes up more space than the original and with unlucky
109 * alignment.
110 */
111#define BLKS_PER_BUF_SHIFT (2)
112#define BLKS_PER_BUF (1 << BLKS_PER_BUF_SHIFT)
113#define BUFFER_SIZE (BLKS_PER_BUF*PAGE_CACHE_SIZE)
114
115static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE];
116static unsigned buffer_blocknr[READ_BUFFERS];
117static struct super_block * buffer_dev[READ_BUFFERS];
118static int next_buffer;
119
120/*
121 * Returns a pointer to a buffer containing at least LEN bytes of
122 * filesystem starting at byte offset OFFSET into the filesystem.
123 */
124static void *cramfs_read(struct super_block *sb, unsigned int offset, unsigned int len)
125{
126 struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
127 struct page *pages[BLKS_PER_BUF];
Andi Drebes6bbfb072007-10-18 03:06:54 -0700128 unsigned i, blocknr, buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 unsigned long devsize;
130 char *data;
131
132 if (!len)
133 return NULL;
134 blocknr = offset >> PAGE_CACHE_SHIFT;
135 offset &= PAGE_CACHE_SIZE - 1;
136
137 /* Check if an existing buffer already has the data.. */
138 for (i = 0; i < READ_BUFFERS; i++) {
139 unsigned int blk_offset;
140
141 if (buffer_dev[i] != sb)
142 continue;
143 if (blocknr < buffer_blocknr[i])
144 continue;
145 blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_CACHE_SHIFT;
146 blk_offset += offset;
147 if (blk_offset + len > BUFFER_SIZE)
148 continue;
149 return read_buffers[i] + blk_offset;
150 }
151
152 devsize = mapping->host->i_size >> PAGE_CACHE_SHIFT;
153
154 /* Ok, read in BLKS_PER_BUF pages completely first. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 for (i = 0; i < BLKS_PER_BUF; i++) {
156 struct page *page = NULL;
157
158 if (blocknr + i < devsize) {
Nick Piggin6fe69002007-05-06 14:49:04 -0700159 page = read_mapping_page_async(mapping, blocknr + i,
160 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 /* synchronous error? */
162 if (IS_ERR(page))
163 page = NULL;
164 }
165 pages[i] = page;
166 }
167
168 for (i = 0; i < BLKS_PER_BUF; i++) {
169 struct page *page = pages[i];
170 if (page) {
171 wait_on_page_locked(page);
172 if (!PageUptodate(page)) {
173 /* asynchronous error */
174 page_cache_release(page);
175 pages[i] = NULL;
176 }
177 }
178 }
179
180 buffer = next_buffer;
181 next_buffer = NEXT_BUFFER(buffer);
182 buffer_blocknr[buffer] = blocknr;
183 buffer_dev[buffer] = sb;
184
185 data = read_buffers[buffer];
186 for (i = 0; i < BLKS_PER_BUF; i++) {
187 struct page *page = pages[i];
188 if (page) {
189 memcpy(data, kmap(page), PAGE_CACHE_SIZE);
190 kunmap(page);
191 page_cache_release(page);
192 } else
193 memset(data, 0, PAGE_CACHE_SIZE);
194 data += PAGE_CACHE_SIZE;
195 }
196 return read_buffers[buffer] + offset;
197}
198
199static void cramfs_put_super(struct super_block *sb)
200{
201 kfree(sb->s_fs_info);
202 sb->s_fs_info = NULL;
203}
204
205static int cramfs_remount(struct super_block *sb, int *flags, char *data)
206{
207 *flags |= MS_RDONLY;
208 return 0;
209}
210
211static int cramfs_fill_super(struct super_block *sb, void *data, int silent)
212{
213 int i;
214 struct cramfs_super super;
215 unsigned long root_offset;
216 struct cramfs_sb_info *sbi;
217 struct inode *root;
218
219 sb->s_flags |= MS_RDONLY;
220
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700221 sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 if (!sbi)
223 return -ENOMEM;
224 sb->s_fs_info = sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 /* Invalidate the read buffers on mount: think disk change.. */
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800227 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 for (i = 0; i < READ_BUFFERS; i++)
229 buffer_blocknr[i] = -1;
230
231 /* Read the first block and get the superblock from it */
232 memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super));
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800233 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
235 /* Do sanity checks on the superblock */
236 if (super.magic != CRAMFS_MAGIC) {
Andi Drebesac8d35c2007-10-16 23:27:12 -0700237 /* check for wrong endianess */
238 if (super.magic == CRAMFS_MAGIC_WEND) {
239 if (!silent)
240 printk(KERN_ERR "cramfs: wrong endianess\n");
241 goto out;
242 }
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 /* check at 512 byte offset */
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800245 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 memcpy(&super, cramfs_read(sb, 512, sizeof(super)), sizeof(super));
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800247 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 if (super.magic != CRAMFS_MAGIC) {
Andi Drebesac8d35c2007-10-16 23:27:12 -0700249 if (super.magic == CRAMFS_MAGIC_WEND && !silent)
250 printk(KERN_ERR "cramfs: wrong endianess\n");
251 else if (!silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 printk(KERN_ERR "cramfs: wrong magic\n");
253 goto out;
254 }
255 }
256
257 /* get feature flags first */
258 if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) {
259 printk(KERN_ERR "cramfs: unsupported filesystem features\n");
260 goto out;
261 }
262
263 /* Check that the root inode is in a sane state */
264 if (!S_ISDIR(super.root.mode)) {
265 printk(KERN_ERR "cramfs: root is not a directory\n");
266 goto out;
267 }
268 root_offset = super.root.offset << 2;
269 if (super.flags & CRAMFS_FLAG_FSID_VERSION_2) {
270 sbi->size=super.size;
271 sbi->blocks=super.fsid.blocks;
272 sbi->files=super.fsid.files;
273 } else {
274 sbi->size=1<<28;
275 sbi->blocks=0;
276 sbi->files=0;
277 }
278 sbi->magic=super.magic;
279 sbi->flags=super.flags;
280 if (root_offset == 0)
281 printk(KERN_INFO "cramfs: empty filesystem");
282 else if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
283 ((root_offset != sizeof(struct cramfs_super)) &&
284 (root_offset != 512 + sizeof(struct cramfs_super))))
285 {
286 printk(KERN_ERR "cramfs: bad root offset %lu\n", root_offset);
287 goto out;
288 }
289
290 /* Set it all up.. */
291 sb->s_op = &cramfs_ops;
292 root = get_cramfs_inode(sb, &super.root);
293 if (!root)
294 goto out;
295 sb->s_root = d_alloc_root(root);
296 if (!sb->s_root) {
297 iput(root);
298 goto out;
299 }
300 return 0;
301out:
302 kfree(sbi);
303 sb->s_fs_info = NULL;
304 return -EINVAL;
305}
306
David Howells726c3342006-06-23 02:02:58 -0700307static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
David Howells726c3342006-06-23 02:02:58 -0700309 struct super_block *sb = dentry->d_sb;
Coly Li94ea77a2009-04-02 16:59:33 -0700310 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
David Howells726c3342006-06-23 02:02:58 -0700311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 buf->f_type = CRAMFS_MAGIC;
313 buf->f_bsize = PAGE_CACHE_SIZE;
314 buf->f_blocks = CRAMFS_SB(sb)->blocks;
315 buf->f_bfree = 0;
316 buf->f_bavail = 0;
317 buf->f_files = CRAMFS_SB(sb)->files;
318 buf->f_ffree = 0;
Coly Li94ea77a2009-04-02 16:59:33 -0700319 buf->f_fsid.val[0] = (u32)id;
320 buf->f_fsid.val[1] = (u32)(id >> 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 buf->f_namelen = CRAMFS_MAXPATHLEN;
322 return 0;
323}
324
325/*
326 * Read a cramfs directory entry.
327 */
328static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
329{
Josef Sipek352d8af2006-12-08 02:36:58 -0800330 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 struct super_block *sb = inode->i_sb;
332 char *buf;
333 unsigned int offset;
334 int copied;
335
336 /* Offset within the thing. */
337 offset = filp->f_pos;
338 if (offset >= inode->i_size)
339 return 0;
340 /* Directory entries are always 4-byte aligned */
341 if (offset & 3)
342 return -EINVAL;
343
Andi Drebes4176ed52007-10-18 03:06:55 -0700344 buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 if (!buf)
346 return -ENOMEM;
347
348 copied = 0;
349 while (offset < inode->i_size) {
350 struct cramfs_inode *de;
351 unsigned long nextoffset;
352 char *name;
353 ino_t ino;
354 mode_t mode;
355 int namelen, error;
356
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800357 mutex_lock(&read_mutex);
Andi Drebes4176ed52007-10-18 03:06:55 -0700358 de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 name = (char *)(de+1);
360
361 /*
362 * Namelengths on disk are shifted by two
363 * and the name padded out to 4-byte boundaries
364 * with zeroes.
365 */
366 namelen = de->namelen << 2;
367 memcpy(buf, name, namelen);
368 ino = CRAMINO(de);
369 mode = de->mode;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800370 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 nextoffset = offset + sizeof(*de) + namelen;
372 for (;;) {
373 if (!namelen) {
374 kfree(buf);
375 return -EIO;
376 }
377 if (buf[namelen-1])
378 break;
379 namelen--;
380 }
381 error = filldir(dirent, buf, namelen, offset, ino, mode >> 12);
382 if (error)
383 break;
384
385 offset = nextoffset;
386 filp->f_pos = offset;
387 copied++;
388 }
389 kfree(buf);
390 return 0;
391}
392
393/*
394 * Lookup and fill in the inode data..
395 */
396static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
397{
398 unsigned int offset = 0;
399 int sorted;
400
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800401 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS;
403 while (offset < dir->i_size) {
404 struct cramfs_inode *de;
405 char *name;
406 int namelen, retval;
407
Andi Drebes4176ed52007-10-18 03:06:55 -0700408 de = cramfs_read(dir->i_sb, OFFSET(dir) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 name = (char *)(de+1);
410
411 /* Try to take advantage of sorted directories */
412 if (sorted && (dentry->d_name.name[0] < name[0]))
413 break;
414
415 namelen = de->namelen << 2;
416 offset += sizeof(*de) + namelen;
417
418 /* Quick check that the name is roughly the right length */
419 if (((dentry->d_name.len + 3) & ~3) != namelen)
420 continue;
421
422 for (;;) {
423 if (!namelen) {
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800424 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 return ERR_PTR(-EIO);
426 }
427 if (name[namelen-1])
428 break;
429 namelen--;
430 }
431 if (namelen != dentry->d_name.len)
432 continue;
433 retval = memcmp(dentry->d_name.name, name, namelen);
434 if (retval > 0)
435 continue;
436 if (!retval) {
437 struct cramfs_inode entry = *de;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800438 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 d_add(dentry, get_cramfs_inode(dir->i_sb, &entry));
440 return NULL;
441 }
442 /* else (retval < 0) */
443 if (sorted)
444 break;
445 }
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800446 mutex_unlock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 d_add(dentry, NULL);
448 return NULL;
449}
450
451static int cramfs_readpage(struct file *file, struct page * page)
452{
453 struct inode *inode = page->mapping->host;
David VomLehn98310e52009-04-02 16:59:15 -0700454 u32 maxblock;
455 int bytes_filled;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 void *pgdata;
457
458 maxblock = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
459 bytes_filled = 0;
David VomLehn98310e52009-04-02 16:59:15 -0700460 pgdata = kmap(page);
461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 if (page->index < maxblock) {
463 struct super_block *sb = inode->i_sb;
464 u32 blkptr_offset = OFFSET(inode) + page->index*4;
465 u32 start_offset, compr_len;
466
467 start_offset = OFFSET(inode) + maxblock*4;
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800468 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 if (page->index)
David VomLehn98310e52009-04-02 16:59:15 -0700470 start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4,
471 4);
472 compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) -
473 start_offset);
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800474 mutex_unlock(&read_mutex);
David VomLehn98310e52009-04-02 16:59:15 -0700475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 if (compr_len == 0)
477 ; /* hole */
David VomLehn98310e52009-04-02 16:59:15 -0700478 else if (unlikely(compr_len > (PAGE_CACHE_SIZE << 1))) {
479 pr_err("cramfs: bad compressed blocksize %u\n",
480 compr_len);
481 goto err;
482 } else {
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800483 mutex_lock(&read_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 bytes_filled = cramfs_uncompress_block(pgdata,
485 PAGE_CACHE_SIZE,
486 cramfs_read(sb, start_offset, compr_len),
487 compr_len);
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800488 mutex_unlock(&read_mutex);
David VomLehn98310e52009-04-02 16:59:15 -0700489 if (unlikely(bytes_filled < 0))
490 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
David VomLehn98310e52009-04-02 16:59:15 -0700492 }
493
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 memset(pgdata + bytes_filled, 0, PAGE_CACHE_SIZE - bytes_filled);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 flush_dcache_page(page);
David VomLehn98310e52009-04-02 16:59:15 -0700496 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 SetPageUptodate(page);
498 unlock_page(page);
499 return 0;
David VomLehn98310e52009-04-02 16:59:15 -0700500
501err:
502 kunmap(page);
503 ClearPageUptodate(page);
504 SetPageError(page);
505 unlock_page(page);
506 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507}
508
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700509static const struct address_space_operations cramfs_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 .readpage = cramfs_readpage
511};
512
513/*
514 * Our operations:
515 */
516
517/*
518 * A directory can only readdir
519 */
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800520static const struct file_operations cramfs_directory_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 .llseek = generic_file_llseek,
522 .read = generic_read_dir,
523 .readdir = cramfs_readdir,
524};
525
Arjan van de Ven754661f2007-02-12 00:55:38 -0800526static const struct inode_operations cramfs_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 .lookup = cramfs_lookup,
528};
529
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800530static const struct super_operations cramfs_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 .put_super = cramfs_put_super,
532 .remount_fs = cramfs_remount,
533 .statfs = cramfs_statfs,
534};
535
David Howells454e2392006-06-23 02:02:57 -0700536static int cramfs_get_sb(struct file_system_type *fs_type,
537 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
David Howells454e2392006-06-23 02:02:57 -0700539 return get_sb_bdev(fs_type, flags, dev_name, data, cramfs_fill_super,
540 mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541}
542
543static struct file_system_type cramfs_fs_type = {
544 .owner = THIS_MODULE,
545 .name = "cramfs",
546 .get_sb = cramfs_get_sb,
547 .kill_sb = kill_block_super,
548 .fs_flags = FS_REQUIRES_DEV,
549};
550
551static int __init init_cramfs_fs(void)
552{
Alexey Dobriyan50d44ed2006-09-29 02:01:04 -0700553 int rv;
554
555 rv = cramfs_uncompress_init();
556 if (rv < 0)
557 return rv;
558 rv = register_filesystem(&cramfs_fs_type);
559 if (rv < 0)
560 cramfs_uncompress_exit();
561 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562}
563
564static void __exit exit_cramfs_fs(void)
565{
566 cramfs_uncompress_exit();
567 unregister_filesystem(&cramfs_fs_type);
568}
569
570module_init(init_cramfs_fs)
571module_exit(exit_cramfs_fs)
572MODULE_LICENSE("GPL");