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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright 2011 Joyent, Inc. All rights reserved. 27 */ 28 29 #include <mdb/mdb_disasm_impl.h> 30 #include <mdb/mdb_modapi.h> 31 #include <mdb/mdb_string.h> 32 #include <mdb/mdb_debug.h> 33 #include <mdb/mdb_err.h> 34 #include <mdb/mdb_nv.h> 35 #include <mdb/mdb.h> 36 37 #include <libdisasm.h> 38 39 int 40 mdb_dis_select(const char *name) 41 { 42 mdb_var_t *v = mdb_nv_lookup(&mdb.m_disasms, name); 43 44 if (v != NULL) { 45 mdb.m_disasm = mdb_nv_get_cookie(v); 46 return (0); 47 } 48 49 if (mdb.m_target == NULL) { 50 if (mdb.m_defdisasm != NULL) 51 strfree(mdb.m_defdisasm); 52 mdb.m_defdisasm = strdup(name); 53 return (0); 54 } 55 56 return (set_errno(EMDB_NODIS)); 57 } 58 59 mdb_disasm_t * 60 mdb_dis_create(mdb_dis_ctor_f *ctor) 61 { 62 mdb_disasm_t *dp = mdb_zalloc(sizeof (mdb_disasm_t), UM_SLEEP); 63 64 if ((dp->dis_module = mdb.m_lmod) == NULL) 65 dp->dis_module = &mdb.m_rmod; 66 67 if (ctor(dp) == 0) { 68 mdb_var_t *v = mdb_nv_lookup(&mdb.m_disasms, dp->dis_name); 69 70 if (v != NULL) { 71 dp->dis_ops->dis_destroy(dp); 72 mdb_free(dp, sizeof (mdb_disasm_t)); 73 (void) set_errno(EMDB_DISEXISTS); 74 return (NULL); 75 } 76 77 (void) mdb_nv_insert(&mdb.m_disasms, dp->dis_name, NULL, 78 (uintptr_t)dp, MDB_NV_RDONLY | MDB_NV_SILENT); 79 80 if (mdb.m_disasm == NULL) { 81 mdb.m_disasm = dp; 82 } else if (mdb.m_defdisasm != NULL && 83 strcmp(mdb.m_defdisasm, dp->dis_name) == 0) { 84 mdb.m_disasm = dp; 85 strfree(mdb.m_defdisasm); 86 mdb.m_defdisasm = NULL; 87 } 88 89 return (dp); 90 } 91 92 mdb_free(dp, sizeof (mdb_disasm_t)); 93 return (NULL); 94 } 95 96 void 97 mdb_dis_destroy(mdb_disasm_t *dp) 98 { 99 mdb_var_t *v = mdb_nv_lookup(&mdb.m_disasms, dp->dis_name); 100 101 ASSERT(v != NULL); 102 mdb_nv_remove(&mdb.m_disasms, v); 103 dp->dis_ops->dis_destroy(dp); 104 mdb_free(dp, sizeof (mdb_disasm_t)); 105 106 if (mdb.m_disasm == dp) 107 (void) mdb_dis_select("default"); 108 } 109 110 mdb_tgt_addr_t 111 mdb_dis_ins2str(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 112 char *buf, size_t len, mdb_tgt_addr_t addr) 113 { 114 return (dp->dis_ops->dis_ins2str(dp, t, as, buf, len, addr)); 115 } 116 117 mdb_tgt_addr_t 118 mdb_dis_previns(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 119 mdb_tgt_addr_t addr, uint_t n) 120 { 121 return (dp->dis_ops->dis_previns(dp, t, as, addr, n)); 122 } 123 124 mdb_tgt_addr_t 125 mdb_dis_nextins(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 126 mdb_tgt_addr_t addr) 127 { 128 return (dp->dis_ops->dis_nextins(dp, t, as, addr)); 129 } 130 131 /*ARGSUSED*/ 132 int 133 cmd_dismode(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 134 { 135 if ((flags & DCMD_ADDRSPEC) || argc > 1) 136 return (DCMD_USAGE); 137 138 if (argc != 0) { 139 const char *name; 140 141 if (argv->a_type == MDB_TYPE_STRING) 142 name = argv->a_un.a_str; 143 else 144 name = numtostr(argv->a_un.a_val, 10, NTOS_UNSIGNED); 145 146 if (mdb_dis_select(name) == -1) { 147 warn("failed to set disassembly mode"); 148 return (DCMD_ERR); 149 } 150 } 151 152 mdb_printf("disassembly mode is %s (%s)\n", 153 mdb.m_disasm->dis_name, mdb.m_disasm->dis_desc); 154 155 return (DCMD_OK); 156 } 157 158 /*ARGSUSED*/ 159 static int 160 print_dis(mdb_var_t *v, void *ignore) 161 { 162 mdb_disasm_t *dp = mdb_nv_get_cookie(v); 163 164 mdb_printf("%-24s - %s\n", dp->dis_name, dp->dis_desc); 165 return (0); 166 } 167 168 /*ARGSUSED*/ 169 int 170 cmd_disasms(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 171 { 172 if ((flags & DCMD_ADDRSPEC) || argc != 0) 173 return (DCMD_USAGE); 174 175 mdb_nv_sort_iter(&mdb.m_disasms, print_dis, NULL, UM_SLEEP | UM_GC); 176 return (DCMD_OK); 177 } 178 179 /* 180 * Generic libdisasm disassembler interfaces. 181 */ 182 183 #define DISBUFSZ 64 184 185 /* 186 * Internal structure used by the read and lookup routines. 187 */ 188 typedef struct dis_buf { 189 mdb_tgt_t *db_tgt; 190 mdb_tgt_as_t db_as; 191 mdb_tgt_addr_t db_addr; 192 mdb_tgt_addr_t db_nextaddr; 193 uchar_t db_buf[DISBUFSZ]; 194 ssize_t db_bufsize; 195 boolean_t db_readerr; 196 } dis_buf_t; 197 198 /* 199 * Disassembler support routine for lookup up an address. Rely on mdb's "%a" 200 * qualifier to convert the address to a symbol. 201 */ 202 /*ARGSUSED*/ 203 static int 204 libdisasm_lookup(void *data, uint64_t addr, char *buf, size_t buflen, 205 uint64_t *start, size_t *len) 206 { 207 char c; 208 GElf_Sym sym; 209 210 if (buf != NULL) { 211 #ifdef __sparc 212 uint32_t instr[3]; 213 uint32_t dtrace_id; 214 215 /* 216 * On SPARC, DTrace FBT trampoline entries have a sethi/or pair 217 * that indicates the dtrace probe id; this may appear as the 218 * first two instructions or one instruction into the 219 * trampoline. 220 */ 221 if (mdb_vread(instr, sizeof (instr), (uintptr_t)addr) == 222 sizeof (instr)) { 223 if ((instr[0] & 0xfffc0000) == 0x11000000 && 224 (instr[1] & 0xffffe000) == 0x90122000) { 225 dtrace_id = (instr[0] << 10) | 226 (instr[1] & 0x1fff); 227 (void) mdb_snprintf(buf, sizeof (buf), "dt=%#x", 228 dtrace_id); 229 goto out; 230 } else if ((instr[1] & 0xfffc0000) == 0x11000000 && 231 (instr[2] & 0xffffe000) == 0x90122000) { 232 dtrace_id = (instr[1] << 10) | 233 (instr[2] & 0x1fff); 234 (void) mdb_snprintf(buf, sizeof (buf), "dt=%#x", 235 dtrace_id); 236 goto out; 237 } 238 } 239 #endif 240 (void) mdb_snprintf(buf, buflen, "%a", (uintptr_t)addr); 241 } 242 243 #ifdef __sparc 244 out: 245 #endif 246 if (mdb_lookup_by_addr(addr, MDB_SYM_FUZZY, &c, 1, &sym) < 0) 247 return (-1); 248 if (start != NULL) 249 *start = sym.st_value; 250 if (len != NULL) 251 *len = sym.st_size; 252 253 return (0); 254 } 255 256 /* 257 * Disassembler support routine for reading from the target. Rather than having 258 * to read one byte at a time, we read from the address space in chunks. If the 259 * current address doesn't lie within our buffer range, we read in the chunk 260 * starting from the given address. 261 */ 262 static int 263 libdisasm_read(void *data, uint64_t pc, void *buf, size_t buflen) 264 { 265 dis_buf_t *db = data; 266 size_t offset; 267 size_t len; 268 269 if (pc - db->db_addr >= db->db_bufsize) { 270 if (mdb_tgt_aread(db->db_tgt, db->db_as, db->db_buf, 271 sizeof (db->db_buf), pc) != -1) { 272 db->db_bufsize = sizeof (db->db_buf); 273 } else if (mdb_tgt_aread(db->db_tgt, db->db_as, db->db_buf, 274 buflen, pc) != -1) { 275 db->db_bufsize = buflen; 276 } else { 277 if (!db->db_readerr) 278 mdb_warn("failed to read instruction at %#lr", 279 (uintptr_t)pc); 280 db->db_readerr = B_TRUE; 281 return (-1); 282 } 283 db->db_addr = pc; 284 } 285 286 offset = pc - db->db_addr; 287 288 len = MIN(buflen, db->db_bufsize - offset); 289 290 (void) memcpy(buf, (char *)db->db_buf + offset, len); 291 db->db_nextaddr = pc + len; 292 293 return (len); 294 } 295 296 static mdb_tgt_addr_t 297 libdisasm_ins2str(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 298 char *buf, size_t len, mdb_tgt_addr_t pc) 299 { 300 dis_handle_t *dhp = dp->dis_data; 301 dis_buf_t db = { 0 }; 302 const char *p; 303 304 /* 305 * Set the libdisasm data to point to our buffer. This will be 306 * passed as the first argument to the lookup and read functions. 307 */ 308 db.db_tgt = t; 309 db.db_as = as; 310 311 dis_set_data(dhp, &db); 312 313 if ((p = mdb_tgt_name(t)) != NULL && strcmp(p, "proc") == 0) { 314 /* check for ELF ET_REL type; turn on NOIMMSYM if so */ 315 GElf_Ehdr leh; 316 317 if (mdb_tgt_getxdata(t, "ehdr", &leh, sizeof (leh)) != -1 && 318 leh.e_type == ET_REL) { 319 dis_flags_set(dhp, DIS_NOIMMSYM); 320 } else { 321 dis_flags_clear(dhp, DIS_NOIMMSYM); 322 } 323 } 324 325 /* 326 * Attempt to disassemble the instruction. If this fails because of an 327 * unknown opcode, drive on anyway. If it fails because we couldn't 328 * read from the target, bail out immediately. 329 */ 330 if (dis_disassemble(dhp, pc, buf, len) != 0) 331 (void) mdb_snprintf(buf, len, 332 "***ERROR--unknown op code***"); 333 334 if (db.db_readerr) 335 return (pc); 336 337 /* 338 * Return the updated location 339 */ 340 return (db.db_nextaddr); 341 } 342 343 static mdb_tgt_addr_t 344 libdisasm_previns(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 345 mdb_tgt_addr_t pc, uint_t n) 346 { 347 dis_handle_t *dhp = dp->dis_data; 348 dis_buf_t db = { 0 }; 349 350 /* 351 * Set the libdisasm data to point to our buffer. This will be 352 * passed as the first argument to the lookup and read functions. 353 * We set 'readerr' to B_TRUE to turn off the mdb_warn() in 354 * libdisasm_read, because the code works by probing backwards until a 355 * valid address is found. 356 */ 357 db.db_tgt = t; 358 db.db_as = as; 359 db.db_readerr = B_TRUE; 360 361 dis_set_data(dhp, &db); 362 363 return (dis_previnstr(dhp, pc, n)); 364 } 365 366 /*ARGSUSED*/ 367 static mdb_tgt_addr_t 368 libdisasm_nextins(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 369 mdb_tgt_addr_t pc) 370 { 371 mdb_tgt_addr_t npc; 372 char c; 373 374 if ((npc = libdisasm_ins2str(dp, t, as, &c, 1, pc)) == pc) 375 return (pc); 376 377 /* 378 * Probe the address to make sure we can read something from it - we 379 * want the address we return to actually contain something. 380 */ 381 if (mdb_tgt_aread(t, as, &c, 1, npc) != 1) 382 return (pc); 383 384 return (npc); 385 } 386 387 static void 388 libdisasm_destroy(mdb_disasm_t *dp) 389 { 390 dis_handle_t *dhp = dp->dis_data; 391 392 dis_handle_destroy(dhp); 393 } 394 395 static const mdb_dis_ops_t libdisasm_ops = { 396 .dis_destroy = libdisasm_destroy, 397 .dis_ins2str = libdisasm_ins2str, 398 .dis_previns = libdisasm_previns, 399 .dis_nextins = libdisasm_nextins 400 }; 401 402 /* 403 * Generic function for creating a libdisasm-backed disassembler. Creates an 404 * MDB disassembler with the given name backed by libdis with the given flags. 405 */ 406 static int 407 libdisasm_create(mdb_disasm_t *dp, const char *name, 408 const char *desc, int flags) 409 { 410 if ((dp->dis_data = dis_handle_create(flags, NULL, libdisasm_lookup, 411 libdisasm_read)) == NULL) 412 return (-1); 413 414 dp->dis_name = name; 415 dp->dis_ops = &libdisasm_ops; 416 dp->dis_desc = desc; 417 418 return (0); 419 } 420 421 #if defined(__i386) || defined(__amd64) 422 static int 423 ia16_create(mdb_disasm_t *dp) 424 { 425 return (libdisasm_create(dp, 426 "ia16", 427 "Intel 16-bit disassembler", 428 DIS_X86_SIZE16)); 429 } 430 431 static int 432 ia32_create(mdb_disasm_t *dp) 433 { 434 return (libdisasm_create(dp, 435 "ia32", 436 "Intel 32-bit disassembler", 437 DIS_X86_SIZE32)); 438 } 439 #endif 440 441 #if defined(__amd64) 442 static int 443 amd64_create(mdb_disasm_t *dp) 444 { 445 return (libdisasm_create(dp, 446 "amd64", 447 "AMD64 and IA32e 64-bit disassembler", 448 DIS_X86_SIZE64)); 449 } 450 #endif 451 452 #if defined(__sparc) 453 static int 454 sparc1_create(mdb_disasm_t *dp) 455 { 456 return (libdisasm_create(dp, 457 "1", 458 "SPARC-v8 disassembler", 459 DIS_SPARC_V8)); 460 } 461 462 static int 463 sparc2_create(mdb_disasm_t *dp) 464 { 465 return (libdisasm_create(dp, 466 "2", 467 "SPARC-v9 disassembler", 468 DIS_SPARC_V9)); 469 } 470 471 static int 472 sparc4_create(mdb_disasm_t *dp) 473 { 474 return (libdisasm_create(dp, 475 "4", 476 "UltraSPARC1-v9 disassembler", 477 DIS_SPARC_V9 | DIS_SPARC_V9_SGI)); 478 } 479 480 static int 481 sparcv8_create(mdb_disasm_t *dp) 482 { 483 return (libdisasm_create(dp, 484 "v8", 485 "SPARC-v8 disassembler", 486 DIS_SPARC_V8)); 487 } 488 489 static int 490 sparcv9_create(mdb_disasm_t *dp) 491 { 492 return (libdisasm_create(dp, 493 "v9", 494 "SPARC-v9 disassembler", 495 DIS_SPARC_V9)); 496 } 497 498 static int 499 sparcv9plus_create(mdb_disasm_t *dp) 500 { 501 return (libdisasm_create(dp, 502 "v9plus", 503 "UltraSPARC1-v9 disassembler", 504 DIS_SPARC_V9 | DIS_SPARC_V9_SGI)); 505 } 506 #endif 507 508 /*ARGSUSED*/ 509 static void 510 defdis_destroy(mdb_disasm_t *dp) 511 { 512 /* Nothing to do here */ 513 } 514 515 /*ARGSUSED*/ 516 static mdb_tgt_addr_t 517 defdis_ins2str(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 518 char *buf, size_t len, mdb_tgt_addr_t addr) 519 { 520 return (addr); 521 } 522 523 /*ARGSUSED*/ 524 static mdb_tgt_addr_t 525 defdis_previns(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 526 mdb_tgt_addr_t addr, uint_t n) 527 { 528 return (addr); 529 } 530 531 /*ARGSUSED*/ 532 static mdb_tgt_addr_t 533 defdis_nextins(mdb_disasm_t *dp, mdb_tgt_t *t, mdb_tgt_as_t as, 534 mdb_tgt_addr_t addr) 535 { 536 return (addr); 537 } 538 539 static const mdb_dis_ops_t defdis_ops = { 540 .dis_destroy = defdis_destroy, 541 .dis_ins2str = defdis_ins2str, 542 .dis_previns = defdis_previns, 543 .dis_nextins = defdis_nextins, 544 }; 545 546 static int 547 defdis_create(mdb_disasm_t *dp) 548 { 549 dp->dis_name = "default"; 550 dp->dis_desc = "default no-op disassembler"; 551 dp->dis_ops = &defdis_ops; 552 553 return (0); 554 } 555 556 mdb_dis_ctor_f *const mdb_dis_builtins[] = { 557 defdis_create, 558 #if defined(__amd64) 559 ia16_create, 560 ia32_create, 561 amd64_create, 562 #elif defined(__i386) 563 ia16_create, 564 ia32_create, 565 #elif defined(__sparc) 566 sparc1_create, 567 sparc2_create, 568 sparc4_create, 569 sparcv8_create, 570 sparcv9_create, 571 sparcv9plus_create, 572 #endif 573 NULL 574 }; 575