1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright IBM Corp. 1999, 2012
7 * Author(s): Michael Holzheu (holzheu@de.ibm.com),
8 * Holger Smolinski (Holger.Smolinski@de.ibm.com)
10 * Bugreports to: <Linux390@de.ibm.com>
13 #define KMSG_COMPONENT "s390dbf"
14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
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 <linux/uaccess.h>
24 #include <linux/export.h>
25 #include <linux/init.h>
27 #include <linux/debugfs.h>
29 #include <asm/debug.h>
31 #define DEBUG_PROLOG_ENTRY -1
33 #define ALL_AREAS 0 /* copy all debug areas */
34 #define NO_AREAS 1 /* copy no debug areas */
38 typedef 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 */
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
;
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)
64 } debug_sprintf_entry_t
;
67 /* internal function prototyes */
69 static int debug_init(void);
70 static ssize_t
debug_output(struct file
*file
, char __user
*user_buf
,
71 size_t user_len
, loff_t
* offset
);
72 static ssize_t
debug_input(struct file
*file
, const char __user
*user_buf
,
73 size_t user_len
, loff_t
* offset
);
74 static int debug_open(struct inode
*inode
, struct file
*file
);
75 static int debug_close(struct inode
*inode
, struct file
*file
);
76 static debug_info_t
*debug_info_create(const char *name
, int pages_per_area
,
77 int nr_areas
, int buf_size
, umode_t mode
);
78 static void debug_info_get(debug_info_t
*);
79 static void debug_info_put(debug_info_t
*);
80 static int debug_prolog_level_fn(debug_info_t
* id
,
81 struct debug_view
*view
, char *out_buf
);
82 static 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
);
85 static int debug_prolog_pages_fn(debug_info_t
* id
,
86 struct debug_view
*view
, char *out_buf
);
87 static 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
);
90 static 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
);
93 static int debug_hex_ascii_format_fn(debug_info_t
* id
, struct debug_view
*view
,
94 char *out_buf
, const char *in_buf
);
95 static int debug_raw_format_fn(debug_info_t
* id
,
96 struct debug_view
*view
, char *out_buf
,
98 static int debug_raw_header_fn(debug_info_t
* id
, struct debug_view
*view
,
99 int area
, debug_entry_t
* entry
, char *out_buf
);
101 static int debug_sprintf_format_fn(debug_info_t
* id
, struct debug_view
*view
,
102 char *out_buf
, debug_sprintf_entry_t
*curr_event
);
106 struct debug_view debug_raw_view
= {
109 &debug_raw_header_fn
,
110 &debug_raw_format_fn
,
114 EXPORT_SYMBOL(debug_raw_view
);
116 struct debug_view debug_hex_ascii_view
= {
119 &debug_dflt_header_fn
,
120 &debug_hex_ascii_format_fn
,
124 EXPORT_SYMBOL(debug_hex_ascii_view
);
126 static struct debug_view debug_level_view
= {
128 &debug_prolog_level_fn
,
131 &debug_input_level_fn
,
135 static struct debug_view debug_pages_view
= {
137 &debug_prolog_pages_fn
,
140 &debug_input_pages_fn
,
144 static struct debug_view debug_flush_view
= {
149 &debug_input_flush_fn
,
153 struct debug_view debug_sprintf_view
= {
156 &debug_dflt_header_fn
,
157 (debug_format_proc_t
*)&debug_sprintf_format_fn
,
161 EXPORT_SYMBOL(debug_sprintf_view
);
163 /* used by dump analysis tools to determine version of debug feature */
164 static unsigned int __used debug_feature_version
= __DEBUG_FEATURE_VERSION
;
168 static debug_info_t
*debug_area_first
= NULL
;
169 static debug_info_t
*debug_area_last
= NULL
;
170 static DEFINE_MUTEX(debug_mutex
);
172 static int initialized
;
173 static int debug_critical
;
175 static const struct file_operations debug_file_ops
= {
176 .owner
= THIS_MODULE
,
177 .read
= debug_output
,
178 .write
= debug_input
,
180 .release
= debug_close
,
184 static struct dentry
*debug_debugfs_root_entry
;
190 * - Debug areas are implemented as a threedimensonal array:
191 * areas[areanumber][pagenumber][pageoffset]
194 static debug_entry_t
***
195 debug_areas_alloc(int pages_per_area
, int nr_areas
)
197 debug_entry_t
*** areas
;
200 areas
= kmalloc(nr_areas
*
201 sizeof(debug_entry_t
**),
204 goto fail_malloc_areas
;
205 for (i
= 0; i
< nr_areas
; i
++) {
206 areas
[i
] = kmalloc(pages_per_area
*
207 sizeof(debug_entry_t
*),GFP_KERNEL
);
209 goto fail_malloc_areas2
;
211 for(j
= 0; j
< pages_per_area
; j
++) {
212 areas
[i
][j
] = kzalloc(PAGE_SIZE
, GFP_KERNEL
);
214 for(j
--; j
>=0 ; j
--) {
218 goto fail_malloc_areas2
;
225 for(i
--; i
>= 0; i
--){
226 for(j
=0; j
< pages_per_area
;j
++){
240 * - alloc new debug-info
244 debug_info_alloc(const char *name
, int pages_per_area
, int nr_areas
,
245 int buf_size
, int level
, int mode
)
249 /* alloc everything */
251 rc
= kmalloc(sizeof(debug_info_t
), GFP_KERNEL
);
254 rc
->active_entries
= kcalloc(nr_areas
, sizeof(int), GFP_KERNEL
);
255 if(!rc
->active_entries
)
256 goto fail_malloc_active_entries
;
257 rc
->active_pages
= kcalloc(nr_areas
, sizeof(int), GFP_KERNEL
);
258 if(!rc
->active_pages
)
259 goto fail_malloc_active_pages
;
260 if((mode
== ALL_AREAS
) && (pages_per_area
!= 0)){
261 rc
->areas
= debug_areas_alloc(pages_per_area
, nr_areas
);
263 goto fail_malloc_areas
;
268 /* initialize members */
270 spin_lock_init(&rc
->lock
);
271 rc
->pages_per_area
= pages_per_area
;
272 rc
->nr_areas
= nr_areas
;
275 rc
->buf_size
= buf_size
;
276 rc
->entry_size
= sizeof(debug_entry_t
) + buf_size
;
277 strlcpy(rc
->name
, name
, sizeof(rc
->name
));
278 memset(rc
->views
, 0, DEBUG_MAX_VIEWS
* sizeof(struct debug_view
*));
279 memset(rc
->debugfs_entries
, 0 ,DEBUG_MAX_VIEWS
*
280 sizeof(struct dentry
*));
281 refcount_set(&(rc
->ref_count
), 0);
286 kfree(rc
->active_pages
);
287 fail_malloc_active_pages
:
288 kfree(rc
->active_entries
);
289 fail_malloc_active_entries
:
297 * - free all debug areas
301 debug_areas_free(debug_info_t
* db_info
)
307 for (i
= 0; i
< db_info
->nr_areas
; i
++) {
308 for(j
= 0; j
< db_info
->pages_per_area
; j
++) {
309 kfree(db_info
->areas
[i
][j
]);
311 kfree(db_info
->areas
[i
]);
313 kfree(db_info
->areas
);
314 db_info
->areas
= NULL
;
319 * - free memory debug-info
323 debug_info_free(debug_info_t
* db_info
){
324 debug_areas_free(db_info
);
325 kfree(db_info
->active_entries
);
326 kfree(db_info
->active_pages
);
332 * - create new debug-info
336 debug_info_create(const char *name
, int pages_per_area
, int nr_areas
,
337 int buf_size
, umode_t mode
)
341 rc
= debug_info_alloc(name
, pages_per_area
, nr_areas
, buf_size
,
342 DEBUG_DEFAULT_LEVEL
, ALL_AREAS
);
346 rc
->mode
= mode
& ~S_IFMT
;
348 /* create root directory */
349 rc
->debugfs_root_entry
= debugfs_create_dir(rc
->name
,
350 debug_debugfs_root_entry
);
352 /* append new element to linked list */
353 if (!debug_area_first
) {
354 /* first element in list */
355 debug_area_first
= rc
;
358 /* append element to end of list */
359 debug_area_last
->next
= rc
;
360 rc
->prev
= debug_area_last
;
362 debug_area_last
= rc
;
365 refcount_set(&rc
->ref_count
, 1);
376 debug_info_copy(debug_info_t
* in
, int mode
)
382 /* get a consistent copy of the debug areas */
384 rc
= debug_info_alloc(in
->name
, in
->pages_per_area
,
385 in
->nr_areas
, in
->buf_size
, in
->level
, mode
);
386 spin_lock_irqsave(&in
->lock
, flags
);
389 /* has something changed in the meantime ? */
390 if((rc
->pages_per_area
== in
->pages_per_area
) &&
391 (rc
->nr_areas
== in
->nr_areas
)) {
394 spin_unlock_irqrestore(&in
->lock
, flags
);
398 if (mode
== NO_AREAS
)
401 for(i
= 0; i
< in
->nr_areas
; i
++){
402 for(j
= 0; j
< in
->pages_per_area
; j
++) {
403 memcpy(rc
->areas
[i
][j
], in
->areas
[i
][j
],PAGE_SIZE
);
407 spin_unlock_irqrestore(&in
->lock
, flags
);
413 * - increments reference count for debug-info
417 debug_info_get(debug_info_t
* db_info
)
420 refcount_inc(&db_info
->ref_count
);
425 * - decreases reference count for debug-info and frees it if necessary
429 debug_info_put(debug_info_t
*db_info
)
435 if (refcount_dec_and_test(&db_info
->ref_count
)) {
436 for (i
= 0; i
< DEBUG_MAX_VIEWS
; i
++) {
437 if (!db_info
->views
[i
])
439 debugfs_remove(db_info
->debugfs_entries
[i
]);
441 debugfs_remove(db_info
->debugfs_root_entry
);
442 if(db_info
== debug_area_first
)
443 debug_area_first
= db_info
->next
;
444 if(db_info
== debug_area_last
)
445 debug_area_last
= db_info
->prev
;
446 if(db_info
->prev
) db_info
->prev
->next
= db_info
->next
;
447 if(db_info
->next
) db_info
->next
->prev
= db_info
->prev
;
448 debug_info_free(db_info
);
453 * debug_format_entry:
454 * - format one debug entry and return size of formated data
458 debug_format_entry(file_private_info_t
*p_info
)
460 debug_info_t
*id_snap
= p_info
->debug_info_snap
;
461 struct debug_view
*view
= p_info
->view
;
462 debug_entry_t
*act_entry
;
464 if(p_info
->act_entry
== DEBUG_PROLOG_ENTRY
){
466 if (view
->prolog_proc
)
467 len
+= view
->prolog_proc(id_snap
,view
,p_info
->temp_buf
);
470 if (!id_snap
->areas
) /* this is true, if we have a prolog only view */
471 goto out
; /* or if 'pages_per_area' is 0 */
472 act_entry
= (debug_entry_t
*) ((char*)id_snap
->areas
[p_info
->act_area
]
473 [p_info
->act_page
] + p_info
->act_entry
);
475 if (act_entry
->id
.stck
== 0LL)
476 goto out
; /* empty entry */
477 if (view
->header_proc
)
478 len
+= view
->header_proc(id_snap
, view
, p_info
->act_area
,
479 act_entry
, p_info
->temp_buf
+ len
);
480 if (view
->format_proc
)
481 len
+= view
->format_proc(id_snap
, view
, p_info
->temp_buf
+ len
,
482 DEBUG_DATA(act_entry
));
489 * - goto next entry in p_info
493 debug_next_entry(file_private_info_t
*p_info
)
497 id
= p_info
->debug_info_snap
;
498 if(p_info
->act_entry
== DEBUG_PROLOG_ENTRY
){
499 p_info
->act_entry
= 0;
500 p_info
->act_page
= 0;
505 p_info
->act_entry
+= id
->entry_size
;
506 /* switch to next page, if we reached the end of the page */
507 if (p_info
->act_entry
> (PAGE_SIZE
- id
->entry_size
)){
509 p_info
->act_entry
= 0;
510 p_info
->act_page
+= 1;
511 if((p_info
->act_page
% id
->pages_per_area
) == 0) {
516 if(p_info
->act_area
>= id
->nr_areas
)
525 * - called for user read()
526 * - copies formated debug entries to the user buffer
530 debug_output(struct file
*file
, /* file descriptor */
531 char __user
*user_buf
, /* user buffer */
532 size_t len
, /* length of buffer */
533 loff_t
*offset
) /* offset in the file */
537 file_private_info_t
*p_info
;
539 p_info
= ((file_private_info_t
*) file
->private_data
);
540 if (*offset
!= p_info
->offset
)
542 if(p_info
->act_area
>= p_info
->debug_info_snap
->nr_areas
)
544 entry_offset
= p_info
->act_entry_offset
;
546 int formatted_line_size
;
547 int formatted_line_residue
;
548 int user_buf_residue
;
551 formatted_line_size
= debug_format_entry(p_info
);
552 formatted_line_residue
= formatted_line_size
- entry_offset
;
553 user_buf_residue
= len
-count
;
554 copy_size
= min(user_buf_residue
, formatted_line_residue
);
556 if (copy_to_user(user_buf
+ count
, p_info
->temp_buf
557 + entry_offset
, copy_size
))
560 entry_offset
+= copy_size
;
562 if(copy_size
== formatted_line_residue
){
564 if(debug_next_entry(p_info
))
569 p_info
->offset
= *offset
+ count
;
570 p_info
->act_entry_offset
= entry_offset
;
571 *offset
= p_info
->offset
;
577 * - called for user write()
578 * - calls input function of view
582 debug_input(struct file
*file
, const char __user
*user_buf
, size_t length
,
586 file_private_info_t
*p_info
;
588 mutex_lock(&debug_mutex
);
589 p_info
= ((file_private_info_t
*) file
->private_data
);
590 if (p_info
->view
->input_proc
)
591 rc
= p_info
->view
->input_proc(p_info
->debug_info_org
,
592 p_info
->view
, file
, user_buf
,
596 mutex_unlock(&debug_mutex
);
597 return rc
; /* number of input characters */
602 * - called for user open()
603 * - copies formated output to private_data area of the file
608 debug_open(struct inode
*inode
, struct file
*file
)
611 file_private_info_t
*p_info
;
612 debug_info_t
*debug_info
, *debug_info_snapshot
;
614 mutex_lock(&debug_mutex
);
615 debug_info
= file_inode(file
)->i_private
;
616 /* find debug view */
617 for (i
= 0; i
< DEBUG_MAX_VIEWS
; i
++) {
618 if (!debug_info
->views
[i
])
620 else if (debug_info
->debugfs_entries
[i
] ==
621 file
->f_path
.dentry
) {
622 goto found
; /* found view ! */
631 /* Make snapshot of current debug areas to get it consistent. */
632 /* To copy all the areas is only needed, if we have a view which */
633 /* formats the debug areas. */
635 if(!debug_info
->views
[i
]->format_proc
&&
636 !debug_info
->views
[i
]->header_proc
){
637 debug_info_snapshot
= debug_info_copy(debug_info
, NO_AREAS
);
639 debug_info_snapshot
= debug_info_copy(debug_info
, ALL_AREAS
);
642 if(!debug_info_snapshot
){
646 p_info
= kmalloc(sizeof(file_private_info_t
),
649 debug_info_free(debug_info_snapshot
);
654 p_info
->debug_info_snap
= debug_info_snapshot
;
655 p_info
->debug_info_org
= debug_info
;
656 p_info
->view
= debug_info
->views
[i
];
657 p_info
->act_area
= 0;
658 p_info
->act_page
= 0;
659 p_info
->act_entry
= DEBUG_PROLOG_ENTRY
;
660 p_info
->act_entry_offset
= 0;
661 file
->private_data
= p_info
;
662 debug_info_get(debug_info
);
663 nonseekable_open(inode
, file
);
665 mutex_unlock(&debug_mutex
);
671 * - called for user close()
672 * - deletes private_data area of the file handle
676 debug_close(struct inode
*inode
, struct file
*file
)
678 file_private_info_t
*p_info
;
679 p_info
= (file_private_info_t
*) file
->private_data
;
680 if(p_info
->debug_info_snap
)
681 debug_info_free(p_info
->debug_info_snap
);
682 debug_info_put(p_info
->debug_info_org
);
683 kfree(file
->private_data
);
684 return 0; /* success */
688 * debug_register_mode:
689 * - Creates and initializes debug area for the caller
690 * The mode parameter allows to specify access rights for the s390dbf files
691 * - Returns handle for debug area
694 debug_info_t
*debug_register_mode(const char *name
, int pages_per_area
,
695 int nr_areas
, int buf_size
, umode_t mode
,
696 uid_t uid
, gid_t gid
)
698 debug_info_t
*rc
= NULL
;
700 /* Since debugfs currently does not support uid/gid other than root, */
701 /* we do not allow gid/uid != 0 until we get support for that. */
702 if ((uid
!= 0) || (gid
!= 0))
703 pr_warn("Root becomes the owner of all s390dbf files in sysfs\n");
704 BUG_ON(!initialized
);
705 mutex_lock(&debug_mutex
);
707 /* create new debug_info */
709 rc
= debug_info_create(name
, pages_per_area
, nr_areas
, buf_size
, mode
);
712 debug_register_view(rc
, &debug_level_view
);
713 debug_register_view(rc
, &debug_flush_view
);
714 debug_register_view(rc
, &debug_pages_view
);
717 pr_err("Registering debug feature %s failed\n", name
);
719 mutex_unlock(&debug_mutex
);
722 EXPORT_SYMBOL(debug_register_mode
);
726 * - creates and initializes debug area for the caller
727 * - returns handle for debug area
730 debug_info_t
*debug_register(const char *name
, int pages_per_area
,
731 int nr_areas
, int buf_size
)
733 return debug_register_mode(name
, pages_per_area
, nr_areas
, buf_size
,
734 S_IRUSR
| S_IWUSR
, 0, 0);
736 EXPORT_SYMBOL(debug_register
);
740 * - give back debug area
744 debug_unregister(debug_info_t
* id
)
748 mutex_lock(&debug_mutex
);
750 mutex_unlock(&debug_mutex
);
755 EXPORT_SYMBOL(debug_unregister
);
759 * - set area size (number of pages) and number of areas
762 debug_set_size(debug_info_t
* id
, int nr_areas
, int pages_per_area
)
765 debug_entry_t
*** new_areas
;
768 if(!id
|| (nr_areas
<= 0) || (pages_per_area
< 0))
770 if(pages_per_area
> 0){
771 new_areas
= debug_areas_alloc(pages_per_area
, nr_areas
);
773 pr_info("Allocating memory for %i pages failed\n",
781 spin_lock_irqsave(&id
->lock
,flags
);
782 debug_areas_free(id
);
783 id
->areas
= new_areas
;
784 id
->nr_areas
= nr_areas
;
785 id
->pages_per_area
= pages_per_area
;
787 memset(id
->active_entries
,0,sizeof(int)*id
->nr_areas
);
788 memset(id
->active_pages
, 0, sizeof(int)*id
->nr_areas
);
789 spin_unlock_irqrestore(&id
->lock
,flags
);
790 pr_info("%s: set new size (%i pages)\n" ,id
->name
, pages_per_area
);
797 * - set actual debug level
801 debug_set_level(debug_info_t
* id
, int new_level
)
806 spin_lock_irqsave(&id
->lock
,flags
);
807 if(new_level
== DEBUG_OFF_LEVEL
){
808 id
->level
= DEBUG_OFF_LEVEL
;
809 pr_info("%s: switched off\n",id
->name
);
810 } else if ((new_level
> DEBUG_MAX_LEVEL
) || (new_level
< 0)) {
811 pr_info("%s: level %i is out of range (%i - %i)\n",
812 id
->name
, new_level
, 0, DEBUG_MAX_LEVEL
);
814 id
->level
= new_level
;
816 spin_unlock_irqrestore(&id
->lock
,flags
);
818 EXPORT_SYMBOL(debug_set_level
);
821 * proceed_active_entry:
822 * - set active entry to next in the ring buffer
826 proceed_active_entry(debug_info_t
* id
)
828 if ((id
->active_entries
[id
->active_area
] += id
->entry_size
)
829 > (PAGE_SIZE
- id
->entry_size
)){
830 id
->active_entries
[id
->active_area
] = 0;
831 id
->active_pages
[id
->active_area
] =
832 (id
->active_pages
[id
->active_area
] + 1) %
838 * proceed_active_area:
839 * - set active area to next in the ring buffer
843 proceed_active_area(debug_info_t
* id
)
846 id
->active_area
= id
->active_area
% id
->nr_areas
;
853 static inline debug_entry_t
*
854 get_active_entry(debug_info_t
* id
)
856 return (debug_entry_t
*) (((char *) id
->areas
[id
->active_area
]
857 [id
->active_pages
[id
->active_area
]]) +
858 id
->active_entries
[id
->active_area
]);
862 * debug_finish_entry:
863 * - set timestamp, caller address, cpu number etc.
867 debug_finish_entry(debug_info_t
* id
, debug_entry_t
* active
, int level
,
870 active
->id
.stck
= get_tod_clock_fast() -
871 *(unsigned long long *) &tod_clock_base
[1];
872 active
->id
.fields
.cpuid
= smp_processor_id();
873 active
->caller
= __builtin_return_address(0);
874 active
->id
.fields
.exception
= exception
;
875 active
->id
.fields
.level
= level
;
876 proceed_active_entry(id
);
878 proceed_active_area(id
);
881 static int debug_stoppable
=1;
882 static int debug_active
=1;
884 #define CTL_S390DBF_STOPPABLE 5678
885 #define CTL_S390DBF_ACTIVE 5679
888 * proc handler for the running debug_active sysctl
889 * always allow read, allow write only if debug_stoppable is set or
890 * if debug_active is already off
893 s390dbf_procactive(struct ctl_table
*table
, int write
,
894 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
896 if (!write
|| debug_stoppable
|| !debug_active
)
897 return proc_dointvec(table
, write
, buffer
, lenp
, ppos
);
903 static struct ctl_table s390dbf_table
[] = {
905 .procname
= "debug_stoppable",
906 .data
= &debug_stoppable
,
907 .maxlen
= sizeof(int),
908 .mode
= S_IRUGO
| S_IWUSR
,
909 .proc_handler
= proc_dointvec
,
912 .procname
= "debug_active",
913 .data
= &debug_active
,
914 .maxlen
= sizeof(int),
915 .mode
= S_IRUGO
| S_IWUSR
,
916 .proc_handler
= s390dbf_procactive
,
921 static struct ctl_table s390dbf_dir_table
[] = {
923 .procname
= "s390dbf",
925 .mode
= S_IRUGO
| S_IXUGO
,
926 .child
= s390dbf_table
,
931 static struct ctl_table_header
*s390dbf_sysctl_header
;
939 EXPORT_SYMBOL(debug_stop_all
);
941 void debug_set_critical(void)
947 * debug_event_common:
948 * - write debug entry with given size
952 debug_event_common(debug_info_t
* id
, int level
, const void *buf
, int len
)
955 debug_entry_t
*active
;
957 if (!debug_active
|| !id
->areas
)
959 if (debug_critical
) {
960 if (!spin_trylock_irqsave(&id
->lock
, flags
))
963 spin_lock_irqsave(&id
->lock
, flags
);
964 active
= get_active_entry(id
);
965 memset(DEBUG_DATA(active
), 0, id
->buf_size
);
966 memcpy(DEBUG_DATA(active
), buf
, min(len
, id
->buf_size
));
967 debug_finish_entry(id
, active
, level
, 0);
968 spin_unlock_irqrestore(&id
->lock
, flags
);
972 EXPORT_SYMBOL(debug_event_common
);
975 * debug_exception_common:
976 * - write debug entry with given size and switch to next debug area
980 *debug_exception_common(debug_info_t
* id
, int level
, const void *buf
, int len
)
983 debug_entry_t
*active
;
985 if (!debug_active
|| !id
->areas
)
987 if (debug_critical
) {
988 if (!spin_trylock_irqsave(&id
->lock
, flags
))
991 spin_lock_irqsave(&id
->lock
, flags
);
992 active
= get_active_entry(id
);
993 memset(DEBUG_DATA(active
), 0, id
->buf_size
);
994 memcpy(DEBUG_DATA(active
), buf
, min(len
, id
->buf_size
));
995 debug_finish_entry(id
, active
, level
, 1);
996 spin_unlock_irqrestore(&id
->lock
, flags
);
1000 EXPORT_SYMBOL(debug_exception_common
);
1003 * counts arguments in format string for sprintf view
1007 debug_count_numargs(char *string
)
1019 * debug_sprintf_event:
1023 __debug_sprintf_event(debug_info_t
*id
, int level
, char *string
, ...)
1027 unsigned long flags
;
1028 debug_sprintf_entry_t
*curr_event
;
1029 debug_entry_t
*active
;
1031 if (!debug_active
|| !id
->areas
)
1033 numargs
=debug_count_numargs(string
);
1035 if (debug_critical
) {
1036 if (!spin_trylock_irqsave(&id
->lock
, flags
))
1039 spin_lock_irqsave(&id
->lock
, flags
);
1040 active
= get_active_entry(id
);
1041 curr_event
=(debug_sprintf_entry_t
*) DEBUG_DATA(active
);
1042 va_start(ap
,string
);
1043 curr_event
->string
=string
;
1044 for(idx
=0;idx
<min(numargs
,(int)(id
->buf_size
/ sizeof(long))-1);idx
++)
1045 curr_event
->args
[idx
]=va_arg(ap
,long);
1047 debug_finish_entry(id
, active
, level
, 0);
1048 spin_unlock_irqrestore(&id
->lock
, flags
);
1052 EXPORT_SYMBOL(__debug_sprintf_event
);
1055 * debug_sprintf_exception:
1059 __debug_sprintf_exception(debug_info_t
*id
, int level
, char *string
, ...)
1063 unsigned long flags
;
1064 debug_sprintf_entry_t
*curr_event
;
1065 debug_entry_t
*active
;
1067 if (!debug_active
|| !id
->areas
)
1070 numargs
=debug_count_numargs(string
);
1072 if (debug_critical
) {
1073 if (!spin_trylock_irqsave(&id
->lock
, flags
))
1076 spin_lock_irqsave(&id
->lock
, flags
);
1077 active
= get_active_entry(id
);
1078 curr_event
=(debug_sprintf_entry_t
*)DEBUG_DATA(active
);
1079 va_start(ap
,string
);
1080 curr_event
->string
=string
;
1081 for(idx
=0;idx
<min(numargs
,(int)(id
->buf_size
/ sizeof(long))-1);idx
++)
1082 curr_event
->args
[idx
]=va_arg(ap
,long);
1084 debug_finish_entry(id
, active
, level
, 1);
1085 spin_unlock_irqrestore(&id
->lock
, flags
);
1089 EXPORT_SYMBOL(__debug_sprintf_exception
);
1092 * debug_register_view:
1096 debug_register_view(debug_info_t
* id
, struct debug_view
*view
)
1100 unsigned long flags
;
1106 mode
= (id
->mode
| S_IFREG
) & ~S_IXUGO
;
1107 if (!(view
->prolog_proc
|| view
->format_proc
|| view
->header_proc
))
1108 mode
&= ~(S_IRUSR
| S_IRGRP
| S_IROTH
);
1109 if (!view
->input_proc
)
1110 mode
&= ~(S_IWUSR
| S_IWGRP
| S_IWOTH
);
1111 pde
= debugfs_create_file(view
->name
, mode
, id
->debugfs_root_entry
,
1112 id
, &debug_file_ops
);
1114 pr_err("Registering view %s/%s failed due to out of "
1115 "memory\n", id
->name
,view
->name
);
1119 spin_lock_irqsave(&id
->lock
, flags
);
1120 for (i
= 0; i
< DEBUG_MAX_VIEWS
; i
++) {
1124 if (i
== DEBUG_MAX_VIEWS
) {
1125 pr_err("Registering view %s/%s would exceed the maximum "
1126 "number of views %i\n", id
->name
, view
->name
, i
);
1129 id
->views
[i
] = view
;
1130 id
->debugfs_entries
[i
] = pde
;
1132 spin_unlock_irqrestore(&id
->lock
, flags
);
1134 debugfs_remove(pde
);
1138 EXPORT_SYMBOL(debug_register_view
);
1141 * debug_unregister_view:
1145 debug_unregister_view(debug_info_t
* id
, struct debug_view
*view
)
1147 struct dentry
*dentry
= NULL
;
1148 unsigned long flags
;
1153 spin_lock_irqsave(&id
->lock
, flags
);
1154 for (i
= 0; i
< DEBUG_MAX_VIEWS
; i
++) {
1155 if (id
->views
[i
] == view
)
1158 if (i
== DEBUG_MAX_VIEWS
)
1161 dentry
= id
->debugfs_entries
[i
];
1162 id
->views
[i
] = NULL
;
1163 id
->debugfs_entries
[i
] = NULL
;
1165 spin_unlock_irqrestore(&id
->lock
, flags
);
1166 debugfs_remove(dentry
);
1170 EXPORT_SYMBOL(debug_unregister_view
);
1172 static inline char *
1173 debug_get_user_string(const char __user
*user_buf
, size_t user_len
)
1177 buffer
= kmalloc(user_len
+ 1, GFP_KERNEL
);
1179 return ERR_PTR(-ENOMEM
);
1180 if (copy_from_user(buffer
, user_buf
, user_len
) != 0) {
1182 return ERR_PTR(-EFAULT
);
1184 /* got the string, now strip linefeed. */
1185 if (buffer
[user_len
- 1] == '\n')
1186 buffer
[user_len
- 1] = 0;
1188 buffer
[user_len
] = 0;
1193 debug_get_uint(char *buf
)
1197 buf
= skip_spaces(buf
);
1198 rc
= simple_strtoul(buf
, &buf
, 10);
1206 * functions for debug-views
1207 ***********************************
1211 * prints out actual debug level
1215 debug_prolog_pages_fn(debug_info_t
* id
,
1216 struct debug_view
*view
, char *out_buf
)
1218 return sprintf(out_buf
, "%i\n", id
->pages_per_area
);
1222 * reads new size (number of pages per debug area)
1226 debug_input_pages_fn(debug_info_t
* id
, struct debug_view
*view
,
1227 struct file
*file
, const char __user
*user_buf
,
1228 size_t user_len
, loff_t
* offset
)
1233 if (user_len
> 0x10000)
1239 str
= debug_get_user_string(user_buf
,user_len
);
1244 new_pages
= debug_get_uint(str
);
1249 rc
= debug_set_size(id
,id
->nr_areas
, new_pages
);
1258 *offset
+= user_len
;
1259 return rc
; /* number of input characters */
1263 * prints out actual debug level
1267 debug_prolog_level_fn(debug_info_t
* id
, struct debug_view
*view
, char *out_buf
)
1271 if(id
->level
== DEBUG_OFF_LEVEL
) {
1272 rc
= sprintf(out_buf
,"-\n");
1275 rc
= sprintf(out_buf
, "%i\n", id
->level
);
1281 * reads new debug level
1285 debug_input_level_fn(debug_info_t
* id
, struct debug_view
*view
,
1286 struct file
*file
, const char __user
*user_buf
,
1287 size_t user_len
, loff_t
* offset
)
1292 if (user_len
> 0x10000)
1298 str
= debug_get_user_string(user_buf
,user_len
);
1304 debug_set_level(id
, DEBUG_OFF_LEVEL
);
1308 new_level
= debug_get_uint(str
);
1311 pr_warn("%s is not a valid level for a debug feature\n", str
);
1314 debug_set_level(id
, new_level
);
1320 *offset
+= user_len
;
1321 return rc
; /* number of input characters */
1326 * flushes debug areas
1329 static void debug_flush(debug_info_t
* id
, int area
)
1331 unsigned long flags
;
1334 if(!id
|| !id
->areas
)
1336 spin_lock_irqsave(&id
->lock
,flags
);
1337 if(area
== DEBUG_FLUSH_ALL
){
1338 id
->active_area
= 0;
1339 memset(id
->active_entries
, 0, id
->nr_areas
* sizeof(int));
1340 for (i
= 0; i
< id
->nr_areas
; i
++) {
1341 id
->active_pages
[i
] = 0;
1342 for(j
= 0; j
< id
->pages_per_area
; j
++) {
1343 memset(id
->areas
[i
][j
], 0, PAGE_SIZE
);
1346 } else if(area
>= 0 && area
< id
->nr_areas
) {
1347 id
->active_entries
[area
] = 0;
1348 id
->active_pages
[area
] = 0;
1349 for(i
= 0; i
< id
->pages_per_area
; i
++) {
1350 memset(id
->areas
[area
][i
],0,PAGE_SIZE
);
1353 spin_unlock_irqrestore(&id
->lock
,flags
);
1357 * view function: flushes debug areas
1361 debug_input_flush_fn(debug_info_t
* id
, struct debug_view
*view
,
1362 struct file
*file
, const char __user
*user_buf
,
1363 size_t user_len
, loff_t
* offset
)
1368 if (user_len
> 0x10000)
1374 if (copy_from_user(input_buf
, user_buf
, 1)){
1378 if(input_buf
[0] == '-') {
1379 debug_flush(id
, DEBUG_FLUSH_ALL
);
1382 if (isdigit(input_buf
[0])) {
1383 int area
= ((int) input_buf
[0] - (int) '0');
1384 debug_flush(id
, area
);
1388 pr_info("Flushing debug data failed because %c is not a valid "
1389 "area\n", input_buf
[0]);
1392 *offset
+= user_len
;
1393 return rc
; /* number of input characters */
1397 * prints debug header in raw format
1401 debug_raw_header_fn(debug_info_t
* id
, struct debug_view
*view
,
1402 int area
, debug_entry_t
* entry
, char *out_buf
)
1406 rc
= sizeof(debug_entry_t
);
1407 memcpy(out_buf
,entry
,sizeof(debug_entry_t
));
1412 * prints debug data in raw format
1416 debug_raw_format_fn(debug_info_t
* id
, struct debug_view
*view
,
1417 char *out_buf
, const char *in_buf
)
1422 memcpy(out_buf
, in_buf
, id
->buf_size
);
1427 * prints debug data in hex/ascii format
1431 debug_hex_ascii_format_fn(debug_info_t
* id
, struct debug_view
*view
,
1432 char *out_buf
, const char *in_buf
)
1436 for (i
= 0; i
< id
->buf_size
; i
++) {
1437 rc
+= sprintf(out_buf
+ rc
, "%02x ",
1438 ((unsigned char *) in_buf
)[i
]);
1440 rc
+= sprintf(out_buf
+ rc
, "| ");
1441 for (i
= 0; i
< id
->buf_size
; i
++) {
1442 unsigned char c
= in_buf
[i
];
1443 if (isascii(c
) && isprint(c
))
1444 rc
+= sprintf(out_buf
+ rc
, "%c", c
);
1446 rc
+= sprintf(out_buf
+ rc
, ".");
1448 rc
+= sprintf(out_buf
+ rc
, "\n");
1453 * prints header for debug entry
1457 debug_dflt_header_fn(debug_info_t
* id
, struct debug_view
*view
,
1458 int area
, debug_entry_t
* entry
, char *out_buf
)
1460 unsigned long base
, sec
, usec
;
1462 unsigned long caller
;
1466 level
= entry
->id
.fields
.level
;
1467 base
= (*(unsigned long *) &tod_clock_base
[0]) >> 4;
1468 sec
= (entry
->id
.stck
>> 12) + base
- (TOD_UNIX_EPOCH
>> 12);
1469 usec
= do_div(sec
, USEC_PER_SEC
);
1471 if (entry
->id
.fields
.exception
)
1475 caller
= (unsigned long) entry
->caller
;
1476 rc
+= sprintf(out_buf
, "%02i %011ld:%06lu %1u %1s %02i %p ",
1477 area
, sec
, usec
, level
, except_str
,
1478 entry
->id
.fields
.cpuid
, (void *)caller
);
1481 EXPORT_SYMBOL(debug_dflt_header_fn
);
1484 * prints debug data sprintf-formated:
1485 * debug_sprinf_event/exception calls must be used together with this view
1488 #define DEBUG_SPRINTF_MAX_ARGS 10
1491 debug_sprintf_format_fn(debug_info_t
* id
, struct debug_view
*view
,
1492 char *out_buf
, debug_sprintf_entry_t
*curr_event
)
1494 int num_longs
, num_used_args
= 0,i
, rc
= 0;
1495 int index
[DEBUG_SPRINTF_MAX_ARGS
];
1497 /* count of longs fit into one entry */
1498 num_longs
= id
->buf_size
/ sizeof(long);
1501 goto out
; /* bufsize of entry too small */
1502 if(num_longs
== 1) {
1503 /* no args, we use only the string */
1504 strcpy(out_buf
, curr_event
->string
);
1505 rc
= strlen(curr_event
->string
);
1509 /* number of arguments used for sprintf (without the format string) */
1510 num_used_args
= min(DEBUG_SPRINTF_MAX_ARGS
, (num_longs
- 1));
1512 memset(index
,0, DEBUG_SPRINTF_MAX_ARGS
* sizeof(int));
1514 for(i
= 0; i
< num_used_args
; i
++)
1517 rc
= sprintf(out_buf
, curr_event
->string
, curr_event
->args
[index
[0]],
1518 curr_event
->args
[index
[1]], curr_event
->args
[index
[2]],
1519 curr_event
->args
[index
[3]], curr_event
->args
[index
[4]],
1520 curr_event
->args
[index
[5]], curr_event
->args
[index
[6]],
1521 curr_event
->args
[index
[7]], curr_event
->args
[index
[8]],
1522 curr_event
->args
[index
[9]]);
1531 * - is called exactly once to initialize the debug feature
1533 static int __init
debug_init(void)
1535 s390dbf_sysctl_header
= register_sysctl_table(s390dbf_dir_table
);
1536 mutex_lock(&debug_mutex
);
1537 debug_debugfs_root_entry
= debugfs_create_dir(DEBUG_DIR_ROOT
, NULL
);
1539 mutex_unlock(&debug_mutex
);
1542 postcore_initcall(debug_init
);