From 9a6545985844978f34f88b82bf1bcd649968c0a3 Mon Sep 17 00:00:00 2001 From: =?utf8?q?J=C3=A9r=C3=A9mie=20Galarneau?= Date: Fri, 16 Nov 2018 16:46:36 -0500 Subject: [PATCH] Fix: cmd_snapshot_record can return unexpected error codes MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit cmd_snapshot_record() does not correctly handle the various error reporting conventions used by the functions it uses. In certain cases, invalid error codes (not part of enum lttng_error_code) can bubble up to the command handler which results in erroneous error messages being reported by the client. This change harmonizes the error handling and changes a number of functions used to explicitly return 'enum lttng_error_code' instead of 'int'. Signed-off-by: Jérémie Galarneau --- src/bin/lttng-sessiond/cmd.c | 152 +++++++++++++++--------------- src/bin/lttng-sessiond/consumer.c | 28 +++--- src/bin/lttng-sessiond/consumer.h | 4 +- src/bin/lttng-sessiond/kernel.c | 25 +++-- src/bin/lttng-sessiond/kernel.h | 2 +- src/bin/lttng-sessiond/ust-app.c | 45 +++++---- src/bin/lttng-sessiond/ust-app.h | 4 +- 7 files changed, 133 insertions(+), 127 deletions(-) diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 23a84615b..0f76ac715 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -954,19 +954,20 @@ error: * Create a socket to the relayd using the URI. * * On success, the relayd_sock pointer is set to the created socket. - * Else, it's stays untouched and a lttcomm error code is returned. + * Else, it remains untouched and an LTTng error code is returned. */ -static int create_connect_relayd(struct lttng_uri *uri, +static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri, struct lttcomm_relayd_sock **relayd_sock, struct consumer_output *consumer) { int ret; + enum lttng_error_code status = LTTNG_OK; struct lttcomm_relayd_sock *rsock; rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR, RELAYD_VERSION_COMM_MINOR); if (!rsock) { - ret = LTTNG_ERR_FATAL; + status = LTTNG_ERR_FATAL; goto error; } @@ -980,7 +981,7 @@ static int create_connect_relayd(struct lttng_uri *uri, health_poll_exit(); if (ret < 0) { ERR("Unable to reach lttng-relayd"); - ret = LTTNG_ERR_RELAYD_CONNECT_FAIL; + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; goto free_sock; } @@ -991,10 +992,11 @@ static int create_connect_relayd(struct lttng_uri *uri, /* Check relayd version */ ret = relayd_version_check(rsock); if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) { + status = LTTNG_ERR_RELAYD_VERSION_FAIL; goto close_sock; } else if (ret < 0) { ERR("Unable to reach lttng-relayd"); - ret = LTTNG_ERR_RELAYD_CONNECT_FAIL; + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; goto close_sock; } consumer->relay_major_version = rsock->major; @@ -1004,13 +1006,13 @@ static int create_connect_relayd(struct lttng_uri *uri, } else { /* Command is not valid */ ERR("Relayd invalid stream type: %d", uri->stype); - ret = LTTNG_ERR_INVALID; + status = LTTNG_ERR_INVALID; goto close_sock; } *relayd_sock = rsock; - return LTTNG_OK; + return status; close_sock: /* The returned value is not useful since we are on an error path. */ @@ -1018,15 +1020,18 @@ close_sock: free_sock: free(rsock); error: - return ret; + return status; } /* * Connect to the relayd using URI and send the socket to the right consumer. * * The consumer socket lock must be held by the caller. + * + * Returns LTTNG_OK on success or an LTTng error code on failure. */ -static int send_consumer_relayd_socket(unsigned int session_id, +static enum lttng_error_code send_consumer_relayd_socket( + unsigned int session_id, struct lttng_uri *relayd_uri, struct consumer_output *consumer, struct consumer_socket *consumer_sock, @@ -1034,10 +1039,11 @@ static int send_consumer_relayd_socket(unsigned int session_id, { int ret; struct lttcomm_relayd_sock *rsock = NULL; + enum lttng_error_code status; /* Connect to relayd and make version check if uri is the control. */ - ret = create_connect_relayd(relayd_uri, &rsock, consumer); - if (ret != LTTNG_OK) { + status = create_connect_relayd(relayd_uri, &rsock, consumer); + if (status != LTTNG_OK) { goto relayd_comm_error; } assert(rsock); @@ -1059,7 +1065,7 @@ static int send_consumer_relayd_socket(unsigned int session_id, relayd_uri->stype, session_id, session_name, hostname, session_live_timer); if (ret < 0) { - ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL; + status = LTTNG_ERR_ENABLE_CONSUMER_FAIL; goto close_sock; } @@ -1070,15 +1076,13 @@ static int send_consumer_relayd_socket(unsigned int session_id, consumer_sock->data_sock_sent = 1; } - ret = LTTNG_OK; - /* * Close socket which was dup on the consumer side. The session daemon does * NOT keep track of the relayd socket(s) once transfer to the consumer. */ close_sock: - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { /* * The consumer output for this session should not be used anymore * since the relayd connection failed thus making any tracing or/and @@ -1090,7 +1094,7 @@ close_sock: free(rsock); relayd_comm_error: - return ret; + return status; } /* @@ -1099,39 +1103,42 @@ relayd_comm_error: * session. * * The consumer socket lock must be held by the caller. + * + * Returns LTTNG_OK, or an LTTng error code on failure. */ -static int send_consumer_relayd_sockets(enum lttng_domain_type domain, +static enum lttng_error_code send_consumer_relayd_sockets( + enum lttng_domain_type domain, unsigned int session_id, struct consumer_output *consumer, struct consumer_socket *sock, char *session_name, char *hostname, int session_live_timer) { - int ret = LTTNG_OK; + enum lttng_error_code status = LTTNG_OK; assert(consumer); assert(sock); /* Sending control relayd socket. */ if (!sock->control_sock_sent) { - ret = send_consumer_relayd_socket(session_id, + status = send_consumer_relayd_socket(session_id, &consumer->dst.net.control, consumer, sock, session_name, hostname, session_live_timer); - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { goto error; } } /* Sending data relayd socket. */ if (!sock->data_sock_sent) { - ret = send_consumer_relayd_socket(session_id, + status = send_consumer_relayd_socket(session_id, &consumer->dst.net.data, consumer, sock, session_name, hostname, session_live_timer); - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { goto error; } } error: - return ret; + return status; } /* @@ -4093,12 +4100,14 @@ end: * Send relayd sockets from snapshot output to consumer. Ignore request if the * snapshot output is *not* set with a remote destination. * - * Return 0 on success or a LTTNG_ERR code. + * Return LTTNG_OK on success or a LTTNG_ERR code. */ -static int set_relayd_for_snapshot(struct consumer_output *consumer, - struct snapshot_output *snap_output, struct ltt_session *session) +static enum lttng_error_code set_relayd_for_snapshot( + struct consumer_output *consumer, + struct snapshot_output *snap_output, + struct ltt_session *session) { - int ret = LTTNG_OK; + enum lttng_error_code status = LTTNG_OK; struct lttng_ht_iter iter; struct consumer_socket *socket; @@ -4121,12 +4130,12 @@ static int set_relayd_for_snapshot(struct consumer_output *consumer, cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter, socket, node.node) { pthread_mutex_lock(socket->lock); - ret = send_consumer_relayd_sockets(0, session->id, + status = send_consumer_relayd_sockets(0, session->id, snap_output->consumer, socket, session->name, session->hostname, session->live_timer); pthread_mutex_unlock(socket->lock); - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { rcu_read_unlock(); goto error; } @@ -4134,7 +4143,7 @@ static int set_relayd_for_snapshot(struct consumer_output *consumer, rcu_read_unlock(); error: - return ret; + return status; } /* @@ -4142,38 +4151,37 @@ error: * * Return LTTNG_OK on success or a LTTNG_ERR code. */ -static int record_kernel_snapshot(struct ltt_kernel_session *ksess, +static enum lttng_error_code record_kernel_snapshot(struct ltt_kernel_session *ksess, struct snapshot_output *output, struct ltt_session *session, int wait, uint64_t nb_packets_per_stream) { int ret; + enum lttng_error_code status; assert(ksess); assert(output); assert(session); - /* * Copy kernel session sockets so we can communicate with the right * consumer for the snapshot record command. */ ret = consumer_copy_sockets(output->consumer, ksess->consumer); if (ret < 0) { - ret = LTTNG_ERR_NOMEM; + status = LTTNG_ERR_NOMEM; goto error; } - ret = set_relayd_for_snapshot(ksess->consumer, output, session); - if (ret != LTTNG_OK) { + status = set_relayd_for_snapshot(ksess->consumer, output, session); + if (status != LTTNG_OK) { goto error_snapshot; } - ret = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { + status = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream); + if (status != LTTNG_OK) { goto error_snapshot; } - ret = LTTNG_OK; goto end; error_snapshot: @@ -4181,19 +4189,20 @@ error_snapshot: consumer_destroy_output_sockets(output->consumer); error: end: - return ret; + return status; } /* * Record a UST snapshot. * - * Return 0 on success or a LTTNG_ERR error code. + * Returns LTTNG_OK on success or a LTTNG_ERR error code. */ -static int record_ust_snapshot(struct ltt_ust_session *usess, +static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess, struct snapshot_output *output, struct ltt_session *session, int wait, uint64_t nb_packets_per_stream) { int ret; + enum lttng_error_code status; assert(usess); assert(output); @@ -4205,35 +4214,25 @@ static int record_ust_snapshot(struct ltt_ust_session *usess, */ ret = consumer_copy_sockets(output->consumer, usess->consumer); if (ret < 0) { - ret = LTTNG_ERR_NOMEM; + status = LTTNG_ERR_NOMEM; goto error; } - ret = set_relayd_for_snapshot(usess->consumer, output, session); - if (ret != LTTNG_OK) { + status = set_relayd_for_snapshot(usess->consumer, output, session); + if (status != LTTNG_OK) { goto error_snapshot; } - ret = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream); - if (ret < 0) { - switch (-ret) { - case EINVAL: - ret = LTTNG_ERR_INVALID; - break; - default: - ret = LTTNG_ERR_SNAPSHOT_FAIL; - break; - } + status = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream); + if (status != LTTNG_OK) { goto error_snapshot; } - ret = LTTNG_OK; - error_snapshot: /* Clean up copied sockets so this output can use some other later on. */ consumer_destroy_output_sockets(output->consumer); error: - return ret; + return status; } static @@ -4333,7 +4332,8 @@ int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t int cmd_snapshot_record(struct ltt_session *session, struct lttng_snapshot_output *output, int wait) { - int ret = LTTNG_OK; + enum lttng_error_code cmd_ret = LTTNG_OK; + int ret; unsigned int use_tmp_output = 0; struct snapshot_output tmp_output; unsigned int snapshot_success = 0; @@ -4348,7 +4348,7 @@ int cmd_snapshot_record(struct ltt_session *session, ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime, sizeof(datetime)); if (!ret) { - ret = LTTNG_ERR_INVALID; + cmd_ret = LTTNG_ERR_INVALID; goto error; } @@ -4357,13 +4357,13 @@ int cmd_snapshot_record(struct ltt_session *session, * set in no output mode. */ if (session->output_traces) { - ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; + cmd_ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; goto error; } /* The session needs to be started at least once. */ if (!session->has_been_started) { - ret = LTTNG_ERR_START_SESSION_ONCE; + cmd_ret = LTTNG_ERR_START_SESSION_ONCE; goto error; } @@ -4374,9 +4374,9 @@ int cmd_snapshot_record(struct ltt_session *session, &tmp_output, NULL); if (ret < 0) { if (ret == -ENOMEM) { - ret = LTTNG_ERR_NOMEM; + cmd_ret = LTTNG_ERR_NOMEM; } else { - ret = LTTNG_ERR_INVALID; + cmd_ret = LTTNG_ERR_INVALID; } goto error; } @@ -4394,24 +4394,24 @@ int cmd_snapshot_record(struct ltt_session *session, nb_packets_per_stream = get_session_nb_packets_per_stream(session, tmp_output.max_size); if (nb_packets_per_stream < 0) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; + cmd_ret = LTTNG_ERR_MAX_SIZE_INVALID; goto error; } if (session->kernel_session) { - ret = record_kernel_snapshot(session->kernel_session, + cmd_ret = record_kernel_snapshot(session->kernel_session, &tmp_output, session, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { + if (cmd_ret != LTTNG_OK) { goto error; } } if (session->ust_session) { - ret = record_ust_snapshot(session->ust_session, + cmd_ret = record_ust_snapshot(session->ust_session, &tmp_output, session, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { + if (cmd_ret != LTTNG_OK) { goto error; } } @@ -4440,7 +4440,7 @@ int cmd_snapshot_record(struct ltt_session *session, nb_packets_per_stream = get_session_nb_packets_per_stream(session, tmp_output.max_size); if (nb_packets_per_stream < 0) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; + cmd_ret = LTTNG_ERR_MAX_SIZE_INVALID; rcu_read_unlock(); goto error; } @@ -4449,7 +4449,7 @@ int cmd_snapshot_record(struct ltt_session *session, if (*output->name != '\0') { if (lttng_strncpy(tmp_output.name, output->name, sizeof(tmp_output.name))) { - ret = LTTNG_ERR_INVALID; + cmd_ret = LTTNG_ERR_INVALID; rcu_read_unlock(); goto error; } @@ -4459,20 +4459,20 @@ int cmd_snapshot_record(struct ltt_session *session, memcpy(tmp_output.datetime, datetime, sizeof(datetime)); if (session->kernel_session) { - ret = record_kernel_snapshot(session->kernel_session, + cmd_ret = record_kernel_snapshot(session->kernel_session, &tmp_output, session, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { + if (cmd_ret != LTTNG_OK) { rcu_read_unlock(); goto error; } } if (session->ust_session) { - ret = record_ust_snapshot(session->ust_session, + cmd_ret = record_ust_snapshot(session->ust_session, &tmp_output, session, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { + if (cmd_ret != LTTNG_OK) { rcu_read_unlock(); goto error; } @@ -4485,11 +4485,11 @@ int cmd_snapshot_record(struct ltt_session *session, if (snapshot_success) { session->snapshot.nb_snapshot++; } else { - ret = LTTNG_ERR_SNAPSHOT_FAIL; + cmd_ret = LTTNG_ERR_SNAPSHOT_FAIL; } error: - return ret; + return cmd_ret; } /* diff --git a/src/bin/lttng-sessiond/consumer.c b/src/bin/lttng-sessiond/consumer.c index a179eeffd..80e313778 100644 --- a/src/bin/lttng-sessiond/consumer.c +++ b/src/bin/lttng-sessiond/consumer.c @@ -1418,14 +1418,15 @@ end: /* * Ask the consumer to snapshot a specific channel using the key. * - * Return 0 on success or else a negative error. + * Returns LTTNG_OK on success or else an LTTng error code. */ -int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, - struct snapshot_output *output, int metadata, uid_t uid, gid_t gid, - const char *session_path, int wait, uint64_t nb_packets_per_stream, - uint64_t trace_archive_id) +enum lttng_error_code consumer_snapshot_channel(struct consumer_socket *socket, + uint64_t key, struct snapshot_output *output, int metadata, + uid_t uid, gid_t gid, const char *session_path, int wait, + uint64_t nb_packets_per_stream, uint64_t trace_archive_id) { int ret; + enum lttng_error_code status = LTTNG_OK; struct lttcomm_consumer_msg msg; assert(socket); @@ -1453,7 +1454,7 @@ int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, output->nb_snapshot, session_path); if (ret < 0) { - ret = -LTTNG_ERR_NOMEM; + status = LTTNG_ERR_INVALID; goto error; } else if (ret >= sizeof(msg.u.snapshot_channel.pathname)) { ERR("Snapshot path exceeds the maximal allowed length of %zu bytes (%i bytes required) with path \"%s/%s/%s-%s-%" PRIu64 "%s\"", @@ -1463,7 +1464,7 @@ int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, output->name, output->datetime, output->nb_snapshot, session_path); - ret = -LTTNG_ERR_SNAPSHOT_FAIL; + status = LTTNG_ERR_SNAPSHOT_FAIL; goto error; } } else { @@ -1475,7 +1476,7 @@ int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, output->nb_snapshot, session_path); if (ret < 0) { - ret = -LTTNG_ERR_NOMEM; + status = LTTNG_ERR_NOMEM; goto error; } else if (ret >= sizeof(msg.u.snapshot_channel.pathname)) { ERR("Snapshot path exceeds the maximal allowed length of %zu bytes (%i bytes required) with path \"%s/%s-%s-%" PRIu64 "%s\"", @@ -1483,7 +1484,7 @@ int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, ret, output->consumer->dst.session_root_path, output->name, output->datetime, output->nb_snapshot, session_path); - ret = -LTTNG_ERR_SNAPSHOT_FAIL; + status = LTTNG_ERR_SNAPSHOT_FAIL; goto error; } @@ -1494,7 +1495,8 @@ int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, S_IRWXU | S_IRWXG, uid, gid); if (ret < 0) { if (errno != EEXIST) { - ERR("Trace directory creation error"); + status = LTTNG_ERR_CREATE_DIR_FAIL; + PERROR("Trace directory creation error"); goto error; } } @@ -1507,10 +1509,10 @@ int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, if (ret < 0) { switch (-ret) { case LTTCOMM_CONSUMERD_CHAN_NOT_FOUND: - ret = -LTTNG_ERR_CHAN_NOT_FOUND; + status = LTTNG_ERR_CHAN_NOT_FOUND; break; default: - ret = -LTTNG_ERR_SNAPSHOT_FAIL; + status = LTTNG_ERR_SNAPSHOT_FAIL; break; } goto error; @@ -1518,7 +1520,7 @@ int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, error: health_code_update(); - return ret; + return status; } /* diff --git a/src/bin/lttng-sessiond/consumer.h b/src/bin/lttng-sessiond/consumer.h index e9c7e31e3..c98ebb34f 100644 --- a/src/bin/lttng-sessiond/consumer.h +++ b/src/bin/lttng-sessiond/consumer.h @@ -312,8 +312,8 @@ int consumer_get_lost_packets(uint64_t session_id, uint64_t channel_key, struct consumer_output *consumer, uint64_t *lost); /* Snapshot command. */ -int consumer_snapshot_channel(struct consumer_socket *socket, uint64_t key, - struct snapshot_output *output, int metadata, +enum lttng_error_code consumer_snapshot_channel(struct consumer_socket *socket, + uint64_t key, struct snapshot_output *output, int metadata, uid_t uid, gid_t gid, const char *session_path, int wait, uint64_t nb_packets_per_stream, uint64_t trace_archive_id); diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index 4327db24b..edb7f7b2f 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -1233,13 +1233,14 @@ void kernel_destroy_channel(struct ltt_kernel_channel *kchan) /* * Take a snapshot for a given kernel session. * - * Return 0 on success or else return a LTTNG_ERR code. + * Return LTTNG_OK on success or else return a LTTNG_ERR code. */ -int kernel_snapshot_record(struct ltt_kernel_session *ksess, +enum lttng_error_code kernel_snapshot_record(struct ltt_kernel_session *ksess, struct snapshot_output *output, int wait, uint64_t nb_packets_per_stream) { int err, ret, saved_metadata_fd; + enum lttng_error_code status = LTTNG_OK; struct consumer_socket *socket; struct lttng_ht_iter iter; struct ltt_kernel_metadata *saved_metadata; @@ -1266,13 +1267,13 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, ret = kernel_open_metadata(ksess); if (ret < 0) { - ret = LTTNG_ERR_KERN_META_FAIL; + status = LTTNG_ERR_KERN_META_FAIL; goto error; } ret = kernel_open_metadata_stream(ksess); if (ret < 0) { - ret = LTTNG_ERR_KERN_META_FAIL; + status = LTTNG_ERR_KERN_META_FAIL; goto error_open_stream; } @@ -1296,19 +1297,18 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, /* Put back the saved consumer output into the session. */ ksess->consumer = saved_output; if (ret < 0) { - ret = LTTNG_ERR_KERN_CONSUMER_FAIL; + status = LTTNG_ERR_KERN_CONSUMER_FAIL; goto error_consumer; } /* For each channel, ask the consumer to snapshot it. */ cds_list_for_each_entry(chan, &ksess->channel_list.head, list) { - ret = consumer_snapshot_channel(socket, chan->key, output, 0, + status = consumer_snapshot_channel(socket, chan->key, output, 0, ksess->uid, ksess->gid, DEFAULT_KERNEL_TRACE_DIR, wait, nb_packets_per_stream, trace_archive_id); - if (ret < 0) { - ret = LTTNG_ERR_KERN_CONSUMER_FAIL; + if (status != LTTNG_OK) { (void) kernel_consumer_destroy_metadata(socket, ksess->metadata); goto error_consumer; @@ -1316,12 +1316,11 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, } /* Snapshot metadata, */ - ret = consumer_snapshot_channel(socket, ksess->metadata->key, output, + status = consumer_snapshot_channel(socket, ksess->metadata->key, output, 1, ksess->uid, ksess->gid, DEFAULT_KERNEL_TRACE_DIR, wait, 0, trace_archive_id); - if (ret < 0) { - ret = LTTNG_ERR_KERN_CONSUMER_FAIL; + if (status != LTTNG_OK) { goto error_consumer; } @@ -1332,8 +1331,6 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess, (void) kernel_consumer_destroy_metadata(socket, ksess->metadata); } - ret = LTTNG_OK; - error_consumer: /* Close newly opened metadata stream. It's now on the consumer side. */ err = close(ksess->metadata_stream_fd); @@ -1349,7 +1346,7 @@ error: ksess->metadata_stream_fd = saved_metadata_fd; rcu_read_unlock(); - return ret; + return status; } /* diff --git a/src/bin/lttng-sessiond/kernel.h b/src/bin/lttng-sessiond/kernel.h index e9024a83e..9b0c15cd1 100644 --- a/src/bin/lttng-sessiond/kernel.h +++ b/src/bin/lttng-sessiond/kernel.h @@ -59,7 +59,7 @@ int kernel_validate_version(int tracer_fd, struct lttng_kernel_tracer_abi_version *kernel_tracer_abi_version); void kernel_destroy_session(struct ltt_kernel_session *ksess); void kernel_destroy_channel(struct ltt_kernel_channel *kchan); -int kernel_snapshot_record(struct ltt_kernel_session *ksess, +enum lttng_error_code kernel_snapshot_record(struct ltt_kernel_session *ksess, struct snapshot_output *output, int wait, uint64_t nb_packets_per_stream); int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits); diff --git a/src/bin/lttng-sessiond/ust-app.c b/src/bin/lttng-sessiond/ust-app.c index 23f29c13c..7b44fb4b4 100644 --- a/src/bin/lttng-sessiond/ust-app.c +++ b/src/bin/lttng-sessiond/ust-app.c @@ -5952,13 +5952,14 @@ void ust_app_destroy(struct ust_app *app) * Take a snapshot for a given UST session. The snapshot is sent to the given * output. * - * Return 0 on success or else a negative value. + * Returns LTTNG_OK on success or a LTTNG_ERR error code. */ -int ust_app_snapshot_record(struct ltt_ust_session *usess, +enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess, struct snapshot_output *output, int wait, uint64_t nb_packets_per_stream) { int ret = 0; + enum lttng_error_code status = LTTNG_OK; struct lttng_ht_iter iter; struct ust_app *app; char pathname[PATH_MAX]; @@ -5994,7 +5995,7 @@ int ust_app_snapshot_record(struct ltt_ust_session *usess, socket = consumer_find_socket_by_bitness(reg->bits_per_long, usess->consumer); if (!socket) { - ret = -EINVAL; + status = LTTNG_ERR_INVALID; goto error; } @@ -6004,27 +6005,28 @@ int ust_app_snapshot_record(struct ltt_ust_session *usess, reg->uid, reg->bits_per_long); if (ret < 0) { PERROR("snprintf snapshot path"); + status = LTTNG_ERR_INVALID; goto error; } /* Add the UST default trace dir to path. */ cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter, reg_chan, node.node) { - ret = consumer_snapshot_channel(socket, + status = consumer_snapshot_channel(socket, reg_chan->consumer_key, output, 0, usess->uid, usess->gid, pathname, wait, nb_packets_per_stream, trace_archive_id); - if (ret < 0) { + if (status != LTTNG_OK) { goto error; } } - ret = consumer_snapshot_channel(socket, + status = consumer_snapshot_channel(socket, reg->registry->reg.ust->metadata_key, output, 1, usess->uid, usess->gid, pathname, wait, 0, trace_archive_id); - if (ret < 0) { + if (status != LTTNG_OK) { goto error; } } @@ -6049,7 +6051,7 @@ int ust_app_snapshot_record(struct ltt_ust_session *usess, socket = consumer_find_socket_by_bitness(app->bits_per_long, output->consumer); if (!socket) { - ret = -EINVAL; + status = LTTNG_ERR_INVALID; goto error; } @@ -6058,22 +6060,25 @@ int ust_app_snapshot_record(struct ltt_ust_session *usess, ret = snprintf(pathname, sizeof(pathname), DEFAULT_UST_TRACE_DIR "/%s", ua_sess->path); if (ret < 0) { + status = LTTNG_ERR_INVALID; PERROR("snprintf snapshot path"); goto error; } cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter, ua_chan, node.node) { - ret = consumer_snapshot_channel(socket, + status = consumer_snapshot_channel(socket, ua_chan->key, output, 0, ua_sess->euid, ua_sess->egid, pathname, wait, nb_packets_per_stream, trace_archive_id); - if (ret < 0) { - if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) { - continue; - } + switch (status) { + case LTTNG_OK: + break; + case LTTNG_ERR_CHAN_NOT_FOUND: + continue; + default: goto error; } } @@ -6083,15 +6088,17 @@ int ust_app_snapshot_record(struct ltt_ust_session *usess, DBG("Application session is being torn down. Skip application."); continue; } - ret = consumer_snapshot_channel(socket, + status = consumer_snapshot_channel(socket, registry->metadata_key, output, 1, ua_sess->euid, ua_sess->egid, pathname, wait, 0, trace_archive_id); - if (ret < 0) { - if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) { - continue; - } + switch (status) { + case LTTNG_OK: + break; + case LTTNG_ERR_CHAN_NOT_FOUND: + continue; + default: goto error; } } @@ -6104,7 +6111,7 @@ int ust_app_snapshot_record(struct ltt_ust_session *usess, error: rcu_read_unlock(); - return ret; + return status; } /* diff --git a/src/bin/lttng-sessiond/ust-app.h b/src/bin/lttng-sessiond/ust-app.h index 52a7cbfd3..913533561 100644 --- a/src/bin/lttng-sessiond/ust-app.h +++ b/src/bin/lttng-sessiond/ust-app.h @@ -345,7 +345,7 @@ void ust_app_notify_sock_unregister(int sock); ssize_t ust_app_push_metadata(struct ust_registry_session *registry, struct consumer_socket *socket, int send_zero_data); void ust_app_destroy(struct ust_app *app); -int ust_app_snapshot_record(struct ltt_ust_session *usess, +enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess, struct snapshot_output *output, int wait, uint64_t nb_packets_per_stream); uint64_t ust_app_get_size_one_more_packet_per_stream( @@ -539,7 +539,7 @@ void ust_app_destroy(struct ust_app *app) return; } static inline -int ust_app_snapshot_record(struct ltt_ust_session *usess, +enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess, struct snapshot_output *output, int wait, uint64_t max_stream_size) { return 0; -- 2.34.1