*/
#define _GNU_SOURCE
+#define _LGPL_SOURCE
#include <assert.h>
#include <popt.h>
#include <stdio.h>
static int opt_userspace;
static int opt_jul;
static int opt_log4j;
+static int opt_python;
static int opt_enable_all;
static char *opt_probe;
static char *opt_function;
-static char *opt_function_entry_symbol;
static char *opt_channel_name;
static char *opt_filter;
static char *opt_exclude;
-#if 0
-/* Not implemented yet */
-static char *opt_cmd_name;
-static pid_t opt_pid;
-#endif
enum {
OPT_HELP = 1,
OPT_TRACEPOINT,
OPT_PROBE,
OPT_FUNCTION,
- OPT_FUNCTION_ENTRY,
OPT_SYSCALL,
OPT_USERSPACE,
OPT_LOGLEVEL,
{"userspace", 'u', POPT_ARG_NONE, 0, OPT_USERSPACE, 0, 0},
{"jul", 'j', POPT_ARG_VAL, &opt_jul, 1, 0, 0},
{"log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, 0, 0},
+ {"python", 'p', POPT_ARG_VAL, &opt_python, 1, 0, 0},
{"tracepoint", 0, POPT_ARG_NONE, 0, OPT_TRACEPOINT, 0, 0},
{"probe", 0, POPT_ARG_STRING, &opt_probe, OPT_PROBE, 0, 0},
{"function", 0, POPT_ARG_STRING, &opt_function, OPT_FUNCTION, 0, 0},
-#if 0
- /*
- * Currently removed from lttng kernel tracer. Removed from
- * lttng UI to discourage its use.
- */
- {"function:entry", 0, POPT_ARG_STRING, &opt_function_entry_symbol, OPT_FUNCTION_ENTRY, 0, 0},
-#endif
{"syscall", 0, POPT_ARG_NONE, 0, OPT_SYSCALL, 0, 0},
{"loglevel", 0, POPT_ARG_STRING, 0, OPT_LOGLEVEL, 0, 0},
{"loglevel-only", 0, POPT_ARG_STRING, 0, OPT_LOGLEVEL_ONLY, 0, 0},
*/
static void usage(FILE *ofp)
{
- fprintf(ofp, "usage: lttng enable-event NAME[,NAME2,...] [-k|-u] [OPTIONS] \n");
+ fprintf(ofp, "usage: lttng enable-event NAME[,NAME2,...] (-k | -u | -j | -l | -p) [OPTIONS] \n");
fprintf(ofp, "\n");
fprintf(ofp, "Options:\n");
fprintf(ofp, " -h, --help Show this help\n");
fprintf(ofp, " -u, --userspace Apply to the user-space tracer\n");
fprintf(ofp, " -j, --jul Apply for Java application using JUL\n");
fprintf(ofp, " -l, --log4j Apply for Java application using LOG4j\n");
+ fprintf(ofp, " -p, --python Apply for Python application\n");
fprintf(ofp, "\n");
fprintf(ofp, "Event options:\n");
fprintf(ofp, " --tracepoint Tracepoint event (default)\n");
fprintf(ofp, " Dynamic function entry/return probe.\n");
fprintf(ofp, " Addr and offset can be octal (0NNN...),\n");
fprintf(ofp, " decimal (NNN...) or hexadecimal (0xNNN...)\n");
-#if 0
- fprintf(ofp, " --function:entry symbol\n");
- fprintf(ofp, " Function tracer event\n");
-#endif
fprintf(ofp, " --syscall System call event\n");
fprintf(ofp, "\n");
fprintf(ofp, " --loglevel name\n");
fprintf(ofp, " LOG4J_ALL = INT32_MIN\n");
fprintf(ofp, " (shortcuts such as \"severe\" are allowed)\n");
fprintf(ofp, "\n");
+ fprintf(ofp, " Available Python domain loglevels:\n");
+ fprintf(ofp, " PYTHON_CRITICAL = %d\n", LTTNG_LOGLEVEL_PYTHON_CRITICAL);
+ fprintf(ofp, " PYTHON_ERROR = %d\n", LTTNG_LOGLEVEL_PYTHON_ERROR);
+ fprintf(ofp, " PYTHON_WARNING = %d\n", LTTNG_LOGLEVEL_PYTHON_WARNING);
+ fprintf(ofp, " PYTHON_INFO = %d\n", LTTNG_LOGLEVEL_PYTHON_INFO);
+ fprintf(ofp, " PYTHON_DEBUG = %d\n", LTTNG_LOGLEVEL_PYTHON_DEBUG);
+ fprintf(ofp, " PYTHON_NOTSET = %d\n", LTTNG_LOGLEVEL_PYTHON_NOTSET);
+ fprintf(ofp, " (shortcuts such as \"critical\" are allowed)\n");
+ fprintf(ofp, "\n");
fprintf(ofp, " -f, --filter \'expression\'\n");
fprintf(ofp, " Filter expression on event fields and context.\n");
fprintf(ofp, " Event recording depends on evaluation.\n");
int i = 0;
char str[LTTNG_SYMBOL_NAME_LEN];
+ if (!inputstr || strlen(inputstr) == 0) {
+ return -1;
+ }
+
/*
* Loop up to LTTNG_SYMBOL_NAME_LEN minus one because the NULL bytes is
* added at the end of the loop so a the upper bound we avoid the overflow.
int i = 0;
char str[LTTNG_SYMBOL_NAME_LEN];
+ if (!inputstr || strlen(inputstr) == 0) {
+ return -1;
+ }
+
/*
* Loop up to LTTNG_SYMBOL_NAME_LEN minus one because the NULL bytes is
* added at the end of the loop so a the upper bound we avoid the overflow.
}
}
+/*
+ * Maps Python loglevel from string to value
+ */
+static int loglevel_python_str_to_value(const char *inputstr)
+{
+ int i = 0;
+ char str[LTTNG_SYMBOL_NAME_LEN];
+
+ if (!inputstr || strlen(inputstr) == 0) {
+ return -1;
+ }
+
+ /*
+ * Loop up to LTTNG_SYMBOL_NAME_LEN minus one because the NULL bytes is
+ * added at the end of the loop so a the upper bound we avoid the overflow.
+ */
+ while (i < (LTTNG_SYMBOL_NAME_LEN - 1) && inputstr[i] != '\0') {
+ str[i] = toupper(inputstr[i]);
+ i++;
+ }
+ str[i] = '\0';
+
+ if (!strcmp(str, "PYTHON_CRITICAL") || !strcmp(str, "CRITICAL")) {
+ return LTTNG_LOGLEVEL_PYTHON_CRITICAL;
+ } else if (!strcmp(str, "PYTHON_ERROR") || !strcmp(str, "ERROR")) {
+ return LTTNG_LOGLEVEL_PYTHON_ERROR;
+ } else if (!strcmp(str, "PYTHON_WARNING") || !strcmp(str, "WARNING")) {
+ return LTTNG_LOGLEVEL_PYTHON_WARNING;
+ } else if (!strcmp(str, "PYTHON_INFO") || !strcmp(str, "INFO")) {
+ return LTTNG_LOGLEVEL_PYTHON_INFO;
+ } else if (!strcmp(str, "PYTNON_DEBUG") || !strcmp(str, "DEBUG")) {
+ return LTTNG_LOGLEVEL_PYTHON_DEBUG;
+ } else if (!strcmp(str, "PYTHON_NOTSET") || !strcmp(str, "NOTSET")) {
+ return LTTNG_LOGLEVEL_PYTHON_NOTSET;
+ } else {
+ return -1;
+ }
+}
+
/*
* Maps loglevel from string to value
*/
int i = 0;
char str[LTTNG_SYMBOL_NAME_LEN];
+ if (!inputstr || strlen(inputstr) == 0) {
+ return -1;
+ }
+
/*
* Loop up to LTTNG_SYMBOL_NAME_LEN minus one because the NULL bytes is
* added at the end of the loop so a the upper bound we avoid the overflow.
/* add length of preamble + one for NUL - one for last (missing) comma */
length += strlen(preamble);
- ret = malloc(length);
+ ret = zmalloc(length);
+ if (!ret) {
+ return NULL;
+ }
strncpy(ret, preamble, length);
for (i = 0; i < count; i++) {
strcat(ret, names[i]);
goto error;
}
if (e == '*') {
+ char *string;
+ char **new_exclusion_list;
+
/* Excluder is a proper subset of event */
+ string = strndup(next_excluder, excluder_length);
+ if (!string) {
+ PERROR("strndup error");
+ goto error;
+ }
+ new_exclusion_list = realloc(exclusion_list,
+ sizeof(char *) * (exclusion_count + 1));
+ if (!new_exclusion_list) {
+ PERROR("realloc");
+ free(string);
+ goto error;
+ }
+ exclusion_list = new_exclusion_list;
exclusion_count++;
- exclusion_list = realloc(exclusion_list, sizeof(char **) * exclusion_count);
- exclusion_list[exclusion_count - 1] = strndup(next_excluder, excluder_length);
-
+ exclusion_list[exclusion_count - 1] = string;
break;
}
if (x != e) {
memset(&dom, 0, sizeof(dom));
if (opt_kernel) {
- if (opt_filter) {
- ERR("Filter not implement for kernel tracing yet");
- ret = CMD_ERROR;
- goto error;
- }
if (opt_loglevel) {
WARN("Kernel loglevels are not supported.");
}
dom.type = LTTNG_DOMAIN_LOG4J;
/* Default. */
dom.buf_type = LTTNG_BUFFER_PER_UID;
+ } else if (opt_python) {
+ dom.type = LTTNG_DOMAIN_PYTHON;
+ /* Default. */
+ dom.buf_type = LTTNG_BUFFER_PER_UID;
} else {
print_missing_domain();
ret = CMD_ERROR;
/* Default setup for enable all */
if (opt_kernel) {
ev.type = opt_event_type;
- ev.name[0] = '\0';
+ strcpy(ev.name, "*");
/* kernel loglevels not implemented */
ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
} else {
strcpy(ev.name, "*");
ev.loglevel_type = opt_loglevel_type;
if (opt_loglevel) {
- assert(opt_userspace || opt_jul || opt_log4j);
+ assert(opt_userspace || opt_jul || opt_log4j || opt_python);
if (opt_userspace) {
ev.loglevel = loglevel_str_to_value(opt_loglevel);
} else if (opt_jul) {
ev.loglevel = loglevel_jul_str_to_value(opt_loglevel);
} else if (opt_log4j) {
ev.loglevel = loglevel_log4j_str_to_value(opt_loglevel);
+ } else if (opt_python) {
+ ev.loglevel = loglevel_python_str_to_value(opt_loglevel);
}
if (ev.loglevel == -1) {
ERR("Unknown loglevel %s", opt_loglevel);
goto error;
}
} else {
- assert(opt_userspace || opt_jul || opt_log4j);
+ assert(opt_userspace || opt_jul || opt_log4j || opt_python);
if (opt_userspace) {
ev.loglevel = -1;
} else if (opt_jul || opt_log4j) {
ev.loglevel = LTTNG_LOGLEVEL_JUL_ALL;
+ } else if (opt_python) {
+ ev.loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
}
}
}
print_channel_name(channel_name), session_name);
warn = 1;
break;
+ case LTTNG_ERR_TRACE_ALREADY_STARTED:
+ {
+ const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
+ ERR("Events: %s (channel %s, session %s)",
+ msg,
+ print_channel_name(channel_name),
+ session_name);
+ error = 1;
+ break;
+ }
default:
ERR("Events: %s (channel %s, session %s)",
lttng_strerror(ret),
case LTTNG_EVENT_TRACEPOINT:
if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
char *exclusion_string = print_exclusions(exclusion_count, exclusion_list);
+
+ if (!exclusion_string) {
+ PERROR("Cannot allocate exclusion_string");
+ error = 1;
+ goto end;
+ }
MSG("All %s tracepoints%s are enabled in channel %s for loglevel %s",
get_domain_str(dom.type),
exclusion_string,
free(exclusion_string);
} else {
char *exclusion_string = print_exclusions(exclusion_count, exclusion_list);
+
+ if (!exclusion_string) {
+ PERROR("Cannot allocate exclusion_string");
+ error = 1;
+ goto end;
+ }
MSG("All %s tracepoints%s are enabled in channel %s",
get_domain_str(dom.type),
exclusion_string,
case LTTNG_EVENT_ALL:
if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
char *exclusion_string = print_exclusions(exclusion_count, exclusion_list);
+
+ if (!exclusion_string) {
+ PERROR("Cannot allocate exclusion_string");
+ error = 1;
+ goto end;
+ }
MSG("All %s events%s are enabled in channel %s for loglevel %s",
get_domain_str(dom.type),
exclusion_string,
free(exclusion_string);
} else {
char *exclusion_string = print_exclusions(exclusion_count, exclusion_list);
+
+ if (!exclusion_string) {
+ PERROR("Cannot allocate exclusion_string");
+ error = 1;
+ goto end;
+ }
MSG("All %s events%s are enabled in channel %s",
get_domain_str(dom.type),
exclusion_string,
print_channel_name(channel_name), session_name);
warn = 1;
break;
+ case LTTNG_ERR_TRACE_ALREADY_STARTED:
+ {
+ const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
+ ERR("All events: %s (channel %s, session %s, filter \'%s\')",
+ msg,
+ print_channel_name(channel_name),
+ session_name, opt_filter);
+ error = 1;
+ break;
+ }
default:
ERR("All events: %s (channel %s, session %s, filter \'%s\')",
lttng_strerror(command_ret),
print_channel_name(channel_name));
switch (opt_event_type) {
- case LTTNG_EVENT_ALL: /* Default behavior is tracepoint */
- ev.type = LTTNG_EVENT_TRACEPOINT;
- /* Fall-through */
+ case LTTNG_EVENT_ALL: /* Enable tracepoints and syscalls */
+ /* If event name differs from *, select tracepoint. */
+ if (strcmp(ev.name, "*")) {
+ ev.type = LTTNG_EVENT_TRACEPOINT;
+ }
+ break;
case LTTNG_EVENT_TRACEPOINT:
break;
case LTTNG_EVENT_PROBE:
goto error;
}
break;
- case LTTNG_EVENT_FUNCTION_ENTRY:
- strncpy(ev.attr.ftrace.symbol_name, opt_function_entry_symbol,
- LTTNG_SYMBOL_NAME_LEN);
- ev.attr.ftrace.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
- break;
case LTTNG_EVENT_SYSCALL:
ev.type = LTTNG_EVENT_SYSCALL;
break;
/* kernel loglevels not implemented */
ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
} else if (opt_userspace) { /* User-space tracer action */
-#if 0
- if (opt_cmd_name != NULL || opt_pid) {
- MSG("Only supporting tracing all UST processes (-u) for now.");
- ret = CMD_UNDEFINED;
- goto error;
- }
-#endif
-
DBG("Enabling UST event %s for channel %s, loglevel %s", event_name,
print_channel_name(channel_name), opt_loglevel ? : "<all>");
break;
case LTTNG_EVENT_PROBE:
case LTTNG_EVENT_FUNCTION:
- case LTTNG_EVENT_FUNCTION_ENTRY:
case LTTNG_EVENT_SYSCALL:
default:
ERR("Event type not available for user-space tracing");
} else {
ev.loglevel = -1;
}
- } else if (opt_jul || opt_log4j) {
+ } else if (opt_jul || opt_log4j || opt_python) {
if (opt_event_type != LTTNG_EVENT_ALL &&
opt_event_type != LTTNG_EVENT_TRACEPOINT) {
ERR("Event type not supported for domain.");
ev.loglevel = loglevel_jul_str_to_value(opt_loglevel);
} else if (opt_log4j) {
ev.loglevel = loglevel_log4j_str_to_value(opt_loglevel);
+ } else if (opt_python) {
+ ev.loglevel = loglevel_python_str_to_value(opt_loglevel);
}
if (ev.loglevel == -1) {
ERR("Unknown loglevel %s", opt_loglevel);
ev.loglevel = LTTNG_LOGLEVEL_JUL_ALL;
} else if (opt_log4j) {
ev.loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
+ } else if (opt_python) {
+ ev.loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
}
}
ev.type = LTTNG_EVENT_TRACEPOINT;
&ev, channel_name,
NULL, exclusion_count, exclusion_list);
exclusion_string = print_exclusions(exclusion_count, exclusion_list);
+ if (!exclusion_string) {
+ PERROR("Cannot allocate exclusion_string");
+ error = 1;
+ goto end;
+ }
if (command_ret < 0) {
/* Turn ret to positive value to handle the positive error code */
switch (-command_ret) {
print_channel_name(channel_name), session_name);
warn = 1;
break;
+ case LTTNG_ERR_TRACE_ALREADY_STARTED:
+ {
+ const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
+ ERR("Event %s%s: %s (channel %s, session %s)", event_name,
+ exclusion_string,
+ msg,
+ print_channel_name(channel_name),
+ session_name);
+ error = 1;
+ break;
+ }
default:
ERR("Event %s%s: %s (channel %s, session %s)", event_name,
exclusion_string,
command_ret = lttng_enable_event_with_exclusions(handle, &ev, channel_name,
opt_filter, exclusion_count, exclusion_list);
exclusion_string = print_exclusions(exclusion_count, exclusion_list);
-
+ if (!exclusion_string) {
+ PERROR("Cannot allocate exclusion_string");
+ error = 1;
+ goto end;
+ }
if (command_ret < 0) {
switch (-command_ret) {
case LTTNG_ERR_FILTER_EXIST:
print_channel_name(channel_name), session_name);
warn = 1;
break;
+ case LTTNG_ERR_TRACE_ALREADY_STARTED:
+ {
+ const char *msg = "The command tried to enable an event in a new domain for a session that has already been started once.";
+ ERR("Event %s%s: %s (channel %s, session %s, filter \'%s\')", ev.name,
+ exclusion_string,
+ msg,
+ print_channel_name(channel_name),
+ session_name, opt_filter);
+ error = 1;
+ break;
+ }
default:
ERR("Event %s%s: %s (channel %s, session %s, filter \'%s\')", ev.name,
exclusion_string,
case OPT_FUNCTION:
opt_event_type = LTTNG_EVENT_FUNCTION;
break;
- case OPT_FUNCTION_ENTRY:
- opt_event_type = LTTNG_EVENT_FUNCTION_ENTRY;
- break;
case OPT_SYSCALL:
opt_event_type = LTTNG_EVENT_SYSCALL;
break;
projects / lttng-tools.git / blobdiff