X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=liblttngctl%2Fliblttngctl.c;h=eb606166c214c9bd850ca7889d961547974ab4cf;hp=fda45ae10d2bc423dea61b94f3a2521c5c074b0c;hb=33a2b85433875769e92ca44a680c46b9498f5174;hpb=ca95a21633510288dbb18a3cd8825195e5cbb4f3 diff --git a/liblttngctl/liblttngctl.c b/liblttngctl/liblttngctl.c index fda45ae10..eb606166c 100644 --- a/liblttngctl/liblttngctl.c +++ b/liblttngctl/liblttngctl.c @@ -24,7 +24,7 @@ #include #include -#include +#include #include "liblttsessiondcomm.h" #include "lttngerr.h" @@ -35,13 +35,7 @@ static char sessiond_sock_path[PATH_MAX]; /* Communication structure to ltt-sessiond */ static struct lttcomm_session_msg lsm; - -/* 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); +static struct lttcomm_lttng_msg llm; /* Variables */ static char *tracing_group; @@ -88,9 +82,6 @@ static int recv_data_sessiond(void *buf, size_t len) } ret = lttcomm_recv_unix_sock(sessiond_socket, buf, len); - if (ret < 0) { - goto end; - } end: return ret; @@ -99,17 +90,20 @@ end: /* * 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; - struct lttcomm_lttng_msg llm; + + ret = lttng_connect_sessiond(); + if (ret < 0) { + goto end; + } lsm.cmd_type = lct; @@ -131,7 +125,7 @@ static int ask_sessiond(enum lttcomm_command_type lct, void **buf) goto end; } - size = llm.size_payload; + size = llm.trace_name_offset + llm.data_size; if (size == 0) { goto end; } @@ -141,6 +135,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; } @@ -148,11 +143,198 @@ static int ask_sessiond(enum lttcomm_command_type lct, void **buf) ret = size; end: - /* Reset lsm data struct */ - memset(&lsm, 0, sizeof(lsm)); + lttng_disconnect_sessiond(); + return ret; +} + +/* + * 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; + } + + 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_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 && 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; +} + +/* + * BEGIN KERNEL CONTROL + */ + +/* + * lttng_kernel_enable_event + * + * Enable an event in the kernel tracer. + */ +int lttng_kernel_enable_event(char *event_name) +{ + int ret; + + if (event_name == NULL) { + ret = ask_sessiond(KERNEL_ENABLE_ALL_EVENT, NULL); + } else { + strncpy(lsm.u.event.event_name, event_name, NAME_MAX); + ret = ask_sessiond(KERNEL_ENABLE_EVENT, NULL); + } + return ret; } +/* + * lttng_kernel_disable_event + * + * Disable an event in the kernel tracer. + */ +int lttng_kernel_disable_event(char *event_name) +{ + strncpy(lsm.u.event.event_name, event_name, NAME_MAX); + return ask_sessiond(KERNEL_DISABLE_EVENT, NULL); +} + +/* + * lttng_kernel_create_session + * + * Create a session in the kernel tracer. + */ +int lttng_kernel_create_session(void) +{ + return ask_sessiond(KERNEL_CREATE_SESSION, NULL); +} + +/* + * lttng_kernel_create_channel + * + * Create a channel in the kernel tracer. + */ +int lttng_kernel_create_channel(void) +{ + return ask_sessiond(KERNEL_CREATE_CHANNEL, NULL); +} + +/* + * lttng_kernel_open_metadata + * + * Open metadata in the kernel tracer. + */ +int lttng_kernel_open_metadata(void) +{ + return ask_sessiond(KERNEL_OPEN_METADATA, NULL); +} + +/* + * lttng_kernel_create_stream + * + * Create stream in the kernel tracer. + */ +int lttng_kernel_create_stream(void) +{ + return ask_sessiond(KERNEL_CREATE_STREAM, NULL); +} + +/* + * lttng_kernel_list_events + * + * List all available events in the kernel. + * + * Return the size (bytes) of the list and set the event_list array. + * On error, return negative value. + */ +int lttng_kernel_list_events(char **event_list) +{ + return ask_sessiond(KERNEL_LIST_EVENTS, (void **) event_list); +} + +/* + * lttng_kernel_start_tracing + * + * Start kernel tracing. + */ +int lttng_kernel_start_tracing(void) +{ + return ask_sessiond(KERNEL_START_TRACE, NULL); +} + +/* + * lttng_kernel_stop_tracing + * + * Stop kernel tracing. + */ +int lttng_kernel_stop_tracing(void) +{ + return ask_sessiond(KERNEL_STOP_TRACE, NULL); +} + +/* + * END KERNEL CONTROL + */ + /* * lttng_get_readable_code * @@ -167,11 +349,43 @@ const char *lttng_get_readable_code(int code) return lttcomm_get_readable_code(code); } +/* + * lttng_ust_start_trace + * + * Request a trace start for pid. + */ +int lttng_ust_start_trace(pid_t pid) +{ + lsm.pid = pid; + return ask_sessiond(UST_START_TRACE, NULL); +} + +/* + * lttng_ust_stop_trace + * + * Request a trace stop for pid. + */ +int lttng_ust_stop_trace(pid_t pid) +{ + lsm.pid = pid; + return ask_sessiond(UST_STOP_TRACE, NULL); +} + +/* + * lttng_ust_create_trace + * + * Request a trace creation for pid. + */ +int lttng_ust_create_trace(pid_t pid) +{ + lsm.pid = pid; + return ask_sessiond(UST_CREATE_TRACE, NULL); +} + /* * lttng_ust_list_apps * - * Ask the session daemon for all UST traceable - * applications. + * Ask the session daemon for all UST traceable applications. * * Return the number of pids. * On error, return negative value. @@ -188,6 +402,51 @@ int lttng_ust_list_apps(pid_t **pids) return ret / sizeof(pid_t); } +/* + * lttng_list_traces + * + * Ask the session daemon for all traces (kernel and ust) for the session + * identified by uuid. + * + * Return the number of traces. + * On error, return negative value. + */ +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) { + return ret; + } + + return ret / sizeof(struct lttng_trace); +} + +/* + * lttng_create_session + * + * Create a brand new session using name. + */ +int lttng_create_session(char *name) +{ + strncpy(lsm.session_name, name, NAME_MAX); + return ask_sessiond(LTTNG_CREATE_SESSION, NULL); +} + +/* + * lttng_destroy_session + * + * Destroy session using name. + */ +int lttng_destroy_session(uuid_t *uuid) +{ + uuid_copy(lsm.session_uuid, *uuid); + return ask_sessiond(LTTNG_DESTROY_SESSION, NULL); +} + /* * lttng_list_sessions * @@ -237,119 +496,74 @@ int lttng_connect_sessiond(void) } /* - * lttng_set_tracing_group + * lttng_disconnect_sessiond * - * 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) +int lttng_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 + * lttng_set_current_session_uuid * - * Return 0 if a sesssion daemon is available - * else return -1 + * Set the session uuid for current lsm. */ -int lttng_check_session_daemon(void) +void lttng_set_current_session_uuid(uuid_t *uuid) { - int ret; - - ret = set_session_daemon_path(); - if (ret < 0) { - return ret; - } - - /* If socket exist, we consider the daemon started */ - ret = access(sessiond_sock_path, F_OK); - if (ret < 0) { - return ret; - } - - return 0; + uuid_copy(lsm.session_uuid, *uuid); } /* - * set_session_daemon_path + * lttng_set_tracing_group * - * Set sessiond socket path by putting it in - * the global sessiond_sock_path variable. + * Set tracing group variable with name. This function + * allocate memory pointed by tracing_group. */ -static int set_session_daemon_path(void) +int lttng_set_tracing_group(const char *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; - } - } else { - strncpy(sessiond_sock_path, DEFAULT_GLOBAL_CLIENT_UNIX_SOCK, - sizeof(DEFAULT_GLOBAL_CLIENT_UNIX_SOCK)); + if (asprintf(&tracing_group, "%s", name) < 0) { + return -ENOMEM; } return 0; } /* - * check_tracing_group + * lttng_check_session_daemon * - * Check if the specified group name exist. - * If yes, 0, else -1 + * Yes, return 1 + * No, return 0 + * Error, return negative value */ -static int check_tracing_group(const char *grp_name) +int lttng_session_daemon_alive(void) { - 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; - } + int 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; + ret = set_session_daemon_path(); + if (ret < 0) { + /* Error */ + return ret; } - for (i = 0; i < grp_list_size; i++) { - if (grp_list[i] == grp_tracing->gr_gid) { - ret = 0; - break; - } + /* If socket exist, we consider the daemon started */ + ret = access(sessiond_sock_path, F_OK); + if (ret < 0) { + /* Not alive */ + return 0; } -free_list: - free(grp_list); - -end: - return ret; + /* Is alive */ + return 1; } /* @@ -358,5 +572,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); }