Merge branch 'linux-2.6' into powerpc-next

4 files changed, 55 insertions, 45 deletions

diff --git a/lib/bitmap.c b/lib/bitmap.c
index c4cb48f77f0c..482df94ea21e 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -316,22 +316,6 @@ int bitmap_scnprintf(char *buf, unsigned int buflen,
 EXPORT_SYMBOL(bitmap_scnprintf);
 
 /**
- * bitmap_scnprintf_len - return buffer length needed to convert
- * bitmap to an ASCII hex string.
- * @len: number of bits to be converted
- */
-int bitmap_scnprintf_len(unsigned int len)
-{
-        /* we need 9 chars per word for 32 bit words (8 hexdigits + sep/null) */
-        int bitslen = ALIGN(len, CHUNKSZ);
-        int wordlen = CHUNKSZ / 4;
-        int buflen = (bitslen / wordlen) * (wordlen + 1) * sizeof(char);
-
-        return buflen;
-}
-EXPORT_SYMBOL(bitmap_scnprintf_len);
-
-/**
  * __bitmap_parse - convert an ASCII hex string into a bitmap.
  * @buf: pointer to buffer containing string.
  * @buflen: buffer size in bytes.  If string is smaller than this
diff --git a/lib/hexdump.c b/lib/hexdump.c
index 343546550dc9..f07c0db81d26 100644
--- a/lib/hexdump.c
+++ b/lib/hexdump.c
@@ -12,6 +12,9 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 
+const char hex_asc[] = "0123456789abcdef";
+EXPORT_SYMBOL(hex_asc);
+
 /**
  * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
  * @buf: data blob to dump
@@ -93,8 +96,8 @@ void hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
                 for (j = 0; (j < rowsize) && (j < len) && (lx + 4) < linebuflen;
                      j++) {
                         ch = ptr[j];
-                        linebuf[lx++] = hex_asc(ch >> 4);
-                        linebuf[lx++] = hex_asc(ch & 0x0f);
+                        linebuf[lx++] = hex_asc_hi(ch);
+                        linebuf[lx++] = hex_asc_lo(ch);
                         linebuf[lx++] = ' ';
                 }
                 ascii_column = 3 * rowsize + 2;
diff --git a/lib/lmb.c b/lib/lmb.c
index 83287d3869a3..867f7b5a8231 100644
--- a/lib/lmb.c
+++ b/lib/lmb.c
@@ -19,31 +19,42 @@
 
 struct lmb lmb;
 
+static int lmb_debug;
+
+static int __init early_lmb(char *p)
+{
+        if (p && strstr(p, "debug"))
+                lmb_debug = 1;
+        return 0;
+}
+early_param("lmb", early_lmb);
+
 void lmb_dump_all(void)
 {
-#ifdef DEBUG
         unsigned long i;
 
-        pr_debug("lmb_dump_all:\n");
-        pr_debug("    memory.cnt                  = 0x%lx\n", lmb.memory.cnt);
-        pr_debug("    memory.size                 = 0x%llx\n",
+        if (!lmb_debug)
+                return;
+
+        pr_info("lmb_dump_all:\n");
+        pr_info("    memory.cnt           = 0x%lx\n", lmb.memory.cnt);
+        pr_info("    memory.size                  = 0x%llx\n",
             (unsigned long long)lmb.memory.size);
         for (i=0; i < lmb.memory.cnt ;i++) {
-                pr_debug("    memory.region[0x%x].base       = 0x%llx\n",
+                pr_info("    memory.region[0x%lx].base       = 0x%llx\n",
                     i, (unsigned long long)lmb.memory.region[i].base);
-                pr_debug("                    .size     = 0x%llx\n",
+                pr_info("                     .size     = 0x%llx\n",
                     (unsigned long long)lmb.memory.region[i].size);
         }
 
-        pr_debug("    reserved.cnt        = 0x%lx\n", lmb.reserved.cnt);
-        pr_debug("    reserved.size       = 0x%lx\n", lmb.reserved.size);
+        pr_info("    reserved.cnt         = 0x%lx\n", lmb.reserved.cnt);
+        pr_info("    reserved.size        = 0x%lx\n", lmb.reserved.size);
         for (i=0; i < lmb.reserved.cnt ;i++) {
-                pr_debug("    reserved.region[0x%x].base       = 0x%llx\n",
+                pr_info("    reserved.region[0x%lx].base       = 0x%llx\n",
                     i, (unsigned long long)lmb.reserved.region[i].base);
-                pr_debug("                    .size     = 0x%llx\n",
+                pr_info("                     .size     = 0x%llx\n",
                     (unsigned long long)lmb.reserved.region[i].size);
         }
-#endif /* DEBUG */
 }
 
 static unsigned long lmb_addrs_overlap(u64 base1, u64 size1, u64 base2,
@@ -286,8 +297,7 @@ static u64 __init lmb_alloc_nid_unreserved(u64 start, u64 end,
                 j = lmb_overlaps_region(&lmb.reserved, base, size);
                 if (j < 0) {
                         /* this area isn't reserved, take it */
-                        if (lmb_add_region(&lmb.reserved, base,
-                                           lmb_align_up(size, align)) < 0)
+                        if (lmb_add_region(&lmb.reserved, base, size) < 0)
                                 base = ~(u64)0;
                         return base;
                 }
@@ -333,6 +343,10 @@ u64 __init lmb_alloc_nid(u64 size, u64 align, int nid,
         struct lmb_region *mem = &lmb.memory;
         int i;
 
+        BUG_ON(0 == size);
+
+        size = lmb_align_up(size, align);
+
         for (i = 0; i < mem->cnt; i++) {
                 u64 ret = lmb_alloc_nid_region(&mem->region[i],
                                                nid_range,
@@ -370,6 +384,8 @@ u64 __init __lmb_alloc_base(u64 size, u64 align, u64 max_addr)
 
         BUG_ON(0 == size);
 
+        size = lmb_align_up(size, align);
+
         /* On some platforms, make sure we allocate lowmem */
         /* Note that LMB_REAL_LIMIT may be LMB_ALLOC_ANYWHERE */
         if (max_addr == LMB_ALLOC_ANYWHERE)
@@ -393,8 +409,7 @@ u64 __init __lmb_alloc_base(u64 size, u64 align, u64 max_addr)
                         j = lmb_overlaps_region(&lmb.reserved, base, size);
                         if (j < 0) {
                                 /* this area isn't reserved, take it */
-                                if (lmb_add_region(&lmb.reserved, base,
-                                                   lmb_align_up(size, align)) < 0)
+                                if (lmb_add_region(&lmb.reserved, base, size) < 0)
                                         return 0;
                                 return base;
                         }
diff --git a/lib/parser.c b/lib/parser.c
index 703c8c13b346..4f0cbc03e0e8 100644
--- a/lib/parser.c
+++ b/lib/parser.c
@@ -182,18 +182,25 @@ int match_hex(substring_t *s, int *result)
 }
 
 /**
- * match_strcpy: - copies the characters from a substring_t to a string
- * @to: string to copy characters to.
- * @s: &substring_t to copy
+ * match_strlcpy: - Copy the characters from a substring_t to a sized buffer
+ * @dest: where to copy to
+ * @src: &substring_t to copy
+ * @size: size of destination buffer
  *
- * Description: Copies the set of characters represented by the given
- * &substring_t @s to the c-style string @to. Caller guarantees that @to is
- * large enough to hold the characters of @s.
+ * Description: Copy the characters in &substring_t @src to the
+ * c-style string @dest.  Copy no more than @size - 1 characters, plus
+ * the terminating NUL.  Return length of @src.
  */
-void match_strcpy(char *to, const substring_t *s)
+size_t match_strlcpy(char *dest, const substring_t *src, size_t size)
 {
-        memcpy(to, s->from, s->to - s->from);
-        to[s->to - s->from] = '\0';
+        size_t ret = src->to - src->from;
+
+        if (size) {
+                size_t len = ret >= size ? size - 1 : ret;
+                memcpy(dest, src->from, len);
+                dest[len] = '\0';
+        }
+        return ret;
 }
 
 /**
@@ -206,9 +213,10 @@ void match_strcpy(char *to, const substring_t *s)
  */
 char *match_strdup(const substring_t *s)
 {
-        char *p = kmalloc(s->to - s->from + 1, GFP_KERNEL);
+        size_t sz = s->to - s->from + 1;
+        char *p = kmalloc(sz, GFP_KERNEL);
         if (p)
-                match_strcpy(p, s);
+                match_strlcpy(p, s, sz);
         return p;
 }
 
@@ -216,5 +224,5 @@ EXPORT_SYMBOL(match_token);
 EXPORT_SYMBOL(match_int);
 EXPORT_SYMBOL(match_octal);
 EXPORT_SYMBOL(match_hex);
-EXPORT_SYMBOL(match_strcpy);
+EXPORT_SYMBOL(match_strlcpy);
 EXPORT_SYMBOL(match_strdup);