cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

orangefs-mod.c (6010B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * (C) 2001 Clemson University and The University of Chicago
      4 *
      5 * Changes by Acxiom Corporation to add proc file handler for pvfs2 client
      6 * parameters, Copyright Acxiom Corporation, 2005.
      7 *
      8 * See COPYING in top-level directory.
      9 */
     10
     11#include "protocol.h"
     12#include "orangefs-kernel.h"
     13#include "orangefs-debugfs.h"
     14#include "orangefs-sysfs.h"
     15
     16/* ORANGEFS_VERSION is a ./configure define */
     17#ifndef ORANGEFS_VERSION
     18#define ORANGEFS_VERSION "upstream"
     19#endif
     20
     21/*
     22 * global variables declared here
     23 */
     24
     25struct orangefs_stats orangefs_stats;
     26
     27/* the size of the hash tables for ops in progress */
     28int hash_table_size = 509;
     29
     30static ulong module_parm_debug_mask;
     31__u64 orangefs_gossip_debug_mask;
     32int op_timeout_secs = ORANGEFS_DEFAULT_OP_TIMEOUT_SECS;
     33int slot_timeout_secs = ORANGEFS_DEFAULT_SLOT_TIMEOUT_SECS;
     34int orangefs_cache_timeout_msecs = 500;
     35int orangefs_dcache_timeout_msecs = 50;
     36int orangefs_getattr_timeout_msecs = 50;
     37
     38MODULE_LICENSE("GPL");
     39MODULE_AUTHOR("ORANGEFS Development Team");
     40MODULE_DESCRIPTION("The Linux Kernel VFS interface to ORANGEFS");
     41MODULE_PARM_DESC(module_parm_debug_mask, "debugging level (see orangefs-debug.h for values)");
     42MODULE_PARM_DESC(op_timeout_secs, "Operation timeout in seconds");
     43MODULE_PARM_DESC(slot_timeout_secs, "Slot timeout in seconds");
     44MODULE_PARM_DESC(hash_table_size,
     45		 "size of hash table for operations in progress");
     46
     47static struct file_system_type orangefs_fs_type = {
     48	.name = "pvfs2",
     49	.mount = orangefs_mount,
     50	.kill_sb = orangefs_kill_sb,
     51	.owner = THIS_MODULE,
     52};
     53
     54module_param(hash_table_size, int, 0);
     55module_param(module_parm_debug_mask, ulong, 0644);
     56module_param(op_timeout_secs, int, 0);
     57module_param(slot_timeout_secs, int, 0);
     58
     59/*
     60 * Blocks non-priority requests from being queued for servicing.  This
     61 * could be used for protecting the request list data structure, but
     62 * for now it's only being used to stall the op addition to the request
     63 * list
     64 */
     65DEFINE_MUTEX(orangefs_request_mutex);
     66
     67/* hash table for storing operations waiting for matching downcall */
     68struct list_head *orangefs_htable_ops_in_progress;
     69DEFINE_SPINLOCK(orangefs_htable_ops_in_progress_lock);
     70
     71/* list for queueing upcall operations */
     72LIST_HEAD(orangefs_request_list);
     73
     74/* used to protect the above orangefs_request_list */
     75DEFINE_SPINLOCK(orangefs_request_list_lock);
     76
     77/* used for incoming request notification */
     78DECLARE_WAIT_QUEUE_HEAD(orangefs_request_list_waitq);
     79
     80static int __init orangefs_init(void)
     81{
     82	int ret;
     83	__u32 i = 0;
     84
     85	if (op_timeout_secs < 0)
     86		op_timeout_secs = 0;
     87
     88	if (slot_timeout_secs < 0)
     89		slot_timeout_secs = 0;
     90
     91	/* initialize global book keeping data structures */
     92	ret = op_cache_initialize();
     93	if (ret < 0)
     94		goto out;
     95
     96	ret = orangefs_inode_cache_initialize();
     97	if (ret < 0)
     98		goto cleanup_op;
     99
    100	orangefs_htable_ops_in_progress =
    101	    kcalloc(hash_table_size, sizeof(struct list_head), GFP_KERNEL);
    102	if (!orangefs_htable_ops_in_progress) {
    103		ret = -ENOMEM;
    104		goto cleanup_inode;
    105	}
    106
    107	/* initialize a doubly linked at each hash table index */
    108	for (i = 0; i < hash_table_size; i++)
    109		INIT_LIST_HEAD(&orangefs_htable_ops_in_progress[i]);
    110
    111	ret = fsid_key_table_initialize();
    112	if (ret < 0)
    113		goto cleanup_progress_table;
    114
    115	/*
    116	 * Build the contents of /sys/kernel/debug/orangefs/debug-help
    117	 * from the keywords in the kernel keyword/mask array.
    118	 *
    119	 * The keywords in the client keyword/mask array are
    120	 * unknown at boot time.
    121	 *
    122	 * orangefs_prepare_debugfs_help_string will be used again
    123	 * later to rebuild the debug-help-string after the client starts
    124	 * and passes along the needed info. The argument signifies
    125	 * which time orangefs_prepare_debugfs_help_string is being
    126	 * called.
    127	 */
    128	ret = orangefs_prepare_debugfs_help_string(1);
    129	if (ret)
    130		goto cleanup_key_table;
    131
    132	orangefs_debugfs_init(module_parm_debug_mask);
    133
    134	ret = orangefs_sysfs_init();
    135	if (ret)
    136		goto sysfs_init_failed;
    137
    138	/* Initialize the orangefsdev subsystem. */
    139	ret = orangefs_dev_init();
    140	if (ret < 0) {
    141		gossip_err("%s: could not initialize device subsystem %d!\n",
    142			   __func__,
    143			   ret);
    144		goto cleanup_device;
    145	}
    146
    147	ret = register_filesystem(&orangefs_fs_type);
    148	if (ret == 0) {
    149		pr_info("%s: module version %s loaded\n",
    150			__func__,
    151			ORANGEFS_VERSION);
    152		goto out;
    153	}
    154
    155	orangefs_sysfs_exit();
    156
    157cleanup_device:
    158	orangefs_dev_cleanup();
    159
    160sysfs_init_failed:
    161	orangefs_debugfs_cleanup();
    162
    163cleanup_key_table:
    164	fsid_key_table_finalize();
    165
    166cleanup_progress_table:
    167	kfree(orangefs_htable_ops_in_progress);
    168
    169cleanup_inode:
    170	orangefs_inode_cache_finalize();
    171
    172cleanup_op:
    173	op_cache_finalize();
    174
    175out:
    176	return ret;
    177}
    178
    179static void __exit orangefs_exit(void)
    180{
    181	int i = 0;
    182	gossip_debug(GOSSIP_INIT_DEBUG, "orangefs: orangefs_exit called\n");
    183
    184	unregister_filesystem(&orangefs_fs_type);
    185	orangefs_debugfs_cleanup();
    186	orangefs_sysfs_exit();
    187	fsid_key_table_finalize();
    188	orangefs_dev_cleanup();
    189	BUG_ON(!list_empty(&orangefs_request_list));
    190	for (i = 0; i < hash_table_size; i++)
    191		BUG_ON(!list_empty(&orangefs_htable_ops_in_progress[i]));
    192
    193	orangefs_inode_cache_finalize();
    194	op_cache_finalize();
    195
    196	kfree(orangefs_htable_ops_in_progress);
    197
    198	pr_info("orangefs: module version %s unloaded\n", ORANGEFS_VERSION);
    199}
    200
    201/*
    202 * What we do in this function is to walk the list of operations
    203 * that are in progress in the hash table and mark them as purged as well.
    204 */
    205void purge_inprogress_ops(void)
    206{
    207	int i;
    208
    209	for (i = 0; i < hash_table_size; i++) {
    210		struct orangefs_kernel_op_s *op;
    211		struct orangefs_kernel_op_s *next;
    212
    213		spin_lock(&orangefs_htable_ops_in_progress_lock);
    214		list_for_each_entry_safe(op,
    215					 next,
    216					 &orangefs_htable_ops_in_progress[i],
    217					 list) {
    218			set_op_state_purged(op);
    219			gossip_debug(GOSSIP_DEV_DEBUG,
    220				     "%s: op:%s: op_state:%d: process:%s:\n",
    221				     __func__,
    222				     get_opname_string(op),
    223				     op->op_state,
    224				     current->comm);
    225		}
    226		spin_unlock(&orangefs_htable_ops_in_progress_lock);
    227	}
    228}
    229
    230module_init(orangefs_init);
    231module_exit(orangefs_exit);