source: src/linux/universal/linux-4.9/fs/orangefs/orangefs-debugfs.c @ 31574

Last change on this file since 31574 was 31574, checked in by brainslayer, 3 months ago

kernel 4.9 update

File size: 25.3 KB
Line 
1/*
2 * What:                /sys/kernel/debug/orangefs/debug-help
3 * Date:                June 2015
4 * Contact:             Mike Marshall <hubcap@omnibond.com>
5 * Description:
6 *                      List of client and kernel debug keywords.
7 *
8 *
9 * What:                /sys/kernel/debug/orangefs/client-debug
10 * Date:                June 2015
11 * Contact:             Mike Marshall <hubcap@omnibond.com>
12 * Description:
13 *                      Debug setting for "the client", the userspace
14 *                      helper for the kernel module.
15 *
16 *
17 * What:                /sys/kernel/debug/orangefs/kernel-debug
18 * Date:                June 2015
19 * Contact:             Mike Marshall <hubcap@omnibond.com>
20 * Description:
21 *                      Debug setting for the orangefs kernel module.
22 *
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.
26 *
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.
33 *
34 *                      "none" and "all" are similar settings for kernel-debug
35 *                      no need for a "verbose".
36 */
37#include <linux/debugfs.h>
38#include <linux/slab.h>
39
40#include <linux/uaccess.h>
41
42#include "orangefs-debugfs.h"
43#include "protocol.h"
44#include "orangefs-kernel.h"
45
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"
55
56/*
57 * An array of client_debug_mask will be built to hold debug keyword/mask
58 * values fetched from userspace.
59 */
60struct client_debug_mask {
61        char *keyword;
62        __u64 mask1;
63        __u64 mask2;
64};
65
66static int orangefs_kernel_debug_init(void);
67
68static int orangefs_debug_help_open(struct inode *, struct file *);
69static void *help_start(struct seq_file *, loff_t *);
70static void *help_next(struct seq_file *, void *, loff_t *);
71static void help_stop(struct seq_file *, void *);
72static int help_show(struct seq_file *, void *);
73
74static int orangefs_debug_open(struct inode *, struct file *);
75
76static ssize_t orangefs_debug_read(struct file *,
77                                 char __user *,
78                                 size_t,
79                                 loff_t *);
80
81static ssize_t orangefs_debug_write(struct file *,
82                                  const char __user *,
83                                  size_t,
84                                  loff_t *);
85
86static int orangefs_prepare_cdm_array(char *);
87static void debug_mask_to_string(void *, int);
88static void do_k_string(void *, int);
89static void do_c_string(void *, int);
90static int keyword_is_amalgam(char *);
91static int check_amalgam_keyword(void *, int);
92static void debug_string_to_mask(char *, void *, int);
93static void do_c_mask(int, char *, struct client_debug_mask **);
94static void do_k_mask(int, char *, __u64 **);
95
96static char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN] = "none";
97static char *debug_help_string;
98static char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
99static char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
100
101static struct dentry *help_file_dentry;
102static struct dentry *client_debug_dentry;
103static struct dentry *debug_dir;
104
105static unsigned int kernel_mask_set_mod_init;
106static int orangefs_debug_disabled = 1;
107static int help_string_initialized;
108
109static const struct seq_operations help_debug_ops = {
110        .start  = help_start,
111        .next   = help_next,
112        .stop   = help_stop,
113        .show   = help_show,
114};
115
116const struct file_operations debug_help_fops = {
117        .owner          = THIS_MODULE,
118        .open           = orangefs_debug_help_open,
119        .read           = seq_read,
120        .release        = seq_release,
121        .llseek         = seq_lseek,
122};
123
124static 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,
130};
131
132static int client_all_index;
133static int client_verbose_index;
134
135static struct client_debug_mask *cdm_array;
136static int cdm_element_count;
137
138static struct client_debug_mask client_debug_mask;
139
140/*
141 * Used to protect data in ORANGEFS_KMOD_DEBUG_FILE and
142 * ORANGEFS_KMOD_DEBUG_FILE.
143 */
144static DEFINE_MUTEX(orangefs_debug_lock);
145
146/* Used to protect data in ORANGEFS_KMOD_DEBUG_HELP_FILE */
147static DEFINE_MUTEX(orangefs_help_file_lock);
148
149/*
150 * initialize kmod debug operations, create orangefs debugfs dir and
151 * ORANGEFS_KMOD_DEBUG_HELP_FILE.
152 */
153int orangefs_debugfs_init(int debug_mask)
154{
155        int rc = -ENOMEM;
156
157        /* convert input debug mask to a 64-bit unsigned integer */
158        orangefs_gossip_debug_mask = (unsigned long long)debug_mask;
159
160        /*
161         * set the kernel's gossip debug string; invalid mask values will
162         * be ignored.
163         */
164        debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
165
166        /* remove any invalid values from the mask */
167        debug_string_to_mask(kernel_debug_string, &orangefs_gossip_debug_mask,
168            0);
169
170        /*
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.
175         */
176        if (orangefs_gossip_debug_mask != 0)
177                kernel_mask_set_mod_init = true;
178
179        pr_info("%s: called with debug mask: :%s: :%llx:\n",
180                __func__,
181                kernel_debug_string,
182                (unsigned long long)orangefs_gossip_debug_mask);
183
184        debug_dir = debugfs_create_dir("orangefs", NULL);
185        if (!debug_dir) {
186                pr_info("%s: debugfs_create_dir failed.\n", __func__);
187                goto out;
188        }
189
190        help_file_dentry = debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE,
191                                  0444,
192                                  debug_dir,
193                                  debug_help_string,
194                                  &debug_help_fops);
195        if (!help_file_dentry) {
196                pr_info("%s: debugfs_create_file failed.\n", __func__);
197                goto out;
198        }
199
200        orangefs_debug_disabled = 0;
201
202        rc = orangefs_kernel_debug_init();
203
204out:
205
206        return rc;
207}
208
209/*
210 * initialize the kernel-debug file.
211 */
212static int orangefs_kernel_debug_init(void)
213{
214        int rc = -ENOMEM;
215        struct dentry *ret;
216        char *k_buffer = NULL;
217
218        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
219
220        k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
221        if (!k_buffer)
222                goto out;
223
224        if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
225                strcpy(k_buffer, kernel_debug_string);
226                strcat(k_buffer, "\n");
227        } else {
228                strcpy(k_buffer, "none\n");
229                pr_info("%s: overflow 1!\n", __func__);
230        }
231
232        ret = debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE,
233                                  0444,
234                                  debug_dir,
235                                  k_buffer,
236                                  &kernel_debug_fops);
237        if (!ret) {
238                pr_info("%s: failed to create %s.\n",
239                        __func__,
240                        ORANGEFS_KMOD_DEBUG_FILE);
241                goto out;
242        }
243
244        rc = 0;
245
246out:
247
248        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
249        return rc;
250}
251
252
253void orangefs_debugfs_cleanup(void)
254{
255        debugfs_remove_recursive(debug_dir);
256}
257
258/* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
259static int orangefs_debug_help_open(struct inode *inode, struct file *file)
260{
261        int rc = -ENODEV;
262        int ret;
263
264        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
265                     "orangefs_debug_help_open: start\n");
266
267        if (orangefs_debug_disabled)
268                goto out;
269
270        ret = seq_open(file, &help_debug_ops);
271        if (ret)
272                goto out;
273
274        ((struct seq_file *)(file->private_data))->private = inode->i_private;
275
276        rc = 0;
277
278out:
279        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
280                     "orangefs_debug_help_open: rc:%d:\n",
281                     rc);
282        return rc;
283}
284
285/*
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.
290 */
291static void *help_start(struct seq_file *m, loff_t *pos)
292{
293        void *payload = NULL;
294
295        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n");
296
297        mutex_lock(&orangefs_help_file_lock);
298
299        if (*pos == 0)
300                payload = m->private;
301
302        return payload;
303}
304
305static void *help_next(struct seq_file *m, void *v, loff_t *pos)
306{
307        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_next: start\n");
308
309        return NULL;
310}
311
312static void help_stop(struct seq_file *m, void *p)
313{
314        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n");
315        mutex_unlock(&orangefs_help_file_lock);
316}
317
318static int help_show(struct seq_file *m, void *v)
319{
320        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_show: start\n");
321
322        seq_puts(m, v);
323
324        return 0;
325}
326
327/*
328 * initialize the client-debug file.
329 */
330int orangefs_client_debug_init(void)
331{
332
333        int rc = -ENOMEM;
334        char *c_buffer = NULL;
335
336        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
337
338        c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
339        if (!c_buffer)
340                goto out;
341
342        if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
343                strcpy(c_buffer, client_debug_string);
344                strcat(c_buffer, "\n");
345        } else {
346                strcpy(c_buffer, "none\n");
347                pr_info("%s: overflow! 2\n", __func__);
348        }
349
350        client_debug_dentry = debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE,
351                                                  0444,
352                                                  debug_dir,
353                                                  c_buffer,
354                                                  &kernel_debug_fops);
355        if (!client_debug_dentry) {
356                pr_info("%s: failed to create updated %s.\n",
357                        __func__,
358                        ORANGEFS_CLIENT_DEBUG_FILE);
359                goto out;
360        }
361
362        rc = 0;
363
364out:
365
366        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
367        return rc;
368}
369
370/* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
371static int orangefs_debug_open(struct inode *inode, struct file *file)
372{
373        int rc = -ENODEV;
374
375        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
376                     "%s: orangefs_debug_disabled: %d\n",
377                     __func__,
378                     orangefs_debug_disabled);
379
380        if (orangefs_debug_disabled)
381                goto out;
382
383        rc = 0;
384        mutex_lock(&orangefs_debug_lock);
385        file->private_data = inode->i_private;
386        mutex_unlock(&orangefs_debug_lock);
387
388out:
389        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
390                     "orangefs_debug_open: rc: %d\n",
391                     rc);
392        return rc;
393}
394
395static ssize_t orangefs_debug_read(struct file *file,
396                                 char __user *ubuf,
397                                 size_t count,
398                                 loff_t *ppos)
399{
400        char *buf;
401        int sprintf_ret;
402        ssize_t read_ret = -ENOMEM;
403
404        gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");
405
406        buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
407        if (!buf)
408                goto out;
409
410        mutex_lock(&orangefs_debug_lock);
411        sprintf_ret = sprintf(buf, "%s", (char *)file->private_data);
412        mutex_unlock(&orangefs_debug_lock);
413
414        read_ret = simple_read_from_buffer(ubuf, count, ppos, buf, sprintf_ret);
415
416        kfree(buf);
417
418out:
419        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
420                     "orangefs_debug_read: ret: %zu\n",
421                     read_ret);
422
423        return read_ret;
424}
425
426static ssize_t orangefs_debug_write(struct file *file,
427                                  const char __user *ubuf,
428                                  size_t count,
429                                  loff_t *ppos)
430{
431        char *buf;
432        int rc = -EFAULT;
433        size_t silly = 0;
434        char *debug_string;
435        struct orangefs_kernel_op_s *new_op = NULL;
436        struct client_debug_mask c_mask = { NULL, 0, 0 };
437
438        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
439                "orangefs_debug_write: %pD\n",
440                file);
441
442        /*
443         * Thwart users who try to jamb a ridiculous number
444         * of bytes into the debug file...
445         */
446        if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) {
447                silly = count;
448                count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1;
449        }
450
451        buf = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
452        if (!buf)
453                goto out;
454
455        if (copy_from_user(buf, ubuf, count - 1)) {
456                gossip_debug(GOSSIP_DEBUGFS_DEBUG,
457                             "%s: copy_from_user failed!\n",
458                             __func__);
459                goto out;
460        }
461
462        /*
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.
467         *
468         * A service operation is required to set a new client-side
469         * debug mask.
470         */
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);
479        } else {
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",
483                                __func__,
484                                is_daemon_in_service());
485                        goto out;
486                }
487
488                debug_string_to_mask(buf, &c_mask, 1);
489                debug_mask_to_string(&c_mask, 1);
490                debug_string = client_debug_string;
491
492                new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
493                if (!new_op) {
494                        pr_info("%s: op_alloc failed!\n", __func__);
495                        goto out;
496                }
497
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,
502                       0,
503                       ORANGEFS_MAX_DEBUG_STRING_LEN);
504                sprintf(new_op->upcall.req.param.s_value,
505                        "%llx %llx\n",
506                        c_mask.mask1,
507                        c_mask.mask2);
508
509                /* service_operation returns 0 on success... */
510                rc = service_operation(new_op,
511                                       "orangefs_param",
512                                        ORANGEFS_OP_INTERRUPTIBLE);
513
514                if (rc)
515                        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
516                                     "%s: service_operation failed! rc:%d:\n",
517                                     __func__,
518                                     rc);
519
520                op_release(new_op);
521        }
522
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);
527
528        *ppos += count;
529        if (silly)
530                rc = silly;
531        else
532                rc = count;
533
534out:
535        gossip_debug(GOSSIP_DEBUGFS_DEBUG,
536                     "orangefs_debug_write: rc: %d\n",
537                     rc);
538        kfree(buf);
539        return rc;
540}
541
542/*
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.
546 */
547static int orangefs_prepare_cdm_array(char *debug_array_string)
548{
549        int i;
550        int rc = -EINVAL;
551        char *cds_head = NULL;
552        char *cds_delimiter = NULL;
553        int keyword_len = 0;
554
555        gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
556
557        /*
558         * figure out how many elements the cdm_array needs.
559         */
560        for (i = 0; i < strlen(debug_array_string); i++)
561                if (debug_array_string[i] == '\n')
562                        cdm_element_count++;
563
564        if (!cdm_element_count) {
565                pr_info("No elements in client debug array string!\n");
566                goto out;
567        }
568
569        cdm_array =
570                kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
571                        GFP_KERNEL);
572        if (!cdm_array) {
573                pr_info("malloc failed for cdm_array!\n");
574                rc = -ENOMEM;
575                goto out;
576        }
577
578        cds_head = debug_array_string;
579
580        for (i = 0; i < cdm_element_count; i++) {
581                cds_delimiter = strchr(cds_head, '\n');
582                *cds_delimiter = '\0';
583
584                keyword_len = strcspn(cds_head, " ");
585
586                cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
587                if (!cdm_array[i].keyword) {
588                        rc = -ENOMEM;
589                        goto out;
590                }
591
592                sscanf(cds_head,
593                       "%s %llx %llx",
594                       cdm_array[i].keyword,
595                       (unsigned long long *)&(cdm_array[i].mask1),
596                       (unsigned long long *)&(cdm_array[i].mask2));
597
598                if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
599                        client_verbose_index = i;
600
601                if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
602                        client_all_index = i;
603
604                cds_head = cds_delimiter + 1;
605        }
606
607        rc = cdm_element_count;
608
609        gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
610
611out:
612
613        return rc;
614
615}
616
617/*
618 * /sys/kernel/debug/orangefs/debug-help can be catted to
619 * see all the available kernel and client debug keywords.
620 *
621 * When orangefs.ko initializes, we have no idea what keywords the
622 * client supports, nor their associated masks.
623 *
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.
628 *
629 * The client might be restarted any number of times between
630 * module reloads, we only build the debug-help file the first time.
631 */
632int orangefs_prepare_debugfs_help_string(int at_boot)
633{
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;
637        size_t result_size;
638        size_t i;
639        char *new;
640        int rc = -EINVAL;
641
642        gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
643
644        if (at_boot)
645                client_title = HELP_STRING_UNINITIALIZED;
646
647        /* build a new debug_help_string. */
648        new = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
649        if (!new) {
650                rc = -ENOMEM;
651                goto out;
652        }
653
654        /*
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.
659         *
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.
663         */
664        strlcat(new, client_title, string_size);
665
666        if (!at_boot) {
667
668                /*
669                 * fill the client keyword/mask array and remember
670                 * how many elements there were.
671                 */
672                cdm_element_count =
673                        orangefs_prepare_cdm_array(client_debug_array_string);
674                if (cdm_element_count <= 0)
675                        goto out;
676
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);
681                }
682        }
683
684        strlcat(new, "\n", string_size);
685        strlcat(new, kernel_title, string_size);
686
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);
691        }
692
693        /* See if we tried to put too many bytes into "new"... */
694        if (result_size >= string_size) {
695                kfree(new);
696                goto out;
697        }
698
699        if (at_boot) {
700                debug_help_string = new;
701        } else {
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);
706        }
707
708        rc = 0;
709
710out:    return rc;
711
712}
713
714/*
715 * kernel = type 0
716 * client = type 1
717 */
718static void debug_mask_to_string(void *mask, int type)
719{
720        int i;
721        int len = 0;
722        char *debug_string;
723        int element_count = 0;
724
725        gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
726
727        if (type) {
728                debug_string = client_debug_string;
729                element_count = cdm_element_count;
730        } else {
731                debug_string = kernel_debug_string;
732                element_count = num_kmod_keyword_mask_map;
733        }
734
735        memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
736
737        /*
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
741         * later...
742         */
743        if (check_amalgam_keyword(mask, type))
744                goto out;
745
746        /* Build the debug string. */
747        for (i = 0; i < element_count; i++)
748                if (type)
749                        do_c_string(mask, i);
750                else
751                        do_k_string(mask, i);
752
753        len = strlen(debug_string);
754
755        if ((len) && (type))
756                client_debug_string[len - 1] = '\0';
757        else if (len)
758                kernel_debug_string[len - 1] = '\0';
759        else if (type)
760                strcpy(client_debug_string, "none");
761        else
762                strcpy(kernel_debug_string, "none");
763
764out:
765gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
766
767        return;
768
769}
770
771static void do_k_string(void *k_mask, int index)
772{
773        __u64 *mask = (__u64 *) k_mask;
774
775        if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
776                goto out;
777
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, ",");
785                        } else {
786                                gossip_err("%s: overflow!\n", __func__);
787                                strcpy(kernel_debug_string, ORANGEFS_ALL);
788                                goto out;
789                        }
790        }
791
792out:
793
794        return;
795}
796
797static void do_c_string(void *c_mask, int index)
798{
799        struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
800
801        if (keyword_is_amalgam(cdm_array[index].keyword))
802                goto out;
803
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, ",");
812                        } else {
813                                gossip_err("%s: overflow!\n", __func__);
814                                strcpy(client_debug_string, ORANGEFS_ALL);
815                                goto out;
816                        }
817        }
818out:
819        return;
820}
821
822static int keyword_is_amalgam(char *keyword)
823{
824        int rc = 0;
825
826        if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
827                rc = 1;
828
829        return rc;
830}
831
832/*
833 * kernel = type 0
834 * client = type 1
835 *
836 * return 1 if we found an amalgam.
837 */
838static int check_amalgam_keyword(void *mask, int type)
839{
840        __u64 *k_mask;
841        struct client_debug_mask *c_mask;
842        int k_all_index = num_kmod_keyword_mask_map - 1;
843        int rc = 0;
844
845        if (type) {
846                c_mask = (struct client_debug_mask *) mask;
847
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);
851                        rc = 1;
852                        goto out;
853                }
854
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);
858                        rc = 1;
859                        goto out;
860                }
861
862        } else {
863                k_mask = (__u64 *) mask;
864
865                if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
866                        strcpy(kernel_debug_string, ORANGEFS_ALL);
867                        rc = 1;
868                        goto out;
869                }
870        }
871
872out:
873
874        return rc;
875}
876
877/*
878 * kernel = type 0
879 * client = type 1
880 */
881static void debug_string_to_mask(char *debug_string, void *mask, int type)
882{
883        char *unchecked_keyword;
884        int i;
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;
890
891        gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
892
893        if (type) {
894                c_mask = (struct client_debug_mask *)mask;
895                element_count = cdm_element_count;
896        } else {
897                k_mask = (__u64 *)mask;
898                *k_mask = 0;
899                element_count = num_kmod_keyword_mask_map;
900        }
901
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++)
906                                if (type)
907                                        do_c_mask(i,
908                                                  unchecked_keyword,
909                                                  &c_mask);
910                                else
911                                        do_k_mask(i,
912                                                  unchecked_keyword,
913                                                  &k_mask);
914                }
915
916        kfree(original_pointer);
917}
918
919static void do_c_mask(int i, char *unchecked_keyword,
920    struct client_debug_mask **sane_mask)
921{
922
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;
926        }
927}
928
929static void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
930{
931
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;
935}
936
937int orangefs_debugfs_new_client_mask(void __user *arg)
938{
939        struct dev_mask2_info_s mask2_info = {0};
940        int ret;
941
942        ret = copy_from_user(&mask2_info,
943                             (void __user *)arg,
944                             sizeof(struct dev_mask2_info_s));
945
946        if (ret != 0)
947                return -EIO;
948
949        client_debug_mask.mask1 = mask2_info.mask1_value;
950        client_debug_mask.mask2 = mask2_info.mask2_value;
951
952        pr_info("%s: client debug mask has been been received "
953                ":%llx: :%llx:\n",
954                __func__,
955                (unsigned long long)client_debug_mask.mask1,
956                (unsigned long long)client_debug_mask.mask2);
957
958        return ret;
959}
960
961int orangefs_debugfs_new_client_string(void __user *arg)
962{
963        int ret;
964
965        ret = copy_from_user(&client_debug_array_string,
966                                     (void __user *)arg,
967                                     ORANGEFS_MAX_DEBUG_STRING_LEN);
968
969        if (ret != 0) {
970                pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
971                        __func__);
972                return -EIO;
973        }
974
975        /*
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.
984         */
985        client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
986                '\0';
987       
988        pr_info("%s: client debug array string has been received.\n",
989                __func__);
990
991        if (!help_string_initialized) {
992
993                /* Build a proper debug help string. */
994                if (orangefs_prepare_debugfs_help_string(0)) {
995                        gossip_err("%s: no debug help string \n",
996                                   __func__);
997                        return -EIO;
998                }
999
1000        }
1001
1002        debug_mask_to_string(&client_debug_mask, 1);
1003
1004        debugfs_remove(client_debug_dentry);
1005
1006        orangefs_client_debug_init();
1007
1008        help_string_initialized++;
1009
1010        return ret;
1011}
1012
1013int orangefs_debugfs_new_debug(void __user *arg)
1014{
1015        struct dev_mask_info_s mask_info = {0};
1016        int ret;
1017
1018        ret = copy_from_user(&mask_info,
1019                             (void __user *)arg,
1020                             sizeof(mask_info));
1021
1022        if (ret != 0)
1023                return -EIO;
1024
1025        if (mask_info.mask_type == KERNEL_MASK) {
1026                if ((mask_info.mask_value == 0)
1027                    && (kernel_mask_set_mod_init)) {
1028                        /*
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.
1033                         */
1034                        return 0;
1035                }
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 "
1040                        ":%s: :%llx:\n",
1041                        __func__,
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"
1048                        ":%s: :%llx:\n",
1049                        __func__,
1050                        client_debug_string,
1051                        llu(mask_info.mask_value));
1052        } else {
1053                gossip_lerr("Invalid mask type....\n");
1054                return -EINVAL;
1055        }
1056
1057        return ret;
1058}
Note: See TracBrowser for help on using the repository browser.