Major changes on the lttng command line tool
authorDavid Goulet <david.goulet@polymtl.ca>
Wed, 18 May 2011 21:40:33 +0000 (17:40 -0400)
committerDavid Goulet <david.goulet@polymtl.ca>
Wed, 18 May 2011 21:45:52 +0000 (17:45 -0400)
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 <david.goulet@polymtl.ca>
include/lttng/lttng.h
liblttngctl/liblttngctl.c
liblttsessiondcomm/liblttsessiondcomm.c
liblttsessiondcomm/liblttsessiondcomm.h
ltt-sessiond/main.c
lttng/lttng.c
lttng/lttng.h
lttng/options.c

index 39a6cbdad383241ad0adf93744d1833bbc8a7b5f..6f4ce130f684341e2799b84ce606c3bb7f127e24 100644 (file)
@@ -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);
index a2934e63c9644e3e70ae3b7309880b4857e9b2bd..230a19d7e8a25805602e71c7f541451213dc9edf 100644 (file)
@@ -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;
 }
index 785d8e827b4dc456703ab8950b49de187d635aca..a5b3818c42b4e8d80facf287b149c54fc07fbd99 100644 (file)
@@ -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",
 };
 
 /*
index 4e86cc5475b6a11804079ac3344a453e61a8a6d6..abcca250930bd766c19a581f9ac8dfd000a3d2c2 100644 (file)
@@ -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 */
index de601b6f86746ba295b50ba335b44eb68acf537b..76e927e43a3fa68b938e79a1d3b28549886d0c20 100644 (file)
@@ -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;
                }
        }
index ab7f67ec52c296245d697d4a663488318acc22f0..10ce2ddfc08539bb121c2a0aa8b3bfe017a93f20 100644 (file)
@@ -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(&current_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(&current_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(&current_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:
index 537ab74d911db8622bbb446db1a30b89cd5fa662..412eba355b78b256a8e96eb3707e8f982c8105e4 100644 (file)
@@ -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;
index de2681054c93d2dbbfd95088a860fd3909e7dda7..bb0233e7e7f79270b8831c231011f0cd549f2d59 100644 (file)
 #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);
This page took 0.056567 seconds and 4 git commands to generate.