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
  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
 165 kmt_printregs(const mdb_tgt_gregset_t *gregs)
 166 {
 167         mdb_v9printregs(gregs);
 168 }
 169 
 170 static int
 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
 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
 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
 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
 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
 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
 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
 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
 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 *
 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
 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 *
 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
 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 *
 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
 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
 521 kmt_startup_isadep(mdb_tgt_t *t)
 522 {
 523 }