void
ktrsyscall(struct lwp *lp, int code, int narg, register_t args[])
{
struct ktr_header *kth;
struct ktr_syscall *ktp;
int len;
register_t *argp;
int i;
len = offsetof(struct ktr_syscall, ktr_args) +
(narg * sizeof(register_t));
/*
* Setting the active bit prevents a ktrace recursion from the
* ktracing op itself.
*/
lp->lwp_traceflag |= KTRFAC_ACTIVE;
kth = ktrgetheader(KTR_SYSCALL);
ktp = kmalloc(len, M_KTRACE, M_WAITOK);
ktp->ktr_code = code;
ktp->ktr_narg = narg;
argp = &ktp->ktr_args[0];
for (i = 0; i < narg; i++)
*argp++ = args[i];
kth->ktr_buf = (caddr_t)ktp;
kth->ktr_len = len;
ktrwrite(lp, kth, NULL);
kfree(ktp, M_KTRACE);
kfree(kth, M_KTRACE);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrsyscall(struct lwp *lp, int code, int narg, register_t args[])
{
struct ktr_header kth;
struct ktr_syscall ktp_cache;
struct ktr_syscall *ktp;
register_t *argp;
int i;
/*
* Setting the active bit prevents a ktrace recursion from the
* ktracing op itself.
*/
lp->lwp_traceflag |= KTRFAC_ACTIVE;
ktrgetheader(&kth, KTR_SYSCALL);
ktp = ktrgetsyscall(&kth, &ktp_cache, narg);
ktp->ktr_code = code;
ktp->ktr_narg = narg;
argp = &ktp->ktr_args[0];
for (i = 0; i < narg; i++)
*argp++ = args[i];
ktrwrite(lp, &kth, NULL);
ktrputsyscall(&ktp_cache, ktp);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktremul(struct proc *p, char *emul)
{
struct ktr_header kth;
p->p_traceflag |= KTRFAC_ACTIVE;
ktrinitheader(&kth, p, KTR_EMUL);
kth.ktr_len = strlen(emul);
kth.ktr_buf = emul;
ktrwrite(p, &kth);
p->p_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrnamei(struct proc *p, char *path)
{
struct ktr_header kth;
p->p_traceflag |= KTRFAC_ACTIVE;
ktrinitheader(&kth, p, KTR_NAMEI);
kth.ktr_len = strlen(path);
kth.ktr_buf = path;
ktrwrite(p, &kth);
p->p_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrnamei(struct lwp *lp, char *path)
{
struct ktr_header kth;
lp->lwp_traceflag |= KTRFAC_ACTIVE;
ktrgetheader(&kth, KTR_NAMEI);
kth.ktr_len = (int)strlen(path);
kth.ktr_buf = path;
ktrwrite(lp, &kth, NULL);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrnamei(struct lwp *lp, char *path)
{
struct ktr_header *kth;
lp->lwp_traceflag |= KTRFAC_ACTIVE;
kth = ktrgetheader(KTR_NAMEI);
kth->ktr_len = strlen(path);
kth->ktr_buf = path;
ktrwrite(lp, kth, NULL);
kfree(kth, M_KTRACE);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrcsw(struct proc *p, int out, int user)
{
struct ktr_header kth;
struct ktr_csw kc;
p->p_traceflag |= KTRFAC_ACTIVE;
ktrinitheader(&kth, p, KTR_CSW);
kc.out = out;
kc.user = user;
kth.ktr_buf = (caddr_t)&kc;
kth.ktr_len = sizeof(struct ktr_csw);
ktrwrite(p, &kth);
p->p_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrcsw(struct lwp *lp, int out, int user)
{
struct ktr_header kth;
struct ktr_csw kc;
lp->lwp_traceflag |= KTRFAC_ACTIVE;
ktrgetheader(&kth, KTR_CSW);
kc.out = out;
kc.user = user;
kth.ktr_buf = (caddr_t)&kc;
kth.ktr_len = (int)sizeof(struct ktr_csw);
ktrwrite(lp, &kth, NULL);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrcsw(struct lwp *lp, int out, int user)
{
struct ktr_header *kth;
struct ktr_csw kc;
lp->lwp_traceflag |= KTRFAC_ACTIVE;
kth = ktrgetheader(KTR_CSW);
kc.out = out;
kc.user = user;
kth->ktr_buf = (caddr_t)&kc;
kth->ktr_len = sizeof (struct ktr_csw);
ktrwrite(lp, kth, NULL);
kfree(kth, M_KTRACE);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrsysret(struct proc *p, register_t code, int error, register_t retval)
{
struct ktr_header kth;
struct ktr_sysret ktp;
p->p_traceflag |= KTRFAC_ACTIVE;
ktrinitheader(&kth, p, KTR_SYSRET);
ktp.ktr_code = code;
ktp.ktr_error = error;
ktp.ktr_retval = retval; /* what about val2 ? */
kth.ktr_buf = (caddr_t)&ktp;
kth.ktr_len = sizeof(struct ktr_sysret);
ktrwrite(p, &kth);
p->p_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrpsig(struct lwp *lp, int sig, sig_t action, sigset_t *mask, int code)
{
struct ktr_header kth;
struct ktr_psig kp;
lp->lwp_traceflag |= KTRFAC_ACTIVE;
ktrgetheader(&kth, KTR_PSIG);
kp.signo = (char)sig;
kp.action = action;
kp.mask = *mask;
kp.code = code;
kth.ktr_buf = (caddr_t)&kp;
kth.ktr_len = (int)sizeof(struct ktr_psig);
ktrwrite(lp, &kth, NULL);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrpsig(struct proc *p, int sig, sig_t action, int mask, int code,
siginfo_t *si)
{
struct ktr_header kth;
struct ktr_psig kp;
p->p_traceflag |= KTRFAC_ACTIVE;
ktrinitheader(&kth, p, KTR_PSIG);
kp.signo = (char)sig;
kp.action = action;
kp.mask = mask;
kp.code = code;
kp.si = *si;
kth.ktr_buf = (caddr_t)&kp;
kth.ktr_len = sizeof(struct ktr_psig);
ktrwrite(p, &kth);
p->p_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrgenio(struct lwp *lp, int fd, enum uio_rw rw, struct uio *uio, int error)
{
struct ktr_header kth;
struct ktr_genio ktg;
if (error)
return;
lp->lwp_traceflag |= KTRFAC_ACTIVE;
ktrgetheader(&kth, KTR_GENIO);
ktg.ktr_fd = fd;
ktg.ktr_rw = rw;
kth.ktr_buf = (caddr_t)&ktg;
kth.ktr_len = (int)sizeof(struct ktr_genio);
uio->uio_offset = 0;
uio->uio_rw = UIO_WRITE;
ktrwrite(lp, &kth, uio);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrsysret(struct lwp *lp, int code, int error, register_t retval)
{
struct ktr_header kth;
struct ktr_sysret ktp;
lp->lwp_traceflag |= KTRFAC_ACTIVE;
ktrgetheader(&kth, KTR_SYSRET);
ktp.ktr_code = code;
ktp.ktr_error = error;
if (error == 0)
ktp.ktr_retval = retval; /* what about val2 ? */
else
ktp.ktr_retval = 0;
kth.ktr_buf = (caddr_t)&ktp;
kth.ktr_len = (int)sizeof(struct ktr_sysret);
ktrwrite(lp, &kth, NULL);
lp->lwp_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrsyscall(struct proc *p, register_t code, size_t argsize, register_t args[])
{
struct ktr_header kth;
struct ktr_syscall *ktp;
size_t len = sizeof(struct ktr_syscall) + argsize;
register_t *argp;
u_int nargs = 0;
int i;
if (code == SYS___sysctl && (p->p_emul->e_flags & EMUL_NATIVE)) {
/*
* The native sysctl encoding stores the mib[]
* array because it is interesting.
*/
if (args[1] > 0)
nargs = min(args[1], CTL_MAXNAME);
len += nargs * sizeof(int);
}
p->p_traceflag |= KTRFAC_ACTIVE;
ktrinitheader(&kth, p, KTR_SYSCALL);
ktp = malloc(len, M_TEMP, M_WAITOK);
ktp->ktr_code = code;
ktp->ktr_argsize = argsize;
argp = (register_t *)((char *)ktp + sizeof(struct ktr_syscall));
for (i = 0; i < (argsize / sizeof *argp); i++)
*argp++ = args[i];
if (code == SYS___sysctl && (p->p_emul->e_flags & EMUL_NATIVE) &&
nargs &&
copyin((void *)args[0], argp, nargs * sizeof(int)))
bzero(argp, nargs * sizeof(int));
kth.ktr_buf = (caddr_t)ktp;
kth.ktr_len = len;
ktrwrite(p, &kth);
free(ktp, M_TEMP);
p->p_traceflag &= ~KTRFAC_ACTIVE;
}
void
ktrgenio(struct proc *p, int fd, enum uio_rw rw, struct iovec *iov, int len,
int error)
{
struct ktr_header kth;
struct ktr_genio *ktp;
caddr_t cp;
int resid = len, count;
int buflen;
if (error)
return;
p->p_traceflag |= KTRFAC_ACTIVE;
buflen = min(PAGE_SIZE, len + sizeof(struct ktr_genio));
ktrinitheader(&kth, p, KTR_GENIO);
ktp = malloc(buflen, M_TEMP, M_WAITOK);
ktp->ktr_fd = fd;
ktp->ktr_rw = rw;
kth.ktr_buf = (caddr_t)ktp;
cp = (caddr_t)((char *)ktp + sizeof (struct ktr_genio));
buflen -= sizeof(struct ktr_genio);
while (resid > 0) {
/*
* Don't allow this process to hog the cpu when doing
* huge I/O.
*/
#ifdef __HAVE_CPUINFO
if (curcpu()->ci_schedstate.spc_schedflags & SPCF_SHOULDYIELD)
#else
if (p->p_schedflags & PSCHED_SHOULDYIELD)
#endif
preempt(NULL);
count = min(iov->iov_len, buflen);
if (count > resid)
count = resid;
if (copyin(iov->iov_base, cp, count))
break;
kth.ktr_len = count + sizeof(struct ktr_genio);
if (ktrwrite(p, &kth) != 0)
break;
iov->iov_len -= count;
iov->iov_base = (caddr_t)iov->iov_base + count;
if (iov->iov_len == 0)
iov++;
resid -= count;
}
free(ktp, M_TEMP);
p->p_traceflag &= ~KTRFAC_ACTIVE;
}
