2 * Copyright (c) 2014 Nicira, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include "guarded-list.h"
21 #include "ovs-thread.h"
22 #include "poll-loop.h"
27 VLOG_DEFINE_THIS_MODULE(ovs_rcu);
30 void (*function)(void *aux);
35 struct list list_node;
36 struct ovsrcu_cb cbs[16];
40 struct ovsrcu_perthread {
41 struct list list_node; /* In global list. */
43 struct ovs_mutex mutex;
45 struct ovsrcu_cbset *cbset;
46 char name[16]; /* This thread's name. */
49 static struct seq *global_seqno;
51 static pthread_key_t perthread_key;
52 static struct list ovsrcu_threads;
53 static struct ovs_mutex ovsrcu_threads_mutex;
55 static struct guarded_list flushed_cbsets;
56 static struct seq *flushed_cbsets_seq;
58 static void ovsrcu_init(void);
59 static void ovsrcu_flush_cbset(struct ovsrcu_perthread *);
60 static void ovsrcu_unregister__(struct ovsrcu_perthread *);
61 static bool ovsrcu_call_postponed(void);
62 static void *ovsrcu_postpone_thread(void *arg OVS_UNUSED);
63 static void ovsrcu_synchronize(void);
65 static struct ovsrcu_perthread *
66 ovsrcu_perthread_get(void)
68 struct ovsrcu_perthread *perthread;
72 perthread = pthread_getspecific(perthread_key);
74 perthread = xmalloc(sizeof *perthread);
75 ovs_mutex_init(&perthread->mutex);
76 perthread->seqno = seq_read(global_seqno);
77 perthread->cbset = NULL;
78 ovs_strlcpy(perthread->name, get_subprogram_name(),
79 sizeof perthread->name);
81 ovs_mutex_lock(&ovsrcu_threads_mutex);
82 list_push_back(&ovsrcu_threads, &perthread->list_node);
83 ovs_mutex_unlock(&ovsrcu_threads_mutex);
85 pthread_setspecific(perthread_key, perthread);
90 /* Indicates the end of a quiescent state. See "Details" near the top of
93 * Quiescent states don't stack or nest, so this always ends a quiescent state
94 * even if ovsrcu_quiesce_start() was called multiple times in a row. */
96 ovsrcu_quiesce_end(void)
98 ovsrcu_perthread_get();
102 ovsrcu_quiesced(void)
104 if (single_threaded()) {
105 ovsrcu_call_postponed();
107 static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
108 if (ovsthread_once_start(&once)) {
109 ovs_thread_create("urcu", ovsrcu_postpone_thread, NULL);
110 ovsthread_once_done(&once);
115 /* Indicates the beginning of a quiescent state. See "Details" near the top of
118 ovsrcu_quiesce_start(void)
120 struct ovsrcu_perthread *perthread;
123 perthread = pthread_getspecific(perthread_key);
125 pthread_setspecific(perthread_key, NULL);
126 ovsrcu_unregister__(perthread);
132 /* Indicates a momentary quiescent state. See "Details" near the top of
138 ovsrcu_perthread_get()->seqno = seq_read(global_seqno);
139 seq_change(global_seqno);
145 ovsrcu_is_quiescent(void)
148 return pthread_getspecific(perthread_key) == NULL;
152 ovsrcu_synchronize(void)
154 unsigned int warning_threshold = 1000;
155 uint64_t target_seqno;
158 if (single_threaded()) {
162 target_seqno = seq_read(global_seqno);
163 ovsrcu_quiesce_start();
167 uint64_t cur_seqno = seq_read(global_seqno);
168 struct ovsrcu_perthread *perthread;
169 char stalled_thread[16];
170 unsigned int elapsed;
173 ovs_mutex_lock(&ovsrcu_threads_mutex);
174 LIST_FOR_EACH (perthread, list_node, &ovsrcu_threads) {
175 if (perthread->seqno <= target_seqno) {
176 ovs_strlcpy(stalled_thread, perthread->name,
177 sizeof stalled_thread);
182 ovs_mutex_unlock(&ovsrcu_threads_mutex);
188 elapsed = time_msec() - start;
189 if (elapsed >= warning_threshold) {
190 VLOG_WARN("blocked %u ms waiting for %s to quiesce",
191 elapsed, stalled_thread);
192 warning_threshold *= 2;
194 poll_timer_wait_until(start + warning_threshold);
196 seq_wait(global_seqno, cur_seqno);
199 ovsrcu_quiesce_end();
202 /* Registers 'function' to be called, passing 'aux' as argument, after the
205 * This function is more conveniently called through the ovsrcu_postpone()
206 * macro, which provides a type-safe way to allow 'function''s parameter to be
207 * any pointer type. */
209 ovsrcu_postpone__(void (*function)(void *aux), void *aux)
211 struct ovsrcu_perthread *perthread = ovsrcu_perthread_get();
212 struct ovsrcu_cbset *cbset;
213 struct ovsrcu_cb *cb;
215 cbset = perthread->cbset;
217 cbset = perthread->cbset = xmalloc(sizeof *perthread->cbset);
221 cb = &cbset->cbs[cbset->n_cbs++];
222 cb->function = function;
225 if (cbset->n_cbs >= ARRAY_SIZE(cbset->cbs)) {
226 ovsrcu_flush_cbset(perthread);
231 ovsrcu_call_postponed(void)
233 struct ovsrcu_cbset *cbset, *next_cbset;
236 guarded_list_pop_all(&flushed_cbsets, &cbsets);
237 if (list_is_empty(&cbsets)) {
241 ovsrcu_synchronize();
243 LIST_FOR_EACH_SAFE (cbset, next_cbset, list_node, &cbsets) {
244 struct ovsrcu_cb *cb;
246 for (cb = cbset->cbs; cb < &cbset->cbs[cbset->n_cbs]; cb++) {
247 cb->function(cb->aux);
249 list_remove(&cbset->list_node);
257 ovsrcu_postpone_thread(void *arg OVS_UNUSED)
259 pthread_detach(pthread_self());
262 uint64_t seqno = seq_read(flushed_cbsets_seq);
263 if (!ovsrcu_call_postponed()) {
264 seq_wait(flushed_cbsets_seq, seqno);
273 ovsrcu_flush_cbset(struct ovsrcu_perthread *perthread)
275 struct ovsrcu_cbset *cbset = perthread->cbset;
278 guarded_list_push_back(&flushed_cbsets, &cbset->list_node, SIZE_MAX);
279 perthread->cbset = NULL;
281 seq_change(flushed_cbsets_seq);
286 ovsrcu_unregister__(struct ovsrcu_perthread *perthread)
288 if (perthread->cbset) {
289 ovsrcu_flush_cbset(perthread);
292 ovs_mutex_lock(&ovsrcu_threads_mutex);
293 list_remove(&perthread->list_node);
294 ovs_mutex_unlock(&ovsrcu_threads_mutex);
296 ovs_mutex_destroy(&perthread->mutex);
299 seq_change(global_seqno);
303 ovsrcu_thread_exit_cb(void *perthread)
305 ovsrcu_unregister__(perthread);
311 static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
312 if (ovsthread_once_start(&once)) {
313 global_seqno = seq_create();
314 xpthread_key_create(&perthread_key, ovsrcu_thread_exit_cb);
315 list_init(&ovsrcu_threads);
316 ovs_mutex_init(&ovsrcu_threads_mutex);
318 guarded_list_init(&flushed_cbsets);
319 flushed_cbsets_seq = seq_create();
321 ovsthread_once_done(&once);