X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Flttng-live%2Fviewer-connection.c;h=befffb30a8c6117c096f9df086c7ff12823781ad;hb=b9e6ec43275c1a46401792b02abfb1ed380619a2;hp=65433896ea3953e58f0151fa9aa047f2e5bec38d;hpb=2242b43d4f50ebdeabb124154fb8ac602c563536;p=babeltrace.git diff --git a/src/plugins/ctf/lttng-live/viewer-connection.c b/src/plugins/ctf/lttng-live/viewer-connection.c index 65433896..befffb30 100644 --- a/src/plugins/ctf/lttng-live/viewer-connection.c +++ b/src/plugins/ctf/lttng-live/viewer-connection.c @@ -24,7 +24,7 @@ #define BT_COMP_LOG_SELF_COMP (viewer_connection->self_comp) #define BT_LOG_OUTPUT_LEVEL (viewer_connection->log_level) #define BT_LOG_TAG "PLUGIN/SRC.CTF.LTTNG-LIVE/VIEWER" -#include "plugins/comp-logging.h" +#include "logging/comp-logging.h" #include #include @@ -67,15 +67,18 @@ ssize_t lttng_live_recv(struct live_viewer_connection *viewer_connection, } if (ret == BT_SOCKET_ERROR && bt_socket_interrupted()) { if (!viewer_connection->in_query && - lttng_live_graph_is_canceled(lttng_live_msg_iter->lttng_live_comp)) { + lttng_live_graph_is_canceled(lttng_live_msg_iter)) { break; } else { continue; } } } while (ret > 0 && to_copy > 0); - if (ret > 0) + + if (ret > 0) { ret = copied; + } + /* ret = 0 means orderly shutdown, ret == BT_SOCKET_ERROR is error. */ return ret; } @@ -93,7 +96,7 @@ ssize_t lttng_live_send(struct live_viewer_connection *viewer_connection, ret = bt_socket_send_nosigpipe(sock, buf, len); if (ret == BT_SOCKET_ERROR && bt_socket_interrupted()) { if (!viewer_connection->in_query && - lttng_live_graph_is_canceled(lttng_live_msg_iter->lttng_live_comp)) { + lttng_live_graph_is_canceled(lttng_live_msg_iter)) { break; } else { continue; @@ -109,6 +112,8 @@ static int parse_url(struct live_viewer_connection *viewer_connection) { char error_buf[256] = { 0 }; + bt_self_component *self_comp = viewer_connection->self_comp; + bt_self_component_class *self_comp_class = viewer_connection->self_comp_class; struct bt_common_lttng_live_url_parts lttng_live_url_parts = { 0 }; int ret = -1; const char *path = viewer_connection->url->str; @@ -117,15 +122,16 @@ int parse_url(struct live_viewer_connection *viewer_connection) goto end; } - lttng_live_url_parts = bt_common_parse_lttng_live_url(path, - error_buf, sizeof(error_buf)); + lttng_live_url_parts = bt_common_parse_lttng_live_url(path, error_buf, + sizeof(error_buf)); if (!lttng_live_url_parts.proto) { - BT_COMP_LOGW("Invalid LTTng live URL format: %s", error_buf); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class,"Invalid LTTng live URL format: %s", + error_buf); goto end; } - viewer_connection->relay_hostname = - lttng_live_url_parts.hostname; + viewer_connection->relay_hostname = lttng_live_url_parts.hostname; lttng_live_url_parts.hostname = NULL; if (lttng_live_url_parts.port >= 0) { @@ -134,26 +140,23 @@ int parse_url(struct live_viewer_connection *viewer_connection) viewer_connection->port = LTTNG_DEFAULT_NETWORK_VIEWER_PORT; } - viewer_connection->target_hostname = - lttng_live_url_parts.target_hostname; + viewer_connection->target_hostname = lttng_live_url_parts.target_hostname; lttng_live_url_parts.target_hostname = NULL; if (lttng_live_url_parts.session_name) { - viewer_connection->session_name = - lttng_live_url_parts.session_name; + viewer_connection->session_name = lttng_live_url_parts.session_name; lttng_live_url_parts.session_name = NULL; } BT_COMP_LOGI("Connecting to hostname : %s, port : %d, " - "target hostname : %s, session name : %s, " - "proto : %s", - viewer_connection->relay_hostname->str, - viewer_connection->port, - viewer_connection->target_hostname == NULL ? - "" : viewer_connection->target_hostname->str, - viewer_connection->session_name == NULL ? - "" : viewer_connection->session_name->str, - lttng_live_url_parts.proto->str); + "target hostname : %s, session name : %s, proto : %s", + viewer_connection->relay_hostname->str, + viewer_connection->port, + !viewer_connection->target_hostname ? + "" : viewer_connection->target_hostname->str, + !viewer_connection->session_name ? + "" : viewer_connection->session_name->str, + lttng_live_url_parts.proto->str); ret = 0; end: @@ -166,6 +169,8 @@ int lttng_live_handshake(struct live_viewer_connection *viewer_connection) { struct lttng_viewer_cmd cmd; struct lttng_viewer_connect connect; + bt_self_component_class *self_comp_class = viewer_connection->self_comp_class; + bt_self_component *self_comp = viewer_connection->self_comp; const size_t cmd_buf_len = sizeof(cmd) + sizeof(connect); char cmd_buf[cmd_buf_len]; int ret; @@ -189,7 +194,9 @@ int lttng_live_handshake(struct live_viewer_connection *viewer_connection) memcpy(cmd_buf + sizeof(cmd), &connect, sizeof(connect)); ret_len = lttng_live_send(viewer_connection, &cmd_buf, cmd_buf_len); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending version: %s", bt_socket_errormsg()); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Error sending version: %s", + bt_socket_errormsg()); goto error; } @@ -197,11 +204,14 @@ int lttng_live_handshake(struct live_viewer_connection *viewer_connection) ret_len = lttng_live_recv(viewer_connection, &connect, sizeof(connect)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving version: %s", bt_socket_errormsg()); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Error receiving version: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(connect)); @@ -212,7 +222,8 @@ int lttng_live_handshake(struct live_viewer_connection *viewer_connection) be32toh(connect.minor)); if (LTTNG_LIVE_MAJOR != be32toh(connect.major)) { - BT_COMP_LOGE("Incompatible lttng-relayd protocol"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Incompatible lttng-relayd protocol"); goto error; } /* Use the smallest protocol version implemented. */ @@ -226,7 +237,6 @@ int lttng_live_handshake(struct live_viewer_connection *viewer_connection) return ret; error: - BT_COMP_LOGE("Unable to establish connection"); return -1; } @@ -235,21 +245,27 @@ int lttng_live_connect_viewer(struct live_viewer_connection *viewer_connection) { struct hostent *host; struct sockaddr_in server_addr; + bt_self_component_class *self_comp_class = viewer_connection->self_comp_class; + bt_self_component *self_comp = viewer_connection->self_comp; int ret; if (parse_url(viewer_connection)) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Failed to parse URL"); goto error; } host = gethostbyname(viewer_connection->relay_hostname->str); if (!host) { - BT_COMP_LOGE("Cannot lookup hostname %s", + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Cannot lookup hostname: hostname=\"%s\"", viewer_connection->relay_hostname->str); goto error; } if ((viewer_connection->control_sock = socket(AF_INET, SOCK_STREAM, 0)) == BT_INVALID_SOCKET) { - BT_COMP_LOGE("Socket creation failed: %s", bt_socket_errormsg()); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Socket creation failed: %s", bt_socket_errormsg()); goto error; } @@ -260,10 +276,14 @@ int lttng_live_connect_viewer(struct live_viewer_connection *viewer_connection) if (connect(viewer_connection->control_sock, (struct sockaddr *) &server_addr, sizeof(struct sockaddr)) == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Connection failed: %s", bt_socket_errormsg()); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Connection failed: %s", + bt_socket_errormsg()); goto error; } if (lttng_live_handshake(viewer_connection)) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Viewer handshake failed"); goto error; } @@ -274,7 +294,8 @@ int lttng_live_connect_viewer(struct live_viewer_connection *viewer_connection) error: if (viewer_connection->control_sock != BT_INVALID_SOCKET) { if (bt_socket_close(viewer_connection->control_sock) == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Close: %s", bt_socket_errormsg()); + BT_COMP_OR_COMP_CLASS_LOGE(self_comp, self_comp_class, + "Error closing socket: %s", bt_socket_errormsg()); } } viewer_connection->control_sock = BT_INVALID_SOCKET; @@ -289,58 +310,46 @@ void lttng_live_disconnect_viewer( return; } if (bt_socket_close(viewer_connection->control_sock) == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Close: %s", bt_socket_errormsg()); + BT_COMP_LOGE("Error closing socket: %s", + bt_socket_errormsg()); viewer_connection->control_sock = BT_INVALID_SOCKET; } } -static -void connection_release(bt_object *obj) -{ - struct live_viewer_connection *conn = - container_of(obj, struct live_viewer_connection, obj); - - live_viewer_connection_destroy(conn); -} - static int list_update_session(bt_value *results, const struct lttng_viewer_session *session, bool *_found, struct live_viewer_connection *viewer_connection) { + bt_self_component_class *self_comp_class = viewer_connection->self_comp_class; + bt_self_component *self_comp = viewer_connection->self_comp; int ret = 0; + uint64_t i, len; bt_value *map = NULL; bt_value *hostname = NULL; bt_value *session_name = NULL; bt_value *btval = NULL; - int i, len; bool found = false; - len = bt_value_array_get_size(results); - if (len < 0) { - BT_COMP_LOGE_STR("Error getting size of array."); - ret = -1; - goto end; - } + len = bt_value_array_get_length(results); for (i = 0; i < len; i++) { const char *hostname_str = NULL; const char *session_name_str = NULL; - map = bt_value_array_borrow_element_by_index(results, (size_t) i); - if (!map) { - BT_COMP_LOGE_STR("Error borrowing map."); - ret = -1; - goto end; - } + map = bt_value_array_borrow_element_by_index(results, i); hostname = bt_value_map_borrow_entry_value(map, "target-hostname"); if (!hostname) { - BT_COMP_LOGE_STR("Error borrowing \"target-hostname\" entry."); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, + "Error borrowing \"target-hostname\" entry."); ret = -1; goto end; } session_name = bt_value_map_borrow_entry_value(map, "session-name"); if (!session_name) { - BT_COMP_LOGE_STR("Error borrowing \"session-name\" entry."); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, + "Error borrowing \"session-name\" entry."); ret = -1; goto end; } @@ -357,25 +366,29 @@ int list_update_session(bt_value *results, btval = bt_value_map_borrow_entry_value(map, "stream-count"); if (!btval) { - BT_COMP_LOGE_STR("Error borrowing \"stream-count\" entry."); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE( + self_comp, self_comp_class, + "Error borrowing \"stream-count\" entry."); ret = -1; goto end; } - val = bt_value_signed_integer_get(btval); + val = bt_value_integer_unsigned_get(btval); /* sum */ val += streams; - bt_value_signed_integer_set(btval, val); + bt_value_integer_unsigned_set(btval, val); btval = bt_value_map_borrow_entry_value(map, "client-count"); if (!btval) { - BT_COMP_LOGE_STR("Error borrowing \"client-count\" entry."); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE( + self_comp, self_comp_class, + "Error borrowing \"client-count\" entry."); ret = -1; goto end; } - val = bt_value_signed_integer_get(btval); + val = bt_value_integer_unsigned_get(btval); /* max */ val = bt_max_t(int64_t, clients, val); - bt_value_signed_integer_set(btval, val); + bt_value_integer_unsigned_set(btval, val); } if (found) { @@ -394,6 +407,7 @@ int list_append_session(bt_value *results, struct live_viewer_connection *viewer_connection) { int ret = 0; + bt_self_component_class *self_comp_class = viewer_connection->self_comp_class; bt_value_map_insert_entry_status insert_status; bt_value_array_append_element_status append_status; bt_value *map = NULL; @@ -411,13 +425,15 @@ int list_append_session(bt_value *results, map = bt_value_map_create(); if (!map) { - BT_COMP_LOGE_STR("Error creating map value."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error creating map value."); ret = -1; goto end; } if (base_url->len < 1) { - BT_COMP_LOGE_STR("Error: base_url length smaller than 1."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error: base_url length smaller than 1."); ret = -1; goto end; } @@ -433,7 +449,8 @@ int list_append_session(bt_value *results, insert_status = bt_value_map_insert_string_entry(map, "url", url->str); if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) { - BT_COMP_LOGE_STR("Error inserting \"url\" entry."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error inserting \"url\" entry."); ret = -1; goto end; } @@ -445,7 +462,8 @@ int list_append_session(bt_value *results, insert_status = bt_value_map_insert_string_entry(map, "target-hostname", session->hostname); if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) { - BT_COMP_LOGE_STR("Error inserting \"target-hostname\" entry."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error inserting \"target-hostname\" entry."); ret = -1; goto end; } @@ -457,7 +475,8 @@ int list_append_session(bt_value *results, insert_status = bt_value_map_insert_string_entry(map, "session-name", session->session_name); if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) { - BT_COMP_LOGE_STR("Error inserting \"session-name\" entry."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error inserting \"session-name\" entry."); ret = -1; goto end; } @@ -469,10 +488,11 @@ int list_append_session(bt_value *results, { uint32_t live_timer = be32toh(session->live_timer); - insert_status = bt_value_map_insert_signed_integer_entry( + insert_status = bt_value_map_insert_unsigned_integer_entry( map, "timer-us", live_timer); if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) { - BT_COMP_LOGE_STR("Error inserting \"timer-us\" entry."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error inserting \"timer-us\" entry."); ret = -1; goto end; } @@ -485,10 +505,11 @@ int list_append_session(bt_value *results, { uint32_t streams = be32toh(session->streams); - insert_status = bt_value_map_insert_signed_integer_entry(map, + insert_status = bt_value_map_insert_unsigned_integer_entry(map, "stream-count", streams); if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) { - BT_COMP_LOGE_STR("Error inserting \"stream-count\" entry."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error inserting \"stream-count\" entry."); ret = -1; goto end; } @@ -501,10 +522,11 @@ int list_append_session(bt_value *results, { uint32_t clients = be32toh(session->clients); - insert_status = bt_value_map_insert_signed_integer_entry(map, + insert_status = bt_value_map_insert_unsigned_integer_entry(map, "client-count", clients); if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) { - BT_COMP_LOGE_STR("Error inserting \"client-count\" entry."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error inserting \"client-count\" entry."); ret = -1; goto end; } @@ -512,7 +534,8 @@ int list_append_session(bt_value *results, append_status = bt_value_array_append_element(results, map); if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) { - BT_COMP_LOGE_STR("Error appending map to results."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error appending map to results."); ret = -1; } @@ -565,6 +588,7 @@ bt_component_class_query_method_status live_viewer_connection_list_sessions( struct live_viewer_connection *viewer_connection, const bt_value **user_result) { + bt_self_component_class *self_comp_class = viewer_connection->self_comp_class; bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK; bt_value *result = NULL; @@ -573,13 +597,10 @@ bt_component_class_query_method_status live_viewer_connection_list_sessions( uint32_t i, sessions_count; ssize_t ret_len; - if (lttng_live_handshake(viewer_connection)) { - goto error; - } - result = bt_value_array_create(); if (!result) { - BT_COMP_LOGE("Error creating array"); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error creating array"); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR; goto error; } @@ -590,7 +611,8 @@ bt_component_class_query_method_status live_viewer_connection_list_sessions( ret_len = lttng_live_send(viewer_connection, &cmd, sizeof(cmd)); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending cmd: %s", bt_socket_errormsg()); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error sending cmd: %s", bt_socket_errormsg()); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } @@ -598,12 +620,15 @@ bt_component_class_query_method_status live_viewer_connection_list_sessions( ret_len = lttng_live_recv(viewer_connection, &list, sizeof(list)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Remote side has closed connection"); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving session list: %s", bt_socket_errormsg()); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error receiving session list: %s", + bt_socket_errormsg()); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } @@ -616,12 +641,15 @@ bt_component_class_query_method_status live_viewer_connection_list_sessions( ret_len = lttng_live_recv(viewer_connection, &lsession, sizeof(lsession)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Remote side has closed connection"); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving session: %s", bt_socket_errormsg()); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error receiving session: %s", + bt_socket_errormsg()); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } @@ -630,6 +658,8 @@ bt_component_class_query_method_status live_viewer_connection_list_sessions( lsession.session_name[LTTNG_VIEWER_NAME_MAX - 1] = '\0'; if (list_append_session(result, viewer_connection->url, &lsession, viewer_connection)) { + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Error appending session"); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } @@ -653,7 +683,8 @@ int lttng_live_query_session_ids(struct lttng_live_msg_iter *lttng_live_msg_iter ssize_t ret_len; uint64_t session_id; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; + bt_self_component *self_comp = viewer_connection->self_comp; cmd.cmd = htobe32(LTTNG_VIEWER_LIST_SESSIONS); cmd.data_size = htobe64((uint64_t) 0); @@ -661,18 +692,22 @@ int lttng_live_query_session_ids(struct lttng_live_msg_iter *lttng_live_msg_iter ret_len = lttng_live_send(viewer_connection, &cmd, sizeof(cmd)); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending cmd: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Error sending cmd: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(cmd)); ret_len = lttng_live_recv(viewer_connection, &list, sizeof(list)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving session list: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving session list: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(list)); @@ -682,11 +717,14 @@ int lttng_live_query_session_ids(struct lttng_live_msg_iter *lttng_live_msg_iter ret_len = lttng_live_recv(viewer_connection, &lsession, sizeof(lsession)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving session: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving session: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(lsession)); @@ -705,6 +743,8 @@ int lttng_live_query_session_ids(struct lttng_live_msg_iter *lttng_live_msg_iter if (lttng_live_add_session(lttng_live_msg_iter, session_id, lsession.hostname, lsession.session_name)) { + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to add live session"); goto error; } } @@ -713,7 +753,6 @@ int lttng_live_query_session_ids(struct lttng_live_msg_iter *lttng_live_msg_iter return 0; error: - BT_COMP_LOGE("Unable to query session ids"); return -1; } @@ -725,7 +764,8 @@ int lttng_live_create_viewer_session( struct lttng_viewer_create_session_response resp; ssize_t ret_len; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; + bt_self_component *self_comp = viewer_connection->self_comp; cmd.cmd = htobe32(LTTNG_VIEWER_CREATE_SESSION); cmd.data_size = htobe64((uint64_t) 0); @@ -733,27 +773,34 @@ int lttng_live_create_viewer_session( ret_len = lttng_live_send(viewer_connection, &cmd, sizeof(cmd)); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending cmd: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Error sending cmd: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(cmd)); ret_len = lttng_live_recv(viewer_connection, &resp, sizeof(resp)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving create session reply: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving create session reply: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(resp)); if (be32toh(resp.status) != LTTNG_VIEWER_CREATE_SESSION_OK) { - BT_COMP_LOGE("Error creating viewer session"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error creating viewer session"); goto error; } if (lttng_live_query_session_ids(lttng_live_msg_iter)) { + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to query live viewer session ids"); goto error; } @@ -770,9 +817,10 @@ int receive_streams(struct lttng_live_session *session, ssize_t ret_len; uint32_t i; struct lttng_live_msg_iter *lttng_live_msg_iter = - session->lttng_live_msg_iter; + session->lttng_live_msg_iter; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; + bt_self_component *self_comp = viewer_connection->self_comp; BT_COMP_LOGI("Getting %" PRIu32 " new streams:", stream_count); for (i = 0; i < stream_count; i++) { @@ -783,11 +831,13 @@ int receive_streams(struct lttng_live_session *session, ret_len = lttng_live_recv(viewer_connection, &stream, sizeof(stream)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving stream"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving stream"); goto error; } BT_ASSERT(ret_len == sizeof(stream)); @@ -798,24 +848,24 @@ int receive_streams(struct lttng_live_session *session, if (stream.metadata_flag) { BT_COMP_LOGI(" metadata stream %" PRIu64 " : %s/%s", - stream_id, stream.path_name, - stream.channel_name); + stream_id, stream.path_name, stream.channel_name); if (lttng_live_metadata_create_stream(session, ctf_trace_id, stream_id, stream.path_name)) { - BT_COMP_LOGE("Error creating metadata stream"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error creating metadata stream"); goto error; } session->lazy_stream_msg_init = true; } else { BT_COMP_LOGI(" stream %" PRIu64 " : %s/%s", - stream_id, stream.path_name, - stream.channel_name); + stream_id, stream.path_name, stream.channel_name); live_stream = lttng_live_stream_iterator_create(session, ctf_trace_id, stream_id); if (!live_stream) { - BT_COMP_LOGE("Error creating streamn"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error creating stream"); goto error; } } @@ -827,19 +877,23 @@ error: } BT_HIDDEN -int lttng_live_attach_session(struct lttng_live_session *session) +enum lttng_live_attach_session_status lttng_live_attach_session( + struct lttng_live_session *session) { struct lttng_viewer_cmd cmd; + enum lttng_live_attach_session_status attach_status; struct lttng_viewer_attach_session_request rq; struct lttng_viewer_attach_session_response rp; - ssize_t ret_len; - struct lttng_live_msg_iter *lttng_live_msg_iter = session->lttng_live_msg_iter; + struct lttng_live_msg_iter *lttng_live_msg_iter = + session->lttng_live_msg_iter; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; + bt_self_component *self_comp = viewer_connection->self_comp; uint64_t session_id = session->id; uint32_t streams_count; const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq); char cmd_buf[cmd_buf_len]; + ssize_t ret_len; cmd.cmd = htobe32(LTTNG_VIEWER_ATTACH_SESSION); cmd.data_size = htobe64((uint64_t) sizeof(rq)); @@ -860,18 +914,23 @@ int lttng_live_attach_session(struct lttng_live_session *session) memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq)); ret_len = lttng_live_send(viewer_connection, &cmd_buf, cmd_buf_len); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending attach request: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error sending attach request: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == cmd_buf_len); ret_len = lttng_live_recv(viewer_connection, &rp, sizeof(rp)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving attach response: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving attach response: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(rp)); @@ -881,34 +940,42 @@ int lttng_live_attach_session(struct lttng_live_session *session) case LTTNG_VIEWER_ATTACH_OK: break; case LTTNG_VIEWER_ATTACH_UNK: - BT_COMP_LOGW("Session id %" PRIu64 " is unknown", session_id); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Session id %" PRIu64 " is unknown", session_id); goto error; case LTTNG_VIEWER_ATTACH_ALREADY: - BT_COMP_LOGW("There is already a viewer attached to this session"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "There is already a viewer attached to this session"); goto error; case LTTNG_VIEWER_ATTACH_NOT_LIVE: - BT_COMP_LOGW("Not a live session"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Not a live session"); goto error; case LTTNG_VIEWER_ATTACH_SEEK_ERR: - BT_COMP_LOGE("Wrong seek parameter"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Wrong seek parameter"); goto error; default: - BT_COMP_LOGE("Unknown attach return code %u", be32toh(rp.status)); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Unknown attach return code %u", be32toh(rp.status)); goto error; } /* We receive the initial list of streams. */ if (receive_streams(session, streams_count)) { + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Error receiving streams"); goto error; } session->attached = true; session->new_streams_needed = false; - return 0; + attach_status = LTTNG_LIVE_ATTACH_SESSION_STATUS_OK; + goto end; error: - return -1; + attach_status = LTTNG_LIVE_ATTACH_SESSION_STATUS_ERROR; + +end: + return attach_status; } BT_HIDDEN @@ -918,9 +985,10 @@ int lttng_live_detach_session(struct lttng_live_session *session) struct lttng_viewer_detach_session_request rq; struct lttng_viewer_detach_session_response rp; ssize_t ret_len; - struct lttng_live_msg_iter *lttng_live_msg_iter = session->lttng_live_msg_iter; + struct lttng_live_msg_iter *lttng_live_msg_iter = + session->lttng_live_msg_iter; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; uint64_t session_id = session->id; const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq); char cmd_buf[cmd_buf_len]; @@ -945,18 +1013,20 @@ int lttng_live_detach_session(struct lttng_live_session *session) memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq)); ret_len = lttng_live_send(viewer_connection, &cmd_buf, cmd_buf_len); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending detach request: %s", bt_socket_errormsg()); + BT_COMP_LOGE("Error sending detach request: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == cmd_buf_len); ret_len = lttng_live_recv(viewer_connection, &rp, sizeof(rp)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE("Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving detach response: %s", bt_socket_errormsg()); + BT_COMP_LOGE("Error receiving detach response: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(rp)); @@ -984,21 +1054,23 @@ error: } BT_HIDDEN -ssize_t lttng_live_get_one_metadata_packet(struct lttng_live_trace *trace, - FILE *fp) +enum lttng_live_get_one_metadata_status lttng_live_get_one_metadata_packet( + struct lttng_live_trace *trace, FILE *fp, size_t *reply_len) { uint64_t len = 0; - int ret; + enum lttng_live_get_one_metadata_status metadata_status; struct lttng_viewer_cmd cmd; struct lttng_viewer_get_metadata rq; struct lttng_viewer_metadata_packet rp; char *data = NULL; ssize_t ret_len; struct lttng_live_session *session = trace->session; - struct lttng_live_msg_iter *lttng_live_msg_iter = session->lttng_live_msg_iter; + struct lttng_live_msg_iter *lttng_live_msg_iter = + session->lttng_live_msg_iter; struct lttng_live_metadata *metadata = trace->metadata; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; + bt_self_component *self_comp = viewer_connection->self_comp; const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq); char cmd_buf[cmd_buf_len]; @@ -1016,47 +1088,62 @@ ssize_t lttng_live_get_one_metadata_packet(struct lttng_live_trace *trace, memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq)); ret_len = lttng_live_send(viewer_connection, &cmd_buf, cmd_buf_len); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending get_metadata request: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error sending get_metadata request: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == cmd_buf_len); ret_len = lttng_live_recv(viewer_connection, &rp, sizeof(rp)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving get_metadata response: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving get_metadata response: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(rp)); switch (be32toh(rp.status)) { case LTTNG_VIEWER_METADATA_OK: - BT_COMP_LOGD("get_metadata : OK"); + BT_COMP_LOGD("Received get_metadata response: ok"); break; case LTTNG_VIEWER_NO_NEW_METADATA: - BT_COMP_LOGD("get_metadata : NO NEW"); - ret = 0; + BT_COMP_LOGD("Received get_metadata response: no new"); + metadata_status = LTTNG_LIVE_GET_ONE_METADATA_STATUS_END; goto end; case LTTNG_VIEWER_METADATA_ERR: - BT_COMP_LOGD("get_metadata : ERR"); - goto error; + /* + * The Relayd cannot find this stream id. Maybe its + * gone already. This can happen in short lived UST app + * in a per-pid session. + */ + BT_COMP_LOGD("Received get_metadata response: error"); + metadata_status = LTTNG_LIVE_GET_ONE_METADATA_STATUS_CLOSED; + goto end; default: - BT_COMP_LOGD("get_metadata : UNKNOWN"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Received get_metadata response: unknown"); goto error; } len = be64toh(rp.len); BT_COMP_LOGD("Writing %" PRIu64" bytes to metadata", len); if (len <= 0) { + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Erroneous response length"); goto error; } data = calloc(1, len); if (!data) { - BT_COMP_LOGE("relay data calloc: %s", strerror(errno)); + BT_COMP_LOGE_APPEND_CAUSE_ERRNO(self_comp, + "Failed to allocate data buffer", "."); goto error; } ret_len = lttng_live_recv(viewer_connection, data, len); @@ -1065,7 +1152,8 @@ ssize_t lttng_live_get_one_metadata_packet(struct lttng_live_trace *trace, goto error_free_data; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving trace packet: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving trace packet: %s", bt_socket_errormsg()); goto error_free_data; } BT_ASSERT(ret_len == len); @@ -1074,19 +1162,24 @@ ssize_t lttng_live_get_one_metadata_packet(struct lttng_live_trace *trace, ret_len = fwrite(data, 1, len, fp); } while (ret_len < 0 && errno == EINTR); if (ret_len < 0) { - BT_COMP_LOGE("Writing in the metadata fp"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Writing in the metadata file stream"); goto error_free_data; } BT_ASSERT(ret_len == len); free(data); - ret = len; -end: - return ret; + *reply_len = len; + metadata_status = LTTNG_LIVE_GET_ONE_METADATA_STATUS_OK; + + goto end; error_free_data: free(data); error: - return -1; + metadata_status = LTTNG_LIVE_GET_ONE_METADATA_STATUS_ERROR; + +end: + return metadata_status; } /* @@ -1115,18 +1208,16 @@ enum lttng_live_iterator_status lttng_live_get_next_index( { struct lttng_viewer_cmd cmd; struct lttng_viewer_get_next_index rq; - ssize_t ret_len; struct lttng_viewer_index rp; - uint32_t flags, status; - enum lttng_live_iterator_status retstatus = - LTTNG_LIVE_ITERATOR_STATUS_OK; + enum lttng_live_iterator_status retstatus = LTTNG_LIVE_ITERATOR_STATUS_OK; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; + bt_self_component *self_comp = viewer_connection->self_comp; struct lttng_live_trace *trace = stream->trace; const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq); char cmd_buf[cmd_buf_len]; - struct lttng_live_component *lttng_live = - lttng_live_msg_iter->lttng_live_comp; + uint32_t flags, status; + ssize_t ret_len; cmd.cmd = htobe32(LTTNG_VIEWER_GET_NEXT_INDEX); cmd.data_size = htobe64((uint64_t) sizeof(rq)); @@ -1145,20 +1236,23 @@ enum lttng_live_iterator_status lttng_live_get_next_index( memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq)); ret_len = lttng_live_send(viewer_connection, &cmd_buf, cmd_buf_len); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending get_next_index request: %s", - bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error sending get_next_index request: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == cmd_buf_len); ret_len = lttng_live_recv(viewer_connection, &rp, sizeof(rp)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving get_next_index response: %s", - bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving get_next_index response: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == sizeof(rp)); @@ -1171,7 +1265,7 @@ enum lttng_live_iterator_status lttng_live_get_next_index( { uint64_t ctf_stream_class_id; - BT_COMP_LOGD("get_next_index: inactive"); + BT_COMP_LOGD("Received get_next_index response: inactive"); memset(index, 0, sizeof(struct packet_index)); index->ts_cycles.timestamp_end = be64toh(rp.timestamp_end); stream->current_inactivity_ts = index->ts_cycles.timestamp_end; @@ -1189,7 +1283,7 @@ enum lttng_live_iterator_status lttng_live_get_next_index( { uint64_t ctf_stream_class_id; - BT_COMP_LOGD("get_next_index: OK"); + BT_COMP_LOGD("Received get_next_index response: OK"); lttng_index_to_packet_index(&rp, index); ctf_stream_class_id = be64toh(rp.stream_id); if (stream->ctf_stream_class_id != -1ULL) { @@ -1202,35 +1296,36 @@ enum lttng_live_iterator_status lttng_live_get_next_index( stream->state = LTTNG_LIVE_STREAM_ACTIVE_DATA; if (flags & LTTNG_VIEWER_FLAG_NEW_METADATA) { - BT_COMP_LOGD("get_next_index: new metadata needed"); + BT_COMP_LOGD("Received get_next_index response: new metadata needed"); trace->new_metadata_needed = true; } if (flags & LTTNG_VIEWER_FLAG_NEW_STREAM) { - BT_COMP_LOGD("get_next_index: new streams needed"); + BT_COMP_LOGD("Received get_next_index response: new streams needed"); lttng_live_need_new_streams(lttng_live_msg_iter); } break; } case LTTNG_VIEWER_INDEX_RETRY: - BT_COMP_LOGD("get_next_index: retry"); + BT_COMP_LOGD("Received get_next_index response: retry"); memset(index, 0, sizeof(struct packet_index)); retstatus = LTTNG_LIVE_ITERATOR_STATUS_AGAIN; stream->state = LTTNG_LIVE_STREAM_ACTIVE_NO_DATA; goto end; case LTTNG_VIEWER_INDEX_HUP: - BT_COMP_LOGD("get_next_index: stream hung up"); + BT_COMP_LOGD("Received get_next_index response: stream hung up"); memset(index, 0, sizeof(struct packet_index)); index->offset = EOF; retstatus = LTTNG_LIVE_ITERATOR_STATUS_END; stream->state = LTTNG_LIVE_STREAM_EOF; + stream->has_stream_hung_up = true; break; case LTTNG_VIEWER_INDEX_ERR: - BT_COMP_LOGE("get_next_index: error"); + BT_COMP_LOGD("Received get_next_index response: error"); memset(index, 0, sizeof(struct packet_index)); stream->state = LTTNG_LIVE_STREAM_ACTIVE_NO_DATA; goto error; default: - BT_COMP_LOGE("get_next_index: unknown value"); + BT_COMP_LOGD("Received get_next_index response: unknown value"); memset(index, 0, sizeof(struct packet_index)); stream->state = LTTNG_LIVE_STREAM_ACTIVE_NO_DATA; goto error; @@ -1239,7 +1334,7 @@ end: return retstatus; error: - if (lttng_live_graph_is_canceled(lttng_live)) { + if (lttng_live_graph_is_canceled(lttng_live_msg_iter)) { retstatus = LTTNG_LIVE_ITERATOR_STATUS_AGAIN; } else { retstatus = LTTNG_LIVE_ITERATOR_STATUS_ERROR; @@ -1254,18 +1349,17 @@ enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( uint64_t offset, uint64_t req_len, uint64_t *recv_len) { enum bt_msg_iter_medium_status retstatus = BT_MSG_ITER_MEDIUM_STATUS_OK; + struct lttng_viewer_trace_packet rp; struct lttng_viewer_cmd cmd; struct lttng_viewer_get_packet rq; - struct lttng_viewer_trace_packet rp; - ssize_t ret_len; - uint32_t flags, status; struct live_viewer_connection *viewer_connection = - lttng_live_msg_iter->viewer_connection; + lttng_live_msg_iter->viewer_connection; + bt_self_component *self_comp = viewer_connection->self_comp; struct lttng_live_trace *trace = stream->trace; const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq); char cmd_buf[cmd_buf_len]; - struct lttng_live_component *lttng_live = - lttng_live_msg_iter->lttng_live_comp; + uint32_t flags, status; + ssize_t ret_len; BT_COMP_LOGD("lttng_live_get_stream_bytes: offset=%" PRIu64 ", req_len=%" PRIu64, offset, req_len); @@ -1287,24 +1381,28 @@ enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq)); ret_len = lttng_live_send(viewer_connection, &cmd_buf, cmd_buf_len); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending get_data request: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error sending get_data_packet request: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == cmd_buf_len); ret_len = lttng_live_recv(viewer_connection, &rp, sizeof(rp)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving get_data response: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Socket error receiving get_data response: %s", + bt_socket_errormsg()); goto error; } if (ret_len != sizeof(rp)) { - BT_COMP_LOGE("get_data_packet: expected %zu" - ", received %zd", sizeof(rp), - ret_len); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "get_data_packet: " + "expected %zu, received %zd", sizeof(rp), ret_len); goto error; } @@ -1314,11 +1412,12 @@ enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( switch (status) { case LTTNG_VIEWER_GET_PACKET_OK: req_len = be32toh(rp.len); - BT_COMP_LOGD("get_data_packet: Ok, packet size : %" PRIu64 "", req_len); + BT_COMP_LOGD("Received get_data_packet response: Ok, " + "packet size : %" PRIu64 "", req_len); break; case LTTNG_VIEWER_GET_PACKET_RETRY: /* Unimplemented by relay daemon */ - BT_COMP_LOGD("get_data_packet: retry"); + BT_COMP_LOGD("Received get_data_packet response: retry"); retstatus = BT_MSG_ITER_MEDIUM_STATUS_AGAIN; goto end; case LTTNG_VIEWER_GET_PACKET_ERR: @@ -1335,13 +1434,15 @@ enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( retstatus = BT_MSG_ITER_MEDIUM_STATUS_AGAIN; goto end; } - BT_COMP_LOGE("get_data_packet: error"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Received get_data_packet response: error"); goto error; case LTTNG_VIEWER_GET_PACKET_EOF: retstatus = BT_MSG_ITER_MEDIUM_STATUS_EOF; goto end; default: - BT_COMP_LOGE("get_data_packet: unknown"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Received get_data_packet response: unknown"); goto error; } @@ -1351,11 +1452,14 @@ enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( ret_len = lttng_live_recv(viewer_connection, buf, req_len); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving trace packet: %s", bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving trace packet: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == req_len); @@ -1364,7 +1468,7 @@ end: return retstatus; error: - if (lttng_live_graph_is_canceled(lttng_live)) { + if (lttng_live_graph_is_canceled(lttng_live_msg_iter)) { retstatus = BT_MSG_ITER_MEDIUM_STATUS_AGAIN; } else { retstatus = BT_MSG_ITER_MEDIUM_STATUS_ERROR; @@ -1384,16 +1488,15 @@ enum lttng_live_iterator_status lttng_live_get_new_streams( struct lttng_viewer_cmd cmd; struct lttng_viewer_new_streams_request rq; struct lttng_viewer_new_streams_response rp; - ssize_t ret_len; struct lttng_live_msg_iter *lttng_live_msg_iter = session->lttng_live_msg_iter; struct live_viewer_connection *viewer_connection = lttng_live_msg_iter->viewer_connection; - struct lttng_live_component *lttng_live = - lttng_live_msg_iter->lttng_live_comp; + bt_self_component *self_comp = viewer_connection->self_comp; uint32_t streams_count; const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq); char cmd_buf[cmd_buf_len]; + ssize_t ret_len; if (!session->new_streams_needed) { return LTTNG_LIVE_ITERATOR_STATUS_OK; @@ -1415,19 +1518,22 @@ enum lttng_live_iterator_status lttng_live_get_new_streams( memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq)); ret_len = lttng_live_send(viewer_connection, &cmd_buf, cmd_buf_len); if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error sending get_new_streams request: %s", - bt_socket_errormsg()); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error sending get_new_streams request: %s", + bt_socket_errormsg()); goto error; } BT_ASSERT(ret_len == cmd_buf_len); ret_len = lttng_live_recv(viewer_connection, &rp, sizeof(rp)); if (ret_len == 0) { - BT_COMP_LOGI("Remote side has closed connection"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Remote side has closed connection"); goto error; } if (ret_len == BT_SOCKET_ERROR) { - BT_COMP_LOGE("Error receiving get_new_streams response"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Error receiving get_new_streams response"); goto error; } BT_ASSERT(ret_len == sizeof(rp)); @@ -1447,24 +1553,28 @@ enum lttng_live_iterator_status lttng_live_get_new_streams( status = LTTNG_LIVE_ITERATOR_STATUS_END; goto end; case LTTNG_VIEWER_NEW_STREAMS_ERR: - BT_COMP_LOGE("get_new_streams error"); + BT_COMP_LOGD("Received get_new_streams response: error"); goto error; default: - BT_COMP_LOGE("Unknown return code %u", be32toh(rp.status)); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Received get_new_streams response: Unknown:" + "return code %u", be32toh(rp.status)); goto error; } if (receive_streams(session, streams_count)) { + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Error receiving streams"); goto error; } end: return status; error: - if (lttng_live_graph_is_canceled(lttng_live)) { + if (lttng_live_graph_is_canceled(lttng_live_msg_iter)) { status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN; } else { status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; + BT_COMP_LOGE("Error receiving streams."); } return status; } @@ -1472,39 +1582,52 @@ error: BT_HIDDEN struct live_viewer_connection *live_viewer_connection_create( const char *url, bool in_query, - struct lttng_live_msg_iter *lttng_live_msg_iter) + struct lttng_live_msg_iter *lttng_live_msg_iter, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class, + bt_logging_level log_level) { struct live_viewer_connection *viewer_connection; viewer_connection = g_new0(struct live_viewer_connection, 1); - if (bt_socket_init(lttng_live_msg_iter->log_level) != 0) { + if (bt_socket_init(log_level) != 0) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Failed to init socket"); goto error; } - viewer_connection->log_level = lttng_live_msg_iter->log_level; - viewer_connection->self_comp = lttng_live_msg_iter->self_comp; - bt_object_init_shared(&viewer_connection->obj, connection_release); + viewer_connection->log_level = log_level; + + viewer_connection->self_comp = self_comp; + viewer_connection->self_comp_class = self_comp_class; + viewer_connection->control_sock = BT_INVALID_SOCKET; viewer_connection->port = -1; viewer_connection->in_query = in_query; viewer_connection->lttng_live_msg_iter = lttng_live_msg_iter; viewer_connection->url = g_string_new(url); if (!viewer_connection->url) { + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Failed to allocate URL buffer"); goto error; } BT_COMP_LOGI("Establishing connection to url \"%s\"...", url); if (lttng_live_connect_viewer(viewer_connection)) { - goto error_report; + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "Failed to establish connection: " + "url=\"%s\"", url); + goto error; } BT_COMP_LOGI("Connection to url \"%s\" is established", url); return viewer_connection; -error_report: - BT_COMP_LOGW("Failure to establish connection to url \"%s\"", url); error: - g_free(viewer_connection); + if (viewer_connection) { + live_viewer_connection_destroy(viewer_connection); + } + return NULL; } @@ -1513,18 +1636,33 @@ void live_viewer_connection_destroy( struct live_viewer_connection *viewer_connection) { BT_COMP_LOGI("Closing connection to url \"%s\"", viewer_connection->url->str); + + if (!viewer_connection) { + goto end; + } + lttng_live_disconnect_viewer(viewer_connection); - g_string_free(viewer_connection->url, true); + + if (viewer_connection->url) { + g_string_free(viewer_connection->url, true); + } + if (viewer_connection->relay_hostname) { g_string_free(viewer_connection->relay_hostname, true); } + if (viewer_connection->target_hostname) { g_string_free(viewer_connection->target_hostname, true); } + if (viewer_connection->session_name) { g_string_free(viewer_connection->session_name, true); } + g_free(viewer_connection); bt_socket_fini(); + +end: + return; }