1 /*
2  * Kernel Debugger Architecture Independent Support Functions
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file "COPYING" in the main directory of this archive
6  * for more details.
7  *
8  * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
9  * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
10  * 03/02/13    added new 2.5 kallsyms <xavier.bru@bull.net>
11  */
12 
13 #include <linux/types.h>
14 #include <linux/sched.h>
15 #include <linux/mm.h>
16 #include <linux/kallsyms.h>
17 #include <linux/stddef.h>
18 #include <linux/vmalloc.h>
19 #include <linux/ptrace.h>
20 #include <linux/highmem.h>
21 #include <linux/hardirq.h>
22 #include <linux/delay.h>
23 #include <linux/uaccess.h>
24 #include <linux/kdb.h>
25 #include <linux/slab.h>
26 #include <linux/ctype.h>
27 #include "kdb_private.h"
28 
29 /*
30  * kdbgetsymval - Return the address of the given symbol.
31  *
32  * Parameters:
33  *	symname	Character string containing symbol name
34  *      symtab  Structure to receive results
35  * Returns:
36  *	0	Symbol not found, symtab zero filled
37  *	1	Symbol mapped to module/symbol/section, data in symtab
38  */
kdbgetsymval(const char * symname,kdb_symtab_t * symtab)39 int kdbgetsymval(const char *symname, kdb_symtab_t *symtab)
40 {
41 	kdb_dbg_printf(AR, "symname=%s, symtab=%px\n", symname, symtab);
42 	memset(symtab, 0, sizeof(*symtab));
43 	symtab->sym_start = kallsyms_lookup_name(symname);
44 	if (symtab->sym_start) {
45 		kdb_dbg_printf(AR, "returns 1, symtab->sym_start=0x%lx\n",
46 			       symtab->sym_start);
47 		return 1;
48 	}
49 	kdb_dbg_printf(AR, "returns 0\n");
50 	return 0;
51 }
52 EXPORT_SYMBOL(kdbgetsymval);
53 
54 /**
55  * kdbnearsym() - Return the name of the symbol with the nearest address
56  *                less than @addr.
57  * @addr: Address to check for near symbol
58  * @symtab: Structure to receive results
59  *
60  * WARNING: This function may return a pointer to a single statically
61  * allocated buffer (namebuf). kdb's unusual calling context (single
62  * threaded, all other CPUs halted) provides us sufficient locking for
63  * this to be safe. The only constraint imposed by the static buffer is
64  * that the caller must consume any previous reply prior to another call
65  * to lookup a new symbol.
66  *
67  * Note that, strictly speaking, some architectures may re-enter the kdb
68  * trap if the system turns out to be very badly damaged and this breaks
69  * the single-threaded assumption above. In these circumstances successful
70  * continuation and exit from the inner trap is unlikely to work and any
71  * user attempting this receives a prominent warning before being allowed
72  * to progress. In these circumstances we remain memory safe because
73  * namebuf[KSYM_NAME_LEN-1] will never change from '\0' although we do
74  * tolerate the possibility of garbled symbol display from the outer kdb
75  * trap.
76  *
77  * Return:
78  * * 0 - No sections contain this address, symtab zero filled
79  * * 1 - Address mapped to module/symbol/section, data in symtab
80  */
kdbnearsym(unsigned long addr,kdb_symtab_t * symtab)81 int kdbnearsym(unsigned long addr, kdb_symtab_t *symtab)
82 {
83 	int ret = 0;
84 	unsigned long symbolsize = 0;
85 	unsigned long offset = 0;
86 	static char namebuf[KSYM_NAME_LEN];
87 
88 	kdb_dbg_printf(AR, "addr=0x%lx, symtab=%px\n", addr, symtab);
89 	memset(symtab, 0, sizeof(*symtab));
90 
91 	if (addr < 4096)
92 		goto out;
93 
94 	symtab->sym_name = kallsyms_lookup(addr, &symbolsize , &offset,
95 				(char **)(&symtab->mod_name), namebuf);
96 	if (offset > 8*1024*1024) {
97 		symtab->sym_name = NULL;
98 		addr = offset = symbolsize = 0;
99 	}
100 	symtab->sym_start = addr - offset;
101 	symtab->sym_end = symtab->sym_start + symbolsize;
102 	ret = symtab->sym_name != NULL && *(symtab->sym_name) != '\0';
103 
104 	if (symtab->mod_name == NULL)
105 		symtab->mod_name = "kernel";
106 	kdb_dbg_printf(AR, "returns %d symtab->sym_start=0x%lx, symtab->mod_name=%px, symtab->sym_name=%px (%s)\n",
107 		       ret, symtab->sym_start, symtab->mod_name, symtab->sym_name, symtab->sym_name);
108 out:
109 	return ret;
110 }
111 
112 static char ks_namebuf[KSYM_NAME_LEN+1], ks_namebuf_prev[KSYM_NAME_LEN+1];
113 
114 /*
115  * kallsyms_symbol_complete
116  *
117  * Parameters:
118  *	prefix_name	prefix of a symbol name to lookup
119  *	max_len		maximum length that can be returned
120  * Returns:
121  *	Number of symbols which match the given prefix.
122  * Notes:
123  *	prefix_name is changed to contain the longest unique prefix that
124  *	starts with this prefix (tab completion).
125  */
kallsyms_symbol_complete(char * prefix_name,int max_len)126 int kallsyms_symbol_complete(char *prefix_name, int max_len)
127 {
128 	loff_t pos = 0;
129 	int prefix_len = strlen(prefix_name), prev_len = 0;
130 	int i, number = 0;
131 	const char *name;
132 
133 	while ((name = kdb_walk_kallsyms(&pos))) {
134 		if (strncmp(name, prefix_name, prefix_len) == 0) {
135 			strscpy(ks_namebuf, name, sizeof(ks_namebuf));
136 			/* Work out the longest name that matches the prefix */
137 			if (++number == 1) {
138 				prev_len = min_t(int, max_len-1,
139 						 strlen(ks_namebuf));
140 				memcpy(ks_namebuf_prev, ks_namebuf, prev_len);
141 				ks_namebuf_prev[prev_len] = '\0';
142 				continue;
143 			}
144 			for (i = 0; i < prev_len; i++) {
145 				if (ks_namebuf[i] != ks_namebuf_prev[i]) {
146 					prev_len = i;
147 					ks_namebuf_prev[i] = '\0';
148 					break;
149 				}
150 			}
151 		}
152 	}
153 	if (prev_len > prefix_len)
154 		memcpy(prefix_name, ks_namebuf_prev, prev_len+1);
155 	return number;
156 }
157 
158 /*
159  * kallsyms_symbol_next
160  *
161  * Parameters:
162  *	prefix_name	prefix of a symbol name to lookup
163  *	flag	0 means search from the head, 1 means continue search.
164  *	buf_size	maximum length that can be written to prefix_name
165  *			buffer
166  * Returns:
167  *	1 if a symbol matches the given prefix.
168  *	0 if no string found
169  */
kallsyms_symbol_next(char * prefix_name,int flag,int buf_size)170 int kallsyms_symbol_next(char *prefix_name, int flag, int buf_size)
171 {
172 	int prefix_len = strlen(prefix_name);
173 	static loff_t pos;
174 	const char *name;
175 
176 	if (!flag)
177 		pos = 0;
178 
179 	while ((name = kdb_walk_kallsyms(&pos))) {
180 		if (!strncmp(name, prefix_name, prefix_len))
181 			return strscpy(prefix_name, name, buf_size);
182 	}
183 	return 0;
184 }
185 
186 /*
187  * kdb_symbol_print - Standard method for printing a symbol name and offset.
188  * Inputs:
189  *	addr	Address to be printed.
190  *	symtab	Address of symbol data, if NULL this routine does its
191  *		own lookup.
192  *	punc	Punctuation for string, bit field.
193  * Remarks:
194  *	The string and its punctuation is only printed if the address
195  *	is inside the kernel, except that the value is always printed
196  *	when requested.
197  */
kdb_symbol_print(unsigned long addr,const kdb_symtab_t * symtab_p,unsigned int punc)198 void kdb_symbol_print(unsigned long addr, const kdb_symtab_t *symtab_p,
199 		      unsigned int punc)
200 {
201 	kdb_symtab_t symtab, *symtab_p2;
202 	if (symtab_p) {
203 		symtab_p2 = (kdb_symtab_t *)symtab_p;
204 	} else {
205 		symtab_p2 = &symtab;
206 		kdbnearsym(addr, symtab_p2);
207 	}
208 	if (!(symtab_p2->sym_name || (punc & KDB_SP_VALUE)))
209 		return;
210 	if (punc & KDB_SP_SPACEB)
211 		kdb_printf(" ");
212 	if (punc & KDB_SP_VALUE)
213 		kdb_printf(kdb_machreg_fmt0, addr);
214 	if (symtab_p2->sym_name) {
215 		if (punc & KDB_SP_VALUE)
216 			kdb_printf(" ");
217 		if (punc & KDB_SP_PAREN)
218 			kdb_printf("(");
219 		if (strcmp(symtab_p2->mod_name, "kernel"))
220 			kdb_printf("[%s]", symtab_p2->mod_name);
221 		kdb_printf("%s", symtab_p2->sym_name);
222 		if (addr != symtab_p2->sym_start)
223 			kdb_printf("+0x%lx", addr - symtab_p2->sym_start);
224 		if (punc & KDB_SP_SYMSIZE)
225 			kdb_printf("/0x%lx",
226 				   symtab_p2->sym_end - symtab_p2->sym_start);
227 		if (punc & KDB_SP_PAREN)
228 			kdb_printf(")");
229 	}
230 	if (punc & KDB_SP_SPACEA)
231 		kdb_printf(" ");
232 	if (punc & KDB_SP_NEWLINE)
233 		kdb_printf("\n");
234 }
235 
236 /*
237  * kdb_strdup - kdb equivalent of strdup, for disasm code.
238  * Inputs:
239  *	str	The string to duplicate.
240  *	type	Flags to kmalloc for the new string.
241  * Returns:
242  *	Address of the new string, NULL if storage could not be allocated.
243  * Remarks:
244  *	This is not in lib/string.c because it uses kmalloc which is not
245  *	available when string.o is used in boot loaders.
246  */
kdb_strdup(const char * str,gfp_t type)247 char *kdb_strdup(const char *str, gfp_t type)
248 {
249 	int n = strlen(str)+1;
250 	char *s = kmalloc(n, type);
251 	if (!s)
252 		return NULL;
253 	return strcpy(s, str);
254 }
255 
256 /*
257  * kdb_getarea_size - Read an area of data.  The kdb equivalent of
258  *	copy_from_user, with kdb messages for invalid addresses.
259  * Inputs:
260  *	res	Pointer to the area to receive the result.
261  *	addr	Address of the area to copy.
262  *	size	Size of the area.
263  * Returns:
264  *	0 for success, < 0 for error.
265  */
kdb_getarea_size(void * res,unsigned long addr,size_t size)266 int kdb_getarea_size(void *res, unsigned long addr, size_t size)
267 {
268 	int ret = copy_from_kernel_nofault((char *)res, (char *)addr, size);
269 	if (ret) {
270 		if (!KDB_STATE(SUPPRESS)) {
271 			kdb_func_printf("Bad address 0x%lx\n", addr);
272 			KDB_STATE_SET(SUPPRESS);
273 		}
274 		ret = KDB_BADADDR;
275 	} else {
276 		KDB_STATE_CLEAR(SUPPRESS);
277 	}
278 	return ret;
279 }
280 
281 /*
282  * kdb_putarea_size - Write an area of data.  The kdb equivalent of
283  *	copy_to_user, with kdb messages for invalid addresses.
284  * Inputs:
285  *	addr	Address of the area to write to.
286  *	res	Pointer to the area holding the data.
287  *	size	Size of the area.
288  * Returns:
289  *	0 for success, < 0 for error.
290  */
kdb_putarea_size(unsigned long addr,void * res,size_t size)291 int kdb_putarea_size(unsigned long addr, void *res, size_t size)
292 {
293 	int ret = copy_to_kernel_nofault((char *)addr, (char *)res, size);
294 	if (ret) {
295 		if (!KDB_STATE(SUPPRESS)) {
296 			kdb_func_printf("Bad address 0x%lx\n", addr);
297 			KDB_STATE_SET(SUPPRESS);
298 		}
299 		ret = KDB_BADADDR;
300 	} else {
301 		KDB_STATE_CLEAR(SUPPRESS);
302 	}
303 	return ret;
304 }
305 
306 /*
307  * kdb_getphys - Read data from a physical address. Validate the
308  * 	address is in range, use kmap_atomic() to get data
309  * 	similar to kdb_getarea() - but for phys addresses
310  * Inputs:
311  * 	res	Pointer to the word to receive the result
312  * 	addr	Physical address of the area to copy
313  * 	size	Size of the area
314  * Returns:
315  *	0 for success, < 0 for error.
316  */
kdb_getphys(void * res,unsigned long addr,size_t size)317 static int kdb_getphys(void *res, unsigned long addr, size_t size)
318 {
319 	unsigned long pfn;
320 	void *vaddr;
321 	struct page *page;
322 
323 	pfn = (addr >> PAGE_SHIFT);
324 	if (!pfn_valid(pfn))
325 		return 1;
326 	page = pfn_to_page(pfn);
327 	vaddr = kmap_atomic(page);
328 	memcpy(res, vaddr + (addr & (PAGE_SIZE - 1)), size);
329 	kunmap_atomic(vaddr);
330 
331 	return 0;
332 }
333 
334 /*
335  * kdb_getphysword
336  * Inputs:
337  *	word	Pointer to the word to receive the result.
338  *	addr	Address of the area to copy.
339  *	size	Size of the area.
340  * Returns:
341  *	0 for success, < 0 for error.
342  */
kdb_getphysword(unsigned long * word,unsigned long addr,size_t size)343 int kdb_getphysword(unsigned long *word, unsigned long addr, size_t size)
344 {
345 	int diag;
346 	__u8  w1;
347 	__u16 w2;
348 	__u32 w4;
349 	__u64 w8;
350 	*word = 0;	/* Default value if addr or size is invalid */
351 
352 	switch (size) {
353 	case 1:
354 		diag = kdb_getphys(&w1, addr, sizeof(w1));
355 		if (!diag)
356 			*word = w1;
357 		break;
358 	case 2:
359 		diag = kdb_getphys(&w2, addr, sizeof(w2));
360 		if (!diag)
361 			*word = w2;
362 		break;
363 	case 4:
364 		diag = kdb_getphys(&w4, addr, sizeof(w4));
365 		if (!diag)
366 			*word = w4;
367 		break;
368 	case 8:
369 		if (size <= sizeof(*word)) {
370 			diag = kdb_getphys(&w8, addr, sizeof(w8));
371 			if (!diag)
372 				*word = w8;
373 			break;
374 		}
375 		fallthrough;
376 	default:
377 		diag = KDB_BADWIDTH;
378 		kdb_func_printf("bad width %zu\n", size);
379 	}
380 	return diag;
381 }
382 
383 /*
384  * kdb_getword - Read a binary value.  Unlike kdb_getarea, this treats
385  *	data as numbers.
386  * Inputs:
387  *	word	Pointer to the word to receive the result.
388  *	addr	Address of the area to copy.
389  *	size	Size of the area.
390  * Returns:
391  *	0 for success, < 0 for error.
392  */
kdb_getword(unsigned long * word,unsigned long addr,size_t size)393 int kdb_getword(unsigned long *word, unsigned long addr, size_t size)
394 {
395 	int diag;
396 	__u8  w1;
397 	__u16 w2;
398 	__u32 w4;
399 	__u64 w8;
400 	*word = 0;	/* Default value if addr or size is invalid */
401 	switch (size) {
402 	case 1:
403 		diag = kdb_getarea(w1, addr);
404 		if (!diag)
405 			*word = w1;
406 		break;
407 	case 2:
408 		diag = kdb_getarea(w2, addr);
409 		if (!diag)
410 			*word = w2;
411 		break;
412 	case 4:
413 		diag = kdb_getarea(w4, addr);
414 		if (!diag)
415 			*word = w4;
416 		break;
417 	case 8:
418 		if (size <= sizeof(*word)) {
419 			diag = kdb_getarea(w8, addr);
420 			if (!diag)
421 				*word = w8;
422 			break;
423 		}
424 		fallthrough;
425 	default:
426 		diag = KDB_BADWIDTH;
427 		kdb_func_printf("bad width %zu\n", size);
428 	}
429 	return diag;
430 }
431 
432 /*
433  * kdb_putword - Write a binary value.  Unlike kdb_putarea, this
434  *	treats data as numbers.
435  * Inputs:
436  *	addr	Address of the area to write to..
437  *	word	The value to set.
438  *	size	Size of the area.
439  * Returns:
440  *	0 for success, < 0 for error.
441  */
kdb_putword(unsigned long addr,unsigned long word,size_t size)442 int kdb_putword(unsigned long addr, unsigned long word, size_t size)
443 {
444 	int diag;
445 	__u8  w1;
446 	__u16 w2;
447 	__u32 w4;
448 	__u64 w8;
449 	switch (size) {
450 	case 1:
451 		w1 = word;
452 		diag = kdb_putarea(addr, w1);
453 		break;
454 	case 2:
455 		w2 = word;
456 		diag = kdb_putarea(addr, w2);
457 		break;
458 	case 4:
459 		w4 = word;
460 		diag = kdb_putarea(addr, w4);
461 		break;
462 	case 8:
463 		if (size <= sizeof(word)) {
464 			w8 = word;
465 			diag = kdb_putarea(addr, w8);
466 			break;
467 		}
468 		fallthrough;
469 	default:
470 		diag = KDB_BADWIDTH;
471 		kdb_func_printf("bad width %zu\n", size);
472 	}
473 	return diag;
474 }
475 
476 
477 
478 /*
479  * kdb_task_state_char - Return the character that represents the task state.
480  * Inputs:
481  *	p	struct task for the process
482  * Returns:
483  *	One character to represent the task state.
484  */
kdb_task_state_char(const struct task_struct * p)485 char kdb_task_state_char (const struct task_struct *p)
486 {
487 	unsigned long tmp;
488 	char state;
489 	int cpu;
490 
491 	if (!p ||
492 	    copy_from_kernel_nofault(&tmp, (char *)p, sizeof(unsigned long)))
493 		return 'E';
494 
495 	state = task_state_to_char((struct task_struct *) p);
496 
497 	if (is_idle_task(p)) {
498 		/* Idle task.  Is it really idle, apart from the kdb
499 		 * interrupt? */
500 		cpu = kdb_process_cpu(p);
501 		if (!kdb_task_has_cpu(p) || kgdb_info[cpu].irq_depth == 1) {
502 			if (cpu != kdb_initial_cpu)
503 				state = '-';	/* idle task */
504 		}
505 	} else if (!p->mm && strchr("IMS", state)) {
506 		state = tolower(state);		/* sleeping system daemon */
507 	}
508 	return state;
509 }
510 
511 /*
512  * kdb_task_state - Return true if a process has the desired state
513  *	given by the mask.
514  * Inputs:
515  *	p	struct task for the process
516  *	mask	set of characters used to select processes; both NULL
517  *	        and the empty string mean adopt a default filter, which
518  *	        is to suppress sleeping system daemons and the idle tasks
519  * Returns:
520  *	True if the process matches at least one criteria defined by the mask.
521  */
kdb_task_state(const struct task_struct * p,const char * mask)522 bool kdb_task_state(const struct task_struct *p, const char *mask)
523 {
524 	char state = kdb_task_state_char(p);
525 
526 	/* If there is no mask, then we will filter code that runs when the
527 	 * scheduler is idling and any system daemons that are currently
528 	 * sleeping.
529 	 */
530 	if (!mask || mask[0] == '\0')
531 		return !strchr("-ims", state);
532 
533 	/* A is a special case that matches all states */
534 	if (strchr(mask, 'A'))
535 		return true;
536 
537 	return strchr(mask, state);
538 }
539 
540 /* Maintain a small stack of kdb_flags to allow recursion without disturbing
541  * the global kdb state.
542  */
543 
544 static int kdb_flags_stack[4], kdb_flags_index;
545 
kdb_save_flags(void)546 void kdb_save_flags(void)
547 {
548 	BUG_ON(kdb_flags_index >= ARRAY_SIZE(kdb_flags_stack));
549 	kdb_flags_stack[kdb_flags_index++] = kdb_flags;
550 }
551 
kdb_restore_flags(void)552 void kdb_restore_flags(void)
553 {
554 	BUG_ON(kdb_flags_index <= 0);
555 	kdb_flags = kdb_flags_stack[--kdb_flags_index];
556 }
557