| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Mon, 23 Jul 2007 21:35:48 +0530
From: Satyam Sharma <ssatyam@....iitk.ac.in>
To: Linux Kernel Mailing List <linux-kernel@...r.kernel.org>
Cc: David Howells <dhowells@...hat.com>,
Nick Piggin <nickpiggin@...oo.com.au>, Andi Kleen <ak@...e.de>,
Andrew Morton <akpm@...ux-foundation.org>,
Linus Torvalds <torvalds@...ux-foundation.org>
Subject: [PATCH 4/8] i386: bitops: Kill volatile-casting of memory addresses
From: Satyam Sharma <ssatyam@....iitk.ac.in>
[4/8] i386: bitops: Kill volatile-casting of memory addresses
All the occurrences of "volatile" that are used to qualify access to the
passed bit-string pointer/address must be removed, because "volatile" is
crazy, doesn't really work anyway, has nothing to do with locking and
atomicity, and is in general wholly unnecessary for these operations:
* In the case of the unlocked variants, we're not providing any guarantees
whatsoever, so we want the caller to do any necessary locking surrounding
the use of that function anyway.
* In case of the primitives where we *do* make locking/atomicity/reordering
(three very different, but related, concepts) guarantees, we're doing that
properly by using the lock instruction-prefix and "__asm__ __volatile__"
anyway (and with "addr" always being constrained with "m" in the assembly,
gcc doesn't bring it into a local register either).
So let's just kill the pointless use of volatile.
Signed-off-by: Satyam Sharma <ssatyam@....iitk.ac.in>
Cc: David Howells <dhowells@...hat.com>
Cc: Nick Piggin <nickpiggin@...oo.com.au>
---
include/asm-i386/bitops.h | 60 +++++++++++++++++++++------------------------
1 files changed, 28 insertions(+), 32 deletions(-)
diff --git a/include/asm-i386/bitops.h b/include/asm-i386/bitops.h
index d623fd9..0f5634b 100644
--- a/include/asm-i386/bitops.h
+++ b/include/asm-i386/bitops.h
@@ -26,8 +26,6 @@
* on single-dword quantities.
*/
-#define ADDR (*(volatile long *) addr)
-
/**
* set_bit - Atomically set a bit in memory
* @nr: the bit to set
@@ -38,11 +36,11 @@
*
* See __set_bit() if you do not require the atomic guarantees.
*/
-static inline void set_bit(int nr, volatile unsigned long * addr)
+static inline void set_bit(int nr, unsigned long *addr)
{
__asm__ __volatile__( LOCK_PREFIX
"btsl %1,%0"
- :"=m" (ADDR)
+ :"=m" (*addr)
:"r" (nr));
}
@@ -58,11 +56,11 @@ static inline void set_bit(int nr, volatile unsigned long * addr)
* This is a fast and unlocked operation, and only suitable for callers
* that already implement higher-level locking to protect access.
*/
-static inline void __set_bit(int nr, volatile unsigned long * addr)
+static inline void __set_bit(int nr, unsigned long *addr)
{
__asm__(
"btsl %1,%0"
- :"=m" (ADDR)
+ :"=m" (*addr)
:"r" (nr));
}
@@ -76,11 +74,11 @@ static inline void __set_bit(int nr, volatile unsigned long * addr)
*
* See __clear_bit() if you do not require the atomic guarantees.
*/
-static inline void clear_bit(int nr, volatile unsigned long * addr)
+static inline void clear_bit(int nr, unsigned long *addr)
{
__asm__ __volatile__( LOCK_PREFIX
"btrl %1,%0"
- :"=m" (ADDR)
+ :"=m" (*addr)
:"r" (nr));
}
@@ -96,11 +94,11 @@ static inline void clear_bit(int nr, volatile unsigned long * addr)
* This is a fast and unlocked operation, and only suitable for callers
* that already implement higher-level locking to protect access.
*/
-static inline void __clear_bit(int nr, volatile unsigned long * addr)
+static inline void __clear_bit(int nr, unsigned long *addr)
{
__asm__ __volatile__(
"btrl %1,%0"
- :"=m" (ADDR)
+ :"=m" (*addr)
:"r" (nr));
}
@@ -123,11 +121,11 @@ static inline void __clear_bit(int nr, volatile unsigned long * addr)
* This is a fast and unlocked operation, and only suitable for callers
* that already implement higher-level locking to protect access.
*/
-static inline void __change_bit(int nr, volatile unsigned long * addr)
+static inline void __change_bit(int nr, unsigned long *addr)
{
__asm__ __volatile__(
"btcl %1,%0"
- :"=m" (ADDR)
+ :"=m" (*addr)
:"r" (nr));
}
@@ -141,11 +139,11 @@ static inline void __change_bit(int nr, volatile unsigned long * addr)
*
* See __change_bit() if you do not require the atomic guarantees.
*/
-static inline void change_bit(int nr, volatile unsigned long * addr)
+static inline void change_bit(int nr, unsigned long *addr)
{
__asm__ __volatile__( LOCK_PREFIX
"btcl %1,%0"
- :"=m" (ADDR)
+ :"=m" (*addr)
:"r" (nr));
}
@@ -159,13 +157,13 @@ static inline void change_bit(int nr, volatile unsigned long * addr)
*
* See __test_and_set_bit() if you do not require the atomic guarantees.
*/
-static inline int test_and_set_bit(int nr, volatile unsigned long * addr)
+static inline int test_and_set_bit(int nr, unsigned long *addr)
{
int oldbit;
__asm__ __volatile__( LOCK_PREFIX
"btsl %2,%1\n\tsbbl %0,%0"
- :"=r" (oldbit),"=m" (ADDR)
+ :"=r" (oldbit),"=m" (*addr)
:"r" (nr) : "memory");
return oldbit;
}
@@ -182,13 +180,13 @@ static inline int test_and_set_bit(int nr, volatile unsigned long * addr)
* This is a fast and unlocked operation, and only suitable for callers
* that already implement higher-level locking to protect access.
*/
-static inline int __test_and_set_bit(int nr, volatile unsigned long * addr)
+static inline int __test_and_set_bit(int nr, unsigned long *addr)
{
int oldbit;
__asm__(
"btsl %2,%1\n\tsbbl %0,%0"
- :"=r" (oldbit),"=m" (ADDR)
+ :"=r" (oldbit),"=m" (*addr)
:"r" (nr));
return oldbit;
}
@@ -203,13 +201,13 @@ static inline int __test_and_set_bit(int nr, volatile unsigned long * addr)
*
* See __test_and_clear_bit() if you do not require the atomic guarantees.
*/
-static inline int test_and_clear_bit(int nr, volatile unsigned long * addr)
+static inline int test_and_clear_bit(int nr, unsigned long *addr)
{
int oldbit;
__asm__ __volatile__( LOCK_PREFIX
"btrl %2,%1\n\tsbbl %0,%0"
- :"=r" (oldbit),"=m" (ADDR)
+ :"=r" (oldbit),"=m" (*addr)
:"r" (nr) : "memory");
return oldbit;
}
@@ -226,13 +224,13 @@ static inline int test_and_clear_bit(int nr, volatile unsigned long * addr)
* This is a fast and unlocked operation, and only suitable for callers
* that already implement higher-level locking to protect access.
*/
-static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
+static inline int __test_and_clear_bit(int nr, unsigned long *addr)
{
int oldbit;
__asm__(
"btrl %2,%1\n\tsbbl %0,%0"
- :"=r" (oldbit),"=m" (ADDR)
+ :"=r" (oldbit),"=m" (*addr)
:"r" (nr));
return oldbit;
}
@@ -249,13 +247,13 @@ static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
* This is a fast and unlocked operation, and only suitable for callers
* that already implement higher-level locking to protect access.
*/
-static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
+static inline int __test_and_change_bit(int nr, unsigned long *addr)
{
int oldbit;
__asm__ __volatile__(
"btcl %2,%1\n\tsbbl %0,%0"
- :"=r" (oldbit),"=m" (ADDR)
+ :"=r" (oldbit),"=m" (*addr)
:"r" (nr) : "memory");
return oldbit;
}
@@ -270,13 +268,13 @@ static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
*
* See __test_and_change_bit() if you do not require the atomic guarantees.
*/
-static inline int test_and_change_bit(int nr, volatile unsigned long* addr)
+static inline int test_and_change_bit(int nr, unsigned long *addr)
{
int oldbit;
__asm__ __volatile__( LOCK_PREFIX
"btcl %2,%1\n\tsbbl %0,%0"
- :"=r" (oldbit),"=m" (ADDR)
+ :"=r" (oldbit),"=m" (*addr)
:"r" (nr) : "memory");
return oldbit;
}
@@ -287,22 +285,22 @@ static inline int test_and_change_bit(int nr, volatile unsigned long* addr)
* @nr: bit number to test
* @addr: Address to start counting from
*/
-static int test_bit(int nr, const volatile void * addr);
+static int test_bit(int nr, const unsigned long *addr);
#endif
-static __always_inline int constant_test_bit(int nr, const volatile unsigned long *addr)
+static __always_inline int constant_test_bit(int nr, const unsigned long *addr)
{
return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
}
-static inline int variable_test_bit(int nr, const volatile unsigned long * addr)
+static inline int variable_test_bit(int nr, const unsigned long *addr)
{
int oldbit;
__asm__ __volatile__(
"btl %2,%1\n\tsbbl %0,%0"
:"=r" (oldbit)
- :"m" (ADDR),"r" (nr));
+ :"m" (*addr),"r" (nr));
return oldbit;
}
@@ -311,8 +309,6 @@ static inline int variable_test_bit(int nr, const volatile unsigned long * addr)
constant_test_bit((nr),(addr)) : \
variable_test_bit((nr),(addr)))
-#undef ADDR
-
/**
* find_first_zero_bit - find the first zero bit in a memory region
* @addr: The address to start the search at
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Powered by blists - more mailing lists