From patchwork Wed Dec 16 00:59:39 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Samuel Thibault X-Patchwork-Id: 41435 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 60E813861826; Wed, 16 Dec 2020 00:59:57 +0000 (GMT) X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from hera.aquilenet.fr (hera.aquilenet.fr [IPv6:2a0c:e300::1]) by sourceware.org (Postfix) with ESMTPS id E61A2385141E for ; Wed, 16 Dec 2020 00:59:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org E61A2385141E Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=ens-lyon.org Authentication-Results: sourceware.org; spf=fail smtp.mailfrom=samuel.thibault@ens-lyon.org Received: from localhost (localhost [127.0.0.1]) by hera.aquilenet.fr (Postfix) with ESMTP id 08553156A; Wed, 16 Dec 2020 01:59:51 +0100 (CET) X-Virus-Scanned: Debian amavisd-new at aquilenet.fr Received: from hera.aquilenet.fr ([127.0.0.1]) by localhost (hera.aquilenet.fr [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id NzvPTfxroM4c; Wed, 16 Dec 2020 01:59:46 +0100 (CET) Received: from function.youpi.perso.aquilenet.fr (unknown [IPv6:2a01:cb19:956:1b00:9eb6:d0ff:fe88:c3c7]) by hera.aquilenet.fr (Postfix) with ESMTPSA id 3C58614E9; Wed, 16 Dec 2020 01:59:46 +0100 (CET) Received: from samy by function.youpi.perso.aquilenet.fr with local (Exim 4.94) (envelope-from ) id 1kpLAP-00CyMI-0E; Wed, 16 Dec 2020 01:59:45 +0100 From: Samuel Thibault To: libc-alpha@sourceware.org Subject: [hurd, commited 2/7] hurd: make lll_* take a variable instead of a ptr Date: Wed, 16 Dec 2020 01:59:39 +0100 Message-Id: <20201216005944.3091900-3-samuel.thibault@ens-lyon.org> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201216005944.3091900-1-samuel.thibault@ens-lyon.org> References: <20201216005944.3091900-1-samuel.thibault@ens-lyon.org> MIME-Version: 1.0 X-Spam-Status: No, score=-12.0 required=5.0 tests=BAYES_00, GIT_PATCH_0, JMQ_SPF_NEUTRAL, KAM_DMARC_STATUS, SPF_HELO_PASS, SPF_NEUTRAL, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: commit-hurd@gnu.org Errors-To: libc-alpha-bounces@sourceware.org Sender: "Libc-alpha" To be coherent with other ports, let's make lll_* take a variable, and rename those that keep taking a ptr into __lll_*. --- hurd/hurdlock.c | 14 ++++---- hurd/hurdlock.h | 38 +++++++++++++--------- hurd/hurdpid.c | 2 +- mach/lock-intern.h | 6 ++-- mach/lowlevellock.h | 24 ++++++++++---- sysdeps/mach/hurd/htl/pt-mutex-lock.c | 8 ++--- sysdeps/mach/hurd/htl/pt-mutex-timedlock.c | 6 ++-- sysdeps/mach/hurd/htl/pt-mutex-trylock.c | 8 ++--- sysdeps/mach/hurd/htl/pt-mutex-unlock.c | 8 ++--- sysdeps/mach/hurd/htl/pt-mutex.h | 2 +- sysdeps/mach/hurd/setpgid.c | 2 +- sysdeps/mach/hurd/setsid.c | 2 +- sysdeps/mach/hurd/tls.h | 4 +-- sysdeps/mach/libc-lock.h | 12 +++---- 14 files changed, 76 insertions(+), 60 deletions(-) diff --git a/hurd/hurdlock.c b/hurd/hurdlock.c index 59d017fc02..3b9974bee5 100644 --- a/hurd/hurdlock.c +++ b/hurd/hurdlock.c @@ -51,7 +51,7 @@ __lll_abstimed_wait (void *ptr, int val, return EINVAL; int mlsec = compute_reltime (tsp, clk); - return mlsec < 0 ? KERN_TIMEDOUT : lll_timed_wait (ptr, val, mlsec, flags); + return mlsec < 0 ? KERN_TIMEDOUT : __lll_timed_wait (ptr, val, mlsec, flags); } int @@ -62,7 +62,7 @@ __lll_abstimed_xwait (void *ptr, int lo, int hi, return EINVAL; int mlsec = compute_reltime (tsp, clk); - return mlsec < 0 ? KERN_TIMEDOUT : lll_timed_xwait (ptr, lo, hi, mlsec, + return mlsec < 0 ? KERN_TIMEDOUT : __lll_timed_xwait (ptr, lo, hi, mlsec, flags); } @@ -73,7 +73,7 @@ __lll_abstimed_lock (void *ptr, if (clk != CLOCK_REALTIME) return EINVAL; - if (lll_trylock (ptr) == 0) + if (__lll_trylock (ptr) == 0) return 0; while (1) @@ -84,7 +84,7 @@ __lll_abstimed_lock (void *ptr, return EINVAL; int mlsec = compute_reltime (tsp, clk); - if (mlsec < 0 || lll_timed_wait (ptr, 2, mlsec, flags) == KERN_TIMEDOUT) + if (mlsec < 0 || __lll_timed_wait (ptr, 2, mlsec, flags) == KERN_TIMEDOUT) return ETIMEDOUT; } } @@ -140,7 +140,7 @@ __lll_robust_lock (void *ptr, int flags) } else { - lll_timed_wait (iptr, val, wait_time, flags); + __lll_timed_wait (iptr, val, wait_time, flags); if (wait_time < MAX_WAIT_TIME) wait_time <<= 1; } @@ -187,7 +187,7 @@ __lll_robust_abstimed_lock (void *ptr, else if (mlsec > wait_time) mlsec = wait_time; - int res = lll_timed_wait (iptr, val, mlsec, flags); + int res = __lll_timed_wait (iptr, val, mlsec, flags); if (res == KERN_TIMEDOUT) return ETIMEDOUT; else if (wait_time < MAX_WAIT_TIME) @@ -223,7 +223,7 @@ __lll_robust_unlock (void *ptr, int flags) { if (val & LLL_WAITERS) { - lll_set_wake (ptr, 0, flags); + __lll_set_wake (ptr, 0, flags); break; } else if (atomic_compare_exchange_weak_release ((unsigned int *)ptr, &val, 0)) diff --git a/hurd/hurdlock.h b/hurd/hurdlock.h index 362bcf6cc2..c1df42bea4 100644 --- a/hurd/hurdlock.h +++ b/hurd/hurdlock.h @@ -31,21 +31,21 @@ struct timespec; /* Wait on 64-bit address PTR, without blocking if its contents are different from the pair . */ -#define lll_xwait(ptr, lo, hi, flags) \ +#define __lll_xwait(ptr, lo, hi, flags) \ __gsync_wait (__mach_task_self (), \ (vm_offset_t)ptr, lo, hi, 0, flags | GSYNC_QUAD) -/* Same as 'lll_wait', but only block for MLSEC milliseconds. */ -#define lll_timed_wait(ptr, val, mlsec, flags) \ +/* Same as '__lll_wait', but only block for MLSEC milliseconds. */ +#define __lll_timed_wait(ptr, val, mlsec, flags) \ __gsync_wait (__mach_task_self (), \ (vm_offset_t)ptr, val, 0, mlsec, flags | GSYNC_TIMED) -/* Same as 'lll_xwait', but only block for MLSEC milliseconds. */ -#define lll_timed_xwait(ptr, lo, hi, mlsec, flags) \ +/* Same as '__lll_xwait', but only block for MLSEC milliseconds. */ +#define __lll_timed_xwait(ptr, lo, hi, mlsec, flags) \ __gsync_wait (__mach_task_self (), (vm_offset_t)ptr, \ lo, hi, mlsec, flags | GSYNC_TIMED | GSYNC_QUAD) -/* Same as 'lll_wait', but only block until TSP elapses, +/* Same as '__lll_wait', but only block until TSP elapses, using clock CLK. */ extern int __lll_abstimed_wait (void *__ptr, int __val, const struct timespec *__tsp, int __flags, int __clk); @@ -63,6 +63,8 @@ extern int __lll_abstimed_lock (void *__ptr, /* Acquire the lock at PTR, but return with an error if the process containing the owner thread dies. */ extern int __lll_robust_lock (void *__ptr, int __flags); +#define lll_robust_lock(var, flags) \ + __lll_robust_lock (&(var), flags) /* Same as '__lll_robust_lock', but only block until TSP elapses, using clock CLK. */ @@ -72,19 +74,23 @@ extern int __lll_robust_abstimed_lock (void *__ptr, /* Same as '__lll_robust_lock', but return with an error if the lock cannot be acquired without blocking. */ extern int __lll_robust_trylock (void *__ptr); +#define lll_robust_trylock(var) \ + __lll_robust_trylock (&(var)) /* Wake one or more threads waiting on address PTR, setting its value to VAL before doing so. */ -#define lll_set_wake(ptr, val, flags) \ +#define __lll_set_wake(ptr, val, flags) \ __gsync_wake (__mach_task_self (), \ (vm_offset_t)ptr, val, flags | GSYNC_MUTATE) /* Release the robust lock at PTR. */ extern void __lll_robust_unlock (void *__ptr, int __flags); +#define lll_robust_unlock(var, flags) \ + __lll_robust_unlock (&(var), flags) /* Rearrange threads waiting on address SRC to instead wait on DST, waking one of them if WAIT_ONE is non-zero. */ -#define lll_requeue(src, dst, wake_one, flags) \ +#define __lll_requeue(src, dst, wake_one, flags) \ __gsync_requeue (__mach_task_self (), (vm_offset_t)src, \ (vm_offset_t)dst, (boolean_t)wake_one, flags) @@ -93,31 +99,31 @@ extern void __lll_robust_unlock (void *__ptr, int __flags); every one of these calls, defaulting to CLOCK_REALTIME if no argument is passed. */ -#define lll_abstimed_wait(ptr, val, tsp, flags, ...) \ +#define lll_abstimed_wait(var, val, tsp, flags, ...) \ ({ \ const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ - __lll_abstimed_wait ((ptr), (val), (tsp), (flags), \ + __lll_abstimed_wait (&(var), (val), (tsp), (flags), \ __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ }) -#define lll_abstimed_xwait(ptr, lo, hi, tsp, flags, ...) \ +#define lll_abstimed_xwait(var, lo, hi, tsp, flags, ...) \ ({ \ const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ - __lll_abstimed_xwait ((ptr), (lo), (hi), (tsp), (flags), \ + __lll_abstimed_xwait (&(var), (lo), (hi), (tsp), (flags), \ __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ }) -#define lll_abstimed_lock(ptr, tsp, flags, ...) \ +#define lll_abstimed_lock(var, tsp, flags, ...) \ ({ \ const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ - __lll_abstimed_lock ((ptr), (tsp), (flags), \ + __lll_abstimed_lock (&(var), (tsp), (flags), \ __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ }) -#define lll_robust_abstimed_lock(ptr, tsp, flags, ...) \ +#define lll_robust_abstimed_lock(var, tsp, flags, ...) \ ({ \ const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ - __lll_robust_abstimed_lock ((ptr), (tsp), (flags), \ + __lll_robust_abstimed_lock (&(var), (tsp), (flags), \ __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ }) diff --git a/hurd/hurdpid.c b/hurd/hurdpid.c index dd8281cda7..5607570d4b 100644 --- a/hurd/hurdpid.c +++ b/hurd/hurdpid.c @@ -66,7 +66,7 @@ _S_msg_proc_newids (mach_port_t me, /* Notify any waiting user threads that the id change as been completed. */ ++_hurd_pids_changed_stamp; - lll_wake (&_hurd_pids_changed_stamp, GSYNC_BROADCAST); + lll_wake (_hurd_pids_changed_stamp, GSYNC_BROADCAST); return 0; } diff --git a/mach/lock-intern.h b/mach/lock-intern.h index 62faf98039..77fc4d17f8 100644 --- a/mach/lock-intern.h +++ b/mach/lock-intern.h @@ -57,7 +57,7 @@ extern void __spin_lock (__spin_lock_t *__lock); _EXTERN_INLINE void __spin_lock (__spin_lock_t *__lock) { - lll_lock (__lock, 0); + __lll_lock (__lock, 0); } #endif @@ -68,7 +68,7 @@ extern void __spin_unlock (__spin_lock_t *__lock); _EXTERN_INLINE void __spin_unlock (__spin_lock_t *__lock) { - lll_unlock (__lock, 0); + __lll_unlock (__lock, 0); } #endif @@ -79,7 +79,7 @@ extern int __spin_try_lock (__spin_lock_t *__lock); _EXTERN_INLINE int __spin_try_lock (__spin_lock_t *__lock) { - return (lll_trylock (__lock) == 0); + return (__lll_trylock (__lock) == 0); } #endif diff --git a/mach/lowlevellock.h b/mach/lowlevellock.h index cf67ccd589..0a22a030b4 100644 --- a/mach/lowlevellock.h +++ b/mach/lowlevellock.h @@ -36,16 +36,20 @@ /* Wait on address PTR, without blocking if its contents * are different from VAL. */ -#define lll_wait(ptr, val, flags) \ +#define __lll_wait(ptr, val, flags) \ __gsync_wait (__mach_task_self (), \ (vm_offset_t)(ptr), (val), 0, 0, (flags)) +#define lll_wait(var, val, flags) \ + __lll_wait (&(var), val, flags) /* Wake one or more threads waiting on address PTR. */ -#define lll_wake(ptr, flags) \ +#define __lll_wake(ptr, flags) \ __gsync_wake (__mach_task_self (), (vm_offset_t)(ptr), 0, (flags)) +#define lll_wake(var, flags) \ + __lll_wake (&(var), flags) /* Acquire the lock at PTR. */ -#define lll_lock(ptr, flags) \ +#define __lll_lock(ptr, flags) \ ({ \ int *__iptr = (int *)(ptr); \ int __flags = (flags); \ @@ -55,27 +59,33 @@ { \ if (atomic_exchange_acq (__iptr, 2) == 0) \ break; \ - lll_wait (__iptr, 2, __flags); \ + __lll_wait (__iptr, 2, __flags); \ } \ (void)0; \ }) +#define lll_lock(var, flags) \ + __lll_lock (&(var), flags) /* Try to acquire the lock at PTR, without blocking. Evaluates to zero on success. */ -#define lll_trylock(ptr) \ +#define __lll_trylock(ptr) \ ({ \ int *__iptr = (int *)(ptr); \ *__iptr == 0 \ && atomic_compare_and_exchange_bool_acq (__iptr, 1, 0) == 0 ? 0 : -1; \ }) +#define lll_trylock(var) \ + __lll_trylock (&(var)) /* Release the lock at PTR. */ -#define lll_unlock(ptr, flags) \ +#define __lll_unlock(ptr, flags) \ ({ \ int *__iptr = (int *)(ptr); \ if (atomic_exchange_rel (__iptr, 0) == 2) \ - lll_wake (__iptr, (flags)); \ + __lll_wake (__iptr, (flags)); \ (void)0; \ }) +#define lll_unlock(var, flags) \ + __lll_unlock (&(var), flags) #endif diff --git a/sysdeps/mach/hurd/htl/pt-mutex-lock.c b/sysdeps/mach/hurd/htl/pt-mutex-lock.c index 22510701d8..ed1f6c13a1 100644 --- a/sysdeps/mach/hurd/htl/pt-mutex-lock.c +++ b/sysdeps/mach/hurd/htl/pt-mutex-lock.c @@ -33,7 +33,7 @@ __pthread_mutex_lock (pthread_mutex_t *mtxp) switch (MTX_TYPE (mtxp)) { case PT_MTX_NORMAL: - lll_lock (&mtxp->__lock, flags); + lll_lock (mtxp->__lock, flags); break; case PT_MTX_RECURSIVE: @@ -47,7 +47,7 @@ __pthread_mutex_lock (pthread_mutex_t *mtxp) return ret; } - lll_lock (&mtxp->__lock, flags); + lll_lock (mtxp->__lock, flags); mtx_set_owner (mtxp, self, flags); mtxp->__cnt = 1; break; @@ -57,7 +57,7 @@ __pthread_mutex_lock (pthread_mutex_t *mtxp) if (mtx_owned_p (mtxp, self, flags)) return EDEADLK; - lll_lock (&mtxp->__lock, flags); + lll_lock (mtxp->__lock, flags); mtx_set_owner (mtxp, self, flags); break; @@ -65,7 +65,7 @@ __pthread_mutex_lock (pthread_mutex_t *mtxp) case PT_MTX_RECURSIVE | PTHREAD_MUTEX_ROBUST: case PT_MTX_ERRORCHECK | PTHREAD_MUTEX_ROBUST: self = _pthread_self (); - ROBUST_LOCK (self, mtxp, __lll_robust_lock, flags); + ROBUST_LOCK (self, mtxp, lll_robust_lock, flags); break; default: diff --git a/sysdeps/mach/hurd/htl/pt-mutex-timedlock.c b/sysdeps/mach/hurd/htl/pt-mutex-timedlock.c index 198b340429..965e8b24fb 100644 --- a/sysdeps/mach/hurd/htl/pt-mutex-timedlock.c +++ b/sysdeps/mach/hurd/htl/pt-mutex-timedlock.c @@ -34,7 +34,7 @@ __pthread_mutex_clocklock (pthread_mutex_t *mtxp, switch (MTX_TYPE (mtxp)) { case PT_MTX_NORMAL: - ret = lll_abstimed_lock (&mtxp->__lock, tsp, flags, clockid); + ret = lll_abstimed_lock (mtxp->__lock, tsp, flags, clockid); break; case PT_MTX_RECURSIVE: @@ -47,7 +47,7 @@ __pthread_mutex_clocklock (pthread_mutex_t *mtxp, ++mtxp->__cnt; ret = 0; } - else if ((ret = lll_abstimed_lock (&mtxp->__lock, tsp, flags, clockid)) == 0) + else if ((ret = lll_abstimed_lock (mtxp->__lock, tsp, flags, clockid)) == 0) { mtx_set_owner (mtxp, self, flags); mtxp->__cnt = 1; @@ -59,7 +59,7 @@ __pthread_mutex_clocklock (pthread_mutex_t *mtxp, self = _pthread_self (); if (mtx_owned_p (mtxp, self, flags)) ret = EDEADLK; - else if ((ret = lll_abstimed_lock (&mtxp->__lock, tsp, flags, clockid)) == 0) + else if ((ret = lll_abstimed_lock (mtxp->__lock, tsp, flags, clockid)) == 0) mtx_set_owner (mtxp, self, flags); break; diff --git a/sysdeps/mach/hurd/htl/pt-mutex-trylock.c b/sysdeps/mach/hurd/htl/pt-mutex-trylock.c index f883ec3f30..62183b0299 100644 --- a/sysdeps/mach/hurd/htl/pt-mutex-trylock.c +++ b/sysdeps/mach/hurd/htl/pt-mutex-trylock.c @@ -32,7 +32,7 @@ __pthread_mutex_trylock (pthread_mutex_t *mtxp) switch (MTX_TYPE (mtxp)) { case PT_MTX_NORMAL: - ret = lll_trylock (&mtxp->__lock); + ret = lll_trylock (mtxp->__lock); if (ret) ret = EBUSY; break; @@ -47,7 +47,7 @@ __pthread_mutex_trylock (pthread_mutex_t *mtxp) ++mtxp->__cnt; ret = 0; } - else if ((ret = lll_trylock (&mtxp->__lock)) == 0) + else if ((ret = lll_trylock (mtxp->__lock)) == 0) { mtx_set_owner (mtxp, self, mtxp->__flags); mtxp->__cnt = 1; @@ -59,7 +59,7 @@ __pthread_mutex_trylock (pthread_mutex_t *mtxp) case PT_MTX_ERRORCHECK: self = _pthread_self (); - if ((ret = lll_trylock (&mtxp->__lock)) == 0) + if ((ret = lll_trylock (mtxp->__lock)) == 0) mtx_set_owner (mtxp, self, mtxp->__flags); else ret = EBUSY; @@ -69,7 +69,7 @@ __pthread_mutex_trylock (pthread_mutex_t *mtxp) case PT_MTX_RECURSIVE | PTHREAD_MUTEX_ROBUST: case PT_MTX_ERRORCHECK | PTHREAD_MUTEX_ROBUST: self = _pthread_self (); - ROBUST_LOCK (self, mtxp, __lll_robust_trylock); + ROBUST_LOCK (self, mtxp, lll_robust_trylock); break; default: diff --git a/sysdeps/mach/hurd/htl/pt-mutex-unlock.c b/sysdeps/mach/hurd/htl/pt-mutex-unlock.c index aabe9eafbb..f2e87a7c6f 100644 --- a/sysdeps/mach/hurd/htl/pt-mutex-unlock.c +++ b/sysdeps/mach/hurd/htl/pt-mutex-unlock.c @@ -32,7 +32,7 @@ __pthread_mutex_unlock (pthread_mutex_t *mtxp) switch (MTX_TYPE (mtxp)) { case PT_MTX_NORMAL: - lll_unlock (&mtxp->__lock, flags); + lll_unlock (mtxp->__lock, flags); break; case PT_MTX_RECURSIVE: @@ -42,7 +42,7 @@ __pthread_mutex_unlock (pthread_mutex_t *mtxp) else if (--mtxp->__cnt == 0) { mtxp->__owner_id = mtxp->__shpid = 0; - lll_unlock (&mtxp->__lock, flags); + lll_unlock (mtxp->__lock, flags); } break; @@ -54,7 +54,7 @@ __pthread_mutex_unlock (pthread_mutex_t *mtxp) else { mtxp->__owner_id = mtxp->__shpid = 0; - lll_unlock (&mtxp->__lock, flags); + lll_unlock (mtxp->__lock, flags); } break; @@ -74,7 +74,7 @@ __pthread_mutex_unlock (pthread_mutex_t *mtxp) * state, mark it as irrecoverable. */ mtxp->__owner_id = ((mtxp->__lock & LLL_DEAD_OWNER) ? NOTRECOVERABLE_ID : 0); - __lll_robust_unlock (&mtxp->__lock, flags); + lll_robust_unlock (mtxp->__lock, flags); } break; diff --git a/sysdeps/mach/hurd/htl/pt-mutex.h b/sysdeps/mach/hurd/htl/pt-mutex.h index 578478fcaf..ead7c91c4f 100644 --- a/sysdeps/mach/hurd/htl/pt-mutex.h +++ b/sysdeps/mach/hurd/htl/pt-mutex.h @@ -42,7 +42,7 @@ return EDEADLK; \ } \ \ - ret = cb (&mtxp->__lock, ##__VA_ARGS__); \ + ret = cb (mtxp->__lock, ##__VA_ARGS__); \ if (ret == 0 || ret == EOWNERDEAD) \ { \ if (mtxp->__owner_id == ENOTRECOVERABLE) \ diff --git a/sysdeps/mach/hurd/setpgid.c b/sysdeps/mach/hurd/setpgid.c index 4bb90c48c7..41562b77e5 100644 --- a/sysdeps/mach/hurd/setpgid.c +++ b/sysdeps/mach/hurd/setpgid.c @@ -39,7 +39,7 @@ __setpgid (pid_t pid, pid_t pgid) /* Synchronize with the signal thread to make sure we have received and processed proc_newids before returning to the user. */ while (_hurd_pids_changed_stamp == stamp) - lll_wait (&_hurd_pids_changed_stamp, stamp, 0); + lll_wait (_hurd_pids_changed_stamp, stamp, 0); return 0; diff --git a/sysdeps/mach/hurd/setsid.c b/sysdeps/mach/hurd/setsid.c index b297473a86..f5c95a334e 100644 --- a/sysdeps/mach/hurd/setsid.c +++ b/sysdeps/mach/hurd/setsid.c @@ -56,7 +56,7 @@ __setsid (void) returned by `getpgrp ()' in other threads) has been updated before we return. */ while (_hurd_pids_changed_stamp == stamp) - lll_wait (&_hurd_pids_changed_stamp, stamp, 0); + lll_wait (_hurd_pids_changed_stamp, stamp, 0); } HURD_CRITICAL_END; diff --git a/sysdeps/mach/hurd/tls.h b/sysdeps/mach/hurd/tls.h index a6a3586785..a0d70c2026 100644 --- a/sysdeps/mach/hurd/tls.h +++ b/sysdeps/mach/hurd/tls.h @@ -60,7 +60,7 @@ #define THREAD_GSCOPE_RESET_FLAG() \ do \ if (atomic_exchange_and_add_rel (&GL(dl_thread_gscope_count), -1) == 1) \ - lll_wake (&GL(dl_thread_gscope_count), 0); \ + lll_wake (GL(dl_thread_gscope_count), 0); \ while (0) #define THREAD_GSCOPE_WAIT() \ do \ @@ -68,7 +68,7 @@ int count; \ atomic_write_barrier (); \ while ((count = GL(dl_thread_gscope_count))) \ - lll_wait (&GL(dl_thread_gscope_count), count, 0); \ + lll_wait (GL(dl_thread_gscope_count), count, 0); \ } \ while (0) diff --git a/sysdeps/mach/libc-lock.h b/sysdeps/mach/libc-lock.h index 3993a57b26..d9a2c42ebe 100644 --- a/sysdeps/mach/libc-lock.h +++ b/sysdeps/mach/libc-lock.h @@ -74,14 +74,14 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t; /* Lock the named lock variable. */ #define __libc_lock_lock(NAME) \ - ({ lll_lock (&(NAME), 0); 0; }) + ({ lll_lock ((NAME), 0); 0; }) /* Lock the named lock variable. */ -#define __libc_lock_trylock(NAME) lll_trylock (&(NAME)) +#define __libc_lock_trylock(NAME) lll_trylock (NAME) /* Unlock the named lock variable. */ #define __libc_lock_unlock(NAME) \ - ({ lll_unlock (&(NAME), 0); 0; }) + ({ lll_unlock ((NAME), 0); 0; }) #define __libc_lock_define_recursive(CLASS,NAME) \ CLASS __libc_lock_recursive_t NAME; @@ -111,7 +111,7 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t; int __r = 0; \ if (__self == __lock->owner) \ ++__lock->cnt; \ - else if ((__r = lll_trylock (&__lock->lock)) == 0) \ + else if ((__r = lll_trylock (__lock->lock)) == 0) \ __lock->owner = __self, __lock->cnt = 1; \ __r; \ }) @@ -122,7 +122,7 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t; void *__self = __libc_lock_owner_self (); \ if (__self != __lock->owner) \ { \ - lll_lock (&__lock->lock, 0); \ + lll_lock (__lock->lock, 0); \ __lock->owner = __self; \ } \ ++__lock->cnt; \ @@ -135,7 +135,7 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t; if (--__lock->cnt == 0) \ { \ __lock->owner = 0; \ - lll_unlock (&__lock->lock, 0); \ + lll_unlock (__lock->lock, 0); \ } \ })