fs/orangefs/orangefs-debugfs.c

   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  */
  60 struct client_debug_mask {
  61         char *keyword;
  62         __u64 mask1;
  63         __u64 mask2;
  64 };
  65
  66 static int orangefs_kernel_debug_init(void);
  67
  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 *);
  73
  74 static int orangefs_debug_open(struct inode *, struct file *);
  75
  76 static ssize_t orangefs_debug_read(struct file *,
  77                                  char __user *,
  78                                  size_t,
  79                                  loff_t *);
  80
  81 static ssize_t orangefs_debug_write(struct file *,
  82                                   const char __user *,
  83                                   size_t,
  84                                   loff_t *);
  85
  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 **);
  95
  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];
 100
 101 static struct dentry *help_file_dentry;
 102 static struct dentry *client_debug_dentry;
 103 static struct dentry *debug_dir;
 104
 105 static unsigned int kernel_mask_set_mod_init;
 106 static int orangefs_debug_disabled = 1;
 107 static int help_string_initialized;
 108
 109 static 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
 116 const 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
 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,
 130 };
 131
 132 static int client_all_index;
 133 static int client_verbose_index;
 134
 135 static struct client_debug_mask *cdm_array;
 136 static int cdm_element_count;
 137
 138 static 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  */
 144 static DEFINE_MUTEX(orangefs_debug_lock);
 145
 146 /* Used to protect data in ORANGEFS_KMOD_DEBUG_HELP_FILE */
 147 static 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  */
 153 int 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
 204 out:
 205
 206         return rc;
 207 }
 208
 209 /*
 210  * initialize the kernel-debug file.
 211  */
 212 static 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
 246 out:
 247
 248         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
 249         return rc;
 250 }
 251
 252
 253 void orangefs_debugfs_cleanup(void)
 254 {
 255         debugfs_remove_recursive(debug_dir);
 256 }
 257
 258 /* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
 259 static 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
 278 out:
 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  */
 291 static 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
 305 static 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
 312 static 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
 318 static 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  */
 330 int 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
 364 out:
 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.*/
 371 static 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
 388 out:
 389         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 390                      "orangefs_debug_open: rc: %d\n",
 391                      rc);
 392         return rc;
 393 }
 394
 395 static 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
 418 out:
 419         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 420                      "orangefs_debug_read: ret: %zu\n",
 421                      read_ret);
 422
 423         return read_ret;
 424 }
 425
 426 static 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         char *s;
 438
 439         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 440                 "orangefs_debug_write: %pD\n",
 441                 file);
 442
 443         if (count == 0)
 444                 return 0;
 445
 446         /*
 447          * Thwart users who try to jamb a ridiculous number
 448          * of bytes into the debug file...
 449          */
 450         if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) {
 451                 silly = count;
 452                 count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1;
 453         }
 454
 455         buf = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 456         if (!buf)
 457                 goto out;
 458
 459         if (copy_from_user(buf, ubuf, count - 1)) {
 460                 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 461                              "%s: copy_from_user failed!\n",
 462                              __func__);
 463                 goto out;
 464         }
 465
 466         /*
 467          * Map the keyword string from userspace into a valid debug mask.
 468          * The mapping process involves mapping the human-inputted string
 469          * into a valid mask, and then rebuilding the string from the
 470          * verified valid mask.
 471          *
 472          * A service operation is required to set a new client-side
 473          * debug mask.
 474          */
 475         if (!strcmp(file->f_path.dentry->d_name.name,
 476                     ORANGEFS_KMOD_DEBUG_FILE)) {
 477                 debug_string_to_mask(buf, &orangefs_gossip_debug_mask, 0);
 478                 debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
 479                 debug_string = kernel_debug_string;
 480                 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 481                              "New kernel debug string is %s\n",
 482                              kernel_debug_string);
 483         } else {
 484                 /* Can't reset client debug mask if client is not running. */
 485                 if (is_daemon_in_service()) {
 486                         pr_info("%s: Client not running :%d:\n",
 487                                 __func__,
 488                                 is_daemon_in_service());
 489                         goto out;
 490                 }
 491
 492                 debug_string_to_mask(buf, &c_mask, 1);
 493                 debug_mask_to_string(&c_mask, 1);
 494                 debug_string = client_debug_string;
 495
 496                 new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
 497                 if (!new_op) {
 498                         pr_info("%s: op_alloc failed!\n", __func__);
 499                         goto out;
 500                 }
 501
 502                 new_op->upcall.req.param.op =
 503                         ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES;
 504                 new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
 505                 memset(new_op->upcall.req.param.s_value,
 506                        0,
 507                        ORANGEFS_MAX_DEBUG_STRING_LEN);
 508                 sprintf(new_op->upcall.req.param.s_value,
 509                         "%llx %llx\n",
 510                         c_mask.mask1,
 511                         c_mask.mask2);
 512
 513                 /* service_operation returns 0 on success... */
 514                 rc = service_operation(new_op,
 515                                        "orangefs_param",
 516                                         ORANGEFS_OP_INTERRUPTIBLE);
 517
 518                 if (rc)
 519                         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 520                                      "%s: service_operation failed! rc:%d:\n",
 521                                      __func__,
 522                                      rc);
 523
 524                 op_release(new_op);
 525         }
 526
 527         mutex_lock(&orangefs_debug_lock);
 528         s = file_inode(file)->i_private;
 529         memset(s, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
 530         sprintf(s, "%s\n", debug_string);
 531         mutex_unlock(&orangefs_debug_lock);
 532
 533         *ppos += count;
 534         if (silly)
 535                 rc = silly;
 536         else
 537                 rc = count;
 538
 539 out:
 540         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 541                      "orangefs_debug_write: rc: %d\n",
 542                      rc);
 543         kfree(buf);
 544         return rc;
 545 }
 546
 547 /*
 548  * After obtaining a string representation of the client's debug
 549  * keywords and their associated masks, this function is called to build an
 550  * array of these values.
 551  */
 552 static int orangefs_prepare_cdm_array(char *debug_array_string)
 553 {
 554         int i;
 555         int rc = -EINVAL;
 556         char *cds_head = NULL;
 557         char *cds_delimiter = NULL;
 558         int keyword_len = 0;
 559
 560         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 561
 562         /*
 563          * figure out how many elements the cdm_array needs.
 564          */
 565         for (i = 0; i < strlen(debug_array_string); i++)
 566                 if (debug_array_string[i] == '\n')
 567                         cdm_element_count++;
 568
 569         if (!cdm_element_count) {
 570                 pr_info("No elements in client debug array string!\n");
 571                 goto out;
 572         }
 573
 574         cdm_array =
 575                 kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
 576                         GFP_KERNEL);
 577         if (!cdm_array) {
 578                 pr_info("malloc failed for cdm_array!\n");
 579                 rc = -ENOMEM;
 580                 goto out;
 581         }
 582
 583         cds_head = debug_array_string;
 584
 585         for (i = 0; i < cdm_element_count; i++) {
 586                 cds_delimiter = strchr(cds_head, '\n');
 587                 *cds_delimiter = '\0';
 588
 589                 keyword_len = strcspn(cds_head, " ");
 590
 591                 cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
 592                 if (!cdm_array[i].keyword) {
 593                         rc = -ENOMEM;
 594                         goto out;
 595                 }
 596
 597                 sscanf(cds_head,
 598                        "%s %llx %llx",
 599                        cdm_array[i].keyword,
 600                        (unsigned long long *)&(cdm_array[i].mask1),
 601                        (unsigned long long *)&(cdm_array[i].mask2));
 602
 603                 if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
 604                         client_verbose_index = i;
 605
 606                 if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
 607                         client_all_index = i;
 608
 609                 cds_head = cds_delimiter + 1;
 610         }
 611
 612         rc = cdm_element_count;
 613
 614         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
 615
 616 out:
 617
 618         return rc;
 619
 620 }
 621
 622 /*
 623  * /sys/kernel/debug/orangefs/debug-help can be catted to
 624  * see all the available kernel and client debug keywords.
 625  *
 626  * When orangefs.ko initializes, we have no idea what keywords the
 627  * client supports, nor their associated masks.
 628  *
 629  * We pass through this function once at module-load and stamp a
 630  * boilerplate "we don't know" message for the client in the
 631  * debug-help file. We pass through here again when the client
 632  * starts and then we can fill out the debug-help file fully.
 633  *
 634  * The client might be restarted any number of times between
 635  * module reloads, we only build the debug-help file the first time.
 636  */
 637 int orangefs_prepare_debugfs_help_string(int at_boot)
 638 {
 639         char *client_title = "Client Debug Keywords:\n";
 640         char *kernel_title = "Kernel Debug Keywords:\n";
 641         size_t string_size =  DEBUG_HELP_STRING_SIZE;
 642         size_t result_size;
 643         size_t i;
 644         char *new;
 645         int rc = -EINVAL;
 646
 647         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 648
 649         if (at_boot)
 650                 client_title = HELP_STRING_UNINITIALIZED;
 651
 652         /* build a new debug_help_string. */
 653         new = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
 654         if (!new) {
 655                 rc = -ENOMEM;
 656                 goto out;
 657         }
 658
 659         /*
 660          * strlcat(dst, src, size) will append at most
 661          * "size - strlen(dst) - 1" bytes of src onto dst,
 662          * null terminating the result, and return the total
 663          * length of the string it tried to create.
 664          *
 665          * We'll just plow through here building our new debug
 666          * help string and let strlcat take care of assuring that
 667          * dst doesn't overflow.
 668          */
 669         strlcat(new, client_title, string_size);
 670
 671         if (!at_boot) {
 672
 673                 /*
 674                  * fill the client keyword/mask array and remember
 675                  * how many elements there were.
 676                  */
 677                 cdm_element_count =
 678                         orangefs_prepare_cdm_array(client_debug_array_string);
 679                 if (cdm_element_count <= 0) {
 680                         kfree(new);
 681                         goto out;
 682                 }
 683
 684                 for (i = 0; i < cdm_element_count; i++) {
 685                         strlcat(new, "\t", string_size);
 686                         strlcat(new, cdm_array[i].keyword, string_size);
 687                         strlcat(new, "\n", string_size);
 688                 }
 689         }
 690
 691         strlcat(new, "\n", string_size);
 692         strlcat(new, kernel_title, string_size);
 693
 694         for (i = 0; i < num_kmod_keyword_mask_map; i++) {
 695                 strlcat(new, "\t", string_size);
 696                 strlcat(new, s_kmod_keyword_mask_map[i].keyword, string_size);
 697                 result_size = strlcat(new, "\n", string_size);
 698         }
 699
 700         /* See if we tried to put too many bytes into "new"... */
 701         if (result_size >= string_size) {
 702                 kfree(new);
 703                 goto out;
 704         }
 705
 706         if (at_boot) {
 707                 debug_help_string = new;
 708         } else {
 709                 mutex_lock(&orangefs_help_file_lock);
 710                 memset(debug_help_string, 0, DEBUG_HELP_STRING_SIZE);
 711                 strlcat(debug_help_string, new, string_size);
 712                 mutex_unlock(&orangefs_help_file_lock);
 713         }
 714
 715         rc = 0;
 716
 717 out:    return rc;
 718
 719 }
 720
 721 /*
 722  * kernel = type 0
 723  * client = type 1
 724  */
 725 static void debug_mask_to_string(void *mask, int type)
 726 {
 727         int i;
 728         int len = 0;
 729         char *debug_string;
 730         int element_count = 0;
 731
 732         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 733
 734         if (type) {
 735                 debug_string = client_debug_string;
 736                 element_count = cdm_element_count;
 737         } else {
 738                 debug_string = kernel_debug_string;
 739                 element_count = num_kmod_keyword_mask_map;
 740         }
 741
 742         memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
 743
 744         /*
 745          * Some keywords, like "all" or "verbose", are amalgams of
 746          * numerous other keywords. Make a special check for those
 747          * before grinding through the whole mask only to find out
 748          * later...
 749          */
 750         if (check_amalgam_keyword(mask, type))
 751                 goto out;
 752
 753         /* Build the debug string. */
 754         for (i = 0; i < element_count; i++)
 755                 if (type)
 756                         do_c_string(mask, i);
 757                 else
 758                         do_k_string(mask, i);
 759
 760         len = strlen(debug_string);
 761
 762         if ((len) && (type))
 763                 client_debug_string[len - 1] = '\0';
 764         else if (len)
 765                 kernel_debug_string[len - 1] = '\0';
 766         else if (type)
 767                 strcpy(client_debug_string, "none");
 768         else
 769                 strcpy(kernel_debug_string, "none");
 770
 771 out:
 772 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
 773
 774         return;
 775
 776 }
 777
 778 static void do_k_string(void *k_mask, int index)
 779 {
 780         __u64 *mask = (__u64 *) k_mask;
 781
 782         if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
 783                 goto out;
 784
 785         if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
 786                 if ((strlen(kernel_debug_string) +
 787                      strlen(s_kmod_keyword_mask_map[index].keyword))
 788                         < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
 789                                 strcat(kernel_debug_string,
 790                                        s_kmod_keyword_mask_map[index].keyword);
 791                                 strcat(kernel_debug_string, ",");
 792                         } else {
 793                                 gossip_err("%s: overflow!\n", __func__);
 794                                 strcpy(kernel_debug_string, ORANGEFS_ALL);
 795                                 goto out;
 796                         }
 797         }
 798
 799 out:
 800
 801         return;
 802 }
 803
 804 static void do_c_string(void *c_mask, int index)
 805 {
 806         struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
 807
 808         if (keyword_is_amalgam(cdm_array[index].keyword))
 809                 goto out;
 810
 811         if ((mask->mask1 & cdm_array[index].mask1) ||
 812             (mask->mask2 & cdm_array[index].mask2)) {
 813                 if ((strlen(client_debug_string) +
 814                      strlen(cdm_array[index].keyword) + 1)
 815                         < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
 816                                 strcat(client_debug_string,
 817                                        cdm_array[index].keyword);
 818                                 strcat(client_debug_string, ",");
 819                         } else {
 820                                 gossip_err("%s: overflow!\n", __func__);
 821                                 strcpy(client_debug_string, ORANGEFS_ALL);
 822                                 goto out;
 823                         }
 824         }
 825 out:
 826         return;
 827 }
 828
 829 static int keyword_is_amalgam(char *keyword)
 830 {
 831         int rc = 0;
 832
 833         if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
 834                 rc = 1;
 835
 836         return rc;
 837 }
 838
 839 /*
 840  * kernel = type 0
 841  * client = type 1
 842  *
 843  * return 1 if we found an amalgam.
 844  */
 845 static int check_amalgam_keyword(void *mask, int type)
 846 {
 847         __u64 *k_mask;
 848         struct client_debug_mask *c_mask;
 849         int k_all_index = num_kmod_keyword_mask_map - 1;
 850         int rc = 0;
 851
 852         if (type) {
 853                 c_mask = (struct client_debug_mask *) mask;
 854
 855                 if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
 856                     (c_mask->mask2 == cdm_array[client_all_index].mask2)) {
 857                         strcpy(client_debug_string, ORANGEFS_ALL);
 858                         rc = 1;
 859                         goto out;
 860                 }
 861
 862                 if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
 863                     (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
 864                         strcpy(client_debug_string, ORANGEFS_VERBOSE);
 865                         rc = 1;
 866                         goto out;
 867                 }
 868
 869         } else {
 870                 k_mask = (__u64 *) mask;
 871
 872                 if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
 873                         strcpy(kernel_debug_string, ORANGEFS_ALL);
 874                         rc = 1;
 875                         goto out;
 876                 }
 877         }
 878
 879 out:
 880
 881         return rc;
 882 }
 883
 884 /*
 885  * kernel = type 0
 886  * client = type 1
 887  */
 888 static void debug_string_to_mask(char *debug_string, void *mask, int type)
 889 {
 890         char *unchecked_keyword;
 891         int i;
 892         char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
 893         char *original_pointer;
 894         int element_count = 0;
 895         struct client_debug_mask *c_mask = NULL;
 896         __u64 *k_mask = NULL;
 897
 898         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 899
 900         if (type) {
 901                 c_mask = (struct client_debug_mask *)mask;
 902                 element_count = cdm_element_count;
 903         } else {
 904                 k_mask = (__u64 *)mask;
 905                 *k_mask = 0;
 906                 element_count = num_kmod_keyword_mask_map;
 907         }
 908
 909         original_pointer = strsep_fodder;
 910         while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
 911                 if (strlen(unchecked_keyword)) {
 912                         for (i = 0; i < element_count; i++)
 913                                 if (type)
 914                                         do_c_mask(i,
 915                                                   unchecked_keyword,
 916                                                   &c_mask);
 917                                 else
 918                                         do_k_mask(i,
 919                                                   unchecked_keyword,
 920                                                   &k_mask);
 921                 }
 922
 923         kfree(original_pointer);
 924 }
 925
 926 static void do_c_mask(int i, char *unchecked_keyword,
 927     struct client_debug_mask **sane_mask)
 928 {
 929
 930         if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
 931                 (**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
 932                 (**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
 933         }
 934 }
 935
 936 static void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
 937 {
 938
 939         if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
 940                 **sane_mask = (**sane_mask) |
 941                                 s_kmod_keyword_mask_map[i].mask_val;
 942 }
 943
 944 int orangefs_debugfs_new_client_mask(void __user *arg)
 945 {
 946         struct dev_mask2_info_s mask2_info = {0};
 947         int ret;
 948
 949         ret = copy_from_user(&mask2_info,
 950                              (void __user *)arg,
 951                              sizeof(struct dev_mask2_info_s));
 952
 953         if (ret != 0)
 954                 return -EIO;
 955
 956         client_debug_mask.mask1 = mask2_info.mask1_value;
 957         client_debug_mask.mask2 = mask2_info.mask2_value;
 958
 959         pr_info("%s: client debug mask has been been received "
 960                 ":%llx: :%llx:\n",
 961                 __func__,
 962                 (unsigned long long)client_debug_mask.mask1,
 963                 (unsigned long long)client_debug_mask.mask2);
 964
 965         return ret;
 966 }
 967
 968 int orangefs_debugfs_new_client_string(void __user *arg)
 969 {
 970         int ret;
 971
 972         ret = copy_from_user(&client_debug_array_string,
 973                              (void __user *)arg,
 974                              ORANGEFS_MAX_DEBUG_STRING_LEN);
 975
 976         if (ret != 0) {
 977                 pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
 978                         __func__);
 979                 return -EFAULT;
 980         }
 981
 982         /*
 983          * The real client-core makes an effort to ensure
 984          * that actual strings that aren't too long to fit in
 985          * this buffer is what we get here. We're going to use
 986          * string functions on the stuff we got, so we'll make
 987          * this extra effort to try and keep from
 988          * flowing out of this buffer when we use the string
 989          * functions, even if somehow the stuff we end up
 990          * with here is garbage.
 991          */
 992         client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
 993                 '\0';
 994
 995         pr_info("%s: client debug array string has been received.\n",
 996                 __func__);
 997
 998         if (!help_string_initialized) {
 999
1000                 /* Build a proper debug help string. */
1001                 ret = orangefs_prepare_debugfs_help_string(0);
1002                 if (ret) {
1003                         gossip_err("%s: no debug help string \n",
1004                                    __func__);
1005                         return ret;
1006                 }
1007
1008         }
1009
1010         debug_mask_to_string(&client_debug_mask, 1);
1011
1012         debugfs_remove(client_debug_dentry);
1013
1014         orangefs_client_debug_init();
1015
1016         help_string_initialized++;
1017
1018         return 0;
1019 }
1020
1021 int orangefs_debugfs_new_debug(void __user *arg)
1022 {
1023         struct dev_mask_info_s mask_info = {0};
1024         int ret;
1025
1026         ret = copy_from_user(&mask_info,
1027                              (void __user *)arg,
1028                              sizeof(mask_info));
1029
1030         if (ret != 0)
1031                 return -EIO;
1032
1033         if (mask_info.mask_type == KERNEL_MASK) {
1034                 if ((mask_info.mask_value == 0)
1035                     && (kernel_mask_set_mod_init)) {
1036                         /*
1037                          * the kernel debug mask was set when the
1038                          * kernel module was loaded; don't override
1039                          * it if the client-core was started without
1040                          * a value for ORANGEFS_KMODMASK.
1041                          */
1042                         return 0;
1043                 }
1044                 debug_mask_to_string(&mask_info.mask_value,
1045                                      mask_info.mask_type);
1046                 orangefs_gossip_debug_mask = mask_info.mask_value;
1047                 pr_info("%s: kernel debug mask has been modified to "
1048                         ":%s: :%llx:\n",
1049                         __func__,
1050                         kernel_debug_string,
1051                         (unsigned long long)orangefs_gossip_debug_mask);
1052         } else if (mask_info.mask_type == CLIENT_MASK) {
1053                 debug_mask_to_string(&mask_info.mask_value,
1054                                      mask_info.mask_type);
1055                 pr_info("%s: client debug mask has been modified to"
1056                         ":%s: :%llx:\n",
1057                         __func__,
1058                         client_debug_string,
1059                         llu(mask_info.mask_value));
1060         } else {
1061                 gossip_lerr("Invalid mask type....\n");
1062                 return -EINVAL;
1063         }
1064
1065         return ret;
1066 }