13c1e38eaSMarcel Moolenaar /* 23c1e38eaSMarcel Moolenaar * Copyright (c) 2004 David Xu <davidxu@freebsd.org> 33c1e38eaSMarcel Moolenaar * All rights reserved. 43c1e38eaSMarcel Moolenaar * 53c1e38eaSMarcel Moolenaar * Redistribution and use in source and binary forms, with or without 63c1e38eaSMarcel Moolenaar * modification, are permitted provided that the following conditions 73c1e38eaSMarcel Moolenaar * are met: 83c1e38eaSMarcel Moolenaar * 1. Redistributions of source code must retain the above copyright 93c1e38eaSMarcel Moolenaar * notice, this list of conditions and the following disclaimer. 103c1e38eaSMarcel Moolenaar * 2. Redistributions in binary form must reproduce the above copyright 113c1e38eaSMarcel Moolenaar * notice, this list of conditions and the following disclaimer in the 123c1e38eaSMarcel Moolenaar * documentation and/or other materials provided with the distribution. 133c1e38eaSMarcel Moolenaar * 143c1e38eaSMarcel Moolenaar * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 153c1e38eaSMarcel Moolenaar * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 163c1e38eaSMarcel Moolenaar * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 173c1e38eaSMarcel Moolenaar * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 183c1e38eaSMarcel Moolenaar * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 193c1e38eaSMarcel Moolenaar * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 203c1e38eaSMarcel Moolenaar * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 213c1e38eaSMarcel Moolenaar * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 223c1e38eaSMarcel Moolenaar * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 233c1e38eaSMarcel Moolenaar * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 243c1e38eaSMarcel Moolenaar * SUCH DAMAGE. 253c1e38eaSMarcel Moolenaar */ 263c1e38eaSMarcel Moolenaar 273c1e38eaSMarcel Moolenaar #include <sys/cdefs.h> 283c1e38eaSMarcel Moolenaar __FBSDID("$FreeBSD$"); 293c1e38eaSMarcel Moolenaar 303e93cc3aSDavid Xu #include <link.h> 313c1e38eaSMarcel Moolenaar #include <stddef.h> 323c1e38eaSMarcel Moolenaar #include <stdlib.h> 333c1e38eaSMarcel Moolenaar #include <string.h> 343c1e38eaSMarcel Moolenaar #include <unistd.h> 353c1e38eaSMarcel Moolenaar #include <pthread.h> 363c1e38eaSMarcel Moolenaar #include <sys/types.h> 373c1e38eaSMarcel Moolenaar #include <sys/kse.h> 383c1e38eaSMarcel Moolenaar #include <sys/ptrace.h> 393c1e38eaSMarcel Moolenaar #include <proc_service.h> 403c1e38eaSMarcel Moolenaar #include <thread_db.h> 413c1e38eaSMarcel Moolenaar 423e93cc3aSDavid Xu #include "rtld.h" 433e93cc3aSDavid Xu 443c1e38eaSMarcel Moolenaar #include "libpthread.h" 453c1e38eaSMarcel Moolenaar #include "libpthread_db.h" 463c1e38eaSMarcel Moolenaar 473c1e38eaSMarcel Moolenaar #define P2T(c) ps2td(c) 483c1e38eaSMarcel Moolenaar 493c1e38eaSMarcel Moolenaar static void pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp); 503c1e38eaSMarcel Moolenaar static int pt_validate(const td_thrhandle_t *th); 513c1e38eaSMarcel Moolenaar 523c1e38eaSMarcel Moolenaar static int 533c1e38eaSMarcel Moolenaar ps2td(int c) 543c1e38eaSMarcel Moolenaar { 553c1e38eaSMarcel Moolenaar switch (c) { 563c1e38eaSMarcel Moolenaar case PS_OK: 573c1e38eaSMarcel Moolenaar return TD_OK; 583c1e38eaSMarcel Moolenaar case PS_ERR: 593c1e38eaSMarcel Moolenaar return TD_ERR; 603c1e38eaSMarcel Moolenaar case PS_BADPID: 613c1e38eaSMarcel Moolenaar return TD_BADPH; 623c1e38eaSMarcel Moolenaar case PS_BADLID: 633c1e38eaSMarcel Moolenaar return TD_NOLWP; 643c1e38eaSMarcel Moolenaar case PS_BADADDR: 653c1e38eaSMarcel Moolenaar return TD_ERR; 663c1e38eaSMarcel Moolenaar case PS_NOSYM: 673c1e38eaSMarcel Moolenaar return TD_NOLIBTHREAD; 683c1e38eaSMarcel Moolenaar case PS_NOFREGS: 693c1e38eaSMarcel Moolenaar return TD_NOFPREGS; 703c1e38eaSMarcel Moolenaar default: 713c1e38eaSMarcel Moolenaar return TD_ERR; 723c1e38eaSMarcel Moolenaar } 733c1e38eaSMarcel Moolenaar } 743c1e38eaSMarcel Moolenaar 753c1e38eaSMarcel Moolenaar static long 763c1e38eaSMarcel Moolenaar pt_map_thread(const td_thragent_t *const_ta, psaddr_t pt, int type) 773c1e38eaSMarcel Moolenaar { 783c1e38eaSMarcel Moolenaar td_thragent_t *ta = __DECONST(td_thragent_t *, const_ta); 793c1e38eaSMarcel Moolenaar struct pt_map *new; 803c1e38eaSMarcel Moolenaar int i, first = -1; 813c1e38eaSMarcel Moolenaar 823c1e38eaSMarcel Moolenaar /* leave zero out */ 833c1e38eaSMarcel Moolenaar for (i = 1; i < ta->map_len; ++i) { 843c1e38eaSMarcel Moolenaar if (ta->map[i].type == PT_NONE) { 853c1e38eaSMarcel Moolenaar if (first == -1) 863c1e38eaSMarcel Moolenaar first = i; 873c1e38eaSMarcel Moolenaar } else if (ta->map[i].type == type && ta->map[i].thr == pt) { 883c1e38eaSMarcel Moolenaar return (i); 893c1e38eaSMarcel Moolenaar } 903c1e38eaSMarcel Moolenaar } 913c1e38eaSMarcel Moolenaar 923c1e38eaSMarcel Moolenaar if (first == -1) { 933c1e38eaSMarcel Moolenaar if (ta->map_len == 0) { 943c1e38eaSMarcel Moolenaar ta->map = calloc(20, sizeof(struct pt_map)); 953c1e38eaSMarcel Moolenaar if (ta->map == NULL) 963c1e38eaSMarcel Moolenaar return (-1); 973c1e38eaSMarcel Moolenaar ta->map_len = 20; 983c1e38eaSMarcel Moolenaar first = 1; 993c1e38eaSMarcel Moolenaar } else { 1003c1e38eaSMarcel Moolenaar new = realloc(ta->map, 1013c1e38eaSMarcel Moolenaar sizeof(struct pt_map) * ta->map_len * 2); 1023c1e38eaSMarcel Moolenaar if (new == NULL) 1033c1e38eaSMarcel Moolenaar return (-1); 1043c1e38eaSMarcel Moolenaar memset(new + ta->map_len, '\0', sizeof(struct pt_map) * 1053c1e38eaSMarcel Moolenaar ta->map_len); 1063c1e38eaSMarcel Moolenaar first = ta->map_len; 1073c1e38eaSMarcel Moolenaar ta->map = new; 1083c1e38eaSMarcel Moolenaar ta->map_len *= 2; 1093c1e38eaSMarcel Moolenaar } 1103c1e38eaSMarcel Moolenaar } 1113c1e38eaSMarcel Moolenaar 1123c1e38eaSMarcel Moolenaar ta->map[first].type = type; 1133c1e38eaSMarcel Moolenaar ta->map[first].thr = pt; 1143c1e38eaSMarcel Moolenaar return (first); 1153c1e38eaSMarcel Moolenaar } 1163c1e38eaSMarcel Moolenaar 1173c1e38eaSMarcel Moolenaar static td_err_e 1183c1e38eaSMarcel Moolenaar pt_init(void) 1193c1e38eaSMarcel Moolenaar { 1203c1e38eaSMarcel Moolenaar pt_md_init(); 1213c1e38eaSMarcel Moolenaar return (0); 1223c1e38eaSMarcel Moolenaar } 1233c1e38eaSMarcel Moolenaar 1243c1e38eaSMarcel Moolenaar static td_err_e 1253c1e38eaSMarcel Moolenaar pt_ta_new(struct ps_prochandle *ph, td_thragent_t **pta) 1263c1e38eaSMarcel Moolenaar { 1273c1e38eaSMarcel Moolenaar #define LOOKUP_SYM(proc, sym, addr) \ 1283c1e38eaSMarcel Moolenaar ret = ps_pglobal_lookup(proc, NULL, sym, addr); \ 1293c1e38eaSMarcel Moolenaar if (ret != 0) { \ 1303c1e38eaSMarcel Moolenaar TDBG("can not find symbol: %s\n", sym); \ 1313c1e38eaSMarcel Moolenaar ret = TD_NOLIBTHREAD; \ 1323c1e38eaSMarcel Moolenaar goto error; \ 1333c1e38eaSMarcel Moolenaar } 1343c1e38eaSMarcel Moolenaar 1353c1e38eaSMarcel Moolenaar td_thragent_t *ta; 1363c1e38eaSMarcel Moolenaar int dbg; 1373c1e38eaSMarcel Moolenaar int ret; 1383c1e38eaSMarcel Moolenaar 1393c1e38eaSMarcel Moolenaar TDBG_FUNC(); 1403c1e38eaSMarcel Moolenaar 1413c1e38eaSMarcel Moolenaar ta = malloc(sizeof(td_thragent_t)); 1423c1e38eaSMarcel Moolenaar if (ta == NULL) 1433c1e38eaSMarcel Moolenaar return (TD_MALLOC); 1443c1e38eaSMarcel Moolenaar 1453c1e38eaSMarcel Moolenaar ta->ph = ph; 1463c1e38eaSMarcel Moolenaar ta->thread_activated = 0; 1473c1e38eaSMarcel Moolenaar ta->map = NULL; 1483c1e38eaSMarcel Moolenaar ta->map_len = 0; 1493c1e38eaSMarcel Moolenaar 1503c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_libkse_debug", &ta->libkse_debug_addr); 1513c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_list", &ta->thread_list_addr); 1523c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_activated", &ta->thread_activated_addr); 1533c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_active_threads",&ta->thread_active_threads_addr); 1543c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_keytable", &ta->thread_keytable_addr); 1553c1e38eaSMarcel Moolenaar 1563c1e38eaSMarcel Moolenaar dbg = getpid(); 1573c1e38eaSMarcel Moolenaar /* 1583c1e38eaSMarcel Moolenaar * If this fails it probably means we're debugging a core file and 1593c1e38eaSMarcel Moolenaar * can't write to it. 1603c1e38eaSMarcel Moolenaar */ 1613c1e38eaSMarcel Moolenaar ps_pwrite(ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 1623c1e38eaSMarcel Moolenaar *pta = ta; 1633c1e38eaSMarcel Moolenaar return (0); 1643c1e38eaSMarcel Moolenaar 1653c1e38eaSMarcel Moolenaar error: 1663c1e38eaSMarcel Moolenaar free(ta); 1673c1e38eaSMarcel Moolenaar return (ret); 1683c1e38eaSMarcel Moolenaar } 1693c1e38eaSMarcel Moolenaar 1703c1e38eaSMarcel Moolenaar static td_err_e 1713c1e38eaSMarcel Moolenaar pt_ta_delete(td_thragent_t *ta) 1723c1e38eaSMarcel Moolenaar { 1733c1e38eaSMarcel Moolenaar int dbg; 1743c1e38eaSMarcel Moolenaar 1753c1e38eaSMarcel Moolenaar TDBG_FUNC(); 1763c1e38eaSMarcel Moolenaar 1773c1e38eaSMarcel Moolenaar dbg = 0; 1783c1e38eaSMarcel Moolenaar /* 1793c1e38eaSMarcel Moolenaar * Error returns from this write are not really a problem; 1803c1e38eaSMarcel Moolenaar * the process doesn't exist any more. 1813c1e38eaSMarcel Moolenaar */ 1823c1e38eaSMarcel Moolenaar ps_pwrite(ta->ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 1833c1e38eaSMarcel Moolenaar if (ta->map) 1843c1e38eaSMarcel Moolenaar free(ta->map); 1853c1e38eaSMarcel Moolenaar free(ta); 1863c1e38eaSMarcel Moolenaar return (TD_OK); 1873c1e38eaSMarcel Moolenaar } 1883c1e38eaSMarcel Moolenaar 1893c1e38eaSMarcel Moolenaar static td_err_e 1903c1e38eaSMarcel Moolenaar pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th) 1913c1e38eaSMarcel Moolenaar { 1923c1e38eaSMarcel Moolenaar prgregset_t gregs; 1933c1e38eaSMarcel Moolenaar TAILQ_HEAD(, pthread) thread_list; 1943c1e38eaSMarcel Moolenaar psaddr_t pt, tcb_addr; 1953c1e38eaSMarcel Moolenaar lwpid_t lwp; 1963c1e38eaSMarcel Moolenaar int ret; 1973c1e38eaSMarcel Moolenaar 1983c1e38eaSMarcel Moolenaar TDBG_FUNC(); 1993c1e38eaSMarcel Moolenaar 2003c1e38eaSMarcel Moolenaar if (id < 0 || id >= ta->map_len || ta->map[id].type == PT_NONE) 2013c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2023c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 2033c1e38eaSMarcel Moolenaar sizeof(thread_list)); 2043c1e38eaSMarcel Moolenaar if (ret != 0) 2053c1e38eaSMarcel Moolenaar return (P2T(ret)); 2063c1e38eaSMarcel Moolenaar pt = (psaddr_t)thread_list.tqh_first; 2073c1e38eaSMarcel Moolenaar if (ta->map[id].type == PT_LWP) { 2083c1e38eaSMarcel Moolenaar /* 2093c1e38eaSMarcel Moolenaar * if we are referencing a lwp, make sure it was not already 2103c1e38eaSMarcel Moolenaar * mapped to user thread. 2113c1e38eaSMarcel Moolenaar */ 2123c1e38eaSMarcel Moolenaar while (pt != 0) { 2133c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 2143c1e38eaSMarcel Moolenaar pt + offsetof(struct pthread, tcb), 2153c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 2163c1e38eaSMarcel Moolenaar if (ret != 0) 2173c1e38eaSMarcel Moolenaar return (P2T(ret)); 2183c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 2193c1e38eaSMarcel Moolenaar tcb_addr + offsetof(struct tcb, 2203c1e38eaSMarcel Moolenaar tcb_tmbx.tm_lwp), 2213c1e38eaSMarcel Moolenaar &lwp, sizeof(lwp)); 2223c1e38eaSMarcel Moolenaar if (ret != 0) 2233c1e38eaSMarcel Moolenaar return (P2T(ret)); 2243c1e38eaSMarcel Moolenaar /* 2253c1e38eaSMarcel Moolenaar * If the lwp was already mapped to userland thread, 2263c1e38eaSMarcel Moolenaar * we shouldn't reference it directly in future. 2273c1e38eaSMarcel Moolenaar */ 2283c1e38eaSMarcel Moolenaar if (lwp == ta->map[id].lwp) { 2293c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2303c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2313c1e38eaSMarcel Moolenaar } 2323c1e38eaSMarcel Moolenaar /* get next thread */ 2333c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 2343c1e38eaSMarcel Moolenaar pt + offsetof(struct pthread, tle.tqe_next), 2353c1e38eaSMarcel Moolenaar &pt, sizeof(pt)); 2363c1e38eaSMarcel Moolenaar if (ret != 0) 2373c1e38eaSMarcel Moolenaar return (P2T(ret)); 2383c1e38eaSMarcel Moolenaar } 2393c1e38eaSMarcel Moolenaar /* check lwp */ 2403c1e38eaSMarcel Moolenaar ret = ptrace(PT_GETREGS, ta->map[id].lwp, (caddr_t)&gregs, 0); 2413c1e38eaSMarcel Moolenaar if (ret != 0) { 2423c1e38eaSMarcel Moolenaar /* no longer exists */ 2433c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2443c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2453c1e38eaSMarcel Moolenaar } 2463c1e38eaSMarcel Moolenaar } else { 2473c1e38eaSMarcel Moolenaar while (pt != 0 && ta->map[id].thr != pt) { 2483c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 2493c1e38eaSMarcel Moolenaar pt + offsetof(struct pthread, tcb), 2503c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 2513c1e38eaSMarcel Moolenaar if (ret != 0) 2523c1e38eaSMarcel Moolenaar return (P2T(ret)); 2533c1e38eaSMarcel Moolenaar /* get next thread */ 2543c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 2553c1e38eaSMarcel Moolenaar pt + offsetof(struct pthread, tle.tqe_next), 2563c1e38eaSMarcel Moolenaar &pt, sizeof(pt)); 2573c1e38eaSMarcel Moolenaar if (ret != 0) 2583c1e38eaSMarcel Moolenaar return (P2T(ret)); 2593c1e38eaSMarcel Moolenaar } 2603c1e38eaSMarcel Moolenaar 2613c1e38eaSMarcel Moolenaar if (pt == 0) { 2623c1e38eaSMarcel Moolenaar /* no longer exists */ 2633c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2643c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2653c1e38eaSMarcel Moolenaar } 2663c1e38eaSMarcel Moolenaar } 2673c1e38eaSMarcel Moolenaar th->th_ta = ta; 2683c1e38eaSMarcel Moolenaar th->th_tid = id; 2693c1e38eaSMarcel Moolenaar return (TD_OK); 2703c1e38eaSMarcel Moolenaar } 2713c1e38eaSMarcel Moolenaar 2723c1e38eaSMarcel Moolenaar static td_err_e 2733c1e38eaSMarcel Moolenaar pt_ta_map_lwp2thr(const td_thragent_t *ta, lwpid_t lwp, td_thrhandle_t *th) 2743c1e38eaSMarcel Moolenaar { 2753c1e38eaSMarcel Moolenaar TAILQ_HEAD(, pthread) thread_list; 2763c1e38eaSMarcel Moolenaar psaddr_t pt, ptr; 2773c1e38eaSMarcel Moolenaar lwpid_t tmp_lwp; 2783c1e38eaSMarcel Moolenaar int ret; 2793c1e38eaSMarcel Moolenaar 2803c1e38eaSMarcel Moolenaar TDBG_FUNC(); 2813c1e38eaSMarcel Moolenaar 2823c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 2833c1e38eaSMarcel Moolenaar sizeof(thread_list)); 2843c1e38eaSMarcel Moolenaar if (ret != 0) 2853c1e38eaSMarcel Moolenaar return (P2T(ret)); 2863c1e38eaSMarcel Moolenaar pt = (psaddr_t)thread_list.tqh_first; 2873c1e38eaSMarcel Moolenaar while (pt != 0) { 2883c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, pt + offsetof(struct pthread, tcb), 2893c1e38eaSMarcel Moolenaar &ptr, sizeof(ptr)); 2903c1e38eaSMarcel Moolenaar if (ret != 0) 2913c1e38eaSMarcel Moolenaar return (P2T(ret)); 2923c1e38eaSMarcel Moolenaar ptr += offsetof(struct tcb, tcb_tmbx.tm_lwp); 2933c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &tmp_lwp, sizeof(lwpid_t)); 2943c1e38eaSMarcel Moolenaar if (ret != 0) 2953c1e38eaSMarcel Moolenaar return (P2T(ret)); 2963c1e38eaSMarcel Moolenaar if (tmp_lwp == lwp) { 2973c1e38eaSMarcel Moolenaar th->th_ta = ta; 2983c1e38eaSMarcel Moolenaar th->th_tid = pt_map_thread(ta, pt, PT_USER); 2993c1e38eaSMarcel Moolenaar if (th->th_tid == -1) 3003c1e38eaSMarcel Moolenaar return (TD_MALLOC); 3013c1e38eaSMarcel Moolenaar pt_unmap_lwp(ta, lwp); 3023c1e38eaSMarcel Moolenaar return (TD_OK); 3033c1e38eaSMarcel Moolenaar } 3043c1e38eaSMarcel Moolenaar 3053c1e38eaSMarcel Moolenaar /* get next thread */ 3063c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 3073c1e38eaSMarcel Moolenaar pt + offsetof(struct pthread, tle.tqe_next), 3083c1e38eaSMarcel Moolenaar &pt, sizeof(pt)); 3093c1e38eaSMarcel Moolenaar if (ret != 0) 3103c1e38eaSMarcel Moolenaar return (P2T(ret)); 3113c1e38eaSMarcel Moolenaar } 3123c1e38eaSMarcel Moolenaar 3133c1e38eaSMarcel Moolenaar return (TD_NOTHR); 3143c1e38eaSMarcel Moolenaar } 3153c1e38eaSMarcel Moolenaar 3163c1e38eaSMarcel Moolenaar static td_err_e 3173c1e38eaSMarcel Moolenaar pt_ta_thr_iter(const td_thragent_t *ta, 3183c1e38eaSMarcel Moolenaar td_thr_iter_f *callback, void *cbdata_p, 3193c1e38eaSMarcel Moolenaar td_thr_state_e state, int ti_pri, 3203c1e38eaSMarcel Moolenaar sigset_t *ti_sigmask_p, 3213c1e38eaSMarcel Moolenaar unsigned int ti_user_flags) 3223c1e38eaSMarcel Moolenaar { 3233c1e38eaSMarcel Moolenaar TAILQ_HEAD(, pthread) thread_list; 3243c1e38eaSMarcel Moolenaar td_thrhandle_t th; 3253c1e38eaSMarcel Moolenaar psaddr_t pt; 3263c1e38eaSMarcel Moolenaar ps_err_e pserr; 3273c1e38eaSMarcel Moolenaar int activated; 3283c1e38eaSMarcel Moolenaar 3293c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3303c1e38eaSMarcel Moolenaar 3313c1e38eaSMarcel Moolenaar pserr = ps_pread(ta->ph, ta->thread_activated_addr, &activated, 3323c1e38eaSMarcel Moolenaar sizeof(int)); 3333c1e38eaSMarcel Moolenaar if (pserr != PS_OK) 3343c1e38eaSMarcel Moolenaar return (P2T(pserr)); 3353c1e38eaSMarcel Moolenaar if (!activated) 3363c1e38eaSMarcel Moolenaar return (TD_OK); 3373c1e38eaSMarcel Moolenaar 3383c1e38eaSMarcel Moolenaar pserr = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 3393c1e38eaSMarcel Moolenaar sizeof(thread_list)); 3403c1e38eaSMarcel Moolenaar if (pserr != 0) 3413c1e38eaSMarcel Moolenaar return (P2T(pserr)); 3423c1e38eaSMarcel Moolenaar pt = (psaddr_t)thread_list.tqh_first; 3433c1e38eaSMarcel Moolenaar while (pt != 0) { 3443c1e38eaSMarcel Moolenaar th.th_ta = ta; 3453c1e38eaSMarcel Moolenaar th.th_tid = pt_map_thread(ta, pt, PT_USER); 3463c1e38eaSMarcel Moolenaar /* should we unmap lwp here ? */ 3473c1e38eaSMarcel Moolenaar if (th.th_tid == -1) 3483c1e38eaSMarcel Moolenaar return (TD_MALLOC); 3493c1e38eaSMarcel Moolenaar if ((*callback)(&th, cbdata_p)) 3503c1e38eaSMarcel Moolenaar return (TD_DBERR); 3513c1e38eaSMarcel Moolenaar /* get next thread */ 3523c1e38eaSMarcel Moolenaar pserr = ps_pread(ta->ph, 3533c1e38eaSMarcel Moolenaar pt + offsetof(struct pthread, tle.tqe_next), &pt, 3543c1e38eaSMarcel Moolenaar sizeof(pt)); 3553c1e38eaSMarcel Moolenaar if (pserr != PS_OK) 3563c1e38eaSMarcel Moolenaar return (P2T(pserr)); 3573c1e38eaSMarcel Moolenaar } 3583c1e38eaSMarcel Moolenaar return (TD_OK); 3593c1e38eaSMarcel Moolenaar } 3603c1e38eaSMarcel Moolenaar 3613c1e38eaSMarcel Moolenaar static td_err_e 3623c1e38eaSMarcel Moolenaar pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg) 3633c1e38eaSMarcel Moolenaar { 3643c1e38eaSMarcel Moolenaar struct pthread_key keytable[PTHREAD_KEYS_MAX]; 3653c1e38eaSMarcel Moolenaar int i, ret; 3663c1e38eaSMarcel Moolenaar 3673c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3683c1e38eaSMarcel Moolenaar 3693c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, (psaddr_t)ta->thread_keytable_addr, keytable, 3703c1e38eaSMarcel Moolenaar sizeof(keytable)); 3713c1e38eaSMarcel Moolenaar if (ret != 0) 3723c1e38eaSMarcel Moolenaar return (P2T(ret)); 3733c1e38eaSMarcel Moolenaar 3743c1e38eaSMarcel Moolenaar for (i = 0; i < PTHREAD_KEYS_MAX; i++) { 3753c1e38eaSMarcel Moolenaar if (keytable[i].allocated) { 3763c1e38eaSMarcel Moolenaar ret = (ki)(i, keytable[i].destructor, arg); 3773c1e38eaSMarcel Moolenaar if (ret != 0) 3783c1e38eaSMarcel Moolenaar return (TD_DBERR); 3793c1e38eaSMarcel Moolenaar } 3803c1e38eaSMarcel Moolenaar } 3813c1e38eaSMarcel Moolenaar return (TD_OK); 3823c1e38eaSMarcel Moolenaar } 3833c1e38eaSMarcel Moolenaar 3843c1e38eaSMarcel Moolenaar static td_err_e 3853c1e38eaSMarcel Moolenaar pt_ta_event_addr(const td_thragent_t *ta, td_event_e event, td_notify_t *ptr) 3863c1e38eaSMarcel Moolenaar { 3873c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3883c1e38eaSMarcel Moolenaar return (TD_NOEVENT); 3893c1e38eaSMarcel Moolenaar } 3903c1e38eaSMarcel Moolenaar 3913c1e38eaSMarcel Moolenaar static td_err_e 3923c1e38eaSMarcel Moolenaar pt_ta_set_event(const td_thragent_t *ta, td_thr_events_t *events) 3933c1e38eaSMarcel Moolenaar { 3943c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3953c1e38eaSMarcel Moolenaar return (TD_ERR); 3963c1e38eaSMarcel Moolenaar } 3973c1e38eaSMarcel Moolenaar 3983c1e38eaSMarcel Moolenaar static td_err_e 3993c1e38eaSMarcel Moolenaar pt_ta_clear_event(const td_thragent_t *ta, td_thr_events_t *events) 4003c1e38eaSMarcel Moolenaar { 4013c1e38eaSMarcel Moolenaar TDBG_FUNC(); 4023c1e38eaSMarcel Moolenaar return (TD_ERR); 4033c1e38eaSMarcel Moolenaar } 4043c1e38eaSMarcel Moolenaar 4053c1e38eaSMarcel Moolenaar static td_err_e 4063c1e38eaSMarcel Moolenaar pt_ta_event_getmsg(const td_thragent_t *ta, td_event_msg_t *msg) 4073c1e38eaSMarcel Moolenaar { 4083c1e38eaSMarcel Moolenaar TDBG_FUNC(); 4093c1e38eaSMarcel Moolenaar return (TD_NOMSG); 4103c1e38eaSMarcel Moolenaar } 4113c1e38eaSMarcel Moolenaar 4123c1e38eaSMarcel Moolenaar static td_err_e 413447d36ecSDavid Xu pt_dbsuspend(const td_thrhandle_t *th, int suspend) 414447d36ecSDavid Xu { 415447d36ecSDavid Xu td_thragent_t *ta = (td_thragent_t *)th->th_ta; 416447d36ecSDavid Xu psaddr_t tcb_addr, tmbx_addr, ptr; 417447d36ecSDavid Xu lwpid_t lwp; 418447d36ecSDavid Xu uint32_t dflags; 4193e93cc3aSDavid Xu int attrflags, locklevel, ret; 420447d36ecSDavid Xu 421447d36ecSDavid Xu TDBG_FUNC(); 422447d36ecSDavid Xu 423447d36ecSDavid Xu ret = pt_validate(th); 424447d36ecSDavid Xu if (ret) 425447d36ecSDavid Xu return (ret); 426447d36ecSDavid Xu 427447d36ecSDavid Xu if (ta->map[th->th_tid].type == PT_LWP) { 428447d36ecSDavid Xu if (suspend) 429447d36ecSDavid Xu ret = ps_lstop(ta->ph, ta->map[th->th_tid].lwp); 430447d36ecSDavid Xu else 431447d36ecSDavid Xu ret = ps_lcontinue(ta->ph, ta->map[th->th_tid].lwp); 432447d36ecSDavid Xu return (P2T(ret)); 433447d36ecSDavid Xu } 434447d36ecSDavid Xu 435447d36ecSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 436447d36ecSDavid Xu offsetof(struct pthread, attr.flags), 437447d36ecSDavid Xu &attrflags, sizeof(attrflags)); 438447d36ecSDavid Xu if (ret != 0) 439447d36ecSDavid Xu return (P2T(ret)); 440447d36ecSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 441447d36ecSDavid Xu offsetof(struct pthread, tcb), 442447d36ecSDavid Xu &tcb_addr, sizeof(tcb_addr)); 443447d36ecSDavid Xu if (ret != 0) 444447d36ecSDavid Xu return (P2T(ret)); 445447d36ecSDavid Xu tmbx_addr = tcb_addr + offsetof(struct tcb, tcb_tmbx); 446447d36ecSDavid Xu ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 447447d36ecSDavid Xu ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 448447d36ecSDavid Xu if (ret != 0) 449447d36ecSDavid Xu return (P2T(ret)); 4503e93cc3aSDavid Xu 4513e93cc3aSDavid Xu if (lwp != 0) { 4523e93cc3aSDavid Xu /* don't suspend signal thread */ 453447d36ecSDavid Xu if (attrflags & THR_SIGNAL_THREAD) 4543e93cc3aSDavid Xu return (0); 4553e93cc3aSDavid Xu if (attrflags & PTHREAD_SCOPE_SYSTEM) { 4563e93cc3aSDavid Xu /* 4573e93cc3aSDavid Xu * don't suspend system scope thread if it is holding 4583e93cc3aSDavid Xu * some low level locks 4593e93cc3aSDavid Xu */ 460447d36ecSDavid Xu ptr = ta->map[th->th_tid].thr + 461447d36ecSDavid Xu offsetof(struct pthread, kse); 462447d36ecSDavid Xu ret = ps_pread(ta->ph, ptr, &ptr, sizeof(ptr)); 463447d36ecSDavid Xu if (ret != 0) 464447d36ecSDavid Xu return (P2T(ret)); 4653e93cc3aSDavid Xu ret = ps_pread(ta->ph, ptr + offsetof(struct kse, 4663e93cc3aSDavid Xu k_locklevel), &locklevel, sizeof(int)); 467447d36ecSDavid Xu if (ret != 0) 468447d36ecSDavid Xu return (P2T(ret)); 4693e93cc3aSDavid Xu if (locklevel <= 0) { 4703e93cc3aSDavid Xu ptr = ta->map[th->th_tid].thr + 4713e93cc3aSDavid Xu offsetof(struct pthread, locklevel); 4723e93cc3aSDavid Xu ret = ps_pread(ta->ph, ptr, &locklevel, 4733e93cc3aSDavid Xu sizeof(int)); 474447d36ecSDavid Xu if (ret != 0) 475447d36ecSDavid Xu return (P2T(ret)); 476447d36ecSDavid Xu } 4773e93cc3aSDavid Xu if (suspend) { 4783e93cc3aSDavid Xu if (locklevel <= 0) 4793e93cc3aSDavid Xu ret = ps_lstop(ta->ph, lwp); 4803e93cc3aSDavid Xu } else { 4813e93cc3aSDavid Xu ret = ps_lcontinue(ta->ph, lwp); 4823e93cc3aSDavid Xu } 4833e93cc3aSDavid Xu if (ret != 0) 4843e93cc3aSDavid Xu return (P2T(ret)); 485447d36ecSDavid Xu /* FALLTHROUGH */ 4863e93cc3aSDavid Xu } else { 4873e93cc3aSDavid Xu struct ptrace_lwpinfo pl; 4883e93cc3aSDavid Xu 4893e93cc3aSDavid Xu if (ptrace(PT_LWPINFO, lwp, (caddr_t) &pl, sizeof(pl))) 4903e93cc3aSDavid Xu return (TD_ERR); 4913e93cc3aSDavid Xu if (suspend) { 4923e93cc3aSDavid Xu if (!(pl.pl_flags & PL_FLAG_BOUND)) 4933e93cc3aSDavid Xu ret = ps_lstop(ta->ph, lwp); 4943e93cc3aSDavid Xu } else { 4953e93cc3aSDavid Xu ret = ps_lcontinue(ta->ph, lwp); 4963e93cc3aSDavid Xu } 4973e93cc3aSDavid Xu if (ret != 0) 4983e93cc3aSDavid Xu return (P2T(ret)); 4993e93cc3aSDavid Xu /* FALLTHROUGH */ 5003e93cc3aSDavid Xu } 501447d36ecSDavid Xu } 502447d36ecSDavid Xu /* read tm_dflags */ 503447d36ecSDavid Xu ret = ps_pread(ta->ph, 504447d36ecSDavid Xu tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 505447d36ecSDavid Xu &dflags, sizeof(dflags)); 506447d36ecSDavid Xu if (ret != 0) 507447d36ecSDavid Xu return (P2T(ret)); 508447d36ecSDavid Xu if (suspend) 5094513fb36SDavid Xu dflags |= TMDF_SUSPEND; 510447d36ecSDavid Xu else 5114513fb36SDavid Xu dflags &= ~TMDF_SUSPEND; 512447d36ecSDavid Xu ret = ps_pwrite(ta->ph, 513447d36ecSDavid Xu tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 514447d36ecSDavid Xu &dflags, sizeof(dflags)); 515447d36ecSDavid Xu return (P2T(ret)); 516447d36ecSDavid Xu } 517447d36ecSDavid Xu 518447d36ecSDavid Xu static td_err_e 5193c1e38eaSMarcel Moolenaar pt_thr_dbresume(const td_thrhandle_t *th) 5203c1e38eaSMarcel Moolenaar { 5213c1e38eaSMarcel Moolenaar TDBG_FUNC(); 522447d36ecSDavid Xu 523447d36ecSDavid Xu return pt_dbsuspend(th, 0); 5243c1e38eaSMarcel Moolenaar } 5253c1e38eaSMarcel Moolenaar 5263c1e38eaSMarcel Moolenaar static td_err_e 5273c1e38eaSMarcel Moolenaar pt_thr_dbsuspend(const td_thrhandle_t *th) 5283c1e38eaSMarcel Moolenaar { 5293c1e38eaSMarcel Moolenaar TDBG_FUNC(); 530447d36ecSDavid Xu 531447d36ecSDavid Xu return pt_dbsuspend(th, 1); 5323c1e38eaSMarcel Moolenaar } 5333c1e38eaSMarcel Moolenaar 5343c1e38eaSMarcel Moolenaar static td_err_e 5353c1e38eaSMarcel Moolenaar pt_thr_validate(const td_thrhandle_t *th) 5363c1e38eaSMarcel Moolenaar { 5373c1e38eaSMarcel Moolenaar td_thrhandle_t temp; 5383c1e38eaSMarcel Moolenaar int ret; 5393c1e38eaSMarcel Moolenaar 5403c1e38eaSMarcel Moolenaar TDBG_FUNC(); 5413c1e38eaSMarcel Moolenaar 5423c1e38eaSMarcel Moolenaar ret = pt_ta_map_id2thr(th->th_ta, th->th_tid, 5433c1e38eaSMarcel Moolenaar &temp); 544447d36ecSDavid Xu return (ret); 5453c1e38eaSMarcel Moolenaar } 5463c1e38eaSMarcel Moolenaar 5473c1e38eaSMarcel Moolenaar static td_err_e 5483c1e38eaSMarcel Moolenaar pt_thr_get_info(const td_thrhandle_t *th, td_thrinfo_t *info) 5493c1e38eaSMarcel Moolenaar { 5503c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 5513c1e38eaSMarcel Moolenaar struct pthread pt; 5523c1e38eaSMarcel Moolenaar int ret; 553447d36ecSDavid Xu uint32_t dflags; 5543c1e38eaSMarcel Moolenaar 5553c1e38eaSMarcel Moolenaar TDBG_FUNC(); 5563c1e38eaSMarcel Moolenaar 5573c1e38eaSMarcel Moolenaar ret = pt_validate(th); 5583c1e38eaSMarcel Moolenaar if (ret) 5593c1e38eaSMarcel Moolenaar return (ret); 5603c1e38eaSMarcel Moolenaar 5613c1e38eaSMarcel Moolenaar memset(info, 0, sizeof(*info)); 5623c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 5633c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_SYSTEM; 5643c1e38eaSMarcel Moolenaar info->ti_lid = ta->map[th->th_tid].lwp; 5653c1e38eaSMarcel Moolenaar info->ti_tid = th->th_tid; 5663c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_RUN; 5673c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_SYSTEM; 5683c1e38eaSMarcel Moolenaar return (TD_OK); 5693c1e38eaSMarcel Moolenaar } 5703c1e38eaSMarcel Moolenaar 5713c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, (psaddr_t)(ta->map[th->th_tid].thr), 5723c1e38eaSMarcel Moolenaar &pt, sizeof(pt)); 5733c1e38eaSMarcel Moolenaar if (ret != 0) 5743c1e38eaSMarcel Moolenaar return (P2T(ret)); 5753c1e38eaSMarcel Moolenaar if (pt.magic != THR_MAGIC) 5763c1e38eaSMarcel Moolenaar return (TD_BADTH); 5773c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 5783c1e38eaSMarcel Moolenaar ((psaddr_t)pt.tcb) + offsetof(struct tcb, tcb_tmbx.tm_lwp), 5793c1e38eaSMarcel Moolenaar &info->ti_lid, sizeof(lwpid_t)); 5803c1e38eaSMarcel Moolenaar if (ret != 0) 5813c1e38eaSMarcel Moolenaar return (P2T(ret)); 582447d36ecSDavid Xu ret = ps_pread(ta->ph, 583447d36ecSDavid Xu ((psaddr_t)pt.tcb) + offsetof(struct tcb, tcb_tmbx.tm_dflags), 584447d36ecSDavid Xu &dflags, sizeof(dflags)); 585447d36ecSDavid Xu if (ret != 0) 586447d36ecSDavid Xu return (P2T(ret)); 5873c1e38eaSMarcel Moolenaar info->ti_ta_p = th->th_ta; 5883c1e38eaSMarcel Moolenaar info->ti_tid = th->th_tid; 5893c1e38eaSMarcel Moolenaar info->ti_tls = (char *)pt.specific; 5903c1e38eaSMarcel Moolenaar info->ti_startfunc = (psaddr_t)pt.start_routine; 5913c1e38eaSMarcel Moolenaar info->ti_stkbase = (psaddr_t) pt.attr.stackaddr_attr; 5923c1e38eaSMarcel Moolenaar info->ti_stksize = pt.attr.stacksize_attr; 5933c1e38eaSMarcel Moolenaar switch (pt.state) { 5943c1e38eaSMarcel Moolenaar case PS_RUNNING: 5953c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_RUN; 5963c1e38eaSMarcel Moolenaar break; 5973c1e38eaSMarcel Moolenaar case PS_LOCKWAIT: 5983c1e38eaSMarcel Moolenaar case PS_MUTEX_WAIT: 5993c1e38eaSMarcel Moolenaar case PS_COND_WAIT: 6003c1e38eaSMarcel Moolenaar case PS_SIGSUSPEND: 6013c1e38eaSMarcel Moolenaar case PS_SIGWAIT: 6023c1e38eaSMarcel Moolenaar case PS_JOIN: 6033c1e38eaSMarcel Moolenaar case PS_SUSPENDED: 6043c1e38eaSMarcel Moolenaar case PS_DEADLOCK: 6053c1e38eaSMarcel Moolenaar case PS_SLEEP_WAIT: 6063c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_SLEEP; 6073c1e38eaSMarcel Moolenaar break; 6083c1e38eaSMarcel Moolenaar case PS_DEAD: 6093c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_ZOMBIE; 6103c1e38eaSMarcel Moolenaar break; 6113c1e38eaSMarcel Moolenaar default: 6123c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_UNKNOWN; 6133c1e38eaSMarcel Moolenaar break; 6143c1e38eaSMarcel Moolenaar } 6153c1e38eaSMarcel Moolenaar 6164513fb36SDavid Xu info->ti_db_suspended = ((dflags & TMDF_SUSPEND) != 0); 6173c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_USER; 6183c1e38eaSMarcel Moolenaar info->ti_pri = pt.active_priority; 6193c1e38eaSMarcel Moolenaar info->ti_sigmask = pt.sigmask; 6203c1e38eaSMarcel Moolenaar info->ti_traceme = 0; 6213c1e38eaSMarcel Moolenaar info->ti_pending = pt.sigpend; 6223c1e38eaSMarcel Moolenaar info->ti_events = 0; 6233c1e38eaSMarcel Moolenaar return (0); 6243c1e38eaSMarcel Moolenaar } 6253c1e38eaSMarcel Moolenaar 6263c1e38eaSMarcel Moolenaar static td_err_e 6273c1e38eaSMarcel Moolenaar pt_thr_getfpregs(const td_thrhandle_t *th, prfpregset_t *fpregs) 6283c1e38eaSMarcel Moolenaar { 6293c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 6303c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 6313c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 6323c1e38eaSMarcel Moolenaar lwpid_t lwp; 6333c1e38eaSMarcel Moolenaar int ret; 6343c1e38eaSMarcel Moolenaar 6353c1e38eaSMarcel Moolenaar TDBG_FUNC(); 6363c1e38eaSMarcel Moolenaar 6373c1e38eaSMarcel Moolenaar ret = pt_validate(th); 6383c1e38eaSMarcel Moolenaar if (ret) 6393c1e38eaSMarcel Moolenaar return (ret); 6403c1e38eaSMarcel Moolenaar 6413c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 6423c1e38eaSMarcel Moolenaar ret = ps_lgetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 6433c1e38eaSMarcel Moolenaar return (P2T(ret)); 6443c1e38eaSMarcel Moolenaar } 6453c1e38eaSMarcel Moolenaar 6463c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 6473c1e38eaSMarcel Moolenaar offsetof(struct pthread, tcb), 6483c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 6493c1e38eaSMarcel Moolenaar if (ret != 0) 6503c1e38eaSMarcel Moolenaar return (P2T(ret)); 6513c1e38eaSMarcel Moolenaar tmbx_addr = tcb_addr + offsetof(struct tcb, tcb_tmbx); 6523c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 6533c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 6543c1e38eaSMarcel Moolenaar if (ret != 0) 6553c1e38eaSMarcel Moolenaar return (P2T(ret)); 6563c1e38eaSMarcel Moolenaar if (lwp != 0) { 6573c1e38eaSMarcel Moolenaar ret = ps_lgetfpregs(ta->ph, lwp, fpregs); 6583c1e38eaSMarcel Moolenaar return (P2T(ret)); 6593c1e38eaSMarcel Moolenaar } 6603c1e38eaSMarcel Moolenaar 6613c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 6623c1e38eaSMarcel Moolenaar if (ret != 0) 6633c1e38eaSMarcel Moolenaar return (P2T(ret)); 6643c1e38eaSMarcel Moolenaar pt_ucontext_to_fpreg(&tmbx.tm_context, fpregs); 6653c1e38eaSMarcel Moolenaar return (0); 6663c1e38eaSMarcel Moolenaar } 6673c1e38eaSMarcel Moolenaar 6683c1e38eaSMarcel Moolenaar static td_err_e 6693c1e38eaSMarcel Moolenaar pt_thr_getgregs(const td_thrhandle_t *th, prgregset_t gregs) 6703c1e38eaSMarcel Moolenaar { 6713c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 6723c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 6733c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 6743c1e38eaSMarcel Moolenaar lwpid_t lwp; 6753c1e38eaSMarcel Moolenaar int ret; 6763c1e38eaSMarcel Moolenaar 6773c1e38eaSMarcel Moolenaar TDBG_FUNC(); 6783c1e38eaSMarcel Moolenaar 6793c1e38eaSMarcel Moolenaar ret = pt_validate(th); 6803c1e38eaSMarcel Moolenaar if (ret) 6813c1e38eaSMarcel Moolenaar return (ret); 6823c1e38eaSMarcel Moolenaar 6833c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 6843c1e38eaSMarcel Moolenaar ret = ps_lgetregs(ta->ph, 6853c1e38eaSMarcel Moolenaar ta->map[th->th_tid].lwp, gregs); 6863c1e38eaSMarcel Moolenaar return (P2T(ret)); 6873c1e38eaSMarcel Moolenaar } 6883c1e38eaSMarcel Moolenaar 6893c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 6903c1e38eaSMarcel Moolenaar offsetof(struct pthread, tcb), 6913c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 6923c1e38eaSMarcel Moolenaar if (ret != 0) 6933c1e38eaSMarcel Moolenaar return (P2T(ret)); 6943c1e38eaSMarcel Moolenaar tmbx_addr = tcb_addr + offsetof(struct tcb, tcb_tmbx); 6953c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 6963c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 6973c1e38eaSMarcel Moolenaar if (ret != 0) 6983c1e38eaSMarcel Moolenaar return (P2T(ret)); 6993c1e38eaSMarcel Moolenaar if (lwp != 0) { 7003c1e38eaSMarcel Moolenaar ret = ps_lgetregs(ta->ph, lwp, gregs); 7013c1e38eaSMarcel Moolenaar return (P2T(ret)); 7023c1e38eaSMarcel Moolenaar } 7033c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7043c1e38eaSMarcel Moolenaar if (ret != 0) 7053c1e38eaSMarcel Moolenaar return (P2T(ret)); 7063c1e38eaSMarcel Moolenaar pt_ucontext_to_reg(&tmbx.tm_context, gregs); 7073c1e38eaSMarcel Moolenaar return (0); 7083c1e38eaSMarcel Moolenaar } 7093c1e38eaSMarcel Moolenaar 7103c1e38eaSMarcel Moolenaar static td_err_e 7113c1e38eaSMarcel Moolenaar pt_thr_setfpregs(const td_thrhandle_t *th, const prfpregset_t *fpregs) 7123c1e38eaSMarcel Moolenaar { 7133c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 7143c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 7153c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 7163c1e38eaSMarcel Moolenaar lwpid_t lwp; 7173c1e38eaSMarcel Moolenaar int ret; 7183c1e38eaSMarcel Moolenaar 7193c1e38eaSMarcel Moolenaar TDBG_FUNC(); 7203c1e38eaSMarcel Moolenaar 7213c1e38eaSMarcel Moolenaar ret = pt_validate(th); 7223c1e38eaSMarcel Moolenaar if (ret) 7233c1e38eaSMarcel Moolenaar return (ret); 7243c1e38eaSMarcel Moolenaar 7253c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 7263c1e38eaSMarcel Moolenaar ret = ps_lsetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 7273c1e38eaSMarcel Moolenaar return (P2T(ret)); 7283c1e38eaSMarcel Moolenaar } 7293c1e38eaSMarcel Moolenaar 7303c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 7313c1e38eaSMarcel Moolenaar offsetof(struct pthread, tcb), 7323c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 7333c1e38eaSMarcel Moolenaar if (ret != 0) 7343c1e38eaSMarcel Moolenaar return (P2T(ret)); 7353c1e38eaSMarcel Moolenaar tmbx_addr = tcb_addr + offsetof(struct tcb, tcb_tmbx); 7363c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 7373c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 7383c1e38eaSMarcel Moolenaar if (ret != 0) 7393c1e38eaSMarcel Moolenaar return (P2T(ret)); 7403c1e38eaSMarcel Moolenaar if (lwp != 0) { 7413c1e38eaSMarcel Moolenaar ret = ps_lsetfpregs(ta->ph, lwp, fpregs); 7423c1e38eaSMarcel Moolenaar return (P2T(ret)); 7433c1e38eaSMarcel Moolenaar } 7443c1e38eaSMarcel Moolenaar /* 7453c1e38eaSMarcel Moolenaar * Read a copy of context, this makes sure that registers 7463c1e38eaSMarcel Moolenaar * not covered by structure reg won't be clobbered 7473c1e38eaSMarcel Moolenaar */ 7483c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7493c1e38eaSMarcel Moolenaar if (ret != 0) 7503c1e38eaSMarcel Moolenaar return (P2T(ret)); 7513c1e38eaSMarcel Moolenaar 7523c1e38eaSMarcel Moolenaar pt_fpreg_to_ucontext(fpregs, &tmbx.tm_context); 7533c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7543c1e38eaSMarcel Moolenaar return (P2T(ret)); 7553c1e38eaSMarcel Moolenaar } 7563c1e38eaSMarcel Moolenaar 7573c1e38eaSMarcel Moolenaar static td_err_e 7583c1e38eaSMarcel Moolenaar pt_thr_setgregs(const td_thrhandle_t *th, const prgregset_t gregs) 7593c1e38eaSMarcel Moolenaar { 7603c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 7613c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 7623c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 7633c1e38eaSMarcel Moolenaar lwpid_t lwp; 7643c1e38eaSMarcel Moolenaar int ret; 7653c1e38eaSMarcel Moolenaar 7663c1e38eaSMarcel Moolenaar TDBG_FUNC(); 7673c1e38eaSMarcel Moolenaar 7683c1e38eaSMarcel Moolenaar ret = pt_validate(th); 7693c1e38eaSMarcel Moolenaar if (ret) 7703c1e38eaSMarcel Moolenaar return (ret); 7713c1e38eaSMarcel Moolenaar 7723c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 7733c1e38eaSMarcel Moolenaar ret = ps_lsetregs(ta->ph, ta->map[th->th_tid].lwp, gregs); 7743c1e38eaSMarcel Moolenaar return (P2T(ret)); 7753c1e38eaSMarcel Moolenaar } 7763c1e38eaSMarcel Moolenaar 7773c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 7783c1e38eaSMarcel Moolenaar offsetof(struct pthread, tcb), 7793c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 7803c1e38eaSMarcel Moolenaar if (ret != 0) 7813c1e38eaSMarcel Moolenaar return (P2T(ret)); 7823c1e38eaSMarcel Moolenaar tmbx_addr = tcb_addr + offsetof(struct tcb, tcb_tmbx); 7833c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 7843c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 7853c1e38eaSMarcel Moolenaar if (ret != 0) 7863c1e38eaSMarcel Moolenaar return (P2T(ret)); 7873c1e38eaSMarcel Moolenaar if (lwp != 0) { 7883c1e38eaSMarcel Moolenaar ret = ps_lsetregs(ta->ph, lwp, gregs); 7893c1e38eaSMarcel Moolenaar return (P2T(ret)); 7903c1e38eaSMarcel Moolenaar } 7913c1e38eaSMarcel Moolenaar 7923c1e38eaSMarcel Moolenaar /* 7933c1e38eaSMarcel Moolenaar * Read a copy of context, make sure that registers 7943c1e38eaSMarcel Moolenaar * not covered by structure reg won't be clobbered 7953c1e38eaSMarcel Moolenaar */ 7963c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7973c1e38eaSMarcel Moolenaar if (ret != 0) 7983c1e38eaSMarcel Moolenaar return (P2T(ret)); 7993c1e38eaSMarcel Moolenaar pt_reg_to_ucontext(gregs, &tmbx.tm_context); 8003c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8013c1e38eaSMarcel Moolenaar return (P2T(ret)); 8023c1e38eaSMarcel Moolenaar } 8033c1e38eaSMarcel Moolenaar 8043c1e38eaSMarcel Moolenaar static td_err_e 8053c1e38eaSMarcel Moolenaar pt_thr_event_enable(const td_thrhandle_t *th, int en) 8063c1e38eaSMarcel Moolenaar { 8073c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8083c1e38eaSMarcel Moolenaar return (TD_ERR); 8093c1e38eaSMarcel Moolenaar } 8103c1e38eaSMarcel Moolenaar 8113c1e38eaSMarcel Moolenaar static td_err_e 8123c1e38eaSMarcel Moolenaar pt_thr_set_event(const td_thrhandle_t *th, td_thr_events_t *setp) 8133c1e38eaSMarcel Moolenaar { 8143c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8153c1e38eaSMarcel Moolenaar return (TD_ERR); 8163c1e38eaSMarcel Moolenaar } 8173c1e38eaSMarcel Moolenaar 8183c1e38eaSMarcel Moolenaar static td_err_e 8193c1e38eaSMarcel Moolenaar pt_thr_clear_event(const td_thrhandle_t *th, td_thr_events_t *setp) 8203c1e38eaSMarcel Moolenaar { 8213c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8223c1e38eaSMarcel Moolenaar return (TD_ERR); 8233c1e38eaSMarcel Moolenaar } 8243c1e38eaSMarcel Moolenaar 8253c1e38eaSMarcel Moolenaar static td_err_e 8263c1e38eaSMarcel Moolenaar pt_thr_event_getmsg(const td_thrhandle_t *th, td_event_msg_t *msg) 8273c1e38eaSMarcel Moolenaar { 8283c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8293c1e38eaSMarcel Moolenaar return (TD_NOMSG); 8303c1e38eaSMarcel Moolenaar } 8313c1e38eaSMarcel Moolenaar 8323c1e38eaSMarcel Moolenaar static td_err_e 8333c1e38eaSMarcel Moolenaar pt_thr_sstep(const td_thrhandle_t *th, int step) 8343c1e38eaSMarcel Moolenaar { 8353c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 8363c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 8373c1e38eaSMarcel Moolenaar struct reg regs; 8383c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr; 839447d36ecSDavid Xu uint32_t dflags; 8403c1e38eaSMarcel Moolenaar lwpid_t lwp; 8413c1e38eaSMarcel Moolenaar int ret; 8423c1e38eaSMarcel Moolenaar 8433c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8443c1e38eaSMarcel Moolenaar 8453c1e38eaSMarcel Moolenaar ret = pt_validate(th); 8463c1e38eaSMarcel Moolenaar if (ret) 8473c1e38eaSMarcel Moolenaar return (ret); 8483c1e38eaSMarcel Moolenaar 8493c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) 8503c1e38eaSMarcel Moolenaar return (TD_BADTH); 8513c1e38eaSMarcel Moolenaar 8523c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 8533c1e38eaSMarcel Moolenaar offsetof(struct pthread, tcb), 8543c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 8553c1e38eaSMarcel Moolenaar if (ret != 0) 8563c1e38eaSMarcel Moolenaar return (P2T(ret)); 8573c1e38eaSMarcel Moolenaar 8583c1e38eaSMarcel Moolenaar /* Clear or set single step flag in thread mailbox */ 859447d36ecSDavid Xu ret = ps_pread(ta->ph, tcb_addr + offsetof(struct tcb, 860447d36ecSDavid Xu tcb_tmbx.tm_dflags), &dflags, sizeof(uint32_t)); 861447d36ecSDavid Xu if (ret != 0) 862447d36ecSDavid Xu return (P2T(ret)); 863447d36ecSDavid Xu if (step != 0) 864447d36ecSDavid Xu dflags |= TMDF_SSTEP; 865447d36ecSDavid Xu else 866447d36ecSDavid Xu dflags &= ~TMDF_SSTEP; 8673c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tcb_addr + offsetof(struct tcb, 868447d36ecSDavid Xu tcb_tmbx.tm_dflags), &dflags, sizeof(uint32_t)); 8693c1e38eaSMarcel Moolenaar if (ret != 0) 8703c1e38eaSMarcel Moolenaar return (P2T(ret)); 8713c1e38eaSMarcel Moolenaar /* Get lwp */ 8723c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tcb_addr + offsetof(struct tcb, 8733c1e38eaSMarcel Moolenaar tcb_tmbx.tm_lwp), &lwp, sizeof(lwpid_t)); 8743c1e38eaSMarcel Moolenaar if (ret != 0) 8753c1e38eaSMarcel Moolenaar return (P2T(ret)); 8763c1e38eaSMarcel Moolenaar if (lwp != 0) 877447d36ecSDavid Xu return (0); 8783c1e38eaSMarcel Moolenaar 8793c1e38eaSMarcel Moolenaar tmbx_addr = tcb_addr + offsetof(struct tcb, tcb_tmbx); 8803c1e38eaSMarcel Moolenaar /* 8813c1e38eaSMarcel Moolenaar * context is in userland, some architectures store 8823c1e38eaSMarcel Moolenaar * single step status in registers, we should change 8833c1e38eaSMarcel Moolenaar * these registers. 8843c1e38eaSMarcel Moolenaar */ 8853c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8863c1e38eaSMarcel Moolenaar if (ret == 0) { 8873c1e38eaSMarcel Moolenaar pt_ucontext_to_reg(&tmbx.tm_context, ®s); 8883c1e38eaSMarcel Moolenaar /* only write out if it is really changed. */ 8893c1e38eaSMarcel Moolenaar if (pt_reg_sstep(®s, step) != 0) { 8903c1e38eaSMarcel Moolenaar pt_reg_to_ucontext(®s, &tmbx.tm_context); 8913c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, 8923c1e38eaSMarcel Moolenaar sizeof(tmbx)); 8933c1e38eaSMarcel Moolenaar } 8943c1e38eaSMarcel Moolenaar } 8953c1e38eaSMarcel Moolenaar return (P2T(ret)); 8963c1e38eaSMarcel Moolenaar } 8973c1e38eaSMarcel Moolenaar 8983c1e38eaSMarcel Moolenaar static void 8993c1e38eaSMarcel Moolenaar pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp) 9003c1e38eaSMarcel Moolenaar { 9013c1e38eaSMarcel Moolenaar int i; 9023c1e38eaSMarcel Moolenaar 9033c1e38eaSMarcel Moolenaar for (i = 0; i < ta->map_len; ++i) { 9043c1e38eaSMarcel Moolenaar if (ta->map[i].type == PT_LWP && ta->map[i].lwp == lwp) { 9053c1e38eaSMarcel Moolenaar ta->map[i].type = PT_NONE; 9063c1e38eaSMarcel Moolenaar return; 9073c1e38eaSMarcel Moolenaar } 9083c1e38eaSMarcel Moolenaar } 9093c1e38eaSMarcel Moolenaar } 9103c1e38eaSMarcel Moolenaar 9113c1e38eaSMarcel Moolenaar static int 9123c1e38eaSMarcel Moolenaar pt_validate(const td_thrhandle_t *th) 9133c1e38eaSMarcel Moolenaar { 9143c1e38eaSMarcel Moolenaar 9153c1e38eaSMarcel Moolenaar if (th->th_tid < 0 || th->th_tid >= th->th_ta->map_len || 9163c1e38eaSMarcel Moolenaar th->th_ta->map[th->th_tid].type == PT_NONE) 9173c1e38eaSMarcel Moolenaar return (TD_NOTHR); 9183c1e38eaSMarcel Moolenaar return (TD_OK); 9193c1e38eaSMarcel Moolenaar } 9203c1e38eaSMarcel Moolenaar 9213e93cc3aSDavid Xu td_err_e 9223e93cc3aSDavid Xu pt_thr_tls_get_addr(const td_thrhandle_t *th, void *_linkmap, size_t offset, 9233e93cc3aSDavid Xu void **address) 9243e93cc3aSDavid Xu { 9253e93cc3aSDavid Xu #if 0 9263e93cc3aSDavid Xu Obj_Entry *obj_entry; 9273e93cc3aSDavid Xu const td_thragent_t *ta = th->th_ta; 9283e93cc3aSDavid Xu psaddr_t tcb_addr, *dtv_addr, tcb_tp; 9293e93cc3aSDavid Xu int tls_index, ret; 9303e93cc3aSDavid Xu 9313e93cc3aSDavid Xu /* linkmap is a member of Obj_Entry */ 9323e93cc3aSDavid Xu obj_entry = (Obj_Entry *) 9333e93cc3aSDavid Xu (((char *)_linkmap) - offsetof(Obj_Entry, linkmap)); 9343e93cc3aSDavid Xu 9353e93cc3aSDavid Xu /* get tlsindex of the object file */ 9363e93cc3aSDavid Xu ret = ps_pread(ta->ph, 9373e93cc3aSDavid Xu ((char *)obj_entry) + offsetof(Obj_Entry, tlsindex), 9383e93cc3aSDavid Xu &tls_index, sizeof(tls_index)); 9393e93cc3aSDavid Xu if (ret != 0) 9403e93cc3aSDavid Xu return (P2T(ret)); 9413e93cc3aSDavid Xu 9423e93cc3aSDavid Xu /* get thread tcb */ 9433e93cc3aSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 9443e93cc3aSDavid Xu offsetof(struct pthread, tcb), 9453e93cc3aSDavid Xu &tcb_addr, sizeof(tcb_addr)); 9463e93cc3aSDavid Xu if (ret != 0) 9473e93cc3aSDavid Xu return (P2T(ret)); 9483e93cc3aSDavid Xu 9493e93cc3aSDavid Xu #ifdef TLS_DTV_AT_TCB 9503e93cc3aSDavid Xu /* get dtv array address */ 9513e93cc3aSDavid Xu ret = ps_pread(ta->ph, tcb_addr + offsetof(struct tcb, tcb_dtv), 9523e93cc3aSDavid Xu &dtv_addr, sizeof(dtv_addr)); 9533e93cc3aSDavid Xu if (ret != 0) 9543e93cc3aSDavid Xu return (P2T(ret)); 9553e93cc3aSDavid Xu #else 9563e93cc3aSDavid Xu #ifdef TLS_DTV_AT_TP 9573e93cc3aSDavid Xu ret = ps_pread(ta->ph, tcb_addr + offsetof(struct tcb, tcb_tp), 9583e93cc3aSDavid Xu &tcb_tp, sizeof(tcb_tp)); 9593e93cc3aSDavid Xu if (ret != 0) 9603e93cc3aSDavid Xu return (P2T(ret)); 9613e93cc3aSDavid Xu ret = ps_pread(ta->ph, tcb_tp + offsetof(struct tp, tp_dtv), 9623e93cc3aSDavid Xu &dtv_addr, sizeof(dtv_addr)); 9633e93cc3aSDavid Xu #else 9643e93cc3aSDavid Xu #error "Either TLS_DTV_AT_TP or TLS_DTV_AT_TCB must be defined." 9653e93cc3aSDavid Xu #endif 9663e93cc3aSDavid Xu #endif 9673e93cc3aSDavid Xu /* now get the object's tls block base address */ 9683e93cc3aSDavid Xu ret = ps_pread(ta->ph, &dtv_addr[tls_index+1], address, 9693e93cc3aSDavid Xu sizeof(*address)); 9703e93cc3aSDavid Xu if (ret != 0) 9713e93cc3aSDavid Xu return (P2T(ret)); 9723e93cc3aSDavid Xu 9733e93cc3aSDavid Xu *address += offset; 9743e93cc3aSDavid Xu #endif 9753e93cc3aSDavid Xu return (TD_OK); 9763e93cc3aSDavid Xu } 9773e93cc3aSDavid Xu 9783c1e38eaSMarcel Moolenaar struct ta_ops libpthread_db_ops = { 9793c1e38eaSMarcel Moolenaar .to_init = pt_init, 9803c1e38eaSMarcel Moolenaar .to_ta_clear_event = pt_ta_clear_event, 9813c1e38eaSMarcel Moolenaar .to_ta_delete = pt_ta_delete, 9823c1e38eaSMarcel Moolenaar .to_ta_event_addr = pt_ta_event_addr, 9833c1e38eaSMarcel Moolenaar .to_ta_event_getmsg = pt_ta_event_getmsg, 9843c1e38eaSMarcel Moolenaar .to_ta_map_id2thr = pt_ta_map_id2thr, 9853c1e38eaSMarcel Moolenaar .to_ta_map_lwp2thr = pt_ta_map_lwp2thr, 9863c1e38eaSMarcel Moolenaar .to_ta_new = pt_ta_new, 9873c1e38eaSMarcel Moolenaar .to_ta_set_event = pt_ta_set_event, 9883c1e38eaSMarcel Moolenaar .to_ta_thr_iter = pt_ta_thr_iter, 9893c1e38eaSMarcel Moolenaar .to_ta_tsd_iter = pt_ta_tsd_iter, 9903c1e38eaSMarcel Moolenaar .to_thr_clear_event = pt_thr_clear_event, 9913c1e38eaSMarcel Moolenaar .to_thr_dbresume = pt_thr_dbresume, 9923c1e38eaSMarcel Moolenaar .to_thr_dbsuspend = pt_thr_dbsuspend, 9933c1e38eaSMarcel Moolenaar .to_thr_event_enable = pt_thr_event_enable, 9943c1e38eaSMarcel Moolenaar .to_thr_event_getmsg = pt_thr_event_getmsg, 9953c1e38eaSMarcel Moolenaar .to_thr_get_info = pt_thr_get_info, 9963c1e38eaSMarcel Moolenaar .to_thr_getfpregs = pt_thr_getfpregs, 9973c1e38eaSMarcel Moolenaar .to_thr_getgregs = pt_thr_getgregs, 9983c1e38eaSMarcel Moolenaar .to_thr_set_event = pt_thr_set_event, 9993c1e38eaSMarcel Moolenaar .to_thr_setfpregs = pt_thr_setfpregs, 10003c1e38eaSMarcel Moolenaar .to_thr_setgregs = pt_thr_setgregs, 10013c1e38eaSMarcel Moolenaar .to_thr_validate = pt_thr_validate, 10023e93cc3aSDavid Xu .to_thr_tls_get_addr = pt_thr_tls_get_addr, 10033c1e38eaSMarcel Moolenaar 10043c1e38eaSMarcel Moolenaar /* FreeBSD specific extensions. */ 10053c1e38eaSMarcel Moolenaar .to_thr_sstep = pt_thr_sstep, 10063c1e38eaSMarcel Moolenaar }; 1007