[thirdparty/systemd.git] / src / shared / cpu-set-util.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <syslog.h>

#include "alloc-util.h"
#include "cpu-set-util.h"
#include "dirent-util.h"
#include "errno-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "hexdecoct.h"
#include "log.h"
#include "macro.h"
#include "memory-util.h"
#include "parse-util.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"

char* cpu_set_to_string(const CPUSet *a) {
        _cleanup_free_ char *str = NULL;
        size_t len = 0;
        int i, r;

        for (i = 0; (size_t) i < a->allocated * 8; i++) {
                if (!CPU_ISSET_S(i, a->allocated, a->set))
                        continue;

                if (!GREEDY_REALLOC(str, len + 1 + DECIMAL_STR_MAX(int)))
                        return NULL;

                r = sprintf(str + len, len > 0 ? " %d" : "%d", i);
                assert_se(r > 0);
                len += r;
        }

        return TAKE_PTR(str) ?: strdup("");
}

char *cpu_set_to_range_string(const CPUSet *set) {
        unsigned range_start = 0, range_end;
        _cleanup_free_ char *str = NULL;
        bool in_range = false;
        size_t len = 0;
        int r;

        for (unsigned i = 0; i < set->allocated * 8; i++)
                if (CPU_ISSET_S(i, set->allocated, set->set)) {
                        if (in_range)
                                range_end++;
                        else {
                                range_start = range_end = i;
                                in_range = true;
                        }
                } else if (in_range) {
                        in_range = false;

                        if (!GREEDY_REALLOC(str, len + 2 + 2 * DECIMAL_STR_MAX(unsigned)))
                                return NULL;

                        if (range_end > range_start)
                                r = sprintf(str + len, len > 0 ? " %u-%u" : "%u-%u", range_start, range_end);
                        else
                                r = sprintf(str + len, len > 0 ? " %u" : "%u", range_start);
                        assert_se(r > 0);
                        len += r;
                }

        if (in_range) {
                if (!GREEDY_REALLOC(str, len + 2 + 2 * DECIMAL_STR_MAX(int)))
                        return NULL;

                if (range_end > range_start)
                        r = sprintf(str + len, len > 0 ? " %u-%u" : "%u-%u", range_start, range_end);
                else
                        r = sprintf(str + len, len > 0 ? " %u" : "%u", range_start);
                assert_se(r > 0);
        }

        return TAKE_PTR(str) ?: strdup("");
}

char* cpu_set_to_mask_string(const CPUSet *a) {
        _cleanup_free_ char *str = NULL;
        size_t len = 0;
        bool found_nonzero = false;

        assert(a);

        /* Return CPU set in hexadecimal bitmap mask, e.g.
         *   CPU   0 ->  "1"
         *   CPU   1 ->  "2"
         *   CPU 0,1 ->  "3"
         *   CPU 0-3 ->  "f"
         *   CPU 0-7 -> "ff"
         *   CPU 4-7 -> "f0"
         *   CPU   7 -> "80"
         *   None    ->  "0"
         *
         * When there are more than 32 CPUs, separate every 32 CPUs by comma, e.g.
         *  CPU 0-47 -> "ffff,ffffffff"
         *  CPU 0-63 -> "ffffffff,ffffffff"
         *  CPU 0-71 -> "ff,ffffffff,ffffffff" */

        for (ssize_t i = a->allocated * 8; i >= 0; i -= 4) {
                uint8_t m = 0;

                for (size_t j = 0; j < 4; j++)
                        if (CPU_ISSET_S(i + j, a->allocated, a->set))
                                m |= 1U << j;

                if (!found_nonzero)
                        found_nonzero = m > 0;

                if (!found_nonzero && m == 0)
                        /* Skip leading zeros */
                        continue;

                if (!GREEDY_REALLOC(str, len + 3))
                        return NULL;

                str[len++] = hexchar(m);
                if (i >= 4 && i % 32 == 0)
                        /* Separate by comma for each 32 CPUs. */
                        str[len++] = ',';
                str[len] = 0;
        }

        return TAKE_PTR(str) ?: strdup("0");
}

CPUSet* cpu_set_free(CPUSet *c) {
        if (!c)
                return c;

        cpu_set_reset(c);
        return mfree(c);
}

int cpu_set_realloc(CPUSet *cpu_set, unsigned ncpus) {
        size_t need;

        assert(cpu_set);

        need = CPU_ALLOC_SIZE(ncpus);
        if (need > cpu_set->allocated) {
                cpu_set_t *t;

                t = realloc(cpu_set->set, need);
                if (!t)
                        return -ENOMEM;

                memzero((uint8_t*) t + cpu_set->allocated, need - cpu_set->allocated);

                cpu_set->set = t;
                cpu_set->allocated = need;
        }

        return 0;
}

int cpu_set_add(CPUSet *cpu_set, unsigned cpu) {
        int r;

        if (cpu >= 8192)
                /* As of kernel 5.1, CONFIG_NR_CPUS can be set to 8192 on PowerPC */
                return -ERANGE;

        r = cpu_set_realloc(cpu_set, cpu + 1);
        if (r < 0)
                return r;

        CPU_SET_S(cpu, cpu_set->allocated, cpu_set->set);
        return 0;
}

int cpu_set_add_all(CPUSet *a, const CPUSet *b) {
        int r;

        /* Do this backwards, so if we fail, we fail before changing anything. */
        for (unsigned cpu_p1 = b->allocated * 8; cpu_p1 > 0; cpu_p1--)
                if (CPU_ISSET_S(cpu_p1 - 1, b->allocated, b->set)) {
                        r = cpu_set_add(a, cpu_p1 - 1);
                        if (r < 0)
                                return r;
                }

        return 1;
}

int parse_cpu_set_full(
                const char *rvalue,
                CPUSet *cpu_set,
                bool warn,
                const char *unit,
                const char *filename,
                unsigned line,
                const char *lvalue) {

        _cleanup_(cpu_set_reset) CPUSet c = {};
        const char *p = ASSERT_PTR(rvalue);

        assert(cpu_set);

        for (;;) {
                _cleanup_free_ char *word = NULL;
                unsigned cpu_lower, cpu_upper;
                int r;

                r = extract_first_word(&p, &word, WHITESPACE ",", EXTRACT_UNQUOTE);
                if (r == -ENOMEM)
                        return warn ? log_oom() : -ENOMEM;
                if (r < 0)
                        return warn ? log_syntax(unit, LOG_ERR, filename, line, r, "Invalid value for %s: %s", lvalue, rvalue) : r;
                if (r == 0)
                        break;

                r = parse_range(word, &cpu_lower, &cpu_upper);
                if (r < 0)
                        return warn ? log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse CPU affinity '%s'", word) : r;

                if (cpu_lower > cpu_upper) {
                        if (warn)
                                log_syntax(unit, LOG_WARNING, filename, line, 0, "Range '%s' is invalid, %u > %u, ignoring.",
                                           word, cpu_lower, cpu_upper);

                        /* Make sure something is allocated, to distinguish this from the empty case */
                        r = cpu_set_realloc(&c, 1);
                        if (r < 0)
                                return r;
                }

                for (unsigned cpu_p1 = MIN(cpu_upper, UINT_MAX-1) + 1; cpu_p1 > cpu_lower; cpu_p1--) {
                        r = cpu_set_add(&c, cpu_p1 - 1);
                        if (r < 0)
                                return warn ? log_syntax(unit, LOG_ERR, filename, line, r,
                                                         "Cannot add CPU %u to set: %m", cpu_p1 - 1) : r;
                }
        }

        *cpu_set = TAKE_STRUCT(c);

        return 0;
}

int parse_cpu_set_extend(
                const char *rvalue,
                CPUSet *old,
                bool warn,
                const char *unit,
                const char *filename,
                unsigned line,
                const char *lvalue) {

        _cleanup_(cpu_set_reset) CPUSet cpuset = {};
        int r;

        assert(old);

        r = parse_cpu_set_full(rvalue, &cpuset, true, unit, filename, line, lvalue);
        if (r < 0)
                return r;

        if (!cpuset.set) {
                /* An empty assignment resets the CPU list */
                cpu_set_reset(old);
                return 0;
        }

        if (!old->set) {
                *old = TAKE_STRUCT(cpuset);
                return 1;
        }

        return cpu_set_add_all(old, &cpuset);
}

int cpus_in_affinity_mask(void) {
        size_t n = 16;
        int r;

        for (;;) {
                cpu_set_t *c;

                c = CPU_ALLOC(n);
                if (!c)
                        return -ENOMEM;

                if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), c) >= 0) {
                        int k;

                        k = CPU_COUNT_S(CPU_ALLOC_SIZE(n), c);
                        CPU_FREE(c);

                        if (k <= 0)
                                return -EINVAL;

                        return k;
                }

                r = -errno;
                CPU_FREE(c);

                if (r != -EINVAL)
                        return r;
                if (n > SIZE_MAX/2)
                        return -ENOMEM;
                n *= 2;
        }
}

int cpu_set_to_dbus(const CPUSet *set, uint8_t **ret, size_t *allocated) {
        uint8_t *out;

        assert(set);
        assert(ret);

        out = new0(uint8_t, set->allocated);
        if (!out)
                return -ENOMEM;

        for (unsigned cpu = 0; cpu < set->allocated * 8; cpu++)
                if (CPU_ISSET_S(cpu, set->allocated, set->set))
                        out[cpu / 8] |= 1u << (cpu % 8);

        *ret = out;
        *allocated = set->allocated;
        return 0;
}

int cpu_set_from_dbus(const uint8_t *bits, size_t size, CPUSet *set) {
        _cleanup_(cpu_set_reset) CPUSet s = {};
        int r;

        assert(bits);
        assert(set);

        for (unsigned cpu = size * 8; cpu > 0; cpu--)
                if (bits[(cpu - 1) / 8] & (1u << ((cpu - 1) % 8))) {
                        r = cpu_set_add(&s, cpu - 1);
                        if (r < 0)
                                return r;
                }

        *set = TAKE_STRUCT(s);
        return 0;
}

int cpu_mask_add_all(CPUSet *mask) {
        long m;
        int r;

        assert(mask);

        m = sysconf(_SC_NPROCESSORS_ONLN);
        if (m < 0)
                return -errno;

        for (unsigned i = 0; i < (unsigned) m; i++) {
                r = cpu_set_add(mask, i);
                if (r < 0)
                        return r;
        }

        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
618234a5	2
11c3a366 TA	3	#include <errno.h>
11c3a366 TA	4	#include <stddef.h>
a832893f	5	#include <stdio.h>
11c3a366 TA	6	#include <syslog.h>
11c3a366 TA	7
b5efdb8a	8	#include "alloc-util.h"
6bedfcbb	9	#include "cpu-set-util.h"
b070c7c0 MS	10	#include "dirent-util.h"
b070c7c0 MS	11	#include "errno-util.h"
84ac7bea	12	#include "extract-word.h"
b070c7c0	13	#include "fd-util.h"
0f30bf58	14	#include "hexdecoct.h"
11c3a366 TA	15	#include "log.h"
11c3a366 TA	16	#include "macro.h"
0985c7c4	17	#include "memory-util.h"
93cc7779	18	#include "parse-util.h"
b070c7c0	19	#include "stat-util.h"
b11d6a7b	20	#include "string-util.h"
b070c7c0	21	#include "strv.h"
618234a5	22
0985c7c4	23	char* cpu_set_to_string(const CPUSet *a) {
a832893f	24	_cleanup_free_ char *str = NULL;
319a4f4b	25	size_t len = 0;
a832893f ZJS	26	int i, r;
a832893f ZJS	27
0985c7c4 ZJS	28	for (i = 0; (size_t) i < a->allocated * 8; i++) {
0985c7c4 ZJS	29	if (!CPU_ISSET_S(i, a->allocated, a->set))
a832893f ZJS	30	continue;
a832893f ZJS	31
319a4f4b	32	if (!GREEDY_REALLOC(str, len + 1 + DECIMAL_STR_MAX(int)))
a832893f ZJS	33	return NULL;
	34
	35	r = sprintf(str + len, len > 0 ? " %d" : "%d", i);
	36	assert_se(r > 0);
	37	len += r;
	38	}
	39
	40	return TAKE_PTR(str) ?: strdup("");
	41	}
	42
71b28519 MS	43	char cpu_set_to_range_string(const CPUSet set) {
	44	unsigned range_start = 0, range_end;
	45	_cleanup_free_ char *str = NULL;
71b28519	46	bool in_range = false;
319a4f4b	47	size_t len = 0;
71b28519 MS	48	int r;
	49
	50	for (unsigned i = 0; i < set->allocated * 8; i++)
	51	if (CPU_ISSET_S(i, set->allocated, set->set)) {
	52	if (in_range)
	53	range_end++;
	54	else {
	55	range_start = range_end = i;
	56	in_range = true;
	57	}
	58	} else if (in_range) {
	59	in_range = false;
	60
319a4f4b	61	if (!GREEDY_REALLOC(str, len + 2 + 2 * DECIMAL_STR_MAX(unsigned)))
71b28519 MS	62	return NULL;
71b28519 MS	63
71923237	64	if (range_end > range_start)
c0f86d66	65	r = sprintf(str + len, len > 0 ? " %u-%u" : "%u-%u", range_start, range_end);
1f57a176	66	else
c0f86d66	67	r = sprintf(str + len, len > 0 ? " %u" : "%u", range_start);
71b28519 MS	68	assert_se(r > 0);
	69	len += r;
	70	}
	71
	72	if (in_range) {
319a4f4b	73	if (!GREEDY_REALLOC(str, len + 2 + 2 * DECIMAL_STR_MAX(int)))
71b28519 MS	74	return NULL;
71b28519 MS	75
71923237	76	if (range_end > range_start)
c0f86d66	77	r = sprintf(str + len, len > 0 ? " %u-%u" : "%u-%u", range_start, range_end);
1f57a176	78	else
c0f86d66	79	r = sprintf(str + len, len > 0 ? " %u" : "%u", range_start);
71b28519 MS	80	assert_se(r > 0);
	81	}
	82
	83	return TAKE_PTR(str) ?: strdup("");
	84	}
	85
0f30bf58 RRZ	86	char* cpu_set_to_mask_string(const CPUSet *a) {
	87	_cleanup_free_ char *str = NULL;
	88	size_t len = 0;
	89	bool found_nonzero = false;
	90
	91	assert(a);
	92
	93	/* Return CPU set in hexadecimal bitmap mask, e.g.
	94	* CPU 0 -> "1"
	95	* CPU 1 -> "2"
	96	* CPU 0,1 -> "3"
	97	* CPU 0-3 -> "f"
	98	* CPU 0-7 -> "ff"
	99	* CPU 4-7 -> "f0"
	100	* CPU 7 -> "80"
	101	* None -> "0"
	102	*
	103	* When there are more than 32 CPUs, separate every 32 CPUs by comma, e.g.
	104	* CPU 0-47 -> "ffff,ffffffff"
	105	* CPU 0-63 -> "ffffffff,ffffffff"
	106	* CPU 0-71 -> "ff,ffffffff,ffffffff" */
	107
	108	for (ssize_t i = a->allocated * 8; i >= 0; i -= 4) {
	109	uint8_t m = 0;
	110
	111	for (size_t j = 0; j < 4; j++)
	112	if (CPU_ISSET_S(i + j, a->allocated, a->set))
	113	m \|= 1U << j;
	114
	115	if (!found_nonzero)
	116	found_nonzero = m > 0;
	117
	118	if (!found_nonzero && m == 0)
	119	/* Skip leading zeros */
	120	continue;
	121
	122	if (!GREEDY_REALLOC(str, len + 3))
	123	return NULL;
	124
	125	str[len++] = hexchar(m);
	126	if (i >= 4 && i % 32 == 0)
	127	/* Separate by comma for each 32 CPUs. */
	128	str[len++] = ',';
	129	str[len] = 0;
	130	}
	131
	132	return TAKE_PTR(str) ?: strdup("0");
	133	}
	134
	135	CPUSet* cpu_set_free(CPUSet *c) {
	136	if (!c)
	137	return c;
	138
	139	cpu_set_reset(c);
	140	return mfree(c);
	141	}
	142
167a776d	143	int cpu_set_realloc(CPUSet *cpu_set, unsigned ncpus) {
0985c7c4 ZJS	144	size_t need;
	145
	146	assert(cpu_set);
	147
	148	need = CPU_ALLOC_SIZE(ncpus);
	149	if (need > cpu_set->allocated) {
	150	cpu_set_t *t;
	151
	152	t = realloc(cpu_set->set, need);
	153	if (!t)
	154	return -ENOMEM;
	155
	156	memzero((uint8_t*) t + cpu_set->allocated, need - cpu_set->allocated);
	157
	158	cpu_set->set = t;
	159	cpu_set->allocated = need;
	160	}
	161
	162	return 0;
	163	}
	164
332d387f	165	int cpu_set_add(CPUSet *cpu_set, unsigned cpu) {
0985c7c4 ZJS	166	int r;
	167
	168	if (cpu >= 8192)
	169	/* As of kernel 5.1, CONFIG_NR_CPUS can be set to 8192 on PowerPC */
	170	return -ERANGE;
	171
	172	r = cpu_set_realloc(cpu_set, cpu + 1);
	173	if (r < 0)
	174	return r;
	175
	176	CPU_SET_S(cpu, cpu_set->allocated, cpu_set->set);
	177	return 0;
	178	}
	179
	180	int cpu_set_add_all(CPUSet a, const CPUSet b) {
	181	int r;
	182
	183	/* Do this backwards, so if we fail, we fail before changing anything. */
	184	for (unsigned cpu_p1 = b->allocated * 8; cpu_p1 > 0; cpu_p1--)
	185	if (CPU_ISSET_S(cpu_p1 - 1, b->allocated, b->set)) {
	186	r = cpu_set_add(a, cpu_p1 - 1);
	187	if (r < 0)
	188	return r;
	189	}
	190
e2b2fb7f	191	return 1;
0985c7c4 ZJS	192	}
	193
	194	int parse_cpu_set_full(
618234a5	195	const char *rvalue,
0985c7c4	196	CPUSet *cpu_set,
6d8a29b2	197	bool warn,
618234a5 LP	198	const char *unit,
	199	const char *filename,
	200	unsigned line,
	201	const char *lvalue) {
	202
0985c7c4	203	_cleanup_(cpu_set_reset) CPUSet c = {};
99534007	204	const char *p = ASSERT_PTR(rvalue);
618234a5	205
cfc28ee2 DT	206	assert(cpu_set);
cfc28ee2 DT	207
618234a5 LP	208	for (;;) {
618234a5 LP	209	_cleanup_free_ char *word = NULL;
0985c7c4	210	unsigned cpu_lower, cpu_upper;
618234a5 LP	211	int r;
618234a5 LP	212
4ec85141	213	r = extract_first_word(&p, &word, WHITESPACE ",", EXTRACT_UNQUOTE);
6d8a29b2 YW	214	if (r == -ENOMEM)
6d8a29b2 YW	215	return warn ? log_oom() : -ENOMEM;
a26662ce	216	if (r < 0)
6d8a29b2	217	return warn ? log_syntax(unit, LOG_ERR, filename, line, r, "Invalid value for %s: %s", lvalue, rvalue) : r;
618234a5 LP	218	if (r == 0)
	219	break;
	220
a26662ce FB	221	r = parse_range(word, &cpu_lower, &cpu_upper);
a26662ce FB	222	if (r < 0)
6d8a29b2	223	return warn ? log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse CPU affinity '%s'", word) : r;
032cf8e4	224
6d8a29b2 YW	225	if (cpu_lower > cpu_upper) {
6d8a29b2 YW	226	if (warn)
0985c7c4 ZJS	227	log_syntax(unit, LOG_WARNING, filename, line, 0, "Range '%s' is invalid, %u > %u, ignoring.",
	228	word, cpu_lower, cpu_upper);
	229
	230	/* Make sure something is allocated, to distinguish this from the empty case */
	231	r = cpu_set_realloc(&c, 1);
	232	if (r < 0)
	233	return r;
032cf8e4 YW	234	}
032cf8e4 YW	235
0985c7c4 ZJS	236	for (unsigned cpu_p1 = MIN(cpu_upper, UINT_MAX-1) + 1; cpu_p1 > cpu_lower; cpu_p1--) {
	237	r = cpu_set_add(&c, cpu_p1 - 1);
	238	if (r < 0)
	239	return warn ? log_syntax(unit, LOG_ERR, filename, line, r,
	240	"Cannot add CPU %u to set: %m", cpu_p1 - 1) : r;
	241	}
032cf8e4 YW	242	}
032cf8e4 YW	243
088d71f8	244	*cpu_set = TAKE_STRUCT(c);
0985c7c4 ZJS	245
	246	return 0;
	247	}
	248
	249	int parse_cpu_set_extend(
	250	const char *rvalue,
	251	CPUSet *old,
	252	bool warn,
	253	const char *unit,
	254	const char *filename,
	255	unsigned line,
	256	const char *lvalue) {
	257
	258	_cleanup_(cpu_set_reset) CPUSet cpuset = {};
	259	int r;
	260
cfc28ee2 DT	261	assert(old);
cfc28ee2 DT	262
0985c7c4 ZJS	263	r = parse_cpu_set_full(rvalue, &cpuset, true, unit, filename, line, lvalue);
	264	if (r < 0)
	265	return r;
	266
	267	if (!cpuset.set) {
	268	/* An empty assignment resets the CPU list */
	269	cpu_set_reset(old);
	270	return 0;
	271	}
	272
	273	if (!old->set) {
088d71f8	274	*old = TAKE_STRUCT(cpuset);
e2b2fb7f	275	return 1;
0985c7c4	276	}
032cf8e4	277
0985c7c4	278	return cpu_set_add_all(old, &cpuset);
032cf8e4	279	}
f44b3035 ZJS	280
	281	int cpus_in_affinity_mask(void) {
	282	size_t n = 16;
	283	int r;
	284
	285	for (;;) {
	286	cpu_set_t *c;
	287
	288	c = CPU_ALLOC(n);
	289	if (!c)
	290	return -ENOMEM;
	291
	292	if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), c) >= 0) {
	293	int k;
	294
	295	k = CPU_COUNT_S(CPU_ALLOC_SIZE(n), c);
	296	CPU_FREE(c);
	297
	298	if (k <= 0)
	299	return -EINVAL;
	300
	301	return k;
	302	}
	303
	304	r = -errno;
	305	CPU_FREE(c);
	306
	307	if (r != -EINVAL)
	308	return r;
	309	if (n > SIZE_MAX/2)
	310	return -ENOMEM;
	311	n *= 2;
	312	}
	313	}
c367f996 MS	314
	315	int cpu_set_to_dbus(const CPUSet set, uint8_t ret, size_t allocated) {
	316	uint8_t *out;
	317
	318	assert(set);
	319	assert(ret);
	320
	321	out = new0(uint8_t, set->allocated);
	322	if (!out)
	323	return -ENOMEM;
	324
	325	for (unsigned cpu = 0; cpu < set->allocated * 8; cpu++)
	326	if (CPU_ISSET_S(cpu, set->allocated, set->set))
	327	out[cpu / 8] \|= 1u << (cpu % 8);
	328
	329	*ret = out;
	330	*allocated = set->allocated;
	331	return 0;
	332	}
	333
	334	int cpu_set_from_dbus(const uint8_t bits, size_t size, CPUSet set) {
	335	_cleanup_(cpu_set_reset) CPUSet s = {};
	336	int r;
	337
	338	assert(bits);
	339	assert(set);
	340
	341	for (unsigned cpu = size * 8; cpu > 0; cpu--)
	342	if (bits[(cpu - 1) / 8] & (1u << ((cpu - 1) % 8))) {
	343	r = cpu_set_add(&s, cpu - 1);
	344	if (r < 0)
	345	return r;
	346	}
	347
088d71f8	348	*set = TAKE_STRUCT(s);
c367f996 MS	349	return 0;
c367f996 MS	350	}
0f30bf58 RRZ	351
	352	int cpu_mask_add_all(CPUSet *mask) {
	353	long m;
	354	int r;
	355
	356	assert(mask);
	357
	358	m = sysconf(_SC_NPROCESSORS_ONLN);
	359	if (m < 0)
	360	return -errno;
	361
	362	for (unsigned i = 0; i < (unsigned) m; i++) {
	363	r = cpu_set_add(mask, i);
	364	if (r < 0)
	365	return r;
	366	}
	367
	368	return 0;
	369	}