From owner-svn-src-all@FreeBSD.ORG Thu Jul 7 17:44:42 2011 Return-Path: Delivered-To: svn-src-all@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id CA1FD106567F; Thu, 7 Jul 2011 17:44:42 +0000 (UTC) (envelope-from trasz@FreeBSD.org) Received: from svn.freebsd.org (svn.freebsd.org [IPv6:2001:4f8:fff6::2c]) by mx1.freebsd.org (Postfix) with ESMTP id B9DD78FC16; Thu, 7 Jul 2011 17:44:42 +0000 (UTC) Received: from svn.freebsd.org (localhost [127.0.0.1]) by svn.freebsd.org (8.14.4/8.14.4) with ESMTP id p67Hig1m072759; Thu, 7 Jul 2011 17:44:42 GMT (envelope-from trasz@svn.freebsd.org) Received: (from trasz@localhost) by svn.freebsd.org (8.14.4/8.14.4/Submit) id p67HigjS072755; Thu, 7 Jul 2011 17:44:42 GMT (envelope-from trasz@svn.freebsd.org) Message-Id: <201107071744.p67HigjS072755@svn.freebsd.org> From: Edward Tomasz Napierala Date: Thu, 7 Jul 2011 17:44:42 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org X-SVN-Group: head MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cc: Subject: svn commit: r223844 - in head/sys: kern sys X-BeenThere: svn-src-all@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: "SVN commit messages for the entire src tree \(except for " user" and " projects" \)" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 07 Jul 2011 17:44:42 -0000 Author: trasz Date: Thu Jul 7 17:44:42 2011 New Revision: 223844 URL: http://svn.freebsd.org/changeset/base/223844 Log: Style fix - macros are supposed to be uppercase. Modified: head/sys/kern/kern_racct.c head/sys/kern/kern_rctl.c head/sys/sys/racct.h Modified: head/sys/kern/kern_racct.c ============================================================================== --- head/sys/kern/kern_racct.c Thu Jul 7 17:00:42 2011 (r223843) +++ head/sys/kern/kern_racct.c Thu Jul 7 17:44:42 2011 (r223844) @@ -173,7 +173,7 @@ racct_sub_racct(struct racct *dest, cons * Update resource usage in dest. */ for (i = 0; i <= RACCT_MAX; i++) { - if (!racct_is_sloppy(i)) { + if (!RACCT_IS_SLOPPY(i)) { KASSERT(dest->r_resources[i] >= 0, ("racct propagation meltdown: dest < 0")); KASSERT(src->r_resources[i] >= 0, @@ -181,10 +181,10 @@ racct_sub_racct(struct racct *dest, cons KASSERT(src->r_resources[i] <= dest->r_resources[i], ("racct propagation meltdown: src > dest")); } - if (racct_is_reclaimable(i)) { + if (RACCT_IS_RECLAIMABLE(i)) { dest->r_resources[i] -= src->r_resources[i]; if (dest->r_resources[i] < 0) { - KASSERT(racct_is_sloppy(i), + KASSERT(RACCT_IS_SLOPPY(i), ("racct_sub_racct: usage < 0")); dest->r_resources[i] = 0; } @@ -218,9 +218,9 @@ racct_destroy_locked(struct racct **racc racct = *racctp; for (i = 0; i <= RACCT_MAX; i++) { - if (racct_is_sloppy(i)) + if (RACCT_IS_SLOPPY(i)) continue; - if (!racct_is_reclaimable(i)) + if (!RACCT_IS_RECLAIMABLE(i)) continue; KASSERT(racct->r_resources[i] == 0, ("destroying non-empty racct: " @@ -255,7 +255,7 @@ racct_alloc_resource(struct racct *racct racct->r_resources[resource] += amount; if (racct->r_resources[resource] < 0) { - KASSERT(racct_is_sloppy(resource), + KASSERT(RACCT_IS_SLOPPY(resource), ("racct_alloc_resource: usage < 0")); racct->r_resources[resource] = 0; } @@ -285,7 +285,7 @@ racct_add(struct proc *p, int resource, mtx_lock(&racct_lock); #ifdef RCTL error = rctl_enforce(p, resource, amount); - if (error && racct_is_deniable(resource)) { + if (error && RACCT_IS_DENIABLE(resource)) { SDT_PROBE(racct, kernel, rusage, add_failure, p, resource, amount, 0, 0); mtx_unlock(&racct_lock); @@ -373,14 +373,14 @@ racct_set_locked(struct proc *p, int res diff = amount - p->p_racct->r_resources[resource]; #ifdef notyet - KASSERT(diff >= 0 || racct_is_reclaimable(resource), + KASSERT(diff >= 0 || RACCT_IS_RECLAIMABLE(resource), ("racct_set: usage of non-reclaimable resource %d dropping", resource)); #endif #ifdef RCTL if (diff > 0) { error = rctl_enforce(p, resource, diff); - if (error && racct_is_deniable(resource)) { + if (error && RACCT_IS_DENIABLE(resource)) { SDT_PROBE(racct, kernel, rusage, set_failure, p, resource, amount, 0, 0); return (error); @@ -489,7 +489,7 @@ racct_sub(struct proc *p, int resource, * We need proc lock to dereference p->p_ucred. */ PROC_LOCK_ASSERT(p, MA_OWNED); - KASSERT(racct_is_reclaimable(resource), + KASSERT(RACCT_IS_RECLAIMABLE(resource), ("racct_sub: called for non-reclaimable resource %d", resource)); mtx_lock(&racct_lock); @@ -512,7 +512,7 @@ racct_sub_cred_locked(struct ucred *cred 0, 0); #ifdef notyet - KASSERT(racct_is_reclaimable(resource), + KASSERT(RACCT_IS_RECLAIMABLE(resource), ("racct_sub_cred: called for non-reclaimable resource %d", resource)); #endif @@ -564,7 +564,7 @@ racct_proc_fork(struct proc *parent, str */ for (i = 0; i <= RACCT_MAX; i++) { if (parent->p_racct->r_resources[i] == 0 || - !racct_is_inheritable(i)) + !RACCT_IS_INHERITABLE(i)) continue; error = racct_set_locked(child, i, Modified: head/sys/kern/kern_rctl.c ============================================================================== --- head/sys/kern/kern_rctl.c Thu Jul 7 17:00:42 2011 (r223843) +++ head/sys/kern/kern_rctl.c Thu Jul 7 17:44:42 2011 (r223844) @@ -907,7 +907,7 @@ rctl_string_to_rule(char *rulestr, struc error = str2int64(amountstr, &rule->rr_amount); if (error != 0) goto out; - if (racct_is_in_thousands(rule->rr_resource)) + if (RACCT_IS_IN_THOUSANDS(rule->rr_resource)) rule->rr_amount *= 1000; } @@ -947,7 +947,7 @@ rctl_rule_add(struct rctl_rule *rule) /* * Some rules just don't make sense. Note that the one below - * cannot be rewritten using racct_is_deniable(); the RACCT_PCTCPU, + * cannot be rewritten using RACCT_IS_DENIABLE(); the RACCT_PCTCPU, * for example, is not deniable in the racct sense, but the * limit is enforced in a different way, so "deny" rules for %CPU * do make sense. @@ -958,7 +958,7 @@ rctl_rule_add(struct rctl_rule *rule) return (EOPNOTSUPP); if (rule->rr_per == RCTL_SUBJECT_TYPE_PROCESS && - racct_is_sloppy(rule->rr_resource)) + RACCT_IS_SLOPPY(rule->rr_resource)) return (EOPNOTSUPP); /* @@ -1152,7 +1152,7 @@ rctl_rule_to_sbuf(struct sbuf *sb, const amount = rule->rr_amount; if (amount != RCTL_AMOUNT_UNDEFINED && - racct_is_in_thousands(rule->rr_resource)) + RACCT_IS_IN_THOUSANDS(rule->rr_resource)) amount /= 1000; sbuf_printf(sb, "%s:%s=%jd", @@ -1219,10 +1219,10 @@ rctl_racct_to_sbuf(struct racct *racct, sb = sbuf_new_auto(); for (i = 0; i <= RACCT_MAX; i++) { - if (sloppy == 0 && racct_is_sloppy(i)) + if (sloppy == 0 && RACCT_IS_SLOPPY(i)) continue; amount = racct->r_resources[i]; - if (racct_is_in_thousands(i)) + if (RACCT_IS_IN_THOUSANDS(i)) amount /= 1000; sbuf_printf(sb, "%s=%jd,", rctl_resource_name(i), amount); } Modified: head/sys/sys/racct.h ============================================================================== --- head/sys/sys/racct.h Thu Jul 7 17:00:42 2011 (r223843) +++ head/sys/sys/racct.h Thu Jul 7 17:44:42 2011 (r223844) @@ -86,31 +86,31 @@ extern int racct_types[]; * visible to the userland. It gets fixed up when retrieving resource * usage or adding rules. */ -#define racct_is_in_thousands(X) (racct_types[X] & RACCT_IN_THOUSANDS) +#define RACCT_IS_IN_THOUSANDS(X) (racct_types[X] & RACCT_IN_THOUSANDS) /* * Resource usage can drop, as opposed to only grow. */ -#define racct_is_reclaimable(X) (racct_types[X] & RACCT_RECLAIMABLE) +#define RACCT_IS_RECLAIMABLE(X) (racct_types[X] & RACCT_RECLAIMABLE) /* * Children inherit resource usage. */ -#define racct_is_inheritable(X) (racct_types[X] & RACCT_INHERITABLE) +#define RACCT_IS_INHERITABLE(X) (racct_types[X] & RACCT_INHERITABLE) /* * racct_{add,set}(9) can actually return an error and not update resource * usage counters. Note that even when resource is not deniable, allocating * resource might cause signals to be sent by RCTL code. */ -#define racct_is_deniable(X) (racct_types[X] & RACCT_DENIABLE) +#define RACCT_IS_DENIABLE(X) (racct_types[X] & RACCT_DENIABLE) /* * Per-process resource usage information makes no sense, but per-credential * one does. This kind of resources are usually allocated for process, but * freed using credentials. */ -#define racct_is_sloppy(X) (racct_types[X] & RACCT_SLOPPY) +#define RACCT_IS_SLOPPY(X) (racct_types[X] & RACCT_SLOPPY) /* * The 'racct' structure defines resource consumption for a particular