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);
80 	for (i = 1; i < ta->map_len; ++i) {
81 		if (ta->map[i].type == PT_NONE) {
84 		} else if (ta->map[i].type == type && ta->map[i].thr == pt) {
90 		if (ta->map_len == 0) {
91 			ta->map = calloc(20, sizeof(struct pt_map));
92 			if (ta->map == NULL)
94 			ta->map_len = 20;
97 			new = realloc(ta->map,
98 			              sizeof(struct pt_map) * ta->map_len * 2);
101 			memset(new + ta->map_len, '\0', sizeof(struct pt_map) *
102 			       ta->map_len);
103 			first = ta->map_len;
104 			ta->map = new;
105 			ta->map_len *= 2;
109 	ta->map[first].type = type;
110 	ta->map[first].thr = pt;
146 	td_thragent_t *ta;
153 	ta = malloc(sizeof(td_thragent_t));
154 	if (ta == NULL)
157 	ta->ph = ph;
158 	ta->thread_activated = 0;
159 	ta->map = NULL;
160 	ta->map_len = 0;
162 	LOOKUP_SYM(ph, "_libkse_debug",		&ta->libkse_debug_addr);
163 	LOOKUP_SYM(ph, "_thread_list",		&ta->thread_list_addr);
164 	LOOKUP_SYM(ph, "_thread_activated",	&ta->thread_activated_addr);
165 	LOOKUP_SYM(ph, "_thread_active_threads",&ta->thread_active_threads_addr);
166 	LOOKUP_SYM(ph, "_thread_keytable",	&ta->thread_keytable_addr);
167 	LOOKUP_VAL(ph, "_thread_off_dtv",	&ta->thread_off_dtv);
168 	LOOKUP_VAL(ph, "_thread_off_kse_locklevel", &ta->thread_off_kse_locklevel);
169 	LOOKUP_VAL(ph, "_thread_off_kse",	&ta->thread_off_kse);
170 	LOOKUP_VAL(ph, "_thread_off_tlsindex",	&ta->thread_off_tlsindex);
171 	LOOKUP_VAL(ph, "_thread_off_attr_flags",	&ta->thread_off_attr_flags);
172 	LOOKUP_VAL(ph, "_thread_size_key",	&ta->thread_size_key);
173 	LOOKUP_VAL(ph, "_thread_off_tcb",	&ta->thread_off_tcb);
174 	LOOKUP_VAL(ph, "_thread_off_linkmap",	&ta->thread_off_linkmap);
175 	LOOKUP_VAL(ph, "_thread_off_tmbx",	&ta->thread_off_tmbx);
176 	LOOKUP_VAL(ph, "_thread_off_thr_locklevel",	&ta->thread_off_thr_locklevel);
177 	LOOKUP_VAL(ph, "_thread_off_next",	&ta->thread_off_next);
178 	LOOKUP_VAL(ph, "_thread_off_state",	&ta->thread_off_state);
179 	LOOKUP_VAL(ph, "_thread_max_keys",	&ta->thread_max_keys);
180 	LOOKUP_VAL(ph, "_thread_off_key_allocated", &ta->thread_off_key_allocated);
181 	LOOKUP_VAL(ph, "_thread_off_key_destructor", &ta->thread_off_key_destructor);
182 	LOOKUP_VAL(ph, "_thread_state_running", &ta->thread_state_running);
183 	LOOKUP_VAL(ph, "_thread_state_zoombie", &ta->thread_state_zoombie);
184 	LOOKUP_VAL(ph, "_thread_off_sigmask",	&ta->thread_off_sigmask);
185 	LOOKUP_VAL(ph, "_thread_off_sigpend",	&ta->thread_off_sigpend);
191 	ps_pwrite(ph, ta->libkse_debug_addr, &dbg, sizeof(int));
192 	*pta = ta;
196 	free(ta);
201 pt_ta_delete(td_thragent_t *ta)
212 	ps_pwrite(ta->ph, ta->libkse_debug_addr, &dbg, sizeof(int));
213 	if (ta->map)
214 		free(ta->map);
215 	free(ta);
220 pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th)
229 	if (id < 0 || id >= ta->map_len || ta->map[id].type == PT_NONE)
232 	ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
235 	if (ta->map[id].type == PT_LWP) {
241 			ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb,
245 			ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx +
253 			if (lwp == ta->map[id].lwp) {
254 				ta->map[id].type = PT_NONE;
258 			ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
263 		ret = ps_lgetregs(ta->ph, ta->map[id].lwp, gregs);
266 			ta->map[id].type = PT_NONE;
270 		while (pt != 0 && ta->map[id].thr != pt) {
271 			ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb,
276 			ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
283 			ta->map[id].type = PT_NONE;
287 	th->th_ta = ta;
294 pt_ta_map_lwp2thr(const td_thragent_t *ta, lwpid_t lwp, td_thrhandle_t *th)
302 	ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
306 		ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb, &tcb_addr);
309 		ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx +
314 			th->th_ta = ta;
315 			th->th_tid = pt_map_thread(ta, pt, PT_USER);
318 			pt_unmap_lwp(ta, lwp);
324 		ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
333 pt_ta_thr_iter(const td_thragent_t *ta, td_thr_iter_f *callback,
344 	pserr = ps_pread(ta->ph, ta->thread_activated_addr, &activated,
351 	ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
355 		th.th_ta = ta;
356 		th.th_tid = pt_map_thread(ta, pt, PT_USER);
364 		ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
372 pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg)
380 	keytable = malloc(ta->thread_max_keys * ta->thread_size_key);
383 	ret = ps_pread(ta->ph, (psaddr_t)ta->thread_keytable_addr, keytable,
384 	               ta->thread_max_keys * ta->thread_size_key);
389 	for (i = 0; i < ta->thread_max_keys; i++) {
391 		    i * ta->thread_size_key + ta->thread_off_key_allocated);
393 		    i * ta->thread_size_key + ta->thread_off_key_destructor);
407 pt_ta_event_addr(const td_thragent_t *ta __unused, td_event_e event __unused,
415 pt_ta_set_event(const td_thragent_t *ta __unused,
423 pt_ta_clear_event(const td_thragent_t *ta __unused,
431 pt_ta_event_getmsg(const td_thragent_t *ta __unused,
441 	const td_thragent_t *ta = th->th_ta;
453 	if (ta->map[th->th_tid].type == PT_LWP) {
455 			ret = ps_lstop(ta->ph, ta->map[th->th_tid].lwp);
457 			ret = ps_lcontinue(ta->ph, ta->map[th->th_tid].lwp);
461 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
462 		ta->thread_off_attr_flags,
466 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
467 	               ta->thread_off_tcb,
471 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
473 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
486 			ptr = ta->map[th->th_tid].thr + ta->thread_off_kse;
487 			ret = ps_pread(ta->ph, ptr, &ptr, sizeof(ptr));
490 			ret = ps_pread(ta->ph, ptr + ta->thread_off_kse_locklevel,
495 				ptr = ta->map[th->th_tid].thr +
496 					ta->thread_off_thr_locklevel;
497 				ret = ps_pread(ta->ph, ptr, &locklevel,
504 					ret = ps_lstop(ta->ph, lwp);
506 				ret = ps_lcontinue(ta->ph, lwp);
514 			if (ps_linfo(ta->ph, lwp, (caddr_t)&pl))
518 					ret = ps_lstop(ta->ph, lwp);
520 				ret = ps_lcontinue(ta->ph, lwp);
528 	ret = ps_pread(ta->ph,
537 	ret = ps_pwrite(ta->ph,
575 	const td_thragent_t *ta = th->th_ta;
592 	if (ta->map[th->th_tid].type == PT_LWP) {
594 		info->ti_lid = ta->map[th->th_tid].lwp;
601 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
602 		ta->thread_off_attr_flags,
606 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
610 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_state,
612 	ret = ps_pread(ta->ph,
613 	        tcb_addr + ta->thread_off_tmbx +
618 	ret = ps_pread(ta->ph,
619 		tcb_addr + ta->thread_off_tmbx +
624 	ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_tmbx +
632 		ret = ps_linfo(ta->ph, lwp, &linfo);
639 		ret = ps_pread(ta->ph,
640 			ta->map[th->th_tid].thr + ta->thread_off_sigmask,
644 		ret = ps_pread(ta->ph,
645 			ta->map[th->th_tid].thr + ta->thread_off_sigpend,
651 	if (state == ta->thread_state_running)
653 	else if (state == ta->thread_state_zoombie)
676 	const td_thragent_t *ta = th->th_ta;
690 	if (ta->map[th->th_tid].type == PT_LWP) {
691 		ret = ps_lgetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave);
695 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
699 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
701 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
705 		ret = ps_lgetxmmregs(ta->ph, lwp, fxsave);
709 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
720 	const td_thragent_t *ta = th->th_ta;
732 	if (ta->map[th->th_tid].type == PT_LWP) {
733 		ret = ps_lgetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs);
737 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
741 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
743 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
747 		ret = ps_lgetfpregs(ta->ph, lwp, fpregs);
751 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
761 	const td_thragent_t *ta = th->th_ta;
773 	if (ta->map[th->th_tid].type == PT_LWP) {
774 		ret = ps_lgetregs(ta->ph,
775 		                  ta->map[th->th_tid].lwp, gregs);
779 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr + ta->thread_off_tcb,
783 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
785 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
789 		ret = ps_lgetregs(ta->ph, lwp, gregs);
792 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
803 	const td_thragent_t *ta = th->th_ta;
817 	if (ta->map[th->th_tid].type == PT_LWP) {
818 		ret = ps_lsetxmmregs(ta->ph, ta->map[th->th_tid].lwp, fxsave);
822 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
823 	                ta->thread_off_tcb,
827 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
829 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
833 		ret = ps_lsetxmmregs(ta->ph, lwp, fxsave);
840 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
845 	ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
853 	const td_thragent_t *ta = th->th_ta;
865 	if (ta->map[th->th_tid].type == PT_LWP) {
866 		ret = ps_lsetfpregs(ta->ph, ta->map[th->th_tid].lwp, fpregs);
870 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
871 	                ta->thread_off_tcb,
875 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
877 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
881 		ret = ps_lsetfpregs(ta->ph, lwp, fpregs);
888 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
893 	ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
900 	const td_thragent_t *ta = th->th_ta;
912 	if (ta->map[th->th_tid].type == PT_LWP) {
913 		ret = ps_lsetregs(ta->ph, ta->map[th->th_tid].lwp, gregs);
917 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
918 	                ta->thread_off_tcb,
922 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
924 	ret = ps_pread(ta->ph, ptr, &lwp, sizeof(lwpid_t));
928 		ret = ps_lsetregs(ta->ph, lwp, gregs);
936 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
940 	ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
978 	const td_thragent_t *ta = th->th_ta;
992 	if (ta->map[th->th_tid].type == PT_LWP)
995 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
996 	                ta->thread_off_tcb,
1002 	ret = ps_pread(ta->ph,
1003 		tcb_addr + ta->thread_off_tmbx +
1012 	ret = ps_pwrite(ta->ph,
1013 		tcb_addr + ta->thread_off_tmbx +
1019 	ret = ps_pread(ta->ph,
1020 		tcb_addr + ta->thread_off_tmbx +
1028 	tmbx_addr = tcb_addr + ta->thread_off_tmbx;
1034 	ret = ps_pread(ta->ph, tmbx_addr, &tmbx, sizeof(tmbx));
1040 			ret = ps_pwrite(ta->ph, tmbx_addr, &tmbx,
1048 pt_unmap_lwp(const td_thragent_t *ta, lwpid_t lwp)
1052 	for (i = 0; i < ta->map_len; ++i) {
1053 		if (ta->map[i].type == PT_LWP && ta->map[i].lwp == lwp) {
1054 			ta->map[i].type = PT_NONE;
1074 	const td_thragent_t *ta = th->th_ta;
1079 	obj_entry = _linkmap - ta->thread_off_linkmap;
1082 	ret = ps_pread(ta->ph,
1083 		obj_entry + ta->thread_off_tlsindex,
1089 	ret = ps_pread(ta->ph, ta->map[th->th_tid].thr +
1090 		ta->thread_off_tcb,
1096 	ret = ps_pread(ta->ph, tcb_addr + ta->thread_off_dtv,
1101 	ret = ps_pread(ta->ph, dtv_addr + sizeof(void *) * (tls_index + 1),