109c434b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * QNX4 file system, Linux implementation.
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Version : 0.2.1
61da177e4SLinus Torvalds *
71da177e4SLinus Torvalds * Using parts of the xiafs filesystem.
81da177e4SLinus Torvalds *
91da177e4SLinus Torvalds * History :
101da177e4SLinus Torvalds *
111da177e4SLinus Torvalds * 01-06-1998 by Richard Frowijn : first release.
121da177e4SLinus Torvalds * 20-06-1998 by Frank Denis : Linux 2.1.99+ support, boot signature, misc.
131da177e4SLinus Torvalds * 30-06-1998 by Frank Denis : first step to write inodes.
141da177e4SLinus Torvalds */
151da177e4SLinus Torvalds
161da177e4SLinus Torvalds #include <linux/module.h>
171da177e4SLinus Torvalds #include <linux/init.h>
18964f5369SAl Viro #include <linux/slab.h>
191da177e4SLinus Torvalds #include <linux/highuid.h>
201da177e4SLinus Torvalds #include <linux/pagemap.h>
211da177e4SLinus Torvalds #include <linux/buffer_head.h>
2279d25767SAl Viro #include <linux/writeback.h>
23964f5369SAl Viro #include <linux/statfs.h>
24964f5369SAl Viro #include "qnx4.h"
251da177e4SLinus Torvalds
261da177e4SLinus Torvalds #define QNX4_VERSION 4
271da177e4SLinus Torvalds #define QNX4_BMNAME ".bitmap"
281da177e4SLinus Torvalds
29ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations qnx4_sops;
301da177e4SLinus Torvalds
311da177e4SLinus Torvalds static struct inode *qnx4_alloc_inode(struct super_block *sb);
32bc40ddd1SAl Viro static void qnx4_free_inode(struct inode *inode);
331da177e4SLinus Torvalds static int qnx4_remount(struct super_block *sb, int *flags, char *data);
34726c3342SDavid Howells static int qnx4_statfs(struct dentry *, struct kstatfs *);
351da177e4SLinus Torvalds
36ee9b6d61SJosef 'Jeff' Sipek static const struct super_operations qnx4_sops =
371da177e4SLinus Torvalds {
381da177e4SLinus Torvalds .alloc_inode = qnx4_alloc_inode,
39bc40ddd1SAl Viro .free_inode = qnx4_free_inode,
401da177e4SLinus Torvalds .statfs = qnx4_statfs,
411da177e4SLinus Torvalds .remount_fs = qnx4_remount,
421da177e4SLinus Torvalds };
431da177e4SLinus Torvalds
qnx4_remount(struct super_block * sb,int * flags,char * data)441da177e4SLinus Torvalds static int qnx4_remount(struct super_block *sb, int *flags, char *data)
451da177e4SLinus Torvalds {
461da177e4SLinus Torvalds struct qnx4_sb_info *qs;
471da177e4SLinus Torvalds
4802b9984dSTheodore Ts'o sync_filesystem(sb);
491da177e4SLinus Torvalds qs = qnx4_sb(sb);
501da177e4SLinus Torvalds qs->Version = QNX4_VERSION;
511751e8a6SLinus Torvalds *flags |= SB_RDONLY;
521da177e4SLinus Torvalds return 0;
531da177e4SLinus Torvalds }
541da177e4SLinus Torvalds
qnx4_get_block(struct inode * inode,sector_t iblock,struct buffer_head * bh,int create)551da177e4SLinus Torvalds static int qnx4_get_block( struct inode *inode, sector_t iblock, struct buffer_head *bh, int create )
561da177e4SLinus Torvalds {
571da177e4SLinus Torvalds unsigned long phys;
581da177e4SLinus Torvalds
59891ddb95SAnders Larsen QNX4DEBUG((KERN_INFO "qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode->i_ino,iblock));
601da177e4SLinus Torvalds
611da177e4SLinus Torvalds phys = qnx4_block_map( inode, iblock );
621da177e4SLinus Torvalds if ( phys ) {
631da177e4SLinus Torvalds // logical block is before EOF
641da177e4SLinus Torvalds map_bh(bh, inode->i_sb, phys);
651da177e4SLinus Torvalds }
661da177e4SLinus Torvalds return 0;
671da177e4SLinus Torvalds }
681da177e4SLinus Torvalds
try_extent(qnx4_xtnt_t * extent,u32 * offset)697cd916f6SAl Viro static inline u32 try_extent(qnx4_xtnt_t *extent, u32 *offset)
707cd916f6SAl Viro {
717cd916f6SAl Viro u32 size = le32_to_cpu(extent->xtnt_size);
727cd916f6SAl Viro if (*offset < size)
737cd916f6SAl Viro return le32_to_cpu(extent->xtnt_blk) + *offset - 1;
747cd916f6SAl Viro *offset -= size;
757cd916f6SAl Viro return 0;
767cd916f6SAl Viro }
777cd916f6SAl Viro
qnx4_block_map(struct inode * inode,long iblock)781da177e4SLinus Torvalds unsigned long qnx4_block_map( struct inode *inode, long iblock )
791da177e4SLinus Torvalds {
801da177e4SLinus Torvalds int ix;
817cd916f6SAl Viro long i_xblk;
821da177e4SLinus Torvalds struct buffer_head *bh = NULL;
831da177e4SLinus Torvalds struct qnx4_xblk *xblk = NULL;
841da177e4SLinus Torvalds struct qnx4_inode_entry *qnx4_inode = qnx4_raw_inode(inode);
8575043cb5SAlexey Dobriyan u16 nxtnt = le16_to_cpu(qnx4_inode->di_num_xtnts);
867cd916f6SAl Viro u32 offset = iblock;
877cd916f6SAl Viro u32 block = try_extent(&qnx4_inode->di_first_xtnt, &offset);
881da177e4SLinus Torvalds
897cd916f6SAl Viro if (block) {
901da177e4SLinus Torvalds // iblock is in the first extent. This is easy.
911da177e4SLinus Torvalds } else {
921da177e4SLinus Torvalds // iblock is beyond first extent. We have to follow the extent chain.
931da177e4SLinus Torvalds i_xblk = le32_to_cpu(qnx4_inode->di_xblk);
941da177e4SLinus Torvalds ix = 0;
951da177e4SLinus Torvalds while ( --nxtnt > 0 ) {
961da177e4SLinus Torvalds if ( ix == 0 ) {
971da177e4SLinus Torvalds // read next xtnt block.
981da177e4SLinus Torvalds bh = sb_bread(inode->i_sb, i_xblk - 1);
991da177e4SLinus Torvalds if ( !bh ) {
100891ddb95SAnders Larsen QNX4DEBUG((KERN_ERR "qnx4: I/O error reading xtnt block [%ld])\n", i_xblk - 1));
1011da177e4SLinus Torvalds return -EIO;
1021da177e4SLinus Torvalds }
1031da177e4SLinus Torvalds xblk = (struct qnx4_xblk*)bh->b_data;
1041da177e4SLinus Torvalds if ( memcmp( xblk->xblk_signature, "IamXblk", 7 ) ) {
105891ddb95SAnders Larsen QNX4DEBUG((KERN_ERR "qnx4: block at %ld is not a valid xtnt\n", qnx4_inode->i_xblk));
1061da177e4SLinus Torvalds return -EIO;
1071da177e4SLinus Torvalds }
1081da177e4SLinus Torvalds }
1097cd916f6SAl Viro block = try_extent(&xblk->xblk_xtnts[ix], &offset);
1107cd916f6SAl Viro if (block) {
1111da177e4SLinus Torvalds // got it!
1121da177e4SLinus Torvalds break;
1131da177e4SLinus Torvalds }
1141da177e4SLinus Torvalds if ( ++ix >= xblk->xblk_num_xtnts ) {
1151da177e4SLinus Torvalds i_xblk = le32_to_cpu(xblk->xblk_next_xblk);
1161da177e4SLinus Torvalds ix = 0;
1171da177e4SLinus Torvalds brelse( bh );
1181da177e4SLinus Torvalds bh = NULL;
1191da177e4SLinus Torvalds }
1201da177e4SLinus Torvalds }
1211da177e4SLinus Torvalds if ( bh )
1221da177e4SLinus Torvalds brelse( bh );
1231da177e4SLinus Torvalds }
1241da177e4SLinus Torvalds
125891ddb95SAnders Larsen QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block));
1261da177e4SLinus Torvalds return block;
1271da177e4SLinus Torvalds }
1281da177e4SLinus Torvalds
qnx4_statfs(struct dentry * dentry,struct kstatfs * buf)129726c3342SDavid Howells static int qnx4_statfs(struct dentry *dentry, struct kstatfs *buf)
1301da177e4SLinus Torvalds {
131726c3342SDavid Howells struct super_block *sb = dentry->d_sb;
1325b76dc06SColy Li u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
133726c3342SDavid Howells
1341da177e4SLinus Torvalds buf->f_type = sb->s_magic;
1351da177e4SLinus Torvalds buf->f_bsize = sb->s_blocksize;
1361da177e4SLinus Torvalds buf->f_blocks = le32_to_cpu(qnx4_sb(sb)->BitMap->di_size) * 8;
1371da177e4SLinus Torvalds buf->f_bfree = qnx4_count_free_blocks(sb);
1381da177e4SLinus Torvalds buf->f_bavail = buf->f_bfree;
1391da177e4SLinus Torvalds buf->f_namelen = QNX4_NAME_MAX;
1406d1349c7SAl Viro buf->f_fsid = u64_to_fsid(id);
1411da177e4SLinus Torvalds
1421da177e4SLinus Torvalds return 0;
1431da177e4SLinus Torvalds }
1441da177e4SLinus Torvalds
1451da177e4SLinus Torvalds /*
1461da177e4SLinus Torvalds * Check the root directory of the filesystem to make sure
1471da177e4SLinus Torvalds * it really _is_ a qnx4 filesystem, and to check the size
1481da177e4SLinus Torvalds * of the directory entry.
1491da177e4SLinus Torvalds */
qnx4_checkroot(struct super_block * sb,struct qnx4_super_block * s)150208adb64SAl Viro static const char *qnx4_checkroot(struct super_block *sb,
151208adb64SAl Viro struct qnx4_super_block *s)
1521da177e4SLinus Torvalds {
1531da177e4SLinus Torvalds struct buffer_head *bh;
1541da177e4SLinus Torvalds struct qnx4_inode_entry *rootdir;
1551da177e4SLinus Torvalds int rd, rl;
1561da177e4SLinus Torvalds int i, j;
1571da177e4SLinus Torvalds
158208adb64SAl Viro if (s->RootDir.di_fname[0] != '/' || s->RootDir.di_fname[1] != '\0')
1591da177e4SLinus Torvalds return "no qnx4 filesystem (no root dir).";
160891ddb95SAnders Larsen QNX4DEBUG((KERN_NOTICE "QNX4 filesystem found on dev %s.\n", sb->s_id));
161208adb64SAl Viro rd = le32_to_cpu(s->RootDir.di_first_xtnt.xtnt_blk) - 1;
162208adb64SAl Viro rl = le32_to_cpu(s->RootDir.di_first_xtnt.xtnt_size);
1631da177e4SLinus Torvalds for (j = 0; j < rl; j++) {
1641da177e4SLinus Torvalds bh = sb_bread(sb, rd + j); /* root dir, first block */
1654134bf81SAl Viro if (bh == NULL)
1661da177e4SLinus Torvalds return "unable to read root entry.";
1674134bf81SAl Viro rootdir = (struct qnx4_inode_entry *) bh->b_data;
1684134bf81SAl Viro for (i = 0; i < QNX4_INODES_PER_BLOCK; i++, rootdir++) {
169891ddb95SAnders Larsen QNX4DEBUG((KERN_INFO "rootdir entry found : [%s]\n", rootdir->di_fname));
1704134bf81SAl Viro if (strcmp(rootdir->di_fname, QNX4_BMNAME) != 0)
1714134bf81SAl Viro continue;
17267c50a7eSThomas Meyer qnx4_sb(sb)->BitMap = kmemdup(rootdir,
17367c50a7eSThomas Meyer sizeof(struct qnx4_inode_entry),
17467c50a7eSThomas Meyer GFP_KERNEL);
1751da177e4SLinus Torvalds brelse(bh);
1764134bf81SAl Viro if (!qnx4_sb(sb)->BitMap)
1771da177e4SLinus Torvalds return "not enough memory for bitmap inode";
1784134bf81SAl Viro /* keep bitmap inode known */
1794134bf81SAl Viro return NULL;
1801da177e4SLinus Torvalds }
1811da177e4SLinus Torvalds brelse(bh);
1821da177e4SLinus Torvalds }
1831da177e4SLinus Torvalds return "bitmap file not found.";
1841da177e4SLinus Torvalds }
1851da177e4SLinus Torvalds
qnx4_fill_super(struct super_block * s,void * data,int silent)1861da177e4SLinus Torvalds static int qnx4_fill_super(struct super_block *s, void *data, int silent)
1871da177e4SLinus Torvalds {
1881da177e4SLinus Torvalds struct buffer_head *bh;
1891da177e4SLinus Torvalds struct inode *root;
1901da177e4SLinus Torvalds const char *errmsg;
1911da177e4SLinus Torvalds struct qnx4_sb_info *qs;
1921da177e4SLinus Torvalds
193f8314dc6SPanagiotis Issaris qs = kzalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL);
194073c2141SArnd Bergmann if (!qs)
1951da177e4SLinus Torvalds return -ENOMEM;
1961da177e4SLinus Torvalds s->s_fs_info = qs;
1971da177e4SLinus Torvalds
1981da177e4SLinus Torvalds sb_set_blocksize(s, QNX4_BLOCK_SIZE);
1991da177e4SLinus Torvalds
200208adb64SAl Viro s->s_op = &qnx4_sops;
201208adb64SAl Viro s->s_magic = QNX4_SUPER_MAGIC;
2021751e8a6SLinus Torvalds s->s_flags |= SB_RDONLY; /* Yup, read-only yet */
20322b13969SDeepa Dinamani s->s_time_min = 0;
20422b13969SDeepa Dinamani s->s_time_max = U32_MAX;
205208adb64SAl Viro
2061da177e4SLinus Torvalds /* Check the superblock signature. Since the qnx4 code is
2071da177e4SLinus Torvalds dangerous, we should leave as quickly as possible
2081da177e4SLinus Torvalds if we don't belong here... */
2091da177e4SLinus Torvalds bh = sb_bread(s, 1);
2101da177e4SLinus Torvalds if (!bh) {
211891ddb95SAnders Larsen printk(KERN_ERR "qnx4: unable to read the superblock\n");
212208adb64SAl Viro return -EINVAL;
2131da177e4SLinus Torvalds }
2141da177e4SLinus Torvalds
2151da177e4SLinus Torvalds /* check before allocating dentries, inodes, .. */
216208adb64SAl Viro errmsg = qnx4_checkroot(s, (struct qnx4_super_block *) bh->b_data);
217208adb64SAl Viro brelse(bh);
2181da177e4SLinus Torvalds if (errmsg != NULL) {
2191da177e4SLinus Torvalds if (!silent)
220891ddb95SAnders Larsen printk(KERN_ERR "qnx4: %s\n", errmsg);
221208adb64SAl Viro return -EINVAL;
2221da177e4SLinus Torvalds }
2231da177e4SLinus Torvalds
2241da177e4SLinus Torvalds /* does root not have inode number QNX4_ROOT_INO ?? */
2252b7e5bcbSDavid Howells root = qnx4_iget(s, QNX4_ROOT_INO * QNX4_INODES_PER_BLOCK);
2262b7e5bcbSDavid Howells if (IS_ERR(root)) {
227891ddb95SAnders Larsen printk(KERN_ERR "qnx4: get inode failed\n");
228208adb64SAl Viro return PTR_ERR(root);
2291da177e4SLinus Torvalds }
2301da177e4SLinus Torvalds
23148fde701SAl Viro s->s_root = d_make_root(root);
2321da177e4SLinus Torvalds if (s->s_root == NULL)
233208adb64SAl Viro return -ENOMEM;
2341da177e4SLinus Torvalds
2351da177e4SLinus Torvalds return 0;
2361da177e4SLinus Torvalds }
2371da177e4SLinus Torvalds
qnx4_kill_sb(struct super_block * sb)238208adb64SAl Viro static void qnx4_kill_sb(struct super_block *sb)
2391da177e4SLinus Torvalds {
2401da177e4SLinus Torvalds struct qnx4_sb_info *qs = qnx4_sb(sb);
241208adb64SAl Viro kill_block_super(sb);
242208adb64SAl Viro if (qs) {
2431da177e4SLinus Torvalds kfree(qs->BitMap);
2441da177e4SLinus Torvalds kfree(qs);
245208adb64SAl Viro }
2461da177e4SLinus Torvalds }
2471da177e4SLinus Torvalds
qnx4_read_folio(struct file * file,struct folio * folio)2482c69e205SMatthew Wilcox (Oracle) static int qnx4_read_folio(struct file *file, struct folio *folio)
2491da177e4SLinus Torvalds {
2502c69e205SMatthew Wilcox (Oracle) return block_read_full_folio(folio, qnx4_get_block);
2511da177e4SLinus Torvalds }
252f8706184SNick Piggin
qnx4_bmap(struct address_space * mapping,sector_t block)2531da177e4SLinus Torvalds static sector_t qnx4_bmap(struct address_space *mapping, sector_t block)
2541da177e4SLinus Torvalds {
2551da177e4SLinus Torvalds return generic_block_bmap(mapping,block,qnx4_get_block);
2561da177e4SLinus Torvalds }
2572c69e205SMatthew Wilcox (Oracle)
258f5e54d6eSChristoph Hellwig static const struct address_space_operations qnx4_aops = {
2592c69e205SMatthew Wilcox (Oracle) .read_folio = qnx4_read_folio,
2601da177e4SLinus Torvalds .bmap = qnx4_bmap
2611da177e4SLinus Torvalds };
2621da177e4SLinus Torvalds
qnx4_iget(struct super_block * sb,unsigned long ino)2632b7e5bcbSDavid Howells struct inode *qnx4_iget(struct super_block *sb, unsigned long ino)
2641da177e4SLinus Torvalds {
2651da177e4SLinus Torvalds struct buffer_head *bh;
2661da177e4SLinus Torvalds struct qnx4_inode_entry *raw_inode;
2672b7e5bcbSDavid Howells int block;
2682b7e5bcbSDavid Howells struct qnx4_inode_entry *qnx4_inode;
2692b7e5bcbSDavid Howells struct inode *inode;
2701da177e4SLinus Torvalds
2712b7e5bcbSDavid Howells inode = iget_locked(sb, ino);
2722b7e5bcbSDavid Howells if (!inode)
2732b7e5bcbSDavid Howells return ERR_PTR(-ENOMEM);
2742b7e5bcbSDavid Howells if (!(inode->i_state & I_NEW))
2752b7e5bcbSDavid Howells return inode;
2762b7e5bcbSDavid Howells
2772b7e5bcbSDavid Howells qnx4_inode = qnx4_raw_inode(inode);
2781da177e4SLinus Torvalds inode->i_mode = 0;
2791da177e4SLinus Torvalds
280891ddb95SAnders Larsen QNX4DEBUG((KERN_INFO "reading inode : [%d]\n", ino));
2811da177e4SLinus Torvalds if (!ino) {
2822b7e5bcbSDavid Howells printk(KERN_ERR "qnx4: bad inode number on dev %s: %lu is "
2832b7e5bcbSDavid Howells "out of range\n",
2841da177e4SLinus Torvalds sb->s_id, ino);
2852b7e5bcbSDavid Howells iget_failed(inode);
2862b7e5bcbSDavid Howells return ERR_PTR(-EIO);
2871da177e4SLinus Torvalds }
2881da177e4SLinus Torvalds block = ino / QNX4_INODES_PER_BLOCK;
2891da177e4SLinus Torvalds
2901da177e4SLinus Torvalds if (!(bh = sb_bread(sb, block))) {
291891ddb95SAnders Larsen printk(KERN_ERR "qnx4: major problem: unable to read inode from dev "
2921da177e4SLinus Torvalds "%s\n", sb->s_id);
2932b7e5bcbSDavid Howells iget_failed(inode);
2942b7e5bcbSDavid Howells return ERR_PTR(-EIO);
2951da177e4SLinus Torvalds }
2961da177e4SLinus Torvalds raw_inode = ((struct qnx4_inode_entry *) bh->b_data) +
2971da177e4SLinus Torvalds (ino % QNX4_INODES_PER_BLOCK);
2981da177e4SLinus Torvalds
2991da177e4SLinus Torvalds inode->i_mode = le16_to_cpu(raw_inode->di_mode);
300511728d7SEric W. Biederman i_uid_write(inode, (uid_t)le16_to_cpu(raw_inode->di_uid));
301511728d7SEric W. Biederman i_gid_write(inode, (gid_t)le16_to_cpu(raw_inode->di_gid));
302bfe86848SMiklos Szeredi set_nlink(inode, le16_to_cpu(raw_inode->di_nlink));
3031da177e4SLinus Torvalds inode->i_size = le32_to_cpu(raw_inode->di_size);
3041da177e4SLinus Torvalds inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->di_mtime);
3051da177e4SLinus Torvalds inode->i_mtime.tv_nsec = 0;
3061da177e4SLinus Torvalds inode->i_atime.tv_sec = le32_to_cpu(raw_inode->di_atime);
3071da177e4SLinus Torvalds inode->i_atime.tv_nsec = 0;
308*bbe21298SJeff Layton inode_set_ctime(inode, le32_to_cpu(raw_inode->di_ctime), 0);
3091da177e4SLinus Torvalds inode->i_blocks = le32_to_cpu(raw_inode->di_first_xtnt.xtnt_size);
3101da177e4SLinus Torvalds
3111da177e4SLinus Torvalds memcpy(qnx4_inode, raw_inode, QNX4_DIR_ENTRY_SIZE);
3121da177e4SLinus Torvalds if (S_ISREG(inode->i_mode)) {
313945ffe54SChristoph Hellwig inode->i_fop = &generic_ro_fops;
3141da177e4SLinus Torvalds inode->i_mapping->a_ops = &qnx4_aops;
3151da177e4SLinus Torvalds qnx4_i(inode)->mmu_private = inode->i_size;
3161da177e4SLinus Torvalds } else if (S_ISDIR(inode->i_mode)) {
3171da177e4SLinus Torvalds inode->i_op = &qnx4_dir_inode_operations;
3181da177e4SLinus Torvalds inode->i_fop = &qnx4_dir_operations;
3191da177e4SLinus Torvalds } else if (S_ISLNK(inode->i_mode)) {
3201da177e4SLinus Torvalds inode->i_op = &page_symlink_inode_operations;
32121fc61c7SAl Viro inode_nohighmem(inode);
3221da177e4SLinus Torvalds inode->i_mapping->a_ops = &qnx4_aops;
3231da177e4SLinus Torvalds qnx4_i(inode)->mmu_private = inode->i_size;
3242b7e5bcbSDavid Howells } else {
3252b7e5bcbSDavid Howells printk(KERN_ERR "qnx4: bad inode %lu on dev %s\n",
3262b7e5bcbSDavid Howells ino, sb->s_id);
3272b7e5bcbSDavid Howells iget_failed(inode);
3281da177e4SLinus Torvalds brelse(bh);
3292b7e5bcbSDavid Howells return ERR_PTR(-EIO);
3302b7e5bcbSDavid Howells }
3312b7e5bcbSDavid Howells brelse(bh);
3322b7e5bcbSDavid Howells unlock_new_inode(inode);
3332b7e5bcbSDavid Howells return inode;
3341da177e4SLinus Torvalds }
3351da177e4SLinus Torvalds
336e18b890bSChristoph Lameter static struct kmem_cache *qnx4_inode_cachep;
3371da177e4SLinus Torvalds
qnx4_alloc_inode(struct super_block * sb)3381da177e4SLinus Torvalds static struct inode *qnx4_alloc_inode(struct super_block *sb)
3391da177e4SLinus Torvalds {
3401da177e4SLinus Torvalds struct qnx4_inode_info *ei;
341fd60b288SMuchun Song ei = alloc_inode_sb(sb, qnx4_inode_cachep, GFP_KERNEL);
3421da177e4SLinus Torvalds if (!ei)
3431da177e4SLinus Torvalds return NULL;
3441da177e4SLinus Torvalds return &ei->vfs_inode;
3451da177e4SLinus Torvalds }
3461da177e4SLinus Torvalds
qnx4_free_inode(struct inode * inode)347bc40ddd1SAl Viro static void qnx4_free_inode(struct inode *inode)
348fa0d7e3dSNick Piggin {
349fa0d7e3dSNick Piggin kmem_cache_free(qnx4_inode_cachep, qnx4_i(inode));
350fa0d7e3dSNick Piggin }
351fa0d7e3dSNick Piggin
init_once(void * foo)35251cc5068SAlexey Dobriyan static void init_once(void *foo)
3531da177e4SLinus Torvalds {
3541da177e4SLinus Torvalds struct qnx4_inode_info *ei = (struct qnx4_inode_info *) foo;
3551da177e4SLinus Torvalds
3561da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode);
3571da177e4SLinus Torvalds }
3581da177e4SLinus Torvalds
init_inodecache(void)3591da177e4SLinus Torvalds static int init_inodecache(void)
3601da177e4SLinus Torvalds {
3611da177e4SLinus Torvalds qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache",
3621da177e4SLinus Torvalds sizeof(struct qnx4_inode_info),
363fffb60f9SPaul Jackson 0, (SLAB_RECLAIM_ACCOUNT|
3645d097056SVladimir Davydov SLAB_MEM_SPREAD|SLAB_ACCOUNT),
36520c2df83SPaul Mundt init_once);
3661da177e4SLinus Torvalds if (qnx4_inode_cachep == NULL)
3671da177e4SLinus Torvalds return -ENOMEM;
3681da177e4SLinus Torvalds return 0;
3691da177e4SLinus Torvalds }
3701da177e4SLinus Torvalds
destroy_inodecache(void)3711da177e4SLinus Torvalds static void destroy_inodecache(void)
3721da177e4SLinus Torvalds {
3738c0a8537SKirill A. Shutemov /*
3748c0a8537SKirill A. Shutemov * Make sure all delayed rcu free inodes are flushed before we
3758c0a8537SKirill A. Shutemov * destroy cache.
3768c0a8537SKirill A. Shutemov */
3778c0a8537SKirill A. Shutemov rcu_barrier();
3781a1d92c1SAlexey Dobriyan kmem_cache_destroy(qnx4_inode_cachep);
3791da177e4SLinus Torvalds }
3801da177e4SLinus Torvalds
qnx4_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)381152a0836SAl Viro static struct dentry *qnx4_mount(struct file_system_type *fs_type,
382152a0836SAl Viro int flags, const char *dev_name, void *data)
3831da177e4SLinus Torvalds {
384152a0836SAl Viro return mount_bdev(fs_type, flags, dev_name, data, qnx4_fill_super);
3851da177e4SLinus Torvalds }
3861da177e4SLinus Torvalds
3871da177e4SLinus Torvalds static struct file_system_type qnx4_fs_type = {
3881da177e4SLinus Torvalds .owner = THIS_MODULE,
3891da177e4SLinus Torvalds .name = "qnx4",
390152a0836SAl Viro .mount = qnx4_mount,
391208adb64SAl Viro .kill_sb = qnx4_kill_sb,
3921da177e4SLinus Torvalds .fs_flags = FS_REQUIRES_DEV,
3931da177e4SLinus Torvalds };
3947f78e035SEric W. Biederman MODULE_ALIAS_FS("qnx4");
3951da177e4SLinus Torvalds
init_qnx4_fs(void)3961da177e4SLinus Torvalds static int __init init_qnx4_fs(void)
3971da177e4SLinus Torvalds {
3981da177e4SLinus Torvalds int err;
3991da177e4SLinus Torvalds
4001da177e4SLinus Torvalds err = init_inodecache();
4011da177e4SLinus Torvalds if (err)
4021da177e4SLinus Torvalds return err;
4031da177e4SLinus Torvalds
4041da177e4SLinus Torvalds err = register_filesystem(&qnx4_fs_type);
4051da177e4SLinus Torvalds if (err) {
4061da177e4SLinus Torvalds destroy_inodecache();
4071da177e4SLinus Torvalds return err;
4081da177e4SLinus Torvalds }
4091da177e4SLinus Torvalds
410891ddb95SAnders Larsen printk(KERN_INFO "QNX4 filesystem 0.2.3 registered.\n");
4111da177e4SLinus Torvalds return 0;
4121da177e4SLinus Torvalds }
4131da177e4SLinus Torvalds
exit_qnx4_fs(void)4141da177e4SLinus Torvalds static void __exit exit_qnx4_fs(void)
4151da177e4SLinus Torvalds {
4161da177e4SLinus Torvalds unregister_filesystem(&qnx4_fs_type);
4171da177e4SLinus Torvalds destroy_inodecache();
4181da177e4SLinus Torvalds }
4191da177e4SLinus Torvalds
4201da177e4SLinus Torvalds module_init(init_qnx4_fs)
4211da177e4SLinus Torvalds module_exit(exit_qnx4_fs)
4221da177e4SLinus Torvalds MODULE_LICENSE("GPL");
4231da177e4SLinus Torvalds
424