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, write to the Free Software
>> 16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
>> 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 void rcu_init(void)
18 unsigned long rgos_norm; !! 31 {
19 }; !! 32 }
20 <<
21 // Maximum number of rcu_gp_oldstate values co <<
22 // not-yet-completed RCU grace periods. <<
23 #define NUM_ACTIVE_RCU_POLL_FULL_OLDSTATE 2 <<
24 33
25 /* !! 34 static inline void rcu_barrier_bh(void)
26 * Are the two oldstate values the same? See <<
27 * docbook header. <<
28 */ <<
29 static inline bool same_state_synchronize_rcu_ <<
30 <<
31 { 35 {
32 return rgosp1->rgos_norm == rgosp2->rg !! 36 wait_rcu_gp(call_rcu_bh);
33 } 37 }
34 38
35 unsigned long get_state_synchronize_rcu(void); !! 39 static inline void rcu_barrier_sched(void)
>> 40 {
>> 41 wait_rcu_gp(call_rcu_sched);
>> 42 }
36 43
37 static inline void get_state_synchronize_rcu_f !! 44 #ifdef CONFIG_TINY_RCU
>> 45
>> 46 static inline void synchronize_rcu_expedited(void)
38 { 47 {
39 rgosp->rgos_norm = get_state_synchroni !! 48 synchronize_sched(); /* Only one CPU, so pretty fast anyway!!! */
40 } 49 }
41 50
42 unsigned long start_poll_synchronize_rcu(void) !! 51 static inline void rcu_barrier(void)
>> 52 {
>> 53 rcu_barrier_sched(); /* Only one CPU, so only one list of callbacks! */
>> 54 }
>> 55
>> 56 #else /* #ifdef CONFIG_TINY_RCU */
43 57
44 static inline void start_poll_synchronize_rcu_ !! 58 void synchronize_rcu_expedited(void);
>> 59
>> 60 static inline void rcu_barrier(void)
45 { 61 {
46 rgosp->rgos_norm = start_poll_synchron !! 62 wait_rcu_gp(call_rcu);
47 } 63 }
48 64
49 bool poll_state_synchronize_rcu(unsigned long !! 65 #endif /* #else #ifdef CONFIG_TINY_RCU */
50 66
51 static inline bool poll_state_synchronize_rcu_ !! 67 static inline void synchronize_rcu_bh(void)
52 { 68 {
53 return poll_state_synchronize_rcu(rgos !! 69 synchronize_sched();
54 } 70 }
55 71
56 static inline void cond_synchronize_rcu(unsign !! 72 static inline void synchronize_rcu_bh_expedited(void)
57 { 73 {
58 might_sleep(); !! 74 synchronize_sched();
59 } 75 }
60 76
61 static inline void cond_synchronize_rcu_full(s !! 77 static inline void synchronize_sched_expedited(void)
62 { 78 {
63 cond_synchronize_rcu(rgosp->rgos_norm) !! 79 synchronize_sched();
64 } 80 }
65 81
66 static inline unsigned long start_poll_synchro !! 82 static inline void kfree_call_rcu(struct rcu_head *head,
>> 83 void (*func)(struct rcu_head *rcu))
67 { 84 {
68 return start_poll_synchronize_rcu(); !! 85 call_rcu(head, func);
69 } 86 }
70 87
71 static inline void start_poll_synchronize_rcu_ !! 88 #ifdef CONFIG_TINY_RCU
>> 89
>> 90 static inline void rcu_preempt_note_context_switch(void)
72 { 91 {
73 rgosp->rgos_norm = start_poll_synchron <<
74 } 92 }
75 93
76 static inline void cond_synchronize_rcu_expedi !! 94 static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
77 { 95 {
78 cond_synchronize_rcu(oldstate); !! 96 *delta_jiffies = ULONG_MAX;
>> 97 return 0;
79 } 98 }
80 99
81 static inline void cond_synchronize_rcu_expedi !! 100 #else /* #ifdef CONFIG_TINY_RCU */
>> 101
>> 102 void rcu_preempt_note_context_switch(void);
>> 103 int rcu_preempt_needs_cpu(void);
>> 104
>> 105 static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
82 { 106 {
83 cond_synchronize_rcu_expedited(rgosp-> !! 107 *delta_jiffies = ULONG_MAX;
>> 108 return rcu_preempt_needs_cpu();
84 } 109 }
85 110
86 extern void rcu_barrier(void); !! 111 #endif /* #else #ifdef CONFIG_TINY_RCU */
87 112
88 static inline void synchronize_rcu_expedited(v !! 113 static inline void rcu_note_context_switch(int cpu)
89 { 114 {
90 synchronize_rcu(); !! 115 rcu_sched_qs(cpu);
>> 116 rcu_preempt_note_context_switch();
91 } 117 }
92 118
93 /* 119 /*
94 * Add one more declaration of kvfree() here. !! 120 * Take advantage of the fact that there is only one CPU, which
95 * not so straight forward to just include <li !! 121 * allows us to ignore virtualization-based context switches.
96 * where it is defined due to getting many com <<
97 * errors caused by that include. <<
98 */ 122 */
99 extern void kvfree(const void *addr); !! 123 static inline void rcu_virt_note_context_switch(int cpu)
100 <<
101 static inline void __kvfree_call_rcu(struct rc <<
102 { 124 {
103 if (head) { <<
104 call_rcu(head, (rcu_callback_t <<
105 return; <<
106 } <<
107 <<
108 // kvfree_rcu(one_arg) call. <<
109 might_sleep(); <<
110 synchronize_rcu(); <<
111 kvfree(ptr); <<
112 } 125 }
113 126
114 static inline void kvfree_rcu_barrier(void) !! 127 /*
>> 128 * Return the number of grace periods.
>> 129 */
>> 130 static inline long rcu_batches_completed(void)
115 { 131 {
116 rcu_barrier(); !! 132 return 0;
117 } 133 }
118 134
119 #ifdef CONFIG_KASAN_GENERIC !! 135 /*
120 void kvfree_call_rcu(struct rcu_head *head, vo !! 136 * Return the number of bottom-half grace periods.
121 #else !! 137 */
122 static inline void kvfree_call_rcu(struct rcu_ !! 138 static inline long rcu_batches_completed_bh(void)
123 { 139 {
124 __kvfree_call_rcu(head, ptr); !! 140 return 0;
125 } 141 }
126 #endif <<
127 142
128 void rcu_qs(void); !! 143 static inline void rcu_force_quiescent_state(void)
129 <<
130 static inline void rcu_softirq_qs(void) <<
131 { 144 {
132 rcu_qs(); <<
133 } 145 }
134 146
135 #define rcu_note_context_switch(preempt) \ !! 147 static inline void rcu_bh_force_quiescent_state(void)
136 do { \ !! 148 {
137 rcu_qs(); \ !! 149 }
138 rcu_tasks_qs(current, (preempt <<
139 } while (0) <<
140 150
141 static inline int rcu_needs_cpu(void) !! 151 static inline void rcu_sched_force_quiescent_state(void)
142 { 152 {
143 return 0; <<
144 } 153 }
145 154
146 static inline void rcu_request_urgent_qs_task( !! 155 static inline void rcu_cpu_stall_reset(void)
>> 156 {
>> 157 }
147 158
148 /* !! 159 #ifdef CONFIG_DEBUG_LOCK_ALLOC
149 * Take advantage of the fact that there is on !! 160 extern int rcu_scheduler_active __read_mostly;
150 * allows us to ignore virtualization-based co !! 161 extern void rcu_scheduler_starting(void);
151 */ !! 162 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
152 static inline void rcu_virt_note_context_switc !! 163 static inline void rcu_scheduler_starting(void)
153 static inline void rcu_cpu_stall_reset(void) { !! 164 {
154 static inline int rcu_jiffies_till_stall_check !! 165 }
155 static inline void rcu_irq_exit_check_preempt( !! 166 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
156 static inline void exit_rcu(void) { } <<
157 static inline bool rcu_preempt_need_deferred_q <<
158 { <<
159 return false; <<
160 } <<
161 static inline void rcu_preempt_deferred_qs(str <<
162 void rcu_scheduler_starting(void); <<
163 static inline void rcu_end_inkernel_boot(void) <<
164 static inline bool rcu_inkernel_boot_has_ended <<
165 static inline bool rcu_is_watching(void) { ret <<
166 static inline void rcu_momentary_eqs(void) { } <<
167 static inline void kfree_rcu_scheduler_running <<
168 static inline bool rcu_gp_might_be_stalled(voi <<
169 <<
170 /* Avoid RCU read-side critical sections leaki <<
171 static inline void rcu_all_qs(void) { barrier( <<
172 <<
173 /* RCUtree hotplug events */ <<
174 #define rcutree_prepare_cpu NULL <<
175 #define rcutree_online_cpu NULL <<
176 #define rcutree_offline_cpu NULL <<
177 #define rcutree_dead_cpu NULL <<
178 #define rcutree_dying_cpu NULL <<
179 static inline void rcutree_report_cpu_starting <<
180 167
181 #endif /* __LINUX_RCUTINY_H */ 168 #endif /* __LINUX_RCUTINY_H */
182 169
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.