1 /* Copyright (C) 2003-2014 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
20 #include <lowlevellock.h>
24 unsigned long int __fork_generation attribute_hidden
;
28 clear_once_control (void *arg
)
30 pthread_once_t
*once_control
= (pthread_once_t
*) arg
;
32 /* Reset to the uninitialized state here. We don't need a stronger memory
33 order because we do not need to make any other of our writes visible to
34 other threads that see this value: This function will be called if we
35 get interrupted (see __pthread_once), so all we need to relay to other
36 threads is the state being reset again. */
38 lll_futex_wake (once_control
, INT_MAX
, LLL_PRIVATE
);
42 /* This is similar to a lock implementation, but we distinguish between three
43 states: not yet initialized (0), initialization in progress
44 (__fork_generation | __PTHREAD_ONCE_INPROGRESS), and initialization
45 finished (__PTHREAD_ONCE_DONE); __fork_generation does not use the bits
46 that are used for __PTHREAD_ONCE_INPROGRESS and __PTHREAD_ONCE_DONE (which
47 is what __PTHREAD_ONCE_FORK_GEN_INCR is used for). If in the first state,
48 threads will try to run the initialization by moving to the second state;
49 the first thread to do so via a CAS on once_control runs init_routine,
51 When forking the process, some threads can be interrupted during the second
52 state; they won't be present in the forked child, so we need to restart
53 initialization in the child. To distinguish an in-progress initialization
54 from an interrupted initialization (in which case we need to reclaim the
55 lock), we look at the fork generation that's part of the second state: We
56 can reclaim iff it differs from the current fork generation.
57 XXX: This algorithm has an ABA issue on the fork generation: If an
58 initialization is interrupted, we then fork 2^30 times (30 bits of
59 once_control are used for the fork generation), and try to initialize
60 again, we can deadlock because we can't distinguish the in-progress and
61 interrupted cases anymore.
62 XXX: We split out this slow path because current compilers do not generate
63 as efficient code when the fast path in __pthread_once below is not in a
66 __attribute__ ((noinline
))
67 __pthread_once_slow (pthread_once_t
*once_control
, void (*init_routine
) (void))
71 int oldval
, val
, newval
;
73 /* We need acquire memory order for this load because if the value
74 signals that initialization has finished, we need to see any
75 data modifications done during initialization. */
77 atomic_read_barrier ();
80 /* Check if the initialization has already been done. */
81 if (__glibc_likely ((val
& __PTHREAD_ONCE_DONE
) != 0))
85 /* We try to set the state to in-progress and having the current
86 fork generation. We don't need atomic accesses for the fork
87 generation because it's immutable in a particular process, and
88 forked child processes start with a single thread that modified
90 newval
= __fork_generation
| __PTHREAD_ONCE_INPROGRESS
;
91 /* We need acquire memory order here for the same reason as for the
92 load from once_control above. */
93 val
= atomic_compare_and_exchange_val_acq (once_control
, newval
,
96 while (__glibc_unlikely (val
!= oldval
));
98 /* Check if another thread already runs the initializer. */
99 if ((oldval
& __PTHREAD_ONCE_INPROGRESS
) != 0)
101 /* Check whether the initializer execution was interrupted by a
102 fork. We know that for both values, __PTHREAD_ONCE_INPROGRESS
103 is set and __PTHREAD_ONCE_DONE is not. */
104 if (oldval
== newval
)
106 /* Same generation, some other thread was faster. Wait. */
107 lll_futex_wait (once_control
, newval
, LLL_PRIVATE
);
112 /* This thread is the first here. Do the initialization.
113 Register a cleanup handler so that in case the thread gets
114 interrupted the initialization can be restarted. */
115 pthread_cleanup_push (clear_once_control
, once_control
);
119 pthread_cleanup_pop (0);
122 /* Mark *once_control as having finished the initialization. We need
123 release memory order here because we need to synchronize with other
124 threads that want to use the initialized data. */
125 atomic_write_barrier ();
126 *once_control
= __PTHREAD_ONCE_DONE
;
128 /* Wake up all other threads. */
129 lll_futex_wake (once_control
, INT_MAX
, LLL_PRIVATE
);
137 __pthread_once (pthread_once_t
*once_control
, void (*init_routine
) (void))
139 /* Fast path. See __pthread_once_slow. */
142 atomic_read_barrier ();
143 if (__glibc_likely ((val
& __PTHREAD_ONCE_DONE
) != 0))
146 return __pthread_once_slow (once_control
, init_routine
);
148 weak_alias (__pthread_once
, pthread_once
)
149 hidden_def (__pthread_once
)