Fix: cmd_snapshot_record can return unexpected error codes
authorJérémie Galarneau <jeremie.galarneau@efficios.com>
Fri, 16 Nov 2018 21:46:36 +0000 (16:46 -0500)
committerJérémie Galarneau <jeremie.galarneau@efficios.com>
Fri, 16 Nov 2018 21:52:08 +0000 (16:52 -0500)
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 <jeremie.galarneau@efficios.com>
src/bin/lttng-sessiond/cmd.c
src/bin/lttng-sessiond/consumer.c
src/bin/lttng-sessiond/consumer.h
src/bin/lttng-sessiond/kernel.c
src/bin/lttng-sessiond/kernel.h
src/bin/lttng-sessiond/ust-app.c
src/bin/lttng-sessiond/ust-app.h

index 23a84615b0a93d108c28c97a8b8d2fb253ff8460..0f76ac71581935ab39c3c8fd57d1c29983aca2a2 100644 (file)
@@ -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;
 }
 
 /*
index a179eeffd1f72f5cde0d1fcb013e70ae2ac4b7e2..80e3137788ebc0c26da3302988a8ead922adf121 100644 (file)
@@ -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;
 }
 
 /*
index e9c7e31e31990eafde155956fb6a0f726cf95506..c98ebb34f8f6b98e55fccbfa15a915df6913c778 100644 (file)
@@ -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);
 
index 4327db24bdb3291f575da0d90c143e280c7bdbfa..edb7f7b2f2f3f83efd53ac077f005b26388d52d9 100644 (file)
@@ -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;
 }
 
 /*
index e9024a83e975290b53b9f624d8e8cc8060984f0d..9b0c15cd14fd866fe71654b9ee41134b9d144de3 100644 (file)
@@ -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);
index 23f29c13ca414a0a02903952879701b73dda397b..7b44fb4b48a050927fe2c897650dd2fda156dfac 100644 (file)
@@ -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;
 }
 
 /*
index 52a7cbfd35dbc060c5e3663bbd418fbb3b87854e..913533561d7a04d0617dc9796583343b6c8fc068 100644 (file)
@@ -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;
This page took 0.062413 seconds and 4 git commands to generate.