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/ktime.h>
16 <<
17 struct rcu_gp_oldstate { <<
18 unsigned long rgos_norm; <<
19 }; <<
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 <<
25 /* <<
26 * Are the two oldstate values the same? See <<
27 * docbook header. <<
28 */ <<
29 static inline bool same_state_synchronize_rcu_ <<
30 <<
31 { <<
32 return rgosp1->rgos_norm == rgosp2->rg <<
33 } <<
34 <<
35 unsigned long get_state_synchronize_rcu(void); <<
36 <<
37 static inline void get_state_synchronize_rcu_f <<
38 { <<
39 rgosp->rgos_norm = get_state_synchroni <<
40 } <<
41 <<
42 unsigned long start_poll_synchronize_rcu(void) <<
43 29
44 static inline void start_poll_synchronize_rcu_ !! 30 struct rcu_dynticks;
>> 31 static inline int rcu_dynticks_snap(struct rcu_dynticks *rdtp)
45 { 32 {
46 rgosp->rgos_norm = start_poll_synchron !! 33 return 0;
47 } 34 }
48 35
49 bool poll_state_synchronize_rcu(unsigned long !! 36 /* Never flag non-existent other CPUs! */
>> 37 static inline bool rcu_eqs_special_set(int cpu) { return false; }
50 38
51 static inline bool poll_state_synchronize_rcu_ !! 39 static inline unsigned long get_state_synchronize_rcu(void)
52 { 40 {
53 return poll_state_synchronize_rcu(rgos !! 41 return 0;
54 } 42 }
55 43
56 static inline void cond_synchronize_rcu(unsign 44 static inline void cond_synchronize_rcu(unsigned long oldstate)
57 { 45 {
58 might_sleep(); 46 might_sleep();
59 } 47 }
60 48
61 static inline void cond_synchronize_rcu_full(s !! 49 static inline unsigned long get_state_synchronize_sched(void)
62 { 50 {
63 cond_synchronize_rcu(rgosp->rgos_norm) !! 51 return 0;
64 } <<
65 <<
66 static inline unsigned long start_poll_synchro <<
67 { <<
68 return start_poll_synchronize_rcu(); <<
69 } 52 }
70 53
71 static inline void start_poll_synchronize_rcu_ !! 54 static inline void cond_synchronize_sched(unsigned long oldstate)
72 { 55 {
73 rgosp->rgos_norm = start_poll_synchron !! 56 might_sleep();
74 } 57 }
75 58
76 static inline void cond_synchronize_rcu_expedi !! 59 extern void rcu_barrier_bh(void);
77 { !! 60 extern void rcu_barrier_sched(void);
78 cond_synchronize_rcu(oldstate); <<
79 } <<
80 61
81 static inline void cond_synchronize_rcu_expedi !! 62 static inline void synchronize_rcu_expedited(void)
82 { 63 {
83 cond_synchronize_rcu_expedited(rgosp-> !! 64 synchronize_sched(); /* Only one CPU, so pretty fast anyway!!! */
84 } 65 }
85 66
86 extern void rcu_barrier(void); !! 67 static inline void rcu_barrier(void)
87 <<
88 static inline void synchronize_rcu_expedited(v <<
89 { 68 {
90 synchronize_rcu(); !! 69 rcu_barrier_sched(); /* Only one CPU, so only one list of callbacks! */
91 } 70 }
92 71
93 /* !! 72 static inline void synchronize_rcu_bh(void)
94 * Add one more declaration of kvfree() here. <<
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 */ <<
99 extern void kvfree(const void *addr); <<
100 <<
101 static inline void __kvfree_call_rcu(struct rc <<
102 { 73 {
103 if (head) { !! 74 synchronize_sched();
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 } 75 }
113 76
114 static inline void kvfree_rcu_barrier(void) !! 77 static inline void synchronize_rcu_bh_expedited(void)
115 { 78 {
116 rcu_barrier(); !! 79 synchronize_sched();
117 } 80 }
118 81
119 #ifdef CONFIG_KASAN_GENERIC !! 82 static inline void synchronize_sched_expedited(void)
120 void kvfree_call_rcu(struct rcu_head *head, vo <<
121 #else <<
122 static inline void kvfree_call_rcu(struct rcu_ <<
123 { 83 {
124 __kvfree_call_rcu(head, ptr); !! 84 synchronize_sched();
125 } 85 }
126 #endif <<
127 86
128 void rcu_qs(void); !! 87 static inline void kfree_call_rcu(struct rcu_head *head,
129 !! 88 rcu_callback_t func)
130 static inline void rcu_softirq_qs(void) <<
131 { 89 {
132 rcu_qs(); !! 90 call_rcu(head, func);
133 } 91 }
134 92
135 #define rcu_note_context_switch(preempt) \ 93 #define rcu_note_context_switch(preempt) \
136 do { \ 94 do { \
137 rcu_qs(); \ !! 95 rcu_sched_qs(); \
138 rcu_tasks_qs(current, (preempt !! 96 rcu_note_voluntary_context_switch_lite(current); \
139 } while (0) 97 } while (0)
140 98
141 static inline int rcu_needs_cpu(void) !! 99 static inline int rcu_needs_cpu(u64 basemono, u64 *nextevt)
142 { 100 {
>> 101 *nextevt = KTIME_MAX;
143 return 0; 102 return 0;
144 } 103 }
145 104
146 static inline void rcu_request_urgent_qs_task( <<
147 <<
148 /* 105 /*
149 * Take advantage of the fact that there is on 106 * Take advantage of the fact that there is only one CPU, which
150 * allows us to ignore virtualization-based co 107 * allows us to ignore virtualization-based context switches.
151 */ 108 */
152 static inline void rcu_virt_note_context_switc !! 109 static inline void rcu_virt_note_context_switch(int cpu) { }
153 static inline void rcu_cpu_stall_reset(void) { 110 static inline void rcu_cpu_stall_reset(void) { }
154 static inline int rcu_jiffies_till_stall_check !! 111 static inline void rcu_idle_enter(void) { }
155 static inline void rcu_irq_exit_check_preempt( !! 112 static inline void rcu_idle_exit(void) { }
>> 113 static inline void rcu_irq_enter(void) { }
>> 114 static inline void rcu_irq_exit_irqson(void) { }
>> 115 static inline void rcu_irq_enter_irqson(void) { }
>> 116 static inline void rcu_irq_exit(void) { }
156 static inline void exit_rcu(void) { } 117 static inline void exit_rcu(void) { }
157 static inline bool rcu_preempt_need_deferred_q !! 118 #ifdef CONFIG_SRCU
158 { <<
159 return false; <<
160 } <<
161 static inline void rcu_preempt_deferred_qs(str <<
162 void rcu_scheduler_starting(void); 119 void rcu_scheduler_starting(void);
>> 120 #else /* #ifndef CONFIG_SRCU */
>> 121 static inline void rcu_scheduler_starting(void) { }
>> 122 #endif /* #else #ifndef CONFIG_SRCU */
163 static inline void rcu_end_inkernel_boot(void) 123 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 124 static inline bool rcu_is_watching(void) { return true; }
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 125
170 /* Avoid RCU read-side critical sections leaki 126 /* Avoid RCU read-side critical sections leaking across. */
171 static inline void rcu_all_qs(void) { barrier( 127 static inline void rcu_all_qs(void) { barrier(); }
172 128
173 /* RCUtree hotplug events */ 129 /* RCUtree hotplug events */
174 #define rcutree_prepare_cpu NULL 130 #define rcutree_prepare_cpu NULL
175 #define rcutree_online_cpu NULL 131 #define rcutree_online_cpu NULL
176 #define rcutree_offline_cpu NULL 132 #define rcutree_offline_cpu NULL
177 #define rcutree_dead_cpu NULL 133 #define rcutree_dead_cpu NULL
178 #define rcutree_dying_cpu NULL 134 #define rcutree_dying_cpu NULL
179 static inline void rcutree_report_cpu_starting <<
180 135
181 #endif /* __LINUX_RCUTINY_H */ 136 #endif /* __LINUX_RCUTINY_H */
182 137
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.