 @@ -1,14 +1,14 @@
-/*	$NetBSD: linux_sched.c,v 1.66.4.1 2015/01/17 12:10:54 martin Exp $	*/
+/*	$NetBSD: linux_sched.c,v 1.66.4.2 2016/12/31 07:38:31 snj Exp $	*/
 /*-
  * Copyright (c) 1999 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center; by Matthias Scheler.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -25,27 +25,27 @@
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Linux compatibility module. Try to deal with scheduler related syscalls.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: linux_sched.c,v 1.66.4.1 2015/01/17 12:10:54 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux_sched.c,v 1.66.4.2 2016/12/31 07:38:31 snj Exp $");
 #include <sys/param.h>
 #include <sys/mount.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/sysctl.h>
 #include <sys/syscallargs.h>
 #include <sys/wait.h>
 #include <sys/kauth.h>
 #include <sys/ptrace.h>
 #include <sys/atomic.h>
 #include <sys/cpu.h>
 @@ -55,26 +55,29 @@ __KERNEL_RCSID(0, "$NetBSD: linux_sched.
 #include <compat/linux/common/linux_emuldata.h>
 #include <compat/linux/common/linux_ipc.h>
 #include <compat/linux/common/linux_sem.h>
 #include <compat/linux/common/linux_exec.h>
 #include <compat/linux/common/linux_machdep.h>
 #include <compat/linux/linux_syscallargs.h>
 #include <compat/linux/common/linux_sched.h>
 static int linux_clone_nptl(struct lwp *, const struct linux_sys_clone_args *,
     register_t *);
 /* Unlike Linux, dynamically calculate CPU mask size */
 #define	LINUX_CPU_MASK_SIZE (sizeof(long) * ((ncpu + LONG_BIT - 1) / LONG_BIT))
 #if DEBUG_LINUX
 #define DPRINTF(x) uprintf x
 #else
 #define DPRINTF(x)
 #endif
 static void
 linux_child_return(void *arg)
+{
 	struct lwp *l = arg;
 	struct proc *p = l->l_proc;
 	struct linux_emuldata *led = l->l_emuldata;
 	void *ctp = led->led_child_tidptr;
 @@ -617,80 +620,90 @@ linux_sys_set_tid_address(struct lwp *l,
 	return 0;
+}
 /* ARGUSED1 */
 int
 linux_sys_gettid(struct lwp *l, const void *v, register_t *retval)
+{
 	*retval = l->l_lid;
 	return 0;
+}
 /*
  * The affinity syscalls assume that the layout of our cpu kcpuset is
  * the same as linux's: a linear bitmask.
  */
 int
 linux_sys_sched_getaffinity(struct lwp *l, const struct linux_sys_sched_getaffinity_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux_pid_t) pid;
 		syscallarg(unsigned int) len;
 		syscallarg(unsigned long *) mask;
 	} */
-	proc_t *p;
+	struct lwp *t;
-	unsigned long *lp, *data;
+	kcpuset_t *kcset;
-	int error, size, nb = ncpu;
+	size_t size;
 	cpuid_t i;
 	int error;
-	/* Unlike Linux, dynamically calculate cpu mask size */
+	size = LINUX_CPU_MASK_SIZE;
 	size = sizeof(long) * ((ncpu + LONG_BIT - 1) / LONG_BIT);
 	if (SCARG(uap, len) < size)
 		return EINVAL;
-	/* XXX: Pointless check.  TODO: Actually implement this. */
+	/* Lock the LWP */
-	mutex_enter(proc_lock);
+	t = lwp_find2(SCARG(uap, pid), l->l_lid);
-	p = proc_find(SCARG(uap, pid));
+	if (t == NULL)
 	mutex_exit(proc_lock);
 	if (p == NULL) {
 		return ESRCH;
 	/*
 	 * return the actual number of CPU, tag all of them as available
 	 * The result is a mask, the first CPU being in the least significant
 	 * bit.
 	 */
 	data = kmem_zalloc(size, KM_SLEEP);
 	lp = data;
 	while (nb > LONG_BIT) {
 		*lp++ = ~0UL;
 		nb -= LONG_BIT;
 	if (nb)
 		*lp = (1 << ncpu) - 1;
-	error = copyout(data, SCARG(uap, mask), size);
+	/* Check the permission */
-	kmem_free(data, size);
+	if (kauth_authorize_process(l->l_cred,
 	    KAUTH_PROCESS_SCHEDULER_GETAFFINITY, t->l_proc, NULL, NULL, NULL)) {
 		mutex_exit(t->l_proc->p_lock);
 		return EPERM;
+	}
 	kcpuset_create(&kcset, true);
 	lwp_lock(t);
 	if (t->l_affinity != NULL)
 		kcpuset_copy(kcset, t->l_affinity);
 	else {
 		/*
 		 * All available CPUs should be masked when affinity has not
 		 * been set.
 		 */
 		kcpuset_zero(kcset);
 		for (i = 0; i < ncpu; i++)
 			kcpuset_set(kcset, i);
+	}
 	lwp_unlock(t);
 	mutex_exit(t->l_proc->p_lock);
 	error = kcpuset_copyout(kcset, (cpuset_t *)SCARG(uap, mask), size);
 	kcpuset_unuse(kcset, NULL);
 	*retval = size;
 	return error;
+}
 int
 linux_sys_sched_setaffinity(struct lwp *l, const struct linux_sys_sched_setaffinity_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux_pid_t) pid;
 		syscallarg(unsigned int) len;
 		syscallarg(unsigned long *) mask;
 	} */
-	proc_t *p;
+	struct sys__sched_setaffinity_args ssa;
 	size_t size;
-	/* XXX: Pointless check.  TODO: Actually implement this. */
+	size = LINUX_CPU_MASK_SIZE;
-	mutex_enter(proc_lock);
+	if (SCARG(uap, len) < size)
-	p = proc_find(SCARG(uap, pid));
+		return EINVAL;
 	mutex_exit(proc_lock);
 	if (p == NULL) {
 		return ESRCH;
-	/* Let's ignore it */
+	SCARG(&ssa, pid) = SCARG(uap, pid);
-	DPRINTF(("%s\n", __func__));
+	SCARG(&ssa, lid) = l->l_lid;
-	return 0;
+	SCARG(&ssa, size) = size;
 	SCARG(&ssa, cpuset) = (cpuset_t *)SCARG(uap, mask);
 	return sys__sched_setaffinity(l, &ssa, retval);
+}