actions: introduce stop session action
authorSimon Marchi <simon.marchi@efficios.com>
Mon, 2 Dec 2019 19:53:11 +0000 (14:53 -0500)
committerJérémie Galarneau <jeremie.galarneau@efficios.com>
Tue, 9 Jun 2020 18:09:55 +0000 (14:09 -0400)
This patch introduces the API for the "stop session" action.

A stop session action is created using the
lttng_action_stop_session_create function.  It is mandatory to set a
session name using lttng_action_stop_session_set_session_name before
using the action in a trigger.

The patch adds the code for serializing the action and deserializing it
on the sessiond side, but not the code for executing it.

Change-Id: Ie00d744340f85f15a333680cf86d3882bd612d1a
Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
include/Makefile.am
include/lttng/action/action.h
include/lttng/action/stop-session-internal.h [new file with mode: 0644]
include/lttng/action/stop-session.h [new file with mode: 0644]
include/lttng/lttng.h
src/common/Makefile.am
src/common/actions/action.c
src/common/actions/stop-session.c [new file with mode: 0644]

index dace86e032831cb797e0f6ee683959a480762719..b31df9da157cc521c149c4d30fa49266b56d4b37 100644 (file)
@@ -122,7 +122,8 @@ lttnginclude_HEADERS = \
 lttngactioninclude_HEADERS= \
        lttng/action/action.h \
        lttng/action/notify.h \
-       lttng/action/start-session.h
+       lttng/action/start-session.h \
+       lttng/action/stop-session.h
 
 lttngconditioninclude_HEADERS= \
        lttng/condition/condition.h \
@@ -146,6 +147,7 @@ noinst_HEADERS = \
        lttng/action/action-internal.h \
        lttng/action/notify-internal.h \
        lttng/action/start-session-internal.h \
+       lttng/action/stop-session-internal.h \
        lttng/condition/condition-internal.h \
        lttng/condition/buffer-usage-internal.h \
        lttng/condition/session-consumed-size-internal.h \
index aa3d11589d07f0d2b50296e09803512ef0e17226..cc26ed9141e33d142b2488c67052061e45b76047 100644 (file)
@@ -18,6 +18,7 @@ enum lttng_action_type {
        LTTNG_ACTION_TYPE_UNKNOWN = -1,
        LTTNG_ACTION_TYPE_NOTIFY = 0,
        LTTNG_ACTION_TYPE_START_SESSION = 1,
+       LTTNG_ACTION_TYPE_STOP_SESSION = 2,
 };
 
 enum lttng_action_status {
diff --git a/include/lttng/action/stop-session-internal.h b/include/lttng/action/stop-session-internal.h
new file mode 100644 (file)
index 0000000..150002e
--- /dev/null
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 Simon Marchi <simon.marchi@efficios.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ */
+
+#ifndef LTTNG_ACTION_STOP_SESSION_INTERNAL_H
+#define LTTNG_ACTION_STOP_SESSION_INTERNAL_H
+
+#include <sys/types.h>
+
+#include <common/macros.h>
+
+struct lttng_action;
+struct lttng_buffer_view;
+
+/*
+ * Create a "stop session" action from a buffer view.
+ *
+ * On success, return the number of bytes consumed from `view`, and the created
+ * action in `*action`. On failure, return -1.
+ */
+LTTNG_HIDDEN
+extern ssize_t lttng_action_stop_session_create_from_buffer(
+               const struct lttng_buffer_view *view,
+               struct lttng_action **action);
+
+#endif /* LTTNG_ACTION_STOP_SESSION_INTERNAL_H */
diff --git a/include/lttng/action/stop-session.h b/include/lttng/action/stop-session.h
new file mode 100644 (file)
index 0000000..5c16731
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2019 Simon Marchi <simon.marchi@efficios.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ */
+
+#ifndef LTTNG_ACTION_STOP_SESSION_H
+#define LTTNG_ACTION_STOP_SESSION_H
+
+struct lttng_action;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Create a newly allocated stop-session action object.
+ *
+ * A stop session action object must have a session name set to be considered
+ * valid when used with a trigger object (lttng_trigger). A name can be set
+ * using `lttng_action_stop_session_set_session_name`.
+ *
+ * Returns a new action on success, NULL on failure. This action must be
+ * destroyed using lttng_action_destroy().
+ */
+extern struct lttng_action *lttng_action_stop_session_create(void);
+
+/*
+ * Set the session name of an lttng_action object of type
+ * LTTNG_ACTION_TYPE_STOP_SESSION.
+ */
+extern enum lttng_action_status lttng_action_stop_session_set_session_name(
+               struct lttng_action *action, const char *session_name);
+
+/*
+ * Get the session name of an lttng_action object of type
+ * LTTNG_ACTION_TYPE_STOP_SESSION.
+ */
+extern enum lttng_action_status lttng_action_stop_session_get_session_name(
+               const struct lttng_action *action, const char **session_name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LTTNG_ACTION_STOP_SESSION_H */
index 6b4ca565770b97b83409b70692ca76e00414dc40..24638a351cb1248e626d1c20436bd90baaa2b1ed 100644 (file)
@@ -19,6 +19,7 @@
 #include <lttng/action/action.h>
 #include <lttng/action/notify.h>
 #include <lttng/action/start-session.h>
+#include <lttng/action/stop-session.h>
 #include <lttng/channel.h>
 #include <lttng/clear-handle.h>
 #include <lttng/clear.h>
index 10e2d40f3676bd208713647338b8e99934eae9c4..5303f26431f3c9e1db9791d314cafc7ffeafbb10 100644 (file)
@@ -30,6 +30,7 @@ libcommon_la_SOURCES = \
        actions/action.c \
        actions/notify.c \
        actions/start-session.c \
+       actions/stop-session.c \
        buffer-usage.c \
        buffer-view.h buffer-view.c \
        common.h \
index bd11301cc8ba1ae0f1062b120247f7aa043958bd..208858e2671c6d94210b9dd81cccbae57a1dd56a 100644 (file)
@@ -10,6 +10,7 @@
 #include <lttng/action/action-internal.h>
 #include <lttng/action/notify-internal.h>
 #include <lttng/action/start-session-internal.h>
+#include <lttng/action/stop-session-internal.h>
 
 static const char *lttng_action_type_string(enum lttng_action_type action_type)
 {
@@ -20,6 +21,8 @@ static const char *lttng_action_type_string(enum lttng_action_type action_type)
                return "NOTIFY";
        case LTTNG_ACTION_TYPE_START_SESSION:
                return "START_SESSION";
+       case LTTNG_ACTION_TYPE_STOP_SESSION:
+               return "STOP_SESSION";
        default:
                return "???";
        }
@@ -134,6 +137,10 @@ ssize_t lttng_action_create_from_buffer(const struct lttng_buffer_view *view,
                create_from_buffer_cb =
                                lttng_action_start_session_create_from_buffer;
                break;
+       case LTTNG_ACTION_TYPE_STOP_SESSION:
+               create_from_buffer_cb =
+                               lttng_action_stop_session_create_from_buffer;
+               break;
        default:
                ERR("Failed to create action from buffer, unhandled action type: action-type=%u (%s)",
                                action_comm->action_type,
diff --git a/src/common/actions/stop-session.c b/src/common/actions/stop-session.c
new file mode 100644 (file)
index 0000000..a36e873
--- /dev/null
@@ -0,0 +1,261 @@
+/*
+ * Copyright (C) 2019 Simon Marchi <simon.marchi@efficios.com>
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ */
+
+#include <assert.h>
+#include <common/error.h>
+#include <common/macros.h>
+#include <lttng/action/action-internal.h>
+#include <lttng/action/stop-session-internal.h>
+#include <lttng/action/stop-session.h>
+
+#define IS_STOP_SESSION_ACTION(action) \
+       (lttng_action_get_type_const(action) == LTTNG_ACTION_TYPE_STOP_SESSION)
+
+struct lttng_action_stop_session {
+       struct lttng_action parent;
+
+       /* Owned by this. */
+       char *session_name;
+};
+
+struct lttng_action_stop_session_comm {
+       /* Includes the trailing \0. */
+       uint32_t session_name_len;
+
+       /*
+        * Variable data:
+        *
+        *  - session name (null terminated)
+        */
+       char data[];
+} LTTNG_PACKED;
+
+static struct lttng_action_stop_session *action_stop_session_from_action(
+               struct lttng_action *action)
+{
+       assert(action);
+
+       return container_of(action, struct lttng_action_stop_session, parent);
+}
+
+static const struct lttng_action_stop_session *
+action_stop_session_from_action_const(const struct lttng_action *action)
+{
+       assert(action);
+
+       return container_of(action, struct lttng_action_stop_session, parent);
+}
+
+static bool lttng_action_stop_session_validate(struct lttng_action *action)
+{
+       bool valid;
+       struct lttng_action_stop_session *action_stop_session;
+
+       if (!action) {
+               valid = false;
+               goto end;
+       }
+
+       action_stop_session = action_stop_session_from_action(action);
+
+       /* A non-empty session name is mandatory. */
+       if (!action_stop_session->session_name ||
+                       strlen(action_stop_session->session_name) == 0) {
+               valid = false;
+               goto end;
+       }
+
+       valid = true;
+end:
+       return valid;
+}
+
+static bool lttng_action_stop_session_is_equal(
+               const struct lttng_action *_a, const struct lttng_action *_b)
+{
+       bool is_equal = false;
+       const struct lttng_action_stop_session *a, *b;
+
+       a = action_stop_session_from_action_const(_a);
+       b = action_stop_session_from_action_const(_b);
+
+       /* Action is not valid if this is not true. */
+       assert(a->session_name);
+       assert(b->session_name);
+       if (strcmp(a->session_name, b->session_name)) {
+               goto end;
+       }
+
+       is_equal = true;
+end:
+       return is_equal;
+}
+
+static int lttng_action_stop_session_serialize(
+               struct lttng_action *action, struct lttng_dynamic_buffer *buf)
+{
+       struct lttng_action_stop_session *action_stop_session;
+       struct lttng_action_stop_session_comm comm;
+       size_t session_name_len;
+       int ret;
+
+       assert(action);
+       assert(buf);
+
+       action_stop_session = action_stop_session_from_action(action);
+
+       assert(action_stop_session->session_name);
+
+       DBG("Serializing stop session action: session-name: %s",
+                       action_stop_session->session_name);
+
+       session_name_len = strlen(action_stop_session->session_name) + 1;
+       comm.session_name_len = session_name_len;
+
+       ret = lttng_dynamic_buffer_append(buf, &comm, sizeof(comm));
+       if (ret) {
+               ret = -1;
+               goto end;
+       }
+
+       ret = lttng_dynamic_buffer_append(buf,
+                       action_stop_session->session_name, session_name_len);
+       if (ret) {
+               ret = -1;
+               goto end;
+       }
+
+       ret = 0;
+end:
+       return ret;
+}
+
+static void lttng_action_stop_session_destroy(struct lttng_action *action)
+{
+       struct lttng_action_stop_session *action_stop_session;
+
+       if (!action) {
+               goto end;
+       }
+
+       action_stop_session = action_stop_session_from_action(action);
+
+       free(action_stop_session->session_name);
+       free(action_stop_session);
+
+end:
+       return;
+}
+
+ssize_t lttng_action_stop_session_create_from_buffer(
+               const struct lttng_buffer_view *view,
+               struct lttng_action **p_action)
+{
+       ssize_t consumed_len;
+       const struct lttng_action_stop_session_comm *comm;
+       const char *session_name;
+       struct lttng_action *action;
+       enum lttng_action_status status;
+
+       action = lttng_action_stop_session_create();
+       if (!action) {
+               consumed_len = -1;
+               goto end;
+       }
+
+       comm = (const struct lttng_action_stop_session_comm *) view->data;
+       session_name = (const char *) &comm->data;
+
+       if (!lttng_buffer_view_contains_string(
+                       view, session_name, comm->session_name_len)) {
+               consumed_len = -1;
+               goto end;
+       }
+
+       status = lttng_action_stop_session_set_session_name(
+                       action, session_name);
+       if (status != LTTNG_ACTION_STATUS_OK) {
+               consumed_len = -1;
+               goto end;
+       }
+
+       consumed_len = sizeof(struct lttng_action_stop_session_comm) +
+                       comm->session_name_len;
+       *p_action = action;
+       action = NULL;
+
+end:
+       lttng_action_stop_session_destroy(action);
+
+       return consumed_len;
+}
+
+struct lttng_action *lttng_action_stop_session_create(void)
+{
+       struct lttng_action *action;
+
+       action = zmalloc(sizeof(struct lttng_action_stop_session));
+       if (!action) {
+               goto end;
+       }
+
+       lttng_action_init(action, LTTNG_ACTION_TYPE_STOP_SESSION,
+                       lttng_action_stop_session_validate,
+                       lttng_action_stop_session_serialize,
+                       lttng_action_stop_session_is_equal,
+                       lttng_action_stop_session_destroy);
+
+end:
+       return action;
+}
+
+enum lttng_action_status lttng_action_stop_session_set_session_name(
+               struct lttng_action *action, const char *session_name)
+{
+       struct lttng_action_stop_session *action_stop_session;
+       enum lttng_action_status status;
+
+       if (!action || !IS_STOP_SESSION_ACTION(action) || !session_name ||
+                       strlen(session_name) == 0) {
+               status = LTTNG_ACTION_STATUS_INVALID;
+               goto end;
+       }
+
+       action_stop_session = action_stop_session_from_action(action);
+
+       free(action_stop_session->session_name);
+
+       action_stop_session->session_name = strdup(session_name);
+       if (!action_stop_session->session_name) {
+               status = LTTNG_ACTION_STATUS_ERROR;
+               goto end;
+       }
+
+       status = LTTNG_ACTION_STATUS_OK;
+end:
+       return status;
+}
+
+enum lttng_action_status lttng_action_stop_session_get_session_name(
+               const struct lttng_action *action, const char **session_name)
+{
+       const struct lttng_action_stop_session *action_stop_session;
+       enum lttng_action_status status;
+
+       if (!action || !IS_STOP_SESSION_ACTION(action) || !session_name) {
+               status = LTTNG_ACTION_STATUS_INVALID;
+               goto end;
+       }
+
+       action_stop_session = action_stop_session_from_action_const(action);
+
+       *session_name = action_stop_session->session_name;
+
+       status = LTTNG_ACTION_STATUS_OK;
+end:
+       return status;
+}
This page took 0.043697 seconds and 4 git commands to generate.