Rev 6936 | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 6936 | Rev 7143 | ||
---|---|---|---|
1 | #ifndef __LINUX_CPUMASK_H |
1 | #ifndef __LINUX_CPUMASK_H |
2 | #define __LINUX_CPUMASK_H |
2 | #define __LINUX_CPUMASK_H |
3 | 3 | ||
4 | /* |
4 | /* |
5 | * Cpumasks provide a bitmap suitable for representing the |
5 | * Cpumasks provide a bitmap suitable for representing the |
6 | * set of CPU's in a system, one bit position per CPU number. In general, |
6 | * set of CPU's in a system, one bit position per CPU number. In general, |
7 | * only nr_cpu_ids (<= NR_CPUS) bits are valid. |
7 | * only nr_cpu_ids (<= NR_CPUS) bits are valid. |
8 | */ |
8 | */ |
9 | #include |
9 | #include |
10 | #include |
10 | #include |
11 | #include |
11 | #include |
12 | #include |
12 | #include |
13 | 13 | ||
14 | /* Don't assign or return these: may not be this big! */ |
14 | /* Don't assign or return these: may not be this big! */ |
15 | typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t; |
15 | typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t; |
16 | 16 | ||
17 | /** |
17 | /** |
18 | * cpumask_bits - get the bits in a cpumask |
18 | * cpumask_bits - get the bits in a cpumask |
19 | * @maskp: the struct cpumask * |
19 | * @maskp: the struct cpumask * |
20 | * |
20 | * |
21 | * You should only assume nr_cpu_ids bits of this mask are valid. This is |
21 | * You should only assume nr_cpu_ids bits of this mask are valid. This is |
22 | * a macro so it's const-correct. |
22 | * a macro so it's const-correct. |
23 | */ |
23 | */ |
24 | #define cpumask_bits(maskp) ((maskp)->bits) |
24 | #define cpumask_bits(maskp) ((maskp)->bits) |
25 | 25 | ||
26 | /** |
26 | /** |
27 | * cpumask_pr_args - printf args to output a cpumask |
27 | * cpumask_pr_args - printf args to output a cpumask |
28 | * @maskp: cpumask to be printed |
28 | * @maskp: cpumask to be printed |
29 | * |
29 | * |
30 | * Can be used to provide arguments for '%*pb[l]' when printing a cpumask. |
30 | * Can be used to provide arguments for '%*pb[l]' when printing a cpumask. |
31 | */ |
31 | */ |
32 | #define cpumask_pr_args(maskp) nr_cpu_ids, cpumask_bits(maskp) |
32 | #define cpumask_pr_args(maskp) nr_cpu_ids, cpumask_bits(maskp) |
33 | 33 | ||
34 | #if NR_CPUS == 1 |
34 | #if NR_CPUS == 1 |
35 | #define nr_cpu_ids 1 |
35 | #define nr_cpu_ids 1 |
36 | #else |
36 | #else |
37 | extern int nr_cpu_ids; |
37 | extern int nr_cpu_ids; |
38 | #endif |
38 | #endif |
39 | 39 | ||
40 | #ifdef CONFIG_CPUMASK_OFFSTACK |
40 | #ifdef CONFIG_CPUMASK_OFFSTACK |
41 | /* Assuming NR_CPUS is huge, a runtime limit is more efficient. Also, |
41 | /* Assuming NR_CPUS is huge, a runtime limit is more efficient. Also, |
42 | * not all bits may be allocated. */ |
42 | * not all bits may be allocated. */ |
43 | #define nr_cpumask_bits nr_cpu_ids |
43 | #define nr_cpumask_bits nr_cpu_ids |
44 | #else |
44 | #else |
45 | #define nr_cpumask_bits NR_CPUS |
45 | #define nr_cpumask_bits NR_CPUS |
46 | #endif |
46 | #endif |
47 | 47 | ||
48 | /* |
48 | /* |
49 | * The following particular system cpumasks and operations manage |
49 | * The following particular system cpumasks and operations manage |
50 | * possible, present, active and online cpus. |
50 | * possible, present, active and online cpus. |
51 | * |
51 | * |
52 | * cpu_possible_mask- has bit 'cpu' set iff cpu is populatable |
52 | * cpu_possible_mask- has bit 'cpu' set iff cpu is populatable |
53 | * cpu_present_mask - has bit 'cpu' set iff cpu is populated |
53 | * cpu_present_mask - has bit 'cpu' set iff cpu is populated |
54 | * cpu_online_mask - has bit 'cpu' set iff cpu available to scheduler |
54 | * cpu_online_mask - has bit 'cpu' set iff cpu available to scheduler |
55 | * cpu_active_mask - has bit 'cpu' set iff cpu available to migration |
55 | * cpu_active_mask - has bit 'cpu' set iff cpu available to migration |
56 | * |
56 | * |
57 | * If !CONFIG_HOTPLUG_CPU, present == possible, and active == online. |
57 | * If !CONFIG_HOTPLUG_CPU, present == possible, and active == online. |
58 | * |
58 | * |
59 | * The cpu_possible_mask is fixed at boot time, as the set of CPU id's |
59 | * The cpu_possible_mask is fixed at boot time, as the set of CPU id's |
60 | * that it is possible might ever be plugged in at anytime during the |
60 | * that it is possible might ever be plugged in at anytime during the |
61 | * life of that system boot. The cpu_present_mask is dynamic(*), |
61 | * life of that system boot. The cpu_present_mask is dynamic(*), |
62 | * representing which CPUs are currently plugged in. And |
62 | * representing which CPUs are currently plugged in. And |
63 | * cpu_online_mask is the dynamic subset of cpu_present_mask, |
63 | * cpu_online_mask is the dynamic subset of cpu_present_mask, |
64 | * indicating those CPUs available for scheduling. |
64 | * indicating those CPUs available for scheduling. |
65 | * |
65 | * |
66 | * If HOTPLUG is enabled, then cpu_possible_mask is forced to have |
66 | * If HOTPLUG is enabled, then cpu_possible_mask is forced to have |
67 | * all NR_CPUS bits set, otherwise it is just the set of CPUs that |
67 | * all NR_CPUS bits set, otherwise it is just the set of CPUs that |
68 | * ACPI reports present at boot. |
68 | * ACPI reports present at boot. |
69 | * |
69 | * |
70 | * If HOTPLUG is enabled, then cpu_present_mask varies dynamically, |
70 | * If HOTPLUG is enabled, then cpu_present_mask varies dynamically, |
71 | * depending on what ACPI reports as currently plugged in, otherwise |
71 | * depending on what ACPI reports as currently plugged in, otherwise |
72 | * cpu_present_mask is just a copy of cpu_possible_mask. |
72 | * cpu_present_mask is just a copy of cpu_possible_mask. |
73 | * |
73 | * |
74 | * (*) Well, cpu_present_mask is dynamic in the hotplug case. If not |
74 | * (*) Well, cpu_present_mask is dynamic in the hotplug case. If not |
75 | * hotplug, it's a copy of cpu_possible_mask, hence fixed at boot. |
75 | * hotplug, it's a copy of cpu_possible_mask, hence fixed at boot. |
76 | * |
76 | * |
77 | * Subtleties: |
77 | * Subtleties: |
78 | * 1) UP arch's (NR_CPUS == 1, CONFIG_SMP not defined) hardcode |
78 | * 1) UP arch's (NR_CPUS == 1, CONFIG_SMP not defined) hardcode |
79 | * assumption that their single CPU is online. The UP |
79 | * assumption that their single CPU is online. The UP |
80 | * cpu_{online,possible,present}_masks are placebos. Changing them |
80 | * cpu_{online,possible,present}_masks are placebos. Changing them |
81 | * will have no useful affect on the following num_*_cpus() |
81 | * will have no useful affect on the following num_*_cpus() |
82 | * and cpu_*() macros in the UP case. This ugliness is a UP |
82 | * and cpu_*() macros in the UP case. This ugliness is a UP |
83 | * optimization - don't waste any instructions or memory references |
83 | * optimization - don't waste any instructions or memory references |
84 | * asking if you're online or how many CPUs there are if there is |
84 | * asking if you're online or how many CPUs there are if there is |
85 | * only one CPU. |
85 | * only one CPU. |
86 | */ |
86 | */ |
87 | 87 | ||
88 | extern struct cpumask __cpu_possible_mask; |
88 | extern struct cpumask __cpu_possible_mask; |
89 | extern struct cpumask __cpu_online_mask; |
89 | extern struct cpumask __cpu_online_mask; |
90 | extern struct cpumask __cpu_present_mask; |
90 | extern struct cpumask __cpu_present_mask; |
91 | extern struct cpumask __cpu_active_mask; |
91 | extern struct cpumask __cpu_active_mask; |
92 | #define cpu_possible_mask ((const struct cpumask *)&__cpu_possible_mask) |
92 | #define cpu_possible_mask ((const struct cpumask *)&__cpu_possible_mask) |
93 | #define cpu_online_mask ((const struct cpumask *)&__cpu_online_mask) |
93 | #define cpu_online_mask ((const struct cpumask *)&__cpu_online_mask) |
94 | #define cpu_present_mask ((const struct cpumask *)&__cpu_present_mask) |
94 | #define cpu_present_mask ((const struct cpumask *)&__cpu_present_mask) |
95 | #define cpu_active_mask ((const struct cpumask *)&__cpu_active_mask) |
95 | #define cpu_active_mask ((const struct cpumask *)&__cpu_active_mask) |
96 | 96 | ||
97 | #if NR_CPUS > 1 |
97 | #if NR_CPUS > 1 |
98 | #define num_online_cpus() cpumask_weight(cpu_online_mask) |
98 | #define num_online_cpus() cpumask_weight(cpu_online_mask) |
99 | #define num_possible_cpus() cpumask_weight(cpu_possible_mask) |
99 | #define num_possible_cpus() cpumask_weight(cpu_possible_mask) |
100 | #define num_present_cpus() cpumask_weight(cpu_present_mask) |
100 | #define num_present_cpus() cpumask_weight(cpu_present_mask) |
101 | #define num_active_cpus() cpumask_weight(cpu_active_mask) |
101 | #define num_active_cpus() cpumask_weight(cpu_active_mask) |
102 | #define cpu_online(cpu) cpumask_test_cpu((cpu), cpu_online_mask) |
102 | #define cpu_online(cpu) cpumask_test_cpu((cpu), cpu_online_mask) |
103 | #define cpu_possible(cpu) cpumask_test_cpu((cpu), cpu_possible_mask) |
103 | #define cpu_possible(cpu) cpumask_test_cpu((cpu), cpu_possible_mask) |
104 | #define cpu_present(cpu) cpumask_test_cpu((cpu), cpu_present_mask) |
104 | #define cpu_present(cpu) cpumask_test_cpu((cpu), cpu_present_mask) |
105 | #define cpu_active(cpu) cpumask_test_cpu((cpu), cpu_active_mask) |
105 | #define cpu_active(cpu) cpumask_test_cpu((cpu), cpu_active_mask) |
106 | #else |
106 | #else |
107 | #define num_online_cpus() 1U |
107 | #define num_online_cpus() 1U |
108 | #define num_possible_cpus() 1U |
108 | #define num_possible_cpus() 1U |
109 | #define num_present_cpus() 1U |
109 | #define num_present_cpus() 1U |
110 | #define num_active_cpus() 1U |
110 | #define num_active_cpus() 1U |
111 | #define cpu_online(cpu) ((cpu) == 0) |
111 | #define cpu_online(cpu) ((cpu) == 0) |
112 | #define cpu_possible(cpu) ((cpu) == 0) |
112 | #define cpu_possible(cpu) ((cpu) == 0) |
113 | #define cpu_present(cpu) ((cpu) == 0) |
113 | #define cpu_present(cpu) ((cpu) == 0) |
114 | #define cpu_active(cpu) ((cpu) == 0) |
114 | #define cpu_active(cpu) ((cpu) == 0) |
115 | #endif |
115 | #endif |
116 | 116 | ||
117 | /* verify cpu argument to cpumask_* operators */ |
117 | /* verify cpu argument to cpumask_* operators */ |
118 | static inline unsigned int cpumask_check(unsigned int cpu) |
118 | static inline unsigned int cpumask_check(unsigned int cpu) |
119 | { |
119 | { |
120 | #ifdef CONFIG_DEBUG_PER_CPU_MAPS |
120 | #ifdef CONFIG_DEBUG_PER_CPU_MAPS |
121 | WARN_ON_ONCE(cpu >= nr_cpumask_bits); |
121 | WARN_ON_ONCE(cpu >= nr_cpumask_bits); |
122 | #endif /* CONFIG_DEBUG_PER_CPU_MAPS */ |
122 | #endif /* CONFIG_DEBUG_PER_CPU_MAPS */ |
123 | return cpu; |
123 | return cpu; |
124 | } |
124 | } |
125 | 125 | ||
126 | #if NR_CPUS == 1 |
126 | #if NR_CPUS == 1 |
127 | /* Uniprocessor. Assume all masks are "1". */ |
127 | /* Uniprocessor. Assume all masks are "1". */ |
128 | static inline unsigned int cpumask_first(const struct cpumask *srcp) |
128 | static inline unsigned int cpumask_first(const struct cpumask *srcp) |
129 | { |
129 | { |
130 | return 0; |
130 | return 0; |
131 | } |
131 | } |
132 | 132 | ||
133 | /* Valid inputs for n are -1 and 0. */ |
133 | /* Valid inputs for n are -1 and 0. */ |
134 | static inline unsigned int cpumask_next(int n, const struct cpumask *srcp) |
134 | static inline unsigned int cpumask_next(int n, const struct cpumask *srcp) |
135 | { |
135 | { |
136 | return n+1; |
136 | return n+1; |
137 | } |
137 | } |
138 | 138 | ||
139 | static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp) |
139 | static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp) |
140 | { |
140 | { |
141 | return n+1; |
141 | return n+1; |
142 | } |
142 | } |
143 | 143 | ||
144 | static inline unsigned int cpumask_next_and(int n, |
144 | static inline unsigned int cpumask_next_and(int n, |
145 | const struct cpumask *srcp, |
145 | const struct cpumask *srcp, |
146 | const struct cpumask *andp) |
146 | const struct cpumask *andp) |
147 | { |
147 | { |
148 | return n+1; |
148 | return n+1; |
149 | } |
149 | } |
150 | 150 | ||
151 | /* cpu must be a valid cpu, ie 0, so there's no other choice. */ |
151 | /* cpu must be a valid cpu, ie 0, so there's no other choice. */ |
152 | static inline unsigned int cpumask_any_but(const struct cpumask *mask, |
152 | static inline unsigned int cpumask_any_but(const struct cpumask *mask, |
153 | unsigned int cpu) |
153 | unsigned int cpu) |
154 | { |
154 | { |
155 | return 1; |
155 | return 1; |
156 | } |
156 | } |
157 | 157 | ||
158 | static inline unsigned int cpumask_local_spread(unsigned int i, int node) |
158 | static inline unsigned int cpumask_local_spread(unsigned int i, int node) |
159 | { |
159 | { |
160 | return 0; |
160 | return 0; |
161 | } |
161 | } |
162 | 162 | ||
163 | #define for_each_cpu(cpu, mask) \ |
163 | #define for_each_cpu(cpu, mask) \ |
164 | for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask) |
164 | for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask) |
165 | #define for_each_cpu_not(cpu, mask) \ |
165 | #define for_each_cpu_not(cpu, mask) \ |
166 | for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask) |
166 | for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask) |
167 | #define for_each_cpu_and(cpu, mask, and) \ |
167 | #define for_each_cpu_and(cpu, mask, and) \ |
168 | for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)and) |
168 | for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask, (void)and) |
169 | #else |
169 | #else |
170 | /** |
170 | /** |
171 | * cpumask_first - get the first cpu in a cpumask |
171 | * cpumask_first - get the first cpu in a cpumask |
172 | * @srcp: the cpumask pointer |
172 | * @srcp: the cpumask pointer |
173 | * |
173 | * |
174 | * Returns >= nr_cpu_ids if no cpus set. |
174 | * Returns >= nr_cpu_ids if no cpus set. |
175 | */ |
175 | */ |
176 | static inline unsigned int cpumask_first(const struct cpumask *srcp) |
176 | static inline unsigned int cpumask_first(const struct cpumask *srcp) |
177 | { |
177 | { |
178 | return find_first_bit(cpumask_bits(srcp), nr_cpumask_bits); |
178 | return find_first_bit(cpumask_bits(srcp), nr_cpumask_bits); |
179 | } |
179 | } |
180 | 180 | ||
181 | /** |
181 | /** |
182 | * cpumask_next - get the next cpu in a cpumask |
182 | * cpumask_next - get the next cpu in a cpumask |
183 | * @n: the cpu prior to the place to search (ie. return will be > @n) |
183 | * @n: the cpu prior to the place to search (ie. return will be > @n) |
184 | * @srcp: the cpumask pointer |
184 | * @srcp: the cpumask pointer |
185 | * |
185 | * |
186 | * Returns >= nr_cpu_ids if no further cpus set. |
186 | * Returns >= nr_cpu_ids if no further cpus set. |
187 | */ |
187 | */ |
188 | static inline unsigned int cpumask_next(int n, const struct cpumask *srcp) |
188 | static inline unsigned int cpumask_next(int n, const struct cpumask *srcp) |
189 | { |
189 | { |
190 | /* -1 is a legal arg here. */ |
190 | /* -1 is a legal arg here. */ |
191 | if (n != -1) |
191 | if (n != -1) |
192 | cpumask_check(n); |
192 | cpumask_check(n); |
193 | return find_next_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1); |
193 | return find_next_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1); |
194 | } |
194 | } |
195 | 195 | ||
196 | /** |
196 | /** |
197 | * cpumask_next_zero - get the next unset cpu in a cpumask |
197 | * cpumask_next_zero - get the next unset cpu in a cpumask |
198 | * @n: the cpu prior to the place to search (ie. return will be > @n) |
198 | * @n: the cpu prior to the place to search (ie. return will be > @n) |
199 | * @srcp: the cpumask pointer |
199 | * @srcp: the cpumask pointer |
200 | * |
200 | * |
201 | * Returns >= nr_cpu_ids if no further cpus unset. |
201 | * Returns >= nr_cpu_ids if no further cpus unset. |
202 | */ |
202 | */ |
203 | static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp) |
203 | static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp) |
204 | { |
204 | { |
205 | /* -1 is a legal arg here. */ |
205 | /* -1 is a legal arg here. */ |
206 | if (n != -1) |
206 | if (n != -1) |
207 | cpumask_check(n); |
207 | cpumask_check(n); |
208 | return find_next_zero_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1); |
208 | return find_next_zero_bit(cpumask_bits(srcp), nr_cpumask_bits, n+1); |
209 | } |
209 | } |
210 | 210 | ||
211 | int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *); |
211 | int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *); |
212 | int cpumask_any_but(const struct cpumask *mask, unsigned int cpu); |
212 | int cpumask_any_but(const struct cpumask *mask, unsigned int cpu); |
213 | unsigned int cpumask_local_spread(unsigned int i, int node); |
213 | unsigned int cpumask_local_spread(unsigned int i, int node); |
214 | 214 | ||
215 | /** |
215 | /** |
216 | * for_each_cpu - iterate over every cpu in a mask |
216 | * for_each_cpu - iterate over every cpu in a mask |
217 | * @cpu: the (optionally unsigned) integer iterator |
217 | * @cpu: the (optionally unsigned) integer iterator |
218 | * @mask: the cpumask pointer |
218 | * @mask: the cpumask pointer |
219 | * |
219 | * |
220 | * After the loop, cpu is >= nr_cpu_ids. |
220 | * After the loop, cpu is >= nr_cpu_ids. |
221 | */ |
221 | */ |
222 | #define for_each_cpu(cpu, mask) \ |
222 | #define for_each_cpu(cpu, mask) \ |
223 | for ((cpu) = -1; \ |
223 | for ((cpu) = -1; \ |
224 | (cpu) = cpumask_next((cpu), (mask)), \ |
224 | (cpu) = cpumask_next((cpu), (mask)), \ |
225 | (cpu) < nr_cpu_ids;) |
225 | (cpu) < nr_cpu_ids;) |
226 | 226 | ||
227 | /** |
227 | /** |
228 | * for_each_cpu_not - iterate over every cpu in a complemented mask |
228 | * for_each_cpu_not - iterate over every cpu in a complemented mask |
229 | * @cpu: the (optionally unsigned) integer iterator |
229 | * @cpu: the (optionally unsigned) integer iterator |
230 | * @mask: the cpumask pointer |
230 | * @mask: the cpumask pointer |
231 | * |
231 | * |
232 | * After the loop, cpu is >= nr_cpu_ids. |
232 | * After the loop, cpu is >= nr_cpu_ids. |
233 | */ |
233 | */ |
234 | #define for_each_cpu_not(cpu, mask) \ |
234 | #define for_each_cpu_not(cpu, mask) \ |
235 | for ((cpu) = -1; \ |
235 | for ((cpu) = -1; \ |
236 | (cpu) = cpumask_next_zero((cpu), (mask)), \ |
236 | (cpu) = cpumask_next_zero((cpu), (mask)), \ |
237 | (cpu) < nr_cpu_ids;) |
237 | (cpu) < nr_cpu_ids;) |
238 | 238 | ||
239 | /** |
239 | /** |
240 | * for_each_cpu_and - iterate over every cpu in both masks |
240 | * for_each_cpu_and - iterate over every cpu in both masks |
241 | * @cpu: the (optionally unsigned) integer iterator |
241 | * @cpu: the (optionally unsigned) integer iterator |
242 | * @mask: the first cpumask pointer |
242 | * @mask: the first cpumask pointer |
243 | * @and: the second cpumask pointer |
243 | * @and: the second cpumask pointer |
244 | * |
244 | * |
245 | * This saves a temporary CPU mask in many places. It is equivalent to: |
245 | * This saves a temporary CPU mask in many places. It is equivalent to: |
246 | * struct cpumask tmp; |
246 | * struct cpumask tmp; |
247 | * cpumask_and(&tmp, &mask, &and); |
247 | * cpumask_and(&tmp, &mask, &and); |
248 | * for_each_cpu(cpu, &tmp) |
248 | * for_each_cpu(cpu, &tmp) |
249 | * ... |
249 | * ... |
250 | * |
250 | * |
251 | * After the loop, cpu is >= nr_cpu_ids. |
251 | * After the loop, cpu is >= nr_cpu_ids. |
252 | */ |
252 | */ |
253 | #define for_each_cpu_and(cpu, mask, and) \ |
253 | #define for_each_cpu_and(cpu, mask, and) \ |
254 | for ((cpu) = -1; \ |
254 | for ((cpu) = -1; \ |
255 | (cpu) = cpumask_next_and((cpu), (mask), (and)), \ |
255 | (cpu) = cpumask_next_and((cpu), (mask), (and)), \ |
256 | (cpu) < nr_cpu_ids;) |
256 | (cpu) < nr_cpu_ids;) |
257 | #endif /* SMP */ |
257 | #endif /* SMP */ |
258 | 258 | ||
259 | #define CPU_BITS_NONE \ |
259 | #define CPU_BITS_NONE \ |
260 | { \ |
260 | { \ |
261 | [0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL \ |
261 | [0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL \ |
262 | } |
262 | } |
263 | 263 | ||
264 | #define CPU_BITS_CPU0 \ |
264 | #define CPU_BITS_CPU0 \ |
265 | { \ |
265 | { \ |
266 | [0] = 1UL \ |
266 | [0] = 1UL \ |
267 | } |
267 | } |
268 | 268 | ||
269 | /** |
269 | /** |
270 | * cpumask_set_cpu - set a cpu in a cpumask |
270 | * cpumask_set_cpu - set a cpu in a cpumask |
271 | * @cpu: cpu number (< nr_cpu_ids) |
271 | * @cpu: cpu number (< nr_cpu_ids) |
272 | * @dstp: the cpumask pointer |
272 | * @dstp: the cpumask pointer |
273 | */ |
273 | */ |
274 | static inline void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp) |
274 | static inline void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp) |
275 | { |
275 | { |
276 | set_bit(cpumask_check(cpu), cpumask_bits(dstp)); |
276 | set_bit(cpumask_check(cpu), cpumask_bits(dstp)); |
277 | } |
277 | } |
278 | 278 | ||
279 | /** |
279 | /** |
280 | * cpumask_clear_cpu - clear a cpu in a cpumask |
280 | * cpumask_clear_cpu - clear a cpu in a cpumask |
281 | * @cpu: cpu number (< nr_cpu_ids) |
281 | * @cpu: cpu number (< nr_cpu_ids) |
282 | * @dstp: the cpumask pointer |
282 | * @dstp: the cpumask pointer |
283 | */ |
283 | */ |
284 | static inline void cpumask_clear_cpu(int cpu, struct cpumask *dstp) |
284 | static inline void cpumask_clear_cpu(int cpu, struct cpumask *dstp) |
285 | { |
285 | { |
286 | clear_bit(cpumask_check(cpu), cpumask_bits(dstp)); |
286 | clear_bit(cpumask_check(cpu), cpumask_bits(dstp)); |
287 | } |
287 | } |
288 | 288 | ||
289 | /** |
289 | /** |
290 | * cpumask_test_cpu - test for a cpu in a cpumask |
290 | * cpumask_test_cpu - test for a cpu in a cpumask |
291 | * @cpu: cpu number (< nr_cpu_ids) |
291 | * @cpu: cpu number (< nr_cpu_ids) |
292 | * @cpumask: the cpumask pointer |
292 | * @cpumask: the cpumask pointer |
293 | * |
293 | * |
294 | * Returns 1 if @cpu is set in @cpumask, else returns 0 |
294 | * Returns 1 if @cpu is set in @cpumask, else returns 0 |
295 | */ |
295 | */ |
296 | static inline int cpumask_test_cpu(int cpu, const struct cpumask *cpumask) |
296 | static inline int cpumask_test_cpu(int cpu, const struct cpumask *cpumask) |
297 | { |
297 | { |
298 | return test_bit(cpumask_check(cpu), cpumask_bits((cpumask))); |
298 | return test_bit(cpumask_check(cpu), cpumask_bits((cpumask))); |
299 | } |
299 | } |
300 | 300 | ||
301 | /** |
301 | /** |
302 | * cpumask_test_and_set_cpu - atomically test and set a cpu in a cpumask |
302 | * cpumask_test_and_set_cpu - atomically test and set a cpu in a cpumask |
303 | * @cpu: cpu number (< nr_cpu_ids) |
303 | * @cpu: cpu number (< nr_cpu_ids) |
304 | * @cpumask: the cpumask pointer |
304 | * @cpumask: the cpumask pointer |
305 | * |
305 | * |
306 | * Returns 1 if @cpu is set in old bitmap of @cpumask, else returns 0 |
306 | * Returns 1 if @cpu is set in old bitmap of @cpumask, else returns 0 |
307 | * |
307 | * |
308 | * test_and_set_bit wrapper for cpumasks. |
308 | * test_and_set_bit wrapper for cpumasks. |
309 | */ |
309 | */ |
310 | static inline int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask) |
310 | static inline int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask) |
311 | { |
311 | { |
312 | return test_and_set_bit(cpumask_check(cpu), cpumask_bits(cpumask)); |
312 | return test_and_set_bit(cpumask_check(cpu), cpumask_bits(cpumask)); |
313 | } |
313 | } |
314 | 314 | ||
315 | /** |
315 | /** |
316 | * cpumask_test_and_clear_cpu - atomically test and clear a cpu in a cpumask |
316 | * cpumask_test_and_clear_cpu - atomically test and clear a cpu in a cpumask |
317 | * @cpu: cpu number (< nr_cpu_ids) |
317 | * @cpu: cpu number (< nr_cpu_ids) |
318 | * @cpumask: the cpumask pointer |
318 | * @cpumask: the cpumask pointer |
319 | * |
319 | * |
320 | * Returns 1 if @cpu is set in old bitmap of @cpumask, else returns 0 |
320 | * Returns 1 if @cpu is set in old bitmap of @cpumask, else returns 0 |
321 | * |
321 | * |
322 | * test_and_clear_bit wrapper for cpumasks. |
322 | * test_and_clear_bit wrapper for cpumasks. |
323 | */ |
323 | */ |
324 | static inline int cpumask_test_and_clear_cpu(int cpu, struct cpumask *cpumask) |
324 | static inline int cpumask_test_and_clear_cpu(int cpu, struct cpumask *cpumask) |
325 | { |
325 | { |
326 | return test_and_clear_bit(cpumask_check(cpu), cpumask_bits(cpumask)); |
326 | return test_and_clear_bit(cpumask_check(cpu), cpumask_bits(cpumask)); |
327 | } |
327 | } |
328 | 328 | ||
329 | /** |
329 | /** |
330 | * cpumask_setall - set all cpus (< nr_cpu_ids) in a cpumask |
330 | * cpumask_setall - set all cpus (< nr_cpu_ids) in a cpumask |
331 | * @dstp: the cpumask pointer |
331 | * @dstp: the cpumask pointer |
332 | */ |
332 | */ |
333 | static inline void cpumask_setall(struct cpumask *dstp) |
333 | static inline void cpumask_setall(struct cpumask *dstp) |
334 | { |
334 | { |
335 | bitmap_fill(cpumask_bits(dstp), nr_cpumask_bits); |
335 | bitmap_fill(cpumask_bits(dstp), nr_cpumask_bits); |
336 | } |
336 | } |
337 | 337 | ||
338 | /** |
338 | /** |
339 | * cpumask_clear - clear all cpus (< nr_cpu_ids) in a cpumask |
339 | * cpumask_clear - clear all cpus (< nr_cpu_ids) in a cpumask |
340 | * @dstp: the cpumask pointer |
340 | * @dstp: the cpumask pointer |
341 | */ |
341 | */ |
342 | static inline void cpumask_clear(struct cpumask *dstp) |
342 | static inline void cpumask_clear(struct cpumask *dstp) |
343 | { |
343 | { |
344 | bitmap_zero(cpumask_bits(dstp), nr_cpumask_bits); |
344 | bitmap_zero(cpumask_bits(dstp), nr_cpumask_bits); |
345 | } |
345 | } |
346 | 346 | ||
347 | /** |
347 | /** |
348 | * cpumask_and - *dstp = *src1p & *src2p |
348 | * cpumask_and - *dstp = *src1p & *src2p |
349 | * @dstp: the cpumask result |
349 | * @dstp: the cpumask result |
350 | * @src1p: the first input |
350 | * @src1p: the first input |
351 | * @src2p: the second input |
351 | * @src2p: the second input |
352 | * |
352 | * |
353 | * If *@dstp is empty, returns 0, else returns 1 |
353 | * If *@dstp is empty, returns 0, else returns 1 |
354 | */ |
354 | */ |
355 | static inline int cpumask_and(struct cpumask *dstp, |
355 | static inline int cpumask_and(struct cpumask *dstp, |
356 | const struct cpumask *src1p, |
356 | const struct cpumask *src1p, |
357 | const struct cpumask *src2p) |
357 | const struct cpumask *src2p) |
358 | { |
358 | { |
359 | return bitmap_and(cpumask_bits(dstp), cpumask_bits(src1p), |
359 | return bitmap_and(cpumask_bits(dstp), cpumask_bits(src1p), |
360 | cpumask_bits(src2p), nr_cpumask_bits); |
360 | cpumask_bits(src2p), nr_cpumask_bits); |
361 | } |
361 | } |
362 | 362 | ||
363 | /** |
363 | /** |
364 | * cpumask_or - *dstp = *src1p | *src2p |
364 | * cpumask_or - *dstp = *src1p | *src2p |
365 | * @dstp: the cpumask result |
365 | * @dstp: the cpumask result |
366 | * @src1p: the first input |
366 | * @src1p: the first input |
367 | * @src2p: the second input |
367 | * @src2p: the second input |
368 | */ |
368 | */ |
369 | static inline void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p, |
369 | static inline void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p, |
370 | const struct cpumask *src2p) |
370 | const struct cpumask *src2p) |
371 | { |
371 | { |
372 | bitmap_or(cpumask_bits(dstp), cpumask_bits(src1p), |
372 | bitmap_or(cpumask_bits(dstp), cpumask_bits(src1p), |
373 | cpumask_bits(src2p), nr_cpumask_bits); |
373 | cpumask_bits(src2p), nr_cpumask_bits); |
374 | } |
374 | } |
375 | 375 | ||
376 | /** |
376 | /** |
377 | * cpumask_xor - *dstp = *src1p ^ *src2p |
377 | * cpumask_xor - *dstp = *src1p ^ *src2p |
378 | * @dstp: the cpumask result |
378 | * @dstp: the cpumask result |
379 | * @src1p: the first input |
379 | * @src1p: the first input |
380 | * @src2p: the second input |
380 | * @src2p: the second input |
381 | */ |
381 | */ |
382 | static inline void cpumask_xor(struct cpumask *dstp, |
382 | static inline void cpumask_xor(struct cpumask *dstp, |
383 | const struct cpumask *src1p, |
383 | const struct cpumask *src1p, |
384 | const struct cpumask *src2p) |
384 | const struct cpumask *src2p) |
385 | { |
385 | { |
386 | bitmap_xor(cpumask_bits(dstp), cpumask_bits(src1p), |
386 | bitmap_xor(cpumask_bits(dstp), cpumask_bits(src1p), |
387 | cpumask_bits(src2p), nr_cpumask_bits); |
387 | cpumask_bits(src2p), nr_cpumask_bits); |
388 | } |
388 | } |
389 | 389 | ||
390 | /** |
390 | /** |
391 | * cpumask_andnot - *dstp = *src1p & ~*src2p |
391 | * cpumask_andnot - *dstp = *src1p & ~*src2p |
392 | * @dstp: the cpumask result |
392 | * @dstp: the cpumask result |
393 | * @src1p: the first input |
393 | * @src1p: the first input |
394 | * @src2p: the second input |
394 | * @src2p: the second input |
395 | * |
395 | * |
396 | * If *@dstp is empty, returns 0, else returns 1 |
396 | * If *@dstp is empty, returns 0, else returns 1 |
397 | */ |
397 | */ |
398 | static inline int cpumask_andnot(struct cpumask *dstp, |
398 | static inline int cpumask_andnot(struct cpumask *dstp, |
399 | const struct cpumask *src1p, |
399 | const struct cpumask *src1p, |
400 | const struct cpumask *src2p) |
400 | const struct cpumask *src2p) |
401 | { |
401 | { |
402 | return bitmap_andnot(cpumask_bits(dstp), cpumask_bits(src1p), |
402 | return bitmap_andnot(cpumask_bits(dstp), cpumask_bits(src1p), |
403 | cpumask_bits(src2p), nr_cpumask_bits); |
403 | cpumask_bits(src2p), nr_cpumask_bits); |
404 | } |
404 | } |
405 | 405 | ||
406 | /** |
406 | /** |
407 | * cpumask_complement - *dstp = ~*srcp |
407 | * cpumask_complement - *dstp = ~*srcp |
408 | * @dstp: the cpumask result |
408 | * @dstp: the cpumask result |
409 | * @srcp: the input to invert |
409 | * @srcp: the input to invert |
410 | */ |
410 | */ |
411 | static inline void cpumask_complement(struct cpumask *dstp, |
411 | static inline void cpumask_complement(struct cpumask *dstp, |
412 | const struct cpumask *srcp) |
412 | const struct cpumask *srcp) |
413 | { |
413 | { |
414 | bitmap_complement(cpumask_bits(dstp), cpumask_bits(srcp), |
414 | bitmap_complement(cpumask_bits(dstp), cpumask_bits(srcp), |
415 | nr_cpumask_bits); |
415 | nr_cpumask_bits); |
416 | } |
416 | } |
417 | 417 | ||
418 | /** |
418 | /** |
419 | * cpumask_equal - *src1p == *src2p |
419 | * cpumask_equal - *src1p == *src2p |
420 | * @src1p: the first input |
420 | * @src1p: the first input |
421 | * @src2p: the second input |
421 | * @src2p: the second input |
422 | */ |
422 | */ |
423 | static inline bool cpumask_equal(const struct cpumask *src1p, |
423 | static inline bool cpumask_equal(const struct cpumask *src1p, |
424 | const struct cpumask *src2p) |
424 | const struct cpumask *src2p) |
425 | { |
425 | { |
426 | return bitmap_equal(cpumask_bits(src1p), cpumask_bits(src2p), |
426 | return bitmap_equal(cpumask_bits(src1p), cpumask_bits(src2p), |
427 | nr_cpumask_bits); |
427 | nr_cpumask_bits); |
428 | } |
428 | } |
429 | 429 | ||
430 | /** |
430 | /** |
431 | * cpumask_intersects - (*src1p & *src2p) != 0 |
431 | * cpumask_intersects - (*src1p & *src2p) != 0 |
432 | * @src1p: the first input |
432 | * @src1p: the first input |
433 | * @src2p: the second input |
433 | * @src2p: the second input |
434 | */ |
434 | */ |
435 | static inline bool cpumask_intersects(const struct cpumask *src1p, |
435 | static inline bool cpumask_intersects(const struct cpumask *src1p, |
436 | const struct cpumask *src2p) |
436 | const struct cpumask *src2p) |
437 | { |
437 | { |
438 | return bitmap_intersects(cpumask_bits(src1p), cpumask_bits(src2p), |
438 | return bitmap_intersects(cpumask_bits(src1p), cpumask_bits(src2p), |
439 | nr_cpumask_bits); |
439 | nr_cpumask_bits); |
440 | } |
440 | } |
441 | 441 | ||
442 | /** |
442 | /** |
443 | * cpumask_subset - (*src1p & ~*src2p) == 0 |
443 | * cpumask_subset - (*src1p & ~*src2p) == 0 |
444 | * @src1p: the first input |
444 | * @src1p: the first input |
445 | * @src2p: the second input |
445 | * @src2p: the second input |
446 | * |
446 | * |
447 | * Returns 1 if *@src1p is a subset of *@src2p, else returns 0 |
447 | * Returns 1 if *@src1p is a subset of *@src2p, else returns 0 |
448 | */ |
448 | */ |
449 | static inline int cpumask_subset(const struct cpumask *src1p, |
449 | static inline int cpumask_subset(const struct cpumask *src1p, |
450 | const struct cpumask *src2p) |
450 | const struct cpumask *src2p) |
451 | { |
451 | { |
452 | return bitmap_subset(cpumask_bits(src1p), cpumask_bits(src2p), |
452 | return bitmap_subset(cpumask_bits(src1p), cpumask_bits(src2p), |
453 | nr_cpumask_bits); |
453 | nr_cpumask_bits); |
454 | } |
454 | } |
455 | 455 | ||
456 | /** |
456 | /** |
457 | * cpumask_empty - *srcp == 0 |
457 | * cpumask_empty - *srcp == 0 |
458 | * @srcp: the cpumask to that all cpus < nr_cpu_ids are clear. |
458 | * @srcp: the cpumask to that all cpus < nr_cpu_ids are clear. |
459 | */ |
459 | */ |
460 | static inline bool cpumask_empty(const struct cpumask *srcp) |
460 | static inline bool cpumask_empty(const struct cpumask *srcp) |
461 | { |
461 | { |
462 | return bitmap_empty(cpumask_bits(srcp), nr_cpumask_bits); |
462 | return bitmap_empty(cpumask_bits(srcp), nr_cpumask_bits); |
463 | } |
463 | } |
464 | 464 | ||
465 | /** |
465 | /** |
466 | * cpumask_full - *srcp == 0xFFFFFFFF... |
466 | * cpumask_full - *srcp == 0xFFFFFFFF... |
467 | * @srcp: the cpumask to that all cpus < nr_cpu_ids are set. |
467 | * @srcp: the cpumask to that all cpus < nr_cpu_ids are set. |
468 | */ |
468 | */ |
469 | static inline bool cpumask_full(const struct cpumask *srcp) |
469 | static inline bool cpumask_full(const struct cpumask *srcp) |
470 | { |
470 | { |
471 | return bitmap_full(cpumask_bits(srcp), nr_cpumask_bits); |
471 | return bitmap_full(cpumask_bits(srcp), nr_cpumask_bits); |
472 | } |
472 | } |
473 | 473 | ||
474 | /** |
474 | /** |
475 | * cpumask_weight - Count of bits in *srcp |
475 | * cpumask_weight - Count of bits in *srcp |
476 | * @srcp: the cpumask to count bits (< nr_cpu_ids) in. |
476 | * @srcp: the cpumask to count bits (< nr_cpu_ids) in. |
477 | */ |
477 | */ |
478 | static inline unsigned int cpumask_weight(const struct cpumask *srcp) |
478 | static inline unsigned int cpumask_weight(const struct cpumask *srcp) |
479 | { |
479 | { |
480 | return bitmap_weight(cpumask_bits(srcp), nr_cpumask_bits); |
480 | return bitmap_weight(cpumask_bits(srcp), nr_cpumask_bits); |
481 | } |
481 | } |
482 | 482 | ||
483 | /** |
483 | /** |
484 | * cpumask_shift_right - *dstp = *srcp >> n |
484 | * cpumask_shift_right - *dstp = *srcp >> n |
485 | * @dstp: the cpumask result |
485 | * @dstp: the cpumask result |
486 | * @srcp: the input to shift |
486 | * @srcp: the input to shift |
487 | * @n: the number of bits to shift by |
487 | * @n: the number of bits to shift by |
488 | */ |
488 | */ |
489 | static inline void cpumask_shift_right(struct cpumask *dstp, |
489 | static inline void cpumask_shift_right(struct cpumask *dstp, |
490 | const struct cpumask *srcp, int n) |
490 | const struct cpumask *srcp, int n) |
491 | { |
491 | { |
492 | bitmap_shift_right(cpumask_bits(dstp), cpumask_bits(srcp), n, |
492 | bitmap_shift_right(cpumask_bits(dstp), cpumask_bits(srcp), n, |
493 | nr_cpumask_bits); |
493 | nr_cpumask_bits); |
494 | } |
494 | } |
495 | 495 | ||
496 | /** |
496 | /** |
497 | * cpumask_shift_left - *dstp = *srcp << n |
497 | * cpumask_shift_left - *dstp = *srcp << n |
498 | * @dstp: the cpumask result |
498 | * @dstp: the cpumask result |
499 | * @srcp: the input to shift |
499 | * @srcp: the input to shift |
500 | * @n: the number of bits to shift by |
500 | * @n: the number of bits to shift by |
501 | */ |
501 | */ |
502 | static inline void cpumask_shift_left(struct cpumask *dstp, |
502 | static inline void cpumask_shift_left(struct cpumask *dstp, |
503 | const struct cpumask *srcp, int n) |
503 | const struct cpumask *srcp, int n) |
504 | { |
504 | { |
505 | bitmap_shift_left(cpumask_bits(dstp), cpumask_bits(srcp), n, |
505 | bitmap_shift_left(cpumask_bits(dstp), cpumask_bits(srcp), n, |
506 | nr_cpumask_bits); |
506 | nr_cpumask_bits); |
507 | } |
507 | } |
508 | 508 | ||
509 | /** |
509 | /** |
510 | * cpumask_copy - *dstp = *srcp |
510 | * cpumask_copy - *dstp = *srcp |
511 | * @dstp: the result |
511 | * @dstp: the result |
512 | * @srcp: the input cpumask |
512 | * @srcp: the input cpumask |
513 | */ |
513 | */ |
514 | static inline void cpumask_copy(struct cpumask *dstp, |
514 | static inline void cpumask_copy(struct cpumask *dstp, |
515 | const struct cpumask *srcp) |
515 | const struct cpumask *srcp) |
516 | { |
516 | { |
517 | bitmap_copy(cpumask_bits(dstp), cpumask_bits(srcp), nr_cpumask_bits); |
517 | bitmap_copy(cpumask_bits(dstp), cpumask_bits(srcp), nr_cpumask_bits); |
518 | } |
518 | } |
519 | 519 | ||
520 | /** |
520 | /** |
521 | * cpumask_any - pick a "random" cpu from *srcp |
521 | * cpumask_any - pick a "random" cpu from *srcp |
522 | * @srcp: the input cpumask |
522 | * @srcp: the input cpumask |
523 | * |
523 | * |
524 | * Returns >= nr_cpu_ids if no cpus set. |
524 | * Returns >= nr_cpu_ids if no cpus set. |
525 | */ |
525 | */ |
526 | #define cpumask_any(srcp) cpumask_first(srcp) |
526 | #define cpumask_any(srcp) cpumask_first(srcp) |
527 | 527 | ||
528 | /** |
528 | /** |
529 | * cpumask_first_and - return the first cpu from *srcp1 & *srcp2 |
529 | * cpumask_first_and - return the first cpu from *srcp1 & *srcp2 |
530 | * @src1p: the first input |
530 | * @src1p: the first input |
531 | * @src2p: the second input |
531 | * @src2p: the second input |
532 | * |
532 | * |
533 | * Returns >= nr_cpu_ids if no cpus set in both. See also cpumask_next_and(). |
533 | * Returns >= nr_cpu_ids if no cpus set in both. See also cpumask_next_and(). |
534 | */ |
534 | */ |
535 | #define cpumask_first_and(src1p, src2p) cpumask_next_and(-1, (src1p), (src2p)) |
535 | #define cpumask_first_and(src1p, src2p) cpumask_next_and(-1, (src1p), (src2p)) |
536 | 536 | ||
537 | /** |
537 | /** |
538 | * cpumask_any_and - pick a "random" cpu from *mask1 & *mask2 |
538 | * cpumask_any_and - pick a "random" cpu from *mask1 & *mask2 |
539 | * @mask1: the first input cpumask |
539 | * @mask1: the first input cpumask |
540 | * @mask2: the second input cpumask |
540 | * @mask2: the second input cpumask |
541 | * |
541 | * |
542 | * Returns >= nr_cpu_ids if no cpus set. |
542 | * Returns >= nr_cpu_ids if no cpus set. |
543 | */ |
543 | */ |
544 | #define cpumask_any_and(mask1, mask2) cpumask_first_and((mask1), (mask2)) |
544 | #define cpumask_any_and(mask1, mask2) cpumask_first_and((mask1), (mask2)) |
545 | 545 | ||
546 | /** |
546 | /** |
547 | * cpumask_of - the cpumask containing just a given cpu |
547 | * cpumask_of - the cpumask containing just a given cpu |
548 | * @cpu: the cpu (<= nr_cpu_ids) |
548 | * @cpu: the cpu (<= nr_cpu_ids) |
549 | */ |
549 | */ |
550 | #define cpumask_of(cpu) (get_cpu_mask(cpu)) |
550 | #define cpumask_of(cpu) (get_cpu_mask(cpu)) |
551 | 551 | ||
552 | /** |
552 | /** |
553 | * cpumask_parse_user - extract a cpumask from a user string |
553 | * cpumask_parse_user - extract a cpumask from a user string |
554 | * @buf: the buffer to extract from |
554 | * @buf: the buffer to extract from |
555 | * @len: the length of the buffer |
555 | * @len: the length of the buffer |
556 | * @dstp: the cpumask to set. |
556 | * @dstp: the cpumask to set. |
557 | * |
557 | * |
558 | * Returns -errno, or 0 for success. |
558 | * Returns -errno, or 0 for success. |
559 | */ |
559 | */ |
560 | static inline int cpumask_parse_user(const char __user *buf, int len, |
560 | static inline int cpumask_parse_user(const char __user *buf, int len, |
561 | struct cpumask *dstp) |
561 | struct cpumask *dstp) |
562 | { |
562 | { |
563 | return bitmap_parse_user(buf, len, cpumask_bits(dstp), nr_cpu_ids); |
563 | return bitmap_parse_user(buf, len, cpumask_bits(dstp), nr_cpu_ids); |
564 | } |
564 | } |
565 | 565 | ||
566 | /** |
566 | /** |
567 | * cpumask_parselist_user - extract a cpumask from a user string |
567 | * cpumask_parselist_user - extract a cpumask from a user string |
568 | * @buf: the buffer to extract from |
568 | * @buf: the buffer to extract from |
569 | * @len: the length of the buffer |
569 | * @len: the length of the buffer |
570 | * @dstp: the cpumask to set. |
570 | * @dstp: the cpumask to set. |
571 | * |
571 | * |
572 | * Returns -errno, or 0 for success. |
572 | * Returns -errno, or 0 for success. |
573 | */ |
573 | */ |
574 | static inline int cpumask_parselist_user(const char __user *buf, int len, |
574 | static inline int cpumask_parselist_user(const char __user *buf, int len, |
575 | struct cpumask *dstp) |
575 | struct cpumask *dstp) |
576 | { |
576 | { |
577 | return bitmap_parselist_user(buf, len, cpumask_bits(dstp), |
577 | return bitmap_parselist_user(buf, len, cpumask_bits(dstp), |
578 | nr_cpu_ids); |
578 | nr_cpu_ids); |
579 | } |
579 | } |
580 | 580 | ||
581 | /** |
581 | /** |
582 | * cpumask_parse - extract a cpumask from from a string |
582 | * cpumask_parse - extract a cpumask from from a string |
583 | * @buf: the buffer to extract from |
583 | * @buf: the buffer to extract from |
584 | * @dstp: the cpumask to set. |
584 | * @dstp: the cpumask to set. |
585 | * |
585 | * |
586 | * Returns -errno, or 0 for success. |
586 | * Returns -errno, or 0 for success. |
587 | */ |
587 | */ |
588 | static inline int cpumask_parse(const char *buf, struct cpumask *dstp) |
588 | static inline int cpumask_parse(const char *buf, struct cpumask *dstp) |
589 | { |
589 | { |
590 | char *nl = strchr(buf, '\n'); |
590 | char *nl = strchr(buf, '\n'); |
591 | unsigned int len = nl ? (unsigned int)(nl - buf) : strlen(buf); |
591 | unsigned int len = nl ? (unsigned int)(nl - buf) : strlen(buf); |
592 | 592 | ||
593 | return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpu_ids); |
593 | return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpu_ids); |
594 | } |
594 | } |
595 | 595 | ||
596 | /** |
596 | /** |
597 | * cpulist_parse - extract a cpumask from a user string of ranges |
597 | * cpulist_parse - extract a cpumask from a user string of ranges |
598 | * @buf: the buffer to extract from |
598 | * @buf: the buffer to extract from |
599 | * @dstp: the cpumask to set. |
599 | * @dstp: the cpumask to set. |
600 | * |
600 | * |
601 | * Returns -errno, or 0 for success. |
601 | * Returns -errno, or 0 for success. |
602 | */ |
602 | */ |
603 | static inline int cpulist_parse(const char *buf, struct cpumask *dstp) |
603 | static inline int cpulist_parse(const char *buf, struct cpumask *dstp) |
604 | { |
604 | { |
605 | return bitmap_parselist(buf, cpumask_bits(dstp), nr_cpu_ids); |
605 | return bitmap_parselist(buf, cpumask_bits(dstp), nr_cpu_ids); |
606 | } |
606 | } |
607 | 607 | ||
608 | /** |
608 | /** |
609 | * cpumask_size - size to allocate for a 'struct cpumask' in bytes |
609 | * cpumask_size - size to allocate for a 'struct cpumask' in bytes |
610 | * |
- | |
611 | * This will eventually be a runtime variable, depending on nr_cpu_ids. |
- | |
612 | */ |
610 | */ |
613 | static inline size_t cpumask_size(void) |
611 | static inline size_t cpumask_size(void) |
614 | { |
612 | { |
615 | return BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long); |
613 | return BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long); |
616 | } |
614 | } |
617 | 615 | ||
618 | /* |
616 | /* |
619 | * cpumask_var_t: struct cpumask for stack usage. |
617 | * cpumask_var_t: struct cpumask for stack usage. |
620 | * |
618 | * |
621 | * Oh, the wicked games we play! In order to make kernel coding a |
619 | * Oh, the wicked games we play! In order to make kernel coding a |
622 | * little more difficult, we typedef cpumask_var_t to an array or a |
620 | * little more difficult, we typedef cpumask_var_t to an array or a |
623 | * pointer: doing &mask on an array is a noop, so it still works. |
621 | * pointer: doing &mask on an array is a noop, so it still works. |
624 | * |
622 | * |
625 | * ie. |
623 | * ie. |
626 | * cpumask_var_t tmpmask; |
624 | * cpumask_var_t tmpmask; |
627 | * if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL)) |
625 | * if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL)) |
628 | * return -ENOMEM; |
626 | * return -ENOMEM; |
629 | * |
627 | * |
630 | * ... use 'tmpmask' like a normal struct cpumask * ... |
628 | * ... use 'tmpmask' like a normal struct cpumask * ... |
631 | * |
629 | * |
632 | * free_cpumask_var(tmpmask); |
630 | * free_cpumask_var(tmpmask); |
633 | * |
631 | * |
634 | * |
632 | * |
635 | * However, one notable exception is there. alloc_cpumask_var() allocates |
633 | * However, one notable exception is there. alloc_cpumask_var() allocates |
636 | * only nr_cpumask_bits bits (in the other hand, real cpumask_t always has |
634 | * only nr_cpumask_bits bits (in the other hand, real cpumask_t always has |
637 | * NR_CPUS bits). Therefore you don't have to dereference cpumask_var_t. |
635 | * NR_CPUS bits). Therefore you don't have to dereference cpumask_var_t. |
638 | * |
636 | * |
639 | * cpumask_var_t tmpmask; |
637 | * cpumask_var_t tmpmask; |
640 | * if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL)) |
638 | * if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL)) |
641 | * return -ENOMEM; |
639 | * return -ENOMEM; |
642 | * |
640 | * |
643 | * var = *tmpmask; |
641 | * var = *tmpmask; |
644 | * |
642 | * |
645 | * This code makes NR_CPUS length memcopy and brings to a memory corruption. |
643 | * This code makes NR_CPUS length memcopy and brings to a memory corruption. |
646 | * cpumask_copy() provide safe copy functionality. |
644 | * cpumask_copy() provide safe copy functionality. |
647 | * |
645 | * |
648 | * Note that there is another evil here: If you define a cpumask_var_t |
646 | * Note that there is another evil here: If you define a cpumask_var_t |
649 | * as a percpu variable then the way to obtain the address of the cpumask |
647 | * as a percpu variable then the way to obtain the address of the cpumask |
650 | * structure differently influences what this_cpu_* operation needs to be |
648 | * structure differently influences what this_cpu_* operation needs to be |
651 | * used. Please use this_cpu_cpumask_var_t in those cases. The direct use |
649 | * used. Please use this_cpu_cpumask_var_t in those cases. The direct use |
652 | * of this_cpu_ptr() or this_cpu_read() will lead to failures when the |
650 | * of this_cpu_ptr() or this_cpu_read() will lead to failures when the |
653 | * other type of cpumask_var_t implementation is configured. |
651 | * other type of cpumask_var_t implementation is configured. |
654 | */ |
652 | */ |
655 | #ifdef CONFIG_CPUMASK_OFFSTACK |
653 | #ifdef CONFIG_CPUMASK_OFFSTACK |
656 | typedef struct cpumask *cpumask_var_t; |
654 | typedef struct cpumask *cpumask_var_t; |
657 | 655 | ||
658 | #define this_cpu_cpumask_var_ptr(x) this_cpu_read(x) |
656 | #define this_cpu_cpumask_var_ptr(x) this_cpu_read(x) |
659 | 657 | ||
660 | bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node); |
658 | bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node); |
661 | bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags); |
659 | bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags); |
662 | bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node); |
660 | bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node); |
663 | bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags); |
661 | bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags); |
664 | void alloc_bootmem_cpumask_var(cpumask_var_t *mask); |
662 | void alloc_bootmem_cpumask_var(cpumask_var_t *mask); |
665 | void free_cpumask_var(cpumask_var_t mask); |
663 | void free_cpumask_var(cpumask_var_t mask); |
666 | void free_bootmem_cpumask_var(cpumask_var_t mask); |
664 | void free_bootmem_cpumask_var(cpumask_var_t mask); |
667 | 665 | ||
668 | #else |
666 | #else |
669 | typedef struct cpumask cpumask_var_t[1]; |
667 | typedef struct cpumask cpumask_var_t[1]; |
670 | 668 | ||
671 | #define this_cpu_cpumask_var_ptr(x) this_cpu_ptr(x) |
669 | #define this_cpu_cpumask_var_ptr(x) this_cpu_ptr(x) |
672 | 670 | ||
673 | static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags) |
671 | static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags) |
674 | { |
672 | { |
675 | return true; |
673 | return true; |
676 | } |
674 | } |
677 | 675 | ||
678 | static inline bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, |
676 | static inline bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, |
679 | int node) |
677 | int node) |
680 | { |
678 | { |
681 | return true; |
679 | return true; |
682 | } |
680 | } |
683 | 681 | ||
684 | static inline bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags) |
682 | static inline bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags) |
685 | { |
683 | { |
686 | cpumask_clear(*mask); |
684 | cpumask_clear(*mask); |
687 | return true; |
685 | return true; |
688 | } |
686 | } |
689 | 687 | ||
690 | static inline bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, |
688 | static inline bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, |
691 | int node) |
689 | int node) |
692 | { |
690 | { |
693 | cpumask_clear(*mask); |
691 | cpumask_clear(*mask); |
694 | return true; |
692 | return true; |
695 | } |
693 | } |
696 | 694 | ||
697 | static inline void alloc_bootmem_cpumask_var(cpumask_var_t *mask) |
695 | static inline void alloc_bootmem_cpumask_var(cpumask_var_t *mask) |
698 | { |
696 | { |
699 | } |
697 | } |
700 | 698 | ||
701 | static inline void free_cpumask_var(cpumask_var_t mask) |
699 | static inline void free_cpumask_var(cpumask_var_t mask) |
702 | { |
700 | { |
703 | } |
701 | } |
704 | 702 | ||
705 | static inline void free_bootmem_cpumask_var(cpumask_var_t mask) |
703 | static inline void free_bootmem_cpumask_var(cpumask_var_t mask) |
706 | { |
704 | { |
707 | } |
705 | } |
708 | #endif /* CONFIG_CPUMASK_OFFSTACK */ |
706 | #endif /* CONFIG_CPUMASK_OFFSTACK */ |
709 | 707 | ||
710 | /* It's common to want to use cpu_all_mask in struct member initializers, |
708 | /* It's common to want to use cpu_all_mask in struct member initializers, |
711 | * so it has to refer to an address rather than a pointer. */ |
709 | * so it has to refer to an address rather than a pointer. */ |
712 | extern const DECLARE_BITMAP(cpu_all_bits, NR_CPUS); |
710 | extern const DECLARE_BITMAP(cpu_all_bits, NR_CPUS); |
713 | #define cpu_all_mask to_cpumask(cpu_all_bits) |
711 | #define cpu_all_mask to_cpumask(cpu_all_bits) |
714 | 712 | ||
715 | /* First bits of cpu_bit_bitmap are in fact unset. */ |
713 | /* First bits of cpu_bit_bitmap are in fact unset. */ |
716 | #define cpu_none_mask to_cpumask(cpu_bit_bitmap[0]) |
714 | #define cpu_none_mask to_cpumask(cpu_bit_bitmap[0]) |
717 | 715 | ||
718 | #define for_each_possible_cpu(cpu) for_each_cpu((cpu), cpu_possible_mask) |
716 | #define for_each_possible_cpu(cpu) for_each_cpu((cpu), cpu_possible_mask) |
719 | #define for_each_online_cpu(cpu) for_each_cpu((cpu), cpu_online_mask) |
717 | #define for_each_online_cpu(cpu) for_each_cpu((cpu), cpu_online_mask) |
720 | #define for_each_present_cpu(cpu) for_each_cpu((cpu), cpu_present_mask) |
718 | #define for_each_present_cpu(cpu) for_each_cpu((cpu), cpu_present_mask) |
721 | 719 | ||
722 | /* Wrappers for arch boot code to manipulate normally-constant masks */ |
720 | /* Wrappers for arch boot code to manipulate normally-constant masks */ |
723 | void init_cpu_present(const struct cpumask *src); |
721 | void init_cpu_present(const struct cpumask *src); |
724 | void init_cpu_possible(const struct cpumask *src); |
722 | void init_cpu_possible(const struct cpumask *src); |
725 | void init_cpu_online(const struct cpumask *src); |
723 | void init_cpu_online(const struct cpumask *src); |
726 | 724 | ||
727 | static inline void |
725 | static inline void |
728 | set_cpu_possible(unsigned int cpu, bool possible) |
726 | set_cpu_possible(unsigned int cpu, bool possible) |
729 | { |
727 | { |
730 | if (possible) |
728 | if (possible) |
731 | cpumask_set_cpu(cpu, &__cpu_possible_mask); |
729 | cpumask_set_cpu(cpu, &__cpu_possible_mask); |
732 | else |
730 | else |
733 | cpumask_clear_cpu(cpu, &__cpu_possible_mask); |
731 | cpumask_clear_cpu(cpu, &__cpu_possible_mask); |
734 | } |
732 | } |
735 | 733 | ||
736 | static inline void |
734 | static inline void |
737 | set_cpu_present(unsigned int cpu, bool present) |
735 | set_cpu_present(unsigned int cpu, bool present) |
738 | { |
736 | { |
739 | if (present) |
737 | if (present) |
740 | cpumask_set_cpu(cpu, &__cpu_present_mask); |
738 | cpumask_set_cpu(cpu, &__cpu_present_mask); |
741 | else |
739 | else |
742 | cpumask_clear_cpu(cpu, &__cpu_present_mask); |
740 | cpumask_clear_cpu(cpu, &__cpu_present_mask); |
743 | } |
741 | } |
744 | 742 | ||
745 | static inline void |
743 | static inline void |
746 | set_cpu_online(unsigned int cpu, bool online) |
744 | set_cpu_online(unsigned int cpu, bool online) |
747 | { |
745 | { |
748 | if (online) { |
746 | if (online) { |
749 | cpumask_set_cpu(cpu, &__cpu_online_mask); |
747 | cpumask_set_cpu(cpu, &__cpu_online_mask); |
750 | cpumask_set_cpu(cpu, &__cpu_active_mask); |
748 | cpumask_set_cpu(cpu, &__cpu_active_mask); |
751 | } else { |
749 | } else { |
752 | cpumask_clear_cpu(cpu, &__cpu_online_mask); |
750 | cpumask_clear_cpu(cpu, &__cpu_online_mask); |
753 | } |
751 | } |
754 | } |
752 | } |
755 | 753 | ||
756 | static inline void |
754 | static inline void |
757 | set_cpu_active(unsigned int cpu, bool active) |
755 | set_cpu_active(unsigned int cpu, bool active) |
758 | { |
756 | { |
759 | if (active) |
757 | if (active) |
760 | cpumask_set_cpu(cpu, &__cpu_active_mask); |
758 | cpumask_set_cpu(cpu, &__cpu_active_mask); |
761 | else |
759 | else |
762 | cpumask_clear_cpu(cpu, &__cpu_active_mask); |
760 | cpumask_clear_cpu(cpu, &__cpu_active_mask); |
763 | } |
761 | } |
764 | 762 | ||
765 | 763 | ||
766 | /** |
764 | /** |
767 | * to_cpumask - convert an NR_CPUS bitmap to a struct cpumask * |
765 | * to_cpumask - convert an NR_CPUS bitmap to a struct cpumask * |
768 | * @bitmap: the bitmap |
766 | * @bitmap: the bitmap |
769 | * |
767 | * |
770 | * There are a few places where cpumask_var_t isn't appropriate and |
768 | * There are a few places where cpumask_var_t isn't appropriate and |
771 | * static cpumasks must be used (eg. very early boot), yet we don't |
769 | * static cpumasks must be used (eg. very early boot), yet we don't |
772 | * expose the definition of 'struct cpumask'. |
770 | * expose the definition of 'struct cpumask'. |
773 | * |
771 | * |
774 | * This does the conversion, and can be used as a constant initializer. |
772 | * This does the conversion, and can be used as a constant initializer. |
775 | */ |
773 | */ |
776 | #define to_cpumask(bitmap) \ |
774 | #define to_cpumask(bitmap) \ |
777 | ((struct cpumask *)(1 ? (bitmap) \ |
775 | ((struct cpumask *)(1 ? (bitmap) \ |
778 | : (void *)sizeof(__check_is_bitmap(bitmap)))) |
776 | : (void *)sizeof(__check_is_bitmap(bitmap)))) |
779 | 777 | ||
780 | static inline int __check_is_bitmap(const unsigned long *bitmap) |
778 | static inline int __check_is_bitmap(const unsigned long *bitmap) |
781 | { |
779 | { |
782 | return 1; |
780 | return 1; |
783 | } |
781 | } |
784 | 782 | ||
785 | /* |
783 | /* |
786 | * Special-case data structure for "single bit set only" constant CPU masks. |
784 | * Special-case data structure for "single bit set only" constant CPU masks. |
787 | * |
785 | * |
788 | * We pre-generate all the 64 (or 32) possible bit positions, with enough |
786 | * We pre-generate all the 64 (or 32) possible bit positions, with enough |
789 | * padding to the left and the right, and return the constant pointer |
787 | * padding to the left and the right, and return the constant pointer |
790 | * appropriately offset. |
788 | * appropriately offset. |
791 | */ |
789 | */ |
792 | extern const unsigned long |
790 | extern const unsigned long |
793 | cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)]; |
791 | cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)]; |
794 | 792 | ||
795 | static inline const struct cpumask *get_cpu_mask(unsigned int cpu) |
793 | static inline const struct cpumask *get_cpu_mask(unsigned int cpu) |
796 | { |
794 | { |
797 | const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG]; |
795 | const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG]; |
798 | p -= cpu / BITS_PER_LONG; |
796 | p -= cpu / BITS_PER_LONG; |
799 | return to_cpumask(p); |
797 | return to_cpumask(p); |
800 | } |
798 | } |
801 | 799 | ||
802 | #define cpu_is_offline(cpu) unlikely(!cpu_online(cpu)) |
800 | #define cpu_is_offline(cpu) unlikely(!cpu_online(cpu)) |
803 | 801 | ||
804 | #if NR_CPUS <= BITS_PER_LONG |
802 | #if NR_CPUS <= BITS_PER_LONG |
805 | #define CPU_BITS_ALL \ |
803 | #define CPU_BITS_ALL \ |
806 | { \ |
804 | { \ |
807 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
805 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
808 | } |
806 | } |
809 | 807 | ||
810 | #else /* NR_CPUS > BITS_PER_LONG */ |
808 | #else /* NR_CPUS > BITS_PER_LONG */ |
811 | 809 | ||
812 | #define CPU_BITS_ALL \ |
810 | #define CPU_BITS_ALL \ |
813 | { \ |
811 | { \ |
814 | [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL, \ |
812 | [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL, \ |
815 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
813 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
816 | } |
814 | } |
817 | #endif /* NR_CPUS > BITS_PER_LONG */ |
815 | #endif /* NR_CPUS > BITS_PER_LONG */ |
818 | 816 | ||
819 | /** |
817 | /** |
820 | * cpumap_print_to_pagebuf - copies the cpumask into the buffer either |
818 | * cpumap_print_to_pagebuf - copies the cpumask into the buffer either |
821 | * as comma-separated list of cpus or hex values of cpumask |
819 | * as comma-separated list of cpus or hex values of cpumask |
822 | * @list: indicates whether the cpumap must be list |
820 | * @list: indicates whether the cpumap must be list |
823 | * @mask: the cpumask to copy |
821 | * @mask: the cpumask to copy |
824 | * @buf: the buffer to copy into |
822 | * @buf: the buffer to copy into |
825 | * |
823 | * |
826 | * Returns the length of the (null-terminated) @buf string, zero if |
824 | * Returns the length of the (null-terminated) @buf string, zero if |
827 | * nothing is copied. |
825 | * nothing is copied. |
828 | */ |
826 | */ |
829 | static inline ssize_t |
827 | static inline ssize_t |
830 | cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask) |
828 | cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask) |
831 | { |
829 | { |
832 | return bitmap_print_to_pagebuf(list, buf, cpumask_bits(mask), |
830 | return bitmap_print_to_pagebuf(list, buf, cpumask_bits(mask), |
833 | nr_cpu_ids); |
831 | nr_cpu_ids); |
834 | } |
832 | } |
835 | 833 | ||
836 | #if NR_CPUS <= BITS_PER_LONG |
834 | #if NR_CPUS <= BITS_PER_LONG |
837 | #define CPU_MASK_ALL \ |
835 | #define CPU_MASK_ALL \ |
838 | (cpumask_t) { { \ |
836 | (cpumask_t) { { \ |
839 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
837 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
840 | } } |
838 | } } |
841 | #else |
839 | #else |
842 | #define CPU_MASK_ALL \ |
840 | #define CPU_MASK_ALL \ |
843 | (cpumask_t) { { \ |
841 | (cpumask_t) { { \ |
844 | [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL, \ |
842 | [0 ... BITS_TO_LONGS(NR_CPUS)-2] = ~0UL, \ |
845 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
843 | [BITS_TO_LONGS(NR_CPUS)-1] = BITMAP_LAST_WORD_MASK(NR_CPUS) \ |
846 | } } |
844 | } } |
847 | #endif /* NR_CPUS > BITS_PER_LONG */ |
845 | #endif /* NR_CPUS > BITS_PER_LONG */ |
848 | 846 | ||
849 | #define CPU_MASK_NONE \ |
847 | #define CPU_MASK_NONE \ |
850 | (cpumask_t) { { \ |
848 | (cpumask_t) { { \ |
851 | [0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL \ |
849 | [0 ... BITS_TO_LONGS(NR_CPUS)-1] = 0UL \ |
852 | } } |
850 | } } |
853 | 851 | ||
854 | #define CPU_MASK_CPU0 \ |
852 | #define CPU_MASK_CPU0 \ |
855 | (cpumask_t) { { \ |
853 | (cpumask_t) { { \ |
856 | [0] = 1UL \ |
854 | [0] = 1UL \ |
857 | } } |
855 | } } |
858 | 856 | ||
859 | #endif /* __LINUX_CPUMASK_H */=>=>=>><>>>>>>>>>>>>>>>>>=> |
857 | #endif /* __LINUX_CPUMASK_H */=>=>=>><>>>>>>>>>>>>>>>>>=> |