Lines Matching defs:dpr
98 dt_proc_bpcreate(dt_proc_t *dpr, uintptr_t addr, dt_bkpt_f *func, void *data)
100 struct ps_prochandle *P = dpr->dpr_proc;
103 assert(MUTEX_HELD(&dpr->dpr_lock));
105 if ((dbp = dt_zalloc(dpr->dpr_hdl, sizeof (dt_bkpt_t))) != NULL) {
113 dt_list_append(&dpr->dpr_bps, dbp);
120 dt_proc_bpdestroy(dt_proc_t *dpr, int delbkpts)
122 int state = Pstate(dpr->dpr_proc);
125 assert(MUTEX_HELD(&dpr->dpr_lock));
127 for (dbp = dt_list_next(&dpr->dpr_bps); dbp != NULL; dbp = nbp) {
130 (void) Pdelbkpt(dpr->dpr_proc,
134 dt_list_delete(&dpr->dpr_bps, dbp);
135 dt_free(dpr->dpr_hdl, dbp);
140 dt_proc_bpmatch(dtrace_hdl_t *dtp, dt_proc_t *dpr)
142 const lwpstatus_t *psp = &Pstatus(dpr->dpr_proc)->pr_lwp;
145 assert(MUTEX_HELD(&dpr->dpr_lock));
147 for (dbp = dt_list_next(&dpr->dpr_bps);
155 (int)dpr->dpr_pid, (ulong_t)psp->pr_reg[R_PC]);
160 (int)dpr->dpr_pid, (ulong_t)dbp->dbp_addr, ++dbp->dbp_hits);
162 dbp->dbp_func(dtp, dpr, dbp->dbp_data);
163 (void) Pxecbkpt(dpr->dpr_proc, dbp->dbp_instr);
167 dt_proc_bpenable(dt_proc_t *dpr)
171 assert(MUTEX_HELD(&dpr->dpr_lock));
173 for (dbp = dt_list_next(&dpr->dpr_bps);
175 if (!dbp->dbp_active && Psetbkpt(dpr->dpr_proc,
184 dt_proc_bpdisable(dt_proc_t *dpr)
188 assert(MUTEX_HELD(&dpr->dpr_lock));
190 for (dbp = dt_list_next(&dpr->dpr_bps);
192 if (dbp->dbp_active && Pdelbkpt(dpr->dpr_proc,
201 dt_proc_notify(dtrace_hdl_t *dtp, dt_proc_hash_t *dph, dt_proc_t *dpr,
208 (int)dpr->dpr_pid, msg);
210 dprn->dprn_dpr = dpr;
234 dt_proc_stop(dt_proc_t *dpr, uint8_t why)
236 assert(MUTEX_HELD(&dpr->dpr_lock));
239 if (dpr->dpr_stop & why) {
240 dpr->dpr_stop |= DT_PROC_STOP_IDLE;
241 dpr->dpr_stop &= ~why;
243 (void) pthread_cond_broadcast(&dpr->dpr_cv);
250 dt_proc_bpdisable(dpr);
252 while (dpr->dpr_stop & DT_PROC_STOP_IDLE)
253 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
255 dt_proc_bpenable(dpr);
261 dt_proc_bpmain(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *fname)
263 dt_dprintf("pid %d: breakpoint at %s()\n", (int)dpr->dpr_pid, fname);
264 dt_proc_stop(dpr, DT_PROC_STOP_MAIN);
268 dt_proc_rdevent(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *evname)
273 if ((err = rd_event_getmsg(dpr->dpr_rtld, &rdm)) != RD_OK) {
275 (int)dpr->dpr_pid, evname, rd_errstr(err));
280 (int)dpr->dpr_pid, evname, rdm.type, rdm.u.state);
287 Pupdate_syms(dpr->dpr_proc);
288 if (dt_pid_create_probes_module(dtp, dpr) != 0)
289 dt_proc_notify(dtp, dtp->dt_procs, dpr,
290 dpr->dpr_errmsg);
294 Pupdate_syms(dpr->dpr_proc);
295 dt_proc_stop(dpr, DT_PROC_STOP_PREINIT);
298 Pupdate_syms(dpr->dpr_proc);
299 dt_proc_stop(dpr, DT_PROC_STOP_POSTINIT);
305 dt_proc_rdwatch(dt_proc_t *dpr, rd_event_e event, const char *evname)
310 if ((err = rd_event_addr(dpr->dpr_rtld, event, &rdn)) != RD_OK) {
312 (int)dpr->dpr_pid, evname, rd_errstr(err));
318 (int)dpr->dpr_pid, evname, rdn.type);
322 (void) dt_proc_bpcreate(dpr, rdn.u.bptaddr,
331 dt_proc_attach(dt_proc_t *dpr, int exec)
333 const pstatus_t *psp = Pstatus(dpr->dpr_proc);
337 assert(MUTEX_HELD(&dpr->dpr_lock));
343 dt_proc_bpdestroy(dpr, B_FALSE);
344 Preset_maps(dpr->dpr_proc);
347 if ((dpr->dpr_rtld = Prd_agent(dpr->dpr_proc)) != NULL &&
348 (err = rd_event_enable(dpr->dpr_rtld, B_TRUE)) == RD_OK) {
349 dt_proc_rdwatch(dpr, RD_PREINIT, "RD_PREINIT");
350 dt_proc_rdwatch(dpr, RD_POSTINIT, "RD_POSTINIT");
351 dt_proc_rdwatch(dpr, RD_DLACTIVITY, "RD_DLACTIVITY");
354 (int)dpr->dpr_pid, dpr->dpr_rtld ? rd_errstr(err) :
358 Pupdate_maps(dpr->dpr_proc);
360 if (Pxlookup_by_name(dpr->dpr_proc, LM_ID_BASE,
362 (void) dt_proc_bpcreate(dpr, (uintptr_t)sym.st_value,
366 (int)dpr->dpr_pid, strerror(errno));
391 dt_proc_waitrun(dt_proc_t *dpr)
393 struct ps_prochandle *P = dpr->dpr_proc;
403 assert(MUTEX_HELD(&dpr->dpr_lock));
415 (void) pthread_mutex_unlock(&dpr->dpr_lock);
417 while (!dpr->dpr_quit) {
421 (void) pthread_mutex_lock(&dpr->dpr_lock);
437 (void) pthread_mutex_unlock(&dpr->dpr_lock);
441 (void) pthread_mutex_lock(&dpr->dpr_lock);
466 dt_proc_t *dpr = datap->dpcd_proc;
467 dt_proc_hash_t *dph = dpr->dpr_hdl->dt_procs;
468 struct ps_prochandle *P = dpr->dpr_proc;
471 int pid = dpr->dpr_pid;
489 (void) pthread_mutex_lock(&dpr->dpr_lock);
516 dt_proc_attach(dpr, B_FALSE); /* enable rtld breakpoints */
523 dt_proc_stop(dpr, DT_PROC_STOP_CREATE);
525 dt_proc_stop(dpr, DT_PROC_STOP_GRAB);
529 (int)dpr->dpr_pid, strerror(errno));
532 (void) pthread_mutex_unlock(&dpr->dpr_lock);
543 while (!dpr->dpr_quit) {
549 (void) pthread_mutex_lock(&dpr->dpr_lock);
552 (void) pthread_mutex_unlock(&dpr->dpr_lock);
575 dt_proc_waitrun(dpr);
576 (void) pthread_mutex_unlock(&dpr->dpr_lock);
590 dt_proc_bpmatch(dtp, dpr);
593 dt_proc_bpdisable(dpr);
596 dt_proc_bpenable(dpr);
599 dt_proc_attach(dpr, B_TRUE);
609 dpr->dpr_quit = B_TRUE;
615 dpr->dpr_quit = B_TRUE;
622 (int)dpr->dpr_pid, strerror(errno));
625 (void) pthread_mutex_unlock(&dpr->dpr_lock);
633 dt_proc_notify(dtp, dph, dpr, NULL);
640 (void) pthread_mutex_lock(&dpr->dpr_lock);
642 dt_proc_bpdestroy(dpr, B_TRUE);
643 dpr->dpr_done = B_TRUE;
644 dpr->dpr_tid = 0;
646 (void) pthread_cond_broadcast(&dpr->dpr_cv);
647 (void) pthread_mutex_unlock(&dpr->dpr_lock);
654 dt_proc_error(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *format, ...)
662 if (dpr->dpr_proc != NULL)
663 Prelease(dpr->dpr_proc, 0);
665 dt_free(dtp, dpr);
675 dt_proc_t *dpr, **dpp = &dph->dph_hash[pid & (dph->dph_hashlen - 1)];
677 for (dpr = *dpp; dpr != NULL; dpr = dpr->dpr_hash) {
678 if (dpr->dpr_pid == pid)
681 dpp = &dpr->dpr_hash;
684 assert(dpr != NULL);
685 assert(dpr->dpr_proc == P);
688 *dpp = dpr->dpr_hash; /* remove from pid hash chain */
690 return (dpr);
696 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
701 assert(dpr != NULL);
708 if (!(Pstatus(dpr->dpr_proc)->pr_flags & (PR_KLC | PR_RLC))) {
709 dt_dprintf("abandoning pid %d\n", (int)dpr->dpr_pid);
711 } else if (Pstatus(dpr->dpr_proc)->pr_flags & PR_KLC) {
712 dt_dprintf("killing pid %d\n", (int)dpr->dpr_pid);
715 dt_dprintf("releasing pid %d\n", (int)dpr->dpr_pid);
719 if (dpr->dpr_tid) {
734 (void) pthread_mutex_lock(&dpr->dpr_lock);
735 dpr->dpr_quit = B_TRUE;
736 (void) _lwp_kill(dpr->dpr_tid, SIGCANCEL);
742 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
743 dt_proc_bpenable(dpr);
744 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
745 (void) pthread_cond_broadcast(&dpr->dpr_cv);
748 while (!dpr->dpr_done)
749 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
751 (void) pthread_mutex_unlock(&dpr->dpr_lock);
764 if (npr->dprn_dpr == dpr) {
778 if (dpr->dpr_cacheable) {
783 dt_list_delete(&dph->dph_lrulist, dpr);
784 Prelease(dpr->dpr_proc, rflag);
785 dt_free(dtp, dpr);
789 dt_proc_create_thread(dtrace_hdl_t *dtp, dt_proc_t *dpr, uint_t stop)
796 (void) pthread_mutex_lock(&dpr->dpr_lock);
797 dpr->dpr_stop |= stop; /* set bit for initial rendezvous */
807 data.dpcd_proc = dpr;
810 err = pthread_create(&dpr->dpr_tid, &a, dt_proc_control, &data);
822 while (!dpr->dpr_done && !(dpr->dpr_stop & DT_PROC_STOP_IDLE))
823 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
831 if (dpr->dpr_done) {
832 const psinfo_t *prp = Ppsinfo(dpr->dpr_proc);
834 int pid = dpr->dpr_pid;
836 if (Pstate(dpr->dpr_proc) == PS_LOST) {
837 (void) dt_proc_error(dpr->dpr_hdl, dpr,
841 (void) dt_proc_error(dpr->dpr_hdl, dpr,
845 (void) dt_proc_error(dpr->dpr_hdl, dpr,
853 (void) dt_proc_error(dpr->dpr_hdl, dpr,
855 (int)dpr->dpr_pid, strerror(err));
858 (void) pthread_mutex_unlock(&dpr->dpr_lock);
868 dt_proc_t *dpr;
871 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
874 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
875 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
877 if ((dpr->dpr_proc = Pcreate(file, argv, &err, NULL, 0)) == NULL) {
878 return (dt_proc_error(dtp, dpr,
882 dpr->dpr_hdl = dtp;
883 dpr->dpr_pid = Pstatus(dpr->dpr_proc)->pr_pid;
885 (void) Punsetflags(dpr->dpr_proc, PR_RLC);
886 (void) Psetflags(dpr->dpr_proc, PR_KLC);
888 if (dt_proc_create_thread(dtp, dpr, dtp->dt_prcmode) != 0)
891 dpr->dpr_hash = dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)];
892 dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)] = dpr;
893 dt_list_prepend(&dph->dph_lrulist, dpr);
895 dt_dprintf("created pid %d\n", (int)dpr->dpr_pid);
896 dpr->dpr_refs++;
898 return (dpr->dpr_proc);
906 dt_proc_t *dpr, *opr;
914 for (dpr = dph->dph_hash[h]; dpr != NULL; dpr = dpr->dpr_hash) {
915 if (dpr->dpr_pid == pid && !dpr->dpr_stale) {
922 if (dpr->dpr_rdonly && !(flags & PGRAB_RDONLY)) {
924 dpr->dpr_stale = B_TRUE;
925 dpr->dpr_cacheable = B_FALSE;
931 dt_list_delete(&dph->dph_lrulist, dpr);
932 dt_list_prepend(&dph->dph_lrulist, dpr);
933 dpr->dpr_refs++;
934 return (dpr->dpr_proc);
938 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
941 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
942 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
944 if ((dpr->dpr_proc = Pgrab(pid, flags, &err)) == NULL) {
945 return (dt_proc_error(dtp, dpr,
949 dpr->dpr_hdl = dtp;
950 dpr->dpr_pid = pid;
952 (void) Punsetflags(dpr->dpr_proc, PR_KLC);
953 (void) Psetflags(dpr->dpr_proc, PR_RLC);
963 * its ID in dpr->dpr_tid.
977 dpr->dpr_cacheable = B_TRUE;
978 dpr->dpr_rdonly = B_TRUE;
982 } else if (dt_proc_create_thread(dtp, dpr, DT_PROC_STOP_GRAB) != 0)
985 dpr->dpr_hash = dph->dph_hash[h];
986 dph->dph_hash[h] = dpr;
987 dt_list_prepend(&dph->dph_lrulist, dpr);
990 dpr->dpr_refs++;
992 return (dpr->dpr_proc);
998 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1001 assert(dpr != NULL);
1002 assert(dpr->dpr_refs != 0);
1004 if (--dpr->dpr_refs == 0 &&
1005 (!dpr->dpr_cacheable || dph->dph_lrucnt > dph->dph_lrulim))
1012 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1014 (void) pthread_mutex_lock(&dpr->dpr_lock);
1016 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
1017 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
1018 (void) pthread_cond_broadcast(&dpr->dpr_cv);
1021 (void) pthread_mutex_unlock(&dpr->dpr_lock);
1027 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1028 int err = pthread_mutex_lock(&dpr->dpr_lock);
1035 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1036 int err = pthread_mutex_unlock(&dpr->dpr_lock);
1064 dt_proc_t *dpr;
1066 while ((dpr = dt_list_next(&dph->dph_lrulist)) != NULL)
1067 dt_proc_destroy(dtp, dpr->dpr_proc);