plugins/component-factory.c

   1 /*
   2  * component-factory.c
   3  *
   4  * Babeltrace Plugin Component Factory
   5  *
   6  * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/plugin/component-factory.h>
  30 #include <babeltrace/plugin/component-factory-internal.h>
  31 #include <babeltrace/babeltrace-internal.h>
  32 #include <babeltrace/compiler.h>
  33 #include <babeltrace/ref.h>
  34 #include <unistd.h>
  35 #include <stdlib.h>
  36 #include <sys/stat.h>
  37 #include <gmodule.h>
  38
  39 #define NATIVE_PLUGIN_SUFFIX ".so"
  40 #define NATIVE_PLUGIN_SUFFIX_LEN sizeof(NATIVE_PLUGIN_SUFFIX)
  41 #define LIBTOOL_PLUGIN_SUFFIX ".la"
  42 #define LIBTOOL_PLUGIN_SUFFIX_LEN sizeof(LIBTOOL_PLUGIN_SUFFIX)
  43 #define PLUGIN_SUFFIX_LEN max_t(size_t, sizeof(NATIVE_PLUGIN_SUFFIX), \
  44                 sizeof(LIBTOOL_PLUGIN_SUFFIX))
  45
  46 /* Allocate dirent as recommended by READDIR(3), NOTES on readdir_r */
  47 static
  48 struct dirent *alloc_dirent(const char *path)
  49 {
  50         size_t len;
  51         long name_max;
  52         struct dirent *entry;
  53
  54         name_max = pathconf(path, _PC_NAME_MAX);
  55         if (name_max == -1) {
  56                 name_max = PATH_MAX;
  57         }
  58         len = offsetof(struct dirent, d_name) + name_max + 1;
  59         entry = zmalloc(len);
  60         return entry;
  61 }
  62
  63 static
  64 enum bt_component_factory_status
  65 bt_component_factory_load_file(struct bt_component_factory *factory,
  66                 const char *path)
  67 {
  68         enum bt_component_factory_status ret = BT_COMPONENT_FACTORY_STATUS_OK;
  69         enum bt_component_status component_status;
  70         size_t path_len;
  71         GModule *module;
  72         struct bt_plugin *plugin;
  73
  74         if (!factory || !path) {
  75                 ret = BT_COMPONENT_FACTORY_STATUS_INVAL;
  76                 goto end;
  77         }
  78
  79         path_len = strlen(path);
  80         if (path_len <= PLUGIN_SUFFIX_LEN) {
  81                 ret = BT_COMPONENT_FACTORY_STATUS_INVAL;
  82                 goto end;
  83         }
  84
  85         path_len++;
  86         /*
  87          * Check if the file ends with a known plugin file type suffix (i.e. .so
  88          * or .la on Linux).
  89          */
  90         if (strncmp(NATIVE_PLUGIN_SUFFIX,
  91                         path + path_len - NATIVE_PLUGIN_SUFFIX_LEN,
  92                         NATIVE_PLUGIN_SUFFIX_LEN) &&
  93                         strncmp(LIBTOOL_PLUGIN_SUFFIX,
  94                         path + path_len - LIBTOOL_PLUGIN_SUFFIX_LEN,
  95                         LIBTOOL_PLUGIN_SUFFIX_LEN)) {
  96                 /* Name indicates that this is not a plugin file. */
  97                 ret = BT_COMPONENT_FACTORY_STATUS_INVAL;
  98                 goto end;
  99         }
 100
 101         module = g_module_open(path, 0);
 102         if (!module) {
 103                 printf_error("Module open error: %s", g_module_error());
 104                 ret = BT_COMPONENT_FACTORY_STATUS_ERROR;
 105                 goto end;
 106         }
 107
 108         /* Load plugin and make sure it defines the required entry points */
 109         plugin = bt_plugin_create(module);
 110         if (!plugin) {
 111                 ret = BT_COMPONENT_FACTORY_STATUS_INVAL_PLUGIN;
 112                 if (!g_module_close(module)) {
 113                         printf_error("Module close error: %s",
 114                                 g_module_error());
 115                 }
 116                 goto end;
 117         }
 118
 119         component_status = bt_plugin_register_component_classes(plugin,
 120                         factory);
 121         if (component_status != BT_COMPONENT_STATUS_OK) {
 122                 switch (component_status) {
 123                 case BT_COMPONENT_STATUS_NOMEM:
 124                         ret = BT_COMPONENT_FACTORY_STATUS_NOMEM;
 125                         break;
 126                 default:
 127                         ret = BT_COMPONENT_FACTORY_STATUS_ERROR;
 128                         break;
 129                 }
 130
 131                 BT_PUT(plugin);
 132                 goto end;
 133         }
 134         g_ptr_array_add(factory->plugins, plugin);
 135 end:
 136         return ret;
 137 }
 138
 139 static
 140 enum bt_component_factory_status
 141 bt_component_factory_load_dir_recursive(struct bt_component_factory *factory,
 142                 const char *path)
 143 {
 144         DIR *directory = NULL;
 145         struct dirent *entry = NULL, *result = NULL;
 146         char *file_path = NULL;
 147         size_t path_len = strlen(path);
 148         enum bt_component_factory_status ret = BT_COMPONENT_FACTORY_STATUS_OK;
 149
 150         if (path_len >= PATH_MAX) {
 151                 ret = BT_COMPONENT_FACTORY_STATUS_INVAL;
 152                 goto end;
 153         }
 154
 155         entry = alloc_dirent(path);
 156         if (!entry) {
 157                 ret = BT_COMPONENT_FACTORY_STATUS_NOMEM;
 158                 goto end;
 159         }
 160
 161         file_path = zmalloc(PATH_MAX);
 162         if (!file_path) {
 163                 ret = BT_COMPONENT_FACTORY_STATUS_NOMEM;
 164                 goto end;
 165         }
 166
 167         strncpy(file_path, path, path_len);
 168         /* Append a trailing '/' to the path */
 169         if (file_path[path_len - 1] != '/') {
 170                 file_path[path_len++] = '/';
 171         }
 172
 173         /* Recursively walk directory */
 174         while (!readdir_r(directory, entry, &result) && result) {
 175                 struct stat st;
 176                 int stat_ret;
 177                 size_t file_name_len = strlen(result->d_name);
 178
 179                 if (path_len + file_name_len >= PATH_MAX) {
 180                         continue;
 181                 }
 182
 183                 strncpy(file_path + path_len, result->d_name, file_name_len);
 184                 file_path[path_len + file_name_len] = '\0';
 185
 186                 stat_ret = stat(file_path, &st);
 187                 if (stat_ret < 0) {
 188                         /* Continue to next file / directory. */
 189                         printf_perror("Failed to stat() plugin file");
 190                         continue;
 191                 }
 192
 193                 if (S_ISDIR(st.st_mode)) {
 194                         ret = bt_component_factory_load_dir_recursive(factory,
 195                                         file_path);
 196                         if (ret != BT_COMPONENT_FACTORY_STATUS_OK) {
 197                                 goto end;
 198                         }
 199                 } else if (S_ISREG(st.st_mode)) {
 200                         bt_component_factory_load_file(factory, file_path);
 201                 }
 202         }
 203 end:
 204         free(entry);
 205         free(file_path);
 206         return ret;
 207 }
 208
 209 static
 210 void bt_component_factory_destroy(struct bt_object *obj)
 211 {
 212         struct bt_component_factory *factory = NULL;
 213
 214         assert(obj);
 215         factory = container_of(obj, struct bt_component_factory, base);
 216
 217         if (factory->plugins) {
 218                 g_ptr_array_free(factory->plugins, TRUE);
 219         }
 220         if (factory->components) {
 221                 g_ptr_array_free(factory->components, TRUE);
 222         }
 223         g_free(factory);
 224 }
 225
 226 struct bt_component_factory *bt_component_factory_create(void)
 227 {
 228         struct bt_component_factory *factory;
 229
 230         factory = g_new0(struct bt_component_factory, 1);
 231         if (!factory) {
 232                 goto end;
 233         }
 234
 235         bt_object_init(factory, bt_component_factory_destroy);
 236         factory->plugins = g_ptr_array_new_with_free_func(
 237                 (GDestroyNotify) bt_put);
 238         if (!factory->plugins) {
 239                 goto error;
 240         }
 241         factory->components = g_ptr_array_new_with_free_func(
 242                 (GDestroyNotify) bt_put);
 243         if (!factory->components) {
 244                 goto error;
 245         }
 246 end:
 247         return factory;
 248 error:
 249         BT_PUT(factory);
 250         return factory;
 251 }
 252
 253 enum bt_component_factory_status bt_component_factory_load(
 254                 struct bt_component_factory *factory, const char *path)
 255 {
 256         enum bt_component_factory_status ret = BT_COMPONENT_FACTORY_STATUS_OK;
 257
 258         if (!factory || !path) {
 259                 ret = BT_COMPONENT_FACTORY_STATUS_INVAL;
 260                 goto end;
 261         }
 262
 263         if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
 264                 ret = BT_COMPONENT_FACTORY_STATUS_NOENT;
 265                 goto end;
 266         }
 267
 268         if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
 269                 ret = bt_component_factory_load_dir_recursive(factory, path);
 270         } else if (g_file_test(path, G_FILE_TEST_IS_REGULAR) ||
 271                         g_file_test(path, G_FILE_TEST_IS_SYMLINK)) {
 272                 ret = bt_component_factory_load_file(factory, path);
 273         } else {
 274                 ret = BT_COMPONENT_FACTORY_STATUS_INVAL;
 275                 goto end;
 276         }
 277 end:
 278         return ret;
 279 }