| /* |
| * 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 = |
| kzalloc(cdm_element_count * sizeof(struct client_debug_mask), |
| 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; |
| } |