10 files changed, 147 insertions, 33 deletions

diff --git a/arch/arm/include/asm/bitops.h b/arch/arm/include/asm/bitops.h
index ce5ee762ed66..4cab9bb823fb 100644
--- a/arch/arm/include/asm/bitops.h
+++ b/arch/arm/include/asm/bitops.h
@@ -338,6 +338,7 @@ static inline int find_next_bit_le(const void *p, int size, int offset)
 
 #endif
 
+#include <asm-generic/bitops/find.h>
 #include <asm-generic/bitops/le.h>
 
 /*
diff --git a/arch/m68k/include/asm/bitops.h b/arch/m68k/include/asm/bitops.h
index dda58cfe8c22..93b47b1f6fb4 100644
--- a/arch/m68k/include/asm/bitops.h
+++ b/arch/m68k/include/asm/bitops.h
@@ -311,7 +311,6 @@ static inline int bfchg_mem_test_and_change_bit(int nr,
  *      functions.
  */
 #if defined(CONFIG_CPU_HAS_NO_BITFIELDS)
-#include <asm-generic/bitops/find.h>
 #include <asm-generic/bitops/ffz.h>
 #else
 
@@ -441,6 +440,8 @@ static inline unsigned long ffz(unsigned long word)
 
 #endif
 
+#include <asm-generic/bitops/find.h>
+
 #ifdef __KERNEL__
 
 #if defined(CONFIG_CPU_HAS_NO_BITFIELDS)
diff --git a/arch/unicore32/include/asm/bitops.h b/arch/unicore32/include/asm/bitops.h
index 401f597bc38c..c0cbdbe17168 100644
--- a/arch/unicore32/include/asm/bitops.h
+++ b/arch/unicore32/include/asm/bitops.h
@@ -44,4 +44,6 @@ static inline int fls(int x)
 #define find_first_bit          find_first_bit
 #define find_first_zero_bit     find_first_zero_bit
 
+#include <asm-generic/bitops/find.h>
+
 #endif /* __UNICORE_BITOPS_H__ */
diff --git a/include/asm-generic/bitops/find.h b/include/asm-generic/bitops/find.h
index 1ba611e16fa0..8a1ee10014de 100644
--- a/include/asm-generic/bitops/find.h
+++ b/include/asm-generic/bitops/find.h
@@ -16,6 +16,22 @@ extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
                 size, unsigned long offset);
 #endif
 
+#ifndef find_next_and_bit
+/**
+ * find_next_and_bit - find the next set bit in both memory regions
+ * @addr1: The first address to base the search on
+ * @addr2: The second address to base the search on
+ * @offset: The bitnumber to start searching at
+ * @size: The bitmap size in bits
+ *
+ * Returns the bit number for the next set bit
+ * If no bits are set, returns @size.
+ */
+extern unsigned long find_next_and_bit(const unsigned long *addr1,
+                const unsigned long *addr2, unsigned long size,
+                unsigned long offset);
+#endif
+
 #ifndef find_next_zero_bit
 /**
  * find_next_zero_bit - find the next cleared bit in a memory region
@@ -55,8 +71,12 @@ extern unsigned long find_first_zero_bit(const unsigned long *addr,
                                          unsigned long size);
 #else /* CONFIG_GENERIC_FIND_FIRST_BIT */
 
+#ifndef find_first_bit
 #define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
+#endif
+#ifndef find_first_zero_bit
 #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
+#endif
 
 #endif /* CONFIG_GENERIC_FIND_FIRST_BIT */
 
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index d9bf699e0e7a..5f11fbdc27f8 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -88,8 +88,12 @@
  *  test_and_change_bit(bit, addr)      Change bit and return old value
  *  find_first_zero_bit(addr, nbits)    Position first zero bit in *addr
  *  find_first_bit(addr, nbits)         Position first set bit in *addr
- *  find_next_zero_bit(addr, nbits, bit)  Position next zero bit in *addr >= bit
+ *  find_next_zero_bit(addr, nbits, bit)
+ *                                      Position next zero bit in *addr >= bit
  *  find_next_bit(addr, nbits, bit)     Position next set bit in *addr >= bit
+ *  find_next_and_bit(addr1, addr2, nbits, bit)
+ *                                      Same as find_next_bit, but in
+ *                                      (*addr1 & *addr2)
  *
  */
 
diff --git a/lib/cpumask.c b/lib/cpumask.c
index 35fe142ebb5e..beca6244671a 100644
--- a/lib/cpumask.c
+++ b/lib/cpumask.c
@@ -33,10 +33,11 @@ EXPORT_SYMBOL(cpumask_next);
 int cpumask_next_and(int n, const struct cpumask *src1p,
                      const struct cpumask *src2p)
 {
-        while ((n = cpumask_next(n, src1p)) < nr_cpu_ids)
-                if (cpumask_test_cpu(n, src2p))
-                        break;
-        return n;
+        /* -1 is a legal arg here. */
+        if (n != -1)
+                cpumask_check(n);
+        return find_next_and_bit(cpumask_bits(src1p), cpumask_bits(src2p),
+                nr_cpumask_bits, n + 1);
 }
 EXPORT_SYMBOL(cpumask_next_and);
 
diff --git a/lib/find_bit.c b/lib/find_bit.c
index 6ed74f78380c..ee3df93ba69a 100644
--- a/lib/find_bit.c
+++ b/lib/find_bit.c
@@ -21,22 +21,29 @@
 #include <linux/export.h>
 #include <linux/kernel.h>
 
-#if !defined(find_next_bit) || !defined(find_next_zero_bit)
+#if !defined(find_next_bit) || !defined(find_next_zero_bit) || \
+                !defined(find_next_and_bit)
 
 /*
- * This is a common helper function for find_next_bit and
- * find_next_zero_bit.  The difference is the "invert" argument, which
- * is XORed with each fetched word before searching it for one bits.
+ * This is a common helper function for find_next_bit, find_next_zero_bit, and
+ * find_next_and_bit. The differences are:
+ *  - The "invert" argument, which is XORed with each fetched word before
+ *    searching it for one bits.
+ *  - The optional "addr2", which is anded with "addr1" if present.
  */
-static unsigned long _find_next_bit(const unsigned long *addr,
-                unsigned long nbits, unsigned long start, unsigned long invert)
+static inline unsigned long _find_next_bit(const unsigned long *addr1,
+                const unsigned long *addr2, unsigned long nbits,
+                unsigned long start, unsigned long invert)
 {
         unsigned long tmp;
 
         if (unlikely(start >= nbits))
                 return nbits;
 
-        tmp = addr[start / BITS_PER_LONG] ^ invert;
+        tmp = addr1[start / BITS_PER_LONG];
+        if (addr2)
+                tmp &= addr2[start / BITS_PER_LONG];
+        tmp ^= invert;
 
         /* Handle 1st word. */
         tmp &= BITMAP_FIRST_WORD_MASK(start);
@@ -47,7 +54,10 @@ static unsigned long _find_next_bit(const unsigned long *addr,
                 if (start >= nbits)
                         return nbits;
 
-                tmp = addr[start / BITS_PER_LONG] ^ invert;
+                tmp = addr1[start / BITS_PER_LONG];
+                if (addr2)
+                        tmp &= addr2[start / BITS_PER_LONG];
+                tmp ^= invert;
         }
 
         return min(start + __ffs(tmp), nbits);
@@ -61,7 +71,7 @@ static unsigned long _find_next_bit(const unsigned long *addr,
 unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
                             unsigned long offset)
 {
-        return _find_next_bit(addr, size, offset, 0UL);
+        return _find_next_bit(addr, NULL, size, offset, 0UL);
 }
 EXPORT_SYMBOL(find_next_bit);
 #endif
@@ -70,11 +80,21 @@ EXPORT_SYMBOL(find_next_bit);
 unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
                                  unsigned long offset)
 {
-        return _find_next_bit(addr, size, offset, ~0UL);
+        return _find_next_bit(addr, NULL, size, offset, ~0UL);
 }
 EXPORT_SYMBOL(find_next_zero_bit);
 #endif
 
+#if !defined(find_next_and_bit)
+unsigned long find_next_and_bit(const unsigned long *addr1,
+                const unsigned long *addr2, unsigned long size,
+                unsigned long offset)
+{
+        return _find_next_bit(addr1, addr2, size, offset, 0UL);
+}
+EXPORT_SYMBOL(find_next_and_bit);
+#endif
+
 #ifndef find_first_bit
 /*
  * Find the first set bit in a memory region.
@@ -146,15 +166,19 @@ static inline unsigned long ext2_swab(const unsigned long y)
 }
 
 #if !defined(find_next_bit_le) || !defined(find_next_zero_bit_le)
-static unsigned long _find_next_bit_le(const unsigned long *addr,
-                unsigned long nbits, unsigned long start, unsigned long invert)
+static inline unsigned long _find_next_bit_le(const unsigned long *addr1,
+                const unsigned long *addr2, unsigned long nbits,
+                unsigned long start, unsigned long invert)
 {
         unsigned long tmp;
 
         if (unlikely(start >= nbits))
                 return nbits;
 
-        tmp = addr[start / BITS_PER_LONG] ^ invert;
+        tmp = addr1[start / BITS_PER_LONG];
+        if (addr2)
+                tmp &= addr2[start / BITS_PER_LONG];
+        tmp ^= invert;
 
         /* Handle 1st word. */
         tmp &= ext2_swab(BITMAP_FIRST_WORD_MASK(start));
@@ -165,7 +189,10 @@ static unsigned long _find_next_bit_le(const unsigned long *addr,
                 if (start >= nbits)
                         return nbits;
 
-                tmp = addr[start / BITS_PER_LONG] ^ invert;
+                tmp = addr1[start / BITS_PER_LONG];
+                if (addr2)
+                        tmp &= addr2[start / BITS_PER_LONG];
+                tmp ^= invert;
         }
 
         return min(start + __ffs(ext2_swab(tmp)), nbits);
@@ -176,7 +203,7 @@ static unsigned long _find_next_bit_le(const unsigned long *addr,
 unsigned long find_next_zero_bit_le(const void *addr, unsigned
                 long size, unsigned long offset)
 {
-        return _find_next_bit_le(addr, size, offset, ~0UL);
+        return _find_next_bit_le(addr, NULL, size, offset, ~0UL);
 }
 EXPORT_SYMBOL(find_next_zero_bit_le);
 #endif
@@ -185,7 +212,7 @@ EXPORT_SYMBOL(find_next_zero_bit_le);
 unsigned long find_next_bit_le(const void *addr, unsigned
                 long size, unsigned long offset)
 {
-        return _find_next_bit_le(addr, size, offset, 0UL);
+        return _find_next_bit_le(addr, NULL, size, offset, 0UL);
 }
 EXPORT_SYMBOL(find_next_bit_le);
 #endif
diff --git a/lib/find_bit_benchmark.c b/lib/find_bit_benchmark.c
index 67b19233c28f..5985a25e6cbc 100644
--- a/lib/find_bit_benchmark.c
+++ b/lib/find_bit_benchmark.c
@@ -35,6 +35,7 @@
 #define SPARSE          500
 
 static DECLARE_BITMAP(bitmap, BITMAP_LEN) __initdata;
+static DECLARE_BITMAP(bitmap2, BITMAP_LEN) __initdata;
 
 /*
  * This is Schlemiel the Painter's algorithm. It should be called after
@@ -103,6 +104,22 @@ static int __init test_find_last_bit(const void *bitmap, unsigned long len)
         return 0;
 }
 
+static int __init test_find_next_and_bit(const void *bitmap,
+                const void *bitmap2, unsigned long len)
+{
+        unsigned long i, cnt;
+        cycles_t cycles;
+
+        cycles = get_cycles();
+        for (cnt = i = 0; i < BITMAP_LEN; cnt++)
+                i = find_next_and_bit(bitmap, bitmap2, BITMAP_LEN, i+1);
+        cycles = get_cycles() - cycles;
+        pr_err("find_next_and_bit:\t\t%llu cycles, %ld iterations\n",
+                (u64)cycles, cnt);
+
+        return 0;
+}
+
 static int __init find_bit_test(void)
 {
         unsigned long nbits = BITMAP_LEN / SPARSE;
@@ -110,23 +127,29 @@ static int __init find_bit_test(void)
         pr_err("\nStart testing find_bit() with random-filled bitmap\n");
 
         get_random_bytes(bitmap, sizeof(bitmap));
+        get_random_bytes(bitmap2, sizeof(bitmap2));
 
         test_find_next_bit(bitmap, BITMAP_LEN);
         test_find_next_zero_bit(bitmap, BITMAP_LEN);
         test_find_last_bit(bitmap, BITMAP_LEN);
         test_find_first_bit(bitmap, BITMAP_LEN);
+        test_find_next_and_bit(bitmap, bitmap2, BITMAP_LEN);
 
         pr_err("\nStart testing find_bit() with sparse bitmap\n");
 
         bitmap_zero(bitmap, BITMAP_LEN);
+        bitmap_zero(bitmap2, BITMAP_LEN);
 
-        while (nbits--)
+        while (nbits--) {
                 __set_bit(prandom_u32() % BITMAP_LEN, bitmap);
+                __set_bit(prandom_u32() % BITMAP_LEN, bitmap2);
+        }
 
         test_find_next_bit(bitmap, BITMAP_LEN);
         test_find_next_zero_bit(bitmap, BITMAP_LEN);
         test_find_last_bit(bitmap, BITMAP_LEN);
         test_find_first_bit(bitmap, BITMAP_LEN);
+        test_find_next_and_bit(bitmap, bitmap2, BITMAP_LEN);
 
         /*
          * Everything is OK. Return error just to let user run benchmark
diff --git a/tools/include/asm-generic/bitops/find.h b/tools/include/asm-generic/bitops/find.h
index 9311fadaaab2..16ed1982cb34 100644
--- a/tools/include/asm-generic/bitops/find.h
+++ b/tools/include/asm-generic/bitops/find.h
@@ -16,6 +16,22 @@ extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
                 size, unsigned long offset);
 #endif
 
+#ifndef find_next_and_bit
+/**
+ * find_next_and_bit - find the next set bit in both memory regions
+ * @addr1: The first address to base the search on
+ * @addr2: The second address to base the search on
+ * @offset: The bitnumber to start searching at
+ * @size: The bitmap size in bits
+ *
+ * Returns the bit number for the next set bit
+ * If no bits are set, returns @size.
+ */
+extern unsigned long find_next_and_bit(const unsigned long *addr1,
+                const unsigned long *addr2, unsigned long size,
+                unsigned long offset);
+#endif
+
 #ifndef find_next_zero_bit
 
 /**
diff --git a/tools/lib/find_bit.c b/tools/lib/find_bit.c
index 42c15f906aac..a88bd507091e 100644
--- a/tools/lib/find_bit.c
+++ b/tools/lib/find_bit.c
@@ -22,22 +22,29 @@
 #include <linux/bitmap.h>
 #include <linux/kernel.h>
 
-#if !defined(find_next_bit)
+#if !defined(find_next_bit) || !defined(find_next_zero_bit) || \
+                !defined(find_next_and_bit)
 
 /*
- * This is a common helper function for find_next_bit and
- * find_next_zero_bit.  The difference is the "invert" argument, which
- * is XORed with each fetched word before searching it for one bits.
+ * This is a common helper function for find_next_bit, find_next_zero_bit, and
+ * find_next_and_bit. The differences are:
+ *  - The "invert" argument, which is XORed with each fetched word before
+ *    searching it for one bits.
+ *  - The optional "addr2", which is anded with "addr1" if present.
  */
-static unsigned long _find_next_bit(const unsigned long *addr,
-                unsigned long nbits, unsigned long start, unsigned long invert)
+static inline unsigned long _find_next_bit(const unsigned long *addr1,
+                const unsigned long *addr2, unsigned long nbits,
+                unsigned long start, unsigned long invert)
 {
         unsigned long tmp;
 
         if (unlikely(start >= nbits))
                 return nbits;
 
-        tmp = addr[start / BITS_PER_LONG] ^ invert;
+        tmp = addr1[start / BITS_PER_LONG];
+        if (addr2)
+                tmp &= addr2[start / BITS_PER_LONG];
+        tmp ^= invert;
 
         /* Handle 1st word. */
         tmp &= BITMAP_FIRST_WORD_MASK(start);
@@ -48,7 +55,10 @@ static unsigned long _find_next_bit(const unsigned long *addr,
                 if (start >= nbits)
                         return nbits;
 
-                tmp = addr[start / BITS_PER_LONG] ^ invert;
+                tmp = addr1[start / BITS_PER_LONG];
+                if (addr2)
+                        tmp &= addr2[start / BITS_PER_LONG];
+                tmp ^= invert;
         }
 
         return min(start + __ffs(tmp), nbits);
@@ -62,7 +72,7 @@ static unsigned long _find_next_bit(const unsigned long *addr,
 unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
                             unsigned long offset)
 {
-        return _find_next_bit(addr, size, offset, 0UL);
+        return _find_next_bit(addr, NULL, size, offset, 0UL);
 }
 #endif
 
@@ -104,6 +114,15 @@ unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)
 unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
                                  unsigned long offset)
 {
-        return _find_next_bit(addr, size, offset, ~0UL);
+        return _find_next_bit(addr, NULL, size, offset, ~0UL);
+}
+#endif
+
+#ifndef find_next_and_bit
+unsigned long find_next_and_bit(const unsigned long *addr1,
+                const unsigned long *addr2, unsigned long size,
+                unsigned long offset)
+{
+        return _find_next_bit(addr1, addr2, size, offset, 0UL);
 }
 #endif