lib/libthread_db/libpthread_db.c

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