2 * What: /sys/kernel/debug/orangefs/debug-help
4 * Contact: Mike Marshall <hubcap@omnibond.com>
6 * List of client and kernel debug keywords.
9 * What: /sys/kernel/debug/orangefs/client-debug
11 * Contact: Mike Marshall <hubcap@omnibond.com>
13 * Debug setting for "the client", the userspace
14 * helper for the kernel module.
17 * What: /sys/kernel/debug/orangefs/kernel-debug
19 * Contact: Mike Marshall <hubcap@omnibond.com>
21 * Debug setting for the orangefs kernel module.
23 * Any of the keywords, or comma-separated lists
24 * of keywords, from debug-help can be catted to
25 * client-debug or kernel-debug.
27 * "none", "all" and "verbose" are special keywords
28 * for client-debug. Setting client-debug to "all"
29 * is kind of like trying to drink water from a
30 * fire hose, "verbose" triggers most of the same
31 * output except for the constant flow of output
32 * from the main wait loop.
34 * "none" and "all" are similar settings for kernel-debug
35 * no need for a "verbose".
37 #include <linux/debugfs.h>
38 #include <linux/slab.h>
40 #include <linux/uaccess.h>
42 #include "orangefs-debugfs.h"
44 #include "orangefs-kernel.h"
46 #define DEBUG_HELP_STRING_SIZE 4096
47 #define HELP_STRING_UNINITIALIZED \
48 "Client Debug Keywords are unknown until the first time\n" \
49 "the client is started after boot.\n"
50 #define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help"
51 #define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug"
52 #define ORANGEFS_CLIENT_DEBUG_FILE "client-debug"
53 #define ORANGEFS_VERBOSE "verbose"
54 #define ORANGEFS_ALL "all"
57 * An array of client_debug_mask will be built to hold debug keyword/mask
58 * values fetched from userspace.
60 struct client_debug_mask
{
66 static int orangefs_kernel_debug_init(void);
68 static int orangefs_debug_help_open(struct inode
*, struct file
*);
69 static void *help_start(struct seq_file
*, loff_t
*);
70 static void *help_next(struct seq_file
*, void *, loff_t
*);
71 static void help_stop(struct seq_file
*, void *);
72 static int help_show(struct seq_file
*, void *);
74 static int orangefs_debug_open(struct inode
*, struct file
*);
76 static ssize_t
orangefs_debug_read(struct file
*,
81 static ssize_t
orangefs_debug_write(struct file
*,
86 static int orangefs_prepare_cdm_array(char *);
87 static void debug_mask_to_string(void *, int);
88 static void do_k_string(void *, int);
89 static void do_c_string(void *, int);
90 static int keyword_is_amalgam(char *);
91 static int check_amalgam_keyword(void *, int);
92 static void debug_string_to_mask(char *, void *, int);
93 static void do_c_mask(int, char *, struct client_debug_mask
**);
94 static void do_k_mask(int, char *, __u64
**);
96 static char kernel_debug_string
[ORANGEFS_MAX_DEBUG_STRING_LEN
] = "none";
97 static char *debug_help_string
;
98 static char client_debug_string
[ORANGEFS_MAX_DEBUG_STRING_LEN
];
99 static char client_debug_array_string
[ORANGEFS_MAX_DEBUG_STRING_LEN
];
101 static struct dentry
*help_file_dentry
;
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 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 int orangefs_debugfs_init(int debug_mask
)
157 /* convert input debug mask to a 64-bit unsigned integer */
158 orangefs_gossip_debug_mask
= (unsigned long long)debug_mask
;
161 * set the kernel's gossip debug string; invalid mask values will
164 debug_mask_to_string(&orangefs_gossip_debug_mask
, 0);
166 /* remove any invalid values from the mask */
167 debug_string_to_mask(kernel_debug_string
, &orangefs_gossip_debug_mask
,
171 * if the mask has a non-zero value, then indicate that the mask
172 * was set when the kernel module was loaded. The orangefs dev ioctl
173 * command will look at this boolean to determine if the kernel's
174 * debug mask should be overwritten when the client-core is started.
176 if (orangefs_gossip_debug_mask
!= 0)
177 kernel_mask_set_mod_init
= true;
179 pr_info("%s: called with debug mask: :%s: :%llx:\n",
182 (unsigned long long)orangefs_gossip_debug_mask
);
184 debug_dir
= debugfs_create_dir("orangefs", NULL
);
186 pr_info("%s: debugfs_create_dir failed.\n", __func__
);
190 help_file_dentry
= debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE
,
195 if (!help_file_dentry
) {
196 pr_info("%s: debugfs_create_file failed.\n", __func__
);
200 orangefs_debug_disabled
= 0;
202 rc
= orangefs_kernel_debug_init();
210 * initialize the kernel-debug file.
212 static int orangefs_kernel_debug_init(void)
216 char *k_buffer
= NULL
;
218 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "%s: start\n", __func__
);
220 k_buffer
= kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN
, GFP_KERNEL
);
224 if (strlen(kernel_debug_string
) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN
) {
225 strcpy(k_buffer
, kernel_debug_string
);
226 strcat(k_buffer
, "\n");
228 strcpy(k_buffer
, "none\n");
229 pr_info("%s: overflow 1!\n", __func__
);
232 ret
= debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE
,
238 pr_info("%s: failed to create %s.\n",
240 ORANGEFS_KMOD_DEBUG_FILE
);
248 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "%s: rc:%d:\n", __func__
, rc
);
253 void orangefs_debugfs_cleanup(void)
255 debugfs_remove_recursive(debug_dir
);
258 /* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
259 static int orangefs_debug_help_open(struct inode
*inode
, struct file
*file
)
264 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
265 "orangefs_debug_help_open: start\n");
267 if (orangefs_debug_disabled
)
270 ret
= seq_open(file
, &help_debug_ops
);
274 ((struct seq_file
*)(file
->private_data
))->private = inode
->i_private
;
279 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
280 "orangefs_debug_help_open: rc:%d:\n",
286 * I think start always gets called again after stop. Start
287 * needs to return NULL when it is done. The whole "payload"
288 * in this case is a single (long) string, so by the second
289 * time we get to start (pos = 1), we're done.
291 static void *help_start(struct seq_file
*m
, loff_t
*pos
)
293 void *payload
= NULL
;
295 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "help_start: start\n");
297 mutex_lock(&orangefs_help_file_lock
);
300 payload
= m
->private;
305 static void *help_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
307 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "help_next: start\n");
312 static void help_stop(struct seq_file
*m
, void *p
)
314 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "help_stop: start\n");
315 mutex_unlock(&orangefs_help_file_lock
);
318 static int help_show(struct seq_file
*m
, void *v
)
320 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "help_show: start\n");
328 * initialize the client-debug file.
330 int orangefs_client_debug_init(void)
334 char *c_buffer
= NULL
;
336 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "%s: start\n", __func__
);
338 c_buffer
= kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN
, GFP_KERNEL
);
342 if (strlen(client_debug_string
) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN
) {
343 strcpy(c_buffer
, client_debug_string
);
344 strcat(c_buffer
, "\n");
346 strcpy(c_buffer
, "none\n");
347 pr_info("%s: overflow! 2\n", __func__
);
350 client_debug_dentry
= debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE
,
355 if (!client_debug_dentry
) {
356 pr_info("%s: failed to create updated %s.\n",
358 ORANGEFS_CLIENT_DEBUG_FILE
);
366 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "%s: rc:%d:\n", __func__
, rc
);
370 /* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
371 static int orangefs_debug_open(struct inode
*inode
, struct file
*file
)
375 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
376 "%s: orangefs_debug_disabled: %d\n",
378 orangefs_debug_disabled
);
380 if (orangefs_debug_disabled
)
384 mutex_lock(&orangefs_debug_lock
);
385 file
->private_data
= inode
->i_private
;
386 mutex_unlock(&orangefs_debug_lock
);
389 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
390 "orangefs_debug_open: rc: %d\n",
395 static ssize_t
orangefs_debug_read(struct file
*file
,
402 ssize_t read_ret
= -ENOMEM
;
404 gossip_debug(GOSSIP_DEBUGFS_DEBUG
, "orangefs_debug_read: start\n");
406 buf
= kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN
, GFP_KERNEL
);
410 mutex_lock(&orangefs_debug_lock
);
411 sprintf_ret
= sprintf(buf
, "%s", (char *)file
->private_data
);
412 mutex_unlock(&orangefs_debug_lock
);
414 read_ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, sprintf_ret
);
419 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
420 "orangefs_debug_read: ret: %zu\n",
426 static ssize_t
orangefs_debug_write(struct file
*file
,
427 const char __user
*ubuf
,
435 struct orangefs_kernel_op_s
*new_op
= NULL
;
436 struct client_debug_mask c_mask
= { NULL
, 0, 0 };
438 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
439 "orangefs_debug_write: %pD\n",
443 * Thwart users who try to jamb a ridiculous number
444 * of bytes into the debug file...
446 if (count
> ORANGEFS_MAX_DEBUG_STRING_LEN
+ 1) {
448 count
= ORANGEFS_MAX_DEBUG_STRING_LEN
+ 1;
451 buf
= kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN
, GFP_KERNEL
);
455 if (copy_from_user(buf
, ubuf
, count
- 1)) {
456 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
457 "%s: copy_from_user failed!\n",
463 * Map the keyword string from userspace into a valid debug mask.
464 * The mapping process involves mapping the human-inputted string
465 * into a valid mask, and then rebuilding the string from the
466 * verified valid mask.
468 * A service operation is required to set a new client-side
471 if (!strcmp(file
->f_path
.dentry
->d_name
.name
,
472 ORANGEFS_KMOD_DEBUG_FILE
)) {
473 debug_string_to_mask(buf
, &orangefs_gossip_debug_mask
, 0);
474 debug_mask_to_string(&orangefs_gossip_debug_mask
, 0);
475 debug_string
= kernel_debug_string
;
476 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
477 "New kernel debug string is %s\n",
478 kernel_debug_string
);
480 /* Can't reset client debug mask if client is not running. */
481 if (is_daemon_in_service()) {
482 pr_info("%s: Client not running :%d:\n",
484 is_daemon_in_service());
488 debug_string_to_mask(buf
, &c_mask
, 1);
489 debug_mask_to_string(&c_mask
, 1);
490 debug_string
= client_debug_string
;
492 new_op
= op_alloc(ORANGEFS_VFS_OP_PARAM
);
494 pr_info("%s: op_alloc failed!\n", __func__
);
498 new_op
->upcall
.req
.param
.op
=
499 ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES
;
500 new_op
->upcall
.req
.param
.type
= ORANGEFS_PARAM_REQUEST_SET
;
501 memset(new_op
->upcall
.req
.param
.s_value
,
503 ORANGEFS_MAX_DEBUG_STRING_LEN
);
504 sprintf(new_op
->upcall
.req
.param
.s_value
,
509 /* service_operation returns 0 on success... */
510 rc
= service_operation(new_op
,
512 ORANGEFS_OP_INTERRUPTIBLE
);
515 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
516 "%s: service_operation failed! rc:%d:\n",
523 mutex_lock(&orangefs_debug_lock
);
524 memset(file
->f_inode
->i_private
, 0, ORANGEFS_MAX_DEBUG_STRING_LEN
);
525 sprintf((char *)file
->f_inode
->i_private
, "%s\n", debug_string
);
526 mutex_unlock(&orangefs_debug_lock
);
535 gossip_debug(GOSSIP_DEBUGFS_DEBUG
,
536 "orangefs_debug_write: rc: %d\n",
543 * After obtaining a string representation of the client's debug
544 * keywords and their associated masks, this function is called to build an
545 * array of these values.
547 static int orangefs_prepare_cdm_array(char *debug_array_string
)
551 char *cds_head
= NULL
;
552 char *cds_delimiter
= NULL
;
555 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
558 * figure out how many elements the cdm_array needs.
560 for (i
= 0; i
< strlen(debug_array_string
); i
++)
561 if (debug_array_string
[i
] == '\n')
564 if (!cdm_element_count
) {
565 pr_info("No elements in client debug array string!\n");
570 kzalloc(cdm_element_count
* sizeof(struct client_debug_mask
),
573 pr_info("malloc failed for cdm_array!\n");
578 cds_head
= debug_array_string
;
580 for (i
= 0; i
< cdm_element_count
; i
++) {
581 cds_delimiter
= strchr(cds_head
, '\n');
582 *cds_delimiter
= '\0';
584 keyword_len
= strcspn(cds_head
, " ");
586 cdm_array
[i
].keyword
= kzalloc(keyword_len
+ 1, GFP_KERNEL
);
587 if (!cdm_array
[i
].keyword
) {
594 cdm_array
[i
].keyword
,
595 (unsigned long long *)&(cdm_array
[i
].mask1
),
596 (unsigned long long *)&(cdm_array
[i
].mask2
));
598 if (!strcmp(cdm_array
[i
].keyword
, ORANGEFS_VERBOSE
))
599 client_verbose_index
= i
;
601 if (!strcmp(cdm_array
[i
].keyword
, ORANGEFS_ALL
))
602 client_all_index
= i
;
604 cds_head
= cds_delimiter
+ 1;
607 rc
= cdm_element_count
;
609 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: rc:%d:\n", __func__
, rc
);
618 * /sys/kernel/debug/orangefs/debug-help can be catted to
619 * see all the available kernel and client debug keywords.
621 * When orangefs.ko initializes, we have no idea what keywords the
622 * client supports, nor their associated masks.
624 * We pass through this function once at module-load and stamp a
625 * boilerplate "we don't know" message for the client in the
626 * debug-help file. We pass through here again when the client
627 * starts and then we can fill out the debug-help file fully.
629 * The client might be restarted any number of times between
630 * module reloads, we only build the debug-help file the first time.
632 int orangefs_prepare_debugfs_help_string(int at_boot
)
634 char *client_title
= "Client Debug Keywords:\n";
635 char *kernel_title
= "Kernel Debug Keywords:\n";
636 size_t string_size
= DEBUG_HELP_STRING_SIZE
;
642 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
645 client_title
= HELP_STRING_UNINITIALIZED
;
647 /* build a new debug_help_string. */
648 new = kzalloc(DEBUG_HELP_STRING_SIZE
, GFP_KERNEL
);
655 * strlcat(dst, src, size) will append at most
656 * "size - strlen(dst) - 1" bytes of src onto dst,
657 * null terminating the result, and return the total
658 * length of the string it tried to create.
660 * We'll just plow through here building our new debug
661 * help string and let strlcat take care of assuring that
662 * dst doesn't overflow.
664 strlcat(new, client_title
, string_size
);
669 * fill the client keyword/mask array and remember
670 * how many elements there were.
673 orangefs_prepare_cdm_array(client_debug_array_string
);
674 if (cdm_element_count
<= 0)
677 for (i
= 0; i
< cdm_element_count
; i
++) {
678 strlcat(new, "\t", string_size
);
679 strlcat(new, cdm_array
[i
].keyword
, string_size
);
680 strlcat(new, "\n", string_size
);
684 strlcat(new, "\n", string_size
);
685 strlcat(new, kernel_title
, string_size
);
687 for (i
= 0; i
< num_kmod_keyword_mask_map
; i
++) {
688 strlcat(new, "\t", string_size
);
689 strlcat(new, s_kmod_keyword_mask_map
[i
].keyword
, string_size
);
690 result_size
= strlcat(new, "\n", string_size
);
693 /* See if we tried to put too many bytes into "new"... */
694 if (result_size
>= string_size
) {
700 debug_help_string
= new;
702 mutex_lock(&orangefs_help_file_lock
);
703 memset(debug_help_string
, 0, DEBUG_HELP_STRING_SIZE
);
704 strlcat(debug_help_string
, new, string_size
);
705 mutex_unlock(&orangefs_help_file_lock
);
718 static void debug_mask_to_string(void *mask
, int type
)
723 int element_count
= 0;
725 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
728 debug_string
= client_debug_string
;
729 element_count
= cdm_element_count
;
731 debug_string
= kernel_debug_string
;
732 element_count
= num_kmod_keyword_mask_map
;
735 memset(debug_string
, 0, ORANGEFS_MAX_DEBUG_STRING_LEN
);
738 * Some keywords, like "all" or "verbose", are amalgams of
739 * numerous other keywords. Make a special check for those
740 * before grinding through the whole mask only to find out
743 if (check_amalgam_keyword(mask
, type
))
746 /* Build the debug string. */
747 for (i
= 0; i
< element_count
; i
++)
749 do_c_string(mask
, i
);
751 do_k_string(mask
, i
);
753 len
= strlen(debug_string
);
756 client_debug_string
[len
- 1] = '\0';
758 kernel_debug_string
[len
- 1] = '\0';
760 strcpy(client_debug_string
, "none");
762 strcpy(kernel_debug_string
, "none");
765 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: string:%s:\n", __func__
, debug_string
);
771 static void do_k_string(void *k_mask
, int index
)
773 __u64
*mask
= (__u64
*) k_mask
;
775 if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map
[index
].keyword
))
778 if (*mask
& s_kmod_keyword_mask_map
[index
].mask_val
) {
779 if ((strlen(kernel_debug_string
) +
780 strlen(s_kmod_keyword_mask_map
[index
].keyword
))
781 < ORANGEFS_MAX_DEBUG_STRING_LEN
- 1) {
782 strcat(kernel_debug_string
,
783 s_kmod_keyword_mask_map
[index
].keyword
);
784 strcat(kernel_debug_string
, ",");
786 gossip_err("%s: overflow!\n", __func__
);
787 strcpy(kernel_debug_string
, ORANGEFS_ALL
);
797 static void do_c_string(void *c_mask
, int index
)
799 struct client_debug_mask
*mask
= (struct client_debug_mask
*) c_mask
;
801 if (keyword_is_amalgam(cdm_array
[index
].keyword
))
804 if ((mask
->mask1
& cdm_array
[index
].mask1
) ||
805 (mask
->mask2
& cdm_array
[index
].mask2
)) {
806 if ((strlen(client_debug_string
) +
807 strlen(cdm_array
[index
].keyword
) + 1)
808 < ORANGEFS_MAX_DEBUG_STRING_LEN
- 2) {
809 strcat(client_debug_string
,
810 cdm_array
[index
].keyword
);
811 strcat(client_debug_string
, ",");
813 gossip_err("%s: overflow!\n", __func__
);
814 strcpy(client_debug_string
, ORANGEFS_ALL
);
822 static int keyword_is_amalgam(char *keyword
)
826 if ((!strcmp(keyword
, ORANGEFS_ALL
)) || (!strcmp(keyword
, ORANGEFS_VERBOSE
)))
836 * return 1 if we found an amalgam.
838 static int check_amalgam_keyword(void *mask
, int type
)
841 struct client_debug_mask
*c_mask
;
842 int k_all_index
= num_kmod_keyword_mask_map
- 1;
846 c_mask
= (struct client_debug_mask
*) mask
;
848 if ((c_mask
->mask1
== cdm_array
[client_all_index
].mask1
) &&
849 (c_mask
->mask2
== cdm_array
[client_all_index
].mask2
)) {
850 strcpy(client_debug_string
, ORANGEFS_ALL
);
855 if ((c_mask
->mask1
== cdm_array
[client_verbose_index
].mask1
) &&
856 (c_mask
->mask2
== cdm_array
[client_verbose_index
].mask2
)) {
857 strcpy(client_debug_string
, ORANGEFS_VERBOSE
);
863 k_mask
= (__u64
*) mask
;
865 if (*k_mask
>= s_kmod_keyword_mask_map
[k_all_index
].mask_val
) {
866 strcpy(kernel_debug_string
, ORANGEFS_ALL
);
881 static void debug_string_to_mask(char *debug_string
, void *mask
, int type
)
883 char *unchecked_keyword
;
885 char *strsep_fodder
= kstrdup(debug_string
, GFP_KERNEL
);
886 char *original_pointer
;
887 int element_count
= 0;
888 struct client_debug_mask
*c_mask
= NULL
;
889 __u64
*k_mask
= NULL
;
891 gossip_debug(GOSSIP_UTILS_DEBUG
, "%s: start\n", __func__
);
894 c_mask
= (struct client_debug_mask
*)mask
;
895 element_count
= cdm_element_count
;
897 k_mask
= (__u64
*)mask
;
899 element_count
= num_kmod_keyword_mask_map
;
902 original_pointer
= strsep_fodder
;
903 while ((unchecked_keyword
= strsep(&strsep_fodder
, ",")))
904 if (strlen(unchecked_keyword
)) {
905 for (i
= 0; i
< element_count
; i
++)
916 kfree(original_pointer
);
919 static void do_c_mask(int i
, char *unchecked_keyword
,
920 struct client_debug_mask
**sane_mask
)
923 if (!strcmp(cdm_array
[i
].keyword
, unchecked_keyword
)) {
924 (**sane_mask
).mask1
= (**sane_mask
).mask1
| cdm_array
[i
].mask1
;
925 (**sane_mask
).mask2
= (**sane_mask
).mask2
| cdm_array
[i
].mask2
;
929 static void do_k_mask(int i
, char *unchecked_keyword
, __u64
**sane_mask
)
932 if (!strcmp(s_kmod_keyword_mask_map
[i
].keyword
, unchecked_keyword
))
933 **sane_mask
= (**sane_mask
) |
934 s_kmod_keyword_mask_map
[i
].mask_val
;
937 int orangefs_debugfs_new_client_mask(void __user
*arg
)
939 struct dev_mask2_info_s mask2_info
= {0};
942 ret
= copy_from_user(&mask2_info
,
944 sizeof(struct dev_mask2_info_s
));
949 client_debug_mask
.mask1
= mask2_info
.mask1_value
;
950 client_debug_mask
.mask2
= mask2_info
.mask2_value
;
952 pr_info("%s: client debug mask has been been received "
955 (unsigned long long)client_debug_mask
.mask1
,
956 (unsigned long long)client_debug_mask
.mask2
);
961 int orangefs_debugfs_new_client_string(void __user
*arg
)
965 ret
= copy_from_user(&client_debug_array_string
,
967 ORANGEFS_MAX_DEBUG_STRING_LEN
);
970 pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
976 * The real client-core makes an effort to ensure
977 * that actual strings that aren't too long to fit in
978 * this buffer is what we get here. We're going to use
979 * string functions on the stuff we got, so we'll make
980 * this extra effort to try and keep from
981 * flowing out of this buffer when we use the string
982 * functions, even if somehow the stuff we end up
983 * with here is garbage.
985 client_debug_array_string
[ORANGEFS_MAX_DEBUG_STRING_LEN
- 1] =
988 pr_info("%s: client debug array string has been received.\n",
991 if (!help_string_initialized
) {
993 /* Build a proper debug help string. */
994 if (orangefs_prepare_debugfs_help_string(0)) {
995 gossip_err("%s: no debug help string \n",
1002 debug_mask_to_string(&client_debug_mask
, 1);
1004 debugfs_remove(client_debug_dentry
);
1006 orangefs_client_debug_init();
1008 help_string_initialized
++;
1013 int orangefs_debugfs_new_debug(void __user
*arg
)
1015 struct dev_mask_info_s mask_info
= {0};
1018 ret
= copy_from_user(&mask_info
,
1025 if (mask_info
.mask_type
== KERNEL_MASK
) {
1026 if ((mask_info
.mask_value
== 0)
1027 && (kernel_mask_set_mod_init
)) {
1029 * the kernel debug mask was set when the
1030 * kernel module was loaded; don't override
1031 * it if the client-core was started without
1032 * a value for ORANGEFS_KMODMASK.
1036 debug_mask_to_string(&mask_info
.mask_value
,
1037 mask_info
.mask_type
);
1038 orangefs_gossip_debug_mask
= mask_info
.mask_value
;
1039 pr_info("%s: kernel debug mask has been modified to "
1042 kernel_debug_string
,
1043 (unsigned long long)orangefs_gossip_debug_mask
);
1044 } else if (mask_info
.mask_type
== CLIENT_MASK
) {
1045 debug_mask_to_string(&mask_info
.mask_value
,
1046 mask_info
.mask_type
);
1047 pr_info("%s: client debug mask has been modified to"
1050 client_debug_string
,
1051 llu(mask_info
.mask_value
));
1053 gossip_lerr("Invalid mask type....\n");