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