Merge branch 'akpm' (patches from Andrew)

Merge misc updates from Andrew Morton:

 - kasan updates

 - procfs

 - lib/bitmap updates

 - other lib/ updates

 - checkpatch tweaks

 - rapidio

 - ubsan

 - pipe fixes and cleanups

 - lots of other misc bits

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (114 commits)
  Documentation/sysctl/user.txt: fix typo
  MAINTAINERS: update ARM/QUALCOMM SUPPORT patterns
  MAINTAINERS: update various PALM patterns
  MAINTAINERS: update "ARM/OXNAS platform support" patterns
  MAINTAINERS: update Cortina/Gemini patterns
  MAINTAINERS: remove ARM/CLKDEV SUPPORT file pattern
  MAINTAINERS: remove ANDROID ION pattern
  mm: docs: add blank lines to silence sphinx "Unexpected indentation" errors
  mm: docs: fix parameter names mismatch
  mm: docs: fixup punctuation
  pipe: read buffer limits atomically
  pipe: simplify round_pipe_size()
  pipe: reject F_SETPIPE_SZ with size over UINT_MAX
  pipe: fix off-by-one error when checking buffer limits
  pipe: actually allow root to exceed the pipe buffer limits
  pipe, sysctl: remove pipe_proc_fn()
  pipe, sysctl: drop 'min' parameter from pipe-max-size converter
  kasan: rework Kconfig settings
  crash_dump: is_kdump_kernel can be boolean
  kernel/mutex: mutex_is_locked can be boolean
  ...

1 files changed, 96 insertions, 199 deletions

diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
index aa1f2669bdd5..b3f235baa05d 100644
--- a/lib/test_bitmap.c
+++ b/lib/test_bitmap.c
@@ -23,7 +23,7 @@ __check_eq_uint(const char *srcfile, unsigned int line,
                 const unsigned int exp_uint, unsigned int x)
 {
         if (exp_uint != x) {
-                pr_warn("[%s:%u] expected %u, got %u\n",
+                pr_err("[%s:%u] expected %u, got %u\n",
                         srcfile, line, exp_uint, x);
                 return false;
         }
@@ -33,19 +33,13 @@ __check_eq_uint(const char *srcfile, unsigned int line,
 
 static bool __init
 __check_eq_bitmap(const char *srcfile, unsigned int line,
-                  const unsigned long *exp_bmap, unsigned int exp_nbits,
-                  const unsigned long *bmap, unsigned int nbits)
+                  const unsigned long *exp_bmap, const unsigned long *bmap,
+                  unsigned int nbits)
 {
-        if (exp_nbits != nbits) {
-                pr_warn("[%s:%u] bitmap length mismatch: expected %u, got %u\n",
-                        srcfile, line, exp_nbits, nbits);
-                return false;
-        }
-
         if (!bitmap_equal(exp_bmap, bmap, nbits)) {
                 pr_warn("[%s:%u] bitmaps contents differ: expected \"%*pbl\", got \"%*pbl\"\n",
                         srcfile, line,
-                        exp_nbits, exp_bmap, nbits, bmap);
+                        nbits, exp_bmap, nbits, bmap);
                 return false;
         }
         return true;
@@ -69,6 +63,10 @@ __check_eq_pbl(const char *srcfile, unsigned int line,
 static bool __init
 __check_eq_u32_array(const char *srcfile, unsigned int line,
                      const u32 *exp_arr, unsigned int exp_len,
+                     const u32 *arr, unsigned int len) __used;
+static bool __init
+__check_eq_u32_array(const char *srcfile, unsigned int line,
+                     const u32 *exp_arr, unsigned int exp_len,
                      const u32 *arr, unsigned int len)
 {
         if (exp_len != len) {
@@ -107,7 +105,65 @@ __check_eq_u32_array(const char *srcfile, unsigned int line,
 #define expect_eq_pbl(...)              __expect_eq(pbl, ##__VA_ARGS__)
 #define expect_eq_u32_array(...)        __expect_eq(u32_array, ##__VA_ARGS__)
 
-static void __init test_zero_fill_copy(void)
+static void __init test_zero_clear(void)
+{
+        DECLARE_BITMAP(bmap, 1024);
+
+        /* Known way to set all bits */
+        memset(bmap, 0xff, 128);
+
+        expect_eq_pbl("0-22", bmap, 23);
+        expect_eq_pbl("0-1023", bmap, 1024);
+
+        /* single-word bitmaps */
+        bitmap_clear(bmap, 0, 9);
+        expect_eq_pbl("9-1023", bmap, 1024);
+
+        bitmap_zero(bmap, 35);
+        expect_eq_pbl("64-1023", bmap, 1024);
+
+        /* cross boundaries operations */
+        bitmap_clear(bmap, 79, 19);
+        expect_eq_pbl("64-78,98-1023", bmap, 1024);
+
+        bitmap_zero(bmap, 115);
+        expect_eq_pbl("128-1023", bmap, 1024);
+
+        /* Zeroing entire area */
+        bitmap_zero(bmap, 1024);
+        expect_eq_pbl("", bmap, 1024);
+}
+
+static void __init test_fill_set(void)
+{
+        DECLARE_BITMAP(bmap, 1024);
+
+        /* Known way to clear all bits */
+        memset(bmap, 0x00, 128);
+
+        expect_eq_pbl("", bmap, 23);
+        expect_eq_pbl("", bmap, 1024);
+
+        /* single-word bitmaps */
+        bitmap_set(bmap, 0, 9);
+        expect_eq_pbl("0-8", bmap, 1024);
+
+        bitmap_fill(bmap, 35);
+        expect_eq_pbl("0-63", bmap, 1024);
+
+        /* cross boundaries operations */
+        bitmap_set(bmap, 79, 19);
+        expect_eq_pbl("0-63,79-97", bmap, 1024);
+
+        bitmap_fill(bmap, 115);
+        expect_eq_pbl("0-127", bmap, 1024);
+
+        /* Zeroing entire area */
+        bitmap_fill(bmap, 1024);
+        expect_eq_pbl("0-1023", bmap, 1024);
+}
+
+static void __init test_copy(void)
 {
         DECLARE_BITMAP(bmap1, 1024);
         DECLARE_BITMAP(bmap2, 1024);
@@ -116,36 +172,20 @@ static void __init test_zero_fill_copy(void)
         bitmap_zero(bmap2, 1024);
 
         /* single-word bitmaps */
-        expect_eq_pbl("", bmap1, 23);
-
-        bitmap_fill(bmap1, 19);
-        expect_eq_pbl("0-18", bmap1, 1024);
-
+        bitmap_set(bmap1, 0, 19);
         bitmap_copy(bmap2, bmap1, 23);
         expect_eq_pbl("0-18", bmap2, 1024);
 
-        bitmap_fill(bmap2, 23);
-        expect_eq_pbl("0-22", bmap2, 1024);
-
+        bitmap_set(bmap2, 0, 23);
         bitmap_copy(bmap2, bmap1, 23);
         expect_eq_pbl("0-18", bmap2, 1024);
 
-        bitmap_zero(bmap1, 23);
-        expect_eq_pbl("", bmap1, 1024);
-
         /* multi-word bitmaps */
-        bitmap_zero(bmap1, 1024);
-        expect_eq_pbl("", bmap1, 1024);
-
-        bitmap_fill(bmap1, 109);
-        expect_eq_pbl("0-108", bmap1, 1024);
-
+        bitmap_set(bmap1, 0, 109);
         bitmap_copy(bmap2, bmap1, 1024);
         expect_eq_pbl("0-108", bmap2, 1024);
 
         bitmap_fill(bmap2, 1024);
-        expect_eq_pbl("0-1023", bmap2, 1024);
-
         bitmap_copy(bmap2, bmap1, 1024);
         expect_eq_pbl("0-108", bmap2, 1024);
 
@@ -160,9 +200,6 @@ static void __init test_zero_fill_copy(void)
         bitmap_fill(bmap2, 1024);
         bitmap_copy(bmap2, bmap1, 97);  /* ... but aligned on word length */
         expect_eq_pbl("0-108,128-1023", bmap2, 1024);
-
-        bitmap_zero(bmap2, 97);  /* ... but 0-padded til word length */
-        expect_eq_pbl("128-1023", bmap2, 1024);
 }
 
 #define PARSE_TIME 0x1
@@ -255,171 +292,29 @@ static void __init test_bitmap_parselist(void)
         }
 }
 
-static void __init test_bitmap_u32_array_conversions(void)
+static void __init test_bitmap_arr32(void)
 {
-        DECLARE_BITMAP(bmap1, 1024);
-        DECLARE_BITMAP(bmap2, 1024);
-        u32 exp_arr[32], arr[32];
-        unsigned nbits;
-
-        for (nbits = 0 ; nbits < 257 ; ++nbits) {
-                const unsigned int used_u32s = DIV_ROUND_UP(nbits, 32);
-                unsigned int i, rv;
-
-                bitmap_zero(bmap1, nbits);
-                bitmap_set(bmap1, nbits, 1024 - nbits);  /* garbage */
-
-                memset(arr, 0xff, sizeof(arr));
-                rv = bitmap_to_u32array(arr, used_u32s, bmap1, nbits);
-                expect_eq_uint(nbits, rv);
-
-                memset(exp_arr, 0xff, sizeof(exp_arr));
-                memset(exp_arr, 0, used_u32s*sizeof(*exp_arr));
-                expect_eq_u32_array(exp_arr, 32, arr, 32);
-
-                bitmap_fill(bmap2, 1024);
-                rv = bitmap_from_u32array(bmap2, nbits, arr, used_u32s);
-                expect_eq_uint(nbits, rv);
-                expect_eq_bitmap(bmap1, 1024, bmap2, 1024);
-
-                for (i = 0 ; i < nbits ; ++i) {
-                        /*
-                         * test conversion bitmap -> u32[]
-                         */
-
-                        bitmap_zero(bmap1, 1024);
-                        __set_bit(i, bmap1);
-                        bitmap_set(bmap1, nbits, 1024 - nbits);  /* garbage */
-
-                        memset(arr, 0xff, sizeof(arr));
-                        rv = bitmap_to_u32array(arr, used_u32s, bmap1, nbits);
-                        expect_eq_uint(nbits, rv);
-
-                        /* 1st used u32 words contain expected bit set, the
-                         * remaining words are left unchanged (0xff)
-                         */
-                        memset(exp_arr, 0xff, sizeof(exp_arr));
-                        memset(exp_arr, 0, used_u32s*sizeof(*exp_arr));
-                        exp_arr[i/32] = (1U<<(i%32));
-                        expect_eq_u32_array(exp_arr, 32, arr, 32);
-
-
-                        /* same, with longer array to fill
-                         */
-                        memset(arr, 0xff, sizeof(arr));
-                        rv = bitmap_to_u32array(arr, 32, bmap1, nbits);
-                        expect_eq_uint(nbits, rv);
-
-                        /* 1st used u32 words contain expected bit set, the
-                         * remaining words are all 0s
-                         */
-                        memset(exp_arr, 0, sizeof(exp_arr));
-                        exp_arr[i/32] = (1U<<(i%32));
-                        expect_eq_u32_array(exp_arr, 32, arr, 32);
-
-                        /*
-                         * test conversion u32[] -> bitmap
-                         */
-
-                        /* the 1st nbits of bmap2 are identical to
-                         * bmap1, the remaining bits of bmap2 are left
-                         * unchanged (all 1s)
-                         */
-                        bitmap_fill(bmap2, 1024);
-                        rv = bitmap_from_u32array(bmap2, nbits,
-                                                  exp_arr, used_u32s);
-                        expect_eq_uint(nbits, rv);
-
-                        expect_eq_bitmap(bmap1, 1024, bmap2, 1024);
-
-                        /* same, with more bits to fill
-                         */
-                        memset(arr, 0xff, sizeof(arr));  /* garbage */
-                        memset(arr, 0, used_u32s*sizeof(u32));
-                        arr[i/32] = (1U<<(i%32));
-
-                        bitmap_fill(bmap2, 1024);
-                        rv = bitmap_from_u32array(bmap2, 1024, arr, used_u32s);
-                        expect_eq_uint(used_u32s*32, rv);
-
-                        /* the 1st nbits of bmap2 are identical to
-                         * bmap1, the remaining bits of bmap2 are cleared
-                         */
-                        bitmap_zero(bmap1, 1024);
-                        __set_bit(i, bmap1);
-                        expect_eq_bitmap(bmap1, 1024, bmap2, 1024);
-
-
-                        /*
-                         * test short conversion bitmap -> u32[] (1
-                         * word too short)
-                         */
-                        if (used_u32s > 1) {
-                                bitmap_zero(bmap1, 1024);
-                                __set_bit(i, bmap1);
-                                bitmap_set(bmap1, nbits,
-                                           1024 - nbits);  /* garbage */
-                                memset(arr, 0xff, sizeof(arr));
-
-                                rv = bitmap_to_u32array(arr, used_u32s - 1,
-                                                        bmap1, nbits);
-                                expect_eq_uint((used_u32s - 1)*32, rv);
-
-                                /* 1st used u32 words contain expected
-                                 * bit set, the remaining words are
-                                 * left unchanged (0xff)
-                                 */
-                                memset(exp_arr, 0xff, sizeof(exp_arr));
-                                memset(exp_arr, 0,
-                                       (used_u32s-1)*sizeof(*exp_arr));
-                                if ((i/32) < (used_u32s - 1))
-                                        exp_arr[i/32] = (1U<<(i%32));
-                                expect_eq_u32_array(exp_arr, 32, arr, 32);
-                        }
-
-                        /*
-                         * test short conversion u32[] -> bitmap (3
-                         * bits too short)
-                         */
-                        if (nbits > 3) {
-                                memset(arr, 0xff, sizeof(arr));  /* garbage */
-                                memset(arr, 0, used_u32s*sizeof(*arr));
-                                arr[i/32] = (1U<<(i%32));
-
-                                bitmap_zero(bmap1, 1024);
-                                rv = bitmap_from_u32array(bmap1, nbits - 3,
-                                                          arr, used_u32s);
-                                expect_eq_uint(nbits - 3, rv);
-
-                                /* we are expecting the bit < nbits -
-                                 * 3 (none otherwise), and the rest of
-                                 * bmap1 unchanged (0-filled)
-                                 */
-                                bitmap_zero(bmap2, 1024);
-                                if (i < nbits - 3)
-                                        __set_bit(i, bmap2);
-                                expect_eq_bitmap(bmap2, 1024, bmap1, 1024);
-
-                                /* do the same with bmap1 initially
-                                 * 1-filled
-                                 */
-
-                                bitmap_fill(bmap1, 1024);
-                                rv = bitmap_from_u32array(bmap1, nbits - 3,
-                                                         arr, used_u32s);
-                                expect_eq_uint(nbits - 3, rv);
-
-                                /* we are expecting the bit < nbits -
-                                 * 3 (none otherwise), and the rest of
-                                 * bmap1 unchanged (1-filled)
-                                 */
-                                bitmap_zero(bmap2, 1024);
-                                if (i < nbits - 3)
-                                        __set_bit(i, bmap2);
-                                bitmap_set(bmap2, nbits-3, 1024 - nbits + 3);
-                                expect_eq_bitmap(bmap2, 1024, bmap1, 1024);
-                        }
-                }
+        unsigned int nbits, next_bit, len = sizeof(exp) * 8;
+        u32 arr[sizeof(exp) / 4];
+        DECLARE_BITMAP(bmap2, len);
+
+        memset(arr, 0xa5, sizeof(arr));
+
+        for (nbits = 0; nbits < len; ++nbits) {
+                bitmap_to_arr32(arr, exp, nbits);
+                bitmap_from_arr32(bmap2, arr, nbits);
+                expect_eq_bitmap(bmap2, exp, nbits);
+
+                next_bit = find_next_bit(bmap2,
+                                round_up(nbits, BITS_PER_LONG), nbits);
+                if (next_bit < round_up(nbits, BITS_PER_LONG))
+                        pr_err("bitmap_copy_arr32(nbits == %d:"
+                                " tail is not safely cleared: %d\n",
+                                nbits, next_bit);
+
+                if (nbits < len - 32)
+                        expect_eq_uint(arr[DIV_ROUND_UP(nbits, 32)],
+                                                                0xa5a5a5a5);
         }
 }
 
@@ -453,8 +348,10 @@ static void noinline __init test_mem_optimisations(void)
 
 static int __init test_bitmap_init(void)
 {
-        test_zero_fill_copy();
-        test_bitmap_u32_array_conversions();
+        test_zero_clear();
+        test_fill_set();
+        test_copy();
+        test_bitmap_arr32();
         test_bitmap_parselist();
         test_mem_optimisations();