fs/qnx6/inode.c

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