Merge commit 'v2.6.38-rc1' into kbuild/packaging

1 files changed, 31 insertions, 7 deletions

diff --git a/lib/scatterlist.c b/lib/scatterlist.c
index 0d475d8167bf..4ceb05d772ae 100644
--- a/lib/scatterlist.c
+++ b/lib/scatterlist.c
@@ -7,8 +7,10 @@
  * Version 2. See the file COPYING for more details.
  */
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/scatterlist.h>
 #include <linux/highmem.h>
+#include <linux/kmemleak.h>
 
 /**
  * sg_next - return the next scatterlist entry in a list
@@ -114,17 +116,29 @@ EXPORT_SYMBOL(sg_init_one);
  */
 static struct scatterlist *sg_kmalloc(unsigned int nents, gfp_t gfp_mask)
 {
-        if (nents == SG_MAX_SINGLE_ALLOC)
-                return (struct scatterlist *) __get_free_page(gfp_mask);
-        else
+        if (nents == SG_MAX_SINGLE_ALLOC) {
+                /*
+                 * Kmemleak doesn't track page allocations as they are not
+                 * commonly used (in a raw form) for kernel data structures.
+                 * As we chain together a list of pages and then a normal
+                 * kmalloc (tracked by kmemleak), in order to for that last
+                 * allocation not to become decoupled (and thus a
+                 * false-positive) we need to inform kmemleak of all the
+                 * intermediate allocations.
+                 */
+                void *ptr = (void *) __get_free_page(gfp_mask);
+                kmemleak_alloc(ptr, PAGE_SIZE, 1, gfp_mask);
+                return ptr;
+        } else
                 return kmalloc(nents * sizeof(struct scatterlist), gfp_mask);
 }
 
 static void sg_kfree(struct scatterlist *sg, unsigned int nents)
 {
-        if (nents == SG_MAX_SINGLE_ALLOC)
+        if (nents == SG_MAX_SINGLE_ALLOC) {
+                kmemleak_free(sg);
                 free_page((unsigned long) sg);
-        else
+        } else
                 kfree(sg);
 }
 
@@ -234,8 +248,18 @@ int __sg_alloc_table(struct sg_table *table, unsigned int nents,
                 left -= sg_size;
 
                 sg = alloc_fn(alloc_size, gfp_mask);
-                if (unlikely(!sg))
-                        return -ENOMEM;
+                if (unlikely(!sg)) {
+                        /*
+                         * Adjust entry count to reflect that the last
+                         * entry of the previous table won't be used for
+                         * linkage.  Without this, sg_kfree() may get
+                         * confused.
+                         */
+                        if (prv)
+                                table->nents = ++table->orig_nents;
+
+                        return -ENOMEM;
+                }
 
                 sg_init_table(sg, alloc_size);
                 table->nents = table->orig_nents += sg_size;