Print this page
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>

Split Close
Expand all
Collapse all
          --- old/usr/src/cmd/mdb/common/mdb/mdb_target.c
          +++ new/usr/src/cmd/mdb/common/mdb/mdb_target.c
↓ open down ↓ 13 lines elided ↑ open up ↑
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*
  22   22   * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23   23   * Use is subject to license terms.
       24 + *
       25 + * Copyright 2018 Joyent, Inc.
  24   26   */
  25   27  
  26   28  /*
  27   29   * MDB Target Layer
  28   30   *
  29   31   * The *target* is the program being inspected by the debugger.  The MDB target
  30   32   * layer provides a set of functions that insulate common debugger code,
  31   33   * including the MDB Module API, from the implementation details of how the
  32   34   * debugger accesses information from a given target.  Each target exports a
  33   35   * standard set of properties, including one or more address  spaces, one or
↓ open down ↓ 141 lines elided ↑ open up ↑
 175  177          (MDB_TGT_SPEC_INTERNAL | MDB_TGT_SPEC_SILENT | MDB_TGT_SPEC_MATCHED | \
 176  178          MDB_TGT_SPEC_DELETED)
 177  179  
 178  180  #define T_AUTO_BITS     \
 179  181          (MDB_TGT_SPEC_AUTOSTOP | MDB_TGT_SPEC_AUTODEL | MDB_TGT_SPEC_AUTODIS)
 180  182  
 181  183  /*
 182  184   * Define convenience macro for referencing target flag pending continue bits.
 183  185   */
 184  186  #define T_CONT_BITS     \
 185      -        (MDB_TGT_F_STEP | MDB_TGT_F_STEP_OUT | MDB_TGT_F_STEP_BRANCH | \
 186      -        MDB_TGT_F_NEXT | MDB_TGT_F_CONT)
      187 +        (MDB_TGT_F_STEP | MDB_TGT_F_STEP_OUT | MDB_TGT_F_NEXT | MDB_TGT_F_CONT)
 187  188  
 188  189  mdb_tgt_t *
 189  190  mdb_tgt_create(mdb_tgt_ctor_f *ctor, int flags, int argc, const char *argv[])
 190  191  {
 191  192          mdb_module_t *mp;
 192  193          mdb_tgt_t *t;
 193  194  
 194  195          if (flags & ~MDB_TGT_F_ALL) {
 195  196                  (void) set_errno(EINVAL);
 196  197                  return (NULL);
↓ open down ↓ 186 lines elided ↑ open up ↑
 383  384  }
 384  385  
 385  386  int
 386  387  mdb_tgt_auxv(mdb_tgt_t *t, const auxv_t **auxvp)
 387  388  {
 388  389          return (t->t_ops->t_auxv(t, auxvp));
 389  390  }
 390  391  
 391  392  ssize_t
 392  393  mdb_tgt_aread(mdb_tgt_t *t, mdb_tgt_as_t as,
 393      -        void *buf, size_t n, mdb_tgt_addr_t addr)
      394 +    void *buf, size_t n, mdb_tgt_addr_t addr)
 394  395  {
 395  396          if (t->t_flags & MDB_TGT_F_ASIO)
 396  397                  return (t->t_ops->t_aread(t, as, buf, n, addr));
 397  398  
 398  399          switch ((uintptr_t)as) {
 399  400          case (uintptr_t)MDB_TGT_AS_VIRT:
 400  401                  return (t->t_ops->t_vread(t, buf, n, addr));
 401  402          case (uintptr_t)MDB_TGT_AS_PHYS:
 402  403                  return (t->t_ops->t_pread(t, buf, n, addr));
 403  404          case (uintptr_t)MDB_TGT_AS_FILE:
 404  405                  return (t->t_ops->t_fread(t, buf, n, addr));
 405  406          case (uintptr_t)MDB_TGT_AS_IO:
 406  407                  return (t->t_ops->t_ioread(t, buf, n, addr));
 407  408          }
 408  409          return (t->t_ops->t_aread(t, as, buf, n, addr));
 409  410  }
 410  411  
 411  412  ssize_t
 412  413  mdb_tgt_awrite(mdb_tgt_t *t, mdb_tgt_as_t as,
 413      -        const void *buf, size_t n, mdb_tgt_addr_t addr)
      414 +    const void *buf, size_t n, mdb_tgt_addr_t addr)
 414  415  {
 415  416          if (!(t->t_flags & MDB_TGT_F_RDWR))
 416  417                  return (set_errno(EMDB_TGTRDONLY));
 417  418  
 418  419          if (t->t_flags & MDB_TGT_F_ASIO)
 419  420                  return (t->t_ops->t_awrite(t, as, buf, n, addr));
 420  421  
 421  422          switch ((uintptr_t)as) {
 422  423          case (uintptr_t)MDB_TGT_AS_VIRT:
 423  424                  return (t->t_ops->t_vwrite(t, buf, n, addr));
↓ open down ↓ 68 lines elided ↑ open up ↑
 492  493  }
 493  494  
 494  495  int
 495  496  mdb_tgt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap)
 496  497  {
 497  498          return (t->t_ops->t_vtop(t, as, va, pap));
 498  499  }
 499  500  
 500  501  ssize_t
 501  502  mdb_tgt_readstr(mdb_tgt_t *t, mdb_tgt_as_t as, char *buf,
 502      -        size_t nbytes, mdb_tgt_addr_t addr)
      503 +    size_t nbytes, mdb_tgt_addr_t addr)
 503  504  {
 504  505          ssize_t n, nread = mdb_tgt_aread(t, as, buf, nbytes, addr);
 505  506          char *p;
 506  507  
 507  508          if (nread >= 0) {
 508  509                  if ((p = memchr(buf, '\0', nread)) != NULL)
 509  510                          nread = (size_t)(p - buf);
 510  511                  goto done;
 511  512          }
 512  513  
↓ open down ↓ 13 lines elided ↑ open up ↑
 526  527  
 527  528  done:
 528  529          if (nbytes != 0)
 529  530                  buf[MIN(nread, nbytes - 1)] = '\0';
 530  531  
 531  532          return (nread);
 532  533  }
 533  534  
 534  535  ssize_t
 535  536  mdb_tgt_writestr(mdb_tgt_t *t, mdb_tgt_as_t as,
 536      -        const char *buf, mdb_tgt_addr_t addr)
      537 +    const char *buf, mdb_tgt_addr_t addr)
 537  538  {
 538  539          ssize_t nwritten = mdb_tgt_awrite(t, as, buf, strlen(buf) + 1, addr);
 539  540          return (nwritten > 0 ? nwritten - 1 : nwritten);
 540  541  }
 541  542  
 542  543  int
 543  544  mdb_tgt_lookup_by_name(mdb_tgt_t *t, const char *obj,
 544      -        const char *name, GElf_Sym *symp, mdb_syminfo_t *sip)
      545 +    const char *name, GElf_Sym *symp, mdb_syminfo_t *sip)
 545  546  {
 546  547          mdb_syminfo_t info;
 547  548          GElf_Sym sym;
 548  549          uint_t id;
 549  550  
 550  551          if (name == NULL || t == NULL)
 551  552                  return (set_errno(EINVAL));
 552  553  
 553  554          if (obj == MDB_TGT_OBJ_EVERY &&
 554  555              mdb_gelf_symtab_lookup_by_name(mdb.m_prsym, name, &sym, &id) == 0) {
↓ open down ↓ 10 lines elided ↑ open up ↑
 565  566  found:
 566  567          if (symp != NULL)
 567  568                  *symp = sym;
 568  569          if (sip != NULL)
 569  570                  *sip = info;
 570  571          return (0);
 571  572  }
 572  573  
 573  574  int
 574  575  mdb_tgt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags,
 575      -        char *buf, size_t len, GElf_Sym *symp, mdb_syminfo_t *sip)
      576 +    char *buf, size_t len, GElf_Sym *symp, mdb_syminfo_t *sip)
 576  577  {
 577  578          mdb_syminfo_t info;
 578  579          GElf_Sym sym;
 579  580  
 580  581          if (t == NULL)
 581  582                  return (set_errno(EINVAL));
 582  583  
 583  584          if (t->t_ops->t_lookup_by_addr(t, addr, flags,
 584  585              buf, len, &sym, &info) == 0) {
 585  586                  if (symp != NULL)
↓ open down ↓ 10 lines elided ↑ open up ↑
 596  597   * The mdb_tgt_lookup_by_scope function is a convenience routine for code that
 597  598   * wants to look up a scoped symbol name such as "object`symbol".  It is
 598  599   * implemented as a simple wrapper around mdb_tgt_lookup_by_name.  Note that
 599  600   * we split on the *last* occurrence of "`", so the object name itself may
 600  601   * contain additional scopes whose evaluation is left to the target.  This
 601  602   * allows targets to implement additional scopes, such as source files,
 602  603   * function names, link map identifiers, etc.
 603  604   */
 604  605  int
 605  606  mdb_tgt_lookup_by_scope(mdb_tgt_t *t, const char *s, GElf_Sym *symp,
 606      -        mdb_syminfo_t *sip)
      607 +    mdb_syminfo_t *sip)
 607  608  {
 608  609          const char *object = MDB_TGT_OBJ_EVERY;
 609  610          const char *name = s;
 610  611          char buf[MDB_TGT_SYM_NAMLEN];
 611  612  
 612  613          if (t == NULL)
 613  614                  return (set_errno(EINVAL));
 614  615  
 615  616          if (strchr(name, '`') != NULL) {
 616  617  
↓ open down ↓ 9 lines elided ↑ open up ↑
 626  627                          if (*name == '\0')
 627  628                                  return (set_errno(EMDB_NOSYM));
 628  629                  }
 629  630          }
 630  631  
 631  632          return (mdb_tgt_lookup_by_name(t, object, name, symp, sip));
 632  633  }
 633  634  
 634  635  int
 635  636  mdb_tgt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which,
 636      -        uint_t type, mdb_tgt_sym_f *cb, void *p)
      637 +    uint_t type, mdb_tgt_sym_f *cb, void *p)
 637  638  {
 638  639          if ((which != MDB_TGT_SYMTAB && which != MDB_TGT_DYNSYM) ||
 639  640              (type & ~(MDB_TGT_BIND_ANY | MDB_TGT_TYPE_ANY)) != 0)
 640  641                  return (set_errno(EINVAL));
 641  642  
 642  643          return (t->t_ops->t_symbol_iter(t, obj, which, type, cb, p));
 643  644  }
 644  645  
 645  646  ssize_t
 646  647  mdb_tgt_readsym(mdb_tgt_t *t, mdb_tgt_as_t as, void *buf, size_t nbytes,
 647      -        const char *obj, const char *name)
      648 +    const char *obj, const char *name)
 648  649  {
 649  650          GElf_Sym sym;
 650  651  
 651  652          if (mdb_tgt_lookup_by_name(t, obj, name, &sym, NULL) == 0)
 652  653                  return (mdb_tgt_aread(t, as, buf, nbytes, sym.st_value));
 653  654  
 654  655          return (-1);
 655  656  }
 656  657  
 657  658  ssize_t
 658  659  mdb_tgt_writesym(mdb_tgt_t *t, mdb_tgt_as_t as, const void *buf,
 659      -        size_t nbytes, const char *obj, const char *name)
      660 +    size_t nbytes, const char *obj, const char *name)
 660  661  {
 661  662          GElf_Sym sym;
 662  663  
 663  664          if (mdb_tgt_lookup_by_name(t, obj, name, &sym, NULL) == 0)
 664  665                  return (mdb_tgt_awrite(t, as, buf, nbytes, sym.st_value));
 665  666  
 666  667          return (-1);
 667  668  }
 668  669  
 669  670  int
↓ open down ↓ 411 lines elided ↑ open up ↑
1081 1082  
1082 1083          /*
1083 1084           * If any of single-step, step-over, or step-out is pending, it takes
1084 1085           * precedence over an explicit or pending continue, because these are
1085 1086           * all different specialized forms of continue.
1086 1087           */
1087 1088          if (t->t_flags & MDB_TGT_F_STEP)
1088 1089                  t_cont = t->t_ops->t_step;
1089 1090          else if (t->t_flags & MDB_TGT_F_NEXT)
1090 1091                  t_cont = t->t_ops->t_step;
1091      -        else if (t->t_flags & MDB_TGT_F_STEP_BRANCH)
1092      -                t_cont = t->t_ops->t_cont;
1093 1092          else if (t->t_flags & MDB_TGT_F_STEP_OUT)
1094 1093                  t_cont = t->t_ops->t_cont;
1095 1094  
1096 1095          /*
1097 1096           * To handle step-over, we ask the target to find the address past the
1098 1097           * next control transfer instruction.  If an address is found, we plant
1099 1098           * a temporary breakpoint there and continue; otherwise just step.
1100 1099           */
1101 1100          if ((t->t_flags & MDB_TGT_F_NEXT) && !(t->t_flags & MDB_TGT_F_STEP)) {
1102 1101                  if (t->t_ops->t_next(t, &addr) == -1 || mdb_tgt_add_vbrkpt(t,
↓ open down ↓ 11 lines elided ↑ open up ↑
1114 1113           */
1115 1114          if (t->t_flags & MDB_TGT_F_STEP_OUT) {
1116 1115                  if (t->t_ops->t_step_out(t, &addr) == -1)
1117 1116                          return (-1); /* errno is set for us */
1118 1117  
1119 1118                  if (mdb_tgt_add_vbrkpt(t, addr, MDB_TGT_SPEC_HIDDEN |
1120 1119                      MDB_TGT_SPEC_TEMPORARY, no_se_f, NULL) == 0)
1121 1120                          return (-1); /* errno is set for us */
1122 1121          }
1123 1122  
1124      -        /*
1125      -         * To handle step-branch, we ask the target to enable it for the coming
1126      -         * continue.  Step-branch is incompatible with step, so don't enable it
1127      -         * if we're going to be stepping.
1128      -         */
1129      -        if (t->t_flags & MDB_TGT_F_STEP_BRANCH && t_cont == t->t_ops->t_cont) {
1130      -                if (t->t_ops->t_step_branch(t) == -1)
1131      -                        return (-1); /* errno is set for us */
1132      -        }
1133      -
1134 1123          (void) mdb_signal_block(SIGHUP);
1135 1124          (void) mdb_signal_block(SIGTERM);
1136 1125          mdb_intr_disable();
1137 1126  
1138 1127          t->t_flags &= ~T_CONT_BITS;
1139 1128          t->t_flags |= MDB_TGT_F_BUSY;
1140 1129          mdb_tgt_sespec_arm_all(t);
1141 1130  
1142 1131          ASSERT(t->t_matched != NULL);
1143 1132          matched = t->t_matched;
↓ open down ↓ 245 lines elided ↑ open up ↑
1389 1378  }
1390 1379  
1391 1380  int
1392 1381  mdb_tgt_step_out(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1393 1382  {
1394 1383          t->t_flags |= MDB_TGT_F_STEP_OUT; /* set flag even if tgt not busy */
1395 1384          return (tgt_request_continue(t, tsp, 0, t->t_ops->t_cont));
1396 1385  }
1397 1386  
1398 1387  int
1399      -mdb_tgt_step_branch(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1400      -{
1401      -        t->t_flags |= MDB_TGT_F_STEP_BRANCH; /* set flag even if tgt not busy */
1402      -        return (tgt_request_continue(t, tsp, 0, t->t_ops->t_cont));
1403      -}
1404      -
1405      -int
1406 1388  mdb_tgt_next(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1407 1389  {
1408 1390          t->t_flags |= MDB_TGT_F_NEXT; /* set flag even if tgt not busy */
1409 1391          return (tgt_request_continue(t, tsp, 0, t->t_ops->t_step));
1410 1392  }
1411 1393  
1412 1394  int
1413 1395  mdb_tgt_continue(mdb_tgt_t *t, mdb_tgt_status_t *tsp)
1414 1396  {
1415 1397          return (tgt_request_continue(t, tsp, MDB_TGT_F_CONT, t->t_ops->t_cont));
↓ open down ↓ 441 lines elided ↑ open up ↑
1857 1839  }
1858 1840  
1859 1841  long
1860 1842  mdb_tgt_nop()
1861 1843  {
1862 1844          return (0L);
1863 1845  }
1864 1846  
1865 1847  int
1866 1848  mdb_tgt_xdata_insert(mdb_tgt_t *t, const char *name, const char *desc,
1867      -        ssize_t (*copy)(mdb_tgt_t *, void *, size_t))
     1849 +    ssize_t (*copy)(mdb_tgt_t *, void *, size_t))
1868 1850  {
1869 1851          mdb_xdata_t *xdp;
1870 1852  
1871 1853          for (xdp = mdb_list_next(&t->t_xdlist); xdp; xdp = mdb_list_next(xdp)) {
1872 1854                  if (strcmp(xdp->xd_name, name) == 0)
1873 1855                          return (set_errno(EMDB_XDEXISTS));
1874 1856          }
1875 1857  
1876 1858          xdp = mdb_alloc(sizeof (mdb_xdata_t), UM_SLEEP);
1877 1859          mdb_list_append(&t->t_xdlist, xdp);
↓ open down ↓ 449 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX