1 #include <linux/kernel.h> 2 #include <linux/bitops.h> 3 #include <linux/cpumask.h> 4 #include <linux/module.h> 5 #include <linux/bootmem.h> 6 7 int __first_cpu(const cpumask_t *srcp) 8 { 9 return min_t(int, NR_CPUS, find_first_bit(srcp->bits, NR_CPUS)); 10 } 11 EXPORT_SYMBOL(__first_cpu); 12 13 int __next_cpu(int n, const cpumask_t *srcp) 14 { 15 return min_t(int, NR_CPUS, find_next_bit(srcp->bits, NR_CPUS, n+1)); 16 } 17 EXPORT_SYMBOL(__next_cpu); 18 19 #if NR_CPUS > 64 20 int __next_cpu_nr(int n, const cpumask_t *srcp) 21 { 22 return min_t(int, nr_cpu_ids, 23 find_next_bit(srcp->bits, nr_cpu_ids, n+1)); 24 } 25 EXPORT_SYMBOL(__next_cpu_nr); 26 #endif 27 28 int __any_online_cpu(const cpumask_t *mask) 29 { 30 int cpu; 31 32 for_each_cpu_mask(cpu, *mask) { 33 if (cpu_online(cpu)) 34 break; 35 } 36 return cpu; 37 } 38 EXPORT_SYMBOL(__any_online_cpu); 39 40 /** 41 * cpumask_next_and - get the next cpu in *src1p & *src2p 42 * @n: the cpu prior to the place to search (ie. return will be > @n) 43 * @src1p: the first cpumask pointer 44 * @src2p: the second cpumask pointer 45 * 46 * Returns >= nr_cpu_ids if no further cpus set in both. 47 */ 48 int cpumask_next_and(int n, const struct cpumask *src1p, 49 const struct cpumask *src2p) 50 { 51 while ((n = cpumask_next(n, src1p)) < nr_cpu_ids) 52 if (cpumask_test_cpu(n, src2p)) 53 break; 54 return n; 55 } 56 EXPORT_SYMBOL(cpumask_next_and); 57 58 /** 59 * cpumask_any_but - return a "random" in a cpumask, but not this one. 60 * @mask: the cpumask to search 61 * @cpu: the cpu to ignore. 62 * 63 * Often used to find any cpu but smp_processor_id() in a mask. 64 * Returns >= nr_cpu_ids if no cpus set. 65 */ 66 int cpumask_any_but(const struct cpumask *mask, unsigned int cpu) 67 { 68 unsigned int i; 69 70 cpumask_check(cpu); 71 for_each_cpu(i, mask) 72 if (i != cpu) 73 break; 74 return i; 75 } 76 77 /* These are not inline because of header tangles. */ 78 #ifdef CONFIG_CPUMASK_OFFSTACK 79 /** 80 * alloc_cpumask_var_node - allocate a struct cpumask on a given node 81 * @mask: pointer to cpumask_var_t where the cpumask is returned 82 * @flags: GFP_ flags 83 * 84 * Only defined when CONFIG_CPUMASK_OFFSTACK=y, otherwise is 85 * a nop returning a constant 1 (in <linux/cpumask.h>) 86 * Returns TRUE if memory allocation succeeded, FALSE otherwise. 87 * 88 * In addition, mask will be NULL if this fails. Note that gcc is 89 * usually smart enough to know that mask can never be NULL if 90 * CONFIG_CPUMASK_OFFSTACK=n, so does code elimination in that case 91 * too. 92 */ 93 bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node) 94 { 95 *mask = kmalloc_node(cpumask_size(), flags, node); 96 97 #ifdef CONFIG_DEBUG_PER_CPU_MAPS 98 if (!*mask) { 99 printk(KERN_ERR "=> alloc_cpumask_var: failed!\n"); 100 dump_stack(); 101 } 102 #endif 103 /* FIXME: Bandaid to save us from old primitives which go to NR_CPUS. */ 104 if (*mask) { 105 unsigned char *ptr = (unsigned char *)cpumask_bits(*mask); 106 unsigned int tail; 107 tail = BITS_TO_LONGS(NR_CPUS - nr_cpumask_bits) * sizeof(long); 108 memset(ptr + cpumask_size() - tail, 0, tail); 109 } 110 111 return *mask != NULL; 112 } 113 EXPORT_SYMBOL(alloc_cpumask_var_node); 114 115 bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node) 116 { 117 return alloc_cpumask_var_node(mask, flags | __GFP_ZERO, node); 118 } 119 EXPORT_SYMBOL(zalloc_cpumask_var_node); 120 121 /** 122 * alloc_cpumask_var - allocate a struct cpumask 123 * @mask: pointer to cpumask_var_t where the cpumask is returned 124 * @flags: GFP_ flags 125 * 126 * Only defined when CONFIG_CPUMASK_OFFSTACK=y, otherwise is 127 * a nop returning a constant 1 (in <linux/cpumask.h>). 128 * 129 * See alloc_cpumask_var_node. 130 */ 131 bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags) 132 { 133 return alloc_cpumask_var_node(mask, flags, numa_node_id()); 134 } 135 EXPORT_SYMBOL(alloc_cpumask_var); 136 137 bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags) 138 { 139 return alloc_cpumask_var(mask, flags | __GFP_ZERO); 140 } 141 EXPORT_SYMBOL(zalloc_cpumask_var); 142 143 /** 144 * alloc_bootmem_cpumask_var - allocate a struct cpumask from the bootmem arena. 145 * @mask: pointer to cpumask_var_t where the cpumask is returned 146 * 147 * Only defined when CONFIG_CPUMASK_OFFSTACK=y, otherwise is 148 * a nop (in <linux/cpumask.h>). 149 * Either returns an allocated (zero-filled) cpumask, or causes the 150 * system to panic. 151 */ 152 void __init alloc_bootmem_cpumask_var(cpumask_var_t *mask) 153 { 154 *mask = alloc_bootmem(cpumask_size()); 155 } 156 157 /** 158 * free_cpumask_var - frees memory allocated for a struct cpumask. 159 * @mask: cpumask to free 160 * 161 * This is safe on a NULL mask. 162 */ 163 void free_cpumask_var(cpumask_var_t mask) 164 { 165 kfree(mask); 166 } 167 EXPORT_SYMBOL(free_cpumask_var); 168 169 /** 170 * free_bootmem_cpumask_var - frees result of alloc_bootmem_cpumask_var 171 * @mask: cpumask to free 172 */ 173 void __init free_bootmem_cpumask_var(cpumask_var_t mask) 174 { 175 free_bootmem((unsigned long)mask, cpumask_size()); 176 } 177 #endif 178