static void
systrace_init(struct sysent *actual, systrace_sysent_t **interposed)
{
systrace_sysent_t *sysent = *interposed;
int i;
if (sysent == NULL) {
*interposed = sysent = kmem_zalloc(sizeof (systrace_sysent_t) *
NSYSCALL, KM_SLEEP);
}
for (i = 0; i < NSYSCALL; i++) {
struct sysent *a = &actual[i];
systrace_sysent_t *s = &sysent[i];
if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a))
continue;
if (a->sy_callc == dtrace_systrace_syscall)
continue;
#ifdef _SYSCALL32_IMPL
if (a->sy_callc == dtrace_systrace_syscall32)
continue;
#endif
s->stsy_underlying = a->sy_callc;
}
}
/*
* "Decode" rv for use in the call to dtrace_probe()
*/
if (rval == ERESTART) {
munged_rv0 = -1LL; /* System call will be reissued in user mode. Make DTrace report a -1 return. */
munged_rv1 = -1LL;
} else if (rval != EJUSTRETURN) {
if (rval) {
munged_rv0 = -1LL; /* Mimic what libc will do. */
munged_rv1 = -1LL;
} else {
switch (sy->stsy_return_type) {
case _SYSCALL_RET_INT_T:
munged_rv0 = rv[0];
munged_rv1 = rv[1];
break;
case _SYSCALL_RET_UINT_T:
munged_rv0 = ((u_int)rv[0]);
munged_rv1 = ((u_int)rv[1]);
break;
case _SYSCALL_RET_OFF_T:
case _SYSCALL_RET_UINT64_T:
munged_rv0 = *(u_int64_t *)rv;
munged_rv1 = 0LL;
break;
case _SYSCALL_RET_ADDR_T:
case _SYSCALL_RET_SIZE_T:
case _SYSCALL_RET_SSIZE_T:
munged_rv0 = *(user_addr_t *)rv;
munged_rv1 = 0LL;
break;
case _SYSCALL_RET_NONE:
munged_rv0 = 0LL;
munged_rv1 = 0LL;
break;
default:
munged_rv0 = 0LL;
munged_rv1 = 0LL;
break;
}
}
} else {
munged_rv0 = 0LL;
munged_rv1 = 0LL;
}
(*systrace_probe)(id, munged_rv0, munged_rv0, munged_rv1, (uint64_t)rval, 0);
}
}
#endif /* __APPLE__ */
#define SYSTRACE_SHIFT 16
#define SYSTRACE_ISENTRY(x) ((int)(x) >> SYSTRACE_SHIFT)
#define SYSTRACE_SYSNUM(x) ((int)(x) & ((1 << SYSTRACE_SHIFT) - 1))
#define SYSTRACE_ENTRY(id) ((1 << SYSTRACE_SHIFT) | (id))
#define SYSTRACE_RETURN(id) (id)
#if ((1 << SYSTRACE_SHIFT) <= NSYSCALL)
#error 1 << SYSTRACE_SHIFT must exceed number of system calls
#endif
static dev_info_t *systrace_devi;
static dtrace_provider_id_t systrace_id;
#if !defined (__APPLE__)
static void
systrace_init(struct sysent *actual, systrace_sysent_t **interposed)
{
systrace_sysent_t *sysent = *interposed;
int i;
if (sysent == NULL) {
*interposed = sysent = kmem_zalloc(sizeof (systrace_sysent_t) *
NSYSCALL, KM_SLEEP);
}
for (i = 0; i < NSYSCALL; i++) {
struct sysent *a = &actual[i];
systrace_sysent_t *s = &sysent[i];
if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a))
continue;
if (a->sy_callc == dtrace_systrace_syscall)
continue;
#ifdef _SYSCALL32_IMPL
if (a->sy_callc == dtrace_systrace_syscall32)
continue;
#endif
s->stsy_underlying = a->sy_callc;
}
}
#else
#define systrace_init _systrace_init /* Avoid name clash with Darwin automagic conf symbol */
static void
systrace_init(struct sysent *actual, systrace_sysent_t **interposed)
{
systrace_sysent_t *ssysent = *interposed; /* Avoid sysent shadow warning
from bsd/sys/sysent.h */
int i;
if (ssysent == NULL) {
*interposed = ssysent = kmem_zalloc(sizeof (systrace_sysent_t) *
NSYSCALL, KM_SLEEP);
}
for (i = 0; i < NSYSCALL; i++) {
struct sysent *a = &actual[i];
systrace_sysent_t *s = &ssysent[i];
if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a))
continue;
if (a->sy_callc == dtrace_systrace_syscall)
continue;
#ifdef _SYSCALL32_IMPL
if (a->sy_callc == dtrace_systrace_syscall32)
continue;
#endif
s->stsy_underlying = a->sy_callc;
s->stsy_return_type = a->sy_return_type;
}
lck_mtx_init(&dtrace_systrace_lock, dtrace_lck_grp, dtrace_lck_attr);
}
/*
* Load system call module.
* Returns with pointer to held read lock for module.
*/
static krwlock_t *
lock_syscall(struct sysent *table, uint_t code)
{
krwlock_t *module_lock;
struct modctl *modp;
int id;
struct sysent *callp;
module_lock = table[code].sy_lock;
callp = &table[code];
/*
* Optimization to only call modload if we don't have a loaded
* syscall.
*/
rw_enter(module_lock, RW_READER);
if (LOADED_SYSCALL(callp))
return (module_lock);
rw_exit(module_lock);
for (;;) {
if ((id = modload("sys", syscallnames[code])) == -1)
break;
/*
* If we loaded successfully at least once, the modctl
* will still be valid, so we try to grab it by filename.
* If this call fails, it's because the mod_filename
* was changed after the call to modload() (mod_hold_by_name()
* is the likely culprit). We can safely just take
* another lap if this is the case; the modload() will
* change the mod_filename back to one by which we can
* find the modctl.
*/
modp = mod_find_by_filename("sys", syscallnames[code]);
if (modp == NULL)
continue;
mutex_enter(&mod_lock);
if (!modp->mod_installed) {
mutex_exit(&mod_lock);
continue;
}
break;
}
rw_enter(module_lock, RW_READER);
if (id != -1)
mutex_exit(&mod_lock);
return (module_lock);
}
static void
machtrace_init(const mach_trap_t *actual, machtrace_sysent_t **interposed)
{
machtrace_sysent_t *msysent = *interposed;
int i;
if (msysent == NULL) {
*interposed = msysent = kmem_zalloc(sizeof (machtrace_sysent_t) *
NSYSCALL, KM_SLEEP);
}
for (i = 0; i < NSYSCALL; i++) {
const mach_trap_t *a = &actual[i];
machtrace_sysent_t *s = &msysent[i];
if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a))
continue;
if (a->mach_trap_function == (mach_call_t)(dtrace_machtrace_syscall))
continue;
s->stsy_underlying = a->mach_trap_function;
}
}
