X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=liblttngctl%2Fliblttngctl.c;h=e693123b9c1c384b5d18f8f9eaa1d64984fe991d;hp=8258874dc56efd23bd679181be6e1a57c6a37f0e;hb=38057ed1e3358090cd03b81ce8414b032eb56f43;hpb=fac6795d6e2c60e79bdc7dab42da94d2025a57d3 diff --git a/liblttngctl/liblttngctl.c b/liblttngctl/liblttngctl.c index 8258874dc..e693123b9 100644 --- a/liblttngctl/liblttngctl.c +++ b/liblttngctl/liblttngctl.c @@ -1,4 +1,5 @@ -/* Copyright (C) 2011 David Goulet +/* + * Copyright (C) 2011 David Goulet * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -13,7 +14,6 @@ * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * */ #define _GNU_SOURCE @@ -24,159 +24,150 @@ #include #include -#include +#include #include "liblttsessiondcomm.h" #include "lttngerr.h" +#include "lttng-share.h" /* Socket to session daemon for communication */ 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; - -/* Prototypes */ -static int check_tracing_group(const char *grp_name); -static int ask_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); +static struct lttcomm_lttng_msg llm; /* Variables */ static char *tracing_group; static int connected; /* - * ask_sessiond + * send_data_sessiond * - * Send lttcomm_session_msg to the daemon and wait - * for the reply. Data replied will be put in llm + * 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; if (!connected) { - ret = -ECONNREFUSED; - goto error; + ret = -ENOTCONN; + goto end; } ret = lttcomm_send_unix_sock(sessiond_socket, &lsm, sizeof(lsm)); - if (ret < 0) { - goto error; - } - ret = lttcomm_recv_unix_sock(sessiond_socket, &llm, sizeof(llm)); - if (ret < 0) { - goto error; - } - - /* Check return code */ - if (llm.ret_code != LTTCOMM_OK) { - ret = -llm.ret_code; - goto error; - } - - return 0; - -error: +end: return ret; } /* - * lttng_get_readable_code + * recv_data_sessiond * - * Return a human readable string of code + * Receive data from the sessiond socket. + * + * On success, return 0 + * On error, return recv() error code */ -const char *lttng_get_readable_code(int code) +static int recv_data_sessiond(void *buf, size_t len) { - if (code > -LTTCOMM_OK) { - return "Ended with errors"; + int ret; + + if (!connected) { + ret = -ENOTCONN; + goto end; } - return lttcomm_get_readable_code(code); + ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len); + +end: + return ret; } /* - * lttng_create_session - * - * 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. + * Check if the specified group name exist. * - * On success, return 0 and session_id point to the uuid str. - * On error, negative value is returned. + * If yes return 0, else return -1. */ -int lttng_create_session(const char *name, char *session_id) +static int check_tracing_group(const char *grp_name) { - int ret; + struct group *grp_tracing; /* no free(). See getgrnam(3) */ + gid_t *grp_list; + int grp_list_size, grp_id, i; + int ret = -1; - 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; + /* 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; } - /* Ask the session daemon */ - ret = ask_sessiond(); - if (ret < 0) { + /* Get number of supplementary group IDs */ + grp_list_size = getgroups(0, NULL); + if (grp_list_size < 0) { + perror("getgroups"); goto end; } - /* Unparse session ID */ - uuid_unparse(llm.session_id, session_id); + /* 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: - reset_data_struct(); - return ret; } /* - * lttng_ust_list_apps - * - * Ask the session daemon for all UST traceable - * applications. - * - * Return the size of pids. + * Set sessiond socket path by putting it in the global sessiond_sock_path + * variable. */ -size_t lttng_ust_list_apps(pid_t **pids) +static int set_session_daemon_path(void) { int ret; - lsm.cmd_type = UST_LIST_APPS; - - ret = ask_sessiond(); - if (ret < 0) { - goto error; + /* 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)); } - *pids = llm.u.list_apps.pids; - - return llm.u.list_apps.size; - -error: - return ret; + return 0; } /* - * lttng_connect_sessiond - * * Connect to the LTTng session daemon. - * On success, return 0 - * On error, return a negative value + * + * On success, return 0. On error, return -1. */ -int lttng_connect_sessiond(void) +static int connect_sessiond(void) { int ret; @@ -198,130 +189,374 @@ int lttng_connect_sessiond(void) } /* - * lttng_set_tracing_group - * - * Set tracing group variable with name. This function - * allocate memory pointed by tracing_group. + * Clean disconnect the session daemon. */ -int lttng_set_tracing_group(const char *name) +static int disconnect_sessiond(void) { - if (asprintf(&tracing_group, "%s", name) < 0) { - return -ENOMEM; + int ret = 0; + + if (connected) { + ret = lttcomm_close_unix_sock(sessiond_socket); + sessiond_socket = 0; + connected = 0; } - return 0; + return ret; } /* - * lttng_check_session_daemon + * ask_sessiond + * + * Ask the session daemon a specific command and put the data into buf. * - * Return 0 if a sesssion daemon is available - * else return -1 + * Return size of data (only payload, not header). */ -int lttng_check_session_daemon(void) +static int ask_sessiond(enum lttcomm_sessiond_command lct, void **buf) { int ret; + size_t size; + void *data = NULL; - ret = set_session_daemon_path(); + ret = connect_sessiond(); if (ret < 0) { - return ret; + goto end; } - /* If socket exist, we consider the daemon started */ - ret = access(sessiond_sock_path, F_OK); + lsm.cmd_type = lct; + + /* Send command to session daemon */ + ret = send_data_sessiond(); if (ret < 0) { - return ret; + goto end; } - return 0; + /* Get header from data transmission */ + ret = recv_data_sessiond(&llm, sizeof(llm)); + if (ret < 0) { + goto end; + } + + /* Check error code if OK */ + if (llm.ret_code != LTTCOMM_OK) { + ret = -llm.ret_code; + goto end; + } + + size = llm.data_size; + if (size == 0) { + ret = 0; + goto end; + } + + data = (void*) malloc(size); + + /* Get payload data */ + ret = recv_data_sessiond(data, size); + if (ret < 0) { + free(data); + goto end; + } + + *buf = data; + ret = size; + +end: + disconnect_sessiond(); + return ret; } /* - * reset_data_struct - * - * Reset session daemon structures. + * Start tracing for all trace of the session. */ -static void reset_data_struct(void) +int lttng_start_tracing(const char *session_name) { - memset(&lsm, 0, sizeof(lsm)); - memset(&llm, 0, sizeof(llm)); + strncpy(lsm.session_name, session_name, NAME_MAX); + return ask_sessiond(LTTNG_START_TRACE, NULL); } /* - * set_session_daemon_path - * - * Set sessiond socket path by putting it in - * the global sessiond_sock_path variable. + * Stop tracing for all trace of the session. */ -static int set_session_daemon_path(void) +int lttng_stop_tracing(const char *session_name) +{ + strncpy(lsm.session_name, session_name, NAME_MAX); + return ask_sessiond(LTTNG_STOP_TRACE, NULL); +} + +/* + * lttng_add_context + */ +int lttng_add_context(struct lttng_domain *domain, + struct lttng_event_context *ctx, const char *event_name, + const char *channel_name) { 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; - } + 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_enable_event + */ +int lttng_enable_event(struct lttng_domain *domain, + struct lttng_event *ev, const char *channel_name) +{ + int ret; + + if (channel_name == NULL) { + strncpy(lsm.u.enable.channel_name, DEFAULT_CHANNEL_NAME, NAME_MAX); } else { - strncpy(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, - sizeof(DEFAULT_GLOBAL_CLIENT_UNIX_SOCK)); + strncpy(lsm.u.enable.channel_name, channel_name, NAME_MAX); } - return 0; + 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; +} + +/* + * Disable an event in the kernel tracer. + */ +int lttng_disable_event(struct lttng_domain *domain, const char *name, + const char *channel_name) +{ + int 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); + } + + 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; +} + +/* + * Enable recording for a channel for the kernel tracer. + */ +int lttng_enable_channel(struct lttng_domain *domain, + struct lttng_channel *chan) +{ + int ret; + + memcpy(&lsm.u.channel.chan, chan, sizeof(struct lttng_channel)); + + 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; +} + +/* + * Disable recording for the channel for the kernel tracer. + */ +int lttng_disable_channel(struct lttng_domain *domain, const char *name) +{ + int ret; + + strncpy(lsm.u.disable.channel_name, name, NAME_MAX); + + 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; + }; + + return ret; } /* - * check_tracing_group + * List all available events in the kernel. * - * Check if the specified group name exist. - * If yes, 0, else -1 + * Return the size (bytes) of the list and set the event_list array. + * On error, return negative value. */ -static int check_tracing_group(const char *grp_name) +int lttng_list_events(struct lttng_domain *domain, char **event_list) { - struct group *grp_tracing; /* no free(). See getgrnam(3) */ - gid_t *grp_list; - int grp_list_size, grp_id, i; - int ret = -1; + int ret; - /* 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; + 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; + }; + + return ret; +} + +/* + * Return a human readable string of code + */ +const char *lttng_get_readable_code(int code) +{ + if (code > -LTTCOMM_OK) { + return "Ended with errors"; } - /* Get number of supplementary group IDs */ - grp_list_size = getgroups(0, NULL); - if (grp_list_size < 0) { - perror("getgroups"); - goto end; + return lttcomm_get_readable_code(code); +} + +/* + * Create a brand new session using name. + */ +int lttng_create_session(const char *name, const char *path) +{ + strncpy(lsm.session_name, name, NAME_MAX); + strncpy(lsm.path, path, PATH_MAX); + return ask_sessiond(LTTNG_CREATE_SESSION, NULL); +} + +/* + * 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); +} + +/* + * 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; } - /* 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; + return ret / sizeof(struct lttng_session); +} + +/* + * Set session name for the current lsm. + */ +void lttng_set_session_name(const char *name) +{ + strncpy(lsm.session_name, name, NAME_MAX); +} + +/* + * lttng_set_tracing_group + * + * Set tracing group variable with name. This function + * allocate memory pointed by tracing_group. + */ +int lttng_set_tracing_group(const char *name) +{ + if (asprintf(&tracing_group, "%s", name) < 0) { + return -ENOMEM; } - for (i = 0; i < grp_list_size; i++) { - if (grp_list[i] == grp_tracing->gr_gid) { - ret = 0; - break; - } + return 0; +} + +/* + * lttng_check_session_daemon + * + * Yes, return 1 + * No, return 0 + * Error, return negative value + */ +int lttng_session_daemon_alive(void) +{ + int ret; + + ret = set_session_daemon_path(); + if (ret < 0) { + /* Error */ + return ret; } -free_list: - free(grp_list); + /* If socket exist, we consider the daemon started */ + ret = access(sessiond_sock_path, F_OK); + if (ret < 0) { + /* Not alive */ + return 0; + } -end: - return ret; + /* Is alive */ + return 1; } /* @@ -330,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); }