libcfs/include/libcfs/user-bitops.h

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2012, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * libcfs/include/libcfs/user-bitops.h
  37  *
  38  * Author: Nikita Danilov <nikita@clusterfs.com>
  39  */
  40
  41 #ifndef __LIBCFS_USER_BITOPS_H__
  42 #define __LIBCFS_USER_BITOPS_H__
  43
  44 /* test if bit nr is set in bitmap addr; returns previous value of bit nr */
  45 static inline int test_and_set_bit(int nr, unsigned long *addr)
  46 {
  47         unsigned long mask;
  48
  49         addr += nr / BITS_PER_LONG;
  50         mask = 1UL << (nr & (BITS_PER_LONG - 1));
  51         nr = (mask & *addr) != 0;
  52         *addr |= mask;
  53         return nr;
  54 }
  55
  56 #define set_bit(n, a) test_and_set_bit(n, a)
  57
  58 /* clear bit nr in bitmap addr; returns previous value of bit nr*/
  59 static inline int test_and_clear_bit(int nr, unsigned long *addr)
  60 {
  61         unsigned long mask;
  62
  63         addr += nr / BITS_PER_LONG;
  64         mask = 1UL << (nr & (BITS_PER_LONG - 1));
  65         nr = (mask & *addr) != 0;
  66         *addr &= ~mask;
  67         return nr;
  68 }
  69
  70 #define clear_bit(n, a) test_and_clear_bit(n, a)
  71
  72 static inline int test_bit(int nr, const unsigned long *addr)
  73 {
  74         return ((1UL << (nr & (BITS_PER_LONG - 1))) &
  75                 ((addr)[nr / BITS_PER_LONG])) != 0;
  76 }
  77
  78 /* using binary seach */
  79 static __inline__ unsigned long fls(long data)
  80 {
  81         int pos = 32;
  82
  83         if (!data)
  84                 return 0;
  85
  86 #if BITS_PER_LONG == 64
  87         /* If any bit of the high 32 bits are set, shift the high
  88          * 32 bits down and pretend like it is a 32-bit value. */
  89         if ((data & 0xFFFFFFFF00000000llu)) {
  90                 data >>= 32;
  91                 pos += 32;
  92         }
  93 #endif
  94
  95         if (!(data & 0xFFFF0000u)) {
  96                 data <<= 16;
  97                 pos -= 16;
  98         }
  99         if (!(data & 0xFF000000u)) {
 100                 data <<= 8;
 101                 pos -= 8;
 102         }
 103         if (!(data & 0xF0000000u)) {
 104                 data <<= 4;
 105                 pos -= 4;
 106         }
 107         if (!(data & 0xC0000000u)) {
 108                 data <<= 2;
 109                 pos -= 2;
 110         }
 111         if (!(data & 0x80000000u)) {
 112                 data <<= 1;
 113                 pos -= 1;
 114         }
 115         return pos;
 116 }
 117
 118 static __inline__ unsigned long __cfs_ffs(long data)
 119 {
 120         int pos = 0;
 121
 122 #if BITS_PER_LONG == 64
 123         if ((data & 0xFFFFFFFF) == 0) {
 124                 pos += 32;
 125                 data >>= 32;
 126         }
 127 #endif
 128         if ((data & 0xFFFF) == 0) {
 129                 pos += 16;
 130                 data >>= 16;
 131         }
 132         if ((data & 0xFF) == 0) {
 133                 pos += 8;
 134                 data >>= 8;
 135         }
 136         if ((data & 0xF) == 0) {
 137                 pos += 4;
 138                 data >>= 4;
 139         }
 140         if ((data & 0x3) == 0) {
 141                 pos += 2;
 142                 data >>= 2;
 143         }
 144         if ((data & 0x1) == 0)
 145                 pos += 1;
 146
 147         return pos;
 148 }
 149
 150 #define ffz(x)          ffs(~(x))
 151 #define flz(x)          fls(~(x))
 152
 153 unsigned long find_next_bit(unsigned long *addr,
 154                             unsigned long size, unsigned long offset);
 155
 156 unsigned long find_next_zero_bit(unsigned long *addr,
 157                                  unsigned long size, unsigned long offset);
 158
 159 #define find_first_bit(addr, size)       find_next_bit((addr), (size),0)
 160 #define find_first_zero_bit(addr, size)  find_next_zero_bit((addr), (size),0)
 161
 162 #endif