Lines Matching defs: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) {
117 dt_list_append(&dpr->dpr_bps, dbp);
124 dt_proc_bpdestroy(dt_proc_t *dpr, int delbkpts)
126 int state = Pstate(dpr->dpr_proc);
129 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
131 for (dbp = dt_list_next(&dpr->dpr_bps); dbp != NULL; dbp = nbp) {
134 (void) Pdelbkpt(dpr->dpr_proc,
138 dt_list_delete(&dpr->dpr_bps, dbp);
139 dt_free(dpr->dpr_hdl, dbp);
144 dt_proc_bpmatch(dtrace_hdl_t *dtp, dt_proc_t *dpr)
147 const lwpstatus_t *psp = &Pstatus(dpr->dpr_proc)->pr_lwp;
153 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
156 proc_regget(dpr->dpr_proc, REG_PC, &pc);
160 for (dbp = dt_list_next(&dpr->dpr_bps);
174 (int)dpr->dpr_pid, (ulong_t)psp->pr_reg[R_PC]);
176 (int)dpr->dpr_pid, pc);
182 (int)dpr->dpr_pid, (ulong_t)dbp->dbp_addr, ++dbp->dbp_hits);
184 dbp->dbp_func(dtp, dpr, dbp->dbp_data);
185 (void) Pxecbkpt(dpr->dpr_proc, dbp->dbp_instr);
189 dt_proc_bpenable(dt_proc_t *dpr)
193 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
195 for (dbp = dt_list_next(&dpr->dpr_bps);
197 if (!dbp->dbp_active && Psetbkpt(dpr->dpr_proc,
206 dt_proc_bpdisable(dt_proc_t *dpr)
210 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
212 for (dbp = dt_list_next(&dpr->dpr_bps);
214 if (dbp->dbp_active && Pdelbkpt(dpr->dpr_proc,
223 dt_proc_notify(dtrace_hdl_t *dtp, dt_proc_hash_t *dph, dt_proc_t *dpr,
230 (int)dpr->dpr_pid, msg);
232 dprn->dprn_dpr = dpr;
256 dt_proc_stop(dt_proc_t *dpr, uint8_t why)
258 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
261 if (dpr->dpr_stop & why) {
262 dpr->dpr_stop |= DT_PROC_STOP_IDLE;
263 dpr->dpr_stop &= ~why;
265 (void) pthread_cond_broadcast(&dpr->dpr_cv);
272 dt_proc_bpdisable(dpr);
274 while (dpr->dpr_stop & DT_PROC_STOP_IDLE)
275 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
277 dt_proc_bpenable(dpr);
283 dt_proc_bpmain(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *fname)
285 dt_dprintf("pid %d: breakpoint at %s()\n", (int)dpr->dpr_pid, fname);
286 dt_proc_stop(dpr, DT_PROC_STOP_MAIN);
290 dt_proc_rdevent(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *evname)
295 if ((err = rd_event_getmsg(dpr->dpr_rtld, &rdm)) != RD_OK) {
297 (int)dpr->dpr_pid, evname, rd_errstr(err));
302 (int)dpr->dpr_pid, evname, rdm.type, rdm.u.state);
309 Pupdate_syms(dpr->dpr_proc);
310 if (dt_pid_create_probes_module(dtp, dpr) != 0)
311 dt_proc_notify(dtp, dtp->dt_procs, dpr,
312 dpr->dpr_errmsg);
316 Pupdate_syms(dpr->dpr_proc);
317 dt_proc_stop(dpr, DT_PROC_STOP_PREINIT);
320 Pupdate_syms(dpr->dpr_proc);
321 dt_proc_stop(dpr, DT_PROC_STOP_POSTINIT);
327 dt_proc_rdwatch(dt_proc_t *dpr, rd_event_e event, const char *evname)
332 if ((err = rd_event_addr(dpr->dpr_rtld, event, &rdn)) != RD_OK) {
334 (int)dpr->dpr_pid, evname, rd_errstr(err));
340 (int)dpr->dpr_pid, evname, rdn.type);
344 (void) dt_proc_bpcreate(dpr, rdn.u.bptaddr,
358 dt_proc_attach(dt_proc_t *dpr, int exec)
361 const pstatus_t *psp = Pstatus(dpr->dpr_proc);
366 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
374 dt_proc_bpdestroy(dpr, B_FALSE);
376 Preset_maps(dpr->dpr_proc);
379 if ((dpr->dpr_rtld = Prd_agent(dpr->dpr_proc)) != NULL &&
380 (err = rd_event_enable(dpr->dpr_rtld, B_TRUE)) == RD_OK) {
382 dt_proc_rdwatch(dpr, RD_PREINIT, "RD_PREINIT");
384 dt_proc_rdwatch(dpr, RD_POSTINIT, "RD_POSTINIT");
386 dt_proc_rdwatch(dpr, RD_DLACTIVITY, "RD_DLACTIVITY");
390 (int)dpr->dpr_pid, dpr->dpr_rtld ? rd_errstr(err) :
394 Pupdate_maps(dpr->dpr_proc);
396 if (Pxlookup_by_name(dpr->dpr_proc, LM_ID_BASE,
398 (void) dt_proc_bpcreate(dpr, (uintptr_t)sym.st_value,
402 (int)dpr->dpr_pid, strerror(errno));
427 dt_proc_waitrun(dt_proc_t *dpr)
431 struct ps_prochandle *P = dpr->dpr_proc;
441 assert(DT_MUTEX_HELD(&dpr->dpr_lock));
453 (void) pthread_mutex_unlock(&dpr->dpr_lock);
455 while (!dpr->dpr_quit) {
459 (void) pthread_mutex_lock(&dpr->dpr_lock);
475 (void) pthread_mutex_unlock(&dpr->dpr_lock);
479 (void) pthread_mutex_lock(&dpr->dpr_lock);
505 dt_proc_t *dpr = datap->dpcd_proc;
506 dt_proc_hash_t *dph = dpr->dpr_hdl->dt_procs;
507 struct ps_prochandle *P = dpr->dpr_proc;
508 int pid = dpr->dpr_pid;
530 (void) pthread_mutex_lock(&dpr->dpr_lock);
559 dt_proc_attach(dpr, B_FALSE); /* enable rtld breakpoints */
570 dt_proc_stop(dpr, DT_PROC_STOP_CREATE);
572 dt_proc_stop(dpr, DT_PROC_STOP_GRAB);
576 (int)dpr->dpr_pid, strerror(errno));
579 (void) pthread_mutex_unlock(&dpr->dpr_lock);
590 while (!dpr->dpr_quit) {
603 (void) pthread_mutex_lock(&dpr->dpr_lock);
608 (void) pthread_mutex_unlock(&dpr->dpr_lock);
636 dt_proc_waitrun(dpr);
637 (void) pthread_mutex_unlock(&dpr->dpr_lock);
651 dt_proc_bpmatch(dtp, dpr);
654 dt_proc_bpdisable(dpr);
657 dt_proc_bpenable(dpr);
660 dt_proc_attach(dpr, B_TRUE);
672 dpr->dpr_quit = B_TRUE;
678 dpr->dpr_quit = B_TRUE;
685 (int)dpr->dpr_pid, strerror(errno));
688 (void) pthread_mutex_unlock(&dpr->dpr_lock);
696 dt_proc_notify(dtp, dph, dpr, NULL);
703 (void) pthread_mutex_lock(&dpr->dpr_lock);
705 dt_proc_bpdestroy(dpr, B_TRUE);
706 dpr->dpr_done = B_TRUE;
707 dpr->dpr_tid = 0;
709 (void) pthread_cond_broadcast(&dpr->dpr_cv);
710 (void) pthread_mutex_unlock(&dpr->dpr_lock);
717 dt_proc_error(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *format, ...)
725 if (dpr->dpr_proc != NULL)
726 Prelease(dpr->dpr_proc, 0);
728 dt_free(dtp, dpr);
742 dt_proc_t *dpr, **dpp = &dph->dph_hash[pid & (dph->dph_hashlen - 1)];
744 for (dpr = *dpp; dpr != NULL; dpr = dpr->dpr_hash) {
745 if (dpr->dpr_pid == pid)
748 dpp = &dpr->dpr_hash;
751 assert(dpr != NULL);
752 assert(dpr->dpr_proc == P);
755 *dpp = dpr->dpr_hash; /* remove from pid hash chain */
757 return (dpr);
763 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
768 assert(dpr != NULL);
776 if (!(Pstatus(dpr->dpr_proc)->pr_flags & (PR_KLC | PR_RLC))) {
778 if (!(proc_getflags(dpr->dpr_proc) & (PR_KLC | PR_RLC))) {
780 dt_dprintf("abandoning pid %d\n", (int)dpr->dpr_pid);
783 } else if (Pstatus(dpr->dpr_proc)->pr_flags & PR_KLC) {
785 } else if (proc_getflags(dpr->dpr_proc) & PR_KLC) {
787 dt_dprintf("killing pid %d\n", (int)dpr->dpr_pid);
790 dt_dprintf("releasing pid %d\n", (int)dpr->dpr_pid);
794 if (dpr->dpr_tid) {
809 (void) pthread_mutex_lock(&dpr->dpr_lock);
810 dpr->dpr_quit = B_TRUE;
812 (void) _lwp_kill(dpr->dpr_tid, SIGCANCEL);
814 pthread_kill(dpr->dpr_tid, SIGTHR);
821 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
822 dt_proc_bpenable(dpr);
823 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
824 (void) pthread_cond_broadcast(&dpr->dpr_cv);
827 while (!dpr->dpr_done)
828 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
830 (void) pthread_mutex_unlock(&dpr->dpr_lock);
843 if (npr->dprn_dpr == dpr) {
857 if (dpr->dpr_cacheable) {
862 dt_list_delete(&dph->dph_lrulist, dpr);
863 Prelease(dpr->dpr_proc, rflag);
864 dt_free(dtp, dpr);
868 dt_proc_create_thread(dtrace_hdl_t *dtp, dt_proc_t *dpr, uint_t stop)
875 (void) pthread_mutex_lock(&dpr->dpr_lock);
876 dpr->dpr_stop |= stop; /* set bit for initial rendezvous */
890 data.dpcd_proc = dpr;
893 err = pthread_create(&dpr->dpr_tid, &a, dt_proc_control, &data);
905 while (!dpr->dpr_done && !(dpr->dpr_stop & DT_PROC_STOP_IDLE))
906 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
914 if (dpr->dpr_done) {
916 const psinfo_t *prp = Ppsinfo(dpr->dpr_proc);
918 int pid = dpr->dpr_pid;
920 int stat = proc_getwstat(dpr->dpr_proc);
921 int pid = proc_getpid(dpr->dpr_proc);
923 if (proc_state(dpr->dpr_proc) == PS_LOST) {
924 (void) dt_proc_error(dpr->dpr_hdl, dpr,
928 (void) dt_proc_error(dpr->dpr_hdl, dpr,
932 (void) dt_proc_error(dpr->dpr_hdl, dpr,
940 (void) dt_proc_error(dpr->dpr_hdl, dpr,
942 (int)dpr->dpr_pid, strerror(err));
946 (void) pthread_mutex_unlock(&dpr->dpr_lock);
957 dt_proc_t *dpr;
960 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
963 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
964 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
967 if ((dpr->dpr_proc = Pcreate(file, argv, &err, NULL, 0)) == NULL) {
970 &dpr->dpr_proc)) != 0) {
972 return (dt_proc_error(dtp, dpr,
976 dpr->dpr_hdl = dtp;
978 dpr->dpr_pid = Pstatus(dpr->dpr_proc)->pr_pid;
980 dpr->dpr_pid = proc_getpid(dpr->dpr_proc);
983 (void) Punsetflags(dpr->dpr_proc, PR_RLC);
984 (void) Psetflags(dpr->dpr_proc, PR_KLC);
986 if (dt_proc_create_thread(dtp, dpr, dtp->dt_prcmode) != 0)
989 dpr->dpr_hash = dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)];
990 dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)] = dpr;
991 dt_list_prepend(&dph->dph_lrulist, dpr);
993 dt_dprintf("created pid %d\n", (int)dpr->dpr_pid);
994 dpr->dpr_refs++;
996 return (dpr->dpr_proc);
1004 dt_proc_t *dpr, *opr;
1012 for (dpr = dph->dph_hash[h]; dpr != NULL; dpr = dpr->dpr_hash) {
1013 if (dpr->dpr_pid == pid && !dpr->dpr_stale) {
1020 if (dpr->dpr_rdonly && !(flags & PGRAB_RDONLY)) {
1022 dpr->dpr_stale = B_TRUE;
1023 dpr->dpr_cacheable = B_FALSE;
1029 dt_list_delete(&dph->dph_lrulist, dpr);
1030 dt_list_prepend(&dph->dph_lrulist, dpr);
1031 dpr->dpr_refs++;
1032 return (dpr->dpr_proc);
1036 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
1039 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
1040 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
1043 if ((dpr->dpr_proc = Pgrab(pid, flags, &err)) == NULL) {
1045 if ((err = proc_attach(pid, flags, &dpr->dpr_proc)) != 0) {
1047 return (dt_proc_error(dtp, dpr,
1051 dpr->dpr_hdl = dtp;
1052 dpr->dpr_pid = pid;
1054 (void) Punsetflags(dpr->dpr_proc, PR_KLC);
1055 (void) Psetflags(dpr->dpr_proc, PR_RLC);
1065 * its ID in dpr->dpr_tid.
1079 dpr->dpr_cacheable = B_TRUE;
1080 dpr->dpr_rdonly = B_TRUE;
1084 } else if (dt_proc_create_thread(dtp, dpr, DT_PROC_STOP_GRAB) != 0)
1087 dpr->dpr_hash = dph->dph_hash[h];
1088 dph->dph_hash[h] = dpr;
1089 dt_list_prepend(&dph->dph_lrulist, dpr);
1092 dpr->dpr_refs++;
1094 return (dpr->dpr_proc);
1100 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1103 assert(dpr != NULL);
1104 assert(dpr->dpr_refs != 0);
1106 if (--dpr->dpr_refs == 0 &&
1107 (!dpr->dpr_cacheable || dph->dph_lrucnt > dph->dph_lrulim))
1114 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1116 (void) pthread_mutex_lock(&dpr->dpr_lock);
1118 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
1119 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
1120 (void) pthread_cond_broadcast(&dpr->dpr_cv);
1123 (void) pthread_mutex_unlock(&dpr->dpr_lock);
1129 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1130 int err = pthread_mutex_lock(&dpr->dpr_lock);
1137 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1138 int err = pthread_mutex_unlock(&dpr->dpr_lock);
1160 dt_proc_t *dpr;
1162 while ((dpr = dt_list_next(&dph->dph_lrulist)) != NULL)
1163 dt_proc_destroy(dtp, dpr->dpr_proc);