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/smp_lock.h> 20 #include <linux/pagemap.h> 21 #include <linux/buffer_head.h> 22 #include <linux/writeback.h> 23 #include <linux/statfs.h> 24 #include "qnx4.h" 25 26 #define QNX4_VERSION 4 27 #define QNX4_BMNAME ".bitmap" 28 29 static const struct super_operations qnx4_sops; 30 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 *); 36 37 static const struct super_operations qnx4_sops = 38 { 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, 44 }; 45 46 static int qnx4_remount(struct super_block *sb, int *flags, char *data) 47 { 48 struct qnx4_sb_info *qs; 49 50 qs = qnx4_sb(sb); 51 qs->Version = QNX4_VERSION; 52 *flags |= MS_RDONLY; 53 return 0; 54 } 55 56 static struct buffer_head *qnx4_getblk(struct inode *inode, int nr, 57 int create) 58 { 59 struct buffer_head *result = NULL; 60 61 if ( nr >= 0 ) 62 nr = qnx4_block_map( inode, nr ); 63 if (nr) { 64 result = sb_getblk(inode->i_sb, nr); 65 return result; 66 } 67 if (!create) { 68 return NULL; 69 } 70 #if 0 71 tmp = qnx4_new_block(inode->i_sb); 72 if (!tmp) { 73 return NULL; 74 } 75 result = sb_getblk(inode->i_sb, tmp); 76 if (tst) { 77 qnx4_free_block(inode->i_sb, tmp); 78 brelse(result); 79 goto repeat; 80 } 81 tst = tmp; 82 #endif 83 inode->i_ctime = CURRENT_TIME_SEC; 84 mark_inode_dirty(inode); 85 return result; 86 } 87 88 struct buffer_head *qnx4_bread(struct inode *inode, int block, int create) 89 { 90 struct buffer_head *bh; 91 92 bh = qnx4_getblk(inode, block, create); 93 if (!bh || buffer_uptodate(bh)) { 94 return bh; 95 } 96 ll_rw_block(READ, 1, &bh); 97 wait_on_buffer(bh); 98 if (buffer_uptodate(bh)) { 99 return bh; 100 } 101 brelse(bh); 102 103 return NULL; 104 } 105 106 static int qnx4_get_block( struct inode *inode, sector_t iblock, struct buffer_head *bh, int create ) 107 { 108 unsigned long phys; 109 110 QNX4DEBUG(("qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode->i_ino,iblock)); 111 112 phys = qnx4_block_map( inode, iblock ); 113 if ( phys ) { 114 // logical block is before EOF 115 map_bh(bh, inode->i_sb, phys); 116 } else if ( create ) { 117 // to be done. 118 } 119 return 0; 120 } 121 122 unsigned long qnx4_block_map( struct inode *inode, long iblock ) 123 { 124 int ix; 125 long offset, i_xblk; 126 unsigned long block = 0; 127 struct buffer_head *bh = NULL; 128 struct qnx4_xblk *xblk = NULL; 129 struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode); 130 u16 nxtnt = le16_to_cpu(qnx4_inode->di_num_xtnts); 131 132 if ( iblock < le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_size) ) { 133 // iblock is in the first extent. This is easy. 134 block = le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_blk) + iblock - 1; 135 } else { 136 // iblock is beyond first extent. We have to follow the extent chain. 137 i_xblk = le32_to_cpu(qnx4_inode->di_xblk); 138 offset = iblock - le32_to_cpu(qnx4_inode->di_first_xtnt.xtnt_size); 139 ix = 0; 140 while ( --nxtnt > 0 ) { 141 if ( ix == 0 ) { 142 // read next xtnt block. 143 bh = sb_bread(inode->i_sb, i_xblk - 1); 144 if ( !bh ) { 145 QNX4DEBUG(("qnx4: I/O error reading xtnt block [%ld])\n", i_xblk - 1)); 146 return -EIO; 147 } 148 xblk = (struct qnx4_xblk*)bh->b_data; 149 if ( memcmp( xblk->xblk_signature, "IamXblk", 7 ) ) { 150 QNX4DEBUG(("qnx4: block at %ld is not a valid xtnt\n", qnx4_inode->i_xblk)); 151 return -EIO; 152 } 153 } 154 if ( offset < le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_size) ) { 155 // got it! 156 block = le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_blk) + offset - 1; 157 break; 158 } 159 offset -= le32_to_cpu(xblk->xblk_xtnts[ix].xtnt_size); 160 if ( ++ix >= xblk->xblk_num_xtnts ) { 161 i_xblk = le32_to_cpu(xblk->xblk_next_xblk); 162 ix = 0; 163 brelse( bh ); 164 bh = NULL; 165 } 166 } 167 if ( bh ) 168 brelse( bh ); 169 } 170 171 QNX4DEBUG(("qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block)); 172 return block; 173 } 174 175 static int qnx4_statfs(struct dentry *dentry, struct kstatfs *buf) 176 { 177 struct super_block *sb = dentry->d_sb; 178 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 179 180 lock_kernel(); 181 182 buf->f_type = sb->s_magic; 183 buf->f_bsize = sb->s_blocksize; 184 buf->f_blocks = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size) * 8; 185 buf->f_bfree = qnx4_count_free_blocks(sb); 186 buf->f_bavail = buf->f_bfree; 187 buf->f_namelen = QNX4_NAME_MAX; 188 buf->f_fsid.val[0] = (u32)id; 189 buf->f_fsid.val[1] = (u32)(id >> 32); 190 191 unlock_kernel(); 192 193 return 0; 194 } 195 196 /* 197 * Check the root directory of the filesystem to make sure 198 * it really _is_ a qnx4 filesystem, and to check the size 199 * of the directory entry. 200 */ 201 static const char *qnx4_checkroot(struct super_block *sb) 202 { 203 struct buffer_head *bh; 204 struct qnx4_inode_entry *rootdir; 205 int rd, rl; 206 int i, j; 207 int found = 0; 208 209 if (*(qnx4_sb(sb)->sb->RootDir.di_fname) != '/') { 210 return "no qnx4 filesystem (no root dir)."; 211 } else { 212 QNX4DEBUG(("QNX4 filesystem found on dev %s.\n", sb->s_id)); 213 rd = le32_to_cpu(qnx4_sb(sb)->sb->RootDir.di_first_xtnt.xtnt_blk) - 1; 214 rl = le32_to_cpu(qnx4_sb(sb)->sb->RootDir.di_first_xtnt.xtnt_size); 215 for (j = 0; j < rl; j++) { 216 bh = sb_bread(sb, rd + j); /* root dir, first block */ 217 if (bh == NULL) { 218 return "unable to read root entry."; 219 } 220 for (i = 0; i < QNX4_INODES_PER_BLOCK; i++) { 221 rootdir = (struct qnx4_inode_entry *) (bh->b_data + i * QNX4_DIR_ENTRY_SIZE); 222 if (rootdir->di_fname != NULL) { 223 QNX4DEBUG(("Rootdir entry found : [%s]\n", rootdir->di_fname)); 224 if (!strncmp(rootdir->di_fname, QNX4_BMNAME, sizeof QNX4_BMNAME)) { 225 found = 1; 226 qnx4_sb(sb)->BitMap = kmalloc( sizeof( struct qnx4_inode_entry ), GFP_KERNEL ); 227 if (!qnx4_sb(sb)->BitMap) { 228 brelse (bh); 229 return "not enough memory for bitmap inode"; 230 } 231 memcpy( qnx4_sb(sb)->BitMap, rootdir, sizeof( struct qnx4_inode_entry ) ); /* keep bitmap inode known */ 232 break; 233 } 234 } 235 } 236 brelse(bh); 237 if (found != 0) { 238 break; 239 } 240 } 241 if (found == 0) { 242 return "bitmap file not found."; 243 } 244 } 245 return NULL; 246 } 247 248 static int qnx4_fill_super(struct super_block *s, void *data, int silent) 249 { 250 struct buffer_head *bh; 251 struct inode *root; 252 const char *errmsg; 253 struct qnx4_sb_info *qs; 254 int ret = -EINVAL; 255 256 qs = kzalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL); 257 if (!qs) 258 return -ENOMEM; 259 s->s_fs_info = qs; 260 261 sb_set_blocksize(s, QNX4_BLOCK_SIZE); 262 263 /* Check the superblock signature. Since the qnx4 code is 264 dangerous, we should leave as quickly as possible 265 if we don't belong here... */ 266 bh = sb_bread(s, 1); 267 if (!bh) { 268 printk("qnx4: unable to read the superblock\n"); 269 goto outnobh; 270 } 271 if ( le32_to_cpup((__le32*) bh->b_data) != QNX4_SUPER_MAGIC ) { 272 if (!silent) 273 printk("qnx4: wrong fsid in superblock.\n"); 274 goto out; 275 } 276 s->s_op = &qnx4_sops; 277 s->s_magic = QNX4_SUPER_MAGIC; 278 s->s_flags |= MS_RDONLY; /* Yup, read-only yet */ 279 qnx4_sb(s)->sb_buf = bh; 280 qnx4_sb(s)->sb = (struct qnx4_super_block *) bh->b_data; 281 282 283 /* check before allocating dentries, inodes, .. */ 284 errmsg = qnx4_checkroot(s); 285 if (errmsg != NULL) { 286 if (!silent) 287 printk("qnx4: %s\n", errmsg); 288 goto out; 289 } 290 291 /* does root not have inode number QNX4_ROOT_INO ?? */ 292 root = qnx4_iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK); 293 if (IS_ERR(root)) { 294 printk("qnx4: get inode failed\n"); 295 ret = PTR_ERR(root); 296 goto out; 297 } 298 299 ret = -ENOMEM; 300 s->s_root = d_alloc_root(root); 301 if (s->s_root == NULL) 302 goto outi; 303 304 brelse(bh); 305 306 return 0; 307 308 outi: 309 iput(root); 310 out: 311 brelse(bh); 312 outnobh: 313 kfree(qs); 314 s->s_fs_info = NULL; 315 return ret; 316 } 317 318 static void qnx4_put_super(struct super_block *sb) 319 { 320 struct qnx4_sb_info *qs = qnx4_sb(sb); 321 kfree( qs->BitMap ); 322 kfree( qs ); 323 sb->s_fs_info = NULL; 324 return; 325 } 326 327 static int qnx4_writepage(struct page *page, struct writeback_control *wbc) 328 { 329 return block_write_full_page(page,qnx4_get_block, wbc); 330 } 331 332 static int qnx4_readpage(struct file *file, struct page *page) 333 { 334 return block_read_full_page(page,qnx4_get_block); 335 } 336 337 static int qnx4_write_begin(struct file *file, struct address_space *mapping, 338 loff_t pos, unsigned len, unsigned flags, 339 struct page **pagep, void **fsdata) 340 { 341 struct qnx4_inode_info *qnx4_inode = qnx4_i(mapping->host); 342 *pagep = NULL; 343 return cont_write_begin(file, mapping, pos, len, flags, pagep, fsdata, 344 qnx4_get_block, 345 &qnx4_inode->mmu_private); 346 } 347 static sector_t qnx4_bmap(struct address_space *mapping, sector_t block) 348 { 349 return generic_block_bmap(mapping,block,qnx4_get_block); 350 } 351 static const struct address_space_operations qnx4_aops = { 352 .readpage = qnx4_readpage, 353 .writepage = qnx4_writepage, 354 .sync_page = block_sync_page, 355 .write_begin = qnx4_write_begin, 356 .write_end = generic_write_end, 357 .bmap = qnx4_bmap 358 }; 359 360 struct inode *qnx4_iget(struct super_block *sb, unsigned long ino) 361 { 362 struct buffer_head *bh; 363 struct qnx4_inode_entry *raw_inode; 364 int block; 365 struct qnx4_inode_entry *qnx4_inode; 366 struct inode *inode; 367 368 inode = iget_locked(sb, ino); 369 if (!inode) 370 return ERR_PTR(-ENOMEM); 371 if (!(inode->i_state & I_NEW)) 372 return inode; 373 374 qnx4_inode = qnx4_raw_inode(inode); 375 inode->i_mode = 0; 376 377 QNX4DEBUG(("Reading inode : [%d]\n", ino)); 378 if (!ino) { 379 printk(KERN_ERR "qnx4: bad inode number on dev %s: %lu is " 380 "out of range\n", 381 sb->s_id, ino); 382 iget_failed(inode); 383 return ERR_PTR(-EIO); 384 } 385 block = ino / QNX4_INODES_PER_BLOCK; 386 387 if (!(bh = sb_bread(sb, block))) { 388 printk("qnx4: major problem: unable to read inode from dev " 389 "%s\n", sb->s_id); 390 iget_failed(inode); 391 return ERR_PTR(-EIO); 392 } 393 raw_inode = ((struct qnx4_inode_entry *) bh->b_data) + 394 (ino % QNX4_INODES_PER_BLOCK); 395 396 inode->i_mode = le16_to_cpu(raw_inode->di_mode); 397 inode->i_uid = (uid_t)le16_to_cpu(raw_inode->di_uid); 398 inode->i_gid = (gid_t)le16_to_cpu(raw_inode->di_gid); 399 inode->i_nlink = le16_to_cpu(raw_inode->di_nlink); 400 inode->i_size = le32_to_cpu(raw_inode->di_size); 401 inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->di_mtime); 402 inode->i_mtime.tv_nsec = 0; 403 inode->i_atime.tv_sec = le32_to_cpu(raw_inode->di_atime); 404 inode->i_atime.tv_nsec = 0; 405 inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->di_ctime); 406 inode->i_ctime.tv_nsec = 0; 407 inode->i_blocks = le32_to_cpu(raw_inode->di_first_xtnt.xtnt_size); 408 409 memcpy(qnx4_inode, raw_inode, QNX4_DIR_ENTRY_SIZE); 410 if (S_ISREG(inode->i_mode)) { 411 inode->i_fop = &generic_ro_fops; 412 inode->i_mapping->a_ops = &qnx4_aops; 413 qnx4_i(inode)->mmu_private = inode->i_size; 414 } else if (S_ISDIR(inode->i_mode)) { 415 inode->i_op = &qnx4_dir_inode_operations; 416 inode->i_fop = &qnx4_dir_operations; 417 } else if (S_ISLNK(inode->i_mode)) { 418 inode->i_op = &page_symlink_inode_operations; 419 inode->i_mapping->a_ops = &qnx4_aops; 420 qnx4_i(inode)->mmu_private = inode->i_size; 421 } else { 422 printk(KERN_ERR "qnx4: bad inode %lu on dev %s\n", 423 ino, sb->s_id); 424 iget_failed(inode); 425 brelse(bh); 426 return ERR_PTR(-EIO); 427 } 428 brelse(bh); 429 unlock_new_inode(inode); 430 return inode; 431 } 432 433 static struct kmem_cache *qnx4_inode_cachep; 434 435 static struct inode *qnx4_alloc_inode(struct super_block *sb) 436 { 437 struct qnx4_inode_info *ei; 438 ei = kmem_cache_alloc(qnx4_inode_cachep, GFP_KERNEL); 439 if (!ei) 440 return NULL; 441 return &ei->vfs_inode; 442 } 443 444 static void qnx4_destroy_inode(struct inode *inode) 445 { 446 kmem_cache_free(qnx4_inode_cachep, qnx4_i(inode)); 447 } 448 449 static void init_once(void *foo) 450 { 451 struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo; 452 453 inode_init_once(&ei->vfs_inode); 454 } 455 456 static int init_inodecache(void) 457 { 458 qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache", 459 sizeof(struct qnx4_inode_info), 460 0, (SLAB_RECLAIM_ACCOUNT| 461 SLAB_MEM_SPREAD), 462 init_once); 463 if (qnx4_inode_cachep == NULL) 464 return -ENOMEM; 465 return 0; 466 } 467 468 static void destroy_inodecache(void) 469 { 470 kmem_cache_destroy(qnx4_inode_cachep); 471 } 472 473 static int qnx4_get_sb(struct file_system_type *fs_type, 474 int flags, const char *dev_name, void *data, struct vfsmount *mnt) 475 { 476 return get_sb_bdev(fs_type, flags, dev_name, data, qnx4_fill_super, 477 mnt); 478 } 479 480 static struct file_system_type qnx4_fs_type = { 481 .owner = THIS_MODULE, 482 .name = "qnx4", 483 .get_sb = qnx4_get_sb, 484 .kill_sb = kill_block_super, 485 .fs_flags = FS_REQUIRES_DEV, 486 }; 487 488 static int __init init_qnx4_fs(void) 489 { 490 int err; 491 492 err = init_inodecache(); 493 if (err) 494 return err; 495 496 err = register_filesystem(&qnx4_fs_type); 497 if (err) { 498 destroy_inodecache(); 499 return err; 500 } 501 502 printk("QNX4 filesystem 0.2.3 registered.\n"); 503 return 0; 504 } 505 506 static void __exit exit_qnx4_fs(void) 507 { 508 unregister_filesystem(&qnx4_fs_type); 509 destroy_inodecache(); 510 } 511 512 module_init(init_qnx4_fs) 513 module_exit(exit_qnx4_fs) 514 MODULE_LICENSE("GPL"); 515 516