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