include/urcu/static/urcu-qsbr.h

   1 #ifndef _URCU_QSBR_STATIC_H
   2 #define _URCU_QSBR_STATIC_H
   3
   4 /*
   5  * urcu-qsbr-static.h
   6  *
   7  * Userspace RCU QSBR header.
   8  *
   9  * TO BE INCLUDED ONLY IN CODE THAT IS TO BE RECOMPILED ON EACH LIBURCU
  10  * RELEASE. See urcu.h for linking dynamically with the userspace rcu library.
  11  *
  12  * Copyright (c) 2009 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  13  * Copyright (c) 2009 Paul E. McKenney, IBM Corporation.
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Lesser General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2.1 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Lesser General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Lesser General Public
  26  * License along with this library; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  28  *
  29  * IBM's contributions to this file may be relicensed under LGPLv2 or later.
  30  */
  31
  32 #include <stdlib.h>
  33 #include <pthread.h>
  34 #include <limits.h>
  35 #include <unistd.h>
  36 #include <stdint.h>
  37
  38 #include <urcu/compiler.h>
  39 #include <urcu/arch.h>
  40 #include <urcu/system.h>
  41 #include <urcu/uatomic.h>
  42 #include <urcu/list.h>
  43 #include <urcu/futex.h>
  44 #include <urcu/tls-compat.h>
  45 #include <urcu/debug.h>
  46 #include <urcu/static/urcu-common.h>
  47
  48 #ifdef __cplusplus
  49 extern "C" {
  50 #endif
  51
  52 /*
  53  * This code section can only be included in LGPL 2.1 compatible source code.
  54  * See below for the function call wrappers which can be used in code meant to
  55  * be only linked with the Userspace RCU library. This comes with a small
  56  * performance degradation on the read-side due to the added function calls.
  57  * This is required to permit relinking with newer versions of the library.
  58  */
  59
  60 #define URCU_QSBR_GP_ONLINE             (1UL << 0)
  61 #define URCU_QSBR_GP_CTR                (1UL << 1)
  62
  63 extern struct urcu_gp urcu_qsbr_gp;
  64
  65 struct urcu_qsbr_reader {
  66         /* Data used by both reader and synchronize_rcu() */
  67         unsigned long ctr;
  68         /* Data used for registry */
  69         struct cds_list_head node __attribute__((aligned(CAA_CACHE_LINE_SIZE)));
  70         int waiting;
  71         pthread_t tid;
  72         /* Reader registered flag, for internal checks. */
  73         unsigned int registered:1;
  74 };
  75
  76 extern DECLARE_URCU_TLS(struct urcu_qsbr_reader, urcu_qsbr_reader);
  77
  78 /*
  79  * Wake-up waiting synchronize_rcu(). Called from many concurrent threads.
  80  */
  81 static inline void urcu_qsbr_wake_up_gp(void)
  82 {
  83         if (caa_unlikely(_CMM_LOAD_SHARED(URCU_TLS(urcu_qsbr_reader).waiting))) {
  84                 _CMM_STORE_SHARED(URCU_TLS(urcu_qsbr_reader).waiting, 0);
  85                 cmm_smp_mb();
  86                 if (uatomic_read(&urcu_qsbr_gp.futex) != -1)
  87                         return;
  88                 uatomic_set(&urcu_qsbr_gp.futex, 0);
  89                 /*
  90                  * Ignoring return value until we can make this function
  91                  * return something (because urcu_die() is not publicly
  92                  * exposed).
  93                  */
  94                 (void) futex_noasync(&urcu_qsbr_gp.futex, FUTEX_WAKE, 1,
  95                                 NULL, NULL, 0);
  96         }
  97 }
  98
  99 static inline enum urcu_state urcu_qsbr_reader_state(unsigned long *ctr)
 100 {
 101         unsigned long v;
 102
 103         v = CMM_LOAD_SHARED(*ctr);
 104         if (!v)
 105                 return URCU_READER_INACTIVE;
 106         if (v == urcu_qsbr_gp.ctr)
 107                 return URCU_READER_ACTIVE_CURRENT;
 108         return URCU_READER_ACTIVE_OLD;
 109 }
 110
 111 /*
 112  * Enter an RCU read-side critical section.
 113  *
 114  * This function is less than 10 lines long.  The intent is that this
 115  * function meets the 10-line criterion for LGPL, allowing this function
 116  * to be invoked directly from non-LGPL code.
 117  */
 118 static inline void _urcu_qsbr_read_lock(void)
 119 {
 120         urcu_assert(URCU_TLS(urcu_qsbr_reader).ctr);
 121 }
 122
 123 /*
 124  * Exit an RCU read-side critical section.
 125  *
 126  * This function is less than 10 lines long.  The intent is that this
 127  * function meets the 10-line criterion for LGPL, allowing this function
 128  * to be invoked directly from non-LGPL code.
 129  */
 130 static inline void _urcu_qsbr_read_unlock(void)
 131 {
 132         urcu_assert(URCU_TLS(urcu_qsbr_reader).ctr);
 133 }
 134
 135 /*
 136  * Returns whether within a RCU read-side critical section.
 137  *
 138  * This function is less than 10 lines long.  The intent is that this
 139  * function meets the 10-line criterion for LGPL, allowing this function
 140  * to be invoked directly from non-LGPL code.
 141  */
 142 static inline int _urcu_qsbr_read_ongoing(void)
 143 {
 144         return URCU_TLS(urcu_qsbr_reader).ctr;
 145 }
 146
 147 /*
 148  * This is a helper function for _rcu_quiescent_state().
 149  * The first cmm_smp_mb() ensures memory accesses in the prior read-side
 150  * critical sections are not reordered with store to
 151  * URCU_TLS(urcu_qsbr_reader).ctr, and ensures that mutexes held within an
 152  * offline section that would happen to end with this
 153  * urcu_qsbr_quiescent_state() call are not reordered with
 154  * store to URCU_TLS(urcu_qsbr_reader).ctr.
 155  */
 156 static inline void _urcu_qsbr_quiescent_state_update_and_wakeup(unsigned long gp_ctr)
 157 {
 158         cmm_smp_mb();
 159         _CMM_STORE_SHARED(URCU_TLS(urcu_qsbr_reader).ctr, gp_ctr);
 160         cmm_smp_mb();   /* write URCU_TLS(urcu_qsbr_reader).ctr before read futex */
 161         urcu_qsbr_wake_up_gp();
 162         cmm_smp_mb();
 163 }
 164
 165 /*
 166  * Inform RCU of a quiescent state.
 167  *
 168  * This function is less than 10 lines long.  The intent is that this
 169  * function meets the 10-line criterion for LGPL, allowing this function
 170  * to be invoked directly from non-LGPL code.
 171  *
 172  * We skip the memory barriers and gp store if our local ctr already
 173  * matches the global urcu_qsbr_gp.ctr value: this is OK because a prior
 174  * _rcu_quiescent_state() or _rcu_thread_online() already updated it
 175  * within our thread, so we have no quiescent state to report.
 176  */
 177 static inline void _urcu_qsbr_quiescent_state(void)
 178 {
 179         unsigned long gp_ctr;
 180
 181         urcu_assert(URCU_TLS(urcu_qsbr_reader).registered);
 182         if ((gp_ctr = CMM_LOAD_SHARED(urcu_qsbr_gp.ctr)) == URCU_TLS(urcu_qsbr_reader).ctr)
 183                 return;
 184         _urcu_qsbr_quiescent_state_update_and_wakeup(gp_ctr);
 185 }
 186
 187 /*
 188  * Take a thread offline, prohibiting it from entering further RCU
 189  * read-side critical sections.
 190  *
 191  * This function is less than 10 lines long.  The intent is that this
 192  * function meets the 10-line criterion for LGPL, allowing this function
 193  * to be invoked directly from non-LGPL code.
 194  */
 195 static inline void _urcu_qsbr_thread_offline(void)
 196 {
 197         urcu_assert(URCU_TLS(urcu_qsbr_reader).registered);
 198         cmm_smp_mb();
 199         CMM_STORE_SHARED(URCU_TLS(urcu_qsbr_reader).ctr, 0);
 200         cmm_smp_mb();   /* write URCU_TLS(urcu_qsbr_reader).ctr before read futex */
 201         urcu_qsbr_wake_up_gp();
 202         cmm_barrier();  /* Ensure the compiler does not reorder us with mutex */
 203 }
 204
 205 /*
 206  * Bring a thread online, allowing it to once again enter RCU
 207  * read-side critical sections.
 208  *
 209  * This function is less than 10 lines long.  The intent is that this
 210  * function meets the 10-line criterion for LGPL, allowing this function
 211  * to be invoked directly from non-LGPL code.
 212  */
 213 static inline void _urcu_qsbr_thread_online(void)
 214 {
 215         urcu_assert(URCU_TLS(urcu_qsbr_reader).registered);
 216         cmm_barrier();  /* Ensure the compiler does not reorder us with mutex */
 217         _CMM_STORE_SHARED(URCU_TLS(urcu_qsbr_reader).ctr, CMM_LOAD_SHARED(urcu_qsbr_gp.ctr));
 218         cmm_smp_mb();
 219 }
 220
 221 #ifdef __cplusplus
 222 }
 223 #endif
 224
 225 #endif /* _URCU_QSBR_STATIC_H */