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