lib/libthread_db/libpthread_db.c

46 static void pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp);
75 	td_thragent_t *ta = __DECONST(td_thragent_t *, const_ta);
81 	for (i = 1; i < ta->map_len; ++i) {
82 		if (ta->map[i].type == PT_NONE) {
85 		} else if (ta->map[i].type == type && ta->map[i].thr == pt) {
91 		if (ta->map_len == 0) {
92 			ta->map = calloc(20, sizeof(struct pt_map));
93 			if (ta->map == NULL)
95 			ta->map_len = 20;
98 			new = reallocarray(ta->map, ta->map_len,
102 			memset(new + ta->map_len, '\0', ta->map_len *
104 			first = ta->map_len;
105 			ta->map = new;
106 			ta->map_len *= 2;
110 	ta->map[first].type = type;
111 	ta->map[first].thr = pt;
147 	td_thragent_t *ta;
154 	ta = malloc(sizeof(td_thragent_t));
155 	if (ta == NULL)
158 	ta->ph = ph;
159 	ta->thread_activated = 0;
160 	ta->map = NULL;
161 	ta->map_len = 0;
163 	LOOKUP_SYM(ph, "_libkse_debug",		&ta->libkse_debug_addr);
164 	LOOKUP_SYM(ph, "_thread_list",		&ta->thread_list_addr);
165 	LOOKUP_SYM(ph, "_thread_activated",	&ta->thread_activated_addr);
166 	LOOKUP_SYM(ph, "_thread_active_threads",&ta->thread_active_threads_addr);
167 	LOOKUP_SYM(ph, "_thread_keytable",	&ta->thread_keytable_addr);
168 	LOOKUP_VAL(ph, "_thread_off_dtv",	&ta->thread_off_dtv);
169 	LOOKUP_VAL(ph, "_thread_off_kse_locklevel", &ta->thread_off_kse_locklevel);
170 	LOOKUP_VAL(ph, "_thread_off_kse",	&ta->thread_off_kse);
171 	LOOKUP_VAL(ph, "_thread_off_tlsindex",	&ta->thread_off_tlsindex);
172 	LOOKUP_VAL(ph, "_thread_off_attr_flags",	&ta->thread_off_attr_flags);
173 	LOOKUP_VAL(ph, "_thread_size_key",	&ta->thread_size_key);
174 	LOOKUP_VAL(ph, "_thread_off_tcb",	&ta->thread_off_tcb);
175 	LOOKUP_VAL(ph, "_thread_off_linkmap",	&ta->thread_off_linkmap);
176 	LOOKUP_VAL(ph, "_thread_off_tmbx",	&ta->thread_off_tmbx);
177 	LOOKUP_VAL(ph, "_thread_off_thr_locklevel",	&ta->thread_off_thr_locklevel);
178 	LOOKUP_VAL(ph, "_thread_off_next",	&ta->thread_off_next);
179 	LOOKUP_VAL(ph, "_thread_off_state",	&ta->thread_off_state);
180 	LOOKUP_VAL(ph, "_thread_max_keys",	&ta->thread_max_keys);
181 	LOOKUP_VAL(ph, "_thread_off_key_allocated", &ta->thread_off_key_allocated);
182 	LOOKUP_VAL(ph, "_thread_off_key_destructor", &ta->thread_off_key_destructor);
183 	LOOKUP_VAL(ph, "_thread_state_running", &ta->thread_state_running);
184 	LOOKUP_VAL(ph, "_thread_state_zoombie", &ta->thread_state_zoombie);
185 	LOOKUP_VAL(ph, "_thread_off_sigmask",	&ta->thread_off_sigmask);
186 	LOOKUP_VAL(ph, "_thread_off_sigpend",	&ta->thread_off_sigpend);
192 	ps_pwrite(ph, ta->libkse_debug_addr, &dbg, sizeof(int));
193 	*pta = ta;
197 	free(ta);
202 pt_ta_delete(td_thragent_t *ta)
213 	ps_pwrite(ta->ph, ta->libkse_debug_addr, &dbg, sizeof(int));
214 	if (ta->map)
215 		free(ta->map);
216 	free(ta);
221 pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th)
230 	if (id < 0 || id >= (long)ta->map_len || ta->map[id].type == PT_NONE)
233 	ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
236 	if (ta->map[id].type == PT_LWP) {
242 			ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb,
246 			ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx +
254 			if (lwp == ta->map[id].lwp) {
255 				ta->map[id].type = PT_NONE;
259 			ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
264 		ret = ps_lgetregs(ta->ph, ta->map[id].lwp, gregs);
267 			ta->map[id].type = PT_NONE;
271 		while (pt != 0 && ta->map[id].thr != pt) {
272 			ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb,
277 			ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
284 			ta->map[id].type = PT_NONE;
288 	th->th_ta = ta;
295 pt_ta_map_lwp2thr(const td_thragent_t *ta, lwpid_t lwp, td_thrhandle_t *th)
303 	ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
307 		ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb, &tcb_addr);
310 		ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx +
315 			th->th_ta = ta;
316 			th->th_tid = pt_map_thread(ta, pt, PT_USER);
319 			pt_unmap_lwp(ta, lwp);
325 		ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
334 pt_ta_thr_iter(const td_thragent_t *ta, td_thr_iter_f *callback,
345 	pserr = ps_pread(ta->ph, ta->thread_activated_addr, &activated,
352 	ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
356 		th.th_ta = ta;
357 		th.th_tid = pt_map_thread(ta, pt, PT_USER);
365 		ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
373 pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg)
381 	keytable = malloc(ta->thread_max_keys * ta->thread_size_key);
384 	ret = ps_pread(ta->ph, (psaddr_t)ta->thread_keytable_addr, keytable,
385 	               ta->thread_max_keys * ta->thread_size_key);
390 	for (i = 0; i < ta->thread_max_keys; i++) {
392 		    i * ta->thread_size_key + ta->thread_off_key_allocated);
394 		    i * ta->thread_size_key + ta->thread_off_key_destructor);
408 pt_ta_event_addr(const td_thragent_t *ta __unused, td_event_e event __unused,
416 pt_ta_set_event(const td_thragent_t *ta __unused,
424 pt_ta_clear_event(const td_thragent_t *ta __unused,
432 pt_ta_event_getmsg(const td_thragent_t *ta __unused,
442 	const td_thragent_t *ta = th->th_ta;
454 	if (ta->map[th->th_tid].type == PT_LWP) {
456 			ret = ps_lstop(ta->ph, ta->map[th->th_tid].lwp);
458 			ret = ps_lcontinue(ta->ph, ta->map[th->th_tid].lwp);
462 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
463 		ta->thread_off_attr_flags,
467 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
468 	               ta->thread_off_tcb,
472 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
474 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
487 			ptr = ta->map[th->th_tid].thr + ta->thread_off_kse;
488 			ret = ps_pread(ta->ph, ptr, &ptr, sizeof(ptr));
491 			ret = ps_pread(ta->ph, ptr + ta->thread_off_kse_locklevel,
496 				ptr = ta->map[th->th_tid].thr +
497 					ta->thread_off_thr_locklevel;
498 				ret = ps_pread(ta->ph, ptr, &locklevel,
505 					ret = ps_lstop(ta->ph, lwp);
507 				ret = ps_lcontinue(ta->ph, lwp);
515 			if (ps_linfo(ta->ph, lwp, (caddr_t)&pl))
519 					ret = ps_lstop(ta->ph, lwp);
521 				ret = ps_lcontinue(ta->ph, lwp);
529 	ret = ps_pread(ta->ph,
538 	ret = ps_pwrite(ta->ph,
576 	const td_thragent_t *ta = th->th_ta;
593 	if (ta->map[th->th_tid].type == PT_LWP) {
595 		info->ti_lid = ta->map[th->th_tid].lwp;
602 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
603 		ta->thread_off_attr_flags,
607 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
611 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_state,
613 	ret = ps_pread(ta->ph,
614 	        tcb_addr + ta->thread_off_tmbx +
619 	ret = ps_pread(ta->ph,
620 		tcb_addr + ta->thread_off_tmbx +
625 	ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_tmbx +
633 		ret = ps_linfo(ta->ph, lwp, &linfo);
640 		ret = ps_pread(ta->ph,
641 			ta->map[th->th_tid].thr + ta->thread_off_sigmask,
645 		ret = ps_pread(ta->ph,
646 			ta->map[th->th_tid].thr + ta->thread_off_sigpend,
652 	if (state == ta->thread_state_running)
654 	else if (state == ta->thread_state_zoombie)
677 	const td_thragent_t *ta = th->th_ta;
691 	if (ta->map[th->th_tid].type == PT_LWP) {
692 		ret = ps_lgetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave);
696 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
700 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
702 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
706 		ret = ps_lgetxmmregs(ta->ph, lwp, fxsave);
710 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
721 	const td_thragent_t *ta = th->th_ta;
733 	if (ta->map[th->th_tid].type == PT_LWP) {
734 		ret = ps_lgetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs);
738 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
742 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
744 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
748 		ret = ps_lgetfpregs(ta->ph, lwp, fpregs);
752 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
762 	const td_thragent_t *ta = th->th_ta;
774 	if (ta->map[th->th_tid].type == PT_LWP) {
775 		ret = ps_lgetregs(ta->ph,
776 		                  ta->map[th->th_tid].lwp, gregs);
780 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
784 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
786 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
790 		ret = ps_lgetregs(ta->ph, lwp, gregs);
793 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
804 	const td_thragent_t *ta = th->th_ta;
818 	if (ta->map[th->th_tid].type == PT_LWP) {
819 		ret = ps_lsetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave);
823 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
824 	                ta->thread_off_tcb,
828 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
830 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
834 		ret = ps_lsetxmmregs(ta->ph, lwp, fxsave);
841 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
846 	ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
854 	const td_thragent_t *ta = th->th_ta;
866 	if (ta->map[th->th_tid].type == PT_LWP) {
867 		ret = ps_lsetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs);
871 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
872 	                ta->thread_off_tcb,
876 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
878 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
882 		ret = ps_lsetfpregs(ta->ph, lwp, fpregs);
889 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
894 	ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
901 	const td_thragent_t *ta = th->th_ta;
913 	if (ta->map[th->th_tid].type == PT_LWP) {
914 		ret = ps_lsetregs(ta->ph, ta->map[th->th_tid].lwp, gregs);
918 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
919 	                ta->thread_off_tcb,
923 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
925 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
929 		ret = ps_lsetregs(ta->ph, lwp, gregs);
937 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
941 	ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
979 	const td_thragent_t *ta = th->th_ta;
993 	if (ta->map[th->th_tid].type == PT_LWP)
996 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
997 	                ta->thread_off_tcb,
1003 	ret = ps_pread(ta->ph,
1004 		tcb_addr + ta->thread_off_tmbx +
1013 	ret = ps_pwrite(ta->ph,
1014 		tcb_addr + ta->thread_off_tmbx +
1020 	ret = ps_pread(ta->ph,
1021 		tcb_addr + ta->thread_off_tmbx +
1029 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
1035 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
1041 			ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx,
1049 pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp)
1053 	for (i = 0; i < ta->map_len; ++i) {
1054 		if (ta->map[i].type == PT_LWP && ta->map[i].lwp == lwp) {
1055 			ta->map[i].type = PT_NONE;
1075 	const td_thragent_t *ta = th->th_ta;
1080 	obj_entry = _linkmap - ta->thread_off_linkmap;
1083 	ret = ps_pread(ta->ph,
1084 		obj_entry + ta->thread_off_tlsindex,
1090 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
1091 		ta->thread_off_tcb,
1097 	ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_dtv,
1102 	ret = ps_pread(ta->ph, dtv_addr + sizeof(void *) * (tls_index + 1),