linux/fs/jfs/super.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *   Copyright (C) International Business Machines Corp., 2000-2004
 *   Portions Copyright (C) Christoph Hellwig, 2001-2002
 */

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/parser.h>
#include <linux/completion.h>
#include <linux/vfs.h>
#include <linux/quotaops.h>
#include <linux/mount.h>
#include <linux/moduleparam.h>
#include <linux/kthread.h>
#include <linux/posix_acl.h>
#include <linux/buffer_head.h>
#include <linux/exportfs.h>
#include <linux/crc32.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/seq_file.h>
#include <linux/blkdev.h>

#include "jfs_incore.h"
#include "jfs_filsys.h"
#include "jfs_inode.h"
#include "jfs_metapage.h"
#include "jfs_superblock.h"
#include "jfs_dmap.h"
#include "jfs_imap.h"
#include "jfs_acl.h"
#include "jfs_debug.h"
#include "jfs_xattr.h"
#include "jfs_dinode.h"

MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;
MODULE_LICENSE(…) …;

static struct kmem_cache *jfs_inode_cachep;

static const struct super_operations jfs_super_operations;
static const struct export_operations jfs_export_operations;
static struct file_system_type jfs_fs_type;

#define MAX_COMMIT_THREADS …
static int commit_threads;
module_param(commit_threads, int, 0);
MODULE_PARM_DESC(…) …;

static struct task_struct *jfsCommitThread[MAX_COMMIT_THREADS];
struct task_struct *jfsIOthread;
struct task_struct *jfsSyncThread;

#ifdef CONFIG_JFS_DEBUG
int jfsloglevel = …;
module_param(jfsloglevel, int, 0644);
MODULE_PARM_DESC(…) …;
#endif

static void jfs_handle_error(struct super_block *sb)
{ … }

void jfs_error(struct super_block *sb, const char *fmt, ...)
{ … }

static struct inode *jfs_alloc_inode(struct super_block *sb)
{ … }

static void jfs_free_inode(struct inode *inode)
{ … }

static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{ … }

#ifdef CONFIG_QUOTA
static int jfs_quota_off(struct super_block *sb, int type);
static int jfs_quota_on(struct super_block *sb, int type, int format_id,
			const struct path *path);

static void jfs_quota_off_umount(struct super_block *sb)
{ … }

static const struct quotactl_ops jfs_quotactl_ops = …;
#else
static inline void jfs_quota_off_umount(struct super_block *sb)
{
}
#endif

static void jfs_put_super(struct super_block *sb)
{ … }

enum { … };

static const match_table_t tokens = …;

static int parse_options(char *options, struct super_block *sb, s64 *newLVSize,
			 int *flag)
{ … }

static int jfs_remount(struct super_block *sb, int *flags, char *data)
{ … }

static int jfs_fill_super(struct super_block *sb, void *data, int silent)
{ … }

static int jfs_freeze(struct super_block *sb)
{ … }

static int jfs_unfreeze(struct super_block *sb)
{ … }

static struct dentry *jfs_do_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
{ … }

static int jfs_sync_fs(struct super_block *sb, int wait)
{ … }

static int jfs_show_options(struct seq_file *seq, struct dentry *root)
{ … }

#ifdef CONFIG_QUOTA

/* Read data from quotafile - avoid pagecache and such because we cannot afford
 * acquiring the locks... As quota files are never truncated and quota code
 * itself serializes the operations (and no one else should touch the files)
 * we don't have to be afraid of races */
static ssize_t jfs_quota_read(struct super_block *sb, int type, char *data,
			      size_t len, loff_t off)
{ … }

/* Write to quotafile */
static ssize_t jfs_quota_write(struct super_block *sb, int type,
			       const char *data, size_t len, loff_t off)
{ … }

static struct dquot __rcu **jfs_get_dquots(struct inode *inode)
{ … }

static int jfs_quota_on(struct super_block *sb, int type, int format_id,
			const struct path *path)
{ … }

static int jfs_quota_off(struct super_block *sb, int type)
{ … }
#endif

static const struct super_operations jfs_super_operations = …;

static const struct export_operations jfs_export_operations = …;

static struct file_system_type jfs_fs_type = …;
MODULE_ALIAS_FS(…) …;

static void init_once(void *foo)
{ … }

static int __init init_jfs_fs(void)
{ … }

static void __exit exit_jfs_fs(void)
{ … }

module_init(…) …
module_exit(…)