hurd: make lll_* take a variable instead of a ptr

To be coherent with other ports, let's make lll_* take a variable, and
rename those that keep taking a ptr into __lll_*.

1 files changed, 22 insertions, 16 deletions

diff --git a/hurd/hurdlock.h b/hurd/hurdlock.h
index 362bcf6..c1df42b 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 <LO, HI>.  */
-#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]);   \
    })