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