Index: compat/linux/linux_futex.c =================================================================== --- compat/linux/linux_futex.c (revision 218951) +++ compat/linux/linux_futex.c (working copy) @@ -52,6 +52,7 @@ #include #include #include +#include #ifdef COMPAT_LINUX32 #include @@ -77,7 +78,8 @@ struct futex { struct sx f_lck; - uint32_t *f_uaddr; + uint32_t *f_uaddr; /* user-supplied value, for debug */ + struct umtx_key f_key; uint32_t f_refcount; uint32_t f_bitset; LIST_ENTRY(futex) f_list; @@ -100,6 +102,7 @@ #define FUTEX_CREATE_WP 0x1 /* create waiting_proc */ #define FUTEX_DONTCREATE 0x2 /* don't create futex if not exists */ #define FUTEX_DONTEXISTS 0x4 /* return EINVAL if futex exists */ +#define FUTEX_SHARED 0x8 /* shared futex */ /* wp_flags */ #define FUTEX_WP_REQUEUED 0x1 /* wp requeued - wp moved from wp_list @@ -136,6 +139,7 @@ LINUX_CTR2(sys_futex, "futex_put destroy uaddr %p ref %d", f->f_uaddr, f->f_refcount); + umtx_key_release(&f->f_key); FUTEX_DESTROY(f); free(f, M_FUTEX); return; @@ -151,13 +155,19 @@ futex_get0(uint32_t *uaddr, struct futex **newf, uint32_t flags) { struct futex *f, *tmpf; + struct umtx_key key; + int error; *newf = tmpf = NULL; + error = umtx_key_get(uaddr, TYPE_FUTEX, (flags & FUTEX_SHARED) ? + PROCESS_SHARE : THREAD_SHARE, &key); + if (error) + return (error); retry: FUTEXES_LOCK; LIST_FOREACH(f, &futex_list, f_list) { - if (f->f_uaddr == uaddr) { + if (umtx_key_match(&f->f_key, &key)) { if (tmpf != NULL) { FUTEX_UNLOCK(tmpf); FUTEX_DESTROY(tmpf); @@ -165,6 +175,7 @@ } if (flags & FUTEX_DONTEXISTS) { FUTEXES_UNLOCK; + umtx_key_release(&key); return (EINVAL); } @@ -174,6 +185,7 @@ */ ++f->f_refcount; FUTEXES_UNLOCK; + umtx_key_release(&key); FUTEX_LOCK(f); *newf = f; @@ -185,6 +197,7 @@ if (flags & FUTEX_DONTCREATE) { FUTEXES_UNLOCK; + umtx_key_release(&key); LINUX_CTR1(sys_futex, "futex_get uaddr %p null", uaddr); return (0); } @@ -193,6 +206,7 @@ FUTEXES_UNLOCK; tmpf = malloc(sizeof(*tmpf), M_FUTEX, M_WAITOK | M_ZERO); tmpf->f_uaddr = uaddr; + tmpf->f_key = key; tmpf->f_refcount = 1; tmpf->f_bitset = FUTEX_BITSET_MATCH_ANY; FUTEX_INIT(tmpf); @@ -438,15 +452,13 @@ struct waiting_proc *wp; struct futex *f, *f2; int error; + uint32_t flags; - /* - * Our implementation provides only privates futexes. Most of the apps - * should use private futexes but don't claim so. Therefore we treat - * all futexes as private by clearing the FUTEX_PRIVATE_FLAG. It works - * in most cases (ie. when futexes are not shared on file descriptor - * or between different processes.). - */ - args->op = args->op & ~LINUX_FUTEX_PRIVATE_FLAG; + if (args->op & LINUX_FUTEX_PRIVATE_FLAG) { + flags = 0; + args->op &= ~LINUX_FUTEX_PRIVATE_FLAG; + } else + flags = FUTEX_SHARED; /* * Currently support for switching between CLOCK_MONOTONIC and @@ -478,7 +490,8 @@ "futex_wait uaddr %p val %d val3 %d"), args->uaddr, args->val, args->val3); #endif - error = futex_get(args->uaddr, &wp, &f, FUTEX_CREATE_WP); + error = futex_get(args->uaddr, &wp, &f, + flags | FUTEX_CREATE_WP); if (error) return (error); error = copyin(args->uaddr, &val, sizeof(val)); @@ -518,7 +531,8 @@ printf(ARGS(sys_futex, "futex_wake uaddr %p val %d val3 %d"), args->uaddr, args->val, args->val3); #endif - error = futex_get(args->uaddr, NULL, &f, FUTEX_DONTCREATE); + error = futex_get(args->uaddr, NULL, &f, + flags | FUTEX_DONTCREATE); if (error) return (error); if (f == NULL) { @@ -550,7 +564,7 @@ */ if (args->uaddr == args->uaddr2) return (EINVAL); - error = futex_get0(args->uaddr, &f, 0); + error = futex_get(args->uaddr, NULL, &f, flags); if (error) return (error); @@ -561,7 +575,8 @@ * Glibc fall back to FUTEX_WAKE in case of any error * returned by FUTEX_CMP_REQUEUE. */ - error = futex_get0(args->uaddr2, &f2, FUTEX_DONTEXISTS); + error = futex_get(args->uaddr2, NULL, &f2, + flags | FUTEX_DONTEXISTS); if (error) { futex_put(f, NULL); return (error); @@ -602,11 +617,11 @@ args->uaddr, args->op, args->val, args->uaddr2, args->val3); #endif - error = futex_get0(args->uaddr, &f, 0); + error = futex_get(args->uaddr, NULL, &f, flags); if (error) return (error); if (args->uaddr != args->uaddr2) - error = futex_get0(args->uaddr2, &f2, 0); + error = futex_get(args->uaddr2, NULL, &f2, flags); if (error) { futex_put(f, NULL); return (error); @@ -800,7 +815,7 @@ if (!pi && (uval & FUTEX_WAITERS)) { error = futex_get(uaddr, NULL, &f, - FUTEX_DONTCREATE); + FUTEX_DONTCREATE | FUTEX_SHARED); if (error) return (error); if (f != NULL) { Index: kern/kern_umtx.c =================================================================== --- kern/kern_umtx.c (revision 218951) +++ kern/kern_umtx.c (working copy) @@ -59,41 +59,9 @@ #include #endif -enum { - TYPE_SIMPLE_WAIT, - TYPE_CV, - TYPE_SEM, - TYPE_SIMPLE_LOCK, - TYPE_NORMAL_UMUTEX, - TYPE_PI_UMUTEX, - TYPE_PP_UMUTEX, - TYPE_RWLOCK -}; - #define _UMUTEX_TRY 1 #define _UMUTEX_WAIT 2 -/* Key to represent a unique userland synchronous object */ -struct umtx_key { - int hash; - int type; - int shared; - union { - struct { - vm_object_t object; - uintptr_t offset; - } shared; - struct { - struct vmspace *vs; - uintptr_t addr; - } private; - struct { - void *a; - uintptr_t b; - } both; - } info; -}; - /* Priority inheritance mutex info. */ struct umtx_pi { /* Owner thread */ @@ -208,10 +176,6 @@ #define UMTX_CHAINS 512 #define UMTX_SHIFTS (__WORD_BIT - 9) -#define THREAD_SHARE 0 -#define PROCESS_SHARE 1 -#define AUTO_SHARE 2 - #define GET_SHARE(flags) \ (((flags) & USYNC_PROCESS_SHARED) == 0 ? THREAD_SHARE : PROCESS_SHARE) @@ -237,10 +201,6 @@ static void umtxq_remove_queue(struct umtx_q *uq, int q); static int umtxq_sleep(struct umtx_q *uq, const char *wmesg, int timo); static int umtxq_count(struct umtx_key *key); -static int umtx_key_match(const struct umtx_key *k1, const struct umtx_key *k2); -static int umtx_key_get(void *addr, int type, int share, - struct umtx_key *key); -static void umtx_key_release(struct umtx_key *key); static struct umtx_pi *umtx_pi_alloc(int); static void umtx_pi_free(struct umtx_pi *pi); static int do_unlock_pp(struct thread *td, struct umutex *m, uint32_t flags); @@ -307,14 +267,6 @@ key->hash = ((n * GOLDEN_RATIO_PRIME) >> UMTX_SHIFTS) % UMTX_CHAINS; } -static inline int -umtx_key_match(const struct umtx_key *k1, const struct umtx_key *k2) -{ - return (k1->type == k2->type && - k1->info.both.a == k2->info.both.a && - k1->info.both.b == k2->info.both.b); -} - static inline struct umtxq_chain * umtxq_getchain(struct umtx_key *key) { @@ -567,7 +519,7 @@ /* * Convert userspace address into unique logical address. */ -static int +int umtx_key_get(void *addr, int type, int share, struct umtx_key *key) { struct thread *td = curthread; @@ -613,7 +565,7 @@ /* * Release key. */ -static inline void +void umtx_key_release(struct umtx_key *key) { if (key->shared) Index: sys/umtx.h =================================================================== --- sys/umtx.h (revision 218951) +++ sys/umtx.h (working copy) @@ -171,8 +171,60 @@ #else +/* + * The umtx_key structure is used by both the Linux futex code and the + * umtx implementation to map userland addresses to unique keys. + */ + +enum { + TYPE_SIMPLE_WAIT, + TYPE_CV, + TYPE_SEM, + TYPE_SIMPLE_LOCK, + TYPE_NORMAL_UMUTEX, + TYPE_PI_UMUTEX, + TYPE_PP_UMUTEX, + TYPE_RWLOCK, + TYPE_FUTEX +}; + +/* Key to represent a unique userland synchronous object */ +struct umtx_key { + int hash; + int type; + int shared; + union { + struct { + struct vm_object *object; + uintptr_t offset; + } shared; + struct { + struct vmspace *vs; + uintptr_t addr; + } private; + struct { + void *a; + uintptr_t b; + } both; + } info; +}; + +#define THREAD_SHARE 0 +#define PROCESS_SHARE 1 +#define AUTO_SHARE 2 + struct thread; +static inline int +umtx_key_match(const struct umtx_key *k1, const struct umtx_key *k2) +{ + return (k1->type == k2->type && + k1->info.both.a == k2->info.both.a && + k1->info.both.b == k2->info.both.b); +} + +int umtx_key_get(void *, int, int, struct umtx_key *); +void umtx_key_release(struct umtx_key *); struct umtx_q *umtxq_alloc(void); void umtxq_free(struct umtx_q *); int kern_umtx_wake(struct thread *, void *, int, int);