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