Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <errno.h>
4 : : #include <stddef.h>
5 : : #include <stdio.h>
6 : : #include <syslog.h>
7 : :
8 : : #include "alloc-util.h"
9 : : #include "cpu-set-util.h"
10 : : #include "dirent-util.h"
11 : : #include "errno-util.h"
12 : : #include "extract-word.h"
13 : : #include "fd-util.h"
14 : : #include "log.h"
15 : : #include "macro.h"
16 : : #include "memory-util.h"
17 : : #include "missing_syscall.h"
18 : : #include "parse-util.h"
19 : : #include "stat-util.h"
20 : : #include "string-util.h"
21 : : #include "string-table.h"
22 : : #include "strv.h"
23 : : #include "util.h"
24 : :
25 : 56 : char* cpu_set_to_string(const CPUSet *a) {
26 : 56 : _cleanup_free_ char *str = NULL;
27 : 56 : size_t allocated = 0, len = 0;
28 : : int i, r;
29 : :
30 [ + + ]: 36920 : for (i = 0; (size_t) i < a->allocated * 8; i++) {
31 [ + - + + : 36864 : if (!CPU_ISSET_S(i, a->allocated, a->set))
+ + ]
32 : 35376 : continue;
33 : :
34 [ - + ]: 1488 : if (!GREEDY_REALLOC(str, allocated, len + 1 + DECIMAL_STR_MAX(int)))
35 : 0 : return NULL;
36 : :
37 [ + + ]: 1488 : r = sprintf(str + len, len > 0 ? " %d" : "%d", i);
38 [ - + ]: 1488 : assert_se(r > 0);
39 : 1488 : len += r;
40 : : }
41 : :
42 [ + - ]: 56 : return TAKE_PTR(str) ?: strdup("");
43 : : }
44 : :
45 : 40 : char *cpu_set_to_range_string(const CPUSet *set) {
46 : 40 : unsigned range_start = 0, range_end;
47 : 40 : _cleanup_free_ char *str = NULL;
48 : 40 : size_t allocated = 0, len = 0;
49 : 40 : bool in_range = false;
50 : : int r;
51 : :
52 [ + + ]: 34856 : for (unsigned i = 0; i < set->allocated * 8; i++)
53 [ + - + + : 34816 : if (CPU_ISSET_S(i, set->allocated, set->set)) {
+ + ]
54 [ + + ]: 988 : if (in_range)
55 : 928 : range_end++;
56 : : else {
57 : 60 : range_start = range_end = i;
58 : 60 : in_range = true;
59 : : }
60 [ + + ]: 33828 : } else if (in_range) {
61 : 52 : in_range = false;
62 : :
63 [ - + ]: 52 : if (!GREEDY_REALLOC(str, allocated, len + 2 + 2 * DECIMAL_STR_MAX(unsigned)))
64 : 0 : return NULL;
65 : :
66 [ + + ]: 52 : if (range_end > range_start)
67 [ + + ]: 36 : r = sprintf(str + len, len > 0 ? " %d-%d" : "%d-%d", range_start, range_end);
68 : : else
69 [ + + ]: 16 : r = sprintf(str + len, len > 0 ? " %d" : "%d", range_start);
70 [ - + ]: 52 : assert_se(r > 0);
71 : 52 : len += r;
72 : : }
73 : :
74 [ + + ]: 40 : if (in_range) {
75 [ - + ]: 8 : if (!GREEDY_REALLOC(str, allocated, len + 2 + 2 * DECIMAL_STR_MAX(int)))
76 : 0 : return NULL;
77 : :
78 [ + + ]: 8 : if (range_end > range_start)
79 [ - + ]: 4 : r = sprintf(str + len, len > 0 ? " %d-%d" : "%d-%d", range_start, range_end);
80 : : else
81 [ + - ]: 4 : r = sprintf(str + len, len > 0 ? " %d" : "%d", range_start);
82 [ - + ]: 8 : assert_se(r > 0);
83 : : }
84 : :
85 [ + + ]: 40 : return TAKE_PTR(str) ?: strdup("");
86 : : }
87 : :
88 : 1968 : int cpu_set_realloc(CPUSet *cpu_set, unsigned ncpus) {
89 : : size_t need;
90 : :
91 [ - + ]: 1968 : assert(cpu_set);
92 : :
93 : 1968 : need = CPU_ALLOC_SIZE(ncpus);
94 [ + + ]: 1968 : if (need > cpu_set->allocated) {
95 : : cpu_set_t *t;
96 : :
97 : 80 : t = realloc(cpu_set->set, need);
98 [ - + ]: 80 : if (!t)
99 : 0 : return -ENOMEM;
100 : :
101 [ + - ]: 80 : memzero((uint8_t*) t + cpu_set->allocated, need - cpu_set->allocated);
102 : :
103 : 80 : cpu_set->set = t;
104 : 80 : cpu_set->allocated = need;
105 : : }
106 : :
107 : 1968 : return 0;
108 : : }
109 : :
110 : 1964 : static int cpu_set_add(CPUSet *cpu_set, unsigned cpu) {
111 : : int r;
112 : :
113 [ - + ]: 1964 : if (cpu >= 8192)
114 : : /* As of kernel 5.1, CONFIG_NR_CPUS can be set to 8192 on PowerPC */
115 : 0 : return -ERANGE;
116 : :
117 : 1964 : r = cpu_set_realloc(cpu_set, cpu + 1);
118 [ - + ]: 1964 : if (r < 0)
119 : 0 : return r;
120 : :
121 [ + - ]: 1964 : CPU_SET_S(cpu, cpu_set->allocated, cpu_set->set);
122 : 1964 : return 0;
123 : : }
124 : :
125 : 4 : int cpu_set_add_all(CPUSet *a, const CPUSet *b) {
126 : : int r;
127 : :
128 : : /* Do this backwards, so if we fail, we fail before changing anything. */
129 [ + + ]: 260 : for (unsigned cpu_p1 = b->allocated * 8; cpu_p1 > 0; cpu_p1--)
130 [ + - + + : 256 : if (CPU_ISSET_S(cpu_p1 - 1, b->allocated, b->set)) {
+ + ]
131 : 4 : r = cpu_set_add(a, cpu_p1 - 1);
132 [ - + ]: 4 : if (r < 0)
133 : 0 : return r;
134 : : }
135 : :
136 : 4 : return 0;
137 : : }
138 : :
139 : 80 : int parse_cpu_set_full(
140 : : const char *rvalue,
141 : : CPUSet *cpu_set,
142 : : bool warn,
143 : : const char *unit,
144 : : const char *filename,
145 : : unsigned line,
146 : : const char *lvalue) {
147 : :
148 : 80 : _cleanup_(cpu_set_reset) CPUSet c = {};
149 : 80 : const char *p = rvalue;
150 : :
151 [ - + ]: 80 : assert(p);
152 : :
153 : 240 : for (;;) {
154 [ + + + ]: 320 : _cleanup_free_ char *word = NULL;
155 : : unsigned cpu_lower, cpu_upper;
156 : : int r;
157 : :
158 : 320 : r = extract_first_word(&p, &word, WHITESPACE ",", EXTRACT_UNQUOTE);
159 [ - + ]: 320 : if (r == -ENOMEM)
160 [ # # ]: 0 : return warn ? log_oom() : -ENOMEM;
161 [ + + ]: 320 : if (r < 0)
162 [ + - + - ]: 4 : return warn ? log_syntax(unit, LOG_ERR, filename, line, r, "Invalid value for %s: %s", lvalue, rvalue) : r;
163 [ + + ]: 316 : if (r == 0)
164 : 68 : break;
165 : :
166 : 248 : r = parse_range(word, &cpu_lower, &cpu_upper);
167 [ + + ]: 248 : if (r < 0)
168 [ + - + - ]: 8 : return warn ? log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse CPU affinity '%s'", word) : r;
169 : :
170 [ + + ]: 240 : if (cpu_lower > cpu_upper) {
171 [ + - ]: 4 : if (warn)
172 [ + - ]: 4 : log_syntax(unit, LOG_WARNING, filename, line, 0, "Range '%s' is invalid, %u > %u, ignoring.",
173 : : word, cpu_lower, cpu_upper);
174 : :
175 : : /* Make sure something is allocated, to distinguish this from the empty case */
176 : 4 : r = cpu_set_realloc(&c, 1);
177 [ - + ]: 4 : if (r < 0)
178 : 0 : return r;
179 : : }
180 : :
181 [ + + ]: 1784 : for (unsigned cpu_p1 = MIN(cpu_upper, UINT_MAX-1) + 1; cpu_p1 > cpu_lower; cpu_p1--) {
182 : 1544 : r = cpu_set_add(&c, cpu_p1 - 1);
183 [ - + ]: 1544 : if (r < 0)
184 [ # # ]: 0 : return warn ? log_syntax(unit, LOG_ERR, filename, line, r,
185 [ # # ]: 0 : "Cannot add CPU %u to set: %m", cpu_p1 - 1) : r;
186 : : }
187 : : }
188 : :
189 : : /* On success, transfer ownership to the output variable */
190 : 68 : *cpu_set = c;
191 : 68 : c = (CPUSet) {};
192 : :
193 : 68 : return 0;
194 : : }
195 : :
196 : 16 : int parse_cpu_set_extend(
197 : : const char *rvalue,
198 : : CPUSet *old,
199 : : bool warn,
200 : : const char *unit,
201 : : const char *filename,
202 : : unsigned line,
203 : : const char *lvalue) {
204 : :
205 : 16 : _cleanup_(cpu_set_reset) CPUSet cpuset = {};
206 : : int r;
207 : :
208 : 16 : r = parse_cpu_set_full(rvalue, &cpuset, true, unit, filename, line, lvalue);
209 [ - + ]: 16 : if (r < 0)
210 : 0 : return r;
211 : :
212 [ + + ]: 16 : if (!cpuset.set) {
213 : : /* An empty assignment resets the CPU list */
214 : 4 : cpu_set_reset(old);
215 : 4 : return 0;
216 : : }
217 : :
218 [ + + ]: 12 : if (!old->set) {
219 : 8 : *old = cpuset;
220 : 8 : cpuset = (CPUSet) {};
221 : 8 : return 0;
222 : : }
223 : :
224 : 4 : return cpu_set_add_all(old, &cpuset);
225 : : }
226 : :
227 : 80 : int cpus_in_affinity_mask(void) {
228 : 80 : size_t n = 16;
229 : : int r;
230 : :
231 : 0 : for (;;) {
232 : : cpu_set_t *c;
233 : :
234 : 80 : c = CPU_ALLOC(n);
235 [ - + ]: 80 : if (!c)
236 : 0 : return -ENOMEM;
237 : :
238 [ + - ]: 80 : if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), c) >= 0) {
239 : : int k;
240 : :
241 : 80 : k = CPU_COUNT_S(CPU_ALLOC_SIZE(n), c);
242 : 80 : CPU_FREE(c);
243 : :
244 [ - + ]: 80 : if (k <= 0)
245 : 0 : return -EINVAL;
246 : :
247 : 80 : return k;
248 : : }
249 : :
250 : 0 : r = -errno;
251 : 0 : CPU_FREE(c);
252 : :
253 [ # # ]: 0 : if (r != -EINVAL)
254 : 0 : return r;
255 [ # # ]: 0 : if (n > SIZE_MAX/2)
256 : 0 : return -ENOMEM;
257 : 0 : n *= 2;
258 : : }
259 : : }
260 : :
261 : 4 : int cpu_set_to_dbus(const CPUSet *set, uint8_t **ret, size_t *allocated) {
262 : : uint8_t *out;
263 : :
264 [ - + ]: 4 : assert(set);
265 [ - + ]: 4 : assert(ret);
266 : :
267 [ + - ]: 4 : out = new0(uint8_t, set->allocated);
268 [ - + ]: 4 : if (!out)
269 : 0 : return -ENOMEM;
270 : :
271 [ + + ]: 1028 : for (unsigned cpu = 0; cpu < set->allocated * 8; cpu++)
272 [ + - + + : 1024 : if (CPU_ISSET_S(cpu, set->allocated, set->set))
+ + ]
273 : 416 : out[cpu / 8] |= 1u << (cpu % 8);
274 : :
275 : 4 : *ret = out;
276 : 4 : *allocated = set->allocated;
277 : 4 : return 0;
278 : : }
279 : :
280 : 4 : int cpu_set_from_dbus(const uint8_t *bits, size_t size, CPUSet *set) {
281 : 4 : _cleanup_(cpu_set_reset) CPUSet s = {};
282 : : int r;
283 : :
284 [ - + ]: 4 : assert(bits);
285 [ - + ]: 4 : assert(set);
286 : :
287 [ + + ]: 1028 : for (unsigned cpu = size * 8; cpu > 0; cpu--)
288 [ + + ]: 1024 : if (bits[(cpu - 1) / 8] & (1u << ((cpu - 1) % 8))) {
289 : 416 : r = cpu_set_add(&s, cpu - 1);
290 [ - + ]: 416 : if (r < 0)
291 : 0 : return r;
292 : : }
293 : :
294 : 4 : *set = s;
295 : 4 : s = (CPUSet) {};
296 : 4 : return 0;
297 : : }
298 : :
299 : 0 : bool numa_policy_is_valid(const NUMAPolicy *policy) {
300 [ # # ]: 0 : assert(policy);
301 : :
302 [ # # ]: 0 : if (!mpol_is_valid(numa_policy_get_type(policy)))
303 : 0 : return false;
304 : :
305 [ # # ]: 0 : if (!policy->nodes.set &&
306 [ # # # # ]: 0 : !IN_SET(numa_policy_get_type(policy), MPOL_DEFAULT, MPOL_LOCAL, MPOL_PREFERRED))
307 : 0 : return false;
308 : :
309 [ # # # # ]: 0 : if (policy->nodes.set &&
310 [ # # ]: 0 : numa_policy_get_type(policy) == MPOL_PREFERRED &&
311 : 0 : CPU_COUNT_S(policy->nodes.allocated, policy->nodes.set) != 1)
312 : 0 : return false;
313 : :
314 : 0 : return true;
315 : : }
316 : :
317 : 0 : static int numa_policy_to_mempolicy(const NUMAPolicy *policy, unsigned long *ret_maxnode, unsigned long **ret_nodes) {
318 : 0 : unsigned node, bits = 0, ulong_bits;
319 : 0 : _cleanup_free_ unsigned long *out = NULL;
320 : :
321 [ # # ]: 0 : assert(policy);
322 [ # # ]: 0 : assert(ret_maxnode);
323 [ # # ]: 0 : assert(ret_nodes);
324 : :
325 [ # # # # : 0 : if (IN_SET(numa_policy_get_type(policy), MPOL_DEFAULT, MPOL_LOCAL) ||
# # ]
326 [ # # ]: 0 : (numa_policy_get_type(policy) == MPOL_PREFERRED && !policy->nodes.set)) {
327 : 0 : *ret_nodes = NULL;
328 : 0 : *ret_maxnode = 0;
329 : 0 : return 0;
330 : : }
331 : :
332 : 0 : bits = policy->nodes.allocated * 8;
333 : 0 : ulong_bits = sizeof(unsigned long) * 8;
334 : :
335 [ # # ]: 0 : out = new0(unsigned long, DIV_ROUND_UP(policy->nodes.allocated, sizeof(unsigned long)));
336 [ # # ]: 0 : if (!out)
337 : 0 : return -ENOMEM;
338 : :
339 : : /* We don't make any assumptions about internal type libc is using to store NUMA node mask.
340 : : Hence we need to convert the node mask to the representation expected by set_mempolicy() */
341 [ # # ]: 0 : for (node = 0; node < bits; node++)
342 [ # # # # : 0 : if (CPU_ISSET_S(node, policy->nodes.allocated, policy->nodes.set))
# # ]
343 : 0 : out[node / ulong_bits] |= 1ul << (node % ulong_bits);
344 : :
345 : 0 : *ret_nodes = TAKE_PTR(out);
346 : 0 : *ret_maxnode = bits + 1;
347 : 0 : return 0;
348 : : }
349 : :
350 : 0 : int apply_numa_policy(const NUMAPolicy *policy) {
351 : : int r;
352 : 0 : _cleanup_free_ unsigned long *nodes = NULL;
353 : : unsigned long maxnode;
354 : :
355 [ # # ]: 0 : assert(policy);
356 : :
357 [ # # # # ]: 0 : if (get_mempolicy(NULL, NULL, 0, 0, 0) < 0 && errno == ENOSYS)
358 : 0 : return -EOPNOTSUPP;
359 : :
360 [ # # ]: 0 : if (!numa_policy_is_valid(policy))
361 : 0 : return -EINVAL;
362 : :
363 : 0 : r = numa_policy_to_mempolicy(policy, &maxnode, &nodes);
364 [ # # ]: 0 : if (r < 0)
365 : 0 : return r;
366 : :
367 : 0 : r = set_mempolicy(numa_policy_get_type(policy), nodes, maxnode);
368 [ # # ]: 0 : if (r < 0)
369 : 0 : return -errno;
370 : :
371 : 0 : return 0;
372 : : }
373 : :
374 : : static const char* const mpol_table[] = {
375 : : [MPOL_DEFAULT] = "default",
376 : : [MPOL_PREFERRED] = "preferred",
377 : : [MPOL_BIND] = "bind",
378 : : [MPOL_INTERLEAVE] = "interleave",
379 : : [MPOL_LOCAL] = "local",
380 : : };
381 : :
382 [ + - - + ]: 4 : DEFINE_STRING_TABLE_LOOKUP(mpol, int);
|
