diff options
author | Samuel Thibault <samuel.thibault@ens-lyon.org> | 2016-08-23 20:16:41 +0200 |
---|---|---|
committer | Samuel Thibault <samuel.thibault@ens-lyon.org> | 2016-08-23 20:16:41 +0200 |
commit | 4169693cc2db66be9babecdaab70986aca735e90 (patch) | |
tree | b4487d76c6bcfbb8402f2be5ed97ae216acd0ee0 /hurd | |
parent | 378cba2c37916d7e0284307cb368baf55f691532 (diff) | |
parent | f0df4a42a77d15d4edfc95bb45035e81cb1bdbaa (diff) |
Merge branch 't/gsync-libc' into refs/top-bases/tschwinge/Roger_Whittaker
Diffstat (limited to 'hurd')
-rw-r--r-- | hurd/Makefile | 1 | ||||
-rw-r--r-- | hurd/Versions | 9 | ||||
-rw-r--r-- | hurd/hurdlock.c | 247 | ||||
-rw-r--r-- | hurd/hurdlock.h | 117 | ||||
-rw-r--r-- | hurd/hurdpid.c | 3 | ||||
-rw-r--r-- | hurd/hurdsig.c | 4 | ||||
-rw-r--r-- | hurd/setauth.c | 5 | ||||
-rw-r--r-- | hurd/sysvshm.c | 3 |
8 files changed, 383 insertions, 6 deletions
diff --git a/hurd/Makefile b/hurd/Makefile index 85c295ac06..59e7d42355 100644 --- a/hurd/Makefile +++ b/hurd/Makefile @@ -56,6 +56,7 @@ routines = hurdstartup hurdinit \ ports-get ports-set hurdports hurdmsg \ errno-loc \ sysvshm \ + hurdlock \ $(sig) $(dtable) $(inlines) port-cleanup report-wait xattr sig = hurdsig hurdfault siginfo hurd-raise preempt-sig \ trampoline longjmp-ts catch-exc exc2signal hurdkill sigunwind \ diff --git a/hurd/Versions b/hurd/Versions index b80323293e..7502d32a22 100644 --- a/hurd/Versions +++ b/hurd/Versions @@ -152,4 +152,13 @@ libc { cthread_keycreate; cthread_getspecific; cthread_setspecific; __libc_getspecific; } + + GLIBC_PRIVATE { + # Used by other libs. + lll_xwait; lll_timed_wait; lll_timed_xwait; + __lll_abstimed_wait; __lll_abstimed_xwait; + __lll_abstimed_lock; lll_robust_lock; + __lll_robust_abstimed_lock; lll_robust_trylock; + lll_set_wake; lll_robust_unlock; lll_requeue; + } } diff --git a/hurd/hurdlock.c b/hurd/hurdlock.c new file mode 100644 index 0000000000..d6e47316ea --- /dev/null +++ b/hurd/hurdlock.c @@ -0,0 +1,247 @@ +/* Copyright (C) 1999-2016 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +#include "hurdlock.h" +#include <hurd.h> +#include <time.h> +#include <errno.h> + +int lll_xwait (void *ptr, int lo, int hi, int flags) +{ + return (__gsync_wait (__mach_task_self (), + (vm_offset_t)ptr, lo, hi, 0, flags | GSYNC_QUAD)); +} + +int lll_timed_wait (void *ptr, int val, int mlsec, int flags) +{ + return (__gsync_wait (__mach_task_self (), + (vm_offset_t)ptr, val, 0, mlsec, flags | GSYNC_TIMED)); +} + +int lll_timed_xwait (void *ptr, int lo, + int hi, int mlsec, int flags) +{ + return (__gsync_wait (__mach_task_self (), (vm_offset_t)ptr, + lo, hi, mlsec, flags | GSYNC_TIMED | GSYNC_QUAD)); +} + +/* Convert an absolute timeout in nanoseconds to a relative + * timeout in milliseconds. */ +static inline int __attribute__ ((gnu_inline)) +compute_reltime (const struct timespec *abstime, clockid_t clk) +{ + struct timespec ts; + __clock_gettime (clk, &ts); + + ts.tv_sec = abstime->tv_sec - ts.tv_sec; + ts.tv_nsec = abstime->tv_nsec - ts.tv_nsec; + + if (ts.tv_nsec < 0) + { + --ts.tv_sec; + ts.tv_nsec += 1000000000; + } + + return (ts.tv_sec < 0 ? -1 : + (int)(ts.tv_sec * 1000 + ts.tv_nsec / 1000000)); +} + +int __lll_abstimed_wait (void *ptr, int val, + const struct timespec *tsp, int flags, int clk) +{ + int mlsec = compute_reltime (tsp, clk); + return (mlsec < 0 ? KERN_TIMEDOUT : + lll_timed_wait (ptr, val, mlsec, flags)); +} + +int __lll_abstimed_xwait (void *ptr, int lo, int hi, + const struct timespec *tsp, int flags, int clk) +{ + int mlsec = compute_reltime (tsp, clk); + return (mlsec < 0 ? KERN_TIMEDOUT : + lll_timed_xwait (ptr, lo, hi, mlsec, flags)); +} + +int __lll_abstimed_lock (void *ptr, + const struct timespec *tsp, int flags, int clk) +{ + if (lll_trylock (ptr) == 0) + return (0); + + while (1) + { + if (atomic_exchange_acq ((int *)ptr, 2) == 0) + return (0); + else if (tsp->tv_nsec < 0 || tsp->tv_nsec >= 1000000000) + return (EINVAL); + + int mlsec = compute_reltime (tsp, clk); + if (mlsec < 0 || lll_timed_wait (ptr, + 2, mlsec, flags) == KERN_TIMEDOUT) + return (ETIMEDOUT); + } +} + +void lll_set_wake (void *ptr, int val, int flags) +{ + __gsync_wake (__mach_task_self (), + (vm_offset_t)ptr, val, flags | GSYNC_MUTATE); +} + +void lll_requeue (void *src, void *dst, int wake_one, int flags) +{ + __gsync_requeue (__mach_task_self (), (vm_offset_t)src, + (vm_offset_t)dst, (boolean_t)wake_one, flags); +} + +/* Robust locks. */ + +extern int __getpid (void) __attribute__ ((const)); +extern task_t __pid2task (int); + +/* Test if a given process id is still valid. */ +static inline int valid_pid (int pid) +{ + task_t task = __pid2task (pid); + if (task == MACH_PORT_NULL) + return (0); + + __mach_port_deallocate (__mach_task_self (), task); + return (1); +} + +/* Robust locks have currently no support from the kernel; they + * are simply implemented with periodic polling. When sleeping, the + * maximum blocking time is determined by this constant. */ +#define MAX_WAIT_TIME 1500 + +int lll_robust_lock (void *ptr, int flags) +{ + int *iptr = (int *)ptr; + int id = __getpid (); + int wait_time = 25; + unsigned int val; + + /* Try to set the lock word to our PID if it's clear. Otherwise, + * mark it as having waiters. */ + while (1) + { + val = *iptr; + if (!val && atomic_compare_and_exchange_bool_acq (iptr, id, 0) == 0) + return (0); + else if (atomic_compare_and_exchange_bool_acq (iptr, + val | LLL_WAITERS, val) == 0) + break; + } + + for (id |= LLL_WAITERS ; ; ) + { + val = *iptr; + if (!val && atomic_compare_and_exchange_bool_acq (iptr, id, 0) == 0) + return (0); + else if (val && !valid_pid (val & LLL_OWNER_MASK)) + { + if (atomic_compare_and_exchange_bool_acq (iptr, id, val) == 0) + return (EOWNERDEAD); + } + else + { + lll_timed_wait (iptr, val, wait_time, flags); + if (wait_time < MAX_WAIT_TIME) + wait_time <<= 1; + } + } +} + +int __lll_robust_abstimed_lock (void *ptr, + const struct timespec *tsp, int flags, int clk) +{ + int *iptr = (int *)ptr; + int id = __getpid (); + int wait_time = 25; + unsigned int val; + + while (1) + { + val = *iptr; + if (!val && atomic_compare_and_exchange_bool_acq (iptr, id, 0) == 0) + return (0); + else if (atomic_compare_and_exchange_bool_acq (iptr, + val | LLL_WAITERS, val) == 0) + break; + } + + for (id |= LLL_WAITERS ; ; ) + { + val = *iptr; + if (!val && atomic_compare_and_exchange_bool_acq (iptr, id, 0) == 0) + return (0); + else if (val && !valid_pid (val & LLL_OWNER_MASK)) + { + if (atomic_compare_and_exchange_bool_acq (iptr, id, val) == 0) + return (EOWNERDEAD); + } + else + { + int mlsec = compute_reltime (tsp, clk); + if (mlsec < 0) + return (ETIMEDOUT); + else if (mlsec > wait_time) + mlsec = wait_time; + + int res = lll_timed_wait (iptr, val, mlsec, flags); + if (res == KERN_TIMEDOUT) + return (ETIMEDOUT); + else if (wait_time < MAX_WAIT_TIME) + wait_time <<= 1; + } + } +} + +int lll_robust_trylock (void *ptr) +{ + int *iptr = (int *)ptr; + int id = __getpid (); + unsigned int val = *iptr; + + if (!val) + { + if (atomic_compare_and_exchange_bool_acq (iptr, id, 0) == 0) + return (0); + } + else if (!valid_pid (val & LLL_OWNER_MASK) && + atomic_compare_and_exchange_bool_acq (iptr, id, val) == 0) + return (EOWNERDEAD); + + return (EBUSY); +} + +void lll_robust_unlock (void *ptr, int flags) +{ + while (1) + { + unsigned int val = *(unsigned int *)ptr; + if (val & LLL_WAITERS) + { + lll_set_wake (ptr, 0, flags); + break; + } + else if (atomic_compare_and_exchange_bool_rel ((int *)ptr, 0, val) == 0) + break; + } +} + diff --git a/hurd/hurdlock.h b/hurd/hurdlock.h new file mode 100644 index 0000000000..405ffaf5f9 --- /dev/null +++ b/hurd/hurdlock.h @@ -0,0 +1,117 @@ +/* Copyright (C) 1999-2016 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +#ifndef _HURD_LOCK_H +#define _HURD_LOCK_H 1 + +#include <mach/lowlevellock.h> + +struct timespec; + +/* Flags for robust locks. */ +#define LLL_WAITERS (1U << 31) +#define LLL_DEAD_OWNER (1U << 30) + +#define LLL_OWNER_MASK ~(LLL_WAITERS | LLL_DEAD_OWNER) + +/* Wait on 64-bit address PTR, without blocking if its contents + * are different from the pair <LO, HI>. */ +extern int lll_xwait (void *__ptr, int __lo, + int __hi, int __flags); + +/* Same as 'lll_wait', but only block for MLSEC milliseconds. */ +extern int lll_timed_wait (void *__ptr, int __val, + int __mlsec, int __flags); + +/* Same as 'lll_xwait', but only block for MLSEC milliseconds. */ +extern int lll_timed_xwait (void *__ptr, int __lo, + int __hi, int __mlsec, int __flags); + +/* 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); + +/* Same as 'lll_xwait', but only block until TSP elapses, + * using clock CLK. */ +extern int __lll_abstimed_xwait (void *__ptr, int __lo, int __hi, + const struct timespec *__tsp, int __flags, int __clk); + +/* Same as 'lll_lock', but return with an error if TSP elapses, + * using clock CLK. */ +extern int __lll_abstimed_lock (void *__ptr, + const struct timespec *__tsp, int __flags, int __clk); + +/* 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); + +/* Same as 'lll_robust_lock', but only block until TSP + * elapses, using clock CLK. */ +extern int __lll_robust_abstimed_lock (void *__ptr, + const struct timespec *__tsp, int __flags, int __clk); + +/* 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); + +/* Wake one or more threads waiting on address PTR, + * setting its value to VAL before doing so. */ +extern void lll_set_wake (void *__ptr, int __val, int __flags); + +/* Release the robust lock at PTR. */ +extern void lll_robust_unlock (void *__ptr, int __flags); + +/* Rearrange threads waiting on address SRC to instead wait on + * DST, waking one of them if WAIT_ONE is non-zero. */ +extern void lll_requeue (void *__src, void *__dst, + int __wake_one, int __flags); + +/* The following are hacks that allow us to simulate optional + * parameters in C, to avoid having to pass the clock id for + * every one of these calls, defaulting to CLOCK_REALTIME if + * no argument is passed. */ + +#define lll_abstimed_wait(ptr, val, tsp, flags, ...) \ + ({ \ + const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ + __lll_abstimed_wait ((ptr), (val), (tsp), (flags), \ + __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ + }) + +#define lll_abstimed_xwait(ptr, lo, hi, tsp, flags, ...) \ + ({ \ + const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ + __lll_abstimed_xwait ((ptr), (lo), (hi), (tsp), (flags), \ + __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ + }) + +#define lll_abstimed_lock(ptr, tsp, flags, ...) \ + ({ \ + const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ + __lll_abstimed_lock ((ptr), (tsp), (flags), \ + __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ + }) + +#define lll_robust_abstimed_lock(ptr, tsp, flags, ...) \ + ({ \ + const clockid_t __clk[] = { CLOCK_REALTIME, ##__VA_ARGS__ }; \ + __lll_robust_abstimed_lock ((ptr), (tsp), (flags), \ + __clk[sizeof (__clk) / sizeof (__clk[0]) - 1]); \ + }) + +#endif diff --git a/hurd/hurdpid.c b/hurd/hurdpid.c index 633ad6db24..56df97c6b8 100644 --- a/hurd/hurdpid.c +++ b/hurd/hurdpid.c @@ -16,6 +16,8 @@ <http://www.gnu.org/licenses/>. */ #include <hurd.h> +#include <lowlevellock.h> + pid_t _hurd_pid, _hurd_ppid, _hurd_pgrp; int _hurd_orphaned; @@ -66,6 +68,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); return 0; } diff --git a/hurd/hurdsig.c b/hurd/hurdsig.c index 5ed63b900a..072a870337 100644 --- a/hurd/hurdsig.c +++ b/hurd/hurdsig.c @@ -1572,14 +1572,14 @@ reauth_proc (mach_port_t new) __mach_port_destroy (__mach_task_self (), ref); /* Set the owner of the process here too. */ - mutex_lock (&_hurd_id.lock); + __mutex_lock (&_hurd_id.lock); if (!_hurd_check_ids ()) HURD_PORT_USE (&_hurd_ports[INIT_PORT_PROC], __proc_setowner (port, (_hurd_id.gen.nuids ? _hurd_id.gen.uids[0] : 0), !_hurd_id.gen.nuids)); - mutex_unlock (&_hurd_id.lock); + __mutex_unlock (&_hurd_id.lock); (void) &reauth_proc; /* Silence compiler warning. */ } diff --git a/hurd/setauth.c b/hurd/setauth.c index 916772f21b..b835c0a80a 100644 --- a/hurd/setauth.c +++ b/hurd/setauth.c @@ -18,14 +18,13 @@ #include <hurd.h> #include <hurd/port.h> #include <hurd/id.h> +#include <hurdlock.h> #include "set-hooks.h" /* Things in the library which want to be run when the auth port changes. */ DEFINE_HOOK (_hurd_reauth_hook, (auth_t new_auth)); -#include <cthreads.h> -static struct mutex reauth_lock = MUTEX_INITIALIZER; - +static unsigned int reauth_lock = LLL_INITIALIZER; /* Set the auth port to NEW, and reauthenticate everything used by the library. */ diff --git a/hurd/sysvshm.c b/hurd/sysvshm.c index 5d538a6373..e049345135 100644 --- a/hurd/sysvshm.c +++ b/hurd/sysvshm.c @@ -26,6 +26,7 @@ #include <dirent.h> #include <sys/stat.h> #include <sys/shm.h> +#include <hurdlock.h> /* Description of an shm attachment. */ @@ -45,7 +46,7 @@ struct sysvshm_attach static struct sysvshm_attach *sysvshm_list; /* A lock to protect the linked list of shared memory attachments. */ -static struct mutex sysvshm_lock = MUTEX_INITIALIZER; +static unsigned int sysvshm_lock = LLL_INITIALIZER; /* Adds a segment attachment. */ |