[lttng-tools.git] / src / bin / lttng / utils.cpp

/*
 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#define _LGPL_SOURCE
#include <stdlib.h>
#include <ctype.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <inttypes.h>
#include <unistd.h>

#include <common/error.h>
#include <common/utils.h>
#include <common/defaults.h>

#include "conf.h"
#include "utils.h"
#include "command.h"

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)
{
	const char *path;
	char *session_name = NULL;

	/* Get path to config file */
	path = utils_get_home_dir();
	if (path == NULL) {
		goto error;
	}

	/* Get session name from config */
	session_name = quiet ? config_read_session_name_quiet(path) :
		config_read_session_name(path);
	if (session_name == NULL) {
		goto error;
	}

	DBG2("Config file path found: %s", path);
	DBG("Session name found: %s", session_name);
	return session_name;

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
 *
 *  List commands line by line. This is mostly for bash auto completion and to
 *  avoid difficult parsing.
 */
void list_commands(struct cmd_struct *commands, FILE *ofp)
{
	int i = 0;
	struct cmd_struct *cmd = NULL;

	cmd = &commands[i];
	while (cmd->name != NULL) {
		fprintf(ofp, "%s\n", cmd->name);
		i++;
		cmd = &commands[i];
	}
}

/*
 * list_cmd_options
 *
 * Prints a simple list of the options available to a command. This is intended
 * to be easily parsed for bash completion.
 */
void list_cmd_options(FILE *ofp, struct poptOption *options)
{
	int i;
	struct poptOption *option = NULL;

	for (i = 0; options[i].longName != NULL; i++) {
		option = &options[i];

		fprintf(ofp, "--%s\n", option->longName);

		if (isprint(option->shortName)) {
			fprintf(ofp, "-%c\n", option->shortName);
		}
	}
}

/*
 * Same as list_cmd_options, but for options specified for argpar.
 */
void list_cmd_options_argpar(FILE *ofp, const struct argpar_opt_descr *options)
{
	int i;

	for (i = 0; options[i].long_name != NULL; i++) {
		const struct argpar_opt_descr *option = &options[i];

		fprintf(ofp, "--%s\n", option->long_name);

		if (isprint(option->short_name)) {
			fprintf(ofp, "-%c\n", option->short_name);
		}
	}
}

/*
 * fls: returns the position of the most significant bit.
 * Returns 0 if no bit is set, else returns the position of the most
 * significant bit (from 1 to 32 on 32-bit, from 1 to 64 on 64-bit).
 */
#if defined(__i386) || defined(__x86_64)
static inline
unsigned int fls_u32(uint32_t x)
{
	int r;

	asm("bsrl %1,%0\n\t"
	    "jnz 1f\n\t"
	    "movl $-1,%0\n\t"
	    "1:\n\t"
	    : "=r" (r) : "rm" (x));
	return r + 1;
}
#define HAS_FLS_U32
#endif

#if defined(__x86_64) && defined(__LP64__)
static inline
unsigned int fls_u64(uint64_t x)
{
	long r;

	asm("bsrq %1,%0\n\t"
	    "jnz 1f\n\t"
	    "movq $-1,%0\n\t"
	    "1:\n\t"
	    : "=r" (r) : "rm" (x));
	return r + 1;
}
#define HAS_FLS_U64
#endif

#ifndef HAS_FLS_U64
static __attribute__((unused))
unsigned int fls_u64(uint64_t x)
{
	unsigned int r = 64;

	if (!x)
		return 0;

	if (!(x & 0xFFFFFFFF00000000ULL)) {
		x <<= 32;
		r -= 32;
	}
	if (!(x & 0xFFFF000000000000ULL)) {
		x <<= 16;
		r -= 16;
	}
	if (!(x & 0xFF00000000000000ULL)) {
		x <<= 8;
		r -= 8;
	}
	if (!(x & 0xF000000000000000ULL)) {
		x <<= 4;
		r -= 4;
	}
	if (!(x & 0xC000000000000000ULL)) {
		x <<= 2;
		r -= 2;
	}
	if (!(x & 0x8000000000000000ULL)) {
		x <<= 1;
		r -= 1;
	}
	return r;
}
#endif

#ifndef HAS_FLS_U32
static __attribute__((unused))
unsigned int fls_u32(uint32_t x)
{
	unsigned int r = 32;

	if (!x)
		return 0;
	if (!(x & 0xFFFF0000U)) {
		x <<= 16;
		r -= 16;
	}
	if (!(x & 0xFF000000U)) {
		x <<= 8;
		r -= 8;
	}
	if (!(x & 0xF0000000U)) {
		x <<= 4;
		r -= 4;
	}
	if (!(x & 0xC0000000U)) {
		x <<= 2;
		r -= 2;
	}
	if (!(x & 0x80000000U)) {
		x <<= 1;
		r -= 1;
	}
	return r;
}
#endif

static
unsigned int fls_ulong(unsigned long x)
{
#if (CAA_BITS_PER_LONG == 32)
	return fls_u32(x);
#else
	return fls_u64(x);
#endif
}

/*
 * Return the minimum order for which x <= (1UL << order).
 * Return -1 if x is 0.
 */
int get_count_order_u32(uint32_t x)
{
	if (!x)
		return -1;

	return fls_u32(x - 1);
}

/*
 * Return the minimum order for which x <= (1UL << order).
 * Return -1 if x is 0.
 */
int get_count_order_u64(uint64_t x)
{
	if (!x)
		return -1;

	return fls_u64(x - 1);
}

/*
 * Return the minimum order for which x <= (1UL << order).
 * Return -1 if x is 0.
 */
int get_count_order_ulong(unsigned long x)
{
	if (!x)
		return -1;

	return fls_ulong(x - 1);
}

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. */
		abort();
	}

	return str_event_type;
}

/*
 * 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 domain_count,
		bool include_agent_domains)
{
	int ret = 0;

	if (domain_count == 0) {
		ERR("Please specify a domain (--kernel/--userspace%s).",
				include_agent_domains ?
						"/--jul/--log4j/--python" :
						"");
		ret = -1;
	} else if (domain_count > 1) {
		ERR("Only one domain must be specified.");
		ret = -1;
	}

	return ret;
}

/*
 * Get the discarded events and lost packet counts.
 */
void print_session_stats(const char *session_name)
{
	char *str;
	const int ret = get_session_stats_str(session_name, &str);

	if (ret >= 0 && str) {
		MSG("%s", str);
		free(str);
	}
}

int get_session_stats_str(const char *session_name, char **out_str)
{
	int count, nb_domains, domain_idx, channel_idx, session_idx, ret;
	struct lttng_domain *domains = NULL;
	struct lttng_channel *channels = NULL;
	uint64_t discarded_events_total = 0, lost_packets_total = 0;
	struct lttng_session *sessions = NULL;
	const struct lttng_session *selected_session = NULL;
	char *stats_str = NULL;
	bool print_discarded_events = false, print_lost_packets = false;

	count = lttng_list_sessions(&sessions);
	if (count < 1) {
		ERR("Failed to retrieve session descriptions while printing session statistics.");
		ret = -1;
		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);
		ret = -1;
		goto end;
	}

	nb_domains = lttng_list_domains(session_name, &domains);
	if (nb_domains < 0) {
		ret = -1;
		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.");
			ret = -1;
			goto end;
		}

		free(channels);
		channels = NULL;
		count = lttng_list_channels(handle, &channels);
		for (channel_idx = 0; channel_idx < count; channel_idx++) {
			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);
	}

	print_discarded_events = discarded_events_total > 0 &&
				 !selected_session->snapshot_mode;
	print_lost_packets = lost_packets_total > 0 &&
			     !selected_session->snapshot_mode;

	if (print_discarded_events && print_lost_packets) {
		ret = asprintf(&stats_str,
				"Warning: %" PRIu64
				" events were discarded and %" PRIu64
				" packets were lost, please refer to "
				"the documentation on channel configuration.",
				discarded_events_total, lost_packets_total);
	} else if (print_discarded_events) {
		ret = asprintf(&stats_str,
				"Warning: %" PRIu64
				" events were discarded, please refer to "
				"the documentation on channel configuration.",
				discarded_events_total);
	} else if (print_lost_packets) {
		ret = asprintf(&stats_str,
				"Warning: %" PRIu64
				" packets were lost, please refer to "
				"the documentation on channel configuration.",
				lost_packets_total);
	} else {
		ret = 0;
	}

	if (ret < 0) {
		ERR("Failed to format lost packet and discarded events statistics");
	} else {
		*out_str = stats_str;
		ret = 0;
	}
end:
	free(sessions);
	free(channels);
	free(domains);
	return ret;
}

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);
	LTTNG_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:
	if (!printed_location) {
		MSG(" at an unknown location");
	}
	return ret;
}
Commit	Line	Data
f3ed775e	1	/*
ab5be9fa	2	* Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
f3ed775e	3	*
ab5be9fa	4	* SPDX-License-Identifier: GPL-2.0-only
f3ed775e	5	*
f3ed775e DG	6	*/
f3ed775e DG	7
6c1c0768	8	#define _LGPL_SOURCE
f3ed775e	9	#include <stdlib.h>
679b4943	10	#include <ctype.h>
3badf2bf	11	#include <limits.h>
8960e9cd DG	12	#include <sys/types.h>
	13	#include <sys/socket.h>
	14	#include <signal.h>
	15	#include <netinet/in.h>
	16	#include <arpa/inet.h>
20fb9e02	17	#include <inttypes.h>
4ba92f18	18	#include <unistd.h>
f3ed775e	19
db758600	20	#include <common/error.h>
feb0f3e5	21	#include <common/utils.h>
4ba92f18	22	#include <common/defaults.h>
f3ed775e	23
beb8c75a	24	#include "conf.h"
679b4943	25	#include "utils.h"
3c9bd23c	26	#include "command.h"
f3ed775e	27
4fd2697f FD	28	static const char *str_all = "ALL";
	29	static const char *str_tracepoint = "Tracepoint";
	30	static const char *str_syscall = "Syscall";
	31	static const char *str_probe = "Probe";
	32	static const char *str_userspace_probe = "Userspace Probe";
	33	static const char *str_function = "Function";
b9dfb167	34
1dac0189 PPM	35	static
1dac0189 PPM	36	char *_get_session_name(int quiet)
f3ed775e	37	{
4f00620d JG	38	const char *path;
4f00620d JG	39	char *session_name = NULL;
f3ed775e DG	40
f3ed775e DG	41	/* Get path to config file */
feb0f3e5	42	path = utils_get_home_dir();
f3ed775e DG	43	if (path == NULL) {
	44	goto error;
	45	}
	46
	47	/* Get session name from config */
1dac0189 PPM	48	session_name = quiet ? config_read_session_name_quiet(path) :
1dac0189 PPM	49	config_read_session_name(path);
f3ed775e	50	if (session_name == NULL) {
58a97671	51	goto error;
f3ed775e DG	52	}
f3ed775e DG	53
3183dbb0	54	DBG2("Config file path found: %s", path);
cd80958d	55	DBG("Session name found: %s", session_name);
f3ed775e	56	return session_name;
3183dbb0 DG	57
	58	error:
	59	return NULL;
f3ed775e	60	}
679b4943	61
1dac0189 PPM	62	/*
	63	* get_session_name
	64	*
	65	* Return allocated string with the session name found in the config
	66	* directory.
	67	*/
	68	char *get_session_name(void)
	69	{
	70	return _get_session_name(0);
	71	}
	72
	73	/*
	74	* get_session_name_quiet (no warnings/errors emitted)
	75	*
	76	* Return allocated string with the session name found in the config
	77	* directory.
	78	*/
	79	char *get_session_name_quiet(void)
	80	{
	81	return _get_session_name(1);
	82	}
	83
3c9bd23c SM	84	/*
	85	* list_commands
	86	*
	87	* List commands line by line. This is mostly for bash auto completion and to
	88	* avoid difficult parsing.
	89	*/
	90	void list_commands(struct cmd_struct commands, FILE ofp)
	91	{
	92	int i = 0;
	93	struct cmd_struct *cmd = NULL;
	94
	95	cmd = &commands[i];
	96	while (cmd->name != NULL) {
	97	fprintf(ofp, "%s\n", cmd->name);
	98	i++;
	99	cmd = &commands[i];
	100	}
	101	}
679b4943 SM	102
	103	/*
	104	* list_cmd_options
	105	*
	106	* Prints a simple list of the options available to a command. This is intended
	107	* to be easily parsed for bash completion.
	108	*/
	109	void list_cmd_options(FILE ofp, struct poptOption options)
	110	{
	111	int i;
	112	struct poptOption *option = NULL;
	113
	114	for (i = 0; options[i].longName != NULL; i++) {
	115	option = &options[i];
	116
	117	fprintf(ofp, "--%s\n", option->longName);
	118
	119	if (isprint(option->shortName)) {
	120	fprintf(ofp, "-%c\n", option->shortName);
	121	}
	122	}
	123	}
8ce58bad	124
b083f028 JR	125	/*
	126	* Same as list_cmd_options, but for options specified for argpar.
	127	*/
	128	void list_cmd_options_argpar(FILE ofp, const struct argpar_opt_descr options)
	129	{
	130	int i;
	131
	132	for (i = 0; options[i].long_name != NULL; i++) {
	133	const struct argpar_opt_descr *option = &options[i];
	134
	135	fprintf(ofp, "--%s\n", option->long_name);
	136
	137	if (isprint(option->short_name)) {
	138	fprintf(ofp, "-%c\n", option->short_name);
	139	}
	140	}
	141	}
	142
8ce58bad MD	143	/*
	144	* fls: returns the position of the most significant bit.
	145	* Returns 0 if no bit is set, else returns the position of the most
	146	* significant bit (from 1 to 32 on 32-bit, from 1 to 64 on 64-bit).
	147	*/
	148	#if defined(__i386) \|\| defined(__x86_64)
	149	static inline
	150	unsigned int fls_u32(uint32_t x)
	151	{
	152	int r;
	153
	154	asm("bsrl %1,%0\n\t"
	155	"jnz 1f\n\t"
	156	"movl $-1,%0\n\t"
	157	"1:\n\t"
	158	: "=r" (r) : "rm" (x));
	159	return r + 1;
	160	}
	161	#define HAS_FLS_U32
	162	#endif
	163
a1e4ab8b	164	#if defined(__x86_64) && defined(__LP64__)
8ce58bad MD	165	static inline
	166	unsigned int fls_u64(uint64_t x)
	167	{
	168	long r;
	169
	170	asm("bsrq %1,%0\n\t"
	171	"jnz 1f\n\t"
	172	"movq $-1,%0\n\t"
	173	"1:\n\t"
	174	: "=r" (r) : "rm" (x));
	175	return r + 1;
	176	}
	177	#define HAS_FLS_U64
	178	#endif
	179
	180	#ifndef HAS_FLS_U64
	181	static __attribute__((unused))
	182	unsigned int fls_u64(uint64_t x)
	183	{
	184	unsigned int r = 64;
	185
	186	if (!x)
	187	return 0;
	188
	189	if (!(x & 0xFFFFFFFF00000000ULL)) {
	190	x <<= 32;
	191	r -= 32;
	192	}
	193	if (!(x & 0xFFFF000000000000ULL)) {
	194	x <<= 16;
	195	r -= 16;
	196	}
	197	if (!(x & 0xFF00000000000000ULL)) {
	198	x <<= 8;
	199	r -= 8;
	200	}
	201	if (!(x & 0xF000000000000000ULL)) {
	202	x <<= 4;
	203	r -= 4;
	204	}
	205	if (!(x & 0xC000000000000000ULL)) {
	206	x <<= 2;
	207	r -= 2;
	208	}
	209	if (!(x & 0x8000000000000000ULL)) {
	210	x <<= 1;
	211	r -= 1;
	212	}
	213	return r;
	214	}
	215	#endif
	216
	217	#ifndef HAS_FLS_U32
	218	static __attribute__((unused))
	219	unsigned int fls_u32(uint32_t x)
	220	{
	221	unsigned int r = 32;
	222
	223	if (!x)
	224	return 0;
	225	if (!(x & 0xFFFF0000U)) {
	226	x <<= 16;
	227	r -= 16;
	228	}
229	if (!(x & 0xFF000000U)) {
230	x <<= 8;
231	r -= 8;
232	}
233	if (!(x & 0xF0000000U)) {
234	x <<= 4;
235	r -= 4;
236	}
237	if (!(x & 0xC0000000U)) {
238	x <<= 2;
239	r -= 2;
240	}
241	if (!(x & 0x80000000U)) {
242	x <<= 1;
243	r -= 1;
244	}
245	return r;
246	}
247	#endif
248
249	static
250	unsigned int fls_ulong(unsigned long x)
251	{
252	#if (CAA_BITS_PER_LONG == 32)
253	return fls_u32(x);
254	#else
255	return fls_u64(x);
256	#endif
257	}
258
259	/*
260	* Return the minimum order for which x <= (1UL << order).
261	* Return -1 if x is 0.
262	*/
263	int get_count_order_u32(uint32_t x)
264	{
265	if (!x)
266	return -1;
267
268	return fls_u32(x - 1);
269	}
270
271	/*
272	* Return the minimum order for which x <= (1UL << order).
273	* Return -1 if x is 0.
274	*/
275	int get_count_order_u64(uint64_t x)
276	{
277	if (!x)
278	return -1;
279
280	return fls_u64(x - 1);
281	}
282
283	/*
284	* Return the minimum order for which x <= (1UL << order).
285	* Return -1 if x is 0.
286	*/
287	int get_count_order_ulong(unsigned long x)
288	{
289	if (!x)
290	return -1;
291
292	return fls_ulong(x - 1);
293	}
b9dfb167	294
4fd2697f FD	295	const char *get_event_type_str(enum lttng_event_type type)
	296	{
	297	const char *str_event_type;
	298
	299	switch (type) {
	300	case LTTNG_EVENT_ALL:
	301	str_event_type = str_all;
	302	break;
	303	case LTTNG_EVENT_TRACEPOINT:
	304	str_event_type = str_tracepoint;
	305	break;
	306	case LTTNG_EVENT_SYSCALL:
	307	str_event_type = str_syscall;
	308	break;
	309	case LTTNG_EVENT_PROBE:
	310	str_event_type = str_probe;
	311	break;
	312	case LTTNG_EVENT_USERSPACE_PROBE:
	313	str_event_type = str_userspace_probe;
	314	break;
	315	case LTTNG_EVENT_FUNCTION:
	316	str_event_type = str_function;
	317	break;
	318	default:
	319	/* Should not have an unknown event type or else define it. */
a0377dfe	320	abort();
4fd2697f FD	321	}
	322
	323	return str_event_type;
	324	}
	325
8960e9cd DG	326	/*
	327	* Spawn a lttng relayd daemon by forking and execv.
	328	*/
	329	int spawn_relayd(const char *pathname, int port)
	330	{
	331	int ret = 0;
	332	pid_t pid;
	333	char url[255];
	334
	335	if (!port) {
	336	port = DEFAULT_NETWORK_VIEWER_PORT;
	337	}
	338
	339	ret = snprintf(url, sizeof(url), "tcp://localhost:%d", port);
	340	if (ret < 0) {
	341	goto end;
	342	}
	343
	344	MSG("Spawning a relayd daemon");
	345	pid = fork();
	346	if (pid == 0) {
	347	/*
	348	* Spawn session daemon and tell
	349	* it to signal us when ready.
	350	*/
	351	execlp(pathname, "lttng-relayd", "-L", url, NULL);
	352	/* execlp only returns if error happened */
	353	if (errno == ENOENT) {
	354	ERR("No relayd found. Use --relayd-path.");
	355	} else {
6f04ed72	356	PERROR("execlp");
8960e9cd DG	357	}
	358	kill(getppid(), SIGTERM); /* wake parent */
	359	exit(EXIT_FAILURE);
	360	} else if (pid > 0) {
	361	goto end;
	362	} else {
6f04ed72	363	PERROR("fork");
8960e9cd DG	364	ret = -1;
	365	goto end;
	366	}
	367
	368	end:
	369	return ret;
	370	}
	371
	372	/*
	373	* Check if relayd is alive.
	374	*
	375	* Return 1 if found else 0 if NOT found. Negative value on error.
	376	*/
	377	int check_relayd(void)
	378	{
	379	int ret, fd;
	380	struct sockaddr_in sin;
	381
	382	fd = socket(AF_INET, SOCK_STREAM, 0);
	383	if (fd < 0) {
6f04ed72	384	PERROR("socket check relayd");
dd02a4c1 DG	385	ret = -1;
dd02a4c1 DG	386	goto error_socket;
8960e9cd DG	387	}
	388
	389	sin.sin_family = AF_INET;
	390	sin.sin_port = htons(DEFAULT_NETWORK_VIEWER_PORT);
	391	ret = inet_pton(sin.sin_family, "127.0.0.1", &sin.sin_addr);
	392	if (ret < 1) {
6f04ed72	393	PERROR("inet_pton check relayd");
dd02a4c1	394	ret = -1;
8960e9cd DG	395	goto error;
	396	}
	397
	398	/*
	399	* A successful connect means the relayd exists thus returning 0 else a
	400	* negative value means it does NOT exists.
	401	*/
56efeab3	402	ret = connect(fd, (struct sockaddr *) &sin, sizeof(sin));
8960e9cd DG	403	if (ret < 0) {
	404	/* Not found. */
	405	ret = 0;
	406	} else {
	407	/* Already spawned. */
	408	ret = 1;
	409	}
	410
8960e9cd	411	error:
dd02a4c1	412	if (close(fd) < 0) {
6f04ed72	413	PERROR("close relayd fd");
dd02a4c1 DG	414	}
	415	error_socket:
	416	return ret;
8960e9cd	417	}
3ecec76a	418
3533d06b JG	419	int print_missing_or_multiple_domains(unsigned int domain_count,
3533d06b JG	420	bool include_agent_domains)
3ecec76a PP	421	{
	422	int ret = 0;
	423
3533d06b JG	424	if (domain_count == 0) {
	425	ERR("Please specify a domain (--kernel/--userspace%s).",
	426	include_agent_domains ?
	427	"/--jul/--log4j/--python" :
	428	"");
3ecec76a	429	ret = -1;
3533d06b JG	430	} else if (domain_count > 1) {
3533d06b JG	431	ERR("Only one domain must be specified.");
3ecec76a PP	432	ret = -1;
	433	}
	434
	435	return ret;
	436	}
20fb9e02 JD	437
	438	/*
	439	* Get the discarded events and lost packet counts.
	440	*/
	441	void print_session_stats(const char *session_name)
	442	{
58f237ca JG	443	char *str;
	444	const int ret = get_session_stats_str(session_name, &str);
	445
	446	if (ret >= 0 && str) {
	447	MSG("%s", str);
	448	free(str);
	449	}
	450	}
	451
	452	int get_session_stats_str(const char session_name, char *out_str)
	453	{
	454	int count, nb_domains, domain_idx, channel_idx, session_idx, ret;
092545c3 SM	455	struct lttng_domain *domains = NULL;
092545c3 SM	456	struct lttng_channel *channels = NULL;
3e8f2238 JG	457	uint64_t discarded_events_total = 0, lost_packets_total = 0;
	458	struct lttng_session *sessions = NULL;
	459	const struct lttng_session *selected_session = NULL;
58f237ca JG	460	char *stats_str = NULL;
58f237ca JG	461	bool print_discarded_events = false, print_lost_packets = false;
3e8f2238 JG	462
	463	count = lttng_list_sessions(&sessions);
	464	if (count < 1) {
	465	ERR("Failed to retrieve session descriptions while printing session statistics.");
58f237ca	466	ret = -1;
3e8f2238 JG	467	goto end;
	468	}
	469
	470	/* Identify the currently-selected sessions. */
	471	for (session_idx = 0; session_idx < count; session_idx++) {
	472	if (!strcmp(session_name, sessions[session_idx].name)) {
	473	selected_session = &sessions[session_idx];
	474	break;
	475	}
	476	}
	477	if (!selected_session) {
	478	ERR("Failed to retrieve session \"%s\" description while printing session statistics.", session_name);
58f237ca	479	ret = -1;
3e8f2238 JG	480	goto end;
3e8f2238 JG	481	}
20fb9e02 JD	482
	483	nb_domains = lttng_list_domains(session_name, &domains);
	484	if (nb_domains < 0) {
58f237ca	485	ret = -1;
20fb9e02 JD	486	goto end;
	487	}
	488	for (domain_idx = 0; domain_idx < nb_domains; domain_idx++) {
	489	struct lttng_handle *handle = lttng_create_handle(session_name,
	490	&domains[domain_idx]);
	491
	492	if (!handle) {
3e8f2238	493	ERR("Failed to create session handle while printing session statistics.");
58f237ca	494	ret = -1;
20fb9e02 JD	495	goto end;
	496	}
	497
092545c3 SM	498	free(channels);
092545c3 SM	499	channels = NULL;
20fb9e02 JD	500	count = lttng_list_channels(handle, &channels);
20fb9e02 JD	501	for (channel_idx = 0; channel_idx < count; channel_idx++) {
3e8f2238	502	uint64_t discarded_events = 0, lost_packets = 0;
20fb9e02 JD	503	struct lttng_channel *channel = &channels[channel_idx];
	504
	505	ret = lttng_channel_get_discarded_event_count(channel,
3e8f2238	506	&discarded_events);
20fb9e02 JD	507	if (ret) {
	508	ERR("Failed to retrieve discarded event count from channel %s",
	509	channel->name);
	510	}
	511
	512	ret = lttng_channel_get_lost_packet_count(channel,
3e8f2238	513	&lost_packets);
20fb9e02 JD	514	if (ret) {
	515	ERR("Failed to retrieve lost packet count from channel %s",
	516	channel->name);
	517	}
	518
3e8f2238 JG	519	discarded_events_total += discarded_events;
3e8f2238 JG	520	lost_packets_total += lost_packets;
20fb9e02 JD	521	}
	522	lttng_destroy_handle(handle);
	523	}
58f237ca JG	524
	525	print_discarded_events = discarded_events_total > 0 &&
	526	!selected_session->snapshot_mode;
	527	print_lost_packets = lost_packets_total > 0 &&
	528	!selected_session->snapshot_mode;
	529
	530	if (print_discarded_events && print_lost_packets) {
	531	ret = asprintf(&stats_str,
	532	"Warning: %" PRIu64
	533	" events were discarded and %" PRIu64
	534	" packets were lost, please refer to "
	535	"the documentation on channel configuration.",
	536	discarded_events_total, lost_packets_total);
	537	} else if (print_discarded_events) {
	538	ret = asprintf(&stats_str,
	539	"Warning: %" PRIu64
	540	" events were discarded, please refer to "
20fb9e02	541	"the documentation on channel configuration.",
3e8f2238	542	discarded_events_total);
58f237ca JG	543	} else if (print_lost_packets) {
	544	ret = asprintf(&stats_str,
	545	"Warning: %" PRIu64
	546	" packets were lost, please refer to "
20fb9e02	547	"the documentation on channel configuration.",
3e8f2238	548	lost_packets_total);
58f237ca JG	549	} else {
58f237ca JG	550	ret = 0;
20fb9e02 JD	551	}
20fb9e02 JD	552
58f237ca JG	553	if (ret < 0) {
	554	ERR("Failed to format lost packet and discarded events statistics");
	555	} else {
	556	*out_str = stats_str;
	557	ret = 0;
	558	}
20fb9e02	559	end:
3e8f2238	560	free(sessions);
092545c3 SM	561	free(channels);
092545c3 SM	562	free(domains);
58f237ca	563	return ret;
20fb9e02	564	}
4ba92f18	565
4fc83d94	566	int show_cmd_help(const char cmd_name, const char help_msg)
4ba92f18 PP	567	{
	568	int ret;
	569	char page_name[32];
	570
	571	ret = sprintf(page_name, "lttng-%s", cmd_name);
a0377dfe	572	LTTNG_ASSERT(ret > 0 && ret < 32);
4fc83d94 PP	573	ret = utils_show_help(1, page_name, help_msg);
	574	if (ret && !help_msg) {
	575	ERR("Cannot view man page `lttng-%s(1)`", cmd_name);
	576	perror("exec");
	577	}
4ba92f18	578
4fc83d94	579	return ret;
4ba92f18	580	}
bbbfd849 JG	581
	582	int print_trace_archive_location(
	583	const struct lttng_trace_archive_location *location,
	584	const char *session_name)
	585	{
	586	int ret = 0;
	587	enum lttng_trace_archive_location_type location_type;
	588	enum lttng_trace_archive_location_status status;
	589	bool printed_location = false;
	590
	591	location_type = lttng_trace_archive_location_get_type(location);
	592
	593	_MSG("Trace chunk archive for session %s is now readable",
	594	session_name);
	595	switch (location_type) {
	596	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	597	{
	598	const char *absolute_path;
	599
	600	status = lttng_trace_archive_location_local_get_absolute_path(
	601	location, &absolute_path);
	602	if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
	603	ret = -1;
	604	goto end;
	605	}
	606	MSG(" at %s", absolute_path);
	607	printed_location = true;
	608	break;
	609	}
	610	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	611	{
	612	uint16_t control_port, data_port;
	613	const char host, relative_path, *protocol_str;
	614	enum lttng_trace_archive_location_relay_protocol_type protocol;
	615
	616	/* Fetch all relay location parameters. */
	617	status = lttng_trace_archive_location_relay_get_protocol_type(
	618	location, &protocol);
	619	if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
	620	ret = -1;
	621	goto end;
	622	}
	623
	624	status = lttng_trace_archive_location_relay_get_host(
	625	location, &host);
	626	if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
	627	ret = -1;
	628	goto end;
	629	}
	630
	631	status = lttng_trace_archive_location_relay_get_control_port(
	632	location, &control_port);
	633	if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
	634	ret = -1;
	635	goto end;
	636	}
	637
	638	status = lttng_trace_archive_location_relay_get_data_port(
	639	location, &data_port);
	640	if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
	641	ret = -1;
	642	goto end;
	643	}
	644
645	status = lttng_trace_archive_location_relay_get_relative_path(
646	location, &relative_path);
647	if (status != LTTNG_TRACE_ARCHIVE_LOCATION_STATUS_OK) {
648	ret = -1;
649	goto end;
650	}
651
652	switch (protocol) {
653	case LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP:
654	protocol_str = "tcp";
655	break;
656	default:
657	protocol_str = "unknown";
658	break;
659	}
660
661	MSG(" on relay %s://%s/%s [control port %" PRIu16 ", data port %"
662	PRIu16 "]", protocol_str, host,
663	relative_path, control_port, data_port);
664	printed_location = true;
665	break;
666	}
667	default:
668	break;
669	}
670	end:
671	if (!printed_location) {
672	MSG(" at an unknown location");
673	}
674	return ret;
675	}