Commit | Line | Data |
---|---|---|
4477a870 MD |
1 | #ifndef _URCU_SIGNAL_STATIC_H |
2 | #define _URCU_SIGNAL_STATIC_H | |
3 | ||
4 | /* | |
5 | * urcu-signal-static.h | |
6 | * | |
7 | * Userspace RCU 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 <unistd.h> | |
35 | #include <stdint.h> | |
36 | ||
37 | #include <urcu/config.h> | |
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 | /* | |
61 | * The signal number used by the RCU library can be overridden with | |
62 | * -DSIGRCU= when compiling the library. | |
63 | * Provide backward compatibility for liburcu 0.3.x SIGURCU. | |
64 | */ | |
65 | #ifdef SIGURCU | |
66 | #define SIGRCU SIGURCU | |
67 | #endif | |
68 | ||
69 | #ifndef SIGRCU | |
70 | #define SIGRCU SIGUSR1 | |
71 | #endif | |
72 | ||
73 | extern struct urcu_gp urcu_signal_gp; | |
74 | ||
75 | extern DECLARE_URCU_TLS(struct urcu_reader, urcu_signal_reader); | |
76 | ||
77 | /* | |
78 | * Helper for _rcu_read_lock(). The format of urcu_signal_gp.ctr (as well as | |
79 | * the per-thread rcu_reader.ctr) has the upper bits containing a count of | |
80 | * _rcu_read_lock() nesting, and a lower-order bit that contains either zero | |
81 | * or URCU_GP_CTR_PHASE. The cmm_barrier() ensures that the accesses in | |
82 | * _rcu_read_lock() happen before the subsequent read-side critical section. | |
83 | */ | |
84 | static inline void _urcu_signal_read_lock_update(unsigned long tmp) | |
85 | { | |
86 | if (caa_likely(!(tmp & URCU_GP_CTR_NEST_MASK))) { | |
87 | _CMM_STORE_SHARED(URCU_TLS(urcu_signal_reader).ctr, _CMM_LOAD_SHARED(urcu_signal_gp.ctr)); | |
88 | cmm_barrier(); | |
89 | } else | |
90 | _CMM_STORE_SHARED(URCU_TLS(urcu_signal_reader).ctr, tmp + URCU_GP_COUNT); | |
91 | } | |
92 | ||
93 | /* | |
94 | * Enter an RCU read-side critical section. | |
95 | * | |
96 | * The first cmm_barrier() call ensures that the compiler does not reorder | |
97 | * the body of _rcu_read_lock() with a mutex. | |
98 | * | |
99 | * This function and its helper are both less than 10 lines long. The | |
100 | * intent is that this function meets the 10-line criterion in LGPL, | |
101 | * allowing this function to be invoked directly from non-LGPL code. | |
102 | */ | |
103 | static inline void _urcu_signal_read_lock(void) | |
104 | { | |
105 | unsigned long tmp; | |
106 | ||
107 | urcu_assert(URCU_TLS(urcu_signal_reader).registered); | |
108 | cmm_barrier(); | |
109 | tmp = URCU_TLS(urcu_signal_reader).ctr; | |
110 | urcu_assert((tmp & URCU_GP_CTR_NEST_MASK) != URCU_GP_CTR_NEST_MASK); | |
111 | _urcu_signal_read_lock_update(tmp); | |
112 | } | |
113 | ||
114 | /* | |
115 | * This is a helper function for _rcu_read_unlock(). | |
116 | * | |
117 | * The first cmm_barrier() call ensures that the critical section is | |
118 | * seen to precede the store to rcu_reader.ctr. | |
119 | * The second cmm_barrier() call ensures that we write to rcu_reader.ctr | |
120 | * before reading the update-side futex. | |
121 | */ | |
122 | static inline void _urcu_signal_read_unlock_update_and_wakeup(unsigned long tmp) | |
123 | { | |
124 | if (caa_likely((tmp & URCU_GP_CTR_NEST_MASK) == URCU_GP_COUNT)) { | |
125 | cmm_barrier(); | |
126 | _CMM_STORE_SHARED(URCU_TLS(urcu_signal_reader).ctr, tmp - URCU_GP_COUNT); | |
127 | cmm_barrier(); | |
128 | urcu_common_wake_up_gp(&urcu_signal_gp); | |
129 | } else | |
130 | _CMM_STORE_SHARED(URCU_TLS(urcu_signal_reader).ctr, tmp - URCU_GP_COUNT); | |
131 | } | |
132 | ||
133 | /* | |
134 | * Exit an RCU read-side crtical section. Both this function and its | |
135 | * helper are smaller than 10 lines of code, and are intended to be | |
136 | * usable by non-LGPL code, as called out in LGPL. | |
137 | */ | |
138 | static inline void _urcu_signal_read_unlock(void) | |
139 | { | |
140 | unsigned long tmp; | |
141 | ||
142 | urcu_assert(URCU_TLS(urcu_signal_reader).registered); | |
143 | tmp = URCU_TLS(urcu_signal_reader).ctr; | |
144 | urcu_assert(tmp & URCU_GP_CTR_NEST_MASK); | |
145 | _urcu_signal_read_unlock_update_and_wakeup(tmp); | |
146 | cmm_barrier(); /* Ensure the compiler does not reorder us with mutex */ | |
147 | } | |
148 | ||
149 | /* | |
150 | * Returns whether within a RCU read-side critical section. | |
151 | * | |
152 | * This function is less than 10 lines long. The intent is that this | |
153 | * function meets the 10-line criterion for LGPL, allowing this function | |
154 | * to be invoked directly from non-LGPL code. | |
155 | */ | |
156 | static inline int _urcu_signal_read_ongoing(void) | |
157 | { | |
158 | return URCU_TLS(urcu_signal_reader).ctr & URCU_GP_CTR_NEST_MASK; | |
159 | } | |
160 | ||
161 | #ifdef __cplusplus | |
162 | } | |
163 | #endif | |
164 | ||
165 | #endif /* _URCU_SIGNAL_STATIC_H */ |