15e53a4f9SPedro F. Giffuni /*- 25e53a4f9SPedro F. Giffuni * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 35e53a4f9SPedro F. Giffuni * 43c1e38eaSMarcel Moolenaar * Copyright (c) 2004 David Xu <davidxu@freebsd.org> 53c1e38eaSMarcel Moolenaar * All rights reserved. 63c1e38eaSMarcel Moolenaar * 73c1e38eaSMarcel Moolenaar * Redistribution and use in source and binary forms, with or without 83c1e38eaSMarcel Moolenaar * modification, are permitted provided that the following conditions 93c1e38eaSMarcel Moolenaar * are met: 103c1e38eaSMarcel Moolenaar * 1. Redistributions of source code must retain the above copyright 113c1e38eaSMarcel Moolenaar * notice, this list of conditions and the following disclaimer. 123c1e38eaSMarcel Moolenaar * 2. Redistributions in binary form must reproduce the above copyright 133c1e38eaSMarcel Moolenaar * notice, this list of conditions and the following disclaimer in the 143c1e38eaSMarcel Moolenaar * documentation and/or other materials provided with the distribution. 153c1e38eaSMarcel Moolenaar * 163c1e38eaSMarcel Moolenaar * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 173c1e38eaSMarcel Moolenaar * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 183c1e38eaSMarcel Moolenaar * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 193c1e38eaSMarcel Moolenaar * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 203c1e38eaSMarcel Moolenaar * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 213c1e38eaSMarcel Moolenaar * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 223c1e38eaSMarcel Moolenaar * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 233c1e38eaSMarcel Moolenaar * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 243c1e38eaSMarcel Moolenaar * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 253c1e38eaSMarcel Moolenaar * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 263c1e38eaSMarcel Moolenaar * SUCH DAMAGE. 273c1e38eaSMarcel Moolenaar */ 283c1e38eaSMarcel Moolenaar 293c1e38eaSMarcel Moolenaar #include <sys/cdefs.h> 303c1e38eaSMarcel Moolenaar __FBSDID("$FreeBSD$"); 313c1e38eaSMarcel Moolenaar 323c1e38eaSMarcel Moolenaar #include <stddef.h> 333c1e38eaSMarcel Moolenaar #include <stdlib.h> 343c1e38eaSMarcel Moolenaar #include <string.h> 353c1e38eaSMarcel Moolenaar #include <unistd.h> 363c1e38eaSMarcel Moolenaar #include <pthread.h> 373c1e38eaSMarcel Moolenaar #include <sys/types.h> 3820b94d80SDavid Xu #include <sys/linker_set.h> 393c1e38eaSMarcel Moolenaar #include <sys/ptrace.h> 403c1e38eaSMarcel Moolenaar #include <proc_service.h> 413c1e38eaSMarcel Moolenaar #include <thread_db.h> 423c1e38eaSMarcel Moolenaar 433c1e38eaSMarcel Moolenaar #include "libpthread_db.h" 44fbb275f5SJeff Roberson #include "kse.h" 453c1e38eaSMarcel Moolenaar 463c1e38eaSMarcel Moolenaar #define P2T(c) ps2td(c) 473c1e38eaSMarcel Moolenaar 483c1e38eaSMarcel Moolenaar static void pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp); 493c1e38eaSMarcel Moolenaar static int pt_validate(const td_thrhandle_t *th); 503c1e38eaSMarcel Moolenaar 513c1e38eaSMarcel Moolenaar static int 523c1e38eaSMarcel Moolenaar ps2td(int c) 533c1e38eaSMarcel Moolenaar { 543c1e38eaSMarcel Moolenaar switch (c) { 553c1e38eaSMarcel Moolenaar case PS_OK: 563c1e38eaSMarcel Moolenaar return TD_OK; 573c1e38eaSMarcel Moolenaar case PS_ERR: 583c1e38eaSMarcel Moolenaar return TD_ERR; 593c1e38eaSMarcel Moolenaar case PS_BADPID: 603c1e38eaSMarcel Moolenaar return TD_BADPH; 613c1e38eaSMarcel Moolenaar case PS_BADLID: 623c1e38eaSMarcel Moolenaar return TD_NOLWP; 633c1e38eaSMarcel Moolenaar case PS_BADADDR: 643c1e38eaSMarcel Moolenaar return TD_ERR; 653c1e38eaSMarcel Moolenaar case PS_NOSYM: 663c1e38eaSMarcel Moolenaar return TD_NOLIBTHREAD; 673c1e38eaSMarcel Moolenaar case PS_NOFREGS: 683c1e38eaSMarcel Moolenaar return TD_NOFPREGS; 693c1e38eaSMarcel Moolenaar default: 703c1e38eaSMarcel Moolenaar return TD_ERR; 713c1e38eaSMarcel Moolenaar } 723c1e38eaSMarcel Moolenaar } 733c1e38eaSMarcel Moolenaar 743c1e38eaSMarcel Moolenaar static long 75820c1c55SMarcel Moolenaar pt_map_thread(const td_thragent_t *const_ta, psaddr_t pt, enum pt_type type) 763c1e38eaSMarcel Moolenaar { 773c1e38eaSMarcel Moolenaar td_thragent_t *ta = __DECONST(td_thragent_t *, const_ta); 783c1e38eaSMarcel Moolenaar struct pt_map *new; 791f2b051dSPedro F. Giffuni int first = -1; 801f2b051dSPedro F. Giffuni unsigned int i; 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 { 1001f2b051dSPedro F. Giffuni new = reallocarray(ta->map, ta->map_len, 1011f2b051dSPedro F. Giffuni 2 * sizeof(struct pt_map)); 1023c1e38eaSMarcel Moolenaar if (new == NULL) 1033c1e38eaSMarcel Moolenaar return (-1); 1041f2b051dSPedro F. Giffuni memset(new + ta->map_len, '\0', ta->map_len * 1053876a562SPedro F. Giffuni sizeof(struct pt_map)); 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 135cd980d46SDavid Xu #define LOOKUP_VAL(proc, sym, val) \ 136cd980d46SDavid Xu ret = ps_pglobal_lookup(proc, NULL, sym, &vaddr);\ 137cd980d46SDavid Xu if (ret != 0) { \ 138cd980d46SDavid Xu TDBG("can not find symbol: %s\n", sym); \ 139cd980d46SDavid Xu ret = TD_NOLIBTHREAD; \ 140cd980d46SDavid Xu goto error; \ 141cd980d46SDavid Xu } \ 142cd980d46SDavid Xu ret = ps_pread(proc, vaddr, val, sizeof(int)); \ 143cd980d46SDavid Xu if (ret != 0) { \ 144cd980d46SDavid Xu TDBG("can not read value of %s\n", sym);\ 145cd980d46SDavid Xu ret = TD_NOLIBTHREAD; \ 146cd980d46SDavid Xu goto error; \ 147cd980d46SDavid Xu } 148cd980d46SDavid Xu 1493c1e38eaSMarcel Moolenaar td_thragent_t *ta; 150cd980d46SDavid Xu psaddr_t vaddr; 1513c1e38eaSMarcel Moolenaar int dbg; 1523c1e38eaSMarcel Moolenaar int ret; 1533c1e38eaSMarcel Moolenaar 1543c1e38eaSMarcel Moolenaar TDBG_FUNC(); 1553c1e38eaSMarcel Moolenaar 1563c1e38eaSMarcel Moolenaar ta = malloc(sizeof(td_thragent_t)); 1573c1e38eaSMarcel Moolenaar if (ta == NULL) 1583c1e38eaSMarcel Moolenaar return (TD_MALLOC); 1593c1e38eaSMarcel Moolenaar 1603c1e38eaSMarcel Moolenaar ta->ph = ph; 1613c1e38eaSMarcel Moolenaar ta->thread_activated = 0; 1623c1e38eaSMarcel Moolenaar ta->map = NULL; 1633c1e38eaSMarcel Moolenaar ta->map_len = 0; 1643c1e38eaSMarcel Moolenaar 1653c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_libkse_debug", &ta->libkse_debug_addr); 1663c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_list", &ta->thread_list_addr); 1673c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_activated", &ta->thread_activated_addr); 1683c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_active_threads",&ta->thread_active_threads_addr); 1693c1e38eaSMarcel Moolenaar LOOKUP_SYM(ph, "_thread_keytable", &ta->thread_keytable_addr); 170cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_dtv", &ta->thread_off_dtv); 171cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_kse_locklevel", &ta->thread_off_kse_locklevel); 172cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_kse", &ta->thread_off_kse); 173cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_tlsindex", &ta->thread_off_tlsindex); 174cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_attr_flags", &ta->thread_off_attr_flags); 175cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_size_key", &ta->thread_size_key); 176cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_tcb", &ta->thread_off_tcb); 177cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_linkmap", &ta->thread_off_linkmap); 178cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_tmbx", &ta->thread_off_tmbx); 179cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_thr_locklevel", &ta->thread_off_thr_locklevel); 180cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_next", &ta->thread_off_next); 181cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_state", &ta->thread_off_state); 182cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_max_keys", &ta->thread_max_keys); 183cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_key_allocated", &ta->thread_off_key_allocated); 184cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_off_key_destructor", &ta->thread_off_key_destructor); 185cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_state_running", &ta->thread_state_running); 186cd980d46SDavid Xu LOOKUP_VAL(ph, "_thread_state_zoombie", &ta->thread_state_zoombie); 1872ed66c93SDavid Xu LOOKUP_VAL(ph, "_thread_off_sigmask", &ta->thread_off_sigmask); 1882ed66c93SDavid Xu LOOKUP_VAL(ph, "_thread_off_sigpend", &ta->thread_off_sigpend); 1893c1e38eaSMarcel Moolenaar dbg = getpid(); 1903c1e38eaSMarcel Moolenaar /* 1913c1e38eaSMarcel Moolenaar * If this fails it probably means we're debugging a core file and 1923c1e38eaSMarcel Moolenaar * can't write to it. 1933c1e38eaSMarcel Moolenaar */ 1943c1e38eaSMarcel Moolenaar ps_pwrite(ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 1953c1e38eaSMarcel Moolenaar *pta = ta; 1963c1e38eaSMarcel Moolenaar return (0); 1973c1e38eaSMarcel Moolenaar 1983c1e38eaSMarcel Moolenaar error: 1993c1e38eaSMarcel Moolenaar free(ta); 2003c1e38eaSMarcel Moolenaar return (ret); 2013c1e38eaSMarcel Moolenaar } 2023c1e38eaSMarcel Moolenaar 2033c1e38eaSMarcel Moolenaar static td_err_e 2043c1e38eaSMarcel Moolenaar pt_ta_delete(td_thragent_t *ta) 2053c1e38eaSMarcel Moolenaar { 2063c1e38eaSMarcel Moolenaar int dbg; 2073c1e38eaSMarcel Moolenaar 2083c1e38eaSMarcel Moolenaar TDBG_FUNC(); 2093c1e38eaSMarcel Moolenaar 2103c1e38eaSMarcel Moolenaar dbg = 0; 2113c1e38eaSMarcel Moolenaar /* 2123c1e38eaSMarcel Moolenaar * Error returns from this write are not really a problem; 2133c1e38eaSMarcel Moolenaar * the process doesn't exist any more. 2143c1e38eaSMarcel Moolenaar */ 2153c1e38eaSMarcel Moolenaar ps_pwrite(ta->ph, ta->libkse_debug_addr, &dbg, sizeof(int)); 2163c1e38eaSMarcel Moolenaar if (ta->map) 2173c1e38eaSMarcel Moolenaar free(ta->map); 2183c1e38eaSMarcel Moolenaar free(ta); 2193c1e38eaSMarcel Moolenaar return (TD_OK); 2203c1e38eaSMarcel Moolenaar } 2213c1e38eaSMarcel Moolenaar 2223c1e38eaSMarcel Moolenaar static td_err_e 2233c1e38eaSMarcel Moolenaar pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th) 2243c1e38eaSMarcel Moolenaar { 2253c1e38eaSMarcel Moolenaar prgregset_t gregs; 2263c1e38eaSMarcel Moolenaar psaddr_t pt, tcb_addr; 2273c1e38eaSMarcel Moolenaar lwpid_t lwp; 2283c1e38eaSMarcel Moolenaar int ret; 2293c1e38eaSMarcel Moolenaar 2303c1e38eaSMarcel Moolenaar TDBG_FUNC(); 2313c1e38eaSMarcel Moolenaar 2328413ef57SPedro F. Giffuni if (id < 0 || id >= (long)ta->map_len || ta->map[id].type == PT_NONE) 2333c1e38eaSMarcel Moolenaar return (TD_NOTHR); 23403fad2adSMarcel Moolenaar 23503fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt); 2363c1e38eaSMarcel Moolenaar if (ret != 0) 23703fad2adSMarcel Moolenaar return (TD_ERR); 2383c1e38eaSMarcel Moolenaar if (ta->map[id].type == PT_LWP) { 2393c1e38eaSMarcel Moolenaar /* 2403c1e38eaSMarcel Moolenaar * if we are referencing a lwp, make sure it was not already 2413c1e38eaSMarcel Moolenaar * mapped to user thread. 2423c1e38eaSMarcel Moolenaar */ 2433c1e38eaSMarcel Moolenaar while (pt != 0) { 24403fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb, 24503fad2adSMarcel Moolenaar &tcb_addr); 2463c1e38eaSMarcel Moolenaar if (ret != 0) 24703fad2adSMarcel Moolenaar return (TD_ERR); 24803fad2adSMarcel Moolenaar ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx + 24903fad2adSMarcel Moolenaar offsetof(struct kse_thr_mailbox, tm_lwp), &lwp); 2503c1e38eaSMarcel Moolenaar if (ret != 0) 25103fad2adSMarcel Moolenaar return (TD_ERR); 2523c1e38eaSMarcel Moolenaar /* 2533c1e38eaSMarcel Moolenaar * If the lwp was already mapped to userland thread, 2543c1e38eaSMarcel Moolenaar * we shouldn't reference it directly in future. 2553c1e38eaSMarcel Moolenaar */ 2563c1e38eaSMarcel Moolenaar if (lwp == ta->map[id].lwp) { 2573c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2583c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2593c1e38eaSMarcel Moolenaar } 2603c1e38eaSMarcel Moolenaar /* get next thread */ 26103fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt); 2623c1e38eaSMarcel Moolenaar if (ret != 0) 26303fad2adSMarcel Moolenaar return (TD_ERR); 2643c1e38eaSMarcel Moolenaar } 2653c1e38eaSMarcel Moolenaar /* check lwp */ 2664db106a9SDavid Xu ret = ps_lgetregs(ta->ph, ta->map[id].lwp, gregs); 2674db106a9SDavid Xu if (ret != PS_OK) { 2683c1e38eaSMarcel Moolenaar /* no longer exists */ 2693c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2703c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2713c1e38eaSMarcel Moolenaar } 2723c1e38eaSMarcel Moolenaar } else { 2733c1e38eaSMarcel Moolenaar while (pt != 0 && ta->map[id].thr != pt) { 27403fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb, 27503fad2adSMarcel Moolenaar &tcb_addr); 2763c1e38eaSMarcel Moolenaar if (ret != 0) 27703fad2adSMarcel Moolenaar return (TD_ERR); 2783c1e38eaSMarcel Moolenaar /* get next thread */ 27903fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt); 2803c1e38eaSMarcel Moolenaar if (ret != 0) 28103fad2adSMarcel Moolenaar return (TD_ERR); 2823c1e38eaSMarcel Moolenaar } 2833c1e38eaSMarcel Moolenaar 2843c1e38eaSMarcel Moolenaar if (pt == 0) { 2853c1e38eaSMarcel Moolenaar /* no longer exists */ 2863c1e38eaSMarcel Moolenaar ta->map[id].type = PT_NONE; 2873c1e38eaSMarcel Moolenaar return (TD_NOTHR); 2883c1e38eaSMarcel Moolenaar } 2893c1e38eaSMarcel Moolenaar } 2903c1e38eaSMarcel Moolenaar th->th_ta = ta; 2913c1e38eaSMarcel Moolenaar th->th_tid = id; 2922ec2da86SDavid Xu th->th_thread = pt; 2933c1e38eaSMarcel Moolenaar return (TD_OK); 2943c1e38eaSMarcel Moolenaar } 2953c1e38eaSMarcel Moolenaar 2963c1e38eaSMarcel Moolenaar static td_err_e 2973c1e38eaSMarcel Moolenaar pt_ta_map_lwp2thr(const td_thragent_t *ta, lwpid_t lwp, td_thrhandle_t *th) 2983c1e38eaSMarcel Moolenaar { 29903fad2adSMarcel Moolenaar psaddr_t pt, tcb_addr; 30003fad2adSMarcel Moolenaar lwpid_t lwp1; 3013c1e38eaSMarcel Moolenaar int ret; 3023c1e38eaSMarcel Moolenaar 3033c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3043c1e38eaSMarcel Moolenaar 30503fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt); 3063c1e38eaSMarcel Moolenaar if (ret != 0) 30703fad2adSMarcel Moolenaar return (TD_ERR); 3083c1e38eaSMarcel Moolenaar while (pt != 0) { 30903fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb, &tcb_addr); 3103c1e38eaSMarcel Moolenaar if (ret != 0) 31103fad2adSMarcel Moolenaar return (TD_ERR); 31203fad2adSMarcel Moolenaar ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx + 31303fad2adSMarcel Moolenaar offsetof(struct kse_thr_mailbox, tm_lwp), &lwp1); 3143c1e38eaSMarcel Moolenaar if (ret != 0) 31503fad2adSMarcel Moolenaar return (TD_ERR); 31603fad2adSMarcel Moolenaar if (lwp1 == lwp) { 3173c1e38eaSMarcel Moolenaar th->th_ta = ta; 3183c1e38eaSMarcel Moolenaar th->th_tid = pt_map_thread(ta, pt, PT_USER); 3193c1e38eaSMarcel Moolenaar if (th->th_tid == -1) 3203c1e38eaSMarcel Moolenaar return (TD_MALLOC); 3213c1e38eaSMarcel Moolenaar pt_unmap_lwp(ta, lwp); 3222ec2da86SDavid Xu th->th_thread = pt; 3233c1e38eaSMarcel Moolenaar return (TD_OK); 3243c1e38eaSMarcel Moolenaar } 3253c1e38eaSMarcel Moolenaar 3263c1e38eaSMarcel Moolenaar /* get next thread */ 32703fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt); 3283c1e38eaSMarcel Moolenaar if (ret != 0) 32903fad2adSMarcel Moolenaar return (TD_ERR); 3303c1e38eaSMarcel Moolenaar } 3313c1e38eaSMarcel Moolenaar 3323c1e38eaSMarcel Moolenaar return (TD_NOTHR); 3333c1e38eaSMarcel Moolenaar } 3343c1e38eaSMarcel Moolenaar 3353c1e38eaSMarcel Moolenaar static td_err_e 336f60a5b31SMarcel Moolenaar pt_ta_thr_iter(const td_thragent_t *ta, td_thr_iter_f *callback, 337f60a5b31SMarcel Moolenaar void *cbdata_p, td_thr_state_e state __unused, int ti_pri __unused, 338f60a5b31SMarcel Moolenaar sigset_t *ti_sigmask_p __unused, unsigned int ti_user_flags __unused) 3393c1e38eaSMarcel Moolenaar { 3403c1e38eaSMarcel Moolenaar td_thrhandle_t th; 3413c1e38eaSMarcel Moolenaar psaddr_t pt; 3423c1e38eaSMarcel Moolenaar ps_err_e pserr; 34303fad2adSMarcel Moolenaar int activated, ret; 3443c1e38eaSMarcel Moolenaar 3453c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3463c1e38eaSMarcel Moolenaar 3473c1e38eaSMarcel Moolenaar pserr = ps_pread(ta->ph, ta->thread_activated_addr, &activated, 3483c1e38eaSMarcel Moolenaar sizeof(int)); 3493c1e38eaSMarcel Moolenaar if (pserr != PS_OK) 3503c1e38eaSMarcel Moolenaar return (P2T(pserr)); 3513c1e38eaSMarcel Moolenaar if (!activated) 3523c1e38eaSMarcel Moolenaar return (TD_OK); 3533c1e38eaSMarcel Moolenaar 35403fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt); 35503fad2adSMarcel Moolenaar if (ret != 0) 35603fad2adSMarcel Moolenaar return (TD_ERR); 3573c1e38eaSMarcel Moolenaar while (pt != 0) { 3583c1e38eaSMarcel Moolenaar th.th_ta = ta; 3593c1e38eaSMarcel Moolenaar th.th_tid = pt_map_thread(ta, pt, PT_USER); 3602ec2da86SDavid Xu th.th_thread = pt; 3613c1e38eaSMarcel Moolenaar /* should we unmap lwp here ? */ 3623c1e38eaSMarcel Moolenaar if (th.th_tid == -1) 3633c1e38eaSMarcel Moolenaar return (TD_MALLOC); 3643c1e38eaSMarcel Moolenaar if ((*callback)(&th, cbdata_p)) 3653c1e38eaSMarcel Moolenaar return (TD_DBERR); 3663c1e38eaSMarcel Moolenaar /* get next thread */ 36703fad2adSMarcel Moolenaar ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt); 36803fad2adSMarcel Moolenaar if (ret != 0) 36903fad2adSMarcel Moolenaar return (TD_ERR); 3703c1e38eaSMarcel Moolenaar } 3713c1e38eaSMarcel Moolenaar return (TD_OK); 3723c1e38eaSMarcel Moolenaar } 3733c1e38eaSMarcel Moolenaar 3743c1e38eaSMarcel Moolenaar static td_err_e 3753c1e38eaSMarcel Moolenaar pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg) 3763c1e38eaSMarcel Moolenaar { 377f60a5b31SMarcel Moolenaar void *keytable; 378cd980d46SDavid Xu void *destructor; 379cd980d46SDavid Xu int i, ret, allocated; 3803c1e38eaSMarcel Moolenaar 3813c1e38eaSMarcel Moolenaar TDBG_FUNC(); 3823c1e38eaSMarcel Moolenaar 383cd980d46SDavid Xu keytable = malloc(ta->thread_max_keys * ta->thread_size_key); 384cd980d46SDavid Xu if (keytable == NULL) 385cd980d46SDavid Xu return (TD_MALLOC); 3863c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, (psaddr_t)ta->thread_keytable_addr, keytable, 387cd980d46SDavid Xu ta->thread_max_keys * ta->thread_size_key); 3882eb43a64SDavid Xu if (ret != 0) { 3892eb43a64SDavid Xu free(keytable); 3903c1e38eaSMarcel Moolenaar return (P2T(ret)); 3912eb43a64SDavid Xu } 392cd980d46SDavid Xu for (i = 0; i < ta->thread_max_keys; i++) { 393f60a5b31SMarcel Moolenaar allocated = *(int *)(void *)((uintptr_t)keytable + 394f60a5b31SMarcel Moolenaar i * ta->thread_size_key + ta->thread_off_key_allocated); 395f60a5b31SMarcel Moolenaar destructor = *(void **)(void *)((uintptr_t)keytable + 396f60a5b31SMarcel Moolenaar i * ta->thread_size_key + ta->thread_off_key_destructor); 397cd980d46SDavid Xu if (allocated) { 398cd980d46SDavid Xu ret = (ki)(i, destructor, arg); 399cd980d46SDavid Xu if (ret != 0) { 400cd980d46SDavid Xu free(keytable); 4013c1e38eaSMarcel Moolenaar return (TD_DBERR); 4023c1e38eaSMarcel Moolenaar } 4033c1e38eaSMarcel Moolenaar } 404cd980d46SDavid Xu } 405cd980d46SDavid Xu free(keytable); 4063c1e38eaSMarcel Moolenaar return (TD_OK); 4073c1e38eaSMarcel Moolenaar } 4083c1e38eaSMarcel Moolenaar 4093c1e38eaSMarcel Moolenaar static td_err_e 410f60a5b31SMarcel Moolenaar pt_ta_event_addr(const td_thragent_t *ta __unused, td_event_e event __unused, 411f60a5b31SMarcel Moolenaar td_notify_t *ptr __unused) 4123c1e38eaSMarcel Moolenaar { 4133c1e38eaSMarcel Moolenaar TDBG_FUNC(); 414a80845eaSDavid Xu return (TD_ERR); 4153c1e38eaSMarcel Moolenaar } 4163c1e38eaSMarcel Moolenaar 4173c1e38eaSMarcel Moolenaar static td_err_e 418f60a5b31SMarcel Moolenaar pt_ta_set_event(const td_thragent_t *ta __unused, 419f60a5b31SMarcel Moolenaar td_thr_events_t *events __unused) 4203c1e38eaSMarcel Moolenaar { 4213c1e38eaSMarcel Moolenaar TDBG_FUNC(); 422a80845eaSDavid Xu return (0); 4233c1e38eaSMarcel Moolenaar } 4243c1e38eaSMarcel Moolenaar 4253c1e38eaSMarcel Moolenaar static td_err_e 426f60a5b31SMarcel Moolenaar pt_ta_clear_event(const td_thragent_t *ta __unused, 427f60a5b31SMarcel Moolenaar td_thr_events_t *events __unused) 4283c1e38eaSMarcel Moolenaar { 4293c1e38eaSMarcel Moolenaar TDBG_FUNC(); 430a80845eaSDavid Xu return (0); 4313c1e38eaSMarcel Moolenaar } 4323c1e38eaSMarcel Moolenaar 4333c1e38eaSMarcel Moolenaar static td_err_e 434f60a5b31SMarcel Moolenaar pt_ta_event_getmsg(const td_thragent_t *ta __unused, 435f60a5b31SMarcel Moolenaar td_event_msg_t *msg __unused) 4363c1e38eaSMarcel Moolenaar { 4373c1e38eaSMarcel Moolenaar TDBG_FUNC(); 4383c1e38eaSMarcel Moolenaar return (TD_NOMSG); 4393c1e38eaSMarcel Moolenaar } 4403c1e38eaSMarcel Moolenaar 4413c1e38eaSMarcel Moolenaar static td_err_e 442447d36ecSDavid Xu pt_dbsuspend(const td_thrhandle_t *th, int suspend) 443447d36ecSDavid Xu { 444f60a5b31SMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 445447d36ecSDavid Xu psaddr_t tcb_addr, tmbx_addr, ptr; 446447d36ecSDavid Xu lwpid_t lwp; 447447d36ecSDavid Xu uint32_t dflags; 4483e93cc3aSDavid Xu int attrflags, locklevel, ret; 449447d36ecSDavid Xu 450447d36ecSDavid Xu TDBG_FUNC(); 451447d36ecSDavid Xu 452447d36ecSDavid Xu ret = pt_validate(th); 453447d36ecSDavid Xu if (ret) 454447d36ecSDavid Xu return (ret); 455447d36ecSDavid Xu 456447d36ecSDavid Xu if (ta->map[th->th_tid].type == PT_LWP) { 457447d36ecSDavid Xu if (suspend) 458447d36ecSDavid Xu ret = ps_lstop(ta->ph, ta->map[th->th_tid].lwp); 459447d36ecSDavid Xu else 460447d36ecSDavid Xu ret = ps_lcontinue(ta->ph, ta->map[th->th_tid].lwp); 461447d36ecSDavid Xu return (P2T(ret)); 462447d36ecSDavid Xu } 463447d36ecSDavid Xu 464447d36ecSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 465cd980d46SDavid Xu ta->thread_off_attr_flags, 466447d36ecSDavid Xu &attrflags, sizeof(attrflags)); 467447d36ecSDavid Xu if (ret != 0) 468447d36ecSDavid Xu return (P2T(ret)); 469447d36ecSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 470cd980d46SDavid Xu ta->thread_off_tcb, 471447d36ecSDavid Xu &tcb_addr, sizeof(tcb_addr)); 472447d36ecSDavid Xu if (ret != 0) 473447d36ecSDavid Xu return (P2T(ret)); 474cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 475447d36ecSDavid Xu ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 476447d36ecSDavid Xu ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 477447d36ecSDavid Xu if (ret != 0) 478447d36ecSDavid Xu return (P2T(ret)); 4793e93cc3aSDavid Xu 4803e93cc3aSDavid Xu if (lwp != 0) { 4813e93cc3aSDavid Xu /* don't suspend signal thread */ 482cd980d46SDavid Xu if (attrflags & 0x200) 4833e93cc3aSDavid Xu return (0); 4843e93cc3aSDavid Xu if (attrflags & PTHREAD_SCOPE_SYSTEM) { 4853e93cc3aSDavid Xu /* 4863e93cc3aSDavid Xu * don't suspend system scope thread if it is holding 4873e93cc3aSDavid Xu * some low level locks 4883e93cc3aSDavid Xu */ 489cd980d46SDavid Xu ptr = ta->map[th->th_tid].thr + ta->thread_off_kse; 490447d36ecSDavid Xu ret = ps_pread(ta->ph, ptr, &ptr, sizeof(ptr)); 491447d36ecSDavid Xu if (ret != 0) 492447d36ecSDavid Xu return (P2T(ret)); 493cd980d46SDavid Xu ret = ps_pread(ta->ph, ptr + ta->thread_off_kse_locklevel, 494cd980d46SDavid Xu &locklevel, sizeof(int)); 495447d36ecSDavid Xu if (ret != 0) 496447d36ecSDavid Xu return (P2T(ret)); 4973e93cc3aSDavid Xu if (locklevel <= 0) { 4983e93cc3aSDavid Xu ptr = ta->map[th->th_tid].thr + 499cd980d46SDavid Xu ta->thread_off_thr_locklevel; 5003e93cc3aSDavid Xu ret = ps_pread(ta->ph, ptr, &locklevel, 5013e93cc3aSDavid Xu sizeof(int)); 502447d36ecSDavid Xu if (ret != 0) 503447d36ecSDavid Xu return (P2T(ret)); 504447d36ecSDavid Xu } 5053e93cc3aSDavid Xu if (suspend) { 5063e93cc3aSDavid Xu if (locklevel <= 0) 5073e93cc3aSDavid Xu ret = ps_lstop(ta->ph, lwp); 5083e93cc3aSDavid Xu } else { 5093e93cc3aSDavid Xu ret = ps_lcontinue(ta->ph, lwp); 5103e93cc3aSDavid Xu } 5113e93cc3aSDavid Xu if (ret != 0) 5123e93cc3aSDavid Xu return (P2T(ret)); 513447d36ecSDavid Xu /* FALLTHROUGH */ 5143e93cc3aSDavid Xu } else { 5153e93cc3aSDavid Xu struct ptrace_lwpinfo pl; 5163e93cc3aSDavid Xu 5176ff81bf5SDavid Xu if (ps_linfo(ta->ph, lwp, (caddr_t)&pl)) 5183e93cc3aSDavid Xu return (TD_ERR); 5193e93cc3aSDavid Xu if (suspend) { 5203e93cc3aSDavid Xu if (!(pl.pl_flags & PL_FLAG_BOUND)) 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)); 5273e93cc3aSDavid Xu /* FALLTHROUGH */ 5283e93cc3aSDavid Xu } 529447d36ecSDavid Xu } 530447d36ecSDavid Xu /* read tm_dflags */ 531447d36ecSDavid Xu ret = ps_pread(ta->ph, 532447d36ecSDavid Xu tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 533447d36ecSDavid Xu &dflags, sizeof(dflags)); 534447d36ecSDavid Xu if (ret != 0) 535447d36ecSDavid Xu return (P2T(ret)); 536447d36ecSDavid Xu if (suspend) 5374513fb36SDavid Xu dflags |= TMDF_SUSPEND; 538447d36ecSDavid Xu else 5394513fb36SDavid Xu dflags &= ~TMDF_SUSPEND; 540447d36ecSDavid Xu ret = ps_pwrite(ta->ph, 541447d36ecSDavid Xu tmbx_addr + offsetof(struct kse_thr_mailbox, tm_dflags), 542447d36ecSDavid Xu &dflags, sizeof(dflags)); 543447d36ecSDavid Xu return (P2T(ret)); 544447d36ecSDavid Xu } 545447d36ecSDavid Xu 546447d36ecSDavid Xu static td_err_e 5473c1e38eaSMarcel Moolenaar pt_thr_dbresume(const td_thrhandle_t *th) 5483c1e38eaSMarcel Moolenaar { 5493c1e38eaSMarcel Moolenaar TDBG_FUNC(); 550447d36ecSDavid Xu 551447d36ecSDavid Xu return pt_dbsuspend(th, 0); 5523c1e38eaSMarcel Moolenaar } 5533c1e38eaSMarcel Moolenaar 5543c1e38eaSMarcel Moolenaar static td_err_e 5553c1e38eaSMarcel Moolenaar pt_thr_dbsuspend(const td_thrhandle_t *th) 5563c1e38eaSMarcel Moolenaar { 5573c1e38eaSMarcel Moolenaar TDBG_FUNC(); 558447d36ecSDavid Xu 559447d36ecSDavid Xu return pt_dbsuspend(th, 1); 5603c1e38eaSMarcel Moolenaar } 5613c1e38eaSMarcel Moolenaar 5623c1e38eaSMarcel Moolenaar static td_err_e 5633c1e38eaSMarcel Moolenaar pt_thr_validate(const td_thrhandle_t *th) 5643c1e38eaSMarcel Moolenaar { 5653c1e38eaSMarcel Moolenaar td_thrhandle_t temp; 5663c1e38eaSMarcel Moolenaar int ret; 5673c1e38eaSMarcel Moolenaar 5683c1e38eaSMarcel Moolenaar TDBG_FUNC(); 5693c1e38eaSMarcel Moolenaar 5703c1e38eaSMarcel Moolenaar ret = pt_ta_map_id2thr(th->th_ta, th->th_tid, 5713c1e38eaSMarcel Moolenaar &temp); 572447d36ecSDavid Xu return (ret); 5733c1e38eaSMarcel Moolenaar } 5743c1e38eaSMarcel Moolenaar 5753c1e38eaSMarcel Moolenaar static td_err_e 576098d0537SKonstantin Belousov pt_thr_old_get_info(const td_thrhandle_t *th, td_old_thrinfo_t *info) 5773c1e38eaSMarcel Moolenaar { 5783c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 5792ed66c93SDavid Xu struct ptrace_lwpinfo linfo; 580cd980d46SDavid Xu psaddr_t tcb_addr; 581447d36ecSDavid Xu uint32_t dflags; 5822ed66c93SDavid Xu lwpid_t lwp; 583cd980d46SDavid Xu int state; 584cd980d46SDavid Xu int ret; 5852ed66c93SDavid Xu int attrflags; 5863c1e38eaSMarcel Moolenaar 5873c1e38eaSMarcel Moolenaar TDBG_FUNC(); 5883c1e38eaSMarcel Moolenaar 58983154c48SDavid Xu bzero(info, sizeof(*info)); 5903c1e38eaSMarcel Moolenaar ret = pt_validate(th); 5913c1e38eaSMarcel Moolenaar if (ret) 5923c1e38eaSMarcel Moolenaar return (ret); 5933c1e38eaSMarcel Moolenaar 5943c1e38eaSMarcel Moolenaar memset(info, 0, sizeof(*info)); 5953c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 5963c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_SYSTEM; 5973c1e38eaSMarcel Moolenaar info->ti_lid = ta->map[th->th_tid].lwp; 5983c1e38eaSMarcel Moolenaar info->ti_tid = th->th_tid; 5993c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_RUN; 6003c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_SYSTEM; 6013c1e38eaSMarcel Moolenaar return (TD_OK); 6023c1e38eaSMarcel Moolenaar } 6032ed66c93SDavid Xu 6042ed66c93SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 6052ed66c93SDavid Xu ta->thread_off_attr_flags, 6062ed66c93SDavid Xu &attrflags, sizeof(attrflags)); 6072ed66c93SDavid Xu if (ret != 0) 6082ed66c93SDavid Xu return (P2T(ret)); 609cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 610cd980d46SDavid Xu &tcb_addr, sizeof(tcb_addr)); 6113c1e38eaSMarcel Moolenaar if (ret != 0) 6123c1e38eaSMarcel Moolenaar return (P2T(ret)); 613cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_state, 614cd980d46SDavid Xu &state, sizeof(state)); 6153c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, 616cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 617cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_lwp), 6183c1e38eaSMarcel Moolenaar &info->ti_lid, sizeof(lwpid_t)); 6193c1e38eaSMarcel Moolenaar if (ret != 0) 6203c1e38eaSMarcel Moolenaar return (P2T(ret)); 621447d36ecSDavid Xu ret = ps_pread(ta->ph, 622cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 623cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_dflags), 624447d36ecSDavid Xu &dflags, sizeof(dflags)); 625447d36ecSDavid Xu if (ret != 0) 626447d36ecSDavid Xu return (P2T(ret)); 6272ed66c93SDavid Xu ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_tmbx + 6282ed66c93SDavid Xu offsetof(struct kse_thr_mailbox, tm_lwp), &lwp, sizeof(lwpid_t)); 6292ed66c93SDavid Xu if (ret != 0) 6302ed66c93SDavid Xu return (P2T(ret)); 6313c1e38eaSMarcel Moolenaar info->ti_ta_p = th->th_ta; 6323c1e38eaSMarcel Moolenaar info->ti_tid = th->th_tid; 6332ed66c93SDavid Xu 6342ed66c93SDavid Xu if (attrflags & PTHREAD_SCOPE_SYSTEM) { 6352ed66c93SDavid Xu ret = ps_linfo(ta->ph, lwp, &linfo); 6362ed66c93SDavid Xu if (ret == PS_OK) { 6372ed66c93SDavid Xu info->ti_sigmask = linfo.pl_sigmask; 6382ed66c93SDavid Xu info->ti_pending = linfo.pl_siglist; 6392ed66c93SDavid Xu } else 6402ed66c93SDavid Xu return (ret); 6412ed66c93SDavid Xu } else { 6422ed66c93SDavid Xu ret = ps_pread(ta->ph, 6432ed66c93SDavid Xu ta->map[th->th_tid].thr + ta->thread_off_sigmask, 6442ed66c93SDavid Xu &info->ti_sigmask, sizeof(sigset_t)); 6452ed66c93SDavid Xu if (ret) 6462ed66c93SDavid Xu return (ret); 6472ed66c93SDavid Xu ret = ps_pread(ta->ph, 6482ed66c93SDavid Xu ta->map[th->th_tid].thr + ta->thread_off_sigpend, 6492ed66c93SDavid Xu &info->ti_pending, sizeof(sigset_t)); 6502ed66c93SDavid Xu if (ret) 6512ed66c93SDavid Xu return (ret); 6522ed66c93SDavid Xu } 6532ed66c93SDavid Xu 654cd980d46SDavid Xu if (state == ta->thread_state_running) 6553c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_RUN; 656cd980d46SDavid Xu else if (state == ta->thread_state_zoombie) 6573c1e38eaSMarcel Moolenaar info->ti_state = TD_THR_ZOMBIE; 658cd980d46SDavid Xu else 659cd980d46SDavid Xu info->ti_state = TD_THR_SLEEP; 6604513fb36SDavid Xu info->ti_db_suspended = ((dflags & TMDF_SUSPEND) != 0); 6613c1e38eaSMarcel Moolenaar info->ti_type = TD_THR_USER; 6623c1e38eaSMarcel Moolenaar return (0); 6633c1e38eaSMarcel Moolenaar } 6643c1e38eaSMarcel Moolenaar 665098d0537SKonstantin Belousov static td_err_e 666098d0537SKonstantin Belousov pt_thr_get_info(const td_thrhandle_t *th, td_thrinfo_t *info) 667098d0537SKonstantin Belousov { 668098d0537SKonstantin Belousov td_err_e e; 669098d0537SKonstantin Belousov 670098d0537SKonstantin Belousov e = pt_thr_old_get_info(th, (td_old_thrinfo_t *)info); 671098d0537SKonstantin Belousov bzero(&info->ti_siginfo, sizeof(info->ti_siginfo)); 672098d0537SKonstantin Belousov return (e); 673098d0537SKonstantin Belousov } 674098d0537SKonstantin Belousov 6758d7681bbSDoug Rabson #ifdef __i386__ 6768d7681bbSDoug Rabson static td_err_e 6778d7681bbSDoug Rabson pt_thr_getxmmregs(const td_thrhandle_t *th, char *fxsave) 6788d7681bbSDoug Rabson { 6798d7681bbSDoug Rabson const td_thragent_t *ta = th->th_ta; 6808d7681bbSDoug Rabson struct kse_thr_mailbox tmbx; 6818d7681bbSDoug Rabson psaddr_t tcb_addr, tmbx_addr, ptr; 6828d7681bbSDoug Rabson lwpid_t lwp; 6838d7681bbSDoug Rabson int ret; 6848d7681bbSDoug Rabson 6858d7681bbSDoug Rabson return TD_ERR; 6868d7681bbSDoug Rabson 6878d7681bbSDoug Rabson TDBG_FUNC(); 6888d7681bbSDoug Rabson 6898d7681bbSDoug Rabson ret = pt_validate(th); 6908d7681bbSDoug Rabson if (ret) 6918d7681bbSDoug Rabson return (ret); 6928d7681bbSDoug Rabson 6938d7681bbSDoug Rabson if (ta->map[th->th_tid].type == PT_LWP) { 6948d7681bbSDoug Rabson ret = ps_lgetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave); 6958d7681bbSDoug Rabson return (P2T(ret)); 6968d7681bbSDoug Rabson } 6978d7681bbSDoug Rabson 6988d7681bbSDoug Rabson ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 6998d7681bbSDoug Rabson &tcb_addr, sizeof(tcb_addr)); 7008d7681bbSDoug Rabson if (ret != 0) 7018d7681bbSDoug Rabson return (P2T(ret)); 7028d7681bbSDoug Rabson tmbx_addr = tcb_addr + ta->thread_off_tmbx; 7038d7681bbSDoug Rabson ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 7048d7681bbSDoug Rabson ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 7058d7681bbSDoug Rabson if (ret != 0) 7068d7681bbSDoug Rabson return (P2T(ret)); 7078d7681bbSDoug Rabson if (lwp != 0) { 7088d7681bbSDoug Rabson ret = ps_lgetxmmregs(ta->ph, lwp, fxsave); 7098d7681bbSDoug Rabson return (P2T(ret)); 7108d7681bbSDoug Rabson } 7118d7681bbSDoug Rabson 7128d7681bbSDoug Rabson ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7138d7681bbSDoug Rabson if (ret != 0) 7148d7681bbSDoug Rabson return (P2T(ret)); 7158d7681bbSDoug Rabson pt_ucontext_to_fxsave(&tmbx.tm_context, fxsave); 7168d7681bbSDoug Rabson return (0); 7178d7681bbSDoug Rabson } 7188d7681bbSDoug Rabson #endif 7198d7681bbSDoug Rabson 7203c1e38eaSMarcel Moolenaar static td_err_e 7213c1e38eaSMarcel Moolenaar pt_thr_getfpregs(const td_thrhandle_t *th, prfpregset_t *fpregs) 7223c1e38eaSMarcel Moolenaar { 7233c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 7243c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 7253c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 7263c1e38eaSMarcel Moolenaar lwpid_t lwp; 7273c1e38eaSMarcel Moolenaar int ret; 7283c1e38eaSMarcel Moolenaar 7293c1e38eaSMarcel Moolenaar TDBG_FUNC(); 7303c1e38eaSMarcel Moolenaar 7313c1e38eaSMarcel Moolenaar ret = pt_validate(th); 7323c1e38eaSMarcel Moolenaar if (ret) 7333c1e38eaSMarcel Moolenaar return (ret); 7343c1e38eaSMarcel Moolenaar 7353c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 7363c1e38eaSMarcel Moolenaar ret = ps_lgetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 7373c1e38eaSMarcel Moolenaar return (P2T(ret)); 7383c1e38eaSMarcel Moolenaar } 7393c1e38eaSMarcel Moolenaar 740cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 7413c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 7423c1e38eaSMarcel Moolenaar if (ret != 0) 7433c1e38eaSMarcel Moolenaar return (P2T(ret)); 744cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 7453c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 7463c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 7473c1e38eaSMarcel Moolenaar if (ret != 0) 7483c1e38eaSMarcel Moolenaar return (P2T(ret)); 7493c1e38eaSMarcel Moolenaar if (lwp != 0) { 7503c1e38eaSMarcel Moolenaar ret = ps_lgetfpregs(ta->ph, lwp, fpregs); 7513c1e38eaSMarcel Moolenaar return (P2T(ret)); 7523c1e38eaSMarcel Moolenaar } 7533c1e38eaSMarcel Moolenaar 7543c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7553c1e38eaSMarcel Moolenaar if (ret != 0) 7563c1e38eaSMarcel Moolenaar return (P2T(ret)); 7573c1e38eaSMarcel Moolenaar pt_ucontext_to_fpreg(&tmbx.tm_context, fpregs); 7583c1e38eaSMarcel Moolenaar return (0); 7593c1e38eaSMarcel Moolenaar } 7603c1e38eaSMarcel Moolenaar 7613c1e38eaSMarcel Moolenaar static td_err_e 7623c1e38eaSMarcel Moolenaar pt_thr_getgregs(const td_thrhandle_t *th, prgregset_t gregs) 7633c1e38eaSMarcel Moolenaar { 7643c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 7653c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 7663c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 7673c1e38eaSMarcel Moolenaar lwpid_t lwp; 7683c1e38eaSMarcel Moolenaar int ret; 7693c1e38eaSMarcel Moolenaar 7703c1e38eaSMarcel Moolenaar TDBG_FUNC(); 7713c1e38eaSMarcel Moolenaar 7723c1e38eaSMarcel Moolenaar ret = pt_validate(th); 7733c1e38eaSMarcel Moolenaar if (ret) 7743c1e38eaSMarcel Moolenaar return (ret); 7753c1e38eaSMarcel Moolenaar 7763c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 7773c1e38eaSMarcel Moolenaar ret = ps_lgetregs(ta->ph, 7783c1e38eaSMarcel Moolenaar ta->map[th->th_tid].lwp, gregs); 7793c1e38eaSMarcel Moolenaar return (P2T(ret)); 7803c1e38eaSMarcel Moolenaar } 7813c1e38eaSMarcel Moolenaar 782cd980d46SDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb, 7833c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 7843c1e38eaSMarcel Moolenaar if (ret != 0) 7853c1e38eaSMarcel Moolenaar return (P2T(ret)); 786cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 7873c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 7883c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 7893c1e38eaSMarcel Moolenaar if (ret != 0) 7903c1e38eaSMarcel Moolenaar return (P2T(ret)); 7913c1e38eaSMarcel Moolenaar if (lwp != 0) { 7923c1e38eaSMarcel Moolenaar ret = ps_lgetregs(ta->ph, lwp, gregs); 7933c1e38eaSMarcel Moolenaar return (P2T(ret)); 7943c1e38eaSMarcel Moolenaar } 7953c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 7963c1e38eaSMarcel Moolenaar if (ret != 0) 7973c1e38eaSMarcel Moolenaar return (P2T(ret)); 7983c1e38eaSMarcel Moolenaar pt_ucontext_to_reg(&tmbx.tm_context, gregs); 7993c1e38eaSMarcel Moolenaar return (0); 8003c1e38eaSMarcel Moolenaar } 8013c1e38eaSMarcel Moolenaar 8028d7681bbSDoug Rabson #ifdef __i386__ 8038d7681bbSDoug Rabson static td_err_e 8048d7681bbSDoug Rabson pt_thr_setxmmregs(const td_thrhandle_t *th, const char *fxsave) 8058d7681bbSDoug Rabson { 8068d7681bbSDoug Rabson const td_thragent_t *ta = th->th_ta; 8078d7681bbSDoug Rabson struct kse_thr_mailbox tmbx; 8088d7681bbSDoug Rabson psaddr_t tcb_addr, tmbx_addr, ptr; 8098d7681bbSDoug Rabson lwpid_t lwp; 8108d7681bbSDoug Rabson int ret; 8118d7681bbSDoug Rabson 8128d7681bbSDoug Rabson return TD_ERR; 8138d7681bbSDoug Rabson 8148d7681bbSDoug Rabson TDBG_FUNC(); 8158d7681bbSDoug Rabson 8168d7681bbSDoug Rabson ret = pt_validate(th); 8178d7681bbSDoug Rabson if (ret) 8188d7681bbSDoug Rabson return (ret); 8198d7681bbSDoug Rabson 8208d7681bbSDoug Rabson if (ta->map[th->th_tid].type == PT_LWP) { 8218d7681bbSDoug Rabson ret = ps_lsetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave); 8228d7681bbSDoug Rabson return (P2T(ret)); 8238d7681bbSDoug Rabson } 8248d7681bbSDoug Rabson 8258d7681bbSDoug Rabson ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 8268d7681bbSDoug Rabson ta->thread_off_tcb, 8278d7681bbSDoug Rabson &tcb_addr, sizeof(tcb_addr)); 8288d7681bbSDoug Rabson if (ret != 0) 8298d7681bbSDoug Rabson return (P2T(ret)); 8308d7681bbSDoug Rabson tmbx_addr = tcb_addr + ta->thread_off_tmbx; 8318d7681bbSDoug Rabson ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 8328d7681bbSDoug Rabson ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 8338d7681bbSDoug Rabson if (ret != 0) 8348d7681bbSDoug Rabson return (P2T(ret)); 8358d7681bbSDoug Rabson if (lwp != 0) { 8368d7681bbSDoug Rabson ret = ps_lsetxmmregs(ta->ph, lwp, fxsave); 8378d7681bbSDoug Rabson return (P2T(ret)); 8388d7681bbSDoug Rabson } 8398d7681bbSDoug Rabson /* 8408d7681bbSDoug Rabson * Read a copy of context, this makes sure that registers 8418d7681bbSDoug Rabson * not covered by structure reg won't be clobbered 8428d7681bbSDoug Rabson */ 8438d7681bbSDoug Rabson ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8448d7681bbSDoug Rabson if (ret != 0) 8458d7681bbSDoug Rabson return (P2T(ret)); 8468d7681bbSDoug Rabson 8478d7681bbSDoug Rabson pt_fxsave_to_ucontext(fxsave, &tmbx.tm_context); 8488d7681bbSDoug Rabson ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8498d7681bbSDoug Rabson return (P2T(ret)); 8508d7681bbSDoug Rabson } 8518d7681bbSDoug Rabson #endif 8528d7681bbSDoug Rabson 8533c1e38eaSMarcel Moolenaar static td_err_e 8543c1e38eaSMarcel Moolenaar pt_thr_setfpregs(const td_thrhandle_t *th, const prfpregset_t *fpregs) 8553c1e38eaSMarcel Moolenaar { 8563c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 8573c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 8583c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 8593c1e38eaSMarcel Moolenaar lwpid_t lwp; 8603c1e38eaSMarcel Moolenaar int ret; 8613c1e38eaSMarcel Moolenaar 8623c1e38eaSMarcel Moolenaar TDBG_FUNC(); 8633c1e38eaSMarcel Moolenaar 8643c1e38eaSMarcel Moolenaar ret = pt_validate(th); 8653c1e38eaSMarcel Moolenaar if (ret) 8663c1e38eaSMarcel Moolenaar return (ret); 8673c1e38eaSMarcel Moolenaar 8683c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 8693c1e38eaSMarcel Moolenaar ret = ps_lsetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs); 8703c1e38eaSMarcel Moolenaar return (P2T(ret)); 8713c1e38eaSMarcel Moolenaar } 8723c1e38eaSMarcel Moolenaar 8733c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 874cd980d46SDavid Xu ta->thread_off_tcb, 8753c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 8763c1e38eaSMarcel Moolenaar if (ret != 0) 8773c1e38eaSMarcel Moolenaar return (P2T(ret)); 878cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 8793c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 8803c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 8813c1e38eaSMarcel Moolenaar if (ret != 0) 8823c1e38eaSMarcel Moolenaar return (P2T(ret)); 8833c1e38eaSMarcel Moolenaar if (lwp != 0) { 8843c1e38eaSMarcel Moolenaar ret = ps_lsetfpregs(ta->ph, lwp, fpregs); 8853c1e38eaSMarcel Moolenaar return (P2T(ret)); 8863c1e38eaSMarcel Moolenaar } 8873c1e38eaSMarcel Moolenaar /* 8883c1e38eaSMarcel Moolenaar * Read a copy of context, this makes sure that registers 8893c1e38eaSMarcel Moolenaar * not covered by structure reg won't be clobbered 8903c1e38eaSMarcel Moolenaar */ 8913c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8923c1e38eaSMarcel Moolenaar if (ret != 0) 8933c1e38eaSMarcel Moolenaar return (P2T(ret)); 8943c1e38eaSMarcel Moolenaar 8953c1e38eaSMarcel Moolenaar pt_fpreg_to_ucontext(fpregs, &tmbx.tm_context); 8963c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 8973c1e38eaSMarcel Moolenaar return (P2T(ret)); 8983c1e38eaSMarcel Moolenaar } 8993c1e38eaSMarcel Moolenaar 9003c1e38eaSMarcel Moolenaar static td_err_e 9013c1e38eaSMarcel Moolenaar pt_thr_setgregs(const td_thrhandle_t *th, const prgregset_t gregs) 9023c1e38eaSMarcel Moolenaar { 9033c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 9043c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 9053c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr, ptr; 9063c1e38eaSMarcel Moolenaar lwpid_t lwp; 9073c1e38eaSMarcel Moolenaar int ret; 9083c1e38eaSMarcel Moolenaar 9093c1e38eaSMarcel Moolenaar TDBG_FUNC(); 9103c1e38eaSMarcel Moolenaar 9113c1e38eaSMarcel Moolenaar ret = pt_validate(th); 9123c1e38eaSMarcel Moolenaar if (ret) 9133c1e38eaSMarcel Moolenaar return (ret); 9143c1e38eaSMarcel Moolenaar 9153c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) { 9163c1e38eaSMarcel Moolenaar ret = ps_lsetregs(ta->ph, ta->map[th->th_tid].lwp, gregs); 9173c1e38eaSMarcel Moolenaar return (P2T(ret)); 9183c1e38eaSMarcel Moolenaar } 9193c1e38eaSMarcel Moolenaar 9203c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 921cd980d46SDavid Xu ta->thread_off_tcb, 9223c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 9233c1e38eaSMarcel Moolenaar if (ret != 0) 9243c1e38eaSMarcel Moolenaar return (P2T(ret)); 925cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 9263c1e38eaSMarcel Moolenaar ptr = tmbx_addr + offsetof(struct kse_thr_mailbox, tm_lwp); 9273c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t)); 9283c1e38eaSMarcel Moolenaar if (ret != 0) 9293c1e38eaSMarcel Moolenaar return (P2T(ret)); 9303c1e38eaSMarcel Moolenaar if (lwp != 0) { 9313c1e38eaSMarcel Moolenaar ret = ps_lsetregs(ta->ph, lwp, gregs); 9323c1e38eaSMarcel Moolenaar return (P2T(ret)); 9333c1e38eaSMarcel Moolenaar } 9343c1e38eaSMarcel Moolenaar 9353c1e38eaSMarcel Moolenaar /* 9363c1e38eaSMarcel Moolenaar * Read a copy of context, make sure that registers 9373c1e38eaSMarcel Moolenaar * not covered by structure reg won't be clobbered 9383c1e38eaSMarcel Moolenaar */ 9393c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 9403c1e38eaSMarcel Moolenaar if (ret != 0) 9413c1e38eaSMarcel Moolenaar return (P2T(ret)); 9423c1e38eaSMarcel Moolenaar pt_reg_to_ucontext(gregs, &tmbx.tm_context); 9433c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 9443c1e38eaSMarcel Moolenaar return (P2T(ret)); 9453c1e38eaSMarcel Moolenaar } 9463c1e38eaSMarcel Moolenaar 9473c1e38eaSMarcel Moolenaar static td_err_e 948f60a5b31SMarcel Moolenaar pt_thr_event_enable(const td_thrhandle_t *th __unused, int en __unused) 9493c1e38eaSMarcel Moolenaar { 9503c1e38eaSMarcel Moolenaar TDBG_FUNC(); 951a80845eaSDavid Xu return (0); 9523c1e38eaSMarcel Moolenaar } 9533c1e38eaSMarcel Moolenaar 9543c1e38eaSMarcel Moolenaar static td_err_e 955f60a5b31SMarcel Moolenaar pt_thr_set_event(const td_thrhandle_t *th __unused, 956f60a5b31SMarcel Moolenaar td_thr_events_t *setp __unused) 9573c1e38eaSMarcel Moolenaar { 9583c1e38eaSMarcel Moolenaar TDBG_FUNC(); 959a80845eaSDavid Xu return (0); 9603c1e38eaSMarcel Moolenaar } 9613c1e38eaSMarcel Moolenaar 9623c1e38eaSMarcel Moolenaar static td_err_e 963f60a5b31SMarcel Moolenaar pt_thr_clear_event(const td_thrhandle_t *th __unused, 964f60a5b31SMarcel Moolenaar td_thr_events_t *setp __unused) 9653c1e38eaSMarcel Moolenaar { 9663c1e38eaSMarcel Moolenaar TDBG_FUNC(); 967a80845eaSDavid Xu return (0); 9683c1e38eaSMarcel Moolenaar } 9693c1e38eaSMarcel Moolenaar 9703c1e38eaSMarcel Moolenaar static td_err_e 971f60a5b31SMarcel Moolenaar pt_thr_event_getmsg(const td_thrhandle_t *th __unused, 972f60a5b31SMarcel Moolenaar td_event_msg_t *msg __unused) 9733c1e38eaSMarcel Moolenaar { 9743c1e38eaSMarcel Moolenaar TDBG_FUNC(); 9753c1e38eaSMarcel Moolenaar return (TD_NOMSG); 9763c1e38eaSMarcel Moolenaar } 9773c1e38eaSMarcel Moolenaar 9783c1e38eaSMarcel Moolenaar static td_err_e 9793c1e38eaSMarcel Moolenaar pt_thr_sstep(const td_thrhandle_t *th, int step) 9803c1e38eaSMarcel Moolenaar { 9813c1e38eaSMarcel Moolenaar const td_thragent_t *ta = th->th_ta; 9823c1e38eaSMarcel Moolenaar struct kse_thr_mailbox tmbx; 9833c1e38eaSMarcel Moolenaar struct reg regs; 9843c1e38eaSMarcel Moolenaar psaddr_t tcb_addr, tmbx_addr; 985447d36ecSDavid Xu uint32_t dflags; 9863c1e38eaSMarcel Moolenaar lwpid_t lwp; 9873c1e38eaSMarcel Moolenaar int ret; 9883c1e38eaSMarcel Moolenaar 9893c1e38eaSMarcel Moolenaar TDBG_FUNC(); 9903c1e38eaSMarcel Moolenaar 9913c1e38eaSMarcel Moolenaar ret = pt_validate(th); 9923c1e38eaSMarcel Moolenaar if (ret) 9933c1e38eaSMarcel Moolenaar return (ret); 9943c1e38eaSMarcel Moolenaar 9953c1e38eaSMarcel Moolenaar if (ta->map[th->th_tid].type == PT_LWP) 9963c1e38eaSMarcel Moolenaar return (TD_BADTH); 9973c1e38eaSMarcel Moolenaar 9983c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 999cd980d46SDavid Xu ta->thread_off_tcb, 10003c1e38eaSMarcel Moolenaar &tcb_addr, sizeof(tcb_addr)); 10013c1e38eaSMarcel Moolenaar if (ret != 0) 10023c1e38eaSMarcel Moolenaar return (P2T(ret)); 10033c1e38eaSMarcel Moolenaar 10043c1e38eaSMarcel Moolenaar /* Clear or set single step flag in thread mailbox */ 1005cd980d46SDavid Xu ret = ps_pread(ta->ph, 1006cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 1007cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_dflags), 1008cd980d46SDavid Xu &dflags, sizeof(uint32_t)); 1009447d36ecSDavid Xu if (ret != 0) 1010447d36ecSDavid Xu return (P2T(ret)); 1011447d36ecSDavid Xu if (step != 0) 1012447d36ecSDavid Xu dflags |= TMDF_SSTEP; 1013447d36ecSDavid Xu else 1014447d36ecSDavid Xu dflags &= ~TMDF_SSTEP; 1015cd980d46SDavid Xu ret = ps_pwrite(ta->ph, 1016cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 1017cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_dflags), 1018cd980d46SDavid Xu &dflags, sizeof(uint32_t)); 10193c1e38eaSMarcel Moolenaar if (ret != 0) 10203c1e38eaSMarcel Moolenaar return (P2T(ret)); 10213c1e38eaSMarcel Moolenaar /* Get lwp */ 1022cd980d46SDavid Xu ret = ps_pread(ta->ph, 1023cd980d46SDavid Xu tcb_addr + ta->thread_off_tmbx + 1024cd980d46SDavid Xu offsetof(struct kse_thr_mailbox, tm_lwp), 1025cd980d46SDavid Xu &lwp, sizeof(lwpid_t)); 10263c1e38eaSMarcel Moolenaar if (ret != 0) 10273c1e38eaSMarcel Moolenaar return (P2T(ret)); 10283c1e38eaSMarcel Moolenaar if (lwp != 0) 1029447d36ecSDavid Xu return (0); 10303c1e38eaSMarcel Moolenaar 1031cd980d46SDavid Xu tmbx_addr = tcb_addr + ta->thread_off_tmbx; 10323c1e38eaSMarcel Moolenaar /* 10333c1e38eaSMarcel Moolenaar * context is in userland, some architectures store 10343c1e38eaSMarcel Moolenaar * single step status in registers, we should change 10353c1e38eaSMarcel Moolenaar * these registers. 10363c1e38eaSMarcel Moolenaar */ 10373c1e38eaSMarcel Moolenaar ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx)); 10383c1e38eaSMarcel Moolenaar if (ret == 0) { 10393c1e38eaSMarcel Moolenaar pt_ucontext_to_reg(&tmbx.tm_context, ®s); 10403c1e38eaSMarcel Moolenaar /* only write out if it is really changed. */ 10413c1e38eaSMarcel Moolenaar if (pt_reg_sstep(®s, step) != 0) { 10423c1e38eaSMarcel Moolenaar pt_reg_to_ucontext(®s, &tmbx.tm_context); 10433c1e38eaSMarcel Moolenaar ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, 10443c1e38eaSMarcel Moolenaar sizeof(tmbx)); 10453c1e38eaSMarcel Moolenaar } 10463c1e38eaSMarcel Moolenaar } 10473c1e38eaSMarcel Moolenaar return (P2T(ret)); 10483c1e38eaSMarcel Moolenaar } 10493c1e38eaSMarcel Moolenaar 10503c1e38eaSMarcel Moolenaar static void 10513c1e38eaSMarcel Moolenaar pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp) 10523c1e38eaSMarcel Moolenaar { 10531f2b051dSPedro F. Giffuni unsigned int i; 10543c1e38eaSMarcel Moolenaar 10553c1e38eaSMarcel Moolenaar for (i = 0; i < ta->map_len; ++i) { 10563c1e38eaSMarcel Moolenaar if (ta->map[i].type == PT_LWP && ta->map[i].lwp == lwp) { 10573c1e38eaSMarcel Moolenaar ta->map[i].type = PT_NONE; 10583c1e38eaSMarcel Moolenaar return; 10593c1e38eaSMarcel Moolenaar } 10603c1e38eaSMarcel Moolenaar } 10613c1e38eaSMarcel Moolenaar } 10623c1e38eaSMarcel Moolenaar 10633c1e38eaSMarcel Moolenaar static int 10643c1e38eaSMarcel Moolenaar pt_validate(const td_thrhandle_t *th) 10653c1e38eaSMarcel Moolenaar { 10663c1e38eaSMarcel Moolenaar 10678413ef57SPedro F. Giffuni if (th->th_tid < 0 || th->th_tid >= (long)th->th_ta->map_len || 10683c1e38eaSMarcel Moolenaar th->th_ta->map[th->th_tid].type == PT_NONE) 10693c1e38eaSMarcel Moolenaar return (TD_NOTHR); 10703c1e38eaSMarcel Moolenaar return (TD_OK); 10713c1e38eaSMarcel Moolenaar } 10723c1e38eaSMarcel Moolenaar 1073820c1c55SMarcel Moolenaar static td_err_e 107416b0c20cSMarcel Moolenaar pt_thr_tls_get_addr(const td_thrhandle_t *th, psaddr_t _linkmap, size_t offset, 107516b0c20cSMarcel Moolenaar psaddr_t *address) 10763e93cc3aSDavid Xu { 10773e93cc3aSDavid Xu const td_thragent_t *ta = th->th_ta; 107816b0c20cSMarcel Moolenaar psaddr_t dtv_addr, obj_entry, tcb_addr; 10793e93cc3aSDavid Xu int tls_index, ret; 10803e93cc3aSDavid Xu 10813e93cc3aSDavid Xu /* linkmap is a member of Obj_Entry */ 108216b0c20cSMarcel Moolenaar obj_entry = _linkmap - ta->thread_off_linkmap; 10833e93cc3aSDavid Xu 10843e93cc3aSDavid Xu /* get tlsindex of the object file */ 10853e93cc3aSDavid Xu ret = ps_pread(ta->ph, 1086cd980d46SDavid Xu obj_entry + ta->thread_off_tlsindex, 10873e93cc3aSDavid Xu &tls_index, sizeof(tls_index)); 10883e93cc3aSDavid Xu if (ret != 0) 10893e93cc3aSDavid Xu return (P2T(ret)); 10903e93cc3aSDavid Xu 10913e93cc3aSDavid Xu /* get thread tcb */ 10923e93cc3aSDavid Xu ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + 1093cd980d46SDavid Xu ta->thread_off_tcb, 10943e93cc3aSDavid Xu &tcb_addr, sizeof(tcb_addr)); 10953e93cc3aSDavid Xu if (ret != 0) 10963e93cc3aSDavid Xu return (P2T(ret)); 10973e93cc3aSDavid Xu 10983e93cc3aSDavid Xu /* get dtv array address */ 1099cd980d46SDavid Xu ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_dtv, 11003e93cc3aSDavid Xu &dtv_addr, sizeof(dtv_addr)); 11013e93cc3aSDavid Xu if (ret != 0) 11023e93cc3aSDavid Xu return (P2T(ret)); 11033e93cc3aSDavid Xu /* now get the object's tls block base address */ 110416b0c20cSMarcel Moolenaar ret = ps_pread(ta->ph, dtv_addr + sizeof(void *) * (tls_index + 1), 110516b0c20cSMarcel Moolenaar address, sizeof(*address)); 11063e93cc3aSDavid Xu if (ret != 0) 11073e93cc3aSDavid Xu return (P2T(ret)); 11083e93cc3aSDavid Xu 11093e93cc3aSDavid Xu *address += offset; 11103e93cc3aSDavid Xu return (TD_OK); 11113e93cc3aSDavid Xu } 11123e93cc3aSDavid Xu 1113ae824d80SEd Schouten static struct ta_ops libpthread_db_ops = { 11143c1e38eaSMarcel Moolenaar .to_init = pt_init, 11153c1e38eaSMarcel Moolenaar .to_ta_clear_event = pt_ta_clear_event, 11163c1e38eaSMarcel Moolenaar .to_ta_delete = pt_ta_delete, 11173c1e38eaSMarcel Moolenaar .to_ta_event_addr = pt_ta_event_addr, 11183c1e38eaSMarcel Moolenaar .to_ta_event_getmsg = pt_ta_event_getmsg, 11193c1e38eaSMarcel Moolenaar .to_ta_map_id2thr = pt_ta_map_id2thr, 11203c1e38eaSMarcel Moolenaar .to_ta_map_lwp2thr = pt_ta_map_lwp2thr, 11213c1e38eaSMarcel Moolenaar .to_ta_new = pt_ta_new, 11223c1e38eaSMarcel Moolenaar .to_ta_set_event = pt_ta_set_event, 11233c1e38eaSMarcel Moolenaar .to_ta_thr_iter = pt_ta_thr_iter, 11243c1e38eaSMarcel Moolenaar .to_ta_tsd_iter = pt_ta_tsd_iter, 11253c1e38eaSMarcel Moolenaar .to_thr_clear_event = pt_thr_clear_event, 11263c1e38eaSMarcel Moolenaar .to_thr_dbresume = pt_thr_dbresume, 11273c1e38eaSMarcel Moolenaar .to_thr_dbsuspend = pt_thr_dbsuspend, 11283c1e38eaSMarcel Moolenaar .to_thr_event_enable = pt_thr_event_enable, 11293c1e38eaSMarcel Moolenaar .to_thr_event_getmsg = pt_thr_event_getmsg, 1130098d0537SKonstantin Belousov .to_thr_old_get_info = pt_thr_old_get_info, 11313c1e38eaSMarcel Moolenaar .to_thr_get_info = pt_thr_get_info, 11323c1e38eaSMarcel Moolenaar .to_thr_getfpregs = pt_thr_getfpregs, 11333c1e38eaSMarcel Moolenaar .to_thr_getgregs = pt_thr_getgregs, 11343c1e38eaSMarcel Moolenaar .to_thr_set_event = pt_thr_set_event, 11353c1e38eaSMarcel Moolenaar .to_thr_setfpregs = pt_thr_setfpregs, 11363c1e38eaSMarcel Moolenaar .to_thr_setgregs = pt_thr_setgregs, 11373c1e38eaSMarcel Moolenaar .to_thr_validate = pt_thr_validate, 11383e93cc3aSDavid Xu .to_thr_tls_get_addr = pt_thr_tls_get_addr, 11393c1e38eaSMarcel Moolenaar 11403c1e38eaSMarcel Moolenaar /* FreeBSD specific extensions. */ 11413c1e38eaSMarcel Moolenaar .to_thr_sstep = pt_thr_sstep, 11428d7681bbSDoug Rabson #ifdef __i386__ 11438d7681bbSDoug Rabson .to_thr_getxmmregs = pt_thr_getxmmregs, 11448d7681bbSDoug Rabson .to_thr_setxmmregs = pt_thr_setxmmregs, 11458d7681bbSDoug Rabson #endif 11463c1e38eaSMarcel Moolenaar }; 114720b94d80SDavid Xu 114820b94d80SDavid Xu DATA_SET(__ta_ops, libpthread_db_ops); 1149