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