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);
end:
lttng_disconnect_sessiond();
- memset(&lsm, 0, sizeof(lsm));
return ret;
}
/*
* 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;
goto end;
}
- uuid_copy(*session_id, llm.session_uuid);
-
end:
return ret;
}
[ 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",
};
/*
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 */
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) {
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");
/* 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 */
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;
}
}
/* 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);
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
if (ret < 0) {
goto end;
}
+ goto error;
}
if (opt_list_session) {
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) {
/*
* 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) {
}
/*
- * 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)) {
}
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:
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) {
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;
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;
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;
/*
* 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:
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;
#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;
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},
{"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}
};
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");
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);
projects / lttng-tools.git / commitdiff
