diff --git a/sbin/pfctl/pfctl_altq.c b/sbin/pfctl/pfctl_altq.c --- a/sbin/pfctl/pfctl_altq.c +++ b/sbin/pfctl/pfctl_altq.c @@ -55,6 +55,9 @@ #define is_sc_null(sc) (((sc) == NULL) || ((sc)->m1 == 0 && (sc)->m2 == 0)) +#define BIT_SET __BIT_SET +#define BIT_ISSET __BIT_ISSET + static STAILQ_HEAD(interfaces, pfctl_altq) interfaces = STAILQ_HEAD_INITIALIZER(interfaces); static struct hsearch_data queue_map; static struct hsearch_data if_map; diff --git a/sys/dev/ena/ena.h b/sys/dev/ena/ena.h --- a/sys/dev/ena/ena.h +++ b/sys/dev/ena/ena.h @@ -176,13 +176,13 @@ typedef struct _ena_state ena_state_t; #define ENA_FLAG_ZERO(adapter) \ - BIT_ZERO(ENA_FLAGS_NUMBER, &(adapter)->flags) + __BIT_ZERO(ENA_FLAGS_NUMBER, &(adapter)->flags) #define ENA_FLAG_ISSET(bit, adapter) \ - BIT_ISSET(ENA_FLAGS_NUMBER, (bit), &(adapter)->flags) + __BIT_ISSET(ENA_FLAGS_NUMBER, (bit), &(adapter)->flags) #define ENA_FLAG_SET_ATOMIC(bit, adapter) \ - BIT_SET_ATOMIC(ENA_FLAGS_NUMBER, (bit), &(adapter)->flags) + __BIT_SET_ATOMIC(ENA_FLAGS_NUMBER, (bit), &(adapter)->flags) #define ENA_FLAG_CLEAR_ATOMIC(bit, adapter) \ - BIT_CLR_ATOMIC(ENA_FLAGS_NUMBER, (bit), &(adapter)->flags) + __BIT_CLR_ATOMIC(ENA_FLAGS_NUMBER, (bit), &(adapter)->flags) struct msix_entry { int entry; diff --git a/sys/sys/bitset.h b/sys/sys/bitset.h --- a/sys/sys/bitset.h +++ b/sys/sys/bitset.h @@ -48,36 +48,36 @@ (__constexpr_cond(__bitset_words((_s)) == 1) ? \ 0 : ((n) / _BITSET_BITS)) -#define BIT_CLR(_s, n, p) \ +#define __BIT_CLR(_s, n, p) \ ((p)->__bits[__bitset_word(_s, n)] &= ~__bitset_mask((_s), (n))) -#define BIT_COPY(_s, f, t) (void)(*(t) = *(f)) +#define __BIT_COPY(_s, f, t) (void)(*(t) = *(f)) -#define BIT_ISSET(_s, n, p) \ +#define __BIT_ISSET(_s, n, p) \ ((((p)->__bits[__bitset_word(_s, n)] & __bitset_mask((_s), (n))) != 0)) -#define BIT_SET(_s, n, p) \ +#define __BIT_SET(_s, n, p) \ ((p)->__bits[__bitset_word(_s, n)] |= __bitset_mask((_s), (n))) -#define BIT_ZERO(_s, p) do { \ +#define __BIT_ZERO(_s, p) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (p)->__bits[__i] = 0L; \ } while (0) -#define BIT_FILL(_s, p) do { \ +#define __BIT_FILL(_s, p) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (p)->__bits[__i] = -1L; \ } while (0) -#define BIT_SETOF(_s, n, p) do { \ - BIT_ZERO(_s, p); \ +#define __BIT_SETOF(_s, n, p) do { \ + __BIT_ZERO(_s, p); \ (p)->__bits[__bitset_word(_s, n)] = __bitset_mask((_s), (n)); \ } while (0) /* Is p empty. */ -#define BIT_EMPTY(_s, p) __extension__ ({ \ +#define __BIT_EMPTY(_s, p) __extension__ ({ \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ if ((p)->__bits[__i]) \ @@ -86,7 +86,7 @@ }) /* Is p full set. */ -#define BIT_ISFULLSET(_s, p) __extension__ ({ \ +#define __BIT_ISFULLSET(_s, p) __extension__ ({ \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ if ((p)->__bits[__i] != (long)-1) \ @@ -95,7 +95,7 @@ }) /* Is c a subset of p. */ -#define BIT_SUBSET(_s, p, c) __extension__ ({ \ +#define __BIT_SUBSET(_s, p, c) __extension__ ({ \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ if (((c)->__bits[__i] & \ @@ -106,7 +106,7 @@ }) /* Are there any common bits between b & c? */ -#define BIT_OVERLAP(_s, p, c) __extension__ ({ \ +#define __BIT_OVERLAP(_s, p, c) __extension__ ({ \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ if (((c)->__bits[__i] & \ @@ -116,7 +116,7 @@ }) /* Compare two sets, returns 0 if equal 1 otherwise. */ -#define BIT_CMP(_s, p, c) __extension__ ({ \ +#define __BIT_CMP(_s, p, c) __extension__ ({ \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ if (((c)->__bits[__i] != \ @@ -125,49 +125,49 @@ __i != __bitset_words((_s)); \ }) -#define BIT_OR(_s, d, s) do { \ +#define __BIT_OR(_s, d, s) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] |= (s)->__bits[__i]; \ } while (0) -#define BIT_OR2(_s, d, s1, s2) do { \ +#define __BIT_OR2(_s, d, s1, s2) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] = (s1)->__bits[__i] | (s2)->__bits[__i];\ } while (0) -#define BIT_AND(_s, d, s) do { \ +#define __BIT_AND(_s, d, s) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] &= (s)->__bits[__i]; \ } while (0) -#define BIT_AND2(_s, d, s1, s2) do { \ +#define __BIT_AND2(_s, d, s1, s2) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] = (s1)->__bits[__i] & (s2)->__bits[__i];\ } while (0) -#define BIT_ANDNOT(_s, d, s) do { \ +#define __BIT_ANDNOT(_s, d, s) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] &= ~(s)->__bits[__i]; \ } while (0) -#define BIT_ANDNOT2(_s, d, s1, s2) do { \ +#define __BIT_ANDNOT2(_s, d, s1, s2) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] = (s1)->__bits[__i] & ~(s2)->__bits[__i];\ } while (0) -#define BIT_XOR(_s, d, s) do { \ +#define __BIT_XOR(_s, d, s) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] ^= (s)->__bits[__i]; \ } while (0) -#define BIT_XOR2(_s, d, s1, s2) do { \ +#define __BIT_XOR2(_s, d, s1, s2) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ (d)->__bits[__i] = (s1)->__bits[__i] ^ (s2)->__bits[__i];\ @@ -179,42 +179,42 @@ * or a bit index. */ -#define BIT_CLR_ATOMIC(_s, n, p) \ +#define __BIT_CLR_ATOMIC(_s, n, p) \ atomic_clear_long(&(p)->__bits[__bitset_word(_s, n)], \ __bitset_mask((_s), n)) -#define BIT_SET_ATOMIC(_s, n, p) \ +#define __BIT_SET_ATOMIC(_s, n, p) \ atomic_set_long(&(p)->__bits[__bitset_word(_s, n)], \ __bitset_mask((_s), n)) -#define BIT_SET_ATOMIC_ACQ(_s, n, p) \ +#define __BIT_SET_ATOMIC_ACQ(_s, n, p) \ atomic_set_acq_long(&(p)->__bits[__bitset_word(_s, n)], \ __bitset_mask((_s), n)) -#define BIT_TEST_CLR_ATOMIC(_s, n, p) \ +#define __BIT_TEST_CLR_ATOMIC(_s, n, p) \ (atomic_testandclear_long( \ &(p)->__bits[__bitset_word((_s), (n))], (n)) != 0) -#define BIT_TEST_SET_ATOMIC(_s, n, p) \ +#define __BIT_TEST_SET_ATOMIC(_s, n, p) \ (atomic_testandset_long( \ &(p)->__bits[__bitset_word((_s), (n))], (n)) != 0) /* Convenience functions catering special cases. */ -#define BIT_AND_ATOMIC(_s, d, s) do { \ +#define __BIT_AND_ATOMIC(_s, d, s) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ atomic_clear_long(&(d)->__bits[__i], \ ~(s)->__bits[__i]); \ } while (0) -#define BIT_OR_ATOMIC(_s, d, s) do { \ +#define __BIT_OR_ATOMIC(_s, d, s) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ atomic_set_long(&(d)->__bits[__i], \ (s)->__bits[__i]); \ } while (0) -#define BIT_COPY_STORE_REL(_s, f, t) do { \ +#define __BIT_COPY_STORE_REL(_s, f, t) do { \ __size_t __i; \ for (__i = 0; __i < __bitset_words((_s)); __i++) \ atomic_store_rel_long(&(t)->__bits[__i], \ @@ -222,10 +222,10 @@ } while (0) /* - * Note that `start` and the returned value from BIT_FFS_AT are + * Note that `start` and the returned value from __BIT_FFS_AT are * 1-based bit indices. */ -#define BIT_FFS_AT(_s, p, start) __extension__ ({ \ +#define __BIT_FFS_AT(_s, p, start) __extension__ ({ \ __size_t __i; \ long __bit, __mask; \ \ @@ -244,9 +244,9 @@ __bit; \ }) -#define BIT_FFS(_s, p) BIT_FFS_AT((_s), (p), 0) +#define __BIT_FFS(_s, p) __BIT_FFS_AT((_s), (p), 0) -#define BIT_FLS(_s, p) __extension__ ({ \ +#define __BIT_FLS(_s, p) __extension__ ({ \ __size_t __i; \ long __bit; \ \ @@ -261,7 +261,7 @@ __bit; \ }) -#define BIT_COUNT(_s, p) __extension__ ({ \ +#define __BIT_COUNT(_s, p) __extension__ ({ \ __size_t __i; \ long __count; \ \ @@ -271,7 +271,7 @@ __count; \ }) -#define _BIT_FOREACH_ADVANCE(_s, i, p, op) __extension__ ({ \ +#define __BIT_FOREACH_ADVANCE(_s, i, p, op) __extension__ ({ \ int __found; \ for (;;) { \ if (__bits != 0) { \ @@ -293,12 +293,12 @@ /* * Non-destructively loop over all set or clear bits in the set. */ -#define _BIT_FOREACH(_s, i, p, op) \ +#define __BIT_FOREACH(_s, i, p, op) \ for (long __i = -1, __bits = 0; \ - _BIT_FOREACH_ADVANCE(_s, i, p, op); ) + __BIT_FOREACH_ADVANCE(_s, i, p, op); ) -#define BIT_FOREACH_ISSET(_s, i, p) _BIT_FOREACH(_s, i, p, ) -#define BIT_FOREACH_ISCLR(_s, i, p) _BIT_FOREACH(_s, i, p, ~) +#define __BIT_FOREACH_ISSET(_s, i, p) __BIT_FOREACH(_s, i, p, ) +#define __BIT_FOREACH_ISCLR(_s, i, p) __BIT_FOREACH(_s, i, p, ~) #define BITSET_T_INITIALIZER(x) \ { .__bits = { x } } @@ -313,4 +313,42 @@ */ #define BITSET_ALLOC(_s, mt, mf) malloc(BITSET_SIZE((_s)), mt, (mf)) +#ifdef _KERNEL +#define BIT_AND __BIT_AND +#define BIT_AND2 __BIT_AND2 +#define BIT_ANDNOT __BIT_ANDNOT +#define BIT_ANDNOT2 __BIT_ANDNOT2 +#define BIT_AND_ATOMIC __BIT_AND_ATOMIC +#define BIT_CLR __BIT_CLR +#define BIT_CLR_ATOMIC __BIT_CLR_ATOMIC +#define BIT_CMP __BIT_CMP +#define BIT_COPY __BIT_COPY +#define BIT_COPY_STORE_REL __BIT_COPY_STORE_REL +#define BIT_COUNT __BIT_COUNT +#define BIT_EMPTY __BIT_EMPTY +#define BIT_FFS __BIT_FFS +#define BIT_FFS_AT __BIT_FFS_AT +#define BIT_FILL __BIT_FILL +#define BIT_FLS __BIT_FLS +#define BIT_FOREACH_ADVANCE __BIT_FOREACH_ADVANCE +#define BIT_FOREACH_ISCLR __BIT_FOREACH_ISCLR +#define BIT_FOREACH_ISSET __BIT_FOREACH_ISSET +#define BIT_ISFULLSET __BIT_ISFULLSET +#define BIT_ISSET __BIT_ISSET +#define BIT_OR __BIT_OR +#define BIT_OR2 __BIT_OR2 +#define BIT_OR_ATOMIC __BIT_OR_ATOMIC +#define BIT_OVERLAP __BIT_OVERLAP +#define BIT_SET __BIT_SET +#define BIT_SETOF __BIT_SETOF +#define BIT_SET_ATOMI __BIT_SET_ATOMIC +#define BIT_SET_ATOMIC_ACQ __BIT_SET_ATOMIC_ACQ +#define BIT_SUBSET __BIT_SUBSET +#define BIT_TEST_CLR_ATOMIC __BIT_TEST_CLR_ATOMIC +#define BIT_TEST_SET_ATOMIC __BIT_TEST_SET_ATOMIC +#define BIT_XOR __BIT_XOR +#define BIT_XOR2 __BIT_XOR2 +#define BIT_ZERO __BIT_ZERO +#endif + #endif /* !_SYS_BITSET_H_ */ diff --git a/sys/sys/cpuset.h b/sys/sys/cpuset.h --- a/sys/sys/cpuset.h +++ b/sys/sys/cpuset.h @@ -43,33 +43,33 @@ #define CPUSETBUFSIZ ((2 + sizeof(long) * 2) * _NCPUWORDS) -#define CPU_CLR(n, p) BIT_CLR(CPU_SETSIZE, n, p) -#define CPU_COPY(f, t) BIT_COPY(CPU_SETSIZE, f, t) -#define CPU_ISSET(n, p) BIT_ISSET(CPU_SETSIZE, n, p) -#define CPU_SET(n, p) BIT_SET(CPU_SETSIZE, n, p) -#define CPU_ZERO(p) BIT_ZERO(CPU_SETSIZE, p) -#define CPU_FILL(p) BIT_FILL(CPU_SETSIZE, p) -#define CPU_SETOF(n, p) BIT_SETOF(CPU_SETSIZE, n, p) -#define CPU_EQUAL(p, c) (BIT_CMP(CPU_SETSIZE, p, c) == 0) -#define CPU_EMPTY(p) BIT_EMPTY(CPU_SETSIZE, p) -#define CPU_ISFULLSET(p) BIT_ISFULLSET(CPU_SETSIZE, p) -#define CPU_SUBSET(p, c) BIT_SUBSET(CPU_SETSIZE, p, c) -#define CPU_OVERLAP(p, c) BIT_OVERLAP(CPU_SETSIZE, p, c) -#define CPU_CMP(p, c) BIT_CMP(CPU_SETSIZE, p, c) -#define CPU_OR(d, s) BIT_OR(CPU_SETSIZE, d, s) -#define CPU_AND(d, s) BIT_AND(CPU_SETSIZE, d, s) -#define CPU_ANDNOT(d, s) BIT_ANDNOT(CPU_SETSIZE, d, s) -#define CPU_CLR_ATOMIC(n, p) BIT_CLR_ATOMIC(CPU_SETSIZE, n, p) -#define CPU_SET_ATOMIC(n, p) BIT_SET_ATOMIC(CPU_SETSIZE, n, p) -#define CPU_SET_ATOMIC_ACQ(n, p) BIT_SET_ATOMIC_ACQ(CPU_SETSIZE, n, p) -#define CPU_AND_ATOMIC(n, p) BIT_AND_ATOMIC(CPU_SETSIZE, n, p) -#define CPU_OR_ATOMIC(d, s) BIT_OR_ATOMIC(CPU_SETSIZE, d, s) -#define CPU_COPY_STORE_REL(f, t) BIT_COPY_STORE_REL(CPU_SETSIZE, f, t) -#define CPU_FFS(p) BIT_FFS(CPU_SETSIZE, p) -#define CPU_FLS(p) BIT_FLS(CPU_SETSIZE, p) -#define CPU_FOREACH_ISSET(i, p) BIT_FOREACH_ISSET(CPU_SETSIZE, i, p) -#define CPU_FOREACH_ISCLR(i, p) BIT_FOREACH_ISCLR(CPU_SETSIZE, i, p) -#define CPU_COUNT(p) ((int)BIT_COUNT(CPU_SETSIZE, p)) +#define CPU_CLR(n, p) __BIT_CLR(CPU_SETSIZE, n, p) +#define CPU_COPY(f, t) __BIT_COPY(CPU_SETSIZE, f, t) +#define CPU_ISSET(n, p) __BIT_ISSET(CPU_SETSIZE, n, p) +#define CPU_SET(n, p) __BIT_SET(CPU_SETSIZE, n, p) +#define CPU_ZERO(p) __BIT_ZERO(CPU_SETSIZE, p) +#define CPU_FILL(p) __BIT_FILL(CPU_SETSIZE, p) +#define CPU_SETOF(n, p) __BIT_SETOF(CPU_SETSIZE, n, p) +#define CPU_EQUAL(p, c) (__BIT_CMP(CPU_SETSIZE, p, c) == 0) +#define CPU_EMPTY(p) __BIT_EMPTY(CPU_SETSIZE, p) +#define CPU_ISFULLSET(p) __BIT_ISFULLSET(CPU_SETSIZE, p) +#define CPU_SUBSET(p, c) __BIT_SUBSET(CPU_SETSIZE, p, c) +#define CPU_OVERLAP(p, c) __BIT_OVERLAP(CPU_SETSIZE, p, c) +#define CPU_CMP(p, c) __BIT_CMP(CPU_SETSIZE, p, c) +#define CPU_OR(d, s) __BIT_OR(CPU_SETSIZE, d, s) +#define CPU_AND(d, s) __BIT_AND(CPU_SETSIZE, d, s) +#define CPU_ANDNOT(d, s) __BIT_ANDNOT(CPU_SETSIZE, d, s) +#define CPU_CLR_ATOMIC(n, p) __BIT_CLR_ATOMIC(CPU_SETSIZE, n, p) +#define CPU_SET_ATOMIC(n, p) __BIT_SET_ATOMIC(CPU_SETSIZE, n, p) +#define CPU_SET_ATOMIC_ACQ(n, p) __BIT_SET_ATOMIC_ACQ(CPU_SETSIZE, n, p) +#define CPU_AND_ATOMIC(n, p) __BIT_AND_ATOMIC(CPU_SETSIZE, n, p) +#define CPU_OR_ATOMIC(d, s) __BIT_OR_ATOMIC(CPU_SETSIZE, d, s) +#define CPU_COPY_STORE_REL(f, t) __BIT_COPY_STORE_REL(CPU_SETSIZE, f, t) +#define CPU_FFS(p) __BIT_FFS(CPU_SETSIZE, p) +#define CPU_FLS(p) __BIT_FLS(CPU_SETSIZE, p) +#define CPU_FOREACH_ISSET(i, p) __BIT_FOREACH_ISSET(CPU_SETSIZE, i, p) +#define CPU_FOREACH_ISCLR(i, p) __BIT_FOREACH_ISCLR(CPU_SETSIZE, i, p) +#define CPU_COUNT(p) ((int)__BIT_COUNT(CPU_SETSIZE, p)) #define CPUSET_FSET BITSET_FSET(_NCPUWORDS) #define CPUSET_T_INITIALIZER BITSET_T_INITIALIZER diff --git a/sys/sys/domainset.h b/sys/sys/domainset.h --- a/sys/sys/domainset.h +++ b/sys/sys/domainset.h @@ -43,32 +43,32 @@ sizeof("::") + sizeof(__XSTRING(DOMAINSET_POLICY_MAX)) + \ sizeof(__XSTRING(MAXMEMDOM))) -#define DOMAINSET_CLR(n, p) BIT_CLR(DOMAINSET_SETSIZE, n, p) -#define DOMAINSET_COPY(f, t) BIT_COPY(DOMAINSET_SETSIZE, f, t) -#define DOMAINSET_ISSET(n, p) BIT_ISSET(DOMAINSET_SETSIZE, n, p) -#define DOMAINSET_SET(n, p) BIT_SET(DOMAINSET_SETSIZE, n, p) -#define DOMAINSET_ZERO(p) BIT_ZERO(DOMAINSET_SETSIZE, p) -#define DOMAINSET_FILL(p) BIT_FILL(DOMAINSET_SETSIZE, p) -#define DOMAINSET_SETOF(n, p) BIT_SETOF(DOMAINSET_SETSIZE, n, p) -#define DOMAINSET_EMPTY(p) BIT_EMPTY(DOMAINSET_SETSIZE, p) -#define DOMAINSET_ISFULLSET(p) BIT_ISFULLSET(DOMAINSET_SETSIZE, p) -#define DOMAINSET_SUBSET(p, c) BIT_SUBSET(DOMAINSET_SETSIZE, p, c) -#define DOMAINSET_OVERLAP(p, c) BIT_OVERLAP(DOMAINSET_SETSIZE, p, c) -#define DOMAINSET_CMP(p, c) BIT_CMP(DOMAINSET_SETSIZE, p, c) -#define DOMAINSET_OR(d, s) BIT_OR(DOMAINSET_SETSIZE, d, s) -#define DOMAINSET_AND(d, s) BIT_AND(DOMAINSET_SETSIZE, d, s) -#define DOMAINSET_ANDNOT(d, s) BIT_ANDNOT(DOMAINSET_SETSIZE, d, s) -#define DOMAINSET_CLR_ATOMIC(n, p) BIT_CLR_ATOMIC(DOMAINSET_SETSIZE, n, p) -#define DOMAINSET_SET_ATOMIC(n, p) BIT_SET_ATOMIC(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_CLR(n, p) __BIT_CLR(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_COPY(f, t) __BIT_COPY(DOMAINSET_SETSIZE, f, t) +#define DOMAINSET_ISSET(n, p) __BIT_ISSET(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_SET(n, p) __BIT_SET(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_ZERO(p) __BIT_ZERO(DOMAINSET_SETSIZE, p) +#define DOMAINSET_FILL(p) __BIT_FILL(DOMAINSET_SETSIZE, p) +#define DOMAINSET_SETOF(n, p) __BIT_SETOF(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_EMPTY(p) __BIT_EMPTY(DOMAINSET_SETSIZE, p) +#define DOMAINSET_ISFULLSET(p) __BIT_ISFULLSET(DOMAINSET_SETSIZE, p) +#define DOMAINSET_SUBSET(p, c) __BIT_SUBSET(DOMAINSET_SETSIZE, p, c) +#define DOMAINSET_OVERLAP(p, c) __BIT_OVERLAP(DOMAINSET_SETSIZE, p, c) +#define DOMAINSET_CMP(p, c) __BIT_CMP(DOMAINSET_SETSIZE, p, c) +#define DOMAINSET_OR(d, s) __BIT_OR(DOMAINSET_SETSIZE, d, s) +#define DOMAINSET_AND(d, s) __BIT_AND(DOMAINSET_SETSIZE, d, s) +#define DOMAINSET_ANDNOT(d, s) __BIT_ANDNOT(DOMAINSET_SETSIZE, d, s) +#define DOMAINSET_CLR_ATOMIC(n, p) __BIT_CLR_ATOMIC(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_SET_ATOMIC(n, p) __BIT_SET_ATOMIC(DOMAINSET_SETSIZE, n, p) #define DOMAINSET_SET_ATOMIC_ACQ(n, p) \ - BIT_SET_ATOMIC_ACQ(DOMAINSET_SETSIZE, n, p) -#define DOMAINSET_AND_ATOMIC(n, p) BIT_AND_ATOMIC(DOMAINSET_SETSIZE, n, p) -#define DOMAINSET_OR_ATOMIC(d, s) BIT_OR_ATOMIC(DOMAINSET_SETSIZE, d, s) + __BIT_SET_ATOMIC_ACQ(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_AND_ATOMIC(n, p) __BIT_AND_ATOMIC(DOMAINSET_SETSIZE, n, p) +#define DOMAINSET_OR_ATOMIC(d, s) __BIT_OR_ATOMIC(DOMAINSET_SETSIZE, d, s) #define DOMAINSET_COPY_STORE_REL(f, t) \ - BIT_COPY_STORE_REL(DOMAINSET_SETSIZE, f, t) -#define DOMAINSET_FFS(p) BIT_FFS(DOMAINSET_SETSIZE, p) -#define DOMAINSET_FLS(p) BIT_FLS(DOMAINSET_SETSIZE, p) -#define DOMAINSET_COUNT(p) ((int)BIT_COUNT(DOMAINSET_SETSIZE, p)) + __BIT_COPY_STORE_REL(DOMAINSET_SETSIZE, f, t) +#define DOMAINSET_FFS(p) __BIT_FFS(DOMAINSET_SETSIZE, p) +#define DOMAINSET_FLS(p) __BIT_FLS(DOMAINSET_SETSIZE, p) +#define DOMAINSET_COUNT(p) ((int)__BIT_COUNT(DOMAINSET_SETSIZE, p)) #define DOMAINSET_FSET BITSET_FSET(_NDOMAINSETWORDS) #define DOMAINSET_T_INITIALIZER BITSET_T_INITIALIZER diff --git a/sys/vm/vm_dumpset.h b/sys/vm/vm_dumpset.h --- a/sys/vm/vm_dumpset.h +++ b/sys/vm/vm_dumpset.h @@ -50,7 +50,7 @@ adj = 0; for (i = 0; dump_avail[i + 1] != 0; i += 2) { if (pa >= dump_avail[i] && pa < dump_avail[i + 1]) { - BIT_SET_ATOMIC(vm_page_dump_pages, + __BIT_SET_ATOMIC(vm_page_dump_pages, (pa >> PAGE_SHIFT) - (dump_avail[i] >> PAGE_SHIFT) + adj, bitset); return; @@ -69,7 +69,7 @@ adj = 0; for (i = 0; dump_avail[i + 1] != 0; i += 2) { if (pa >= dump_avail[i] && pa < dump_avail[i + 1]) { - BIT_CLR_ATOMIC(vm_page_dump_pages, + __BIT_CLR_ATOMIC(vm_page_dump_pages, (pa >> PAGE_SHIFT) - (dump_avail[i] >> PAGE_SHIFT) + adj, bitset); return; @@ -96,8 +96,8 @@ } #define VM_PAGE_DUMP_FOREACH(bitset, pa) \ - for (vm_pindex_t __b = BIT_FFS(vm_page_dump_pages, bitset); \ + for (vm_pindex_t __b = __BIT_FFS(vm_page_dump_pages, bitset); \ (pa) = vm_page_dump_index_to_pa(__b - 1), __b != 0; \ - __b = BIT_FFS_AT(vm_page_dump_pages, bitset, __b)) + __b = __BIT_FFS_AT(vm_page_dump_pages, bitset, __b)) #endif /* _SYS_DUMPSET_H_ */ diff --git a/tests/sys/sys/bitset_test.c b/tests/sys/sys/bitset_test.c --- a/tests/sys/sys/bitset_test.c +++ b/tests/sys/sys/bitset_test.c @@ -15,6 +15,15 @@ #include +#define BIT_CLR __BIT_CLR +#define BIT_FILL __BIT_FILL +#define BIT_FOREACH_COUNT __BIT_FOREACH_COUNT +#define BIT_FOREACH_ISCLR __BIT_FOREACH_ISCLR +#define BIT_FOREACH_ISSET __BIT_FOREACH_ISSET +#define BIT_ISSET __BIT_ISSET +#define BIT_SET __BIT_SET +#define BIT_ZERO __BIT_ZERO + BITSET_DEFINE(bs256, 256); ATF_TC_WITHOUT_HEAD(bit_foreach); diff --git a/usr.bin/cpuset/cpuset.c b/usr.bin/cpuset/cpuset.c --- a/usr.bin/cpuset/cpuset.c +++ b/usr.bin/cpuset/cpuset.c @@ -50,6 +50,9 @@ #include #include +#define BIT_SET __BIT_SET +#define BIT_ISSET __BIT_ISSET + static int Cflag; static int cflag; static int dflag;