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