arch/s390/kernel/debug.c

   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 %px  ",
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);