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 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 /* 27 * Copyright 2018 Joyent, Inc. 28 * Copyright (c) 2014 by Delphix. All rights reserved. 29 * Copyright 2020 Oxide Computer Company 30 */ 31 32 /* 33 * User Process Target 34 * 35 * The user process target is invoked when the -u or -p command-line options 36 * are used, or when an ELF executable file or ELF core file is specified on 37 * the command-line. This target is also selected by default when no target 38 * options are present. In this case, it defaults the executable name to 39 * "a.out". If no process or core file is currently attached, the target 40 * functions as a kind of virtual /dev/zero (in accordance with adb(1) 41 * semantics); reads from the virtual address space return zeroes and writes 42 * fail silently. The proc target itself is designed as a wrapper around the 43 * services provided by libproc.so: t->t_pshandle is set to the struct 44 * ps_prochandle pointer returned as a handle by libproc. The target also 45 * opens the executable file itself using the MDB GElf services, for 46 * interpreting the .symtab and .dynsym if no libproc handle has been 47 * initialized, and for handling i/o to and from the object file. Currently, 48 * the only ISA-dependent portions of the proc target are the $r and ::fpregs 49 * dcmds, the callbacks for t_next() and t_step_out(), and the list of named 50 * registers; these are linked in from the proc_isadep.c file for each ISA and 51 * called from the common code in this file. 52 * 53 * The user process target implements complete user process control using the 54 * facilities provided by libproc.so. The MDB execution control model and 55 * an overview of software event management is described in mdb_target.c. The 56 * proc target implements breakpoints by replacing the instruction of interest 57 * with a trap instruction, and then restoring the original instruction to step 58 * over the breakpoint. The idea of replacing program text with instructions 59 * that transfer control to the debugger dates back as far as 1951 [1]. When 60 * the target stops, we replace each breakpoint with the original instruction 61 * as part of the disarm operation. This means that no special processing is 62 * required for t_vread() because the instrumented instructions will never be 63 * seen by the debugger once the target stops. Some debuggers have improved 64 * start/stop performance by leaving breakpoint traps in place and then 65 * handling a read from a breakpoint address as a special case. Although this 66 * improves efficiency for a source-level debugger, it runs somewhat contrary 67 * to the philosophy of the low-level debugger. Since we remove the 68 * instructions, users can apply other external debugging tools to the process 69 * once it has stopped (e.g. the proc(1) tools) and not be misled by MDB 70 * instrumentation. The tracing of faults, signals, system calls, and 71 * watchpoints and general process inspection is implemented directly using 72 * the mechanisms provided by /proc, as described originally in [2] and [3]. 73 * 74 * References 75 * 76 * [1] S. Gill, "The Diagnosis Of Mistakes In Programmes on the EDSAC", 77 * Proceedings of the Royal Society Series A Mathematical and Physical 78 * Sciences, Cambridge University Press, 206(1087), May 1951, pp. 538-554. 79 * 80 * [2] T.J. Killian, "Processes as Files", Proceedings of the USENIX Association 81 * Summer Conference, Salt Lake City, June 1984, pp. 203-207. 82 * 83 * [3] Roger Faulkner and Ron Gomes, "The Process File System and Process 84 * Model in UNIX System V", Proceedings of the USENIX Association 85 * Winter Conference, Dallas, January 1991, pp. 243-252. 86 */ 87 88 #include <mdb/mdb_proc.h> 89 #include <mdb/mdb_disasm.h> 90 #include <mdb/mdb_signal.h> 91 #include <mdb/mdb_string.h> 92 #include <mdb/mdb_module.h> 93 #include <mdb/mdb_debug.h> 94 #include <mdb/mdb_conf.h> 95 #include <mdb/mdb_err.h> 96 #include <mdb/mdb_types.h> 97 #include <mdb/mdb.h> 98 99 #include <sys/utsname.h> 100 #include <sys/wait.h> 101 #include <sys/stat.h> 102 #include <termio.h> 103 #include <signal.h> 104 #include <stdio_ext.h> 105 #include <stdlib.h> 106 #include <string.h> 107 #include <ctype.h> 108 109 #define PC_FAKE -1UL /* illegal pc value unequal 0 */ 110 #define PANIC_BUFSIZE 1024 111 112 static const char PT_EXEC_PATH[] = "a.out"; /* Default executable */ 113 static const char PT_CORE_PATH[] = "core"; /* Default core file */ 114 115 static const pt_ptl_ops_t proc_lwp_ops; 116 static const pt_ptl_ops_t proc_tdb_ops; 117 static const mdb_se_ops_t proc_brkpt_ops; 118 static const mdb_se_ops_t proc_wapt_ops; 119 120 static int pt_setrun(mdb_tgt_t *, mdb_tgt_status_t *, int); 121 static void pt_activate_common(mdb_tgt_t *); 122 static mdb_tgt_vespec_f pt_ignore_sig; 123 static mdb_tgt_se_f pt_fork; 124 static mdb_tgt_se_f pt_exec; 125 126 static int pt_lookup_by_name_thr(mdb_tgt_t *, const char *, 127 const char *, GElf_Sym *, mdb_syminfo_t *, mdb_tgt_tid_t); 128 static int tlsbase(mdb_tgt_t *, mdb_tgt_tid_t, Lmid_t, const char *, 129 psaddr_t *); 130 131 /* 132 * When debugging postmortem, we don't resolve names as we may very well not 133 * be on a system on which those names resolve. 134 */ 135 #define PT_LIBPROC_RESOLVE(P) \ 136 (!(mdb.m_flags & MDB_FL_LMRAW) && Pstate(P) != PS_DEAD) 137 138 /* 139 * The Perror_printf() function interposes on the default, empty libproc 140 * definition. It will be called to report additional information on complex 141 * errors, such as a corrupt core file. We just pass the args to vwarn. 142 */ 143 /*ARGSUSED*/ 144 void 145 Perror_printf(struct ps_prochandle *P, const char *format, ...) 146 { 147 va_list alist; 148 149 va_start(alist, format); 150 vwarn(format, alist); 151 va_end(alist); 152 } 153 154 /* 155 * Open the specified i/o backend as the a.out executable file, and attempt to 156 * load its standard and dynamic symbol tables. Note that if mdb_gelf_create 157 * succeeds, io is assigned to p_fio and is automatically held by gelf_create. 158 */ 159 static mdb_gelf_file_t * 160 pt_open_aout(mdb_tgt_t *t, mdb_io_t *io) 161 { 162 pt_data_t *pt = t->t_data; 163 GElf_Sym s1, s2; 164 165 if ((pt->p_file = mdb_gelf_create(io, ET_NONE, GF_FILE)) == NULL) 166 return (NULL); 167 168 pt->p_symtab = mdb_gelf_symtab_create_file(pt->p_file, 169 SHT_SYMTAB, MDB_TGT_SYMTAB); 170 pt->p_dynsym = mdb_gelf_symtab_create_file(pt->p_file, 171 SHT_DYNSYM, MDB_TGT_DYNSYM); 172 173 /* 174 * If we've got an _start symbol with a zero size, prime the private 175 * symbol table with a copy of _start with its size set to the distance 176 * between _mcount and _start. We do this because DevPro has shipped 177 * the Intel crt1.o without proper .size directives for years, which 178 * precludes proper identification of _start in stack traces. 179 */ 180 if (mdb_gelf_symtab_lookup_by_name(pt->p_dynsym, "_start", &s1, 181 NULL) == 0 && s1.st_size == 0 && 182 GELF_ST_TYPE(s1.st_info) == STT_FUNC) { 183 if (mdb_gelf_symtab_lookup_by_name(pt->p_dynsym, "_mcount", 184 &s2, NULL) == 0 && GELF_ST_TYPE(s2.st_info) == STT_FUNC) { 185 s1.st_size = s2.st_value - s1.st_value; 186 mdb_gelf_symtab_insert(mdb.m_prsym, "_start", &s1); 187 } 188 } 189 190 pt->p_fio = io; 191 return (pt->p_file); 192 } 193 194 /* 195 * Destroy the symbol tables and GElf file object associated with p_fio. Note 196 * that we do not need to explicitly free p_fio: its reference count is 197 * automatically decremented by mdb_gelf_destroy, which will free it if needed. 198 */ 199 static void 200 pt_close_aout(mdb_tgt_t *t) 201 { 202 pt_data_t *pt = t->t_data; 203 204 if (pt->p_symtab != NULL) { 205 mdb_gelf_symtab_destroy(pt->p_symtab); 206 pt->p_symtab = NULL; 207 } 208 209 if (pt->p_dynsym != NULL) { 210 mdb_gelf_symtab_destroy(pt->p_dynsym); 211 pt->p_dynsym = NULL; 212 } 213 214 if (pt->p_file != NULL) { 215 mdb_gelf_destroy(pt->p_file); 216 pt->p_file = NULL; 217 } 218 219 mdb_gelf_symtab_delete(mdb.m_prsym, "_start", NULL); 220 pt->p_fio = NULL; 221 } 222 223 typedef struct tdb_mapping { 224 const char *tm_thr_lib; 225 const char *tm_db_dir; 226 const char *tm_db_name; 227 } tdb_mapping_t; 228 229 static const tdb_mapping_t tdb_map[] = { 230 { "/lwp/amd64/libthread.so", "/usr/lib/lwp/", "libthread_db.so" }, 231 { "/lwp/sparcv9/libthread.so", "/usr/lib/lwp/", "libthread_db.so" }, 232 { "/lwp/libthread.so", "/usr/lib/lwp/", "libthread_db.so" }, 233 { "/libthread.so", "/lib/", "libthread_db.so" }, 234 { "/libc_hwcap", "/lib/", "libc_db.so" }, 235 { "/libc.so", "/lib/", "libc_db.so" } 236 }; 237 238 /* 239 * Pobject_iter callback that we use to search for the presence of libthread in 240 * order to load the corresponding libthread_db support. We derive the 241 * libthread_db path dynamically based on the libthread path. If libthread is 242 * found, this function returns 1 (and thus Pobject_iter aborts and returns 1) 243 * regardless of whether it was successful in loading the libthread_db support. 244 * If we iterate over all objects and no libthread is found, 0 is returned. 245 * Since libthread_db support was then merged into libc_db, we load either 246 * libc_db or libthread_db, depending on which library we see first. 247 */ 248 /*ARGSUSED*/ 249 static int 250 thr_check(mdb_tgt_t *t, const prmap_t *pmp, const char *name) 251 { 252 pt_data_t *pt = t->t_data; 253 const mdb_tdb_ops_t *ops; 254 char *p; 255 256 char path[MAXPATHLEN]; 257 258 int libn; 259 260 if (name == NULL) 261 return (0); /* no rtld_db object name; keep going */ 262 263 for (libn = 0; libn < sizeof (tdb_map) / sizeof (tdb_map[0]); libn++) { 264 if ((p = strstr(name, tdb_map[libn].tm_thr_lib)) != NULL) 265 break; 266 } 267 268 if (p == NULL) 269 return (0); /* no match; keep going */ 270 271 path[0] = '\0'; 272 (void) strlcat(path, mdb.m_root, sizeof (path)); 273 (void) strlcat(path, tdb_map[libn].tm_db_dir, sizeof (path)); 274 #if !defined(_ILP32) 275 (void) strlcat(path, "64/", sizeof (path)); 276 #endif /* !_ILP32 */ 277 (void) strlcat(path, tdb_map[libn].tm_db_name, sizeof (path)); 278 279 /* Append the trailing library version number. */ 280 (void) strlcat(path, strrchr(name, '.'), sizeof (path)); 281 282 if ((ops = mdb_tdb_load(path)) == NULL) { 283 if (libn != 0 || errno != ENOENT) 284 warn("failed to load %s", path); 285 goto err; 286 } 287 288 if (ops == pt->p_tdb_ops) 289 return (1); /* no changes needed */ 290 291 PTL_DTOR(t); 292 pt->p_tdb_ops = ops; 293 pt->p_ptl_ops = &proc_tdb_ops; 294 pt->p_ptl_hdl = NULL; 295 296 if (PTL_CTOR(t) == -1) { 297 warn("failed to initialize %s", path); 298 goto err; 299 } 300 301 mdb_dprintf(MDB_DBG_TGT, "loaded %s for debugging %s\n", path, name); 302 (void) mdb_tgt_status(t, &t->t_status); 303 return (1); 304 err: 305 PTL_DTOR(t); 306 pt->p_tdb_ops = NULL; 307 pt->p_ptl_ops = &proc_lwp_ops; 308 pt->p_ptl_hdl = NULL; 309 310 if (libn != 0 || errno != ENOENT) { 311 warn("warning: debugger will only be able to " 312 "examine raw LWPs\n"); 313 } 314 315 (void) mdb_tgt_status(t, &t->t_status); 316 return (1); 317 } 318 319 /* 320 * Whenever the link map is consistent following an add or delete event, we ask 321 * libproc to update its mappings, check to see if we need to load libthread_db, 322 * and then update breakpoints which have been mapped or unmapped. 323 */ 324 /*ARGSUSED*/ 325 static void 326 pt_rtld_event(mdb_tgt_t *t, int vid, void *private) 327 { 328 struct ps_prochandle *P = t->t_pshandle; 329 pt_data_t *pt = t->t_data; 330 rd_event_msg_t rdm; 331 int docontinue = 1; 332 333 if (rd_event_getmsg(pt->p_rtld, &rdm) == RD_OK) { 334 335 mdb_dprintf(MDB_DBG_TGT, "rtld event type 0x%x state 0x%x\n", 336 rdm.type, rdm.u.state); 337 338 if (rdm.type == RD_DLACTIVITY && rdm.u.state == RD_CONSISTENT) { 339 mdb_sespec_t *sep, *nsep = mdb_list_next(&t->t_active); 340 pt_brkpt_t *ptb; 341 342 Pupdate_maps(P); 343 344 if (Pobject_iter(P, (proc_map_f *)thr_check, t) == 0 && 345 pt->p_ptl_ops != &proc_lwp_ops) { 346 mdb_dprintf(MDB_DBG_TGT, "unloading thread_db " 347 "support after dlclose\n"); 348 PTL_DTOR(t); 349 pt->p_tdb_ops = NULL; 350 pt->p_ptl_ops = &proc_lwp_ops; 351 pt->p_ptl_hdl = NULL; 352 (void) mdb_tgt_status(t, &t->t_status); 353 } 354 355 for (sep = nsep; sep != NULL; sep = nsep) { 356 nsep = mdb_list_next(sep); 357 ptb = sep->se_data; 358 359 if (sep->se_ops == &proc_brkpt_ops && 360 Paddr_to_map(P, ptb->ptb_addr) == NULL) 361 mdb_tgt_sespec_idle_one(t, sep, 362 EMDB_NOMAP); 363 } 364 365 if (!mdb_tgt_sespec_activate_all(t) && 366 (mdb.m_flags & MDB_FL_BPTNOSYMSTOP) && 367 pt->p_rtld_finished) { 368 /* 369 * We weren't able to activate the breakpoints. 370 * If so requested, we'll return without 371 * calling continue, thus throwing the user into 372 * the debugger. 373 */ 374 docontinue = 0; 375 } 376 377 if (pt->p_rdstate == PT_RD_ADD) 378 pt->p_rdstate = PT_RD_CONSIST; 379 } 380 381 if (rdm.type == RD_PREINIT) 382 (void) mdb_tgt_sespec_activate_all(t); 383 384 if (rdm.type == RD_POSTINIT) { 385 pt->p_rtld_finished = TRUE; 386 if (!mdb_tgt_sespec_activate_all(t) && 387 (mdb.m_flags & MDB_FL_BPTNOSYMSTOP)) { 388 /* 389 * Now that rtld has been initialized, we 390 * should be able to initialize all deferred 391 * breakpoints. If we can't, don't let the 392 * target continue. 393 */ 394 docontinue = 0; 395 } 396 } 397 398 if (rdm.type == RD_DLACTIVITY && rdm.u.state == RD_ADD && 399 pt->p_rtld_finished) 400 pt->p_rdstate = MAX(pt->p_rdstate, PT_RD_ADD); 401 } 402 403 if (docontinue) 404 (void) mdb_tgt_continue(t, NULL); 405 } 406 407 static void 408 pt_post_attach(mdb_tgt_t *t) 409 { 410 struct ps_prochandle *P = t->t_pshandle; 411 const lwpstatus_t *psp = &Pstatus(P)->pr_lwp; 412 pt_data_t *pt = t->t_data; 413 int hflag = MDB_TGT_SPEC_HIDDEN; 414 415 mdb_dprintf(MDB_DBG_TGT, "attach pr_flags=0x%x pr_why=%d pr_what=%d\n", 416 psp->pr_flags, psp->pr_why, psp->pr_what); 417 418 /* 419 * When we grab a process, the initial setting of p_rtld_finished 420 * should be false if the process was just created by exec; otherwise 421 * we permit unscoped references to resolve because we do not know how 422 * far the process has proceeded through linker initialization. 423 */ 424 if ((psp->pr_flags & PR_ISTOP) && psp->pr_why == PR_SYSEXIT && 425 psp->pr_errno == 0 && psp->pr_what == SYS_execve) { 426 if (mdb.m_target == NULL) { 427 warn("target performed exec of %s\n", 428 IOP_NAME(pt->p_fio)); 429 } 430 pt->p_rtld_finished = FALSE; 431 } else 432 pt->p_rtld_finished = TRUE; 433 434 /* 435 * When we grab a process, if it is stopped by job control and part of 436 * the same session (i.e. same controlling tty), set MDB_FL_JOBCTL so 437 * we will know to bring it to the foreground when we continue it. 438 */ 439 if (mdb.m_term != NULL && (psp->pr_flags & PR_STOPPED) && 440 psp->pr_why == PR_JOBCONTROL && getsid(0) == Pstatus(P)->pr_sid) 441 mdb.m_flags |= MDB_FL_JOBCTL; 442 443 /* 444 * When we grab control of a live process, set F_RDWR so that the 445 * target layer permits writes to the target's address space. 446 */ 447 t->t_flags |= MDB_TGT_F_RDWR; 448 449 (void) Pfault(P, FLTBPT, TRUE); /* always trace breakpoints */ 450 (void) Pfault(P, FLTWATCH, TRUE); /* always trace watchpoints */ 451 (void) Pfault(P, FLTTRACE, TRUE); /* always trace single-step */ 452 453 (void) Punsetflags(P, PR_ASYNC); /* require synchronous mode */ 454 (void) Psetflags(P, PR_BPTADJ); /* always adjust eip on x86 */ 455 (void) Psetflags(P, PR_FORK); /* inherit tracing on fork */ 456 457 /* 458 * Install event specifiers to track fork and exec activities: 459 */ 460 (void) mdb_tgt_add_sysexit(t, SYS_vfork, hflag, pt_fork, NULL); 461 (void) mdb_tgt_add_sysexit(t, SYS_forksys, hflag, pt_fork, NULL); 462 (void) mdb_tgt_add_sysexit(t, SYS_execve, hflag, pt_exec, NULL); 463 464 /* 465 * Attempt to instantiate the librtld_db agent and set breakpoints 466 * to track rtld activity. We will legitimately fail to instantiate 467 * the rtld_db agent if the target is statically linked. 468 */ 469 if (pt->p_rtld == NULL && (pt->p_rtld = Prd_agent(P)) != NULL) { 470 rd_notify_t rdn; 471 rd_err_e err; 472 473 if ((err = rd_event_enable(pt->p_rtld, TRUE)) != RD_OK) { 474 warn("failed to enable rtld_db event tracing: %s\n", 475 rd_errstr(err)); 476 goto out; 477 } 478 479 if ((err = rd_event_addr(pt->p_rtld, RD_PREINIT, 480 &rdn)) == RD_OK && rdn.type == RD_NOTIFY_BPT) { 481 (void) mdb_tgt_add_vbrkpt(t, rdn.u.bptaddr, 482 hflag, pt_rtld_event, NULL); 483 } else { 484 warn("failed to install rtld_db preinit tracing: %s\n", 485 rd_errstr(err)); 486 } 487 488 if ((err = rd_event_addr(pt->p_rtld, RD_POSTINIT, 489 &rdn)) == RD_OK && rdn.type == RD_NOTIFY_BPT) { 490 (void) mdb_tgt_add_vbrkpt(t, rdn.u.bptaddr, 491 hflag, pt_rtld_event, NULL); 492 } else { 493 warn("failed to install rtld_db postinit tracing: %s\n", 494 rd_errstr(err)); 495 } 496 497 if ((err = rd_event_addr(pt->p_rtld, RD_DLACTIVITY, 498 &rdn)) == RD_OK && rdn.type == RD_NOTIFY_BPT) { 499 (void) mdb_tgt_add_vbrkpt(t, rdn.u.bptaddr, 500 hflag, pt_rtld_event, NULL); 501 } else { 502 warn("failed to install rtld_db activity tracing: %s\n", 503 rd_errstr(err)); 504 } 505 } 506 out: 507 Pupdate_maps(P); 508 Psync(P); 509 510 /* 511 * If librtld_db failed to initialize due to an error or because we are 512 * debugging a statically linked executable, allow unscoped references. 513 */ 514 if (pt->p_rtld == NULL) 515 pt->p_rtld_finished = TRUE; 516 517 (void) mdb_tgt_sespec_activate_all(t); 518 } 519 520 /*ARGSUSED*/ 521 static int 522 pt_vespec_delete(mdb_tgt_t *t, void *private, int id, void *data) 523 { 524 if (id < 0) { 525 ASSERT(data == NULL); /* we don't use any ve_data */ 526 (void) mdb_tgt_vespec_delete(t, id); 527 } 528 return (0); 529 } 530 531 static void 532 pt_pre_detach(mdb_tgt_t *t, int clear_matched) 533 { 534 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 535 pt_data_t *pt = t->t_data; 536 long cmd = 0; 537 538 /* 539 * If we are about to release the process and it is stopped on a traced 540 * SIGINT, breakpoint fault, single-step fault, or watchpoint, make 541 * sure to clear this event prior to releasing the process so that it 542 * does not subsequently reissue the fault and die from SIGTRAP. 543 */ 544 if (psp->pr_flags & PR_ISTOP) { 545 if (psp->pr_why == PR_FAULTED && (psp->pr_what == FLTBPT || 546 psp->pr_what == FLTTRACE || psp->pr_what == FLTWATCH)) 547 cmd = PCCFAULT; 548 else if (psp->pr_why == PR_SIGNALLED && psp->pr_what == SIGINT) 549 cmd = PCCSIG; 550 551 if (cmd != 0) 552 (void) write(Pctlfd(t->t_pshandle), &cmd, sizeof (cmd)); 553 } 554 555 if (Pstate(t->t_pshandle) == PS_UNDEAD) 556 (void) waitpid(Pstatus(t->t_pshandle)->pr_pid, NULL, WNOHANG); 557 558 (void) mdb_tgt_vespec_iter(t, pt_vespec_delete, NULL); 559 mdb_tgt_sespec_idle_all(t, EMDB_NOPROC, clear_matched); 560 561 if (pt->p_fio != pt->p_aout_fio) { 562 pt_close_aout(t); 563 (void) pt_open_aout(t, pt->p_aout_fio); 564 } 565 566 PTL_DTOR(t); 567 pt->p_tdb_ops = NULL; 568 pt->p_ptl_ops = &proc_lwp_ops; 569 pt->p_ptl_hdl = NULL; 570 571 pt->p_rtld = NULL; 572 pt->p_signal = 0; 573 pt->p_rtld_finished = FALSE; 574 pt->p_rdstate = PT_RD_NONE; 575 } 576 577 static void 578 pt_release_parents(mdb_tgt_t *t) 579 { 580 struct ps_prochandle *P = t->t_pshandle; 581 pt_data_t *pt = t->t_data; 582 583 mdb_sespec_t *sep; 584 pt_vforkp_t *vfp; 585 586 while ((vfp = mdb_list_next(&pt->p_vforkp)) != NULL) { 587 mdb_dprintf(MDB_DBG_TGT, "releasing vfork parent %d\n", 588 (int)Pstatus(vfp->p_pshandle)->pr_pid); 589 590 /* 591 * To release vfork parents, we must also wipe out any armed 592 * events in the parent by switching t_pshandle and calling 593 * se_disarm(). Do not change states or lose the matched list. 594 */ 595 t->t_pshandle = vfp->p_pshandle; 596 597 for (sep = mdb_list_next(&t->t_active); sep != NULL; 598 sep = mdb_list_next(sep)) { 599 if (sep->se_state == MDB_TGT_SPEC_ARMED) 600 (void) sep->se_ops->se_disarm(t, sep); 601 } 602 603 t->t_pshandle = P; 604 605 Prelease(vfp->p_pshandle, PRELEASE_CLEAR); 606 mdb_list_delete(&pt->p_vforkp, vfp); 607 mdb_free(vfp, sizeof (pt_vforkp_t)); 608 } 609 } 610 611 /*ARGSUSED*/ 612 static void 613 pt_fork(mdb_tgt_t *t, int vid, void *private) 614 { 615 struct ps_prochandle *P = t->t_pshandle; 616 const lwpstatus_t *psp = &Pstatus(P)->pr_lwp; 617 pt_data_t *pt = t->t_data; 618 mdb_sespec_t *sep; 619 620 int follow_parent = mdb.m_forkmode != MDB_FM_CHILD; 621 int is_vfork = (psp->pr_what == SYS_vfork || 622 (psp->pr_what == SYS_forksys && psp->pr_sysarg[0] == 2)); 623 624 struct ps_prochandle *C; 625 const lwpstatus_t *csp; 626 char sysname[32]; 627 int gcode; 628 char c; 629 630 mdb_dprintf(MDB_DBG_TGT, "parent %s: errno=%d rv1=%ld rv2=%ld\n", 631 proc_sysname(psp->pr_what, sysname, sizeof (sysname)), 632 psp->pr_errno, psp->pr_rval1, psp->pr_rval2); 633 634 if (psp->pr_errno != 0) { 635 (void) mdb_tgt_continue(t, NULL); 636 return; /* fork failed */ 637 } 638 639 /* 640 * If forkmode is ASK and stdout is a terminal, then ask the user to 641 * explicitly set the fork behavior for this particular fork. 642 */ 643 if (mdb.m_forkmode == MDB_FM_ASK && mdb.m_term != NULL) { 644 mdb_iob_printf(mdb.m_err, "%s: %s detected: follow (p)arent " 645 "or (c)hild? ", mdb.m_pname, sysname); 646 mdb_iob_flush(mdb.m_err); 647 648 while (IOP_READ(mdb.m_term, &c, sizeof (c)) == sizeof (c)) { 649 if (c == 'P' || c == 'p') { 650 mdb_iob_printf(mdb.m_err, "%c\n", c); 651 follow_parent = TRUE; 652 break; 653 } else if (c == 'C' || c == 'c') { 654 mdb_iob_printf(mdb.m_err, "%c\n", c); 655 follow_parent = FALSE; 656 break; 657 } 658 } 659 } 660 661 /* 662 * The parent is now stopped on exit from its fork call. We must now 663 * grab the child on its return from fork in order to manipulate it. 664 */ 665 if ((C = Pgrab(psp->pr_rval1, PGRAB_RETAIN, &gcode)) == NULL) { 666 warn("failed to grab forked child process %ld: %s\n", 667 psp->pr_rval1, Pgrab_error(gcode)); 668 return; /* just stop if we failed to grab the child */ 669 } 670 671 /* 672 * We may have grabbed the child and stopped it prematurely before it 673 * stopped on exit from fork. If so, wait up to 1 sec for it to settle. 674 */ 675 if (Pstatus(C)->pr_lwp.pr_why != PR_SYSEXIT) 676 (void) Pwait(C, MILLISEC); 677 678 csp = &Pstatus(C)->pr_lwp; 679 680 if (csp->pr_why != PR_SYSEXIT || 681 (csp->pr_what != SYS_vfork && csp->pr_what != SYS_forksys)) { 682 warn("forked child process %ld did not stop on exit from " 683 "fork as expected\n", psp->pr_rval1); 684 } 685 686 warn("target forked child process %ld (debugger following %s)\n", 687 psp->pr_rval1, follow_parent ? "parent" : "child"); 688 689 (void) Punsetflags(C, PR_ASYNC); /* require synchronous mode */ 690 (void) Psetflags(C, PR_BPTADJ); /* always adjust eip on x86 */ 691 (void) Prd_agent(C); /* initialize librtld_db */ 692 693 /* 694 * At the time pt_fork() is called, the target event engine has already 695 * disarmed the specifiers on the active list, clearing out events in 696 * the parent process. However, this means that events that change 697 * the address space (e.g. breakpoints) have not been effectively 698 * disarmed in the child since its address space reflects the state of 699 * the process at the time of fork when events were armed. We must 700 * therefore handle this as a special case and re-invoke the disarm 701 * callback of each active specifier to clean out the child process. 702 */ 703 if (!is_vfork) { 704 for (t->t_pshandle = C, sep = mdb_list_next(&t->t_active); 705 sep != NULL; sep = mdb_list_next(sep)) { 706 if (sep->se_state == MDB_TGT_SPEC_ACTIVE) 707 (void) sep->se_ops->se_disarm(t, sep); 708 } 709 710 t->t_pshandle = P; /* restore pshandle to parent */ 711 } 712 713 /* 714 * If we're following the parent process, we need to temporarily change 715 * t_pshandle to refer to the child handle C so that we can clear out 716 * all the events in the child prior to releasing it below. If we are 717 * tracing a vfork, we also need to explicitly wait for the child to 718 * exec, exit, or die before we can reset and continue the parent. We 719 * avoid having to deal with the vfork child forking again by clearing 720 * PR_FORK and setting PR_RLC; if it does fork it will effectively be 721 * released from our control and we will continue following the parent. 722 */ 723 if (follow_parent) { 724 if (is_vfork) { 725 mdb_tgt_status_t status; 726 727 ASSERT(psp->pr_flags & PR_VFORKP); 728 mdb_tgt_sespec_idle_all(t, EBUSY, FALSE); 729 t->t_pshandle = C; 730 731 (void) Psysexit(C, SYS_execve, TRUE); 732 733 (void) Punsetflags(C, PR_FORK | PR_KLC); 734 (void) Psetflags(C, PR_RLC); 735 736 do { 737 if (pt_setrun(t, &status, 0) == -1 || 738 status.st_state == MDB_TGT_UNDEAD || 739 status.st_state == MDB_TGT_LOST) 740 break; /* failure or process died */ 741 742 } while (csp->pr_why != PR_SYSEXIT || 743 csp->pr_errno != 0 || csp->pr_what != SYS_execve); 744 } else 745 t->t_pshandle = C; 746 } 747 748 /* 749 * If we are following the child, destroy any active libthread_db 750 * handle before we release the parent process. 751 */ 752 if (!follow_parent) { 753 PTL_DTOR(t); 754 pt->p_tdb_ops = NULL; 755 pt->p_ptl_ops = &proc_lwp_ops; 756 pt->p_ptl_hdl = NULL; 757 } 758 759 /* 760 * Idle all events to make sure the address space and tracing flags are 761 * restored, and then release the process we are not tracing. If we 762 * are following the child of a vfork, we push the parent's pshandle 763 * on to a list of vfork parents to be released when we exec or exit. 764 */ 765 if (is_vfork && !follow_parent) { 766 pt_vforkp_t *vfp = mdb_alloc(sizeof (pt_vforkp_t), UM_SLEEP); 767 768 ASSERT(psp->pr_flags & PR_VFORKP); 769 vfp->p_pshandle = P; 770 mdb_list_append(&pt->p_vforkp, vfp); 771 mdb_tgt_sespec_idle_all(t, EBUSY, FALSE); 772 773 } else { 774 mdb_tgt_sespec_idle_all(t, EBUSY, FALSE); 775 Prelease(t->t_pshandle, PRELEASE_CLEAR); 776 if (!follow_parent) 777 pt_release_parents(t); 778 } 779 780 /* 781 * Now that all the hard stuff is done, switch t_pshandle back to the 782 * process we are following and reset our events to the ACTIVE state. 783 * If we are following the child, reset the libthread_db handle as well 784 * as the rtld agent. 785 */ 786 if (follow_parent) 787 t->t_pshandle = P; 788 else { 789 t->t_pshandle = C; 790 pt->p_rtld = Prd_agent(C); 791 (void) Pobject_iter(t->t_pshandle, (proc_map_f *)thr_check, t); 792 } 793 794 (void) mdb_tgt_sespec_activate_all(t); 795 (void) mdb_tgt_continue(t, NULL); 796 } 797 798 /*ARGSUSED*/ 799 static void 800 pt_exec(mdb_tgt_t *t, int vid, void *private) 801 { 802 struct ps_prochandle *P = t->t_pshandle; 803 const pstatus_t *psp = Pstatus(P); 804 pt_data_t *pt = t->t_data; 805 int follow_exec = mdb.m_execmode == MDB_EM_FOLLOW; 806 pid_t pid = psp->pr_pid; 807 808 char execname[MAXPATHLEN]; 809 mdb_sespec_t *sep, *nsep; 810 mdb_io_t *io; 811 char c; 812 813 mdb_dprintf(MDB_DBG_TGT, "exit from %s: errno=%d\n", proc_sysname( 814 psp->pr_lwp.pr_what, execname, sizeof (execname)), 815 psp->pr_lwp.pr_errno); 816 817 if (psp->pr_lwp.pr_errno != 0) { 818 (void) mdb_tgt_continue(t, NULL); 819 return; /* exec failed */ 820 } 821 822 /* 823 * If execmode is ASK and stdout is a terminal, then ask the user to 824 * explicitly set the exec behavior for this particular exec. If 825 * Pstate() still shows PS_LOST, we are being called from pt_setrun() 826 * directly and therefore we must resume the terminal since it is still 827 * in the suspended state as far as tgt_continue() is concerned. 828 */ 829 if (mdb.m_execmode == MDB_EM_ASK && mdb.m_term != NULL) { 830 if (Pstate(P) == PS_LOST) 831 IOP_RESUME(mdb.m_term); 832 833 mdb_iob_printf(mdb.m_err, "%s: %s detected: (f)ollow new " 834 "program or (s)top? ", mdb.m_pname, execname); 835 mdb_iob_flush(mdb.m_err); 836 837 while (IOP_READ(mdb.m_term, &c, sizeof (c)) == sizeof (c)) { 838 if (c == 'F' || c == 'f') { 839 mdb_iob_printf(mdb.m_err, "%c\n", c); 840 follow_exec = TRUE; 841 break; 842 } else if (c == 'S' || c == 's') { 843 mdb_iob_printf(mdb.m_err, "%c\n", c); 844 follow_exec = FALSE; 845 break; 846 } 847 } 848 849 if (Pstate(P) == PS_LOST) 850 IOP_SUSPEND(mdb.m_term); 851 } 852 853 pt_release_parents(t); /* release any waiting vfork parents */ 854 pt_pre_detach(t, FALSE); /* remove our breakpoints and idle events */ 855 Preset_maps(P); /* libproc must delete mappings and symtabs */ 856 pt_close_aout(t); /* free pt symbol tables and GElf file data */ 857 858 /* 859 * If we lost control of the process across the exec and are not able 860 * to reopen it, we have no choice but to clear the matched event list 861 * and wait for the user to quit or otherwise release the process. 862 */ 863 if (Pstate(P) == PS_LOST && Preopen(P) == -1) { 864 int error = errno; 865 866 warn("lost control of PID %d due to exec of %s executable\n", 867 (int)pid, error == EOVERFLOW ? "64-bit" : "set-id"); 868 869 for (sep = t->t_matched; sep != T_SE_END; sep = nsep) { 870 nsep = sep->se_matched; 871 sep->se_matched = NULL; 872 mdb_tgt_sespec_rele(t, sep); 873 } 874 875 if (error != EOVERFLOW) 876 return; /* just stop if we exec'd a set-id executable */ 877 } 878 879 if (Pstate(P) != PS_LOST) { 880 if (Pexecname(P, execname, sizeof (execname)) == NULL) { 881 (void) mdb_iob_snprintf(execname, sizeof (execname), 882 "/proc/%d/object/a.out", (int)pid); 883 } 884 885 if (follow_exec == FALSE || psp->pr_dmodel == PR_MODEL_NATIVE) 886 warn("target performed exec of %s\n", execname); 887 888 io = mdb_fdio_create_path(NULL, execname, pt->p_oflags, 0); 889 if (io == NULL) { 890 warn("failed to open %s", execname); 891 warn("a.out symbol tables will not be available\n"); 892 } else if (pt_open_aout(t, io) == NULL) { 893 (void) mdb_dis_select(pt_disasm(NULL)); 894 mdb_io_destroy(io); 895 } else 896 (void) mdb_dis_select(pt_disasm(&pt->p_file->gf_ehdr)); 897 } 898 899 /* 900 * We reset our libthread_db state here, but deliberately do NOT call 901 * PTL_DTOR because we do not want to call libthread_db's td_ta_delete. 902 * This interface is hopelessly broken in that it writes to the process 903 * address space (which we do not want it to do after an exec) and it 904 * doesn't bother deallocating any of its storage anyway. 905 */ 906 pt->p_tdb_ops = NULL; 907 pt->p_ptl_ops = &proc_lwp_ops; 908 pt->p_ptl_hdl = NULL; 909 910 if (follow_exec && psp->pr_dmodel != PR_MODEL_NATIVE) { 911 const char *argv[3]; 912 char *state, *env; 913 char pidarg[16]; 914 size_t envlen; 915 916 if (realpath(getexecname(), execname) == NULL) { 917 warn("cannot follow PID %d -- failed to resolve " 918 "debugger pathname for re-exec", (int)pid); 919 return; 920 } 921 922 warn("restarting debugger to follow PID %d ...\n", (int)pid); 923 mdb_dprintf(MDB_DBG_TGT, "re-exec'ing %s\n", execname); 924 925 (void) mdb_snprintf(pidarg, sizeof (pidarg), "-p%d", (int)pid); 926 927 state = mdb_get_config(); 928 envlen = strlen(MDB_CONFIG_ENV_VAR) + 1 + strlen(state) + 1; 929 env = mdb_alloc(envlen, UM_SLEEP); 930 (void) snprintf(env, envlen, 931 "%s=%s", MDB_CONFIG_ENV_VAR, state); 932 933 (void) putenv(env); 934 935 argv[0] = mdb.m_pname; 936 argv[1] = pidarg; 937 argv[2] = NULL; 938 939 if (mdb.m_term != NULL) 940 IOP_SUSPEND(mdb.m_term); 941 942 Prelease(P, PRELEASE_CLEAR | PRELEASE_HANG); 943 (void) execv(execname, (char *const *)argv); 944 warn("failed to re-exec debugger"); 945 946 if (mdb.m_term != NULL) 947 IOP_RESUME(mdb.m_term); 948 949 t->t_pshandle = pt->p_idlehandle; 950 return; 951 } 952 953 pt_post_attach(t); /* install tracing flags and activate events */ 954 pt_activate_common(t); /* initialize librtld_db and libthread_db */ 955 956 if (psp->pr_dmodel != PR_MODEL_NATIVE && mdb.m_term != NULL) { 957 warn("loadable dcmds will not operate on non-native %d-bit " 958 "data model\n", psp->pr_dmodel == PR_MODEL_ILP32 ? 32 : 64); 959 warn("use ::release -a and then run mdb -p %d to restart " 960 "debugger\n", (int)pid); 961 } 962 963 if (follow_exec) 964 (void) mdb_tgt_continue(t, NULL); 965 } 966 967 static int 968 pt_setflags(mdb_tgt_t *t, int flags) 969 { 970 pt_data_t *pt = t->t_data; 971 972 if ((flags ^ t->t_flags) & MDB_TGT_F_RDWR) { 973 int mode = (flags & MDB_TGT_F_RDWR) ? O_RDWR : O_RDONLY; 974 mdb_io_t *io; 975 976 if (pt->p_fio == NULL) 977 return (set_errno(EMDB_NOEXEC)); 978 979 io = mdb_fdio_create_path(NULL, IOP_NAME(pt->p_fio), mode, 0); 980 981 if (io == NULL) 982 return (-1); /* errno is set for us */ 983 984 t->t_flags = (t->t_flags & ~MDB_TGT_F_RDWR) | 985 (flags & MDB_TGT_F_RDWR); 986 987 pt->p_fio = mdb_io_hold(io); 988 mdb_io_rele(pt->p_file->gf_io); 989 pt->p_file->gf_io = pt->p_fio; 990 } 991 992 if (flags & MDB_TGT_F_FORCE) { 993 t->t_flags |= MDB_TGT_F_FORCE; 994 pt->p_gflags |= PGRAB_FORCE; 995 } 996 997 return (0); 998 } 999 1000 /*ARGSUSED*/ 1001 static int 1002 pt_frame(void *arglim, uintptr_t pc, uint_t argc, const long *argv, 1003 const mdb_tgt_gregset_t *gregs) 1004 { 1005 argc = MIN(argc, (uint_t)(uintptr_t)arglim); 1006 mdb_printf("%a(", pc); 1007 1008 if (argc != 0) { 1009 mdb_printf("%lr", *argv++); 1010 for (argc--; argc != 0; argc--) 1011 mdb_printf(", %lr", *argv++); 1012 } 1013 1014 mdb_printf(")\n"); 1015 return (0); 1016 } 1017 1018 static int 1019 pt_framev(void *arglim, uintptr_t pc, uint_t argc, const long *argv, 1020 const mdb_tgt_gregset_t *gregs) 1021 { 1022 argc = MIN(argc, (uint_t)(uintptr_t)arglim); 1023 #if defined(__i386) || defined(__amd64) 1024 mdb_printf("%0?lr %a(", gregs->gregs[R_FP], pc); 1025 #else 1026 mdb_printf("%0?lr %a(", gregs->gregs[R_SP], pc); 1027 #endif 1028 if (argc != 0) { 1029 mdb_printf("%lr", *argv++); 1030 for (argc--; argc != 0; argc--) 1031 mdb_printf(", %lr", *argv++); 1032 } 1033 1034 mdb_printf(")\n"); 1035 return (0); 1036 } 1037 1038 static int 1039 pt_framer(void *arglim, uintptr_t pc, uint_t argc, const long *argv, 1040 const mdb_tgt_gregset_t *gregs) 1041 { 1042 if (pt_frameregs(arglim, pc, argc, argv, gregs, pc == PC_FAKE) == -1) { 1043 /* 1044 * Use verbose format if register format is not supported. 1045 */ 1046 return (pt_framev(arglim, pc, argc, argv, gregs)); 1047 } 1048 1049 return (0); 1050 } 1051 1052 /*ARGSUSED*/ 1053 static int 1054 pt_stack_common(uintptr_t addr, uint_t flags, int argc, 1055 const mdb_arg_t *argv, mdb_tgt_stack_f *func, prgreg_t saved_pc) 1056 { 1057 void *arg = (void *)(uintptr_t)mdb.m_nargs; 1058 mdb_tgt_t *t = mdb.m_target; 1059 mdb_tgt_gregset_t gregs; 1060 1061 if (argc != 0) { 1062 if (argv->a_type == MDB_TYPE_CHAR || argc > 1) 1063 return (DCMD_USAGE); 1064 1065 if (argv->a_type == MDB_TYPE_STRING) 1066 arg = (void *)(uintptr_t)mdb_strtoull(argv->a_un.a_str); 1067 else 1068 arg = (void *)(uintptr_t)argv->a_un.a_val; 1069 } 1070 1071 if (t->t_pshandle == NULL || Pstate(t->t_pshandle) == PS_IDLE) { 1072 mdb_warn("no process active\n"); 1073 return (DCMD_ERR); 1074 } 1075 1076 /* 1077 * In the universe of sparcv7, sparcv9, ia32, and amd64 this code can be 1078 * common: <sys/procfs_isa.h> conveniently #defines R_FP to be the 1079 * appropriate register we need to set in order to perform a stack 1080 * traceback from a given frame address. 1081 */ 1082 if (flags & DCMD_ADDRSPEC) { 1083 bzero(&gregs, sizeof (gregs)); 1084 gregs.gregs[R_FP] = addr; 1085 #ifdef __sparc 1086 gregs.gregs[R_I7] = saved_pc; 1087 #endif /* __sparc */ 1088 } else if (PTL_GETREGS(t, PTL_TID(t), gregs.gregs) != 0) { 1089 mdb_warn("failed to get current register set"); 1090 return (DCMD_ERR); 1091 } 1092 1093 (void) mdb_tgt_stack_iter(t, &gregs, func, arg); 1094 return (DCMD_OK); 1095 } 1096 1097 static int 1098 pt_stack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1099 { 1100 return (pt_stack_common(addr, flags, argc, argv, pt_frame, 0)); 1101 } 1102 1103 static int 1104 pt_stackv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1105 { 1106 return (pt_stack_common(addr, flags, argc, argv, pt_framev, 0)); 1107 } 1108 1109 static int 1110 pt_stackr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1111 { 1112 /* 1113 * Force printing of first register window, by setting the 1114 * saved pc (%i7) to PC_FAKE. 1115 */ 1116 return (pt_stack_common(addr, flags, argc, argv, pt_framer, PC_FAKE)); 1117 } 1118 1119 /*ARGSUSED*/ 1120 static int 1121 pt_ignored(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1122 { 1123 struct ps_prochandle *P = mdb.m_target->t_pshandle; 1124 char buf[PRSIGBUFSZ]; 1125 1126 if ((flags & DCMD_ADDRSPEC) || argc != 0) 1127 return (DCMD_USAGE); 1128 1129 if (P == NULL) { 1130 mdb_warn("no process is currently active\n"); 1131 return (DCMD_ERR); 1132 } 1133 1134 mdb_printf("%s\n", proc_sigset2str(&Pstatus(P)->pr_sigtrace, " ", 1135 FALSE, buf, sizeof (buf))); 1136 1137 return (DCMD_OK); 1138 } 1139 1140 /*ARGSUSED*/ 1141 static int 1142 pt_lwpid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1143 { 1144 struct ps_prochandle *P = mdb.m_target->t_pshandle; 1145 1146 if ((flags & DCMD_ADDRSPEC) || argc != 0) 1147 return (DCMD_USAGE); 1148 1149 if (P == NULL) { 1150 mdb_warn("no process is currently active\n"); 1151 return (DCMD_ERR); 1152 } 1153 1154 mdb_printf("%d\n", Pstatus(P)->pr_lwp.pr_lwpid); 1155 return (DCMD_OK); 1156 } 1157 1158 static int 1159 pt_print_lwpid(int *n, const lwpstatus_t *psp) 1160 { 1161 struct ps_prochandle *P = mdb.m_target->t_pshandle; 1162 int nlwp = Pstatus(P)->pr_nlwp; 1163 1164 if (*n == nlwp - 2) 1165 mdb_printf("%d and ", (int)psp->pr_lwpid); 1166 else if (*n == nlwp - 1) 1167 mdb_printf("%d are", (int)psp->pr_lwpid); 1168 else 1169 mdb_printf("%d, ", (int)psp->pr_lwpid); 1170 1171 (*n)++; 1172 return (0); 1173 } 1174 1175 /*ARGSUSED*/ 1176 static int 1177 pt_lwpids(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1178 { 1179 struct ps_prochandle *P = mdb.m_target->t_pshandle; 1180 int n = 0; 1181 1182 if (P == NULL) { 1183 mdb_warn("no process is currently active\n"); 1184 return (DCMD_ERR); 1185 } 1186 1187 switch (Pstatus(P)->pr_nlwp) { 1188 case 0: 1189 mdb_printf("no lwps are"); 1190 break; 1191 case 1: 1192 mdb_printf("lwpid %d is the only lwp", 1193 Pstatus(P)->pr_lwp.pr_lwpid); 1194 break; 1195 default: 1196 mdb_printf("lwpids "); 1197 (void) Plwp_iter(P, (proc_lwp_f *)pt_print_lwpid, &n); 1198 } 1199 1200 switch (Pstate(P)) { 1201 case PS_DEAD: 1202 mdb_printf(" in core of process %d.\n", Pstatus(P)->pr_pid); 1203 break; 1204 case PS_IDLE: 1205 mdb_printf(" in idle target.\n"); 1206 break; 1207 default: 1208 mdb_printf(" in process %d.\n", (int)Pstatus(P)->pr_pid); 1209 break; 1210 } 1211 1212 return (DCMD_OK); 1213 } 1214 1215 /*ARGSUSED*/ 1216 static int 1217 pt_ignore(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1218 { 1219 pt_data_t *pt = mdb.m_target->t_data; 1220 1221 if (!(flags & DCMD_ADDRSPEC) || argc != 0) 1222 return (DCMD_USAGE); 1223 1224 if (addr < 1 || addr > pt->p_maxsig) { 1225 mdb_warn("invalid signal number -- 0t%lu\n", addr); 1226 return (DCMD_ERR); 1227 } 1228 1229 (void) mdb_tgt_vespec_iter(mdb.m_target, pt_ignore_sig, (void *)addr); 1230 return (DCMD_OK); 1231 } 1232 1233 /*ARGSUSED*/ 1234 static int 1235 pt_attach(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1236 { 1237 mdb_tgt_t *t = mdb.m_target; 1238 pt_data_t *pt = t->t_data; 1239 int state, perr; 1240 1241 if (!(flags & DCMD_ADDRSPEC) && argc == 0) 1242 return (DCMD_USAGE); 1243 1244 if (((flags & DCMD_ADDRSPEC) && argc != 0) || argc > 1 || 1245 (argc != 0 && argv->a_type != MDB_TYPE_STRING)) 1246 return (DCMD_USAGE); 1247 1248 if (t->t_pshandle != NULL && Pstate(t->t_pshandle) != PS_IDLE) { 1249 mdb_warn("debugger is already attached to a %s\n", 1250 (Pstate(t->t_pshandle) == PS_DEAD) ? "core" : "process"); 1251 return (DCMD_ERR); 1252 } 1253 1254 if (pt->p_fio == NULL) { 1255 mdb_warn("attach requires executable to be specified on " 1256 "command-line (or use -p)\n"); 1257 return (DCMD_ERR); 1258 } 1259 1260 if (flags & DCMD_ADDRSPEC) 1261 t->t_pshandle = Pgrab((pid_t)addr, pt->p_gflags, &perr); 1262 else 1263 t->t_pshandle = proc_arg_grab(argv->a_un.a_str, 1264 PR_ARG_ANY, pt->p_gflags, &perr); 1265 1266 if (t->t_pshandle == NULL) { 1267 t->t_pshandle = pt->p_idlehandle; 1268 mdb_warn("cannot attach: %s\n", Pgrab_error(perr)); 1269 return (DCMD_ERR); 1270 } 1271 1272 state = Pstate(t->t_pshandle); 1273 if (state != PS_DEAD && state != PS_IDLE) { 1274 (void) Punsetflags(t->t_pshandle, PR_KLC); 1275 (void) Psetflags(t->t_pshandle, PR_RLC); 1276 pt_post_attach(t); 1277 pt_activate_common(t); 1278 } 1279 1280 (void) mdb_tgt_status(t, &t->t_status); 1281 mdb_module_load_all(0); 1282 return (DCMD_OK); 1283 } 1284 1285 static int 1286 pt_regstatus(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1287 { 1288 mdb_tgt_t *t = mdb.m_target; 1289 1290 if (t->t_pshandle != NULL) { 1291 const pstatus_t *psp = Pstatus(t->t_pshandle); 1292 int cursig = psp->pr_lwp.pr_cursig; 1293 char signame[SIG2STR_MAX]; 1294 int state = Pstate(t->t_pshandle); 1295 1296 if (state != PS_DEAD && state != PS_IDLE) 1297 mdb_printf("process id = %d\n", psp->pr_pid); 1298 else 1299 mdb_printf("no process\n"); 1300 1301 if (cursig != 0 && sig2str(cursig, signame) == 0) 1302 mdb_printf("SIG%s: %s\n", signame, strsignal(cursig)); 1303 } 1304 1305 return (pt_regs(addr, flags, argc, argv)); 1306 } 1307 1308 static void 1309 pt_thread_name(mdb_tgt_t *t, mdb_tgt_tid_t tid, char *buf, size_t bufsize) 1310 { 1311 char name[THREAD_NAME_MAX]; 1312 1313 buf[0] = '\0'; 1314 1315 if (t->t_pshandle == NULL || 1316 Plwp_getname(t->t_pshandle, tid, name, sizeof (name)) != 0 || 1317 name[0] == '\0') { 1318 (void) mdb_snprintf(buf, bufsize, "%lu", tid); 1319 return; 1320 } 1321 1322 (void) mdb_snprintf(buf, bufsize, "%lu [%s]", tid, name); 1323 } 1324 1325 static int 1326 pt_findstack(uintptr_t tid, uint_t flags, int argc, const mdb_arg_t *argv) 1327 { 1328 mdb_tgt_t *t = mdb.m_target; 1329 mdb_tgt_gregset_t gregs; 1330 int showargs = 0; 1331 int count; 1332 uintptr_t pc, sp; 1333 char name[128]; 1334 1335 if (!(flags & DCMD_ADDRSPEC)) 1336 return (DCMD_USAGE); 1337 1338 count = mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &showargs, 1339 NULL); 1340 argc -= count; 1341 argv += count; 1342 1343 if (argc > 1 || (argc == 1 && argv->a_type != MDB_TYPE_STRING)) 1344 return (DCMD_USAGE); 1345 1346 if (PTL_GETREGS(t, tid, gregs.gregs) != 0) { 1347 mdb_warn("failed to get register set for thread %p", tid); 1348 return (DCMD_ERR); 1349 } 1350 1351 pc = gregs.gregs[R_PC]; 1352 #if defined(__i386) || defined(__amd64) 1353 sp = gregs.gregs[R_FP]; 1354 #else 1355 sp = gregs.gregs[R_SP]; 1356 #endif 1357 1358 pt_thread_name(t, tid, name, sizeof (name)); 1359 1360 mdb_printf("stack pointer for thread %s: %p\n", name, sp); 1361 if (pc != 0) 1362 mdb_printf("[ %0?lr %a() ]\n", sp, pc); 1363 1364 (void) mdb_inc_indent(2); 1365 mdb_set_dot(sp); 1366 1367 if (argc == 1) 1368 (void) mdb_eval(argv->a_un.a_str); 1369 else if (showargs) 1370 (void) mdb_eval("<.$C"); 1371 else 1372 (void) mdb_eval("<.$C0"); 1373 1374 (void) mdb_dec_indent(2); 1375 return (DCMD_OK); 1376 } 1377 1378 /*ARGSUSED*/ 1379 static int 1380 pt_gcore(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1381 { 1382 mdb_tgt_t *t = mdb.m_target; 1383 char *prefix = "core"; 1384 char *content_str = NULL; 1385 core_content_t content = CC_CONTENT_DEFAULT; 1386 size_t size; 1387 char *fname; 1388 pid_t pid; 1389 1390 if (flags & DCMD_ADDRSPEC) 1391 return (DCMD_USAGE); 1392 1393 if (mdb_getopts(argc, argv, 1394 'o', MDB_OPT_STR, &prefix, 1395 'c', MDB_OPT_STR, &content_str, NULL) != argc) 1396 return (DCMD_USAGE); 1397 1398 if (content_str != NULL && 1399 (proc_str2content(content_str, &content) != 0 || 1400 content == CC_CONTENT_INVALID)) { 1401 mdb_warn("invalid content string '%s'\n", content_str); 1402 return (DCMD_ERR); 1403 } 1404 1405 if (t->t_pshandle == NULL) { 1406 mdb_warn("no process active\n"); 1407 return (DCMD_ERR); 1408 } 1409 1410 pid = Pstatus(t->t_pshandle)->pr_pid; 1411 size = 1 + mdb_snprintf(NULL, 0, "%s.%d", prefix, (int)pid); 1412 fname = mdb_alloc(size, UM_SLEEP | UM_GC); 1413 (void) mdb_snprintf(fname, size, "%s.%d", prefix, (int)pid); 1414 1415 if (Pgcore(t->t_pshandle, fname, content) != 0) { 1416 /* 1417 * Short writes during dumping are specifically described by 1418 * EBADE, just as ZFS uses this otherwise-unused code for 1419 * checksum errors. Translate to and mdb errno. 1420 */ 1421 if (errno == EBADE) 1422 (void) set_errno(EMDB_SHORTWRITE); 1423 mdb_warn("couldn't dump core"); 1424 return (DCMD_ERR); 1425 } 1426 1427 mdb_warn("%s dumped\n", fname); 1428 1429 return (DCMD_OK); 1430 } 1431 1432 /*ARGSUSED*/ 1433 static int 1434 pt_kill(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1435 { 1436 mdb_tgt_t *t = mdb.m_target; 1437 pt_data_t *pt = t->t_data; 1438 int state; 1439 1440 if ((flags & DCMD_ADDRSPEC) || argc != 0) 1441 return (DCMD_USAGE); 1442 1443 if (t->t_pshandle != NULL && 1444 (state = Pstate(t->t_pshandle)) != PS_DEAD && state != PS_IDLE) { 1445 mdb_warn("victim process PID %d forcibly terminated\n", 1446 (int)Pstatus(t->t_pshandle)->pr_pid); 1447 pt_pre_detach(t, TRUE); 1448 pt_release_parents(t); 1449 Prelease(t->t_pshandle, PRELEASE_KILL); 1450 t->t_pshandle = pt->p_idlehandle; 1451 (void) mdb_tgt_status(t, &t->t_status); 1452 mdb.m_flags &= ~(MDB_FL_VCREATE | MDB_FL_JOBCTL); 1453 } else 1454 mdb_warn("no victim process is currently under control\n"); 1455 1456 return (DCMD_OK); 1457 } 1458 1459 /*ARGSUSED*/ 1460 static int 1461 pt_detach(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1462 { 1463 mdb_tgt_t *t = mdb.m_target; 1464 pt_data_t *pt = t->t_data; 1465 int rflags = pt->p_rflags; 1466 1467 if (argc != 0 && argv->a_type == MDB_TYPE_STRING && 1468 strcmp(argv->a_un.a_str, "-a") == 0) { 1469 rflags = PRELEASE_HANG | PRELEASE_CLEAR; 1470 argv++; 1471 argc--; 1472 } 1473 1474 if ((flags & DCMD_ADDRSPEC) || argc != 0) 1475 return (DCMD_USAGE); 1476 1477 if (t->t_pshandle == NULL || Pstate(t->t_pshandle) == PS_IDLE) { 1478 mdb_warn("debugger is not currently attached to a process " 1479 "or core file\n"); 1480 return (DCMD_ERR); 1481 } 1482 1483 pt_pre_detach(t, TRUE); 1484 pt_release_parents(t); 1485 Prelease(t->t_pshandle, rflags); 1486 t->t_pshandle = pt->p_idlehandle; 1487 (void) mdb_tgt_status(t, &t->t_status); 1488 mdb.m_flags &= ~(MDB_FL_VCREATE | MDB_FL_JOBCTL); 1489 1490 return (DCMD_OK); 1491 } 1492 1493 static uintmax_t 1494 reg_disc_get(const mdb_var_t *v) 1495 { 1496 mdb_tgt_t *t = MDB_NV_COOKIE(v); 1497 mdb_tgt_tid_t tid = PTL_TID(t); 1498 mdb_tgt_reg_t r = 0; 1499 1500 if (tid != (mdb_tgt_tid_t)-1L) 1501 (void) mdb_tgt_getareg(t, tid, mdb_nv_get_name(v), &r); 1502 1503 return (r); 1504 } 1505 1506 static void 1507 reg_disc_set(mdb_var_t *v, uintmax_t r) 1508 { 1509 mdb_tgt_t *t = MDB_NV_COOKIE(v); 1510 mdb_tgt_tid_t tid = PTL_TID(t); 1511 1512 if (tid != (mdb_tgt_tid_t)-1L && mdb_tgt_putareg(t, tid, 1513 mdb_nv_get_name(v), r) == -1) 1514 mdb_warn("failed to modify %%%s register", mdb_nv_get_name(v)); 1515 } 1516 1517 static void 1518 pt_print_reason(const lwpstatus_t *psp) 1519 { 1520 char name[SIG2STR_MAX + 4]; /* enough for SIG+name+\0, syscall or flt */ 1521 const char *desc; 1522 1523 switch (psp->pr_why) { 1524 case PR_REQUESTED: 1525 mdb_printf("stopped by debugger"); 1526 break; 1527 case PR_SIGNALLED: 1528 mdb_printf("stopped on %s (%s)", proc_signame(psp->pr_what, 1529 name, sizeof (name)), strsignal(psp->pr_what)); 1530 break; 1531 case PR_SYSENTRY: 1532 mdb_printf("stopped on entry to %s system call", 1533 proc_sysname(psp->pr_what, name, sizeof (name))); 1534 break; 1535 case PR_SYSEXIT: 1536 mdb_printf("stopped on exit from %s system call", 1537 proc_sysname(psp->pr_what, name, sizeof (name))); 1538 break; 1539 case PR_JOBCONTROL: 1540 mdb_printf("stopped by job control"); 1541 break; 1542 case PR_FAULTED: 1543 if (psp->pr_what == FLTBPT) { 1544 mdb_printf("stopped on a breakpoint"); 1545 } else if (psp->pr_what == FLTWATCH) { 1546 switch (psp->pr_info.si_code) { 1547 case TRAP_RWATCH: 1548 desc = "read"; 1549 break; 1550 case TRAP_WWATCH: 1551 desc = "write"; 1552 break; 1553 case TRAP_XWATCH: 1554 desc = "execute"; 1555 break; 1556 default: 1557 desc = "unknown"; 1558 } 1559 mdb_printf("stopped %s a watchpoint (%s access to %p)", 1560 psp->pr_info.si_trapafter ? "after" : "on", 1561 desc, psp->pr_info.si_addr); 1562 } else if (psp->pr_what == FLTTRACE) { 1563 mdb_printf("stopped after a single-step"); 1564 } else { 1565 mdb_printf("stopped on a %s fault", 1566 proc_fltname(psp->pr_what, name, sizeof (name))); 1567 } 1568 break; 1569 case PR_SUSPENDED: 1570 case PR_CHECKPOINT: 1571 mdb_printf("suspended by the kernel"); 1572 break; 1573 default: 1574 mdb_printf("stopped for unknown reason (%d/%d)", 1575 psp->pr_why, psp->pr_what); 1576 } 1577 } 1578 1579 static void 1580 pt_status_dcmd_upanic(prupanic_t *pru) 1581 { 1582 size_t i; 1583 1584 mdb_printf("process panicked\n"); 1585 if ((pru->pru_flags & PRUPANIC_FLAG_MSG_ERROR) != 0) { 1586 mdb_printf("warning: process upanic message was bad\n"); 1587 return; 1588 } 1589 1590 if ((pru->pru_flags & PRUPANIC_FLAG_MSG_VALID) == 0) 1591 return; 1592 1593 if ((pru->pru_flags & PRUPANIC_FLAG_MSG_TRUNC) != 0) { 1594 mdb_printf("warning: process upanic message truncated\n"); 1595 } 1596 1597 mdb_printf("upanic message: "); 1598 1599 for (i = 0; i < PRUPANIC_BUFLEN; i++) { 1600 if (pru->pru_data[i] == '\0') 1601 break; 1602 if (isascii(pru->pru_data[i]) && isprint(pru->pru_data[i])) { 1603 mdb_printf("%c", pru->pru_data[i]); 1604 } else { 1605 mdb_printf("\\x%02x", pru->pru_data[i]); 1606 } 1607 } 1608 mdb_printf("\n"); 1609 } 1610 1611 /*ARGSUSED*/ 1612 static int 1613 pt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1614 { 1615 mdb_tgt_t *t = mdb.m_target; 1616 struct ps_prochandle *P = t->t_pshandle; 1617 pt_data_t *pt = t->t_data; 1618 1619 if (P != NULL) { 1620 const psinfo_t *pip = Ppsinfo(P); 1621 const pstatus_t *psp = Pstatus(P); 1622 int cursig = 0, bits = 0, coredump = 0; 1623 int state; 1624 GElf_Sym sym; 1625 uintptr_t panicstr; 1626 char *panicbuf = mdb_alloc(PANIC_BUFSIZE, UM_SLEEP); 1627 const siginfo_t *sip = &(psp->pr_lwp.pr_info); 1628 prupanic_t *pru = NULL; 1629 1630 char execname[MAXPATHLEN], buf[BUFSIZ]; 1631 char signame[SIG2STR_MAX + 4]; /* enough for SIG+name+\0 */ 1632 1633 mdb_tgt_spec_desc_t desc; 1634 mdb_sespec_t *sep; 1635 1636 struct utsname uts; 1637 prcred_t cred; 1638 psinfo_t pi; 1639 1640 (void) strcpy(uts.nodename, "unknown machine"); 1641 (void) Puname(P, &uts); 1642 1643 if (pip != NULL) { 1644 bcopy(pip, &pi, sizeof (psinfo_t)); 1645 proc_unctrl_psinfo(&pi); 1646 } else 1647 bzero(&pi, sizeof (psinfo_t)); 1648 1649 bits = pi.pr_dmodel == PR_MODEL_ILP32 ? 32 : 64; 1650 1651 state = Pstate(P); 1652 if (psp != NULL && state != PS_UNDEAD && state != PS_IDLE) 1653 cursig = psp->pr_lwp.pr_cursig; 1654 1655 if (state == PS_DEAD && pip != NULL) { 1656 mdb_printf("debugging core file of %s (%d-bit) " 1657 "from %s\n", pi.pr_fname, bits, uts.nodename); 1658 1659 } else if (state == PS_DEAD) { 1660 mdb_printf("debugging core file\n"); 1661 1662 } else if (state == PS_IDLE) { 1663 const GElf_Ehdr *ehp = &pt->p_file->gf_ehdr; 1664 1665 mdb_printf("debugging %s file (%d-bit)\n", 1666 ehp->e_type == ET_EXEC ? "executable" : "object", 1667 ehp->e_ident[EI_CLASS] == ELFCLASS32 ? 32 : 64); 1668 1669 } else if (state == PS_UNDEAD && pi.pr_pid == 0) { 1670 mdb_printf("debugging defunct process\n"); 1671 1672 } else { 1673 mdb_printf("debugging PID %d (%d-bit)\n", 1674 pi.pr_pid, bits); 1675 } 1676 1677 if (Pexecname(P, execname, sizeof (execname)) != NULL) 1678 mdb_printf("file: %s\n", execname); 1679 1680 if (pip != NULL && state == PS_DEAD) 1681 mdb_printf("initial argv: %s\n", pi.pr_psargs); 1682 1683 if (state != PS_UNDEAD && state != PS_IDLE) { 1684 mdb_printf("threading model: "); 1685 if (pt->p_ptl_ops == &proc_lwp_ops) 1686 mdb_printf("raw lwps\n"); 1687 else 1688 mdb_printf("native threads\n"); 1689 } 1690 1691 mdb_printf("status: "); 1692 switch (state) { 1693 case PS_RUN: 1694 ASSERT(!(psp->pr_flags & PR_STOPPED)); 1695 mdb_printf("process is running"); 1696 if (psp->pr_flags & PR_DSTOP) 1697 mdb_printf(", debugger stop directive pending"); 1698 mdb_printf("\n"); 1699 break; 1700 1701 case PS_STOP: 1702 ASSERT(psp->pr_flags & PR_STOPPED); 1703 pt_print_reason(&psp->pr_lwp); 1704 1705 if (psp->pr_flags & PR_DSTOP) 1706 mdb_printf(", debugger stop directive pending"); 1707 if (psp->pr_flags & PR_ASLEEP) 1708 mdb_printf(", sleeping in %s system call", 1709 proc_sysname(psp->pr_lwp.pr_syscall, 1710 signame, sizeof (signame))); 1711 1712 mdb_printf("\n"); 1713 1714 for (sep = t->t_matched; sep != T_SE_END; 1715 sep = sep->se_matched) { 1716 mdb_printf("event: %s\n", sep->se_ops->se_info( 1717 t, sep, mdb_list_next(&sep->se_velist), 1718 &desc, buf, sizeof (buf))); 1719 } 1720 break; 1721 1722 case PS_LOST: 1723 mdb_printf("debugger lost control of process\n"); 1724 break; 1725 1726 case PS_UNDEAD: 1727 coredump = WIFSIGNALED(pi.pr_wstat) && 1728 WCOREDUMP(pi.pr_wstat); 1729 /*FALLTHRU*/ 1730 1731 case PS_DEAD: 1732 if (cursig == 0 && WIFSIGNALED(pi.pr_wstat)) 1733 cursig = WTERMSIG(pi.pr_wstat); 1734 1735 (void) Pupanic(P, &pru); 1736 1737 /* 1738 * Test for upanic first. We can only use pr_wstat == 0 1739 * as a test for gcore if an NT_PRCRED note is present; 1740 * these features were added at the same time in Solaris 1741 * 8. 1742 */ 1743 if (pru != NULL) { 1744 pt_status_dcmd_upanic(pru); 1745 Pupanic_free(pru); 1746 } else if (pi.pr_wstat == 0 && Pstate(P) == PS_DEAD && 1747 Pcred(P, &cred, 1) == 0) { 1748 mdb_printf("process core file generated " 1749 "with gcore(1)\n"); 1750 } else if (cursig != 0) { 1751 mdb_printf("process terminated by %s (%s)", 1752 proc_signame(cursig, signame, 1753 sizeof (signame)), strsignal(cursig)); 1754 1755 if (sip->si_signo != 0 && SI_FROMUSER(sip) && 1756 sip->si_pid != 0) { 1757 mdb_printf(", pid=%d uid=%u", 1758 (int)sip->si_pid, sip->si_uid); 1759 if (sip->si_code != 0) { 1760 mdb_printf(" code=%d", 1761 sip->si_code); 1762 } 1763 } else { 1764 switch (sip->si_signo) { 1765 case SIGILL: 1766 case SIGTRAP: 1767 case SIGFPE: 1768 case SIGSEGV: 1769 case SIGBUS: 1770 case SIGEMT: 1771 mdb_printf(", addr=%p", 1772 sip->si_addr); 1773 default: 1774 break; 1775 } 1776 } 1777 1778 if (coredump) 1779 mdb_printf(" - core file dumped"); 1780 mdb_printf("\n"); 1781 } else { 1782 mdb_printf("process terminated with exit " 1783 "status %d\n", WEXITSTATUS(pi.pr_wstat)); 1784 } 1785 1786 if (Plookup_by_name(t->t_pshandle, "libc.so", 1787 "panicstr", &sym) == 0 && 1788 Pread(t->t_pshandle, &panicstr, sizeof (panicstr), 1789 sym.st_value) == sizeof (panicstr) && 1790 Pread_string(t->t_pshandle, panicbuf, 1791 PANIC_BUFSIZE, panicstr) > 0) { 1792 mdb_printf("libc panic message: %s", 1793 panicbuf); 1794 } 1795 1796 break; 1797 1798 case PS_IDLE: 1799 mdb_printf("idle\n"); 1800 break; 1801 1802 default: 1803 mdb_printf("unknown libproc Pstate: %d\n", Pstate(P)); 1804 } 1805 mdb_free(panicbuf, PANIC_BUFSIZE); 1806 1807 } else if (pt->p_file != NULL) { 1808 const GElf_Ehdr *ehp = &pt->p_file->gf_ehdr; 1809 1810 mdb_printf("debugging %s file (%d-bit)\n", 1811 ehp->e_type == ET_EXEC ? "executable" : "object", 1812 ehp->e_ident[EI_CLASS] == ELFCLASS32 ? 32 : 64); 1813 mdb_printf("executable file: %s\n", IOP_NAME(pt->p_fio)); 1814 mdb_printf("status: idle\n"); 1815 } 1816 1817 return (DCMD_OK); 1818 } 1819 1820 static int 1821 pt_tls(uintptr_t tid, uint_t flags, int argc, const mdb_arg_t *argv) 1822 { 1823 const char *name; 1824 const char *object; 1825 GElf_Sym sym; 1826 mdb_syminfo_t si; 1827 mdb_tgt_t *t = mdb.m_target; 1828 1829 if (!(flags & DCMD_ADDRSPEC) || argc > 1) 1830 return (DCMD_USAGE); 1831 1832 if (argc == 0) { 1833 psaddr_t b; 1834 1835 if (tlsbase(t, tid, PR_LMID_EVERY, MDB_TGT_OBJ_EXEC, &b) != 0) { 1836 mdb_warn("failed to lookup tlsbase for %r", tid); 1837 return (DCMD_ERR); 1838 } 1839 1840 mdb_printf("%lr\n", b); 1841 mdb_set_dot(b); 1842 1843 return (DCMD_OK); 1844 } 1845 1846 name = argv[0].a_un.a_str; 1847 object = MDB_TGT_OBJ_EVERY; 1848 1849 if (pt_lookup_by_name_thr(t, object, name, &sym, &si, tid) != 0) { 1850 mdb_warn("failed to lookup %s", name); 1851 return (DCMD_ABORT); /* avoid repeated failure */ 1852 } 1853 1854 if (GELF_ST_TYPE(sym.st_info) != STT_TLS && DCMD_HDRSPEC(flags)) 1855 mdb_warn("%s does not refer to thread local storage\n", name); 1856 1857 mdb_printf("%llr\n", sym.st_value); 1858 mdb_set_dot(sym.st_value); 1859 1860 return (DCMD_OK); 1861 } 1862 1863 /*ARGSUSED*/ 1864 static int 1865 pt_tmodel(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1866 { 1867 mdb_tgt_t *t = mdb.m_target; 1868 pt_data_t *pt = t->t_data; 1869 const pt_ptl_ops_t *ptl_ops; 1870 1871 if (argc != 1 || argv->a_type != MDB_TYPE_STRING) 1872 return (DCMD_USAGE); 1873 1874 if (strcmp(argv->a_un.a_str, "thread") == 0) 1875 ptl_ops = &proc_tdb_ops; 1876 else if (strcmp(argv->a_un.a_str, "lwp") == 0) 1877 ptl_ops = &proc_lwp_ops; 1878 else 1879 return (DCMD_USAGE); 1880 1881 if (t->t_pshandle != NULL && pt->p_ptl_ops != ptl_ops) { 1882 PTL_DTOR(t); 1883 pt->p_tdb_ops = NULL; 1884 pt->p_ptl_ops = &proc_lwp_ops; 1885 pt->p_ptl_hdl = NULL; 1886 1887 if (ptl_ops == &proc_tdb_ops) { 1888 (void) Pobject_iter(t->t_pshandle, (proc_map_f *) 1889 thr_check, t); 1890 } 1891 } 1892 1893 (void) mdb_tgt_status(t, &t->t_status); 1894 return (DCMD_OK); 1895 } 1896 1897 static const char * 1898 env_match(const char *cmp, const char *nameval) 1899 { 1900 const char *loc; 1901 size_t cmplen = strlen(cmp); 1902 1903 loc = strchr(nameval, '='); 1904 if (loc != NULL && (loc - nameval) == cmplen && 1905 strncmp(nameval, cmp, cmplen) == 0) { 1906 return (loc + 1); 1907 } 1908 1909 return (NULL); 1910 } 1911 1912 /*ARGSUSED*/ 1913 static int 1914 print_env(void *data, struct ps_prochandle *P, uintptr_t addr, 1915 const char *nameval) 1916 { 1917 const char *value; 1918 1919 if (nameval == NULL) { 1920 mdb_printf("<0x%p>\n", addr); 1921 } else { 1922 if (data == NULL) 1923 mdb_printf("%s\n", nameval); 1924 else if ((value = env_match(data, nameval)) != NULL) 1925 mdb_printf("%s\n", value); 1926 } 1927 1928 return (0); 1929 } 1930 1931 /*ARGSUSED*/ 1932 static int 1933 pt_getenv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1934 { 1935 mdb_tgt_t *t = mdb.m_target; 1936 pt_data_t *pt = t->t_data; 1937 int i; 1938 uint_t opt_t = 0; 1939 mdb_var_t *v; 1940 1941 i = mdb_getopts(argc, argv, 1942 't', MDB_OPT_SETBITS, TRUE, &opt_t, NULL); 1943 1944 argc -= i; 1945 argv += i; 1946 1947 if ((flags & DCMD_ADDRSPEC) || argc > 1) 1948 return (DCMD_USAGE); 1949 1950 if (argc == 1 && argv->a_type != MDB_TYPE_STRING) 1951 return (DCMD_USAGE); 1952 1953 if (opt_t && t->t_pshandle == NULL) { 1954 mdb_warn("no process active\n"); 1955 return (DCMD_ERR); 1956 } 1957 1958 if (opt_t && (Pstate(t->t_pshandle) == PS_IDLE || 1959 Pstate(t->t_pshandle) == PS_UNDEAD)) { 1960 mdb_warn("-t option requires target to be running\n"); 1961 return (DCMD_ERR); 1962 } 1963 1964 if (opt_t != 0) { 1965 if (Penv_iter(t->t_pshandle, print_env, 1966 argc == 0 ? NULL : (void *)argv->a_un.a_str) != 0) 1967 return (DCMD_ERR); 1968 } else if (argc == 1) { 1969 if ((v = mdb_nv_lookup(&pt->p_env, argv->a_un.a_str)) == NULL) 1970 return (DCMD_ERR); 1971 1972 ASSERT(strchr(mdb_nv_get_cookie(v), '=') != NULL); 1973 mdb_printf("%s\n", strchr(mdb_nv_get_cookie(v), '=') + 1); 1974 } else { 1975 1976 mdb_nv_rewind(&pt->p_env); 1977 while ((v = mdb_nv_advance(&pt->p_env)) != NULL) 1978 mdb_printf("%s\n", mdb_nv_get_cookie(v)); 1979 } 1980 1981 return (DCMD_OK); 1982 } 1983 1984 /* 1985 * Function to set a variable in the internal environment, which is used when 1986 * creating new processes. Note that it is possible that 'nameval' can refer to 1987 * read-only memory, if mdb calls putenv() on an existing value before calling 1988 * this function. While we should avoid this situation, this function is 1989 * designed to be robust in the face of such changes. 1990 */ 1991 static void 1992 pt_env_set(pt_data_t *pt, const char *nameval) 1993 { 1994 mdb_var_t *v; 1995 char *equals, *val; 1996 const char *name; 1997 size_t len; 1998 1999 if ((equals = strchr(nameval, '=')) != NULL) { 2000 val = strdup(nameval); 2001 equals = val + (equals - nameval); 2002 } else { 2003 /* 2004 * nameval doesn't contain an equals character. Convert this to 2005 * be 'nameval='. 2006 */ 2007 len = strlen(nameval); 2008 val = mdb_alloc(len + 2, UM_SLEEP); 2009 (void) mdb_snprintf(val, len + 2, "%s=", nameval); 2010 equals = val + len; 2011 } 2012 2013 /* temporary truncate the string for lookup/insert */ 2014 *equals = '\0'; 2015 v = mdb_nv_lookup(&pt->p_env, val); 2016 2017 if (v != NULL) { 2018 char *old = mdb_nv_get_cookie(v); 2019 mdb_free(old, strlen(old) + 1); 2020 name = mdb_nv_get_name(v); 2021 } else { 2022 /* 2023 * The environment is created using MDB_NV_EXTNAME, so we must 2024 * provide external storage for the variable names. 2025 */ 2026 name = strdup(val); 2027 } 2028 2029 *equals = '='; 2030 2031 (void) mdb_nv_insert(&pt->p_env, name, NULL, (uintptr_t)val, 2032 MDB_NV_EXTNAME); 2033 2034 *equals = '='; 2035 } 2036 2037 /* 2038 * Clears the internal environment. 2039 */ 2040 static void 2041 pt_env_clear(pt_data_t *pt) 2042 { 2043 mdb_var_t *v; 2044 char *val, *name; 2045 2046 mdb_nv_rewind(&pt->p_env); 2047 while ((v = mdb_nv_advance(&pt->p_env)) != NULL) { 2048 2049 name = (char *)mdb_nv_get_name(v); 2050 val = mdb_nv_get_cookie(v); 2051 2052 mdb_nv_remove(&pt->p_env, v); 2053 2054 mdb_free(name, strlen(name) + 1); 2055 mdb_free(val, strlen(val) + 1); 2056 } 2057 } 2058 2059 /*ARGSUSED*/ 2060 static int 2061 pt_setenv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2062 { 2063 mdb_tgt_t *t = mdb.m_target; 2064 pt_data_t *pt = t->t_data; 2065 char *nameval; 2066 size_t len; 2067 int alloc; 2068 2069 if ((flags & DCMD_ADDRSPEC) || argc == 0 || argc > 2) 2070 return (DCMD_USAGE); 2071 2072 if ((argc > 0 && argv[0].a_type != MDB_TYPE_STRING) || 2073 (argc > 1 && argv[1].a_type != MDB_TYPE_STRING)) 2074 return (DCMD_USAGE); 2075 2076 if (t->t_pshandle == NULL) { 2077 mdb_warn("no process active\n"); 2078 return (DCMD_ERR); 2079 } 2080 2081 /* 2082 * If the process is in some sort of running state, warn the user that 2083 * changes won't immediately take effect. 2084 */ 2085 if (Pstate(t->t_pshandle) == PS_RUN || 2086 Pstate(t->t_pshandle) == PS_STOP) { 2087 mdb_warn("warning: changes will not take effect until process" 2088 " is restarted\n"); 2089 } 2090 2091 /* 2092 * We allow two forms of operation. The first is the usual "name=value" 2093 * parameter. We also allow the user to specify two arguments, where 2094 * the first is the name of the variable, and the second is the value. 2095 */ 2096 alloc = 0; 2097 if (argc == 1) { 2098 nameval = (char *)argv->a_un.a_str; 2099 } else { 2100 len = strlen(argv[0].a_un.a_str) + 2101 strlen(argv[1].a_un.a_str) + 2; 2102 nameval = mdb_alloc(len, UM_SLEEP); 2103 (void) mdb_snprintf(nameval, len, "%s=%s", argv[0].a_un.a_str, 2104 argv[1].a_un.a_str); 2105 alloc = 1; 2106 } 2107 2108 pt_env_set(pt, nameval); 2109 2110 if (alloc) 2111 mdb_free(nameval, strlen(nameval) + 1); 2112 2113 return (DCMD_OK); 2114 } 2115 2116 /*ARGSUSED*/ 2117 static int 2118 pt_unsetenv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2119 { 2120 mdb_tgt_t *t = mdb.m_target; 2121 pt_data_t *pt = t->t_data; 2122 mdb_var_t *v; 2123 char *value, *name; 2124 2125 if ((flags & DCMD_ADDRSPEC) || argc > 1) 2126 return (DCMD_USAGE); 2127 2128 if (argc == 1 && argv->a_type != MDB_TYPE_STRING) 2129 return (DCMD_USAGE); 2130 2131 if (t->t_pshandle == NULL) { 2132 mdb_warn("no process active\n"); 2133 return (DCMD_ERR); 2134 } 2135 2136 /* 2137 * If the process is in some sort of running state, warn the user that 2138 * changes won't immediately take effect. 2139 */ 2140 if (Pstate(t->t_pshandle) == PS_RUN || 2141 Pstate(t->t_pshandle) == PS_STOP) { 2142 mdb_warn("warning: changes will not take effect until process" 2143 " is restarted\n"); 2144 } 2145 2146 if (argc == 0) { 2147 pt_env_clear(pt); 2148 } else { 2149 if ((v = mdb_nv_lookup(&pt->p_env, argv->a_un.a_str)) != NULL) { 2150 name = (char *)mdb_nv_get_name(v); 2151 value = mdb_nv_get_cookie(v); 2152 2153 mdb_nv_remove(&pt->p_env, v); 2154 2155 mdb_free(name, strlen(name) + 1); 2156 mdb_free(value, strlen(value) + 1); 2157 } 2158 } 2159 2160 return (DCMD_OK); 2161 } 2162 2163 void 2164 getenv_help(void) 2165 { 2166 mdb_printf("-t show current process environment" 2167 " instead of initial environment.\n"); 2168 } 2169 2170 static const mdb_dcmd_t pt_dcmds[] = { 2171 { "$c", "?[cnt]", "print stack backtrace", pt_stack }, 2172 { "$C", "?[cnt]", "print stack backtrace", pt_stackv }, 2173 { "$i", NULL, "print signals that are ignored", pt_ignored }, 2174 { "$l", NULL, "print the representative thread's lwp id", pt_lwpid }, 2175 { "$L", NULL, "print list of the active lwp ids", pt_lwpids }, 2176 { "$r", "?[-u]", "print general-purpose registers", pt_regs }, 2177 { "$x", "?", "print floating point registers", pt_fpregs }, 2178 { "$X", "?", "print floating point registers", pt_fpregs }, 2179 { "$y", "?", "print floating point registers", pt_fpregs }, 2180 { "$Y", "?", "print floating point registers", pt_fpregs }, 2181 { "$?", "?", "print status and registers", pt_regstatus }, 2182 { ":A", "?[core|pid]", "attach to process or core file", pt_attach }, 2183 { ":i", ":", "ignore signal (delete all matching events)", pt_ignore }, 2184 { ":k", NULL, "forcibly kill and release target", pt_kill }, 2185 { ":R", "[-a]", "release the previously attached process", pt_detach }, 2186 { "attach", "?[core|pid]", 2187 "attach to process or core file", pt_attach }, 2188 { "findstack", ":[-v]", "find user thread stack", pt_findstack }, 2189 { "gcore", "[-o prefix] [-c content]", 2190 "produce a core file for the attached process", pt_gcore }, 2191 { "getenv", "[-t] [name]", "display an environment variable", 2192 pt_getenv, getenv_help }, 2193 { "kill", NULL, "forcibly kill and release target", pt_kill }, 2194 { "release", "[-a]", 2195 "release the previously attached process", pt_detach }, 2196 { "regs", "?[-u]", "print general-purpose registers", pt_regs }, 2197 { "fpregs", "?[-dqs]", "print floating point registers", pt_fpregs }, 2198 { "setenv", "name=value", "set an environment variable", pt_setenv }, 2199 { "stack", "?[cnt]", "print stack backtrace", pt_stack }, 2200 { "stackregs", "?", "print stack backtrace and registers", pt_stackr }, 2201 { "status", NULL, "print summary of current target", pt_status_dcmd }, 2202 { "tls", ":symbol", 2203 "lookup TLS data in the context of a given thread", pt_tls }, 2204 { "tmodel", "{thread|lwp}", NULL, pt_tmodel }, 2205 { "unsetenv", "[name]", "clear an environment variable", pt_unsetenv }, 2206 { NULL } 2207 }; 2208 2209 static void 2210 pt_thr_walk_fini(mdb_walk_state_t *wsp) 2211 { 2212 mdb_addrvec_destroy(wsp->walk_data); 2213 mdb_free(wsp->walk_data, sizeof (mdb_addrvec_t)); 2214 } 2215 2216 static int 2217 pt_thr_walk_init(mdb_walk_state_t *wsp) 2218 { 2219 wsp->walk_data = mdb_zalloc(sizeof (mdb_addrvec_t), UM_SLEEP); 2220 mdb_addrvec_create(wsp->walk_data); 2221 2222 if (PTL_ITER(mdb.m_target, wsp->walk_data) == -1) { 2223 mdb_warn("failed to iterate over threads"); 2224 pt_thr_walk_fini(wsp); 2225 return (WALK_ERR); 2226 } 2227 2228 return (WALK_NEXT); 2229 } 2230 2231 static int 2232 pt_thr_walk_step(mdb_walk_state_t *wsp) 2233 { 2234 if (mdb_addrvec_length(wsp->walk_data) != 0) { 2235 return (wsp->walk_callback(mdb_addrvec_shift(wsp->walk_data), 2236 NULL, wsp->walk_cbdata)); 2237 } 2238 return (WALK_DONE); 2239 } 2240 2241 static const mdb_walker_t pt_walkers[] = { 2242 { "thread", "walk list of valid thread identifiers", 2243 pt_thr_walk_init, pt_thr_walk_step, pt_thr_walk_fini }, 2244 { NULL } 2245 }; 2246 2247 static int 2248 pt_agent_check(boolean_t *agent, const lwpstatus_t *psp) 2249 { 2250 if (psp->pr_flags & PR_AGENT) 2251 *agent = B_TRUE; 2252 2253 return (0); 2254 } 2255 2256 static void 2257 pt_activate_common(mdb_tgt_t *t) 2258 { 2259 pt_data_t *pt = t->t_data; 2260 boolean_t hasagent = B_FALSE; 2261 GElf_Sym sym; 2262 2263 /* 2264 * If we have a libproc handle and AT_BASE is set, the process or core 2265 * is dynamically linked. We call Prd_agent() to force libproc to 2266 * try to initialize librtld_db, and issue a warning if that fails. 2267 */ 2268 if (t->t_pshandle != NULL && Pgetauxval(t->t_pshandle, 2269 AT_BASE) != -1L && Prd_agent(t->t_pshandle) == NULL) { 2270 mdb_warn("warning: librtld_db failed to initialize; shared " 2271 "library information will not be available\n"); 2272 } 2273 2274 if (t->t_pshandle != NULL) { 2275 (void) Plwp_iter(t->t_pshandle, 2276 (proc_lwp_f *)pt_agent_check, &hasagent); 2277 } 2278 2279 if (hasagent) { 2280 mdb_warn("agent lwp detected; forcing " 2281 "lwp thread model (use ::tmodel to change)\n"); 2282 } else if (t->t_pshandle != NULL && Pstate(t->t_pshandle) != PS_IDLE) { 2283 /* 2284 * If we have a libproc handle and we do not have an agent LWP, 2285 * look for the correct thread debugging library. (If we have 2286 * an agent LWP, we leave the model as the raw LWP model to 2287 * allow the agent LWP to be visible to the debugger.) 2288 */ 2289 (void) Pobject_iter(t->t_pshandle, (proc_map_f *)thr_check, t); 2290 } 2291 2292 /* 2293 * If there's a global object named '_mdb_abort_info', assuming we're 2294 * debugging mdb itself and load the developer support module. 2295 */ 2296 if (mdb_gelf_symtab_lookup_by_name(pt->p_symtab, "_mdb_abort_info", 2297 &sym, NULL) == 0 && GELF_ST_TYPE(sym.st_info) == STT_OBJECT) { 2298 if (mdb_module_load("mdb_ds", MDB_MOD_SILENT) < 0) 2299 mdb_warn("warning: failed to load developer support\n"); 2300 } 2301 2302 mdb_tgt_elf_export(pt->p_file); 2303 } 2304 2305 static void 2306 pt_activate(mdb_tgt_t *t) 2307 { 2308 static const mdb_nv_disc_t reg_disc = { reg_disc_set, reg_disc_get }; 2309 2310 pt_data_t *pt = t->t_data; 2311 struct utsname u1, u2; 2312 mdb_var_t *v; 2313 core_content_t content; 2314 2315 if (t->t_pshandle) { 2316 mdb_prop_postmortem = (Pstate(t->t_pshandle) == PS_DEAD); 2317 mdb_prop_kernel = FALSE; 2318 } else 2319 mdb_prop_kernel = mdb_prop_postmortem = FALSE; 2320 2321 mdb_prop_datamodel = MDB_TGT_MODEL_NATIVE; 2322 2323 /* 2324 * If we're examining a core file that doesn't contain program text, 2325 * and uname(2) doesn't match the NT_UTSNAME note recorded in the 2326 * core file, issue a warning. 2327 */ 2328 if (mdb_prop_postmortem == TRUE && 2329 ((content = Pcontent(t->t_pshandle)) == CC_CONTENT_INVALID || 2330 !(content & CC_CONTENT_TEXT)) && 2331 uname(&u1) >= 0 && Puname(t->t_pshandle, &u2) == 0 && 2332 (strcmp(u1.release, u2.release) != 0 || 2333 strcmp(u1.version, u2.version) != 0)) { 2334 mdb_warn("warning: core file is from %s %s %s; shared text " 2335 "mappings may not match installed libraries\n", 2336 u2.sysname, u2.release, u2.version); 2337 } 2338 2339 /* 2340 * Perform the common initialization tasks -- these are shared with 2341 * the pt_exec() and pt_run() subroutines. 2342 */ 2343 pt_activate_common(t); 2344 2345 (void) mdb_tgt_register_dcmds(t, &pt_dcmds[0], MDB_MOD_FORCE); 2346 (void) mdb_tgt_register_walkers(t, &pt_walkers[0], MDB_MOD_FORCE); 2347 2348 /* 2349 * Iterate through our register description list and export 2350 * each register as a named variable. 2351 */ 2352 mdb_nv_rewind(&pt->p_regs); 2353 while ((v = mdb_nv_advance(&pt->p_regs)) != NULL) { 2354 ushort_t rd_flags = MDB_TGT_R_FLAGS(mdb_nv_get_value(v)); 2355 2356 if (!(rd_flags & MDB_TGT_R_EXPORT)) 2357 continue; /* Don't export register as a variable */ 2358 2359 (void) mdb_nv_insert(&mdb.m_nv, mdb_nv_get_name(v), ®_disc, 2360 (uintptr_t)t, MDB_NV_PERSIST); 2361 } 2362 } 2363 2364 static void 2365 pt_deactivate(mdb_tgt_t *t) 2366 { 2367 pt_data_t *pt = t->t_data; 2368 const mdb_dcmd_t *dcp; 2369 const mdb_walker_t *wp; 2370 mdb_var_t *v, *w; 2371 2372 mdb_nv_rewind(&pt->p_regs); 2373 while ((v = mdb_nv_advance(&pt->p_regs)) != NULL) { 2374 ushort_t rd_flags = MDB_TGT_R_FLAGS(mdb_nv_get_value(v)); 2375 2376 if (!(rd_flags & MDB_TGT_R_EXPORT)) 2377 continue; /* Didn't export register as a variable */ 2378 2379 if (w = mdb_nv_lookup(&mdb.m_nv, mdb_nv_get_name(v))) { 2380 w->v_flags &= ~MDB_NV_PERSIST; 2381 mdb_nv_remove(&mdb.m_nv, w); 2382 } 2383 } 2384 2385 for (wp = &pt_walkers[0]; wp->walk_name != NULL; wp++) { 2386 if (mdb_module_remove_walker(t->t_module, wp->walk_name) == -1) 2387 warn("failed to remove walk %s", wp->walk_name); 2388 } 2389 2390 for (dcp = &pt_dcmds[0]; dcp->dc_name != NULL; dcp++) { 2391 if (mdb_module_remove_dcmd(t->t_module, dcp->dc_name) == -1) 2392 warn("failed to remove dcmd %s", dcp->dc_name); 2393 } 2394 2395 mdb_prop_postmortem = FALSE; 2396 mdb_prop_kernel = FALSE; 2397 mdb_prop_datamodel = MDB_TGT_MODEL_UNKNOWN; 2398 } 2399 2400 static void 2401 pt_periodic(mdb_tgt_t *t) 2402 { 2403 pt_data_t *pt = t->t_data; 2404 2405 if (pt->p_rdstate == PT_RD_CONSIST) { 2406 if (t->t_pshandle != NULL && Pstate(t->t_pshandle) < PS_LOST && 2407 !(mdb.m_flags & MDB_FL_NOMODS)) { 2408 mdb_printf("%s: You've got symbols!\n", mdb.m_pname); 2409 mdb_module_load_all(0); 2410 } 2411 pt->p_rdstate = PT_RD_NONE; 2412 } 2413 } 2414 2415 static void 2416 pt_destroy(mdb_tgt_t *t) 2417 { 2418 pt_data_t *pt = t->t_data; 2419 2420 if (pt->p_idlehandle != NULL && pt->p_idlehandle != t->t_pshandle) 2421 Prelease(pt->p_idlehandle, 0); 2422 2423 if (t->t_pshandle != NULL) { 2424 PTL_DTOR(t); 2425 pt_release_parents(t); 2426 pt_pre_detach(t, TRUE); 2427 Prelease(t->t_pshandle, pt->p_rflags); 2428 } 2429 2430 mdb.m_flags &= ~(MDB_FL_VCREATE | MDB_FL_JOBCTL); 2431 pt_close_aout(t); 2432 2433 if (pt->p_aout_fio != NULL) 2434 mdb_io_rele(pt->p_aout_fio); 2435 2436 pt_env_clear(pt); 2437 mdb_nv_destroy(&pt->p_env); 2438 2439 mdb_nv_destroy(&pt->p_regs); 2440 mdb_free(pt, sizeof (pt_data_t)); 2441 } 2442 2443 /*ARGSUSED*/ 2444 static const char * 2445 pt_name(mdb_tgt_t *t) 2446 { 2447 return ("proc"); 2448 } 2449 2450 static const char * 2451 pt_platform(mdb_tgt_t *t) 2452 { 2453 pt_data_t *pt = t->t_data; 2454 2455 if (t->t_pshandle != NULL && 2456 Pplatform(t->t_pshandle, pt->p_platform, MAXNAMELEN) != NULL) 2457 return (pt->p_platform); 2458 2459 return (mdb_conf_platform()); 2460 } 2461 2462 static int 2463 pt_uname(mdb_tgt_t *t, struct utsname *utsp) 2464 { 2465 if (t->t_pshandle != NULL) 2466 return (Puname(t->t_pshandle, utsp)); 2467 2468 return (uname(utsp) >= 0 ? 0 : -1); 2469 } 2470 2471 static int 2472 pt_dmodel(mdb_tgt_t *t) 2473 { 2474 if (t->t_pshandle == NULL) 2475 return (MDB_TGT_MODEL_NATIVE); 2476 2477 switch (Pstatus(t->t_pshandle)->pr_dmodel) { 2478 case PR_MODEL_ILP32: 2479 return (MDB_TGT_MODEL_ILP32); 2480 case PR_MODEL_LP64: 2481 return (MDB_TGT_MODEL_LP64); 2482 } 2483 2484 return (MDB_TGT_MODEL_UNKNOWN); 2485 } 2486 2487 static ssize_t 2488 pt_vread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr) 2489 { 2490 ssize_t n; 2491 2492 /* 2493 * If no handle is open yet, reads from virtual addresses are 2494 * allowed to succeed but return zero-filled memory. 2495 */ 2496 if (t->t_pshandle == NULL) { 2497 bzero(buf, nbytes); 2498 return (nbytes); 2499 } 2500 2501 if ((n = Pread(t->t_pshandle, buf, nbytes, addr)) <= 0) 2502 return (set_errno(EMDB_NOMAP)); 2503 2504 return (n); 2505 } 2506 2507 static ssize_t 2508 pt_vwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr) 2509 { 2510 ssize_t n; 2511 2512 /* 2513 * If no handle is open yet, writes to virtual addresses are 2514 * allowed to succeed but do not actually modify anything. 2515 */ 2516 if (t->t_pshandle == NULL) 2517 return (nbytes); 2518 2519 n = Pwrite(t->t_pshandle, buf, nbytes, addr); 2520 2521 if (n == -1 && errno == EIO) 2522 return (set_errno(EMDB_NOMAP)); 2523 2524 return (n); 2525 } 2526 2527 static ssize_t 2528 pt_fread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr) 2529 { 2530 pt_data_t *pt = t->t_data; 2531 2532 if (pt->p_file != NULL) { 2533 return (mdb_gelf_rw(pt->p_file, buf, nbytes, addr, 2534 IOPF_READ(pt->p_fio), GIO_READ)); 2535 } 2536 2537 bzero(buf, nbytes); 2538 return (nbytes); 2539 } 2540 2541 static ssize_t 2542 pt_fwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr) 2543 { 2544 pt_data_t *pt = t->t_data; 2545 2546 if (pt->p_file != NULL) { 2547 return (mdb_gelf_rw(pt->p_file, (void *)buf, nbytes, addr, 2548 IOPF_WRITE(pt->p_fio), GIO_WRITE)); 2549 } 2550 2551 return (nbytes); 2552 } 2553 2554 static const char * 2555 pt_resolve_lmid(const char *object, Lmid_t *lmidp) 2556 { 2557 Lmid_t lmid = PR_LMID_EVERY; 2558 const char *p; 2559 2560 if (object == MDB_TGT_OBJ_EVERY || object == MDB_TGT_OBJ_EXEC) 2561 lmid = LM_ID_BASE; /* restrict scope to a.out's link map */ 2562 else if (object != MDB_TGT_OBJ_RTLD && strncmp(object, "LM", 2) == 0 && 2563 (p = strchr(object, '`')) != NULL) { 2564 object += 2; /* skip past initial "LM" prefix */ 2565 lmid = strntoul(object, (size_t)(p - object), mdb.m_radix); 2566 object = p + 1; /* skip past link map specifier */ 2567 } 2568 2569 *lmidp = lmid; 2570 return (object); 2571 } 2572 2573 static int 2574 tlsbase(mdb_tgt_t *t, mdb_tgt_tid_t tid, Lmid_t lmid, const char *object, 2575 psaddr_t *basep) 2576 { 2577 pt_data_t *pt = t->t_data; 2578 const rd_loadobj_t *loadobjp; 2579 td_thrhandle_t th; 2580 td_err_e err; 2581 2582 if (object == MDB_TGT_OBJ_EVERY) 2583 return (set_errno(EINVAL)); 2584 2585 if (t->t_pshandle == NULL || Pstate(t->t_pshandle) == PS_IDLE) 2586 return (set_errno(EMDB_NOPROC)); 2587 2588 if (pt->p_tdb_ops == NULL) 2589 return (set_errno(EMDB_TDB)); 2590 2591 err = pt->p_tdb_ops->td_ta_map_id2thr(pt->p_ptl_hdl, tid, &th); 2592 if (err != TD_OK) 2593 return (set_errno(tdb_to_errno(err))); 2594 2595 /* 2596 * If this fails, rtld_db has failed to initialize properly. 2597 */ 2598 if ((loadobjp = Plmid_to_loadobj(t->t_pshandle, lmid, object)) == NULL) 2599 return (set_errno(EMDB_NORTLD)); 2600 2601 /* 2602 * This will fail if the TLS block has not been allocated for the 2603 * object that contains the TLS symbol in question. 2604 */ 2605 err = pt->p_tdb_ops->td_thr_tlsbase(&th, loadobjp->rl_tlsmodid, basep); 2606 if (err != TD_OK) 2607 return (set_errno(tdb_to_errno(err))); 2608 2609 return (0); 2610 } 2611 2612 typedef struct { 2613 mdb_tgt_t *pl_tgt; 2614 const char *pl_name; 2615 Lmid_t pl_lmid; 2616 GElf_Sym *pl_symp; 2617 mdb_syminfo_t *pl_sip; 2618 mdb_tgt_tid_t pl_tid; 2619 mdb_bool_t pl_found; 2620 } pt_lookup_t; 2621 2622 /*ARGSUSED*/ 2623 static int 2624 pt_lookup_cb(void *data, const prmap_t *pmp, const char *object) 2625 { 2626 pt_lookup_t *plp = data; 2627 struct ps_prochandle *P = plp->pl_tgt->t_pshandle; 2628 prsyminfo_t si; 2629 GElf_Sym sym; 2630 2631 if (Pxlookup_by_name(P, plp->pl_lmid, object, plp->pl_name, &sym, 2632 &si) != 0) 2633 return (0); 2634 2635 /* 2636 * If we encounter a match with SHN_UNDEF, keep looking for a 2637 * better match. Return the first match with SHN_UNDEF set if no 2638 * better match is found. 2639 */ 2640 if (sym.st_shndx == SHN_UNDEF) { 2641 if (!plp->pl_found) { 2642 plp->pl_found = TRUE; 2643 *plp->pl_symp = sym; 2644 plp->pl_sip->sym_table = si.prs_table; 2645 plp->pl_sip->sym_id = si.prs_id; 2646 } 2647 2648 return (0); 2649 } 2650 2651 /* 2652 * Note that if the symbol's st_shndx is SHN_UNDEF we don't have the 2653 * TLS offset anyway, so adding in the tlsbase would be worthless. 2654 */ 2655 if (GELF_ST_TYPE(sym.st_info) == STT_TLS && 2656 plp->pl_tid != (mdb_tgt_tid_t)-1) { 2657 psaddr_t base; 2658 2659 if (tlsbase(plp->pl_tgt, plp->pl_tid, plp->pl_lmid, object, 2660 &base) != 0) 2661 return (-1); /* errno is set for us */ 2662 2663 sym.st_value += base; 2664 } 2665 2666 plp->pl_found = TRUE; 2667 *plp->pl_symp = sym; 2668 plp->pl_sip->sym_table = si.prs_table; 2669 plp->pl_sip->sym_id = si.prs_id; 2670 2671 return (1); 2672 } 2673 2674 /* 2675 * Lookup the symbol with a thread context so that we can adjust TLS symbols 2676 * to get the values as they would appear in the context of the given thread. 2677 */ 2678 static int 2679 pt_lookup_by_name_thr(mdb_tgt_t *t, const char *object, 2680 const char *name, GElf_Sym *symp, mdb_syminfo_t *sip, mdb_tgt_tid_t tid) 2681 { 2682 struct ps_prochandle *P = t->t_pshandle; 2683 pt_data_t *pt = t->t_data; 2684 Lmid_t lmid; 2685 uint_t i; 2686 const rd_loadobj_t *aout_lop; 2687 2688 object = pt_resolve_lmid(object, &lmid); 2689 2690 if (P != NULL) { 2691 pt_lookup_t pl; 2692 2693 pl.pl_tgt = t; 2694 pl.pl_name = name; 2695 pl.pl_lmid = lmid; 2696 pl.pl_symp = symp; 2697 pl.pl_sip = sip; 2698 pl.pl_tid = tid; 2699 pl.pl_found = FALSE; 2700 2701 if (object == MDB_TGT_OBJ_EVERY) { 2702 if (Pobject_iter_resolved(P, pt_lookup_cb, &pl) == -1) 2703 return (-1); /* errno is set for us */ 2704 if ((!pl.pl_found) && 2705 (Pobject_iter(P, pt_lookup_cb, &pl) == -1)) 2706 return (-1); /* errno is set for us */ 2707 } else { 2708 const prmap_t *pmp; 2709 2710 /* 2711 * This can fail either due to an invalid lmid or 2712 * an invalid object. To determine which is 2713 * faulty, we test the lmid against known valid 2714 * lmids and then see if using a wild-card lmid 2715 * improves ths situation. 2716 */ 2717 if ((pmp = Plmid_to_map(P, lmid, object)) == NULL) { 2718 if (lmid != PR_LMID_EVERY && 2719 lmid != LM_ID_BASE && 2720 lmid != LM_ID_LDSO && 2721 Plmid_to_map(P, PR_LMID_EVERY, object) 2722 != NULL) 2723 return (set_errno(EMDB_NOLMID)); 2724 else 2725 return (set_errno(EMDB_NOOBJ)); 2726 } 2727 2728 if (pt_lookup_cb(&pl, pmp, object) == -1) 2729 return (-1); /* errno is set for us */ 2730 } 2731 2732 if (pl.pl_found) 2733 return (0); 2734 } 2735 2736 /* 2737 * If libproc doesn't have the symbols for rtld, we're cooked -- 2738 * mdb doesn't have those symbols either. 2739 */ 2740 if (object == MDB_TGT_OBJ_RTLD) 2741 return (set_errno(EMDB_NOSYM)); 2742 2743 if (object != MDB_TGT_OBJ_EXEC && object != MDB_TGT_OBJ_EVERY) { 2744 int status = mdb_gelf_symtab_lookup_by_file(pt->p_symtab, 2745 object, name, symp, &sip->sym_id); 2746 2747 if (status != 0) { 2748 if (P != NULL && 2749 Plmid_to_map(P, PR_LMID_EVERY, object) != NULL) 2750 return (set_errno(EMDB_NOSYM)); 2751 else 2752 return (-1); /* errno set from lookup_by_file */ 2753 } 2754 2755 goto found; 2756 } 2757 2758 if (mdb_gelf_symtab_lookup_by_name(pt->p_symtab, name, symp, &i) == 0) { 2759 sip->sym_table = MDB_TGT_SYMTAB; 2760 sip->sym_id = i; 2761 goto local_found; 2762 } 2763 2764 if (mdb_gelf_symtab_lookup_by_name(pt->p_dynsym, name, symp, &i) == 0) { 2765 sip->sym_table = MDB_TGT_DYNSYM; 2766 sip->sym_id = i; 2767 goto local_found; 2768 } 2769 2770 return (set_errno(EMDB_NOSYM)); 2771 2772 local_found: 2773 if (pt->p_file != NULL && 2774 pt->p_file->gf_ehdr.e_type == ET_DYN && 2775 P != NULL && 2776 (aout_lop = Pname_to_loadobj(P, PR_OBJ_EXEC)) != NULL) 2777 symp->st_value += aout_lop->rl_base; 2778 2779 found: 2780 /* 2781 * If the symbol has type TLS, libproc should have found the symbol 2782 * if it exists and has been allocated. 2783 */ 2784 if (GELF_ST_TYPE(symp->st_info) == STT_TLS) 2785 return (set_errno(EMDB_TLS)); 2786 2787 return (0); 2788 } 2789 2790 static int 2791 pt_lookup_by_name(mdb_tgt_t *t, const char *object, 2792 const char *name, GElf_Sym *symp, mdb_syminfo_t *sip) 2793 { 2794 return (pt_lookup_by_name_thr(t, object, name, symp, sip, PTL_TID(t))); 2795 } 2796 2797 static int 2798 pt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags, 2799 char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip) 2800 { 2801 struct ps_prochandle *P = t->t_pshandle; 2802 pt_data_t *pt = t->t_data; 2803 rd_plt_info_t rpi = { 0 }; 2804 2805 const char *pltsym; 2806 int rv, match, i; 2807 2808 mdb_gelf_symtab_t *gsts[3]; /* mdb.m_prsym, .symtab, .dynsym */ 2809 int gstc = 0; /* number of valid gsts[] entries */ 2810 2811 mdb_gelf_symtab_t *gst = NULL; /* set if 'sym' is from a gst */ 2812 const prmap_t *pmp = NULL; /* set if 'sym' is from libproc */ 2813 GElf_Sym sym; /* best symbol found so far if !exact */ 2814 prsyminfo_t si; 2815 2816 /* 2817 * Fill in our array of symbol table pointers with the private symbol 2818 * table, static symbol table, and dynamic symbol table if applicable. 2819 * These are done in order of precedence so that if we match and 2820 * MDB_TGT_SYM_EXACT is set, we need not look any further. 2821 */ 2822 if (mdb.m_prsym != NULL) 2823 gsts[gstc++] = mdb.m_prsym; 2824 if (P == NULL && pt->p_symtab != NULL) 2825 gsts[gstc++] = pt->p_symtab; 2826 if (P == NULL && pt->p_dynsym != NULL) 2827 gsts[gstc++] = pt->p_dynsym; 2828 2829 /* 2830 * Loop through our array attempting to match the address. If we match 2831 * and we're in exact mode, we're done. Otherwise save the symbol in 2832 * the local sym variable if it is closer than our previous match. 2833 * We explicitly watch for zero-valued symbols since DevPro insists 2834 * on storing __fsr_init_value's value as the symbol value instead 2835 * of storing it in a constant integer. 2836 */ 2837 for (i = 0; i < gstc; i++) { 2838 if (mdb_gelf_symtab_lookup_by_addr(gsts[i], addr, flags, buf, 2839 nbytes, symp, &sip->sym_id) != 0 || symp->st_value == 0) 2840 continue; 2841 2842 if (flags & MDB_TGT_SYM_EXACT) { 2843 gst = gsts[i]; 2844 goto found; 2845 } 2846 2847 if (gst == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) { 2848 gst = gsts[i]; 2849 sym = *symp; 2850 } 2851 } 2852 2853 /* 2854 * If we have no libproc handle active, we're done: fail if gst is 2855 * NULL; otherwise copy out our best symbol and skip to the end. 2856 * We also skip to found if gst is the private symbol table: we 2857 * want this to always take precedence over PLT re-vectoring. 2858 */ 2859 if (P == NULL || (gst != NULL && gst == mdb.m_prsym)) { 2860 if (gst == NULL) 2861 return (set_errno(EMDB_NOSYMADDR)); 2862 *symp = sym; 2863 goto found; 2864 } 2865 2866 /* 2867 * Check to see if the address is in a PLT: if it is, use librtld_db to 2868 * attempt to resolve the PLT entry. If the entry is bound, reset addr 2869 * to the bound address, add a special prefix to the caller's buf, 2870 * forget our previous guess, and then continue using the new addr. 2871 * If the entry is not bound, copy the corresponding symbol name into 2872 * buf and return a fake symbol for the given address. 2873 */ 2874 if ((pltsym = Ppltdest(P, addr)) != NULL) { 2875 const rd_loadobj_t *rlp; 2876 rd_agent_t *rap; 2877 2878 if ((rap = Prd_agent(P)) != NULL && 2879 (rlp = Paddr_to_loadobj(P, addr)) != NULL && 2880 rd_plt_resolution(rap, addr, Pstatus(P)->pr_lwp.pr_lwpid, 2881 rlp->rl_plt_base, &rpi) == RD_OK && 2882 (rpi.pi_flags & RD_FLG_PI_PLTBOUND)) { 2883 size_t n; 2884 n = mdb_iob_snprintf(buf, nbytes, "PLT="); 2885 addr = rpi.pi_baddr; 2886 if (n > nbytes) { 2887 buf += nbytes; 2888 nbytes = 0; 2889 } else { 2890 buf += n; 2891 nbytes -= n; 2892 } 2893 gst = NULL; 2894 } else { 2895 (void) mdb_iob_snprintf(buf, nbytes, "PLT:%s", pltsym); 2896 bzero(symp, sizeof (GElf_Sym)); 2897 symp->st_value = addr; 2898 symp->st_info = GELF_ST_INFO(STB_GLOBAL, STT_FUNC); 2899 return (0); 2900 } 2901 } 2902 2903 /* 2904 * Ask libproc to convert the address to the closest symbol for us. 2905 * Once we get the closest symbol, we perform the EXACT match or 2906 * smart-mode or absolute distance check ourself: 2907 */ 2908 if (PT_LIBPROC_RESOLVE(P)) { 2909 rv = Pxlookup_by_addr_resolved(P, addr, buf, nbytes, 2910 symp, &si); 2911 } else { 2912 rv = Pxlookup_by_addr(P, addr, buf, nbytes, 2913 symp, &si); 2914 } 2915 if ((rv == 0) && (symp->st_value != 0) && 2916 (gst == NULL || mdb_gelf_sym_closer(symp, &sym, addr))) { 2917 2918 if (flags & MDB_TGT_SYM_EXACT) 2919 match = (addr == symp->st_value); 2920 else if (mdb.m_symdist == 0) 2921 match = (addr >= symp->st_value && 2922 addr < symp->st_value + symp->st_size); 2923 else 2924 match = (addr >= symp->st_value && 2925 addr < symp->st_value + mdb.m_symdist); 2926 2927 if (match) { 2928 pmp = Paddr_to_map(P, addr); 2929 gst = NULL; 2930 sip->sym_table = si.prs_table; 2931 sip->sym_id = si.prs_id; 2932 goto found; 2933 } 2934 } 2935 2936 /* 2937 * If we get here, Plookup_by_addr has failed us. If we have no 2938 * previous best symbol (gst == NULL), we've failed completely. 2939 * Otherwise we copy out that symbol and continue on to 'found'. 2940 */ 2941 if (gst == NULL) 2942 return (set_errno(EMDB_NOSYMADDR)); 2943 *symp = sym; 2944 found: 2945 /* 2946 * Once we've found something, copy the final name into the caller's 2947 * buffer and prefix it with the mapping name if appropriate. 2948 */ 2949 if (pmp != NULL && pmp != Pname_to_map(P, PR_OBJ_EXEC)) { 2950 const char *prefix = pmp->pr_mapname; 2951 Lmid_t lmid; 2952 2953 if (PT_LIBPROC_RESOLVE(P)) { 2954 if (Pobjname_resolved(P, addr, pt->p_objname, 2955 MDB_TGT_MAPSZ)) 2956 prefix = pt->p_objname; 2957 } else { 2958 if (Pobjname(P, addr, pt->p_objname, MDB_TGT_MAPSZ)) 2959 prefix = pt->p_objname; 2960 } 2961 2962 if (buf != NULL && nbytes > 1) { 2963 (void) strncpy(pt->p_symname, buf, MDB_TGT_SYM_NAMLEN); 2964 pt->p_symname[MDB_TGT_SYM_NAMLEN - 1] = '\0'; 2965 } else { 2966 pt->p_symname[0] = '\0'; 2967 } 2968 2969 if (prefix == pt->p_objname && Plmid(P, addr, &lmid) == 0 && ( 2970 (lmid != LM_ID_BASE && lmid != LM_ID_LDSO) || 2971 (mdb.m_flags & MDB_FL_SHOWLMID))) { 2972 (void) mdb_iob_snprintf(buf, nbytes, "LM%lr`%s`%s", 2973 lmid, strbasename(prefix), pt->p_symname); 2974 } else { 2975 (void) mdb_iob_snprintf(buf, nbytes, "%s`%s", 2976 strbasename(prefix), pt->p_symname); 2977 } 2978 2979 } else if (gst != NULL && buf != NULL && nbytes > 0) { 2980 (void) strncpy(buf, mdb_gelf_sym_name(gst, symp), nbytes); 2981 buf[nbytes - 1] = '\0'; 2982 } 2983 2984 return (0); 2985 } 2986 2987 2988 static int 2989 pt_symbol_iter_cb(void *arg, const GElf_Sym *sym, const char *name, 2990 const prsyminfo_t *sip) 2991 { 2992 pt_symarg_t *psp = arg; 2993 2994 psp->psym_info.sym_id = sip->prs_id; 2995 2996 return (psp->psym_func(psp->psym_private, sym, name, &psp->psym_info, 2997 psp->psym_obj)); 2998 } 2999 3000 static int 3001 pt_objsym_iter(void *arg, const prmap_t *pmp, const char *object) 3002 { 3003 Lmid_t lmid = PR_LMID_EVERY; 3004 pt_symarg_t *psp = arg; 3005 3006 psp->psym_obj = object; 3007 3008 (void) Plmid(psp->psym_targ->t_pshandle, pmp->pr_vaddr, &lmid); 3009 (void) Pxsymbol_iter(psp->psym_targ->t_pshandle, lmid, object, 3010 psp->psym_which, psp->psym_type, pt_symbol_iter_cb, arg); 3011 3012 return (0); 3013 } 3014 3015 static int 3016 pt_symbol_filt(void *arg, const GElf_Sym *sym, const char *name, uint_t id) 3017 { 3018 pt_symarg_t *psp = arg; 3019 3020 if (mdb_tgt_sym_match(sym, psp->psym_type)) { 3021 psp->psym_info.sym_id = id; 3022 return (psp->psym_func(psp->psym_private, sym, name, 3023 &psp->psym_info, psp->psym_obj)); 3024 } 3025 3026 return (0); 3027 } 3028 3029 static int 3030 pt_symbol_iter(mdb_tgt_t *t, const char *object, uint_t which, 3031 uint_t type, mdb_tgt_sym_f *func, void *private) 3032 { 3033 pt_data_t *pt = t->t_data; 3034 mdb_gelf_symtab_t *gst; 3035 pt_symarg_t ps; 3036 Lmid_t lmid; 3037 3038 object = pt_resolve_lmid(object, &lmid); 3039 3040 ps.psym_targ = t; 3041 ps.psym_which = which; 3042 ps.psym_type = type; 3043 ps.psym_func = func; 3044 ps.psym_private = private; 3045 ps.psym_obj = object; 3046 3047 if (t->t_pshandle != NULL) { 3048 if (object != MDB_TGT_OBJ_EVERY) { 3049 if (Plmid_to_map(t->t_pshandle, lmid, object) == NULL) 3050 return (set_errno(EMDB_NOOBJ)); 3051 (void) Pxsymbol_iter(t->t_pshandle, lmid, object, 3052 which, type, pt_symbol_iter_cb, &ps); 3053 return (0); 3054 } else if (Prd_agent(t->t_pshandle) != NULL) { 3055 if (PT_LIBPROC_RESOLVE(t->t_pshandle)) { 3056 (void) Pobject_iter_resolved(t->t_pshandle, 3057 pt_objsym_iter, &ps); 3058 } else { 3059 (void) Pobject_iter(t->t_pshandle, 3060 pt_objsym_iter, &ps); 3061 } 3062 return (0); 3063 } 3064 } 3065 3066 if (lmid != LM_ID_BASE && lmid != PR_LMID_EVERY) 3067 return (set_errno(EMDB_NOLMID)); 3068 3069 if (object != MDB_TGT_OBJ_EXEC && object != MDB_TGT_OBJ_EVERY && 3070 pt->p_fio != NULL && 3071 strcmp(object, IOP_NAME(pt->p_fio)) != 0) 3072 return (set_errno(EMDB_NOOBJ)); 3073 3074 if (which == MDB_TGT_SYMTAB) 3075 gst = pt->p_symtab; 3076 else 3077 gst = pt->p_dynsym; 3078 3079 if (gst != NULL) { 3080 ps.psym_info.sym_table = gst->gst_tabid; 3081 mdb_gelf_symtab_iter(gst, pt_symbol_filt, &ps); 3082 } 3083 3084 return (0); 3085 } 3086 3087 static const mdb_map_t * 3088 pt_prmap_to_mdbmap(mdb_tgt_t *t, const prmap_t *prp, mdb_map_t *mp) 3089 { 3090 struct ps_prochandle *P = t->t_pshandle; 3091 char *rv, name[MAXPATHLEN]; 3092 Lmid_t lmid; 3093 3094 if (PT_LIBPROC_RESOLVE(P)) { 3095 rv = Pobjname_resolved(P, prp->pr_vaddr, name, sizeof (name)); 3096 } else { 3097 rv = Pobjname(P, prp->pr_vaddr, name, sizeof (name)); 3098 } 3099 3100 if (rv != NULL) { 3101 if (Plmid(P, prp->pr_vaddr, &lmid) == 0 && ( 3102 (lmid != LM_ID_BASE && lmid != LM_ID_LDSO) || 3103 (mdb.m_flags & MDB_FL_SHOWLMID))) { 3104 (void) mdb_iob_snprintf(mp->map_name, MDB_TGT_MAPSZ, 3105 "LM%lr`%s", lmid, name); 3106 } else { 3107 (void) strncpy(mp->map_name, name, MDB_TGT_MAPSZ - 1); 3108 mp->map_name[MDB_TGT_MAPSZ - 1] = '\0'; 3109 } 3110 } else { 3111 (void) strncpy(mp->map_name, prp->pr_mapname, 3112 MDB_TGT_MAPSZ - 1); 3113 mp->map_name[MDB_TGT_MAPSZ - 1] = '\0'; 3114 } 3115 3116 mp->map_base = prp->pr_vaddr; 3117 mp->map_size = prp->pr_size; 3118 mp->map_flags = 0; 3119 3120 if (prp->pr_mflags & MA_READ) 3121 mp->map_flags |= MDB_TGT_MAP_R; 3122 if (prp->pr_mflags & MA_WRITE) 3123 mp->map_flags |= MDB_TGT_MAP_W; 3124 if (prp->pr_mflags & MA_EXEC) 3125 mp->map_flags |= MDB_TGT_MAP_X; 3126 3127 if (prp->pr_mflags & MA_SHM) 3128 mp->map_flags |= MDB_TGT_MAP_SHMEM; 3129 if (prp->pr_mflags & MA_BREAK) 3130 mp->map_flags |= MDB_TGT_MAP_HEAP; 3131 if (prp->pr_mflags & MA_STACK) 3132 mp->map_flags |= MDB_TGT_MAP_STACK; 3133 if (prp->pr_mflags & MA_ANON) 3134 mp->map_flags |= MDB_TGT_MAP_ANON; 3135 3136 return (mp); 3137 } 3138 3139 /*ARGSUSED*/ 3140 static int 3141 pt_map_apply(void *arg, const prmap_t *prp, const char *name) 3142 { 3143 pt_maparg_t *pmp = arg; 3144 mdb_map_t map; 3145 3146 return (pmp->pmap_func(pmp->pmap_private, 3147 pt_prmap_to_mdbmap(pmp->pmap_targ, prp, &map), map.map_name)); 3148 } 3149 3150 static int 3151 pt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 3152 { 3153 if (t->t_pshandle != NULL) { 3154 pt_maparg_t pm; 3155 3156 pm.pmap_targ = t; 3157 pm.pmap_func = func; 3158 pm.pmap_private = private; 3159 3160 if (PT_LIBPROC_RESOLVE(t->t_pshandle)) { 3161 (void) Pmapping_iter_resolved(t->t_pshandle, 3162 pt_map_apply, &pm); 3163 } else { 3164 (void) Pmapping_iter(t->t_pshandle, 3165 pt_map_apply, &pm); 3166 } 3167 return (0); 3168 } 3169 3170 return (set_errno(EMDB_NOPROC)); 3171 } 3172 3173 static int 3174 pt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 3175 { 3176 pt_data_t *pt = t->t_data; 3177 3178 /* 3179 * If we have a libproc handle, we can just call Pobject_iter to 3180 * iterate over its list of load object information. 3181 */ 3182 if (t->t_pshandle != NULL) { 3183 pt_maparg_t pm; 3184 3185 pm.pmap_targ = t; 3186 pm.pmap_func = func; 3187 pm.pmap_private = private; 3188 3189 if (PT_LIBPROC_RESOLVE(t->t_pshandle)) { 3190 (void) Pobject_iter_resolved(t->t_pshandle, 3191 pt_map_apply, &pm); 3192 } else { 3193 (void) Pobject_iter(t->t_pshandle, 3194 pt_map_apply, &pm); 3195 } 3196 return (0); 3197 } 3198 3199 /* 3200 * If we're examining an executable or other ELF file but we have no 3201 * libproc handle, fake up some information based on DT_NEEDED entries. 3202 */ 3203 if (pt->p_dynsym != NULL && pt->p_file->gf_dyns != NULL && 3204 pt->p_fio != NULL) { 3205 mdb_gelf_sect_t *gsp = pt->p_dynsym->gst_ssect; 3206 GElf_Dyn *dynp = pt->p_file->gf_dyns; 3207 mdb_map_t *mp = &pt->p_map; 3208 const char *s = IOP_NAME(pt->p_fio); 3209 size_t i; 3210 3211 (void) strncpy(mp->map_name, s, MDB_TGT_MAPSZ); 3212 mp->map_name[MDB_TGT_MAPSZ - 1] = '\0'; 3213 mp->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_X; 3214 mp->map_base = 0; 3215 mp->map_size = 0; 3216 3217 if (func(private, mp, s) != 0) 3218 return (0); 3219 3220 for (i = 0; i < pt->p_file->gf_ndyns; i++, dynp++) { 3221 if (dynp->d_tag == DT_NEEDED) { 3222 s = (char *)gsp->gs_data + dynp->d_un.d_val; 3223 (void) strncpy(mp->map_name, s, MDB_TGT_MAPSZ); 3224 mp->map_name[MDB_TGT_MAPSZ - 1] = '\0'; 3225 if (func(private, mp, s) != 0) 3226 return (0); 3227 } 3228 } 3229 3230 return (0); 3231 } 3232 3233 return (set_errno(EMDB_NOPROC)); 3234 } 3235 3236 static const mdb_map_t * 3237 pt_addr_to_map(mdb_tgt_t *t, uintptr_t addr) 3238 { 3239 pt_data_t *pt = t->t_data; 3240 const prmap_t *pmp; 3241 3242 if (t->t_pshandle == NULL) { 3243 (void) set_errno(EMDB_NOPROC); 3244 return (NULL); 3245 } 3246 3247 if ((pmp = Paddr_to_map(t->t_pshandle, addr)) == NULL) { 3248 (void) set_errno(EMDB_NOMAP); 3249 return (NULL); 3250 } 3251 3252 return (pt_prmap_to_mdbmap(t, pmp, &pt->p_map)); 3253 } 3254 3255 static const mdb_map_t * 3256 pt_name_to_map(mdb_tgt_t *t, const char *object) 3257 { 3258 pt_data_t *pt = t->t_data; 3259 const prmap_t *pmp; 3260 Lmid_t lmid; 3261 3262 if (t->t_pshandle == NULL) { 3263 (void) set_errno(EMDB_NOPROC); 3264 return (NULL); 3265 } 3266 3267 object = pt_resolve_lmid(object, &lmid); 3268 3269 if ((pmp = Plmid_to_map(t->t_pshandle, lmid, object)) == NULL) { 3270 (void) set_errno(EMDB_NOOBJ); 3271 return (NULL); 3272 } 3273 3274 return (pt_prmap_to_mdbmap(t, pmp, &pt->p_map)); 3275 } 3276 3277 static ctf_file_t * 3278 pt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr) 3279 { 3280 ctf_file_t *ret; 3281 3282 if (t->t_pshandle == NULL) { 3283 (void) set_errno(EMDB_NOPROC); 3284 return (NULL); 3285 } 3286 3287 if ((ret = Paddr_to_ctf(t->t_pshandle, addr)) == NULL) { 3288 (void) set_errno(EMDB_NOOBJ); 3289 return (NULL); 3290 } 3291 3292 return (ret); 3293 } 3294 3295 static ctf_file_t * 3296 pt_name_to_ctf(mdb_tgt_t *t, const char *name) 3297 { 3298 ctf_file_t *ret; 3299 3300 if (t->t_pshandle == NULL) { 3301 (void) set_errno(EMDB_NOPROC); 3302 return (NULL); 3303 } 3304 3305 if ((ret = Pname_to_ctf(t->t_pshandle, name)) == NULL) { 3306 (void) set_errno(EMDB_NOOBJ); 3307 return (NULL); 3308 } 3309 3310 return (ret); 3311 } 3312 3313 static int 3314 pt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 3315 { 3316 const pstatus_t *psp; 3317 prgregset_t gregs; 3318 int state; 3319 3320 bzero(tsp, sizeof (mdb_tgt_status_t)); 3321 3322 if (t->t_pshandle == NULL) { 3323 tsp->st_state = MDB_TGT_IDLE; 3324 return (0); 3325 } 3326 3327 switch (state = Pstate(t->t_pshandle)) { 3328 case PS_RUN: 3329 tsp->st_state = MDB_TGT_RUNNING; 3330 break; 3331 3332 case PS_STOP: 3333 tsp->st_state = MDB_TGT_STOPPED; 3334 psp = Pstatus(t->t_pshandle); 3335 3336 tsp->st_tid = PTL_TID(t); 3337 if (PTL_GETREGS(t, tsp->st_tid, gregs) == 0) 3338 tsp->st_pc = gregs[R_PC]; 3339 3340 if (psp->pr_flags & PR_ISTOP) 3341 tsp->st_flags |= MDB_TGT_ISTOP; 3342 if (psp->pr_flags & PR_DSTOP) 3343 tsp->st_flags |= MDB_TGT_DSTOP; 3344 3345 break; 3346 3347 case PS_LOST: 3348 tsp->st_state = MDB_TGT_LOST; 3349 break; 3350 case PS_UNDEAD: 3351 tsp->st_state = MDB_TGT_UNDEAD; 3352 break; 3353 case PS_DEAD: 3354 tsp->st_state = MDB_TGT_DEAD; 3355 break; 3356 case PS_IDLE: 3357 tsp->st_state = MDB_TGT_IDLE; 3358 break; 3359 default: 3360 fail("unknown libproc state (%d)\n", state); 3361 } 3362 3363 if (t->t_flags & MDB_TGT_F_BUSY) 3364 tsp->st_flags |= MDB_TGT_BUSY; 3365 3366 return (0); 3367 } 3368 3369 static void 3370 pt_dupfd(const char *file, int oflags, mode_t mode, int dfd) 3371 { 3372 int fd; 3373 3374 if ((fd = open(file, oflags, mode)) >= 0) { 3375 (void) fcntl(fd, F_DUP2FD, dfd); 3376 (void) close(fd); 3377 } else 3378 warn("failed to open %s as descriptor %d", file, dfd); 3379 } 3380 3381 /* 3382 * The Pcreate_callback() function interposes on the default, empty libproc 3383 * definition. It will be called following a fork of a new child process by 3384 * Pcreate() below, but before the exec of the new process image. We use this 3385 * callback to optionally redirect stdin and stdout and reset the dispositions 3386 * of SIGPIPE and SIGQUIT from SIG_IGN back to SIG_DFL. 3387 */ 3388 /*ARGSUSED*/ 3389 void 3390 Pcreate_callback(struct ps_prochandle *P) 3391 { 3392 pt_data_t *pt = mdb.m_target->t_data; 3393 3394 if (pt->p_stdin != NULL) 3395 pt_dupfd(pt->p_stdin, O_RDWR, 0, STDIN_FILENO); 3396 if (pt->p_stdout != NULL) 3397 pt_dupfd(pt->p_stdout, O_CREAT | O_WRONLY, 0666, STDOUT_FILENO); 3398 3399 (void) mdb_signal_sethandler(SIGPIPE, SIG_DFL, NULL); 3400 (void) mdb_signal_sethandler(SIGQUIT, SIG_DFL, NULL); 3401 } 3402 3403 static int 3404 pt_run(mdb_tgt_t *t, int argc, const mdb_arg_t *argv) 3405 { 3406 pt_data_t *pt = t->t_data; 3407 struct ps_prochandle *P; 3408 char execname[MAXPATHLEN]; 3409 const char **pargv; 3410 int pargc = 0; 3411 int i, perr; 3412 char **penv; 3413 mdb_var_t *v; 3414 3415 if (pt->p_aout_fio == NULL) { 3416 warn("run requires executable to be specified on " 3417 "command-line\n"); 3418 return (set_errno(EMDB_TGT)); 3419 } 3420 3421 pargv = mdb_alloc(sizeof (char *) * (argc + 2), UM_SLEEP); 3422 pargv[pargc++] = strbasename(IOP_NAME(pt->p_aout_fio)); 3423 3424 for (i = 0; i < argc; i++) { 3425 if (argv[i].a_type != MDB_TYPE_STRING) { 3426 mdb_free(pargv, sizeof (char *) * (argc + 2)); 3427 return (set_errno(EINVAL)); 3428 } 3429 if (argv[i].a_un.a_str[0] == '<') 3430 pt->p_stdin = argv[i].a_un.a_str + 1; 3431 else if (argv[i].a_un.a_str[0] == '>') 3432 pt->p_stdout = argv[i].a_un.a_str + 1; 3433 else 3434 pargv[pargc++] = argv[i].a_un.a_str; 3435 } 3436 pargv[pargc] = NULL; 3437 3438 /* 3439 * Since Pcreate() uses execvp() and "." may not be present in $PATH, 3440 * we must manually prepend "./" when the executable is a simple name. 3441 */ 3442 if (strchr(IOP_NAME(pt->p_aout_fio), '/') == NULL) { 3443 (void) snprintf(execname, sizeof (execname), "./%s", 3444 IOP_NAME(pt->p_aout_fio)); 3445 } else { 3446 (void) snprintf(execname, sizeof (execname), "%s", 3447 IOP_NAME(pt->p_aout_fio)); 3448 } 3449 3450 penv = mdb_alloc((mdb_nv_size(&pt->p_env)+ 1) * sizeof (char *), 3451 UM_SLEEP); 3452 for (mdb_nv_rewind(&pt->p_env), i = 0; 3453 (v = mdb_nv_advance(&pt->p_env)) != NULL; i++) 3454 penv[i] = mdb_nv_get_cookie(v); 3455 penv[i] = NULL; 3456 3457 P = Pxcreate(execname, (char **)pargv, penv, &perr, NULL, 0); 3458 mdb_free(pargv, sizeof (char *) * (argc + 2)); 3459 pt->p_stdin = pt->p_stdout = NULL; 3460 3461 mdb_free(penv, i * sizeof (char *)); 3462 3463 if (P == NULL) { 3464 warn("failed to create process: %s\n", Pcreate_error(perr)); 3465 return (set_errno(EMDB_TGT)); 3466 } 3467 3468 if (t->t_pshandle != NULL) { 3469 pt_pre_detach(t, TRUE); 3470 if (t->t_pshandle != pt->p_idlehandle) 3471 Prelease(t->t_pshandle, pt->p_rflags); 3472 } 3473 3474 (void) Punsetflags(P, PR_RLC); /* make sure run-on-last-close is off */ 3475 (void) Psetflags(P, PR_KLC); /* kill on last close by debugger */ 3476 pt->p_rflags = PRELEASE_KILL; /* kill on debugger Prelease */ 3477 t->t_pshandle = P; 3478 3479 pt_post_attach(t); 3480 pt_activate_common(t); 3481 (void) mdb_tgt_status(t, &t->t_status); 3482 mdb.m_flags |= MDB_FL_VCREATE; 3483 3484 return (0); 3485 } 3486 3487 /* 3488 * Forward a signal to the victim process in order to force it to stop or die. 3489 * Refer to the comments above pt_setrun(), below, for more info. 3490 */ 3491 /*ARGSUSED*/ 3492 static void 3493 pt_sigfwd(int sig, siginfo_t *sip, ucontext_t *ucp, mdb_tgt_t *t) 3494 { 3495 struct ps_prochandle *P = t->t_pshandle; 3496 const lwpstatus_t *psp = &Pstatus(P)->pr_lwp; 3497 pid_t pid = Pstatus(P)->pr_pid; 3498 long ctl[2]; 3499 3500 if (getpgid(pid) != mdb.m_pgid) { 3501 mdb_dprintf(MDB_DBG_TGT, "fwd SIG#%d to %d\n", sig, (int)pid); 3502 (void) kill(pid, sig); 3503 } 3504 3505 if (Pwait(P, 1) == 0 && (psp->pr_flags & PR_STOPPED) && 3506 psp->pr_why == PR_JOBCONTROL && Pdstop(P) == 0) { 3507 /* 3508 * If we're job control stopped and our DSTOP is pending, the 3509 * victim will never see our signal, so undo the kill() and 3510 * then send SIGCONT the victim to kick it out of the job 3511 * control stop and force our DSTOP to take effect. 3512 */ 3513 if ((psp->pr_flags & PR_DSTOP) && 3514 prismember(&Pstatus(P)->pr_sigpend, sig)) { 3515 ctl[0] = PCUNKILL; 3516 ctl[1] = sig; 3517 (void) write(Pctlfd(P), ctl, sizeof (ctl)); 3518 } 3519 3520 mdb_dprintf(MDB_DBG_TGT, "fwd SIGCONT to %d\n", (int)pid); 3521 (void) kill(pid, SIGCONT); 3522 } 3523 } 3524 3525 /* 3526 * Common code for step and continue: if no victim process has been created, 3527 * call pt_run() to create one. Then set the victim running, clearing any 3528 * pending fault. One special case is that if the victim was previously 3529 * stopped on reception of SIGINT, we know that SIGINT was traced and the user 3530 * requested the victim to stop, so clear this signal before continuing. 3531 * For all other traced signals, the signal will be delivered on continue. 3532 * 3533 * Once the victim process is running, we wait for it to stop on an event of 3534 * interest. Although libproc provides the basic primitive to wait for the 3535 * victim, we must be careful in our handling of signals. We want to allow the 3536 * user to issue a SIGINT or SIGQUIT using the designated terminal control 3537 * character (typically ^C and ^\), and have these signals stop the target and 3538 * return control to the debugger if the signals are traced. There are three 3539 * cases to be considered in our implementation: 3540 * 3541 * (1) If the debugger and victim are in the same process group, both receive 3542 * the signal from the terminal driver. The debugger returns from Pwait() with 3543 * errno = EINTR, so we want to loop back and continue waiting until the victim 3544 * stops on receipt of its SIGINT or SIGQUIT. 3545 * 3546 * (2) If the debugger and victim are in different process groups, and the 3547 * victim is a member of the foreground process group, it will receive the 3548 * signal from the terminal driver and the debugger will not. As such, we 3549 * will remain blocked in Pwait() until the victim stops on its signal. 3550 * 3551 * (3) If the debugger and victim are in different process groups, and the 3552 * debugger is a member of the foreground process group, it will receive the 3553 * signal from the terminal driver, and the victim will not. The debugger 3554 * returns from Pwait() with errno = EINTR, so we need to forward the signal 3555 * to the victim process directly and then Pwait() again for it to stop. 3556 * 3557 * We can observe that all three cases are handled by simply calling Pwait() 3558 * repeatedly if it fails with EINTR, and forwarding SIGINT and SIGQUIT to 3559 * the victim if it is in a different process group, using pt_sigfwd() above. 3560 * 3561 * An additional complication is that the process may not be able to field 3562 * the signal if it is currently stopped by job control. In this case, we 3563 * also DSTOP the process, and then send it a SIGCONT to wake it up from 3564 * job control and force it to re-enter stop() under the control of /proc. 3565 * 3566 * Finally, we would like to allow the user to suspend the process using the 3567 * terminal suspend character (typically ^Z) if both are in the same session. 3568 * We again employ pt_sigfwd() to forward SIGTSTP to the victim, wait for it to 3569 * stop from job control, and then capture it using /proc. Once the process 3570 * has stopped, normal SIGTSTP processing is restored and the user can issue 3571 * another ^Z in order to suspend the debugger and return to the parent shell. 3572 */ 3573 static int 3574 pt_setrun(mdb_tgt_t *t, mdb_tgt_status_t *tsp, int flags) 3575 { 3576 struct ps_prochandle *P = t->t_pshandle; 3577 pt_data_t *pt = t->t_data; 3578 pid_t old_pgid = -1; 3579 3580 mdb_signal_f *intf, *quitf, *tstpf; 3581 const lwpstatus_t *psp; 3582 void *intd, *quitd, *tstpd; 3583 3584 int sig = pt->p_signal; 3585 int error = 0; 3586 int pgid = -1; 3587 3588 pt->p_signal = 0; /* clear pending signal */ 3589 3590 if (P == NULL && pt_run(t, 0, NULL) == -1) 3591 return (-1); /* errno is set for us */ 3592 3593 P = t->t_pshandle; 3594 psp = &Pstatus(P)->pr_lwp; 3595 3596 if (sig == 0 && psp->pr_why == PR_SIGNALLED && psp->pr_what == SIGINT) 3597 flags |= PRCSIG; /* clear pending SIGINT */ 3598 else 3599 flags |= PRCFAULT; /* clear any pending fault (e.g. BPT) */ 3600 3601 intf = mdb_signal_gethandler(SIGINT, &intd); 3602 quitf = mdb_signal_gethandler(SIGQUIT, &quitd); 3603 tstpf = mdb_signal_gethandler(SIGTSTP, &tstpd); 3604 3605 (void) mdb_signal_sethandler(SIGINT, (mdb_signal_f *)pt_sigfwd, t); 3606 (void) mdb_signal_sethandler(SIGQUIT, (mdb_signal_f *)pt_sigfwd, t); 3607 (void) mdb_signal_sethandler(SIGTSTP, (mdb_signal_f *)pt_sigfwd, t); 3608 3609 if (sig != 0 && Pstate(P) == PS_RUN && 3610 kill(Pstatus(P)->pr_pid, sig) == -1) { 3611 error = errno; 3612 goto out; 3613 } 3614 3615 /* 3616 * If we attached to a job stopped background process in the same 3617 * session, make its pgid the foreground process group before running 3618 * it. Ignore SIGTTOU while doing this to avoid being suspended. 3619 */ 3620 if (mdb.m_flags & MDB_FL_JOBCTL) { 3621 (void) mdb_signal_sethandler(SIGTTOU, SIG_IGN, NULL); 3622 (void) IOP_CTL(mdb.m_term, TIOCGPGRP, &old_pgid); 3623 (void) IOP_CTL(mdb.m_term, TIOCSPGRP, 3624 (void *)&Pstatus(P)->pr_pgid); 3625 (void) mdb_signal_sethandler(SIGTTOU, SIG_DFL, NULL); 3626 } 3627 3628 if (Pstate(P) != PS_RUN && Psetrun(P, sig, flags) == -1) { 3629 error = errno; 3630 goto out; 3631 } 3632 3633 /* 3634 * If the process is stopped on job control, resume its process group 3635 * by sending it a SIGCONT if we are in the same session. Otherwise 3636 * we have no choice but to wait for someone else to foreground it. 3637 */ 3638 if (psp->pr_why == PR_JOBCONTROL) { 3639 if (mdb.m_flags & MDB_FL_JOBCTL) 3640 (void) kill(-Pstatus(P)->pr_pgid, SIGCONT); 3641 else if (mdb.m_term != NULL) 3642 warn("process is still suspended by job control ...\n"); 3643 } 3644 3645 /* 3646 * Wait for the process to stop. As described above, we loop around if 3647 * we are interrupted (EINTR). If we lose control, attempt to re-open 3648 * the process, or call pt_exec() if that fails to handle a re-exec. 3649 * If the process dies (ENOENT) or Pwait() fails, break out of the loop. 3650 */ 3651 while (Pwait(P, 0) == -1) { 3652 if (errno != EINTR) { 3653 if (Pstate(P) == PS_LOST) { 3654 if (Preopen(P) == 0) 3655 continue; /* Pwait() again */ 3656 else 3657 pt_exec(t, 0, NULL); 3658 } else if (errno != ENOENT) 3659 warn("failed to wait for event"); 3660 break; 3661 } 3662 } 3663 3664 /* 3665 * If we changed the foreground process group, restore the old pgid 3666 * while ignoring SIGTTOU so we are not accidentally suspended. 3667 */ 3668 if (old_pgid != -1) { 3669 (void) mdb_signal_sethandler(SIGTTOU, SIG_IGN, NULL); 3670 (void) IOP_CTL(mdb.m_term, TIOCSPGRP, &pgid); 3671 (void) mdb_signal_sethandler(SIGTTOU, SIG_DFL, NULL); 3672 } 3673 3674 /* 3675 * If we're now stopped on exit from a successful exec, release any 3676 * vfork parents and clean out their address space before returning 3677 * to tgt_continue() and perturbing the list of armed event specs. 3678 * If we're stopped for any other reason, just update the mappings. 3679 */ 3680 switch (Pstate(P)) { 3681 case PS_STOP: 3682 if (psp->pr_why == PR_SYSEXIT && psp->pr_errno == 0 && 3683 psp->pr_what == SYS_execve) 3684 pt_release_parents(t); 3685 else 3686 Pupdate_maps(P); 3687 break; 3688 3689 case PS_UNDEAD: 3690 case PS_LOST: 3691 pt_release_parents(t); 3692 break; 3693 } 3694 3695 out: 3696 (void) mdb_signal_sethandler(SIGINT, intf, intd); 3697 (void) mdb_signal_sethandler(SIGQUIT, quitf, quitd); 3698 (void) mdb_signal_sethandler(SIGTSTP, tstpf, tstpd); 3699 (void) pt_status(t, tsp); 3700 3701 return (error ? set_errno(error) : 0); 3702 } 3703 3704 static int 3705 pt_step(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 3706 { 3707 return (pt_setrun(t, tsp, PRSTEP)); 3708 } 3709 3710 static int 3711 pt_continue(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 3712 { 3713 return (pt_setrun(t, tsp, 0)); 3714 } 3715 3716 static int 3717 pt_signal(mdb_tgt_t *t, int sig) 3718 { 3719 pt_data_t *pt = t->t_data; 3720 3721 if (sig > 0 && sig <= pt->p_maxsig) { 3722 pt->p_signal = sig; /* pending until next pt_setrun */ 3723 return (0); 3724 } 3725 3726 return (set_errno(EMDB_BADSIGNUM)); 3727 } 3728 3729 static int 3730 pt_sysenter_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 3731 { 3732 struct ps_prochandle *P = t->t_pshandle; 3733 3734 if (P != NULL && Pstate(P) < PS_LOST) { 3735 sep->se_data = args; /* data is raw system call number */ 3736 return (Psysentry(P, (intptr_t)args, TRUE) < 0 ? -1 : 0); 3737 } 3738 3739 return (set_errno(EMDB_NOPROC)); 3740 } 3741 3742 static void 3743 pt_sysenter_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 3744 { 3745 (void) Psysentry(t->t_pshandle, (intptr_t)sep->se_data, FALSE); 3746 } 3747 3748 /*ARGSUSED*/ 3749 static char * 3750 pt_sysenter_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 3751 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 3752 { 3753 char name[32]; 3754 int sysnum; 3755 3756 if (vep != NULL) 3757 sysnum = (intptr_t)vep->ve_args; 3758 else 3759 sysnum = (intptr_t)sep->se_data; 3760 3761 (void) proc_sysname(sysnum, name, sizeof (name)); 3762 (void) mdb_iob_snprintf(buf, nbytes, "stop on entry to %s", name); 3763 3764 return (buf); 3765 } 3766 3767 /*ARGSUSED*/ 3768 static int 3769 pt_sysenter_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 3770 { 3771 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 3772 int sysnum = (intptr_t)sep->se_data; 3773 3774 return (psp->pr_why == PR_SYSENTRY && psp->pr_what == sysnum); 3775 } 3776 3777 static const mdb_se_ops_t proc_sysenter_ops = { 3778 pt_sysenter_ctor, /* se_ctor */ 3779 pt_sysenter_dtor, /* se_dtor */ 3780 pt_sysenter_info, /* se_info */ 3781 no_se_secmp, /* se_secmp */ 3782 no_se_vecmp, /* se_vecmp */ 3783 no_se_arm, /* se_arm */ 3784 no_se_disarm, /* se_disarm */ 3785 no_se_cont, /* se_cont */ 3786 pt_sysenter_match /* se_match */ 3787 }; 3788 3789 static int 3790 pt_sysexit_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 3791 { 3792 struct ps_prochandle *P = t->t_pshandle; 3793 3794 if (P != NULL && Pstate(P) < PS_LOST) { 3795 sep->se_data = args; /* data is raw system call number */ 3796 return (Psysexit(P, (intptr_t)args, TRUE) < 0 ? -1 : 0); 3797 } 3798 3799 return (set_errno(EMDB_NOPROC)); 3800 } 3801 3802 static void 3803 pt_sysexit_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 3804 { 3805 (void) Psysexit(t->t_pshandle, (intptr_t)sep->se_data, FALSE); 3806 } 3807 3808 /*ARGSUSED*/ 3809 static char * 3810 pt_sysexit_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 3811 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 3812 { 3813 char name[32]; 3814 int sysnum; 3815 3816 if (vep != NULL) 3817 sysnum = (intptr_t)vep->ve_args; 3818 else 3819 sysnum = (intptr_t)sep->se_data; 3820 3821 (void) proc_sysname(sysnum, name, sizeof (name)); 3822 (void) mdb_iob_snprintf(buf, nbytes, "stop on exit from %s", name); 3823 3824 return (buf); 3825 } 3826 3827 /*ARGSUSED*/ 3828 static int 3829 pt_sysexit_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 3830 { 3831 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 3832 int sysnum = (intptr_t)sep->se_data; 3833 3834 return (psp->pr_why == PR_SYSEXIT && psp->pr_what == sysnum); 3835 } 3836 3837 static const mdb_se_ops_t proc_sysexit_ops = { 3838 pt_sysexit_ctor, /* se_ctor */ 3839 pt_sysexit_dtor, /* se_dtor */ 3840 pt_sysexit_info, /* se_info */ 3841 no_se_secmp, /* se_secmp */ 3842 no_se_vecmp, /* se_vecmp */ 3843 no_se_arm, /* se_arm */ 3844 no_se_disarm, /* se_disarm */ 3845 no_se_cont, /* se_cont */ 3846 pt_sysexit_match /* se_match */ 3847 }; 3848 3849 static int 3850 pt_signal_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 3851 { 3852 struct ps_prochandle *P = t->t_pshandle; 3853 3854 if (P != NULL && Pstate(P) < PS_LOST) { 3855 sep->se_data = args; /* data is raw signal number */ 3856 return (Psignal(P, (intptr_t)args, TRUE) < 0 ? -1 : 0); 3857 } 3858 3859 return (set_errno(EMDB_NOPROC)); 3860 } 3861 3862 static void 3863 pt_signal_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 3864 { 3865 (void) Psignal(t->t_pshandle, (intptr_t)sep->se_data, FALSE); 3866 } 3867 3868 /*ARGSUSED*/ 3869 static char * 3870 pt_signal_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 3871 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 3872 { 3873 char name[SIG2STR_MAX]; 3874 int signum; 3875 3876 if (vep != NULL) 3877 signum = (intptr_t)vep->ve_args; 3878 else 3879 signum = (intptr_t)sep->se_data; 3880 3881 (void) proc_signame(signum, name, sizeof (name)); 3882 (void) mdb_iob_snprintf(buf, nbytes, "stop on %s", name); 3883 3884 return (buf); 3885 } 3886 3887 /*ARGSUSED*/ 3888 static int 3889 pt_signal_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 3890 { 3891 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 3892 int signum = (intptr_t)sep->se_data; 3893 3894 return (psp->pr_why == PR_SIGNALLED && psp->pr_what == signum); 3895 } 3896 3897 static const mdb_se_ops_t proc_signal_ops = { 3898 pt_signal_ctor, /* se_ctor */ 3899 pt_signal_dtor, /* se_dtor */ 3900 pt_signal_info, /* se_info */ 3901 no_se_secmp, /* se_secmp */ 3902 no_se_vecmp, /* se_vecmp */ 3903 no_se_arm, /* se_arm */ 3904 no_se_disarm, /* se_disarm */ 3905 no_se_cont, /* se_cont */ 3906 pt_signal_match /* se_match */ 3907 }; 3908 3909 static int 3910 pt_fault_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 3911 { 3912 struct ps_prochandle *P = t->t_pshandle; 3913 3914 if (P != NULL && Pstate(P) < PS_LOST) { 3915 sep->se_data = args; /* data is raw fault number */ 3916 return (Pfault(P, (intptr_t)args, TRUE) < 0 ? -1 : 0); 3917 } 3918 3919 return (set_errno(EMDB_NOPROC)); 3920 } 3921 3922 static void 3923 pt_fault_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 3924 { 3925 int fault = (intptr_t)sep->se_data; 3926 3927 if (fault != FLTBPT && fault != FLTTRACE && fault != FLTWATCH) 3928 (void) Pfault(t->t_pshandle, fault, FALSE); 3929 } 3930 3931 /*ARGSUSED*/ 3932 static char * 3933 pt_fault_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 3934 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 3935 { 3936 char name[32]; 3937 int fltnum; 3938 3939 if (vep != NULL) 3940 fltnum = (intptr_t)vep->ve_args; 3941 else 3942 fltnum = (intptr_t)sep->se_data; 3943 3944 (void) proc_fltname(fltnum, name, sizeof (name)); 3945 (void) mdb_iob_snprintf(buf, nbytes, "stop on %s", name); 3946 3947 return (buf); 3948 } 3949 3950 /*ARGSUSED*/ 3951 static int 3952 pt_fault_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 3953 { 3954 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 3955 int fltnum = (intptr_t)sep->se_data; 3956 3957 return (psp->pr_why == PR_FAULTED && psp->pr_what == fltnum); 3958 } 3959 3960 static const mdb_se_ops_t proc_fault_ops = { 3961 pt_fault_ctor, /* se_ctor */ 3962 pt_fault_dtor, /* se_dtor */ 3963 pt_fault_info, /* se_info */ 3964 no_se_secmp, /* se_secmp */ 3965 no_se_vecmp, /* se_vecmp */ 3966 no_se_arm, /* se_arm */ 3967 no_se_disarm, /* se_disarm */ 3968 no_se_cont, /* se_cont */ 3969 pt_fault_match /* se_match */ 3970 }; 3971 3972 /* 3973 * Callback for pt_ignore() dcmd above: for each VID, determine if it 3974 * corresponds to a vespec that traces the specified signal, and delete it. 3975 */ 3976 /*ARGSUSED*/ 3977 static int 3978 pt_ignore_sig(mdb_tgt_t *t, void *sig, int vid, void *data) 3979 { 3980 mdb_vespec_t *vep = mdb_tgt_vespec_lookup(t, vid); 3981 3982 if (vep->ve_se->se_ops == &proc_signal_ops && vep->ve_args == sig) 3983 (void) mdb_tgt_vespec_delete(t, vid); 3984 3985 return (0); 3986 } 3987 3988 static int 3989 pt_brkpt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 3990 { 3991 pt_data_t *pt = t->t_data; 3992 pt_bparg_t *pta = args; 3993 pt_brkpt_t *ptb; 3994 GElf_Sym s; 3995 3996 if (t->t_pshandle == NULL || Pstate(t->t_pshandle) >= PS_LOST) 3997 return (set_errno(EMDB_NOPROC)); 3998 3999 if (pta->pta_symbol != NULL) { 4000 if (!pt->p_rtld_finished && 4001 strchr(pta->pta_symbol, '`') == NULL) 4002 return (set_errno(EMDB_NOSYM)); 4003 if (mdb_tgt_lookup_by_scope(t, pta->pta_symbol, &s, 4004 NULL) == -1) { 4005 if (errno != EMDB_NOOBJ && !(errno == EMDB_NOSYM && 4006 (!(mdb.m_flags & MDB_FL_BPTNOSYMSTOP) || 4007 !pt->p_rtld_finished))) { 4008 warn("breakpoint %s activation failed", 4009 pta->pta_symbol); 4010 } 4011 return (-1); /* errno is set for us */ 4012 } 4013 4014 pta->pta_addr = (uintptr_t)s.st_value; 4015 } 4016 4017 #ifdef __sparc 4018 if (pta->pta_addr & 3) 4019 return (set_errno(EMDB_BPALIGN)); 4020 #endif 4021 4022 if (Paddr_to_map(t->t_pshandle, pta->pta_addr) == NULL) 4023 return (set_errno(EMDB_NOMAP)); 4024 4025 ptb = mdb_alloc(sizeof (pt_brkpt_t), UM_SLEEP); 4026 ptb->ptb_addr = pta->pta_addr; 4027 ptb->ptb_instr = 0; 4028 sep->se_data = ptb; 4029 4030 return (0); 4031 } 4032 4033 /*ARGSUSED*/ 4034 static void 4035 pt_brkpt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 4036 { 4037 mdb_free(sep->se_data, sizeof (pt_brkpt_t)); 4038 } 4039 4040 /*ARGSUSED*/ 4041 static char * 4042 pt_brkpt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 4043 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 4044 { 4045 uintptr_t addr = 0; 4046 4047 if (vep != NULL) { 4048 pt_bparg_t *pta = vep->ve_args; 4049 4050 if (pta->pta_symbol != NULL) { 4051 (void) mdb_iob_snprintf(buf, nbytes, "stop at %s", 4052 pta->pta_symbol); 4053 } else { 4054 (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", 4055 pta->pta_addr); 4056 addr = pta->pta_addr; 4057 } 4058 4059 } else { 4060 addr = ((pt_brkpt_t *)sep->se_data)->ptb_addr; 4061 (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", addr); 4062 } 4063 4064 sp->spec_base = addr; 4065 sp->spec_size = sizeof (instr_t); 4066 4067 return (buf); 4068 } 4069 4070 static int 4071 pt_brkpt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 4072 { 4073 pt_brkpt_t *ptb = sep->se_data; 4074 pt_bparg_t *pta = args; 4075 GElf_Sym sym; 4076 4077 if (pta->pta_symbol != NULL) { 4078 return (mdb_tgt_lookup_by_scope(t, pta->pta_symbol, 4079 &sym, NULL) == 0 && sym.st_value == ptb->ptb_addr); 4080 } 4081 4082 return (pta->pta_addr == ptb->ptb_addr); 4083 } 4084 4085 /*ARGSUSED*/ 4086 static int 4087 pt_brkpt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args) 4088 { 4089 pt_bparg_t *pta1 = vep->ve_args; 4090 pt_bparg_t *pta2 = args; 4091 4092 if (pta1->pta_symbol != NULL && pta2->pta_symbol != NULL) 4093 return (strcmp(pta1->pta_symbol, pta2->pta_symbol) == 0); 4094 4095 if (pta1->pta_symbol == NULL && pta2->pta_symbol == NULL) 4096 return (pta1->pta_addr == pta2->pta_addr); 4097 4098 return (0); /* fail if one is symbolic, other is an explicit address */ 4099 } 4100 4101 static int 4102 pt_brkpt_arm(mdb_tgt_t *t, mdb_sespec_t *sep) 4103 { 4104 pt_brkpt_t *ptb = sep->se_data; 4105 return (Psetbkpt(t->t_pshandle, ptb->ptb_addr, &ptb->ptb_instr)); 4106 } 4107 4108 /* 4109 * In order to disarm a breakpoint, we replace the trap instruction at ptb_addr 4110 * with the saved instruction. However, if we have stopped after a successful 4111 * exec(2), we do not want to restore ptb_instr because the address space has 4112 * now been replaced with the text of a different executable, and so restoring 4113 * the saved instruction would be incorrect. The exec itself has effectively 4114 * removed all breakpoint trap instructions for us, so we can just return. 4115 */ 4116 static int 4117 pt_brkpt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep) 4118 { 4119 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 4120 pt_brkpt_t *ptb = sep->se_data; 4121 4122 if (psp->pr_why == PR_SYSEXIT && psp->pr_errno == 0 && 4123 psp->pr_what == SYS_execve) 4124 return (0); /* do not restore saved instruction */ 4125 4126 return (Pdelbkpt(t->t_pshandle, ptb->ptb_addr, ptb->ptb_instr)); 4127 } 4128 4129 /* 4130 * Determine whether the specified sespec is an armed watchpoint that overlaps 4131 * with the given breakpoint and has the given flags set. We use this to find 4132 * conflicts with breakpoints, below. 4133 */ 4134 static int 4135 pt_wp_overlap(mdb_sespec_t *sep, pt_brkpt_t *ptb, int flags) 4136 { 4137 const prwatch_t *wp = sep->se_data; 4138 4139 return (sep->se_state == MDB_TGT_SPEC_ARMED && 4140 sep->se_ops == &proc_wapt_ops && (wp->pr_wflags & flags) && 4141 ptb->ptb_addr - wp->pr_vaddr < wp->pr_size); 4142 } 4143 4144 /* 4145 * We step over breakpoints using Pxecbkpt() in libproc. If a conflicting 4146 * watchpoint is present, we must temporarily remove it before stepping over 4147 * the breakpoint so we do not immediately re-trigger the watchpoint. We know 4148 * the watchpoint has already triggered on our trap instruction as part of 4149 * fetching it. Before we return, we must re-install any disabled watchpoints. 4150 */ 4151 static int 4152 pt_brkpt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 4153 { 4154 pt_brkpt_t *ptb = sep->se_data; 4155 int status = -1; 4156 int error; 4157 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 4158 4159 /* 4160 * If the PC no longer matches our original address, then the user has 4161 * changed it while we have been stopped. In this case, it no longer 4162 * makes any sense to continue over this breakpoint. We return as if we 4163 * continued normally. 4164 */ 4165 if ((uintptr_t)psp->pr_info.si_addr != psp->pr_reg[R_PC]) 4166 return (pt_status(t, tsp)); 4167 4168 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 4169 if (pt_wp_overlap(sep, ptb, WA_EXEC)) 4170 (void) Pdelwapt(t->t_pshandle, sep->se_data); 4171 } 4172 4173 if (Pxecbkpt(t->t_pshandle, ptb->ptb_instr) == 0 && 4174 Pdelbkpt(t->t_pshandle, ptb->ptb_addr, ptb->ptb_instr) == 0) 4175 status = pt_status(t, tsp); 4176 4177 error = errno; /* save errno from Pxecbkpt, Pdelbkpt, or pt_status */ 4178 4179 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 4180 if (pt_wp_overlap(sep, ptb, WA_EXEC) && 4181 Psetwapt(t->t_pshandle, sep->se_data) == -1) { 4182 sep->se_state = MDB_TGT_SPEC_ERROR; 4183 sep->se_errno = errno; 4184 } 4185 } 4186 4187 (void) set_errno(error); 4188 return (status); 4189 } 4190 4191 /*ARGSUSED*/ 4192 static int 4193 pt_brkpt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 4194 { 4195 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 4196 pt_brkpt_t *ptb = sep->se_data; 4197 4198 return (psp->pr_why == PR_FAULTED && psp->pr_what == FLTBPT && 4199 psp->pr_reg[R_PC] == ptb->ptb_addr); 4200 } 4201 4202 static const mdb_se_ops_t proc_brkpt_ops = { 4203 pt_brkpt_ctor, /* se_ctor */ 4204 pt_brkpt_dtor, /* se_dtor */ 4205 pt_brkpt_info, /* se_info */ 4206 pt_brkpt_secmp, /* se_secmp */ 4207 pt_brkpt_vecmp, /* se_vecmp */ 4208 pt_brkpt_arm, /* se_arm */ 4209 pt_brkpt_disarm, /* se_disarm */ 4210 pt_brkpt_cont, /* se_cont */ 4211 pt_brkpt_match /* se_match */ 4212 }; 4213 4214 static int 4215 pt_wapt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 4216 { 4217 if (t->t_pshandle == NULL || Pstate(t->t_pshandle) >= PS_LOST) 4218 return (set_errno(EMDB_NOPROC)); 4219 4220 sep->se_data = mdb_alloc(sizeof (prwatch_t), UM_SLEEP); 4221 bcopy(args, sep->se_data, sizeof (prwatch_t)); 4222 return (0); 4223 } 4224 4225 /*ARGSUSED*/ 4226 static void 4227 pt_wapt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 4228 { 4229 mdb_free(sep->se_data, sizeof (prwatch_t)); 4230 } 4231 4232 /*ARGSUSED*/ 4233 static char * 4234 pt_wapt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 4235 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 4236 { 4237 prwatch_t *wp = vep != NULL ? vep->ve_args : sep->se_data; 4238 char desc[24]; 4239 4240 ASSERT(wp->pr_wflags != 0); 4241 desc[0] = '\0'; 4242 4243 switch (wp->pr_wflags) { 4244 case WA_READ: 4245 (void) strcat(desc, "/read"); 4246 break; 4247 case WA_WRITE: 4248 (void) strcat(desc, "/write"); 4249 break; 4250 case WA_EXEC: 4251 (void) strcat(desc, "/exec"); 4252 break; 4253 default: 4254 if (wp->pr_wflags & WA_READ) 4255 (void) strcat(desc, "/r"); 4256 if (wp->pr_wflags & WA_WRITE) 4257 (void) strcat(desc, "/w"); 4258 if (wp->pr_wflags & WA_EXEC) 4259 (void) strcat(desc, "/x"); 4260 } 4261 4262 (void) mdb_iob_snprintf(buf, nbytes, "stop on %s of [%la, %la)", 4263 desc + 1, wp->pr_vaddr, wp->pr_vaddr + wp->pr_size); 4264 4265 sp->spec_base = wp->pr_vaddr; 4266 sp->spec_size = wp->pr_size; 4267 4268 return (buf); 4269 } 4270 4271 /*ARGSUSED*/ 4272 static int 4273 pt_wapt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 4274 { 4275 prwatch_t *wp1 = sep->se_data; 4276 prwatch_t *wp2 = args; 4277 4278 return (wp1->pr_vaddr == wp2->pr_vaddr && 4279 wp1->pr_size == wp2->pr_size && wp1->pr_wflags == wp2->pr_wflags); 4280 } 4281 4282 /*ARGSUSED*/ 4283 static int 4284 pt_wapt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args) 4285 { 4286 prwatch_t *wp1 = vep->ve_args; 4287 prwatch_t *wp2 = args; 4288 4289 return (wp1->pr_vaddr == wp2->pr_vaddr && 4290 wp1->pr_size == wp2->pr_size && wp1->pr_wflags == wp2->pr_wflags); 4291 } 4292 4293 static int 4294 pt_wapt_arm(mdb_tgt_t *t, mdb_sespec_t *sep) 4295 { 4296 return (Psetwapt(t->t_pshandle, sep->se_data)); 4297 } 4298 4299 static int 4300 pt_wapt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep) 4301 { 4302 return (Pdelwapt(t->t_pshandle, sep->se_data)); 4303 } 4304 4305 /* 4306 * Determine whether the specified sespec is an armed breakpoint at the 4307 * given %pc. We use this to find conflicts with watchpoints below. 4308 */ 4309 static int 4310 pt_bp_overlap(mdb_sespec_t *sep, uintptr_t pc) 4311 { 4312 pt_brkpt_t *ptb = sep->se_data; 4313 4314 return (sep->se_state == MDB_TGT_SPEC_ARMED && 4315 sep->se_ops == &proc_brkpt_ops && ptb->ptb_addr == pc); 4316 } 4317 4318 /* 4319 * We step over watchpoints using Pxecwapt() in libproc. If a conflicting 4320 * breakpoint is present, we must temporarily disarm it before stepping 4321 * over the watchpoint so we do not immediately re-trigger the breakpoint. 4322 * This is similar to the case handled in pt_brkpt_cont(), above. 4323 */ 4324 static int 4325 pt_wapt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 4326 { 4327 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 4328 mdb_sespec_t *bep = NULL; 4329 int status = -1; 4330 int error; 4331 4332 /* 4333 * If the PC no longer matches our original address, then the user has 4334 * changed it while we have been stopped. In this case, it no longer 4335 * makes any sense to continue over this instruction. We return as if 4336 * we continued normally. 4337 */ 4338 if ((uintptr_t)psp->pr_info.si_pc != psp->pr_reg[R_PC]) 4339 return (pt_status(t, tsp)); 4340 4341 if (psp->pr_info.si_code != TRAP_XWATCH) { 4342 for (bep = mdb_list_next(&t->t_active); bep != NULL; 4343 bep = mdb_list_next(bep)) { 4344 if (pt_bp_overlap(bep, psp->pr_reg[R_PC])) { 4345 (void) bep->se_ops->se_disarm(t, bep); 4346 bep->se_state = MDB_TGT_SPEC_ACTIVE; 4347 break; 4348 } 4349 } 4350 } 4351 4352 if (Pxecwapt(t->t_pshandle, sep->se_data) == 0) 4353 status = pt_status(t, tsp); 4354 4355 error = errno; /* save errno from Pxecwapt or pt_status */ 4356 4357 if (bep != NULL) 4358 mdb_tgt_sespec_arm_one(t, bep); 4359 4360 (void) set_errno(error); 4361 return (status); 4362 } 4363 4364 /*ARGSUSED*/ 4365 static int 4366 pt_wapt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 4367 { 4368 const lwpstatus_t *psp = &Pstatus(t->t_pshandle)->pr_lwp; 4369 prwatch_t *wp = sep->se_data; 4370 4371 return (psp->pr_why == PR_FAULTED && psp->pr_what == FLTWATCH && 4372 (uintptr_t)psp->pr_info.si_addr - wp->pr_vaddr < wp->pr_size); 4373 } 4374 4375 static const mdb_se_ops_t proc_wapt_ops = { 4376 pt_wapt_ctor, /* se_ctor */ 4377 pt_wapt_dtor, /* se_dtor */ 4378 pt_wapt_info, /* se_info */ 4379 pt_wapt_secmp, /* se_secmp */ 4380 pt_wapt_vecmp, /* se_vecmp */ 4381 pt_wapt_arm, /* se_arm */ 4382 pt_wapt_disarm, /* se_disarm */ 4383 pt_wapt_cont, /* se_cont */ 4384 pt_wapt_match /* se_match */ 4385 }; 4386 4387 static void 4388 pt_bparg_dtor(mdb_vespec_t *vep) 4389 { 4390 pt_bparg_t *pta = vep->ve_args; 4391 4392 if (pta->pta_symbol != NULL) 4393 strfree(pta->pta_symbol); 4394 4395 mdb_free(pta, sizeof (pt_bparg_t)); 4396 } 4397 4398 static int 4399 pt_add_vbrkpt(mdb_tgt_t *t, uintptr_t addr, 4400 int spec_flags, mdb_tgt_se_f *func, void *data) 4401 { 4402 pt_bparg_t *pta = mdb_alloc(sizeof (pt_bparg_t), UM_SLEEP); 4403 4404 pta->pta_symbol = NULL; 4405 pta->pta_addr = addr; 4406 4407 return (mdb_tgt_vespec_insert(t, &proc_brkpt_ops, spec_flags, 4408 func, data, pta, pt_bparg_dtor)); 4409 } 4410 4411 static int 4412 pt_add_sbrkpt(mdb_tgt_t *t, const char *sym, 4413 int spec_flags, mdb_tgt_se_f *func, void *data) 4414 { 4415 pt_bparg_t *pta; 4416 4417 if (sym[0] == '`') { 4418 (void) set_errno(EMDB_NOOBJ); 4419 return (0); 4420 } 4421 4422 if (sym[strlen(sym) - 1] == '`') { 4423 (void) set_errno(EMDB_NOSYM); 4424 return (0); 4425 } 4426 4427 pta = mdb_alloc(sizeof (pt_bparg_t), UM_SLEEP); 4428 pta->pta_symbol = strdup(sym); 4429 pta->pta_addr = 0; 4430 4431 return (mdb_tgt_vespec_insert(t, &proc_brkpt_ops, spec_flags, 4432 func, data, pta, pt_bparg_dtor)); 4433 } 4434 4435 static int 4436 pt_wparg_overlap(const prwatch_t *wp1, const prwatch_t *wp2) 4437 { 4438 if (wp2->pr_vaddr + wp2->pr_size <= wp1->pr_vaddr) 4439 return (0); /* no range overlap */ 4440 4441 if (wp1->pr_vaddr + wp1->pr_size <= wp2->pr_vaddr) 4442 return (0); /* no range overlap */ 4443 4444 return (wp1->pr_vaddr != wp2->pr_vaddr || 4445 wp1->pr_size != wp2->pr_size || wp1->pr_wflags != wp2->pr_wflags); 4446 } 4447 4448 static void 4449 pt_wparg_dtor(mdb_vespec_t *vep) 4450 { 4451 mdb_free(vep->ve_args, sizeof (prwatch_t)); 4452 } 4453 4454 static int 4455 pt_add_vwapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags, 4456 int spec_flags, mdb_tgt_se_f *func, void *data) 4457 { 4458 prwatch_t *wp = mdb_alloc(sizeof (prwatch_t), UM_SLEEP); 4459 mdb_sespec_t *sep; 4460 4461 wp->pr_vaddr = addr; 4462 wp->pr_size = len; 4463 wp->pr_wflags = 0; 4464 4465 if (wflags & MDB_TGT_WA_R) 4466 wp->pr_wflags |= WA_READ; 4467 if (wflags & MDB_TGT_WA_W) 4468 wp->pr_wflags |= WA_WRITE; 4469 if (wflags & MDB_TGT_WA_X) 4470 wp->pr_wflags |= WA_EXEC; 4471 4472 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 4473 if (sep->se_ops == &proc_wapt_ops && 4474 mdb_list_next(&sep->se_velist) != NULL && 4475 pt_wparg_overlap(wp, sep->se_data)) 4476 goto dup; 4477 } 4478 4479 for (sep = mdb_list_next(&t->t_idle); sep; sep = mdb_list_next(sep)) { 4480 if (sep->se_ops == &proc_wapt_ops && pt_wparg_overlap(wp, 4481 ((mdb_vespec_t *)mdb_list_next(&sep->se_velist))->ve_args)) 4482 goto dup; 4483 } 4484 4485 return (mdb_tgt_vespec_insert(t, &proc_wapt_ops, spec_flags, 4486 func, data, wp, pt_wparg_dtor)); 4487 4488 dup: 4489 mdb_free(wp, sizeof (prwatch_t)); 4490 (void) set_errno(EMDB_WPDUP); 4491 return (0); 4492 } 4493 4494 static int 4495 pt_add_sysenter(mdb_tgt_t *t, int sysnum, 4496 int spec_flags, mdb_tgt_se_f *func, void *data) 4497 { 4498 if (sysnum <= 0 || sysnum > PRMAXSYS) { 4499 (void) set_errno(EMDB_BADSYSNUM); 4500 return (0); 4501 } 4502 4503 return (mdb_tgt_vespec_insert(t, &proc_sysenter_ops, spec_flags, 4504 func, data, (void *)(uintptr_t)sysnum, no_ve_dtor)); 4505 } 4506 4507 static int 4508 pt_add_sysexit(mdb_tgt_t *t, int sysnum, 4509 int spec_flags, mdb_tgt_se_f *func, void *data) 4510 { 4511 if (sysnum <= 0 || sysnum > PRMAXSYS) { 4512 (void) set_errno(EMDB_BADSYSNUM); 4513 return (0); 4514 } 4515 4516 return (mdb_tgt_vespec_insert(t, &proc_sysexit_ops, spec_flags, 4517 func, data, (void *)(uintptr_t)sysnum, no_ve_dtor)); 4518 } 4519 4520 static int 4521 pt_add_signal(mdb_tgt_t *t, int signum, 4522 int spec_flags, mdb_tgt_se_f *func, void *data) 4523 { 4524 pt_data_t *pt = t->t_data; 4525 4526 if (signum <= 0 || signum > pt->p_maxsig) { 4527 (void) set_errno(EMDB_BADSIGNUM); 4528 return (0); 4529 } 4530 4531 return (mdb_tgt_vespec_insert(t, &proc_signal_ops, spec_flags, 4532 func, data, (void *)(uintptr_t)signum, no_ve_dtor)); 4533 } 4534 4535 static int 4536 pt_add_fault(mdb_tgt_t *t, int fltnum, 4537 int spec_flags, mdb_tgt_se_f *func, void *data) 4538 { 4539 if (fltnum <= 0 || fltnum > PRMAXFAULT) { 4540 (void) set_errno(EMDB_BADFLTNUM); 4541 return (0); 4542 } 4543 4544 return (mdb_tgt_vespec_insert(t, &proc_fault_ops, spec_flags, 4545 func, data, (void *)(uintptr_t)fltnum, no_ve_dtor)); 4546 } 4547 4548 static int 4549 pt_getareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, 4550 const char *rname, mdb_tgt_reg_t *rp) 4551 { 4552 pt_data_t *pt = t->t_data; 4553 prgregset_t grs; 4554 mdb_var_t *v; 4555 4556 if (t->t_pshandle == NULL) 4557 return (set_errno(EMDB_NOPROC)); 4558 4559 if ((v = mdb_nv_lookup(&pt->p_regs, rname)) != NULL) { 4560 uintmax_t rd_nval = mdb_nv_get_value(v); 4561 ushort_t rd_num = MDB_TGT_R_NUM(rd_nval); 4562 ushort_t rd_flags = MDB_TGT_R_FLAGS(rd_nval); 4563 4564 if (!MDB_TGT_R_IS_FP(rd_flags)) { 4565 mdb_tgt_reg_t r = 0; 4566 4567 #if defined(__sparc) && defined(_ILP32) 4568 /* 4569 * If we are debugging on 32-bit SPARC, the globals and 4570 * outs can have 32 upper bits hiding in the xregs. 4571 */ 4572 /* gcc doesn't like >= R_G0 because R_G0 == 0 */ 4573 int is_g = (rd_num == R_G0 || 4574 rd_num >= R_G1 && rd_num <= R_G7); 4575 int is_o = (rd_num >= R_O0 && rd_num <= R_O7); 4576 prxregset_t xrs; 4577 4578 if (is_g && PTL_GETXREGS(t, tid, &xrs) == 0 && 4579 xrs.pr_type == XR_TYPE_V8P) { 4580 r |= (uint64_t)xrs.pr_un.pr_v8p.pr_xg[ 4581 rd_num - R_G0 + XR_G0] << 32; 4582 } 4583 4584 if (is_o && PTL_GETXREGS(t, tid, &xrs) == 0 && 4585 xrs.pr_type == XR_TYPE_V8P) { 4586 r |= (uint64_t)xrs.pr_un.pr_v8p.pr_xo[ 4587 rd_num - R_O0 + XR_O0] << 32; 4588 } 4589 #endif /* __sparc && _ILP32 */ 4590 4591 /* 4592 * Avoid sign-extension by casting: recall that procfs 4593 * defines prgreg_t as a long or int and our native 4594 * register handling uses uint64_t's. 4595 */ 4596 if (PTL_GETREGS(t, tid, grs) == 0) { 4597 *rp = r | (ulong_t)grs[rd_num]; 4598 if (rd_flags & MDB_TGT_R_32) 4599 *rp &= 0xffffffffULL; 4600 else if (rd_flags & MDB_TGT_R_16) 4601 *rp &= 0xffffULL; 4602 else if (rd_flags & MDB_TGT_R_8H) 4603 *rp = (*rp & 0xff00ULL) >> 8; 4604 else if (rd_flags & MDB_TGT_R_8L) 4605 *rp &= 0xffULL; 4606 return (0); 4607 } 4608 return (-1); 4609 } else 4610 return (pt_getfpreg(t, tid, rd_num, rd_flags, rp)); 4611 } 4612 4613 return (set_errno(EMDB_BADREG)); 4614 } 4615 4616 static int 4617 pt_putareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, mdb_tgt_reg_t r) 4618 { 4619 pt_data_t *pt = t->t_data; 4620 prgregset_t grs; 4621 mdb_var_t *v; 4622 4623 if (t->t_pshandle == NULL) 4624 return (set_errno(EMDB_NOPROC)); 4625 4626 if ((v = mdb_nv_lookup(&pt->p_regs, rname)) != NULL) { 4627 uintmax_t rd_nval = mdb_nv_get_value(v); 4628 ushort_t rd_num = MDB_TGT_R_NUM(rd_nval); 4629 ushort_t rd_flags = MDB_TGT_R_FLAGS(rd_nval); 4630 4631 if (!MDB_TGT_R_IS_FP(rd_flags)) { 4632 4633 if (rd_flags & MDB_TGT_R_32) 4634 r &= 0xffffffffULL; 4635 else if (rd_flags & MDB_TGT_R_16) 4636 r &= 0xffffULL; 4637 else if (rd_flags & MDB_TGT_R_8H) 4638 r = (r & 0xffULL) << 8; 4639 else if (rd_flags & MDB_TGT_R_8L) 4640 r &= 0xffULL; 4641 4642 #if defined(__sparc) && defined(_ILP32) 4643 /* 4644 * If we are debugging on 32-bit SPARC, the globals and 4645 * outs can have 32 upper bits stored in the xregs. 4646 */ 4647 int is_g = (rd_num == R_G0 || 4648 rd_num >= R_G1 && rd_num <= R_G7); 4649 int is_o = (rd_num >= R_O0 && rd_num <= R_O7); 4650 prxregset_t xrs; 4651 4652 if ((is_g || is_o) && PTL_GETXREGS(t, tid, &xrs) == 0 && 4653 xrs.pr_type == XR_TYPE_V8P) { 4654 if (is_g) { 4655 xrs.pr_un.pr_v8p.pr_xg[rd_num - 4656 R_G0 + XR_G0] = (uint32_t)(r >> 32); 4657 } else if (is_o) { 4658 xrs.pr_un.pr_v8p.pr_xo[rd_num - 4659 R_O0 + XR_O0] = (uint32_t)(r >> 32); 4660 } 4661 4662 if (PTL_SETXREGS(t, tid, &xrs) == -1) 4663 return (-1); 4664 } 4665 #endif /* __sparc && _ILP32 */ 4666 4667 if (PTL_GETREGS(t, tid, grs) == 0) { 4668 grs[rd_num] = (prgreg_t)r; 4669 return (PTL_SETREGS(t, tid, grs)); 4670 } 4671 return (-1); 4672 } else 4673 return (pt_putfpreg(t, tid, rd_num, rd_flags, r)); 4674 } 4675 4676 return (set_errno(EMDB_BADREG)); 4677 } 4678 4679 static int 4680 pt_stack_call(pt_stkarg_t *psp, const prgregset_t grs, uint_t argc, long *argv) 4681 { 4682 psp->pstk_gotpc |= (grs[R_PC] != 0); 4683 4684 if (!psp->pstk_gotpc) 4685 return (0); /* skip initial zeroed frames */ 4686 4687 return (psp->pstk_func(psp->pstk_private, grs[R_PC], 4688 argc, argv, (const struct mdb_tgt_gregset *)grs)); 4689 } 4690 4691 static int 4692 pt_stack_iter(mdb_tgt_t *t, const mdb_tgt_gregset_t *gsp, 4693 mdb_tgt_stack_f *func, void *arg) 4694 { 4695 if (t->t_pshandle != NULL) { 4696 pt_stkarg_t pstk; 4697 4698 pstk.pstk_func = func; 4699 pstk.pstk_private = arg; 4700 pstk.pstk_gotpc = FALSE; 4701 4702 (void) Pstack_iter(t->t_pshandle, gsp->gregs, 4703 (proc_stack_f *)pt_stack_call, &pstk); 4704 4705 return (0); 4706 } 4707 4708 return (set_errno(EMDB_NOPROC)); 4709 } 4710 4711 static int 4712 pt_auxv(mdb_tgt_t *t, const auxv_t **auxvp) 4713 { 4714 if (t->t_pshandle != NULL) { 4715 *auxvp = Pgetauxvec(t->t_pshandle); 4716 return (0); 4717 } 4718 4719 return (set_errno(EMDB_NOPROC)); 4720 } 4721 4722 4723 static const mdb_tgt_ops_t proc_ops = { 4724 pt_setflags, /* t_setflags */ 4725 (int (*)())(uintptr_t)mdb_tgt_notsup, /* t_setcontext */ 4726 pt_activate, /* t_activate */ 4727 pt_deactivate, /* t_deactivate */ 4728 pt_periodic, /* t_periodic */ 4729 pt_destroy, /* t_destroy */ 4730 pt_name, /* t_name */ 4731 (const char *(*)())mdb_conf_isa, /* t_isa */ 4732 pt_platform, /* t_platform */ 4733 pt_uname, /* t_uname */ 4734 pt_dmodel, /* t_dmodel */ 4735 (ssize_t (*)())mdb_tgt_notsup, /* t_aread */ 4736 (ssize_t (*)())mdb_tgt_notsup, /* t_awrite */ 4737 pt_vread, /* t_vread */ 4738 pt_vwrite, /* t_vwrite */ 4739 (ssize_t (*)())mdb_tgt_notsup, /* t_pread */ 4740 (ssize_t (*)())mdb_tgt_notsup, /* t_pwrite */ 4741 pt_fread, /* t_fread */ 4742 pt_fwrite, /* t_fwrite */ 4743 (ssize_t (*)())mdb_tgt_notsup, /* t_ioread */ 4744 (ssize_t (*)())mdb_tgt_notsup, /* t_iowrite */ 4745 (int (*)())(uintptr_t)mdb_tgt_notsup, /* t_vtop */ 4746 pt_lookup_by_name, /* t_lookup_by_name */ 4747 pt_lookup_by_addr, /* t_lookup_by_addr */ 4748 pt_symbol_iter, /* t_symbol_iter */ 4749 pt_mapping_iter, /* t_mapping_iter */ 4750 pt_object_iter, /* t_object_iter */ 4751 pt_addr_to_map, /* t_addr_to_map */ 4752 pt_name_to_map, /* t_name_to_map */ 4753 pt_addr_to_ctf, /* t_addr_to_ctf */ 4754 pt_name_to_ctf, /* t_name_to_ctf */ 4755 pt_status, /* t_status */ 4756 pt_run, /* t_run */ 4757 pt_step, /* t_step */ 4758 pt_step_out, /* t_step_out */ 4759 pt_next, /* t_next */ 4760 pt_continue, /* t_cont */ 4761 pt_signal, /* t_signal */ 4762 pt_add_vbrkpt, /* t_add_vbrkpt */ 4763 pt_add_sbrkpt, /* t_add_sbrkpt */ 4764 (int (*)())(uintptr_t)mdb_tgt_null, /* t_add_pwapt */ 4765 pt_add_vwapt, /* t_add_vwapt */ 4766 (int (*)())(uintptr_t)mdb_tgt_null, /* t_add_iowapt */ 4767 pt_add_sysenter, /* t_add_sysenter */ 4768 pt_add_sysexit, /* t_add_sysexit */ 4769 pt_add_signal, /* t_add_signal */ 4770 pt_add_fault, /* t_add_fault */ 4771 pt_getareg, /* t_getareg */ 4772 pt_putareg, /* t_putareg */ 4773 pt_stack_iter, /* t_stack_iter */ 4774 pt_auxv /* t_auxv */ 4775 }; 4776 4777 /* 4778 * Utility function for converting libproc errno values to mdb error values 4779 * for the ptl calls below. Currently, we only need to convert ENOENT to 4780 * EMDB_NOTHREAD to produce a more useful error message for the user. 4781 */ 4782 static int 4783 ptl_err(int error) 4784 { 4785 if (error != 0 && errno == ENOENT) 4786 return (set_errno(EMDB_NOTHREAD)); 4787 4788 return (error); 4789 } 4790 4791 /*ARGSUSED*/ 4792 static mdb_tgt_tid_t 4793 pt_lwp_tid(mdb_tgt_t *t, void *tap) 4794 { 4795 if (t->t_pshandle != NULL) 4796 return (Pstatus(t->t_pshandle)->pr_lwp.pr_lwpid); 4797 4798 return (set_errno(EMDB_NOPROC)); 4799 } 4800 4801 static int 4802 pt_lwp_add(mdb_addrvec_t *ap, const lwpstatus_t *psp) 4803 { 4804 mdb_addrvec_unshift(ap, psp->pr_lwpid); 4805 return (0); 4806 } 4807 4808 /*ARGSUSED*/ 4809 static int 4810 pt_lwp_iter(mdb_tgt_t *t, void *tap, mdb_addrvec_t *ap) 4811 { 4812 if (t->t_pshandle != NULL) 4813 return (Plwp_iter(t->t_pshandle, (proc_lwp_f *)pt_lwp_add, ap)); 4814 4815 return (set_errno(EMDB_NOPROC)); 4816 } 4817 4818 /*ARGSUSED*/ 4819 static int 4820 pt_lwp_getregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, prgregset_t gregs) 4821 { 4822 if (t->t_pshandle != NULL) { 4823 return (ptl_err(Plwp_getregs(t->t_pshandle, 4824 (lwpid_t)tid, gregs))); 4825 } 4826 return (set_errno(EMDB_NOPROC)); 4827 } 4828 4829 /*ARGSUSED*/ 4830 static int 4831 pt_lwp_setregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, prgregset_t gregs) 4832 { 4833 if (t->t_pshandle != NULL) { 4834 return (ptl_err(Plwp_setregs(t->t_pshandle, 4835 (lwpid_t)tid, gregs))); 4836 } 4837 return (set_errno(EMDB_NOPROC)); 4838 } 4839 4840 #ifdef __sparc 4841 4842 /*ARGSUSED*/ 4843 static int 4844 pt_lwp_getxregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, prxregset_t *xregs) 4845 { 4846 if (t->t_pshandle != NULL) { 4847 return (ptl_err(Plwp_getxregs(t->t_pshandle, 4848 (lwpid_t)tid, xregs))); 4849 } 4850 return (set_errno(EMDB_NOPROC)); 4851 } 4852 4853 /*ARGSUSED*/ 4854 static int 4855 pt_lwp_setxregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, 4856 const prxregset_t *xregs) 4857 { 4858 if (t->t_pshandle != NULL) { 4859 return (ptl_err(Plwp_setxregs(t->t_pshandle, 4860 (lwpid_t)tid, xregs))); 4861 } 4862 return (set_errno(EMDB_NOPROC)); 4863 } 4864 4865 #endif /* __sparc */ 4866 4867 /*ARGSUSED*/ 4868 static int 4869 pt_lwp_getfpregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, 4870 prfpregset_t *fpregs) 4871 { 4872 if (t->t_pshandle != NULL) { 4873 return (ptl_err(Plwp_getfpregs(t->t_pshandle, 4874 (lwpid_t)tid, fpregs))); 4875 } 4876 return (set_errno(EMDB_NOPROC)); 4877 } 4878 4879 /*ARGSUSED*/ 4880 static int 4881 pt_lwp_setfpregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, 4882 const prfpregset_t *fpregs) 4883 { 4884 if (t->t_pshandle != NULL) { 4885 return (ptl_err(Plwp_setfpregs(t->t_pshandle, 4886 (lwpid_t)tid, fpregs))); 4887 } 4888 return (set_errno(EMDB_NOPROC)); 4889 } 4890 4891 static const pt_ptl_ops_t proc_lwp_ops = { 4892 (int (*)())(uintptr_t)mdb_tgt_nop, 4893 (void (*)())(uintptr_t)mdb_tgt_nop, 4894 pt_lwp_tid, 4895 pt_lwp_iter, 4896 pt_lwp_getregs, 4897 pt_lwp_setregs, 4898 #ifdef __sparc 4899 pt_lwp_getxregs, 4900 pt_lwp_setxregs, 4901 #endif 4902 pt_lwp_getfpregs, 4903 pt_lwp_setfpregs 4904 }; 4905 4906 static int 4907 pt_tdb_ctor(mdb_tgt_t *t) 4908 { 4909 pt_data_t *pt = t->t_data; 4910 td_thragent_t *tap; 4911 td_err_e err; 4912 4913 if ((err = pt->p_tdb_ops->td_ta_new(t->t_pshandle, &tap)) != TD_OK) 4914 return (set_errno(tdb_to_errno(err))); 4915 4916 pt->p_ptl_hdl = tap; 4917 return (0); 4918 } 4919 4920 static void 4921 pt_tdb_dtor(mdb_tgt_t *t, void *tap) 4922 { 4923 pt_data_t *pt = t->t_data; 4924 4925 ASSERT(tap == pt->p_ptl_hdl); 4926 (void) pt->p_tdb_ops->td_ta_delete(tap); 4927 pt->p_ptl_hdl = NULL; 4928 } 4929 4930 static mdb_tgt_tid_t 4931 pt_tdb_tid(mdb_tgt_t *t, void *tap) 4932 { 4933 pt_data_t *pt = t->t_data; 4934 4935 td_thrhandle_t th; 4936 td_thrinfo_t ti; 4937 td_err_e err; 4938 4939 if (t->t_pshandle == NULL) 4940 return (set_errno(EMDB_NOPROC)); 4941 4942 if ((err = pt->p_tdb_ops->td_ta_map_lwp2thr(tap, 4943 Pstatus(t->t_pshandle)->pr_lwp.pr_lwpid, &th)) != TD_OK) 4944 return (set_errno(tdb_to_errno(err))); 4945 4946 if ((err = pt->p_tdb_ops->td_thr_get_info(&th, &ti)) != TD_OK) 4947 return (set_errno(tdb_to_errno(err))); 4948 4949 return (ti.ti_tid); 4950 } 4951 4952 static int 4953 pt_tdb_add(const td_thrhandle_t *thp, pt_addarg_t *pap) 4954 { 4955 td_thrinfo_t ti; 4956 4957 if (pap->pa_pt->p_tdb_ops->td_thr_get_info(thp, &ti) == TD_OK && 4958 ti.ti_state != TD_THR_ZOMBIE) 4959 mdb_addrvec_unshift(pap->pa_ap, ti.ti_tid); 4960 4961 return (0); 4962 } 4963 4964 static int 4965 pt_tdb_iter(mdb_tgt_t *t, void *tap, mdb_addrvec_t *ap) 4966 { 4967 pt_data_t *pt = t->t_data; 4968 pt_addarg_t arg; 4969 int err; 4970 4971 if (t->t_pshandle == NULL) 4972 return (set_errno(EMDB_NOPROC)); 4973 4974 arg.pa_pt = pt; 4975 arg.pa_ap = ap; 4976 4977 if ((err = pt->p_tdb_ops->td_ta_thr_iter(tap, (td_thr_iter_f *) 4978 pt_tdb_add, &arg, TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY, 4979 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS)) != TD_OK) 4980 return (set_errno(tdb_to_errno(err))); 4981 4982 return (0); 4983 } 4984 4985 static int 4986 pt_tdb_getregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, prgregset_t gregs) 4987 { 4988 pt_data_t *pt = t->t_data; 4989 4990 td_thrhandle_t th; 4991 td_err_e err; 4992 4993 if (t->t_pshandle == NULL) 4994 return (set_errno(EMDB_NOPROC)); 4995 4996 if ((err = pt->p_tdb_ops->td_ta_map_id2thr(tap, tid, &th)) != TD_OK) 4997 return (set_errno(tdb_to_errno(err))); 4998 4999 err = pt->p_tdb_ops->td_thr_getgregs(&th, gregs); 5000 if (err != TD_OK && err != TD_PARTIALREG) 5001 return (set_errno(tdb_to_errno(err))); 5002 5003 return (0); 5004 } 5005 5006 static int 5007 pt_tdb_setregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, prgregset_t gregs) 5008 { 5009 pt_data_t *pt = t->t_data; 5010 5011 td_thrhandle_t th; 5012 td_err_e err; 5013 5014 if (t->t_pshandle == NULL) 5015 return (set_errno(EMDB_NOPROC)); 5016 5017 if ((err = pt->p_tdb_ops->td_ta_map_id2thr(tap, tid, &th)) != TD_OK) 5018 return (set_errno(tdb_to_errno(err))); 5019 5020 err = pt->p_tdb_ops->td_thr_setgregs(&th, gregs); 5021 if (err != TD_OK && err != TD_PARTIALREG) 5022 return (set_errno(tdb_to_errno(err))); 5023 5024 return (0); 5025 } 5026 5027 #ifdef __sparc 5028 5029 static int 5030 pt_tdb_getxregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, prxregset_t *xregs) 5031 { 5032 pt_data_t *pt = t->t_data; 5033 5034 td_thrhandle_t th; 5035 td_err_e err; 5036 5037 if (t->t_pshandle == NULL) 5038 return (set_errno(EMDB_NOPROC)); 5039 5040 if ((err = pt->p_tdb_ops->td_ta_map_id2thr(tap, tid, &th)) != TD_OK) 5041 return (set_errno(tdb_to_errno(err))); 5042 5043 err = pt->p_tdb_ops->td_thr_getxregs(&th, xregs); 5044 if (err != TD_OK && err != TD_PARTIALREG) 5045 return (set_errno(tdb_to_errno(err))); 5046 5047 return (0); 5048 } 5049 5050 static int 5051 pt_tdb_setxregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, 5052 const prxregset_t *xregs) 5053 { 5054 pt_data_t *pt = t->t_data; 5055 5056 td_thrhandle_t th; 5057 td_err_e err; 5058 5059 if (t->t_pshandle == NULL) 5060 return (set_errno(EMDB_NOPROC)); 5061 5062 if ((err = pt->p_tdb_ops->td_ta_map_id2thr(tap, tid, &th)) != TD_OK) 5063 return (set_errno(tdb_to_errno(err))); 5064 5065 err = pt->p_tdb_ops->td_thr_setxregs(&th, xregs); 5066 if (err != TD_OK && err != TD_PARTIALREG) 5067 return (set_errno(tdb_to_errno(err))); 5068 5069 return (0); 5070 } 5071 5072 #endif /* __sparc */ 5073 5074 static int 5075 pt_tdb_getfpregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, 5076 prfpregset_t *fpregs) 5077 { 5078 pt_data_t *pt = t->t_data; 5079 5080 td_thrhandle_t th; 5081 td_err_e err; 5082 5083 if (t->t_pshandle == NULL) 5084 return (set_errno(EMDB_NOPROC)); 5085 5086 if ((err = pt->p_tdb_ops->td_ta_map_id2thr(tap, tid, &th)) != TD_OK) 5087 return (set_errno(tdb_to_errno(err))); 5088 5089 err = pt->p_tdb_ops->td_thr_getfpregs(&th, fpregs); 5090 if (err != TD_OK && err != TD_PARTIALREG) 5091 return (set_errno(tdb_to_errno(err))); 5092 5093 return (0); 5094 } 5095 5096 static int 5097 pt_tdb_setfpregs(mdb_tgt_t *t, void *tap, mdb_tgt_tid_t tid, 5098 const prfpregset_t *fpregs) 5099 { 5100 pt_data_t *pt = t->t_data; 5101 5102 td_thrhandle_t th; 5103 td_err_e err; 5104 5105 if (t->t_pshandle == NULL) 5106 return (set_errno(EMDB_NOPROC)); 5107 5108 if ((err = pt->p_tdb_ops->td_ta_map_id2thr(tap, tid, &th)) != TD_OK) 5109 return (set_errno(tdb_to_errno(err))); 5110 5111 err = pt->p_tdb_ops->td_thr_setfpregs(&th, fpregs); 5112 if (err != TD_OK && err != TD_PARTIALREG) 5113 return (set_errno(tdb_to_errno(err))); 5114 5115 return (0); 5116 } 5117 5118 static const pt_ptl_ops_t proc_tdb_ops = { 5119 pt_tdb_ctor, 5120 pt_tdb_dtor, 5121 pt_tdb_tid, 5122 pt_tdb_iter, 5123 pt_tdb_getregs, 5124 pt_tdb_setregs, 5125 #ifdef __sparc 5126 pt_tdb_getxregs, 5127 pt_tdb_setxregs, 5128 #endif 5129 pt_tdb_getfpregs, 5130 pt_tdb_setfpregs 5131 }; 5132 5133 static ssize_t 5134 pt_xd_auxv(mdb_tgt_t *t, void *buf, size_t nbytes) 5135 { 5136 struct ps_prochandle *P = t->t_pshandle; 5137 const auxv_t *auxp, *auxv = NULL; 5138 int auxn = 0; 5139 5140 if (P != NULL && (auxv = Pgetauxvec(P)) != NULL && 5141 auxv->a_type != AT_NULL) { 5142 for (auxp = auxv, auxn = 1; auxp->a_type != 0; auxp++) 5143 auxn++; 5144 } 5145 5146 if (buf == NULL && nbytes == 0) 5147 return (sizeof (auxv_t) * auxn); 5148 5149 if (auxn == 0) 5150 return (set_errno(ENODATA)); 5151 5152 nbytes = MIN(nbytes, sizeof (auxv_t) * auxn); 5153 bcopy(auxv, buf, nbytes); 5154 return (nbytes); 5155 } 5156 5157 static ssize_t 5158 pt_xd_cred(mdb_tgt_t *t, void *buf, size_t nbytes) 5159 { 5160 prcred_t cr, *crp; 5161 size_t cbytes = 0; 5162 5163 if (t->t_pshandle != NULL && Pcred(t->t_pshandle, &cr, 1) == 0) { 5164 cbytes = (cr.pr_ngroups <= 1) ? sizeof (prcred_t) : 5165 (sizeof (prcred_t) + (cr.pr_ngroups - 1) * sizeof (gid_t)); 5166 } 5167 5168 if (buf == NULL && nbytes == 0) 5169 return (cbytes); 5170 5171 if (cbytes == 0) 5172 return (set_errno(ENODATA)); 5173 5174 crp = mdb_alloc(cbytes, UM_SLEEP); 5175 5176 if (Pcred(t->t_pshandle, crp, cr.pr_ngroups) == -1) 5177 return (set_errno(ENODATA)); 5178 5179 nbytes = MIN(nbytes, cbytes); 5180 bcopy(crp, buf, nbytes); 5181 mdb_free(crp, cbytes); 5182 return (nbytes); 5183 } 5184 5185 static ssize_t 5186 pt_xd_ehdr(mdb_tgt_t *t, void *buf, size_t nbytes) 5187 { 5188 pt_data_t *pt = t->t_data; 5189 5190 if (buf == NULL && nbytes == 0) 5191 return (sizeof (GElf_Ehdr)); 5192 5193 if (pt->p_file == NULL) 5194 return (set_errno(ENODATA)); 5195 5196 nbytes = MIN(nbytes, sizeof (GElf_Ehdr)); 5197 bcopy(&pt->p_file->gf_ehdr, buf, nbytes); 5198 return (nbytes); 5199 } 5200 5201 static int 5202 pt_copy_lwp(lwpstatus_t **lspp, const lwpstatus_t *lsp) 5203 { 5204 bcopy(lsp, *lspp, sizeof (lwpstatus_t)); 5205 (*lspp)++; 5206 return (0); 5207 } 5208 5209 static ssize_t 5210 pt_xd_lwpstatus(mdb_tgt_t *t, void *buf, size_t nbytes) 5211 { 5212 lwpstatus_t *lsp, *lbuf; 5213 const pstatus_t *psp; 5214 int nlwp = 0; 5215 5216 if (t->t_pshandle != NULL && (psp = Pstatus(t->t_pshandle)) != NULL) 5217 nlwp = psp->pr_nlwp; 5218 5219 if (buf == NULL && nbytes == 0) 5220 return (sizeof (lwpstatus_t) * nlwp); 5221 5222 if (nlwp == 0) 5223 return (set_errno(ENODATA)); 5224 5225 lsp = lbuf = mdb_alloc(sizeof (lwpstatus_t) * nlwp, UM_SLEEP); 5226 nbytes = MIN(nbytes, sizeof (lwpstatus_t) * nlwp); 5227 5228 (void) Plwp_iter(t->t_pshandle, (proc_lwp_f *)pt_copy_lwp, &lsp); 5229 bcopy(lbuf, buf, nbytes); 5230 5231 mdb_free(lbuf, sizeof (lwpstatus_t) * nlwp); 5232 return (nbytes); 5233 } 5234 5235 static ssize_t 5236 pt_xd_pshandle(mdb_tgt_t *t, void *buf, size_t nbytes) 5237 { 5238 if (buf == NULL && nbytes == 0) 5239 return (sizeof (struct ps_prochandle *)); 5240 5241 if (t->t_pshandle == NULL || nbytes != sizeof (struct ps_prochandle *)) 5242 return (set_errno(ENODATA)); 5243 5244 bcopy(&t->t_pshandle, buf, nbytes); 5245 return (nbytes); 5246 } 5247 5248 static ssize_t 5249 pt_xd_psinfo(mdb_tgt_t *t, void *buf, size_t nbytes) 5250 { 5251 const psinfo_t *psp; 5252 5253 if (buf == NULL && nbytes == 0) 5254 return (sizeof (psinfo_t)); 5255 5256 if (t->t_pshandle == NULL || (psp = Ppsinfo(t->t_pshandle)) == NULL) 5257 return (set_errno(ENODATA)); 5258 5259 nbytes = MIN(nbytes, sizeof (psinfo_t)); 5260 bcopy(psp, buf, nbytes); 5261 return (nbytes); 5262 } 5263 5264 static ssize_t 5265 pt_xd_pstatus(mdb_tgt_t *t, void *buf, size_t nbytes) 5266 { 5267 const pstatus_t *psp; 5268 5269 if (buf == NULL && nbytes == 0) 5270 return (sizeof (pstatus_t)); 5271 5272 if (t->t_pshandle == NULL || (psp = Pstatus(t->t_pshandle)) == NULL) 5273 return (set_errno(ENODATA)); 5274 5275 nbytes = MIN(nbytes, sizeof (pstatus_t)); 5276 bcopy(psp, buf, nbytes); 5277 return (nbytes); 5278 } 5279 5280 static ssize_t 5281 pt_xd_utsname(mdb_tgt_t *t, void *buf, size_t nbytes) 5282 { 5283 struct utsname uts; 5284 5285 if (buf == NULL && nbytes == 0) 5286 return (sizeof (struct utsname)); 5287 5288 if (t->t_pshandle == NULL || Puname(t->t_pshandle, &uts) != 0) 5289 return (set_errno(ENODATA)); 5290 5291 nbytes = MIN(nbytes, sizeof (struct utsname)); 5292 bcopy(&uts, buf, nbytes); 5293 return (nbytes); 5294 } 5295 5296 int 5297 mdb_proc_tgt_create(mdb_tgt_t *t, int argc, const char *argv[]) 5298 { 5299 pt_data_t *pt = mdb_zalloc(sizeof (pt_data_t), UM_SLEEP); 5300 5301 const char *aout_path = argc > 0 ? argv[0] : PT_EXEC_PATH; 5302 const char *core_path = argc > 1 ? argv[1] : NULL; 5303 5304 const mdb_tgt_regdesc_t *rdp; 5305 char execname[MAXPATHLEN]; 5306 struct stat64 st; 5307 int perr; 5308 int state = 0; 5309 struct rlimit rlim; 5310 int i; 5311 5312 if (argc > 2) { 5313 mdb_free(pt, sizeof (pt_data_t)); 5314 return (set_errno(EINVAL)); 5315 } 5316 5317 if (t->t_flags & MDB_TGT_F_RDWR) 5318 pt->p_oflags = O_RDWR; 5319 else 5320 pt->p_oflags = O_RDONLY; 5321 5322 if (t->t_flags & MDB_TGT_F_FORCE) 5323 pt->p_gflags |= PGRAB_FORCE; 5324 if (t->t_flags & MDB_TGT_F_NOSTOP) 5325 pt->p_gflags |= PGRAB_NOSTOP; 5326 5327 pt->p_ptl_ops = &proc_lwp_ops; 5328 pt->p_maxsig = sysconf(_SC_SIGRT_MAX); 5329 5330 (void) mdb_nv_create(&pt->p_regs, UM_SLEEP); 5331 (void) mdb_nv_create(&pt->p_env, UM_SLEEP); 5332 5333 t->t_ops = &proc_ops; 5334 t->t_data = pt; 5335 5336 /* 5337 * If no core file name was specified, but the file ./core is present, 5338 * infer that we want to debug it. I find this behavior confusing, 5339 * so we only do this when precise adb(1) compatibility is required. 5340 */ 5341 if (core_path == NULL && (mdb.m_flags & MDB_FL_ADB) && 5342 access(PT_CORE_PATH, F_OK) == 0) 5343 core_path = PT_CORE_PATH; 5344 5345 /* 5346 * For compatibility with adb(1), the special name "-" may be used 5347 * to suppress the loading of the executable or core file. 5348 */ 5349 if (aout_path != NULL && strcmp(aout_path, "-") == 0) 5350 aout_path = NULL; 5351 if (core_path != NULL && strcmp(core_path, "-") == 0) 5352 core_path = NULL; 5353 5354 /* 5355 * If a core file or pid was specified, attempt to grab it now using 5356 * proc_arg_grab(); otherwise we'll create a fresh process later. 5357 */ 5358 if (core_path != NULL && (t->t_pshandle = proc_arg_xgrab(core_path, 5359 aout_path == PT_EXEC_PATH ? NULL : aout_path, PR_ARG_ANY, 5360 pt->p_gflags, &perr, NULL)) == NULL) { 5361 mdb_warn("cannot debug %s: %s\n", core_path, Pgrab_error(perr)); 5362 goto err; 5363 } 5364 5365 if (aout_path != NULL && 5366 (pt->p_idlehandle = Pgrab_file(aout_path, &perr)) != NULL && 5367 t->t_pshandle == NULL) 5368 t->t_pshandle = pt->p_idlehandle; 5369 5370 if (t->t_pshandle != NULL) 5371 state = Pstate(t->t_pshandle); 5372 5373 /* 5374 * Make sure we'll have enough file descriptors to handle a target 5375 * has many many mappings. 5376 */ 5377 if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) { 5378 rlim.rlim_cur = rlim.rlim_max; 5379 (void) setrlimit(RLIMIT_NOFILE, &rlim); 5380 (void) enable_extended_FILE_stdio(-1, -1); 5381 } 5382 5383 /* 5384 * If we don't have an executable path or the executable path is the 5385 * /proc/<pid>/object/a.out path, but we now have a libproc handle, 5386 * attempt to derive the executable path using Pexecname(). We need 5387 * to do this in the /proc case in order to open the executable for 5388 * writing because /proc/object/<file> permission are masked with 0555. 5389 * If Pexecname() fails us, fall back to /proc/<pid>/object/a.out. 5390 */ 5391 if (t->t_pshandle != NULL && (aout_path == NULL || (stat64(aout_path, 5392 &st) == 0 && strcmp(st.st_fstype, "proc") == 0))) { 5393 GElf_Sym s; 5394 aout_path = Pexecname(t->t_pshandle, execname, MAXPATHLEN); 5395 if (aout_path == NULL && state != PS_DEAD && state != PS_IDLE) { 5396 (void) mdb_iob_snprintf(execname, sizeof (execname), 5397 "/proc/%d/object/a.out", 5398 (int)Pstatus(t->t_pshandle)->pr_pid); 5399 aout_path = execname; 5400 } 5401 if (aout_path == NULL && 5402 Plookup_by_name(t->t_pshandle, "a.out", "_start", &s) != 0) 5403 mdb_warn("warning: failed to infer pathname to " 5404 "executable; symbol table will not be available\n"); 5405 5406 mdb_dprintf(MDB_DBG_TGT, "a.out is %s\n", aout_path); 5407 } 5408 5409 /* 5410 * Attempt to open the executable file. We only want this operation 5411 * to actually cause the constructor to abort if the executable file 5412 * name was given explicitly. If we defaulted to PT_EXEC_PATH or 5413 * derived the executable using Pexecname, then we want to continue 5414 * along with p_fio and p_file set to NULL. 5415 */ 5416 if (aout_path != NULL && (pt->p_aout_fio = mdb_fdio_create_path(NULL, 5417 aout_path, pt->p_oflags, 0)) == NULL && argc > 0) { 5418 mdb_warn("failed to open %s", aout_path); 5419 goto err; 5420 } 5421 5422 /* 5423 * Now create an ELF file from the input file, if we have one. Again, 5424 * only abort the constructor if the name was given explicitly. 5425 */ 5426 if (pt->p_aout_fio != NULL && pt_open_aout(t, 5427 mdb_io_hold(pt->p_aout_fio)) == NULL && argc > 0) 5428 goto err; 5429 5430 /* 5431 * If we've successfully opened an ELF file, select the appropriate 5432 * disassembler based on the ELF header. 5433 */ 5434 if (pt->p_file != NULL) 5435 (void) mdb_dis_select(pt_disasm(&pt->p_file->gf_ehdr)); 5436 else 5437 (void) mdb_dis_select(pt_disasm(NULL)); 5438 5439 /* 5440 * Add each register described in the target ISA register description 5441 * list to our hash table of register descriptions and then add any 5442 * appropriate ISA-specific floating-point register descriptions. 5443 */ 5444 for (rdp = pt_regdesc; rdp->rd_name != NULL; rdp++) { 5445 (void) mdb_nv_insert(&pt->p_regs, rdp->rd_name, NULL, 5446 MDB_TGT_R_NVAL(rdp->rd_num, rdp->rd_flags), MDB_NV_RDONLY); 5447 } 5448 pt_addfpregs(t); 5449 5450 /* 5451 * Certain important /proc structures may be of interest to mdb 5452 * modules and their dcmds. Export these using the xdata interface: 5453 */ 5454 (void) mdb_tgt_xdata_insert(t, "auxv", 5455 "procfs auxv_t array", pt_xd_auxv); 5456 (void) mdb_tgt_xdata_insert(t, "cred", 5457 "procfs prcred_t structure", pt_xd_cred); 5458 (void) mdb_tgt_xdata_insert(t, "ehdr", 5459 "executable file GElf_Ehdr structure", pt_xd_ehdr); 5460 (void) mdb_tgt_xdata_insert(t, "lwpstatus", 5461 "procfs lwpstatus_t array", pt_xd_lwpstatus); 5462 (void) mdb_tgt_xdata_insert(t, "pshandle", 5463 "libproc proc service API handle", pt_xd_pshandle); 5464 (void) mdb_tgt_xdata_insert(t, "psinfo", 5465 "procfs psinfo_t structure", pt_xd_psinfo); 5466 (void) mdb_tgt_xdata_insert(t, "pstatus", 5467 "procfs pstatus_t structure", pt_xd_pstatus); 5468 (void) mdb_tgt_xdata_insert(t, "utsname", 5469 "utsname structure", pt_xd_utsname); 5470 5471 /* 5472 * Force a status update now so that we fill in t_status with the 5473 * latest information based on any successful grab. 5474 */ 5475 (void) mdb_tgt_status(t, &t->t_status); 5476 5477 /* 5478 * If we're not examining a core file, trace SIGINT and all signals 5479 * that cause the process to dump core as part of our initialization. 5480 */ 5481 if ((t->t_pshandle != NULL && state != PS_DEAD && state != PS_IDLE) || 5482 (pt->p_file != NULL && pt->p_file->gf_ehdr.e_type == ET_EXEC)) { 5483 5484 int tflag = MDB_TGT_SPEC_STICKY; /* default sigs are sticky */ 5485 5486 (void) mdb_tgt_add_signal(t, SIGINT, tflag, no_se_f, NULL); 5487 (void) mdb_tgt_add_signal(t, SIGQUIT, tflag, no_se_f, NULL); 5488 (void) mdb_tgt_add_signal(t, SIGILL, tflag, no_se_f, NULL); 5489 (void) mdb_tgt_add_signal(t, SIGTRAP, tflag, no_se_f, NULL); 5490 (void) mdb_tgt_add_signal(t, SIGABRT, tflag, no_se_f, NULL); 5491 (void) mdb_tgt_add_signal(t, SIGEMT, tflag, no_se_f, NULL); 5492 (void) mdb_tgt_add_signal(t, SIGFPE, tflag, no_se_f, NULL); 5493 (void) mdb_tgt_add_signal(t, SIGBUS, tflag, no_se_f, NULL); 5494 (void) mdb_tgt_add_signal(t, SIGSEGV, tflag, no_se_f, NULL); 5495 (void) mdb_tgt_add_signal(t, SIGSYS, tflag, no_se_f, NULL); 5496 (void) mdb_tgt_add_signal(t, SIGXCPU, tflag, no_se_f, NULL); 5497 (void) mdb_tgt_add_signal(t, SIGXFSZ, tflag, no_se_f, NULL); 5498 } 5499 5500 /* 5501 * If we've grabbed a live process, establish our initial breakpoints 5502 * and librtld_db agent so we can track rtld activity. If FL_VCREATE 5503 * is set, this process was created by a previous instantiation of 5504 * the debugger, so reset pr_flags to kill it; otherwise we attached 5505 * to an already running process. Pgrab() has already set the PR_RLC 5506 * flag appropriately based on whether the process was stopped when we 5507 * attached. 5508 */ 5509 if (t->t_pshandle != NULL && state != PS_DEAD && state != PS_IDLE) { 5510 if (mdb.m_flags & MDB_FL_VCREATE) { 5511 (void) Punsetflags(t->t_pshandle, PR_RLC); 5512 (void) Psetflags(t->t_pshandle, PR_KLC); 5513 pt->p_rflags = PRELEASE_KILL; 5514 } else { 5515 (void) Punsetflags(t->t_pshandle, PR_KLC); 5516 } 5517 pt_post_attach(t); 5518 } 5519 5520 /* 5521 * Initialize a local copy of the environment, which can be modified 5522 * before running the program. 5523 */ 5524 for (i = 0; mdb.m_env[i] != NULL; i++) 5525 pt_env_set(pt, mdb.m_env[i]); 5526 5527 /* 5528 * If adb(1) compatibility mode is on, then print the appropriate 5529 * greeting message if we have grabbed a core file. 5530 */ 5531 if ((mdb.m_flags & MDB_FL_ADB) && t->t_pshandle != NULL && 5532 state == PS_DEAD) { 5533 const pstatus_t *psp = Pstatus(t->t_pshandle); 5534 int cursig = psp->pr_lwp.pr_cursig; 5535 char signame[SIG2STR_MAX]; 5536 5537 mdb_printf("core file = %s -- program ``%s'' on platform %s\n", 5538 core_path, aout_path ? aout_path : "?", pt_platform(t)); 5539 5540 if (cursig != 0 && sig2str(cursig, signame) == 0) 5541 mdb_printf("SIG%s: %s\n", signame, strsignal(cursig)); 5542 } 5543 5544 return (0); 5545 5546 err: 5547 pt_destroy(t); 5548 return (-1); 5549 } 5550