[ust.git] / ust / ust.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 <regex.h>

#include "ustcomm.h"
#include "ustcmd.h"
#include "usterr.h"

enum command {
	START_TRACE,
	STOP_TRACE,
	START,
	DESTROY,
	LIST_MARKERS,
	ENABLE_MARKER,
	DISABLE_MARKER,
	GET_ONLINE_PIDS,
	UNKNOWN
};

struct ust_opts {
	enum command cmd;
	pid_t *pids;
	char *regex;
	regex_t preg;
	int regex_state;
};

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\
    --start-trace\t\t\tStart tracing\n\
    --stop-trace\t\t\tStop tracing\n\
    --destroy-trace\t\t\tDestroy the trace\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;
	opts->regex_state = -1;

	while (1) {
		int option_index = 0;
		static struct option long_options[] = {
			{"start-trace", 0, 0, 1000},
			{"stop-trace", 0, 0, 1001},
			{"destroy-trace", 0, 0, 1002},
			{"list-markers", 0, 0, 1004},
			{"print-markers", 0, 0, 1005},
			{"pid", 1, 0, 1006},
			{"enable-marker", 1, 0, 1007},
			{"disable-marker", 1, 0, 1008},
			{"start", 0, 0, 1009},
			{"help", 0, 0, 'h'},
			{"version", 0, 0, 1010},
			{"online-pids", 0, 0, 1011},
			{0, 0, 0, 0}
		};

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

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

		case 1000:
			opts->cmd = START_TRACE;
			break;
		case 1001:
			opts->cmd = STOP_TRACE;
			break;
		case 1009:
			opts->cmd = START;
			break;
		case 1002:
			opts->cmd = DESTROY;
			break;
		case 1004:
			opts->cmd = LIST_MARKERS;
			break;
		case 1007:
			opts->cmd = ENABLE_MARKER;
			opts->regex = strdup(optarg);
			break;
		case 1008:
			opts->cmd = DISABLE_MARKER;
			opts->regex = strdup(optarg);
			break;
		case 1011:
			opts->cmd = GET_ONLINE_PIDS;
			break;
		case 'h':
			usage();
			exit(0);
		case 1010:
			printf("Version 0.1\n");

		default:
			/* unknown option or other error; error is
			printed by getopt, just return */
			opts->cmd = UNKNOWN;
			return 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;
	}

	if (opts->cmd == ENABLE_MARKER || opts->cmd == DISABLE_MARKER) {
		opts->regex_state = regcomp(&opts->preg, opts->regex, 0);
		if (opts->regex_state) {
			ERR("invalid regular expression\n");
		}
	}

	return 0;
}

static void regex_change_m_state(struct ust_opts *opts, pid_t pid)
{
	struct marker_status *cmsf = NULL;
	unsigned int i = 0;
	int e = (opts->cmd == ENABLE_MARKER);

	if (opts->regex_state != 0) {
		return;
	}

	if (ustcmd_get_cmsf(&cmsf, pid)) {
		fprintf(stderr, "error while trying to get markers for PID "
			"%u\n", (unsigned int) pid);
		return;
	}
	while (cmsf[i].channel != NULL) {
		char *mc;
		asprintf(&mc, "%s/%s", cmsf[i].channel, cmsf[i].marker);
		if (regexec(&opts->preg, mc, 0, NULL, 0) == 0) {
			/* We got a match! */
			if (ustcmd_set_marker_state(mc,
			e ? USTCMD_MS_ON : USTCMD_MS_OFF, pid)) {
				fprintf(stderr,
					"error while trying to %sable marker"
					"\"%s\" for PID %u\n",
					e ? "en" : "dis", mc,
					(unsigned int) pid);
			} else {
				printf("sucessfully %sabled marker "
					"\"%s\" for PID %u\n",
					e ? "en" : "dis", mc,
					(unsigned int) pid);
			}
		}
		free(mc);
		++i;
	}
	ustcmd_free_cmsf(cmsf);
}

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 START_TRACE:
				result = ustcmd_start_trace(*pidit);
				if (result) {
					ERR("error while trying to for trace with PID %u\n", (unsigned int) *pidit);
					break;
				}
				//printf("sucessfully started trace for PID %u\n", (unsigned int) *pidit);
				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;
				}
				//printf("sucessfully stopped trace for PID %u\n", (unsigned int) *pidit);
				break;

			case START:
				result = ustcmd_setup_and_start(*pidit);
				if (result) {
					ERR("error while trying to setup/start trace for PID %u\n", (unsigned int) *pidit);
					break;
				}
				//printf("sucessfully setup/started trace for PID %u\n", (unsigned int) *pidit);
				break;

			case DESTROY:
				result = ustcmd_destroy_trace(*pidit);
				if (result) {
					ERR("error while trying to destroy trace with PID %u\n", (unsigned int) *pidit);
					break;
				}
				//printf("sucessfully destroyed trace for PID %u\n", (unsigned int) *pidit);
				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, fs: %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:
			case DISABLE_MARKER:
				regex_change_m_state(&opts, *pidit);
			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
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>
ef290fca	24	#include <regex.h>
fbd8191b	25
f9e5ce61	26	#include "ustcomm.h"
ae937656	27	#include "ustcmd.h"
2028e7fd	28	#include "usterr.h"
ae937656 PP	29
	30	enum command {
	31	START_TRACE,
	32	STOP_TRACE,
	33	START,
	34	DESTROY,
	35	LIST_MARKERS,
	36	ENABLE_MARKER,
	37	DISABLE_MARKER,
	38	GET_ONLINE_PIDS,
	39	UNKNOWN
ef290fca	40	};
fbd8191b	41
52c51a47	42	struct ust_opts {
ae937656	43	enum command cmd;
52c51a47	44	pid_t *pids;
08230db7	45	char *regex;
ef290fca PMF	46	regex_t preg;
ef290fca PMF	47	int regex_state;
52c51a47 PMF	48	};
52c51a47 PMF	49
fd2fb4f9 PMF	50	char *progname = NULL;
	51
	52	void usage(void)
	53	{
ae937656	54	fprintf(stderr, "usage: %s COMMAND PIDs...\n", progname);
fd2fb4f9 PMF	55	fprintf(stderr, "\nControl the tracing of a process that supports LTTng Userspace Tracing.\n\
	56	\n\
	57	Commands:\n\
	58	--start-trace\t\t\tStart tracing\n\
	59	--stop-trace\t\t\tStop tracing\n\
	60	--destroy-trace\t\t\tDestroy the trace\n\
ae937656 PP	61	--enable-marker \"CHANNEL/MARKER\"\tEnable a marker\n\
	62	--disable-marker \"CHANNEL/MARKER\"\tDisable a marker\n\
	63	--list-markers\t\t\tList the markers of the process, their\n\t\t\t\t\t state and format string\n\
	64	\
fd2fb4f9 PMF	65	");
	66	}
	67
52c51a47	68	int parse_opts_long(int argc, char *argv, struct ust_opts opts)
fbd8191b	69	{
52c51a47	70	int c;
52c51a47	71
52c51a47	72	opts->pids = NULL;
ef290fca PMF	73	opts->regex = NULL;
ef290fca PMF	74	opts->regex_state = -1;
52c51a47 PMF	75
52c51a47 PMF	76	while (1) {
52c51a47 PMF	77	int option_index = 0;
	78	static struct option long_options[] = {
	79	{"start-trace", 0, 0, 1000},
	80	{"stop-trace", 0, 0, 1001},
	81	{"destroy-trace", 0, 0, 1002},
	82	{"list-markers", 0, 0, 1004},
	83	{"print-markers", 0, 0, 1005},
	84	{"pid", 1, 0, 1006},
	85	{"enable-marker", 1, 0, 1007},
	86	{"disable-marker", 1, 0, 1008},
	87	{"start", 0, 0, 1009},
d373b5cd PMF	88	{"help", 0, 0, 'h'},
d373b5cd PMF	89	{"version", 0, 0, 1010},
ae937656	90	{"online-pids", 0, 0, 1011},
52c51a47 PMF	91	{0, 0, 0, 0}
	92	};
	93
d373b5cd	94	c = getopt_long(argc, argv, "h", long_options, &option_index);
52c51a47 PMF	95	if (c == -1)
	96	break;
	97
	98	switch (c) {
	99	case 0:
	100	printf("option %s", long_options[option_index].name);
	101	if (optarg)
	102	printf(" with arg %s", optarg);
	103	printf("\n");
	104	break;
	105
	106	case 1000:
ae937656	107	opts->cmd = START_TRACE;
52c51a47 PMF	108	break;
52c51a47 PMF	109	case 1001:
ae937656	110	opts->cmd = STOP_TRACE;
52c51a47 PMF	111	break;
52c51a47 PMF	112	case 1009:
ae937656	113	opts->cmd = START;
52c51a47 PMF	114	break;
52c51a47 PMF	115	case 1002:
ae937656	116	opts->cmd = DESTROY;
52c51a47 PMF	117	break;
52c51a47 PMF	118	case 1004:
ae937656	119	opts->cmd = LIST_MARKERS;
52c51a47 PMF	120	break;
52c51a47 PMF	121	case 1007:
ae937656	122	opts->cmd = ENABLE_MARKER;
ef290fca	123	opts->regex = strdup(optarg);
52c51a47 PMF	124	break;
52c51a47 PMF	125	case 1008:
ae937656	126	opts->cmd = DISABLE_MARKER;
ef290fca	127	opts->regex = strdup(optarg);
ae937656 PP	128	break;
	129	case 1011:
	130	opts->cmd = GET_ONLINE_PIDS;
52c51a47	131	break;
d373b5cd PMF	132	case 'h':
	133	usage();
	134	exit(0);
	135	case 1010:
ae937656	136	printf("Version 0.1\n");
52c51a47 PMF	137
52c51a47 PMF	138	default:
ae937656 PP	139	/* unknown option or other error; error is
	140	printed by getopt, just return */
	141	opts->cmd = UNKNOWN;
52c51a47	142	return 1;
fbd8191b PMF	143	}
	144	}
	145
772030fe	146	if (argc - optind > 0 && opts->cmd != GET_ONLINE_PIDS) {
52c51a47 PMF	147	int i;
	148	int pididx=0;
	149	opts->pids = malloc((argc-optind+1) * sizeof(pid_t));
fbd8191b	150
52c51a47	151	for(i=optind; i<argc; i++) {
08230db7 PMF	152	/* don't take any chances, use a long long */
	153	long long tmp;
	154	char *endptr;
	155	tmp = strtoull(argv[i], &endptr, 10);
	156	if(*endptr != '\0') {
	157	ERR("The pid \"%s\" is invalid.", argv[i]);
	158	return 1;
	159	}
	160	opts->pids[pididx++] = (pid_t) tmp;
52c51a47 PMF	161	}
52c51a47 PMF	162	opts->pids[pididx] = -1;
fbd8191b PMF	163	}
fbd8191b PMF	164
772030fe	165	if (opts->cmd == ENABLE_MARKER \|\| opts->cmd == DISABLE_MARKER) {
08230db7 PMF	166	opts->regex_state = regcomp(&opts->preg, opts->regex, 0);
	167	if (opts->regex_state) {
	168	ERR("invalid regular expression\n");
772030fe PMF	169	}
	170	}
	171
52c51a47 PMF	172	return 0;
52c51a47 PMF	173	}
fbd8191b	174
08230db7 PMF	175	static void regex_change_m_state(struct ust_opts *opts, pid_t pid)
	176	{
	177	struct marker_status *cmsf = NULL;
772030fe PMF	178	unsigned int i = 0;
	179	int e = (opts->cmd == ENABLE_MARKER);
	180
	181	if (opts->regex_state != 0) {
	182	return;
	183	}
	184
	185	if (ustcmd_get_cmsf(&cmsf, pid)) {
	186	fprintf(stderr, "error while trying to get markers for PID "
	187	"%u\n", (unsigned int) pid);
	188	return;
	189	}
	190	while (cmsf[i].channel != NULL) {
08230db7	191	char *mc;
772030fe PMF	192	asprintf(&mc, "%s/%s", cmsf[i].channel, cmsf[i].marker);
	193	if (regexec(&opts->preg, mc, 0, NULL, 0) == 0) {
	194	/* We got a match! */
	195	if (ustcmd_set_marker_state(mc,
	196	e ? USTCMD_MS_ON : USTCMD_MS_OFF, pid)) {
	197	fprintf(stderr,
	198	"error while trying to %sable marker"
	199	"\"%s\" for PID %u\n",
	200	e ? "en" : "dis", mc,
	201	(unsigned int) pid);
	202	} else {
	203	printf("sucessfully %sabled marker "
	204	"\"%s\" for PID %u\n",
	205	e ? "en" : "dis", mc,
	206	(unsigned int) pid);
	207	}
	208	}
	209	free(mc);
	210	++i;
	211	}
	212	ustcmd_free_cmsf(cmsf);
	213	}
	214
fbd8191b PMF	215	int main(int argc, char *argv[])
fbd8191b PMF	216	{
52c51a47	217	pid_t *pidit;
52c51a47 PMF	218	int result;
52c51a47 PMF	219	struct ust_opts opts;
fbd8191b	220
52c51a47	221	progname = argv[0];
fbd8191b	222
52c51a47 PMF	223	if(argc <= 1) {
	224	fprintf(stderr, "No operation specified.\n");
	225	usage();
	226	exit(EXIT_FAILURE);
	227	}
	228
	229	result = parse_opts_long(argc, argv, &opts);
	230	if(result) {
08230db7	231	fprintf(stderr, "\n");
52c51a47 PMF	232	usage();
	233	exit(EXIT_FAILURE);
	234	}
	235
ae937656	236	if(opts.pids == NULL && opts.cmd != GET_ONLINE_PIDS) {
52c51a47 PMF	237	fprintf(stderr, "No pid specified.\n");
	238	usage();
	239	exit(EXIT_FAILURE);
	240	}
ae937656	241	if(opts.cmd == UNKNOWN) {
52c51a47 PMF	242	fprintf(stderr, "No command specified.\n");
	243	usage();
	244	exit(EXIT_FAILURE);
	245	}
ae937656	246	if (opts.cmd == GET_ONLINE_PIDS) {
08230db7	247	pid_t *pp = ustcmd_get_online_pids();
ae937656	248	unsigned int i = 0;
52c51a47	249
ae937656 PP	250	if (pp) {
	251	while (pp[i] != 0) {
	252	printf("%u\n", (unsigned int) pp[i]);
	253	++i;
	254	}
	255	free(pp);
52c51a47	256	}
ef290fca	257
ae937656 PP	258	exit(EXIT_SUCCESS);
ae937656 PP	259	}
52c51a47	260
ae937656	261	pidit = opts.pids;
08230db7	262	struct marker_status *cmsf = NULL;
ef290fca	263
ae937656 PP	264	while(*pidit != -1) {
	265	switch (opts.cmd) {
	266	case START_TRACE:
08230db7 PMF	267	result = ustcmd_start_trace(*pidit);
	268	if (result) {
	269	ERR("error while trying to for trace with PID %u\n", (unsigned int) *pidit);
	270	break;
	271	}
	272	//printf("sucessfully started trace for PID %u\n", (unsigned int) *pidit);
ae937656	273	break;
ef290fca	274
ae937656	275	case STOP_TRACE:
08230db7 PMF	276	result = ustcmd_stop_trace(*pidit);
	277	if (result) {
	278	ERR("error while trying to stop trace for PID %u\n", (unsigned int) *pidit);
	279	break;
	280	}
	281	//printf("sucessfully stopped trace for PID %u\n", (unsigned int) *pidit);
ae937656	282	break;
ef290fca	283
ae937656	284	case START:
08230db7 PMF	285	result = ustcmd_setup_and_start(*pidit);
	286	if (result) {
	287	ERR("error while trying to setup/start trace for PID %u\n", (unsigned int) *pidit);
	288	break;
	289	}
	290	//printf("sucessfully setup/started trace for PID %u\n", (unsigned int) *pidit);
ae937656	291	break;
ef290fca	292
ae937656	293	case DESTROY:
08230db7 PMF	294	result = ustcmd_destroy_trace(*pidit);
	295	if (result) {
	296	ERR("error while trying to destroy trace with PID %u\n", (unsigned int) *pidit);
	297	break;
	298	}
	299	//printf("sucessfully destroyed trace for PID %u\n", (unsigned int) *pidit);
ae937656	300	break;
ef290fca	301
ae937656	302	case LIST_MARKERS:
08230db7 PMF	303	cmsf = NULL;
	304	if (ustcmd_get_cmsf(&cmsf, *pidit)) {
	305	fprintf(stderr,
	306	"error while trying to list markers for"
	307	" PID %u\n", (unsigned int) *pidit);
	308	break;
	309	}
	310	unsigned int i = 0;
	311	while (cmsf[i].channel != NULL) {
	312	printf("{PID: %u, channel/marker: %s/%s, "
	313	"state: %u, fs: %s}\n",
	314	(unsigned int) *pidit,
	315	cmsf[i].channel,
	316	cmsf[i].marker,
	317	cmsf[i].state,
	318	cmsf[i].fs);
	319	++i;
	320	}
	321	ustcmd_free_cmsf(cmsf);
ae937656	322	break;
ef290fca	323
ae937656	324	case ENABLE_MARKER:
ae937656	325	case DISABLE_MARKER:
ef290fca	326	regex_change_m_state(&opts, *pidit);
ae937656	327	break;
ef290fca	328
ae937656	329	default:
08230db7	330	ERR("unknown command\n");
ae937656 PP	331	break;
ae937656 PP	332	}
ef290fca	333
52c51a47 PMF	334	pidit++;
52c51a47 PMF	335	}
82b1a169	336
ef290fca PMF	337	if (opts.pids != NULL) {
	338	free(opts.pids);
	339	}
	340	if (opts.regex != NULL) {
	341	free(opts.regex);
ae937656	342	}
fbd8191b PMF	343
	344	return 0;
	345	}
ae937656	346