From: Mathieu Desnoyers Date: Wed, 4 Jul 2018 20:46:25 +0000 (-0400) Subject: Backport: trackers: update lttng-sessiond X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=commitdiff_plain;h=c92af2a5fd6587a03f1a0e927fd734751032b3a1 Backport: trackers: update lttng-sessiond Signed-off-by: Mathieu Desnoyers --- diff --git a/src/bin/lttng-sessiond/Makefile.am b/src/bin/lttng-sessiond/Makefile.am index 827de138e..04f5cf4a3 100644 --- a/src/bin/lttng-sessiond/Makefile.am +++ b/src/bin/lttng-sessiond/Makefile.am @@ -29,7 +29,8 @@ lttng_sessiond_SOURCES = utils.c utils.h \ agent.c agent.h \ save.h save.c \ load-session-thread.h load-session-thread.c \ - syscall.h syscall.c + syscall.h syscall.c \ + 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 cf30b8ebf..d5ed1dcfc 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -1195,12 +1195,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; @@ -1213,7 +1215,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; } @@ -1227,7 +1229,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; } @@ -1246,12 +1248,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; @@ -1264,7 +1268,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; } @@ -1278,7 +1282,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; } @@ -2332,12 +2336,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; @@ -2348,7 +2354,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; @@ -2360,7 +2366,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 ac88d5130..bb1a19b42 100644 --- a/src/bin/lttng-sessiond/cmd.h +++ b/src/bin/lttng-sessiond/cmd.h @@ -40,10 +40,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, @@ -93,8 +97,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 b1a3f0b70..ea0e75d7f 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -384,16 +384,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: @@ -401,103 +487,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 233ceffea..4e284d930 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); @@ -63,7 +67,8 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits); 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); #endif /* _LTT_KERNEL_CTL_H */ diff --git a/src/bin/lttng-sessiond/main.c b/src/bin/lttng-sessiond/main.c index c878cda95..7c5691f2b 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" @@ -3081,7 +3082,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: break; default: @@ -3490,18 +3491,100 @@ error_add_context: &cmd_ctx->lsm->u.channel.chan, 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: @@ -3700,27 +3783,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 1a879b214..b09aeccc6 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,12 +111,14 @@ 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; } 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) @@ -119,12 +130,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; } @@ -132,6 +145,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; } @@ -139,6 +153,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; } @@ -146,6 +161,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; } @@ -154,10 +170,13 @@ 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; } + + ret = LTTNG_OK; end: - return ret ? LTTNG_ERR_SAVE_IO_FAIL : 0; + return ret; } static @@ -335,6 +354,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) @@ -510,10 +530,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) @@ -529,7 +552,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; } } @@ -540,10 +563,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) @@ -654,10 +680,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) @@ -682,7 +711,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; } @@ -695,22 +724,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) { @@ -725,7 +757,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; } @@ -733,10 +765,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 ltt_ust_channel *chan, @@ -768,12 +803,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; } @@ -786,15 +821,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; @@ -866,10 +904,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) @@ -878,7 +918,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; } @@ -890,7 +930,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; } } @@ -901,10 +941,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) @@ -948,10 +991,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) @@ -990,10 +1036,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) @@ -1019,10 +1068,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) @@ -1058,7 +1110,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; } @@ -1076,10 +1128,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) @@ -1110,17 +1165,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; } @@ -1130,10 +1185,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, @@ -1166,7 +1224,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; } @@ -1194,7 +1252,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 { @@ -1214,13 +1272,13 @@ int save_ust_channel(struct config_writer *writer, * them. */ ret = save_agent_events(writer, ust_chan, 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; } @@ -1230,10 +1288,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) @@ -1268,7 +1329,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; } } @@ -1279,6 +1340,8 @@ int save_kernel_session(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + + ret = LTTNG_OK; end: return ret; } @@ -1311,19 +1374,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; } @@ -1331,8 +1433,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; } @@ -1346,64 +1448,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) @@ -1465,7 +1653,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; } @@ -1488,14 +1676,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; } } @@ -1507,14 +1696,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); @@ -1529,7 +1720,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); @@ -1539,7 +1729,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; } @@ -1550,8 +1740,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; } @@ -1571,22 +1761,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; } } @@ -1597,10 +1787,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) @@ -1681,10 +1874,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 { @@ -1721,10 +1914,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) @@ -1767,7 +1963,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; } @@ -1787,6 +1983,7 @@ int save_snapshot_outputs(struct config_writer *writer, goto end; } + ret = LTTNG_OK; end: return ret; end_unlock: @@ -1794,6 +1991,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) @@ -1806,7 +2004,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; } @@ -1818,13 +2016,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; } } @@ -1836,6 +2034,7 @@ int save_session_output(struct config_writer *writer, ret = LTTNG_ERR_SAVE_IO_FAIL; goto end; } + ret = LTTNG_OK; end: return ret; } @@ -1843,7 +2042,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, @@ -1970,7 +2169,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); @@ -1981,7 +2180,7 @@ int save_session(struct ltt_session *session, } ret = save_domains(writer, session); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -2024,7 +2223,7 @@ int save_session(struct ltt_session *session, } ret = save_session_output(writer, session); - if (ret) { + if (ret != LTTNG_OK) { goto end; } @@ -2041,12 +2240,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."); @@ -2054,8 +2255,10 @@ end: } if (file_opened) { - ret = close(fd); - if (ret) { + int closeret; + + closeret = close(fd); + if (closeret) { PERROR("Closing XML session configuration"); } } @@ -2083,7 +2286,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 { @@ -2095,7 +2298,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 fa207bc67..d1f826883 100644 --- a/src/bin/lttng-sessiond/trace-kernel.c +++ b/src/bin/lttng-sessiond/trace-kernel.c @@ -156,6 +156,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; @@ -164,6 +188,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: @@ -595,5 +625,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 74bf1df1d..fbaa5039c 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 { @@ -116,6 +117,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 1c325fb25..10af67e37 100644 --- a/src/bin/lttng-sessiond/trace-ust.c +++ b/src/bin/lttng-sessiond/trace-ust.c @@ -31,6 +31,7 @@ #include "utils.h" #include "ust-app.h" #include "agent.h" +#include "tracker.h" /* * Match function for the events hash table lookup. @@ -280,7 +281,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 +313,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; } @@ -668,28 +684,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; } @@ -698,42 +714,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; @@ -741,20 +757,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)); @@ -762,48 +778,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; @@ -812,47 +866,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); } } } @@ -863,45 +950,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: @@ -911,45 +1033,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); } /* @@ -1182,7 +1281,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 fc9eef4b7..6cabaf86b 100644 --- a/src/bin/lttng-sessiond/trace-ust.h +++ b/src/bin/lttng-sessiond/trace-ust.h @@ -90,11 +90,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; }; @@ -137,7 +137,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; }; /* @@ -214,13 +222,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 */ @@ -308,23 +322,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 54c22df76..ed9c9fe35 100644 --- a/src/bin/lttng-sessiond/ust-app.c +++ b/src/bin/lttng-sessiond/ust-app.c @@ -4084,7 +4084,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; } @@ -5059,7 +5061,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);