lib/libthread_db/libpthread_db.c

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