fs/orangefs/orangefs-debugfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * What:                /sys/kernel/debug/orangefs/debug-help
   4  * Date:                June 2015
   5  * Contact:             Mike Marshall <hubcap@omnibond.com>
   6  * Description:
   7  *                      List of client and kernel debug keywords.
   8  *
   9  *
  10  * What:                /sys/kernel/debug/orangefs/client-debug
  11  * Date:                June 2015
  12  * Contact:             Mike Marshall <hubcap@omnibond.com>
  13  * Description:
  14  *                      Debug setting for "the client", the userspace
  15  *                      helper for the kernel module.
  16  *
  17  *
  18  * What:                /sys/kernel/debug/orangefs/kernel-debug
  19  * Date:                June 2015
  20  * Contact:             Mike Marshall <hubcap@omnibond.com>
  21  * Description:
  22  *                      Debug setting for the orangefs kernel module.
  23  *
  24  *                      Any of the keywords, or comma-separated lists
  25  *                      of keywords, from debug-help can be catted to
  26  *                      client-debug or kernel-debug.
  27  *
  28  *                      "none", "all" and "verbose" are special keywords
  29  *                      for client-debug. Setting client-debug to "all"
  30  *                      is kind of like trying to drink water from a
  31  *                      fire hose, "verbose" triggers most of the same
  32  *                      output except for the constant flow of output
  33  *                      from the main wait loop.
  34  *
  35  *                      "none" and "all" are similar settings for kernel-debug
  36  *                      no need for a "verbose".
  37  */
  38 #include <linux/debugfs.h>
  39 #include <linux/slab.h>
  40
  41 #include <linux/uaccess.h>
  42
  43 #include "orangefs-debugfs.h"
  44 #include "protocol.h"
  45 #include "orangefs-kernel.h"
  46
  47 #define DEBUG_HELP_STRING_SIZE 4096
  48 #define HELP_STRING_UNINITIALIZED \
  49         "Client Debug Keywords are unknown until the first time\n" \
  50         "the client is started after boot.\n"
  51 #define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help"
  52 #define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug"
  53 #define ORANGEFS_CLIENT_DEBUG_FILE "client-debug"
  54 #define ORANGEFS_VERBOSE "verbose"
  55 #define ORANGEFS_ALL "all"
  56
  57 /*
  58  * An array of client_debug_mask will be built to hold debug keyword/mask
  59  * values fetched from userspace.
  60  */
  61 struct client_debug_mask {
  62         char *keyword;
  63         __u64 mask1;
  64         __u64 mask2;
  65 };
  66
  67 static void orangefs_kernel_debug_init(void);
  68
  69 static int orangefs_debug_help_open(struct inode *, struct file *);
  70 static void *help_start(struct seq_file *, loff_t *);
  71 static void *help_next(struct seq_file *, void *, loff_t *);
  72 static void help_stop(struct seq_file *, void *);
  73 static int help_show(struct seq_file *, void *);
  74
  75 static int orangefs_debug_open(struct inode *, struct file *);
  76
  77 static ssize_t orangefs_debug_read(struct file *,
  78                                  char __user *,
  79                                  size_t,
  80                                  loff_t *);
  81
  82 static ssize_t orangefs_debug_write(struct file *,
  83                                   const char __user *,
  84                                   size_t,
  85                                   loff_t *);
  86
  87 static int orangefs_prepare_cdm_array(char *);
  88 static void debug_mask_to_string(void *, int);
  89 static void do_k_string(void *, int);
  90 static void do_c_string(void *, int);
  91 static int keyword_is_amalgam(char *);
  92 static int check_amalgam_keyword(void *, int);
  93 static void debug_string_to_mask(char *, void *, int);
  94 static void do_c_mask(int, char *, struct client_debug_mask **);
  95 static void do_k_mask(int, char *, __u64 **);
  96
  97 static char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN] = "none";
  98 static char *debug_help_string;
  99 static char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
 100 static char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
 101
 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 static 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 void orangefs_debugfs_init(int debug_mask)
 154 {
 155         /* convert input debug mask to a 64-bit unsigned integer */
 156         orangefs_gossip_debug_mask = (unsigned long long)debug_mask;
 157
 158         /*
 159          * set the kernel's gossip debug string; invalid mask values will
 160          * be ignored.
 161          */
 162         debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
 163
 164         /* remove any invalid values from the mask */
 165         debug_string_to_mask(kernel_debug_string, &orangefs_gossip_debug_mask,
 166             0);
 167
 168         /*
 169          * if the mask has a non-zero value, then indicate that the mask
 170          * was set when the kernel module was loaded.  The orangefs dev ioctl
 171          * command will look at this boolean to determine if the kernel's
 172          * debug mask should be overwritten when the client-core is started.
 173          */
 174         if (orangefs_gossip_debug_mask != 0)
 175                 kernel_mask_set_mod_init = true;
 176
 177         pr_info("%s: called with debug mask: :%s: :%llx:\n",
 178                 __func__,
 179                 kernel_debug_string,
 180                 (unsigned long long)orangefs_gossip_debug_mask);
 181
 182         debug_dir = debugfs_create_dir("orangefs", NULL);
 183
 184         debugfs_create_file(ORANGEFS_KMOD_DEBUG_HELP_FILE, 0444, debug_dir,
 185                             debug_help_string, &debug_help_fops);
 186
 187         orangefs_debug_disabled = 0;
 188
 189         orangefs_kernel_debug_init();
 190 }
 191
 192 /*
 193  * initialize the kernel-debug file.
 194  */
 195 static void orangefs_kernel_debug_init(void)
 196 {
 197         int rc = -ENOMEM;
 198         char *k_buffer = NULL;
 199
 200         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
 201
 202         k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 203         if (!k_buffer)
 204                 goto out;
 205
 206         if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
 207                 strcpy(k_buffer, kernel_debug_string);
 208                 strcat(k_buffer, "\n");
 209         } else {
 210                 strcpy(k_buffer, "none\n");
 211                 pr_info("%s: overflow 1!\n", __func__);
 212         }
 213
 214         debugfs_create_file(ORANGEFS_KMOD_DEBUG_FILE, 0444, debug_dir, k_buffer,
 215                             &kernel_debug_fops);
 216
 217 out:
 218         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
 219 }
 220
 221
 222 void orangefs_debugfs_cleanup(void)
 223 {
 224         debugfs_remove_recursive(debug_dir);
 225 }
 226
 227 /* open ORANGEFS_KMOD_DEBUG_HELP_FILE */
 228 static int orangefs_debug_help_open(struct inode *inode, struct file *file)
 229 {
 230         int rc = -ENODEV;
 231         int ret;
 232
 233         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 234                      "orangefs_debug_help_open: start\n");
 235
 236         if (orangefs_debug_disabled)
 237                 goto out;
 238
 239         ret = seq_open(file, &help_debug_ops);
 240         if (ret)
 241                 goto out;
 242
 243         ((struct seq_file *)(file->private_data))->private = inode->i_private;
 244
 245         rc = 0;
 246
 247 out:
 248         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 249                      "orangefs_debug_help_open: rc:%d:\n",
 250                      rc);
 251         return rc;
 252 }
 253
 254 /*
 255  * I think start always gets called again after stop. Start
 256  * needs to return NULL when it is done. The whole "payload"
 257  * in this case is a single (long) string, so by the second
 258  * time we get to start (pos = 1), we're done.
 259  */
 260 static void *help_start(struct seq_file *m, loff_t *pos)
 261 {
 262         void *payload = NULL;
 263
 264         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n");
 265
 266         mutex_lock(&orangefs_help_file_lock);
 267
 268         if (*pos == 0)
 269                 payload = m->private;
 270
 271         return payload;
 272 }
 273
 274 static void *help_next(struct seq_file *m, void *v, loff_t *pos)
 275 {
 276         (*pos)++;
 277         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_next: start\n");
 278
 279         return NULL;
 280 }
 281
 282 static void help_stop(struct seq_file *m, void *p)
 283 {
 284         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n");
 285         mutex_unlock(&orangefs_help_file_lock);
 286 }
 287
 288 static int help_show(struct seq_file *m, void *v)
 289 {
 290         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_show: start\n");
 291
 292         seq_puts(m, v);
 293
 294         return 0;
 295 }
 296
 297 /*
 298  * initialize the client-debug file.
 299  */
 300 static int orangefs_client_debug_init(void)
 301 {
 302
 303         int rc = -ENOMEM;
 304         char *c_buffer = NULL;
 305
 306         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
 307
 308         c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 309         if (!c_buffer)
 310                 goto out;
 311
 312         if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
 313                 strcpy(c_buffer, client_debug_string);
 314                 strcat(c_buffer, "\n");
 315         } else {
 316                 strcpy(c_buffer, "none\n");
 317                 pr_info("%s: overflow! 2\n", __func__);
 318         }
 319
 320         client_debug_dentry = debugfs_create_file(ORANGEFS_CLIENT_DEBUG_FILE,
 321                                                   0444,
 322                                                   debug_dir,
 323                                                   c_buffer,
 324                                                   &kernel_debug_fops);
 325
 326         rc = 0;
 327
 328 out:
 329
 330         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
 331         return rc;
 332 }
 333
 334 /* open ORANGEFS_KMOD_DEBUG_FILE or ORANGEFS_CLIENT_DEBUG_FILE.*/
 335 static int orangefs_debug_open(struct inode *inode, struct file *file)
 336 {
 337         int rc = -ENODEV;
 338
 339         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 340                      "%s: orangefs_debug_disabled: %d\n",
 341                      __func__,
 342                      orangefs_debug_disabled);
 343
 344         if (orangefs_debug_disabled)
 345                 goto out;
 346
 347         rc = 0;
 348         mutex_lock(&orangefs_debug_lock);
 349         file->private_data = inode->i_private;
 350         mutex_unlock(&orangefs_debug_lock);
 351
 352 out:
 353         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 354                      "orangefs_debug_open: rc: %d\n",
 355                      rc);
 356         return rc;
 357 }
 358
 359 static ssize_t orangefs_debug_read(struct file *file,
 360                                  char __user *ubuf,
 361                                  size_t count,
 362                                  loff_t *ppos)
 363 {
 364         char *buf;
 365         int sprintf_ret;
 366         ssize_t read_ret = -ENOMEM;
 367
 368         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");
 369
 370         buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 371         if (!buf)
 372                 goto out;
 373
 374         mutex_lock(&orangefs_debug_lock);
 375         sprintf_ret = sprintf(buf, "%s", (char *)file->private_data);
 376         mutex_unlock(&orangefs_debug_lock);
 377
 378         read_ret = simple_read_from_buffer(ubuf, count, ppos, buf, sprintf_ret);
 379
 380         kfree(buf);
 381
 382 out:
 383         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 384                      "orangefs_debug_read: ret: %zu\n",
 385                      read_ret);
 386
 387         return read_ret;
 388 }
 389
 390 static ssize_t orangefs_debug_write(struct file *file,
 391                                   const char __user *ubuf,
 392                                   size_t count,
 393                                   loff_t *ppos)
 394 {
 395         char *buf;
 396         int rc = -EFAULT;
 397         size_t silly = 0;
 398         char *debug_string;
 399         struct orangefs_kernel_op_s *new_op = NULL;
 400         struct client_debug_mask c_mask = { NULL, 0, 0 };
 401         char *s;
 402
 403         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 404                 "orangefs_debug_write: %pD\n",
 405                 file);
 406
 407         if (count == 0)
 408                 return 0;
 409
 410         /*
 411          * Thwart users who try to jamb a ridiculous number
 412          * of bytes into the debug file...
 413          */
 414         if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) {
 415                 silly = count;
 416                 count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1;
 417         }
 418
 419         buf = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 420         if (!buf)
 421                 goto out;
 422
 423         if (copy_from_user(buf, ubuf, count - 1)) {
 424                 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 425                              "%s: copy_from_user failed!\n",
 426                              __func__);
 427                 goto out;
 428         }
 429
 430         /*
 431          * Map the keyword string from userspace into a valid debug mask.
 432          * The mapping process involves mapping the human-inputted string
 433          * into a valid mask, and then rebuilding the string from the
 434          * verified valid mask.
 435          *
 436          * A service operation is required to set a new client-side
 437          * debug mask.
 438          */
 439         if (!strcmp(file->f_path.dentry->d_name.name,
 440                     ORANGEFS_KMOD_DEBUG_FILE)) {
 441                 debug_string_to_mask(buf, &orangefs_gossip_debug_mask, 0);
 442                 debug_mask_to_string(&orangefs_gossip_debug_mask, 0);
 443                 debug_string = kernel_debug_string;
 444                 gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 445                              "New kernel debug string is %s\n",
 446                              kernel_debug_string);
 447         } else {
 448                 /* Can't reset client debug mask if client is not running. */
 449                 if (is_daemon_in_service()) {
 450                         pr_info("%s: Client not running :%d:\n",
 451                                 __func__,
 452                                 is_daemon_in_service());
 453                         goto out;
 454                 }
 455
 456                 debug_string_to_mask(buf, &c_mask, 1);
 457                 debug_mask_to_string(&c_mask, 1);
 458                 debug_string = client_debug_string;
 459
 460                 new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
 461                 if (!new_op) {
 462                         pr_info("%s: op_alloc failed!\n", __func__);
 463                         goto out;
 464                 }
 465
 466                 new_op->upcall.req.param.op =
 467                         ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES;
 468                 new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
 469                 memset(new_op->upcall.req.param.s_value,
 470                        0,
 471                        ORANGEFS_MAX_DEBUG_STRING_LEN);
 472                 sprintf(new_op->upcall.req.param.s_value,
 473                         "%llx %llx\n",
 474                         c_mask.mask1,
 475                         c_mask.mask2);
 476
 477                 /* service_operation returns 0 on success... */
 478                 rc = service_operation(new_op,
 479                                        "orangefs_param",
 480                                         ORANGEFS_OP_INTERRUPTIBLE);
 481
 482                 if (rc)
 483                         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 484                                      "%s: service_operation failed! rc:%d:\n",
 485                                      __func__,
 486                                      rc);
 487
 488                 op_release(new_op);
 489         }
 490
 491         mutex_lock(&orangefs_debug_lock);
 492         s = file_inode(file)->i_private;
 493         memset(s, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
 494         sprintf(s, "%s\n", debug_string);
 495         mutex_unlock(&orangefs_debug_lock);
 496
 497         *ppos += count;
 498         if (silly)
 499                 rc = silly;
 500         else
 501                 rc = count;
 502
 503 out:
 504         gossip_debug(GOSSIP_DEBUGFS_DEBUG,
 505                      "orangefs_debug_write: rc: %d\n",
 506                      rc);
 507         kfree(buf);
 508         return rc;
 509 }
 510
 511 /*
 512  * After obtaining a string representation of the client's debug
 513  * keywords and their associated masks, this function is called to build an
 514  * array of these values.
 515  */
 516 static int orangefs_prepare_cdm_array(char *debug_array_string)
 517 {
 518         int i;
 519         int rc = -EINVAL;
 520         char *cds_head = NULL;
 521         char *cds_delimiter = NULL;
 522         int keyword_len = 0;
 523
 524         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 525
 526         /*
 527          * figure out how many elements the cdm_array needs.
 528          */
 529         for (i = 0; i < strlen(debug_array_string); i++)
 530                 if (debug_array_string[i] == '\n')
 531                         cdm_element_count++;
 532
 533         if (!cdm_element_count) {
 534                 pr_info("No elements in client debug array string!\n");
 535                 goto out;
 536         }
 537
 538         cdm_array = kcalloc(cdm_element_count, sizeof(*cdm_array), GFP_KERNEL);
 539         if (!cdm_array) {
 540                 rc = -ENOMEM;
 541                 goto out;
 542         }
 543
 544         cds_head = debug_array_string;
 545
 546         for (i = 0; i < cdm_element_count; i++) {
 547                 cds_delimiter = strchr(cds_head, '\n');
 548                 *cds_delimiter = '\0';
 549
 550                 keyword_len = strcspn(cds_head, " ");
 551
 552                 cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
 553                 if (!cdm_array[i].keyword) {
 554                         rc = -ENOMEM;
 555                         goto out;
 556                 }
 557
 558                 sscanf(cds_head,
 559                        "%s %llx %llx",
 560                        cdm_array[i].keyword,
 561                        (unsigned long long *)&(cdm_array[i].mask1),
 562                        (unsigned long long *)&(cdm_array[i].mask2));
 563
 564                 if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
 565                         client_verbose_index = i;
 566
 567                 if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
 568                         client_all_index = i;
 569
 570                 cds_head = cds_delimiter + 1;
 571         }
 572
 573         rc = cdm_element_count;
 574
 575         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
 576
 577 out:
 578
 579         return rc;
 580
 581 }
 582
 583 /*
 584  * /sys/kernel/debug/orangefs/debug-help can be catted to
 585  * see all the available kernel and client debug keywords.
 586  *
 587  * When orangefs.ko initializes, we have no idea what keywords the
 588  * client supports, nor their associated masks.
 589  *
 590  * We pass through this function once at module-load and stamp a
 591  * boilerplate "we don't know" message for the client in the
 592  * debug-help file. We pass through here again when the client
 593  * starts and then we can fill out the debug-help file fully.
 594  *
 595  * The client might be restarted any number of times between
 596  * module reloads, we only build the debug-help file the first time.
 597  */
 598 int orangefs_prepare_debugfs_help_string(int at_boot)
 599 {
 600         char *client_title = "Client Debug Keywords:\n";
 601         char *kernel_title = "Kernel Debug Keywords:\n";
 602         size_t string_size =  DEBUG_HELP_STRING_SIZE;
 603         size_t result_size;
 604         size_t i;
 605         char *new;
 606         int rc = -EINVAL;
 607
 608         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 609
 610         if (at_boot)
 611                 client_title = HELP_STRING_UNINITIALIZED;
 612
 613         /* build a new debug_help_string. */
 614         new = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
 615         if (!new) {
 616                 rc = -ENOMEM;
 617                 goto out;
 618         }
 619
 620         /*
 621          * strlcat(dst, src, size) will append at most
 622          * "size - strlen(dst) - 1" bytes of src onto dst,
 623          * null terminating the result, and return the total
 624          * length of the string it tried to create.
 625          *
 626          * We'll just plow through here building our new debug
 627          * help string and let strlcat take care of assuring that
 628          * dst doesn't overflow.
 629          */
 630         strlcat(new, client_title, string_size);
 631
 632         if (!at_boot) {
 633
 634                 /*
 635                  * fill the client keyword/mask array and remember
 636                  * how many elements there were.
 637                  */
 638                 cdm_element_count =
 639                         orangefs_prepare_cdm_array(client_debug_array_string);
 640                 if (cdm_element_count <= 0) {
 641                         kfree(new);
 642                         goto out;
 643                 }
 644
 645                 for (i = 0; i < cdm_element_count; i++) {
 646                         strlcat(new, "\t", string_size);
 647                         strlcat(new, cdm_array[i].keyword, string_size);
 648                         strlcat(new, "\n", string_size);
 649                 }
 650         }
 651
 652         strlcat(new, "\n", string_size);
 653         strlcat(new, kernel_title, string_size);
 654
 655         for (i = 0; i < num_kmod_keyword_mask_map; i++) {
 656                 strlcat(new, "\t", string_size);
 657                 strlcat(new, s_kmod_keyword_mask_map[i].keyword, string_size);
 658                 result_size = strlcat(new, "\n", string_size);
 659         }
 660
 661         /* See if we tried to put too many bytes into "new"... */
 662         if (result_size >= string_size) {
 663                 kfree(new);
 664                 goto out;
 665         }
 666
 667         if (at_boot) {
 668                 debug_help_string = new;
 669         } else {
 670                 mutex_lock(&orangefs_help_file_lock);
 671                 memset(debug_help_string, 0, DEBUG_HELP_STRING_SIZE);
 672                 strlcat(debug_help_string, new, string_size);
 673                 mutex_unlock(&orangefs_help_file_lock);
 674         }
 675
 676         rc = 0;
 677
 678 out:    return rc;
 679
 680 }
 681
 682 /*
 683  * kernel = type 0
 684  * client = type 1
 685  */
 686 static void debug_mask_to_string(void *mask, int type)
 687 {
 688         int i;
 689         int len = 0;
 690         char *debug_string;
 691         int element_count = 0;
 692
 693         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 694
 695         if (type) {
 696                 debug_string = client_debug_string;
 697                 element_count = cdm_element_count;
 698         } else {
 699                 debug_string = kernel_debug_string;
 700                 element_count = num_kmod_keyword_mask_map;
 701         }
 702
 703         memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
 704
 705         /*
 706          * Some keywords, like "all" or "verbose", are amalgams of
 707          * numerous other keywords. Make a special check for those
 708          * before grinding through the whole mask only to find out
 709          * later...
 710          */
 711         if (check_amalgam_keyword(mask, type))
 712                 goto out;
 713
 714         /* Build the debug string. */
 715         for (i = 0; i < element_count; i++)
 716                 if (type)
 717                         do_c_string(mask, i);
 718                 else
 719                         do_k_string(mask, i);
 720
 721         len = strlen(debug_string);
 722
 723         if ((len) && (type))
 724                 client_debug_string[len - 1] = '\0';
 725         else if (len)
 726                 kernel_debug_string[len - 1] = '\0';
 727         else if (type)
 728                 strcpy(client_debug_string, "none");
 729         else
 730                 strcpy(kernel_debug_string, "none");
 731
 732 out:
 733 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
 734
 735         return;
 736
 737 }
 738
 739 static void do_k_string(void *k_mask, int index)
 740 {
 741         __u64 *mask = (__u64 *) k_mask;
 742
 743         if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
 744                 goto out;
 745
 746         if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
 747                 if ((strlen(kernel_debug_string) +
 748                      strlen(s_kmod_keyword_mask_map[index].keyword))
 749                         < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
 750                                 strcat(kernel_debug_string,
 751                                        s_kmod_keyword_mask_map[index].keyword);
 752                                 strcat(kernel_debug_string, ",");
 753                         } else {
 754                                 gossip_err("%s: overflow!\n", __func__);
 755                                 strcpy(kernel_debug_string, ORANGEFS_ALL);
 756                                 goto out;
 757                         }
 758         }
 759
 760 out:
 761
 762         return;
 763 }
 764
 765 static void do_c_string(void *c_mask, int index)
 766 {
 767         struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
 768
 769         if (keyword_is_amalgam(cdm_array[index].keyword))
 770                 goto out;
 771
 772         if ((mask->mask1 & cdm_array[index].mask1) ||
 773             (mask->mask2 & cdm_array[index].mask2)) {
 774                 if ((strlen(client_debug_string) +
 775                      strlen(cdm_array[index].keyword) + 1)
 776                         < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
 777                                 strcat(client_debug_string,
 778                                        cdm_array[index].keyword);
 779                                 strcat(client_debug_string, ",");
 780                         } else {
 781                                 gossip_err("%s: overflow!\n", __func__);
 782                                 strcpy(client_debug_string, ORANGEFS_ALL);
 783                                 goto out;
 784                         }
 785         }
 786 out:
 787         return;
 788 }
 789
 790 static int keyword_is_amalgam(char *keyword)
 791 {
 792         int rc = 0;
 793
 794         if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
 795                 rc = 1;
 796
 797         return rc;
 798 }
 799
 800 /*
 801  * kernel = type 0
 802  * client = type 1
 803  *
 804  * return 1 if we found an amalgam.
 805  */
 806 static int check_amalgam_keyword(void *mask, int type)
 807 {
 808         __u64 *k_mask;
 809         struct client_debug_mask *c_mask;
 810         int k_all_index = num_kmod_keyword_mask_map - 1;
 811         int rc = 0;
 812
 813         if (type) {
 814                 c_mask = (struct client_debug_mask *) mask;
 815
 816                 if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
 817                     (c_mask->mask2 == cdm_array[client_all_index].mask2)) {
 818                         strcpy(client_debug_string, ORANGEFS_ALL);
 819                         rc = 1;
 820                         goto out;
 821                 }
 822
 823                 if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
 824                     (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
 825                         strcpy(client_debug_string, ORANGEFS_VERBOSE);
 826                         rc = 1;
 827                         goto out;
 828                 }
 829
 830         } else {
 831                 k_mask = (__u64 *) mask;
 832
 833                 if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
 834                         strcpy(kernel_debug_string, ORANGEFS_ALL);
 835                         rc = 1;
 836                         goto out;
 837                 }
 838         }
 839
 840 out:
 841
 842         return rc;
 843 }
 844
 845 /*
 846  * kernel = type 0
 847  * client = type 1
 848  */
 849 static void debug_string_to_mask(char *debug_string, void *mask, int type)
 850 {
 851         char *unchecked_keyword;
 852         int i;
 853         char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
 854         char *original_pointer;
 855         int element_count = 0;
 856         struct client_debug_mask *c_mask = NULL;
 857         __u64 *k_mask = NULL;
 858
 859         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 860
 861         if (type) {
 862                 c_mask = (struct client_debug_mask *)mask;
 863                 element_count = cdm_element_count;
 864         } else {
 865                 k_mask = (__u64 *)mask;
 866                 *k_mask = 0;
 867                 element_count = num_kmod_keyword_mask_map;
 868         }
 869
 870         original_pointer = strsep_fodder;
 871         while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
 872                 if (strlen(unchecked_keyword)) {
 873                         for (i = 0; i < element_count; i++)
 874                                 if (type)
 875                                         do_c_mask(i,
 876                                                   unchecked_keyword,
 877                                                   &c_mask);
 878                                 else
 879                                         do_k_mask(i,
 880                                                   unchecked_keyword,
 881                                                   &k_mask);
 882                 }
 883
 884         kfree(original_pointer);
 885 }
 886
 887 static void do_c_mask(int i, char *unchecked_keyword,
 888     struct client_debug_mask **sane_mask)
 889 {
 890
 891         if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
 892                 (**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
 893                 (**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
 894         }
 895 }
 896
 897 static void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
 898 {
 899
 900         if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
 901                 **sane_mask = (**sane_mask) |
 902                                 s_kmod_keyword_mask_map[i].mask_val;
 903 }
 904
 905 int orangefs_debugfs_new_client_mask(void __user *arg)
 906 {
 907         struct dev_mask2_info_s mask2_info = {0};
 908         int ret;
 909
 910         ret = copy_from_user(&mask2_info,
 911                              (void __user *)arg,
 912                              sizeof(struct dev_mask2_info_s));
 913
 914         if (ret != 0)
 915                 return -EIO;
 916
 917         client_debug_mask.mask1 = mask2_info.mask1_value;
 918         client_debug_mask.mask2 = mask2_info.mask2_value;
 919
 920         pr_info("%s: client debug mask has been been received "
 921                 ":%llx: :%llx:\n",
 922                 __func__,
 923                 (unsigned long long)client_debug_mask.mask1,
 924                 (unsigned long long)client_debug_mask.mask2);
 925
 926         return ret;
 927 }
 928
 929 int orangefs_debugfs_new_client_string(void __user *arg)
 930 {
 931         int ret;
 932
 933         ret = copy_from_user(&client_debug_array_string,
 934                              (void __user *)arg,
 935                              ORANGEFS_MAX_DEBUG_STRING_LEN);
 936
 937         if (ret != 0) {
 938                 pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
 939                         __func__);
 940                 return -EFAULT;
 941         }
 942
 943         /*
 944          * The real client-core makes an effort to ensure
 945          * that actual strings that aren't too long to fit in
 946          * this buffer is what we get here. We're going to use
 947          * string functions on the stuff we got, so we'll make
 948          * this extra effort to try and keep from
 949          * flowing out of this buffer when we use the string
 950          * functions, even if somehow the stuff we end up
 951          * with here is garbage.
 952          */
 953         client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
 954                 '\0';
 955
 956         pr_info("%s: client debug array string has been received.\n",
 957                 __func__);
 958
 959         if (!help_string_initialized) {
 960
 961                 /* Build a proper debug help string. */
 962                 ret = orangefs_prepare_debugfs_help_string(0);
 963                 if (ret) {
 964                         gossip_err("%s: no debug help string \n",
 965                                    __func__);
 966                         return ret;
 967                 }
 968
 969         }
 970
 971         debug_mask_to_string(&client_debug_mask, 1);
 972
 973         debugfs_remove(client_debug_dentry);
 974
 975         orangefs_client_debug_init();
 976
 977         help_string_initialized++;
 978
 979         return 0;
 980 }
 981
 982 int orangefs_debugfs_new_debug(void __user *arg)
 983 {
 984         struct dev_mask_info_s mask_info = {0};
 985         int ret;
 986
 987         ret = copy_from_user(&mask_info,
 988                              (void __user *)arg,
 989                              sizeof(mask_info));
 990
 991         if (ret != 0)
 992                 return -EIO;
 993
 994         if (mask_info.mask_type == KERNEL_MASK) {
 995                 if ((mask_info.mask_value == 0)
 996                     && (kernel_mask_set_mod_init)) {
 997                         /*
 998                          * the kernel debug mask was set when the
 999                          * kernel module was loaded; don't override
1000                          * it if the client-core was started without
1001                          * a value for ORANGEFS_KMODMASK.
1002                          */
1003                         return 0;
1004                 }
1005                 debug_mask_to_string(&mask_info.mask_value,
1006                                      mask_info.mask_type);
1007                 orangefs_gossip_debug_mask = mask_info.mask_value;
1008                 pr_info("%s: kernel debug mask has been modified to "
1009                         ":%s: :%llx:\n",
1010                         __func__,
1011                         kernel_debug_string,
1012                         (unsigned long long)orangefs_gossip_debug_mask);
1013         } else if (mask_info.mask_type == CLIENT_MASK) {
1014                 debug_mask_to_string(&mask_info.mask_value,
1015                                      mask_info.mask_type);
1016                 pr_info("%s: client debug mask has been modified to"
1017                         ":%s: :%llx:\n",
1018                         __func__,
1019                         client_debug_string,
1020                         llu(mask_info.mask_value));
1021         } else {
1022                 gossip_err("Invalid mask type....\n");
1023                 return -EINVAL;
1024         }
1025
1026         return ret;
1027 }