lib/ovs-rcu.c

   1 /*
   2  * Copyright (c) 2014 Nicira, Inc.
   3  *
   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:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <config.h>
  18 #include "ovs-rcu.h"
  19 #include "guarded-list.h"
  20 #include "list.h"
  21 #include "ovs-thread.h"
  22 #include "poll-loop.h"
  23 #include "seq.h"
  24 #include "timeval.h"
  25 #include "openvswitch/vlog.h"
  26
  27 VLOG_DEFINE_THIS_MODULE(ovs_rcu);
  28
  29 struct ovsrcu_cb {
  30     void (*function)(void *aux);
  31     void *aux;
  32 };
  33
  34 struct ovsrcu_cbset {
  35     struct ovs_list list_node;
  36     struct ovsrcu_cb cbs[16];
  37     int n_cbs;
  38 };
  39
  40 struct ovsrcu_perthread {
  41     struct ovs_list list_node;  /* In global list. */
  42
  43     struct ovs_mutex mutex;
  44     uint64_t seqno;
  45     struct ovsrcu_cbset *cbset;
  46     char name[16];              /* This thread's name. */
  47 };
  48
  49 static struct seq *global_seqno;
  50
  51 static pthread_key_t perthread_key;
  52 static struct ovs_list ovsrcu_threads;
  53 static struct ovs_mutex ovsrcu_threads_mutex;
  54
  55 static struct guarded_list flushed_cbsets;
  56 static struct seq *flushed_cbsets_seq;
  57
  58 static void ovsrcu_init_module(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
  64 static struct ovsrcu_perthread *
  65 ovsrcu_perthread_get(void)
  66 {
  67     struct ovsrcu_perthread *perthread;
  68
  69     ovsrcu_init_module();
  70
  71     perthread = pthread_getspecific(perthread_key);
  72     if (!perthread) {
  73         const char *name = get_subprogram_name();
  74
  75         perthread = xmalloc(sizeof *perthread);
  76         ovs_mutex_init(&perthread->mutex);
  77         perthread->seqno = seq_read(global_seqno);
  78         perthread->cbset = NULL;
  79         ovs_strlcpy(perthread->name, name[0] ? name : "main",
  80                     sizeof perthread->name);
  81
  82         ovs_mutex_lock(&ovsrcu_threads_mutex);
  83         list_push_back(&ovsrcu_threads, &perthread->list_node);
  84         ovs_mutex_unlock(&ovsrcu_threads_mutex);
  85
  86         pthread_setspecific(perthread_key, perthread);
  87     }
  88     return perthread;
  89 }
  90
  91 /* Indicates the end of a quiescent state.  See "Details" near the top of
  92  * ovs-rcu.h.
  93  *
  94  * Quiescent states don't stack or nest, so this always ends a quiescent state
  95  * even if ovsrcu_quiesce_start() was called multiple times in a row. */
  96 void
  97 ovsrcu_quiesce_end(void)
  98 {
  99     ovsrcu_perthread_get();
 100 }
 101
 102 static void
 103 ovsrcu_quiesced(void)
 104 {
 105     if (single_threaded()) {
 106         ovsrcu_call_postponed();
 107     } else {
 108         static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
 109         if (ovsthread_once_start(&once)) {
 110             ovs_thread_create("urcu", ovsrcu_postpone_thread, NULL);
 111             ovsthread_once_done(&once);
 112         }
 113     }
 114 }
 115
 116 /* Indicates the beginning of a quiescent state.  See "Details" near the top of
 117  * ovs-rcu.h. */
 118 void
 119 ovsrcu_quiesce_start(void)
 120 {
 121     struct ovsrcu_perthread *perthread;
 122
 123     ovsrcu_init_module();
 124     perthread = pthread_getspecific(perthread_key);
 125     if (perthread) {
 126         pthread_setspecific(perthread_key, NULL);
 127         ovsrcu_unregister__(perthread);
 128     }
 129
 130     ovsrcu_quiesced();
 131 }
 132
 133 /* Indicates a momentary quiescent state.  See "Details" near the top of
 134  * ovs-rcu.h.
 135  *
 136  * Provides a full memory barrier via seq_change().
 137  */
 138 void
 139 ovsrcu_quiesce(void)
 140 {
 141     struct ovsrcu_perthread *perthread;
 142
 143     perthread = ovsrcu_perthread_get();
 144     perthread->seqno = seq_read(global_seqno);
 145     if (perthread->cbset) {
 146         ovsrcu_flush_cbset(perthread);
 147     }
 148     seq_change(global_seqno);
 149
 150     ovsrcu_quiesced();
 151 }
 152
 153 bool
 154 ovsrcu_is_quiescent(void)
 155 {
 156     ovsrcu_init_module();
 157     return pthread_getspecific(perthread_key) == NULL;
 158 }
 159
 160 void
 161 ovsrcu_synchronize(void)
 162 {
 163     unsigned int warning_threshold = 1000;
 164     uint64_t target_seqno;
 165     long long int start;
 166
 167     if (single_threaded()) {
 168         return;
 169     }
 170
 171     target_seqno = seq_read(global_seqno);
 172     ovsrcu_quiesce_start();
 173     start = time_msec();
 174
 175     for (;;) {
 176         uint64_t cur_seqno = seq_read(global_seqno);
 177         struct ovsrcu_perthread *perthread;
 178         char stalled_thread[16];
 179         unsigned int elapsed;
 180         bool done = true;
 181
 182         ovs_mutex_lock(&ovsrcu_threads_mutex);
 183         LIST_FOR_EACH (perthread, list_node, &ovsrcu_threads) {
 184             if (perthread->seqno <= target_seqno) {
 185                 ovs_strlcpy(stalled_thread, perthread->name,
 186                             sizeof stalled_thread);
 187                 done = false;
 188                 break;
 189             }
 190         }
 191         ovs_mutex_unlock(&ovsrcu_threads_mutex);
 192
 193         if (done) {
 194             break;
 195         }
 196
 197         elapsed = time_msec() - start;
 198         if (elapsed >= warning_threshold) {
 199             VLOG_WARN("blocked %u ms waiting for %s to quiesce",
 200                       elapsed, stalled_thread);
 201             warning_threshold *= 2;
 202         }
 203         poll_timer_wait_until(start + warning_threshold);
 204
 205         seq_wait(global_seqno, cur_seqno);
 206         poll_block();
 207     }
 208     ovsrcu_quiesce_end();
 209 }
 210
 211 /* Registers 'function' to be called, passing 'aux' as argument, after the
 212  * next grace period.
 213  *
 214  * This function is more conveniently called through the ovsrcu_postpone()
 215  * macro, which provides a type-safe way to allow 'function''s parameter to be
 216  * any pointer type. */
 217 void
 218 ovsrcu_postpone__(void (*function)(void *aux), void *aux)
 219 {
 220     struct ovsrcu_perthread *perthread = ovsrcu_perthread_get();
 221     struct ovsrcu_cbset *cbset;
 222     struct ovsrcu_cb *cb;
 223
 224     cbset = perthread->cbset;
 225     if (!cbset) {
 226         cbset = perthread->cbset = xmalloc(sizeof *perthread->cbset);
 227         cbset->n_cbs = 0;
 228     }
 229
 230     cb = &cbset->cbs[cbset->n_cbs++];
 231     cb->function = function;
 232     cb->aux = aux;
 233
 234     if (cbset->n_cbs >= ARRAY_SIZE(cbset->cbs)) {
 235         ovsrcu_flush_cbset(perthread);
 236     }
 237 }
 238
 239 static bool
 240 ovsrcu_call_postponed(void)
 241 {
 242     struct ovsrcu_cbset *cbset;
 243     struct ovs_list cbsets;
 244
 245     guarded_list_pop_all(&flushed_cbsets, &cbsets);
 246     if (list_is_empty(&cbsets)) {
 247         return false;
 248     }
 249
 250     ovsrcu_synchronize();
 251
 252     LIST_FOR_EACH_POP (cbset, list_node, &cbsets) {
 253         struct ovsrcu_cb *cb;
 254
 255         for (cb = cbset->cbs; cb < &cbset->cbs[cbset->n_cbs]; cb++) {
 256             cb->function(cb->aux);
 257         }
 258         free(cbset);
 259     }
 260
 261     return true;
 262 }
 263
 264 static void *
 265 ovsrcu_postpone_thread(void *arg OVS_UNUSED)
 266 {
 267     pthread_detach(pthread_self());
 268
 269     for (;;) {
 270         uint64_t seqno = seq_read(flushed_cbsets_seq);
 271         if (!ovsrcu_call_postponed()) {
 272             seq_wait(flushed_cbsets_seq, seqno);
 273             poll_block();
 274         }
 275     }
 276
 277     OVS_NOT_REACHED();
 278 }
 279
 280 static void
 281 ovsrcu_flush_cbset(struct ovsrcu_perthread *perthread)
 282 {
 283     struct ovsrcu_cbset *cbset = perthread->cbset;
 284
 285     if (cbset) {
 286         guarded_list_push_back(&flushed_cbsets, &cbset->list_node, SIZE_MAX);
 287         perthread->cbset = NULL;
 288
 289         seq_change(flushed_cbsets_seq);
 290     }
 291 }
 292
 293 static void
 294 ovsrcu_unregister__(struct ovsrcu_perthread *perthread)
 295 {
 296     if (perthread->cbset) {
 297         ovsrcu_flush_cbset(perthread);
 298     }
 299
 300     ovs_mutex_lock(&ovsrcu_threads_mutex);
 301     list_remove(&perthread->list_node);
 302     ovs_mutex_unlock(&ovsrcu_threads_mutex);
 303
 304     ovs_mutex_destroy(&perthread->mutex);
 305     free(perthread);
 306
 307     seq_change(global_seqno);
 308 }
 309
 310 static void
 311 ovsrcu_thread_exit_cb(void *perthread)
 312 {
 313     ovsrcu_unregister__(perthread);
 314 }
 315
 316 static void
 317 ovsrcu_init_module(void)
 318 {
 319     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
 320     if (ovsthread_once_start(&once)) {
 321         global_seqno = seq_create();
 322         xpthread_key_create(&perthread_key, ovsrcu_thread_exit_cb);
 323         list_init(&ovsrcu_threads);
 324         ovs_mutex_init(&ovsrcu_threads_mutex);
 325
 326         guarded_list_init(&flushed_cbsets);
 327         flushed_cbsets_seq = seq_create();
 328
 329         ovsthread_once_done(&once);
 330     }
 331 }