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 <asm/uaccess.h>
  20 #include <asm/semaphore.h>
  21
  22 #include <linux/module.h>
  23 #include <linux/init.h>
  24
  25 #include <asm/debug.h>
  26
  27 #define MIN(a,b) (((a)<(b))?(a):(b))
  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;
  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 *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_common:
 696  * - set timestamp, caller address, cpu number etc.
 697  */
 698
 699 extern inline debug_entry_t *debug_common(debug_info_t * id, int level,
 700                                     const void *buf, int len, int exception)
 701 {
 702         unsigned long flags;
 703         debug_entry_t *active;
 704
 705         spin_lock_irqsave(&id->lock, flags);
 706         active = get_active_entry(id);
 707         STCK(active->id.stck);
 708         active->id.fields.cpuid = smp_processor_id();
 709         active->caller = __builtin_return_address(0);
 710         active->id.fields.exception = exception;
 711         active->id.fields.level     = level;
 712         memset(DEBUG_DATA(active), 0, id->buf_size);
 713         memcpy(DEBUG_DATA(active), buf, MIN(len, id->buf_size));
 714         proceed_active_entry(id);
 715         if(exception)
 716                 proceed_active_area(id);
 717         spin_unlock_irqrestore(&id->lock, flags);
 718
 719         return active;
 720 }
 721
 722 /*
 723  * debug_event_common:
 724  * - write debug entry with given size
 725  */
 726
 727 debug_entry_t *debug_event_common(debug_info_t * id, int level, const void *buf,
 728                                   int len)
 729 {
 730         return debug_common(id, level, buf, len, 0);
 731 }
 732
 733 /*
 734  * debug_exception_common:
 735  * - write debug entry with given size and switch to next debug area
 736  */
 737
 738 debug_entry_t *debug_exception_common(debug_info_t * id, int level,
 739                                       const void *buf, int len)
 740 {
 741         return debug_common(id, level, buf, len, 1);
 742 }
 743
 744 /*
 745  * counts arguments in format string for sprintf view
 746  */
 747
 748 extern inline int debug_count_numargs(char *string)
 749 {
 750         int numargs=0;
 751
 752         while(*string) {
 753                 if(*string++=='%')
 754                         numargs++;
 755         }
 756         return(numargs);
 757 }
 758
 759 /*
 760  * debug_sprintf_event:
 761  */
 762
 763 debug_entry_t *debug_sprintf_event(debug_info_t* id,
 764                                    int level,char *string,...)
 765 {
 766         va_list   ap;
 767         int numargs,alloc_size,idx;
 768         debug_sprintf_entry *curr_event;
 769         debug_entry_t *retval = NULL;
 770
 771         if((!id) || (level > id->level))
 772                 return NULL;
 773         else {
 774                 numargs=debug_count_numargs(string);
 775                 alloc_size=offsetof(debug_sprintf_entry,args[numargs]);
 776                 curr_event=alloca(alloc_size);
 777
 778                 if(curr_event){
 779                         va_start(ap,string);
 780                         curr_event->string=string;
 781                         for(idx=0;idx<numargs;idx++)
 782                                 curr_event->args[idx]=va_arg(ap,long);
 783                         retval=debug_common(id,level, curr_event,alloc_size,0);
 784                         va_end(ap);
 785                 }
 786                 return retval;
 787         }
 788 }
 789
 790 /*
 791  * debug_sprintf_exception:
 792  */
 793
 794 debug_entry_t *debug_sprintf_exception(debug_info_t* id,
 795                                        int level,char *string,...)
 796 {
 797         va_list   ap;
 798         int numargs,alloc_size,idx;
 799         debug_sprintf_entry *curr_event;
 800         debug_entry_t *retval = NULL;
 801
 802         if((!id) || (level > id->level))
 803                 return NULL;
 804         else {
 805                 numargs=debug_count_numargs(string);
 806                 alloc_size=offsetof(debug_sprintf_entry,args[numargs]);
 807                 curr_event=alloca(alloc_size);
 808
 809                 if(curr_event){
 810                         va_start(ap,string);
 811                         curr_event->string=string;
 812                         for(idx=0;idx<numargs;idx++)
 813                                 curr_event->args[idx]=va_arg(ap,long);
 814                         retval=debug_common(id,level, curr_event,alloc_size,1);
 815                         va_end(ap);
 816                 }
 817                 return retval;
 818         }
 819 }
 820
 821 /*
 822  * debug_init:
 823  * - is called exactly once to initialize the debug feature
 824  */
 825
 826 static int __init debug_init(void)
 827 {
 828         int rc = 0;
 829
 830         down(&debug_lock);
 831 #ifdef CONFIG_PROC_FS
 832         debug_proc_root_entry = proc_mkdir(DEBUG_DIR_ROOT, NULL);
 833 #endif /* CONFIG_PROC_FS */
 834         printk(KERN_INFO "debug: Initialization complete\n");
 835         initialized = 1;
 836         up(&debug_lock);
 837
 838         return rc;
 839 }
 840
 841 /*
 842  * debug_register_view:
 843  */
 844
 845 int debug_register_view(debug_info_t * id, struct debug_view *view)
 846 {
 847         int rc = 0;
 848         int i;
 849         unsigned long flags;
 850         mode_t mode = S_IFREG;
 851         struct proc_dir_entry *pde;
 852
 853         if (!id)
 854                 goto out;
 855         pde = create_proc_entry(view->name, mode, id->proc_root_entry);
 856         if (!pde){
 857                 printk(KERN_WARNING "debug: create_proc_entry() failed! Cannot register view %s/%s\n", id->name,view->name);
 858                 rc = -1;
 859                 goto out;
 860         }
 861
 862         spin_lock_irqsave(&id->lock, flags);
 863         for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
 864                 if (id->views[i] == NULL)
 865                         break;
 866         }
 867         if (i == DEBUG_MAX_VIEWS) {
 868                 printk(KERN_WARNING "debug: cannot register view %s/%s\n",
 869                         id->name,view->name);
 870                 printk(KERN_WARNING
 871                         "debug: maximum number of views reached (%i)!\n", i);
 872                 remove_proc_entry(pde->name, id->proc_root_entry);
 873                 rc = -1;
 874         }
 875         else {
 876                 id->views[i] = view;
 877                 if (view->prolog_proc || view->format_proc || view->header_proc)
 878                         mode |= S_IRUSR;
 879                 if (view->input_proc)
 880                         mode |= S_IWUSR;
 881                 pde->proc_fops = &debug_file_ops;
 882                 id->proc_entries[i] = pde;
 883         }
 884         spin_unlock_irqrestore(&id->lock, flags);
 885       out:
 886         return rc;
 887 }
 888
 889 /*
 890  * debug_unregister_view:
 891  */
 892
 893 int debug_unregister_view(debug_info_t * id, struct debug_view *view)
 894 {
 895         int rc = 0;
 896         int i;
 897         unsigned long flags;
 898
 899         if (!id)
 900                 goto out;
 901         spin_lock_irqsave(&id->lock, flags);
 902         for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
 903                 if (id->views[i] == view)
 904                         break;
 905         }
 906         if (i == DEBUG_MAX_VIEWS)
 907                 rc = -1;
 908         else {
 909 #ifdef CONFIG_PROC_FS
 910                 remove_proc_entry(id->proc_entries[i]->name,
 911                                   id->proc_root_entry);
 912 #endif
 913                 id->views[i] = NULL;
 914                 rc = 0;
 915         }
 916         spin_unlock_irqrestore(&id->lock, flags);
 917       out:
 918         return rc;
 919 }
 920
 921 /*
 922  * functions for debug-views
 923  ***********************************
 924 */
 925
 926 /*
 927  * prints out actual debug level
 928  */
 929
 930 static int debug_prolog_level_fn(debug_info_t * id,
 931                                  struct debug_view *view, char *out_buf)
 932 {
 933         int rc = 0;
 934
 935         if(id->level == -1) rc = sprintf(out_buf,"-\n");
 936         else rc = sprintf(out_buf, "%i\n", id->level);
 937         return rc;
 938 }
 939
 940 /*
 941  * reads new debug level
 942  */
 943
 944 static int debug_input_level_fn(debug_info_t * id, struct debug_view *view,
 945                                 struct file *file, const char __user *user_buf,
 946                                 size_t in_buf_size, loff_t * offset)
 947 {
 948         char input_buf[1];
 949         int rc = in_buf_size;
 950
 951         if (*offset != 0)
 952                 goto out;
 953         if (copy_from_user(input_buf, user_buf, 1)){
 954                 rc = -EFAULT;
 955                 goto out;
 956         }
 957         if (isdigit(input_buf[0])) {
 958                 int new_level = ((int) input_buf[0] - (int) '0');
 959                 debug_set_level(id, new_level);
 960         } else if(input_buf[0] == '-') {
 961                 debug_set_level(id, DEBUG_OFF_LEVEL);
 962         } else {
 963                 printk(KERN_INFO "debug: level `%c` is not valid\n",
 964                        input_buf[0]);
 965         }
 966       out:
 967         *offset += in_buf_size;
 968         return rc;              /* number of input characters */
 969 }
 970
 971
 972 /*
 973  * flushes debug areas
 974  */
 975
 976 void debug_flush(debug_info_t* id, int area)
 977 {
 978         unsigned long flags;
 979         int i;
 980
 981         if(!id)
 982                 return;
 983         spin_lock_irqsave(&id->lock,flags);
 984         if(area == DEBUG_FLUSH_ALL){
 985                 id->active_area = 0;
 986                 memset(id->active_entry, 0, id->nr_areas * sizeof(int));
 987                 for (i = 0; i < id->nr_areas; i++)
 988                         memset(id->areas[i], 0, PAGE_SIZE << id->page_order);
 989                 printk(KERN_INFO "debug: %s: all areas flushed\n",id->name);
 990         } else if(area >= 0 && area < id->nr_areas) {
 991                 id->active_entry[area] = 0;
 992                 memset(id->areas[area], 0, PAGE_SIZE << id->page_order);
 993                 printk(KERN_INFO
 994                         "debug: %s: area %i has been flushed\n",
 995                         id->name, area);
 996         } else {
 997                 printk(KERN_INFO
 998                         "debug: %s: area %i cannot be flushed (range: %i - %i)\n",
 999                         id->name, area, 0, id->nr_areas-1);
1000         }
1001         spin_unlock_irqrestore(&id->lock,flags);
1002 }
1003
1004 /*
1005  * view function: flushes debug areas
1006  */
1007
1008 static int debug_input_flush_fn(debug_info_t * id, struct debug_view *view,
1009                                 struct file *file, const char __user *user_buf,
1010                                 size_t in_buf_size, loff_t * offset)
1011 {
1012         char input_buf[1];
1013         int rc = in_buf_size;
1014
1015         if (*offset != 0)
1016                 goto out;
1017         if (copy_from_user(input_buf, user_buf, 1)){
1018                 rc = -EFAULT;
1019                 goto out;
1020         }
1021         if(input_buf[0] == '-') {
1022                 debug_flush(id, DEBUG_FLUSH_ALL);
1023                 goto out;
1024         }
1025         if (isdigit(input_buf[0])) {
1026                 int area = ((int) input_buf[0] - (int) '0');
1027                 debug_flush(id, area);
1028                 goto out;
1029         }
1030
1031         printk(KERN_INFO "debug: area `%c` is not valid\n", input_buf[0]);
1032
1033       out:
1034         *offset += in_buf_size;
1035         return rc;              /* number of input characters */
1036 }
1037
1038 /*
1039  * prints debug header in raw format
1040  */
1041
1042 int debug_raw_header_fn(debug_info_t * id, struct debug_view *view,
1043                          int area, debug_entry_t * entry, char *out_buf)
1044 {
1045         int rc;
1046
1047         rc = sizeof(debug_entry_t);
1048         memcpy(out_buf,entry,sizeof(debug_entry_t));
1049         return rc;
1050 }
1051
1052 /*
1053  * prints debug data in raw format
1054  */
1055
1056 static int debug_raw_format_fn(debug_info_t * id, struct debug_view *view,
1057                                char *out_buf, const char *in_buf)
1058 {
1059         int rc;
1060
1061         rc = id->buf_size;
1062         memcpy(out_buf, in_buf, id->buf_size);
1063         return rc;
1064 }
1065
1066 /*
1067  * prints debug data in hex/ascii format
1068  */
1069
1070 static int debug_hex_ascii_format_fn(debug_info_t * id, struct debug_view *view,
1071                                   char *out_buf, const char *in_buf)
1072 {
1073         int i, rc = 0;
1074
1075         for (i = 0; i < id->buf_size; i++) {
1076                 rc += sprintf(out_buf + rc, "%02x ",
1077                               ((unsigned char *) in_buf)[i]);
1078         }
1079         rc += sprintf(out_buf + rc, "| ");
1080         for (i = 0; i < id->buf_size; i++) {
1081                 unsigned char c = in_buf[i];
1082                 if (!isprint(c))
1083                         rc += sprintf(out_buf + rc, ".");
1084                 else
1085                         rc += sprintf(out_buf + rc, "%c", c);
1086         }
1087         rc += sprintf(out_buf + rc, "\n");
1088         return rc;
1089 }
1090
1091 /*
1092  * prints header for debug entry
1093  */
1094
1095 int debug_dflt_header_fn(debug_info_t * id, struct debug_view *view,
1096                          int area, debug_entry_t * entry, char *out_buf)
1097 {
1098         struct timeval time_val;
1099         unsigned long long time;
1100         char *except_str;
1101         unsigned long caller;
1102         int rc = 0;
1103         unsigned int level;
1104
1105         level = entry->id.fields.level;
1106         time = entry->id.stck;
1107         /* adjust todclock to 1970 */
1108         time -= 0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096);
1109         tod_to_timeval(time, &time_val);
1110
1111         if (entry->id.fields.exception)
1112                 except_str = "*";
1113         else
1114                 except_str = "-";
1115         caller = ((unsigned long) entry->caller) & PSW_ADDR_INSN;
1116         rc += sprintf(out_buf, "%02i %011lu:%06lu %1u %1s %02i %p  ",
1117                       area, time_val.tv_sec, time_val.tv_usec, level,
1118                       except_str, entry->id.fields.cpuid, (void *) caller);
1119         return rc;
1120 }
1121
1122 /*
1123  * prints debug data sprintf-formated:
1124  * debug_sprinf_event/exception calls must be used together with this view
1125  */
1126
1127 #define DEBUG_SPRINTF_MAX_ARGS 10
1128
1129 int debug_sprintf_format_fn(debug_info_t * id, struct debug_view *view,
1130                             char *out_buf, debug_sprintf_entry *curr_event)
1131 {
1132         int num_longs, num_used_args = 0,i, rc = 0;
1133         int index[DEBUG_SPRINTF_MAX_ARGS];
1134
1135         /* count of longs fit into one entry */
1136         num_longs = id->buf_size /  sizeof(long);
1137
1138         if(num_longs < 1)
1139                 goto out; /* bufsize of entry too small */
1140         if(num_longs == 1) {
1141                 /* no args, we use only the string */
1142                 strcpy(out_buf, curr_event->string);
1143                 rc = strlen(curr_event->string);
1144                 goto out;
1145         }
1146
1147         /* number of arguments used for sprintf (without the format string) */
1148         num_used_args   = MIN(DEBUG_SPRINTF_MAX_ARGS, (num_longs - 1));
1149
1150         memset(index,0, DEBUG_SPRINTF_MAX_ARGS * sizeof(int));
1151
1152         for(i = 0; i < num_used_args; i++)
1153                 index[i] = i;
1154
1155         rc =  sprintf(out_buf, curr_event->string, curr_event->args[index[0]],
1156                 curr_event->args[index[1]], curr_event->args[index[2]],
1157                 curr_event->args[index[3]], curr_event->args[index[4]],
1158                 curr_event->args[index[5]], curr_event->args[index[6]],
1159                 curr_event->args[index[7]], curr_event->args[index[8]],
1160                 curr_event->args[index[9]]);
1161
1162 out:
1163
1164         return rc;
1165 }
1166
1167 /*
1168  * clean up module
1169  */
1170 void __exit debug_exit(void)
1171 {
1172 #ifdef DEBUG
1173         printk("debug_cleanup_module: \n");
1174 #endif
1175 #ifdef CONFIG_PROC_FS
1176         remove_proc_entry(debug_proc_root_entry->name, NULL);
1177 #endif /* CONFIG_PROC_FS */
1178         return;
1179 }
1180
1181 /*
1182  * module definitions
1183  */
1184 core_initcall(debug_init);
1185 module_exit(debug_exit);
1186 MODULE_LICENSE("GPL");
1187
1188 EXPORT_SYMBOL(debug_register);
1189 EXPORT_SYMBOL(debug_unregister);
1190 EXPORT_SYMBOL(debug_set_level);
1191 EXPORT_SYMBOL(debug_register_view);
1192 EXPORT_SYMBOL(debug_unregister_view);
1193 EXPORT_SYMBOL(debug_event_common);
1194 EXPORT_SYMBOL(debug_exception_common);
1195 EXPORT_SYMBOL(debug_hex_ascii_view);
1196 EXPORT_SYMBOL(debug_raw_view);
1197 EXPORT_SYMBOL(debug_dflt_header_fn);
1198 EXPORT_SYMBOL(debug_sprintf_view);
1199 EXPORT_SYMBOL(debug_sprintf_exception);
1200 EXPORT_SYMBOL(debug_sprintf_event);