* [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
@ 2005-03-11 0:06 Jody McIntyre
2005-03-11 0:08 ` [PATCH, RFC 2/3] Use sem_getcount in ieee1394 Jody McIntyre
` (2 more replies)
0 siblings, 3 replies; 14+ messages in thread
From: Jody McIntyre @ 2005-03-11 0:06 UTC (permalink / raw)
To: linux-kernel; +Cc: willy
parisc and frv define sem_getcount() in semaphore.h, which returns the
current semaphore value. This is cleaner than doing
atomic_read(&semaphore.count), currently done in
drivers/ieee1394/nodemgr.c and fs/xfs/linux-2.6/xfs_buf.c, and will work
on all architectures if sem_getcount() is added.
This patch adds sem_getcount(). I will also send patches that convert
ieee1394 and xfs to use sem_getcount(), which fixes a warning on parisc
(and presumably frv.)
Any objections?
Jody
--
Adds sem_getcount() to architectures that were missing it. Renames
sema_count on arm for this purpose (sema_count has no current callers.)
Tested on i386, ia64, parisc.
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
Index: 1394-dev/include/asm-h8300/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-h8300/semaphore.h 2005-02-10 12:39:28.000000000 -0500
+++ 1394-dev/include/asm-h8300/semaphore.h 2005-03-08 16:38:06.000000000 -0500
@@ -59,6 +59,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-sh64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sh64/semaphore.h 2005-02-10 12:39:41.000000000 -0500
+++ 1394-dev/include/asm-sh64/semaphore.h 2005-03-08 16:42:14.000000000 -0500
@@ -72,6 +72,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
#if 0
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
Index: 1394-dev/include/asm-m68knommu/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m68knommu/semaphore.h 2005-02-10 12:39:29.000000000 -0500
+++ 1394-dev/include/asm-m68knommu/semaphore.h 2005-03-08 16:39:18.000000000 -0500
@@ -59,6 +59,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-m32r/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m32r/semaphore.h 2005-02-10 12:39:28.000000000 -0500
+++ 1394-dev/include/asm-m32r/semaphore.h 2005-03-08 16:38:26.000000000 -0500
@@ -64,6 +64,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-ia64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ia64/semaphore.h 2005-02-10 12:39:28.000000000 -0500
+++ 1394-dev/include/asm-ia64/semaphore.h 2005-03-08 16:38:21.000000000 -0500
@@ -50,6 +50,11 @@ init_MUTEX_LOCKED (struct semaphore *sem
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
extern void __down (struct semaphore * sem);
extern int __down_interruptible (struct semaphore * sem);
extern int __down_trylock (struct semaphore * sem);
Index: 1394-dev/include/asm-i386/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-i386/semaphore.h 2005-02-10 12:39:28.000000000 -0500
+++ 1394-dev/include/asm-i386/semaphore.h 2005-03-08 16:13:56.000000000 -0500
@@ -87,6 +87,13 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+typedef atomic_t semcount_t;
+
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
fastcall void __down_failed(void /* special register calling convention */);
fastcall int __down_failed_interruptible(void /* params in registers */);
fastcall int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-sparc/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sparc/semaphore.h 2005-02-10 12:39:41.000000000 -0500
+++ 1394-dev/include/asm-sparc/semaphore.h 2005-03-08 16:42:37.000000000 -0500
@@ -48,6 +48,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern int __down_trylock(struct semaphore * sem);
Index: 1394-dev/include/asm-x86_64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-x86_64/semaphore.h 2005-02-10 12:39:41.000000000 -0500
+++ 1394-dev/include/asm-x86_64/semaphore.h 2005-03-08 16:43:23.000000000 -0500
@@ -88,6 +88,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-ppc/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ppc/semaphore.h 2005-02-10 12:39:40.000000000 -0500
+++ 1394-dev/include/asm-ppc/semaphore.h 2005-03-08 16:41:22.000000000 -0500
@@ -62,6 +62,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
Index: 1394-dev/include/asm-ppc64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ppc64/semaphore.h 2005-02-10 12:39:40.000000000 -0500
+++ 1394-dev/include/asm-ppc64/semaphore.h 2005-03-08 16:41:32.000000000 -0500
@@ -56,6 +56,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
Index: 1394-dev/include/asm-arm26/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-arm26/semaphore.h 2005-02-10 12:39:28.000000000 -0500
+++ 1394-dev/include/asm-arm26/semaphore.h 2005-03-08 16:36:37.000000000 -0500
@@ -51,6 +51,11 @@ static inline void init_MUTEX_LOCKED(str
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
/*
* special register calling convention
*/
Index: 1394-dev/include/asm-s390/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-s390/semaphore.h 2005-02-10 12:39:40.000000000 -0500
+++ 1394-dev/include/asm-s390/semaphore.h 2005-03-08 16:41:41.000000000 -0500
@@ -53,6 +53,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
asmlinkage void __down(struct semaphore * sem);
asmlinkage int __down_interruptible(struct semaphore * sem);
asmlinkage int __down_trylock(struct semaphore * sem);
Index: 1394-dev/include/asm-m68k/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m68k/semaphore.h 2005-02-10 12:39:28.000000000 -0500
+++ 1394-dev/include/asm-m68k/semaphore.h 2005-03-08 16:39:10.000000000 -0500
@@ -60,6 +60,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-arm/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-arm/semaphore.h 2005-02-10 12:39:27.000000000 -0500
+++ 1394-dev/include/asm-arm/semaphore.h 2005-03-08 16:36:00.000000000 -0500
@@ -49,7 +49,7 @@ static inline void init_MUTEX_LOCKED(str
sema_init(sem, 0);
}
-static inline int sema_count(struct semaphore *sem)
+static inline int sem_getcount(struct semaphore *sem)
{
return atomic_read(&sem->count);
}
Index: 1394-dev/include/asm-sparc64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sparc64/semaphore.h 2005-02-10 12:39:41.000000000 -0500
+++ 1394-dev/include/asm-sparc64/semaphore.h 2005-03-08 16:42:51.000000000 -0500
@@ -47,6 +47,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
extern void up(struct semaphore *sem);
extern void down(struct semaphore *sem);
extern int down_trylock(struct semaphore *sem);
Index: 1394-dev/include/asm-sh/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sh/semaphore.h 2005-02-10 12:39:40.000000000 -0500
+++ 1394-dev/include/asm-sh/semaphore.h 2005-03-08 16:42:04.000000000 -0500
@@ -65,6 +65,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
#if 0
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
Index: 1394-dev/include/asm-mips/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-mips/semaphore.h 2005-02-10 12:39:29.000000000 -0500
+++ 1394-dev/include/asm-mips/semaphore.h 2005-03-08 16:39:31.000000000 -0500
@@ -70,6 +70,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
Index: 1394-dev/include/asm-alpha/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-alpha/semaphore.h 2005-02-10 12:39:27.000000000 -0500
+++ 1394-dev/include/asm-alpha/semaphore.h 2005-03-08 16:13:47.000000000 -0500
@@ -57,6 +57,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem.count);
+}
+
extern void down(struct semaphore *);
extern void __down_failed(struct semaphore *);
extern int down_interruptible(struct semaphore *);
Index: 1394-dev/include/asm-cris/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-cris/semaphore.h 2005-02-10 12:39:28.000000000 -0500
+++ 1394-dev/include/asm-cris/semaphore.h 2005-03-08 16:37:12.000000000 -0500
@@ -57,6 +57,11 @@ extern inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern int __down_trylock(struct semaphore * sem);
Index: 1394-dev/include/asm-v850/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-v850/semaphore.h 2005-02-10 12:39:41.000000000 -0500
+++ 1394-dev/include/asm-v850/semaphore.h 2005-03-08 16:43:13.000000000 -0500
@@ -42,6 +42,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init (sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count);
+}
+
/*
* special register calling convention
*/
--
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 2/3] Use sem_getcount in ieee1394
2005-03-11 0:06 [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Jody McIntyre
@ 2005-03-11 0:08 ` Jody McIntyre
2005-03-11 0:10 ` [PATCH, RFC 3/3] Use sem_getcount in xfs Jody McIntyre
2005-03-11 4:55 ` [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Andrew Morton
2 siblings, 0 replies; 14+ messages in thread
From: Jody McIntyre @ 2005-03-11 0:08 UTC (permalink / raw)
To: linux-kernel; +Cc: willy
Convert 1394's node manager to use sem_getcount instead of nasty hack.
Tested on parisc (where it eliminates a warning), ia64, i386.
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
Index: 1394-dev/drivers/ieee1394/nodemgr.c
===================================================================
--- 1394-dev.orig/drivers/ieee1394/nodemgr.c 2005-03-08 16:50:40.000000000 -0500
+++ 1394-dev/drivers/ieee1394/nodemgr.c 2005-03-08 16:51:07.000000000 -0500
@@ -284,7 +284,7 @@ static DEVICE_ATTR(bus_options,S_IRUGO,f
static ssize_t fw_show_ne_tlabels_free(struct device *dev, char *buf)
{
struct node_entry *ne = container_of(dev, struct node_entry, device);
- return sprintf(buf, "%d\n", atomic_read(&ne->tpool->count.count) + 1);
+ return sprintf(buf, "%d\n", sem_getcount(&ne->tpool->count) + 1);
}
static DEVICE_ATTR(tlabels_free,S_IRUGO,fw_show_ne_tlabels_free,NULL);
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 3/3] Use sem_getcount in xfs
2005-03-11 0:06 [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Jody McIntyre
2005-03-11 0:08 ` [PATCH, RFC 2/3] Use sem_getcount in ieee1394 Jody McIntyre
@ 2005-03-11 0:10 ` Jody McIntyre
2005-03-11 4:55 ` [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Andrew Morton
2 siblings, 0 replies; 14+ messages in thread
From: Jody McIntyre @ 2005-03-11 0:10 UTC (permalink / raw)
To: linux-kernel; +Cc: willy
Convert XFS to use sem_getcount instead of nasty hack. Should fix warning
with XFS debugging on PARISC. Untested since there is no obvious way to
turn on XFS debugging.
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
Index: 1394-dev/fs/xfs/linux-2.6/xfs_buf.c
===================================================================
--- 1394-dev.orig/fs/xfs/linux-2.6/xfs_buf.c 2005-03-10 18:20:13.000000000 -0500
+++ 1394-dev/fs/xfs/linux-2.6/xfs_buf.c 2005-03-10 18:20:55.000000000 -0500
@@ -976,7 +976,7 @@ int
pagebuf_lock_value(
xfs_buf_t *pb)
{
- return(atomic_read(&pb->pb_sema.count));
+ return(sem_getcount(&pb->pb_sema));
}
#endif
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
2005-03-11 0:06 [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Jody McIntyre
2005-03-11 0:08 ` [PATCH, RFC 2/3] Use sem_getcount in ieee1394 Jody McIntyre
2005-03-11 0:10 ` [PATCH, RFC 3/3] Use sem_getcount in xfs Jody McIntyre
@ 2005-03-11 4:55 ` Andrew Morton
2005-03-11 5:10 ` Roland Dreier
2005-03-11 5:31 ` Jody McIntyre
2 siblings, 2 replies; 14+ messages in thread
From: Andrew Morton @ 2005-03-11 4:55 UTC (permalink / raw)
To: Jody McIntyre; +Cc: linux-kernel, willy, Nathan Scott
Jody McIntyre <scjody@modernduck.com> wrote:
>
> parisc and frv define sem_getcount() in semaphore.h, which returns the
> current semaphore value. This is cleaner than doing
> atomic_read(&semaphore.count), currently done in
> drivers/ieee1394/nodemgr.c and fs/xfs/linux-2.6/xfs_buf.c, and will work
> on all architectures if sem_getcount() is added.
That's a fairly bizarre thing to want to do. Would it be hard to modify
xfs and 1394 to stop wanting to read a semaphore's up() count?
(Why do they want to do this anyway?)
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
2005-03-11 4:55 ` [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Andrew Morton
@ 2005-03-11 5:10 ` Roland Dreier
2005-03-11 5:18 ` Nathan Scott
2005-03-11 5:31 ` Jody McIntyre
1 sibling, 1 reply; 14+ messages in thread
From: Roland Dreier @ 2005-03-11 5:10 UTC (permalink / raw)
To: Andrew Morton; +Cc: Jody McIntyre, linux-kernel, willy, Nathan Scott
Andrew> (Why do they want to do this anyway?)
Neither use seems really fundamental. The XFS use is explicitly
inside #ifdef DEBUG and seems to be used only for assertions.
ieee1394 is just sticking the value in a read-only sysfs attribute.
- R.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
2005-03-11 5:10 ` Roland Dreier
@ 2005-03-11 5:18 ` Nathan Scott
0 siblings, 0 replies; 14+ messages in thread
From: Nathan Scott @ 2005-03-11 5:18 UTC (permalink / raw)
To: Andrew Morton, Roland Dreier; +Cc: Jody McIntyre, linux-kernel, willy
On Thu, Mar 10, 2005 at 09:10:42PM -0800, Roland Dreier wrote:
> Andrew> (Why do they want to do this anyway?)
>
> Neither use seems really fundamental. The XFS use is explicitly
> inside #ifdef DEBUG and seems to be used only for assertions.
Right, our peeking at that value is debug-only (so usually its not
even compiled in). I wouldn't go out of your way to add a more
permanent interface just for this, we can live without it.
cheers.
--
Nathan
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
2005-03-11 4:55 ` [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Andrew Morton
2005-03-11 5:10 ` Roland Dreier
@ 2005-03-11 5:31 ` Jody McIntyre
2005-03-11 5:56 ` Andrew Morton
1 sibling, 1 reply; 14+ messages in thread
From: Jody McIntyre @ 2005-03-11 5:31 UTC (permalink / raw)
To: Andrew Morton; +Cc: linux-kernel, willy, Nathan Scott
On Thu, Mar 10, 2005 at 08:55:03PM -0800, Andrew Morton wrote:
> Jody McIntyre <scjody@modernduck.com> wrote:
> >
> > parisc and frv define sem_getcount() in semaphore.h, which returns the
> > current semaphore value. This is cleaner than doing
> > atomic_read(&semaphore.count), currently done in
> > drivers/ieee1394/nodemgr.c and fs/xfs/linux-2.6/xfs_buf.c, and will work
> > on all architectures if sem_getcount() is added.
>
> That's a fairly bizarre thing to want to do. Would it be hard to modify
> xfs and 1394 to stop wanting to read a semaphore's up() count?
The count is the number of free transaction labels (1394 async is
transaction-based) and is initialized to 64. When a new transaction label
is needed, the requestor does a down(), then locks the tlabel variables
and allocates a new one. When a transaction label is freed, an up()
occurs. The semaphore's up() count is therefore the number of free
tlabels, and the number of outstanding transactions is (64 - count). I
can imagine situations in which this would be a useful statistic, but
I'm not sure any of them actually exist.
I haven't investigated xfs, but modifying 1394 would be fairly easy. I
could add a second variable that tracks the up() count, or just drop the
sysfs attribute that reports the number. The first option seems a bit
wasteful, but only slightly. I thought this patch was worthwhile based
on xfs wanting to do this and 3 arches already having (unused)
implementations of sem_getcount/sema_count.
If this patch isn't accepted, we should get rid of the xfs and 1394
hacks and delete sem_getcount (parisc, frv) and sema_count (arm) as they
are unused.
Jody
>
> (Why do they want to do this anyway?)
--
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
2005-03-11 5:31 ` Jody McIntyre
@ 2005-03-11 5:56 ` Andrew Morton
2005-03-11 12:27 ` Matthew Wilcox
0 siblings, 1 reply; 14+ messages in thread
From: Andrew Morton @ 2005-03-11 5:56 UTC (permalink / raw)
To: Jody McIntyre; +Cc: linux-kernel, willy, nathans
Jody McIntyre <scjody@modernduck.com> wrote:
>
> On Thu, Mar 10, 2005 at 08:55:03PM -0800, Andrew Morton wrote:
> > Jody McIntyre <scjody@modernduck.com> wrote:
> > >
> > > parisc and frv define sem_getcount() in semaphore.h, which returns the
> > > current semaphore value. This is cleaner than doing
> > > atomic_read(&semaphore.count), currently done in
> > > drivers/ieee1394/nodemgr.c and fs/xfs/linux-2.6/xfs_buf.c, and will work
> > > on all architectures if sem_getcount() is added.
> >
> > That's a fairly bizarre thing to want to do. Would it be hard to modify
> > xfs and 1394 to stop wanting to read a semaphore's up() count?
>
> The count is the number of free transaction labels (1394 async is
> transaction-based) and is initialized to 64. When a new transaction label
> is needed, the requestor does a down(), then locks the tlabel variables
> and allocates a new one. When a transaction label is freed, an up()
> occurs. The semaphore's up() count is therefore the number of free
> tlabels, and the number of outstanding transactions is (64 - count). I
> can imagine situations in which this would be a useful statistic, but
> I'm not sure any of them actually exist.
That's a nice application of semaphores. I can see that there's also a
need to be able to read the value back for reporting purposes. Dang.
But I guess it's a bit hard to justify adding more infrastructure to
support a single callsite which has a simple alternative. So if you could
please add the separate counter?
> ...
>
> If this patch isn't accepted, we should get rid of the xfs and 1394
> hacks and delete sem_getcount (parisc, frv) and sema_count (arm) as they
> are unused.
True.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
2005-03-11 5:56 ` Andrew Morton
@ 2005-03-11 12:27 ` Matthew Wilcox
2005-03-11 17:04 ` Jody McIntyre
0 siblings, 1 reply; 14+ messages in thread
From: Matthew Wilcox @ 2005-03-11 12:27 UTC (permalink / raw)
To: Andrew Morton; +Cc: Jody McIntyre, linux-kernel, willy, nathans
On Thu, Mar 10, 2005 at 09:56:52PM -0800, Andrew Morton wrote:
> That's a nice application of semaphores. I can see that there's also a
> need to be able to read the value back for reporting purposes. Dang.
>
> But I guess it's a bit hard to justify adding more infrastructure to
> support a single callsite which has a simple alternative. So if you could
> please add the separate counter?
It's pretty *small* infrastructure, and it gives me something to whine at
people about when they use atomic_read on something that isn't an atomic.
> > ...
> >
> > If this patch isn't accepted, we should get rid of the xfs and 1394
> > hacks and delete sem_getcount (parisc, frv) and sema_count (arm) as they
> > are unused.
>
> True.
If we are going to get rid of sem_getcount, could we rename the 'count'
variables, at least on i386 and ppc to make it clear that you're not
supposed to do this ... maybe to 'count_$ARCH'?
--
"Next the statesmen will invent cheap lies, putting the blame upon
the nation that is attacked, and every man will be glad of those
conscience-soothing falsities, and will diligently study them, and refuse
to examine any refutations of them; and thus he will by and by convince
himself that the war is just, and will thank God for the better sleep
he enjoys after this process of grotesque self-deception." -- Mark Twain
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it
2005-03-11 12:27 ` Matthew Wilcox
@ 2005-03-11 17:04 ` Jody McIntyre
2005-03-16 19:27 ` [PATCH, RFC 1/4] Rename semaphore count variable to be arch specific Jody McIntyre
0 siblings, 1 reply; 14+ messages in thread
From: Jody McIntyre @ 2005-03-11 17:04 UTC (permalink / raw)
To: Matthew Wilcox; +Cc: Andrew Morton, linux-kernel, willy, nathans
On Fri, Mar 11, 2005 at 12:27:47PM +0000, Matthew Wilcox wrote:
> > But I guess it's a bit hard to justify adding more infrastructure to
> > support a single callsite which has a simple alternative. So if you could
> > please add the separate counter?
>
> It's pretty *small* infrastructure, and it gives me something to whine at
> people about when they use atomic_read on something that isn't an atomic.
Agreed, but I don't mind adding a separate counter. However...
> If we are going to get rid of sem_getcount, could we rename the 'count'
> variables, at least on i386 and ppc to make it clear that you're not
> supposed to do this ... maybe to 'count_$ARCH'?
I'm working on a patch to do just that. It fails when building XFS:
fs/xfs/xfs_inode_item.c: In function `xfs_inode_item_pushbuf':
fs/xfs/xfs_inode_item.c:803: error: structure has no member named `count'
fs/xfs/xfs_inode_item.c:825: error: structure has no member named `count'
fs/xfs/linux-2.6/sema.h:
#define valusema(sp) (atomic_read(&(sp)->count))
It seems getting the value of a semaphore is more common than it appears
at first glance. I don't see how this code could possibly work on
parisc. Therefore I propose:
1. Adding sem_getcount() everywhere, as in my original patch.
2. Renaming count to count_$ARCH as willy suggested.
3. Anyone who abuses semaphores will now break. Fix them to use
sem_getcount().
I'll work on that over the weekend unless anyone has any better ideas.
Jody
>
> --
> "Next the statesmen will invent cheap lies, putting the blame upon
> the nation that is attacked, and every man will be glad of those
> conscience-soothing falsities, and will diligently study them, and refuse
> to examine any refutations of them; and thus he will by and by convince
> himself that the war is just, and will thank God for the better sleep
> he enjoys after this process of grotesque self-deception." -- Mark Twain
--
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH, RFC 1/4] Rename semaphore count variable to be arch specific
2005-03-11 17:04 ` Jody McIntyre
@ 2005-03-16 19:27 ` Jody McIntyre
2005-03-16 19:28 ` [PATCH, RFC 2/4] Add sem_getcount on arches that lack it Jody McIntyre
` (2 more replies)
0 siblings, 3 replies; 14+ messages in thread
From: Jody McIntyre @ 2005-03-16 19:27 UTC (permalink / raw)
To: Matthew Wilcox; +Cc: Andrew Morton, linux-kernel, willy, nathans
On Fri, Mar 11, 2005 at 12:04:49PM -0500, Jody McIntyre wrote:
> Therefore I propose:
>
> 1. Adding sem_getcount() everywhere, as in my original patch.
> 2. Renaming count to count_$ARCH as willy suggested.
> 3. Anyone who abuses semaphores will now break. Fix them to use
> sem_getcount().
OK, here it is. Tested 3. with 'make allyesconfig' on i386 to be sure
I've caught all abuses.
--
Rename semaphore "count" members to count_$ARCH, to emphasize that this is
an opaque type and sem_getcount() should be used to retrieve the current
up() count.
Tested on i386, ia64, parisc. More testing would be good.
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
arch/sparc64/kernel/semaphore.c | 36 ++++++++++++++++++------------------
include/asm-alpha/semaphore.h | 22 +++++++++++-----------
include/asm-arm/semaphore.h | 17 ++++++-----------
include/asm-arm26/semaphore.h | 6 +++---
include/asm-cris/semaphore.h | 12 ++++++------
include/asm-frv/semaphore.h | 5 -----
include/asm-h8300/semaphore.h | 12 ++++++------
include/asm-i386/semaphore.h | 22 +++++++++++-----------
include/asm-ia64/semaphore.h | 12 ++++++------
include/asm-m32r/semaphore.h | 14 +++++++-------
include/asm-m68k/semaphore.h | 4 ++--
include/asm-m68knommu/semaphore.h | 12 ++++++------
include/asm-mips/semaphore.h | 14 +++++++-------
include/asm-parisc/semaphore.h | 5 -----
include/asm-ppc/semaphore.h | 14 +++++++-------
include/asm-ppc64/semaphore.h | 14 +++++++-------
include/asm-s390/semaphore.h | 12 ++++++------
include/asm-sh/semaphore.h | 14 +++++++-------
include/asm-sh64/semaphore.h | 14 +++++++-------
include/asm-sparc/semaphore.h | 14 +++++++-------
include/asm-sparc64/semaphore.h | 4 ++--
include/asm-v850/semaphore.h | 10 +++++-----
include/asm-x86_64/semaphore.h | 20 ++++++++++----------
23 files changed, 147 insertions(+), 162 deletions(-)
Index: 1394-dev/include/asm-h8300/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-h8300/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-h8300/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -23,14 +23,14 @@
struct semaphore {
- atomic_t count;
+ atomic_t count_h8300;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_h8300 = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -82,7 +82,7 @@ static inline void down(struct semaphore
might_sleep();
- count = &(sem->count);
+ count = &(sem->count_h8300);
__asm__ __volatile__(
"stc ccr,r3l\n\t"
"orc #0x80,ccr\n\t"
@@ -108,7 +108,7 @@ static inline int down_interruptible(str
might_sleep();
- count = &(sem->count);
+ count = &(sem->count_h8300);
__asm__ __volatile__(
"stc ccr,r1l\n\t"
"orc #0x80,ccr\n\t"
@@ -134,7 +134,7 @@ static inline int down_trylock(struct se
{
register atomic_t *count asm("er0");
- count = &(sem->count);
+ count = &(sem->count_h8300);
__asm__ __volatile__(
"stc ccr,r3l\n\t"
"orc #0x80,ccr\n\t"
@@ -170,7 +170,7 @@ static inline void up(struct semaphore *
{
register atomic_t *count asm("er0");
- count = &(sem->count);
+ count = &(sem->count_h8300);
__asm__ __volatile__(
"stc ccr,r3l\n\t"
"orc #0x80,ccr\n\t"
Index: 1394-dev/arch/sparc64/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/sparc64/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/sparc64/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -11,12 +11,12 @@
#include <linux/init.h>
/*
- * Atomically update sem->count.
+ * Atomically update sem->count_sparc64.
* This does the equivalent of the following:
*
- * old_count = sem->count;
+ * old_count = sem->count_sparc64;
* tmp = MAX(old_count, 0) + incr;
- * sem->count = tmp;
+ * sem->count_sparc64 = tmp;
* return old_count;
*/
static __inline__ int __sem_update_count(struct semaphore *sem, int incr)
@@ -24,7 +24,7 @@ static __inline__ int __sem_update_count
int old_count, tmp;
__asm__ __volatile__("\n"
-" ! __sem_update_count old_count(%0) tmp(%1) incr(%4) &sem->count(%3)\n"
+" ! __sem_update_count old_count(%0) tmp(%1) incr(%4) &sem->count_sparc64(%3)\n"
"1: ldsw [%3], %0\n"
" mov %0, %1\n"
" cmp %0, 0\n"
@@ -34,8 +34,8 @@ static __inline__ int __sem_update_count
" cmp %0, %1\n"
" bne,pn %%icc, 1b\n"
" membar #StoreLoad | #StoreStore\n"
- : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
- : "r" (&sem->count), "r" (incr), "m" (sem->count)
+ : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count_sparc64)
+ : "r" (&sem->count_sparc64), "r" (incr), "m" (sem->count_sparc64)
: "cc");
return old_count;
@@ -50,9 +50,9 @@ static void __up(struct semaphore *sem)
void up(struct semaphore *sem)
{
/* This atomically does:
- * old_val = sem->count;
- * new_val = sem->count + 1;
- * sem->count = new_val;
+ * old_val = sem->count_sparc64;
+ * new_val = sem->count_sparc64 + 1;
+ * sem->count_sparc64 = new_val;
* if (old_val < 0)
* __up(sem);
*
@@ -113,9 +113,9 @@ void __sched down(struct semaphore *sem)
{
might_sleep();
/* This atomically does:
- * old_val = sem->count;
- * new_val = sem->count - 1;
- * sem->count = new_val;
+ * old_val = sem->count_sparc64;
+ * new_val = sem->count_sparc64 - 1;
+ * sem->count_sparc64 = new_val;
* if (old_val < 1)
* __down(sem);
*
@@ -158,12 +158,12 @@ int down_trylock(struct semaphore *sem)
int ret;
/* This atomically does:
- * old_val = sem->count;
- * new_val = sem->count - 1;
+ * old_val = sem->count_sparc64;
+ * new_val = sem->count_sparc64 - 1;
* if (old_val < 1) {
* ret = 1;
* } else {
- * sem->count = new_val;
+ * sem->count_sparc64 = new_val;
* ret = 0;
* }
*
@@ -223,9 +223,9 @@ int __sched down_interruptible(struct se
might_sleep();
/* This atomically does:
- * old_val = sem->count;
- * new_val = sem->count - 1;
- * sem->count = new_val;
+ * old_val = sem->count_sparc64;
+ * new_val = sem->count_sparc64 - 1;
+ * sem->count_sparc64 = new_val;
* if (old_val < 1)
* ret = __down_interruptible(sem);
*
Index: 1394-dev/include/asm-sh64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sh64/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-sh64/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -28,14 +28,14 @@
#include <asm/atomic.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_sh64;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_sh64 = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -57,7 +57,7 @@ static inline void sema_init (struct sem
* i'd rather use the more flexible initialization above, but sadly
* GCC 2.7.2.3 emits a bogus warning. EGCS doesnt. Oh well.
*/
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_sh64, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
@@ -88,7 +88,7 @@ extern spinlock_t semaphore_wake_lock;
static inline void down(struct semaphore * sem)
{
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_sh64) < 0)
__down(sem);
}
@@ -96,7 +96,7 @@ static inline int down_interruptible(str
{
int ret = 0;
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_sh64) < 0)
ret = __down_interruptible(sem);
return ret;
}
@@ -105,7 +105,7 @@ static inline int down_trylock(struct se
{
int ret = 0;
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_sh64) < 0)
ret = __down_trylock(sem);
return ret;
}
@@ -116,7 +116,7 @@ static inline int down_trylock(struct se
*/
static inline void up(struct semaphore * sem)
{
- if (atomic_inc_return(&sem->count) <= 0)
+ if (atomic_inc_return(&sem->count_sh64) <= 0)
__up(sem);
}
Index: 1394-dev/include/asm-m68knommu/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m68knommu/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-m68knommu/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -23,16 +23,16 @@
struct semaphore {
- atomic_t count;
+ atomic_t count_m68knommu;
atomic_t waking;
wait_queue_head_t wait;
};
-#define __SEMAPHORE_INITIALIZER(name, n) \
-{ \
- .count = ATOMIC_INIT(n), \
- .waking = ATOMIC_INIT(0), \
- .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
+#define __SEMAPHORE_INITIALIZER(name, n) \
+{ \
+ .count_m68knommu = ATOMIC_INIT(n), \
+ .waking = ATOMIC_INIT(0), \
+ .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
#define __MUTEX_INITIALIZER(name) \
Index: 1394-dev/include/asm-m32r/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m32r/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-m32r/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -20,14 +20,14 @@
#include <asm/atomic.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_m32r;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_m32r = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -49,7 +49,7 @@ static inline void sema_init (struct sem
* i'd rather use the more flexible initialization above, but sadly
* GCC 2.7.2.3 emits a bogus warning. EGCS doesnt. Oh well.
*/
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_m32r, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
@@ -92,7 +92,7 @@ static inline void down(struct semaphore
"addi %0, #-1; \n\t"
M32R_UNLOCK" %0, @%1; \n\t"
: "=&r" (count)
- : "r" (&sem->count)
+ : "r" (&sem->count_m32r)
: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
, "r4"
@@ -123,7 +123,7 @@ static inline int down_interruptible(str
"addi %0, #-1; \n\t"
M32R_UNLOCK" %0, @%1; \n\t"
: "=&r" (count)
- : "r" (&sem->count)
+ : "r" (&sem->count_m32r)
: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
, "r4"
@@ -155,7 +155,7 @@ static inline int down_trylock(struct se
"addi %0, #-1; \n\t"
M32R_UNLOCK" %0, @%1; \n\t"
: "=&r" (count)
- : "r" (&sem->count)
+ : "r" (&sem->count_m32r)
: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
, "r4"
@@ -188,7 +188,7 @@ static inline void up(struct semaphore *
"addi %0, #1; \n\t"
M32R_UNLOCK" %0, @%1; \n\t"
: "=&r" (count)
- : "r" (&sem->count)
+ : "r" (&sem->count_m32r)
: "memory"
#ifdef CONFIG_CHIP_M32700_TS1
, "r4"
Index: 1394-dev/include/asm-ia64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ia64/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-ia64/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -12,14 +12,14 @@
#include <asm/atomic.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_ia64;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_ia64 = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -63,7 +63,7 @@ static inline void
down (struct semaphore *sem)
{
might_sleep();
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_ia64) < 0)
__down(sem);
}
@@ -77,7 +77,7 @@ down_interruptible (struct semaphore * s
int ret = 0;
might_sleep();
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_ia64) < 0)
ret = __down_interruptible(sem);
return ret;
}
@@ -87,7 +87,7 @@ down_trylock (struct semaphore *sem)
{
int ret = 0;
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_ia64) < 0)
ret = __down_trylock(sem);
return ret;
}
@@ -95,7 +95,7 @@ down_trylock (struct semaphore *sem)
static inline void
up (struct semaphore * sem)
{
- if (atomic_inc_return(&sem->count) <= 0)
+ if (atomic_inc_return(&sem->count_ia64) <= 0)
__up(sem);
}
Index: 1394-dev/include/asm-i386/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-i386/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-i386/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -42,7 +42,7 @@
#include <linux/rwsem.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_i386;
int sleepers;
wait_queue_head_t wait;
};
@@ -50,7 +50,7 @@ struct semaphore {
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_i386 = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -72,7 +72,7 @@ static inline void sema_init (struct sem
* i'd rather use the more flexible initialization above, but sadly
* GCC 2.7.2.3 emits a bogus warning. EGCS doesn't. Oh well.
*/
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_i386, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
@@ -107,7 +107,7 @@ static inline void down(struct semaphore
might_sleep();
__asm__ __volatile__(
"# atomic down operation\n\t"
- LOCK "decl %0\n\t" /* --sem->count */
+ LOCK "decl %0\n\t" /* --sem->count_i386 */
"js 2f\n"
"1:\n"
LOCK_SECTION_START("")
@@ -115,7 +115,7 @@ static inline void down(struct semaphore
"call __down_failed\n\t"
"jmp 1b\n"
LOCK_SECTION_END
- :"=m" (sem->count)
+ :"=m" (sem->count_i386)
:
:"memory","ax");
}
@@ -131,7 +131,7 @@ static inline int down_interruptible(str
might_sleep();
__asm__ __volatile__(
"# atomic interruptible down operation\n\t"
- LOCK "decl %1\n\t" /* --sem->count */
+ LOCK "decl %1\n\t" /* --sem->count_i386 */
"js 2f\n\t"
"xorl %0,%0\n"
"1:\n"
@@ -140,7 +140,7 @@ static inline int down_interruptible(str
"call __down_failed_interruptible\n\t"
"jmp 1b\n"
LOCK_SECTION_END
- :"=a" (result), "=m" (sem->count)
+ :"=a" (result), "=m" (sem->count_i386)
:
:"memory");
return result;
@@ -156,7 +156,7 @@ static inline int down_trylock(struct se
__asm__ __volatile__(
"# atomic interruptible down operation\n\t"
- LOCK "decl %1\n\t" /* --sem->count */
+ LOCK "decl %1\n\t" /* --sem->count_i386 */
"js 2f\n\t"
"xorl %0,%0\n"
"1:\n"
@@ -165,7 +165,7 @@ static inline int down_trylock(struct se
"call __down_failed_trylock\n\t"
"jmp 1b\n"
LOCK_SECTION_END
- :"=a" (result), "=m" (sem->count)
+ :"=a" (result), "=m" (sem->count_i386)
:
:"memory");
return result;
@@ -181,7 +181,7 @@ static inline void up(struct semaphore *
{
__asm__ __volatile__(
"# atomic up operation\n\t"
- LOCK "incl %0\n\t" /* ++sem->count */
+ LOCK "incl %0\n\t" /* ++sem->count_i386 */
"jle 2f\n"
"1:\n"
LOCK_SECTION_START("")
@@ -190,7 +190,7 @@ static inline void up(struct semaphore *
"jmp 1b\n"
LOCK_SECTION_END
".subsection 0\n"
- :"=m" (sem->count)
+ :"=m" (sem->count_i386)
:
:"memory","ax");
}
Index: 1394-dev/include/asm-sparc/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sparc/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-sparc/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -10,14 +10,14 @@
#include <linux/rwsem.h>
struct semaphore {
- atomic24_t count;
+ atomic24_t count_sparc;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC24_INIT(n), \
+ .count_sparc = ATOMIC24_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -33,7 +33,7 @@ struct semaphore {
static inline void sema_init (struct semaphore *sem, int val)
{
- atomic24_set(&sem->count, val);
+ atomic24_set(&sem->count_sparc, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
@@ -60,7 +60,7 @@ static inline void down(struct semaphore
might_sleep();
- ptr = &(sem->count.counter);
+ ptr = &(sem->count_sparc.counter);
increment = 1;
__asm__ __volatile__(
@@ -94,7 +94,7 @@ static inline int down_interruptible(str
might_sleep();
- ptr = &(sem->count.counter);
+ ptr = &(sem->count_sparc.counter);
increment = 1;
__asm__ __volatile__(
@@ -129,7 +129,7 @@ static inline int down_trylock(struct se
register volatile int *ptr asm("g1");
register int increment asm("g2");
- ptr = &(sem->count.counter);
+ ptr = &(sem->count_sparc.counter);
increment = 1;
__asm__ __volatile__(
@@ -164,7 +164,7 @@ static inline void up(struct semaphore *
register volatile int *ptr asm("g1");
register int increment asm("g2");
- ptr = &(sem->count.counter);
+ ptr = &(sem->count_sparc.counter);
increment = 1;
__asm__ __volatile__(
Index: 1394-dev/include/asm-x86_64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-x86_64/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-x86_64/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -44,14 +44,14 @@
#include <linux/stringify.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_x86_64;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_x86_64 = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -73,7 +73,7 @@ static inline void sema_init (struct sem
* i'd rather use the more flexible initialization above, but sadly
* GCC 2.7.2.3 emits a bogus warning. EGCS doesn't. Oh well.
*/
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_x86_64, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
@@ -116,7 +116,7 @@ static inline void down(struct semaphore
"2:\tcall __down_failed\n\t"
"jmp 1b\n"
LOCK_SECTION_END
- :"=m" (sem->count)
+ :"=m" (sem->count_x86_64)
:"D" (sem)
:"memory");
}
@@ -133,7 +133,7 @@ static inline int down_interruptible(str
__asm__ __volatile__(
"# atomic interruptible down operation\n\t"
- LOCK "decl %1\n\t" /* --sem->count */
+ LOCK "decl %1\n\t" /* --sem->count_x86_64 */
"js 2f\n\t"
"xorl %0,%0\n"
"1:\n"
@@ -141,7 +141,7 @@ static inline int down_interruptible(str
"2:\tcall __down_failed_interruptible\n\t"
"jmp 1b\n"
LOCK_SECTION_END
- :"=a" (result), "=m" (sem->count)
+ :"=a" (result), "=m" (sem->count_x86_64)
:"D" (sem)
:"memory");
return result;
@@ -157,7 +157,7 @@ static inline int down_trylock(struct se
__asm__ __volatile__(
"# atomic interruptible down operation\n\t"
- LOCK "decl %1\n\t" /* --sem->count */
+ LOCK "decl %1\n\t" /* --sem->count_x86_64 */
"js 2f\n\t"
"xorl %0,%0\n"
"1:\n"
@@ -165,7 +165,7 @@ static inline int down_trylock(struct se
"2:\tcall __down_failed_trylock\n\t"
"jmp 1b\n"
LOCK_SECTION_END
- :"=a" (result), "=m" (sem->count)
+ :"=a" (result), "=m" (sem->count_x86_64)
:"D" (sem)
:"memory","cc");
return result;
@@ -181,14 +181,14 @@ static inline void up(struct semaphore *
{
__asm__ __volatile__(
"# atomic up operation\n\t"
- LOCK "incl %0\n\t" /* ++sem->count */
+ LOCK "incl %0\n\t" /* ++sem->count_x86_64 */
"jle 2f\n"
"1:\n"
LOCK_SECTION_START("")
"2:\tcall __up_wakeup\n\t"
"jmp 1b\n"
LOCK_SECTION_END
- :"=m" (sem->count)
+ :"=m" (sem->count_x86_64)
:"D" (sem)
:"memory");
}
Index: 1394-dev/include/asm-ppc/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ppc/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-ppc/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -27,13 +27,13 @@ struct semaphore {
* but additionally indicates that some process(es) might be
* sleeping on `wait'.
*/
- atomic_t count;
+ atomic_t count_ppc;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_ppc = ATOMIC_INIT(n), \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -48,7 +48,7 @@ struct semaphore {
static inline void sema_init (struct semaphore *sem, int val)
{
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_ppc, val);
init_waitqueue_head(&sem->wait);
}
@@ -73,7 +73,7 @@ extern inline void down(struct semaphore
/*
* Try to get the semaphore, take the slow path if we fail.
*/
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_ppc) < 0)
__down(sem);
smp_wmb();
}
@@ -84,7 +84,7 @@ extern inline int down_interruptible(str
might_sleep();
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_ppc) < 0)
ret = __down_interruptible(sem);
smp_wmb();
return ret;
@@ -94,7 +94,7 @@ extern inline int down_trylock(struct se
{
int ret;
- ret = atomic_dec_if_positive(&sem->count) < 0;
+ ret = atomic_dec_if_positive(&sem->count_ppc) < 0;
smp_wmb();
return ret;
}
@@ -102,7 +102,7 @@ extern inline int down_trylock(struct se
extern inline void up(struct semaphore * sem)
{
smp_wmb();
- if (atomic_inc_return(&sem->count) <= 0)
+ if (atomic_inc_return(&sem->count_ppc) <= 0)
__up(sem);
}
Index: 1394-dev/include/asm-ppc64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ppc64/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-ppc64/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -21,13 +21,13 @@ struct semaphore {
* but additionally indicates that some process(es) might be
* sleeping on `wait'.
*/
- atomic_t count;
+ atomic_t count_ppc64;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_ppc64 = ATOMIC_INIT(n), \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -42,7 +42,7 @@ struct semaphore {
static inline void sema_init (struct semaphore *sem, int val)
{
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_ppc64, val);
init_waitqueue_head(&sem->wait);
}
@@ -67,7 +67,7 @@ static inline void down(struct semaphore
/*
* Try to get the semaphore, take the slow path if we fail.
*/
- if (unlikely(atomic_dec_return(&sem->count) < 0))
+ if (unlikely(atomic_dec_return(&sem->count_ppc64) < 0))
__down(sem);
}
@@ -77,19 +77,19 @@ static inline int down_interruptible(str
might_sleep();
- if (unlikely(atomic_dec_return(&sem->count) < 0))
+ if (unlikely(atomic_dec_return(&sem->count_ppc64) < 0))
ret = __down_interruptible(sem);
return ret;
}
static inline int down_trylock(struct semaphore * sem)
{
- return atomic_dec_if_positive(&sem->count) < 0;
+ return atomic_dec_if_positive(&sem->count_ppc64) < 0;
}
static inline void up(struct semaphore * sem)
{
- if (unlikely(atomic_inc_return(&sem->count) <= 0))
+ if (unlikely(atomic_inc_return(&sem->count_ppc64) <= 0))
__up(sem);
}
Index: 1394-dev/include/asm-arm26/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-arm26/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-arm26/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -13,14 +13,14 @@
#include <asm/locks.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_arm;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INIT(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_arm = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
}
@@ -36,7 +36,7 @@ struct semaphore {
static inline void sema_init(struct semaphore *sem, int val)
{
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_arm, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
Index: 1394-dev/include/asm-s390/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-s390/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-s390/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -22,7 +22,7 @@ struct semaphore {
* but additionally indicates that some process(es) might be
* sleeping on `wait'.
*/
- atomic_t count;
+ atomic_t count_s390;
wait_queue_head_t wait;
};
@@ -61,7 +61,7 @@ asmlinkage void __up(struct semaphore *
static inline void down(struct semaphore * sem)
{
might_sleep();
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_s390) < 0)
__down(sem);
}
@@ -70,7 +70,7 @@ static inline int down_interruptible(str
int ret = 0;
might_sleep();
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_s390) < 0)
ret = __down_interruptible(sem);
return ret;
}
@@ -95,15 +95,15 @@ static inline int down_trylock(struct se
" cs %0,%1,0(%3)\n"
" jl 0b\n"
"1:"
- : "=&d" (old_val), "=&d" (new_val), "=m" (sem->count.counter)
- : "a" (&sem->count.counter), "m" (sem->count.counter)
+ : "=&d" (old_val), "=&d" (new_val), "=m" (sem->count_s390.counter)
+ : "a" (&sem->count_s390.counter), "m" (sem->count_s390.counter)
: "cc", "memory" );
return old_val <= 0;
}
static inline void up(struct semaphore * sem)
{
- if (atomic_inc_return(&sem->count) <= 0)
+ if (atomic_inc_return(&sem->count_s390) <= 0)
__up(sem);
}
Index: 1394-dev/include/asm-m68k/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m68k/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-m68k/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -24,14 +24,14 @@
struct semaphore {
- atomic_t count;
+ atomic_t count_m68k;
atomic_t waking;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_m68k = ATOMIC_INIT(n), \
.waking = ATOMIC_INIT(0), \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
Index: 1394-dev/include/asm-arm/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-arm/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-arm/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -13,15 +13,15 @@
#include <asm/locks.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_arm;
int sleepers;
wait_queue_head_t wait;
};
-#define __SEMAPHORE_INIT(name, cnt) \
-{ \
- .count = ATOMIC_INIT(cnt), \
- .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
+#define __SEMAPHORE_INIT(name, cnt) \
+{ \
+ .count_arm = ATOMIC_INIT(cnt), \
+ .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
}
#define __MUTEX_INITIALIZER(name) __SEMAPHORE_INIT(name,1)
@@ -34,7 +34,7 @@ struct semaphore {
static inline void sema_init(struct semaphore *sem, int val)
{
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_arm, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
Index: 1394-dev/include/asm-sparc64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sparc64/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-sparc64/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -14,7 +14,7 @@
#include <linux/rwsem.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_sparc64;
wait_queue_head_t wait;
};
@@ -33,7 +33,7 @@ struct semaphore {
static inline void sema_init (struct semaphore *sem, int val)
{
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_sparc64, val);
init_waitqueue_head(&sem->wait);
}
Index: 1394-dev/include/asm-sh/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sh/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-sh/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -21,14 +21,14 @@
#include <asm/atomic.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_sh;
int sleepers;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_sh = ATOMIC_INIT(n), \
.sleepers = 0, \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -50,7 +50,7 @@ static inline void sema_init (struct sem
* i'd rather use the more flexible initialization above, but sadly
* GCC 2.7.2.3 emits a bogus warning. EGCS doesn't. Oh well.
*/
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_sh, val);
sem->sleepers = 0;
init_waitqueue_head(&sem->wait);
}
@@ -82,7 +82,7 @@ extern spinlock_t semaphore_wake_lock;
static inline void down(struct semaphore * sem)
{
might_sleep();
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_sh) < 0)
__down(sem);
}
@@ -91,7 +91,7 @@ static inline int down_interruptible(str
int ret = 0;
might_sleep();
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_sh) < 0)
ret = __down_interruptible(sem);
return ret;
}
@@ -100,7 +100,7 @@ static inline int down_trylock(struct se
{
int ret = 0;
- if (atomic_dec_return(&sem->count) < 0)
+ if (atomic_dec_return(&sem->count_sh) < 0)
ret = __down_trylock(sem);
return ret;
}
@@ -111,7 +111,7 @@ static inline int down_trylock(struct se
*/
static inline void up(struct semaphore * sem)
{
- if (atomic_inc_return(&sem->count) <= 0)
+ if (atomic_inc_return(&sem->count_sh) <= 0)
__up(sem);
}
Index: 1394-dev/include/asm-mips/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-mips/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-mips/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -35,13 +35,13 @@ struct semaphore {
* but additionally indicates that some process(es) might be
* sleeping on `wait'.
*/
- atomic_t count;
+ atomic_t count_mips;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_mips = ATOMIC_INIT(n), \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -56,7 +56,7 @@ struct semaphore {
static inline void sema_init (struct semaphore *sem, int val)
{
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_mips, val);
init_waitqueue_head(&sem->wait);
}
@@ -81,7 +81,7 @@ static inline void down(struct semaphore
/*
* Try to get the semaphore, take the slow path if we fail.
*/
- if (unlikely(atomic_dec_return(&sem->count) < 0))
+ if (unlikely(atomic_dec_return(&sem->count_mips) < 0))
__down(sem);
}
@@ -91,19 +91,19 @@ static inline int down_interruptible(str
might_sleep();
- if (unlikely(atomic_dec_return(&sem->count) < 0))
+ if (unlikely(atomic_dec_return(&sem->count_mips) < 0))
ret = __down_interruptible(sem);
return ret;
}
static inline int down_trylock(struct semaphore * sem)
{
- return atomic_dec_if_positive(&sem->count) < 0;
+ return atomic_dec_if_positive(&sem->count_mips) < 0;
}
static inline void up(struct semaphore * sem)
{
- if (unlikely(atomic_inc_return(&sem->count) <= 0))
+ if (unlikely(atomic_inc_return(&sem->count_mips) <= 0))
__up(sem);
}
Index: 1394-dev/include/asm-alpha/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-alpha/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-alpha/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -16,14 +16,14 @@
#include <linux/rwsem.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_alpha;
wait_queue_head_t wait;
};
-#define __SEMAPHORE_INITIALIZER(name, n) \
-{ \
- .count = ATOMIC_INIT(n), \
- .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
+#define __SEMAPHORE_INITIALIZER(name, n) \
+{ \
+ .count_alpha = ATOMIC_INIT(n), \
+ .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
}
#define __MUTEX_INITIALIZER(name) \
@@ -43,7 +43,7 @@ static inline void sema_init(struct sema
* except that gcc produces better initializing by parts yet.
*/
- atomic_set(&sem->count, val);
+ atomic_set(&sem->count_alpha, val);
init_waitqueue_head(&sem->wait);
}
@@ -75,7 +75,7 @@ static inline void __down(struct semapho
{
long count;
might_sleep();
- count = atomic_dec_return(&sem->count);
+ count = atomic_dec_return(&sem->count_alpha);
if (unlikely(count < 0))
__down_failed(sem);
}
@@ -84,7 +84,7 @@ static inline int __down_interruptible(s
{
long count;
might_sleep();
- count = atomic_dec_return(&sem->count);
+ count = atomic_dec_return(&sem->count_alpha);
if (unlikely(count < 0))
return __down_failed_interruptible(sem);
return 0;
@@ -119,15 +119,15 @@ static inline int __down_trylock(struct
".subsection 2\n"
"3: br 1b\n"
".previous"
- : "=&r" (ret), "=m" (sem->count)
- : "m" (sem->count));
+ : "=&r" (ret), "=m" (sem->count_alpha)
+ : "m" (sem->count_alpha));
return ret < 0;
}
static inline void __up(struct semaphore *sem)
{
- if (unlikely(atomic_inc_return(&sem->count) <= 0))
+ if (unlikely(atomic_inc_return(&sem->count_alpha) <= 0))
__up_wakeup(sem);
}
Index: 1394-dev/include/asm-frv/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-frv/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-frv/semaphore.h 2005-03-15 17:26:42.000000000 -0500
@@ -71,6 +71,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return sem->count_frv;
+}
+
extern void __down(struct semaphore *sem, unsigned long flags);
extern int __down_interruptible(struct semaphore *sem, unsigned long flags);
extern void __up(struct semaphore *sem);
@@ -151,11 +156,6 @@ static inline void up(struct semaphore *
spin_unlock_irqrestore(&sem->wait_lock, flags);
}
-static inline int sem_getcount(struct semaphore *sem)
-{
- return sem->counter;
-}
-
#endif /* __ASSEMBLY__ */
#endif
Index: 1394-dev/include/asm-cris/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-cris/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-cris/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -21,14 +21,14 @@
int printk(const char *fmt, ...);
struct semaphore {
- atomic_t count;
+ atomic_t count_cris;
atomic_t waking;
wait_queue_head_t wait;
};
#define __SEMAPHORE_INITIALIZER(name, n) \
{ \
- .count = ATOMIC_INIT(n), \
+ .count_cris = ATOMIC_INIT(n), \
.waking = ATOMIC_INIT(0), \
.wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
}
@@ -74,7 +74,7 @@ extern inline void down(struct semaphore
/* atomically decrement the semaphores count, and if its negative, we wait */
local_save_flags(flags);
local_irq_disable();
- failed = --(sem->count.counter) < 0;
+ failed = --(sem->count_cris.counter) < 0;
local_irq_restore(flags);
if(failed) {
__down(sem);
@@ -97,7 +97,7 @@ extern inline int down_interruptible(str
/* atomically decrement the semaphores count, and if its negative, we wait */
local_save_flags(flags);
local_irq_disable();
- failed = --(sem->count.counter) < 0;
+ failed = --(sem->count_cris.counter) < 0;
local_irq_restore(flags);
if(failed)
failed = __down_interruptible(sem);
@@ -111,7 +111,7 @@ extern inline int down_trylock(struct se
local_save_flags(flags);
local_irq_disable();
- failed = --(sem->count.counter) < 0;
+ failed = --(sem->count_cris.counter) < 0;
local_irq_restore(flags);
if(failed)
failed = __down_trylock(sem);
@@ -132,7 +132,7 @@ extern inline void up(struct semaphore *
/* atomically increment the semaphores count, and if it was negative, we wake people */
local_save_flags(flags);
local_irq_disable();
- wakeup = ++(sem->count.counter) <= 0;
+ wakeup = ++(sem->count_cris.counter) <= 0;
local_irq_restore(flags);
if(wakeup) {
__up(sem);
Index: 1394-dev/include/asm-v850/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-v850/semaphore.h 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/include/asm-v850/semaphore.h 2005-03-15 17:29:24.000000000 -0500
@@ -9,7 +9,7 @@
#include <asm/atomic.h>
struct semaphore {
- atomic_t count;
+ atomic_t count_v850;
int sleepers;
wait_queue_head_t wait;
};
@@ -58,7 +58,7 @@ extern void __up (struct semaphore * sem
extern inline void down (struct semaphore * sem)
{
might_sleep();
- if (atomic_dec_return (&sem->count) < 0)
+ if (atomic_dec_return (&sem->count_v850) < 0)
__down (sem);
}
@@ -66,7 +66,7 @@ extern inline int down_interruptible (st
{
int ret = 0;
might_sleep();
- if (atomic_dec_return (&sem->count) < 0)
+ if (atomic_dec_return (&sem->count_v850) < 0)
ret = __down_interruptible (sem);
return ret;
}
@@ -74,14 +74,14 @@ extern inline int down_interruptible (st
extern inline int down_trylock (struct semaphore *sem)
{
int ret = 0;
- if (atomic_dec_return (&sem->count) < 0)
+ if (atomic_dec_return (&sem->count_v850) < 0)
ret = __down_trylock (sem);
return ret;
}
extern inline void up (struct semaphore * sem)
{
- if (atomic_inc_return (&sem->count) <= 0)
+ if (atomic_inc_return (&sem->count_v850) <= 0)
__up (sem);
}
Index: 1394-dev/arch/i386/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/i386/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/i386/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -73,7 +73,7 @@ fastcall void __sched __down(struct sema
* playing, because we own the spinlock in
* the wait_queue_head.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_i386)) {
sem->sleepers = 0;
break;
}
@@ -116,7 +116,7 @@ fastcall int __sched __down_interruptibl
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic_add(sleepers, &sem->count);
+ atomic_add(sleepers, &sem->count_i386);
break;
}
@@ -126,7 +126,7 @@ fastcall int __sched __down_interruptibl
* wait_queue_head. The "-1" is because we're
* still hoping to get the semaphore.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_i386)) {
sem->sleepers = 0;
break;
}
@@ -168,7 +168,7 @@ fastcall int __down_trylock(struct semap
* playing, because we own the spinlock in the
* wait_queue_head.
*/
- if (!atomic_add_negative(sleepers, &sem->count)) {
+ if (!atomic_add_negative(sleepers, &sem->count_i386)) {
wake_up_locked(&sem->wait);
}
Index: 1394-dev/arch/mips/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/mips/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/mips/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -24,16 +24,16 @@
#include <asm/semaphore.h>
#include <asm/war.h>
/*
- * Atomically update sem->count.
+ * Atomically update sem->count_mips.
* This does the equivalent of the following:
*
- * old_count = sem->count;
+ * old_count = sem->count_mips;
* tmp = MAX(old_count, 0) + incr;
- * sem->count = tmp;
+ * sem->count_mips = tmp;
* return old_count;
*
* On machines without lld/scd we need a spinlock to make the manipulation of
- * sem->count and sem->waking atomic. Scalability isn't an issue because
+ * sem->count_mips and sem->waking atomic. Scalability isn't an issue because
* this lock is used on UP only so it's just an empty variable.
*/
static inline int __sem_update_count(struct semaphore *sem, int incr)
@@ -49,8 +49,8 @@ static inline int __sem_update_count(str
" add %1, %1, %3 \n"
" sc %1, %2 \n"
" beqzl %1, 1b \n"
- : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
- : "r" (incr), "m" (sem->count));
+ : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count_mips)
+ : "r" (incr), "m" (sem->count_mips));
} else if (cpu_has_llsc) {
__asm__ __volatile__(
"1: ll %0, %2 \n"
@@ -60,16 +60,16 @@ static inline int __sem_update_count(str
" add %1, %1, %3 \n"
" sc %1, %2 \n"
" beqz %1, 1b \n"
- : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
- : "r" (incr), "m" (sem->count));
+ : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count_mips)
+ : "r" (incr), "m" (sem->count_mips));
} else {
static DEFINE_SPINLOCK(semaphore_lock);
unsigned long flags;
spin_lock_irqsave(&semaphore_lock, flags);
- old_count = atomic_read(&sem->count);
+ old_count = atomic_read(&sem->count_mips);
tmp = max_t(int, old_count, 0) + incr;
- atomic_set(&sem->count, tmp);
+ atomic_set(&sem->count_mips, tmp);
spin_unlock_irqrestore(&semaphore_lock, flags);
}
@@ -144,7 +144,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
/*
* A signal is pending - give up trying.
- * Set sem->count to 0 if it is negative,
+ * Set sem->count_mips to 0 if it is negative,
* since we are no longer sleeping.
*/
__sem_update_count(sem, 0);
Index: 1394-dev/arch/arm/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/arm/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/arm/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -72,7 +72,7 @@ void __sched __down(struct semaphore * s
* Add "everybody else" into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_arm)) {
sem->sleepers = 0;
break;
}
@@ -112,7 +112,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic_add(sleepers, &sem->count);
+ atomic_add(sleepers, &sem->count_arm);
break;
}
@@ -122,7 +122,7 @@ int __sched __down_interruptible(struct
* "-1" is because we're still hoping to get
* the lock.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_arm)) {
sem->sleepers = 0;
break;
}
@@ -161,7 +161,7 @@ int __down_trylock(struct semaphore * se
* Add "everybody else" and us into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic_add_negative(sleepers, &sem->count))
+ if (!atomic_add_negative(sleepers, &sem->count_arm))
wake_up(&sem->wait);
spin_unlock_irqrestore(&semaphore_lock, flags);
Index: 1394-dev/arch/m68knommu/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/m68knommu/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/m68knommu/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -75,8 +75,8 @@ void __up(struct semaphore *sem)
add_wait_queue(&sem->wait, &wait); \
\
/* \
- * Ok, we're set up. sem->count is known to be less than zero \
- * so we must wait. \
+ * Ok, we're set up. sem->count_m68knommu is known to be less \
+ * than zero so we must wait. \
* \
* We can let go the lock for purposes of waiting. \
* We re-acquire it after awaking so as to protect \
Index: 1394-dev/arch/alpha/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/alpha/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/alpha/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -16,12 +16,12 @@
*/
/*
- * Atomically update sem->count.
+ * Atomically update sem->count_alpha.
* This does the equivalent of the following:
*
- * old_count = sem->count;
+ * old_count = sem->count_alpha;
* tmp = MAX(old_count, 0) + incr;
- * sem->count = tmp;
+ * sem->count_alpha = tmp;
* return old_count;
*/
static inline int __sem_update_count(struct semaphore *sem, int incr)
@@ -38,8 +38,8 @@ static inline int __sem_update_count(str
".subsection 2\n"
"2: br 1b\n"
".previous"
- : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
- : "Ir" (incr), "1" (tmp), "m" (sem->count));
+ : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count_alpha)
+ : "Ir" (incr), "1" (tmp), "m" (sem->count_alpha));
return old_count;
}
@@ -169,7 +169,7 @@ down(struct semaphore *sem)
#ifdef CONFIG_DEBUG_SEMAPHORE
printk("%s(%d): down(%p) <count=%d> from %p\n",
current->comm, current->pid, sem,
- atomic_read(&sem->count), __builtin_return_address(0));
+ atomic_read(&sem->count_alpha), __builtin_return_address(0));
#endif
__down(sem);
}
@@ -183,7 +183,7 @@ down_interruptible(struct semaphore *sem
#ifdef CONFIG_DEBUG_SEMAPHORE
printk("%s(%d): down(%p) <count=%d> from %p\n",
current->comm, current->pid, sem,
- atomic_read(&sem->count), __builtin_return_address(0));
+ atomic_read(&sem->count_alpha), __builtin_return_address(0));
#endif
return __down_interruptible(sem);
}
@@ -218,7 +218,7 @@ up(struct semaphore *sem)
#ifdef CONFIG_DEBUG_SEMAPHORE
printk("%s(%d): up(%p) <count=%d> from %p\n",
current->comm, current->pid, sem,
- atomic_read(&sem->count), __builtin_return_address(0));
+ atomic_read(&sem->count_alpha), __builtin_return_address(0));
#endif
__up(sem);
}
Index: 1394-dev/arch/s390/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/s390/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/s390/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -16,10 +16,10 @@
#include <asm/semaphore.h>
/*
- * Atomically update sem->count. Equivalent to:
- * old_val = sem->count.counter;
+ * Atomically update sem->count_s390. Equivalent to:
+ * old_val = sem->count_s390.counter;
* new_val = ((old_val >= 0) ? old_val : 0) + incr;
- * sem->count.counter = new_val;
+ * sem->count_s390.counter = new_val;
* return old_val;
*/
static inline int __sem_update_count(struct semaphore *sem, int incr)
@@ -34,8 +34,8 @@ static inline int __sem_update_count(str
" cs %0,%1,0(%3)\n"
" jl 0b\n"
: "=&d" (old_val), "=&d" (new_val),
- "=m" (sem->count)
- : "a" (&sem->count), "d" (incr), "m" (sem->count)
+ "=m" (sem->count_s390)
+ : "a" (&sem->count_s390), "d" (incr), "m" (sem->count_s390)
: "cc" );
return old_val;
}
Index: 1394-dev/arch/h8300/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/h8300/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/h8300/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -74,8 +74,8 @@ void __up(struct semaphore *sem)
add_wait_queue(&sem->wait, &wait); \
\
/* \
- * Ok, we're set up. sem->count is known to be less than zero \
- * so we must wait. \
+ * Ok, we're set up. sem->count_h8300 is known to be less than \
+ * zero so we must wait. \
* \
* We can let go the lock for purposes of waiting. \
* We re-acquire it after awaking so as to protect \
Index: 1394-dev/arch/sh/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/sh/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/sh/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -82,8 +82,8 @@ void __up(struct semaphore *sem)
add_wait_queue(&sem->wait, &wait); \
\
/* \
- * Ok, we're set up. sem->count is known to be less than zero \
- * so we must wait. \
+ * Ok, we're set up. sem->count_sh is known to be less than \
+ * zero so we must wait. \
* \
* We can let go the lock for purposes of waiting. \
* We re-acquire it after awaking so as to protect \
Index: 1394-dev/arch/m68k/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/m68k/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/m68k/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -74,8 +74,8 @@ void __up(struct semaphore *sem)
add_wait_queue(&sem->wait, &wait); \
\
/* \
- * Ok, we're set up. sem->count is known to be less than zero \
- * so we must wait. \
+ * Ok, we're set up. sem->count_m68k is known to be less than \
+ * zero so we must wait. \
* \
* We can let go the lock for purposes of waiting. \
* We re-acquire it after awaking so as to protect \
Index: 1394-dev/arch/ia64/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/ia64/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/ia64/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -64,7 +64,7 @@ void __sched __down (struct semaphore *s
* playing, because we own the spinlock in
* the wait_queue_head.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_ia64)) {
sem->sleepers = 0;
break;
}
@@ -107,7 +107,7 @@ int __sched __down_interruptible (struct
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic_add(sleepers, &sem->count);
+ atomic_add(sleepers, &sem->count_ia64);
break;
}
@@ -117,7 +117,7 @@ int __sched __down_interruptible (struct
* wait_queue_head. The "-1" is because we're
* still hoping to get the semaphore.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_ia64)) {
sem->sleepers = 0;
break;
}
@@ -156,7 +156,7 @@ __down_trylock (struct semaphore *sem)
* playing, because we own the spinlock in the
* wait_queue_head.
*/
- if (!atomic_add_negative(sleepers, &sem->count)) {
+ if (!atomic_add_negative(sleepers, &sem->count_ia64)) {
wake_up_locked(&sem->wait);
}
Index: 1394-dev/arch/cris/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/cris/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/cris/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -73,8 +73,8 @@ void __up(struct semaphore *sem)
add_wait_queue(&sem->wait, &wait); \
\
/* \
- * Ok, we're set up. sem->count is known to be less than zero \
- * so we must wait. \
+ * Ok, we're set up. sem->count_cris is known to be less than \
+ * zero so we must wait. \
* \
* We can let go the lock for purposes of waiting. \
* We re-acquire it after awaking so as to protect \
Index: 1394-dev/arch/sh64/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/sh64/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/sh64/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -83,8 +83,8 @@ void __up(struct semaphore *sem)
add_wait_queue(&sem->wait, &wait); \
\
/* \
- * Ok, we're set up. sem->count is known to be less than zero \
- * so we must wait. \
+ * Ok, we're set up. sem->count_sh64 is known to be less than \
+ * zero so we must wait. \
* \
* We can let go the lock for purposes of waiting. \
* We re-acquire it after awaking so as to protect \
Index: 1394-dev/arch/ppc64/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/ppc64/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/ppc64/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -25,12 +25,12 @@
#include <asm/errno.h>
/*
- * Atomically update sem->count.
+ * Atomically update sem->count_ppc64.
* This does the equivalent of the following:
*
- * old_count = sem->count;
+ * old_count = sem->count_ppc64;
* tmp = MAX(old_count, 0) + incr;
- * sem->count = tmp;
+ * sem->count_ppc64 = tmp;
* return old_count;
*/
static inline int __sem_update_count(struct semaphore *sem, int incr)
@@ -44,8 +44,8 @@ static inline int __sem_update_count(str
" add %1,%1,%4\n"
" stwcx. %1,0,%3\n"
" bne 1b"
- : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
- : "r" (&sem->count), "r" (incr), "m" (sem->count)
+ : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count_ppc64)
+ : "r" (&sem->count_ppc64), "r" (incr), "m" (sem->count_ppc64)
: "cc");
return old_count;
@@ -117,7 +117,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
/*
* A signal is pending - give up trying.
- * Set sem->count to 0 if it is negative,
+ * Set sem->count_ppc64 to 0 if it is negative,
* since we are no longer sleeping.
*/
__sem_update_count(sem, 0);
Index: 1394-dev/arch/ppc/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/ppc/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/ppc/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -21,12 +21,12 @@
#include <asm/errno.h>
/*
- * Atomically update sem->count.
+ * Atomically update sem->count_ppc.
* This does the equivalent of the following:
*
- * old_count = sem->count;
+ * old_count = sem->count_ppc;
* tmp = MAX(old_count, 0) + incr;
- * sem->count = tmp;
+ * sem->count_ppc = tmp;
* return old_count;
*/
static inline int __sem_update_count(struct semaphore *sem, int incr)
@@ -41,8 +41,8 @@ static inline int __sem_update_count(str
PPC405_ERR77(0,%3)
" stwcx. %1,0,%3\n"
" bne 1b"
- : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
- : "r" (&sem->count), "r" (incr), "m" (sem->count)
+ : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count_ppc)
+ : "r" (&sem->count_ppc), "r" (incr), "m" (sem->count_ppc)
: "cc");
return old_count;
@@ -114,7 +114,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
/*
* A signal is pending - give up trying.
- * Set sem->count to 0 if it is negative,
+ * Set sem->count_ppc to 0 if it is negative,
* since we are no longer sleeping.
*/
__sem_update_count(sem, 0);
Index: 1394-dev/arch/v850/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/v850/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/v850/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -73,7 +73,7 @@ void __sched __down(struct semaphore * s
* Add "everybody else" into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_v850)) {
sem->sleepers = 0;
break;
}
@@ -113,7 +113,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic_add(sleepers, &sem->count);
+ atomic_add(sleepers, &sem->count_v850);
break;
}
@@ -123,7 +123,7 @@ int __sched __down_interruptible(struct
* "-1" is because we're still hoping to get
* the lock.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_v850)) {
sem->sleepers = 0;
break;
}
@@ -158,7 +158,7 @@ int __down_trylock(struct semaphore * se
* Add "everybody else" and us into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic_add_negative(sleepers, &sem->count))
+ if (!atomic_add_negative(sleepers, &sem->count_v850))
wake_up(&sem->wait);
spin_unlock_irqrestore(&semaphore_lock, flags);
Index: 1394-dev/arch/m32r/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/m32r/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/m32r/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -82,7 +82,7 @@ asmlinkage void __sched __down(struct se
* playing, because we own the spinlock in
* the wait_queue_head.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_m32r)) {
sem->sleepers = 0;
break;
}
@@ -125,7 +125,7 @@ asmlinkage int __sched __down_interrupti
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic_add(sleepers, &sem->count);
+ atomic_add(sleepers, &sem->count_m32r);
break;
}
@@ -135,7 +135,7 @@ asmlinkage int __sched __down_interrupti
* wait_queue_head. The "-1" is because we're
* still hoping to get the semaphore.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_m32r)) {
sem->sleepers = 0;
break;
}
@@ -177,7 +177,7 @@ asmlinkage int __down_trylock(struct sem
* playing, because we own the spinlock in the
* wait_queue_head.
*/
- if (!atomic_add_negative(sleepers, &sem->count)) {
+ if (!atomic_add_negative(sleepers, &sem->count_m32r)) {
wake_up_locked(&sem->wait);
}
Index: 1394-dev/arch/arm26/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/arm26/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/arm26/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -74,7 +74,7 @@ void __sched __down(struct semaphore * s
* Add "everybody else" into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_arm26)) {
sem->sleepers = 0;
break;
}
@@ -114,7 +114,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic_add(sleepers, &sem->count);
+ atomic_add(sleepers, &sem->count_arm26);
break;
}
@@ -124,7 +124,7 @@ int __sched __down_interruptible(struct
* "-1" is because we're still hoping to get
* the lock.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_arm26)) {
sem->sleepers = 0;
break;
}
@@ -163,7 +163,7 @@ int __down_trylock(struct semaphore * se
* Add "everybody else" and us into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic_add_negative(sleepers, &sem->count))
+ if (!atomic_add_negative(sleepers, &sem->count_arm26))
wake_up(&sem->wait);
spin_unlock_irqrestore(&semaphore_lock, flags);
Index: 1394-dev/arch/x86_64/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/x86_64/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/x86_64/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -74,7 +74,7 @@ void __sched __down(struct semaphore * s
* playing, because we own the spinlock in
* the wait_queue_head.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_x86_64)) {
sem->sleepers = 0;
break;
}
@@ -117,7 +117,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic_add(sleepers, &sem->count);
+ atomic_add(sleepers, &sem->count_x86_64);
break;
}
@@ -127,7 +127,7 @@ int __sched __down_interruptible(struct
* wait_queue_head. The "-1" is because we're
* still hoping to get the semaphore.
*/
- if (!atomic_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic_add_negative(sleepers - 1, &sem->count_x86_64)) {
sem->sleepers = 0;
break;
}
@@ -169,7 +169,7 @@ int __down_trylock(struct semaphore * se
* playing, because we own the spinlock in the
* wait_queue_head.
*/
- if (!atomic_add_negative(sleepers, &sem->count)) {
+ if (!atomic_add_negative(sleepers, &sem->count_x86_64)) {
wake_up_locked(&sem->wait);
}
Index: 1394-dev/arch/sparc/kernel/semaphore.c
===================================================================
--- 1394-dev.orig/arch/sparc/kernel/semaphore.c 2005-03-15 17:24:10.000000000 -0500
+++ 1394-dev/arch/sparc/kernel/semaphore.c 2005-03-15 17:24:16.000000000 -0500
@@ -62,7 +62,7 @@ void __sched __down(struct semaphore * s
* Add "everybody else" into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic24_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic24_add_negative(sleepers - 1, &sem->count_sparc)) {
sem->sleepers = 0;
break;
}
@@ -102,7 +102,7 @@ int __sched __down_interruptible(struct
if (signal_pending(current)) {
retval = -EINTR;
sem->sleepers = 0;
- atomic24_add(sleepers, &sem->count);
+ atomic24_add(sleepers, &sem->count_sparc);
break;
}
@@ -112,7 +112,7 @@ int __sched __down_interruptible(struct
* "-1" is because we're still hoping to get
* the lock.
*/
- if (!atomic24_add_negative(sleepers - 1, &sem->count)) {
+ if (!atomic24_add_negative(sleepers - 1, &sem->count_sparc)) {
sem->sleepers = 0;
break;
}
@@ -147,7 +147,7 @@ int __down_trylock(struct semaphore * se
* Add "everybody else" and us into it. They aren't
* playing, because we own the spinlock.
*/
- if (!atomic24_add_negative(sleepers, &sem->count))
+ if (!atomic24_add_negative(sleepers, &sem->count_sparc))
wake_up(&sem->wait);
spin_unlock_irqrestore(&semaphore_lock, flags);
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 2/4] Add sem_getcount on arches that lack it
2005-03-16 19:27 ` [PATCH, RFC 1/4] Rename semaphore count variable to be arch specific Jody McIntyre
@ 2005-03-16 19:28 ` Jody McIntyre
2005-03-16 19:28 ` [PATCH, RFC 3/4] Use sem_getcount in XFS Jody McIntyre
2005-03-16 19:31 ` [PATCH, RFC 4/4] Use sem_getcount in ieee1394 Jody McIntyre
2 siblings, 0 replies; 14+ messages in thread
From: Jody McIntyre @ 2005-03-16 19:28 UTC (permalink / raw)
To: Matthew Wilcox; +Cc: Andrew Morton, linux-kernel, willy, nathans
Adds sem_getcount() to architectures that were missing it. Renames
sema_count on arm for this purpose (sema_count has no current callers.)
Tested on i386, ia64, parisc.
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
Index: 1394-dev/include/asm-h8300/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-h8300/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-h8300/semaphore.h 2005-03-15 17:26:51.000000000 -0500
@@ -59,6 +59,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_h8300);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-sh64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sh64/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-sh64/semaphore.h 2005-03-15 17:28:46.000000000 -0500
@@ -72,6 +72,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_sh64);
+}
+
#if 0
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
Index: 1394-dev/include/asm-m68knommu/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m68knommu/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-m68knommu/semaphore.h 2005-03-15 17:27:30.000000000 -0500
@@ -59,6 +59,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_m68knommu);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-m32r/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m32r/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-m32r/semaphore.h 2005-03-15 17:27:12.000000000 -0500
@@ -64,6 +64,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_m32r);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-ia64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ia64/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-ia64/semaphore.h 2005-03-15 17:27:06.000000000 -0500
@@ -50,6 +50,11 @@ init_MUTEX_LOCKED (struct semaphore *sem
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_ia64);
+}
+
extern void __down (struct semaphore * sem);
extern int __down_interruptible (struct semaphore * sem);
extern int __down_trylock (struct semaphore * sem);
Index: 1394-dev/include/asm-i386/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-i386/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-i386/semaphore.h 2005-03-15 17:27:00.000000000 -0500
@@ -87,6 +87,13 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+typedef atomic_t semcount_t;
+
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_i386);
+}
+
fastcall void __down_failed(void /* special register calling convention */);
fastcall int __down_failed_interruptible(void /* params in registers */);
fastcall int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-sparc/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sparc/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-sparc/semaphore.h 2005-03-15 17:28:51.000000000 -0500
@@ -48,6 +48,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_sparc);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern int __down_trylock(struct semaphore * sem);
Index: 1394-dev/include/asm-x86_64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-x86_64/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-x86_64/semaphore.h 2005-03-15 17:29:10.000000000 -0500
@@ -88,6 +88,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_x86_64);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-ppc/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ppc/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-ppc/semaphore.h 2005-03-15 17:28:19.000000000 -0500
@@ -62,6 +62,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_ppc);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
Index: 1394-dev/include/asm-ppc64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-ppc64/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-ppc64/semaphore.h 2005-03-15 17:28:24.000000000 -0500
@@ -56,6 +56,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_ppc64);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
Index: 1394-dev/include/asm-arm26/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-arm26/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-arm26/semaphore.h 2005-03-15 17:26:15.000000000 -0500
@@ -51,6 +51,11 @@ static inline void init_MUTEX_LOCKED(str
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_arm);
+}
+
/*
* special register calling convention
*/
Index: 1394-dev/include/asm-s390/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-s390/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-s390/semaphore.h 2005-03-15 17:28:35.000000000 -0500
@@ -53,6 +53,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_s390);
+}
+
asmlinkage void __down(struct semaphore * sem);
asmlinkage int __down_interruptible(struct semaphore * sem);
asmlinkage int __down_trylock(struct semaphore * sem);
Index: 1394-dev/include/asm-m68k/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-m68k/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-m68k/semaphore.h 2005-03-15 17:27:18.000000000 -0500
@@ -60,6 +60,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_m68k);
+}
+
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
asmlinkage int __down_failed_trylock(void /* params in registers */);
Index: 1394-dev/include/asm-arm/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-arm/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-arm/semaphore.h 2005-03-15 17:25:57.000000000 -0500
@@ -49,9 +49,9 @@ static inline void init_MUTEX_LOCKED(str
sema_init(sem, 0);
}
-static inline int sema_count(struct semaphore *sem)
+static inline int sem_getcount(struct semaphore *sem)
{
- return atomic_read(&sem->count);
+ return atomic_read(&sem->count_arm);
}
/*
Index: 1394-dev/include/asm-sparc64/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sparc64/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-sparc64/semaphore.h 2005-03-15 17:28:56.000000000 -0500
@@ -47,6 +47,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_sparc64);
+}
+
extern void up(struct semaphore *sem);
extern void down(struct semaphore *sem);
extern int down_trylock(struct semaphore *sem);
Index: 1394-dev/include/asm-sh/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-sh/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-sh/semaphore.h 2005-03-15 17:28:40.000000000 -0500
@@ -65,6 +65,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_sh);
+}
+
#if 0
asmlinkage void __down_failed(void /* special register calling convention */);
asmlinkage int __down_failed_interruptible(void /* params in registers */);
Index: 1394-dev/include/asm-mips/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-mips/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-mips/semaphore.h 2005-03-15 17:27:35.000000000 -0500
@@ -70,6 +70,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_mips);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
Index: 1394-dev/include/asm-alpha/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-alpha/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-alpha/semaphore.h 2005-03-15 17:25:48.000000000 -0500
@@ -57,6 +57,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem.count_alpha);
+}
+
extern void down(struct semaphore *);
extern void __down_failed(struct semaphore *);
extern int down_interruptible(struct semaphore *);
Index: 1394-dev/include/asm-cris/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-cris/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-cris/semaphore.h 2005-03-15 17:26:26.000000000 -0500
@@ -57,6 +57,11 @@ extern inline void init_MUTEX_LOCKED (st
sema_init(sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_cris);
+}
+
extern void __down(struct semaphore * sem);
extern int __down_interruptible(struct semaphore * sem);
extern int __down_trylock(struct semaphore * sem);
Index: 1394-dev/include/asm-v850/semaphore.h
===================================================================
--- 1394-dev.orig/include/asm-v850/semaphore.h 2005-03-15 17:24:16.000000000 -0500
+++ 1394-dev/include/asm-v850/semaphore.h 2005-03-15 17:29:02.000000000 -0500
@@ -42,6 +42,11 @@ static inline void init_MUTEX_LOCKED (st
sema_init (sem, 0);
}
+static inline int sem_getcount(struct semaphore *sem)
+{
+ return atomic_read(&sem->count_v850);
+}
+
/*
* special register calling convention
*/
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 3/4] Use sem_getcount in XFS
2005-03-16 19:27 ` [PATCH, RFC 1/4] Rename semaphore count variable to be arch specific Jody McIntyre
2005-03-16 19:28 ` [PATCH, RFC 2/4] Add sem_getcount on arches that lack it Jody McIntyre
@ 2005-03-16 19:28 ` Jody McIntyre
2005-03-16 19:31 ` [PATCH, RFC 4/4] Use sem_getcount in ieee1394 Jody McIntyre
2 siblings, 0 replies; 14+ messages in thread
From: Jody McIntyre @ 2005-03-16 19:28 UTC (permalink / raw)
To: Matthew Wilcox; +Cc: Andrew Morton, linux-kernel, willy, nathans
Convert XFS to use sem_getcount instead of nasty hack. Fixes warning
with XFS debugging on parisc (untested since I can't find an obvious way
to enable XFS debugging) as well as the valusema macro, used in two places
in XFS.
Tested on i386, ia64, parisc.
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
Index: 1394-dev/fs/xfs/linux-2.6/xfs_buf.c
===================================================================
--- 1394-dev.orig/fs/xfs/linux-2.6/xfs_buf.c 2005-03-15 17:45:47.000000000 -0500
+++ 1394-dev/fs/xfs/linux-2.6/xfs_buf.c 2005-03-15 17:52:39.000000000 -0500
@@ -976,7 +976,7 @@ int
pagebuf_lock_value(
xfs_buf_t *pb)
{
- return(atomic_read(&pb->pb_sema.count));
+ return(sem_getcount(&pb->pb_sema));
}
#endif
Index: 1394-dev/fs/xfs/linux-2.6/sema.h
===================================================================
--- 1394-dev.orig/fs/xfs/linux-2.6/sema.h 2005-03-15 17:59:50.000000000 -0500
+++ 1394-dev/fs/xfs/linux-2.6/sema.h 2005-03-15 18:16:00.000000000 -0500
@@ -48,7 +48,7 @@ typedef struct semaphore sema_t;
#define initnsema(sp, val, name) sema_init(sp, val)
#define psema(sp, b) down(sp)
#define vsema(sp) up(sp)
-#define valusema(sp) (atomic_read(&(sp)->count))
+#define valusema(sp) (sem_getcount(sp))
#define freesema(sema)
/*
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH, RFC 4/4] Use sem_getcount in ieee1394
2005-03-16 19:27 ` [PATCH, RFC 1/4] Rename semaphore count variable to be arch specific Jody McIntyre
2005-03-16 19:28 ` [PATCH, RFC 2/4] Add sem_getcount on arches that lack it Jody McIntyre
2005-03-16 19:28 ` [PATCH, RFC 3/4] Use sem_getcount in XFS Jody McIntyre
@ 2005-03-16 19:31 ` Jody McIntyre
2 siblings, 0 replies; 14+ messages in thread
From: Jody McIntyre @ 2005-03-16 19:31 UTC (permalink / raw)
To: Matthew Wilcox; +Cc: Andrew Morton, linux-kernel, willy, nathans
Convert 1394's node manager to use sem_getcount instead of nasty hack.
Tested on parisc (where it eliminates a warning), ia64, i386.
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
Index: 1394-dev/drivers/ieee1394/nodemgr.c
===================================================================
--- 1394-dev.orig/drivers/ieee1394/nodemgr.c 2005-03-15 18:23:35.000000000 -0500
+++ 1394-dev/drivers/ieee1394/nodemgr.c 2005-03-15 18:23:35.000000000 -0500
@@ -284,7 +284,7 @@ static DEVICE_ATTR(bus_options,S_IRUGO,f
static ssize_t fw_show_ne_tlabels_free(struct device *dev, char *buf)
{
struct node_entry *ne = container_of(dev, struct node_entry, device);
- return sprintf(buf, "%d\n", atomic_read(&ne->tpool->count.count) + 1);
+ return sprintf(buf, "%d\n", sem_getcount(&ne->tpool->count) + 1);
}
static DEVICE_ATTR(tlabels_free,S_IRUGO,fw_show_ne_tlabels_free,NULL);
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2005-03-16 19:35 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2005-03-11 0:06 [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Jody McIntyre
2005-03-11 0:08 ` [PATCH, RFC 2/3] Use sem_getcount in ieee1394 Jody McIntyre
2005-03-11 0:10 ` [PATCH, RFC 3/3] Use sem_getcount in xfs Jody McIntyre
2005-03-11 4:55 ` [PATCH, RFC 1/3] Add sem_getcount() to arches that lack it Andrew Morton
2005-03-11 5:10 ` Roland Dreier
2005-03-11 5:18 ` Nathan Scott
2005-03-11 5:31 ` Jody McIntyre
2005-03-11 5:56 ` Andrew Morton
2005-03-11 12:27 ` Matthew Wilcox
2005-03-11 17:04 ` Jody McIntyre
2005-03-16 19:27 ` [PATCH, RFC 1/4] Rename semaphore count variable to be arch specific Jody McIntyre
2005-03-16 19:28 ` [PATCH, RFC 2/4] Add sem_getcount on arches that lack it Jody McIntyre
2005-03-16 19:28 ` [PATCH, RFC 3/4] Use sem_getcount in XFS Jody McIntyre
2005-03-16 19:31 ` [PATCH, RFC 4/4] Use sem_getcount in ieee1394 Jody McIntyre
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.