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