#include <sys/time.h>
#include <sys/proc.h>
#include <sys/wait.h>
#include <strings.h>
#include <signal.h>
#include <assert.h>
#include <errno.h>
#include "dt_impl.h"
#include <dt_proc.h>
#include <dt_pid.h>
extern void dt_proc_rdwatch(dt_proc_t *, rd_event_e, const char *);
extern void *dt_proc_control(void *arg);
void Pcheckpoint_syms(struct ps_prochandle *P);
dt_bkpt_t *
dt_proc_bpcreate(dt_proc_t *dpr, uintptr_t addr, dt_bkpt_f *func, void *data)
{
struct ps_prochandle *P = dpr->dpr_proc;
dt_bkpt_t *dbp;
assert(DT_MUTEX_HELD(&dpr->dpr_lock));
if ((dbp = dt_zalloc(dpr->dpr_hdl, sizeof (dt_bkpt_t))) != NULL) {
dbp->dbp_func = func;
dbp->dbp_data = data;
dbp->dbp_addr = addr;
if (Psetbkpt(P, dbp->dbp_addr, &dbp->dbp_instr) == 0)
dbp->dbp_active = B_TRUE;
dt_list_append(&dpr->dpr_bps, dbp);
}
return (dbp);
}
void
dt_proc_bpdestroy(dt_proc_t *dpr, int delbkpts)
{
int state = Pstate(dpr->dpr_proc);
dt_bkpt_t *dbp, *nbp;
assert(DT_MUTEX_HELD(&dpr->dpr_lock));
for (dbp = dt_list_next(&dpr->dpr_bps); dbp != NULL; dbp = nbp) {
if (delbkpts && dbp->dbp_active &&
state != PS_LOST && state != PS_UNDEAD) {
(void) Pdelbkpt(dpr->dpr_proc,
dbp->dbp_addr, dbp->dbp_instr);
}
nbp = dt_list_next(dbp);
dt_list_delete(&dpr->dpr_bps, dbp);
dt_free(dpr->dpr_hdl, dbp);
}
}
void
dt_proc_bpenable(dt_proc_t *dpr)
{
}
void
dt_proc_bpdisable(dt_proc_t *dpr)
{
}
void
dt_proc_notify(dtrace_hdl_t *dtp, dt_proc_hash_t *dph, dt_proc_t *dpr,
const char *msg)
{
dt_proc_notify_t *dprn = dt_alloc(dtp, sizeof (dt_proc_notify_t));
if (dprn == NULL) {
dt_dprintf("failed to allocate notification for %d %s\n",
(int)dpr->dpr_pid, msg);
} else {
dprn->dprn_dpr = dpr;
if (msg == NULL)
dprn->dprn_errmsg[0] = '\0';
else
(void) strlcpy(dprn->dprn_errmsg, msg,
sizeof (dprn->dprn_errmsg));
(void) pthread_mutex_lock(&dph->dph_lock);
dprn->dprn_next = dph->dph_notify;
dph->dph_notify = dprn;
(void) dtrace_signal(dtp);
(void) pthread_mutex_unlock(&dph->dph_lock);
}
}
void
dt_proc_stop(dt_proc_t *dpr, uint8_t why)
{
assert(DT_MUTEX_HELD(&dpr->dpr_lock));
assert(why != DT_PROC_STOP_IDLE);
if (dpr->dpr_stop & why) {
dpr->dpr_stop |= DT_PROC_STOP_IDLE;
dpr->dpr_stop &= ~why;
(void) pthread_cond_broadcast(&dpr->dpr_cv);
dt_proc_bpdisable(dpr);
while (dpr->dpr_stop & DT_PROC_STOP_IDLE)
(void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
dt_proc_bpenable(dpr);
}
}
void
dt_proc_bpmain(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *fname)
{
dt_dprintf("pid %d: breakpoint at %s()\n", (int)dpr->dpr_pid, fname);
dt_proc_stop(dpr, DT_PROC_STOP_MAIN);
}
static void
dt_proc_rdevent(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *evname)
{
rd_event_msg_t rdm;
rd_err_e err;
if ((err = rd_event_getmsg(dpr->dpr_rtld, &rdm)) != RD_OK) {
dt_dprintf("pid %d: failed to get %s event message: %s\n",
(int)dpr->dpr_pid, evname, rd_errstr(err));
return;
}
dt_dprintf("pid %d: rtld event %s type=%d state %d\n",
(int)dpr->dpr_pid, evname, rdm.type, rdm.u.state);
switch (rdm.type) {
case RD_DLACTIVITY:
if (rdm.u.state != RD_CONSISTENT)
break;
Pupdate_syms(dpr->dpr_proc);
if (dt_pid_create_probes_module(dtp, dpr) != 0)
dt_proc_notify(dtp, dtp->dt_procs, dpr,
dpr->dpr_errmsg);
Pcheckpoint_syms(dpr->dpr_proc);
break;
case RD_PREINIT:
Pupdate_syms(dpr->dpr_proc);
dt_proc_stop(dpr, DT_PROC_STOP_PREINIT);
break;
case RD_POSTINIT:
Pupdate_syms(dpr->dpr_proc);
dt_proc_stop(dpr, DT_PROC_STOP_POSTINIT);
break;
}
}
void
dt_proc_rdwatch(dt_proc_t *dpr, rd_event_e event, const char *evname)
{
rd_notify_t rdn;
rd_err_e err;
if ((err = rd_event_addr(dpr->dpr_rtld, event, &rdn)) != RD_OK) {
dt_dprintf("pid %d: failed to get event address for %s: %s\n",
(int)dpr->dpr_pid, evname, rd_errstr(err));
return;
}
if (rdn.type != RD_NOTIFY_BPT) {
dt_dprintf("pid %d: event %s has unexpected type %d\n",
(int)dpr->dpr_pid, evname, rdn.type);
return;
}
(void) dt_proc_bpcreate(dpr, rdn.u.bptaddr,
(dt_bkpt_f *)dt_proc_rdevent, (void *)evname);
}
typedef struct dt_proc_control_data {
dtrace_hdl_t *dpcd_hdl;
dt_proc_t *dpcd_proc;
} dt_proc_control_data_t;
static struct ps_prochandle *
dt_proc_error(dtrace_hdl_t *dtp, dt_proc_t *dpr, const char *format, ...)
{
va_list ap;
va_start(ap, format);
dt_set_errmsg(dtp, NULL, NULL, NULL, 0, format, ap);
va_end(ap);
if (dpr->dpr_proc != NULL)
Prelease(dpr->dpr_proc, 0);
dt_free(dtp, dpr);
(void) dt_set_errno(dtp, EDT_COMPILER);
return (NULL);
}
dt_proc_t *
dt_proc_lookup(dtrace_hdl_t *dtp, struct ps_prochandle *P, int remove)
{
dt_proc_hash_t *dph = dtp->dt_procs;
pid_t pid = Pstatus(P)->pr_pid;
dt_proc_t *dpr, **dpp = &dph->dph_hash[pid & (dph->dph_hashlen - 1)];
for (dpr = *dpp; dpr != NULL; dpr = dpr->dpr_hash) {
if (dpr->dpr_pid == pid)
break;
else
dpp = &dpr->dpr_hash;
}
assert(dpr != NULL);
assert(dpr->dpr_proc == P);
if (remove)
*dpp = dpr->dpr_hash;
return (dpr);
}
static void
dt_proc_destroy(dtrace_hdl_t *dtp, struct ps_prochandle *P)
{
dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
dt_proc_hash_t *dph = dtp->dt_procs;
dt_proc_notify_t *npr, **npp;
int rflag;
assert(dpr != NULL);
if (!(Pstatus(dpr->dpr_proc)->pr_flags & (PR_KLC | PR_RLC))) {
dt_dprintf("abandoning pid %d\n", (int)dpr->dpr_pid);
rflag = PRELEASE_HANG;
} else {
dt_dprintf("releasing pid %d\n", (int)dpr->dpr_pid);
rflag = 0;
}
if (dpr->dpr_tid) {
(void) pthread_mutex_lock(&dpr->dpr_lock);
dpr->dpr_quit = B_TRUE;
Pcreate_async_proc_activity(dpr->dpr_proc, RD_NONE);
if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
dt_proc_bpenable(dpr);
dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
(void) pthread_cond_broadcast(&dpr->dpr_cv);
}
while (!dpr->dpr_done)
(void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
(void) pthread_mutex_unlock(&dpr->dpr_lock);
}
(void) pthread_mutex_lock(&dph->dph_lock);
(void) dt_proc_lookup(dtp, P, B_TRUE);
npp = &dph->dph_notify;
while ((npr = *npp) != NULL) {
if (npr->dprn_dpr == dpr) {
*npp = npr->dprn_next;
dt_free(dtp, npr);
} else {
npp = &npr->dprn_next;
}
}
(void) pthread_mutex_unlock(&dph->dph_lock);
if (dpr->dpr_cacheable) {
assert(dph->dph_lrucnt != 0);
dph->dph_lrucnt--;
}
dt_list_delete(&dph->dph_lrulist, dpr);
Prelease(dpr->dpr_proc, rflag);
dt_free(dtp, dpr);
}
static int
dt_proc_create_thread(dtrace_hdl_t *dtp, dt_proc_t *dpr, uint_t stop)
{
dt_proc_control_data_t data;
sigset_t nset, oset;
pthread_attr_t a;
int err;
(void) pthread_mutex_lock(&dpr->dpr_lock);
dpr->dpr_stop |= stop;
(void) pthread_attr_init(&a);
(void) pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
(void) sigfillset(&nset);
(void) sigdelset(&nset, SIGABRT);
data.dpcd_hdl = dtp;
data.dpcd_proc = dpr;
(void) pthread_sigmask(SIG_SETMASK, &nset, &oset);
err = pthread_create(&dpr->dpr_tid, &a, dt_proc_control, &data);
(void) pthread_sigmask(SIG_SETMASK, &oset, NULL);
if (err == 0) {
while (!dpr->dpr_done && !(dpr->dpr_stop & DT_PROC_STOP_IDLE))
(void) pthread_cond_wait(&dpr->dpr_cv, &dpr->dpr_lock);
if (dpr->dpr_done) {
int stat = 0;
int pid = dpr->dpr_pid;
if (Pstate(dpr->dpr_proc) == PS_LOST) {
(void) dt_proc_error(dpr->dpr_hdl, dpr,
"failed to control pid %d: process exec'd "
"set-id or unobservable program\n", pid);
} else if (WIFSIGNALED(stat)) {
(void) dt_proc_error(dpr->dpr_hdl, dpr,
"failed to control pid %d: process died "
"from signal %d\n", pid, WTERMSIG(stat));
} else {
(void) dt_proc_error(dpr->dpr_hdl, dpr,
"failed to control pid %d: process exited "
"with status %d\n", pid, WEXITSTATUS(stat));
}
err = ESRCH;
}
} else {
(void) dt_proc_error(dpr->dpr_hdl, dpr,
"failed to create control thread for process-id %d: %s\n",
(int)dpr->dpr_pid, strerror(err));
}
(void) pthread_mutex_unlock(&dpr->dpr_lock);
(void) pthread_attr_destroy(&a);
return (err);
}
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);
(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);
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;
for (dpr = dph->dph_hash[h]; dpr != NULL; dpr = dpr->dpr_hash) {
if (dpr->dpr_pid == pid && !dpr->dpr_stale) {
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);
(void) pthread_mutex_init(&dpr->dpr_lock, NULL);
(void) pthread_cond_init(&dpr->dpr_cv, NULL);
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 (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);
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);
}
void
dt_proc_release(dtrace_hdl_t *dtp, struct ps_prochandle *P)
{
dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
dt_proc_hash_t *dph = dtp->dt_procs;
assert(dpr != NULL);
assert(dpr->dpr_refs != 0);
if (--dpr->dpr_refs == 0 &&
(!dpr->dpr_cacheable || dph->dph_lrucnt > dph->dph_lrulim))
dt_proc_destroy(dtp, P);
}
void
dt_proc_continue(dtrace_hdl_t *dtp, struct ps_prochandle *P)
{
dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
(void) pthread_mutex_lock(&dpr->dpr_lock);
if (dpr->dpr_stop & DT_PROC_STOP_IDLE) {
dpr->dpr_stop &= ~DT_PROC_STOP_IDLE;
(void) pthread_cond_broadcast(&dpr->dpr_cv);
}
(void) pthread_mutex_unlock(&dpr->dpr_lock);
}
void
dt_proc_lock(dtrace_hdl_t *dtp, struct ps_prochandle *P)
{
dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
int err = pthread_mutex_lock(&dpr->dpr_lock);
assert(err == 0);
}
void
dt_proc_unlock(dtrace_hdl_t *dtp, struct ps_prochandle *P)
{
dt_proc_t *dpr = dt_proc_lookup(dtp, P, B_FALSE);
int err = pthread_mutex_unlock(&dpr->dpr_lock);
assert(err == 0);
}
void
dt_proc_hash_create(dtrace_hdl_t *dtp)
{
if ((dtp->dt_procs = dt_zalloc(dtp, sizeof (dt_proc_hash_t) +
sizeof (dt_proc_t *) * _dtrace_pidbuckets - 1)) != NULL) {
(void) pthread_mutex_init(&dtp->dt_procs->dph_lock, NULL);
dtp->dt_procs->dph_hashlen = _dtrace_pidbuckets;
dtp->dt_procs->dph_lrulim = _dtrace_pidlrulim;
}
}
void
dt_proc_hash_destroy(dtrace_hdl_t *dtp)
{
dt_proc_hash_t *dph = dtp->dt_procs;
dt_proc_t *dpr;
while ((dpr = dt_list_next(&dph->dph_lrulist)) != NULL)
dt_proc_destroy(dtp, dpr->dpr_proc);
dtp->dt_procs = NULL;
dt_free(dtp, dph);
}
struct ps_prochandle *
dtrace_proc_create(dtrace_hdl_t *dtp, const char *file, char *const *argv)
{
dt_ident_t *idp = dt_idhash_lookup(dtp->dt_macros, "target");
struct ps_prochandle *P = dt_proc_create(dtp, file, argv);
if (P != NULL && idp != NULL && idp->di_id == 0)
idp->di_id = Pstatus(P)->pr_pid;
return (P);
}
struct ps_prochandle *
dtrace_proc_grab(dtrace_hdl_t *dtp, pid_t pid, int flags)
{
dt_ident_t *idp = dt_idhash_lookup(dtp->dt_macros, "target");
struct ps_prochandle *P = dt_proc_grab(dtp, pid, flags, 0);
if (P != NULL && idp != NULL && idp->di_id == 0)
idp->di_id = pid;
return (P);
}
struct ps_prochandle *
dtrace_proc_waitfor(dtrace_hdl_t *dtp, char const *pname)
{
dt_ident_t *idp = dt_idhash_lookup(dtp->dt_macros, "target");
struct ps_prochandle *P = NULL;
int err;
dtrace_procdesc_t pdesc;
assert(dtp);
assert(pname);
assert(*pname != '\0');
size_t max_len = sizeof(pdesc.p_name);
if (strlcpy(pdesc.p_name, pname, max_len) >= max_len) {
fprintf(stderr, "Error, the process name (%s) exceeded the %lu characters limit\n",
pname, sizeof(pdesc.p_name) - 1);
return NULL;
}
fprintf(stdout, "Waiting for %s, hit Ctrl-C to stop waiting...\n", pdesc.p_name);
if ((err = dt_ioctl(dtp, DTRACEIOC_PROCWAITFOR, &pdesc)) != 0) {
fprintf(stderr, "Error, dt_ioctl() failed (%s)\n", strerror(errno));
return NULL;
}
assert(pdesc.p_pid != -1);
P = dt_proc_grab(dtp, pdesc.p_pid, 0, 0);
if ((err = pid_resume(pdesc.p_pid)) != 0) {
dt_dprintf("Unable to resume the process (pid=%d), the process is still suspended\n",
pdesc.p_pid);
}
if (P != NULL && idp != NULL && idp->di_id == 0)
idp->di_id = pdesc.p_pid;
return P;
}
void
dtrace_proc_release(dtrace_hdl_t *dtp, struct ps_prochandle *P)
{
dt_proc_release(dtp, P);
}
void
dtrace_proc_continue(dtrace_hdl_t *dtp, struct ps_prochandle *P)
{
dt_proc_continue(dtp, P);
}