arch/s390/kernel/debug.c

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