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