/*
- * babeltrace.c
- *
- * Babeltrace Trace Converter
- *
* Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
*
* Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
#include "logging.h"
#include <babeltrace/babeltrace.h>
-#include <babeltrace/plugin/plugin.h>
#include <babeltrace/common-internal.h>
-#include <babeltrace/graph/component.h>
-#include <babeltrace/graph/component-source.h>
-#include <babeltrace/graph/component-sink.h>
-#include <babeltrace/graph/component-filter.h>
-#include <babeltrace/graph/component-class.h>
-#include <babeltrace/graph/port.h>
-#include <babeltrace/graph/graph.h>
-#include <babeltrace/graph/connection.h>
-#include <babeltrace/graph/notification-iterator.h>
-#include <babeltrace/ref.h>
-#include <babeltrace/values.h>
-#include <babeltrace/values-internal.h>
-#include <babeltrace/logging.h>
#include <unistd.h>
#include <stdlib.h>
#include <popt.h>
*/
static const char* log_level_env_var_names[] = {
"BABELTRACE_COMMON_LOG_LEVEL",
+ "BABELTRACE_COMPAT_LOG_LEVEL",
"BABELTRACE_PLUGIN_CTF_BTR_LOG_LEVEL",
- "BABELTRACE_PLUGIN_CTF_FS_SRC_LOG_LEVEL",
- "BABELTRACE_PLUGIN_CTF_LTTNG_LIVE_SRC_LOG_LEVEL",
+ "BABELTRACE_SINK_CTF_FS_LOG_LEVEL",
+ "BABELTRACE_SRC_CTF_FS_LOG_LEVEL",
+ "BABELTRACE_SRC_CTF_LTTNG_LIVE_LOG_LEVEL",
"BABELTRACE_PLUGIN_CTF_METADATA_LOG_LEVEL",
"BABELTRACE_PLUGIN_CTF_NOTIF_ITER_LOG_LEVEL",
- "BABELTRACE_PLUGIN_LTTNG_UTILS_DEBUG_INFO_FLT_LOG_LEVEL",
- "BABELTRACE_PLUGIN_TEXT_DMESG_SRC_LOG_LEVEL",
- "BABELTRACE_PLUGIN_UTILS_MUXER_FLT_LOG_LEVEL",
- "BABELTRACE_PLUGIN_UTILS_TRIMMER_FLT_LOG_LEVEL",
"BABELTRACE_PLUGIN_CTFCOPYTRACE_LIB_LOG_LEVEL",
- "BABELTRACE_PLUGIN_CTF_FS_SINK_LOG_LEVEL",
+ "BABELTRACE_FLT_LTTNG_UTILS_DEBUG_INFO_LOG_LEVEL",
+ "BABELTRACE_SRC_TEXT_DMESG_LOG_LEVEL",
+ "BABELTRACE_SINK_TEXT_PRETTY_LOG_LEVEL",
+ "BABELTRACE_FLT_UTILS_MUXER_LOG_LEVEL",
+ "BABELTRACE_FLT_UTILS_TRIMMER_LOG_LEVEL",
+ "BABELTRACE_PYTHON_BT2_LOG_LEVEL",
"BABELTRACE_PYTHON_PLUGIN_PROVIDER_LOG_LEVEL",
NULL,
};
/* Application's processing graph (weak) */
-static struct bt_graph *the_graph;
+static struct bt_private_graph *the_graph;
+static struct bt_query_executor *the_query_executor;
static bool canceled = false;
GPtrArray *loaded_plugins;
+#ifdef __MINGW32__
+
+#include <windows.h>
+
+static
+BOOL WINAPI signal_handler(DWORD signal) {
+ if (the_graph) {
+ bt_private_graph_cancel(the_graph);
+ }
+
+ canceled = true;
+
+ return TRUE;
+}
+
static
-void sigint_handler(int signum)
+void set_signal_handler(void)
+{
+ if (!SetConsoleCtrlHandler(signal_handler, TRUE)) {
+ BT_LOGE("Failed to set the ctrl+c handler.");
+ }
+}
+
+#else /* __MINGW32__ */
+
+static
+void signal_handler(int signum)
{
if (signum != SIGINT) {
return;
}
if (the_graph) {
- bt_graph_cancel(the_graph);
+ bt_private_graph_cancel(the_graph);
+ }
+
+ if (the_query_executor) {
+ bt_query_executor_cancel(the_query_executor);
}
canceled = true;
}
+static
+void set_signal_handler(void)
+{
+ struct sigaction new_action, old_action;
+
+ new_action.sa_handler = signal_handler;
+ sigemptyset(&new_action.sa_mask);
+ new_action.sa_flags = 0;
+ sigaction(SIGINT, NULL, &old_action);
+
+ if (old_action.sa_handler != SIG_IGN) {
+ sigaction(SIGINT, &new_action, NULL);
+ }
+}
+
+#endif /* __MINGW32__ */
+
static
void init_static_data(void)
{
- loaded_plugins = g_ptr_array_new_with_free_func(bt_put);
+ loaded_plugins = g_ptr_array_new_with_free_func(bt_object_put_ref);
}
static
g_ptr_array_free(loaded_plugins, TRUE);
}
+static
+int create_the_query_executor(void)
+{
+ int ret = 0;
+
+ the_query_executor = bt_query_executor_create();
+ if (!the_query_executor) {
+ BT_LOGE_STR("Cannot create a query executor.");
+ ret = -1;
+ }
+
+ return ret;
+}
+
+static
+void destroy_the_query_executor(void)
+{
+ BT_OBJECT_PUT_REF_AND_RESET(the_query_executor);
+}
+
+static
+int query(struct bt_component_class *comp_cls, const char *obj,
+ struct bt_value *params, struct bt_value **user_result,
+ const char **fail_reason)
+{
+ struct bt_value *result = NULL;
+ enum bt_query_status status;
+ *fail_reason = "unknown error";
+ int ret = 0;
+
+ BT_ASSERT(fail_reason);
+ BT_ASSERT(user_result);
+ ret = create_the_query_executor();
+ if (ret) {
+ /* create_the_query_executor() logs errors */
+ goto end;
+ }
+
+ if (canceled) {
+ BT_LOGI("Canceled by user before executing the query: "
+ "comp-cls-addr=%p, comp-cls-name=\"%s\", "
+ "query-obj=\"%s\"", comp_cls,
+ bt_component_class_get_name(comp_cls), obj);
+ *fail_reason = "canceled by user";
+ goto error;
+ }
+
+ while (true) {
+ status = bt_query_executor_query(the_query_executor, comp_cls,
+ obj, params, &result);
+ switch (status) {
+ case BT_QUERY_STATUS_OK:
+ goto ok;
+ case BT_QUERY_STATUS_AGAIN:
+ {
+ const uint64_t sleep_time_us = 100000;
+
+ /* Wait 100 ms and retry */
+ BT_LOGV("Got BT_QUERY_STATUS_AGAIN: sleeping: "
+ "time-us=%" PRIu64, sleep_time_us);
+
+ if (usleep(sleep_time_us)) {
+ if (bt_query_executor_is_canceled(the_query_executor)) {
+ BT_LOGI("Query was canceled by user: "
+ "comp-cls-addr=%p, comp-cls-name=\"%s\", "
+ "query-obj=\"%s\"", comp_cls,
+ bt_component_class_get_name(comp_cls),
+ obj);
+ *fail_reason = "canceled by user";
+ goto error;
+ }
+ }
+
+ continue;
+ }
+ case BT_QUERY_STATUS_EXECUTOR_CANCELED:
+ *fail_reason = "canceled by user";
+ goto error;
+ case BT_QUERY_STATUS_ERROR:
+ case BT_QUERY_STATUS_INVALID:
+ goto error;
+ case BT_QUERY_STATUS_INVALID_OBJECT:
+ *fail_reason = "invalid or unknown query object";
+ goto error;
+ case BT_QUERY_STATUS_INVALID_PARAMS:
+ *fail_reason = "invalid query parameters";
+ goto error;
+ case BT_QUERY_STATUS_NOMEM:
+ *fail_reason = "not enough memory";
+ goto error;
+ default:
+ BT_LOGF("Unknown query status: status=%d", status);
+ abort();
+ }
+ }
+
+ok:
+ *user_result = result;
+ result = NULL;
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ destroy_the_query_executor();
+ bt_object_put_ref(result);
+ return ret;
+}
+
static
struct bt_plugin *find_plugin(const char *name)
{
int i;
struct bt_plugin *plugin = NULL;
- assert(name);
+ BT_ASSERT(name);
BT_LOGD("Finding plugin: name=\"%s\"", name);
for (i = 0; i < loaded_plugins->len; i++) {
}
}
- return bt_get(plugin);
+ return bt_object_get_ref(plugin);
}
static
comp_class = bt_plugin_get_component_class_by_name_and_type(plugin,
comp_class_name, comp_class_type);
- BT_PUT(plugin);
+ BT_OBJECT_PUT_REF_AND_RESET(plugin);
end:
if (BT_LOG_ON_DEBUG) {
print_indent(print_map_value_data->fp, print_map_value_data->indent);
fprintf(print_map_value_data->fp, "%s: ", key);
+ BT_ASSERT(object);
if (bt_value_is_array(object) &&
bt_value_array_is_empty(object)) {
const char *str_val;
int size;
int i;
- enum bt_value_status status;
if (!value) {
return;
bt_common_color_reset());
break;
case BT_VALUE_TYPE_BOOL:
- status = bt_value_bool_get(value, &bool_val);
- if (status != BT_VALUE_STATUS_OK) {
- goto error;
- }
+ bool_val = bt_value_bool_get(value);
fprintf(fp, "%s%s%s%s\n", bt_common_color_bold(),
bt_common_color_fg_cyan(), bool_val ? "yes" : "no",
bt_common_color_reset());
break;
case BT_VALUE_TYPE_INTEGER:
- status = bt_value_integer_get(value, &int_val);
- if (status != BT_VALUE_STATUS_OK) {
- goto error;
- }
+ int_val = bt_value_integer_get(value);
fprintf(fp, "%s%s%" PRId64 "%s\n", bt_common_color_bold(),
bt_common_color_fg_red(), int_val,
bt_common_color_reset());
break;
- case BT_VALUE_TYPE_FLOAT:
- status = bt_value_float_get(value, &dbl_val);
- if (status != BT_VALUE_STATUS_OK) {
- goto error;
- }
+ case BT_VALUE_TYPE_REAL:
+ dbl_val = bt_value_real_get(value);
fprintf(fp, "%s%s%lf%s\n", bt_common_color_bold(),
bt_common_color_fg_red(), dbl_val,
bt_common_color_reset());
break;
case BT_VALUE_TYPE_STRING:
- status = bt_value_string_get(value, &str_val);
- if (status != BT_VALUE_STATUS_OK) {
- goto error;
- }
+ str_val = bt_value_string_get(value);
fprintf(fp, "%s%s%s%s\n", bt_common_color_bold(),
bt_common_color_fg_green(), str_val,
bt_common_color_reset());
break;
case BT_VALUE_TYPE_ARRAY:
- size = bt_value_array_size(value);
+ size = bt_value_array_get_size(value);
if (size < 0) {
goto error;
}
for (i = 0; i < size; i++) {
struct bt_value *element =
- bt_value_array_get(value, i);
+ bt_value_array_borrow_element_by_index(
+ value, i);
if (!element) {
goto error;
}
print_value_rec(fp, element, indent + 2);
- BT_PUT(element);
}
break;
case BT_VALUE_TYPE_MAP:
break;
}
- bt_value_map_foreach(value, print_map_value, &data);
+ bt_value_map_foreach_entry(value, print_map_value, &data);
break;
}
default:
error:
BT_LOGE("Error printing value of type %s.",
- bt_value_type_string(bt_value_get_type(value)));
+ bt_common_value_type_string(bt_value_get_type(value)));
}
static
}
fprintf(stderr, " Parameters:\n");
- print_value(stderr, bt_config_component->params, 8);
+ print_value(stderr,
+ bt_value_borrow_from_private(bt_config_component->params), 8);
}
static
struct bt_config_component *cfg_component =
bt_config_get_component(array, i);
print_bt_config_component(cfg_component);
- BT_PUT(cfg_component);
+ BT_OBJECT_PUT_REF_AND_RESET(cfg_component);
}
}
{
size_t i;
- print_plugin_paths(cfg->plugin_paths);
+ print_plugin_paths(bt_value_borrow_from_private(cfg->plugin_paths));
fprintf(stderr, " Source component instances:\n");
print_bt_config_components(cfg->cmd_data.run.sources);
static
void print_cfg_list_plugins(struct bt_config *cfg)
{
- print_plugin_paths(cfg->plugin_paths);
+ print_plugin_paths(bt_value_borrow_from_private(cfg->plugin_paths));
}
static
void print_cfg_help(struct bt_config *cfg)
{
- print_plugin_paths(cfg->plugin_paths);
+ print_plugin_paths(bt_value_borrow_from_private(cfg->plugin_paths));
}
static
void print_cfg_print_ctf_metadata(struct bt_config *cfg)
{
- print_plugin_paths(cfg->plugin_paths);
+ print_plugin_paths(bt_value_borrow_from_private(cfg->plugin_paths));
fprintf(stderr, " Path: %s\n",
cfg->cmd_data.print_ctf_metadata.path->str);
}
static
void print_cfg_print_lttng_live_sessions(struct bt_config *cfg)
{
- print_plugin_paths(cfg->plugin_paths);
+ print_plugin_paths(bt_value_borrow_from_private(cfg->plugin_paths));
fprintf(stderr, " URL: %s\n",
cfg->cmd_data.print_lttng_live_sessions.url->str);
}
static
void print_cfg_query(struct bt_config *cfg)
{
- print_plugin_paths(cfg->plugin_paths);
+ print_plugin_paths(bt_value_borrow_from_private(cfg->plugin_paths));
fprintf(stderr, " Object: `%s`\n", cfg->cmd_data.query.object->str);
fprintf(stderr, " Component class:\n");
print_bt_config_component(cfg->cmd_data.query.cfg_component);
int64_t count;
count = bt_plugin_set_get_plugin_count(plugin_set);
- assert(count >= 0);
+ BT_ASSERT(count >= 0);
for (i = 0; i < count; i++) {
struct bt_plugin *plugin =
struct bt_plugin *loaded_plugin =
find_plugin(bt_plugin_get_name(plugin));
- assert(plugin);
+ BT_ASSERT(plugin);
if (loaded_plugin) {
BT_LOGI("Not using plugin: another one already exists with the same name: "
bt_plugin_get_name(plugin),
bt_plugin_get_path(plugin),
bt_plugin_get_path(loaded_plugin));
- bt_put(loaded_plugin);
+ bt_object_put_ref(loaded_plugin);
} else {
/* Add to global array. */
BT_LOGD("Adding plugin to loaded plugins: plugin-path=\"%s\"",
bt_plugin_get_name(plugin));
- g_ptr_array_add(loaded_plugins, bt_get(plugin));
+ g_ptr_array_add(loaded_plugins, bt_object_get_ref(plugin));
}
- bt_put(plugin);
+ bt_object_put_ref(plugin);
}
}
{
int nr_paths, i, ret = 0;
- nr_paths = bt_value_array_size(plugin_paths);
+ nr_paths = bt_value_array_get_size(plugin_paths);
if (nr_paths < 0) {
BT_LOGE_STR("Cannot load dynamic plugins: no plugin path.");
ret = -1;
struct bt_value *plugin_path_value = NULL;
const char *plugin_path;
struct bt_plugin_set *plugin_set;
- enum bt_value_status status;
- plugin_path_value = bt_value_array_get(plugin_paths, i);
- status = bt_value_string_get(plugin_path_value, &plugin_path);
- if (status != BT_VALUE_STATUS_OK) {
- BT_LOGD_STR("Cannot get plugin path string.");
- BT_PUT(plugin_path_value);
- continue;
- }
+ plugin_path_value = bt_value_array_borrow_element_by_index(
+ plugin_paths, i);
+ plugin_path = bt_value_string_get(plugin_path_value);
/*
* Skip this if the directory does not exist because
if (!g_file_test(plugin_path, G_FILE_TEST_IS_DIR)) {
BT_LOGV("Skipping nonexistent directory path: "
"path=\"%s\"", plugin_path);
- BT_PUT(plugin_path_value);
continue;
}
if (!plugin_set) {
BT_LOGD("Unable to load dynamic plugins: path=\"%s\"",
plugin_path);
- BT_PUT(plugin_path_value);
continue;
}
add_to_loaded_plugins(plugin_set);
- bt_put(plugin_set);
- BT_PUT(plugin_path_value);
+ bt_object_put_ref(plugin_set);
}
end:
return ret;
}
add_to_loaded_plugins(plugin_set);
- bt_put(plugin_set);
+ bt_object_put_ref(plugin_set);
end:
return ret;
}
printf("%s%s%s%s:\n", bt_common_color_bold(),
bt_common_color_fg_blue(), plugin_name,
bt_common_color_reset());
- printf(" %sPath%s: %s\n", bt_common_color_bold(),
- bt_common_color_reset(), path ? path : "(None)");
+ if (path) {
+ printf(" %sPath%s: %s\n", bt_common_color_bold(),
+ bt_common_color_reset(), path);
+ } else {
+ puts(" Built-in");
+ }
if (version_status == BT_PLUGIN_STATUS_OK) {
printf(" %sVersion%s: %u.%u.%u",
int ret = 0;
struct bt_component_class *comp_cls = NULL;
struct bt_value *results = NULL;
+ const char *fail_reason = NULL;
comp_cls = find_component_class(cfg->cmd_data.query.cfg_component->plugin_name->str,
cfg->cmd_data.query.cfg_component->comp_cls_name->str,
goto end;
}
- results = bt_component_class_query(comp_cls,
- cfg->cmd_data.query.object->str,
- cfg->cmd_data.query.cfg_component->params);
- if (!results) {
- BT_LOGE("Failed to query component class: plugin-name=\"%s\", "
- "comp-cls-name=\"%s\", comp-cls-type=%d "
- "object=\"%s\"",
- cfg->cmd_data.query.cfg_component->plugin_name->str,
- cfg->cmd_data.query.cfg_component->comp_cls_name->str,
- cfg->cmd_data.query.cfg_component->type,
- cfg->cmd_data.query.object->str);
- fprintf(stderr, "%s%sFailed to query info to %s",
- bt_common_color_bold(),
- bt_common_color_fg_red(),
- bt_common_color_reset());
- print_plugin_comp_cls_opt(stderr,
- cfg->cmd_data.query.cfg_component->plugin_name->str,
- cfg->cmd_data.query.cfg_component->comp_cls_name->str,
- cfg->cmd_data.query.cfg_component->type);
- fprintf(stderr, "%s%s with object `%s`%s\n",
- bt_common_color_bold(),
- bt_common_color_fg_red(),
- cfg->cmd_data.query.object->str,
- bt_common_color_reset());
- ret = -1;
- goto end;
+ ret = query(comp_cls, cfg->cmd_data.query.object->str,
+ bt_value_borrow_from_private(cfg->cmd_data.query.cfg_component->params),
+ &results, &fail_reason);
+ if (ret) {
+ goto failed;
}
print_value(stdout, results, 0);
+ goto end;
+
+failed:
+ BT_LOGE("Failed to query component class: %s: plugin-name=\"%s\", "
+ "comp-cls-name=\"%s\", comp-cls-type=%d "
+ "object=\"%s\"", fail_reason,
+ cfg->cmd_data.query.cfg_component->plugin_name->str,
+ cfg->cmd_data.query.cfg_component->comp_cls_name->str,
+ cfg->cmd_data.query.cfg_component->type,
+ cfg->cmd_data.query.object->str);
+ fprintf(stderr, "%s%sFailed to query info to %s",
+ bt_common_color_bold(),
+ bt_common_color_fg_red(),
+ bt_common_color_reset());
+ print_plugin_comp_cls_opt(stderr,
+ cfg->cmd_data.query.cfg_component->plugin_name->str,
+ cfg->cmd_data.query.cfg_component->comp_cls_name->str,
+ cfg->cmd_data.query.cfg_component->type);
+ fprintf(stderr, "%s%s with object `%s`: %s%s\n",
+ bt_common_color_bold(),
+ bt_common_color_fg_red(),
+ cfg->cmd_data.query.object->str,
+ fail_reason,
+ bt_common_color_reset());
+ ret = -1;
end:
- bt_put(comp_cls);
- bt_put(results);
+ bt_object_put_ref(comp_cls);
+ bt_object_put_ref(results);
return ret;
}
goto end;
}
- bt_put(needed_comp_cls);
+ bt_object_put_ref(needed_comp_cls);
}
for (i = 0; i < bt_plugin_get_component_class_count(plugin); i++) {
enum bt_component_class_type type =
bt_component_class_get_type(comp_cls);
- assert(comp_cls);
+ BT_ASSERT(comp_cls);
if (cfg->cmd_data.help.cfg_component->type !=
BT_COMPONENT_CLASS_TYPE_UNKNOWN) {
if (strcmp(cfg->cmd_data.help.cfg_component->comp_cls_name->str,
- comp_class_name) != 0 &&
- type ==
- cfg->cmd_data.help.cfg_component->type) {
- bt_put(comp_cls);
+ comp_class_name) != 0 ||
+ type != cfg->cmd_data.help.cfg_component->type) {
+ bt_object_put_ref(comp_cls);
continue;
}
}
printf("\n%s\n", comp_class_help);
}
- bt_put(comp_cls);
+ bt_object_put_ref(comp_cls);
}
end:
- bt_put(plugin);
+ bt_object_put_ref(plugin);
return ret;
}
int plugins_count, component_classes_count = 0, i;
printf("From the following plugin paths:\n\n");
- print_value(stdout, cfg->plugin_paths, 2);
+ print_value(stdout, bt_value_borrow_from_private(cfg->plugin_paths), 2);
printf("\n");
plugins_count = loaded_plugins->len;
if (plugins_count == 0) {
}
printf("\n");
- bt_put(comp_class);
+ bt_object_put_ref(comp_class);
}
}
int ret = 0;
struct bt_component_class *comp_cls = NULL;
struct bt_value *results = NULL;
- struct bt_value *params = NULL;
+ struct bt_private_value *params = NULL;
struct bt_value *map = NULL;
struct bt_value *v = NULL;
static const char * const plugin_name = "ctf";
static const enum bt_component_class_type comp_cls_type =
BT_COMPONENT_CLASS_TYPE_SOURCE;
int64_t array_size, i;
+ const char *fail_reason = NULL;
+ FILE *out_stream = stdout;
- assert(cfg->cmd_data.print_lttng_live_sessions.url);
+ BT_ASSERT(cfg->cmd_data.print_lttng_live_sessions.url);
comp_cls = find_component_class(plugin_name, comp_cls_name,
comp_cls_type);
if (!comp_cls) {
goto error;
}
- params = bt_value_map_create();
+ params = bt_private_value_map_create();
if (!params) {
goto error;
}
- ret = bt_value_map_insert_string(params, "url",
+ ret = bt_private_value_map_insert_string_entry(params, "url",
cfg->cmd_data.print_lttng_live_sessions.url->str);
if (ret) {
goto error;
}
- results = bt_component_class_query(comp_cls, "sessions",
- params);
- if (!results) {
- BT_LOGE_STR("Failed to query for sessions.");
- fprintf(stderr, "%s%sFailed to request sessions%s\n",
- bt_common_color_bold(),
- bt_common_color_fg_red(),
- bt_common_color_reset());
- goto error;
+ ret = query(comp_cls, "sessions", bt_value_borrow_from_private(params),
+ &results, &fail_reason);
+ if (ret) {
+ goto failed;
}
+ BT_ASSERT(results);
+
if (!bt_value_is_array(results)) {
BT_LOGE_STR("Expecting an array for sessions query.");
fprintf(stderr, "%s%sUnexpected type returned by session query%s\n",
goto error;
}
- array_size = bt_value_array_size(results);
+ if (cfg->cmd_data.print_lttng_live_sessions.output_path->len > 0) {
+ out_stream =
+ fopen(cfg->cmd_data.print_lttng_live_sessions.output_path->str,
+ "w");
+ if (!out_stream) {
+ ret = -1;
+ BT_LOGE_ERRNO("Cannot open file for writing",
+ ": path=\"%s\"",
+ cfg->cmd_data.print_lttng_live_sessions.output_path->str);
+ goto end;
+ }
+ }
+
+ array_size = bt_value_array_get_size(results);
for (i = 0; i < array_size; i++) {
const char *url_text;
int64_t timer_us, streams, clients;
- map = bt_value_array_get(results, i);
+ map = bt_value_array_borrow_element_by_index(results, i);
if (!map) {
BT_LOGE_STR("Unexpected empty array entry.");
goto error;
goto error;
}
- v = bt_value_map_get(map, "url");
+ v = bt_value_map_borrow_entry_value(map, "url");
if (!v) {
BT_LOGE_STR("Unexpected empty array \"url\" entry.");
goto error;
}
- ret = bt_value_string_get(v, &url_text);
- assert(ret == 0);
- printf("%s", url_text);
- BT_PUT(v);
-
- v = bt_value_map_get(map, "timer-us");
+ url_text = bt_value_string_get(v);
+ fprintf(out_stream, "%s", url_text);
+ v = bt_value_map_borrow_entry_value(map, "timer-us");
if (!v) {
BT_LOGE_STR("Unexpected empty array \"timer-us\" entry.");
goto error;
}
- ret = bt_value_integer_get(v, &timer_us);
- assert(ret == 0);
- printf(" (timer = %" PRIu64 ", ", timer_us);
- BT_PUT(v);
-
- v = bt_value_map_get(map, "stream-count");
+ timer_us = bt_value_integer_get(v);
+ fprintf(out_stream, " (timer = %" PRIu64 ", ", timer_us);
+ v = bt_value_map_borrow_entry_value(map, "stream-count");
if (!v) {
BT_LOGE_STR("Unexpected empty array \"stream-count\" entry.");
goto error;
}
- ret = bt_value_integer_get(v, &streams);
- assert(ret == 0);
- printf("%" PRIu64 " stream(s), ", streams);
- BT_PUT(v);
-
- v = bt_value_map_get(map, "client-count");
+ streams = bt_value_integer_get(v);
+ fprintf(out_stream, "%" PRIu64 " stream(s), ", streams);
+ v = bt_value_map_borrow_entry_value(map, "client-count");
if (!v) {
BT_LOGE_STR("Unexpected empty array \"client-count\" entry.");
goto error;
}
- ret = bt_value_integer_get(v, &clients);
- assert(ret == 0);
- printf("%" PRIu64 " client(s) connected)\n", clients);
- BT_PUT(v);
-
- BT_PUT(map);
+ clients = bt_value_integer_get(v);
+ fprintf(out_stream, "%" PRIu64 " client(s) connected)\n", clients);
}
-end:
- bt_put(v);
- bt_put(map);
- bt_put(results);
- bt_put(params);
- bt_put(comp_cls);
- return 0;
+
+ goto end;
+
+failed:
+ BT_LOGE("Failed to query for sessions: %s", fail_reason);
+ fprintf(stderr, "%s%sFailed to request sessions: %s%s\n",
+ bt_common_color_bold(),
+ bt_common_color_fg_red(),
+ fail_reason,
+ bt_common_color_reset());
error:
ret = -1;
- goto end;
+
+end:
+ bt_object_put_ref(results);
+ bt_object_put_ref(params);
+ bt_object_put_ref(comp_cls);
+
+ if (out_stream && out_stream != stdout) {
+ int fclose_ret = fclose(out_stream);
+
+ if (fclose_ret) {
+ BT_LOGE_ERRNO("Cannot close file stream",
+ ": path=\"%s\"",
+ cfg->cmd_data.print_lttng_live_sessions.output_path->str);
+ }
+ }
+
+ return 0;
}
static
int ret = 0;
struct bt_component_class *comp_cls = NULL;
struct bt_value *results = NULL;
- struct bt_value *params = NULL;
+ struct bt_private_value *params = NULL;
struct bt_value *metadata_text_value = NULL;
const char *metadata_text = NULL;
static const char * const plugin_name = "ctf";
static const char * const comp_cls_name = "fs";
static const enum bt_component_class_type comp_cls_type =
BT_COMPONENT_CLASS_TYPE_SOURCE;
+ const char *fail_reason = NULL;
+ FILE *out_stream = stdout;
- assert(cfg->cmd_data.print_ctf_metadata.path);
+ BT_ASSERT(cfg->cmd_data.print_ctf_metadata.path);
comp_cls = find_component_class(plugin_name, comp_cls_name,
comp_cls_type);
if (!comp_cls) {
goto end;
}
- params = bt_value_map_create();
+ params = bt_private_value_map_create();
if (!params) {
ret = -1;
goto end;
}
- ret = bt_value_map_insert_string(params, "path",
+ ret = bt_private_value_map_insert_string_entry(params, "path",
cfg->cmd_data.print_ctf_metadata.path->str);
if (ret) {
ret = -1;
goto end;
}
- results = bt_component_class_query(comp_cls, "metadata-info",
- params);
- if (!results) {
- ret = -1;
- BT_LOGE_STR("Failed to query for metadata info.");
- fprintf(stderr, "%s%sFailed to request metadata info%s\n",
- bt_common_color_bold(),
- bt_common_color_fg_red(),
- bt_common_color_reset());
- goto end;
+ ret = query(comp_cls, "metadata-info",
+ bt_value_borrow_from_private(params), &results, &fail_reason);
+ if (ret) {
+ goto failed;
}
- metadata_text_value = bt_value_map_get(results, "text");
+ metadata_text_value = bt_value_map_borrow_entry_value(results, "text");
if (!metadata_text_value) {
BT_LOGE_STR("Cannot find `text` string value in the resulting metadata info object.");
ret = -1;
goto end;
}
- ret = bt_value_string_get(metadata_text_value, &metadata_text);
- assert(ret == 0);
- printf("%s\n", metadata_text);
+ metadata_text = bt_value_string_get(metadata_text_value);
+
+ if (cfg->cmd_data.print_ctf_metadata.output_path->len > 0) {
+ out_stream =
+ fopen(cfg->cmd_data.print_ctf_metadata.output_path->str,
+ "w");
+ if (!out_stream) {
+ ret = -1;
+ BT_LOGE_ERRNO("Cannot open file for writing",
+ ": path=\"%s\"",
+ cfg->cmd_data.print_ctf_metadata.output_path->str);
+ goto end;
+ }
+ }
+
+ ret = fprintf(out_stream, "%s\n", metadata_text);
+ if (ret < 0) {
+ BT_LOGE("Cannot write whole metadata text to output stream: "
+ "ret=%d", ret);
+ }
+
+ goto end;
+
+failed:
+ ret = -1;
+ BT_LOGE("Failed to query for metadata info: %s", fail_reason);
+ fprintf(stderr, "%s%sFailed to request metadata info: %s%s\n",
+ bt_common_color_bold(),
+ bt_common_color_fg_red(),
+ fail_reason,
+ bt_common_color_reset());
end:
- bt_put(results);
- bt_put(params);
- bt_put(metadata_text_value);
- bt_put(comp_cls);
+ destroy_the_query_executor();
+ bt_object_put_ref(results);
+ bt_object_put_ref(params);
+ bt_object_put_ref(comp_cls);
+
+ if (out_stream && out_stream != stdout) {
+ int fclose_ret = fclose(out_stream);
+
+ if (fclose_ret) {
+ BT_LOGE_ERRNO("Cannot close file stream",
+ ": path=\"%s\"",
+ cfg->cmd_data.print_ctf_metadata.output_path->str);
+ }
+ }
+
return 0;
}
{
const struct port_id *id = v;
- assert(id->instance_name);
- assert(id->port_name);
+ BT_ASSERT(id->instance_name);
+ BT_ASSERT(id->port_name);
return g_str_hash(id->instance_name) ^ g_str_hash(id->port_name);
}
GHashTable *components;
/* Owned by this */
- struct bt_graph *graph;
+ struct bt_private_graph *graph;
/* Weak */
struct bt_config *cfg;
struct bt_port *(*port_by_index_fn)(struct bt_component *, uint64_t);
enum bt_graph_status status = BT_GRAPH_STATUS_ERROR;
bool insert_trimmer = false;
- struct bt_value *trimmer_params = NULL;
+ struct bt_private_value *trimmer_params = NULL;
char *intersection_begin = NULL;
char *intersection_end = NULL;
struct bt_component *trimmer = NULL;
}
insert_trimmer = true;
- trimmer_params = bt_value_map_create();
+ trimmer_params = bt_private_value_map_create();
if (!trimmer_params) {
goto error;
}
- status = bt_value_map_insert_string(trimmer_params,
- "begin", intersection_begin);
+ status = bt_private_value_map_insert_string_entry(
+ trimmer_params, "begin", intersection_begin);
if (status != BT_VALUE_STATUS_OK) {
goto error;
}
- status = bt_value_map_insert_string(trimmer_params,
+ status = bt_private_value_map_insert_string_entry(
+ trimmer_params,
"end", intersection_end);
if (status != BT_VALUE_STATUS_OK) {
goto error;
cfg_conn->arg->str);
downstreamp_comp_name_quark = g_quark_from_string(
cfg_conn->downstream_comp_name->str);
- assert(downstreamp_comp_name_quark > 0);
+ BT_ASSERT(downstreamp_comp_name_quark > 0);
downstream_comp = g_hash_table_lookup(ctx->components,
GUINT_TO_POINTER(downstreamp_comp_name_quark));
if (!downstream_comp) {
}
downstream_port_count = port_count_fn(downstream_comp);
- assert(downstream_port_count >= 0);
+ BT_ASSERT(downstream_port_count >= 0);
for (i = 0; i < downstream_port_count; i++) {
struct bt_port *downstream_port =
const char *upstream_port_name;
const char *downstream_port_name;
- assert(downstream_port);
+ BT_ASSERT(downstream_port);
/* Skip port if it's already connected. */
if (bt_port_is_connected(downstream_port)) {
- bt_put(downstream_port);
+ bt_object_put_ref(downstream_port);
BT_LOGD("Skipping downstream port: already connected: "
"port-addr=%p, port-name=\"%s\"",
downstream_port,
}
downstream_port_name = bt_port_get_name(downstream_port);
- assert(downstream_port_name);
+ BT_ASSERT(downstream_port_name);
upstream_port_name = bt_port_get_name(upstream_port);
- assert(upstream_port_name);
+ BT_ASSERT(upstream_port_name);
if (!bt_common_star_glob_match(
cfg_conn->downstream_port_glob->str, SIZE_MAX,
downstream_port_name, SIZE_MAX)) {
- bt_put(downstream_port);
+ bt_object_put_ref(downstream_port);
continue;
}
ret = 0;
ctx->connect_ports = false;
- graph_status = bt_graph_add_component(ctx->graph,
- trimmer_class, trimmer_name, trimmer_params,
+ graph_status = bt_private_graph_add_component(ctx->graph,
+ trimmer_class, trimmer_name,
+ bt_value_borrow_from_private(trimmer_params),
&trimmer);
free(trimmer_name);
if (graph_status != BT_GRAPH_STATUS_OK) {
goto error;
}
- assert(trimmer);
+ BT_ASSERT(trimmer);
trimmer_input =
bt_component_filter_get_input_port_by_index(
* Replace the current downstream port by the trimmer's
* upstream port.
*/
- BT_MOVE(downstream_port, trimmer_input);
+ BT_OBJECT_MOVE_REF(downstream_port, trimmer_input);
downstream_port_name = bt_port_get_name(
downstream_port);
if (!downstream_port_name) {
}
/* We have a winner! */
- status = bt_graph_connect_ports(ctx->graph,
+ status = bt_private_graph_connect_ports(ctx->graph,
upstream_port, downstream_port, NULL);
- BT_PUT(downstream_port);
+ BT_OBJECT_PUT_REF_AND_RESET(downstream_port);
switch (status) {
case BT_GRAPH_STATUS_OK:
break;
end:
free(intersection_begin);
free(intersection_end);
- BT_PUT(trimmer_params);
- BT_PUT(trimmer_class);
- BT_PUT(trimmer);
- BT_PUT(trimmer_input);
- BT_PUT(trimmer_output);
+ BT_OBJECT_PUT_REF_AND_RESET(trimmer_params);
+ BT_OBJECT_PUT_REF_AND_RESET(trimmer_class);
+ BT_OBJECT_PUT_REF_AND_RESET(trimmer);
+ BT_OBJECT_PUT_REF_AND_RESET(trimmer_input);
+ BT_OBJECT_PUT_REF_AND_RESET(trimmer_output);
return ret;
}
struct bt_component *upstream_comp = NULL;
size_t i;
- assert(ctx);
- assert(upstream_port);
+ BT_ASSERT(ctx);
+ BT_ASSERT(upstream_port);
upstream_port_name = bt_port_get_name(upstream_port);
- assert(upstream_port_name);
+ BT_ASSERT(upstream_port_name);
upstream_comp = bt_port_get_component(upstream_port);
if (!upstream_comp) {
BT_LOGW("Upstream port to connect is not part of a component: "
}
upstream_comp_name = bt_component_get_name(upstream_comp);
- assert(upstream_comp_name);
+ BT_ASSERT(upstream_comp_name);
BT_LOGI("Connecting upstream port: comp-addr=%p, comp-name=\"%s\", "
"port-addr=%p, port-name=\"%s\"",
upstream_comp, upstream_comp_name,
ret = -1;
end:
- bt_put(upstream_comp);
+ bt_object_put_ref(upstream_comp);
return ret;
}
}
end:
- bt_put(comp);
+ bt_object_put_ref(comp);
return;
}
struct bt_component *upstream_comp = bt_port_get_component(upstream_port);
struct bt_component *downstream_comp = bt_port_get_component(downstream_port);
- assert(upstream_comp);
- assert(downstream_comp);
+ BT_ASSERT(upstream_comp);
+ BT_ASSERT(downstream_comp);
BT_LOGI("Graph's component ports connected: "
"upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
"upstream-port-addr=%p, upstream-port-name=\"%s\", "
upstream_port, bt_port_get_name(upstream_port),
downstream_comp, bt_component_get_name(downstream_comp),
downstream_port, bt_port_get_name(downstream_port));
- bt_put(upstream_comp);
- bt_put(downstream_comp);
+ bt_object_put_ref(upstream_comp);
+ bt_object_put_ref(downstream_comp);
}
static
ctx->intersections = NULL;
}
- BT_PUT(ctx->graph);
+ BT_OBJECT_PUT_REF_AND_RESET(ctx->graph);
the_graph = NULL;
ctx->cfg = NULL;
}
ctx->cfg = cfg;
ctx->connect_ports = false;
ctx->components = g_hash_table_new_full(g_direct_hash, g_direct_equal,
- NULL, bt_put);
+ NULL, bt_object_put_ref);
if (!ctx->components) {
goto error;
}
}
}
- ctx->graph = bt_graph_create();
+ ctx->graph = bt_private_graph_create();
if (!ctx->graph) {
goto error;
}
the_graph = ctx->graph;
- ret = bt_graph_add_port_added_listener(ctx->graph,
+ ret = bt_private_graph_add_port_added_listener(ctx->graph,
graph_port_added_listener, NULL, ctx);
if (ret < 0) {
BT_LOGE_STR("Cannot add \"port added\" listener to graph.");
goto error;
}
- ret = bt_graph_add_port_removed_listener(ctx->graph,
+ ret = bt_private_graph_add_port_removed_listener(ctx->graph,
graph_port_removed_listener, NULL, ctx);
if (ret < 0) {
BT_LOGE_STR("Cannot add \"port removed\" listener to graph.");
goto error;
}
- ret = bt_graph_add_ports_connected_listener(ctx->graph,
+ ret = bt_private_graph_add_ports_connected_listener(ctx->graph,
graph_ports_connected_listener, NULL, ctx);
if (ret < 0) {
BT_LOGE_STR("Cannot add \"ports connected\" listener to graph.");
goto error;
}
- ret = bt_graph_add_ports_disconnected_listener(ctx->graph,
+ ret = bt_private_graph_add_ports_disconnected_listener(ctx->graph,
graph_ports_disconnected_listener, NULL, ctx);
if (ret < 0) {
BT_LOGE_STR("Cannot add \"ports disconnected\" listener to graph.");
enum bt_value_status value_status;
const char *path = NULL;
struct bt_value *component_path_value = NULL;
- struct bt_value *query_params = NULL;
+ struct bt_private_value *query_params = NULL;
struct bt_value *query_result = NULL;
struct bt_value *trace_info = NULL;
struct bt_value *intersection_range = NULL;
struct bt_value *stream_info = NULL;
struct port_id *port_id = NULL;
struct trace_range *trace_range = NULL;
+ const char *fail_reason = NULL;
- component_path_value = bt_value_map_get(cfg_comp->params, "path");
- if (!bt_value_is_string(component_path_value)) {
+ component_path_value = bt_value_map_borrow_entry_value(
+ bt_value_borrow_from_private(cfg_comp->params),
+ "path");
+ if (component_path_value && !bt_value_is_string(component_path_value)) {
BT_LOGD("Cannot get path parameter: component-name=%s",
cfg_comp->instance_name->str);
ret = -1;
goto error;
}
- value_status = bt_value_string_get(component_path_value, &path);
- if (value_status != BT_VALUE_STATUS_OK) {
- BT_LOGD("Cannot get path string value: component-name=%s",
- cfg_comp->instance_name->str);
- ret = -1;
- goto error;
- }
-
- query_params = bt_value_map_create();
+ path = bt_value_string_get(component_path_value);
+ query_params = bt_private_value_map_create();
if (!query_params) {
BT_LOGE_STR("Cannot create query parameters.");
ret = -1;
goto error;
}
- value_status = bt_value_map_insert(query_params, "path", component_path_value);
+ value_status = bt_private_value_map_insert_entry(query_params, "path",
+ component_path_value);
if (value_status != BT_VALUE_STATUS_OK) {
- BT_LOGE_STR("Cannot insert path parameter in query paramater map.");
+ BT_LOGE_STR("Cannot insert path parameter in query parameter map.");
ret = -1;
goto error;
}
- query_result = bt_component_class_query(comp_cls, "trace-info",
- query_params);
- if (!query_result) {
- BT_LOGD("Component class \'%s\' does not support the \'trace-info\' query.",
+ ret = query(comp_cls, "trace-info",
+ bt_value_borrow_from_private(query_params), &query_result,
+ &fail_reason);
+ if (ret) {
+ BT_LOGD("Component class does not support the `trace-info` query: %s: "
+ "comp-class-name=\"%s\"", fail_reason,
bt_component_class_get_name(comp_cls));
ret = -1;
goto error;
}
+ BT_ASSERT(query_result);
+
if (!bt_value_is_array(query_result)) {
BT_LOGD("Unexpected format of \'trace-info\' query result: "
"component-class-name=%s",
goto error;
}
- trace_count = bt_value_array_size(query_result);
+ trace_count = bt_value_array_get_size(query_result);
if (trace_count < 0) {
ret = -1;
goto error;
uint64_t stream_idx;
int64_t stream_count;
- trace_info = bt_value_array_get(query_result, trace_idx);
+ trace_info = bt_value_array_borrow_element_by_index(
+ query_result, trace_idx);
if (!trace_info || !bt_value_is_map(trace_info)) {
ret = -1;
BT_LOGD_STR("Cannot retrieve trace from query result.");
goto error;
}
- intersection_range = bt_value_map_get(trace_info,
+ intersection_range = bt_value_map_borrow_entry_value(trace_info,
"intersection-range-ns");
if (!intersection_range) {
ret = -1;
goto error;
}
- intersection_begin = bt_value_map_get(intersection_range,
- "begin");
+ intersection_begin = bt_value_map_borrow_entry_value(
+ intersection_range, "begin");
if (!intersection_begin) {
ret = -1;
BT_LOGD_STR("Cannot retrieve intersection-range-ns \'begin\' field from query result.");
goto error;
}
- intersection_end = bt_value_map_get(intersection_range,
- "end");
+ intersection_end = bt_value_map_borrow_entry_value(
+ intersection_range, "end");
if (!intersection_end) {
ret = -1;
BT_LOGD_STR("Cannot retrieve intersection-range-ns \'end\' field from query result.");
goto error;
}
- value_status = bt_value_integer_get(intersection_begin, &begin);
- if (value_status != BT_VALUE_STATUS_OK) {
- ret = -1;
- BT_LOGD_STR("Cannot retrieve value of intersection-range-ns \'begin\' field from query result.");
- goto error;
- }
-
- value_status = bt_value_integer_get(intersection_end, &end);
- if (value_status != BT_VALUE_STATUS_OK) {
- ret = -1;
- BT_LOGD_STR("Cannot retrieve value of intersection-range-ns \'end\' field from query result.");
- goto error;
- }
+ begin = bt_value_integer_get(intersection_begin);
+ end = bt_value_integer_get(intersection_end);
if (begin < 0 || end < 0 || end < begin) {
BT_LOGW("Invalid trace stream intersection values: "
goto error;
}
- stream_infos = bt_value_map_get(trace_info, "streams");
+ stream_infos = bt_value_map_borrow_entry_value(trace_info,
+ "streams");
if (!stream_infos || !bt_value_is_array(stream_infos)) {
ret = -1;
- BT_LOGD_STR("Cannot retrieve stream informations from trace in query result.");
+ BT_LOGD_STR("Cannot retrieve stream information from trace in query result.");
goto error;
}
- stream_count = bt_value_array_size(stream_infos);
+ stream_count = bt_value_array_get_size(stream_infos);
if (stream_count < 0) {
ret = -1;
goto error;
trace_range->intersection_range_begin_ns = begin;
trace_range->intersection_range_end_ns = end;
- stream_info = bt_value_array_get(stream_infos,
- stream_idx);
+ stream_info = bt_value_array_borrow_element_by_index(
+ stream_infos, stream_idx);
if (!stream_info || !bt_value_is_map(stream_info)) {
ret = -1;
BT_LOGD_STR("Cannot retrieve stream informations from trace in query result.");
goto error;
}
- stream_paths = bt_value_map_get(stream_info, "paths");
+ stream_paths = bt_value_map_borrow_entry_value(
+ stream_info, "paths");
if (!stream_paths || !bt_value_is_array(stream_paths)) {
ret = -1;
BT_LOGD_STR("Cannot retrieve stream paths from trace in query result.");
goto error;
}
- stream_path_value = bt_value_array_get(stream_paths, 0);
+ stream_path_value =
+ bt_value_array_borrow_element_by_index(
+ stream_paths, 0);
if (!stream_path_value ||
!bt_value_is_string(stream_path_value)) {
ret = -1;
goto error;
}
- value_status = bt_value_string_get(stream_path_value,
- &stream_path);
- if (value_status != BT_VALUE_STATUS_OK) {
- ret = -1;
- goto error;
- }
-
+ stream_path = bt_value_string_get(stream_path_value);
port_id->port_name = strdup(stream_path);
if (!port_id->port_name) {
ret = -1;
port_id = NULL;
trace_range = NULL;
- BT_PUT(stream_info);
- BT_PUT(stream_paths);
- BT_PUT(stream_path_value);
}
-
- BT_PUT(trace_info);
- BT_PUT(stream_paths);
- BT_PUT(stream_path_value);
- BT_PUT(intersection_range);
- BT_PUT(intersection_begin);
- BT_PUT(intersection_end);
- BT_PUT(stream_paths);
- BT_PUT(stream_path_value);
}
goto end;
path ? path : "(unknown)",
bt_common_color_reset());
end:
- bt_put(component_path_value);
- bt_put(query_params);
- bt_put(query_result);
- bt_put(trace_info);
- bt_put(intersection_range);
- bt_put(intersection_begin);
- bt_put(intersection_end);
- bt_put(stream_infos);
- bt_put(stream_info);
- bt_put(stream_paths);
- bt_put(stream_path_value);
+ bt_object_put_ref(query_params);
+ bt_object_put_ref(query_result);
g_free(port_id);
g_free(trace_range);
return ret;
goto error;
}
- ret = bt_graph_add_component(ctx->graph, comp_cls,
- cfg_comp->instance_name->str, cfg_comp->params, &comp);
+ ret = bt_private_graph_add_component(ctx->graph, comp_cls,
+ cfg_comp->instance_name->str,
+ bt_value_borrow_from_private(cfg_comp->params), &comp);
if (ret) {
BT_LOGE("Cannot create component: plugin-name=\"%s\", "
"comp-cls-name=\"%s\", comp-cls-type=%d, "
BT_LOGI("Created and inserted component: comp-addr=%p, comp-name=\"%s\"",
comp, cfg_comp->instance_name->str);
quark = g_quark_from_string(cfg_comp->instance_name->str);
- assert(quark > 0);
+ BT_ASSERT(quark > 0);
g_hash_table_insert(ctx->components,
GUINT_TO_POINTER(quark), comp);
comp = NULL;
- BT_PUT(comp_cls);
+ BT_OBJECT_PUT_REF_AND_RESET(comp_cls);
}
goto end;
ret = -1;
end:
- bt_put(comp);
- bt_put(comp_cls);
+ bt_object_put_ref(comp);
+ bt_object_put_ref(comp_cls);
return ret;
}
uint64_t i;
count = port_count_fn(comp);
- assert(count >= 0);
+ BT_ASSERT(count >= 0);
for (i = 0; i < count; i++) {
struct bt_port *upstream_port = port_by_index_fn(comp, i);
- assert(upstream_port);
+ BT_ASSERT(upstream_port);
ret = cmd_run_ctx_connect_upstream_port(ctx, upstream_port);
- bt_put(upstream_port);
+ bt_object_put_ref(upstream_port);
if (ret) {
goto end;
}
/* Run the graph */
while (true) {
- enum bt_graph_status graph_status = bt_graph_run(ctx.graph);
+ enum bt_graph_status graph_status = bt_private_graph_run(ctx.graph);
/*
* Reset console in case something messed with console
printf("%s", bt_common_color_reset());
fflush(stdout);
fprintf(stderr, "%s", bt_common_color_reset());
- BT_LOGV("bt_graph_run() returned: status=%s",
+ BT_LOGV("bt_private_graph_run() returned: status=%s",
bt_graph_status_str(graph_status));
switch (graph_status) {
BT_LOGI_STR("Graph was canceled by user.");
goto error;
case BT_GRAPH_STATUS_AGAIN:
- if (bt_graph_is_canceled(ctx.graph)) {
+ if (bt_graph_is_canceled(
+ bt_graph_borrow_from_private(ctx.graph))) {
BT_LOGI_STR("Graph was canceled by user.");
goto error;
}
cfg->cmd_data.run.retry_duration_us);
if (usleep(cfg->cmd_data.run.retry_duration_us)) {
- if (bt_graph_is_canceled(ctx.graph)) {
+ if (bt_graph_is_canceled(
+ bt_graph_borrow_from_private(ctx.graph))) {
BT_LOGI_STR("Graph was canceled by user.");
goto error;
}
}
}
-static
-void set_sigint_handler(void)
-{
- struct sigaction new_action, old_action;
-
- new_action.sa_handler = sigint_handler;
- sigemptyset(&new_action.sa_mask);
- new_action.sa_flags = 0;
- sigaction(SIGINT, NULL, &old_action);
-
- if (old_action.sa_handler != SIG_IGN) {
- sigaction(SIGINT, &new_action, NULL);
- }
-}
-
int main(int argc, const char **argv)
{
int ret;
struct bt_config *cfg;
init_log_level();
- set_sigint_handler();
+ set_signal_handler();
init_static_data();
cfg = bt_config_cli_args_create_with_default(argc, argv, &retcode);
print_cfg(cfg);
if (cfg->command_needs_plugins) {
- ret = load_all_plugins(cfg->plugin_paths);
+ ret = load_all_plugins(
+ bt_value_borrow_from_private(cfg->plugin_paths));
if (ret) {
BT_LOGE("Failed to load plugins: ret=%d", ret);
retcode = 1;
retcode = ret ? 1 : 0;
end:
- BT_PUT(cfg);
+ BT_OBJECT_PUT_REF_AND_RESET(cfg);
fini_static_data();
return retcode;
}