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

source code of linux/fs/qnx6/inode.c