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/seq_file.h> 23 #include <linux/crc32.h> 24 #include <linux/mpage.h> 25 #include <linux/fs_parser.h> 26 #include <linux/fs_context.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_reconfigure(struct fs_context *fc); 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 .show_options = qnx6_show_options, 44 }; 45 46 static int qnx6_show_options(struct seq_file *seq, struct dentry *root) 47 { 48 struct super_block *sb = root->d_sb; 49 struct qnx6_sb_info *sbi = QNX6_SB(sb); 50 51 if (sbi->s_mount_opt & QNX6_MOUNT_MMI_FS) 52 seq_puts(seq, ",mmi_fs"); 53 return 0; 54 } 55 56 static int qnx6_reconfigure(struct fs_context *fc) 57 { 58 struct super_block *sb = fc->root->d_sb; 59 60 sync_filesystem(sb); 61 fc->sb_flags |= SB_RDONLY; 62 return 0; 63 } 64 65 static unsigned qnx6_get_devblock(struct super_block *sb, __fs32 block) 66 { 67 struct qnx6_sb_info *sbi = QNX6_SB(sb); 68 return fs32_to_cpu(sbi, block) + sbi->s_blks_off; 69 } 70 71 static unsigned qnx6_block_map(struct inode *inode, unsigned iblock); 72 73 static int qnx6_get_block(struct inode *inode, sector_t iblock, 74 struct buffer_head *bh, int create) 75 { 76 unsigned phys; 77 78 pr_debug("qnx6_get_block inode=[%ld] iblock=[%ld]\n", 79 inode->i_ino, (unsigned long)iblock); 80 81 phys = qnx6_block_map(inode, iblock); 82 if (phys) { 83 /* logical block is before EOF */ 84 map_bh(bh, inode->i_sb, phys); 85 } 86 return 0; 87 } 88 89 static int qnx6_check_blockptr(__fs32 ptr) 90 { 91 if (ptr == ~(__fs32)0) { 92 pr_err("hit unused blockpointer.\n"); 93 return 0; 94 } 95 return 1; 96 } 97 98 static int qnx6_read_folio(struct file *file, struct folio *folio) 99 { 100 return mpage_read_folio(folio, qnx6_get_block); 101 } 102 103 static void qnx6_readahead(struct readahead_control *rac) 104 { 105 mpage_readahead(rac, 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 = u64_to_fsid(id); 171 172 return 0; 173 } 174 175 /* 176 * Check the root directory of the filesystem to make sure 177 * it really _is_ a qnx6 filesystem, and to check the size 178 * of the directory entry. 179 */ 180 static const char *qnx6_checkroot(struct super_block *s) 181 { 182 static char match_root[2][3] = {".\0\0", "..\0"}; 183 int i, error = 0; 184 struct qnx6_dir_entry *dir_entry; 185 struct inode *root = d_inode(s->s_root); 186 struct address_space *mapping = root->i_mapping; 187 struct page *page = read_mapping_page(mapping, 0, NULL); 188 if (IS_ERR(page)) 189 return "error reading root directory"; 190 kmap(page); 191 dir_entry = page_address(page); 192 for (i = 0; i < 2; i++) { 193 /* maximum 3 bytes - due to match_root limitation */ 194 if (strncmp(dir_entry[i].de_fname, match_root[i], 3)) 195 error = 1; 196 } 197 qnx6_put_page(page); 198 if (error) 199 return "error reading root directory."; 200 return NULL; 201 } 202 203 #ifdef CONFIG_QNX6FS_DEBUG 204 void qnx6_superblock_debug(struct qnx6_super_block *sb, struct super_block *s) 205 { 206 struct qnx6_sb_info *sbi = QNX6_SB(s); 207 208 pr_debug("magic: %08x\n", fs32_to_cpu(sbi, sb->sb_magic)); 209 pr_debug("checksum: %08x\n", fs32_to_cpu(sbi, sb->sb_checksum)); 210 pr_debug("serial: %llx\n", fs64_to_cpu(sbi, sb->sb_serial)); 211 pr_debug("flags: %08x\n", fs32_to_cpu(sbi, sb->sb_flags)); 212 pr_debug("blocksize: %08x\n", fs32_to_cpu(sbi, sb->sb_blocksize)); 213 pr_debug("num_inodes: %08x\n", fs32_to_cpu(sbi, sb->sb_num_inodes)); 214 pr_debug("free_inodes: %08x\n", fs32_to_cpu(sbi, sb->sb_free_inodes)); 215 pr_debug("num_blocks: %08x\n", fs32_to_cpu(sbi, sb->sb_num_blocks)); 216 pr_debug("free_blocks: %08x\n", fs32_to_cpu(sbi, sb->sb_free_blocks)); 217 pr_debug("inode_levels: %02x\n", sb->Inode.levels); 218 } 219 #endif 220 221 enum { 222 Opt_mmifs 223 }; 224 225 struct qnx6_context { 226 unsigned long s_mount_opts; 227 }; 228 229 static const struct fs_parameter_spec qnx6_param_spec[] = { 230 fsparam_flag ("mmi_fs", Opt_mmifs), 231 {} 232 }; 233 234 static int qnx6_parse_param(struct fs_context *fc, struct fs_parameter *param) 235 { 236 struct qnx6_context *ctx = fc->fs_private; 237 struct fs_parse_result result; 238 int opt; 239 240 opt = fs_parse(fc, qnx6_param_spec, param, &result); 241 if (opt < 0) 242 return opt; 243 244 switch (opt) { 245 case Opt_mmifs: 246 ctx->s_mount_opts |= QNX6_MOUNT_MMI_FS; 247 break; 248 default: 249 return -EINVAL; 250 } 251 return 0; 252 } 253 254 static struct buffer_head *qnx6_check_first_superblock(struct super_block *s, 255 int offset, int silent) 256 { 257 struct qnx6_sb_info *sbi = QNX6_SB(s); 258 struct buffer_head *bh; 259 struct qnx6_super_block *sb; 260 261 /* Check the superblock signatures 262 start with the first superblock */ 263 bh = sb_bread(s, offset); 264 if (!bh) { 265 pr_err("unable to read the first superblock\n"); 266 return NULL; 267 } 268 sb = (struct qnx6_super_block *)bh->b_data; 269 if (fs32_to_cpu(sbi, sb->sb_magic) != QNX6_SUPER_MAGIC) { 270 sbi->s_bytesex = BYTESEX_BE; 271 if (fs32_to_cpu(sbi, sb->sb_magic) == QNX6_SUPER_MAGIC) { 272 /* we got a big endian fs */ 273 pr_debug("fs got different endianness.\n"); 274 return bh; 275 } else 276 sbi->s_bytesex = BYTESEX_LE; 277 if (!silent) { 278 if (offset == 0) { 279 pr_err("wrong signature (magic) in superblock #1.\n"); 280 } else { 281 pr_info("wrong signature (magic) at position (0x%lx) - will try alternative position (0x0000).\n", 282 offset * s->s_blocksize); 283 } 284 } 285 brelse(bh); 286 return NULL; 287 } 288 return bh; 289 } 290 291 static struct inode *qnx6_private_inode(struct super_block *s, 292 struct qnx6_root_node *p); 293 294 static int qnx6_fill_super(struct super_block *s, struct fs_context *fc) 295 { 296 struct buffer_head *bh1 = NULL, *bh2 = NULL; 297 struct qnx6_super_block *sb1 = NULL, *sb2 = NULL; 298 struct qnx6_sb_info *sbi; 299 struct qnx6_context *ctx = fc->fs_private; 300 struct inode *root; 301 const char *errmsg; 302 struct qnx6_sb_info *qs; 303 int ret = -EINVAL; 304 u64 offset; 305 int bootblock_offset = QNX6_BOOTBLOCK_SIZE; 306 int silent = fc->sb_flags & SB_SILENT; 307 308 qs = kzalloc(sizeof(struct qnx6_sb_info), GFP_KERNEL); 309 if (!qs) 310 return -ENOMEM; 311 s->s_fs_info = qs; 312 qs->s_mount_opt = ctx->s_mount_opts; 313 314 /* Superblock always is 512 Byte long */ 315 if (!sb_set_blocksize(s, QNX6_SUPERBLOCK_SIZE)) { 316 pr_err("unable to set blocksize\n"); 317 goto outnobh; 318 } 319 320 if (qs->s_mount_opt == QNX6_MOUNT_MMI_FS) { 321 sb1 = qnx6_mmi_fill_super(s, silent); 322 if (sb1) 323 goto mmi_success; 324 else 325 goto outnobh; 326 } 327 sbi = QNX6_SB(s); 328 sbi->s_bytesex = BYTESEX_LE; 329 /* Check the superblock signatures 330 start with the first superblock */ 331 bh1 = qnx6_check_first_superblock(s, 332 bootblock_offset / QNX6_SUPERBLOCK_SIZE, silent); 333 if (!bh1) { 334 /* try again without bootblock offset */ 335 bh1 = qnx6_check_first_superblock(s, 0, silent); 336 if (!bh1) { 337 pr_err("unable to read the first superblock\n"); 338 goto outnobh; 339 } 340 /* seems that no bootblock at partition start */ 341 bootblock_offset = 0; 342 } 343 sb1 = (struct qnx6_super_block *)bh1->b_data; 344 345 #ifdef CONFIG_QNX6FS_DEBUG 346 qnx6_superblock_debug(sb1, s); 347 #endif 348 349 /* checksum check - start at byte 8 and end at byte 512 */ 350 if (fs32_to_cpu(sbi, sb1->sb_checksum) != 351 crc32_be(0, (char *)(bh1->b_data + 8), 504)) { 352 pr_err("superblock #1 checksum error\n"); 353 goto out; 354 } 355 356 /* set new blocksize */ 357 if (!sb_set_blocksize(s, fs32_to_cpu(sbi, sb1->sb_blocksize))) { 358 pr_err("unable to set blocksize\n"); 359 goto out; 360 } 361 /* blocksize invalidates bh - pull it back in */ 362 brelse(bh1); 363 bh1 = sb_bread(s, bootblock_offset >> s->s_blocksize_bits); 364 if (!bh1) 365 goto outnobh; 366 sb1 = (struct qnx6_super_block *)bh1->b_data; 367 368 /* calculate second superblock blocknumber */ 369 offset = fs32_to_cpu(sbi, sb1->sb_num_blocks) + 370 (bootblock_offset >> s->s_blocksize_bits) + 371 (QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits); 372 373 /* set bootblock offset */ 374 sbi->s_blks_off = (bootblock_offset >> s->s_blocksize_bits) + 375 (QNX6_SUPERBLOCK_AREA >> s->s_blocksize_bits); 376 377 /* next the second superblock */ 378 bh2 = sb_bread(s, offset); 379 if (!bh2) { 380 pr_err("unable to read the second superblock\n"); 381 goto out; 382 } 383 sb2 = (struct qnx6_super_block *)bh2->b_data; 384 if (fs32_to_cpu(sbi, sb2->sb_magic) != QNX6_SUPER_MAGIC) { 385 if (!silent) 386 pr_err("wrong signature (magic) in superblock #2.\n"); 387 goto out; 388 } 389 390 /* checksum check - start at byte 8 and end at byte 512 */ 391 if (fs32_to_cpu(sbi, sb2->sb_checksum) != 392 crc32_be(0, (char *)(bh2->b_data + 8), 504)) { 393 pr_err("superblock #2 checksum error\n"); 394 goto out; 395 } 396 397 if (fs64_to_cpu(sbi, sb1->sb_serial) >= 398 fs64_to_cpu(sbi, sb2->sb_serial)) { 399 /* superblock #1 active */ 400 sbi->sb_buf = bh1; 401 sbi->sb = (struct qnx6_super_block *)bh1->b_data; 402 brelse(bh2); 403 pr_info("superblock #1 active\n"); 404 } else { 405 /* superblock #2 active */ 406 sbi->sb_buf = bh2; 407 sbi->sb = (struct qnx6_super_block *)bh2->b_data; 408 brelse(bh1); 409 pr_info("superblock #2 active\n"); 410 } 411 mmi_success: 412 /* sanity check - limit maximum indirect pointer levels */ 413 if (sb1->Inode.levels > QNX6_PTR_MAX_LEVELS) { 414 pr_err("too many inode levels (max %i, sb %i)\n", 415 QNX6_PTR_MAX_LEVELS, sb1->Inode.levels); 416 goto out; 417 } 418 if (sb1->Longfile.levels > QNX6_PTR_MAX_LEVELS) { 419 pr_err("too many longfilename levels (max %i, sb %i)\n", 420 QNX6_PTR_MAX_LEVELS, sb1->Longfile.levels); 421 goto out; 422 } 423 s->s_op = &qnx6_sops; 424 s->s_magic = QNX6_SUPER_MAGIC; 425 s->s_flags |= SB_RDONLY; /* Yup, read-only yet */ 426 s->s_time_min = 0; 427 s->s_time_max = U32_MAX; 428 429 /* ease the later tree level calculations */ 430 sbi = QNX6_SB(s); 431 sbi->s_ptrbits = ilog2(s->s_blocksize / 4); 432 sbi->inodes = qnx6_private_inode(s, &sb1->Inode); 433 if (!sbi->inodes) 434 goto out; 435 sbi->longfile = qnx6_private_inode(s, &sb1->Longfile); 436 if (!sbi->longfile) 437 goto out1; 438 439 /* prefetch root inode */ 440 root = qnx6_iget(s, QNX6_ROOT_INO); 441 if (IS_ERR(root)) { 442 pr_err("get inode failed\n"); 443 ret = PTR_ERR(root); 444 goto out2; 445 } 446 447 ret = -ENOMEM; 448 s->s_root = d_make_root(root); 449 if (!s->s_root) 450 goto out2; 451 452 ret = -EINVAL; 453 errmsg = qnx6_checkroot(s); 454 if (errmsg != NULL) { 455 if (!silent) 456 pr_err("%s\n", errmsg); 457 goto out3; 458 } 459 return 0; 460 461 out3: 462 dput(s->s_root); 463 s->s_root = NULL; 464 out2: 465 iput(sbi->longfile); 466 out1: 467 iput(sbi->inodes); 468 out: 469 brelse(bh1); 470 brelse(bh2); 471 outnobh: 472 kfree(qs); 473 s->s_fs_info = NULL; 474 return ret; 475 } 476 477 static void qnx6_put_super(struct super_block *sb) 478 { 479 struct qnx6_sb_info *qs = QNX6_SB(sb); 480 brelse(qs->sb_buf); 481 iput(qs->longfile); 482 iput(qs->inodes); 483 kfree(qs); 484 sb->s_fs_info = NULL; 485 return; 486 } 487 488 static sector_t qnx6_bmap(struct address_space *mapping, sector_t block) 489 { 490 return generic_block_bmap(mapping, block, qnx6_get_block); 491 } 492 static const struct address_space_operations qnx6_aops = { 493 .read_folio = qnx6_read_folio, 494 .readahead = qnx6_readahead, 495 .bmap = qnx6_bmap 496 }; 497 498 static struct inode *qnx6_private_inode(struct super_block *s, 499 struct qnx6_root_node *p) 500 { 501 struct inode *inode = new_inode(s); 502 if (inode) { 503 struct qnx6_inode_info *ei = QNX6_I(inode); 504 struct qnx6_sb_info *sbi = QNX6_SB(s); 505 inode->i_size = fs64_to_cpu(sbi, p->size); 506 memcpy(ei->di_block_ptr, p->ptr, sizeof(p->ptr)); 507 ei->di_filelevels = p->levels; 508 inode->i_mode = S_IFREG | S_IRUSR; /* probably wrong */ 509 inode->i_mapping->a_ops = &qnx6_aops; 510 } 511 return inode; 512 } 513 514 struct inode *qnx6_iget(struct super_block *sb, unsigned ino) 515 { 516 struct qnx6_sb_info *sbi = QNX6_SB(sb); 517 struct qnx6_inode_entry *raw_inode; 518 struct inode *inode; 519 struct qnx6_inode_info *ei; 520 struct address_space *mapping; 521 struct page *page; 522 u32 n, offs; 523 524 inode = iget_locked(sb, ino); 525 if (!inode) 526 return ERR_PTR(-ENOMEM); 527 if (!(inode->i_state & I_NEW)) 528 return inode; 529 530 ei = QNX6_I(inode); 531 532 inode->i_mode = 0; 533 534 if (ino == 0) { 535 pr_err("bad inode number on dev %s: %u is out of range\n", 536 sb->s_id, ino); 537 iget_failed(inode); 538 return ERR_PTR(-EIO); 539 } 540 n = (ino - 1) >> (PAGE_SHIFT - QNX6_INODE_SIZE_BITS); 541 offs = (ino - 1) & (~PAGE_MASK >> QNX6_INODE_SIZE_BITS); 542 mapping = sbi->inodes->i_mapping; 543 page = read_mapping_page(mapping, n, NULL); 544 if (IS_ERR(page)) { 545 pr_err("major problem: unable to read inode from dev %s\n", 546 sb->s_id); 547 iget_failed(inode); 548 return ERR_CAST(page); 549 } 550 kmap(page); 551 raw_inode = ((struct qnx6_inode_entry *)page_address(page)) + offs; 552 553 inode->i_mode = fs16_to_cpu(sbi, raw_inode->di_mode); 554 i_uid_write(inode, (uid_t)fs32_to_cpu(sbi, raw_inode->di_uid)); 555 i_gid_write(inode, (gid_t)fs32_to_cpu(sbi, raw_inode->di_gid)); 556 inode->i_size = fs64_to_cpu(sbi, raw_inode->di_size); 557 inode_set_mtime(inode, fs32_to_cpu(sbi, raw_inode->di_mtime), 0); 558 inode_set_atime(inode, fs32_to_cpu(sbi, raw_inode->di_atime), 0); 559 inode_set_ctime(inode, fs32_to_cpu(sbi, raw_inode->di_ctime), 0); 560 561 /* calc blocks based on 512 byte blocksize */ 562 inode->i_blocks = (inode->i_size + 511) >> 9; 563 564 memcpy(&ei->di_block_ptr, &raw_inode->di_block_ptr, 565 sizeof(raw_inode->di_block_ptr)); 566 ei->di_filelevels = raw_inode->di_filelevels; 567 568 if (S_ISREG(inode->i_mode)) { 569 inode->i_fop = &generic_ro_fops; 570 inode->i_mapping->a_ops = &qnx6_aops; 571 } else if (S_ISDIR(inode->i_mode)) { 572 inode->i_op = &qnx6_dir_inode_operations; 573 inode->i_fop = &qnx6_dir_operations; 574 inode->i_mapping->a_ops = &qnx6_aops; 575 } else if (S_ISLNK(inode->i_mode)) { 576 inode->i_op = &page_symlink_inode_operations; 577 inode_nohighmem(inode); 578 inode->i_mapping->a_ops = &qnx6_aops; 579 } else 580 init_special_inode(inode, inode->i_mode, 0); 581 qnx6_put_page(page); 582 unlock_new_inode(inode); 583 return inode; 584 } 585 586 static struct kmem_cache *qnx6_inode_cachep; 587 588 static struct inode *qnx6_alloc_inode(struct super_block *sb) 589 { 590 struct qnx6_inode_info *ei; 591 ei = alloc_inode_sb(sb, qnx6_inode_cachep, GFP_KERNEL); 592 if (!ei) 593 return NULL; 594 return &ei->vfs_inode; 595 } 596 597 static void qnx6_free_inode(struct inode *inode) 598 { 599 kmem_cache_free(qnx6_inode_cachep, QNX6_I(inode)); 600 } 601 602 static void init_once(void *foo) 603 { 604 struct qnx6_inode_info *ei = (struct qnx6_inode_info *) foo; 605 606 inode_init_once(&ei->vfs_inode); 607 } 608 609 static int init_inodecache(void) 610 { 611 qnx6_inode_cachep = kmem_cache_create("qnx6_inode_cache", 612 sizeof(struct qnx6_inode_info), 613 0, (SLAB_RECLAIM_ACCOUNT| 614 SLAB_ACCOUNT), 615 init_once); 616 if (!qnx6_inode_cachep) 617 return -ENOMEM; 618 return 0; 619 } 620 621 static void destroy_inodecache(void) 622 { 623 /* 624 * Make sure all delayed rcu free inodes are flushed before we 625 * destroy cache. 626 */ 627 rcu_barrier(); 628 kmem_cache_destroy(qnx6_inode_cachep); 629 } 630 631 static int qnx6_get_tree(struct fs_context *fc) 632 { 633 return get_tree_bdev(fc, qnx6_fill_super); 634 } 635 636 static void qnx6_free_fc(struct fs_context *fc) 637 { 638 kfree(fc->fs_private); 639 } 640 641 static const struct fs_context_operations qnx6_context_ops = { 642 .parse_param = qnx6_parse_param, 643 .get_tree = qnx6_get_tree, 644 .reconfigure = qnx6_reconfigure, 645 .free = qnx6_free_fc, 646 }; 647 648 static int qnx6_init_fs_context(struct fs_context *fc) 649 { 650 struct qnx6_context *ctx; 651 652 ctx = kzalloc(sizeof(struct qnx6_context), GFP_KERNEL); 653 if (!ctx) 654 return -ENOMEM; 655 fc->ops = &qnx6_context_ops; 656 fc->fs_private = ctx; 657 658 return 0; 659 } 660 661 static struct file_system_type qnx6_fs_type = { 662 .owner = THIS_MODULE, 663 .name = "qnx6", 664 .kill_sb = kill_block_super, 665 .fs_flags = FS_REQUIRES_DEV, 666 .init_fs_context = qnx6_init_fs_context, 667 .parameters = qnx6_param_spec, 668 }; 669 MODULE_ALIAS_FS("qnx6"); 670 671 static int __init init_qnx6_fs(void) 672 { 673 int err; 674 675 err = init_inodecache(); 676 if (err) 677 return err; 678 679 err = register_filesystem(&qnx6_fs_type); 680 if (err) { 681 destroy_inodecache(); 682 return err; 683 } 684 685 pr_info("QNX6 filesystem 1.0.0 registered.\n"); 686 return 0; 687 } 688 689 static void __exit exit_qnx6_fs(void) 690 { 691 unregister_filesystem(&qnx6_fs_type); 692 destroy_inodecache(); 693 } 694 695 module_init(init_qnx6_fs) 696 module_exit(exit_qnx6_fs) 697 MODULE_DESCRIPTION("QNX6 file system"); 698 MODULE_LICENSE("GPL"); 699