Linux Audio

Check our new training course

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