Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk/stdinc.h"
7 : : #include "spdk/cpuset.h"
8 : :
9 : : #include "spdk_internal/cunit.h"
10 : :
11 : : #include "util/cpuset.c"
12 : :
13 : : static int
14 : 105 : cpuset_check_range(struct spdk_cpuset *core_mask, uint32_t min, uint32_t max, bool isset)
15 : : {
16 : : uint32_t core;
17 [ + + ]: 49233 : for (core = min; core <= max; core++) {
18 [ - + ]: 49128 : if (isset != spdk_cpuset_get_cpu(core_mask, core)) {
19 : 0 : return -1;
20 : : }
21 : : }
22 : 105 : return 0;
23 : : }
24 : :
25 : : static void
26 : 3 : test_cpuset(void)
27 : : {
28 : : uint32_t cpu;
29 : 3 : struct spdk_cpuset *set = spdk_cpuset_alloc();
30 : :
31 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(set != NULL);
32 : 3 : CU_ASSERT(spdk_cpuset_count(set) == 0);
33 : :
34 : : /* Set cpu 0 */
35 : 3 : spdk_cpuset_set_cpu(set, 0, true);
36 : 3 : CU_ASSERT(spdk_cpuset_get_cpu(set, 0) == true);
37 : 3 : CU_ASSERT(cpuset_check_range(set, 1, SPDK_CPUSET_SIZE - 1, false) == 0);
38 : 3 : CU_ASSERT(spdk_cpuset_count(set) == 1);
39 : :
40 : : /* Set last cpu (cpu 0 already set) */
41 : 3 : spdk_cpuset_set_cpu(set, SPDK_CPUSET_SIZE - 1, true);
42 : 3 : CU_ASSERT(spdk_cpuset_get_cpu(set, 0) == true);
43 : 3 : CU_ASSERT(spdk_cpuset_get_cpu(set, SPDK_CPUSET_SIZE - 1) == true);
44 : 3 : CU_ASSERT(cpuset_check_range(set, 1, SPDK_CPUSET_SIZE - 2, false) == 0);
45 : 3 : CU_ASSERT(spdk_cpuset_count(set) == 2);
46 : :
47 : : /* Clear cpu 0 (last cpu already set) */
48 : 3 : spdk_cpuset_set_cpu(set, 0, false);
49 : 3 : CU_ASSERT(spdk_cpuset_get_cpu(set, 0) == false);
50 : 3 : CU_ASSERT(cpuset_check_range(set, 1, SPDK_CPUSET_SIZE - 2, false) == 0);
51 : 3 : CU_ASSERT(spdk_cpuset_get_cpu(set, SPDK_CPUSET_SIZE - 1) == true);
52 : 3 : CU_ASSERT(spdk_cpuset_count(set) == 1);
53 : :
54 : : /* Set middle cpu (last cpu already set) */
55 : 3 : cpu = (SPDK_CPUSET_SIZE - 1) / 2;
56 : 3 : spdk_cpuset_set_cpu(set, cpu, true);
57 : 3 : CU_ASSERT(spdk_cpuset_get_cpu(set, cpu) == true);
58 : 3 : CU_ASSERT(spdk_cpuset_get_cpu(set, SPDK_CPUSET_SIZE - 1) == true);
59 : 3 : CU_ASSERT(cpuset_check_range(set, 1, cpu - 1, false) == 0);
60 : 3 : CU_ASSERT(cpuset_check_range(set, cpu + 1, SPDK_CPUSET_SIZE - 2, false) == 0);
61 : 3 : CU_ASSERT(spdk_cpuset_count(set) == 2);
62 : :
63 : : /* Set all cpus */
64 [ + + ]: 3075 : for (cpu = 0; cpu < SPDK_CPUSET_SIZE; cpu++) {
65 : 3072 : spdk_cpuset_set_cpu(set, cpu, true);
66 : : }
67 : 3 : CU_ASSERT(cpuset_check_range(set, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
68 : 3 : CU_ASSERT(spdk_cpuset_count(set) == SPDK_CPUSET_SIZE);
69 : :
70 : : /* Clear all cpus */
71 : 3 : spdk_cpuset_zero(set);
72 : 3 : CU_ASSERT(cpuset_check_range(set, 0, SPDK_CPUSET_SIZE - 1, false) == 0);
73 : 3 : CU_ASSERT(spdk_cpuset_count(set) == 0);
74 : :
75 : 3 : spdk_cpuset_free(set);
76 : 3 : }
77 : :
78 : : static void
79 : 3 : test_cpuset_parse(void)
80 : : {
81 : : int rc;
82 : : struct spdk_cpuset *core_mask;
83 : 3 : char buf[1024];
84 : :
85 : 3 : core_mask = spdk_cpuset_alloc();
86 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(core_mask != NULL);
87 : :
88 : : /* Only core 0 should be set */
89 : 3 : rc = spdk_cpuset_parse(core_mask, "0x1");
90 : 3 : CU_ASSERT(rc >= 0);
91 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, 0, true) == 0);
92 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 1, SPDK_CPUSET_SIZE - 1, false) == 0);
93 : :
94 : : /* Only core 1 should be set */
95 : 3 : rc = spdk_cpuset_parse(core_mask, "[1]");
96 : 3 : CU_ASSERT(rc >= 0);
97 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, 0, false) == 0);
98 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 1, 1, true) == 0);
99 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 2, SPDK_CPUSET_SIZE - 1, false) == 0);
100 : :
101 : : /* Set cores 0-10,12,128-254 */
102 : 3 : rc = spdk_cpuset_parse(core_mask, "[0-10,12,128-254]");
103 : 3 : CU_ASSERT(rc >= 0);
104 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, 10, true) == 0);
105 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 11, 11, false) == 0);
106 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 12, 12, true) == 0);
107 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 13, 127, false) == 0);
108 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 128, 254, true) == 0);
109 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 255, SPDK_CPUSET_SIZE - 1, false) == 0);
110 : :
111 : : /* Set all cores */
112 : 3 : snprintf(buf, sizeof(buf), "[0-%d]", SPDK_CPUSET_SIZE - 1);
113 : 3 : rc = spdk_cpuset_parse(core_mask, buf);
114 : 3 : CU_ASSERT(rc >= 0);
115 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
116 : :
117 : : /* Null parameters not allowed */
118 : 3 : rc = spdk_cpuset_parse(core_mask, NULL);
119 : 3 : CU_ASSERT(rc < 0);
120 : :
121 : 3 : rc = spdk_cpuset_parse(NULL, "[1]");
122 : 3 : CU_ASSERT(rc < 0);
123 : :
124 : : /* Wrong formatted core lists */
125 : 3 : rc = spdk_cpuset_parse(core_mask, "");
126 : 3 : CU_ASSERT(rc < 0);
127 : :
128 : 3 : rc = spdk_cpuset_parse(core_mask, "[");
129 : 3 : CU_ASSERT(rc < 0);
130 : :
131 : 3 : rc = spdk_cpuset_parse(core_mask, "[]");
132 : 3 : CU_ASSERT(rc < 0);
133 : :
134 : 3 : rc = spdk_cpuset_parse(core_mask, "[10--11]");
135 : 3 : CU_ASSERT(rc < 0);
136 : :
137 : 3 : rc = spdk_cpuset_parse(core_mask, "[11-10]");
138 : 3 : CU_ASSERT(rc < 0);
139 : :
140 : 3 : rc = spdk_cpuset_parse(core_mask, "[10-11,]");
141 : 3 : CU_ASSERT(rc < 0);
142 : :
143 : 3 : rc = spdk_cpuset_parse(core_mask, "[,10-11]");
144 : 3 : CU_ASSERT(rc < 0);
145 : :
146 : : /* Out of range value */
147 : 3 : snprintf(buf, sizeof(buf), "[%d]", SPDK_CPUSET_SIZE + 1);
148 : 3 : rc = spdk_cpuset_parse(core_mask, buf);
149 : 3 : CU_ASSERT(rc < 0);
150 : :
151 : : /* Overflow value (UINT64_MAX * 10) */
152 : 3 : rc = spdk_cpuset_parse(core_mask, "[184467440737095516150]");
153 : 3 : CU_ASSERT(rc < 0);
154 : :
155 : : /* Test mask with cores 4-7 and 168-171 set. */
156 : 3 : rc = spdk_cpuset_parse(core_mask, "0xF0000000000000000000000000000000000000000F0");
157 : 3 : CU_ASSERT(rc == 0);
158 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, 3, false) == 0);
159 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 4, 7, true) == 0);
160 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 8, 167, false) == 0);
161 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 168, 171, true) == 0);
162 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 172, SPDK_CPUSET_SIZE - 1, false) == 0);
163 : :
164 : : /* Test masks with commas. The commas should be ignored by cpuset, to
165 : : * allow using spdk_cpuset_parse() with Linux kernel sysfs strings
166 : : * that insert commas for readability purposes.
167 : : */
168 : 3 : rc = spdk_cpuset_parse(core_mask, "FF,FF0000FF,00000000");
169 : 3 : CU_ASSERT(rc == 0);
170 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, 31, false) == 0);
171 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 32, 39, true) == 0);
172 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 40, 55, false) == 0);
173 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 56, 71, true) == 0);
174 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 72, SPDK_CPUSET_SIZE - 1, false) == 0);
175 : :
176 : : /* Test masks with random commas. We just ignore the commas, cpuset
177 : : * should not try to validate that commas are only in certain positions.
178 : : */
179 : 3 : rc = spdk_cpuset_parse(core_mask, ",,,,,000,,1,0,0,,,,");
180 : 3 : CU_ASSERT(rc == 0);
181 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, 7, false) == 0);
182 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 8, 8, true) == 0);
183 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 9, SPDK_CPUSET_SIZE - 1, false) == 0);
184 : :
185 : 3 : spdk_cpuset_free(core_mask);
186 : 3 : }
187 : :
188 : : static void
189 : 3 : test_cpuset_fmt(void)
190 : : {
191 : : int i;
192 : : uint32_t lcore;
193 : 3 : struct spdk_cpuset *core_mask = spdk_cpuset_alloc();
194 : : const char *hex_mask;
195 : 3 : char hex_mask_ref[SPDK_CPUSET_SIZE / 4 + 1];
196 : :
197 : : /* Clear coremask. hex_mask should be "0" */
198 : 3 : spdk_cpuset_zero(core_mask);
199 : 3 : hex_mask = spdk_cpuset_fmt(core_mask);
200 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(hex_mask != NULL);
201 [ - + ]: 3 : CU_ASSERT(strcmp("0", hex_mask) == 0);
202 : :
203 : : /* Set coremask 0x51234. Result should be "51234" */
204 : 3 : spdk_cpuset_zero(core_mask);
205 : 3 : spdk_cpuset_set_cpu(core_mask, 2, true);
206 : 3 : spdk_cpuset_set_cpu(core_mask, 4, true);
207 : 3 : spdk_cpuset_set_cpu(core_mask, 5, true);
208 : 3 : spdk_cpuset_set_cpu(core_mask, 9, true);
209 : 3 : spdk_cpuset_set_cpu(core_mask, 12, true);
210 : 3 : spdk_cpuset_set_cpu(core_mask, 16, true);
211 : 3 : spdk_cpuset_set_cpu(core_mask, 18, true);
212 : 3 : hex_mask = spdk_cpuset_fmt(core_mask);
213 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(hex_mask != NULL);
214 [ - + ]: 3 : CU_ASSERT(strcmp("51234", hex_mask) == 0);
215 : :
216 : : /* Set all cores */
217 : 3 : spdk_cpuset_zero(core_mask);
218 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, false) == 0);
219 : :
220 [ + + ]: 3075 : for (lcore = 0; lcore < SPDK_CPUSET_SIZE; lcore++) {
221 : 3072 : spdk_cpuset_set_cpu(core_mask, lcore, true);
222 : : }
223 [ + + ]: 771 : for (i = 0; i < SPDK_CPUSET_SIZE / 4; i++) {
224 : 768 : hex_mask_ref[i] = 'f';
225 : : }
226 : 3 : hex_mask_ref[SPDK_CPUSET_SIZE / 4] = '\0';
227 : :
228 : : /* Check data before format */
229 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
230 : :
231 : 3 : hex_mask = spdk_cpuset_fmt(core_mask);
232 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(hex_mask != NULL);
233 [ - + ]: 3 : CU_ASSERT(strcmp(hex_mask_ref, hex_mask) == 0);
234 : :
235 : : /* Check data integrity after format */
236 : 3 : CU_ASSERT(cpuset_check_range(core_mask, 0, SPDK_CPUSET_SIZE - 1, true) == 0);
237 : :
238 : 3 : spdk_cpuset_free(core_mask);
239 : 3 : }
240 : :
241 : : static void
242 : 39 : set_bit(void *ctx, uint32_t cpu)
243 : : {
244 : 39 : uint64_t *mask = ctx;
245 : :
246 [ - + ]: 39 : SPDK_CU_ASSERT_FATAL(cpu < 64);
247 [ - + ]: 39 : (*mask) |= (1 << cpu);
248 : 39 : }
249 : :
250 : : static void
251 : 3 : test_cpuset_foreach(void)
252 : : {
253 : 3 : struct spdk_cpuset cpuset = {};
254 : 3 : uint64_t mask = 0;
255 : :
256 : 3 : CU_ASSERT(spdk_cpuset_parse(&cpuset, "0xF135704") == 0);
257 : 3 : spdk_cpuset_for_each_cpu(&cpuset, set_bit, &mask);
258 : 3 : CU_ASSERT(mask == 0xF135704);
259 : 3 : }
260 : :
261 : : int
262 : 3 : main(int argc, char **argv)
263 : : {
264 : 3 : CU_pSuite suite = NULL;
265 : : unsigned int num_failures;
266 : :
267 : 3 : CU_initialize_registry();
268 : :
269 : 3 : suite = CU_add_suite("cpuset", NULL, NULL);
270 : :
271 : 3 : CU_ADD_TEST(suite, test_cpuset);
272 : 3 : CU_ADD_TEST(suite, test_cpuset_parse);
273 : 3 : CU_ADD_TEST(suite, test_cpuset_fmt);
274 : 3 : CU_ADD_TEST(suite, test_cpuset_foreach);
275 : :
276 : 3 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
277 : :
278 : 3 : CU_cleanup_registry();
279 : :
280 : 3 : return num_failures;
281 : : }
|