[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 "ustcomm.h"
#include "ustcmd.h"
#include "usterr.h"

enum command {
	CREATE_TRACE=1000,
	ALLOC_TRACE,
	START_TRACE,
	STOP_TRACE,
	DESTROY_TRACE,
	LIST_MARKERS,
	ENABLE_MARKER,
	DISABLE_MARKER,
	GET_ONLINE_PIDS,
	SET_SUBBUF_SIZE,
	SET_SUBBUF_NUM,
	GET_SUBBUF_SIZE,
	GET_SUBBUF_NUM,
	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\
    --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\
    --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\
\
");
}

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 },
			{ "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 },
			{ 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:
			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 = malloc((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;
}

int main(int argc, char *argv[])
{
	pid_t *pidit;
	int result;
	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;

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

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

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

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

			case LIST_MARKERS:
				cmsf = NULL;
				if (ustcmd_get_cmsf(&cmsf, *pidit)) {
					fprintf(stderr,
						"error while trying to list markers for"
						" PID %u\n", (unsigned int) *pidit);
					break;
				}
				unsigned int 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 ENABLE_MARKER:
				if(opts.regex)
					ustcmd_set_marker_state(opts.regex, 1, *pidit);
				break;
			case DISABLE_MARKER:
				if(opts.regex)
					ustcmd_set_marker_state(opts.regex, 0, *pidit);
				break;

			case SET_SUBBUF_SIZE:
				ustcmd_set_subbuf_size(opts.regex, *pidit);
				break;

			case SET_SUBBUF_NUM:
				ustcmd_set_subbuf_num(opts.regex, *pidit);
				break;

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

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

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

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

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

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

		pidit++;
	}

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

	return 0;
}
Commit	Line	Data
	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
	18	#define _GNU_SOURCE
	19	#include <stdio.h>
	20	#include <unistd.h>
	21	#include <getopt.h>
	22	#include <stdlib.h>
	23	#include <fcntl.h>
	24
	25	#include "ustcomm.h"
	26	#include "ustcmd.h"
	27	#include "usterr.h"
	28
	29	enum command {
	30	CREATE_TRACE=1000,
	31	ALLOC_TRACE,
	32	START_TRACE,
	33	STOP_TRACE,
	34	DESTROY_TRACE,
	35	LIST_MARKERS,
	36	ENABLE_MARKER,
	37	DISABLE_MARKER,
	38	GET_ONLINE_PIDS,
	39	SET_SUBBUF_SIZE,
	40	SET_SUBBUF_NUM,
	41	GET_SUBBUF_SIZE,
	42	GET_SUBBUF_NUM,
	43	UNKNOWN
	44	};
	45
	46	struct ust_opts {
	47	enum command cmd;
	48	pid_t *pids;
	49	char *regex;
	50	};
	51
	52	char *progname = NULL;
	53
	54	void usage(void)
	55	{
	56	fprintf(stderr, "usage: %s COMMAND PIDs...\n", progname);
	57	fprintf(stderr, "\nControl the tracing of a process that supports LTTng Userspace Tracing.\n\
	58	\n\
	59	Commands:\n\
	60	--create-trace\t\t\tCreate trace\n\
	61	--alloc-trace\t\t\tAlloc trace\n\
	62	--start-trace\t\t\tStart tracing\n\
	63	--stop-trace\t\t\tStop tracing\n\
	64	--destroy-trace\t\t\tDestroy the trace\n\
	65	--set-subbuf-size \"CHANNEL/bytes\"\tSet the size of subbuffers per channel\n\
	66	--set-subbuf-num \"CHANNEL/n\"\tSet the number of subbuffers per channel\n\
	67	--get-subbuf-size \"CHANNEL\"\t\tGet the size of subbuffers per channel\n\
	68	--get-subbuf-num \"CHANNEL\"\t\tGet the number of subbuffers per channel\n\
	69	--enable-marker \"CHANNEL/MARKER\"\tEnable a marker\n\
	70	--disable-marker \"CHANNEL/MARKER\"\tDisable a marker\n\
	71	--list-markers\t\t\tList the markers of the process, their\n\t\t\t\t\t state and format string\n\
	72	\
	73	");
	74	}
	75
	76	int parse_opts_long(int argc, char *argv, struct ust_opts opts)
	77	{
	78	int c;
	79
	80	opts->pids = NULL;
	81	opts->regex = NULL;
	82
	83	while (1) {
	84	int option_index = 0;
	85	static struct option long_options[] = {
	86	{ "create-trace", 0, 0, CREATE_TRACE },
	87	{ "alloc-trace", 0, 0, ALLOC_TRACE },
	88	{ "start-trace", 0, 0, START_TRACE },
	89	{ "stop-trace", 0, 0, STOP_TRACE },
	90	{ "destroy-trace", 0, 0, DESTROY_TRACE },
	91	{ "list-markers", 0, 0, LIST_MARKERS },
	92	{ "enable-marker", 1, 0, ENABLE_MARKER },
	93	{ "disable-marker", 1, 0, DISABLE_MARKER },
	94	{ "help", 0, 0, 'h' },
	95	{ "online-pids", 0, 0, GET_ONLINE_PIDS },
	96	{ "set-subbuf-size", 1, 0, SET_SUBBUF_SIZE },
	97	{ "set-subbuf-num", 1, 0, SET_SUBBUF_NUM },
	98	{ "get-subbuf-size", 1, 0, GET_SUBBUF_SIZE },
	99	{ "get-subbuf-num", 1, 0, GET_SUBBUF_NUM },
	100	{ 0, 0, 0, 0 }
	101	};
	102
	103	c = getopt_long(argc, argv, "h", long_options, &option_index);
	104	if (c == -1)
	105	break;
	106
	107	if(c >= 1000)
	108	opts->cmd = c;
	109
	110	switch (c) {
	111	case 0:
	112	printf("option %s", long_options[option_index].name);
	113	if (optarg)
	114	printf(" with arg %s", optarg);
	115	printf("\n");
	116	break;
	117
	118	case ENABLE_MARKER:
	119	case DISABLE_MARKER:
	120	case SET_SUBBUF_SIZE:
	121	case SET_SUBBUF_NUM:
	122	case GET_SUBBUF_SIZE:
	123	case GET_SUBBUF_NUM:
	124	opts->regex = strdup(optarg);
	125	break;
	126
	127	case 'h':
	128	usage();
	129	exit(0);
	130
	131	case '?':
	132	fprintf(stderr, "Invalid argument\n\n");
	133	usage();
	134	exit(1);
	135	}
	136	}
	137
	138	if (argc - optind > 0 && opts->cmd != GET_ONLINE_PIDS) {
	139	int i;
	140	int pididx=0;
	141	opts->pids = malloc((argc-optind+1) * sizeof(pid_t));
	142
	143	for(i=optind; i<argc; i++) {
	144	/* don't take any chances, use a long long */
	145	long long tmp;
	146	char *endptr;
	147	tmp = strtoull(argv[i], &endptr, 10);
	148	if(*endptr != '\0') {
	149	ERR("The pid \"%s\" is invalid.", argv[i]);
	150	return 1;
	151	}
	152	opts->pids[pididx++] = (pid_t) tmp;
	153	}
	154	opts->pids[pididx] = -1;
	155	}
	156
	157	return 0;
	158	}
	159
	160	int main(int argc, char *argv[])
	161	{
	162	pid_t *pidit;
	163	int result;
	164	struct ust_opts opts;
	165
	166	progname = argv[0];
	167
	168	if(argc <= 1) {
	169	fprintf(stderr, "No operation specified.\n");
	170	usage();
	171	exit(EXIT_FAILURE);
	172	}
	173
	174	result = parse_opts_long(argc, argv, &opts);
	175	if(result) {
	176	fprintf(stderr, "\n");
	177	usage();
	178	exit(EXIT_FAILURE);
	179	}
	180
	181	if(opts.pids == NULL && opts.cmd != GET_ONLINE_PIDS) {
	182	fprintf(stderr, "No pid specified.\n");
	183	usage();
	184	exit(EXIT_FAILURE);
	185	}
	186	if(opts.cmd == UNKNOWN) {
	187	fprintf(stderr, "No command specified.\n");
	188	usage();
	189	exit(EXIT_FAILURE);
	190	}
	191	if (opts.cmd == GET_ONLINE_PIDS) {
	192	pid_t *pp = ustcmd_get_online_pids();
	193	unsigned int i = 0;
	194
	195	if (pp) {
	196	while (pp[i] != 0) {
	197	printf("%u\n", (unsigned int) pp[i]);
	198	++i;
	199	}
	200	free(pp);
	201	}
	202
	203	exit(EXIT_SUCCESS);
	204	}
	205
	206	pidit = opts.pids;
	207	struct marker_status *cmsf = NULL;
	208
	209	while(*pidit != -1) {
	210	switch (opts.cmd) {
	211	case CREATE_TRACE:
	212	result = ustcmd_create_trace(*pidit);
	213	if (result) {
	214	ERR("error while trying to create trace with PID %u\n", (unsigned int) *pidit);
	215	break;
	216	}
	217	break;
	218
	219	case START_TRACE:
	220	result = ustcmd_start_trace(*pidit);
	221	if (result) {
	222	ERR("error while trying to for trace with PID %u\n", (unsigned int) *pidit);
	223	break;
	224	}
	225	break;
	226
	227	case STOP_TRACE:
	228	result = ustcmd_stop_trace(*pidit);
	229	if (result) {
	230	ERR("error while trying to stop trace for PID %u\n", (unsigned int) *pidit);
	231	break;
	232	}
	233	break;
	234
	235	case DESTROY_TRACE:
	236	result = ustcmd_destroy_trace(*pidit);
	237	if (result) {
	238	ERR("error while trying to destroy trace with PID %u\n", (unsigned int) *pidit);
	239	break;
	240	}
	241	break;
	242
	243	case LIST_MARKERS:
	244	cmsf = NULL;
	245	if (ustcmd_get_cmsf(&cmsf, *pidit)) {
	246	fprintf(stderr,
	247	"error while trying to list markers for"
	248	" PID %u\n", (unsigned int) *pidit);
	249	break;
	250	}
	251	unsigned int i = 0;
	252	while (cmsf[i].channel != NULL) {
	253	printf("{PID: %u, channel/marker: %s/%s, "
	254	"state: %u, fmt: %s}\n",
	255	(unsigned int) *pidit,
	256	cmsf[i].channel,
	257	cmsf[i].marker,
	258	cmsf[i].state,
	259	cmsf[i].fs);
	260	++i;
	261	}
	262	ustcmd_free_cmsf(cmsf);
	263	break;
	264
	265	case ENABLE_MARKER:
	266	if(opts.regex)
	267	ustcmd_set_marker_state(opts.regex, 1, *pidit);
	268	break;
	269	case DISABLE_MARKER:
	270	if(opts.regex)
	271	ustcmd_set_marker_state(opts.regex, 0, *pidit);
	272	break;
	273
	274	case SET_SUBBUF_SIZE:
	275	ustcmd_set_subbuf_size(opts.regex, *pidit);
	276	break;
	277
	278	case SET_SUBBUF_NUM:
	279	ustcmd_set_subbuf_num(opts.regex, *pidit);
	280	break;
	281
	282	case GET_SUBBUF_SIZE:
	283	result = ustcmd_get_subbuf_size(opts.regex, *pidit);
	284	if (result == -1) {
	285	ERR("error while trying to get_subuf_size with PID %u\n", (unsigned int) *pidit);
	286	break;
	287	}
	288
	289	printf("the size of subbufers is %d\n", result);
	290	break;
	291
	292	case GET_SUBBUF_NUM:
	293	result = ustcmd_get_subbuf_num(opts.regex, *pidit);
	294	if (result == -1) {
	295	ERR("error while trying to get_subuf_num with PID %u\n", (unsigned int) *pidit);
	296	break;
	297	}
	298
	299	printf("the number of subbufers is %d\n", result);
	300	break;
	301
	302	case ALLOC_TRACE:
	303	result = ustcmd_alloc_trace(*pidit);
	304	if (result) {
	305	ERR("error while trying to alloc trace with PID %u\n", (unsigned int) *pidit);
	306	break;
	307	}
	308	break;
	309
	310	default:
	311	ERR("unknown command\n");
	312	break;
	313	}
	314
	315	pidit++;
	316	}
	317
	318	if (opts.pids != NULL) {
	319	free(opts.pids);
	320	}
	321	if (opts.regex != NULL) {
	322	free(opts.regex);
	323	}
	324
	325	return 0;
	326	}
	327