15 files changed, 378 insertions, 341 deletions
diff --git a/include/asm-alpha/bitops.h b/include/asm-alpha/bitops.h
index 9e19a704d484..15f3ae25c511 100644
--- a/include/asm-alpha/bitops.h
+++ b/include/asm-alpha/bitops.h
@@ -388,6 +388,11 @@ static inline int fls64(unsigned long x)
 }
 #endif
+static inline unsigned long __fls(unsigned long x)
+{
+        return fls64(x) - 1;
+}
 static inline int fls(int x)
 {
        return fls64((unsigned int) x);
diff --git a/include/asm-generic/bitops/__fls.h b/include/asm-generic/bitops/__fls.h
new file mode 100644
index 000000000000..be24465403d6
--- /dev/null
+++ b/include/asm-generic/bitops/__fls.h
@@ -0,0 +1,43 @@
+#ifndef _ASM_GENERIC_BITOPS___FLS_H_
+#define _ASM_GENERIC_BITOPS___FLS_H_
+#include <asm/types.h>
+/**
+ * __fls - find last (most-significant) set bit in a long word
+ * @word: the word to search
+ *
+ * Undefined if no set bit exists, so code should check against 0 first.
+ */
+static inline unsigned long __fls(unsigned long word)
+{
+        int num = BITS_PER_LONG - 1;
+#if BITS_PER_LONG == 64
+        if (!(word & (~0ul << 32))) {
+                num -= 32;
+                word <<= 32;
+        }
+#endif
+        if (!(word & (~0ul << (BITS_PER_LONG-16)))) {
+                num -= 16;
+                word <<= 16;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-8)))) {
+                num -= 8;
+                word <<= 8;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-4)))) {
+                num -= 4;
+                word <<= 4;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-2)))) {
+                num -= 2;
+                word <<= 2;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-1))))
+                num -= 1;
+        return num;
+}
+#endif /* _ASM_GENERIC_BITOPS___FLS_H_ */
diff --git a/include/asm-generic/bitops/find.h b/include/asm-generic/bitops/find.h
index 72a51e5a12ef..1914e9742512 100644
--- a/include/asm-generic/bitops/find.h
+++ b/include/asm-generic/bitops/find.h
@@ -1,11 +1,13 @@
 #ifndef _ASM_GENERIC_BITOPS_FIND_H_
 #define _ASM_GENERIC_BITOPS_FIND_H_
+#ifndef CONFIG_GENERIC_FIND_NEXT_BIT
 extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
                size, unsigned long offset);
 extern unsigned long find_next_zero_bit(const unsigned long *addr, unsigned
                long size, unsigned long offset);
+#endif
 #define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
 #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
diff --git a/include/asm-generic/bitops/fls64.h b/include/asm-generic/bitops/fls64.h
index 1b6b17ce2428..86d403f8b256 100644
--- a/include/asm-generic/bitops/fls64.h
+++ b/include/asm-generic/bitops/fls64.h
@@ -3,6 +3,18 @@
 #include <asm/types.h>
+/**
+ * fls64 - find last set bit in a 64-bit word
+ * @x: the word to search
+ *
+ * This is defined in a similar way as the libc and compiler builtin
+ * ffsll, but returns the position of the most significant set bit.
+ *
+ * fls64(value) returns 0 if value is 0 or the position of the last
+ * set bit if value is nonzero. The last (most significant) bit is
+ * at position 64.
+ */
+#if BITS_PER_LONG == 32
 static inline int fls64(__u64 x)
 {
        __u32 h = x >> 32;
@@ -10,5 +22,15 @@ static inline int fls64(__u64 x)
                return fls(h) + 32;
        return fls(x);
 }
+#elif BITS_PER_LONG == 64
+static inline int fls64(__u64 x)
+{
+        if (x == 0)
+                return 0;
+        return __fls(x) + 1;
+}
+#else
+#error BITS_PER_LONG not 32 or 64
+#endif
 #endif /* _ASM_GENERIC_BITOPS_FLS64_H_ */
diff --git a/include/asm-ia64/bitops.h b/include/asm-ia64/bitops.h
index 953d3df9dd22..e2ca80037335 100644
--- a/include/asm-ia64/bitops.h
+++ b/include/asm-ia64/bitops.h
@@ -407,6 +407,22 @@ fls (int t)
        return ia64_popcnt(x);
 }
+/*
+ * Find the last (most significant) bit set.  Undefined for x==0.
+ * Bits are numbered from 0..63 (e.g., __fls(9) == 3).
+ */
+static inline unsigned long
+__fls (unsigned long x)
+{
+        x |= x >> 1;
+        x |= x >> 2;
+        x |= x >> 4;
+        x |= x >> 8;
+        x |= x >> 16;
+        x |= x >> 32;
+        return ia64_popcnt(x) - 1;
+}
 #include <asm-generic/bitops/fls64.h>
 /*
diff --git a/include/asm-mips/bitops.h b/include/asm-mips/bitops.h
index ec75ce4cdb8c..c2bd126c3b4e 100644
--- a/include/asm-mips/bitops.h
+++ b/include/asm-mips/bitops.h
@@ -591,6 +591,11 @@ static inline int __ilog2(unsigned long x)
        return 63 - lz;
 }
+static inline unsigned long __fls(unsigned long x)
+{
+        return __ilog2(x);
+}
 #if defined(CONFIG_CPU_MIPS32) || defined(CONFIG_CPU_MIPS64)
 /*
diff --git a/include/asm-parisc/bitops.h b/include/asm-parisc/bitops.h
index f8eebcbad01f..7a6ea10bd231 100644
--- a/include/asm-parisc/bitops.h
+++ b/include/asm-parisc/bitops.h
@@ -210,6 +210,7 @@ static __inline__ int fls(int x)
        return ret;
 }
+#include <asm-generic/bitops/__fls.h>
 #include <asm-generic/bitops/fls64.h>
 #include <asm-generic/bitops/hweight.h>
 #include <asm-generic/bitops/lock.h>
diff --git a/include/asm-powerpc/bitops.h b/include/asm-powerpc/bitops.h
index a99a74929475..897eade3afbe 100644
--- a/include/asm-powerpc/bitops.h
+++ b/include/asm-powerpc/bitops.h
@@ -313,6 +313,11 @@ static __inline__ int fls(unsigned int x)
        return 32 - lz;
 }
+static __inline__ unsigned long __fls(unsigned long x)
+{
+        return __ilog2(x);
+}
 /*
 * 64-bit can do this using one cntlzd (count leading zeroes doubleword)
 * instruction; for 32-bit we use the generic version, which does two
diff --git a/include/asm-s390/bitops.h b/include/asm-s390/bitops.h
index 965394e69452..b4eb24ab5af9 100644
--- a/include/asm-s390/bitops.h
+++ b/include/asm-s390/bitops.h
@@ -769,6 +769,7 @@ static inline int sched_find_first_bit(unsigned long *b)
 }
 #include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/__fls.h>
 #include <asm-generic/bitops/fls64.h>
 #include <asm-generic/bitops/hweight.h>
diff --git a/include/asm-sh/bitops.h b/include/asm-sh/bitops.h
index b6ba5a60dec2..d7d382f63ee5 100644
--- a/include/asm-sh/bitops.h
+++ b/include/asm-sh/bitops.h
@@ -95,6 +95,7 @@ static inline unsigned long ffz(unsigned long word)
 #include <asm-generic/bitops/ext2-atomic.h>
 #include <asm-generic/bitops/minix.h>
 #include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/__fls.h>
 #include <asm-generic/bitops/fls64.h>
 #endif /* __KERNEL__ */
diff --git a/include/asm-sparc64/bitops.h b/include/asm-sparc64/bitops.h
index 982ce8992b91..11f9d8146cdf 100644
--- a/include/asm-sparc64/bitops.h
+++ b/include/asm-sparc64/bitops.h
@@ -34,6 +34,7 @@ extern void change_bit(unsigned long nr, volatile unsigned long *addr);
 #include <asm-generic/bitops/ffz.h>
 #include <asm-generic/bitops/__ffs.h>
 #include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/__fls.h>
 #include <asm-generic/bitops/fls64.h>
 #ifdef __KERNEL__
diff --git a/include/asm-x86/bitops.h b/include/asm-x86/bitops.h
index 1ae7b270a1ef..b81a4d4d3337 100644
--- a/include/asm-x86/bitops.h
+++ b/include/asm-x86/bitops.h
@@ -62,12 +62,9 @@ static inline void set_bit(int nr, volatile void *addr)
 */
 static inline void __set_bit(int nr, volatile void *addr)
 {
-        asm volatile("bts %1,%0"
+        asm volatile("bts %1,%0" : ADDR : "Ir" (nr) : "memory");
-                     : ADDR
-                     : "Ir" (nr) : "memory");
 }
 /**
 * clear_bit - Clears a bit in memory
 * @nr: Bit to clear
@@ -297,19 +294,145 @@ static inline int variable_test_bit(int nr, volatile const void *addr)
 static int test_bit(int nr, const volatile unsigned long *addr);
 #endif
-#define test_bit(nr,addr)                       \
+#define test_bit(nr, addr)                      \
-        (__builtin_constant_p(nr) ?             \
+        (__builtin_constant_p((nr))             \
-         constant_test_bit((nr),(addr)) :       \
+         ? constant_test_bit((nr), (addr))      \
-         variable_test_bit((nr),(addr)))
+         : variable_test_bit((nr), (addr)))
+/**
+ * __ffs - find first set bit in word
+ * @word: The word to search
+ *
+ * Undefined if no bit exists, so code should check against 0 first.
+ */
+static inline unsigned long __ffs(unsigned long word)
+{
+        asm("bsf %1,%0"
+                : "=r" (word)
+                : "rm" (word));
+        return word;
+}
+/**
+ * ffz - find first zero bit in word
+ * @word: The word to search
+ *
+ * Undefined if no zero exists, so code should check against ~0UL first.
+ */
+static inline unsigned long ffz(unsigned long word)
+{
+        asm("bsf %1,%0"
+                : "=r" (word)
+                : "r" (~word));
+        return word;
+}
+/*
+ * __fls: find last set bit in word
+ * @word: The word to search
+ *
+ * Undefined if no zero exists, so code should check against ~0UL first.
+ */
+static inline unsigned long __fls(unsigned long word)
+{
+        asm("bsr %1,%0"
+            : "=r" (word)
+            : "rm" (word));
+        return word;
+}
+#ifdef __KERNEL__
+/**
+ * ffs - find first set bit in word
+ * @x: the word to search
+ *
+ * This is defined the same way as the libc and compiler builtin ffs
+ * routines, therefore differs in spirit from the other bitops.
+ *
+ * ffs(value) returns 0 if value is 0 or the position of the first
+ * set bit if value is nonzero. The first (least significant) bit
+ * is at position 1.
+ */
+static inline int ffs(int x)
+{
+        int r;
+#ifdef CONFIG_X86_CMOV
+        asm("bsfl %1,%0\n\t"
+            "cmovzl %2,%0"
+            : "=r" (r) : "rm" (x), "r" (-1));
+#else
+        asm("bsfl %1,%0\n\t"
+            "jnz 1f\n\t"
+            "movl $-1,%0\n"
+            "1:" : "=r" (r) : "rm" (x));
+#endif
+        return r + 1;
+}
+/**
+ * fls - find last set bit in word
+ * @x: the word to search
+ *
+ * This is defined in a similar way as the libc and compiler builtin
+ * ffs, but returns the position of the most significant set bit.
+ *
+ * fls(value) returns 0 if value is 0 or the position of the last
+ * set bit if value is nonzero. The last (most significant) bit is
+ * at position 32.
+ */
+static inline int fls(int x)
+{
+        int r;
+#ifdef CONFIG_X86_CMOV
+        asm("bsrl %1,%0\n\t"
+            "cmovzl %2,%0"
+            : "=&r" (r) : "rm" (x), "rm" (-1));
+#else
+        asm("bsrl %1,%0\n\t"
+            "jnz 1f\n\t"
+            "movl $-1,%0\n"
+            "1:" : "=r" (r) : "rm" (x));
+#endif
+        return r + 1;
+}
+#endif /* __KERNEL__ */
 #undef BASE_ADDR
 #undef BIT_ADDR
 #undef ADDR
-#ifdef CONFIG_X86_32
+static inline void set_bit_string(unsigned long *bitmap,
-# include "bitops_32.h"
+                unsigned long i, int len)
-#else
+{
-# include "bitops_64.h"
+        unsigned long end = i + len;
-#endif
+        while (i < end) {
+                __set_bit(i, bitmap);
+                i++;
+        }
+}
+#ifdef __KERNEL__
+#include <asm-generic/bitops/sched.h>
+#define ARCH_HAS_FAST_MULTIPLIER 1
+#include <asm-generic/bitops/hweight.h>
+#endif /* __KERNEL__ */
+#include <asm-generic/bitops/fls64.h>
+#ifdef __KERNEL__
+#include <asm-generic/bitops/ext2-non-atomic.h>
+#define ext2_set_bit_atomic(lock, nr, addr)                     \
+        test_and_set_bit((nr), (unsigned long *)(addr))
+#define ext2_clear_bit_atomic(lock, nr, addr)                   \
+        test_and_clear_bit((nr), (unsigned long *)(addr))
+#include <asm-generic/bitops/minix.h>
+#endif /* __KERNEL__ */
 #endif  /* _ASM_X86_BITOPS_H */
diff --git a/include/asm-x86/bitops_32.h b/include/asm-x86/bitops_32.h
deleted file mode 100644
index 2513a81f82aa..000000000000
--- a/include/asm-x86/bitops_32.h
+++ /dev/null
@@ -1,166 +0,0 @@
-#ifndef _I386_BITOPS_H
-#define _I386_BITOPS_H
-/*
- * Copyright 1992, Linus Torvalds.
- */
-/**
- * find_first_zero_bit - find the first zero bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit number of the first zero bit, not the number of the byte
- * containing a bit.
- */
-static inline int find_first_zero_bit(const unsigned long *addr, unsigned size)
-{
-        int d0, d1, d2;
-        int res;
-        if (!size)
-                return 0;
-        /* This looks at memory.
-         * Mark it volatile to tell gcc not to move it around
-         */
-        asm volatile("movl $-1,%%eax\n\t"
-                     "xorl %%edx,%%edx\n\t"
-                     "repe; scasl\n\t"
-                     "je 1f\n\t"
-                     "xorl -4(%%edi),%%eax\n\t"
-                     "subl $4,%%edi\n\t"
-                     "bsfl %%eax,%%edx\n"
-                     "1:\tsubl %%ebx,%%edi\n\t"
-                     "shll $3,%%edi\n\t"
-                     "addl %%edi,%%edx"
-                     : "=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
-                     : "1" ((size + 31) >> 5), "2" (addr),
-                       "b" (addr) : "memory");
-        return res;
-}
-/**
- * find_next_zero_bit - find the first zero bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bit number to start searching at
- * @size: The maximum size to search
- */
-int find_next_zero_bit(const unsigned long *addr, int size, int offset);
-/**
- * __ffs - find first bit in word.
- * @word: The word to search
- *
- * Undefined if no bit exists, so code should check against 0 first.
- */
-static inline unsigned long __ffs(unsigned long word)
-{
-        __asm__("bsfl %1,%0"
-                :"=r" (word)
-                :"rm" (word));
-        return word;
-}
-/**
- * find_first_bit - find the first set bit in a memory region
- * @addr: The address to start the search at
- * @size: The maximum size to search
- *
- * Returns the bit number of the first set bit, not the number of the byte
- * containing a bit.
- */
-static inline unsigned find_first_bit(const unsigned long *addr, unsigned size)
-{
-        unsigned x = 0;
-        while (x < size) {
-                unsigned long val = *addr++;
-                if (val)
-                        return __ffs(val) + x;
-                x += sizeof(*addr) << 3;
-        }
-        return x;
-}
-/**
- * find_next_bit - find the first set bit in a memory region
- * @addr: The address to base the search on
- * @offset: The bit number to start searching at
- * @size: The maximum size to search
- */
-int find_next_bit(const unsigned long *addr, int size, int offset);
-/**
- * ffz - find first zero in word.
- * @word: The word to search
- *
- * Undefined if no zero exists, so code should check against ~0UL first.
- */
-static inline unsigned long ffz(unsigned long word)
-{
-        __asm__("bsfl %1,%0"
-                :"=r" (word)
-                :"r" (~word));
-        return word;
-}
-#ifdef __KERNEL__
-#include <asm-generic/bitops/sched.h>
-/**
- * ffs - find first bit set
- * @x: the word to search
- *
- * This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz() (man ffs).
- */
-static inline int ffs(int x)
-{
-        int r;
-        __asm__("bsfl %1,%0\n\t"
-                "jnz 1f\n\t"
-                "movl $-1,%0\n"
-                "1:" : "=r" (r) : "rm" (x));
-        return r+1;
-}
-/**
- * fls - find last bit set
- * @x: the word to search
- *
- * This is defined the same way as ffs().
- */
-static inline int fls(int x)
-{
-        int r;
-        __asm__("bsrl %1,%0\n\t"
-                "jnz 1f\n\t"
-                "movl $-1,%0\n"
-                "1:" : "=r" (r) : "rm" (x));
-        return r+1;
-}
-#include <asm-generic/bitops/hweight.h>
-#endif /* __KERNEL__ */
-#include <asm-generic/bitops/fls64.h>
-#ifdef __KERNEL__
-#include <asm-generic/bitops/ext2-non-atomic.h>
-#define ext2_set_bit_atomic(lock, nr, addr)                     \
-        test_and_set_bit((nr), (unsigned long *)(addr))
-#define ext2_clear_bit_atomic(lock, nr, addr)                   \
-        test_and_clear_bit((nr), (unsigned long *)(addr))
-#include <asm-generic/bitops/minix.h>
-#endif /* __KERNEL__ */
-#endif /* _I386_BITOPS_H */
diff --git a/include/asm-x86/bitops_64.h b/include/asm-x86/bitops_64.h
deleted file mode 100644
index 365f8207ea59..000000000000
--- a/include/asm-x86/bitops_64.h
+++ /dev/null
@@ -1,162 +0,0 @@
-#ifndef _X86_64_BITOPS_H
-#define _X86_64_BITOPS_H
-/*
- * Copyright 1992, Linus Torvalds.
- */
-extern long find_first_zero_bit(const unsigned long *addr, unsigned long size);
-extern long find_next_zero_bit(const unsigned long *addr, long size, long offset);
-extern long find_first_bit(const unsigned long *addr, unsigned long size);
-extern long find_next_bit(const unsigned long *addr, long size, long offset);
-/* return index of first bet set in val or max when no bit is set */
-static inline long __scanbit(unsigned long val, unsigned long max)
-{
-        asm("bsfq %1,%0 ; cmovz %2,%0" : "=&r" (val) : "r" (val), "r" (max));
-        return val;
-}
-#define find_next_bit(addr,size,off) \
-((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ?         \
-  ((off) + (__scanbit((*(unsigned long *)addr) >> (off),(size)-(off)))) : \
-        find_next_bit(addr,size,off)))
-#define find_next_zero_bit(addr,size,off) \
-((__builtin_constant_p(size) && (size) <= BITS_PER_LONG ?         \
-  ((off)+(__scanbit(~(((*(unsigned long *)addr)) >> (off)),(size)-(off)))) : \
-        find_next_zero_bit(addr,size,off)))
-#define find_first_bit(addr, size)                                      \
-        ((__builtin_constant_p((size)) && (size) <= BITS_PER_LONG       \
-          ? (__scanbit(*(unsigned long *)(addr), (size)))               \
-          : find_first_bit((addr), (size))))
-#define find_first_zero_bit(addr, size)                                 \
-        ((__builtin_constant_p((size)) && (size) <= BITS_PER_LONG       \
-          ? (__scanbit(~*(unsigned long *)(addr), (size)))              \
-          : find_first_zero_bit((addr), (size))))
-static inline void set_bit_string(unsigned long *bitmap, unsigned long i,
-                                  int len)
-{
-        unsigned long end = i + len;
-        while (i < end) {
-                __set_bit(i, bitmap);
-                i++;
-        }
-}
-/**
- * ffz - find first zero in word.
- * @word: The word to search
- *
- * Undefined if no zero exists, so code should check against ~0UL first.
- */
-static inline unsigned long ffz(unsigned long word)
-{
-        __asm__("bsfq %1,%0"
-                :"=r" (word)
-                :"r" (~word));
-        return word;
-}
-/**
- * __ffs - find first bit in word.
- * @word: The word to search
- *
- * Undefined if no bit exists, so code should check against 0 first.
- */
-static inline unsigned long __ffs(unsigned long word)
-{
-        __asm__("bsfq %1,%0"
-                :"=r" (word)
-                :"rm" (word));
-        return word;
-}
-/*
- * __fls: find last bit set.
- * @word: The word to search
- *
- * Undefined if no zero exists, so code should check against ~0UL first.
- */
-static inline unsigned long __fls(unsigned long word)
-{
-        __asm__("bsrq %1,%0"
-                :"=r" (word)
-                :"rm" (word));
-        return word;
-}
-#ifdef __KERNEL__
-#include <asm-generic/bitops/sched.h>
-/**
- * ffs - find first bit set
- * @x: the word to search
- *
- * This is defined the same way as
- * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
- */
-static inline int ffs(int x)
-{
-        int r;
-        __asm__("bsfl %1,%0\n\t"
-                "cmovzl %2,%0" 
-                : "=r" (r) : "rm" (x), "r" (-1));
-        return r+1;
-}
-/**
- * fls64 - find last bit set in 64 bit word
- * @x: the word to search
- *
- * This is defined the same way as fls.
- */
-static inline int fls64(__u64 x)
-{
-        if (x == 0)
-                return 0;
-        return __fls(x) + 1;
-}
-/**
- * fls - find last bit set
- * @x: the word to search
- *
- * This is defined the same way as ffs.
- */
-static inline int fls(int x)
-{
-        int r;
-        __asm__("bsrl %1,%0\n\t"
-                "cmovzl %2,%0"
-                : "=&r" (r) : "rm" (x), "rm" (-1));
-        return r+1;
-}
-#define ARCH_HAS_FAST_MULTIPLIER 1
-#include <asm-generic/bitops/hweight.h>
-#endif /* __KERNEL__ */
-#ifdef __KERNEL__
-#include <asm-generic/bitops/ext2-non-atomic.h>
-#define ext2_set_bit_atomic(lock, nr, addr)                     \
-        test_and_set_bit((nr), (unsigned long *)(addr))
-#define ext2_clear_bit_atomic(lock, nr, addr)                   \
-        test_and_clear_bit((nr), (unsigned long *)(addr))
-#include <asm-generic/bitops/minix.h>
-#endif /* __KERNEL__ */
-#endif /* _X86_64_BITOPS_H */
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index 40d54731de7e..48bde600a2db 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -112,4 +112,144 @@ static inline unsigned fls_long(unsigned long l)
        return fls64(l);
 }
+#ifdef __KERNEL__
+#ifdef CONFIG_GENERIC_FIND_FIRST_BIT
+extern unsigned long __find_first_bit(const unsigned long *addr,
+                unsigned long size);
+/**
+ * find_first_bit - find the first set bit in a memory region
+ * @addr: The address to start the search at
+ * @size: The maximum size to search
+ *
+ * Returns the bit number of the first set bit.
+ */
+static __always_inline unsigned long
+find_first_bit(const unsigned long *addr, unsigned long size)
+{
+        /* Avoid a function call if the bitmap size is a constant */
+        /* and not bigger than BITS_PER_LONG. */
+        /* insert a sentinel so that __ffs returns size if there */
+        /* are no set bits in the bitmap */
+        if (__builtin_constant_p(size) && (size < BITS_PER_LONG))
+                return __ffs((*addr) | (1ul << size));
+        /* the result of __ffs(0) is undefined, so it needs to be */
+        /* handled separately */
+        if (__builtin_constant_p(size) && (size == BITS_PER_LONG))
+                return ((*addr) == 0) ? BITS_PER_LONG : __ffs(*addr);
+        /* size is not constant or too big */
+        return __find_first_bit(addr, size);
+}
+extern unsigned long __find_first_zero_bit(const unsigned long *addr,
+                unsigned long size);
+/**
+ * find_first_zero_bit - find the first cleared bit in a memory region
+ * @addr: The address to start the search at
+ * @size: The maximum size to search
+ *
+ * Returns the bit number of the first cleared bit.
+ */
+static __always_inline unsigned long
+find_first_zero_bit(const unsigned long *addr, unsigned long size)
+{
+        /* Avoid a function call if the bitmap size is a constant */
+        /* and not bigger than BITS_PER_LONG. */
+        /* insert a sentinel so that __ffs returns size if there */
+        /* are no set bits in the bitmap */
+        if (__builtin_constant_p(size) && (size < BITS_PER_LONG)) {
+                return __ffs(~(*addr) | (1ul << size));
+        }
+        /* the result of __ffs(0) is undefined, so it needs to be */
+        /* handled separately */
+        if (__builtin_constant_p(size) && (size == BITS_PER_LONG))
+                return (~(*addr) == 0) ? BITS_PER_LONG : __ffs(~(*addr));
+        /* size is not constant or too big */
+        return __find_first_zero_bit(addr, size);
+}
+#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
+#ifdef CONFIG_GENERIC_FIND_NEXT_BIT
+extern unsigned long __find_next_bit(const unsigned long *addr,
+                unsigned long size, unsigned long offset);
+/**
+ * find_next_bit - find the next set bit in a memory region
+ * @addr: The address to base the search on
+ * @offset: The bitnumber to start searching at
+ * @size: The bitmap size in bits
+ */
+static __always_inline unsigned long
+find_next_bit(const unsigned long *addr, unsigned long size,
+                unsigned long offset)
+{
+        unsigned long value;
+        /* Avoid a function call if the bitmap size is a constant */
+        /* and not bigger than BITS_PER_LONG. */
+        /* insert a sentinel so that __ffs returns size if there */
+        /* are no set bits in the bitmap */
+        if (__builtin_constant_p(size) && (size < BITS_PER_LONG)) {
+                value = (*addr) & ((~0ul) << offset);
+                value |= (1ul << size);
+                return __ffs(value);
+        }
+        /* the result of __ffs(0) is undefined, so it needs to be */
+        /* handled separately */
+        if (__builtin_constant_p(size) && (size == BITS_PER_LONG)) {
+                value = (*addr) & ((~0ul) << offset);
+                return (value == 0) ? BITS_PER_LONG : __ffs(value);
+        }
+        /* size is not constant or too big */
+        return __find_next_bit(addr, size, offset);
+}
+extern unsigned long __find_next_zero_bit(const unsigned long *addr,
+                unsigned long size, unsigned long offset);
+/**
+ * find_next_zero_bit - find the next cleared bit in a memory region
+ * @addr: The address to base the search on
+ * @offset: The bitnumber to start searching at
+ * @size: The bitmap size in bits
+ */
+static __always_inline unsigned long
+find_next_zero_bit(const unsigned long *addr, unsigned long size,
+                unsigned long offset)
+{
+        unsigned long value;
+        /* Avoid a function call if the bitmap size is a constant */
+        /* and not bigger than BITS_PER_LONG. */
+        /* insert a sentinel so that __ffs returns size if there */
+        /* are no set bits in the bitmap */
+        if (__builtin_constant_p(size) && (size < BITS_PER_LONG)) {
+                value = (~(*addr)) & ((~0ul) << offset);
+                value |= (1ul << size);
+                return __ffs(value);
+        }
+        /* the result of __ffs(0) is undefined, so it needs to be */
+        /* handled separately */
+        if (__builtin_constant_p(size) && (size == BITS_PER_LONG)) {
+                value = (~(*addr)) & ((~0ul) << offset);
+                return (value == 0) ? BITS_PER_LONG : __ffs(value);
+        }
+        /* size is not constant or too big */
+        return __find_next_zero_bit(addr, size, offset);
+}
+#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */
+#endif /* __KERNEL__ */
 #endif