e141939080f0d6db65c525305cab5a74b9dd552c
[linux-2.6.git] / fs / cramfs / inode.c
1 /*
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>
25 #include <linux/mutex.h>
26
27 #include <asm/uaccess.h>
28
29 static const struct super_operations cramfs_ops;
30 static const struct inode_operations cramfs_dir_inode_operations;
31 static const struct file_operations cramfs_directory_operations;
32 static const struct address_space_operations cramfs_aops;
33
34 static DEFINE_MUTEX(read_mutex);
35
36
37 /* These macros may change in future, to provide better st_ino semantics. */
38 #define OFFSET(x)       ((x)->i_ino)
39
40 static unsigned long cramino(struct cramfs_inode *cino, unsigned int offset)
41 {
42         if (!cino->offset)
43                 return offset + 1;
44         if (!cino->size)
45                 return offset + 1;
46
47         /*
48          * The file mode test fixes buggy mkcramfs implementations where
49          * cramfs_inode->offset is set to a non zero value for entries
50          * which did not contain data, like devices node and fifos.
51          */
52         switch (cino->mode & S_IFMT) {
53         case S_IFREG:
54         case S_IFDIR:
55         case S_IFLNK:
56                 return cino->offset << 2;
57         default:
58                 break;
59         }
60         return offset + 1;
61 }
62
63 static struct inode *get_cramfs_inode(struct super_block *sb,
64         struct cramfs_inode *cramfs_inode, unsigned int offset)
65 {
66         struct inode *inode;
67         static struct timespec zerotime;
68
69         inode = iget_locked(sb, cramino(cramfs_inode, offset));
70         if (!inode)
71                 return ERR_PTR(-ENOMEM);
72         if (!(inode->i_state & I_NEW))
73                 return inode;
74
75         switch (cramfs_inode->mode & S_IFMT) {
76         case S_IFREG:
77                 inode->i_fop = &generic_ro_fops;
78                 inode->i_data.a_ops = &cramfs_aops;
79                 break;
80         case S_IFDIR:
81                 inode->i_op = &cramfs_dir_inode_operations;
82                 inode->i_fop = &cramfs_directory_operations;
83                 break;
84         case S_IFLNK:
85                 inode->i_op = &page_symlink_inode_operations;
86                 inode->i_data.a_ops = &cramfs_aops;
87                 break;
88         default:
89                 init_special_inode(inode, cramfs_inode->mode,
90                                 old_decode_dev(cramfs_inode->size));
91         }
92
93         inode->i_mode = cramfs_inode->mode;
94         inode->i_uid = cramfs_inode->uid;
95         inode->i_gid = cramfs_inode->gid;
96
97         /* if the lower 2 bits are zero, the inode contains data */
98         if (!(inode->i_ino & 3)) {
99                 inode->i_size = cramfs_inode->size;
100                 inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1;
101         }
102
103         /* Struct copy intentional */
104         inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime;
105         /* inode->i_nlink is left 1 - arguably wrong for directories,
106            but it's the best we can do without reading the directory
107            contents.  1 yields the right result in GNU find, even
108            without -noleaf option. */
109
110         unlock_new_inode(inode);
111
112         return inode;
113 }
114
115 /*
116  * We have our own block cache: don't fill up the buffer cache
117  * with the rom-image, because the way the filesystem is set
118  * up the accesses should be fairly regular and cached in the
119  * page cache and dentry tree anyway..
120  *
121  * This also acts as a way to guarantee contiguous areas of up to
122  * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to
123  * worry about end-of-buffer issues even when decompressing a full
124  * page cache.
125  */
126 #define READ_BUFFERS (2)
127 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
128 #define NEXT_BUFFER(_ix) ((_ix) ^ 1)
129
130 /*
131  * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
132  * data that takes up more space than the original and with unlucky
133  * alignment.
134  */
135 #define BLKS_PER_BUF_SHIFT      (2)
136 #define BLKS_PER_BUF            (1 << BLKS_PER_BUF_SHIFT)
137 #define BUFFER_SIZE             (BLKS_PER_BUF*PAGE_CACHE_SIZE)
138
139 static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE];
140 static unsigned buffer_blocknr[READ_BUFFERS];
141 static struct super_block * buffer_dev[READ_BUFFERS];
142 static int next_buffer;
143
144 /*
145  * Returns a pointer to a buffer containing at least LEN bytes of
146  * filesystem starting at byte offset OFFSET into the filesystem.
147  */
148 static void *cramfs_read(struct super_block *sb, unsigned int offset, unsigned int len)
149 {
150         struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
151         struct page *pages[BLKS_PER_BUF];
152         unsigned i, blocknr, buffer;
153         unsigned long devsize;
154         char *data;
155
156         if (!len)
157                 return NULL;
158         blocknr = offset >> PAGE_CACHE_SHIFT;
159         offset &= PAGE_CACHE_SIZE - 1;
160
161         /* Check if an existing buffer already has the data.. */
162         for (i = 0; i < READ_BUFFERS; i++) {
163                 unsigned int blk_offset;
164
165                 if (buffer_dev[i] != sb)
166                         continue;
167                 if (blocknr < buffer_blocknr[i])
168                         continue;
169                 blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_CACHE_SHIFT;
170                 blk_offset += offset;
171                 if (blk_offset + len > BUFFER_SIZE)
172                         continue;
173                 return read_buffers[i] + blk_offset;
174         }
175
176         devsize = mapping->host->i_size >> PAGE_CACHE_SHIFT;
177
178         /* Ok, read in BLKS_PER_BUF pages completely first. */
179         for (i = 0; i < BLKS_PER_BUF; i++) {
180                 struct page *page = NULL;
181
182                 if (blocknr + i < devsize) {
183                         page = read_mapping_page_async(mapping, blocknr + i,
184                                                                         NULL);
185                         /* synchronous error? */
186                         if (IS_ERR(page))
187                                 page = NULL;
188                 }
189                 pages[i] = page;
190         }
191
192         for (i = 0; i < BLKS_PER_BUF; i++) {
193                 struct page *page = pages[i];
194                 if (page) {
195                         wait_on_page_locked(page);
196                         if (!PageUptodate(page)) {
197                                 /* asynchronous error */
198                                 page_cache_release(page);
199                                 pages[i] = NULL;
200                         }
201                 }
202         }
203
204         buffer = next_buffer;
205         next_buffer = NEXT_BUFFER(buffer);
206         buffer_blocknr[buffer] = blocknr;
207         buffer_dev[buffer] = sb;
208
209         data = read_buffers[buffer];
210         for (i = 0; i < BLKS_PER_BUF; i++) {
211                 struct page *page = pages[i];
212                 if (page) {
213                         memcpy(data, kmap(page), PAGE_CACHE_SIZE);
214                         kunmap(page);
215                         page_cache_release(page);
216                 } else
217                         memset(data, 0, PAGE_CACHE_SIZE);
218                 data += PAGE_CACHE_SIZE;
219         }
220         return read_buffers[buffer] + offset;
221 }
222
223 static void cramfs_put_super(struct super_block *sb)
224 {
225         kfree(sb->s_fs_info);
226         sb->s_fs_info = NULL;
227 }
228
229 static int cramfs_remount(struct super_block *sb, int *flags, char *data)
230 {
231         *flags |= MS_RDONLY;
232         return 0;
233 }
234
235 static int cramfs_fill_super(struct super_block *sb, void *data, int silent)
236 {
237         int i;
238         struct cramfs_super super;
239         unsigned long root_offset;
240         struct cramfs_sb_info *sbi;
241         struct inode *root;
242
243         sb->s_flags |= MS_RDONLY;
244
245         sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL);
246         if (!sbi)
247                 return -ENOMEM;
248         sb->s_fs_info = sbi;
249
250         /* Invalidate the read buffers on mount: think disk change.. */
251         mutex_lock(&read_mutex);
252         for (i = 0; i < READ_BUFFERS; i++)
253                 buffer_blocknr[i] = -1;
254
255         /* Read the first block and get the superblock from it */
256         memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super));
257         mutex_unlock(&read_mutex);
258
259         /* Do sanity checks on the superblock */
260         if (super.magic != CRAMFS_MAGIC) {
261                 /* check for wrong endianess */
262                 if (super.magic == CRAMFS_MAGIC_WEND) {
263                         if (!silent)
264                                 printk(KERN_ERR "cramfs: wrong endianess\n");
265                         goto out;
266                 }
267
268                 /* check at 512 byte offset */
269                 mutex_lock(&read_mutex);
270                 memcpy(&super, cramfs_read(sb, 512, sizeof(super)), sizeof(super));
271                 mutex_unlock(&read_mutex);
272                 if (super.magic != CRAMFS_MAGIC) {
273                         if (super.magic == CRAMFS_MAGIC_WEND && !silent)
274                                 printk(KERN_ERR "cramfs: wrong endianess\n");
275                         else if (!silent)
276                                 printk(KERN_ERR "cramfs: wrong magic\n");
277                         goto out;
278                 }
279         }
280
281         /* get feature flags first */
282         if (super.flags & ~CRAMFS_SUPPORTED_FLAGS) {
283                 printk(KERN_ERR "cramfs: unsupported filesystem features\n");
284                 goto out;
285         }
286
287         /* Check that the root inode is in a sane state */
288         if (!S_ISDIR(super.root.mode)) {
289                 printk(KERN_ERR "cramfs: root is not a directory\n");
290                 goto out;
291         }
292         /* correct strange, hard-coded permissions of mkcramfs */
293         super.root.mode |= (S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
294
295         root_offset = super.root.offset << 2;
296         if (super.flags & CRAMFS_FLAG_FSID_VERSION_2) {
297                 sbi->size=super.size;
298                 sbi->blocks=super.fsid.blocks;
299                 sbi->files=super.fsid.files;
300         } else {
301                 sbi->size=1<<28;
302                 sbi->blocks=0;
303                 sbi->files=0;
304         }
305         sbi->magic=super.magic;
306         sbi->flags=super.flags;
307         if (root_offset == 0)
308                 printk(KERN_INFO "cramfs: empty filesystem");
309         else if (!(super.flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
310                  ((root_offset != sizeof(struct cramfs_super)) &&
311                   (root_offset != 512 + sizeof(struct cramfs_super))))
312         {
313                 printk(KERN_ERR "cramfs: bad root offset %lu\n", root_offset);
314                 goto out;
315         }
316
317         /* Set it all up.. */
318         sb->s_op = &cramfs_ops;
319         root = get_cramfs_inode(sb, &super.root, 0);
320         if (!root)
321                 goto out;
322         sb->s_root = d_alloc_root(root);
323         if (!sb->s_root) {
324                 iput(root);
325                 goto out;
326         }
327         return 0;
328 out:
329         kfree(sbi);
330         sb->s_fs_info = NULL;
331         return -EINVAL;
332 }
333
334 static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf)
335 {
336         struct super_block *sb = dentry->d_sb;
337         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
338
339         buf->f_type = CRAMFS_MAGIC;
340         buf->f_bsize = PAGE_CACHE_SIZE;
341         buf->f_blocks = CRAMFS_SB(sb)->blocks;
342         buf->f_bfree = 0;
343         buf->f_bavail = 0;
344         buf->f_files = CRAMFS_SB(sb)->files;
345         buf->f_ffree = 0;
346         buf->f_fsid.val[0] = (u32)id;
347         buf->f_fsid.val[1] = (u32)(id >> 32);
348         buf->f_namelen = CRAMFS_MAXPATHLEN;
349         return 0;
350 }
351
352 /*
353  * Read a cramfs directory entry.
354  */
355 static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
356 {
357         struct inode *inode = filp->f_path.dentry->d_inode;
358         struct super_block *sb = inode->i_sb;
359         char *buf;
360         unsigned int offset;
361         int copied;
362
363         /* Offset within the thing. */
364         offset = filp->f_pos;
365         if (offset >= inode->i_size)
366                 return 0;
367         /* Directory entries are always 4-byte aligned */
368         if (offset & 3)
369                 return -EINVAL;
370
371         buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL);
372         if (!buf)
373                 return -ENOMEM;
374
375         copied = 0;
376         while (offset < inode->i_size) {
377                 struct cramfs_inode *de;
378                 unsigned long nextoffset;
379                 char *name;
380                 ino_t ino;
381                 mode_t mode;
382                 int namelen, error;
383
384                 mutex_lock(&read_mutex);
385                 de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN);
386                 name = (char *)(de+1);
387
388                 /*
389                  * Namelengths on disk are shifted by two
390                  * and the name padded out to 4-byte boundaries
391                  * with zeroes.
392                  */
393                 namelen = de->namelen << 2;
394                 memcpy(buf, name, namelen);
395                 ino = cramino(de, OFFSET(inode) + offset);
396                 mode = de->mode;
397                 mutex_unlock(&read_mutex);
398                 nextoffset = offset + sizeof(*de) + namelen;
399                 for (;;) {
400                         if (!namelen) {
401                                 kfree(buf);
402                                 return -EIO;
403                         }
404                         if (buf[namelen-1])
405                                 break;
406                         namelen--;
407                 }
408                 error = filldir(dirent, buf, namelen, offset, ino, mode >> 12);
409                 if (error)
410                         break;
411
412                 offset = nextoffset;
413                 filp->f_pos = offset;
414                 copied++;
415         }
416         kfree(buf);
417         return 0;
418 }
419
420 /*
421  * Lookup and fill in the inode data..
422  */
423 static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
424 {
425         unsigned int offset = 0;
426         int sorted;
427
428         mutex_lock(&read_mutex);
429         sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS;
430         while (offset < dir->i_size) {
431                 struct cramfs_inode *de;
432                 char *name;
433                 int namelen, retval;
434                 int dir_off = OFFSET(dir) + offset;
435
436                 de = cramfs_read(dir->i_sb, dir_off, sizeof(*de)+CRAMFS_MAXPATHLEN);
437                 name = (char *)(de+1);
438
439                 /* Try to take advantage of sorted directories */
440                 if (sorted && (dentry->d_name.name[0] < name[0]))
441                         break;
442
443                 namelen = de->namelen << 2;
444                 offset += sizeof(*de) + namelen;
445
446                 /* Quick check that the name is roughly the right length */
447                 if (((dentry->d_name.len + 3) & ~3) != namelen)
448                         continue;
449
450                 for (;;) {
451                         if (!namelen) {
452                                 mutex_unlock(&read_mutex);
453                                 return ERR_PTR(-EIO);
454                         }
455                         if (name[namelen-1])
456                                 break;
457                         namelen--;
458                 }
459                 if (namelen != dentry->d_name.len)
460                         continue;
461                 retval = memcmp(dentry->d_name.name, name, namelen);
462                 if (retval > 0)
463                         continue;
464                 if (!retval) {
465                         struct cramfs_inode entry = *de;
466                         mutex_unlock(&read_mutex);
467                         d_add(dentry, get_cramfs_inode(dir->i_sb, &entry, dir_off));
468                         return NULL;
469                 }
470                 /* else (retval < 0) */
471                 if (sorted)
472                         break;
473         }
474         mutex_unlock(&read_mutex);
475         d_add(dentry, NULL);
476         return NULL;
477 }
478
479 static int cramfs_readpage(struct file *file, struct page * page)
480 {
481         struct inode *inode = page->mapping->host;
482         u32 maxblock;
483         int bytes_filled;
484         void *pgdata;
485
486         maxblock = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
487         bytes_filled = 0;
488         pgdata = kmap(page);
489
490         if (page->index < maxblock) {
491                 struct super_block *sb = inode->i_sb;
492                 u32 blkptr_offset = OFFSET(inode) + page->index*4;
493                 u32 start_offset, compr_len;
494
495                 start_offset = OFFSET(inode) + maxblock*4;
496                 mutex_lock(&read_mutex);
497                 if (page->index)
498                         start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4,
499                                 4);
500                 compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) -
501                         start_offset);
502                 mutex_unlock(&read_mutex);
503
504                 if (compr_len == 0)
505                         ; /* hole */
506                 else if (unlikely(compr_len > (PAGE_CACHE_SIZE << 1))) {
507                         pr_err("cramfs: bad compressed blocksize %u\n",
508                                 compr_len);
509                         goto err;
510                 } else {
511                         mutex_lock(&read_mutex);
512                         bytes_filled = cramfs_uncompress_block(pgdata,
513                                  PAGE_CACHE_SIZE,
514                                  cramfs_read(sb, start_offset, compr_len),
515                                  compr_len);
516                         mutex_unlock(&read_mutex);
517                         if (unlikely(bytes_filled < 0))
518                                 goto err;
519                 }
520         }
521
522         memset(pgdata + bytes_filled, 0, PAGE_CACHE_SIZE - bytes_filled);
523         flush_dcache_page(page);
524         kunmap(page);
525         SetPageUptodate(page);
526         unlock_page(page);
527         return 0;
528
529 err:
530         kunmap(page);
531         ClearPageUptodate(page);
532         SetPageError(page);
533         unlock_page(page);
534         return 0;
535 }
536
537 static const struct address_space_operations cramfs_aops = {
538         .readpage = cramfs_readpage
539 };
540
541 /*
542  * Our operations:
543  */
544
545 /*
546  * A directory can only readdir
547  */
548 static const struct file_operations cramfs_directory_operations = {
549         .llseek         = generic_file_llseek,
550         .read           = generic_read_dir,
551         .readdir        = cramfs_readdir,
552 };
553
554 static const struct inode_operations cramfs_dir_inode_operations = {
555         .lookup         = cramfs_lookup,
556 };
557
558 static const struct super_operations cramfs_ops = {
559         .put_super      = cramfs_put_super,
560         .remount_fs     = cramfs_remount,
561         .statfs         = cramfs_statfs,
562 };
563
564 static struct dentry *cramfs_mount(struct file_system_type *fs_type,
565         int flags, const char *dev_name, void *data)
566 {
567         return mount_bdev(fs_type, flags, dev_name, data, cramfs_fill_super);
568 }
569
570 static struct file_system_type cramfs_fs_type = {
571         .owner          = THIS_MODULE,
572         .name           = "cramfs",
573         .mount          = cramfs_mount,
574         .kill_sb        = kill_block_super,
575         .fs_flags       = FS_REQUIRES_DEV,
576 };
577
578 static int __init init_cramfs_fs(void)
579 {
580         int rv;
581
582         rv = cramfs_uncompress_init();
583         if (rv < 0)
584                 return rv;
585         rv = register_filesystem(&cramfs_fs_type);
586         if (rv < 0)
587                 cramfs_uncompress_exit();
588         return rv;
589 }
590
591 static void __exit exit_cramfs_fs(void)
592 {
593         cramfs_uncompress_exit();
594         unregister_filesystem(&cramfs_fs_type);
595 }
596
597 module_init(init_cramfs_fs)
598 module_exit(exit_cramfs_fs)
599 MODULE_LICENSE("GPL");