Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Dominik Brodowski | 1207 | 99.92% | 2 | 66.67% |
Greg Kroah-Hartman | 1 | 0.08% | 1 | 33.33% |
Total | 1208 | 3 |
// 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 == 0) return 0; bmp->size = n; bmp->maskp = calloc(longsperbits(n), sizeof(unsigned long)); if (bmp->maskp == 0) { free(bmp); return 0; } return bmp; } /* Free `struct bitmask` */ void bitmask_free(struct bitmask *bmp) { if (bmp == 0) 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; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1