10 files changed, 315 insertions, 50 deletions

diff --git a/lib/Makefile b/lib/Makefile
index 9085ad6fa53d..3b1f94bbe9de 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -11,7 +11,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
          rbtree.o radix-tree.o dump_stack.o \
          idr.o int_sqrt.o extable.o prio_tree.o \
          sha1.o irq_regs.o reciprocal_div.o argv_split.o \
-         proportions.o prio_heap.o ratelimit.o
+         proportions.o prio_heap.o ratelimit.o show_mem.o
 
 lib-$(CONFIG_MMU) += ioremap.o
 lib-$(CONFIG_SMP) += cpumask.o
@@ -78,6 +78,8 @@ lib-$(CONFIG_GENERIC_BUG) += bug.o
 
 obj-$(CONFIG_HAVE_LMB) += lmb.o
 
+obj-$(CONFIG_HAVE_ARCH_TRACEHOOK) += syscall.o
+
 hostprogs-y     := gen_crc32table
 clean-files     := crc32table.h
 
diff --git a/lib/debugobjects.c b/lib/debugobjects.c
index f86196390cfd..45a6bde762d1 100644
--- a/lib/debugobjects.c
+++ b/lib/debugobjects.c
@@ -205,9 +205,8 @@ static void debug_print_object(struct debug_obj *obj, char *msg)
 
         if (limit < 5 && obj->descr != descr_test) {
                 limit++;
-                printk(KERN_ERR "ODEBUG: %s %s object type: %s\n", msg,
+                WARN(1, KERN_ERR "ODEBUG: %s %s object type: %s\n", msg,
                        obj_states[obj->state], obj->descr->name);
-                WARN_ON(1);
         }
         debug_objects_warnings++;
 }
@@ -733,26 +732,22 @@ check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
 
         obj = lookup_object(addr, db);
         if (!obj && state != ODEBUG_STATE_NONE) {
-                printk(KERN_ERR "ODEBUG: selftest object not found\n");
-                WARN_ON(1);
+                WARN(1, KERN_ERR "ODEBUG: selftest object not found\n");
                 goto out;
         }
         if (obj && obj->state != state) {
-                printk(KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
+                WARN(1, KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
                        obj->state, state);
-                WARN_ON(1);
                 goto out;
         }
         if (fixups != debug_objects_fixups) {
-                printk(KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
+                WARN(1, KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
                        fixups, debug_objects_fixups);
-                WARN_ON(1);
                 goto out;
         }
         if (warnings != debug_objects_warnings) {
-                printk(KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
+                WARN(1, KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
                        warnings, debug_objects_warnings);
-                WARN_ON(1);
                 goto out;
         }
         res = 0;
diff --git a/lib/idr.c b/lib/idr.c
index 3476f8203e97..e728c7fccc4d 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -607,7 +607,7 @@ void *idr_replace(struct idr *idp, void *ptr, int id)
 }
 EXPORT_SYMBOL(idr_replace);
 
-static void idr_cache_ctor(struct kmem_cache *idr_layer_cache, void *idr_layer)
+static void idr_cache_ctor(void *idr_layer)
 {
         memset(idr_layer, 0, sizeof(struct idr_layer));
 }
diff --git a/lib/iomap.c b/lib/iomap.c
index 37a3ea4cac9f..d32229385151 100644
--- a/lib/iomap.c
+++ b/lib/iomap.c
@@ -40,8 +40,7 @@ static void bad_io_access(unsigned long port, const char *access)
         static int count = 10;
         if (count) {
                 count--;
-                printk(KERN_ERR "Bad IO access at port %#lx (%s)\n", port, access);
-                WARN_ON(1);
+                WARN(1, KERN_ERR "Bad IO access at port %#lx (%s)\n", port, access);
         }
 }
 
diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c
index 9f8d599459d1..3f914725bda8 100644
--- a/lib/kobject_uevent.c
+++ b/lib/kobject_uevent.c
@@ -285,8 +285,7 @@ int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
         int len;
 
         if (env->envp_idx >= ARRAY_SIZE(env->envp)) {
-                printk(KERN_ERR "add_uevent_var: too many keys\n");
-                WARN_ON(1);
+                WARN(1, KERN_ERR "add_uevent_var: too many keys\n");
                 return -ENOMEM;
         }
 
@@ -297,8 +296,7 @@ int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
         va_end(args);
 
         if (len >= (sizeof(env->buf) - env->buflen)) {
-                printk(KERN_ERR "add_uevent_var: buffer size too small\n");
-                WARN_ON(1);
+                WARN(1, KERN_ERR "add_uevent_var: buffer size too small\n");
                 return -ENOMEM;
         }
 
diff --git a/lib/plist.c b/lib/plist.c
index 3074a02272f3..d6c64a824e1d 100644
--- a/lib/plist.c
+++ b/lib/plist.c
@@ -31,12 +31,13 @@
 static void plist_check_prev_next(struct list_head *t, struct list_head *p,
                                   struct list_head *n)
 {
-        if (n->prev != p || p->next != n) {
-                printk("top: %p, n: %p, p: %p\n", t, t->next, t->prev);
-                printk("prev: %p, n: %p, p: %p\n", p, p->next, p->prev);
-                printk("next: %p, n: %p, p: %p\n", n, n->next, n->prev);
-                WARN_ON(1);
-        }
+        WARN(n->prev != p || p->next != n,
+                        "top: %p, n: %p, p: %p\n"
+                        "prev: %p, n: %p, p: %p\n"
+                        "next: %p, n: %p, p: %p\n",
+                         t, t->next, t->prev,
+                        p, p->next, p->prev,
+                        n, n->next, n->prev);
 }
 
 static void plist_check_list(struct list_head *top)
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index 56ec21a7f73d..be86b32bc874 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -359,18 +359,17 @@ EXPORT_SYMBOL(radix_tree_insert);
  *      Returns:  the slot corresponding to the position @index in the
  *      radix tree @root. This is useful for update-if-exists operations.
  *
- *      This function cannot be called under rcu_read_lock, it must be
- *      excluded from writers, as must the returned slot for subsequent
- *      use by radix_tree_deref_slot() and radix_tree_replace slot.
- *      Caller must hold tree write locked across slot lookup and
- *      replace.
+ *      This function can be called under rcu_read_lock iff the slot is not
+ *      modified by radix_tree_replace_slot, otherwise it must be called
+ *      exclusive from other writers. Any dereference of the slot must be done
+ *      using radix_tree_deref_slot.
  */
 void **radix_tree_lookup_slot(struct radix_tree_root *root, unsigned long index)
 {
         unsigned int height, shift;
         struct radix_tree_node *node, **slot;
 
-        node = root->rnode;
+        node = rcu_dereference(root->rnode);
         if (node == NULL)
                 return NULL;
 
@@ -390,7 +389,7 @@ void **radix_tree_lookup_slot(struct radix_tree_root *root, unsigned long index)
         do {
                 slot = (struct radix_tree_node **)
                         (node->slots + ((index>>shift) & RADIX_TREE_MAP_MASK));
-                node = *slot;
+                node = rcu_dereference(*slot);
                 if (node == NULL)
                         return NULL;
 
@@ -667,7 +666,7 @@ unsigned long radix_tree_next_hole(struct radix_tree_root *root,
 EXPORT_SYMBOL(radix_tree_next_hole);
 
 static unsigned int
-__lookup(struct radix_tree_node *slot, void **results, unsigned long index,
+__lookup(struct radix_tree_node *slot, void ***results, unsigned long index,
         unsigned int max_items, unsigned long *next_index)
 {
         unsigned int nr_found = 0;
@@ -701,11 +700,9 @@ __lookup(struct radix_tree_node *slot, void **results, unsigned long index,
 
         /* Bottom level: grab some items */
         for (i = index & RADIX_TREE_MAP_MASK; i < RADIX_TREE_MAP_SIZE; i++) {
-                struct radix_tree_node *node;
                 index++;
-                node = slot->slots[i];
-                if (node) {
-                        results[nr_found++] = rcu_dereference(node);
+                if (slot->slots[i]) {
+                        results[nr_found++] = &(slot->slots[i]);
                         if (nr_found == max_items)
                                 goto out;
                 }
@@ -759,13 +756,22 @@ radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
 
         ret = 0;
         while (ret < max_items) {
-                unsigned int nr_found;
+                unsigned int nr_found, slots_found, i;
                 unsigned long next_index;       /* Index of next search */
 
                 if (cur_index > max_index)
                         break;
-                nr_found = __lookup(node, results + ret, cur_index,
+                slots_found = __lookup(node, (void ***)results + ret, cur_index,
                                         max_items - ret, &next_index);
+                nr_found = 0;
+                for (i = 0; i < slots_found; i++) {
+                        struct radix_tree_node *slot;
+                        slot = *(((void ***)results)[ret + i]);
+                        if (!slot)
+                                continue;
+                        results[ret + nr_found] = rcu_dereference(slot);
+                        nr_found++;
+                }
                 ret += nr_found;
                 if (next_index == 0)
                         break;
@@ -776,12 +782,71 @@ radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
 }
 EXPORT_SYMBOL(radix_tree_gang_lookup);
 
+/**
+ *      radix_tree_gang_lookup_slot - perform multiple slot lookup on radix tree
+ *      @root:          radix tree root
+ *      @results:       where the results of the lookup are placed
+ *      @first_index:   start the lookup from this key
+ *      @max_items:     place up to this many items at *results
+ *
+ *      Performs an index-ascending scan of the tree for present items.  Places
+ *      their slots at *@results and returns the number of items which were
+ *      placed at *@results.
+ *
+ *      The implementation is naive.
+ *
+ *      Like radix_tree_gang_lookup as far as RCU and locking goes. Slots must
+ *      be dereferenced with radix_tree_deref_slot, and if using only RCU
+ *      protection, radix_tree_deref_slot may fail requiring a retry.
+ */
+unsigned int
+radix_tree_gang_lookup_slot(struct radix_tree_root *root, void ***results,
+                        unsigned long first_index, unsigned int max_items)
+{
+        unsigned long max_index;
+        struct radix_tree_node *node;
+        unsigned long cur_index = first_index;
+        unsigned int ret;
+
+        node = rcu_dereference(root->rnode);
+        if (!node)
+                return 0;
+
+        if (!radix_tree_is_indirect_ptr(node)) {
+                if (first_index > 0)
+                        return 0;
+                results[0] = (void **)&root->rnode;
+                return 1;
+        }
+        node = radix_tree_indirect_to_ptr(node);
+
+        max_index = radix_tree_maxindex(node->height);
+
+        ret = 0;
+        while (ret < max_items) {
+                unsigned int slots_found;
+                unsigned long next_index;       /* Index of next search */
+
+                if (cur_index > max_index)
+                        break;
+                slots_found = __lookup(node, results + ret, cur_index,
+                                        max_items - ret, &next_index);
+                ret += slots_found;
+                if (next_index == 0)
+                        break;
+                cur_index = next_index;
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL(radix_tree_gang_lookup_slot);
+
 /*
  * FIXME: the two tag_get()s here should use find_next_bit() instead of
  * open-coding the search.
  */
 static unsigned int
-__lookup_tag(struct radix_tree_node *slot, void **results, unsigned long index,
+__lookup_tag(struct radix_tree_node *slot, void ***results, unsigned long index,
         unsigned int max_items, unsigned long *next_index, unsigned int tag)
 {
         unsigned int nr_found = 0;
@@ -811,11 +876,9 @@ __lookup_tag(struct radix_tree_node *slot, void **results, unsigned long index,
                         unsigned long j = index & RADIX_TREE_MAP_MASK;
 
                         for ( ; j < RADIX_TREE_MAP_SIZE; j++) {
-                                struct radix_tree_node *node;
                                 index++;
                                 if (!tag_get(slot, tag, j))
                                         continue;
-                                node = slot->slots[j];
                                 /*
                                  * Even though the tag was found set, we need to
                                  * recheck that we have a non-NULL node, because
@@ -826,9 +889,8 @@ __lookup_tag(struct radix_tree_node *slot, void **results, unsigned long index,
                                  * lookup ->slots[x] without a lock (ie. can't
                                  * rely on its value remaining the same).
                                  */
-                                if (node) {
-                                        node = rcu_dereference(node);
-                                        results[nr_found++] = node;
+                                if (slot->slots[j]) {
+                                        results[nr_found++] = &(slot->slots[j]);
                                         if (nr_found == max_items)
                                                 goto out;
                                 }
@@ -887,13 +949,22 @@ radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
 
         ret = 0;
         while (ret < max_items) {
-                unsigned int nr_found;
+                unsigned int nr_found, slots_found, i;
                 unsigned long next_index;       /* Index of next search */
 
                 if (cur_index > max_index)
                         break;
-                nr_found = __lookup_tag(node, results + ret, cur_index,
-                                        max_items - ret, &next_index, tag);
+                slots_found = __lookup_tag(node, (void ***)results + ret,
+                                cur_index, max_items - ret, &next_index, tag);
+                nr_found = 0;
+                for (i = 0; i < slots_found; i++) {
+                        struct radix_tree_node *slot;
+                        slot = *(((void ***)results)[ret + i]);
+                        if (!slot)
+                                continue;
+                        results[ret + nr_found] = rcu_dereference(slot);
+                        nr_found++;
+                }
                 ret += nr_found;
                 if (next_index == 0)
                         break;
@@ -905,6 +976,67 @@ radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
 EXPORT_SYMBOL(radix_tree_gang_lookup_tag);
 
 /**
+ *      radix_tree_gang_lookup_tag_slot - perform multiple slot lookup on a
+ *                                        radix tree based on a tag
+ *      @root:          radix tree root
+ *      @results:       where the results of the lookup are placed
+ *      @first_index:   start the lookup from this key
+ *      @max_items:     place up to this many items at *results
+ *      @tag:           the tag index (< RADIX_TREE_MAX_TAGS)
+ *
+ *      Performs an index-ascending scan of the tree for present items which
+ *      have the tag indexed by @tag set.  Places the slots at *@results and
+ *      returns the number of slots which were placed at *@results.
+ */
+unsigned int
+radix_tree_gang_lookup_tag_slot(struct radix_tree_root *root, void ***results,
+                unsigned long first_index, unsigned int max_items,
+                unsigned int tag)
+{
+        struct radix_tree_node *node;
+        unsigned long max_index;
+        unsigned long cur_index = first_index;
+        unsigned int ret;
+
+        /* check the root's tag bit */
+        if (!root_tag_get(root, tag))
+                return 0;
+
+        node = rcu_dereference(root->rnode);
+        if (!node)
+                return 0;
+
+        if (!radix_tree_is_indirect_ptr(node)) {
+                if (first_index > 0)
+                        return 0;
+                results[0] = (void **)&root->rnode;
+                return 1;
+        }
+        node = radix_tree_indirect_to_ptr(node);
+
+        max_index = radix_tree_maxindex(node->height);
+
+        ret = 0;
+        while (ret < max_items) {
+                unsigned int slots_found;
+                unsigned long next_index;       /* Index of next search */
+
+                if (cur_index > max_index)
+                        break;
+                slots_found = __lookup_tag(node, results + ret,
+                                cur_index, max_items - ret, &next_index, tag);
+                ret += slots_found;
+                if (next_index == 0)
+                        break;
+                cur_index = next_index;
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL(radix_tree_gang_lookup_tag_slot);
+
+
+/**
  *      radix_tree_shrink    -    shrink height of a radix tree to minimal
  *      @root           radix tree root
  */
@@ -1051,7 +1183,7 @@ int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag)
 EXPORT_SYMBOL(radix_tree_tagged);
 
 static void
-radix_tree_node_ctor(struct kmem_cache *cachep, void *node)
+radix_tree_node_ctor(void *node)
 {
         memset(node, 0, sizeof(struct radix_tree_node));
 }
diff --git a/lib/show_mem.c b/lib/show_mem.c
new file mode 100644
index 000000000000..238e72a18ce1
--- /dev/null
+++ b/lib/show_mem.c
@@ -0,0 +1,63 @@
+/*
+ * Generic show_mem() implementation
+ *
+ * Copyright (C) 2008 Johannes Weiner <hannes@saeurebad.de>
+ * All code subject to the GPL version 2.
+ */
+
+#include <linux/mm.h>
+#include <linux/nmi.h>
+#include <linux/quicklist.h>
+
+void show_mem(void)
+{
+        pg_data_t *pgdat;
+        unsigned long total = 0, reserved = 0, shared = 0,
+                nonshared = 0, highmem = 0;
+
+        printk(KERN_INFO "Mem-Info:\n");
+        show_free_areas();
+
+        for_each_online_pgdat(pgdat) {
+                unsigned long i, flags;
+
+                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))
+                                continue;
+
+                        page = pfn_to_page(pfn);
+
+                        if (PageHighMem(page))
+                                highmem++;
+
+                        if (PageReserved(page))
+                                reserved++;
+                        else if (page_count(page) == 1)
+                                nonshared++;
+                        else if (page_count(page) > 1)
+                                shared += page_count(page) - 1;
+
+                        total++;
+                }
+                pgdat_resize_unlock(pgdat, &flags);
+        }
+
+        printk(KERN_INFO "%lu pages RAM\n", total);
+#ifdef CONFIG_HIGHMEM
+        printk(KERN_INFO "%lu pages HighMem\n", highmem);
+#endif
+        printk(KERN_INFO "%lu pages reserved\n", reserved);
+        printk(KERN_INFO "%lu pages shared\n", shared);
+        printk(KERN_INFO "%lu pages non-shared\n", nonshared);
+#ifdef CONFIG_QUICKLIST
+        printk(KERN_INFO "%lu pages in pagetable cache\n",
+                quicklist_total_size());
+#endif
+}
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index d568894df8cc..977edbdbc1de 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -492,7 +492,7 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                  */
                 dma_addr_t handle;
                 handle = swiotlb_map_single(NULL, NULL, size, DMA_FROM_DEVICE);
-                if (swiotlb_dma_mapping_error(handle))
+                if (swiotlb_dma_mapping_error(hwdev, handle))
                         return NULL;
 
                 ret = bus_to_virt(handle);
@@ -824,7 +824,7 @@ swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
 }
 
 int
-swiotlb_dma_mapping_error(dma_addr_t dma_addr)
+swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr)
 {
         return (dma_addr == virt_to_bus(io_tlb_overflow_buffer));
 }
diff --git a/lib/syscall.c b/lib/syscall.c
new file mode 100644
index 000000000000..a4f7067f72fa
--- /dev/null
+++ b/lib/syscall.c
@@ -0,0 +1,75 @@
+#include <linux/ptrace.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <asm/syscall.h>
+
+static int collect_syscall(struct task_struct *target, long *callno,
+                           unsigned long args[6], unsigned int maxargs,
+                           unsigned long *sp, unsigned long *pc)
+{
+        struct pt_regs *regs = task_pt_regs(target);
+        if (unlikely(!regs))
+                return -EAGAIN;
+
+        *sp = user_stack_pointer(regs);
+        *pc = instruction_pointer(regs);
+
+        *callno = syscall_get_nr(target, regs);
+        if (*callno != -1L && maxargs > 0)
+                syscall_get_arguments(target, regs, 0, maxargs, args);
+
+        return 0;
+}
+
+/**
+ * task_current_syscall - Discover what a blocked task is doing.
+ * @target:             thread to examine
+ * @callno:             filled with system call number or -1
+ * @args:               filled with @maxargs system call arguments
+ * @maxargs:            number of elements in @args to fill
+ * @sp:                 filled with user stack pointer
+ * @pc:                 filled with user PC
+ *
+ * If @target is blocked in a system call, returns zero with *@callno
+ * set to the the call's number and @args filled in with its arguments.
+ * Registers not used for system call arguments may not be available and
+ * it is not kosher to use &struct user_regset calls while the system
+ * call is still in progress.  Note we may get this result if @target
+ * has finished its system call but not yet returned to user mode, such
+ * as when it's stopped for signal handling or syscall exit tracing.
+ *
+ * If @target is blocked in the kernel during a fault or exception,
+ * returns zero with *@callno set to -1 and does not fill in @args.
+ * If so, it's now safe to examine @target using &struct user_regset
+ * get() calls as long as we're sure @target won't return to user mode.
+ *
+ * Returns -%EAGAIN if @target does not remain blocked.
+ *
+ * Returns -%EINVAL if @maxargs is too large (maximum is six).
+ */
+int task_current_syscall(struct task_struct *target, long *callno,
+                         unsigned long args[6], unsigned int maxargs,
+                         unsigned long *sp, unsigned long *pc)
+{
+        long state;
+        unsigned long ncsw;
+
+        if (unlikely(maxargs > 6))
+                return -EINVAL;
+
+        if (target == current)
+                return collect_syscall(target, callno, args, maxargs, sp, pc);
+
+        state = target->state;
+        if (unlikely(!state))
+                return -EAGAIN;
+
+        ncsw = wait_task_inactive(target, state);
+        if (unlikely(!ncsw) ||
+            unlikely(collect_syscall(target, callno, args, maxargs, sp, pc)) ||
+            unlikely(wait_task_inactive(target, state) != ncsw))
+                return -EAGAIN;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(task_current_syscall);