X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Futils.c;h=e88166a438a06f98177d7a722ce5561b111b0617;hp=802e0971bd6785c2853e0ffeb1d88b0edc03a5a4;hb=ab5be9fa2eb5ba9600a82cd18fd3cfcbac69169a;hpb=20fb9e0220fe6ca9d6fd52e4e3e41b898452a8f1 diff --git a/src/bin/lttng/utils.c b/src/bin/lttng/utils.c index 802e0971b..e88166a43 100644 --- a/src/bin/lttng/utils.c +++ b/src/bin/lttng/utils.c @@ -1,18 +1,8 @@ /* - * Copyright (c) 2011 David Goulet + * Copyright (C) 2011 David Goulet * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License, version 2 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _LGPL_SOURCE @@ -26,9 +16,11 @@ #include #include #include +#include #include #include +#include #include "conf.h" #include "utils.h" @@ -39,11 +31,18 @@ static const char *str_ust = "UST"; static const char *str_jul = "JUL"; static const char *str_log4j = "LOG4J"; static const char *str_python = "Python"; +static const char *str_all = "ALL"; +static const char *str_tracepoint = "Tracepoint"; +static const char *str_syscall = "Syscall"; +static const char *str_probe = "Probe"; +static const char *str_userspace_probe = "Userspace Probe"; +static const char *str_function = "Function"; static char *_get_session_name(int quiet) { - char *path, *session_name = NULL; + const char *path; + char *session_name = NULL; /* Get path to config file */ path = utils_get_home_dir(); @@ -150,7 +149,7 @@ unsigned int fls_u32(uint32_t x) #define HAS_FLS_U32 #endif -#if defined(__x86_64) +#if defined(__x86_64) && defined(__LP64__) static inline unsigned int fls_u64(uint64_t x) { @@ -309,6 +308,37 @@ const char *get_domain_str(enum lttng_domain_type domain) return str_dom; } +const char *get_event_type_str(enum lttng_event_type type) +{ + const char *str_event_type; + + switch (type) { + case LTTNG_EVENT_ALL: + str_event_type = str_all; + break; + case LTTNG_EVENT_TRACEPOINT: + str_event_type = str_tracepoint; + break; + case LTTNG_EVENT_SYSCALL: + str_event_type = str_syscall; + break; + case LTTNG_EVENT_PROBE: + str_event_type = str_probe; + break; + case LTTNG_EVENT_USERSPACE_PROBE: + str_event_type = str_userspace_probe; + break; + case LTTNG_EVENT_FUNCTION: + str_event_type = str_function; + break; + default: + /* Should not have an unknown event type or else define it. */ + assert(0); + } + + return str_event_type; +} + /* * Spawn a lttng relayd daemon by forking and execv. */ @@ -385,7 +415,7 @@ int check_relayd(void) * A successful connect means the relayd exists thus returning 0 else a * negative value means it does NOT exists. */ - ret = connect(fd, &sin, sizeof(sin)); + ret = connect(fd, (struct sockaddr *) &sin, sizeof(sin)); if (ret < 0) { /* Not found. */ ret = 0; @@ -422,10 +452,30 @@ int print_missing_or_multiple_domains(unsigned int sum) */ void print_session_stats(const char *session_name) { - int count, nb_domains, domain_idx, channel_idx; + int count, nb_domains, domain_idx, channel_idx, session_idx; struct lttng_domain *domains; struct lttng_channel *channels; - uint64_t discarded_total = 0, lost_total = 0; + 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) { @@ -436,46 +486,157 @@ void print_session_stats(const char *session_name) &domains[domain_idx]); if (!handle) { - ERR("Failed to create session handle while printing session stats."); + 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 = 0, lost = 0; + uint64_t discarded_events = 0, lost_packets = 0; struct lttng_channel *channel = &channels[channel_idx]; ret = lttng_channel_get_discarded_event_count(channel, - &discarded); + &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); + &lost_packets); if (ret) { ERR("Failed to retrieve lost packet count from channel %s", channel->name); } - discarded_total += discarded; - lost_total += lost; + discarded_events_total += discarded_events; + lost_packets_total += lost_packets; } lttng_destroy_handle(handle); } - if (discarded_total > 0) { + if (discarded_events_total > 0 && !selected_session->snapshot_mode) { MSG("[warning] %" PRIu64 " events discarded, please refer to " "the documentation on channel configuration.", - discarded_total); + discarded_events_total); } - if (lost_total > 0) { + if (lost_packets_total > 0 && !selected_session->snapshot_mode) { MSG("[warning] %" PRIu64 " packets lost, please refer to " "the documentation on channel configuration.", - lost_total); + 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; +} + +int print_trace_archive_location( + const struct lttng_trace_archive_location *location, + const char *session_name) +{ + int ret = 0; + enum lttng_trace_archive_location_type location_type; + enum lttng_trace_archive_location_status status; + bool printed_location = false; + + location_type = lttng_trace_archive_location_get_type(location); + + _MSG("Trace chunk archive for session %s is now readable", + session_name); + switch (location_type) { + case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL: + { + const char *absolute_path; + + status = lttng_trace_archive_location_local_get_absolute_path( + location, &absolute_path); + if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) { + ret = -1; + goto end; + } + MSG(" at %s", absolute_path); + printed_location = true; + break; } + case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY: + { + uint16_t control_port, data_port; + const char *host, *relative_path, *protocol_str; + enum lttng_trace_archive_location_relay_protocol_type protocol; + + /* Fetch all relay location parameters. */ + status = lttng_trace_archive_location_relay_get_protocol_type( + location, &protocol); + if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) { + ret = -1; + goto end; + } + + status = lttng_trace_archive_location_relay_get_host( + location, &host); + if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) { + ret = -1; + goto end; + } + + status = lttng_trace_archive_location_relay_get_control_port( + location, &control_port); + if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) { + ret = -1; + goto end; + } + status = lttng_trace_archive_location_relay_get_data_port( + location, &data_port); + if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) { + ret = -1; + goto end; + } + + status = lttng_trace_archive_location_relay_get_relative_path( + location, &relative_path); + if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) { + ret = -1; + goto end; + } + + switch (protocol) { + case LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP: + protocol_str = "tcp"; + break; + default: + protocol_str = "unknown"; + break; + } + + MSG(" on relay %s://%s/%s [control port %" PRIu16 ", data port %" + PRIu16 "]", protocol_str, host, + relative_path, control_port, data_port); + printed_location = true; + break; + } + default: + break; + } end: - return; + if (!printed_location) { + MSG(" at an unknown location"); + } + return ret; }