1 /* SPDX-License-Identifier: GPL-2.0+ */ <<
2 /* 1 /*
3 * Read-Copy Update mechanism for mutual exclu 2 * Read-Copy Update mechanism for mutual exclusion, the Bloatwatch edition.
4 * 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 *
5 * Copyright IBM Corporation, 2008 18 * Copyright IBM Corporation, 2008
6 * 19 *
7 * Author: Paul E. McKenney <paulmck@linux.ibm !! 20 * Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
8 * 21 *
9 * For detailed explanation of Read-Copy Updat 22 * For detailed explanation of Read-Copy Update mechanism see -
10 * Documentation/RCU 23 * Documentation/RCU
11 */ 24 */
12 #ifndef __LINUX_TINY_H 25 #ifndef __LINUX_TINY_H
13 #define __LINUX_TINY_H 26 #define __LINUX_TINY_H
14 27
15 #include <asm/param.h> /* for HZ */ !! 28 #include <linux/cache.h>
16 29
17 struct rcu_gp_oldstate { !! 30 static inline unsigned long get_state_synchronize_rcu(void)
18 unsigned long rgos_norm; !! 31 {
19 }; !! 32 return 0;
>> 33 }
20 34
21 // Maximum number of rcu_gp_oldstate values co !! 35 static inline void cond_synchronize_rcu(unsigned long oldstate)
22 // not-yet-completed RCU grace periods. !! 36 {
23 #define NUM_ACTIVE_RCU_POLL_FULL_OLDSTATE 2 !! 37 might_sleep();
>> 38 }
24 39
25 /* !! 40 static inline unsigned long get_state_synchronize_sched(void)
26 * Are the two oldstate values the same? See <<
27 * docbook header. <<
28 */ <<
29 static inline bool same_state_synchronize_rcu_ <<
30 <<
31 { 41 {
32 return rgosp1->rgos_norm == rgosp2->rg !! 42 return 0;
33 } 43 }
34 44
35 unsigned long get_state_synchronize_rcu(void); !! 45 static inline void cond_synchronize_sched(unsigned long oldstate)
>> 46 {
>> 47 might_sleep();
>> 48 }
36 49
37 static inline void get_state_synchronize_rcu_f !! 50 static inline void rcu_barrier_bh(void)
38 { 51 {
39 rgosp->rgos_norm = get_state_synchroni !! 52 wait_rcu_gp(call_rcu_bh);
40 } 53 }
41 54
42 unsigned long start_poll_synchronize_rcu(void) !! 55 static inline void rcu_barrier_sched(void)
>> 56 {
>> 57 wait_rcu_gp(call_rcu_sched);
>> 58 }
43 59
44 static inline void start_poll_synchronize_rcu_ !! 60 static inline void synchronize_rcu_expedited(void)
45 { 61 {
46 rgosp->rgos_norm = start_poll_synchron !! 62 synchronize_sched(); /* Only one CPU, so pretty fast anyway!!! */
47 } 63 }
48 64
49 bool poll_state_synchronize_rcu(unsigned long !! 65 static inline void rcu_barrier(void)
>> 66 {
>> 67 rcu_barrier_sched(); /* Only one CPU, so only one list of callbacks! */
>> 68 }
50 69
51 static inline bool poll_state_synchronize_rcu_ !! 70 static inline void synchronize_rcu_bh(void)
52 { 71 {
53 return poll_state_synchronize_rcu(rgos !! 72 synchronize_sched();
54 } 73 }
55 74
56 static inline void cond_synchronize_rcu(unsign !! 75 static inline void synchronize_rcu_bh_expedited(void)
57 { 76 {
58 might_sleep(); !! 77 synchronize_sched();
59 } 78 }
60 79
61 static inline void cond_synchronize_rcu_full(s !! 80 static inline void synchronize_sched_expedited(void)
62 { 81 {
63 cond_synchronize_rcu(rgosp->rgos_norm) !! 82 synchronize_sched();
64 } 83 }
65 84
66 static inline unsigned long start_poll_synchro !! 85 static inline void kfree_call_rcu(struct rcu_head *head,
>> 86 rcu_callback_t func)
67 { 87 {
68 return start_poll_synchronize_rcu(); !! 88 call_rcu(head, func);
69 } 89 }
70 90
71 static inline void start_poll_synchronize_rcu_ !! 91 static inline void rcu_note_context_switch(void)
72 { 92 {
73 rgosp->rgos_norm = start_poll_synchron !! 93 rcu_sched_qs();
74 } 94 }
75 95
76 static inline void cond_synchronize_rcu_expedi !! 96 /*
>> 97 * Take advantage of the fact that there is only one CPU, which
>> 98 * allows us to ignore virtualization-based context switches.
>> 99 */
>> 100 static inline void rcu_virt_note_context_switch(int cpu)
77 { 101 {
78 cond_synchronize_rcu(oldstate); <<
79 } 102 }
80 103
81 static inline void cond_synchronize_rcu_expedi !! 104 /*
>> 105 * Return the number of grace periods started.
>> 106 */
>> 107 static inline unsigned long rcu_batches_started(void)
82 { 108 {
83 cond_synchronize_rcu_expedited(rgosp-> !! 109 return 0;
84 } 110 }
85 111
86 extern void rcu_barrier(void); !! 112 /*
>> 113 * Return the number of bottom-half grace periods started.
>> 114 */
>> 115 static inline unsigned long rcu_batches_started_bh(void)
>> 116 {
>> 117 return 0;
>> 118 }
87 119
88 static inline void synchronize_rcu_expedited(v !! 120 /*
>> 121 * Return the number of sched grace periods started.
>> 122 */
>> 123 static inline unsigned long rcu_batches_started_sched(void)
89 { 124 {
90 synchronize_rcu(); !! 125 return 0;
91 } 126 }
92 127
93 /* 128 /*
94 * Add one more declaration of kvfree() here. !! 129 * Return the number of grace periods completed.
95 * not so straight forward to just include <li <<
96 * where it is defined due to getting many com <<
97 * errors caused by that include. <<
98 */ 130 */
99 extern void kvfree(const void *addr); !! 131 static inline unsigned long rcu_batches_completed(void)
>> 132 {
>> 133 return 0;
>> 134 }
100 135
101 static inline void __kvfree_call_rcu(struct rc !! 136 /*
>> 137 * Return the number of bottom-half grace periods completed.
>> 138 */
>> 139 static inline unsigned long rcu_batches_completed_bh(void)
102 { 140 {
103 if (head) { !! 141 return 0;
104 call_rcu(head, (rcu_callback_t !! 142 }
105 return; <<
106 } <<
107 143
108 // kvfree_rcu(one_arg) call. !! 144 /*
109 might_sleep(); !! 145 * Return the number of sched grace periods completed.
110 synchronize_rcu(); !! 146 */
111 kvfree(ptr); !! 147 static inline unsigned long rcu_batches_completed_sched(void)
>> 148 {
>> 149 return 0;
112 } 150 }
113 151
114 static inline void kvfree_rcu_barrier(void) !! 152 /*
>> 153 * Return the number of expedited grace periods completed.
>> 154 */
>> 155 static inline unsigned long rcu_exp_batches_completed(void)
115 { 156 {
116 rcu_barrier(); !! 157 return 0;
117 } 158 }
118 159
119 #ifdef CONFIG_KASAN_GENERIC !! 160 /*
120 void kvfree_call_rcu(struct rcu_head *head, vo !! 161 * Return the number of expedited sched grace periods completed.
121 #else !! 162 */
122 static inline void kvfree_call_rcu(struct rcu_ !! 163 static inline unsigned long rcu_exp_batches_completed_sched(void)
123 { 164 {
124 __kvfree_call_rcu(head, ptr); !! 165 return 0;
125 } 166 }
126 #endif <<
127 167
128 void rcu_qs(void); !! 168 static inline void rcu_force_quiescent_state(void)
>> 169 {
>> 170 }
129 171
130 static inline void rcu_softirq_qs(void) !! 172 static inline void rcu_bh_force_quiescent_state(void)
131 { 173 {
132 rcu_qs(); <<
133 } 174 }
134 175
135 #define rcu_note_context_switch(preempt) \ !! 176 static inline void rcu_sched_force_quiescent_state(void)
136 do { \ !! 177 {
137 rcu_qs(); \ !! 178 }
138 rcu_tasks_qs(current, (preempt <<
139 } while (0) <<
140 179
141 static inline int rcu_needs_cpu(void) !! 180 static inline void show_rcu_gp_kthreads(void)
142 { 181 {
143 return 0; <<
144 } 182 }
145 183
146 static inline void rcu_request_urgent_qs_task( !! 184 static inline void rcu_cpu_stall_reset(void)
>> 185 {
>> 186 }
147 187
148 /* !! 188 static inline void rcu_idle_enter(void)
149 * Take advantage of the fact that there is on !! 189 {
150 * allows us to ignore virtualization-based co !! 190 }
151 */ !! 191
152 static inline void rcu_virt_note_context_switc !! 192 static inline void rcu_idle_exit(void)
153 static inline void rcu_cpu_stall_reset(void) { !! 193 {
154 static inline int rcu_jiffies_till_stall_check !! 194 }
155 static inline void rcu_irq_exit_check_preempt( !! 195
156 static inline void exit_rcu(void) { } !! 196 static inline void rcu_irq_enter(void)
157 static inline bool rcu_preempt_need_deferred_q !! 197 {
>> 198 }
>> 199
>> 200 static inline void rcu_irq_exit_irqson(void)
158 { 201 {
159 return false; <<
160 } 202 }
161 static inline void rcu_preempt_deferred_qs(str !! 203
>> 204 static inline void rcu_irq_enter_irqson(void)
>> 205 {
>> 206 }
>> 207
>> 208 static inline void rcu_irq_exit(void)
>> 209 {
>> 210 }
>> 211
>> 212 static inline void exit_rcu(void)
>> 213 {
>> 214 }
>> 215
>> 216 #ifdef CONFIG_DEBUG_LOCK_ALLOC
>> 217 extern int rcu_scheduler_active __read_mostly;
162 void rcu_scheduler_starting(void); 218 void rcu_scheduler_starting(void);
163 static inline void rcu_end_inkernel_boot(void) !! 219 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
164 static inline bool rcu_inkernel_boot_has_ended !! 220 static inline void rcu_scheduler_starting(void)
165 static inline bool rcu_is_watching(void) { ret !! 221 {
166 static inline void rcu_momentary_eqs(void) { } !! 222 }
167 static inline void kfree_rcu_scheduler_running !! 223 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
168 static inline bool rcu_gp_might_be_stalled(voi !! 224
>> 225 #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE)
>> 226
>> 227 static inline bool rcu_is_watching(void)
>> 228 {
>> 229 return __rcu_is_watching();
>> 230 }
>> 231
>> 232 #else /* defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) */
169 233
170 /* Avoid RCU read-side critical sections leaki !! 234 static inline bool rcu_is_watching(void)
171 static inline void rcu_all_qs(void) { barrier( !! 235 {
>> 236 return true;
>> 237 }
>> 238
>> 239 #endif /* #else defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) */
>> 240
>> 241 static inline void rcu_all_qs(void)
>> 242 {
>> 243 barrier(); /* Avoid RCU read-side critical sections leaking across. */
>> 244 }
172 245
173 /* RCUtree hotplug events */ 246 /* RCUtree hotplug events */
174 #define rcutree_prepare_cpu NULL 247 #define rcutree_prepare_cpu NULL
175 #define rcutree_online_cpu NULL 248 #define rcutree_online_cpu NULL
176 #define rcutree_offline_cpu NULL 249 #define rcutree_offline_cpu NULL
177 #define rcutree_dead_cpu NULL 250 #define rcutree_dead_cpu NULL
178 #define rcutree_dying_cpu NULL 251 #define rcutree_dying_cpu NULL
179 static inline void rcutree_report_cpu_starting <<
180 252
181 #endif /* __LINUX_RCUTINY_H */ 253 #endif /* __LINUX_RCUTINY_H */
182 254
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.