X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=liblttngctl%2Fliblttngctl.c;h=e400775eaa97a6ffcd983cf4f6cd14da695ec18b;hp=d8481496d042b6c3c2b2c9375edf9c374e1a0aae;hb=847177cda88eed885da0b5f0b66b03ffcd06c8f6;hpb=e065084a507dd07b658b3d26c58b1ddd519e25a0 diff --git a/liblttngctl/liblttngctl.c b/liblttngctl/liblttngctl.c index d8481496d..e400775ea 100644 --- a/liblttngctl/liblttngctl.c +++ b/liblttngctl/liblttngctl.c @@ -24,7 +24,7 @@ #include #include -#include +#include #include "liblttsessiondcomm.h" #include "lttngerr.h" @@ -34,33 +34,29 @@ static int sessiond_socket; static char sessiond_sock_path[PATH_MAX]; /* Communication structure to ltt-sessiond */ -static struct lttcomm_lttng_msg llm; static struct lttcomm_session_msg lsm; +static struct lttcomm_lttng_msg llm; /* Prototypes */ static int check_tracing_group(const char *grp_name); -static int ask_sessiond(void); -static int recvfrom_sessiond(void); +static int ask_sessiond(enum lttcomm_sessiond_command lct, void **buf); +static int recv_data_sessiond(void *buf, size_t len); +static int send_data_sessiond(void); static int set_session_daemon_path(void); -static void reset_data_struct(void); - -int lttng_connect_sessiond(void); -int lttng_create_session(const char *name, char *session_id); -int lttng_check_session_daemon(void); /* Variables */ static char *tracing_group; static int connected; /* - * ask_sessiond + * send_data_sessiond * * Send lttcomm_session_msg to the session daemon. * * On success, return 0 * On error, return error code */ -static int ask_sessiond(void) +static int send_data_sessiond(void) { int ret; @@ -76,14 +72,14 @@ end: } /* - * recvfrom_sessiond + * recv_data_sessiond * * Receive data from the sessiond socket. * * On success, return 0 * On error, return recv() error code */ -static int recvfrom_sessiond(void) +static int recv_data_sessiond(void *buf, size_t len) { int ret; @@ -92,18 +88,73 @@ static int recvfrom_sessiond(void) goto end; } - ret = lttcomm_recv_unix_sock(sessiond_socket, &llm, sizeof(llm)); + ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len); + if (ret < 0) { + goto end; + } + +end: + return ret; +} + +/* + * ask_sessiond + * + * Ask the session daemon a specific command + * and put the data into buf. + * + * Return size of data (only payload, not header). + */ +static int ask_sessiond(enum lttcomm_sessiond_command lct, void **buf) +{ + int ret; + size_t size; + void *data = NULL; + + ret = lttng_connect_sessiond(); + if (ret < 0) { + goto end; + } + + lsm.cmd_type = lct; + + /* Send command to session daemon */ + ret = send_data_sessiond(); + if (ret < 0) { + goto end; + } + + /* Get header from data transmission */ + ret = recv_data_sessiond(&llm, sizeof(llm)); if (ret < 0) { goto end; } - /* Check return code */ + /* Check error code if OK */ if (llm.ret_code != LTTCOMM_OK) { ret = -llm.ret_code; goto end; } + size = llm.trace_name_offset + llm.data_size; + if (size == 0) { + goto end; + } + + data = (void*) malloc(size); + + /* Get payload data */ + ret = recv_data_sessiond(data, size); + if (ret < 0) { + goto end; + } + + *buf = data; + ret = size; + end: + lttng_disconnect_sessiond(); + memset(&lsm, 0, sizeof(lsm)); return ret; } @@ -122,38 +173,46 @@ const char *lttng_get_readable_code(int code) } /* - * lttng_create_session + * lttng_ust_start_trace * - * Create a tracing session using "name" to the session daemon. - * If no name is given, the auto session creation is set and - * the daemon will take care of finding a name. + * Request a trace start for pid. + */ +int lttng_ust_start_trace(pid_t pid) +{ + int ret; + + lsm.pid = pid; + ret = ask_sessiond(UST_START_TRACE, NULL); + + return ret; +} + +/* + * lttng_ust_stop_trace * - * On success, return 0 and session_id point to the uuid str. - * On error, negative value is returned. + * Request a trace stop for pid. */ -int lttng_create_session(const char *name, char *session_id) +int lttng_ust_stop_trace(pid_t pid) { int ret; - lsm.cmd_type = LTTNG_CREATE_SESSION; - if (name == NULL) { - lsm.u.create_session.auto_session = 1; - } else { - strncpy(lsm.session_name, name, strlen(name)); - lsm.u.create_session.auto_session = 0; - } + lsm.pid = pid; + ret = ask_sessiond(UST_STOP_TRACE, NULL); - /* Ask the session daemon */ - ret = ask_sessiond(); - if (ret < 0) { - goto end; - } + return ret; +} - /* Unparse session ID */ - uuid_unparse(llm.session_id, session_id); +/* + * lttng_ust_create_trace + * + * Request a trace creation for pid. + */ +int lttng_ust_create_trace(pid_t pid) +{ + int ret; -end: - reset_data_struct(); + lsm.pid = pid; + ret = ask_sessiond(UST_CREATE_TRACE, NULL); return ret; } @@ -164,43 +223,107 @@ end: * Ask the session daemon for all UST traceable * applications. * - * Return the size of pids. + * Return the number of pids. + * On error, return negative value. */ -size_t lttng_ust_list_apps(pid_t **pids) +int lttng_ust_list_apps(pid_t **pids) { - int ret, first = 0; - size_t size = 0; - pid_t *p = NULL; + int ret; - lsm.cmd_type = UST_LIST_APPS; + ret = ask_sessiond(UST_LIST_APPS, (void**) pids); + if (ret < 0) { + return ret; + } + + return ret / sizeof(pid_t); +} - ret = ask_sessiond(); +/* + * lttng_list_traces + * + * Ask the session daemon for all traces (kernel and ust) + * for the session identified by uuid. + * + * Return the number of traces. + */ +int lttng_list_traces(uuid_t *uuid, struct lttng_trace **traces) +{ + int ret; + + uuid_copy(lsm.session_uuid, *uuid); + + ret = ask_sessiond(LTTNG_LIST_TRACES, (void **) traces); if (ret < 0) { - goto error; + return ret; } - do { - ret = recvfrom_sessiond(); - if (ret < 0) { - goto error; - } + return ret / sizeof(struct lttng_trace); +} - if (first == 0) { - first = 1; - size = llm.num_pckt; - p = malloc(sizeof(pid_t) * size); - } - p[size - llm.num_pckt] = llm.u.list_apps.pid; - } while ((llm.num_pckt-1) != 0); +/* + * lttng_create_session + * + * Create a brand new session using name. Allocate + * the session_id param pointing to the UUID. + */ +int lttng_create_session(char *name, uuid_t *session_id) +{ + int ret; + + strncpy(lsm.session_name, name, sizeof(lsm.session_name)); + lsm.session_name[sizeof(lsm.session_name) - 1] = '\0'; + + ret = ask_sessiond(LTTNG_CREATE_SESSION, NULL); + if (ret < 0) { + goto end; + } + + uuid_copy(*session_id, llm.session_uuid); + +end: + return ret; +} + +/* + * lttng_destroy_session + * + * Destroy session using name. + */ +int lttng_destroy_session(uuid_t *uuid) +{ + int ret; - *pids = p; + uuid_copy(lsm.session_uuid, *uuid); - return size; + ret = ask_sessiond(LTTNG_DESTROY_SESSION, NULL); + if (ret < 0) { + goto end; + } -error: +end: return ret; } +/* + * lttng_list_sessions + * + * Ask the session daemon for all available sessions. + * + * Return number of session. + * On error, return negative value. + */ +int lttng_list_sessions(struct lttng_session **sessions) +{ + int ret; + + ret = ask_sessiond(LTTNG_LIST_SESSIONS, (void**) sessions); + if (ret < 0) { + return ret; + } + + return ret / sizeof(struct lttng_session); +} + /* * lttng_connect_sessiond * @@ -229,6 +352,34 @@ int lttng_connect_sessiond(void) return 0; } +/* + * lttng_disconnect_sessiond + * + * Clean disconnect the session daemon. + */ +int lttng_disconnect_sessiond(void) +{ + int ret = 0; + + if (connected) { + ret = lttcomm_close_unix_sock(sessiond_socket); + sessiond_socket = 0; + connected = 0; + } + + return ret; +} + +/* + * lttng_set_current_session_uuid + * + * Set the session uuid for current lsm. + */ +void lttng_set_current_session_uuid(uuid_t *uuid) +{ + uuid_copy(lsm.session_uuid, *uuid); +} + /* * lttng_set_tracing_group * @@ -268,17 +419,6 @@ int lttng_check_session_daemon(void) return 0; } -/* - * reset_data_struct - * - * Reset session daemon structures. - */ -static void reset_data_struct(void) -{ - memset(&lsm, 0, sizeof(lsm)); - memset(&llm, 0, sizeof(llm)); -} - /* * set_session_daemon_path * @@ -291,7 +431,7 @@ static int set_session_daemon_path(void) /* Are we in the tracing group ? */ ret = check_tracing_group(tracing_group); - if (ret < 0) { + if (ret < 0 && getuid() != 0) { if (sprintf(sessiond_sock_path, DEFAULT_HOME_CLIENT_UNIX_SOCK, getenv("HOME")) < 0) { return -ENOMEM;