bitmask.c

Go to the documentation of this file.

#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;
}