2 * QNX6 file system, Linux implementation.
8 * 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release.
9 * 16-02-2012 pagemap extension by Al Viro
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>
28 static const struct super_operations qnx6_sops
;
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
);
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
,
46 static int qnx6_show_options(struct seq_file
*seq
, struct dentry
*root
)
48 struct super_block
*sb
= root
->d_sb
;
49 struct qnx6_sb_info
*sbi
= QNX6_SB(sb
);
51 if (sbi
->s_mount_opt
& QNX6_MOUNT_MMI_FS
)
52 seq_puts(seq
, ",mmi_fs");
56 static int qnx6_remount(struct super_block
*sb
, int *flags
, char *data
)
63 static unsigned qnx6_get_devblock(struct super_block
*sb
, __fs32 block
)
65 struct qnx6_sb_info
*sbi
= QNX6_SB(sb
);
66 return fs32_to_cpu(sbi
, block
) + sbi
->s_blks_off
;
69 static unsigned qnx6_block_map(struct inode
*inode
, unsigned iblock
);
71 static int qnx6_get_block(struct inode
*inode
, sector_t iblock
,
72 struct buffer_head
*bh
, int create
)
76 QNX6DEBUG((KERN_INFO
"qnx6: qnx6_get_block inode=[%ld] iblock=[%ld]\n",
77 inode
->i_ino
, (unsigned long)iblock
));
79 phys
= qnx6_block_map(inode
, iblock
);
81 /* logical block is before EOF */
82 map_bh(bh
, inode
->i_sb
, phys
);
87 static int qnx6_check_blockptr(__fs32 ptr
)
89 if (ptr
== ~(__fs32
)0) {
90 printk(KERN_ERR
"qnx6: hit unused blockpointer.\n");
96 static int qnx6_readpage(struct file
*file
, struct page
*page
)
98 return mpage_readpage(page
, qnx6_get_block
);
101 static int qnx6_readpages(struct file
*file
, struct address_space
*mapping
,
102 struct list_head
*pages
, unsigned nr_pages
)
104 return mpage_readpages(mapping
, pages
, nr_pages
, qnx6_get_block
);
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
111 static unsigned qnx6_block_map(struct inode
*inode
, unsigned no
)
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
);
117 struct buffer_head
*bh
;
120 int ptrbits
= sbi
->s_ptrbits
;
122 u32 mask
= (1 << ptrbits
) - 1;
123 int depth
= ei
->di_filelevels
;
126 bitdelta
= ptrbits
* depth
;
127 levelptr
= no
>> bitdelta
;
129 if (levelptr
> QNX6_NO_DIRECT_POINTERS
- 1) {
130 printk(KERN_ERR
"qnx6:Requested file block number (%u) too big.",
135 block
= qnx6_get_devblock(s
, ei
->di_block_ptr
[levelptr
]);
137 for (i
= 0; i
< depth
; i
++) {
138 bh
= sb_bread(s
, block
);
140 printk(KERN_ERR
"qnx6:Error reading block (%u)\n",
145 levelptr
= (no
>> bitdelta
) & mask
;
146 ptr
= ((__fs32
*)bh
->b_data
)[levelptr
];
148 if (!qnx6_check_blockptr(ptr
))
151 block
= qnx6_get_devblock(s
, ptr
);
157 static int qnx6_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
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
);
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);
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.
182 static const char *qnx6_checkroot(struct super_block
*s
)
184 static char match_root
[2][3] = {".\0\0", "..\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
);
191 return "error reading root directory";
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))
201 return "error reading root directory.";
205 #ifdef CONFIG_QNX6FS_DEBUG
206 void qnx6_superblock_debug(struct qnx6_super_block
*sb
, struct super_block
*s
)
208 struct qnx6_sb_info
*sbi
= QNX6_SB(s
);
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",
238 static const match_table_t tokens
= {
239 {Opt_mmifs
, "mmi_fs"},
243 static int qnx6_parse_options(char *options
, struct super_block
*sb
)
246 struct qnx6_sb_info
*sbi
= QNX6_SB(sb
);
247 substring_t args
[MAX_OPT_ARGS
];
252 while ((p
= strsep(&options
, ",")) != NULL
) {
257 token
= match_token(p
, tokens
, args
);
260 set_opt(sbi
->s_mount_opt
, MMI_FS
);
269 static struct buffer_head
*qnx6_check_first_superblock(struct super_block
*s
,
270 int offset
, int silent
)
272 struct qnx6_sb_info
*sbi
= QNX6_SB(s
);
273 struct buffer_head
*bh
;
274 struct qnx6_super_block
*sb
;
276 /* Check the superblock signatures
277 start with the first superblock */
278 bh
= sb_bread(s
, offset
);
280 printk(KERN_ERR
"qnx6: unable to read the first superblock\n");
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"
292 sbi
->s_bytesex
= BYTESEX_LE
;
295 printk(KERN_ERR
"qnx6: wrong signature (magic)"
296 " in superblock #1.\n");
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
);
310 static struct inode
*qnx6_private_inode(struct super_block
*s
,
311 struct qnx6_root_node
*p
);
313 static int qnx6_fill_super(struct super_block
*s
, void *data
, int silent
)
315 struct buffer_head
*bh1
= NULL
, *bh2
= NULL
;
316 struct qnx6_super_block
*sb1
= NULL
, *sb2
= NULL
;
317 struct qnx6_sb_info
*sbi
;
320 struct qnx6_sb_info
*qs
;
323 int bootblock_offset
= QNX6_BOOTBLOCK_SIZE
;
325 qs
= kzalloc(sizeof(struct qnx6_sb_info
), GFP_KERNEL
);
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");
336 /* parse the mount-options */
337 if (!qnx6_parse_options((char *) data
, s
)) {
338 printk(KERN_ERR
"qnx6: invalid mount options.\n");
341 if (test_opt(s
, MMI_FS
)) {
342 sb1
= qnx6_mmi_fill_super(s
, silent
);
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
);
355 /* try again without bootblock offset */
356 bh1
= qnx6_check_first_superblock(s
, 0, silent
);
358 printk(KERN_ERR
"qnx6: unable to read the first superblock\n");
361 /* seems that no bootblock at partition start */
362 bootblock_offset
= 0;
364 sb1
= (struct qnx6_super_block
*)bh1
->b_data
;
366 #ifdef CONFIG_QNX6FS_DEBUG
367 qnx6_superblock_debug(sb1
, s
);
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");
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");
382 /* blocksize invalidates bh - pull it back in */
384 bh1
= sb_bread(s
, bootblock_offset
>> s
->s_blocksize_bits
);
387 sb1
= (struct qnx6_super_block
*)bh1
->b_data
;
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
);
394 /* set bootblock offset */
395 sbi
->s_blks_off
= (bootblock_offset
>> s
->s_blocksize_bits
) +
396 (QNX6_SUPERBLOCK_AREA
>> s
->s_blocksize_bits
);
398 /* next the second superblock */
399 bh2
= sb_bread(s
, offset
);
401 printk(KERN_ERR
"qnx6: unable to read the second superblock\n");
404 sb2
= (struct qnx6_super_block
*)bh2
->b_data
;
405 if (fs32_to_cpu(sbi
, sb2
->sb_magic
) != QNX6_SUPER_MAGIC
) {
407 printk(KERN_ERR
"qnx6: wrong signature (magic)"
408 " in superblock #2.\n");
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");
419 if (fs64_to_cpu(sbi
, sb1
->sb_serial
) >=
420 fs64_to_cpu(sbi
, sb2
->sb_serial
)) {
421 /* superblock #1 active */
423 sbi
->sb
= (struct qnx6_super_block
*)bh1
->b_data
;
425 printk(KERN_INFO
"qnx6: superblock #1 active\n");
427 /* superblock #2 active */
429 sbi
->sb
= (struct qnx6_super_block
*)bh2
->b_data
;
431 printk(KERN_INFO
"qnx6: superblock #2 active\n");
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
);
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
);
446 s
->s_op
= &qnx6_sops
;
447 s
->s_magic
= QNX6_SUPER_MAGIC
;
448 s
->s_flags
|= MS_RDONLY
; /* Yup, read-only yet */
450 /* ease the later tree level calculations */
452 sbi
->s_ptrbits
= ilog2(s
->s_blocksize
/ 4);
453 sbi
->inodes
= qnx6_private_inode(s
, &sb1
->Inode
);
456 sbi
->longfile
= qnx6_private_inode(s
, &sb1
->Longfile
);
460 /* prefetch root inode */
461 root
= qnx6_iget(s
, QNX6_ROOT_INO
);
463 printk(KERN_ERR
"qnx6: get inode failed\n");
469 s
->s_root
= d_make_root(root
);
474 errmsg
= qnx6_checkroot(s
);
475 if (errmsg
!= NULL
) {
477 printk(KERN_ERR
"qnx6: %s\n", errmsg
);
500 static void qnx6_put_super(struct super_block
*sb
)
502 struct qnx6_sb_info
*qs
= QNX6_SB(sb
);
507 sb
->s_fs_info
= NULL
;
511 static sector_t
qnx6_bmap(struct address_space
*mapping
, sector_t block
)
513 return generic_block_bmap(mapping
, block
, qnx6_get_block
);
515 static const struct address_space_operations qnx6_aops
= {
516 .readpage
= qnx6_readpage
,
517 .readpages
= qnx6_readpages
,
521 static struct inode
*qnx6_private_inode(struct super_block
*s
,
522 struct qnx6_root_node
*p
)
524 struct inode
*inode
= new_inode(s
);
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
;
537 struct inode
*qnx6_iget(struct super_block
*sb
, unsigned ino
)
539 struct qnx6_sb_info
*sbi
= QNX6_SB(sb
);
540 struct qnx6_inode_entry
*raw_inode
;
542 struct qnx6_inode_info
*ei
;
543 struct address_space
*mapping
;
547 inode
= iget_locked(sb
, ino
);
549 return ERR_PTR(-ENOMEM
);
550 if (!(inode
->i_state
& I_NEW
))
558 printk(KERN_ERR
"qnx6: bad inode number on dev %s: %u is "
562 return ERR_PTR(-EIO
);
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
);
569 printk(KERN_ERR
"qnx6: major problem: unable to read inode from "
570 "dev %s\n", sb
->s_id
);
572 return ERR_CAST(page
);
575 raw_inode
= ((struct qnx6_inode_entry
*)page_address(page
)) + offs
;
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;
588 /* calc blocks based on 512 byte blocksize */
589 inode
->i_blocks
= (inode
->i_size
+ 511) >> 9;
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
;
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
;
606 init_special_inode(inode
, inode
->i_mode
, 0);
608 unlock_new_inode(inode
);
612 static struct kmem_cache
*qnx6_inode_cachep
;
614 static struct inode
*qnx6_alloc_inode(struct super_block
*sb
)
616 struct qnx6_inode_info
*ei
;
617 ei
= kmem_cache_alloc(qnx6_inode_cachep
, GFP_KERNEL
);
620 return &ei
->vfs_inode
;
623 static void qnx6_i_callback(struct rcu_head
*head
)
625 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
626 kmem_cache_free(qnx6_inode_cachep
, QNX6_I(inode
));
629 static void qnx6_destroy_inode(struct inode
*inode
)
631 call_rcu(&inode
->i_rcu
, qnx6_i_callback
);
634 static void init_once(void *foo
)
636 struct qnx6_inode_info
*ei
= (struct qnx6_inode_info
*) foo
;
638 inode_init_once(&ei
->vfs_inode
);
641 static int init_inodecache(void)
643 qnx6_inode_cachep
= kmem_cache_create("qnx6_inode_cache",
644 sizeof(struct qnx6_inode_info
),
645 0, (SLAB_RECLAIM_ACCOUNT
|
648 if (!qnx6_inode_cachep
)
653 static void destroy_inodecache(void)
656 * Make sure all delayed rcu free inodes are flushed before we
660 kmem_cache_destroy(qnx6_inode_cachep
);
663 static struct dentry
*qnx6_mount(struct file_system_type
*fs_type
,
664 int flags
, const char *dev_name
, void *data
)
666 return mount_bdev(fs_type
, flags
, dev_name
, data
, qnx6_fill_super
);
669 static struct file_system_type qnx6_fs_type
= {
670 .owner
= THIS_MODULE
,
673 .kill_sb
= kill_block_super
,
674 .fs_flags
= FS_REQUIRES_DEV
,
676 MODULE_ALIAS_FS("qnx6");
678 static int __init
init_qnx6_fs(void)
682 err
= init_inodecache();
686 err
= register_filesystem(&qnx6_fs_type
);
688 destroy_inodecache();
692 printk(KERN_INFO
"QNX6 filesystem 1.0.0 registered.\n");
696 static void __exit
exit_qnx6_fs(void)
698 unregister_filesystem(&qnx6_fs_type
);
699 destroy_inodecache();
702 module_init(init_qnx6_fs
)
703 module_exit(exit_qnx6_fs
)
704 MODULE_LICENSE("GPL");