2 * QNX4 file system, Linux implementation.
6 * Using parts of the xiafs filesystem.
10 * 01-06-1998 by Richard Frowijn : first release.
11 * 20-06-1998 by Frank Denis : Linux 2.1.99+ support, boot signature, misc.
12 * 30-06-1998 by Frank Denis : first step to write inodes.
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/string.h>
18 #include <linux/errno.h>
19 #include <linux/slab.h>
21 #include <linux/qnx4_fs.h>
22 #include <linux/init.h>
23 #include <linux/highuid.h>
24 #include <linux/smp_lock.h>
25 #include <linux/pagemap.h>
26 #include <linux/buffer_head.h>
27 #include <linux/writeback.h>
28 #include <linux/vfs.h>
29 #include <asm/uaccess.h>
31 #define QNX4_VERSION 4
32 #define QNX4_BMNAME ".bitmap"
34 static const struct super_operations qnx4_sops
;
36 #ifdef CONFIG_QNX4FS_RW
38 static void qnx4_delete_inode(struct inode
*inode
)
40 QNX4DEBUG(("qnx4: deleting inode [%lu]\n", (unsigned long) inode
->i_ino
));
41 truncate_inode_pages(&inode
->i_data
, 0);
45 qnx4_free_inode(inode
);
49 static int qnx4_write_inode(struct inode
*inode
, int do_sync
)
51 struct qnx4_inode_entry
*raw_inode
;
53 struct buffer_head
*bh
;
56 QNX4DEBUG(("qnx4: write inode 1.\n"));
57 if (inode
->i_nlink
== 0) {
61 printk("qnx4: bad inode number on dev %s: %d is out of range\n",
62 inode
->i_sb
->s_id
, ino
);
65 QNX4DEBUG(("qnx4: write inode 2.\n"));
66 block
= ino
/ QNX4_INODES_PER_BLOCK
;
68 if (!(bh
= sb_bread(inode
->i_sb
, block
))) {
69 printk("qnx4: major problem: unable to read inode from dev "
70 "%s\n", inode
->i_sb
->s_id
);
74 raw_inode
= ((struct qnx4_inode_entry
*) bh
->b_data
) +
75 (ino
% QNX4_INODES_PER_BLOCK
);
76 raw_inode
->di_mode
= cpu_to_le16(inode
->i_mode
);
77 raw_inode
->di_uid
= cpu_to_le16(fs_high2lowuid(inode
->i_uid
));
78 raw_inode
->di_gid
= cpu_to_le16(fs_high2lowgid(inode
->i_gid
));
79 raw_inode
->di_nlink
= cpu_to_le16(inode
->i_nlink
);
80 raw_inode
->di_size
= cpu_to_le32(inode
->i_size
);
81 raw_inode
->di_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
82 raw_inode
->di_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
83 raw_inode
->di_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
84 raw_inode
->di_first_xtnt
.xtnt_size
= cpu_to_le32(inode
->i_blocks
);
85 mark_buffer_dirty(bh
);
87 sync_dirty_buffer(bh
);
88 if (buffer_req(bh
) && !buffer_uptodate(bh
)) {
89 printk("qnx4: IO error syncing inode [%s:%08x]\n",
90 inode
->i_sb
->s_id
, ino
);
103 static void qnx4_put_super(struct super_block
*sb
);
104 static struct inode
*qnx4_alloc_inode(struct super_block
*sb
);
105 static void qnx4_destroy_inode(struct inode
*inode
);
106 static int qnx4_remount(struct super_block
*sb
, int *flags
, char *data
);
107 static int qnx4_statfs(struct dentry
*, struct kstatfs
*);
109 static const struct super_operations qnx4_sops
=
111 .alloc_inode
= qnx4_alloc_inode
,
112 .destroy_inode
= qnx4_destroy_inode
,
113 .put_super
= qnx4_put_super
,
114 .statfs
= qnx4_statfs
,
115 .remount_fs
= qnx4_remount
,
116 #ifdef CONFIG_QNX4FS_RW
117 .write_inode
= qnx4_write_inode
,
118 .delete_inode
= qnx4_delete_inode
,
122 static int qnx4_remount(struct super_block
*sb
, int *flags
, char *data
)
124 struct qnx4_sb_info
*qs
;
127 qs
->Version
= QNX4_VERSION
;
128 #ifndef CONFIG_QNX4FS_RW
131 if (*flags
& MS_RDONLY
) {
135 mark_buffer_dirty(qs
->sb_buf
);
140 static struct buffer_head
*qnx4_getblk(struct inode
*inode
, int nr
,
143 struct buffer_head
*result
= NULL
;
146 nr
= qnx4_block_map( inode
, nr
);
148 result
= sb_getblk(inode
->i_sb
, nr
);
155 tmp
= qnx4_new_block(inode
->i_sb
);
159 result
= sb_getblk(inode
->i_sb
, tmp
);
161 qnx4_free_block(inode
->i_sb
, tmp
);
167 inode
->i_ctime
= CURRENT_TIME_SEC
;
168 mark_inode_dirty(inode
);
172 struct buffer_head
*qnx4_bread(struct inode
*inode
, int block
, int create
)
174 struct buffer_head
*bh
;
176 bh
= qnx4_getblk(inode
, block
, create
);
177 if (!bh
|| buffer_uptodate(bh
)) {
180 ll_rw_block(READ
, 1, &bh
);
182 if (buffer_uptodate(bh
)) {
190 static int qnx4_get_block( struct inode
*inode
, sector_t iblock
, struct buffer_head
*bh
, int create
)
194 QNX4DEBUG(("qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode
->i_ino
,iblock
));
196 phys
= qnx4_block_map( inode
, iblock
);
198 // logical block is before EOF
199 map_bh(bh
, inode
->i_sb
, phys
);
200 } else if ( create
) {
206 unsigned long qnx4_block_map( struct inode
*inode
, long iblock
)
210 unsigned long block
= 0;
211 struct buffer_head
*bh
= NULL
;
212 struct qnx4_xblk
*xblk
= NULL
;
213 struct qnx4_inode_entry
*qnx4_inode
= qnx4_raw_inode(inode
);
214 u16 nxtnt
= le16_to_cpu(qnx4_inode
->di_num_xtnts
);
216 if ( iblock
< le32_to_cpu(qnx4_inode
->di_first_xtnt
.xtnt_size
) ) {
217 // iblock is in the first extent. This is easy.
218 block
= le32_to_cpu(qnx4_inode
->di_first_xtnt
.xtnt_blk
) + iblock
- 1;
220 // iblock is beyond first extent. We have to follow the extent chain.
221 i_xblk
= le32_to_cpu(qnx4_inode
->di_xblk
);
222 offset
= iblock
- le32_to_cpu(qnx4_inode
->di_first_xtnt
.xtnt_size
);
224 while ( --nxtnt
> 0 ) {
226 // read next xtnt block.
227 bh
= sb_bread(inode
->i_sb
, i_xblk
- 1);
229 QNX4DEBUG(("qnx4: I/O error reading xtnt block [%ld])\n", i_xblk
- 1));
232 xblk
= (struct qnx4_xblk
*)bh
->b_data
;
233 if ( memcmp( xblk
->xblk_signature
, "IamXblk", 7 ) ) {
234 QNX4DEBUG(("qnx4: block at %ld is not a valid xtnt\n", qnx4_inode
->i_xblk
));
238 if ( offset
< le32_to_cpu(xblk
->xblk_xtnts
[ix
].xtnt_size
) ) {
240 block
= le32_to_cpu(xblk
->xblk_xtnts
[ix
].xtnt_blk
) + offset
- 1;
243 offset
-= le32_to_cpu(xblk
->xblk_xtnts
[ix
].xtnt_size
);
244 if ( ++ix
>= xblk
->xblk_num_xtnts
) {
245 i_xblk
= le32_to_cpu(xblk
->xblk_next_xblk
);
255 QNX4DEBUG(("qnx4: mapping block %ld of inode %ld = %ld\n",iblock
,inode
->i_ino
,block
));
259 static int qnx4_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
261 struct super_block
*sb
= dentry
->d_sb
;
262 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
266 buf
->f_type
= sb
->s_magic
;
267 buf
->f_bsize
= sb
->s_blocksize
;
268 buf
->f_blocks
= le32_to_cpu(qnx4_sb(sb
)->BitMap
->di_size
) * 8;
269 buf
->f_bfree
= qnx4_count_free_blocks(sb
);
270 buf
->f_bavail
= buf
->f_bfree
;
271 buf
->f_namelen
= QNX4_NAME_MAX
;
272 buf
->f_fsid
.val
[0] = (u32
)id
;
273 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
281 * Check the root directory of the filesystem to make sure
282 * it really _is_ a qnx4 filesystem, and to check the size
283 * of the directory entry.
285 static const char *qnx4_checkroot(struct super_block
*sb
)
287 struct buffer_head
*bh
;
288 struct qnx4_inode_entry
*rootdir
;
293 if (*(qnx4_sb(sb
)->sb
->RootDir
.di_fname
) != '/') {
294 return "no qnx4 filesystem (no root dir).";
296 QNX4DEBUG(("QNX4 filesystem found on dev %s.\n", sb
->s_id
));
297 rd
= le32_to_cpu(qnx4_sb(sb
)->sb
->RootDir
.di_first_xtnt
.xtnt_blk
) - 1;
298 rl
= le32_to_cpu(qnx4_sb(sb
)->sb
->RootDir
.di_first_xtnt
.xtnt_size
);
299 for (j
= 0; j
< rl
; j
++) {
300 bh
= sb_bread(sb
, rd
+ j
); /* root dir, first block */
302 return "unable to read root entry.";
304 for (i
= 0; i
< QNX4_INODES_PER_BLOCK
; i
++) {
305 rootdir
= (struct qnx4_inode_entry
*) (bh
->b_data
+ i
* QNX4_DIR_ENTRY_SIZE
);
306 if (rootdir
->di_fname
!= NULL
) {
307 QNX4DEBUG(("Rootdir entry found : [%s]\n", rootdir
->di_fname
));
308 if (!strncmp(rootdir
->di_fname
, QNX4_BMNAME
, sizeof QNX4_BMNAME
)) {
310 qnx4_sb(sb
)->BitMap
= kmalloc( sizeof( struct qnx4_inode_entry
), GFP_KERNEL
);
311 if (!qnx4_sb(sb
)->BitMap
) {
313 return "not enough memory for bitmap inode";
315 memcpy( qnx4_sb(sb
)->BitMap
, rootdir
, sizeof( struct qnx4_inode_entry
) ); /* keep bitmap inode known */
326 return "bitmap file not found.";
332 static int qnx4_fill_super(struct super_block
*s
, void *data
, int silent
)
334 struct buffer_head
*bh
;
337 struct qnx4_sb_info
*qs
;
340 qs
= kzalloc(sizeof(struct qnx4_sb_info
), GFP_KERNEL
);
345 sb_set_blocksize(s
, QNX4_BLOCK_SIZE
);
347 /* Check the superblock signature. Since the qnx4 code is
348 dangerous, we should leave as quickly as possible
349 if we don't belong here... */
352 printk("qnx4: unable to read the superblock\n");
355 if ( le32_to_cpup((__le32
*) bh
->b_data
) != QNX4_SUPER_MAGIC
) {
357 printk("qnx4: wrong fsid in superblock.\n");
360 s
->s_op
= &qnx4_sops
;
361 s
->s_magic
= QNX4_SUPER_MAGIC
;
362 #ifndef CONFIG_QNX4FS_RW
363 s
->s_flags
|= MS_RDONLY
; /* Yup, read-only yet */
365 qnx4_sb(s
)->sb_buf
= bh
;
366 qnx4_sb(s
)->sb
= (struct qnx4_super_block
*) bh
->b_data
;
369 /* check before allocating dentries, inodes, .. */
370 errmsg
= qnx4_checkroot(s
);
371 if (errmsg
!= NULL
) {
373 printk("qnx4: %s\n", errmsg
);
377 /* does root not have inode number QNX4_ROOT_INO ?? */
378 root
= qnx4_iget(s
, QNX4_ROOT_INO
* QNX4_INODES_PER_BLOCK
);
380 printk("qnx4: get inode failed\n");
386 s
->s_root
= d_alloc_root(root
);
387 if (s
->s_root
== NULL
)
404 static void qnx4_put_super(struct super_block
*sb
)
406 struct qnx4_sb_info
*qs
= qnx4_sb(sb
);
409 sb
->s_fs_info
= NULL
;
413 static int qnx4_writepage(struct page
*page
, struct writeback_control
*wbc
)
415 return block_write_full_page(page
,qnx4_get_block
, wbc
);
418 static int qnx4_readpage(struct file
*file
, struct page
*page
)
420 return block_read_full_page(page
,qnx4_get_block
);
423 static int qnx4_write_begin(struct file
*file
, struct address_space
*mapping
,
424 loff_t pos
, unsigned len
, unsigned flags
,
425 struct page
**pagep
, void **fsdata
)
427 struct qnx4_inode_info
*qnx4_inode
= qnx4_i(mapping
->host
);
429 return cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
431 &qnx4_inode
->mmu_private
);
433 static sector_t
qnx4_bmap(struct address_space
*mapping
, sector_t block
)
435 return generic_block_bmap(mapping
,block
,qnx4_get_block
);
437 static const struct address_space_operations qnx4_aops
= {
438 .readpage
= qnx4_readpage
,
439 .writepage
= qnx4_writepage
,
440 .sync_page
= block_sync_page
,
441 .write_begin
= qnx4_write_begin
,
442 .write_end
= generic_write_end
,
446 struct inode
*qnx4_iget(struct super_block
*sb
, unsigned long ino
)
448 struct buffer_head
*bh
;
449 struct qnx4_inode_entry
*raw_inode
;
451 struct qnx4_inode_entry
*qnx4_inode
;
454 inode
= iget_locked(sb
, ino
);
456 return ERR_PTR(-ENOMEM
);
457 if (!(inode
->i_state
& I_NEW
))
460 qnx4_inode
= qnx4_raw_inode(inode
);
463 QNX4DEBUG(("Reading inode : [%d]\n", ino
));
465 printk(KERN_ERR
"qnx4: bad inode number on dev %s: %lu is "
469 return ERR_PTR(-EIO
);
471 block
= ino
/ QNX4_INODES_PER_BLOCK
;
473 if (!(bh
= sb_bread(sb
, block
))) {
474 printk("qnx4: major problem: unable to read inode from dev "
477 return ERR_PTR(-EIO
);
479 raw_inode
= ((struct qnx4_inode_entry
*) bh
->b_data
) +
480 (ino
% QNX4_INODES_PER_BLOCK
);
482 inode
->i_mode
= le16_to_cpu(raw_inode
->di_mode
);
483 inode
->i_uid
= (uid_t
)le16_to_cpu(raw_inode
->di_uid
);
484 inode
->i_gid
= (gid_t
)le16_to_cpu(raw_inode
->di_gid
);
485 inode
->i_nlink
= le16_to_cpu(raw_inode
->di_nlink
);
486 inode
->i_size
= le32_to_cpu(raw_inode
->di_size
);
487 inode
->i_mtime
.tv_sec
= le32_to_cpu(raw_inode
->di_mtime
);
488 inode
->i_mtime
.tv_nsec
= 0;
489 inode
->i_atime
.tv_sec
= le32_to_cpu(raw_inode
->di_atime
);
490 inode
->i_atime
.tv_nsec
= 0;
491 inode
->i_ctime
.tv_sec
= le32_to_cpu(raw_inode
->di_ctime
);
492 inode
->i_ctime
.tv_nsec
= 0;
493 inode
->i_blocks
= le32_to_cpu(raw_inode
->di_first_xtnt
.xtnt_size
);
495 memcpy(qnx4_inode
, raw_inode
, QNX4_DIR_ENTRY_SIZE
);
496 if (S_ISREG(inode
->i_mode
)) {
497 inode
->i_op
= &qnx4_file_inode_operations
;
498 inode
->i_fop
= &qnx4_file_operations
;
499 inode
->i_mapping
->a_ops
= &qnx4_aops
;
500 qnx4_i(inode
)->mmu_private
= inode
->i_size
;
501 } else if (S_ISDIR(inode
->i_mode
)) {
502 inode
->i_op
= &qnx4_dir_inode_operations
;
503 inode
->i_fop
= &qnx4_dir_operations
;
504 } else if (S_ISLNK(inode
->i_mode
)) {
505 inode
->i_op
= &page_symlink_inode_operations
;
506 inode
->i_mapping
->a_ops
= &qnx4_aops
;
507 qnx4_i(inode
)->mmu_private
= inode
->i_size
;
509 printk(KERN_ERR
"qnx4: bad inode %lu on dev %s\n",
513 return ERR_PTR(-EIO
);
516 unlock_new_inode(inode
);
520 static struct kmem_cache
*qnx4_inode_cachep
;
522 static struct inode
*qnx4_alloc_inode(struct super_block
*sb
)
524 struct qnx4_inode_info
*ei
;
525 ei
= kmem_cache_alloc(qnx4_inode_cachep
, GFP_KERNEL
);
528 return &ei
->vfs_inode
;
531 static void qnx4_destroy_inode(struct inode
*inode
)
533 kmem_cache_free(qnx4_inode_cachep
, qnx4_i(inode
));
536 static void init_once(void *foo
)
538 struct qnx4_inode_info
*ei
= (struct qnx4_inode_info
*) foo
;
540 inode_init_once(&ei
->vfs_inode
);
543 static int init_inodecache(void)
545 qnx4_inode_cachep
= kmem_cache_create("qnx4_inode_cache",
546 sizeof(struct qnx4_inode_info
),
547 0, (SLAB_RECLAIM_ACCOUNT
|
550 if (qnx4_inode_cachep
== NULL
)
555 static void destroy_inodecache(void)
557 kmem_cache_destroy(qnx4_inode_cachep
);
560 static int qnx4_get_sb(struct file_system_type
*fs_type
,
561 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
563 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, qnx4_fill_super
,
567 static struct file_system_type qnx4_fs_type
= {
568 .owner
= THIS_MODULE
,
570 .get_sb
= qnx4_get_sb
,
571 .kill_sb
= kill_block_super
,
572 .fs_flags
= FS_REQUIRES_DEV
,
575 static int __init
init_qnx4_fs(void)
579 err
= init_inodecache();
583 err
= register_filesystem(&qnx4_fs_type
);
585 destroy_inodecache();
589 printk("QNX4 filesystem 0.2.3 registered.\n");
593 static void __exit
exit_qnx4_fs(void)
595 unregister_filesystem(&qnx4_fs_type
);
596 destroy_inodecache();
599 module_init(init_qnx4_fs
)
600 module_exit(exit_qnx4_fs
)
601 MODULE_LICENSE("GPL");