D30040.diff
No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

D30040.diff
View Options

	diff --git a/sys/compat/linux/linux_futex.c b/sys/compat/linux/linux_futex.c
	--- a/sys/compat/linux/linux_futex.c
	+++ b/sys/compat/linux/linux_futex.c
	@@ -91,58 +91,32 @@
	/**
	* DTrace probes in this module.
	*/
	-LIN_SDT_PROBE_DEFINE2(futex, futex_put, entry, "struct futex *",
	- "struct waiting_proc *");
	LIN_SDT_PROBE_DEFINE3(futex, futex_put, destroy, "uint32_t *", "uint32_t",
	"int");
	LIN_SDT_PROBE_DEFINE3(futex, futex_put, unlock, "uint32_t *", "uint32_t",
	"int");
	-LIN_SDT_PROBE_DEFINE0(futex, futex_put, return);
	-LIN_SDT_PROBE_DEFINE3(futex, futex_get0, entry, "uint32_t ", "struct futex *",
	- "uint32_t");
	LIN_SDT_PROBE_DEFINE1(futex, futex_get0, umtx_key_get_error, "int");
	LIN_SDT_PROBE_DEFINE3(futex, futex_get0, shared, "uint32_t *", "uint32_t",
	"int");
	LIN_SDT_PROBE_DEFINE1(futex, futex_get0, null, "uint32_t *");
	LIN_SDT_PROBE_DEFINE3(futex, futex_get0, new, "uint32_t *", "uint32_t", "int");
	-LIN_SDT_PROBE_DEFINE1(futex, futex_get0, return, "int");
	-LIN_SDT_PROBE_DEFINE3(futex, futex_get, entry, "uint32_t *",
	- "struct waiting_proc ", "struct futex ");
	LIN_SDT_PROBE_DEFINE0(futex, futex_get, error);
	-LIN_SDT_PROBE_DEFINE1(futex, futex_get, return, "int");
	-LIN_SDT_PROBE_DEFINE3(futex, futex_sleep, entry, "struct futex *",
	- "struct waiting_proc *", "struct timespec ");
	LIN_SDT_PROBE_DEFINE5(futex, futex_sleep, requeue_error, "int", "uint32_t *",
	"struct waiting_proc ", "uint32_t ", "uint32_t");
	LIN_SDT_PROBE_DEFINE3(futex, futex_sleep, sleep_error, "int", "uint32_t *",
	"struct waiting_proc *");
	-LIN_SDT_PROBE_DEFINE1(futex, futex_sleep, return, "int");
	-LIN_SDT_PROBE_DEFINE3(futex, futex_wake, entry, "struct futex *", "int",
	- "uint32_t");
	LIN_SDT_PROBE_DEFINE3(futex, futex_wake, iterate, "uint32_t",
	"struct waiting_proc *", "uint32_t");
	LIN_SDT_PROBE_DEFINE1(futex, futex_wake, wakeup, "struct waiting_proc *");
	-LIN_SDT_PROBE_DEFINE1(futex, futex_wake, return, "int");
	-LIN_SDT_PROBE_DEFINE4(futex, futex_requeue, entry, "struct futex *", "int",
	- "struct futex *", "int");
	LIN_SDT_PROBE_DEFINE1(futex, futex_requeue, wakeup, "struct waiting_proc *");
	LIN_SDT_PROBE_DEFINE3(futex, futex_requeue, requeue, "uint32_t *",
	"struct waiting_proc *", "uint32_t");
	-LIN_SDT_PROBE_DEFINE1(futex, futex_requeue, return, "int");
	-LIN_SDT_PROBE_DEFINE4(futex, futex_wait, entry, "struct futex *",
	- "struct waiting_proc *", "struct timespec ", "uint32_t");
	LIN_SDT_PROBE_DEFINE1(futex, futex_wait, sleep_error, "int");
	-LIN_SDT_PROBE_DEFINE1(futex, futex_wait, return, "int");
	-LIN_SDT_PROBE_DEFINE3(futex, futex_atomic_op, entry, "struct thread *",
	- "int", "uint32_t");
	LIN_SDT_PROBE_DEFINE4(futex, futex_atomic_op, decoded_op, "int", "int", "int",
	"int");
	LIN_SDT_PROBE_DEFINE0(futex, futex_atomic_op, missing_access_check);
	LIN_SDT_PROBE_DEFINE1(futex, futex_atomic_op, unimplemented_op, "int");
	LIN_SDT_PROBE_DEFINE1(futex, futex_atomic_op, unimplemented_cmp, "int");
	-LIN_SDT_PROBE_DEFINE1(futex, futex_atomic_op, return, "int");
	-LIN_SDT_PROBE_DEFINE2(futex, linux_sys_futex, entry, "struct thread *",
	- "struct linux_sys_futex_args *");
	LIN_SDT_PROBE_DEFINE0(futex, linux_sys_futex, unimplemented_clockswitch);
	LIN_SDT_PROBE_DEFINE1(futex, linux_sys_futex, copyin_error, "int");
	LIN_SDT_PROBE_DEFINE0(futex, linux_sys_futex, invalid_cmp_requeue_use);
	@@ -166,28 +140,11 @@
	LIN_SDT_PROBE_DEFINE0(futex, linux_sys_futex, unimplemented_wait_requeue_pi);
	LIN_SDT_PROBE_DEFINE0(futex, linux_sys_futex, unimplemented_cmp_requeue_pi);
	LIN_SDT_PROBE_DEFINE1(futex, linux_sys_futex, unknown_operation, "int");
	-LIN_SDT_PROBE_DEFINE1(futex, linux_sys_futex, return, "int");
	-LIN_SDT_PROBE_DEFINE2(futex, linux_set_robust_list, entry, "struct thread *",
	- "struct linux_set_robust_list_args *");
	LIN_SDT_PROBE_DEFINE0(futex, linux_set_robust_list, size_error);
	-LIN_SDT_PROBE_DEFINE1(futex, linux_set_robust_list, return, "int");
	-LIN_SDT_PROBE_DEFINE2(futex, linux_get_robust_list, entry, "struct thread *",
	- "struct linux_get_robust_list_args *");
	LIN_SDT_PROBE_DEFINE1(futex, linux_get_robust_list, copyout_error, "int");
	-LIN_SDT_PROBE_DEFINE1(futex, linux_get_robust_list, return, "int");
	-LIN_SDT_PROBE_DEFINE3(futex, handle_futex_death, entry,
	- "struct linux_emuldata ", "uint32_t ", "unsigned int");
	LIN_SDT_PROBE_DEFINE1(futex, handle_futex_death, copyin_error, "int");
	-LIN_SDT_PROBE_DEFINE1(futex, handle_futex_death, return, "int");
	-LIN_SDT_PROBE_DEFINE3(futex, fetch_robust_entry, entry,
	- "struct linux_robust_list ", "struct linux_robust_list ",
	- "unsigned int *");
	LIN_SDT_PROBE_DEFINE1(futex, fetch_robust_entry, copyin_error, "int");
	-LIN_SDT_PROBE_DEFINE1(futex, fetch_robust_entry, return, "int");
	-LIN_SDT_PROBE_DEFINE2(futex, release_futexes, entry, "struct thread *",
	- "struct linux_emuldata *");
	LIN_SDT_PROBE_DEFINE1(futex, release_futexes, copyin_error, "int");
	-LIN_SDT_PROBE_DEFINE0(futex, release_futexes, return);

	struct futex;

	@@ -298,7 +255,6 @@
	static void
	futex_put(struct futex f, struct waiting_proc wp)
	{
	- LIN_SDT_PROBE2(futex, futex_put, entry, f, wp);

	if (wp != NULL) {
	if ((wp->wp_flags & FUTEX_WP_REMOVED) == 0)
	@@ -320,8 +276,6 @@
	umtx_key_release(&f->f_key);
	FUTEX_DESTROY(f);
	free(f, M_FUTEX);
	-
	- LIN_SDT_PROBE0(futex, futex_put, return);
	return;
	}

	@@ -332,8 +286,6 @@
	if (FUTEX_LOCKED(f))
	futex_unlock(f);
	FUTEXES_UNLOCK;
	-
	- LIN_SDT_PROBE0(futex, futex_put, return);
	}

	static int
	@@ -343,15 +295,12 @@
	struct umtx_key key;
	int error;

	- LIN_SDT_PROBE3(futex, futex_get0, entry, uaddr, newf, flags);
	-
	*newf = tmpf = NULL;

	error = umtx_key_get(uaddr, TYPE_FUTEX, (flags & FUTEX_SHARED) ?
	AUTO_SHARE : THREAD_SHARE, &key);
	if (error) {
	LIN_SDT_PROBE1(futex, futex_get0, umtx_key_get_error, error);
	- LIN_SDT_PROBE1(futex, futex_get0, return, error);
	return (error);
	}
	retry:
	@@ -368,8 +317,6 @@
	FUTEXES_UNLOCK;
	umtx_key_release(&key);

	- LIN_SDT_PROBE1(futex, futex_get0, return,
	- EINVAL);
	return (EINVAL);
	}

	@@ -389,7 +336,6 @@
	LINUX_CTR3(sys_futex, "futex_get uaddr %p ref %d shared %d",
	uaddr, f->f_refcount, f->f_key.shared);

	- LIN_SDT_PROBE1(futex, futex_get0, return, 0);
	return (0);
	}
	}
	@@ -400,7 +346,6 @@
	LIN_SDT_PROBE1(futex, futex_get0, null, uaddr);
	LINUX_CTR1(sys_futex, "futex_get uaddr %p null", uaddr);

	- LIN_SDT_PROBE1(futex, futex_get0, return, 0);
	return (0);
	}

	@@ -432,7 +377,6 @@
	uaddr, tmpf->f_refcount, tmpf->f_key.shared);
	*newf = tmpf;

	- LIN_SDT_PROBE1(futex, futex_get0, return, 0);
	return (0);
	}

	@@ -442,8 +386,6 @@
	{
	int error;

	- LIN_SDT_PROBE3(futex, futex_get, entry, uaddr, wp, f);
	-
	if (flags & FUTEX_CREATE_WP) {
	*wp = malloc(sizeof(struct waiting_proc), M_FUTEX_WP, M_WAITOK);
	(*wp)->wp_flags = 0;
	@@ -455,7 +397,6 @@
	if (flags & FUTEX_CREATE_WP)
	free(*wp, M_FUTEX_WP);

	- LIN_SDT_PROBE1(futex, futex_get, return, error);
	return (error);
	}
	if (flags & FUTEX_CREATE_WP) {
	@@ -463,7 +404,6 @@
	(wp)->wp_futex = f;
	}

	- LIN_SDT_PROBE1(futex, futex_get, return, error);
	return (error);
	}

	@@ -512,7 +452,6 @@
	sbt = 0;
	prec = 0;
	}
	- LIN_SDT_PROBE3(futex, futex_sleep, entry, f, wp, sbt);
	LINUX_CTR4(sys_futex, "futex_sleep enter uaddr %p wp %p timo %ld ref %d",
	f->f_uaddr, wp, sbt, f->f_refcount);

	@@ -544,7 +483,6 @@

	futex_put(f, wp);

	- LIN_SDT_PROBE1(futex, futex_sleep, return, error);
	return (error);
	}

	@@ -554,12 +492,8 @@
	struct waiting_proc wp, wpt;
	int count = 0;

	- LIN_SDT_PROBE3(futex, futex_wake, entry, f, n, bitset);
	-
	- if (bitset == 0) {
	- LIN_SDT_PROBE1(futex, futex_wake, return, EINVAL);
	+ if (bitset == 0)
	return (EINVAL);
	- }

	FUTEX_ASSERT_LOCKED(f);
	TAILQ_FOREACH_SAFE(wp, &f->f_waiting_proc, wp_list, wpt) {
	@@ -582,7 +516,6 @@
	break;
	}

	- LIN_SDT_PROBE1(futex, futex_wake, return, count);
	return (count);
	}

	@@ -592,8 +525,6 @@
	struct waiting_proc wp, wpt;
	int count = 0;

	- LIN_SDT_PROBE4(futex, futex_requeue, entry, f, n, f2, n2);
	-
	FUTEX_ASSERT_LOCKED(f);
	FUTEX_ASSERT_LOCKED(f2);

	@@ -629,7 +560,6 @@
	}
	}

	- LIN_SDT_PROBE1(futex, futex_requeue, return, count);
	return (count);
	}

	@@ -639,10 +569,7 @@
	{
	int error;

	- LIN_SDT_PROBE4(futex, futex_wait, entry, f, wp, ts, bitset);
	-
	if (bitset == 0) {
	- LIN_SDT_PROBE1(futex, futex_wait, return, EINVAL);
	futex_put(f, wp);
	return (EINVAL);
	}
	@@ -654,7 +581,6 @@
	if (error == EWOULDBLOCK)
	error = ETIMEDOUT;

	- LIN_SDT_PROBE1(futex, futex_wait, return, error);
	return (error);
	}

	@@ -667,8 +593,6 @@
	int cmparg = (encoded_op << 20) >> 20;
	int oldval = 0, ret;

	- LIN_SDT_PROBE3(futex, futex_atomic_op, entry, td, encoded_op, uaddr);
	-
	if (encoded_op & (FUTEX_OP_OPARG_SHIFT << 28))
	oparg = 1 << oparg;

	@@ -700,10 +624,8 @@
	break;
	}

	- if (ret) {
	- LIN_SDT_PROBE1(futex, futex_atomic_op, return, ret);
	+ if (ret)
	return (ret);
	- }

	switch (cmp) {
	case FUTEX_OP_CMP_EQ:
	@@ -729,7 +651,6 @@
	ret = -ENOSYS;
	}

	- LIN_SDT_PROBE1(futex, futex_atomic_op, return, ret);
	return (ret);
	}

	@@ -744,8 +665,6 @@
	int error, save;
	uint32_t flags, val;

	- LIN_SDT_PROBE2(futex, linux_sys_futex, entry, td, args);
	-
	if (args->op & LINUX_FUTEX_PRIVATE_FLAG) {
	flags = 0;
	args->op &= ~LINUX_FUTEX_PRIVATE_FLAG;
	@@ -764,7 +683,6 @@
	args->op != LINUX_FUTEX_WAIT_REQUEUE_PI) {
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	unimplemented_clockswitch);
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, ENOSYS);
	return (ENOSYS);
	}

	@@ -788,7 +706,6 @@
	if (error) {
	LIN_SDT_PROBE1(futex, linux_sys_futex, copyin_error,
	error);
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}
	ts = &uts;
	@@ -798,10 +715,8 @@
	retry0:
	error = futex_get(args->uaddr, &wp, &f,
	flags \| FUTEX_CREATE_WP);
	- if (error) {
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	+ if (error)
	return (error);
	- }

	error = copyin_nofault(args->uaddr, &val, sizeof(val));
	if (error) {
	@@ -813,7 +728,6 @@
	error);
	LINUX_CTR1(sys_futex, "WAIT copyin failed %d",
	error);
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}
	if (val != args->val) {
	@@ -824,9 +738,6 @@
	"WAIT uaddr %p val 0x%x != uval 0x%x",
	args->uaddr, args->val, val);
	futex_put(f, wp);
	-
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return,
	- EWOULDBLOCK);
	return (EWOULDBLOCK);
	}

	@@ -845,15 +756,11 @@

	error = futex_get(args->uaddr, NULL, &f,
	flags \| FUTEX_DONTCREATE);
	- if (error) {
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	+ if (error)
	return (error);
	- }

	if (f == NULL) {
	td->td_retval[0] = 0;
	-
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}
	td->td_retval[0] = futex_wake(f, args->val, args->val3);
	@@ -876,16 +783,13 @@
	if (args->uaddr == args->uaddr2) {
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	invalid_cmp_requeue_use);
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, EINVAL);
	return (EINVAL);
	}

	retry1:
	error = futex_get(args->uaddr, NULL, &f, flags \| FUTEX_DONTLOCK);
	- if (error) {
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	+ if (error)
	return (error);
	- }

	/*
	* To avoid deadlocks return EINVAL if second futex
	@@ -898,8 +802,6 @@
	flags \| FUTEX_DONTEXISTS \| FUTEX_DONTLOCK);
	if (error) {
	futex_put(f, NULL);
	-
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}
	futex_lock(f);
	@@ -915,7 +817,6 @@
	error);
	LINUX_CTR1(sys_futex, "CMP_REQUEUE copyin failed %d",
	error);
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}
	if (val != args->val3) {
	@@ -925,8 +826,6 @@
	args->val, val);
	futex_put(f2, NULL);
	futex_put(f, NULL);
	-
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, EAGAIN);
	return (EAGAIN);
	}

	@@ -944,23 +843,17 @@
	args->uaddr, args->val, args->uaddr2, args->val3,
	args->timeout);

	- if (args->uaddr == args->uaddr2) {
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, EINVAL);
	+ if (args->uaddr == args->uaddr2)
	return (EINVAL);
	- }

	retry2:
	error = futex_get(args->uaddr, NULL, &f, flags \| FUTEX_DONTLOCK);
	- if (error) {
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	+ if (error)
	return (error);
	- }

	error = futex_get(args->uaddr2, NULL, &f2, flags \| FUTEX_DONTLOCK);
	if (error) {
	futex_put(f, NULL);
	-
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}
	futex_lock(f);
	@@ -984,7 +877,6 @@
	error = copyin(args->uaddr2, &val, sizeof(val));
	if (error == 0)
	goto retry2;
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}

	@@ -1015,7 +907,6 @@
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	unimplemented_lock_pi);
	}
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, ENOSYS);
	return (ENOSYS);

	case LINUX_FUTEX_UNLOCK_PI:
	@@ -1027,7 +918,6 @@
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	unimplemented_unlock_pi);
	}
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, ENOSYS);
	return (ENOSYS);

	case LINUX_FUTEX_TRYLOCK_PI:
	@@ -1039,7 +929,6 @@
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	unimplemented_trylock_pi);
	}
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, ENOSYS);
	return (ENOSYS);

	case LINUX_FUTEX_REQUEUE:
	@@ -1056,8 +945,6 @@
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	deprecated_requeue);
	}
	-
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, EINVAL);
	return (EINVAL);

	case LINUX_FUTEX_WAIT_REQUEUE_PI:
	@@ -1069,7 +956,6 @@
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	unimplemented_wait_requeue_pi);
	}
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, ENOSYS);
	return (ENOSYS);

	case LINUX_FUTEX_CMP_REQUEUE_PI:
	@@ -1081,18 +967,15 @@
	LIN_SDT_PROBE0(futex, linux_sys_futex,
	unimplemented_cmp_requeue_pi);
	}
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, ENOSYS);
	return (ENOSYS);

	default:
	linux_msg(td, "unsupported futex op %d", args->op);
	LIN_SDT_PROBE1(futex, linux_sys_futex, unknown_operation,
	args->op);
	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, ENOSYS);
	return (ENOSYS);
	}

	- LIN_SDT_PROBE1(futex, linux_sys_futex, return, error);
	return (error);
	}

	@@ -1101,18 +984,14 @@
	{
	struct linux_emuldata *em;

	- LIN_SDT_PROBE2(futex, linux_set_robust_list, entry, td, args);
	-
	if (args->len != sizeof(struct linux_robust_list_head)) {
	LIN_SDT_PROBE0(futex, linux_set_robust_list, size_error);
	- LIN_SDT_PROBE1(futex, linux_set_robust_list, return, EINVAL);
	return (EINVAL);
	}

	em = em_find(td);
	em->robust_futexes = args->head;

	- LIN_SDT_PROBE1(futex, linux_set_robust_list, return, 0);
	return (0);
	}

	@@ -1125,22 +1004,15 @@
	struct thread *td2;
	int error = 0;

	- LIN_SDT_PROBE2(futex, linux_get_robust_list, entry, td, args);
	-
	if (!args->pid) {
	em = em_find(td);
	KASSERT(em != NULL, ("get_robust_list: emuldata notfound.\n"));
	head = em->robust_futexes;
	} else {
	td2 = tdfind(args->pid, -1);
	- if (td2 == NULL) {
	- LIN_SDT_PROBE1(futex, linux_get_robust_list, return,
	- ESRCH);
	+ if (td2 == NULL)
	return (ESRCH);
	- }
	if (SV_PROC_ABI(td2->td_proc) != SV_ABI_LINUX) {
	- LIN_SDT_PROBE1(futex, linux_get_robust_list, return,
	- EPERM);
	PROC_UNLOCK(td2->td_proc);
	return (EPERM);
	}
	@@ -1152,9 +1024,6 @@
	priv_check(td, PRIV_CRED_SETEUID) \|\|
	p_candebug(td, td2->td_proc)) {
	PROC_UNLOCK(td2->td_proc);
	-
	- LIN_SDT_PROBE1(futex, linux_get_robust_list, return,
	- EPERM);
	return (EPERM);
	}
	head = em->robust_futexes;
	@@ -1166,7 +1035,6 @@
	if (error) {
	LIN_SDT_PROBE1(futex, linux_get_robust_list, copyout_error,
	error);
	- LIN_SDT_PROBE1(futex, linux_get_robust_list, return, EFAULT);
	return (EFAULT);
	}

	@@ -1176,7 +1044,6 @@
	error);
	}

	- LIN_SDT_PROBE1(futex, linux_get_robust_list, return, error);
	return (error);
	}

	@@ -1188,24 +1055,18 @@
	struct futex *f;
	int error;

	- LIN_SDT_PROBE3(futex, handle_futex_death, entry, em, uaddr, pi);
	-
	retry:
	error = copyin(uaddr, &uval, 4);
	if (error) {
	LIN_SDT_PROBE1(futex, handle_futex_death, copyin_error, error);
	- LIN_SDT_PROBE1(futex, handle_futex_death, return, EFAULT);
	return (EFAULT);
	}
	if ((uval & FUTEX_TID_MASK) == em->em_tid) {
	mval = (uval & FUTEX_WAITERS) \| FUTEX_OWNER_DIED;
	nval = casuword32(uaddr, uval, mval);

	- if (nval == -1) {
	- LIN_SDT_PROBE1(futex, handle_futex_death, return,
	- EFAULT);
	+ if (nval == -1)
	return (EFAULT);
	- }

	if (nval != uval)
	goto retry;
	@@ -1213,11 +1074,8 @@
	if (!pi && (uval & FUTEX_WAITERS)) {
	error = futex_get(uaddr, NULL, &f,
	FUTEX_DONTCREATE \| FUTEX_SHARED);
	- if (error) {
	- LIN_SDT_PROBE1(futex, handle_futex_death,
	- return, error);
	+ if (error)
	return (error);
	- }
	if (f != NULL) {
	futex_wake(f, 1, FUTEX_BITSET_MATCH_ANY);
	futex_put(f, NULL);
	@@ -1225,7 +1083,6 @@
	}
	}

	- LIN_SDT_PROBE1(futex, handle_futex_death, return, 0);
	return (0);
	}

	@@ -1236,19 +1093,15 @@
	l_ulong uentry;
	int error;

	- LIN_SDT_PROBE3(futex, fetch_robust_entry, entry, entry, head, pi);
	-
	error = copyin((const void *)head, &uentry, sizeof(l_ulong));
	if (error) {
	LIN_SDT_PROBE1(futex, fetch_robust_entry, copyin_error, error);
	- LIN_SDT_PROBE1(futex, fetch_robust_entry, return, EFAULT);
	return (EFAULT);
	}

	entry = (void )(uentry & ~1UL);
	*pi = uentry & 1;

	- LIN_SDT_PROBE1(futex, fetch_robust_entry, return, 0);
	return (0);
	}

	@@ -1262,32 +1115,23 @@
	l_long futex_offset;
	int rc, error;

	- LIN_SDT_PROBE2(futex, release_futexes, entry, td, em);
	-
	head = em->robust_futexes;

	- if (head == NULL) {
	- LIN_SDT_PROBE0(futex, release_futexes, return);
	+ if (head == NULL)
	return;
	- }

	- if (fetch_robust_entry(&entry, PTRIN(&head->list.next), &pi)) {
	- LIN_SDT_PROBE0(futex, release_futexes, return);
	+ if (fetch_robust_entry(&entry, PTRIN(&head->list.next), &pi))
	return;
	- }

	error = copyin(&head->futex_offset, &futex_offset,
	sizeof(futex_offset));
	if (error) {
	LIN_SDT_PROBE1(futex, release_futexes, copyin_error, error);
	- LIN_SDT_PROBE0(futex, release_futexes, return);
	return;
	}

	- if (fetch_robust_entry(&pending, PTRIN(&head->pending_list), &pip)) {
	- LIN_SDT_PROBE0(futex, release_futexes, return);
	+ if (fetch_robust_entry(&pending, PTRIN(&head->pending_list), &pip))
	return;
	- }

	while (entry != &head->list) {
	rc = fetch_robust_entry(&next_entry, PTRIN(&entry->next), &next_pi);
	@@ -1295,13 +1139,10 @@
	if (entry != pending)
	if (handle_futex_death(em,
	(uint32_t *)((caddr_t)entry + futex_offset), pi)) {
	- LIN_SDT_PROBE0(futex, release_futexes, return);
	return;
	}
	- if (rc) {
	- LIN_SDT_PROBE0(futex, release_futexes, return);
	+ if (rc)
	return;
	- }

	entry = next_entry;
	pi = next_pi;
	@@ -1314,6 +1155,4 @@

	if (pending)
	handle_futex_death(em, (uint32_t *)((caddr_t)pending + futex_offset), pip);
	-
	- LIN_SDT_PROBE0(futex, release_futexes, return);
	}
	diff --git a/sys/compat/linux/linux_sysctl.c b/sys/compat/linux/linux_sysctl.c
	--- a/sys/compat/linux/linux_sysctl.c
	+++ b/sys/compat/linux/linux_sysctl.c
	@@ -75,16 +75,10 @@
	/**
	* DTrace probes in this module.
	*/
	-LIN_SDT_PROBE_DEFINE2(sysctl, handle_string, entry, "struct l___sysctl_args *",
	- "char *");
	LIN_SDT_PROBE_DEFINE1(sysctl, handle_string, copyout_error, "int");
	-LIN_SDT_PROBE_DEFINE1(sysctl, handle_string, return, "int");
	-LIN_SDT_PROBE_DEFINE2(sysctl, linux_sysctl, entry, "struct l___sysctl_args *",
	- "struct thread *");
	LIN_SDT_PROBE_DEFINE1(sysctl, linux_sysctl, copyin_error, "int");
	LIN_SDT_PROBE_DEFINE2(sysctl, linux_sysctl, wrong_length, "int", "int");
	LIN_SDT_PROBE_DEFINE1(sysctl, linux_sysctl, unsupported_sysctl, "char *");
	-LIN_SDT_PROBE_DEFINE1(sysctl, linux_sysctl, return, "int");

	#ifdef LINUX_LEGACY_SYSCALLS
	static int
	@@ -92,8 +86,6 @@
	{
	int error;

	- LIN_SDT_PROBE2(sysctl, handle_string, entry, la, value);
	-
	if (la->oldval != 0) {
	l_int len = strlen(value);
	error = copyout(value, PTRIN(la->oldval), len + 1);
	@@ -102,17 +94,13 @@
	if (error) {
	LIN_SDT_PROBE1(sysctl, handle_string, copyout_error,
	error);
	- LIN_SDT_PROBE1(sysctl, handle_string, return, error);
	return (error);
	}
	}

	- if (la->newval != 0) {
	- LIN_SDT_PROBE1(sysctl, handle_string, return, ENOTDIR);
	+ if (la->newval != 0)
	return (ENOTDIR);
	- }

	- LIN_SDT_PROBE1(sysctl, handle_string, return, 0);
	return (0);
	}

	@@ -125,19 +113,15 @@
	char *sysctl_string;
	int error, i;

	- LIN_SDT_PROBE2(sysctl, linux_sysctl, entry, td, args->args);
	-
	error = copyin(args->args, &la, sizeof(la));
	if (error) {
	LIN_SDT_PROBE1(sysctl, linux_sysctl, copyin_error, error);
	- LIN_SDT_PROBE1(sysctl, linux_sysctl, return, error);
	return (error);
	}

	if (la.nlen <= 0 \|\| la.nlen > LINUX_CTL_MAXNAME) {
	LIN_SDT_PROBE2(sysctl, linux_sysctl, wrong_length, la.nlen,
	LINUX_CTL_MAXNAME);
	- LIN_SDT_PROBE1(sysctl, linux_sysctl, return, ENOTDIR);
	return (ENOTDIR);
	}

	@@ -145,7 +129,6 @@
	error = copyin(PTRIN(la.name), mib, la.nlen * sizeof(l_int));
	if (error) {
	LIN_SDT_PROBE1(sysctl, linux_sysctl, copyin_error, error);
	- LIN_SDT_PROBE1(sysctl, linux_sysctl, return, error);
	free(mib, M_LINUX);
	return (error);
	}
	@@ -159,7 +142,6 @@
	case LINUX_KERN_VERSION:
	error = handle_string(&la, version);
	free(mib, M_LINUX);
	- LIN_SDT_PROBE1(sysctl, linux_sysctl, return, error);
	return (error);
	default:
	break;
	@@ -189,7 +171,6 @@

	free(mib, M_LINUX);

	- LIN_SDT_PROBE1(sysctl, linux_sysctl, return, ENOTDIR);
	return (ENOTDIR);
	}
	#endif
	diff --git a/sys/compat/linux/linux_time.c b/sys/compat/linux/linux_time.c
	--- a/sys/compat/linux/linux_time.c
	+++ b/sys/compat/linux/linux_time.c
	@@ -75,58 +75,33 @@
	/**
	* DTrace probes in this module.
	*/
	-LIN_SDT_PROBE_DEFINE2(time, native_to_linux_timespec, entry,
	- "struct l_timespec ", "struct timespec ");
	-LIN_SDT_PROBE_DEFINE0(time, native_to_linux_timespec, return);
	-LIN_SDT_PROBE_DEFINE2(time, linux_to_native_timespec, entry,
	- "struct timespec ", "struct l_timespec ");
	-LIN_SDT_PROBE_DEFINE1(time, linux_to_native_timespec, return, "int");
	-LIN_SDT_PROBE_DEFINE2(time, linux_to_native_clockid, entry, "clockid_t *",
	- "clockid_t");
	LIN_SDT_PROBE_DEFINE1(time, linux_to_native_clockid, unsupported_clockid,
	"clockid_t");
	LIN_SDT_PROBE_DEFINE1(time, linux_to_native_clockid, unknown_clockid,
	"clockid_t");
	-LIN_SDT_PROBE_DEFINE1(time, linux_to_native_clockid, return, "int");
	-LIN_SDT_PROBE_DEFINE2(time, linux_clock_gettime, entry, "clockid_t",
	- "struct l_timespec *");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, conversion_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, gettime_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, copyout_error, "int");
	-LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, return, "int");
	-LIN_SDT_PROBE_DEFINE2(time, linux_clock_settime, entry, "clockid_t",
	- "struct l_timespec *");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, conversion_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, settime_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, copyin_error, "int");
	-LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, return, "int");
	-LIN_SDT_PROBE_DEFINE2(time, linux_clock_getres, entry, "clockid_t",
	- "struct l_timespec *");
	LIN_SDT_PROBE_DEFINE0(time, linux_clock_getres, nullcall);
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, conversion_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, getres_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, copyout_error, "int");
	-LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, return, "int");
	-LIN_SDT_PROBE_DEFINE2(time, linux_nanosleep, entry, "const struct l_timespec *",
	- "struct l_timespec *");
	LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, conversion_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, copyout_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, copyin_error, "int");
	-LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, return, "int");
	-LIN_SDT_PROBE_DEFINE4(time, linux_clock_nanosleep, entry, "clockid_t", "int",
	- "struct l_timespec ", "struct l_timespec ");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, conversion_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, copyout_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, copyin_error, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, unsupported_flags, "int");
	LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, unsupported_clockid, "int");
	-LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, return, "int");

	int
	native_to_linux_timespec(struct l_timespec ltp, struct timespec ntp)
	{

	- LIN_SDT_PROBE2(time, native_to_linux_timespec, entry, ltp, ntp);
	#ifdef COMPAT_LINUX32
	if (ntp->tv_sec > INT_MAX \|\| ntp->tv_sec < INT_MIN)
	return (EOVERFLOW);
	@@ -134,7 +109,6 @@
	ltp->tv_sec = ntp->tv_sec;
	ltp->tv_nsec = ntp->tv_nsec;

	- LIN_SDT_PROBE0(time, native_to_linux_timespec, return);
	return (0);
	}

	@@ -142,16 +116,11 @@
	linux_to_native_timespec(struct timespec ntp, struct l_timespec ltp)
	{

	- LIN_SDT_PROBE2(time, linux_to_native_timespec, entry, ntp, ltp);
	-
	- if (ltp->tv_sec < 0 \|\| ltp->tv_nsec < 0 \|\| ltp->tv_nsec > 999999999) {
	- LIN_SDT_PROBE1(time, linux_to_native_timespec, return, EINVAL);
	+ if (ltp->tv_sec < 0 \|\| ltp->tv_nsec < 0 \|\| ltp->tv_nsec > 999999999)
	return (EINVAL);
	- }
	ntp->tv_sec = ltp->tv_sec;
	ntp->tv_nsec = ltp->tv_nsec;

	- LIN_SDT_PROBE1(time, linux_to_native_timespec, return, 0);
	return (0);
	}

	@@ -181,8 +150,6 @@
	linux_to_native_clockid(clockid_t *n, clockid_t l)
	{

	- LIN_SDT_PROBE2(time, linux_to_native_clockid, entry, n, l);
	-
	if (l < 0) {
	/* cpu-clock */
	if ((l & LINUX_CLOCKFD_MASK) == LINUX_CLOCKFD)
	@@ -226,16 +193,13 @@
	case LINUX_CLOCK_TAI:
	LIN_SDT_PROBE1(time, linux_to_native_clockid,
	unsupported_clockid, l);
	- LIN_SDT_PROBE1(time, linux_to_native_clockid, return, EINVAL);
	return (EINVAL);
	default:
	LIN_SDT_PROBE1(time, linux_to_native_clockid,
	unknown_clockid, l);
	- LIN_SDT_PROBE1(time, linux_to_native_clockid, return, EINVAL);
	return (EINVAL);
	}

	- LIN_SDT_PROBE1(time, linux_to_native_clockid, return, 0);
	return (0);
	}

	@@ -264,15 +228,12 @@
	pid_t pid;
	lwpid_t tid;

	- LIN_SDT_PROBE2(time, linux_clock_gettime, entry, args->which, args->tp);
	-
	error = linux_to_native_clockid(&nwhich, args->which);
	if (error != 0) {
	linux_msg(curthread,
	"unsupported clock_gettime clockid %d", args->which);
	LIN_SDT_PROBE1(time, linux_clock_gettime, conversion_error,
	error);
	- LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
	return (error);
	}

	@@ -375,7 +336,6 @@
	}
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_clock_gettime, gettime_error, error);
	- LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
	return (error);
	}
	error = native_to_linux_timespec(&lts, &tp);
	@@ -385,7 +345,6 @@
	if (error != 0)
	LIN_SDT_PROBE1(time, linux_clock_gettime, copyout_error, error);

	- LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
	return (error);
	}

	@@ -397,28 +356,23 @@
	int error;
	clockid_t nwhich;

	- LIN_SDT_PROBE2(time, linux_clock_settime, entry, args->which, args->tp);
	-
	error = linux_to_native_clockid(&nwhich, args->which);
	if (error != 0) {
	linux_msg(curthread,
	"unsupported clock_settime clockid %d", args->which);
	LIN_SDT_PROBE1(time, linux_clock_settime, conversion_error,
	error);
	- LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
	return (error);
	}
	error = copyin(args->tp, &lts, sizeof lts);
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_clock_settime, copyin_error, error);
	- LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
	return (error);
	}
	error = linux_to_native_timespec(&ts, &lts);
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_clock_settime, conversion_error,
	error);
	- LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
	return (error);
	}

	@@ -426,7 +380,6 @@
	if (error != 0)
	LIN_SDT_PROBE1(time, linux_clock_settime, settime_error, error);

	- LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
	return (error);
	}

	@@ -441,15 +394,12 @@
	pid_t pid;
	lwpid_t tid;

	- LIN_SDT_PROBE2(time, linux_clock_getres, entry, args->which, args->tp);
	-
	error = linux_to_native_clockid(&nwhich, args->which);
	if (error != 0) {
	linux_msg(curthread,
	"unsupported clock_getres clockid %d", args->which);
	LIN_SDT_PROBE1(time, linux_clock_getres, conversion_error,
	error);
	- LIN_SDT_PROBE1(time, linux_clock_getres, return, error);
	return (error);
	}

	@@ -482,7 +432,6 @@

	if (args->tp == NULL) {
	LIN_SDT_PROBE0(time, linux_clock_getres, nullcall);
	- LIN_SDT_PROBE1(time, linux_clock_getres, return, 0);
	return (0);
	}

	@@ -522,7 +471,6 @@
	error = kern_clock_getres(td, nwhich, &ts);
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_clock_getres, getres_error, error);
	- LIN_SDT_PROBE1(time, linux_clock_getres, return, error);
	return (error);
	}

	@@ -534,7 +482,6 @@
	if (error != 0)
	LIN_SDT_PROBE1(time, linux_clock_getres, copyout_error, error);

	- LIN_SDT_PROBE1(time, linux_clock_getres, return, error);
	return (error);
	}

	@@ -546,12 +493,9 @@
	struct timespec rqts, rmts;
	int error, error2;

	- LIN_SDT_PROBE2(time, linux_nanosleep, entry, args->rqtp, args->rmtp);
	-
	error = copyin(args->rqtp, &lrqts, sizeof lrqts);
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_nanosleep, copyin_error, error);
	- LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
	return (error);
	}

	@@ -563,7 +507,6 @@
	error = linux_to_native_timespec(&rqts, &lrqts);
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_nanosleep, conversion_error, error);
	- LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
	return (error);
	}
	error = kern_nanosleep(td, &rqts, rmtp);
	@@ -575,12 +518,10 @@
	if (error2 != 0) {
	LIN_SDT_PROBE1(time, linux_nanosleep, copyout_error,
	error2);
	- LIN_SDT_PROBE1(time, linux_nanosleep, return, error2);
	return (error2);
	}
	}

	- LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
	return (error);
	}

	@@ -593,14 +534,10 @@
	int error, error2, flags;
	clockid_t clockid;

	- LIN_SDT_PROBE4(time, linux_clock_nanosleep, entry, args->which,
	- args->flags, args->rqtp, args->rmtp);
	-
	error = linux_to_native_timerflags(&flags, args->flags);
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_clock_nanosleep, unsupported_flags,
	args->flags);
	- LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
	return (error);
	}

	@@ -610,7 +547,6 @@
	"unsupported clock_nanosleep clockid %d", args->which);
	LIN_SDT_PROBE1(time, linux_clock_nanosleep, unsupported_clockid,
	args->which);
	- LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
	return (error);
	}

	@@ -618,7 +554,6 @@
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_clock_nanosleep, copyin_error,
	error);
	- LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
	return (error);
	}

	@@ -631,7 +566,6 @@
	if (error != 0) {
	LIN_SDT_PROBE1(time, linux_clock_nanosleep, conversion_error,
	error);
	- LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
	return (error);
	}
	error = kern_clock_nanosleep(td, clockid, flags, &rqts, rmtp);
	@@ -644,12 +578,9 @@
	if (error2 != 0) {
	LIN_SDT_PROBE1(time, linux_clock_nanosleep,
	copyout_error, error2);
	- LIN_SDT_PROBE1(time, linux_clock_nanosleep,
	- return, error2);
	return (error2);
	}
	}

	- LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
	return (error);
	}
	diff --git a/sys/compat/linux/linux_uid16.c b/sys/compat/linux/linux_uid16.c
	--- a/sys/compat/linux/linux_uid16.c
	+++ b/sys/compat/linux/linux_uid16.c
	@@ -61,43 +61,11 @@
	/**
	* DTrace probes in this module.
	*/
	-LIN_SDT_PROBE_DEFINE3(uid16, linux_chown16, entry, "char *", "l_uid16_t",
	- "l_gid16_t");
	LIN_SDT_PROBE_DEFINE1(uid16, linux_chown16, conv_path, "char *");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_chown16, return, "int");
	-LIN_SDT_PROBE_DEFINE3(uid16, linux_lchown16, entry, "char *", "l_uid16_t",
	- "l_gid16_t");
	LIN_SDT_PROBE_DEFINE1(uid16, linux_lchown16, conv_path, "char *");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_lchown16, return, "int");
	-LIN_SDT_PROBE_DEFINE2(uid16, linux_setgroups16, entry, "l_uint", "l_gid16_t *");
	LIN_SDT_PROBE_DEFINE1(uid16, linux_setgroups16, copyin_error, "int");
	LIN_SDT_PROBE_DEFINE1(uid16, linux_setgroups16, priv_check_cred_error, "int");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setgroups16, return, "int");
	-LIN_SDT_PROBE_DEFINE2(uid16, linux_getgroups16, entry, "l_uint", "l_gid16_t *");
	LIN_SDT_PROBE_DEFINE1(uid16, linux_getgroups16, copyout_error, "int");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_getgroups16, return, "int");
	-LIN_SDT_PROBE_DEFINE0(uid16, linux_getgid16, entry);
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_getgid16, return, "int");
	-LIN_SDT_PROBE_DEFINE0(uid16, linux_getuid16, entry);
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_getuid16, return, "int");
	-LIN_SDT_PROBE_DEFINE0(uid16, linux_getegid16, entry);
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_getegid16, return, "int");
	-LIN_SDT_PROBE_DEFINE0(uid16, linux_geteuid16, entry);
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_geteuid16, return, "int");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setgid16, entry, "l_gid16_t");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setgid16, return, "int");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setuid16, entry, "l_uid16_t");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setuid16, return, "int");
	-LIN_SDT_PROBE_DEFINE2(uid16, linux_setregid16, entry, "l_gid16_t", "l_gid16_t");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setregid16, return, "int");
	-LIN_SDT_PROBE_DEFINE2(uid16, linux_setreuid16, entry, "l_uid16_t", "l_uid16_t");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setreuid16, return, "int");
	-LIN_SDT_PROBE_DEFINE3(uid16, linux_setresgid16, entry, "l_gid16_t", "l_gid16_t",
	- "l_gid16_t");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setresgid16, return, "int");
	-LIN_SDT_PROBE_DEFINE3(uid16, linux_setresuid16, entry, "l_uid16_t", "l_uid16_t",
	- "l_uid16_t");
	-LIN_SDT_PROBE_DEFINE1(uid16, linux_setresuid16, return, "int");

	DUMMY(setfsuid16);
	DUMMY(setfsgid16);
	@@ -122,14 +90,11 @@
	* LCONVPATHEXIST may return on its own and we do not want to
	* have a stray entry without the corresponding return.
	*/
	- LIN_SDT_PROBE3(uid16, linux_chown16, entry, args->path, args->uid,
	- args->gid);
	LIN_SDT_PROBE1(uid16, linux_chown16, conv_path, path);

	error = kern_fchownat(td, AT_FDCWD, path, UIO_SYSSPACE,
	CAST_NOCHG(args->uid), CAST_NOCHG(args->gid), 0);
	LFREEPATH(path);
	- LIN_SDT_PROBE1(uid16, linux_chown16, return, error);
	}
	return (error);
	}
	@@ -151,14 +116,11 @@
	* LCONVPATHEXIST may return on its own and we do not want to
	* have a stray entry without the corresponding return.
	*/
	- LIN_SDT_PROBE3(uid16, linux_lchown16, entry, args->path, args->uid,
	- args->gid);
	LIN_SDT_PROBE1(uid16, linux_lchown16, conv_path, path);

	error = kern_fchownat(td, AT_FDCWD, path, UIO_SYSSPACE,
	CAST_NOCHG(args->uid), CAST_NOCHG(args->gid), AT_SYMLINK_NOFOLLOW);
	LFREEPATH(path);
	- LIN_SDT_PROBE1(uid16, linux_lchown16, return, error);
	}
	return (error);
	}
	@@ -172,19 +134,13 @@
	int ngrp, error;
	struct proc *p;

	- LIN_SDT_PROBE2(uid16, linux_setgroups16, entry, args->gidsetsize,
	- args->gidset);
	-
	ngrp = args->gidsetsize;
	- if (ngrp < 0 \|\| ngrp >= ngroups_max + 1) {
	- LIN_SDT_PROBE1(uid16, linux_setgroups16, return, EINVAL);
	+ if (ngrp < 0 \|\| ngrp >= ngroups_max + 1)
	return (EINVAL);
	- }
	linux_gidset = malloc(ngrp * sizeof(*linux_gidset), M_LINUX, M_WAITOK);
	error = copyin(args->gidset, linux_gidset, ngrp * sizeof(l_gid16_t));
	if (error) {
	LIN_SDT_PROBE1(uid16, linux_setgroups16, copyin_error, error);
	- LIN_SDT_PROBE1(uid16, linux_setgroups16, return, error);
	free(linux_gidset, M_LINUX);
	return (error);
	}
	@@ -229,7 +185,6 @@
	out:
	free(linux_gidset, M_LINUX);

	- LIN_SDT_PROBE1(uid16, linux_setgroups16, return, error);
	return (error);
	}

	@@ -241,9 +196,6 @@
	gid_t *bsd_gidset;
	int bsd_gidsetsz, ngrp, error;

	- LIN_SDT_PROBE2(uid16, linux_getgroups16, entry, args->gidsetsize,
	- args->gidset);
	-
	cred = td->td_ucred;
	bsd_gidset = cred->cr_groups;
	bsd_gidsetsz = cred->cr_ngroups - 1;
	@@ -256,15 +208,11 @@

	if ((ngrp = args->gidsetsize) == 0) {
	td->td_retval[0] = bsd_gidsetsz;
	-
	- LIN_SDT_PROBE1(uid16, linux_getgroups16, return, 0);
	return (0);
	}

	- if (ngrp < bsd_gidsetsz) {
	- LIN_SDT_PROBE1(uid16, linux_getgroups16, return, EINVAL);
	+ if (ngrp < bsd_gidsetsz)
	return (EINVAL);
	- }

	ngrp = 0;
	linux_gidset = malloc(bsd_gidsetsz * sizeof(*linux_gidset),
	@@ -278,13 +226,11 @@
	free(linux_gidset, M_LINUX);
	if (error) {
	LIN_SDT_PROBE1(uid16, linux_getgroups16, copyout_error, error);
	- LIN_SDT_PROBE1(uid16, linux_getgroups16, return, error);
	return (error);
	}

	td->td_retval[0] = ngrp;

	- LIN_SDT_PROBE1(uid16, linux_getgroups16, return, 0);
	return (0);
	}

	@@ -292,11 +238,8 @@
	linux_getgid16(struct thread td, struct linux_getgid16_args args)
	{

	- LIN_SDT_PROBE0(uid16, linux_getgid16, entry);
	-
	td->td_retval[0] = td->td_ucred->cr_rgid;

	- LIN_SDT_PROBE1(uid16, linux_getgid16, return, 0);
	return (0);
	}

	@@ -304,11 +247,8 @@
	linux_getuid16(struct thread td, struct linux_getuid16_args args)
	{

	- LIN_SDT_PROBE0(uid16, linux_getuid16, entry);
	-
	td->td_retval[0] = td->td_ucred->cr_ruid;

	- LIN_SDT_PROBE1(uid16, linux_getuid16, return, 0);
	return (0);
	}

	@@ -318,11 +258,8 @@
	struct getegid_args bsd;
	int error;

	- LIN_SDT_PROBE0(uid16, linux_getegid16, entry);
	-
	error = sys_getegid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_getegid16, return, error);
	return (error);
	}

	@@ -332,11 +269,8 @@
	struct geteuid_args bsd;
	int error;

	- LIN_SDT_PROBE0(uid16, linux_geteuid16, entry);
	-
	error = sys_geteuid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_geteuid16, return, error);
	return (error);
	}

	@@ -346,12 +280,9 @@
	struct setgid_args bsd;
	int error;

	- LIN_SDT_PROBE1(uid16, linux_setgid16, entry, args->gid);
	-
	bsd.gid = args->gid;
	error = sys_setgid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_setgid16, return, error);
	return (error);
	}

	@@ -361,12 +292,9 @@
	struct setuid_args bsd;
	int error;

	- LIN_SDT_PROBE1(uid16, linux_setuid16, entry, args->uid);
	-
	bsd.uid = args->uid;
	error = sys_setuid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_setuid16, return, error);
	return (error);
	}

	@@ -376,13 +304,10 @@
	struct setregid_args bsd;
	int error;

	- LIN_SDT_PROBE2(uid16, linux_setregid16, entry, args->rgid, args->egid);
	-
	bsd.rgid = CAST_NOCHG(args->rgid);
	bsd.egid = CAST_NOCHG(args->egid);
	error = sys_setregid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_setregid16, return, error);
	return (error);
	}

	@@ -392,13 +317,10 @@
	struct setreuid_args bsd;
	int error;

	- LIN_SDT_PROBE2(uid16, linux_setreuid16, entry, args->ruid, args->euid);
	-
	bsd.ruid = CAST_NOCHG(args->ruid);
	bsd.euid = CAST_NOCHG(args->euid);
	error = sys_setreuid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_setreuid16, return, error);
	return (error);
	}

	@@ -408,15 +330,11 @@
	struct setresgid_args bsd;
	int error;

	- LIN_SDT_PROBE3(uid16, linux_setresgid16, entry, args->rgid, args->egid,
	- args->sgid);
	-
	bsd.rgid = CAST_NOCHG(args->rgid);
	bsd.egid = CAST_NOCHG(args->egid);
	bsd.sgid = CAST_NOCHG(args->sgid);
	error = sys_setresgid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_setresgid16, return, error);
	return (error);
	}

	@@ -426,14 +344,10 @@
	struct setresuid_args bsd;
	int error;

	- LIN_SDT_PROBE3(uid16, linux_setresuid16, entry, args->ruid, args->euid,
	- args->suid);
	-
	bsd.ruid = CAST_NOCHG(args->ruid);
	bsd.euid = CAST_NOCHG(args->euid);
	bsd.suid = CAST_NOCHG(args->suid);
	error = sys_setresuid(td, &bsd);

	- LIN_SDT_PROBE1(uid16, linux_setresuid16, return, error);
	return (error);
	}
	diff --git a/sys/compat/linux/linux_util.h b/sys/compat/linux/linux_util.h
	--- a/sys/compat/linux/linux_util.h
	+++ b/sys/compat/linux/linux_util.h
	@@ -77,23 +77,18 @@
	#define LFREEPATH(path) free(path, M_TEMP)

	#define DUMMY(s) \
	-LIN_SDT_PROBE_DEFINE0(dummy, s, entry); \
	LIN_SDT_PROBE_DEFINE0(dummy, s, not_implemented); \
	-LIN_SDT_PROBE_DEFINE1(dummy, s, return, "int"); \
	int \
	linux_ ## s(struct thread td, struct linux_ ## s ## _args args) \
	{ \
	static pid_t pid; \
	\
	- LIN_SDT_PROBE0(dummy, s, entry); \
	- \
	if (pid != td->td_proc->p_pid) { \
	linux_msg(td, "syscall %s not implemented", #s); \
	LIN_SDT_PROBE0(dummy, s, not_implemented); \
	pid = td->td_proc->p_pid; \
	}; \
	\
	- LIN_SDT_PROBE1(dummy, s, return, ENOSYS); \
	return (ENOSYS); \
	} \
	struct __hack

File Metadata

Mime Type: text/plain
Expires: Fri, Jul 31, 2:56 AM (8 h, 17 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 35762369
Default Alt Text: D30040.diff (40 KB)

D30040.diffNo OneTemporaryActions

D30040.diffView Options

File Metadata

Event Timeline

D30040.diff
No OneTemporary
Actions

D30040.diff
View Options