1 /* 2 * Copyright (c) 2004 David Xu <davidxu@freebsd.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <stddef.h> 31 #include <stdlib.h> 32 #include <string.h> 33 #include <unistd.h> 34 #include <pthread.h> 35 #include <sys/types.h> 36 #include <sys/kse.h> 37 #include <sys/ptrace.h> 38 #include <proc_service.h> 39 #include <thread_db.h> 40 41 #include "libpthread_db.h" 42 43 #define P2T(c) ps2td(c) 44 45 static void pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp); 46 static int pt_validate(const td_thrhandle_t *th); 47 48 static int 49 ps2td(int c) 50 { 51 switch (c) { 52 case PS_OK: 53 return TD_OK; 54 case PS_ERR: 55 return TD_ERR; 56 case PS_BADPID: 57 return TD_BADPH; 58 case PS_BADLID: 59 return TD_NOLWP; 60 case PS_BADADDR: 61 return TD_ERR; 62 case PS_NOSYM: 63 return TD_NOLIBTHREAD; 64 case PS_NOFREGS: 65 return TD_NOFPREGS; 66 default: 67 return TD_ERR; 68 } 69 } 70 71 static long 72 pt_map_thread(const td_thragent_t *const_ta, psaddr_t pt, int type) 73 { 74 td_thragent_t *ta = __DECONST(td_thragent_t *, const_ta); 75 struct pt_map *new; 76 int i, first = -1; 77 78 /* leave zero out */ 79 for (i = 1; i < ta->map_len; ++i) { 80 if (ta->map[i].type == PT_NONE) { 81 if (first == -1) 82 first = i; 83 } else if (ta->map[i].type == type && ta->map[i].thr == pt) { 84 return (i); 85 } 86 } 87 88 if (first == -1) { 89 if (ta->map_len == 0) { 90 ta->map = calloc(20, sizeof(struct pt_map)); 91 if (ta->map == NULL) 92 return (-1); 93 ta->map_len = 20; 94 first = 1; 95 } else { 96 new = realloc(ta->map, 97 sizeof(struct pt_map) * ta->map_len * 2); 98 if (new == NULL) 99 return (-1); 100 memset(new + ta->map_len, '\0', sizeof(struct pt_map) * 101 ta->map_len); 102 first = ta->map_len; 103 ta->map = new; 104 ta->map_len *= 2; 105 } 106 } 107 108 ta->map[first].type = type; 109 ta->map[first].thr = pt; 110 return (first); 111 } 112 113 static td_err_e 114 pt_init(void) 115 { 116 pt_md_init(); 117 return (0); 118 } 119 120 static td_err_e 121 pt_ta_new(struct ps_prochandle *ph, td_thragent_t **pta) 122 { 123 #define LOOKUP_SYM(proc, sym, addr) \ 124 ret = ps_pglobal_lookup(proc, NULL, sym, addr); \ 125 if (ret != 0) { \ 126 TDBG("can not find symbol: %s\n", sym); \ 127 ret = TD_NOLIBTHREAD; \ 128 goto error; \ 129 } 130 131 #define LOOKUP_VAL(proc, sym, val) \ 132 ret = ps_pglobal_lookup(proc, NULL, sym, &vaddr);\ 133 if (ret != 0) { \ 134 TDBG("can not find symbol: %s\n", sym); \ 135 ret = TD_NOLIBTHREAD; \ 136 goto error; \ 137 } \ 138 ret = ps_pread(proc, vaddr, val, sizeof(int)); \ 139 if (ret != 0) { \ 140 TDBG("can not read value of %s\n", sym);\ 141 ret = TD_NOLIBTHREAD; \ 142 goto error; \ 143 } 144 145 td_thragent_t *ta; 146 psaddr_t vaddr; 147 int dbg; 148 int ret; 149 150 TDBG_FUNC(); 151 152 ta = malloc(sizeof(td_thragent_t)); 153 if (ta == NULL) 154 return (TD_MALLOC); 155 156 ta->ph = ph; 157 ta->thread_activated = 0; 158 ta->map = NULL; 159 ta->map_len = 0; 160 161 LOOKUP_SYM(ph, "_libkse_debug", &ta->libkse_debug_addr); 162 LOOKUP_SYM(ph, "_thread_list", &ta->thread_list_addr); 163 LOOKUP_SYM(ph, "_thread_activated", &ta->thread_activated_addr); 164 LOOKUP_SYM(ph, "_thread_active_threads",&ta->thread_active_threads_addr); 165 LOOKUP_SYM(ph, "_thread_keytable", &ta->thread_keytable_addr); 166 LOOKUP_VAL(ph, "_thread_off_dtv", &ta->thread_off_dtv); 167 LOOKUP_VAL(ph, "_thread_off_kse_locklevel", &ta->thread_off_kse_locklevel); 168 LOOKUP_VAL(ph, "_thread_off_kse", &ta->thread_off_kse); 169 LOOKUP_VAL(ph, "_thread_off_tlsindex", &ta->thread_off_tlsindex); 170 LOOKUP_VAL(ph, "_thread_off_attr_flags", &ta->thread_off_attr_flags); 171 LOOKUP_VAL(ph, "_thread_size_key", &ta->thread_size_key); 172 LOOKUP_VAL(ph, "_thread_off_tcb", &ta->thread_off_tcb); 173 LOOKUP_VAL(ph, "_thread_off_linkmap", &ta->thread_off_linkmap); 174 LOOKUP_VAL(ph, "_thread_off_tmbx", &ta->thread_off_tmbx); 175 LOOKUP_VAL(ph, "_thread_off_thr_locklevel", &ta->thread_off_thr_locklevel); 176 LOOKUP_VAL(ph, "_thread_off_next", &ta->thread_off_next); 177 LOOKUP_VAL(ph, "_thread_off_state", &ta->thread_off_state); 178 LOOKUP_VAL(ph, "_thread_max_keys", &ta->thread_max_keys); 179 LOOKUP_VAL(ph, "_thread_off_key_allocated", &ta->thread_off_key_allocated); 180 LOOKUP_VAL(ph, "_thread_off_key_destructor", &ta->thread_off_key_destructor); 181 LOOKUP_VAL(ph, "_thread_state_running", &ta->thread_state_running); 182 LOOKUP_VAL(ph, "_thread_state_zoombie", &ta->thread_state_zoombie); 183 dbg = getpid(); 184 /* 185 * If this fails it probably means we're debugging a core file and 186 * can't write to it. 187 */ 188 ps_pwrite(ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 189 *pta = ta; 190 return (0); 191 192 error: 193 free(ta); 194 return (ret); 195 } 196 197 static td_err_e 198 pt_ta_delete(td_thragent_t *ta) 199 { 200 int dbg; 201 202 TDBG_FUNC(); 203 204 dbg = 0; 205 /* 206 * Error returns from this write are not really a problem; 207 * the process doesn't exist any more. 208 */ 209 ps_pwrite(ta->ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 210 if (ta->map) 211 free(ta->map); 212 free(ta); 213 return (TD_OK); 214 } 215 216 static td_err_e 217 pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th) 218 { 219 prgregset_t gregs; 220 TAILQ_HEAD(, pthread) thread_list; 221 psaddr_t pt, tcb_addr; 222 lwpid_t lwp; 223 int ret; 224 225 TDBG_FUNC(); 226 227 if (id < 0 || id >= ta->map_len || ta->map[id].type == PT_NONE) 228 return (TD_NOTHR); 229 ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 230 sizeof(thread_list)); 231 if (ret != 0) 232 return (P2T(ret)); 233 pt = (psaddr_t)thread_list.tqh_first; 234 if (ta->map[id].type == PT_LWP) { 235 /* 236 * if we are referencing a lwp, make sure it was not already 237 * mapped to user thread. 238 */ 239 while (pt != 0) { 240 ret = ps_pread(ta->ph, 241 pt + ta->thread_off_tcb, 242 &tcb_addr, sizeof(tcb_addr)); 243 if (ret != 0) 244 return (P2T(ret)); 245 ret = ps_pread(ta->ph, 246 tcb_addr + ta->thread_off_tmbx + 247 offsetof(struct kse_thr_mailbox, tm_lwp), 248 &lwp, sizeof(lwp)); 249 if (ret != 0) 250 return (P2T(ret)); 251 /* 252 * If the lwp was already mapped to userland thread, 253 * we shouldn't reference it directly in future. 254 */ 255 if (lwp == ta->map[id].lwp) { 256 ta->map[id].type = PT_NONE; 257 return (TD_NOTHR); 258 } 259 /* get next thread */ 260 ret = ps_pread(ta->ph, 261 pt + ta->thread_off_next, 262 &pt, sizeof(pt)); 263 if (ret != 0) 264 return (P2T(ret)); 265 } 266 /* check lwp */ 267 ret = ps_lgetregs(ta->ph, ta->map[id].lwp, gregs); 268 if (ret != PS_OK) { 269 /* no longer exists */ 270 ta->map[id].type = PT_NONE; 271 return (TD_NOTHR); 272 } 273 } else { 274 while (pt != 0 && ta->map[id].thr != pt) { 275 ret = ps_pread(ta->ph, 276 pt + ta->thread_off_tcb, 277 &tcb_addr, sizeof(tcb_addr)); 278 if (ret != 0) 279 return (P2T(ret)); 280 /* get next thread */ 281 ret = ps_pread(ta->ph, 282 pt + ta->thread_off_next, 283 &pt, sizeof(pt)); 284 if (ret != 0) 285 return (P2T(ret)); 286 } 287 288 if (pt == 0) { 289 /* no longer exists */ 290 ta->map[id].type = PT_NONE; 291 return (TD_NOTHR); 292 } 293 } 294 th->th_ta = ta; 295 th->th_tid = id; 296 th->th_thread = pt; 297 return (TD_OK); 298 } 299 300 static td_err_e 301 pt_ta_map_lwp2thr(const td_thragent_t *ta, lwpid_t lwp, td_thrhandle_t *th) 302 { 303 TAILQ_HEAD(, pthread) thread_list; 304 psaddr_t pt, ptr; 305 lwpid_t tmp_lwp; 306 int ret; 307 308 TDBG_FUNC(); 309 310 ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 311 sizeof(thread_list)); 312 if (ret != 0) 313 return (P2T(ret)); 314 pt = (psaddr_t)thread_list.tqh_first; 315 while (pt != 0) { 316 ret = ps_pread(ta->ph, pt + ta->thread_off_tcb, 317 &ptr, sizeof(ptr)); 318 if (ret != 0) 319 return (P2T(ret)); 320 ptr += ta->thread_off_tmbx + 321 offsetof(struct kse_thr_mailbox, tm_lwp); 322 ret = ps_pread(ta->ph, ptr, &tmp_lwp, sizeof(lwpid_t)); 323 if (ret != 0) 324 return (P2T(ret)); 325 if (tmp_lwp == lwp) { 326 th->th_ta = ta; 327 th->th_tid = pt_map_thread(ta, pt, PT_USER); 328 if (th->th_tid == -1) 329 return (TD_MALLOC); 330 pt_unmap_lwp(ta, lwp); 331 th->th_thread = pt; 332 return (TD_OK); 333 } 334 335 /* get next thread */ 336 ret = ps_pread(ta->ph, 337 pt + ta->thread_off_next, 338 &pt, sizeof(pt)); 339 if (ret != 0) 340 return (P2T(ret)); 341 } 342 343 return (TD_NOTHR); 344 } 345 346 static td_err_e 347 pt_ta_thr_iter(const td_thragent_t *ta, 348 td_thr_iter_f *callback, void *cbdata_p, 349 td_thr_state_e state, int ti_pri, 350 sigset_t *ti_sigmask_p, 351 unsigned int ti_user_flags) 352 { 353 TAILQ_HEAD(, pthread) thread_list; 354 td_thrhandle_t th; 355 psaddr_t pt; 356 ps_err_e pserr; 357 int activated; 358 359 TDBG_FUNC(); 360 361 pserr = ps_pread(ta->ph, ta->thread_activated_addr, &activated, 362 sizeof(int)); 363 if (pserr != PS_OK) 364 return (P2T(pserr)); 365 if (!activated) 366 return (TD_OK); 367 368 pserr = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 369 sizeof(thread_list)); 370 if (pserr != 0) 371 return (P2T(pserr)); 372 pt = (psaddr_t)thread_list.tqh_first; 373 while (pt != 0) { 374 th.th_ta = ta; 375 th.th_tid = pt_map_thread(ta, pt, PT_USER); 376 th.th_thread = pt; 377 /* should we unmap lwp here ? */ 378 if (th.th_tid == -1) 379 return (TD_MALLOC); 380 if ((*callback)(&th, cbdata_p)) 381 return (TD_DBERR); 382 /* get next thread */ 383 pserr = ps_pread(ta->ph, 384 pt + ta->thread_off_next, &pt, 385 sizeof(pt)); 386 if (pserr != PS_OK) 387 return (P2T(pserr)); 388 } 389 return (TD_OK); 390 } 391 392 static td_err_e 393 pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg) 394 { 395 char *keytable; 396 void *destructor; 397 int i, ret, allocated; 398 399 TDBG_FUNC(); 400 401 keytable = malloc(ta->thread_max_keys * ta->thread_size_key); 402 if (keytable == NULL) 403 return (TD_MALLOC); 404 ret = ps_pread(ta->ph, (psaddr_t)ta->thread_keytable_addr, keytable, 405 ta->thread_max_keys * ta->thread_size_key); 406 if (ret != 0) { 407 free(keytable); 408 return (P2T(ret)); 409 } 410 for (i = 0; i < ta->thread_max_keys; i++) { 411 allocated = *(int *)(keytable + i * ta->thread_size_key + 412 ta->thread_off_key_allocated); 413 destructor = *(void **)(keytable + i * ta->thread_size_key + 414 ta->thread_off_key_destructor); 415 if (allocated) { 416 ret = (ki)(i, destructor, arg); 417 if (ret != 0) { 418 free(keytable); 419 return (TD_DBERR); 420 } 421 } 422 } 423 free(keytable); 424 return (TD_OK); 425 } 426 427 static td_err_e 428 pt_ta_event_addr(const td_thragent_t *ta, td_event_e event, td_notify_t *ptr) 429 { 430 TDBG_FUNC(); 431 return (TD_ERR); 432 } 433 434 static td_err_e 435 pt_ta_set_event(const td_thragent_t *ta, td_thr_events_t *events) 436 { 437 TDBG_FUNC(); 438 return (0); 439 } 440 441 static td_err_e 442 pt_ta_clear_event(const td_thragent_t *ta, td_thr_events_t *events) 443 { 444 TDBG_FUNC(); 445 return (0); 446 } 447 448 static td_err_e 449 pt_ta_event_getmsg(const td_thragent_t *ta, td_event_msg_t *msg) 450 { 451 TDBG_FUNC(); 452 return (TD_NOMSG); 453 } 454 455 static td_err_e 456 pt_dbsuspend(const td_thrhandle_t *th, int suspend) 457 { 458 td_thragent_t *ta = (td_thragent_t *)th->th_ta; 459 psaddr_t tcb_addr, tmbx_addr, ptr; 460 lwpid_t lwp; 461 uint32_t dflags; 462 int attrflags, locklevel, ret; 463 464 TDBG_FUNC(); 465 466 ret = pt_validate(th); 467 if (ret) 468 return (ret); 469 470 if (ta->map[th->th_tid].type == PT_LWP) { 471 if (suspend) 472 ret = ps_lstop(ta->ph, ta->map[th->th_tid].lwp); 473 else 474 ret = ps_lcontinue(ta->ph, ta->map[th->th_tid].lwp); 475 return (P2T(ret)); 476 } 477 478 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 479 ta->thread_off_attr_flags, 480 &attrflags, sizeof(attrflags)); 481 if (ret != 0) 482 return (P2T(ret)); 483 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 484 ta->thread_off_tcb, 485 &tcb_addr, sizeof(tcb_addr)); 486 if (ret != 0) 487 return (P2T(ret)); 488 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 489 ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 490 ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 491 if (ret != 0) 492 return (P2T(ret)); 493 494 if (lwp != 0) { 495 /* don't suspend signal thread */ 496 if (attrflags & 0x200) 497 return (0); 498 if (attrflags & PTHREAD_SCOPE_SYSTEM) { 499 /* 500 * don't suspend system scope thread if it is holding 501 * some low level locks 502 */ 503 ptr = ta->map[th->th_tid].thr + ta->thread_off_kse; 504 ret = ps_pread(ta->ph, ptr, &ptr, sizeof(ptr)); 505 if (ret != 0) 506 return (P2T(ret)); 507 ret = ps_pread(ta->ph, ptr + ta->thread_off_kse_locklevel, 508 &locklevel, sizeof(int)); 509 if (ret != 0) 510 return (P2T(ret)); 511 if (locklevel <= 0) { 512 ptr = ta->map[th->th_tid].thr + 513 ta->thread_off_thr_locklevel; 514 ret = ps_pread(ta->ph, ptr, &locklevel, 515 sizeof(int)); 516 if (ret != 0) 517 return (P2T(ret)); 518 } 519 if (suspend) { 520 if (locklevel <= 0) 521 ret = ps_lstop(ta->ph, lwp); 522 } else { 523 ret = ps_lcontinue(ta->ph, lwp); 524 } 525 if (ret != 0) 526 return (P2T(ret)); 527 /* FALLTHROUGH */ 528 } else { 529 struct ptrace_lwpinfo pl; 530 531 if (ps_linfo(ta->ph, lwp, (caddr_t)&pl)) 532 return (TD_ERR); 533 if (suspend) { 534 if (!(pl.pl_flags & PL_FLAG_BOUND)) 535 ret = ps_lstop(ta->ph, lwp); 536 } else { 537 ret = ps_lcontinue(ta->ph, lwp); 538 } 539 if (ret != 0) 540 return (P2T(ret)); 541 /* FALLTHROUGH */ 542 } 543 } 544 /* read tm_dflags */ 545 ret = ps_pread(ta->ph, 546 tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 547 &dflags, sizeof(dflags)); 548 if (ret != 0) 549 return (P2T(ret)); 550 if (suspend) 551 dflags |= TMDF_SUSPEND; 552 else 553 dflags &= ~TMDF_SUSPEND; 554 ret = ps_pwrite(ta->ph, 555 tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 556 &dflags, sizeof(dflags)); 557 return (P2T(ret)); 558 } 559 560 static td_err_e 561 pt_thr_dbresume(const td_thrhandle_t *th) 562 { 563 TDBG_FUNC(); 564 565 return pt_dbsuspend(th, 0); 566 } 567 568 static td_err_e 569 pt_thr_dbsuspend(const td_thrhandle_t *th) 570 { 571 TDBG_FUNC(); 572 573 return pt_dbsuspend(th, 1); 574 } 575 576 static td_err_e 577 pt_thr_validate(const td_thrhandle_t *th) 578 { 579 td_thrhandle_t temp; 580 int ret; 581 582 TDBG_FUNC(); 583 584 ret = pt_ta_map_id2thr(th->th_ta, th->th_tid, 585 &temp); 586 return (ret); 587 } 588 589 static td_err_e 590 pt_thr_get_info(const td_thrhandle_t *th, td_thrinfo_t *info) 591 { 592 const td_thragent_t *ta = th->th_ta; 593 psaddr_t tcb_addr; 594 uint32_t dflags; 595 int state; 596 int ret; 597 598 TDBG_FUNC(); 599 600 bzero(info, sizeof(*info)); 601 ret = pt_validate(th); 602 if (ret) 603 return (ret); 604 605 memset(info, 0, sizeof(*info)); 606 if (ta->map[th->th_tid].type == PT_LWP) { 607 info->ti_type = TD_THR_SYSTEM; 608 info->ti_lid = ta->map[th->th_tid].lwp; 609 info->ti_tid = th->th_tid; 610 info->ti_state = TD_THR_RUN; 611 info->ti_type = TD_THR_SYSTEM; 612 return (TD_OK); 613 } 614 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 615 &tcb_addr, sizeof(tcb_addr)); 616 if (ret != 0) 617 return (P2T(ret)); 618 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_state, 619 &state, sizeof(state)); 620 ret = ps_pread(ta->ph, 621 tcb_addr + ta->thread_off_tmbx + 622 offsetof(struct kse_thr_mailbox, tm_lwp), 623 &info->ti_lid, sizeof(lwpid_t)); 624 if (ret != 0) 625 return (P2T(ret)); 626 ret = ps_pread(ta->ph, 627 tcb_addr + ta->thread_off_tmbx + 628 offsetof(struct kse_thr_mailbox, tm_dflags), 629 &dflags, sizeof(dflags)); 630 if (ret != 0) 631 return (P2T(ret)); 632 info->ti_ta_p = th->th_ta; 633 info->ti_tid = th->th_tid; 634 if (state == ta->thread_state_running) 635 info->ti_state = TD_THR_RUN; 636 else if (state == ta->thread_state_zoombie) 637 info->ti_state = TD_THR_ZOMBIE; 638 else 639 info->ti_state = TD_THR_SLEEP; 640 info->ti_db_suspended = ((dflags & TMDF_SUSPEND) != 0); 641 info->ti_type = TD_THR_USER; 642 return (0); 643 } 644 645 #ifdef __i386__ 646 static td_err_e 647 pt_thr_getxmmregs(const td_thrhandle_t *th, char *fxsave) 648 { 649 const td_thragent_t *ta = th->th_ta; 650 struct kse_thr_mailbox tmbx; 651 psaddr_t tcb_addr, tmbx_addr, ptr; 652 lwpid_t lwp; 653 int ret; 654 655 return TD_ERR; 656 657 TDBG_FUNC(); 658 659 ret = pt_validate(th); 660 if (ret) 661 return (ret); 662 663 if (ta->map[th->th_tid].type == PT_LWP) { 664 ret = ps_lgetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave); 665 return (P2T(ret)); 666 } 667 668 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 669 &tcb_addr, sizeof(tcb_addr)); 670 if (ret != 0) 671 return (P2T(ret)); 672 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 673 ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 674 ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 675 if (ret != 0) 676 return (P2T(ret)); 677 if (lwp != 0) { 678 ret = ps_lgetxmmregs(ta->ph, lwp, fxsave); 679 return (P2T(ret)); 680 } 681 682 ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 683 if (ret != 0) 684 return (P2T(ret)); 685 pt_ucontext_to_fxsave(&tmbx.tm_context, fxsave); 686 return (0); 687 } 688 #endif 689 690 static td_err_e 691 pt_thr_getfpregs(const td_thrhandle_t *th, prfpregset_t *fpregs) 692 { 693 const td_thragent_t *ta = th->th_ta; 694 struct kse_thr_mailbox tmbx; 695 psaddr_t tcb_addr, tmbx_addr, ptr; 696 lwpid_t lwp; 697 int ret; 698 699 TDBG_FUNC(); 700 701 ret = pt_validate(th); 702 if (ret) 703 return (ret); 704 705 if (ta->map[th->th_tid].type == PT_LWP) { 706 ret = ps_lgetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 707 return (P2T(ret)); 708 } 709 710 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 711 &tcb_addr, sizeof(tcb_addr)); 712 if (ret != 0) 713 return (P2T(ret)); 714 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 715 ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 716 ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 717 if (ret != 0) 718 return (P2T(ret)); 719 if (lwp != 0) { 720 ret = ps_lgetfpregs(ta->ph, lwp, fpregs); 721 return (P2T(ret)); 722 } 723 724 ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 725 if (ret != 0) 726 return (P2T(ret)); 727 pt_ucontext_to_fpreg(&tmbx.tm_context, fpregs); 728 return (0); 729 } 730 731 static td_err_e 732 pt_thr_getgregs(const td_thrhandle_t *th, prgregset_t gregs) 733 { 734 const td_thragent_t *ta = th->th_ta; 735 struct kse_thr_mailbox tmbx; 736 psaddr_t tcb_addr, tmbx_addr, ptr; 737 lwpid_t lwp; 738 int ret; 739 740 TDBG_FUNC(); 741 742 ret = pt_validate(th); 743 if (ret) 744 return (ret); 745 746 if (ta->map[th->th_tid].type == PT_LWP) { 747 ret = ps_lgetregs(ta->ph, 748 ta->map[th->th_tid].lwp, gregs); 749 return (P2T(ret)); 750 } 751 752 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 753 &tcb_addr, sizeof(tcb_addr)); 754 if (ret != 0) 755 return (P2T(ret)); 756 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 757 ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 758 ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 759 if (ret != 0) 760 return (P2T(ret)); 761 if (lwp != 0) { 762 ret = ps_lgetregs(ta->ph, lwp, gregs); 763 return (P2T(ret)); 764 } 765 ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 766 if (ret != 0) 767 return (P2T(ret)); 768 pt_ucontext_to_reg(&tmbx.tm_context, gregs); 769 return (0); 770 } 771 772 #ifdef __i386__ 773 static td_err_e 774 pt_thr_setxmmregs(const td_thrhandle_t *th, const char *fxsave) 775 { 776 const td_thragent_t *ta = th->th_ta; 777 struct kse_thr_mailbox tmbx; 778 psaddr_t tcb_addr, tmbx_addr, ptr; 779 lwpid_t lwp; 780 int ret; 781 782 return TD_ERR; 783 784 TDBG_FUNC(); 785 786 ret = pt_validate(th); 787 if (ret) 788 return (ret); 789 790 if (ta->map[th->th_tid].type == PT_LWP) { 791 ret = ps_lsetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave); 792 return (P2T(ret)); 793 } 794 795 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 796 ta->thread_off_tcb, 797 &tcb_addr, sizeof(tcb_addr)); 798 if (ret != 0) 799 return (P2T(ret)); 800 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 801 ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 802 ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 803 if (ret != 0) 804 return (P2T(ret)); 805 if (lwp != 0) { 806 ret = ps_lsetxmmregs(ta->ph, lwp, fxsave); 807 return (P2T(ret)); 808 } 809 /* 810 * Read a copy of context, this makes sure that registers 811 * not covered by structure reg won't be clobbered 812 */ 813 ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 814 if (ret != 0) 815 return (P2T(ret)); 816 817 pt_fxsave_to_ucontext(fxsave, &tmbx.tm_context); 818 ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 819 return (P2T(ret)); 820 } 821 #endif 822 823 static td_err_e 824 pt_thr_setfpregs(const td_thrhandle_t *th, const prfpregset_t *fpregs) 825 { 826 const td_thragent_t *ta = th->th_ta; 827 struct kse_thr_mailbox tmbx; 828 psaddr_t tcb_addr, tmbx_addr, ptr; 829 lwpid_t lwp; 830 int ret; 831 832 TDBG_FUNC(); 833 834 ret = pt_validate(th); 835 if (ret) 836 return (ret); 837 838 if (ta->map[th->th_tid].type == PT_LWP) { 839 ret = ps_lsetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 840 return (P2T(ret)); 841 } 842 843 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 844 ta->thread_off_tcb, 845 &tcb_addr, sizeof(tcb_addr)); 846 if (ret != 0) 847 return (P2T(ret)); 848 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 849 ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 850 ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 851 if (ret != 0) 852 return (P2T(ret)); 853 if (lwp != 0) { 854 ret = ps_lsetfpregs(ta->ph, lwp, fpregs); 855 return (P2T(ret)); 856 } 857 /* 858 * Read a copy of context, this makes sure that registers 859 * not covered by structure reg won't be clobbered 860 */ 861 ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 862 if (ret != 0) 863 return (P2T(ret)); 864 865 pt_fpreg_to_ucontext(fpregs, &tmbx.tm_context); 866 ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 867 return (P2T(ret)); 868 } 869 870 static td_err_e 871 pt_thr_setgregs(const td_thrhandle_t *th, const prgregset_t gregs) 872 { 873 const td_thragent_t *ta = th->th_ta; 874 struct kse_thr_mailbox tmbx; 875 psaddr_t tcb_addr, tmbx_addr, ptr; 876 lwpid_t lwp; 877 int ret; 878 879 TDBG_FUNC(); 880 881 ret = pt_validate(th); 882 if (ret) 883 return (ret); 884 885 if (ta->map[th->th_tid].type == PT_LWP) { 886 ret = ps_lsetregs(ta->ph, ta->map[th->th_tid].lwp, gregs); 887 return (P2T(ret)); 888 } 889 890 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 891 ta->thread_off_tcb, 892 &tcb_addr, sizeof(tcb_addr)); 893 if (ret != 0) 894 return (P2T(ret)); 895 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 896 ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 897 ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 898 if (ret != 0) 899 return (P2T(ret)); 900 if (lwp != 0) { 901 ret = ps_lsetregs(ta->ph, lwp, gregs); 902 return (P2T(ret)); 903 } 904 905 /* 906 * Read a copy of context, make sure that registers 907 * not covered by structure reg won't be clobbered 908 */ 909 ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 910 if (ret != 0) 911 return (P2T(ret)); 912 pt_reg_to_ucontext(gregs, &tmbx.tm_context); 913 ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 914 return (P2T(ret)); 915 } 916 917 static td_err_e 918 pt_thr_event_enable(const td_thrhandle_t *th, int en) 919 { 920 TDBG_FUNC(); 921 return (0); 922 } 923 924 static td_err_e 925 pt_thr_set_event(const td_thrhandle_t *th, td_thr_events_t *setp) 926 { 927 TDBG_FUNC(); 928 return (0); 929 } 930 931 static td_err_e 932 pt_thr_clear_event(const td_thrhandle_t *th, td_thr_events_t *setp) 933 { 934 TDBG_FUNC(); 935 return (0); 936 } 937 938 static td_err_e 939 pt_thr_event_getmsg(const td_thrhandle_t *th, td_event_msg_t *msg) 940 { 941 TDBG_FUNC(); 942 return (TD_NOMSG); 943 } 944 945 static td_err_e 946 pt_thr_sstep(const td_thrhandle_t *th, int step) 947 { 948 const td_thragent_t *ta = th->th_ta; 949 struct kse_thr_mailbox tmbx; 950 struct reg regs; 951 psaddr_t tcb_addr, tmbx_addr; 952 uint32_t dflags; 953 lwpid_t lwp; 954 int ret; 955 956 TDBG_FUNC(); 957 958 ret = pt_validate(th); 959 if (ret) 960 return (ret); 961 962 if (ta->map[th->th_tid].type == PT_LWP) 963 return (TD_BADTH); 964 965 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 966 ta->thread_off_tcb, 967 &tcb_addr, sizeof(tcb_addr)); 968 if (ret != 0) 969 return (P2T(ret)); 970 971 /* Clear or set single step flag in thread mailbox */ 972 ret = ps_pread(ta->ph, 973 tcb_addr + ta->thread_off_tmbx + 974 offsetof(struct kse_thr_mailbox, tm_dflags), 975 &dflags, sizeof(uint32_t)); 976 if (ret != 0) 977 return (P2T(ret)); 978 if (step != 0) 979 dflags |= TMDF_SSTEP; 980 else 981 dflags &= ~TMDF_SSTEP; 982 ret = ps_pwrite(ta->ph, 983 tcb_addr + ta->thread_off_tmbx + 984 offsetof(struct kse_thr_mailbox, tm_dflags), 985 &dflags, sizeof(uint32_t)); 986 if (ret != 0) 987 return (P2T(ret)); 988 /* Get lwp */ 989 ret = ps_pread(ta->ph, 990 tcb_addr + ta->thread_off_tmbx + 991 offsetof(struct kse_thr_mailbox, tm_lwp), 992 &lwp, sizeof(lwpid_t)); 993 if (ret != 0) 994 return (P2T(ret)); 995 if (lwp != 0) 996 return (0); 997 998 tmbx_addr = tcb_addr + ta->thread_off_tmbx; 999 /* 1000 * context is in userland, some architectures store 1001 * single step status in registers, we should change 1002 * these registers. 1003 */ 1004 ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 1005 if (ret == 0) { 1006 pt_ucontext_to_reg(&tmbx.tm_context, ®s); 1007 /* only write out if it is really changed. */ 1008 if (pt_reg_sstep(®s, step) != 0) { 1009 pt_reg_to_ucontext(®s, &tmbx.tm_context); 1010 ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, 1011 sizeof(tmbx)); 1012 } 1013 } 1014 return (P2T(ret)); 1015 } 1016 1017 static void 1018 pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp) 1019 { 1020 int i; 1021 1022 for (i = 0; i < ta->map_len; ++i) { 1023 if (ta->map[i].type == PT_LWP && ta->map[i].lwp == lwp) { 1024 ta->map[i].type = PT_NONE; 1025 return; 1026 } 1027 } 1028 } 1029 1030 static int 1031 pt_validate(const td_thrhandle_t *th) 1032 { 1033 1034 if (th->th_tid < 0 || th->th_tid >= th->th_ta->map_len || 1035 th->th_ta->map[th->th_tid].type == PT_NONE) 1036 return (TD_NOTHR); 1037 return (TD_OK); 1038 } 1039 1040 td_err_e 1041 pt_thr_tls_get_addr(const td_thrhandle_t *th, void *_linkmap, size_t offset, 1042 void **address) 1043 { 1044 char *obj_entry; 1045 const td_thragent_t *ta = th->th_ta; 1046 psaddr_t tcb_addr, *dtv_addr; 1047 int tls_index, ret; 1048 1049 /* linkmap is a member of Obj_Entry */ 1050 obj_entry = (char *)_linkmap - ta->thread_off_linkmap; 1051 1052 /* get tlsindex of the object file */ 1053 ret = ps_pread(ta->ph, 1054 obj_entry + ta->thread_off_tlsindex, 1055 &tls_index, sizeof(tls_index)); 1056 if (ret != 0) 1057 return (P2T(ret)); 1058 1059 /* get thread tcb */ 1060 ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 1061 ta->thread_off_tcb, 1062 &tcb_addr, sizeof(tcb_addr)); 1063 if (ret != 0) 1064 return (P2T(ret)); 1065 1066 /* get dtv array address */ 1067 ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_dtv, 1068 &dtv_addr, sizeof(dtv_addr)); 1069 if (ret != 0) 1070 return (P2T(ret)); 1071 /* now get the object's tls block base address */ 1072 ret = ps_pread(ta->ph, &dtv_addr[tls_index+1], address, 1073 sizeof(*address)); 1074 if (ret != 0) 1075 return (P2T(ret)); 1076 1077 *address += offset; 1078 return (TD_OK); 1079 } 1080 1081 struct ta_ops libpthread_db_ops = { 1082 .to_init = pt_init, 1083 .to_ta_clear_event = pt_ta_clear_event, 1084 .to_ta_delete = pt_ta_delete, 1085 .to_ta_event_addr = pt_ta_event_addr, 1086 .to_ta_event_getmsg = pt_ta_event_getmsg, 1087 .to_ta_map_id2thr = pt_ta_map_id2thr, 1088 .to_ta_map_lwp2thr = pt_ta_map_lwp2thr, 1089 .to_ta_new = pt_ta_new, 1090 .to_ta_set_event = pt_ta_set_event, 1091 .to_ta_thr_iter = pt_ta_thr_iter, 1092 .to_ta_tsd_iter = pt_ta_tsd_iter, 1093 .to_thr_clear_event = pt_thr_clear_event, 1094 .to_thr_dbresume = pt_thr_dbresume, 1095 .to_thr_dbsuspend = pt_thr_dbsuspend, 1096 .to_thr_event_enable = pt_thr_event_enable, 1097 .to_thr_event_getmsg = pt_thr_event_getmsg, 1098 .to_thr_get_info = pt_thr_get_info, 1099 .to_thr_getfpregs = pt_thr_getfpregs, 1100 .to_thr_getgregs = pt_thr_getgregs, 1101 .to_thr_set_event = pt_thr_set_event, 1102 .to_thr_setfpregs = pt_thr_setfpregs, 1103 .to_thr_setgregs = pt_thr_setgregs, 1104 .to_thr_validate = pt_thr_validate, 1105 .to_thr_tls_get_addr = pt_thr_tls_get_addr, 1106 1107 /* FreeBSD specific extensions. */ 1108 .to_thr_sstep = pt_thr_sstep, 1109 #ifdef __i386__ 1110 .to_thr_getxmmregs = pt_thr_getxmmregs, 1111 .to_thr_setxmmregs = pt_thr_setxmmregs, 1112 #endif 1113 }; 1114