src/lib/plugin/plugin.h

   1 #ifndef BABELTRACE_PLUGIN_PLUGIN_INTERNAL_H
   2 #define BABELTRACE_PLUGIN_PLUGIN_INTERNAL_H
   3
   4 /*
   5  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   6  * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  */
  26
  27 #include "common/macros.h"
  28 #include "lib/graph/component-class.h"
  29 #include <babeltrace2/plugin/plugin-const.h>
  30 #include <babeltrace2/plugin/plugin-dev.h>
  31 #include "lib/object.h"
  32 #include <babeltrace2/types.h>
  33 #include "common/assert.h"
  34 #include <glib.h>
  35
  36 #include "plugin-so.h"
  37
  38 /* Protection: this file uses BT_LIB_LOG*() macros directly */
  39 #ifndef BT_LIB_LOG_SUPPORTED
  40 # error Please include "lib/logging.h" before including this file.
  41 #endif
  42
  43 enum bt_plugin_type {
  44         BT_PLUGIN_TYPE_SO = 0,
  45         BT_PLUGIN_TYPE_PYTHON = 1,
  46 };
  47
  48 enum bt_plugin_status {
  49         BT_PLUGIN_STATUS_OK = 0,
  50         BT_PLUGIN_STATUS_ERROR = -1,
  51         BT_PLUGIN_STATUS_NOMEM = -12,
  52 };
  53
  54 struct bt_plugin {
  55         struct bt_object base;
  56         enum bt_plugin_type type;
  57
  58         /* Arrays of `struct bt_component_class *` (owned by this) */
  59         GPtrArray *src_comp_classes;
  60         GPtrArray *flt_comp_classes;
  61         GPtrArray *sink_comp_classes;
  62
  63         /* Info (owned by this) */
  64         struct {
  65                 GString *path;
  66                 GString *name;
  67                 GString *author;
  68                 GString *license;
  69                 GString *description;
  70                 struct {
  71                         unsigned int major;
  72                         unsigned int minor;
  73                         unsigned int patch;
  74                         GString *extra;
  75                 } version;
  76                 bool path_set;
  77                 bool name_set;
  78                 bool author_set;
  79                 bool license_set;
  80                 bool description_set;
  81                 bool version_set;
  82         } info;
  83
  84         /* Value depends on the specific plugin type */
  85         void *spec_data;
  86         void (*destroy_spec_data)(struct bt_plugin *);
  87 };
  88
  89 struct bt_plugin_set {
  90         struct bt_object base;
  91
  92         /* Array of struct bt_plugin * */
  93         GPtrArray *plugins;
  94 };
  95
  96 static inline
  97 const char *bt_plugin_status_string(enum bt_plugin_status status)
  98 {
  99         switch (status) {
 100         case BT_PLUGIN_STATUS_OK:
 101                 return "BT_PLUGIN_STATUS_OK";
 102         case BT_PLUGIN_STATUS_ERROR:
 103                 return "BT_PLUGIN_STATUS_ERROR";
 104         case BT_PLUGIN_STATUS_NOMEM:
 105                 return "BT_PLUGIN_STATUS_NOMEM";
 106         default:
 107                 return "(unknown)";
 108         }
 109 }
 110
 111 static inline
 112 const char *bt_plugin_type_string(enum bt_plugin_type type)
 113 {
 114         switch (type) {
 115         case BT_PLUGIN_TYPE_SO:
 116                 return "BT_PLUGIN_TYPE_SO";
 117         case BT_PLUGIN_TYPE_PYTHON:
 118                 return "BT_PLUGIN_TYPE_PYTHON";
 119         default:
 120                 return "(unknown)";
 121         }
 122 }
 123
 124 static inline
 125 void bt_plugin_destroy(struct bt_object *obj)
 126 {
 127         struct bt_plugin *plugin;
 128
 129         BT_ASSERT(obj);
 130         plugin = container_of(obj, struct bt_plugin, base);
 131         BT_LIB_LOGI("Destroying plugin object: %!+l", plugin);
 132
 133         if (plugin->destroy_spec_data) {
 134                 plugin->destroy_spec_data(plugin);
 135         }
 136
 137         if (plugin->src_comp_classes) {
 138                 BT_LOGD_STR("Putting source component classes.");
 139                 g_ptr_array_free(plugin->src_comp_classes, TRUE);
 140                 plugin->src_comp_classes = NULL;
 141         }
 142
 143         if (plugin->flt_comp_classes) {
 144                 BT_LOGD_STR("Putting filter component classes.");
 145                 g_ptr_array_free(plugin->flt_comp_classes, TRUE);
 146                 plugin->flt_comp_classes = NULL;
 147         }
 148
 149         if (plugin->sink_comp_classes) {
 150                 BT_LOGD_STR("Putting sink component classes.");
 151                 g_ptr_array_free(plugin->sink_comp_classes, TRUE);
 152                 plugin->sink_comp_classes = NULL;
 153         }
 154
 155         if (plugin->info.name) {
 156                 g_string_free(plugin->info.name, TRUE);
 157                 plugin->info.name = NULL;
 158         }
 159
 160         if (plugin->info.path) {
 161                 g_string_free(plugin->info.path, TRUE);
 162                 plugin->info.path = NULL;
 163         }
 164
 165         if (plugin->info.description) {
 166                 g_string_free(plugin->info.description, TRUE);
 167                 plugin->info.description = NULL;
 168         }
 169
 170         if (plugin->info.author) {
 171                 g_string_free(plugin->info.author, TRUE);
 172                 plugin->info.author = NULL;
 173         }
 174
 175         if (plugin->info.license) {
 176                 g_string_free(plugin->info.license, TRUE);
 177                 plugin->info.license = NULL;
 178         }
 179
 180         if (plugin->info.version.extra) {
 181                 g_string_free(plugin->info.version.extra, TRUE);
 182                 plugin->info.version.extra = NULL;
 183         }
 184
 185         g_free(plugin);
 186 }
 187
 188 static inline
 189 struct bt_plugin *bt_plugin_create_empty(enum bt_plugin_type type)
 190 {
 191         struct bt_plugin *plugin = NULL;
 192
 193         BT_LOGD("Creating empty plugin object: type=%s",
 194                 bt_plugin_type_string(type));
 195
 196         plugin = g_new0(struct bt_plugin, 1);
 197         if (!plugin) {
 198                 BT_LOGE_STR("Failed to allocate one plugin.");
 199                 goto error;
 200         }
 201
 202         bt_object_init_shared(&plugin->base, bt_plugin_destroy);
 203         plugin->type = type;
 204
 205         /* Create empty arrays of component classes */
 206         plugin->src_comp_classes =
 207                 g_ptr_array_new_with_free_func(
 208                         (GDestroyNotify) bt_object_put_ref);
 209         if (!plugin->src_comp_classes) {
 210                 BT_LOGE_STR("Failed to allocate a GPtrArray.");
 211                 goto error;
 212         }
 213
 214         plugin->flt_comp_classes =
 215                 g_ptr_array_new_with_free_func(
 216                         (GDestroyNotify) bt_object_put_ref);
 217         if (!plugin->flt_comp_classes) {
 218                 BT_LOGE_STR("Failed to allocate a GPtrArray.");
 219                 goto error;
 220         }
 221
 222         plugin->sink_comp_classes =
 223                 g_ptr_array_new_with_free_func(
 224                         (GDestroyNotify) bt_object_put_ref);
 225         if (!plugin->sink_comp_classes) {
 226                 BT_LOGE_STR("Failed to allocate a GPtrArray.");
 227                 goto error;
 228         }
 229
 230         /* Create empty info */
 231         plugin->info.name = g_string_new(NULL);
 232         if (!plugin->info.name) {
 233                 BT_LOGE_STR("Failed to allocate a GString.");
 234                 goto error;
 235         }
 236
 237         plugin->info.path = g_string_new(NULL);
 238         if (!plugin->info.path) {
 239                 BT_LOGE_STR("Failed to allocate a GString.");
 240                 goto error;
 241         }
 242
 243         plugin->info.description = g_string_new(NULL);
 244         if (!plugin->info.description) {
 245                 BT_LOGE_STR("Failed to allocate a GString.");
 246                 goto error;
 247         }
 248
 249         plugin->info.author = g_string_new(NULL);
 250         if (!plugin->info.author) {
 251                 BT_LOGE_STR("Failed to allocate a GString.");
 252                 goto error;
 253         }
 254
 255         plugin->info.license = g_string_new(NULL);
 256         if (!plugin->info.license) {
 257                 BT_LOGE_STR("Failed to allocate a GString.");
 258                 goto error;
 259         }
 260
 261         plugin->info.version.extra = g_string_new(NULL);
 262         if (!plugin->info.version.extra) {
 263                 BT_LOGE_STR("Failed to allocate a GString.");
 264                 goto error;
 265         }
 266
 267         BT_LIB_LOGD("Created empty plugin object: %!+l", plugin);
 268         goto end;
 269
 270 error:
 271         BT_OBJECT_PUT_REF_AND_RESET(plugin);
 272
 273 end:
 274         return plugin;
 275 }
 276
 277 static inline
 278 void bt_plugin_set_path(struct bt_plugin *plugin, const char *path)
 279 {
 280         BT_ASSERT(plugin);
 281         BT_ASSERT(path);
 282         g_string_assign(plugin->info.path, path);
 283         plugin->info.path_set = BT_TRUE;
 284         BT_LIB_LOGD("Set plugin's path: %![plugin-]+l, path=\"%s\"",
 285                 plugin, path);
 286 }
 287
 288 static inline
 289 void bt_plugin_set_name(struct bt_plugin *plugin, const char *name)
 290 {
 291         BT_ASSERT(plugin);
 292         BT_ASSERT(name);
 293         g_string_assign(plugin->info.name, name);
 294         plugin->info.name_set = BT_TRUE;
 295         BT_LIB_LOGD("Set plugin's name: %![plugin-]+l, name=\"%s\"",
 296                 plugin, name);
 297 }
 298
 299 static inline
 300 void bt_plugin_set_description(struct bt_plugin *plugin,
 301                 const char *description)
 302 {
 303         BT_ASSERT(plugin);
 304         BT_ASSERT(description);
 305         g_string_assign(plugin->info.description, description);
 306         plugin->info.description_set = BT_TRUE;
 307         BT_LIB_LOGD("Set plugin's description: %![plugin-]+l", plugin);
 308 }
 309
 310 static inline
 311 void bt_plugin_set_author(struct bt_plugin *plugin, const char *author)
 312 {
 313         BT_ASSERT(plugin);
 314         BT_ASSERT(author);
 315         g_string_assign(plugin->info.author, author);
 316         plugin->info.author_set = BT_TRUE;
 317         BT_LIB_LOGD("Set plugin's author: %![plugin-]+l, author=\"%s\"",
 318                 plugin, author);
 319 }
 320
 321 static inline
 322 void bt_plugin_set_license(struct bt_plugin *plugin, const char *license)
 323 {
 324         BT_ASSERT(plugin);
 325         BT_ASSERT(license);
 326         g_string_assign(plugin->info.license, license);
 327         plugin->info.license_set = BT_TRUE;
 328         BT_LIB_LOGD("Set plugin's path: %![plugin-]+l, license=\"%s\"",
 329                 plugin, license);
 330 }
 331
 332 static inline
 333 void bt_plugin_set_version(struct bt_plugin *plugin, unsigned int major,
 334                 unsigned int minor, unsigned int patch, const char *extra)
 335 {
 336         BT_ASSERT(plugin);
 337         plugin->info.version.major = major;
 338         plugin->info.version.minor = minor;
 339         plugin->info.version.patch = patch;
 340
 341         if (extra) {
 342                 g_string_assign(plugin->info.version.extra, extra);
 343         }
 344
 345         plugin->info.version_set = BT_TRUE;
 346         BT_LIB_LOGD("Set plugin's version: %![plugin-]+l, "
 347                 "major=%u, minor=%u, patch=%u, extra=\"%s\"",
 348                 plugin, major, minor, patch, extra);
 349 }
 350
 351 static inline
 352 enum bt_plugin_status bt_plugin_add_component_class(
 353         struct bt_plugin *plugin, struct bt_component_class *comp_class)
 354 {
 355         GPtrArray *comp_classes;
 356
 357         BT_ASSERT(plugin);
 358         BT_ASSERT(comp_class);
 359
 360         switch (comp_class->type) {
 361         case BT_COMPONENT_CLASS_TYPE_SOURCE:
 362                 comp_classes = plugin->src_comp_classes;
 363                 break;
 364         case BT_COMPONENT_CLASS_TYPE_FILTER:
 365                 comp_classes = plugin->flt_comp_classes;
 366                 break;
 367         case BT_COMPONENT_CLASS_TYPE_SINK:
 368                 comp_classes = plugin->sink_comp_classes;
 369                 break;
 370         default:
 371                 abort();
 372         }
 373
 374         /* Add new component class */
 375         bt_object_get_ref(comp_class);
 376         g_ptr_array_add(comp_classes, comp_class);
 377
 378         /* Special case for a shared object plugin */
 379         if (plugin->type == BT_PLUGIN_TYPE_SO) {
 380                 bt_plugin_so_on_add_component_class(plugin, comp_class);
 381         }
 382
 383         BT_LIB_LOGD("Added component class to plugin: "
 384                 "%![plugin-]+l, %![cc-]+C", plugin, comp_class);
 385         return BT_PLUGIN_STATUS_OK;
 386 }
 387
 388 static
 389 void bt_plugin_set_destroy(struct bt_object *obj)
 390 {
 391         struct bt_plugin_set *plugin_set =
 392                 container_of(obj, struct bt_plugin_set, base);
 393
 394         if (!plugin_set) {
 395                 return;
 396         }
 397
 398         BT_LOGD("Destroying plugin set: addr=%p", plugin_set);
 399
 400         if (plugin_set->plugins) {
 401                 BT_LOGD_STR("Putting plugins.");
 402                 g_ptr_array_free(plugin_set->plugins, TRUE);
 403         }
 404
 405         g_free(plugin_set);
 406 }
 407
 408 static inline
 409 struct bt_plugin_set *bt_plugin_set_create(void)
 410 {
 411         struct bt_plugin_set *plugin_set = g_new0(struct bt_plugin_set, 1);
 412
 413         if (!plugin_set) {
 414                 goto end;
 415         }
 416
 417         BT_LOGD_STR("Creating empty plugin set.");
 418         bt_object_init_shared(&plugin_set->base, bt_plugin_set_destroy);
 419
 420         plugin_set->plugins = g_ptr_array_new_with_free_func(
 421                 (GDestroyNotify) bt_object_put_ref);
 422         if (!plugin_set->plugins) {
 423                 BT_LOGE_STR("Failed to allocate a GPtrArray.");
 424                 BT_OBJECT_PUT_REF_AND_RESET(plugin_set);
 425                 goto end;
 426         }
 427
 428         BT_LOGD("Created empty plugin set: addr=%p", plugin_set);
 429
 430 end:
 431         return plugin_set;
 432 }
 433
 434 static inline
 435 void bt_plugin_set_add_plugin(struct bt_plugin_set *plugin_set,
 436                 struct bt_plugin *plugin)
 437 {
 438         BT_ASSERT(plugin_set);
 439         BT_ASSERT(plugin);
 440         bt_object_get_ref(plugin);
 441         g_ptr_array_add(plugin_set->plugins, plugin);
 442         BT_LIB_LOGD("Added plugin to plugin set: "
 443                 "plugin-set-addr=%p, %![plugin-]+l",
 444                 plugin_set, plugin);
 445 }
 446
 447 #endif /* BABELTRACE_PLUGIN_PLUGIN_INTERNAL_H */