1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * S/390 debug facility 4 * 5 * Copyright IBM Corp. 1999, 2012 6 * 7 * Author(s): Michael Holzheu (holzheu@de.ibm.com), 8 * Holger Smolinski (Holger.Smolinski@de.ibm.com) 9 * 10 * Bugreports to: <Linux390@de.ibm.com> 11 */ 12 13 #define KMSG_COMPONENT "s390dbf" 14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 15 16 #include <linux/stddef.h> 17 #include <linux/kernel.h> 18 #include <linux/errno.h> 19 #include <linux/slab.h> 20 #include <linux/ctype.h> 21 #include <linux/string.h> 22 #include <linux/sysctl.h> 23 #include <linux/uaccess.h> 24 #include <linux/export.h> 25 #include <linux/init.h> 26 #include <linux/fs.h> 27 #include <linux/debugfs.h> 28 29 #include <asm/debug.h> 30 31 #define DEBUG_PROLOG_ENTRY -1 32 33 #define ALL_AREAS 0 /* copy all debug areas */ 34 #define NO_AREAS 1 /* copy no debug areas */ 35 36 /* typedefs */ 37 38 typedef struct file_private_info { 39 loff_t offset; /* offset of last read in file */ 40 int act_area; /* number of last formated area */ 41 int act_page; /* act page in given area */ 42 int act_entry; /* last formated entry (offset */ 43 /* relative to beginning of last */ 44 /* formated page) */ 45 size_t act_entry_offset; /* up to this offset we copied */ 46 /* in last read the last formated */ 47 /* entry to userland */ 48 char temp_buf[2048]; /* buffer for output */ 49 debug_info_t *debug_info_org; /* original debug information */ 50 debug_info_t *debug_info_snap; /* snapshot of debug information */ 51 struct debug_view *view; /* used view of debug info */ 52 } file_private_info_t; 53 54 typedef struct { 55 char *string; 56 /* 57 * This assumes that all args are converted into longs 58 * on L/390 this is the case for all types of parameter 59 * except of floats, and long long (32 bit) 60 * 61 */ 62 long args[0]; 63 } debug_sprintf_entry_t; 64 65 /* internal function prototyes */ 66 67 static int debug_init(void); 68 static ssize_t debug_output(struct file *file, char __user *user_buf, 69 size_t user_len, loff_t *offset); 70 static ssize_t debug_input(struct file *file, const char __user *user_buf, 71 size_t user_len, loff_t *offset); 72 static int debug_open(struct inode *inode, struct file *file); 73 static int debug_close(struct inode *inode, struct file *file); 74 static debug_info_t *debug_info_create(const char *name, int pages_per_area, 75 int nr_areas, int buf_size, umode_t mode); 76 static void debug_info_get(debug_info_t *); 77 static void debug_info_put(debug_info_t *); 78 static int debug_prolog_level_fn(debug_info_t *id, 79 struct debug_view *view, char *out_buf); 80 static int debug_input_level_fn(debug_info_t *id, struct debug_view *view, 81 struct file *file, const char __user *user_buf, 82 size_t user_buf_size, loff_t *offset); 83 static int debug_prolog_pages_fn(debug_info_t *id, 84 struct debug_view *view, char *out_buf); 85 static int debug_input_pages_fn(debug_info_t *id, struct debug_view *view, 86 struct file *file, const char __user *user_buf, 87 size_t user_buf_size, loff_t *offset); 88 static int debug_input_flush_fn(debug_info_t *id, struct debug_view *view, 89 struct file *file, const char __user *user_buf, 90 size_t user_buf_size, loff_t *offset); 91 static int debug_hex_ascii_format_fn(debug_info_t *id, struct debug_view *view, 92 char *out_buf, const char *in_buf); 93 static int debug_raw_format_fn(debug_info_t *id, 94 struct debug_view *view, char *out_buf, 95 const char *in_buf); 96 static int debug_raw_header_fn(debug_info_t *id, struct debug_view *view, 97 int area, debug_entry_t *entry, char *out_buf); 98 99 static int debug_sprintf_format_fn(debug_info_t *id, struct debug_view *view, 100 char *out_buf, debug_sprintf_entry_t *curr_event); 101 102 /* globals */ 103 104 struct debug_view debug_raw_view = { 105 "raw", 106 NULL, 107 &debug_raw_header_fn, 108 &debug_raw_format_fn, 109 NULL, 110 NULL 111 }; 112 EXPORT_SYMBOL(debug_raw_view); 113 114 struct debug_view debug_hex_ascii_view = { 115 "hex_ascii", 116 NULL, 117 &debug_dflt_header_fn, 118 &debug_hex_ascii_format_fn, 119 NULL, 120 NULL 121 }; 122 EXPORT_SYMBOL(debug_hex_ascii_view); 123 124 static struct debug_view debug_level_view = { 125 "level", 126 &debug_prolog_level_fn, 127 NULL, 128 NULL, 129 &debug_input_level_fn, 130 NULL 131 }; 132 133 static struct debug_view debug_pages_view = { 134 "pages", 135 &debug_prolog_pages_fn, 136 NULL, 137 NULL, 138 &debug_input_pages_fn, 139 NULL 140 }; 141 142 static struct debug_view debug_flush_view = { 143 "flush", 144 NULL, 145 NULL, 146 NULL, 147 &debug_input_flush_fn, 148 NULL 149 }; 150 151 struct debug_view debug_sprintf_view = { 152 "sprintf", 153 NULL, 154 &debug_dflt_header_fn, 155 (debug_format_proc_t *)&debug_sprintf_format_fn, 156 NULL, 157 NULL 158 }; 159 EXPORT_SYMBOL(debug_sprintf_view); 160 161 /* used by dump analysis tools to determine version of debug feature */ 162 static unsigned int __used debug_feature_version = __DEBUG_FEATURE_VERSION; 163 164 /* static globals */ 165 166 static debug_info_t *debug_area_first; 167 static debug_info_t *debug_area_last; 168 static DEFINE_MUTEX(debug_mutex); 169 170 static int initialized; 171 static int debug_critical; 172 173 static const struct file_operations debug_file_ops = { 174 .owner = THIS_MODULE, 175 .read = debug_output, 176 .write = debug_input, 177 .open = debug_open, 178 .release = debug_close, 179 .llseek = no_llseek, 180 }; 181 182 static struct dentry *debug_debugfs_root_entry; 183 184 /* functions */ 185 186 /* 187 * debug_areas_alloc 188 * - Debug areas are implemented as a threedimensonal array: 189 * areas[areanumber][pagenumber][pageoffset] 190 */ 191 192 static debug_entry_t ***debug_areas_alloc(int pages_per_area, int nr_areas) 193 { 194 debug_entry_t ***areas; 195 int i, j; 196 197 areas = kmalloc(nr_areas * sizeof(debug_entry_t **), GFP_KERNEL); 198 if (!areas) 199 goto fail_malloc_areas; 200 for (i = 0; i < nr_areas; i++) { 201 areas[i] = kmalloc(pages_per_area * sizeof(debug_entry_t *), GFP_KERNEL); 202 if (!areas[i]) 203 goto fail_malloc_areas2; 204 for (j = 0; j < pages_per_area; j++) { 205 areas[i][j] = kzalloc(PAGE_SIZE, GFP_KERNEL); 206 if (!areas[i][j]) { 207 for (j--; j >= 0 ; j--) 208 kfree(areas[i][j]); 209 kfree(areas[i]); 210 goto fail_malloc_areas2; 211 } 212 } 213 } 214 return areas; 215 216 fail_malloc_areas2: 217 for (i--; i >= 0; i--) { 218 for (j = 0; j < pages_per_area; j++) 219 kfree(areas[i][j]); 220 kfree(areas[i]); 221 } 222 kfree(areas); 223 fail_malloc_areas: 224 return NULL; 225 } 226 227 /* 228 * debug_info_alloc 229 * - alloc new debug-info 230 */ 231 static debug_info_t *debug_info_alloc(const char *name, int pages_per_area, 232 int nr_areas, int buf_size, int level, 233 int mode) 234 { 235 debug_info_t *rc; 236 237 /* alloc everything */ 238 rc = kmalloc(sizeof(debug_info_t), GFP_KERNEL); 239 if (!rc) 240 goto fail_malloc_rc; 241 rc->active_entries = kcalloc(nr_areas, sizeof(int), GFP_KERNEL); 242 if (!rc->active_entries) 243 goto fail_malloc_active_entries; 244 rc->active_pages = kcalloc(nr_areas, sizeof(int), GFP_KERNEL); 245 if (!rc->active_pages) 246 goto fail_malloc_active_pages; 247 if ((mode == ALL_AREAS) && (pages_per_area != 0)) { 248 rc->areas = debug_areas_alloc(pages_per_area, nr_areas); 249 if (!rc->areas) 250 goto fail_malloc_areas; 251 } else { 252 rc->areas = NULL; 253 } 254 255 /* initialize members */ 256 spin_lock_init(&rc->lock); 257 rc->pages_per_area = pages_per_area; 258 rc->nr_areas = nr_areas; 259 rc->active_area = 0; 260 rc->level = level; 261 rc->buf_size = buf_size; 262 rc->entry_size = sizeof(debug_entry_t) + buf_size; 263 strlcpy(rc->name, name, sizeof(rc->name)); 264 memset(rc->views, 0, DEBUG_MAX_VIEWS * sizeof(struct debug_view *)); 265 memset(rc->debugfs_entries, 0, DEBUG_MAX_VIEWS * sizeof(struct dentry *)); 266 refcount_set(&(rc->ref_count), 0); 267 268 return rc; 269 270 fail_malloc_areas: 271 kfree(rc->active_pages); 272 fail_malloc_active_pages: 273 kfree(rc->active_entries); 274 fail_malloc_active_entries: 275 kfree(rc); 276 fail_malloc_rc: 277 return NULL; 278 } 279 280 /* 281 * debug_areas_free 282 * - free all debug areas 283 */ 284 static void debug_areas_free(debug_info_t *db_info) 285 { 286 int i, j; 287 288 if (!db_info->areas) 289 return; 290 for (i = 0; i < db_info->nr_areas; i++) { 291 for (j = 0; j < db_info->pages_per_area; j++) 292 kfree(db_info->areas[i][j]); 293 kfree(db_info->areas[i]); 294 } 295 kfree(db_info->areas); 296 db_info->areas = NULL; 297 } 298 299 /* 300 * debug_info_free 301 * - free memory debug-info 302 */ 303 static void debug_info_free(debug_info_t *db_info) 304 { 305 debug_areas_free(db_info); 306 kfree(db_info->active_entries); 307 kfree(db_info->active_pages); 308 kfree(db_info); 309 } 310 311 /* 312 * debug_info_create 313 * - create new debug-info 314 */ 315 316 static debug_info_t *debug_info_create(const char *name, int pages_per_area, 317 int nr_areas, int buf_size, umode_t mode) 318 { 319 debug_info_t *rc; 320 321 rc = debug_info_alloc(name, pages_per_area, nr_areas, buf_size, 322 DEBUG_DEFAULT_LEVEL, ALL_AREAS); 323 if (!rc) 324 goto out; 325 326 rc->mode = mode & ~S_IFMT; 327 328 /* create root directory */ 329 rc->debugfs_root_entry = debugfs_create_dir(rc->name, 330 debug_debugfs_root_entry); 331 332 /* append new element to linked list */ 333 if (!debug_area_first) { 334 /* first element in list */ 335 debug_area_first = rc; 336 rc->prev = NULL; 337 } else { 338 /* append element to end of list */ 339 debug_area_last->next = rc; 340 rc->prev = debug_area_last; 341 } 342 debug_area_last = rc; 343 rc->next = NULL; 344 345 refcount_set(&rc->ref_count, 1); 346 out: 347 return rc; 348 } 349 350 /* 351 * debug_info_copy 352 * - copy debug-info 353 */ 354 static debug_info_t *debug_info_copy(debug_info_t *in, int mode) 355 { 356 unsigned long flags; 357 debug_info_t *rc; 358 int i, j; 359 360 /* get a consistent copy of the debug areas */ 361 do { 362 rc = debug_info_alloc(in->name, in->pages_per_area, 363 in->nr_areas, in->buf_size, in->level, mode); 364 spin_lock_irqsave(&in->lock, flags); 365 if (!rc) 366 goto out; 367 /* has something changed in the meantime ? */ 368 if ((rc->pages_per_area == in->pages_per_area) && 369 (rc->nr_areas == in->nr_areas)) { 370 break; 371 } 372 spin_unlock_irqrestore(&in->lock, flags); 373 debug_info_free(rc); 374 } while (1); 375 376 if (mode == NO_AREAS) 377 goto out; 378 379 for (i = 0; i < in->nr_areas; i++) { 380 for (j = 0; j < in->pages_per_area; j++) 381 memcpy(rc->areas[i][j], in->areas[i][j], PAGE_SIZE); 382 } 383 out: 384 spin_unlock_irqrestore(&in->lock, flags); 385 return rc; 386 } 387 388 /* 389 * debug_info_get 390 * - increments reference count for debug-info 391 */ 392 static void debug_info_get(debug_info_t *db_info) 393 { 394 if (db_info) 395 refcount_inc(&db_info->ref_count); 396 } 397 398 /* 399 * debug_info_put: 400 * - decreases reference count for debug-info and frees it if necessary 401 */ 402 static void debug_info_put(debug_info_t *db_info) 403 { 404 int i; 405 406 if (!db_info) 407 return; 408 if (refcount_dec_and_test(&db_info->ref_count)) { 409 for (i = 0; i < DEBUG_MAX_VIEWS; i++) { 410 if (!db_info->views[i]) 411 continue; 412 debugfs_remove(db_info->debugfs_entries[i]); 413 } 414 debugfs_remove(db_info->debugfs_root_entry); 415 if (db_info == debug_area_first) 416 debug_area_first = db_info->next; 417 if (db_info == debug_area_last) 418 debug_area_last = db_info->prev; 419 if (db_info->prev) 420 db_info->prev->next = db_info->next; 421 if (db_info->next) 422 db_info->next->prev = db_info->prev; 423 debug_info_free(db_info); 424 } 425 } 426 427 /* 428 * debug_format_entry: 429 * - format one debug entry and return size of formated data 430 */ 431 static int debug_format_entry(file_private_info_t *p_info) 432 { 433 debug_info_t *id_snap = p_info->debug_info_snap; 434 struct debug_view *view = p_info->view; 435 debug_entry_t *act_entry; 436 size_t len = 0; 437 438 if (p_info->act_entry == DEBUG_PROLOG_ENTRY) { 439 /* print prolog */ 440 if (view->prolog_proc) 441 len += view->prolog_proc(id_snap, view, p_info->temp_buf); 442 goto out; 443 } 444 if (!id_snap->areas) /* this is true, if we have a prolog only view */ 445 goto out; /* or if 'pages_per_area' is 0 */ 446 act_entry = (debug_entry_t *) ((char *)id_snap->areas[p_info->act_area] 447 [p_info->act_page] + p_info->act_entry); 448 449 if (act_entry->id.stck == 0LL) 450 goto out; /* empty entry */ 451 if (view->header_proc) 452 len += view->header_proc(id_snap, view, p_info->act_area, 453 act_entry, p_info->temp_buf + len); 454 if (view->format_proc) 455 len += view->format_proc(id_snap, view, p_info->temp_buf + len, 456 DEBUG_DATA(act_entry)); 457 out: 458 return len; 459 } 460 461 /* 462 * debug_next_entry: 463 * - goto next entry in p_info 464 */ 465 static inline int debug_next_entry(file_private_info_t *p_info) 466 { 467 debug_info_t *id; 468 469 id = p_info->debug_info_snap; 470 if (p_info->act_entry == DEBUG_PROLOG_ENTRY) { 471 p_info->act_entry = 0; 472 p_info->act_page = 0; 473 goto out; 474 } 475 if (!id->areas) 476 return 1; 477 p_info->act_entry += id->entry_size; 478 /* switch to next page, if we reached the end of the page */ 479 if (p_info->act_entry > (PAGE_SIZE - id->entry_size)) { 480 /* next page */ 481 p_info->act_entry = 0; 482 p_info->act_page += 1; 483 if ((p_info->act_page % id->pages_per_area) == 0) { 484 /* next area */ 485 p_info->act_area++; 486 p_info->act_page = 0; 487 } 488 if (p_info->act_area >= id->nr_areas) 489 return 1; 490 } 491 out: 492 return 0; 493 } 494 495 /* 496 * debug_output: 497 * - called for user read() 498 * - copies formated debug entries to the user buffer 499 */ 500 static ssize_t debug_output(struct file *file, /* file descriptor */ 501 char __user *user_buf, /* user buffer */ 502 size_t len, /* length of buffer */ 503 loff_t *offset) /* offset in the file */ 504 { 505 size_t count = 0; 506 size_t entry_offset; 507 file_private_info_t *p_info; 508 509 p_info = (file_private_info_t *) file->private_data; 510 if (*offset != p_info->offset) 511 return -EPIPE; 512 if (p_info->act_area >= p_info->debug_info_snap->nr_areas) 513 return 0; 514 entry_offset = p_info->act_entry_offset; 515 while (count < len) { 516 int formatted_line_residue; 517 int formatted_line_size; 518 int user_buf_residue; 519 size_t copy_size; 520 521 formatted_line_size = debug_format_entry(p_info); 522 formatted_line_residue = formatted_line_size - entry_offset; 523 user_buf_residue = len-count; 524 copy_size = min(user_buf_residue, formatted_line_residue); 525 if (copy_size) { 526 if (copy_to_user(user_buf + count, p_info->temp_buf 527 + entry_offset, copy_size)) 528 return -EFAULT; 529 count += copy_size; 530 entry_offset += copy_size; 531 } 532 if (copy_size == formatted_line_residue) { 533 entry_offset = 0; 534 if (debug_next_entry(p_info)) 535 goto out; 536 } 537 } 538 out: 539 p_info->offset = *offset + count; 540 p_info->act_entry_offset = entry_offset; 541 *offset = p_info->offset; 542 return count; 543 } 544 545 /* 546 * debug_input: 547 * - called for user write() 548 * - calls input function of view 549 */ 550 static ssize_t debug_input(struct file *file, const char __user *user_buf, 551 size_t length, loff_t *offset) 552 { 553 file_private_info_t *p_info; 554 int rc = 0; 555 556 mutex_lock(&debug_mutex); 557 p_info = ((file_private_info_t *) file->private_data); 558 if (p_info->view->input_proc) { 559 rc = p_info->view->input_proc(p_info->debug_info_org, 560 p_info->view, file, user_buf, 561 length, offset); 562 } else { 563 rc = -EPERM; 564 } 565 mutex_unlock(&debug_mutex); 566 return rc; /* number of input characters */ 567 } 568 569 /* 570 * debug_open: 571 * - called for user open() 572 * - copies formated output to private_data area of the file 573 * handle 574 */ 575 static int debug_open(struct inode *inode, struct file *file) 576 { 577 debug_info_t *debug_info, *debug_info_snapshot; 578 file_private_info_t *p_info; 579 int i, rc = 0; 580 581 mutex_lock(&debug_mutex); 582 debug_info = file_inode(file)->i_private; 583 /* find debug view */ 584 for (i = 0; i < DEBUG_MAX_VIEWS; i++) { 585 if (!debug_info->views[i]) 586 continue; 587 else if (debug_info->debugfs_entries[i] == file->f_path.dentry) 588 goto found; /* found view ! */ 589 } 590 /* no entry found */ 591 rc = -EINVAL; 592 goto out; 593 594 found: 595 596 /* Make snapshot of current debug areas to get it consistent. */ 597 /* To copy all the areas is only needed, if we have a view which */ 598 /* formats the debug areas. */ 599 600 if (!debug_info->views[i]->format_proc && !debug_info->views[i]->header_proc) 601 debug_info_snapshot = debug_info_copy(debug_info, NO_AREAS); 602 else 603 debug_info_snapshot = debug_info_copy(debug_info, ALL_AREAS); 604 605 if (!debug_info_snapshot) { 606 rc = -ENOMEM; 607 goto out; 608 } 609 p_info = kmalloc(sizeof(file_private_info_t), GFP_KERNEL); 610 if (!p_info) { 611 debug_info_free(debug_info_snapshot); 612 rc = -ENOMEM; 613 goto out; 614 } 615 p_info->offset = 0; 616 p_info->debug_info_snap = debug_info_snapshot; 617 p_info->debug_info_org = debug_info; 618 p_info->view = debug_info->views[i]; 619 p_info->act_area = 0; 620 p_info->act_page = 0; 621 p_info->act_entry = DEBUG_PROLOG_ENTRY; 622 p_info->act_entry_offset = 0; 623 file->private_data = p_info; 624 debug_info_get(debug_info); 625 nonseekable_open(inode, file); 626 out: 627 mutex_unlock(&debug_mutex); 628 return rc; 629 } 630 631 /* 632 * debug_close: 633 * - called for user close() 634 * - deletes private_data area of the file handle 635 */ 636 static int debug_close(struct inode *inode, struct file *file) 637 { 638 file_private_info_t *p_info; 639 640 p_info = (file_private_info_t *) file->private_data; 641 if (p_info->debug_info_snap) 642 debug_info_free(p_info->debug_info_snap); 643 debug_info_put(p_info->debug_info_org); 644 kfree(file->private_data); 645 return 0; /* success */ 646 } 647 648 /* 649 * debug_register_mode: 650 * - Creates and initializes debug area for the caller 651 * The mode parameter allows to specify access rights for the s390dbf files 652 * - Returns handle for debug area 653 */ 654 debug_info_t *debug_register_mode(const char *name, int pages_per_area, 655 int nr_areas, int buf_size, umode_t mode, 656 uid_t uid, gid_t gid) 657 { 658 debug_info_t *rc = NULL; 659 660 /* Since debugfs currently does not support uid/gid other than root, */ 661 /* we do not allow gid/uid != 0 until we get support for that. */ 662 if ((uid != 0) || (gid != 0)) 663 pr_warn("Root becomes the owner of all s390dbf files in sysfs\n"); 664 BUG_ON(!initialized); 665 mutex_lock(&debug_mutex); 666 667 /* create new debug_info */ 668 rc = debug_info_create(name, pages_per_area, nr_areas, buf_size, mode); 669 if (!rc) 670 goto out; 671 debug_register_view(rc, &debug_level_view); 672 debug_register_view(rc, &debug_flush_view); 673 debug_register_view(rc, &debug_pages_view); 674 out: 675 if (!rc) 676 pr_err("Registering debug feature %s failed\n", name); 677 mutex_unlock(&debug_mutex); 678 return rc; 679 } 680 EXPORT_SYMBOL(debug_register_mode); 681 682 /* 683 * debug_register: 684 * - creates and initializes debug area for the caller 685 * - returns handle for debug area 686 */ 687 debug_info_t *debug_register(const char *name, int pages_per_area, 688 int nr_areas, int buf_size) 689 { 690 return debug_register_mode(name, pages_per_area, nr_areas, buf_size, 691 S_IRUSR | S_IWUSR, 0, 0); 692 } 693 EXPORT_SYMBOL(debug_register); 694 695 /* 696 * debug_unregister: 697 * - give back debug area 698 */ 699 void debug_unregister(debug_info_t *id) 700 { 701 if (!id) 702 return; 703 mutex_lock(&debug_mutex); 704 debug_info_put(id); 705 mutex_unlock(&debug_mutex); 706 } 707 EXPORT_SYMBOL(debug_unregister); 708 709 /* 710 * debug_set_size: 711 * - set area size (number of pages) and number of areas 712 */ 713 static int debug_set_size(debug_info_t *id, int nr_areas, int pages_per_area) 714 { 715 debug_entry_t ***new_areas; 716 unsigned long flags; 717 int rc = 0; 718 719 if (!id || (nr_areas <= 0) || (pages_per_area < 0)) 720 return -EINVAL; 721 if (pages_per_area > 0) { 722 new_areas = debug_areas_alloc(pages_per_area, nr_areas); 723 if (!new_areas) { 724 pr_info("Allocating memory for %i pages failed\n", 725 pages_per_area); 726 rc = -ENOMEM; 727 goto out; 728 } 729 } else { 730 new_areas = NULL; 731 } 732 spin_lock_irqsave(&id->lock, flags); 733 debug_areas_free(id); 734 id->areas = new_areas; 735 id->nr_areas = nr_areas; 736 id->pages_per_area = pages_per_area; 737 id->active_area = 0; 738 memset(id->active_entries, 0, sizeof(int)*id->nr_areas); 739 memset(id->active_pages, 0, sizeof(int)*id->nr_areas); 740 spin_unlock_irqrestore(&id->lock, flags); 741 pr_info("%s: set new size (%i pages)\n", id->name, pages_per_area); 742 out: 743 return rc; 744 } 745 746 /* 747 * debug_set_level: 748 * - set actual debug level 749 */ 750 void debug_set_level(debug_info_t *id, int new_level) 751 { 752 unsigned long flags; 753 754 if (!id) 755 return; 756 spin_lock_irqsave(&id->lock, flags); 757 if (new_level == DEBUG_OFF_LEVEL) { 758 id->level = DEBUG_OFF_LEVEL; 759 pr_info("%s: switched off\n", id->name); 760 } else if ((new_level > DEBUG_MAX_LEVEL) || (new_level < 0)) { 761 pr_info("%s: level %i is out of range (%i - %i)\n", 762 id->name, new_level, 0, DEBUG_MAX_LEVEL); 763 } else { 764 id->level = new_level; 765 } 766 spin_unlock_irqrestore(&id->lock, flags); 767 } 768 EXPORT_SYMBOL(debug_set_level); 769 770 /* 771 * proceed_active_entry: 772 * - set active entry to next in the ring buffer 773 */ 774 static inline void proceed_active_entry(debug_info_t *id) 775 { 776 if ((id->active_entries[id->active_area] += id->entry_size) 777 > (PAGE_SIZE - id->entry_size)) { 778 id->active_entries[id->active_area] = 0; 779 id->active_pages[id->active_area] = 780 (id->active_pages[id->active_area] + 1) % 781 id->pages_per_area; 782 } 783 } 784 785 /* 786 * proceed_active_area: 787 * - set active area to next in the ring buffer 788 */ 789 static inline void proceed_active_area(debug_info_t *id) 790 { 791 id->active_area++; 792 id->active_area = id->active_area % id->nr_areas; 793 } 794 795 /* 796 * get_active_entry: 797 */ 798 static inline debug_entry_t *get_active_entry(debug_info_t *id) 799 { 800 return (debug_entry_t *) (((char *) id->areas[id->active_area] 801 [id->active_pages[id->active_area]]) + 802 id->active_entries[id->active_area]); 803 } 804 805 /* 806 * debug_finish_entry: 807 * - set timestamp, caller address, cpu number etc. 808 */ 809 810 static inline void debug_finish_entry(debug_info_t *id, debug_entry_t *active, 811 int level, int exception) 812 { 813 active->id.stck = get_tod_clock_fast() - 814 *(unsigned long long *) &tod_clock_base[1]; 815 active->id.fields.cpuid = smp_processor_id(); 816 active->caller = __builtin_return_address(0); 817 active->id.fields.exception = exception; 818 active->id.fields.level = level; 819 proceed_active_entry(id); 820 if (exception) 821 proceed_active_area(id); 822 } 823 824 static int debug_stoppable = 1; 825 static int debug_active = 1; 826 827 #define CTL_S390DBF_STOPPABLE 5678 828 #define CTL_S390DBF_ACTIVE 5679 829 830 /* 831 * proc handler for the running debug_active sysctl 832 * always allow read, allow write only if debug_stoppable is set or 833 * if debug_active is already off 834 */ 835 static int s390dbf_procactive(struct ctl_table *table, int write, 836 void __user *buffer, size_t *lenp, loff_t *ppos) 837 { 838 if (!write || debug_stoppable || !debug_active) 839 return proc_dointvec(table, write, buffer, lenp, ppos); 840 else 841 return 0; 842 } 843 844 static struct ctl_table s390dbf_table[] = { 845 { 846 .procname = "debug_stoppable", 847 .data = &debug_stoppable, 848 .maxlen = sizeof(int), 849 .mode = S_IRUGO | S_IWUSR, 850 .proc_handler = proc_dointvec, 851 }, 852 { 853 .procname = "debug_active", 854 .data = &debug_active, 855 .maxlen = sizeof(int), 856 .mode = S_IRUGO | S_IWUSR, 857 .proc_handler = s390dbf_procactive, 858 }, 859 { } 860 }; 861 862 static struct ctl_table s390dbf_dir_table[] = { 863 { 864 .procname = "s390dbf", 865 .maxlen = 0, 866 .mode = S_IRUGO | S_IXUGO, 867 .child = s390dbf_table, 868 }, 869 { } 870 }; 871 872 static struct ctl_table_header *s390dbf_sysctl_header; 873 874 void debug_stop_all(void) 875 { 876 if (debug_stoppable) 877 debug_active = 0; 878 } 879 EXPORT_SYMBOL(debug_stop_all); 880 881 void debug_set_critical(void) 882 { 883 debug_critical = 1; 884 } 885 886 /* 887 * debug_event_common: 888 * - write debug entry with given size 889 */ 890 debug_entry_t *debug_event_common(debug_info_t *id, int level, const void *buf, 891 int len) 892 { 893 debug_entry_t *active; 894 unsigned long flags; 895 896 if (!debug_active || !id->areas) 897 return NULL; 898 if (debug_critical) { 899 if (!spin_trylock_irqsave(&id->lock, flags)) 900 return NULL; 901 } else { 902 spin_lock_irqsave(&id->lock, flags); 903 } 904 do { 905 active = get_active_entry(id); 906 memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size)); 907 if (len < id->buf_size) 908 memset((DEBUG_DATA(active)) + len, 0, id->buf_size - len); 909 debug_finish_entry(id, active, level, 0); 910 len -= id->buf_size; 911 buf += id->buf_size; 912 } while (len > 0); 913 914 spin_unlock_irqrestore(&id->lock, flags); 915 return active; 916 } 917 EXPORT_SYMBOL(debug_event_common); 918 919 /* 920 * debug_exception_common: 921 * - write debug entry with given size and switch to next debug area 922 */ 923 debug_entry_t *debug_exception_common(debug_info_t *id, int level, 924 const void *buf, int len) 925 { 926 debug_entry_t *active; 927 unsigned long flags; 928 929 if (!debug_active || !id->areas) 930 return NULL; 931 if (debug_critical) { 932 if (!spin_trylock_irqsave(&id->lock, flags)) 933 return NULL; 934 } else { 935 spin_lock_irqsave(&id->lock, flags); 936 } 937 do { 938 active = get_active_entry(id); 939 memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size)); 940 if (len < id->buf_size) 941 memset((DEBUG_DATA(active)) + len, 0, id->buf_size - len); 942 debug_finish_entry(id, active, level, len <= id->buf_size); 943 len -= id->buf_size; 944 buf += id->buf_size; 945 } while (len > 0); 946 947 spin_unlock_irqrestore(&id->lock, flags); 948 return active; 949 } 950 EXPORT_SYMBOL(debug_exception_common); 951 952 /* 953 * counts arguments in format string for sprintf view 954 */ 955 static inline int debug_count_numargs(char *string) 956 { 957 int numargs = 0; 958 959 while (*string) { 960 if (*string++ == '%') 961 numargs++; 962 } 963 return numargs; 964 } 965 966 /* 967 * debug_sprintf_event: 968 */ 969 debug_entry_t *__debug_sprintf_event(debug_info_t *id, int level, char *string, ...) 970 { 971 debug_sprintf_entry_t *curr_event; 972 debug_entry_t *active; 973 unsigned long flags; 974 int numargs, idx; 975 va_list ap; 976 977 if (!debug_active || !id->areas) 978 return NULL; 979 numargs = debug_count_numargs(string); 980 981 if (debug_critical) { 982 if (!spin_trylock_irqsave(&id->lock, flags)) 983 return NULL; 984 } else { 985 spin_lock_irqsave(&id->lock, flags); 986 } 987 active = get_active_entry(id); 988 curr_event = (debug_sprintf_entry_t *) DEBUG_DATA(active); 989 va_start(ap, string); 990 curr_event->string = string; 991 for (idx = 0; idx < min(numargs, (int)(id->buf_size / sizeof(long)) - 1); idx++) 992 curr_event->args[idx] = va_arg(ap, long); 993 va_end(ap); 994 debug_finish_entry(id, active, level, 0); 995 spin_unlock_irqrestore(&id->lock, flags); 996 997 return active; 998 } 999 EXPORT_SYMBOL(__debug_sprintf_event); 1000 1001 /* 1002 * debug_sprintf_exception: 1003 */ 1004 debug_entry_t *__debug_sprintf_exception(debug_info_t *id, int level, char *string, ...) 1005 { 1006 debug_sprintf_entry_t *curr_event; 1007 debug_entry_t *active; 1008 unsigned long flags; 1009 int numargs, idx; 1010 va_list ap; 1011 1012 if (!debug_active || !id->areas) 1013 return NULL; 1014 1015 numargs = debug_count_numargs(string); 1016 1017 if (debug_critical) { 1018 if (!spin_trylock_irqsave(&id->lock, flags)) 1019 return NULL; 1020 } else { 1021 spin_lock_irqsave(&id->lock, flags); 1022 } 1023 active = get_active_entry(id); 1024 curr_event = (debug_sprintf_entry_t *)DEBUG_DATA(active); 1025 va_start(ap, string); 1026 curr_event->string = string; 1027 for (idx = 0; idx < min(numargs, (int)(id->buf_size / sizeof(long)) - 1); idx++) 1028 curr_event->args[idx] = va_arg(ap, long); 1029 va_end(ap); 1030 debug_finish_entry(id, active, level, 1); 1031 spin_unlock_irqrestore(&id->lock, flags); 1032 1033 return active; 1034 } 1035 EXPORT_SYMBOL(__debug_sprintf_exception); 1036 1037 /* 1038 * debug_register_view: 1039 */ 1040 int debug_register_view(debug_info_t *id, struct debug_view *view) 1041 { 1042 unsigned long flags; 1043 struct dentry *pde; 1044 umode_t mode; 1045 int rc = 0; 1046 int i; 1047 1048 if (!id) 1049 goto out; 1050 mode = (id->mode | S_IFREG) & ~S_IXUGO; 1051 if (!(view->prolog_proc || view->format_proc || view->header_proc)) 1052 mode &= ~(S_IRUSR | S_IRGRP | S_IROTH); 1053 if (!view->input_proc) 1054 mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH); 1055 pde = debugfs_create_file(view->name, mode, id->debugfs_root_entry, 1056 id, &debug_file_ops); 1057 if (!pde) { 1058 pr_err("Registering view %s/%s failed due to out of " 1059 "memory\n", id->name, view->name); 1060 rc = -1; 1061 goto out; 1062 } 1063 spin_lock_irqsave(&id->lock, flags); 1064 for (i = 0; i < DEBUG_MAX_VIEWS; i++) { 1065 if (!id->views[i]) 1066 break; 1067 } 1068 if (i == DEBUG_MAX_VIEWS) { 1069 pr_err("Registering view %s/%s would exceed the maximum " 1070 "number of views %i\n", id->name, view->name, i); 1071 rc = -1; 1072 } else { 1073 id->views[i] = view; 1074 id->debugfs_entries[i] = pde; 1075 } 1076 spin_unlock_irqrestore(&id->lock, flags); 1077 if (rc) 1078 debugfs_remove(pde); 1079 out: 1080 return rc; 1081 } 1082 EXPORT_SYMBOL(debug_register_view); 1083 1084 /* 1085 * debug_unregister_view: 1086 */ 1087 int debug_unregister_view(debug_info_t *id, struct debug_view *view) 1088 { 1089 struct dentry *dentry = NULL; 1090 unsigned long flags; 1091 int i, rc = 0; 1092 1093 if (!id) 1094 goto out; 1095 spin_lock_irqsave(&id->lock, flags); 1096 for (i = 0; i < DEBUG_MAX_VIEWS; i++) { 1097 if (id->views[i] == view) 1098 break; 1099 } 1100 if (i == DEBUG_MAX_VIEWS) { 1101 rc = -1; 1102 } else { 1103 dentry = id->debugfs_entries[i]; 1104 id->views[i] = NULL; 1105 id->debugfs_entries[i] = NULL; 1106 } 1107 spin_unlock_irqrestore(&id->lock, flags); 1108 debugfs_remove(dentry); 1109 out: 1110 return rc; 1111 } 1112 EXPORT_SYMBOL(debug_unregister_view); 1113 1114 static inline char *debug_get_user_string(const char __user *user_buf, 1115 size_t user_len) 1116 { 1117 char *buffer; 1118 1119 buffer = kmalloc(user_len + 1, GFP_KERNEL); 1120 if (!buffer) 1121 return ERR_PTR(-ENOMEM); 1122 if (copy_from_user(buffer, user_buf, user_len) != 0) { 1123 kfree(buffer); 1124 return ERR_PTR(-EFAULT); 1125 } 1126 /* got the string, now strip linefeed. */ 1127 if (buffer[user_len - 1] == '\n') 1128 buffer[user_len - 1] = 0; 1129 else 1130 buffer[user_len] = 0; 1131 return buffer; 1132 } 1133 1134 static inline int debug_get_uint(char *buf) 1135 { 1136 int rc; 1137 1138 buf = skip_spaces(buf); 1139 rc = simple_strtoul(buf, &buf, 10); 1140 if (*buf) 1141 rc = -EINVAL; 1142 return rc; 1143 } 1144 1145 /* 1146 * functions for debug-views 1147 *********************************** 1148 */ 1149 1150 /* 1151 * prints out actual debug level 1152 */ 1153 1154 static int debug_prolog_pages_fn(debug_info_t *id, struct debug_view *view, 1155 char *out_buf) 1156 { 1157 return sprintf(out_buf, "%i\n", id->pages_per_area); 1158 } 1159 1160 /* 1161 * reads new size (number of pages per debug area) 1162 */ 1163 1164 static int debug_input_pages_fn(debug_info_t *id, struct debug_view *view, 1165 struct file *file, const char __user *user_buf, 1166 size_t user_len, loff_t *offset) 1167 { 1168 int rc, new_pages; 1169 char *str; 1170 1171 if (user_len > 0x10000) 1172 user_len = 0x10000; 1173 if (*offset != 0) { 1174 rc = -EPIPE; 1175 goto out; 1176 } 1177 str = debug_get_user_string(user_buf, user_len); 1178 if (IS_ERR(str)) { 1179 rc = PTR_ERR(str); 1180 goto out; 1181 } 1182 new_pages = debug_get_uint(str); 1183 if (new_pages < 0) { 1184 rc = -EINVAL; 1185 goto free_str; 1186 } 1187 rc = debug_set_size(id, id->nr_areas, new_pages); 1188 if (rc != 0) { 1189 rc = -EINVAL; 1190 goto free_str; 1191 } 1192 rc = user_len; 1193 free_str: 1194 kfree(str); 1195 out: 1196 *offset += user_len; 1197 return rc; /* number of input characters */ 1198 } 1199 1200 /* 1201 * prints out actual debug level 1202 */ 1203 static int debug_prolog_level_fn(debug_info_t *id, struct debug_view *view, 1204 char *out_buf) 1205 { 1206 int rc = 0; 1207 1208 if (id->level == DEBUG_OFF_LEVEL) 1209 rc = sprintf(out_buf, "-\n"); 1210 else 1211 rc = sprintf(out_buf, "%i\n", id->level); 1212 return rc; 1213 } 1214 1215 /* 1216 * reads new debug level 1217 */ 1218 static int debug_input_level_fn(debug_info_t *id, struct debug_view *view, 1219 struct file *file, const char __user *user_buf, 1220 size_t user_len, loff_t *offset) 1221 { 1222 int rc, new_level; 1223 char *str; 1224 1225 if (user_len > 0x10000) 1226 user_len = 0x10000; 1227 if (*offset != 0) { 1228 rc = -EPIPE; 1229 goto out; 1230 } 1231 str = debug_get_user_string(user_buf, user_len); 1232 if (IS_ERR(str)) { 1233 rc = PTR_ERR(str); 1234 goto out; 1235 } 1236 if (str[0] == '-') { 1237 debug_set_level(id, DEBUG_OFF_LEVEL); 1238 rc = user_len; 1239 goto free_str; 1240 } else { 1241 new_level = debug_get_uint(str); 1242 } 1243 if (new_level < 0) { 1244 pr_warn("%s is not a valid level for a debug feature\n", str); 1245 rc = -EINVAL; 1246 } else { 1247 debug_set_level(id, new_level); 1248 rc = user_len; 1249 } 1250 free_str: 1251 kfree(str); 1252 out: 1253 *offset += user_len; 1254 return rc; /* number of input characters */ 1255 } 1256 1257 /* 1258 * flushes debug areas 1259 */ 1260 static void debug_flush(debug_info_t *id, int area) 1261 { 1262 unsigned long flags; 1263 int i, j; 1264 1265 if (!id || !id->areas) 1266 return; 1267 spin_lock_irqsave(&id->lock, flags); 1268 if (area == DEBUG_FLUSH_ALL) { 1269 id->active_area = 0; 1270 memset(id->active_entries, 0, id->nr_areas * sizeof(int)); 1271 for (i = 0; i < id->nr_areas; i++) { 1272 id->active_pages[i] = 0; 1273 for (j = 0; j < id->pages_per_area; j++) 1274 memset(id->areas[i][j], 0, PAGE_SIZE); 1275 } 1276 } else if (area >= 0 && area < id->nr_areas) { 1277 id->active_entries[area] = 0; 1278 id->active_pages[area] = 0; 1279 for (i = 0; i < id->pages_per_area; i++) 1280 memset(id->areas[area][i], 0, PAGE_SIZE); 1281 } 1282 spin_unlock_irqrestore(&id->lock, flags); 1283 } 1284 1285 /* 1286 * view function: flushes debug areas 1287 */ 1288 static int debug_input_flush_fn(debug_info_t *id, struct debug_view *view, 1289 struct file *file, const char __user *user_buf, 1290 size_t user_len, loff_t *offset) 1291 { 1292 char input_buf[1]; 1293 int rc = user_len; 1294 1295 if (user_len > 0x10000) 1296 user_len = 0x10000; 1297 if (*offset != 0) { 1298 rc = -EPIPE; 1299 goto out; 1300 } 1301 if (copy_from_user(input_buf, user_buf, 1)) { 1302 rc = -EFAULT; 1303 goto out; 1304 } 1305 if (input_buf[0] == '-') { 1306 debug_flush(id, DEBUG_FLUSH_ALL); 1307 goto out; 1308 } 1309 if (isdigit(input_buf[0])) { 1310 int area = ((int) input_buf[0] - (int) '0'); 1311 1312 debug_flush(id, area); 1313 goto out; 1314 } 1315 1316 pr_info("Flushing debug data failed because %c is not a valid " 1317 "area\n", input_buf[0]); 1318 1319 out: 1320 *offset += user_len; 1321 return rc; /* number of input characters */ 1322 } 1323 1324 /* 1325 * prints debug header in raw format 1326 */ 1327 static int debug_raw_header_fn(debug_info_t *id, struct debug_view *view, 1328 int area, debug_entry_t *entry, char *out_buf) 1329 { 1330 int rc; 1331 1332 rc = sizeof(debug_entry_t); 1333 memcpy(out_buf, entry, sizeof(debug_entry_t)); 1334 return rc; 1335 } 1336 1337 /* 1338 * prints debug data in raw format 1339 */ 1340 static int debug_raw_format_fn(debug_info_t *id, struct debug_view *view, 1341 char *out_buf, const char *in_buf) 1342 { 1343 int rc; 1344 1345 rc = id->buf_size; 1346 memcpy(out_buf, in_buf, id->buf_size); 1347 return rc; 1348 } 1349 1350 /* 1351 * prints debug data in hex/ascii format 1352 */ 1353 static int debug_hex_ascii_format_fn(debug_info_t *id, struct debug_view *view, 1354 char *out_buf, const char *in_buf) 1355 { 1356 int i, rc = 0; 1357 1358 for (i = 0; i < id->buf_size; i++) 1359 rc += sprintf(out_buf + rc, "%02x ", ((unsigned char *) in_buf)[i]); 1360 rc += sprintf(out_buf + rc, "| "); 1361 for (i = 0; i < id->buf_size; i++) { 1362 unsigned char c = in_buf[i]; 1363 1364 if (isascii(c) && isprint(c)) 1365 rc += sprintf(out_buf + rc, "%c", c); 1366 else 1367 rc += sprintf(out_buf + rc, "."); 1368 } 1369 rc += sprintf(out_buf + rc, "\n"); 1370 return rc; 1371 } 1372 1373 /* 1374 * prints header for debug entry 1375 */ 1376 int debug_dflt_header_fn(debug_info_t *id, struct debug_view *view, 1377 int area, debug_entry_t *entry, char *out_buf) 1378 { 1379 unsigned long base, sec, usec; 1380 unsigned long caller; 1381 unsigned int level; 1382 char *except_str; 1383 int rc = 0; 1384 1385 level = entry->id.fields.level; 1386 base = (*(unsigned long *) &tod_clock_base[0]) >> 4; 1387 sec = (entry->id.stck >> 12) + base - (TOD_UNIX_EPOCH >> 12); 1388 usec = do_div(sec, USEC_PER_SEC); 1389 1390 if (entry->id.fields.exception) 1391 except_str = "*"; 1392 else 1393 except_str = "-"; 1394 caller = (unsigned long) entry->caller; 1395 rc += sprintf(out_buf, "%02i %011ld:%06lu %1u %1s %02i %pK ", 1396 area, sec, usec, level, except_str, 1397 entry->id.fields.cpuid, (void *)caller); 1398 return rc; 1399 } 1400 EXPORT_SYMBOL(debug_dflt_header_fn); 1401 1402 /* 1403 * prints debug data sprintf-formated: 1404 * debug_sprinf_event/exception calls must be used together with this view 1405 */ 1406 1407 #define DEBUG_SPRINTF_MAX_ARGS 10 1408 1409 static int debug_sprintf_format_fn(debug_info_t *id, struct debug_view *view, 1410 char *out_buf, debug_sprintf_entry_t *curr_event) 1411 { 1412 int num_longs, num_used_args = 0, i, rc = 0; 1413 int index[DEBUG_SPRINTF_MAX_ARGS]; 1414 1415 /* count of longs fit into one entry */ 1416 num_longs = id->buf_size / sizeof(long); 1417 1418 if (num_longs < 1) 1419 goto out; /* bufsize of entry too small */ 1420 if (num_longs == 1) { 1421 /* no args, we use only the string */ 1422 strcpy(out_buf, curr_event->string); 1423 rc = strlen(curr_event->string); 1424 goto out; 1425 } 1426 1427 /* number of arguments used for sprintf (without the format string) */ 1428 num_used_args = min(DEBUG_SPRINTF_MAX_ARGS, (num_longs - 1)); 1429 1430 memset(index, 0, DEBUG_SPRINTF_MAX_ARGS * sizeof(int)); 1431 1432 for (i = 0; i < num_used_args; i++) 1433 index[i] = i; 1434 1435 rc = sprintf(out_buf, curr_event->string, curr_event->args[index[0]], 1436 curr_event->args[index[1]], curr_event->args[index[2]], 1437 curr_event->args[index[3]], curr_event->args[index[4]], 1438 curr_event->args[index[5]], curr_event->args[index[6]], 1439 curr_event->args[index[7]], curr_event->args[index[8]], 1440 curr_event->args[index[9]]); 1441 out: 1442 return rc; 1443 } 1444 1445 /* 1446 * debug_init: 1447 * - is called exactly once to initialize the debug feature 1448 */ 1449 static int __init debug_init(void) 1450 { 1451 s390dbf_sysctl_header = register_sysctl_table(s390dbf_dir_table); 1452 mutex_lock(&debug_mutex); 1453 debug_debugfs_root_entry = debugfs_create_dir(DEBUG_DIR_ROOT, NULL); 1454 initialized = 1; 1455 mutex_unlock(&debug_mutex); 1456 return 0; 1457 } 1458 postcore_initcall(debug_init); 1459