This source file includes following definitions.
- hwloc__dlforeach_cb
- hwloc_plugins_exit
- hwloc_plugins_init
- hwloc_disc_component_type_string
- hwloc_disc_component_register
- hwloc_components_init
- hwloc_backends_init
- hwloc_disc_component_find
- hwloc_disc_component_force_enable
- hwloc_disc_component_try_enable
- hwloc_disc_components_enable_others
- hwloc_components_fini
- hwloc_backend_alloc
- hwloc_backend_disable
- hwloc_backend_enable
- hwloc_backends_is_thissystem
- hwloc_backends_find_callbacks
- hwloc_backends_disable_all
1
2
3
4
5
6
7 #include <private/autogen/config.h>
8 #include <hwloc.h>
9 #include <private/private.h>
10 #include <private/xml.h>
11 #include <private/misc.h>
12
13 #define HWLOC_COMPONENT_STOP_NAME "stop"
14 #define HWLOC_COMPONENT_EXCLUDE_CHAR '-'
15 #define HWLOC_COMPONENT_SEPS ","
16
17
18
19
20
21 static struct hwloc_disc_component * hwloc_disc_components = NULL;
22
23 static unsigned hwloc_components_users = 0;
24
25 static int hwloc_components_verbose = 0;
26 #ifdef HWLOC_HAVE_PLUGINS
27 static int hwloc_plugins_verbose = 0;
28 static const char * hwloc_plugins_blacklist = NULL;
29 #endif
30
31
32
33
34
35
36
37 #ifdef HWLOC_WIN_SYS
38
39
40 #include <windows.h>
41 static LONG hwloc_components_mutex = 0;
42 #define HWLOC_COMPONENTS_LOCK() do { \
43 while (InterlockedCompareExchange(&hwloc_components_mutex, 1, 0) != 0) \
44 SwitchToThread(); \
45 } while (0)
46 #define HWLOC_COMPONENTS_UNLOCK() do { \
47 assert(hwloc_components_mutex == 1); \
48 hwloc_components_mutex = 0; \
49 } while (0)
50
51 #elif defined HWLOC_HAVE_PTHREAD_MUTEX
52
53 #include <pthread.h>
54 static pthread_mutex_t hwloc_components_mutex = PTHREAD_MUTEX_INITIALIZER;
55 #define HWLOC_COMPONENTS_LOCK() pthread_mutex_lock(&hwloc_components_mutex)
56 #define HWLOC_COMPONENTS_UNLOCK() pthread_mutex_unlock(&hwloc_components_mutex)
57
58 #else
59 #error No mutex implementation available
60 #endif
61
62
63 #ifdef HWLOC_HAVE_PLUGINS
64
65 #include <ltdl.h>
66
67
68 static struct hwloc__plugin_desc {
69 char *name;
70 struct hwloc_component *component;
71 char *filename;
72 lt_dlhandle handle;
73 struct hwloc__plugin_desc *next;
74 } *hwloc_plugins = NULL;
75
76 static int
77 hwloc__dlforeach_cb(const char *filename, void *_data __hwloc_attribute_unused)
78 {
79 const char *basename;
80 lt_dlhandle handle;
81 struct hwloc_component *component;
82 struct hwloc__plugin_desc *desc, **prevdesc;
83
84 if (hwloc_plugins_verbose)
85 fprintf(stderr, "Plugin dlforeach found `%s'\n", filename);
86
87 basename = strrchr(filename, '/');
88 if (!basename)
89 basename = filename;
90 else
91 basename++;
92
93 if (hwloc_plugins_blacklist && strstr(hwloc_plugins_blacklist, basename)) {
94 if (hwloc_plugins_verbose)
95 fprintf(stderr, "Plugin `%s' is blacklisted in the environment\n", basename);
96 goto out;
97 }
98
99
100 handle = lt_dlopenext(filename);
101 if (!handle) {
102 if (hwloc_plugins_verbose)
103 fprintf(stderr, "Failed to load plugin: %s\n", lt_dlerror());
104 goto out;
105 }
106
107 {
108 char componentsymbolname[strlen(basename)+10+1];
109 sprintf(componentsymbolname, "%s_component", basename);
110 component = lt_dlsym(handle, componentsymbolname);
111 if (!component) {
112 if (hwloc_plugins_verbose)
113 fprintf(stderr, "Failed to find component symbol `%s'\n",
114 componentsymbolname);
115 goto out_with_handle;
116 }
117 if (component->abi != HWLOC_COMPONENT_ABI) {
118 if (hwloc_plugins_verbose)
119 fprintf(stderr, "Plugin symbol ABI %u instead of %d\n",
120 component->abi, HWLOC_COMPONENT_ABI);
121 goto out_with_handle;
122 }
123 if (hwloc_plugins_verbose)
124 fprintf(stderr, "Plugin contains expected symbol `%s'\n",
125 componentsymbolname);
126 }
127
128 if (HWLOC_COMPONENT_TYPE_DISC == component->type) {
129 if (strncmp(basename, "hwloc_", 6)) {
130 if (hwloc_plugins_verbose)
131 fprintf(stderr, "Plugin name `%s' doesn't match its type DISCOVERY\n", basename);
132 goto out_with_handle;
133 }
134 } else if (HWLOC_COMPONENT_TYPE_XML == component->type) {
135 if (strncmp(basename, "hwloc_xml_", 10)) {
136 if (hwloc_plugins_verbose)
137 fprintf(stderr, "Plugin name `%s' doesn't match its type XML\n", basename);
138 goto out_with_handle;
139 }
140 } else {
141 if (hwloc_plugins_verbose)
142 fprintf(stderr, "Plugin name `%s' has invalid type %u\n",
143 basename, (unsigned) component->type);
144 goto out_with_handle;
145 }
146
147
148 desc = malloc(sizeof(*desc));
149 if (!desc)
150 goto out_with_handle;
151 desc->name = strdup(basename);
152 desc->filename = strdup(filename);
153 desc->component = component;
154 desc->handle = handle;
155 desc->next = NULL;
156 if (hwloc_plugins_verbose)
157 fprintf(stderr, "Plugin descriptor `%s' ready\n", basename);
158
159
160 prevdesc = &hwloc_plugins;
161 while (*prevdesc)
162 prevdesc = &((*prevdesc)->next);
163 *prevdesc = desc;
164 if (hwloc_plugins_verbose)
165 fprintf(stderr, "Plugin descriptor `%s' queued\n", basename);
166 return 0;
167
168 out_with_handle:
169 lt_dlclose(handle);
170 out:
171 return 0;
172 }
173
174 static void
175 hwloc_plugins_exit(void)
176 {
177 struct hwloc__plugin_desc *desc, *next;
178
179 if (hwloc_plugins_verbose)
180 fprintf(stderr, "Closing all plugins\n");
181
182 desc = hwloc_plugins;
183 while (desc) {
184 next = desc->next;
185 lt_dlclose(desc->handle);
186 free(desc->name);
187 free(desc->filename);
188 free(desc);
189 desc = next;
190 }
191 hwloc_plugins = NULL;
192
193 lt_dlexit();
194 }
195
196 static int
197 hwloc_plugins_init(void)
198 {
199 const char *verboseenv;
200 const char *path = HWLOC_PLUGINS_PATH;
201 const char *env;
202 int err;
203
204 verboseenv = getenv("HWLOC_PLUGINS_VERBOSE");
205 hwloc_plugins_verbose = verboseenv ? atoi(verboseenv) : 0;
206
207 hwloc_plugins_blacklist = getenv("HWLOC_PLUGINS_BLACKLIST");
208
209 err = lt_dlinit();
210 if (err)
211 goto out;
212
213 env = getenv("HWLOC_PLUGINS_PATH");
214 if (env)
215 path = env;
216
217 hwloc_plugins = NULL;
218
219 if (hwloc_plugins_verbose)
220 fprintf(stderr, "Starting plugin dlforeach in %s\n", path);
221 err = lt_dlforeachfile(path, hwloc__dlforeach_cb, NULL);
222 if (err)
223 goto out_with_init;
224
225 return 0;
226
227 out_with_init:
228 hwloc_plugins_exit();
229 out:
230 return -1;
231 }
232
233 #endif
234
235 static const char *
236 hwloc_disc_component_type_string(hwloc_disc_component_type_t type)
237 {
238 switch (type) {
239 case HWLOC_DISC_COMPONENT_TYPE_CPU: return "cpu";
240 case HWLOC_DISC_COMPONENT_TYPE_GLOBAL: return "global";
241 case HWLOC_DISC_COMPONENT_TYPE_MISC: return "misc";
242 default: return "**unknown**";
243 }
244 }
245
246 static int
247 hwloc_disc_component_register(struct hwloc_disc_component *component,
248 const char *filename)
249 {
250 struct hwloc_disc_component **prev;
251
252
253 if (!strcmp(component->name, HWLOC_COMPONENT_STOP_NAME)) {
254 if (hwloc_components_verbose)
255 fprintf(stderr, "Cannot register discovery component with reserved name `" HWLOC_COMPONENT_STOP_NAME "'\n");
256 return -1;
257 }
258 if (strchr(component->name, HWLOC_COMPONENT_EXCLUDE_CHAR)
259 || strcspn(component->name, HWLOC_COMPONENT_SEPS) != strlen(component->name)) {
260 if (hwloc_components_verbose)
261 fprintf(stderr, "Cannot register discovery component with name `%s' containing reserved characters `%c" HWLOC_COMPONENT_SEPS "'\n",
262 component->name, HWLOC_COMPONENT_EXCLUDE_CHAR);
263 return -1;
264 }
265
266 switch ((unsigned) component->type) {
267 case HWLOC_DISC_COMPONENT_TYPE_CPU:
268 case HWLOC_DISC_COMPONENT_TYPE_GLOBAL:
269 case HWLOC_DISC_COMPONENT_TYPE_MISC:
270 break;
271 default:
272 fprintf(stderr, "Cannot register discovery component `%s' with unknown type %u\n",
273 component->name, (unsigned) component->type);
274 return -1;
275 }
276
277 prev = &hwloc_disc_components;
278 while (NULL != *prev) {
279 if (!strcmp((*prev)->name, component->name)) {
280
281 if ((*prev)->priority < component->priority) {
282
283 if (hwloc_components_verbose)
284 fprintf(stderr, "Dropping previously registered discovery component `%s', priority %u lower than new one %u\n",
285 (*prev)->name, (*prev)->priority, component->priority);
286 *prev = (*prev)->next;
287 } else {
288
289 if (hwloc_components_verbose)
290 fprintf(stderr, "Ignoring new discovery component `%s', priority %u lower than previously registered one %u\n",
291 component->name, component->priority, (*prev)->priority);
292 return -1;
293 }
294 }
295 prev = &((*prev)->next);
296 }
297 if (hwloc_components_verbose)
298 fprintf(stderr, "Registered %s discovery component `%s' with priority %u (%s%s)\n",
299 hwloc_disc_component_type_string(component->type), component->name, component->priority,
300 filename ? "from plugin " : "statically build", filename ? filename : "");
301
302 prev = &hwloc_disc_components;
303 while (NULL != *prev) {
304 if ((*prev)->priority < component->priority)
305 break;
306 prev = &((*prev)->next);
307 }
308 component->next = *prev;
309 *prev = component;
310 return 0;
311 }
312
313 #include <static-components.h>
314
315 static void (**hwloc_component_finalize_cbs)(unsigned long);
316 static unsigned hwloc_component_finalize_cb_count;
317
318 void
319 hwloc_components_init(void)
320 {
321 #ifdef HWLOC_HAVE_PLUGINS
322 struct hwloc__plugin_desc *desc;
323 #endif
324 const char *verboseenv;
325 unsigned i;
326
327 HWLOC_COMPONENTS_LOCK();
328 assert((unsigned) -1 != hwloc_components_users);
329 if (0 != hwloc_components_users++) {
330 HWLOC_COMPONENTS_UNLOCK();
331 return;
332 }
333
334 verboseenv = getenv("HWLOC_COMPONENTS_VERBOSE");
335 hwloc_components_verbose = verboseenv ? atoi(verboseenv) : 0;
336
337 #ifdef HWLOC_HAVE_PLUGINS
338 hwloc_plugins_init();
339 #endif
340
341 hwloc_component_finalize_cbs = NULL;
342 hwloc_component_finalize_cb_count = 0;
343
344 for(i=0; NULL != hwloc_static_components[i]; i++)
345 hwloc_component_finalize_cb_count++;
346 #ifdef HWLOC_HAVE_PLUGINS
347 for(desc = hwloc_plugins; NULL != desc; desc = desc->next)
348 hwloc_component_finalize_cb_count++;
349 #endif
350 if (hwloc_component_finalize_cb_count) {
351 hwloc_component_finalize_cbs = calloc(hwloc_component_finalize_cb_count,
352 sizeof(*hwloc_component_finalize_cbs));
353 assert(hwloc_component_finalize_cbs);
354
355 hwloc_component_finalize_cb_count = 0;
356 }
357
358
359 for(i=0; NULL != hwloc_static_components[i]; i++) {
360 if (hwloc_static_components[i]->flags) {
361 fprintf(stderr, "Ignoring static component with invalid flags %lx\n",
362 hwloc_static_components[i]->flags);
363 continue;
364 }
365
366
367 if (hwloc_static_components[i]->init && hwloc_static_components[i]->init(0) < 0) {
368 if (hwloc_components_verbose)
369 fprintf(stderr, "Ignoring static component, failed to initialize\n");
370 continue;
371 }
372
373 if (hwloc_static_components[i]->finalize)
374 hwloc_component_finalize_cbs[hwloc_component_finalize_cb_count++] = hwloc_static_components[i]->finalize;
375
376
377 if (HWLOC_COMPONENT_TYPE_DISC == hwloc_static_components[i]->type)
378 hwloc_disc_component_register(hwloc_static_components[i]->data, NULL);
379 else if (HWLOC_COMPONENT_TYPE_XML == hwloc_static_components[i]->type)
380 hwloc_xml_callbacks_register(hwloc_static_components[i]->data);
381 else
382 assert(0);
383 }
384
385
386 #ifdef HWLOC_HAVE_PLUGINS
387 for(desc = hwloc_plugins; NULL != desc; desc = desc->next) {
388 if (desc->component->flags) {
389 fprintf(stderr, "Ignoring plugin `%s' component with invalid flags %lx\n",
390 desc->name, desc->component->flags);
391 continue;
392 }
393
394
395 if (desc->component->init && desc->component->init(0) < 0) {
396 if (hwloc_components_verbose)
397 fprintf(stderr, "Ignoring plugin `%s', failed to initialize\n", desc->name);
398 continue;
399 }
400
401 if (desc->component->finalize)
402 hwloc_component_finalize_cbs[hwloc_component_finalize_cb_count++] = desc->component->finalize;
403
404
405 if (HWLOC_COMPONENT_TYPE_DISC == desc->component->type)
406 hwloc_disc_component_register(desc->component->data, desc->filename);
407 else if (HWLOC_COMPONENT_TYPE_XML == desc->component->type)
408 hwloc_xml_callbacks_register(desc->component->data);
409 else
410 assert(0);
411 }
412 #endif
413
414 HWLOC_COMPONENTS_UNLOCK();
415 }
416
417 void
418 hwloc_backends_init(struct hwloc_topology *topology)
419 {
420 topology->backends = NULL;
421 topology->backend_excludes = 0;
422 }
423
424 static struct hwloc_disc_component *
425 hwloc_disc_component_find(int type ,
426 const char *name )
427 {
428 struct hwloc_disc_component *comp = hwloc_disc_components;
429 while (NULL != comp) {
430 if ((-1 == type || type == (int) comp->type)
431 && (NULL == name || !strcmp(name, comp->name)))
432 return comp;
433 comp = comp->next;
434 }
435 return NULL;
436 }
437
438
439 int
440 hwloc_disc_component_force_enable(struct hwloc_topology *topology,
441 int envvar_forced,
442 int type, const char *name,
443 const void *data1, const void *data2, const void *data3)
444 {
445 struct hwloc_disc_component *comp;
446 struct hwloc_backend *backend;
447
448 if (topology->is_loaded) {
449 errno = EBUSY;
450 return -1;
451 }
452
453 comp = hwloc_disc_component_find(type, name);
454 if (!comp) {
455 errno = ENOSYS;
456 return -1;
457 }
458
459 backend = comp->instantiate(comp, data1, data2, data3);
460 if (backend) {
461 backend->envvar_forced = envvar_forced;
462 if (topology->backends)
463 hwloc_backends_disable_all(topology);
464 return hwloc_backend_enable(topology, backend);
465 } else
466 return -1;
467 }
468
469 static int
470 hwloc_disc_component_try_enable(struct hwloc_topology *topology,
471 struct hwloc_disc_component *comp,
472 const char *comparg,
473 int envvar_forced)
474 {
475 struct hwloc_backend *backend;
476
477 if (topology->backend_excludes & comp->type) {
478 if (hwloc_components_verbose)
479
480
481 fprintf(stderr, "Excluding %s discovery component `%s', conflicts with excludes 0x%x\n",
482 hwloc_disc_component_type_string(comp->type), comp->name, topology->backend_excludes);
483 return -1;
484 }
485
486 backend = comp->instantiate(comp, comparg, NULL, NULL);
487 if (!backend) {
488 if (hwloc_components_verbose || envvar_forced)
489 fprintf(stderr, "Failed to instantiate discovery component `%s'\n", comp->name);
490 return -1;
491 }
492
493 backend->envvar_forced = envvar_forced;
494 return hwloc_backend_enable(topology, backend);
495 }
496
497 void
498 hwloc_disc_components_enable_others(struct hwloc_topology *topology)
499 {
500 struct hwloc_disc_component *comp;
501 struct hwloc_backend *backend;
502 int tryall = 1;
503 const char *_env;
504 char *env;
505
506 _env = getenv("HWLOC_COMPONENTS");
507 env = _env ? strdup(_env) : NULL;
508
509
510 if (env) {
511 char *curenv = env;
512 size_t s;
513
514 while (*curenv) {
515 s = strcspn(curenv, HWLOC_COMPONENT_SEPS);
516 if (s) {
517 char c;
518
519
520 if (!strncmp(curenv, "linuxpci", 8) && s == 8) {
521 curenv[5] = 'i';
522 curenv[6] = 'o';
523 curenv[7] = *HWLOC_COMPONENT_SEPS;
524 } else if (curenv[0] == HWLOC_COMPONENT_EXCLUDE_CHAR && !strncmp(curenv+1, "linuxpci", 8) && s == 9) {
525 curenv[6] = 'i';
526 curenv[7] = 'o';
527 curenv[8] = *HWLOC_COMPONENT_SEPS;
528
529 goto nextname;
530 }
531
532 if (curenv[0] == HWLOC_COMPONENT_EXCLUDE_CHAR)
533 goto nextname;
534
535 if (!strncmp(curenv, HWLOC_COMPONENT_STOP_NAME, s)) {
536 tryall = 0;
537 break;
538 }
539
540
541 c = curenv[s];
542 curenv[s] = '\0';
543
544 comp = hwloc_disc_component_find(-1, curenv);
545 if (comp) {
546 hwloc_disc_component_try_enable(topology, comp, NULL, 1 );
547 } else {
548 fprintf(stderr, "Cannot find discovery component `%s'\n", curenv);
549 }
550
551
552 curenv[s] = c;
553 }
554
555 nextname:
556 curenv += s;
557 if (*curenv)
558
559 curenv++;
560 }
561 }
562
563
564
565
566 if (tryall) {
567 comp = hwloc_disc_components;
568 while (NULL != comp) {
569 if (!comp->enabled_by_default)
570 goto nextcomp;
571
572 if (env) {
573 char *curenv = env;
574 while (*curenv) {
575 size_t s = strcspn(curenv, HWLOC_COMPONENT_SEPS);
576 if (curenv[0] == HWLOC_COMPONENT_EXCLUDE_CHAR && !strncmp(curenv+1, comp->name, s-1) && strlen(comp->name) == s-1) {
577 if (hwloc_components_verbose)
578 fprintf(stderr, "Excluding %s discovery component `%s' because of HWLOC_COMPONENTS environment variable\n",
579 hwloc_disc_component_type_string(comp->type), comp->name);
580 goto nextcomp;
581 }
582 curenv += s;
583 if (*curenv)
584
585 curenv++;
586 }
587 }
588 hwloc_disc_component_try_enable(topology, comp, NULL, 0 );
589 nextcomp:
590 comp = comp->next;
591 }
592 }
593
594 if (hwloc_components_verbose) {
595
596 int first = 1;
597 backend = topology->backends;
598 fprintf(stderr, "Final list of enabled discovery components: ");
599 while (backend != NULL) {
600 fprintf(stderr, "%s%s", first ? "" : ",", backend->component->name);
601 backend = backend->next;
602 first = 0;
603 }
604 fprintf(stderr, "\n");
605 }
606
607 free(env);
608 }
609
610 void
611 hwloc_components_fini(void)
612 {
613 unsigned i;
614
615 HWLOC_COMPONENTS_LOCK();
616 assert(0 != hwloc_components_users);
617 if (0 != --hwloc_components_users) {
618 HWLOC_COMPONENTS_UNLOCK();
619 return;
620 }
621
622 for(i=0; i<hwloc_component_finalize_cb_count; i++)
623 hwloc_component_finalize_cbs[hwloc_component_finalize_cb_count-i-1](0);
624 free(hwloc_component_finalize_cbs);
625 hwloc_component_finalize_cbs = NULL;
626 hwloc_component_finalize_cb_count = 0;
627
628
629
630 hwloc_disc_components = NULL;
631 hwloc_xml_callbacks_reset();
632
633 #ifdef HWLOC_HAVE_PLUGINS
634 hwloc_plugins_exit();
635 #endif
636
637 HWLOC_COMPONENTS_UNLOCK();
638 }
639
640 struct hwloc_backend *
641 hwloc_backend_alloc(struct hwloc_disc_component *component)
642 {
643 struct hwloc_backend * backend = malloc(sizeof(*backend));
644 if (!backend) {
645 errno = ENOMEM;
646 return NULL;
647 }
648 backend->component = component;
649 backend->flags = 0;
650 backend->discover = NULL;
651 backend->get_pci_busid_cpuset = NULL;
652 backend->disable = NULL;
653 backend->is_thissystem = -1;
654 backend->next = NULL;
655 backend->envvar_forced = 0;
656 return backend;
657 }
658
659 static void
660 hwloc_backend_disable(struct hwloc_backend *backend)
661 {
662 if (backend->disable)
663 backend->disable(backend);
664 free(backend);
665 }
666
667 int
668 hwloc_backend_enable(struct hwloc_topology *topology, struct hwloc_backend *backend)
669 {
670 struct hwloc_backend **pprev;
671
672
673 if (backend->flags) {
674 fprintf(stderr, "Cannot enable %s discovery component `%s' with unknown flags %lx\n",
675 hwloc_disc_component_type_string(backend->component->type), backend->component->name, backend->flags);
676 return -1;
677 }
678
679
680 pprev = &topology->backends;
681 while (NULL != *pprev) {
682 if ((*pprev)->component == backend->component) {
683 if (hwloc_components_verbose)
684 fprintf(stderr, "Cannot enable %s discovery component `%s' twice\n",
685 hwloc_disc_component_type_string(backend->component->type), backend->component->name);
686 hwloc_backend_disable(backend);
687 errno = EBUSY;
688 return -1;
689 }
690 pprev = &((*pprev)->next);
691 }
692
693 if (hwloc_components_verbose)
694 fprintf(stderr, "Enabling %s discovery component `%s'\n",
695 hwloc_disc_component_type_string(backend->component->type), backend->component->name);
696
697
698 pprev = &topology->backends;
699 while (NULL != *pprev)
700 pprev = &((*pprev)->next);
701 backend->next = *pprev;
702 *pprev = backend;
703
704 backend->topology = topology;
705 topology->backend_excludes |= backend->component->excludes;
706 return 0;
707 }
708
709 void
710 hwloc_backends_is_thissystem(struct hwloc_topology *topology)
711 {
712 struct hwloc_backend *backend;
713 const char *local_env;
714
715
716
717
718
719
720
721
722 topology->is_thissystem = 1;
723
724
725 backend = topology->backends;
726 while (backend != NULL) {
727 if (backend->envvar_forced == 0 && backend->is_thissystem != -1) {
728 assert(backend->is_thissystem == 0);
729 topology->is_thissystem = 0;
730 }
731 backend = backend->next;
732 }
733
734
735 if (topology->flags & HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM)
736 topology->is_thissystem = 1;
737
738
739 backend = topology->backends;
740 while (backend != NULL) {
741 if (backend->envvar_forced == 1 && backend->is_thissystem != -1) {
742 assert(backend->is_thissystem == 0);
743 topology->is_thissystem = 0;
744 }
745 backend = backend->next;
746 }
747
748
749 local_env = getenv("HWLOC_THISSYSTEM");
750 if (local_env)
751 topology->is_thissystem = atoi(local_env);
752 }
753
754 void
755 hwloc_backends_find_callbacks(struct hwloc_topology *topology)
756 {
757 struct hwloc_backend *backend = topology->backends;
758
759 topology->get_pci_busid_cpuset_backend = NULL;
760 while (backend != NULL) {
761 if (backend->get_pci_busid_cpuset) {
762 topology->get_pci_busid_cpuset_backend = backend;
763 return;
764 }
765 backend = backend->next;
766 }
767 return;
768 }
769
770 void
771 hwloc_backends_disable_all(struct hwloc_topology *topology)
772 {
773 struct hwloc_backend *backend;
774
775 while (NULL != (backend = topology->backends)) {
776 struct hwloc_backend *next = backend->next;
777 if (hwloc_components_verbose)
778 fprintf(stderr, "Disabling %s discovery component `%s'\n",
779 hwloc_disc_component_type_string(backend->component->type), backend->component->name);
780 hwloc_backend_disable(backend);
781 topology->backends = next;
782 }
783 topology->backends = NULL;
784 topology->backend_excludes = 0;
785 }