librhcm/bitmap.c

   1 /*
   2   Copyright Red Hat, Inc. 2002-2003
   3
   4   The Red Hat Cluster Manager API Library is free software; you can
   5   redistribute it and/or modify it under the terms of the GNU Lesser
   6   General Public License as published by the Free Software Foundation;
   7   either version 2.1 of the License, or (at your option) any later
   8   version.
   9
  10   The Red Hat Cluster Manager API Library is distributed in the hope
  11   that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13   PURPOSE.  See the GNU Lesser General Public License for more details.
  14
  15   You should have received a copy of the GNU Lesser General Public
  16   License along with this library; if not, write to the Free Software
  17   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18   USA.
  19  */
  20 /** @file
  21  * Bitmap and membership mask handling routines.
  22  */
  23 #include <stdio.h>
  24 #include <cm_api.h>
  25 #include <string.h>
  26 #include <stdint.h>
  27
  28
  29 /**
  30  * Clear a bit in a bitmap / bitmask.
  31  *
  32  * @param mask          Bitmask to modify.
  33  * @param bitidx        Bit to modify.
  34  * @param masklen       Bitmask length (in uint32_t units).
  35  * @return              -1 if the index exceeds the number of bits in the
  36  *                      bitmap, otherwise 0.
  37  */
  38 int
  39 clear_bit(uint32_t *mask, uint32_t bitidx, uint32_t masklen)
  40 {
  41         uint32_t idx;
  42         uint32_t bit;
  43
  44         /* Index into array */
  45         idx = bitidx >> 5;
  46         bit = 1 << (bitidx & 0x1F);
  47
  48         if (idx >= masklen)
  49                 return -1;
  50
  51         mask[idx] &= ~bit;
  52
  53         return 0;
  54 }
  55
  56
  57 /**
  58  * Set a bit in a bitmap / bitmask.
  59  *
  60  * @param mask          Bitmask to modify.
  61  * @param bitidx        Bit to modify.
  62  * @param masklen       Bitmask length (in uint32_t units).
  63  * @return              -1 if the index exceeds the number of bits in the
  64  *                      bitmap, otherwise 0.
  65  */
  66 int
  67 set_bit(uint32_t *mask, uint32_t bitidx, uint32_t masklen)
  68 {
  69         uint32_t idx;
  70         uint32_t bit;
  71
  72         /* Index into array */
  73         idx = bitidx >> 5;
  74         bit = 1 << (bitidx & 0x1F);
  75
  76         if (idx >= masklen)
  77                 return -1;
  78
  79         mask[idx] |= bit;
  80
  81         return 0;
  82 }
  83
  84
  85 /**
  86  * Check the status of a bit in a bitmap / bitmask.
  87  *
  88  * @param mask          Bitmask to check.
  89  * @param bitidx        Bit to to check.
  90  * @param masklen       Bitmask length (in uint32_t units).
  91  * @return              -1 if the index exceeds the number of bits in the
  92  *                      bitmap, 0 if not set, or 1 if set.
  93  */
  94 int
  95 is_bit_set(uint32_t *mask, uint32_t bitidx, uint32_t masklen)
  96 {
  97         uint32_t idx;
  98         uint32_t bit;
  99
 100         /* Index into array */
 101         idx = bitidx >> 5;
 102         bit = 1 << (bitidx & 0x1F);
 103
 104         if (idx >= masklen)
 105                 return -1;
 106
 107         return !!(mask[idx]&bit);
 108 }
 109
 110
 111 /**
 112  * Check to see if a member is online within a given mask.
 113  *
 114  * @param mask          Membership mask.
 115  * @param node          Member number/ID to check.
 116  * @return              See is_bit_set.
 117  * @see is_bit_set
 118  */
 119 int
 120 memb_online(memb_mask_t mask, int node)
 121 {
 122         return (is_bit_set((uint32_t *)mask, node, MEMB_MASK_LEN));
 123 }
 124
 125
 126 /**
 127  * Return the lowest-numbered member in a given membership mask
 128  *
 129  * @param mask          Membership mask.
 130  * @return              Index of lowest bit set in mask.
 131  * @see is_bit_set
 132  */
 133 int
 134 memb_low_id(memb_mask_t mask)
 135 {
 136         int x;
 137
 138         for (x = 0; x < MAX_NODES; x++)
 139                 if (is_bit_set((uint32_t *)mask, x, MEMB_MASK_LEN) == 1)
 140                         return x;
 141         return -1;
 142 }
 143
 144
 145 /**
 146  * Return the highest-numbered member in a given membership mask
 147  *
 148  * @param mask          Membership mask.
 149  * @return              Index of highest bit set in mask.
 150  * @see is_bit_set
 151  */
 152 int
 153 memb_high_id(memb_mask_t mask)
 154 {
 155         int x;
 156
 157         for (x = MAX_NODES-1; x >= 0; x--)
 158                 if (is_bit_set((uint32_t *)mask, x, MEMB_MASK_LEN) == 1)
 159                         return x;
 160         return -1;
 161 }
 162
 163
 164 /**
 165  * Return the the number of bits ON in a given membership mask.
 166  *
 167  * @param mask          Membership mask.
 168  * @return              Number of bits ON in mask.
 169  * @see is_bit_set
 170  */
 171 int
 172 memb_count(memb_mask_t mask)
 173 {
 174         int x, rv = 0;
 175
 176         for (x = 0; x < MAX_NODES; x++)
 177                 if (is_bit_set((uint32_t *)mask, x, MEMB_MASK_LEN) == 1)
 178                         rv++;
 179
 180         return rv;
 181 }
 182
 183
 184 /**
 185  * Constructs a formatted string out of a membership mask and returns it.
 186  *
 187  * @param mask          Membership mask.
 188  * @return              Pointer to static format string, or NULL if
 189  *                      mask is NULL.
 190  */
 191 char *
 192 memb_mask_str(memb_mask_t mask)
 193 {
 194         static char bufferstr[MEMB_MASK_LEN * 8 + 3];
 195         char tmpstr[9];
 196         int x;
 197
 198         if (!(uint32_t *)mask)
 199                 return NULL;
 200
 201         snprintf(bufferstr, sizeof(bufferstr), "0x");
 202         for (x=MEMB_MASK_LEN-1; x>=0; x--) {
 203                 snprintf(tmpstr,sizeof(tmpstr),"%08x",((uint32_t *)mask)[x]);
 204                 strcat(bufferstr,tmpstr);
 205         }
 206
 207         return bufferstr;
 208 }
 209
 210
 211 #ifdef STANDALONE
 212 int
 213 main(int argc, char **argv)
 214 {
 215         int a;
 216         memb_mask_t membership;
 217
 218         memset(membership, 0, sizeof(membership));
 219
 220         a = atoi(argv[1]);
 221         printf("bit[%d] = %d\n", a, is_bit_set(membership, a, MEMB_MASK_LEN));
 222         set_bit(membership, a, MEMB_MASK_LEN);
 223         printf("bit[%d] = %d\n", a, is_bit_set(membership, a, MEMB_MASK_LEN));
 224         clear_bit(membership, a, MEMB_MASK_LEN);
 225         printf("bit[%d] = %d\n", a, is_bit_set(membership, a, 64));
 226         set_bit(membership, a, MEMB_MASK_LEN);
 227
 228         printf("Mask = %s\n", memb_mask_str(membership));
 229
 230         return 0;
 231
 232
 233 }
 234 #endif