Merge branch 'akpm' (patches from Andrew Morton)

Merge first patch-bomb from Andrew Morton:
 "Quite a lot of other stuff is banked up awaiting further
  next->mainline merging, but this batch contains:

   - Lots of random misc patches
   - OCFS2
   - Most of MM
   - backlight updates
   - lib/ updates
   - printk updates
   - checkpatch updates
   - epoll tweaking
   - rtc updates
   - hfs
   - hfsplus
   - documentation
   - procfs
   - update gcov to gcc-4.7 format
   - IPC"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (269 commits)
  ipc, msg: fix message length check for negative values
  ipc/util.c: remove unnecessary work pending test
  devpts: plug the memory leak in kill_sb
  ./Makefile: export initial ramdisk compression config option
  init/Kconfig: add option to disable kernel compression
  drivers: w1: make w1_slave::flags long to avoid memory corruption
  drivers/w1/masters/ds1wm.cuse dev_get_platdata()
  drivers/memstick/core/ms_block.c: fix unreachable state in h_msb_read_page()
  drivers/memstick/core/mspro_block.c: fix attributes array allocation
  drivers/pps/clients/pps-gpio.c: remove redundant of_match_ptr
  kernel/panic.c: reduce 1 byte usage for print tainted buffer
  gcov: reuse kbasename helper
  kernel/gcov/fs.c: use pr_warn()
  kernel/module.c: use pr_foo()
  gcov: compile specific gcov implementation based on gcc version
  gcov: add support for gcc 4.7 gcov format
  gcov: move gcov structs definitions to a gcc version specific file
  kernel/taskstats.c: return -ENOMEM when alloc memory fails in add_del_listener()
  kernel/taskstats.c: add nla_nest_cancel() for failure processing between nla_nest_start() and nla_nest_end()
  kernel/sysctl_binary.c: use scnprintf() instead of snprintf()
  ...

8 files changed, 222 insertions, 33 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index ebef88f61b7d..db25707aa41b 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1481,6 +1481,15 @@ config INTERVAL_TREE_TEST
         help
           A benchmark measuring the performance of the interval tree library
 
+config PERCPU_TEST
+        tristate "Per cpu operations test"
+        depends on m && DEBUG_KERNEL
+        help
+          Enable this option to build test module which validates per-cpu
+          operations.
+
+          If unsure, say N.
+
 config ATOMIC64_SELFTEST
         bool "Perform an atomic64_t self-test at boot"
         help
diff --git a/lib/Makefile b/lib/Makefile
index f3bb2cb98adf..bb016e116ba4 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -157,6 +157,8 @@ obj-$(CONFIG_INTERVAL_TREE_TEST) += interval_tree_test.o
 
 interval_tree_test-objs := interval_tree_test_main.o interval_tree.o
 
+obj-$(CONFIG_PERCPU_TEST) += percpu_test.o
+
 obj-$(CONFIG_ASN1) += asn1_decoder.o
 
 obj-$(CONFIG_FONT_SUPPORT) += fonts/
diff --git a/lib/debugobjects.c b/lib/debugobjects.c
index bf2c8b1043d8..e0731c3db706 100644
--- a/lib/debugobjects.c
+++ b/lib/debugobjects.c
@@ -196,7 +196,7 @@ static void free_object(struct debug_obj *obj)
          * initialized:
          */
         if (obj_pool_free > ODEBUG_POOL_SIZE && obj_cache)
-                sched = keventd_up() && !work_pending(&debug_obj_work);
+                sched = keventd_up();
         hlist_add_head(&obj->node, &obj_pool);
         obj_pool_free++;
         obj_pool_used--;
diff --git a/lib/digsig.c b/lib/digsig.c
index 2f31e6a45f0a..8793aeda30ca 100644
--- a/lib/digsig.c
+++ b/lib/digsig.c
@@ -209,7 +209,7 @@ int digsig_verify(struct key *keyring, const char *sig, int siglen,
                 kref = keyring_search(make_key_ref(keyring, 1UL),
                                                 &key_type_user, name);
                 if (IS_ERR(kref))
-                        key = ERR_PTR(PTR_ERR(kref));
+                        key = ERR_CAST(kref);
                 else
                         key = key_ref_to_ptr(kref);
         } else {
diff --git a/lib/genalloc.c b/lib/genalloc.c
index 26cf20be72b7..dda31168844f 100644
--- a/lib/genalloc.c
+++ b/lib/genalloc.c
@@ -313,6 +313,34 @@ retry:
 EXPORT_SYMBOL(gen_pool_alloc);
 
 /**
+ * gen_pool_dma_alloc - allocate special memory from the pool for DMA usage
+ * @pool: pool to allocate from
+ * @size: number of bytes to allocate from the pool
+ * @dma: dma-view physical address
+ *
+ * Allocate the requested number of bytes from the specified pool.
+ * Uses the pool allocation function (with first-fit algorithm by default).
+ * Can not be used in NMI handler on architectures without
+ * NMI-safe cmpxchg implementation.
+ */
+void *gen_pool_dma_alloc(struct gen_pool *pool, size_t size, dma_addr_t *dma)
+{
+        unsigned long vaddr;
+
+        if (!pool)
+                return NULL;
+
+        vaddr = gen_pool_alloc(pool, size);
+        if (!vaddr)
+                return NULL;
+
+        *dma = gen_pool_virt_to_phys(pool, vaddr);
+
+        return (void *)vaddr;
+}
+EXPORT_SYMBOL(gen_pool_dma_alloc);
+
+/**
  * gen_pool_free - free allocated special memory back to the pool
  * @pool: pool to free to
  * @addr: starting address of memory to free back to pool
diff --git a/lib/percpu_test.c b/lib/percpu_test.c
new file mode 100644
index 000000000000..0b5d14dadd1a
--- /dev/null
+++ b/lib/percpu_test.c
@@ -0,0 +1,138 @@
+#include <linux/module.h>
+
+/* validate @native and @pcp counter values match @expected */
+#define CHECK(native, pcp, expected)                                    \
+        do {                                                            \
+                WARN((native) != (expected),                            \
+                     "raw %ld (0x%lx) != expected %lld (0x%llx)",       \
+                     (native), (native),                                \
+                     (long long)(expected), (long long)(expected));     \
+                WARN(__this_cpu_read(pcp) != (expected),                \
+                     "pcp %ld (0x%lx) != expected %lld (0x%llx)",       \
+                     __this_cpu_read(pcp), __this_cpu_read(pcp),        \
+                     (long long)(expected), (long long)(expected));     \
+        } while (0)
+
+static DEFINE_PER_CPU(long, long_counter);
+static DEFINE_PER_CPU(unsigned long, ulong_counter);
+
+static int __init percpu_test_init(void)
+{
+        /*
+         * volatile prevents compiler from optimizing it uses, otherwise the
+         * +ul_one/-ul_one below would replace with inc/dec instructions.
+         */
+        volatile unsigned int ui_one = 1;
+        long l = 0;
+        unsigned long ul = 0;
+
+        pr_info("percpu test start\n");
+
+        preempt_disable();
+
+        l += -1;
+        __this_cpu_add(long_counter, -1);
+        CHECK(l, long_counter, -1);
+
+        l += 1;
+        __this_cpu_add(long_counter, 1);
+        CHECK(l, long_counter, 0);
+
+        ul = 0;
+        __this_cpu_write(ulong_counter, 0);
+
+        ul += 1UL;
+        __this_cpu_add(ulong_counter, 1UL);
+        CHECK(ul, ulong_counter, 1);
+
+        ul += -1UL;
+        __this_cpu_add(ulong_counter, -1UL);
+        CHECK(ul, ulong_counter, 0);
+
+        ul += -(unsigned long)1;
+        __this_cpu_add(ulong_counter, -(unsigned long)1);
+        CHECK(ul, ulong_counter, -1);
+
+        ul = 0;
+        __this_cpu_write(ulong_counter, 0);
+
+        ul -= 1;
+        __this_cpu_dec(ulong_counter);
+        CHECK(ul, ulong_counter, -1);
+        CHECK(ul, ulong_counter, ULONG_MAX);
+
+        l += -ui_one;
+        __this_cpu_add(long_counter, -ui_one);
+        CHECK(l, long_counter, 0xffffffff);
+
+        l += ui_one;
+        __this_cpu_add(long_counter, ui_one);
+        CHECK(l, long_counter, (long)0x100000000LL);
+
+
+        l = 0;
+        __this_cpu_write(long_counter, 0);
+
+        l -= ui_one;
+        __this_cpu_sub(long_counter, ui_one);
+        CHECK(l, long_counter, -1);
+
+        l = 0;
+        __this_cpu_write(long_counter, 0);
+
+        l += ui_one;
+        __this_cpu_add(long_counter, ui_one);
+        CHECK(l, long_counter, 1);
+
+        l += -ui_one;
+        __this_cpu_add(long_counter, -ui_one);
+        CHECK(l, long_counter, (long)0x100000000LL);
+
+        l = 0;
+        __this_cpu_write(long_counter, 0);
+
+        l -= ui_one;
+        this_cpu_sub(long_counter, ui_one);
+        CHECK(l, long_counter, -1);
+        CHECK(l, long_counter, ULONG_MAX);
+
+        ul = 0;
+        __this_cpu_write(ulong_counter, 0);
+
+        ul += ui_one;
+        __this_cpu_add(ulong_counter, ui_one);
+        CHECK(ul, ulong_counter, 1);
+
+        ul = 0;
+        __this_cpu_write(ulong_counter, 0);
+
+        ul -= ui_one;
+        __this_cpu_sub(ulong_counter, ui_one);
+        CHECK(ul, ulong_counter, -1);
+        CHECK(ul, ulong_counter, ULONG_MAX);
+
+        ul = 3;
+        __this_cpu_write(ulong_counter, 3);
+
+        ul = this_cpu_sub_return(ulong_counter, ui_one);
+        CHECK(ul, ulong_counter, 2);
+
+        ul = __this_cpu_sub_return(ulong_counter, ui_one);
+        CHECK(ul, ulong_counter, 1);
+
+        preempt_enable();
+
+        pr_info("percpu test done\n");
+        return -EAGAIN;  /* Fail will directly unload the module */
+}
+
+static void __exit percpu_test_exit(void)
+{
+}
+
+module_init(percpu_test_init)
+module_exit(percpu_test_exit)
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Greg Thelen");
+MODULE_DESCRIPTION("percpu operations test");
diff --git a/lib/show_mem.c b/lib/show_mem.c
index b7c72311ad0c..5847a4921b8e 100644
--- a/lib/show_mem.c
+++ b/lib/show_mem.c
@@ -12,8 +12,7 @@
 void show_mem(unsigned int filter)
 {
         pg_data_t *pgdat;
-        unsigned long total = 0, reserved = 0, shared = 0,
-                nonshared = 0, highmem = 0;
+        unsigned long total = 0, reserved = 0, highmem = 0;
 
         printk("Mem-Info:\n");
         show_free_areas(filter);
@@ -22,43 +21,27 @@ void show_mem(unsigned int filter)
                 return;
 
         for_each_online_pgdat(pgdat) {
-                unsigned long i, flags;
+                unsigned long flags;
+                int zoneid;
 
                 pgdat_resize_lock(pgdat, &flags);
-                for (i = 0; i < pgdat->node_spanned_pages; i++) {
-                        struct page *page;
-                        unsigned long pfn = pgdat->node_start_pfn + i;
-
-                        if (unlikely(!(i % MAX_ORDER_NR_PAGES)))
-                                touch_nmi_watchdog();
-
-                        if (!pfn_valid(pfn))
+                for (zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
+                        struct zone *zone = &pgdat->node_zones[zoneid];
+                        if (!populated_zone(zone))
                                 continue;
 
-                        page = pfn_to_page(pfn);
-
-                        if (PageHighMem(page))
-                                highmem++;
+                        total += zone->present_pages;
+                        reserved = zone->present_pages - zone->managed_pages;
 
-                        if (PageReserved(page))
-                                reserved++;
-                        else if (page_count(page) == 1)
-                                nonshared++;
-                        else if (page_count(page) > 1)
-                                shared += page_count(page) - 1;
-
-                        total++;
+                        if (is_highmem_idx(zoneid))
+                                highmem += zone->present_pages;
                 }
                 pgdat_resize_unlock(pgdat, &flags);
         }
 
         printk("%lu pages RAM\n", total);
-#ifdef CONFIG_HIGHMEM
-        printk("%lu pages HighMem\n", highmem);
-#endif
+        printk("%lu pages HighMem/MovableOnly\n", highmem);
         printk("%lu pages reserved\n", reserved);
-        printk("%lu pages shared\n", shared);
-        printk("%lu pages non-shared\n", nonshared);
 #ifdef CONFIG_QUICKLIST
         printk("%lu pages in pagetable cache\n",
                 quicklist_total_size());
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 26559bdb4c49..48586ac3a62e 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -27,6 +27,7 @@
 #include <linux/uaccess.h>
 #include <linux/ioport.h>
 #include <linux/dcache.h>
+#include <linux/cred.h>
 #include <net/addrconf.h>
 
 #include <asm/page.h>           /* for PAGE_SIZE */
@@ -1218,6 +1219,8 @@ int kptr_restrict __read_mostly;
  *            The maximum supported length is 64 bytes of the input. Consider
  *            to use print_hex_dump() for the larger input.
  * - 'a' For a phys_addr_t type and its derivative types (passed by reference)
+ * - 'd[234]' For a dentry name (optionally 2-4 last components)
+ * - 'D[234]' Same as 'd' but for a struct file
  *
  * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
  * function pointers are really function descriptors, which contain a
@@ -1312,11 +1315,37 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,
                                 spec.field_width = default_width;
                         return string(buf, end, "pK-error", spec);
                 }
-                if (!((kptr_restrict == 0) ||
-                      (kptr_restrict == 1 &&
-                       has_capability_noaudit(current, CAP_SYSLOG))))
+
+                switch (kptr_restrict) {
+                case 0:
+                        /* Always print %pK values */
+                        break;
+                case 1: {
+                        /*
+                         * Only print the real pointer value if the current
+                         * process has CAP_SYSLOG and is running with the
+                         * same credentials it started with. This is because
+                         * access to files is checked at open() time, but %pK
+                         * checks permission at read() time. We don't want to
+                         * leak pointer values if a binary opens a file using
+                         * %pK and then elevates privileges before reading it.
+                         */
+                        const struct cred *cred = current_cred();
+
+                        if (!has_capability_noaudit(current, CAP_SYSLOG) ||
+                            !uid_eq(cred->euid, cred->uid) ||
+                            !gid_eq(cred->egid, cred->gid))
+                                ptr = NULL;
+                        break;
+                }
+                case 2:
+                default:
+                        /* Always print 0's for %pK */
                         ptr = NULL;
+                        break;
+                }
                 break;
+
         case 'N':
                 switch (fmt[1]) {
                 case 'F':