PageRenderTime 161ms CodeModel.GetById 110ms app.highlight 43ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/s390/kernel/debug.c

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