Skip site navigation (1)Skip section navigation (2)
Date:      Sun, 21 Jun 2015 16:09:48 +1000 (EST)
From:      Bruce Evans <brde@optusnet.com.au>
To:        Pedro Giffuni <pfg@freebsd.org>
Cc:        Bruce Evans <brde@optusnet.com.au>, Dimitry Andric <dim@freebsd.org>,  David Chisnall <theraven@freebsd.org>, src-committers@freebsd.org,  svn-src-all@freebsd.org, svn-src-head@freebsd.org
Subject:   Re: svn commit: r268137 - head/sys/sys
Message-ID:  <20150621154332.U976@besplex.bde.org>
In-Reply-To: <55861046.4050501@FreeBSD.org>
References:  <201407020845.s628jRG5031824@svn.freebsd.org> <5BE3492F-86A0-4CE3-A27C-8DB5EB662C64@FreeBSD.org> <55842F16.5040608@FreeBSD.org> <D58BE060-870A-4D5E-AE46-D915D9CD6A0C@FreeBSD.org> <20150620023835.N2562@besplex.bde.org> <55861046.4050501@FreeBSD.org>

next in thread | previous in thread | raw e-mail | index | archive | help
On Sat, 20 Jun 2015, Pedro Giffuni wrote:

> On 06/19/15 12:23, Bruce Evans wrote:
>> On Fri, 19 Jun 2015, Dimitry Andric wrote:
>>=20
>>> On 19 Jun 2015, at 17:02, Pedro Giffuni <pfg@freebsd.org> wrote:
>>>>=20
>>>>> On 19/06/2015 05:16 a.m., David Chisnall wrote:
>>>>>> I only just caught this (having seen the fallout from NetBSD doing t=
he=20
>>>>>> same thing in a shipping release and the pain that it=E2=80=99s caus=
ed):
>>>>>> __weak is a reserved keyword in Objective-C, please pick another nam=
e=20
>>>>>> for this.  This in cdefs.h makes it impossible to include any FreeBS=
D=20
>>>>>> standard headers in Objective-C programs (of which we have a couple =
of=20
>>>>>> hundred in ports) if they use any of the modern Objective-C language=
=20
>>>>>> modes.
>>> ...
>>>> Closely related to this, we are redefining _Noreturn, which is a reser=
ved=20
>>>> keyword in C11.
>>>=20
>>> No, sys/cdefs.h has:
>>>=20
>>>   254  /*
>>>   255   * Keywords added in C11.
>>>   256   */
>>>   257
>>>   258  #if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L ||=
=20
>>> defined(lint)
>>> [...]
>>>   284  #if defined(__cplusplus) && __cplusplus >=3D 201103L
>>>   285  #define _Noreturn               [[noreturn]]
>>>   286  #else
>>>   287  #define _Noreturn               __dead2
>>>   288  #endif
>>> [...]
>>>   320  #endif /* __STDC_VERSION__ || __STDC_VERSION__ < 201112L */
>>>=20
>>> So the whole block redefining all the _Xxx identifiers is skipped for
>>> C11 and higher.
>>=20
>> I probably pointed this out incorrectly to Pedro.
>>=20
>> All uses of _Noreturn are still broken, and also ugly.  __dead2 is the
>> gcc-2 compatible version of the gcc-1 compatible macro __dead.  It is
>> syntactically different from __dead and _Noreturn.  It must be placed
>> after the function parameter list instead of in the function type
>> declarator because old versions of gcc only accept attributes there.
>> __dead and presumably _Noreturn must be placed in the function type
>> declarator.  This is incompatible, and also uglier.
>>=20
> I was thinking that _Noreturn can be fixed for older compilers
> less disruptively.
>
> I haven't tested the attached patch the idea is to resurrect
> __dead and use it for _Noreturn.
>
>> Correct version with ugly declarations:
>>=20
>> __dead void
>>     foo(void) __dead2;
>>=20
>
> With the patch we would use:
>
> __Noreturn void
>   foo(void) _dead2;
>
> Which is still ugly but C11-ish.

That asks for the same problems as defining __weak.

Why not just don't use _Noreturn?  It is an unimprovement on the gcc
attribute.  The attribute works at the beginning or end, while Noreturn
only works at the end.  I checked this:

pts/23:bde@freefall:~/s> cc -O -S a.c -std=3Dc11
a.c:3:26: error: '_Noreturn' keyword must precede function declarator
_Noreturn void bar(void) _Noreturn;
                          ^

I also checked if __dead2 works at the beginning in gcc-2.95.4.  It
does, but other headers are broken, so the support for gcc-2.95.4 in
sys/cdefs.h is almost useless:

pts/23:bde@freefall:~/s> gcc295 -O -S a.c
In file included from /usr/include/machine/_types.h:6,
                  from /usr/include/sys/_types.h:33,
                  from /usr/include/x86/endian.h:37,
                  from /usr/include/machine/endian.h:6,
                  from /usr/include/sys/types.h:44,
                  from a.c:1:
/usr/include/x86/_types.h:161: syntax error before `__gnuc_va_list'
/usr/include/x86/_types.h:161: warning: data definition has no type or stor=
age c
lass

Here is the broken part of x86/_types.h:

%%%
#ifdef __GNUCLIKE_BUILTIN_VARARGS
typedef __builtin_va_list=09__va_list;=09/* internally known to gcc */
#elif defined(lint)
typedef char *=09=09=09__va_list;=09/* pretend */
#endif
#if defined(__GNUC_VA_LIST_COMPATIBILITY) && !defined(__GNUC_VA_LIST) \
     && !defined(__NO_GNUC_VA_LIST)
#define __GNUC_VA_LIST
meta: next is line 161:
typedef __va_list=09=09__gnuc_va_list; /* compatibility w/GNU headers*/
#endif
%%%

Despite (rather, because of) mounds of ifdefs to support old gcc, it doesn'=
t
actually work.

<stdarg.h> is honestly broken.  It knows that it depends on the gcc feature
__GNUCLIKE_BUILTIN_STDARG, and aborts with an #error when it is not availab=
le.
All of the _GNUCLIKE_BUILTIN_* macros for variadic args are controlled by
sys/cdefs.h.  They are defined when the compiler is either gcc newer than
gcc-2.95 or is icc.

Bruce
From owner-svn-src-all@FreeBSD.ORG  Sun Jun 21 06:28:31 2015
Return-Path: <owner-svn-src-all@FreeBSD.ORG>
Delivered-To: svn-src-all@hub.freebsd.org
Received: from mx1.freebsd.org (mx1.freebsd.org
 [IPv6:2001:1900:2254:206a::19:1])
 (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits))
 (No client certificate requested)
 by hub.freebsd.org (Postfix) with ESMTPS id 24C5CA5B;
 Sun, 21 Jun 2015 06:28:31 +0000 (UTC)
 (envelope-from trasz@FreeBSD.org)
Received: from svn.freebsd.org (svn.freebsd.org
 [IPv6:2001:1900:2254:2068::e6a:0])
 (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))
 (Client did not present a certificate)
 by mx1.freebsd.org (Postfix) with ESMTPS id 0FC6BF5C;
 Sun, 21 Jun 2015 06:28:31 +0000 (UTC)
 (envelope-from trasz@FreeBSD.org)
Received: from svn.freebsd.org ([127.0.1.70])
 by svn.freebsd.org (8.14.9/8.14.9) with ESMTP id t5L6SVP7045929;
 Sun, 21 Jun 2015 06:28:31 GMT (envelope-from trasz@FreeBSD.org)
Received: (from trasz@localhost)
 by svn.freebsd.org (8.14.9/8.14.9/Submit) id t5L6SRBZ045904;
 Sun, 21 Jun 2015 06:28:27 GMT (envelope-from trasz@FreeBSD.org)
Message-Id: <201506210628.t5L6SRBZ045904@svn.freebsd.org>
X-Authentication-Warning: svn.freebsd.org: trasz set sender to
 trasz@FreeBSD.org using -f
From: Edward Tomasz Napierala <trasz@FreeBSD.org>
Date: Sun, 21 Jun 2015 06:28:27 +0000 (UTC)
To: src-committers@freebsd.org, svn-src-all@freebsd.org,
 svn-src-stable@freebsd.org, svn-src-stable-10@freebsd.org
Subject: svn commit: r284665 - in stable/10: sys/amd64/conf sys/conf
 sys/i386/conf sys/kern sys/pc98/conf sys/powerpc/conf sys/sparc64/conf
 sys/sys sys/vm usr.bin/rctl
X-SVN-Group: stable-10
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-BeenThere: svn-src-all@freebsd.org
X-Mailman-Version: 2.1.20
Precedence: list
List-Id: "SVN commit messages for the entire src tree \(except for &quot;
 user&quot; and &quot; projects&quot; \)" <svn-src-all.freebsd.org>
List-Unsubscribe: <http://lists.freebsd.org/mailman/options/svn-src-all>,
 <mailto:svn-src-all-request@freebsd.org?subject=unsubscribe>
List-Archive: <http://lists.freebsd.org/pipermail/svn-src-all/>;
List-Post: <mailto:svn-src-all@freebsd.org>
List-Help: <mailto:svn-src-all-request@freebsd.org?subject=help>
List-Subscribe: <http://lists.freebsd.org/mailman/listinfo/svn-src-all>,
 <mailto:svn-src-all-request@freebsd.org?subject=subscribe>
X-List-Received-Date: Sun, 21 Jun 2015 06:28:31 -0000

Author: trasz
Date: Sun Jun 21 06:28:26 2015
New Revision: 284665
URL: https://svnweb.freebsd.org/changeset/base/284665

Log:
  MFC r282213:
  
  Add kern.racct.enable tunable and RACCT_DISABLED config option.
  The point of this is to be able to add RACCT (with RACCT_DISABLED)
  to GENERIC, to avoid having to rebuild the kernel to use rctl(8).
  
  MFC r282901:
  
  Build GENERIC with RACCT/RCTL support by default.  Note that it still
  needs to be enabled by adding "kern.racct.enable=1" to /boot/loader.conf.
  
  Note those two are MFC-ed together, because the latter one changes the
  name of RACCT_DISABLED option to RACCT_DEFAULT_TO_DISABLED.  Should have
  committed the renaming separately...
  
  Relnotes:	yes
  Sponsored by:	The FreeBSD Foundation

Modified:
  stable/10/sys/amd64/conf/GENERIC
  stable/10/sys/conf/options
  stable/10/sys/i386/conf/GENERIC
  stable/10/sys/kern/imgact_elf.c
  stable/10/sys/kern/kern_descrip.c
  stable/10/sys/kern/kern_exit.c
  stable/10/sys/kern/kern_jail.c
  stable/10/sys/kern/kern_racct.c
  stable/10/sys/kern/kern_rctl.c
  stable/10/sys/kern/kern_thr.c
  stable/10/sys/kern/sched_4bsd.c
  stable/10/sys/kern/subr_trap.c
  stable/10/sys/kern/sysv_msg.c
  stable/10/sys/kern/sysv_sem.c
  stable/10/sys/kern/sysv_shm.c
  stable/10/sys/pc98/conf/GENERIC
  stable/10/sys/powerpc/conf/GENERIC
  stable/10/sys/sparc64/conf/GENERIC
  stable/10/sys/sys/racct.h
  stable/10/sys/vm/swap_pager.c
  stable/10/sys/vm/vm_map.c
  stable/10/sys/vm/vm_mmap.c
  stable/10/sys/vm/vm_pageout.c
  stable/10/sys/vm/vm_unix.c
  stable/10/usr.bin/rctl/rctl.8
Directory Properties:
  stable/10/   (props changed)

Modified: stable/10/sys/amd64/conf/GENERIC
==============================================================================
--- stable/10/sys/amd64/conf/GENERIC	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/amd64/conf/GENERIC	Sun Jun 21 06:28:26 2015	(r284665)
@@ -72,6 +72,9 @@ options 	KDTRACE_FRAME		# Ensure frames 
 options 	KDTRACE_HOOKS		# Kernel DTrace hooks
 options 	DDB_CTF			# Kernel ELF linker loads CTF data
 options 	INCLUDE_CONFIG_FILE	# Include this file in kernel
+options 	RACCT			# Resource accounting framework
+options 	RACCT_DEFAULT_TO_DISABLED # Set kern.racct.enable=0 by default
+options 	RCTL			# Resource limits
 
 # Debugging support.  Always need this:
 options 	KDB			# Enable kernel debugger support.

Modified: stable/10/sys/conf/options
==============================================================================
--- stable/10/sys/conf/options	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/conf/options	Sun Jun 21 06:28:26 2015	(r284665)
@@ -925,6 +925,7 @@ IPOIB_CM	opt_ofed.h
 
 # Resource Accounting
 RACCT		opt_global.h
+RACCT_DEFAULT_TO_DISABLED	opt_global.h
 
 # Resource Limits
 RCTL		opt_global.h

Modified: stable/10/sys/i386/conf/GENERIC
==============================================================================
--- stable/10/sys/i386/conf/GENERIC	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/i386/conf/GENERIC	Sun Jun 21 06:28:26 2015	(r284665)
@@ -72,6 +72,9 @@ options 	MAC			# TrustedBSD MAC Framewor
 options 	KDTRACE_HOOKS		# Kernel DTrace hooks
 options 	DDB_CTF			# Kernel ELF linker loads CTF data
 options 	INCLUDE_CONFIG_FILE	# Include this file in kernel
+options 	RACCT			# Resource accounting framework
+options 	RACCT_DEFAULT_TO_DISABLED # Set kern.racct.enable=0 by default
+options 	RCTL			# Resource limits
 
 # Debugging support.  Always need this:
 options 	KDB			# Enable kernel debugger support.

Modified: stable/10/sys/kern/imgact_elf.c
==============================================================================
--- stable/10/sys/kern/imgact_elf.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/imgact_elf.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -1231,12 +1231,14 @@ __elfN(coredump)(struct thread *td, stru
 	coresize = round_page(hdrsize + notesz) + seginfo.size;
 
 #ifdef RACCT
-	PROC_LOCK(td->td_proc);
-	error = racct_add(td->td_proc, RACCT_CORE, coresize);
-	PROC_UNLOCK(td->td_proc);
-	if (error != 0) {
-		error = EFAULT;
-		goto done;
+	if (racct_enable) {
+		PROC_LOCK(td->td_proc);
+		error = racct_add(td->td_proc, RACCT_CORE, coresize);
+		PROC_UNLOCK(td->td_proc);
+		if (error != 0) {
+			error = EFAULT;
+			goto done;
+		}
 	}
 #endif
 	if (coresize >= limit) {

Modified: stable/10/sys/kern/kern_descrip.c
==============================================================================
--- stable/10/sys/kern/kern_descrip.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/kern_descrip.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -874,13 +874,15 @@ do_dup(struct thread *td, int flags, int
 			 * the limit on the size of the file descriptor table.
 			 */
 #ifdef RACCT
-			PROC_LOCK(p);
-			error = racct_set(p, RACCT_NOFILE, new + 1);
-			PROC_UNLOCK(p);
-			if (error != 0) {
-				FILEDESC_XUNLOCK(fdp);
-				fdrop(fp, td);
-				return (EMFILE);
+			if (racct_enable) {
+				PROC_LOCK(p);
+				error = racct_set(p, RACCT_NOFILE, new + 1);
+				PROC_UNLOCK(p);
+				if (error != 0) {
+					FILEDESC_XUNLOCK(fdp);
+					fdrop(fp, td);
+					return (EMFILE);
+				}
 			}
 #endif
 			fdgrowtable_exp(fdp, new + 1);
@@ -1641,11 +1643,13 @@ fdalloc(struct thread *td, int minfd, in
 	if (fd >= fdp->fd_nfiles) {
 		allocfd = min(fd * 2, maxfd);
 #ifdef RACCT
-		PROC_LOCK(p);
-		error = racct_set(p, RACCT_NOFILE, allocfd);
-		PROC_UNLOCK(p);
-		if (error != 0)
-			return (EMFILE);
+		if (racct_enable) {
+			PROC_LOCK(p);
+			error = racct_set(p, RACCT_NOFILE, allocfd);
+			PROC_UNLOCK(p);
+			if (error != 0)
+				return (EMFILE);
+		}
 #endif
 		/*
 		 * fd is already equal to first free descriptor >= minfd, so
@@ -2008,9 +2012,11 @@ fdescfree(struct thread *td)
 		return;
 
 #ifdef RACCT
-	PROC_LOCK(td->td_proc);
-	racct_set(td->td_proc, RACCT_NOFILE, 0);
-	PROC_UNLOCK(td->td_proc);
+	if (racct_enable) {
+		PROC_LOCK(td->td_proc);
+		racct_set(td->td_proc, RACCT_NOFILE, 0);
+		PROC_UNLOCK(td->td_proc);
+	}
 #endif
 
 	/* Check for special need to clear POSIX style locks */

Modified: stable/10/sys/kern/kern_exit.c
==============================================================================
--- stable/10/sys/kern/kern_exit.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/kern_exit.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -921,9 +921,11 @@ proc_reap(struct thread *td, struct proc
 	 * Destroy resource accounting information associated with the process.
 	 */
 #ifdef RACCT
-	PROC_LOCK(p);
-	racct_sub(p, RACCT_NPROC, 1);
-	PROC_UNLOCK(p);
+	if (racct_enable) {
+		PROC_LOCK(p);
+		racct_sub(p, RACCT_NPROC, 1);
+		PROC_UNLOCK(p);
+	}
 #endif
 	racct_proc_exit(p);
 

Modified: stable/10/sys/kern/kern_jail.c
==============================================================================
--- stable/10/sys/kern/kern_jail.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/kern_jail.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -1787,7 +1787,7 @@ kern_jail_set(struct thread *td, struct 
 	mtx_unlock(&pr->pr_mtx);
 
 #ifdef RACCT
-	if (created)
+	if (racct_enable && created)
 		prison_racct_attach(pr);
 #endif
 
@@ -1871,7 +1871,7 @@ kern_jail_set(struct thread *td, struct 
 	}
 
 #ifdef RACCT
-	if (!created) {
+	if (racct_enable && !created) {
 		if (!(flags & JAIL_ATTACH))
 			sx_sunlock(&allprison_lock);
 		prison_racct_modify(pr);
@@ -2661,7 +2661,8 @@ prison_deref(struct prison *pr, int flag
 			cpuset_rel(pr->pr_cpuset);
 		osd_jail_exit(pr);
 #ifdef RACCT
-		prison_racct_detach(pr);
+		if (racct_enable)
+			prison_racct_detach(pr);
 #endif
 		free(pr, M_PRISON);
 
@@ -4482,12 +4483,15 @@ SYSCTL_JAIL_PARAM(_allow_mount, tmpfs, C
 SYSCTL_JAIL_PARAM(_allow_mount, zfs, CTLTYPE_INT | CTLFLAG_RW,
     "B", "Jail may mount the zfs file system");
 
+#ifdef RACCT
 void
 prison_racct_foreach(void (*callback)(struct racct *racct,
     void *arg2, void *arg3), void *arg2, void *arg3)
 {
 	struct prison_racct *prr;
 
+	ASSERT_RACCT_ENABLED();
+
 	sx_slock(&allprison_lock);
 	LIST_FOREACH(prr, &allprison_racct, prr_next)
 		(callback)(prr->prr_racct, arg2, arg3);
@@ -4499,6 +4503,7 @@ prison_racct_find_locked(const char *nam
 {
 	struct prison_racct *prr;
 
+	ASSERT_RACCT_ENABLED();
 	sx_assert(&allprison_lock, SA_XLOCKED);
 
 	if (name[0] == '\0' || strlen(name) >= MAXHOSTNAMELEN)
@@ -4529,6 +4534,8 @@ prison_racct_find(const char *name)
 {
 	struct prison_racct *prr;
 
+	ASSERT_RACCT_ENABLED();
+
 	sx_xlock(&allprison_lock);
 	prr = prison_racct_find_locked(name);
 	sx_xunlock(&allprison_lock);
@@ -4539,6 +4546,8 @@ void
 prison_racct_hold(struct prison_racct *prr)
 {
 
+	ASSERT_RACCT_ENABLED();
+
 	refcount_acquire(&prr->prr_refcount);
 }
 
@@ -4546,6 +4555,7 @@ static void
 prison_racct_free_locked(struct prison_racct *prr)
 {
 
+	ASSERT_RACCT_ENABLED();
 	sx_assert(&allprison_lock, SA_XLOCKED);
 
 	if (refcount_release(&prr->prr_refcount)) {
@@ -4560,6 +4570,7 @@ prison_racct_free(struct prison_racct *p
 {
 	int old;
 
+	ASSERT_RACCT_ENABLED();
 	sx_assert(&allprison_lock, SA_UNLOCKED);
 
 	old = prr->prr_refcount;
@@ -4571,12 +4582,12 @@ prison_racct_free(struct prison_racct *p
 	sx_xunlock(&allprison_lock);
 }
 
-#ifdef RACCT
 static void
 prison_racct_attach(struct prison *pr)
 {
 	struct prison_racct *prr;
 
+	ASSERT_RACCT_ENABLED();
 	sx_assert(&allprison_lock, SA_XLOCKED);
 
 	prr = prison_racct_find_locked(pr->pr_name);
@@ -4596,6 +4607,8 @@ prison_racct_modify(struct prison *pr)
 	struct ucred *cred;
 	struct prison_racct *oldprr;
 
+	ASSERT_RACCT_ENABLED();
+
 	sx_slock(&allproc_lock);
 	sx_xlock(&allprison_lock);
 
@@ -4635,6 +4648,7 @@ static void
 prison_racct_detach(struct prison *pr)
 {
 
+	ASSERT_RACCT_ENABLED();
 	sx_assert(&allprison_lock, SA_UNLOCKED);
 
 	if (pr->pr_prison_racct == NULL)

Modified: stable/10/sys/kern/kern_racct.c
==============================================================================
--- stable/10/sys/kern/kern_racct.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/kern_racct.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -71,8 +71,15 @@ FEATURE(racct, "Resource Accounting");
  * Do not block processes that have their %cpu usage <= pcpu_threshold.
  */
 static int pcpu_threshold = 1;
+#ifdef RACCT_DEFAULT_TO_DISABLED
+int racct_enable = 0;
+#else
+int racct_enable = 1;
+#endif
 
 SYSCTL_NODE(_kern, OID_AUTO, racct, CTLFLAG_RW, 0, "Resource Accounting");
+SYSCTL_UINT(_kern_racct, OID_AUTO, enable, CTLFLAG_RDTUN, &racct_enable,
+    0, "Enable RACCT/RCTL");
 SYSCTL_UINT(_kern_racct, OID_AUTO, pcpu_threshold, CTLFLAG_RW, &pcpu_threshold,
     0, "Processes with higher %cpu usage than this value can be throttled.");
 
@@ -314,6 +321,8 @@ racct_getpcpu(struct proc *p, u_int pcpu
 	fixpt_t p_pctcpu;
 	struct thread *td;
 
+	ASSERT_RACCT_ENABLED();
+
 	/*
 	 * If the process is swapped out, we count its %cpu usage as zero.
 	 * This behaviour is consistent with the userland ps(1) tool.
@@ -378,6 +387,7 @@ racct_add_racct(struct racct *dest, cons
 {
 	int i;
 
+	ASSERT_RACCT_ENABLED();
 	mtx_assert(&racct_lock, MA_OWNED);
 
 	/*
@@ -399,6 +409,7 @@ racct_sub_racct(struct racct *dest, cons
 {
 	int i;
 
+	ASSERT_RACCT_ENABLED();
 	mtx_assert(&racct_lock, MA_OWNED);
 
 	/*
@@ -432,6 +443,9 @@ void
 racct_create(struct racct **racctp)
 {
 
+	if (!racct_enable)
+		return;
+
 	SDT_PROBE(racct, kernel, racct, create, racctp, 0, 0, 0, 0);
 
 	KASSERT(*racctp == NULL, ("racct already allocated"));
@@ -445,6 +459,8 @@ racct_destroy_locked(struct racct **racc
 	int i;
 	struct racct *racct;
 
+	ASSERT_RACCT_ENABLED();
+
 	SDT_PROBE(racct, kernel, racct, destroy, racctp, 0, 0, 0, 0);
 
 	mtx_assert(&racct_lock, MA_OWNED);
@@ -471,6 +487,9 @@ void
 racct_destroy(struct racct **racct)
 {
 
+	if (!racct_enable)
+		return;
+
 	mtx_lock(&racct_lock);
 	racct_destroy_locked(racct);
 	mtx_unlock(&racct_lock);
@@ -486,6 +505,7 @@ racct_alloc_resource(struct racct *racct
     uint64_t amount)
 {
 
+	ASSERT_RACCT_ENABLED();
 	mtx_assert(&racct_lock, MA_OWNED);
 	KASSERT(racct != NULL, ("NULL racct"));
 
@@ -517,6 +537,8 @@ racct_add_locked(struct proc *p, int res
 	int error;
 #endif
 
+	ASSERT_RACCT_ENABLED();
+
 	SDT_PROBE(racct, kernel, rusage, add, p, resource, amount, 0, 0);
 
 	/*
@@ -547,6 +569,9 @@ racct_add(struct proc *p, int resource, 
 {
 	int error;
 
+	if (!racct_enable)
+		return (0);
+
 	mtx_lock(&racct_lock);
 	error = racct_add_locked(p, resource, amount);
 	mtx_unlock(&racct_lock);
@@ -558,6 +583,8 @@ racct_add_cred_locked(struct ucred *cred
 {
 	struct prison *pr;
 
+	ASSERT_RACCT_ENABLED();
+
 	SDT_PROBE(racct, kernel, rusage, add__cred, cred, resource, amount,
 	    0, 0);
 
@@ -578,6 +605,9 @@ void
 racct_add_cred(struct ucred *cred, int resource, uint64_t amount)
 {
 
+	if (!racct_enable)
+		return;
+
 	mtx_lock(&racct_lock);
 	racct_add_cred_locked(cred, resource, amount);
 	mtx_unlock(&racct_lock);
@@ -591,6 +621,9 @@ void
 racct_add_force(struct proc *p, int resource, uint64_t amount)
 {
 
+	if (!racct_enable)
+		return;
+
 	SDT_PROBE(racct, kernel, rusage, add__force, p, resource, amount, 0, 0);
 
 	/*
@@ -613,6 +646,8 @@ racct_set_locked(struct proc *p, int res
 	int error;
 #endif
 
+	ASSERT_RACCT_ENABLED();
+
 	SDT_PROBE(racct, kernel, rusage, set, p, resource, amount, 0, 0);
 
 	/*
@@ -672,6 +707,9 @@ racct_set(struct proc *p, int resource, 
 {
 	int error;
 
+	if (!racct_enable)
+		return (0);
+
 	mtx_lock(&racct_lock);
 	error = racct_set_locked(p, resource, amount);
 	mtx_unlock(&racct_lock);
@@ -684,6 +722,8 @@ racct_set_force_locked(struct proc *p, i
 	int64_t old_amount, decayed_amount;
 	int64_t diff_proc, diff_cred;
 
+	ASSERT_RACCT_ENABLED();
+
 	SDT_PROBE(racct, kernel, rusage, set, p, resource, amount, 0, 0);
 
 	/*
@@ -718,6 +758,10 @@ racct_set_force_locked(struct proc *p, i
 void
 racct_set_force(struct proc *p, int resource, uint64_t amount)
 {
+
+	if (!racct_enable)
+		return;
+
 	mtx_lock(&racct_lock);
 	racct_set_force_locked(p, resource, amount);
 	mtx_unlock(&racct_lock);
@@ -733,6 +777,9 @@ uint64_t
 racct_get_limit(struct proc *p, int resource)
 {
 
+	if (!racct_enable)
+		return (UINT64_MAX);
+
 #ifdef RCTL
 	return (rctl_get_limit(p, resource));
 #else
@@ -750,6 +797,9 @@ uint64_t
 racct_get_available(struct proc *p, int resource)
 {
 
+	if (!racct_enable)
+		return (UINT64_MAX);
+
 #ifdef RCTL
 	return (rctl_get_available(p, resource));
 #else
@@ -766,6 +816,8 @@ static int64_t
 racct_pcpu_available(struct proc *p)
 {
 
+	ASSERT_RACCT_ENABLED();
+
 #ifdef RCTL
 	return (rctl_pcpu_available(p));
 #else
@@ -780,6 +832,9 @@ void
 racct_sub(struct proc *p, int resource, uint64_t amount)
 {
 
+	if (!racct_enable)
+		return;
+
 	SDT_PROBE(racct, kernel, rusage, sub, p, resource, amount, 0, 0);
 
 	/*
@@ -805,6 +860,8 @@ racct_sub_cred_locked(struct ucred *cred
 {
 	struct prison *pr;
 
+	ASSERT_RACCT_ENABLED();
+
 	SDT_PROBE(racct, kernel, rusage, sub__cred, cred, resource, amount,
 	    0, 0);
 
@@ -828,6 +885,9 @@ void
 racct_sub_cred(struct ucred *cred, int resource, uint64_t amount)
 {
 
+	if (!racct_enable)
+		return;
+
 	mtx_lock(&racct_lock);
 	racct_sub_cred_locked(cred, resource, amount);
 	mtx_unlock(&racct_lock);
@@ -841,6 +901,9 @@ racct_proc_fork(struct proc *parent, str
 {
 	int i, error = 0;
 
+	if (!racct_enable)
+		return (0);
+
 	/*
 	 * Create racct for the child process.
 	 */
@@ -897,6 +960,9 @@ racct_proc_fork_done(struct proc *child)
 {
 
 #ifdef RCTL
+	if (!racct_enable)
+		return;
+
 	PROC_LOCK(child);
 	mtx_lock(&racct_lock);
 	rctl_enforce(child, RACCT_NPROC, 0);
@@ -914,6 +980,9 @@ racct_proc_exit(struct proc *p)
 	struct timeval wallclock;
 	uint64_t pct_estimate, pct;
 
+	if (!racct_enable)
+		return;
+
 	PROC_LOCK(p);
 	/*
 	 * We don't need to calculate rux, proc_reap() has already done this.
@@ -968,6 +1037,9 @@ racct_proc_ucred_changed(struct proc *p,
 	struct loginclass *oldlc, *newlc;
 	struct prison *oldpr, *newpr, *pr;
 
+	if (!racct_enable)
+		return;
+
 	PROC_LOCK_ASSERT(p, MA_NOTOWNED);
 
 	newuip = newcred->cr_ruidinfo;
@@ -1005,6 +1077,8 @@ void
 racct_move(struct racct *dest, struct racct *src)
 {
 
+	ASSERT_RACCT_ENABLED();
+
 	mtx_lock(&racct_lock);
 
 	racct_add_racct(dest, src);
@@ -1021,6 +1095,7 @@ racct_proc_throttle(struct proc *p)
 	int cpuid;
 #endif
 
+	ASSERT_RACCT_ENABLED();
 	PROC_LOCK_ASSERT(p, MA_OWNED);
 
 	/*
@@ -1066,6 +1141,9 @@ racct_proc_throttle(struct proc *p)
 static void
 racct_proc_wakeup(struct proc *p)
 {
+
+	ASSERT_RACCT_ENABLED();
+
 	PROC_LOCK_ASSERT(p, MA_OWNED);
 
 	if (p->p_throttled) {
@@ -1080,6 +1158,8 @@ racct_decay_resource(struct racct *racct
 	int resource;
 	int64_t r_old, r_new;
 
+	ASSERT_RACCT_ENABLED();
+
 	resource = *(int *)res;
 	r_old = racct->r_resources[resource];
 
@@ -1096,6 +1176,9 @@ racct_decay_resource(struct racct *racct
 static void
 racct_decay(int resource)
 {
+
+	ASSERT_RACCT_ENABLED();
+
 	ui_racct_foreach(racct_decay_resource, &resource, NULL);
 	loginclass_racct_foreach(racct_decay_resource, &resource, NULL);
 	prison_racct_foreach(racct_decay_resource, &resource, NULL);
@@ -1110,6 +1193,8 @@ racctd(void)
 	uint64_t runtime;
 	uint64_t pct, pct_estimate;
 
+	ASSERT_RACCT_ENABLED();
+
 	for (;;) {
 		racct_decay(RACCT_PCTCPU);
 
@@ -1189,11 +1274,22 @@ static struct kproc_desc racctd_kp = {
 	racctd,
 	NULL
 };
-SYSINIT(racctd, SI_SUB_RACCTD, SI_ORDER_FIRST, kproc_start, &racctd_kp);
+
+static void
+racctd_init(void)
+{
+	if (!racct_enable)
+		return;
+
+	kproc_start(&racctd_kp);
+}
+SYSINIT(racctd, SI_SUB_RACCTD, SI_ORDER_FIRST, racctd_init, NULL);
 
 static void
 racct_init(void)
 {
+	if (!racct_enable)
+		return;
 
 	racct_zone = uma_zcreate("racct", sizeof(struct racct),
 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);

Modified: stable/10/sys/kern/kern_rctl.c
==============================================================================
--- stable/10/sys/kern/kern_rctl.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/kern_rctl.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -225,6 +225,7 @@ rctl_available_resource(const struct pro
 	int64_t available = INT64_MAX;
 	struct ucred *cred = p->p_ucred;
 
+	ASSERT_RACCT_ENABLED();
 	rw_assert(&rctl_lock, RA_LOCKED);
 
 	resource = rule->rr_resource;
@@ -264,6 +265,8 @@ rctl_would_exceed(const struct proc *p, 
 {
 	int64_t available;
 
+	ASSERT_RACCT_ENABLED();
+
 	rw_assert(&rctl_lock, RA_LOCKED);
 
 	available = rctl_available_resource(p, rule);
@@ -283,6 +286,8 @@ rctl_pcpu_available(const struct proc *p
 	struct rctl_rule_link *link;
 	int64_t available, minavailable, limit;
 
+	ASSERT_RACCT_ENABLED();
+
 	minavailable = INT64_MAX;
 	limit = 0;
 
@@ -334,6 +339,8 @@ rctl_enforce(struct proc *p, int resourc
 	static int curtime = 0;
 	static struct timeval lasttime;
 
+	ASSERT_RACCT_ENABLED();
+
 	rw_rlock(&rctl_lock);
 
 	/*
@@ -457,6 +464,8 @@ rctl_get_limit(struct proc *p, int resou
 	struct rctl_rule_link *link;
 	uint64_t amount = UINT64_MAX;
 
+	ASSERT_RACCT_ENABLED();
+
 	rw_rlock(&rctl_lock);
 
 	/*
@@ -487,6 +496,8 @@ rctl_get_available(struct proc *p, int r
 
 	minavailable = INT64_MAX;
 
+	ASSERT_RACCT_ENABLED();
+
 	rw_rlock(&rctl_lock);
 
 	/*
@@ -521,6 +532,8 @@ static int
 rctl_rule_matches(const struct rctl_rule *rule, const struct rctl_rule *filter)
 {
 
+	ASSERT_RACCT_ENABLED();
+
 	if (filter->rr_subject_type != RCTL_SUBJECT_TYPE_UNDEFINED) {
 		if (rule->rr_subject_type != filter->rr_subject_type)
 			return (0);
@@ -635,6 +648,7 @@ rctl_racct_add_rule(struct racct *racct,
 {
 	struct rctl_rule_link *link;
 
+	ASSERT_RACCT_ENABLED();
 	KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));
 
 	rctl_rule_acquire(rule);
@@ -652,6 +666,7 @@ rctl_racct_add_rule_locked(struct racct 
 {
 	struct rctl_rule_link *link;
 
+	ASSERT_RACCT_ENABLED();
 	KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));
 	rw_assert(&rctl_lock, RA_WLOCKED);
 
@@ -678,6 +693,7 @@ rctl_racct_remove_rules(struct racct *ra
 	int removed = 0;
 	struct rctl_rule_link *link, *linktmp;
 
+	ASSERT_RACCT_ENABLED();
 	rw_assert(&rctl_lock, RA_WLOCKED);
 
 	LIST_FOREACH_SAFE(link, &racct->r_rule_links, rrl_next, linktmp) {
@@ -696,6 +712,8 @@ static void
 rctl_rule_acquire_subject(struct rctl_rule *rule)
 {
 
+	ASSERT_RACCT_ENABLED();
+
 	switch (rule->rr_subject_type) {
 	case RCTL_SUBJECT_TYPE_UNDEFINED:
 	case RCTL_SUBJECT_TYPE_PROCESS:
@@ -722,6 +740,8 @@ static void
 rctl_rule_release_subject(struct rctl_rule *rule)
 {
 
+	ASSERT_RACCT_ENABLED();
+
 	switch (rule->rr_subject_type) {
 	case RCTL_SUBJECT_TYPE_UNDEFINED:
 	case RCTL_SUBJECT_TYPE_PROCESS:
@@ -749,6 +769,8 @@ rctl_rule_alloc(int flags)
 {
 	struct rctl_rule *rule;
 
+	ASSERT_RACCT_ENABLED();
+
 	rule = uma_zalloc(rctl_rule_zone, flags);
 	if (rule == NULL)
 		return (NULL);
@@ -771,6 +793,8 @@ rctl_rule_duplicate(const struct rctl_ru
 {
 	struct rctl_rule *copy;
 
+	ASSERT_RACCT_ENABLED();
+
 	copy = uma_zalloc(rctl_rule_zone, flags);
 	if (copy == NULL)
 		return (NULL);
@@ -793,6 +817,7 @@ void
 rctl_rule_acquire(struct rctl_rule *rule)
 {
 
+	ASSERT_RACCT_ENABLED();
 	KASSERT(rule->rr_refcount > 0, ("rule->rr_refcount <= 0"));
 
 	refcount_acquire(&rule->rr_refcount);
@@ -805,6 +830,7 @@ rctl_rule_free(void *context, int pendin
 	
 	rule = (struct rctl_rule *)context;
 
+	ASSERT_RACCT_ENABLED();
 	KASSERT(rule->rr_refcount == 0, ("rule->rr_refcount != 0"));
 	
 	/*
@@ -819,6 +845,7 @@ void
 rctl_rule_release(struct rctl_rule *rule)
 {
 
+	ASSERT_RACCT_ENABLED();
 	KASSERT(rule->rr_refcount > 0, ("rule->rr_refcount <= 0"));
 
 	if (refcount_release(&rule->rr_refcount)) {
@@ -838,6 +865,8 @@ static int
 rctl_rule_fully_specified(const struct rctl_rule *rule)
 {
 
+	ASSERT_RACCT_ENABLED();
+
 	switch (rule->rr_subject_type) {
 	case RCTL_SUBJECT_TYPE_UNDEFINED:
 		return (0);
@@ -882,6 +911,8 @@ rctl_string_to_rule(char *rulestr, struc
 	struct rctl_rule *rule;
 	id_t id;
 
+	ASSERT_RACCT_ENABLED();
+
 	rule = rctl_rule_alloc(M_WAITOK);
 
 	subjectstr = strsep(&rulestr, ":");
@@ -1008,6 +1039,7 @@ rctl_rule_add(struct rctl_rule *rule)
 	struct rctl_rule *rule2;
 	int match;
 
+	ASSERT_RACCT_ENABLED();
 	KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));
 
 	/*
@@ -1118,6 +1150,8 @@ rctl_rule_remove_callback(struct racct *
 	struct rctl_rule *filter = (struct rctl_rule *)arg2;
 	int found = 0;
 
+	ASSERT_RACCT_ENABLED();
+
 	rw_wlock(&rctl_lock);
 	found += rctl_racct_remove_rules(racct, filter);
 	rw_wunlock(&rctl_lock);
@@ -1134,6 +1168,8 @@ rctl_rule_remove(struct rctl_rule *filte
 	int found = 0;
 	struct proc *p;
 
+	ASSERT_RACCT_ENABLED();
+
 	if (filter->rr_subject_type == RCTL_SUBJECT_TYPE_PROCESS &&
 	    filter->rr_subject.rs_proc != NULL) {
 		p = filter->rr_subject.rs_proc;
@@ -1172,6 +1208,8 @@ rctl_rule_to_sbuf(struct sbuf *sb, const
 {
 	int64_t amount;
 
+	ASSERT_RACCT_ENABLED();
+
 	sbuf_printf(sb, "%s:", rctl_subject_type_name(rule->rr_subject_type));
 
 	switch (rule->rr_subject_type) {
@@ -1231,6 +1269,8 @@ rctl_read_inbuf(char **inputstr, const c
 	int error;
 	char *str;
 
+	ASSERT_RACCT_ENABLED();
+
 	if (inbuflen <= 0)
 		return (EINVAL);
 	if (inbuflen > RCTL_MAX_INBUFLEN)
@@ -1256,6 +1296,8 @@ rctl_write_outbuf(struct sbuf *outputsbu
 {
 	int error;
 
+	ASSERT_RACCT_ENABLED();
+
 	if (outputsbuf == NULL)
 		return (0);
 
@@ -1277,6 +1319,8 @@ rctl_racct_to_sbuf(struct racct *racct, 
 	int64_t amount;
 	struct sbuf *sb;
 
+	ASSERT_RACCT_ENABLED();
+
 	sb = sbuf_new_auto();
 	for (i = 0; i <= RACCT_MAX; i++) {
 		if (sloppy == 0 && RACCT_IS_SLOPPY(i))
@@ -1302,6 +1346,9 @@ sys_rctl_get_racct(struct thread *td, st
 	struct loginclass *lc;
 	struct prison_racct *prr;
 
+	if (!racct_enable)
+		return (ENOSYS);
+
 	error = priv_check(td, PRIV_RCTL_GET_RACCT);
 	if (error != 0)
 		return (error);
@@ -1372,6 +1419,8 @@ rctl_get_rules_callback(struct racct *ra
 	struct rctl_rule_link *link;
 	struct sbuf *sb = (struct sbuf *)arg3;
 
+	ASSERT_RACCT_ENABLED();
+
 	rw_rlock(&rctl_lock);
 	LIST_FOREACH(link, &racct->r_rule_links, rrl_next) {
 		if (!rctl_rule_matches(link->rrl_rule, filter))
@@ -1393,6 +1442,9 @@ sys_rctl_get_rules(struct thread *td, st
 	struct rctl_rule_link *link;
 	struct proc *p;
 
+	if (!racct_enable)
+		return (ENOSYS);
+
 	error = priv_check(td, PRIV_RCTL_GET_RULES);
 	if (error != 0)
 		return (error);
@@ -1467,6 +1519,9 @@ sys_rctl_get_limits(struct thread *td, s
 	struct rctl_rule *filter;
 	struct rctl_rule_link *link;
 
+	if (!racct_enable)
+		return (ENOSYS);
+
 	error = priv_check(td, PRIV_RCTL_GET_LIMITS);
 	if (error != 0)
 		return (error);
@@ -1538,6 +1593,9 @@ sys_rctl_add_rule(struct thread *td, str
 	struct rctl_rule *rule;
 	char *inputstr;
 
+	if (!racct_enable)
+		return (ENOSYS);
+
 	error = priv_check(td, PRIV_RCTL_ADD_RULE);
 	if (error != 0)
 		return (error);
@@ -1580,6 +1638,9 @@ sys_rctl_remove_rule(struct thread *td, 
 	struct rctl_rule *filter;
 	char *inputstr;
 
+	if (!racct_enable)
+		return (ENOSYS);
+
 	error = priv_check(td, PRIV_RCTL_REMOVE_RULE);
 	if (error != 0)
 		return (error);
@@ -1616,6 +1677,8 @@ rctl_proc_ucred_changed(struct proc *p, 
 	struct prison_racct *newprr;
 	LIST_HEAD(, rctl_rule_link) newrules;
 
+	ASSERT_RACCT_ENABLED();
+
 	newuip = newcred->cr_ruidinfo;
 	newlc = newcred->cr_loginclass;
 	newprr = newcred->cr_prison->pr_prison_racct;
@@ -1756,6 +1819,7 @@ rctl_proc_fork(struct proc *parent, stru
 
 	LIST_INIT(&child->p_racct->r_rule_links);
 
+	ASSERT_RACCT_ENABLED();
 	KASSERT(parent->p_racct != NULL, ("process without racct; p = %p", parent));
 
 	rw_wlock(&rctl_lock);
@@ -1809,6 +1873,8 @@ rctl_racct_release(struct racct *racct)
 {
 	struct rctl_rule_link *link;
 
+	ASSERT_RACCT_ENABLED();
+
 	rw_wlock(&rctl_lock);
 	while (!LIST_EMPTY(&racct->r_rule_links)) {
 		link = LIST_FIRST(&racct->r_rule_links);
@@ -1823,6 +1889,9 @@ static void
 rctl_init(void)
 {
 
+	if (!racct_enable)
+		return;
+
 	rctl_rule_link_zone = uma_zcreate("rctl_rule_link",
 	    sizeof(struct rctl_rule_link), NULL, NULL, NULL, NULL,
 	    UMA_ALIGN_PTR, UMA_ZONE_NOFREE);

Modified: stable/10/sys/kern/kern_thr.c
==============================================================================
--- stable/10/sys/kern/kern_thr.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/kern_thr.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -281,9 +281,11 @@ create_thread(struct thread *td, mcontex
 
 fail:
 #ifdef RACCT
-	PROC_LOCK(p);
-	racct_sub(p, RACCT_NTHR, 1);
-	PROC_UNLOCK(p);
+	if (racct_enable) {
+		PROC_LOCK(p);
+		racct_sub(p, RACCT_NTHR, 1);
+		PROC_UNLOCK(p);
+	}
 #endif
 	return (error);
 }

Modified: stable/10/sys/kern/sched_4bsd.c
==============================================================================
--- stable/10/sys/kern/sched_4bsd.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/sched_4bsd.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -1586,7 +1586,7 @@ sched_pctcpu(struct thread *td)
 	return (ts->ts_pctcpu);
 }
 
-#ifdef	RACCT
+#ifdef RACCT
 /*
  * Calculates the contribution to the thread cpu usage for the latest
  * (unfinished) second.

Modified: stable/10/sys/kern/subr_trap.c
==============================================================================
--- stable/10/sys/kern/subr_trap.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/subr_trap.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -60,6 +60,7 @@ __FBSDID("$FreeBSD$");
 #include <sys/ktr.h>
 #include <sys/pioctl.h>
 #include <sys/ptrace.h>
+#include <sys/racct.h>
 #include <sys/resourcevar.h>
 #include <sys/sched.h>
 #include <sys/signalvar.h>
@@ -177,11 +178,13 @@ userret(struct thread *td, struct trapfr
 	    __func__, td, p->p_pid, td->td_name, curvnet,
 	    (td->td_vnet_lpush != NULL) ? td->td_vnet_lpush : "N/A"));
 #endif
-#ifdef	RACCT
-	PROC_LOCK(p);
-	while (p->p_throttled == 1)
-		msleep(p->p_racct, &p->p_mtx, 0, "racct", 0);
-	PROC_UNLOCK(p);
+#ifdef RACCT
+	if (racct_enable) {
+		PROC_LOCK(p);
+		while (p->p_throttled == 1)
+			msleep(p->p_racct, &p->p_mtx, 0, "racct", 0);
+		PROC_UNLOCK(p);
+	}
 #endif
 }
 

Modified: stable/10/sys/kern/sysv_msg.c
==============================================================================
--- stable/10/sys/kern/sysv_msg.c	Sun Jun 21 06:05:33 2015	(r284664)
+++ stable/10/sys/kern/sysv_msg.c	Sun Jun 21 06:28:26 2015	(r284665)
@@ -623,12 +623,14 @@ sys_msgget(td, uap)
 			goto done2;
 		}
 #ifdef RACCT
-		PROC_LOCK(td->td_proc);
-		error = racct_add(td->td_proc, RACCT_NMSGQ, 1);
-		PROC_UNLOCK(td->td_proc);
-		if (error != 0) {
-			error = ENOSPC;
-			goto done2;
+		if (racct_enable) {
+			PROC_LOCK(td->td_proc);
+			error = racct_add(td->td_proc, RACCT_NMSGQ, 1);
+			PROC_UNLOCK(td->td_proc);
+			if (error != 0) {
+				error = ENOSPC;
+				goto done2;
+			}
 		}
 #endif
 		DPRINTF(("msqid %d is available\n", msqid));
@@ -730,20 +732,22 @@ kern_msgsnd(td, msqid, msgp, msgsz, msgf

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?20150621154332.U976>