 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_synch.c,v 1.267 2009/07/19 10:11:55 yamt Exp $	*/
+/*	$NetBSD: kern_synch.c,v 1.268 2009/10/03 01:30:25 elad Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2004, 2006, 2007, 2008, 2009
  *    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 Charles M. Hannum, Andrew Doran and
  * Daniel Sieger.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -59,27 +59,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 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.
+ *
  *	@(#)kern_synch.c	8.9 (Berkeley) 5/19/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_synch.c,v 1.267 2009/07/19 10:11:55 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_synch.c,v 1.268 2009/10/03 01:30:25 elad Exp $");
 #include "opt_kstack.h"
 #include "opt_perfctrs.h"
 #include "opt_sa.h"
 #define	__MUTEX_PRIVATE
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #if defined(PERFCTRS)
 #include <sys/pmc.h>
 @@ -87,26 +87,27 @@ __KERNEL_RCSID(0, "$NetBSD: kern_synch.c
 #include <sys/cpu.h>
 #include <sys/resourcevar.h>
 #include <sys/sched.h>
 #include <sys/sa.h>
 #include <sys/savar.h>
 #include <sys/syscall_stats.h>
 #include <sys/sleepq.h>
 #include <sys/lockdebug.h>
 #include <sys/evcnt.h>
 #include <sys/intr.h>
 #include <sys/lwpctl.h>
 #include <sys/atomic.h>
 #include <sys/simplelock.h>
 #include <sys/kauth.h>
 #include <uvm/uvm_extern.h>
 #include <dev/lockstat.h>
 static u_int	sched_unsleep(struct lwp *, bool);
 static void	sched_changepri(struct lwp *, pri_t);
 static void	sched_lendpri(struct lwp *, pri_t);
 static void	resched_cpu(struct lwp *);
 syncobj_t sleep_syncobj = {
 	SOBJ_SLEEPQ_SORTED,
 	sleepq_unsleep,
 @@ -117,57 +118,111 @@ syncobj_t sleep_syncobj = {
 syncobj_t sched_syncobj = {
 	SOBJ_SLEEPQ_SORTED,
 	sched_unsleep,
 	sched_changepri,
 	sched_lendpri,
 	syncobj_noowner,
 };
 callout_t 	sched_pstats_ch;
 unsigned	sched_pstats_ticks;
 kcondvar_t	lbolt;			/* once a second sleep address */
 kauth_listener_t	sched_listener;
 /* Preemption event counters */
 static struct evcnt kpreempt_ev_crit;
 static struct evcnt kpreempt_ev_klock;
 static struct evcnt kpreempt_ev_immed;
 /*
  * During autoconfiguration or after a panic, a sleep will simply lower the
  * priority briefly to allow interrupts, then return.  The priority to be
  * used (safepri) is machine-dependent, thus this value is initialized and
  * maintained in the machine-dependent layers.  This priority will typically
  * be 0, or the lowest priority that is safe for use on the interrupt stack;
  * it can be made higher to block network software interrupts after panics.
  */
 int	safepri;
 static int
 sched_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
     void *arg0, void *arg1, void *arg2, void *arg3)
+{
 	struct proc *p;
 	int result;
 	result = KAUTH_RESULT_DEFER;
 	p = arg0;
 	switch (action) {
 	case KAUTH_PROCESS_SCHEDULER_GETPARAM:
 		if (kauth_cred_uidmatch(cred, p->p_cred))
 			result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_PROCESS_SCHEDULER_SETPARAM:
 		if (kauth_cred_uidmatch(cred, p->p_cred)) {
 			struct lwp *l;
 			int policy;
 			pri_t priority;
 			l = arg1;
 			policy = (int)(unsigned long)arg2;
 			priority = (pri_t)(unsigned long)arg3;
 			if ((policy == l->l_class ||
 			    (policy != SCHED_FIFO && policy != SCHED_RR)) &&
 			    priority <= l->l_priority)
 				result = KAUTH_RESULT_ALLOW;
+		}
 		break;
 	case KAUTH_PROCESS_SCHEDULER_GETAFFINITY:
 		result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_PROCESS_SCHEDULER_SETAFFINITY:
 		/* Privileged; we let the secmodel handle this. */
 		break;
 	default:
 		break;
+	}
 	return result;
+}
 void
 sched_init(void)
+{
 	cv_init(&lbolt, "lbolt");
 	callout_init(&sched_pstats_ch, CALLOUT_MPSAFE);
 	callout_setfunc(&sched_pstats_ch, sched_pstats, NULL);
 	evcnt_attach_dynamic(&kpreempt_ev_crit, EVCNT_TYPE_MISC, NULL,
 	   "kpreempt", "defer: critical section");
 	evcnt_attach_dynamic(&kpreempt_ev_klock, EVCNT_TYPE_MISC, NULL,
 	   "kpreempt", "defer: kernel_lock");
 	evcnt_attach_dynamic(&kpreempt_ev_immed, EVCNT_TYPE_MISC, NULL,
 	   "kpreempt", "immediate");
 	sched_pstats(NULL);
 	sched_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS,
 	    sched_listener_cb, NULL);
+}
 /*
  * OBSOLETE INTERFACE
+ *
  * General sleep call.  Suspends the current LWP until a wakeup is
  * performed on the specified identifier.  The LWP will then be made
  * runnable with the specified priority.  Sleeps at most timo/hz seconds (0
  * means no timeout).  If pri includes PCATCH flag, signals are checked
  * before and after sleeping, else signals are not checked.  Returns 0 if
  * awakened, EWOULDBLOCK if the timeout expires.  If PCATCH is set and a
  * signal needs to be delivered, ERESTART is returned if the current system
  * call should be restarted if possible, and EINTR is returned if the system

 @@ -1,14 +1,14 @@
-/* $NetBSD: secmodel_suser.c,v 1.17 2009/10/03 00:37:01 elad Exp $ */
+/* $NetBSD: secmodel_suser.c,v 1.18 2009/10/03 01:30:25 elad Exp $ */
 /*-
  * Copyright (c) 2006 Elad Efrat <elad@NetBSD.org>
  * All rights reserved.
+ *
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
 @@ -28,27 +28,27 @@
 /*
  * This file contains kauth(9) listeners needed to implement the traditional
  * NetBSD superuser access restrictions.
+ *
  * There are two main resources a request can be issued to: user-owned and
  * system owned. For the first, traditional Unix access checks are done, as
  * well as superuser checks. If needed, the request context is examined before
  * a decision is made. For the latter, usually only superuser checks are done
  * as normal users are not allowed to access system resources.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: secmodel_suser.c,v 1.17 2009/10/03 00:37:01 elad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: secmodel_suser.c,v 1.18 2009/10/03 01:30:25 elad Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/kauth.h>
 #include <sys/mutex.h>
 #include <sys/mount.h>
 #include <sys/socketvar.h>
 #include <sys/sysctl.h>
 #include <sys/vnode.h>
 #include <sys/proc.h>
 #include <sys/uidinfo.h>
 #include <sys/module.h>
 @@ -613,56 +613,27 @@ secmodel_suser_process_cb(kauth_cred_t c
 			if (isroot)
 				result = KAUTH_RESULT_ALLOW;
 			break;
 		default:
 			break;
+		}
 		break;
+		}
 	case KAUTH_PROCESS_SCHEDULER_GETPARAM:
 		if (isroot || kauth_cred_uidmatch(cred, p->p_cred))
 			result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_PROCESS_SCHEDULER_SETPARAM:
 		if (isroot)
 			result = KAUTH_RESULT_ALLOW;
 		else if (kauth_cred_uidmatch(cred, p->p_cred)) {
 			struct lwp *l;
 			int policy;
 			pri_t priority;
 			l = arg1;
 			policy = (int)(unsigned long)arg2;
 			priority = (pri_t)(unsigned long)arg3;
 			if ((policy == l->l_class ||
 			    (policy != SCHED_FIFO && policy != SCHED_RR)) &&
 			    priority <= l->l_priority)
 				result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_PROCESS_SCHEDULER_GETAFFINITY:
 		result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_PROCESS_SCHEDULER_SETAFFINITY:
 		if (isroot)
 			result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_PROCESS_SETID:
 		if (isroot)
 			result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_PROCESS_STOPFLAG:
 		if (isroot || proc_uidmatch(cred, p->p_cred) == 0) {