1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * QNX6 file system, Linux implementation. 4 * 5 * Version : 1.0.0 6 * 7 * History : 8 * 9 * 01-02-2012 by Kai Bankett (chaosman@ontika.net) : first release. 10 * 16-02-2012 pagemap extension by Al Viro 11 * 12 */ 13 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/slab.h> 17 #include <linux/highuid.h> 18 #include <linux/pagemap.h> 19 #include <linux/buffer_head.h> 20 #include <linux/writeback.h> 21 #include <linux/statfs.h> 22 #include <linux/parser.h> 23 #include <linux/seq_file.h> 24 #include <linux/mount.h> 25 #include <linux/crc32.h> 26 #include <linux/mpage.h> 27 #include "qnx6.h" 28 29 static const struct super_operations qnx6_sops; 30 31 static void qnx6_put_super(struct super_block *sb); 32 static struct inode *qnx6_alloc_inode(struct super_block *sb); 33 static void qnx6_free_inode(struct inode *inode); 34 static int qnx6_remount(struct super_block *sb, int *flags, char *data); 35 static int qnx6_statfs(struct dentry *dentry, struct kstatfs *buf); 36 static int qnx6_show_options(struct seq_file *seq, struct dentry *root); 37 38 static const struct super_operations qnx6_sops = { 39 .alloc_inode = qnx6_alloc_inode, 40 .free_inode = qnx6_free_inode, 41 .put_super = qnx6_put_super, 42 .statfs = qnx6_statfs, 43 .remount_fs = qnx6_remount, 44 .show_options = qnx6_show_options, 45 }; 46 47 static int qnx6_show_options(struct seq_file *seq, struct dentry *root) 48 { 49 struct super_block *sb = root->d_sb; 50 struct qnx6_sb_info *sbi = QNX6_SB(sb); 51 52 if (sbi->s_mount_opt & QNX6_MOUNT_MMI_FS) 53 seq_puts(seq, ",mmi_fs"); 54 return 0; 55 } 56 57 static int qnx6_remount(struct super_block *sb, int *flags, char *data) 58 { 59 sync_filesystem(sb); 60 *flags |= SB_RDONLY; 61 return 0; 62 } 63 64 static unsigned qnx6_get_devblock(struct super_block *sb, __fs32 block) 65 { 66 struct qnx6_sb_info *sbi = QNX6_SB(sb); 67 return fs32_to_cpu(sbi, block) + sbi->s_blks_off; 68 } 69 70 static unsigned qnx6_block_map(struct inode *inode, unsigned iblock); 71 72 static int qnx6_get_block(struct inode *inode, sector_t iblock, 73 struct buffer_head *bh, int create) 74 { 75 unsigned phys; 76 77 pr_debug("qnx6_get_block inode=[%ld] iblock=[%ld]\n", 78 inode->i_ino, (unsigned long)iblock); 79 80 phys = qnx6_block_map(inode, iblock); 81 if (phys) { 82 /* logical block is before EOF */ 83 map_bh(bh, inode->i_sb, phys); 84 } 85 return 0; 86 } 87 88 static int qnx6_check_blockptr(__fs32 ptr) 89 { 90 if (ptr == ~(__fs32)0) { 91 pr_err("hit unused blockpointer.\n"); 92 return 0; 93 } 94 return 1; 95 } 96 97 static int qnx6_readpage(struct file *file, struct page *page) 98 { 99 return mpage_readpage(page, qnx6_get_block); 100 } 101 102 static int qnx6_readpages(struct file *file, struct address_space *mapping, 103 struct list_head *pages, unsigned nr_pages) 104 { 105 return mpage_readpages(mapping, pages, nr_pages, qnx6_get_block); 106 } 107 108 /* 109 * returns the block number for the no-th element in the tree 110 * inodebits requred as there are multiple inodes in one inode block 111 */ 112 static unsigned qnx6_block_map(struct inode *inode, unsigned no) 113 { 114 struct super_block *s = inode->i_sb; 115 struct qnx6_sb_info *sbi = QNX6_SB(s); 116 struct qnx6_inode_info *ei = QNX6_I(inode); 117 unsigned block = 0; 118 struct buffer_head *bh; 119 __fs32 ptr; 120 int levelptr; 121 int ptrbits = sbi->s_ptrbits; 122 int bitdelta; 123 u32 mask = (1 << ptrbits) - 1; 124 int depth = ei->di_filelevels; 125 int i; 126 127 bitdelta = ptrbits * depth; 128 levelptr = no >> bitdelta; 129 130 if (levelptr > QNX6_NO_DIRECT_POINTERS - 1) { 131 pr_err("Requested file block number (%u) too big.", no); 132 return 0; 133 } 134 135 block = qnx6_get_devblock(s, ei->di_block_ptr[levelptr]); 136 137 for (i = 0; i < depth; i++) { 138 bh = sb_bread(s, block); 139 if (!bh) { 140 pr_err("Error reading block (%u)\n", block); 141 return 0; 142 } 143 bitdelta -= ptrbits; 144 levelptr = (no >> bitdelta) & mask; 145 ptr = ((__fs32 *)bh->b_data)[levelptr]; 146 147 if (!qnx6_check_blockptr(ptr)) 148 return 0; 149 150 block = qnx6_get_devblock(s, ptr); 151 brelse(bh); 152 } 153 return block; 154 } 155 156 static int qnx6_statfs(struct dentry *dentry, struct kstatfs *buf) 157 { 158 struct super_block *sb = dentry->d_sb; 159 struct qnx6_sb_info *sbi = QNX6_SB(sb); 160 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 161 162 buf->f_type = sb->s_magic; 163 buf->f_bsize = sb->s_blocksize; 164 buf->f_blocks = fs32_to_cpu(sbi, sbi->sb->sb_num_blocks); 165 buf->f_bfree = fs32_to_cpu(sbi, sbi->sb->sb_free_blocks); 166 buf->f_files = fs32_to_cpu(sbi, sbi->sb->sb_num_inodes); 167 buf->f_ffree = fs32_to_cpu(sbi, sbi->sb->sb_free_inodes); 168 buf->f_bavail = buf->f_bfree; 169 buf->f_namelen = QNX6_LONG_NAME_MAX; 170 buf->f_fsid.val[0] = (u32)id; 171 buf->f_fsid.val[1] = (u32)(id >> 32); 172 173 return 0; 174 } 175 176 /* 177 * Check the root directory of the filesystem to make sure 178 * it really _is_ a qnx6 filesystem, and to check the size 179 * of the directory entry. 180 */ 181 static const char *qnx6_checkroot(struct super_block *s) 182 { 183 static char match_root[2][3] = {".\0\0", "..\0"}; 184 int i, error = 0; 185 struct qnx6_dir_entry *dir_entry; 186 struct inode *root = d_inode(s->s_root); 187 struct address_space *mapping = root->i_mapping; 188 struct page *page = read_mapping_page(mapping, 0, NULL); 189 if (IS_ERR(page)) 190 return "error reading root directory"; 191 kmap(page); 192 dir_entry = page_address(page); 193 for (i = 0; i < 2; i++) { 194 /* maximum 3 bytes - due to match_root limitation */ 195 if (strncmp(dir_entry[i].de_fname, match_root[i], 3)) 196 error = 1; 197 } 198 qnx6_put_page(page); 199 if (error) 200 return "error reading root directory."; 201 return NULL; 202 } 203 204 #ifdef CONFIG_QNX6FS_DEBUG 205 void qnx6_superblock_debug(struct qnx6_super_block *sb, struct super_block *s) 206 { 207 struct qnx6_sb_info *sbi = QNX6_SB(s); 208 209 pr_debug("magic: %08x\n", fs32_to_cpu(sbi, sb->sb_magic)); 210 pr_debug("checksum: %08x\n", fs32_to_cpu(sbi, sb->sb_checksum)); 211 pr_debug("serial: %llx\n", fs64_to_cpu(sbi, sb->sb_serial)); 212 pr_debug("flags: %08x\n", fs32_to_cpu(sbi, sb->sb_flags)); 213 pr_debug("blocksize: %08x\n", fs32_to_cpu(sbi, sb->sb_blocksize)); 214 pr_debug("num_inodes: %08x\n", fs32_to_cpu(sbi, sb->sb_num_inodes)); 215 pr_debug("free_inodes: %08x\n", fs32_to_cpu(sbi, sb->sb_free_inodes)); 216 pr_debug("num_blocks: %08x\n", fs32_to_cpu(sbi, sb->sb_num_blocks)); 217 pr_debug("free_blocks: %08x\n", fs32_to_cpu(sbi, sb->sb_free_blocks)); 218 pr_debug("inode_levels: %02x\n", sb->Inode.levels); 219 } 220 #endif 221 222 enum { 223 Opt_mmifs, 224 Opt_err 225 }; 226 227 static const match_table_t tokens = { 228 {Opt_mmifs, "mmi_fs"}, 229 {Opt_err, NULL} 230 }; 231 232 static int qnx6_parse_options(char *options, struct super_block *sb) 233 { 234 char *p; 235 struct qnx6_sb_info *sbi = QNX6_SB(sb); 236 substring_t args[MAX_OPT_ARGS]; 237 238 if (!options) 239 return 1; 240 241 while ((p = strsep(&options, ",")) != NULL) { 242 int token; 243 if (!*p) 244 continue; 245 246 token = match_token(p, tokens, args); 247 switch (token) { 248 case Opt_mmifs: 249 set_opt(sbi->s_mount_opt, MMI_FS); 250 break; 251 default: 252 return 0; 253 } 254 } 255 return 1; 256 } 257 258 static struct buffer_head *qnx6_check_first_superblock(struct super_block *s, 259 int offset, int silent) 260 { 261 struct qnx6_sb_info *sbi = QNX6_SB(s); 262 struct buffer_head *bh; 263 struct qnx6_super_block *sb; 264 265 /* Check the superblock signatures 266 start with the first superblock */ 267 bh = sb_bread(s, offset); 268 if (!bh) { 269 pr_err("unable to read the first superblock\n"); 270 return NULL; 271 } 272 sb = (struct qnx6_super_block *)bh->b_data; 273 if (fs32_to_cpu(sbi, sb->sb_magic) != QNX6_SUPER_MAGIC) { 274 sbi->s_bytesex = BYTESEX_BE; 275 if (fs32_to_cpu(sbi, sb->sb_magic) == QNX6_SUPER_MAGIC) { 276 /* we got a big endian fs */ 277 pr_debug("fs got different endianness.\n"); 278 return bh; 279 } else 280 sbi->s_bytesex = BYTESEX_LE; 281 if (!silent) { 282 if (offset == 0) { 283 pr_err("wrong signature (magic) in superblock #1.\n"); 284 } else { 285 pr_info("wrong signature (magic) at position (0x%lx) - will try alternative position (0x0000).\n", 286 offset * s->s_blocksize); 287 } 288 } 289 brelse(bh); 290 return NULL; 291 } 292 return bh; 293 } 294 295 static struct inode *qnx6_private_inode(struct super_block *s, 296 struct qnx6_root_node *p); 297 298 static int qnx6_fill_super(struct super_block *s, void *data, int silent) 299 { 300 struct buffer_head *bh1 = NULL, *bh2 = NULL; 301 struct qnx6_super_block *sb1 = NULL, *sb2 = NULL; 302 struct qnx6_sb_info *sbi; 303 struct inode *root; 304 const char *errmsg; 305 struct qnx6_sb_info *qs; 306 int ret = -EINVAL; 307 u64 offset; 308 int bootblock_offset = QNX6_BOOTBLOCK_SIZE; 309 310 qs = kzalloc(sizeof(struct qnx6_sb_info), GFP_KERNEL); 311 if (!qs) 312 return -ENOMEM; 313 s->s_fs_info = qs; 314 315 /* Superblock always is 512 Byte long */ 316 if (!sb_set_blocksize(s, QNX6_SUPERBLOCK_SIZE)) { 317 pr_err("unable to set blocksize\n"); 318 goto outnobh; 319 } 320 321 /* parse the mount-options */ 322 if (!qnx6_parse_options((char *) data, s)) { 323 pr_err("invalid mount options.\n"); 324 goto outnobh; 325 } 326 if (test_opt(s, MMI_FS)) { 327 sb1 = qnx6_mmi_fill_super(s, silent); 328 if (sb1) 329 goto mmi_success; 330 else 331 goto outnobh; 332 } 333 sbi = QNX6_SB(s); 334 sbi->s_bytesex = BYTESEX_LE; 335 /* Check the superblock signatures 336 start with the first superblock */ 337 bh1 = qnx6_check_first_superblock(s, 338 bootblock_offset / QNX6_SUPERBLOCK_SIZE, silent); 339 if (!bh1) { 340 /* try again without bootblock offset */ 341 bh1 = qnx6_check_first_superblock(s, 0, silent); 342 if (!bh1) { 343 pr_err("unable to read the first superblock\n"); 344 goto outnobh; 345 } 346 /* seems that no bootblock at partition start */ 347 bootblock_offset = 0; 348 } 349 sb1 = (struct qnx6_super_block *)bh1->b_data; 350 351 #ifdef CONFIG_QNX6FS_DEBUG 352 qnx6_superblock_debug(sb1, s); 353 #endif 354 355 /* checksum check - start at byte 8 and end at byte 512 */ 356 if (fs32_to_cpu(sbi, sb1->sb_checksum) != 357 crc32_be(0, (char *)(bh1->b_data + 8), 504)) { 358 pr_err("superblock #1 checksum error\n"); 359 goto out; 360 } 361 362 /* set new blocksize */ 363 if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) { 364 pr_err("unable to set blocksize\n"); 365 goto out; 366 } 367 /* blocksize invalidates bh - pull it back in */ 368 brelse(bh1); 369 bh1 = sb_bread(s, bootblock_offset >> s->s_blocksize_bits); 370 if (!bh1) 371 goto outnobh; 372 sb1 = (struct qnx6_super_block *)bh1->b_data; 373 374 /* calculate second superblock blocknumber */ 375 offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) + 376 (bootblock_offset >> s->s_blocksize_bits) + 377 (QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits); 378 379 /* set bootblock offset */ 380 sbi->s_blks_off = (bootblock_offset >> s->s_blocksize_bits) + 381 (QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits); 382 383 /* next the second superblock */ 384 bh2 = sb_bread(s, offset); 385 if (!bh2) { 386 pr_err("unable to read the second superblock\n"); 387 goto out; 388 } 389 sb2 = (struct qnx6_super_block *)bh2->b_data; 390 if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) { 391 if (!silent) 392 pr_err("wrong signature (magic) in superblock #2.\n"); 393 goto out; 394 } 395 396 /* checksum check - start at byte 8 and end at byte 512 */ 397 if (fs32_to_cpu(sbi, sb2->sb_checksum) != 398 crc32_be(0, (char *)(bh2->b_data + 8), 504)) { 399 pr_err("superblock #2 checksum error\n"); 400 goto out; 401 } 402 403 if (fs64_to_cpu(sbi, sb1->sb_serial) >= 404 fs64_to_cpu(sbi, sb2->sb_serial)) { 405 /* superblock #1 active */ 406 sbi->sb_buf = bh1; 407 sbi->sb = (struct qnx6_super_block *)bh1->b_data; 408 brelse(bh2); 409 pr_info("superblock #1 active\n"); 410 } else { 411 /* superblock #2 active */ 412 sbi->sb_buf = bh2; 413 sbi->sb = (struct qnx6_super_block *)bh2->b_data; 414 brelse(bh1); 415 pr_info("superblock #2 active\n"); 416 } 417 mmi_success: 418 /* sanity check - limit maximum indirect pointer levels */ 419 if (sb1->Inode.levels > QNX6_PTR_MAX_LEVELS) { 420 pr_err("too many inode levels (max %i, sb %i)\n", 421 QNX6_PTR_MAX_LEVELS, sb1->Inode.levels); 422 goto out; 423 } 424 if (sb1->Longfile.levels > QNX6_PTR_MAX_LEVELS) { 425 pr_err("too many longfilename levels (max %i, sb %i)\n", 426 QNX6_PTR_MAX_LEVELS, sb1->Longfile.levels); 427 goto out; 428 } 429 s->s_op = &qnx6_sops; 430 s->s_magic = QNX6_SUPER_MAGIC; 431 s->s_flags |= SB_RDONLY; /* Yup, read-only yet */ 432 s->s_time_min = 0; 433 s->s_time_max = U32_MAX; 434 435 /* ease the later tree level calculations */ 436 sbi = QNX6_SB(s); 437 sbi->s_ptrbits = ilog2(s->s_blocksize / 4); 438 sbi->inodes = qnx6_private_inode(s, &sb1->Inode); 439 if (!sbi->inodes) 440 goto out; 441 sbi->longfile = qnx6_private_inode(s, &sb1->Longfile); 442 if (!sbi->longfile) 443 goto out1; 444 445 /* prefetch root inode */ 446 root = qnx6_iget(s, QNX6_ROOT_INO); 447 if (IS_ERR(root)) { 448 pr_err("get inode failed\n"); 449 ret = PTR_ERR(root); 450 goto out2; 451 } 452 453 ret = -ENOMEM; 454 s->s_root = d_make_root(root); 455 if (!s->s_root) 456 goto out2; 457 458 ret = -EINVAL; 459 errmsg = qnx6_checkroot(s); 460 if (errmsg != NULL) { 461 if (!silent) 462 pr_err("%s\n", errmsg); 463 goto out3; 464 } 465 return 0; 466 467 out3: 468 dput(s->s_root); 469 s->s_root = NULL; 470 out2: 471 iput(sbi->longfile); 472 out1: 473 iput(sbi->inodes); 474 out: 475 if (bh1) 476 brelse(bh1); 477 if (bh2) 478 brelse(bh2); 479 outnobh: 480 kfree(qs); 481 s->s_fs_info = NULL; 482 return ret; 483 } 484 485 static void qnx6_put_super(struct super_block *sb) 486 { 487 struct qnx6_sb_info *qs = QNX6_SB(sb); 488 brelse(qs->sb_buf); 489 iput(qs->longfile); 490 iput(qs->inodes); 491 kfree(qs); 492 sb->s_fs_info = NULL; 493 return; 494 } 495 496 static sector_t qnx6_bmap(struct address_space *mapping, sector_t block) 497 { 498 return generic_block_bmap(mapping, block, qnx6_get_block); 499 } 500 static const struct address_space_operations qnx6_aops = { 501 .readpage = qnx6_readpage, 502 .readpages = qnx6_readpages, 503 .bmap = qnx6_bmap 504 }; 505 506 static struct inode *qnx6_private_inode(struct super_block *s, 507 struct qnx6_root_node *p) 508 { 509 struct inode *inode = new_inode(s); 510 if (inode) { 511 struct qnx6_inode_info *ei = QNX6_I(inode); 512 struct qnx6_sb_info *sbi = QNX6_SB(s); 513 inode->i_size = fs64_to_cpu(sbi, p->size); 514 memcpy(ei->di_block_ptr, p->ptr, sizeof(p->ptr)); 515 ei->di_filelevels = p->levels; 516 inode->i_mode = S_IFREG | S_IRUSR; /* probably wrong */ 517 inode->i_mapping->a_ops = &qnx6_aops; 518 } 519 return inode; 520 } 521 522 struct inode *qnx6_iget(struct super_block *sb, unsigned ino) 523 { 524 struct qnx6_sb_info *sbi = QNX6_SB(sb); 525 struct qnx6_inode_entry *raw_inode; 526 struct inode *inode; 527 struct qnx6_inode_info *ei; 528 struct address_space *mapping; 529 struct page *page; 530 u32 n, offs; 531 532 inode = iget_locked(sb, ino); 533 if (!inode) 534 return ERR_PTR(-ENOMEM); 535 if (!(inode->i_state & I_NEW)) 536 return inode; 537 538 ei = QNX6_I(inode); 539 540 inode->i_mode = 0; 541 542 if (ino == 0) { 543 pr_err("bad inode number on dev %s: %u is out of range\n", 544 sb->s_id, ino); 545 iget_failed(inode); 546 return ERR_PTR(-EIO); 547 } 548 n = (ino - 1) >> (PAGE_SHIFT - QNX6_INODE_SIZE_BITS); 549 offs = (ino - 1) & (~PAGE_MASK >> QNX6_INODE_SIZE_BITS); 550 mapping = sbi->inodes->i_mapping; 551 page = read_mapping_page(mapping, n, NULL); 552 if (IS_ERR(page)) { 553 pr_err("major problem: unable to read inode from dev %s\n", 554 sb->s_id); 555 iget_failed(inode); 556 return ERR_CAST(page); 557 } 558 kmap(page); 559 raw_inode = ((struct qnx6_inode_entry *)page_address(page)) + offs; 560 561 inode->i_mode = fs16_to_cpu(sbi, raw_inode->di_mode); 562 i_uid_write(inode, (uid_t)fs32_to_cpu(sbi, raw_inode->di_uid)); 563 i_gid_write(inode, (gid_t)fs32_to_cpu(sbi, raw_inode->di_gid)); 564 inode->i_size = fs64_to_cpu(sbi, raw_inode->di_size); 565 inode->i_mtime.tv_sec = fs32_to_cpu(sbi, raw_inode->di_mtime); 566 inode->i_mtime.tv_nsec = 0; 567 inode->i_atime.tv_sec = fs32_to_cpu(sbi, raw_inode->di_atime); 568 inode->i_atime.tv_nsec = 0; 569 inode->i_ctime.tv_sec = fs32_to_cpu(sbi, raw_inode->di_ctime); 570 inode->i_ctime.tv_nsec = 0; 571 572 /* calc blocks based on 512 byte blocksize */ 573 inode->i_blocks = (inode->i_size + 511) >> 9; 574 575 memcpy(&ei->di_block_ptr, &raw_inode->di_block_ptr, 576 sizeof(raw_inode->di_block_ptr)); 577 ei->di_filelevels = raw_inode->di_filelevels; 578 579 if (S_ISREG(inode->i_mode)) { 580 inode->i_fop = &generic_ro_fops; 581 inode->i_mapping->a_ops = &qnx6_aops; 582 } else if (S_ISDIR(inode->i_mode)) { 583 inode->i_op = &qnx6_dir_inode_operations; 584 inode->i_fop = &qnx6_dir_operations; 585 inode->i_mapping->a_ops = &qnx6_aops; 586 } else if (S_ISLNK(inode->i_mode)) { 587 inode->i_op = &page_symlink_inode_operations; 588 inode_nohighmem(inode); 589 inode->i_mapping->a_ops = &qnx6_aops; 590 } else 591 init_special_inode(inode, inode->i_mode, 0); 592 qnx6_put_page(page); 593 unlock_new_inode(inode); 594 return inode; 595 } 596 597 static struct kmem_cache *qnx6_inode_cachep; 598 599 static struct inode *qnx6_alloc_inode(struct super_block *sb) 600 { 601 struct qnx6_inode_info *ei; 602 ei = kmem_cache_alloc(qnx6_inode_cachep, GFP_KERNEL); 603 if (!ei) 604 return NULL; 605 return &ei->vfs_inode; 606 } 607 608 static void qnx6_free_inode(struct inode *inode) 609 { 610 kmem_cache_free(qnx6_inode_cachep, QNX6_I(inode)); 611 } 612 613 static void init_once(void *foo) 614 { 615 struct qnx6_inode_info *ei = (struct qnx6_inode_info *) foo; 616 617 inode_init_once(&ei->vfs_inode); 618 } 619 620 static int init_inodecache(void) 621 { 622 qnx6_inode_cachep = kmem_cache_create("qnx6_inode_cache", 623 sizeof(struct qnx6_inode_info), 624 0, (SLAB_RECLAIM_ACCOUNT| 625 SLAB_MEM_SPREAD|SLAB_ACCOUNT), 626 init_once); 627 if (!qnx6_inode_cachep) 628 return -ENOMEM; 629 return 0; 630 } 631 632 static void destroy_inodecache(void) 633 { 634 /* 635 * Make sure all delayed rcu free inodes are flushed before we 636 * destroy cache. 637 */ 638 rcu_barrier(); 639 kmem_cache_destroy(qnx6_inode_cachep); 640 } 641 642 static struct dentry *qnx6_mount(struct file_system_type *fs_type, 643 int flags, const char *dev_name, void *data) 644 { 645 return mount_bdev(fs_type, flags, dev_name, data, qnx6_fill_super); 646 } 647 648 static struct file_system_type qnx6_fs_type = { 649 .owner = THIS_MODULE, 650 .name = "qnx6", 651 .mount = qnx6_mount, 652 .kill_sb = kill_block_super, 653 .fs_flags = FS_REQUIRES_DEV, 654 }; 655 MODULE_ALIAS_FS("qnx6"); 656 657 static int __init init_qnx6_fs(void) 658 { 659 int err; 660 661 err = init_inodecache(); 662 if (err) 663 return err; 664 665 err = register_filesystem(&qnx6_fs_type); 666 if (err) { 667 destroy_inodecache(); 668 return err; 669 } 670 671 pr_info("QNX6 filesystem 1.0.0 registered.\n"); 672 return 0; 673 } 674 675 static void __exit exit_qnx6_fs(void) 676 { 677 unregister_filesystem(&qnx6_fs_type); 678 destroy_inodecache(); 679 } 680 681 module_init(init_qnx6_fs) 682 module_exit(exit_qnx6_fs) 683 MODULE_LICENSE("GPL"); 684