Let's use this approach now:
INFO level:
Any useful information which a non-developer user would possibly
understand.
Anything logged with this level must _not_ happen repetitively on
the fast path, that is, nothing related to each message, for
example. This level is used for sporadic and one-shot events.
* CLI or component configuration report.
* Successful plugin, component, or message iterator initialization.
* In the library: anything related to plugins, graphs, component
classes, components, message iterators, connections, and ports
which is not on the fast path.
* Successful connection to or disconnection from another system.
* An _optional_ subsystem cannot be loaded.
* An _optional_ field/datum cannot be found.
DEBUG level:
Something that only Babeltrace developers would be interested into,
which can occur on the fast path, but not more often than once per
message.
* Object construction and destruction.
* Object recycling (except fields).
* Object copying (except fields and values).
* Object freezing (whatever the type, as freezing only occurs in
developer mode).
* Object cancellation.
* Calling user methods and logging the result.
* Setting object properties (except fields and values).
VERBOSE level:
Low-level debugging context information (anything that does not fit
the other log levels). More appropriate for tracing in general.
* Reference count change.
* Fast path, low level state machine's state change.
* Get or set an object's property.
* Object comparison's intermediate results.
This will also be written in `CONTRIBUTING.adoc` by another patch.
The goal here is to make the DEBUG level the default minimal, build-time
log level, so that Babeltrace users have enough logging by default
without impacting the performance too much. From what I measured once
this patch is applied, the performance is very similar to an INFO build.
Many DEBUG logging statements are upgraded to the INFO level because
they only occur once, or very rarely, and consist of interesting
information for someone who does not have deep knowledge of the
Babeltrace source code.
Many VERBOSE logging statements are upgraded to the DEBUG level so that,
by default, we have more information in the log file of someone who
needs support. Those statements are executed seldom enough (at most once
per message) to be promoted as such.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Icdd1ec8f1f54396eea5588968d85e446030f282d
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1439
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
44 files changed:
void set_signal_handler(void)
{
if (!SetConsoleCtrlHandler(signal_handler, TRUE)) {
void set_signal_handler(void)
{
if (!SetConsoleCtrlHandler(signal_handler, TRUE)) {
- BT_LOGE("Failed to set the ctrl+c handler.");
+ BT_LOGE("Failed to set the Ctrl+C handler.");
const uint64_t sleep_time_us = 100000;
/* Wait 100 ms and retry */
const uint64_t sleep_time_us = 100000;
/* Wait 100 ms and retry */
- BT_LOGV("Got BT_QUERY_EXECUTOR_STATUS_AGAIN: sleeping: "
+ BT_LOGD("Got BT_QUERY_EXECUTOR_STATUS_AGAIN: sleeping: "
"time-us=%" PRIu64, sleep_time_us);
if (usleep(sleep_time_us)) {
"time-us=%" PRIu64, sleep_time_us);
if (usleep(sleep_time_us)) {
const bt_plugin *plugin = NULL;
BT_ASSERT(name);
const bt_plugin *plugin = NULL;
BT_ASSERT(name);
- BT_LOGD("Finding plugin: name=\"%s\"", name);
+ BT_LOGI("Finding plugin: name=\"%s\"", name);
for (i = 0; i < loaded_plugins->len; i++) {
plugin = g_ptr_array_index(loaded_plugins, i);
for (i = 0; i < loaded_plugins->len; i++) {
plugin = g_ptr_array_index(loaded_plugins, i);
- if (BT_LOG_ON_DEBUG) {
- if (plugin) {
- BT_LOGD("Found plugin: plugin-addr=%p", plugin);
- } else {
- BT_LOGD("Cannot find plugin.");
- }
+ if (plugin) {
+ BT_LOGI("Found plugin: name=\"%s\", plugin-addr=%p",
+ name, plugin);
+ } else {
+ BT_LOGI("Cannot find plugin: name=\"%s\"", name);
}
bt_plugin_get_ref(plugin);
}
bt_plugin_get_ref(plugin);
const void *comp_class = NULL;
const bt_plugin *plugin;
const void *comp_class = NULL;
const bt_plugin *plugin;
- BT_LOGD("Finding component class: plugin-name=\"%s\", "
+ BT_LOGI("Finding component class: plugin-name=\"%s\", "
"comp-cls-name=\"%s\"", plugin_name, comp_class_name);
plugin = find_plugin(plugin_name);
"comp-cls-name=\"%s\"", plugin_name, comp_class_name);
plugin = find_plugin(plugin_name);
BT_PLUGIN_PUT_REF_AND_RESET(plugin);
end:
BT_PLUGIN_PUT_REF_AND_RESET(plugin);
end:
- if (BT_LOG_ON_DEBUG) {
- if (comp_class) {
- BT_LOGD("Found component class: comp-cls-addr=%p",
- comp_class);
- } else {
- BT_LOGD("Cannot find source component class.");
- }
+ if (comp_class) {
+ BT_LOGI("Found component class: plugin-name=\"%s\", "
+ "comp-cls-name=\"%s\"", plugin_name, comp_class_name);
+ } else {
+ BT_LOGI("Cannot find source component class: "
+ "plugin-name=\"%s\", comp-cls-name=\"%s\"",
+ plugin_name, comp_class_name);
- BT_LOGI_STR("Configuration:");
- fprintf(stderr, " Debug mode: %s\n", cfg->debug ? "yes" : "no");
- fprintf(stderr, " Verbose mode: %s\n", cfg->verbose ? "yes" : "no");
+ BT_LOGI_STR("CLI configuration:");
+ BT_LOGI(" Debug mode: %s\n", cfg->debug ? "yes" : "no");
+ BT_LOGI(" Verbose mode: %s\n", cfg->verbose ? "yes" : "no");
switch (cfg->command) {
case BT_CONFIG_COMMAND_RUN:
switch (cfg->command) {
case BT_CONFIG_COMMAND_RUN:
- BT_LOGI("Loading dynamic plugins.");
+ BT_LOGI_STR("Loading dynamic plugins.");
for (i = 0; i < nr_paths; i++) {
const bt_value *plugin_path_value = NULL;
for (i = 0; i < nr_paths; i++) {
const bt_value *plugin_path_value = NULL;
* directory.
*/
if (!g_file_test(plugin_path, G_FILE_TEST_IS_DIR)) {
* directory.
*/
if (!g_file_test(plugin_path, G_FILE_TEST_IS_DIR)) {
- BT_LOGV("Skipping nonexistent directory path: "
+ BT_LOGI("Skipping nonexistent directory path: "
"path=\"%s\"", plugin_path);
continue;
}
plugin_set = bt_plugin_find_all_from_dir(plugin_path, false);
if (!plugin_set) {
"path=\"%s\"", plugin_path);
continue;
}
plugin_set = bt_plugin_find_all_from_dir(plugin_path, false);
if (!plugin_set) {
- BT_LOGD("Unable to load dynamic plugins: path=\"%s\"",
- plugin_path);
+ BT_LOGI("Unable to load dynamic plugins from directory: "
+ "path=\"%s\"", plugin_path);
/* Skip port if it's already connected. */
if (bt_port_is_connected(downstream_port)) {
/* Skip port if it's already connected. */
if (bt_port_is_connected(downstream_port)) {
- BT_LOGD("Skipping downstream port: already connected: "
+ BT_LOGI("Skipping downstream port: already connected: "
"port-addr=%p, port-name=\"%s\"",
downstream_port,
bt_port_get_name(downstream_port));
"port-addr=%p, port-name=\"%s\"",
downstream_port,
bt_port_get_name(downstream_port));
stream_infos, stream_idx);
if (!stream_info || !bt_value_is_map(stream_info)) {
ret = -1;
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.");
+ BT_LOGE_STR("Cannot retrieve stream informations from trace in query result.");
goto error;
}
port_name = bt_value_map_borrow_entry_value_const(stream_info, "port-name");
if (!port_name || !bt_value_is_string(port_name)) {
ret = -1;
goto error;
}
port_name = bt_value_map_borrow_entry_value_const(stream_info, "port-name");
if (!port_name || !bt_value_is_string(port_name)) {
ret = -1;
- BT_LOGD_STR("Cannot retrieve port name in query result.");
+ BT_LOGE_STR("Cannot retrieve port name in query result.");
length = strlen(home_dir) + strlen(HOME_PLUGIN_SUBPATH) + 1;
if (length >= PATH_MAX) {
length = strlen(home_dir) + strlen(HOME_PLUGIN_SUBPATH) + 1;
if (length >= PATH_MAX) {
- BT_LOGW("Home directory path is too long: length=%zu",
- length);
+ BT_LOGW("Home directory path is too long: "
+ "length=%zu, max-length=%u", length, PATH_MAX);
if (ret < 0) {
if (errno == EINTR) {
#ifdef BT_LOGD_STR
if (ret < 0) {
if (errno == EINTR) {
#ifdef BT_LOGD_STR
- BT_LOGD_STR("read() call interrupted. Retrying...");
+ BT_LOGD_STR("read() call interrupted; retrying...");
#endif
/* retry operation */
continue;
#endif
/* retry operation */
continue;
int ret;
BT_ASSERT(ctfser);
int ret;
BT_ASSERT(ctfser);
- BT_LOGV("Increasing stream file's current packet size: "
+ BT_LOGD("Increasing stream file's current packet size: "
"path=\"%s\", fd=%d, "
"offset-in-cur-packet-bits=%" PRIu64 ", "
"cur-packet-size-bytes=%" PRIu64,
"path=\"%s\", fd=%d, "
"offset-in-cur-packet-bits=%" PRIu64 ", "
"cur-packet-size-bytes=%" PRIu64,
- BT_LOGV("Increased packet size: "
+ BT_LOGD("Increased packet size: "
"path=\"%s\", fd=%d, "
"offset-in-cur-packet-bits=%" PRIu64 ", "
"new-packet-size-bytes=%" PRIu64,
"path=\"%s\", fd=%d, "
"offset-in-cur-packet-bits=%" PRIu64 ", "
"new-packet-size-bytes=%" PRIu64,
- BT_LOGV("Opening packet: path=\"%s\", fd=%d, "
+ BT_LOGD("Opening packet: path=\"%s\", fd=%d, "
"prev-packet-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
ctfser->prev_packet_size_bytes);
"prev-packet-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
ctfser->prev_packet_size_bytes);
- BT_LOGV("Opened packet: path=\"%s\", fd=%d, "
+ BT_LOGD("Opened packet: path=\"%s\", fd=%d, "
"cur-packet-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
ctfser->cur_packet_size_bytes);
"cur-packet-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
ctfser->cur_packet_size_bytes);
void bt_ctfser_close_current_packet(struct bt_ctfser *ctfser,
uint64_t packet_size_bytes)
{
void bt_ctfser_close_current_packet(struct bt_ctfser *ctfser,
uint64_t packet_size_bytes)
{
- BT_LOGV("Closing packet: path=\"%s\", fd=%d, "
+ BT_LOGD("Closing packet: path=\"%s\", fd=%d, "
"offset-in-cur-packet-bits=%" PRIu64
"cur-packet-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
"offset-in-cur-packet-bits=%" PRIu64
"cur-packet-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
*/
ctfser->prev_packet_size_bytes = packet_size_bytes;
ctfser->stream_size_bytes += packet_size_bytes;
*/
ctfser->prev_packet_size_bytes = packet_size_bytes;
ctfser->stream_size_bytes += packet_size_bytes;
- BT_LOGV("Closed packet: path=\"%s\", fd=%d, "
+ BT_LOGD("Closed packet: path=\"%s\", fd=%d, "
"stream-file-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
ctfser->stream_size_bytes);
"stream-file-size-bytes=%" PRIu64,
ctfser->path->str, ctfser->fd,
ctfser->stream_size_bytes);
fd_internal = g_new0(struct fd_handle_internal, 1);
if (!fd_internal) {
fd_internal = g_new0(struct fd_handle_internal, 1);
if (!fd_internal) {
- BT_LOGE("Failed to allocate fd internal handle");
+ BT_LOGE_STR("Failed to allocate internal FD handle.");
goto error;
}
file_key = g_new0(struct file_key, 1);
if (!fd_internal) {
goto error;
}
file_key = g_new0(struct file_key, 1);
if (!fd_internal) {
- BT_LOGE("Failed to allocate file key");
+ BT_LOGE_STR("Failed to allocate file key.");
close_ret = close(fd_internal->fd_handle.fd);
if (close_ret == -1) {
close_ret = close(fd_internal->fd_handle.fd);
if (close_ret == -1) {
- BT_LOGW_ERRNO("Failed to close file descriptor",
+ BT_LOGE_ERRNO("Failed to close file descriptor",
": fd=%d", fd_internal->fd_handle.fd);
}
ret = g_hash_table_remove(fdc->cache, fd_internal->key);
": fd=%d", fd_internal->fd_handle.fd);
}
ret = g_hash_table_remove(fdc->cache, fd_internal->key);
struct bt_component_class_sink_colander_data *user_provided_data =
init_method_data;
struct bt_component_class_sink_colander_data *user_provided_data =
init_method_data;
- if (!init_method_data) {
- BT_LOGW_STR("Component initialization method data is NULL.");
- status = BT_SELF_COMPONENT_STATUS_ERROR;
- goto end;
- }
-
+ BT_ASSERT(init_method_data);
colander_data = g_new0(
struct bt_component_class_sink_colander_priv_data, 1);
if (!colander_data) {
colander_data = g_new0(
struct bt_component_class_sink_colander_priv_data, 1);
if (!colander_data) {
bt_message_array_const msgs;
BT_ASSERT(colander_data);
bt_message_array_const msgs;
BT_ASSERT(colander_data);
-
- if (!colander_data->msg_iter) {
- BT_LIB_LOGW("Trying to consume without an "
- "upstream message iterator: %![comp-]+c",
- self_comp);
- goto end;
- }
-
+ BT_ASSERT(colander_data->msg_iter);
msg_iter_status =
bt_self_component_port_input_message_iterator_next(
colander_data->msg_iter, &msgs,
msg_iter_status =
bt_self_component_port_input_message_iterator_next(
colander_data->msg_iter, &msgs,
BT_ASSERT(obj);
class = container_of(obj, struct bt_component_class, base);
BT_ASSERT(obj);
class = container_of(obj, struct bt_component_class, base);
- BT_LIB_LOGD("Destroying component class: %!+C", class);
+ BT_LIB_LOGI("Destroying component class: %!+C", class);
/* Call destroy listeners in reverse registration order */
for (i = class->destroy_listeners->len - 1; i >= 0; i--) {
/* Call destroy listeners in reverse registration order */
for (i = class->destroy_listeners->len - 1; i >= 0; i--) {
BT_ASSERT_PRE_NON_NULL(name, "Name");
BT_ASSERT_PRE_NON_NULL(method, "Message iterator next method");
BT_ASSERT_PRE_NON_NULL(name, "Name");
BT_ASSERT_PRE_NON_NULL(method, "Message iterator next method");
- BT_LOGD("Creating source component class: "
+ BT_LOGI("Creating source component class: "
"name=\"%s\", msg-iter-next-method-addr=%p",
name, method);
source_class = g_new0(struct bt_component_class_source, 1);
"name=\"%s\", msg-iter-next-method-addr=%p",
name, method);
source_class = g_new0(struct bt_component_class_source, 1);
}
source_class->methods.msg_iter_next = method;
}
source_class->methods.msg_iter_next = method;
- BT_LIB_LOGD("Created source component class: %!+C", source_class);
+ BT_LIB_LOGI("Created source component class: %!+C", source_class);
end:
return (void *) source_class;
end:
return (void *) source_class;
BT_ASSERT_PRE_NON_NULL(name, "Name");
BT_ASSERT_PRE_NON_NULL(method, "Message iterator next method");
BT_ASSERT_PRE_NON_NULL(name, "Name");
BT_ASSERT_PRE_NON_NULL(method, "Message iterator next method");
- BT_LOGD("Creating filter component class: "
+ BT_LOGI("Creating filter component class: "
"name=\"%s\", msg-iter-next-method-addr=%p",
name, method);
filter_class = g_new0(struct bt_component_class_filter, 1);
"name=\"%s\", msg-iter-next-method-addr=%p",
name, method);
filter_class = g_new0(struct bt_component_class_filter, 1);
}
filter_class->methods.msg_iter_next = method;
}
filter_class->methods.msg_iter_next = method;
- BT_LIB_LOGD("Created filter component class: %!+C", filter_class);
+ BT_LIB_LOGI("Created filter component class: %!+C", filter_class);
end:
return (void *) filter_class;
end:
return (void *) filter_class;
BT_ASSERT_PRE_NON_NULL(name, "Name");
BT_ASSERT_PRE_NON_NULL(method, "Consume next method");
BT_ASSERT_PRE_NON_NULL(name, "Name");
BT_ASSERT_PRE_NON_NULL(method, "Consume next method");
- BT_LOGD("Creating sink component class: "
+ BT_LOGI("Creating sink component class: "
"name=\"%s\", consume-method-addr=%p",
name, method);
sink_class = g_new0(struct bt_component_class_sink, 1);
"name=\"%s\", consume-method-addr=%p",
name, method);
sink_class = g_new0(struct bt_component_class_sink, 1);
}
sink_class->methods.consume = method;
}
sink_class->methods.consume = method;
- BT_LIB_LOGD("Created sink component class: %!+C", sink_class);
+ BT_LIB_LOGI("Created sink component class: %!+C", sink_class);
end:
return (void *) sink_class;
end:
return (void *) sink_class;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.init = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.init = method;
- BT_LIB_LOGV("Set source component class's initialization method: "
+ BT_LIB_LOGD("Set source component class's initialization method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.init = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.init = method;
- BT_LIB_LOGV("Set filter component class's initialization method: "
+ BT_LIB_LOGD("Set filter component class's initialization method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.init = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.init = method;
- BT_LIB_LOGV("Set sink component class's initialization method: "
+ BT_LIB_LOGD("Set sink component class's initialization method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.finalize = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.finalize = method;
- BT_LIB_LOGV("Set source component class's finalization method: "
+ BT_LIB_LOGD("Set source component class's finalization method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.finalize = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.finalize = method;
- BT_LIB_LOGV("Set filter component class's finalization method: "
+ BT_LIB_LOGD("Set filter component class's finalization method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.finalize = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.finalize = method;
- BT_LIB_LOGV("Set sink component class's finalization method: "
+ BT_LIB_LOGD("Set sink component class's finalization method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.query = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.query = method;
- BT_LIB_LOGV("Set source component class's query method: "
+ BT_LIB_LOGD("Set source component class's query method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.query = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.query = method;
- BT_LIB_LOGV("Set filter component class's query method: "
+ BT_LIB_LOGD("Set filter component class's query method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.query = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.query = method;
- BT_LIB_LOGV("Set sink component class's query method: "
+ BT_LIB_LOGD("Set sink component class's query method: "
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
"%!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_input_port_connection = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_input_port_connection = method;
- BT_LIB_LOGV("Set filter component class's \"accept input port connection\" method"
+ BT_LIB_LOGD("Set filter component class's \"accept input port connection\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_input_port_connection = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_input_port_connection = method;
- BT_LIB_LOGV("Set sink component class's \"accept input port connection\" method"
+ BT_LIB_LOGD("Set sink component class's \"accept input port connection\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_output_port_connection = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_output_port_connection = method;
- BT_LIB_LOGV("Set source component class's \"accept output port connection\" method"
+ BT_LIB_LOGD("Set source component class's \"accept output port connection\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_output_port_connection = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.accept_output_port_connection = method;
- BT_LIB_LOGV("Set filter component class's \"accept output port connection\" method"
+ BT_LIB_LOGD("Set filter component class's \"accept output port connection\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.input_port_connected = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.input_port_connected = method;
- BT_LIB_LOGV("Set filter component class's \"input port connected\" method"
+ BT_LIB_LOGD("Set filter component class's \"input port connected\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.input_port_connected = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.input_port_connected = method;
- BT_LIB_LOGV("Set sink component class's \"input port connected\" method"
+ BT_LIB_LOGD("Set sink component class's \"input port connected\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.output_port_connected = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.output_port_connected = method;
- BT_LIB_LOGV("Set source component class's \"output port connected\" method"
+ BT_LIB_LOGD("Set source component class's \"output port connected\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.output_port_connected = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.output_port_connected = method;
- BT_LIB_LOGV("Set filter component class's \"output port connected\" method"
+ BT_LIB_LOGD("Set filter component class's \"output port connected\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.graph_is_configured = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.graph_is_configured = method;
- BT_LIB_LOGV("Set sink component class's \"graph is configured\" method"
+ BT_LIB_LOGD("Set sink component class's \"graph is configured\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_init = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_init = method;
- BT_LIB_LOGV("Set source component class's message iterator initialization method"
+ BT_LIB_LOGD("Set source component class's message iterator initialization method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_init = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_init = method;
- BT_LIB_LOGV("Set filter component class's message iterator initialization method"
+ BT_LIB_LOGD("Set filter component class's message iterator initialization method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_finalize = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_finalize = method;
- BT_LIB_LOGV("Set source component class's message iterator finalization method"
+ BT_LIB_LOGD("Set source component class's message iterator finalization method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_finalize = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_finalize = method;
- BT_LIB_LOGV("Set filter component class's message iterator finalization method"
+ BT_LIB_LOGD("Set filter component class's message iterator finalization method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_ns_from_origin = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_ns_from_origin = method;
- BT_LIB_LOGV("Set filter component class's message iterator \"seek nanoseconds from origin\" method"
+ BT_LIB_LOGD("Set filter component class's message iterator \"seek nanoseconds from origin\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_ns_from_origin = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_ns_from_origin = method;
- BT_LIB_LOGV("Set source component class's message iterator \"seek nanoseconds from origin\" method"
+ BT_LIB_LOGD("Set source component class's message iterator \"seek nanoseconds from origin\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_beginning = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_beginning = method;
- BT_LIB_LOGV("Set filter component class's message iterator \"seek beginning\" method"
+ BT_LIB_LOGD("Set filter component class's message iterator \"seek beginning\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_beginning = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_seek_beginning = method;
- BT_LIB_LOGV("Set source component class's message iterator \"seek beginning\" method"
+ BT_LIB_LOGD("Set source component class's message iterator \"seek beginning\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_beginning = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_beginning = method;
- BT_LIB_LOGV("Set filter component class's message iterator \"can seek beginning\" method"
+ BT_LIB_LOGD("Set filter component class's message iterator \"can seek beginning\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_beginning = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_beginning = method;
- BT_LIB_LOGV("Set source component class's message iterator \"can seek beginning\" method"
+ BT_LIB_LOGD("Set source component class's message iterator \"can seek beginning\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_ns_from_origin = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_ns_from_origin = method;
- BT_LIB_LOGV("Set filter component class's message iterator \"can seek nanoseconds from origin\" method"
+ BT_LIB_LOGD("Set filter component class's message iterator \"can seek nanoseconds from origin\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_ns_from_origin = method;
BT_ASSERT_PRE_NON_NULL(method, "Method");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
comp_cls->methods.msg_iter_can_seek_ns_from_origin = method;
- BT_LIB_LOGV("Set source component class's message iterator \"can seek nanoseconds from origin\" method"
+ BT_LIB_LOGD("Set source component class's message iterator \"can seek nanoseconds from origin\" method"
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
": %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(description, "Description");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
g_string_assign(comp_cls->description, description);
BT_ASSERT_PRE_NON_NULL(description, "Description");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
g_string_assign(comp_cls->description, description);
- BT_LIB_LOGV("Set component class's description: "
+ BT_LIB_LOGD("Set component class's description: "
"addr=%p, name=\"%s\", type=%s",
comp_cls,
bt_component_class_get_name(comp_cls),
"addr=%p, name=\"%s\", type=%s",
comp_cls,
bt_component_class_get_name(comp_cls),
BT_ASSERT_PRE_NON_NULL(help, "Help");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
g_string_assign(comp_cls->help, help);
BT_ASSERT_PRE_NON_NULL(help, "Help");
BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
g_string_assign(comp_cls->help, help);
- BT_LIB_LOGV("Set component class's help text: %!+C", comp_cls);
+ BT_LIB_LOGD("Set component class's help text: %!+C", comp_cls);
return BT_COMPONENT_CLASS_STATUS_OK;
}
return BT_COMPONENT_CLASS_STATUS_OK;
}
listener.func = func;
listener.data = data;
g_array_append_val(comp_cls->destroy_listeners, listener);
listener.func = func;
listener.data = data;
g_array_append_val(comp_cls->destroy_listeners, listener);
- BT_LIB_LOGV("Added destroy listener to component class: "
+ BT_LIB_LOGD("Added destroy listener to component class: "
"%![cc-]+C, listener-func-addr=%p", comp_cls, func);
}
"%![cc-]+C, listener-func-addr=%p", comp_cls, func);
}
- BT_LIB_LOGD("Calling user's finalization method: "
+ BT_LIB_LOGI("Calling user's component finalization method: "
"%![comp-]+c", comp);
method(comp);
}
"%![comp-]+c", comp);
method(comp);
}
*/
obj->ref_count++;
component = container_of(obj, struct bt_component, base);
*/
obj->ref_count++;
component = container_of(obj, struct bt_component, base);
- BT_LIB_LOGD("Destroying component: %![comp-]+c, %![graph-]+g",
+ BT_LIB_LOGI("Destroying component: %![comp-]+c, %![graph-]+g",
component, bt_component_borrow_graph(component));
/* Call destroy listeners in reverse registration order */
component, bt_component_borrow_graph(component));
/* Call destroy listeners in reverse registration order */
// TODO: Validate that the name is not already used.
// TODO: Validate that the name is not already used.
- BT_LIB_LOGD("Adding port to component: %![comp-]+c, "
+ BT_LIB_LOGI("Adding port to component: %![comp-]+c, "
"port-type=%s, port-name=\"%s\"", component,
bt_port_type_string(port_type), name);
"port-type=%s, port-name=\"%s\"", component,
bt_port_type_string(port_type), name);
- BT_LIB_LOGD("Created and added port to component: "
+ BT_LIB_LOGI("Created and added port to component: "
"%![comp-]+c, %![port-]+p", component, new_port);
*port = new_port;
"%![comp-]+c, %![port-]+p", component, new_port);
*port = new_port;
BT_ASSERT(component_class);
BT_ASSERT(name);
type = bt_component_class_get_type(component_class);
BT_ASSERT(component_class);
BT_ASSERT(name);
type = bt_component_class_get_type(component_class);
- BT_LIB_LOGD("Creating empty component from component class: %![cc-]+C, "
+ BT_LIB_LOGI("Creating empty component from component class: %![cc-]+C, "
"comp-name=\"%s\"", component_class, name);
component = component_create_funcs[type](component_class);
if (!component) {
"comp-name=\"%s\"", component_class, name);
component = component_create_funcs[type](component_class);
if (!component) {
- BT_LIB_LOGD("Created empty component from component class: "
+ BT_LIB_LOGI("Created empty component from component class: "
"%![cc-]+C, %![comp-]+c", component_class, component);
BT_OBJECT_MOVE_REF(*user_component, component);
"%![cc-]+C, %![comp-]+c", component_class, component);
BT_OBJECT_MOVE_REF(*user_component, component);
BT_ASSERT_PRE_NON_NULL(component, "Component");
component->user_data = data;
BT_ASSERT_PRE_NON_NULL(component, "Component");
component->user_data = data;
- BT_LIB_LOGV("Set component's user data: %!+c", component);
+ BT_LIB_LOGD("Set component's user data: %!+c", component);
listener.func = func;
listener.data = data;
g_array_append_val(component->destroy_listeners, listener);
listener.func = func;
listener.data = data;
g_array_append_val(component->destroy_listeners, listener);
- BT_LIB_LOGV("Added destroy listener: %![comp-]+c, "
+ BT_LIB_LOGD("Added destroy listener: %![comp-]+c, "
"func-addr=%p, data-addr=%p",
component, func, data);
}
"func-addr=%p, data-addr=%p",
component, func, data);
}
if (listener->func == func && listener->data == data) {
g_array_remove_index(component->destroy_listeners, i);
i--;
if (listener->func == func && listener->data == data) {
g_array_remove_index(component->destroy_listeners, i);
i--;
- BT_LIB_LOGV("Removed destroy listener: %![comp-]+c, "
+ BT_LIB_LOGD("Removed destroy listener: %![comp-]+c, "
"func-addr=%p, data-addr=%p",
component, func, data);
}
"func-addr=%p, data-addr=%p",
component, func, data);
}
struct bt_connection *connection = container_of(obj,
struct bt_connection, base);
struct bt_connection *connection = container_of(obj,
struct bt_connection, base);
- BT_LIB_LOGD("Destroying connection: %!+x", connection);
+ BT_LIB_LOGI("Destroying connection: %!+x", connection);
/*
* Make sure that each message iterator which was created for
/*
* Make sure that each message iterator which was created for
{
struct bt_connection *connection = NULL;
{
struct bt_connection *connection = NULL;
- BT_LIB_LOGD("Creating connection: "
+ BT_LIB_LOGI("Creating connection: "
"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
graph, upstream_port, downstream_port);
connection = g_new0(struct bt_connection, 1);
"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
graph, upstream_port, downstream_port);
connection = g_new0(struct bt_connection, 1);
downstream_port);
bt_port_set_connection(downstream_port, connection);
bt_object_set_parent(&connection->base, &graph->base);
downstream_port);
bt_port_set_connection(downstream_port, connection);
bt_object_set_parent(&connection->base, &graph->base);
- BT_LIB_LOGD("Created connection: %!+x", connection);
+ BT_LIB_LOGI("Created connection: %!+x", connection);
struct bt_port *upstream_port = conn->upstream_port;
size_t i;
struct bt_port *upstream_port = conn->upstream_port;
size_t i;
- BT_LIB_LOGD("Ending connection: %!+x, try-remove-from-graph=%d",
+ BT_LIB_LOGI("Ending connection: %!+x, try-remove-from-graph=%d",
conn, try_remove_from_graph);
/*
conn, try_remove_from_graph);
/*
struct bt_self_component_port_input_message_iterator *iterator)
{
g_ptr_array_remove(conn->iterators, iterator);
struct bt_self_component_port_input_message_iterator *iterator)
{
g_ptr_array_remove(conn->iterators, iterator);
- BT_LIB_LOGV("Removed message iterator from connection: "
+ BT_LIB_LOGD("Removed message iterator from connection: "
"%![conn-]+x, %![iter-]+i", conn, iterator);
try_remove_connection_from_graph(conn);
}
"%![conn-]+x, %![iter-]+i", conn, iterator);
try_remove_connection_from_graph(conn);
}
* step 4 goes from 1 to 2, and from 2 to 1 at step 6. This
* ensures that this function is not called two times.
*/
* step 4 goes from 1 to 2, and from 2 to 1 at step 6. This
* ensures that this function is not called two times.
*/
- BT_LIB_LOGD("Destroying graph: %!+g", graph);
+ BT_LIB_LOGI("Destroying graph: %!+g", graph);
struct bt_graph *graph;
int ret;
struct bt_graph *graph;
int ret;
- BT_LOGD_STR("Creating graph object.");
+ BT_LOGI_STR("Creating graph object.");
graph = g_new0(struct bt_graph, 1);
if (!graph) {
BT_LOGE_STR("Failed to allocate one graph.");
graph = g_new0(struct bt_graph, 1);
if (!graph) {
BT_LOGE_STR("Failed to allocate one graph.");
graph->messages = g_ptr_array_new_with_free_func(
(GDestroyNotify) notify_message_graph_is_destroyed);
graph->messages = g_ptr_array_new_with_free_func(
(GDestroyNotify) notify_message_graph_is_destroyed);
- BT_LIB_LOGD("Created graph object: %!+g", graph);
+ BT_LIB_LOGI("Created graph object: %!+g", graph);
end:
return (void *) graph;
end:
return (void *) graph;
"Downstream port does not belong to a component: %!+p",
downstream_port);
init_can_consume = graph->can_consume;
"Downstream port does not belong to a component: %!+p",
downstream_port);
init_can_consume = graph->can_consume;
- BT_LIB_LOGD("Connecting component ports within graph: "
+ BT_LIB_LOGI("Connecting component ports within graph: "
"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
graph, upstream_port, downstream_port);
bt_graph_set_can_consume(graph, false);
"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
graph, upstream_port, downstream_port);
bt_graph_set_can_consume(graph, false);
}
connection->notified_graph_ports_connected = true;
}
connection->notified_graph_ports_connected = true;
- BT_LIB_LOGD("Connected component ports within graph: "
+ BT_LIB_LOGI("Connected component ports within graph: "
"%![graph-]+g, %![up-comp-]+c, %![down-comp-]+c, "
"%![up-port-]+p, %![down-port-]+p",
graph, upstream_component, downstream_component,
"%![graph-]+g, %![up-comp-]+c, %![down-comp-]+c, "
"%![up-port-]+p, %![down-port-]+p",
graph, upstream_component, downstream_component,
- BT_LIB_LOGV("Consumed from sink: %![comp-]+c, status=%s",
+ BT_LIB_LOGD("Consumed from sink: %![comp-]+c, status=%s",
comp, bt_self_component_status_string(comp_status));
end:
comp, bt_self_component_status_string(comp_status));
end:
- BT_LIB_LOGV("Consumed sink node: %![comp-]+c, status=%s",
+ BT_LIB_LOGD("Consumed sink node: %![comp-]+c, status=%s",
sink, bt_graph_status_string(status));
return status;
}
sink, bt_graph_status_string(status));
return status;
}
GList *sink_node;
int index;
GList *sink_node;
int index;
- BT_LIB_LOGV("Making specific sink consume: %![comp-]+c", sink);
+ BT_LIB_LOGD("Making specific sink consume: %![comp-]+c", sink);
BT_ASSERT(bt_component_borrow_graph((void *) sink) == graph);
if (g_queue_is_empty(graph->sinks_to_consume)) {
BT_ASSERT(bt_component_borrow_graph((void *) sink) == graph);
if (g_queue_is_empty(graph->sinks_to_consume)) {
- BT_LOGV_STR("Graph's sink queue is empty: end of graph.");
+ BT_LOGD_STR("Graph's sink queue is empty: end of graph.");
status = BT_GRAPH_STATUS_END;
goto end;
}
index = g_queue_index(graph->sinks_to_consume, sink);
if (index < 0) {
status = BT_GRAPH_STATUS_END;
goto end;
}
index = g_queue_index(graph->sinks_to_consume, sink);
if (index < 0) {
- BT_LOGV_STR("Sink is not marked as consumable: sink is ended.");
+ BT_LIB_LOGD("Sink component is not marked as consumable: "
+ "component sink is ended: %![comp-]+c", sink);
status = BT_GRAPH_STATUS_END;
goto end;
}
status = BT_GRAPH_STATUS_END;
goto end;
}
BT_ASSERT_PRE(graph->has_sink,
"Graph has no sink component: %!+g", graph);
BT_ASSERT_PRE(graph->has_sink,
"Graph has no sink component: %!+g", graph);
- BT_LIB_LOGV("Making next sink consume: %![graph-]+g", graph);
+ BT_LIB_LOGD("Making next sink component consume: %![graph-]+g", graph);
if (G_UNLIKELY(g_queue_is_empty(graph->sinks_to_consume))) {
if (G_UNLIKELY(g_queue_is_empty(graph->sinks_to_consume))) {
- BT_LOGV_STR("Graph's sink queue is empty: end of graph.");
+ BT_LOGD_STR("Graph's sink queue is empty: end of graph.");
status = BT_GRAPH_STATUS_END;
goto end;
}
current_node = g_queue_pop_head_link(graph->sinks_to_consume);
sink = current_node->data;
status = BT_GRAPH_STATUS_END;
goto end;
}
current_node = g_queue_pop_head_link(graph->sinks_to_consume);
sink = current_node->data;
- BT_LIB_LOGV("Chose next sink to consume: %!+c", sink);
+ BT_LIB_LOGD("Chose next sink to consume: %!+c", sink);
status = consume_sink_node(graph, current_node);
end:
status = consume_sink_node(graph, current_node);
end:
- BT_LIB_LOGV("Running graph: %!+g", graph);
+ BT_LIB_LOGI("Running graph: %!+g", graph);
* it was intentional: log with a DEBUG level only.
*/
if (G_UNLIKELY(graph->canceled)) {
* it was intentional: log with a DEBUG level only.
*/
if (G_UNLIKELY(graph->canceled)) {
- BT_LIB_LOGD("Stopping the graph: graph is canceled: "
+ BT_LIB_LOGI("Stopping the graph: graph is canceled: "
"%!+g", graph);
status = BT_GRAPH_STATUS_CANCELED;
goto end;
"%!+g", graph);
status = BT_GRAPH_STATUS_CANCELED;
goto end;
- BT_LIB_LOGV("Graph ran: %![graph-]+g, status=%s", graph,
+ BT_LIB_LOGI("Graph ran: %![graph-]+g, status=%s", graph,
bt_graph_status_string(status));
bt_graph_set_can_consume(graph, true);
return status;
bt_graph_status_string(status));
bt_graph_set_can_consume(graph, true);
return status;
"%!+g", graph);
g_array_append_val(graph->listeners.source_output_port_added, listener);
listener_id = graph->listeners.source_output_port_added->len - 1;
"%!+g", graph);
g_array_append_val(graph->listeners.source_output_port_added, listener);
listener_id = graph->listeners.source_output_port_added->len - 1;
- BT_LIB_LOGV("Added \"source component output port added\" listener to graph: "
+ BT_LIB_LOGD("Added \"source component output port added\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%!+g", graph);
g_array_append_val(graph->listeners.filter_output_port_added, listener);
listener_id = graph->listeners.filter_output_port_added->len - 1;
"%!+g", graph);
g_array_append_val(graph->listeners.filter_output_port_added, listener);
listener_id = graph->listeners.filter_output_port_added->len - 1;
- BT_LIB_LOGV("Added \"filter component output port added\" listener to graph: "
+ BT_LIB_LOGD("Added \"filter component output port added\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%!+g", graph);
g_array_append_val(graph->listeners.filter_input_port_added, listener);
listener_id = graph->listeners.filter_input_port_added->len - 1;
"%!+g", graph);
g_array_append_val(graph->listeners.filter_input_port_added, listener);
listener_id = graph->listeners.filter_input_port_added->len - 1;
- BT_LIB_LOGV("Added \"filter component input port added\" listener to graph: "
+ BT_LIB_LOGD("Added \"filter component input port added\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%!+g", graph);
g_array_append_val(graph->listeners.sink_input_port_added, listener);
listener_id = graph->listeners.sink_input_port_added->len - 1;
"%!+g", graph);
g_array_append_val(graph->listeners.sink_input_port_added, listener);
listener_id = graph->listeners.sink_input_port_added->len - 1;
- BT_LIB_LOGV("Added \"sink component input port added\" listener to graph: "
+ BT_LIB_LOGD("Added \"sink component input port added\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
g_array_append_val(graph->listeners.source_filter_ports_connected,
listener);
listener_id = graph->listeners.source_filter_ports_connected->len - 1;
g_array_append_val(graph->listeners.source_filter_ports_connected,
listener);
listener_id = graph->listeners.source_filter_ports_connected->len - 1;
- BT_LIB_LOGV("Added \"source to filter component ports connected\" listener to graph: "
+ BT_LIB_LOGD("Added \"source to filter component ports connected\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
g_array_append_val(graph->listeners.source_sink_ports_connected,
listener);
listener_id = graph->listeners.source_sink_ports_connected->len - 1;
g_array_append_val(graph->listeners.source_sink_ports_connected,
listener);
listener_id = graph->listeners.source_sink_ports_connected->len - 1;
- BT_LIB_LOGV("Added \"source to sink component ports connected\" listener to graph: "
+ BT_LIB_LOGD("Added \"source to sink component ports connected\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
g_array_append_val(graph->listeners.filter_filter_ports_connected,
listener);
listener_id = graph->listeners.filter_filter_ports_connected->len - 1;
g_array_append_val(graph->listeners.filter_filter_ports_connected,
listener);
listener_id = graph->listeners.filter_filter_ports_connected->len - 1;
- BT_LIB_LOGV("Added \"filter to filter component ports connected\" listener to graph: "
+ BT_LIB_LOGD("Added \"filter to filter component ports connected\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
g_array_append_val(graph->listeners.filter_sink_ports_connected,
listener);
listener_id = graph->listeners.filter_sink_ports_connected->len - 1;
g_array_append_val(graph->listeners.filter_sink_ports_connected,
listener);
listener_id = graph->listeners.filter_sink_ports_connected->len - 1;
- BT_LIB_LOGV("Added \"filter to sink component ports connected\" listener to graph: "
+ BT_LIB_LOGD("Added \"filter to sink component ports connected\" listener to graph: "
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
"%![graph-]+g, listener-addr=%p, id=%d", graph, listener,
listener_id);
BT_ASSERT(graph);
BT_ASSERT(port);
BT_ASSERT(graph);
BT_ASSERT(port);
- BT_LIB_LOGV("Notifying graph listeners that a port was added: "
+ BT_LIB_LOGD("Notifying graph listeners that a port was added: "
"%![graph-]+g, %![port-]+p", graph, port);
comp = bt_port_borrow_component_inline(port);
BT_ASSERT(comp);
"%![graph-]+g, %![port-]+p", graph, port);
comp = bt_port_borrow_component_inline(port);
BT_ASSERT(comp);
BT_ASSERT(graph);
BT_ASSERT(upstream_port);
BT_ASSERT(downstream_port);
BT_ASSERT(graph);
BT_ASSERT(upstream_port);
BT_ASSERT(downstream_port);
- BT_LIB_LOGV("Notifying graph listeners that ports were connected: "
+ BT_LIB_LOGD("Notifying graph listeners that ports were connected: "
"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
graph, upstream_port, downstream_port);
upstream_comp = bt_port_borrow_component_inline(upstream_port);
"%![graph-]+g, %![up-port-]+p, %![down-port-]+p",
graph, upstream_port, downstream_port);
upstream_comp = bt_port_borrow_component_inline(upstream_port);
BT_ASSERT_PRE_NON_NULL(graph, "Graph");
graph->canceled = true;
BT_ASSERT_PRE_NON_NULL(graph, "Graph");
graph->canceled = true;
- BT_LIB_LOGV("Canceled graph: %!+i", graph);
+ BT_LIB_LOGI("Canceled graph: %!+i", graph);
return BT_GRAPH_STATUS_OK;
}
return BT_GRAPH_STATUS_OK;
}
{
BT_ASSERT(graph);
BT_ASSERT(connection);
{
BT_ASSERT(graph);
BT_ASSERT(connection);
- BT_LIB_LOGV("Removing graph's connection: %![graph-]+g, %![conn-]+x",
+ BT_LIB_LOGD("Removing graph's connection: %![graph-]+g, %![conn-]+x",
graph, connection);
g_ptr_array_remove(graph->connections, connection);
}
graph, connection);
g_ptr_array_remove(graph->connections, connection);
}
"Parameter value is not a map value: %!+v", params);
init_can_consume = graph->can_consume;
bt_graph_set_can_consume(graph, false);
"Parameter value is not a map value: %!+v", params);
init_can_consume = graph->can_consume;
bt_graph_set_can_consume(graph, false);
- BT_LIB_LOGD("Adding component to graph: "
+ BT_LIB_LOGI("Adding component to graph: "
"%![graph-]+g, %![cc-]+C, name=\"%s\", %![params-]+v, "
"init-method-data-addr=%p",
graph, comp_cls, name, params, init_method_data);
"%![graph-]+g, %![cc-]+C, name=\"%s\", %![params-]+v, "
"init-method-data-addr=%p",
graph, comp_cls, name, params, init_method_data);
if (!params) {
new_params = bt_value_map_create();
if (!new_params) {
if (!params) {
new_params = bt_value_map_create();
if (!new_params) {
- BT_LOGE_STR("Cannot create map value object.");
+ BT_LOGE_STR("Cannot create empty map value object.");
graph_status = BT_GRAPH_STATUS_NOMEM;
goto end;
}
graph_status = BT_GRAPH_STATUS_NOMEM;
goto end;
}
*/
BT_LOGD_STR("Freezing component class.");
bt_component_class_freeze(comp_cls);
*/
BT_LOGD_STR("Freezing component class.");
bt_component_class_freeze(comp_cls);
- BT_LIB_LOGD("Added component to graph: "
+ BT_LIB_LOGI("Added component to graph: "
"%![graph-]+g, %![cc-]+C, name=\"%s\", %![params-]+v, "
"init-method-data-addr=%p, %![comp-]+c",
graph, comp_cls, name, params, init_method_data, component);
"%![graph-]+g, %![cc-]+C, name=\"%s\", %![params-]+v, "
"init-method-data-addr=%p, %![comp-]+c",
graph, comp_cls, name, params, init_method_data, component);
void bt_graph_make_faulty(struct bt_graph *graph)
{
graph->config_state = BT_GRAPH_CONFIGURATION_STATE_FAULTY;
void bt_graph_make_faulty(struct bt_graph *graph)
{
graph->config_state = BT_GRAPH_CONFIGURATION_STATE_FAULTY;
-#ifdef BT_LIB_LOGD
- BT_LIB_LOGD("Set graph's state to faulty: %![graph-]+g", graph);
+#ifdef BT_LIB_LOGI
+ BT_LIB_LOGI("Set graph's state to faulty: %![graph-]+g", graph);
*/
obj->ref_count++;
iterator = (void *) obj;
*/
obj->ref_count++;
iterator = (void *) obj;
- BT_LIB_LOGD("Destroying self component input port message iterator object: "
+ BT_LIB_LOGI("Destroying self component input port message iterator object: "
"%!+i", iterator);
bt_self_component_port_input_message_iterator_try_finalize(iterator);
"%!+i", iterator);
bt_self_component_port_input_message_iterator_try_finalize(iterator);
{
BT_ASSERT(iterator);
iterator->connection = connection;
{
BT_ASSERT(iterator);
iterator->connection = connection;
- BT_LIB_LOGV("Set message iterator's connection: "
+ BT_LIB_LOGI("Set message iterator's connection: "
"%![iter-]+i, %![conn-]+x", iterator, connection);
}
"%![iter-]+i, %![conn-]+x", iterator, connection);
}
BT_ASSERT(upstream_comp);
BT_ASSERT(upstream_port);
BT_ASSERT(bt_port_is_connected(upstream_port));
BT_ASSERT(upstream_comp);
BT_ASSERT(upstream_port);
BT_ASSERT(bt_port_is_connected(upstream_port));
- BT_LIB_LOGD("Creating initial message iterator on self component input port: "
+ BT_LIB_LOGI("Creating initial message iterator on self component input port: "
"%![up-comp-]+c, %![up-port-]+p", upstream_comp, upstream_port);
BT_ASSERT(bt_component_get_class_type(upstream_comp) ==
BT_COMPONENT_CLASS_TYPE_SOURCE ||
"%![up-comp-]+c, %![up-port-]+p", upstream_comp, upstream_port);
BT_ASSERT(bt_component_get_class_type(upstream_comp) ==
BT_COMPONENT_CLASS_TYPE_SOURCE ||
can_seek_beginning_true;
}
can_seek_beginning_true;
}
- BT_LIB_LOGD("Created initial message iterator on self component input port: "
+ BT_LIB_LOGI("Created initial message iterator on self component input port: "
"%![up-port-]+p, %![up-comp-]+c, %![iter-]+i",
upstream_port, upstream_comp, iterator);
"%![up-port-]+p, %![up-comp-]+c, %![iter-]+i",
upstream_port, upstream_comp, iterator);
set_self_comp_port_input_msg_iterator_state(iterator,
BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_STATE_ACTIVE);
g_ptr_array_add(port->connection->iterators, iterator);
set_self_comp_port_input_msg_iterator_state(iterator,
BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_STATE_ACTIVE);
g_ptr_array_add(port->connection->iterators, iterator);
- BT_LIB_LOGD("Created message iterator on self component input port: "
+ BT_LIB_LOGI("Created message iterator on self component input port: "
"%![up-port-]+p, %![up-comp-]+c, %![iter-]+i",
upstream_port, upstream_comp, iterator);
"%![up-port-]+p, %![up-comp-]+c, %![iter-]+i",
upstream_port, upstream_comp, iterator);
BT_ASSERT_PRE_NON_NULL(iterator, "Message iterator");
iterator->user_data = data;
BT_ASSERT_PRE_NON_NULL(iterator, "Message iterator");
iterator->user_data = data;
- BT_LIB_LOGV("Set message iterator's user data: "
+ BT_LIB_LOGD("Set message iterator's user data: "
"%!+i, user-data-addr=%p", iterator, data);
}
"%!+i, user-data-addr=%p", iterator, data);
}
"Graph is not configured: %!+g",
bt_component_borrow_graph(iterator->upstream_component));
BT_LIB_LOGD("Getting next self component input port "
"Graph is not configured: %!+g",
bt_component_borrow_graph(iterator->upstream_component));
BT_LIB_LOGD("Getting next self component input port "
- "message iterator's messages: %!+i", iterator);
+ "message iterator's messages: %!+i, batch-size=%u",
+ iterator, MSG_BATCH_SIZE);
/*
* Call the user's "next" method to get the next messages
/*
* Call the user's "next" method to get the next messages
*/
BT_ASSERT(iterator->methods.next);
BT_LOGD_STR("Calling user's \"next\" method.");
*/
BT_ASSERT(iterator->methods.next);
BT_LOGD_STR("Calling user's \"next\" method.");
status = iterator->methods.next(iterator,
(void *) iterator->base.msgs->pdata, MSG_BATCH_SIZE,
user_count);
status = iterator->methods.next(iterator,
(void *) iterator->base.msgs->pdata, MSG_BATCH_SIZE,
user_count);
- BT_LOGD("User method returned: status=%s",
- bt_message_iterator_status_string(status));
+ BT_LOGD("User method returned: status=%s, msg-count=%" PRIu64,
+ bt_message_iterator_status_string(status), *user_count);
if (status < 0) {
BT_LOGW_STR("User method failed.");
goto end;
if (status < 0) {
BT_LOGW_STR("User method failed.");
goto end;
{
struct bt_port_output_message_iterator *iterator = (void *) obj;
{
struct bt_port_output_message_iterator *iterator = (void *) obj;
- BT_LIB_LOGD("Destroying output port message iterator object: %!+i",
+ BT_LIB_LOGI("Destroying output port message iterator object: %!+i",
iterator);
BT_LOGD_STR("Putting graph.");
BT_OBJECT_PUT_REF_AND_RESET(iterator->graph);
iterator);
BT_LOGD_STR("Putting graph.");
BT_OBJECT_PUT_REF_AND_RESET(iterator->graph);
"Graph already has a sink component: %![graph-]+g");
/* Create message iterator */
"Graph already has a sink component: %![graph-]+g");
/* Create message iterator */
- BT_LIB_LOGD("Creating message iterator on output port: "
+ BT_LIB_LOGI("Creating message iterator on output port: "
"%![port-]+p, %![comp-]+c", output_port, output_port_comp);
iterator = g_new0(struct bt_port_output_message_iterator, 1);
if (!iterator) {
"%![port-]+p, %![comp-]+c", output_port, output_port_comp);
iterator = g_new0(struct bt_port_output_message_iterator, 1);
if (!iterator) {
(struct bt_message_message_iterator_inactivity *) obj;
BT_LIB_LOGD("Destroying message iterator inactivity message: %!+n",
(struct bt_message_message_iterator_inactivity *) obj;
BT_LIB_LOGD("Destroying message iterator inactivity message: %!+n",
if (message->default_cs) {
bt_clock_snapshot_recycle(message->default_cs);
if (message->default_cs) {
bt_clock_snapshot_recycle(message->default_cs);
message = g_new0(struct bt_message_message_iterator_inactivity, 1);
if (!message) {
BT_LOGE_STR("Failed to allocate one message iterator "
message = g_new0(struct bt_message_message_iterator_inactivity, 1);
if (!message) {
BT_LOGE_STR("Failed to allocate one message iterator "
- "inactivity message.");
+ "inactivity message.");
goto error;
}
bt_message_init(&message->parent,
goto error;
}
bt_message_init(&message->parent,
bt_clock_snapshot_set_raw_value(message->default_cs, value_cycles);
BT_LIB_LOGD("Created message iterator inactivity message object: %!+n",
bt_clock_snapshot_set_raw_value(message->default_cs, value_cycles);
BT_LIB_LOGD("Created message iterator inactivity message object: %!+n",
value_cycles);
stream_act_msg->default_cs_state =
BT_MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_KNOWN;
value_cycles);
stream_act_msg->default_cs_state =
BT_MESSAGE_STREAM_ACTIVITY_CLOCK_SNAPSHOT_STATE_KNOWN;
- BT_LIB_LOGV("Set stream activity message's default clock snapshot: "
+ BT_LIB_LOGD("Set stream activity message's default clock snapshot: "
"%![msg-]+n, value=%" PRIu64, msg, value_cycles);
}
"%![msg-]+n, value=%" PRIu64, msg, value_cycles);
}
msg,
bt_message_stream_activity_clock_snapshot_state_string(state));
stream_act_msg->default_cs_state = state;
msg,
bt_message_stream_activity_clock_snapshot_state_string(state));
stream_act_msg->default_cs_state = state;
- BT_LIB_LOGV("Set stream activity message's default clock snapshot state: "
+ BT_LIB_LOGD("Set stream activity message's default clock snapshot state: "
"%![msg-]+n, state=%s", msg,
bt_message_stream_activity_clock_snapshot_state_string(state));
}
"%![msg-]+n, state=%s", msg,
bt_message_stream_activity_clock_snapshot_state_string(state));
}
{
struct bt_port *port = (void *) obj;
{
struct bt_port *port = (void *) obj;
- BT_LIB_LOGD("Destroying port: %!+p", port);
+ BT_LIB_LOGI("Destroying port: %!+p", port);
if (port->name) {
g_string_free(port->name, TRUE);
if (port->name) {
g_string_free(port->name, TRUE);
- BT_LIB_LOGD("Creating port for component: %![comp-]+c, port-type=%s, "
+ BT_LIB_LOGI("Creating port for component: %![comp-]+c, port-type=%s, "
"port-name=\"%s\"", parent_component, bt_port_type_string(type),
name);
bt_object_init_shared_with_parent(&port->base, destroy_port);
"port-name=\"%s\"", parent_component, bt_port_type_string(type),
name);
bt_object_init_shared_with_parent(&port->base, destroy_port);
port->type = type;
port->user_data = user_data;
bt_object_set_parent(&port->base, &parent_component->base);
port->type = type;
port->user_data = user_data;
bt_object_set_parent(&port->base, &parent_component->base);
- BT_LIB_LOGD("Created port for component: "
+ BT_LIB_LOGI("Created port for component: "
"%![comp-]+c, %![port-]+p", parent_component, port);
end:
"%![comp-]+c, %![port-]+p", parent_component, port);
end:
* connection exists.
*/
port->connection = connection;
* connection exists.
*/
port->connection = connection;
- BT_LIB_LOGV("Set port's connection: %![port-]+p, %![conn-]+x", port,
+ BT_LIB_LOGI("Set port's connection: %![port-]+p, %![conn-]+x", port,
{
BT_ASSERT_PRE_NON_NULL(query_exec, "Query executor");
query_exec->canceled = BT_TRUE;
{
BT_ASSERT_PRE_NON_NULL(query_exec, "Query executor");
query_exec->canceled = BT_TRUE;
- BT_LOGV("Canceled query executor: addr=%p", query_exec);
+ BT_LOGI("Canceled query executor: addr=%p", query_exec);
return BT_QUERY_EXECUTOR_STATUS_OK;
}
return BT_QUERY_EXECUTOR_STATUS_OK;
}
}
/* Pool is empty: create a brand new object */
}
/* Pool is empty: create a brand new object */
-#ifdef BT_LOGV
- BT_LOGV("Pool is empty: allocating new object: pool-addr=%p",
+#ifdef BT_LOGD
+ BT_LOGD("Pool is empty: allocating new object: pool-addr=%p",
if (pool->size == pool->objects->len) {
/* Backing array is full: make place for recycled object */
if (pool->size == pool->objects->len) {
/* Backing array is full: make place for recycled object */
-#ifdef BT_LOGV
- BT_LOGV("Object pool is full: increasing object pool capacity: "
+#ifdef BT_LOGD
+ BT_LOGD("Object pool is full: increasing object pool capacity: "
"pool-addr=%p, old-pool-cap=%u, new-pool-cap=%u",
pool, pool->objects->len, pool->objects->len + 1);
#endif
"pool-addr=%p, old-pool-cap=%u, new-pool-cap=%u",
pool, pool->objects->len, pool->objects->len + 1);
#endif
const char *path = shared_lib_handle->path ?
shared_lib_handle->path->str : NULL;
const char *path = shared_lib_handle->path ?
shared_lib_handle->path->str : NULL;
- BT_LOGD("Destroying shared library handle: addr=%p, path=\"%s\"",
+ BT_LOGI("Destroying shared library handle: addr=%p, path=\"%s\"",
shared_lib_handle, path);
if (shared_lib_handle->init_called && shared_lib_handle->exit) {
shared_lib_handle, path);
if (shared_lib_handle->init_called && shared_lib_handle->exit) {
if (!var || strcmp(var, "1") != 0) {
#endif
if (!var || strcmp(var, "1") != 0) {
#endif
- BT_LOGD("Closing GModule: path=\"%s\"", path);
+ BT_LOGI("Closing GModule: path=\"%s\"", path);
if (!g_module_close(shared_lib_handle->module)) {
BT_LOGE("Cannot close GModule: %s: path=\"%s\"",
if (!g_module_close(shared_lib_handle->module)) {
BT_LOGE("Cannot close GModule: %s: path=\"%s\"",
shared_lib_handle->module = NULL;
#ifndef NDEBUG
} else {
shared_lib_handle->module = NULL;
#ifndef NDEBUG
} else {
- BT_LOGD("Not closing GModule because `BABELTRACE_NO_DLCLOSE=1`: "
+ BT_LOGI("Not closing GModule because `BABELTRACE_NO_DLCLOSE=1`: "
"path=\"%s\"", path);
}
#endif
"path=\"%s\"", path);
}
#endif
{
struct bt_plugin_so_shared_lib_handle *shared_lib_handle = NULL;
{
struct bt_plugin_so_shared_lib_handle *shared_lib_handle = NULL;
- BT_LOGD("Creating shared library handle: path=\"%s\"", path);
+ BT_LOGI("Creating shared library handle: path=\"%s\"", path);
shared_lib_handle = g_new0(struct bt_plugin_so_shared_lib_handle, 1);
if (!shared_lib_handle) {
BT_LOGE_STR("Failed to allocate one shared library handle.");
shared_lib_handle = g_new0(struct bt_plugin_so_shared_lib_handle, 1);
if (!shared_lib_handle) {
BT_LOGE_STR("Failed to allocate one shared library handle.");
shared_lib_handle->module = g_module_open(path, G_MODULE_BIND_LOCAL);
if (!shared_lib_handle->module) {
/*
shared_lib_handle->module = g_module_open(path, G_MODULE_BIND_LOCAL);
if (!shared_lib_handle->module) {
/*
- * DEBUG-level logging because we're only _trying_ to
+ * INFO-level logging because we're only _trying_ to
* open this file as a Babeltrace plugin: if it's not,
* it's not an error. And because this can be tried
* open this file as a Babeltrace plugin: if it's not,
* it's not an error. And because this can be tried
- * during bt_plugin_find_all_from_dir(), it's not even
- * a warning.
+ * during bt_plugin_find_all_from_dir(), it's not even a
+ * warning.
- BT_LOGD("Cannot open GModule: %s: path=\"%s\"",
+ BT_LOGI("Cannot open GModule: %s: path=\"%s\"",
g_module_error(), path);
goto error;
}
g_module_error(), path);
goto error;
}
end:
if (shared_lib_handle) {
end:
if (shared_lib_handle) {
- BT_LOGD("Created shared library handle: path=\"%s\", addr=%p",
+ BT_LOGI("Created shared library handle: path=\"%s\", addr=%p",
path, shared_lib_handle);
}
path, shared_lib_handle);
}
- BT_LOGD("Initializing plugin object from descriptors found in sections: "
+ BT_LOGI("Initializing plugin object from descriptors found in sections: "
"plugin-addr=%p, plugin-path=\"%s\", "
"attrs-begin-addr=%p, attrs-end-addr=%p, "
"cc-descr-begin-addr=%p, cc-descr-end-addr=%p, "
"plugin-addr=%p, plugin-path=\"%s\", "
"attrs-begin-addr=%p, attrs-end-addr=%p, "
"cc-descr-begin-addr=%p, cc-descr-end-addr=%p, "
struct bt_component_class_filter *flt_comp_class = NULL;
struct bt_component_class_sink *sink_comp_class = NULL;
struct bt_component_class_filter *flt_comp_class = NULL;
struct bt_component_class_sink *sink_comp_class = NULL;
- BT_LOGD("Creating and setting properties of plugin's component class: "
+ BT_LOGI("Creating and setting properties of plugin's component class: "
"plugin-path=\"%s\", plugin-name=\"%s\", "
"comp-class-name=\"%s\", comp-class-type=%s",
spec->shared_lib_handle->path ?
"plugin-path=\"%s\", plugin-name=\"%s\", "
"comp-class-name=\"%s\", comp-class-type=%s",
spec->shared_lib_handle->path ?
cc_descriptors_count = count_non_null_items_in_section(cc_descriptors_begin, cc_descriptors_end);
cc_descr_attrs_count = count_non_null_items_in_section(cc_descr_attrs_begin, cc_descr_attrs_end);
cc_descriptors_count = count_non_null_items_in_section(cc_descriptors_begin, cc_descriptors_end);
cc_descr_attrs_count = count_non_null_items_in_section(cc_descr_attrs_begin, cc_descr_attrs_end);
- BT_LOGD("Creating all SO plugins from sections: "
+ BT_LOGI("Creating all SO plugins from sections: "
"plugin-path=\"%s\", "
"descr-begin-addr=%p, descr-end-addr=%p, "
"attrs-begin-addr=%p, attrs-end-addr=%p, "
"plugin-path=\"%s\", "
"descr-begin-addr=%p, descr-end-addr=%p, "
"attrs-begin-addr=%p, attrs-end-addr=%p, "
- BT_LOGD("Creating plugin object for plugin: "
+ BT_LOGI("Creating plugin object for plugin: "
"name=\"%s\", abi-major=%d, abi-minor=%d",
descriptor->name, descriptor->major, descriptor->minor);
if (descriptor->major > __BT_PLUGIN_VERSION_MAJOR) {
/*
"name=\"%s\", abi-major=%d, abi-minor=%d",
descriptor->name, descriptor->major, descriptor->minor);
if (descriptor->major > __BT_PLUGIN_VERSION_MAJOR) {
/*
- * DEBUG-level logging because we're only
+ * INFO-level logging because we're only
* _trying_ to open this file as a compatible
* Babeltrace plugin: if it's not, it's not an
* error. And because this can be tried during
* _trying_ to open this file as a compatible
* Babeltrace plugin: if it's not, it's not an
* error. And because this can be tried during
- * bt_plugin_find_all_from_dir(), it's not
- * even a warning.
+ * bt_plugin_find_all_from_dir(), it's not even
+ * a warning.
- BT_LOGD("Unknown ABI major version: abi-major=%d",
+ BT_LOGI("Unknown ABI major version: abi-major=%d",
descriptor->major);
goto error;
}
descriptor->major);
goto error;
}
bt_bool is_libtool_wrapper = BT_FALSE, is_shared_object = BT_FALSE;
struct bt_plugin_so_shared_lib_handle *shared_lib_handle = NULL;
bt_bool is_libtool_wrapper = BT_FALSE, is_shared_object = BT_FALSE;
struct bt_plugin_so_shared_lib_handle *shared_lib_handle = NULL;
- if (!path) {
- BT_LOGW_STR("Invalid parameter: path is NULL.");
- goto end;
- }
-
- BT_LOGD("Creating all SO plugins from file: path=\"%s\"", path);
- if (path_len <= PLUGIN_SUFFIX_LEN) {
- BT_LOGW("Invalid parameter: path length is too short: "
- "path-length=%zu", path_len);
- goto end;
- }
-
+ BT_ASSERT_PRE(path_len > PLUGIN_SUFFIX_LEN,
+ "Path length is too short: path-length=%zu, min-length=%zu",
+ path_len, PLUGIN_SUFFIX_LEN);
+ BT_LOGI("Trying to create all SO plugins from file: path=\"%s\"", path);
- * Check if the file ends with a known plugin file type suffix (i.e. .so
- * or .la on Linux).
+ * Check if the file ends with a known plugin file type suffix
+ * (i.e. .so or .la on Linux).
*/
is_libtool_wrapper = !strncmp(LIBTOOL_PLUGIN_SUFFIX,
path + path_len - LIBTOOL_PLUGIN_SUFFIX_LEN,
*/
is_libtool_wrapper = !strncmp(LIBTOOL_PLUGIN_SUFFIX,
path + path_len - LIBTOOL_PLUGIN_SUFFIX_LEN,
NATIVE_PLUGIN_SUFFIX_LEN);
if (!is_shared_object && !is_libtool_wrapper) {
/* Name indicates this is not a plugin file; not an error */
NATIVE_PLUGIN_SUFFIX_LEN);
if (!is_shared_object && !is_libtool_wrapper) {
/* Name indicates this is not a plugin file; not an error */
- BT_LOGV("File is not a SO plugin file: path=\"%s\"", path);
+ BT_LOGI("File is not a SO plugin file: path=\"%s\"", path);
goto end;
}
shared_lib_handle = bt_plugin_so_shared_lib_handle_create(path);
if (!shared_lib_handle) {
goto end;
}
shared_lib_handle = bt_plugin_so_shared_lib_handle_create(path);
if (!shared_lib_handle) {
+ /* bt_plugin_so_shared_lib_handle_create() logs more details */
BT_LOGD_STR("Cannot create shared library handle.");
goto end;
}
BT_LOGD_STR("Cannot create shared library handle.");
goto end;
}
(gpointer *) &get_begin_section_plugin_descriptors)) {
descriptors_begin = get_begin_section_plugin_descriptors();
} else {
(gpointer *) &get_begin_section_plugin_descriptors)) {
descriptors_begin = get_begin_section_plugin_descriptors();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_begin_section_plugin_descriptors");
goto end;
"symbol=\"%s\"", path,
"__bt_get_begin_section_plugin_descriptors");
goto end;
(gpointer *) &get_end_section_plugin_descriptors)) {
descriptors_end = get_end_section_plugin_descriptors();
} else {
(gpointer *) &get_end_section_plugin_descriptors)) {
descriptors_end = get_end_section_plugin_descriptors();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_end_section_plugin_descriptors");
goto end;
"symbol=\"%s\"", path,
"__bt_get_end_section_plugin_descriptors");
goto end;
(gpointer *) &get_begin_section_plugin_descriptor_attributes)) {
attrs_begin = get_begin_section_plugin_descriptor_attributes();
} else {
(gpointer *) &get_begin_section_plugin_descriptor_attributes)) {
attrs_begin = get_begin_section_plugin_descriptor_attributes();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_begin_section_plugin_descriptor_attributes");
}
"symbol=\"%s\"", path,
"__bt_get_begin_section_plugin_descriptor_attributes");
}
(gpointer *) &get_end_section_plugin_descriptor_attributes)) {
attrs_end = get_end_section_plugin_descriptor_attributes();
} else {
(gpointer *) &get_end_section_plugin_descriptor_attributes)) {
attrs_end = get_end_section_plugin_descriptor_attributes();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_end_section_plugin_descriptor_attributes");
}
if ((!!attrs_begin - !!attrs_end) != 0) {
"symbol=\"%s\"", path,
"__bt_get_end_section_plugin_descriptor_attributes");
}
if ((!!attrs_begin - !!attrs_end) != 0) {
- BT_LOGD("Found section start or end symbol, but not both: "
+ BT_LOGI("Found section start or end symbol, but not both: "
"path=\"%s\", symbol-start=\"%s\", "
"symbol-end=\"%s\", symbol-start-addr=%p, "
"symbol-end-addr=%p",
"path=\"%s\", symbol-start=\"%s\", "
"symbol-end=\"%s\", symbol-start-addr=%p, "
"symbol-end-addr=%p",
(gpointer *) &get_begin_section_component_class_descriptors)) {
cc_descriptors_begin = get_begin_section_component_class_descriptors();
} else {
(gpointer *) &get_begin_section_component_class_descriptors)) {
cc_descriptors_begin = get_begin_section_component_class_descriptors();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_begin_section_component_class_descriptors");
}
"symbol=\"%s\"", path,
"__bt_get_begin_section_component_class_descriptors");
}
(gpointer *) &get_end_section_component_class_descriptors)) {
cc_descriptors_end = get_end_section_component_class_descriptors();
} else {
(gpointer *) &get_end_section_component_class_descriptors)) {
cc_descriptors_end = get_end_section_component_class_descriptors();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_end_section_component_class_descriptors");
}
if ((!!cc_descriptors_begin - !!cc_descriptors_end) != 0) {
"symbol=\"%s\"", path,
"__bt_get_end_section_component_class_descriptors");
}
if ((!!cc_descriptors_begin - !!cc_descriptors_end) != 0) {
- BT_LOGD("Found section start or end symbol, but not both: "
+ BT_LOGI("Found section start or end symbol, but not both: "
"path=\"%s\", symbol-start=\"%s\", "
"symbol-end=\"%s\", symbol-start-addr=%p, "
"symbol-end-addr=%p",
"path=\"%s\", symbol-start=\"%s\", "
"symbol-end=\"%s\", symbol-start-addr=%p, "
"symbol-end-addr=%p",
(gpointer *) &get_begin_section_component_class_descriptor_attributes)) {
cc_descr_attrs_begin = get_begin_section_component_class_descriptor_attributes();
} else {
(gpointer *) &get_begin_section_component_class_descriptor_attributes)) {
cc_descr_attrs_begin = get_begin_section_component_class_descriptor_attributes();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_begin_section_component_class_descriptor_attributes");
}
"symbol=\"%s\"", path,
"__bt_get_begin_section_component_class_descriptor_attributes");
}
(gpointer *) &get_end_section_component_class_descriptor_attributes)) {
cc_descr_attrs_end = get_end_section_component_class_descriptor_attributes();
} else {
(gpointer *) &get_end_section_component_class_descriptor_attributes)) {
cc_descr_attrs_end = get_end_section_component_class_descriptor_attributes();
} else {
- BT_LOGD("Cannot resolve plugin symbol: path=\"%s\", "
+ BT_LOGI("Cannot resolve plugin symbol: path=\"%s\", "
"symbol=\"%s\"", path,
"__bt_get_end_section_component_class_descriptor_attributes");
}
if ((!!cc_descr_attrs_begin - !!cc_descr_attrs_end) != 0) {
"symbol=\"%s\"", path,
"__bt_get_end_section_component_class_descriptor_attributes");
}
if ((!!cc_descr_attrs_begin - !!cc_descr_attrs_end) != 0) {
- BT_LOGD("Found section start or end symbol, but not both: "
+ BT_LOGI("Found section start or end symbol, but not both: "
"path=\"%s\", symbol-start=\"%s\", "
"symbol-end=\"%s\", symbol-start-addr=%p, "
"symbol-end-addr=%p",
"path=\"%s\", symbol-start=\"%s\", "
"symbol-end=\"%s\", symbol-start-addr=%p, "
"symbol-end-addr=%p",
{
bt_list_del(&comp_class->node);
BT_OBJECT_PUT_REF_AND_RESET(comp_class->so_handle);
{
bt_list_del(&comp_class->node);
BT_OBJECT_PUT_REF_AND_RESET(comp_class->so_handle);
- BT_LOGV("Component class destroyed: removed entry from list: "
+ BT_LOGD("Component class destroyed: removed entry from list: "
"comp-cls-addr=%p", comp_class);
}
"comp-cls-addr=%p", comp_class);
}
- BT_LOGD_STR("Loading Python plugin provider module.");
+ BT_LOGI_STR("Loading Python plugin provider module.");
python_plugin_provider_module =
g_module_open(PYTHON_PLUGIN_PROVIDER_FILENAME, 0);
if (!python_plugin_provider_module) {
python_plugin_provider_module =
g_module_open(PYTHON_PLUGIN_PROVIDER_FILENAME, 0);
if (!python_plugin_provider_module) {
__attribute__((destructor)) static
void fini_python_plugin_provider(void) {
if (python_plugin_provider_module) {
__attribute__((destructor)) static
void fini_python_plugin_provider(void) {
if (python_plugin_provider_module) {
- BT_LOGD("Unloading Python plugin provider module.");
+ BT_LOGI("Unloading Python plugin provider module.");
if (!g_module_close(python_plugin_provider_module)) {
BT_LOGE("Failed to close the Python plugin provider module: %s.",
if (!g_module_close(python_plugin_provider_module)) {
BT_LOGE("Failed to close the Python plugin provider module: %s.",
struct bt_plugin_set *plugin_set = NULL;
BT_ASSERT_PRE_NON_NULL(path, "Path");
struct bt_plugin_set *plugin_set = NULL;
BT_ASSERT_PRE_NON_NULL(path, "Path");
- BT_LOGD("Creating plugins from file: path=\"%s\"", path);
+ BT_LOGI("Creating plugins from file: path=\"%s\"", path);
/* Try shared object plugins */
plugin_set = bt_plugin_so_create_all_from_file(path);
/* Try shared object plugins */
plugin_set = bt_plugin_so_create_all_from_file(path);
- BT_LOGD("Created %u plugins from file: "
+ BT_LOGI("Created %u plugins from file: "
"path=\"%s\", count=%u, plugin-set-addr=%p",
plugin_set->plugins->len, path,
plugin_set->plugins->len, plugin_set);
} else {
"path=\"%s\", count=%u, plugin-set-addr=%p",
plugin_set->plugins->len, path,
plugin_set->plugins->len, plugin_set);
} else {
- BT_LOGD("Found no plugins in file: path=\"%s\"", path);
+ BT_LOGI("Found no plugins in file: path=\"%s\"", path);
size_t i, j;
BT_ASSERT_PRE_NON_NULL(plugin_name, "Name");
size_t i, j;
BT_ASSERT_PRE_NON_NULL(plugin_name, "Name");
- BT_LOGD("Finding named plugin in standard directories and built-in plugins: "
+ BT_LOGI("Finding named plugin in standard directories and built-in plugins: "
"name=\"%s\"", plugin_name);
dirs = g_ptr_array_new_with_free_func((GDestroyNotify) destroy_gstring);
if (!dirs) {
"name=\"%s\"", plugin_name);
dirs = g_ptr_array_new_with_free_func((GDestroyNotify) destroy_gstring);
if (!dirs) {
* bt_plugin_find_all_from_dir() would log a warning.
*/
if (!g_file_test(dir->str, G_FILE_TEST_IS_DIR)) {
* bt_plugin_find_all_from_dir() would log a warning.
*/
if (!g_file_test(dir->str, G_FILE_TEST_IS_DIR)) {
- BT_LOGV("Skipping nonexistent directory path: "
+ BT_LOGI("Skipping nonexistent directory path: "
"path=\"%s\"", dir->str);
continue;
}
"path=\"%s\"", dir->str);
continue;
}
/* bt_plugin_find_all_from_dir() logs details/errors */
plugin_set = bt_plugin_find_all_from_dir(dir->str, BT_FALSE);
if (!plugin_set) {
/* bt_plugin_find_all_from_dir() logs details/errors */
plugin_set = bt_plugin_find_all_from_dir(dir->str, BT_FALSE);
if (!plugin_set) {
- BT_LOGD("No plugins found in directory: path=\"%s\"",
+ BT_LOGI("No plugins found in directory: path=\"%s\"",
if (strcmp(bt_plugin_get_name(candidate_plugin),
plugin_name) == 0) {
if (strcmp(bt_plugin_get_name(candidate_plugin),
plugin_name) == 0) {
- BT_LOGD("Plugin found in directory: name=\"%s\", path=\"%s\"",
+ BT_LOGI("Plugin found in directory: name=\"%s\", path=\"%s\"",
plugin_name, dir->str);
plugin = candidate_plugin;
bt_object_get_no_null_check(plugin);
plugin_name, dir->str);
plugin = candidate_plugin;
bt_object_get_no_null_check(plugin);
- BT_LOGD("Plugin not found in directory: name=\"%s\", path=\"%s\"",
+ BT_LOGI("Plugin not found in directory: name=\"%s\", path=\"%s\"",
plugin_name, dir->str);
}
plugin_name, dir->str);
}
if (strcmp(bt_plugin_get_name(candidate_plugin),
plugin_name) == 0) {
if (strcmp(bt_plugin_get_name(candidate_plugin),
plugin_name) == 0) {
- BT_LOGD("Plugin found in built-in plugins: "
+ BT_LOGI("Plugin found in built-in plugins: "
"name=\"%s\"", plugin_name);
plugin = candidate_plugin;
bt_object_get_no_null_check(plugin);
"name=\"%s\"", plugin_name);
plugin = candidate_plugin;
bt_object_get_no_null_check(plugin);
- BT_LIB_LOGD("Found plugin in standard directories and built-in plugins: "
+ BT_LIB_LOGI("Found plugin in standard directories and built-in plugins: "
"%!+l", plugin);
} else {
"%!+l", plugin);
} else {
- BT_LOGD("No plugin found in standard directories and built-in plugins: "
+ BT_LOGI("No plugin found in standard directories and built-in plugins: "
"name=\"%s\"", plugin_name);
}
"name=\"%s\"", plugin_name);
}
if (name[0] == '.') {
/* Skip hidden files */
if (name[0] == '.') {
/* Skip hidden files */
- BT_LOGV("Skipping hidden file: path=\"%s\"", file);
+ BT_LOGI("Skipping hidden file: path=\"%s\"", file);
struct bt_plugin *plugin =
g_ptr_array_index(plugins_from_file->plugins, j);
struct bt_plugin *plugin =
g_ptr_array_index(plugins_from_file->plugins, j);
- BT_LIB_LOGD("Adding plugin to plugin set: "
+ BT_LIB_LOGI("Adding plugin to plugin set: "
"plugin-path=\"%s\", %![plugin-]+l",
file, plugin);
bt_plugin_set_add_plugin(
"plugin-path=\"%s\", %![plugin-]+l",
file, plugin);
bt_plugin_set_add_plugin(
break;
case FTW_NS:
/* Continue to next file / directory. */
break;
case FTW_NS:
/* Continue to next file / directory. */
- BT_LOGD("Cannot get file information: continuing: path=\"%s\"", file);
+ BT_LOGI("Cannot get file information: continuing: path=\"%s\"", file);
struct bt_plugin_set *plugin_set;
enum bt_plugin_status status;
struct bt_plugin_set *plugin_set;
enum bt_plugin_status status;
- BT_LOGD("Creating all plugins in directory: path=\"%s\", recurse=%d",
+ BT_LOGI("Creating all plugins in directory: path=\"%s\", recurse=%d",
path, recurse);
plugin_set = bt_plugin_set_create();
if (!plugin_set) {
path, recurse);
plugin_set = bt_plugin_set_create();
if (!plugin_set) {
- BT_LOGD("Created %u plugins from directory: count=%u, path=\"%s\"",
+ BT_LOGI("Created %u plugins from directory: count=%u, path=\"%s\"",
plugin_set->plugins->len, plugin_set->plugins->len, path);
goto end;
plugin_set->plugins->len, plugin_set->plugins->len, path);
goto end;
BT_ASSERT_PRE_NON_NULL(plugin, "Plugin");
if (!plugin->info.version_set) {
BT_ASSERT_PRE_NON_NULL(plugin, "Plugin");
if (!plugin->info.version_set) {
- BT_LIB_LOGV("Plugin's version is not set: %!+l", plugin);
+ BT_LIB_LOGD("Plugin's version is not set: %!+l", plugin);
avail = BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE;
goto end;
}
avail = BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE;
goto end;
}
BT_ASSERT(obj);
plugin = container_of(obj, struct bt_plugin, base);
BT_ASSERT(obj);
plugin = container_of(obj, struct bt_plugin, base);
- BT_LIB_LOGD("Destroying plugin object: %!+l", plugin);
+ BT_LIB_LOGI("Destroying plugin object: %!+l", plugin);
if (plugin->destroy_spec_data) {
plugin->destroy_spec_data(plugin);
if (plugin->destroy_spec_data) {
plugin->destroy_spec_data(plugin);
BT_ASSERT(path);
g_string_assign(plugin->info.path, path);
plugin->info.path_set = BT_TRUE;
BT_ASSERT(path);
g_string_assign(plugin->info.path, path);
plugin->info.path_set = BT_TRUE;
- BT_LIB_LOGV("Set plugin's path: %![plugin-]+l, path=\"%s\"",
+ BT_LIB_LOGD("Set plugin's path: %![plugin-]+l, path=\"%s\"",
BT_ASSERT(name);
g_string_assign(plugin->info.name, name);
plugin->info.name_set = BT_TRUE;
BT_ASSERT(name);
g_string_assign(plugin->info.name, name);
plugin->info.name_set = BT_TRUE;
- BT_LIB_LOGV("Set plugin's name: %![plugin-]+l, name=\"%s\"",
+ BT_LIB_LOGD("Set plugin's name: %![plugin-]+l, name=\"%s\"",
BT_ASSERT(description);
g_string_assign(plugin->info.description, description);
plugin->info.description_set = BT_TRUE;
BT_ASSERT(description);
g_string_assign(plugin->info.description, description);
plugin->info.description_set = BT_TRUE;
- BT_LIB_LOGV("Set plugin's description: %![plugin-]+l", plugin);
+ BT_LIB_LOGD("Set plugin's description: %![plugin-]+l", plugin);
BT_ASSERT(author);
g_string_assign(plugin->info.author, author);
plugin->info.author_set = BT_TRUE;
BT_ASSERT(author);
g_string_assign(plugin->info.author, author);
plugin->info.author_set = BT_TRUE;
- BT_LIB_LOGV("Set plugin's author: %![plugin-]+l, author=\"%s\"",
+ BT_LIB_LOGD("Set plugin's author: %![plugin-]+l, author=\"%s\"",
BT_ASSERT(license);
g_string_assign(plugin->info.license, license);
plugin->info.license_set = BT_TRUE;
BT_ASSERT(license);
g_string_assign(plugin->info.license, license);
plugin->info.license_set = BT_TRUE;
- BT_LIB_LOGV("Set plugin's path: %![plugin-]+l, license=\"%s\"",
+ BT_LIB_LOGD("Set plugin's path: %![plugin-]+l, license=\"%s\"",
}
plugin->info.version_set = BT_TRUE;
}
plugin->info.version_set = BT_TRUE;
- BT_LIB_LOGV("Set plugin's version: %![plugin-]+l, "
+ BT_LIB_LOGD("Set plugin's version: %![plugin-]+l, "
"major=%u, minor=%u, patch=%u, extra=\"%s\"",
plugin, major, minor, patch, extra);
}
"major=%u, minor=%u, patch=%u, extra=\"%s\"",
plugin, major, minor, patch, extra);
}
BT_ASSERT(plugin);
bt_object_get_ref(plugin);
g_ptr_array_add(plugin_set->plugins, plugin);
BT_ASSERT(plugin);
bt_object_get_ref(plugin);
g_ptr_array_add(plugin_set->plugins, plugin);
- BT_LIB_LOGV("Added plugin to plugin set: "
+ BT_LIB_LOGD("Added plugin to plugin set: "
"plugin-set-addr=%p, %![plugin-]+l",
plugin_set, plugin);
}
"plugin-set-addr=%p, %![plugin-]+l",
plugin_set, plugin);
}
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
g_string_assign(clock_class->name.str, name);
clock_class->name.value = clock_class->name.str->str;
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
g_string_assign(clock_class->name.str, name);
clock_class->name.value = clock_class->name.str->str;
- BT_LIB_LOGV("Set clock class's name: %!+K", clock_class);
+ BT_LIB_LOGD("Set clock class's name: %!+K", clock_class);
return BT_CLOCK_CLASS_STATUS_OK;
}
return BT_CLOCK_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
g_string_assign(clock_class->description.str, descr);
clock_class->description.value = clock_class->description.str->str;
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
g_string_assign(clock_class->description.str, descr);
clock_class->description.value = clock_class->description.str->str;
- BT_LIB_LOGV("Set clock class's description: %!+K",
+ BT_LIB_LOGD("Set clock class's description: %!+K",
clock_class);
return BT_CLOCK_CLASS_STATUS_OK;
}
clock_class);
return BT_CLOCK_CLASS_STATUS_OK;
}
"%![cc-]+K, new-freq=%" PRIu64, clock_class, frequency);
clock_class->frequency = frequency;
set_base_offset(clock_class);
"%![cc-]+K, new-freq=%" PRIu64, clock_class, frequency);
clock_class->frequency = frequency;
set_base_offset(clock_class);
- BT_LIB_LOGV("Set clock class's frequency: %!+K", clock_class);
+ BT_LIB_LOGD("Set clock class's frequency: %!+K", clock_class);
}
uint64_t bt_clock_class_get_precision(const struct bt_clock_class *clock_class)
}
uint64_t bt_clock_class_get_precision(const struct bt_clock_class *clock_class)
"Invalid precision: %![cc-]+K, new-precision=%" PRIu64,
clock_class, precision);
clock_class->precision = precision;
"Invalid precision: %![cc-]+K, new-precision=%" PRIu64,
clock_class, precision);
clock_class->precision = precision;
- BT_LIB_LOGV("Set clock class's precision: %!+K", clock_class);
+ BT_LIB_LOGD("Set clock class's precision: %!+K", clock_class);
}
void bt_clock_class_get_offset(const struct bt_clock_class *clock_class,
}
void bt_clock_class_get_offset(const struct bt_clock_class *clock_class,
clock_class->offset_seconds = seconds;
clock_class->offset_cycles = cycles;
set_base_offset(clock_class);
clock_class->offset_seconds = seconds;
clock_class->offset_cycles = cycles;
set_base_offset(clock_class);
- BT_LIB_LOGV("Set clock class's offset: %!+K", clock_class);
+ BT_LIB_LOGD("Set clock class's offset: %!+K", clock_class);
}
bt_bool bt_clock_class_origin_is_unix_epoch(const struct bt_clock_class *clock_class)
}
bt_bool bt_clock_class_origin_is_unix_epoch(const struct bt_clock_class *clock_class)
BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
clock_class->origin_is_unix_epoch = (bool) origin_is_unix_epoch;
BT_ASSERT_PRE_NON_NULL(clock_class, "Clock class");
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
clock_class->origin_is_unix_epoch = (bool) origin_is_unix_epoch;
- BT_LIB_LOGV("Set clock class's origin is Unix epoch property: %!+K",
+ BT_LIB_LOGD("Set clock class's origin is Unix epoch property: %!+K",
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
memcpy(clock_class->uuid.uuid, uuid, BABELTRACE_UUID_LEN);
clock_class->uuid.value = clock_class->uuid.uuid;
BT_ASSERT_PRE_CLOCK_CLASS_HOT(clock_class);
memcpy(clock_class->uuid.uuid, uuid, BABELTRACE_UUID_LEN);
clock_class->uuid.value = clock_class->uuid.uuid;
- BT_LIB_LOGV("Set clock class's UUID: %!+K", clock_class);
+ BT_LIB_LOGD("Set clock class's UUID: %!+K", clock_class);
ret = bt_util_ns_from_origin_clock_class(clock_class, cycles, ns);
if (ret) {
ret = BT_CLOCK_CLASS_STATUS_OVERFLOW;
ret = bt_util_ns_from_origin_clock_class(clock_class, cycles, ns);
if (ret) {
ret = BT_CLOCK_CLASS_STATUS_OVERFLOW;
- BT_LIB_LOGW("Cannot convert cycles to nanoseconds "
+ BT_LIB_LOGD("Cannot convert cycles to nanoseconds "
"from origin for given clock class: "
"value overflows the signed 64-bit integer range: "
"%![cc-]+K, cycles=%" PRIu64,
"from origin for given clock class: "
"value overflows the signed 64-bit integer range: "
"%![cc-]+K, cycles=%" PRIu64,
BT_ASSERT_PRE_EVENT_CLASS_HOT(event_class);
g_string_assign(event_class->name.str, name);
event_class->name.value = event_class->name.str->str;
BT_ASSERT_PRE_EVENT_CLASS_HOT(event_class);
g_string_assign(event_class->name.str, name);
event_class->name.value = event_class->name.str->str;
- BT_LIB_LOGV("Set event class's name: %!+E", event_class);
+ BT_LIB_LOGD("Set event class's name: %!+E", event_class);
return BT_EVENT_CLASS_STATUS_OK;
}
return BT_EVENT_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_EVENT_CLASS_HOT(event_class);
bt_property_uint_set(&event_class->log_level,
(uint64_t) log_level);
BT_ASSERT_PRE_EVENT_CLASS_HOT(event_class);
bt_property_uint_set(&event_class->log_level,
(uint64_t) log_level);
- BT_LIB_LOGV("Set event class's log level: %!+E", event_class);
+ BT_LIB_LOGD("Set event class's log level: %!+E", event_class);
}
const char *bt_event_class_get_emf_uri(const struct bt_event_class *event_class)
}
const char *bt_event_class_get_emf_uri(const struct bt_event_class *event_class)
BT_ASSERT_PRE_EVENT_CLASS_HOT(event_class);
g_string_assign(event_class->emf_uri.str, emf_uri);
event_class->emf_uri.value = event_class->emf_uri.str->str;
BT_ASSERT_PRE_EVENT_CLASS_HOT(event_class);
g_string_assign(event_class->emf_uri.str, emf_uri);
event_class->emf_uri.value = event_class->emf_uri.str->str;
- BT_LIB_LOGV("Set event class's EMF URI: %!+E", event_class);
+ BT_LIB_LOGD("Set event class's EMF URI: %!+E", event_class);
return BT_EVENT_CLASS_STATUS_OK;
}
return BT_EVENT_CLASS_STATUS_OK;
}
event_class->specific_context_fc = field_class;
bt_object_get_no_null_check(event_class->specific_context_fc);
bt_field_class_freeze(field_class);
event_class->specific_context_fc = field_class;
bt_object_get_no_null_check(event_class->specific_context_fc);
bt_field_class_freeze(field_class);
- BT_LIB_LOGV("Set event class's specific context field class: %!+E",
+ BT_LIB_LOGD("Set event class's specific context field class: %!+E",
event_class->payload_fc = field_class;
bt_object_get_no_null_check(event_class->payload_fc);
bt_field_class_freeze(field_class);
event_class->payload_fc = field_class;
bt_object_get_no_null_check(event_class->payload_fc);
bt_field_class_freeze(field_class);
- BT_LIB_LOGV("Set event class's payload field class: %!+E", event_class);
+ BT_LIB_LOGD("Set event class's payload field class: %!+E", event_class);
BT_ASSERT(!event->packet);
event->packet = packet;
bt_object_get_no_null_check_no_parent_check(&event->packet->base);
BT_ASSERT(!event->packet);
event->packet = packet;
bt_object_get_no_null_check_no_parent_check(&event->packet->base);
- BT_LIB_LOGV("Set event's packet: %![event-]+e, %![packet-]+a",
+ BT_LIB_LOGD("Set event's packet: %![event-]+e, %![packet-]+a",
"at least one of the current mapping ranges contains values "
"which are outside this range: %!+F, size=%" PRIu64, fc, size);
int_fc->range = size;
"at least one of the current mapping ranges contains values "
"which are outside this range: %!+F, size=%" PRIu64, fc, size);
int_fc->range = size;
- BT_LIB_LOGV("Set integer field class's field value range: %!+F", fc);
+ BT_LIB_LOGD("Set integer field class's field value range: %!+F", fc);
}
enum bt_field_class_integer_preferred_display_base
}
enum bt_field_class_integer_preferred_display_base
BT_ASSERT_PRE_FC_IS_INT(fc, "Field class");
BT_ASSERT_PRE_FC_HOT(fc, "Field class");
int_fc->base = base;
BT_ASSERT_PRE_FC_IS_INT(fc, "Field class");
BT_ASSERT_PRE_FC_HOT(fc, "Field class");
int_fc->base = base;
- BT_LIB_LOGV("Set integer field class's preferred display base: %!+F", fc);
+ BT_LIB_LOGD("Set integer field class's preferred display base: %!+F", fc);
mapping->ranges->len - 1);
range->lower.u = lower;
range->upper.u = upper;
mapping->ranges->len - 1);
range->lower.u = lower;
range->upper.u = upper;
- BT_LIB_LOGV("Added mapping to enumeration field class: "
+ BT_LIB_LOGD("Added mapping to enumeration field class: "
"%![fc-]+F, label=\"%s\", lower-unsigned=%" PRIu64 ", "
"upper-unsigned=%" PRIu64, fc, label, lower, upper);
"%![fc-]+F, label=\"%s\", lower-unsigned=%" PRIu64 ", "
"upper-unsigned=%" PRIu64, fc, label, lower, upper);
BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_REAL, "Field class");
BT_ASSERT_PRE_FC_HOT(fc, "Field class");
real_fc->is_single_precision = (bool) is_single_precision;
BT_ASSERT_PRE_FC_HAS_ID(fc, BT_FIELD_CLASS_TYPE_REAL, "Field class");
BT_ASSERT_PRE_FC_HOT(fc, "Field class");
real_fc->is_single_precision = (bool) is_single_precision;
- BT_LIB_LOGV("Set real field class's \"is single precision\" property: "
+ BT_LIB_LOGD("Set real field class's \"is single precision\" property: "
BT_ASSERT_PRE_STREAM_CLASS_HOT(stream_class);
g_string_assign(stream_class->name.str, name);
stream_class->name.value = stream_class->name.str->str;
BT_ASSERT_PRE_STREAM_CLASS_HOT(stream_class);
g_string_assign(stream_class->name.str, name);
stream_class->name.value = stream_class->name.str->str;
- BT_LIB_LOGV("Set stream class's name: %!+S", stream_class);
+ BT_LIB_LOGD("Set stream class's name: %!+S", stream_class);
return BT_STREAM_CLASS_STATUS_OK;
}
return BT_STREAM_CLASS_STATUS_OK;
}
stream_class->packet_context_fc = field_class;
bt_object_get_no_null_check(stream_class->packet_context_fc);
bt_field_class_freeze(field_class);
stream_class->packet_context_fc = field_class;
bt_object_get_no_null_check(stream_class->packet_context_fc);
bt_field_class_freeze(field_class);
- BT_LIB_LOGV("Set stream class's packet context field class: %!+S",
+ BT_LIB_LOGD("Set stream class's packet context field class: %!+S",
stream_class->event_common_context_fc = field_class;
bt_object_get_no_null_check(stream_class->event_common_context_fc);
bt_field_class_freeze(field_class);
stream_class->event_common_context_fc = field_class;
bt_object_get_no_null_check(stream_class->event_common_context_fc);
bt_field_class_freeze(field_class);
- BT_LIB_LOGV("Set stream class's event common context field class: %!+S",
+ BT_LIB_LOGD("Set stream class's event common context field class: %!+S",
stream_class->default_clock_class = clock_class;
bt_object_get_no_null_check(stream_class->default_clock_class);
bt_clock_class_freeze(clock_class);
stream_class->default_clock_class = clock_class;
bt_object_get_no_null_check(stream_class->default_clock_class);
bt_clock_class_freeze(clock_class);
- BT_LIB_LOGV("Set stream class's default clock class: %!+S",
+ BT_LIB_LOGD("Set stream class's default clock class: %!+S",
stream_class);
return BT_STREAM_CLASS_STATUS_OK;
}
stream_class);
return BT_STREAM_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
BT_ASSERT_PRE_STREAM_CLASS_HOT(stream_class);
stream_class->assigns_automatic_event_class_id = (bool) value;
BT_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
BT_ASSERT_PRE_STREAM_CLASS_HOT(stream_class);
stream_class->assigns_automatic_event_class_id = (bool) value;
- BT_LIB_LOGV("Set stream class's automatic event class ID "
+ BT_LIB_LOGD("Set stream class's automatic event class ID "
"assignment property: %!+S", stream_class);
}
"assignment property: %!+S", stream_class);
}
"Stream class has no default clock class: %!+S", stream_class);
stream_class->packets_have_beginning_default_clock_snapshot =
(bool) value;
"Stream class has no default clock class: %!+S", stream_class);
stream_class->packets_have_beginning_default_clock_snapshot =
(bool) value;
- BT_LIB_LOGV("Set stream class's \"packets have default beginning "
+ BT_LIB_LOGD("Set stream class's \"packets have default beginning "
"clock snapshot\" property: %!+S", stream_class);
}
"clock snapshot\" property: %!+S", stream_class);
}
"Stream class has no default clock class: %!+S", stream_class);
stream_class->packets_have_end_default_clock_snapshot =
(bool) value;
"Stream class has no default clock class: %!+S", stream_class);
stream_class->packets_have_end_default_clock_snapshot =
(bool) value;
- BT_LIB_LOGV("Set stream class's \"packets have default end "
+ BT_LIB_LOGD("Set stream class's \"packets have default end "
"clock snapshot\" property: %!+S", stream_class);
}
"clock snapshot\" property: %!+S", stream_class);
}
(bool) supports_discarded_events;
stream_class->discarded_events_have_default_clock_snapshots =
(bool) with_default_clock_snapshots;
(bool) supports_discarded_events;
stream_class->discarded_events_have_default_clock_snapshots =
(bool) with_default_clock_snapshots;
- BT_LIB_LOGV("Set stream class's discarded events support property: "
+ BT_LIB_LOGD("Set stream class's discarded events support property: "
(bool) supports_discarded_packets;
stream_class->discarded_packets_have_default_clock_snapshots =
(bool) with_default_clock_snapshots;
(bool) supports_discarded_packets;
stream_class->discarded_packets_have_default_clock_snapshots =
(bool) with_default_clock_snapshots;
- BT_LIB_LOGV("Set stream class's discarded packets support property: "
+ BT_LIB_LOGD("Set stream class's discarded packets support property: "
BT_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
BT_ASSERT_PRE_STREAM_CLASS_HOT(stream_class);
stream_class->assigns_automatic_stream_id = (bool) value;
BT_ASSERT_PRE_NON_NULL(stream_class, "Stream class");
BT_ASSERT_PRE_STREAM_CLASS_HOT(stream_class);
stream_class->assigns_automatic_stream_id = (bool) value;
- BT_LIB_LOGV("Set stream class's automatic stream ID "
+ BT_LIB_LOGD("Set stream class's automatic stream ID "
"assignment property: %!+S", stream_class);
}
"assignment property: %!+S", stream_class);
}
BT_ASSERT_PRE_STREAM_HOT(stream);
g_string_assign(stream->name.str, name);
stream->name.value = stream->name.str->str;
BT_ASSERT_PRE_STREAM_HOT(stream);
g_string_assign(stream->name.str, name);
stream->name.value = stream->name.str->str;
- BT_LIB_LOGV("Set stream's name: %!+s", stream);
+ BT_LIB_LOGD("Set stream's name: %!+s", stream);
return BT_STREAM_STATUS_OK;
}
return BT_STREAM_STATUS_OK;
}
*/
if (tc->destruction_listeners) {
uint64_t i;
*/
if (tc->destruction_listeners) {
uint64_t i;
- BT_LIB_LOGV("Calling trace class destruction listener(s): %!+T", tc);
+ BT_LIB_LOGD("Calling trace class destruction listener(s): %!+T", tc);
/*
* The trace class' reference count is 0 if we're here. Increment
/*
* The trace class' reference count is 0 if we're here. Increment
BT_ASSERT_PRE_TRACE_CLASS_HOT(tc);
g_string_assign(tc->name.str, name);
tc->name.value = tc->name.str->str;
BT_ASSERT_PRE_TRACE_CLASS_HOT(tc);
g_string_assign(tc->name.str, name);
tc->name.value = tc->name.str->str;
- BT_LIB_LOGV("Set trace class's name: %!+T", tc);
+ BT_LIB_LOGD("Set trace class's name: %!+T", tc);
return BT_TRACE_CLASS_STATUS_OK;
}
return BT_TRACE_CLASS_STATUS_OK;
}
BT_ASSERT_PRE_TRACE_CLASS_HOT(tc);
memcpy(tc->uuid.uuid, uuid, BABELTRACE_UUID_LEN);
tc->uuid.value = tc->uuid.uuid;
BT_ASSERT_PRE_TRACE_CLASS_HOT(tc);
memcpy(tc->uuid.uuid, uuid, BABELTRACE_UUID_LEN);
tc->uuid.value = tc->uuid.uuid;
- BT_LIB_LOGV("Set trace class's UUID: %!+T", tc);
+ BT_LIB_LOGD("Set trace class's UUID: %!+T", tc);
}
enum bt_trace_class_status bt_trace_class_add_destruction_listener(
}
enum bt_trace_class_status bt_trace_class_add_destruction_listener(
- BT_LIB_LOGV("Added trace class destruction listener: %![tc-]+T, "
+ BT_LIB_LOGD("Added trace class destruction listener: %![tc-]+T, "
"listener-id=%" PRIu64, tc, i);
return BT_TRACE_CLASS_STATUS_OK;
}
"listener-id=%" PRIu64, tc, i);
return BT_TRACE_CLASS_STATUS_OK;
}
elem->func = NULL;
elem->data = NULL;
elem->func = NULL;
elem->data = NULL;
- BT_LIB_LOGV("Removed trace class destruction listener: "
+ BT_LIB_LOGD("Removed trace class destruction listener: "
"%![tc-]+T, listener-id=%" PRIu64,
tc, listener_id);
return BT_TRACE_CLASS_STATUS_OK;
"%![tc-]+T, listener-id=%" PRIu64,
tc, listener_id);
return BT_TRACE_CLASS_STATUS_OK;
"%![tc-]+T, entry-name=\"%s\"", tc, name);
} else {
bt_value_freeze(value);
"%![tc-]+T, entry-name=\"%s\"", tc, name);
} else {
bt_value_freeze(value);
- BT_LIB_LOGV("Set trace class's environment entry: "
+ BT_LIB_LOGD("Set trace class's environment entry: "
"%![tc-]+T, entry-name=\"%s\"", tc, name);
}
"%![tc-]+T, entry-name=\"%s\"", tc, name);
}
BT_ASSERT_PRE_NON_NULL(tc, "Trace class");
BT_ASSERT_PRE_TRACE_CLASS_HOT(tc);
tc->assigns_automatic_stream_class_id = (bool) value;
BT_ASSERT_PRE_NON_NULL(tc, "Trace class");
BT_ASSERT_PRE_TRACE_CLASS_HOT(tc);
tc->assigns_automatic_stream_class_id = (bool) value;
- BT_LIB_LOGV("Set trace class's automatic stream class ID "
+ BT_LIB_LOGD("Set trace class's automatic stream class ID "
"assignment property: %!+T", tc);
}
"assignment property: %!+T", tc);
}
*/
if (trace->destruction_listeners) {
uint64_t i;
*/
if (trace->destruction_listeners) {
uint64_t i;
- BT_LIB_LOGV("Calling trace destruction listener(s): %!+t", trace);
+ BT_LIB_LOGD("Calling trace destruction listener(s): %!+t", trace);
/*
* The trace's reference count is 0 if we're here. Increment
/*
* The trace's reference count is 0 if we're here. Increment
BT_ASSERT_PRE_TRACE_HOT(trace);
g_string_assign(trace->name.str, name);
trace->name.value = trace->name.str->str;
BT_ASSERT_PRE_TRACE_HOT(trace);
g_string_assign(trace->name.str, name);
trace->name.value = trace->name.str->str;
- BT_LIB_LOGV("Set trace's name: %!+t", trace);
+ BT_LIB_LOGD("Set trace's name: %!+t", trace);
return BT_TRACE_STATUS_OK;
}
return BT_TRACE_STATUS_OK;
}
- BT_LIB_LOGV("Added destruction listener: " "%![trace-]+t, "
+ BT_LIB_LOGD("Added destruction listener: " "%![trace-]+t, "
"listener-id=%" PRIu64, trace, i);
return BT_TRACE_STATUS_OK;
}
"listener-id=%" PRIu64, trace, i);
return BT_TRACE_STATUS_OK;
}
elem->func = NULL;
elem->data = NULL;
elem->func = NULL;
elem->data = NULL;
- BT_LIB_LOGV("Removed \"trace destruction listener: "
+ BT_LIB_LOGD("Removed \"trace destruction listener: "
"%![trace-]+t, listener-id=%" PRIu64,
trace, listener_id);
return BT_TRACE_STATUS_OK;
"%![trace-]+t, listener-id=%" PRIu64,
trace, listener_id);
return BT_TRACE_STATUS_OK;
- BT_LOGD_STR("Creating binary class reader (BFCR).");
+ BT_LOGD_STR("Creating binary field class reader (BFCR).");
bfcr = g_new0(struct bt_bfcr, 1);
if (!bfcr) {
BT_LOGE_STR("Failed to allocate one binary class reader.");
bfcr = g_new0(struct bt_bfcr, 1);
if (!bfcr) {
BT_LOGE_STR("Failed to allocate one binary class reader.");
- BT_LOGV("Pushing field class on context's stack: "
+ BT_LOGD("Pushing field class on context's stack: "
"fc-addr=%p, stack-size-before=%u", fc, stack->len);
frame->fc = fc;
g_ptr_array_add(stack, frame);
"fc-addr=%p, stack-size-before=%u", fc, stack->len);
frame->fc = fc;
g_ptr_array_add(stack, frame);
* This will call the frame's destructor and free it, as
* well as put its contained field class.
*/
* This will call the frame's destructor and free it, as
* well as put its contained field class.
*/
- BT_LOGV("Popping context's stack: stack-size-before=%u",
+ BT_LOGD("Popping context's stack: stack-size-before=%u",
stack->len);
g_ptr_array_set_size(stack, stack->len - 1);
}
stack->len);
g_ptr_array_set_size(stack, stack->len - 1);
}
if (strncmp(pathstr, absolute_path_prefixes[scope],
strlen(absolute_path_prefixes[scope]))) {
/* Prefix does not match: try the next one */
if (strncmp(pathstr, absolute_path_prefixes[scope],
strlen(absolute_path_prefixes[scope]))) {
/* Prefix does not match: try the next one */
- BT_LOGV("Prefix does not match: trying the next one: "
+ BT_LOGD("Prefix does not match: trying the next one: "
"path=\"%s\", path-prefix=\"%s\", scope=%s",
pathstr, absolute_path_prefixes[scope],
ctf_scope_string(scope));
"path=\"%s\", path-prefix=\"%s\", scope=%s",
pathstr, absolute_path_prefixes[scope],
ctf_scope_string(scope));
/* Found it! */
ret = scope;
/* Found it! */
ret = scope;
- BT_LOGV("Found root scope from absolute path: "
+ BT_LOGD("Found root scope from absolute path: "
"path=\"%s\", scope=%s", pathstr,
ctf_scope_string(scope));
goto end;
"path=\"%s\", scope=%s", pathstr,
ctf_scope_string(scope));
goto end;
struct ctf_field_class *child_fc;
const char *ft_name = ptoken_get_string(cur_ptoken);
struct ctf_field_class *child_fc;
const char *ft_name = ptoken_get_string(cur_ptoken);
- BT_LOGV("Current path token: token=\"%s\"", ft_name);
+ BT_LOGD("Current path token: token=\"%s\"", ft_name);
/* Find to which index corresponds the current path token */
if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY ||
/* Find to which index corresponds the current path token */
if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY ||
* Error: field name does not exist or
* wrong current class.
*/
* Error: field name does not exist or
* wrong current class.
*/
- BT_LOGV("Cannot get index of field class: "
+ BT_LOGD("Cannot get index of field class: "
"field-name=\"%s\", "
"src-index=%" PRId64 ", "
"child-index=%" PRId64 ", "
"field-name=\"%s\", "
"src-index=%" PRId64 ", "
"child-index=%" PRId64 ", "
goto end;
} else if (child_index > src_index &&
!first_level_done) {
goto end;
} else if (child_index > src_index &&
!first_level_done) {
- BT_LOGV("Child field class is located after source field class: "
+ BT_LOGD("Child field class is located after source field class: "
"field-name=\"%s\", "
"src-index=%" PRId64 ", "
"child-index=%" PRId64 ", "
"field-name=\"%s\", "
"src-index=%" PRId64 ", "
"child-index=%" PRId64 ", "
int64_t cur_index = field_class_stack_at(ctx->field_class_stack,
parent_pos_in_stack)->index;
int64_t cur_index = field_class_stack_at(ctx->field_class_stack,
parent_pos_in_stack)->index;
- BT_LOGV("Locating target field class from current parent field class: "
+ BT_LOGD("Locating target field class from current parent field class: "
"parent-pos=%" PRId64 ", parent-fc-addr=%p, "
"cur-index=%" PRId64,
parent_pos_in_stack, parent_class, cur_index);
"parent-pos=%" PRId64 ", parent-fc-addr=%p, "
"cur-index=%" PRId64,
parent_pos_in_stack, parent_class, cur_index);
parent_class, cur_index);
if (ret) {
/* Not found... yet */
parent_class, cur_index);
if (ret) {
/* Not found... yet */
- BT_LOGV_STR("Not found at this point.");
+ BT_LOGD_STR("Not found at this point.");
ctf_field_path_clear(&tail_field_path);
} else {
/* Found: stitch tail field path to head field path */
ctf_field_path_clear(&tail_field_path);
} else {
/* Found: stitch tail field path to head field path */
if (root_scope == -1) {
/* Relative path: start with current root scope */
field_path->root = ctx->root_scope;
if (root_scope == -1) {
/* Relative path: start with current root scope */
field_path->root = ctx->root_scope;
- BT_LOGV("Detected relative path: starting with current root scope: "
+ BT_LOGD("Detected relative path: starting with current root scope: "
"scope=%s", ctf_scope_string(field_path->root));
ret = relative_ptokens_to_field_path(ptokens, field_path, ctx);
if (ret) {
"scope=%s", ctf_scope_string(field_path->root));
ret = relative_ptokens_to_field_path(ptokens, field_path, ctx);
if (ret) {
} else {
/* Absolute path: use found root scope */
field_path->root = root_scope;
} else {
/* Absolute path: use found root scope */
field_path->root = root_scope;
- BT_LOGV("Detected absolute path: using root scope: "
+ BT_LOGD("Detected absolute path: using root scope: "
"scope=%s", ctf_scope_string(field_path->root));
ret = absolute_ptokens_to_field_path(ptokens, field_path, ctx);
if (ret) {
"scope=%s", ctf_scope_string(field_path->root));
ret = absolute_ptokens_to_field_path(ptokens, field_path, ctx);
if (ret) {
const char *field_path_pretty_str =
field_path_pretty ? field_path_pretty->str : NULL;
const char *field_path_pretty_str =
field_path_pretty ? field_path_pretty->str : NULL;
- BT_LOGV("Found field path: path=\"%s\", field-path=\"%s\"",
+ BT_LOGD("Found field path: path=\"%s\", field-path=\"%s\"",
pathstr, field_path_pretty_str);
if (field_path_pretty) {
pathstr, field_path_pretty_str);
if (field_path_pretty) {
const char *field_path2_pretty_str =
field_path2_pretty ? field_path2_pretty->str : NULL;
const char *field_path2_pretty_str =
field_path2_pretty ? field_path2_pretty->str : NULL;
- BT_LOGV("Finding lowest common ancestor (LCA) between two field paths: "
+ BT_LOGD("Finding lowest common ancestor (LCA) between two field paths: "
"field-path-1=\"%s\", field-path-2=\"%s\"",
field_path1_pretty_str, field_path2_pretty_str);
"field-path-1=\"%s\", field-path-2=\"%s\"",
field_path1_pretty_str, field_path2_pretty_str);
- BT_LOGV("Found LCA: lca-index=%" PRId64, lca_index);
+ BT_LOGD("Found LCA: lca-index=%" PRId64, lca_index);
- BT_LOGV("Resolving field class's child field class: "
+ BT_LOGD("Resolving field class's child field class: "
"parent-fc-addr=%p, child-fc-addr=%p, "
"index=%" PRIu64 ", count=%" PRIu64,
fc, child_fc, i, field_count);
"parent-fc-addr=%p, child-fc-addr=%p, "
"index=%" PRIu64 ", count=%" PRIu64,
fc, child_fc, i, field_count);
len = fread(&magic, sizeof(magic), 1, fp);
if (len != 1) {
len = fread(&magic, sizeof(magic), 1, fp);
if (len != 1) {
- BT_LOGD_STR("Cannot reade first metadata packet header: assuming the stream is not packetized.");
+ BT_LOGI_STR("Cannot read first metadata packet header: assuming the stream is not packetized.");
- BT_LOGV("Decoding metadata packet: mdec-addr=%p, offset=%ld",
+ BT_LOGD("Decoding metadata packet: mdec-addr=%p, offset=%ld",
mdec, offset);
readlen = fread(&header, sizeof(header), 1, in_fp);
if (feof(in_fp) != 0) {
mdec, offset);
readlen = fread(&header, sizeof(header), 1, in_fp);
if (feof(in_fp) != 0) {
- BT_LOGV("Reached end of file: offset=%ld", ftell(in_fp));
+ BT_LOGI("Reached end of file: offset=%ld", ftell(in_fp));
goto end;
}
if (readlen < 1) {
goto end;
}
if (readlen < 1) {
- BT_LOGV("Cannot decode metadata packet: offset=%ld", offset);
+ BT_LOGE("Cannot decode metadata packet: offset=%ld", offset);
BT_ASSERT(mdec);
if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo)) {
BT_ASSERT(mdec);
if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo)) {
- BT_LOGD("Metadata stream is packetized: mdec-addr=%p", mdec);
+ BT_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
mdec, fp, &buf, mdec->bo);
if (ret) {
ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
mdec, fp, &buf, mdec->bo);
if (ret) {
ssize_t nr_items;
const long init_pos = ftell(fp);
ssize_t nr_items;
const long init_pos = ftell(fp);
- BT_LOGD("Metadata stream is plain text: mdec-addr=%p", mdec);
+ BT_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
if (init_pos < 0) {
BT_LOGE_ERRNO("Failed to get current file position", ".");
if (init_pos < 0) {
BT_LOGE_ERRNO("Failed to get current file position", ".");
- BT_LOGD("Found metadata stream version in signature: version=%u.%u", major, minor);
+ BT_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
if (!is_version_valid(major, minor)) {
BT_LOGE("Invalid metadata version found in plain text signature: "
if (!is_version_valid(major, minor)) {
BT_LOGE("Invalid metadata version found in plain text signature: "
size_t buffer_sz = 0;
enum bt_msg_iter_medium_status m_status;
size_t buffer_sz = 0;
enum bt_msg_iter_medium_status m_status;
- BT_LOGV("Calling user function (request bytes): notit-addr=%p, "
+ BT_LOGD("Calling user function (request bytes): notit-addr=%p, "
"request-size=%zu", notit, notit->medium.max_request_sz);
m_status = notit->medium.medops.request_bytes(
notit->medium.max_request_sz, &buffer_addr,
&buffer_sz, notit->medium.data);
"request-size=%zu", notit, notit->medium.max_request_sz);
m_status = notit->medium.medops.request_bytes(
notit->medium.max_request_sz, &buffer_addr,
&buffer_sz, notit->medium.data);
- BT_LOGV("User function returned: status=%s, buf-addr=%p, buf-size=%zu",
+ BT_LOGD("User function returned: status=%s, buf-addr=%p, buf-size=%zu",
bt_msg_iter_medium_status_string(m_status),
buffer_addr, buffer_sz);
if (m_status == BT_MSG_ITER_MEDIUM_STATUS_OK) {
bt_msg_iter_medium_status_string(m_status),
buffer_addr, buffer_sz);
if (m_status == BT_MSG_ITER_MEDIUM_STATUS_OK) {
/* New medium buffer address */
notit->buf.addr = buffer_addr;
/* New medium buffer address */
notit->buf.addr = buffer_addr;
- BT_LOGV("User function returned new bytes: "
+ BT_LOGD("User function returned new bytes: "
"packet-offset=%zu, cur=%zu, size=%zu, addr=%p",
notit->buf.packet_offset, notit->buf.at,
notit->buf.sz, notit->buf.addr);
"packet-offset=%zu, cur=%zu, size=%zu, addr=%p",
notit->buf.packet_offset, notit->buf.at,
notit->buf.sz, notit->buf.addr);
- BT_LOGV_MEM(buffer_addr, buffer_sz, "Returned bytes at %p:",
+ BT_LOGD_MEM(buffer_addr, buffer_sz, "Returned bytes at %p:",
buffer_addr);
} else if (m_status == BT_MSG_ITER_MEDIUM_STATUS_EOF) {
/*
buffer_addr);
} else if (m_status == BT_MSG_ITER_MEDIUM_STATUS_EOF) {
/*
notit->cur_stream_class_id = -1;
notit->cur_event_class_id = -1;
notit->cur_data_stream_id = -1;
notit->cur_stream_class_id = -1;
notit->cur_event_class_id = -1;
notit->cur_data_stream_id = -1;
- BT_LOGV("Decoding packet header field:"
+ BT_LOGD("Decoding packet header field:"
"notit-addr=%p, trace-class-addr=%p, fc-addr=%p",
notit, notit->meta.tc, packet_header_fc);
ret = read_dscope_begin_state(notit, packet_header_fc,
"notit-addr=%p, trace-class-addr=%p, fc-addr=%p",
notit, notit->meta.tc, packet_header_fc);
ret = read_dscope_begin_state(notit, packet_header_fc,
notit->meta.sc = new_stream_class;
}
notit->meta.sc = new_stream_class;
}
- BT_LOGV("Set current stream class: "
+ BT_LOGD("Set current stream class: "
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64,
notit, notit->meta.sc, notit->meta.sc->id);
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64,
notit, notit->meta.sc, notit->meta.sc->id);
enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK;
bt_stream *stream = NULL;
enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK;
bt_stream *stream = NULL;
- BT_LOGV("Calling user function (get stream): notit-addr=%p, "
+ BT_LOGD("Calling user function (get stream): notit-addr=%p, "
"stream-class-addr=%p, stream-class-id=%" PRId64,
notit, notit->meta.sc,
notit->meta.sc->id);
"stream-class-addr=%p, stream-class-id=%" PRId64,
notit, notit->meta.sc,
notit->meta.sc->id);
notit->meta.sc->ir_sc, notit->cur_data_stream_id,
notit->medium.data);
bt_stream_get_ref(stream);
notit->meta.sc->ir_sc, notit->cur_data_stream_id,
notit->medium.data);
bt_stream_get_ref(stream);
- BT_LOGV("User function returned: stream-addr=%p", stream);
+ BT_LOGD("User function returned: stream-addr=%p", stream);
if (!stream) {
BT_LOGW_STR("User function failed to return a stream object "
"for the given stream class.");
if (!stream) {
BT_LOGW_STR("User function failed to return a stream object "
"for the given stream class.");
enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK;
bt_packet *packet = NULL;
enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK;
bt_packet *packet = NULL;
- BT_LOGV("Creating packet for packet message: "
+ BT_LOGD("Creating packet for packet message: "
- BT_LOGV("Creating packet from stream: "
+ BT_LOGD("Creating packet from stream: "
"notit-addr=%p, stream-addr=%p, "
"stream-class-addr=%p, "
"stream-class-id=%" PRId64,
"notit-addr=%p, stream-addr=%p, "
"stream-class-addr=%p, "
"stream-class-id=%" PRId64,
BT_ASSERT(notit->meta.sc);
packet_context_fc = notit->meta.sc->packet_context_fc;
if (!packet_context_fc) {
BT_ASSERT(notit->meta.sc);
packet_context_fc = notit->meta.sc->packet_context_fc;
if (!packet_context_fc) {
- BT_LOGV("No packet packet context field class in stream class: continuing: "
+ BT_LOGD("No packet packet context field class in stream class: continuing: "
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64,
notit, notit->meta.sc,
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64,
notit, notit->meta.sc,
BT_ASSERT(notit->dscopes.stream_packet_context);
}
BT_ASSERT(notit->dscopes.stream_packet_context);
}
- BT_LOGV("Decoding packet context field: "
+ BT_LOGD("Decoding packet context field: "
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64 ", fc-addr=%p",
notit, notit->meta.sc,
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64 ", fc-addr=%p",
notit, notit->meta.sc,
- BT_LOGV("Set current packet and content sizes: "
+ BT_LOGD("Set current packet and content sizes: "
"notit-addr=%p, packet-size=%" PRIu64 ", content-size=%" PRIu64,
notit, notit->cur_exp_packet_total_size,
notit->cur_exp_packet_content_size);
"notit-addr=%p, packet-size=%" PRIu64 ", content-size=%" PRIu64,
notit, notit->cur_exp_packet_total_size,
notit->cur_exp_packet_content_size);
if (G_UNLIKELY(packet_at(notit) ==
notit->cur_exp_packet_content_size)) {
/* No more events! */
if (G_UNLIKELY(packet_at(notit) ==
notit->cur_exp_packet_content_size)) {
/* No more events! */
- BT_LOGV("Reached end of packet: notit-addr=%p, "
+ BT_LOGD("Reached end of packet: notit-addr=%p, "
"cur=%zu", notit, packet_at(notit));
notit->state = STATE_EMIT_MSG_PACKET_END_MULTI;
goto end;
} else if (G_UNLIKELY(packet_at(notit) >
notit->cur_exp_packet_content_size)) {
/* That's not supposed to happen */
"cur=%zu", notit, packet_at(notit));
notit->state = STATE_EMIT_MSG_PACKET_END_MULTI;
goto end;
} else if (G_UNLIKELY(packet_at(notit) >
notit->cur_exp_packet_content_size)) {
/* That's not supposed to happen */
- BT_LOGV("Before decoding event header field: cursor is passed the packet's content: "
+ BT_LOGD("Before decoding event header field: cursor is passed the packet's content: "
"notit-addr=%p, content-size=%" PRId64 ", "
"cur=%zu", notit,
notit->cur_exp_packet_content_size,
"notit-addr=%p, content-size=%" PRId64 ", "
"cur=%zu", notit,
notit->cur_exp_packet_content_size,
- BT_LOGV("Decoding event header field: "
+ BT_LOGD("Decoding event header field: "
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64 ", "
"fc-addr=%p",
"notit-addr=%p, stream-class-addr=%p, "
"stream-class-id=%" PRId64 ", "
"fc-addr=%p",
}
notit->meta.ec = new_event_class;
}
notit->meta.ec = new_event_class;
- BT_LOGV("Set current event class: "
+ BT_LOGD("Set current event class: "
"notit-addr=%p, event-class-addr=%p, "
"event-class-id=%" PRId64 ", "
"event-class-name=\"%s\"",
"notit-addr=%p, event-class-addr=%p, "
"event-class-id=%" PRId64 ", "
"event-class-name=\"%s\"",
BT_ASSERT(notit->meta.ec);
BT_ASSERT(notit->packet);
BT_ASSERT(notit->meta.ec);
BT_ASSERT(notit->packet);
- BT_LOGV("Creating event message from event class and packet: "
+ BT_LOGD("Creating event message from event class and packet: "
"notit-addr=%p, ec-addr=%p, ec-name=\"%s\", packet-addr=%p",
notit, notit->meta.ec,
notit->meta.ec->name->str,
"notit-addr=%p, ec-addr=%p, ec-name=\"%s\", packet-addr=%p",
notit, notit->meta.ec,
notit->meta.ec->name->str,
} else {
size_t bits_to_consume;
} else {
size_t bits_to_consume;
- BT_LOGV("Trying to skip %zu bits of padding: notit-addr=%p, size=%zu",
+ BT_LOGD("Trying to skip %zu bits of padding: notit-addr=%p, size=%zu",
bits_to_skip, notit, bits_to_skip);
status = buf_ensure_available_bits(notit);
if (status != BT_MSG_ITER_STATUS_OK) {
bits_to_skip, notit, bits_to_skip);
status = buf_ensure_available_bits(notit);
if (status != BT_MSG_ITER_STATUS_OK) {
}
bits_to_consume = MIN(buf_available_bits(notit), bits_to_skip);
}
bits_to_consume = MIN(buf_available_bits(notit), bits_to_skip);
- BT_LOGV("Skipping %zu bits of padding: notit-addr=%p, size=%zu",
+ BT_LOGD("Skipping %zu bits of padding: notit-addr=%p, size=%zu",
bits_to_consume, notit, bits_to_consume);
buf_consume_bits(notit, bits_to_consume);
bits_to_skip = notit->cur_exp_packet_total_size -
bits_to_consume, notit, bits_to_consume);
buf_consume_bits(notit, bits_to_consume);
bits_to_skip = notit->cur_exp_packet_total_size -
case STATE_DONE:
break;
default:
case STATE_DONE:
break;
default:
- BT_LOGD("Unknown CTF plugin message iterator state: "
+ BT_LOGF("Unknown CTF plugin message iterator state: "
"notit-addr=%p, state=%d", notit, notit->state);
abort();
}
"notit-addr=%p, state=%d", notit, notit->state);
abort();
}
notit->cur_packet_offset += notit->cur_exp_packet_total_size;
}
notit->cur_packet_offset += notit->cur_exp_packet_total_size;
}
- BT_LOGV("Switching packet: notit-addr=%p, cur=%zu, "
+ BT_LOGD("Switching packet: notit-addr=%p, cur=%zu, "
"packet-offset=%" PRId64, notit, notit->buf.at,
notit->cur_packet_offset);
stack_clear(notit->stack);
"packet-offset=%" PRId64, notit, notit->buf.at,
notit->cur_packet_offset);
stack_clear(notit->stack);
notit->buf.sz -= consumed_bytes;
notit->buf.at = 0;
notit->buf.packet_offset = 0;
notit->buf.sz -= consumed_bytes;
notit->buf.at = 0;
notit->buf.packet_offset = 0;
- BT_LOGV("Adjusted buffer: addr=%p, size=%zu",
+ BT_LOGD("Adjusted buffer: addr=%p, size=%zu",
notit->buf.addr, notit->buf.sz);
}
notit->buf.addr, notit->buf.sz);
}
BT_ASSERT(message);
notit->msg_iter = msg_iter;
notit->set_stream = true;
BT_ASSERT(message);
notit->msg_iter = msg_iter;
notit->set_stream = true;
- BT_LOGV("Getting next message: notit-addr=%p", notit);
+ BT_LOGD("Getting next message: notit-addr=%p", notit);
while (true) {
status = handle_state(notit);
if (G_UNLIKELY(status == BT_MSG_ITER_STATUS_AGAIN)) {
while (true) {
status = handle_state(notit);
if (G_UNLIKELY(status == BT_MSG_ITER_STATUS_AGAIN)) {
- BT_LOGV_STR("Medium returned BT_MSG_ITER_STATUS_AGAIN.");
+ BT_LOGD_STR("Medium returned BT_MSG_ITER_STATUS_AGAIN.");
goto end;
} else if (G_UNLIKELY(status != BT_MSG_ITER_STATUS_OK)) {
BT_LOGW("Cannot handle state: notit-addr=%p, state=%s",
goto end;
} else if (G_UNLIKELY(status != BT_MSG_ITER_STATUS_OK)) {
BT_LOGW("Cannot handle state: notit-addr=%p, state=%s",
while (true) {
status = handle_state(notit);
if (G_UNLIKELY(status == BT_MSG_ITER_STATUS_AGAIN)) {
while (true) {
status = handle_state(notit);
if (G_UNLIKELY(status == BT_MSG_ITER_STATUS_AGAIN)) {
- BT_LOGV_STR("Medium returned BT_MSG_ITER_STATUS_AGAIN.");
+ BT_LOGD_STR("Medium returned BT_MSG_ITER_STATUS_AGAIN.");
goto end;
} else if (G_UNLIKELY(status != BT_MSG_ITER_STATUS_OK)) {
BT_LOGW("Cannot handle state: notit-addr=%p, state=%s",
goto end;
} else if (G_UNLIKELY(status != BT_MSG_ITER_STATUS_OK)) {
BT_LOGW("Cannot handle state: notit-addr=%p, state=%s",
* the format.
*/
if (!g_time_val_from_iso8601(datetime, &tv)) {
* the format.
*/
if (!g_time_val_from_iso8601(datetime, &tv)) {
- BT_LOGD("Couldn't parse datetime as iso8601: date=\"%s\"", datetime);
+ BT_LOGI("Couldn't parse datetime as ISO 8601: date=\"%s\"", datetime);
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_buffering_id");
if (!v || !bt_value_is_signed_integer(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_buffering_id");
if (!v || !bt_value_is_signed_integer(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_buffering_id\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_buffering_id\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "isa_length");
if (!v || !bt_value_is_signed_integer(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "isa_length");
if (!v || !bt_value_is_signed_integer(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"isa_length\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"isa_length\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "procname");
if (!v || !bt_value_is_string(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "procname");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"procname\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"procname\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "vpid");
if (!v || !bt_value_is_signed_integer(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "vpid");
if (!v || !bt_value_is_signed_integer(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"vpid\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"vpid\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "vpid_datetime");
if (!v || !bt_value_is_string(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "vpid_datetime");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"vpid_datetime\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"vpid_datetime\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_name");
if (!v || !bt_value_is_string(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_name");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_name\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_name\"");
if (!g_str_equal(tracer_name, "lttng-ust")
&& !g_str_equal(tracer_name, "lttng-modules")) {
if (!g_str_equal(tracer_name, "lttng-ust")
&& !g_str_equal(tracer_name, "lttng-modules")) {
- BT_LOGD("Unrecognized tracer name: name=\"%s\"", tracer_name);
+ BT_LOGI("Unrecognized tracer name: name=\"%s\"", tracer_name);
goto error;
}
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_major");
if (!v || !bt_value_is_signed_integer(v)) {
goto error;
}
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_major");
if (!v || !bt_value_is_signed_integer(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_major\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_major\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_minor");
if (!v || !bt_value_is_signed_integer(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_minor");
if (!v || !bt_value_is_signed_integer(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_minor\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_minor\"");
goto error;
}
tracer_minor = bt_value_signed_integer_get(v);
if (!(tracer_major >= 3 || (tracer_major == 2 && tracer_minor >= 11))) {
goto error;
}
tracer_minor = bt_value_signed_integer_get(v);
if (!(tracer_major >= 3 || (tracer_major == 2 && tracer_minor >= 11))) {
- BT_LOGD("Unsupported LTTng version for automatic trace path: major=%" PRId64 ", minor=%" PRId64,
+ BT_LOGI("Unsupported LTTng version for automatic trace path: major=%" PRId64 ", minor=%" PRId64,
tracer_major, tracer_minor);
goto error;
}
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "hostname");
if (!v || !bt_value_is_string(v)) {
tracer_major, tracer_minor);
goto error;
}
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "hostname");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_hostname\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_hostname\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "trace_name");
if (!v || !bt_value_is_string(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "trace_name");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"trace_name\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"trace_name\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "trace_creation_datetime");
if (!v || !bt_value_is_string(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "trace_creation_datetime");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"trace_creation_datetime\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"trace_creation_datetime\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "domain");
if (!v || !bt_value_is_string(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "domain");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"domain\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"domain\"");
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_buffering_scheme");
if (!v || !bt_value_is_string(v)) {
v = bt_trace_class_borrow_environment_entry_value_by_name_const(tc, "tracer_buffering_scheme");
if (!v || !bt_value_is_string(v)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_buffering_scheme\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_buffering_scheme\"");
}
} else {
/* Unknown buffering scheme. */
}
} else {
/* Unknown buffering scheme. */
- BT_LOGD("Unknown buffering scheme: tracer_buffering_scheme=\"%s\"", tracer_buffering_scheme);
+ BT_LOGI("Unknown buffering scheme: tracer_buffering_scheme=\"%s\"", tracer_buffering_scheme);
goto error;
}
} else if (!g_str_equal(domain, "kernel")) {
/* Unknown domain. */
goto error;
}
} else if (!g_str_equal(domain, "kernel")) {
/* Unknown domain. */
- BT_LOGD("Unknown domain: domain=\"%s\"", domain);
+ BT_LOGI("Unknown domain: domain=\"%s\"", domain);
struct ctf_stream_class *sc;
struct bt_msg_iter_packet_properties props;
struct ctf_stream_class *sc;
struct bt_msg_iter_packet_properties props;
- BT_LOGD("Building index from .idx file of stream file %s",
+ BT_LOGI("Building index from .idx file of stream file %s",
ds_file->file->path->str);
ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
if (ret) {
ds_file->file->path->str);
ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
if (ret) {
- BT_LOGD_STR("Cannot read first packet's header and context fields.");
+ BT_LOGI_STR("Cannot read first packet's header and context fields.");
props.stream_class_id);
BT_ASSERT(sc);
if (!sc->default_clock_class) {
props.stream_class_id);
BT_ASSERT(sc);
if (!sc->default_clock_class) {
- BT_LOGD_STR("Cannot find stream class's default clock class.");
+ BT_LOGI_STR("Cannot find stream class's default clock class.");
index_entry->timestamp_begin,
&index_entry->timestamp_begin_ns);
if (ret) {
index_entry->timestamp_begin,
&index_entry->timestamp_begin_ns);
if (ret) {
- BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch during index parsing");
+ BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during index parsing");
goto error;
}
ret = convert_cycles_to_ns(sc->default_clock_class,
index_entry->timestamp_end,
&index_entry->timestamp_end_ns);
if (ret) {
goto error;
}
ret = convert_cycles_to_ns(sc->default_clock_class,
index_entry->timestamp_end,
&index_entry->timestamp_end_ns);
if (ret) {
- BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing");
+ BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing");
props->snapshots.beginning_clock,
&entry->timestamp_begin_ns);
if (ret) {
props->snapshots.beginning_clock,
&entry->timestamp_begin_ns);
if (ret) {
- BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
+ BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
props->snapshots.end_clock,
&entry->timestamp_end_ns);
if (ret) {
props->snapshots.end_clock,
&entry->timestamp_end_ns);
if (ret) {
- BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
+ BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK;
off_t current_packet_offset_bytes = 0;
enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK;
off_t current_packet_offset_bytes = 0;
- BT_LOGD("Indexing stream file %s", ds_file->file->path->str);
+ BT_LOGI("Indexing stream file %s", ds_file->file->path->str);
index = ctf_fs_ds_index_create();
if (!index) {
index = ctf_fs_ds_index_create();
if (!index) {
- BT_LOGD("Failed to build index from .index file; "
+ BT_LOGI("Failed to build index from .index file; "
"falling back to stream indexing.");
index = build_index_from_stream_file(ds_file);
end:
"falling back to stream indexing.");
index = build_index_from_stream_file(ds_file);
end:
int ret = 0;
struct stat stat;
int ret = 0;
struct stat stat;
- BT_LOGD("Opening file \"%s\" with mode \"%s\"", file->path->str, mode);
+ BT_LOGI("Opening file \"%s\" with mode \"%s\"", file->path->str, mode);
file->fp = fopen(file->path->str, mode);
if (!file->fp) {
BT_LOGE("Cannot open file \"%s\" with mode \"%s\": %s",
file->fp = fopen(file->path->str, mode);
if (!file->fp) {
BT_LOGE("Cannot open file \"%s\" with mode \"%s\": %s",
- BT_LOGD("Opened file: %p", file->fp);
+ BT_LOGI("Opened file: %p", file->fp);
if (fstat(fileno(file->fp), &stat)) {
BT_LOGE("Cannot get file information: %s", strerror(errno));
if (fstat(fileno(file->fp), &stat)) {
BT_LOGE("Cannot get file information: %s", strerror(errno));
}
file->size = stat.st_size;
}
file->size = stat.st_size;
- BT_LOGD("File is %jd bytes", (intmax_t) file->size);
+ BT_LOGI("File is %jd bytes", (intmax_t) file->size);
- BT_LOGD("Creating one port named `%s`", port_name);
+ BT_LOGI("Creating one port named `%s`", port_name);
/* Create output port for this file */
port_data = g_new0(struct ctf_fs_port_data, 1);
/* Create output port for this file */
port_data = g_new0(struct ctf_fs_port_data, 1);
if (!strcmp(basename, CTF_FS_METADATA_FILENAME)) {
/* Ignore the metadata stream. */
if (!strcmp(basename, CTF_FS_METADATA_FILENAME)) {
/* Ignore the metadata stream. */
- BT_LOGD("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`",
+ BT_LOGI("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`",
ctf_fs_trace->path->str, basename);
continue;
}
if (basename[0] == '.') {
ctf_fs_trace->path->str, basename);
continue;
}
if (basename[0] == '.') {
- BT_LOGD("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`",
+ BT_LOGI("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`",
ctf_fs_trace->path->str, basename);
continue;
}
ctf_fs_trace->path->str, basename);
continue;
}
g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s",
ctf_fs_trace->path->str, basename);
if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s",
ctf_fs_trace->path->str, basename);
if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
- BT_LOGD("Ignoring non-regular file `%s`",
+ BT_LOGI("Ignoring non-regular file `%s`",
file->path->str);
ctf_fs_file_destroy(file);
file = NULL;
file->path->str);
ctf_fs_file_destroy(file);
file = NULL;
if (file->size == 0) {
/* Skip empty stream. */
if (file->size == 0) {
/* Skip empty stream. */
- BT_LOGD("Ignoring empty file `%s`", file->path->str);
+ BT_LOGI("Ignoring empty file `%s`", file->path->str);
ctf_fs_file_destroy(file);
continue;
}
ctf_fs_file_destroy(file);
continue;
}
dir = g_dir_open(start_path, 0, &error);
if (!dir) {
if (error->code == G_FILE_ERROR_ACCES) {
dir = g_dir_open(start_path, 0, &error);
if (!dir) {
if (error->code == G_FILE_ERROR_ACCES) {
- BT_LOGD("Cannot open directory `%s`: %s (code %d): continuing",
+ BT_LOGI("Cannot open directory `%s`: %s (code %d): continuing",
start_path, error->message, error->code);
goto end;
}
start_path, error->message, error->code);
goto end;
}
if (!lttng_live_stream->stream) {
uint64_t stream_class_id = bt_stream_class_get_id(stream_class);
if (!lttng_live_stream->stream) {
uint64_t stream_class_id = bt_stream_class_get_id(stream_class);
- BT_LOGD("Creating stream %s (ID: %" PRIu64 ") out of stream "
+ BT_LOGI("Creating stream %s (ID: %" PRIu64 ") out of stream "
"class %" PRId64, lttng_live_stream->name->str,
stream_id, stream_class_id);
"class %" PRId64, lttng_live_stream->name->str,
stream_id, stream_class_id);
BT_ASSERT(msg);
BT_ASSERT(ts_ns);
BT_ASSERT(msg);
BT_ASSERT(ts_ns);
- BT_LOGV("Getting message's timestamp: iter-data-addr=%p, msg-addr=%p, "
+ BT_LOGD("Getting message's timestamp: iter-data-addr=%p, msg-addr=%p, "
"last-msg-ts=%" PRId64, lttng_live_msg_iter, msg,
last_msg_ts_ns);
"last-msg-ts=%" PRId64, lttng_live_msg_iter, msg,
last_msg_ts_ns);
break;
default:
/* All the other messages have a higher priority */
break;
default:
/* All the other messages have a higher priority */
- BT_LOGV_STR("Message has no timestamp: using the last message timestamp.");
+ BT_LOGD_STR("Message has no timestamp: using the last message timestamp.");
*ts_ns = last_msg_ts_ns;
goto end;
}
*ts_ns = last_msg_ts_ns;
goto end;
}
goto end;
no_clock_snapshot:
goto end;
no_clock_snapshot:
- BT_LOGV_STR("Message's default clock snapshot is missing: "
+ BT_LOGD_STR("Message's default clock snapshot is missing: "
"using the last message timestamp.");
*ts_ns = last_msg_ts_ns;
goto end;
"using the last message timestamp.");
*ts_ns = last_msg_ts_ns;
goto end;
- BT_LOGV("Found message's timestamp: "
+ BT_LOGD("Found message's timestamp: "
"iter-data-addr=%p, msg-addr=%p, "
"last-msg-ts=%" PRId64 ", ts=%" PRId64,
lttng_live_msg_iter, msg, last_msg_ts_ns, *ts_ns);
"iter-data-addr=%p, msg-addr=%p, "
"last-msg-ts=%" PRId64 ", ts=%" PRId64,
lttng_live_msg_iter, msg, last_msg_ts_ns, *ts_ns);
lttng_live_url_parts.session_name = NULL;
}
lttng_live_url_parts.session_name = NULL;
}
- BT_LOGD("Connecting to hostname : %s, port : %d, "
+ BT_LOGI("Connecting to hostname : %s, port : %d, "
"target hostname : %s, session name : %s, "
"proto : %s",
viewer_connection->relay_hostname->str,
"target hostname : %s, session name : %s, "
"proto : %s",
viewer_connection->relay_hostname->str,
}
BT_ASSERT(ret_len == sizeof(connect));
}
BT_ASSERT(ret_len == sizeof(connect));
- BT_LOGD("Received viewer session ID : %" PRIu64,
+ BT_LOGI("Received viewer session ID : %" PRIu64,
(uint64_t) be64toh(connect.viewer_session_id));
(uint64_t) be64toh(connect.viewer_session_id));
- BT_LOGD("Relayd version : %u.%u", be32toh(connect.major),
+ BT_LOGI("Relayd version : %u.%u", be32toh(connect.major),
be32toh(connect.minor));
if (LTTNG_LIVE_MAJOR != be32toh(connect.major)) {
be32toh(connect.minor));
if (LTTNG_LIVE_MAJOR != be32toh(connect.major)) {
lsession.session_name[LTTNG_VIEWER_NAME_MAX - 1] = '\0';
session_id = be64toh(lsession.id);
lsession.session_name[LTTNG_VIEWER_NAME_MAX - 1] = '\0';
session_id = be64toh(lsession.id);
- BT_LOGD("Adding session %" PRIu64 " hostname: %s session_name: %s",
+ BT_LOGI("Adding session %" PRIu64 " hostname: %s session_name: %s",
session_id, lsession.hostname, lsession.session_name);
if ((strncmp(lsession.session_name,
session_id, lsession.hostname, lsession.session_name);
if ((strncmp(lsession.session_name,
struct live_viewer_connection *viewer_connection =
lttng_live_msg_iter->viewer_connection;
struct live_viewer_connection *viewer_connection =
lttng_live_msg_iter->viewer_connection;
- BT_LOGD("Getting %" PRIu32 " new streams:", stream_count);
+ BT_LOGI("Getting %" PRIu32 " new streams:", stream_count);
for (i = 0; i < stream_count; i++) {
struct lttng_viewer_stream stream;
struct lttng_live_stream_iterator *live_stream;
for (i = 0; i < stream_count; i++) {
struct lttng_viewer_stream stream;
struct lttng_live_stream_iterator *live_stream;
ctf_trace_id = be64toh(stream.ctf_trace_id);
if (stream.metadata_flag) {
ctf_trace_id = be64toh(stream.ctf_trace_id);
if (stream.metadata_flag) {
- BT_LOGD(" metadata stream %" PRIu64 " : %s/%s",
+ BT_LOGI(" metadata stream %" PRIu64 " : %s/%s",
stream_id, stream.path_name,
stream.channel_name);
if (lttng_live_metadata_create_stream(session,
stream_id, stream.path_name,
stream.channel_name);
if (lttng_live_metadata_create_stream(session,
}
session->lazy_stream_msg_init = true;
} else {
}
session->lazy_stream_msg_init = true;
} else {
- BT_LOGD(" stream %" PRIu64 " : %s/%s",
+ BT_LOGI(" stream %" PRIu64 " : %s/%s",
stream_id, stream.path_name,
stream.channel_name);
live_stream = lttng_live_stream_iterator_create(session,
stream_id, stream.path_name,
stream.channel_name);
live_stream = lttng_live_stream_iterator_create(session,
- BT_LOGD("Establishing connection to url \"%s\"...", url);
+ BT_LOGI("Establishing connection to url \"%s\"...", url);
if (lttng_live_connect_viewer(viewer_connection)) {
goto error_report;
}
if (lttng_live_connect_viewer(viewer_connection)) {
goto error_report;
}
- BT_LOGD("Connection to url \"%s\" is established", url);
+ BT_LOGI("Connection to url \"%s\" is established", url);
return viewer_connection;
error_report:
return viewer_connection;
error_report:
void live_viewer_connection_destroy(
struct live_viewer_connection *viewer_connection)
{
void live_viewer_connection_destroy(
struct live_viewer_connection *viewer_connection)
{
- BT_LOGD("Closing connection to url \"%s\"", viewer_connection->url->str);
+ BT_LOGI("Closing connection to url \"%s\"", viewer_connection->url->str);
lttng_live_disconnect_viewer(viewer_connection);
g_string_free(viewer_connection->url, true);
if (viewer_connection->relay_hostname) {
lttng_live_disconnect_viewer(viewer_connection);
g_string_free(viewer_connection->url, true);
if (viewer_connection->relay_hostname) {
int ret = 0;
if (elf_version(EV_CURRENT) == EV_NONE) {
int ret = 0;
if (elf_version(EV_CURRENT) == EV_NONE) {
- BT_LOGD("ELF library initialization failed: %s.",
+ BT_LOGI("ELF library initialization failed: %s.",
elf_errmsg(-1));
ret = -1;
}
elf_errmsg(-1));
ret = -1;
}
elf_handle = bt_fd_cache_get_handle(bin->fd_cache, bin->elf_path);
if (!elf_handle) {
elf_handle = bt_fd_cache_get_handle(bin->fd_cache, bin->elf_path);
if (!elf_handle) {
- BT_LOGD("Failed to open %s", bin->elf_path);
+ BT_LOGI("Failed to open %s", bin->elf_path);
goto error;
}
bin->elf_handle = elf_handle;
goto error;
}
bin->elf_handle = elf_handle;
*/
bin->file_build_id_matches = is_build_id_matching(bin);
if (!bin->file_build_id_matches) {
*/
bin->file_build_id_matches = is_build_id_matching(bin);
if (!bin->file_build_id_matches) {
- BT_LOGD_STR("Supplied Build ID does not match Build ID of the "
+ BT_LOGI_STR("Supplied Build ID does not match Build ID of the "
"binary or library found on the file system.");
goto error;
}
"binary or library found on the file system.");
goto error;
}
if (!bin->dwarf_info && !bin->is_elf_only) {
ret = bin_info_set_dwarf_info(bin);
if (ret) {
if (!bin->dwarf_info && !bin->is_elf_only) {
ret = bin_info_set_dwarf_info(bin);
if (ret) {
- BT_LOGD_STR("Failed to set bin dwarf info, falling "
+ BT_LOGI_STR("Failed to set bin dwarf info, falling "
"back to ELF lookup.");
/* Failed to set DWARF info, fallback to ELF. */
bin->is_elf_only = true;
"back to ELF lookup.");
/* Failed to set DWARF info, fallback to ELF. */
bin->is_elf_only = true;
ret = bin_info_lookup_elf_function_name(bin, addr,
&_func_name);
if (ret) {
ret = bin_info_lookup_elf_function_name(bin, addr,
&_func_name);
if (ret) {
- BT_LOGD("Failed to lookup function name (ELF): "
+ BT_LOGI("Failed to lookup function name (ELF): "
"ret=%d", ret);
}
} else {
ret = bin_info_lookup_dwarf_function_name(bin, addr,
&_func_name);
if (ret) {
"ret=%d", ret);
}
} else {
ret = bin_info_lookup_dwarf_function_name(bin, addr,
&_func_name);
if (ret) {
- BT_LOGD("Failed to lookup function name (DWARF): "
+ BT_LOGI("Failed to lookup function name (DWARF): "
/* Lookup source location */
ret = bin_info_lookup_source_location(bin, ip, &src_loc);
if (ret) {
/* Lookup source location */
ret = bin_info_lookup_source_location(bin, ip, &src_loc);
if (ret) {
- BT_LOGD("Failed to lookup source location: ret=%d", ret);
+ BT_LOGI("Failed to lookup source location: ret=%d", ret);
debug_info_src->line_no =
g_strdup_printf("%"PRId64, src_loc->line_no);
if (!debug_info_src->line_no) {
debug_info_src->line_no =
g_strdup_printf("%"PRId64, src_loc->line_no);
if (!debug_info_src->line_no) {
- BT_LOGD("Error occured when setting line_no field.");
+ BT_LOGE("Error occured when setting line_no field.");
status = bt_trace_remove_destruction_listener(debug_info->input_trace,
debug_info->destruction_listener_id);
if (status != BT_TRACE_STATUS_OK) {
status = bt_trace_remove_destruction_listener(debug_info->input_trace,
debug_info->destruction_listener_id);
if (status != BT_TRACE_STATUS_OK) {
- BT_LOGD("Trace destruction listener removal failed.");
+ BT_LOGE("Trace destruction listener removal failed.");
struct debug_info_component *debug_info_comp;
bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
struct debug_info_component *debug_info_comp;
bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
- BT_LOGD("Initializing debug_info component: "
+ BT_LOGI("Initializing debug_info component: "
"comp-addr=%p, params-addr=%p", self_comp, params);
debug_info_comp = g_new0(struct debug_info_component, 1);
"comp-addr=%p, params-addr=%p", self_comp, params);
debug_info_comp = g_new0(struct debug_info_component, 1);
bt_self_component_get_data(
bt_self_component_filter_as_self_component(
self_comp));
bt_self_component_get_data(
bt_self_component_filter_as_self_component(
self_comp));
- BT_LOGD("Finalizing debug_info self_component: comp-addr=%p",
+ BT_LOGI("Finalizing debug_info self_component: comp-addr=%p",
self_comp);
destroy_debug_info_comp(debug_info);
self_comp);
destroy_debug_info_comp(debug_info);
out_fc_type = bt_field_get_class_type(out_field);
BT_ASSERT(in_fc_type == out_fc_type);
out_fc_type = bt_field_get_class_type(out_field);
BT_ASSERT(in_fc_type == out_fc_type);
- BT_LOGD("Copying content of field: in-f-addr=%p, out-f-addr=%p",
+ BT_LOGV("Copying content of field: in-f-addr=%p, out-f-addr=%p",
in_field, out_field);
switch (in_fc_type) {
case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
in_field, out_field);
switch (in_fc_type) {
case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
- BT_LOGD("Copied content of field: in-f-addr=%p, out-f-addr=%p",
+ BT_LOGV("Copied content of field: in-f-addr=%p, out-f-addr=%p",
muxer_comp->available_input_ports++;
muxer_comp->next_port_num++;
muxer_comp->available_input_ports++;
muxer_comp->next_port_num++;
- BT_LOGD("Added one input port to muxer component: "
+ BT_LOGI("Added one input port to muxer component: "
"port-name=\"%s\", comp-addr=%p",
port_name->str, self_comp);
"port-name=\"%s\", comp-addr=%p",
port_name->str, self_comp);
bool_val = bt_value_bool_get(assume_absolute_clock_classes);
muxer_comp->assume_absolute_clock_classes = (bool) bool_val;
bool_val = bt_value_bool_get(assume_absolute_clock_classes);
muxer_comp->assume_absolute_clock_classes = (bool) bool_val;
- BT_LOGD("Configured muxer component: muxer-comp-addr=%p, "
+ BT_LOGI("Configured muxer component: muxer-comp-addr=%p, "
"assume-absolute-clock-classes=%d",
muxer_comp, muxer_comp->assume_absolute_clock_classes);
goto end;
"assume-absolute-clock-classes=%d",
muxer_comp, muxer_comp->assume_absolute_clock_classes);
goto end;
bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
struct muxer_comp *muxer_comp = g_new0(struct muxer_comp, 1);
bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
struct muxer_comp *muxer_comp = g_new0(struct muxer_comp, 1);
- BT_LOGD("Initializing muxer component: "
+ BT_LOGI("Initializing muxer component: "
"comp-addr=%p, params-addr=%p", self_comp, params);
if (!muxer_comp) {
"comp-addr=%p, params-addr=%p", self_comp, params);
if (!muxer_comp) {
- BT_LOGD("Initialized muxer component: "
+ BT_LOGI("Initialized muxer component: "
"comp-addr=%p, params-addr=%p, muxer-comp-addr=%p",
self_comp, params, muxer_comp);
"comp-addr=%p, params-addr=%p, muxer-comp-addr=%p",
self_comp, params, muxer_comp);
struct muxer_comp *muxer_comp = bt_self_component_get_data(
bt_self_component_filter_as_self_component(self_comp));
struct muxer_comp *muxer_comp = bt_self_component_get_data(
bt_self_component_filter_as_self_component(self_comp));
- BT_LOGD("Finalizing muxer component: comp-addr=%p",
+ BT_LOGI("Finalizing muxer component: comp-addr=%p",
self_comp);
destroy_muxer_comp(muxer_comp);
}
self_comp);
destroy_muxer_comp(muxer_comp);
}
- BT_LOGD("Created upstream message iterator on input port: "
+ BT_LOGI("Created upstream message iterator on input port: "
"port-addr=%p, port-name=\"%s\", msg-iter-addr=%p",
port, bt_port_get_name(port), msg_iter);
"port-addr=%p, port-name=\"%s\", msg-iter-addr=%p",
port, bt_port_get_name(port), msg_iter);
uint64_t i;
uint64_t count;
uint64_t i;
uint64_t count;
- BT_LOGV("Calling upstream message iterator's \"next\" method: "
+ BT_LOGD("Calling upstream message iterator's \"next\" method: "
"muxer-upstream-msg-iter-wrap-addr=%p, msg-iter-addr=%p",
muxer_upstream_msg_iter,
muxer_upstream_msg_iter->msg_iter);
input_port_iter_status = bt_self_component_port_input_message_iterator_next(
muxer_upstream_msg_iter->msg_iter, &msgs, &count);
"muxer-upstream-msg-iter-wrap-addr=%p, msg-iter-addr=%p",
muxer_upstream_msg_iter,
muxer_upstream_msg_iter->msg_iter);
input_port_iter_status = bt_self_component_port_input_message_iterator_next(
muxer_upstream_msg_iter->msg_iter, &msgs, &count);
- BT_LOGV("Upstream message iterator's \"next\" method returned: "
+ BT_LOGD("Upstream message iterator's \"next\" method returned: "
"status=%s", bt_message_iterator_status_string(input_port_iter_status));
switch (input_port_iter_status) {
"status=%s", bt_message_iterator_status_string(input_port_iter_status));
switch (input_port_iter_status) {
* Message iterator's current message is
* valid: it must be considered for muxing operations.
*/
* Message iterator's current message is
* valid: it must be considered for muxing operations.
*/
- BT_LOGV_STR("Validated upstream message iterator wrapper.");
+ BT_LOGD_STR("Validated upstream message iterator wrapper.");
BT_ASSERT(count > 0);
/* Move messages to our queue */
BT_ASSERT(count > 0);
/* Move messages to our queue */
BT_ASSERT(msg);
BT_ASSERT(ts_ns);
BT_ASSERT(msg);
BT_ASSERT(ts_ns);
- BT_LOGV("Getting message's timestamp: "
+ BT_LOGD("Getting message's timestamp: "
"muxer-msg-iter-addr=%p, msg-addr=%p, "
"last-returned-ts=%" PRId64,
muxer_msg_iter, msg, last_returned_ts_ns);
"muxer-msg-iter-addr=%p, msg-addr=%p, "
"last-returned-ts=%" PRId64,
muxer_msg_iter, msg, last_returned_ts_ns);
break;
default:
/* All the other messages have a higher priority */
break;
default:
/* All the other messages have a higher priority */
- BT_LOGV_STR("Message has no timestamp: using the last returned timestamp.");
+ BT_LOGD_STR("Message has no timestamp: using the last returned timestamp.");
*ts_ns = last_returned_ts_ns;
goto end;
}
*ts_ns = last_returned_ts_ns;
goto end;
}
goto end;
no_clock_snapshot:
goto end;
no_clock_snapshot:
- BT_LOGV_STR("Message's default clock snapshot is missing: "
+ BT_LOGD_STR("Message's default clock snapshot is missing: "
"using the last returned timestamp.");
*ts_ns = last_returned_ts_ns;
goto end;
"using the last returned timestamp.");
*ts_ns = last_returned_ts_ns;
goto end;
- BT_LOGV("Found message's timestamp: "
+ BT_LOGD("Found message's timestamp: "
"muxer-msg-iter-addr=%p, msg-addr=%p, "
"last-returned-ts=%" PRId64 ", ts=%" PRId64,
muxer_msg_iter, msg, last_returned_ts_ns,
"muxer-msg-iter-addr=%p, msg-addr=%p, "
"last-returned-ts=%" PRId64 ", ts=%" PRId64,
muxer_msg_iter, msg, last_returned_ts_ns,
bt_self_message_iterator_status status =
BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
bt_self_message_iterator_status status =
BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
- BT_LOGV("Validating muxer's upstream message iterator wrapper: "
+ BT_LOGD("Validating muxer's upstream message iterator wrapper: "
"muxer-upstream-msg-iter-wrap-addr=%p",
muxer_upstream_msg_iter);
if (muxer_upstream_msg_iter->msgs->length > 0 ||
!muxer_upstream_msg_iter->msg_iter) {
"muxer-upstream-msg-iter-wrap-addr=%p",
muxer_upstream_msg_iter);
if (muxer_upstream_msg_iter->msgs->length > 0 ||
!muxer_upstream_msg_iter->msg_iter) {
- BT_LOGV("Already valid or not considered: "
+ BT_LOGD("Already valid or not considered: "
"queue-len=%u, upstream-msg-iter-addr=%p",
muxer_upstream_msg_iter->msgs->length,
muxer_upstream_msg_iter->msg_iter);
"queue-len=%u, upstream-msg-iter-addr=%p",
muxer_upstream_msg_iter->msgs->length,
muxer_upstream_msg_iter->msg_iter);
BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
size_t i;
BT_SELF_MESSAGE_ITERATOR_STATUS_OK;
size_t i;
- BT_LOGV("Validating muxer's upstream message iterator wrappers: "
+ BT_LOGD("Validating muxer's upstream message iterator wrappers: "
"muxer-msg-iter-addr=%p", muxer_msg_iter);
for (i = 0; i < muxer_msg_iter->active_muxer_upstream_msg_iters->len;
"muxer-msg-iter-addr=%p", muxer_msg_iter);
for (i = 0; i < muxer_msg_iter->active_muxer_upstream_msg_iters->len;
muxer_msg_iter,
muxer_upstream_msg_iter);
} else {
muxer_msg_iter,
muxer_upstream_msg_iter);
} else {
- BT_LOGV("Cannot validate muxer's upstream message iterator wrapper: "
+ BT_LOGD("Cannot validate muxer's upstream message iterator wrapper: "
"muxer-msg-iter-addr=%p, "
"muxer-upstream-msg-iter-wrap-addr=%p",
muxer_msg_iter,
"muxer-msg-iter-addr=%p, "
"muxer-upstream-msg-iter-wrap-addr=%p",
muxer_msg_iter,
* array of ended iterators if it's ended.
*/
if (G_UNLIKELY(is_ended)) {
* array of ended iterators if it's ended.
*/
if (G_UNLIKELY(is_ended)) {
- BT_LOGV("Muxer's upstream message iterator wrapper: ended or canceled: "
+ BT_LOGD("Muxer's upstream message iterator wrapper: ended or canceled: "
"muxer-msg-iter-addr=%p, "
"muxer-upstream-msg-iter-wrap-addr=%p",
muxer_msg_iter, muxer_upstream_msg_iter);
"muxer-msg-iter-addr=%p, "
"muxer-upstream-msg-iter-wrap-addr=%p",
muxer_msg_iter, muxer_upstream_msg_iter);
"status=%s",
bt_common_self_message_iterator_status_string(status));
} else {
"status=%s",
bt_common_self_message_iterator_status_string(status));
} else {
- BT_LOGV("Cannot find the youngest upstream message iterator wrapper: "
+ BT_LOGD("Cannot find the youngest upstream message iterator wrapper: "
"status=%s",
bt_common_self_message_iterator_status_string(status));
}
"status=%s",
bt_common_self_message_iterator_status_string(status));
}
- BT_LOGV("Found youngest upstream message iterator wrapper: "
+ BT_LOGD("Found youngest upstream message iterator wrapper: "
"muxer-msg-iter-addr=%p, "
"muxer-upstream-msg-iter-wrap-addr=%p, "
"ts=%" PRId64,
"muxer-msg-iter-addr=%p, "
"muxer-upstream-msg-iter-wrap-addr=%p, "
"ts=%" PRId64,
- BT_LOGD("Creating all Python plugins from file: path=\"%s\"", path);
+ BT_LOGI("Trying to create all Python plugins from file: path=\"%s\"",
+ path);
path_len = strlen(path);
/* File name ends with `.py` */
if (strncmp(path + path_len - PYTHON_PLUGIN_FILE_EXT_LEN,
PYTHON_PLUGIN_FILE_EXT,
PYTHON_PLUGIN_FILE_EXT_LEN) != 0) {
path_len = strlen(path);
/* File name ends with `.py` */
if (strncmp(path + path_len - PYTHON_PLUGIN_FILE_EXT_LEN,
PYTHON_PLUGIN_FILE_EXT,
PYTHON_PLUGIN_FILE_EXT_LEN) != 0) {
- BT_LOGD("Skipping non-Python file: path=\"%s\"", path);
+ BT_LOGI("Skipping non-Python file: path=\"%s\"", path);
if (strncmp(basename, PYTHON_PLUGIN_FILE_PREFIX,
PYTHON_PLUGIN_FILE_PREFIX_LEN) != 0) {
if (strncmp(basename, PYTHON_PLUGIN_FILE_PREFIX,
PYTHON_PLUGIN_FILE_PREFIX_LEN) != 0) {
- BT_LOGD("Skipping Python file not starting with `%s`: "
+ BT_LOGI("Skipping Python file not starting with `%s`: "
"path=\"%s\"", PYTHON_PLUGIN_FILE_PREFIX, path);
goto error;
}
"path=\"%s\"", PYTHON_PLUGIN_FILE_PREFIX, path);
goto error;
}