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