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