src/lib/plugin/plugin.c

   1 /*
   2  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   3  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  */
  25
  26 #define BT_LOG_TAG "LIB/PLUGIN"
  27 #include "lib/logging.h"
  28
  29 #include "common/assert.h"
  30 #include "lib/assert-pre.h"
  31 #include "common/macros.h"
  32 #include "compat/compiler.h"
  33 #include "common/common.h"
  34 #include <babeltrace2/plugin/plugin-const.h>
  35 #include <babeltrace2/graph/component-class-const.h>
  36 #include <babeltrace2/current-thread.h>
  37 #include "lib/graph/component-class.h"
  38 #include <babeltrace2/types.h>
  39 #include <glib.h>
  40 #include <unistd.h>
  41 #include <stdlib.h>
  42 #include <stdint.h>
  43 #include <inttypes.h>
  44 #include <sys/stat.h>
  45 #include <ftw.h>
  46 #include <pthread.h>
  47
  48 #include "plugin.h"
  49 #include "plugin-so.h"
  50 #include "lib/func-status.h"
  51
  52 #define PYTHON_PLUGIN_PROVIDER_FILENAME "babeltrace2-python-plugin-provider." G_MODULE_SUFFIX
  53 #define PYTHON_PLUGIN_PROVIDER_DIR      BABELTRACE_PLUGIN_PROVIDERS_DIR
  54 #define PYTHON_PLUGIN_PROVIDER_SYM_NAME bt_plugin_python_create_all_from_file
  55 #define PYTHON_PLUGIN_PROVIDER_SYM_NAME_STR     G_STRINGIFY(PYTHON_PLUGIN_PROVIDER_SYM_NAME)
  56
  57 #define APPEND_ALL_FROM_DIR_NFDOPEN_MAX 8
  58
  59 /* Declare here to make sure definition in both ifdef branches are in sync. */
  60 static
  61 int init_python_plugin_provider(void);
  62 typedef int (*create_all_from_file_sym_type)(
  63                 const char *path,
  64                 bool fail_on_load_error,
  65                 struct bt_plugin_set **plugin_set_out);
  66
  67 #ifdef BT_BUILT_IN_PYTHON_PLUGIN_SUPPORT
  68 #include <plugin/python-plugin-provider.h>
  69
  70 static
  71 create_all_from_file_sym_type
  72         bt_plugin_python_create_all_from_file_sym =
  73                         bt_plugin_python_create_all_from_file;
  74
  75 static
  76 int init_python_plugin_provider(void)
  77 {
  78 }
  79 #else /* BT_BUILT_IN_PYTHON_PLUGIN_SUPPORT */
  80 static GModule *python_plugin_provider_module;
  81
  82 static
  83 create_all_from_file_sym_type bt_plugin_python_create_all_from_file_sym;
  84
  85 static
  86 int init_python_plugin_provider(void) {
  87         int status = BT_FUNC_STATUS_OK;
  88         const char *provider_dir_envvar;
  89         static const char * const provider_dir_envvar_name = "LIBBABELTRACE2_PLUGIN_PROVIDER_DIR";
  90         char *provider_path = NULL;
  91
  92         if (bt_plugin_python_create_all_from_file_sym) {
  93                 goto end;
  94         }
  95
  96         BT_LOGI_STR("Loading Python plugin provider module.");
  97
  98         provider_dir_envvar = getenv(provider_dir_envvar_name);
  99         if (provider_dir_envvar) {
 100                 provider_path = g_build_filename(provider_dir_envvar,
 101                         PYTHON_PLUGIN_PROVIDER_FILENAME, NULL);
 102                 BT_LOGI("Using `%s` environment variable to find the Python "
 103                         "plugin provider: path=\"%s\"", provider_dir_envvar_name,
 104                         provider_path);
 105         } else {
 106                 provider_path = g_build_filename(PYTHON_PLUGIN_PROVIDER_DIR,
 107                         PYTHON_PLUGIN_PROVIDER_FILENAME, NULL);
 108                 BT_LOGI("Using default path (`%s` environment variable is not "
 109                         "set) to find the Python plugin provider: path=\"%s\"",
 110                         provider_dir_envvar_name, provider_path);
 111         }
 112
 113         python_plugin_provider_module = g_module_open(provider_path, 0);
 114         if (!python_plugin_provider_module) {
 115                 /*
 116                  * This is not an error. The whole point of having an
 117                  * external Python plugin provider is that it can be
 118                  * missing and the Babeltrace library still works.
 119                  */
 120                 BT_LOGI("Cannot open `%s`: %s: continuing without Python plugin support.",
 121                         provider_path, g_module_error());
 122                 goto end;
 123         }
 124
 125         if (!g_module_symbol(python_plugin_provider_module,
 126                         PYTHON_PLUGIN_PROVIDER_SYM_NAME_STR,
 127                         (gpointer) &bt_plugin_python_create_all_from_file_sym)) {
 128                 /*
 129                  * This is an error because, since we found the Python
 130                  * plugin provider shared object, we expect this symbol
 131                  * to exist.
 132                  */
 133                 BT_LIB_LOGE_APPEND_CAUSE(
 134                         "Cannot find the Python plugin provider loading symbol: "
 135                         "%s: continuing without Python plugin support: "
 136                         "file=\"%s\", symbol=\"%s\"",
 137                         g_module_error(),
 138                         provider_path,
 139                         PYTHON_PLUGIN_PROVIDER_SYM_NAME_STR);
 140                 status = BT_FUNC_STATUS_ERROR;
 141                 goto end;
 142         }
 143
 144         BT_LOGI("Loaded Python plugin provider module: addr=%p",
 145                 python_plugin_provider_module);
 146
 147 end:
 148         g_free(provider_path);
 149
 150         return status;
 151 }
 152
 153 __attribute__((destructor)) static
 154 void fini_python_plugin_provider(void) {
 155         if (python_plugin_provider_module) {
 156                 BT_LOGI("Unloading Python plugin provider module.");
 157
 158                 if (!g_module_close(python_plugin_provider_module)) {
 159                         /*
 160                          * This occurs when the library is finalized: do
 161                          * NOT append an error cause.
 162                          */
 163                         BT_LOGE("Failed to close the Python plugin provider module: %s.",
 164                                 g_module_error());
 165                 }
 166
 167                 python_plugin_provider_module = NULL;
 168         }
 169 }
 170 #endif
 171
 172 uint64_t bt_plugin_set_get_plugin_count(const struct bt_plugin_set *plugin_set)
 173 {
 174         BT_ASSERT_PRE_DEV_NON_NULL(plugin_set, "Plugin set");
 175         return (uint64_t) plugin_set->plugins->len;
 176 }
 177
 178 const struct bt_plugin *bt_plugin_set_borrow_plugin_by_index_const(
 179                 const struct bt_plugin_set *plugin_set, uint64_t index)
 180 {
 181         BT_ASSERT_PRE_DEV_NON_NULL(plugin_set, "Plugin set");
 182         BT_ASSERT_PRE_DEV_VALID_INDEX(index, plugin_set->plugins->len);
 183         return g_ptr_array_index(plugin_set->plugins, index);
 184 }
 185
 186 enum bt_plugin_find_all_from_static_status bt_plugin_find_all_from_static(
 187                 bt_bool fail_on_load_error,
 188                 const struct bt_plugin_set **plugin_set_out)
 189 {
 190         /* bt_plugin_so_create_all_from_static() logs errors */
 191         return bt_plugin_so_create_all_from_static(fail_on_load_error,
 192                 (void *) plugin_set_out);
 193 }
 194
 195 enum bt_plugin_find_all_from_file_status bt_plugin_find_all_from_file(
 196                 const char *path, bt_bool fail_on_load_error,
 197                 const struct bt_plugin_set **plugin_set_out)
 198 {
 199         enum bt_plugin_find_all_from_file_status status;
 200
 201         BT_ASSERT_PRE_NON_NULL(path, "Path");
 202         BT_ASSERT_PRE_NON_NULL(path, "Plugin set (output)");
 203         BT_LOGI("Creating plugins from file: path=\"%s\"", path);
 204
 205         /* Try shared object plugins */
 206         status = bt_plugin_so_create_all_from_file(path, fail_on_load_error,
 207                 (void *) plugin_set_out);
 208         if (status == BT_FUNC_STATUS_OK) {
 209                 BT_ASSERT(*plugin_set_out);
 210                 BT_ASSERT((*plugin_set_out)->plugins->len > 0);
 211                 goto end;
 212         } else if (status < 0) {
 213                 BT_ASSERT(!*plugin_set_out);
 214                 goto end;
 215         }
 216
 217         BT_ASSERT(status == BT_FUNC_STATUS_NOT_FOUND);
 218         BT_ASSERT(!*plugin_set_out);
 219
 220         /* Try Python plugins if support is available */
 221         status = init_python_plugin_provider();
 222         if (status < 0) {
 223                 /* init_python_plugin_provider() logs errors */
 224                 goto end;
 225         }
 226
 227         BT_ASSERT(status == BT_FUNC_STATUS_OK);
 228         status = BT_FUNC_STATUS_NOT_FOUND;
 229
 230         if (bt_plugin_python_create_all_from_file_sym) {
 231                 /* Python plugin provider exists */
 232                 status = bt_plugin_python_create_all_from_file_sym(path,
 233                         fail_on_load_error, (void *) plugin_set_out);
 234                 if (status == BT_FUNC_STATUS_OK) {
 235                         BT_ASSERT(*plugin_set_out);
 236                         BT_ASSERT((*plugin_set_out)->plugins->len > 0);
 237                         goto end;
 238                 } else if (status < 0) {
 239                         /*
 240                          * bt_plugin_python_create_all_from_file_sym()
 241                          * handles `fail_on_load_error` itself, so this
 242                          * is a "real" error.
 243                          */
 244                         BT_ASSERT(!*plugin_set_out);
 245                         goto end;
 246                 }
 247
 248                 BT_ASSERT(status == BT_FUNC_STATUS_NOT_FOUND);
 249                 BT_ASSERT(!*plugin_set_out);
 250         }
 251
 252 end:
 253         if (status == BT_FUNC_STATUS_OK) {
 254                 BT_LOGI("Created %u plugins from file: "
 255                         "path=\"%s\", count=%u, plugin-set-addr=%p",
 256                         (*plugin_set_out)->plugins->len, path,
 257                         (*plugin_set_out)->plugins->len,
 258                         *plugin_set_out);
 259         } else if (status == BT_FUNC_STATUS_NOT_FOUND) {
 260                 BT_LOGI("Found no plugins in file: path=\"%s\"", path);
 261         }
 262
 263         return status;
 264 }
 265
 266 static
 267 void destroy_gstring(void *data)
 268 {
 269         g_string_free(data, TRUE);
 270 }
 271
 272 enum bt_plugin_find_all_status bt_plugin_find_all(bt_bool find_in_std_env_var,
 273                 bt_bool find_in_user_dir, bt_bool find_in_sys_dir,
 274                 bt_bool find_in_static, bt_bool fail_on_load_error,
 275                 const struct bt_plugin_set **plugin_set_out)
 276 {
 277         char *home_plugin_dir = NULL;
 278         const struct bt_plugin_set *plugin_set = NULL;
 279         GPtrArray *dirs = NULL;
 280         int ret;
 281         int status = BT_FUNC_STATUS_OK;
 282         uint64_t dir_i, plugin_i;
 283
 284         BT_ASSERT_PRE_NON_NULL(plugin_set_out, "Plugin set (output)");
 285         BT_LOGI("Finding all plugins in standard directories and built-in plugins: "
 286                 "find-in-std-env-var=%d, find-in-user-dir=%d, "
 287                 "find-in-sys-dir=%d, find-in-static=%d",
 288                 find_in_std_env_var, find_in_user_dir, find_in_sys_dir,
 289                 find_in_static);
 290         dirs = g_ptr_array_new_with_free_func((GDestroyNotify) destroy_gstring);
 291         if (!dirs) {
 292                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray.");
 293                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 294                 goto end;
 295         }
 296
 297         *plugin_set_out = bt_plugin_set_create();
 298         if (!*plugin_set_out) {
 299                 BT_LIB_LOGE_APPEND_CAUSE("Cannot create empty plugin set.");
 300                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 301                 goto end;
 302         }
 303
 304         /*
 305          * Search order is:
 306          *
 307          * 1. `BABELTRACE_PLUGIN_PATH` environment variable
 308          *    (colon-separated list of directories)
 309          * 2. `~/.local/lib/babeltrace2/plugins`
 310          * 3. Default system directory for Babeltrace plugins, usually
 311          *    `/usr/lib/babeltrace2/plugins` or
 312          *    `/usr/local/lib/babeltrace2/plugins` if installed locally
 313          * 4. Built-in plugins (static)
 314          *
 315          * Directories are searched non-recursively.
 316          */
 317         if (find_in_std_env_var) {
 318                 const char *envvar = getenv("BABELTRACE_PLUGIN_PATH");
 319
 320                 if (envvar) {
 321                         ret = bt_common_append_plugin_path_dirs(envvar, dirs);
 322                         if (ret) {
 323                                 BT_LIB_LOGE_APPEND_CAUSE(
 324                                         "Failed to append plugin path to array of directories.");
 325                                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 326                                 goto end;
 327                         }
 328                 }
 329         }
 330
 331         if (find_in_user_dir) {
 332                 home_plugin_dir = bt_common_get_home_plugin_path(
 333                         BT_LOG_OUTPUT_LEVEL);
 334                 if (home_plugin_dir) {
 335                         GString *home_plugin_dir_str = g_string_new(
 336                                 home_plugin_dir);
 337
 338                         if (!home_plugin_dir_str) {
 339                                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
 340                                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 341                                 goto end;
 342                         }
 343
 344                         g_ptr_array_add(dirs, home_plugin_dir_str);
 345                 }
 346         }
 347
 348         if (find_in_sys_dir) {
 349                 const char *system_plugin_dir =
 350                         bt_common_get_system_plugin_path();
 351
 352                 if (system_plugin_dir) {
 353                         GString *system_plugin_dir_str =
 354                                 g_string_new(system_plugin_dir);
 355
 356                         if (!system_plugin_dir_str) {
 357                                 BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString.");
 358                                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 359                                 goto end;
 360                         }
 361
 362                         g_ptr_array_add(dirs, system_plugin_dir_str);
 363                 }
 364         }
 365
 366         for (dir_i = 0; dir_i < dirs->len; dir_i++) {
 367                 GString *dir = dirs->pdata[dir_i];
 368
 369                 BT_OBJECT_PUT_REF_AND_RESET(plugin_set);
 370
 371                 /*
 372                  * Skip this if the directory does not exist because
 373                  * bt_plugin_find_all_from_dir() would log a warning.
 374                  */
 375                 if (!g_file_test(dir->str, G_FILE_TEST_IS_DIR)) {
 376                         BT_LOGI("Skipping nonexistent directory path: "
 377                                 "path=\"%s\"", dir->str);
 378                         continue;
 379                 }
 380
 381                 /* bt_plugin_find_all_from_dir() logs details/errors */
 382                 status = bt_plugin_find_all_from_dir(dir->str, BT_FALSE,
 383                         fail_on_load_error, &plugin_set);
 384                 if (status < 0) {
 385                         BT_ASSERT(!plugin_set);
 386                         goto end;
 387                 } else if (status == BT_FUNC_STATUS_NOT_FOUND) {
 388                         BT_ASSERT(!plugin_set);
 389                         BT_LOGI("No plugins found in directory: path=\"%s\"",
 390                                 dir->str);
 391                         continue;
 392                 }
 393
 394                 BT_ASSERT(status == BT_FUNC_STATUS_OK);
 395                 BT_ASSERT(plugin_set);
 396                 BT_LOGI("Found plugins in directory: path=\"%s\", count=%u",
 397                         dir->str, plugin_set->plugins->len);
 398
 399                 for (plugin_i = 0; plugin_i < plugin_set->plugins->len;
 400                                 plugin_i++) {
 401                         bt_plugin_set_add_plugin((void *) *plugin_set_out,
 402                                 plugin_set->plugins->pdata[plugin_i]);
 403                 }
 404         }
 405
 406         if (find_in_static) {
 407                 BT_OBJECT_PUT_REF_AND_RESET(plugin_set);
 408                 status = bt_plugin_find_all_from_static(fail_on_load_error,
 409                         &plugin_set);
 410                 if (status < 0) {
 411                         BT_ASSERT(!plugin_set);
 412                         goto end;
 413                 } else if (status == BT_FUNC_STATUS_NOT_FOUND) {
 414                         BT_ASSERT(!plugin_set);
 415                         BT_LOGI_STR("No plugins found in built-in plugins.");
 416                         goto end;
 417                 }
 418
 419                 BT_ASSERT(status == BT_FUNC_STATUS_OK);
 420                 BT_ASSERT(plugin_set);
 421                 BT_LOGI("Found built-in plugins: count=%u",
 422                         plugin_set->plugins->len);
 423
 424                 for (plugin_i = 0; plugin_i < plugin_set->plugins->len;
 425                                 plugin_i++) {
 426                         bt_plugin_set_add_plugin((void *) *plugin_set_out,
 427                                 plugin_set->plugins->pdata[plugin_i]);
 428                 }
 429         }
 430
 431 end:
 432         free(home_plugin_dir);
 433         bt_object_put_ref(plugin_set);
 434
 435         if (dirs) {
 436                 g_ptr_array_free(dirs, TRUE);
 437         }
 438
 439         if (status < 0) {
 440                 BT_OBJECT_PUT_REF_AND_RESET(*plugin_set_out);
 441         } else {
 442                 BT_ASSERT(*plugin_set_out);
 443
 444                 if ((*plugin_set_out)->plugins->len > 0) {
 445                         BT_LOGI("Found plugins in standard directories and built-in plugins: "
 446                                 "count=%u", (*plugin_set_out)->plugins->len);
 447                         status = BT_FUNC_STATUS_OK;
 448                 } else {
 449                         BT_LOGI_STR("No plugins found in standard directories and built-in plugins.");
 450                         status = BT_FUNC_STATUS_NOT_FOUND;
 451                         BT_OBJECT_PUT_REF_AND_RESET(*plugin_set_out);
 452                 }
 453         }
 454
 455         return status;
 456 }
 457
 458 enum bt_plugin_find_status bt_plugin_find(const char *plugin_name,
 459                 bt_bool find_in_std_env_var, bt_bool find_in_user_dir,
 460                 bt_bool find_in_sys_dir, bt_bool find_in_static,
 461                 bt_bool fail_on_load_error, const struct bt_plugin **plugin_out)
 462 {
 463         enum bt_plugin_find_status status;
 464         const struct bt_plugin_set *plugin_set = NULL;
 465         uint64_t i;
 466
 467         BT_ASSERT_PRE_NON_NULL(plugin_name, "Name");
 468         BT_ASSERT_PRE_NON_NULL(plugin_out, "Plugin (output)");
 469         BT_LOGI("Finding named plugin in standard directories and built-in plugins: "
 470                 "name=\"%s\", find-in-std-env-var=%d, find-in-user-dir=%d, "
 471                 "find-in-sys-dir=%d, find-in-static=%d",
 472                 plugin_name, find_in_std_env_var, find_in_user_dir,
 473                 find_in_sys_dir, find_in_static);
 474         status = (enum bt_plugin_find_status) bt_plugin_find_all(find_in_std_env_var, find_in_user_dir,
 475                 find_in_sys_dir, find_in_static, fail_on_load_error,
 476                 &plugin_set);
 477         if (status != BT_FUNC_STATUS_OK) {
 478                 BT_ASSERT(!plugin_set);
 479                 goto end;
 480         }
 481
 482         BT_ASSERT(plugin_set);
 483
 484         for (i = 0; i < plugin_set->plugins->len; i++) {
 485                 const struct bt_plugin *plugin = plugin_set->plugins->pdata[i];
 486
 487                 if (strcmp(plugin->info.name->str, plugin_name) == 0) {
 488                         *plugin_out = plugin;
 489                         bt_object_get_ref_no_null_check(*plugin_out);
 490                         goto end;
 491                 }
 492         }
 493
 494         status = BT_FUNC_STATUS_NOT_FOUND;
 495
 496 end:
 497         if (status == BT_FUNC_STATUS_OK) {
 498                 BT_ASSERT(*plugin_out);
 499                 BT_LIB_LOGI("Found plugin in standard directories and built-in plugins: "
 500                         "%!+l", *plugin_out);
 501         } else if (status == BT_FUNC_STATUS_NOT_FOUND) {
 502                 BT_LOGI("No plugin found in standard directories and built-in plugins: "
 503                         "name=\"%s\"", plugin_name);
 504         }
 505
 506         bt_plugin_set_put_ref(plugin_set);
 507
 508         return status;
 509 }
 510
 511 static struct {
 512         pthread_mutex_t lock;
 513         struct bt_plugin_set *plugin_set;
 514         bool recurse;
 515         bool fail_on_load_error;
 516         int status;
 517 } append_all_from_dir_info = {
 518         .lock = PTHREAD_MUTEX_INITIALIZER
 519 };
 520
 521 static
 522 int nftw_append_all_from_dir(const char *file,
 523                 const struct stat *sb, int flag, struct FTW *s)
 524 {
 525         int ret = 0;
 526         const char *name = file + s->base;
 527
 528         /* Check for recursion */
 529         if (!append_all_from_dir_info.recurse && s->level > 1) {
 530                 goto end;
 531         }
 532
 533         switch (flag) {
 534         case FTW_F:
 535         {
 536                 const struct bt_plugin_set *plugins_from_file = NULL;
 537
 538                 if (name[0] == '.') {
 539                         /* Skip hidden files */
 540                         BT_LOGI("Skipping hidden file: path=\"%s\"", file);
 541                         goto end;
 542                 }
 543
 544                 append_all_from_dir_info.status =
 545                         bt_plugin_find_all_from_file(file,
 546                                 append_all_from_dir_info.fail_on_load_error,
 547                                 &plugins_from_file);
 548                 if (append_all_from_dir_info.status == BT_FUNC_STATUS_OK) {
 549                         size_t j;
 550
 551                         BT_ASSERT(plugins_from_file);
 552
 553                         for (j = 0; j < plugins_from_file->plugins->len; j++) {
 554                                 struct bt_plugin *plugin =
 555                                         g_ptr_array_index(plugins_from_file->plugins, j);
 556
 557                                 BT_LIB_LOGI("Adding plugin to plugin set: "
 558                                         "plugin-path=\"%s\", %![plugin-]+l",
 559                                         file, plugin);
 560                                 bt_plugin_set_add_plugin(
 561                                         append_all_from_dir_info.plugin_set,
 562                                         plugin);
 563                         }
 564
 565                         bt_object_put_ref(plugins_from_file);
 566                         goto end;
 567                 } else if (append_all_from_dir_info.status < 0) {
 568                         /* bt_plugin_find_all_from_file() logs errors */
 569                         BT_ASSERT(!plugins_from_file);
 570                         ret = -1;
 571                         goto end;
 572                 }
 573
 574                 /*
 575                  * Not found in this file: this is no an error; continue
 576                  * walking the directories.
 577                  */
 578                 BT_ASSERT(!plugins_from_file);
 579                 BT_ASSERT(append_all_from_dir_info.status ==
 580                         BT_FUNC_STATUS_NOT_FOUND);
 581                 break;
 582         }
 583         case FTW_DNR:
 584                 /* Continue to next file / directory. */
 585                 BT_LOGI("Cannot enter directory: continuing: path=\"%s\"", file);
 586                 break;
 587         case FTW_NS:
 588                 /* Continue to next file / directory. */
 589                 BT_LOGI("Cannot get file information: continuing: path=\"%s\"", file);
 590                 break;
 591         }
 592
 593 end:
 594         return ret;
 595 }
 596
 597 static
 598 int bt_plugin_create_append_all_from_dir(struct bt_plugin_set *plugin_set,
 599                 const char *path, bt_bool recurse, bt_bool fail_on_load_error)
 600 {
 601         int nftw_flags = FTW_PHYS;
 602         int ret;
 603         int status;
 604         struct stat sb;
 605
 606         BT_ASSERT(plugin_set);
 607         BT_ASSERT(path);
 608         BT_ASSERT(strlen(path) < PATH_MAX);
 609
 610         /*
 611          * Make sure that path exists and is accessible.
 612          * This is necessary since Cygwin implementation of nftw() is not POSIX
 613          * compliant. Cygwin nftw() implementation does not fail on non-existent
 614          * path with ENOENT. Instead, it flags the directory as FTW_NS. FTW_NS during
 615          * nftw_append_all_from_dir is not treated as an error since we are
 616          * traversing the tree for plugin discovery.
 617          */
 618         if (stat(path, &sb)) {
 619                 BT_LOGW_ERRNO("Cannot open directory",
 620                         ": path=\"%s\", recurse=%d",
 621                         path, recurse);
 622                 (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_UNKNOWN(
 623                         "Babeltrace library",
 624                         "Cannot open directory: path=\"%s\", recurse=%d",
 625                         path, recurse);
 626                 status = BT_FUNC_STATUS_ERROR;
 627                 goto end;
 628         }
 629
 630         pthread_mutex_lock(&append_all_from_dir_info.lock);
 631         append_all_from_dir_info.plugin_set = plugin_set;
 632         append_all_from_dir_info.recurse = recurse;
 633         append_all_from_dir_info.status = BT_FUNC_STATUS_OK;
 634         append_all_from_dir_info.fail_on_load_error = fail_on_load_error;
 635         ret = nftw(path, nftw_append_all_from_dir,
 636                 APPEND_ALL_FROM_DIR_NFDOPEN_MAX, nftw_flags);
 637         append_all_from_dir_info.plugin_set = NULL;
 638         status = append_all_from_dir_info.status;
 639         pthread_mutex_unlock(&append_all_from_dir_info.lock);
 640         if (ret) {
 641                 BT_LIB_LOGW_APPEND_CAUSE("Failed to walk directory",
 642                         ": path=\"%s\", recurse=%d",
 643                         path, recurse);
 644                 status = BT_FUNC_STATUS_ERROR;
 645                 goto end;
 646         }
 647
 648         if (status == BT_FUNC_STATUS_NOT_FOUND) {
 649                 /*
 650                  * We're just appending in this function; even if
 651                  * nothing was found, it's still okay from the caller's
 652                  * perspective.
 653                  */
 654                 status = BT_FUNC_STATUS_OK;
 655         }
 656
 657 end:
 658         return status;
 659 }
 660
 661 enum bt_plugin_find_all_from_dir_status bt_plugin_find_all_from_dir(
 662                 const char *path, bt_bool recurse, bt_bool fail_on_load_error,
 663                 const struct bt_plugin_set **plugin_set_out)
 664 {
 665         enum bt_plugin_find_all_from_dir_status status =
 666                 BT_FUNC_STATUS_OK;
 667
 668         BT_ASSERT_PRE_NON_NULL(plugin_set_out, "Plugin set (output)");
 669         BT_LOGI("Creating all plugins in directory: path=\"%s\", recurse=%d",
 670                 path, recurse);
 671         *plugin_set_out = bt_plugin_set_create();
 672         if (!*plugin_set_out) {
 673                 BT_LIB_LOGE_APPEND_CAUSE("Cannot create empty plugin set.");
 674                 status = BT_FUNC_STATUS_MEMORY_ERROR;
 675                 goto error;
 676         }
 677
 678         /*
 679          * Append found plugins to array (never returns
 680          * `BT_FUNC_STATUS_NOT_FOUND`)
 681          */
 682         status = bt_plugin_create_append_all_from_dir((void *) *plugin_set_out,
 683                 path, recurse, fail_on_load_error);
 684         if (status < 0) {
 685                 /*
 686                  * bt_plugin_create_append_all_from_dir() handles
 687                  * `fail_on_load_error`, so this is a "real" error.
 688                  */
 689                 BT_LIB_LOGE_APPEND_CAUSE(
 690                         "Cannot append plugins found in directory: "
 691                         "path=\"%s\", status=%s",
 692                         path, bt_common_func_status_string(status));
 693                 goto error;
 694         }
 695
 696         BT_ASSERT(status == BT_FUNC_STATUS_OK);
 697
 698         if ((*plugin_set_out)->plugins->len == 0) {
 699                 /* Nothing was appended: not found */
 700                 BT_LOGI("No plugins found in directory: path=\"%s\"", path);
 701                 status = BT_FUNC_STATUS_NOT_FOUND;
 702                 goto error;
 703         }
 704
 705         BT_LOGI("Created %u plugins from directory: count=%u, path=\"%s\"",
 706                 (*plugin_set_out)->plugins->len,
 707                 (*plugin_set_out)->plugins->len, path);
 708         goto end;
 709
 710 error:
 711         BT_ASSERT(status != BT_FUNC_STATUS_OK);
 712         BT_OBJECT_PUT_REF_AND_RESET(*plugin_set_out);
 713
 714 end:
 715         return status;
 716 }
 717
 718 const char *bt_plugin_get_name(const struct bt_plugin *plugin)
 719 {
 720         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 721         return plugin->info.name_set ? plugin->info.name->str : NULL;
 722 }
 723
 724 const char *bt_plugin_get_author(const struct bt_plugin *plugin)
 725 {
 726         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 727         return plugin->info.author_set ? plugin->info.author->str : NULL;
 728 }
 729
 730 const char *bt_plugin_get_license(const struct bt_plugin *plugin)
 731 {
 732         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 733         return plugin->info.license_set ? plugin->info.license->str : NULL;
 734 }
 735
 736 const char *bt_plugin_get_path(const struct bt_plugin *plugin)
 737 {
 738         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 739         return plugin->info.path_set ? plugin->info.path->str : NULL;
 740 }
 741
 742 const char *bt_plugin_get_description(const struct bt_plugin *plugin)
 743 {
 744         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 745         return plugin->info.description_set ?
 746                 plugin->info.description->str : NULL;
 747 }
 748
 749 enum bt_property_availability bt_plugin_get_version(const struct bt_plugin *plugin,
 750                 unsigned int *major, unsigned int *minor, unsigned int *patch,
 751                 const char **extra)
 752 {
 753         enum bt_property_availability avail =
 754                 BT_PROPERTY_AVAILABILITY_AVAILABLE;
 755
 756         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 757
 758         if (!plugin->info.version_set) {
 759                 BT_LIB_LOGD("Plugin's version is not set: %!+l", plugin);
 760                 avail = BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE;
 761                 goto end;
 762         }
 763
 764         if (major) {
 765                 *major = plugin->info.version.major;
 766         }
 767
 768         if (minor) {
 769                 *minor = plugin->info.version.minor;
 770         }
 771
 772         if (patch) {
 773                 *patch = plugin->info.version.patch;
 774         }
 775
 776         if (extra) {
 777                 *extra = plugin->info.version.extra->str;
 778         }
 779
 780 end:
 781         return avail;
 782 }
 783
 784 uint64_t bt_plugin_get_source_component_class_count(const struct bt_plugin *plugin)
 785 {
 786         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 787         return (uint64_t) plugin->src_comp_classes->len;
 788 }
 789
 790 uint64_t bt_plugin_get_filter_component_class_count(const struct bt_plugin *plugin)
 791 {
 792         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 793         return (uint64_t) plugin->flt_comp_classes->len;
 794 }
 795
 796 uint64_t bt_plugin_get_sink_component_class_count(const struct bt_plugin *plugin)
 797 {
 798         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 799         return (uint64_t) plugin->sink_comp_classes->len;
 800 }
 801
 802 static inline
 803 struct bt_component_class *borrow_component_class_by_index(
 804                 const struct bt_plugin *plugin, GPtrArray *comp_classes,
 805                 uint64_t index)
 806 {
 807         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 808         BT_ASSERT_PRE_DEV_VALID_INDEX(index, comp_classes->len);
 809         return g_ptr_array_index(comp_classes, index);
 810 }
 811
 812 const struct bt_component_class_source *
 813 bt_plugin_borrow_source_component_class_by_index_const(
 814                 const struct bt_plugin *plugin, uint64_t index)
 815 {
 816         return (const void *) borrow_component_class_by_index(plugin,
 817                 plugin->src_comp_classes, index);
 818 }
 819
 820 const struct bt_component_class_filter *
 821 bt_plugin_borrow_filter_component_class_by_index_const(
 822                 const struct bt_plugin *plugin, uint64_t index)
 823 {
 824         return (const void *) borrow_component_class_by_index(plugin,
 825                 plugin->flt_comp_classes, index);
 826 }
 827
 828 const struct bt_component_class_sink *
 829 bt_plugin_borrow_sink_component_class_by_index_const(
 830                 const struct bt_plugin *plugin, uint64_t index)
 831 {
 832         return (const void *) borrow_component_class_by_index(plugin,
 833                 plugin->sink_comp_classes, index);
 834 }
 835
 836 static inline
 837 struct bt_component_class *borrow_component_class_by_name(
 838                 const struct bt_plugin *plugin, GPtrArray *comp_classes,
 839                 const char *name)
 840 {
 841         struct bt_component_class *comp_class = NULL;
 842         size_t i;
 843
 844         BT_ASSERT_PRE_DEV_NON_NULL(plugin, "Plugin");
 845         BT_ASSERT_PRE_DEV_NON_NULL(name, "Name");
 846
 847         for (i = 0; i < comp_classes->len; i++) {
 848                 struct bt_component_class *comp_class_candidate =
 849                         g_ptr_array_index(comp_classes, i);
 850                 const char *comp_class_cand_name =
 851                         bt_component_class_get_name(comp_class_candidate);
 852
 853                 BT_ASSERT_DBG(comp_class_cand_name);
 854
 855                 if (strcmp(name, comp_class_cand_name) == 0) {
 856                         comp_class = comp_class_candidate;
 857                         break;
 858                 }
 859         }
 860
 861         return comp_class;
 862 }
 863
 864 const struct bt_component_class_source *
 865 bt_plugin_borrow_source_component_class_by_name_const(
 866                 const struct bt_plugin *plugin, const char *name)
 867 {
 868         return (const void *) borrow_component_class_by_name(plugin,
 869                 plugin->src_comp_classes, name);
 870 }
 871
 872 const struct bt_component_class_filter *
 873 bt_plugin_borrow_filter_component_class_by_name_const(
 874                 const struct bt_plugin *plugin, const char *name)
 875 {
 876         return (const void *) borrow_component_class_by_name(plugin,
 877                 plugin->flt_comp_classes, name);
 878 }
 879
 880 const struct bt_component_class_sink *
 881 bt_plugin_borrow_sink_component_class_by_name_const(
 882                 const struct bt_plugin *plugin, const char *name)
 883 {
 884         return (const void *) borrow_component_class_by_name(plugin,
 885                 plugin->sink_comp_classes, name);
 886 }
 887
 888 void bt_plugin_get_ref(const struct bt_plugin *plugin)
 889 {
 890         bt_object_get_ref(plugin);
 891 }
 892
 893 void bt_plugin_put_ref(const struct bt_plugin *plugin)
 894 {
 895         bt_object_put_ref(plugin);
 896 }
 897
 898 void bt_plugin_set_get_ref(const struct bt_plugin_set *plugin_set)
 899 {
 900         bt_object_get_ref(plugin_set);
 901 }
 902
 903 void bt_plugin_set_put_ref(const struct bt_plugin_set *plugin_set)
 904 {
 905         bt_object_put_ref(plugin_set);
 906 }