Skip to contentSkip to conversation

: grub: Fix handling of long printf arguments on 64-bit.

PATCH In review David Miller 5 participants 16 messages Apr 11, 2009 – Apr 15, 2009

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 : grub: Fix handling of long printf arguments on 64-bit.

The grub printf code tries to treat 'long' and 'int' the same, that doesn't work on (most) 64-bit platforms.

2009-04-11 David S. Miller <[email protected]>

* kern/misc.c (grub_ltoa): New function. (grub_vsprintf): Use it to format 'long' integers.

---
 kern/misc.c |   35 +++++++++++++++++++++++++++++++----
 1 files changed, 31 insertions(+), 4 deletions(-)
kern/misc.c +31 -4
index 23eaa14..85a5d95 100644
@@ -590,6 +590,31 @@ grub_itoa (char *str, int c, unsigned n)
   return p;
 }
 
+static char *
+grub_ltoa (char *str, int c, unsigned long n)
+{
+  unsigned long base = (c == 'x') ? 16 : 10;
+  char *p;
+
+  if ((long) n < 0 && c == 'd')
+    {
+      n = (unsigned) (-((long) n));
+      *str++ = '-';
+    }
+
+  p = str;
+  do
+    {
+      unsigned long d = n % base;
+      *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
+    }
+  while (n /= base);
+  *p = 0;
+
+  grub_reverse (str);
+  return p;
+}
+
 /* Divide N by D, return the quotient, and store the remainder in *R.  */
 grub_uint64_t
 grub_divmod64 (grub_uint64_t n, grub_uint32_t d, grub_uint32_t *r)
@@ -790,12 +815,14 @@ grub_vsprintf (char *str, const char *fmt, va_list args)
 		  ll = va_arg (args, long long);
 		  grub_lltoa (tmp, c, ll);
 		}
+	      else if (longfmt)
+		{
+		  long l = va_arg (args, long);
+		  grub_ltoa (tmp, c, l);
+		}
 	      else
 		{
-		  if (longfmt)
-		    n = va_arg (args, long);
-		  else
-		    n = va_arg (args, int);
+		  n = va_arg (args, int);
 		  grub_itoa (tmp, c, n);
 		}
 	      if (! rightfill && grub_strlen (tmp) < format1)
Signature · 1 line
1.6.2.2
#1 lore raw
Quoted 2 lines · On Saturday 11 April 2009 17:08:29 David Miller wrote:

The grub printf code tries to treat 'long' and 'int' the same, that doesn't work on (most) 64-bit platforms.

Right. Good finding.

Regards,
Okuji

Quoted 64 lines

2009-04-11 David S. Miller <[email protected]>

* kern/misc.c (grub_ltoa): New function. (grub_vsprintf): Use it to format 'long' integers.

---
 kern/misc.c |   35 +++++++++++++++++++++++++++++++----
 1 files changed, 31 insertions(+), 4 deletions(-)
kern/misc.c +31 -4
index 23eaa14..85a5d95 100644
@@ -590,6 +590,31 @@ grub_itoa (char *str, int c, unsigned n)
   return p;
 }
 
+static char *
+grub_ltoa (char *str, int c, unsigned long n)
+{
+  unsigned long base = (c == 'x') ? 16 : 10;
+  char *p;
+
+  if ((long) n < 0 && c == 'd')
+    {
+      n = (unsigned) (-((long) n));
+      *str++ = '-';
+    }
+
+  p = str;
+  do
+    {
+      unsigned long d = n % base;
+      *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
+    }
+  while (n /= base);
+  *p = 0;
+
+  grub_reverse (str);
+  return p;
+}
+
 /* Divide N by D, return the quotient, and store the remainder in *R.  */
 grub_uint64_t
 grub_divmod64 (grub_uint64_t n, grub_uint32_t d, grub_uint32_t *r)
@@ -790,12 +815,14 @@ grub_vsprintf (char *str, const char *fmt, va_list
 args) ll = va_arg (args, long long);
 		  grub_lltoa (tmp, c, ll);
 		}
+	      else if (longfmt)
+		{
+		  long l = va_arg (args, long);
+		  grub_ltoa (tmp, c, l);
+		}
 	      else
 		{
-		  if (longfmt)
-		    n = va_arg (args, long);
-		  else
-		    n = va_arg (args, int);
+		  n = va_arg (args, int);
 		  grub_itoa (tmp, c, n);
 		}
 	      if (! rightfill && grub_strlen (tmp) < format1)
#2 lore raw

From: "Yoshinori K. Okuji" <[email protected]>
Date: Sat, 11 Apr 2009 19:19:49 +0900

Quoted 5 lines · On Saturday 11 April 2009 17:08:29 David Miller wrote:
Quoted 2 lines

The grub printf code tries to treat 'long' and 'int' the same, that doesn't work on (most) 64-bit platforms.

Right. Good finding.

Committed. Thanks for reviewing.

#3 lore raw

I do not agree with having separate grub_itoa/grub_ltoa/grub_lltoa in kernel where the size is critical. We should have only lltoa and use it in all contexts. I know because of divmod64 it's slower than ltoa or itoa but it's used only for output so speed isn't so important

Quoted 15 lines · David Miller

From: "Yoshinori K. Okuji" <[email protected]>
Date: Sat, 11 Apr 2009 19:19:49 +0900

Quoted 4 lines · On Saturday 11 April 2009 17:08:29 David Miller wrote:
Quoted 2 lines

The grub printf code tries to treat 'long' and 'int' the same, that doesn't work on (most) 64-bit platforms.

Right. Good finding.

Committed. Thanks for reviewing.

_______________________________________________
Grub-devel mailing list
[email protected]
http://lists.gnu.org/mailman/listinfo/grub-devel

Signature · 2 lines
Regards
Vladimir 'phcoder' Serbinenko
#4 lore raw
Quoted 2 lines · phcoder

I do not agree with having separate grub_itoa/grub_ltoa/grub_lltoa in kernel where the size is critical.

Nice catch!

Quoted 3 lines

We should have only lltoa and use it
in all contexts. I know because of divmod64 it's slower than ltoa or itoa but it's used only for output so speed isn't so important

I agree.

Signature · 2 lines
Regards,
Pavel Roskin
#5 lore raw
In reply to phcoder

From: phcoder <[email protected]>
Date: Sat, 11 Apr 2009 21:10:26 +0200

Quoted 3 lines

I do not agree with having separate grub_itoa/grub_ltoa/grub_lltoa in kernel where the size is critical. We should have only lltoa and use it in all contexts.

I look forward to your patch implementing this improvement :-)

#6 lore raw
Quoted 9 lines · David Miller

From: phcoder <[email protected]>
Date: Sat, 11 Apr 2009 21:10:26 +0200

Quoted 3 lines

I do not agree with having separate grub_itoa/grub_ltoa/grub_lltoa in kernel where the size is critical. We should have only lltoa and use it in all contexts.

I look forward to your patch implementing this improvement :-)

Signature · 2 lines
Regards
Vladimir 'phcoder' Serbinenko
ChangeLog +8 -0
index 237c6f4..d701519 100644
@@ -1,3 +1,11 @@
+2009-04-12  Vladimir Serbinenko	 <[email protected]>
+
+	use grub_lltoa instead of grub_itoa and grub_ltoa for all purposes
+	
+	* kern/misc.c (grub_itoa): Removed function
+	(grub_ltoa): likewise
+	(grub_vsprintf): use grub_lltoa
+
 2009-04-12  David S. Miller  <[email protected]>
 
 	* kern/misc.c (grub_ltoa): Fix cast when handling negative
kern/misc.c +2 -52

70 lines not on this page · raw message

#7 lore raw

kern/misc.c grub_vsprintf (char *str, const char *fmt, va_list args) · line 776

Quoted 8 lines
kern/misc.c +2 -2
-                 grub_ltoa (tmp, c, l);
+                 grub_lltoa (tmp, c, l);
                }
              else
                {
                  n = va_arg (args, int);
-                 grub_itoa (tmp, c, n);
+                 grub_lltoa (tmp, c, n);

Do you think they deserve a comment saying why lltoa and that e.g. grub_ltoa would work equally well there except for space reasons? (In case we ever decided to change that code back, it would be easier to figure out.)

-Isaac

#8 lore raw
Quoted 9 lines · Isaac Dupree

kern/misc.c grub_vsprintf (char *str, const char *fmt, va_list args) · line 776

Quoted 8 lines
kern/misc.c +2 -2
-                 grub_ltoa (tmp, c, l);
+                 grub_lltoa (tmp, c, l);
                }
              else
                {
                  n = va_arg (args, int);
-                 grub_itoa (tmp, c, n);
+                 grub_lltoa (tmp, c, n);
Quoted 3 lines

Do you think they deserve a comment saying why lltoa and that e.g. grub_ltoa would work equally well there except for space reasons? (In case we ever decided to change that code back, it would be easier to figure out.)

If somebody wants to change the code back, that person would need to justify adding two functions to kern/misc.c, which is part of the GRUB core and should be kept minimal. I don't think it will be easy to justify.

Signature · 2 lines
Regards,
Pavel Roskin
#9 lore raw
In reply to phcoder

kern/misc.c grub_vsprintf (char *str, const char *fmt, va_list args) · line 776

Quoted 2 lines · phcoder
kern/misc.c +1 -1
-                 grub_itoa (tmp, c, n);
+                 grub_lltoa (tmp, c, n);

Wrong. For "x" and "u" specifiers, the value is unsigned int, but n is signed int. If we extend signed into to unsigned long long, we get a sign extension that would be incorrect.

Suppose the argument is 0xffffffff. n would be -1. grub_lltoa() would get (unsigned long long)-1, that is 0xffffffffffffffff.

If the type is going to be converted, we need to treat signed and unsigned values separately.

Signature · 2 lines
Regards,
Pavel Roskin
#10 lore raw
Quoted 2 lines · Pavel Roskin

If the type is going to be converted, we need to treat signed and unsigned values separately.

This is compile tested only, to show what I mean. The size of kernel.img is reduced from 31220 to 31124. The code looks long, but I'm sure an optimizing compiler can simplify it well. Variable names are changed for readability.

misc.c +21 -58
Index: kern/misc.c
===================================================================
@@ -565,56 +565,6 @@
     }
 }
 
-static char *
-grub_itoa (char *str, int c, unsigned n)
-{
-  unsigned base = (c == 'x') ? 16 : 10;
-  char *p;
-  
-  if ((int) n < 0 && c == 'd')
-    {
-      n = (unsigned) (-((int) n));
-      *str++ = '-';
-    }
-
-  p = str;
-  do
-    {
-      unsigned d = n % base;
-      *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
-    }
-  while (n /= base);
-  *p = 0;
-
-  grub_reverse (str);
-  return p;
-}
-
-static char *
-grub_ltoa (char *str, int c, unsigned long n)
-{
-  unsigned long base = (c == 'x') ? 16 : 10;
-  char *p;
-
-  if ((long) n < 0 && c == 'd')
-    {
-      n = (unsigned long) (-((long) n));
-      *str++ = '-';
-    }
-
-  p = str;
-  do
-    {
-      unsigned long d = n % base;
-      *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
-    }
-  while (n /= base);
-  *p = 0;
-
-  grub_reverse (str);
-  return p;
-}
-
 /* Divide N by D, return the quotient, and store the remainder in *R.  */
 grub_uint64_t
 grub_divmod64 (grub_uint64_t n, grub_uint32_t d, grub_uint32_t *r)
@@ -807,23 +757,36 @@
 	      /* fall through */
 	    case 'x':
 	    case 'u':
+	      if (longlongfmt)
+		{
+		  unsigned long long ull = va_arg (args, unsigned long long);
+		  grub_lltoa (tmp, c, ull);
+		}
+	      else if (longfmt)
+		{
+		  unsigned long ul = va_arg (args, unsigned long);
+		  grub_lltoa (tmp, c, ul);
+		}
+	      else
+		{
+		  unsigned int ui = va_arg (args, unsigned int);
+		  grub_lltoa (tmp, c, ui);
+		}
 	    case 'd':
 	      if (longlongfmt)
 		{
-		  long long ll;
-
-		  ll = va_arg (args, long long);
-		  grub_lltoa (tmp, c, ll);
+		  long long sll = va_arg (args, long long);
+		  grub_lltoa (tmp, c, sll);
 		}
 	      else if (longfmt)
 		{
-		  long l = va_arg (args, long);
-		  grub_ltoa (tmp, c, l);
+		  long sl = va_arg (args, long);
+		  grub_lltoa (tmp, c, sl);
 		}
 	      else
 		{
-		  n = va_arg (args, int);
-		  grub_itoa (tmp, c, n);
+		  int si = va_arg (args, int);
+		  grub_lltoa (tmp, c, si);
 		}
 	      if (! rightfill && grub_strlen (tmp) < format1)
 		write_fill (zerofill, format1 - grub_strlen (tmp));
Signature · 2 lines
Regards,
Pavel Roskin
#11 lore raw

I already understood what you meant in first mail. Sorry for not paying attention to this detail. Here is my proposition. IT decreases the size from 31224 to 31068 bytes. I tested it with following input
grub_printf ("Hello World: %d %ld %lld %x %lx %llx %u %lu %llu\n",

               0xffffffff, 0xffffffff, 0xffffffffffffffffLL,
               0xffffffff, 0xffffffff, 0xffffffffffffffffLL,
               0xffffffff, 0xffffffff, 0xffffffffffffffffLL);
  grub_printf ("Hello World: %d %ld %lld %x %lx %llx %u %lu %llu\n",
               0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL,
               0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL,
               0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL);

Output was:
Hello World: -1 -1 -1 ffffffff ffffffff ffffffffffffffff 4294967295 4294967295 18446744073709551615 Hello World: 268435455 268435455 1152921504606846975 fffffff fffffff fffffffffffffff 268435455 268435455 1152921504606846975

Quoted 118 lines · Pavel Roskin
Quoted 2 lines · Pavel Roskin

If the type is going to be converted, we need to treat signed and unsigned values separately.

This is compile tested only, to show what I mean. The size of kernel.img is reduced from 31220 to 31124. The code looks long, but I'm sure an optimizing compiler can simplify it well. Variable names are changed for readability.

Index: kern/misc.c
===================================================================

misc.c +21 -58
@@ -565,56 +565,6 @@
     }
 }
 
-static char *
-grub_itoa (char *str, int c, unsigned n)
-{
-  unsigned base = (c == 'x') ? 16 : 10;
-  char *p;
-  
-  if ((int) n < 0 && c == 'd')
-    {
-      n = (unsigned) (-((int) n));
-      *str++ = '-';
-    }
-
-  p = str;
-  do
-    {
-      unsigned d = n % base;
-      *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
-    }
-  while (n /= base);
-  *p = 0;
-
-  grub_reverse (str);
-  return p;
-}
-
-static char *
-grub_ltoa (char *str, int c, unsigned long n)
-{
-  unsigned long base = (c == 'x') ? 16 : 10;
-  char *p;
-
-  if ((long) n < 0 && c == 'd')
-    {
-      n = (unsigned long) (-((long) n));
-      *str++ = '-';
-    }
-
-  p = str;
-  do
-    {
-      unsigned long d = n % base;
-      *p++ = (d > 9) ? d + 'a' - 10 : d + '0';
-    }
-  while (n /= base);
-  *p = 0;
-
-  grub_reverse (str);
-  return p;
-}
-
 /* Divide N by D, return the quotient, and store the remainder in *R.  */
 grub_uint64_t
 grub_divmod64 (grub_uint64_t n, grub_uint32_t d, grub_uint32_t *r)
@@ -807,23 +757,36 @@
 	      /* fall through */
 	    case 'x':
 	    case 'u':
+	      if (longlongfmt)
+		{
+		  unsigned long long ull = va_arg (args, unsigned long long);
+		  grub_lltoa (tmp, c, ull);
+		}
+	      else if (longfmt)
+		{
+		  unsigned long ul = va_arg (args, unsigned long);
+		  grub_lltoa (tmp, c, ul);
+		}
+	      else
+		{
+		  unsigned int ui = va_arg (args, unsigned int);
+		  grub_lltoa (tmp, c, ui);
+		}
 	    case 'd':
 	      if (longlongfmt)
 		{
-		  long long ll;
-
-		  ll = va_arg (args, long long);
-		  grub_lltoa (tmp, c, ll);
+		  long long sll = va_arg (args, long long);
+		  grub_lltoa (tmp, c, sll);
 		}
 	      else if (longfmt)
 		{
-		  long l = va_arg (args, long);
-		  grub_ltoa (tmp, c, l);
+		  long sl = va_arg (args, long);
+		  grub_lltoa (tmp, c, sl);
 		}
 	      else
 		{
-		  n = va_arg (args, int);
-		  grub_itoa (tmp, c, n);
+		  int si = va_arg (args, int);
+		  grub_lltoa (tmp, c, si);
 		}
 	      if (! rightfill && grub_strlen (tmp) < format1)
 		write_fill (zerofill, format1 - grub_strlen (tmp));
Signature · 2 lines
Regards
Vladimir 'phcoder' Serbinenko
ChangeLog +8 -0
index 237c6f4..d701519 100644
@@ -1,3 +1,11 @@
+2009-04-13  Vladimir Serbinenko	 <[email protected]>
+
+	use grub_lltoa instead of grub_itoa and grub_ltoa for all purposes
+	
+	* kern/misc.c (grub_itoa): Removed function
+	(grub_ltoa): likewise
+	(grub_vsprintf): use grub_lltoa
+
 2009-04-12  David S. Miller  <[email protected]>
 
 	* kern/misc.c (grub_ltoa): Fix cast when handling negative
kern/misc.c +16 -53

102 lines not on this page · raw message

#12 lore raw
Quoted 11 lines · phcoder

I already understood what you meant in first mail. Sorry for not paying attention to this detail. Here is my proposition. IT decreases the size from 31224 to 31068 bytes. I tested it with following input
grub_printf ("Hello World: %d %ld %lld %x %lx %llx %u %lu %llu\n",

                0xffffffff, 0xffffffff, 0xffffffffffffffffLL,
                0xffffffff, 0xffffffff, 0xffffffffffffffffLL,
                0xffffffff, 0xffffffff, 0xffffffffffffffffLL);
   grub_printf ("Hello World: %d %ld %lld %x %lx %llx %u %lu %llu\n",
                0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL,
                0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL,
                0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL);
Quoted 5 lines

Output was:
Hello World: -1 -1 -1 ffffffff ffffffff ffffffffffffffff 4294967295 4294967295 18446744073709551615
Hello World: 268435455 268435455 1152921504606846975 fffffff fffffff fffffffffffffff 268435455 268435455 1152921504606846975

Thanks for the patch and for the test! You patch doesn't look as pedantic as mine, but apparently the compiler can optimize you code better. I have no objections to your patch.

Signature · 2 lines
Regards,
Pavel Roskin
#13 lore raw

commited

Quoted 18 lines · Pavel Roskin
Quoted 9 lines · phcoder

I already understood what you meant in first mail. Sorry for not paying attention to this detail. Here is my proposition. IT decreases the size from 31224 to 31068 bytes. I tested it with following input
grub_printf ("Hello World: %d %ld %lld %x %lx %llx %u %lu %llu\n",

                0xffffffff, 0xffffffff, 0xffffffffffffffffLL,
                0xffffffff, 0xffffffff, 0xffffffffffffffffLL,
                0xffffffff, 0xffffffff, 0xffffffffffffffffLL);
   grub_printf ("Hello World: %d %ld %lld %x %lx %llx %u %lu %llu\n",
                0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL,
                0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL,
                0x0fffffff, 0x0fffffff, 0x0fffffffffffffffLL);
Quoted 3 lines

Output was:
Hello World: -1 -1 -1 ffffffff ffffffff ffffffffffffffff 4294967295 4294967295 18446744073709551615 Hello World: 268435455 268435455 1152921504606846975 fffffff fffffff fffffffffffffff 268435455 268435455 1152921504606846975

Thanks for the patch and for the test! You patch doesn't look as pedantic as mine, but apparently the compiler can optimize you code better. I have no objections to your patch.

Signature · 2 lines
Regards
Vladimir 'phcoder' Serbinenko
#14 lore raw
In reply to David Miller
Quoted 4 lines · David Miller

The grub printf code tries to treat 'long' and 'int' the same, that doesn't work on (most) 64-bit platforms.

+ n = (unsigned) (-((long) n));

"unsigned" means "unsigned int". You need "unsigned long" here.

It's probably irrelevant if we kill grub_ltoa(), but anyway, let's be careful.

Signature · 2 lines
Regards,
Pavel Roskin
#15 lore raw

From: Pavel Roskin <[email protected]>
Date: Sun, 12 Apr 2009 02:39:22 -0400

Quoted 7 lines · David Miller
Quoted 4 lines

The grub printf code tries to treat 'long' and 'int' the same, that doesn't work on (most) 64-bit platforms.

+ n = (unsigned) (-((long) n));

"unsigned" means "unsigned int". You need "unsigned long" here.

Thanks, I'll fix this as follows.

* kern/misc.c (grub_ltoa): Fix cast when handling negative values. Noticed by Pavel Roskin.

misc.c +1 -1
@@ -598,7 +598,7 @@
 
   if ((long) n < 0 && c == 'd')
     {
-      n = (unsigned) (-((long) n));
+      n = (unsigned long) (-((long) n));
       *str++ = '-';
     }