X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=liblttngctl%2Fliblttngctl.c;h=e693123b9c1c384b5d18f8f9eaa1d64984fe991d;hp=7ddbc3099d102de20d83e87f0990c5ab65e830c5;hb=38057ed1e3358090cd03b81ce8414b032eb56f43;hpb=d36b858358a8ef4e00de843379d670925f9c23b6 diff --git a/liblttngctl/liblttngctl.c b/liblttngctl/liblttngctl.c index 7ddbc3099..e693123b9 100644 --- a/liblttngctl/liblttngctl.c +++ b/liblttngctl/liblttngctl.c @@ -89,70 +89,9 @@ end: } /* - * 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 error code if OK */ - if (llm.ret_code != LTTCOMM_OK) { - ret = -llm.ret_code; - goto end; - } - - size = llm.data_size; - if (size == 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: - lttng_disconnect_sessiond(); - return ret; -} - -/* - * check_tracing_group - * * Check if the specified group name exist. - * If yes, 0, else -1 + * + * If yes return 0, else return -1. */ static int check_tracing_group(const char *grp_name) { @@ -201,10 +140,8 @@ end: } /* - * set_session_daemon_path - * - * Set sessiond socket path by putting it in - * the global sessiond_sock_path variable. + * Set sessiond socket path by putting it in the global sessiond_sock_path + * variable. */ static int set_session_daemon_path(void) { @@ -226,193 +163,318 @@ static int set_session_daemon_path(void) } /* - * lttng_start_tracing + * 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. + * + * 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 = 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 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; +} + +/* * Start tracing for all trace of the session. */ -int lttng_start_tracing(char *session_name) +int lttng_start_tracing(const char *session_name) { strncpy(lsm.session_name, session_name, NAME_MAX); return ask_sessiond(LTTNG_START_TRACE, NULL); } /* - * lttng_stop_tracing - * * Stop tracing for all trace of the session. */ -int lttng_stop_tracing(char *session_name) +int lttng_stop_tracing(const char *session_name) { strncpy(lsm.session_name, session_name, NAME_MAX); return ask_sessiond(LTTNG_STOP_TRACE, NULL); } /* - * BEGIN Kernel control API + * 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; + + 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_kernel_enable_event + * lttng_enable_event */ -int lttng_kernel_enable_event(struct lttng_event *ev, char *channel_name) +int lttng_enable_event(struct lttng_domain *domain, + struct lttng_event *ev, const char *channel_name) { int ret; - if (strlen(channel_name) == 0) { + 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); } - 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); - } + 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_kernel_disable_event - * - * Disable an event in the kernel tracer. + * Disable an event in the kernel tracer. */ -int lttng_kernel_disable_event(char *name, char *channel_name) +int lttng_disable_event(struct lttng_domain *domain, const char *name, + const char *channel_name) { int ret; - if (strlen(channel_name) == 0) { + 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); } - 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); - } + 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_kernel_enable_channel - * - * Enable recording for a channel for the kernel tracer. + * Enable recording for a channel for the kernel tracer. */ -int lttng_kernel_enable_channel(char *name) +int lttng_enable_channel(struct lttng_domain *domain, + struct lttng_channel *chan) { - strncpy(lsm.u.enable.channel_name, name, NAME_MAX); - return ask_sessiond(LTTNG_KERNEL_ENABLE_CHANNEL, NULL); -} - -/* - * lttng_kernel_disable_channel - * - * Disable recording for the channel for the kernel tracer. - */ -int lttng_kernel_disable_channel(char *name) -{ - return ask_sessiond(LTTNG_KERNEL_DISABLE_CHANNEL, NULL); -} + int ret; -/* - * lttng_kernel_create_channel - * - * Create a channel in the kernel tracer. - */ -int lttng_kernel_create_channel(struct lttng_channel *chan) -{ memcpy(&lsm.u.channel.chan, chan, sizeof(struct lttng_channel)); - return ask_sessiond(LTTNG_KERNEL_CREATE_CHANNEL, NULL); + + 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; } /* - * lttng_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. + * Disable recording for the channel for the kernel tracer. */ -int lttng_kernel_list_events(char **event_list) +int lttng_disable_channel(struct lttng_domain *domain, const char *name) { - return ask_sessiond(LTTNG_KERNEL_LIST_EVENTS, (void **) event_list); -} + int ret; -/* - * END Kernel control API - */ + strncpy(lsm.u.disable.channel_name, name, NAME_MAX); -/* - * lttng_get_readable_code - * - * Return a human readable string of code - */ -const char *lttng_get_readable_code(int code) -{ - if (code > -LTTCOMM_OK) { - return "Ended with errors"; - } + 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 lttcomm_get_readable_code(code); + return ret; } /* - * lttng_ust_list_apps + * List all available events in the kernel. * - * Ask the session daemon for all UST traceable applications. - * - * Return the number of pids. - * On error, return negative value. + * Return the size (bytes) of the list and set the event_list array. + * On error, return negative value. */ -int lttng_ust_list_traceable_apps(pid_t **pids) +int lttng_list_events(struct lttng_domain *domain, char **event_list) { int ret; - ret = ask_sessiond(LTTNG_LIST_TRACEABLE_APPS, (void**) pids); - if (ret < 0) { - return ret; - } + 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 / sizeof(pid_t); + return ret; } /* - * lttng_list_traces - * - * Ask the session daemon for all traces (kernel and ust) for the session - * identified by name. - * - * Return the number of traces. - * On error, return negative value. + * Return a human readable string of code */ -/* -int lttng_list_traces(char *session_name, struct lttng_trace **traces) +const char *lttng_get_readable_code(int code) { - int ret; - - strncpy(lsm.session_name, session_name, NAME_MAX); - - ret = ask_sessiond(LTTNG_LIST_TRACES, (void **) traces); - if (ret < 0) { - return ret; + if (code > -LTTCOMM_OK) { + return "Ended with errors"; } - return ret / sizeof(struct lttng_trace); + return lttcomm_get_readable_code(code); } -*/ /* - * lttng_create_session - * * Create a brand new session using name. */ -int lttng_create_session(char *name, char *path) +int lttng_create_session(const char *name, const char *path) { strncpy(lsm.session_name, name, NAME_MAX); strncpy(lsm.path, path, PATH_MAX); @@ -420,19 +482,15 @@ int lttng_create_session(char *name, char *path) } /* - * lttng_destroy_session - * * Destroy session using name. */ -int lttng_destroy_session(char *name) +int lttng_destroy_session(const char *name) { strncpy(lsm.session_name, name, NAME_MAX); return ask_sessiond(LTTNG_DESTROY_SESSION, NULL); } /* - * lttng_list_sessions - * * Ask the session daemon for all available sessions. * * Return number of session. @@ -451,52 +509,9 @@ int lttng_list_sessions(struct lttng_session **sessions) } /* - * lttng_connect_sessiond - * - * Connect to the LTTng session daemon. - * On success, return 0 - * On error, return a negative value + * Set session name for the current lsm. */ -int lttng_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; -} - -/* - * 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; -} - -void lttng_set_session_name(char *name) +void lttng_set_session_name(const char *name) { strncpy(lsm.session_name, name, NAME_MAX); }