Page MenuHomeFreeBSD
Files F141092586

D33235.id99357.diff
No OneTemporary
Actions

D33235.id99357.diff
View Options

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 <atf-c.h>
+#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 <unistd.h>
#include <string.h>
+#define BIT_SET __BIT_SET
+#define BIT_ISSET __BIT_ISSET
+
static int Cflag;
static int cflag;
static int dflag;

File Metadata

Mime Type
text/plain
Expires
Thu, Jan 1, 6:31 PM (6 h, 46 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
27442492
Default Alt Text
D33235.id99357.diff (18 KB)

Event Timeline