Skip to content

L
linux
Commit b78b1198 authored by Martin Brandenburg's avatar Martin Brandenburg
Browse files
Options

Merge branch 'misc' into for-next 

Pull in an OrangeFS branch containing miscellaneous improvements.

- clean up debugfs globals
- remove dead code in sysfs
- reorganize duplicated sysfs attribute structs
- consolidate sysfs show and store functions
- remove duplicated sysfs_ops structures
- describe organization of sysfs
- make devreq_mutex static
- g_orangefs_stats -> orangefs_stats for consistency
- rename most remaining global variables
parents f808e138 1d503617
Show whitespace changes
Inline Side-by-side
Showing with 994 additions and 1711 deletions
fs/orangefs/dcache.c
View file @ b78b1198
......@@ -73,7 +73,7 @@ static int orangefs_revalidate_lookup(struct dentry *dentry)
}
}
dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;
dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;
ret = 1;
out_release_op:
op_release(new_op);
......
fs/orangefs/devorangefs-req.c
View file @ b78b1198
......@@ -11,6 +11,7 @@
#include "orangefs-kernel.h"
#include "orangefs-dev-proto.h"
#include "orangefs-bufmap.h"
#include "orangefs-debugfs.h"
#include <linux/debugfs.h>
#include <linux/slab.h>
......@@ -21,6 +22,8 @@ uint32_t orangefs_userspace_version;
static int open_access_count;
static DEFINE_MUTEX(devreq_mutex);
#define DUMP_DEVICE_ERROR() \
do { \
gossip_err("*****************************************************\n");\
......@@ -45,7 +48,7 @@ static void orangefs_devreq_add_op(struct orangefs_kernel_op_s *op)
{
int index = hash_func(op->tag, hash_table_size);
list_add_tail(&op->list, &htable_ops_in_progress[index]);
list_add_tail(&op->list, &orangefs_htable_ops_in_progress[index]);
}
/*
......@@ -59,20 +62,20 @@ static struct orangefs_kernel_op_s *orangefs_devreq_remove_op(__u64 tag)
index = hash_func(tag, hash_table_size);
spin_lock(&htable_ops_in_progress_lock);
spin_lock(&orangefs_htable_ops_in_progress_lock);
list_for_each_entry_safe(op,
next,
&htable_ops_in_progress[index],
&orangefs_htable_ops_in_progress[index],
list) {
if (op->tag == tag && !op_state_purged(op) &&
!op_state_given_up(op)) {
list_del_init(&op->list);
spin_unlock(&htable_ops_in_progress_lock);
spin_unlock(&orangefs_htable_ops_in_progress_lock);
return op;
}
}
spin_unlock(&htable_ops_in_progress_lock);
spin_unlock(&orangefs_htable_ops_in_progress_lock);
return NULL;
}
......@@ -278,11 +281,11 @@ static ssize_t orangefs_devreq_read(struct file *file,
if (ret != 0)
goto error;
spin_lock(&htable_ops_in_progress_lock);
spin_lock(&orangefs_htable_ops_in_progress_lock);
spin_lock(&cur_op->lock);
if (unlikely(op_state_given_up(cur_op))) {
spin_unlock(&cur_op->lock);
spin_unlock(&htable_ops_in_progress_lock);
spin_unlock(&orangefs_htable_ops_in_progress_lock);
complete(&cur_op->waitq);
goto restart;
}
......@@ -300,7 +303,7 @@ static ssize_t orangefs_devreq_read(struct file *file,
current->comm);
orangefs_devreq_add_op(cur_op);
spin_unlock(&cur_op->lock);
spin_unlock(&htable_ops_in_progress_lock);
spin_unlock(&orangefs_htable_ops_in_progress_lock);
/* The client only asks to read one size buffer. */
return MAX_DEV_REQ_UPSIZE;
......@@ -586,8 +589,6 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
static __s32 max_down_size = MAX_DEV_REQ_DOWNSIZE;
struct ORANGEFS_dev_map_desc user_desc;
int ret = 0;
struct dev_mask_info_s mask_info = { 0 };
struct dev_mask2_info_s mask2_info = { 0, 0 };
int upstream_kmod = 1;
struct orangefs_sb_info_s *orangefs_sb;
......@@ -629,7 +630,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
* all of the remounts are serviced (to avoid ops between
* mounts to fail)
*/
ret = mutex_lock_interruptible(&request_mutex);
ret = mutex_lock_interruptible(&orangefs_request_mutex);
if (ret < 0)
return ret;
gossip_debug(GOSSIP_DEV_DEBUG,
......@@ -664,7 +665,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
gossip_debug(GOSSIP_DEV_DEBUG,
"%s: priority remount complete\n",
__func__);
mutex_unlock(&request_mutex);
mutex_unlock(&orangefs_request_mutex);
return ret;
case ORANGEFS_DEV_UPSTREAM:
......@@ -678,134 +679,11 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
return ret;
case ORANGEFS_DEV_CLIENT_MASK:
ret = copy_from_user(&mask2_info,
(void __user *)arg,
sizeof(struct dev_mask2_info_s));
if (ret != 0)
return -EIO;
client_debug_mask.mask1 = mask2_info.mask1_value;
client_debug_mask.mask2 = mask2_info.mask2_value;
pr_info("%s: client debug mask has been been received "
":%llx: :%llx:\n",
__func__,
(unsigned long long)client_debug_mask.mask1,
(unsigned long long)client_debug_mask.mask2);
return ret;
return orangefs_debugfs_new_client_mask((void __user *)arg);
case ORANGEFS_DEV_CLIENT_STRING:
ret = copy_from_user(&client_debug_array_string,
(void __user *)arg,
ORANGEFS_MAX_DEBUG_STRING_LEN);
/*
* The real client-core makes an effort to ensure
* that actual strings that aren't too long to fit in
* this buffer is what we get here. We're going to use
* string functions on the stuff we got, so we'll make
* this extra effort to try and keep from
* flowing out of this buffer when we use the string
* functions, even if somehow the stuff we end up
* with here is garbage.
*/
client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
'\0';
if (ret != 0) {
pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
__func__);
return -EIO;
}
pr_info("%s: client debug array string has been received.\n",
__func__);
if (!help_string_initialized) {
/* Free the "we don't know yet" default string... */
kfree(debug_help_string);
/* build a proper debug help string */
if (orangefs_prepare_debugfs_help_string(0)) {
gossip_err("%s: no debug help string \n",
__func__);
return -EIO;
}
/* Replace the boilerplate boot-time debug-help file. */
debugfs_remove(help_file_dentry);
help_file_dentry =
debugfs_create_file(
ORANGEFS_KMOD_DEBUG_HELP_FILE,
0444,
debug_dir,
debug_help_string,
&debug_help_fops);
if (!help_file_dentry) {
gossip_err("%s: debugfs_create_file failed for"
" :%s:!\n",
__func__,
ORANGEFS_KMOD_DEBUG_HELP_FILE);
return -EIO;
}
}
debug_mask_to_string(&client_debug_mask, 1);
debugfs_remove(client_debug_dentry);
orangefs_client_debug_init();
help_string_initialized++;
return ret;
return orangefs_debugfs_new_client_string((void __user *)arg);
case ORANGEFS_DEV_DEBUG:
ret = copy_from_user(&mask_info,
(void __user *)arg,
sizeof(mask_info));
if (ret != 0)
return -EIO;
if (mask_info.mask_type == KERNEL_MASK) {
if ((mask_info.mask_value == 0)
&& (kernel_mask_set_mod_init)) {
/*
* the kernel debug mask was set when the
* kernel module was loaded; don't override
* it if the client-core was started without
* a value for ORANGEFS_KMODMASK.
*/
return 0;
}
debug_mask_to_string(&mask_info.mask_value,
mask_info.mask_type);
gossip_debug_mask = mask_info.mask_value;
pr_info("%s: kernel debug mask has been modified to "
":%s: :%llx:\n",
__func__,
kernel_debug_string,
(unsigned long long)gossip_debug_mask);
} else if (mask_info.mask_type == CLIENT_MASK) {
debug_mask_to_string(&mask_info.mask_value,
mask_info.mask_type);
pr_info("%s: client debug mask has been modified to"
":%s: :%llx:\n",
__func__,
client_debug_string,
llu(mask_info.mask_value));
} else {
gossip_lerr("Invalid mask type....\n");
return -EINVAL;
}
return ret;
return orangefs_debugfs_new_debug((void __user *)arg);
default:
return -ENOIOCTLCMD;
}
......
fs/orangefs/file.c
View file @ b78b1198
......@@ -412,7 +412,7 @@ ssize_t orangefs_inode_read(struct inode *inode,
size_t bufmap_size;
ssize_t ret = -EINVAL;
g_orangefs_stats.reads++;
orangefs_stats.reads++;
bufmap_size = orangefs_bufmap_size_query();
if (count > bufmap_size) {
......@@ -453,7 +453,7 @@ static ssize_t orangefs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter
gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_read_iter\n");
g_orangefs_stats.reads++;
orangefs_stats.reads++;
rc = do_readv_writev(ORANGEFS_IO_READ, file, &pos, iter);
iocb->ki_pos = pos;
......@@ -514,7 +514,7 @@ static ssize_t orangefs_file_write_iter(struct kiocb *iocb, struct iov_iter *ite
}
iocb->ki_pos = pos;
g_orangefs_stats.writes++;
orangefs_stats.writes++;
out:
......
fs/orangefs/namei.c
View file @ b78b1198
......@@ -72,7 +72,7 @@ static int orangefs_create(struct inode *dir,
d_instantiate(dentry, inode);
unlock_new_inode(inode);
dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;
dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;
ORANGEFS_I(inode)->getattr_time = jiffies - 1;
gossip_debug(GOSSIP_NAME_DEBUG,
......@@ -183,7 +183,7 @@ static struct dentry *orangefs_lookup(struct inode *dir, struct dentry *dentry,
goto out;
}
dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;
dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;
inode = orangefs_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn);
if (IS_ERR(inode)) {
......@@ -322,7 +322,7 @@ static int orangefs_symlink(struct inode *dir,
d_instantiate(dentry, inode);
unlock_new_inode(inode);
dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;
dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;
ORANGEFS_I(inode)->getattr_time = jiffies - 1;
gossip_debug(GOSSIP_NAME_DEBUG,
......@@ -386,7 +386,7 @@ static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
d_instantiate(dentry, inode);
unlock_new_inode(inode);
dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;
dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;
ORANGEFS_I(inode)->getattr_time = jiffies - 1;
gossip_debug(GOSSIP_NAME_DEBUG,
......
fs/orangefs/orangefs-debugfs.c
View file @ b78b1198
......@@ -43,36 +43,35 @@
#include "protocol.h"
#include "orangefs-kernel.h"
static int orangefs_debug_disabled = 1;
static int orangefs_debug_help_open(struct inode *, struct file *);
#define DEBUG_HELP_STRING_SIZE 4096
#define HELP_STRING_UNINITIALIZED \
"Client Debug Keywords are unknown until the first time\n" \
"the client is started after boot.\n"
#define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help"
#define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug"
#define ORANGEFS_CLIENT_DEBUG_FILE "client-debug"
#define ORANGEFS_VERBOSE "verbose"
#define ORANGEFS_ALL "all"
const struct file_operations debug_help_fops = {
.open = orangefs_debug_help_open,
.read = seq_read,
.release = seq_release,
.llseek = seq_lseek,
/*
* An array of client_debug_mask will be built to hold debug keyword/mask
* values fetched from userspace.
*/
struct client_debug_mask {
char *keyword;
__u64 mask1;
__u64 mask2;
};
static int orangefs_kernel_debug_init(void);
static int orangefs_debug_help_open(struct inode *, struct file *);
static void *help_start(struct seq_file *, loff_t *);
static void *help_next(struct seq_file *, void *, loff_t *);
static void help_stop(struct seq_file *, void *);
static int help_show(struct seq_file *, void *);
static const struct seq_operations help_debug_ops = {
.start = help_start,
.next = help_next,
.stop = help_stop,
.show = help_show,
};
/*
* Used to protect data in ORANGEFS_KMOD_DEBUG_FILE and
* ORANGEFS_KMOD_DEBUG_FILE.
*/
static DEFINE_MUTEX(orangefs_debug_lock);
int orangefs_debug_open(struct inode *, struct file *);
static int orangefs_debug_open(struct inode *, struct file *);
static ssize_t orangefs_debug_read(struct file *,
char __user *,
......@@ -84,6 +83,43 @@ static ssize_t orangefs_debug_write(struct file *,
size_t,
loff_t *);
static int orangefs_prepare_cdm_array(char *);
static void debug_mask_to_string(void *, int);
static void do_k_string(void *, int);
static void do_c_string(void *, int);
static int keyword_is_amalgam(char *);
static int check_amalgam_keyword(void *, int);
static void debug_string_to_mask(char *, void *, int);
static void do_c_mask(int, char *, struct client_debug_mask **);
static void do_k_mask(int, char *, __u64 **);
static char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN] = "none";
static char *debug_help_string;
static char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
static char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
static struct dentry *help_file_dentry;
static struct dentry *client_debug_dentry;
static struct dentry *debug_dir;
static unsigned int kernel_mask_set_mod_init;
static int orangefs_debug_disabled = 1;
static int help_string_initialized;
static const struct seq_operations help_debug_ops = {
.start = help_start,
.next = help_next,
.stop = help_stop,
.show = help_show,
};
const struct file_operations debug_help_fops = {
.open = orangefs_debug_help_open,
.read = seq_read,
.release = seq_release,
.llseek = seq_lseek,
};
static const struct file_operations kernel_debug_fops = {
.open = orangefs_debug_open,
.read = orangefs_debug_read,
......@@ -91,15 +127,55 @@ static const struct file_operations kernel_debug_fops = {
.llseek = generic_file_llseek,
};
static int client_all_index;
static int client_verbose_index;
static struct client_debug_mask *cdm_array;
static int cdm_element_count;
static struct client_debug_mask client_debug_mask;
/*
* Used to protect data in ORANGEFS_KMOD_DEBUG_FILE and
* ORANGEFS_KMOD_DEBUG_FILE.
*/
static DEFINE_MUTEX(orangefs_debug_lock);
/*
* initialize kmod debug operations, create orangefs debugfs dir and
* ORANGEFS_KMOD_DEBUG_HELP_FILE.
*/
int orangefs_debugfs_init(void)
int orangefs_debugfs_init(int debug_mask)
{
int rc = -ENOMEM;
/* convert input debug mask to a 64-bit unsigned integer */
orangefs_gossip_debug_mask = (unsigned long long)debug_mask;
/*
* set the kernel's gossip debug string; invalid mask values will
* be ignored.
*/
debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
/* remove any invalid values from the mask */
debug_string_to_mask(kernel_debug_string, &orangefs_gossip_debug_mask,
0);
/*
* if the mask has a non-zero value, then indicate that the mask
* was set when the kernel module was loaded. The orangefs dev ioctl
* command will look at this boolean to determine if the kernel's
* debug mask should be overwritten when the client-core is started.
*/
if (orangefs_gossip_debug_mask != 0)
kernel_mask_set_mod_init = true;
pr_info("%s: called with debug mask: :%s: :%llx:\n",
__func__,
kernel_debug_string,
(unsigned long long)orangefs_gossip_debug_mask);
debug_dir = debugfs_create_dir("orangefs", NULL);
if (!debug_dir) {
pr_info("%s: debugfs_create_dir failed.\n", __func__);
......@@ -117,13 +193,58 @@ int orangefs_debugfs_init(void)
}
orangefs_debug_disabled = 0;
rc = orangefs_kernel_debug_init();
out:
return rc;
}
/*
* initialize the kernel-debug file.
*/
static int orangefs_kernel_debug_init(void)
{
int rc = -ENOMEM;
struct dentry *ret;
char *k_buffer = NULL;
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
if (!k_buffer)
goto out;
if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
strcpy(k_buffer, kernel_debug_string);
strcat(k_buffer, "\n");
} else {
strcpy(k_buffer, "none\n");
pr_info("%s: overflow 1!\n", __func__);
}
ret = debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE,
0444,
debug_dir,
k_buffer,
&kernel_debug_fops);
if (!ret) {
pr_info("%s: failed to create %s.\n",
__func__,
ORANGEFS_KMOD_DEBUG_FILE);
goto out;
}
rc = 0;
out:
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
return rc;
}
void orangefs_debugfs_cleanup(void)
{
debugfs_remove_recursive(debug_dir);
......@@ -195,49 +316,6 @@ static int help_show(struct seq_file *m, void *v)
return 0;
}
/*
* initialize the kernel-debug file.
*/
int orangefs_kernel_debug_init(void)
{
int rc = -ENOMEM;
struct dentry *ret;
char *k_buffer = NULL;
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
if (!k_buffer)
goto out;
if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
strcpy(k_buffer, kernel_debug_string);
strcat(k_buffer, "\n");
} else {
strcpy(k_buffer, "none\n");
pr_info("%s: overflow 1!\n", __func__);
}
ret = debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE,
0444,
debug_dir,
k_buffer,
&kernel_debug_fops);
if (!ret) {
pr_info("%s: failed to create %s.\n",
__func__,
ORANGEFS_KMOD_DEBUG_FILE);
goto out;
}
rc = 0;
out:
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
return rc;
}
/*
* initialize the client-debug file.
*/
......@@ -282,7 +360,7 @@ int orangefs_client_debug_init(void)
}
/* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
int orangefs_debug_open(struct inode *inode, struct file *file)
static int orangefs_debug_open(struct inode *inode, struct file *file)
{
int rc = -ENODEV;
......@@ -384,8 +462,8 @@ static ssize_t orangefs_debug_write(struct file *file,
*/
if (!strcmp(file->f_path.dentry->d_name.name,
ORANGEFS_KMOD_DEBUG_FILE)) {
debug_string_to_mask(buf, &gossip_debug_mask, 0);
debug_mask_to_string(&gossip_debug_mask, 0);
debug_string_to_mask(buf, &orangefs_gossip_debug_mask, 0);
debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
debug_string = kernel_debug_string;
gossip_debug(GOSSIP_DEBUGFS_DEBUG,
"New kernel debug string is %s\n",
......@@ -452,3 +530,546 @@ static ssize_t orangefs_debug_write(struct file *file,
kfree(buf);
return rc;
}
/*
* After obtaining a string representation of the client's debug
* keywords and their associated masks, this function is called to build an
* array of these values.
*/
static int orangefs_prepare_cdm_array(char *debug_array_string)
{
int i;
int rc = -EINVAL;
char *cds_head = NULL;
char *cds_delimiter = NULL;
int keyword_len = 0;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
/*
* figure out how many elements the cdm_array needs.
*/
for (i = 0; i < strlen(debug_array_string); i++)
if (debug_array_string[i] == '\n')
cdm_element_count++;
if (!cdm_element_count) {
pr_info("No elements in client debug array string!\n");
goto out;
}
cdm_array =
kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
GFP_KERNEL);
if (!cdm_array) {
pr_info("malloc failed for cdm_array!\n");
rc = -ENOMEM;
goto out;
}
cds_head = debug_array_string;
for (i = 0; i < cdm_element_count; i++) {
cds_delimiter = strchr(cds_head, '\n');
*cds_delimiter = '\0';
keyword_len = strcspn(cds_head, " ");
cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
if (!cdm_array[i].keyword) {
rc = -ENOMEM;
goto out;
}
sscanf(cds_head,
"%s %llx %llx",
cdm_array[i].keyword,
(unsigned long long *)&(cdm_array[i].mask1),
(unsigned long long *)&(cdm_array[i].mask2));
if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
client_verbose_index = i;
if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
client_all_index = i;
cds_head = cds_delimiter + 1;
}
rc = cdm_element_count;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
out:
return rc;
}
/*
* /sys/kernel/debug/orangefs/debug-help can be catted to
* see all the available kernel and client debug keywords.
*
* When the kernel boots, we have no idea what keywords the
* client supports, nor their associated masks.
*
* We pass through this function once at boot and stamp a
* boilerplate "we don't know" message for the client in the
* debug-help file. We pass through here again when the client
* starts and then we can fill out the debug-help file fully.
*
* The client might be restarted any number of times between
* reboots, we only build the debug-help file the first time.
*/
int orangefs_prepare_debugfs_help_string(int at_boot)
{
int rc = -EINVAL;
int i;
int byte_count = 0;
char *client_title = "Client Debug Keywords:\n";
char *kernel_title = "Kernel Debug Keywords:\n";
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
if (at_boot) {
byte_count += strlen(HELP_STRING_UNINITIALIZED);
client_title = HELP_STRING_UNINITIALIZED;
} else {
/*
* fill the client keyword/mask array and remember
* how many elements there were.
*/
cdm_element_count =
orangefs_prepare_cdm_array(client_debug_array_string);
if (cdm_element_count <= 0)
goto out;
/* Count the bytes destined for debug_help_string. */
byte_count += strlen(client_title);
for (i = 0; i < cdm_element_count; i++) {
byte_count += strlen(cdm_array[i].keyword + 2);
if (byte_count >= DEBUG_HELP_STRING_SIZE) {
pr_info("%s: overflow 1!\n", __func__);
goto out;
}
}
gossip_debug(GOSSIP_UTILS_DEBUG,
"%s: cdm_element_count:%d:\n",
__func__,
cdm_element_count);
}
byte_count += strlen(kernel_title);
for (i = 0; i < num_kmod_keyword_mask_map; i++) {
byte_count +=
strlen(s_kmod_keyword_mask_map[i].keyword + 2);
if (byte_count >= DEBUG_HELP_STRING_SIZE) {
pr_info("%s: overflow 2!\n", __func__);
goto out;
}
}
/* build debug_help_string. */
debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
if (!debug_help_string) {
rc = -ENOMEM;
goto out;
}
strcat(debug_help_string, client_title);
if (!at_boot) {
for (i = 0; i < cdm_element_count; i++) {
strcat(debug_help_string, "\t");
strcat(debug_help_string, cdm_array[i].keyword);
strcat(debug_help_string, "\n");
}
}
strcat(debug_help_string, "\n");
strcat(debug_help_string, kernel_title);
for (i = 0; i < num_kmod_keyword_mask_map; i++) {
strcat(debug_help_string, "\t");
strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword);
strcat(debug_help_string, "\n");
}
rc = 0;
out:
return rc;
}
/*
* kernel = type 0
* client = type 1
*/
static void debug_mask_to_string(void *mask, int type)
{
int i;
int len = 0;
char *debug_string;
int element_count = 0;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
if (type) {
debug_string = client_debug_string;
element_count = cdm_element_count;
} else {
debug_string = kernel_debug_string;
element_count = num_kmod_keyword_mask_map;
}
memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
/*
* Some keywords, like "all" or "verbose", are amalgams of
* numerous other keywords. Make a special check for those
* before grinding through the whole mask only to find out
* later...
*/
if (check_amalgam_keyword(mask, type))
goto out;
/* Build the debug string. */
for (i = 0; i < element_count; i++)
if (type)
do_c_string(mask, i);
else
do_k_string(mask, i);
len = strlen(debug_string);
if ((len) && (type))
client_debug_string[len - 1] = '\0';
else if (len)
kernel_debug_string[len - 1] = '\0';
else if (type)
strcpy(client_debug_string, "none");
else
strcpy(kernel_debug_string, "none");
out:
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
return;
}
static void do_k_string(void *k_mask, int index)
{
__u64 *mask = (__u64 *) k_mask;
if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
goto out;
if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
if ((strlen(kernel_debug_string) +
strlen(s_kmod_keyword_mask_map[index].keyword))
< ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
strcat(kernel_debug_string,
s_kmod_keyword_mask_map[index].keyword);
strcat(kernel_debug_string, ",");
} else {
gossip_err("%s: overflow!\n", __func__);
strcpy(kernel_debug_string, ORANGEFS_ALL);
goto out;
}
}
out:
return;
}
static void do_c_string(void *c_mask, int index)
{
struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
if (keyword_is_amalgam(cdm_array[index].keyword))
goto out;
if ((mask->mask1 & cdm_array[index].mask1) ||
(mask->mask2 & cdm_array[index].mask2)) {
if ((strlen(client_debug_string) +
strlen(cdm_array[index].keyword) + 1)
< ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
strcat(client_debug_string,
cdm_array[index].keyword);
strcat(client_debug_string, ",");
} else {
gossip_err("%s: overflow!\n", __func__);
strcpy(client_debug_string, ORANGEFS_ALL);
goto out;
}
}
out:
return;
}
static int keyword_is_amalgam(char *keyword)
{
int rc = 0;
if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
rc = 1;
return rc;
}
/*
* kernel = type 0
* client = type 1
*
* return 1 if we found an amalgam.
*/
static int check_amalgam_keyword(void *mask, int type)
{
__u64 *k_mask;
struct client_debug_mask *c_mask;
int k_all_index = num_kmod_keyword_mask_map - 1;
int rc = 0;
if (type) {
c_mask = (struct client_debug_mask *) mask;
if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
(c_mask->mask2 == cdm_array[client_all_index].mask2)) {
strcpy(client_debug_string, ORANGEFS_ALL);
rc = 1;
goto out;
}
if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
(c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
strcpy(client_debug_string, ORANGEFS_VERBOSE);
rc = 1;
goto out;
}
} else {
k_mask = (__u64 *) mask;
if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
strcpy(kernel_debug_string, ORANGEFS_ALL);
rc = 1;
goto out;
}
}
out:
return rc;
}
/*
* kernel = type 0
* client = type 1
*/
static void debug_string_to_mask(char *debug_string, void *mask, int type)
{
char *unchecked_keyword;
int i;
char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
char *original_pointer;
int element_count = 0;
struct client_debug_mask *c_mask = NULL;
__u64 *k_mask = NULL;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
if (type) {
c_mask = (struct client_debug_mask *)mask;
element_count = cdm_element_count;
} else {
k_mask = (__u64 *)mask;
*k_mask = 0;
element_count = num_kmod_keyword_mask_map;
}
original_pointer = strsep_fodder;
while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
if (strlen(unchecked_keyword)) {
for (i = 0; i < element_count; i++)
if (type)
do_c_mask(i,
unchecked_keyword,
&c_mask);
else
do_k_mask(i,
unchecked_keyword,
&k_mask);
}
kfree(original_pointer);
}
static void do_c_mask(int i, char *unchecked_keyword,
struct client_debug_mask **sane_mask)
{
if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
(**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
(**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
}
}
static void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
{
if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
**sane_mask = (**sane_mask) |
s_kmod_keyword_mask_map[i].mask_val;
}
int orangefs_debugfs_new_client_mask(void __user *arg)
{
struct dev_mask2_info_s mask2_info = {0};
int ret;
ret = copy_from_user(&mask2_info,
(void __user *)arg,
sizeof(struct dev_mask2_info_s));
if (ret != 0)
return -EIO;
client_debug_mask.mask1 = mask2_info.mask1_value;
client_debug_mask.mask2 = mask2_info.mask2_value;
pr_info("%s: client debug mask has been been received "
":%llx: :%llx:\n",
__func__,
(unsigned long long)client_debug_mask.mask1,
(unsigned long long)client_debug_mask.mask2);
return ret;
}
int orangefs_debugfs_new_client_string(void __user *arg)
{
int ret;
ret = copy_from_user(&client_debug_array_string,
(void __user *)arg,
ORANGEFS_MAX_DEBUG_STRING_LEN);
if (ret != 0)
return -EIO;
/*
* The real client-core makes an effort to ensure
* that actual strings that aren't too long to fit in
* this buffer is what we get here. We're going to use
* string functions on the stuff we got, so we'll make
* this extra effort to try and keep from
* flowing out of this buffer when we use the string
* functions, even if somehow the stuff we end up
* with here is garbage.
*/
client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
'\0';
if (ret != 0) {
pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
__func__);
return -EIO;
}
pr_info("%s: client debug array string has been received.\n",
__func__);
if (!help_string_initialized) {
/* Free the "we don't know yet" default string... */
kfree(debug_help_string);
/* build a proper debug help string */
if (orangefs_prepare_debugfs_help_string(0)) {
gossip_err("%s: no debug help string \n",
__func__);
return -EIO;
}
/* Replace the boilerplate boot-time debug-help file. */
debugfs_remove(help_file_dentry);
help_file_dentry =
debugfs_create_file(
ORANGEFS_KMOD_DEBUG_HELP_FILE,
0444,
debug_dir,
debug_help_string,
&debug_help_fops);
if (!help_file_dentry) {
gossip_err("%s: debugfs_create_file failed for"
" :%s:!\n",
__func__,
ORANGEFS_KMOD_DEBUG_HELP_FILE);
return -EIO;
}
}
debug_mask_to_string(&client_debug_mask, 1);
debugfs_remove(client_debug_dentry);
orangefs_client_debug_init();
help_string_initialized++;
return ret;
}
int orangefs_debugfs_new_debug(void __user *arg)
{
struct dev_mask_info_s mask_info = {0};
int ret;
ret = copy_from_user(&mask_info,
(void __user *)arg,
sizeof(mask_info));
if (ret != 0)
return -EIO;
if (mask_info.mask_type == KERNEL_MASK) {
if ((mask_info.mask_value == 0)
&& (kernel_mask_set_mod_init)) {
/*
* the kernel debug mask was set when the
* kernel module was loaded; don't override
* it if the client-core was started without
* a value for ORANGEFS_KMODMASK.
*/
return 0;
}
debug_mask_to_string(&mask_info.mask_value,
mask_info.mask_type);
orangefs_gossip_debug_mask = mask_info.mask_value;
pr_info("%s: kernel debug mask has been modified to "
":%s: :%llx:\n",
__func__,
kernel_debug_string,
(unsigned long long)orangefs_gossip_debug_mask);
} else if (mask_info.mask_type == CLIENT_MASK) {
debug_mask_to_string(&mask_info.mask_value,
mask_info.mask_type);
pr_info("%s: client debug mask has been modified to"
":%s: :%llx:\n",
__func__,
client_debug_string,
llu(mask_info.mask_value));
} else {
gossip_lerr("Invalid mask type....\n");
return -EINVAL;
}
return ret;
}
fs/orangefs/orangefs-debugfs.h
View file @ b78b1198
int orangefs_debugfs_init(void);
int orangefs_kernel_debug_init(void);
int orangefs_debugfs_init(int);
void orangefs_debugfs_cleanup(void);
int orangefs_client_debug_init(void);
int orangefs_prepare_debugfs_help_string(int);
int orangefs_debugfs_new_client_mask(void __user *);
int orangefs_debugfs_new_client_string(void __user *);
int orangefs_debugfs_new_debug(void __user *);
fs/orangefs/orangefs-kernel.h
View file @ b78b1198
......@@ -99,16 +99,6 @@ enum orangefs_vfs_op_states {
OP_VFS_STATE_GIVEN_UP = 16,
};
/*
* An array of client_debug_mask will be built to hold debug keyword/mask
* values fetched from userspace.
*/
struct client_debug_mask {
char *keyword;
__u64 mask1;
__u64 mask2;
};
/*
* orangefs kernel memory related flags
*/
......@@ -119,29 +109,6 @@ struct client_debug_mask {
#define ORANGEFS_CACHE_CREATE_FLAGS 0
#endif /* ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) */
/* these functions are defined in orangefs-utils.c */
int orangefs_prepare_cdm_array(char *debug_array_string);
int orangefs_prepare_debugfs_help_string(int);
/* defined in orangefs-debugfs.c */
int orangefs_client_debug_init(void);
void debug_string_to_mask(char *, void *, int);
void do_c_mask(int, char *, struct client_debug_mask **);
void do_k_mask(int, char *, __u64 **);
void debug_mask_to_string(void *, int);
void do_k_string(void *, int);
void do_c_string(void *, int);
int check_amalgam_keyword(void *, int);
int keyword_is_amalgam(char *);
/*these variables are defined in orangefs-mod.c */
extern char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
extern char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
extern char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
extern unsigned int kernel_mask_set_mod_init;
extern int orangefs_init_acl(struct inode *inode, struct inode *dir);
extern const struct xattr_handler *orangefs_xattr_handlers[];
......@@ -331,7 +298,7 @@ struct orangefs_stats {
unsigned long writes;
};
extern struct orangefs_stats g_orangefs_stats;
extern struct orangefs_stats orangefs_stats;
/*
* NOTE: See Documentation/filesystems/porting for information
......@@ -547,20 +514,18 @@ bool orangefs_cancel_op_in_progress(struct orangefs_kernel_op_s *op);
int orangefs_normalize_to_errno(__s32 error_code);
extern struct mutex devreq_mutex;
extern struct mutex request_mutex;
extern int debug;
extern struct mutex orangefs_request_mutex;
extern int op_timeout_secs;
extern int slot_timeout_secs;
extern int dcache_timeout_msecs;
extern int getattr_timeout_msecs;
extern int orangefs_dcache_timeout_msecs;
extern int orangefs_getattr_timeout_msecs;
extern struct list_head orangefs_superblocks;
extern spinlock_t orangefs_superblocks_lock;
extern struct list_head orangefs_request_list;
extern spinlock_t orangefs_request_list_lock;
extern wait_queue_head_t orangefs_request_list_waitq;
extern struct list_head *htable_ops_in_progress;
extern spinlock_t htable_ops_in_progress_lock;
extern struct list_head *orangefs_htable_ops_in_progress;
extern spinlock_t orangefs_htable_ops_in_progress_lock;
extern int hash_table_size;
extern const struct address_space_operations orangefs_address_operations;
......
fs/orangefs/orangefs-mod.c
View file @ b78b1198
......@@ -21,34 +21,17 @@
* global variables declared here
*/
/* array of client debug keyword/mask values */
struct client_debug_mask *cdm_array;
int cdm_element_count;
char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN] = "none";
char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
char *debug_help_string;
int help_string_initialized;
struct dentry *help_file_dentry;
struct dentry *client_debug_dentry;
struct dentry *debug_dir;
int client_verbose_index;
int client_all_index;
struct orangefs_stats g_orangefs_stats;
struct orangefs_stats orangefs_stats;
/* the size of the hash tables for ops in progress */
int hash_table_size = 509;
static ulong module_parm_debug_mask;
__u64 gossip_debug_mask;
struct client_debug_mask client_debug_mask = { NULL, 0, 0 };
unsigned int kernel_mask_set_mod_init; /* implicitly false */
__u64 orangefs_gossip_debug_mask;
int op_timeout_secs = ORANGEFS_DEFAULT_OP_TIMEOUT_SECS;
int slot_timeout_secs = ORANGEFS_DEFAULT_SLOT_TIMEOUT_SECS;
int dcache_timeout_msecs = 50;
int getattr_timeout_msecs = 50;
int orangefs_dcache_timeout_msecs = 50;
int orangefs_getattr_timeout_msecs = 50;
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ORANGEFS Development Team");
......@@ -71,20 +54,17 @@ module_param(module_parm_debug_mask, ulong, 0644);
module_param(op_timeout_secs, int, 0);
module_param(slot_timeout_secs, int, 0);
/* synchronizes the request device file */
DEFINE_MUTEX(devreq_mutex);
/*
* Blocks non-priority requests from being queued for servicing. This
* could be used for protecting the request list data structure, but
* for now it's only being used to stall the op addition to the request
* list
*/
DEFINE_MUTEX(request_mutex);
DEFINE_MUTEX(orangefs_request_mutex);
/* hash table for storing operations waiting for matching downcall */
struct list_head *htable_ops_in_progress;
DEFINE_SPINLOCK(htable_ops_in_progress_lock);
struct list_head *orangefs_htable_ops_in_progress;
DEFINE_SPINLOCK(orangefs_htable_ops_in_progress_lock);
/* list for queueing upcall operations */
LIST_HEAD(orangefs_request_list);
......@@ -100,32 +80,6 @@ static int __init orangefs_init(void)
int ret = -1;
__u32 i = 0;
/* convert input debug mask to a 64-bit unsigned integer */
gossip_debug_mask = (unsigned long long) module_parm_debug_mask;
/*
* set the kernel's gossip debug string; invalid mask values will
* be ignored.
*/
debug_mask_to_string(&gossip_debug_mask, 0);
/* remove any invalid values from the mask */
debug_string_to_mask(kernel_debug_string, &gossip_debug_mask, 0);
/*
* if the mask has a non-zero value, then indicate that the mask
* was set when the kernel module was loaded. The orangefs dev ioctl
* command will look at this boolean to determine if the kernel's
* debug mask should be overwritten when the client-core is started.
*/
if (gossip_debug_mask != 0)
kernel_mask_set_mod_init = true;
pr_info("%s: called with debug mask: :%s: :%llx:\n",
__func__,
kernel_debug_string,
(unsigned long long)gossip_debug_mask);
ret = bdi_init(&orangefs_backing_dev_info);
if (ret)
......@@ -146,9 +100,9 @@ static int __init orangefs_init(void)
if (ret < 0)
goto cleanup_op;
htable_ops_in_progress =
orangefs_htable_ops_in_progress =
kcalloc(hash_table_size, sizeof(struct list_head), GFP_KERNEL);
if (!htable_ops_in_progress) {
if (!orangefs_htable_ops_in_progress) {
gossip_err("Failed to initialize op hashtable");
ret = -ENOMEM;
goto cleanup_inode;
......@@ -156,7 +110,7 @@ static int __init orangefs_init(void)
/* initialize a doubly linked at each hash table index */
for (i = 0; i < hash_table_size; i++)
INIT_LIST_HEAD(&htable_ops_in_progress[i]);
INIT_LIST_HEAD(&orangefs_htable_ops_in_progress[i]);
ret = fsid_key_table_initialize();
if (ret < 0)
......@@ -179,14 +133,10 @@ static int __init orangefs_init(void)
if (ret)
goto cleanup_key_table;
ret = orangefs_debugfs_init();
ret = orangefs_debugfs_init(module_parm_debug_mask);
if (ret)
goto debugfs_init_failed;
ret = orangefs_kernel_debug_init();
if (ret)
goto kernel_debug_init_failed;
ret = orangefs_sysfs_init();
if (ret)
goto sysfs_init_failed;
......@@ -214,8 +164,6 @@ static int __init orangefs_init(void)
sysfs_init_failed:
kernel_debug_init_failed:
debugfs_init_failed:
orangefs_debugfs_cleanup();
......@@ -223,7 +171,7 @@ static int __init orangefs_init(void)
fsid_key_table_finalize();
cleanup_progress_table:
kfree(htable_ops_in_progress);
kfree(orangefs_htable_ops_in_progress);
cleanup_inode:
orangefs_inode_cache_finalize();
......@@ -250,12 +198,12 @@ static void __exit orangefs_exit(void)
orangefs_dev_cleanup();
BUG_ON(!list_empty(&orangefs_request_list));
for (i = 0; i < hash_table_size; i++)
BUG_ON(!list_empty(&htable_ops_in_progress[i]));
BUG_ON(!list_empty(&orangefs_htable_ops_in_progress[i]));
orangefs_inode_cache_finalize();
op_cache_finalize();
kfree(htable_ops_in_progress);
kfree(orangefs_htable_ops_in_progress);
bdi_destroy(&orangefs_backing_dev_info);
......@@ -274,10 +222,10 @@ void purge_inprogress_ops(void)
struct orangefs_kernel_op_s *op;
struct orangefs_kernel_op_s *next;
spin_lock(&htable_ops_in_progress_lock);
spin_lock(&orangefs_htable_ops_in_progress_lock);
list_for_each_entry_safe(op,
next,
&htable_ops_in_progress[i],
&orangefs_htable_ops_in_progress[i],
list) {
set_op_state_purged(op);
gossip_debug(GOSSIP_DEV_DEBUG,
......@@ -287,7 +235,7 @@ void purge_inprogress_ops(void)
op->op_state,
current->comm);
}
spin_unlock(&htable_ops_in_progress_lock);
spin_unlock(&orangefs_htable_ops_in_progress_lock);
}
}
......
fs/orangefs/orangefs-sysfs.c
View file @ b78b1198
......@@ -139,159 +139,34 @@
#define PC_KOBJ_ID "pc"
#define STATS_KOBJ_ID "stats"
struct orangefs_obj {
struct kobject kobj;
int op_timeout_secs;
int perf_counter_reset;
int perf_history_size;
int perf_time_interval_secs;
int slot_timeout_secs;
int dcache_timeout_msecs;
int getattr_timeout_msecs;
};
struct acache_orangefs_obj {
struct kobject kobj;
int hard_limit;
int reclaim_percentage;
int soft_limit;
int timeout_msecs;
};
struct capcache_orangefs_obj {
struct kobject kobj;
int hard_limit;
int reclaim_percentage;
int soft_limit;
int timeout_secs;
};
struct ccache_orangefs_obj {
struct kobject kobj;
int hard_limit;
int reclaim_percentage;
int soft_limit;
int timeout_secs;
};
struct ncache_orangefs_obj {
struct kobject kobj;
int hard_limit;
int reclaim_percentage;
int soft_limit;
int timeout_msecs;
};
struct pc_orangefs_obj {
struct kobject kobj;
char *acache;
char *capcache;
char *ncache;
};
struct stats_orangefs_obj {
struct kobject kobj;
int reads;
int writes;
};
/*
* Every item calls orangefs_attr_show and orangefs_attr_store through
* orangefs_sysfs_ops. They look at the orangefs_attributes further below to
* call one of sysfs_int_show, sysfs_int_store, sysfs_service_op_show, or
* sysfs_service_op_store.
*/
struct orangefs_attribute {
struct attribute attr;
ssize_t (*show)(struct orangefs_obj *orangefs_obj,
ssize_t (*show)(struct kobject *kobj,
struct orangefs_attribute *attr,
char *buf);
ssize_t (*store)(struct orangefs_obj *orangefs_obj,
ssize_t (*store)(struct kobject *kobj,
struct orangefs_attribute *attr,
const char *buf,
size_t count);
};
struct acache_orangefs_attribute {
struct attribute attr;
ssize_t (*show)(struct acache_orangefs_obj *acache_orangefs_obj,
struct acache_orangefs_attribute *attr,
char *buf);
ssize_t (*store)(struct acache_orangefs_obj *acache_orangefs_obj,
struct acache_orangefs_attribute *attr,
const char *buf,
size_t count);
};
struct capcache_orangefs_attribute {
struct attribute attr;
ssize_t (*show)(struct capcache_orangefs_obj *capcache_orangefs_obj,
struct capcache_orangefs_attribute *attr,
char *buf);
ssize_t (*store)(struct capcache_orangefs_obj *capcache_orangefs_obj,
struct capcache_orangefs_attribute *attr,
const char *buf,
size_t count);
};
struct ccache_orangefs_attribute {
struct attribute attr;
ssize_t (*show)(struct ccache_orangefs_obj *ccache_orangefs_obj,
struct ccache_orangefs_attribute *attr,
char *buf);
ssize_t (*store)(struct ccache_orangefs_obj *ccache_orangefs_obj,
struct ccache_orangefs_attribute *attr,
const char *buf,
size_t count);
};
struct ncache_orangefs_attribute {
struct attribute attr;
ssize_t (*show)(struct ncache_orangefs_obj *ncache_orangefs_obj,
struct ncache_orangefs_attribute *attr,
char *buf);
ssize_t (*store)(struct ncache_orangefs_obj *ncache_orangefs_obj,
struct ncache_orangefs_attribute *attr,
const char *buf,
size_t count);
};
struct pc_orangefs_attribute {
struct attribute attr;
ssize_t (*show)(struct pc_orangefs_obj *pc_orangefs_obj,
struct pc_orangefs_attribute *attr,
char *buf);
ssize_t (*store)(struct pc_orangefs_obj *pc_orangefs_obj,
struct pc_orangefs_attribute *attr,
const char *buf,
size_t count);
};
struct stats_orangefs_attribute {
struct attribute attr;
ssize_t (*show)(struct stats_orangefs_obj *stats_orangefs_obj,
struct stats_orangefs_attribute *attr,
char *buf);
ssize_t (*store)(struct stats_orangefs_obj *stats_orangefs_obj,
struct stats_orangefs_attribute *attr,
const char *buf,
size_t count);
};
static ssize_t orangefs_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct orangefs_attribute *attribute;
struct orangefs_obj *orangefs_obj;
int rc;
attribute = container_of(attr, struct orangefs_attribute, attr);
orangefs_obj = container_of(kobj, struct orangefs_obj, kobj);
if (!attribute->show) {
rc = -EIO;
goto out;
}
rc = attribute->show(orangefs_obj, attribute, buf);
out:
return rc;
if (!attribute->show)
return -EIO;
return attribute->show(kobj, attribute, buf);
}
static ssize_t orangefs_attr_store(struct kobject *kobj,
......@@ -300,24 +175,15 @@ static ssize_t orangefs_attr_store(struct kobject *kobj,
size_t len)
{
struct orangefs_attribute *attribute;
struct orangefs_obj *orangefs_obj;
int rc;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"orangefs_attr_store: start\n");
if (!strcmp(kobj->name, PC_KOBJ_ID) ||
!strcmp(kobj->name, STATS_KOBJ_ID))
return -EPERM;
attribute = container_of(attr, struct orangefs_attribute, attr);
orangefs_obj = container_of(kobj, struct orangefs_obj, kobj);
if (!attribute->store) {
rc = -EIO;
goto out;
}
rc = attribute->store(orangefs_obj, attribute, buf, len);
out:
return rc;
if (!attribute->store)
return -EIO;
return attribute->store(kobj, attribute, buf, len);
}
static const struct sysfs_ops orangefs_sysfs_ops = {
......@@ -325,402 +191,58 @@ static const struct sysfs_ops orangefs_sysfs_ops = {
.store = orangefs_attr_store,
};
static ssize_t acache_orangefs_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct acache_orangefs_attribute *attribute;
struct acache_orangefs_obj *acache_orangefs_obj;
int rc;
attribute = container_of(attr, struct acache_orangefs_attribute, attr);
acache_orangefs_obj =
container_of(kobj, struct acache_orangefs_obj, kobj);
if (!attribute->show) {
rc = -EIO;
goto out;
}
rc = attribute->show(acache_orangefs_obj, attribute, buf);
out:
return rc;
}
static ssize_t acache_orangefs_attr_store(struct kobject *kobj,
struct attribute *attr,
const char *buf,
size_t len)
{
struct acache_orangefs_attribute *attribute;
struct acache_orangefs_obj *acache_orangefs_obj;
int rc;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"acache_orangefs_attr_store: start\n");
attribute = container_of(attr, struct acache_orangefs_attribute, attr);
acache_orangefs_obj =
container_of(kobj, struct acache_orangefs_obj, kobj);
if (!attribute->store) {
rc = -EIO;
goto out;
}
rc = attribute->store(acache_orangefs_obj, attribute, buf, len);
out:
return rc;
}
static const struct sysfs_ops acache_orangefs_sysfs_ops = {
.show = acache_orangefs_attr_show,
.store = acache_orangefs_attr_store,
};
static ssize_t capcache_orangefs_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct capcache_orangefs_attribute *attribute;
struct capcache_orangefs_obj *capcache_orangefs_obj;
int rc;
attribute =
container_of(attr, struct capcache_orangefs_attribute, attr);
capcache_orangefs_obj =
container_of(kobj, struct capcache_orangefs_obj, kobj);
if (!attribute->show) {
rc = -EIO;
goto out;
}
rc = attribute->show(capcache_orangefs_obj, attribute, buf);
out:
return rc;
}
static ssize_t capcache_orangefs_attr_store(struct kobject *kobj,
struct attribute *attr,
const char *buf,
size_t len)
{
struct capcache_orangefs_attribute *attribute;
struct capcache_orangefs_obj *capcache_orangefs_obj;
int rc;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"capcache_orangefs_attr_store: start\n");
attribute =
container_of(attr, struct capcache_orangefs_attribute, attr);
capcache_orangefs_obj =
container_of(kobj, struct capcache_orangefs_obj, kobj);
if (!attribute->store) {
rc = -EIO;
goto out;
}
rc = attribute->store(capcache_orangefs_obj, attribute, buf, len);
out:
return rc;
}
static const struct sysfs_ops capcache_orangefs_sysfs_ops = {
.show = capcache_orangefs_attr_show,
.store = capcache_orangefs_attr_store,
};
static ssize_t ccache_orangefs_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct ccache_orangefs_attribute *attribute;
struct ccache_orangefs_obj *ccache_orangefs_obj;
int rc;
attribute =
container_of(attr, struct ccache_orangefs_attribute, attr);
ccache_orangefs_obj =
container_of(kobj, struct ccache_orangefs_obj, kobj);
if (!attribute->show) {
rc = -EIO;
goto out;
}
rc = attribute->show(ccache_orangefs_obj, attribute, buf);
out:
return rc;
}
static ssize_t ccache_orangefs_attr_store(struct kobject *kobj,
struct attribute *attr,
const char *buf,
size_t len)
{
struct ccache_orangefs_attribute *attribute;
struct ccache_orangefs_obj *ccache_orangefs_obj;
int rc;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"ccache_orangefs_attr_store: start\n");
attribute =
container_of(attr, struct ccache_orangefs_attribute, attr);
ccache_orangefs_obj =
container_of(kobj, struct ccache_orangefs_obj, kobj);
if (!attribute->store) {
rc = -EIO;
goto out;
}
rc = attribute->store(ccache_orangefs_obj, attribute, buf, len);
out:
return rc;
}
static const struct sysfs_ops ccache_orangefs_sysfs_ops = {
.show = ccache_orangefs_attr_show,
.store = ccache_orangefs_attr_store,
};
static ssize_t ncache_orangefs_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct ncache_orangefs_attribute *attribute;
struct ncache_orangefs_obj *ncache_orangefs_obj;
int rc;
attribute = container_of(attr, struct ncache_orangefs_attribute, attr);
ncache_orangefs_obj =
container_of(kobj, struct ncache_orangefs_obj, kobj);
if (!attribute->show) {
rc = -EIO;
goto out;
}
rc = attribute->show(ncache_orangefs_obj, attribute, buf);
out:
return rc;
}
static ssize_t ncache_orangefs_attr_store(struct kobject *kobj,
struct attribute *attr,
const char *buf,
size_t len)
{
struct ncache_orangefs_attribute *attribute;
struct ncache_orangefs_obj *ncache_orangefs_obj;
int rc;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"ncache_orangefs_attr_store: start\n");
attribute = container_of(attr, struct ncache_orangefs_attribute, attr);
ncache_orangefs_obj =
container_of(kobj, struct ncache_orangefs_obj, kobj);
if (!attribute->store) {
rc = -EIO;
goto out;
}
rc = attribute->store(ncache_orangefs_obj, attribute, buf, len);
out:
return rc;
}
static const struct sysfs_ops ncache_orangefs_sysfs_ops = {
.show = ncache_orangefs_attr_show,
.store = ncache_orangefs_attr_store,
};
static ssize_t pc_orangefs_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct pc_orangefs_attribute *attribute;
struct pc_orangefs_obj *pc_orangefs_obj;
int rc;
attribute = container_of(attr, struct pc_orangefs_attribute, attr);
pc_orangefs_obj =
container_of(kobj, struct pc_orangefs_obj, kobj);
if (!attribute->show) {
rc = -EIO;
goto out;
}
rc = attribute->show(pc_orangefs_obj, attribute, buf);
out:
return rc;
}
static const struct sysfs_ops pc_orangefs_sysfs_ops = {
.show = pc_orangefs_attr_show,
};
static ssize_t stats_orangefs_attr_show(struct kobject *kobj,
struct attribute *attr,
char *buf)
{
struct stats_orangefs_attribute *attribute;
struct stats_orangefs_obj *stats_orangefs_obj;
int rc;
attribute = container_of(attr, struct stats_orangefs_attribute, attr);
stats_orangefs_obj =
container_of(kobj, struct stats_orangefs_obj, kobj);
if (!attribute->show) {
rc = -EIO;
goto out;
}
rc = attribute->show(stats_orangefs_obj, attribute, buf);
out:
return rc;
}
static const struct sysfs_ops stats_orangefs_sysfs_ops = {
.show = stats_orangefs_attr_show,
};
static void orangefs_release(struct kobject *kobj)
{
struct orangefs_obj *orangefs_obj;
orangefs_obj = container_of(kobj, struct orangefs_obj, kobj);
kfree(orangefs_obj);
}
static void acache_orangefs_release(struct kobject *kobj)
{
struct acache_orangefs_obj *acache_orangefs_obj;
acache_orangefs_obj =
container_of(kobj, struct acache_orangefs_obj, kobj);
kfree(acache_orangefs_obj);
}
static void capcache_orangefs_release(struct kobject *kobj)
{
struct capcache_orangefs_obj *capcache_orangefs_obj;
capcache_orangefs_obj =
container_of(kobj, struct capcache_orangefs_obj, kobj);
kfree(capcache_orangefs_obj);
}
static void ccache_orangefs_release(struct kobject *kobj)
{
struct ccache_orangefs_obj *ccache_orangefs_obj;
ccache_orangefs_obj =
container_of(kobj, struct ccache_orangefs_obj, kobj);
kfree(ccache_orangefs_obj);
}
static void ncache_orangefs_release(struct kobject *kobj)
{
struct ncache_orangefs_obj *ncache_orangefs_obj;
ncache_orangefs_obj =
container_of(kobj, struct ncache_orangefs_obj, kobj);
kfree(ncache_orangefs_obj);
}
static void pc_orangefs_release(struct kobject *kobj)
{
struct pc_orangefs_obj *pc_orangefs_obj;
pc_orangefs_obj =
container_of(kobj, struct pc_orangefs_obj, kobj);
kfree(pc_orangefs_obj);
}
static void stats_orangefs_release(struct kobject *kobj)
{
struct stats_orangefs_obj *stats_orangefs_obj;
stats_orangefs_obj =
container_of(kobj, struct stats_orangefs_obj, kobj);
kfree(stats_orangefs_obj);
}
static ssize_t sysfs_int_show(char *kobj_id, char *buf, void *attr)
static ssize_t sysfs_int_show(struct kobject *kobj,
struct orangefs_attribute *attr, char *buf)
{
int rc = -EIO;
struct orangefs_attribute *orangefs_attr;
struct stats_orangefs_attribute *stats_orangefs_attr;
gossip_debug(GOSSIP_SYSFS_DEBUG, "sysfs_int_show: id:%s:\n", kobj_id);
if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) {
orangefs_attr = (struct orangefs_attribute *)attr;
gossip_debug(GOSSIP_SYSFS_DEBUG, "sysfs_int_show: id:%s:\n",
kobj->name);
if (!strcmp(orangefs_attr->attr.name, "op_timeout_secs")) {
if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "op_timeout_secs")) {
rc = scnprintf(buf,
PAGE_SIZE,
"%d\n",
op_timeout_secs);
goto out;
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"slot_timeout_secs")) {
rc = scnprintf(buf,
PAGE_SIZE,
"%d\n",
slot_timeout_secs);
goto out;
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"dcache_timeout_msecs")) {
rc = scnprintf(buf,
PAGE_SIZE,
"%d\n",
dcache_timeout_msecs);
orangefs_dcache_timeout_msecs);
goto out;
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"getattr_timeout_msecs")) {
rc = scnprintf(buf,
PAGE_SIZE,
"%d\n",
getattr_timeout_msecs);
orangefs_getattr_timeout_msecs);
goto out;
} else {
goto out;
}
} else if (!strcmp(kobj_id, STATS_KOBJ_ID)) {
stats_orangefs_attr = (struct stats_orangefs_attribute *)attr;
if (!strcmp(stats_orangefs_attr->attr.name, "reads")) {
} else if (!strcmp(kobj->name, STATS_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "reads")) {
rc = scnprintf(buf,
PAGE_SIZE,
"%lu\n",
g_orangefs_stats.reads);
orangefs_stats.reads);
goto out;
} else if (!strcmp(stats_orangefs_attr->attr.name, "writes")) {
} else if (!strcmp(attr->attr.name, "writes")) {
rc = scnprintf(buf,
PAGE_SIZE,
"%lu\n",
g_orangefs_stats.writes);
orangefs_stats.writes);
goto out;
} else {
goto out;
......@@ -732,45 +254,13 @@ static ssize_t sysfs_int_show(char *kobj_id, char *buf, void *attr)
return rc;
}
static ssize_t int_orangefs_show(struct orangefs_obj *orangefs_obj,
struct orangefs_attribute *attr,
char *buf)
{
int rc;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"int_orangefs_show:start attr->attr.name:%s:\n",
attr->attr.name);
rc = sysfs_int_show(ORANGEFS_KOBJ_ID, buf, (void *) attr);
return rc;
}
static ssize_t int_stats_show(struct stats_orangefs_obj *stats_orangefs_obj,
struct stats_orangefs_attribute *attr,
char *buf)
{
int rc;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"int_stats_show:start attr->attr.name:%s:\n",
attr->attr.name);
rc = sysfs_int_show(STATS_KOBJ_ID, buf, (void *) attr);
return rc;
}
static ssize_t int_store(struct orangefs_obj *orangefs_obj,
struct orangefs_attribute *attr,
const char *buf,
size_t count)
static ssize_t sysfs_int_store(struct kobject *kobj,
struct orangefs_attribute *attr, const char *buf, size_t count)
{
int rc = 0;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"int_store: start attr->attr.name:%s: buf:%s:\n",
"sysfs_int_store: start attr->attr.name:%s: buf:%s:\n",
attr->attr.name, buf);
if (!strcmp(attr->attr.name, "op_timeout_secs")) {
......@@ -780,10 +270,10 @@ static ssize_t int_store(struct orangefs_obj *orangefs_obj,
rc = kstrtoint(buf, 0, &slot_timeout_secs);
goto out;
} else if (!strcmp(attr->attr.name, "dcache_timeout_msecs")) {
rc = kstrtoint(buf, 0, &dcache_timeout_msecs);
rc = kstrtoint(buf, 0, &orangefs_dcache_timeout_msecs);
goto out;
} else if (!strcmp(attr->attr.name, "getattr_timeout_msecs")) {
rc = kstrtoint(buf, 0, &getattr_timeout_msecs);
rc = kstrtoint(buf, 0, &orangefs_getattr_timeout_msecs);
goto out;
} else {
goto out;
......@@ -801,24 +291,19 @@ static ssize_t int_store(struct orangefs_obj *orangefs_obj,
/*
* obtain attribute values from userspace with a service operation.
*/
static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
static ssize_t sysfs_service_op_show(struct kobject *kobj,
struct orangefs_attribute *attr, char *buf)
{
struct orangefs_kernel_op_s *new_op = NULL;
int rc = 0;
char *ser_op_type = NULL;
struct orangefs_attribute *orangefs_attr;
struct acache_orangefs_attribute *acache_attr;
struct capcache_orangefs_attribute *capcache_attr;
struct ccache_orangefs_attribute *ccache_attr;
struct ncache_orangefs_attribute *ncache_attr;
struct pc_orangefs_attribute *pc_attr;
__u32 op_alloc_type;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"sysfs_service_op_show: id:%s:\n",
kobj_id);
kobj->name);
if (strcmp(kobj_id, PC_KOBJ_ID))
if (strcmp(kobj->name, PC_KOBJ_ID))
op_alloc_type = ORANGEFS_VFS_OP_PARAM;
else
op_alloc_type = ORANGEFS_VFS_OP_PERF_COUNT;
......@@ -836,148 +321,135 @@ static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
goto out;
}
if (strcmp(kobj_id, PC_KOBJ_ID))
if (strcmp(kobj->name, PC_KOBJ_ID))
new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_GET;
if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) {
orangefs_attr = (struct orangefs_attribute *)attr;
if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
/* Drop unsupported requests first. */
if (!(orangefs_features & ORANGEFS_FEATURE_READAHEAD) &&
(!strcmp(orangefs_attr->attr.name, "readahead_count") ||
!strcmp(orangefs_attr->attr.name, "readahead_size") ||
!strcmp(orangefs_attr->attr.name,
"readahead_count_size"))) {
(!strcmp(attr->attr.name, "readahead_count") ||
!strcmp(attr->attr.name, "readahead_size") ||
!strcmp(attr->attr.name, "readahead_count_size"))) {
rc = -EINVAL;
goto out;
}
if (!strcmp(orangefs_attr->attr.name, "perf_history_size"))
if (!strcmp(attr->attr.name, "perf_history_size"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
else if (!strcmp(orangefs_attr->attr.name,
else if (!strcmp(attr->attr.name,
"perf_time_interval_secs"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
else if (!strcmp(orangefs_attr->attr.name,
else if (!strcmp(attr->attr.name,
"perf_counter_reset"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
else if (!strcmp(orangefs_attr->attr.name,
else if (!strcmp(attr->attr.name,
"readahead_count"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT;
else if (!strcmp(orangefs_attr->attr.name,
else if (!strcmp(attr->attr.name,
"readahead_size"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_READAHEAD_SIZE;
else if (!strcmp(orangefs_attr->attr.name,
else if (!strcmp(attr->attr.name,
"readahead_count_size"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE;
} else if (!strcmp(kobj_id, ACACHE_KOBJ_ID)) {
acache_attr = (struct acache_orangefs_attribute *)attr;
if (!strcmp(acache_attr->attr.name, "timeout_msecs"))
} else if (!strcmp(kobj->name, ACACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "timeout_msecs"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
if (!strcmp(acache_attr->attr.name, "hard_limit"))
if (!strcmp(attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
if (!strcmp(acache_attr->attr.name, "soft_limit"))
if (!strcmp(attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
if (!strcmp(acache_attr->attr.name, "reclaim_percentage"))
if (!strcmp(attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, CAPCACHE_KOBJ_ID)) {
capcache_attr = (struct capcache_orangefs_attribute *)attr;
if (!strcmp(capcache_attr->attr.name, "timeout_secs"))
} else if (!strcmp(kobj->name, CAPCACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "timeout_secs"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
if (!strcmp(capcache_attr->attr.name, "hard_limit"))
if (!strcmp(attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
if (!strcmp(capcache_attr->attr.name, "soft_limit"))
if (!strcmp(attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
if (!strcmp(capcache_attr->attr.name, "reclaim_percentage"))
if (!strcmp(attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, CCACHE_KOBJ_ID)) {
ccache_attr = (struct ccache_orangefs_attribute *)attr;
if (!strcmp(ccache_attr->attr.name, "timeout_secs"))
} else if (!strcmp(kobj->name, CCACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "timeout_secs"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
if (!strcmp(ccache_attr->attr.name, "hard_limit"))
if (!strcmp(attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
if (!strcmp(ccache_attr->attr.name, "soft_limit"))
if (!strcmp(attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
if (!strcmp(ccache_attr->attr.name, "reclaim_percentage"))
if (!strcmp(attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, NCACHE_KOBJ_ID)) {
ncache_attr = (struct ncache_orangefs_attribute *)attr;
if (!strcmp(ncache_attr->attr.name, "timeout_msecs"))
} else if (!strcmp(kobj->name, NCACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "timeout_msecs"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
if (!strcmp(ncache_attr->attr.name, "hard_limit"))
if (!strcmp(attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
if (!strcmp(ncache_attr->attr.name, "soft_limit"))
if (!strcmp(attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
if (!strcmp(ncache_attr->attr.name, "reclaim_percentage"))
if (!strcmp(attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, PC_KOBJ_ID)) {
pc_attr = (struct pc_orangefs_attribute *)attr;
if (!strcmp(pc_attr->attr.name, ACACHE_KOBJ_ID))
} else if (!strcmp(kobj->name, PC_KOBJ_ID)) {
if (!strcmp(attr->attr.name, ACACHE_KOBJ_ID))
new_op->upcall.req.perf_count.type =
ORANGEFS_PERF_COUNT_REQUEST_ACACHE;
if (!strcmp(pc_attr->attr.name, CAPCACHE_KOBJ_ID))
if (!strcmp(attr->attr.name, CAPCACHE_KOBJ_ID))
new_op->upcall.req.perf_count.type =
ORANGEFS_PERF_COUNT_REQUEST_CAPCACHE;
if (!strcmp(pc_attr->attr.name, NCACHE_KOBJ_ID))
if (!strcmp(attr->attr.name, NCACHE_KOBJ_ID))
new_op->upcall.req.perf_count.type =
ORANGEFS_PERF_COUNT_REQUEST_NCACHE;
} else {
gossip_err("sysfs_service_op_show: unknown kobj_id:%s:\n",
kobj_id);
kobj->name);
rc = -EINVAL;
goto out;
}
if (strcmp(kobj_id, PC_KOBJ_ID))
if (strcmp(kobj->name, PC_KOBJ_ID))
ser_op_type = "orangefs_param";
else
ser_op_type = "orangefs_perf_count";
......@@ -990,7 +462,7 @@ static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
out:
if (!rc) {
if (strcmp(kobj_id, PC_KOBJ_ID)) {
if (strcmp(kobj->name, PC_KOBJ_ID)) {
if (new_op->upcall.req.param.op ==
ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE) {
rc = scnprintf(buf, PAGE_SIZE, "%d %d\n",
......@@ -1017,77 +489,6 @@ static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
}
static ssize_t service_orangefs_show(struct orangefs_obj *orangefs_obj,
struct orangefs_attribute *attr,
char *buf)
{
int rc = 0;
rc = sysfs_service_op_show(ORANGEFS_KOBJ_ID, buf, (void *)attr);
return rc;
}
static ssize_t
service_acache_show(struct acache_orangefs_obj *acache_orangefs_obj,
struct acache_orangefs_attribute *attr,
char *buf)
{
int rc = 0;
rc = sysfs_service_op_show(ACACHE_KOBJ_ID, buf, (void *)attr);
return rc;
}
static ssize_t service_capcache_show(struct capcache_orangefs_obj
*capcache_orangefs_obj,
struct capcache_orangefs_attribute *attr,
char *buf)
{
int rc = 0;
rc = sysfs_service_op_show(CAPCACHE_KOBJ_ID, buf, (void *)attr);
return rc;
}
static ssize_t service_ccache_show(struct ccache_orangefs_obj
*ccache_orangefs_obj,
struct ccache_orangefs_attribute *attr,
char *buf)
{
int rc = 0;
rc = sysfs_service_op_show(CCACHE_KOBJ_ID, buf, (void *)attr);
return rc;
}
static ssize_t
service_ncache_show(struct ncache_orangefs_obj *ncache_orangefs_obj,
struct ncache_orangefs_attribute *attr,
char *buf)
{
int rc = 0;
rc = sysfs_service_op_show(NCACHE_KOBJ_ID, buf, (void *)attr);
return rc;
}
static ssize_t
service_pc_show(struct pc_orangefs_obj *pc_orangefs_obj,
struct pc_orangefs_attribute *attr,
char *buf)
{
int rc = 0;
rc = sysfs_service_op_show(PC_KOBJ_ID, buf, (void *)attr);
return rc;
}
/*
* pass attribute values back to userspace with a service operation.
*
......@@ -1099,20 +500,16 @@ static ssize_t
* We want to return 1 if we think everything went OK, and
* EINVAL if not.
*/
static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
static ssize_t sysfs_service_op_store(struct kobject *kobj,
struct orangefs_attribute *attr, const char *buf, size_t count)
{
struct orangefs_kernel_op_s *new_op = NULL;
int val = 0;
int rc = 0;
struct orangefs_attribute *orangefs_attr;
struct acache_orangefs_attribute *acache_attr;
struct capcache_orangefs_attribute *capcache_attr;
struct ccache_orangefs_attribute *ccache_attr;
struct ncache_orangefs_attribute *ncache_attr;
gossip_debug(GOSSIP_SYSFS_DEBUG,
"sysfs_service_op_store: id:%s:\n",
kobj_id);
kobj->name);
new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
if (!new_op)
......@@ -1131,9 +528,8 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
* The value we want to send back to userspace is in buf, unless this
* there are two parameters, which is specially handled below.
*/
if (strcmp(kobj_id, ORANGEFS_KOBJ_ID) ||
strcmp(((struct orangefs_attribute *)attr)->attr.name,
"readahead_count_size")) {
if (strcmp(kobj->name, ORANGEFS_KOBJ_ID) ||
strcmp(attr->attr.name, "readahead_count_size")) {
rc = kstrtoint(buf, 0, &val);
if (rc)
goto out;
......@@ -1141,19 +537,17 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) {
orangefs_attr = (struct orangefs_attribute *)attr;
if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
/* Drop unsupported requests first. */
if (!(orangefs_features & ORANGEFS_FEATURE_READAHEAD) &&
(!strcmp(orangefs_attr->attr.name, "readahead_count") ||
!strcmp(orangefs_attr->attr.name, "readahead_size") ||
!strcmp(orangefs_attr->attr.name,
"readahead_count_size"))) {
(!strcmp(attr->attr.name, "readahead_count") ||
!strcmp(attr->attr.name, "readahead_size") ||
!strcmp(attr->attr.name, "readahead_count_size"))) {
rc = -EINVAL;
goto out;
}
if (!strcmp(orangefs_attr->attr.name, "perf_history_size")) {
if (!strcmp(attr->attr.name, "perf_history_size")) {
if (val > 0) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
......@@ -1161,7 +555,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"perf_time_interval_secs")) {
if (val > 0) {
new_op->upcall.req.param.op =
......@@ -1170,7 +564,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"perf_counter_reset")) {
if ((val == 0) || (val == 1)) {
new_op->upcall.req.param.op =
......@@ -1179,7 +573,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"readahead_count")) {
if ((val >= 0)) {
new_op->upcall.req.param.op =
......@@ -1188,7 +582,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"readahead_size")) {
if ((val >= 0)) {
new_op->upcall.req.param.op =
......@@ -1197,7 +591,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"readahead_count_size")) {
int val1, val2;
rc = sscanf(buf, "%d %d", &val1, &val2);
......@@ -1215,7 +609,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
new_op->upcall.req.param.u.value32[0] = val1;
new_op->upcall.req.param.u.value32[1] = val2;
goto value_set;
} else if (!strcmp(orangefs_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"perf_counter_reset")) {
if ((val > 0)) {
new_op->upcall.req.param.op =
......@@ -1226,10 +620,8 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
}
}
} else if (!strcmp(kobj_id, ACACHE_KOBJ_ID)) {
acache_attr = (struct acache_orangefs_attribute *)attr;
if (!strcmp(acache_attr->attr.name, "hard_limit")) {
} else if (!strcmp(kobj->name, ACACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "hard_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
......@@ -1237,7 +629,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(acache_attr->attr.name, "soft_limit")) {
} else if (!strcmp(attr->attr.name, "soft_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
......@@ -1245,7 +637,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(acache_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"reclaim_percentage")) {
if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op =
......@@ -1254,7 +646,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(acache_attr->attr.name, "timeout_msecs")) {
} else if (!strcmp(attr->attr.name, "timeout_msecs")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
......@@ -1264,10 +656,8 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
}
}
} else if (!strcmp(kobj_id, CAPCACHE_KOBJ_ID)) {
capcache_attr = (struct capcache_orangefs_attribute *)attr;
if (!strcmp(capcache_attr->attr.name, "hard_limit")) {
} else if (!strcmp(kobj->name, CAPCACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "hard_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
......@@ -1275,7 +665,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(capcache_attr->attr.name, "soft_limit")) {
} else if (!strcmp(attr->attr.name, "soft_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
......@@ -1283,7 +673,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(capcache_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"reclaim_percentage")) {
if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op =
......@@ -1292,7 +682,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(capcache_attr->attr.name, "timeout_secs")) {
} else if (!strcmp(attr->attr.name, "timeout_secs")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
......@@ -1302,10 +692,8 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
}
}
} else if (!strcmp(kobj_id, CCACHE_KOBJ_ID)) {
ccache_attr = (struct ccache_orangefs_attribute *)attr;
if (!strcmp(ccache_attr->attr.name, "hard_limit")) {
} else if (!strcmp(kobj->name, CCACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "hard_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
......@@ -1313,7 +701,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(ccache_attr->attr.name, "soft_limit")) {
} else if (!strcmp(attr->attr.name, "soft_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
......@@ -1321,7 +709,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(ccache_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"reclaim_percentage")) {
if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op =
......@@ -1330,7 +718,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(ccache_attr->attr.name, "timeout_secs")) {
} else if (!strcmp(attr->attr.name, "timeout_secs")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
......@@ -1340,10 +728,8 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
}
}
} else if (!strcmp(kobj_id, NCACHE_KOBJ_ID)) {
ncache_attr = (struct ncache_orangefs_attribute *)attr;
if (!strcmp(ncache_attr->attr.name, "hard_limit")) {
} else if (!strcmp(kobj->name, NCACHE_KOBJ_ID)) {
if (!strcmp(attr->attr.name, "hard_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
......@@ -1351,7 +737,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(ncache_attr->attr.name, "soft_limit")) {
} else if (!strcmp(attr->attr.name, "soft_limit")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
......@@ -1359,7 +745,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(ncache_attr->attr.name,
} else if (!strcmp(attr->attr.name,
"reclaim_percentage")) {
if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op =
......@@ -1368,7 +754,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc = 0;
goto out;
}
} else if (!strcmp(ncache_attr->attr.name, "timeout_msecs")) {
} else if (!strcmp(attr->attr.name, "timeout_msecs")) {
if (val > -1) {
new_op->upcall.req.param.op =
ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
......@@ -1380,7 +766,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else {
gossip_err("sysfs_service_op_store: unknown kobj_id:%s:\n",
kobj_id);
kobj->name);
rc = -EINVAL;
goto out;
}
......@@ -1399,7 +785,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
rc);
rc = 0;
} else {
rc = 1;
rc = count;
}
out:
......@@ -1411,133 +797,47 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
return rc;
}
static ssize_t
service_orangefs_store(struct orangefs_obj *orangefs_obj,
struct orangefs_attribute *attr,
const char *buf,
size_t count)
{
int rc = 0;
rc = sysfs_service_op_store(ORANGEFS_KOBJ_ID, buf, (void *) attr);
/* rc should have an errno value if the service_op went bad. */
if (rc == 1)
rc = count;
return rc;
}
static ssize_t
service_acache_store(struct acache_orangefs_obj *acache_orangefs_obj,
struct acache_orangefs_attribute *attr,
const char *buf,
size_t count)
{
int rc = 0;
rc = sysfs_service_op_store(ACACHE_KOBJ_ID, buf, (void *) attr);
/* rc should have an errno value if the service_op went bad. */
if (rc == 1)
rc = count;
return rc;
}
static ssize_t
service_capcache_store(struct capcache_orangefs_obj
*capcache_orangefs_obj,
struct capcache_orangefs_attribute *attr,
const char *buf,
size_t count)
{
int rc = 0;
rc = sysfs_service_op_store(CAPCACHE_KOBJ_ID, buf, (void *) attr);
/* rc should have an errno value if the service_op went bad. */
if (rc == 1)
rc = count;
return rc;
}
static ssize_t service_ccache_store(struct ccache_orangefs_obj
*ccache_orangefs_obj,
struct ccache_orangefs_attribute *attr,
const char *buf,
size_t count)
{
int rc = 0;
rc = sysfs_service_op_store(CCACHE_KOBJ_ID, buf, (void *) attr);
/* rc should have an errno value if the service_op went bad. */
if (rc == 1)
rc = count;
return rc;
}
static ssize_t
service_ncache_store(struct ncache_orangefs_obj *ncache_orangefs_obj,
struct ncache_orangefs_attribute *attr,
const char *buf,
size_t count)
{
int rc = 0;
rc = sysfs_service_op_store(NCACHE_KOBJ_ID, buf, (void *) attr);
/* rc should have an errno value if the service_op went bad. */
if (rc == 1)
rc = count;
return rc;
}
static struct orangefs_attribute op_timeout_secs_attribute =
__ATTR(op_timeout_secs, 0664, int_orangefs_show, int_store);
__ATTR(op_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);
static struct orangefs_attribute slot_timeout_secs_attribute =
__ATTR(slot_timeout_secs, 0664, int_orangefs_show, int_store);
__ATTR(slot_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);
static struct orangefs_attribute dcache_timeout_msecs_attribute =
__ATTR(dcache_timeout_msecs, 0664, int_orangefs_show, int_store);
__ATTR(dcache_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);
static struct orangefs_attribute getattr_timeout_msecs_attribute =
__ATTR(getattr_timeout_msecs, 0664, int_orangefs_show, int_store);
__ATTR(getattr_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);
static struct orangefs_attribute readahead_count_attribute =
__ATTR(readahead_count, 0664, service_orangefs_show,
service_orangefs_store);
__ATTR(readahead_count, 0664, sysfs_service_op_show,
sysfs_service_op_store);
static struct orangefs_attribute readahead_size_attribute =
__ATTR(readahead_size, 0664, service_orangefs_show,
service_orangefs_store);
__ATTR(readahead_size, 0664, sysfs_service_op_show,
sysfs_service_op_store);
static struct orangefs_attribute readahead_count_size_attribute =
__ATTR(readahead_count_size, 0664, service_orangefs_show,
service_orangefs_store);
__ATTR(readahead_count_size, 0664, sysfs_service_op_show,
sysfs_service_op_store);
static struct orangefs_attribute perf_counter_reset_attribute =
__ATTR(perf_counter_reset,
0664,
service_orangefs_show,
service_orangefs_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct orangefs_attribute perf_history_size_attribute =
__ATTR(perf_history_size,
0664,
service_orangefs_show,
service_orangefs_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct orangefs_attribute perf_time_interval_secs_attribute =
__ATTR(perf_time_interval_secs,
0664,
service_orangefs_show,
service_orangefs_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct attribute *orangefs_default_attrs[] = {
&op_timeout_secs_attribute.attr,
......@@ -1555,33 +855,32 @@ static struct attribute *orangefs_default_attrs[] = {
static struct kobj_type orangefs_ktype = {
.sysfs_ops = &orangefs_sysfs_ops,
.release = orangefs_release,
.default_attrs = orangefs_default_attrs,
};
static struct acache_orangefs_attribute acache_hard_limit_attribute =
static struct orangefs_attribute acache_hard_limit_attribute =
__ATTR(hard_limit,
0664,
service_acache_show,
service_acache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct acache_orangefs_attribute acache_reclaim_percent_attribute =
static struct orangefs_attribute acache_reclaim_percent_attribute =
__ATTR(reclaim_percentage,
0664,
service_acache_show,
service_acache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct acache_orangefs_attribute acache_soft_limit_attribute =
static struct orangefs_attribute acache_soft_limit_attribute =
__ATTR(soft_limit,
0664,
service_acache_show,
service_acache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct acache_orangefs_attribute acache_timeout_msecs_attribute =
static struct orangefs_attribute acache_timeout_msecs_attribute =
__ATTR(timeout_msecs,
0664,
service_acache_show,
service_acache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct attribute *acache_orangefs_default_attrs[] = {
&acache_hard_limit_attribute.attr,
......@@ -1592,34 +891,33 @@ static struct attribute *acache_orangefs_default_attrs[] = {
};
static struct kobj_type acache_orangefs_ktype = {
.sysfs_ops = &acache_orangefs_sysfs_ops,
.release = acache_orangefs_release,
.sysfs_ops = &orangefs_sysfs_ops,
.default_attrs = acache_orangefs_default_attrs,
};
static struct capcache_orangefs_attribute capcache_hard_limit_attribute =
static struct orangefs_attribute capcache_hard_limit_attribute =
__ATTR(hard_limit,
0664,
service_capcache_show,
service_capcache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct capcache_orangefs_attribute capcache_reclaim_percent_attribute =
static struct orangefs_attribute capcache_reclaim_percent_attribute =
__ATTR(reclaim_percentage,
0664,
service_capcache_show,
service_capcache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct capcache_orangefs_attribute capcache_soft_limit_attribute =
static struct orangefs_attribute capcache_soft_limit_attribute =
__ATTR(soft_limit,
0664,
service_capcache_show,
service_capcache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct capcache_orangefs_attribute capcache_timeout_secs_attribute =
static struct orangefs_attribute capcache_timeout_secs_attribute =
__ATTR(timeout_secs,
0664,
service_capcache_show,
service_capcache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct attribute *capcache_orangefs_default_attrs[] = {
&capcache_hard_limit_attribute.attr,
......@@ -1630,34 +928,33 @@ static struct attribute *capcache_orangefs_default_attrs[] = {
};
static struct kobj_type capcache_orangefs_ktype = {
.sysfs_ops = &capcache_orangefs_sysfs_ops,
.release = capcache_orangefs_release,
.sysfs_ops = &orangefs_sysfs_ops,
.default_attrs = capcache_orangefs_default_attrs,
};
static struct ccache_orangefs_attribute ccache_hard_limit_attribute =
static struct orangefs_attribute ccache_hard_limit_attribute =
__ATTR(hard_limit,
0664,
service_ccache_show,
service_ccache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct ccache_orangefs_attribute ccache_reclaim_percent_attribute =
static struct orangefs_attribute ccache_reclaim_percent_attribute =
__ATTR(reclaim_percentage,
0664,
service_ccache_show,
service_ccache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct ccache_orangefs_attribute ccache_soft_limit_attribute =
static struct orangefs_attribute ccache_soft_limit_attribute =
__ATTR(soft_limit,
0664,
service_ccache_show,
service_ccache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct ccache_orangefs_attribute ccache_timeout_secs_attribute =
static struct orangefs_attribute ccache_timeout_secs_attribute =
__ATTR(timeout_secs,
0664,
service_ccache_show,
service_ccache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct attribute *ccache_orangefs_default_attrs[] = {
&ccache_hard_limit_attribute.attr,
......@@ -1668,34 +965,33 @@ static struct attribute *ccache_orangefs_default_attrs[] = {
};
static struct kobj_type ccache_orangefs_ktype = {
.sysfs_ops = &ccache_orangefs_sysfs_ops,
.release = ccache_orangefs_release,
.sysfs_ops = &orangefs_sysfs_ops,
.default_attrs = ccache_orangefs_default_attrs,
};
static struct ncache_orangefs_attribute ncache_hard_limit_attribute =
static struct orangefs_attribute ncache_hard_limit_attribute =
__ATTR(hard_limit,
0664,
service_ncache_show,
service_ncache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct ncache_orangefs_attribute ncache_reclaim_percent_attribute =
static struct orangefs_attribute ncache_reclaim_percent_attribute =
__ATTR(reclaim_percentage,
0664,
service_ncache_show,
service_ncache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct ncache_orangefs_attribute ncache_soft_limit_attribute =
static struct orangefs_attribute ncache_soft_limit_attribute =
__ATTR(soft_limit,
0664,
service_ncache_show,
service_ncache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct ncache_orangefs_attribute ncache_timeout_msecs_attribute =
static struct orangefs_attribute ncache_timeout_msecs_attribute =
__ATTR(timeout_msecs,
0664,
service_ncache_show,
service_ncache_store);
sysfs_service_op_show,
sysfs_service_op_store);
static struct attribute *ncache_orangefs_default_attrs[] = {
&ncache_hard_limit_attribute.attr,
......@@ -1706,27 +1002,26 @@ static struct attribute *ncache_orangefs_default_attrs[] = {
};
static struct kobj_type ncache_orangefs_ktype = {
.sysfs_ops = &ncache_orangefs_sysfs_ops,
.release = ncache_orangefs_release,
.sysfs_ops = &orangefs_sysfs_ops,
.default_attrs = ncache_orangefs_default_attrs,
};
static struct pc_orangefs_attribute pc_acache_attribute =
static struct orangefs_attribute pc_acache_attribute =
__ATTR(acache,
0664,
service_pc_show,
sysfs_service_op_show,
NULL);
static struct pc_orangefs_attribute pc_capcache_attribute =
static struct orangefs_attribute pc_capcache_attribute =
__ATTR(capcache,
0664,
service_pc_show,
sysfs_service_op_show,
NULL);
static struct pc_orangefs_attribute pc_ncache_attribute =
static struct orangefs_attribute pc_ncache_attribute =
__ATTR(ncache,
0664,
service_pc_show,
sysfs_service_op_show,
NULL);
static struct attribute *pc_orangefs_default_attrs[] = {
......@@ -1737,21 +1032,20 @@ static struct attribute *pc_orangefs_default_attrs[] = {
};
static struct kobj_type pc_orangefs_ktype = {
.sysfs_ops = &pc_orangefs_sysfs_ops,
.release = pc_orangefs_release,
.sysfs_ops = &orangefs_sysfs_ops,
.default_attrs = pc_orangefs_default_attrs,
};
static struct stats_orangefs_attribute stats_reads_attribute =
static struct orangefs_attribute stats_reads_attribute =
__ATTR(reads,
0664,
int_stats_show,
sysfs_int_show,
NULL);
static struct stats_orangefs_attribute stats_writes_attribute =
static struct orangefs_attribute stats_writes_attribute =
__ATTR(writes,
0664,
int_stats_show,
sysfs_int_show,
NULL);
static struct attribute *stats_orangefs_default_attrs[] = {
......@@ -1761,18 +1055,17 @@ static struct attribute *stats_orangefs_default_attrs[] = {
};
static struct kobj_type stats_orangefs_ktype = {
.sysfs_ops = &stats_orangefs_sysfs_ops,
.release = stats_orangefs_release,
.sysfs_ops = &orangefs_sysfs_ops,
.default_attrs = stats_orangefs_default_attrs,
};
static struct orangefs_obj *orangefs_obj;
static struct acache_orangefs_obj *acache_orangefs_obj;
static struct capcache_orangefs_obj *capcache_orangefs_obj;
static struct ccache_orangefs_obj *ccache_orangefs_obj;
static struct ncache_orangefs_obj *ncache_orangefs_obj;
static struct pc_orangefs_obj *pc_orangefs_obj;
static struct stats_orangefs_obj *stats_orangefs_obj;
static struct kobject *orangefs_obj;
static struct kobject *acache_orangefs_obj;
static struct kobject *capcache_orangefs_obj;
static struct kobject *ccache_orangefs_obj;
static struct kobject *ncache_orangefs_obj;
static struct kobject *pc_orangefs_obj;
static struct kobject *stats_orangefs_obj;
int orangefs_sysfs_init(void)
{
......@@ -1785,7 +1078,7 @@ int orangefs_sysfs_init(void)
if (!orangefs_obj)
goto out;
rc = kobject_init_and_add(&orangefs_obj->kobj,
rc = kobject_init_and_add(orangefs_obj,
&orangefs_ktype,
fs_kobj,
ORANGEFS_KOBJ_ID);
......@@ -1793,7 +1086,7 @@ int orangefs_sysfs_init(void)
if (rc)
goto ofs_obj_bail;
kobject_uevent(&orangefs_obj->kobj, KOBJ_ADD);
kobject_uevent(orangefs_obj, KOBJ_ADD);
/* create /sys/fs/orangefs/acache. */
acache_orangefs_obj = kzalloc(sizeof(*acache_orangefs_obj), GFP_KERNEL);
......@@ -1802,15 +1095,15 @@ int orangefs_sysfs_init(void)
goto ofs_obj_bail;
}
rc = kobject_init_and_add(&acache_orangefs_obj->kobj,
rc = kobject_init_and_add(acache_orangefs_obj,
&acache_orangefs_ktype,
&orangefs_obj->kobj,
orangefs_obj,
ACACHE_KOBJ_ID);
if (rc)
goto acache_obj_bail;
kobject_uevent(&acache_orangefs_obj->kobj, KOBJ_ADD);
kobject_uevent(acache_orangefs_obj, KOBJ_ADD);
/* create /sys/fs/orangefs/capcache. */
capcache_orangefs_obj =
......@@ -1820,14 +1113,14 @@ int orangefs_sysfs_init(void)
goto acache_obj_bail;
}
rc = kobject_init_and_add(&capcache_orangefs_obj->kobj,
rc = kobject_init_and_add(capcache_orangefs_obj,
&capcache_orangefs_ktype,
&orangefs_obj->kobj,
orangefs_obj,
CAPCACHE_KOBJ_ID);
if (rc)
goto capcache_obj_bail;
kobject_uevent(&capcache_orangefs_obj->kobj, KOBJ_ADD);
kobject_uevent(capcache_orangefs_obj, KOBJ_ADD);
/* create /sys/fs/orangefs/ccache. */
ccache_orangefs_obj =
......@@ -1837,14 +1130,14 @@ int orangefs_sysfs_init(void)
goto capcache_obj_bail;
}
rc = kobject_init_and_add(&ccache_orangefs_obj->kobj,
rc = kobject_init_and_add(ccache_orangefs_obj,
&ccache_orangefs_ktype,
&orangefs_obj->kobj,
orangefs_obj,
CCACHE_KOBJ_ID);
if (rc)
goto ccache_obj_bail;
kobject_uevent(&ccache_orangefs_obj->kobj, KOBJ_ADD);
kobject_uevent(ccache_orangefs_obj, KOBJ_ADD);
/* create /sys/fs/orangefs/ncache. */
ncache_orangefs_obj = kzalloc(sizeof(*ncache_orangefs_obj), GFP_KERNEL);
......@@ -1853,15 +1146,15 @@ int orangefs_sysfs_init(void)
goto ccache_obj_bail;
}
rc = kobject_init_and_add(&ncache_orangefs_obj->kobj,
rc = kobject_init_and_add(ncache_orangefs_obj,
&ncache_orangefs_ktype,
&orangefs_obj->kobj,
orangefs_obj,
NCACHE_KOBJ_ID);
if (rc)
goto ncache_obj_bail;
kobject_uevent(&ncache_orangefs_obj->kobj, KOBJ_ADD);
kobject_uevent(ncache_orangefs_obj, KOBJ_ADD);
/* create /sys/fs/orangefs/perf_counters. */
pc_orangefs_obj = kzalloc(sizeof(*pc_orangefs_obj), GFP_KERNEL);
......@@ -1870,15 +1163,15 @@ int orangefs_sysfs_init(void)
goto ncache_obj_bail;
}
rc = kobject_init_and_add(&pc_orangefs_obj->kobj,
rc = kobject_init_and_add(pc_orangefs_obj,
&pc_orangefs_ktype,
&orangefs_obj->kobj,
orangefs_obj,
"perf_counters");
if (rc)
goto pc_obj_bail;
kobject_uevent(&pc_orangefs_obj->kobj, KOBJ_ADD);
kobject_uevent(pc_orangefs_obj, KOBJ_ADD);
/* create /sys/fs/orangefs/stats. */
stats_orangefs_obj = kzalloc(sizeof(*stats_orangefs_obj), GFP_KERNEL);
......@@ -1887,37 +1180,31 @@ int orangefs_sysfs_init(void)
goto pc_obj_bail;
}
rc = kobject_init_and_add(&stats_orangefs_obj->kobj,
rc = kobject_init_and_add(stats_orangefs_obj,
&stats_orangefs_ktype,
&orangefs_obj->kobj,
orangefs_obj,
STATS_KOBJ_ID);
if (rc)
goto stats_obj_bail;
kobject_uevent(&stats_orangefs_obj->kobj, KOBJ_ADD);
kobject_uevent(stats_orangefs_obj, KOBJ_ADD);
goto out;
stats_obj_bail:
kobject_put(&stats_orangefs_obj->kobj);
kobject_put(stats_orangefs_obj);
pc_obj_bail:
kobject_put(&pc_orangefs_obj->kobj);
kobject_put(pc_orangefs_obj);
ncache_obj_bail:
kobject_put(&ncache_orangefs_obj->kobj);
kobject_put(ncache_orangefs_obj);
ccache_obj_bail:
kobject_put(&ccache_orangefs_obj->kobj);
kobject_put(ccache_orangefs_obj);
capcache_obj_bail:
kobject_put(&capcache_orangefs_obj->kobj);
kobject_put(capcache_orangefs_obj);
acache_obj_bail:
kobject_put(&acache_orangefs_obj->kobj);
kobject_put(acache_orangefs_obj);
ofs_obj_bail:
kobject_put(&orangefs_obj->kobj);
kobject_put(orangefs_obj);
out:
return rc;
}
......@@ -1925,13 +1212,11 @@ int orangefs_sysfs_init(void)
void orangefs_sysfs_exit(void)
{
gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_exit: start\n");
kobject_put(&acache_orangefs_obj->kobj);
kobject_put(&capcache_orangefs_obj->kobj);
kobject_put(&ccache_orangefs_obj->kobj);
kobject_put(&ncache_orangefs_obj->kobj);
kobject_put(&pc_orangefs_obj->kobj);
kobject_put(&stats_orangefs_obj->kobj);
kobject_put(&orangefs_obj->kobj);
kobject_put(acache_orangefs_obj);
kobject_put(capcache_orangefs_obj);
kobject_put(ccache_orangefs_obj);
kobject_put(ncache_orangefs_obj);
kobject_put(pc_orangefs_obj);
kobject_put(stats_orangefs_obj);
kobject_put(orangefs_obj);
}
fs/orangefs/orangefs-utils.c
View file @ b78b1198
......@@ -347,7 +347,8 @@ int orangefs_inode_getattr(struct inode *inode, int new, int bypass)
inode->i_mode = type | (is_root_handle(inode) ? S_ISVTX : 0) |
orangefs_inode_perms(&new_op->downcall.resp.getattr.attributes);
orangefs_inode->getattr_time = jiffies + getattr_timeout_msecs*HZ/1000;
orangefs_inode->getattr_time = jiffies +
orangefs_getattr_timeout_msecs*HZ/1000;
ret = 0;
out:
op_release(new_op);
......@@ -656,401 +657,3 @@ __s32 ORANGEFS_util_translate_mode(int mode)
return ret;
}
#undef NUM_MODES
/*
* After obtaining a string representation of the client's debug
* keywords and their associated masks, this function is called to build an
* array of these values.
*/
int orangefs_prepare_cdm_array(char *debug_array_string)
{
int i;
int rc = -EINVAL;
char *cds_head = NULL;
char *cds_delimiter = NULL;
int keyword_len = 0;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
/*
* figure out how many elements the cdm_array needs.
*/
for (i = 0; i < strlen(debug_array_string); i++)
if (debug_array_string[i] == '\n')
cdm_element_count++;
if (!cdm_element_count) {
pr_info("No elements in client debug array string!\n");
goto out;
}
cdm_array =
kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
GFP_KERNEL);
if (!cdm_array) {
pr_info("malloc failed for cdm_array!\n");
rc = -ENOMEM;
goto out;
}
cds_head = debug_array_string;
for (i = 0; i < cdm_element_count; i++) {
cds_delimiter = strchr(cds_head, '\n');
*cds_delimiter = '\0';
keyword_len = strcspn(cds_head, " ");
cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
if (!cdm_array[i].keyword) {
rc = -ENOMEM;
goto out;
}
sscanf(cds_head,
"%s %llx %llx",
cdm_array[i].keyword,
(unsigned long long *)&(cdm_array[i].mask1),
(unsigned long long *)&(cdm_array[i].mask2));
if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
client_verbose_index = i;
if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
client_all_index = i;
cds_head = cds_delimiter + 1;
}
rc = cdm_element_count;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
out:
return rc;
}
/*
* /sys/kernel/debug/orangefs/debug-help can be catted to
* see all the available kernel and client debug keywords.
*
* When the kernel boots, we have no idea what keywords the
* client supports, nor their associated masks.
*
* We pass through this function once at boot and stamp a
* boilerplate "we don't know" message for the client in the
* debug-help file. We pass through here again when the client
* starts and then we can fill out the debug-help file fully.
*
* The client might be restarted any number of times between
* reboots, we only build the debug-help file the first time.
*/
int orangefs_prepare_debugfs_help_string(int at_boot)
{
int rc = -EINVAL;
int i;
int byte_count = 0;
char *client_title = "Client Debug Keywords:\n";
char *kernel_title = "Kernel Debug Keywords:\n";
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
if (at_boot) {
byte_count += strlen(HELP_STRING_UNINITIALIZED);
client_title = HELP_STRING_UNINITIALIZED;
} else {
/*
* fill the client keyword/mask array and remember
* how many elements there were.
*/
cdm_element_count =
orangefs_prepare_cdm_array(client_debug_array_string);
if (cdm_element_count <= 0)
goto out;
/* Count the bytes destined for debug_help_string. */
byte_count += strlen(client_title);
for (i = 0; i < cdm_element_count; i++) {
byte_count += strlen(cdm_array[i].keyword + 2);
if (byte_count >= DEBUG_HELP_STRING_SIZE) {
pr_info("%s: overflow 1!\n", __func__);
goto out;
}
}
gossip_debug(GOSSIP_UTILS_DEBUG,
"%s: cdm_element_count:%d:\n",
__func__,
cdm_element_count);
}
byte_count += strlen(kernel_title);
for (i = 0; i < num_kmod_keyword_mask_map; i++) {
byte_count +=
strlen(s_kmod_keyword_mask_map[i].keyword + 2);
if (byte_count >= DEBUG_HELP_STRING_SIZE) {
pr_info("%s: overflow 2!\n", __func__);
goto out;
}
}
/* build debug_help_string. */
debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
if (!debug_help_string) {
rc = -ENOMEM;
goto out;
}
strcat(debug_help_string, client_title);
if (!at_boot) {
for (i = 0; i < cdm_element_count; i++) {
strcat(debug_help_string, "\t");
strcat(debug_help_string, cdm_array[i].keyword);
strcat(debug_help_string, "\n");
}
}
strcat(debug_help_string, "\n");
strcat(debug_help_string, kernel_title);
for (i = 0; i < num_kmod_keyword_mask_map; i++) {
strcat(debug_help_string, "\t");
strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword);
strcat(debug_help_string, "\n");
}
rc = 0;
out:
return rc;
}
/*
* kernel = type 0
* client = type 1
*/
void debug_mask_to_string(void *mask, int type)
{
int i;
int len = 0;
char *debug_string;
int element_count = 0;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
if (type) {
debug_string = client_debug_string;
element_count = cdm_element_count;
} else {
debug_string = kernel_debug_string;
element_count = num_kmod_keyword_mask_map;
}
memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
/*
* Some keywords, like "all" or "verbose", are amalgams of
* numerous other keywords. Make a special check for those
* before grinding through the whole mask only to find out
* later...
*/
if (check_amalgam_keyword(mask, type))
goto out;
/* Build the debug string. */
for (i = 0; i < element_count; i++)
if (type)
do_c_string(mask, i);
else
do_k_string(mask, i);
len = strlen(debug_string);
if ((len) && (type))
client_debug_string[len - 1] = '\0';
else if (len)
kernel_debug_string[len - 1] = '\0';
else if (type)
strcpy(client_debug_string, "none");
else
strcpy(kernel_debug_string, "none");
out:
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
return;
}
void do_k_string(void *k_mask, int index)
{
__u64 *mask = (__u64 *) k_mask;
if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
goto out;
if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
if ((strlen(kernel_debug_string) +
strlen(s_kmod_keyword_mask_map[index].keyword))
< ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
strcat(kernel_debug_string,
s_kmod_keyword_mask_map[index].keyword);
strcat(kernel_debug_string, ",");
} else {
gossip_err("%s: overflow!\n", __func__);
strcpy(kernel_debug_string, ORANGEFS_ALL);
goto out;
}
}
out:
return;
}
void do_c_string(void *c_mask, int index)
{
struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
if (keyword_is_amalgam(cdm_array[index].keyword))
goto out;
if ((mask->mask1 & cdm_array[index].mask1) ||
(mask->mask2 & cdm_array[index].mask2)) {
if ((strlen(client_debug_string) +
strlen(cdm_array[index].keyword) + 1)
< ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
strcat(client_debug_string,
cdm_array[index].keyword);
strcat(client_debug_string, ",");
} else {
gossip_err("%s: overflow!\n", __func__);
strcpy(client_debug_string, ORANGEFS_ALL);
goto out;
}
}
out:
return;
}
int keyword_is_amalgam(char *keyword)
{
int rc = 0;
if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
rc = 1;
return rc;
}
/*
* kernel = type 0
* client = type 1
*
* return 1 if we found an amalgam.
*/
int check_amalgam_keyword(void *mask, int type)
{
__u64 *k_mask;
struct client_debug_mask *c_mask;
int k_all_index = num_kmod_keyword_mask_map - 1;
int rc = 0;
if (type) {
c_mask = (struct client_debug_mask *) mask;
if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
(c_mask->mask2 == cdm_array[client_all_index].mask2)) {
strcpy(client_debug_string, ORANGEFS_ALL);
rc = 1;
goto out;
}
if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
(c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
strcpy(client_debug_string, ORANGEFS_VERBOSE);
rc = 1;
goto out;
}
} else {
k_mask = (__u64 *) mask;
if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
strcpy(kernel_debug_string, ORANGEFS_ALL);
rc = 1;
goto out;
}
}
out:
return rc;
}
/*
* kernel = type 0
* client = type 1
*/
void debug_string_to_mask(char *debug_string, void *mask, int type)
{
char *unchecked_keyword;
int i;
char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
char *original_pointer;
int element_count = 0;
struct client_debug_mask *c_mask;
__u64 *k_mask;
gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
if (type) {
c_mask = (struct client_debug_mask *)mask;
element_count = cdm_element_count;
} else {
k_mask = (__u64 *)mask;
*k_mask = 0;
element_count = num_kmod_keyword_mask_map;
}
original_pointer = strsep_fodder;
while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
if (strlen(unchecked_keyword)) {
for (i = 0; i < element_count; i++)
if (type)
do_c_mask(i,
unchecked_keyword,
&c_mask);
else
do_k_mask(i,
unchecked_keyword,
&k_mask);
}
kfree(original_pointer);
}
void do_c_mask(int i,
char *unchecked_keyword,
struct client_debug_mask **sane_mask)
{
if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
(**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
(**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
}
}
void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
{
if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
**sane_mask = (**sane_mask) |
s_kmod_keyword_mask_map[i].mask_val;
}
fs/orangefs/protocol.h
View file @ b78b1198
......@@ -4,26 +4,6 @@
#include <linux/slab.h>
#include <linux/ioctl.h>
extern struct client_debug_mask *cdm_array;
extern char *debug_help_string;
extern int help_string_initialized;
extern struct dentry *debug_dir;
extern struct dentry *help_file_dentry;
extern struct dentry *client_debug_dentry;
extern const struct file_operations debug_help_fops;
extern int client_all_index;
extern int client_verbose_index;
extern int cdm_element_count;
#define DEBUG_HELP_STRING_SIZE 4096
#define HELP_STRING_UNINITIALIZED \
"Client Debug Keywords are unknown until the first time\n" \
"the client is started after boot.\n"
#define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help"
#define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug"
#define ORANGEFS_CLIENT_DEBUG_FILE "client-debug"
#define ORANGEFS_VERBOSE "verbose"
#define ORANGEFS_ALL "all"
/* pvfs2-config.h ***********************************************************/
#define ORANGEFS_VERSION_MAJOR 2
#define ORANGEFS_VERSION_MINOR 9
......@@ -426,13 +406,12 @@ do { \
printk(KERN_DEBUG fmt, ##__VA_ARGS__); \
} while (0)
#else
extern __u64 gossip_debug_mask;
extern struct client_debug_mask client_debug_mask;
extern __u64 orangefs_gossip_debug_mask;
/* try to avoid function call overhead by checking masks in macro */
#define gossip_debug(mask, fmt, ...) \
do { \
if (gossip_debug_mask & (mask)) \
if (orangefs_gossip_debug_mask & (mask)) \
printk(KERN_DEBUG fmt, ##__VA_ARGS__); \
} while (0)
#endif /* GOSSIP_DISABLE_DEBUG */
......
fs/orangefs/super.c
View file @ b78b1198
......@@ -557,8 +557,8 @@ void orangefs_kill_sb(struct super_block *sb)
* make sure that ORANGEFS_DEV_REMOUNT_ALL loop that might've seen us
* gets completed before we free the dang thing.
*/
mutex_lock(&request_mutex);
mutex_unlock(&request_mutex);
mutex_lock(&orangefs_request_mutex);
mutex_unlock(&orangefs_request_mutex);
/* free the orangefs superblock private data */
kfree(ORANGEFS_SB(sb));
......
fs/orangefs/waitqueue.c
View file @ b78b1198
......@@ -87,9 +87,9 @@ int service_operation(struct orangefs_kernel_op_s *op,
*/
if (!(flags & ORANGEFS_OP_NO_MUTEX)) {
if (flags & ORANGEFS_OP_INTERRUPTIBLE)
ret = mutex_lock_interruptible(&request_mutex);
ret = mutex_lock_interruptible(&orangefs_request_mutex);
else
ret = mutex_lock_killable(&request_mutex);
ret = mutex_lock_killable(&orangefs_request_mutex);
/*
* check to see if we were interrupted while waiting for
* mutex
......@@ -129,7 +129,7 @@ int service_operation(struct orangefs_kernel_op_s *op,
spin_unlock(&orangefs_request_list_lock);
if (!(flags & ORANGEFS_OP_NO_MUTEX))
mutex_unlock(&request_mutex);
mutex_unlock(&orangefs_request_mutex);
ret = wait_for_matching_downcall(op, timeout,
flags & ORANGEFS_OP_INTERRUPTIBLE);
......@@ -272,9 +272,9 @@ static void
} else if (op_state_in_progress(op)) {
/* op must be removed from the in progress htable */
spin_unlock(&op->lock);
spin_lock(&htable_ops_in_progress_lock);
spin_lock(&orangefs_htable_ops_in_progress_lock);
list_del_init(&op->list);
spin_unlock(&htable_ops_in_progress_lock);
spin_unlock(&orangefs_htable_ops_in_progress_lock);
gossip_debug(GOSSIP_WAIT_DEBUG,
"Interrupted: Removed op %p"
" from htable_ops_in_progress\n",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7