~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/qnx6/inode.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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         *flags |= MS_RDONLY;
 59         return 0;
 60 }
 61 
 62 static 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 
 68 static unsigned qnx6_block_map(struct inode *inode, unsigned iblock);
 69 
 70 static 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 
 86 static 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 
 95 static int qnx6_readpage(struct file *file, struct page *page)
 96 {
 97         return mpage_readpage(page, qnx6_get_block);
 98 }
 99 
100 static 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  */
110 static 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 
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 = 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
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         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 
232 enum {
233         Opt_mmifs,
234         Opt_err
235 };
236 
237 static const match_table_t tokens = {
238         {Opt_mmifs, "mmi_fs"},
239         {Opt_err, NULL}
240 };
241 
242 static 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 
268 static 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                                         " endianness.\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 
309 static struct inode *qnx6_private_inode(struct super_block *s,
310                                         struct qnx6_root_node *p);
311 
312 static 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         }
432 mmi_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 
481 out3:
482         dput(s->s_root);
483         s->s_root = NULL;
484 out2:
485         iput(sbi->longfile);
486 out1:
487         iput(sbi->inodes);
488 out:
489         if (bh1)
490                 brelse(bh1);
491         if (bh2)
492                 brelse(bh2);
493 outnobh:
494         kfree(qs);
495         s->s_fs_info = NULL;
496         return ret;
497 }
498 
499 static 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 
510 static sector_t qnx6_bmap(struct address_space *mapping, sector_t block)
511 {
512         return generic_block_bmap(mapping, block, qnx6_get_block);
513 }
514 static const struct address_space_operations qnx6_aops = {
515         .readpage       = qnx6_readpage,
516         .readpages      = qnx6_readpages,
517         .bmap           = qnx6_bmap
518 };
519 
520 static 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 
536 struct 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         i_uid_write(inode, (uid_t)fs32_to_cpu(sbi, raw_inode->di_uid));
578         i_gid_write(inode, (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 
611 static struct kmem_cache *qnx6_inode_cachep;
612 
613 static 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 
622 static 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 
628 static void qnx6_destroy_inode(struct inode *inode)
629 {
630         call_rcu(&inode->i_rcu, qnx6_i_callback);
631 }
632 
633 static 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 
640 static 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 
652 static void destroy_inodecache(void)
653 {
654         /*
655          * Make sure all delayed rcu free inodes are flushed before we
656          * destroy cache.
657          */
658         rcu_barrier();
659         kmem_cache_destroy(qnx6_inode_cachep);
660 }
661 
662 static struct dentry *qnx6_mount(struct file_system_type *fs_type,
663         int flags, const char *dev_name, void *data)
664 {
665         return mount_bdev(fs_type, flags, dev_name, data, qnx6_fill_super);
666 }
667 
668 static struct file_system_type qnx6_fs_type = {
669         .owner          = THIS_MODULE,
670         .name           = "qnx6",
671         .mount          = qnx6_mount,
672         .kill_sb        = kill_block_super,
673         .fs_flags       = FS_REQUIRES_DEV,
674 };
675 MODULE_ALIAS_FS("qnx6");
676 
677 static int __init init_qnx6_fs(void)
678 {
679         int err;
680 
681         err = init_inodecache();
682         if (err)
683                 return err;
684 
685         err = register_filesystem(&qnx6_fs_type);
686         if (err) {
687                 destroy_inodecache();
688                 return err;
689         }
690 
691         printk(KERN_INFO "QNX6 filesystem 1.0.0 registered.\n");
692         return 0;
693 }
694 
695 static void __exit exit_qnx6_fs(void)
696 {
697         unregister_filesystem(&qnx6_fs_type);
698         destroy_inodecache();
699 }
700 
701 module_init(init_qnx6_fs)
702 module_exit(exit_qnx6_fs)
703 MODULE_LICENSE("GPL");
704 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp