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 (!strncmp(rootdir
->di_fname
, QNX4_BMNAME
, sizeof QNX4_BMNAME
)) {
206 qnx4_sb(sb
)->BitMap
= kmalloc( sizeof( struct qnx4_inode_entry
), GFP_KERNEL
);
207 if (!qnx4_sb(sb
)->BitMap
) {
209 return "not enough memory for bitmap inode";
211 memcpy( qnx4_sb(sb
)->BitMap
, rootdir
, sizeof( struct qnx4_inode_entry
) ); /* keep bitmap inode known */
222 return "bitmap file not found.";
228 static int qnx4_fill_super(struct super_block
*s
, void *data
, int silent
)
230 struct buffer_head
*bh
;
233 struct qnx4_sb_info
*qs
;
236 qs
= kzalloc(sizeof(struct qnx4_sb_info
), GFP_KERNEL
);
241 sb_set_blocksize(s
, QNX4_BLOCK_SIZE
);
243 /* Check the superblock signature. Since the qnx4 code is
244 dangerous, we should leave as quickly as possible
245 if we don't belong here... */
248 printk(KERN_ERR
"qnx4: unable to read the superblock\n");
251 if ( le32_to_cpup((__le32
*) bh
->b_data
) != QNX4_SUPER_MAGIC
) {
253 printk(KERN_ERR
"qnx4: wrong fsid in superblock.\n");
256 s
->s_op
= &qnx4_sops
;
257 s
->s_magic
= QNX4_SUPER_MAGIC
;
258 s
->s_flags
|= MS_RDONLY
; /* Yup, read-only yet */
259 qnx4_sb(s
)->sb_buf
= bh
;
260 qnx4_sb(s
)->sb
= (struct qnx4_super_block
*) bh
->b_data
;
263 /* check before allocating dentries, inodes, .. */
264 errmsg
= qnx4_checkroot(s
);
265 if (errmsg
!= NULL
) {
267 printk(KERN_ERR
"qnx4: %s\n", errmsg
);
271 /* does root not have inode number QNX4_ROOT_INO ?? */
272 root
= qnx4_iget(s
, QNX4_ROOT_INO
* QNX4_INODES_PER_BLOCK
);
274 printk(KERN_ERR
"qnx4: get inode failed\n");
280 s
->s_root
= d_alloc_root(root
);
281 if (s
->s_root
== NULL
)
298 static void qnx4_put_super(struct super_block
*sb
)
300 struct qnx4_sb_info
*qs
= qnx4_sb(sb
);
303 sb
->s_fs_info
= NULL
;
307 static int qnx4_writepage(struct page
*page
, struct writeback_control
*wbc
)
309 return block_write_full_page(page
,qnx4_get_block
, wbc
);
312 static int qnx4_readpage(struct file
*file
, struct page
*page
)
314 return block_read_full_page(page
,qnx4_get_block
);
317 static int qnx4_write_begin(struct file
*file
, struct address_space
*mapping
,
318 loff_t pos
, unsigned len
, unsigned flags
,
319 struct page
**pagep
, void **fsdata
)
321 struct qnx4_inode_info
*qnx4_inode
= qnx4_i(mapping
->host
);
323 return cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
325 &qnx4_inode
->mmu_private
);
327 static sector_t
qnx4_bmap(struct address_space
*mapping
, sector_t block
)
329 return generic_block_bmap(mapping
,block
,qnx4_get_block
);
331 static const struct address_space_operations qnx4_aops
= {
332 .readpage
= qnx4_readpage
,
333 .writepage
= qnx4_writepage
,
334 .sync_page
= block_sync_page
,
335 .write_begin
= qnx4_write_begin
,
336 .write_end
= generic_write_end
,
340 struct inode
*qnx4_iget(struct super_block
*sb
, unsigned long ino
)
342 struct buffer_head
*bh
;
343 struct qnx4_inode_entry
*raw_inode
;
345 struct qnx4_inode_entry
*qnx4_inode
;
348 inode
= iget_locked(sb
, ino
);
350 return ERR_PTR(-ENOMEM
);
351 if (!(inode
->i_state
& I_NEW
))
354 qnx4_inode
= qnx4_raw_inode(inode
);
357 QNX4DEBUG((KERN_INFO
"reading inode : [%d]\n", ino
));
359 printk(KERN_ERR
"qnx4: bad inode number on dev %s: %lu is "
363 return ERR_PTR(-EIO
);
365 block
= ino
/ QNX4_INODES_PER_BLOCK
;
367 if (!(bh
= sb_bread(sb
, block
))) {
368 printk(KERN_ERR
"qnx4: major problem: unable to read inode from dev "
371 return ERR_PTR(-EIO
);
373 raw_inode
= ((struct qnx4_inode_entry
*) bh
->b_data
) +
374 (ino
% QNX4_INODES_PER_BLOCK
);
376 inode
->i_mode
= le16_to_cpu(raw_inode
->di_mode
);
377 inode
->i_uid
= (uid_t
)le16_to_cpu(raw_inode
->di_uid
);
378 inode
->i_gid
= (gid_t
)le16_to_cpu(raw_inode
->di_gid
);
379 inode
->i_nlink
= le16_to_cpu(raw_inode
->di_nlink
);
380 inode
->i_size
= le32_to_cpu(raw_inode
->di_size
);
381 inode
->i_mtime
.tv_sec
= le32_to_cpu(raw_inode
->di_mtime
);
382 inode
->i_mtime
.tv_nsec
= 0;
383 inode
->i_atime
.tv_sec
= le32_to_cpu(raw_inode
->di_atime
);
384 inode
->i_atime
.tv_nsec
= 0;
385 inode
->i_ctime
.tv_sec
= le32_to_cpu(raw_inode
->di_ctime
);
386 inode
->i_ctime
.tv_nsec
= 0;
387 inode
->i_blocks
= le32_to_cpu(raw_inode
->di_first_xtnt
.xtnt_size
);
389 memcpy(qnx4_inode
, raw_inode
, QNX4_DIR_ENTRY_SIZE
);
390 if (S_ISREG(inode
->i_mode
)) {
391 inode
->i_fop
= &generic_ro_fops
;
392 inode
->i_mapping
->a_ops
= &qnx4_aops
;
393 qnx4_i(inode
)->mmu_private
= inode
->i_size
;
394 } else if (S_ISDIR(inode
->i_mode
)) {
395 inode
->i_op
= &qnx4_dir_inode_operations
;
396 inode
->i_fop
= &qnx4_dir_operations
;
397 } else if (S_ISLNK(inode
->i_mode
)) {
398 inode
->i_op
= &page_symlink_inode_operations
;
399 inode
->i_mapping
->a_ops
= &qnx4_aops
;
400 qnx4_i(inode
)->mmu_private
= inode
->i_size
;
402 printk(KERN_ERR
"qnx4: bad inode %lu on dev %s\n",
406 return ERR_PTR(-EIO
);
409 unlock_new_inode(inode
);
413 static struct kmem_cache
*qnx4_inode_cachep
;
415 static struct inode
*qnx4_alloc_inode(struct super_block
*sb
)
417 struct qnx4_inode_info
*ei
;
418 ei
= kmem_cache_alloc(qnx4_inode_cachep
, GFP_KERNEL
);
421 return &ei
->vfs_inode
;
424 static void qnx4_destroy_inode(struct inode
*inode
)
426 kmem_cache_free(qnx4_inode_cachep
, qnx4_i(inode
));
429 static void init_once(void *foo
)
431 struct qnx4_inode_info
*ei
= (struct qnx4_inode_info
*) foo
;
433 inode_init_once(&ei
->vfs_inode
);
436 static int init_inodecache(void)
438 qnx4_inode_cachep
= kmem_cache_create("qnx4_inode_cache",
439 sizeof(struct qnx4_inode_info
),
440 0, (SLAB_RECLAIM_ACCOUNT
|
443 if (qnx4_inode_cachep
== NULL
)
448 static void destroy_inodecache(void)
450 kmem_cache_destroy(qnx4_inode_cachep
);
453 static int qnx4_get_sb(struct file_system_type
*fs_type
,
454 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
456 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, qnx4_fill_super
,
460 static struct file_system_type qnx4_fs_type
= {
461 .owner
= THIS_MODULE
,
463 .get_sb
= qnx4_get_sb
,
464 .kill_sb
= kill_block_super
,
465 .fs_flags
= FS_REQUIRES_DEV
,
468 static int __init
init_qnx4_fs(void)
472 err
= init_inodecache();
476 err
= register_filesystem(&qnx4_fs_type
);
478 destroy_inodecache();
482 printk(KERN_INFO
"QNX4 filesystem 0.2.3 registered.\n");
486 static void __exit
exit_qnx4_fs(void)
488 unregister_filesystem(&qnx4_fs_type
);
489 destroy_inodecache();
492 module_init(init_qnx4_fs
)
493 module_exit(exit_qnx4_fs
)
494 MODULE_LICENSE("GPL");