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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 /*
29 * isa-dependent portions of the kmdb target
30 */
31
32 #include <kmdb/kvm.h>
33 #include <kmdb/kvm_cpu.h>
34 #include <kmdb/kmdb_kdi.h>
35 #include <kmdb/kmdb_asmutil.h>
36 #include <mdb/mdb_debug.h>
37 #include <mdb/mdb_err.h>
38 #include <mdb/mdb_list.h>
39 #include <mdb/mdb_target_impl.h>
40 #include <mdb/mdb_isautil.h>
41 #include <mdb/mdb_kreg_impl.h>
42 #include <mdb/mdb.h>
43
44 #include <sys/types.h>
45 #include <sys/frame.h>
46 #include <sys/trap.h>
47 #include <sys/bitmap.h>
48 #include <sys/pci_impl.h>
49
50 /* Higher than the highest trap number for which we have a defined specifier */
51 #define KMT_MAXTRAPNO 0x20
52
53 #define IOPORTLIMIT 0xffff /* XXX find a new home for this */
54
55 const char *
56 kmt_def_dismode(void)
57 {
58 #ifdef __amd64
59 return ("amd64");
60 #else
61 return ("ia32");
62 #endif
63 }
64
65 int
66 kmt_step_out_validate(mdb_tgt_t *t, uintptr_t pc)
67 {
68 kmt_data_t *kmt = t->t_data;
69 int i;
70
71 for (i = 0; i < sizeof (kmt->kmt_intrsyms) / sizeof (GElf_Sym); i++) {
72 GElf_Sym *sym = (GElf_Sym *)&kmt->kmt_intrsyms + i;
73
74 if (pc >= sym->st_value && pc < sym->st_value + sym->st_size)
75 return (0);
76 }
77
78 return (1);
79 }
80
81 /*
82 * Determine the return address for the current frame.
83 */
84 int
85 kmt_step_out(mdb_tgt_t *t, uintptr_t *p)
86 {
87 mdb_instr_t instr;
88 kreg_t pc, sp, fp;
89
90 (void) kmdb_dpi_get_register("pc", &pc);
91 (void) kmdb_dpi_get_register("sp", &sp);
92 (void) kmdb_dpi_get_register("fp", &fp);
93
94 if (mdb_tgt_vread(t, &instr, sizeof (mdb_instr_t), pc) !=
95 sizeof (mdb_instr_t))
96 return (-1); /* errno is set for us */
97
98 if (!kmt_step_out_validate(t, pc))
99 return (set_errno(EMDB_TGTNOTSUP));
100
101 return (mdb_isa_step_out(t, p, pc, fp, sp, instr));
102 }
103
104 int
105 kmt_step_branch(mdb_tgt_t *t)
106 {
107 kmt_data_t *kmt = t->t_data;
108
109 return (kmt_cpu_step_branch(t, kmt->kmt_cpu));
110 }
111
112 /*
113 * Return the address of the next instruction following a call, or return -1
114 * and set errno to EAGAIN if the target should just single-step.
115 */
116 int
117 kmt_next(mdb_tgt_t *t, uintptr_t *p)
118 {
119 kreg_t pc;
120 mdb_instr_t instr;
121
122 (void) kmdb_dpi_get_register("pc", &pc);
123
124 if (mdb_tgt_vread(t, &instr, sizeof (mdb_instr_t), pc) !=
125 sizeof (mdb_instr_t))
126 return (-1); /* errno is set for us */
127
128 return (mdb_isa_next(t, p, pc, instr));
129 }
130
131 /*ARGSUSED*/
132 static int
133 kmt_stack_common(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
134 int cpuid, mdb_tgt_stack_f *func)
135 {
136 const mdb_tgt_gregset_t *grp = NULL;
137 mdb_tgt_gregset_t gregs;
138 void *arg = (void *)(uintptr_t)mdb.m_nargs;
139
140 if (flags & DCMD_ADDRSPEC) {
141 bzero(&gregs, sizeof (gregs));
142 gregs.kregs[KREG_FP] = addr;
143 grp = &gregs;
144 } else
145 grp = kmdb_dpi_get_gregs(cpuid);
146
147 if (grp == NULL) {
148 warn("failed to retrieve registers for cpu %d", cpuid);
149 return (DCMD_ERR);
150 }
151
152 if (argc != 0) {
153 if (argv->a_type == MDB_TYPE_CHAR || argc > 1)
154 return (DCMD_USAGE);
155
156 if (argv->a_type == MDB_TYPE_STRING)
157 arg = (void *)(uintptr_t)mdb_strtoull(argv->a_un.a_str);
158 else
159 arg = (void *)(uintptr_t)argv->a_un.a_val;
160 }
161
162 (void) mdb_isa_kvm_stack_iter(mdb.m_target, grp, func, arg);
163
164 return (DCMD_OK);
165 }
166
167 int
168 kmt_cpustack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
169 int cpuid, int verbose)
170 {
171 return (kmt_stack_common(addr, flags, argc, argv, cpuid,
172 (verbose ? mdb_isa_kvm_framev : mdb_isa_kvm_frame)));
173 }
174
175 int
176 kmt_stack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
177 {
178 return (kmt_stack_common(addr, flags, argc, argv, DPI_MASTER_CPUID,
179 mdb_isa_kvm_frame));
180 }
181
182 int
183 kmt_stackv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
184 {
185 return (kmt_stack_common(addr, flags, argc, argv, DPI_MASTER_CPUID,
186 mdb_isa_kvm_framev));
187 }
188
189 int
190 kmt_stackr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
191 {
192 return (kmt_stack_common(addr, flags, argc, argv, DPI_MASTER_CPUID,
193 mdb_isa_kvm_framev));
194 }
195
196 /*ARGSUSED*/
197 void
198 kmt_printregs(const mdb_tgt_gregset_t *gregs)
199 {
200 mdb_isa_printregs(gregs);
201 }
202
203 #define IOCHECK_NOWARN 0
204 #define IOCHECK_WARN 1
205
206 static int
207 kmt_io_check(uint64_t nbytes, uintptr_t addr, int dowarn)
208 {
209 if (addr > IOPORTLIMIT) {
210 if (dowarn)
211 warn("port address must be 0-%#x\n", IOPORTLIMIT);
212 return (set_errno(EINVAL));
213 }
214
215 if (nbytes != 1 && nbytes != 2 && nbytes != 4) {
216 if (dowarn)
217 warn("port access must be 1, 2, or 4 bytes\n");
218 return (set_errno(EINVAL));
219 }
220
221 if ((addr & (nbytes - 1)) != 0) {
222 if (dowarn) {
223 warn("address for %llu-byte access must be %llu-byte "
224 "aligned\n", (u_longlong_t)nbytes,
225 (u_longlong_t)nbytes);
226 }
227 return (set_errno(EINVAL));
228 }
229
230 return (0);
231 }
232
233 /*ARGSUSED1*/
234 int
235 kmt_in_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
236 {
237 uint64_t len = 0;
238 uint32_t buf;
239
240 if (mdb_getopts(argc, argv,
241 'L', MDB_OPT_UINT64, &len,
242 NULL) != argc)
243 return (DCMD_USAGE);
244
245 if (len == 0)
246 len = mdb.m_dcount;
247
248 if (kmt_io_check(len, addr, IOCHECK_WARN) < 0)
249 return (DCMD_ERR);
250
251 if (mdb_tgt_ioread(mdb.m_target, &buf, len, addr) < 0) {
252 warn("failed to read from port 0x%llx", (u_longlong_t)addr);
253 return (DCMD_ERR);
254 }
255
256 mdb_printf("%x\n", buf);
257
258 return (DCMD_OK);
259 }
260
261 static uint64_t
262 kmt_numarg(const mdb_arg_t *arg)
263 {
264 if (arg->a_type == MDB_TYPE_STRING)
265 return (mdb_strtoull(arg->a_un.a_str));
266 else
267 return (arg->a_un.a_val);
268 }
269
270 /*ARGSUSED1*/
271 int
272 kmt_out_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
273 {
274 uint64_t len = 0;
275 uint64_t val;
276
277 if (mdb_getopts(argc, argv,
278 'L', MDB_OPT_UINT64, &len,
279 NULL) != argc - 1)
280 return (DCMD_USAGE);
281
282 if (len == 0)
283 len = mdb.m_dcount;
284
285 argv += argc - 1;
286 val = kmt_numarg(argv);
287
288 if (kmt_io_check(len, addr, IOCHECK_WARN) < 0)
289 return (DCMD_ERR);
290
291 if (val > (1ULL << (len * NBBY)) - 1) {
292 warn("value is out of range for port size\n");
293 return (DCMD_ERR);
294 }
295
296 if (mdb_tgt_iowrite(mdb.m_target, &val, len, addr) < 0) {
297 warn("failed to write to port %llx", (u_longlong_t)addr);
298 return (DCMD_ERR);
299 }
300
301 return (DCMD_OK);
302 }
303
304 static int
305 kmt_rwmsr(uint32_t addr, uint64_t *valp, void (*rw)(uint32_t, uint64_t *))
306 {
307 jmp_buf pcb, *oldpcb = NULL;
308
309 if (setjmp(pcb) != 0) {
310 kmdb_dpi_restore_fault_hdlr(oldpcb);
311 return (-1); /* errno is set for us */
312 }
313
314 oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
315 rw(addr, valp);
316 kmdb_dpi_restore_fault_hdlr(oldpcb);
317
318 return (0);
319 }
320
321 /*ARGSUSED*/
322 int
323 kmt_rdmsr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
324 {
325 uint64_t val;
326
327 if (!(flags & DCMD_ADDRSPEC))
328 return (DCMD_USAGE);
329
330 if (kmt_rwmsr(addr, &val, rdmsr) < 0) {
331 warn("rdmsr failed");
332 return (DCMD_ERR);
333 }
334
335 mdb_printf("%llx\n", (u_longlong_t)val);
336
337 return (DCMD_OK);
338 }
339
340 /*ARGSUSED*/
341 int
342 kmt_wrmsr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
343 {
344 uint64_t val;
345
346 if (!(flags & DCMD_ADDRSPEC) || argc != 1)
347 return (DCMD_USAGE);
348
349 val = kmt_numarg(argv);
350
351 if (kmt_rwmsr(addr, &val, wrmsr)) {
352 warn("wrmsr failed");
353 return (DCMD_ERR);
354 }
355
356 return (DCMD_OK);
357 }
358
359 int
360 kmt_msr_validate(const kdi_msr_t *msr)
361 {
362 uint64_t val;
363
364 for (/* */; msr->msr_num != 0; msr++) {
365 if (kmt_rwmsr(msr->msr_num, &val, rdmsr) < 0)
366 return (0);
367 }
368
369 return (1);
370 }
371
372 /*ARGSUSED*/
373 ssize_t
374 kmt_write(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
375 {
376 if (!(t->t_flags & MDB_TGT_F_ALLOWIO) &&
377 (nbytes = kmdb_kdi_range_is_nontoxic(addr, nbytes, 1)) == 0)
378 return (set_errno(EMDB_NOMAP));
379
380 /*
381 * No writes to user space are allowed. If we were to allow it, we'd
382 * be in the unfortunate situation where kmdb could place a breakpoint
383 * on a userspace executable page; this dirty page would end up being
384 * flushed back to disk, incurring sadness when it's next executed.
385 * Besides, we can't allow trapping in from userspace anyway.
386 */
387 if (addr < kmdb_kdi_get_userlimit())
388 return (set_errno(EMDB_TGTNOTSUP));
389
390 return (kmt_rw(t, (void *)buf, nbytes, addr, kmt_writer));
391 }
392
393 /*ARGSUSED*/
394 static ssize_t
395 kmt_iorw(mdb_tgt_t *t, void *buf, size_t nbytes, uint64_t addr,
396 void (*iorw)(void *, size_t, uintptr_t))
397 {
398 jmp_buf pcb, *oldpcb = NULL;
399
400 if (kmt_io_check(nbytes, addr, IOCHECK_NOWARN) < 0)
401 return (-1); /* errno is set for us */
402
403 if (setjmp(pcb) != 0) {
404 kmdb_dpi_restore_fault_hdlr(oldpcb);
405 return (-1); /* errno is set for us */
406 }
407
408 oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
409 iorw(buf, nbytes, addr);
410 kmdb_dpi_restore_fault_hdlr(oldpcb);
411
412 return (nbytes);
413 }
414
415 /*ARGSUSED*/
416 ssize_t
417 kmt_ioread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
418 {
419 return (kmt_iorw(t, buf, nbytes, addr, kmt_in));
420 }
421
422 /*ARGSUSED*/
423 ssize_t
424 kmt_iowrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr)
425 {
426 return (kmt_iorw(t, (void *)buf, nbytes, addr, kmt_out));
427 }
428
429 static int
430 kmt_pcicfg_common(uintptr_t off, uint32_t *valp, const mdb_arg_t *argv,
431 void (*rw)(void *, size_t, uintptr_t))
432 {
433 uint32_t bus, dev, func;
434 uint32_t addr;
435
436 bus = kmt_numarg(&argv[0]);
437 dev = kmt_numarg(&argv[1]);
438 func = kmt_numarg(&argv[2]);
439
440 if ((bus & 0xffff) != bus) {
441 warn("invalid bus number (must be 0-0xffff)\n");
442 return (DCMD_ERR);
443 }
444
445 if ((dev & 0x1f) != dev) {
446 warn("invalid device number (must be 0-0x1f)\n");
447 return (DCMD_ERR);
448 }
449
450 if ((func & 0x7) != func) {
451 warn("invalid function number (must be 0-7)\n");
452 return (DCMD_ERR);
453 }
454
455 if ((off & 0xfc) != off) {
456 warn("invalid register number (must be 0-0xff, and 4-byte "
457 "aligned\n");
458 return (DCMD_ERR);
459 }
460
461 addr = PCI_CADDR1(bus, dev, func, off);
462
463 if (kmt_iowrite(mdb.m_target, &addr, sizeof (addr), PCI_CONFADD) !=
464 sizeof (addr)) {
465 warn("write of PCI_CONFADD failed");
466 return (DCMD_ERR);
467 }
468
469 if (kmt_iorw(mdb.m_target, valp, sizeof (*valp), PCI_CONFDATA, rw) !=
470 sizeof (*valp)) {
471 warn("access to PCI_CONFDATA failed");
472 return (DCMD_ERR);
473 }
474
475 return (DCMD_OK);
476 }
477
478 /*ARGSUSED*/
479 int
480 kmt_rdpcicfg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
481 {
482 uint32_t val;
483
484 if (argc != 3 || !(flags & DCMD_ADDRSPEC))
485 return (DCMD_USAGE);
486
487 if (kmt_pcicfg_common(addr, &val, argv, kmt_in) != DCMD_OK)
488 return (DCMD_ERR);
489
490 mdb_printf("%llx\n", (u_longlong_t)val);
491
492 return (DCMD_OK);
493 }
494
495 /*ARGSUSED*/
496 int
497 kmt_wrpcicfg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
498 {
499 uint32_t val;
500
501 if (argc != 4 || !(flags & DCMD_ADDRSPEC))
502 return (DCMD_USAGE);
503
504 val = (uint32_t)kmt_numarg(&argv[3]);
505
506 if (kmt_pcicfg_common(addr, &val, argv, kmt_out) != DCMD_OK)
507 return (DCMD_ERR);
508
509 return (DCMD_OK);
510 }
511
512 const char *
513 kmt_trapname(int trapnum)
514 {
515 static char trapname[11];
516
517 switch (trapnum) {
518 case T_ZERODIV:
519 return ("division by zero (#de) trap");
520 case T_SGLSTP:
521 return ("single-step (#db) trap");
522 case T_NMIFLT:
523 return ("NMI");
524 case T_BPTFLT:
525 return ("breakpoint (#bp) trap");
526 case T_ILLINST:
527 return ("illegal instruction (#ud) trap");
528 case T_SEGFLT:
529 return ("segment not present (#np) trap");
530 case T_STKFLT:
531 return ("stack (#ss) trap");
532 case T_GPFLT:
533 return ("general protection (#gp) trap");
534 case T_PGFLT:
535 return ("page fault (#pf) trap");
536 case T_ALIGNMENT:
537 return ("alignment check (#ac) trap");
538 case T_MCE:
539 return ("machine check (#mc) trap");
540 case T_SIMDFPE:
541 return ("SSE/SSE2 (#xm) trap");
542 case T_DBGENTR:
543 return ("debugger entry trap");
544 default:
545 (void) mdb_snprintf(trapname, sizeof (trapname), "trap %#x",
546 trapnum);
547 return (trapname);
548 }
549 }
550
551 void
552 kmt_init_isadep(mdb_tgt_t *t)
553 {
554 kmt_data_t *kmt = t->t_data;
555
556 kmt->kmt_rds = mdb_isa_kregs;
557
558 kmt->kmt_trapmax = KMT_MAXTRAPNO;
559 kmt->kmt_trapmap = mdb_zalloc(BT_SIZEOFMAP(kmt->kmt_trapmax), UM_SLEEP);
560
561 /* Traps for which we want to provide an explicit message */
562 (void) mdb_tgt_add_fault(t, T_ZERODIV, MDB_TGT_SPEC_INTERNAL,
563 no_se_f, NULL);
564 (void) mdb_tgt_add_fault(t, T_ILLINST, MDB_TGT_SPEC_INTERNAL,
565 no_se_f, NULL);
566 (void) mdb_tgt_add_fault(t, T_SEGFLT, MDB_TGT_SPEC_INTERNAL,
567 no_se_f, NULL);
568 (void) mdb_tgt_add_fault(t, T_STKFLT, MDB_TGT_SPEC_INTERNAL,
569 no_se_f, NULL);
570 (void) mdb_tgt_add_fault(t, T_GPFLT, MDB_TGT_SPEC_INTERNAL,
571 no_se_f, NULL);
572 (void) mdb_tgt_add_fault(t, T_PGFLT, MDB_TGT_SPEC_INTERNAL,
573 no_se_f, NULL);
574 (void) mdb_tgt_add_fault(t, T_ALIGNMENT, MDB_TGT_SPEC_INTERNAL,
575 no_se_f, NULL);
576 (void) mdb_tgt_add_fault(t, T_MCE, MDB_TGT_SPEC_INTERNAL,
577 no_se_f, NULL);
578 (void) mdb_tgt_add_fault(t, T_SIMDFPE, MDB_TGT_SPEC_INTERNAL,
579 no_se_f, NULL);
580
581 /*
582 * Traps which will be handled elsewhere, and which therefore don't
583 * need the trap-based message.
584 */
585 BT_SET(kmt->kmt_trapmap, T_SGLSTP);
586 BT_SET(kmt->kmt_trapmap, T_BPTFLT);
587 BT_SET(kmt->kmt_trapmap, T_DBGENTR);
588
589 /* Catch-all for traps not explicitly listed here */
590 (void) mdb_tgt_add_fault(t, KMT_TRAP_NOTENUM, MDB_TGT_SPEC_INTERNAL,
591 no_se_f, NULL);
592 }
593
594 void
595 kmt_startup_isadep(mdb_tgt_t *t)
596 {
597 kmt_data_t *kmt = t->t_data;
598
599 /*
600 * The stack trace and ::step out code need to detect "interrupt"
601 * frames. The heuristic they use to detect said frames requires the
602 * addresses of routines that can generate them.
603 */
604 (void) mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC,
605 "cmnint", &kmt->kmt_intrsyms._kmt_cmnint, NULL);
606 (void) mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC,
607 "cmntrap", &kmt->kmt_intrsyms._kmt_cmntrap, NULL);
608 (void) mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC,
609 "sys_sysenter", &kmt->kmt_intrsyms._kmt_sysenter, NULL);
610 (void) mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC,
611 "brand_sys_sysenter", &kmt->kmt_intrsyms._kmt_brand_sysenter, NULL);
612 #if defined(__amd64)
613 (void) mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC,
614 "sys_syscall", &kmt->kmt_intrsyms._kmt_syscall, NULL);
615 (void) mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC,
616 "brand_sys_syscall", &kmt->kmt_intrsyms._kmt_brand_syscall, NULL);
617 #endif
618 }