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 } 1028