X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng%2Futils.c;h=52a2440e7dc486e24b94d85fb94aea7bda3feefa;hb=a18d95449bcab62b0ed21ea8b93798c2e31bdf62;hp=556728da23773f19935d0ea8b484a1b2cf901664;hpb=b9dfb1671626365019a72318fb131eb321244245;p=lttng-tools.git diff --git a/src/bin/lttng/utils.c b/src/bin/lttng/utils.c index 556728da2..52a2440e7 100644 --- a/src/bin/lttng/utils.c +++ b/src/bin/lttng/utils.c @@ -15,14 +15,22 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include #include +#include +#include +#include +#include +#include +#include +#include #include #include +#include #include "conf.h" #include "utils.h" @@ -31,14 +39,11 @@ static const char *str_kernel = "Kernel"; static const char *str_ust = "UST"; static const char *str_jul = "JUL"; +static const char *str_log4j = "LOG4J"; +static const char *str_python = "Python"; -/* - * get_session_name - * - * Return allocated string with the session name found in the config - * directory. - */ -char *get_session_name(void) +static +char *_get_session_name(int quiet) { char *path, *session_name = NULL; @@ -49,7 +54,8 @@ char *get_session_name(void) } /* Get session name from config */ - session_name = config_read_session_name(path); + session_name = quiet ? config_read_session_name_quiet(path) : + config_read_session_name(path); if (session_name == NULL) { goto error; } @@ -62,6 +68,28 @@ error: return NULL; } +/* + * get_session_name + * + * Return allocated string with the session name found in the config + * directory. + */ +char *get_session_name(void) +{ + return _get_session_name(0); +} + +/* + * get_session_name_quiet (no warnings/errors emitted) + * + * Return allocated string with the session name found in the config + * directory. + */ +char *get_session_name_quiet(void) +{ + return _get_session_name(1); +} + /* * list_commands * @@ -269,6 +297,12 @@ const char *get_domain_str(enum lttng_domain_type domain) case LTTNG_DOMAIN_JUL: str_dom = str_jul; break; + case LTTNG_DOMAIN_LOG4J: + str_dom = str_log4j; + break; + case LTTNG_DOMAIN_PYTHON: + str_dom = str_python; + break; default: /* Should not have an unknown domain or else define it. */ assert(0); @@ -276,3 +310,210 @@ const char *get_domain_str(enum lttng_domain_type domain) return str_dom; } + +/* + * Spawn a lttng relayd daemon by forking and execv. + */ +int spawn_relayd(const char *pathname, int port) +{ + int ret = 0; + pid_t pid; + char url[255]; + + if (!port) { + port = DEFAULT_NETWORK_VIEWER_PORT; + } + + ret = snprintf(url, sizeof(url), "tcp://localhost:%d", port); + if (ret < 0) { + goto end; + } + + MSG("Spawning a relayd daemon"); + pid = fork(); + if (pid == 0) { + /* + * Spawn session daemon and tell + * it to signal us when ready. + */ + execlp(pathname, "lttng-relayd", "-L", url, NULL); + /* execlp only returns if error happened */ + if (errno == ENOENT) { + ERR("No relayd found. Use --relayd-path."); + } else { + PERROR("execlp"); + } + kill(getppid(), SIGTERM); /* wake parent */ + exit(EXIT_FAILURE); + } else if (pid > 0) { + goto end; + } else { + PERROR("fork"); + ret = -1; + goto end; + } + +end: + return ret; +} + +/* + * Check if relayd is alive. + * + * Return 1 if found else 0 if NOT found. Negative value on error. + */ +int check_relayd(void) +{ + int ret, fd; + struct sockaddr_in sin; + + fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) { + PERROR("socket check relayd"); + ret = -1; + goto error_socket; + } + + sin.sin_family = AF_INET; + sin.sin_port = htons(DEFAULT_NETWORK_VIEWER_PORT); + ret = inet_pton(sin.sin_family, "127.0.0.1", &sin.sin_addr); + if (ret < 1) { + PERROR("inet_pton check relayd"); + ret = -1; + goto error; + } + + /* + * A successful connect means the relayd exists thus returning 0 else a + * negative value means it does NOT exists. + */ + ret = connect(fd, (struct sockaddr *) &sin, sizeof(sin)); + if (ret < 0) { + /* Not found. */ + ret = 0; + } else { + /* Already spawned. */ + ret = 1; + } + +error: + if (close(fd) < 0) { + PERROR("close relayd fd"); + } +error_socket: + return ret; +} + +int print_missing_or_multiple_domains(unsigned int sum) +{ + int ret = 0; + + if (sum == 0) { + ERR("Please specify a domain (-k/-u/-j)."); + ret = -1; + } else if (sum > 1) { + ERR("Multiple domains specified."); + ret = -1; + } + + return ret; +} + +/* + * Get the discarded events and lost packet counts. + */ +void print_session_stats(const char *session_name) +{ + int count, nb_domains, domain_idx, channel_idx, session_idx; + struct lttng_domain *domains; + struct lttng_channel *channels; + uint64_t discarded_events_total = 0, lost_packets_total = 0; + struct lttng_session *sessions = NULL; + const struct lttng_session *selected_session = NULL; + + count = lttng_list_sessions(&sessions); + if (count < 1) { + ERR("Failed to retrieve session descriptions while printing session statistics."); + goto end; + } + + /* Identify the currently-selected sessions. */ + for (session_idx = 0; session_idx < count; session_idx++) { + if (!strcmp(session_name, sessions[session_idx].name)) { + selected_session = &sessions[session_idx]; + break; + } + } + if (!selected_session) { + ERR("Failed to retrieve session \"%s\" description while printing session statistics.", session_name); + goto end; + } + + nb_domains = lttng_list_domains(session_name, &domains); + if (nb_domains < 0) { + goto end; + } + for (domain_idx = 0; domain_idx < nb_domains; domain_idx++) { + struct lttng_handle *handle = lttng_create_handle(session_name, + &domains[domain_idx]); + + if (!handle) { + ERR("Failed to create session handle while printing session statistics."); + goto end; + } + + count = lttng_list_channels(handle, &channels); + for (channel_idx = 0; channel_idx < count; channel_idx++) { + int ret; + uint64_t discarded_events = 0, lost_packets = 0; + struct lttng_channel *channel = &channels[channel_idx]; + + ret = lttng_channel_get_discarded_event_count(channel, + &discarded_events); + if (ret) { + ERR("Failed to retrieve discarded event count from channel %s", + channel->name); + } + + ret = lttng_channel_get_lost_packet_count(channel, + &lost_packets); + if (ret) { + ERR("Failed to retrieve lost packet count from channel %s", + channel->name); + } + + discarded_events_total += discarded_events; + lost_packets_total += lost_packets; + } + lttng_destroy_handle(handle); + } + if (discarded_events_total > 0 && !selected_session->snapshot_mode) { + MSG("[warning] %" PRIu64 " events discarded, please refer to " + "the documentation on channel configuration.", + discarded_events_total); + } + if (lost_packets_total > 0 && !selected_session->snapshot_mode) { + MSG("[warning] %" PRIu64 " packets lost, please refer to " + "the documentation on channel configuration.", + lost_packets_total); + } + +end: + free(sessions); +} + +int show_cmd_help(const char *cmd_name, const char *help_msg) +{ + int ret; + char page_name[32]; + + ret = sprintf(page_name, "lttng-%s", cmd_name); + assert(ret > 0 && ret < 32); + ret = utils_show_help(1, page_name, help_msg); + if (ret && !help_msg) { + ERR("Cannot view man page `lttng-%s(1)`", cmd_name); + perror("exec"); + } + + return ret; +}