: grub: Fix handling of long printf arguments on 64-bit.
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
@@ -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
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@@ -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)
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.
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 +0900Quoted 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
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
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 :-)
Quoted 9 lines · David Miller
From: phcoder <[email protected]>
Date: Sat, 11 Apr 2009 21:10:26 +0200Quoted 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
@@ -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
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
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_ltoawould 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
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
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
@@ -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
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
@@ -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
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
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 1152921504606846975Thanks 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
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
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++ ='-' ; }