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 /*
  23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 /*
  27  * Copyright (c) 2012, Joyent, Inc.  All rights reserved.
  28  * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
  29  * Copyright (c) 2013 by Delphix. All rights reserved.
  30  */
  31 
  32 #include <sys/types.h>
  33 #include <sys/reg.h>
  34 #include <sys/privregs.h>
  35 #include <sys/stack.h>
  36 #include <sys/frame.h>
  37 
  38 #include <mdb/mdb_target_impl.h>
  39 #include <mdb/mdb_kreg_impl.h>
  40 #include <mdb/mdb_debug.h>
  41 #include <mdb/mdb_modapi.h>
  42 #include <mdb/mdb_amd64util.h>
  43 #include <mdb/mdb_ctf.h>
  44 #include <mdb/mdb_err.h>
  45 #include <mdb/mdb.h>
  46 
  47 #include <saveargs.h>
  48 
  49 /*
  50  * This array is used by the getareg and putareg entry points, and also by our
  51  * register variable discipline.
  52  */
  53 
  54 const mdb_tgt_regdesc_t mdb_amd64_kregs[] = {
  55         { "savfp", KREG_SAVFP, MDB_TGT_R_EXPORT },
  56         { "savpc", KREG_SAVPC, MDB_TGT_R_EXPORT },
  57         { "rdi", KREG_RDI, MDB_TGT_R_EXPORT },
  58         { "edi", KREG_RDI, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  59         { "di",  KREG_RDI, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  60         { "dil", KREG_RDI, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  61         { "rsi", KREG_RSI, MDB_TGT_R_EXPORT },
  62         { "esi", KREG_RSI, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  63         { "si",  KREG_RSI, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  64         { "sil", KREG_RSI, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  65         { "rdx", KREG_RDX, MDB_TGT_R_EXPORT },
  66         { "edx", KREG_RDX, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  67         { "dx",  KREG_RDX, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  68         { "dh",  KREG_RDX, MDB_TGT_R_EXPORT | MDB_TGT_R_8H },
  69         { "dl",  KREG_RDX, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  70         { "rcx", KREG_RCX, MDB_TGT_R_EXPORT },
  71         { "ecx", KREG_RCX, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  72         { "cx",  KREG_RCX, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  73         { "ch",  KREG_RCX, MDB_TGT_R_EXPORT | MDB_TGT_R_8H },
  74         { "cl",  KREG_RCX, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  75         { "r8", KREG_R8, MDB_TGT_R_EXPORT },
  76         { "r8d", KREG_R8,  MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  77         { "r8w", KREG_R8,  MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  78         { "r8l", KREG_R8,  MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  79         { "r9", KREG_R9, MDB_TGT_R_EXPORT },
  80         { "r9d", KREG_R8,  MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  81         { "r9w", KREG_R8,  MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  82         { "r9l", KREG_R8,  MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  83         { "rax", KREG_RAX, MDB_TGT_R_EXPORT },
  84         { "eax", KREG_RAX, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  85         { "ax",  KREG_RAX, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  86         { "ah",  KREG_RAX, MDB_TGT_R_EXPORT | MDB_TGT_R_8H },
  87         { "al",  KREG_RAX, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  88         { "rbx", KREG_RBX, MDB_TGT_R_EXPORT },
  89         { "ebx", KREG_RBX, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  90         { "bx",  KREG_RBX, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  91         { "bh",  KREG_RBX, MDB_TGT_R_EXPORT | MDB_TGT_R_8H },
  92         { "bl",  KREG_RBX, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  93         { "rbp", KREG_RBP, MDB_TGT_R_EXPORT },
  94         { "ebp", KREG_RBP, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  95         { "bp",  KREG_RBP, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
  96         { "bpl", KREG_RBP, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
  97         { "r10", KREG_R10, MDB_TGT_R_EXPORT },
  98         { "r10d", KREG_R10, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
  99         { "r10w", KREG_R10, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
 100         { "r10l", KREG_R10, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
 101         { "r11", KREG_R11, MDB_TGT_R_EXPORT },
 102         { "r11d", KREG_R11, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
 103         { "r11w", KREG_R11, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
 104         { "r11l", KREG_R11, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
 105         { "r12", KREG_R12, MDB_TGT_R_EXPORT },
 106         { "r12d", KREG_R12, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
 107         { "r12w", KREG_R12, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
 108         { "r12l", KREG_R12, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
 109         { "r13", KREG_R13, MDB_TGT_R_EXPORT },
 110         { "r13d", KREG_R13, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
 111         { "r13w", KREG_R13, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
 112         { "r13l", KREG_R13, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
 113         { "r14", KREG_R14, MDB_TGT_R_EXPORT },
 114         { "r14d", KREG_R14, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
 115         { "r14w", KREG_R14, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
 116         { "r14l", KREG_R14, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
 117         { "r15", KREG_R15, MDB_TGT_R_EXPORT },
 118         { "r15d", KREG_R15, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
 119         { "r15w", KREG_R15, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
 120         { "r15l", KREG_R15, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
 121         { "ds", KREG_DS, MDB_TGT_R_EXPORT },
 122         { "es", KREG_ES, MDB_TGT_R_EXPORT },
 123         { "fs", KREG_FS, MDB_TGT_R_EXPORT },
 124         { "gs", KREG_GS, MDB_TGT_R_EXPORT },
 125         { "trapno", KREG_TRAPNO, MDB_TGT_R_EXPORT | MDB_TGT_R_PRIV },
 126         { "err", KREG_ERR, MDB_TGT_R_EXPORT | MDB_TGT_R_PRIV },
 127         { "rip", KREG_RIP, MDB_TGT_R_EXPORT },
 128         { "cs", KREG_CS, MDB_TGT_R_EXPORT },
 129         { "rflags", KREG_RFLAGS, MDB_TGT_R_EXPORT },
 130         { "eflags", KREG_RFLAGS, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
 131         { "rsp", KREG_RSP, MDB_TGT_R_EXPORT },
 132         { "esp", KREG_RSP, MDB_TGT_R_EXPORT | MDB_TGT_R_32 },
 133         { "sp",  KREG_RSP, MDB_TGT_R_EXPORT | MDB_TGT_R_16 },
 134         { "spl", KREG_RSP, MDB_TGT_R_EXPORT | MDB_TGT_R_8L },
 135         { "ss", KREG_SS, MDB_TGT_R_EXPORT },
 136         { NULL, 0, 0 }
 137 };
 138 
 139 void
 140 mdb_amd64_printregs(const mdb_tgt_gregset_t *gregs)
 141 {
 142         const kreg_t *kregs = &gregs->kregs[0];
 143         kreg_t rflags = kregs[KREG_RFLAGS];
 144 
 145 #define GETREG2(x) ((uintptr_t)kregs[(x)]), ((uintptr_t)kregs[(x)])
 146 
 147         mdb_printf("%%rax = 0x%0?p %15A %%r9  = 0x%0?p %A\n",
 148             GETREG2(KREG_RAX), GETREG2(KREG_R9));
 149         mdb_printf("%%rbx = 0x%0?p %15A %%r10 = 0x%0?p %A\n",
 150             GETREG2(KREG_RBX), GETREG2(KREG_R10));
 151         mdb_printf("%%rcx = 0x%0?p %15A %%r11 = 0x%0?p %A\n",
 152             GETREG2(KREG_RCX), GETREG2(KREG_R11));
 153         mdb_printf("%%rdx = 0x%0?p %15A %%r12 = 0x%0?p %A\n",
 154             GETREG2(KREG_RDX), GETREG2(KREG_R12));
 155         mdb_printf("%%rsi = 0x%0?p %15A %%r13 = 0x%0?p %A\n",
 156             GETREG2(KREG_RSI), GETREG2(KREG_R13));
 157         mdb_printf("%%rdi = 0x%0?p %15A %%r14 = 0x%0?p %A\n",
 158             GETREG2(KREG_RDI), GETREG2(KREG_R14));
 159         mdb_printf("%%r8  = 0x%0?p %15A %%r15 = 0x%0?p %A\n\n",
 160             GETREG2(KREG_R8), GETREG2(KREG_R15));
 161 
 162         mdb_printf("%%rip = 0x%0?p %A\n", GETREG2(KREG_RIP));
 163         mdb_printf("%%rbp = 0x%0?p\n", kregs[KREG_RBP]);
 164         mdb_printf("%%rsp = 0x%0?p\n", kregs[KREG_RSP]);
 165 
 166         mdb_printf("%%rflags = 0x%08x\n", rflags);
 167 
 168         mdb_printf("  id=%u vip=%u vif=%u ac=%u vm=%u rf=%u nt=%u iopl=0x%x\n",
 169             (rflags & KREG_EFLAGS_ID_MASK) >> KREG_EFLAGS_ID_SHIFT,
 170             (rflags & KREG_EFLAGS_VIP_MASK) >> KREG_EFLAGS_VIP_SHIFT,
 171             (rflags & KREG_EFLAGS_VIF_MASK) >> KREG_EFLAGS_VIF_SHIFT,
 172             (rflags & KREG_EFLAGS_AC_MASK) >> KREG_EFLAGS_AC_SHIFT,
 173             (rflags & KREG_EFLAGS_VM_MASK) >> KREG_EFLAGS_VM_SHIFT,
 174             (rflags & KREG_EFLAGS_RF_MASK) >> KREG_EFLAGS_RF_SHIFT,
 175             (rflags & KREG_EFLAGS_NT_MASK) >> KREG_EFLAGS_NT_SHIFT,
 176             (rflags & KREG_EFLAGS_IOPL_MASK) >> KREG_EFLAGS_IOPL_SHIFT);
 177 
 178         mdb_printf("  status=<%s,%s,%s,%s,%s,%s,%s,%s,%s>\n\n",
 179             (rflags & KREG_EFLAGS_OF_MASK) ? "OF" : "of",
 180             (rflags & KREG_EFLAGS_DF_MASK) ? "DF" : "df",
 181             (rflags & KREG_EFLAGS_IF_MASK) ? "IF" : "if",
 182             (rflags & KREG_EFLAGS_TF_MASK) ? "TF" : "tf",
 183             (rflags & KREG_EFLAGS_SF_MASK) ? "SF" : "sf",
 184             (rflags & KREG_EFLAGS_ZF_MASK) ? "ZF" : "zf",
 185             (rflags & KREG_EFLAGS_AF_MASK) ? "AF" : "af",
 186             (rflags & KREG_EFLAGS_PF_MASK) ? "PF" : "pf",
 187             (rflags & KREG_EFLAGS_CF_MASK) ? "CF" : "cf");
 188 
 189         mdb_printf("%24s%%cs = 0x%04x\t%%ds = 0x%04x\t%%es = 0x%04x\n",
 190             " ", kregs[KREG_CS], kregs[KREG_DS], kregs[KREG_ES]);
 191 
 192         mdb_printf("%%trapno = 0x%x\t\t%%fs = 0x%04x\t%%gs = 0x%04x\n",
 193             kregs[KREG_TRAPNO], (kregs[KREG_FS] & 0xffff),
 194             (kregs[KREG_GS] & 0xffff));
 195         mdb_printf("   %%err = 0x%x\n", kregs[KREG_ERR]);
 196 }
 197 
 198 int
 199 mdb_amd64_kvm_stack_iter(mdb_tgt_t *t, const mdb_tgt_gregset_t *gsp,
 200     mdb_tgt_stack_f *func, void *arg)
 201 {
 202         mdb_tgt_gregset_t gregs;
 203         kreg_t *kregs = &gregs.kregs[0];
 204         int got_pc = (gsp->kregs[KREG_RIP] != 0);
 205         uint_t argc, reg_argc;
 206         long fr_argv[32];
 207         int start_index; /* index to save_instr where to start comparison */
 208         int err;
 209         int i;
 210 
 211         struct fr {
 212                 uintptr_t fr_savfp;
 213                 uintptr_t fr_savpc;
 214         } fr;
 215 
 216         uintptr_t fp = gsp->kregs[KREG_RBP];
 217         uintptr_t pc = gsp->kregs[KREG_RIP];
 218         uintptr_t lastfp = 0;
 219 
 220         ssize_t size;
 221         ssize_t insnsize;
 222         uint8_t ins[SAVEARGS_INSN_SEQ_LEN];
 223 
 224         GElf_Sym s;
 225         mdb_syminfo_t sip;
 226         mdb_ctf_funcinfo_t mfp;
 227         int xpv_panic = 0;
 228         int advance_tortoise = 1;
 229         uintptr_t tortoise_fp = 0;
 230 #ifndef _KMDB
 231         int xp;
 232 
 233         if ((mdb_readsym(&xp, sizeof (xp), "xpv_panicking") != -1) && (xp > 0))
 234                 xpv_panic = 1;
 235 #endif
 236 
 237         bcopy(gsp, &gregs, sizeof (gregs));
 238 
 239         while (fp != 0) {
 240                 int args_style = 0;
 241 
 242                 if (mdb_tgt_vread(t, &fr, sizeof (fr), fp) != sizeof (fr)) {
 243                         err = EMDB_NOMAP;
 244                         goto badfp;
 245                 }
 246 
 247                 if (tortoise_fp == 0) {
 248                         tortoise_fp = fp;
 249                 } else {
 250                         /*
 251                          * Advance tortoise_fp every other frame, so we detect
 252                          * cycles with Floyd's tortoise/hare.
 253                          */
 254                         if (advance_tortoise != 0) {
 255                                 struct fr tfr;
 256 
 257                                 if (mdb_tgt_vread(t, &tfr, sizeof (tfr),
 258                                     tortoise_fp) != sizeof (tfr)) {
 259                                         err = EMDB_NOMAP;
 260                                         goto badfp;
 261                                 }
 262 
 263                                 tortoise_fp = tfr.fr_savfp;
 264                         }
 265 
 266                         if (fp == tortoise_fp) {
 267                                 err = EMDB_STKFRAME;
 268                                 goto badfp;
 269                         }
 270                 }
 271 
 272                 advance_tortoise = !advance_tortoise;
 273 
 274                 if ((mdb_tgt_lookup_by_addr(t, pc, MDB_TGT_SYM_FUZZY,
 275                     NULL, 0, &s, &sip) == 0) &&
 276                     (mdb_ctf_func_info(&s, &sip, &mfp) == 0)) {
 277                         int return_type = mdb_ctf_type_kind(mfp.mtf_return);
 278                         mdb_ctf_id_t args_types[5];
 279 
 280                         argc = mfp.mtf_argc;
 281 
 282                         /*
 283                          * If the function returns a structure or union
 284                          * greater than 16 bytes in size %rdi contains the
 285                          * address in which to store the return value rather
 286                          * than for an argument.
 287                          */
 288                         if ((return_type == CTF_K_STRUCT ||
 289                             return_type == CTF_K_UNION) &&
 290                             mdb_ctf_type_size(mfp.mtf_return) > 16)
 291                                 start_index = 1;
 292                         else
 293                                 start_index = 0;
 294 
 295                         /*
 296                          * If any of the first 5 arguments are a structure
 297                          * less than 16 bytes in size, it will be passed
 298                          * spread across two argument registers, and we will
 299                          * not cope.
 300                          */
 301                         if (mdb_ctf_func_args(&mfp, 5, args_types) == CTF_ERR)
 302                                 argc = 0;
 303 
 304                         for (i = 0; i < MIN(5, argc); i++) {
 305                                 int t = mdb_ctf_type_kind(args_types[i]);
 306 
 307                                 if (((t == CTF_K_STRUCT) ||
 308                                     (t == CTF_K_UNION)) &&
 309                                     mdb_ctf_type_size(args_types[i]) <= 16) {
 310                                         argc = 0;
 311                                         break;
 312                                 }
 313                         }
 314                 } else {
 315                         argc = 0;
 316                 }
 317 
 318                 /*
 319                  * The number of instructions to search for argument saving is
 320                  * limited such that only instructions prior to %pc are
 321                  * considered such that we never read arguments from a
 322                  * function where the saving code has not in fact yet
 323                  * executed.
 324                  */
 325                 insnsize = MIN(MIN(s.st_size, SAVEARGS_INSN_SEQ_LEN),
 326                     pc - s.st_value);
 327 
 328                 if (mdb_tgt_vread(t, ins, insnsize, s.st_value) != insnsize)
 329                         argc = 0;
 330 
 331                 if ((argc != 0) &&
 332                     ((args_style = saveargs_has_args(ins, insnsize, argc,
 333                     start_index)) != SAVEARGS_NO_ARGS)) {
 334                         /* Up to 6 arguments are passed via registers */
 335                         reg_argc = MIN((6 - start_index), mfp.mtf_argc);
 336                         size = reg_argc * sizeof (long);
 337 
 338                         /*
 339                          * If Studio pushed a structure return address as an
 340                          * argument, we need to read one more argument than
 341                          * actually exists (the addr) to make everything line
 342                          * up.
 343                          */
 344                         if (args_style == SAVEARGS_STRUCT_ARGS)
 345                                 size += sizeof (long);
 346 
 347                         if (mdb_tgt_vread(t, fr_argv, size, (fp - size))
 348                             != size)
 349                                 return (-1);    /* errno has been set for us */
 350 
 351                         /*
 352                          * Arrange the arguments in the right order for
 353                          * printing.
 354                          */
 355                         for (i = 0; i < (reg_argc / 2); i++) {
 356                                 long t = fr_argv[i];
 357 
 358                                 fr_argv[i] = fr_argv[reg_argc - i - 1];
 359                                 fr_argv[reg_argc - i - 1] = t;
 360                         }
 361 
 362                         if (argc > reg_argc) {
 363                                 size = MIN((argc - reg_argc) * sizeof (long),
 364                                     sizeof (fr_argv) -
 365                                     (reg_argc * sizeof (long)));
 366 
 367                                 if (mdb_tgt_vread(t, &fr_argv[reg_argc], size,
 368                                     fp + sizeof (fr)) != size)
 369                                         return (-1); /* errno has been set */
 370                         }
 371                 } else {
 372                         argc = 0;
 373                 }
 374 
 375                 if (got_pc && func(arg, pc, argc, fr_argv, &gregs) != 0)
 376                         break;
 377 
 378                 kregs[KREG_RSP] = kregs[KREG_RBP];
 379 
 380                 lastfp = fp;
 381                 fp = fr.fr_savfp;
 382                 /*
 383                  * The Xen hypervisor marks a stack frame as belonging to
 384                  * an exception by inverting the bits of the pointer to
 385                  * that frame.  We attempt to identify these frames by
 386                  * inverting the pointer and seeing if it is within 0xfff
 387                  * bytes of the last frame.
 388                  */
 389                 if (xpv_panic)
 390                         if ((fp != 0) && (fp < lastfp) &&
 391                             ((lastfp ^ ~fp) < 0xfff))
 392                                 fp = ~fp;
 393 
 394                 kregs[KREG_RBP] = fp;
 395                 kregs[KREG_RIP] = pc = fr.fr_savpc;
 396 
 397                 got_pc = (pc != 0);
 398         }
 399 
 400         return (0);
 401 
 402 badfp:
 403         mdb_printf("%p [%s]", fp, mdb_strerror(err));
 404         return (set_errno(err));
 405 }
 406 
 407 /*
 408  * Determine the return address for the current frame.  Typically this is the
 409  * fr_savpc value from the current frame, but we also perform some special
 410  * handling to see if we are stopped on one of the first two instructions of
 411  * a typical function prologue, in which case %rbp will not be set up yet.
 412  */
 413 int
 414 mdb_amd64_step_out(mdb_tgt_t *t, uintptr_t *p, kreg_t pc, kreg_t fp, kreg_t sp,
 415     mdb_instr_t curinstr)
 416 {
 417         struct frame fr;
 418         GElf_Sym s;
 419         char buf[1];
 420 
 421         enum {
 422                 M_PUSHQ_RBP     = 0x55, /* pushq %rbp */
 423                 M_REX_W         = 0x48, /* REX prefix with only W set */
 424                 M_MOVL_RBP      = 0x8b  /* movq %rsp, %rbp with prefix */
 425         };
 426 
 427         if (mdb_tgt_lookup_by_addr(t, pc, MDB_TGT_SYM_FUZZY,
 428             buf, 0, &s, NULL) == 0) {
 429                 if (pc == s.st_value && curinstr == M_PUSHQ_RBP)
 430                         fp = sp - 8;
 431                 else if (pc == s.st_value + 1 && curinstr == M_REX_W) {
 432                         if (mdb_tgt_vread(t, &curinstr, sizeof (curinstr),
 433                             pc + 1) == sizeof (curinstr) && curinstr ==
 434                             M_MOVL_RBP)
 435                                 fp = sp;
 436                 }
 437         }
 438 
 439         if (mdb_tgt_vread(t, &fr, sizeof (fr), fp) == sizeof (fr)) {
 440                 *p = fr.fr_savpc;
 441                 return (0);
 442         }
 443 
 444         return (-1); /* errno is set for us */
 445 }
 446 
 447 /*ARGSUSED*/
 448 int
 449 mdb_amd64_next(mdb_tgt_t *t, uintptr_t *p, kreg_t pc, mdb_instr_t curinstr)
 450 {
 451         mdb_tgt_addr_t npc;
 452         mdb_tgt_addr_t callpc;
 453 
 454         enum {
 455                 M_CALL_REL = 0xe8, /* call near with relative displacement */
 456                 M_CALL_REG = 0xff, /* call near indirect or call far register */
 457 
 458                 M_REX_LO = 0x40,
 459                 M_REX_HI = 0x4f
 460         };
 461 
 462         /*
 463          * If the opcode is a near call with relative displacement, assume the
 464          * displacement is a rel32 from the next instruction.
 465          */
 466         if (curinstr == M_CALL_REL) {
 467                 *p = pc + sizeof (mdb_instr_t) + sizeof (uint32_t);
 468                 return (0);
 469         }
 470 
 471         /* Skip the rex prefix, if any */
 472         callpc = pc;
 473         while (curinstr >= M_REX_LO && curinstr <= M_REX_HI) {
 474                 if (mdb_tgt_vread(t, &curinstr, sizeof (curinstr), ++callpc) !=
 475                     sizeof (curinstr))
 476                         return (-1); /* errno is set for us */
 477         }
 478 
 479         if (curinstr != M_CALL_REG) {
 480                 /* It's not a call */
 481                 return (set_errno(EAGAIN));
 482         }
 483 
 484         if ((npc = mdb_dis_nextins(mdb.m_disasm, t, MDB_TGT_AS_VIRT, pc)) == pc)
 485                 return (-1); /* errno is set for us */
 486 
 487         *p = npc;
 488         return (0);
 489 }
 490 
 491 /*ARGSUSED*/
 492 int
 493 mdb_amd64_kvm_frame(void *arglim, uintptr_t pc, uint_t argc, const long *argv,
 494     const mdb_tgt_gregset_t *gregs)
 495 {
 496         argc = MIN(argc, (uintptr_t)arglim);
 497         mdb_printf("%a(", pc);
 498 
 499         if (argc != 0) {
 500                 mdb_printf("%lr", *argv++);
 501                 for (argc--; argc != 0; argc--)
 502                         mdb_printf(", %lr", *argv++);
 503         }
 504 
 505         mdb_printf(")\n");
 506         return (0);
 507 }
 508 
 509 int
 510 mdb_amd64_kvm_framev(void *arglim, uintptr_t pc, uint_t argc, const long *argv,
 511     const mdb_tgt_gregset_t *gregs)
 512 {
 513         /*
 514          * Historically adb limited stack trace argument display to a fixed-
 515          * size number of arguments since no symbolic debugging info existed.
 516          * On amd64 we can detect the true number of saved arguments so only
 517          * respect an arglim of zero; otherwise display the entire argv[].
 518          */
 519         if (arglim == 0)
 520                 argc = 0;
 521 
 522         mdb_printf("%0?lr %a(", gregs->kregs[KREG_RBP], pc);
 523 
 524         if (argc != 0) {
 525                 mdb_printf("%lr", *argv++);
 526                 for (argc--; argc != 0; argc--)
 527                         mdb_printf(", %lr", *argv++);
 528         }
 529 
 530         mdb_printf(")\n");
 531         return (0);
 532 }