sessiond: clean-up: remove unused `state` function parameter

[lttng-tools.git] / src / bin / lttng-sessiond / notification-thread-events.c

diff --git a/src/bin/lttng-sessiond/notification-thread-events.c b/src/bin/lttng-sessiond/notification-thread-events.c
index bdbac0c4001f44f218ea0821eab5891972d35043..9cb3590167ed761f5dd04f71edd04103da7461b3 100644 (file)
--- a/src/bin/lttng-sessiond/notification-thread-events.c
+++ b/src/bin/lttng-sessiond/notification-thread-events.c
@@ -1,18 +1,8 @@
 /*
- * Copyright (C) 2017 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
  *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License, version 2 only, as
- * published by the Free Software Foundation.
+ * SPDX-License-Identifier: GPL-2.0-only
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc., 51
- * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
 #define _LGPL_SOURCE
@@ -928,7 +918,10 @@ int evaluate_condition_for_client(const struct lttng_trigger *trigger,
                ret = -1;
                goto end;
        }
-
+       if (ret) {
+               /* Fatal error. */
+               goto end;
+       }
        if (!evaluation) {
                /* Evaluation yielded nothing. Normal exit. */
                DBG("[notification-thread] Newly subscribed-to condition evaluated to false, nothing to report to client");
@@ -2571,8 +2564,7 @@ int client_flush_outgoing_queue(struct notification_client *client,
        ret = lttcomm_send_unix_sock_non_block(client->socket,
                        client->communication.outbound.buffer.data,
                        to_send_count);
-       if ((ret < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) ||
-                       (ret > 0 && ret < to_send_count)) {
+       if ((ret >= 0 && ret < to_send_count)) {
                DBG("[notification-thread] Client (socket fd = %i) outgoing queue could not be completely flushed",
                                client->socket);
                to_send_count -= max(ret, 0);
@@ -2808,14 +2800,14 @@ int client_dispatch_message(struct notification_client *client,
                struct lttng_condition *condition;
                enum lttng_notification_channel_status status =
                                LTTNG_NOTIFICATION_CHANNEL_STATUS_OK;
-               const struct lttng_buffer_view condition_view =
-                               lttng_buffer_view_from_dynamic_buffer(
+               struct lttng_payload_view condition_view =
+                               lttng_payload_view_from_dynamic_buffer(
                                        &client->communication.inbound.buffer,
                                        0, -1);
                size_t expected_condition_size =
                                client->communication.inbound.buffer.size;
 
-               ret = lttng_condition_create_from_buffer(&condition_view,
+               ret = lttng_condition_create_from_payload(&condition_view,
                                &condition);
                if (ret != expected_condition_size) {
                        ERR("[notification-thread] Malformed condition received from client");
@@ -2956,7 +2948,7 @@ bool evaluate_buffer_usage_condition(const struct lttng_condition *condition,
                 * forego this double-multiplication or it could be performed
                 * as fixed-point math.
                 *
-                * Note that caching should accomodate the case where the
+                * Note that caching should accommodates the case where the
                 * condition applies to multiple channels (i.e. don't assume
                 * that all channels matching my_chann* have the same size...)
                 */
@@ -3096,8 +3088,7 @@ end:
 }
 
 static
-int client_enqueue_dropped_notification(struct notification_client *client,
-               struct notification_thread_state *state)
+int client_enqueue_dropped_notification(struct notification_client *client)
 {
        int ret;
        struct lttng_notification_channel_message msg = {
@@ -3119,7 +3110,7 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
                uid_t channel_uid, gid_t channel_gid)
 {
        int ret = 0;
-       struct lttng_dynamic_buffer msg_buffer;
+       struct lttng_payload msg_payload;
        struct notification_client_list_element *client_list_element, *tmp;
        const struct lttng_notification notification = {
                .condition = (struct lttng_condition *) lttng_trigger_get_const_condition(trigger),
@@ -3129,15 +3120,15 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
                .type = (int8_t) LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_NOTIFICATION,
        };
 
-       lttng_dynamic_buffer_init(&msg_buffer);
+       lttng_payload_init(&msg_payload);
 
-       ret = lttng_dynamic_buffer_append(&msg_buffer, &msg_header,
+       ret = lttng_dynamic_buffer_append(&msg_payload.buffer, &msg_header,
                        sizeof(msg_header));
        if (ret) {
                goto end;
        }
 
-       ret = lttng_notification_serialize(&notification, &msg_buffer);
+       ret = lttng_notification_serialize(&notification, &msg_payload);
        if (ret) {
                ERR("[notification-thread] Failed to serialize notification");
                ret = -1;
@@ -3145,8 +3136,8 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
        }
 
        /* Update payload size. */
-       ((struct lttng_notification_channel_message * ) msg_buffer.data)->size =
-                       (uint32_t) (msg_buffer.size - sizeof(msg_header));
+       ((struct lttng_notification_channel_message * ) msg_payload.buffer.data)->size =
+                       (uint32_t) (msg_payload.buffer.size - sizeof(msg_header));
 
        cds_list_for_each_entry_safe(client_list_element, tmp,
                        &client_list->list, node) {
@@ -3161,7 +3152,7 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
                }
 
                DBG("[notification-thread] Sending notification to client (fd = %i, %zu bytes)",
-                               client->socket, msg_buffer.size);
+                               client->socket, msg_payload.buffer.size);
                if (client->communication.outbound.buffer.size) {
                        /*
                         * Outgoing data is already buffered for this client;
@@ -3175,7 +3166,7 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
                        if (!client->communication.outbound.dropped_notification) {
                                client->communication.outbound.dropped_notification = true;
                                ret = client_enqueue_dropped_notification(
-                                               client, state);
+                                               client);
                                if (ret) {
                                        goto end;
                                }
@@ -3185,7 +3176,7 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
 
                ret = lttng_dynamic_buffer_append_buffer(
                                &client->communication.outbound.buffer,
-                               &msg_buffer);
+                               &msg_payload.buffer);
                if (ret) {
                        goto end;
                }
@@ -3197,7 +3188,7 @@ int send_evaluation_to_clients(const struct lttng_trigger *trigger,
        }
        ret = 0;
 end:
-       lttng_dynamic_buffer_reset(&msg_buffer);
+       lttng_payload_reset(&msg_payload);
        return ret;
 }