Skip to contentSkip to conversation

edac/mce_amd: fix shift warning

PATCH In review Randy Dunlap 5 participants 9 messages Oct 13, 2010 – Oct 14, 2010

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 edac/mce_amd: fix shift warning

From: Randy Dunlap <[email protected]>

The BIT() macro works on unsigned longs, but this warning happens on i386 (X86_32), where UL is 32 bits and this value needs to be 64 bits, so use open-coded ULL.

drivers/edac/mce_amd.c:262: warning: left shift count >= width of type

Cc Doug Thompson <[email protected]>
Cc Borislav Petkov <[email protected]>
---
 drivers/edac/mce_amd.c |    3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/edac/mce_amd.c +2 -1
@@ -259,7 +259,8 @@ static void amd_decode_ic_mce(struct mce
 		pr_cont("%s TLB %s.\n", LL_MSG(ec),
 			(xec ? "multimatch" : "parity error"));
 	else if (BUS_ERROR(ec)) {
-		bool k8 = (boot_cpu_data.x86 == 0xf && (m->status & BIT(58)));
+		bool k8 = (boot_cpu_data.x86 == 0xf &&
+				(m->status & (1ULL << 58)));
 
 		pr_cont("during %s.\n", (k8 ? "system linefill" : "NB data read"));
 	} else if (fam_ops->ic_mce(ec))
#1 lore raw
Quoted 7 lines · Randy Dunlap

From: Randy Dunlap <[email protected]>
Subject: [PATCH -next] edac/mce_amd: fix shift warning
To: "lkml" <[email protected]>
Cc: "Doug Thompson" <[email protected]>, "Borislav Petkov" <[email protected]>, "akpm" <[email protected]>
Date: Wednesday, October 13, 2010, 2:10 PM
From: Randy Dunlap <[email protected]>

Quoted 5 lines

The BIT() macro works on unsigned longs, but this warning happens
on i386 (X86_32), where UL is 32 bits and this value needs to be
64 bits, so use open-coded ULL.

good find

Quoted 5 lines

drivers/edac/mce_amd.c:262: warning: left shift count >= width of type

Quoted 28 lines
Cc Doug Thompson <[email protected]>
Cc Borislav Petkov <[email protected]>
---
 drivers/edac/mce_amd.c |    3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/edac/mce_amd.c +0 -0
@@ -259,7 +259,8 @@ static void amd_decode_ic_mce(struct

mce
        pr_cont("%s TLB
%s.\n", LL_MSG(ec),

(xec ? "multimatch" : "parity error"));
    else if (BUS_ERROR(ec)) {
-        bool k8 =
(boot_cpu_data.x86 == 0xf && (m->status &
BIT(58)));
+        bool k8 =
(boot_cpu_data.x86 == 0xf &&
+
    (m->status & (1ULL <<
58)));

        pr_cont("during
%s.\n", (k8 ? "system linefill" : "NB data read"));
    } else if (fam_ops->ic_mce(ec))

#2 lore raw
In reply to Randy Dunlap

From: Randy Dunlap <[email protected]>
Date: Wed, Oct 13, 2010 at 04:10:57PM -0400

Quoted 5 lines

The BIT() macro works on unsigned longs, but this warning happens on i386 (X86_32), where UL is 32 bits and this value needs to be 64 bits, so use open-coded ULL.

drivers/edac/mce_amd.c:262: warning: left shift count >= width of type

Ok, so BIT() should be fixed to work with the largest type available, IMHO. Let me cook up something.

Quoted 3 lines
Cc Doug Thompson <[email protected]>
Cc Borislav Petkov <[email protected]>

In the meantime, I'll push your fix to Linus, thanks for testing this on 32-bit :).

Signature · 8 lines
Regards/Gruss,
Boris.

Advanced Micro Devices GmbH
Einsteinring 24, 85609 Dornach
General Managers: Alberto Bozzo, Andrew Bowd
Registration: Dornach, Gemeinde Aschheim, Landkreis Muenchen
Registergericht Muenchen, HRB Nr. 43632
#3 lore raw

PATCH 1/1 bitops.h: Widen BIT macro to support 64-bit types

Quoted 11 lines

From: Randy Dunlap <[email protected]>
Date: Wed, Oct 13, 2010 at 04:10:57PM -0400

Quoted 5 lines

The BIT() macro works on unsigned longs, but this warning happens on i386 (X86_32), where UL is 32 bits and this value needs to be 64 bits, so use open-coded ULL.

drivers/edac/mce_amd.c:262: warning: left shift count >= width of type

Ok, so BIT() should be fixed to work with the largest type available, IMHO. Let me cook up something.

Maybe something like the following. Build-tested with the crosstool
(http://www.kernel.org/pub/tools/crosstool) on the following arches:
alpha blackfin cris hppa64 ia64 mips64 sparc.

Any objections?

--
From: Borislav Petkov <[email protected]>
Date: Thu, 14 Oct 2010 12:00:17 +0200
Subject: [PATCH] bitops.h: Widen BIT macro to support 64-bit types

Nowadays, every arch defines an unsigned 64-bit type using either one of the include/asm-generic/int-l{,l}64.h headers. Thus, make the BIT() macro return that 64-bit type by default. This makes sense on x86 when manipulating MSR values and prevents overflow errors on 32-bit arches, for example.

---
 include/linux/bitops.h |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
include/linux/bitops.h +1 -1
index fc68053..7b9170b 100644
@@ -3,7 +3,7 @@
 #include <asm/types.h>
 
 #ifdef	__KERNEL__
-#define BIT(nr)			(1UL << (nr))
+#define BIT(nr)			(U64_C(1) << (nr))
 #define BIT_MASK(nr)		(1UL << ((nr) % BITS_PER_LONG))
 #define BIT_WORD(nr)		((nr) / BITS_PER_LONG)
 #define BITS_PER_BYTE		8
Signature · 11 lines
1.7.3.1.50.g1e633

-- 
Regards/Gruss,
Boris.

Advanced Micro Devices GmbH
Einsteinring 24, 85609 Dornach
General Managers: Alberto Bozzo, Andrew Bowd
Registration: Dornach, Gemeinde Aschheim, Landkreis Muenchen
Registergericht Muenchen, HRB Nr. 43632
#4 lore raw

Re: [PATCH] bitops.h: Widen BIT macro to support 64-bit types

include/linux/bitops.h line 6

Quoted 3 lines · Borislav Petkov

#ifdef __KERNEL__

include/linux/bitops.h +1 -1
-#define BIT(nr)			(1UL << (nr))
+#define BIT(nr)			(U64_C(1) << (nr))

Why not just use 1ULL instead?

Signature · 4 lines
Matthew Wilcox				Intel Open Source Technology Centre
"Bill, look, we understand that you're interested in selling us this
operating system, but compare it to ours.  We can't possibly take such
a retrograde step."
#5 lore raw

Re: [PATCH] bitops.h: Widen BIT macro to support 64-bit types

From: Matthew Wilcox <[email protected]>
Date: Thu, Oct 14, 2010 at 07:12:13AM -0400

Quoted 6 lines · Borislav Petkov

include/linux/bitops.h line 6

Quoted 3 lines

#ifdef __KERNEL__

include/linux/bitops.h +1 -1
-#define BIT(nr)			(1UL << (nr))
+#define BIT(nr)			(U64_C(1) << (nr))

Why not just use 1ULL instead?

Wanted to be __ASSEMBLY__ safe.

Signature · 8 lines
Regards/Gruss,
Boris.

Advanced Micro Devices GmbH
Einsteinring 24, 85609 Dornach
General Managers: Alberto Bozzo, Andrew Bowd
Registration: Dornach, Gemeinde Aschheim, Landkreis Muenchen
Registergericht Muenchen, HRB Nr. 43632
#6 lore raw

Re: [PATCH] bitops.h: Widen BIT macro to support 64-bit types

Quoted 11 lines · Borislav Petkov

From: Matthew Wilcox <[email protected]>
Date: Thu, Oct 14, 2010 at 07:12:13AM -0400

Quoted 6 lines · Borislav Petkov

include/linux/bitops.h line 6

Quoted 3 lines

#ifdef __KERNEL__

include/linux/bitops.h +1 -1
-#define BIT(nr)			(1UL << (nr))
+#define BIT(nr)			(U64_C(1) << (nr))

Why not just use 1ULL instead?

Wanted to be __ASSEMBLY__ safe.

Admirable, but the entire file is __ASSEMBLY__ unsafe at this point, so I don't see the point.

Signature · 4 lines
Matthew Wilcox				Intel Open Source Technology Centre
"Bill, look, we understand that you're interested in selling us this
operating system, but compare it to ours.  We can't possibly take such
a retrograde step."
#7 lore raw

Re: [PATCH] bitops.h: Widen BIT macro to support 64-bit types

In reply to Borislav Petkov
Quoted 9 lines · Borislav Petkov
Quoted 3 lines

Ok, so BIT() should be fixed to work with the largest type available, IMHO. Let me cook up something.

Maybe something like the following. Build-tested with the crosstool
(http://www.kernel.org/pub/tools/crosstool) on the following arches:
alpha blackfin cris hppa64 ia64 mips64 sparc.

Any objections?

Yeah. I object. I have no idea what this will change for everything else that expects bitops to work on unsigned long values.

I really think that the bug is not in the BIT() definition, but in the use. If somebody wants a non-unsigned-long bit field, they had better not use bitops.h.

And no, just changing the BIT() macro to return a 64-bit value is _not_ trivially safe. Due to C type rules, now all arithmetic using BIT() will suddenly be 64-bit, which is often *much* slower, and can introduce real bugs.

On many architectures, a 64-bit non-constant shift will even end up being a function call. And if the thing is used in a varargs function, the argument layout will be totally different. We've also had several issues with 64-bit types and switch() statements, for example. And a quick grep for '\<BIT(' shows that non-constant cases are not unheard of, and there's a lot of random use where it is not at all obvious that it's safe (because it's used for defining other defines).

So no. I do not think BIT() should be 64-bit. It's "unsigned long". Look at all the other things around it, and look at all the historical uses.

Linus

#8 lore raw

Re: [PATCH] bitops.h: Widen BIT macro to support 64-bit types

From: Linus Torvalds <[email protected]>
Date: Thu, Oct 14, 2010 at 08:03:17AM -0700

Quoted 23 lines · Borislav Petkov
Quoted 9 lines
Quoted 3 lines

Ok, so BIT() should be fixed to work with the largest type available, IMHO. Let me cook up something.

Maybe something like the following. Build-tested with the crosstool
(http://www.kernel.org/pub/tools/crosstool) on the following arches:
alpha blackfin cris hppa64 ia64 mips64 sparc.

Any objections?

Yeah. I object. I have no idea what this will change for everything else that expects bitops to work on unsigned long values.

I really think that the bug is not in the BIT() definition, but in the use. If somebody wants a non-unsigned-long bit field, they had better not use bitops.h.

And no, just changing the BIT() macro to return a 64-bit value is _not_ trivially safe. Due to C type rules, now all arithmetic using BIT() will suddenly be 64-bit, which is often *much* slower, and can introduce real bugs.

Quoted 7 lines

On many architectures, a 64-bit non-constant shift will even end up being a function call. And if the thing is used in a varargs function, the argument layout will be totally different. We've also had several issues with 64-bit types and switch() statements, for example. And a quick grep for '\<BIT(' shows that non-constant cases are not unheard of, and there's a lot of random use where it is not at all obvious that it's safe (because it's used for defining other defines).

Concerning safety, I actually had a version which did check the bit number supplied as an arg for overflowing but this failed when using BIT() in struct initializers:

	.struct_member = { BIT(bla) }

But thanks for the detailed explanation! This makes perfect sense; it was too much wishful thinking on my part to assume that a ULL BIT() would be fine after checking that all arches support the unsigned 64-bit type.

I'm much better off with a local BIT_64() or similar, definition.

Thanks.

Signature · 8 lines
Regards/Gruss,
Boris.

Advanced Micro Devices GmbH
Einsteinring 24, 85609 Dornach
General Managers: Alberto Bozzo, Andrew Bowd
Registration: Dornach, Gemeinde Aschheim, Landkreis Muenchen
Registergericht Muenchen, HRB Nr. 43632