lib/cpumask.c

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