fs/qnx6/inode.c

   1 /*
   2  * QNX6 file system, Linux implementation.
   3  *
   4  * Version : 1.0.0
   5  *
   6  * History :
   7  *
   8  * 01-02-2012 by Kai Bankett ([email protected]) : first release.
   9  * 16-02-2012 pagemap extension by Al Viro
  10  *
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/slab.h>
  16 #include <linux/highuid.h>
  17 #include <linux/pagemap.h>
  18 #include <linux/buffer_head.h>
  19 #include <linux/writeback.h>
  20 #include <linux/statfs.h>
  21 #include <linux/parser.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/mount.h>
  24 #include <linux/crc32.h>
  25 #include <linux/mpage.h>
  26 #include "qnx6.h"
  27
  28 static const struct super_operations qnx6_sops;
  29
  30 static void qnx6_put_super(struct super_block *sb);
  31 static struct inode *qnx6_alloc_inode(struct super_block *sb);
  32 static void qnx6_destroy_inode(struct inode *inode);
  33 static int qnx6_remount(struct super_block *sb, int *flags, char *data);
  34 static int qnx6_statfs(struct dentry *dentry, struct kstatfs *buf);
  35 static int qnx6_show_options(struct seq_file *seq, struct dentry *root);
  36
  37 static const struct super_operations qnx6_sops = {
  38         .alloc_inode    = qnx6_alloc_inode,
  39         .destroy_inode  = qnx6_destroy_inode,
  40         .put_super      = qnx6_put_super,
  41         .statfs         = qnx6_statfs,
  42         .remount_fs     = qnx6_remount,
  43         .show_options   = qnx6_show_options,
  44 };
  45
  46 static int qnx6_show_options(struct seq_file *seq, struct dentry *root)
  47 {
  48         struct super_block *sb = root->d_sb;
  49         struct qnx6_sb_info *sbi = QNX6_SB(sb);
  50
  51         if (sbi->s_mount_opt & QNX6_MOUNT_MMI_FS)
  52                 seq_puts(seq, ",mmi_fs");
  53         return 0;
  54 }
  55
  56 static int qnx6_remount(struct super_block *sb, int *flags, char *data)
  57 {
  58         sync_filesystem(sb);
  59         *flags |= MS_RDONLY;
  60         return 0;
  61 }
  62
  63 static unsigned qnx6_get_devblock(struct super_block *sb, __fs32 block)
  64 {
  65         struct qnx6_sb_info *sbi = QNX6_SB(sb);
  66         return fs32_to_cpu(sbi, block) + sbi->s_blks_off;
  67 }
  68
  69 static unsigned qnx6_block_map(struct inode *inode, unsigned iblock);
  70
  71 static int qnx6_get_block(struct inode *inode, sector_t iblock,
  72                         struct buffer_head *bh, int create)
  73 {
  74         unsigned phys;
  75
  76         QNX6DEBUG((KERN_INFO "qnx6: qnx6_get_block inode=[%ld] iblock=[%ld]\n",
  77                         inode->i_ino, (unsigned long)iblock));
  78
  79         phys = qnx6_block_map(inode, iblock);
  80         if (phys) {
  81                 /* logical block is before EOF */
  82                 map_bh(bh, inode->i_sb, phys);
  83         }
  84         return 0;
  85 }
  86
  87 static int qnx6_check_blockptr(__fs32 ptr)
  88 {
  89         if (ptr == ~(__fs32)0) {
  90                 printk(KERN_ERR "qnx6: hit unused blockpointer.\n");
  91                 return 0;
  92         }
  93         return 1;
  94 }
  95
  96 static int qnx6_readpage(struct file *file, struct page *page)
  97 {
  98         return mpage_readpage(page, qnx6_get_block);
  99 }
 100
 101 static int qnx6_readpages(struct file *file, struct address_space *mapping,
 102                    struct list_head *pages, unsigned nr_pages)
 103 {
 104         return mpage_readpages(mapping, pages, nr_pages, qnx6_get_block);
 105 }
 106
 107 /*
 108  * returns the block number for the no-th element in the tree
 109  * inodebits requred as there are multiple inodes in one inode block
 110  */
 111 static unsigned qnx6_block_map(struct inode *inode, unsigned no)
 112 {
 113         struct super_block *s = inode->i_sb;
 114         struct qnx6_sb_info *sbi = QNX6_SB(s);
 115         struct qnx6_inode_info *ei = QNX6_I(inode);
 116         unsigned block = 0;
 117         struct buffer_head *bh;
 118         __fs32 ptr;
 119         int levelptr;
 120         int ptrbits = sbi->s_ptrbits;
 121         int bitdelta;
 122         u32 mask = (1 << ptrbits) - 1;
 123         int depth = ei->di_filelevels;
 124         int i;
 125
 126         bitdelta = ptrbits * depth;
 127         levelptr = no >> bitdelta;
 128
 129         if (levelptr > QNX6_NO_DIRECT_POINTERS - 1) {
 130                 printk(KERN_ERR "qnx6:Requested file block number (%u) too big.",
 131                                 no);
 132                 return 0;
 133         }
 134
 135         block = qnx6_get_devblock(s, ei->di_block_ptr[levelptr]);
 136
 137         for (i = 0; i < depth; i++) {
 138                 bh = sb_bread(s, block);
 139                 if (!bh) {
 140                         printk(KERN_ERR "qnx6:Error reading block (%u)\n",
 141                                         block);
 142                         return 0;
 143                 }
 144                 bitdelta -= ptrbits;
 145                 levelptr = (no >> bitdelta) & mask;
 146                 ptr = ((__fs32 *)bh->b_data)[levelptr];
 147
 148                 if (!qnx6_check_blockptr(ptr))
 149                         return 0;
 150
 151                 block = qnx6_get_devblock(s, ptr);
 152                 brelse(bh);
 153         }
 154         return block;
 155 }
 156
 157 static int qnx6_statfs(struct dentry *dentry, struct kstatfs *buf)
 158 {
 159         struct super_block *sb = dentry->d_sb;
 160         struct qnx6_sb_info *sbi = QNX6_SB(sb);
 161         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
 162
 163         buf->f_type    = sb->s_magic;
 164         buf->f_bsize   = sb->s_blocksize;
 165         buf->f_blocks  = fs32_to_cpu(sbi, sbi->sb->sb_num_blocks);
 166         buf->f_bfree   = fs32_to_cpu(sbi, sbi->sb->sb_free_blocks);
 167         buf->f_files   = fs32_to_cpu(sbi, sbi->sb->sb_num_inodes);
 168         buf->f_ffree   = fs32_to_cpu(sbi, sbi->sb->sb_free_inodes);
 169         buf->f_bavail  = buf->f_bfree;
 170         buf->f_namelen = QNX6_LONG_NAME_MAX;
 171         buf->f_fsid.val[0] = (u32)id;
 172         buf->f_fsid.val[1] = (u32)(id >> 32);
 173
 174         return 0;
 175 }
 176
 177 /*
 178  * Check the root directory of the filesystem to make sure
 179  * it really _is_ a qnx6 filesystem, and to check the size
 180  * of the directory entry.
 181  */
 182 static const char *qnx6_checkroot(struct super_block *s)
 183 {
 184         static char match_root[2][3] = {".\0\0", "..\0"};
 185         int i, error = 0;
 186         struct qnx6_dir_entry *dir_entry;
 187         struct inode *root = s->s_root->d_inode;
 188         struct address_space *mapping = root->i_mapping;
 189         struct page *page = read_mapping_page(mapping, 0, NULL);
 190         if (IS_ERR(page))
 191                 return "error reading root directory";
 192         kmap(page);
 193         dir_entry = page_address(page);
 194         for (i = 0; i < 2; i++) {
 195                 /* maximum 3 bytes - due to match_root limitation */
 196                 if (strncmp(dir_entry[i].de_fname, match_root[i], 3))
 197                         error = 1;
 198         }
 199         qnx6_put_page(page);
 200         if (error)
 201                 return "error reading root directory.";
 202         return NULL;
 203 }
 204
 205 #ifdef CONFIG_QNX6FS_DEBUG
 206 void qnx6_superblock_debug(struct qnx6_super_block *sb, struct super_block *s)
 207 {
 208         struct qnx6_sb_info *sbi = QNX6_SB(s);
 209
 210         QNX6DEBUG((KERN_INFO "magic: %08x\n",
 211                                 fs32_to_cpu(sbi, sb->sb_magic)));
 212         QNX6DEBUG((KERN_INFO "checksum: %08x\n",
 213                                 fs32_to_cpu(sbi, sb->sb_checksum)));
 214         QNX6DEBUG((KERN_INFO "serial: %llx\n",
 215                                 fs64_to_cpu(sbi, sb->sb_serial)));
 216         QNX6DEBUG((KERN_INFO "flags: %08x\n",
 217                                 fs32_to_cpu(sbi, sb->sb_flags)));
 218         QNX6DEBUG((KERN_INFO "blocksize: %08x\n",
 219                                 fs32_to_cpu(sbi, sb->sb_blocksize)));
 220         QNX6DEBUG((KERN_INFO "num_inodes: %08x\n",
 221                                 fs32_to_cpu(sbi, sb->sb_num_inodes)));
 222         QNX6DEBUG((KERN_INFO "free_inodes: %08x\n",
 223                                 fs32_to_cpu(sbi, sb->sb_free_inodes)));
 224         QNX6DEBUG((KERN_INFO "num_blocks: %08x\n",
 225                                 fs32_to_cpu(sbi, sb->sb_num_blocks)));
 226         QNX6DEBUG((KERN_INFO "free_blocks: %08x\n",
 227                                 fs32_to_cpu(sbi, sb->sb_free_blocks)));
 228         QNX6DEBUG((KERN_INFO "inode_levels: %02x\n",
 229                                 sb->Inode.levels));
 230 }
 231 #endif
 232
 233 enum {
 234         Opt_mmifs,
 235         Opt_err
 236 };
 237
 238 static const match_table_t tokens = {
 239         {Opt_mmifs, "mmi_fs"},
 240         {Opt_err, NULL}
 241 };
 242
 243 static int qnx6_parse_options(char *options, struct super_block *sb)
 244 {
 245         char *p;
 246         struct qnx6_sb_info *sbi = QNX6_SB(sb);
 247         substring_t args[MAX_OPT_ARGS];
 248
 249         if (!options)
 250                 return 1;
 251
 252         while ((p = strsep(&options, ",")) != NULL) {
 253                 int token;
 254                 if (!*p)
 255                         continue;
 256
 257                 token = match_token(p, tokens, args);
 258                 switch (token) {
 259                 case Opt_mmifs:
 260                         set_opt(sbi->s_mount_opt, MMI_FS);
 261                         break;
 262                 default:
 263                         return 0;
 264                 }
 265         }
 266         return 1;
 267 }
 268
 269 static struct buffer_head *qnx6_check_first_superblock(struct super_block *s,
 270                                 int offset, int silent)
 271 {
 272         struct qnx6_sb_info *sbi = QNX6_SB(s);
 273         struct buffer_head *bh;
 274         struct qnx6_super_block *sb;
 275
 276         /* Check the superblock signatures
 277            start with the first superblock */
 278         bh = sb_bread(s, offset);
 279         if (!bh) {
 280                 printk(KERN_ERR "qnx6: unable to read the first superblock\n");
 281                 return NULL;
 282         }
 283         sb = (struct qnx6_super_block *)bh->b_data;
 284         if (fs32_to_cpu(sbi, sb->sb_magic) != QNX6_SUPER_MAGIC) {
 285                 sbi->s_bytesex = BYTESEX_BE;
 286                 if (fs32_to_cpu(sbi, sb->sb_magic) == QNX6_SUPER_MAGIC) {
 287                         /* we got a big endian fs */
 288                         QNX6DEBUG((KERN_INFO "qnx6: fs got different"
 289                                         " endianness.\n"));
 290                         return bh;
 291                 } else
 292                         sbi->s_bytesex = BYTESEX_LE;
 293                 if (!silent) {
 294                         if (offset == 0) {
 295                                 printk(KERN_ERR "qnx6: wrong signature (magic)"
 296                                         " in superblock #1.\n");
 297                         } else {
 298                                 printk(KERN_INFO "qnx6: wrong signature (magic)"
 299                                         " at position (0x%lx) - will try"
 300                                         " alternative position (0x0000).\n",
 301                                                 offset * s->s_blocksize);
 302                         }
 303                 }
 304                 brelse(bh);
 305                 return NULL;
 306         }
 307         return bh;
 308 }
 309
 310 static struct inode *qnx6_private_inode(struct super_block *s,
 311                                         struct qnx6_root_node *p);
 312
 313 static int qnx6_fill_super(struct super_block *s, void *data, int silent)
 314 {
 315         struct buffer_head *bh1 = NULL, *bh2 = NULL;
 316         struct qnx6_super_block *sb1 = NULL, *sb2 = NULL;
 317         struct qnx6_sb_info *sbi;
 318         struct inode *root;
 319         const char *errmsg;
 320         struct qnx6_sb_info *qs;
 321         int ret = -EINVAL;
 322         u64 offset;
 323         int bootblock_offset = QNX6_BOOTBLOCK_SIZE;
 324
 325         qs = kzalloc(sizeof(struct qnx6_sb_info), GFP_KERNEL);
 326         if (!qs)
 327                 return -ENOMEM;
 328         s->s_fs_info = qs;
 329
 330         /* Superblock always is 512 Byte long */
 331         if (!sb_set_blocksize(s, QNX6_SUPERBLOCK_SIZE)) {
 332                 printk(KERN_ERR "qnx6: unable to set blocksize\n");
 333                 goto outnobh;
 334         }
 335
 336         /* parse the mount-options */
 337         if (!qnx6_parse_options((char *) data, s)) {
 338                 printk(KERN_ERR "qnx6: invalid mount options.\n");
 339                 goto outnobh;
 340         }
 341         if (test_opt(s, MMI_FS)) {
 342                 sb1 = qnx6_mmi_fill_super(s, silent);
 343                 if (sb1)
 344                         goto mmi_success;
 345                 else
 346                         goto outnobh;
 347         }
 348         sbi = QNX6_SB(s);
 349         sbi->s_bytesex = BYTESEX_LE;
 350         /* Check the superblock signatures
 351            start with the first superblock */
 352         bh1 = qnx6_check_first_superblock(s,
 353                 bootblock_offset / QNX6_SUPERBLOCK_SIZE, silent);
 354         if (!bh1) {
 355                 /* try again without bootblock offset */
 356                 bh1 = qnx6_check_first_superblock(s, 0, silent);
 357                 if (!bh1) {
 358                         printk(KERN_ERR "qnx6: unable to read the first superblock\n");
 359                         goto outnobh;
 360                 }
 361                 /* seems that no bootblock at partition start */
 362                 bootblock_offset = 0;
 363         }
 364         sb1 = (struct qnx6_super_block *)bh1->b_data;
 365
 366 #ifdef CONFIG_QNX6FS_DEBUG
 367         qnx6_superblock_debug(sb1, s);
 368 #endif
 369
 370         /* checksum check - start at byte 8 and end at byte 512 */
 371         if (fs32_to_cpu(sbi, sb1->sb_checksum) !=
 372                         crc32_be(0, (char *)(bh1->b_data + 8), 504)) {
 373                 printk(KERN_ERR "qnx6: superblock #1 checksum error\n");
 374                 goto out;
 375         }
 376
 377         /* set new blocksize */
 378         if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) {
 379                 printk(KERN_ERR "qnx6: unable to set blocksize\n");
 380                 goto out;
 381         }
 382         /* blocksize invalidates bh - pull it back in */
 383         brelse(bh1);
 384         bh1 = sb_bread(s, bootblock_offset >> s->s_blocksize_bits);
 385         if (!bh1)
 386                 goto outnobh;
 387         sb1 = (struct qnx6_super_block *)bh1->b_data;
 388
 389         /* calculate second superblock blocknumber */
 390         offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) +
 391                 (bootblock_offset >> s->s_blocksize_bits) +
 392                 (QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits);
 393
 394         /* set bootblock offset */
 395         sbi->s_blks_off = (bootblock_offset >> s->s_blocksize_bits) +
 396                           (QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits);
 397
 398         /* next the second superblock */
 399         bh2 = sb_bread(s, offset);
 400         if (!bh2) {
 401                 printk(KERN_ERR "qnx6: unable to read the second superblock\n");
 402                 goto out;
 403         }
 404         sb2 = (struct qnx6_super_block *)bh2->b_data;
 405         if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) {
 406                 if (!silent)
 407                         printk(KERN_ERR "qnx6: wrong signature (magic)"
 408                                         " in superblock #2.\n");
 409                 goto out;
 410         }
 411
 412         /* checksum check - start at byte 8 and end at byte 512 */
 413         if (fs32_to_cpu(sbi, sb2->sb_checksum) !=
 414                                 crc32_be(0, (char *)(bh2->b_data + 8), 504)) {
 415                 printk(KERN_ERR "qnx6: superblock #2 checksum error\n");
 416                 goto out;
 417         }
 418
 419         if (fs64_to_cpu(sbi, sb1->sb_serial) >=
 420                                         fs64_to_cpu(sbi, sb2->sb_serial)) {
 421                 /* superblock #1 active */
 422                 sbi->sb_buf = bh1;
 423                 sbi->sb = (struct qnx6_super_block *)bh1->b_data;
 424                 brelse(bh2);
 425                 printk(KERN_INFO "qnx6: superblock #1 active\n");
 426         } else {
 427                 /* superblock #2 active */
 428                 sbi->sb_buf = bh2;
 429                 sbi->sb = (struct qnx6_super_block *)bh2->b_data;
 430                 brelse(bh1);
 431                 printk(KERN_INFO "qnx6: superblock #2 active\n");
 432         }
 433 mmi_success:
 434         /* sanity check - limit maximum indirect pointer levels */
 435         if (sb1->Inode.levels > QNX6_PTR_MAX_LEVELS) {
 436                 printk(KERN_ERR "qnx6: too many inode levels (max %i, sb %i)\n",
 437                         QNX6_PTR_MAX_LEVELS, sb1->Inode.levels);
 438                 goto out;
 439         }
 440         if (sb1->Longfile.levels > QNX6_PTR_MAX_LEVELS) {
 441                 printk(KERN_ERR "qnx6: too many longfilename levels"
 442                                 " (max %i, sb %i)\n",
 443                         QNX6_PTR_MAX_LEVELS, sb1->Longfile.levels);
 444                 goto out;
 445         }
 446         s->s_op = &qnx6_sops;
 447         s->s_magic = QNX6_SUPER_MAGIC;
 448         s->s_flags |= MS_RDONLY;        /* Yup, read-only yet */
 449
 450         /* ease the later tree level calculations */
 451         sbi = QNX6_SB(s);
 452         sbi->s_ptrbits = ilog2(s->s_blocksize / 4);
 453         sbi->inodes = qnx6_private_inode(s, &sb1->Inode);
 454         if (!sbi->inodes)
 455                 goto out;
 456         sbi->longfile = qnx6_private_inode(s, &sb1->Longfile);
 457         if (!sbi->longfile)
 458                 goto out1;
 459
 460         /* prefetch root inode */
 461         root = qnx6_iget(s, QNX6_ROOT_INO);
 462         if (IS_ERR(root)) {
 463                 printk(KERN_ERR "qnx6: get inode failed\n");
 464                 ret = PTR_ERR(root);
 465                 goto out2;
 466         }
 467
 468         ret = -ENOMEM;
 469         s->s_root = d_make_root(root);
 470         if (!s->s_root)
 471                 goto out2;
 472
 473         ret = -EINVAL;
 474         errmsg = qnx6_checkroot(s);
 475         if (errmsg != NULL) {
 476                 if (!silent)
 477                         printk(KERN_ERR "qnx6: %s\n", errmsg);
 478                 goto out3;
 479         }
 480         return 0;
 481
 482 out3:
 483         dput(s->s_root);
 484         s->s_root = NULL;
 485 out2:
 486         iput(sbi->longfile);
 487 out1:
 488         iput(sbi->inodes);
 489 out:
 490         if (bh1)
 491                 brelse(bh1);
 492         if (bh2)
 493                 brelse(bh2);
 494 outnobh:
 495         kfree(qs);
 496         s->s_fs_info = NULL;
 497         return ret;
 498 }
 499
 500 static void qnx6_put_super(struct super_block *sb)
 501 {
 502         struct qnx6_sb_info *qs = QNX6_SB(sb);
 503         brelse(qs->sb_buf);
 504         iput(qs->longfile);
 505         iput(qs->inodes);
 506         kfree(qs);
 507         sb->s_fs_info = NULL;
 508         return;
 509 }
 510
 511 static sector_t qnx6_bmap(struct address_space *mapping, sector_t block)
 512 {
 513         return generic_block_bmap(mapping, block, qnx6_get_block);
 514 }
 515 static const struct address_space_operations qnx6_aops = {
 516         .readpage       = qnx6_readpage,
 517         .readpages      = qnx6_readpages,
 518         .bmap           = qnx6_bmap
 519 };
 520
 521 static struct inode *qnx6_private_inode(struct super_block *s,
 522                                         struct qnx6_root_node *p)
 523 {
 524         struct inode *inode = new_inode(s);
 525         if (inode) {
 526                 struct qnx6_inode_info *ei = QNX6_I(inode);
 527                 struct qnx6_sb_info *sbi = QNX6_SB(s);
 528                 inode->i_size = fs64_to_cpu(sbi, p->size);
 529                 memcpy(ei->di_block_ptr, p->ptr, sizeof(p->ptr));
 530                 ei->di_filelevels = p->levels;
 531                 inode->i_mode = S_IFREG | S_IRUSR; /* probably wrong */
 532                 inode->i_mapping->a_ops = &qnx6_aops;
 533         }
 534         return inode;
 535 }
 536
 537 struct inode *qnx6_iget(struct super_block *sb, unsigned ino)
 538 {
 539         struct qnx6_sb_info *sbi = QNX6_SB(sb);
 540         struct qnx6_inode_entry *raw_inode;
 541         struct inode *inode;
 542         struct qnx6_inode_info  *ei;
 543         struct address_space *mapping;
 544         struct page *page;
 545         u32 n, offs;
 546
 547         inode = iget_locked(sb, ino);
 548         if (!inode)
 549                 return ERR_PTR(-ENOMEM);
 550         if (!(inode->i_state & I_NEW))
 551                 return inode;
 552
 553         ei = QNX6_I(inode);
 554
 555         inode->i_mode = 0;
 556
 557         if (ino == 0) {
 558                 printk(KERN_ERR "qnx6: bad inode number on dev %s: %u is "
 559                                 "out of range\n",
 560                        sb->s_id, ino);
 561                 iget_failed(inode);
 562                 return ERR_PTR(-EIO);
 563         }
 564         n = (ino - 1) >> (PAGE_CACHE_SHIFT - QNX6_INODE_SIZE_BITS);
 565         offs = (ino - 1) & (~PAGE_CACHE_MASK >> QNX6_INODE_SIZE_BITS);
 566         mapping = sbi->inodes->i_mapping;
 567         page = read_mapping_page(mapping, n, NULL);
 568         if (IS_ERR(page)) {
 569                 printk(KERN_ERR "qnx6: major problem: unable to read inode from "
 570                        "dev %s\n", sb->s_id);
 571                 iget_failed(inode);
 572                 return ERR_CAST(page);
 573         }
 574         kmap(page);
 575         raw_inode = ((struct qnx6_inode_entry *)page_address(page)) + offs;
 576
 577         inode->i_mode    = fs16_to_cpu(sbi, raw_inode->di_mode);
 578         i_uid_write(inode, (uid_t)fs32_to_cpu(sbi, raw_inode->di_uid));
 579         i_gid_write(inode, (gid_t)fs32_to_cpu(sbi, raw_inode->di_gid));
 580         inode->i_size    = fs64_to_cpu(sbi, raw_inode->di_size);
 581         inode->i_mtime.tv_sec   = fs32_to_cpu(sbi, raw_inode->di_mtime);
 582         inode->i_mtime.tv_nsec = 0;
 583         inode->i_atime.tv_sec   = fs32_to_cpu(sbi, raw_inode->di_atime);
 584         inode->i_atime.tv_nsec = 0;
 585         inode->i_ctime.tv_sec   = fs32_to_cpu(sbi, raw_inode->di_ctime);
 586         inode->i_ctime.tv_nsec = 0;
 587
 588         /* calc blocks based on 512 byte blocksize */
 589         inode->i_blocks = (inode->i_size + 511) >> 9;
 590
 591         memcpy(&ei->di_block_ptr, &raw_inode->di_block_ptr,
 592                                 sizeof(raw_inode->di_block_ptr));
 593         ei->di_filelevels = raw_inode->di_filelevels;
 594
 595         if (S_ISREG(inode->i_mode)) {
 596                 inode->i_fop = &generic_ro_fops;
 597                 inode->i_mapping->a_ops = &qnx6_aops;
 598         } else if (S_ISDIR(inode->i_mode)) {
 599                 inode->i_op = &qnx6_dir_inode_operations;
 600                 inode->i_fop = &qnx6_dir_operations;
 601                 inode->i_mapping->a_ops = &qnx6_aops;
 602         } else if (S_ISLNK(inode->i_mode)) {
 603                 inode->i_op = &page_symlink_inode_operations;
 604                 inode->i_mapping->a_ops = &qnx6_aops;
 605         } else
 606                 init_special_inode(inode, inode->i_mode, 0);
 607         qnx6_put_page(page);
 608         unlock_new_inode(inode);
 609         return inode;
 610 }
 611
 612 static struct kmem_cache *qnx6_inode_cachep;
 613
 614 static struct inode *qnx6_alloc_inode(struct super_block *sb)
 615 {
 616         struct qnx6_inode_info *ei;
 617         ei = kmem_cache_alloc(qnx6_inode_cachep, GFP_KERNEL);
 618         if (!ei)
 619                 return NULL;
 620         return &ei->vfs_inode;
 621 }
 622
 623 static void qnx6_i_callback(struct rcu_head *head)
 624 {
 625         struct inode *inode = container_of(head, struct inode, i_rcu);
 626         kmem_cache_free(qnx6_inode_cachep, QNX6_I(inode));
 627 }
 628
 629 static void qnx6_destroy_inode(struct inode *inode)
 630 {
 631         call_rcu(&inode->i_rcu, qnx6_i_callback);
 632 }
 633
 634 static void init_once(void *foo)
 635 {
 636         struct qnx6_inode_info *ei = (struct qnx6_inode_info *) foo;
 637
 638         inode_init_once(&ei->vfs_inode);
 639 }
 640
 641 static int init_inodecache(void)
 642 {
 643         qnx6_inode_cachep = kmem_cache_create("qnx6_inode_cache",
 644                                              sizeof(struct qnx6_inode_info),
 645                                              0, (SLAB_RECLAIM_ACCOUNT|
 646                                                 SLAB_MEM_SPREAD),
 647                                              init_once);
 648         if (!qnx6_inode_cachep)
 649                 return -ENOMEM;
 650         return 0;
 651 }
 652
 653 static void destroy_inodecache(void)
 654 {
 655         /*
 656          * Make sure all delayed rcu free inodes are flushed before we
 657          * destroy cache.
 658          */
 659         rcu_barrier();
 660         kmem_cache_destroy(qnx6_inode_cachep);
 661 }
 662
 663 static struct dentry *qnx6_mount(struct file_system_type *fs_type,
 664         int flags, const char *dev_name, void *data)
 665 {
 666         return mount_bdev(fs_type, flags, dev_name, data, qnx6_fill_super);
 667 }
 668
 669 static struct file_system_type qnx6_fs_type = {
 670         .owner          = THIS_MODULE,
 671         .name           = "qnx6",
 672         .mount          = qnx6_mount,
 673         .kill_sb        = kill_block_super,
 674         .fs_flags       = FS_REQUIRES_DEV,
 675 };
 676 MODULE_ALIAS_FS("qnx6");
 677
 678 static int __init init_qnx6_fs(void)
 679 {
 680         int err;
 681
 682         err = init_inodecache();
 683         if (err)
 684                 return err;
 685
 686         err = register_filesystem(&qnx6_fs_type);
 687         if (err) {
 688                 destroy_inodecache();
 689                 return err;
 690         }
 691
 692         printk(KERN_INFO "QNX6 filesystem 1.0.0 registered.\n");
 693         return 0;
 694 }
 695
 696 static void __exit exit_qnx6_fs(void)
 697 {
 698         unregister_filesystem(&qnx6_fs_type);
 699         destroy_inodecache();
 700 }
 701
 702 module_init(init_qnx6_fs)
 703 module_exit(exit_qnx6_fs)
 704 MODULE_LICENSE("GPL");