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