| // SPDX-License-Identifier: GPL-2.0 | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <helpers/bitmask.h> | |
| /* How many bits in an unsigned long */ | |
| #define bitsperlong (8 * sizeof(unsigned long)) | |
| /* howmany(a,b) : how many elements of size b needed to hold all of a */ | |
| #define howmany(x, y) (((x)+((y)-1))/(y)) | |
| /* How many longs in mask of n bits */ | |
| #define longsperbits(n) howmany(n, bitsperlong) | |
| #define max(a, b) ((a) > (b) ? (a) : (b)) | |
| /* | |
| * Allocate and free `struct bitmask *` | |
| */ | |
| /* Allocate a new `struct bitmask` with a size of n bits */ | |
| struct bitmask *bitmask_alloc(unsigned int n) | |
| { | |
| struct bitmask *bmp; | |
| bmp = malloc(sizeof(*bmp)); | |
| if (!bmp) | |
| return 0; | |
| bmp->size = n; | |
| bmp->maskp = calloc(longsperbits(n), sizeof(unsigned long)); | |
| if (!bmp->maskp) { | |
| free(bmp); | |
| return 0; | |
| } | |
| return bmp; | |
| } | |
| /* Free `struct bitmask` */ | |
| void bitmask_free(struct bitmask *bmp) | |
| { | |
| if (!bmp) | |
| return; | |
| free(bmp->maskp); | |
| bmp->maskp = (unsigned long *)0xdeadcdef; /* double free tripwire */ | |
| free(bmp); | |
| } | |
| /* | |
| * The routines _getbit() and _setbit() are the only | |
| * routines that actually understand the layout of bmp->maskp[]. | |
| * | |
| * On little endian architectures, this could simply be an array of | |
| * bytes. But the kernel layout of bitmasks _is_ visible to userspace | |
| * via the sched_(set/get)affinity calls in Linux 2.6, and on big | |
| * endian architectures, it is painfully obvious that this is an | |
| * array of unsigned longs. | |
| */ | |
| /* Return the value (0 or 1) of bit n in bitmask bmp */ | |
| static unsigned int _getbit(const struct bitmask *bmp, unsigned int n) | |
| { | |
| if (n < bmp->size) | |
| return (bmp->maskp[n/bitsperlong] >> (n % bitsperlong)) & 1; | |
| else | |
| return 0; | |
| } | |
| /* Set bit n in bitmask bmp to value v (0 or 1) */ | |
| static void _setbit(struct bitmask *bmp, unsigned int n, unsigned int v) | |
| { | |
| if (n < bmp->size) { | |
| if (v) | |
| bmp->maskp[n/bitsperlong] |= 1UL << (n % bitsperlong); | |
| else | |
| bmp->maskp[n/bitsperlong] &= | |
| ~(1UL << (n % bitsperlong)); | |
| } | |
| } | |
| /* | |
| * When parsing bitmask lists, only allow numbers, separated by one | |
| * of the allowed next characters. | |
| * | |
| * The parameter 'sret' is the return from a sscanf "%u%c". It is | |
| * -1 if the sscanf input string was empty. It is 0 if the first | |
| * character in the sscanf input string was not a decimal number. | |
| * It is 1 if the unsigned number matching the "%u" was the end of the | |
| * input string. It is 2 if one or more additional characters followed | |
| * the matched unsigned number. If it is 2, then 'nextc' is the first | |
| * character following the number. The parameter 'ok_next_chars' | |
| * is the nul-terminated list of allowed next characters. | |
| * | |
| * The mask term just scanned was ok if and only if either the numbers | |
| * matching the %u were all of the input or if the next character in | |
| * the input past the numbers was one of the allowed next characters. | |
| */ | |
| static int scan_was_ok(int sret, char nextc, const char *ok_next_chars) | |
| { | |
| return sret == 1 || | |
| (sret == 2 && strchr(ok_next_chars, nextc) != NULL); | |
| } | |
| static const char *nexttoken(const char *q, int sep) | |
| { | |
| if (q) | |
| q = strchr(q, sep); | |
| if (q) | |
| q++; | |
| return q; | |
| } | |
| /* Set a single bit i in bitmask */ | |
| struct bitmask *bitmask_setbit(struct bitmask *bmp, unsigned int i) | |
| { | |
| _setbit(bmp, i, 1); | |
| return bmp; | |
| } | |
| /* Set all bits in bitmask: bmp = ~0 */ | |
| struct bitmask *bitmask_setall(struct bitmask *bmp) | |
| { | |
| unsigned int i; | |
| for (i = 0; i < bmp->size; i++) | |
| _setbit(bmp, i, 1); | |
| return bmp; | |
| } | |
| /* Clear all bits in bitmask: bmp = 0 */ | |
| struct bitmask *bitmask_clearall(struct bitmask *bmp) | |
| { | |
| unsigned int i; | |
| for (i = 0; i < bmp->size; i++) | |
| _setbit(bmp, i, 0); | |
| return bmp; | |
| } | |
| /* True if all bits are clear */ | |
| int bitmask_isallclear(const struct bitmask *bmp) | |
| { | |
| unsigned int i; | |
| for (i = 0; i < bmp->size; i++) | |
| if (_getbit(bmp, i)) | |
| return 0; | |
| return 1; | |
| } | |
| /* True if specified bit i is set */ | |
| int bitmask_isbitset(const struct bitmask *bmp, unsigned int i) | |
| { | |
| return _getbit(bmp, i); | |
| } | |
| /* Number of lowest set bit (min) */ | |
| unsigned int bitmask_first(const struct bitmask *bmp) | |
| { | |
| return bitmask_next(bmp, 0); | |
| } | |
| /* Number of highest set bit (max) */ | |
| unsigned int bitmask_last(const struct bitmask *bmp) | |
| { | |
| unsigned int i; | |
| unsigned int m = bmp->size; | |
| for (i = 0; i < bmp->size; i++) | |
| if (_getbit(bmp, i)) | |
| m = i; | |
| return m; | |
| } | |
| /* Number of next set bit at or above given bit i */ | |
| unsigned int bitmask_next(const struct bitmask *bmp, unsigned int i) | |
| { | |
| unsigned int n; | |
| for (n = i; n < bmp->size; n++) | |
| if (_getbit(bmp, n)) | |
| break; | |
| return n; | |
| } | |
| /* | |
| * Parses a comma-separated list of numbers and ranges of numbers, | |
| * with optional ':%u' strides modifying ranges, into provided bitmask. | |
| * Some examples of input lists and their equivalent simple list: | |
| * Input Equivalent to | |
| * 0-3 0,1,2,3 | |
| * 0-7:2 0,2,4,6 | |
| * 1,3,5-7 1,3,5,6,7 | |
| * 0-3:2,8-15:4 0,2,8,12 | |
| */ | |
| int bitmask_parselist(const char *buf, struct bitmask *bmp) | |
| { | |
| const char *p, *q; | |
| bitmask_clearall(bmp); | |
| q = buf; | |
| while (p = q, q = nexttoken(q, ','), p) { | |
| unsigned int a; /* begin of range */ | |
| unsigned int b; /* end of range */ | |
| unsigned int s; /* stride */ | |
| const char *c1, *c2; /* next tokens after '-' or ',' */ | |
| char nextc; /* char after sscanf %u match */ | |
| int sret; /* sscanf return (number of matches) */ | |
| sret = sscanf(p, "%u%c", &a, &nextc); | |
| if (!scan_was_ok(sret, nextc, ",-")) | |
| goto err; | |
| b = a; | |
| s = 1; | |
| c1 = nexttoken(p, '-'); | |
| c2 = nexttoken(p, ','); | |
| if (c1 != NULL && (c2 == NULL || c1 < c2)) { | |
| sret = sscanf(c1, "%u%c", &b, &nextc); | |
| if (!scan_was_ok(sret, nextc, ",:")) | |
| goto err; | |
| c1 = nexttoken(c1, ':'); | |
| if (c1 != NULL && (c2 == NULL || c1 < c2)) { | |
| sret = sscanf(c1, "%u%c", &s, &nextc); | |
| if (!scan_was_ok(sret, nextc, ",")) | |
| goto err; | |
| } | |
| } | |
| if (!(a <= b)) | |
| goto err; | |
| if (b >= bmp->size) | |
| goto err; | |
| while (a <= b) { | |
| _setbit(bmp, a, 1); | |
| a += s; | |
| } | |
| } | |
| return 0; | |
| err: | |
| bitmask_clearall(bmp); | |
| return -1; | |
| } | |
| /* | |
| * emit(buf, buflen, rbot, rtop, len) | |
| * | |
| * Helper routine for bitmask_displaylist(). Write decimal number | |
| * or range to buf+len, suppressing output past buf+buflen, with optional | |
| * comma-prefix. Return len of what would be written to buf, if it | |
| * all fit. | |
| */ | |
| static inline int emit(char *buf, int buflen, int rbot, int rtop, int len) | |
| { | |
| if (len > 0) | |
| len += snprintf(buf + len, max(buflen - len, 0), ","); | |
| if (rbot == rtop) | |
| len += snprintf(buf + len, max(buflen - len, 0), "%d", rbot); | |
| else | |
| len += snprintf(buf + len, max(buflen - len, 0), "%d-%d", | |
| rbot, rtop); | |
| return len; | |
| } | |
| /* | |
| * Write decimal list representation of bmp to buf. | |
| * | |
| * Output format is a comma-separated list of decimal numbers and | |
| * ranges. Consecutively set bits are shown as two hyphen-separated | |
| * decimal numbers, the smallest and largest bit numbers set in | |
| * the range. Output format is compatible with the format | |
| * accepted as input by bitmap_parselist(). | |
| * | |
| * The return value is the number of characters which would be | |
| * generated for the given input, excluding the trailing '\0', as | |
| * per ISO C99. | |
| */ | |
| int bitmask_displaylist(char *buf, int buflen, const struct bitmask *bmp) | |
| { | |
| int len = 0; | |
| /* current bit is 'cur', most recently seen range is [rbot, rtop] */ | |
| unsigned int cur, rbot, rtop; | |
| if (buflen > 0) | |
| *buf = 0; | |
| rbot = cur = bitmask_first(bmp); | |
| while (cur < bmp->size) { | |
| rtop = cur; | |
| cur = bitmask_next(bmp, cur+1); | |
| if (cur >= bmp->size || cur > rtop + 1) { | |
| len = emit(buf, buflen, rbot, rtop, len); | |
| rbot = cur; | |
| } | |
| } | |
| return len; | |
| } |