From a24248b306f337c48df6bd4dd3a88a67fe5b074a Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Wed, 4 Jul 2018 16:46:25 -0400 Subject: [PATCH] trackers: update lttng-sessiond Signed-off-by: Mathieu Desnoyers --- src/bin/lttng-sessiond/Makefile.am | 3 +- src/bin/lttng-sessiond/cmd.c | 36 ++- src/bin/lttng-sessiond/cmd.h | 18 +- src/bin/lttng-sessiond/kernel.c | 261 ++++++++++++------ src/bin/lttng-sessiond/kernel.h | 15 +- src/bin/lttng-sessiond/main.c | 160 +++++++++-- src/bin/lttng-sessiond/save.c | 377 ++++++++++++++++++++------ src/bin/lttng-sessiond/trace-kernel.c | 37 +++ src/bin/lttng-sessiond/trace-kernel.h | 8 + src/bin/lttng-sessiond/trace-ust.c | 352 +++++++++++++++--------- src/bin/lttng-sessiond/trace-ust.h | 44 ++- src/bin/lttng-sessiond/ust-app.c | 8 +- 12 files changed, 964 insertions(+), 355 deletions(-) diff --git a/src/bin/lttng-sessiond/Makefile.am b/src/bin/lttng-sessiond/Makefile.am index d57c63963..ff66cfd7f 100644 --- a/src/bin/lttng-sessiond/Makefile.am +++ b/src/bin/lttng-sessiond/Makefile.am @@ -39,7 +39,8 @@ lttng_sessiond_SOURCES = utils.c utils.h \ sessiond-config.h sessiond-config.c \ rotate.h rotate.c \ rotation-thread.h rotation-thread.c \ - sessiond-timer.c sessiond-timer.h + sessiond-timer.c sessiond-timer.h \ + tracker.c tracker.h if HAVE_LIBLTTNG_UST_CTL lttng_sessiond_SOURCES += trace-ust.c ust-registry.c ust-app.c \ diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 6722341bb..7fc3087db 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -1220,12 +1220,14 @@ error: } /* - * Command LTTNG_TRACK_PID processed by the client thread. + * Command LTTNG_TRACK_ID processed by the client thread. * * Called with session lock held. */ -int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid) +int cmd_track_id(struct ltt_session *session, + enum lttng_tracker_type tracker_type, + enum lttng_domain_type domain, + struct lttng_tracker_id *id) { int ret; @@ -1238,7 +1240,7 @@ int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, ksess = session->kernel_session; - ret = kernel_track_pid(ksess, pid); + ret = kernel_track_id(tracker_type, ksess, id); if (ret != LTTNG_OK) { goto error; } @@ -1252,7 +1254,7 @@ int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, usess = session->ust_session; - ret = trace_ust_track_pid(usess, pid); + ret = trace_ust_track_id(tracker_type, usess, id); if (ret != LTTNG_OK) { goto error; } @@ -1271,12 +1273,14 @@ error: } /* - * Command LTTNG_UNTRACK_PID processed by the client thread. + * Command LTTNG_UNTRACK_ID processed by the client thread. * * Called with session lock held. */ -int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid) +int cmd_untrack_id(struct ltt_session *session, + enum lttng_tracker_type tracker_type, + enum lttng_domain_type domain, + struct lttng_tracker_id *id) { int ret; @@ -1289,7 +1293,7 @@ int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, ksess = session->kernel_session; - ret = kernel_untrack_pid(ksess, pid); + ret = kernel_untrack_id(tracker_type, ksess, id); if (ret != LTTNG_OK) { goto error; } @@ -1303,7 +1307,7 @@ int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, usess = session->ust_session; - ret = trace_ust_untrack_pid(usess, pid); + ret = trace_ust_untrack_id(tracker_type, usess, id); if (ret != LTTNG_OK) { goto error; } @@ -2340,12 +2344,14 @@ ssize_t cmd_list_syscalls(struct lttng_event **events) } /* - * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread. + * Command LTTNG_LIST_TRACKER_IDS processed by the client thread. * * Called with session lock held. */ -ssize_t cmd_list_tracker_pids(struct ltt_session *session, - enum lttng_domain_type domain, int32_t **pids) +ssize_t cmd_list_tracker_ids(enum lttng_tracker_type tracker_type, + struct ltt_session *session, + enum lttng_domain_type domain, + struct lttng_tracker_id **ids) { int ret; ssize_t nr_pids = 0; @@ -2356,7 +2362,7 @@ ssize_t cmd_list_tracker_pids(struct ltt_session *session, struct ltt_kernel_session *ksess; ksess = session->kernel_session; - nr_pids = kernel_list_tracker_pids(ksess, pids); + nr_pids = kernel_list_tracker_ids(tracker_type, ksess, ids); if (nr_pids < 0) { ret = LTTNG_ERR_KERN_LIST_FAIL; goto error; @@ -2368,7 +2374,7 @@ ssize_t cmd_list_tracker_pids(struct ltt_session *session, struct ltt_ust_session *usess; usess = session->ust_session; - nr_pids = trace_ust_list_tracker_pids(usess, pids); + nr_pids = trace_ust_list_tracker_ids(tracker_type, usess, ids); if (nr_pids < 0) { ret = LTTNG_ERR_UST_LIST_FAIL; goto error; diff --git a/src/bin/lttng-sessiond/cmd.h b/src/bin/lttng-sessiond/cmd.h index 6a6c87eaa..4b7fa0278 100644 --- a/src/bin/lttng-sessiond/cmd.h +++ b/src/bin/lttng-sessiond/cmd.h @@ -43,10 +43,14 @@ int cmd_disable_channel(struct ltt_session *session, int cmd_enable_channel(struct ltt_session *session, struct lttng_domain *domain, struct lttng_channel *attr, int wpipe); -int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid); -int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, - int pid); +int cmd_track_id(struct ltt_session *session, + enum lttng_tracker_type tracker_type, + enum lttng_domain_type domain, + struct lttng_tracker_id *id); +int cmd_untrack_id(struct ltt_session *session, + enum lttng_tracker_type tracker_type, + enum lttng_domain_type domain, + struct lttng_tracker_id *id); /* Event commands */ int cmd_disable_event(struct ltt_session *session, @@ -96,8 +100,10 @@ ssize_t cmd_list_tracepoints(enum lttng_domain_type domain, ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, struct lttng_snapshot_output **outputs); ssize_t cmd_list_syscalls(struct lttng_event **events); -ssize_t cmd_list_tracker_pids(struct ltt_session *session, - enum lttng_domain_type domain, int32_t **pids); +ssize_t cmd_list_tracker_ids(enum lttng_tracker_type tracker_type, + struct ltt_session *session, + enum lttng_domain_type domain, + struct lttng_tracker_id **ids); int cmd_data_pending(struct ltt_session *session); diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index fc817b2db..e223bcc07 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -396,16 +396,102 @@ error: return ret; } +static +struct lttng_tracker_list *get_id_tracker_list(struct ltt_kernel_session *session, + enum lttng_tracker_type tracker_type) +{ + switch (tracker_type) { + case LTTNG_TRACKER_PID: + return session->tracker_list_pid; + case LTTNG_TRACKER_VPID: + return session->tracker_list_vpid; + case LTTNG_TRACKER_UID: + return session->tracker_list_uid; + case LTTNG_TRACKER_VUID: + return session->tracker_list_vuid; + case LTTNG_TRACKER_GID: + return session->tracker_list_gid; + case LTTNG_TRACKER_VGID: + return session->tracker_list_vgid; + default: + return NULL; + } +} -int kernel_track_pid(struct ltt_kernel_session *session, int pid) +int kernel_track_id(enum lttng_tracker_type tracker_type, + struct ltt_kernel_session *session, + struct lttng_tracker_id *id) { - int ret; + int ret, value; + struct lttng_tracker_list *tracker_list; + + ret = lttng_tracker_id_lookup_string(tracker_type, + id, &value); + if (ret != LTTNG_OK) { + return ret; + } + + /* Add to list. */ + tracker_list = get_id_tracker_list(session, tracker_type); + if (!tracker_list) { + return LTTNG_ERR_INVALID; + } + ret = lttng_tracker_list_add(tracker_list, id); + if (ret != LTTNG_OK) { + return ret; + } - DBG("Kernel track PID %d for session id %" PRIu64 ".", - pid, session->id); - ret = kernctl_track_pid(session->fd, pid); - if (!ret) { - return LTTNG_OK; + switch (tracker_type) { + case LTTNG_TRACKER_PID: + DBG("Kernel track PID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_track_pid(session->fd, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_VPID: + DBG("Kernel track VPID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_track_id(session->fd, LTTNG_TRACKER_VPID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_UID: + DBG("Kernel track UID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_track_id(session->fd, LTTNG_TRACKER_UID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_GID: + DBG("Kernel track GID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_track_id(session->fd, LTTNG_TRACKER_GID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_VUID: + DBG("Kernel track VUID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_track_id(session->fd, LTTNG_TRACKER_VUID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_VGID: + DBG("Kernel track VGID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_track_id(session->fd, LTTNG_TRACKER_VGID, value); + if (!ret) { + return LTTNG_OK; + } + break; + default: + return LTTNG_ERR_INVALID; } switch (-ret) { case EINVAL: @@ -413,103 +499,114 @@ int kernel_track_pid(struct ltt_kernel_session *session, int pid) case ENOMEM: return LTTNG_ERR_NOMEM; case EEXIST: - return LTTNG_ERR_PID_TRACKED; + return LTTNG_ERR_ID_TRACKED; default: return LTTNG_ERR_UNK; } } -int kernel_untrack_pid(struct ltt_kernel_session *session, int pid) +int kernel_untrack_id(enum lttng_tracker_type tracker_type, + struct ltt_kernel_session *session, + struct lttng_tracker_id *id) { - int ret; + int ret, value; + struct lttng_tracker_list *tracker_list; - DBG("Kernel untrack PID %d for session id %" PRIu64 ".", - pid, session->id); - ret = kernctl_untrack_pid(session->fd, pid); - if (!ret) { - return LTTNG_OK; + ret = lttng_tracker_id_lookup_string(tracker_type, + id, &value); + if (ret != LTTNG_OK) { + return ret; } + + /* Remove from list. */ + tracker_list = get_id_tracker_list(session, tracker_type); + if (!tracker_list) { + return LTTNG_ERR_INVALID; + } + ret = lttng_tracker_list_remove(tracker_list, id); + if (ret != LTTNG_OK) { + return ret; + } + + switch (tracker_type) { + case LTTNG_TRACKER_PID: + DBG("Kernel untrack PID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_untrack_pid(session->fd, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_VPID: + DBG("Kernel untrack VPID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_VPID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_UID: + DBG("Kernel untrack UID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_UID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_GID: + DBG("Kernel untrack GID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_GID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_VUID: + DBG("Kernel untrack VUID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_VUID, value); + if (!ret) { + return LTTNG_OK; + } + break; + case LTTNG_TRACKER_VGID: + DBG("Kernel untrack VGID %d for session id %" PRIu64 ".", + value, session->id); + ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_VGID, value); + if (!ret) { + return LTTNG_OK; + } + break; + default: + return LTTNG_ERR_INVALID; + } + switch (-ret) { case EINVAL: return LTTNG_ERR_INVALID; case ENOMEM: return LTTNG_ERR_NOMEM; case ENOENT: - return LTTNG_ERR_PID_NOT_TRACKED; + return LTTNG_ERR_ID_NOT_TRACKED; default: return LTTNG_ERR_UNK; } } -ssize_t kernel_list_tracker_pids(struct ltt_kernel_session *session, - int **_pids) +/* + * Called with session lock held. + */ +ssize_t kernel_list_tracker_ids(enum lttng_tracker_type tracker_type, + struct ltt_kernel_session *session, + struct lttng_tracker_id **_ids) { - int fd, ret; - int pid; - ssize_t nbmem, count = 0; - FILE *fp; - int *pids; + struct lttng_tracker_list *tracker_list; - fd = kernctl_list_tracker_pids(session->fd); - if (fd < 0) { - PERROR("kernel tracker pids list"); - goto error; - } - - fp = fdopen(fd, "r"); - if (fp == NULL) { - PERROR("kernel tracker pids list fdopen"); - goto error_fp; - } - - nbmem = KERNEL_TRACKER_PIDS_INIT_LIST_SIZE; - pids = zmalloc(sizeof(*pids) * nbmem); - if (pids == NULL) { - PERROR("alloc list pids"); - count = -ENOMEM; - goto end; + tracker_list = get_id_tracker_list(session, tracker_type); + if (!tracker_list) { + return -LTTNG_ERR_INVALID; } - - while (fscanf(fp, "process { pid = %u; };\n", &pid) == 1) { - if (count >= nbmem) { - int *new_pids; - size_t new_nbmem; - - new_nbmem = nbmem << 1; - DBG("Reallocating pids list from %zu to %zu entries", - nbmem, new_nbmem); - new_pids = realloc(pids, new_nbmem * sizeof(*new_pids)); - if (new_pids == NULL) { - PERROR("realloc list events"); - free(pids); - count = -ENOMEM; - goto end; - } - /* Zero the new memory */ - memset(new_pids + nbmem, 0, - (new_nbmem - nbmem) * sizeof(*new_pids)); - nbmem = new_nbmem; - pids = new_pids; - } - pids[count++] = pid; - } - - *_pids = pids; - DBG("Kernel list tracker pids done (%zd pids)", count); -end: - ret = fclose(fp); /* closes both fp and fd */ - if (ret) { - PERROR("fclose"); - } - return count; - -error_fp: - ret = close(fd); - if (ret) { - PERROR("close"); - } -error: - return -1; + return lttng_tracker_id_get_list(tracker_list, _ids); } /* diff --git a/src/bin/lttng-sessiond/kernel.h b/src/bin/lttng-sessiond/kernel.h index 8d5ddb668..bceb4aa9a 100644 --- a/src/bin/lttng-sessiond/kernel.h +++ b/src/bin/lttng-sessiond/kernel.h @@ -30,7 +30,7 @@ * dynamic reallocation is performed. */ #define KERNEL_EVENT_INIT_LIST_SIZE 64 -#define KERNEL_TRACKER_PIDS_INIT_LIST_SIZE 64 +#define KERNEL_TRACKER_IDS_INIT_LIST_SIZE 64 int kernel_add_channel_context(struct ltt_kernel_channel *chan, struct ltt_kernel_context *ctx); @@ -43,8 +43,12 @@ int kernel_disable_channel(struct ltt_kernel_channel *chan); int kernel_disable_event(struct ltt_kernel_event *event); int kernel_enable_event(struct ltt_kernel_event *event); int kernel_enable_channel(struct ltt_kernel_channel *chan); -int kernel_track_pid(struct ltt_kernel_session *session, int pid); -int kernel_untrack_pid(struct ltt_kernel_session *session, int pid); +int kernel_track_id(enum lttng_tracker_type tracker_type, + struct ltt_kernel_session *session, + struct lttng_tracker_id *id); +int kernel_untrack_id(enum lttng_tracker_type tracker_type, + struct ltt_kernel_session *session, + struct lttng_tracker_id *id); int kernel_open_metadata(struct ltt_kernel_session *session); int kernel_open_metadata_stream(struct ltt_kernel_session *session); int kernel_open_channel_stream(struct ltt_kernel_channel *channel); @@ -66,8 +70,9 @@ int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits); int kernel_rotate_session(struct ltt_session *session); int init_kernel_workarounds(void); -ssize_t kernel_list_tracker_pids(struct ltt_kernel_session *session, - int **_pids); +ssize_t kernel_list_tracker_ids(enum lttng_tracker_type tracker_type, + struct ltt_kernel_session *session, + struct lttng_tracker_id **_ids); int kernel_supports_ring_buffer_snapshot_sample_positions(int tracer_fd); #endif /* _LTT_KERNEL_CTL_H */ diff --git a/src/bin/lttng-sessiond/main.c b/src/bin/lttng-sessiond/main.c index 2b2a59ade..3c88a0344 100644 --- a/src/bin/lttng-sessiond/main.c +++ b/src/bin/lttng-sessiond/main.c @@ -49,6 +49,7 @@ #include #include #include +#include #include "lttng-sessiond.h" #include "buffer-registry.h" @@ -3042,7 +3043,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int sock, case LTTNG_LIST_CHANNELS: case LTTNG_LIST_EVENTS: case LTTNG_LIST_SYSCALLS: - case LTTNG_LIST_TRACKER_PIDS: + case LTTNG_LIST_TRACKER_IDS: case LTTNG_DATA_PENDING: case LTTNG_ROTATE_SESSION: case LTTNG_ROTATION_GET_INFO: @@ -3460,18 +3461,100 @@ error_add_context: kernel_poll_pipe[1]); break; } - case LTTNG_TRACK_PID: + case LTTNG_TRACK_ID: { - ret = cmd_track_pid(cmd_ctx->session, + struct lttng_tracker_id id; + + memset(&id, 0, sizeof(id)); + id.type = cmd_ctx->lsm->u.id_tracker.id_type; + switch (id.type) { + case LTTNG_ID_ALL: + break; + case LTTNG_ID_VALUE: + id.value = cmd_ctx->lsm->u.id_tracker.u.value; + break; + case LTTNG_ID_STRING: + { + size_t var_len = cmd_ctx->lsm->u.id_tracker.u.var_len; + + id.string = zmalloc(var_len); + if (!id.string) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + DBG("Receiving var len tracker id string from client."); + ret = lttcomm_recv_unix_sock(sock, id.string, var_len); + if (ret <= 0) { + DBG("Nothing received."); + *sock_error = 1; + free(id.string); + ret = LTTNG_ERR_INVALID; + goto error; + } + if (strnlen(id.string, var_len) != var_len - 1) { + DBG("Corrupted string."); + free(id.string); + ret = LTTNG_ERR_INVALID; + goto error; + } + break; + } + default: + ret = LTTNG_ERR_INVALID; + goto error; + } + ret = cmd_track_id(cmd_ctx->session, + cmd_ctx->lsm->u.id_tracker.tracker_type, cmd_ctx->lsm->domain.type, - cmd_ctx->lsm->u.pid_tracker.pid); + &id); break; } - case LTTNG_UNTRACK_PID: + case LTTNG_UNTRACK_ID: { - ret = cmd_untrack_pid(cmd_ctx->session, + struct lttng_tracker_id id; + + memset(&id, 0, sizeof(id)); + id.type = cmd_ctx->lsm->u.id_tracker.id_type; + switch (id.type) { + case LTTNG_ID_ALL: + break; + case LTTNG_ID_VALUE: + id.value = cmd_ctx->lsm->u.id_tracker.u.value; + break; + case LTTNG_ID_STRING: + { + size_t var_len = cmd_ctx->lsm->u.id_tracker.u.var_len; + + id.string = zmalloc(var_len); + if (!id.string) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + DBG("Receiving var len tracker id string from client."); + ret = lttcomm_recv_unix_sock(sock, id.string, var_len); + if (ret <= 0) { + DBG("Nothing received."); + *sock_error = 1; + free(id.string); + ret = LTTNG_ERR_INVALID; + goto error; + } + if (strnlen(id.string, var_len) != var_len - 1) { + DBG("Corrupted string."); + free(id.string); + ret = LTTNG_ERR_INVALID; + goto error; + } + break; + } + default: + ret = LTTNG_ERR_INVALID; + goto error; + } + ret = cmd_untrack_id(cmd_ctx->session, + cmd_ctx->lsm->u.id_tracker.tracker_type, cmd_ctx->lsm->domain.type, - cmd_ctx->lsm->u.pid_tracker.pid); + &id); break; } case LTTNG_ENABLE_EVENT: @@ -3670,27 +3753,60 @@ error_add_context: ret = LTTNG_OK; break; } - case LTTNG_LIST_TRACKER_PIDS: + case LTTNG_LIST_TRACKER_IDS: { - int32_t *pids = NULL; - ssize_t nr_pids; - - nr_pids = cmd_list_tracker_pids(cmd_ctx->session, - cmd_ctx->lsm->domain.type, &pids); - if (nr_pids < 0) { + struct lttcomm_tracker_command_header cmd_header; + struct lttng_tracker_id *ids = NULL; + ssize_t nr_ids, i; + struct lttng_dynamic_buffer buf; + + nr_ids = cmd_list_tracker_ids(cmd_ctx->lsm->u.id_tracker.tracker_type, + cmd_ctx->session, + cmd_ctx->lsm->domain.type, &ids); + if (nr_ids < 0) { /* Return value is a negative lttng_error_code. */ - ret = -nr_pids; + ret = -nr_ids; goto error; } - /* - * Setup lttng message with payload size set to the event list size in - * bytes and then copy list into the llm payload. - */ - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, pids, - sizeof(int32_t) * nr_pids); - free(pids); + lttng_dynamic_buffer_init(&buf); + for (i = 0; i < nr_ids; i++) { + struct lttng_tracker_id *id = &ids[i]; + struct lttcomm_tracker_id_header id_hdr; + size_t var_data_len = 0; + + memset(&id_hdr, 0, sizeof(id_hdr)); + id_hdr.type = id->type; + switch (id->type) { + case LTTNG_ID_ALL: + break; + case LTTNG_ID_VALUE: + id_hdr.u.value = id->value; + break; + case LTTNG_ID_STRING: + id_hdr.u.var_data_len = var_data_len = strlen(id->string) + 1; + break; + default: + ret = LTTNG_ERR_INVALID; + goto error; + } + ret = lttng_dynamic_buffer_append(&buf, &id_hdr, sizeof(id_hdr)); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + ret = lttng_dynamic_buffer_append(&buf, id->string, var_data_len); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + } + cmd_header.nb_tracker_id = nr_ids; + ret = setup_lttng_msg(cmd_ctx, buf.data, buf.size, &cmd_header, + sizeof(cmd_header)); + free(ids); + lttng_dynamic_buffer_reset(&buf); if (ret < 0) { goto setup_error; } diff --git a/src/bin/lttng-sessiond/save.c b/src/bin/lttng-sessiond/save.c index 6b1bf69c4..1e0681e1b 100644 --- a/src/bin/lttng-sessiond/save.c +++ b/src/bin/lttng-sessiond/save.c @@ -36,6 +36,7 @@ #include "trace-ust.h" #include "agent.h" +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_kernel_channel_attributes(struct config_writer *writer, struct lttng_channel_attr *attr) @@ -47,12 +48,14 @@ int save_kernel_channel_attributes(struct config_writer *writer, attr->overwrite ? config_overwrite_mode_overwrite : config_overwrite_mode_discard); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } ret = config_writer_write_element_unsigned_int(writer, config_element_subbuf_size, attr->subbuf_size); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -60,6 +63,7 @@ int save_kernel_channel_attributes(struct config_writer *writer, config_element_num_subbuf, attr->num_subbuf); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -67,6 +71,7 @@ int save_kernel_channel_attributes(struct config_writer *writer, config_element_switch_timer_interval, attr->switch_timer_interval); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -74,6 +79,7 @@ int save_kernel_channel_attributes(struct config_writer *writer, config_element_read_timer_interval, attr->read_timer_interval); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -82,12 +88,14 @@ int save_kernel_channel_attributes(struct config_writer *writer, attr->output == LTTNG_EVENT_SPLICE ? config_output_type_splice : config_output_type_mmap); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } ret = config_writer_write_element_unsigned_int(writer, config_element_tracefile_size, attr->tracefile_size); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -95,6 +103,7 @@ int save_kernel_channel_attributes(struct config_writer *writer, config_element_tracefile_count, attr->tracefile_count); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -102,6 +111,7 @@ int save_kernel_channel_attributes(struct config_writer *writer, config_element_live_timer_interval, attr->live_timer_interval); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -113,6 +123,7 @@ int save_kernel_channel_attributes(struct config_writer *writer, config_element_monitor_timer_interval, ext->monitor_timer_interval); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -120,14 +131,17 @@ int save_kernel_channel_attributes(struct config_writer *writer, config_element_blocking_timeout, ext->blocking_timeout); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } } + ret = LTTNG_OK; end: - return ret ? LTTNG_ERR_SAVE_IO_FAIL : 0; + return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_channel_attributes(struct config_writer *writer, struct lttng_ust_channel_attr *attr) @@ -140,12 +154,14 @@ int save_ust_channel_attributes(struct config_writer *writer, attr->overwrite ? config_overwrite_mode_overwrite : config_overwrite_mode_discard); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } ret = config_writer_write_element_unsigned_int(writer, config_element_subbuf_size, attr->subbuf_size); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -153,6 +169,7 @@ int save_ust_channel_attributes(struct config_writer *writer, config_element_num_subbuf, attr->num_subbuf); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -160,6 +177,7 @@ int save_ust_channel_attributes(struct config_writer *writer, config_element_switch_timer_interval, attr->switch_timer_interval); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -167,6 +185,7 @@ int save_ust_channel_attributes(struct config_writer *writer, config_element_read_timer_interval, attr->read_timer_interval); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -175,6 +194,7 @@ int save_ust_channel_attributes(struct config_writer *writer, attr->output == LTTNG_UST_MMAP ? config_output_type_mmap : config_output_type_splice); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -182,6 +202,7 @@ int save_ust_channel_attributes(struct config_writer *writer, config_element_blocking_timeout, attr->u.s.blocking_timeout); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } @@ -194,11 +215,13 @@ int save_ust_channel_attributes(struct config_writer *writer, config_element_monitor_timer_interval, channel->monitor_timer_interval); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + ret = LTTNG_OK; end: - return ret ? LTTNG_ERR_SAVE_IO_FAIL : 0; + return ret; } static @@ -376,6 +399,7 @@ const char *get_loglevel_type_string( return loglevel_type_string; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_kernel_event(struct config_writer *writer, struct ltt_kernel_event *event) @@ -551,10 +575,13 @@ int save_kernel_event(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_kernel_events(struct config_writer *writer, struct ltt_kernel_channel *kchan) @@ -570,7 +597,7 @@ int save_kernel_events(struct config_writer *writer, cds_list_for_each_entry(event, &kchan->events_list.head, list) { ret = save_kernel_event(writer, event); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } @@ -581,10 +608,13 @@ int save_kernel_events(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_event(struct config_writer *writer, struct ltt_ust_event *event) @@ -695,10 +725,13 @@ int save_ust_event(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_events(struct config_writer *writer, struct lttng_ht *events) @@ -723,7 +756,7 @@ int save_ust_events(struct config_writer *writer, continue; } ret = save_ust_event(writer, event); - if (ret) { + if (ret != LTTNG_OK) { rcu_read_unlock(); goto end; } @@ -736,22 +769,25 @@ int save_ust_events(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int init_ust_event_from_agent_event(struct ltt_ust_event *ust_event, struct agent_event *agent_event) { - int ret = 0; + int ret; enum lttng_ust_loglevel_type ust_loglevel_type; ust_event->enabled = agent_event->enabled; ust_event->attr.instrumentation = LTTNG_UST_TRACEPOINT; if (lttng_strncpy(ust_event->attr.name, agent_event->name, LTTNG_SYMBOL_NAME_LEN)) { - ret = -1; + ret = LTTNG_ERR_INVALID; goto end; } switch (agent_event->loglevel_type) { @@ -766,7 +802,7 @@ int init_ust_event_from_agent_event(struct ltt_ust_event *ust_event, break; default: ERR("Invalid agent_event loglevel_type."); - ret = -1; + ret = LTTNG_ERR_INVALID; goto end; } @@ -774,10 +810,13 @@ int init_ust_event_from_agent_event(struct ltt_ust_event *ust_event, ust_event->attr.loglevel = agent_event->loglevel_value; ust_event->filter_expression = agent_event->filter_expression; ust_event->exclusion = agent_event->exclusion; + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_agent_events(struct config_writer *writer, struct agent *agent) @@ -808,12 +847,12 @@ int save_agent_events(struct config_writer *writer, * structures...). */ ret = init_ust_event_from_agent_event(&fake_event, agent_event); - if (ret) { + if (ret != LTTNG_OK) { rcu_read_unlock(); goto end; } ret = save_ust_event(writer, &fake_event); - if (ret) { + if (ret != LTTNG_OK) { rcu_read_unlock(); goto end; } @@ -826,15 +865,18 @@ int save_agent_events(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_kernel_context(struct config_writer *writer, struct lttng_kernel_context *ctx) { - int ret = 0; + int ret = LTTNG_OK; if (!ctx) { goto end; @@ -906,10 +948,12 @@ int save_kernel_context(struct config_writer *writer, goto end; } + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_kernel_contexts(struct config_writer *writer, struct ltt_kernel_channel *kchan) @@ -918,7 +962,7 @@ int save_kernel_contexts(struct config_writer *writer, struct ltt_kernel_context *ctx; if (cds_list_empty(&kchan->ctx_list)) { - ret = 0; + ret = LTTNG_OK; goto end; } @@ -930,7 +974,7 @@ int save_kernel_contexts(struct config_writer *writer, cds_list_for_each_entry(ctx, &kchan->ctx_list, list) { ret = save_kernel_context(writer, &ctx->ctx); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } @@ -941,10 +985,13 @@ int save_kernel_contexts(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_context_perf_thread_counter(struct config_writer *writer, struct ltt_ust_context *ctx) @@ -988,10 +1035,13 @@ int save_ust_context_perf_thread_counter(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_context_app_ctx(struct config_writer *writer, struct ltt_ust_context *ctx) @@ -1030,10 +1080,13 @@ int save_ust_context_app_ctx(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_context_generic(struct config_writer *writer, struct ltt_ust_context *ctx) @@ -1059,10 +1112,13 @@ int save_ust_context_generic(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_context(struct config_writer *writer, struct cds_list_head *ctx_list) @@ -1098,7 +1154,7 @@ int save_ust_context(struct config_writer *writer, /* Save generic context. */ ret = save_ust_context_generic(writer, ctx); } - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -1116,10 +1172,13 @@ int save_ust_context(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_kernel_channel(struct config_writer *writer, struct ltt_kernel_channel *kchan) @@ -1150,17 +1209,17 @@ int save_kernel_channel(struct config_writer *writer, } ret = save_kernel_channel_attributes(writer, &kchan->channel->attr); - if (ret) { + if (ret != LTTNG_OK) { goto end; } ret = save_kernel_events(writer, kchan); - if (ret) { + if (ret != LTTNG_OK) { goto end; } ret = save_kernel_contexts(writer, kchan); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -1170,10 +1229,13 @@ int save_kernel_channel(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_channel(struct config_writer *writer, struct ltt_ust_channel *ust_chan, @@ -1206,7 +1268,7 @@ int save_ust_channel(struct config_writer *writer, } ret = save_ust_channel_attributes(writer, &ust_chan->attr); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -1234,7 +1296,7 @@ int save_ust_channel(struct config_writer *writer, if (ust_chan->domain == LTTNG_DOMAIN_UST) { ret = save_ust_events(writer, ust_chan->events); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } else { @@ -1254,13 +1316,13 @@ int save_ust_channel(struct config_writer *writer, * them. */ ret = save_agent_events(writer, agent); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } ret = save_ust_context(writer, &ust_chan->ctx_list); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -1270,10 +1332,13 @@ int save_ust_channel(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_kernel_session(struct config_writer *writer, struct ltt_session *session) @@ -1308,7 +1373,7 @@ int save_kernel_session(struct config_writer *writer, cds_list_for_each_entry(kchan, &session->kernel_session->channel_list.head, list) { ret = save_kernel_channel(writer, kchan); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } @@ -1319,6 +1384,8 @@ int save_kernel_session(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } @@ -1351,19 +1418,58 @@ const char *get_config_domain_str(enum lttng_domain_type domain) return str_dom; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static -int save_pid_tracker(struct config_writer *writer, - struct ltt_session *sess, int domain) +int save_id_tracker(struct config_writer *writer, + struct ltt_session *sess, int domain, + enum lttng_tracker_type tracker_type) { - int ret = 0; - ssize_t nr_pids = 0, i; - int32_t *pids = NULL; + int ret = LTTNG_OK; + ssize_t nr_ids = 0, i; + struct lttng_tracker_id *ids = NULL; + const char *element_id_tracker, *element_target_id, *element_id; + + switch (tracker_type) { + case LTTNG_TRACKER_PID: + element_id_tracker = config_element_pid_tracker; + element_target_id = config_element_target_pid; + element_id = config_element_pid; + break; + case LTTNG_TRACKER_VPID: + element_id_tracker = config_element_vpid_tracker; + element_target_id = config_element_target_vpid; + element_id = config_element_id; + break; + case LTTNG_TRACKER_UID: + element_id_tracker = config_element_uid_tracker; + element_target_id = config_element_target_uid; + element_id = config_element_id; + break; + case LTTNG_TRACKER_VUID: + element_id_tracker = config_element_vuid_tracker; + element_target_id = config_element_target_vuid; + element_id = config_element_id; + break; + case LTTNG_TRACKER_GID: + element_id_tracker = config_element_gid_tracker; + element_target_id = config_element_target_gid; + element_id = config_element_id; + break; + case LTTNG_TRACKER_VGID: + element_id_tracker = config_element_vgid_tracker; + element_target_id = config_element_target_vgid; + element_id = config_element_id; + break; + default: + ret = LTTNG_ERR_SAVE_IO_FAIL; + goto end; + } switch (domain) { case LTTNG_DOMAIN_KERNEL: { - nr_pids = kernel_list_tracker_pids(sess->kernel_session, &pids); - if (nr_pids < 0) { + nr_ids = kernel_list_tracker_ids(tracker_type, sess->kernel_session, &ids); + if (nr_ids < 0) { ret = LTTNG_ERR_KERN_LIST_FAIL; goto end; } @@ -1371,8 +1477,8 @@ int save_pid_tracker(struct config_writer *writer, } case LTTNG_DOMAIN_UST: { - nr_pids = trace_ust_list_tracker_pids(sess->ust_session, &pids); - if (nr_pids < 0) { + nr_ids = trace_ust_list_tracker_ids(tracker_type, sess->ust_session, &ids); + if (nr_ids < 0) { ret = LTTNG_ERR_UST_LIST_FAIL; goto end; } @@ -1386,64 +1492,150 @@ int save_pid_tracker(struct config_writer *writer, goto end; } - /* Only create a pid_tracker if enabled or untrack all */ - if (nr_pids != 1 || (nr_pids == 1 && pids[0] != -1)) { + + if (nr_ids == 1 && ids[0].type == LTTNG_ID_ALL) { + /* Tracking all, nothing to output. */ + ret = LTTNG_OK; + goto end; + } + + ret = config_writer_open_element(writer, element_id_tracker); + if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; + goto end; + } + + ret = config_writer_open_element(writer, + config_element_targets); + if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; + goto end; + } + + if (nr_ids == 0) { + /* Tracking none: empty list. */ ret = config_writer_open_element(writer, - config_element_pid_tracker); + element_target_id); if (ret) { ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } - ret = config_writer_open_element(writer, - config_element_targets); + /* /$element_target_id */ + ret = config_writer_close_element(writer); if (ret) { ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } - - for (i = 0; i < nr_pids; i++) { - ret = config_writer_open_element(writer, - config_element_target_pid); - if (ret) { + } else { + /* Tracking list. */ + for (i = 0; i < nr_ids; i++) { + switch (ids[i].type) { + case LTTNG_ID_VALUE: + ret = config_writer_open_element(writer, + element_target_id); + if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; + goto end; + } + ret = config_writer_write_element_unsigned_int(writer, + element_id, ids[i].value); + break; + case LTTNG_ID_STRING: + ret = config_writer_open_element(writer, + element_target_id); + if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; + goto end; + } + ret = config_writer_write_element_string(writer, + config_element_name, ids[i].string); + break; + default: + /* Unexpected. */ ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } - - ret = config_writer_write_element_unsigned_int(writer, - config_element_pid, pids[i]); if (ret) { ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } - /* /pid_target */ + /* /$element_target_id */ ret = config_writer_close_element(writer); if (ret) { ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } } + } - /* /targets */ - ret = config_writer_close_element(writer); - if (ret) { - ret = LTTNG_ERR_SAVE_IO_FAIL; - goto end; - } + /* /targets */ + ret = config_writer_close_element(writer); + if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; + goto end; + } - /* /pid_tracker */ - ret = config_writer_close_element(writer); - if (ret) { - ret = LTTNG_ERR_SAVE_IO_FAIL; - goto end; - } + /* /$element_id_tracker */ + ret = config_writer_close_element(writer); + if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; + goto end; } + + ret = LTTNG_OK; end: - free(pids); + free(ids); return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ +static +int save_id_trackers(struct config_writer *writer, + struct ltt_session *sess, int domain) +{ + int ret; + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_PID); + if (ret != LTTNG_OK) + return ret; + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_VPID); + if (ret != LTTNG_OK) + return ret; + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_UID); + if (ret != LTTNG_OK) + return ret; + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_VUID); + if (ret != LTTNG_OK) + return ret; + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_GID); + if (ret != LTTNG_OK) + return ret; + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_VGID); + if (ret != LTTNG_OK) + return ret; + break; + case LTTNG_DOMAIN_UST: + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_VPID); + if (ret != LTTNG_OK) + return ret; + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_VUID); + if (ret != LTTNG_OK) + return ret; + ret = save_id_tracker(writer, sess, domain, LTTNG_TRACKER_VGID); + if (ret != LTTNG_OK) + return ret; + break; + default: + return LTTNG_ERR_INVALID; + } + return LTTNG_OK; +} + +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_ust_domain(struct config_writer *writer, struct ltt_session *session, enum lttng_domain_type domain) @@ -1505,7 +1697,7 @@ int save_ust_domain(struct config_writer *writer, ust_chan = caa_container_of(node, struct ltt_ust_channel, node); if (domain == ust_chan->domain) { ret = save_ust_channel(writer, ust_chan, session->ust_session); - if (ret) { + if (ret != LTTNG_OK) { rcu_read_unlock(); goto end; } @@ -1528,14 +1720,15 @@ int save_ust_domain(struct config_writer *writer, goto end; } - ret = save_pid_tracker(writer, session, LTTNG_DOMAIN_UST); - if (ret) { + ret = save_id_trackers(writer, session, LTTNG_DOMAIN_UST); + if (ret != LTTNG_OK) { goto end; } /* /trackers */ ret = config_writer_close_element(writer); if (ret) { + ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } } @@ -1547,14 +1740,16 @@ int save_ust_domain(struct config_writer *writer, goto end; } + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_domains(struct config_writer *writer, struct ltt_session *session) { - int ret = 0; + int ret = LTTNG_OK; assert(writer); assert(session); @@ -1569,7 +1764,6 @@ int save_domains(struct config_writer *writer, struct ltt_session *session) goto end; } - if (session->kernel_session) { ret = config_writer_open_element(writer, config_element_domain); @@ -1579,7 +1773,7 @@ int save_domains(struct config_writer *writer, struct ltt_session *session) } ret = save_kernel_session(writer, session); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -1590,8 +1784,8 @@ int save_domains(struct config_writer *writer, struct ltt_session *session) goto end; } - ret = save_pid_tracker(writer, session, LTTNG_DOMAIN_KERNEL); - if (ret) { + ret = save_id_trackers(writer, session, LTTNG_DOMAIN_KERNEL); + if (ret != LTTNG_OK) { goto end; } @@ -1611,22 +1805,22 @@ int save_domains(struct config_writer *writer, struct ltt_session *session) if (session->ust_session) { ret = save_ust_domain(writer, session, LTTNG_DOMAIN_UST); - if (ret) { + if (ret != LTTNG_OK) { goto end; } ret = save_ust_domain(writer, session, LTTNG_DOMAIN_JUL); - if (ret) { + if (ret != LTTNG_OK) { goto end; } ret = save_ust_domain(writer, session, LTTNG_DOMAIN_LOG4J); - if (ret) { + if (ret != LTTNG_OK) { goto end; } ret = save_ust_domain(writer, session, LTTNG_DOMAIN_PYTHON); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } @@ -1637,10 +1831,13 @@ int save_domains(struct config_writer *writer, struct ltt_session *session) ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_consumer_output(struct config_writer *writer, struct consumer_output *output) @@ -1721,10 +1918,10 @@ int save_consumer_output(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end_net_output; } - + ret = LTTNG_OK; end_net_output: free(uri); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } else { @@ -1761,10 +1958,13 @@ end_net_output: ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_snapshot_outputs(struct config_writer *writer, struct snapshot *snapshot) @@ -1807,7 +2007,7 @@ int save_snapshot_outputs(struct config_writer *writer, } ret = save_consumer_output(writer, output->consumer); - if (ret) { + if (ret != LTTNG_OK) { goto end_unlock; } @@ -1827,6 +2027,7 @@ int save_snapshot_outputs(struct config_writer *writer, goto end; } + ret = LTTNG_OK; end: return ret; end_unlock: @@ -1834,6 +2035,7 @@ end_unlock: return ret; } +/* Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_session_output(struct config_writer *writer, struct ltt_session *session) @@ -1846,7 +2048,7 @@ int save_session_output(struct config_writer *writer, if ((session->snapshot_mode && session->snapshot.nb_output == 0) || (!session->snapshot_mode && !session->consumer)) { /* Session is in no output mode */ - ret = 0; + ret = LTTNG_OK; goto end; } @@ -1858,13 +2060,13 @@ int save_session_output(struct config_writer *writer, if (session->snapshot_mode) { ret = save_snapshot_outputs(writer, &session->snapshot); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } else { if (session->consumer) { ret = save_consumer_output(writer, session->consumer); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } @@ -1876,6 +2078,7 @@ int save_session_output(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + ret = LTTNG_OK; end: return ret; } @@ -1883,7 +2086,7 @@ end: /* * Save the given session. * - * Return 0 on success else a LTTNG_ERR* code. + * Return LTTNG_OK on success else a LTTNG_ERR* code. */ static int save_session(struct ltt_session *session, @@ -2010,7 +2213,7 @@ int save_session(struct ltt_session *session, goto end; } - if(session->shm_path[0] != '\0') { + if (session->shm_path[0] != '\0') { ret = config_writer_write_element_string(writer, config_element_shared_memory_path, session->shm_path); @@ -2021,7 +2224,7 @@ int save_session(struct ltt_session *session, } ret = save_domains(writer, session); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -2084,7 +2287,7 @@ int save_session(struct ltt_session *session, } ret = save_session_output(writer, session); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -2101,12 +2304,14 @@ int save_session(struct ltt_session *session, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: if (writer && config_writer_destroy(writer)) { /* Preserve the original error code */ - ret = ret ? ret : LTTNG_ERR_SAVE_IO_FAIL; + ret = ret != LTTNG_OK ? ret : LTTNG_ERR_SAVE_IO_FAIL; } - if (ret) { + if (ret != LTTNG_OK) { /* Delete file in case of error */ if (file_opened && unlink(config_file_path)) { PERROR("Unlinking XML session configuration."); @@ -2114,8 +2319,10 @@ end: } if (file_opened) { - ret = close(fd); - if (ret) { + int closeret; + + closeret = close(fd); + if (closeret) { PERROR("Closing XML session configuration"); } } @@ -2143,7 +2350,7 @@ int cmd_save_sessions(struct lttng_save_session_attr *attr, session_lock(session); ret = save_session(session, attr, creds); session_unlock(session); - if (ret) { + if (ret != LTTNG_OK) { goto end; } } else { @@ -2155,7 +2362,7 @@ int cmd_save_sessions(struct lttng_save_session_attr *attr, session_unlock(session); /* Don't abort if we don't have the required permissions. */ - if (ret && ret != LTTNG_ERR_EPERM) { + if (ret != LTTNG_OK && ret != LTTNG_ERR_EPERM) { goto end; } } diff --git a/src/bin/lttng-sessiond/trace-kernel.c b/src/bin/lttng-sessiond/trace-kernel.c index ef5abbab4..1d7e1724c 100644 --- a/src/bin/lttng-sessiond/trace-kernel.c +++ b/src/bin/lttng-sessiond/trace-kernel.c @@ -158,6 +158,30 @@ struct ltt_kernel_session *trace_kernel_create_session(void) lks->metadata = NULL; CDS_INIT_LIST_HEAD(&lks->channel_list.head); + lks->tracker_list_pid = lttng_tracker_list_create(); + if (!lks->tracker_list_pid) { + goto error; + } + lks->tracker_list_vpid = lttng_tracker_list_create(); + if (!lks->tracker_list_vpid) { + goto error; + } + lks->tracker_list_uid = lttng_tracker_list_create(); + if (!lks->tracker_list_uid) { + goto error; + } + lks->tracker_list_vuid = lttng_tracker_list_create(); + if (!lks->tracker_list_vuid) { + goto error; + } + lks->tracker_list_gid = lttng_tracker_list_create(); + if (!lks->tracker_list_gid) { + goto error; + } + lks->tracker_list_vgid = lttng_tracker_list_create(); + if (!lks->tracker_list_vgid) { + goto error; + } lks->consumer = consumer_create_output(CONSUMER_DST_LOCAL); if (lks->consumer == NULL) { goto error; @@ -166,6 +190,12 @@ struct ltt_kernel_session *trace_kernel_create_session(void) return lks; error: + lttng_tracker_list_destroy(lks->tracker_list_pid); + lttng_tracker_list_destroy(lks->tracker_list_vpid); + lttng_tracker_list_destroy(lks->tracker_list_uid); + lttng_tracker_list_destroy(lks->tracker_list_vuid); + lttng_tracker_list_destroy(lks->tracker_list_gid); + lttng_tracker_list_destroy(lks->tracker_list_vgid); free(lks); alloc_error: @@ -621,5 +651,12 @@ void trace_kernel_destroy_session(struct ltt_kernel_session *session) /* Wipe consumer output object */ consumer_output_put(session->consumer); + lttng_tracker_list_destroy(session->tracker_list_pid); + lttng_tracker_list_destroy(session->tracker_list_vpid); + lttng_tracker_list_destroy(session->tracker_list_uid); + lttng_tracker_list_destroy(session->tracker_list_vuid); + lttng_tracker_list_destroy(session->tracker_list_gid); + lttng_tracker_list_destroy(session->tracker_list_vgid); + free(session); } diff --git a/src/bin/lttng-sessiond/trace-kernel.h b/src/bin/lttng-sessiond/trace-kernel.h index 3210d4b33..15e837f8c 100644 --- a/src/bin/lttng-sessiond/trace-kernel.h +++ b/src/bin/lttng-sessiond/trace-kernel.h @@ -26,6 +26,7 @@ #include #include "consumer.h" +#include "tracker.h" /* Kernel event list */ struct ltt_kernel_event_list { @@ -119,6 +120,13 @@ struct ltt_kernel_session { unsigned int output_traces; unsigned int snapshot_mode; unsigned int has_non_default_channel; + + struct lttng_tracker_list *tracker_list_pid; + struct lttng_tracker_list *tracker_list_vpid; + struct lttng_tracker_list *tracker_list_uid; + struct lttng_tracker_list *tracker_list_vuid; + struct lttng_tracker_list *tracker_list_gid; + struct lttng_tracker_list *tracker_list_vgid; }; /* diff --git a/src/bin/lttng-sessiond/trace-ust.c b/src/bin/lttng-sessiond/trace-ust.c index bcb04fe57..ff0c97513 100644 --- a/src/bin/lttng-sessiond/trace-ust.c +++ b/src/bin/lttng-sessiond/trace-ust.c @@ -280,7 +280,7 @@ struct ltt_ust_session *trace_ust_create_session(uint64_t session_id) lus = zmalloc(sizeof(struct ltt_ust_session)); if (lus == NULL) { PERROR("create ust session zmalloc"); - goto error; + goto error_alloc; } /* Init data structure */ @@ -312,20 +312,35 @@ struct ltt_ust_session *trace_ust_create_session(uint64_t session_id) /* Alloc agent hash table. */ lus->agents = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + lus->tracker_list_vpid = lttng_tracker_list_create(); + if (!lus->tracker_list_vpid) { + goto error; + } + lus->tracker_list_vuid = lttng_tracker_list_create(); + if (!lus->tracker_list_vuid) { + goto error; + } + lus->tracker_list_vgid = lttng_tracker_list_create(); + if (!lus->tracker_list_vgid) { + goto error; + } lus->consumer = consumer_create_output(CONSUMER_DST_LOCAL); if (lus->consumer == NULL) { - goto error_consumer; + goto error; } DBG2("UST trace session create successful"); return lus; -error_consumer: +error: + lttng_tracker_list_destroy(lus->tracker_list_vpid); + lttng_tracker_list_destroy(lus->tracker_list_vuid); + lttng_tracker_list_destroy(lus->tracker_list_vgid); ht_cleanup_push(lus->domain_global.channels); ht_cleanup_push(lus->agents); free(lus); -error: +error_alloc: return NULL; } @@ -672,28 +687,28 @@ error: } static -void destroy_pid_tracker_node_rcu(struct rcu_head *head) +void destroy_id_tracker_node_rcu(struct rcu_head *head) { - struct ust_pid_tracker_node *tracker_node = - caa_container_of(head, struct ust_pid_tracker_node, node.head); + struct ust_id_tracker_node *tracker_node = + caa_container_of(head, struct ust_id_tracker_node, node.head); free(tracker_node); } static -void destroy_pid_tracker_node(struct ust_pid_tracker_node *tracker_node) +void destroy_id_tracker_node(struct ust_id_tracker_node *tracker_node) { - call_rcu(&tracker_node->node.head, destroy_pid_tracker_node_rcu); + call_rcu(&tracker_node->node.head, destroy_id_tracker_node_rcu); } static -int init_pid_tracker(struct ust_pid_tracker *pid_tracker) +int init_id_tracker(struct ust_id_tracker *id_tracker) { - int ret = 0; + int ret = LTTNG_OK; - pid_tracker->ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); - if (!pid_tracker->ht) { - ret = -1; + id_tracker->ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); + if (!id_tracker->ht) { + ret = LTTNG_ERR_NOMEM; goto end; } @@ -702,42 +717,42 @@ end: } /* - * Teardown pid tracker content, but don't free pid_tracker object. + * Teardown id tracker content, but don't free id_tracker object. */ static -void fini_pid_tracker(struct ust_pid_tracker *pid_tracker) +void fini_id_tracker(struct ust_id_tracker *id_tracker) { - struct ust_pid_tracker_node *tracker_node; + struct ust_id_tracker_node *tracker_node; struct lttng_ht_iter iter; - if (!pid_tracker->ht) { + if (!id_tracker->ht) { return; } rcu_read_lock(); - cds_lfht_for_each_entry(pid_tracker->ht->ht, + cds_lfht_for_each_entry(id_tracker->ht->ht, &iter.iter, tracker_node, node.node) { - int ret = lttng_ht_del(pid_tracker->ht, &iter); + int ret = lttng_ht_del(id_tracker->ht, &iter); assert(!ret); - destroy_pid_tracker_node(tracker_node); + destroy_id_tracker_node(tracker_node); } rcu_read_unlock(); - ht_cleanup_push(pid_tracker->ht); - pid_tracker->ht = NULL; + ht_cleanup_push(id_tracker->ht); + id_tracker->ht = NULL; } static -struct ust_pid_tracker_node *pid_tracker_lookup( - struct ust_pid_tracker *pid_tracker, int pid, +struct ust_id_tracker_node *id_tracker_lookup( + struct ust_id_tracker *id_tracker, int id, struct lttng_ht_iter *iter) { - unsigned long _pid = (unsigned long) pid; + unsigned long _id = (unsigned long) id; struct lttng_ht_node_ulong *node; - lttng_ht_lookup(pid_tracker->ht, (void *) _pid, iter); + lttng_ht_lookup(id_tracker->ht, (void *) _id, iter); node = lttng_ht_iter_get_node_ulong(iter); if (node) { - return caa_container_of(node, struct ust_pid_tracker_node, + return caa_container_of(node, struct ust_id_tracker_node, node); } else { return NULL; @@ -745,20 +760,20 @@ struct ust_pid_tracker_node *pid_tracker_lookup( } static -int pid_tracker_add_pid(struct ust_pid_tracker *pid_tracker, int pid) +int id_tracker_add_id(struct ust_id_tracker *id_tracker, int id) { int retval = LTTNG_OK; - struct ust_pid_tracker_node *tracker_node; + struct ust_id_tracker_node *tracker_node; struct lttng_ht_iter iter; - if (pid < 0) { + if (id < 0) { retval = LTTNG_ERR_INVALID; goto end; } - tracker_node = pid_tracker_lookup(pid_tracker, pid, &iter); + tracker_node = id_tracker_lookup(id_tracker, id, &iter); if (tracker_node) { /* Already exists. */ - retval = LTTNG_ERR_PID_TRACKED; + retval = LTTNG_ERR_ID_TRACKED; goto end; } tracker_node = zmalloc(sizeof(*tracker_node)); @@ -766,48 +781,86 @@ int pid_tracker_add_pid(struct ust_pid_tracker *pid_tracker, int pid) retval = LTTNG_ERR_NOMEM; goto end; } - lttng_ht_node_init_ulong(&tracker_node->node, (unsigned long) pid); - lttng_ht_add_unique_ulong(pid_tracker->ht, &tracker_node->node); + lttng_ht_node_init_ulong(&tracker_node->node, (unsigned long) id); + lttng_ht_add_unique_ulong(id_tracker->ht, &tracker_node->node); end: return retval; } static -int pid_tracker_del_pid(struct ust_pid_tracker *pid_tracker, int pid) +int id_tracker_del_id(struct ust_id_tracker *id_tracker, int id) { int retval = LTTNG_OK, ret; - struct ust_pid_tracker_node *tracker_node; + struct ust_id_tracker_node *tracker_node; struct lttng_ht_iter iter; - if (pid < 0) { + if (id < 0) { retval = LTTNG_ERR_INVALID; goto end; } - tracker_node = pid_tracker_lookup(pid_tracker, pid, &iter); + tracker_node = id_tracker_lookup(id_tracker, id, &iter); if (!tracker_node) { /* Not found */ - retval = LTTNG_ERR_PID_NOT_TRACKED; + retval = LTTNG_ERR_ID_NOT_TRACKED; goto end; } - ret = lttng_ht_del(pid_tracker->ht, &iter); + ret = lttng_ht_del(id_tracker->ht, &iter); assert(!ret); - destroy_pid_tracker_node(tracker_node); + destroy_id_tracker_node(tracker_node); end: return retval; } +static +struct ust_id_tracker *get_id_tracker(struct ltt_ust_session *session, + enum lttng_tracker_type tracker_type) +{ + switch (tracker_type) { + case LTTNG_TRACKER_VPID: + return &session->vpid_tracker; + case LTTNG_TRACKER_VUID: + return &session->vuid_tracker; + case LTTNG_TRACKER_VGID: + return &session->vgid_tracker; + default: + return NULL; + } +} + +static +struct lttng_tracker_list *get_id_tracker_list(struct ltt_ust_session *session, + enum lttng_tracker_type tracker_type) +{ + switch (tracker_type) { + case LTTNG_TRACKER_VPID: + return session->tracker_list_vpid; + case LTTNG_TRACKER_VUID: + return session->tracker_list_vuid; + case LTTNG_TRACKER_VGID: + return session->tracker_list_vgid; + default: + return NULL; + } +} + /* * The session lock is held when calling this function. */ -int trace_ust_pid_tracker_lookup(struct ltt_ust_session *session, int pid) +int trace_ust_id_tracker_lookup(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, int id) { struct lttng_ht_iter iter; + struct ust_id_tracker *id_tracker; - if (!session->pid_tracker.ht) { + id_tracker = get_id_tracker(session, tracker_type); + if (!id_tracker) { + abort(); + } + if (!id_tracker->ht) { return 1; } - if (pid_tracker_lookup(&session->pid_tracker, pid, &iter)) { + if (id_tracker_lookup(id_tracker, id, &iter)) { return 1; } return 0; @@ -816,47 +869,80 @@ int trace_ust_pid_tracker_lookup(struct ltt_ust_session *session, int pid) /* * Called with the session lock held. */ -int trace_ust_track_pid(struct ltt_ust_session *session, int pid) +int trace_ust_track_id(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, + struct lttng_tracker_id *id) { int retval = LTTNG_OK; + struct ust_id_tracker *id_tracker; + struct lttng_tracker_list *tracker_list; + int value; + + if (tracker_type == LTTNG_TRACKER_PID) { + DBG("Backward compatible behavior: translate PID tracker to VPID tracker for UST domain."); + tracker_type = LTTNG_TRACKER_VPID; + } + + retval = lttng_tracker_id_lookup_string(tracker_type, + id, &value); + if (retval != LTTNG_OK) { + return retval; + } + + /* Add to list. */ + tracker_list = get_id_tracker_list(session, tracker_type); + if (!tracker_list) { + return LTTNG_ERR_INVALID; + } + retval = lttng_tracker_list_add(tracker_list, id); + if (retval != LTTNG_OK) { + return retval; + } - if (pid == -1) { - /* Track all pids: destroy tracker if exists. */ - if (session->pid_tracker.ht) { - fini_pid_tracker(&session->pid_tracker); + id_tracker = get_id_tracker(session, tracker_type); + if (!id_tracker) { + abort(); + } + if (value == -1) { + /* Track all ids: destroy tracker if exists. */ + if (id_tracker->ht) { + fini_id_tracker(id_tracker); /* Ensure all apps have session. */ ust_app_global_update_all(session); } } else { - int ret; - - if (!session->pid_tracker.ht) { + if (!id_tracker->ht) { /* Create tracker. */ - if (init_pid_tracker(&session->pid_tracker)) { - ERR("Error initializing PID tracker"); - retval = LTTNG_ERR_NOMEM; + retval = init_id_tracker(id_tracker); + if (retval != LTTNG_OK) { + ERR("Error initializing ID tracker"); goto end; } - ret = pid_tracker_add_pid(&session->pid_tracker, pid); - if (ret != LTTNG_OK) { - retval = ret; - fini_pid_tracker(&session->pid_tracker); + retval = id_tracker_add_id(id_tracker, value); + if (retval != LTTNG_OK) { + fini_id_tracker(id_tracker); goto end; } - /* Remove all apps from session except pid. */ + /* Keep only apps matching ID. */ ust_app_global_update_all(session); } else { struct ust_app *app; - ret = pid_tracker_add_pid(&session->pid_tracker, pid); - if (ret != LTTNG_OK) { - retval = ret; + retval = id_tracker_add_id(id_tracker, value); + if (retval != LTTNG_OK) { goto end; } /* Add session to application */ - app = ust_app_find_by_pid(pid); - if (app) { - ust_app_global_update(session, app); + switch (tracker_type) { + case LTTNG_TRACKER_VPID: + app = ust_app_find_by_pid(value); + if (app) { + ust_app_global_update(session, app); + } + break; + default: + /* Keep only apps matching ID. */ + ust_app_global_update_all(session); } } } @@ -867,45 +953,80 @@ end: /* * Called with the session lock held. */ -int trace_ust_untrack_pid(struct ltt_ust_session *session, int pid) +int trace_ust_untrack_id(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, struct lttng_tracker_id *id) { int retval = LTTNG_OK; + struct ust_id_tracker *id_tracker; + struct lttng_tracker_list *tracker_list; + int value; + + if (tracker_type == LTTNG_TRACKER_PID) { + DBG("Backward compatible behavior: translate PID tracker to VPID tracker for UST domain."); + tracker_type = LTTNG_TRACKER_VPID; + } - if (pid == -1) { + retval = lttng_tracker_id_lookup_string(tracker_type, + id, &value); + if (retval != LTTNG_OK) { + return retval; + } + + /* Remove from list. */ + tracker_list = get_id_tracker_list(session, tracker_type); + if (!tracker_list) { + return LTTNG_ERR_INVALID; + } + retval = lttng_tracker_list_remove(tracker_list, id); + if (retval != LTTNG_OK) { + return retval; + } + + id_tracker = get_id_tracker(session, tracker_type); + if (!id_tracker) { + abort(); + } + + if (value == -1) { /* Create empty tracker, replace old tracker. */ - struct ust_pid_tracker tmp_tracker; + struct ust_id_tracker tmp_tracker; - tmp_tracker = session->pid_tracker; - if (init_pid_tracker(&session->pid_tracker)) { - ERR("Error initializing PID tracker"); - retval = LTTNG_ERR_NOMEM; + tmp_tracker = *id_tracker; + retval = init_id_tracker(id_tracker); + if (retval != LTTNG_OK) { + ERR("Error initializing ID tracker"); /* Rollback operation. */ - session->pid_tracker = tmp_tracker; + *id_tracker = tmp_tracker; goto end; } - fini_pid_tracker(&tmp_tracker); + fini_id_tracker(&tmp_tracker); - /* Remove session from all applications */ + /* Keep only apps matching ID. */ ust_app_global_update_all(session); } else { - int ret; struct ust_app *app; - if (!session->pid_tracker.ht) { - /* No PID being tracked. */ - retval = LTTNG_ERR_PID_NOT_TRACKED; + if (!id_tracker->ht) { + /* No ID being tracked. */ + retval = LTTNG_ERR_ID_NOT_TRACKED; goto end; } - /* Remove PID from tracker */ - ret = pid_tracker_del_pid(&session->pid_tracker, pid); - if (ret != LTTNG_OK) { - retval = ret; + /* Remove ID from tracker */ + retval = id_tracker_del_id(id_tracker, value); + if (retval != LTTNG_OK) { goto end; } - /* Remove session from application. */ - app = ust_app_find_by_pid(pid); - if (app) { - ust_app_global_update(session, app); + switch (tracker_type) { + case LTTNG_TRACKER_VPID: + /* Remove session from application. */ + app = ust_app_find_by_pid(value); + if (app) { + ust_app_global_update(session, app); + } + break; + default: + /* Keep only apps matching ID. */ + ust_app_global_update_all(session); } } end: @@ -915,45 +1036,22 @@ end: /* * Called with session lock held. */ -ssize_t trace_ust_list_tracker_pids(struct ltt_ust_session *session, - int32_t **_pids) +ssize_t trace_ust_list_tracker_ids(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, + struct lttng_tracker_id **_ids) { - struct ust_pid_tracker_node *tracker_node; - struct lttng_ht_iter iter; - unsigned long count, i = 0; - long approx[2]; - int32_t *pids; - int ret = 0; + struct lttng_tracker_list *tracker_list; - if (!session->pid_tracker.ht) { - /* Tracker disabled. Set first entry to -1. */ - pids = zmalloc(sizeof(*pids)); - if (!pids) { - ret = -1; - goto end; - } - pids[0] = -1; - *_pids = pids; - return 1; + if (tracker_type == LTTNG_TRACKER_PID) { + DBG("Backward compatible behavior: translate PID tracker to VPID tracker for UST domain."); + tracker_type = LTTNG_TRACKER_VPID; } - rcu_read_lock(); - cds_lfht_count_nodes(session->pid_tracker.ht->ht, - &approx[0], &count, &approx[1]); - pids = zmalloc(sizeof(*pids) * count); - if (!pids) { - ret = -1; - goto end; - } - cds_lfht_for_each_entry(session->pid_tracker.ht->ht, - &iter.iter, tracker_node, node.node) { - pids[i++] = tracker_node->node.key; + tracker_list = get_id_tracker_list(session, tracker_type); + if (!tracker_list) { + return -LTTNG_ERR_INVALID; } - *_pids = pids; - ret = count; -end: - rcu_read_unlock(); - return ret; + return lttng_tracker_id_get_list(tracker_list, _ids); } /* @@ -1186,7 +1284,13 @@ void trace_ust_destroy_session(struct ltt_ust_session *session) consumer_output_put(session->consumer); - fini_pid_tracker(&session->pid_tracker); + lttng_tracker_list_destroy(session->tracker_list_vpid); + lttng_tracker_list_destroy(session->tracker_list_vuid); + lttng_tracker_list_destroy(session->tracker_list_vgid); + + fini_id_tracker(&session->vpid_tracker); + fini_id_tracker(&session->vuid_tracker); + fini_id_tracker(&session->vgid_tracker); free(session); } diff --git a/src/bin/lttng-sessiond/trace-ust.h b/src/bin/lttng-sessiond/trace-ust.h index 33b0a2031..cb2b1fcfd 100644 --- a/src/bin/lttng-sessiond/trace-ust.h +++ b/src/bin/lttng-sessiond/trace-ust.h @@ -91,11 +91,11 @@ struct ltt_ust_domain_global { struct cds_list_head registry_buffer_uid_list; }; -struct ust_pid_tracker_node { +struct ust_id_tracker_node { struct lttng_ht_node_ulong node; }; -struct ust_pid_tracker { +struct ust_id_tracker { struct lttng_ht *ht; }; @@ -138,7 +138,15 @@ struct ltt_ust_session { char root_shm_path[PATH_MAX]; char shm_path[PATH_MAX]; - struct ust_pid_tracker pid_tracker; + /* Trackers used for actual lookup on app registration. */ + struct ust_id_tracker vpid_tracker; + struct ust_id_tracker vuid_tracker; + struct ust_id_tracker vgid_tracker; + + /* Tracker list of keys requested by users. */ + struct lttng_tracker_list *tracker_list_vpid; + struct lttng_tracker_list *tracker_list_vuid; + struct lttng_tracker_list *tracker_list_vgid; }; /* @@ -215,13 +223,19 @@ void trace_ust_destroy_channel(struct ltt_ust_channel *channel); void trace_ust_destroy_event(struct ltt_ust_event *event); void trace_ust_destroy_context(struct ltt_ust_context *ctx); -int trace_ust_track_pid(struct ltt_ust_session *session, int pid); -int trace_ust_untrack_pid(struct ltt_ust_session *session, int pid); +int trace_ust_track_id(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, + struct lttng_tracker_id *id); +int trace_ust_untrack_id(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, + struct lttng_tracker_id *id); -int trace_ust_pid_tracker_lookup(struct ltt_ust_session *session, int pid); +int trace_ust_id_tracker_lookup(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, int id); -ssize_t trace_ust_list_tracker_pids(struct ltt_ust_session *session, - int32_t **_pids); +ssize_t trace_ust_list_tracker_ids(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, + struct lttng_tracker_id **_ids); #else /* HAVE_LIBLTTNG_UST_CTL */ @@ -309,23 +323,27 @@ struct agent *trace_ust_find_agent(struct ltt_ust_session *session, return NULL; } static inline -int trace_ust_track_pid(struct ltt_ust_session *session, int pid) +int trace_ust_track_id(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, int id) { return 0; } static inline -int trace_ust_untrack_pid(struct ltt_ust_session *session, int pid) +int trace_ust_untrack_id(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, int id) { return 0; } static inline -int trace_ust_pid_tracker_lookup(struct ltt_ust_session *session, int pid) +int trace_ust_id_tracker_lookup(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, int pid) { return 0; } static inline -ssize_t trace_ust_list_tracker_pids(struct ltt_ust_session *session, - int32_t **_pids) +ssize_t trace_ust_list_tracker_ids(enum lttng_tracker_type tracker_type, + struct ltt_ust_session *session, + struct lttng_tracker_id **_ids) { return -1; } diff --git a/src/bin/lttng-sessiond/ust-app.c b/src/bin/lttng-sessiond/ust-app.c index 160f567c8..38271c35e 100644 --- a/src/bin/lttng-sessiond/ust-app.c +++ b/src/bin/lttng-sessiond/ust-app.c @@ -4165,7 +4165,9 @@ int ust_app_create_channel_glb(struct ltt_ust_session *usess, */ continue; } - if (!trace_ust_pid_tracker_lookup(usess, app->pid)) { + if (!(trace_ust_id_tracker_lookup(LTTNG_TRACKER_VPID, usess, app->pid) + && trace_ust_id_tracker_lookup(LTTNG_TRACKER_VUID, usess, app->uid) + && trace_ust_id_tracker_lookup(LTTNG_TRACKER_VGID, usess, app->gid))) { /* Skip. */ continue; } @@ -5163,7 +5165,9 @@ void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app) return; } - if (trace_ust_pid_tracker_lookup(usess, app->pid)) { + if (trace_ust_id_tracker_lookup(LTTNG_TRACKER_VPID, usess, app->pid) + && trace_ust_id_tracker_lookup(LTTNG_TRACKER_VUID, usess, app->uid) + && trace_ust_id_tracker_lookup(LTTNG_TRACKER_VGID, usess, app->gid)) { ust_app_global_create(usess, app); } else { ust_app_global_destroy(usess, app); -- 2.34.1