Lines Matching refs:dpr
102 dt_proc_bpcreate(dt_proc_t *dpr, uintptr_t addr, dt_bkpt_f *func, void *data)
104 struct ps_prochandle *P = dpr->dpr_proc;
107 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
109 if ((dbp = dt_zalloc(dpr->dpr_hdl, sizeof (dt_bkpt_t))) != NULL) {
121 dt_list_append(&dpr->dpr_bps, dbp);
128 dt_proc_bpdestroy(dt_proc_t *dpr, int delbkpts)
130 int state = Pstate(dpr->dpr_proc);
133 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
135 for (dbp = dt_list_next(&dpr->dpr_bps); dbp != NULL; dbp = nbp) {
138 (void) Pdelbkpt(dpr->dpr_proc,
142 dt_list_delete(&dpr->dpr_bps, dbp);
143 dt_free(dpr->dpr_hdl, dbp);
148 dt_proc_bpmatch(dtrace_hdl_t *dtp, dt_proc_t *dpr)
151 const lwpstatus_t *psp = &Pstatus(dpr->dpr_proc)->pr_lwp;
157 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
160 proc_regget(dpr->dpr_proc, REG_PC, &pc);
164 for (dbp = dt_list_next(&dpr->dpr_bps);
178 (int)dpr->dpr_pid, (ulong_t)psp->pr_reg[R_PC]);
180 (int)dpr->dpr_pid, pc);
186 (int)dpr->dpr_pid, (ulong_t)dbp->dbp_addr, ++dbp->dbp_hits);
188 dbp->dbp_func(dtp, dpr, dbp->dbp_data);
190 (void) Pxecbkpt(dpr->dpr_proc, &dbp->dbp_instr);
192 (void) Pxecbkpt(dpr->dpr_proc, dbp->dbp_instr);
197 dt_proc_bpenable(dt_proc_t *dpr)
201 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
203 for (dbp = dt_list_next(&dpr->dpr_bps);
205 if (!dbp->dbp_active && Psetbkpt(dpr->dpr_proc,
214 dt_proc_bpdisable(dt_proc_t *dpr)
218 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
220 for (dbp = dt_list_next(&dpr->dpr_bps);
222 if (dbp->dbp_active && Pdelbkpt(dpr->dpr_proc,
231 dt_proc_notify(dtrace_hdl_t *dtp, dt_proc_hash_t *dph, dt_proc_t *dpr,
238 (int)dpr->dpr_pid, msg);
240 dprn->dprn_dpr = dpr;
264 dt_proc_stop(dt_proc_t *dpr, uint8_t why)
266 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
269 if (dpr->dpr_stop & why) {
270 dpr->dpr_stop |= DT_PROC_STOP_IDLE;
271 dpr->dpr_stop &= ~why;
273 (void) pthread_cond_broadcast(&dpr->dpr_cv);
280 dt_proc_bpdisable(dpr);
282 while (dpr->dpr_stop & DT_PROC_STOP_IDLE)
283 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
285 dt_proc_bpenable(dpr);
291 dt_proc_bpmain(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *fname)
293 dt_dprintf("pid %d: breakpoint at %s()\n", (int)dpr->dpr_pid, fname);
294 dt_proc_stop(dpr, DT_PROC_STOP_MAIN);
298 dt_proc_rdevent(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *evname)
303 if ((err = rd_event_getmsg(dpr->dpr_rtld, &rdm)) != RD_OK) {
305 (int)dpr->dpr_pid, evname, rd_errstr(err));
310 (int)dpr->dpr_pid, evname, rdm.type, rdm.u.state);
319 Pupdate_syms(dpr->dpr_proc);
320 if (dt_pid_create_probes_module(dtp, dpr) != 0)
321 dt_proc_notify(dtp, dtp->dt_procs, dpr,
322 dpr->dpr_errmsg);
326 Pupdate_syms(dpr->dpr_proc);
327 dt_proc_stop(dpr, DT_PROC_STOP_PREINIT);
330 Pupdate_syms(dpr->dpr_proc);
331 dt_proc_stop(dpr, DT_PROC_STOP_POSTINIT);
337 dt_proc_rdwatch(dt_proc_t *dpr, rd_event_e event, const char *evname)
342 if ((err = rd_event_addr(dpr->dpr_rtld, event, &rdn)) != RD_OK) {
344 (int)dpr->dpr_pid, evname, rd_errstr(err));
350 (int)dpr->dpr_pid, evname, rdn.type);
354 (void) dt_proc_bpcreate(dpr, rdn.u.bptaddr,
368 dt_proc_attach(dt_proc_t *dpr, int exec)
371 const pstatus_t *psp = Pstatus(dpr->dpr_proc);
376 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
384 dt_proc_bpdestroy(dpr, B_FALSE);
386 Preset_maps(dpr->dpr_proc);
389 if ((dpr->dpr_rtld = Prd_agent(dpr->dpr_proc)) != NULL &&
390 (err = rd_event_enable(dpr->dpr_rtld, B_TRUE)) == RD_OK) {
392 dt_proc_rdwatch(dpr, RD_PREINIT, "RD_PREINIT");
394 dt_proc_rdwatch(dpr, RD_POSTINIT, "RD_POSTINIT");
396 dt_proc_rdwatch(dpr, RD_DLACTIVITY, "RD_DLACTIVITY");
400 (int)dpr->dpr_pid, dpr->dpr_rtld ? rd_errstr(err) :
404 Pupdate_maps(dpr->dpr_proc);
406 if (Pxlookup_by_name(dpr->dpr_proc, LM_ID_BASE,
408 (void) dt_proc_bpcreate(dpr, (uintptr_t)sym.st_value,
412 (int)dpr->dpr_pid, strerror(errno));
437 dt_proc_waitrun(dt_proc_t *dpr)
441 struct ps_prochandle *P = dpr->dpr_proc;
451 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
463 (void) pthread_mutex_unlock(&dpr->dpr_lock);
465 while (!dpr->dpr_quit) {
469 (void) pthread_mutex_lock(&dpr->dpr_lock);
485 (void) pthread_mutex_unlock(&dpr->dpr_lock);
489 (void) pthread_mutex_lock(&dpr->dpr_lock);
515 dt_proc_t *dpr = datap->dpcd_proc;
516 dt_proc_hash_t *dph = dpr->dpr_hdl->dt_procs;
517 struct ps_prochandle *P = dpr->dpr_proc;
518 int pid = dpr->dpr_pid;
540 (void) pthread_mutex_lock(&dpr->dpr_lock);
569 dt_proc_attach(dpr, B_FALSE); /* enable rtld breakpoints */
580 dt_proc_stop(dpr, DT_PROC_STOP_CREATE);
582 dt_proc_stop(dpr, DT_PROC_STOP_GRAB);
586 (int)dpr->dpr_pid, strerror(errno));
589 (void) pthread_mutex_unlock(&dpr->dpr_lock);
600 while (!dpr->dpr_quit) {
613 (void) pthread_mutex_lock(&dpr->dpr_lock);
618 (void) pthread_mutex_unlock(&dpr->dpr_lock);
646 dt_proc_waitrun(dpr);
647 (void) pthread_mutex_unlock(&dpr->dpr_lock);
661 dt_proc_bpmatch(dtp, dpr);
664 dt_proc_bpdisable(dpr);
667 dt_proc_bpenable(dpr);
670 dt_proc_attach(dpr, B_TRUE);
682 dpr->dpr_quit = B_TRUE;
688 dpr->dpr_quit = B_TRUE;
695 (int)dpr->dpr_pid, strerror(errno));
698 (void) pthread_mutex_unlock(&dpr->dpr_lock);
706 dt_proc_notify(dtp, dph, dpr, NULL);
713 (void) pthread_mutex_lock(&dpr->dpr_lock);
715 dt_proc_bpdestroy(dpr, B_TRUE);
716 dpr->dpr_done = B_TRUE;
717 dpr->dpr_tid = 0;
719 (void) pthread_cond_broadcast(&dpr->dpr_cv);
720 (void) pthread_mutex_unlock(&dpr->dpr_lock);
727 dt_proc_error(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *format, ...)
735 if (dpr->dpr_proc != NULL)
736 Prelease(dpr->dpr_proc, 0);
738 dt_free(dtp, dpr);
752 dt_proc_t *dpr, **dpp = &dph->dph_hash[pid & (dph->dph_hashlen - 1)];
754 for (dpr = *dpp; dpr != NULL; dpr = dpr->dpr_hash) {
755 if (dpr->dpr_pid == pid)
758 dpp = &dpr->dpr_hash;
761 assert(dpr != NULL);
762 assert(dpr->dpr_proc == P);
765 *dpp = dpr->dpr_hash; /* remove from pid hash chain */
767 return (dpr);
773 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
778 assert(dpr != NULL);
786 if (!(Pstatus(dpr->dpr_proc)->pr_flags & (PR_KLC | PR_RLC))) {
788 if (!(proc_getflags(dpr->dpr_proc) & (PR_KLC | PR_RLC))) {
790 dt_dprintf("abandoning pid %d\n", (int)dpr->dpr_pid);
793 } else if (Pstatus(dpr->dpr_proc)->pr_flags & PR_KLC) {
795 } else if (proc_getflags(dpr->dpr_proc) & PR_KLC) {
797 dt_dprintf("killing pid %d\n", (int)dpr->dpr_pid);
800 dt_dprintf("releasing pid %d\n", (int)dpr->dpr_pid);
804 if (dpr->dpr_tid) {
819 (void) pthread_mutex_lock(&dpr->dpr_lock);
820 dpr->dpr_quit = B_TRUE;
822 (void) _lwp_kill(dpr->dpr_tid, SIGCANCEL);
824 pthread_kill(dpr->dpr_tid, SIGTHR);
826 pthread_cancel(dpr->dpr_tid);
833 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
834 dt_proc_bpenable(dpr);
835 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
836 (void) pthread_cond_broadcast(&dpr->dpr_cv);
839 while (!dpr->dpr_done)
840 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
842 (void) pthread_mutex_unlock(&dpr->dpr_lock);
855 if (npr->dprn_dpr == dpr) {
869 if (dpr->dpr_cacheable) {
874 dt_list_delete(&dph->dph_lrulist, dpr);
875 Prelease(dpr->dpr_proc, rflag);
876 dt_free(dtp, dpr);
880 dt_proc_create_thread(dtrace_hdl_t *dtp, dt_proc_t *dpr, uint_t stop)
887 (void) pthread_mutex_lock(&dpr->dpr_lock);
888 dpr->dpr_stop |= stop; /* set bit for initial rendezvous */
902 data.dpcd_proc = dpr;
905 err = pthread_create(&dpr->dpr_tid, &a, dt_proc_control, &data);
917 while (!dpr->dpr_done && !(dpr->dpr_stop & DT_PROC_STOP_IDLE))
918 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
926 if (dpr->dpr_done) {
928 const psinfo_t *prp = Ppsinfo(dpr->dpr_proc);
930 int pid = dpr->dpr_pid;
932 int stat = proc_getwstat(dpr->dpr_proc);
933 int pid = proc_getpid(dpr->dpr_proc);
935 if (proc_state(dpr->dpr_proc) == PS_LOST) {
936 (void) dt_proc_error(dpr->dpr_hdl, dpr,
940 (void) dt_proc_error(dpr->dpr_hdl, dpr,
944 (void) dt_proc_error(dpr->dpr_hdl, dpr,
952 (void) dt_proc_error(dpr->dpr_hdl, dpr,
954 (int)dpr->dpr_pid, strerror(err));
958 (void) pthread_mutex_unlock(&dpr->dpr_lock);
969 dt_proc_t *dpr;
972 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
975 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
976 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
979 if ((dpr->dpr_proc = Pcreate(file, argv, &err, NULL, 0)) == NULL) {
982 &dpr->dpr_proc)) != 0) {
984 return (dt_proc_error(dtp, dpr,
988 dpr->dpr_hdl = dtp;
990 dpr->dpr_pid = Pstatus(dpr->dpr_proc)->pr_pid;
992 dpr->dpr_pid = proc_getpid(dpr->dpr_proc);
995 (void) Punsetflags(dpr->dpr_proc, PR_RLC);
996 (void) Psetflags(dpr->dpr_proc, PR_KLC);
998 if (dt_proc_create_thread(dtp, dpr, dtp->dt_prcmode) != 0)
1001 dpr->dpr_hash = dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)];
1002 dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)] = dpr;
1003 dt_list_prepend(&dph->dph_lrulist, dpr);
1005 dt_dprintf("created pid %d\n", (int)dpr->dpr_pid);
1006 dpr->dpr_refs++;
1008 return (dpr->dpr_proc);
1016 dt_proc_t *dpr, *opr;
1024 for (dpr = dph->dph_hash[h]; dpr != NULL; dpr = dpr->dpr_hash) {
1025 if (dpr->dpr_pid == pid && !dpr->dpr_stale) {
1032 if (dpr->dpr_rdonly && !(flags & PGRAB_RDONLY)) {
1034 dpr->dpr_stale = B_TRUE;
1035 dpr->dpr_cacheable = B_FALSE;
1041 dt_list_delete(&dph->dph_lrulist, dpr);
1042 dt_list_prepend(&dph->dph_lrulist, dpr);
1043 dpr->dpr_refs++;
1044 return (dpr->dpr_proc);
1048 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
1051 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
1052 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
1055 if ((dpr->dpr_proc = Pgrab(pid, flags, &err)) == NULL) {
1057 if ((err = proc_attach(pid, flags, &dpr->dpr_proc)) != 0) {
1059 return (dt_proc_error(dtp, dpr,
1063 dpr->dpr_hdl = dtp;
1064 dpr->dpr_pid = pid;
1066 (void) Punsetflags(dpr->dpr_proc, PR_KLC);
1067 (void) Psetflags(dpr->dpr_proc, PR_RLC);
1077 * its ID in dpr->dpr_tid.
1091 dpr->dpr_cacheable = B_TRUE;
1092 dpr->dpr_rdonly = B_TRUE;
1096 } else if (dt_proc_create_thread(dtp, dpr, DT_PROC_STOP_GRAB) != 0)
1099 dpr->dpr_hash = dph->dph_hash[h];
1100 dph->dph_hash[h] = dpr;
1101 dt_list_prepend(&dph->dph_lrulist, dpr);
1104 dpr->dpr_refs++;
1106 return (dpr->dpr_proc);
1112 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1115 assert(dpr != NULL);
1116 assert(dpr->dpr_refs != 0);
1118 if (--dpr->dpr_refs == 0 &&
1119 (!dpr->dpr_cacheable || dph->dph_lrucnt > dph->dph_lrulim))
1126 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1128 (void) pthread_mutex_lock(&dpr->dpr_lock);
1130 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
1131 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
1132 (void) pthread_cond_broadcast(&dpr->dpr_cv);
1135 (void) pthread_mutex_unlock(&dpr->dpr_lock);
1141 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1142 int err = pthread_mutex_lock(&dpr->dpr_lock);
1149 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1150 int err = pthread_mutex_unlock(&dpr->dpr_lock);
1172 dt_proc_t *dpr;
1174 while ((dpr = dt_list_next(&dph->dph_lrulist)) != NULL)
1175 dt_proc_destroy(dtp, dpr->dpr_proc);