Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us