Stefan Eßer wrote: > The branch main has been updated by se: > > URL: > https://cgit.FreeBSD.org/src/commit/?id=5e04571cf3cf4024be926976a6abf19626df30be > > commit 5e04571cf3cf4024be926976a6abf19626df30be > Author: Stefan Eßer <s...@freebsd.org> > AuthorDate: 2021-12-05 21:27:33 +0000 > Commit: Stefan Eßer <s...@freebsd.org> > CommitDate: 2021-12-05 22:00:25 +0000 > > sys/bitset.h: reduce visibility of BIT_* macros > > Add two underscore characters "__" to names of BIT_* and BITSET_* > macros to move them to the implementation name space and to prevent > a name space pollution due to BIT_* macros in 3rd party programs with > conflicting parameter signatures. > > These prefixed macro names are used in kernel header files to define > macros in e.g. sched.h, sys/cpuset.h and sys/domainset.h. > > If C programs are built with either -D_KERNEL (automatically passed > when building a kernel or kernel modules) or -D_WANT_FREENBSD_BITSET > (or this macros is defined in the source code before including the > bitset macros), then all macros are made visible with their previous > names, too. E.g., both __BIT_SET() and BIT_SET() are visible with > either of _KERNEL or _WANT_FREEBSD_BITSET defined. > > The main reason for this change is that some 3rd party sources > including sched.h have been found to contain conflicting BIT_* > macros. > > As a work-around, parts of shed.h have been made conditional and > depend on _WITH_CPU_SET_T being set when sched.h is included. > Ports that expect the full functionality provided by sched.h need > to be built with -D_WITH_CPU_SET_T. But this leads to conflicts if > BIT_* macros are defined in that program, too. > > This patch set makes all of sched.h visible again without this > parameter being passed and without any name space pollution due > to BIT_* macros becoming visible when sched.h is included.
I think I've spotted an issue in the devel/libvirt port related to this change. IIUC, the original -D_WITH_CPU_SET_T knob was added in commit 90fa9705d5cd29cf11c5dc7319299788dec2546a as a workaround because many third party build systems assume glibc compatibility if they can detect sched_getaffinity(). As there's no 100% compatibility and, specifically, not all CPU_* macros are implemented, related user code fails to build. To handle this in libvirt, I've updated the build system to detect cpu_set_t presence instead of sched_getaffinity() which appears to be more accurate. With this commit, this breaks again because cpu_set_t is now visible without extra flags, but some macros are missing and the build fails. I can fix it in libvirt, but I imagine other packages might be affected as well. I'm wondering if it makes sense to keep hiding cpu_set_t under -D_WITH_CPU_SET_T while not all CPU_* macros are implemented? > > This patch set will be backported to the STABLE branches, but ports > will need to use -D_WITH_CPU_SET_T as long as there are supported > releases that do not contain these patches. > > Reviewed by: kib, markj > MFC after: 1 month > Relnotes: yes > Differential Revision: https://reviews.freebsd.org/D33235 > --- > include/sched.h | 4 -- > lib/libmemstat/memstat_uma.c | 2 + > sbin/pfctl/pfctl_altq.c | 1 + > sbin/pfctl/pfctl_parser.h | 2 +- > share/man/man9/bitset.9 | 25 +++++++++ > sys/sys/_bitset.h | 13 +++-- > sys/sys/_cpuset.h | 2 +- > sys/sys/_domainset.h | 2 +- > sys/sys/bitset.h | 130 > +++++++++++++++++++++++++++++-------------- > sys/sys/cpuset.h | 58 +++++++++---------- > sys/sys/domainset.h | 52 ++++++++--------- > tests/sys/sys/bitset_test.c | 2 + > usr.bin/cpuset/cpuset.c | 2 + > 13 files changed, 186 insertions(+), 109 deletions(-) > > diff --git a/include/sched.h b/include/sched.h > index 460d3bfed154..2d4f301c9718 100644 > --- a/include/sched.h > +++ b/include/sched.h > @@ -33,20 +33,16 @@ > #include <sys/types.h> > #include <sys/sched.h> > #if __BSD_VISIBLE > -#ifdef _WITH_CPU_SET_T > #include <sys/cpuset.h> > struct _cpuset; > typedef struct _cpuset cpu_set_t; > -#endif /* _WITH_CPU_SET_T */ > #endif /* __BSD_VISIBLE */ > > __BEGIN_DECLS > #if __BSD_VISIBLE > -#ifdef _WITH_CPU_SET_T > int sched_getaffinity(pid_t pid, size_t cpusetsz, cpuset_t *cpuset); > int sched_setaffinity(int pid, size_t cpusetsz, const cpuset_t *cpuset); > int sched_getcpu(void); > -#endif /* _WITH_CPU_SET_T */ > #endif /* __BSD_VISIBLE */ > __END_DECLS > > diff --git a/lib/libmemstat/memstat_uma.c b/lib/libmemstat/memstat_uma.c > index b416cbc63297..980a674ab76e 100644 > --- a/lib/libmemstat/memstat_uma.c > +++ b/lib/libmemstat/memstat_uma.c > @@ -28,6 +28,8 @@ > * $FreeBSD$ > */ > > +#define _WANT_FREEBSD_BITSET > + > #include <sys/param.h> > #include <sys/counter.h> > #include <sys/cpuset.h> > diff --git a/sbin/pfctl/pfctl_altq.c b/sbin/pfctl/pfctl_altq.c > index 304bf69d7c7a..6d35ae77240f 100644 > --- a/sbin/pfctl/pfctl_altq.c > +++ b/sbin/pfctl/pfctl_altq.c > @@ -22,6 +22,7 @@ > __FBSDID("$FreeBSD$"); > > #define PFIOC_USE_LATEST > +#define _WANT_FREEBSD_BITSET > > #include <sys/types.h> > #include <sys/bitset.h> > diff --git a/sbin/pfctl/pfctl_parser.h b/sbin/pfctl/pfctl_parser.h > index 4e144b97567b..0cd19a560f8d 100644 > --- a/sbin/pfctl/pfctl_parser.h > +++ b/sbin/pfctl/pfctl_parser.h > @@ -184,7 +184,7 @@ struct node_queue_opt { > }; > > #define QPRI_BITSET_SIZE 256 > -BITSET_DEFINE(qpri_bitset, QPRI_BITSET_SIZE); > +__BITSET_DEFINE(qpri_bitset, QPRI_BITSET_SIZE); > LIST_HEAD(gen_sc, segment); > > struct pfctl_altq { > diff --git a/share/man/man9/bitset.9 b/share/man/man9/bitset.9 > index 1a5ec05b01c6..e6ce3d9b4f58 100644 > --- a/share/man/man9/bitset.9 > +++ b/share/man/man9/bitset.9 > @@ -164,6 +164,7 @@ > .Fo BIT_COPY_STORE_REL > .Fa "const SETSIZE" "struct STRUCTNAME *from" "struct STRUCTNAME *to" > .Fc > +.Fd #define _WANT_FREEBSD_BITSET > .Sh DESCRIPTION > The > .Nm > @@ -179,6 +180,16 @@ One example use of > is > .In sys/cpuset.h . > .Pp > +These macros are meant to be used in the kernel and are visible if > +.Dv _KERNEL is defined when > +.In sys/_bitset.h > +or > +.In sys/bitset.h > +are included in a program. > +Userland programs must define > +.Dv _WANT_FREEBSD_BITSET > +before including these files to make the macros visible. > +.Pp > The > .Fn BITSET_DEFINE > macro defines a bitset struct > @@ -584,3 +595,17 @@ Unlike every other reference to individual set members, > which are zero-indexed, > and > .Fn BIT_FLS > return a one-indexed result (or zero if the set is empty). > +.Pp > +In order to use the macros defined in > +.In sys/bitset.h > +and > +.In sys/_bitset.h > +in userland programs, > +.Dv _WANT_FREEBSD_BITSET > +has to be defined before including the header files. > +This requirements exists to prevent a name space pollution due to macros > defined in > +.Nm > +in programs that include > +.In sys/cpuset.h > +or > +.In sched.h . > diff --git a/sys/sys/_bitset.h b/sys/sys/_bitset.h > index e54f04cbeee7..1c167daf3f09 100644 > --- a/sys/sys/_bitset.h > +++ b/sys/sys/_bitset.h > @@ -44,8 +44,8 @@ > > #define __bitset_words(_s) (__howmany(_s, _BITSET_BITS)) > > -#define BITSET_DEFINE(t, _s) > \ > -struct t { \ > +#define __BITSET_DEFINE(_t, _s) > \ > +struct _t { \ > long __bits[__bitset_words((_s))]; > \ > } > > @@ -55,12 +55,17 @@ struct t { > \ > * Sadly we cannot declare a bitset struct with '__bits[]', because it's > * the only member of the struct and the compiler complains. > */ > -#define BITSET_DEFINE_VAR(t) BITSET_DEFINE(t, 1) > +#define __BITSET_DEFINE_VAR(_t) __BITSET_DEFINE(_t, 1) > > /* > * Define a default type that can be used while manually specifying size > * to every call. > */ > -BITSET_DEFINE(bitset, 1); > +__BITSET_DEFINE(bitset, 1); > + > +#if defined(_KERNEL) || defined(_WANT_FREEBSD_BITSET) > +#define BITSET_DEFINE(_t, _s) __BITSET_DEFINE(_t, _s) > +#define BITSET_DEFINE_VAR(_t) __BITSET_DEFINE_VAR(_t) > +#endif > > #endif /* !_SYS__BITSET_H_ */ > diff --git a/sys/sys/_cpuset.h b/sys/sys/_cpuset.h > index cb3c0f9d586e..9033acb9ba14 100644 > --- a/sys/sys/_cpuset.h > +++ b/sys/sys/_cpuset.h > @@ -46,7 +46,7 @@ > #define CPU_SETSIZE CPU_MAXSIZE > #endif > > -BITSET_DEFINE(_cpuset, CPU_SETSIZE); > +__BITSET_DEFINE(_cpuset, CPU_SETSIZE); > typedef struct _cpuset cpuset_t; > > #endif /* !_SYS__CPUSET_H_ */ > diff --git a/sys/sys/_domainset.h b/sys/sys/_domainset.h > index 5685d532a9e3..443c68fd331b 100644 > --- a/sys/sys/_domainset.h > +++ b/sys/sys/_domainset.h > @@ -43,7 +43,7 @@ > #define DOMAINSET_SETSIZE DOMAINSET_MAXSIZE > #endif > > -BITSET_DEFINE(_domainset, DOMAINSET_SETSIZE); > +__BITSET_DEFINE(_domainset, DOMAINSET_SETSIZE); > typedef struct _domainset domainset_t; > > /* > diff --git a/sys/sys/bitset.h b/sys/sys/bitset.h > index 1c154d5601ab..91a5e6e37db3 100644 > --- 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,24 +293,68 @@ > /* > * 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) > \ > +#define __BITSET_T_INITIALIZER(x) > \ > { .__bits = { x } } > > -#define BITSET_FSET(n) > \ > +#define __BITSET_FSET(n) > \ > [ 0 ... ((n) - 1) ] = (-1L) > > -#define BITSET_SIZE(_s) (__bitset_words((_s)) * sizeof(long)) > +#define __BITSET_SIZE(_s) (__bitset_words((_s)) * sizeof(long)) > > /* > * Dynamically allocate a bitset. > */ > -#define BITSET_ALLOC(_s, mt, mf) malloc(BITSET_SIZE((_s)), mt, (mf)) > +#define __BITSET_ALLOC(_s, mt, mf) malloc(__BITSET_SIZE((_s)), mt, (mf)) > + > +#if defined(_KERNEL) || defined(_WANT_FREEBSD_BITSET) > +#define BIT_AND(_s, d, s) __BIT_AND(_s, d, s) > +#define BIT_AND2(_s, d, s1, s2) __BIT_AND2(_s, d, s1, > s2) > +#define BIT_ANDNOT(_s, d, s) __BIT_ANDNOT(_s, d, s) > +#define BIT_ANDNOT2(_s, d, s1, s2) __BIT_ANDNOT2(_s, d, > s1, s2) > +#define BIT_AND_ATOMIC(_s, d, s) __BIT_AND_ATOMIC(_s, d, > s) > +#define BIT_CLR(_s, n, p) __BIT_CLR(_s, n, p) > +#define BIT_CLR_ATOMIC(_s, n, p) __BIT_CLR_ATOMIC(_s, n, > p) > +#define BIT_CMP(_s, p, c) __BIT_CMP(_s, p, c) > +#define BIT_COPY(_s, f, t) __BIT_COPY(_s, f, t) > +#define BIT_COPY_STORE_REL(_s, f, t) > __BIT_COPY_STORE_REL(_s, f, t) > +#define BIT_COUNT(_s, p) __BIT_COUNT(_s, p) > +#define BIT_EMPTY(_s, p) __BIT_EMPTY(_s, p) > +#define BIT_FFS(_s, p) __BIT_FFS(_s, p) > +#define BIT_FFS_AT(_s, p, start) __BIT_FFS_AT(_s, p, > start) > +#define BIT_FILL(_s, p) __BIT_FILL(_s, p) > +#define BIT_FLS(_s, p) __BIT_FLS(_s, p) > +#define BIT_FOREACH(_s, i, p, op) __BIT_FOREACH(_s, i, p, op) > +#define BIT_FOREACH_ADVANCE(_s, i, p, op) > __BIT_FOREACH_ADVANCE(_s, i, p, op) > +#define BIT_FOREACH_ISCLR(_s, i, p) __BIT_FOREACH_ISCLR(_s, > i, p) > +#define BIT_FOREACH_ISSET(_s, i, p) __BIT_FOREACH_ISSET(_s, > i, p) > +#define BIT_ISFULLSET(_s, p) __BIT_ISFULLSET(_s, p) > +#define BIT_ISSET(_s, n, p) __BIT_ISSET(_s, n, p) > +#define BIT_OR(_s, d, s) __BIT_OR(_s, d, s) > +#define BIT_OR2(_s, d, s1, s2) __BIT_OR2(_s, d, s1, s2) > +#define BIT_OR_ATOMIC(_s, d, s) __BIT_OR_ATOMIC(_s, d, > s) > +#define BIT_OVERLAP(_s, p, c) __BIT_OVERLAP(_s, p, c) > +#define BIT_SET(_s, n, p) __BIT_SET(_s, n, p) > +#define BIT_SETOF(_s, n, p) __BIT_SETOF(_s, n, p) > +#define BIT_SET_ATOMIC(_s, n, p) __BIT_SET_ATOMIC(_s, n, > p) > +#define BIT_SET_ATOMIC_ACQ(_s, n, p) > __BIT_SET_ATOMIC_ACQ(_s, n, p) > +#define BIT_SUBSET(_s, p, c) __BIT_SUBSET(_s, p, c) > +#define BIT_TEST_CLR_ATOMIC(_s, n, p) > __BIT_TEST_CLR_ATOMIC(_s, n, p) > +#define BIT_TEST_SET_ATOMIC(_s, n, p) > __BIT_TEST_SET_ATOMIC(_s, n, p) > +#define BIT_XOR(_s, d, s) __BIT_XOR(_s, d, s) > +#define BIT_XOR2(_s, d, s1, s2) __BIT_XOR2(_s, d, s1, > s2) > +#define BIT_ZERO(_s, p) __BIT_ZERO(_s, p) > + > +#define BITSET_ALLOC(_s, mt, mf) __BITSET_ALLOC(_s, mt, mf) > +#define BITSET_FSET(n) __BITSET_FSET(n) > +#define BITSET_SIZE(_s) __BITSET_SIZE(_s) > +#define BITSET_T_INITIALIZER(x) > __BITSET_T_INITIALIZER(x) > +#endif > > #endif /* !_SYS_BITSET_H_ */ > diff --git a/sys/sys/cpuset.h b/sys/sys/cpuset.h > index 602f73fbe5e4..71317670c593 100644 > --- a/sys/sys/cpuset.h > +++ b/sys/sys/cpuset.h > @@ -43,35 +43,35 @@ > > #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 CPUSET_FSET BITSET_FSET(_NCPUWORDS) > -#define CPUSET_T_INITIALIZER BITSET_T_INITIALIZER > +#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(x) __BITSET_T_INITIALIZER(x) > > /* > * Valid cpulevel_t values. > diff --git a/sys/sys/domainset.h b/sys/sys/domainset.h > index 2113196d8d26..51b5011fcb4e 100644 > --- a/sys/sys/domainset.h > +++ b/sys/sys/domainset.h > @@ -43,34 +43,34 @@ > 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)) > -#define DOMAINSET_FSET BITSET_FSET(_NDOMAINSETWORDS) > -#define DOMAINSET_T_INITIALIZER BITSET_T_INITIALIZER > + __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(x) __BITSET_T_INITIALIZER(x) > > #define DOMAINSET_POLICY_INVALID 0 > #define DOMAINSET_POLICY_ROUNDROBIN 1 > diff --git a/tests/sys/sys/bitset_test.c b/tests/sys/sys/bitset_test.c > index 781b523dae97..d193d2e3014c 100644 > --- a/tests/sys/sys/bitset_test.c > +++ b/tests/sys/sys/bitset_test.c > @@ -7,6 +7,8 @@ > * the FreeBSD Foundation. > */ > > +#define _WANT_FREEBSD_BITSET > + > #include <sys/types.h> > #include <sys/_bitset.h> > #include <sys/bitset.h> > diff --git a/usr.bin/cpuset/cpuset.c b/usr.bin/cpuset/cpuset.c > index e039030415bb..79c6c2b6ca79 100644 > --- a/usr.bin/cpuset/cpuset.c > +++ b/usr.bin/cpuset/cpuset.c > @@ -32,6 +32,8 @@ > #include <sys/cdefs.h> > __FBSDID("$FreeBSD$"); > > +#define _WANT_FREEBSD_BITSET > + > #include <sys/param.h> > #include <sys/types.h> > #include <sys/time.h> > Roman Bogorodskiy
signature.asc
Description: PGP signature
