1 /* 2 * QNX4 file system, Linux implementation. 3 * 4 * Version : 0.2.1 5 * 6 * Using parts of the xiafs filesystem. 7 * 8 * History : 9 * 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. 13 */ 14 15 #include <linux/module.h> 16 #include <linux/init.h> 17 #include <linux/slab.h> 18 #include <linux/highuid.h> 19 #include <linux/pagemap.h> 20 #include <linux/buffer_head.h> 21 #include <linux/writeback.h> 22 #include <linux/statfs.h> 23 #include "qnx4.h" 24 25 #define QNX4_VERSION 4 26 #define QNX4_BMNAME ".bitmap" 27 28 static const struct super_operations qnx4_sops; 29 30 static struct inode *qnx4_alloc_inode(struct super_block *sb); 31 static void qnx4_destroy_inode(struct inode *inode); 32 static int qnx4_remount(struct super_block *sb, int *flags, char *data); 33 static int qnx4_statfs(struct dentry *, struct kstatfs *); 34 35 static const struct super_operations qnx4_sops = 36 { 37 .alloc_inode = qnx4_alloc_inode, 38 .destroy_inode = qnx4_destroy_inode, 39 .statfs = qnx4_statfs, 40 .remount_fs = qnx4_remount, 41 }; 42 43 static int qnx4_remount(struct super_block *sb, int *flags, char *data) 44 { 45 struct qnx4_sb_info *qs; 46 47 qs = qnx4_sb(sb); 48 qs->Version = QNX4_VERSION; 49 *flags |= MS_RDONLY; 50 return 0; 51 } 52 53 static int qnx4_get_block( struct inode *inode, sector_t iblock, struct buffer_head *bh, int create ) 54 { 55 unsigned long phys; 56 57 QNX4DEBUG((KERN_INFO "qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode->i_ino,iblock)); 58 59 phys = qnx4_block_map( inode, iblock ); 60 if ( phys ) { 61 // logical block is before EOF 62 map_bh(bh, inode->i_sb, phys); 63 } 64 return 0; 65 } 66 67 static inline u32 try_extent(qnx4_xtnt_t *extent, u32 *offset) 68 { 69 u32 size = le32_to_cpu(extent->xtnt_size); 70 if (*offset < size) 71 return le32_to_cpu(extent->xtnt_blk) + *offset - 1; 72 *offset -= size; 73 return 0; 74 } 75 76 unsigned long qnx4_block_map( struct inode *inode, long iblock ) 77 { 78 int ix; 79 long i_xblk; 80 struct buffer_head *bh = NULL; 81 struct qnx4_xblk *xblk = NULL; 82 struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode); 83 u16 nxtnt = le16_to_cpu(qnx4_inode->di_num_xtnts); 84 u32 offset = iblock; 85 u32 block = try_extent(&qnx4_inode->di_first_xtnt, &offset); 86 87 if (block) { 88 // iblock is in the first extent. This is easy. 89 } else { 90 // iblock is beyond first extent. We have to follow the extent chain. 91 i_xblk = le32_to_cpu(qnx4_inode->di_xblk); 92 ix = 0; 93 while ( --nxtnt > 0 ) { 94 if ( ix == 0 ) { 95 // read next xtnt block. 96 bh = sb_bread(inode->i_sb, i_xblk - 1); 97 if ( !bh ) { 98 QNX4DEBUG((KERN_ERR "qnx4: I/O error reading xtnt block [%ld])\n", i_xblk - 1)); 99 return -EIO; 100 } 101 xblk = (struct qnx4_xblk*)bh->b_data; 102 if ( memcmp( xblk->xblk_signature, "IamXblk", 7 ) ) { 103 QNX4DEBUG((KERN_ERR "qnx4: block at %ld is not a valid xtnt\n", qnx4_inode->i_xblk)); 104 return -EIO; 105 } 106 } 107 block = try_extent(&xblk->xblk_xtnts[ix], &offset); 108 if (block) { 109 // got it! 110 break; 111 } 112 if ( ++ix >= xblk->xblk_num_xtnts ) { 113 i_xblk = le32_to_cpu(xblk->xblk_next_xblk); 114 ix = 0; 115 brelse( bh ); 116 bh = NULL; 117 } 118 } 119 if ( bh ) 120 brelse( bh ); 121 } 122 123 QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block)); 124 return block; 125 } 126 127 static int qnx4_statfs(struct dentry *dentry, struct kstatfs *buf) 128 { 129 struct super_block *sb = dentry->d_sb; 130 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 131 132 buf->f_type = sb->s_magic; 133 buf->f_bsize = sb->s_blocksize; 134 buf->f_blocks = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size) * 8; 135 buf->f_bfree = qnx4_count_free_blocks(sb); 136 buf->f_bavail = buf->f_bfree; 137 buf->f_namelen = QNX4_NAME_MAX; 138 buf->f_fsid.val[0] = (u32)id; 139 buf->f_fsid.val[1] = (u32)(id >> 32); 140 141 return 0; 142 } 143 144 /* 145 * Check the root directory of the filesystem to make sure 146 * it really _is_ a qnx4 filesystem, and to check the size 147 * of the directory entry. 148 */ 149 static const char *qnx4_checkroot(struct super_block *sb, 150 struct qnx4_super_block *s) 151 { 152 struct buffer_head *bh; 153 struct qnx4_inode_entry *rootdir; 154 int rd, rl; 155 int i, j; 156 157 if (s->RootDir.di_fname[0] != '/' || s->RootDir.di_fname[1] != '\0') 158 return "no qnx4 filesystem (no root dir)."; 159 QNX4DEBUG((KERN_NOTICE "QNX4 filesystem found on dev %s.\n", sb->s_id)); 160 rd = le32_to_cpu(s->RootDir.di_first_xtnt.xtnt_blk) - 1; 161 rl = le32_to_cpu(s->RootDir.di_first_xtnt.xtnt_size); 162 for (j = 0; j < rl; j++) { 163 bh = sb_bread(sb, rd + j); /* root dir, first block */ 164 if (bh == NULL) 165 return "unable to read root entry."; 166 rootdir = (struct qnx4_inode_entry *) bh->b_data; 167 for (i = 0; i < QNX4_INODES_PER_BLOCK; i++, rootdir++) { 168 QNX4DEBUG((KERN_INFO "rootdir entry found : [%s]\n", rootdir->di_fname)); 169 if (strcmp(rootdir->di_fname, QNX4_BMNAME) != 0) 170 continue; 171 qnx4_sb(sb)->BitMap = kmemdup(rootdir, 172 sizeof(struct qnx4_inode_entry), 173 GFP_KERNEL); 174 brelse(bh); 175 if (!qnx4_sb(sb)->BitMap) 176 return "not enough memory for bitmap inode"; 177 /* keep bitmap inode known */ 178 return NULL; 179 } 180 brelse(bh); 181 } 182 return "bitmap file not found."; 183 } 184 185 static int qnx4_fill_super(struct super_block *s, void *data, int silent) 186 { 187 struct buffer_head *bh; 188 struct inode *root; 189 const char *errmsg; 190 struct qnx4_sb_info *qs; 191 192 qs = kzalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL); 193 if (!qs) 194 return -ENOMEM; 195 s->s_fs_info = qs; 196 197 sb_set_blocksize(s, QNX4_BLOCK_SIZE); 198 199 s->s_op = &qnx4_sops; 200 s->s_magic = QNX4_SUPER_MAGIC; 201 s->s_flags |= MS_RDONLY; /* Yup, read-only yet */ 202 203 /* Check the superblock signature. Since the qnx4 code is 204 dangerous, we should leave as quickly as possible 205 if we don't belong here... */ 206 bh = sb_bread(s, 1); 207 if (!bh) { 208 printk(KERN_ERR "qnx4: unable to read the superblock\n"); 209 return -EINVAL; 210 } 211 212 /* check before allocating dentries, inodes, .. */ 213 errmsg = qnx4_checkroot(s, (struct qnx4_super_block *) bh->b_data); 214 brelse(bh); 215 if (errmsg != NULL) { 216 if (!silent) 217 printk(KERN_ERR "qnx4: %s\n", errmsg); 218 return -EINVAL; 219 } 220 221 /* does root not have inode number QNX4_ROOT_INO ?? */ 222 root = qnx4_iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK); 223 if (IS_ERR(root)) { 224 printk(KERN_ERR "qnx4: get inode failed\n"); 225 return PTR_ERR(root); 226 } 227 228 s->s_root = d_make_root(root); 229 if (s->s_root == NULL) 230 return -ENOMEM; 231 232 return 0; 233 } 234 235 static void qnx4_kill_sb(struct super_block *sb) 236 { 237 struct qnx4_sb_info *qs = qnx4_sb(sb); 238 kill_block_super(sb); 239 if (qs) { 240 kfree(qs->BitMap); 241 kfree(qs); 242 } 243 } 244 245 static int qnx4_readpage(struct file *file, struct page *page) 246 { 247 return block_read_full_page(page,qnx4_get_block); 248 } 249 250 static sector_t qnx4_bmap(struct address_space *mapping, sector_t block) 251 { 252 return generic_block_bmap(mapping,block,qnx4_get_block); 253 } 254 static const struct address_space_operations qnx4_aops = { 255 .readpage = qnx4_readpage, 256 .bmap = qnx4_bmap 257 }; 258 259 struct inode *qnx4_iget(struct super_block *sb, unsigned long ino) 260 { 261 struct buffer_head *bh; 262 struct qnx4_inode_entry *raw_inode; 263 int block; 264 struct qnx4_inode_entry *qnx4_inode; 265 struct inode *inode; 266 267 inode = iget_locked(sb, ino); 268 if (!inode) 269 return ERR_PTR(-ENOMEM); 270 if (!(inode->i_state & I_NEW)) 271 return inode; 272 273 qnx4_inode = qnx4_raw_inode(inode); 274 inode->i_mode = 0; 275 276 QNX4DEBUG((KERN_INFO "reading inode : [%d]\n", ino)); 277 if (!ino) { 278 printk(KERN_ERR "qnx4: bad inode number on dev %s: %lu is " 279 "out of range\n", 280 sb->s_id, ino); 281 iget_failed(inode); 282 return ERR_PTR(-EIO); 283 } 284 block = ino / QNX4_INODES_PER_BLOCK; 285 286 if (!(bh = sb_bread(sb, block))) { 287 printk(KERN_ERR "qnx4: major problem: unable to read inode from dev " 288 "%s\n", sb->s_id); 289 iget_failed(inode); 290 return ERR_PTR(-EIO); 291 } 292 raw_inode = ((struct qnx4_inode_entry *) bh->b_data) + 293 (ino % QNX4_INODES_PER_BLOCK); 294 295 inode->i_mode = le16_to_cpu(raw_inode->di_mode); 296 i_uid_write(inode, (uid_t)le16_to_cpu(raw_inode->di_uid)); 297 i_gid_write(inode, (gid_t)le16_to_cpu(raw_inode->di_gid)); 298 set_nlink(inode, le16_to_cpu(raw_inode->di_nlink)); 299 inode->i_size = le32_to_cpu(raw_inode->di_size); 300 inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->di_mtime); 301 inode->i_mtime.tv_nsec = 0; 302 inode->i_atime.tv_sec = le32_to_cpu(raw_inode->di_atime); 303 inode->i_atime.tv_nsec = 0; 304 inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->di_ctime); 305 inode->i_ctime.tv_nsec = 0; 306 inode->i_blocks = le32_to_cpu(raw_inode->di_first_xtnt.xtnt_size); 307 308 memcpy(qnx4_inode, raw_inode, QNX4_DIR_ENTRY_SIZE); 309 if (S_ISREG(inode->i_mode)) { 310 inode->i_fop = &generic_ro_fops; 311 inode->i_mapping->a_ops = &qnx4_aops; 312 qnx4_i(inode)->mmu_private = inode->i_size; 313 } else if (S_ISDIR(inode->i_mode)) { 314 inode->i_op = &qnx4_dir_inode_operations; 315 inode->i_fop = &qnx4_dir_operations; 316 } else if (S_ISLNK(inode->i_mode)) { 317 inode->i_op = &page_symlink_inode_operations; 318 inode->i_mapping->a_ops = &qnx4_aops; 319 qnx4_i(inode)->mmu_private = inode->i_size; 320 } else { 321 printk(KERN_ERR "qnx4: bad inode %lu on dev %s\n", 322 ino, sb->s_id); 323 iget_failed(inode); 324 brelse(bh); 325 return ERR_PTR(-EIO); 326 } 327 brelse(bh); 328 unlock_new_inode(inode); 329 return inode; 330 } 331 332 static struct kmem_cache *qnx4_inode_cachep; 333 334 static struct inode *qnx4_alloc_inode(struct super_block *sb) 335 { 336 struct qnx4_inode_info *ei; 337 ei = kmem_cache_alloc(qnx4_inode_cachep, GFP_KERNEL); 338 if (!ei) 339 return NULL; 340 return &ei->vfs_inode; 341 } 342 343 static void qnx4_i_callback(struct rcu_head *head) 344 { 345 struct inode *inode = container_of(head, struct inode, i_rcu); 346 kmem_cache_free(qnx4_inode_cachep, qnx4_i(inode)); 347 } 348 349 static void qnx4_destroy_inode(struct inode *inode) 350 { 351 call_rcu(&inode->i_rcu, qnx4_i_callback); 352 } 353 354 static void init_once(void *foo) 355 { 356 struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo; 357 358 inode_init_once(&ei->vfs_inode); 359 } 360 361 static int init_inodecache(void) 362 { 363 qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache", 364 sizeof(struct qnx4_inode_info), 365 0, (SLAB_RECLAIM_ACCOUNT| 366 SLAB_MEM_SPREAD), 367 init_once); 368 if (qnx4_inode_cachep == NULL) 369 return -ENOMEM; 370 return 0; 371 } 372 373 static void destroy_inodecache(void) 374 { 375 /* 376 * Make sure all delayed rcu free inodes are flushed before we 377 * destroy cache. 378 */ 379 rcu_barrier(); 380 kmem_cache_destroy(qnx4_inode_cachep); 381 } 382 383 static struct dentry *qnx4_mount(struct file_system_type *fs_type, 384 int flags, const char *dev_name, void *data) 385 { 386 return mount_bdev(fs_type, flags, dev_name, data, qnx4_fill_super); 387 } 388 389 static struct file_system_type qnx4_fs_type = { 390 .owner = THIS_MODULE, 391 .name = "qnx4", 392 .mount = qnx4_mount, 393 .kill_sb = qnx4_kill_sb, 394 .fs_flags = FS_REQUIRES_DEV, 395 }; 396 MODULE_ALIAS_FS("qnx4"); 397 398 static int __init init_qnx4_fs(void) 399 { 400 int err; 401 402 err = init_inodecache(); 403 if (err) 404 return err; 405 406 err = register_filesystem(&qnx4_fs_type); 407 if (err) { 408 destroy_inodecache(); 409 return err; 410 } 411 412 printk(KERN_INFO "QNX4 filesystem 0.2.3 registered.\n"); 413 return 0; 414 } 415 416 static void __exit exit_qnx4_fs(void) 417 { 418 unregister_filesystem(&qnx4_fs_type); 419 destroy_inodecache(); 420 } 421 422 module_init(init_qnx4_fs) 423 module_exit(exit_qnx4_fs) 424 MODULE_LICENSE("GPL"); 425 426