struct ps_prochandle *
dt_proc_create(dtrace_hdl_t *dtp, const char *file, char *const *argv)
{
dt_proc_hash_t *dph = dtp->dt_procs;
dt_proc_t *dpr;
int err;
if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
return (NULL); /* errno is set for us */
(void) pthread_mutex_init(&dpr->dpr_lock, NULL);
(void) pthread_cond_init(&dpr->dpr_cv, NULL);
if ((dpr->dpr_proc = Pcreate(file, argv, &err, NULL, 0, dtp->dt_arch)) == NULL) {
return (dt_proc_error(dtp, dpr,
"failed to execute %s: %s\n", file, Pcreate_error(err)));
}
dpr->dpr_hdl = dtp;
dpr->dpr_pid = Pstatus(dpr->dpr_proc)->pr_pid;
(void) Punsetflags(dpr->dpr_proc, PR_RLC);
(void) Psetflags(dpr->dpr_proc, PR_KLC);
if (dt_proc_create_thread(dtp, dpr, dtp->dt_prcmode) != 0)
return (NULL); /* dt_proc_error() has been called for us */
dpr->dpr_hash = dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)];
dph->dph_hash[dpr->dpr_pid & (dph->dph_hashlen - 1)] = dpr;
dt_list_prepend(&dph->dph_lrulist, dpr);
dt_dprintf("created pid %d\n", (int)dpr->dpr_pid);
dpr->dpr_refs++;
return (dpr->dpr_proc);
}
struct ps_prochandle *
dt_proc_grab(dtrace_hdl_t *dtp, pid_t pid, int flags, int nomonitor)
{
dt_proc_hash_t *dph = dtp->dt_procs;
uint_t h = pid & (dph->dph_hashlen - 1);
dt_proc_t *dpr, *opr;
int err;
/*
* Search the hash table for the pid. If it is already grabbed or
* created, move the handle to the front of the lrulist, increment
* the reference count, and return the existing ps_prochandle.
*/
for (dpr = dph->dph_hash[h]; dpr != NULL; dpr = dpr->dpr_hash) {
if (dpr->dpr_pid == pid && !dpr->dpr_stale) {
/*
* If the cached handle was opened read-only and
* this request is for a writeable handle, mark
* the cached handle as stale and open a new handle.
* Since it's stale, unmark it as cacheable.
*/
if (dpr->dpr_rdonly && !(flags & PGRAB_RDONLY)) {
dt_dprintf("upgrading pid %d\n", (int)pid);
dpr->dpr_stale = B_TRUE;
dpr->dpr_cacheable = B_FALSE;
dph->dph_lrucnt--;
break;
}
dt_dprintf("grabbed pid %d (cached)\n", (int)pid);
dt_list_delete(&dph->dph_lrulist, dpr);
dt_list_prepend(&dph->dph_lrulist, dpr);
dpr->dpr_refs++;
return (dpr->dpr_proc);
}
}
if ((dpr = dt_zalloc(dtp, sizeof (dt_proc_t))) == NULL)
return (NULL); /* errno is set for us */
(void) pthread_mutex_init(&dpr->dpr_lock, NULL);
(void) pthread_cond_init(&dpr->dpr_cv, NULL);
//printf("grabbing pid %d\n", pid);
if ((dpr->dpr_proc = Pgrab(pid, flags, &err)) == NULL) {
return (dt_proc_error(dtp, dpr,
"failed to grab pid %d: %s\n", (int)pid, Pgrab_error(err)));
}
dpr->dpr_hdl = dtp;
dpr->dpr_pid = pid;
(void) Punsetflags(dpr->dpr_proc, PR_KLC);
(void) Psetflags(dpr->dpr_proc, PR_RLC);
/*
* If we are attempting to grab the process without a monitor
* thread, then mark the process cacheable only if it's being
* grabbed read-only. If we're currently caching more process
* handles than dph_lrulim permits, attempt to find the
* least-recently-used handle that is currently unreferenced and
* release it from the cache. Otherwise we are grabbing the process
* for control: create a control thread for this process and store
* its ID in dpr->dpr_tid.
*/
if (nomonitor || (flags & PGRAB_RDONLY)) {
if (dph->dph_lrucnt >= dph->dph_lrulim) {
for (opr = dt_list_prev(&dph->dph_lrulist);
opr != NULL; opr = dt_list_prev(opr)) {
if (opr->dpr_cacheable && opr->dpr_refs == 0) {
dt_proc_destroy(dtp, opr->dpr_proc);
break;
}
}
}
if (flags & PGRAB_RDONLY) {
dpr->dpr_cacheable = B_TRUE;
dpr->dpr_rdonly = B_TRUE;
dph->dph_lrucnt++;
}
} else if (dt_proc_create_thread(dtp, dpr, DT_PROC_STOP_GRAB) != 0)
return (NULL); /* dt_proc_error() has been called for us */
dpr->dpr_hash = dph->dph_hash[h];
dph->dph_hash[h] = dpr;
dt_list_prepend(&dph->dph_lrulist, dpr);
dt_dprintf("grabbed pid %d\n", (int)pid);
dpr->dpr_refs++;
return (dpr->dpr_proc);
}
