Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1#include <linux/slab.h>
2#include <linux/kernel.h>
3#include <linux/bitops.h>
4#include <linux/cpumask.h>
5#include <linux/export.h>
6#include <linux/bootmem.h>
7
8/**
9 * cpumask_next_and - get the next cpu in *src1p & *src2p
10 * @n: the cpu prior to the place to search (ie. return will be > @n)
11 * @src1p: the first cpumask pointer
12 * @src2p: the second cpumask pointer
13 *
14 * Returns >= nr_cpu_ids if no further cpus set in both.
15 */
16int cpumask_next_and(int n, const struct cpumask *src1p,
17 const struct cpumask *src2p)
18{
19 while ((n = cpumask_next(n, src1p)) < nr_cpu_ids)
20 if (cpumask_test_cpu(n, src2p))
21 break;
22 return n;
23}
24EXPORT_SYMBOL(cpumask_next_and);
25
26/**
27 * cpumask_any_but - return a "random" in a cpumask, but not this one.
28 * @mask: the cpumask to search
29 * @cpu: the cpu to ignore.
30 *
31 * Often used to find any cpu but smp_processor_id() in a mask.
32 * Returns >= nr_cpu_ids if no cpus set.
33 */
34int cpumask_any_but(const struct cpumask *mask, unsigned int cpu)
35{
36 unsigned int i;
37
38 cpumask_check(cpu);
39 for_each_cpu(i, mask)
40 if (i != cpu)
41 break;
42 return i;
43}
44EXPORT_SYMBOL(cpumask_any_but);
45
46/**
47 * cpumask_next_wrap - helper to implement for_each_cpu_wrap
48 * @n: the cpu prior to the place to search
49 * @mask: the cpumask pointer
50 * @start: the start point of the iteration
51 * @wrap: assume @n crossing @start terminates the iteration
52 *
53 * Returns >= nr_cpu_ids on completion
54 *
55 * Note: the @wrap argument is required for the start condition when
56 * we cannot assume @start is set in @mask.
57 */
58int cpumask_next_wrap(int n, const struct cpumask *mask, int start, bool wrap)
59{
60 int next;
61
62again:
63 next = cpumask_next(n, mask);
64
65 if (wrap && n < start && next >= start) {
66 return nr_cpumask_bits;
67
68 } else if (next >= nr_cpumask_bits) {
69 wrap = true;
70 n = -1;
71 goto again;
72 }
73
74 return next;
75}
76EXPORT_SYMBOL(cpumask_next_wrap);
77
78/* These are not inline because of header tangles. */
79#ifdef CONFIG_CPUMASK_OFFSTACK
80/**
81 * alloc_cpumask_var_node - allocate a struct cpumask on a given node
82 * @mask: pointer to cpumask_var_t where the cpumask is returned
83 * @flags: GFP_ flags
84 *
85 * Only defined when CONFIG_CPUMASK_OFFSTACK=y, otherwise is
86 * a nop returning a constant 1 (in <linux/cpumask.h>)
87 * Returns TRUE if memory allocation succeeded, FALSE otherwise.
88 *
89 * In addition, mask will be NULL if this fails. Note that gcc is
90 * usually smart enough to know that mask can never be NULL if
91 * CONFIG_CPUMASK_OFFSTACK=n, so does code elimination in that case
92 * too.
93 */
94bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node)
95{
96 *mask = kmalloc_node(cpumask_size(), flags, node);
97
98#ifdef CONFIG_DEBUG_PER_CPU_MAPS
99 if (!*mask) {
100 printk(KERN_ERR "=> alloc_cpumask_var: failed!\n");
101 dump_stack();
102 }
103#endif
104
105 return *mask != NULL;
106}
107EXPORT_SYMBOL(alloc_cpumask_var_node);
108
109bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node)
110{
111 return alloc_cpumask_var_node(mask, flags | __GFP_ZERO, node);
112}
113EXPORT_SYMBOL(zalloc_cpumask_var_node);
114
115/**
116 * alloc_cpumask_var - allocate a struct cpumask
117 * @mask: pointer to cpumask_var_t where the cpumask is returned
118 * @flags: GFP_ flags
119 *
120 * Only defined when CONFIG_CPUMASK_OFFSTACK=y, otherwise is
121 * a nop returning a constant 1 (in <linux/cpumask.h>).
122 *
123 * See alloc_cpumask_var_node.
124 */
125bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
126{
127 return alloc_cpumask_var_node(mask, flags, NUMA_NO_NODE);
128}
129EXPORT_SYMBOL(alloc_cpumask_var);
130
131bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
132{
133 return alloc_cpumask_var(mask, flags | __GFP_ZERO);
134}
135EXPORT_SYMBOL(zalloc_cpumask_var);
136
137/**
138 * alloc_bootmem_cpumask_var - allocate a struct cpumask from the bootmem arena.
139 * @mask: pointer to cpumask_var_t where the cpumask is returned
140 *
141 * Only defined when CONFIG_CPUMASK_OFFSTACK=y, otherwise is
142 * a nop (in <linux/cpumask.h>).
143 * Either returns an allocated (zero-filled) cpumask, or causes the
144 * system to panic.
145 */
146void __init alloc_bootmem_cpumask_var(cpumask_var_t *mask)
147{
148 *mask = memblock_virt_alloc(cpumask_size(), 0);
149}
150
151/**
152 * free_cpumask_var - frees memory allocated for a struct cpumask.
153 * @mask: cpumask to free
154 *
155 * This is safe on a NULL mask.
156 */
157void free_cpumask_var(cpumask_var_t mask)
158{
159 kfree(mask);
160}
161EXPORT_SYMBOL(free_cpumask_var);
162
163/**
164 * free_bootmem_cpumask_var - frees result of alloc_bootmem_cpumask_var
165 * @mask: cpumask to free
166 */
167void __init free_bootmem_cpumask_var(cpumask_var_t mask)
168{
169 memblock_free_early(__pa(mask), cpumask_size());
170}
171#endif
172
173/**
174 * cpumask_local_spread - select the i'th cpu with local numa cpu's first
175 * @i: index number
176 * @node: local numa_node
177 *
178 * This function selects an online CPU according to a numa aware policy;
179 * local cpus are returned first, followed by non-local ones, then it
180 * wraps around.
181 *
182 * It's not very efficient, but useful for setup.
183 */
184unsigned int cpumask_local_spread(unsigned int i, int node)
185{
186 int cpu;
187
188 /* Wrap: we always want a cpu. */
189 i %= num_online_cpus();
190
191 if (node == -1) {
192 for_each_cpu(cpu, cpu_online_mask)
193 if (i-- == 0)
194 return cpu;
195 } else {
196 /* NUMA first. */
197 for_each_cpu_and(cpu, cpumask_of_node(node), cpu_online_mask)
198 if (i-- == 0)
199 return cpu;
200
201 for_each_cpu(cpu, cpu_online_mask) {
202 /* Skip NUMA nodes, done above. */
203 if (cpumask_test_cpu(cpu, cpumask_of_node(node)))
204 continue;
205
206 if (i-- == 0)
207 return cpu;
208 }
209 }
210 BUG();
211}
212EXPORT_SYMBOL(cpumask_local_spread);