arch/s390/kernel/debug.c

   1 /*
   2  *  arch/s390/kernel/debug.c
   3  *   S/390 debug facility
   4  *
   5  *    Copyright (C) 1999, 2000 IBM Deutschland Entwicklung GmbH,
   6  *                             IBM Corporation
   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 #include <linux/config.h>
  14 #include <linux/stddef.h>
  15 #include <linux/kernel.h>
  16 #include <linux/errno.h>
  17 #include <linux/slab.h>
  18 #include <linux/ctype.h>
  19 #include <linux/sysctl.h>
  20 #include <asm/uaccess.h>
  21 #include <asm/semaphore.h>
  22
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25
  26 #include <asm/debug.h>
  27
  28 #define DEBUG_PROLOG_ENTRY -1
  29
  30 /* typedefs */
  31
  32 typedef struct file_private_info {
  33         loff_t offset;                  /* offset of last read in file */
  34         int    act_area;                /* number of last formated area */
  35         int    act_entry;               /* last formated entry (offset */
  36                                         /* relative to beginning of last */
  37                                         /* formated area) */
  38         size_t act_entry_offset;        /* up to this offset we copied */
  39                                         /* in last read the last formated */
  40                                         /* entry to userland */
  41         char   temp_buf[2048];          /* buffer for output */
  42         debug_info_t *debug_info_org;   /* original debug information */
  43         debug_info_t *debug_info_snap;  /* snapshot of debug information */
  44         struct debug_view *view;        /* used view of debug info */
  45 } file_private_info_t;
  46
  47 typedef struct
  48 {
  49         char *string;
  50         /*
  51          * This assumes that all args are converted into longs
  52          * on L/390 this is the case for all types of parameter
  53          * except of floats, and long long (32 bit)
  54          *
  55          */
  56         long args[0];
  57 } debug_sprintf_entry_t;
  58
  59
  60 extern void tod_to_timeval(uint64_t todval, struct timeval *xtime);
  61
  62 /* internal function prototyes */
  63
  64 static int debug_init(void);
  65 static ssize_t debug_output(struct file *file, char __user *user_buf,
  66                             size_t user_len, loff_t * offset);
  67 static ssize_t debug_input(struct file *file, const char __user *user_buf,
  68                            size_t user_len, loff_t * offset);
  69 static int debug_open(struct inode *inode, struct file *file);
  70 static int debug_close(struct inode *inode, struct file *file);
  71 static debug_info_t*  debug_info_create(char *name, int page_order, int nr_areas, int buf_size);
  72 static void debug_info_get(debug_info_t *);
  73 static void debug_info_put(debug_info_t *);
  74 static int debug_prolog_level_fn(debug_info_t * id,
  75                                  struct debug_view *view, char *out_buf);
  76 static int debug_input_level_fn(debug_info_t * id, struct debug_view *view,
  77                                 struct file *file, const char __user *user_buf,
  78                                 size_t user_buf_size, loff_t * offset);
  79 static int debug_input_flush_fn(debug_info_t * id, struct debug_view *view,
  80                                 struct file *file, const char __user *user_buf,
  81                                 size_t user_buf_size, loff_t * offset);
  82 static int debug_hex_ascii_format_fn(debug_info_t * id, struct debug_view *view,
  83                                 char *out_buf, const char *in_buf);
  84 static int debug_raw_format_fn(debug_info_t * id,
  85                                  struct debug_view *view, char *out_buf,
  86                                  const char *in_buf);
  87 static int debug_raw_header_fn(debug_info_t * id, struct debug_view *view,
  88                          int area, debug_entry_t * entry, char *out_buf);
  89
  90 static int debug_sprintf_format_fn(debug_info_t * id, struct debug_view *view,
  91                                    char *out_buf, debug_sprintf_entry_t *curr_event);
  92
  93 /* globals */
  94
  95 struct debug_view debug_raw_view = {
  96         "raw",
  97         NULL,
  98         &debug_raw_header_fn,
  99         &debug_raw_format_fn,
 100         NULL,
 101         NULL
 102 };
 103
 104 struct debug_view debug_hex_ascii_view = {
 105         "hex_ascii",
 106         NULL,
 107         &debug_dflt_header_fn,
 108         &debug_hex_ascii_format_fn,
 109         NULL,
 110         NULL
 111 };
 112
 113 struct debug_view debug_level_view = {
 114         "level",
 115         &debug_prolog_level_fn,
 116         NULL,
 117         NULL,
 118         &debug_input_level_fn,
 119         NULL
 120 };
 121
 122 struct debug_view debug_flush_view = {
 123         "flush",
 124         NULL,
 125         NULL,
 126         NULL,
 127         &debug_input_flush_fn,
 128         NULL
 129 };
 130
 131 struct debug_view debug_sprintf_view = {
 132         "sprintf",
 133         NULL,
 134         &debug_dflt_header_fn,
 135         (debug_format_proc_t*)&debug_sprintf_format_fn,
 136         NULL,
 137         NULL
 138 };
 139
 140
 141 unsigned int debug_feature_version = __DEBUG_FEATURE_VERSION;
 142
 143 /* static globals */
 144
 145 static debug_info_t *debug_area_first = NULL;
 146 static debug_info_t *debug_area_last = NULL;
 147 DECLARE_MUTEX(debug_lock);
 148
 149 static int initialized;
 150
 151 static struct file_operations debug_file_ops = {
 152         .owner   = THIS_MODULE,
 153         .read    = debug_output,
 154         .write   = debug_input,
 155         .open    = debug_open,
 156         .release = debug_close,
 157 };
 158
 159 static struct proc_dir_entry *debug_proc_root_entry;
 160
 161 /* functions */
 162
 163 /*
 164  * debug_info_alloc
 165  * - alloc new debug-info
 166  */
 167
 168 static debug_info_t*  debug_info_alloc(char *name, int page_order,
 169                                         int nr_areas, int buf_size)
 170 {
 171         debug_info_t* rc;
 172         int i;
 173
 174         /* alloc everything */
 175
 176         rc = (debug_info_t*) kmalloc(sizeof(debug_info_t), GFP_ATOMIC);
 177         if(!rc)
 178                 goto fail_malloc_rc;
 179         rc->active_entry = (int*)kmalloc(nr_areas * sizeof(int), GFP_ATOMIC);
 180         if(!rc->active_entry)
 181                 goto fail_malloc_active_entry;
 182         memset(rc->active_entry, 0, nr_areas * sizeof(int));
 183         rc->areas = (debug_entry_t **) kmalloc(nr_areas *
 184                                                 sizeof(debug_entry_t *),
 185                                                 GFP_ATOMIC);
 186         if (!rc->areas)
 187                 goto fail_malloc_areas;
 188         for (i = 0; i < nr_areas; i++) {
 189                 rc->areas[i] = (debug_entry_t *) __get_free_pages(GFP_ATOMIC,
 190                                                                 page_order);
 191                 if (!rc->areas[i]) {
 192                         for (i--; i >= 0; i--) {
 193                                 free_pages((unsigned long) rc->areas[i],
 194                                                 page_order);
 195                         }
 196                         goto fail_malloc_areas2;
 197                 } else {
 198                         memset(rc->areas[i], 0, PAGE_SIZE << page_order);
 199                 }
 200         }
 201
 202         /* initialize members */
 203
 204         spin_lock_init(&rc->lock);
 205         rc->page_order  = page_order;
 206         rc->nr_areas    = nr_areas;
 207         rc->active_area = 0;
 208         rc->level       = DEBUG_DEFAULT_LEVEL;
 209         rc->buf_size    = buf_size;
 210         rc->entry_size  = sizeof(debug_entry_t) + buf_size;
 211         strlcpy(rc->name, name, sizeof(rc->name));
 212         memset(rc->views, 0, DEBUG_MAX_VIEWS * sizeof(struct debug_view *));
 213 #ifdef CONFIG_PROC_FS
 214         memset(rc->proc_entries, 0 ,DEBUG_MAX_VIEWS *
 215                 sizeof(struct proc_dir_entry*));
 216 #endif /* CONFIG_PROC_FS */
 217         atomic_set(&(rc->ref_count), 0);
 218
 219         return rc;
 220
 221 fail_malloc_areas2:
 222         kfree(rc->areas);
 223 fail_malloc_areas:
 224         kfree(rc->active_entry);
 225 fail_malloc_active_entry:
 226         kfree(rc);
 227 fail_malloc_rc:
 228         return NULL;
 229 }
 230
 231 /*
 232  * debug_info_free
 233  * - free memory debug-info
 234  */
 235
 236 static void debug_info_free(debug_info_t* db_info){
 237         int i;
 238         for (i = 0; i < db_info->nr_areas; i++) {
 239                 free_pages((unsigned long) db_info->areas[i],
 240                 db_info->page_order);
 241         }
 242         kfree(db_info->areas);
 243         kfree(db_info->active_entry);
 244         kfree(db_info);
 245 }
 246
 247 /*
 248  * debug_info_create
 249  * - create new debug-info
 250  */
 251
 252 static debug_info_t*  debug_info_create(char *name, int page_order,
 253                                         int nr_areas, int buf_size)
 254 {
 255         debug_info_t* rc;
 256
 257         rc = debug_info_alloc(name, page_order, nr_areas, buf_size);
 258         if(!rc)
 259                 goto out;
 260
 261
 262         /* create proc rood directory */
 263         rc->proc_root_entry = proc_mkdir(rc->name, debug_proc_root_entry);
 264
 265         /* append new element to linked list */
 266         if (debug_area_first == NULL) {
 267                 /* first element in list */
 268                 debug_area_first = rc;
 269                 rc->prev = NULL;
 270         } else {
 271                 /* append element to end of list */
 272                 debug_area_last->next = rc;
 273                 rc->prev = debug_area_last;
 274         }
 275         debug_area_last = rc;
 276         rc->next = NULL;
 277
 278         debug_info_get(rc);
 279 out:
 280         return rc;
 281 }
 282
 283 /*
 284  * debug_info_copy
 285  * - copy debug-info
 286  */
 287
 288 static debug_info_t* debug_info_copy(debug_info_t* in)
 289 {
 290         int i;
 291         debug_info_t* rc;
 292         rc = debug_info_alloc(in->name, in->page_order,
 293                                 in->nr_areas, in->buf_size);
 294         if(!rc)
 295                 goto out;
 296
 297         for(i = 0; i < in->nr_areas; i++){
 298                 memcpy(rc->areas[i],in->areas[i], PAGE_SIZE << in->page_order);
 299         }
 300 out:
 301         return rc;
 302 }
 303
 304 /*
 305  * debug_info_get
 306  * - increments reference count for debug-info
 307  */
 308
 309 static void debug_info_get(debug_info_t * db_info)
 310 {
 311         if (db_info)
 312                 atomic_inc(&db_info->ref_count);
 313 }
 314
 315 /*
 316  * debug_info_put:
 317  * - decreases reference count for debug-info and frees it if necessary
 318  */
 319
 320 static void debug_info_put(debug_info_t *db_info)
 321 {
 322         int i;
 323
 324         if (!db_info)
 325                 return;
 326         if (atomic_dec_and_test(&db_info->ref_count)) {
 327 #ifdef DEBUG
 328                 printk(KERN_INFO "debug: freeing debug area %p (%s)\n",
 329                        db_info, db_info->name);
 330 #endif
 331                 for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
 332                         if (db_info->views[i] == NULL)
 333                                 continue;
 334 #ifdef CONFIG_PROC_FS
 335                         remove_proc_entry(db_info->proc_entries[i]->name,
 336                                           db_info->proc_root_entry);
 337 #endif
 338                 }
 339 #ifdef CONFIG_PROC_FS
 340                 remove_proc_entry(db_info->proc_root_entry->name,
 341                                   debug_proc_root_entry);
 342 #endif
 343                 if(db_info == debug_area_first)
 344                         debug_area_first = db_info->next;
 345                 if(db_info == debug_area_last)
 346                         debug_area_last = db_info->prev;
 347                 if(db_info->prev) db_info->prev->next = db_info->next;
 348                 if(db_info->next) db_info->next->prev = db_info->prev;
 349                 debug_info_free(db_info);
 350         }
 351 }
 352
 353 /*
 354  * debug_format_entry:
 355  * - format one debug entry and return size of formated data
 356  */
 357
 358 static int debug_format_entry(file_private_info_t *p_info)
 359 {
 360         debug_info_t *id_org    = p_info->debug_info_org;
 361         debug_info_t *id_snap   = p_info->debug_info_snap;
 362         struct debug_view *view = p_info->view;
 363         debug_entry_t *act_entry;
 364         size_t len = 0;
 365         if(p_info->act_entry == DEBUG_PROLOG_ENTRY){
 366                 /* print prolog */
 367                 if (view->prolog_proc)
 368                         len += view->prolog_proc(id_org, view,p_info->temp_buf);
 369                 goto out;
 370         }
 371
 372         act_entry = (debug_entry_t *) ((char*)id_snap->areas[p_info->act_area] +
 373                                         p_info->act_entry);
 374
 375         if (act_entry->id.stck == 0LL)
 376                         goto out;  /* empty entry */
 377         if (view->header_proc)
 378                 len += view->header_proc(id_org, view, p_info->act_area,
 379                                         act_entry, p_info->temp_buf + len);
 380         if (view->format_proc)
 381                 len += view->format_proc(id_org, view, p_info->temp_buf + len,
 382                                                 DEBUG_DATA(act_entry));
 383       out:
 384         return len;
 385 }
 386
 387 /*
 388  * debug_next_entry:
 389  * - goto next entry in p_info
 390  */
 391
 392 extern inline int debug_next_entry(file_private_info_t *p_info)
 393 {
 394         debug_info_t *id = p_info->debug_info_snap;
 395         if(p_info->act_entry == DEBUG_PROLOG_ENTRY){
 396                 p_info->act_entry = 0;
 397                 goto out;
 398         }
 399         if ((p_info->act_entry += id->entry_size)
 400                 > ((PAGE_SIZE << (id->page_order))
 401                 - id->entry_size)){
 402
 403                 /* next area */
 404                 p_info->act_entry = 0;
 405                 p_info->act_area++;
 406                 if(p_info->act_area >= id->nr_areas)
 407                         return 1;
 408         }
 409 out:
 410         return 0;
 411 }
 412
 413 /*
 414  * debug_output:
 415  * - called for user read()
 416  * - copies formated debug entries to the user buffer
 417  */
 418
 419 static ssize_t debug_output(struct file *file,          /* file descriptor */
 420                             char __user *user_buf,      /* user buffer */
 421                             size_t  len,                /* length of buffer */
 422                             loff_t *offset)           /* offset in the file */
 423 {
 424         size_t count = 0;
 425         size_t entry_offset, size = 0;
 426         file_private_info_t *p_info;
 427
 428         p_info = ((file_private_info_t *) file->private_data);
 429         if (*offset != p_info->offset)
 430                 return -EPIPE;
 431         if(p_info->act_area >= p_info->debug_info_snap->nr_areas)
 432                 return 0;
 433
 434         entry_offset = p_info->act_entry_offset;
 435
 436         while(count < len){
 437                 size = debug_format_entry(p_info);
 438                 size = min((len - count), (size - entry_offset));
 439
 440                 if(size){
 441                         if (copy_to_user(user_buf + count,
 442                                         p_info->temp_buf + entry_offset, size))
 443                         return -EFAULT;
 444                 }
 445                 count += size;
 446                 entry_offset = 0;
 447                 if(count != len)
 448                         if(debug_next_entry(p_info))
 449                                 goto out;
 450         }
 451 out:
 452         p_info->offset           = *offset + count;
 453         p_info->act_entry_offset = size;
 454         *offset = p_info->offset;
 455         return count;
 456 }
 457
 458 /*
 459  * debug_input:
 460  * - called for user write()
 461  * - calls input function of view
 462  */
 463
 464 static ssize_t debug_input(struct file *file,
 465                            const char __user *user_buf, size_t length,
 466                            loff_t *offset)
 467 {
 468         int rc = 0;
 469         file_private_info_t *p_info;
 470
 471         down(&debug_lock);
 472         p_info = ((file_private_info_t *) file->private_data);
 473         if (p_info->view->input_proc)
 474                 rc = p_info->view->input_proc(p_info->debug_info_org,
 475                                               p_info->view, file, user_buf,
 476                                               length, offset);
 477         else
 478                 rc = -EPERM;
 479         up(&debug_lock);
 480         return rc;              /* number of input characters */
 481 }
 482
 483 /*
 484  * debug_open:
 485  * - called for user open()
 486  * - copies formated output to private_data area of the file
 487  *   handle
 488  */
 489
 490 static int debug_open(struct inode *inode, struct file *file)
 491 {
 492         int i = 0, rc = 0;
 493         file_private_info_t *p_info;
 494         debug_info_t *debug_info, *debug_info_snapshot;
 495
 496 #ifdef DEBUG
 497         printk("debug_open\n");
 498 #endif
 499         down(&debug_lock);
 500
 501         /* find debug log and view */
 502
 503         debug_info = debug_area_first;
 504         while(debug_info != NULL){
 505                 for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
 506                         if (debug_info->views[i] == NULL)
 507                                 continue;
 508                         else if (debug_info->proc_entries[i] ==
 509                                  PDE(file->f_dentry->d_inode)) {
 510                                 goto found;     /* found view ! */
 511                         }
 512                 }
 513                 debug_info = debug_info->next;
 514         }
 515         /* no entry found */
 516         rc = -EINVAL;
 517         goto out;
 518
 519       found:
 520
 521         /* make snapshot of current debug areas to get it consistent */
 522
 523         debug_info_snapshot = debug_info_copy(debug_info);
 524
 525         if(!debug_info_snapshot){
 526 #ifdef DEBUG
 527                 printk(KERN_ERR "debug_open: debug_info_copy failed (out of mem)\n");
 528 #endif
 529                 rc = -ENOMEM;
 530                 goto out;
 531         }
 532
 533         if ((file->private_data =
 534              kmalloc(sizeof(file_private_info_t), GFP_ATOMIC)) == 0) {
 535 #ifdef DEBUG
 536                 printk(KERN_ERR "debug_open: kmalloc failed\n");
 537 #endif
 538                 debug_info_free(debug_info_snapshot);
 539                 rc = -ENOMEM;
 540                 goto out;
 541         }
 542         p_info = (file_private_info_t *) file->private_data;
 543         p_info->offset = 0;
 544         p_info->debug_info_snap = debug_info_snapshot;
 545         p_info->debug_info_org  = debug_info;
 546         p_info->view = debug_info->views[i];
 547         p_info->act_area = 0;
 548         p_info->act_entry = DEBUG_PROLOG_ENTRY;
 549         p_info->act_entry_offset = 0;
 550
 551         debug_info_get(debug_info);
 552
 553       out:
 554         up(&debug_lock);
 555         return rc;
 556 }
 557
 558 /*
 559  * debug_close:
 560  * - called for user close()
 561  * - deletes  private_data area of the file handle
 562  */
 563
 564 static int debug_close(struct inode *inode, struct file *file)
 565 {
 566         file_private_info_t *p_info;
 567 #ifdef DEBUG
 568         printk("debug_close\n");
 569 #endif
 570         p_info = (file_private_info_t *) file->private_data;
 571         debug_info_free(p_info->debug_info_snap);
 572         debug_info_put(p_info->debug_info_org);
 573         kfree(file->private_data);
 574         return 0;               /* success */
 575 }
 576
 577 /*
 578  * debug_register:
 579  * - creates and initializes debug area for the caller
 580  * - returns handle for debug area
 581  */
 582
 583 debug_info_t *debug_register
 584     (char *name, int page_order, int nr_areas, int buf_size)
 585 {
 586         debug_info_t *rc = NULL;
 587
 588         if (!initialized)
 589                 BUG();
 590         down(&debug_lock);
 591
 592         /* create new debug_info */
 593
 594         rc = debug_info_create(name, page_order, nr_areas, buf_size);
 595         if(!rc)
 596                 goto out;
 597         debug_register_view(rc, &debug_level_view);
 598         debug_register_view(rc, &debug_flush_view);
 599 #ifdef DEBUG
 600         printk(KERN_INFO
 601                "debug: reserved %d areas of %d pages for debugging %s\n",
 602                nr_areas, 1 << page_order, rc->name);
 603 #endif
 604       out:
 605         if (rc == NULL){
 606                 printk(KERN_ERR "debug: debug_register failed for %s\n",name);
 607         }
 608         up(&debug_lock);
 609         return rc;
 610 }
 611
 612 /*
 613  * debug_unregister:
 614  * - give back debug area
 615  */
 616
 617 void debug_unregister(debug_info_t * id)
 618 {
 619         if (!id)
 620                 goto out;
 621         down(&debug_lock);
 622 #ifdef DEBUG
 623         printk(KERN_INFO "debug: unregistering %s\n", id->name);
 624 #endif
 625         debug_info_put(id);
 626         up(&debug_lock);
 627
 628       out:
 629         return;
 630 }
 631
 632 /*
 633  * debug_set_level:
 634  * - set actual debug level
 635  */
 636
 637 void debug_set_level(debug_info_t* id, int new_level)
 638 {
 639         unsigned long flags;
 640         if(!id)
 641                 return;
 642         spin_lock_irqsave(&id->lock,flags);
 643         if(new_level == DEBUG_OFF_LEVEL){
 644                 id->level = DEBUG_OFF_LEVEL;
 645                 printk(KERN_INFO "debug: %s: switched off\n",id->name);
 646         } else if ((new_level > DEBUG_MAX_LEVEL) || (new_level < 0)) {
 647                 printk(KERN_INFO
 648                         "debug: %s: level %i is out of range (%i - %i)\n",
 649                         id->name, new_level, 0, DEBUG_MAX_LEVEL);
 650         } else {
 651                 id->level = new_level;
 652 #ifdef DEBUG
 653                 printk(KERN_INFO
 654                         "debug: %s: new level %i\n",id->name,id->level);
 655 #endif
 656         }
 657         spin_unlock_irqrestore(&id->lock,flags);
 658 }
 659
 660
 661 /*
 662  * proceed_active_entry:
 663  * - set active entry to next in the ring buffer
 664  */
 665
 666 extern inline void proceed_active_entry(debug_info_t * id)
 667 {
 668         if ((id->active_entry[id->active_area] += id->entry_size)
 669             > ((PAGE_SIZE << (id->page_order)) - id->entry_size))
 670                 id->active_entry[id->active_area] = 0;
 671 }
 672
 673 /*
 674  * proceed_active_area:
 675  * - set active area to next in the ring buffer
 676  */
 677
 678 extern inline void proceed_active_area(debug_info_t * id)
 679 {
 680         id->active_area++;
 681         id->active_area = id->active_area % id->nr_areas;
 682 }
 683
 684 /*
 685  * get_active_entry:
 686  */
 687
 688 extern inline debug_entry_t *get_active_entry(debug_info_t * id)
 689 {
 690         return (debug_entry_t *) ((char *) id->areas[id->active_area] +
 691                                   id->active_entry[id->active_area]);
 692 }
 693
 694 /*
 695  * debug_finish_entry:
 696  * - set timestamp, caller address, cpu number etc.
 697  */
 698
 699 extern inline void debug_finish_entry(debug_info_t * id, debug_entry_t* active,
 700                 int level, int exception)
 701 {
 702         STCK(active->id.stck);
 703         active->id.fields.cpuid = smp_processor_id();
 704         active->caller = __builtin_return_address(0);
 705         active->id.fields.exception = exception;
 706         active->id.fields.level     = level;
 707         proceed_active_entry(id);
 708         if(exception)
 709                 proceed_active_area(id);
 710 }
 711
 712 static int debug_stoppable=1;
 713 static int debug_active=1;
 714
 715 #define CTL_S390DBF 5677
 716 #define CTL_S390DBF_STOPPABLE 5678
 717 #define CTL_S390DBF_ACTIVE 5679
 718
 719 /*
 720  * proc handler for the running debug_active sysctl
 721  * always allow read, allow write only if debug_stoppable is set or
 722  * if debug_active is already off
 723  */
 724 static int s390dbf_procactive(ctl_table *table, int write, struct file *filp,
 725                      void __user *buffer, size_t *lenp, loff_t *ppos)
 726 {
 727         if (!write || debug_stoppable || !debug_active)
 728                 return proc_dointvec(table, write, filp, buffer, lenp, ppos);
 729         else
 730                 return 0;
 731 }
 732
 733
 734 static struct ctl_table s390dbf_table[] = {
 735         {
 736                 .ctl_name       = CTL_S390DBF_STOPPABLE,
 737                 .procname       = "debug_stoppable",
 738                 .data           = &debug_stoppable,
 739                 .maxlen         = sizeof(int),
 740                 .mode           = S_IRUGO | S_IWUSR,
 741                 .proc_handler   = &proc_dointvec,
 742                 .strategy       = &sysctl_intvec,
 743         },
 744          {
 745                 .ctl_name       = CTL_S390DBF_ACTIVE,
 746                 .procname       = "debug_active",
 747                 .data           = &debug_active,
 748                 .maxlen         = sizeof(int),
 749                 .mode           = S_IRUGO | S_IWUSR,
 750                 .proc_handler   = &s390dbf_procactive,
 751                 .strategy       = &sysctl_intvec,
 752         },
 753         { .ctl_name = 0 }
 754 };
 755
 756 static struct ctl_table s390dbf_dir_table[] = {
 757         {
 758                 .ctl_name       = CTL_S390DBF,
 759                 .procname       = "s390dbf",
 760                 .maxlen         = 0,
 761                 .mode           = S_IRUGO | S_IXUGO,
 762                 .child          = s390dbf_table,
 763         },
 764         { .ctl_name = 0 }
 765 };
 766
 767 struct ctl_table_header *s390dbf_sysctl_header;
 768
 769 void debug_stop_all(void)
 770 {
 771         if (debug_stoppable)
 772                 debug_active = 0;
 773 }
 774
 775
 776 /*
 777  * debug_event_common:
 778  * - write debug entry with given size
 779  */
 780
 781 debug_entry_t *debug_event_common(debug_info_t * id, int level, const void *buf,
 782                                   int len)
 783 {
 784         unsigned long flags;
 785         debug_entry_t *active;
 786
 787         if (!debug_active)
 788                 return NULL;
 789         spin_lock_irqsave(&id->lock, flags);
 790         active = get_active_entry(id);
 791         memset(DEBUG_DATA(active), 0, id->buf_size);
 792         memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size));
 793         debug_finish_entry(id, active, level, 0);
 794         spin_unlock_irqrestore(&id->lock, flags);
 795
 796         return active;
 797 }
 798
 799 /*
 800  * debug_exception_common:
 801  * - write debug entry with given size and switch to next debug area
 802  */
 803
 804 debug_entry_t *debug_exception_common(debug_info_t * id, int level,
 805                                       const void *buf, int len)
 806 {
 807         unsigned long flags;
 808         debug_entry_t *active;
 809
 810         if (!debug_active)
 811                 return NULL;
 812         spin_lock_irqsave(&id->lock, flags);
 813         active = get_active_entry(id);
 814         memset(DEBUG_DATA(active), 0, id->buf_size);
 815         memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size));
 816         debug_finish_entry(id, active, level, 1);
 817         spin_unlock_irqrestore(&id->lock, flags);
 818
 819         return active;
 820 }
 821
 822 /*
 823  * counts arguments in format string for sprintf view
 824  */
 825
 826 extern inline int debug_count_numargs(char *string)
 827 {
 828         int numargs=0;
 829
 830         while(*string) {
 831                 if(*string++=='%')
 832                         numargs++;
 833         }
 834         return(numargs);
 835 }
 836
 837 /*
 838  * debug_sprintf_event:
 839  */
 840
 841 debug_entry_t *debug_sprintf_event(debug_info_t* id,
 842                                    int level,char *string,...)
 843 {
 844         va_list   ap;
 845         int numargs,idx;
 846         unsigned long flags;
 847         debug_sprintf_entry_t *curr_event;
 848         debug_entry_t *active;
 849
 850         if((!id) || (level > id->level))
 851                 return NULL;
 852         if (!debug_active)
 853                 return NULL;
 854         numargs=debug_count_numargs(string);
 855
 856         spin_lock_irqsave(&id->lock, flags);
 857         active = get_active_entry(id);
 858         curr_event=(debug_sprintf_entry_t *) DEBUG_DATA(active);
 859         va_start(ap,string);
 860         curr_event->string=string;
 861         for(idx=0;idx<min(numargs,(int)(id->buf_size / sizeof(long))-1);idx++)
 862                 curr_event->args[idx]=va_arg(ap,long);
 863         va_end(ap);
 864         debug_finish_entry(id, active, level, 0);
 865         spin_unlock_irqrestore(&id->lock, flags);
 866
 867         return active;
 868 }
 869
 870 /*
 871  * debug_sprintf_exception:
 872  */
 873
 874 debug_entry_t *debug_sprintf_exception(debug_info_t* id,
 875                                        int level,char *string,...)
 876 {
 877         va_list   ap;
 878         int numargs,idx;
 879         unsigned long flags;
 880         debug_sprintf_entry_t *curr_event;
 881         debug_entry_t *active;
 882
 883         if((!id) || (level > id->level))
 884                 return NULL;
 885         if (!debug_active)
 886                 return NULL;
 887
 888         numargs=debug_count_numargs(string);
 889
 890         spin_lock_irqsave(&id->lock, flags);
 891         active = get_active_entry(id);
 892         curr_event=(debug_sprintf_entry_t *)DEBUG_DATA(active);
 893         va_start(ap,string);
 894         curr_event->string=string;
 895         for(idx=0;idx<min(numargs,(int)(id->buf_size / sizeof(long))-1);idx++)
 896                 curr_event->args[idx]=va_arg(ap,long);
 897         va_end(ap);
 898         debug_finish_entry(id, active, level, 1);
 899         spin_unlock_irqrestore(&id->lock, flags);
 900
 901         return active;
 902 }
 903
 904 /*
 905  * debug_init:
 906  * - is called exactly once to initialize the debug feature
 907  */
 908
 909 static int __init debug_init(void)
 910 {
 911         int rc = 0;
 912
 913         s390dbf_sysctl_header = register_sysctl_table(s390dbf_dir_table, 1);
 914         down(&debug_lock);
 915 #ifdef CONFIG_PROC_FS
 916         debug_proc_root_entry = proc_mkdir(DEBUG_DIR_ROOT, NULL);
 917 #endif /* CONFIG_PROC_FS */
 918         printk(KERN_INFO "debug: Initialization complete\n");
 919         initialized = 1;
 920         up(&debug_lock);
 921
 922         return rc;
 923 }
 924
 925 /*
 926  * debug_register_view:
 927  */
 928
 929 int debug_register_view(debug_info_t * id, struct debug_view *view)
 930 {
 931         int rc = 0;
 932         int i;
 933         unsigned long flags;
 934         mode_t mode = S_IFREG;
 935         struct proc_dir_entry *pde;
 936
 937         if (!id)
 938                 goto out;
 939         if (view->prolog_proc || view->format_proc || view->header_proc)
 940                 mode |= S_IRUSR;
 941         if (view->input_proc)
 942                 mode |= S_IWUSR;
 943         pde = create_proc_entry(view->name, mode, id->proc_root_entry);
 944         if (!pde){
 945                 printk(KERN_WARNING "debug: create_proc_entry() failed! Cannot register view %s/%s\n", id->name,view->name);
 946                 rc = -1;
 947                 goto out;
 948         }
 949
 950         spin_lock_irqsave(&id->lock, flags);
 951         for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
 952                 if (id->views[i] == NULL)
 953                         break;
 954         }
 955         if (i == DEBUG_MAX_VIEWS) {
 956                 printk(KERN_WARNING "debug: cannot register view %s/%s\n",
 957                         id->name,view->name);
 958                 printk(KERN_WARNING
 959                         "debug: maximum number of views reached (%i)!\n", i);
 960                 remove_proc_entry(pde->name, id->proc_root_entry);
 961                 rc = -1;
 962         }
 963         else {
 964                 id->views[i] = view;
 965                 pde->proc_fops = &debug_file_ops;
 966                 id->proc_entries[i] = pde;
 967         }
 968         spin_unlock_irqrestore(&id->lock, flags);
 969       out:
 970         return rc;
 971 }
 972
 973 /*
 974  * debug_unregister_view:
 975  */
 976
 977 int debug_unregister_view(debug_info_t * id, struct debug_view *view)
 978 {
 979         int rc = 0;
 980         int i;
 981         unsigned long flags;
 982
 983         if (!id)
 984                 goto out;
 985         spin_lock_irqsave(&id->lock, flags);
 986         for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
 987                 if (id->views[i] == view)
 988                         break;
 989         }
 990         if (i == DEBUG_MAX_VIEWS)
 991                 rc = -1;
 992         else {
 993 #ifdef CONFIG_PROC_FS
 994                 remove_proc_entry(id->proc_entries[i]->name,
 995                                   id->proc_root_entry);
 996 #endif
 997                 id->views[i] = NULL;
 998                 rc = 0;
 999         }
1000         spin_unlock_irqrestore(&id->lock, flags);
1001       out:
1002         return rc;
1003 }
1004
1005 /*
1006  * functions for debug-views
1007  ***********************************
1008 */
1009
1010 /*
1011  * prints out actual debug level
1012  */
1013
1014 static int debug_prolog_level_fn(debug_info_t * id,
1015                                  struct debug_view *view, char *out_buf)
1016 {
1017         int rc = 0;
1018
1019         if(id->level == -1) rc = sprintf(out_buf,"-\n");
1020         else rc = sprintf(out_buf, "%i\n", id->level);
1021         return rc;
1022 }
1023
1024 /*
1025  * reads new debug level
1026  */
1027
1028 static int debug_input_level_fn(debug_info_t * id, struct debug_view *view,
1029                                 struct file *file, const char __user *user_buf,
1030                                 size_t in_buf_size, loff_t * offset)
1031 {
1032         char input_buf[1];
1033         int rc = in_buf_size;
1034
1035         if (*offset != 0)
1036                 goto out;
1037         if (copy_from_user(input_buf, user_buf, 1)){
1038                 rc = -EFAULT;
1039                 goto out;
1040         }
1041         if (isdigit(input_buf[0])) {
1042                 int new_level = ((int) input_buf[0] - (int) '0');
1043                 debug_set_level(id, new_level);
1044         } else if(input_buf[0] == '-') {
1045                 debug_set_level(id, DEBUG_OFF_LEVEL);
1046         } else {
1047                 printk(KERN_INFO "debug: level `%c` is not valid\n",
1048                        input_buf[0]);
1049         }
1050       out:
1051         *offset += in_buf_size;
1052         return rc;              /* number of input characters */
1053 }
1054
1055
1056 /*
1057  * flushes debug areas
1058  */
1059
1060 void debug_flush(debug_info_t* id, int area)
1061 {
1062         unsigned long flags;
1063         int i;
1064
1065         if(!id)
1066                 return;
1067         spin_lock_irqsave(&id->lock,flags);
1068         if(area == DEBUG_FLUSH_ALL){
1069                 id->active_area = 0;
1070                 memset(id->active_entry, 0, id->nr_areas * sizeof(int));
1071                 for (i = 0; i < id->nr_areas; i++)
1072                         memset(id->areas[i], 0, PAGE_SIZE << id->page_order);
1073                 printk(KERN_INFO "debug: %s: all areas flushed\n",id->name);
1074         } else if(area >= 0 && area < id->nr_areas) {
1075                 id->active_entry[area] = 0;
1076                 memset(id->areas[area], 0, PAGE_SIZE << id->page_order);
1077                 printk(KERN_INFO
1078                         "debug: %s: area %i has been flushed\n",
1079                         id->name, area);
1080         } else {
1081                 printk(KERN_INFO
1082                         "debug: %s: area %i cannot be flushed (range: %i - %i)\n",
1083                         id->name, area, 0, id->nr_areas-1);
1084         }
1085         spin_unlock_irqrestore(&id->lock,flags);
1086 }
1087
1088 /*
1089  * view function: flushes debug areas
1090  */
1091
1092 static int debug_input_flush_fn(debug_info_t * id, struct debug_view *view,
1093                                 struct file *file, const char __user *user_buf,
1094                                 size_t in_buf_size, loff_t * offset)
1095 {
1096         char input_buf[1];
1097         int rc = in_buf_size;
1098
1099         if (*offset != 0)
1100                 goto out;
1101         if (copy_from_user(input_buf, user_buf, 1)){
1102                 rc = -EFAULT;
1103                 goto out;
1104         }
1105         if(input_buf[0] == '-') {
1106                 debug_flush(id, DEBUG_FLUSH_ALL);
1107                 goto out;
1108         }
1109         if (isdigit(input_buf[0])) {
1110                 int area = ((int) input_buf[0] - (int) '0');
1111                 debug_flush(id, area);
1112                 goto out;
1113         }
1114
1115         printk(KERN_INFO "debug: area `%c` is not valid\n", input_buf[0]);
1116
1117       out:
1118         *offset += in_buf_size;
1119         return rc;              /* number of input characters */
1120 }
1121
1122 /*
1123  * prints debug header in raw format
1124  */
1125
1126 int debug_raw_header_fn(debug_info_t * id, struct debug_view *view,
1127                          int area, debug_entry_t * entry, char *out_buf)
1128 {
1129         int rc;
1130
1131         rc = sizeof(debug_entry_t);
1132         memcpy(out_buf,entry,sizeof(debug_entry_t));
1133         return rc;
1134 }
1135
1136 /*
1137  * prints debug data in raw format
1138  */
1139
1140 static int debug_raw_format_fn(debug_info_t * id, struct debug_view *view,
1141                                char *out_buf, const char *in_buf)
1142 {
1143         int rc;
1144
1145         rc = id->buf_size;
1146         memcpy(out_buf, in_buf, id->buf_size);
1147         return rc;
1148 }
1149
1150 /*
1151  * prints debug data in hex/ascii format
1152  */
1153
1154 static int debug_hex_ascii_format_fn(debug_info_t * id, struct debug_view *view,
1155                                   char *out_buf, const char *in_buf)
1156 {
1157         int i, rc = 0;
1158
1159         for (i = 0; i < id->buf_size; i++) {
1160                 rc += sprintf(out_buf + rc, "%02x ",
1161                               ((unsigned char *) in_buf)[i]);
1162         }
1163         rc += sprintf(out_buf + rc, "| ");
1164         for (i = 0; i < id->buf_size; i++) {
1165                 unsigned char c = in_buf[i];
1166                 if (!isprint(c))
1167                         rc += sprintf(out_buf + rc, ".");
1168                 else
1169                         rc += sprintf(out_buf + rc, "%c", c);
1170         }
1171         rc += sprintf(out_buf + rc, "\n");
1172         return rc;
1173 }
1174
1175 /*
1176  * prints header for debug entry
1177  */
1178
1179 int debug_dflt_header_fn(debug_info_t * id, struct debug_view *view,
1180                          int area, debug_entry_t * entry, char *out_buf)
1181 {
1182         struct timeval time_val;
1183         unsigned long long time;
1184         char *except_str;
1185         unsigned long caller;
1186         int rc = 0;
1187         unsigned int level;
1188
1189         level = entry->id.fields.level;
1190         time = entry->id.stck;
1191         /* adjust todclock to 1970 */
1192         time -= 0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096);
1193         tod_to_timeval(time, &time_val);
1194
1195         if (entry->id.fields.exception)
1196                 except_str = "*";
1197         else
1198                 except_str = "-";
1199         caller = ((unsigned long) entry->caller) & PSW_ADDR_INSN;
1200         rc += sprintf(out_buf, "%02i %011lu:%06lu %1u %1s %02i %p  ",
1201                       area, time_val.tv_sec, time_val.tv_usec, level,
1202                       except_str, entry->id.fields.cpuid, (void *) caller);
1203         return rc;
1204 }
1205
1206 /*
1207  * prints debug data sprintf-formated:
1208  * debug_sprinf_event/exception calls must be used together with this view
1209  */
1210
1211 #define DEBUG_SPRINTF_MAX_ARGS 10
1212
1213 int debug_sprintf_format_fn(debug_info_t * id, struct debug_view *view,
1214                             char *out_buf, debug_sprintf_entry_t *curr_event)
1215 {
1216         int num_longs, num_used_args = 0,i, rc = 0;
1217         int index[DEBUG_SPRINTF_MAX_ARGS];
1218
1219         /* count of longs fit into one entry */
1220         num_longs = id->buf_size /  sizeof(long);
1221
1222         if(num_longs < 1)
1223                 goto out; /* bufsize of entry too small */
1224         if(num_longs == 1) {
1225                 /* no args, we use only the string */
1226                 strcpy(out_buf, curr_event->string);
1227                 rc = strlen(curr_event->string);
1228                 goto out;
1229         }
1230
1231         /* number of arguments used for sprintf (without the format string) */
1232         num_used_args   = min(DEBUG_SPRINTF_MAX_ARGS, (num_longs - 1));
1233
1234         memset(index,0, DEBUG_SPRINTF_MAX_ARGS * sizeof(int));
1235
1236         for(i = 0; i < num_used_args; i++)
1237                 index[i] = i;
1238
1239         rc =  sprintf(out_buf, curr_event->string, curr_event->args[index[0]],
1240                 curr_event->args[index[1]], curr_event->args[index[2]],
1241                 curr_event->args[index[3]], curr_event->args[index[4]],
1242                 curr_event->args[index[5]], curr_event->args[index[6]],
1243                 curr_event->args[index[7]], curr_event->args[index[8]],
1244                 curr_event->args[index[9]]);
1245
1246 out:
1247
1248         return rc;
1249 }
1250
1251 /*
1252  * clean up module
1253  */
1254 void __exit debug_exit(void)
1255 {
1256 #ifdef DEBUG
1257         printk("debug_cleanup_module: \n");
1258 #endif
1259 #ifdef CONFIG_PROC_FS
1260         remove_proc_entry(debug_proc_root_entry->name, NULL);
1261 #endif /* CONFIG_PROC_FS */
1262         unregister_sysctl_table(s390dbf_sysctl_header);
1263         return;
1264 }
1265
1266 /*
1267  * module definitions
1268  */
1269 core_initcall(debug_init);
1270 module_exit(debug_exit);
1271 MODULE_LICENSE("GPL");
1272
1273 EXPORT_SYMBOL(debug_register);
1274 EXPORT_SYMBOL(debug_unregister);
1275 EXPORT_SYMBOL(debug_set_level);
1276 EXPORT_SYMBOL(debug_stop_all);
1277 EXPORT_SYMBOL(debug_register_view);
1278 EXPORT_SYMBOL(debug_unregister_view);
1279 EXPORT_SYMBOL(debug_event_common);
1280 EXPORT_SYMBOL(debug_exception_common);
1281 EXPORT_SYMBOL(debug_hex_ascii_view);
1282 EXPORT_SYMBOL(debug_raw_view);
1283 EXPORT_SYMBOL(debug_dflt_header_fn);
1284 EXPORT_SYMBOL(debug_sprintf_view);
1285 EXPORT_SYMBOL(debug_sprintf_exception);
1286 EXPORT_SYMBOL(debug_sprintf_event);