From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1791) id F423C3984025; Tue, 8 Jun 2021 20:48:24 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org F423C3984025 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Adhemerval Zanella To: glibc-cvs@sourceware.org Subject: [glibc/azanella/pthread-multiple-fixes] nptl: Handle robust PI mutexes for !__ASSUME_SET_ROBUST_LIST X-Act-Checkin: glibc X-Git-Author: Adhemerval Zanella X-Git-Refname: refs/heads/azanella/pthread-multiple-fixes X-Git-Oldrev: 12c7358b250a3adf48c1d50b092aa055a1cd8230 X-Git-Newrev: b67a586c4596e06bf7d75a7306954d378d4a214b Message-Id: <20210608204824.F423C3984025@sourceware.org> Date: Tue, 8 Jun 2021 20:48:24 +0000 (GMT) X-BeenThere: glibc-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Glibc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 08 Jun 2021 20:48:25 -0000 https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=b67a586c4596e06bf7d75a7306954d378d4a214b commit b67a586c4596e06bf7d75a7306954d378d4a214b Author: Adhemerval Zanella Date: Mon Jun 7 11:52:35 2021 -0300 nptl: Handle robust PI mutexes for !__ASSUME_SET_ROBUST_LIST The robust PI mutexes are signaled by setting the LSB bit to 1, so the code requires to ignore before access the __pthread_mutex_s fields. The code is also simplifies (the initialization code is not really required, pd->robust_head.list and pd->robust_list.__next are essentially the same for !__PTHREAD_MUTEX_HAVE_PREV), the futex wake is optimized to be issued only when required, the the futex shared bit is set only when required. Checked on a build for m68k-linux-gnu. Diff: --- nptl/pthread_create.c | 47 +++++++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 22 deletions(-) diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c index 3004f38254..5ade1bd461 100644 --- a/nptl/pthread_create.c +++ b/nptl/pthread_create.c @@ -479,34 +479,37 @@ start_thread (void *arg) #ifndef __ASSUME_SET_ROBUST_LIST /* If this thread has any robust mutexes locked, handle them now. */ -# if __PTHREAD_MUTEX_HAVE_PREV - void *robust = pd->robust_head.list; -# else - __pthread_slist_t *robust = pd->robust_list.__next; -# endif + void **robust; /* We let the kernel do the notification if it is able to do so. If we have to do it here there for sure are no PI mutexes involved since the kernel support for them is even more recent. */ - if (!__nptl_set_robust_list_avail - && __builtin_expect (robust != (void *) &pd->robust_head, 0)) + while ((robust = pd->robust_head.list) + && robust != (void *) &pd->robust_head) { - do + /* Note: robust PI futexes are signaled by setting bit 0. */ + void **robustp = (void **) ((uintptr_t) robust & ~1UL); + + struct __pthread_mutex_s *mtx = (struct __pthread_mutex_s *) + ((char *) robustp - offsetof (struct __pthread_mutex_s, + __list.__next)); + unsigned int nusers = mtx->__nusers; + int shared = mtx->__kind & 128; + + pd->robust_head.list_op_pending = robust; + pd->robust_head.list = *robustp; + /* Although the list won't be change at this point, it follows the + expected kernel ABI. */ + __asm ("" ::: "memory"); + + int lock = atomic_exchange_relaxed (&mtx->__lock, FUTEX_OWNER_DIED); + /* Wake any users if mutex is acquired with potential users. */ + if (lock > 1 || nusers != 0) { - struct __pthread_mutex_s *this = (struct __pthread_mutex_s *) - ((char *) robust - offsetof (struct __pthread_mutex_s, - __list.__next)); - robust = *((void **) robust); - -# if __PTHREAD_MUTEX_HAVE_PREV - this->__list.__prev = NULL; -# endif - this->__list.__next = NULL; - - atomic_or (&this->__lock, FUTEX_OWNER_DIED); - futex_wake ((unsigned int *) &this->__lock, 1, - /* XYZ */ FUTEX_SHARED); + if ((uintptr_t) robust & 1) + futex_unlock_pi ((unsigned int *) &mtx->__lock, shared); + else + futex_wake ((unsigned int *) &mtx->__lock, 1, shared); } - while (robust != (void *) &pd->robust_head); } #endif