1 // SPDX-License-Identifier: GPL-2.0
3 * What: /sys/kernel/debug/orangefs/debug-help
5 * Contact: Mike Marshall <hubcap@omnibond.com>
7 * List of client and kernel debug keywords.
10 * What: /sys/kernel/debug/orangefs/client-debug
12 * Contact: Mike Marshall <hubcap@omnibond.com>
14 * Debug setting for "the client", the userspace
15 * helper for the kernel module.
18 * What: /sys/kernel/debug/orangefs/kernel-debug
20 * Contact: Mike Marshall <hubcap@omnibond.com>
22 * Debug setting for the orangefs kernel module.
24 * Any of the keywords, or comma-separated lists
25 * of keywords, from debug-help can be catted to
26 * client-debug or kernel-debug.
28 * "none", "all" and "verbose" are special keywords
29 * for client-debug. Setting client-debug to "all"
30 * is kind of like trying to drink water from a
31 * fire hose, "verbose" triggers most of the same
32 * output except for the constant flow of output
33 * from the main wait loop.
35 * "none" and "all" are similar settings for kernel-debug
36 * no need for a "verbose".
38 #include <linux/debugfs.h>
39 #include <linux/slab.h>
41 #include <linux/uaccess.h>
43 #include "orangefs-debugfs.h"
45 #include "orangefs-kernel.h"
47 #define DEBUG_HELP_STRING_SIZE 4096
48 #define HELP_STRING_UNINITIALIZED \
49 "Client Debug Keywords are unknown until the first time\n" \
50 "the client is started after boot.\n"
51 #define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help"
52 #define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug"
53 #define ORANGEFS_CLIENT_DEBUG_FILE "client-debug"
54 #define ORANGEFS_VERBOSE "verbose"
55 #define ORANGEFS_ALL "all"
58 * An array of client_debug_mask will be built to hold debug keyword/mask
59 * values fetched from userspace.
61 struct client_debug_mask {
67 static void orangefs_kernel_debug_init(void);
69 static int orangefs_debug_help_open(struct inode *, struct file *);
70 static void *help_start(struct seq_file *, loff_t *);
71 static void *help_next(struct seq_file *, void *, loff_t *);
72 static void help_stop(struct seq_file *, void *);
73 static int help_show(struct seq_file *, void *);
75 static int orangefs_debug_open(struct inode *, struct file *);
77 static ssize_t orangefs_debug_read(struct file *,
82 static ssize_t orangefs_debug_write(struct file *,
87 static int orangefs_prepare_cdm_array(char *);
88 static void debug_mask_to_string(void *, int);
89 static void do_k_string(void *, int);
90 static void do_c_string(void *, int);
91 static int keyword_is_amalgam(char *);
92 static int check_amalgam_keyword(void *, int);
93 static void debug_string_to_mask(char *, void *, int);
94 static void do_c_mask(int, char *, struct client_debug_mask **);
95 static void do_k_mask(int, char *, __u64 **);
97 static char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN] = "none";
98 static char *debug_help_string;
99 static char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
100 static char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
102 static struct dentry *client_debug_dentry;
103 static struct dentry *debug_dir;
105 static unsigned int kernel_mask_set_mod_init;
106 static int orangefs_debug_disabled = 1;
107 static int help_string_initialized;
109 static const struct seq_operations help_debug_ops = {
116 static const struct file_operations debug_help_fops = {
117 .owner = THIS_MODULE,
118 .open = orangefs_debug_help_open,
120 .release = seq_release,
124 static const struct file_operations kernel_debug_fops = {
125 .owner = THIS_MODULE,
126 .open = orangefs_debug_open,
127 .read = orangefs_debug_read,
128 .write = orangefs_debug_write,
129 .llseek = generic_file_llseek,
132 static int client_all_index;
133 static int client_verbose_index;
135 static struct client_debug_mask *cdm_array;
136 static int cdm_element_count;
138 static struct client_debug_mask client_debug_mask;
141 * Used to protect data in ORANGEFS_KMOD_DEBUG_FILE and
142 * ORANGEFS_KMOD_DEBUG_FILE.
144 static DEFINE_MUTEX(orangefs_debug_lock);
146 /* Used to protect data in ORANGEFS_KMOD_DEBUG_HELP_FILE */
147 static DEFINE_MUTEX(orangefs_help_file_lock);
150 * initialize kmod debug operations, create orangefs debugfs dir and
151 * ORANGEFS_KMOD_DEBUG_HELP_FILE.
153 void orangefs_debugfs_init(int debug_mask)
155 /* convert input debug mask to a 64-bit unsigned integer */
156 orangefs_gossip_debug_mask = (unsigned long long)debug_mask;
159 * set the kernel's gossip debug string; invalid mask values will
162 debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
164 /* remove any invalid values from the mask */
165 debug_string_to_mask(kernel_debug_string, &orangefs_gossip_debug_mask,
169 * if the mask has a non-zero value, then indicate that the mask
170 * was set when the kernel module was loaded. The orangefs dev ioctl
171 * command will look at this boolean to determine if the kernel's
172 * debug mask should be overwritten when the client-core is started.
174 if (orangefs_gossip_debug_mask != 0)
175 kernel_mask_set_mod_init = true;
177 pr_info("%s: called with debug mask: :%s: :%llx:\n",
180 (unsigned long long)orangefs_gossip_debug_mask);
182 debug_dir = debugfs_create_dir("orangefs", NULL);
184 debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE, 0444, debug_dir,
185 debug_help_string, &debug_help_fops);
187 orangefs_debug_disabled = 0;
189 orangefs_kernel_debug_init();
193 * initialize the kernel-debug file.
195 static void orangefs_kernel_debug_init(void)
198 char *k_buffer = NULL;
200 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
202 k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
206 if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
207 strcpy(k_buffer, kernel_debug_string);
208 strcat(k_buffer, "\n");
210 strcpy(k_buffer, "none\n");
211 pr_info("%s: overflow 1!\n", __func__);
214 debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE, 0444, debug_dir, k_buffer,
218 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
222 void orangefs_debugfs_cleanup(void)
224 debugfs_remove_recursive(debug_dir);
227 /* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
228 static int orangefs_debug_help_open(struct inode *inode, struct file *file)
233 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
234 "orangefs_debug_help_open: start\n");
236 if (orangefs_debug_disabled)
239 ret = seq_open(file, &help_debug_ops);
243 ((struct seq_file *)(file->private_data))->private = inode->i_private;
248 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
249 "orangefs_debug_help_open: rc:%d:\n",
255 * I think start always gets called again after stop. Start
256 * needs to return NULL when it is done. The whole "payload"
257 * in this case is a single (long) string, so by the second
258 * time we get to start (pos = 1), we're done.
260 static void *help_start(struct seq_file *m, loff_t *pos)
262 void *payload = NULL;
264 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n");
266 mutex_lock(&orangefs_help_file_lock);
269 payload = m->private;
274 static void *help_next(struct seq_file *m, void *v, loff_t *pos)
276 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_next: start\n");
281 static void help_stop(struct seq_file *m, void *p)
283 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n");
284 mutex_unlock(&orangefs_help_file_lock);
287 static int help_show(struct seq_file *m, void *v)
289 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_show: start\n");
297 * initialize the client-debug file.
299 static int orangefs_client_debug_init(void)
303 char *c_buffer = NULL;
305 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
307 c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
311 if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
312 strcpy(c_buffer, client_debug_string);
313 strcat(c_buffer, "\n");
315 strcpy(c_buffer, "none\n");
316 pr_info("%s: overflow! 2\n", __func__);
319 client_debug_dentry = debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE,
329 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
333 /* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
334 static int orangefs_debug_open(struct inode *inode, struct file *file)
338 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
339 "%s: orangefs_debug_disabled: %d\n",
341 orangefs_debug_disabled);
343 if (orangefs_debug_disabled)
347 mutex_lock(&orangefs_debug_lock);
348 file->private_data = inode->i_private;
349 mutex_unlock(&orangefs_debug_lock);
352 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
353 "orangefs_debug_open: rc: %d\n",
358 static ssize_t orangefs_debug_read(struct file *file,
365 ssize_t read_ret = -ENOMEM;
367 gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");
369 buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
373 mutex_lock(&orangefs_debug_lock);
374 sprintf_ret = sprintf(buf, "%s", (char *)file->private_data);
375 mutex_unlock(&orangefs_debug_lock);
377 read_ret = simple_read_from_buffer(ubuf, count, ppos, buf, sprintf_ret);
382 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
383 "orangefs_debug_read: ret: %zu\n",
389 static ssize_t orangefs_debug_write(struct file *file,
390 const char __user *ubuf,
398 struct orangefs_kernel_op_s *new_op = NULL;
399 struct client_debug_mask c_mask = { NULL, 0, 0 };
402 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
403 "orangefs_debug_write: %pD\n",
410 * Thwart users who try to jamb a ridiculous number
411 * of bytes into the debug file...
413 if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) {
415 count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1;
418 buf = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
422 if (copy_from_user(buf, ubuf, count - 1)) {
423 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
424 "%s: copy_from_user failed!\n",
430 * Map the keyword string from userspace into a valid debug mask.
431 * The mapping process involves mapping the human-inputted string
432 * into a valid mask, and then rebuilding the string from the
433 * verified valid mask.
435 * A service operation is required to set a new client-side
438 if (!strcmp(file->f_path.dentry->d_name.name,
439 ORANGEFS_KMOD_DEBUG_FILE)) {
440 debug_string_to_mask(buf, &orangefs_gossip_debug_mask, 0);
441 debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
442 debug_string = kernel_debug_string;
443 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
444 "New kernel debug string is %s\n",
445 kernel_debug_string);
447 /* Can't reset client debug mask if client is not running. */
448 if (is_daemon_in_service()) {
449 pr_info("%s: Client not running :%d:\n",
451 is_daemon_in_service());
455 debug_string_to_mask(buf, &c_mask, 1);
456 debug_mask_to_string(&c_mask, 1);
457 debug_string = client_debug_string;
459 new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
461 pr_info("%s: op_alloc failed!\n", __func__);
465 new_op->upcall.req.param.op =
466 ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES;
467 new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
468 memset(new_op->upcall.req.param.s_value,
470 ORANGEFS_MAX_DEBUG_STRING_LEN);
471 sprintf(new_op->upcall.req.param.s_value,
476 /* service_operation returns 0 on success... */
477 rc = service_operation(new_op,
479 ORANGEFS_OP_INTERRUPTIBLE);
482 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
483 "%s: service_operation failed! rc:%d:\n",
490 mutex_lock(&orangefs_debug_lock);
491 s = file_inode(file)->i_private;
492 memset(s, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
493 sprintf(s, "%s\n", debug_string);
494 mutex_unlock(&orangefs_debug_lock);
503 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
504 "orangefs_debug_write: rc: %d\n",
511 * After obtaining a string representation of the client's debug
512 * keywords and their associated masks, this function is called to build an
513 * array of these values.
515 static int orangefs_prepare_cdm_array(char *debug_array_string)
519 char *cds_head = NULL;
520 char *cds_delimiter = NULL;
523 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
526 * figure out how many elements the cdm_array needs.
528 for (i = 0; i < strlen(debug_array_string); i++)
529 if (debug_array_string[i] == '\n')
532 if (!cdm_element_count) {
533 pr_info("No elements in client debug array string!\n");
537 cdm_array = kcalloc(cdm_element_count, sizeof(*cdm_array), GFP_KERNEL);
543 cds_head = debug_array_string;
545 for (i = 0; i < cdm_element_count; i++) {
546 cds_delimiter = strchr(cds_head, '\n');
547 *cds_delimiter = '\0';
549 keyword_len = strcspn(cds_head, " ");
551 cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
552 if (!cdm_array[i].keyword) {
559 cdm_array[i].keyword,
560 (unsigned long long *)&(cdm_array[i].mask1),
561 (unsigned long long *)&(cdm_array[i].mask2));
563 if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
564 client_verbose_index = i;
566 if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
567 client_all_index = i;
569 cds_head = cds_delimiter + 1;
572 rc = cdm_element_count;
574 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
583 * /sys/kernel/debug/orangefs/debug-help can be catted to
584 * see all the available kernel and client debug keywords.
586 * When orangefs.ko initializes, we have no idea what keywords the
587 * client supports, nor their associated masks.
589 * We pass through this function once at module-load and stamp a
590 * boilerplate "we don't know" message for the client in the
591 * debug-help file. We pass through here again when the client
592 * starts and then we can fill out the debug-help file fully.
594 * The client might be restarted any number of times between
595 * module reloads, we only build the debug-help file the first time.
597 int orangefs_prepare_debugfs_help_string(int at_boot)
599 char *client_title = "Client Debug Keywords:\n";
600 char *kernel_title = "Kernel Debug Keywords:\n";
601 size_t string_size = DEBUG_HELP_STRING_SIZE;
607 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
610 client_title = HELP_STRING_UNINITIALIZED;
612 /* build a new debug_help_string. */
613 new = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
620 * strlcat(dst, src, size) will append at most
621 * "size - strlen(dst) - 1" bytes of src onto dst,
622 * null terminating the result, and return the total
623 * length of the string it tried to create.
625 * We'll just plow through here building our new debug
626 * help string and let strlcat take care of assuring that
627 * dst doesn't overflow.
629 strlcat(new, client_title, string_size);
634 * fill the client keyword/mask array and remember
635 * how many elements there were.
638 orangefs_prepare_cdm_array(client_debug_array_string);
639 if (cdm_element_count <= 0) {
644 for (i = 0; i < cdm_element_count; i++) {
645 strlcat(new, "\t", string_size);
646 strlcat(new, cdm_array[i].keyword, string_size);
647 strlcat(new, "\n", string_size);
651 strlcat(new, "\n", string_size);
652 strlcat(new, kernel_title, string_size);
654 for (i = 0; i < num_kmod_keyword_mask_map; i++) {
655 strlcat(new, "\t", string_size);
656 strlcat(new, s_kmod_keyword_mask_map[i].keyword, string_size);
657 result_size = strlcat(new, "\n", string_size);
660 /* See if we tried to put too many bytes into "new"... */
661 if (result_size >= string_size) {
667 debug_help_string = new;
669 mutex_lock(&orangefs_help_file_lock);
670 memset(debug_help_string, 0, DEBUG_HELP_STRING_SIZE);
671 strlcat(debug_help_string, new, string_size);
672 mutex_unlock(&orangefs_help_file_lock);
685 static void debug_mask_to_string(void *mask, int type)
690 int element_count = 0;
692 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
695 debug_string = client_debug_string;
696 element_count = cdm_element_count;
698 debug_string = kernel_debug_string;
699 element_count = num_kmod_keyword_mask_map;
702 memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
705 * Some keywords, like "all" or "verbose", are amalgams of
706 * numerous other keywords. Make a special check for those
707 * before grinding through the whole mask only to find out
710 if (check_amalgam_keyword(mask, type))
713 /* Build the debug string. */
714 for (i = 0; i < element_count; i++)
716 do_c_string(mask, i);
718 do_k_string(mask, i);
720 len = strlen(debug_string);
723 client_debug_string[len - 1] = '\0';
725 kernel_debug_string[len - 1] = '\0';
727 strcpy(client_debug_string, "none");
729 strcpy(kernel_debug_string, "none");
732 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
738 static void do_k_string(void *k_mask, int index)
740 __u64 *mask = (__u64 *) k_mask;
742 if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
745 if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
746 if ((strlen(kernel_debug_string) +
747 strlen(s_kmod_keyword_mask_map[index].keyword))
748 < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
749 strcat(kernel_debug_string,
750 s_kmod_keyword_mask_map[index].keyword);
751 strcat(kernel_debug_string, ",");
753 gossip_err("%s: overflow!\n", __func__);
754 strcpy(kernel_debug_string, ORANGEFS_ALL);
764 static void do_c_string(void *c_mask, int index)
766 struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
768 if (keyword_is_amalgam(cdm_array[index].keyword))
771 if ((mask->mask1 & cdm_array[index].mask1) ||
772 (mask->mask2 & cdm_array[index].mask2)) {
773 if ((strlen(client_debug_string) +
774 strlen(cdm_array[index].keyword) + 1)
775 < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
776 strcat(client_debug_string,
777 cdm_array[index].keyword);
778 strcat(client_debug_string, ",");
780 gossip_err("%s: overflow!\n", __func__);
781 strcpy(client_debug_string, ORANGEFS_ALL);
789 static int keyword_is_amalgam(char *keyword)
793 if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
803 * return 1 if we found an amalgam.
805 static int check_amalgam_keyword(void *mask, int type)
808 struct client_debug_mask *c_mask;
809 int k_all_index = num_kmod_keyword_mask_map - 1;
813 c_mask = (struct client_debug_mask *) mask;
815 if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
816 (c_mask->mask2 == cdm_array[client_all_index].mask2)) {
817 strcpy(client_debug_string, ORANGEFS_ALL);
822 if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
823 (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
824 strcpy(client_debug_string, ORANGEFS_VERBOSE);
830 k_mask = (__u64 *) mask;
832 if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
833 strcpy(kernel_debug_string, ORANGEFS_ALL);
848 static void debug_string_to_mask(char *debug_string, void *mask, int type)
850 char *unchecked_keyword;
852 char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
853 char *original_pointer;
854 int element_count = 0;
855 struct client_debug_mask *c_mask = NULL;
856 __u64 *k_mask = NULL;
858 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
861 c_mask = (struct client_debug_mask *)mask;
862 element_count = cdm_element_count;
864 k_mask = (__u64 *)mask;
866 element_count = num_kmod_keyword_mask_map;
869 original_pointer = strsep_fodder;
870 while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
871 if (strlen(unchecked_keyword)) {
872 for (i = 0; i < element_count; i++)
883 kfree(original_pointer);
886 static void do_c_mask(int i, char *unchecked_keyword,
887 struct client_debug_mask **sane_mask)
890 if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
891 (**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
892 (**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
896 static void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
899 if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
900 **sane_mask = (**sane_mask) |
901 s_kmod_keyword_mask_map[i].mask_val;
904 int orangefs_debugfs_new_client_mask(void __user *arg)
906 struct dev_mask2_info_s mask2_info = {0};
909 ret = copy_from_user(&mask2_info,
911 sizeof(struct dev_mask2_info_s));
916 client_debug_mask.mask1 = mask2_info.mask1_value;
917 client_debug_mask.mask2 = mask2_info.mask2_value;
919 pr_info("%s: client debug mask has been been received "
922 (unsigned long long)client_debug_mask.mask1,
923 (unsigned long long)client_debug_mask.mask2);
928 int orangefs_debugfs_new_client_string(void __user *arg)
932 ret = copy_from_user(&client_debug_array_string,
934 ORANGEFS_MAX_DEBUG_STRING_LEN);
937 pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
943 * The real client-core makes an effort to ensure
944 * that actual strings that aren't too long to fit in
945 * this buffer is what we get here. We're going to use
946 * string functions on the stuff we got, so we'll make
947 * this extra effort to try and keep from
948 * flowing out of this buffer when we use the string
949 * functions, even if somehow the stuff we end up
950 * with here is garbage.
952 client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
955 pr_info("%s: client debug array string has been received.\n",
958 if (!help_string_initialized) {
960 /* Build a proper debug help string. */
961 ret = orangefs_prepare_debugfs_help_string(0);
963 gossip_err("%s: no debug help string \n",
970 debug_mask_to_string(&client_debug_mask, 1);
972 debugfs_remove(client_debug_dentry);
974 orangefs_client_debug_init();
976 help_string_initialized++;
981 int orangefs_debugfs_new_debug(void __user *arg)
983 struct dev_mask_info_s mask_info = {0};
986 ret = copy_from_user(&mask_info,
993 if (mask_info.mask_type == KERNEL_MASK) {
994 if ((mask_info.mask_value == 0)
995 && (kernel_mask_set_mod_init)) {
997 * the kernel debug mask was set when the
998 * kernel module was loaded; don't override
999 * it if the client-core was started without
1000 * a value for ORANGEFS_KMODMASK.
1004 debug_mask_to_string(&mask_info.mask_value,
1005 mask_info.mask_type);
1006 orangefs_gossip_debug_mask = mask_info.mask_value;
1007 pr_info("%s: kernel debug mask has been modified to "
1010 kernel_debug_string,
1011 (unsigned long long)orangefs_gossip_debug_mask);
1012 } else if (mask_info.mask_type == CLIENT_MASK) {
1013 debug_mask_to_string(&mask_info.mask_value,
1014 mask_info.mask_type);
1015 pr_info("%s: client debug mask has been modified to"
1018 client_debug_string,
1019 llu(mask_info.mask_value));
1021 gossip_err("Invalid mask type....\n");