9 files changed, 430 insertions, 117 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index c6e854f215fa..6cdcf38f2da9 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -440,7 +440,7 @@ config LOCKDEP
         bool
         depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
         select STACKTRACE
-        select FRAME_POINTER if !X86 && !MIPS && !PPC && !ARM_UNWIND
+        select FRAME_POINTER if !X86 && !MIPS && !PPC && !ARM_UNWIND && !S390
         select KALLSYMS
         select KALLSYMS_ALL
 
@@ -620,7 +620,7 @@ config ARCH_WANT_FRAME_POINTERS
 config FRAME_POINTER
         bool "Compile the kernel with frame pointers"
         depends on DEBUG_KERNEL && \
-                (CRIS || M68K || M68KNOMMU || FRV || UML || S390 || \
+                (CRIS || M68K || M68KNOMMU || FRV || UML || \
                  AVR32 || SUPERH || BLACKFIN || MN10300) || \
                 ARCH_WANT_FRAME_POINTERS
         default y if (DEBUG_INFO && UML) || ARCH_WANT_FRAME_POINTERS
@@ -809,13 +809,13 @@ config FAULT_INJECTION_STACKTRACE_FILTER
         depends on FAULT_INJECTION_DEBUG_FS && STACKTRACE_SUPPORT
         depends on !X86_64
         select STACKTRACE
-        select FRAME_POINTER if !PPC
+        select FRAME_POINTER if !PPC && !S390
         help
           Provide stacktrace filter for fault-injection capabilities
 
 config LATENCYTOP
         bool "Latency measuring infrastructure"
-        select FRAME_POINTER if !MIPS && !PPC
+        select FRAME_POINTER if !MIPS && !PPC && !S390
         select KALLSYMS
         select KALLSYMS_ALL
         select STACKTRACE
@@ -891,7 +891,6 @@ config DYNAMIC_DEBUG
         default n
         depends on PRINTK
         depends on DEBUG_FS
-        select PRINTK_DEBUG
         help
 
           Compiles debug level messages into the kernel, which would not
diff --git a/lib/Makefile b/lib/Makefile
index d6edd6753f40..33a40e40e3ee 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -38,7 +38,7 @@ lib-$(CONFIG_RWSEM_GENERIC_SPINLOCK) += rwsem-spinlock.o
 lib-$(CONFIG_RWSEM_XCHGADD_ALGORITHM) += rwsem.o
 lib-$(CONFIG_GENERIC_FIND_FIRST_BIT) += find_next_bit.o
 lib-$(CONFIG_GENERIC_FIND_NEXT_BIT) += find_next_bit.o
-lib-$(CONFIG_GENERIC_FIND_LAST_BIT) += find_last_bit.o
+obj-$(CONFIG_GENERIC_FIND_LAST_BIT) += find_last_bit.o
 obj-$(CONFIG_GENERIC_HWEIGHT) += hweight.o
 obj-$(CONFIG_LOCK_KERNEL) += kernel_lock.o
 obj-$(CONFIG_DEBUG_PREEMPT) += smp_processor_id.o
diff --git a/lib/cpumask.c b/lib/cpumask.c
index 1f71b97de0f9..eb23aaa0c7b8 100644
--- a/lib/cpumask.c
+++ b/lib/cpumask.c
@@ -119,6 +119,12 @@ bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node)
 }
 EXPORT_SYMBOL(alloc_cpumask_var_node);
 
+bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node)
+{
+        return alloc_cpumask_var_node(mask, flags | __GFP_ZERO, node);
+}
+EXPORT_SYMBOL(zalloc_cpumask_var_node);
+
 /**
  * alloc_cpumask_var - allocate a struct cpumask
  * @mask: pointer to cpumask_var_t where the cpumask is returned
@@ -135,6 +141,12 @@ bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
 }
 EXPORT_SYMBOL(alloc_cpumask_var);
 
+bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
+{
+        return alloc_cpumask_var(mask, flags | __GFP_ZERO);
+}
+EXPORT_SYMBOL(zalloc_cpumask_var);
+
 /**
  * alloc_bootmem_cpumask_var - allocate a struct cpumask from the bootmem arena.
  * @mask: pointer to cpumask_var_t where the cpumask is returned
diff --git a/lib/debug_locks.c b/lib/debug_locks.c
index 0218b4693dd8..bc3b11731b9c 100644
--- a/lib/debug_locks.c
+++ b/lib/debug_locks.c
@@ -36,7 +36,7 @@ int debug_locks_silent;
  */
 int debug_locks_off(void)
 {
-        if (xchg(&debug_locks, 0)) {
+        if (__debug_locks_off()) {
                 if (!debug_locks_silent) {
                         oops_in_progress = 1;
                         console_verbose();
diff --git a/lib/dma-debug.c b/lib/dma-debug.c
index d3da7edc034f..ad65fc0317d9 100644
--- a/lib/dma-debug.c
+++ b/lib/dma-debug.c
@@ -23,9 +23,11 @@
 #include <linux/dma-debug.h>
 #include <linux/spinlock.h>
 #include <linux/debugfs.h>
+#include <linux/uaccess.h>
 #include <linux/device.h>
 #include <linux/types.h>
 #include <linux/sched.h>
+#include <linux/ctype.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 
@@ -85,6 +87,7 @@ static u32 show_num_errors = 1;
 
 static u32 num_free_entries;
 static u32 min_free_entries;
+static u32 nr_total_entries;
 
 /* number of preallocated entries requested by kernel cmdline */
 static u32 req_entries;
@@ -97,6 +100,16 @@ static struct dentry *show_all_errors_dent  __read_mostly;
 static struct dentry *show_num_errors_dent  __read_mostly;
 static struct dentry *num_free_entries_dent __read_mostly;
 static struct dentry *min_free_entries_dent __read_mostly;
+static struct dentry *filter_dent           __read_mostly;
+
+/* per-driver filter related state */
+
+#define NAME_MAX_LEN    64
+
+static char                  current_driver_name[NAME_MAX_LEN] __read_mostly;
+static struct device_driver *current_driver                    __read_mostly;
+
+static DEFINE_RWLOCK(driver_name_lock);
 
 static const char *type2name[4] = { "single", "page",
                                     "scather-gather", "coherent" };
@@ -104,6 +117,11 @@ static const char *type2name[4] = { "single", "page",
 static const char *dir2name[4] = { "DMA_BIDIRECTIONAL", "DMA_TO_DEVICE",
                                    "DMA_FROM_DEVICE", "DMA_NONE" };
 
+/* little merge helper - remove it after the merge window */
+#ifndef BUS_NOTIFY_UNBOUND_DRIVER
+#define BUS_NOTIFY_UNBOUND_DRIVER 0x0005
+#endif
+
 /*
  * The access to some variables in this macro is racy. We can't use atomic_t
  * here because all these variables are exported to debugfs. Some of them even
@@ -121,15 +139,54 @@ static inline void dump_entry_trace(struct dma_debug_entry *entry)
 {
 #ifdef CONFIG_STACKTRACE
         if (entry) {
-                printk(KERN_WARNING "Mapped at:\n");
+                pr_warning("Mapped at:\n");
                 print_stack_trace(&entry->stacktrace, 0);
         }
 #endif
 }
 
+static bool driver_filter(struct device *dev)
+{
+        struct device_driver *drv;
+        unsigned long flags;
+        bool ret;
+
+        /* driver filter off */
+        if (likely(!current_driver_name[0]))
+                return true;
+
+        /* driver filter on and initialized */
+        if (current_driver && dev->driver == current_driver)
+                return true;
+
+        if (current_driver || !current_driver_name[0])
+                return false;
+
+        /* driver filter on but not yet initialized */
+        drv = get_driver(dev->driver);
+        if (!drv)
+                return false;
+
+        /* lock to protect against change of current_driver_name */
+        read_lock_irqsave(&driver_name_lock, flags);
+
+        ret = false;
+        if (drv->name &&
+            strncmp(current_driver_name, drv->name, NAME_MAX_LEN - 1) == 0) {
+                current_driver = drv;
+                ret = true;
+        }
+
+        read_unlock_irqrestore(&driver_name_lock, flags);
+        put_driver(drv);
+
+        return ret;
+}
+
 #define err_printk(dev, entry, format, arg...) do {             \
                 error_count += 1;                               \
-                if (show_all_errors || show_num_errors > 0) {   \
+                if (driver_filter(dev) &&                       \
+                    (show_all_errors || show_num_errors > 0)) { \
                         WARN(1, "%s %s: " format,               \
                              dev_driver_string(dev),            \
                              dev_name(dev) , ## arg);           \
@@ -185,15 +242,50 @@ static void put_hash_bucket(struct hash_bucket *bucket,
 static struct dma_debug_entry *hash_bucket_find(struct hash_bucket *bucket,
                                                 struct dma_debug_entry *ref)
 {
-        struct dma_debug_entry *entry;
+        struct dma_debug_entry *entry, *ret = NULL;
+        int matches = 0, match_lvl, last_lvl = 0;
 
         list_for_each_entry(entry, &bucket->list, list) {
-                if ((entry->dev_addr == ref->dev_addr) &&
-                    (entry->dev == ref->dev))
+                if ((entry->dev_addr != ref->dev_addr) ||
+                    (entry->dev != ref->dev))
+                        continue;
+
+                /*
+                 * Some drivers map the same physical address multiple
+                 * times. Without a hardware IOMMU this results in the
+                 * same device addresses being put into the dma-debug
+                 * hash multiple times too. This can result in false
+                 * positives being reported. Therfore we implement a
+                 * best-fit algorithm here which returns the entry from
+                 * the hash which fits best to the reference value
+                 * instead of the first-fit.
+                 */
+                matches += 1;
+                match_lvl = 0;
+                entry->size      == ref->size      ? ++match_lvl : match_lvl;
+                entry->type      == ref->type      ? ++match_lvl : match_lvl;
+                entry->direction == ref->direction ? ++match_lvl : match_lvl;
+
+                if (match_lvl == 3) {
+                        /* perfect-fit - return the result */
                         return entry;
+                } else if (match_lvl > last_lvl) {
+                        /*
+                         * We found an entry that fits better then the
+                         * previous one
+                         */
+                        last_lvl = match_lvl;
+                        ret      = entry;
+                }
         }
 
-        return NULL;
+        /*
+         * If we have multiple matches but no perfect-fit, just return
+         * NULL.
+         */
+        ret = (matches == 1) ? ret : NULL;
+
+        return ret;
 }
 
 /*
@@ -257,6 +349,21 @@ static void add_dma_entry(struct dma_debug_entry *entry)
         put_hash_bucket(bucket, &flags);
 }
 
+static struct dma_debug_entry *__dma_entry_alloc(void)
+{
+        struct dma_debug_entry *entry;
+
+        entry = list_entry(free_entries.next, struct dma_debug_entry, list);
+        list_del(&entry->list);
+        memset(entry, 0, sizeof(*entry));
+
+        num_free_entries -= 1;
+        if (num_free_entries < min_free_entries)
+                min_free_entries = num_free_entries;
+
+        return entry;
+}
+
 /* struct dma_entry allocator
  *
  * The next two functions implement the allocator for
@@ -270,15 +377,12 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         spin_lock_irqsave(&free_entries_lock, flags);
 
         if (list_empty(&free_entries)) {
-                printk(KERN_ERR "DMA-API: debugging out of memory "
-                                "- disabling\n");
+                pr_err("DMA-API: debugging out of memory - disabling\n");
                 global_disable = true;
                 goto out;
         }
 
-        entry = list_entry(free_entries.next, struct dma_debug_entry, list);
-        list_del(&entry->list);
-        memset(entry, 0, sizeof(*entry));
+        entry = __dma_entry_alloc();
 
 #ifdef CONFIG_STACKTRACE
         entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES;
@@ -286,9 +390,6 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         entry->stacktrace.skip = 2;
         save_stack_trace(&entry->stacktrace);
 #endif
-        num_free_entries -= 1;
-        if (num_free_entries < min_free_entries)
-                min_free_entries = num_free_entries;
 
 out:
         spin_unlock_irqrestore(&free_entries_lock, flags);
@@ -310,6 +411,53 @@ static void dma_entry_free(struct dma_debug_entry *entry)
         spin_unlock_irqrestore(&free_entries_lock, flags);
 }
 
+int dma_debug_resize_entries(u32 num_entries)
+{
+        int i, delta, ret = 0;
+        unsigned long flags;
+        struct dma_debug_entry *entry;
+        LIST_HEAD(tmp);
+
+        spin_lock_irqsave(&free_entries_lock, flags);
+
+        if (nr_total_entries < num_entries) {
+                delta = num_entries - nr_total_entries;
+
+                spin_unlock_irqrestore(&free_entries_lock, flags);
+
+                for (i = 0; i < delta; i++) {
+                        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
+                        if (!entry)
+                                break;
+
+                        list_add_tail(&entry->list, &tmp);
+                }
+
+                spin_lock_irqsave(&free_entries_lock, flags);
+
+                list_splice(&tmp, &free_entries);
+                nr_total_entries += i;
+                num_free_entries += i;
+        } else {
+                delta = nr_total_entries - num_entries;
+
+                for (i = 0; i < delta && !list_empty(&free_entries); i++) {
+                        entry = __dma_entry_alloc();
+                        kfree(entry);
+                }
+
+                nr_total_entries -= i;
+        }
+
+        if (nr_total_entries != num_entries)
+                ret = 1;
+
+        spin_unlock_irqrestore(&free_entries_lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL(dma_debug_resize_entries);
+
 /*
  * DMA-API debugging init code
  *
@@ -334,8 +482,7 @@ static int prealloc_memory(u32 num_entries)
         num_free_entries = num_entries;
         min_free_entries = num_entries;
 
-        printk(KERN_INFO "DMA-API: preallocated %d debug entries\n",
-                        num_entries);
+        pr_info("DMA-API: preallocated %d debug entries\n", num_entries);
 
         return 0;
 
@@ -349,11 +496,102 @@ out_err:
         return -ENOMEM;
 }
 
+static ssize_t filter_read(struct file *file, char __user *user_buf,
+                           size_t count, loff_t *ppos)
+{
+        char buf[NAME_MAX_LEN + 1];
+        unsigned long flags;
+        int len;
+
+        if (!current_driver_name[0])
+                return 0;
+
+        /*
+         * We can't copy to userspace directly because current_driver_name can
+         * only be read under the driver_name_lock with irqs disabled. So
+         * create a temporary copy first.
+         */
+        read_lock_irqsave(&driver_name_lock, flags);
+        len = scnprintf(buf, NAME_MAX_LEN + 1, "%s\n", current_driver_name);
+        read_unlock_irqrestore(&driver_name_lock, flags);
+
+        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t filter_write(struct file *file, const char __user *userbuf,
+                            size_t count, loff_t *ppos)
+{
+        char buf[NAME_MAX_LEN];
+        unsigned long flags;
+        size_t len;
+        int i;
+
+        /*
+         * We can't copy from userspace directly. Access to
+         * current_driver_name is protected with a write_lock with irqs
+         * disabled. Since copy_from_user can fault and may sleep we
+         * need to copy to temporary buffer first
+         */
+        len = min(count, (size_t)(NAME_MAX_LEN - 1));
+        if (copy_from_user(buf, userbuf, len))
+                return -EFAULT;
+
+        buf[len] = 0;
+
+        write_lock_irqsave(&driver_name_lock, flags);
+
+        /*
+         * Now handle the string we got from userspace very carefully.
+         * The rules are:
+         *         - only use the first token we got
+         *         - token delimiter is everything looking like a space
+         *           character (' ', '\n', '\t' ...)
+         *
+         */
+        if (!isalnum(buf[0])) {
+                /*
+                 * If the first character userspace gave us is not
+                 * alphanumerical then assume the filter should be
+                 * switched off.
+                 */
+                if (current_driver_name[0])
+                        pr_info("DMA-API: switching off dma-debug driver filter\n");
+                current_driver_name[0] = 0;
+                current_driver = NULL;
+                goto out_unlock;
+        }
+
+        /*
+         * Now parse out the first token and use it as the name for the
+         * driver to filter for.
+         */
+        for (i = 0; i < NAME_MAX_LEN; ++i) {
+                current_driver_name[i] = buf[i];
+                if (isspace(buf[i]) || buf[i] == ' ' || buf[i] == 0)
+                        break;
+        }
+        current_driver_name[i] = 0;
+        current_driver = NULL;
+
+        pr_info("DMA-API: enable driver filter for driver [%s]\n",
+                current_driver_name);
+
+out_unlock:
+        write_unlock_irqrestore(&driver_name_lock, flags);
+
+        return count;
+}
+
+const struct file_operations filter_fops = {
+        .read  = filter_read,
+        .write = filter_write,
+};
+
 static int dma_debug_fs_init(void)
 {
         dma_debug_dent = debugfs_create_dir("dma-api", NULL);
         if (!dma_debug_dent) {
-                printk(KERN_ERR "DMA-API: can not create debugfs directory\n");
+                pr_err("DMA-API: can not create debugfs directory\n");
                 return -ENOMEM;
         }
 
@@ -392,6 +630,11 @@ static int dma_debug_fs_init(void)
         if (!min_free_entries_dent)
                 goto out_err;
 
+        filter_dent = debugfs_create_file("driver_filter", 0644,
+                                          dma_debug_dent, NULL, &filter_fops);
+        if (!filter_dent)
+                goto out_err;
+
         return 0;
 
 out_err:
@@ -406,15 +649,19 @@ static int device_dma_allocations(struct device *dev)
         unsigned long flags;
         int count = 0, i;
 
+        local_irq_save(flags);
+
         for (i = 0; i < HASH_SIZE; ++i) {
-                spin_lock_irqsave(&dma_entry_hash[i].lock, flags);
+                spin_lock(&dma_entry_hash[i].lock);
                 list_for_each_entry(entry, &dma_entry_hash[i].list, list) {
                         if (entry->dev == dev)
                                 count += 1;
                 }
-                spin_unlock_irqrestore(&dma_entry_hash[i].lock, flags);
+                spin_unlock(&dma_entry_hash[i].lock);
         }
 
+        local_irq_restore(flags);
+
         return count;
 }
 
@@ -426,7 +673,7 @@ static int dma_debug_device_change(struct notifier_block *nb,
 
 
         switch (action) {
-        case BUS_NOTIFY_UNBIND_DRIVER:
+        case BUS_NOTIFY_UNBOUND_DRIVER:
                 count = device_dma_allocations(dev);
                 if (count == 0)
                         break;
@@ -447,7 +694,7 @@ void dma_debug_add_bus(struct bus_type *bus)
 
         nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
         if (nb == NULL) {
-                printk(KERN_ERR "dma_debug_add_bus: out of memory\n");
+                pr_err("dma_debug_add_bus: out of memory\n");
                 return;
         }
 
@@ -472,8 +719,7 @@ void dma_debug_init(u32 num_entries)
         }
 
         if (dma_debug_fs_init() != 0) {
-                printk(KERN_ERR "DMA-API: error creating debugfs entries "
-                                "- disabling\n");
+                pr_err("DMA-API: error creating debugfs entries - disabling\n");
                 global_disable = true;
 
                 return;
@@ -483,14 +729,15 @@ void dma_debug_init(u32 num_entries)
                 num_entries = req_entries;
 
         if (prealloc_memory(num_entries) != 0) {
-                printk(KERN_ERR "DMA-API: debugging out of memory error "
-                                "- disabled\n");
+                pr_err("DMA-API: debugging out of memory error - disabled\n");
                 global_disable = true;
 
                 return;
         }
 
-        printk(KERN_INFO "DMA-API: debugging enabled by kernel config\n");
+        nr_total_entries = num_free_entries;
+
+        pr_info("DMA-API: debugging enabled by kernel config\n");
 }
 
 static __init int dma_debug_cmdline(char *str)
@@ -499,8 +746,7 @@ static __init int dma_debug_cmdline(char *str)
                 return -EINVAL;
 
         if (strncmp(str, "off", 3) == 0) {
-                printk(KERN_INFO "DMA-API: debugging disabled on kernel "
-                                 "command line\n");
+                pr_info("DMA-API: debugging disabled on kernel command line\n");
                 global_disable = true;
         }
 
@@ -774,15 +1020,15 @@ void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
                 entry->type           = dma_debug_sg;
                 entry->dev            = dev;
                 entry->paddr          = sg_phys(s);
-                entry->size           = s->length;
-                entry->dev_addr       = s->dma_address;
+                entry->size           = sg_dma_len(s);
+                entry->dev_addr       = sg_dma_address(s);
                 entry->direction      = direction;
                 entry->sg_call_ents   = nents;
                 entry->sg_mapped_ents = mapped_ents;
 
                 if (!PageHighMem(sg_page(s))) {
                         check_for_stack(dev, sg_virt(s));
-                        check_for_illegal_area(dev, sg_virt(s), s->length);
+                        check_for_illegal_area(dev, sg_virt(s), sg_dma_len(s));
                 }
 
                 add_dma_entry(entry);
@@ -790,13 +1036,33 @@ void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
 }
 EXPORT_SYMBOL(debug_dma_map_sg);
 
+static int get_nr_mapped_entries(struct device *dev, struct scatterlist *s)
+{
+        struct dma_debug_entry *entry, ref;
+        struct hash_bucket *bucket;
+        unsigned long flags;
+        int mapped_ents;
+
+        ref.dev      = dev;
+        ref.dev_addr = sg_dma_address(s);
+        ref.size     = sg_dma_len(s),
+
+        bucket       = get_hash_bucket(&ref, &flags);
+        entry        = hash_bucket_find(bucket, &ref);
+        mapped_ents  = 0;
+
+        if (entry)
+                mapped_ents = entry->sg_mapped_ents;
+        put_hash_bucket(bucket, &flags);
+
+        return mapped_ents;
+}
+
 void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                         int nelems, int dir)
 {
-        struct dma_debug_entry *entry;
         struct scatterlist *s;
         int mapped_ents = 0, i;
-        unsigned long flags;
 
         if (unlikely(global_disable))
                 return;
@@ -807,8 +1073,8 @@ void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                         .type           = dma_debug_sg,
                         .dev            = dev,
                         .paddr          = sg_phys(s),
-                        .dev_addr       = s->dma_address,
-                        .size           = s->length,
+                        .dev_addr       = sg_dma_address(s),
+                        .size           = sg_dma_len(s),
                         .direction      = dir,
                         .sg_call_ents   = 0,
                 };
@@ -816,14 +1082,9 @@ void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                 if (mapped_ents && i >= mapped_ents)
                         break;
 
-                if (mapped_ents == 0) {
-                        struct hash_bucket *bucket;
+                if (!i) {
                         ref.sg_call_ents = nelems;
-                        bucket = get_hash_bucket(&ref, &flags);
-                        entry = hash_bucket_find(bucket, &ref);
-                        if (entry)
-                                mapped_ents = entry->sg_mapped_ents;
-                        put_hash_bucket(bucket, &flags);
+                        mapped_ents = get_nr_mapped_entries(dev, s);
                 }
 
                 check_unmap(&ref);
@@ -925,14 +1186,20 @@ void debug_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
                                int nelems, int direction)
 {
         struct scatterlist *s;
-        int i;
+        int mapped_ents = 0, i;
 
         if (unlikely(global_disable))
                 return;
 
         for_each_sg(sg, s, nelems, i) {
-                check_sync(dev, s->dma_address, s->dma_length, 0,
-                                direction, true);
+                if (!i)
+                        mapped_ents = get_nr_mapped_entries(dev, s);
+
+                if (i >= mapped_ents)
+                        break;
+
+                check_sync(dev, sg_dma_address(s), sg_dma_len(s), 0,
+                           direction, true);
         }
 }
 EXPORT_SYMBOL(debug_dma_sync_sg_for_cpu);
@@ -941,15 +1208,39 @@ void debug_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
                                   int nelems, int direction)
 {
         struct scatterlist *s;
-        int i;
+        int mapped_ents = 0, i;
 
         if (unlikely(global_disable))
                 return;
 
         for_each_sg(sg, s, nelems, i) {
-                check_sync(dev, s->dma_address, s->dma_length, 0,
-                                direction, false);
+                if (!i)
+                        mapped_ents = get_nr_mapped_entries(dev, s);
+
+                if (i >= mapped_ents)
+                        break;
+
+                check_sync(dev, sg_dma_address(s), sg_dma_len(s), 0,
+                           direction, false);
         }
 }
 EXPORT_SYMBOL(debug_dma_sync_sg_for_device);
 
+static int __init dma_debug_driver_setup(char *str)
+{
+        int i;
+
+        for (i = 0; i < NAME_MAX_LEN - 1; ++i, ++str) {
+                current_driver_name[i] = *str;
+                if (*str == 0)
+                        break;
+        }
+
+        if (current_driver_name[0])
+                pr_info("DMA-API: enable driver filter for driver [%s]\n",
+                        current_driver_name);
+
+
+        return 1;
+}
+__setup("dma_debug_driver=", dma_debug_driver_setup);
diff --git a/lib/kobject.c b/lib/kobject.c
index a6dec32f2ddd..bacf6fe4f7a0 100644
--- a/lib/kobject.c
+++ b/lib/kobject.c
@@ -218,6 +218,9 @@ int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
         const char *old_name = kobj->name;
         char *s;
 
+        if (kobj->name && !fmt)
+                return 0;
+
         kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
         if (!kobj->name)
                 return -ENOMEM;
diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c
index 97a777ad4f59..920a3ca6e259 100644
--- a/lib/kobject_uevent.c
+++ b/lib/kobject_uevent.c
@@ -258,7 +258,7 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
                         goto exit;
 
                 retval = call_usermodehelper(argv[0], argv,
-                                             env->envp, UMH_NO_WAIT);
+                                             env->envp, UMH_WAIT_EXEC);
         }
 
 exit:
@@ -328,7 +328,7 @@ static int __init kobject_uevent_init(void)
                        "kobject_uevent: unable to create netlink socket!\n");
                 return -ENODEV;
         }
-
+        netlink_set_nonroot(NETLINK_KOBJECT_UEVENT, NL_NONROOT_RECV);
         return 0;
 }
 
diff --git a/lib/scatterlist.c b/lib/scatterlist.c
index b7b449dafbe5..a295e404e908 100644
--- a/lib/scatterlist.c
+++ b/lib/scatterlist.c
@@ -347,9 +347,12 @@ bool sg_miter_next(struct sg_mapping_iter *miter)
         sg_miter_stop(miter);
 
         /* get to the next sg if necessary.  __offset is adjusted by stop */
-        if (miter->__offset == miter->__sg->length && --miter->__nents) {
-                miter->__sg = sg_next(miter->__sg);
-                miter->__offset = 0;
+        while (miter->__offset == miter->__sg->length) {
+                if (--miter->__nents) {
+                        miter->__sg = sg_next(miter->__sg);
+                        miter->__offset = 0;
+                } else
+                        return false;
         }
 
         /* map the next page */
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index 2b0b5a7d2ced..bffe6d7ef9d9 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -60,8 +60,8 @@ enum dma_sync_target {
 int swiotlb_force;
 
 /*
- * Used to do a quick range check in swiotlb_unmap_single and
- * swiotlb_sync_single_*, to see if the memory was in fact allocated by this
+ * Used to do a quick range check in unmap_single and
+ * sync_single_*, to see if the memory was in fact allocated by this
  * API.
  */
 static char *io_tlb_start, *io_tlb_end;
@@ -129,7 +129,7 @@ dma_addr_t __weak swiotlb_phys_to_bus(struct device *hwdev, phys_addr_t paddr)
         return paddr;
 }
 
-phys_addr_t __weak swiotlb_bus_to_phys(dma_addr_t baddr)
+phys_addr_t __weak swiotlb_bus_to_phys(struct device *hwdev, dma_addr_t baddr)
 {
         return baddr;
 }
@@ -140,9 +140,15 @@ static dma_addr_t swiotlb_virt_to_bus(struct device *hwdev,
         return swiotlb_phys_to_bus(hwdev, virt_to_phys(address));
 }
 
-static void *swiotlb_bus_to_virt(dma_addr_t address)
+void * __weak swiotlb_bus_to_virt(struct device *hwdev, dma_addr_t address)
 {
-        return phys_to_virt(swiotlb_bus_to_phys(address));
+        return phys_to_virt(swiotlb_bus_to_phys(hwdev, address));
+}
+
+int __weak swiotlb_arch_address_needs_mapping(struct device *hwdev,
+                                               dma_addr_t addr, size_t size)
+{
+        return !is_buffer_dma_capable(dma_get_mask(hwdev), addr, size);
 }
 
 int __weak swiotlb_arch_range_needs_mapping(phys_addr_t paddr, size_t size)
@@ -309,10 +315,10 @@ cleanup1:
         return -ENOMEM;
 }
 
-static int
+static inline int
 address_needs_mapping(struct device *hwdev, dma_addr_t addr, size_t size)
 {
-        return !is_buffer_dma_capable(dma_get_mask(hwdev), addr, size);
+        return swiotlb_arch_address_needs_mapping(hwdev, addr, size);
 }
 
 static inline int range_needs_mapping(phys_addr_t paddr, size_t size)
@@ -341,7 +347,7 @@ static void swiotlb_bounce(phys_addr_t phys, char *dma_addr, size_t size,
                 unsigned long flags;
 
                 while (size) {
-                        sz = min(PAGE_SIZE - offset, size);
+                        sz = min_t(size_t, PAGE_SIZE - offset, size);
 
                         local_irq_save(flags);
                         buffer = kmap_atomic(pfn_to_page(pfn),
@@ -476,7 +482,7 @@ found:
  * dma_addr is the kernel virtual address of the bounce buffer to unmap.
  */
 static void
-unmap_single(struct device *hwdev, char *dma_addr, size_t size, int dir)
+do_unmap_single(struct device *hwdev, char *dma_addr, size_t size, int dir)
 {
         unsigned long flags;
         int i, count, nslots = ALIGN(size, 1 << IO_TLB_SHIFT) >> IO_TLB_SHIFT;
@@ -560,7 +566,6 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                                    size)) {
                 /*
                  * The allocated memory isn't reachable by the device.
-                 * Fall back on swiotlb_map_single().
                  */
                 free_pages((unsigned long) ret, order);
                 ret = NULL;
@@ -568,9 +573,8 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
         if (!ret) {
                 /*
                  * We are either out of memory or the device can't DMA
-                 * to GFP_DMA memory; fall back on
-                 * swiotlb_map_single(), which will grab memory from
-                 * the lowest available address range.
+                 * to GFP_DMA memory; fall back on map_single(), which
+                 * will grab memory from the lowest available address range.
                  */
                 ret = map_single(hwdev, 0, size, DMA_FROM_DEVICE);
                 if (!ret)
@@ -587,7 +591,7 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                        (unsigned long long)dev_addr);
 
                 /* DMA_TO_DEVICE to avoid memcpy in unmap_single */
-                unmap_single(hwdev, ret, size, DMA_TO_DEVICE);
+                do_unmap_single(hwdev, ret, size, DMA_TO_DEVICE);
                 return NULL;
         }
         *dma_handle = dev_addr;
@@ -604,7 +608,7 @@ swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
                 free_pages((unsigned long) vaddr, get_order(size));
         else
                 /* DMA_TO_DEVICE to avoid memcpy in unmap_single */
-                unmap_single(hwdev, vaddr, size, DMA_TO_DEVICE);
+                do_unmap_single(hwdev, vaddr, size, DMA_TO_DEVICE);
 }
 EXPORT_SYMBOL(swiotlb_free_coherent);
 
@@ -634,7 +638,7 @@ swiotlb_full(struct device *dev, size_t size, int dir, int do_panic)
  * physical address to use is returned.
  *
  * Once the device is given the dma address, the device owns this memory until
- * either swiotlb_unmap_single or swiotlb_dma_sync_single is performed.
+ * either swiotlb_unmap_page or swiotlb_dma_sync_single is performed.
  */
 dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                             unsigned long offset, size_t size,
@@ -642,18 +646,17 @@ dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                             struct dma_attrs *attrs)
 {
         phys_addr_t phys = page_to_phys(page) + offset;
-        void *ptr = page_address(page) + offset;
         dma_addr_t dev_addr = swiotlb_phys_to_bus(dev, phys);
         void *map;
 
         BUG_ON(dir == DMA_NONE);
         /*
-         * If the pointer passed in happens to be in the device's DMA window,
+         * If the address happens to be in the device's DMA window,
          * we can safely return the device addr and not worry about bounce
          * buffering it.
          */
         if (!address_needs_mapping(dev, dev_addr, size) &&
-            !range_needs_mapping(virt_to_phys(ptr), size))
+            !range_needs_mapping(phys, size))
                 return dev_addr;
 
         /*
@@ -679,23 +682,35 @@ EXPORT_SYMBOL_GPL(swiotlb_map_page);
 
 /*
  * Unmap a single streaming mode DMA translation.  The dma_addr and size must
- * match what was provided for in a previous swiotlb_map_single call.  All
+ * match what was provided for in a previous swiotlb_map_page call.  All
  * other usages are undefined.
  *
  * After this call, reads by the cpu to the buffer are guaranteed to see
  * whatever the device wrote there.
  */
+static void unmap_single(struct device *hwdev, dma_addr_t dev_addr,
+                         size_t size, int dir)
+{
+        char *dma_addr = swiotlb_bus_to_virt(hwdev, dev_addr);
+
+        BUG_ON(dir == DMA_NONE);
+
+        if (is_swiotlb_buffer(dma_addr)) {
+                do_unmap_single(hwdev, dma_addr, size, dir);
+                return;
+        }
+
+        if (dir != DMA_FROM_DEVICE)
+                return;
+
+        dma_mark_clean(dma_addr, size);
+}
+
 void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
                         size_t size, enum dma_data_direction dir,
                         struct dma_attrs *attrs)
 {
-        char *dma_addr = swiotlb_bus_to_virt(dev_addr);
-
-        BUG_ON(dir == DMA_NONE);
-        if (is_swiotlb_buffer(dma_addr))
-                unmap_single(hwdev, dma_addr, size, dir);
-        else if (dir == DMA_FROM_DEVICE)
-                dma_mark_clean(dma_addr, size);
+        unmap_single(hwdev, dev_addr, size, dir);
 }
 EXPORT_SYMBOL_GPL(swiotlb_unmap_page);
 
@@ -703,7 +718,7 @@ EXPORT_SYMBOL_GPL(swiotlb_unmap_page);
  * Make physical memory consistent for a single streaming mode DMA translation
  * after a transfer.
  *
- * If you perform a swiotlb_map_single() but wish to interrogate the buffer
+ * If you perform a swiotlb_map_page() but wish to interrogate the buffer
  * using the cpu, yet do not wish to teardown the dma mapping, you must
  * call this function before doing so.  At the next point you give the dma
  * address back to the card, you must first perform a
@@ -713,13 +728,19 @@ static void
 swiotlb_sync_single(struct device *hwdev, dma_addr_t dev_addr,
                     size_t size, int dir, int target)
 {
-        char *dma_addr = swiotlb_bus_to_virt(dev_addr);
+        char *dma_addr = swiotlb_bus_to_virt(hwdev, dev_addr);
 
         BUG_ON(dir == DMA_NONE);
-        if (is_swiotlb_buffer(dma_addr))
+
+        if (is_swiotlb_buffer(dma_addr)) {
                 sync_single(hwdev, dma_addr, size, dir, target);
-        else if (dir == DMA_FROM_DEVICE)
-                dma_mark_clean(dma_addr, size);
+                return;
+        }
+
+        if (dir != DMA_FROM_DEVICE)
+                return;
+
+        dma_mark_clean(dma_addr, size);
 }
 
 void
@@ -746,13 +767,7 @@ swiotlb_sync_single_range(struct device *hwdev, dma_addr_t dev_addr,
                           unsigned long offset, size_t size,
                           int dir, int target)
 {
-        char *dma_addr = swiotlb_bus_to_virt(dev_addr) + offset;
-
-        BUG_ON(dir == DMA_NONE);
-        if (is_swiotlb_buffer(dma_addr))
-                sync_single(hwdev, dma_addr, size, dir, target);
-        else if (dir == DMA_FROM_DEVICE)
-                dma_mark_clean(dma_addr, size);
+        swiotlb_sync_single(hwdev, dev_addr + offset, size, dir, target);
 }
 
 void
@@ -777,7 +792,7 @@ EXPORT_SYMBOL_GPL(swiotlb_sync_single_range_for_device);
 
 /*
  * Map a set of buffers described by scatterlist in streaming mode for DMA.
- * This is the scatter-gather version of the above swiotlb_map_single
+ * This is the scatter-gather version of the above swiotlb_map_page
  * interface.  Here the scatter gather list elements are each tagged with the
  * appropriate dma address and length.  They are obtained via
  * sg_dma_{address,length}(SG).
@@ -788,7 +803,7 @@ EXPORT_SYMBOL_GPL(swiotlb_sync_single_range_for_device);
  *       The routine returns the number of addr/length pairs actually
  *       used, at most nents.
  *
- * Device ownership issues as mentioned above for swiotlb_map_single are the
+ * Device ownership issues as mentioned above for swiotlb_map_page are the
  * same here.
  */
 int
@@ -836,7 +851,7 @@ EXPORT_SYMBOL(swiotlb_map_sg);
 
 /*
  * Unmap a set of streaming mode DMA translations.  Again, cpu read rules
- * concerning calls here are the same as for swiotlb_unmap_single() above.
+ * concerning calls here are the same as for swiotlb_unmap_page() above.
  */
 void
 swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
@@ -847,13 +862,9 @@ swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
 
         BUG_ON(dir == DMA_NONE);
 
-        for_each_sg(sgl, sg, nelems, i) {
-                if (sg->dma_address != swiotlb_phys_to_bus(hwdev, sg_phys(sg)))
-                        unmap_single(hwdev, swiotlb_bus_to_virt(sg->dma_address),
-                                     sg->dma_length, dir);
-                else if (dir == DMA_FROM_DEVICE)
-                        dma_mark_clean(swiotlb_bus_to_virt(sg->dma_address), sg->dma_length);
-        }
+        for_each_sg(sgl, sg, nelems, i)
+                unmap_single(hwdev, sg->dma_address, sg->dma_length, dir);
+
 }
 EXPORT_SYMBOL(swiotlb_unmap_sg_attrs);
 
@@ -879,15 +890,9 @@ swiotlb_sync_sg(struct device *hwdev, struct scatterlist *sgl,
         struct scatterlist *sg;
         int i;
 
-        BUG_ON(dir == DMA_NONE);
-
-        for_each_sg(sgl, sg, nelems, i) {
-                if (sg->dma_address != swiotlb_phys_to_bus(hwdev, sg_phys(sg)))
-                        sync_single(hwdev, swiotlb_bus_to_virt(sg->dma_address),
+        for_each_sg(sgl, sg, nelems, i)
+                swiotlb_sync_single(hwdev, sg->dma_address,
                                     sg->dma_length, dir, target);
-                else if (dir == DMA_FROM_DEVICE)
-                        dma_mark_clean(swiotlb_bus_to_virt(sg->dma_address), sg->dma_length);
-        }
 }
 
 void