[lttng-ust.git] / ustctl / ustctl.c

/* Copyright (C) 2009  Pierre-Marc Fournier
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <stdlib.h>
#include <fcntl.h>

#include "ust/ustcmd.h"
#include "usterr.h"

enum command {
	CREATE_TRACE=1000,
	ALLOC_TRACE,
	START_TRACE,
	STOP_TRACE,
	DESTROY_TRACE,
	LIST_MARKERS,
	LIST_TRACE_EVENTS,
	ENABLE_MARKER,
	DISABLE_MARKER,
	GET_ONLINE_PIDS,
	SET_SUBBUF_SIZE,
	SET_SUBBUF_NUM,
	GET_SUBBUF_SIZE,
	GET_SUBBUF_NUM,
	GET_SOCK_PATH,
	SET_SOCK_PATH,
	FORCE_SWITCH,
	UNKNOWN
};

struct ust_opts {
	enum command cmd;
	pid_t *pids;
	char *regex;
};

char *progname = NULL;

void usage(void)
{
	fprintf(stderr, "usage: %s COMMAND PIDs...\n", progname);
	fprintf(stderr, "\nControl the tracing of a process that supports LTTng Userspace Tracing.\n\
\n\
Commands:\n\
    --create-trace\t\t\tCreate trace\n\
    --alloc-trace\t\t\tAlloc trace\n\
    --start-trace\t\t\tStart tracing\n\
    --stop-trace\t\t\tStop tracing\n\
    --destroy-trace\t\t\tDestroy the trace\n\
    --set-subbuf-size \"CHANNEL/bytes\"\tSet the size of subbuffers per channel\n\
    --set-subbuf-num \"CHANNEL/n\"\tSet the number of subbuffers per channel\n\
    --set-sock-path\t\t\tSet the path of the daemon socket\n\
    --get-subbuf-size \"CHANNEL\"\t\tGet the size of subbuffers per channel\n\
    --get-subbuf-num \"CHANNEL\"\t\tGet the number of subbuffers per channel\n\
    --get-sock-path\t\t\tGet the path of the daemon socket\n\
    --enable-marker \"CHANNEL/MARKER\"\tEnable a marker\n\
    --disable-marker \"CHANNEL/MARKER\"\tDisable a marker\n\
    --list-markers\t\t\tList the markers of the process, their\n\t\t\t\t\t  state and format string\n\
    --list-trace-events\t\t\tList the trace-events of the process\n\
    --force-switch\t\t\tForce a subbuffer switch\n\
\
");
}

int parse_opts_long(int argc, char **argv, struct ust_opts *opts)
{
	int c;

	opts->pids = NULL;
	opts->regex = NULL;

	while (1) {
		int option_index = 0;
		static struct option long_options[] = {
			{ "create-trace", 0, 0, CREATE_TRACE },
			{ "alloc-trace", 0, 0, ALLOC_TRACE },
			{ "start-trace", 0, 0, START_TRACE },
			{ "stop-trace", 0, 0, STOP_TRACE },
			{ "destroy-trace", 0, 0, DESTROY_TRACE },
			{ "list-markers", 0, 0, LIST_MARKERS },
			{ "list-trace-events", 0, 0, LIST_TRACE_EVENTS},
			{ "enable-marker", 1, 0, ENABLE_MARKER },
			{ "disable-marker", 1, 0, DISABLE_MARKER },
			{ "help", 0, 0, 'h' },
			{ "online-pids", 0, 0, GET_ONLINE_PIDS },
			{ "set-subbuf-size", 1, 0, SET_SUBBUF_SIZE },
			{ "set-subbuf-num", 1, 0, SET_SUBBUF_NUM },
			{ "get-subbuf-size", 1, 0, GET_SUBBUF_SIZE },
			{ "get-subbuf-num", 1, 0, GET_SUBBUF_NUM },
			{ "get-sock-path", 0, 0, GET_SOCK_PATH },
			{ "set-sock-path", 1, 0, SET_SOCK_PATH },
			{ "force-switch", 0, 0, FORCE_SWITCH },
			{ 0, 0, 0, 0 }
		};

		c = getopt_long(argc, argv, "h", long_options, &option_index);
		if (c == -1)
			break;

		if(c >= 1000)
			opts->cmd = c;

		switch (c) {
		case 0:
			printf("option %s", long_options[option_index].name);
			if (optarg)
				printf(" with arg %s", optarg);
			printf("\n");
			break;

		case ENABLE_MARKER:
		case DISABLE_MARKER:
		case SET_SUBBUF_SIZE:
		case SET_SUBBUF_NUM:
		case GET_SUBBUF_SIZE:
		case GET_SUBBUF_NUM:
		case SET_SOCK_PATH:
			opts->regex = strdup(optarg);
			break;

		case 'h':
			usage();
			exit(0);

		case '?':
			fprintf(stderr, "Invalid argument\n\n");
			usage();
			exit(1);
		}
	}

	if (argc - optind > 0 && opts->cmd != GET_ONLINE_PIDS) {
		int i;
		int pididx=0;
		opts->pids = zmalloc((argc-optind+1) * sizeof(pid_t));

		for(i=optind; i<argc; i++) {
			/* don't take any chances, use a long long */
			long long tmp;
			char *endptr;
			tmp = strtoull(argv[i], &endptr, 10);
			if(*endptr != '\0') {
				ERR("The pid \"%s\" is invalid.", argv[i]);
				return 1;
			}
			opts->pids[pididx++] = (pid_t) tmp;
		}
		opts->pids[pididx] = -1;
	}

	return 0;
}

static int scan_ch_marker(const char *channel_marker, char **channel,
			char **marker)
{
	int result;

	*channel = NULL;
	*marker = NULL;

	result = sscanf(channel_marker, "%a[^/]/%as", channel, marker);
	if (result != 2) {
		if (errno) {
			PERROR("Failed to read channel and marker names");
		} else {
			ERR("Failed to parse marker and channel names");
		}
		if (*channel) {
			free(*channel);
		}
		if (*marker) {
			free(*marker);
		}
		return -1;
	} else {
		return 0;
	}
}

static int scan_ch_and_num(const char *ch_num, char **channel, unsigned int *num)
{
	int result;

	*channel = NULL;

	result = sscanf(ch_num, "%a[^/]/%u", channel, num);
	if (result != 2) {
		if (errno) {
			PERROR("Failed to parse channel and number");
		} else {
			ERR("Failed to parse channel and number");
		}
		if (*channel) {
			free(*channel);
		}
		return -1;
	}
}

char *trace = "auto";

int main(int argc, char *argv[])
{
	pid_t *pidit;
	int result;
	int retval = EXIT_SUCCESS;
	char *tmp;
	struct ust_opts opts;

	progname = argv[0];

	if(argc <= 1) {
		fprintf(stderr, "No operation specified.\n");
		usage();
		exit(EXIT_FAILURE);
	}

	result = parse_opts_long(argc, argv, &opts);
	if(result) {
		fprintf(stderr, "\n");
		usage();
		exit(EXIT_FAILURE);
	}

	if(opts.pids == NULL && opts.cmd != GET_ONLINE_PIDS) {
		fprintf(stderr, "No pid specified.\n");
		usage();
		exit(EXIT_FAILURE);
	}
	if(opts.cmd == UNKNOWN) {
		fprintf(stderr, "No command specified.\n");
		usage();
		exit(EXIT_FAILURE);
	}
	if (opts.cmd == GET_ONLINE_PIDS) {
		pid_t *pp = ustcmd_get_online_pids();
		unsigned int i = 0;

		if (pp) {
			while (pp[i] != 0) {
				printf("%u\n", (unsigned int) pp[i]);
				++i;
			}
			free(pp);
		}

		exit(EXIT_SUCCESS);
	}

	pidit = opts.pids;
	struct marker_status *cmsf = NULL;
	struct trace_event_status *tes = NULL;
	unsigned int i = 0;

	while(*pidit != -1) {
		switch (opts.cmd) {
			case CREATE_TRACE:
				result = ustcmd_create_trace(trace, *pidit);
				if (result) {
					ERR("error while trying to create trace with PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}
				break;

			case START_TRACE:
				result = ustcmd_start_trace(trace, *pidit);
				if (result) {
					ERR("error while trying to for trace with PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}
				break;

			case STOP_TRACE:
				result = ustcmd_stop_trace(trace, *pidit);
				if (result) {
					ERR("error while trying to stop trace for PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}
				break;

			case DESTROY_TRACE:
				result = ustcmd_destroy_trace(trace, *pidit);
				if (result) {
					ERR("error while trying to destroy trace with PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}
				break;

			case LIST_MARKERS:
				cmsf = NULL;
				if (ustcmd_get_cmsf(&cmsf, *pidit)) {
					ERR("error while trying to list markers for PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}
				i = 0;
				while (cmsf[i].channel != NULL) {
					printf("{PID: %u, channel/marker: %s/%s, "
						"state: %u, fmt: %s}\n",
						(unsigned int) *pidit,
						cmsf[i].channel,
						cmsf[i].marker,
						cmsf[i].state,
						cmsf[i].fs);
					++i;
				}
				ustcmd_free_cmsf(cmsf);
				break;

			case LIST_TRACE_EVENTS:
				tes = NULL;
				if (ustcmd_get_tes(&tes, *pidit)) {
					ERR("error while trying to list "
					    "trace_events for PID %u\n",
					    (unsigned int) *pidit);
					break;
				}
				i = 0;
				while (tes[i].name != NULL) {
					printf("{PID: %u, trace_event: %s}\n",
					       (unsigned int) *pidit,
					       tes[i].name);
					++i;
				}
				ustcmd_free_tes(tes);

				break;
			case ENABLE_MARKER:
				if (opts.regex) {
					char *channel, *marker;

					if (scan_ch_marker(opts.regex,
							   &channel, &marker)) {
						retval = EXIT_FAILURE;
						break;
					}
					if (ustcmd_set_marker_state(trace, channel, marker, 1, *pidit)) {
						PERROR("error while trying to enable marker %s with PID %u",
						       opts.regex, (unsigned int) *pidit);
						retval = EXIT_FAILURE;
					}
				}

				break;
			case DISABLE_MARKER:
				if (opts.regex) {
					char *channel, *marker;

					if (scan_ch_marker(opts.regex,
							   &channel, &marker)) {
						retval = EXIT_FAILURE;
						break;
					}
					if (ustcmd_set_marker_state(trace, channel, marker, 0, *pidit)) {
						ERR("error while trying to disable marker %s with PID %u\n",
								opts.regex, (unsigned int) *pidit);
						retval = EXIT_FAILURE;
					}
				}
				break;

			case SET_SUBBUF_SIZE:
				if (opts.regex) {
					char *channel;
					unsigned int size;
					if (scan_ch_and_num(opts.regex, &channel, &size)) {
						retval = EXIT_FAILURE;
						break;
					}

					if (ustcmd_set_subbuf_size(trace, channel, size, *pidit)) {
						ERR("error while trying to set the size of subbuffers with PID %u\n",
								(unsigned int) *pidit);
						retval = EXIT_FAILURE;
					}
				}
				break;

			case SET_SUBBUF_NUM:
				if (opts.regex) {
					char *channel;
					unsigned int num;
					if (scan_ch_and_num(opts.regex, &channel, &num)) {
						retval = EXIT_FAILURE;
						break;
					}

					if (num < 2) {
						ERR("Subbuffer count should be greater or equal to 2");
						retval = EXIT_FAILURE;
						break;
					}
					if (ustcmd_set_subbuf_num(trace, channel, num, *pidit)) {
						ERR("error while trying to set the number of subbuffers with PID %u\n",
								(unsigned int) *pidit);
						retval = EXIT_FAILURE;
					}
				}
				break;

			case GET_SUBBUF_SIZE:
				result = ustcmd_get_subbuf_size(trace, opts.regex, *pidit);
				if (result == -1) {
					ERR("error while trying to get_subuf_size with PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}

				printf("the size of subbufers is %d\n", result);
				break;

			case GET_SUBBUF_NUM:
				result = ustcmd_get_subbuf_num(trace, opts.regex, *pidit);
				if (result == -1) {
					ERR("error while trying to get_subuf_num with PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}

				printf("the number of subbufers is %d\n", result);
				break;

			case ALLOC_TRACE:
				result = ustcmd_alloc_trace(trace, *pidit);
				if (result) {
					ERR("error while trying to alloc trace with PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
				}
				break;

			case GET_SOCK_PATH:
				result = ustcmd_get_sock_path(&tmp, *pidit);
				if (result) {
					ERR("error while trying to get sock path for PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
					break;
				}
				printf("the socket path is %s\n", tmp);
				free(tmp);
				break;

			case SET_SOCK_PATH:
				result = ustcmd_set_sock_path(opts.regex, *pidit);
				if (result) {
					ERR("error while trying to set sock path for PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
				}
				break;

			case FORCE_SWITCH:
				result = ustcmd_force_switch(*pidit);
				if (result) {
					ERR("error while trying to force switch for PID %u\n", (unsigned int) *pidit);
					retval = EXIT_FAILURE;
				}
				break;

			default:
				ERR("unknown command\n");
				retval = EXIT_FAILURE;
				break;
		}

		pidit++;
	}

	if (opts.pids != NULL) {
		free(opts.pids);
	}
	if (opts.regex != NULL) {
		free(opts.regex);
	}

	return retval;
}
Commit	Line	Data
c39c72ee PMF	1	/* Copyright (C) 2009 Pierre-Marc Fournier
	2	*
	3	* This library is free software; you can redistribute it and/or
	4	* modify it under the terms of the GNU Lesser General Public
	5	* License as published by the Free Software Foundation; either
	6	* version 2.1 of the License, or (at your option) any later version.
	7	*
	8	* This library is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* Lesser General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public
	14	* License along with this library; if not, write to the Free Software
	15	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
872037bb PMF	18	#define _GNU_SOURCE
872037bb PMF	19	#include <stdio.h>
fbd8191b PMF	20	#include <unistd.h>
	21	#include <getopt.h>
	22	#include <stdlib.h>
fbd8191b	23	#include <fcntl.h>
fbd8191b	24
d6c9f207	25	#include "ust/ustcmd.h"
2028e7fd	26	#include "usterr.h"
ae937656 PP	27
ae937656 PP	28	enum command {
b0a5a08b PMF	29	CREATE_TRACE=1000,
b0a5a08b PMF	30	ALLOC_TRACE,
ae937656 PP	31	START_TRACE,
ae937656 PP	32	STOP_TRACE,
b0a5a08b	33	DESTROY_TRACE,
ae937656	34	LIST_MARKERS,
a3adfb05	35	LIST_TRACE_EVENTS,
ae937656 PP	36	ENABLE_MARKER,
	37	DISABLE_MARKER,
	38	GET_ONLINE_PIDS,
763f41e5 DS	39	SET_SUBBUF_SIZE,
763f41e5 DS	40	SET_SUBBUF_NUM,
e77b8e8e DS	41	GET_SUBBUF_SIZE,
e77b8e8e DS	42	GET_SUBBUF_NUM,
b2fb2f91 AH	43	GET_SOCK_PATH,
b2fb2f91 AH	44	SET_SOCK_PATH,
b9318b35	45	FORCE_SWITCH,
ae937656	46	UNKNOWN
ef290fca	47	};
fbd8191b	48
52c51a47	49	struct ust_opts {
ae937656	50	enum command cmd;
52c51a47	51	pid_t *pids;
08230db7	52	char *regex;
52c51a47 PMF	53	};
52c51a47 PMF	54
fd2fb4f9 PMF	55	char *progname = NULL;
	56
	57	void usage(void)
	58	{
ae937656	59	fprintf(stderr, "usage: %s COMMAND PIDs...\n", progname);
fd2fb4f9 PMF	60	fprintf(stderr, "\nControl the tracing of a process that supports LTTng Userspace Tracing.\n\
	61	\n\
	62	Commands:\n\
62ec620f	63	--create-trace\t\t\tCreate trace\n\
4ed9f99d	64	--alloc-trace\t\t\tAlloc trace\n\
fd2fb4f9 PMF	65	--start-trace\t\t\tStart tracing\n\
	66	--stop-trace\t\t\tStop tracing\n\
	67	--destroy-trace\t\t\tDestroy the trace\n\
763f41e5 DS	68	--set-subbuf-size \"CHANNEL/bytes\"\tSet the size of subbuffers per channel\n\
763f41e5 DS	69	--set-subbuf-num \"CHANNEL/n\"\tSet the number of subbuffers per channel\n\
b2fb2f91	70	--set-sock-path\t\t\tSet the path of the daemon socket\n\
e77b8e8e DS	71	--get-subbuf-size \"CHANNEL\"\t\tGet the size of subbuffers per channel\n\
e77b8e8e DS	72	--get-subbuf-num \"CHANNEL\"\t\tGet the number of subbuffers per channel\n\
b2fb2f91	73	--get-sock-path\t\t\tGet the path of the daemon socket\n\
ae937656 PP	74	--enable-marker \"CHANNEL/MARKER\"\tEnable a marker\n\
	75	--disable-marker \"CHANNEL/MARKER\"\tDisable a marker\n\
	76	--list-markers\t\t\tList the markers of the process, their\n\t\t\t\t\t state and format string\n\
a3adfb05	77	--list-trace-events\t\t\tList the trace-events of the process\n\
b9318b35	78	--force-switch\t\t\tForce a subbuffer switch\n\
ae937656	79	\
fd2fb4f9 PMF	80	");
	81	}
	82
52c51a47	83	int parse_opts_long(int argc, char *argv, struct ust_opts opts)
fbd8191b	84	{
52c51a47	85	int c;
52c51a47	86
52c51a47	87	opts->pids = NULL;
ef290fca	88	opts->regex = NULL;
52c51a47 PMF	89
52c51a47 PMF	90	while (1) {
52c51a47 PMF	91	int option_index = 0;
52c51a47 PMF	92	static struct option long_options[] = {
b0a5a08b PMF	93	{ "create-trace", 0, 0, CREATE_TRACE },
	94	{ "alloc-trace", 0, 0, ALLOC_TRACE },
	95	{ "start-trace", 0, 0, START_TRACE },
	96	{ "stop-trace", 0, 0, STOP_TRACE },
	97	{ "destroy-trace", 0, 0, DESTROY_TRACE },
	98	{ "list-markers", 0, 0, LIST_MARKERS },
a3adfb05	99	{ "list-trace-events", 0, 0, LIST_TRACE_EVENTS},
b0a5a08b PMF	100	{ "enable-marker", 1, 0, ENABLE_MARKER },
	101	{ "disable-marker", 1, 0, DISABLE_MARKER },
	102	{ "help", 0, 0, 'h' },
	103	{ "online-pids", 0, 0, GET_ONLINE_PIDS },
	104	{ "set-subbuf-size", 1, 0, SET_SUBBUF_SIZE },
	105	{ "set-subbuf-num", 1, 0, SET_SUBBUF_NUM },
e77b8e8e DS	106	{ "get-subbuf-size", 1, 0, GET_SUBBUF_SIZE },
e77b8e8e DS	107	{ "get-subbuf-num", 1, 0, GET_SUBBUF_NUM },
b2fb2f91 AH	108	{ "get-sock-path", 0, 0, GET_SOCK_PATH },
b2fb2f91 AH	109	{ "set-sock-path", 1, 0, SET_SOCK_PATH },
b9318b35	110	{ "force-switch", 0, 0, FORCE_SWITCH },
b0a5a08b	111	{ 0, 0, 0, 0 }
52c51a47 PMF	112	};
52c51a47 PMF	113
d373b5cd	114	c = getopt_long(argc, argv, "h", long_options, &option_index);
52c51a47 PMF	115	if (c == -1)
	116	break;
	117
b0a5a08b PMF	118	if(c >= 1000)
	119	opts->cmd = c;
	120
52c51a47 PMF	121	switch (c) {
	122	case 0:
	123	printf("option %s", long_options[option_index].name);
	124	if (optarg)
	125	printf(" with arg %s", optarg);
	126	printf("\n");
	127	break;
	128
b0a5a08b PMF	129	case ENABLE_MARKER:
	130	case DISABLE_MARKER:
	131	case SET_SUBBUF_SIZE:
	132	case SET_SUBBUF_NUM:
e77b8e8e DS	133	case GET_SUBBUF_SIZE:
e77b8e8e DS	134	case GET_SUBBUF_NUM:
b2fb2f91	135	case SET_SOCK_PATH:
ef290fca	136	opts->regex = strdup(optarg);
ae937656	137	break;
b0a5a08b	138
d373b5cd PMF	139	case 'h':
	140	usage();
	141	exit(0);
b0a5a08b PMF	142
	143	case '?':
	144	fprintf(stderr, "Invalid argument\n\n");
	145	usage();
	146	exit(1);
fbd8191b PMF	147	}
	148	}
	149
772030fe	150	if (argc - optind > 0 && opts->cmd != GET_ONLINE_PIDS) {
52c51a47 PMF	151	int i;
52c51a47 PMF	152	int pididx=0;
7032c7d3	153	opts->pids = zmalloc((argc-optind+1) * sizeof(pid_t));
fbd8191b	154
52c51a47	155	for(i=optind; i<argc; i++) {
08230db7 PMF	156	/* don't take any chances, use a long long */
	157	long long tmp;
	158	char *endptr;
	159	tmp = strtoull(argv[i], &endptr, 10);
	160	if(*endptr != '\0') {
	161	ERR("The pid \"%s\" is invalid.", argv[i]);
	162	return 1;
	163	}
	164	opts->pids[pididx++] = (pid_t) tmp;
52c51a47 PMF	165	}
52c51a47 PMF	166	opts->pids[pididx] = -1;
fbd8191b PMF	167	}
fbd8191b PMF	168
52c51a47 PMF	169	return 0;
52c51a47 PMF	170	}
fbd8191b	171
72098143 NC	172	static int scan_ch_marker(const char channel_marker, char *channel,
	173	char **marker)
	174	{
	175	int result;
	176
	177	*channel = NULL;
	178	*marker = NULL;
	179
	180	result = sscanf(channel_marker, "%a[^/]/%as", channel, marker);
	181	if (result != 2) {
	182	if (errno) {
	183	PERROR("Failed to read channel and marker names");
	184	} else {
	185	ERR("Failed to parse marker and channel names");
	186	}
	187	if (*channel) {
	188	free(*channel);
	189	}
	190	if (*marker) {
	191	free(*marker);
	192	}
	193	return -1;
	194	} else {
	195	return 0;
	196	}
	197	}
	198
	199	static int scan_ch_and_num(const char ch_num, char channel, unsigned int num)
	200	{
	201	int result;
	202
	203	*channel = NULL;
	204
	205	result = sscanf(ch_num, "%a[^/]/%u", channel, num);
	206	if (result != 2) {
	207	if (errno) {
	208	PERROR("Failed to parse channel and number");
	209	} else {
	210	ERR("Failed to parse channel and number");
	211	}
	212	if (*channel) {
	213	free(*channel);
	214	}
	215	return -1;
	216	}
	217	}
	218
d89b8191 NC	219	char *trace = "auto";
d89b8191 NC	220
fbd8191b PMF	221	int main(int argc, char *argv[])
fbd8191b PMF	222	{
52c51a47	223	pid_t *pidit;
52c51a47	224	int result;
1e620c53	225	int retval = EXIT_SUCCESS;
b2fb2f91	226	char *tmp;
52c51a47	227	struct ust_opts opts;
fbd8191b	228
52c51a47	229	progname = argv[0];
fbd8191b	230
52c51a47 PMF	231	if(argc <= 1) {
	232	fprintf(stderr, "No operation specified.\n");
	233	usage();
	234	exit(EXIT_FAILURE);
	235	}
	236
	237	result = parse_opts_long(argc, argv, &opts);
	238	if(result) {
08230db7	239	fprintf(stderr, "\n");
52c51a47 PMF	240	usage();
	241	exit(EXIT_FAILURE);
	242	}
	243
ae937656	244	if(opts.pids == NULL && opts.cmd != GET_ONLINE_PIDS) {
52c51a47 PMF	245	fprintf(stderr, "No pid specified.\n");
	246	usage();
	247	exit(EXIT_FAILURE);
	248	}
ae937656	249	if(opts.cmd == UNKNOWN) {
52c51a47 PMF	250	fprintf(stderr, "No command specified.\n");
	251	usage();
	252	exit(EXIT_FAILURE);
	253	}
ae937656	254	if (opts.cmd == GET_ONLINE_PIDS) {
08230db7	255	pid_t *pp = ustcmd_get_online_pids();
ae937656	256	unsigned int i = 0;
52c51a47	257
ae937656 PP	258	if (pp) {
	259	while (pp[i] != 0) {
	260	printf("%u\n", (unsigned int) pp[i]);
	261	++i;
	262	}
	263	free(pp);
52c51a47	264	}
ef290fca	265
ae937656 PP	266	exit(EXIT_SUCCESS);
ae937656 PP	267	}
52c51a47	268
ae937656	269	pidit = opts.pids;
08230db7	270	struct marker_status *cmsf = NULL;
a3adfb05 NC	271	struct trace_event_status *tes = NULL;
a3adfb05 NC	272	unsigned int i = 0;
ef290fca	273
ae937656 PP	274	while(*pidit != -1) {
ae937656 PP	275	switch (opts.cmd) {
62ec620f	276	case CREATE_TRACE:
d89b8191	277	result = ustcmd_create_trace(trace, *pidit);
62ec620f PMF	278	if (result) {
62ec620f PMF	279	ERR("error while trying to create trace with PID %u\n", (unsigned int) *pidit);
1e620c53	280	retval = EXIT_FAILURE;
62ec620f PMF	281	break;
	282	}
	283	break;
	284
ae937656	285	case START_TRACE:
d89b8191	286	result = ustcmd_start_trace(trace, *pidit);
08230db7 PMF	287	if (result) {
08230db7 PMF	288	ERR("error while trying to for trace with PID %u\n", (unsigned int) *pidit);
1e620c53	289	retval = EXIT_FAILURE;
08230db7 PMF	290	break;
08230db7 PMF	291	}
ae937656	292	break;
ef290fca	293
ae937656	294	case STOP_TRACE:
d89b8191	295	result = ustcmd_stop_trace(trace, *pidit);
08230db7 PMF	296	if (result) {
08230db7 PMF	297	ERR("error while trying to stop trace for PID %u\n", (unsigned int) *pidit);
1e620c53	298	retval = EXIT_FAILURE;
08230db7 PMF	299	break;
08230db7 PMF	300	}
ae937656	301	break;
ef290fca	302
b0a5a08b	303	case DESTROY_TRACE:
d89b8191	304	result = ustcmd_destroy_trace(trace, *pidit);
08230db7 PMF	305	if (result) {
08230db7 PMF	306	ERR("error while trying to destroy trace with PID %u\n", (unsigned int) *pidit);
1e620c53	307	retval = EXIT_FAILURE;
08230db7 PMF	308	break;
08230db7 PMF	309	}
ae937656	310	break;
ef290fca	311
ae937656	312	case LIST_MARKERS:
08230db7 PMF	313	cmsf = NULL;
08230db7 PMF	314	if (ustcmd_get_cmsf(&cmsf, *pidit)) {
1e620c53 DG	315	ERR("error while trying to list markers for PID %u\n", (unsigned int) *pidit);
1e620c53 DG	316	retval = EXIT_FAILURE;
08230db7 PMF	317	break;
08230db7 PMF	318	}
a3adfb05	319	i = 0;
08230db7 PMF	320	while (cmsf[i].channel != NULL) {
08230db7 PMF	321	printf("{PID: %u, channel/marker: %s/%s, "
264f6231	322	"state: %u, fmt: %s}\n",
08230db7 PMF	323	(unsigned int) *pidit,
	324	cmsf[i].channel,
	325	cmsf[i].marker,
	326	cmsf[i].state,
	327	cmsf[i].fs);
	328	++i;
	329	}
	330	ustcmd_free_cmsf(cmsf);
ae937656	331	break;
ef290fca	332
a3adfb05 NC	333	case LIST_TRACE_EVENTS:
	334	tes = NULL;
	335	if (ustcmd_get_tes(&tes, *pidit)) {
	336	ERR("error while trying to list "
	337	"trace_events for PID %u\n",
	338	(unsigned int) *pidit);
	339	break;
	340	}
	341	i = 0;
	342	while (tes[i].name != NULL) {
	343	printf("{PID: %u, trace_event: %s}\n",
	344	(unsigned int) *pidit,
	345	tes[i].name);
	346	++i;
	347	}
	348	ustcmd_free_tes(tes);
	349
	350	break;
ae937656	351	case ENABLE_MARKER:
1e620c53	352	if (opts.regex) {
72098143 NC	353	char channel, marker;
	354
	355	if (scan_ch_marker(opts.regex,
	356	&channel, &marker)) {
	357	retval = EXIT_FAILURE;
	358	break;
	359	}
d89b8191	360	if (ustcmd_set_marker_state(trace, channel, marker, 1, *pidit)) {
72098143 NC	361	PERROR("error while trying to enable marker %s with PID %u",
72098143 NC	362	opts.regex, (unsigned int) *pidit);
1e620c53 DG	363	retval = EXIT_FAILURE;
	364	}
	365	}
72098143	366
ee648b8f	367	break;
ae937656	368	case DISABLE_MARKER:
1e620c53	369	if (opts.regex) {
72098143 NC	370	char channel, marker;
	371
	372	if (scan_ch_marker(opts.regex,
	373	&channel, &marker)) {
	374	retval = EXIT_FAILURE;
	375	break;
	376	}
d89b8191	377	if (ustcmd_set_marker_state(trace, channel, marker, 0, *pidit)) {
1e620c53 DG	378	ERR("error while trying to disable marker %s with PID %u\n",
	379	opts.regex, (unsigned int) *pidit);
	380	retval = EXIT_FAILURE;
	381	}
	382	}
ee648b8f	383	break;
ef290fca	384
763f41e5	385	case SET_SUBBUF_SIZE:
1e620c53	386	if (opts.regex) {
72098143 NC	387	char *channel;
	388	unsigned int size;
	389	if (scan_ch_and_num(opts.regex, &channel, &size)) {
	390	retval = EXIT_FAILURE;
	391	break;
	392	}
	393
d89b8191	394	if (ustcmd_set_subbuf_size(trace, channel, size, *pidit)) {
1e620c53 DG	395	ERR("error while trying to set the size of subbuffers with PID %u\n",
	396	(unsigned int) *pidit);
	397	retval = EXIT_FAILURE;
	398	}
	399	}
763f41e5 DS	400	break;
	401
	402	case SET_SUBBUF_NUM:
1e620c53	403	if (opts.regex) {
72098143 NC	404	char *channel;
	405	unsigned int num;
	406	if (scan_ch_and_num(opts.regex, &channel, &num)) {
	407	retval = EXIT_FAILURE;
	408	break;
	409	}
	410
	411	if (num < 2) {
	412	ERR("Subbuffer count should be greater or equal to 2");
	413	retval = EXIT_FAILURE;
	414	break;
	415	}
d89b8191	416	if (ustcmd_set_subbuf_num(trace, channel, num, *pidit)) {
1e620c53 DG	417	ERR("error while trying to set the number of subbuffers with PID %u\n",
	418	(unsigned int) *pidit);
	419	retval = EXIT_FAILURE;
	420	}
	421	}
763f41e5 DS	422	break;
763f41e5 DS	423
e77b8e8e	424	case GET_SUBBUF_SIZE:
d89b8191	425	result = ustcmd_get_subbuf_size(trace, opts.regex, *pidit);
e77b8e8e DS	426	if (result == -1) {
e77b8e8e DS	427	ERR("error while trying to get_subuf_size with PID %u\n", (unsigned int) *pidit);
1e620c53	428	retval = EXIT_FAILURE;
e77b8e8e DS	429	break;
	430	}
	431
	432	printf("the size of subbufers is %d\n", result);
	433	break;
	434
	435	case GET_SUBBUF_NUM:
d89b8191	436	result = ustcmd_get_subbuf_num(trace, opts.regex, *pidit);
e77b8e8e DS	437	if (result == -1) {
e77b8e8e DS	438	ERR("error while trying to get_subuf_num with PID %u\n", (unsigned int) *pidit);
1e620c53	439	retval = EXIT_FAILURE;
e77b8e8e DS	440	break;
	441	}
	442
	443	printf("the number of subbufers is %d\n", result);
	444	break;
	445
763f41e5	446	case ALLOC_TRACE:
d89b8191	447	result = ustcmd_alloc_trace(trace, *pidit);
763f41e5 DS	448	if (result) {
763f41e5 DS	449	ERR("error while trying to alloc trace with PID %u\n", (unsigned int) *pidit);
1e620c53	450	retval = EXIT_FAILURE;
763f41e5 DS	451	}
	452	break;
	453
b2fb2f91 AH	454	case GET_SOCK_PATH:
	455	result = ustcmd_get_sock_path(&tmp, *pidit);
	456	if (result) {
	457	ERR("error while trying to get sock path for PID %u\n", (unsigned int) *pidit);
1e620c53	458	retval = EXIT_FAILURE;
b2fb2f91 AH	459	break;
	460	}
	461	printf("the socket path is %s\n", tmp);
	462	free(tmp);
	463	break;
	464
	465	case SET_SOCK_PATH:
	466	result = ustcmd_set_sock_path(opts.regex, *pidit);
	467	if (result) {
	468	ERR("error while trying to set sock path for PID %u\n", (unsigned int) *pidit);
1e620c53	469	retval = EXIT_FAILURE;
b2fb2f91 AH	470	}
	471	break;
	472
b9318b35 AH	473	case FORCE_SWITCH:
	474	result = ustcmd_force_switch(*pidit);
	475	if (result) {
	476	ERR("error while trying to force switch for PID %u\n", (unsigned int) *pidit);
1e620c53	477	retval = EXIT_FAILURE;
b9318b35 AH	478	}
	479	break;
	480
ae937656	481	default:
08230db7	482	ERR("unknown command\n");
1e620c53 DG	483	retval = EXIT_FAILURE;
1e620c53 DG	484	break;
ae937656	485	}
ef290fca	486
52c51a47 PMF	487	pidit++;
52c51a47 PMF	488	}
82b1a169	489
ef290fca PMF	490	if (opts.pids != NULL) {
	491	free(opts.pids);
	492	}
	493	if (opts.regex != NULL) {
	494	free(opts.regex);
ae937656	495	}
fbd8191b	496
1e620c53	497	return retval;
fbd8191b	498	}
ae937656	499