* - Takes instrumentation source specific arguments.
*/
-#include <lttng/ust-abi.h>
-#include <lttng/ust-error.h>
+#define _LGPL_SOURCE
+#include <fcntl.h>
+#include <stdint.h>
+#include <unistd.h>
+
#include <urcu/compiler.h>
#include <urcu/list.h>
+
+#include <helper.h>
+#include <lttng/tracepoint.h>
+#include <lttng/ust-abi.h>
+#include <lttng/ust-error.h>
#include <lttng/ust-events.h>
#include <lttng/ust-version.h>
-#include <lttng/tracepoint.h>
-#include "tracepoint-internal.h"
+#include <ust-fd.h>
#include <usterr-signal-safe.h>
-#include <helper.h>
-#include "lttng-tracer.h"
-#include "../libringbuffer/shm.h"
+
#include "../libringbuffer/frontend_types.h"
+#include "../libringbuffer/shm.h"
+#include "lttng-tracer.h"
+#include "string-utils.h"
+#include "ust-events-internal.h"
#define OBJ_NAME_LEN 16
}
if ((--obj->u.s.f_count) == 1) {
const struct lttng_ust_objd_ops *ops = objd_ops(id);
-
+
if (ops->release)
ops->release(id);
objd_free(id);
*/
static const struct lttng_ust_objd_ops lttng_ops;
+static const struct lttng_ust_objd_ops lttng_event_notifier_group_ops;
static const struct lttng_ust_objd_ops lttng_session_ops;
static const struct lttng_ust_objd_ops lttng_channel_ops;
-static const struct lttng_ust_objd_ops lttng_enabler_ops;
+static const struct lttng_ust_objd_ops lttng_event_enabler_ops;
+static const struct lttng_ust_objd_ops lttng_event_notifier_enabler_ops;
static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops;
static const struct lttng_ust_objd_ops lttng_tracepoint_field_list_ops;
return 0;
}
+static
+int lttng_abi_event_notifier_send_fd(void *owner, int event_notifier_notif_fd)
+{
+ struct lttng_event_notifier_group *event_notifier_group;
+ int event_notifier_group_objd, ret, fd_flag, close_ret;
+
+ event_notifier_group = lttng_event_notifier_group_create();
+ if (!event_notifier_group)
+ return -ENOMEM;
+
+ /*
+ * Set this file descriptor as NON-BLOCKING.
+ */
+ fd_flag = fcntl(event_notifier_notif_fd, F_GETFL);
+
+ fd_flag |= O_NONBLOCK;
+
+ ret = fcntl(event_notifier_notif_fd, F_SETFL, fd_flag);
+ if (ret) {
+ ret = -errno;
+ goto fd_error;
+ }
+
+ event_notifier_group_objd = objd_alloc(event_notifier_group,
+ <tng_event_notifier_group_ops, owner, "event_notifier_group");
+ if (event_notifier_group_objd < 0) {
+ ret = event_notifier_group_objd;
+ goto objd_error;
+ }
+
+ event_notifier_group->objd = event_notifier_group_objd;
+ event_notifier_group->owner = owner;
+ event_notifier_group->notification_fd = event_notifier_notif_fd;
+
+ return event_notifier_group_objd;
+
+objd_error:
+ lttng_event_notifier_group_destroy(event_notifier_group);
+fd_error:
+ close_ret = close(event_notifier_notif_fd);
+ if (close_ret) {
+ PERROR("close");
+ }
+
+ return ret;
+}
+
static
long lttng_abi_add_context(int objd,
struct lttng_ust_context *context_param,
case LTTNG_UST_WAIT_QUIESCENT:
synchronize_trace();
return 0;
+ case LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE:
+ return lttng_abi_event_notifier_send_fd(owner,
+ uargs->event_notifier_handle.event_notifier_notif_fd);
default:
return -EINVAL;
}
/* error path after channel was created */
objd_error:
notransport:
- free(lttng_chan);
alloc_error:
channel_destroy(chan, channel_handle, 0);
return ret;
{
int close_ret;
+ lttng_ust_lock_fd_tracker();
close_ret = close(wakeup_fd);
+ lttng_ust_unlock_fd_tracker();
if (close_ret) {
PERROR("close");
}
case LTTNG_UST_SESSION_STOP:
case LTTNG_UST_DISABLE:
return lttng_session_disable(session);
+ case LTTNG_UST_SESSION_STATEDUMP:
+ return lttng_session_statedump(session);
default:
return -EINVAL;
}
.cmd = lttng_session_cmd,
};
+static int lttng_ust_event_notifier_enabler_create(int event_notifier_group_obj,
+ void *owner, struct lttng_ust_event_notifier *event_notifier_param,
+ enum lttng_enabler_format_type type)
+{
+ struct lttng_event_notifier_group *event_notifier_group =
+ objd_private(event_notifier_group_obj);
+ struct lttng_event_notifier_enabler *event_notifier_enabler;
+ int event_notifier_objd, ret;
+
+ event_notifier_param->event.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+ event_notifier_objd = objd_alloc(NULL, <tng_event_notifier_enabler_ops, owner,
+ "event_notifier enabler");
+ if (event_notifier_objd < 0) {
+ ret = event_notifier_objd;
+ goto objd_error;
+ }
+
+ event_notifier_enabler = lttng_event_notifier_enabler_create(
+ event_notifier_group, type, event_notifier_param);
+ if (!event_notifier_enabler) {
+ ret = -ENOMEM;
+ goto event_notifier_error;
+ }
+
+ objd_set_private(event_notifier_objd, event_notifier_enabler);
+ /* The event_notifier holds a reference on the event_notifier group. */
+ objd_ref(event_notifier_enabler->group->objd);
+
+ return event_notifier_objd;
+
+event_notifier_error:
+ {
+ int err;
+
+ err = lttng_ust_objd_unref(event_notifier_objd, 1);
+ assert(!err);
+ }
+objd_error:
+ return ret;
+}
+
+static
+long lttng_event_notifier_enabler_cmd(int objd, unsigned int cmd, unsigned long arg,
+ union ust_args *uargs, void *owner)
+{
+ struct lttng_event_notifier_enabler *event_notifier_enabler = objd_private(objd);
+ switch (cmd) {
+ case LTTNG_UST_FILTER:
+ return lttng_event_notifier_enabler_attach_filter_bytecode(
+ event_notifier_enabler,
+ (struct lttng_ust_filter_bytecode_node *) arg);
+ case LTTNG_UST_EXCLUSION:
+ return lttng_event_notifier_enabler_attach_exclusion(event_notifier_enabler,
+ (struct lttng_ust_excluder_node *) arg);
+ case LTTNG_UST_ENABLE:
+ return lttng_event_notifier_enabler_enable(event_notifier_enabler);
+ case LTTNG_UST_DISABLE:
+ return lttng_event_notifier_enabler_disable(event_notifier_enabler);
+ default:
+ return -EINVAL;
+ }
+}
+
+static
+long lttng_event_notifier_group_cmd(int objd, unsigned int cmd, unsigned long arg,
+ union ust_args *uargs, void *owner)
+{
+ switch (cmd) {
+ case LTTNG_UST_EVENT_NOTIFIER_CREATE:
+ {
+ struct lttng_ust_event_notifier *event_notifier_param =
+ (struct lttng_ust_event_notifier *) arg;
+ if (strutils_is_star_glob_pattern(event_notifier_param->event.name)) {
+ /*
+ * If the event name is a star globbing pattern,
+ * we create the special star globbing enabler.
+ */
+ return lttng_ust_event_notifier_enabler_create(objd,
+ owner, event_notifier_param,
+ LTTNG_ENABLER_FORMAT_STAR_GLOB);
+ } else {
+ return lttng_ust_event_notifier_enabler_create(objd,
+ owner, event_notifier_param,
+ LTTNG_ENABLER_FORMAT_EVENT);
+ }
+ }
+ default:
+ return -EINVAL;
+ }
+}
+
+static
+int lttng_event_notifier_enabler_release(int objd)
+{
+ struct lttng_event_notifier_enabler *event_notifier_enabler = objd_private(objd);
+
+ if (event_notifier_enabler)
+ return lttng_ust_objd_unref(event_notifier_enabler->group->objd, 0);
+ return 0;
+}
+
+static const struct lttng_ust_objd_ops lttng_event_notifier_enabler_ops = {
+ .release = lttng_event_notifier_enabler_release,
+ .cmd = lttng_event_notifier_enabler_cmd,
+};
+
+static
+int lttng_release_event_notifier_group(int objd)
+{
+ struct lttng_event_notifier_group *event_notifier_group = objd_private(objd);
+
+ if (event_notifier_group) {
+ lttng_event_notifier_group_destroy(event_notifier_group);
+ return 0;
+ } else {
+ return -EINVAL;
+ }
+}
+
+static const struct lttng_ust_objd_ops lttng_event_notifier_group_ops = {
+ .release = lttng_release_event_notifier_group,
+ .cmd = lttng_event_notifier_group_cmd,
+};
+
static
long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg,
union ust_args *uargs, void *owner)
}
static
-int lttng_abi_create_enabler(int channel_objd,
+int lttng_abi_create_event_enabler(int channel_objd,
struct lttng_ust_event *event_param,
void *owner,
- enum lttng_enabler_type type)
+ enum lttng_enabler_format_type format_type)
{
struct lttng_channel *channel = objd_private(channel_objd);
- struct lttng_enabler *enabler;
+ struct lttng_event_enabler *enabler;
int event_objd, ret;
event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
- event_objd = objd_alloc(NULL, <tng_enabler_ops, owner, "enabler");
+ event_objd = objd_alloc(NULL, <tng_event_enabler_ops, owner,
+ "event enabler");
if (event_objd < 0) {
ret = event_objd;
goto objd_error;
* We tolerate no failure path after event creation. It will stay
* invariant for the rest of the session.
*/
- enabler = lttng_enabler_create(type, event_param, channel);
+ enabler = lttng_event_enabler_create(format_type, event_param, channel);
if (!enabler) {
ret = -ENOMEM;
goto event_error;
{
struct lttng_ust_event *event_param =
(struct lttng_ust_event *) arg;
- if (event_param->name[strlen(event_param->name) - 1] == '*') {
- /* If ends with wildcard, create wildcard. */
- return lttng_abi_create_enabler(objd, event_param,
- owner, LTTNG_ENABLER_WILDCARD);
+
+ if (strutils_is_star_glob_pattern(event_param->name)) {
+ /*
+ * If the event name is a star globbing pattern,
+ * we create the special star globbing enabler.
+ */
+ return lttng_abi_create_event_enabler(objd, event_param,
+ owner, LTTNG_ENABLER_FORMAT_STAR_GLOB);
} else {
- return lttng_abi_create_enabler(objd, event_param,
- owner, LTTNG_ENABLER_EVENT);
+ return lttng_abi_create_event_enabler(objd, event_param,
+ owner, LTTNG_ENABLER_FORMAT_EVENT);
}
}
case LTTNG_UST_CONTEXT:
* Attach exclusions to an enabler.
*/
static
-long lttng_enabler_cmd(int objd, unsigned int cmd, unsigned long arg,
+long lttng_event_enabler_cmd(int objd, unsigned int cmd, unsigned long arg,
union ust_args *uargs, void *owner)
{
- struct lttng_enabler *enabler = objd_private(objd);
+ struct lttng_event_enabler *enabler = objd_private(objd);
switch (cmd) {
case LTTNG_UST_CONTEXT:
- return lttng_enabler_attach_context(enabler,
+ return lttng_event_enabler_attach_context(enabler,
(struct lttng_ust_context *) arg);
case LTTNG_UST_ENABLE:
- return lttng_enabler_enable(enabler);
+ return lttng_event_enabler_enable(enabler);
case LTTNG_UST_DISABLE:
- return lttng_enabler_disable(enabler);
+ return lttng_event_enabler_disable(enabler);
case LTTNG_UST_FILTER:
{
int ret;
- ret = lttng_enabler_attach_bytecode(enabler,
+ ret = lttng_event_enabler_attach_filter_bytecode(enabler,
(struct lttng_ust_filter_bytecode_node *) arg);
if (ret)
return ret;
}
case LTTNG_UST_EXCLUSION:
{
- return lttng_enabler_attach_exclusion(enabler,
+ return lttng_event_enabler_attach_exclusion(enabler,
(struct lttng_ust_excluder_node *) arg);
}
default:
}
static
-int lttng_enabler_release(int objd)
+int lttng_event_enabler_release(int objd)
{
- struct lttng_enabler *enabler = objd_private(objd);
+ struct lttng_event_enabler *event_enabler = objd_private(objd);
+
+ if (event_enabler)
+ return lttng_ust_objd_unref(event_enabler->chan->objd, 0);
- if (enabler)
- return lttng_ust_objd_unref(enabler->chan->objd, 0);
return 0;
}
-static const struct lttng_ust_objd_ops lttng_enabler_ops = {
- .release = lttng_enabler_release,
- .cmd = lttng_enabler_cmd,
+static const struct lttng_ust_objd_ops lttng_event_enabler_ops = {
+ .release = lttng_event_enabler_release,
+ .cmd = lttng_event_enabler_cmd,
};
void lttng_ust_abi_exit(void)
projects / lttng-ust.git / blobdiff