Lines Matching defs:dpr
94 dt_proc_bpcreate(dt_proc_t *dpr, uintptr_t addr, dt_bkpt_f *func, void *data)
96 struct ps_prochandle *P = dpr->dpr_proc;
99 assert(MUTEX_HELD(&dpr->dpr_lock));
101 if ((dbp = dt_zalloc(dpr->dpr_hdl, sizeof (dt_bkpt_t))) != NULL) {
109 dt_list_append(&dpr->dpr_bps, dbp);
116 dt_proc_bpdestroy(dt_proc_t *dpr, int delbkpts)
118 int state = Pstate(dpr->dpr_proc);
121 assert(MUTEX_HELD(&dpr->dpr_lock));
123 for (dbp = dt_list_next(&dpr->dpr_bps); dbp != NULL; dbp = nbp) {
126 (void) Pdelbkpt(dpr->dpr_proc,
130 dt_list_delete(&dpr->dpr_bps, dbp);
131 dt_free(dpr->dpr_hdl, dbp);
136 dt_proc_bpmatch(dtrace_hdl_t *dtp, dt_proc_t *dpr)
138 const lwpstatus_t *psp = &Pstatus(dpr->dpr_proc)->pr_lwp;
141 assert(MUTEX_HELD(&dpr->dpr_lock));
143 for (dbp = dt_list_next(&dpr->dpr_bps);
151 (int)dpr->dpr_pid, (ulong_t)psp->pr_reg[R_PC]);
156 (int)dpr->dpr_pid, (ulong_t)dbp->dbp_addr, ++dbp->dbp_hits);
158 dbp->dbp_func(dtp, dpr, dbp->dbp_data);
159 (void) Pxecbkpt(dpr->dpr_proc, dbp->dbp_instr);
163 dt_proc_bpenable(dt_proc_t *dpr)
167 assert(MUTEX_HELD(&dpr->dpr_lock));
169 for (dbp = dt_list_next(&dpr->dpr_bps);
171 if (!dbp->dbp_active && Psetbkpt(dpr->dpr_proc,
180 dt_proc_bpdisable(dt_proc_t *dpr)
184 assert(MUTEX_HELD(&dpr->dpr_lock));
186 for (dbp = dt_list_next(&dpr->dpr_bps);
188 if (dbp->dbp_active && Pdelbkpt(dpr->dpr_proc,
197 dt_proc_notify(dtrace_hdl_t *dtp, dt_proc_hash_t *dph, dt_proc_t *dpr,
204 (int)dpr->dpr_pid, msg);
206 dprn->dprn_dpr = dpr;
230 dt_proc_stop(dt_proc_t *dpr, uint8_t why)
232 assert(MUTEX_HELD(&dpr->dpr_lock));
235 if (dpr->dpr_stop & why) {
236 dpr->dpr_stop |= DT_PROC_STOP_IDLE;
237 dpr->dpr_stop &= ~why;
239 (void) pthread_cond_broadcast(&dpr->dpr_cv);
246 dt_proc_bpdisable(dpr);
248 while (dpr->dpr_stop & DT_PROC_STOP_IDLE)
249 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
251 dt_proc_bpenable(dpr);
257 dt_proc_bpmain(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *fname)
259 dt_dprintf("pid %d: breakpoint at %s()\n", (int)dpr->dpr_pid, fname);
260 dt_proc_stop(dpr, DT_PROC_STOP_MAIN);
264 dt_proc_rdevent(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *evname)
269 if ((err = rd_event_getmsg(dpr->dpr_rtld, &rdm)) != RD_OK) {
271 (int)dpr->dpr_pid, evname, rd_errstr(err));
276 (int)dpr->dpr_pid, evname, rdm.type, rdm.u.state);
283 Pupdate_syms(dpr->dpr_proc);
284 if (dt_pid_create_probes_module(dtp, dpr) != 0)
285 dt_proc_notify(dtp, dtp->dt_procs, dpr,
286 dpr->dpr_errmsg);
290 Pupdate_syms(dpr->dpr_proc);
291 dt_proc_stop(dpr, DT_PROC_STOP_PREINIT);
294 Pupdate_syms(dpr->dpr_proc);
295 dt_proc_stop(dpr, DT_PROC_STOP_POSTINIT);
301 dt_proc_rdwatch(dt_proc_t *dpr, rd_event_e event, const char *evname)
306 if ((err = rd_event_addr(dpr->dpr_rtld, event, &rdn)) != RD_OK) {
308 (int)dpr->dpr_pid, evname, rd_errstr(err));
314 (int)dpr->dpr_pid, evname, rdn.type);
318 (void) dt_proc_bpcreate(dpr, rdn.u.bptaddr,
327 dt_proc_attach(dt_proc_t *dpr, int exec)
329 const pstatus_t *psp = Pstatus(dpr->dpr_proc);
333 assert(MUTEX_HELD(&dpr->dpr_lock));
339 dt_proc_bpdestroy(dpr, B_FALSE);
340 Preset_maps(dpr->dpr_proc);
343 if ((dpr->dpr_rtld = Prd_agent(dpr->dpr_proc)) != NULL &&
344 (err = rd_event_enable(dpr->dpr_rtld, B_TRUE)) == RD_OK) {
345 dt_proc_rdwatch(dpr, RD_PREINIT, "RD_PREINIT");
346 dt_proc_rdwatch(dpr, RD_POSTINIT, "RD_POSTINIT");
347 dt_proc_rdwatch(dpr, RD_DLACTIVITY, "RD_DLACTIVITY");
350 (int)dpr->dpr_pid, dpr->dpr_rtld ? rd_errstr(err) :
354 Pupdate_maps(dpr->dpr_proc);
356 if (Pxlookup_by_name(dpr->dpr_proc, LM_ID_BASE,
358 (void) dt_proc_bpcreate(dpr, (uintptr_t)sym.st_value,
362 (int)dpr->dpr_pid, strerror(errno));
387 dt_proc_waitrun(dt_proc_t *dpr)
389 struct ps_prochandle *P = dpr->dpr_proc;
399 assert(MUTEX_HELD(&dpr->dpr_lock));
411 (void) pthread_mutex_unlock(&dpr->dpr_lock);
413 while (!dpr->dpr_quit) {
417 (void) pthread_mutex_lock(&dpr->dpr_lock);
433 (void) pthread_mutex_unlock(&dpr->dpr_lock);
437 (void) pthread_mutex_lock(&dpr->dpr_lock);
462 dt_proc_t *dpr = datap->dpcd_proc;
463 dt_proc_hash_t *dph = dpr->dpr_hdl->dt_procs;
464 struct ps_prochandle *P = dpr->dpr_proc;
467 int pid = dpr->dpr_pid;
485 (void) pthread_mutex_lock(&dpr->dpr_lock);
512 dt_proc_attach(dpr, B_FALSE); /* enable rtld breakpoints */
519 dt_proc_stop(dpr, DT_PROC_STOP_CREATE);
521 dt_proc_stop(dpr, DT_PROC_STOP_GRAB);
525 (int)dpr->dpr_pid, strerror(errno));
528 (void) pthread_mutex_unlock(&dpr->dpr_lock);
539 while (!dpr->dpr_quit) {
545 (void) pthread_mutex_lock(&dpr->dpr_lock);
548 (void) pthread_mutex_unlock(&dpr->dpr_lock);
571 dt_proc_waitrun(dpr);
572 (void) pthread_mutex_unlock(&dpr->dpr_lock);
586 dt_proc_bpmatch(dtp, dpr);
589 dt_proc_bpdisable(dpr);
592 dt_proc_bpenable(dpr);
595 dt_proc_attach(dpr, B_TRUE);
605 dpr->dpr_quit = B_TRUE;
611 dpr->dpr_quit = B_TRUE;
618 (int)dpr->dpr_pid, strerror(errno));
621 (void) pthread_mutex_unlock(&dpr->dpr_lock);
629 dt_proc_notify(dtp, dph, dpr, NULL);
636 (void) pthread_mutex_lock(&dpr->dpr_lock);
638 dt_proc_bpdestroy(dpr, B_TRUE);
639 dpr->dpr_done = B_TRUE;
640 dpr->dpr_tid = 0;
642 (void) pthread_cond_broadcast(&dpr->dpr_cv);
643 (void) pthread_mutex_unlock(&dpr->dpr_lock);
650 dt_proc_error(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *format, ...)
658 if (dpr->dpr_proc != NULL)
659 Prelease(dpr->dpr_proc, 0);
661 dt_free(dtp, dpr);
671 dt_proc_t *dpr, **dpp = &dph->dph_hash[pid & (dph->dph_hashlen - 1)];
673 for (dpr = *dpp; dpr != NULL; dpr = dpr->dpr_hash) {
674 if (dpr->dpr_pid == pid)
677 dpp = &dpr->dpr_hash;
680 assert(dpr != NULL);
681 assert(dpr->dpr_proc == P);
684 *dpp = dpr->dpr_hash; /* remove from pid hash chain */
686 return (dpr);
692 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
697 assert(dpr != NULL);
704 if (!(Pstatus(dpr->dpr_proc)->pr_flags & (PR_KLC | PR_RLC))) {
705 dt_dprintf("abandoning pid %d\n", (int)dpr->dpr_pid);
707 } else if (Pstatus(dpr->dpr_proc)->pr_flags & PR_KLC) {
708 dt_dprintf("killing pid %d\n", (int)dpr->dpr_pid);
711 dt_dprintf("releasing pid %d\n", (int)dpr->dpr_pid);
715 if (dpr->dpr_tid) {
730 (void) pthread_mutex_lock(&dpr->dpr_lock);
731 dpr->dpr_quit = B_TRUE;
732 (void) _lwp_kill(dpr->dpr_tid, SIGCANCEL);
738 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
739 dt_proc_bpenable(dpr);
740 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
741 (void) pthread_cond_broadcast(&dpr->dpr_cv);
744 while (!dpr->dpr_done)
745 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
747 (void) pthread_mutex_unlock(&dpr->dpr_lock);
760 if (npr->dprn_dpr == dpr) {
774 if (dpr->dpr_cacheable) {
779 dt_list_delete(&dph->dph_lrulist, dpr);
780 Prelease(dpr->dpr_proc, rflag);
781 dt_free(dtp, dpr);
785 dt_proc_create_thread(dtrace_hdl_t *dtp, dt_proc_t *dpr, uint_t stop)
792 (void) pthread_mutex_lock(&dpr->dpr_lock);
793 dpr->dpr_stop |= stop; /* set bit for initial rendezvous */
803 data.dpcd_proc = dpr;
806 err = pthread_create(&dpr->dpr_tid, &a, dt_proc_control, &data);
818 while (!dpr->dpr_done && !(dpr->dpr_stop & DT_PROC_STOP_IDLE))
819 (void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
827 if (dpr->dpr_done) {
828 const psinfo_t *prp = Ppsinfo(dpr->dpr_proc);
830 int pid = dpr->dpr_pid;
832 if (Pstate(dpr->dpr_proc) == PS_LOST) {
833 (void) dt_proc_error(dpr->dpr_hdl, dpr,
837 (void) dt_proc_error(dpr->dpr_hdl, dpr,
841 (void) dt_proc_error(dpr->dpr_hdl, dpr,
849 (void) dt_proc_error(dpr->dpr_hdl, dpr,
851 (int)dpr->dpr_pid, strerror(err));
854 (void) pthread_mutex_unlock(&dpr->dpr_lock);
864 dt_proc_t *dpr;
867 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
870 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
871 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
873 if ((dpr->dpr_proc = Pcreate(file, argv, &err, NULL, 0)) == NULL) {
874 return (dt_proc_error(dtp, dpr,
878 dpr->dpr_hdl = dtp;
879 dpr->dpr_pid = Pstatus(dpr->dpr_proc)->pr_pid;
881 (void) Punsetflags(dpr->dpr_proc, PR_RLC);
882 (void) Psetflags(dpr->dpr_proc, PR_KLC);
884 if (dt_proc_create_thread(dtp, dpr, dtp->dt_prcmode) != 0)
887 dpr->dpr_hash = dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)];
888 dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)] = dpr;
889 dt_list_prepend(&dph->dph_lrulist, dpr);
891 dt_dprintf("created pid %d\n", (int)dpr->dpr_pid);
892 dpr->dpr_refs++;
894 return (dpr->dpr_proc);
902 dt_proc_t *dpr, *opr;
910 for (dpr = dph->dph_hash[h]; dpr != NULL; dpr = dpr->dpr_hash) {
911 if (dpr->dpr_pid == pid && !dpr->dpr_stale) {
918 if (dpr->dpr_rdonly && !(flags & PGRAB_RDONLY)) {
920 dpr->dpr_stale = B_TRUE;
921 dpr->dpr_cacheable = B_FALSE;
927 dt_list_delete(&dph->dph_lrulist, dpr);
928 dt_list_prepend(&dph->dph_lrulist, dpr);
929 dpr->dpr_refs++;
930 return (dpr->dpr_proc);
934 if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
937 (void) pthread_mutex_init(&dpr->dpr_lock, NULL);
938 (void) pthread_cond_init(&dpr->dpr_cv, NULL);
940 if ((dpr->dpr_proc = Pgrab(pid, flags, &err)) == NULL) {
941 return (dt_proc_error(dtp, dpr,
945 dpr->dpr_hdl = dtp;
946 dpr->dpr_pid = pid;
948 (void) Punsetflags(dpr->dpr_proc, PR_KLC);
949 (void) Psetflags(dpr->dpr_proc, PR_RLC);
959 * its ID in dpr->dpr_tid.
973 dpr->dpr_cacheable = B_TRUE;
974 dpr->dpr_rdonly = B_TRUE;
978 } else if (dt_proc_create_thread(dtp, dpr, DT_PROC_STOP_GRAB) != 0)
981 dpr->dpr_hash = dph->dph_hash[h];
982 dph->dph_hash[h] = dpr;
983 dt_list_prepend(&dph->dph_lrulist, dpr);
986 dpr->dpr_refs++;
988 return (dpr->dpr_proc);
994 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
997 assert(dpr != NULL);
998 assert(dpr->dpr_refs != 0);
1000 if (--dpr->dpr_refs == 0 &&
1001 (!dpr->dpr_cacheable || dph->dph_lrucnt > dph->dph_lrulim))
1008 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1010 (void) pthread_mutex_lock(&dpr->dpr_lock);
1012 if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
1013 dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
1014 (void) pthread_cond_broadcast(&dpr->dpr_cv);
1017 (void) pthread_mutex_unlock(&dpr->dpr_lock);
1023 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1024 int err = pthread_mutex_lock(&dpr->dpr_lock);
1031 dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
1032 int err = pthread_mutex_unlock(&dpr->dpr_lock);
1054 dt_proc_t *dpr;
1056 while ((dpr = dt_list_next(&dph->dph_lrulist)) != NULL)
1057 dt_proc_destroy(dtp, dpr->dpr_proc);