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