include/babeltrace/plugin/plugin-internal.h

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