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[0];
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, debug_sprintf_entry_t *curr_event);
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_format_proc_t *)&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 
debug_areas_alloc(int pages_per_area,int nr_areas)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(areas);
213 fail_malloc_areas:
214 	return NULL;
215 }
216 
217 /*
218  * debug_info_alloc
219  * - alloc new debug-info
220  */
debug_info_alloc(const char * name,int pages_per_area,int nr_areas,int buf_size,int level,int mode)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  */
debug_areas_free(debug_info_t * db_info)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(db_info->areas[i][j]);
283 		kfree(db_info->areas[i]);
284 	}
285 	kfree(db_info->areas);
286 	db_info->areas = NULL;
287 }
288 
289 /*
290  * debug_info_free
291  * - free memory debug-info
292  */
debug_info_free(debug_info_t * db_info)293 static void debug_info_free(debug_info_t *db_info)
294 {
295 	debug_areas_free(db_info);
296 	kfree(db_info->active_entries);
297 	kfree(db_info->active_pages);
298 	kfree(db_info);
299 }
300 
301 /*
302  * debug_info_create
303  * - create new debug-info
304  */
305 
debug_info_create(const char * name,int pages_per_area,int nr_areas,int buf_size,umode_t mode)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  */
debug_info_copy(debug_info_t * in,int mode)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(&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(&in->lock, flags);
357 	return rc;
358 }
359 
360 /*
361  * debug_info_get
362  * - increments reference count for debug-info
363  */
debug_info_get(debug_info_t * db_info)364 static void debug_info_get(debug_info_t *db_info)
365 {
366 	if (db_info)
367 		refcount_inc(&db_info->ref_count);
368 }
369 
370 /*
371  * debug_info_put:
372  * - decreases reference count for debug-info and frees it if necessary
373  */
debug_info_put(debug_info_t * db_info)374 static void debug_info_put(debug_info_t *db_info)
375 {
376 	if (!db_info)
377 		return;
378 	if (refcount_dec_and_test(&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  */
debug_format_entry(file_private_info_t * p_info)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  */
debug_next_entry(file_private_info_t * p_info)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  */
debug_output(struct file * file,char __user * user_buf,size_t len,loff_t * offset)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(user_buf + count, p_info->temp_buf
482 					 + entry_offset, 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  */
debug_input(struct file * file,const char __user * user_buf,size_t length,loff_t * offset)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(&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  */
debug_open(struct inode * inode,struct file * file)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(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, file);
581 out:
582 	mutex_unlock(&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  */
debug_close(struct inode * inode,struct file * file)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(file->private_data);
600 	return 0; /* success */
601 }
602 
603 /* Create debugfs entries and add to internal list. */
_debug_register(debug_info_t * id)604 static void _debug_register(debug_info_t *id)
605 {
606 	/* create root directory */
607 	id->debugfs_root_entry = debugfs_create_dir(id->name,
608 						    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  */
debug_register_mode(const char * name,int pages_per_area,int nr_areas,int buf_size,umode_t mode,uid_t uid,gid_t gid)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(&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  */
debug_register(const char * name,int pages_per_area,int nr_areas,int buf_size)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  */
debug_register_static(debug_info_t * id,int pages_per_area,int nr_areas)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(&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(&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(&debug_mutex);
748 }
749 
750 /* Remove debugfs entries and remove from internal list. */
_debug_unregister(debug_info_t * id)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(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  */
debug_unregister(debug_info_t * id)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(&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  */
debug_set_size(debug_info_t * id,int nr_areas,int pages_per_area)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(&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  */
debug_set_level(debug_info_t * id,int new_level)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(&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  */
proceed_active_entry(debug_info_t * id)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  */
proceed_active_area(debug_info_t * id)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  */
get_active_entry(debug_info_t * id)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. */
debug_areas_swap(debug_info_t * a,debug_info_t * 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. */
debug_events_append(debug_info_t * dest,debug_info_t * src)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 
debug_finish_entry(debug_info_t * id,debug_entry_t * active,int level,int exception)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  */
s390dbf_procactive(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)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 
984 static struct ctl_table s390dbf_dir_table[] = {
985 	{
986 		.procname	= "s390dbf",
987 		.maxlen		= 0,
988 		.mode		= S_IRUGO | S_IXUGO,
989 		.child		= s390dbf_table,
990 	},
991 	{ }
992 };
993 
994 static struct ctl_table_header *s390dbf_sysctl_header;
995 
996 /**
997  * debug_stop_all() - stops the debug feature if stopping is allowed.
998  *
999  * Return:
1000  * -   none
1001  *
1002  * Currently used in case of a kernel oops.
1003  */
debug_stop_all(void)1004 void debug_stop_all(void)
1005 {
1006 	if (debug_stoppable)
1007 		debug_active = 0;
1008 }
1009 EXPORT_SYMBOL(debug_stop_all);
1010 
1011 /**
1012  * debug_set_critical() - event/exception functions try lock instead of spin.
1013  *
1014  * Return:
1015  * -   none
1016  *
1017  * Currently used in case of stopping all CPUs but the current one.
1018  * Once in this state, functions to write a debug entry for an
1019  * event or exception no longer spin on the debug area lock,
1020  * but only try to get it and fail if they do not get the lock.
1021  */
debug_set_critical(void)1022 void debug_set_critical(void)
1023 {
1024 	debug_critical = 1;
1025 }
1026 
1027 /*
1028  * debug_event_common:
1029  * - write debug entry with given size
1030  */
debug_event_common(debug_info_t * id,int level,const void * buf,int len)1031 debug_entry_t *debug_event_common(debug_info_t *id, int level, const void *buf,
1032 				  int len)
1033 {
1034 	debug_entry_t *active;
1035 	unsigned long flags;
1036 
1037 	if (!debug_active || !id->areas)
1038 		return NULL;
1039 	if (debug_critical) {
1040 		if (!spin_trylock_irqsave(&id->lock, flags))
1041 			return NULL;
1042 	} else {
1043 		spin_lock_irqsave(&id->lock, flags);
1044 	}
1045 	do {
1046 		active = get_active_entry(id);
1047 		memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size));
1048 		if (len < id->buf_size)
1049 			memset((DEBUG_DATA(active)) + len, 0, id->buf_size - len);
1050 		debug_finish_entry(id, active, level, 0);
1051 		len -= id->buf_size;
1052 		buf += id->buf_size;
1053 	} while (len > 0);
1054 
1055 	spin_unlock_irqrestore(&id->lock, flags);
1056 	return active;
1057 }
1058 EXPORT_SYMBOL(debug_event_common);
1059 
1060 /*
1061  * debug_exception_common:
1062  * - write debug entry with given size and switch to next debug area
1063  */
debug_exception_common(debug_info_t * id,int level,const void * buf,int len)1064 debug_entry_t *debug_exception_common(debug_info_t *id, int level,
1065 				      const void *buf, int len)
1066 {
1067 	debug_entry_t *active;
1068 	unsigned long flags;
1069 
1070 	if (!debug_active || !id->areas)
1071 		return NULL;
1072 	if (debug_critical) {
1073 		if (!spin_trylock_irqsave(&id->lock, flags))
1074 			return NULL;
1075 	} else {
1076 		spin_lock_irqsave(&id->lock, flags);
1077 	}
1078 	do {
1079 		active = get_active_entry(id);
1080 		memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size));
1081 		if (len < id->buf_size)
1082 			memset((DEBUG_DATA(active)) + len, 0, id->buf_size - len);
1083 		debug_finish_entry(id, active, level, len <= id->buf_size);
1084 		len -= id->buf_size;
1085 		buf += id->buf_size;
1086 	} while (len > 0);
1087 
1088 	spin_unlock_irqrestore(&id->lock, flags);
1089 	return active;
1090 }
1091 EXPORT_SYMBOL(debug_exception_common);
1092 
1093 /*
1094  * counts arguments in format string for sprintf view
1095  */
debug_count_numargs(char * string)1096 static inline int debug_count_numargs(char *string)
1097 {
1098 	int numargs = 0;
1099 
1100 	while (*string) {
1101 		if (*string++ == '%')
1102 			numargs++;
1103 	}
1104 	return numargs;
1105 }
1106 
1107 /*
1108  * debug_sprintf_event:
1109  */
__debug_sprintf_event(debug_info_t * id,int level,char * string,...)1110 debug_entry_t *__debug_sprintf_event(debug_info_t *id, int level, char *string, ...)
1111 {
1112 	debug_sprintf_entry_t *curr_event;
1113 	debug_entry_t *active;
1114 	unsigned long flags;
1115 	int numargs, idx;
1116 	va_list ap;
1117 
1118 	if (!debug_active || !id->areas)
1119 		return NULL;
1120 	numargs = debug_count_numargs(string);
1121 
1122 	if (debug_critical) {
1123 		if (!spin_trylock_irqsave(&id->lock, flags))
1124 			return NULL;
1125 	} else {
1126 		spin_lock_irqsave(&id->lock, flags);
1127 	}
1128 	active = get_active_entry(id);
1129 	curr_event = (debug_sprintf_entry_t *) DEBUG_DATA(active);
1130 	va_start(ap, string);
1131 	curr_event->string = string;
1132 	for (idx = 0; idx < min(numargs, (int)(id->buf_size / sizeof(long)) - 1); idx++)
1133 		curr_event->args[idx] = va_arg(ap, long);
1134 	va_end(ap);
1135 	debug_finish_entry(id, active, level, 0);
1136 	spin_unlock_irqrestore(&id->lock, flags);
1137 
1138 	return active;
1139 }
1140 EXPORT_SYMBOL(__debug_sprintf_event);
1141 
1142 /*
1143  * debug_sprintf_exception:
1144  */
__debug_sprintf_exception(debug_info_t * id,int level,char * string,...)1145 debug_entry_t *__debug_sprintf_exception(debug_info_t *id, int level, char *string, ...)
1146 {
1147 	debug_sprintf_entry_t *curr_event;
1148 	debug_entry_t *active;
1149 	unsigned long flags;
1150 	int numargs, idx;
1151 	va_list ap;
1152 
1153 	if (!debug_active || !id->areas)
1154 		return NULL;
1155 
1156 	numargs = debug_count_numargs(string);
1157 
1158 	if (debug_critical) {
1159 		if (!spin_trylock_irqsave(&id->lock, flags))
1160 			return NULL;
1161 	} else {
1162 		spin_lock_irqsave(&id->lock, flags);
1163 	}
1164 	active = get_active_entry(id);
1165 	curr_event = (debug_sprintf_entry_t *)DEBUG_DATA(active);
1166 	va_start(ap, string);
1167 	curr_event->string = string;
1168 	for (idx = 0; idx < min(numargs, (int)(id->buf_size / sizeof(long)) - 1); idx++)
1169 		curr_event->args[idx] = va_arg(ap, long);
1170 	va_end(ap);
1171 	debug_finish_entry(id, active, level, 1);
1172 	spin_unlock_irqrestore(&id->lock, flags);
1173 
1174 	return active;
1175 }
1176 EXPORT_SYMBOL(__debug_sprintf_exception);
1177 
1178 /**
1179  * debug_register_view() - registers new debug view and creates debugfs
1180  *			   dir entry
1181  *
1182  * @id:		handle for debug log
1183  * @view:	pointer to debug view struct
1184  *
1185  * Return:
1186  * -   0  : ok
1187  * -   < 0: Error
1188  */
debug_register_view(debug_info_t * id,struct debug_view * view)1189 int debug_register_view(debug_info_t *id, struct debug_view *view)
1190 {
1191 	unsigned long flags;
1192 	struct dentry *pde;
1193 	umode_t mode;
1194 	int rc = 0;
1195 	int i;
1196 
1197 	if (!id)
1198 		goto out;
1199 	mode = (id->mode | S_IFREG) & ~S_IXUGO;
1200 	if (!(view->prolog_proc || view->format_proc || view->header_proc))
1201 		mode &= ~(S_IRUSR | S_IRGRP | S_IROTH);
1202 	if (!view->input_proc)
1203 		mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
1204 	pde = debugfs_create_file(view->name, mode, id->debugfs_root_entry,
1205 				  id, &debug_file_ops);
1206 	spin_lock_irqsave(&id->lock, flags);
1207 	for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
1208 		if (!id->views[i])
1209 			break;
1210 	}
1211 	if (i == DEBUG_MAX_VIEWS) {
1212 		rc = -1;
1213 	} else {
1214 		id->views[i] = view;
1215 		id->debugfs_entries[i] = pde;
1216 	}
1217 	spin_unlock_irqrestore(&id->lock, flags);
1218 	if (rc) {
1219 		pr_err("Registering view %s/%s would exceed the maximum "
1220 		       "number of views %i\n", id->name, view->name, i);
1221 		debugfs_remove(pde);
1222 	}
1223 out:
1224 	return rc;
1225 }
1226 EXPORT_SYMBOL(debug_register_view);
1227 
1228 /**
1229  * debug_unregister_view() - unregisters debug view and removes debugfs
1230  *			     dir entry
1231  *
1232  * @id:		handle for debug log
1233  * @view:	pointer to debug view struct
1234  *
1235  * Return:
1236  * -   0  : ok
1237  * -   < 0: Error
1238  */
debug_unregister_view(debug_info_t * id,struct debug_view * view)1239 int debug_unregister_view(debug_info_t *id, struct debug_view *view)
1240 {
1241 	struct dentry *dentry = NULL;
1242 	unsigned long flags;
1243 	int i, rc = 0;
1244 
1245 	if (!id)
1246 		goto out;
1247 	spin_lock_irqsave(&id->lock, flags);
1248 	for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
1249 		if (id->views[i] == view)
1250 			break;
1251 	}
1252 	if (i == DEBUG_MAX_VIEWS) {
1253 		rc = -1;
1254 	} else {
1255 		dentry = id->debugfs_entries[i];
1256 		id->views[i] = NULL;
1257 		id->debugfs_entries[i] = NULL;
1258 	}
1259 	spin_unlock_irqrestore(&id->lock, flags);
1260 	debugfs_remove(dentry);
1261 out:
1262 	return rc;
1263 }
1264 EXPORT_SYMBOL(debug_unregister_view);
1265 
debug_get_user_string(const char __user * user_buf,size_t user_len)1266 static inline char *debug_get_user_string(const char __user *user_buf,
1267 					  size_t user_len)
1268 {
1269 	char *buffer;
1270 
1271 	buffer = kmalloc(user_len + 1, GFP_KERNEL);
1272 	if (!buffer)
1273 		return ERR_PTR(-ENOMEM);
1274 	if (copy_from_user(buffer, user_buf, user_len) != 0) {
1275 		kfree(buffer);
1276 		return ERR_PTR(-EFAULT);
1277 	}
1278 	/* got the string, now strip linefeed. */
1279 	if (buffer[user_len - 1] == '\n')
1280 		buffer[user_len - 1] = 0;
1281 	else
1282 		buffer[user_len] = 0;
1283 	return buffer;
1284 }
1285 
debug_get_uint(char * buf)1286 static inline int debug_get_uint(char *buf)
1287 {
1288 	int rc;
1289 
1290 	buf = skip_spaces(buf);
1291 	rc = simple_strtoul(buf, &buf, 10);
1292 	if (*buf)
1293 		rc = -EINVAL;
1294 	return rc;
1295 }
1296 
1297 /*
1298  * functions for debug-views
1299  ***********************************
1300 */
1301 
1302 /*
1303  * prints out actual debug level
1304  */
1305 
debug_prolog_pages_fn(debug_info_t * id,struct debug_view * view,char * out_buf)1306 static int debug_prolog_pages_fn(debug_info_t *id, struct debug_view *view,
1307 				 char *out_buf)
1308 {
1309 	return sprintf(out_buf, "%i\n", id->pages_per_area);
1310 }
1311 
1312 /*
1313  * reads new size (number of pages per debug area)
1314  */
1315 
debug_input_pages_fn(debug_info_t * id,struct debug_view * view,struct file * file,const char __user * user_buf,size_t user_len,loff_t * offset)1316 static int debug_input_pages_fn(debug_info_t *id, struct debug_view *view,
1317 				struct file *file, const char __user *user_buf,
1318 				size_t user_len, loff_t *offset)
1319 {
1320 	int rc, new_pages;
1321 	char *str;
1322 
1323 	if (user_len > 0x10000)
1324 		user_len = 0x10000;
1325 	if (*offset != 0) {
1326 		rc = -EPIPE;
1327 		goto out;
1328 	}
1329 	str = debug_get_user_string(user_buf, user_len);
1330 	if (IS_ERR(str)) {
1331 		rc = PTR_ERR(str);
1332 		goto out;
1333 	}
1334 	new_pages = debug_get_uint(str);
1335 	if (new_pages < 0) {
1336 		rc = -EINVAL;
1337 		goto free_str;
1338 	}
1339 	rc = debug_set_size(id, id->nr_areas, new_pages);
1340 	if (rc != 0) {
1341 		rc = -EINVAL;
1342 		goto free_str;
1343 	}
1344 	rc = user_len;
1345 free_str:
1346 	kfree(str);
1347 out:
1348 	*offset += user_len;
1349 	return rc;		/* number of input characters */
1350 }
1351 
1352 /*
1353  * prints out actual debug level
1354  */
debug_prolog_level_fn(debug_info_t * id,struct debug_view * view,char * out_buf)1355 static int debug_prolog_level_fn(debug_info_t *id, struct debug_view *view,
1356 				 char *out_buf)
1357 {
1358 	int rc = 0;
1359 
1360 	if (id->level == DEBUG_OFF_LEVEL)
1361 		rc = sprintf(out_buf, "-\n");
1362 	else
1363 		rc = sprintf(out_buf, "%i\n", id->level);
1364 	return rc;
1365 }
1366 
1367 /*
1368  * reads new debug level
1369  */
debug_input_level_fn(debug_info_t * id,struct debug_view * view,struct file * file,const char __user * user_buf,size_t user_len,loff_t * offset)1370 static int debug_input_level_fn(debug_info_t *id, struct debug_view *view,
1371 				struct file *file, const char __user *user_buf,
1372 				size_t user_len, loff_t *offset)
1373 {
1374 	int rc, new_level;
1375 	char *str;
1376 
1377 	if (user_len > 0x10000)
1378 		user_len = 0x10000;
1379 	if (*offset != 0) {
1380 		rc = -EPIPE;
1381 		goto out;
1382 	}
1383 	str = debug_get_user_string(user_buf, user_len);
1384 	if (IS_ERR(str)) {
1385 		rc = PTR_ERR(str);
1386 		goto out;
1387 	}
1388 	if (str[0] == '-') {
1389 		debug_set_level(id, DEBUG_OFF_LEVEL);
1390 		rc = user_len;
1391 		goto free_str;
1392 	} else {
1393 		new_level = debug_get_uint(str);
1394 	}
1395 	if (new_level < 0) {
1396 		pr_warn("%s is not a valid level for a debug feature\n", str);
1397 		rc = -EINVAL;
1398 	} else {
1399 		debug_set_level(id, new_level);
1400 		rc = user_len;
1401 	}
1402 free_str:
1403 	kfree(str);
1404 out:
1405 	*offset += user_len;
1406 	return rc;		/* number of input characters */
1407 }
1408 
1409 /*
1410  * flushes debug areas
1411  */
debug_flush(debug_info_t * id,int area)1412 static void debug_flush(debug_info_t *id, int area)
1413 {
1414 	unsigned long flags;
1415 	int i, j;
1416 
1417 	if (!id || !id->areas)
1418 		return;
1419 	spin_lock_irqsave(&id->lock, flags);
1420 	if (area == DEBUG_FLUSH_ALL) {
1421 		id->active_area = 0;
1422 		memset(id->active_entries, 0, id->nr_areas * sizeof(int));
1423 		for (i = 0; i < id->nr_areas; i++) {
1424 			id->active_pages[i] = 0;
1425 			for (j = 0; j < id->pages_per_area; j++)
1426 				memset(id->areas[i][j], 0, PAGE_SIZE);
1427 		}
1428 	} else if (area >= 0 && area < id->nr_areas) {
1429 		id->active_entries[area] = 0;
1430 		id->active_pages[area] = 0;
1431 		for (i = 0; i < id->pages_per_area; i++)
1432 			memset(id->areas[area][i], 0, PAGE_SIZE);
1433 	}
1434 	spin_unlock_irqrestore(&id->lock, flags);
1435 }
1436 
1437 /*
1438  * view function: flushes debug areas
1439  */
debug_input_flush_fn(debug_info_t * id,struct debug_view * view,struct file * file,const char __user * user_buf,size_t user_len,loff_t * offset)1440 static int debug_input_flush_fn(debug_info_t *id, struct debug_view *view,
1441 				struct file *file, const char __user *user_buf,
1442 				size_t user_len, loff_t *offset)
1443 {
1444 	char input_buf[1];
1445 	int rc = user_len;
1446 
1447 	if (user_len > 0x10000)
1448 		user_len = 0x10000;
1449 	if (*offset != 0) {
1450 		rc = -EPIPE;
1451 		goto out;
1452 	}
1453 	if (copy_from_user(input_buf, user_buf, 1)) {
1454 		rc = -EFAULT;
1455 		goto out;
1456 	}
1457 	if (input_buf[0] == '-') {
1458 		debug_flush(id, DEBUG_FLUSH_ALL);
1459 		goto out;
1460 	}
1461 	if (isdigit(input_buf[0])) {
1462 		int area = ((int) input_buf[0] - (int) '0');
1463 
1464 		debug_flush(id, area);
1465 		goto out;
1466 	}
1467 
1468 	pr_info("Flushing debug data failed because %c is not a valid "
1469 		 "area\n", input_buf[0]);
1470 
1471 out:
1472 	*offset += user_len;
1473 	return rc;		/* number of input characters */
1474 }
1475 
1476 /*
1477  * prints debug data in hex/ascii format
1478  */
debug_hex_ascii_format_fn(debug_info_t * id,struct debug_view * view,char * out_buf,const char * in_buf)1479 static int debug_hex_ascii_format_fn(debug_info_t *id, struct debug_view *view,
1480 				     char *out_buf, const char *in_buf)
1481 {
1482 	int i, rc = 0;
1483 
1484 	for (i = 0; i < id->buf_size; i++)
1485 		rc += sprintf(out_buf + rc, "%02x ", ((unsigned char *) in_buf)[i]);
1486 	rc += sprintf(out_buf + rc, "| ");
1487 	for (i = 0; i < id->buf_size; i++) {
1488 		unsigned char c = in_buf[i];
1489 
1490 		if (isascii(c) && isprint(c))
1491 			rc += sprintf(out_buf + rc, "%c", c);
1492 		else
1493 			rc += sprintf(out_buf + rc, ".");
1494 	}
1495 	rc += sprintf(out_buf + rc, "\n");
1496 	return rc;
1497 }
1498 
1499 /*
1500  * prints header for debug entry
1501  */
debug_dflt_header_fn(debug_info_t * id,struct debug_view * view,int area,debug_entry_t * entry,char * out_buf)1502 int debug_dflt_header_fn(debug_info_t *id, struct debug_view *view,
1503 			 int area, debug_entry_t *entry, char *out_buf)
1504 {
1505 	unsigned long sec, usec;
1506 	unsigned long caller;
1507 	unsigned int level;
1508 	char *except_str;
1509 	int rc = 0;
1510 
1511 	level = entry->level;
1512 	sec = entry->clock;
1513 	usec = do_div(sec, USEC_PER_SEC);
1514 
1515 	if (entry->exception)
1516 		except_str = "*";
1517 	else
1518 		except_str = "-";
1519 	caller = (unsigned long) entry->caller;
1520 	rc += sprintf(out_buf, "%02i %011ld:%06lu %1u %1s %04u %px  ",
1521 		      area, sec, usec, level, except_str,
1522 		      entry->cpu, (void *)caller);
1523 	return rc;
1524 }
1525 EXPORT_SYMBOL(debug_dflt_header_fn);
1526 
1527 /*
1528  * prints debug data sprintf-formated:
1529  * debug_sprinf_event/exception calls must be used together with this view
1530  */
1531 
1532 #define DEBUG_SPRINTF_MAX_ARGS 10
1533 
debug_sprintf_format_fn(debug_info_t * id,struct debug_view * view,char * out_buf,debug_sprintf_entry_t * curr_event)1534 static int debug_sprintf_format_fn(debug_info_t *id, struct debug_view *view,
1535 				   char *out_buf, debug_sprintf_entry_t *curr_event)
1536 {
1537 	int num_longs, num_used_args = 0, i, rc = 0;
1538 	int index[DEBUG_SPRINTF_MAX_ARGS];
1539 
1540 	/* count of longs fit into one entry */
1541 	num_longs = id->buf_size / sizeof(long);
1542 
1543 	if (num_longs < 1)
1544 		goto out; /* bufsize of entry too small */
1545 	if (num_longs == 1) {
1546 		/* no args, we use only the string */
1547 		strcpy(out_buf, curr_event->string);
1548 		rc = strlen(curr_event->string);
1549 		goto out;
1550 	}
1551 
1552 	/* number of arguments used for sprintf (without the format string) */
1553 	num_used_args = min(DEBUG_SPRINTF_MAX_ARGS, (num_longs - 1));
1554 
1555 	memset(index, 0, DEBUG_SPRINTF_MAX_ARGS * sizeof(int));
1556 
1557 	for (i = 0; i < num_used_args; i++)
1558 		index[i] = i;
1559 
1560 	rc = sprintf(out_buf, curr_event->string, curr_event->args[index[0]],
1561 		     curr_event->args[index[1]], curr_event->args[index[2]],
1562 		     curr_event->args[index[3]], curr_event->args[index[4]],
1563 		     curr_event->args[index[5]], curr_event->args[index[6]],
1564 		     curr_event->args[index[7]], curr_event->args[index[8]],
1565 		     curr_event->args[index[9]]);
1566 out:
1567 	return rc;
1568 }
1569 
1570 /*
1571  * debug_init:
1572  * - is called exactly once to initialize the debug feature
1573  */
debug_init(void)1574 static int __init debug_init(void)
1575 {
1576 	s390dbf_sysctl_header = register_sysctl_table(s390dbf_dir_table);
1577 	mutex_lock(&debug_mutex);
1578 	debug_debugfs_root_entry = debugfs_create_dir(DEBUG_DIR_ROOT, NULL);
1579 	initialized = 1;
1580 	mutex_unlock(&debug_mutex);
1581 	return 0;
1582 }
1583 postcore_initcall(debug_init);
1584