X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=liblttngctl%2Fliblttngctl.c;h=e693123b9c1c384b5d18f8f9eaa1d64984fe991d;hp=1793bc53ad44a23195157427b30950f85bb8e9d6;hb=38057ed1e3358090cd03b81ce8414b032eb56f43;hpb=96243366860d20e371efed0500070cdbc4a01ec7 diff --git a/liblttngctl/liblttngctl.c b/liblttngctl/liblttngctl.c index 1793bc53a..e693123b9 100644 --- a/liblttngctl/liblttngctl.c +++ b/liblttngctl/liblttngctl.c @@ -28,6 +28,7 @@ #include "liblttsessiondcomm.h" #include "lttngerr.h" +#include "lttng-share.h" /* Socket to session daemon for communication */ static int sessiond_socket; @@ -37,13 +38,6 @@ static char sessiond_sock_path[PATH_MAX]; 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(enum lttcomm_command_type 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); - /* Variables */ static char *tracing_group; static int connected; @@ -89,29 +83,141 @@ static int recv_data_sessiond(void *buf, size_t len) } ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len); - if (ret < 0) { + +end: + return ret; +} + +/* + * Check if the specified group name exist. + * + * If yes return 0, else return -1. + */ +static int check_tracing_group(const char *grp_name) +{ + struct group *grp_tracing; /* no free(). See getgrnam(3) */ + gid_t *grp_list; + int grp_list_size, grp_id, i; + int ret = -1; + + /* Get GID of group 'tracing' */ + grp_tracing = getgrnam(grp_name); + if (grp_tracing == NULL) { + /* NULL means not found also. getgrnam(3) */ + if (errno != 0) { + perror("getgrnam"); + } goto end; } + /* Get number of supplementary group IDs */ + grp_list_size = getgroups(0, NULL); + if (grp_list_size < 0) { + perror("getgroups"); + goto end; + } + + /* Alloc group list of the right size */ + grp_list = malloc(grp_list_size * sizeof(gid_t)); + grp_id = getgroups(grp_list_size, grp_list); + if (grp_id < -1) { + perror("getgroups"); + goto free_list; + } + + for (i = 0; i < grp_list_size; i++) { + if (grp_list[i] == grp_tracing->gr_gid) { + ret = 0; + break; + } + } + +free_list: + free(grp_list); + end: return ret; } +/* + * Set sessiond socket path by putting it in the global sessiond_sock_path + * variable. + */ +static int set_session_daemon_path(void) +{ + int ret; + + /* Are we in the tracing group ? */ + ret = check_tracing_group(tracing_group); + if (ret < 0 && getuid() != 0) { + if (sprintf(sessiond_sock_path, DEFAULT_HOME_CLIENT_UNIX_SOCK, + getenv("HOME")) < 0) { + return -ENOMEM; + } + } else { + strncpy(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, + sizeof(DEFAULT_GLOBAL_CLIENT_UNIX_SOCK)); + } + + return 0; +} + +/* + * Connect to the LTTng session daemon. + * + * On success, return 0. On error, return -1. + */ +static int connect_sessiond(void) +{ + int ret; + + ret = set_session_daemon_path(); + if (ret < 0) { + return ret; + } + + /* Connect to the sesssion daemon */ + ret = lttcomm_connect_unix_sock(sessiond_sock_path); + if (ret < 0) { + return ret; + } + + sessiond_socket = ret; + connected = 1; + + return 0; +} + +/* + * Clean disconnect the session daemon. + */ +static int disconnect_sessiond(void) +{ + int ret = 0; + + if (connected) { + ret = lttcomm_close_unix_sock(sessiond_socket); + sessiond_socket = 0; + connected = 0; + } + + return ret; +} + /* * ask_sessiond * - * Ask the session daemon a specific command - * and put the data into buf. + * 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_command_type lct, void **buf) +static int ask_sessiond(enum lttcomm_sessiond_command lct, void **buf) { int ret; size_t size; void *data = NULL; - ret = lttng_connect_sessiond(); + ret = connect_sessiond(); if (ret < 0) { goto end; } @@ -136,8 +242,9 @@ static int ask_sessiond(enum lttcomm_command_type lct, void **buf) goto end; } - size = llm.size_payload; + size = llm.data_size; if (size == 0) { + ret = 0; goto end; } @@ -146,6 +253,7 @@ static int ask_sessiond(enum lttcomm_command_type lct, void **buf) /* Get payload data */ ret = recv_data_sessiond(data, size); if (ret < 0) { + free(data); goto end; } @@ -153,231 +261,259 @@ static int ask_sessiond(enum lttcomm_command_type lct, void **buf) ret = size; end: - lttng_disconnect_sessiond(); - memset(&lsm, 0, sizeof(lsm)); + disconnect_sessiond(); return ret; } /* - * lttng_get_readable_code - * - * Return a human readable string of code + * Start tracing for all trace of the session. */ -const char *lttng_get_readable_code(int code) +int lttng_start_tracing(const char *session_name) { - if (code > -LTTCOMM_OK) { - return "Ended with errors"; - } - - return lttcomm_get_readable_code(code); + strncpy(lsm.session_name, session_name, NAME_MAX); + return ask_sessiond(LTTNG_START_TRACE, NULL); } /* - * lttng_ust_start_trace - * - * Request a trace start for pid. + * Stop tracing for all trace of the session. */ -int lttng_ust_start_trace(pid_t pid) +int lttng_stop_tracing(const char *session_name) { - int ret; - - lsm.pid = pid; - ret = ask_sessiond(UST_START_TRACE, NULL); - - return ret; + strncpy(lsm.session_name, session_name, NAME_MAX); + return ask_sessiond(LTTNG_STOP_TRACE, NULL); } /* - * lttng_ust_stop_trace - * - * Request a trace stop for pid. + * lttng_add_context */ -int lttng_ust_stop_trace(pid_t pid) +int lttng_add_context(struct lttng_domain *domain, + struct lttng_event_context *ctx, const char *event_name, + const char *channel_name) { int ret; - lsm.pid = pid; - ret = ask_sessiond(UST_STOP_TRACE, NULL); + if (channel_name != NULL) { + strncpy(lsm.u.context.channel_name, channel_name, NAME_MAX); + } + + if (event_name != NULL) { + strncpy(lsm.u.context.event_name, event_name, NAME_MAX); + } + + memcpy(&lsm.u.context.ctx, ctx, sizeof(struct lttng_event_context)); + + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + ret = ask_sessiond(LTTNG_KERNEL_ADD_CONTEXT, NULL); + break; + case LTTNG_DOMAIN_UST: + ret = LTTCOMM_NOT_IMPLEMENTED; + break; + default: + ret = LTTCOMM_UNKNOWN_DOMAIN; + break; + }; return ret; } /* - * lttng_ust_create_trace - * - * Request a trace creation for pid. + * lttng_enable_event */ -int lttng_ust_create_trace(pid_t pid) +int lttng_enable_event(struct lttng_domain *domain, + struct lttng_event *ev, const char *channel_name) { int ret; - lsm.pid = pid; - ret = ask_sessiond(UST_CREATE_TRACE, NULL); + if (channel_name == NULL) { + strncpy(lsm.u.enable.channel_name, DEFAULT_CHANNEL_NAME, NAME_MAX); + } else { + strncpy(lsm.u.enable.channel_name, channel_name, NAME_MAX); + } + + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + if (ev == NULL) { + ret = ask_sessiond(LTTNG_KERNEL_ENABLE_ALL_EVENT, NULL); + } else { + memcpy(&lsm.u.enable.event, ev, sizeof(struct lttng_event)); + ret = ask_sessiond(LTTNG_KERNEL_ENABLE_EVENT, NULL); + } + break; + case LTTNG_DOMAIN_UST: + ret = LTTCOMM_NOT_IMPLEMENTED; + break; + default: + ret = LTTCOMM_UNKNOWN_DOMAIN; + break; + }; return ret; } /* - * lttng_ust_list_apps - * - * Ask the session daemon for all UST traceable - * applications. - * - * Return the number of pids. - * On error, return negative value. + * Disable an event in the kernel tracer. */ -int lttng_ust_list_apps(pid_t **pids) +int lttng_disable_event(struct lttng_domain *domain, const char *name, + const char *channel_name) { int ret; - ret = ask_sessiond(UST_LIST_APPS, (void**) pids); - if (ret < 0) { - return ret; + if (channel_name == NULL) { + strncpy(lsm.u.disable.channel_name, DEFAULT_CHANNEL_NAME, NAME_MAX); + } else { + strncpy(lsm.u.disable.channel_name, channel_name, NAME_MAX); } - return ret / sizeof(pid_t); + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + if (name == NULL) { + ret = ask_sessiond(LTTNG_KERNEL_DISABLE_ALL_EVENT, NULL); + } else { + strncpy(lsm.u.disable.name, name, NAME_MAX); + ret = ask_sessiond(LTTNG_KERNEL_DISABLE_EVENT, NULL); + } + break; + case LTTNG_DOMAIN_UST: + ret = LTTCOMM_NOT_IMPLEMENTED; + break; + default: + ret = LTTCOMM_UNKNOWN_DOMAIN; + break; + }; + + return ret; } /* - * lttng_list_traces - * - * Ask the session daemon for all traces (kernel and ust) - * for the session identified by uuid. - * - * Return the number of traces. + * Enable recording for a channel for the kernel tracer. */ -int lttng_list_traces(uuid_t *uuid, struct lttng_trace **traces) +int lttng_enable_channel(struct lttng_domain *domain, + struct lttng_channel *chan) { int ret; - uuid_copy(lsm.session_id, *uuid); + memcpy(&lsm.u.channel.chan, chan, sizeof(struct lttng_channel)); - ret = ask_sessiond(LTTNG_LIST_TRACES, (void **) traces); - if (ret < 0) { - return ret; - } + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + ret = ask_sessiond(LTTNG_KERNEL_ENABLE_CHANNEL, NULL); + break; + case LTTNG_DOMAIN_UST: + ret = LTTCOMM_NOT_IMPLEMENTED; + break; + default: + ret = LTTCOMM_UNKNOWN_DOMAIN; + break; + }; - return ret / sizeof(struct lttng_trace); + return ret; } /* - * lttng_create_session - * - * Create a brand new session using name. Allocate - * the session_id param pointing to the UUID. + * Disable recording for the channel for the kernel tracer. */ -int lttng_create_session(char *name, uuid_t *session_id) +int lttng_disable_channel(struct lttng_domain *domain, const char *name) { 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; - } + strncpy(lsm.u.disable.channel_name, name, NAME_MAX); - uuid_copy(*session_id, llm.session_id); + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + ret = ask_sessiond(LTTNG_KERNEL_DISABLE_CHANNEL, NULL); + break; + case LTTNG_DOMAIN_UST: + ret = LTTCOMM_NOT_IMPLEMENTED; + break; + default: + ret = LTTCOMM_UNKNOWN_DOMAIN; + break; + }; -end: return ret; } /* - * lttng_destroy_session + * List all available events in the kernel. * - * Destroy session using name. + * Return the size (bytes) of the list and set the event_list array. + * On error, return negative value. */ -int lttng_destroy_session(uuid_t *uuid) +int lttng_list_events(struct lttng_domain *domain, char **event_list) { int ret; - uuid_copy(lsm.session_id, *uuid); - - ret = ask_sessiond(LTTNG_DESTROY_SESSION, NULL); - if (ret < 0) { - goto end; - } + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + ret = ask_sessiond(LTTNG_KERNEL_LIST_EVENTS, (void **) event_list); + break; + case LTTNG_DOMAIN_UST: + ret = LTTCOMM_NOT_IMPLEMENTED; + break; + default: + ret = LTTCOMM_UNKNOWN_DOMAIN; + break; + }; -end: return ret; } /* - * lttng_list_sessions - * - * Ask the session daemon for all available sessions. - * - * Return number of session. - * On error, return negative value. + * Return a human readable string of code */ -int lttng_list_sessions(struct lttng_session **sessions) +const char *lttng_get_readable_code(int code) { - int ret; - - ret = ask_sessiond(LTTNG_LIST_SESSIONS, (void**) sessions); - if (ret < 0) { - return ret; + if (code > -LTTCOMM_OK) { + return "Ended with errors"; } - return ret / sizeof(struct lttng_session); + return lttcomm_get_readable_code(code); } /* - * lttng_connect_sessiond - * - * Connect to the LTTng session daemon. - * On success, return 0 - * On error, return a negative value + * Create a brand new session using name. */ -int lttng_connect_sessiond(void) +int lttng_create_session(const char *name, const char *path) { - int ret; - - ret = set_session_daemon_path(); - if (ret < 0) { - return ret; - } - - /* Connect to the sesssion daemon */ - ret = lttcomm_connect_unix_sock(sessiond_sock_path); - if (ret < 0) { - return ret; - } - - sessiond_socket = ret; - connected = 1; + strncpy(lsm.session_name, name, NAME_MAX); + strncpy(lsm.path, path, PATH_MAX); + return ask_sessiond(LTTNG_CREATE_SESSION, NULL); +} - return 0; +/* + * Destroy session using name. + */ +int lttng_destroy_session(const char *name) +{ + strncpy(lsm.session_name, name, NAME_MAX); + return ask_sessiond(LTTNG_DESTROY_SESSION, NULL); } /* - * lttng_disconnect_sessiond + * Ask the session daemon for all available sessions. * - * Clean disconnect the session daemon. + * Return number of session. + * On error, return negative value. */ -int lttng_disconnect_sessiond(void) +int lttng_list_sessions(struct lttng_session **sessions) { - int ret = 0; + int ret; - if (connected) { - ret = lttcomm_close_unix_sock(sessiond_socket); - sessiond_socket = 0; - connected = 0; + ret = ask_sessiond(LTTNG_LIST_SESSIONS, (void**) sessions); + if (ret < 0) { + return ret; } - return ret; + return ret / sizeof(struct lttng_session); } /* - * lttng_set_current_session_uuid - * - * Set the session uuid for current lsm. + * Set session name for the current lsm. */ -void lttng_set_current_session_uuid(uuid_t *uuid) +void lttng_set_session_name(const char *name) { - uuid_copy(lsm.session_id, *uuid); + strncpy(lsm.session_name, name, NAME_MAX); } /* @@ -398,102 +534,29 @@ int lttng_set_tracing_group(const char *name) /* * lttng_check_session_daemon * - * Return 0 if a sesssion daemon is available - * else return -1 + * Yes, return 1 + * No, return 0 + * Error, return negative value */ -int lttng_check_session_daemon(void) +int lttng_session_daemon_alive(void) { int ret; ret = set_session_daemon_path(); if (ret < 0) { + /* Error */ return ret; } /* If socket exist, we consider the daemon started */ ret = access(sessiond_sock_path, F_OK); if (ret < 0) { - return ret; - } - - return 0; -} - -/* - * set_session_daemon_path - * - * Set sessiond socket path by putting it in - * the global sessiond_sock_path variable. - */ -static int set_session_daemon_path(void) -{ - int ret; - - /* Are we in the tracing group ? */ - ret = check_tracing_group(tracing_group); - if (ret < 0) { - if (sprintf(sessiond_sock_path, DEFAULT_HOME_CLIENT_UNIX_SOCK, - getenv("HOME")) < 0) { - return -ENOMEM; - } - } else { - strncpy(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, - sizeof(DEFAULT_GLOBAL_CLIENT_UNIX_SOCK)); - } - - return 0; -} - -/* - * check_tracing_group - * - * Check if the specified group name exist. - * If yes, 0, else -1 - */ -static int check_tracing_group(const char *grp_name) -{ - struct group *grp_tracing; /* no free(). See getgrnam(3) */ - gid_t *grp_list; - int grp_list_size, grp_id, i; - int ret = -1; - - /* Get GID of group 'tracing' */ - grp_tracing = getgrnam(grp_name); - if (grp_tracing == NULL) { - /* NULL means not found also. getgrnam(3) */ - if (errno != 0) { - perror("getgrnam"); - } - goto end; - } - - /* Get number of supplementary group IDs */ - grp_list_size = getgroups(0, NULL); - if (grp_list_size < 0) { - perror("getgroups"); - goto end; - } - - /* Alloc group list of the right size */ - grp_list = malloc(grp_list_size * sizeof(gid_t)); - grp_id = getgroups(grp_list_size, grp_list); - if (grp_id < -1) { - perror("getgroups"); - goto free_list; + /* Not alive */ + return 0; } - for (i = 0; i < grp_list_size; i++) { - if (grp_list[i] == grp_tracing->gr_gid) { - ret = 0; - break; - } - } - -free_list: - free(grp_list); - -end: - return ret; + /* Is alive */ + return 1; } /* @@ -502,5 +565,5 @@ end: static void __attribute__((constructor)) init() { /* Set default session group */ - lttng_set_tracing_group(DEFAULT_TRACING_GROUP); + lttng_set_tracing_group(LTTNG_DEFAULT_TRACING_GROUP); }