/* * Initialize the repository */ int mca_base_component_repository_init(void) { /* Setup internal structures */ if (!initialized) { #if OPAL_WANT_LIBLTDL /* Initialize libltdl */ if (lt_dlinit() != 0) { return OPAL_ERR_OUT_OF_RESOURCE; } #if OPAL_HAVE_LTDL_ADVISE if (lt_dladvise_init(&opal_mca_dladvise)) { return OPAL_ERR_OUT_OF_RESOURCE; } if (lt_dladvise_ext(&opal_mca_dladvise)) { return OPAL_ERROR; } if (lt_dladvise_global(&opal_mca_dladvise)) { return OPAL_ERROR; } #endif OBJ_CONSTRUCT(&repository, opal_list_t); #endif initialized = true; } /* All done */ return OPAL_SUCCESS; }
/* * (Try to) load the shared object `file'. Won't complain if it isn't a shared * object, but it will bitch about a shared object not having a * ``module_register'' symbol.. */ static int plugin_load_file (char *file, uint32_t flags) { lt_dlhandle dlh; void (*reg_handle) (void); lt_dlinit (); lt_dlerror (); /* clear errors */ #if LIBTOOL_VERSION == 2 if (flags & PLUGIN_FLAGS_GLOBAL) { lt_dladvise advise; lt_dladvise_init(&advise); lt_dladvise_global(&advise); dlh = lt_dlopenadvise(file, advise); lt_dladvise_destroy(&advise); } else { dlh = lt_dlopen (file); } #else /* if LIBTOOL_VERSION == 1 */ if (flags & PLUGIN_FLAGS_GLOBAL) WARNING ("plugin_load_file: The global flag is not supported, " "libtool 2 is required for this."); dlh = lt_dlopen (file); #endif if (dlh == NULL) { char errbuf[1024] = ""; ssnprintf (errbuf, sizeof (errbuf), "lt_dlopen (\"%s\") failed: %s. " "The most common cause for this problem are " "missing dependencies. Use ldd(1) to check " "the dependencies of the plugin " "/ shared object.", file, lt_dlerror ()); ERROR ("%s", errbuf); /* Make sure this is printed to STDERR in any case, but also * make sure it's printed only once. */ if (list_log != NULL) fprintf (stderr, "ERROR: %s\n", errbuf); return (1); } if ((reg_handle = (void (*) (void)) lt_dlsym (dlh, "module_register")) == NULL) { WARNING ("Couldn't find symbol \"module_register\" in \"%s\": %s\n", file, lt_dlerror ()); lt_dlclose (dlh); return (-1); } (*reg_handle) (); return (0); }
lt_dlhandle sbncLoadLibrary(const char *Filename) { lt_dlhandle handle = 0; lt_dladvise advise; if (!lt_dladvise_init(&advise) && !lt_dladvise_global(&advise)) { handle = lt_dlopenadvise(Filename, advise); } lt_dladvise_destroy(&advise); return handle; }
/* * Load shared module using the equivalent of the RTLD_GLOBAL flag */ static lt_dlhandle dlopenext_global (const char *filename) { lt_dlhandle handle = 0; lt_dladvise advise; if (!lt_dladvise_init (&advise) && !lt_dladvise_ext (&advise) && !lt_dladvise_global(&advise)) handle = lt_dlopenadvise (filename, advise); lt_dladvise_destroy (&advise); return handle; }
static lt_dlhandle my_dlopen(const char *filename) { lt_dlhandle handle = 0; lt_dladvise advice[1]; if (!lt_dladvise_init(advice) && !lt_dladvise_ext(advice) && !lt_dladvise_global(advice)) { handle = lt_dlopenadvise(filename, advice[0]); } lt_dladvise_destroy(advice); return handle; }
/* * (Try to) load the shared object `file'. Won't complain if it isn't a shared * object, but it will bitch about a shared object not having a * ``module_register'' symbol.. */ static int plugin_load_file (char *file, uint32_t flags) { lt_dlhandle dlh; void (*reg_handle) (void); DEBUG ("file = %s", file); lt_dlinit (); lt_dlerror (); /* clear errors */ #if LIBTOOL_VERSION == 2 if (flags & PLUGIN_FLAGS_GLOBAL) { lt_dladvise advise; lt_dladvise_init(&advise); lt_dladvise_global(&advise); dlh = lt_dlopenadvise(file, advise); lt_dladvise_destroy(&advise); } else { dlh = lt_dlopen (file); } #else /* if LIBTOOL_VERSION == 1 */ if (flags & PLUGIN_FLAGS_GLOBAL) ERROR ("plugin_load_file: The global flag is not supported, " "libtool 2 is required for this."); dlh = lt_dlopen (file); #endif if (dlh == NULL) { const char *error = lt_dlerror (); ERROR ("lt_dlopen (%s) failed: %s", file, error); fprintf (stderr, "lt_dlopen (%s) failed: %s\n", file, error); return (1); } if ((reg_handle = (void (*) (void)) lt_dlsym (dlh, "module_register")) == NULL) { WARNING ("Couldn't find symbol `module_register' in `%s': %s\n", file, lt_dlerror ()); lt_dlclose (dlh); return (-1); } (*reg_handle) (); return (0); }
void plugins_init(const char *path) { char *plugins_path; lt_dladvise advise; if (path && !strcmp(path, "none")) { return; } if (!(plugins_path = path ? xstrdup(path) : xstrdup(ovs_pluginsdir()))) { VLOG_ERR("Failed to allocate plugins path"); return; } if (lt_dlinit() || lt_dlsetsearchpath(plugins_path) || lt_dladvise_init(&advise)) { VLOG_ERR("ltdl initializations: %s", lt_dlerror()); goto err_init; } if (!(interface_id = lt_dlinterface_register("ovs-plugin", NULL))) { VLOG_ERR("lt_dlinterface_register: %s", lt_dlerror()); goto err_interface_register; } if (lt_dladvise_global(&advise) || lt_dladvise_ext (&advise) || lt_dlforeachfile(lt_dlgetsearchpath(), &plugins_open_plugin, &advise)) { VLOG_ERR("ltdl setting advise: %s", lt_dlerror()); goto err_set_advise; } VLOG_INFO("Successfully initialized all plugins"); return; err_set_advise: lt_dlinterface_free(interface_id); err_interface_register: if (lt_dladvise_destroy(&advise)) { VLOG_ERR("destroying ltdl advise%s", lt_dlerror()); return; } err_init: free(plugins_path); }
void datasource_cache::register_datasources(const std::string& str) { #ifdef MAPNIK_THREADSAFE mutex::scoped_lock lock(mapnik::singleton<mapnik::datasource_cache, mapnik::CreateStatic>::mutex_); #endif boost::filesystem::path path(str); plugin_directories_.push_back(str); boost::filesystem::directory_iterator end_itr; if (exists(path) && is_directory(path)) { for (boost::filesystem::directory_iterator itr(path);itr!=end_itr;++itr ) { #if BOOST_VERSION < 103400 if (!is_directory( *itr ) && is_input_plugin(itr->leaf())) #else #if (BOOST_FILESYSTEM_VERSION == 3) if (!is_directory( *itr ) && is_input_plugin(itr->path().filename().string())) #else // v2 if (!is_directory( *itr ) && is_input_plugin(itr->path().leaf())) #endif #endif { try { #ifdef LIBTOOL_SUPPORTS_ADVISE /* Note: the below was added as a workaround pre http://trac.mapnik.org/ticket/790 It could now be removed, but also is not doing any harm AFAICT. */ // with ltdl >=2.2 we can actually pass RTDL_GLOBAL to dlopen via the // ltdl advise trick which is required on linux unless plugins are directly // linked to libmapnik (and deps) at build time. The only other approach is to // set the dlopen flags in the calling process (like in the python bindings) // clear errors lt_dlerror(); lt_dlhandle module = 0; lt_dladvise advise; int ret; ret = lt_dlinit(); if (ret != 0) { std::clog << "Datasource loader: could not intialize dynamic loading: " << lt_dlerror() << "\n"; } ret = lt_dladvise_init(&advise); if (ret != 0) { std::clog << "Datasource loader: could not intialize dynamic loading: " << lt_dlerror() << "\n"; } ret = lt_dladvise_global(&advise); if (ret != 0) { std::clog << "Datasource loader: could not intialize dynamic loading of global symbols: " << lt_dlerror() << "\n"; } #if (BOOST_FILESYSTEM_VERSION == 3) module = lt_dlopenadvise (itr->path().string().c_str(), advise); #else // v2 module = lt_dlopenadvise (itr->string().c_str(), advise); #endif lt_dladvise_destroy(&advise); #else #if (BOOST_FILESYSTEM_VERSION == 3) lt_dlhandle module = lt_dlopen(itr->path().string().c_str()); #else // v2 lt_dlhandle module = lt_dlopen(itr->string().c_str()); #endif #endif if (module) { // http://www.mr-edd.co.uk/blog/supressing_gcc_warnings #ifdef __GNUC__ __extension__ #endif datasource_name* ds_name = reinterpret_cast<datasource_name*>(lt_dlsym(module, "datasource_name")); if (ds_name && insert(ds_name(),module)) { #ifdef MAPNIK_DEBUG std::clog << "Datasource loader: registered: " << ds_name() << std::endl; #endif registered_=true; } } else { #if (BOOST_FILESYSTEM_VERSION == 3) std::clog << "Problem loading plugin library: " << itr->path().string() << " (dlopen failed - plugin likely has an unsatisfied dependency or incompatible ABI)" << std::endl; #else // v2 std::clog << "Problem loading plugin library: " << itr->string() << " (dlopen failed - plugin likely has an unsatisfied dependency or incompatible ABI)" << std::endl; #endif } } catch (...) {} } } } }
static int dso_load_module(char *name) { int res; char *symbol_name, *path, *tmp; module *m; lt_ptr mh = NULL; lt_dladvise advise; if (name == NULL) { errno = EINVAL; return -1; } if (strncmp(name, "mod_", 4) != 0 || name[strlen(name)-2] != '.' || name[strlen(name)-1] != 'c') { errno = EINVAL; return -1; } pr_log_debug(DEBUG7, "loading '%s'", name); tmp = strrchr(name, '.'); if (tmp == NULL) { errno = EINVAL; return -1; } if (lt_dladvise_init(&advise) < 0) { pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION ": unable to initialise advise: %s", lt_dlerror()); errno = EPERM; return -1; } if (lt_dladvise_ext(&advise) < 0) { pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION ": unable to setting 'ext' advise hint: %s", lt_dlerror()); lt_dladvise_destroy(&advise); errno = EPERM; return -1; } if (lt_dladvise_global(&advise) < 0) { pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION ": unable to setting 'global' advise hint: %s", lt_dlerror()); lt_dladvise_destroy(&advise); errno = EPERM; return -1; } *tmp = '\0'; /* Load file: $prefix/libexec/<module> */ path = pdircat(dso_pool, dso_module_path, name, NULL); pr_trace_msg(trace_channel, 5, "loading module '%s'", path); mh = lt_dlopenadvise(path, advise); if (mh == NULL) { *tmp = '.'; pr_log_debug(DEBUG3, MOD_DSO_VERSION ": unable to dlopen '%s': %s (%s)", name, lt_dlerror(), strerror(errno)); pr_log_debug(DEBUG3, MOD_DSO_VERSION ": defaulting to 'self' for symbol resolution"); lt_dladvise_destroy(&advise); mh = lt_dlopen(NULL); if (mh == NULL) { pr_log_debug(DEBUG0, MOD_DSO_VERSION ": error loading 'self': %s", lt_dlerror()); if (errno == ENOENT) { pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION ": check to see if '%s.la' exists", path); } return -1; } } lt_dladvise_destroy(&advise); /* Tease name of the module structure out of the given name: * <module>.<ext> --> <module>_module */ *tmp = '\0'; symbol_name = pstrcat(dso_pool, name+4, "_module", NULL); /* Lookup module structure symbol by name. */ pr_trace_msg(trace_channel, 7, "looking for symbol '%s' in loaded module", symbol_name); m = (module *) lt_dlsym(mh, symbol_name); if (m == NULL) { *tmp = '.'; pr_log_debug(DEBUG1, MOD_DSO_VERSION ": unable to find module symbol '%s' in '%s'", symbol_name, mh ? name : "self"); pr_trace_msg(trace_channel, 1, "unable to find module symbol '%s' in '%s'", symbol_name, mh ? name : "self"); lt_dlclose(mh); mh = NULL; if (errno == ENOENT) { pr_log_pri(PR_LOG_NOTICE, MOD_DSO_VERSION ": check to see if '%s.la' exists", path); } return -1; } *tmp = '.'; m->handle = mh; /* Add the module to the core structures */ res = pr_module_load(m); if (res < 0) { if (errno == EEXIST) { pr_log_pri(PR_LOG_INFO, MOD_DSO_VERSION ": module 'mod_%s.c' already loaded", m->name); pr_trace_msg(trace_channel, 1, "module 'mod_%s.c' already loaded", m->name); } else if (errno == EACCES) { pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION ": module 'mod_%s.c' has wrong API version (0x%x), must be 0x%x", m->name, m->api_version, PR_MODULE_API_VERSION); pr_trace_msg(trace_channel, 1, "module 'mod_%s.c' has wrong API version (0x%x), must be 0x%x", m->name, m->api_version, PR_MODULE_API_VERSION); } else if (errno == EPERM) { pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION ": module 'mod_%s.c' failed to initialize", m->name); pr_trace_msg(trace_channel, 1, "module 'mod_%s.c' failed to initialize", m->name); } lt_dlclose(mh); mh = NULL; return -1; } pr_trace_msg(trace_channel, 8, "module '%s' successfully loaded", path); return 0; }
static int do_test(void) { FILE *fp; char filename[] = "./libompi_dbg_msgq"; char full_filename[] = "./libompi_dbg_msgq.la"; char line[1024]; int happy; lt_dlhandle dlhandle; #if OPAL_HAVE_LTDL_ADVISE lt_dladvise dladvise; #endif /* Double check that the .la file is there that we expect; if it's not, skip this test. */ fp = fopen(full_filename, "r"); if (NULL == fp) { fprintf(stderr, "File %s.la doesn't seem to exist; skipping this test\n", full_filename); exit(77); } /* We know the .la file is there, so read it, looking for the dlopen value. If the dlopen value is '' (i.e., empty), then there's nothing to dlopen (i.e., OMPI was built with --enable-static --disable-shared, so return 77 to skip this test. This is horrible, but I can't think of a better way to check it (since there is no good way to #define whether we have built statically or not...). */ happy = 0; while (1) { if (0 == fgets(line, sizeof(line) - 1, fp)) { break; } if (0 == strncmp(line, "dlname=", 7)) { if (0 == strncmp(line + 7, "''", 2)) { happy = 0; } else { happy = 1; } break; } } fclose(fp); if (!happy) { fprintf(stderr, "No test file to dlopen (perhaps --enable-static?); skipping\n"); exit(77); } /* Startup LT */ if (lt_dlinit() != 0) { fprintf(stderr, "Failed to lt_dlinit\n"); return 1; } printf("Trying to lt_dlopen file with dladvise_local: %s\n", filename); #if OPAL_HAVE_LTDL_ADVISE if (lt_dladvise_init(&dladvise) || lt_dladvise_ext(&dladvise) || lt_dladvise_local(&dladvise)) { fprintf(stderr, "lt_dladvise failed to initialize properly\n"); return 1; } dlhandle = lt_dlopenadvise(filename, dladvise); lt_dladvise_destroy(&dladvise); #else dlhandle = lt_dlopenext(filename); #endif if (NULL != dlhandle) { lt_dlclose(dlhandle); printf("File opened with dladvise_local, all passed\n"); return 0; } printf("Failed to open with dladvise_local: %s\n", lt_dlerror()); printf("Retrying with dladvise_global\n"); #if OPAL_HAVE_LTDL_ADVISE if (lt_dladvise_init(&dladvise) || lt_dladvise_ext(&dladvise) || lt_dladvise_global(&dladvise)) { fprintf(stderr, "lt_dladvise failed to initialize properly\n"); return 1; } dlhandle = lt_dlopenadvise(filename, dladvise); lt_dladvise_destroy(&dladvise); #else dlhandle = lt_dlopenext(filename); #endif if (NULL != dlhandle) { lt_dlclose(dlhandle); printf("File opened with dladvise_global\n"); return 0; } fprintf(stderr, "File failed to open with dladvise_global: %s\n", lt_dlerror()); return 2; }