1 /* 2 * Read-Copy Update mechanism for mutual exclusion, the Bloatwatch edition. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, you can access it online at 16 * http://www.gnu.org/licenses/gpl-2.0.html. 17 * 18 * Copyright IBM Corporation, 2008 19 * 20 * Author: Paul E. McKenney <[email protected]> 21 * 22 * For detailed explanation of Read-Copy Update mechanism see - 23 * Documentation/RCU 24 */ 25 #ifndef __LINUX_TINY_H 26 #define __LINUX_TINY_H 27 28 #include <linux/cache.h> 29 30 struct rcu_dynticks; 31 static inline int rcu_dynticks_snap(struct rcu_dynticks *rdtp) 32 { 33 return 0; 34 } 35 36 static inline bool rcu_eqs_special_set(int cpu) 37 { 38 return false; /* Never flag non-existent other CPUs! */ 39 } 40 41 static inline unsigned long get_state_synchronize_rcu(void) 42 { 43 return 0; 44 } 45 46 static inline void cond_synchronize_rcu(unsigned long oldstate) 47 { 48 might_sleep(); 49 } 50 51 static inline unsigned long get_state_synchronize_sched(void) 52 { 53 return 0; 54 } 55 56 static inline void cond_synchronize_sched(unsigned long oldstate) 57 { 58 might_sleep(); 59 } 60 61 extern void rcu_barrier_bh(void); 62 extern void rcu_barrier_sched(void); 63 64 static inline void synchronize_rcu_expedited(void) 65 { 66 synchronize_sched(); /* Only one CPU, so pretty fast anyway!!! */ 67 } 68 69 static inline void rcu_barrier(void) 70 { 71 rcu_barrier_sched(); /* Only one CPU, so only one list of callbacks! */ 72 } 73 74 static inline void synchronize_rcu_bh(void) 75 { 76 synchronize_sched(); 77 } 78 79 static inline void synchronize_rcu_bh_expedited(void) 80 { 81 synchronize_sched(); 82 } 83 84 static inline void synchronize_sched_expedited(void) 85 { 86 synchronize_sched(); 87 } 88 89 static inline void kfree_call_rcu(struct rcu_head *head, 90 rcu_callback_t func) 91 { 92 call_rcu(head, func); 93 } 94 95 static inline void rcu_note_context_switch(void) 96 { 97 rcu_sched_qs(); 98 } 99 100 /* 101 * Take advantage of the fact that there is only one CPU, which 102 * allows us to ignore virtualization-based context switches. 103 */ 104 static inline void rcu_virt_note_context_switch(int cpu) 105 { 106 } 107 108 /* 109 * Return the number of grace periods started. 110 */ 111 static inline unsigned long rcu_batches_started(void) 112 { 113 return 0; 114 } 115 116 /* 117 * Return the number of bottom-half grace periods started. 118 */ 119 static inline unsigned long rcu_batches_started_bh(void) 120 { 121 return 0; 122 } 123 124 /* 125 * Return the number of sched grace periods started. 126 */ 127 static inline unsigned long rcu_batches_started_sched(void) 128 { 129 return 0; 130 } 131 132 /* 133 * Return the number of grace periods completed. 134 */ 135 static inline unsigned long rcu_batches_completed(void) 136 { 137 return 0; 138 } 139 140 /* 141 * Return the number of bottom-half grace periods completed. 142 */ 143 static inline unsigned long rcu_batches_completed_bh(void) 144 { 145 return 0; 146 } 147 148 /* 149 * Return the number of sched grace periods completed. 150 */ 151 static inline unsigned long rcu_batches_completed_sched(void) 152 { 153 return 0; 154 } 155 156 /* 157 * Return the number of expedited grace periods completed. 158 */ 159 static inline unsigned long rcu_exp_batches_completed(void) 160 { 161 return 0; 162 } 163 164 /* 165 * Return the number of expedited sched grace periods completed. 166 */ 167 static inline unsigned long rcu_exp_batches_completed_sched(void) 168 { 169 return 0; 170 } 171 172 static inline void rcu_force_quiescent_state(void) 173 { 174 } 175 176 static inline void rcu_bh_force_quiescent_state(void) 177 { 178 } 179 180 static inline void rcu_sched_force_quiescent_state(void) 181 { 182 } 183 184 static inline void show_rcu_gp_kthreads(void) 185 { 186 } 187 188 static inline void rcu_cpu_stall_reset(void) 189 { 190 } 191 192 static inline void rcu_idle_enter(void) 193 { 194 } 195 196 static inline void rcu_idle_exit(void) 197 { 198 } 199 200 static inline void rcu_irq_enter(void) 201 { 202 } 203 204 static inline void rcu_irq_exit_irqson(void) 205 { 206 } 207 208 static inline void rcu_irq_enter_irqson(void) 209 { 210 } 211 212 static inline void rcu_irq_exit(void) 213 { 214 } 215 216 static inline void exit_rcu(void) 217 { 218 } 219 220 #ifdef CONFIG_DEBUG_LOCK_ALLOC 221 extern int rcu_scheduler_active __read_mostly; 222 void rcu_scheduler_starting(void); 223 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */ 224 static inline void rcu_scheduler_starting(void) 225 { 226 } 227 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */ 228 229 #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) 230 231 static inline bool rcu_is_watching(void) 232 { 233 return __rcu_is_watching(); 234 } 235 236 #else /* defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) */ 237 238 static inline bool rcu_is_watching(void) 239 { 240 return true; 241 } 242 243 #endif /* #else defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) */ 244 245 static inline void rcu_all_qs(void) 246 { 247 barrier(); /* Avoid RCU read-side critical sections leaking across. */ 248 } 249 250 /* RCUtree hotplug events */ 251 #define rcutree_prepare_cpu NULL 252 #define rcutree_online_cpu NULL 253 #define rcutree_offline_cpu NULL 254 #define rcutree_dead_cpu NULL 255 #define rcutree_dying_cpu NULL 256 257 #endif /* __LINUX_RCUTINY_H */ 258