// SPDX-License-Identifier: GPL-2.0 /* * What: /sys/kernel/debug/orangefs/debug-help * Date: June 2015 * Contact: Mike Marshall <hubcap@omnibond.com> * Description: * List of client and kernel debug keywords. * * * What: /sys/kernel/debug/orangefs/client-debug * Date: June 2015 * Contact: Mike Marshall <hubcap@omnibond.com> * Description: * Debug setting for "the client", the userspace * helper for the kernel module. * * * What: /sys/kernel/debug/orangefs/kernel-debug * Date: June 2015 * Contact: Mike Marshall <hubcap@omnibond.com> * Description: * Debug setting for the orangefs kernel module. * * Any of the keywords, or comma-separated lists * of keywords, from debug-help can be catted to * client-debug or kernel-debug. * * "none", "all" and "verbose" are special keywords * for client-debug. Setting client-debug to "all" * is kind of like trying to drink water from a * fire hose, "verbose" triggers most of the same * output except for the constant flow of output * from the main wait loop. * * "none" and "all" are similar settings for kernel-debug * no need for a "verbose". */ #include <linux/debugfs.h> #include <linux/slab.h> #include <linux/uaccess.h> #include "orangefs-debugfs.h" #include "protocol.h" #include "orangefs-kernel.h" #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" /* * 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 int orangefs_debug_open(struct inode *, struct file *); static ssize_t orangefs_debug_read(struct file *, char __user *, size_t, loff_t *); static ssize_t orangefs_debug_write(struct file *, const char __user *, 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 = { .owner = THIS_MODULE, .open = orangefs_debug_help_open, .read = seq_read, .release = seq_release, .llseek = seq_lseek, }; static const struct file_operations kernel_debug_fops = { .owner = THIS_MODULE, .open = orangefs_debug_open, .read = orangefs_debug_read, .write = orangefs_debug_write, .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); /* Used to protect data in ORANGEFS_KMOD_DEBUG_HELP_FILE */ static DEFINE_MUTEX(orangefs_help_file_lock); /* * initialize kmod debug operations, create orangefs debugfs dir and * ORANGEFS_KMOD_DEBUG_HELP_FILE. */ 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__); goto out; } help_file_dentry = debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE, 0444, debug_dir, debug_help_string, &debug_help_fops); if (!help_file_dentry) { pr_info("%s: debugfs_create_file failed.\n", __func__); goto out; } 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); } /* open ORANGEFS_KMOD_DEBUG_HELP_FILE */ static int orangefs_debug_help_open(struct inode *inode, struct file *file) { int rc = -ENODEV; int ret; gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_help_open: start\n"); if (orangefs_debug_disabled) goto out; ret = seq_open(file, &help_debug_ops); if (ret) goto out; ((struct seq_file *)(file->private_data))->private = inode->i_private; rc = 0; out: gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_help_open: rc:%d:\n", rc); return rc; } /* * I think start always gets called again after stop. Start * needs to return NULL when it is done. The whole "payload" * in this case is a single (long) string, so by the second * time we get to start (pos = 1), we're done. */ static void *help_start(struct seq_file *m, loff_t *pos) { void *payload = NULL; gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n"); mutex_lock(&orangefs_help_file_lock); if (*pos == 0) payload = m->private; return payload; } static void *help_next(struct seq_file *m, void *v, loff_t *pos) { gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_next: start\n"); return NULL; } static void help_stop(struct seq_file *m, void *p) { gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n"); mutex_unlock(&orangefs_help_file_lock); } static int help_show(struct seq_file *m, void *v) { gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_show: start\n"); seq_puts(m, v); return 0; } /* * initialize the client-debug file. */ int orangefs_client_debug_init(void) { int rc = -ENOMEM; char *c_buffer = NULL; gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__); c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL); if (!c_buffer) goto out; if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) { strcpy(c_buffer, client_debug_string); strcat(c_buffer, "\n"); } else { strcpy(c_buffer, "none\n"); pr_info("%s: overflow! 2\n", __func__); } client_debug_dentry = debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE, 0444, debug_dir, c_buffer, &kernel_debug_fops); if (!client_debug_dentry) { pr_info("%s: failed to create updated %s.\n", __func__, ORANGEFS_CLIENT_DEBUG_FILE); goto out; } rc = 0; out: gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc); return rc; } /* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/ static int orangefs_debug_open(struct inode *inode, struct file *file) { int rc = -ENODEV; gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: orangefs_debug_disabled: %d\n", __func__, orangefs_debug_disabled); if (orangefs_debug_disabled) goto out; rc = 0; mutex_lock(&orangefs_debug_lock); file->private_data = inode->i_private; mutex_unlock(&orangefs_debug_lock); out: gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_open: rc: %d\n", rc); return rc; } static ssize_t orangefs_debug_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { char *buf; int sprintf_ret; ssize_t read_ret = -ENOMEM; gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n"); buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL); if (!buf) goto out; mutex_lock(&orangefs_debug_lock); sprintf_ret = sprintf(buf, "%s", (char *)file->private_data); mutex_unlock(&orangefs_debug_lock); read_ret = simple_read_from_buffer(ubuf, count, ppos, buf, sprintf_ret); kfree(buf); out: gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: ret: %zu\n", read_ret); return read_ret; } static ssize_t orangefs_debug_write(struct file *file, const char __user *ubuf, size_t count, loff_t *ppos) { char *buf; int rc = -EFAULT; size_t silly = 0; char *debug_string; struct orangefs_kernel_op_s *new_op = NULL; struct client_debug_mask c_mask = { NULL, 0, 0 }; char *s; gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_write: %pD\n", file); if (count == 0) return 0; /* * Thwart users who try to jamb a ridiculous number * of bytes into the debug file... */ if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) { silly = count; count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1; } buf = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL); if (!buf) goto out; if (copy_from_user(buf, ubuf, count - 1)) { gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: copy_from_user failed!\n", __func__); goto out; } /* * Map the keyword string from userspace into a valid debug mask. * The mapping process involves mapping the human-inputted string * into a valid mask, and then rebuilding the string from the * verified valid mask. * * A service operation is required to set a new client-side * debug mask. */ if (!strcmp(file->f_path.dentry->d_name.name, ORANGEFS_KMOD_DEBUG_FILE)) { 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", kernel_debug_string); } else { /* Can't reset client debug mask if client is not running. */ if (is_daemon_in_service()) { pr_info("%s: Client not running :%d:\n", __func__, is_daemon_in_service()); goto out; } debug_string_to_mask(buf, &c_mask, 1); debug_mask_to_string(&c_mask, 1); debug_string = client_debug_string; new_op = op_alloc(ORANGEFS_VFS_OP_PARAM); if (!new_op) { pr_info("%s: op_alloc failed!\n", __func__); goto out; } new_op->upcall.req.param.op = ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES; new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET; memset(new_op->upcall.req.param.s_value, 0, ORANGEFS_MAX_DEBUG_STRING_LEN); sprintf(new_op->upcall.req.param.s_value, "%llx %llx\n", c_mask.mask1, c_mask.mask2); /* service_operation returns 0 on success... */ rc = service_operation(new_op, "orangefs_param", ORANGEFS_OP_INTERRUPTIBLE); if (rc) gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: service_operation failed! rc:%d:\n", __func__, rc); op_release(new_op); } mutex_lock(&orangefs_debug_lock); s = file_inode(file)->i_private; memset(s, 0, ORANGEFS_MAX_DEBUG_STRING_LEN); sprintf(s, "%s\n", debug_string); mutex_unlock(&orangefs_debug_lock); *ppos += count; if (silly) rc = silly; else rc = count; out: gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_write: rc: %d\n", rc); 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 = kcalloc(cdm_element_count, sizeof(*cdm_array), GFP_KERNEL); if (!cdm_array) { 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 orangefs.ko initializes, we have no idea what keywords the * client supports, nor their associated masks. * * We pass through this function once at module-load 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 * module reloads, we only build the debug-help file the first time. */ int orangefs_prepare_debugfs_help_string(int at_boot) { char *client_title = "Client Debug Keywords:\n"; char *kernel_title = "Kernel Debug Keywords:\n"; size_t string_size = DEBUG_HELP_STRING_SIZE; size_t result_size; size_t i; char *new; int rc = -EINVAL; gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__); if (at_boot) client_title = HELP_STRING_UNINITIALIZED; /* build a new debug_help_string. */ new = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL); if (!new) { rc = -ENOMEM; goto out; } /* * strlcat(dst, src, size) will append at most * "size - strlen(dst) - 1" bytes of src onto dst, * null terminating the result, and return the total * length of the string it tried to create. * * We'll just plow through here building our new debug * help string and let strlcat take care of assuring that * dst doesn't overflow. */ strlcat(new, client_title, string_size); if (!at_boot) { /* * 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) { kfree(new); goto out; } for (i = 0; i < cdm_element_count; i++) { strlcat(new, "\t", string_size); strlcat(new, cdm_array[i].keyword, string_size); strlcat(new, "\n", string_size); } } strlcat(new, "\n", string_size); strlcat(new, kernel_title, string_size); for (i = 0; i < num_kmod_keyword_mask_map; i++) { strlcat(new, "\t", string_size); strlcat(new, s_kmod_keyword_mask_map[i].keyword, string_size); result_size = strlcat(new, "\n", string_size); } /* See if we tried to put too many bytes into "new"... */ if (result_size >= string_size) { kfree(new); goto out; } if (at_boot) { debug_help_string = new; } else { mutex_lock(&orangefs_help_file_lock); memset(debug_help_string, 0, DEBUG_HELP_STRING_SIZE); strlcat(debug_help_string, new, string_size); mutex_unlock(&orangefs_help_file_lock); } 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) { pr_info("%s: CLIENT_STRING: copy_from_user failed\n", __func__); return -EFAULT; } /* * 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'; pr_info("%s: client debug array string has been received.\n", __func__); if (!help_string_initialized) { /* Build a proper debug help string. */ ret = orangefs_prepare_debugfs_help_string(0); if (ret) { gossip_err("%s: no debug help string \n", __func__); return ret; } } debug_mask_to_string(&client_debug_mask, 1); debugfs_remove(client_debug_dentry); orangefs_client_debug_init(); help_string_initialized++; return 0; } 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; }