linux/fs/qnx6/inode.c
<<
>>
Prefs
   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
  28static const struct super_operations qnx6_sops;
  29
  30static void qnx6_put_super(struct super_block *sb);
  31static struct inode *qnx6_alloc_inode(struct super_block *sb);
  32static void qnx6_destroy_inode(struct inode *inode);
  33static int qnx6_remount(struct super_block *sb, int *flags, char *data);
  34static int qnx6_statfs(struct dentry *dentry, struct kstatfs *buf);
  35static int qnx6_show_options(struct seq_file *seq, struct dentry *root);
  36
  37static 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
  46static 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
  56static int qnx6_remount(struct super_block *sb, int *flags, char *data)
  57{
  58        *flags |= MS_RDONLY;
  59        return 0;
  60}
  61
  62static 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
  68static unsigned qnx6_block_map(struct inode *inode, unsigned iblock);
  69
  70static 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
  86static 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
  95static int qnx6_readpage(struct file *file, struct page *page)
  96{
  97        return mpage_readpage(page, qnx6_get_block);
  98}
  99
 100static 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 */
 110static 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
 156static 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 */
 181static 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
 205void 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
 232enum {
 233        Opt_mmifs,
 234        Opt_err
 235};
 236
 237static const match_table_t tokens = {
 238        {Opt_mmifs, "mmi_fs"},
 239        {Opt_err, NULL}
 240};
 241
 242static 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
 268static 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                                        " endianess.\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
 309static struct inode *qnx6_private_inode(struct super_block *s,
 310                                        struct qnx6_root_node *p);
 311
 312static 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        }
 432mmi_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
 481out3:
 482        dput(s->s_root);
 483        s->s_root = NULL;
 484out2:
 485        iput(sbi->longfile);
 486out1:
 487        iput(sbi->inodes);
 488out:
 489        if (bh1)
 490                brelse(bh1);
 491        if (bh2)
 492                brelse(bh2);
 493outnobh:
 494        kfree(qs);
 495        s->s_fs_info = NULL;
 496        return ret;
 497}
 498
 499static 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
 510static sector_t qnx6_bmap(struct address_space *mapping, sector_t block)
 511{
 512        return generic_block_bmap(mapping, block, qnx6_get_block);
 513}
 514static const struct address_space_operations qnx6_aops = {
 515        .readpage       = qnx6_readpage,
 516        .readpages      = qnx6_readpages,
 517        .bmap           = qnx6_bmap
 518};
 519
 520static 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
 536struct 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        inode->i_uid     = (uid_t)fs32_to_cpu(sbi, raw_inode->di_uid);
 578        inode->i_gid     = (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
 611static struct kmem_cache *qnx6_inode_cachep;
 612
 613static 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
 622static 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
 628static void qnx6_destroy_inode(struct inode *inode)
 629{
 630        call_rcu(&inode->i_rcu, qnx6_i_callback);
 631}
 632
 633static 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
 640static 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
 652static void destroy_inodecache(void)
 653{
 654        kmem_cache_destroy(qnx6_inode_cachep);
 655}
 656
 657static struct dentry *qnx6_mount(struct file_system_type *fs_type,
 658        int flags, const char *dev_name, void *data)
 659{
 660        return mount_bdev(fs_type, flags, dev_name, data, qnx6_fill_super);
 661}
 662
 663static struct file_system_type qnx6_fs_type = {
 664        .owner          = THIS_MODULE,
 665        .name           = "qnx6",
 666        .mount          = qnx6_mount,
 667        .kill_sb        = kill_block_super,
 668        .fs_flags       = FS_REQUIRES_DEV,
 669};
 670
 671static int __init init_qnx6_fs(void)
 672{
 673        int err;
 674
 675        err = init_inodecache();
 676        if (err)
 677                return err;
 678
 679        err = register_filesystem(&qnx6_fs_type);
 680        if (err) {
 681                destroy_inodecache();
 682                return err;
 683        }
 684
 685        printk(KERN_INFO "QNX6 filesystem 1.0.0 registered.\n");
 686        return 0;
 687}
 688
 689static void __exit exit_qnx6_fs(void)
 690{
 691        unregister_filesystem(&qnx6_fs_type);
 692        destroy_inodecache();
 693}
 694
 695module_init(init_qnx6_fs)
 696module_exit(exit_qnx6_fs)
 697MODULE_LICENSE("GPL");
 698
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.