From: David Goulet Date: Wed, 18 May 2011 21:40:33 +0000 (-0400) Subject: Major changes on the lttng command line tool X-Git-Tag: v2.0-pre1~133 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=894be886aae0f1a1f49e63723511fcb15e816e7e;p=lttng-tools.git Major changes on the lttng command line tool Add create and destroy trace action but NOT implemented on the session daemon side. Add kernel create channel option but NOT implemented on the session daemon side. Add auto_session and auto_trace support for the lttng tool. This means that if only --start is specified with a certain pid for instance, a session is automatically created and a trace. Fix a bug on the session daemon side where the ret value was changed when no lttcomm_lttng_msg structure was allocated before replying to the client. Add a lot more command line validation for conflicting command. Remove the use of UUID in the session name and for the create trace of the liblttngctl API. Remove the memset(0) applied to the llm structure of liblttngctl thus resetting every information. This is not wanted for multiple command for one lttng execution. Signed-off-by: David Goulet --- diff --git a/include/lttng/lttng.h b/include/lttng/lttng.h index 39a6cbdad..6f4ce130f 100644 --- a/include/lttng/lttng.h +++ b/include/lttng/lttng.h @@ -58,7 +58,7 @@ struct lttng_trace { enum lttng_trace_type type; }; -extern int lttng_create_session(char *name, uuid_t *session_id); +extern int lttng_create_session(char *name); extern int lttng_destroy_session(uuid_t *uuid); extern int lttng_connect_sessiond(void); extern int lttng_disconnect_sessiond(void); diff --git a/liblttngctl/liblttngctl.c b/liblttngctl/liblttngctl.c index a2934e63c..230a19d7e 100644 --- a/liblttngctl/liblttngctl.c +++ b/liblttngctl/liblttngctl.c @@ -154,7 +154,6 @@ static int ask_sessiond(enum lttcomm_sessiond_command lct, void **buf) end: lttng_disconnect_sessiond(); - memset(&lsm, 0, sizeof(lsm)); return ret; } @@ -343,10 +342,9 @@ int lttng_list_traces(uuid_t *uuid, struct lttng_trace **traces) /* * lttng_create_session * - * Create a brand new session using name. Allocate - * the session_id param pointing to the UUID. + * Create a brand new session using name. */ -int lttng_create_session(char *name, uuid_t *session_id) +int lttng_create_session(char *name) { int ret; @@ -358,8 +356,6 @@ int lttng_create_session(char *name, uuid_t *session_id) goto end; } - uuid_copy(*session_id, llm.session_uuid); - end: return ret; } diff --git a/liblttsessiondcomm/liblttsessiondcomm.c b/liblttsessiondcomm/liblttsessiondcomm.c index 785d8e827..a5b3818c4 100644 --- a/liblttsessiondcomm/liblttsessiondcomm.c +++ b/liblttsessiondcomm/liblttsessiondcomm.c @@ -57,6 +57,7 @@ static const char *lttcomm_readable_code[] = { [ LTTCOMM_ERR_INDEX(KCONSUMERD_EXIT_SUCCESS) ] = "Kconsumerd exiting normally", [ LTTCOMM_ERR_INDEX(KCONSUMERD_EXIT_FAILURE) ] = "Kconsumerd exiting on error", [ LTTCOMM_ERR_INDEX(KCONSUMERD_OUTFD_ERROR) ] = "Kconsumerd error opening the tracefile", + [ LTTCOMM_ERR_INDEX(LTTCOMM_NO_EVENT) ] = "No event found", }; /* diff --git a/liblttsessiondcomm/liblttsessiondcomm.h b/liblttsessiondcomm/liblttsessiondcomm.h index 4e86cc547..abcca2509 100644 --- a/liblttsessiondcomm/liblttsessiondcomm.h +++ b/liblttsessiondcomm/liblttsessiondcomm.h @@ -99,6 +99,7 @@ enum lttcomm_return_code { LTTCOMM_NO_TRACEABLE, /* Error for non traceable app */ LTTCOMM_SELECT_SESS, /* Must select a session */ LTTCOMM_EXIST_SESS, /* Session name already exist */ + LTTCOMM_NO_EVENT, /* No event found */ LTTCOMM_NR, /* Last element */ KCONSUMERD_COMMAND_SOCK_READY, /* when kconsumerd command socket ready */ KCONSUMERD_SUCCESS_RECV_FD, /* success on receiving fds */ diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c index de601b6f8..76e927e43 100644 --- a/ltt-sessiond/main.c +++ b/ltt-sessiond/main.c @@ -160,6 +160,7 @@ static void *thread_manage_apps(void *data) notify_apps(default_global_apps_pipe); while (1) { + DBG("Accepting application registration"); /* Blocking call, waiting for transmission */ sock = lttcomm_accept_unix_sock(apps_sock); if (sock < 0) { @@ -263,7 +264,8 @@ static void *thread_manage_clients(void *data) continue; } - DBG("Sending response to client (size: %d)", cmd_ctx->lttng_msg_size); + DBG("Sending response (size: %d, retcode: %d)", + cmd_ctx->lttng_msg_size, cmd_ctx->llm->ret_code); ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size); if (ret < 0) { ERR("Failed to send data back to client"); @@ -465,6 +467,19 @@ static int process_client_msg(struct command_ctx *cmd_ctx) /* Process by command type */ switch (cmd_ctx->lsm->cmd_type) { + case KERNEL_ENABLE_EVENT: + { + /* Setup lttng message with no payload */ + ret = setup_lttng_msg(cmd_ctx, 0); + if (ret < 0) { + goto setup_error; + } + + DBG("Enabling kernel event %s", cmd_ctx->lsm->u.event.event_name); + + ret = LTTCOMM_OK; + break; + } case LTTNG_CREATE_SESSION: { /* Setup lttng message with no payload */ @@ -624,12 +639,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx) return ret; error: - DBG("Return code to client %d", ret); - if (cmd_ctx->llm == NULL) { DBG("Missing llm structure. Allocating one."); - ret = setup_lttng_msg(cmd_ctx, 0); - if (ret < 0) { + if (setup_lttng_msg(cmd_ctx, 0) < 0) { goto setup_error; } } diff --git a/lttng/lttng.c b/lttng/lttng.c index ab7f67ec5..10ce2ddfc 100644 --- a/lttng/lttng.c +++ b/lttng/lttng.c @@ -38,9 +38,9 @@ /* Variables */ static char *progname; static char *session_name; -static char short_str_uuid[UUID_SHORT_STR_LEN]; -static char long_str_uuid[UUID_STR_LEN]; static uuid_t current_uuid; +static int auto_session; +static int auto_trace; /* Prototypes */ static int process_client_opt(void); @@ -48,13 +48,14 @@ static int process_opt_list_apps(void); static int process_opt_list_sessions(void); static int process_opt_list_traces(void); static int process_opt_create_session(void); +static int process_kernel_create_trace(void); +static int process_opt_kernel_event(void); static int set_session_uuid(void); static void sighandler(int sig); static int set_signal_handler(void); static int validate_options(void); static char *get_cmdline_by_pid(pid_t pid); static void set_opt_session_info(void); -static void shorten_uuid(char *long_u, char *short_u); /* * start_client @@ -74,6 +75,7 @@ static int process_client_opt(void) if (ret < 0) { goto end; } + goto error; } if (opt_list_session) { @@ -81,32 +83,30 @@ static int process_client_opt(void) if (ret < 0) { goto end; } + goto error; } - if (opt_destroy_session) { - ret = lttng_destroy_session(¤t_uuid); + /* Session creation or auto session set on */ + if (auto_session || opt_create_session) { + DBG("Creating a new session"); + ret = process_opt_create_session(); if (ret < 0) { goto end; } - MSG("Session %s destroyed.", opt_session_uuid); } - if (!opt_list_session && !opt_list_apps) { - if (uuid_is_null(current_uuid)) { - /* If no session uuid, create session */ - DBG("No session specified. Creating session."); - ret = process_opt_create_session(); - if (ret < 0) { - goto end; - } - } + ret = set_session_uuid(); + if (ret < 0) { + ERR("Session %s not found", opt_session_name); + goto error; + } - DBG("Set session uuid to %s", long_str_uuid); - ret = set_session_uuid(); + if (opt_destroy_session) { + ret = lttng_destroy_session(¤t_uuid); if (ret < 0) { - ERR("Session UUID %s not found", opt_session_uuid); - goto error; + goto end; } + MSG("Session %s destroyed.", opt_session_name); } if (opt_list_traces) { @@ -119,23 +119,36 @@ static int process_client_opt(void) /* * Action on traces (kernel or/and userspace). */ + if (opt_trace_kernel) { - ERR("Not implemented yet"); - ret = -ENOSYS; - goto end; + if (auto_trace || opt_create_trace) { + DBG("Creating a kernel trace"); + ret = process_kernel_create_trace(); + if (ret < 0) { + goto end; + } + } + + if (opt_event_list != NULL) { + ret = process_opt_kernel_event(); + } else { + // Enable all events + } + + goto error; } if (opt_trace_pid != 0) { - if (opt_create_trace) { + if (auto_trace || opt_create_trace) { DBG("Create a userspace trace for pid %d", opt_trace_pid); ret = lttng_ust_create_trace(opt_trace_pid); if (ret < 0) { goto end; } - MSG("Trace created successfully!\nUse --start to start tracing."); + MSG("Trace created successfully!"); } - if (opt_start_trace) { + if (auto_trace || opt_start_trace) { DBG("Start trace for pid %d", opt_trace_pid); ret = lttng_ust_start_trace(opt_trace_pid); if (ret < 0) { @@ -162,65 +175,64 @@ error: /* fall through */ } /* - * set_opt_session_info + * process_kernel_create_trace * - * Setup session_name, current_uuid, short_str_uuid and - * long_str_uuid using the command line options. + * Create a kernel trace. */ -static void set_opt_session_info(void) +static int process_kernel_create_trace(void) { - int count, i, short_len; - char *tok; - struct lttng_session *sessions; + return 0; +} - if (opt_session_uuid != NULL) { - short_len = sizeof(short_str_uuid) - 1; - /* Shorten uuid */ - tok = strchr(opt_session_uuid, '.'); - if (strlen(tok + 1) == short_len) { - memcpy(short_str_uuid, tok + 1, short_len); - short_str_uuid[short_len] = '\0'; - } +/* + * process_kernel_event + * + * Enable kernel event from the command line list given. + */ +static int process_opt_kernel_event(void) +{ + int ret; + char *event_name; - /* Get long real uuid_t from session daemon */ - count = lttng_list_sessions(&sessions); - for (i = 0; i < count; i++) { - uuid_unparse(sessions[i].uuid, long_str_uuid); - if (strncmp(long_str_uuid, short_str_uuid, 8) == 0) { - uuid_copy(current_uuid, sessions[i].uuid); - break; - } + event_name = strtok(opt_event_list, ","); + while (event_name != NULL) { + DBG("Enabling kernel event %s", event_name); + ret = lttng_kernel_enable_event(event_name); + if (ret < 0) { + ERR("%s %s", lttng_get_readable_code(ret), event_name); + } else { + MSG("Kernel event %s enabled.", event_name); } + /* Next event */ + event_name = strtok(NULL, ","); } - if (opt_session_name != NULL) { - session_name = strndup(opt_session_name, NAME_MAX); - } + return 0; } /* - * shorten_uuid + * set_opt_session_info * - * Small function to shorten the 37 bytes long uuid_t - * string representation to 8 characters. + * Setup session_name, current_uuid, short_str_uuid and + * long_str_uuid using the command line options. */ -static void shorten_uuid(char *long_u, char *short_u) +static void set_opt_session_info(void) { - memcpy(short_u, long_u, 8); - short_u[UUID_SHORT_STR_LEN - 1] = '\0'; + if (opt_session_name != NULL) { + session_name = strndup(opt_session_name, NAME_MAX); + DBG("Session name set to %s", session_name); + } } /* * set_session_uuid * - * Set current session uuid to the current flow of - * command(s) using the already shorten uuid or - * current full uuid. + * Set current session uuid to the current flow of command(s) using the + * session_name. */ static int set_session_uuid(void) { - int ret, count, i; - char str_uuid[37]; + int ret, count, i, found = 0; struct lttng_session *sessions; if (!uuid_is_null(current_uuid)) { @@ -235,16 +247,22 @@ static int set_session_uuid(void) } for (i = 0; i < count; i++) { - uuid_unparse(sessions[i].uuid, str_uuid); - if (strncmp(str_uuid, short_str_uuid, 8) == 0) { + if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) { lttng_set_current_session_uuid(&sessions[i].uuid); + uuid_copy(current_uuid, sessions[i].uuid); + found = 1; break; } } free(sessions); + if (!found) { + return -1; + } + end: + DBG("Session UUID set"); return 0; error: @@ -262,10 +280,17 @@ static int process_opt_list_traces(void) struct lttng_trace *traces; ret = lttng_list_traces(¤t_uuid, &traces); + DBG("Number of traces to list %d", ret); if (ret < 0) { goto error; } + /* No traces */ + if (ret == 0) { + MSG("No traces found."); + goto error; + } + MSG("Userspace traces:"); for (i = 0; i < ret; i++) { if (traces[i].type == USERSPACE) { @@ -299,30 +324,25 @@ error: static int process_opt_create_session(void) { int ret; - uuid_t session_id; - char str_uuid[37]; char name[NAME_MAX]; time_t rawtime; struct tm *timeinfo; - /* Auto session creation */ - if (opt_create_session == 0) { + /* Auto session name creation */ + if (opt_session_name == NULL) { time(&rawtime); timeinfo = localtime(&rawtime); - strftime(name, sizeof(name), "%Y%m%d-%H%M%S", timeinfo); + strftime(name, sizeof(name), "auto-%Y%m%d-%H%M%S", timeinfo); session_name = strndup(name, sizeof(name)); + DBG("Auto session name set to %s", session_name); } - ret = lttng_create_session(session_name, &session_id); + ret = lttng_create_session(session_name); if (ret < 0) { goto error; } - uuid_unparse(session_id, str_uuid); - uuid_copy(current_uuid, session_id); - shorten_uuid(str_uuid, short_str_uuid); - - MSG("Session UUID created: %s.%s", session_name, short_str_uuid); + MSG("Session created: %s", session_name); error: return ret; @@ -337,11 +357,9 @@ error: static int process_opt_list_sessions(void) { int ret, count, i; - char tmp_short_uuid[9]; - char str_uuid[37]; - struct lttng_session *sess; + struct lttng_session *sessions; - count = lttng_list_sessions(&sess); + count = lttng_list_sessions(&sessions); DBG("Session count %d", count); if (count < 0) { ret = count; @@ -350,12 +368,10 @@ static int process_opt_list_sessions(void) MSG("Available sessions (UUIDs):"); for (i = 0; i < count; i++) { - uuid_unparse(sess[i].uuid, str_uuid); - shorten_uuid(str_uuid, tmp_short_uuid); - MSG(" %d) %s.%s", i+1, sess[i].name, tmp_short_uuid); + MSG(" %d) %s", i+1, sessions[i].name); } - free(sess); + free(sessions); MSG("\nTo select a session, use -s, --session UUID."); return 0; @@ -436,31 +452,70 @@ end: /* * validate_options * - * Make sure that all options passed to the command line - * are compatible with each others. + * Make sure that all options passed to the command line are compatible with + * each others. * * On error, return -1 * On success, return 0 */ static int validate_options(void) { + /* If listing options, jump validation */ + if (opt_list_apps || opt_list_session) { + goto end; + } /* Conflicting command */ if (opt_start_trace && opt_stop_trace) { ERR("Can't use --start and --stop together."); goto error; /* If no PID specified and trace_kernel is off */ - } else if ((opt_trace_pid == 0 && opt_trace_kernel == 0) && - (opt_create_trace || opt_start_trace || opt_stop_trace)) { - ERR("Please specify a PID using -p, --pid PID."); - goto error; - } else if (opt_session_uuid && opt_create_session) { - ERR("Please don't use -s and -c together. Useless action."); + } else if ((opt_trace_pid == 0 && !opt_trace_kernel) && + (opt_create_trace || opt_start_trace || opt_stop_trace || opt_destroy_trace)) { + ERR("Please specify for which tracer (-k or -p PID)."); goto error; - } else if (opt_list_traces && opt_session_uuid == NULL) { + /* List traces, we need a session name */ + } else if (opt_list_traces && opt_session_name == NULL) { ERR("Can't use -t without -s, --session option."); goto error; + /* Can't set event for both kernel and userspace at the same time */ + } else if (opt_event_list != NULL && (opt_trace_kernel && opt_trace_pid)) { + ERR("Please don't use --event for both kernel and userspace.\nOne at a time to enable events."); + goto error; + /* Don't need a trace name for kernel tracig */ + } else if (opt_trace_name != NULL && opt_trace_kernel) { + ERR("For action on a kernel trace, please don't specify a trace name."); + goto error; + } else if (opt_destroy_trace && opt_session_name == NULL) { + ERR("Please specify a session in order to destroy a trace"); + goto error; + } else if (opt_create_trace || opt_destroy_trace) { + /* Both kernel and user-space are denied for these options */ + if (opt_trace_pid != 0 && opt_trace_kernel) { + ERR("Kernel and user-space trace creation and destruction can't be used together."); + goto error; + /* Need a trace name for user-space tracing */ + } else if (opt_trace_name == NULL && opt_trace_pid != 0) { + ERR("Please specify a trace name for user-space tracing"); + goto error; + } + } else if (opt_stop_trace && opt_trace_pid != 0 && opt_trace_name == NULL) { + ERR("Please specify a trace name for user-space tracing"); + goto error; } + /* If start trace, auto start tracing */ + if (opt_start_trace) { + DBG("Requesting auto tracing"); + auto_trace = 1; + } + + /* If no session, auto create one */ + if (opt_session_name == NULL) { + DBG("Requesting an auto session creation"); + auto_session = 1; + } + +end: return 0; error: diff --git a/lttng/lttng.h b/lttng/lttng.h index 537ab74d9..412eba355 100644 --- a/lttng/lttng.h +++ b/lttng/lttng.h @@ -30,8 +30,14 @@ extern char *opt_tracing_group; extern char *opt_session_uuid; extern char *opt_sessiond_path; extern char *opt_session_name; +extern char *opt_event_list; +extern char *opt_trace_name; +extern int opt_destroy_trace; +extern int opt_enable_event; +extern int opt_disable_event; extern int opt_destroy_session; extern int opt_create_session; +extern int opt_create_channel; extern int opt_list_apps; extern int opt_no_sessiond; extern int opt_list_session; diff --git a/lttng/options.c b/lttng/options.c index de2681054..bb0233e7e 100644 --- a/lttng/options.c +++ b/lttng/options.c @@ -22,10 +22,12 @@ #include "lttng.h" /* Option variables */ +char *opt_event_list; char *opt_tracing_group; -char *opt_session_uuid; char *opt_sessiond_path; char *opt_session_name; +char *opt_trace_name; +int opt_destroy_trace; int opt_create_session; int opt_destroy_session; int opt_trace_kernel = 0; @@ -35,25 +37,37 @@ int opt_list_apps = 0; int opt_no_sessiond = 0; int opt_list_session = 0; int opt_list_traces = 0; -int opt_create_trace = 0; +int opt_create_trace; int opt_start_trace = 0; int opt_stop_trace = 0; +int opt_enable_event; +int opt_disable_event; +int opt_create_channel; pid_t opt_trace_pid = 0; enum { OPT_HELP = 1, + OPT_ENABLE_EVENT, + OPT_DISABLE_EVENT, OPT_CREATE_SESSION, + OPT_CREATE_TRACE, OPT_DESTROY_SESSION, + OPT_DESTROY_TRACE, + OPT_START_TRACE, + OPT_STOP_TRACE, }; static struct poptOption long_options[] = { /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */ {"create-session", 'c', POPT_ARG_STRING, 0, OPT_CREATE_SESSION, 0, 0}, - {"create-trace", 'C', POPT_ARG_VAL, &opt_create_trace, 1, 0, 0}, + {"create-trace", 'C', POPT_ARG_STRING | POPT_ARGFLAG_OPTIONAL, 0, OPT_CREATE_TRACE, 0, 0}, + {"destroy-trace", 'D', POPT_ARG_STRING | POPT_ARGFLAG_OPTIONAL, 0, OPT_DESTROY_TRACE, 0, 0}, {"destroy-session", 'd', POPT_ARG_STRING, 0, OPT_DESTROY_SESSION, 0, 0}, + {"disable-event", 0, POPT_ARG_STRING, 0, OPT_DISABLE_EVENT, 0, 0}, + {"enable-event", 'e', POPT_ARG_STRING, 0, OPT_ENABLE_EVENT, 0, 0}, {"group", 0, POPT_ARG_STRING, &opt_tracing_group, 0, 0, 0}, {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0}, - {"kernel", 0, POPT_ARG_VAL, &opt_trace_kernel, 1, 0, 0}, + {"kernel", 'k', POPT_ARG_VAL, &opt_trace_kernel, 1, 0, 0}, {"list-apps", 'L', POPT_ARG_VAL, &opt_list_apps, 1, 0, 0}, {"list-sessions", 'l', POPT_ARG_VAL, &opt_list_session, 1, 0, 0}, {"list-traces", 't', POPT_ARG_VAL, &opt_list_traces, 1, 0, 0}, @@ -61,12 +75,11 @@ static struct poptOption long_options[] = { {"no-sessiond", 0, POPT_ARG_VAL, &opt_no_sessiond, 1, 0, 0}, {"pid", 'p', POPT_ARG_INT, &opt_trace_pid, 0, 0, 0}, {"quiet", 'q', POPT_ARG_VAL, &opt_quiet, 1, 0, 0}, - {"session", 's', POPT_ARG_STRING, &opt_session_uuid, 0, 0, 0}, + {"session", 's', POPT_ARG_STRING, &opt_session_name, 0, 0, 0}, {"sessiond-path", 0, POPT_ARG_STRING, &opt_sessiond_path, 0, 0, 0}, - {"start", 0, POPT_ARG_VAL, &opt_start_trace, 1, 0, 0}, - {"stop", 0, POPT_ARG_VAL, &opt_stop_trace, 1, 0, 0}, + {"start", 0, POPT_ARG_STRING | POPT_ARGFLAG_OPTIONAL, 0, OPT_START_TRACE, 0, 0}, + {"stop", 0, POPT_ARG_STRING | POPT_ARGFLAG_OPTIONAL, 0, OPT_STOP_TRACE, 0, 0}, {"verbose", 'v', POPT_ARG_VAL, &opt_verbose, 1, 0, 0}, - //{"session", 0, POPT_ARG_STRING | POPT_ARGFLAG_OPTIONAL, &opt_session_name, 0, 0}, {0, 0, 0, 0, 0, 0, 0} }; @@ -86,22 +99,29 @@ static void usage(FILE *ofp) fprintf(ofp, " --group NAME Unix tracing group name. (default: tracing)\n"); fprintf(ofp, " --no-sessiond Don't spawn a session daemon\n"); fprintf(ofp, " --sessiond-path Session daemon full path\n"); + fprintf(ofp, " -L, --list-apps List traceable user-space applications\n"); fprintf(ofp, "\n"); fprintf(ofp, "Session options:\n"); fprintf(ofp, " -c, --create-session NAME Create a new session\n"); - fprintf(ofp, " -l, --list-sessions List all available sessions\n"); + fprintf(ofp, " -l, --list-sessions List all available sessions by name\n"); fprintf(ofp, " -s, --session UUID Specify tracing session using UUID\n"); fprintf(ofp, " -d, --destroy-session NAME Destroy the session specified by NAME\n"); + fprintf(ofp, " -t, --list-traces List session's traces. Use -s to specify the session\n"); fprintf(ofp, "\n"); fprintf(ofp, "Tracing options:\n"); - //fprintf(ofp, " --kernel Enable kernel tracing\n"); - //fprintf(ofp, " --no-kernel Disable kernel tracing\n"); - fprintf(ofp, " -p, --pid PID Set tracing action for PID\n"); - fprintf(ofp, " -L, --list-apps List traceable UST applications\n"); - fprintf(ofp, " -t, --list-traces List session's traces. Use -s to specify the session\n"); - fprintf(ofp, " -C, --create-trace Create a trace\n"); - fprintf(ofp, " --start Start tracing\n"); - fprintf(ofp, " --stop Stop tracing\n"); + fprintf(ofp, " -p, --pid PID Specify action on user-space tracer for PID\n"); + fprintf(ofp, " -k, --kernel Specify action on kernel tracer\n"); + fprintf(ofp, " -e, --enable-event LIST Enable tracing event (support marker and tracepoint)\n"); + fprintf(ofp, " --disable-event LIST Disable tracing event (support marker and tracepoint)\n"); + fprintf(ofp, " -C, --create-trace Create a trace. Allocate and setup a trace\n"); + fprintf(ofp, " -D, --destroy-trace [NAME] Destroy a trace. Use NAME to identify user-space trace\n"); + fprintf(ofp, " --start [NAME] Start tracing. Use NAME to identify user-space trace\n"); + fprintf(ofp, " --stop [NAME] Stop tracing. Use NAME to identify user-space trace\n"); + fprintf(ofp, "\n"); + fprintf(ofp, "Kernel tracing options:\n"); + fprintf(ofp, " --create-channel Create kernel channel\n"); + fprintf(ofp, "\n"); + fprintf(ofp, "User-space tracing options:\n"); fprintf(ofp, "\n"); fprintf(ofp, "Please see the lttng(1) man page for full documentation.\n"); fprintf(ofp, "See http://lttng.org for updates, bug reports and news.\n"); @@ -138,7 +158,27 @@ int parse_args(int argc, const char **argv) break; case OPT_DESTROY_SESSION: opt_destroy_session = 1; - opt_session_uuid = poptGetOptArg(pc); + opt_session_name = poptGetOptArg(pc); + break; + case OPT_ENABLE_EVENT: + opt_enable_event = 1; + opt_event_list = poptGetOptArg(pc); + break; + case OPT_DESTROY_TRACE: + opt_destroy_trace = 1; + opt_trace_name = poptGetOptArg(pc); + break; + case OPT_START_TRACE: + opt_start_trace = 1; + opt_trace_name = poptGetOptArg(pc); + break; + case OPT_STOP_TRACE: + opt_stop_trace = 1; + opt_trace_name = poptGetOptArg(pc); + break; + case OPT_CREATE_TRACE: + opt_create_trace = 1; + opt_trace_name = poptGetOptArg(pc); break; default: usage(stderr);