Skip to contentSkip to conversation

m32r: Revise __raw_read_trylock()

PATCH In review Hirokazu Takata 5 participants 8 messages Sep 22, 2006 – Sep 26, 2006 Generic include/asm header files

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 m32r: Revise __raw_read_trylock()

Hi,

Matthew Wilcox pointed out that generic__raw_read_trylock() is unfit for use.

Here is a patch to fix __raw_read_trylock() for m32r. It is taken from the i386 implementation.

---
 include/asm-m32r/spinlock.h |   10 +++++++++-
 1 files changed, 9 insertions(+), 1 deletions(-)
include/asm-m32r/spinlock.h +9 -1
index f94c1a6..78205f0 100644
@@ -298,7 +298,15 @@ #endif	/* CONFIG_CHIP_M32700_TS1 */
 	);
 }
 
-#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
+static inline int __raw_read_trylock(raw_rwlock_t *lock)
+{
+	atomic_t *count = (atomic_t*)lock;
+	atomic_dec(count);
+	if (atomic_read(count) >= 0)
+		return 1;
+	atomic_inc(count);
+	return 0;
+}
 
 static inline int __raw_write_trylock(raw_rwlock_t *lock)
 {
Signature · 2 lines
Hirokazu Takata <[email protected]>
Linux/M32R Project:  http://www.linux-m32r.org/
#1 lore raw
Quoted 6 lines · Hirokazu Takata

Matthew Wilcox pointed out that generic__raw_read_trylock() is unfit for use.

Here is a patch to fix __raw_read_trylock() for m32r. It is taken from the i386 implementation.

This might be a stupid question, but why exactly are we ripping out generic__raw_read_trylock() if architectures are going to implement a generic implementation anyways, rather than just changing it to match the proper semantics?

With this the m32r patch can be dropped and the rest of the architectures can switch over as necessary to optimized versions, rather than being fundamentally broken.

--

 include/asm-i386/spinlock.h |   10 +---------
 kernel/spinlock.c           |    9 +++++++--
 2 files changed, 8 insertions(+), 11 deletions(-)
include/asm-i386/spinlock.h +1 -9
index d102036..2aba6b3 100644
@@ -169,15 +169,7 @@ static inline void __raw_write_lock(raw_
 	__build_write_lock(rw, "__write_lock_failed");
 }
 
-static inline int __raw_read_trylock(raw_rwlock_t *lock)
-{
-	atomic_t *count = (atomic_t *)lock;
-	atomic_dec(count);
-	if (atomic_read(count) >= 0)
-		return 1;
-	atomic_inc(count);
-	return 0;
-}
+#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
 
 static inline int __raw_write_trylock(raw_rwlock_t *lock)
 {
kernel/spinlock.c +7 -2
index fb524b0..8d50b9d 100644
@@ -15,6 +15,7 @@ #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <linux/debug_locks.h>
 #include <linux/module.h>
+#include <asm/atomic.h>
 
 /*
  * Generic declaration of the raw read_trylock() function,
@@ -22,8 +23,12 @@ #include <linux/module.h>
  */
 int __lockfunc generic__raw_read_trylock(raw_rwlock_t *lock)
 {
-	__raw_read_lock(lock);
-	return 1;
+	atomic_t *count = (atomic_t *)lock;
+	atomic_dec(count);
+	if (atomic_read(count) >= 0)
+		return 1;
+	atomic_inc(count);
+	return 0;
 }
 EXPORT_SYMBOL(generic__raw_read_trylock);
#2 lore raw
Quoted 4 lines · Paul Mundt

This might be a stupid question, but why exactly are we ripping out generic__raw_read_trylock() if architectures are going to implement a generic implementation anyways, rather than just changing it to match the proper semantics?

Because there is no generic definition of struct spinlock.

kernel/spinlock.c #include <linux/module.h> · line 32

Quoted 11 lines

int __lockfunc generic__raw_read_trylock(raw_rwlock_t *lock) {

kernel/spinlock.c +6 -2
-	__raw_read_lock(lock);
-	return 1;
+	atomic_t *count = (atomic_t *)lock;
+	atomic_dec(count);
+	if (atomic_read(count) >= 0)
+		return 1;
+	atomic_inc(count);
+	return 0;
 }

You're assuming:

- a spinlock is an atomic_t.
- Said atomic_t uses RW_LOCK_BIAS to indicate locked/unlocked.

This is true for m32r, but not for sparc. SuperH looks completely broken -- I don't see how holding a read lock prevents someone else from getting a write lock. The SH write_trylock uses RW_LOCK_BIAS, but write_lock doesn't. Are there any SMP SH machines?

#3 lore raw
Quoted 6 lines · Matthew Wilcox

You're assuming:

- a spinlock is an atomic_t.
- Said atomic_t uses RW_LOCK_BIAS to indicate locked/unlocked.

This is true for m32r, but not for sparc.

That makes sense, thanks for the clarification.

Quoted 4 lines

SuperH looks completely broken -- I don't see how holding a read lock prevents someone else from getting a write lock. The SH write_trylock uses RW_LOCK_BIAS, but write_lock doesn't. Are there any SMP SH machines?

Yes, it's broken, most of the work for that has been happening out of tree, and we'll have to sync it up again. The initial work was targetted at a pair of microcontrollers, but there were too many other issues there that the work was eventually abandoned. Recently it's started up again on more reasonable CPUs, so we'll be fixing these things up in order.

#4 lore raw
In reply to Hirokazu Takata

include/asm-m32r/spinlock.h #endif /* CONFIG_CHIP_M32700_TS1 */ · line 309

Quoted 12 lines · Hirokazu Takata
include/asm-m32r/spinlock.h +9 -1
-#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
+static inline int __raw_read_trylock(raw_rwlock_t *lock)
+{
+	atomic_t *count = (atomic_t*)lock;
+	atomic_dec(count);
+	if (atomic_read(count) >= 0)
+		return 1;
+	atomic_inc(count);
+	return 0;
+}

Is there a race here between __raw_read_trylock and __raw_write_trylock?

CPU A CPU B
__raw_read_trylock
atomic_dec(count);
__raw_write_trylock atomic_sub_and_test(RW_LOCK_BIAS, count)
atomic_read(count)

It'd be fairly harmless as neither would manage to get the lock. But I think it's not too hard to fix. Seems to me you want to do:

static inline int __raw_read_trylock(raw_rwlock_t *lock)

{
	atomic_t *count = (atomic_t*)lock;
	if (atomic_dec_return(count) >= 0)
		return 1;
	atomic_inc(count);
	return 0;
}

eliminating the race.

#5 lore raw

From: Matthew Wilcox <[email protected]>
Subject: Re: [PATCH] m32r: Revise __raw_read_trylock()
Date: Sun, 24 Sep 2006 00:20:36 -0600

Quoted 16 lines · Hirokazu Takata

Review

Quoted 12 lines
(quoted diff) +9 -1
-#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
+static inline int __raw_read_trylock(raw_rwlock_t *lock)
+{
+	atomic_t *count = (atomic_t*)lock;
+	atomic_dec(count);
+	if (atomic_read(count) >= 0)
+		return 1;
+	atomic_inc(count);
+	return 0;
+}

Is there a race here between __raw_read_trylock and __raw_write_trylock?

Quoted 6 lines

CPU A CPU B
__raw_read_trylock
atomic_dec(count);
__raw_write_trylock atomic_sub_and_test(RW_LOCK_BIAS, count)
atomic_read(count)

Indeed, it is a possible race.

Quoted 2 lines

It'd be fairly harmless as neither would manage to get the lock. But I think it's not too hard to fix. Seems to me you want to do:

I agree with you.
As you said, I think the above case is harmless.

Quoted 11 lines

static inline int __raw_read_trylock(raw_rwlock_t *lock)

{
	atomic_t *count = (atomic_t*)lock;
	if (atomic_dec_return(count) >= 0)
		return 1;
	atomic_inc(count);
	return 0;
}

eliminating the race.

All right, I think this fix is preferable.

Andrew, please drop and replace the previous my patch with the following Matthew's fix.

Thank you.

--

 include/asm-m32r/spinlock.h |    9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
include/asm-m32r/spinlock.h +8 -1
index f94c1a6..f9f9072 100644
@@ -298,7 +298,14 @@ #endif	/* CONFIG_CHIP_M32700_TS1 */
 	);
 }
 
-#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
+static inline int __raw_read_trylock(raw_rwlock_t *lock)
+{
+	atomic_t *count = (atomic_t*)lock;
+	if (atomic_dec_return(count) >= 0)
+		return 1;
+	atomic_inc(count);
+	return 0;
+}
 
 static inline int __raw_write_trylock(raw_rwlock_t *lock)
 {

--
Hirokazu Takata <[email protected]>
Linux/M32R Project: http://www.linux-m32r.org/

#6 lore raw
Quoted 18 lines · On Mon, 25 Sep 2006 16:47:22 +0900 Hirokazu Takata…

Andrew, please drop and replace the previous my patch with the following Matthew's fix.

Thank you.

--

 include/asm-m32r/spinlock.h |    9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
include/asm-m32r/spinlock.h +0 -0
index f94c1a6..f9f9072 100644
@@ -298,7 +298,14 @@ #endif	/* CONFIG_CHIP_M32700_TS1 */
 	);
 }

include/asm-m32r/spinlock.h #endif /* CONFIG_CHIP_M32700_TS1 */ · line 308

Quoted 10 lines
include/asm-m32r/spinlock.h +8 -1
 
-#define __raw_read_trylock(lock) generic__raw_read_trylock(lock)
+static inline int __raw_read_trylock(raw_rwlock_t *lock)
+{
+	atomic_t *count = (atomic_t*)lock;
+	if (atomic_dec_return(count) >= 0)
+		return 1;
+	atomic_inc(count);
+	return 0;
+}

We don't have a changelog for this patch. My usual technique when this happens is to mutter something unprintable then go on a hunt through the mailing list archives.

But all I have is "Matthew Wilcox pointed out that generic__raw_read_trylock() is unfit for use.".

What's wrong with it?

#7 lore raw
Quoted 8 lines · Andrew Morton

We don't have a changelog for this patch. My usual technique when this happens is to mutter something unprintable then go on a hunt through the mailing list archives.

But all I have is "Matthew Wilcox pointed out that generic__raw_read_trylock() is unfit for use.".

What's wrong with it?

I pointed it out on linux-arch a couple of weeks ago. Ever look at the generic__raw_read_trylock implementation?

$ git-diff linus spinlock.c 
kernel/spinlock.c +0 -11
index fb524b0..6fc4c92 100644
@@ -16,17 +16,6 @@ #include <linux/interrupt.h>
 #include <linux/debug_locks.h>
 #include <linux/module.h>
 
-/*
- * Generic declaration of the raw read_trylock() function,
- * architectures are supposed to optimize this:
- */
-int __lockfunc generic__raw_read_trylock(raw_rwlock_t *lock)
-{
-       __raw_read_lock(lock);
-       return 1;
-}
-EXPORT_SYMBOL(generic__raw_read_trylock);
-
 

If the cpu has the lock held for write, is interrupted, and the interrupt handler calls read_trylock(), it's an instant deadlock.

Now, Dave Miller has subsequently pointed out that we don't have any situations where this can occur. Nevertheless, we should delete generic__raw_read_lock (and its associated EXPORT to make Arjan happy) so that nobody thinks they can use it.