X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/b0d623f7f2ae71ed96e60569f61f9a9a27016e80..a39ff7e25e19b3a8c3020042a3872ca9ec9659f1:/bsd/dev/dtrace/dtrace_subr.c diff --git a/bsd/dev/dtrace/dtrace_subr.c b/bsd/dev/dtrace/dtrace_subr.c index 3d8e65309..3bc601af8 100644 --- a/bsd/dev/dtrace/dtrace_subr.c +++ b/bsd/dev/dtrace/dtrace_subr.c @@ -34,13 +34,24 @@ #include #include #include +#include +#include #include +#include +#include -#if defined(__APPLE__) -/* Solaris proc_t is the struct. Darwin's proc_t is a pointer to it. */ -#define proc_t struct proc /* Steer clear of the Darwin typedef for proc_t */ +#if CONFIG_CSR +#include +#include #endif +/* + * APPLE NOTE: Solaris proc_t is the struct. + * Darwin's proc_t is a pointer to it. + */ +#define proc_t struct proc /* Steer clear of the Darwin typedef for proc_t */ + + /* Copied from an arch specific dtrace_subr.c. */ int (*dtrace_fasttrap_probe_ptr)(struct regs *); @@ -49,11 +60,9 @@ int (*dtrace_fasttrap_probe_ptr)(struct regs *); * They're assigned in dtrace.c but Darwin never calls them. */ void (*dtrace_cpu_init)(processorid_t); -void (*dtrace_modload)(struct modctl *); -void (*dtrace_modunload)(struct modctl *); -#if defined(__APPLE__) +int (*dtrace_modload)(struct kmod_info *, uint32_t); +int (*dtrace_modunload)(struct kmod_info *); void (*dtrace_helpers_cleanup)(proc_t *); -#endif void (*dtrace_helpers_fork)(proc_t *, proc_t *); void (*dtrace_cpustart_init)(void); void (*dtrace_cpustart_fini)(void); @@ -80,16 +89,150 @@ void (*dtrace_fasttrap_exit_ptr)(proc_t *); void dtrace_fasttrap_fork(proc_t *p, proc_t *cp) { -#if !defined(__APPLE__) - ASSERT(p->p_proc_flag & P_PR_LOCK); - ASSERT(p->p_dtrace_count > 0); -#endif /* __APPLE__ */ - if (dtrace_fasttrap_fork_ptr) { (*dtrace_fasttrap_fork_ptr)(p, cp); } } + +/* + * DTrace wait for process execution + * + * This feature is using a list of entries, each entry containing a pointer + * on a process description. The description is provided by a client, and it + * contains the command we want to wait for along with a reserved space for + * the caught process id. + * + * Once an awaited process has been spawned, it will be suspended before + * notifying the client. Once the client has been back to userland, it's its + * duty to resume the task. + */ + +lck_mtx_t dtrace_procwaitfor_lock; + +typedef struct dtrace_proc_awaited_entry { + struct dtrace_procdesc *pdesc; + LIST_ENTRY(dtrace_proc_awaited_entry) entries; +} dtrace_proc_awaited_entry_t; + +LIST_HEAD(listhead, dtrace_proc_awaited_entry) dtrace_proc_awaited_head + = LIST_HEAD_INITIALIZER(dtrace_proc_awaited_head); + +void (*dtrace_proc_waitfor_exec_ptr)(proc_t*) = NULL; + +static int +dtrace_proc_get_execpath(proc_t *p, char *buffer, int *maxlen) +{ + int err = 0, vid = 0; + vnode_t tvp = NULLVP, nvp = NULLVP; + + ASSERT(p); + ASSERT(buffer); + ASSERT(maxlen); + + if ((tvp = p->p_textvp) == NULLVP) + return ESRCH; + + vid = vnode_vid(tvp); + if ((err = vnode_getwithvid(tvp, vid)) != 0) + return err; + + if ((err = vn_getpath_fsenter(tvp, buffer, maxlen)) != 0) + return err; + vnode_put(tvp); + + if ((err = vnode_lookup(buffer, 0, &nvp, vfs_context_current())) != 0) + return err; + if (nvp != NULLVP) + vnode_put(nvp); + + return 0; +} + + +static void +dtrace_proc_exec_notification(proc_t *p) { + dtrace_proc_awaited_entry_t *entry, *tmp; + static char execpath[MAXPATHLEN]; + + ASSERT(p); + ASSERT(p->p_pid != -1); + ASSERT(current_task() != p->task); + + lck_mtx_lock(&dtrace_procwaitfor_lock); + + LIST_FOREACH_SAFE(entry, &dtrace_proc_awaited_head, entries, tmp) { + /* By default consider we're using p_comm. */ + char *pname = p->p_comm; + + /* Already matched with another process. */ + if ((entry->pdesc->p_pid != -1)) + continue; + + /* p_comm is too short, use the execpath. */ + if (entry->pdesc->p_name_length >= MAXCOMLEN) { + /* + * Retrieve the executable path. After the call, length contains + * the length of the string + 1. + */ + int length = sizeof(execpath); + if (dtrace_proc_get_execpath(p, execpath, &length) != 0) + continue; + /* Move the cursor to the position after the last / */ + pname = &execpath[length - 1]; + while (pname != execpath && *pname != '/') + pname--; + pname = (*pname == '/') ? pname + 1 : pname; + } + + if (!strcmp(entry->pdesc->p_name, pname)) { + entry->pdesc->p_pid = p->p_pid; + task_pidsuspend(p->task); + wakeup(entry); + } + } + + lck_mtx_unlock(&dtrace_procwaitfor_lock); +} + +int +dtrace_proc_waitfor(dtrace_procdesc_t* pdesc) { + dtrace_proc_awaited_entry_t entry; + int res; + + ASSERT(pdesc); + ASSERT(pdesc->p_name); + + /* + * Never trust user input, compute the length of the process name and ensure the + * string is null terminated. + */ + pdesc->p_name_length = strnlen(pdesc->p_name, sizeof(pdesc->p_name)); + if (pdesc->p_name_length >= (int) sizeof(pdesc->p_name)) + return -1; + + lck_mtx_lock(&dtrace_procwaitfor_lock); + + /* Initialize and insert the entry, then install the hook. */ + pdesc->p_pid = -1; + entry.pdesc = pdesc; + LIST_INSERT_HEAD(&dtrace_proc_awaited_head, &entry, entries); + dtrace_proc_waitfor_exec_ptr = &dtrace_proc_exec_notification; + + /* Sleep until the process has been executed */ + res = msleep(&entry, &dtrace_procwaitfor_lock, PCATCH, "dtrace_proc_waitfor", NULL); + + /* Remove the entry and the hook if it is not needed anymore. */ + LIST_REMOVE(&entry, entries); + if (LIST_EMPTY(&dtrace_proc_awaited_head)) + dtrace_proc_waitfor_exec_ptr = NULL; + + lck_mtx_unlock(&dtrace_procwaitfor_lock); + + return res; +} + + typedef struct dtrace_invop_hdlr { int (*dtih_func)(uintptr_t, uintptr_t *, uintptr_t); struct dtrace_invop_hdlr *dtih_next; @@ -152,3 +295,113 @@ dtrace_invop_remove(int (*func)(uintptr_t, uintptr_t *, uintptr_t)) kmem_free(hdlr, sizeof (dtrace_invop_hdlr_t)); } +static minor_t next_minor = 0; +static dtrace_state_t* dtrace_clients[DTRACE_NCLIENTS] = {NULL}; + + +minor_t +dtrace_state_reserve(void) +{ + for (int i = 0; i < DTRACE_NCLIENTS; i++) { + minor_t minor = atomic_add_32(&next_minor, 1) % DTRACE_NCLIENTS; + if (dtrace_clients[minor] == NULL) + return minor; + } + return 0; +} + +dtrace_state_t* +dtrace_state_get(minor_t minor) +{ + ASSERT(minor < DTRACE_NCLIENTS); + return dtrace_clients[minor]; +} + +dtrace_state_t* +dtrace_state_allocate(minor_t minor) +{ + dtrace_state_t *state = _MALLOC(sizeof(dtrace_state_t), M_TEMP, M_ZERO | M_WAITOK); + if (dtrace_casptr(&dtrace_clients[minor], NULL, state) != NULL) { + // We have been raced by another client for this number, abort + _FREE(state, M_TEMP); + return NULL; + } + return state; +} + +void +dtrace_state_free(minor_t minor) +{ + dtrace_state_t *state = dtrace_clients[minor]; + dtrace_clients[minor] = NULL; + _FREE(state, M_TEMP); +} + + + +void +dtrace_restriction_policy_load(void) +{ +} + +/* + * Check if DTrace has been restricted by the current security policy. + */ +boolean_t +dtrace_is_restricted(void) +{ +#if CONFIG_CSR + if (csr_check(CSR_ALLOW_UNRESTRICTED_DTRACE) != 0) + return TRUE; +#endif + + return FALSE; +} + +boolean_t +dtrace_are_restrictions_relaxed(void) +{ +#if CONFIG_CSR + if (csr_check(CSR_ALLOW_APPLE_INTERNAL) == 0) + return TRUE; +#endif + + return FALSE; +} + +boolean_t +dtrace_fbt_probes_restricted(void) +{ + +#if CONFIG_CSR + if (dtrace_is_restricted() && !dtrace_are_restrictions_relaxed()) + return TRUE; +#endif + + return FALSE; +} + +boolean_t +dtrace_sdt_probes_restricted(void) +{ + + return FALSE; +} + +/* + * Check if the process can be attached. + */ +boolean_t +dtrace_can_attach_to_proc(proc_t *proc) +{ +#pragma unused(proc) + ASSERT(proc != NULL); + +#if CONFIG_CSR + if (cs_restricted(proc)) + return FALSE; +#endif + + return TRUE; +} +