• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Routines providing a simple monitor for use on the PowerMac.
3  *
4  * Copyright (C) 1996-2005 Paul Mackerras.
5  * Copyright (C) 2001 PPC64 Team, IBM Corp
6  * Copyrignt (C) 2006 Michael Ellerman, IBM Corp
7  *
8  *      This program is free software; you can redistribute it and/or
9  *      modify it under the terms of the GNU General Public License
10  *      as published by the Free Software Foundation; either version
11  *      2 of the License, or (at your option) any later version.
12  */
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/smp.h>
16 #include <linux/mm.h>
17 #include <linux/reboot.h>
18 #include <linux/delay.h>
19 #include <linux/kallsyms.h>
20 #include <linux/cpumask.h>
21 #include <linux/export.h>
22 #include <linux/sysrq.h>
23 #include <linux/interrupt.h>
24 #include <linux/irq.h>
25 #include <linux/bug.h>
26 
27 #include <asm/ptrace.h>
28 #include <asm/string.h>
29 #include <asm/prom.h>
30 #include <asm/machdep.h>
31 #include <asm/xmon.h>
32 #include <asm/processor.h>
33 #include <asm/pgtable.h>
34 #include <asm/mmu.h>
35 #include <asm/mmu_context.h>
36 #include <asm/cputable.h>
37 #include <asm/rtas.h>
38 #include <asm/sstep.h>
39 #include <asm/irq_regs.h>
40 #include <asm/spu.h>
41 #include <asm/spu_priv1.h>
42 #include <asm/setjmp.h>
43 #include <asm/reg.h>
44 #include <asm/debug.h>
45 
46 #ifdef CONFIG_PPC64
47 #include <asm/hvcall.h>
48 #include <asm/paca.h>
49 #endif
50 
51 #include "nonstdio.h"
52 #include "dis-asm.h"
53 
54 #define scanhex	xmon_scanhex
55 #define skipbl	xmon_skipbl
56 
57 #ifdef CONFIG_SMP
58 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
59 static unsigned long xmon_taken = 1;
60 static int xmon_owner;
61 static int xmon_gate;
62 #endif /* CONFIG_SMP */
63 
64 static unsigned long in_xmon __read_mostly = 0;
65 
66 static unsigned long adrs;
67 static int size = 1;
68 #define MAX_DUMP (128 * 1024)
69 static unsigned long ndump = 64;
70 static unsigned long nidump = 16;
71 static unsigned long ncsum = 4096;
72 static int termch;
73 static char tmpstr[128];
74 
75 static long bus_error_jmp[JMP_BUF_LEN];
76 static int catch_memory_errors;
77 static long *xmon_fault_jmp[NR_CPUS];
78 
79 /* Breakpoint stuff */
80 struct bpt {
81 	unsigned long	address;
82 	unsigned int	instr[2];
83 	atomic_t	ref_count;
84 	int		enabled;
85 	unsigned long	pad;
86 };
87 
88 /* Bits in bpt.enabled */
89 #define BP_IABR_TE	1		/* IABR translation enabled */
90 #define BP_IABR		2
91 #define BP_TRAP		8
92 #define BP_DABR		0x10
93 
94 #define NBPTS	256
95 static struct bpt bpts[NBPTS];
96 static struct bpt dabr;
97 static struct bpt *iabr;
98 static unsigned bpinstr = 0x7fe00008;	/* trap */
99 
100 #define BP_NUM(bp)	((bp) - bpts + 1)
101 
102 /* Prototypes */
103 static int cmds(struct pt_regs *);
104 static int mread(unsigned long, void *, int);
105 static int mwrite(unsigned long, void *, int);
106 static int handle_fault(struct pt_regs *);
107 static void byterev(unsigned char *, int);
108 static void memex(void);
109 static int bsesc(void);
110 static void dump(void);
111 static void prdump(unsigned long, long);
112 static int ppc_inst_dump(unsigned long, long, int);
113 static void dump_log_buf(void);
114 static void backtrace(struct pt_regs *);
115 static void excprint(struct pt_regs *);
116 static void prregs(struct pt_regs *);
117 static void memops(int);
118 static void memlocate(void);
119 static void memzcan(void);
120 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
121 int skipbl(void);
122 int scanhex(unsigned long *valp);
123 static void scannl(void);
124 static int hexdigit(int);
125 void getstring(char *, int);
126 static void flush_input(void);
127 static int inchar(void);
128 static void take_input(char *);
129 static unsigned long read_spr(int);
130 static void write_spr(int, unsigned long);
131 static void super_regs(void);
132 static void remove_bpts(void);
133 static void insert_bpts(void);
134 static void remove_cpu_bpts(void);
135 static void insert_cpu_bpts(void);
136 static struct bpt *at_breakpoint(unsigned long pc);
137 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
138 static int  do_step(struct pt_regs *);
139 static void bpt_cmds(void);
140 static void cacheflush(void);
141 static int  cpu_cmd(void);
142 static void csum(void);
143 static void bootcmds(void);
144 static void proccall(void);
145 void dump_segments(void);
146 static void symbol_lookup(void);
147 static void xmon_show_stack(unsigned long sp, unsigned long lr,
148 			    unsigned long pc);
149 static void xmon_print_symbol(unsigned long address, const char *mid,
150 			      const char *after);
151 static const char *getvecname(unsigned long vec);
152 
153 static int do_spu_cmd(void);
154 
155 #ifdef CONFIG_44x
156 static void dump_tlb_44x(void);
157 #endif
158 #ifdef CONFIG_PPC_BOOK3E
159 static void dump_tlb_book3e(void);
160 #endif
161 
162 static int xmon_no_auto_backtrace;
163 
164 extern void xmon_enter(void);
165 extern void xmon_leave(void);
166 
167 #ifdef CONFIG_PPC64
168 #define REG		"%.16lx"
169 #define REGS_PER_LINE	4
170 #define LAST_VOLATILE	13
171 #else
172 #define REG		"%.8lx"
173 #define REGS_PER_LINE	8
174 #define LAST_VOLATILE	12
175 #endif
176 
177 #define GETWORD(v)	(((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
178 
179 #define isxdigit(c)	(('0' <= (c) && (c) <= '9') \
180 			 || ('a' <= (c) && (c) <= 'f') \
181 			 || ('A' <= (c) && (c) <= 'F'))
182 #define isalnum(c)	(('0' <= (c) && (c) <= '9') \
183 			 || ('a' <= (c) && (c) <= 'z') \
184 			 || ('A' <= (c) && (c) <= 'Z'))
185 #define isspace(c)	(c == ' ' || c == '\t' || c == 10 || c == 13 || c == 0)
186 
187 static char *help_string = "\
188 Commands:\n\
189   b	show breakpoints\n\
190   bd	set data breakpoint\n\
191   bi	set instruction breakpoint\n\
192   bc	clear breakpoint\n"
193 #ifdef CONFIG_SMP
194   "\
195   c	print cpus stopped in xmon\n\
196   c#	try to switch to cpu number h (in hex)\n"
197 #endif
198   "\
199   C	checksum\n\
200   d	dump bytes\n\
201   di	dump instructions\n\
202   df	dump float values\n\
203   dd	dump double values\n\
204   dl    dump the kernel log buffer\n\
205   dr	dump stream of raw bytes\n\
206   e	print exception information\n\
207   f	flush cache\n\
208   la	lookup symbol+offset of specified address\n\
209   ls	lookup address of specified symbol\n\
210   m	examine/change memory\n\
211   mm	move a block of memory\n\
212   ms	set a block of memory\n\
213   md	compare two blocks of memory\n\
214   ml	locate a block of memory\n\
215   mz	zero a block of memory\n\
216   mi	show information about memory allocation\n\
217   p 	call a procedure\n\
218   r	print registers\n\
219   s	single step\n"
220 #ifdef CONFIG_SPU_BASE
221 "  ss	stop execution on all spus\n\
222   sr	restore execution on stopped spus\n\
223   sf  #	dump spu fields for spu # (in hex)\n\
224   sd  #	dump spu local store for spu # (in hex)\n\
225   sdi #	disassemble spu local store for spu # (in hex)\n"
226 #endif
227 "  S	print special registers\n\
228   t	print backtrace\n\
229   x	exit monitor and recover\n\
230   X	exit monitor and dont recover\n"
231 #if defined(CONFIG_PPC64) && !defined(CONFIG_PPC_BOOK3E)
232 "  u	dump segment table or SLB\n"
233 #elif defined(CONFIG_PPC_STD_MMU_32)
234 "  u	dump segment registers\n"
235 #elif defined(CONFIG_44x) || defined(CONFIG_PPC_BOOK3E)
236 "  u	dump TLB\n"
237 #endif
238 "  ?	help\n"
239 "  zr	reboot\n\
240   zh	halt\n"
241 ;
242 
243 static struct pt_regs *xmon_regs;
244 
sync(void)245 static inline void sync(void)
246 {
247 	asm volatile("sync; isync");
248 }
249 
store_inst(void * p)250 static inline void store_inst(void *p)
251 {
252 	asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
253 }
254 
cflush(void * p)255 static inline void cflush(void *p)
256 {
257 	asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
258 }
259 
cinval(void * p)260 static inline void cinval(void *p)
261 {
262 	asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
263 }
264 
265 /*
266  * Disable surveillance (the service processor watchdog function)
267  * while we are in xmon.
268  * XXX we should re-enable it when we leave. :)
269  */
270 #define SURVEILLANCE_TOKEN	9000
271 
disable_surveillance(void)272 static inline void disable_surveillance(void)
273 {
274 #ifdef CONFIG_PPC_PSERIES
275 	/* Since this can't be a module, args should end up below 4GB. */
276 	static struct rtas_args args;
277 
278 	/*
279 	 * At this point we have got all the cpus we can into
280 	 * xmon, so there is hopefully no other cpu calling RTAS
281 	 * at the moment, even though we don't take rtas.lock.
282 	 * If we did try to take rtas.lock there would be a
283 	 * real possibility of deadlock.
284 	 */
285 	args.token = rtas_token("set-indicator");
286 	if (args.token == RTAS_UNKNOWN_SERVICE)
287 		return;
288 	args.nargs = 3;
289 	args.nret = 1;
290 	args.rets = &args.args[3];
291 	args.args[0] = SURVEILLANCE_TOKEN;
292 	args.args[1] = 0;
293 	args.args[2] = 0;
294 	enter_rtas(__pa(&args));
295 #endif /* CONFIG_PPC_PSERIES */
296 }
297 
298 #ifdef CONFIG_SMP
299 static int xmon_speaker;
300 
get_output_lock(void)301 static void get_output_lock(void)
302 {
303 	int me = smp_processor_id() + 0x100;
304 	int last_speaker = 0, prev;
305 	long timeout;
306 
307 	if (xmon_speaker == me)
308 		return;
309 	for (;;) {
310 		if (xmon_speaker == 0) {
311 			last_speaker = cmpxchg(&xmon_speaker, 0, me);
312 			if (last_speaker == 0)
313 				return;
314 		}
315 		timeout = 10000000;
316 		while (xmon_speaker == last_speaker) {
317 			if (--timeout > 0)
318 				continue;
319 			/* hostile takeover */
320 			prev = cmpxchg(&xmon_speaker, last_speaker, me);
321 			if (prev == last_speaker)
322 				return;
323 			break;
324 		}
325 	}
326 }
327 
release_output_lock(void)328 static void release_output_lock(void)
329 {
330 	xmon_speaker = 0;
331 }
332 
cpus_are_in_xmon(void)333 int cpus_are_in_xmon(void)
334 {
335 	return !cpumask_empty(&cpus_in_xmon);
336 }
337 #endif
338 
unrecoverable_excp(struct pt_regs * regs)339 static inline int unrecoverable_excp(struct pt_regs *regs)
340 {
341 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
342 	/* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
343 	return 0;
344 #else
345 	return ((regs->msr & MSR_RI) == 0);
346 #endif
347 }
348 
xmon_core(struct pt_regs * regs,int fromipi)349 static int xmon_core(struct pt_regs *regs, int fromipi)
350 {
351 	int cmd = 0;
352 	struct bpt *bp;
353 	long recurse_jmp[JMP_BUF_LEN];
354 	unsigned long offset;
355 	unsigned long flags;
356 #ifdef CONFIG_SMP
357 	int cpu;
358 	int secondary;
359 	unsigned long timeout;
360 #endif
361 
362 	local_irq_save(flags);
363 
364 	bp = in_breakpoint_table(regs->nip, &offset);
365 	if (bp != NULL) {
366 		regs->nip = bp->address + offset;
367 		atomic_dec(&bp->ref_count);
368 	}
369 
370 	remove_cpu_bpts();
371 
372 #ifdef CONFIG_SMP
373 	cpu = smp_processor_id();
374 	if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
375 		get_output_lock();
376 		excprint(regs);
377 		printf("cpu 0x%x: Exception %lx %s in xmon, "
378 		       "returning to main loop\n",
379 		       cpu, regs->trap, getvecname(TRAP(regs)));
380 		release_output_lock();
381 		longjmp(xmon_fault_jmp[cpu], 1);
382 	}
383 
384 	if (setjmp(recurse_jmp) != 0) {
385 		if (!in_xmon || !xmon_gate) {
386 			get_output_lock();
387 			printf("xmon: WARNING: bad recursive fault "
388 			       "on cpu 0x%x\n", cpu);
389 			release_output_lock();
390 			goto waiting;
391 		}
392 		secondary = !(xmon_taken && cpu == xmon_owner);
393 		goto cmdloop;
394 	}
395 
396 	xmon_fault_jmp[cpu] = recurse_jmp;
397 	cpumask_set_cpu(cpu, &cpus_in_xmon);
398 
399 	bp = NULL;
400 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT))
401 		bp = at_breakpoint(regs->nip);
402 	if (bp || unrecoverable_excp(regs))
403 		fromipi = 0;
404 
405 	if (!fromipi) {
406 		get_output_lock();
407 		excprint(regs);
408 		if (bp) {
409 			printf("cpu 0x%x stopped at breakpoint 0x%x (",
410 			       cpu, BP_NUM(bp));
411 			xmon_print_symbol(regs->nip, " ", ")\n");
412 		}
413 		if (unrecoverable_excp(regs))
414 			printf("WARNING: exception is not recoverable, "
415 			       "can't continue\n");
416 		release_output_lock();
417 	}
418 
419  waiting:
420 	secondary = 1;
421 	while (secondary && !xmon_gate) {
422 		if (in_xmon == 0) {
423 			if (fromipi)
424 				goto leave;
425 			secondary = test_and_set_bit(0, &in_xmon);
426 		}
427 		barrier();
428 	}
429 
430 	if (!secondary && !xmon_gate) {
431 		/* we are the first cpu to come in */
432 		/* interrupt other cpu(s) */
433 		int ncpus = num_online_cpus();
434 
435 		xmon_owner = cpu;
436 		mb();
437 		if (ncpus > 1) {
438 			smp_send_debugger_break();
439 			/* wait for other cpus to come in */
440 			for (timeout = 100000000; timeout != 0; --timeout) {
441 				if (cpumask_weight(&cpus_in_xmon) >= ncpus)
442 					break;
443 				barrier();
444 			}
445 		}
446 		remove_bpts();
447 		disable_surveillance();
448 		/* for breakpoint or single step, print the current instr. */
449 		if (bp || TRAP(regs) == 0xd00)
450 			ppc_inst_dump(regs->nip, 1, 0);
451 		printf("enter ? for help\n");
452 		mb();
453 		xmon_gate = 1;
454 		barrier();
455 	}
456 
457  cmdloop:
458 	while (in_xmon) {
459 		if (secondary) {
460 			if (cpu == xmon_owner) {
461 				if (!test_and_set_bit(0, &xmon_taken)) {
462 					secondary = 0;
463 					continue;
464 				}
465 				/* missed it */
466 				while (cpu == xmon_owner)
467 					barrier();
468 			}
469 			barrier();
470 		} else {
471 			cmd = cmds(regs);
472 			if (cmd != 0) {
473 				/* exiting xmon */
474 				insert_bpts();
475 				xmon_gate = 0;
476 				wmb();
477 				in_xmon = 0;
478 				break;
479 			}
480 			/* have switched to some other cpu */
481 			secondary = 1;
482 		}
483 	}
484  leave:
485 	cpumask_clear_cpu(cpu, &cpus_in_xmon);
486 	xmon_fault_jmp[cpu] = NULL;
487 #else
488 	/* UP is simple... */
489 	if (in_xmon) {
490 		printf("Exception %lx %s in xmon, returning to main loop\n",
491 		       regs->trap, getvecname(TRAP(regs)));
492 		longjmp(xmon_fault_jmp[0], 1);
493 	}
494 	if (setjmp(recurse_jmp) == 0) {
495 		xmon_fault_jmp[0] = recurse_jmp;
496 		in_xmon = 1;
497 
498 		excprint(regs);
499 		bp = at_breakpoint(regs->nip);
500 		if (bp) {
501 			printf("Stopped at breakpoint %x (", BP_NUM(bp));
502 			xmon_print_symbol(regs->nip, " ", ")\n");
503 		}
504 		if (unrecoverable_excp(regs))
505 			printf("WARNING: exception is not recoverable, "
506 			       "can't continue\n");
507 		remove_bpts();
508 		disable_surveillance();
509 		/* for breakpoint or single step, print the current instr. */
510 		if (bp || TRAP(regs) == 0xd00)
511 			ppc_inst_dump(regs->nip, 1, 0);
512 		printf("enter ? for help\n");
513 	}
514 
515 	cmd = cmds(regs);
516 
517 	insert_bpts();
518 	in_xmon = 0;
519 #endif
520 
521 #ifdef CONFIG_BOOKE
522 	if (regs->msr & MSR_DE) {
523 		bp = at_breakpoint(regs->nip);
524 		if (bp != NULL) {
525 			regs->nip = (unsigned long) &bp->instr[0];
526 			atomic_inc(&bp->ref_count);
527 		}
528 	}
529 #else
530 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
531 		bp = at_breakpoint(regs->nip);
532 		if (bp != NULL) {
533 			int stepped = emulate_step(regs, bp->instr[0]);
534 			if (stepped == 0) {
535 				regs->nip = (unsigned long) &bp->instr[0];
536 				atomic_inc(&bp->ref_count);
537 			} else if (stepped < 0) {
538 				printf("Couldn't single-step %s instruction\n",
539 				    (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
540 			}
541 		}
542 	}
543 #endif
544 	insert_cpu_bpts();
545 
546 	local_irq_restore(flags);
547 
548 	return cmd != 'X' && cmd != EOF;
549 }
550 
xmon(struct pt_regs * excp)551 int xmon(struct pt_regs *excp)
552 {
553 	struct pt_regs regs;
554 
555 	if (excp == NULL) {
556 		ppc_save_regs(&regs);
557 		excp = &regs;
558 	}
559 
560 	return xmon_core(excp, 0);
561 }
562 EXPORT_SYMBOL(xmon);
563 
xmon_irq(int irq,void * d)564 irqreturn_t xmon_irq(int irq, void *d)
565 {
566 	unsigned long flags;
567 	local_irq_save(flags);
568 	printf("Keyboard interrupt\n");
569 	xmon(get_irq_regs());
570 	local_irq_restore(flags);
571 	return IRQ_HANDLED;
572 }
573 
xmon_bpt(struct pt_regs * regs)574 static int xmon_bpt(struct pt_regs *regs)
575 {
576 	struct bpt *bp;
577 	unsigned long offset;
578 
579 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
580 		return 0;
581 
582 	/* Are we at the trap at bp->instr[1] for some bp? */
583 	bp = in_breakpoint_table(regs->nip, &offset);
584 	if (bp != NULL && offset == 4) {
585 		regs->nip = bp->address + 4;
586 		atomic_dec(&bp->ref_count);
587 		return 1;
588 	}
589 
590 	/* Are we at a breakpoint? */
591 	bp = at_breakpoint(regs->nip);
592 	if (!bp)
593 		return 0;
594 
595 	xmon_core(regs, 0);
596 
597 	return 1;
598 }
599 
xmon_sstep(struct pt_regs * regs)600 static int xmon_sstep(struct pt_regs *regs)
601 {
602 	if (user_mode(regs))
603 		return 0;
604 	xmon_core(regs, 0);
605 	return 1;
606 }
607 
xmon_dabr_match(struct pt_regs * regs)608 static int xmon_dabr_match(struct pt_regs *regs)
609 {
610 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
611 		return 0;
612 	if (dabr.enabled == 0)
613 		return 0;
614 	xmon_core(regs, 0);
615 	return 1;
616 }
617 
xmon_iabr_match(struct pt_regs * regs)618 static int xmon_iabr_match(struct pt_regs *regs)
619 {
620 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
621 		return 0;
622 	if (iabr == NULL)
623 		return 0;
624 	xmon_core(regs, 0);
625 	return 1;
626 }
627 
xmon_ipi(struct pt_regs * regs)628 static int xmon_ipi(struct pt_regs *regs)
629 {
630 #ifdef CONFIG_SMP
631 	if (in_xmon && !cpumask_test_cpu(smp_processor_id(), &cpus_in_xmon))
632 		xmon_core(regs, 1);
633 #endif
634 	return 0;
635 }
636 
xmon_fault_handler(struct pt_regs * regs)637 static int xmon_fault_handler(struct pt_regs *regs)
638 {
639 	struct bpt *bp;
640 	unsigned long offset;
641 
642 	if (in_xmon && catch_memory_errors)
643 		handle_fault(regs);	/* doesn't return */
644 
645 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
646 		bp = in_breakpoint_table(regs->nip, &offset);
647 		if (bp != NULL) {
648 			regs->nip = bp->address + offset;
649 			atomic_dec(&bp->ref_count);
650 		}
651 	}
652 
653 	return 0;
654 }
655 
at_breakpoint(unsigned long pc)656 static struct bpt *at_breakpoint(unsigned long pc)
657 {
658 	int i;
659 	struct bpt *bp;
660 
661 	bp = bpts;
662 	for (i = 0; i < NBPTS; ++i, ++bp)
663 		if (bp->enabled && pc == bp->address)
664 			return bp;
665 	return NULL;
666 }
667 
in_breakpoint_table(unsigned long nip,unsigned long * offp)668 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
669 {
670 	unsigned long off;
671 
672 	off = nip - (unsigned long) bpts;
673 	if (off >= sizeof(bpts))
674 		return NULL;
675 	off %= sizeof(struct bpt);
676 	if (off != offsetof(struct bpt, instr[0])
677 	    && off != offsetof(struct bpt, instr[1]))
678 		return NULL;
679 	*offp = off - offsetof(struct bpt, instr[0]);
680 	return (struct bpt *) (nip - off);
681 }
682 
new_breakpoint(unsigned long a)683 static struct bpt *new_breakpoint(unsigned long a)
684 {
685 	struct bpt *bp;
686 
687 	a &= ~3UL;
688 	bp = at_breakpoint(a);
689 	if (bp)
690 		return bp;
691 
692 	for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
693 		if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
694 			bp->address = a;
695 			bp->instr[1] = bpinstr;
696 			store_inst(&bp->instr[1]);
697 			return bp;
698 		}
699 	}
700 
701 	printf("Sorry, no free breakpoints.  Please clear one first.\n");
702 	return NULL;
703 }
704 
insert_bpts(void)705 static void insert_bpts(void)
706 {
707 	int i;
708 	struct bpt *bp;
709 
710 	bp = bpts;
711 	for (i = 0; i < NBPTS; ++i, ++bp) {
712 		if ((bp->enabled & (BP_TRAP|BP_IABR)) == 0)
713 			continue;
714 		if (mread(bp->address, &bp->instr[0], 4) != 4) {
715 			printf("Couldn't read instruction at %lx, "
716 			       "disabling breakpoint there\n", bp->address);
717 			bp->enabled = 0;
718 			continue;
719 		}
720 		if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
721 			printf("Breakpoint at %lx is on an mtmsrd or rfid "
722 			       "instruction, disabling it\n", bp->address);
723 			bp->enabled = 0;
724 			continue;
725 		}
726 		store_inst(&bp->instr[0]);
727 		if (bp->enabled & BP_IABR)
728 			continue;
729 		if (mwrite(bp->address, &bpinstr, 4) != 4) {
730 			printf("Couldn't write instruction at %lx, "
731 			       "disabling breakpoint there\n", bp->address);
732 			bp->enabled &= ~BP_TRAP;
733 			continue;
734 		}
735 		store_inst((void *)bp->address);
736 	}
737 }
738 
insert_cpu_bpts(void)739 static void insert_cpu_bpts(void)
740 {
741 	if (dabr.enabled)
742 		set_dabr(dabr.address | (dabr.enabled & 7));
743 	if (iabr && cpu_has_feature(CPU_FTR_IABR))
744 		mtspr(SPRN_IABR, iabr->address
745 			 | (iabr->enabled & (BP_IABR|BP_IABR_TE)));
746 }
747 
remove_bpts(void)748 static void remove_bpts(void)
749 {
750 	int i;
751 	struct bpt *bp;
752 	unsigned instr;
753 
754 	bp = bpts;
755 	for (i = 0; i < NBPTS; ++i, ++bp) {
756 		if ((bp->enabled & (BP_TRAP|BP_IABR)) != BP_TRAP)
757 			continue;
758 		if (mread(bp->address, &instr, 4) == 4
759 		    && instr == bpinstr
760 		    && mwrite(bp->address, &bp->instr, 4) != 4)
761 			printf("Couldn't remove breakpoint at %lx\n",
762 			       bp->address);
763 		else
764 			store_inst((void *)bp->address);
765 	}
766 }
767 
remove_cpu_bpts(void)768 static void remove_cpu_bpts(void)
769 {
770 	set_dabr(0);
771 	if (cpu_has_feature(CPU_FTR_IABR))
772 		mtspr(SPRN_IABR, 0);
773 }
774 
775 /* Command interpreting routine */
776 static char *last_cmd;
777 
778 static int
cmds(struct pt_regs * excp)779 cmds(struct pt_regs *excp)
780 {
781 	int cmd = 0;
782 
783 	last_cmd = NULL;
784 	xmon_regs = excp;
785 
786 	if (!xmon_no_auto_backtrace) {
787 		xmon_no_auto_backtrace = 1;
788 		xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
789 	}
790 
791 	for(;;) {
792 #ifdef CONFIG_SMP
793 		printf("%x:", smp_processor_id());
794 #endif /* CONFIG_SMP */
795 		printf("mon> ");
796 		flush_input();
797 		termch = 0;
798 		cmd = skipbl();
799 		if( cmd == '\n' ) {
800 			if (last_cmd == NULL)
801 				continue;
802 			take_input(last_cmd);
803 			last_cmd = NULL;
804 			cmd = inchar();
805 		}
806 		switch (cmd) {
807 		case 'm':
808 			cmd = inchar();
809 			switch (cmd) {
810 			case 'm':
811 			case 's':
812 			case 'd':
813 				memops(cmd);
814 				break;
815 			case 'l':
816 				memlocate();
817 				break;
818 			case 'z':
819 				memzcan();
820 				break;
821 			case 'i':
822 				show_mem(0);
823 				break;
824 			default:
825 				termch = cmd;
826 				memex();
827 			}
828 			break;
829 		case 'd':
830 			dump();
831 			break;
832 		case 'l':
833 			symbol_lookup();
834 			break;
835 		case 'r':
836 			prregs(excp);	/* print regs */
837 			break;
838 		case 'e':
839 			excprint(excp);
840 			break;
841 		case 'S':
842 			super_regs();
843 			break;
844 		case 't':
845 			backtrace(excp);
846 			break;
847 		case 'f':
848 			cacheflush();
849 			break;
850 		case 's':
851 			if (do_spu_cmd() == 0)
852 				break;
853 			if (do_step(excp))
854 				return cmd;
855 			break;
856 		case 'x':
857 		case 'X':
858 			return cmd;
859 		case EOF:
860 			printf(" <no input ...>\n");
861 			mdelay(2000);
862 			return cmd;
863 		case '?':
864 			xmon_puts(help_string);
865 			break;
866 		case 'b':
867 			bpt_cmds();
868 			break;
869 		case 'C':
870 			csum();
871 			break;
872 		case 'c':
873 			if (cpu_cmd())
874 				return 0;
875 			break;
876 		case 'z':
877 			bootcmds();
878 			break;
879 		case 'p':
880 			proccall();
881 			break;
882 #ifdef CONFIG_PPC_STD_MMU
883 		case 'u':
884 			dump_segments();
885 			break;
886 #elif defined(CONFIG_4xx)
887 		case 'u':
888 			dump_tlb_44x();
889 			break;
890 #elif defined(CONFIG_PPC_BOOK3E)
891 		case 'u':
892 			dump_tlb_book3e();
893 			break;
894 #endif
895 		default:
896 			printf("Unrecognized command: ");
897 		        do {
898 				if (' ' < cmd && cmd <= '~')
899 					putchar(cmd);
900 				else
901 					printf("\\x%x", cmd);
902 				cmd = inchar();
903 		        } while (cmd != '\n');
904 			printf(" (type ? for help)\n");
905 			break;
906 		}
907 	}
908 }
909 
910 #ifdef CONFIG_BOOKE
do_step(struct pt_regs * regs)911 static int do_step(struct pt_regs *regs)
912 {
913 	regs->msr |= MSR_DE;
914 	mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
915 	return 1;
916 }
917 #else
918 /*
919  * Step a single instruction.
920  * Some instructions we emulate, others we execute with MSR_SE set.
921  */
do_step(struct pt_regs * regs)922 static int do_step(struct pt_regs *regs)
923 {
924 	unsigned int instr;
925 	int stepped;
926 
927 	/* check we are in 64-bit kernel mode, translation enabled */
928 	if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
929 		if (mread(regs->nip, &instr, 4) == 4) {
930 			stepped = emulate_step(regs, instr);
931 			if (stepped < 0) {
932 				printf("Couldn't single-step %s instruction\n",
933 				       (IS_RFID(instr)? "rfid": "mtmsrd"));
934 				return 0;
935 			}
936 			if (stepped > 0) {
937 				regs->trap = 0xd00 | (regs->trap & 1);
938 				printf("stepped to ");
939 				xmon_print_symbol(regs->nip, " ", "\n");
940 				ppc_inst_dump(regs->nip, 1, 0);
941 				return 0;
942 			}
943 		}
944 	}
945 	regs->msr |= MSR_SE;
946 	return 1;
947 }
948 #endif
949 
bootcmds(void)950 static void bootcmds(void)
951 {
952 	int cmd;
953 
954 	cmd = inchar();
955 	if (cmd == 'r')
956 		ppc_md.restart(NULL);
957 	else if (cmd == 'h')
958 		ppc_md.halt();
959 	else if (cmd == 'p')
960 		ppc_md.power_off();
961 }
962 
cpu_cmd(void)963 static int cpu_cmd(void)
964 {
965 #ifdef CONFIG_SMP
966 	unsigned long cpu;
967 	int timeout;
968 	int count;
969 
970 	if (!scanhex(&cpu)) {
971 		/* print cpus waiting or in xmon */
972 		printf("cpus stopped:");
973 		count = 0;
974 		for_each_possible_cpu(cpu) {
975 			if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
976 				if (count == 0)
977 					printf(" %x", cpu);
978 				++count;
979 			} else {
980 				if (count > 1)
981 					printf("-%x", cpu - 1);
982 				count = 0;
983 			}
984 		}
985 		if (count > 1)
986 			printf("-%x", NR_CPUS - 1);
987 		printf("\n");
988 		return 0;
989 	}
990 	/* try to switch to cpu specified */
991 	if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
992 		printf("cpu 0x%x isn't in xmon\n", cpu);
993 		return 0;
994 	}
995 	xmon_taken = 0;
996 	mb();
997 	xmon_owner = cpu;
998 	timeout = 10000000;
999 	while (!xmon_taken) {
1000 		if (--timeout == 0) {
1001 			if (test_and_set_bit(0, &xmon_taken))
1002 				break;
1003 			/* take control back */
1004 			mb();
1005 			xmon_owner = smp_processor_id();
1006 			printf("cpu %u didn't take control\n", cpu);
1007 			return 0;
1008 		}
1009 		barrier();
1010 	}
1011 	return 1;
1012 #else
1013 	return 0;
1014 #endif /* CONFIG_SMP */
1015 }
1016 
1017 static unsigned short fcstab[256] = {
1018 	0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1019 	0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1020 	0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1021 	0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1022 	0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1023 	0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1024 	0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1025 	0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1026 	0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1027 	0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1028 	0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1029 	0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1030 	0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1031 	0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1032 	0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1033 	0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1034 	0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1035 	0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1036 	0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1037 	0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1038 	0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1039 	0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1040 	0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1041 	0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1042 	0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1043 	0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1044 	0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1045 	0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1046 	0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1047 	0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1048 	0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1049 	0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1050 };
1051 
1052 #define FCS(fcs, c)	(((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1053 
1054 static void
csum(void)1055 csum(void)
1056 {
1057 	unsigned int i;
1058 	unsigned short fcs;
1059 	unsigned char v;
1060 
1061 	if (!scanhex(&adrs))
1062 		return;
1063 	if (!scanhex(&ncsum))
1064 		return;
1065 	fcs = 0xffff;
1066 	for (i = 0; i < ncsum; ++i) {
1067 		if (mread(adrs+i, &v, 1) == 0) {
1068 			printf("csum stopped at %x\n", adrs+i);
1069 			break;
1070 		}
1071 		fcs = FCS(fcs, v);
1072 	}
1073 	printf("%x\n", fcs);
1074 }
1075 
1076 /*
1077  * Check if this is a suitable place to put a breakpoint.
1078  */
check_bp_loc(unsigned long addr)1079 static long check_bp_loc(unsigned long addr)
1080 {
1081 	unsigned int instr;
1082 
1083 	addr &= ~3;
1084 	if (!is_kernel_addr(addr)) {
1085 		printf("Breakpoints may only be placed at kernel addresses\n");
1086 		return 0;
1087 	}
1088 	if (!mread(addr, &instr, sizeof(instr))) {
1089 		printf("Can't read instruction at address %lx\n", addr);
1090 		return 0;
1091 	}
1092 	if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1093 		printf("Breakpoints may not be placed on mtmsrd or rfid "
1094 		       "instructions\n");
1095 		return 0;
1096 	}
1097 	return 1;
1098 }
1099 
1100 static char *breakpoint_help_string =
1101     "Breakpoint command usage:\n"
1102     "b                show breakpoints\n"
1103     "b <addr> [cnt]   set breakpoint at given instr addr\n"
1104     "bc               clear all breakpoints\n"
1105     "bc <n/addr>      clear breakpoint number n or at addr\n"
1106     "bi <addr> [cnt]  set hardware instr breakpoint (POWER3/RS64 only)\n"
1107     "bd <addr> [cnt]  set hardware data breakpoint\n"
1108     "";
1109 
1110 static void
bpt_cmds(void)1111 bpt_cmds(void)
1112 {
1113 	int cmd;
1114 	unsigned long a;
1115 	int mode, i;
1116 	struct bpt *bp;
1117 	const char badaddr[] = "Only kernel addresses are permitted "
1118 		"for breakpoints\n";
1119 
1120 	cmd = inchar();
1121 	switch (cmd) {
1122 #ifndef CONFIG_8xx
1123 	case 'd':	/* bd - hardware data breakpoint */
1124 		mode = 7;
1125 		cmd = inchar();
1126 		if (cmd == 'r')
1127 			mode = 5;
1128 		else if (cmd == 'w')
1129 			mode = 6;
1130 		else
1131 			termch = cmd;
1132 		dabr.address = 0;
1133 		dabr.enabled = 0;
1134 		if (scanhex(&dabr.address)) {
1135 			if (!is_kernel_addr(dabr.address)) {
1136 				printf(badaddr);
1137 				break;
1138 			}
1139 			dabr.address &= ~7;
1140 			dabr.enabled = mode | BP_DABR;
1141 		}
1142 		break;
1143 
1144 	case 'i':	/* bi - hardware instr breakpoint */
1145 		if (!cpu_has_feature(CPU_FTR_IABR)) {
1146 			printf("Hardware instruction breakpoint "
1147 			       "not supported on this cpu\n");
1148 			break;
1149 		}
1150 		if (iabr) {
1151 			iabr->enabled &= ~(BP_IABR | BP_IABR_TE);
1152 			iabr = NULL;
1153 		}
1154 		if (!scanhex(&a))
1155 			break;
1156 		if (!check_bp_loc(a))
1157 			break;
1158 		bp = new_breakpoint(a);
1159 		if (bp != NULL) {
1160 			bp->enabled |= BP_IABR | BP_IABR_TE;
1161 			iabr = bp;
1162 		}
1163 		break;
1164 #endif
1165 
1166 	case 'c':
1167 		if (!scanhex(&a)) {
1168 			/* clear all breakpoints */
1169 			for (i = 0; i < NBPTS; ++i)
1170 				bpts[i].enabled = 0;
1171 			iabr = NULL;
1172 			dabr.enabled = 0;
1173 			printf("All breakpoints cleared\n");
1174 			break;
1175 		}
1176 
1177 		if (a <= NBPTS && a >= 1) {
1178 			/* assume a breakpoint number */
1179 			bp = &bpts[a-1];	/* bp nums are 1 based */
1180 		} else {
1181 			/* assume a breakpoint address */
1182 			bp = at_breakpoint(a);
1183 			if (bp == NULL) {
1184 				printf("No breakpoint at %x\n", a);
1185 				break;
1186 			}
1187 		}
1188 
1189 		printf("Cleared breakpoint %x (", BP_NUM(bp));
1190 		xmon_print_symbol(bp->address, " ", ")\n");
1191 		bp->enabled = 0;
1192 		break;
1193 
1194 	default:
1195 		termch = cmd;
1196 	        cmd = skipbl();
1197 		if (cmd == '?') {
1198 			printf(breakpoint_help_string);
1199 			break;
1200 		}
1201 		termch = cmd;
1202 		if (!scanhex(&a)) {
1203 			/* print all breakpoints */
1204 			printf("   type            address\n");
1205 			if (dabr.enabled) {
1206 				printf("   data   "REG"  [", dabr.address);
1207 				if (dabr.enabled & 1)
1208 					printf("r");
1209 				if (dabr.enabled & 2)
1210 					printf("w");
1211 				printf("]\n");
1212 			}
1213 			for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1214 				if (!bp->enabled)
1215 					continue;
1216 				printf("%2x %s   ", BP_NUM(bp),
1217 				    (bp->enabled & BP_IABR)? "inst": "trap");
1218 				xmon_print_symbol(bp->address, "  ", "\n");
1219 			}
1220 			break;
1221 		}
1222 
1223 		if (!check_bp_loc(a))
1224 			break;
1225 		bp = new_breakpoint(a);
1226 		if (bp != NULL)
1227 			bp->enabled |= BP_TRAP;
1228 		break;
1229 	}
1230 }
1231 
1232 /* Very cheap human name for vector lookup. */
1233 static
getvecname(unsigned long vec)1234 const char *getvecname(unsigned long vec)
1235 {
1236 	char *ret;
1237 
1238 	switch (vec) {
1239 	case 0x100:	ret = "(System Reset)"; break;
1240 	case 0x200:	ret = "(Machine Check)"; break;
1241 	case 0x300:	ret = "(Data Access)"; break;
1242 	case 0x380:	ret = "(Data SLB Access)"; break;
1243 	case 0x400:	ret = "(Instruction Access)"; break;
1244 	case 0x480:	ret = "(Instruction SLB Access)"; break;
1245 	case 0x500:	ret = "(Hardware Interrupt)"; break;
1246 	case 0x600:	ret = "(Alignment)"; break;
1247 	case 0x700:	ret = "(Program Check)"; break;
1248 	case 0x800:	ret = "(FPU Unavailable)"; break;
1249 	case 0x900:	ret = "(Decrementer)"; break;
1250 	case 0xc00:	ret = "(System Call)"; break;
1251 	case 0xd00:	ret = "(Single Step)"; break;
1252 	case 0xf00:	ret = "(Performance Monitor)"; break;
1253 	case 0xf20:	ret = "(Altivec Unavailable)"; break;
1254 	case 0x1300:	ret = "(Instruction Breakpoint)"; break;
1255 	default: ret = "";
1256 	}
1257 	return ret;
1258 }
1259 
get_function_bounds(unsigned long pc,unsigned long * startp,unsigned long * endp)1260 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1261 				unsigned long *endp)
1262 {
1263 	unsigned long size, offset;
1264 	const char *name;
1265 
1266 	*startp = *endp = 0;
1267 	if (pc == 0)
1268 		return;
1269 	if (setjmp(bus_error_jmp) == 0) {
1270 		catch_memory_errors = 1;
1271 		sync();
1272 		name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1273 		if (name != NULL) {
1274 			*startp = pc - offset;
1275 			*endp = pc - offset + size;
1276 		}
1277 		sync();
1278 	}
1279 	catch_memory_errors = 0;
1280 }
1281 
1282 static int xmon_depth_to_print = 64;
1283 
1284 #define LRSAVE_OFFSET		(STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1285 #define MARKER_OFFSET		(STACK_FRAME_MARKER * sizeof(unsigned long))
1286 
1287 #ifdef __powerpc64__
1288 #define REGS_OFFSET		0x70
1289 #else
1290 #define REGS_OFFSET		16
1291 #endif
1292 
xmon_show_stack(unsigned long sp,unsigned long lr,unsigned long pc)1293 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1294 			    unsigned long pc)
1295 {
1296 	unsigned long ip;
1297 	unsigned long newsp;
1298 	unsigned long marker;
1299 	int count = 0;
1300 	struct pt_regs regs;
1301 
1302 	do {
1303 		if (sp < PAGE_OFFSET) {
1304 			if (sp != 0)
1305 				printf("SP (%lx) is in userspace\n", sp);
1306 			break;
1307 		}
1308 
1309 		if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1310 		    || !mread(sp, &newsp, sizeof(unsigned long))) {
1311 			printf("Couldn't read stack frame at %lx\n", sp);
1312 			break;
1313 		}
1314 
1315 		/*
1316 		 * For the first stack frame, try to work out if
1317 		 * LR and/or the saved LR value in the bottommost
1318 		 * stack frame are valid.
1319 		 */
1320 		if ((pc | lr) != 0) {
1321 			unsigned long fnstart, fnend;
1322 			unsigned long nextip;
1323 			int printip = 1;
1324 
1325 			get_function_bounds(pc, &fnstart, &fnend);
1326 			nextip = 0;
1327 			if (newsp > sp)
1328 				mread(newsp + LRSAVE_OFFSET, &nextip,
1329 				      sizeof(unsigned long));
1330 			if (lr == ip) {
1331 				if (lr < PAGE_OFFSET
1332 				    || (fnstart <= lr && lr < fnend))
1333 					printip = 0;
1334 			} else if (lr == nextip) {
1335 				printip = 0;
1336 			} else if (lr >= PAGE_OFFSET
1337 				   && !(fnstart <= lr && lr < fnend)) {
1338 				printf("[link register   ] ");
1339 				xmon_print_symbol(lr, " ", "\n");
1340 			}
1341 			if (printip) {
1342 				printf("["REG"] ", sp);
1343 				xmon_print_symbol(ip, " ", " (unreliable)\n");
1344 			}
1345 			pc = lr = 0;
1346 
1347 		} else {
1348 			printf("["REG"] ", sp);
1349 			xmon_print_symbol(ip, " ", "\n");
1350 		}
1351 
1352 		/* Look for "regshere" marker to see if this is
1353 		   an exception frame. */
1354 		if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1355 		    && marker == STACK_FRAME_REGS_MARKER) {
1356 			if (mread(sp + REGS_OFFSET, &regs, sizeof(regs))
1357 			    != sizeof(regs)) {
1358 				printf("Couldn't read registers at %lx\n",
1359 				       sp + REGS_OFFSET);
1360 				break;
1361 			}
1362                         printf("--- Exception: %lx %s at ", regs.trap,
1363 			       getvecname(TRAP(&regs)));
1364 			pc = regs.nip;
1365 			lr = regs.link;
1366 			xmon_print_symbol(pc, " ", "\n");
1367 		}
1368 
1369 		if (newsp == 0)
1370 			break;
1371 
1372 		sp = newsp;
1373 	} while (count++ < xmon_depth_to_print);
1374 }
1375 
backtrace(struct pt_regs * excp)1376 static void backtrace(struct pt_regs *excp)
1377 {
1378 	unsigned long sp;
1379 
1380 	if (scanhex(&sp))
1381 		xmon_show_stack(sp, 0, 0);
1382 	else
1383 		xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1384 	scannl();
1385 }
1386 
print_bug_trap(struct pt_regs * regs)1387 static void print_bug_trap(struct pt_regs *regs)
1388 {
1389 #ifdef CONFIG_BUG
1390 	const struct bug_entry *bug;
1391 	unsigned long addr;
1392 
1393 	if (regs->msr & MSR_PR)
1394 		return;		/* not in kernel */
1395 	addr = regs->nip;	/* address of trap instruction */
1396 	if (addr < PAGE_OFFSET)
1397 		return;
1398 	bug = find_bug(regs->nip);
1399 	if (bug == NULL)
1400 		return;
1401 	if (is_warning_bug(bug))
1402 		return;
1403 
1404 #ifdef CONFIG_DEBUG_BUGVERBOSE
1405 	printf("kernel BUG at %s:%u!\n",
1406 	       bug->file, bug->line);
1407 #else
1408 	printf("kernel BUG at %p!\n", (void *)bug->bug_addr);
1409 #endif
1410 #endif /* CONFIG_BUG */
1411 }
1412 
excprint(struct pt_regs * fp)1413 static void excprint(struct pt_regs *fp)
1414 {
1415 	unsigned long trap;
1416 
1417 #ifdef CONFIG_SMP
1418 	printf("cpu 0x%x: ", smp_processor_id());
1419 #endif /* CONFIG_SMP */
1420 
1421 	trap = TRAP(fp);
1422 	printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1423 	printf("    pc: ");
1424 	xmon_print_symbol(fp->nip, ": ", "\n");
1425 
1426 	printf("    lr: ", fp->link);
1427 	xmon_print_symbol(fp->link, ": ", "\n");
1428 
1429 	printf("    sp: %lx\n", fp->gpr[1]);
1430 	printf("   msr: %lx\n", fp->msr);
1431 
1432 	if (trap == 0x300 || trap == 0x380 || trap == 0x600) {
1433 		printf("   dar: %lx\n", fp->dar);
1434 		if (trap != 0x380)
1435 			printf(" dsisr: %lx\n", fp->dsisr);
1436 	}
1437 
1438 	printf("  current = 0x%lx\n", current);
1439 #ifdef CONFIG_PPC64
1440 	printf("  paca    = 0x%lx\t softe: %d\t irq_happened: 0x%02x\n",
1441 	       local_paca, local_paca->soft_enabled, local_paca->irq_happened);
1442 #endif
1443 	if (current) {
1444 		printf("    pid   = %ld, comm = %s\n",
1445 		       current->pid, current->comm);
1446 	}
1447 
1448 	if (trap == 0x700)
1449 		print_bug_trap(fp);
1450 }
1451 
prregs(struct pt_regs * fp)1452 static void prregs(struct pt_regs *fp)
1453 {
1454 	int n, trap;
1455 	unsigned long base;
1456 	struct pt_regs regs;
1457 
1458 	if (scanhex(&base)) {
1459 		if (setjmp(bus_error_jmp) == 0) {
1460 			catch_memory_errors = 1;
1461 			sync();
1462 			regs = *(struct pt_regs *)base;
1463 			sync();
1464 			__delay(200);
1465 		} else {
1466 			catch_memory_errors = 0;
1467 			printf("*** Error reading registers from "REG"\n",
1468 			       base);
1469 			return;
1470 		}
1471 		catch_memory_errors = 0;
1472 		fp = &regs;
1473 	}
1474 
1475 #ifdef CONFIG_PPC64
1476 	if (FULL_REGS(fp)) {
1477 		for (n = 0; n < 16; ++n)
1478 			printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
1479 			       n, fp->gpr[n], n+16, fp->gpr[n+16]);
1480 	} else {
1481 		for (n = 0; n < 7; ++n)
1482 			printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
1483 			       n, fp->gpr[n], n+7, fp->gpr[n+7]);
1484 	}
1485 #else
1486 	for (n = 0; n < 32; ++n) {
1487 		printf("R%.2d = %.8x%s", n, fp->gpr[n],
1488 		       (n & 3) == 3? "\n": "   ");
1489 		if (n == 12 && !FULL_REGS(fp)) {
1490 			printf("\n");
1491 			break;
1492 		}
1493 	}
1494 #endif
1495 	printf("pc  = ");
1496 	xmon_print_symbol(fp->nip, " ", "\n");
1497 	if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1498 		printf("cfar= ");
1499 		xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1500 	}
1501 	printf("lr  = ");
1502 	xmon_print_symbol(fp->link, " ", "\n");
1503 	printf("msr = "REG"   cr  = %.8lx\n", fp->msr, fp->ccr);
1504 	printf("ctr = "REG"   xer = "REG"   trap = %4lx\n",
1505 	       fp->ctr, fp->xer, fp->trap);
1506 	trap = TRAP(fp);
1507 	if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1508 		printf("dar = "REG"   dsisr = %.8lx\n", fp->dar, fp->dsisr);
1509 }
1510 
cacheflush(void)1511 static void cacheflush(void)
1512 {
1513 	int cmd;
1514 	unsigned long nflush;
1515 
1516 	cmd = inchar();
1517 	if (cmd != 'i')
1518 		termch = cmd;
1519 	scanhex((void *)&adrs);
1520 	if (termch != '\n')
1521 		termch = 0;
1522 	nflush = 1;
1523 	scanhex(&nflush);
1524 	nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1525 	if (setjmp(bus_error_jmp) == 0) {
1526 		catch_memory_errors = 1;
1527 		sync();
1528 
1529 		if (cmd != 'i') {
1530 			for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1531 				cflush((void *) adrs);
1532 		} else {
1533 			for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1534 				cinval((void *) adrs);
1535 		}
1536 		sync();
1537 		/* wait a little while to see if we get a machine check */
1538 		__delay(200);
1539 	}
1540 	catch_memory_errors = 0;
1541 }
1542 
1543 static unsigned long
read_spr(int n)1544 read_spr(int n)
1545 {
1546 	unsigned int instrs[2];
1547 	unsigned long (*code)(void);
1548 	unsigned long ret = -1UL;
1549 #ifdef CONFIG_PPC64
1550 	unsigned long opd[3];
1551 
1552 	opd[0] = (unsigned long)instrs;
1553 	opd[1] = 0;
1554 	opd[2] = 0;
1555 	code = (unsigned long (*)(void)) opd;
1556 #else
1557 	code = (unsigned long (*)(void)) instrs;
1558 #endif
1559 
1560 	/* mfspr r3,n; blr */
1561 	instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1562 	instrs[1] = 0x4e800020;
1563 	store_inst(instrs);
1564 	store_inst(instrs+1);
1565 
1566 	if (setjmp(bus_error_jmp) == 0) {
1567 		catch_memory_errors = 1;
1568 		sync();
1569 
1570 		ret = code();
1571 
1572 		sync();
1573 		/* wait a little while to see if we get a machine check */
1574 		__delay(200);
1575 		n = size;
1576 	}
1577 
1578 	return ret;
1579 }
1580 
1581 static void
write_spr(int n,unsigned long val)1582 write_spr(int n, unsigned long val)
1583 {
1584 	unsigned int instrs[2];
1585 	unsigned long (*code)(unsigned long);
1586 #ifdef CONFIG_PPC64
1587 	unsigned long opd[3];
1588 
1589 	opd[0] = (unsigned long)instrs;
1590 	opd[1] = 0;
1591 	opd[2] = 0;
1592 	code = (unsigned long (*)(unsigned long)) opd;
1593 #else
1594 	code = (unsigned long (*)(unsigned long)) instrs;
1595 #endif
1596 
1597 	instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1598 	instrs[1] = 0x4e800020;
1599 	store_inst(instrs);
1600 	store_inst(instrs+1);
1601 
1602 	if (setjmp(bus_error_jmp) == 0) {
1603 		catch_memory_errors = 1;
1604 		sync();
1605 
1606 		code(val);
1607 
1608 		sync();
1609 		/* wait a little while to see if we get a machine check */
1610 		__delay(200);
1611 		n = size;
1612 	}
1613 }
1614 
1615 static unsigned long regno;
1616 extern char exc_prolog;
1617 extern char dec_exc;
1618 
super_regs(void)1619 static void super_regs(void)
1620 {
1621 	int cmd;
1622 	unsigned long val;
1623 
1624 	cmd = skipbl();
1625 	if (cmd == '\n') {
1626 	        unsigned long sp, toc;
1627 		asm("mr %0,1" : "=r" (sp) :);
1628 		asm("mr %0,2" : "=r" (toc) :);
1629 
1630 		printf("msr  = "REG"  sprg0= "REG"\n",
1631 		       mfmsr(), mfspr(SPRN_SPRG0));
1632 		printf("pvr  = "REG"  sprg1= "REG"\n",
1633 		       mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1634 		printf("dec  = "REG"  sprg2= "REG"\n",
1635 		       mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1636 		printf("sp   = "REG"  sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
1637 		printf("toc  = "REG"  dar  = "REG"\n", toc, mfspr(SPRN_DAR));
1638 
1639 		return;
1640 	}
1641 
1642 	scanhex(&regno);
1643 	switch (cmd) {
1644 	case 'w':
1645 		val = read_spr(regno);
1646 		scanhex(&val);
1647 		write_spr(regno, val);
1648 		/* fall through */
1649 	case 'r':
1650 		printf("spr %lx = %lx\n", regno, read_spr(regno));
1651 		break;
1652 	}
1653 	scannl();
1654 }
1655 
1656 /*
1657  * Stuff for reading and writing memory safely
1658  */
1659 static int
mread(unsigned long adrs,void * buf,int size)1660 mread(unsigned long adrs, void *buf, int size)
1661 {
1662 	volatile int n;
1663 	char *p, *q;
1664 
1665 	n = 0;
1666 	if (setjmp(bus_error_jmp) == 0) {
1667 		catch_memory_errors = 1;
1668 		sync();
1669 		p = (char *)adrs;
1670 		q = (char *)buf;
1671 		switch (size) {
1672 		case 2:
1673 			*(u16 *)q = *(u16 *)p;
1674 			break;
1675 		case 4:
1676 			*(u32 *)q = *(u32 *)p;
1677 			break;
1678 		case 8:
1679 			*(u64 *)q = *(u64 *)p;
1680 			break;
1681 		default:
1682 			for( ; n < size; ++n) {
1683 				*q++ = *p++;
1684 				sync();
1685 			}
1686 		}
1687 		sync();
1688 		/* wait a little while to see if we get a machine check */
1689 		__delay(200);
1690 		n = size;
1691 	}
1692 	catch_memory_errors = 0;
1693 	return n;
1694 }
1695 
1696 static int
mwrite(unsigned long adrs,void * buf,int size)1697 mwrite(unsigned long adrs, void *buf, int size)
1698 {
1699 	volatile int n;
1700 	char *p, *q;
1701 
1702 	n = 0;
1703 	if (setjmp(bus_error_jmp) == 0) {
1704 		catch_memory_errors = 1;
1705 		sync();
1706 		p = (char *) adrs;
1707 		q = (char *) buf;
1708 		switch (size) {
1709 		case 2:
1710 			*(u16 *)p = *(u16 *)q;
1711 			break;
1712 		case 4:
1713 			*(u32 *)p = *(u32 *)q;
1714 			break;
1715 		case 8:
1716 			*(u64 *)p = *(u64 *)q;
1717 			break;
1718 		default:
1719 			for ( ; n < size; ++n) {
1720 				*p++ = *q++;
1721 				sync();
1722 			}
1723 		}
1724 		sync();
1725 		/* wait a little while to see if we get a machine check */
1726 		__delay(200);
1727 		n = size;
1728 	} else {
1729 		printf("*** Error writing address %x\n", adrs + n);
1730 	}
1731 	catch_memory_errors = 0;
1732 	return n;
1733 }
1734 
1735 static int fault_type;
1736 static int fault_except;
1737 static char *fault_chars[] = { "--", "**", "##" };
1738 
handle_fault(struct pt_regs * regs)1739 static int handle_fault(struct pt_regs *regs)
1740 {
1741 	fault_except = TRAP(regs);
1742 	switch (TRAP(regs)) {
1743 	case 0x200:
1744 		fault_type = 0;
1745 		break;
1746 	case 0x300:
1747 	case 0x380:
1748 		fault_type = 1;
1749 		break;
1750 	default:
1751 		fault_type = 2;
1752 	}
1753 
1754 	longjmp(bus_error_jmp, 1);
1755 
1756 	return 0;
1757 }
1758 
1759 #define SWAP(a, b, t)	((t) = (a), (a) = (b), (b) = (t))
1760 
1761 static void
byterev(unsigned char * val,int size)1762 byterev(unsigned char *val, int size)
1763 {
1764 	int t;
1765 
1766 	switch (size) {
1767 	case 2:
1768 		SWAP(val[0], val[1], t);
1769 		break;
1770 	case 4:
1771 		SWAP(val[0], val[3], t);
1772 		SWAP(val[1], val[2], t);
1773 		break;
1774 	case 8: /* is there really any use for this? */
1775 		SWAP(val[0], val[7], t);
1776 		SWAP(val[1], val[6], t);
1777 		SWAP(val[2], val[5], t);
1778 		SWAP(val[3], val[4], t);
1779 		break;
1780 	}
1781 }
1782 
1783 static int brev;
1784 static int mnoread;
1785 
1786 static char *memex_help_string =
1787     "Memory examine command usage:\n"
1788     "m [addr] [flags] examine/change memory\n"
1789     "  addr is optional.  will start where left off.\n"
1790     "  flags may include chars from this set:\n"
1791     "    b   modify by bytes (default)\n"
1792     "    w   modify by words (2 byte)\n"
1793     "    l   modify by longs (4 byte)\n"
1794     "    d   modify by doubleword (8 byte)\n"
1795     "    r   toggle reverse byte order mode\n"
1796     "    n   do not read memory (for i/o spaces)\n"
1797     "    .   ok to read (default)\n"
1798     "NOTE: flags are saved as defaults\n"
1799     "";
1800 
1801 static char *memex_subcmd_help_string =
1802     "Memory examine subcommands:\n"
1803     "  hexval   write this val to current location\n"
1804     "  'string' write chars from string to this location\n"
1805     "  '        increment address\n"
1806     "  ^        decrement address\n"
1807     "  /        increment addr by 0x10.  //=0x100, ///=0x1000, etc\n"
1808     "  \\        decrement addr by 0x10.  \\\\=0x100, \\\\\\=0x1000, etc\n"
1809     "  `        clear no-read flag\n"
1810     "  ;        stay at this addr\n"
1811     "  v        change to byte mode\n"
1812     "  w        change to word (2 byte) mode\n"
1813     "  l        change to long (4 byte) mode\n"
1814     "  u        change to doubleword (8 byte) mode\n"
1815     "  m addr   change current addr\n"
1816     "  n        toggle no-read flag\n"
1817     "  r        toggle byte reverse flag\n"
1818     "  < count  back up count bytes\n"
1819     "  > count  skip forward count bytes\n"
1820     "  x        exit this mode\n"
1821     "";
1822 
1823 static void
memex(void)1824 memex(void)
1825 {
1826 	int cmd, inc, i, nslash;
1827 	unsigned long n;
1828 	unsigned char val[16];
1829 
1830 	scanhex((void *)&adrs);
1831 	cmd = skipbl();
1832 	if (cmd == '?') {
1833 		printf(memex_help_string);
1834 		return;
1835 	} else {
1836 		termch = cmd;
1837 	}
1838 	last_cmd = "m\n";
1839 	while ((cmd = skipbl()) != '\n') {
1840 		switch( cmd ){
1841 		case 'b':	size = 1;	break;
1842 		case 'w':	size = 2;	break;
1843 		case 'l':	size = 4;	break;
1844 		case 'd':	size = 8;	break;
1845 		case 'r': 	brev = !brev;	break;
1846 		case 'n':	mnoread = 1;	break;
1847 		case '.':	mnoread = 0;	break;
1848 		}
1849 	}
1850 	if( size <= 0 )
1851 		size = 1;
1852 	else if( size > 8 )
1853 		size = 8;
1854 	for(;;){
1855 		if (!mnoread)
1856 			n = mread(adrs, val, size);
1857 		printf(REG"%c", adrs, brev? 'r': ' ');
1858 		if (!mnoread) {
1859 			if (brev)
1860 				byterev(val, size);
1861 			putchar(' ');
1862 			for (i = 0; i < n; ++i)
1863 				printf("%.2x", val[i]);
1864 			for (; i < size; ++i)
1865 				printf("%s", fault_chars[fault_type]);
1866 		}
1867 		putchar(' ');
1868 		inc = size;
1869 		nslash = 0;
1870 		for(;;){
1871 			if( scanhex(&n) ){
1872 				for (i = 0; i < size; ++i)
1873 					val[i] = n >> (i * 8);
1874 				if (!brev)
1875 					byterev(val, size);
1876 				mwrite(adrs, val, size);
1877 				inc = size;
1878 			}
1879 			cmd = skipbl();
1880 			if (cmd == '\n')
1881 				break;
1882 			inc = 0;
1883 			switch (cmd) {
1884 			case '\'':
1885 				for(;;){
1886 					n = inchar();
1887 					if( n == '\\' )
1888 						n = bsesc();
1889 					else if( n == '\'' )
1890 						break;
1891 					for (i = 0; i < size; ++i)
1892 						val[i] = n >> (i * 8);
1893 					if (!brev)
1894 						byterev(val, size);
1895 					mwrite(adrs, val, size);
1896 					adrs += size;
1897 				}
1898 				adrs -= size;
1899 				inc = size;
1900 				break;
1901 			case ',':
1902 				adrs += size;
1903 				break;
1904 			case '.':
1905 				mnoread = 0;
1906 				break;
1907 			case ';':
1908 				break;
1909 			case 'x':
1910 			case EOF:
1911 				scannl();
1912 				return;
1913 			case 'b':
1914 			case 'v':
1915 				size = 1;
1916 				break;
1917 			case 'w':
1918 				size = 2;
1919 				break;
1920 			case 'l':
1921 				size = 4;
1922 				break;
1923 			case 'u':
1924 				size = 8;
1925 				break;
1926 			case '^':
1927 				adrs -= size;
1928 				break;
1929 				break;
1930 			case '/':
1931 				if (nslash > 0)
1932 					adrs -= 1 << nslash;
1933 				else
1934 					nslash = 0;
1935 				nslash += 4;
1936 				adrs += 1 << nslash;
1937 				break;
1938 			case '\\':
1939 				if (nslash < 0)
1940 					adrs += 1 << -nslash;
1941 				else
1942 					nslash = 0;
1943 				nslash -= 4;
1944 				adrs -= 1 << -nslash;
1945 				break;
1946 			case 'm':
1947 				scanhex((void *)&adrs);
1948 				break;
1949 			case 'n':
1950 				mnoread = 1;
1951 				break;
1952 			case 'r':
1953 				brev = !brev;
1954 				break;
1955 			case '<':
1956 				n = size;
1957 				scanhex(&n);
1958 				adrs -= n;
1959 				break;
1960 			case '>':
1961 				n = size;
1962 				scanhex(&n);
1963 				adrs += n;
1964 				break;
1965 			case '?':
1966 				printf(memex_subcmd_help_string);
1967 				break;
1968 			}
1969 		}
1970 		adrs += inc;
1971 	}
1972 }
1973 
1974 static int
bsesc(void)1975 bsesc(void)
1976 {
1977 	int c;
1978 
1979 	c = inchar();
1980 	switch( c ){
1981 	case 'n':	c = '\n';	break;
1982 	case 'r':	c = '\r';	break;
1983 	case 'b':	c = '\b';	break;
1984 	case 't':	c = '\t';	break;
1985 	}
1986 	return c;
1987 }
1988 
xmon_rawdump(unsigned long adrs,long ndump)1989 static void xmon_rawdump (unsigned long adrs, long ndump)
1990 {
1991 	long n, m, r, nr;
1992 	unsigned char temp[16];
1993 
1994 	for (n = ndump; n > 0;) {
1995 		r = n < 16? n: 16;
1996 		nr = mread(adrs, temp, r);
1997 		adrs += nr;
1998 		for (m = 0; m < r; ++m) {
1999 			if (m < nr)
2000 				printf("%.2x", temp[m]);
2001 			else
2002 				printf("%s", fault_chars[fault_type]);
2003 		}
2004 		n -= r;
2005 		if (nr < r)
2006 			break;
2007 	}
2008 	printf("\n");
2009 }
2010 
2011 #define isxdigit(c)	(('0' <= (c) && (c) <= '9') \
2012 			 || ('a' <= (c) && (c) <= 'f') \
2013 			 || ('A' <= (c) && (c) <= 'F'))
2014 static void
dump(void)2015 dump(void)
2016 {
2017 	int c;
2018 
2019 	c = inchar();
2020 	if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
2021 		termch = c;
2022 	scanhex((void *)&adrs);
2023 	if (termch != '\n')
2024 		termch = 0;
2025 	if (c == 'i') {
2026 		scanhex(&nidump);
2027 		if (nidump == 0)
2028 			nidump = 16;
2029 		else if (nidump > MAX_DUMP)
2030 			nidump = MAX_DUMP;
2031 		adrs += ppc_inst_dump(adrs, nidump, 1);
2032 		last_cmd = "di\n";
2033 	} else if (c == 'l') {
2034 		dump_log_buf();
2035 	} else if (c == 'r') {
2036 		scanhex(&ndump);
2037 		if (ndump == 0)
2038 			ndump = 64;
2039 		xmon_rawdump(adrs, ndump);
2040 		adrs += ndump;
2041 		last_cmd = "dr\n";
2042 	} else {
2043 		scanhex(&ndump);
2044 		if (ndump == 0)
2045 			ndump = 64;
2046 		else if (ndump > MAX_DUMP)
2047 			ndump = MAX_DUMP;
2048 		prdump(adrs, ndump);
2049 		adrs += ndump;
2050 		last_cmd = "d\n";
2051 	}
2052 }
2053 
2054 static void
prdump(unsigned long adrs,long ndump)2055 prdump(unsigned long adrs, long ndump)
2056 {
2057 	long n, m, c, r, nr;
2058 	unsigned char temp[16];
2059 
2060 	for (n = ndump; n > 0;) {
2061 		printf(REG, adrs);
2062 		putchar(' ');
2063 		r = n < 16? n: 16;
2064 		nr = mread(adrs, temp, r);
2065 		adrs += nr;
2066 		for (m = 0; m < r; ++m) {
2067 		        if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2068 				putchar(' ');
2069 			if (m < nr)
2070 				printf("%.2x", temp[m]);
2071 			else
2072 				printf("%s", fault_chars[fault_type]);
2073 		}
2074 		for (; m < 16; ++m) {
2075 		        if ((m & (sizeof(long) - 1)) == 0)
2076 				putchar(' ');
2077 			printf("  ");
2078 		}
2079 		printf("  |");
2080 		for (m = 0; m < r; ++m) {
2081 			if (m < nr) {
2082 				c = temp[m];
2083 				putchar(' ' <= c && c <= '~'? c: '.');
2084 			} else
2085 				putchar(' ');
2086 		}
2087 		n -= r;
2088 		for (; m < 16; ++m)
2089 			putchar(' ');
2090 		printf("|\n");
2091 		if (nr < r)
2092 			break;
2093 	}
2094 }
2095 
2096 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2097 
2098 static int
generic_inst_dump(unsigned long adr,long count,int praddr,instruction_dump_func dump_func)2099 generic_inst_dump(unsigned long adr, long count, int praddr,
2100 			instruction_dump_func dump_func)
2101 {
2102 	int nr, dotted;
2103 	unsigned long first_adr;
2104 	unsigned long inst, last_inst = 0;
2105 	unsigned char val[4];
2106 
2107 	dotted = 0;
2108 	for (first_adr = adr; count > 0; --count, adr += 4) {
2109 		nr = mread(adr, val, 4);
2110 		if (nr == 0) {
2111 			if (praddr) {
2112 				const char *x = fault_chars[fault_type];
2113 				printf(REG"  %s%s%s%s\n", adr, x, x, x, x);
2114 			}
2115 			break;
2116 		}
2117 		inst = GETWORD(val);
2118 		if (adr > first_adr && inst == last_inst) {
2119 			if (!dotted) {
2120 				printf(" ...\n");
2121 				dotted = 1;
2122 			}
2123 			continue;
2124 		}
2125 		dotted = 0;
2126 		last_inst = inst;
2127 		if (praddr)
2128 			printf(REG"  %.8x", adr, inst);
2129 		printf("\t");
2130 		dump_func(inst, adr);
2131 		printf("\n");
2132 	}
2133 	return adr - first_adr;
2134 }
2135 
2136 static int
ppc_inst_dump(unsigned long adr,long count,int praddr)2137 ppc_inst_dump(unsigned long adr, long count, int praddr)
2138 {
2139 	return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2140 }
2141 
2142 void
print_address(unsigned long addr)2143 print_address(unsigned long addr)
2144 {
2145 	xmon_print_symbol(addr, "\t# ", "");
2146 }
2147 
2148 void
dump_log_buf(void)2149 dump_log_buf(void)
2150 {
2151         const unsigned long size = 128;
2152         unsigned long end, addr;
2153         unsigned char buf[size + 1];
2154 
2155         addr = 0;
2156         buf[size] = '\0';
2157 
2158         if (setjmp(bus_error_jmp) != 0) {
2159                 printf("Unable to lookup symbol __log_buf!\n");
2160                 return;
2161         }
2162 
2163         catch_memory_errors = 1;
2164         sync();
2165         addr = kallsyms_lookup_name("__log_buf");
2166 
2167         if (! addr)
2168                 printf("Symbol __log_buf not found!\n");
2169         else {
2170                 end = addr + (1 << CONFIG_LOG_BUF_SHIFT);
2171                 while (addr < end) {
2172                         if (! mread(addr, buf, size)) {
2173                                 printf("Can't read memory at address 0x%lx\n", addr);
2174                                 break;
2175                         }
2176 
2177                         printf("%s", buf);
2178 
2179                         if (strlen(buf) < size)
2180                                 break;
2181 
2182                         addr += size;
2183                 }
2184         }
2185 
2186         sync();
2187         /* wait a little while to see if we get a machine check */
2188         __delay(200);
2189         catch_memory_errors = 0;
2190 }
2191 
2192 /*
2193  * Memory operations - move, set, print differences
2194  */
2195 static unsigned long mdest;		/* destination address */
2196 static unsigned long msrc;		/* source address */
2197 static unsigned long mval;		/* byte value to set memory to */
2198 static unsigned long mcount;		/* # bytes to affect */
2199 static unsigned long mdiffs;		/* max # differences to print */
2200 
2201 static void
memops(int cmd)2202 memops(int cmd)
2203 {
2204 	scanhex((void *)&mdest);
2205 	if( termch != '\n' )
2206 		termch = 0;
2207 	scanhex((void *)(cmd == 's'? &mval: &msrc));
2208 	if( termch != '\n' )
2209 		termch = 0;
2210 	scanhex((void *)&mcount);
2211 	switch( cmd ){
2212 	case 'm':
2213 		memmove((void *)mdest, (void *)msrc, mcount);
2214 		break;
2215 	case 's':
2216 		memset((void *)mdest, mval, mcount);
2217 		break;
2218 	case 'd':
2219 		if( termch != '\n' )
2220 			termch = 0;
2221 		scanhex((void *)&mdiffs);
2222 		memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2223 		break;
2224 	}
2225 }
2226 
2227 static void
memdiffs(unsigned char * p1,unsigned char * p2,unsigned nb,unsigned maxpr)2228 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2229 {
2230 	unsigned n, prt;
2231 
2232 	prt = 0;
2233 	for( n = nb; n > 0; --n )
2234 		if( *p1++ != *p2++ )
2235 			if( ++prt <= maxpr )
2236 				printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2237 					p1[-1], p2 - 1, p2[-1]);
2238 	if( prt > maxpr )
2239 		printf("Total of %d differences\n", prt);
2240 }
2241 
2242 static unsigned mend;
2243 static unsigned mask;
2244 
2245 static void
memlocate(void)2246 memlocate(void)
2247 {
2248 	unsigned a, n;
2249 	unsigned char val[4];
2250 
2251 	last_cmd = "ml";
2252 	scanhex((void *)&mdest);
2253 	if (termch != '\n') {
2254 		termch = 0;
2255 		scanhex((void *)&mend);
2256 		if (termch != '\n') {
2257 			termch = 0;
2258 			scanhex((void *)&mval);
2259 			mask = ~0;
2260 			if (termch != '\n') termch = 0;
2261 			scanhex((void *)&mask);
2262 		}
2263 	}
2264 	n = 0;
2265 	for (a = mdest; a < mend; a += 4) {
2266 		if (mread(a, val, 4) == 4
2267 			&& ((GETWORD(val) ^ mval) & mask) == 0) {
2268 			printf("%.16x:  %.16x\n", a, GETWORD(val));
2269 			if (++n >= 10)
2270 				break;
2271 		}
2272 	}
2273 }
2274 
2275 static unsigned long mskip = 0x1000;
2276 static unsigned long mlim = 0xffffffff;
2277 
2278 static void
memzcan(void)2279 memzcan(void)
2280 {
2281 	unsigned char v;
2282 	unsigned a;
2283 	int ok, ook;
2284 
2285 	scanhex(&mdest);
2286 	if (termch != '\n') termch = 0;
2287 	scanhex(&mskip);
2288 	if (termch != '\n') termch = 0;
2289 	scanhex(&mlim);
2290 	ook = 0;
2291 	for (a = mdest; a < mlim; a += mskip) {
2292 		ok = mread(a, &v, 1);
2293 		if (ok && !ook) {
2294 			printf("%.8x .. ", a);
2295 		} else if (!ok && ook)
2296 			printf("%.8x\n", a - mskip);
2297 		ook = ok;
2298 		if (a + mskip < a)
2299 			break;
2300 	}
2301 	if (ook)
2302 		printf("%.8x\n", a - mskip);
2303 }
2304 
proccall(void)2305 static void proccall(void)
2306 {
2307 	unsigned long args[8];
2308 	unsigned long ret;
2309 	int i;
2310 	typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2311 			unsigned long, unsigned long, unsigned long,
2312 			unsigned long, unsigned long, unsigned long);
2313 	callfunc_t func;
2314 
2315 	if (!scanhex(&adrs))
2316 		return;
2317 	if (termch != '\n')
2318 		termch = 0;
2319 	for (i = 0; i < 8; ++i)
2320 		args[i] = 0;
2321 	for (i = 0; i < 8; ++i) {
2322 		if (!scanhex(&args[i]) || termch == '\n')
2323 			break;
2324 		termch = 0;
2325 	}
2326 	func = (callfunc_t) adrs;
2327 	ret = 0;
2328 	if (setjmp(bus_error_jmp) == 0) {
2329 		catch_memory_errors = 1;
2330 		sync();
2331 		ret = func(args[0], args[1], args[2], args[3],
2332 			   args[4], args[5], args[6], args[7]);
2333 		sync();
2334 		printf("return value is %x\n", ret);
2335 	} else {
2336 		printf("*** %x exception occurred\n", fault_except);
2337 	}
2338 	catch_memory_errors = 0;
2339 }
2340 
2341 /* Input scanning routines */
2342 int
skipbl(void)2343 skipbl(void)
2344 {
2345 	int c;
2346 
2347 	if( termch != 0 ){
2348 		c = termch;
2349 		termch = 0;
2350 	} else
2351 		c = inchar();
2352 	while( c == ' ' || c == '\t' )
2353 		c = inchar();
2354 	return c;
2355 }
2356 
2357 #define N_PTREGS	44
2358 static char *regnames[N_PTREGS] = {
2359 	"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2360 	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2361 	"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2362 	"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2363 	"pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2364 #ifdef CONFIG_PPC64
2365 	"softe",
2366 #else
2367 	"mq",
2368 #endif
2369 	"trap", "dar", "dsisr", "res"
2370 };
2371 
2372 int
scanhex(unsigned long * vp)2373 scanhex(unsigned long *vp)
2374 {
2375 	int c, d;
2376 	unsigned long v;
2377 
2378 	c = skipbl();
2379 	if (c == '%') {
2380 		/* parse register name */
2381 		char regname[8];
2382 		int i;
2383 
2384 		for (i = 0; i < sizeof(regname) - 1; ++i) {
2385 			c = inchar();
2386 			if (!isalnum(c)) {
2387 				termch = c;
2388 				break;
2389 			}
2390 			regname[i] = c;
2391 		}
2392 		regname[i] = 0;
2393 		for (i = 0; i < N_PTREGS; ++i) {
2394 			if (strcmp(regnames[i], regname) == 0) {
2395 				if (xmon_regs == NULL) {
2396 					printf("regs not available\n");
2397 					return 0;
2398 				}
2399 				*vp = ((unsigned long *)xmon_regs)[i];
2400 				return 1;
2401 			}
2402 		}
2403 		printf("invalid register name '%%%s'\n", regname);
2404 		return 0;
2405 	}
2406 
2407 	/* skip leading "0x" if any */
2408 
2409 	if (c == '0') {
2410 		c = inchar();
2411 		if (c == 'x') {
2412 			c = inchar();
2413 		} else {
2414 			d = hexdigit(c);
2415 			if (d == EOF) {
2416 				termch = c;
2417 				*vp = 0;
2418 				return 1;
2419 			}
2420 		}
2421 	} else if (c == '$') {
2422 		int i;
2423 		for (i=0; i<63; i++) {
2424 			c = inchar();
2425 			if (isspace(c)) {
2426 				termch = c;
2427 				break;
2428 			}
2429 			tmpstr[i] = c;
2430 		}
2431 		tmpstr[i++] = 0;
2432 		*vp = 0;
2433 		if (setjmp(bus_error_jmp) == 0) {
2434 			catch_memory_errors = 1;
2435 			sync();
2436 			*vp = kallsyms_lookup_name(tmpstr);
2437 			sync();
2438 		}
2439 		catch_memory_errors = 0;
2440 		if (!(*vp)) {
2441 			printf("unknown symbol '%s'\n", tmpstr);
2442 			return 0;
2443 		}
2444 		return 1;
2445 	}
2446 
2447 	d = hexdigit(c);
2448 	if (d == EOF) {
2449 		termch = c;
2450 		return 0;
2451 	}
2452 	v = 0;
2453 	do {
2454 		v = (v << 4) + d;
2455 		c = inchar();
2456 		d = hexdigit(c);
2457 	} while (d != EOF);
2458 	termch = c;
2459 	*vp = v;
2460 	return 1;
2461 }
2462 
2463 static void
scannl(void)2464 scannl(void)
2465 {
2466 	int c;
2467 
2468 	c = termch;
2469 	termch = 0;
2470 	while( c != '\n' )
2471 		c = inchar();
2472 }
2473 
hexdigit(int c)2474 static int hexdigit(int c)
2475 {
2476 	if( '0' <= c && c <= '9' )
2477 		return c - '0';
2478 	if( 'A' <= c && c <= 'F' )
2479 		return c - ('A' - 10);
2480 	if( 'a' <= c && c <= 'f' )
2481 		return c - ('a' - 10);
2482 	return EOF;
2483 }
2484 
2485 void
getstring(char * s,int size)2486 getstring(char *s, int size)
2487 {
2488 	int c;
2489 
2490 	c = skipbl();
2491 	do {
2492 		if( size > 1 ){
2493 			*s++ = c;
2494 			--size;
2495 		}
2496 		c = inchar();
2497 	} while( c != ' ' && c != '\t' && c != '\n' );
2498 	termch = c;
2499 	*s = 0;
2500 }
2501 
2502 static char line[256];
2503 static char *lineptr;
2504 
2505 static void
flush_input(void)2506 flush_input(void)
2507 {
2508 	lineptr = NULL;
2509 }
2510 
2511 static int
inchar(void)2512 inchar(void)
2513 {
2514 	if (lineptr == NULL || *lineptr == 0) {
2515 		if (xmon_gets(line, sizeof(line)) == NULL) {
2516 			lineptr = NULL;
2517 			return EOF;
2518 		}
2519 		lineptr = line;
2520 	}
2521 	return *lineptr++;
2522 }
2523 
2524 static void
take_input(char * str)2525 take_input(char *str)
2526 {
2527 	lineptr = str;
2528 }
2529 
2530 
2531 static void
symbol_lookup(void)2532 symbol_lookup(void)
2533 {
2534 	int type = inchar();
2535 	unsigned long addr;
2536 	static char tmp[64];
2537 
2538 	switch (type) {
2539 	case 'a':
2540 		if (scanhex(&addr))
2541 			xmon_print_symbol(addr, ": ", "\n");
2542 		termch = 0;
2543 		break;
2544 	case 's':
2545 		getstring(tmp, 64);
2546 		if (setjmp(bus_error_jmp) == 0) {
2547 			catch_memory_errors = 1;
2548 			sync();
2549 			addr = kallsyms_lookup_name(tmp);
2550 			if (addr)
2551 				printf("%s: %lx\n", tmp, addr);
2552 			else
2553 				printf("Symbol '%s' not found.\n", tmp);
2554 			sync();
2555 		}
2556 		catch_memory_errors = 0;
2557 		termch = 0;
2558 		break;
2559 	}
2560 }
2561 
2562 
2563 /* Print an address in numeric and symbolic form (if possible) */
xmon_print_symbol(unsigned long address,const char * mid,const char * after)2564 static void xmon_print_symbol(unsigned long address, const char *mid,
2565 			      const char *after)
2566 {
2567 	char *modname;
2568 	const char *name = NULL;
2569 	unsigned long offset, size;
2570 
2571 	printf(REG, address);
2572 	if (setjmp(bus_error_jmp) == 0) {
2573 		catch_memory_errors = 1;
2574 		sync();
2575 		name = kallsyms_lookup(address, &size, &offset, &modname,
2576 				       tmpstr);
2577 		sync();
2578 		/* wait a little while to see if we get a machine check */
2579 		__delay(200);
2580 	}
2581 
2582 	catch_memory_errors = 0;
2583 
2584 	if (name) {
2585 		printf("%s%s+%#lx/%#lx", mid, name, offset, size);
2586 		if (modname)
2587 			printf(" [%s]", modname);
2588 	}
2589 	printf("%s", after);
2590 }
2591 
2592 #ifdef CONFIG_PPC_BOOK3S_64
dump_slb(void)2593 static void dump_slb(void)
2594 {
2595 	int i;
2596 	unsigned long esid,vsid,valid;
2597 	unsigned long llp;
2598 
2599 	printf("SLB contents of cpu %x\n", smp_processor_id());
2600 
2601 	for (i = 0; i < mmu_slb_size; i++) {
2602 		asm volatile("slbmfee  %0,%1" : "=r" (esid) : "r" (i));
2603 		asm volatile("slbmfev  %0,%1" : "=r" (vsid) : "r" (i));
2604 		valid = (esid & SLB_ESID_V);
2605 		if (valid | esid | vsid) {
2606 			printf("%02d %016lx %016lx", i, esid, vsid);
2607 			if (valid) {
2608 				llp = vsid & SLB_VSID_LLP;
2609 				if (vsid & SLB_VSID_B_1T) {
2610 					printf("  1T  ESID=%9lx  VSID=%13lx LLP:%3lx \n",
2611 						GET_ESID_1T(esid),
2612 						(vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
2613 						llp);
2614 				} else {
2615 					printf(" 256M ESID=%9lx  VSID=%13lx LLP:%3lx \n",
2616 						GET_ESID(esid),
2617 						(vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
2618 						llp);
2619 				}
2620 			} else
2621 				printf("\n");
2622 		}
2623 	}
2624 }
2625 
dump_stab(void)2626 static void dump_stab(void)
2627 {
2628 	int i;
2629 	unsigned long *tmp = (unsigned long *)local_paca->stab_addr;
2630 
2631 	printf("Segment table contents of cpu %x\n", smp_processor_id());
2632 
2633 	for (i = 0; i < PAGE_SIZE/16; i++) {
2634 		unsigned long a, b;
2635 
2636 		a = *tmp++;
2637 		b = *tmp++;
2638 
2639 		if (a || b) {
2640 			printf("%03d %016lx ", i, a);
2641 			printf("%016lx\n", b);
2642 		}
2643 	}
2644 }
2645 
dump_segments(void)2646 void dump_segments(void)
2647 {
2648 	if (mmu_has_feature(MMU_FTR_SLB))
2649 		dump_slb();
2650 	else
2651 		dump_stab();
2652 }
2653 #endif
2654 
2655 #ifdef CONFIG_PPC_STD_MMU_32
dump_segments(void)2656 void dump_segments(void)
2657 {
2658 	int i;
2659 
2660 	printf("sr0-15 =");
2661 	for (i = 0; i < 16; ++i)
2662 		printf(" %x", mfsrin(i));
2663 	printf("\n");
2664 }
2665 #endif
2666 
2667 #ifdef CONFIG_44x
dump_tlb_44x(void)2668 static void dump_tlb_44x(void)
2669 {
2670 	int i;
2671 
2672 	for (i = 0; i < PPC44x_TLB_SIZE; i++) {
2673 		unsigned long w0,w1,w2;
2674 		asm volatile("tlbre  %0,%1,0" : "=r" (w0) : "r" (i));
2675 		asm volatile("tlbre  %0,%1,1" : "=r" (w1) : "r" (i));
2676 		asm volatile("tlbre  %0,%1,2" : "=r" (w2) : "r" (i));
2677 		printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
2678 		if (w0 & PPC44x_TLB_VALID) {
2679 			printf("V %08x -> %01x%08x %c%c%c%c%c",
2680 			       w0 & PPC44x_TLB_EPN_MASK,
2681 			       w1 & PPC44x_TLB_ERPN_MASK,
2682 			       w1 & PPC44x_TLB_RPN_MASK,
2683 			       (w2 & PPC44x_TLB_W) ? 'W' : 'w',
2684 			       (w2 & PPC44x_TLB_I) ? 'I' : 'i',
2685 			       (w2 & PPC44x_TLB_M) ? 'M' : 'm',
2686 			       (w2 & PPC44x_TLB_G) ? 'G' : 'g',
2687 			       (w2 & PPC44x_TLB_E) ? 'E' : 'e');
2688 		}
2689 		printf("\n");
2690 	}
2691 }
2692 #endif /* CONFIG_44x */
2693 
2694 #ifdef CONFIG_PPC_BOOK3E
dump_tlb_book3e(void)2695 static void dump_tlb_book3e(void)
2696 {
2697 	u32 mmucfg, pidmask, lpidmask;
2698 	u64 ramask;
2699 	int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
2700 	int mmu_version;
2701 	static const char *pgsz_names[] = {
2702 		"  1K",
2703 		"  2K",
2704 		"  4K",
2705 		"  8K",
2706 		" 16K",
2707 		" 32K",
2708 		" 64K",
2709 		"128K",
2710 		"256K",
2711 		"512K",
2712 		"  1M",
2713 		"  2M",
2714 		"  4M",
2715 		"  8M",
2716 		" 16M",
2717 		" 32M",
2718 		" 64M",
2719 		"128M",
2720 		"256M",
2721 		"512M",
2722 		"  1G",
2723 		"  2G",
2724 		"  4G",
2725 		"  8G",
2726 		" 16G",
2727 		" 32G",
2728 		" 64G",
2729 		"128G",
2730 		"256G",
2731 		"512G",
2732 		"  1T",
2733 		"  2T",
2734 	};
2735 
2736 	/* Gather some infos about the MMU */
2737 	mmucfg = mfspr(SPRN_MMUCFG);
2738 	mmu_version = (mmucfg & 3) + 1;
2739 	ntlbs = ((mmucfg >> 2) & 3) + 1;
2740 	pidsz = ((mmucfg >> 6) & 0x1f) + 1;
2741 	lpidsz = (mmucfg >> 24) & 0xf;
2742 	rasz = (mmucfg >> 16) & 0x7f;
2743 	if ((mmu_version > 1) && (mmucfg & 0x10000))
2744 		lrat = 1;
2745 	printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
2746 	       mmu_version, ntlbs, pidsz, lpidsz, rasz);
2747 	pidmask = (1ul << pidsz) - 1;
2748 	lpidmask = (1ul << lpidsz) - 1;
2749 	ramask = (1ull << rasz) - 1;
2750 
2751 	for (tlb = 0; tlb < ntlbs; tlb++) {
2752 		u32 tlbcfg;
2753 		int nent, assoc, new_cc = 1;
2754 		printf("TLB %d:\n------\n", tlb);
2755 		switch(tlb) {
2756 		case 0:
2757 			tlbcfg = mfspr(SPRN_TLB0CFG);
2758 			break;
2759 		case 1:
2760 			tlbcfg = mfspr(SPRN_TLB1CFG);
2761 			break;
2762 		case 2:
2763 			tlbcfg = mfspr(SPRN_TLB2CFG);
2764 			break;
2765 		case 3:
2766 			tlbcfg = mfspr(SPRN_TLB3CFG);
2767 			break;
2768 		default:
2769 			printf("Unsupported TLB number !\n");
2770 			continue;
2771 		}
2772 		nent = tlbcfg & 0xfff;
2773 		assoc = (tlbcfg >> 24) & 0xff;
2774 		for (i = 0; i < nent; i++) {
2775 			u32 mas0 = MAS0_TLBSEL(tlb);
2776 			u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
2777 			u64 mas2 = 0;
2778 			u64 mas7_mas3;
2779 			int esel = i, cc = i;
2780 
2781 			if (assoc != 0) {
2782 				cc = i / assoc;
2783 				esel = i % assoc;
2784 				mas2 = cc * 0x1000;
2785 			}
2786 
2787 			mas0 |= MAS0_ESEL(esel);
2788 			mtspr(SPRN_MAS0, mas0);
2789 			mtspr(SPRN_MAS1, mas1);
2790 			mtspr(SPRN_MAS2, mas2);
2791 			asm volatile("tlbre  0,0,0" : : : "memory");
2792 			mas1 = mfspr(SPRN_MAS1);
2793 			mas2 = mfspr(SPRN_MAS2);
2794 			mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
2795 			if (assoc && (i % assoc) == 0)
2796 				new_cc = 1;
2797 			if (!(mas1 & MAS1_VALID))
2798 				continue;
2799 			if (assoc == 0)
2800 				printf("%04x- ", i);
2801 			else if (new_cc)
2802 				printf("%04x-%c", cc, 'A' + esel);
2803 			else
2804 				printf("    |%c", 'A' + esel);
2805 			new_cc = 0;
2806 			printf(" %016llx %04x %s %c%c AS%c",
2807 			       mas2 & ~0x3ffull,
2808 			       (mas1 >> 16) & 0x3fff,
2809 			       pgsz_names[(mas1 >> 7) & 0x1f],
2810 			       mas1 & MAS1_IND ? 'I' : ' ',
2811 			       mas1 & MAS1_IPROT ? 'P' : ' ',
2812 			       mas1 & MAS1_TS ? '1' : '0');
2813 			printf(" %c%c%c%c%c%c%c",
2814 			       mas2 & MAS2_X0 ? 'a' : ' ',
2815 			       mas2 & MAS2_X1 ? 'v' : ' ',
2816 			       mas2 & MAS2_W  ? 'w' : ' ',
2817 			       mas2 & MAS2_I  ? 'i' : ' ',
2818 			       mas2 & MAS2_M  ? 'm' : ' ',
2819 			       mas2 & MAS2_G  ? 'g' : ' ',
2820 			       mas2 & MAS2_E  ? 'e' : ' ');
2821 			printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
2822 			if (mas1 & MAS1_IND)
2823 				printf(" %s\n",
2824 				       pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
2825 			else
2826 				printf(" U%c%c%c S%c%c%c\n",
2827 				       mas7_mas3 & MAS3_UX ? 'x' : ' ',
2828 				       mas7_mas3 & MAS3_UW ? 'w' : ' ',
2829 				       mas7_mas3 & MAS3_UR ? 'r' : ' ',
2830 				       mas7_mas3 & MAS3_SX ? 'x' : ' ',
2831 				       mas7_mas3 & MAS3_SW ? 'w' : ' ',
2832 				       mas7_mas3 & MAS3_SR ? 'r' : ' ');
2833 		}
2834 	}
2835 }
2836 #endif /* CONFIG_PPC_BOOK3E */
2837 
xmon_init(int enable)2838 static void xmon_init(int enable)
2839 {
2840 	if (enable) {
2841 		__debugger = xmon;
2842 		__debugger_ipi = xmon_ipi;
2843 		__debugger_bpt = xmon_bpt;
2844 		__debugger_sstep = xmon_sstep;
2845 		__debugger_iabr_match = xmon_iabr_match;
2846 		__debugger_dabr_match = xmon_dabr_match;
2847 		__debugger_fault_handler = xmon_fault_handler;
2848 	} else {
2849 		__debugger = NULL;
2850 		__debugger_ipi = NULL;
2851 		__debugger_bpt = NULL;
2852 		__debugger_sstep = NULL;
2853 		__debugger_iabr_match = NULL;
2854 		__debugger_dabr_match = NULL;
2855 		__debugger_fault_handler = NULL;
2856 	}
2857 	xmon_map_scc();
2858 }
2859 
2860 #ifdef CONFIG_MAGIC_SYSRQ
sysrq_handle_xmon(int key)2861 static void sysrq_handle_xmon(int key)
2862 {
2863 	/* ensure xmon is enabled */
2864 	xmon_init(1);
2865 	debugger(get_irq_regs());
2866 }
2867 
2868 static struct sysrq_key_op sysrq_xmon_op = {
2869 	.handler =	sysrq_handle_xmon,
2870 	.help_msg =	"Xmon",
2871 	.action_msg =	"Entering xmon",
2872 };
2873 
setup_xmon_sysrq(void)2874 static int __init setup_xmon_sysrq(void)
2875 {
2876 	register_sysrq_key('x', &sysrq_xmon_op);
2877 	return 0;
2878 }
2879 __initcall(setup_xmon_sysrq);
2880 #endif /* CONFIG_MAGIC_SYSRQ */
2881 
2882 static int __initdata xmon_early, xmon_off;
2883 
early_parse_xmon(char * p)2884 static int __init early_parse_xmon(char *p)
2885 {
2886 	if (!p || strncmp(p, "early", 5) == 0) {
2887 		/* just "xmon" is equivalent to "xmon=early" */
2888 		xmon_init(1);
2889 		xmon_early = 1;
2890 	} else if (strncmp(p, "on", 2) == 0)
2891 		xmon_init(1);
2892 	else if (strncmp(p, "off", 3) == 0)
2893 		xmon_off = 1;
2894 	else if (strncmp(p, "nobt", 4) == 0)
2895 		xmon_no_auto_backtrace = 1;
2896 	else
2897 		return 1;
2898 
2899 	return 0;
2900 }
2901 early_param("xmon", early_parse_xmon);
2902 
xmon_setup(void)2903 void __init xmon_setup(void)
2904 {
2905 #ifdef CONFIG_XMON_DEFAULT
2906 	if (!xmon_off)
2907 		xmon_init(1);
2908 #endif
2909 	if (xmon_early)
2910 		debugger(NULL);
2911 }
2912 
2913 #ifdef CONFIG_SPU_BASE
2914 
2915 struct spu_info {
2916 	struct spu *spu;
2917 	u64 saved_mfc_sr1_RW;
2918 	u32 saved_spu_runcntl_RW;
2919 	unsigned long dump_addr;
2920 	u8 stopped_ok;
2921 };
2922 
2923 #define XMON_NUM_SPUS	16	/* Enough for current hardware */
2924 
2925 static struct spu_info spu_info[XMON_NUM_SPUS];
2926 
xmon_register_spus(struct list_head * list)2927 void xmon_register_spus(struct list_head *list)
2928 {
2929 	struct spu *spu;
2930 
2931 	list_for_each_entry(spu, list, full_list) {
2932 		if (spu->number >= XMON_NUM_SPUS) {
2933 			WARN_ON(1);
2934 			continue;
2935 		}
2936 
2937 		spu_info[spu->number].spu = spu;
2938 		spu_info[spu->number].stopped_ok = 0;
2939 		spu_info[spu->number].dump_addr = (unsigned long)
2940 				spu_info[spu->number].spu->local_store;
2941 	}
2942 }
2943 
stop_spus(void)2944 static void stop_spus(void)
2945 {
2946 	struct spu *spu;
2947 	int i;
2948 	u64 tmp;
2949 
2950 	for (i = 0; i < XMON_NUM_SPUS; i++) {
2951 		if (!spu_info[i].spu)
2952 			continue;
2953 
2954 		if (setjmp(bus_error_jmp) == 0) {
2955 			catch_memory_errors = 1;
2956 			sync();
2957 
2958 			spu = spu_info[i].spu;
2959 
2960 			spu_info[i].saved_spu_runcntl_RW =
2961 				in_be32(&spu->problem->spu_runcntl_RW);
2962 
2963 			tmp = spu_mfc_sr1_get(spu);
2964 			spu_info[i].saved_mfc_sr1_RW = tmp;
2965 
2966 			tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
2967 			spu_mfc_sr1_set(spu, tmp);
2968 
2969 			sync();
2970 			__delay(200);
2971 
2972 			spu_info[i].stopped_ok = 1;
2973 
2974 			printf("Stopped spu %.2d (was %s)\n", i,
2975 					spu_info[i].saved_spu_runcntl_RW ?
2976 					"running" : "stopped");
2977 		} else {
2978 			catch_memory_errors = 0;
2979 			printf("*** Error stopping spu %.2d\n", i);
2980 		}
2981 		catch_memory_errors = 0;
2982 	}
2983 }
2984 
restart_spus(void)2985 static void restart_spus(void)
2986 {
2987 	struct spu *spu;
2988 	int i;
2989 
2990 	for (i = 0; i < XMON_NUM_SPUS; i++) {
2991 		if (!spu_info[i].spu)
2992 			continue;
2993 
2994 		if (!spu_info[i].stopped_ok) {
2995 			printf("*** Error, spu %d was not successfully stopped"
2996 					", not restarting\n", i);
2997 			continue;
2998 		}
2999 
3000 		if (setjmp(bus_error_jmp) == 0) {
3001 			catch_memory_errors = 1;
3002 			sync();
3003 
3004 			spu = spu_info[i].spu;
3005 			spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3006 			out_be32(&spu->problem->spu_runcntl_RW,
3007 					spu_info[i].saved_spu_runcntl_RW);
3008 
3009 			sync();
3010 			__delay(200);
3011 
3012 			printf("Restarted spu %.2d\n", i);
3013 		} else {
3014 			catch_memory_errors = 0;
3015 			printf("*** Error restarting spu %.2d\n", i);
3016 		}
3017 		catch_memory_errors = 0;
3018 	}
3019 }
3020 
3021 #define DUMP_WIDTH	23
3022 #define DUMP_VALUE(format, field, value)				\
3023 do {									\
3024 	if (setjmp(bus_error_jmp) == 0) {				\
3025 		catch_memory_errors = 1;				\
3026 		sync();							\
3027 		printf("  %-*s = "format"\n", DUMP_WIDTH,		\
3028 				#field, value);				\
3029 		sync();							\
3030 		__delay(200);						\
3031 	} else {							\
3032 		catch_memory_errors = 0;				\
3033 		printf("  %-*s = *** Error reading field.\n",		\
3034 					DUMP_WIDTH, #field);		\
3035 	}								\
3036 	catch_memory_errors = 0;					\
3037 } while (0)
3038 
3039 #define DUMP_FIELD(obj, format, field)	\
3040 	DUMP_VALUE(format, field, obj->field)
3041 
dump_spu_fields(struct spu * spu)3042 static void dump_spu_fields(struct spu *spu)
3043 {
3044 	printf("Dumping spu fields at address %p:\n", spu);
3045 
3046 	DUMP_FIELD(spu, "0x%x", number);
3047 	DUMP_FIELD(spu, "%s", name);
3048 	DUMP_FIELD(spu, "0x%lx", local_store_phys);
3049 	DUMP_FIELD(spu, "0x%p", local_store);
3050 	DUMP_FIELD(spu, "0x%lx", ls_size);
3051 	DUMP_FIELD(spu, "0x%x", node);
3052 	DUMP_FIELD(spu, "0x%lx", flags);
3053 	DUMP_FIELD(spu, "%d", class_0_pending);
3054 	DUMP_FIELD(spu, "0x%lx", class_0_dar);
3055 	DUMP_FIELD(spu, "0x%lx", class_1_dar);
3056 	DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
3057 	DUMP_FIELD(spu, "0x%lx", irqs[0]);
3058 	DUMP_FIELD(spu, "0x%lx", irqs[1]);
3059 	DUMP_FIELD(spu, "0x%lx", irqs[2]);
3060 	DUMP_FIELD(spu, "0x%x", slb_replace);
3061 	DUMP_FIELD(spu, "%d", pid);
3062 	DUMP_FIELD(spu, "0x%p", mm);
3063 	DUMP_FIELD(spu, "0x%p", ctx);
3064 	DUMP_FIELD(spu, "0x%p", rq);
3065 	DUMP_FIELD(spu, "0x%p", timestamp);
3066 	DUMP_FIELD(spu, "0x%lx", problem_phys);
3067 	DUMP_FIELD(spu, "0x%p", problem);
3068 	DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
3069 			in_be32(&spu->problem->spu_runcntl_RW));
3070 	DUMP_VALUE("0x%x", problem->spu_status_R,
3071 			in_be32(&spu->problem->spu_status_R));
3072 	DUMP_VALUE("0x%x", problem->spu_npc_RW,
3073 			in_be32(&spu->problem->spu_npc_RW));
3074 	DUMP_FIELD(spu, "0x%p", priv2);
3075 	DUMP_FIELD(spu, "0x%p", pdata);
3076 }
3077 
3078 int
spu_inst_dump(unsigned long adr,long count,int praddr)3079 spu_inst_dump(unsigned long adr, long count, int praddr)
3080 {
3081 	return generic_inst_dump(adr, count, praddr, print_insn_spu);
3082 }
3083 
dump_spu_ls(unsigned long num,int subcmd)3084 static void dump_spu_ls(unsigned long num, int subcmd)
3085 {
3086 	unsigned long offset, addr, ls_addr;
3087 
3088 	if (setjmp(bus_error_jmp) == 0) {
3089 		catch_memory_errors = 1;
3090 		sync();
3091 		ls_addr = (unsigned long)spu_info[num].spu->local_store;
3092 		sync();
3093 		__delay(200);
3094 	} else {
3095 		catch_memory_errors = 0;
3096 		printf("*** Error: accessing spu info for spu %d\n", num);
3097 		return;
3098 	}
3099 	catch_memory_errors = 0;
3100 
3101 	if (scanhex(&offset))
3102 		addr = ls_addr + offset;
3103 	else
3104 		addr = spu_info[num].dump_addr;
3105 
3106 	if (addr >= ls_addr + LS_SIZE) {
3107 		printf("*** Error: address outside of local store\n");
3108 		return;
3109 	}
3110 
3111 	switch (subcmd) {
3112 	case 'i':
3113 		addr += spu_inst_dump(addr, 16, 1);
3114 		last_cmd = "sdi\n";
3115 		break;
3116 	default:
3117 		prdump(addr, 64);
3118 		addr += 64;
3119 		last_cmd = "sd\n";
3120 		break;
3121 	}
3122 
3123 	spu_info[num].dump_addr = addr;
3124 }
3125 
do_spu_cmd(void)3126 static int do_spu_cmd(void)
3127 {
3128 	static unsigned long num = 0;
3129 	int cmd, subcmd = 0;
3130 
3131 	cmd = inchar();
3132 	switch (cmd) {
3133 	case 's':
3134 		stop_spus();
3135 		break;
3136 	case 'r':
3137 		restart_spus();
3138 		break;
3139 	case 'd':
3140 		subcmd = inchar();
3141 		if (isxdigit(subcmd) || subcmd == '\n')
3142 			termch = subcmd;
3143 	case 'f':
3144 		scanhex(&num);
3145 		if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
3146 			printf("*** Error: invalid spu number\n");
3147 			return 0;
3148 		}
3149 
3150 		switch (cmd) {
3151 		case 'f':
3152 			dump_spu_fields(spu_info[num].spu);
3153 			break;
3154 		default:
3155 			dump_spu_ls(num, subcmd);
3156 			break;
3157 		}
3158 
3159 		break;
3160 	default:
3161 		return -1;
3162 	}
3163 
3164 	return 0;
3165 }
3166 #else /* ! CONFIG_SPU_BASE */
do_spu_cmd(void)3167 static int do_spu_cmd(void)
3168 {
3169 	return -1;
3170 }
3171 #endif
3172