1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright 2018 Joyent, Inc.
27  */
28 
29 /*
30  * isa-dependent portions of the kmdb target
31  */
32 
33 #include <mdb/mdb_kreg_impl.h>
34 #include <mdb/mdb_debug.h>
35 #include <mdb/mdb_modapi.h>
36 #include <mdb/mdb_v9util.h>
37 #include <mdb/mdb_target_impl.h>
38 #include <mdb/mdb_err.h>
39 #include <mdb/mdb_umem.h>
40 #include <kmdb/kmdb_kdi.h>
41 #include <kmdb/kmdb_dpi.h>
42 #include <kmdb/kmdb_promif.h>
43 #include <kmdb/kmdb_asmutil.h>
44 #include <kmdb/kvm.h>
45 #include <mdb/mdb.h>
46 
47 #include <sys/types.h>
48 #include <sys/stack.h>
49 #include <sys/regset.h>
50 #include <sys/sysmacros.h>
51 #include <sys/bitmap.h>
52 #include <sys/machtrap.h>
53 #include <sys/trap.h>
54 
55 /* Higher than the highest trap number for which we have a specific specifier */
56 #define	KMT_MAXTRAPNO	0x1ff
57 
58 #define	OP(x)		((x) >> 30)
59 #define	OP3(x)		(((x) >> 19) & 0x3f)
60 #define	RD(x)		(((x) >> 25) & 0x1f)
61 #define	RS1(x)		(((x) >> 14) & 0x1f)
62 #define	RS2(x)		((x) & 0x1f)
63 
64 #define	OP_ARITH	0x2
65 
66 #define	OP3_OR		0x02
67 #define	OP3_SAVE	0x3c
68 #define	OP3_RESTORE	0x3d
69 
70 static int
kmt_stack_iter(mdb_tgt_t * t,const mdb_tgt_gregset_t * gsp,mdb_tgt_stack_f * func,void * arg,int cpuid)71 kmt_stack_iter(mdb_tgt_t *t, const mdb_tgt_gregset_t *gsp,
72     mdb_tgt_stack_f *func, void *arg, int cpuid)
73 {
74 	const mdb_tgt_gregset_t *grp;
75 	mdb_tgt_gregset_t gregs;
76 	kreg_t *kregs = &gregs.kregs[0];
77 	long nwin, stopwin, canrestore, wp, i, sp;
78 	long argv[6];
79 
80 	/*
81 	 * If gsp isn't null, we were asked to dump a trace from a
82 	 * specific location.  The normal iterator can handle that.
83 	 */
84 	if (gsp != NULL) {
85 		if (cpuid != DPI_MASTER_CPUID)
86 			warn("register set provided - ignoring cpu argument\n");
87 		return (mdb_kvm_v9stack_iter(t, gsp, func, arg));
88 	}
89 
90 	if (kmdb_dpi_get_cpu_state(cpuid) < 0) {
91 		warn("failed to iterate through stack for cpu %u", cpuid);
92 		return (DCMD_ERR);
93 	}
94 
95 	/*
96 	 * We're being asked to dump the trace for the current CPU.
97 	 * To do that, we need to iterate first through the saved
98 	 * register windors.  If there's more to the trace than that,
99 	 * we'll hand off to the normal iterator.
100 	 */
101 	if ((grp = kmdb_dpi_get_gregs(cpuid)) == NULL) {
102 		warn("failed to retrieve registers for cpu %d", cpuid);
103 		return (DCMD_ERR);
104 	}
105 
106 	bcopy(grp, &gregs, sizeof (mdb_tgt_gregset_t));
107 
108 	wp = kregs[KREG_CWP];
109 	canrestore = kregs[KREG_CANRESTORE];
110 	nwin = kmdb_dpi_get_nwin(cpuid);
111 	stopwin = ((wp + nwin) - canrestore - 1) % nwin;
112 
113 	mdb_dprintf(MDB_DBG_KMOD, "dumping cwp = %lu, canrestore = %lu, "
114 	    "stopwin = %lu\n", wp, canrestore, stopwin);
115 
116 	for (;;) {
117 		struct rwindow rwin;
118 
119 		for (i = 0; i < 6; i++)
120 			argv[i] = kregs[KREG_I0 + i];
121 
122 		if (kregs[KREG_PC] != 0 &&
123 		    func(arg, kregs[KREG_PC], 6, argv, &gregs) != 0)
124 			return (0);
125 
126 		kregs[KREG_PC] = kregs[KREG_I7];
127 		kregs[KREG_NPC] = kregs[KREG_PC] + 4;
128 
129 		if ((sp = kregs[KREG_FP] + STACK_BIAS) == STACK_BIAS || sp == 0)
130 			return (0); /* Stop if we're at the end of stack */
131 
132 		if (sp & (STACK_ALIGN - 1))
133 			return (set_errno(EMDB_STKALIGN));
134 
135 		wp = (wp + nwin - 1) % nwin;
136 
137 		if (wp == stopwin)
138 			break;
139 
140 		bcopy(&kregs[KREG_I0], &kregs[KREG_O0], 8 * sizeof (kreg_t));
141 
142 		if (kmdb_dpi_get_rwin(cpuid, wp, &rwin) < 0) {
143 			warn("unable to get registers from window %ld\n", wp);
144 			return (-1);
145 		}
146 
147 		for (i = 0; i < 8; i++)
148 			kregs[KREG_L0 + i] = (uintptr_t)rwin.rw_local[i];
149 		for (i = 0; i < 8; i++)
150 			kregs[KREG_I0 + i] = (uintptr_t)rwin.rw_in[i];
151 	}
152 
153 	mdb_dprintf(MDB_DBG_KMOD, "dumping wp %ld and beyond normally\n", wp);
154 
155 	/*
156 	 * hack - if we null out pc here, iterator won't print the frame
157 	 * that corresponds to the current set of registers.  That's what we
158 	 * want because we just printed them above.
159 	 */
160 	kregs[KREG_PC] = 0;
161 	return (mdb_kvm_v9stack_iter(t, &gregs, func, arg));
162 }
163 
164 void
kmt_printregs(const mdb_tgt_gregset_t * gregs)165 kmt_printregs(const mdb_tgt_gregset_t *gregs)
166 {
167 	mdb_v9printregs(gregs);
168 }
169 
170 static int
kmt_stack_common(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv,int cpuid,mdb_tgt_stack_f * func,kreg_t saved_pc)171 kmt_stack_common(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
172     int cpuid, mdb_tgt_stack_f *func, kreg_t saved_pc)
173 {
174 	mdb_tgt_gregset_t *grp = NULL;
175 	mdb_tgt_gregset_t gregs;
176 	void *arg = (void *)(uintptr_t)mdb.m_nargs;
177 
178 	if (flags & DCMD_ADDRSPEC) {
179 		bzero(&gregs, sizeof (gregs));
180 		gregs.kregs[KREG_FP] = addr;
181 		gregs.kregs[KREG_I7] = saved_pc;
182 		grp = &gregs;
183 	}
184 
185 	if (argc != 0) {
186 		if (argv->a_type == MDB_TYPE_CHAR || argc > 1)
187 			return (DCMD_USAGE);
188 
189 		if (argv->a_type == MDB_TYPE_STRING)
190 			arg = (void *)(uintptr_t)(uint_t)
191 			    mdb_strtoull(argv->a_un.a_str);
192 		else
193 			arg = (void *)(uintptr_t)(uint_t)argv->a_un.a_val;
194 	}
195 
196 	(void) kmt_stack_iter(mdb.m_target, grp, func, arg, cpuid);
197 
198 	return (DCMD_OK);
199 }
200 
201 int
kmt_cpustack(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv,int cpuid,int verbose)202 kmt_cpustack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
203     int cpuid, int verbose)
204 {
205 	return (kmt_stack_common(addr, flags, argc, argv, cpuid,
206 	    (verbose ? mdb_kvm_v9framev : mdb_kvm_v9frame), 0));
207 }
208 
209 int
kmt_stack(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)210 kmt_stack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
211 {
212 	return (kmt_stack_common(addr, flags, argc, argv, DPI_MASTER_CPUID,
213 	    mdb_kvm_v9frame, 0));
214 }
215 
216 int
kmt_stackv(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)217 kmt_stackv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
218 {
219 	return (kmt_stack_common(addr, flags, argc, argv, DPI_MASTER_CPUID,
220 	    mdb_kvm_v9framev, 0));
221 }
222 
223 int
kmt_stackr(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)224 kmt_stackr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
225 {
226 	/*
227 	 * Force printing of the first register window by setting the saved
228 	 * pc (%i7) to PC_FAKE.
229 	 */
230 	return (kmt_stack_common(addr, flags, argc, argv, DPI_MASTER_CPUID,
231 	    mdb_kvm_v9framer, PC_FAKE));
232 }
233 
234 ssize_t
kmt_write_page(mdb_tgt_t * t,const void * buf,size_t nbytes,uintptr_t addr)235 kmt_write_page(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
236 {
237 	jmp_buf *oldpcb = NULL;
238 	jmp_buf pcb;
239 	physaddr_t pa;
240 
241 	/*
242 	 * Can we write to this page?
243 	 */
244 	if (!(t->t_flags & MDB_TGT_F_ALLOWIO) &&
245 	    (nbytes = kmdb_kdi_range_is_nontoxic(addr, nbytes, 1)) == 0)
246 		return (set_errno(EMDB_NOMAP));
247 
248 	/*
249 	 * The OBP va>pa call returns a protection value that's right only some
250 	 * of the time.  We can, however, tell if we failed a write due to a
251 	 * protection violation.  If we get such an error, we'll retry the
252 	 * write using pwrite.
253 	 */
254 	if (setjmp(pcb) != 0) {
255 		/* We failed the write */
256 		kmdb_dpi_restore_fault_hdlr(oldpcb);
257 
258 		if (errno == EACCES && kmdb_prom_vtop(addr, &pa) == 0)
259 			return (kmt_pwrite(t, buf, nbytes, pa));
260 		return (-1); /* errno is set for us */
261 	}
262 
263 	mdb_dprintf(MDB_DBG_KMOD, "copying %lu bytes from %p to %p\n", nbytes,
264 	    buf, (void *)addr);
265 
266 	oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
267 	(void) kmt_writer((void *)buf, nbytes, addr);
268 	kmdb_dpi_restore_fault_hdlr(oldpcb);
269 
270 	return (nbytes);
271 }
272 
273 /*ARGSUSED*/
274 ssize_t
kmt_write(mdb_tgt_t * t,const void * buf,size_t nbytes,uintptr_t addr)275 kmt_write(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
276 {
277 	size_t ntowrite, nwritten, n;
278 	int rc;
279 
280 	kmdb_prom_check_interrupt();
281 
282 	if (nbytes == 0)
283 		return (0);
284 
285 	/*
286 	 * Break the writes up into page-sized chunks.  First, the leading page
287 	 * fragment (if any), then the subsequent pages.
288 	 */
289 
290 	if ((n = (addr & (mdb.m_pagesize - 1))) != 0) {
291 		ntowrite = MIN(mdb.m_pagesize - n, nbytes);
292 
293 		if ((rc = kmt_write_page(t, buf, ntowrite, addr)) != ntowrite)
294 			return (rc);
295 
296 		addr = roundup(addr, mdb.m_pagesize);
297 		nbytes -= ntowrite;
298 		nwritten = ntowrite;
299 		buf = ((caddr_t)buf + ntowrite);
300 	}
301 
302 	while (nbytes > 0) {
303 		ntowrite = MIN(mdb.m_pagesize, nbytes);
304 
305 		if ((rc = kmt_write_page(t, buf, ntowrite, addr)) != ntowrite)
306 			return (rc < 0 ? rc : rc + nwritten);
307 
308 		addr += mdb.m_pagesize;
309 		nbytes -= ntowrite;
310 		nwritten += ntowrite;
311 		buf = ((caddr_t)buf + ntowrite);
312 	}
313 
314 	return (rc);
315 }
316 
317 /*ARGSUSED*/
318 ssize_t
kmt_ioread(mdb_tgt_t * t,void * buf,size_t nbytes,uintptr_t addr)319 kmt_ioread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
320 {
321 	return (set_errno(EMDB_TGTHWNOTSUP));
322 }
323 
324 /*ARGSUSED*/
325 ssize_t
kmt_iowrite(mdb_tgt_t * t,const void * buf,size_t nbytes,uintptr_t addr)326 kmt_iowrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
327 {
328 	return (set_errno(EMDB_TGTHWNOTSUP));
329 }
330 
331 const char *
kmt_def_dismode(void)332 kmt_def_dismode(void)
333 {
334 #ifdef __sparcv9
335 	return ("v9plus");
336 #else
337 	return ("v8");
338 #endif
339 }
340 
341 /*
342  * If we are stopped on a save instruction or at the first instruction of a
343  * known function, return %o7 as the step-out address; otherwise return the
344  * current frame's return address (%i7).  Significantly better handling of
345  * step out in leaf routines could be accomplished by implementing more
346  * complex decoding of the current function and our current state.
347  */
348 int
kmt_step_out(mdb_tgt_t * t,uintptr_t * p)349 kmt_step_out(mdb_tgt_t *t, uintptr_t *p)
350 {
351 	kreg_t pc, i7, o7;
352 	GElf_Sym func;
353 
354 	(void) kmdb_dpi_get_register("pc", &pc);
355 	(void) kmdb_dpi_get_register("i7", &i7);
356 	(void) kmdb_dpi_get_register("o7", &o7);
357 
358 	if (mdb_tgt_lookup_by_addr(t, pc, MDB_TGT_SYM_FUZZY, NULL, 0,
359 	    &func, NULL) == 0 && func.st_value == pc)
360 		*p = o7 + 2 * sizeof (mdb_instr_t);
361 	else {
362 		mdb_instr_t instr;
363 
364 		if (mdb_tgt_vread(t, &instr, sizeof (instr), pc) !=
365 		    sizeof (instr)) {
366 			warn("failed to read instruction at %p for step out",
367 			    (void *)pc);
368 			return (-1);
369 		}
370 
371 		if (OP(instr) == OP_ARITH && OP3(instr) == OP3_SAVE)
372 			*p = o7 + 2 * sizeof (mdb_instr_t);
373 		else
374 			*p = i7 + 2 * sizeof (mdb_instr_t);
375 	}
376 
377 	return (0);
378 }
379 
380 static const char *
regno2name(int idx)381 regno2name(int idx)
382 {
383 	const mdb_tgt_regdesc_t *rd;
384 
385 	for (rd = mdb_sparcv9_kregs; rd->rd_name != NULL; rd++) {
386 		if (idx == rd->rd_num)
387 			return (rd->rd_name);
388 	}
389 
390 	ASSERT(rd->rd_name != NULL);
391 
392 	return ("unknown");
393 }
394 
395 /*
396  * Step over call and jmpl by returning the address of the position where a
397  * temporary breakpoint can be set to catch return from the control transfer.
398  * This function does not currently provide advanced decoding of DCTI couples
399  * or any other complex special case; we just fall back to single-step.
400  */
401 int
kmt_next(mdb_tgt_t * t,uintptr_t * p)402 kmt_next(mdb_tgt_t *t, uintptr_t *p)
403 {
404 	kreg_t pc, npc;
405 	GElf_Sym func;
406 
407 	(void) kmdb_dpi_get_register("pc", &pc);
408 	(void) kmdb_dpi_get_register("npc", &npc);
409 
410 	if (mdb_tgt_lookup_by_addr(t, pc, MDB_TGT_SYM_FUZZY, NULL, 0,
411 	    &func, NULL) != 0)
412 		return (-1);
413 
414 	if (npc < func.st_value || func.st_value + func.st_size <= npc) {
415 		mdb_instr_t instr;
416 		kreg_t reg;
417 
418 		/*
419 		 * We're about to transfer control outside this function, so we
420 		 * want to stop when control returns from the other function.
421 		 * Normally the return address will be in %o7, tail-calls being
422 		 * the exception.  We try to discover if this is a tail-call and
423 		 * compute the return address in that case.
424 		 */
425 		if (mdb_tgt_vread(t, &instr, sizeof (instr), pc) !=
426 		    sizeof (instr)) {
427 			warn("failed to read instruction at %p for next",
428 			    (void *)pc);
429 			return (-1);
430 		}
431 
432 		if (OP(instr) == OP_ARITH && OP3(instr) == OP3_RESTORE) {
433 			(void) kmdb_dpi_get_register("i7", &reg);
434 		} else if (OP(instr) == OP_ARITH && OP3(instr) == OP3_OR &&
435 		    RD(instr) == KREG_O7) {
436 			if (RS1(instr) == KREG_G0)
437 				return (set_errno(EAGAIN));
438 
439 			(void) kmdb_dpi_get_register(regno2name(RS2(instr)),
440 			    &reg);
441 		} else
442 			(void) kmdb_dpi_get_register("o7", &reg);
443 
444 		*p = reg + 2 * sizeof (mdb_instr_t);
445 
446 		return (0);
447 	}
448 
449 	return (set_errno(EAGAIN));
450 }
451 
452 const char *
kmt_trapname(int trapnum)453 kmt_trapname(int trapnum)
454 {
455 	static char trapname[11];
456 
457 	switch (trapnum) {
458 	case T_INSTR_EXCEPTION:
459 		return ("instruction access error trap");
460 	case T_ALIGNMENT:
461 		return ("improper alignment trap");
462 	case T_UNIMP_INSTR:
463 		return ("illegal instruction trap");
464 	case T_IDIV0:
465 		return ("division by zero trap");
466 	case T_FAST_INSTR_MMU_MISS:
467 		return ("instruction access MMU miss trap");
468 	case T_FAST_DATA_MMU_MISS:
469 		return ("data access MMU miss trap");
470 	case ST_KMDB_TRAP|T_SOFTWARE_TRAP:
471 		return ("debugger entry trap");
472 	case ST_KMDB_BREAKPOINT|T_SOFTWARE_TRAP:
473 		return ("breakpoint trap");
474 	default:
475 		(void) mdb_snprintf(trapname, sizeof (trapname), "trap %#x",
476 		    trapnum);
477 		return (trapname);
478 	}
479 }
480 
481 void
kmt_init_isadep(mdb_tgt_t * t)482 kmt_init_isadep(mdb_tgt_t *t)
483 {
484 	kmt_data_t *kmt = t->t_data;
485 
486 	kmt->kmt_rds = mdb_sparcv9_kregs;
487 
488 	kmt->kmt_trapmax = KMT_MAXTRAPNO;
489 	kmt->kmt_trapmap = mdb_zalloc(BT_SIZEOFMAP(kmt->kmt_trapmax), UM_SLEEP);
490 
491 	/* Traps for which we want to provide an explicit message */
492 	(void) mdb_tgt_add_fault(t, T_INSTR_EXCEPTION, MDB_TGT_SPEC_INTERNAL,
493 	    no_se_f, NULL);
494 	(void) mdb_tgt_add_fault(t, T_ALIGNMENT, MDB_TGT_SPEC_INTERNAL,
495 	    no_se_f, NULL);
496 	(void) mdb_tgt_add_fault(t, T_UNIMP_INSTR, MDB_TGT_SPEC_INTERNAL,
497 	    no_se_f, NULL);
498 	(void) mdb_tgt_add_fault(t, T_IDIV0, MDB_TGT_SPEC_INTERNAL,
499 	    no_se_f, NULL);
500 	(void) mdb_tgt_add_fault(t, T_FAST_INSTR_MMU_MISS,
501 	    MDB_TGT_SPEC_INTERNAL, no_se_f, NULL);
502 	(void) mdb_tgt_add_fault(t, T_FAST_DATA_MMU_MISS, MDB_TGT_SPEC_INTERNAL,
503 	    no_se_f, NULL);
504 
505 	/*
506 	 * Traps which will be handled elsewhere, and which therefore don't
507 	 * need the trap-based message.
508 	 */
509 	BT_SET(kmt->kmt_trapmap, ST_KMDB_TRAP|T_SOFTWARE_TRAP);
510 	BT_SET(kmt->kmt_trapmap, ST_KMDB_BREAKPOINT|T_SOFTWARE_TRAP);
511 	BT_SET(kmt->kmt_trapmap, T_PA_WATCHPOINT);
512 	BT_SET(kmt->kmt_trapmap, T_VA_WATCHPOINT);
513 
514 	/* Catch-all for traps not explicitly listed here */
515 	(void) mdb_tgt_add_fault(t, KMT_TRAP_NOTENUM, MDB_TGT_SPEC_INTERNAL,
516 	    no_se_f, NULL);
517 }
518 
519 /*ARGSUSED*/
520 void
kmt_startup_isadep(mdb_tgt_t * t)521 kmt_startup_isadep(mdb_tgt_t *t)
522 {
523 }
524