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