D2369.id5002.diff
No OneTemporary
Actions

Size

37 KB

Referenced Files

None

Subscribers

None

D2369.id5002.diff
View Options

	Index: sys/conf/options
	===================================================================
	--- sys/conf/options
	+++ sys/conf/options
	@@ -928,6 +928,7 @@

	# Resource Accounting
	RACCT opt_global.h
	+RACCT_DISABLED opt_global.h

	# Resource Limits
	RCTL opt_global.h
	Index: sys/kern/imgact_elf.c
	===================================================================
	--- sys/kern/imgact_elf.c
	+++ sys/kern/imgact_elf.c
	@@ -1238,12 +1238,14 @@
	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) {
	Index: sys/kern/kern_descrip.c
	===================================================================
	--- sys/kern/kern_descrip.c
	+++ sys/kern/kern_descrip.c
	@@ -857,13 +857,15 @@
	* 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);
	@@ -1631,11 +1633,13 @@
	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
	@@ -2042,9 +2046,11 @@
	MPASS(fdp != NULL);

	#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

	if (td->td_proc->p_fdtol != NULL)
	Index: sys/kern/kern_exit.c
	===================================================================
	--- sys/kern/kern_exit.c
	+++ sys/kern/kern_exit.c
	@@ -907,9 +907,11 @@
	* 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);

	Index: sys/kern/kern_jail.c
	===================================================================
	--- sys/kern/kern_jail.c
	+++ sys/kern/kern_jail.c
	@@ -1778,7 +1778,7 @@
	mtx_unlock(&pr->pr_mtx);

	#ifdef RACCT
	- if (created)
	+ if (racct_enable && created)
	prison_racct_attach(pr);
	#endif

	@@ -1862,7 +1862,7 @@
	}

	#ifdef RACCT
	- if (!created) {
	+ if (racct_enable && !created) {
	if (!(flags & JAIL_ATTACH))
	sx_sunlock(&allprison_lock);
	prison_racct_modify(pr);
	@@ -2652,7 +2652,8 @@
	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);

	@@ -4460,12 +4461,15 @@
	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;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	sx_slock(&allprison_lock);
	LIST_FOREACH(prr, &allprison_racct, prr_next)
	(callback)(prr->prr_racct, arg2, arg3);
	@@ -4477,6 +4481,7 @@
	{
	struct prison_racct *prr;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	sx_assert(&allprison_lock, SA_XLOCKED);

	if (name[0] == '\0' \|\| strlen(name) >= MAXHOSTNAMELEN)
	@@ -4507,6 +4512,8 @@
	{
	struct prison_racct *prr;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	sx_xlock(&allprison_lock);
	prr = prison_racct_find_locked(name);
	sx_xunlock(&allprison_lock);
	@@ -4517,6 +4524,8 @@
	prison_racct_hold(struct prison_racct *prr)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	refcount_acquire(&prr->prr_refcount);
	}

	@@ -4524,6 +4533,7 @@
	prison_racct_free_locked(struct prison_racct *prr)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	sx_assert(&allprison_lock, SA_XLOCKED);

	if (refcount_release(&prr->prr_refcount)) {
	@@ -4538,6 +4548,7 @@
	{
	int old;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	sx_assert(&allprison_lock, SA_UNLOCKED);

	old = prr->prr_refcount;
	@@ -4549,12 +4560,12 @@
	sx_xunlock(&allprison_lock);
	}

	-#ifdef RACCT
	static void
	prison_racct_attach(struct prison *pr)
	{
	struct prison_racct *prr;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	sx_assert(&allprison_lock, SA_XLOCKED);

	prr = prison_racct_find_locked(pr->pr_name);
	@@ -4574,6 +4585,8 @@
	struct ucred *cred;
	struct prison_racct *oldprr;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	sx_slock(&allproc_lock);
	sx_xlock(&allprison_lock);

	@@ -4613,6 +4626,7 @@
	prison_racct_detach(struct prison *pr)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	sx_assert(&allprison_lock, SA_UNLOCKED);

	if (pr->pr_prison_racct == NULL)
	Index: sys/kern/kern_racct.c
	===================================================================
	--- sys/kern/kern_racct.c
	+++ sys/kern/kern_racct.c
	@@ -70,8 +70,15 @@
	* Do not block processes that have their %cpu usage <= pcpu_threshold.
	*/
	static int pcpu_threshold = 1;
	+#ifdef RACCT_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.");

	@@ -313,6 +320,8 @@
	fixpt_t p_pctcpu;
	struct thread *td;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	/*
	* If the process is swapped out, we count its %cpu usage as zero.
	* This behaviour is consistent with the userland ps(1) tool.
	@@ -377,6 +386,7 @@
	{
	int i;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	mtx_assert(&racct_lock, MA_OWNED);

	/*
	@@ -398,6 +408,7 @@
	{
	int i;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	mtx_assert(&racct_lock, MA_OWNED);

	/*
	@@ -431,6 +442,9 @@
	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"));
	@@ -444,6 +458,8 @@
	int i;
	struct racct *racct;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	SDT_PROBE(racct, kernel, racct, destroy, racctp, 0, 0, 0, 0);

	mtx_assert(&racct_lock, MA_OWNED);
	@@ -470,6 +486,9 @@
	racct_destroy(struct racct **racct)
	{

	+ if (!racct_enable)
	+ return;
	+
	mtx_lock(&racct_lock);
	racct_destroy_locked(racct);
	mtx_unlock(&racct_lock);
	@@ -485,6 +504,7 @@
	uint64_t amount)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	mtx_assert(&racct_lock, MA_OWNED);
	KASSERT(racct != NULL, ("NULL racct"));

	@@ -516,6 +536,8 @@
	int error;
	#endif

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	SDT_PROBE(racct, kernel, rusage, add, p, resource, amount, 0, 0);

	/*
	@@ -546,6 +568,9 @@
	{
	int error;

	+ if (!racct_enable)
	+ return (0);
	+
	mtx_lock(&racct_lock);
	error = racct_add_locked(p, resource, amount);
	mtx_unlock(&racct_lock);
	@@ -557,6 +582,8 @@
	{
	struct prison *pr;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	SDT_PROBE(racct, kernel, rusage, add__cred, cred, resource, amount,
	0, 0);

	@@ -577,6 +604,9 @@
	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);
	@@ -590,6 +620,9 @@
	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);

	/*
	@@ -612,6 +645,8 @@
	int error;
	#endif

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	SDT_PROBE(racct, kernel, rusage, set, p, resource, amount, 0, 0);

	/*
	@@ -671,6 +706,9 @@
	{
	int error;

	+ if (!racct_enable)
	+ return (0);
	+
	mtx_lock(&racct_lock);
	error = racct_set_locked(p, resource, amount);
	mtx_unlock(&racct_lock);
	@@ -683,6 +721,8 @@
	int64_t old_amount, decayed_amount;
	int64_t diff_proc, diff_cred;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	SDT_PROBE(racct, kernel, rusage, set, p, resource, amount, 0, 0);

	/*
	@@ -717,6 +757,10 @@
	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);
	@@ -732,6 +776,9 @@
	racct_get_limit(struct proc *p, int resource)
	{

	+ if (!racct_enable)
	+ return (UINT64_MAX);
	+
	#ifdef RCTL
	return (rctl_get_limit(p, resource));
	#else
	@@ -749,6 +796,9 @@
	racct_get_available(struct proc *p, int resource)
	{

	+ if (!racct_enable)
	+ return (UINT64_MAX);
	+
	#ifdef RCTL
	return (rctl_get_available(p, resource));
	#else
	@@ -765,6 +815,8 @@
	racct_pcpu_available(struct proc *p)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	#ifdef RCTL
	return (rctl_pcpu_available(p));
	#else
	@@ -779,6 +831,9 @@
	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);

	/*
	@@ -804,6 +859,8 @@
	{
	struct prison *pr;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	SDT_PROBE(racct, kernel, rusage, sub__cred, cred, resource, amount,
	0, 0);

	@@ -827,6 +884,9 @@
	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);
	@@ -840,6 +900,9 @@
	{
	int i, error = 0;

	+ if (!racct_enable)
	+ return (0);
	+
	/*
	* Create racct for the child process.
	*/
	@@ -896,6 +959,9 @@
	{

	#ifdef RCTL
	+ if (!racct_enable)
	+ return;
	+
	PROC_LOCK(child);
	mtx_lock(&racct_lock);
	rctl_enforce(child, RACCT_NPROC, 0);
	@@ -913,6 +979,9 @@
	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.
	@@ -967,6 +1036,9 @@
	struct loginclass oldlc, newlc;
	struct prison oldpr, newpr, *pr;

	+ if (!racct_enable)
	+ return;
	+
	PROC_LOCK_ASSERT(p, MA_NOTOWNED);

	newuip = newcred->cr_ruidinfo;
	@@ -1004,6 +1076,8 @@
	racct_move(struct racct dest, struct racct src)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	mtx_lock(&racct_lock);

	racct_add_racct(dest, src);
	@@ -1020,6 +1094,7 @@
	int cpuid;
	#endif

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	PROC_LOCK_ASSERT(p, MA_OWNED);

	/*
	@@ -1065,6 +1140,9 @@
	static void
	racct_proc_wakeup(struct proc *p)
	{
	+
	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	PROC_LOCK_ASSERT(p, MA_OWNED);

	if (p->p_throttled) {
	@@ -1079,6 +1157,8 @@
	int resource;
	int64_t r_old, r_new;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	resource = (int )res;
	r_old = racct->r_resources[resource];

	@@ -1095,6 +1175,9 @@
	static void
	racct_decay(int resource)
	{
	+
	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	ui_racct_foreach(racct_decay_resource, &resource, NULL);
	loginclass_racct_foreach(racct_decay_resource, &resource, NULL);
	prison_racct_foreach(racct_decay_resource, &resource, NULL);
	@@ -1109,6 +1192,8 @@
	uint64_t runtime;
	uint64_t pct, pct_estimate;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	for (;;) {
	racct_decay(RACCT_PCTCPU);

	@@ -1188,11 +1273,25 @@
	racctd,
	NULL
	};
	-SYSINIT(racctd, SI_SUB_RACCTD, SI_ORDER_FIRST, kproc_start, &racctd_kp);
	+
	+static void
	+racctd_init(void)
	+{
	+ if (!racct_enable)
	+ return;
	+
	+ /*
	+ * XXX: Make sure racct works.
	+ */
	+ 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);
	Index: sys/kern/kern_rctl.c
	===================================================================
	--- sys/kern/kern_rctl.c
	+++ sys/kern/kern_rctl.c
	@@ -225,6 +225,7 @@
	int64_t available = INT64_MAX;
	struct ucred *cred = p->p_ucred;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	rw_assert(&rctl_lock, RA_LOCKED);

	resource = rule->rr_resource;
	@@ -264,6 +265,8 @@
	{
	int64_t available;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rw_assert(&rctl_lock, RA_LOCKED);

	available = rctl_available_resource(p, rule);
	@@ -283,6 +286,8 @@
	struct rctl_rule_link *link;
	int64_t available, minavailable, limit;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	minavailable = INT64_MAX;
	limit = 0;

	@@ -334,6 +339,8 @@
	static int curtime = 0;
	static struct timeval lasttime;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rw_rlock(&rctl_lock);

	/*
	@@ -457,6 +464,8 @@
	struct rctl_rule_link *link;
	uint64_t amount = UINT64_MAX;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rw_rlock(&rctl_lock);

	/*
	@@ -487,6 +496,8 @@

	minavailable = INT64_MAX;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rw_rlock(&rctl_lock);

	/*
	@@ -521,6 +532,8 @@
	rctl_rule_matches(const struct rctl_rule rule, const struct rctl_rule filter)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	if (filter->rr_subject_type != RCTL_SUBJECT_TYPE_UNDEFINED) {
	if (rule->rr_subject_type != filter->rr_subject_type)
	return (0);
	@@ -635,6 +648,7 @@
	{
	struct rctl_rule_link *link;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));

	rctl_rule_acquire(rule);
	@@ -652,6 +666,7 @@
	{
	struct rctl_rule_link *link;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));
	rw_assert(&rctl_lock, RA_WLOCKED);

	@@ -678,6 +693,7 @@
	int removed = 0;
	struct rctl_rule_link link, linktmp;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	rw_assert(&rctl_lock, RA_WLOCKED);

	LIST_FOREACH_SAFE(link, &racct->r_rule_links, rrl_next, linktmp) {
	@@ -696,6 +712,8 @@
	rctl_rule_acquire_subject(struct rctl_rule *rule)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	switch (rule->rr_subject_type) {
	case RCTL_SUBJECT_TYPE_UNDEFINED:
	case RCTL_SUBJECT_TYPE_PROCESS:
	@@ -722,6 +740,8 @@
	rctl_rule_release_subject(struct rctl_rule *rule)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	switch (rule->rr_subject_type) {
	case RCTL_SUBJECT_TYPE_UNDEFINED:
	case RCTL_SUBJECT_TYPE_PROCESS:
	@@ -749,6 +769,8 @@
	{
	struct rctl_rule *rule;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rule = uma_zalloc(rctl_rule_zone, flags);
	if (rule == NULL)
	return (NULL);
	@@ -771,6 +793,8 @@
	{
	struct rctl_rule *copy;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	copy = uma_zalloc(rctl_rule_zone, flags);
	if (copy == NULL)
	return (NULL);
	@@ -793,6 +817,7 @@
	rctl_rule_acquire(struct rctl_rule *rule)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	KASSERT(rule->rr_refcount > 0, ("rule->rr_refcount <= 0"));

	refcount_acquire(&rule->rr_refcount);
	@@ -805,6 +830,7 @@

	rule = (struct rctl_rule *)context;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	KASSERT(rule->rr_refcount == 0, ("rule->rr_refcount != 0"));

	/*
	@@ -819,6 +845,7 @@
	rctl_rule_release(struct rctl_rule *rule)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	KASSERT(rule->rr_refcount > 0, ("rule->rr_refcount <= 0"));

	if (refcount_release(&rule->rr_refcount)) {
	@@ -838,6 +865,8 @@
	rctl_rule_fully_specified(const struct rctl_rule *rule)
	{

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	switch (rule->rr_subject_type) {
	case RCTL_SUBJECT_TYPE_UNDEFINED:
	return (0);
	@@ -882,6 +911,8 @@
	struct rctl_rule *rule;
	id_t id;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rule = rctl_rule_alloc(M_WAITOK);

	subjectstr = strsep(&rulestr, ":");
	@@ -1008,6 +1039,7 @@
	struct rctl_rule *rule2;
	int match;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	KASSERT(rctl_rule_fully_specified(rule), ("rule not fully specified"));

	/*
	@@ -1118,6 +1150,8 @@
	struct rctl_rule filter = (struct rctl_rule )arg2;
	int found = 0;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rw_wlock(&rctl_lock);
	found += rctl_racct_remove_rules(racct, filter);
	rw_wunlock(&rctl_lock);
	@@ -1134,6 +1168,8 @@
	int found = 0;
	struct proc *p;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	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 @@
	{
	int64_t amount;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	sbuf_printf(sb, "%s:", rctl_subject_type_name(rule->rr_subject_type));

	switch (rule->rr_subject_type) {
	@@ -1231,6 +1269,8 @@
	int error;
	char *str;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	if (inbuflen <= 0)
	return (EINVAL);
	if (inbuflen > RCTL_MAX_INBUFLEN)
	@@ -1256,6 +1296,8 @@
	{
	int error;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	if (outputsbuf == NULL)
	return (0);

	@@ -1277,6 +1319,8 @@
	int64_t amount;
	struct sbuf *sb;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	sb = sbuf_new_auto();
	for (i = 0; i <= RACCT_MAX; i++) {
	if (sloppy == 0 && RACCT_IS_SLOPPY(i))
	@@ -1302,6 +1346,9 @@
	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 @@
	struct rctl_rule_link *link;
	struct sbuf sb = (struct sbuf )arg3;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	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 @@
	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 @@
	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 @@
	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 @@
	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 @@
	struct prison_racct *newprr;
	LIST_HEAD(, rctl_rule_link) newrules;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	newuip = newcred->cr_ruidinfo;
	newlc = newcred->cr_loginclass;
	newprr = newcred->cr_prison->pr_prison_racct;
	@@ -1756,6 +1819,7 @@

	LIST_INIT(&child->p_racct->r_rule_links);

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	KASSERT(parent->p_racct != NULL, ("process without racct; p = %p", parent));

	rw_wlock(&rctl_lock);
	@@ -1809,6 +1873,8 @@
	{
	struct rctl_rule_link *link;

	+ KASSERT(racct_enable, ("called with !racct_enable"));
	+
	rw_wlock(&rctl_lock);
	while (!LIST_EMPTY(&racct->r_rule_links)) {
	link = LIST_FIRST(&racct->r_rule_links);
	@@ -1823,6 +1889,9 @@
	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);
	Index: sys/kern/kern_thr.c
	===================================================================
	--- sys/kern/kern_thr.c
	+++ sys/kern/kern_thr.c
	@@ -187,11 +187,13 @@
	}

	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- error = racct_add(p, RACCT_NTHR, 1);
	- PROC_UNLOCK(td->td_proc);
	- if (error != 0)
	- return (EPROCLIM);
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ error = racct_add(p, RACCT_NTHR, 1);
	+ PROC_UNLOCK(td->td_proc);
	+ if (error != 0)
	+ return (EPROCLIM);
	+ }
	#endif

	/* Initialize our td */
	@@ -280,9 +282,11 @@

	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);
	}
	Index: sys/kern/sched_4bsd.c
	===================================================================
	--- sys/kern/sched_4bsd.c
	+++ sys/kern/sched_4bsd.c
	@@ -1585,7 +1585,7 @@
	return (ts->ts_pctcpu);
	}

	-#ifdef RACCT
	+#ifdef RACCT
	/*
	* Calculates the contribution to the thread cpu usage for the latest
	* (unfinished) second.
	Index: sys/kern/subr_trap.c
	===================================================================
	--- sys/kern/subr_trap.c
	+++ sys/kern/subr_trap.c
	@@ -59,6 +59,7 @@
	#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>
	@@ -172,11 +173,13 @@
	__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
	}

	Index: sys/kern/sysv_msg.c
	===================================================================
	--- sys/kern/sysv_msg.c
	+++ sys/kern/sysv_msg.c
	@@ -617,12 +617,14 @@
	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));
	@@ -724,20 +726,22 @@
	#endif

	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- if (racct_add(td->td_proc, RACCT_MSGQQUEUED, 1)) {
	- PROC_UNLOCK(td->td_proc);
	- error = EAGAIN;
	- goto done2;
	- }
	- saved_msgsz = msgsz;
	- if (racct_add(td->td_proc, RACCT_MSGQSIZE, msgsz)) {
	- racct_sub(td->td_proc, RACCT_MSGQQUEUED, 1);
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ if (racct_add(td->td_proc, RACCT_MSGQQUEUED, 1)) {
	+ PROC_UNLOCK(td->td_proc);
	+ error = EAGAIN;
	+ goto done2;
	+ }
	+ saved_msgsz = msgsz;
	+ if (racct_add(td->td_proc, RACCT_MSGQSIZE, msgsz)) {
	+ racct_sub(td->td_proc, RACCT_MSGQQUEUED, 1);
	+ PROC_UNLOCK(td->td_proc);
	+ error = EAGAIN;
	+ goto done2;
	+ }
	PROC_UNLOCK(td->td_proc);
	- error = EAGAIN;
	- goto done2;
	}
	- PROC_UNLOCK(td->td_proc);
	#endif

	segs_needed = (msgsz + msginfo.msgssz - 1) / msginfo.msgssz;
	@@ -994,7 +998,7 @@
	td->td_retval[0] = 0;
	done3:
	#ifdef RACCT
	- if (error != 0) {
	+ if (racct_enable && error != 0) {
	PROC_LOCK(td->td_proc);
	racct_sub(td->td_proc, RACCT_MSGQQUEUED, 1);
	racct_sub(td->td_proc, RACCT_MSGQSIZE, saved_msgsz);
	Index: sys/kern/sysv_sem.c
	===================================================================
	--- sys/kern/sysv_sem.c
	+++ sys/kern/sysv_sem.c
	@@ -915,12 +915,14 @@
	goto done2;
	}
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- error = racct_add(td->td_proc, RACCT_NSEM, nsems);
	- 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_NSEM, nsems);
	+ PROC_UNLOCK(td->td_proc);
	+ if (error != 0) {
	+ error = ENOSPC;
	+ goto done2;
	+ }
	}
	#endif
	DPRINTF(("semid %d is available\n", semid));
	@@ -1009,12 +1011,15 @@
	return (E2BIG);
	} else {
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- if (nsops > racct_get_available(td->td_proc, RACCT_NSEMOP)) {
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ if (nsops >
	+ racct_get_available(td->td_proc, RACCT_NSEMOP)) {
	+ PROC_UNLOCK(td->td_proc);
	+ return (E2BIG);
	+ }
	PROC_UNLOCK(td->td_proc);
	- return (E2BIG);
	}
	- PROC_UNLOCK(td->td_proc);
	#endif

	sops = malloc(nsops * sizeof(*sops), M_TEMP, M_WAITOK);
	Index: sys/kern/sysv_shm.c
	===================================================================
	--- sys/kern/sysv_shm.c
	+++ sys/kern/sysv_shm.c
	@@ -651,17 +651,19 @@
	("segnum %d shmalloced %d", segnum, shmalloced));
	shmseg = &shmsegs[segnum];
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- if (racct_add(td->td_proc, RACCT_NSHM, 1)) {
	- PROC_UNLOCK(td->td_proc);
	- return (ENOSPC);
	- }
	- if (racct_add(td->td_proc, RACCT_SHMSIZE, size)) {
	- racct_sub(td->td_proc, RACCT_NSHM, 1);
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ if (racct_add(td->td_proc, RACCT_NSHM, 1)) {
	+ PROC_UNLOCK(td->td_proc);
	+ return (ENOSPC);
	+ }
	+ if (racct_add(td->td_proc, RACCT_SHMSIZE, size)) {
	+ racct_sub(td->td_proc, RACCT_NSHM, 1);
	+ PROC_UNLOCK(td->td_proc);
	+ return (ENOMEM);
	+ }
	PROC_UNLOCK(td->td_proc);
	- return (ENOMEM);
	}
	- PROC_UNLOCK(td->td_proc);
	#endif

	/*
	@@ -672,10 +674,12 @@
	0, size, VM_PROT_DEFAULT, 0, cred);
	if (shm_object == NULL) {
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- racct_sub(td->td_proc, RACCT_NSHM, 1);
	- racct_sub(td->td_proc, RACCT_SHMSIZE, size);
	- PROC_UNLOCK(td->td_proc);
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ racct_sub(td->td_proc, RACCT_NSHM, 1);
	+ racct_sub(td->td_proc, RACCT_SHMSIZE, size);
	+ PROC_UNLOCK(td->td_proc);
	+ }
	#endif
	return (ENOMEM);
	}
	Index: sys/sys/racct.h
	===================================================================
	--- sys/sys/racct.h
	+++ sys/sys/racct.h
	@@ -83,6 +83,7 @@
	#define RACCT_DECAYING 0x20

	extern int racct_types[];
	+extern int racct_enable;

	/*
	* Amount stored in c_resources[] is 10**6 times bigger than what's
	Index: sys/vm/swap_pager.c
	===================================================================
	--- sys/vm/swap_pager.c
	+++ sys/vm/swap_pager.c
	@@ -198,11 +198,13 @@
	panic("swap_reserve: & PAGE_MASK");

	#ifdef RACCT
	- PROC_LOCK(curproc);
	- error = racct_add(curproc, RACCT_SWAP, incr);
	- PROC_UNLOCK(curproc);
	- if (error != 0)
	- return (0);
	+ if (racct_enable) {
	+ PROC_LOCK(curproc);
	+ error = racct_add(curproc, RACCT_SWAP, incr);
	+ PROC_UNLOCK(curproc);
	+ if (error != 0)
	+ return (0);
	+ }
	#endif

	res = 0;
	Index: sys/vm/vm_map.c
	===================================================================
	--- sys/vm/vm_map.c
	+++ sys/vm/vm_map.c
	@@ -300,11 +300,11 @@
	return (vm);
	}

	+#ifdef RACCT
	static void
	vmspace_container_reset(struct proc *p)
	{

	-#ifdef RACCT
	PROC_LOCK(p);
	racct_set(p, RACCT_DATA, 0);
	racct_set(p, RACCT_STACK, 0);
	@@ -312,8 +312,8 @@
	racct_set(p, RACCT_MEMLOCK, 0);
	racct_set(p, RACCT_VMEM, 0);
	PROC_UNLOCK(p);
	-#endif
	}
	+#endif

	static inline void
	vmspace_dofree(struct vmspace *vm)
	@@ -415,7 +415,10 @@
	pmap_activate(td);
	vmspace_dofree(vm);
	}
	- vmspace_container_reset(p);
	+#ifdef RACCT
	+ if (racct_enable)
	+ vmspace_container_reset(p);
	+#endif
	}

	/* Acquire reference to vmspace owned by another process. */
	@@ -3652,14 +3655,16 @@
	return (KERN_NO_SPACE);
	}
	#ifdef RACCT
	- PROC_LOCK(p);
	- if (is_procstack &&
	- racct_set(p, RACCT_STACK, ctob(vm->vm_ssize) + grow_amount)) {
	+ if (racct_enable) {
	+ PROC_LOCK(p);
	+ if (is_procstack && racct_set(p, RACCT_STACK,
	+ ctob(vm->vm_ssize) + grow_amount)) {
	+ PROC_UNLOCK(p);
	+ vm_map_unlock_read(map);
	+ return (KERN_NO_SPACE);
	+ }
	PROC_UNLOCK(p);
	- vm_map_unlock_read(map);
	- return (KERN_NO_SPACE);
	}
	- PROC_UNLOCK(p);
	#endif

	/* Round up the grow amount modulo sgrowsiz */
	@@ -3685,15 +3690,17 @@
	goto out;
	}
	#ifdef RACCT
	- PROC_LOCK(p);
	- if (racct_set(p, RACCT_MEMLOCK,
	- ptoa(pmap_wired_count(map->pmap)) + grow_amount)) {
	+ if (racct_enable) {
	+ PROC_LOCK(p);
	+ if (racct_set(p, RACCT_MEMLOCK,
	+ ptoa(pmap_wired_count(map->pmap)) + grow_amount)) {
	+ PROC_UNLOCK(p);
	+ vm_map_unlock_read(map);
	+ rv = KERN_NO_SPACE;
	+ goto out;
	+ }
	PROC_UNLOCK(p);
	- vm_map_unlock_read(map);
	- rv = KERN_NO_SPACE;
	- goto out;
	}
	- PROC_UNLOCK(p);
	#endif
	}
	/* If we would blow our VMEM resource limit, no go */
	@@ -3703,14 +3710,16 @@
	goto out;
	}
	#ifdef RACCT
	- PROC_LOCK(p);
	- if (racct_set(p, RACCT_VMEM, map->size + grow_amount)) {
	+ if (racct_enable) {
	+ PROC_LOCK(p);
	+ if (racct_set(p, RACCT_VMEM, map->size + grow_amount)) {
	+ PROC_UNLOCK(p);
	+ vm_map_unlock_read(map);
	+ rv = KERN_NO_SPACE;
	+ goto out;
	+ }
	PROC_UNLOCK(p);
	- vm_map_unlock_read(map);
	- rv = KERN_NO_SPACE;
	- goto out;
	}
	- PROC_UNLOCK(p);
	#endif

	if (vm_map_lock_upgrade(map))
	@@ -3809,7 +3818,7 @@

	out:
	#ifdef RACCT
	- if (rv != KERN_SUCCESS) {
	+ if (racct_enable && rv != KERN_SUCCESS) {
	PROC_LOCK(p);
	error = racct_set(p, RACCT_VMEM, map->size);
	KASSERT(error == 0, ("decreasing RACCT_VMEM failed"));
	Index: sys/vm/vm_mmap.c
	===================================================================
	--- sys/vm/vm_mmap.c
	+++ sys/vm/vm_mmap.c
	@@ -1122,16 +1122,18 @@
	if (npages + vm_cnt.v_wire_count > vm_page_max_wired)
	return (EAGAIN);
	#ifdef RACCT
	- PROC_LOCK(proc);
	- error = racct_set(proc, RACCT_MEMLOCK, nsize);
	- PROC_UNLOCK(proc);
	- if (error != 0)
	- return (ENOMEM);
	+ if (racct_enable) {
	+ PROC_LOCK(proc);
	+ error = racct_set(proc, RACCT_MEMLOCK, nsize);
	+ PROC_UNLOCK(proc);
	+ if (error != 0)
	+ return (ENOMEM);
	+ }
	#endif
	error = vm_map_wire(map, start, end,
	VM_MAP_WIRE_USER \| VM_MAP_WIRE_NOHOLES);
	#ifdef RACCT
	- if (error != KERN_SUCCESS) {
	+ if (racct_enable && error != KERN_SUCCESS) {
	PROC_LOCK(proc);
	racct_set(proc, RACCT_MEMLOCK,
	ptoa(pmap_wired_count(map->pmap)));
	@@ -1179,11 +1181,13 @@
	PROC_UNLOCK(td->td_proc);
	}
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- error = racct_set(td->td_proc, RACCT_MEMLOCK, map->size);
	- PROC_UNLOCK(td->td_proc);
	- if (error != 0)
	- return (ENOMEM);
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ error = racct_set(td->td_proc, RACCT_MEMLOCK, map->size);
	+ PROC_UNLOCK(td->td_proc);
	+ if (error != 0)
	+ return (ENOMEM);
	+ }
	#endif

	if (uap->how & MCL_FUTURE) {
	@@ -1205,7 +1209,7 @@
	error = (error == KERN_SUCCESS ? 0 : EAGAIN);
	}
	#ifdef RACCT
	- if (error != KERN_SUCCESS) {
	+ if (racct_enable && error != KERN_SUCCESS) {
	PROC_LOCK(td->td_proc);
	racct_set(td->td_proc, RACCT_MEMLOCK,
	ptoa(pmap_wired_count(map->pmap)));
	@@ -1247,7 +1251,7 @@
	error = vm_map_unwire(map, vm_map_min(map), vm_map_max(map),
	VM_MAP_WIRE_USER\|VM_MAP_WIRE_HOLESOK);
	#ifdef RACCT
	- if (error == KERN_SUCCESS) {
	+ if (racct_enable && error == KERN_SUCCESS) {
	PROC_LOCK(td->td_proc);
	racct_set(td->td_proc, RACCT_MEMLOCK, 0);
	PROC_UNLOCK(td->td_proc);
	@@ -1291,7 +1295,7 @@
	error = vm_map_unwire(&td->td_proc->p_vmspace->vm_map, start, end,
	VM_MAP_WIRE_USER \| VM_MAP_WIRE_NOHOLES);
	#ifdef RACCT
	- if (error == KERN_SUCCESS) {
	+ if (racct_enable && error == KERN_SUCCESS) {
	PROC_LOCK(td->td_proc);
	map = &td->td_proc->p_vmspace->vm_map;
	racct_set(td->td_proc, RACCT_MEMLOCK,
	Index: sys/vm/vm_pageout.c
	===================================================================
	--- sys/vm/vm_pageout.c
	+++ sys/vm/vm_pageout.c
	@@ -1788,7 +1788,8 @@
	while (TRUE) {
	mtx_lock(&vm_daemon_mtx);
	#ifdef RACCT
	- msleep(&vm_daemon_needed, &vm_daemon_mtx, PPAUSE, "psleep", hz);
	+ msleep(&vm_daemon_needed, &vm_daemon_mtx, PPAUSE, "psleep",
	+ racct_enable ? hz : 0);
	#else
	msleep(&vm_daemon_needed, &vm_daemon_mtx, PPAUSE, "psleep", 0);
	#endif
	@@ -1866,33 +1867,40 @@
	&vm->vm_map, limit);
	}
	#ifdef RACCT
	- rsize = IDX_TO_OFF(size);
	- PROC_LOCK(p);
	- racct_set(p, RACCT_RSS, rsize);
	- ravailable = racct_get_available(p, RACCT_RSS);
	- PROC_UNLOCK(p);
	- if (rsize > ravailable) {
	- /*
	- * Don't be overly aggressive; this might be
	- * an innocent process, and the limit could've
	- * been exceeded by some memory hog. Don't
	- * try to deactivate more than 1/4th of process'
	- * resident set size.
	- */
	- if (attempts <= 8) {
	- if (ravailable < rsize - (rsize / 4))
	- ravailable = rsize - (rsize / 4);
	- }
	- vm_pageout_map_deactivate_pages(
	- &vm->vm_map, OFF_TO_IDX(ravailable));
	- /* Update RSS usage after paging out. */
	- size = vmspace_resident_count(vm);
	+ if (racct_enable) {
	rsize = IDX_TO_OFF(size);
	PROC_LOCK(p);
	racct_set(p, RACCT_RSS, rsize);
	+ ravailable = racct_get_available(p, RACCT_RSS);
	PROC_UNLOCK(p);
	- if (rsize > ravailable)
	- tryagain = 1;
	+ if (rsize > ravailable) {
	+ /*
	+ * Don't be overly aggressive; this
	+ * might be an innocent process,
	+ * and the limit could've been exceeded
	+ * by some memory hog. Don't try
	+ * to deactivate more than 1/4th
	+ * of process' resident set size.
	+ */
	+ if (attempts <= 8) {
	+ if (ravailable < rsize -
	+ (rsize / 4)) {
	+ ravailable = rsize -
	+ (rsize / 4);
	+ }
	+ }
	+ vm_pageout_map_deactivate_pages(
	+ &vm->vm_map,
	+ OFF_TO_IDX(ravailable));
	+ /* Update RSS usage after paging out. */
	+ size = vmspace_resident_count(vm);
	+ rsize = IDX_TO_OFF(size);
	+ PROC_LOCK(p);
	+ racct_set(p, RACCT_RSS, rsize);
	+ PROC_UNLOCK(p);
	+ if (rsize > ravailable)
	+ tryagain = 1;
	+ }
	}
	#endif
	vmspace_free(vm);
	Index: sys/vm/vm_unix.c
	===================================================================
	--- sys/vm/vm_unix.c
	+++ sys/vm/vm_unix.c
	@@ -130,35 +130,39 @@
	goto done;
	}
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- error = racct_set(td->td_proc, RACCT_DATA, new - base);
	- if (error != 0) {
	- PROC_UNLOCK(td->td_proc);
	- error = ENOMEM;
	- goto done;
	- }
	- error = racct_set(td->td_proc, RACCT_VMEM,
	- map->size + (new - old));
	- if (error != 0) {
	- racct_set_force(td->td_proc, RACCT_DATA, old - base);
	- PROC_UNLOCK(td->td_proc);
	- error = ENOMEM;
	- goto done;
	- }
	- if (!old_mlock && map->flags & MAP_WIREFUTURE) {
	- error = racct_set(td->td_proc, RACCT_MEMLOCK,
	- ptoa(pmap_wired_count(map->pmap)) + (new - old));
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ error = racct_set(td->td_proc, RACCT_DATA, new - base);
	+ if (error != 0) {
	+ PROC_UNLOCK(td->td_proc);
	+ error = ENOMEM;
	+ goto done;
	+ }
	+ error = racct_set(td->td_proc, RACCT_VMEM,
	+ map->size + (new - old));
	if (error != 0) {
	racct_set_force(td->td_proc, RACCT_DATA,
	old - base);
	- racct_set_force(td->td_proc, RACCT_VMEM,
	- map->size);
	PROC_UNLOCK(td->td_proc);
	error = ENOMEM;
	goto done;
	}
	+ if (!old_mlock && map->flags & MAP_WIREFUTURE) {
	+ error = racct_set(td->td_proc, RACCT_MEMLOCK,
	+ ptoa(pmap_wired_count(map->pmap)) +
	+ (new - old));
	+ if (error != 0) {
	+ racct_set_force(td->td_proc, RACCT_DATA,
	+ old - base);
	+ racct_set_force(td->td_proc, RACCT_VMEM,
	+ map->size);
	+ PROC_UNLOCK(td->td_proc);
	+ error = ENOMEM;
	+ goto done;
	+ }
	+ }
	+ PROC_UNLOCK(td->td_proc);
	}
	- PROC_UNLOCK(td->td_proc);
	#endif
	prot = VM_PROT_RW;
	#ifdef COMPAT_FREEBSD32
	@@ -170,14 +174,19 @@
	rv = vm_map_insert(map, NULL, 0, old, new, prot, VM_PROT_ALL, 0);
	if (rv != KERN_SUCCESS) {
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- racct_set_force(td->td_proc, RACCT_DATA, old - base);
	- racct_set_force(td->td_proc, RACCT_VMEM, map->size);
	- if (!old_mlock && map->flags & MAP_WIREFUTURE) {
	- racct_set_force(td->td_proc, RACCT_MEMLOCK,
	- ptoa(pmap_wired_count(map->pmap)));
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ racct_set_force(td->td_proc,
	+ RACCT_DATA, old - base);
	+ racct_set_force(td->td_proc,
	+ RACCT_VMEM, map->size);
	+ if (!old_mlock && map->flags & MAP_WIREFUTURE) {
	+ racct_set_force(td->td_proc,
	+ RACCT_MEMLOCK,
	+ ptoa(pmap_wired_count(map->pmap)));
	+ }
	+ PROC_UNLOCK(td->td_proc);
	}
	- PROC_UNLOCK(td->td_proc);
	#endif
	error = ENOMEM;
	goto done;
	@@ -205,14 +214,16 @@
	}
	vm->vm_dsize -= btoc(old - new);
	#ifdef RACCT
	- PROC_LOCK(td->td_proc);
	- racct_set_force(td->td_proc, RACCT_DATA, new - base);
	- racct_set_force(td->td_proc, RACCT_VMEM, map->size);
	- if (!old_mlock && map->flags & MAP_WIREFUTURE) {
	- racct_set_force(td->td_proc, RACCT_MEMLOCK,
	- ptoa(pmap_wired_count(map->pmap)));
	+ if (racct_enable) {
	+ PROC_LOCK(td->td_proc);
	+ racct_set_force(td->td_proc, RACCT_DATA, new - base);
	+ racct_set_force(td->td_proc, RACCT_VMEM, map->size);
	+ if (!old_mlock && map->flags & MAP_WIREFUTURE) {
	+ racct_set_force(td->td_proc, RACCT_MEMLOCK,
	+ ptoa(pmap_wired_count(map->pmap)));
	+ }
	+ PROC_UNLOCK(td->td_proc);
	}
	- PROC_UNLOCK(td->td_proc);
	#endif
	}
	done:

File Metadata

Mime Type: text/plain
Expires: Mon, Apr 6, 1:54 AM (3 h, 39 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 30929579
Default Alt Text: D2369.id5002.diff (37 KB)

D2369.id5002.diffNo OneTemporaryActions

D2369.id5002.diffView Options

File Metadata

Event Timeline

D2369.id5002.diff
No OneTemporary
Actions

D2369.id5002.diff
View Options