tools/power/cpupower/utils/helpers/bitmask.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include <helpers/bitmask.h>
   7
   8 /* How many bits in an unsigned long */
   9 #define bitsperlong (8 * sizeof(unsigned long))
  10
  11 /* howmany(a,b) : how many elements of size b needed to hold all of a */
  12 #define howmany(x, y) (((x)+((y)-1))/(y))
  13
  14 /* How many longs in mask of n bits */
  15 #define longsperbits(n) howmany(n, bitsperlong)
  16
  17 #define max(a, b) ((a) > (b) ? (a) : (b))
  18
  19 /*
  20  * Allocate and free `struct bitmask *`
  21  */
  22
  23 /* Allocate a new `struct bitmask` with a size of n bits */
  24 struct bitmask *bitmask_alloc(unsigned int n)
  25 {
  26         struct bitmask *bmp;
  27
  28         bmp = malloc(sizeof(*bmp));
  29         if (bmp == 0)
  30                 return 0;
  31         bmp->size = n;
  32         bmp->maskp = calloc(longsperbits(n), sizeof(unsigned long));
  33         if (bmp->maskp == 0) {
  34                 free(bmp);
  35                 return 0;
  36         }
  37         return bmp;
  38 }
  39
  40 /* Free `struct bitmask` */
  41 void bitmask_free(struct bitmask *bmp)
  42 {
  43         if (bmp == 0)
  44                 return;
  45         free(bmp->maskp);
  46         bmp->maskp = (unsigned long *)0xdeadcdef;  /* double free tripwire */
  47         free(bmp);
  48 }
  49
  50 /*
  51  * The routines _getbit() and _setbit() are the only
  52  * routines that actually understand the layout of bmp->maskp[].
  53  *
  54  * On little endian architectures, this could simply be an array of
  55  * bytes.  But the kernel layout of bitmasks _is_ visible to userspace
  56  * via the sched_(set/get)affinity calls in Linux 2.6, and on big
  57  * endian architectures, it is painfully obvious that this is an
  58  * array of unsigned longs.
  59  */
  60
  61 /* Return the value (0 or 1) of bit n in bitmask bmp */
  62 static unsigned int _getbit(const struct bitmask *bmp, unsigned int n)
  63 {
  64         if (n < bmp->size)
  65                 return (bmp->maskp[n/bitsperlong] >> (n % bitsperlong)) & 1;
  66         else
  67                 return 0;
  68 }
  69
  70 /* Set bit n in bitmask bmp to value v (0 or 1) */
  71 static void _setbit(struct bitmask *bmp, unsigned int n, unsigned int v)
  72 {
  73         if (n < bmp->size) {
  74                 if (v)
  75                         bmp->maskp[n/bitsperlong] |= 1UL << (n % bitsperlong);
  76                 else
  77                         bmp->maskp[n/bitsperlong] &=
  78                                 ~(1UL << (n % bitsperlong));
  79         }
  80 }
  81
  82 /*
  83  * When parsing bitmask lists, only allow numbers, separated by one
  84  * of the allowed next characters.
  85  *
  86  * The parameter 'sret' is the return from a sscanf "%u%c".  It is
  87  * -1 if the sscanf input string was empty.  It is 0 if the first
  88  * character in the sscanf input string was not a decimal number.
  89  * It is 1 if the unsigned number matching the "%u" was the end of the
  90  * input string.  It is 2 if one or more additional characters followed
  91  * the matched unsigned number.  If it is 2, then 'nextc' is the first
  92  * character following the number.  The parameter 'ok_next_chars'
  93  * is the nul-terminated list of allowed next characters.
  94  *
  95  * The mask term just scanned was ok if and only if either the numbers
  96  * matching the %u were all of the input or if the next character in
  97  * the input past the numbers was one of the allowed next characters.
  98  */
  99 static int scan_was_ok(int sret, char nextc, const char *ok_next_chars)
 100 {
 101         return sret == 1 ||
 102                 (sret == 2 && strchr(ok_next_chars, nextc) != NULL);
 103 }
 104
 105 static const char *nexttoken(const char *q,  int sep)
 106 {
 107         if (q)
 108                 q = strchr(q, sep);
 109         if (q)
 110                 q++;
 111         return q;
 112 }
 113
 114 /* Set a single bit i in bitmask */
 115 struct bitmask *bitmask_setbit(struct bitmask *bmp, unsigned int i)
 116 {
 117         _setbit(bmp, i, 1);
 118         return bmp;
 119 }
 120
 121 /* Set all bits in bitmask: bmp = ~0 */
 122 struct bitmask *bitmask_setall(struct bitmask *bmp)
 123 {
 124         unsigned int i;
 125         for (i = 0; i < bmp->size; i++)
 126                 _setbit(bmp, i, 1);
 127         return bmp;
 128 }
 129
 130 /* Clear all bits in bitmask: bmp = 0 */
 131 struct bitmask *bitmask_clearall(struct bitmask *bmp)
 132 {
 133         unsigned int i;
 134         for (i = 0; i < bmp->size; i++)
 135                 _setbit(bmp, i, 0);
 136         return bmp;
 137 }
 138
 139 /* True if all bits are clear */
 140 int bitmask_isallclear(const struct bitmask *bmp)
 141 {
 142         unsigned int i;
 143         for (i = 0; i < bmp->size; i++)
 144                 if (_getbit(bmp, i))
 145                         return 0;
 146         return 1;
 147 }
 148
 149 /* True if specified bit i is set */
 150 int bitmask_isbitset(const struct bitmask *bmp, unsigned int i)
 151 {
 152         return _getbit(bmp, i);
 153 }
 154
 155 /* Number of lowest set bit (min) */
 156 unsigned int bitmask_first(const struct bitmask *bmp)
 157 {
 158         return bitmask_next(bmp, 0);
 159 }
 160
 161 /* Number of highest set bit (max) */
 162 unsigned int bitmask_last(const struct bitmask *bmp)
 163 {
 164         unsigned int i;
 165         unsigned int m = bmp->size;
 166         for (i = 0; i < bmp->size; i++)
 167                 if (_getbit(bmp, i))
 168                         m = i;
 169         return m;
 170 }
 171
 172 /* Number of next set bit at or above given bit i */
 173 unsigned int bitmask_next(const struct bitmask *bmp, unsigned int i)
 174 {
 175         unsigned int n;
 176         for (n = i; n < bmp->size; n++)
 177                 if (_getbit(bmp, n))
 178                         break;
 179         return n;
 180 }
 181
 182 /*
 183  * Parses a comma-separated list of numbers and ranges of numbers,
 184  * with optional ':%u' strides modifying ranges, into provided bitmask.
 185  * Some examples of input lists and their equivalent simple list:
 186  *      Input           Equivalent to
 187  *      0-3             0,1,2,3
 188  *      0-7:2           0,2,4,6
 189  *      1,3,5-7         1,3,5,6,7
 190  *      0-3:2,8-15:4    0,2,8,12
 191  */
 192 int bitmask_parselist(const char *buf, struct bitmask *bmp)
 193 {
 194         const char *p, *q;
 195
 196         bitmask_clearall(bmp);
 197
 198         q = buf;
 199         while (p = q, q = nexttoken(q, ','), p) {
 200                 unsigned int a;         /* begin of range */
 201                 unsigned int b;         /* end of range */
 202                 unsigned int s;         /* stride */
 203                 const char *c1, *c2;    /* next tokens after '-' or ',' */
 204                 char nextc;             /* char after sscanf %u match */
 205                 int sret;               /* sscanf return (number of matches) */
 206
 207                 sret = sscanf(p, "%u%c", &a, &nextc);
 208                 if (!scan_was_ok(sret, nextc, ",-"))
 209                         goto err;
 210                 b = a;
 211                 s = 1;
 212                 c1 = nexttoken(p, '-');
 213                 c2 = nexttoken(p, ',');
 214                 if (c1 != NULL && (c2 == NULL || c1 < c2)) {
 215                         sret = sscanf(c1, "%u%c", &b, &nextc);
 216                         if (!scan_was_ok(sret, nextc, ",:"))
 217                                 goto err;
 218                         c1 = nexttoken(c1, ':');
 219                         if (c1 != NULL && (c2 == NULL || c1 < c2)) {
 220                                 sret = sscanf(c1, "%u%c", &s, &nextc);
 221                                 if (!scan_was_ok(sret, nextc, ","))
 222                                         goto err;
 223                         }
 224                 }
 225                 if (!(a <= b))
 226                         goto err;
 227                 if (b >= bmp->size)
 228                         goto err;
 229                 while (a <= b) {
 230                         _setbit(bmp, a, 1);
 231                         a += s;
 232                 }
 233         }
 234         return 0;
 235 err:
 236         bitmask_clearall(bmp);
 237         return -1;
 238 }
 239
 240 /*
 241  * emit(buf, buflen, rbot, rtop, len)
 242  *
 243  * Helper routine for bitmask_displaylist().  Write decimal number
 244  * or range to buf+len, suppressing output past buf+buflen, with optional
 245  * comma-prefix.  Return len of what would be written to buf, if it
 246  * all fit.
 247  */
 248
 249 static inline int emit(char *buf, int buflen, int rbot, int rtop, int len)
 250 {
 251         if (len > 0)
 252                 len += snprintf(buf + len, max(buflen - len, 0), ",");
 253         if (rbot == rtop)
 254                 len += snprintf(buf + len, max(buflen - len, 0), "%d", rbot);
 255         else
 256                 len += snprintf(buf + len, max(buflen - len, 0), "%d-%d",
 257                                 rbot, rtop);
 258         return len;
 259 }
 260
 261 /*
 262  * Write decimal list representation of bmp to buf.
 263  *
 264  * Output format is a comma-separated list of decimal numbers and
 265  * ranges.  Consecutively set bits are shown as two hyphen-separated
 266  * decimal numbers, the smallest and largest bit numbers set in
 267  * the range.  Output format is compatible with the format
 268  * accepted as input by bitmap_parselist().
 269  *
 270  * The return value is the number of characters which would be
 271  * generated for the given input, excluding the trailing '\0', as
 272  * per ISO C99.
 273  */
 274
 275 int bitmask_displaylist(char *buf, int buflen, const struct bitmask *bmp)
 276 {
 277         int len = 0;
 278         /* current bit is 'cur', most recently seen range is [rbot, rtop] */
 279         unsigned int cur, rbot, rtop;
 280
 281         if (buflen > 0)
 282                 *buf = 0;
 283         rbot = cur = bitmask_first(bmp);
 284         while (cur < bmp->size) {
 285                 rtop = cur;
 286                 cur = bitmask_next(bmp, cur+1);
 287                 if (cur >= bmp->size || cur > rtop + 1) {
 288                         len = emit(buf, buflen, rbot, rtop, len);
 289                         rbot = cur;
 290                 }
 291         }
 292         return len;
 293 }