*/
#define _GNU_SOURCE
+#define _LGPL_SOURCE
#include <assert.h>
#include <grp.h>
#include <errno.h>
case LTTNG_DOMAIN_UST:
case LTTNG_DOMAIN_JUL:
case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
memcpy(dst, src, sizeof(struct lttng_domain));
break;
default:
/* Get number of supplementary group IDs */
grp_list_size = getgroups(0, NULL);
if (grp_list_size < 0) {
- perror("getgroups");
+ PERROR("getgroups");
goto end;
}
/* Alloc group list of the right size */
- grp_list = malloc(grp_list_size * sizeof(gid_t));
+ grp_list = zmalloc(grp_list_size * sizeof(gid_t));
if (!grp_list) {
- perror("malloc");
+ PERROR("malloc");
goto end;
}
grp_id = getgroups(grp_list_size, grp_list);
if (grp_id < 0) {
- perror("getgroups");
+ PERROR("getgroups");
goto free_list;
}
ret = lttcomm_close_unix_sock(ret);
if (ret < 0) {
- perror("lttcomm_close_unix_sock");
+ PERROR("lttcomm_close_unix_sock");
}
return 0;
goto end;
}
- data = (void*) malloc(size);
+ data = zmalloc(size);
+ if (!data) {
+ ret = -ENOMEM;
+ goto end;
+ }
/* Get payload data */
ret = recv_data_sessiond(data, size);
goto end;
}
- handle = malloc(sizeof(struct lttng_handle));
+ handle = zmalloc(sizeof(struct lttng_handle));
if (handle == NULL) {
PERROR("malloc handle");
goto end;
}
/*
- * Depending on the event, return a newly allocated JUL filter expression or
+ * Depending on the event, return a newly allocated agent filter expression or
* NULL if not applicable.
*
* An event with NO loglevel and the name is * will return NULL.
*/
-static char *set_jul_filter(const char *filter, struct lttng_event *ev)
+static char *set_agent_filter(const char *filter, struct lttng_event *ev)
{
int err;
- char *jul_filter = NULL;
+ char *agent_filter = NULL;
assert(ev);
/* Don't add filter for the '*' event. */
if (ev->name[0] != '*') {
if (filter) {
- err = asprintf(&jul_filter, "(%s) && (logger_name == \"%s\")", filter,
+ err = asprintf(&agent_filter, "(%s) && (logger_name == \"%s\")", filter,
ev->name);
} else {
- err = asprintf(&jul_filter, "logger_name == \"%s\"", ev->name);
+ err = asprintf(&agent_filter, "logger_name == \"%s\"", ev->name);
}
if (err < 0) {
PERROR("asprintf");
op = "==";
}
- if (filter || jul_filter) {
+ if (filter || agent_filter) {
char *new_filter;
err = asprintf(&new_filter, "(%s) && (int_loglevel %s %d)",
- jul_filter ? jul_filter : filter, op,
+ agent_filter ? agent_filter : filter, op,
ev->loglevel);
- if (jul_filter) {
- free(jul_filter);
+ if (agent_filter) {
+ free(agent_filter);
}
- jul_filter = new_filter;
+ agent_filter = new_filter;
} else {
- err = asprintf(&jul_filter, "int_loglevel %s %d", op,
+ err = asprintf(&agent_filter, "int_loglevel %s %d", op,
ev->loglevel);
}
if (err < 0) {
}
}
- return jul_filter;
+ return agent_filter;
error:
- free(jul_filter);
+ free(agent_filter);
return NULL;
}
/* No need to keep the memory stream. */
if (fclose(fmem) != 0) {
- perror("fclose");
+ PERROR("fclose");
}
*ctxp = ctx;
filter_parser_ctx_free(ctx);
filter_alloc_error:
if (fclose(fmem) != 0) {
- perror("fclose");
+ PERROR("fclose");
}
error:
return ret;
sizeof(lsm.u.enable.channel_name));
}
- if (ev->name[0] != '\0') {
- lsm.cmd_type = LTTNG_ENABLE_EVENT;
- } else {
- lsm.cmd_type = LTTNG_ENABLE_ALL_EVENT;
+ lsm.cmd_type = LTTNG_ENABLE_EVENT;
+ if (ev->name[0] == '\0') {
+ /* Enable all events */
+ lttng_ctl_copy_string(ev->name, "*", sizeof(ev->name));
}
lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
*/
if (exclusion_count == 0 && filter_expression == NULL &&
(handle->domain.type != LTTNG_DOMAIN_JUL &&
- handle->domain.type != LTTNG_DOMAIN_LOG4J)) {
+ handle->domain.type != LTTNG_DOMAIN_LOG4J &&
+ handle->domain.type != LTTNG_DOMAIN_PYTHON)) {
goto ask_sessiond;
}
/* Parse filter expression */
if (filter_expression != NULL || handle->domain.type == LTTNG_DOMAIN_JUL
- || handle->domain.type == LTTNG_DOMAIN_LOG4J) {
+ || handle->domain.type == LTTNG_DOMAIN_LOG4J
+ || handle->domain.type == LTTNG_DOMAIN_PYTHON) {
if (handle->domain.type == LTTNG_DOMAIN_JUL ||
- handle->domain.type == LTTNG_DOMAIN_LOG4J) {
- char *jul_filter;
+ handle->domain.type == LTTNG_DOMAIN_LOG4J ||
+ handle->domain.type == LTTNG_DOMAIN_PYTHON) {
+ char *agent_filter;
/* Setup JUL filter if needed. */
- jul_filter = set_jul_filter(filter_expression, ev);
- if (!jul_filter) {
+ agent_filter = set_agent_filter(filter_expression, ev);
+ if (!agent_filter) {
if (!filter_expression) {
/* No JUL and no filter, just skip everything below. */
goto ask_sessiond;
}
} else {
/*
- * With a JUL filter, the original filter has been added to it
- * thus replace the filter expression.
+ * With an agent filter, the original filter has been added to
+ * it thus replace the filter expression.
*/
- filter_expression = jul_filter;
+ filter_expression = agent_filter;
free_filter_expression = 1;
}
}
sizeof(lsm.u.disable.channel_name));
}
- if (ev->name[0] != '\0') {
- lsm.cmd_type = LTTNG_DISABLE_EVENT;
- } else {
- lsm.cmd_type = LTTNG_DISABLE_ALL_EVENT;
+ lsm.cmd_type = LTTNG_DISABLE_EVENT;
+ if (ev->name[0] == '\0') {
+ /* Disable all events */
+ lttng_ctl_copy_string(ev->name, "*", sizeof(ev->name));
}
lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
*/
if (filter_expression == NULL &&
(handle->domain.type != LTTNG_DOMAIN_JUL &&
- handle->domain.type != LTTNG_DOMAIN_LOG4J)) {
+ handle->domain.type != LTTNG_DOMAIN_LOG4J &&
+ handle->domain.type != LTTNG_DOMAIN_PYTHON)) {
goto ask_sessiond;
}
/* Parse filter expression */
if (filter_expression != NULL || handle->domain.type == LTTNG_DOMAIN_JUL
- || handle->domain.type == LTTNG_DOMAIN_LOG4J) {
+ || handle->domain.type == LTTNG_DOMAIN_LOG4J
+ || handle->domain.type == LTTNG_DOMAIN_PYTHON) {
if (handle->domain.type == LTTNG_DOMAIN_JUL ||
- handle->domain.type == LTTNG_DOMAIN_LOG4J) {
- char *jul_filter;
+ handle->domain.type == LTTNG_DOMAIN_LOG4J ||
+ handle->domain.type == LTTNG_DOMAIN_PYTHON) {
+ char *agent_filter;
/* Setup JUL filter if needed. */
- jul_filter = set_jul_filter(filter_expression, ev);
- if (!jul_filter) {
+ agent_filter = set_agent_filter(filter_expression, ev);
+ if (!agent_filter) {
if (!filter_expression) {
/* No JUL and no filter, just skip everything below. */
goto ask_sessiond;
* With a JUL filter, the original filter has been added to it
* thus replace the filter expression.
*/
- filter_expression = jul_filter;
+ filter_expression = agent_filter;
free_filter_expression = 1;
}
}
struct lttng_event ev;
memset(&ev, 0, sizeof(ev));
+ ev.loglevel = -1;
ev.type = LTTNG_EVENT_ALL;
lttng_ctl_copy_string(ev.name, name, sizeof(ev.name));
return lttng_disable_event_ext(handle, &ev, channel_name, NULL);
return lttng_ctl_ask_sessiond(&lsm, NULL);
}
+/*
+ * Add PID to session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_track_pid(struct lttng_handle *handle, int pid)
+{
+ struct lttcomm_session_msg lsm;
+
+ /*
+ * NULL arguments are forbidden. No default values.
+ */
+ if (handle == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+
+ lsm.cmd_type = LTTNG_TRACK_PID;
+ lsm.u.pid_tracker.pid = pid;
+
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+
+ return lttng_ctl_ask_sessiond(&lsm, NULL);
+}
+
+/*
+ * Remove PID from session tracker.
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_untrack_pid(struct lttng_handle *handle, int pid)
+{
+ struct lttcomm_session_msg lsm;
+
+ /*
+ * NULL arguments are forbidden. No default values.
+ */
+ if (handle == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+
+ lsm.cmd_type = LTTNG_UNTRACK_PID;
+ lsm.u.pid_tracker.pid = pid;
+
+ lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain);
+
+ lttng_ctl_copy_string(lsm.session.name, handle->session_name,
+ sizeof(lsm.session.name));
+
+ return lttng_ctl_ask_sessiond(&lsm, NULL);
+}
+
/*
* Lists all available tracepoints of domain.
* Sets the contents of the events array.
return ret / sizeof(struct lttng_event_field);
}
+/*
+ * Lists all available kernel system calls. Allocates and sets the contents of
+ * the events array.
+ *
+ * Returns the number of lttng_event entries in events; on error, returns a
+ * negative value.
+ */
+int lttng_list_syscalls(struct lttng_event **events)
+{
+ int ret;
+ struct lttcomm_session_msg lsm;
+
+ if (!events) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_LIST_SYSCALLS;
+ /* Force kernel domain for system calls. */
+ lsm.domain.type = LTTNG_DOMAIN_KERNEL;
+
+ ret = lttng_ctl_ask_sessiond(&lsm, (void **) events);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return ret / sizeof(struct lttng_event);
+}
+
/*
* Returns a human readable string describing
* the error code (a negative value).
return ret / sizeof(struct lttng_session);
}
+int lttng_set_session_shm_path(const char *session_name,
+ const char *shm_path)
+{
+ struct lttcomm_session_msg lsm;
+
+ if (session_name == NULL) {
+ return -LTTNG_ERR_INVALID;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_SET_SESSION_SHM_PATH;
+
+ lttng_ctl_copy_string(lsm.session.name, session_name,
+ sizeof(lsm.session.name));
+ lttng_ctl_copy_string(lsm.u.set_shm_path.shm_path, shm_path,
+ sizeof(lsm.u.set_shm_path.shm_path));
+
+ return lttng_ctl_ask_sessiond(&lsm, NULL);
+}
+
/*
* Ask the session daemon for all available domains of a session.
* Sets the contents of the domains array.
projects / lttng-tools.git / blobdiff