9210 remove KMDB branch debugging support
9211 ::crregs could do with cr2/cr3 support
9209 ::ttrace should be able to filter by thread
Reviewed by: Patrick Mooney <patrick.mooney@joyent.com>
Reviewed by: Yuri Pankov <yuripv@yuripv.net>

   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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright (c) 2013 by Delphix. All rights reserved.


  24  */
  25 
  26 #include <kmdb/kmdb_kvm.h>
  27 #include <kmdb/kvm.h>
  28 #include <kmdb/kmdb_kdi.h>
  29 #include <kmdb/kmdb_promif.h>
  30 #include <kmdb/kmdb_module.h>
  31 #include <kmdb/kmdb_asmutil.h>
  32 #include <mdb/mdb_types.h>
  33 #include <mdb/mdb_conf.h>
  34 #include <mdb/mdb_err.h>
  35 #include <mdb/mdb_modapi.h>
  36 #include <mdb/mdb_target_impl.h>
  37 #include <mdb/mdb_debug.h>
  38 #include <mdb/mdb_string.h>
  39 #include <mdb/mdb_ctf.h>
  40 #include <mdb/mdb_kreg_impl.h>
  41 #include <mdb/mdb_ks.h>
  42 #include <mdb/mdb.h>
  43 
  44 #include <strings.h>
  45 #include <dlfcn.h>
  46 #include <sys/isa_defs.h>
  47 #include <sys/kobj.h>
  48 #include <sys/kobj_impl.h>
  49 #include <sys/bitmap.h>
  50 #include <vm/as.h>
  51 
  52 static const char KMT_RTLD_NAME[] = "krtld";
  53 static const char KMT_MODULE[] = "mdb_ks";
  54 static const char KMT_CTFPARENT[] = "genunix";
  55 
  56 static mdb_list_t kmt_defbp_list;       /* List of current deferred bp's */
  57 static int kmt_defbp_lock;              /* For list, running kernel holds */
  58 static uint_t kmt_defbp_modchg_isload;  /* Whether mod change is load/unload */
  59 static struct modctl *kmt_defbp_modchg_modctl; /* modctl for defbp checking */
  60 static uint_t kmt_defbp_num;            /* Number of referenced def'd bp's */
  61 static int kmt_defbp_bpspec;            /* vespec for def'd bp activation bp */
  62 
  63 static const mdb_se_ops_t kmt_brkpt_ops;
  64 static const mdb_se_ops_t kmt_wapt_ops;
  65 
  66 static void kmt_sync(mdb_tgt_t *);
  67 
  68 typedef struct kmt_symarg {
  69         mdb_tgt_sym_f *sym_cb;          /* Caller's callback function */
  70         void *sym_data;                 /* Callback function argument */
  71         uint_t sym_type;                /* Symbol type/binding filter */
  72         mdb_syminfo_t sym_info;         /* Symbol id and table id */
  73         const char *sym_obj;            /* Containing object */
  74 } kmt_symarg_t;
  75 
  76 typedef struct kmt_maparg {
  77         mdb_tgt_t *map_target;          /* Target used for mapping iter */
  78         mdb_tgt_map_f *map_cb;          /* Caller's callback function */
  79         void *map_data;                 /* Callback function argument */
  80 } kmt_maparg_t;
  81 
  82 /*ARGSUSED*/
  83 int
  84 kmt_setflags(mdb_tgt_t *t, int flags)
  85 {
  86         /*
  87          * We only handle one flag (ALLOWIO), and we can't fail to set or clear
  88          * it, so we just blindly replace the t_flags version with the one
  89          * passed.
  90          */
  91         t->t_flags = (t->t_flags & ~MDB_TGT_F_ALLOWIO) |
  92             (flags & MDB_TGT_F_ALLOWIO);
  93 
  94         return (0);
  95 }
  96 
  97 /*ARGSUSED*/
  98 const char *
  99 kmt_name(mdb_tgt_t *t)
 100 {
 101         return ("kmdb_kvm");
 102 }
 103 
 104 /*ARGSUSED*/
 105 static const char *
 106 kmt_platform(mdb_tgt_t *t)
 107 {
 108         static char platform[SYS_NMLN];
 109 
 110         if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT)
 111                 return (mdb_conf_platform());
 112 
 113         if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, platform,
 114             sizeof (platform), "unix", "platform") != sizeof (platform)) {
 115                 warn("'platform' symbol is missing from kernel\n");
 116                 return ("unknown");
 117         }
 118 
 119         return (platform);
 120 }
 121 
 122 static int
 123 kmt_uname(mdb_tgt_t *t, struct utsname *utsp)
 124 {
 125         return (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, utsp,
 126             sizeof (struct utsname), MDB_TGT_OBJ_EXEC, "utsname"));
 127 }
 128 
 129 /*ARGSUSED*/
 130 static int
 131 kmt_dmodel(mdb_tgt_t *t)
 132 {
 133         return (MDB_TGT_MODEL_NATIVE);
 134 }
 135 
 136 /*ARGSUSED*/
 137 ssize_t
 138 kmt_rw(mdb_tgt_t *t, void *buf, size_t nbytes, uint64_t addr,
 139     ssize_t (*rw)(void *, size_t, uint64_t))
 140 {
 141         /*
 142          * chunksz needs to be volatile because of the use of setjmp() in this
 143          * function.
 144          */
 145         volatile size_t chunksz;
 146         size_t n, ndone;
 147         jmp_buf *oldpcb = NULL;
 148         jmp_buf pcb;
 149         ssize_t res;
 150 
 151         kmdb_prom_check_interrupt();
 152 
 153         if (nbytes == 0)
 154                 return (0);
 155 
 156         /*
 157          * Try to process the entire buffer, as requested.  If we catch a fault,
 158          * try smaller chunks.  This allows us to handle regions that cross
 159          * mapping boundaries.
 160          */
 161         chunksz = nbytes;
 162         ndone = 0;
 163         if (setjmp(pcb) != 0) {
 164                 if (chunksz == 1) {
 165                         /* We failed with the smallest chunk - give up */
 166                         kmdb_dpi_restore_fault_hdlr(oldpcb);
 167                         return (ndone > 0 ? ndone : -1); /* errno set for us */
 168                 } else if (chunksz > 4)
 169                         chunksz = 4;
 170                 else
 171                         chunksz = 1;
 172         }
 173 
 174         oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
 175         while (nbytes > 0) {
 176                 n = MIN(chunksz, nbytes);
 177 
 178                 if ((res = rw(buf, n, addr)) != n)
 179                         return (res < 0 ? res : ndone + res);
 180 
 181                 addr += n;
 182                 nbytes -= n;
 183                 ndone += n;
 184                 buf = ((caddr_t)buf + n);
 185         }
 186 
 187         kmdb_dpi_restore_fault_hdlr(oldpcb);
 188 
 189         return (ndone);
 190 }
 191 
 192 static void
 193 kmt_bcopy(const void *s1, void *s2, size_t n)
 194 {
 195         /*
 196          * We need to guarantee atomic accesses for certain sizes.  bcopy won't
 197          * make that guarantee, so we need to do it ourselves.
 198          */
 199 #ifdef  _LP64
 200         if (n == 8 && ((uintptr_t)s1 & 7) == 0 && ((uintptr_t)s2 & 7) == 0)
 201                 *(uint64_t *)s2 = *(uint64_t *)s1;
 202         else
 203 #endif
 204         if (n == 4 && ((uintptr_t)s1 & 3) == 0 && ((uintptr_t)s2 & 3) == 0)
 205                 *(uint32_t *)s2 = *(uint32_t *)s1;
 206         else if (n == 2 && ((uintptr_t)s1 & 1) == 0 && ((uintptr_t)s2 & 1) == 0)
 207                 *(uint16_t *)s2 = *(uint16_t *)s1;
 208         else if (n == 1)
 209                 *(uint8_t *)s2 = *(uint8_t *)s1;
 210         else
 211                 bcopy(s1, s2, n);
 212 }
 213 
 214 static ssize_t
 215 kmt_reader(void *buf, size_t nbytes, uint64_t addr)
 216 {
 217         kmt_bcopy((void *)(uintptr_t)addr, buf, nbytes);
 218         return (nbytes);
 219 }
 220 
 221 ssize_t
 222 kmt_writer(void *buf, size_t nbytes, uint64_t addr)
 223 {
 224         kmt_bcopy(buf, (void *)(uintptr_t)addr, nbytes);
 225         return (nbytes);
 226 }
 227 
 228 /*ARGSUSED*/
 229 static ssize_t
 230 kmt_read(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr)
 231 {
 232         /*
 233          * We don't want to allow reads of I/O-mapped memory.  Multi-page reads
 234          * that cross into I/O-mapped memory should be restricted to the initial
 235          * non-I/O region.  Reads that begin in I/O-mapped memory are failed
 236          * outright.
 237          */
 238         if (!(t->t_flags & MDB_TGT_F_ALLOWIO) &&
 239             (nbytes = kmdb_kdi_range_is_nontoxic(addr, nbytes, 0)) == 0)
 240                 return (set_errno(EMDB_NOMAP));
 241 
 242         return (kmt_rw(t, buf, nbytes, addr, kmt_reader));
 243 }
 244 
 245 /*ARGSUSED*/
 246 static ssize_t
 247 kmt_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr)
 248 {
 249         return (kmt_rw(t, buf, nbytes, addr, kmdb_kdi_pread));
 250 }
 251 
 252 /*ARGSUSED*/
 253 ssize_t
 254 kmt_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr)
 255 {
 256         return (kmt_rw(t, (void *)buf, nbytes, addr, kmdb_kdi_pwrite));
 257 }
 258 
 259 static uintptr_t
 260 kmt_read_kas(mdb_tgt_t *t)
 261 {
 262         GElf_Sym sym;
 263 
 264         if (mdb_tgt_lookup_by_name(t, "unix", "kas", &sym, NULL) < 0) {
 265                 warn("'kas' symbol is missing from kernel\n");
 266                 (void) set_errno(EMDB_NOSYM);
 267                 return (0);
 268         }
 269 
 270         return ((uintptr_t)sym.st_value);
 271 }
 272 
 273 static int
 274 kmt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap)
 275 {
 276         mdb_module_t *mod;
 277         struct as *asp;
 278         mdb_var_t *v;
 279 
 280         switch ((uintptr_t)as) {
 281         case (uintptr_t)MDB_TGT_AS_PHYS:
 282         case (uintptr_t)MDB_TGT_AS_FILE:
 283         case (uintptr_t)MDB_TGT_AS_IO:
 284                 return (set_errno(EINVAL));
 285         case (uintptr_t)MDB_TGT_AS_VIRT:
 286                 if ((asp = (struct as *)kmt_read_kas(t)) == NULL)
 287                         return (-1); /* errno is set for us */
 288                 break;
 289         default:
 290                 asp = (struct as *)as;
 291 
 292                 /* We don't support non-kas vtop */
 293                 if (asp != (struct as *)kmt_read_kas(t))
 294                         return (set_errno(EMDB_TGTNOTSUP));
 295         }
 296 
 297         if (kmdb_prom_vtop(va, pap) == 0)
 298                 return (0);
 299 
 300         if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL &&
 301             (mod = mdb_nv_get_cookie(v)) != NULL) {
 302                 int (*fptr)(uintptr_t, struct as *, physaddr_t *);
 303 
 304                 fptr = (int (*)(uintptr_t, struct as *, physaddr_t *))
 305                     dlsym(mod->mod_hdl, "platform_vtop");
 306 
 307                 if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0))
 308                         return (0);
 309         }
 310 
 311         return (set_errno(EMDB_NOMAP));
 312 }
 313 
 314 /*ARGSUSED*/
 315 static int
 316 kmt_cpuregs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 317 {
 318         const mdb_tgt_gregset_t *gregs;
 319         intptr_t cpuid = DPI_MASTER_CPUID;
 320         int i;
 321 
 322         if (flags & DCMD_ADDRSPEC) {
 323                 if (argc != 0)
 324                         return (DCMD_USAGE);
 325                 if ((cpuid = mdb_cpu2cpuid(addr)) < 0) {
 326                         (void) set_errno(EMDB_NOMAP);
 327                         mdb_warn("failed to find cpuid for cpu at %p", addr);
 328                         return (DCMD_ERR);
 329                 }
 330         }
 331 
 332         i = mdb_getopts(argc, argv,
 333             'c', MDB_OPT_UINTPTR, &cpuid,
 334             NULL);
 335 
 336         argc -= i;
 337         argv += i;
 338 
 339         if (argc != 0)
 340                 return (DCMD_USAGE);
 341 
 342         if ((gregs = kmdb_dpi_get_gregs(cpuid)) == NULL) {
 343                 warn("failed to retrieve registers for cpu %d", (int)cpuid);
 344                 return (DCMD_ERR);
 345         }
 346 
 347         kmt_printregs(gregs);
 348 
 349         return (DCMD_OK);
 350 }
 351 
 352 static int
 353 kmt_regs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 354 {
 355         if (flags & DCMD_ADDRSPEC)
 356                 return (DCMD_USAGE);
 357 
 358         return (kmt_cpuregs(addr, flags, argc, argv));
 359 }
 360 
 361 static int
 362 kmt_cpustack_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 363 {
 364         intptr_t cpuid = DPI_MASTER_CPUID;
 365         uint_t verbose = 0;
 366         int i;
 367 
 368         if (flags & DCMD_ADDRSPEC) {
 369                 if ((cpuid = mdb_cpu2cpuid(addr)) < 0) {
 370                         (void) set_errno(EMDB_NOMAP);
 371                         mdb_warn("failed to find cpuid for cpu at %p", addr);
 372                         return (DCMD_ERR);
 373                 }
 374                 flags &= ~DCMD_ADDRSPEC;
 375         }
 376 
 377         i = mdb_getopts(argc, argv,
 378             'c', MDB_OPT_UINTPTR, &cpuid,
 379             'v', MDB_OPT_SETBITS, 1, &verbose,
 380             NULL);
 381 
 382         argc -= i;
 383         argv += i;
 384 
 385         return (kmt_cpustack(addr, flags, argc, argv, cpuid, verbose));
 386 }
 387 
 388 /*
 389  * Lasciate ogne speranza, voi ch'intrate.
 390  */
 391 static int
 392 kmt_call(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 393 {
 394         uintptr_t *call_argv, rval;
 395         int parse_strings = 1;
 396         GElf_Sym sym;
 397         jmp_buf *oldpcb = NULL;
 398         jmp_buf pcb;
 399         int i;
 400 
 401         if (!(flags & DCMD_ADDRSPEC))
 402                 return (DCMD_USAGE);
 403 
 404         if (mdb_tgt_lookup_by_addr(mdb.m_target, addr, MDB_TGT_SYM_EXACT,
 405             NULL, 0, &sym, NULL) == 0 && GELF_ST_TYPE(sym.st_info) !=
 406             STT_FUNC) {
 407                 warn("%a is not a function\n", addr);
 408                 return (DCMD_ERR);
 409         }
 410 
 411         if (argc > 1 && argv[0].a_type == MDB_TYPE_STRING &&
 412             strcmp(argv[0].a_un.a_str, "-s") == 0) {
 413                 parse_strings = 0;
 414                 argc--;
 415                 argv++;
 416         }
 417 
 418         call_argv = mdb_alloc(sizeof (uintptr_t) * argc, UM_SLEEP);
 419 
 420         for (i = 0; i < argc; i++) {
 421                 switch (argv[i].a_type) {
 422                 case MDB_TYPE_STRING:
 423                         /*
 424                          * mdb_strtoull doesn't return on error, so we have to
 425                          * pre-check strings suspected to contain numbers.
 426                          */
 427                         if (parse_strings && strisbasenum(argv[i].a_un.a_str)) {
 428                                 call_argv[i] = (uintptr_t)mdb_strtoull(
 429                                     argv[i].a_un.a_str);
 430                         } else
 431                                 call_argv[i] = (uintptr_t)argv[i].a_un.a_str;
 432 
 433                         break;
 434 
 435                 case MDB_TYPE_IMMEDIATE:
 436                         call_argv[i] = argv[i].a_un.a_val;
 437                         break;
 438 
 439                 default:
 440                         mdb_free(call_argv,
 441                             sizeof (uintptr_t) * argc);
 442                         return (DCMD_USAGE);
 443                 }
 444         }
 445 
 446         if (setjmp(pcb) != 0) {
 447                 warn("call failed: caught a trap\n");
 448 
 449                 kmdb_dpi_restore_fault_hdlr(oldpcb);
 450                 mdb_free(call_argv, sizeof (uintptr_t) * argc);
 451                 return (DCMD_ERR);
 452         }
 453 
 454         oldpcb = kmdb_dpi_set_fault_hdlr(&pcb);
 455         rval = kmdb_dpi_call(addr, argc, call_argv);
 456         kmdb_dpi_restore_fault_hdlr(oldpcb);
 457 
 458         if (flags & DCMD_PIPE_OUT) {
 459                 mdb_printf("%p\n", rval);
 460         } else {
 461                 /* pretty-print the results */
 462                 mdb_printf("%p = %a(", rval, addr);
 463                 for (i = 0; i < argc; i++) {
 464                         if (i > 0)
 465                                 mdb_printf(", ");
 466                         if (argv[i].a_type == MDB_TYPE_STRING) {
 467                                 /* I'm ashamed but amused */
 468                                 char *quote = &("\""[parse_strings &&
 469                                     strisbasenum(argv[i].a_un.a_str)]);
 470 
 471                                 mdb_printf("%s%s%s", quote, argv[i].a_un.a_str,
 472                                     quote);
 473                         } else
 474                                 mdb_printf("%p", argv[i].a_un.a_val);
 475                 }
 476                 mdb_printf(");\n");
 477         }
 478 
 479         mdb_free(call_argv, sizeof (uintptr_t) * argc);
 480 
 481         return (DCMD_OK);
 482 }
 483 
 484 /*ARGSUSED*/
 485 int
 486 kmt_dump_crumbs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 487 {
 488         intptr_t cpu = -1;
 489 
 490         if (flags & DCMD_ADDRSPEC) {
 491                 if (argc != 0)
 492                         return (DCMD_USAGE);
 493         } else {
 494                 addr = 0;
 495 
 496                 if (mdb_getopts(argc, argv,
 497                     'c', MDB_OPT_UINTPTR, &cpu,
 498                     NULL) != argc)
 499                         return (DCMD_USAGE);
 500         }
 501 
 502         kmdb_dpi_dump_crumbs(addr, cpu);
 503 
 504         return (DCMD_OK);
 505 }
 506 
 507 /*ARGSUSED*/
 508 static int
 509 kmt_noducttape(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 510 {
 511         int a = 0;
 512 
 513         return (a/a);
 514 }
 515 
 516 static int
 517 kmt_dmod_status(char *msg, int state)
 518 {
 519         kmdb_modctl_t *kmc;
 520         mdb_var_t *v;
 521         int first = 1, n = 0;
 522 
 523         mdb_nv_rewind(&mdb.m_dmodctl);
 524         while ((v = mdb_nv_advance(&mdb.m_dmodctl)) != NULL) {
 525                 kmc = MDB_NV_COOKIE(v);
 526 
 527                 if (kmc->kmc_state != state)
 528                         continue;
 529 
 530                 n++;
 531 
 532                 if (msg != NULL) {
 533                         if (first) {
 534                                 mdb_printf(msg, NULL);
 535                                 first = 0;
 536                         }
 537 
 538                         mdb_printf(" %s", kmc->kmc_modname);
 539                 }
 540         }
 541 
 542         if (!first && msg != NULL)
 543                 mdb_printf("\n");
 544 
 545         return (n);
 546 }
 547 
 548 /*ARGSUSED*/
 549 static int
 550 kmt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 551 {
 552         kmt_data_t *kmt = mdb.m_target->t_data;
 553         struct utsname uts;
 554         char uuid[37];
 555         kreg_t tt;
 556 
 557         if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, &uts, sizeof (uts),
 558             "unix", "utsname") != sizeof (uts)) {
 559                 warn("failed to read 'utsname' struct from kernel\n");
 560                 bzero(&uts, sizeof (uts));
 561                 (void) strcpy(uts.nodename, "unknown machine");
 562         }
 563 
 564         mdb_printf("debugging live kernel (%d-bit) on %s\n",
 565             (int)(sizeof (void *) * NBBY),
 566             (*uts.nodename == '\0' ? "(not set)" : uts.nodename));
 567         mdb_printf("operating system: %s %s (%s)\n",
 568             uts.release, uts.version, uts.machine);
 569 
 570         if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, uuid, sizeof (uuid),
 571             "genunix", "dump_osimage_uuid") != sizeof (uuid)) {
 572                 warn("failed to read 'dump_osimage_uuid' string from kernel\n");
 573                 (void) strcpy(uuid, "(error)");
 574         } else if (*uuid == '\0') {
 575                 (void) strcpy(uuid, "(not set)");
 576         } else if (uuid[36] != '\0') {
 577                 (void) strcpy(uuid, "(invalid)");
 578         }
 579         mdb_printf("image uuid: %s\n", uuid);
 580 
 581         if (kmt->kmt_cpu != NULL) {
 582                 mdb_printf("CPU-specific support: %s\n",
 583                     kmt_cpu_name(kmt->kmt_cpu));
 584         }
 585 
 586         mdb_printf("DTrace state: %s\n", (kmdb_kdi_dtrace_get_state() ==
 587             KDI_DTSTATE_DTRACE_ACTIVE ? "active (debugger breakpoints cannot "
 588             "be armed)" : "inactive"));
 589 
 590         (void) kmdb_dpi_get_register("tt", &tt);
 591         mdb_printf("stopped on: %s\n", kmt_trapname(tt));
 592 
 593         (void) kmt_dmod_status("pending dmod loads:", KMDB_MC_STATE_LOADING);
 594         (void) kmt_dmod_status("pending dmod unloads:",
 595             KMDB_MC_STATE_UNLOADING);
 596 
 597         return (DCMD_OK);
 598 }
 599 
 600 /*ARGSUSED*/
 601 static int
 602 kmt_switch(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 603 {
 604         if (!(flags & DCMD_ADDRSPEC) || argc != 0)
 605                 return (DCMD_USAGE);
 606 
 607         if (kmdb_dpi_switch_master((int)addr) < 0) {
 608                 warn("failed to switch to CPU %d", (int)addr);
 609                 return (DCMD_ERR);
 610         }
 611 
 612         return (DCMD_OK);
 613 }
 614 
 615 static const mdb_dcmd_t kmt_dcmds[] = {
 616         { "$c", "?[cnt]", "print stack backtrace", kmt_stack },
 617         { "$C", "?[cnt]", "print stack backtrace", kmt_stackv },
 618         { "$r", NULL, "print general-purpose registers", kmt_regs },
 619         { "$?", NULL, "print status and registers", kmt_regs },
 620         { ":x", ":", "change the active CPU", kmt_switch },
 621         { "call", ":[arg ...]", "call a kernel function", kmt_call },
 622         { "cpustack", "?[-v] [-c cpuid] [cnt]", "print stack backtrace for a "
 623             "specific CPU", kmt_cpustack_dcmd },
 624         { "cpuregs", "?[-c cpuid]", "print general-purpose registers for a "
 625             "specific CPU", kmt_cpuregs },
 626         { "crumbs", NULL, NULL, kmt_dump_crumbs },
 627 #if defined(__i386) || defined(__amd64)
 628         { "in", ":[-L len]", "read from I/O port", kmt_in_dcmd },
 629         { "out", ":[-L len] val", "write to I/O port", kmt_out_dcmd },
 630         { "rdmsr", ":", "read an MSR", kmt_rdmsr },
 631         { "wrmsr", ": val", "write an MSR", kmt_wrmsr },
 632         { "rdpcicfg", ": bus dev func", "read a register in PCI config space",
 633         kmt_rdpcicfg },
 634         { "wrpcicfg", ": bus dev func val", "write a register in PCI config "
 635         "space", kmt_wrpcicfg },
 636 #endif
 637         { "noducttape", NULL, NULL, kmt_noducttape },
 638         { "regs", NULL, "print general-purpose registers", kmt_regs },
 639         { "stack", "?[cnt]", "print stack backtrace", kmt_stack },
 640         { "stackregs", "?", "print stack backtrace and registers", kmt_stackr },
 641         { "status", NULL, "print summary of current target", kmt_status_dcmd },
 642         { "switch", ":", "change the active CPU", kmt_switch },
 643         { NULL }
 644 };
 645 
 646 static uintmax_t
 647 kmt_reg_disc_get(const mdb_var_t *v)
 648 {
 649         mdb_tgt_reg_t r = 0;
 650 
 651         (void) mdb_tgt_getareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), &r);
 652 
 653         return (r);
 654 }
 655 
 656 static void
 657 kmt_reg_disc_set(mdb_var_t *v, uintmax_t r)
 658 {
 659         if (mdb_tgt_putareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), r) == -1)
 660                 warn("failed to modify %%%s register", mdb_nv_get_name(v));
 661 }
 662 
 663 static const mdb_nv_disc_t kmt_reg_disc = {
 664         kmt_reg_disc_set,
 665         kmt_reg_disc_get
 666 };
 667 
 668 /*ARGSUSED*/
 669 static int
 670 kmt_getareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname,
 671     mdb_tgt_reg_t *rp)
 672 {
 673         kreg_t val;
 674 
 675         if (kmdb_dpi_get_register(rname, &val) < 0)
 676                 return (set_errno(EMDB_BADREG));
 677 
 678         *rp = val;
 679         return (0);
 680 }
 681 
 682 /*ARGSUSED*/
 683 static int
 684 kmt_putareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, mdb_tgt_reg_t r)
 685 {
 686         if (kmdb_dpi_set_register(rname, r) < 0)
 687                 return (set_errno(EMDB_BADREG));
 688 
 689         return (0);
 690 }
 691 
 692 static void
 693 kmt_mod_destroy(kmt_module_t *km)
 694 {
 695         if (km->km_name != NULL)
 696                 strfree(km->km_name);
 697         if (km->km_symtab != NULL)
 698                 mdb_gelf_symtab_destroy(km->km_symtab);
 699         if (km->km_ctfp != NULL)
 700                 mdb_ctf_close(km->km_ctfp);
 701 }
 702 
 703 static kmt_module_t *
 704 kmt_mod_create(mdb_tgt_t *t, struct modctl *ctlp, char *name)
 705 {
 706         kmt_module_t *km = mdb_zalloc(sizeof (kmt_module_t), UM_SLEEP);
 707         struct module *mod;
 708 
 709         km->km_name = mdb_alloc(strlen(name) + 1, UM_SLEEP);
 710         (void) strcpy(km->km_name, name);
 711 
 712         bcopy(ctlp, &km->km_modctl, sizeof (struct modctl));
 713 
 714         if (mdb_tgt_vread(t, &km->km_module, sizeof (struct module),
 715             (uintptr_t)km->km_modctl.mod_mp) != sizeof (struct module))
 716                 goto create_module_cleanup;
 717         mod = &km->km_module;
 718 
 719         if (mod->symhdr != NULL && mod->strhdr != NULL && mod->symtbl != NULL &&
 720             mod->strings != NULL) {
 721                 mdb_gelf_ehdr_to_gehdr(&mod->hdr, &km->km_ehdr);
 722 
 723                 km->km_symtab = mdb_gelf_symtab_create_raw(&km->km_ehdr,
 724                     mod->symhdr, mod->symtbl, mod->strhdr, mod->strings,
 725                     MDB_TGT_SYMTAB);
 726 
 727                 km->km_symtab_va = mod->symtbl;
 728                 km->km_strtab_va = mod->strings;
 729 
 730                 if (mdb_tgt_vread(t, &km->km_symtab_hdr, sizeof (Shdr),
 731                     (uintptr_t)mod->symhdr) != sizeof (Shdr) ||
 732                     mdb_tgt_vread(t, &km->km_strtab_hdr, sizeof (Shdr),
 733                     (uintptr_t)mod->strhdr) != sizeof (Shdr))
 734                         goto create_module_cleanup;
 735         }
 736 
 737         /*
 738          * We don't want everyone rooting around in the module structure, so we
 739          * make copies of the interesting members.
 740          */
 741         km->km_text_va = (uintptr_t)mod->text;
 742         km->km_text_size = mod->text_size;
 743         km->km_data_va = (uintptr_t)mod->data;
 744         km->km_data_size = mod->data_size;
 745         km->km_bss_va = (uintptr_t)mod->bss;
 746         km->km_bss_size = mod->bss_size;
 747         km->km_ctf_va = mod->ctfdata;
 748         km->km_ctf_size = mod->ctfsize;
 749 
 750         if (mod->flags & KOBJ_PRIM)
 751                 km->km_flags |= KM_F_PRIMARY;
 752 
 753         return (km);
 754 
 755 create_module_cleanup:
 756         warn("failed to read module %s\n", name);
 757         kmt_mod_destroy(km);
 758         return (NULL);
 759 }
 760 
 761 static void
 762 kmt_mod_remove(kmt_data_t *kmt, kmt_module_t *km)
 763 {
 764         mdb_var_t *v = mdb_nv_lookup(&kmt->kmt_modules, km->km_name);
 765 
 766         ASSERT(v != NULL);
 767 
 768         mdb_dprintf(MDB_DBG_KMOD, "removing module %s\n", km->km_name);
 769 
 770         mdb_list_delete(&kmt->kmt_modlist, km);
 771         mdb_nv_remove(&kmt->kmt_modules, v);
 772         kmt_mod_destroy(km);
 773 }
 774 
 775 static int
 776 kmt_modlist_update_cb(struct modctl *modp, void *arg)
 777 {
 778         mdb_tgt_t *t = arg;
 779         kmt_data_t *kmt = t->t_data;
 780         kmt_module_t *km;
 781         mdb_var_t *v;
 782         char name[MAXNAMELEN];
 783 
 784         if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name, MAXNAMELEN,
 785             (uintptr_t)modp->mod_modname) <= 0) {
 786                 warn("failed to read module name at %p",
 787                     (void *)modp->mod_modname);
 788         }
 789 
 790         /* We only care about modules that are actually loaded */
 791         if (!kmdb_kdi_mod_isloaded(modp))
 792                 return (0);
 793 
 794         /*
 795          * Skip the modules we already know about and that haven't
 796          * changed since last time we were here.
 797          */
 798         if ((v = mdb_nv_lookup(&kmt->kmt_modules, name)) != NULL) {
 799                 km = MDB_NV_COOKIE(v);
 800 
 801                 if (kmdb_kdi_mod_haschanged(&km->km_modctl, &km->km_module,
 802                     modp, modp->mod_mp)) {
 803                         /*
 804                          * The module has changed since last we saw it.  For
 805                          * safety, remove our old version, and treat it as a
 806                          * new module.
 807                          */
 808                         mdb_dprintf(MDB_DBG_KMOD, "stutter module %s\n", name);
 809                         kmt_mod_remove(kmt, km);
 810                 } else {
 811                         km->km_seen = 1;
 812                         return (0);
 813                 }
 814         }
 815 
 816         mdb_dprintf(MDB_DBG_KMOD, "found new module %s\n", name);
 817 
 818         if ((km = kmt_mod_create(t, modp, name)) != NULL) {
 819                 mdb_list_append(&kmt->kmt_modlist, km);
 820                 (void) mdb_nv_insert(&kmt->kmt_modules, name, NULL,
 821                     (uintptr_t)km, 0);
 822                 km->km_seen = 1;
 823         }
 824 
 825         return (0);
 826 }
 827 
 828 static void
 829 kmt_modlist_update(mdb_tgt_t *t)
 830 {
 831         kmt_data_t *kmt = t->t_data;
 832         kmt_module_t *km, *kmn;
 833 
 834         if (kmdb_kdi_mod_iter(kmt_modlist_update_cb, t) < 0) {
 835                 warn("failed to complete update of kernel module list\n");
 836                 return;
 837         }
 838 
 839         km = mdb_list_next(&kmt->kmt_modlist);
 840         while (km != NULL) {
 841                 kmn = mdb_list_next(km);
 842 
 843                 if (km->km_seen == 1) {
 844                         /* Reset the mark for next time */
 845                         km->km_seen = 0;
 846                 } else {
 847                         /*
 848                          * We didn't see it on the kernel's module list, so
 849                          * remove it from our view of the world.
 850                          */
 851                         kmt_mod_remove(kmt, km);
 852                 }
 853 
 854                 km = kmn;
 855         }
 856 }
 857 
 858 static void
 859 kmt_periodic(mdb_tgt_t *t)
 860 {
 861         (void) mdb_tgt_status(t, &t->t_status);
 862 }
 863 
 864 int
 865 kmt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags,
 866     char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip)
 867 {
 868         kmt_data_t *kmt = t->t_data;
 869         kmt_module_t *km = mdb_list_next(&kmt->kmt_modlist);
 870         kmt_module_t *sym_km = NULL;
 871         kmt_module_t prmod;
 872         GElf_Sym sym;
 873         uint_t symid;
 874         const char *name;
 875 
 876         /*
 877          * We look through the private symbols (if any), then through the module
 878          * symbols.  We can simplify the loop if we pretend the private symbols
 879          * come from a module.
 880          */
 881         if (mdb.m_prsym != NULL) {
 882                 bzero(&prmod, sizeof (kmt_module_t));
 883                 prmod.km_name = "<<<prmod>>>";
 884                 prmod.km_symtab = mdb.m_prsym;
 885                 prmod.km_list.ml_next = (mdb_list_t *)km;
 886                 km = &prmod;
 887         }
 888 
 889         /* Symbol resolution isn't available during initialization */
 890         if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT)
 891                 return (set_errno(EMDB_NOSYM));
 892 
 893         for (; km != NULL; km = mdb_list_next(km)) {
 894                 if (km != &prmod && !kmt->kmt_symavail)
 895                         continue;
 896 
 897                 if (km->km_symtab == NULL)
 898                         continue;
 899 
 900                 if (mdb_gelf_symtab_lookup_by_addr(km->km_symtab, addr, flags,
 901                     buf, nbytes, symp, &sip->sym_id) != 0 ||
 902                     symp->st_value == 0)
 903                         continue;
 904 
 905                 if (flags & MDB_TGT_SYM_EXACT) {
 906                         sym_km = km;
 907                         goto found;
 908                 }
 909 
 910                 /*
 911                  * If this is the first match we've found, or if this symbol is
 912                  * closer to the specified address than the last one we found,
 913                  * use it.
 914                  */
 915                 if (sym_km == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) {
 916                         sym_km = km;
 917                         sym = *symp;
 918                         symid = sip->sym_id;
 919                 }
 920         }
 921 
 922         /*
 923          * kmdb dmods are normal kernel modules, loaded by krtld as such.  To
 924          * avoid polluting modinfo, and to keep from confusing the module
 925          * subsystem (many dmods have the same names as real kernel modules),
 926          * kmdb keeps their modctls separate, and doesn't allow their loading
 927          * to be broadcast via the krtld module load/unload mechanism.  As a
 928          * result, kmdb_kvm doesn't find out about them, and can't turn their
 929          * addresses into symbols.  This can be most inconvenient during
 930          * debugger faults, as the dmod frames will show up without names.
 931          * We weren't able to turn the requested address into a symbol, so we'll
 932          * take a spin through the dmods, trying to match our address against
 933          * their symbols.
 934          */
 935         if (sym_km == NULL) {
 936                 return (kmdb_module_lookup_by_addr(addr, flags, buf, nbytes,
 937                     symp, sip));
 938         }
 939 
 940         *symp = sym;
 941         sip->sym_id = symid;
 942 
 943 found:
 944         /*
 945          * Once we've found something, copy the final name into the caller's
 946          * buffer and prefix it with the load object name if appropriate.
 947          */
 948         name = mdb_gelf_sym_name(sym_km->km_symtab, symp);
 949 
 950         if (sym_km == &prmod) {
 951                 if (buf != NULL) {
 952                         (void) strncpy(buf, name, nbytes);
 953                         buf[nbytes - 1] = '\0';
 954                 }
 955                 sip->sym_table = MDB_TGT_PRVSYM;
 956         } else {
 957                 if (buf != NULL) {
 958                         if (sym_km->km_flags & KM_F_PRIMARY) {
 959                                 (void) strncpy(buf, name, nbytes);
 960                                 buf[nbytes - 1] = '\0';
 961                         } else {
 962                                 (void) mdb_snprintf(buf, nbytes, "%s`%s",
 963                                     sym_km->km_name, name);
 964                         }
 965                 }
 966                 sip->sym_table = MDB_TGT_SYMTAB;
 967         }
 968 
 969         return (0);
 970 }
 971 
 972 static int
 973 kmt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name,
 974     GElf_Sym *symp, mdb_syminfo_t *sip)
 975 {
 976         kmt_data_t *kmt = t->t_data;
 977         kmt_module_t *km;
 978         mdb_var_t *v;
 979         GElf_Sym sym;
 980         uint_t symid;
 981         int n;
 982 
 983         if (!kmt->kmt_symavail)
 984                 return (set_errno(EMDB_NOSYM));
 985 
 986         switch ((uintptr_t)obj) {
 987         case (uintptr_t)MDB_TGT_OBJ_EXEC:
 988         case (uintptr_t)MDB_TGT_OBJ_EVERY:
 989                 km = mdb_list_next(&kmt->kmt_modlist);
 990                 n = mdb_nv_size(&kmt->kmt_modules);
 991                 break;
 992 
 993         case (uintptr_t)MDB_TGT_OBJ_RTLD:
 994                 obj = kmt->kmt_rtld_name;
 995                 /*FALLTHROUGH*/
 996 
 997         default:
 998                 /*
 999                  * If this is a request for a dmod symbol, let kmdb_module
1000                  * handle it.
1001                  */
1002                 if (obj != NULL && strncmp(obj, "DMOD`", 5) == 0) {
1003                         return (kmdb_module_lookup_by_name(obj + 5, name,
1004                             symp, sip));
1005                 }
1006 
1007                 if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL)
1008                         return (set_errno(EMDB_NOOBJ));
1009 
1010                 km = mdb_nv_get_cookie(v);
1011                 n = 1;
1012         }
1013 
1014         /*
1015          * kmdb's kvm target is at a bit of a disadvantage compared to mdb's
1016          * kvm target when it comes to global symbol lookups.  mdb has ksyms,
1017          * which hides pesky things like symbols that are undefined in unix,
1018          * but which are defined in genunix.  We don't have such a facility -
1019          * we simply iterate through the modules, looking for a given symbol
1020          * in each.  Unless we're careful, we'll return the undef in the
1021          * aforementioned case.
1022          */
1023         for (; n > 0; n--, km = mdb_list_next(km)) {
1024                 if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name,
1025                     &sym, &symid) == 0 && sym.st_shndx != SHN_UNDEF)
1026                         break;
1027         }
1028 
1029         if (n == 0)
1030                 return (set_errno(EMDB_NOSYM));
1031 
1032 found:
1033         bcopy(&sym, symp, sizeof (GElf_Sym));
1034         sip->sym_id = symid;
1035         sip->sym_table = MDB_TGT_SYMTAB;
1036 
1037         return (0);
1038 }
1039 
1040 static int
1041 kmt_symtab_func(void *data, const GElf_Sym *sym, const char *name, uint_t id)
1042 {
1043         kmt_symarg_t *arg = data;
1044 
1045         if (mdb_tgt_sym_match(sym, arg->sym_type)) {
1046                 arg->sym_info.sym_id = id;
1047 
1048                 return (arg->sym_cb(arg->sym_data, sym, name, &arg->sym_info,
1049                     arg->sym_obj));
1050         }
1051 
1052         return (0);
1053 }
1054 
1055 static void
1056 kmt_symtab_iter(mdb_gelf_symtab_t *gst, uint_t type, const char *obj,
1057     mdb_tgt_sym_f *cb, void *p)
1058 {
1059         kmt_symarg_t arg;
1060 
1061         arg.sym_cb = cb;
1062         arg.sym_data = p;
1063         arg.sym_type = type;
1064         arg.sym_info.sym_table = gst->gst_tabid;
1065         arg.sym_obj = obj;
1066 
1067         mdb_gelf_symtab_iter(gst, kmt_symtab_func, &arg);
1068 }
1069 
1070 static int
1071 kmt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type,
1072     mdb_tgt_sym_f *cb, void *data)
1073 {
1074         kmt_data_t *kmt = t->t_data;
1075         kmt_module_t *km;
1076 
1077         mdb_gelf_symtab_t *symtab = NULL;
1078         mdb_var_t *v;
1079 
1080         if (which == MDB_TGT_DYNSYM)
1081                 return (set_errno(EMDB_TGTNOTSUP));
1082 
1083         switch ((uintptr_t)obj) {
1084         case (uintptr_t)MDB_TGT_OBJ_EXEC:
1085         case (uintptr_t)MDB_TGT_OBJ_EVERY:
1086                 mdb_nv_rewind(&kmt->kmt_modules);
1087                 while ((v = mdb_nv_advance(&kmt->kmt_modules)) != NULL) {
1088                         km = mdb_nv_get_cookie(v);
1089 
1090                         if (km->km_symtab != NULL) {
1091                                 kmt_symtab_iter(km->km_symtab, type,
1092                                     km->km_name, cb, data);
1093                         }
1094                 }
1095                 return (0);
1096 
1097         case (uintptr_t)MDB_TGT_OBJ_RTLD:
1098                 obj = kmt->kmt_rtld_name;
1099                 /*FALLTHROUGH*/
1100 
1101         default:
1102                 if (strncmp(obj, "DMOD`", 5) == 0) {
1103                         return (kmdb_module_symbol_iter(obj + 5, type,
1104                             cb, data));
1105                 }
1106 
1107                 if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL)
1108                         return (set_errno(EMDB_NOOBJ));
1109                 km = mdb_nv_get_cookie(v);
1110 
1111                 symtab = km->km_symtab;
1112         }
1113 
1114         if (symtab != NULL)
1115                 kmt_symtab_iter(symtab, type, obj, cb, data);
1116 
1117         return (0);
1118 }
1119 
1120 static int
1121 kmt_mapping_walk(uintptr_t addr, const void *data, kmt_maparg_t *marg)
1122 {
1123         /*
1124          * This is a bit sketchy but avoids problematic compilation of this
1125          * target against the current VM implementation.  Now that we have
1126          * vmem, we can make this less broken and more informative by changing
1127          * this code to invoke the vmem walker in the near future.
1128          */
1129         const struct kmt_seg {
1130                 caddr_t s_base;
1131                 size_t s_size;
1132         } *segp = (const struct kmt_seg *)data;
1133 
1134         mdb_map_t map;
1135         GElf_Sym sym;
1136         mdb_syminfo_t info;
1137 
1138         map.map_base = (uintptr_t)segp->s_base;
1139         map.map_size = segp->s_size;
1140         map.map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
1141 
1142         if (kmt_lookup_by_addr(marg->map_target, addr, MDB_TGT_SYM_EXACT,
1143             map.map_name, MDB_TGT_MAPSZ, &sym, &info) == -1) {
1144 
1145                 (void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ,
1146                     "%lr", addr);
1147         }
1148 
1149         return (marg->map_cb(marg->map_data, &map, map.map_name));
1150 }
1151 
1152 static int
1153 kmt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
1154 {
1155         kmt_maparg_t m;
1156         uintptr_t kas;
1157 
1158         m.map_target = t;
1159         m.map_cb = func;
1160         m.map_data = private;
1161 
1162         if ((kas = kmt_read_kas(t)) == NULL)
1163                 return (-1); /* errno is set for us */
1164 
1165         return (mdb_pwalk("seg", (mdb_walk_cb_t)kmt_mapping_walk, &m, kas));
1166 }
1167 
1168 static const mdb_map_t *
1169 kmt_mod_to_map(kmt_module_t *km, mdb_map_t *map)
1170 {
1171         (void) strncpy(map->map_name, km->km_name, MDB_TGT_MAPSZ);
1172         map->map_name[MDB_TGT_MAPSZ - 1] = '\0';
1173         map->map_base = km->km_text_va;
1174         map->map_size = km->km_text_size;
1175         map->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X;
1176 
1177         return (map);
1178 }
1179 
1180 static int
1181 kmt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private)
1182 {
1183         kmt_data_t *kmt = t->t_data;
1184         kmt_module_t *km;
1185         mdb_map_t m;
1186 
1187         for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1188             km = mdb_list_next(km)) {
1189                 if (func(private, kmt_mod_to_map(km, &m), km->km_name) == -1)
1190                         break;
1191         }
1192 
1193         return (0);
1194 }
1195 
1196 static const mdb_map_t *
1197 kmt_addr_to_map(mdb_tgt_t *t, uintptr_t addr)
1198 {
1199         kmt_data_t *kmt = t->t_data;
1200         kmt_module_t *km;
1201 
1202         for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1203             km = mdb_list_next(km)) {
1204                 if (addr - km->km_text_va < km->km_text_size ||
1205                     addr - km->km_data_va < km->km_data_size ||
1206                     addr - km->km_bss_va < km->km_bss_size)
1207                         return (kmt_mod_to_map(km, &kmt->kmt_map));
1208         }
1209 
1210         (void) set_errno(EMDB_NOMAP);
1211         return (NULL);
1212 }
1213 
1214 static kmt_module_t *
1215 kmt_module_by_name(kmt_data_t *kmt, const char *name)
1216 {
1217         kmt_module_t *km;
1218 
1219         for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1220             km = mdb_list_next(km)) {
1221                 if (strcmp(name, km->km_name) == 0)
1222                         return (km);
1223         }
1224 
1225         return (NULL);
1226 }
1227 
1228 static const mdb_map_t *
1229 kmt_name_to_map(mdb_tgt_t *t, const char *name)
1230 {
1231         kmt_data_t *kmt = t->t_data;
1232         kmt_module_t *km;
1233         mdb_map_t m;
1234 
1235         /*
1236          * If name is MDB_TGT_OBJ_EXEC, return the first module on the list,
1237          * which will be unix since we keep kmt_modlist in load order.
1238          */
1239         if (name == MDB_TGT_OBJ_EXEC) {
1240                 return (kmt_mod_to_map(mdb_list_next(&kmt->kmt_modlist),
1241                     &m));
1242         }
1243 
1244         if (name == MDB_TGT_OBJ_RTLD)
1245                 name = kmt->kmt_rtld_name;
1246 
1247         if ((km = kmt_module_by_name(kmt, name)) != NULL)
1248                 return (kmt_mod_to_map(km, &m));
1249 
1250         (void) set_errno(EMDB_NOOBJ);
1251         return (NULL);
1252 }
1253 
1254 static ctf_file_t *
1255 kmt_load_ctfdata(mdb_tgt_t *t, kmt_module_t *km)
1256 {
1257         kmt_data_t *kmt = t->t_data;
1258         int err;
1259 
1260         if (km->km_ctfp != NULL)
1261                 return (km->km_ctfp);
1262 
1263         if (km->km_ctf_va == NULL || km->km_symtab == NULL) {
1264                 (void) set_errno(EMDB_NOCTF);
1265                 return (NULL);
1266         }
1267 
1268         if ((km->km_ctfp = mdb_ctf_bufopen(km->km_ctf_va, km->km_ctf_size,
1269             km->km_symtab_va, &km->km_symtab_hdr, km->km_strtab_va,
1270             &km->km_strtab_hdr, &err)) == NULL) {
1271                 (void) set_errno(ctf_to_errno(err));
1272                 return (NULL);
1273         }
1274 
1275         mdb_dprintf(MDB_DBG_KMOD, "loaded %lu bytes of CTF data for %s\n",
1276             (ulong_t)km->km_ctf_size, km->km_name);
1277 
1278         if (ctf_parent_name(km->km_ctfp) != NULL) {
1279                 mdb_var_t *v;
1280 
1281                 if ((v = mdb_nv_lookup(&kmt->kmt_modules,
1282                     ctf_parent_name(km->km_ctfp))) != NULL) {
1283                         kmt_module_t *pm = mdb_nv_get_cookie(v);
1284 
1285                         if (pm->km_ctfp == NULL)
1286                                 (void) kmt_load_ctfdata(t, pm);
1287 
1288                         if (pm->km_ctfp != NULL && ctf_import(km->km_ctfp,
1289                             pm->km_ctfp) == CTF_ERR) {
1290                                 warn("failed to import parent types into "
1291                                     "%s: %s\n", km->km_name,
1292                                     ctf_errmsg(ctf_errno(km->km_ctfp)));
1293                         }
1294                 } else {
1295                         warn("failed to load CTF data for %s - parent %s not "
1296                             "loaded\n", km->km_name,
1297                             ctf_parent_name(km->km_ctfp));
1298                 }
1299         }
1300 
1301         return (km->km_ctfp);
1302 }
1303 
1304 ctf_file_t *
1305 kmt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr)
1306 {
1307         kmt_data_t *kmt = t->t_data;
1308         kmt_module_t *km;
1309 
1310         for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL;
1311             km = mdb_list_next(km)) {
1312                 if (addr - km->km_text_va < km->km_text_size ||
1313                     addr - km->km_data_va < km->km_data_size ||
1314                     addr - km->km_bss_va < km->km_bss_size)
1315                         return (kmt_load_ctfdata(t, km));
1316         }
1317 
1318         return (kmdb_module_addr_to_ctf(addr));
1319 }
1320 
1321 ctf_file_t *
1322 kmt_name_to_ctf(mdb_tgt_t *t, const char *name)
1323 {
1324         kmt_data_t *kt = t->t_data;
1325         kmt_module_t *km;
1326 
1327         if (name == MDB_TGT_OBJ_EXEC) {
1328                 name = KMT_CTFPARENT;
1329         } else if (name == MDB_TGT_OBJ_RTLD) {
1330                 name = kt->kmt_rtld_name;
1331         } else if (strncmp(name, "DMOD`", 5) == 0) {
1332                 /* Request for CTF data for a DMOD symbol */
1333                 return (kmdb_module_name_to_ctf(name + 5));
1334         }
1335 
1336         if ((km = kmt_module_by_name(kt, name)) != NULL)
1337                 return (kmt_load_ctfdata(t, km));
1338 
1339         (void) set_errno(EMDB_NOOBJ);
1340         return (NULL);
1341 }
1342 
1343 /*ARGSUSED*/
1344 static int
1345 kmt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1346 {
1347         int state;
1348 
1349         bzero(tsp, sizeof (mdb_tgt_status_t));
1350 
1351         switch ((state = kmdb_dpi_get_state(NULL))) {
1352         case DPI_STATE_INIT:
1353                 tsp->st_state = MDB_TGT_RUNNING;
1354                 tsp->st_pc = 0;
1355                 break;
1356 
1357         case DPI_STATE_STOPPED:
1358                 tsp->st_state = MDB_TGT_STOPPED;
1359 
1360                 (void) kmdb_dpi_get_register("pc", &tsp->st_pc);
1361                 break;
1362 
1363         case DPI_STATE_FAULTED:
1364                 tsp->st_state = MDB_TGT_STOPPED;
1365 
1366                 (void) kmdb_dpi_get_register("pc", &tsp->st_pc);
1367 
1368                 tsp->st_flags |= MDB_TGT_ISTOP;
1369                 break;
1370 
1371         case DPI_STATE_LOST:
1372                 tsp->st_state = MDB_TGT_LOST;
1373 
1374                 (void) kmdb_dpi_get_register("pc", &tsp->st_pc);
1375                 break;
1376         }
1377 
1378         mdb_dprintf(MDB_DBG_KMOD, "kmt_status, dpi: %d tsp: %d, pc = %p %A\n",
1379             state, tsp->st_state, (void *)tsp->st_pc, tsp->st_pc);
1380 
1381         return (0);
1382 }
1383 
1384 /*
1385  * Invoked when kmt_defbp_enter_debugger is called, this routine activates and
1386  * deactivates deferred breakpoints in response to module load and unload
1387  * events.
1388  */
1389 /*ARGSUSED*/
1390 static void
1391 kmt_defbp_event(mdb_tgt_t *t, int vid, void *private)
1392 {
1393         if (kmt_defbp_modchg_isload) {
1394                 if (!mdb_tgt_sespec_activate_all(t) &&
1395                     (mdb.m_flags & MDB_FL_BPTNOSYMSTOP)) {
1396                         /*
1397                          * We weren't able to activate the breakpoints.
1398                          * If so requested, we'll return without calling
1399                          * continue, thus throwing the user into the debugger.
1400                          */
1401                         return;
1402                 }
1403 
1404         } else {
1405                 mdb_sespec_t *sep, *nsep;
1406                 const mdb_map_t *map, *bpmap;
1407                 mdb_map_t modmap;
1408 
1409                 if ((map = kmt_addr_to_map(t,
1410                     (uintptr_t)kmt_defbp_modchg_modctl->mod_text)) == NULL) {
1411                         warn("module unload notification for unknown module %s",
1412                             kmt_defbp_modchg_modctl->mod_modname);
1413                         return; /* drop into the debugger */
1414                 }
1415 
1416                 bcopy(map, &modmap, sizeof (mdb_map_t));
1417 
1418                 for (sep = mdb_list_next(&t->t_active); sep; sep = nsep) {
1419                         nsep = mdb_list_next(sep);
1420 
1421                         if (sep->se_ops == &kmt_brkpt_ops) {
1422                                 kmt_brkpt_t *kb = sep->se_data;
1423 
1424                                 if ((bpmap = kmt_addr_to_map(t,
1425                                     kb->kb_addr)) == NULL ||
1426                                     (bpmap->map_base == modmap.map_base &&
1427                                     bpmap->map_size == modmap.map_size)) {
1428                                         mdb_tgt_sespec_idle_one(t, sep,
1429                                             EMDB_NOMAP);
1430                                 }
1431                         }
1432                 }
1433         }
1434 
1435         (void) mdb_tgt_continue(t, NULL);
1436 }
1437 
1438 static void
1439 kmt_defbp_enter_debugger(void)
1440 {
1441         /*
1442          * The debugger places a breakpoint here.  We can't have a simple
1443          * nop function here, because GCC knows much more than we do, and
1444          * will optimize away the call to it.
1445          */
1446         (void) get_fp();
1447 }
1448 
1449 /*
1450  * This routine is called while the kernel is running.  It attempts to determine
1451  * whether any deferred breakpoints exist for the module being changed (loaded
1452  * or unloaded).  If any such breakpoints exist, the debugger will be entered to
1453  * process them.
1454  */
1455 static void
1456 kmt_defbp_modchg(struct modctl *mctl, int isload)
1457 {
1458         kmt_defbp_t *dbp;
1459 
1460         kmt_defbp_lock = 1;
1461 
1462         for (dbp = mdb_list_next(&kmt_defbp_list); dbp;
1463             dbp = mdb_list_next(dbp)) {
1464                 if (!dbp->dbp_ref)
1465                         continue;
1466 
1467                 if (strcmp(mctl->mod_modname, dbp->dbp_objname) == 0) {
1468                         /*
1469                          * Activate the breakpoint
1470                          */
1471                         kmt_defbp_modchg_isload = isload;
1472                         kmt_defbp_modchg_modctl = mctl;
1473 
1474                         kmt_defbp_enter_debugger();
1475                         break;
1476                 }
1477         }
1478 
1479         kmt_defbp_lock = 0;
1480 }
1481 
1482 /*ARGSUSED*/
1483 static int
1484 kmt_continue(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1485 {
1486         int n;
1487 
1488         kmdb_dpi_resume();
1489 
1490         /*
1491          * The order of the following two calls is important.  If there are
1492          * load acks on the work queue, we'll initialize the dmods they
1493          * represent.  This will involve a call to _mdb_init, which may very
1494          * well result in a symbol lookup.  If we haven't resynced our view
1495          * of symbols with the current state of the world, this lookup could
1496          * end very badly.  We therefore make sure to sync before processing
1497          * the work queue.
1498          */
1499         kmt_sync(t);
1500         kmdb_dpi_process_work_queue();
1501 
1502         if (kmdb_kdi_get_unload_request())
1503                 t->t_flags |= MDB_TGT_F_UNLOAD;
1504 
1505         (void) mdb_tgt_status(t, &t->t_status);
1506 
1507         if ((n = kmt_dmod_status(NULL, KMDB_MC_STATE_LOADING) +
1508             kmt_dmod_status(NULL, KMDB_MC_STATE_UNLOADING)) != 0) {
1509                 mdb_warn("%d dmod load%c/unload%c pending\n", n,
1510                     "s"[n == 1], "s"[n == 1]);
1511         }
1512 
1513         return (0);
1514 }
1515 
1516 /*ARGSUSED*/
1517 static int
1518 kmt_step(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1519 {
1520         int rc;
1521 
1522         if ((rc = kmdb_dpi_step()) == 0)
1523                 (void) mdb_tgt_status(t, &t->t_status);
1524 
1525         return (rc);
1526 }
1527 
1528 static int
1529 kmt_defbp_activate(mdb_tgt_t *t)
1530 {
1531         kmdb_dpi_modchg_register(kmt_defbp_modchg);
1532 
1533         /*
1534          * The routines that add and arm breakpoints will check for the proper
1535          * DTrace state, but they'll just put this breakpoint on the idle list
1536          * if DTrace is active.  It'll correctly move to the active list when
1537          * DTrace deactivates, but that's insufficient for our purposes -- we
1538          * need to do extra processing at that point.  We won't get to do said
1539          * processing with with a normal idle->active transition, so we just
1540          * won't add it add it until we're sure that it'll stick.
1541          */
1542 
1543         if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
1544                 return (set_errno(EMDB_DTACTIVE));
1545 
1546         kmt_defbp_bpspec = mdb_tgt_add_vbrkpt(t,
1547             (uintptr_t)kmt_defbp_enter_debugger,
1548             MDB_TGT_SPEC_HIDDEN, kmt_defbp_event, NULL);
1549 
1550         return (0);
1551 }
1552 
1553 static void
1554 kmt_defbp_deactivate(mdb_tgt_t *t)
1555 {
1556         kmdb_dpi_modchg_cancel();
1557 
1558         if (kmt_defbp_bpspec != 0) {
1559                 if (t != NULL)
1560                         (void) mdb_tgt_vespec_delete(t, kmt_defbp_bpspec);
1561 
1562                 kmt_defbp_bpspec = 0;
1563         }
1564 }
1565 
1566 static kmt_defbp_t *
1567 kmt_defbp_create(mdb_tgt_t *t, const char *objname, const char *symname)
1568 {
1569         kmt_defbp_t *dbp = mdb_alloc(sizeof (kmt_defbp_t), UM_SLEEP);
1570 
1571         mdb_dprintf(MDB_DBG_KMOD, "defbp_create %s`%s\n", objname, symname);
1572 
1573         dbp->dbp_objname = strdup(objname);
1574         dbp->dbp_symname = strdup(symname);
1575         dbp->dbp_ref = 1;
1576 
1577         kmt_defbp_num++;
1578 
1579         if (kmt_defbp_num == 1 || kmt_defbp_bpspec == 0) {
1580                 if (kmt_defbp_activate(t) < 0)
1581                         warn("failed to activate deferred breakpoints");
1582         }
1583 
1584         mdb_list_append(&kmt_defbp_list, dbp);
1585 
1586         return (dbp);
1587 }
1588 
1589 static void
1590 kmt_defbp_destroy(kmt_defbp_t *dbp)
1591 {
1592         mdb_dprintf(MDB_DBG_KMOD, "defbp_destroy %s`%s\n", dbp->dbp_objname,
1593             dbp->dbp_symname);
1594 
1595         mdb_list_delete(&kmt_defbp_list, dbp);
1596 
1597         strfree(dbp->dbp_objname);
1598         strfree(dbp->dbp_symname);
1599         mdb_free(dbp, sizeof (kmt_defbp_t));
1600 }
1601 
1602 static void
1603 kmt_defbp_prune_common(int all)
1604 {
1605         kmt_defbp_t *dbp, *ndbp;
1606 
1607         /* We can't remove items from the list while the driver is using it. */
1608         if (kmt_defbp_lock)
1609                 return;
1610 
1611         for (dbp = mdb_list_next(&kmt_defbp_list); dbp != NULL; dbp = ndbp) {
1612                 ndbp = mdb_list_next(dbp);
1613 
1614                 if (!all && dbp->dbp_ref)
1615                         continue;
1616 
1617                 kmt_defbp_destroy(dbp);
1618         }
1619 }
1620 
1621 static void
1622 kmt_defbp_prune(void)
1623 {
1624         kmt_defbp_prune_common(0);
1625 }
1626 
1627 static void
1628 kmt_defbp_destroy_all(void)
1629 {
1630         kmt_defbp_prune_common(1);
1631 }
1632 
1633 static void
1634 kmt_defbp_delete(mdb_tgt_t *t, kmt_defbp_t *dbp)
1635 {
1636         dbp->dbp_ref = 0;
1637 
1638         ASSERT(kmt_defbp_num > 0);
1639         kmt_defbp_num--;
1640 
1641         if (kmt_defbp_num == 0)
1642                 kmt_defbp_deactivate(t);
1643 
1644         kmt_defbp_prune();
1645 }
1646 
1647 static int
1648 kmt_brkpt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1649 {
1650         mdb_tgt_status_t tsp;
1651         kmt_bparg_t *ka = args;
1652         kmt_brkpt_t *kb;
1653         GElf_Sym s;
1654         mdb_instr_t instr;
1655 
1656         (void) mdb_tgt_status(t, &tsp);
1657         if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED)
1658                 return (set_errno(EMDB_NOPROC));
1659 
1660         if (ka->ka_symbol != NULL) {
1661                 if (mdb_tgt_lookup_by_scope(t, ka->ka_symbol, &s, NULL) == -1) {
1662                         if (errno != EMDB_NOOBJ && !(errno == EMDB_NOSYM &&
1663                             !(mdb.m_flags & MDB_FL_BPTNOSYMSTOP))) {
1664                                 warn("breakpoint %s activation failed",
1665                                     ka->ka_symbol);
1666                         }
1667                         return (-1); /* errno is set for us */
1668                 }
1669 
1670                 ka->ka_addr = (uintptr_t)s.st_value;
1671         }
1672 
1673 #ifdef __sparc
1674         if (ka->ka_addr & 3)
1675                 return (set_errno(EMDB_BPALIGN));
1676 #endif
1677 
1678         if (mdb_vread(&instr, sizeof (instr), ka->ka_addr) != sizeof (instr))
1679                 return (-1); /* errno is set for us */
1680 
1681         if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
1682                 warn("breakpoint will not arm until DTrace is inactive\n");
1683 
1684         kb = mdb_zalloc(sizeof (kmt_brkpt_t), UM_SLEEP);
1685         kb->kb_addr = ka->ka_addr;
1686         sep->se_data = kb;
1687 
1688         return (0);
1689 }
1690 
1691 /*ARGSUSED*/
1692 static void
1693 kmt_brkpt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep)
1694 {
1695         mdb_free(sep->se_data, sizeof (kmt_brkpt_t));
1696 }
1697 
1698 /*ARGSUSED*/
1699 static char *
1700 kmt_brkpt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
1701     mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
1702 {
1703         uintptr_t addr = NULL;
1704 
1705         if (vep != NULL) {
1706                 kmt_bparg_t *ka = vep->ve_args;
1707 
1708                 if (ka->ka_symbol != NULL) {
1709                         (void) mdb_iob_snprintf(buf, nbytes, "stop at %s",
1710                             ka->ka_symbol);
1711                 } else {
1712                         (void) mdb_iob_snprintf(buf, nbytes, "stop at %a",
1713                             ka->ka_addr);
1714                         addr = ka->ka_addr;
1715                 }
1716 
1717         } else {
1718                 addr = ((kmt_brkpt_t *)sep->se_data)->kb_addr;
1719                 (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", addr);
1720         }
1721 
1722         sp->spec_base = addr;
1723         sp->spec_size = sizeof (mdb_instr_t);
1724 
1725         return (buf);
1726 }
1727 
1728 static int
1729 kmt_brkpt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1730 {
1731         kmt_brkpt_t *kb = sep->se_data;
1732         kmt_bparg_t *ka = args;
1733         GElf_Sym sym;
1734 
1735         if (ka->ka_symbol != NULL) {
1736                 return (mdb_tgt_lookup_by_scope(t, ka->ka_symbol,
1737                     &sym, NULL) == 0 && sym.st_value == kb->kb_addr);
1738         }
1739 
1740         return (ka->ka_addr == kb->kb_addr);
1741 }
1742 
1743 /*ARGSUSED*/
1744 static int
1745 kmt_brkpt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args)
1746 {
1747         kmt_bparg_t *ka1 = vep->ve_args;
1748         kmt_bparg_t *ka2 = args;
1749 
1750         if (ka1->ka_symbol != NULL && ka2->ka_symbol != NULL)
1751                 return (strcmp(ka1->ka_symbol, ka2->ka_symbol) == 0);
1752 
1753         if (ka1->ka_symbol == NULL && ka2->ka_symbol == NULL)
1754                 return (ka1->ka_addr == ka2->ka_addr);
1755 
1756         return (0); /* fail if one is symbolic, other is an explicit address */
1757 }
1758 
1759 static int
1760 kmt_brkpt_arm(mdb_tgt_t *t, mdb_sespec_t *sep)
1761 {
1762         kmt_data_t *kmt = t->t_data;
1763         kmt_brkpt_t *kb = sep->se_data;
1764         int rv;
1765 
1766         if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE)
1767                 return (set_errno(EMDB_DTACTIVE));
1768 
1769         if ((rv = kmdb_dpi_brkpt_arm(kb->kb_addr, &kb->kb_oinstr)) != 0)
1770                 return (rv);
1771 
1772         if (kmt->kmt_narmedbpts++ == 0)
1773                 (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_ACTIVATE);
1774 
1775         return (0);
1776 }
1777 
1778 static int
1779 kmt_brkpt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep)
1780 {
1781         kmt_data_t *kmt = t->t_data;
1782         kmt_brkpt_t *kb = sep->se_data;
1783         int rv;
1784 
1785         ASSERT(kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_KMDB_BPT_ACTIVE);
1786 
1787         if ((rv = kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr)) != 0)
1788                 return (rv);
1789 
1790         if (--kmt->kmt_narmedbpts == 0)
1791                 (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_DEACTIVATE);
1792 
1793         return (0);
1794 }
1795 
1796 /*
1797  * Determine whether the specified sespec is an armed watchpoint that overlaps
1798  * with the given breakpoint and has the given flags set.  We use this to find
1799  * conflicts with breakpoints, below.
1800  */
1801 static int
1802 kmt_wp_overlap(mdb_sespec_t *sep, kmt_brkpt_t *kb, int flags)
1803 {
1804         const kmdb_wapt_t *wp = sep->se_data;
1805 
1806         return (sep->se_state == MDB_TGT_SPEC_ARMED &&
1807             sep->se_ops == &kmt_wapt_ops && (wp->wp_wflags & flags) &&
1808             kb->kb_addr - wp->wp_addr < wp->wp_size);
1809 }
1810 
1811 /*
1812  * We step over breakpoints using our single-stepper.  If a conflicting
1813  * watchpoint is present, we must temporarily remove it before stepping over the
1814  * breakpoint so we don't immediately re-trigger the watchpoint.  We know the
1815  * watchpoint has already triggered on our trap instruction as part of fetching
1816  * it.  Before we return, we must re-install any disabled watchpoints.
1817  */
1818 static int
1819 kmt_brkpt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
1820 {
1821         kmt_brkpt_t *kb = sep->se_data;
1822         int status = -1;
1823         int error;
1824 
1825         for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
1826                 if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X))
1827                         (void) kmdb_dpi_wapt_disarm(sep->se_data);
1828         }
1829 
1830         if (kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr) == 0 &&
1831             kmt_step(t, tsp) == 0)
1832                 status = kmt_status(t, tsp);
1833 
1834         error = errno; /* save errno from disarm, step, or status */
1835 
1836         for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
1837                 if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X))
1838                         kmdb_dpi_wapt_arm(sep->se_data);
1839         }
1840 
1841         (void) set_errno(error);
1842         return (status);
1843 }
1844 
1845 /*ARGSUSED*/
1846 static int
1847 kmt_brkpt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
1848 {
1849         kmt_brkpt_t *kb = sep->se_data;
1850         int state, why;
1851         kreg_t pc;
1852 
1853         state = kmdb_dpi_get_state(&why);
1854         (void) kmdb_dpi_get_register("pc", &pc);
1855 
1856         return (state == DPI_STATE_FAULTED && why == DPI_STATE_WHY_BKPT &&
1857             pc == kb->kb_addr);
1858 }
1859 
1860 static const mdb_se_ops_t kmt_brkpt_ops = {
1861         kmt_brkpt_ctor,         /* se_ctor */
1862         kmt_brkpt_dtor,         /* se_dtor */
1863         kmt_brkpt_info,         /* se_info */
1864         kmt_brkpt_secmp,        /* se_secmp */
1865         kmt_brkpt_vecmp,        /* se_vecmp */
1866         kmt_brkpt_arm,          /* se_arm */
1867         kmt_brkpt_disarm,       /* se_disarm */
1868         kmt_brkpt_cont,         /* se_cont */
1869         kmt_brkpt_match         /* se_match */
1870 };
1871 
1872 static int
1873 kmt_wapt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1874 {
1875         mdb_tgt_status_t tsp;
1876         kmdb_wapt_t *vwp = args;
1877         kmdb_wapt_t *swp;
1878 
1879         (void) mdb_tgt_status(t, &tsp);
1880         if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED)
1881                 return (set_errno(EMDB_NOPROC));
1882 
1883         swp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP);
1884         bcopy(vwp, swp, sizeof (kmdb_wapt_t));
1885 
1886         if (kmdb_dpi_wapt_reserve(swp) < 0) {
1887                 mdb_free(swp, sizeof (kmdb_wapt_t));
1888                 return (-1); /* errno is set for us */
1889         }
1890 
1891         sep->se_data = swp;
1892 
1893         return (0);
1894 }
1895 
1896 /*ARGSUSED*/
1897 static void
1898 kmt_wapt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep)
1899 {
1900         kmdb_wapt_t *wp = sep->se_data;
1901 
1902         kmdb_dpi_wapt_release(wp);
1903         mdb_free(wp, sizeof (kmdb_wapt_t));
1904 }
1905 
1906 /*ARGSUSED*/
1907 static char *
1908 kmt_wapt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
1909     mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
1910 {
1911         kmdb_wapt_t *wp = vep != NULL ? vep->ve_args : sep->se_data;
1912         const char *fmt;
1913         char desc[24];
1914 
1915         ASSERT(wp->wp_wflags != 0);
1916         desc[0] = '\0';
1917 
1918         switch (wp->wp_wflags) {
1919         case MDB_TGT_WA_R:
1920                 (void) strcat(desc, "/read");
1921                 break;
1922         case MDB_TGT_WA_W:
1923                 (void) strcat(desc, "/write");
1924                 break;
1925         case MDB_TGT_WA_X:
1926                 (void) strcat(desc, "/exec");
1927                 break;
1928         default:
1929                 if (wp->wp_wflags & MDB_TGT_WA_R)
1930                         (void) strcat(desc, "/r");
1931                 if (wp->wp_wflags & MDB_TGT_WA_W)
1932                         (void) strcat(desc, "/w");
1933                 if (wp->wp_wflags & MDB_TGT_WA_X)
1934                         (void) strcat(desc, "/x");
1935         }
1936 
1937         switch (wp->wp_type) {
1938         case DPI_WAPT_TYPE_PHYS:
1939                 fmt = "stop on %s of phys [%p, %p)";
1940                 break;
1941 
1942         case DPI_WAPT_TYPE_VIRT:
1943                 fmt = "stop on %s of [%la, %la)";
1944                 break;
1945 
1946         case DPI_WAPT_TYPE_IO:
1947                 if (wp->wp_size == 1)
1948                         fmt = "stop on %s of I/O port %p";
1949                 else
1950                         fmt = "stop on %s of I/O port [%p, %p)";
1951                 break;
1952         }
1953 
1954         (void) mdb_iob_snprintf(buf, nbytes, fmt, desc + 1, wp->wp_addr,
1955             wp->wp_addr + wp->wp_size);
1956 
1957         sp->spec_base = wp->wp_addr;
1958         sp->spec_size = wp->wp_size;
1959 
1960         return (buf);
1961 }
1962 
1963 /*ARGSUSED*/
1964 static int
1965 kmt_wapt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
1966 {
1967         kmdb_wapt_t *wp1 = sep->se_data;
1968         kmdb_wapt_t *wp2 = args;
1969 
1970         return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size &&
1971             wp1->wp_wflags == wp2->wp_wflags);
1972 }
1973 
1974 /*ARGSUSED*/
1975 static int
1976 kmt_wapt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args)
1977 {
1978         kmdb_wapt_t *wp1 = vep->ve_args;
1979         kmdb_wapt_t *wp2 = args;
1980 
1981         return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size &&
1982             wp1->wp_wflags == wp2->wp_wflags);
1983 }
1984 
1985 /*ARGSUSED*/
1986 static int
1987 kmt_wapt_arm(mdb_tgt_t *t, mdb_sespec_t *sep)
1988 {
1989         kmdb_dpi_wapt_arm(sep->se_data);
1990 
1991         return (0);
1992 }
1993 
1994 /*ARGSUSED*/
1995 static int
1996 kmt_wapt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep)
1997 {
1998         kmdb_dpi_wapt_disarm(sep->se_data);
1999 
2000         return (0);
2001 }
2002 
2003 /*
2004  * Determine whether the specified sespec is an armed breakpoint at the given
2005  * %pc.  We use this to find conflicts with watchpoints below.
2006  */
2007 static int
2008 kmt_bp_overlap(mdb_sespec_t *sep, uintptr_t pc)
2009 {
2010         kmt_brkpt_t *kb = sep->se_data;
2011 
2012         return (sep->se_state == MDB_TGT_SPEC_ARMED &&
2013             sep->se_ops == &kmt_brkpt_ops && kb->kb_addr == pc);
2014 }
2015 
2016 /*
2017  * We step over watchpoints using our single-stepper.  If a conflicting
2018  * breakpoint is present, we must temporarily disarm it before stepping over
2019  * the watchpoint so we do not immediately re-trigger the breakpoint.  This is
2020  * similar to the case handled in kmt_brkpt_cont(), above.
2021  */
2022 static int
2023 kmt_wapt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
2024 {
2025         mdb_sespec_t *bep = NULL;
2026         int status = -1;
2027         int error, why;
2028 
2029         /*
2030          * If we stopped for anything other than a watchpoint, check to see
2031          * if there's a breakpoint here.
2032          */
2033         if (!(kmdb_dpi_get_state(&why) == DPI_STATE_FAULTED &&
2034             (why == DPI_STATE_WHY_V_WAPT || why == DPI_STATE_WHY_P_WAPT))) {
2035                 kreg_t pc;
2036 
2037                 (void) kmdb_dpi_get_register("pc", &pc);
2038 
2039                 for (bep = mdb_list_next(&t->t_active); bep != NULL;
2040                     bep = mdb_list_next(bep)) {
2041                         if (kmt_bp_overlap(bep, pc)) {
2042                                 (void) bep->se_ops->se_disarm(t, bep);
2043                                 bep->se_state = MDB_TGT_SPEC_ACTIVE;
2044                                 break;
2045                         }
2046                 }
2047         }
2048 
2049         kmdb_dpi_wapt_disarm(sep->se_data);
2050         if (kmt_step(t, tsp) == 0)
2051                 status = kmt_status(t, tsp);
2052 
2053         error = errno; /* save errno from step or status */
2054 
2055         if (bep != NULL)
2056                 mdb_tgt_sespec_arm_one(t, bep);
2057 
2058         (void) set_errno(error);
2059         return (status);
2060 }
2061 
2062 /*ARGSUSED*/
2063 static int
2064 kmt_wapt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
2065 {
2066         return (kmdb_dpi_wapt_match(sep->se_data));
2067 }
2068 
2069 static const mdb_se_ops_t kmt_wapt_ops = {
2070         kmt_wapt_ctor,          /* se_ctor */
2071         kmt_wapt_dtor,          /* se_dtor */
2072         kmt_wapt_info,          /* se_info */
2073         kmt_wapt_secmp,         /* se_secmp */
2074         kmt_wapt_vecmp,         /* se_vecmp */
2075         kmt_wapt_arm,           /* se_arm */
2076         kmt_wapt_disarm,        /* se_disarm */
2077         kmt_wapt_cont,          /* se_cont */
2078         kmt_wapt_match          /* se_match */
2079 };
2080 
2081 /*ARGSUSED*/
2082 static int
2083 kmt_trap_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args)
2084 {
2085         sep->se_data = args; /* trap number */
2086 
2087         return (0);
2088 }
2089 
2090 /*ARGSUSED*/
2091 static char *
2092 kmt_trap_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep,
2093     mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes)
2094 {
2095         const char *name;
2096         int trapnum;
2097 
2098         if (vep != NULL)
2099                 trapnum = (intptr_t)vep->ve_args;
2100         else
2101                 trapnum = (intptr_t)sep->se_data;
2102 
2103         if (trapnum == KMT_TRAP_ALL)
2104                 name = "any trap";
2105         else if (trapnum == KMT_TRAP_NOTENUM)
2106                 name = "miscellaneous trap";
2107         else
2108                 name = kmt_trapname(trapnum);
2109 
2110         (void) mdb_iob_snprintf(buf, nbytes, "single-step stop on %s", name);
2111 
2112         return (buf);
2113 }
2114 
2115 /*ARGSUSED2*/
2116 static int
2117 kmt_trap_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp)
2118 {
2119         int spectt = (intptr_t)sep->se_data;
2120         kmt_data_t *kmt = t->t_data;
2121         kreg_t tt;
2122 
2123         (void) kmdb_dpi_get_register("tt", &tt);
2124 
2125         switch (spectt) {
2126         case KMT_TRAP_ALL:
2127                 return (1);
2128         case KMT_TRAP_NOTENUM:
2129                 return (tt > kmt->kmt_trapmax ||
2130                     !BT_TEST(kmt->kmt_trapmap, tt));
2131         default:
2132                 return (tt == spectt);
2133         }
2134 }
2135 
2136 static const mdb_se_ops_t kmt_trap_ops = {
2137         kmt_trap_ctor,          /* se_ctor */
2138         no_se_dtor,             /* se_dtor */
2139         kmt_trap_info,          /* se_info */
2140         no_se_secmp,            /* se_secmp */
2141         no_se_vecmp,            /* se_vecmp */
2142         no_se_arm,              /* se_arm */
2143         no_se_disarm,           /* se_disarm */
2144         no_se_cont,             /* se_cont */
2145         kmt_trap_match          /* se_match */
2146 };
2147 
2148 static void
2149 kmt_bparg_dtor(mdb_vespec_t *vep)
2150 {
2151         kmt_bparg_t *ka = vep->ve_args;
2152 
2153         if (ka->ka_symbol != NULL)
2154                 strfree(ka->ka_symbol);
2155 
2156         if (ka->ka_defbp != NULL)
2157                 kmt_defbp_delete(mdb.m_target, ka->ka_defbp);
2158 
2159         mdb_free(ka, sizeof (kmt_bparg_t));
2160 }
2161 
2162 static int
2163 kmt_add_vbrkpt(mdb_tgt_t *t, uintptr_t addr,
2164     int spec_flags, mdb_tgt_se_f *func, void *data)
2165 {
2166         kmt_bparg_t *ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP);
2167 
2168         ka->ka_addr = addr;
2169         ka->ka_symbol = NULL;
2170         ka->ka_defbp = NULL;
2171 
2172         return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags,
2173             func, data, ka, kmt_bparg_dtor));
2174 }
2175 
2176 static int
2177 kmt_add_sbrkpt(mdb_tgt_t *t, const char *fullname,
2178     int spec_flags, mdb_tgt_se_f *func, void *data)
2179 {
2180         kmt_bparg_t *ka;
2181         kmt_defbp_t *dbp;
2182         GElf_Sym sym;
2183         char *tick, *objname, *symname;
2184         int serrno;
2185 
2186         if ((tick = strchr(fullname, '`')) == fullname) {
2187                 (void) set_errno(EMDB_NOOBJ);
2188                 return (0);
2189         }
2190 
2191         /*
2192          * Deferred breakpoints are always scoped.  If we didn't find a tick,
2193          * there's no scope.  We'll create a vbrkpt, but only if we can turn the
2194          * provided string into an address.
2195          */
2196         if (tick == NULL) {
2197                 uintptr_t addr;
2198 
2199                 if (strisbasenum(fullname)) {
2200                         addr = mdb_strtoull(fullname); /* a bare address */
2201                 } else if (mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EVERY,
2202                     fullname, &sym, NULL) < 0) {
2203                         (void) set_errno(EMDB_NOSYM);
2204                         return (0);
2205                 } else {
2206                         addr = (uintptr_t)sym.st_value; /* unscoped sym name */
2207                 }
2208 
2209                 return (kmt_add_vbrkpt(t, addr, spec_flags, func, data));
2210         }
2211 
2212         if (*(tick + 1) == '\0') {
2213                 (void) set_errno(EMDB_NOSYM);
2214                 return (0);
2215         }
2216 
2217         objname = strndup(fullname, tick - fullname);
2218         symname = tick + 1;
2219 
2220         if (mdb_tgt_lookup_by_name(t, objname, symname, NULL, NULL) < 0 &&
2221             errno != EMDB_NOOBJ) {
2222                 serrno = errno;
2223                 strfree(objname);
2224 
2225                 (void) set_errno(serrno);
2226                 return (0); /* errno is set for us */
2227         }
2228 
2229         dbp = kmt_defbp_create(t, objname, symname);
2230         strfree(objname);
2231 
2232         ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP);
2233         ka->ka_symbol = strdup(fullname);
2234         ka->ka_addr = NULL;
2235         ka->ka_defbp = dbp;
2236 
2237         return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags,
2238             func, data, ka, kmt_bparg_dtor));
2239 }
2240 
2241 static int
2242 kmt_wparg_overlap(const kmdb_wapt_t *wp1, const kmdb_wapt_t *wp2)
2243 {
2244         /* Assume the watchpoint spaces don't overlap */
2245         if (wp1->wp_type != wp2->wp_type)
2246                 return (0);
2247 
2248         if (wp2->wp_addr + wp2->wp_size <= wp1->wp_addr)
2249                 return (0); /* no range overlap */
2250 
2251         if (wp1->wp_addr + wp1->wp_size <= wp2->wp_addr)
2252                 return (0); /* no range overlap */
2253 
2254         return (wp1->wp_addr != wp2->wp_addr || wp1->wp_size != wp2->wp_size ||
2255             wp1->wp_wflags != wp2->wp_wflags);
2256 }
2257 
2258 static void
2259 kmt_wparg_dtor(mdb_vespec_t *vep)
2260 {
2261         mdb_free(vep->ve_args, sizeof (kmdb_wapt_t));
2262 }
2263 
2264 static int
2265 kmt_add_wapt_common(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
2266     int spec_flags, mdb_tgt_se_f *func, void *data, int type)
2267 {
2268         kmdb_wapt_t *wp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP);
2269         mdb_sespec_t *sep;
2270 
2271         wp->wp_addr = addr;
2272         wp->wp_size = len;
2273         wp->wp_type = type;
2274         wp->wp_wflags = wflags;
2275 
2276         if (kmdb_dpi_wapt_validate(wp) < 0)
2277                 return (0); /* errno is set for us */
2278 
2279         for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) {
2280                 if (sep->se_ops == &kmt_wapt_ops &&
2281                     mdb_list_next(&sep->se_velist) != NULL &&
2282                     kmt_wparg_overlap(wp, sep->se_data))
2283                         goto wapt_dup;
2284         }
2285 
2286         for (sep = mdb_list_next(&t->t_idle); sep; sep = mdb_list_next(sep)) {
2287                 if (sep->se_ops == &kmt_wapt_ops && kmt_wparg_overlap(wp,
2288                     ((mdb_vespec_t *)mdb_list_next(&sep->se_velist))->ve_args))
2289                         goto wapt_dup;
2290         }
2291 
2292         return (mdb_tgt_vespec_insert(t, &kmt_wapt_ops, spec_flags,
2293             func, data, wp, kmt_wparg_dtor));
2294 
2295 wapt_dup:
2296         mdb_free(wp, sizeof (kmdb_wapt_t));
2297         (void) set_errno(EMDB_WPDUP);
2298         return (0);
2299 }
2300 
2301 static int
2302 kmt_add_pwapt(mdb_tgt_t *t, physaddr_t addr, size_t len, uint_t wflags,
2303     int spec_flags, mdb_tgt_se_f *func, void *data)
2304 {
2305         return (kmt_add_wapt_common(t, (uintptr_t)addr, len, wflags, spec_flags,
2306             func, data, DPI_WAPT_TYPE_PHYS));
2307 }
2308 
2309 static int
2310 kmt_add_vwapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
2311     int spec_flags, mdb_tgt_se_f *func, void *data)
2312 {
2313         return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func,
2314             data, DPI_WAPT_TYPE_VIRT));
2315 }
2316 
2317 static int
2318 kmt_add_iowapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags,
2319     int spec_flags, mdb_tgt_se_f *func, void *data)
2320 {
2321         return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func,
2322             data, DPI_WAPT_TYPE_IO));
2323 }
2324 
2325 static int
2326 kmt_add_trap(mdb_tgt_t *t, int trapnum, int spec_flags, mdb_tgt_se_f *func,
2327     void *data)
2328 {
2329         kmt_data_t *kmt = t->t_data;
2330 
2331         if (trapnum != KMT_TRAP_ALL && trapnum != KMT_TRAP_NOTENUM) {
2332                 if (trapnum < 0 || trapnum > kmt->kmt_trapmax) {
2333                         (void) set_errno(EMDB_BADFLTNUM);
2334                         return (0);
2335                 }
2336 
2337                 BT_SET(kmt->kmt_trapmap, trapnum);
2338         }
2339 
2340         return (mdb_tgt_vespec_insert(t, &kmt_trap_ops, spec_flags, func, data,
2341             (void *)(uintptr_t)trapnum, no_ve_dtor));
2342 }
2343 
2344 /*ARGSUSED*/
2345 static uintmax_t
2346 kmt_cpuid_disc_get(const mdb_var_t *v)
2347 {
2348         return (kmdb_dpi_get_master_cpuid());
2349 }
2350 
2351 static const mdb_nv_disc_t kmt_cpuid_disc = {
2352         NULL,
2353         kmt_cpuid_disc_get
2354 };
2355 
2356 /*
2357  * This routine executes while the kernel is running.
2358  */
2359 void
2360 kmt_activate(mdb_tgt_t *t)
2361 {
2362         kmt_data_t *kmt = t->t_data;
2363 
2364         mdb_prop_postmortem = FALSE;
2365         mdb_prop_kernel = TRUE;
2366 
2367         (void) mdb_tgt_register_dcmds(t, &kmt_dcmds[0], MDB_MOD_FORCE);
2368         mdb_tgt_register_regvars(t, kmt->kmt_rds, &kmt_reg_disc, 0);
2369 
2370         /*
2371          * Force load of the MDB krtld module, in case it's been rolled into
2372          * unix.
2373          */
2374         (void) mdb_module_load(KMT_RTLD_NAME, MDB_MOD_SILENT | MDB_MOD_DEFER);
2375 }
2376 
2377 static void
2378 kmt_destroy(mdb_tgt_t *t)
2379 {
2380         kmt_data_t *kmt = t->t_data;
2381         kmt_module_t *km, *pkm;
2382 
2383         mdb_nv_destroy(&kmt->kmt_modules);
2384         for (km = mdb_list_prev(&kmt->kmt_modlist); km != NULL; km = pkm) {
2385                 pkm = mdb_list_prev(km);
2386                 mdb_free(km, sizeof (kmt_module_t));
2387         }
2388 
2389         if (!kmt_defbp_lock)
2390                 kmt_defbp_destroy_all();
2391 
2392         if (kmt->kmt_trapmap != NULL)
2393                 mdb_free(kmt->kmt_trapmap, BT_SIZEOFMAP(kmt->kmt_trapmax));
2394 
2395         if (kmt->kmt_cpu != NULL)
2396                 kmt_cpu_destroy(kmt->kmt_cpu);
2397 
2398         if (kmt != NULL)
2399                 mdb_free(kmt, sizeof (kmt_data_t));
2400 }
2401 
2402 static const mdb_tgt_ops_t kmt_ops = {
2403         kmt_setflags,                           /* t_setflags */
2404         (int (*)()) mdb_tgt_notsup,             /* t_setcontext */
2405         kmt_activate,                           /* t_activate */
2406         (void (*)()) mdb_tgt_nop,               /* t_deactivate */
2407         kmt_periodic,                           /* t_periodic */
2408         kmt_destroy,                            /* t_destroy */
2409         kmt_name,                               /* t_name */
2410         (const char *(*)()) mdb_conf_isa,       /* t_isa */
2411         kmt_platform,                           /* t_platform */
2412         kmt_uname,                              /* t_uname */
2413         kmt_dmodel,                             /* t_dmodel */
2414         (ssize_t (*)()) mdb_tgt_notsup,         /* t_aread */
2415         (ssize_t (*)()) mdb_tgt_notsup,         /* t_awrite */
2416         kmt_read,                               /* t_vread */
2417         kmt_write,                              /* t_vwrite */
2418         kmt_pread,                              /* t_pread */
2419         kmt_pwrite,                             /* t_pwrite */
2420         kmt_read,                               /* t_fread */
2421         kmt_write,                              /* t_fwrite */
2422         kmt_ioread,                             /* t_ioread */
2423         kmt_iowrite,                            /* t_iowrite */
2424         kmt_vtop,                               /* t_vtop */
2425         kmt_lookup_by_name,                     /* t_lookup_by_name */
2426         kmt_lookup_by_addr,                     /* t_lookup_by_addr */
2427         kmt_symbol_iter,                        /* t_symbol_iter */
2428         kmt_mapping_iter,                       /* t_mapping_iter */
2429         kmt_object_iter,                        /* t_object_iter */
2430         kmt_addr_to_map,                        /* t_addr_to_map */
2431         kmt_name_to_map,                        /* t_name_to_map */
2432         kmt_addr_to_ctf,                        /* t_addr_to_ctf */
2433         kmt_name_to_ctf,                        /* t_name_to_ctf */
2434         kmt_status,                             /* t_status */
2435         (int (*)()) mdb_tgt_notsup,             /* t_run */
2436         kmt_step,                               /* t_step */
2437         kmt_step_out,                           /* t_step_out */
2438         kmt_step_branch,                        /* t_step_branch */
2439         kmt_next,                               /* t_next */
2440         kmt_continue,                           /* t_cont */
2441         (int (*)()) mdb_tgt_notsup,             /* t_signal */
2442         kmt_add_vbrkpt,                         /* t_add_vbrkpt */
2443         kmt_add_sbrkpt,                         /* t_add_sbrkpt */
2444         kmt_add_pwapt,                          /* t_add_pwapt */
2445         kmt_add_vwapt,                          /* t_add_vwapt */
2446         kmt_add_iowapt,                         /* t_add_iowapt */
2447         (int (*)()) mdb_tgt_null,               /* t_add_sysenter */
2448         (int (*)()) mdb_tgt_null,               /* t_add_sysexit */
2449         (int (*)()) mdb_tgt_null,               /* t_add_signal */
2450         kmt_add_trap,                           /* t_add_fault */
2451         kmt_getareg,                            /* t_getareg */
2452         kmt_putareg,                            /* t_putareg */
2453         (int (*)()) mdb_tgt_nop,                /* XXX t_stack_iter */
2454         (int (*)()) mdb_tgt_notsup              /* t_auxv */
2455 };
2456 
2457 /*
2458  * Called immediately upon resumption of the system after a step or continue.
2459  * Allows us to synchronize kmt's view of the world with reality.
2460  */
2461 /*ARGSUSED*/
2462 static void
2463 kmt_sync(mdb_tgt_t *t)
2464 {
2465         kmt_data_t *kmt = t->t_data;
2466         int symavail;
2467 
2468         mdb_dprintf(MDB_DBG_KMOD, "synchronizing with kernel\n");
2469 
2470         symavail = kmt->kmt_symavail;
2471         kmt->kmt_symavail = FALSE;
2472 
2473         /*
2474          * Resync our view of the world if the modules have changed, or if we
2475          * didn't have any symbols coming into this function.  The latter will
2476          * only happen on startup.
2477          */
2478         if (kmdb_kdi_mods_changed() || !symavail)
2479                 kmt_modlist_update(t);
2480 
2481         /*
2482          * It would be nice if we could run this less frequently, perhaps
2483          * after a dvec-initiated trigger.
2484          */
2485         kmdb_module_sync();
2486 
2487         kmt->kmt_symavail = TRUE;
2488 
2489         mdb_dprintf(MDB_DBG_KMOD, "synchronization complete\n");
2490 
2491         kmt_defbp_prune();
2492 
2493         if (kmt_defbp_num > 0 && kmt_defbp_bpspec == 0 &&
2494             kmdb_kdi_dtrace_get_state() != KDI_DTSTATE_DTRACE_ACTIVE) {
2495                 /*
2496                  * Deferred breakpoints were created while DTrace was active,
2497                  * and consequently the deferred breakpoint enabling mechanism
2498                  * wasn't activated.  Activate it now, and then try to activate
2499                  * the deferred breakpoints.  We do this so that we can catch
2500                  * the ones which may apply to modules that have been loaded
2501                  * while they were waiting for DTrace to deactivate.
2502                  */
2503                 (void) kmt_defbp_activate(t);
2504                 (void) mdb_tgt_sespec_activate_all(t);
2505         }
2506 
2507         if (kmt->kmt_cpu_retry && ((kmt->kmt_cpu = kmt_cpu_create(t)) !=
2508             NULL || errno != EAGAIN))
2509                 kmt->kmt_cpu_retry = FALSE;
2510 
2511         (void) mdb_tgt_status(t, &t->t_status);
2512 }
2513 
2514 /*
2515  * This routine executes while the kernel is running.
2516  */
2517 /*ARGSUSED*/
2518 int
2519 kmdb_kvm_create(mdb_tgt_t *t, int argc, const char *argv[])
2520 {
2521         kmt_data_t *kmt;
2522 
2523         if (argc != 0)
2524                 return (set_errno(EINVAL));
2525 
2526         kmt = mdb_zalloc(sizeof (kmt_data_t), UM_SLEEP);
2527         t->t_data = kmt;
2528         t->t_ops = &kmt_ops;
2529         t->t_flags |= MDB_TGT_F_RDWR;        /* kmdb is always r/w */
2530 
2531         (void) mdb_nv_insert(&mdb.m_nv, "cpuid", &kmt_cpuid_disc, 0,
2532             MDB_NV_PERSIST | MDB_NV_RDONLY);
2533 
2534         (void) mdb_nv_create(&kmt->kmt_modules, UM_SLEEP);
2535 
2536         kmt_init_isadep(t);
2537 
2538         kmt->kmt_symavail = FALSE;
2539         kmt->kmt_cpu_retry = TRUE;
2540 
2541         bzero(&kmt_defbp_list, sizeof (mdb_list_t));
2542 
2543         return (0);
2544 
2545 create_err:
2546         kmt_destroy(t);
2547 
2548         return (-1);
2549 }
2550 
2551 /*
2552  * This routine is called once, when kmdb first has control of the world.
2553  */
2554 void
2555 kmdb_kvm_startup(void)
2556 {
2557         kmt_data_t *kmt = mdb.m_target->t_data;
2558 
2559         mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm startup\n");
2560 
2561         kmt_sync(mdb.m_target);
2562         (void) mdb_module_load_builtin(KMT_MODULE);
2563         kmt_startup_isadep(mdb.m_target);
2564 
2565         /*
2566          * This is here because we need to write the deferred breakpoint
2567          * breakpoint when the debugger starts.  Our normal r/o write routines
2568          * don't work when the kernel is running, so we have to do it during
2569          * startup.
2570          */
2571         (void) mdb_tgt_sespec_activate_all(mdb.m_target);
2572 
2573         kmt->kmt_rtld_name = KMT_RTLD_NAME;
2574 
2575         if (kmt_module_by_name(kmt, KMT_RTLD_NAME) == NULL)
2576                 kmt->kmt_rtld_name = "unix";
2577 }
2578 
2579 /*
2580  * This routine is called after kmdb has loaded its initial set of modules.
2581  */
2582 void
2583 kmdb_kvm_poststartup(void)
2584 {
2585         mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm post-startup\n");
2586 
2587         (void) mdb_dis_select(kmt_def_dismode());
2588 }
--- EOF ---