linux/fs/orangefs/super.c

// SPDX-License-Identifier: GPL-2.0
/*
 * (C) 2001 Clemson University and The University of Chicago
 *
 * See COPYING in top-level directory.
 */

#include "protocol.h"
#include "orangefs-kernel.h"
#include "orangefs-bufmap.h"

#include <linux/parser.h>
#include <linux/hashtable.h>
#include <linux/seq_file.h>

/* a cache for orangefs-inode objects (i.e. orangefs inode private data) */
static struct kmem_cache *orangefs_inode_cache;

/* list for storing orangefs specific superblocks in use */
LIST_HEAD(…);

DEFINE_SPINLOCK(…);

enum { … };

static const match_table_t tokens = …;

uint64_t orangefs_features;

static int orangefs_show_options(struct seq_file *m, struct dentry *root)
{ … }

static int parse_mount_options(struct super_block *sb, char *options,
		int silent)
{ … }

static void orangefs_inode_cache_ctor(void *req)
{ … }

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

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

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

static int orangefs_write_inode(struct inode *inode,
				struct writeback_control *wbc)
{ … }

/*
 * NOTE: information filled in here is typically reflected in the
 * output of the system command 'df'
*/
static int orangefs_statfs(struct dentry *dentry, struct kstatfs *buf)
{ … }

/*
 * Remount as initiated by VFS layer.  We just need to reparse the mount
 * options, no need to signal pvfs2-client-core about it.
 */
static int orangefs_remount_fs(struct super_block *sb, int *flags, char *data)
{ … }

/*
 * Remount as initiated by pvfs2-client-core on restart.  This is used to
 * repopulate mount information left from previous pvfs2-client-core.
 *
 * the idea here is that given a valid superblock, we're
 * re-initializing the user space client with the initial mount
 * information specified when the super block was first initialized.
 * this is very different than the first initialization/creation of a
 * superblock.  we use the special service_priority_operation to make
 * sure that the mount gets ahead of any other pending operation that
 * is waiting for servicing.  this means that the pvfs2-client won't
 * fail to start several times for all other pending operations before
 * the client regains all of the mount information from us.
 * NOTE: this function assumes that the request_mutex is already acquired!
 */
int orangefs_remount(struct orangefs_sb_info_s *orangefs_sb)
{ … }

int fsid_key_table_initialize(void)
{ … }

void fsid_key_table_finalize(void)
{ … }

static const struct super_operations orangefs_s_ops = …;

static struct dentry *orangefs_fh_to_dentry(struct super_block *sb,
				  struct fid *fid,
				  int fh_len,
				  int fh_type)
{ … }

static int orangefs_encode_fh(struct inode *inode,
		    __u32 *fh,
		    int *max_len,
		    struct inode *parent)
{ … }

static const struct export_operations orangefs_export_ops = …;

static int orangefs_unmount(int id, __s32 fs_id, const char *devname)
{ … }

static int orangefs_fill_sb(struct super_block *sb,
		struct orangefs_fs_mount_response *fs_mount,
		void *data, int silent)
{ … }

struct dentry *orangefs_mount(struct file_system_type *fst,
			   int flags,
			   const char *devname,
			   void *data)
{ … }

void orangefs_kill_sb(struct super_block *sb)
{ … }

int orangefs_inode_cache_initialize(void)
{ … }

int orangefs_inode_cache_finalize(void)
{ … }