X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Flib%2Flttng-ctl%2Flttng-ctl.c;h=4e1665f401a333719b7220638e43a80c95cee4a6;hp=157d9a4335af5b5d52b3fcc7be942b4f2d77719a;hb=a58c490f0bff52a73717d31d04d1472629180de2;hpb=53e367f936beb2f9a1f49f6a2920c2f58bcb08d7 diff --git a/src/lib/lttng-ctl/lttng-ctl.c b/src/lib/lttng-ctl/lttng-ctl.c index 157d9a433..4e1665f40 100644 --- a/src/lib/lttng-ctl/lttng-ctl.c +++ b/src/lib/lttng-ctl/lttng-ctl.c @@ -36,6 +36,9 @@ #include #include #include +#include +#include +#include #include "filter/filter-ast.h" #include "filter/filter-parser.h" @@ -519,10 +522,6 @@ struct lttng_handle *lttng_create_handle(const char *session_name, { struct lttng_handle *handle = NULL; - if (domain == NULL) { - goto end; - } - handle = zmalloc(sizeof(struct lttng_handle)); if (handle == NULL) { PERROR("malloc handle"); @@ -533,8 +532,10 @@ struct lttng_handle *lttng_create_handle(const char *session_name, lttng_ctl_copy_string(handle->session_name, session_name, sizeof(handle->session_name)); - /* Copy lttng domain */ - lttng_ctl_copy_lttng_domain(&handle->domain, domain); + /* Copy lttng domain or leave initialized to 0. */ + if (domain) { + lttng_ctl_copy_lttng_domain(&handle->domain, domain); + } end: return handle; @@ -736,9 +737,16 @@ int lttng_add_context(struct lttng_handle *handle, memcpy(buf + provider_len, ctx_name, ctx_len); } memcpy(&lsm.u.context.ctx, ctx, sizeof(struct lttng_event_context)); - /* Don't leak application addresses to the sessiond. */ - lsm.u.context.ctx.u.app_ctx.provider_name = NULL; - lsm.u.context.ctx.u.app_ctx.ctx_name = NULL; + + if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) { + /* + * Don't leak application addresses to the sessiond. + * This is only necessary when ctx is for an app ctx otherwise + * the values inside the union (type & config) are overwritten. + */ + lsm.u.context.ctx.u.app_ctx.provider_name = NULL; + lsm.u.context.ctx.u.app_ctx.ctx_name = NULL; + } ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, buf, len, NULL); end: @@ -1554,6 +1562,7 @@ int lttng_create_session(const char *name, const char *url) * Destroy session using name. * Returns size of returned session payload data or a negative error code. */ +static int _lttng_destroy_session(const char *session_name) { struct lttcomm_session_msg lsm; @@ -1809,13 +1818,13 @@ error: return ret; } -int lttng_event_get_filter_string(struct lttng_event *event, - const char **filter_string) +int lttng_event_get_filter_expression(struct lttng_event *event, + const char **filter_expression) { int ret = 0; struct lttcomm_event_extended_header *ext_header; - if (!event || !filter_string) { + if (!event || !filter_expression) { ret = -LTTNG_ERR_INVALID; goto end; } @@ -1827,15 +1836,15 @@ int lttng_event_get_filter_string(struct lttng_event *event, * This can happen since the lttng_event structure is * used for other tasks where this pointer is never set. */ - *filter_string = NULL; + *filter_expression = NULL; goto end; } if (ext_header->filter_len) { - *filter_string = ((const char *) (ext_header)) + - sizeof(*ext_header); + *filter_expression = ((const char *) (ext_header)) + + sizeof(*ext_header); } else { - *filter_string = NULL; + *filter_expression = NULL; } end: @@ -1921,26 +1930,13 @@ int lttng_set_tracing_group(const char *name) return 0; } -/* - * Returns size of returned session payload data or a negative error code. - */ int lttng_calibrate(struct lttng_handle *handle, struct lttng_calibrate *calibrate) { - struct lttcomm_session_msg lsm; - - /* Safety check. NULL pointer are forbidden */ - if (handle == NULL || calibrate == NULL) { - return -LTTNG_ERR_INVALID; - } - - memset(&lsm, 0, sizeof(lsm)); - lsm.cmd_type = LTTNG_CALIBRATE; - lttng_ctl_copy_lttng_domain(&lsm.domain, &handle->domain); - - memcpy(&lsm.u.calibrate, calibrate, sizeof(lsm.u.calibrate)); - - return lttng_ctl_ask_sessiond(&lsm, NULL); + /* + * This command was removed in LTTng 2.9. + */ + return -LTTNG_ERR_UND; } /* @@ -2374,10 +2370,166 @@ int lttng_list_tracker_pids(struct lttng_handle *handle, return 0; } +/* + * Regenerate the metadata for a session. + * Return 0 on success, a negative error code on error. + */ +int lttng_regenerate_metadata(const char *session_name) +{ + int ret; + struct lttcomm_session_msg lsm; + + if (!session_name) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_REGENERATE_METADATA; + + lttng_ctl_copy_string(lsm.session.name, session_name, + sizeof(lsm.session.name)); + + ret = lttng_ctl_ask_sessiond(&lsm, NULL); + if (ret < 0) { + goto end; + } + + ret = 0; +end: + return ret; +} + +/* + * Deprecated, replaced by lttng_regenerate_metadata. + */ +int lttng_metadata_regenerate(const char *session_name) +{ + return lttng_regenerate_metadata(session_name); +} + +/* + * Regenerate the statedump of a session. + * Return 0 on success, a negative error code on error. + */ +int lttng_regenerate_statedump(const char *session_name) +{ + int ret; + struct lttcomm_session_msg lsm; + + if (!session_name) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_REGENERATE_STATEDUMP; + + lttng_ctl_copy_string(lsm.session.name, session_name, + sizeof(lsm.session.name)); + + ret = lttng_ctl_ask_sessiond(&lsm, NULL); + if (ret < 0) { + goto end; + } + + ret = 0; +end: + return ret; +} + +int lttng_register_trigger(struct lttng_trigger *trigger) +{ + int ret; + struct lttcomm_session_msg lsm; + char *trigger_buf = NULL; + ssize_t trigger_size; + + if (!trigger) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + + if (!lttng_trigger_validate(trigger)) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + + trigger_size = lttng_trigger_serialize(trigger, NULL); + if (trigger_size < 0) { + ret = -LTTNG_ERR_UNK; + goto end; + } + + trigger_buf = zmalloc(trigger_size); + if (!trigger_buf) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_REGISTER_TRIGGER; + if (lttng_trigger_serialize(trigger, trigger_buf) < 0) { + ret = -LTTNG_ERR_UNK; + goto end; + } + + lsm.u.trigger.length = (uint32_t) trigger_size; + ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, trigger_buf, + trigger_size, NULL); +end: + free(trigger_buf); + return ret; +} + +int lttng_unregister_trigger(struct lttng_trigger *trigger) +{ + int ret; + struct lttcomm_session_msg lsm; + char *trigger_buf = NULL; + ssize_t trigger_size; + + if (!trigger) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + + if (!lttng_trigger_validate(trigger)) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + + trigger_size = lttng_trigger_serialize(trigger, NULL); + if (trigger_size < 0) { + ret = -LTTNG_ERR_UNK; + goto end; + } + + trigger_buf = zmalloc(trigger_size); + if (!trigger_buf) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + memset(&lsm, 0, sizeof(lsm)); + lsm.cmd_type = LTTNG_UNREGISTER_TRIGGER; + if (lttng_trigger_serialize(trigger, trigger_buf) < 0) { + ret = -LTTNG_ERR_UNK; + goto end; + } + + lsm.u.trigger.length = (uint32_t) trigger_size; + ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, trigger_buf, + trigger_size, NULL); +end: + free(trigger_buf); + return ret; +} + /* * lib constructor. */ -static void __attribute__((constructor)) init() +static void __attribute__((constructor)) init(void) { /* Set default session group */ lttng_set_tracing_group(DEFAULT_TRACING_GROUP); @@ -2386,7 +2538,7 @@ static void __attribute__((constructor)) init() /* * lib destructor. */ -static void __attribute__((destructor)) lttng_ctl_exit() +static void __attribute__((destructor)) lttng_ctl_exit(void) { free(tracing_group); }