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 303c1e38eaSMarcel Moolenaar #include <stddef.h> 313c1e38eaSMarcel Moolenaar #include <stdlib.h> 323c1e38eaSMarcel Moolenaar #include <string.h> 333c1e38eaSMarcel Moolenaar #include <unistd.h> 343c1e38eaSMarcel Moolenaar #include <pthread.h> 353c1e38eaSMarcel Moolenaar #include <sys/types.h> 363c1e38eaSMarcel Moolenaar #include <sys/kse.h> 373c1e38eaSMarcel Moolenaar #include <sys/ptrace.h> 383c1e38eaSMarcel Moolenaar #include <proc_service.h> 393c1e38eaSMarcel Moolenaar #include <thread_db.h> 403c1e38eaSMarcel Moolenaar 413c1e38eaSMarcel Moolenaar #include "libpthread_db.h" 423c1e38eaSMarcel Moolenaar 433c1e38eaSMarcel Moolenaar #define P2T(c) ps2td(c) 443c1e38eaSMarcel Moolenaar 453c1e38eaSMarcel Moolenaar static void pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp); 463c1e38eaSMarcel Moolenaar static int pt_validate(const td_thrhandle_t *th); 473c1e38eaSMarcel Moolenaar 483c1e38eaSMarcel Moolenaar static int 493c1e38eaSMarcel Moolenaar ps2td(int c) 503c1e38eaSMarcel Moolenaar { 513c1e38eaSMarcel Moolenaar switch (c) { 523c1e38eaSMarcel Moolenaar case PS_OK: 533c1e38eaSMarcel Moolenaar return TD_OK; 543c1e38eaSMarcel Moolenaar case PS_ERR: 553c1e38eaSMarcel Moolenaar return TD_ERR; 563c1e38eaSMarcel Moolenaar case PS_BADPID: 573c1e38eaSMarcel Moolenaar return TD_BADPH; 583c1e38eaSMarcel Moolenaar case PS_BADLID: 593c1e38eaSMarcel Moolenaar return TD_NOLWP; 603c1e38eaSMarcel Moolenaar case PS_BADADDR: 613c1e38eaSMarcel Moolenaar return TD_ERR; 623c1e38eaSMarcel Moolenaar case PS_NOSYM: 633c1e38eaSMarcel Moolenaar return TD_NOLIBTHREAD; 643c1e38eaSMarcel Moolenaar case PS_NOFREGS: 653c1e38eaSMarcel Moolenaar return TD_NOFPREGS; 663c1e38eaSMarcel Moolenaar default: 673c1e38eaSMarcel Moolenaar return TD_ERR; 683c1e38eaSMarcel Moolenaar } 693c1e38eaSMarcel Moolenaar } 703c1e38eaSMarcel Moolenaar 713c1e38eaSMarcel Moolenaar static long 723c1e38eaSMarcel Moolenaar pt_map_thread(const td_thragent_t *const_ta, psaddr_t pt, int type) 733c1e38eaSMarcel Moolenaar { 743c1e38eaSMarcel Moolenaar td_thragent_t *ta = __DECONST(td_thragent_t *, const_ta); 753c1e38eaSMarcel Moolenaar struct pt_map *new; 763c1e38eaSMarcel Moolenaar int i, first = -1; 773c1e38eaSMarcel Moolenaar 783c1e38eaSMarcel Moolenaar /* leave zero out */ 793c1e38eaSMarcel Moolenaar for (i = 1; i < ta->map_len; ++i) { 803c1e38eaSMarcel Moolenaar if (ta->map[i].type == PT_NONE) { 813c1e38eaSMarcel Moolenaar if (first == -1) 823c1e38eaSMarcel Moolenaar first = i; 833c1e38eaSMarcel Moolenaar } else if (ta->map[i].type == type && ta->map[i].thr == pt) { 843c1e38eaSMarcel Moolenaar return (i); 853c1e38eaSMarcel Moolenaar } 863c1e38eaSMarcel Moolenaar } 873c1e38eaSMarcel Moolenaar 883c1e38eaSMarcel Moolenaar if (first == -1) { 893c1e38eaSMarcel Moolenaar if (ta->map_len == 0) { 903c1e38eaSMarcel Moolenaar ta->map = calloc(20, sizeof(struct pt_map)); 913c1e38eaSMarcel Moolenaar if (ta->map == NULL) 923c1e38eaSMarcel Moolenaar return (-1); 933c1e38eaSMarcel Moolenaar ta->map_len = 20; 943c1e38eaSMarcel Moolenaar first = 1; 953c1e38eaSMarcel Moolenaar } else { 963c1e38eaSMarcel Moolenaar new = realloc(ta->map, 973c1e38eaSMarcel Moolenaar sizeof(struct pt_map) * ta->map_len * 2); 983c1e38eaSMarcel Moolenaar if (new == NULL) 993c1e38eaSMarcel Moolenaar return (-1); 1003c1e38eaSMarcel Moolenaar memset(new + ta->map_len, '\0', sizeof(struct pt_map) * 1013c1e38eaSMarcel Moolenaar ta->map_len); 1023c1e38eaSMarcel Moolenaar first = ta->map_len; 1033c1e38eaSMarcel Moolenaar ta->map = new; 1043c1e38eaSMarcel Moolenaar ta->map_len *= 2; 1053c1e38eaSMarcel Moolenaar } 1063c1e38eaSMarcel Moolenaar } 1073c1e38eaSMarcel Moolenaar 1083c1e38eaSMarcel Moolenaar ta->map[first].type = type; 1093c1e38eaSMarcel Moolenaar ta->map[first].thr = pt; 1103c1e38eaSMarcel Moolenaar return (first); 1113c1e38eaSMarcel Moolenaar } 1123c1e38eaSMarcel Moolenaar 1133c1e38eaSMarcel Moolenaar static td_err_e 1143c1e38eaSMarcel Moolenaar pt_init(void) 1153c1e38eaSMarcel Moolenaar { 1163c1e38eaSMarcel Moolenaar pt_md_init(); 1173c1e38eaSMarcel Moolenaar return (0); 1183c1e38eaSMarcel Moolenaar } 1193c1e38eaSMarcel Moolenaar 1203c1e38eaSMarcel Moolenaar static td_err_e 1213c1e38eaSMarcel Moolenaar pt_ta_new(struct ps_prochandle *ph, td_thragent_t **pta) 1223c1e38eaSMarcel Moolenaar { 1233c1e38eaSMarcel Moolenaar #define LOOKUP_SYM(proc, sym, addr) \ 1243c1e38eaSMarcel Moolenaar ret = ps_pglobal_lookup(proc, NULL, sym, addr); \ 1253c1e38eaSMarcel Moolenaar if (ret != 0) { \ 1263c1e38eaSMarcel Moolenaar TDBG("can not find symbol: %s\n", sym); \ 1273c1e38eaSMarcel Moolenaar ret = TD_NOLIBTHREAD; \ 1283c1e38eaSMarcel Moolenaar goto error; \ 1293c1e38eaSMarcel Moolenaar } 1303c1e38eaSMarcel Moolenaar 131cd980d46SDavid Xu #define LOOKUP_VAL(proc, sym, val) \ 132cd980d46SDavid Xu ret = ps_pglobal_lookup(proc, NULL, sym, &vaddr);\ 133cd980d46SDavid Xu if (ret != 0) { \ 134cd980d46SDavid Xu TDBG("can not find symbol: %s\n", sym); \ 135cd980d46SDavid Xu ret = TD_NOLIBTHREAD; \ 136cd980d46SDavid Xu goto error; \ 137cd980d46SDavid Xu } \ 138cd980d46SDavid Xu ret = ps_pread(proc, vaddr, val, sizeof(int)); \ 139cd980d46SDavid Xu if (ret != 0) { \ 140cd980d46SDavid Xu TDBG("can not read value of %s\n", sym);\ 141cd980d46SDavid Xu ret = TD_NOLIBTHREAD; \ 142cd980d46SDavid Xu goto error; \ 143cd980d46SDavid Xu } 144cd980d46SDavid Xu 1453c1e38eaSMarcel Moolenaar td_thragent_t *ta; 146cd980d46SDavid Xu psaddr_t vaddr; 1473c1e38eaSMarcel Moolenaar int dbg; 1483c1e38eaSMarcel Moolenaar int ret; 1493c1e38eaSMarcel Moolenaar 1503c1e38eaSMarcel Moolenaar TDBG_FUNC(); 1513c1e38eaSMarcel Moolenaar 1523c1e38eaSMarcel Moolenaar ta = malloc(sizeof(td_thragent_t)); 1533c1e38eaSMarcel Moolenaar if (ta == NULL) 1543c1e38eaSMarcel Moolenaar return (TD_MALLOC); 1553c1e38eaSMarcel Moolenaar 1563c1e38eaSMarcel Moolenaar ta->ph = ph; 1573c1e38eaSMarcel Moolenaar ta->thread_activated = 0; 1583c1e38eaSMarcel Moolenaar ta->map = NULL; 1593c1e38eaSMarcel Moolenaar ta->map_len = 0; 1603c1e38eaSMarcel Moolenaar 1613c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_libkse_debug", &ta->libkse_debug_addr); 1623c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_list", &ta->thread_list_addr); 1633c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_activated", &ta->thread_activated_addr); 1643c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_active_threads",&ta->thread_active_threads_addr); 1653c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_keytable", &ta->thread_keytable_addr); 166cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_dtv", &ta->thread_off_dtv); 167cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_kse_locklevel", &ta->thread_off_kse_locklevel); 168cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_kse", &ta->thread_off_kse); 169cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_tlsindex", &ta->thread_off_tlsindex); 170cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_attr_flags", &ta->thread_off_attr_flags); 171cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_size_key", &ta->thread_size_key); 172cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_tcb", &ta->thread_off_tcb); 173cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_linkmap", &ta->thread_off_linkmap); 174cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_tmbx", &ta->thread_off_tmbx); 175cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_thr_locklevel", &ta->thread_off_thr_locklevel); 176cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_next", &ta->thread_off_next); 177cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_state", &ta->thread_off_state); 178cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_max_keys", &ta->thread_max_keys); 179cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_key_allocated", &ta->thread_off_key_allocated); 180cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_key_destructor", &ta->thread_off_key_destructor); 181cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_state_running", &ta->thread_state_running); 182cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_state_zoombie", &ta->thread_state_zoombie); 1833c1e38eaSMarcel Moolenaar dbg = getpid(); 1843c1e38eaSMarcel Moolenaar /* 1853c1e38eaSMarcel Moolenaar * If this fails it probably means we're debugging a core file and 1863c1e38eaSMarcel Moolenaar * can't write to it. 1873c1e38eaSMarcel Moolenaar */ 1883c1e38eaSMarcel Moolenaar ps_pwrite(ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 1893c1e38eaSMarcel Moolenaar *pta = ta; 1903c1e38eaSMarcel Moolenaar return (0); 1913c1e38eaSMarcel Moolenaar 1923c1e38eaSMarcel Moolenaar error: 1933c1e38eaSMarcel Moolenaar free(ta); 1943c1e38eaSMarcel Moolenaar return (ret); 1953c1e38eaSMarcel Moolenaar } 1963c1e38eaSMarcel Moolenaar 1973c1e38eaSMarcel Moolenaar static td_err_e 1983c1e38eaSMarcel Moolenaar pt_ta_delete(td_thragent_t *ta) 1993c1e38eaSMarcel Moolenaar { 2003c1e38eaSMarcel Moolenaar int dbg; 2013c1e38eaSMarcel Moolenaar 2023c1e38eaSMarcel Moolenaar TDBG_FUNC(); 2033c1e38eaSMarcel Moolenaar 2043c1e38eaSMarcel Moolenaar dbg = 0; 2053c1e38eaSMarcel Moolenaar /* 2063c1e38eaSMarcel Moolenaar * Error returns from this write are not really a problem; 2073c1e38eaSMarcel Moolenaar * the process doesn't exist any more. 2083c1e38eaSMarcel Moolenaar */ 2093c1e38eaSMarcel Moolenaar ps_pwrite(ta->ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 2103c1e38eaSMarcel Moolenaar if (ta->map) 2113c1e38eaSMarcel Moolenaar free(ta->map); 2123c1e38eaSMarcel Moolenaar free(ta); 2133c1e38eaSMarcel Moolenaar return (TD_OK); 2143c1e38eaSMarcel Moolenaar } 2153c1e38eaSMarcel Moolenaar 2163c1e38eaSMarcel Moolenaar static td_err_e 2173c1e38eaSMarcel Moolenaar pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th) 2183c1e38eaSMarcel Moolenaar { 2193c1e38eaSMarcel Moolenaar prgregset_t gregs; 2203c1e38eaSMarcel Moolenaar TAILQ_HEAD(, pthread) thread_list; 2213c1e38eaSMarcel Moolenaar psaddr_t pt, tcb_addr; 2223c1e38eaSMarcel Moolenaar lwpid_t lwp; 2233c1e38eaSMarcel Moolenaar int ret; 2243c1e38eaSMarcel Moolenaar 2253c1e38eaSMarcel Moolenaar TDBG_FUNC(); 2263c1e38eaSMarcel Moolenaar 2273c1e38eaSMarcel Moolenaar if (id < 0 || id >= ta->map_len || ta->map[id].type == PT_NONE) 2283c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2293c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 2303c1e38eaSMarcel Moolenaar sizeof(thread_list)); 2313c1e38eaSMarcel Moolenaar if (ret != 0) 2323c1e38eaSMarcel Moolenaar return (P2T(ret)); 2333c1e38eaSMarcel Moolenaar pt = (psaddr_t)thread_list.tqh_first; 2343c1e38eaSMarcel Moolenaar if (ta->map[id].type == PT_LWP) { 2353c1e38eaSMarcel Moolenaar /* 2363c1e38eaSMarcel Moolenaar * if we are referencing a lwp, make sure it was not already 2373c1e38eaSMarcel Moolenaar * mapped to user thread. 2383c1e38eaSMarcel Moolenaar */ 2393c1e38eaSMarcel Moolenaar while (pt != 0) { 2403c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 241cd980d46SDavid Xu pt + ta->thread_off_tcb, 2423c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 2433c1e38eaSMarcel Moolenaar if (ret != 0) 2443c1e38eaSMarcel Moolenaar return (P2T(ret)); 2453c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 246cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 247cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_lwp), 2483c1e38eaSMarcel Moolenaar &lwp, sizeof(lwp)); 2493c1e38eaSMarcel Moolenaar if (ret != 0) 2503c1e38eaSMarcel Moolenaar return (P2T(ret)); 2513c1e38eaSMarcel Moolenaar /* 2523c1e38eaSMarcel Moolenaar * If the lwp was already mapped to userland thread, 2533c1e38eaSMarcel Moolenaar * we shouldn't reference it directly in future. 2543c1e38eaSMarcel Moolenaar */ 2553c1e38eaSMarcel Moolenaar if (lwp == ta->map[id].lwp) { 2563c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2573c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2583c1e38eaSMarcel Moolenaar } 2593c1e38eaSMarcel Moolenaar /* get next thread */ 2603c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 261cd980d46SDavid Xu pt + ta->thread_off_next, 2623c1e38eaSMarcel Moolenaar &pt, sizeof(pt)); 2633c1e38eaSMarcel Moolenaar if (ret != 0) 2643c1e38eaSMarcel Moolenaar return (P2T(ret)); 2653c1e38eaSMarcel Moolenaar } 2663c1e38eaSMarcel Moolenaar /* check lwp */ 2674db106a9SDavid Xu ret = ps_lgetregs(ta->ph, ta->map[id].lwp, gregs); 2684db106a9SDavid Xu if (ret != PS_OK) { 2693c1e38eaSMarcel Moolenaar /* no longer exists */ 2703c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2713c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2723c1e38eaSMarcel Moolenaar } 2733c1e38eaSMarcel Moolenaar } else { 2743c1e38eaSMarcel Moolenaar while (pt != 0 && ta->map[id].thr != pt) { 2753c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 276cd980d46SDavid Xu pt + ta->thread_off_tcb, 2773c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 2783c1e38eaSMarcel Moolenaar if (ret != 0) 2793c1e38eaSMarcel Moolenaar return (P2T(ret)); 2803c1e38eaSMarcel Moolenaar /* get next thread */ 2813c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 282cd980d46SDavid Xu pt + ta->thread_off_next, 2833c1e38eaSMarcel Moolenaar &pt, sizeof(pt)); 2843c1e38eaSMarcel Moolenaar if (ret != 0) 2853c1e38eaSMarcel Moolenaar return (P2T(ret)); 2863c1e38eaSMarcel Moolenaar } 2873c1e38eaSMarcel Moolenaar 2883c1e38eaSMarcel Moolenaar if (pt == 0) { 2893c1e38eaSMarcel Moolenaar /* no longer exists */ 2903c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2913c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2923c1e38eaSMarcel Moolenaar } 2933c1e38eaSMarcel Moolenaar } 2943c1e38eaSMarcel Moolenaar th->th_ta = ta; 2953c1e38eaSMarcel Moolenaar th->th_tid = id; 2962ec2da86SDavid Xu th->th_thread = pt; 2973c1e38eaSMarcel Moolenaar return (TD_OK); 2983c1e38eaSMarcel Moolenaar } 2993c1e38eaSMarcel Moolenaar 3003c1e38eaSMarcel Moolenaar static td_err_e 3013c1e38eaSMarcel Moolenaar pt_ta_map_lwp2thr(const td_thragent_t *ta, lwpid_t lwp, td_thrhandle_t *th) 3023c1e38eaSMarcel Moolenaar { 3033c1e38eaSMarcel Moolenaar TAILQ_HEAD(, pthread) thread_list; 3043c1e38eaSMarcel Moolenaar psaddr_t pt, ptr; 3053c1e38eaSMarcel Moolenaar lwpid_t tmp_lwp; 3063c1e38eaSMarcel Moolenaar int ret; 3073c1e38eaSMarcel Moolenaar 3083c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3093c1e38eaSMarcel Moolenaar 3103c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 3113c1e38eaSMarcel Moolenaar sizeof(thread_list)); 3123c1e38eaSMarcel Moolenaar if (ret != 0) 3133c1e38eaSMarcel Moolenaar return (P2T(ret)); 3143c1e38eaSMarcel Moolenaar pt = (psaddr_t)thread_list.tqh_first; 3153c1e38eaSMarcel Moolenaar while (pt != 0) { 316cd980d46SDavid Xu ret = ps_pread(ta->ph, pt + ta->thread_off_tcb, 3173c1e38eaSMarcel Moolenaar &ptr, sizeof(ptr)); 3183c1e38eaSMarcel Moolenaar if (ret != 0) 3193c1e38eaSMarcel Moolenaar return (P2T(ret)); 320cd980d46SDavid Xu ptr += ta->thread_off_tmbx + 321cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_lwp); 3223c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &tmp_lwp, sizeof(lwpid_t)); 3233c1e38eaSMarcel Moolenaar if (ret != 0) 3243c1e38eaSMarcel Moolenaar return (P2T(ret)); 3253c1e38eaSMarcel Moolenaar if (tmp_lwp == lwp) { 3263c1e38eaSMarcel Moolenaar th->th_ta = ta; 3273c1e38eaSMarcel Moolenaar th->th_tid = pt_map_thread(ta, pt, PT_USER); 3283c1e38eaSMarcel Moolenaar if (th->th_tid == -1) 3293c1e38eaSMarcel Moolenaar return (TD_MALLOC); 3303c1e38eaSMarcel Moolenaar pt_unmap_lwp(ta, lwp); 3312ec2da86SDavid Xu th->th_thread = pt; 3323c1e38eaSMarcel Moolenaar return (TD_OK); 3333c1e38eaSMarcel Moolenaar } 3343c1e38eaSMarcel Moolenaar 3353c1e38eaSMarcel Moolenaar /* get next thread */ 3363c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 337cd980d46SDavid Xu pt + ta->thread_off_next, 3383c1e38eaSMarcel Moolenaar &pt, sizeof(pt)); 3393c1e38eaSMarcel Moolenaar if (ret != 0) 3403c1e38eaSMarcel Moolenaar return (P2T(ret)); 3413c1e38eaSMarcel Moolenaar } 3423c1e38eaSMarcel Moolenaar 3433c1e38eaSMarcel Moolenaar return (TD_NOTHR); 3443c1e38eaSMarcel Moolenaar } 3453c1e38eaSMarcel Moolenaar 3463c1e38eaSMarcel Moolenaar static td_err_e 3473c1e38eaSMarcel Moolenaar pt_ta_thr_iter(const td_thragent_t *ta, 3483c1e38eaSMarcel Moolenaar td_thr_iter_f *callback, void *cbdata_p, 3493c1e38eaSMarcel Moolenaar td_thr_state_e state, int ti_pri, 3503c1e38eaSMarcel Moolenaar sigset_t *ti_sigmask_p, 3513c1e38eaSMarcel Moolenaar unsigned int ti_user_flags) 3523c1e38eaSMarcel Moolenaar { 3533c1e38eaSMarcel Moolenaar TAILQ_HEAD(, pthread) thread_list; 3543c1e38eaSMarcel Moolenaar td_thrhandle_t th; 3553c1e38eaSMarcel Moolenaar psaddr_t pt; 3563c1e38eaSMarcel Moolenaar ps_err_e pserr; 3573c1e38eaSMarcel Moolenaar int activated; 3583c1e38eaSMarcel Moolenaar 3593c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3603c1e38eaSMarcel Moolenaar 3613c1e38eaSMarcel Moolenaar pserr = ps_pread(ta->ph, ta->thread_activated_addr, &activated, 3623c1e38eaSMarcel Moolenaar sizeof(int)); 3633c1e38eaSMarcel Moolenaar if (pserr != PS_OK) 3643c1e38eaSMarcel Moolenaar return (P2T(pserr)); 3653c1e38eaSMarcel Moolenaar if (!activated) 3663c1e38eaSMarcel Moolenaar return (TD_OK); 3673c1e38eaSMarcel Moolenaar 3683c1e38eaSMarcel Moolenaar pserr = ps_pread(ta->ph, ta->thread_list_addr, &thread_list, 3693c1e38eaSMarcel Moolenaar sizeof(thread_list)); 3703c1e38eaSMarcel Moolenaar if (pserr != 0) 3713c1e38eaSMarcel Moolenaar return (P2T(pserr)); 3723c1e38eaSMarcel Moolenaar pt = (psaddr_t)thread_list.tqh_first; 3733c1e38eaSMarcel Moolenaar while (pt != 0) { 3743c1e38eaSMarcel Moolenaar th.th_ta = ta; 3753c1e38eaSMarcel Moolenaar th.th_tid = pt_map_thread(ta, pt, PT_USER); 3762ec2da86SDavid Xu th.th_thread = pt; 3773c1e38eaSMarcel Moolenaar /* should we unmap lwp here ? */ 3783c1e38eaSMarcel Moolenaar if (th.th_tid == -1) 3793c1e38eaSMarcel Moolenaar return (TD_MALLOC); 3803c1e38eaSMarcel Moolenaar if ((*callback)(&th, cbdata_p)) 3813c1e38eaSMarcel Moolenaar return (TD_DBERR); 3823c1e38eaSMarcel Moolenaar /* get next thread */ 3833c1e38eaSMarcel Moolenaar pserr = ps_pread(ta->ph, 384cd980d46SDavid Xu pt + ta->thread_off_next, &pt, 3853c1e38eaSMarcel Moolenaar sizeof(pt)); 3863c1e38eaSMarcel Moolenaar if (pserr != PS_OK) 3873c1e38eaSMarcel Moolenaar return (P2T(pserr)); 3883c1e38eaSMarcel Moolenaar } 3893c1e38eaSMarcel Moolenaar return (TD_OK); 3903c1e38eaSMarcel Moolenaar } 3913c1e38eaSMarcel Moolenaar 3923c1e38eaSMarcel Moolenaar static td_err_e 3933c1e38eaSMarcel Moolenaar pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg) 3943c1e38eaSMarcel Moolenaar { 395cd980d46SDavid Xu char *keytable; 396cd980d46SDavid Xu void *destructor; 397cd980d46SDavid Xu int i, ret, allocated; 3983c1e38eaSMarcel Moolenaar 3993c1e38eaSMarcel Moolenaar TDBG_FUNC(); 4003c1e38eaSMarcel Moolenaar 401cd980d46SDavid Xu keytable = malloc(ta->thread_max_keys * ta->thread_size_key); 402cd980d46SDavid Xu if (keytable == NULL) 403cd980d46SDavid Xu return (TD_MALLOC); 4043c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, (psaddr_t)ta->thread_keytable_addr, keytable, 405cd980d46SDavid Xu ta->thread_max_keys * ta->thread_size_key); 4062eb43a64SDavid Xu if (ret != 0) { 4072eb43a64SDavid Xu free(keytable); 4083c1e38eaSMarcel Moolenaar return (P2T(ret)); 4092eb43a64SDavid Xu } 410cd980d46SDavid Xu for (i = 0; i < ta->thread_max_keys; i++) { 411cd980d46SDavid Xu allocated = *(int *)(keytable + i * ta->thread_size_key + 412cd980d46SDavid Xu ta->thread_off_key_allocated); 413cd980d46SDavid Xu destructor = *(void **)(keytable + i * ta->thread_size_key + 414cd980d46SDavid Xu ta->thread_off_key_destructor); 415cd980d46SDavid Xu if (allocated) { 416cd980d46SDavid Xu ret = (ki)(i, destructor, arg); 417cd980d46SDavid Xu if (ret != 0) { 418cd980d46SDavid Xu free(keytable); 4193c1e38eaSMarcel Moolenaar return (TD_DBERR); 4203c1e38eaSMarcel Moolenaar } 4213c1e38eaSMarcel Moolenaar } 422cd980d46SDavid Xu } 423cd980d46SDavid Xu free(keytable); 4243c1e38eaSMarcel Moolenaar return (TD_OK); 4253c1e38eaSMarcel Moolenaar } 4263c1e38eaSMarcel Moolenaar 4273c1e38eaSMarcel Moolenaar static td_err_e 4283c1e38eaSMarcel Moolenaar pt_ta_event_addr(const td_thragent_t *ta, td_event_e event, td_notify_t *ptr) 4293c1e38eaSMarcel Moolenaar { 4303c1e38eaSMarcel Moolenaar TDBG_FUNC(); 431a80845eaSDavid Xu return (TD_ERR); 4323c1e38eaSMarcel Moolenaar } 4333c1e38eaSMarcel Moolenaar 4343c1e38eaSMarcel Moolenaar static td_err_e 4353c1e38eaSMarcel Moolenaar pt_ta_set_event(const td_thragent_t *ta, td_thr_events_t *events) 4363c1e38eaSMarcel Moolenaar { 4373c1e38eaSMarcel Moolenaar TDBG_FUNC(); 438a80845eaSDavid Xu return (0); 4393c1e38eaSMarcel Moolenaar } 4403c1e38eaSMarcel Moolenaar 4413c1e38eaSMarcel Moolenaar static td_err_e 4423c1e38eaSMarcel Moolenaar pt_ta_clear_event(const td_thragent_t *ta, td_thr_events_t *events) 4433c1e38eaSMarcel Moolenaar { 4443c1e38eaSMarcel Moolenaar TDBG_FUNC(); 445a80845eaSDavid Xu return (0); 4463c1e38eaSMarcel Moolenaar } 4473c1e38eaSMarcel Moolenaar 4483c1e38eaSMarcel Moolenaar static td_err_e 4493c1e38eaSMarcel Moolenaar pt_ta_event_getmsg(const td_thragent_t *ta, td_event_msg_t *msg) 4503c1e38eaSMarcel Moolenaar { 4513c1e38eaSMarcel Moolenaar TDBG_FUNC(); 4523c1e38eaSMarcel Moolenaar return (TD_NOMSG); 4533c1e38eaSMarcel Moolenaar } 4543c1e38eaSMarcel Moolenaar 4553c1e38eaSMarcel Moolenaar static td_err_e 456447d36ecSDavid Xu pt_dbsuspend(const td_thrhandle_t *th, int suspend) 457447d36ecSDavid Xu { 458447d36ecSDavid Xu td_thragent_t *ta = (td_thragent_t *)th->th_ta; 459447d36ecSDavid Xu psaddr_t tcb_addr, tmbx_addr, ptr; 460447d36ecSDavid Xu lwpid_t lwp; 461447d36ecSDavid Xu uint32_t dflags; 4623e93cc3aSDavid Xu int attrflags, locklevel, ret; 463447d36ecSDavid Xu 464447d36ecSDavid Xu TDBG_FUNC(); 465447d36ecSDavid Xu 466447d36ecSDavid Xu ret = pt_validate(th); 467447d36ecSDavid Xu if (ret) 468447d36ecSDavid Xu return (ret); 469447d36ecSDavid Xu 470447d36ecSDavid Xu if (ta->map[th->th_tid].type == PT_LWP) { 471447d36ecSDavid Xu if (suspend) 472447d36ecSDavid Xu ret = ps_lstop(ta->ph, ta->map[th->th_tid].lwp); 473447d36ecSDavid Xu else 474447d36ecSDavid Xu ret = ps_lcontinue(ta->ph, ta->map[th->th_tid].lwp); 475447d36ecSDavid Xu return (P2T(ret)); 476447d36ecSDavid Xu } 477447d36ecSDavid Xu 478447d36ecSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 479cd980d46SDavid Xu ta->thread_off_attr_flags, 480447d36ecSDavid Xu &attrflags, sizeof(attrflags)); 481447d36ecSDavid Xu if (ret != 0) 482447d36ecSDavid Xu return (P2T(ret)); 483447d36ecSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 484cd980d46SDavid Xu ta->thread_off_tcb, 485447d36ecSDavid Xu &tcb_addr, sizeof(tcb_addr)); 486447d36ecSDavid Xu if (ret != 0) 487447d36ecSDavid Xu return (P2T(ret)); 488cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 489447d36ecSDavid Xu ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 490447d36ecSDavid Xu ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 491447d36ecSDavid Xu if (ret != 0) 492447d36ecSDavid Xu return (P2T(ret)); 4933e93cc3aSDavid Xu 4943e93cc3aSDavid Xu if (lwp != 0) { 4953e93cc3aSDavid Xu /* don't suspend signal thread */ 496cd980d46SDavid Xu if (attrflags & 0x200) 4973e93cc3aSDavid Xu return (0); 4983e93cc3aSDavid Xu if (attrflags & PTHREAD_SCOPE_SYSTEM) { 4993e93cc3aSDavid Xu /* 5003e93cc3aSDavid Xu * don't suspend system scope thread if it is holding 5013e93cc3aSDavid Xu * some low level locks 5023e93cc3aSDavid Xu */ 503cd980d46SDavid Xu ptr = ta->map[th->th_tid].thr + ta->thread_off_kse; 504447d36ecSDavid Xu ret = ps_pread(ta->ph, ptr, &ptr, sizeof(ptr)); 505447d36ecSDavid Xu if (ret != 0) 506447d36ecSDavid Xu return (P2T(ret)); 507cd980d46SDavid Xu ret = ps_pread(ta->ph, ptr + ta->thread_off_kse_locklevel, 508cd980d46SDavid Xu &locklevel, sizeof(int)); 509447d36ecSDavid Xu if (ret != 0) 510447d36ecSDavid Xu return (P2T(ret)); 5113e93cc3aSDavid Xu if (locklevel <= 0) { 5123e93cc3aSDavid Xu ptr = ta->map[th->th_tid].thr + 513cd980d46SDavid Xu ta->thread_off_thr_locklevel; 5143e93cc3aSDavid Xu ret = ps_pread(ta->ph, ptr, &locklevel, 5153e93cc3aSDavid Xu sizeof(int)); 516447d36ecSDavid Xu if (ret != 0) 517447d36ecSDavid Xu return (P2T(ret)); 518447d36ecSDavid Xu } 5193e93cc3aSDavid Xu if (suspend) { 5203e93cc3aSDavid Xu if (locklevel <= 0) 5213e93cc3aSDavid Xu ret = ps_lstop(ta->ph, lwp); 5223e93cc3aSDavid Xu } else { 5233e93cc3aSDavid Xu ret = ps_lcontinue(ta->ph, lwp); 5243e93cc3aSDavid Xu } 5253e93cc3aSDavid Xu if (ret != 0) 5263e93cc3aSDavid Xu return (P2T(ret)); 527447d36ecSDavid Xu /* FALLTHROUGH */ 5283e93cc3aSDavid Xu } else { 5293e93cc3aSDavid Xu struct ptrace_lwpinfo pl; 5303e93cc3aSDavid Xu 5316ff81bf5SDavid Xu if (ps_linfo(ta->ph, lwp, (caddr_t)&pl)) 5323e93cc3aSDavid Xu return (TD_ERR); 5333e93cc3aSDavid Xu if (suspend) { 5343e93cc3aSDavid Xu if (!(pl.pl_flags & PL_FLAG_BOUND)) 5353e93cc3aSDavid Xu ret = ps_lstop(ta->ph, lwp); 5363e93cc3aSDavid Xu } else { 5373e93cc3aSDavid Xu ret = ps_lcontinue(ta->ph, lwp); 5383e93cc3aSDavid Xu } 5393e93cc3aSDavid Xu if (ret != 0) 5403e93cc3aSDavid Xu return (P2T(ret)); 5413e93cc3aSDavid Xu /* FALLTHROUGH */ 5423e93cc3aSDavid Xu } 543447d36ecSDavid Xu } 544447d36ecSDavid Xu /* read tm_dflags */ 545447d36ecSDavid Xu ret = ps_pread(ta->ph, 546447d36ecSDavid Xu tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 547447d36ecSDavid Xu &dflags, sizeof(dflags)); 548447d36ecSDavid Xu if (ret != 0) 549447d36ecSDavid Xu return (P2T(ret)); 550447d36ecSDavid Xu if (suspend) 5514513fb36SDavid Xu dflags |= TMDF_SUSPEND; 552447d36ecSDavid Xu else 5534513fb36SDavid Xu dflags &= ~TMDF_SUSPEND; 554447d36ecSDavid Xu ret = ps_pwrite(ta->ph, 555447d36ecSDavid Xu tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 556447d36ecSDavid Xu &dflags, sizeof(dflags)); 557447d36ecSDavid Xu return (P2T(ret)); 558447d36ecSDavid Xu } 559447d36ecSDavid Xu 560447d36ecSDavid Xu static td_err_e 5613c1e38eaSMarcel Moolenaar pt_thr_dbresume(const td_thrhandle_t *th) 5623c1e38eaSMarcel Moolenaar { 5633c1e38eaSMarcel Moolenaar TDBG_FUNC(); 564447d36ecSDavid Xu 565447d36ecSDavid Xu return pt_dbsuspend(th, 0); 5663c1e38eaSMarcel Moolenaar } 5673c1e38eaSMarcel Moolenaar 5683c1e38eaSMarcel Moolenaar static td_err_e 5693c1e38eaSMarcel Moolenaar pt_thr_dbsuspend(const td_thrhandle_t *th) 5703c1e38eaSMarcel Moolenaar { 5713c1e38eaSMarcel Moolenaar TDBG_FUNC(); 572447d36ecSDavid Xu 573447d36ecSDavid Xu return pt_dbsuspend(th, 1); 5743c1e38eaSMarcel Moolenaar } 5753c1e38eaSMarcel Moolenaar 5763c1e38eaSMarcel Moolenaar static td_err_e 5773c1e38eaSMarcel Moolenaar pt_thr_validate(const td_thrhandle_t *th) 5783c1e38eaSMarcel Moolenaar { 5793c1e38eaSMarcel Moolenaar td_thrhandle_t temp; 5803c1e38eaSMarcel Moolenaar int ret; 5813c1e38eaSMarcel Moolenaar 5823c1e38eaSMarcel Moolenaar TDBG_FUNC(); 5833c1e38eaSMarcel Moolenaar 5843c1e38eaSMarcel Moolenaar ret = pt_ta_map_id2thr(th->th_ta, th->th_tid, 5853c1e38eaSMarcel Moolenaar &temp); 586447d36ecSDavid Xu return (ret); 5873c1e38eaSMarcel Moolenaar } 5883c1e38eaSMarcel Moolenaar 5893c1e38eaSMarcel Moolenaar static td_err_e 5903c1e38eaSMarcel Moolenaar pt_thr_get_info(const td_thrhandle_t *th, td_thrinfo_t *info) 5913c1e38eaSMarcel Moolenaar { 5923c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 593cd980d46SDavid Xu psaddr_t tcb_addr; 594447d36ecSDavid Xu uint32_t dflags; 595cd980d46SDavid Xu int state; 596cd980d46SDavid Xu int ret; 5973c1e38eaSMarcel Moolenaar 5983c1e38eaSMarcel Moolenaar TDBG_FUNC(); 5993c1e38eaSMarcel Moolenaar 60083154c48SDavid Xu bzero(info, sizeof(*info)); 6013c1e38eaSMarcel Moolenaar ret = pt_validate(th); 6023c1e38eaSMarcel Moolenaar if (ret) 6033c1e38eaSMarcel Moolenaar return (ret); 6043c1e38eaSMarcel Moolenaar 6053c1e38eaSMarcel Moolenaar memset(info, 0, sizeof(*info)); 6063c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 6073c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_SYSTEM; 6083c1e38eaSMarcel Moolenaar info->ti_lid = ta->map[th->th_tid].lwp; 6093c1e38eaSMarcel Moolenaar info->ti_tid = th->th_tid; 6103c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_RUN; 6113c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_SYSTEM; 6123c1e38eaSMarcel Moolenaar return (TD_OK); 6133c1e38eaSMarcel Moolenaar } 614cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 615cd980d46SDavid Xu &tcb_addr, sizeof(tcb_addr)); 6163c1e38eaSMarcel Moolenaar if (ret != 0) 6173c1e38eaSMarcel Moolenaar return (P2T(ret)); 618cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_state, 619cd980d46SDavid Xu &state, sizeof(state)); 6203c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 621cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 622cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_lwp), 6233c1e38eaSMarcel Moolenaar &info->ti_lid, sizeof(lwpid_t)); 6243c1e38eaSMarcel Moolenaar if (ret != 0) 6253c1e38eaSMarcel Moolenaar return (P2T(ret)); 626447d36ecSDavid Xu ret = ps_pread(ta->ph, 627cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 628cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_dflags), 629447d36ecSDavid Xu &dflags, sizeof(dflags)); 630447d36ecSDavid Xu if (ret != 0) 631447d36ecSDavid Xu return (P2T(ret)); 6323c1e38eaSMarcel Moolenaar info->ti_ta_p = th->th_ta; 6333c1e38eaSMarcel Moolenaar info->ti_tid = th->th_tid; 634cd980d46SDavid Xu if (state == ta->thread_state_running) 6353c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_RUN; 636cd980d46SDavid Xu else if (state == ta->thread_state_zoombie) 6373c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_ZOMBIE; 638cd980d46SDavid Xu else 639cd980d46SDavid Xu info->ti_state = TD_THR_SLEEP; 6404513fb36SDavid Xu info->ti_db_suspended = ((dflags & TMDF_SUSPEND) != 0); 6413c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_USER; 6423c1e38eaSMarcel Moolenaar return (0); 6433c1e38eaSMarcel Moolenaar } 6443c1e38eaSMarcel Moolenaar 6458d7681bbSDoug Rabson #ifdef __i386__ 6468d7681bbSDoug Rabson static td_err_e 6478d7681bbSDoug Rabson pt_thr_getxmmregs(const td_thrhandle_t *th, char *fxsave) 6488d7681bbSDoug Rabson { 6498d7681bbSDoug Rabson const td_thragent_t *ta = th->th_ta; 6508d7681bbSDoug Rabson struct kse_thr_mailbox tmbx; 6518d7681bbSDoug Rabson psaddr_t tcb_addr, tmbx_addr, ptr; 6528d7681bbSDoug Rabson lwpid_t lwp; 6538d7681bbSDoug Rabson int ret; 6548d7681bbSDoug Rabson 6558d7681bbSDoug Rabson return TD_ERR; 6568d7681bbSDoug Rabson 6578d7681bbSDoug Rabson TDBG_FUNC(); 6588d7681bbSDoug Rabson 6598d7681bbSDoug Rabson ret = pt_validate(th); 6608d7681bbSDoug Rabson if (ret) 6618d7681bbSDoug Rabson return (ret); 6628d7681bbSDoug Rabson 6638d7681bbSDoug Rabson if (ta->map[th->th_tid].type == PT_LWP) { 6648d7681bbSDoug Rabson ret = ps_lgetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave); 6658d7681bbSDoug Rabson return (P2T(ret)); 6668d7681bbSDoug Rabson } 6678d7681bbSDoug Rabson 6688d7681bbSDoug Rabson ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 6698d7681bbSDoug Rabson &tcb_addr, sizeof(tcb_addr)); 6708d7681bbSDoug Rabson if (ret != 0) 6718d7681bbSDoug Rabson return (P2T(ret)); 6728d7681bbSDoug Rabson tmbx_addr = tcb_addr + ta->thread_off_tmbx; 6738d7681bbSDoug Rabson ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 6748d7681bbSDoug Rabson ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 6758d7681bbSDoug Rabson if (ret != 0) 6768d7681bbSDoug Rabson return (P2T(ret)); 6778d7681bbSDoug Rabson if (lwp != 0) { 6788d7681bbSDoug Rabson ret = ps_lgetxmmregs(ta->ph, lwp, fxsave); 6798d7681bbSDoug Rabson return (P2T(ret)); 6808d7681bbSDoug Rabson } 6818d7681bbSDoug Rabson 6828d7681bbSDoug Rabson ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 6838d7681bbSDoug Rabson if (ret != 0) 6848d7681bbSDoug Rabson return (P2T(ret)); 6858d7681bbSDoug Rabson pt_ucontext_to_fxsave(&tmbx.tm_context, fxsave); 6868d7681bbSDoug Rabson return (0); 6878d7681bbSDoug Rabson } 6888d7681bbSDoug Rabson #endif 6898d7681bbSDoug Rabson 6903c1e38eaSMarcel Moolenaar static td_err_e 6913c1e38eaSMarcel Moolenaar pt_thr_getfpregs(const td_thrhandle_t *th, prfpregset_t *fpregs) 6923c1e38eaSMarcel Moolenaar { 6933c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 6943c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 6953c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 6963c1e38eaSMarcel Moolenaar lwpid_t lwp; 6973c1e38eaSMarcel Moolenaar int ret; 6983c1e38eaSMarcel Moolenaar 6993c1e38eaSMarcel Moolenaar TDBG_FUNC(); 7003c1e38eaSMarcel Moolenaar 7013c1e38eaSMarcel Moolenaar ret = pt_validate(th); 7023c1e38eaSMarcel Moolenaar if (ret) 7033c1e38eaSMarcel Moolenaar return (ret); 7043c1e38eaSMarcel Moolenaar 7053c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 7063c1e38eaSMarcel Moolenaar ret = ps_lgetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 7073c1e38eaSMarcel Moolenaar return (P2T(ret)); 7083c1e38eaSMarcel Moolenaar } 7093c1e38eaSMarcel Moolenaar 710cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 7113c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 7123c1e38eaSMarcel Moolenaar if (ret != 0) 7133c1e38eaSMarcel Moolenaar return (P2T(ret)); 714cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 7153c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 7163c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 7173c1e38eaSMarcel Moolenaar if (ret != 0) 7183c1e38eaSMarcel Moolenaar return (P2T(ret)); 7193c1e38eaSMarcel Moolenaar if (lwp != 0) { 7203c1e38eaSMarcel Moolenaar ret = ps_lgetfpregs(ta->ph, lwp, fpregs); 7213c1e38eaSMarcel Moolenaar return (P2T(ret)); 7223c1e38eaSMarcel Moolenaar } 7233c1e38eaSMarcel Moolenaar 7243c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7253c1e38eaSMarcel Moolenaar if (ret != 0) 7263c1e38eaSMarcel Moolenaar return (P2T(ret)); 7273c1e38eaSMarcel Moolenaar pt_ucontext_to_fpreg(&tmbx.tm_context, fpregs); 7283c1e38eaSMarcel Moolenaar return (0); 7293c1e38eaSMarcel Moolenaar } 7303c1e38eaSMarcel Moolenaar 7313c1e38eaSMarcel Moolenaar static td_err_e 7323c1e38eaSMarcel Moolenaar pt_thr_getgregs(const td_thrhandle_t *th, prgregset_t gregs) 7333c1e38eaSMarcel Moolenaar { 7343c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 7353c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 7363c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 7373c1e38eaSMarcel Moolenaar lwpid_t lwp; 7383c1e38eaSMarcel Moolenaar int ret; 7393c1e38eaSMarcel Moolenaar 7403c1e38eaSMarcel Moolenaar TDBG_FUNC(); 7413c1e38eaSMarcel Moolenaar 7423c1e38eaSMarcel Moolenaar ret = pt_validate(th); 7433c1e38eaSMarcel Moolenaar if (ret) 7443c1e38eaSMarcel Moolenaar return (ret); 7453c1e38eaSMarcel Moolenaar 7463c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 7473c1e38eaSMarcel Moolenaar ret = ps_lgetregs(ta->ph, 7483c1e38eaSMarcel Moolenaar ta->map[th->th_tid].lwp, gregs); 7493c1e38eaSMarcel Moolenaar return (P2T(ret)); 7503c1e38eaSMarcel Moolenaar } 7513c1e38eaSMarcel Moolenaar 752cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 7533c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 7543c1e38eaSMarcel Moolenaar if (ret != 0) 7553c1e38eaSMarcel Moolenaar return (P2T(ret)); 756cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 7573c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 7583c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 7593c1e38eaSMarcel Moolenaar if (ret != 0) 7603c1e38eaSMarcel Moolenaar return (P2T(ret)); 7613c1e38eaSMarcel Moolenaar if (lwp != 0) { 7623c1e38eaSMarcel Moolenaar ret = ps_lgetregs(ta->ph, lwp, gregs); 7633c1e38eaSMarcel Moolenaar return (P2T(ret)); 7643c1e38eaSMarcel Moolenaar } 7653c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7663c1e38eaSMarcel Moolenaar if (ret != 0) 7673c1e38eaSMarcel Moolenaar return (P2T(ret)); 7683c1e38eaSMarcel Moolenaar pt_ucontext_to_reg(&tmbx.tm_context, gregs); 7693c1e38eaSMarcel Moolenaar return (0); 7703c1e38eaSMarcel Moolenaar } 7713c1e38eaSMarcel Moolenaar 7728d7681bbSDoug Rabson #ifdef __i386__ 7738d7681bbSDoug Rabson static td_err_e 7748d7681bbSDoug Rabson pt_thr_setxmmregs(const td_thrhandle_t *th, const char *fxsave) 7758d7681bbSDoug Rabson { 7768d7681bbSDoug Rabson const td_thragent_t *ta = th->th_ta; 7778d7681bbSDoug Rabson struct kse_thr_mailbox tmbx; 7788d7681bbSDoug Rabson psaddr_t tcb_addr, tmbx_addr, ptr; 7798d7681bbSDoug Rabson lwpid_t lwp; 7808d7681bbSDoug Rabson int ret; 7818d7681bbSDoug Rabson 7828d7681bbSDoug Rabson return TD_ERR; 7838d7681bbSDoug Rabson 7848d7681bbSDoug Rabson TDBG_FUNC(); 7858d7681bbSDoug Rabson 7868d7681bbSDoug Rabson ret = pt_validate(th); 7878d7681bbSDoug Rabson if (ret) 7888d7681bbSDoug Rabson return (ret); 7898d7681bbSDoug Rabson 7908d7681bbSDoug Rabson if (ta->map[th->th_tid].type == PT_LWP) { 7918d7681bbSDoug Rabson ret = ps_lsetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave); 7928d7681bbSDoug Rabson return (P2T(ret)); 7938d7681bbSDoug Rabson } 7948d7681bbSDoug Rabson 7958d7681bbSDoug Rabson ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 7968d7681bbSDoug Rabson ta->thread_off_tcb, 7978d7681bbSDoug Rabson &tcb_addr, sizeof(tcb_addr)); 7988d7681bbSDoug Rabson if (ret != 0) 7998d7681bbSDoug Rabson return (P2T(ret)); 8008d7681bbSDoug Rabson tmbx_addr = tcb_addr + ta->thread_off_tmbx; 8018d7681bbSDoug Rabson ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 8028d7681bbSDoug Rabson ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 8038d7681bbSDoug Rabson if (ret != 0) 8048d7681bbSDoug Rabson return (P2T(ret)); 8058d7681bbSDoug Rabson if (lwp != 0) { 8068d7681bbSDoug Rabson ret = ps_lsetxmmregs(ta->ph, lwp, fxsave); 8078d7681bbSDoug Rabson return (P2T(ret)); 8088d7681bbSDoug Rabson } 8098d7681bbSDoug Rabson /* 8108d7681bbSDoug Rabson * Read a copy of context, this makes sure that registers 8118d7681bbSDoug Rabson * not covered by structure reg won't be clobbered 8128d7681bbSDoug Rabson */ 8138d7681bbSDoug Rabson ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8148d7681bbSDoug Rabson if (ret != 0) 8158d7681bbSDoug Rabson return (P2T(ret)); 8168d7681bbSDoug Rabson 8178d7681bbSDoug Rabson pt_fxsave_to_ucontext(fxsave, &tmbx.tm_context); 8188d7681bbSDoug Rabson ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8198d7681bbSDoug Rabson return (P2T(ret)); 8208d7681bbSDoug Rabson } 8218d7681bbSDoug Rabson #endif 8228d7681bbSDoug Rabson 8233c1e38eaSMarcel Moolenaar static td_err_e 8243c1e38eaSMarcel Moolenaar pt_thr_setfpregs(const td_thrhandle_t *th, const prfpregset_t *fpregs) 8253c1e38eaSMarcel Moolenaar { 8263c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 8273c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 8283c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 8293c1e38eaSMarcel Moolenaar lwpid_t lwp; 8303c1e38eaSMarcel Moolenaar int ret; 8313c1e38eaSMarcel Moolenaar 8323c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8333c1e38eaSMarcel Moolenaar 8343c1e38eaSMarcel Moolenaar ret = pt_validate(th); 8353c1e38eaSMarcel Moolenaar if (ret) 8363c1e38eaSMarcel Moolenaar return (ret); 8373c1e38eaSMarcel Moolenaar 8383c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 8393c1e38eaSMarcel Moolenaar ret = ps_lsetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 8403c1e38eaSMarcel Moolenaar return (P2T(ret)); 8413c1e38eaSMarcel Moolenaar } 8423c1e38eaSMarcel Moolenaar 8433c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 844cd980d46SDavid Xu ta->thread_off_tcb, 8453c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 8463c1e38eaSMarcel Moolenaar if (ret != 0) 8473c1e38eaSMarcel Moolenaar return (P2T(ret)); 848cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 8493c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 8503c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 8513c1e38eaSMarcel Moolenaar if (ret != 0) 8523c1e38eaSMarcel Moolenaar return (P2T(ret)); 8533c1e38eaSMarcel Moolenaar if (lwp != 0) { 8543c1e38eaSMarcel Moolenaar ret = ps_lsetfpregs(ta->ph, lwp, fpregs); 8553c1e38eaSMarcel Moolenaar return (P2T(ret)); 8563c1e38eaSMarcel Moolenaar } 8573c1e38eaSMarcel Moolenaar /* 8583c1e38eaSMarcel Moolenaar * Read a copy of context, this makes sure that registers 8593c1e38eaSMarcel Moolenaar * not covered by structure reg won't be clobbered 8603c1e38eaSMarcel Moolenaar */ 8613c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8623c1e38eaSMarcel Moolenaar if (ret != 0) 8633c1e38eaSMarcel Moolenaar return (P2T(ret)); 8643c1e38eaSMarcel Moolenaar 8653c1e38eaSMarcel Moolenaar pt_fpreg_to_ucontext(fpregs, &tmbx.tm_context); 8663c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8673c1e38eaSMarcel Moolenaar return (P2T(ret)); 8683c1e38eaSMarcel Moolenaar } 8693c1e38eaSMarcel Moolenaar 8703c1e38eaSMarcel Moolenaar static td_err_e 8713c1e38eaSMarcel Moolenaar pt_thr_setgregs(const td_thrhandle_t *th, const prgregset_t gregs) 8723c1e38eaSMarcel Moolenaar { 8733c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 8743c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 8753c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 8763c1e38eaSMarcel Moolenaar lwpid_t lwp; 8773c1e38eaSMarcel Moolenaar int ret; 8783c1e38eaSMarcel Moolenaar 8793c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8803c1e38eaSMarcel Moolenaar 8813c1e38eaSMarcel Moolenaar ret = pt_validate(th); 8823c1e38eaSMarcel Moolenaar if (ret) 8833c1e38eaSMarcel Moolenaar return (ret); 8843c1e38eaSMarcel Moolenaar 8853c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 8863c1e38eaSMarcel Moolenaar ret = ps_lsetregs(ta->ph, ta->map[th->th_tid].lwp, gregs); 8873c1e38eaSMarcel Moolenaar return (P2T(ret)); 8883c1e38eaSMarcel Moolenaar } 8893c1e38eaSMarcel Moolenaar 8903c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 891cd980d46SDavid Xu ta->thread_off_tcb, 8923c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 8933c1e38eaSMarcel Moolenaar if (ret != 0) 8943c1e38eaSMarcel Moolenaar return (P2T(ret)); 895cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 8963c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 8973c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 8983c1e38eaSMarcel Moolenaar if (ret != 0) 8993c1e38eaSMarcel Moolenaar return (P2T(ret)); 9003c1e38eaSMarcel Moolenaar if (lwp != 0) { 9013c1e38eaSMarcel Moolenaar ret = ps_lsetregs(ta->ph, lwp, gregs); 9023c1e38eaSMarcel Moolenaar return (P2T(ret)); 9033c1e38eaSMarcel Moolenaar } 9043c1e38eaSMarcel Moolenaar 9053c1e38eaSMarcel Moolenaar /* 9063c1e38eaSMarcel Moolenaar * Read a copy of context, make sure that registers 9073c1e38eaSMarcel Moolenaar * not covered by structure reg won't be clobbered 9083c1e38eaSMarcel Moolenaar */ 9093c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 9103c1e38eaSMarcel Moolenaar if (ret != 0) 9113c1e38eaSMarcel Moolenaar return (P2T(ret)); 9123c1e38eaSMarcel Moolenaar pt_reg_to_ucontext(gregs, &tmbx.tm_context); 9133c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 9143c1e38eaSMarcel Moolenaar return (P2T(ret)); 9153c1e38eaSMarcel Moolenaar } 9163c1e38eaSMarcel Moolenaar 9173c1e38eaSMarcel Moolenaar static td_err_e 9183c1e38eaSMarcel Moolenaar pt_thr_event_enable(const td_thrhandle_t *th, int en) 9193c1e38eaSMarcel Moolenaar { 9203c1e38eaSMarcel Moolenaar TDBG_FUNC(); 921a80845eaSDavid Xu return (0); 9223c1e38eaSMarcel Moolenaar } 9233c1e38eaSMarcel Moolenaar 9243c1e38eaSMarcel Moolenaar static td_err_e 9253c1e38eaSMarcel Moolenaar pt_thr_set_event(const td_thrhandle_t *th, td_thr_events_t *setp) 9263c1e38eaSMarcel Moolenaar { 9273c1e38eaSMarcel Moolenaar TDBG_FUNC(); 928a80845eaSDavid Xu return (0); 9293c1e38eaSMarcel Moolenaar } 9303c1e38eaSMarcel Moolenaar 9313c1e38eaSMarcel Moolenaar static td_err_e 9323c1e38eaSMarcel Moolenaar pt_thr_clear_event(const td_thrhandle_t *th, td_thr_events_t *setp) 9333c1e38eaSMarcel Moolenaar { 9343c1e38eaSMarcel Moolenaar TDBG_FUNC(); 935a80845eaSDavid Xu return (0); 9363c1e38eaSMarcel Moolenaar } 9373c1e38eaSMarcel Moolenaar 9383c1e38eaSMarcel Moolenaar static td_err_e 9393c1e38eaSMarcel Moolenaar pt_thr_event_getmsg(const td_thrhandle_t *th, td_event_msg_t *msg) 9403c1e38eaSMarcel Moolenaar { 9413c1e38eaSMarcel Moolenaar TDBG_FUNC(); 9423c1e38eaSMarcel Moolenaar return (TD_NOMSG); 9433c1e38eaSMarcel Moolenaar } 9443c1e38eaSMarcel Moolenaar 9453c1e38eaSMarcel Moolenaar static td_err_e 9463c1e38eaSMarcel Moolenaar pt_thr_sstep(const td_thrhandle_t *th, int step) 9473c1e38eaSMarcel Moolenaar { 9483c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 9493c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 9503c1e38eaSMarcel Moolenaar struct reg regs; 9513c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr; 952447d36ecSDavid Xu uint32_t dflags; 9533c1e38eaSMarcel Moolenaar lwpid_t lwp; 9543c1e38eaSMarcel Moolenaar int ret; 9553c1e38eaSMarcel Moolenaar 9563c1e38eaSMarcel Moolenaar TDBG_FUNC(); 9573c1e38eaSMarcel Moolenaar 9583c1e38eaSMarcel Moolenaar ret = pt_validate(th); 9593c1e38eaSMarcel Moolenaar if (ret) 9603c1e38eaSMarcel Moolenaar return (ret); 9613c1e38eaSMarcel Moolenaar 9623c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) 9633c1e38eaSMarcel Moolenaar return (TD_BADTH); 9643c1e38eaSMarcel Moolenaar 9653c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 966cd980d46SDavid Xu ta->thread_off_tcb, 9673c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 9683c1e38eaSMarcel Moolenaar if (ret != 0) 9693c1e38eaSMarcel Moolenaar return (P2T(ret)); 9703c1e38eaSMarcel Moolenaar 9713c1e38eaSMarcel Moolenaar /* Clear or set single step flag in thread mailbox */ 972cd980d46SDavid Xu ret = ps_pread(ta->ph, 973cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 974cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_dflags), 975cd980d46SDavid Xu &dflags, sizeof(uint32_t)); 976447d36ecSDavid Xu if (ret != 0) 977447d36ecSDavid Xu return (P2T(ret)); 978447d36ecSDavid Xu if (step != 0) 979447d36ecSDavid Xu dflags |= TMDF_SSTEP; 980447d36ecSDavid Xu else 981447d36ecSDavid Xu dflags &= ~TMDF_SSTEP; 982cd980d46SDavid Xu ret = ps_pwrite(ta->ph, 983cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 984cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_dflags), 985cd980d46SDavid Xu &dflags, sizeof(uint32_t)); 9863c1e38eaSMarcel Moolenaar if (ret != 0) 9873c1e38eaSMarcel Moolenaar return (P2T(ret)); 9883c1e38eaSMarcel Moolenaar /* Get lwp */ 989cd980d46SDavid Xu ret = ps_pread(ta->ph, 990cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 991cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_lwp), 992cd980d46SDavid Xu &lwp, sizeof(lwpid_t)); 9933c1e38eaSMarcel Moolenaar if (ret != 0) 9943c1e38eaSMarcel Moolenaar return (P2T(ret)); 9953c1e38eaSMarcel Moolenaar if (lwp != 0) 996447d36ecSDavid Xu return (0); 9973c1e38eaSMarcel Moolenaar 998cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 9993c1e38eaSMarcel Moolenaar /* 10003c1e38eaSMarcel Moolenaar * context is in userland, some architectures store 10013c1e38eaSMarcel Moolenaar * single step status in registers, we should change 10023c1e38eaSMarcel Moolenaar * these registers. 10033c1e38eaSMarcel Moolenaar */ 10043c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 10053c1e38eaSMarcel Moolenaar if (ret == 0) { 10063c1e38eaSMarcel Moolenaar pt_ucontext_to_reg(&tmbx.tm_context, ®s); 10073c1e38eaSMarcel Moolenaar /* only write out if it is really changed. */ 10083c1e38eaSMarcel Moolenaar if (pt_reg_sstep(®s, step) != 0) { 10093c1e38eaSMarcel Moolenaar pt_reg_to_ucontext(®s, &tmbx.tm_context); 10103c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, 10113c1e38eaSMarcel Moolenaar sizeof(tmbx)); 10123c1e38eaSMarcel Moolenaar } 10133c1e38eaSMarcel Moolenaar } 10143c1e38eaSMarcel Moolenaar return (P2T(ret)); 10153c1e38eaSMarcel Moolenaar } 10163c1e38eaSMarcel Moolenaar 10173c1e38eaSMarcel Moolenaar static void 10183c1e38eaSMarcel Moolenaar pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp) 10193c1e38eaSMarcel Moolenaar { 10203c1e38eaSMarcel Moolenaar int i; 10213c1e38eaSMarcel Moolenaar 10223c1e38eaSMarcel Moolenaar for (i = 0; i < ta->map_len; ++i) { 10233c1e38eaSMarcel Moolenaar if (ta->map[i].type == PT_LWP && ta->map[i].lwp == lwp) { 10243c1e38eaSMarcel Moolenaar ta->map[i].type = PT_NONE; 10253c1e38eaSMarcel Moolenaar return; 10263c1e38eaSMarcel Moolenaar } 10273c1e38eaSMarcel Moolenaar } 10283c1e38eaSMarcel Moolenaar } 10293c1e38eaSMarcel Moolenaar 10303c1e38eaSMarcel Moolenaar static int 10313c1e38eaSMarcel Moolenaar pt_validate(const td_thrhandle_t *th) 10323c1e38eaSMarcel Moolenaar { 10333c1e38eaSMarcel Moolenaar 10343c1e38eaSMarcel Moolenaar if (th->th_tid < 0 || th->th_tid >= th->th_ta->map_len || 10353c1e38eaSMarcel Moolenaar th->th_ta->map[th->th_tid].type == PT_NONE) 10363c1e38eaSMarcel Moolenaar return (TD_NOTHR); 10373c1e38eaSMarcel Moolenaar return (TD_OK); 10383c1e38eaSMarcel Moolenaar } 10393c1e38eaSMarcel Moolenaar 10403e93cc3aSDavid Xu td_err_e 10413e93cc3aSDavid Xu pt_thr_tls_get_addr(const td_thrhandle_t *th, void *_linkmap, size_t offset, 10423e93cc3aSDavid Xu void **address) 10433e93cc3aSDavid Xu { 1044cd980d46SDavid Xu char *obj_entry; 10453e93cc3aSDavid Xu const td_thragent_t *ta = th->th_ta; 1046d36dd0b7SPhilippe Charnier psaddr_t tcb_addr, *dtv_addr; 10473e93cc3aSDavid Xu int tls_index, ret; 10483e93cc3aSDavid Xu 10493e93cc3aSDavid Xu /* linkmap is a member of Obj_Entry */ 1050cd980d46SDavid Xu obj_entry = (char *)_linkmap - ta->thread_off_linkmap; 10513e93cc3aSDavid Xu 10523e93cc3aSDavid Xu /* get tlsindex of the object file */ 10533e93cc3aSDavid Xu ret = ps_pread(ta->ph, 1054cd980d46SDavid Xu obj_entry + ta->thread_off_tlsindex, 10553e93cc3aSDavid Xu &tls_index, sizeof(tls_index)); 10563e93cc3aSDavid Xu if (ret != 0) 10573e93cc3aSDavid Xu return (P2T(ret)); 10583e93cc3aSDavid Xu 10593e93cc3aSDavid Xu /* get thread tcb */ 10603e93cc3aSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 1061cd980d46SDavid Xu ta->thread_off_tcb, 10623e93cc3aSDavid Xu &tcb_addr, sizeof(tcb_addr)); 10633e93cc3aSDavid Xu if (ret != 0) 10643e93cc3aSDavid Xu return (P2T(ret)); 10653e93cc3aSDavid Xu 10663e93cc3aSDavid Xu /* get dtv array address */ 1067cd980d46SDavid Xu ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_dtv, 10683e93cc3aSDavid Xu &dtv_addr, sizeof(dtv_addr)); 10693e93cc3aSDavid Xu if (ret != 0) 10703e93cc3aSDavid Xu return (P2T(ret)); 10713e93cc3aSDavid Xu /* now get the object's tls block base address */ 10723e93cc3aSDavid Xu ret = ps_pread(ta->ph, &dtv_addr[tls_index+1], address, 10733e93cc3aSDavid Xu sizeof(*address)); 10743e93cc3aSDavid Xu if (ret != 0) 10753e93cc3aSDavid Xu return (P2T(ret)); 10763e93cc3aSDavid Xu 10773e93cc3aSDavid Xu *address += offset; 10783e93cc3aSDavid Xu return (TD_OK); 10793e93cc3aSDavid Xu } 10803e93cc3aSDavid Xu 10813c1e38eaSMarcel Moolenaar struct ta_ops libpthread_db_ops = { 10823c1e38eaSMarcel Moolenaar .to_init = pt_init, 10833c1e38eaSMarcel Moolenaar .to_ta_clear_event = pt_ta_clear_event, 10843c1e38eaSMarcel Moolenaar .to_ta_delete = pt_ta_delete, 10853c1e38eaSMarcel Moolenaar .to_ta_event_addr = pt_ta_event_addr, 10863c1e38eaSMarcel Moolenaar .to_ta_event_getmsg = pt_ta_event_getmsg, 10873c1e38eaSMarcel Moolenaar .to_ta_map_id2thr = pt_ta_map_id2thr, 10883c1e38eaSMarcel Moolenaar .to_ta_map_lwp2thr = pt_ta_map_lwp2thr, 10893c1e38eaSMarcel Moolenaar .to_ta_new = pt_ta_new, 10903c1e38eaSMarcel Moolenaar .to_ta_set_event = pt_ta_set_event, 10913c1e38eaSMarcel Moolenaar .to_ta_thr_iter = pt_ta_thr_iter, 10923c1e38eaSMarcel Moolenaar .to_ta_tsd_iter = pt_ta_tsd_iter, 10933c1e38eaSMarcel Moolenaar .to_thr_clear_event = pt_thr_clear_event, 10943c1e38eaSMarcel Moolenaar .to_thr_dbresume = pt_thr_dbresume, 10953c1e38eaSMarcel Moolenaar .to_thr_dbsuspend = pt_thr_dbsuspend, 10963c1e38eaSMarcel Moolenaar .to_thr_event_enable = pt_thr_event_enable, 10973c1e38eaSMarcel Moolenaar .to_thr_event_getmsg = pt_thr_event_getmsg, 10983c1e38eaSMarcel Moolenaar .to_thr_get_info = pt_thr_get_info, 10993c1e38eaSMarcel Moolenaar .to_thr_getfpregs = pt_thr_getfpregs, 11003c1e38eaSMarcel Moolenaar .to_thr_getgregs = pt_thr_getgregs, 11013c1e38eaSMarcel Moolenaar .to_thr_set_event = pt_thr_set_event, 11023c1e38eaSMarcel Moolenaar .to_thr_setfpregs = pt_thr_setfpregs, 11033c1e38eaSMarcel Moolenaar .to_thr_setgregs = pt_thr_setgregs, 11043c1e38eaSMarcel Moolenaar .to_thr_validate = pt_thr_validate, 11053e93cc3aSDavid Xu .to_thr_tls_get_addr = pt_thr_tls_get_addr, 11063c1e38eaSMarcel Moolenaar 11073c1e38eaSMarcel Moolenaar /* FreeBSD specific extensions. */ 11083c1e38eaSMarcel Moolenaar .to_thr_sstep = pt_thr_sstep, 11098d7681bbSDoug Rabson #ifdef __i386__ 11108d7681bbSDoug Rabson .to_thr_getxmmregs = pt_thr_getxmmregs, 11118d7681bbSDoug Rabson .to_thr_setxmmregs = pt_thr_setxmmregs, 11128d7681bbSDoug Rabson #endif 11133c1e38eaSMarcel Moolenaar }; 1114