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 */
- 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)) {
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);
plugin = NULL;
}
- 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);
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);
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);
}
return comp_class;
return;
}
- 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:
goto end;
}
- 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;
* 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) {
- BT_LOGD("Unable to load dynamic plugins: path=\"%s\"",
- plugin_path);
+ BT_LOGI("Unable to load dynamic plugins from directory: "
+ "path=\"%s\"", plugin_path);
continue;
}
/* 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));
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;
- BT_LOGD_STR("Cannot retrieve port name in query result.");
+ BT_LOGE_STR("Cannot retrieve port name in query result.");
goto error;
}
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);
goto end;
}
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;
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,
goto end;
}
- 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,
{
int ret = 0;
- 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);
goto end;
}
- 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);
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,
*/
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);
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) {
- BT_LOGE("Failed to allocate file key");
+ BT_LOGE_STR("Failed to allocate file key.");
goto error;
}
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);
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) {
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,
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--) {
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);
}
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;
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);
}
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;
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);
}
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;
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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),
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;
}
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);
}
}
if (method) {
- BT_LIB_LOGD("Calling user's finalization method: "
+ BT_LIB_LOGI("Calling user's component finalization method: "
"%![comp-]+c", comp);
method(comp);
}
*/
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 */
// 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);
}
}
- 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;
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) {
goto end;
}
- 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);
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);
}
BT_HIDDEN
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);
}
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);
}
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
{
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);
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);
end:
return connection;
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);
/*
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);
}
* 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);
obj->ref_count++;
/*
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->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;
"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);
}
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,
goto end;
}
- 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:
}
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;
}
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_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) {
- 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;
}
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))) {
- 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;
- 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:
goto end;
}
- BT_LIB_LOGV("Running graph: %!+g", graph);
+ BT_LIB_LOGI("Running graph: %!+g", graph);
do {
/*
* 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;
}
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;
"%!+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);
"%!+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);
"%!+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);
"%!+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);
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);
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);
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);
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);
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);
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);
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;
}
{
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);
}
"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);
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;
}
*/
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);
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);
#endif
}
*/
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);
{
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);
}
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 ||
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);
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);
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);
}
"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
*/
BT_ASSERT(iterator->methods.next);
BT_LOGD_STR("Calling user's \"next\" method.");
+ *user_count = 0;
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;
{
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);
"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) {
(struct bt_message_message_iterator_inactivity *) obj;
BT_LIB_LOGD("Destroying message iterator inactivity message: %!+n",
- message);
+ message);
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 "
- "inactivity message.");
+ "inactivity message.");
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",
- ret_msg);
+ ret_msg);
goto end;
error:
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,
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));
}
{
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);
goto end;
}
- 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->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:
* 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,
connection);
}
{
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;
}
}
/* 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",
pool);
#endif
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
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) {
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\"",
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
{
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->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
- * 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;
}
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);
}
size_t i;
int ret;
- 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, "
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 ?
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, "
continue;
}
- 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) {
/*
- * 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
- * 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;
}
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);
+ BT_ASSERT(path);
path_len = strlen(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);
path_len++;
+
/*
- * 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,
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) {
+ /* bt_plugin_so_shared_lib_handle_create() logs more details */
BT_LOGD_STR("Cannot create shared library handle.");
goto end;
}
(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;
(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;
(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");
}
(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) {
- 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",
(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");
}
(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) {
- 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",
(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");
}
(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) {
- 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",
{
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);
}
return;
}
- 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) {
__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.",
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);
end:
if (plugin_set) {
- 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 {
- BT_LOGD("Found no plugins in file: path=\"%s\"", path);
+ BT_LOGI("Found no plugins in file: path=\"%s\"", path);
}
return plugin_set;
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) {
* 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;
}
/* 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\"",
dir->str);
continue;
}
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);
}
}
- 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);
}
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);
}
if (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 {
- 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);
}
if (name[0] == '.') {
/* Skip hidden files */
- BT_LOGV("Skipping hidden file: path=\"%s\"", file);
+ BT_LOGI("Skipping hidden file: path=\"%s\"", file);
goto end;
}
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(
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);
break;
}
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) {
goto error;
}
- 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;
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;
}
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);
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\"",
plugin, path);
}
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\"",
plugin, name);
}
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);
}
static inline
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\"",
plugin, author);
}
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, license);
}
}
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);
}
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);
}
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;
}
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;
}
"%![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)
"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,
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_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",
clock_class);
}
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);
}
BT_HIDDEN
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,
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;
}
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)
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;
}
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);
end:
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);
end:
return ret;
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",
event, packet);
}
"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
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);
}
static
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);
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: "
"%!+F", fc);
}
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;
}
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);
end:
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);
end:
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;
}
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);
}
"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);
}
"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);
}
(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: "
"%!+S", stream_class);
}
(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: "
"%!+S", stream_class);
}
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);
}
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;
}
*/
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
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;
}
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(
*listener_id = i;
}
- 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;
}
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, 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);
}
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);
}
*/
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
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;
}
*listener_id = i;
}
- 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;
}
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;
{
struct bt_bfcr *bfcr;
- 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.");
goto end;
}
- 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);
* 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);
}
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));
/* 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;
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 ||
* 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 ", "
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 ", "
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_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 */
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) {
} 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) {
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) {
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);
lca_index++;
}
- BT_LOGV("Found LCA: lca-index=%" PRId64, lca_index);
+ BT_LOGD("Found LCA: lca-index=%" PRId64, lca_index);
return lca_index;
}
(int64_t) i;
}
- 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);
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.");
goto end;
}
".");
goto error;
}
- 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) {
- 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) {
- BT_LOGV("Cannot decode metadata packet: offset=%ld", offset);
+ BT_LOGE("Cannot decode metadata packet: offset=%ld", offset);
goto error;
}
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) {
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", ".");
"mdec-addr=%p", mdec);
}
- 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: "
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);
- 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) {
/* 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);
- 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) {
/*
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->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);
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);
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.");
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: "
"notit-addr=%p", notit);
- 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,
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,
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,
goto end;
}
- 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);
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 */
- 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,
goto end;
}
- 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->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\"",
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,
} 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_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 -
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->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);
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);
}
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)) {
- 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",
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",
* 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);
goto end;
}
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\"");
goto error;
}
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\"");
goto error;
}
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\"");
goto error;
}
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\"");
goto error;
}
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\"");
goto error;
}
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\"");
goto error;
}
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)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_major\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_major\"");
goto error;
}
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))) {
- 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)) {
- BT_LOGD_STR("Couldn't get environment value: name=\"tracer_hostname\"");
+ BT_LOGI_STR("Couldn't get environment value: name=\"tracer_hostname\"");
goto error;
}
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\"");
goto error;
}
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\"");
goto error;
}
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\"");
goto error;
}
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\"");
goto error;
}
}
} 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. */
- BT_LOGD("Unknown domain: domain=\"%s\"", domain);
+ BT_LOGI("Unknown domain: domain=\"%s\"", domain);
goto error;
}
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) {
- BT_LOGD_STR("Cannot read first packet's header and context fields.");
+ BT_LOGI_STR("Cannot read first packet's header and context fields.");
goto error;
}
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.");
goto error;
}
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) {
- 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");
goto error;
}
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.");
goto end;
}
} else {
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.");
goto end;
}
} else {
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) {
goto end;
}
- 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:
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",
goto error;
}
- 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));
}
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);
goto end;
error:
goto error;
}
- 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);
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] == '.') {
- 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;
}
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;
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;
}
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;
}
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);
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);
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;
}
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;
end:
if (ret == 0) {
- 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);
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,
}
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));
- 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)) {
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,
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;
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,
}
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,
goto error;
}
- 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;
}
- BT_LOGD("Connection to url \"%s\" is established", url);
+ BT_LOGI("Connection to url \"%s\" is established", url);
return viewer_connection;
error_report:
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) {
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_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;
*/
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;
}
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;
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) {
- BT_LOGD("Failed to lookup function name (DWARF): "
+ BT_LOGI("Failed to lookup function name (DWARF): "
"ret=%d", 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) {
- BT_LOGD("Error occured when setting line_no field.");
+ BT_LOGE("Error occured when setting line_no field.");
goto error;
}
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.");
}
g_free(debug_info);
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);
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);
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:
default:
abort();
}
- 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",
in_field, out_field);
}
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);
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;
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) {
goto error;
}
- 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);
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);
}
goto end;
}
- 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);
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);
- 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) {
* 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(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);
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;
}
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;
end:
if (ret == 0) {
- 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,
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) {
- 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);
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,
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,
* 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);
"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));
}
goto end;
}
- 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,
goto error;
}
- 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) {
- BT_LOGD("Skipping non-Python file: path=\"%s\"", path);
+ BT_LOGI("Skipping non-Python file: path=\"%s\"", path);
goto error;
}
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;
}
projects / babeltrace.git / commitdiff
