Subversion Repositories Kolibri OS

Rev

Rev 6936 | Details | Compare with Previous | Last modification | View Log | RSS feed

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