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/init.h>
17 #include <linux/slab.h>
18 #include <linux/highuid.h>
19 #include <linux/smp_lock.h>
20 #include <linux/pagemap.h>
21 #include <linux/buffer_head.h>
22 #include <linux/writeback.h>
23 #include <linux/statfs.h>
26 #define QNX4_VERSION 4
27 #define QNX4_BMNAME ".bitmap"
29 static const struct super_operations qnx4_sops
;
31 static void qnx4_put_super(struct super_block
*sb
);
32 static struct inode
*qnx4_alloc_inode(struct super_block
*sb
);
33 static void qnx4_destroy_inode(struct inode
*inode
);
34 static int qnx4_remount(struct super_block
*sb
, int *flags
, char *data
);
35 static int qnx4_statfs(struct dentry
*, struct kstatfs
*);
37 static const struct super_operations qnx4_sops
=
39 .alloc_inode
= qnx4_alloc_inode
,
40 .destroy_inode
= qnx4_destroy_inode
,
41 .put_super
= qnx4_put_super
,
42 .statfs
= qnx4_statfs
,
43 .remount_fs
= qnx4_remount
,
46 static int qnx4_remount(struct super_block
*sb
, int *flags
, char *data
)
48 struct qnx4_sb_info
*qs
;
51 qs
->Version
= QNX4_VERSION
;
56 static struct buffer_head
*qnx4_getblk(struct inode
*inode
, int nr
,
59 struct buffer_head
*result
= NULL
;
62 nr
= qnx4_block_map( inode
, nr
);
64 result
= sb_getblk(inode
->i_sb
, nr
);
70 struct buffer_head
*qnx4_bread(struct inode
*inode
, int block
, int create
)
72 struct buffer_head
*bh
;
74 bh
= qnx4_getblk(inode
, block
, create
);
75 if (!bh
|| buffer_uptodate(bh
)) {
78 ll_rw_block(READ
, 1, &bh
);
80 if (buffer_uptodate(bh
)) {
88 static int qnx4_get_block( struct inode
*inode
, sector_t iblock
, struct buffer_head
*bh
, int create
)
92 QNX4DEBUG((KERN_INFO
"qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode
->i_ino
,iblock
));
94 phys
= qnx4_block_map( inode
, iblock
);
96 // logical block is before EOF
97 map_bh(bh
, inode
->i_sb
, phys
);
102 unsigned long qnx4_block_map( struct inode
*inode
, long iblock
)
106 unsigned long block
= 0;
107 struct buffer_head
*bh
= NULL
;
108 struct qnx4_xblk
*xblk
= NULL
;
109 struct qnx4_inode_entry
*qnx4_inode
= qnx4_raw_inode(inode
);
110 u16 nxtnt
= le16_to_cpu(qnx4_inode
->di_num_xtnts
);
112 if ( iblock
< le32_to_cpu(qnx4_inode
->di_first_xtnt
.xtnt_size
) ) {
113 // iblock is in the first extent. This is easy.
114 block
= le32_to_cpu(qnx4_inode
->di_first_xtnt
.xtnt_blk
) + iblock
- 1;
116 // iblock is beyond first extent. We have to follow the extent chain.
117 i_xblk
= le32_to_cpu(qnx4_inode
->di_xblk
);
118 offset
= iblock
- le32_to_cpu(qnx4_inode
->di_first_xtnt
.xtnt_size
);
120 while ( --nxtnt
> 0 ) {
122 // read next xtnt block.
123 bh
= sb_bread(inode
->i_sb
, i_xblk
- 1);
125 QNX4DEBUG((KERN_ERR
"qnx4: I/O error reading xtnt block [%ld])\n", i_xblk
- 1));
128 xblk
= (struct qnx4_xblk
*)bh
->b_data
;
129 if ( memcmp( xblk
->xblk_signature
, "IamXblk", 7 ) ) {
130 QNX4DEBUG((KERN_ERR
"qnx4: block at %ld is not a valid xtnt\n", qnx4_inode
->i_xblk
));
134 if ( offset
< le32_to_cpu(xblk
->xblk_xtnts
[ix
].xtnt_size
) ) {
136 block
= le32_to_cpu(xblk
->xblk_xtnts
[ix
].xtnt_blk
) + offset
- 1;
139 offset
-= le32_to_cpu(xblk
->xblk_xtnts
[ix
].xtnt_size
);
140 if ( ++ix
>= xblk
->xblk_num_xtnts
) {
141 i_xblk
= le32_to_cpu(xblk
->xblk_next_xblk
);
151 QNX4DEBUG((KERN_INFO
"qnx4: mapping block %ld of inode %ld = %ld\n",iblock
,inode
->i_ino
,block
));
155 static int qnx4_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
157 struct super_block
*sb
= dentry
->d_sb
;
158 u64 id
= huge_encode_dev(sb
->s_bdev
->bd_dev
);
162 buf
->f_type
= sb
->s_magic
;
163 buf
->f_bsize
= sb
->s_blocksize
;
164 buf
->f_blocks
= le32_to_cpu(qnx4_sb(sb
)->BitMap
->di_size
) * 8;
165 buf
->f_bfree
= qnx4_count_free_blocks(sb
);
166 buf
->f_bavail
= buf
->f_bfree
;
167 buf
->f_namelen
= QNX4_NAME_MAX
;
168 buf
->f_fsid
.val
[0] = (u32
)id
;
169 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
177 * Check the root directory of the filesystem to make sure
178 * it really _is_ a qnx4 filesystem, and to check the size
179 * of the directory entry.
181 static const char *qnx4_checkroot(struct super_block
*sb
)
183 struct buffer_head
*bh
;
184 struct qnx4_inode_entry
*rootdir
;
189 if (*(qnx4_sb(sb
)->sb
->RootDir
.di_fname
) != '/') {
190 return "no qnx4 filesystem (no root dir).";
192 QNX4DEBUG((KERN_NOTICE
"QNX4 filesystem found on dev %s.\n", sb
->s_id
));
193 rd
= le32_to_cpu(qnx4_sb(sb
)->sb
->RootDir
.di_first_xtnt
.xtnt_blk
) - 1;
194 rl
= le32_to_cpu(qnx4_sb(sb
)->sb
->RootDir
.di_first_xtnt
.xtnt_size
);
195 for (j
= 0; j
< rl
; j
++) {
196 bh
= sb_bread(sb
, rd
+ j
); /* root dir, first block */
198 return "unable to read root entry.";
200 for (i
= 0; i
< QNX4_INODES_PER_BLOCK
; i
++) {
201 rootdir
= (struct qnx4_inode_entry
*) (bh
->b_data
+ i
* QNX4_DIR_ENTRY_SIZE
);
202 if (rootdir
->di_fname
!= NULL
) {
203 QNX4DEBUG((KERN_INFO
"rootdir entry found : [%s]\n", rootdir
->di_fname
));
204 if (!strcmp(rootdir
->di_fname
,
207 qnx4_sb(sb
)->BitMap
= kmalloc( sizeof( struct qnx4_inode_entry
), GFP_KERNEL
);
208 if (!qnx4_sb(sb
)->BitMap
) {
210 return "not enough memory for bitmap inode";
212 memcpy( qnx4_sb(sb
)->BitMap
, rootdir
, sizeof( struct qnx4_inode_entry
) ); /* keep bitmap inode known */
223 return "bitmap file not found.";
229 static int qnx4_fill_super(struct super_block
*s
, void *data
, int silent
)
231 struct buffer_head
*bh
;
234 struct qnx4_sb_info
*qs
;
239 qs
= kzalloc(sizeof(struct qnx4_sb_info
), GFP_KERNEL
);
246 sb_set_blocksize(s
, QNX4_BLOCK_SIZE
);
248 /* Check the superblock signature. Since the qnx4 code is
249 dangerous, we should leave as quickly as possible
250 if we don't belong here... */
253 printk(KERN_ERR
"qnx4: unable to read the superblock\n");
256 if ( le32_to_cpup((__le32
*) bh
->b_data
) != QNX4_SUPER_MAGIC
) {
258 printk(KERN_ERR
"qnx4: wrong fsid in superblock.\n");
261 s
->s_op
= &qnx4_sops
;
262 s
->s_magic
= QNX4_SUPER_MAGIC
;
263 s
->s_flags
|= MS_RDONLY
; /* Yup, read-only yet */
264 qnx4_sb(s
)->sb_buf
= bh
;
265 qnx4_sb(s
)->sb
= (struct qnx4_super_block
*) bh
->b_data
;
268 /* check before allocating dentries, inodes, .. */
269 errmsg
= qnx4_checkroot(s
);
270 if (errmsg
!= NULL
) {
272 printk(KERN_ERR
"qnx4: %s\n", errmsg
);
276 /* does root not have inode number QNX4_ROOT_INO ?? */
277 root
= qnx4_iget(s
, QNX4_ROOT_INO
* QNX4_INODES_PER_BLOCK
);
279 printk(KERN_ERR
"qnx4: get inode failed\n");
285 s
->s_root
= d_alloc_root(root
);
286 if (s
->s_root
== NULL
)
305 static void qnx4_put_super(struct super_block
*sb
)
307 struct qnx4_sb_info
*qs
= qnx4_sb(sb
);
310 sb
->s_fs_info
= NULL
;
314 static int qnx4_writepage(struct page
*page
, struct writeback_control
*wbc
)
316 return block_write_full_page(page
,qnx4_get_block
, wbc
);
319 static int qnx4_readpage(struct file
*file
, struct page
*page
)
321 return block_read_full_page(page
,qnx4_get_block
);
324 static int qnx4_write_begin(struct file
*file
, struct address_space
*mapping
,
325 loff_t pos
, unsigned len
, unsigned flags
,
326 struct page
**pagep
, void **fsdata
)
328 struct qnx4_inode_info
*qnx4_inode
= qnx4_i(mapping
->host
);
332 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
334 &qnx4_inode
->mmu_private
);
336 loff_t isize
= mapping
->host
->i_size
;
337 if (pos
+ len
> isize
)
338 vmtruncate(mapping
->host
, isize
);
343 static sector_t
qnx4_bmap(struct address_space
*mapping
, sector_t block
)
345 return generic_block_bmap(mapping
,block
,qnx4_get_block
);
347 static const struct address_space_operations qnx4_aops
= {
348 .readpage
= qnx4_readpage
,
349 .writepage
= qnx4_writepage
,
350 .sync_page
= block_sync_page
,
351 .write_begin
= qnx4_write_begin
,
352 .write_end
= generic_write_end
,
356 struct inode
*qnx4_iget(struct super_block
*sb
, unsigned long ino
)
358 struct buffer_head
*bh
;
359 struct qnx4_inode_entry
*raw_inode
;
361 struct qnx4_inode_entry
*qnx4_inode
;
364 inode
= iget_locked(sb
, ino
);
366 return ERR_PTR(-ENOMEM
);
367 if (!(inode
->i_state
& I_NEW
))
370 qnx4_inode
= qnx4_raw_inode(inode
);
373 QNX4DEBUG((KERN_INFO
"reading inode : [%d]\n", ino
));
375 printk(KERN_ERR
"qnx4: bad inode number on dev %s: %lu is "
379 return ERR_PTR(-EIO
);
381 block
= ino
/ QNX4_INODES_PER_BLOCK
;
383 if (!(bh
= sb_bread(sb
, block
))) {
384 printk(KERN_ERR
"qnx4: major problem: unable to read inode from dev "
387 return ERR_PTR(-EIO
);
389 raw_inode
= ((struct qnx4_inode_entry
*) bh
->b_data
) +
390 (ino
% QNX4_INODES_PER_BLOCK
);
392 inode
->i_mode
= le16_to_cpu(raw_inode
->di_mode
);
393 inode
->i_uid
= (uid_t
)le16_to_cpu(raw_inode
->di_uid
);
394 inode
->i_gid
= (gid_t
)le16_to_cpu(raw_inode
->di_gid
);
395 inode
->i_nlink
= le16_to_cpu(raw_inode
->di_nlink
);
396 inode
->i_size
= le32_to_cpu(raw_inode
->di_size
);
397 inode
->i_mtime
.tv_sec
= le32_to_cpu(raw_inode
->di_mtime
);
398 inode
->i_mtime
.tv_nsec
= 0;
399 inode
->i_atime
.tv_sec
= le32_to_cpu(raw_inode
->di_atime
);
400 inode
->i_atime
.tv_nsec
= 0;
401 inode
->i_ctime
.tv_sec
= le32_to_cpu(raw_inode
->di_ctime
);
402 inode
->i_ctime
.tv_nsec
= 0;
403 inode
->i_blocks
= le32_to_cpu(raw_inode
->di_first_xtnt
.xtnt_size
);
405 memcpy(qnx4_inode
, raw_inode
, QNX4_DIR_ENTRY_SIZE
);
406 if (S_ISREG(inode
->i_mode
)) {
407 inode
->i_fop
= &generic_ro_fops
;
408 inode
->i_mapping
->a_ops
= &qnx4_aops
;
409 qnx4_i(inode
)->mmu_private
= inode
->i_size
;
410 } else if (S_ISDIR(inode
->i_mode
)) {
411 inode
->i_op
= &qnx4_dir_inode_operations
;
412 inode
->i_fop
= &qnx4_dir_operations
;
413 } else if (S_ISLNK(inode
->i_mode
)) {
414 inode
->i_op
= &page_symlink_inode_operations
;
415 inode
->i_mapping
->a_ops
= &qnx4_aops
;
416 qnx4_i(inode
)->mmu_private
= inode
->i_size
;
418 printk(KERN_ERR
"qnx4: bad inode %lu on dev %s\n",
422 return ERR_PTR(-EIO
);
425 unlock_new_inode(inode
);
429 static struct kmem_cache
*qnx4_inode_cachep
;
431 static struct inode
*qnx4_alloc_inode(struct super_block
*sb
)
433 struct qnx4_inode_info
*ei
;
434 ei
= kmem_cache_alloc(qnx4_inode_cachep
, GFP_KERNEL
);
437 return &ei
->vfs_inode
;
440 static void qnx4_destroy_inode(struct inode
*inode
)
442 kmem_cache_free(qnx4_inode_cachep
, qnx4_i(inode
));
445 static void init_once(void *foo
)
447 struct qnx4_inode_info
*ei
= (struct qnx4_inode_info
*) foo
;
449 inode_init_once(&ei
->vfs_inode
);
452 static int init_inodecache(void)
454 qnx4_inode_cachep
= kmem_cache_create("qnx4_inode_cache",
455 sizeof(struct qnx4_inode_info
),
456 0, (SLAB_RECLAIM_ACCOUNT
|
459 if (qnx4_inode_cachep
== NULL
)
464 static void destroy_inodecache(void)
466 kmem_cache_destroy(qnx4_inode_cachep
);
469 static int qnx4_get_sb(struct file_system_type
*fs_type
,
470 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
472 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, qnx4_fill_super
,
476 static struct file_system_type qnx4_fs_type
= {
477 .owner
= THIS_MODULE
,
479 .get_sb
= qnx4_get_sb
,
480 .kill_sb
= kill_block_super
,
481 .fs_flags
= FS_REQUIRES_DEV
,
484 static int __init
init_qnx4_fs(void)
488 err
= init_inodecache();
492 err
= register_filesystem(&qnx4_fs_type
);
494 destroy_inodecache();
498 printk(KERN_INFO
"QNX4 filesystem 0.2.3 registered.\n");
502 static void __exit
exit_qnx4_fs(void)
504 unregister_filesystem(&qnx4_fs_type
);
505 destroy_inodecache();
508 module_init(init_qnx4_fs
)
509 module_exit(exit_qnx4_fs
)
510 MODULE_LICENSE("GPL");