Merge branch 'akpm' (patches from Andrew)

Merge fourth patch-bomb from Andrew Morton:
 "A lot more stuff than expected, sorry.  A bunch of ocfs2 reviewing was
  finished off.

   - mhocko's oom-reaper out-of-memory-handler changes

   - ocfs2 fixes and features

   - KASAN feature work

   - various fixes"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (42 commits)
  thp: fix typo in khugepaged_scan_pmd()
  MAINTAINERS: fill entries for KASAN
  mm/filemap: generic_file_read_iter(): check for zero reads unconditionally
  kasan: test fix: warn if the UAF could not be detected in kmalloc_uaf2
  mm, kasan: stackdepot implementation. Enable stackdepot for SLAB
  arch, ftrace: for KASAN put hard/soft IRQ entries into separate sections
  mm, kasan: add GFP flags to KASAN API
  mm, kasan: SLAB support
  kasan: modify kmalloc_large_oob_right(), add kmalloc_pagealloc_oob_right()
  include/linux/oom.h: remove undefined oom_kills_count()/note_oom_kill()
  mm/page_alloc: prevent merging between isolated and other pageblocks
  drivers/memstick/host/r592.c: avoid gcc-6 warning
  ocfs2: extend enough credits for freeing one truncate record while replaying truncate records
  ocfs2: extend transaction for ocfs2_remove_rightmost_path() and ocfs2_update_edge_lengths() before to avoid inconsistency between inode and et
  ocfs2/dlm: move lock to the tail of grant queue while doing in-place convert
  ocfs2: solve a problem of crossing the boundary in updating backups
  ocfs2: fix occurring deadlock by changing ocfs2_wq from global to local
  ocfs2/dlm: fix BUG in dlm_move_lockres_to_recovery_list
  ocfs2/dlm: fix race between convert and recovery
  ocfs2: fix a deadlock issue in ocfs2_dio_end_io_write()
  ...

5 files changed, 324 insertions, 2 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index 133ebc0c1773..3cca1222578e 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -536,4 +536,8 @@ config ARCH_HAS_PMEM_API
 config ARCH_HAS_MMIO_FLUSH
         bool
 
+config STACKDEPOT
+        bool
+        select STACKTRACE
+
 endmenu
diff --git a/lib/Kconfig.kasan b/lib/Kconfig.kasan
index 0fee5acd5aa0..67d8c6838ba9 100644
--- a/lib/Kconfig.kasan
+++ b/lib/Kconfig.kasan
@@ -5,8 +5,9 @@ if HAVE_ARCH_KASAN
 
 config KASAN
         bool "KASan: runtime memory debugger"
-        depends on SLUB_DEBUG
+        depends on SLUB_DEBUG || (SLAB && !DEBUG_SLAB)
         select CONSTRUCTORS
+        select STACKDEPOT if SLAB
         help
           Enables kernel address sanitizer - runtime memory debugger,
           designed to find out-of-bounds accesses and use-after-free bugs.
@@ -16,6 +17,8 @@ config KASAN
           This feature consumes about 1/8 of available memory and brings about
           ~x3 performance slowdown.
           For better error detection enable CONFIG_STACKTRACE.
+          Currently CONFIG_KASAN doesn't work with CONFIG_DEBUG_SLAB
+          (the resulting kernel does not boot).
 
 choice
         prompt "Instrumentation type"
diff --git a/lib/Makefile b/lib/Makefile
index a1de5b61ff40..7bd6fd436c97 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -181,6 +181,9 @@ obj-$(CONFIG_SG_SPLIT) += sg_split.o
 obj-$(CONFIG_STMP_DEVICE) += stmp_device.o
 obj-$(CONFIG_IRQ_POLL) += irq_poll.o
 
+obj-$(CONFIG_STACKDEPOT) += stackdepot.o
+KASAN_SANITIZE_stackdepot.o := n
+
 libfdt_files = fdt.o fdt_ro.o fdt_wip.o fdt_rw.o fdt_sw.o fdt_strerror.o \
                fdt_empty_tree.o
 $(foreach file, $(libfdt_files), \
diff --git a/lib/stackdepot.c b/lib/stackdepot.c
new file mode 100644
index 000000000000..654c9d87e83a
--- /dev/null
+++ b/lib/stackdepot.c
@@ -0,0 +1,284 @@
+/*
+ * Generic stack depot for storing stack traces.
+ *
+ * Some debugging tools need to save stack traces of certain events which can
+ * be later presented to the user. For example, KASAN needs to safe alloc and
+ * free stacks for each object, but storing two stack traces per object
+ * requires too much memory (e.g. SLUB_DEBUG needs 256 bytes per object for
+ * that).
+ *
+ * Instead, stack depot maintains a hashtable of unique stacktraces. Since alloc
+ * and free stacks repeat a lot, we save about 100x space.
+ * Stacks are never removed from depot, so we store them contiguously one after
+ * another in a contiguos memory allocation.
+ *
+ * Author: Alexander Potapenko <glider@google.com>
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * Based on code by Dmitry Chernenkov.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ */
+
+#include <linux/gfp.h>
+#include <linux/jhash.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/percpu.h>
+#include <linux/printk.h>
+#include <linux/slab.h>
+#include <linux/stacktrace.h>
+#include <linux/stackdepot.h>
+#include <linux/string.h>
+#include <linux/types.h>
+
+#define DEPOT_STACK_BITS (sizeof(depot_stack_handle_t) * 8)
+
+#define STACK_ALLOC_ORDER 2 /* 'Slab' size order for stack depot, 4 pages */
+#define STACK_ALLOC_SIZE (1LL << (PAGE_SHIFT + STACK_ALLOC_ORDER))
+#define STACK_ALLOC_ALIGN 4
+#define STACK_ALLOC_OFFSET_BITS (STACK_ALLOC_ORDER + PAGE_SHIFT - \
+                                        STACK_ALLOC_ALIGN)
+#define STACK_ALLOC_INDEX_BITS (DEPOT_STACK_BITS - STACK_ALLOC_OFFSET_BITS)
+#define STACK_ALLOC_SLABS_CAP 1024
+#define STACK_ALLOC_MAX_SLABS \
+        (((1LL << (STACK_ALLOC_INDEX_BITS)) < STACK_ALLOC_SLABS_CAP) ? \
+         (1LL << (STACK_ALLOC_INDEX_BITS)) : STACK_ALLOC_SLABS_CAP)
+
+/* The compact structure to store the reference to stacks. */
+union handle_parts {
+        depot_stack_handle_t handle;
+        struct {
+                u32 slabindex : STACK_ALLOC_INDEX_BITS;
+                u32 offset : STACK_ALLOC_OFFSET_BITS;
+        };
+};
+
+struct stack_record {
+        struct stack_record *next;      /* Link in the hashtable */
+        u32 hash;                       /* Hash in the hastable */
+        u32 size;                       /* Number of frames in the stack */
+        union handle_parts handle;
+        unsigned long entries[1];       /* Variable-sized array of entries. */
+};
+
+static void *stack_slabs[STACK_ALLOC_MAX_SLABS];
+
+static int depot_index;
+static int next_slab_inited;
+static size_t depot_offset;
+static DEFINE_SPINLOCK(depot_lock);
+
+static bool init_stack_slab(void **prealloc)
+{
+        if (!*prealloc)
+                return false;
+        /*
+         * This smp_load_acquire() pairs with smp_store_release() to
+         * |next_slab_inited| below and in depot_alloc_stack().
+         */
+        if (smp_load_acquire(&next_slab_inited))
+                return true;
+        if (stack_slabs[depot_index] == NULL) {
+                stack_slabs[depot_index] = *prealloc;
+        } else {
+                stack_slabs[depot_index + 1] = *prealloc;
+                /*
+                 * This smp_store_release pairs with smp_load_acquire() from
+                 * |next_slab_inited| above and in depot_save_stack().
+                 */
+                smp_store_release(&next_slab_inited, 1);
+        }
+        *prealloc = NULL;
+        return true;
+}
+
+/* Allocation of a new stack in raw storage */
+static struct stack_record *depot_alloc_stack(unsigned long *entries, int size,
+                u32 hash, void **prealloc, gfp_t alloc_flags)
+{
+        int required_size = offsetof(struct stack_record, entries) +
+                sizeof(unsigned long) * size;
+        struct stack_record *stack;
+
+        required_size = ALIGN(required_size, 1 << STACK_ALLOC_ALIGN);
+
+        if (unlikely(depot_offset + required_size > STACK_ALLOC_SIZE)) {
+                if (unlikely(depot_index + 1 >= STACK_ALLOC_MAX_SLABS)) {
+                        WARN_ONCE(1, "Stack depot reached limit capacity");
+                        return NULL;
+                }
+                depot_index++;
+                depot_offset = 0;
+                /*
+                 * smp_store_release() here pairs with smp_load_acquire() from
+                 * |next_slab_inited| in depot_save_stack() and
+                 * init_stack_slab().
+                 */
+                if (depot_index + 1 < STACK_ALLOC_MAX_SLABS)
+                        smp_store_release(&next_slab_inited, 0);
+        }
+        init_stack_slab(prealloc);
+        if (stack_slabs[depot_index] == NULL)
+                return NULL;
+
+        stack = stack_slabs[depot_index] + depot_offset;
+
+        stack->hash = hash;
+        stack->size = size;
+        stack->handle.slabindex = depot_index;
+        stack->handle.offset = depot_offset >> STACK_ALLOC_ALIGN;
+        memcpy(stack->entries, entries, size * sizeof(unsigned long));
+        depot_offset += required_size;
+
+        return stack;
+}
+
+#define STACK_HASH_ORDER 20
+#define STACK_HASH_SIZE (1L << STACK_HASH_ORDER)
+#define STACK_HASH_MASK (STACK_HASH_SIZE - 1)
+#define STACK_HASH_SEED 0x9747b28c
+
+static struct stack_record *stack_table[STACK_HASH_SIZE] = {
+        [0 ...  STACK_HASH_SIZE - 1] = NULL
+};
+
+/* Calculate hash for a stack */
+static inline u32 hash_stack(unsigned long *entries, unsigned int size)
+{
+        return jhash2((u32 *)entries,
+                               size * sizeof(unsigned long) / sizeof(u32),
+                               STACK_HASH_SEED);
+}
+
+/* Find a stack that is equal to the one stored in entries in the hash */
+static inline struct stack_record *find_stack(struct stack_record *bucket,
+                                             unsigned long *entries, int size,
+                                             u32 hash)
+{
+        struct stack_record *found;
+
+        for (found = bucket; found; found = found->next) {
+                if (found->hash == hash &&
+                    found->size == size &&
+                    !memcmp(entries, found->entries,
+                            size * sizeof(unsigned long))) {
+                        return found;
+                }
+        }
+        return NULL;
+}
+
+void depot_fetch_stack(depot_stack_handle_t handle, struct stack_trace *trace)
+{
+        union handle_parts parts = { .handle = handle };
+        void *slab = stack_slabs[parts.slabindex];
+        size_t offset = parts.offset << STACK_ALLOC_ALIGN;
+        struct stack_record *stack = slab + offset;
+
+        trace->nr_entries = trace->max_entries = stack->size;
+        trace->entries = stack->entries;
+        trace->skip = 0;
+}
+
+/**
+ * depot_save_stack - save stack in a stack depot.
+ * @trace - the stacktrace to save.
+ * @alloc_flags - flags for allocating additional memory if required.
+ *
+ * Returns the handle of the stack struct stored in depot.
+ */
+depot_stack_handle_t depot_save_stack(struct stack_trace *trace,
+                                    gfp_t alloc_flags)
+{
+        u32 hash;
+        depot_stack_handle_t retval = 0;
+        struct stack_record *found = NULL, **bucket;
+        unsigned long flags;
+        struct page *page = NULL;
+        void *prealloc = NULL;
+
+        if (unlikely(trace->nr_entries == 0))
+                goto fast_exit;
+
+        hash = hash_stack(trace->entries, trace->nr_entries);
+        /* Bad luck, we won't store this stack. */
+        if (hash == 0)
+                goto exit;
+
+        bucket = &stack_table[hash & STACK_HASH_MASK];
+
+        /*
+         * Fast path: look the stack trace up without locking.
+         * The smp_load_acquire() here pairs with smp_store_release() to
+         * |bucket| below.
+         */
+        found = find_stack(smp_load_acquire(bucket), trace->entries,
+                           trace->nr_entries, hash);
+        if (found)
+                goto exit;
+
+        /*
+         * Check if the current or the next stack slab need to be initialized.
+         * If so, allocate the memory - we won't be able to do that under the
+         * lock.
+         *
+         * The smp_load_acquire() here pairs with smp_store_release() to
+         * |next_slab_inited| in depot_alloc_stack() and init_stack_slab().
+         */
+        if (unlikely(!smp_load_acquire(&next_slab_inited))) {
+                /*
+                 * Zero out zone modifiers, as we don't have specific zone
+                 * requirements. Keep the flags related to allocation in atomic
+                 * contexts and I/O.
+                 */
+                alloc_flags &= ~GFP_ZONEMASK;
+                alloc_flags &= (GFP_ATOMIC | GFP_KERNEL);
+                page = alloc_pages(alloc_flags, STACK_ALLOC_ORDER);
+                if (page)
+                        prealloc = page_address(page);
+        }
+
+        spin_lock_irqsave(&depot_lock, flags);
+
+        found = find_stack(*bucket, trace->entries, trace->nr_entries, hash);
+        if (!found) {
+                struct stack_record *new =
+                        depot_alloc_stack(trace->entries, trace->nr_entries,
+                                          hash, &prealloc, alloc_flags);
+                if (new) {
+                        new->next = *bucket;
+                        /*
+                         * This smp_store_release() pairs with
+                         * smp_load_acquire() from |bucket| above.
+                         */
+                        smp_store_release(bucket, new);
+                        found = new;
+                }
+        } else if (prealloc) {
+                /*
+                 * We didn't need to store this stack trace, but let's keep
+                 * the preallocated memory for the future.
+                 */
+                WARN_ON(!init_stack_slab(&prealloc));
+        }
+
+        spin_unlock_irqrestore(&depot_lock, flags);
+exit:
+        if (prealloc) {
+                /* Nobody used this memory, ok to free it. */
+                free_pages((unsigned long)prealloc, STACK_ALLOC_ORDER);
+        }
+        if (found)
+                retval = found->handle.handle;
+fast_exit:
+        return retval;
+}
diff --git a/lib/test_kasan.c b/lib/test_kasan.c
index c32f3b0048dc..82169fbf2453 100644
--- a/lib/test_kasan.c
+++ b/lib/test_kasan.c
@@ -65,11 +65,34 @@ static noinline void __init kmalloc_node_oob_right(void)
         kfree(ptr);
 }
 
-static noinline void __init kmalloc_large_oob_right(void)
+#ifdef CONFIG_SLUB
+static noinline void __init kmalloc_pagealloc_oob_right(void)
 {
         char *ptr;
         size_t size = KMALLOC_MAX_CACHE_SIZE + 10;
 
+        /* Allocate a chunk that does not fit into a SLUB cache to trigger
+         * the page allocator fallback.
+         */
+        pr_info("kmalloc pagealloc allocation: out-of-bounds to right\n");
+        ptr = kmalloc(size, GFP_KERNEL);
+        if (!ptr) {
+                pr_err("Allocation failed\n");
+                return;
+        }
+
+        ptr[size] = 0;
+        kfree(ptr);
+}
+#endif
+
+static noinline void __init kmalloc_large_oob_right(void)
+{
+        char *ptr;
+        size_t size = KMALLOC_MAX_CACHE_SIZE - 256;
+        /* Allocate a chunk that is large enough, but still fits into a slab
+         * and does not trigger the page allocator fallback in SLUB.
+         */
         pr_info("kmalloc large allocation: out-of-bounds to right\n");
         ptr = kmalloc(size, GFP_KERNEL);
         if (!ptr) {
@@ -271,6 +294,8 @@ static noinline void __init kmalloc_uaf2(void)
         }
 
         ptr1[40] = 'x';
+        if (ptr1 == ptr2)
+                pr_err("Could not detect use-after-free: ptr1 == ptr2\n");
         kfree(ptr2);
 }
 
@@ -324,6 +349,9 @@ static int __init kmalloc_tests_init(void)
         kmalloc_oob_right();
         kmalloc_oob_left();
         kmalloc_node_oob_right();
+#ifdef CONFIG_SLUB
+        kmalloc_pagealloc_oob_right();
+#endif
         kmalloc_large_oob_right();
         kmalloc_oob_krealloc_more();
         kmalloc_oob_krealloc_less();