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");