Return -EEXIST when the old cpu call_rcu_data has not been removed

[urcu.git] / urcu-call-rcu-impl.h

diff --git a/urcu-call-rcu-impl.h b/urcu-call-rcu-impl.h
index d5baa69685387808044529f634a69157ca9126c0..ae93468d8beb4e9fb9167a4dcc5b462892f3d9a2 100644 (file)
--- a/urcu-call-rcu-impl.h
+++ b/urcu-call-rcu-impl.h
@@ -115,7 +115,12 @@ static void alloc_cpu_call_rcu_data(void)
 
 #else /* #if defined(HAVE_SCHED_GETCPU) && defined(HAVE_SYSCONF) */
 
-static const struct call_rcu_data **per_cpu_call_rcu_data = NULL;
+/*
+ * per_cpu_call_rcu_data should be constant, but some functions below, used both
+ * for cases where cpu number is available and not available, assume it it not
+ * constant.
+ */
+static struct call_rcu_data **per_cpu_call_rcu_data = NULL;
 static const long maxcpus = -1;
 
 static void alloc_cpu_call_rcu_data(void)
@@ -210,6 +215,11 @@ static void *call_rcu_thread(void *arg)
                exit(-1);
        }
 
+       /*
+        * If callbacks take a read-side lock, we need to be registered.
+        */
+       rcu_register_thread();
+
        thread_call_rcu_data = crdp;
        if (!rt) {
                uatomic_dec(&crdp->futex);
@@ -242,6 +252,7 @@ static void *call_rcu_thread(void *arg)
                }
                if (uatomic_read(&crdp->flags) & URCU_CALL_RCU_STOP)
                        break;
+               rcu_thread_offline();
                if (!rt) {
                        if (&crdp->cbs.head
                            == _CMM_LOAD_SHARED(crdp->cbs.tail)) {
@@ -259,6 +270,7 @@ static void *call_rcu_thread(void *arg)
                } else {
                        poll(NULL, 0, 10);
                }
+               rcu_thread_online();
        }
        if (!rt) {
                /*
@@ -268,6 +280,7 @@ static void *call_rcu_thread(void *arg)
                uatomic_set(&crdp->futex, 0);
        }
        uatomic_or(&crdp->flags, URCU_CALL_RCU_STOPPED);
+       rcu_unregister_thread();
        return NULL;
 }
 
@@ -370,9 +383,10 @@ struct call_rcu_data *create_call_rcu_data(unsigned long flags,
 
 int set_cpu_call_rcu_data(int cpu, struct call_rcu_data *crdp)
 {
-       int warned = 0;
+       static int warned = 0;
 
        call_rcu_lock(&call_rcu_mutex);
+       alloc_cpu_call_rcu_data();
        if (cpu < 0 || maxcpus <= cpu) {
                if (!warned) {
                        fprintf(stderr, "[error] liburcu: set CPU # out of range\n");
@@ -382,13 +396,21 @@ int set_cpu_call_rcu_data(int cpu, struct call_rcu_data *crdp)
                errno = EINVAL;
                return -EINVAL;
        }
-       alloc_cpu_call_rcu_data();
-       call_rcu_unlock(&call_rcu_mutex);
+
        if (per_cpu_call_rcu_data == NULL) {
+               call_rcu_unlock(&call_rcu_mutex);
                errno = ENOMEM;
                return -ENOMEM;
        }
+
+       if (per_cpu_call_rcu_data[cpu] != NULL && crdp != NULL) {
+               call_rcu_unlock(&call_rcu_mutex);
+               errno = EEXIST;
+               return -EEXIST;
+       }
+
        per_cpu_call_rcu_data[cpu] = crdp;
+       call_rcu_unlock(&call_rcu_mutex);
        return 0;
 }
 
@@ -422,22 +444,17 @@ struct call_rcu_data *get_default_call_rcu_data(void)
  */
 struct call_rcu_data *get_call_rcu_data(void)
 {
-       int curcpu;
-       static int warned = 0;
+       struct call_rcu_data *crd;
 
        if (thread_call_rcu_data != NULL)
                return thread_call_rcu_data;
-       if (maxcpus <= 0)
-               return get_default_call_rcu_data();
-       curcpu = sched_getcpu();
-       if (!warned && (curcpu < 0 || maxcpus <= curcpu)) {
-               fprintf(stderr, "[error] liburcu: gcrd CPU # out of range\n");
-               warned = 1;
+
+       if (maxcpus > 0) {
+               crd = get_cpu_call_rcu_data(sched_getcpu());
+               if (crd)
+                       return crd;
        }
-       if (curcpu >= 0 && maxcpus > curcpu &&
-           per_cpu_call_rcu_data != NULL &&
-           per_cpu_call_rcu_data[curcpu] != NULL)
-               return per_cpu_call_rcu_data[curcpu];
+
        return get_default_call_rcu_data();
 }
 
@@ -469,7 +486,9 @@ void set_thread_call_rcu_data(struct call_rcu_data *crdp)
 /*
  * Create a separate call_rcu thread for each CPU.  This does not
  * replace a pre-existing call_rcu thread -- use the set_cpu_call_rcu_data()
- * function if you want that behavior.
+ * function if you want that behavior. Should be paired with
+ * free_all_cpu_call_rcu_data() to teardown these call_rcu worker
+ * threads.
  */
 
 int create_all_cpu_call_rcu_data(unsigned long flags)
@@ -590,9 +609,11 @@ void call_rcu_data_free(struct call_rcu_data *crdp)
                *cbs_endprev = cbs;
                uatomic_add(&default_call_rcu_data->qlen,
                            uatomic_read(&crdp->qlen));
-               cds_list_del(&crdp->list);
-               free(crdp);
+               wake_call_rcu_thread(default_call_rcu_data);
        }
+
+       cds_list_del(&crdp->list);
+       free(crdp);
 }
 
 /*
@@ -641,7 +662,7 @@ void call_rcu_after_fork_parent(void)
  */
 void call_rcu_after_fork_child(void)
 {
-       struct call_rcu_data *crdp;
+       struct call_rcu_data *crdp, *next;
 
        /* Release the mutex. */
        call_rcu_unlock(&call_rcu_mutex);
@@ -654,12 +675,9 @@ void call_rcu_after_fork_child(void)
        (void)get_default_call_rcu_data();
 
        /* Dispose of all of the rest of the call_rcu_data structures. */
-       while (call_rcu_data_list.next != call_rcu_data_list.prev) {
-               crdp = cds_list_entry(call_rcu_data_list.prev,
-                                     struct call_rcu_data, list);
+       cds_list_for_each_entry_safe(crdp, next, &call_rcu_data_list, list) {
                if (crdp == default_call_rcu_data)
-                       crdp = cds_list_entry(crdp->list.prev,
-                                             struct call_rcu_data, list);
+                       continue;
                uatomic_set(&crdp->flags, URCU_CALL_RCU_STOPPED);
                call_rcu_data_free(crdp);
        }