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 }