[Glibc-bsd-commits] r5490 - trunk/glibc-ports/kfreebsd/fbtl
ps-guest at alioth.debian.org
ps-guest at alioth.debian.org
Sat Jul 12 08:37:53 UTC 2014
Author: ps-guest
Date: 2014-07-12 08:37:53 +0000 (Sat, 12 Jul 2014)
New Revision: 5490
Modified:
trunk/glibc-ports/kfreebsd/fbtl/pthread_once.c
Log:
sync pthread_once.c with current generic nptl version
Modified: trunk/glibc-ports/kfreebsd/fbtl/pthread_once.c
===================================================================
--- trunk/glibc-ports/kfreebsd/fbtl/pthread_once.c 2014-07-12 08:37:06 UTC (rev 5489)
+++ trunk/glibc-ports/kfreebsd/fbtl/pthread_once.c 2014-07-12 08:37:53 UTC (rev 5490)
@@ -1,4 +1,4 @@
-/* Copyright (C) 2003-2013 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2014 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Jakub Jelinek <jakub at redhat.com>, 2003.
@@ -18,6 +18,7 @@
#include "pthreadP.h"
#include <lowlevellock.h>
+#include <atomic.h>
unsigned long int __fork_generation attribute_hidden;
@@ -28,11 +29,33 @@
{
pthread_once_t *once_control = (pthread_once_t *) arg;
+ /* Reset to the uninitialized state here. We don't need a stronger memory
+ order because we do not need to make any other of our writes visible to
+ other threads that see this value: This function will be called if we
+ get interrupted (see __pthread_once), so all we need to relay to other
+ threads is the state being reset again. */
*once_control = 0;
lll_futex_wake (once_control, INT_MAX, LLL_PRIVATE);
}
+/* This is similar to a lock implementation, but we distinguish between three
+ states: not yet initialized (0), initialization finished (2), and
+ initialization in progress (__fork_generation | 1). If in the first state,
+ threads will try to run the initialization by moving to the second state;
+ the first thread to do so via a CAS on once_control runs init_routine,
+ other threads block.
+ When forking the process, some threads can be interrupted during the second
+ state; they won't be present in the forked child, so we need to restart
+ initialization in the child. To distinguish an in-progress initialization
+ from an interrupted initialization (in which case we need to reclaim the
+ lock), we look at the fork generation that's part of the second state: We
+ can reclaim iff it differs from the current fork generation.
+ XXX: This algorithm has an ABA issue on the fork generation: If an
+ initialization is interrupted, we then fork 2^30 times (30 bits of
+ once_control are used for the fork generation), and try to initialize
+ again, we can deadlock because we can't distinguish the in-progress and
+ interrupted cases anymore. */
int
__pthread_once (once_control, init_routine)
pthread_once_t *once_control;
@@ -42,26 +65,38 @@
{
int oldval, val, newval;
+ /* We need acquire memory order for this load because if the value
+ signals that initialization has finished, we need to be see any
+ data modifications done during initialization. */
val = *once_control;
+ atomic_read_barrier();
do
{
- /* Check if the initialized has already been done. */
- if ((val & 2) != 0)
+ /* Check if the initialization has already been done. */
+ if (__glibc_likely ((val & 2) != 0))
return 0;
oldval = val;
- newval = (oldval & 3) | __fork_generation | 1;
+ /* We try to set the state to in-progress and having the current
+ fork generation. We don't need atomic accesses for the fork
+ generation because it's immutable in a particular process, and
+ forked child processes start with a single thread that modified
+ the generation. */
+ newval = __fork_generation | 1;
+ /* We need acquire memory order here for the same reason as for the
+ load from once_control above. */
val = atomic_compare_and_exchange_val_acq (once_control, newval,
oldval);
}
- while (__builtin_expect (val != oldval, 0));
+ while (__glibc_unlikely (val != oldval));
/* Check if another thread already runs the initializer. */
if ((oldval & 1) != 0)
{
- /* Check whether the initializer execution was interrupted
- by a fork. */
- if (((oldval ^ newval) & -4) == 0)
+ /* Check whether the initializer execution was interrupted by a
+ fork. We know that for both values, bit 0 is set and bit 1 is
+ not. */
+ if (oldval == newval)
{
/* Same generation, some other thread was faster. Wait. */
lll_futex_wait (once_control, newval, LLL_PRIVATE);
@@ -79,8 +114,11 @@
pthread_cleanup_pop (0);
- /* Add one to *once_control. */
- atomic_increment (once_control);
+ /* Mark *once_control as having finished the initialization. We need
+ release memory order here because we need to synchronize with other
+ threads that want to use the initialized data. */
+ atomic_write_barrier();
+ *once_control = 2;
/* Wake up all other threads. */
lll_futex_wake (once_control, INT_MAX, LLL_PRIVATE);
More information about the Glibc-bsd-commits
mailing list