]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
cd0cfad7 | 2 | #include <api/fs/fs.h> |
a12b51c4 | 3 | #include "cpumap.h" |
5e51b0bb ACM |
4 | #include "debug.h" |
5 | #include "event.h" | |
a12b51c4 | 6 | #include <assert.h> |
76b31a29 | 7 | #include <dirent.h> |
a12b51c4 | 8 | #include <stdio.h> |
86ee6e18 | 9 | #include <stdlib.h> |
f77b57ad | 10 | #include <linux/bitmap.h> |
f30a79b0 | 11 | #include "asm/bug.h" |
a12b51c4 | 12 | |
3052ba56 | 13 | #include <linux/ctype.h> |
7f7c536f | 14 | #include <linux/zalloc.h> |
3d689ed6 | 15 | |
5ac76283 | 16 | static int max_cpu_num; |
92a7e127 | 17 | static int max_present_cpu_num; |
5ac76283 ACM |
18 | static int max_node_num; |
19 | static int *cpunode_map; | |
20 | ||
f854839b | 21 | static struct perf_cpu_map *cpu_map__from_entries(struct cpu_map_entries *cpus) |
f77b57ad | 22 | { |
f854839b | 23 | struct perf_cpu_map *map; |
f77b57ad | 24 | |
315c0a1f | 25 | map = perf_cpu_map__empty_new(cpus->nr); |
f77b57ad JO |
26 | if (map) { |
27 | unsigned i; | |
28 | ||
15d2b995 JO |
29 | for (i = 0; i < cpus->nr; i++) { |
30 | /* | |
31 | * Special treatment for -1, which is not real cpu number, | |
32 | * and we need to use (int) -1 to initialize map[i], | |
33 | * otherwise it would become 65535. | |
34 | */ | |
35 | if (cpus->cpu[i] == (u16) -1) | |
36 | map->map[i] = -1; | |
37 | else | |
38 | map->map[i] = (int) cpus->cpu[i]; | |
39 | } | |
f77b57ad JO |
40 | } |
41 | ||
42 | return map; | |
43 | } | |
44 | ||
72932371 | 45 | static struct perf_cpu_map *cpu_map__from_mask(struct perf_record_record_cpu_map *mask) |
f77b57ad | 46 | { |
f854839b | 47 | struct perf_cpu_map *map; |
f77b57ad JO |
48 | int nr, nbits = mask->nr * mask->long_size * BITS_PER_BYTE; |
49 | ||
50 | nr = bitmap_weight(mask->mask, nbits); | |
51 | ||
315c0a1f | 52 | map = perf_cpu_map__empty_new(nr); |
f77b57ad JO |
53 | if (map) { |
54 | int cpu, i = 0; | |
55 | ||
56 | for_each_set_bit(cpu, mask->mask, nbits) | |
57 | map->map[i++] = cpu; | |
58 | } | |
59 | return map; | |
60 | ||
61 | } | |
62 | ||
72932371 | 63 | struct perf_cpu_map *cpu_map__new_data(struct perf_record_cpu_map_data *data) |
f77b57ad JO |
64 | { |
65 | if (data->type == PERF_CPU_MAP__CPUS) | |
66 | return cpu_map__from_entries((struct cpu_map_entries *)data->data); | |
67 | else | |
72932371 | 68 | return cpu_map__from_mask((struct perf_record_record_cpu_map *)data->data); |
f77b57ad JO |
69 | } |
70 | ||
f854839b | 71 | size_t cpu_map__fprintf(struct perf_cpu_map *map, FILE *fp) |
9ae7d335 | 72 | { |
a24020e6 JO |
73 | #define BUFSIZE 1024 |
74 | char buf[BUFSIZE]; | |
9ae7d335 | 75 | |
a24020e6 JO |
76 | cpu_map__snprint(map, buf, sizeof(buf)); |
77 | return fprintf(fp, "%s\n", buf); | |
78 | #undef BUFSIZE | |
9ae7d335 ACM |
79 | } |
80 | ||
315c0a1f | 81 | struct perf_cpu_map *perf_cpu_map__empty_new(int nr) |
2322f573 | 82 | { |
f854839b | 83 | struct perf_cpu_map *cpus = malloc(sizeof(*cpus) + sizeof(int) * nr); |
2322f573 JO |
84 | |
85 | if (cpus != NULL) { | |
86 | int i; | |
87 | ||
88 | cpus->nr = nr; | |
89 | for (i = 0; i < nr; i++) | |
90 | cpus->map[i] = -1; | |
91 | ||
ec09a42a | 92 | refcount_set(&cpus->refcnt, 1); |
2322f573 JO |
93 | } |
94 | ||
95 | return cpus; | |
96 | } | |
97 | ||
5d8cf721 | 98 | static int cpu__get_topology_int(int cpu, const char *name, int *value) |
5ac59a8a | 99 | { |
5ac59a8a | 100 | char path[PATH_MAX]; |
5ac59a8a | 101 | |
86ee6e18 | 102 | snprintf(path, PATH_MAX, |
5d8cf721 | 103 | "devices/system/cpu/cpu%d/topology/%s", cpu, name); |
5ac59a8a | 104 | |
5d8cf721 ACM |
105 | return sysfs__read_int(path, value); |
106 | } | |
193b6bd3 | 107 | |
5d8cf721 ACM |
108 | int cpu_map__get_socket_id(int cpu) |
109 | { | |
110 | int value, ret = cpu__get_topology_int(cpu, "physical_package_id", &value); | |
111 | return ret ?: value; | |
193b6bd3 KL |
112 | } |
113 | ||
f854839b | 114 | int cpu_map__get_socket(struct perf_cpu_map *map, int idx, void *data __maybe_unused) |
193b6bd3 KL |
115 | { |
116 | int cpu; | |
117 | ||
118 | if (idx > map->nr) | |
119 | return -1; | |
120 | ||
121 | cpu = map->map[idx]; | |
122 | ||
123 | return cpu_map__get_socket_id(cpu); | |
5ac59a8a SE |
124 | } |
125 | ||
86ee6e18 | 126 | static int cmp_ids(const void *a, const void *b) |
5ac59a8a | 127 | { |
86ee6e18 SE |
128 | return *(int *)a - *(int *)b; |
129 | } | |
130 | ||
f854839b JO |
131 | int cpu_map__build_map(struct perf_cpu_map *cpus, struct perf_cpu_map **res, |
132 | int (*f)(struct perf_cpu_map *map, int cpu, void *data), | |
1fe7a300 | 133 | void *data) |
86ee6e18 | 134 | { |
f854839b | 135 | struct perf_cpu_map *c; |
5ac59a8a SE |
136 | int nr = cpus->nr; |
137 | int cpu, s1, s2; | |
138 | ||
86ee6e18 SE |
139 | /* allocate as much as possible */ |
140 | c = calloc(1, sizeof(*c) + nr * sizeof(int)); | |
141 | if (!c) | |
5ac59a8a SE |
142 | return -1; |
143 | ||
144 | for (cpu = 0; cpu < nr; cpu++) { | |
1fe7a300 | 145 | s1 = f(cpus, cpu, data); |
86ee6e18 SE |
146 | for (s2 = 0; s2 < c->nr; s2++) { |
147 | if (s1 == c->map[s2]) | |
5ac59a8a SE |
148 | break; |
149 | } | |
86ee6e18 SE |
150 | if (s2 == c->nr) { |
151 | c->map[c->nr] = s1; | |
152 | c->nr++; | |
5ac59a8a SE |
153 | } |
154 | } | |
86ee6e18 SE |
155 | /* ensure we process id in increasing order */ |
156 | qsort(c->map, c->nr, sizeof(int), cmp_ids); | |
157 | ||
ec09a42a | 158 | refcount_set(&c->refcnt, 1); |
86ee6e18 | 159 | *res = c; |
5ac59a8a SE |
160 | return 0; |
161 | } | |
86ee6e18 | 162 | |
b74d8686 KL |
163 | int cpu_map__get_die_id(int cpu) |
164 | { | |
165 | int value, ret = cpu__get_topology_int(cpu, "die_id", &value); | |
166 | ||
167 | return ret ?: value; | |
168 | } | |
169 | ||
f854839b | 170 | int cpu_map__get_die(struct perf_cpu_map *map, int idx, void *data) |
db5742b6 KL |
171 | { |
172 | int cpu, die_id, s; | |
173 | ||
174 | if (idx > map->nr) | |
175 | return -1; | |
176 | ||
177 | cpu = map->map[idx]; | |
178 | ||
179 | die_id = cpu_map__get_die_id(cpu); | |
180 | /* There is no die_id on legacy system. */ | |
181 | if (die_id == -1) | |
182 | die_id = 0; | |
183 | ||
184 | s = cpu_map__get_socket(map, idx, data); | |
185 | if (s == -1) | |
186 | return -1; | |
187 | ||
188 | /* | |
189 | * Encode socket in bit range 15:8 | |
190 | * die_id is relative to socket, and | |
191 | * we need a global id. So we combine | |
192 | * socket + die id | |
193 | */ | |
194 | if (WARN_ONCE(die_id >> 8, "The die id number is too big.\n")) | |
195 | return -1; | |
196 | ||
197 | if (WARN_ONCE(s >> 8, "The socket id number is too big.\n")) | |
198 | return -1; | |
199 | ||
200 | return (s << 8) | (die_id & 0xff); | |
201 | } | |
202 | ||
193b6bd3 | 203 | int cpu_map__get_core_id(int cpu) |
12c08a9f | 204 | { |
5d8cf721 ACM |
205 | int value, ret = cpu__get_topology_int(cpu, "core_id", &value); |
206 | return ret ?: value; | |
193b6bd3 KL |
207 | } |
208 | ||
86895b48 JO |
209 | int cpu_map__get_node_id(int cpu) |
210 | { | |
211 | return cpu__get_node(cpu); | |
212 | } | |
213 | ||
f854839b | 214 | int cpu_map__get_core(struct perf_cpu_map *map, int idx, void *data) |
193b6bd3 | 215 | { |
db5742b6 | 216 | int cpu, s_die; |
193b6bd3 KL |
217 | |
218 | if (idx > map->nr) | |
12c08a9f SE |
219 | return -1; |
220 | ||
193b6bd3 KL |
221 | cpu = map->map[idx]; |
222 | ||
223 | cpu = cpu_map__get_core_id(cpu); | |
224 | ||
db5742b6 KL |
225 | /* s_die is the combination of socket + die id */ |
226 | s_die = cpu_map__get_die(map, idx, data); | |
227 | if (s_die == -1) | |
12c08a9f SE |
228 | return -1; |
229 | ||
230 | /* | |
db5742b6 KL |
231 | * encode socket in bit range 31:24 |
232 | * encode die id in bit range 23:16 | |
233 | * core_id is relative to socket and die, | |
12c08a9f | 234 | * we need a global id. So we combine |
db5742b6 | 235 | * socket + die id + core id |
12c08a9f | 236 | */ |
db5742b6 KL |
237 | if (WARN_ONCE(cpu >> 16, "The core id number is too big.\n")) |
238 | return -1; | |
239 | ||
240 | return (s_die << 16) | (cpu & 0xffff); | |
12c08a9f SE |
241 | } |
242 | ||
86895b48 JO |
243 | int cpu_map__get_node(struct perf_cpu_map *map, int idx, void *data __maybe_unused) |
244 | { | |
245 | if (idx < 0 || idx >= map->nr) | |
246 | return -1; | |
247 | ||
248 | return cpu_map__get_node_id(map->map[idx]); | |
249 | } | |
250 | ||
f854839b | 251 | int cpu_map__build_socket_map(struct perf_cpu_map *cpus, struct perf_cpu_map **sockp) |
86ee6e18 | 252 | { |
1fe7a300 | 253 | return cpu_map__build_map(cpus, sockp, cpu_map__get_socket, NULL); |
86ee6e18 | 254 | } |
12c08a9f | 255 | |
f854839b | 256 | int cpu_map__build_die_map(struct perf_cpu_map *cpus, struct perf_cpu_map **diep) |
db5742b6 KL |
257 | { |
258 | return cpu_map__build_map(cpus, diep, cpu_map__get_die, NULL); | |
259 | } | |
260 | ||
f854839b | 261 | int cpu_map__build_core_map(struct perf_cpu_map *cpus, struct perf_cpu_map **corep) |
12c08a9f | 262 | { |
1fe7a300 | 263 | return cpu_map__build_map(cpus, corep, cpu_map__get_core, NULL); |
86895b48 JO |
264 | } |
265 | ||
266 | int cpu_map__build_node_map(struct perf_cpu_map *cpus, struct perf_cpu_map **numap) | |
267 | { | |
268 | return cpu_map__build_map(cpus, numap, cpu_map__get_node, NULL); | |
12c08a9f | 269 | } |
7780c25b DZ |
270 | |
271 | /* setup simple routines to easily access node numbers given a cpu number */ | |
272 | static int get_max_num(char *path, int *max) | |
273 | { | |
274 | size_t num; | |
275 | char *buf; | |
276 | int err = 0; | |
277 | ||
278 | if (filename__read_str(path, &buf, &num)) | |
279 | return -1; | |
280 | ||
281 | buf[num] = '\0'; | |
282 | ||
283 | /* start on the right, to find highest node num */ | |
284 | while (--num) { | |
285 | if ((buf[num] == ',') || (buf[num] == '-')) { | |
286 | num++; | |
287 | break; | |
288 | } | |
289 | } | |
290 | if (sscanf(&buf[num], "%d", max) < 1) { | |
291 | err = -1; | |
292 | goto out; | |
293 | } | |
294 | ||
295 | /* convert from 0-based to 1-based */ | |
296 | (*max)++; | |
297 | ||
298 | out: | |
299 | free(buf); | |
300 | return err; | |
301 | } | |
302 | ||
303 | /* Determine highest possible cpu in the system for sparse allocation */ | |
304 | static void set_max_cpu_num(void) | |
305 | { | |
306 | const char *mnt; | |
307 | char path[PATH_MAX]; | |
308 | int ret = -1; | |
309 | ||
310 | /* set up default */ | |
311 | max_cpu_num = 4096; | |
92a7e127 | 312 | max_present_cpu_num = 4096; |
7780c25b DZ |
313 | |
314 | mnt = sysfs__mountpoint(); | |
315 | if (!mnt) | |
316 | goto out; | |
317 | ||
318 | /* get the highest possible cpu number for a sparse allocation */ | |
f5b1f4e4 | 319 | ret = snprintf(path, PATH_MAX, "%s/devices/system/cpu/possible", mnt); |
7780c25b DZ |
320 | if (ret == PATH_MAX) { |
321 | pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX); | |
322 | goto out; | |
323 | } | |
324 | ||
325 | ret = get_max_num(path, &max_cpu_num); | |
92a7e127 JS |
326 | if (ret) |
327 | goto out; | |
328 | ||
329 | /* get the highest present cpu number for a sparse allocation */ | |
330 | ret = snprintf(path, PATH_MAX, "%s/devices/system/cpu/present", mnt); | |
331 | if (ret == PATH_MAX) { | |
332 | pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX); | |
333 | goto out; | |
334 | } | |
335 | ||
336 | ret = get_max_num(path, &max_present_cpu_num); | |
7780c25b DZ |
337 | |
338 | out: | |
339 | if (ret) | |
340 | pr_err("Failed to read max cpus, using default of %d\n", max_cpu_num); | |
341 | } | |
342 | ||
343 | /* Determine highest possible node in the system for sparse allocation */ | |
344 | static void set_max_node_num(void) | |
345 | { | |
346 | const char *mnt; | |
347 | char path[PATH_MAX]; | |
348 | int ret = -1; | |
349 | ||
350 | /* set up default */ | |
351 | max_node_num = 8; | |
352 | ||
353 | mnt = sysfs__mountpoint(); | |
354 | if (!mnt) | |
355 | goto out; | |
356 | ||
357 | /* get the highest possible cpu number for a sparse allocation */ | |
358 | ret = snprintf(path, PATH_MAX, "%s/devices/system/node/possible", mnt); | |
359 | if (ret == PATH_MAX) { | |
360 | pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX); | |
361 | goto out; | |
362 | } | |
363 | ||
364 | ret = get_max_num(path, &max_node_num); | |
365 | ||
366 | out: | |
367 | if (ret) | |
368 | pr_err("Failed to read max nodes, using default of %d\n", max_node_num); | |
369 | } | |
370 | ||
5ac76283 ACM |
371 | int cpu__max_node(void) |
372 | { | |
373 | if (unlikely(!max_node_num)) | |
374 | set_max_node_num(); | |
375 | ||
376 | return max_node_num; | |
377 | } | |
378 | ||
379 | int cpu__max_cpu(void) | |
380 | { | |
381 | if (unlikely(!max_cpu_num)) | |
382 | set_max_cpu_num(); | |
383 | ||
384 | return max_cpu_num; | |
385 | } | |
386 | ||
92a7e127 JS |
387 | int cpu__max_present_cpu(void) |
388 | { | |
389 | if (unlikely(!max_present_cpu_num)) | |
390 | set_max_cpu_num(); | |
391 | ||
392 | return max_present_cpu_num; | |
393 | } | |
394 | ||
395 | ||
5ac76283 ACM |
396 | int cpu__get_node(int cpu) |
397 | { | |
398 | if (unlikely(cpunode_map == NULL)) { | |
399 | pr_debug("cpu_map not initialized\n"); | |
400 | return -1; | |
401 | } | |
402 | ||
403 | return cpunode_map[cpu]; | |
404 | } | |
405 | ||
7780c25b DZ |
406 | static int init_cpunode_map(void) |
407 | { | |
408 | int i; | |
409 | ||
410 | set_max_cpu_num(); | |
411 | set_max_node_num(); | |
412 | ||
413 | cpunode_map = calloc(max_cpu_num, sizeof(int)); | |
414 | if (!cpunode_map) { | |
415 | pr_err("%s: calloc failed\n", __func__); | |
416 | return -1; | |
417 | } | |
418 | ||
419 | for (i = 0; i < max_cpu_num; i++) | |
420 | cpunode_map[i] = -1; | |
421 | ||
422 | return 0; | |
423 | } | |
424 | ||
425 | int cpu__setup_cpunode_map(void) | |
426 | { | |
427 | struct dirent *dent1, *dent2; | |
428 | DIR *dir1, *dir2; | |
429 | unsigned int cpu, mem; | |
430 | char buf[PATH_MAX]; | |
431 | char path[PATH_MAX]; | |
432 | const char *mnt; | |
433 | int n; | |
434 | ||
435 | /* initialize globals */ | |
436 | if (init_cpunode_map()) | |
437 | return -1; | |
438 | ||
439 | mnt = sysfs__mountpoint(); | |
440 | if (!mnt) | |
441 | return 0; | |
442 | ||
443 | n = snprintf(path, PATH_MAX, "%s/devices/system/node", mnt); | |
444 | if (n == PATH_MAX) { | |
445 | pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX); | |
446 | return -1; | |
447 | } | |
448 | ||
449 | dir1 = opendir(path); | |
450 | if (!dir1) | |
451 | return 0; | |
452 | ||
453 | /* walk tree and setup map */ | |
454 | while ((dent1 = readdir(dir1)) != NULL) { | |
455 | if (dent1->d_type != DT_DIR || sscanf(dent1->d_name, "node%u", &mem) < 1) | |
456 | continue; | |
457 | ||
458 | n = snprintf(buf, PATH_MAX, "%s/%s", path, dent1->d_name); | |
459 | if (n == PATH_MAX) { | |
460 | pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX); | |
461 | continue; | |
462 | } | |
463 | ||
464 | dir2 = opendir(buf); | |
465 | if (!dir2) | |
466 | continue; | |
467 | while ((dent2 = readdir(dir2)) != NULL) { | |
468 | if (dent2->d_type != DT_LNK || sscanf(dent2->d_name, "cpu%u", &cpu) < 1) | |
469 | continue; | |
470 | cpunode_map[cpu] = mem; | |
471 | } | |
472 | closedir(dir2); | |
473 | } | |
474 | closedir(dir1); | |
475 | return 0; | |
476 | } | |
e632aa69 | 477 | |
f854839b | 478 | bool cpu_map__has(struct perf_cpu_map *cpus, int cpu) |
9a6c582d | 479 | { |
b4df75de | 480 | return perf_cpu_map__idx(cpus, cpu) != -1; |
9a6c582d MR |
481 | } |
482 | ||
f854839b | 483 | int cpu_map__cpu(struct perf_cpu_map *cpus, int idx) |
9a6c582d MR |
484 | { |
485 | return cpus->map[idx]; | |
e632aa69 | 486 | } |
a24020e6 | 487 | |
f854839b | 488 | size_t cpu_map__snprint(struct perf_cpu_map *map, char *buf, size_t size) |
a24020e6 JO |
489 | { |
490 | int i, cpu, start = -1; | |
491 | bool first = true; | |
492 | size_t ret = 0; | |
493 | ||
494 | #define COMMA first ? "" : "," | |
495 | ||
496 | for (i = 0; i < map->nr + 1; i++) { | |
497 | bool last = i == map->nr; | |
498 | ||
499 | cpu = last ? INT_MAX : map->map[i]; | |
500 | ||
501 | if (start == -1) { | |
502 | start = i; | |
503 | if (last) { | |
504 | ret += snprintf(buf + ret, size - ret, | |
505 | "%s%d", COMMA, | |
506 | map->map[i]); | |
507 | } | |
508 | } else if (((i - start) != (cpu - map->map[start])) || last) { | |
509 | int end = i - 1; | |
510 | ||
511 | if (start == end) { | |
512 | ret += snprintf(buf + ret, size - ret, | |
513 | "%s%d", COMMA, | |
514 | map->map[start]); | |
515 | } else { | |
516 | ret += snprintf(buf + ret, size - ret, | |
517 | "%s%d-%d", COMMA, | |
518 | map->map[start], map->map[end]); | |
519 | } | |
520 | first = false; | |
521 | start = i; | |
522 | } | |
523 | } | |
524 | ||
525 | #undef COMMA | |
526 | ||
deb83da1 | 527 | pr_debug2("cpumask list: %s\n", buf); |
a24020e6 JO |
528 | return ret; |
529 | } | |
4400ac8a NK |
530 | |
531 | static char hex_char(unsigned char val) | |
532 | { | |
533 | if (val < 10) | |
534 | return val + '0'; | |
535 | if (val < 16) | |
536 | return val - 10 + 'a'; | |
537 | return '?'; | |
538 | } | |
539 | ||
f854839b | 540 | size_t cpu_map__snprint_mask(struct perf_cpu_map *map, char *buf, size_t size) |
4400ac8a NK |
541 | { |
542 | int i, cpu; | |
543 | char *ptr = buf; | |
544 | unsigned char *bitmap; | |
545 | int last_cpu = cpu_map__cpu(map, map->nr - 1); | |
546 | ||
5f5e25f1 HZ |
547 | if (buf == NULL) |
548 | return 0; | |
549 | ||
550 | bitmap = zalloc(last_cpu / 8 + 1); | |
4400ac8a NK |
551 | if (bitmap == NULL) { |
552 | buf[0] = '\0'; | |
553 | return 0; | |
554 | } | |
555 | ||
556 | for (i = 0; i < map->nr; i++) { | |
557 | cpu = cpu_map__cpu(map, i); | |
558 | bitmap[cpu / 8] |= 1 << (cpu % 8); | |
559 | } | |
560 | ||
561 | for (cpu = last_cpu / 4 * 4; cpu >= 0; cpu -= 4) { | |
562 | unsigned char bits = bitmap[cpu / 8]; | |
563 | ||
564 | if (cpu % 8) | |
565 | bits >>= 4; | |
566 | else | |
567 | bits &= 0xf; | |
568 | ||
569 | *ptr++ = hex_char(bits); | |
570 | if ((cpu % 32) == 0 && cpu > 0) | |
571 | *ptr++ = ','; | |
572 | } | |
573 | *ptr = '\0'; | |
574 | free(bitmap); | |
575 | ||
576 | buf[size - 1] = '\0'; | |
577 | return ptr - buf; | |
578 | } | |
f13de660 | 579 | |
f854839b | 580 | const struct perf_cpu_map *cpu_map__online(void) /* thread unsafe */ |
f13de660 | 581 | { |
f854839b | 582 | static const struct perf_cpu_map *online = NULL; |
f13de660 AB |
583 | |
584 | if (!online) | |
9c3516d1 | 585 | online = perf_cpu_map__new(NULL); /* from /sys/devices/system/cpu/online */ |
f13de660 AB |
586 | |
587 | return online; | |
588 | } |