/*
- * lttng-ust-comm.c
+ * SPDX-License-Identifier: LGPL-2.1-only
*
* Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define _LGPL_SOURCE
-#define _GNU_SOURCE
#include <stddef.h>
#include <stdint.h>
#include <sys/types.h>
#include <signal.h>
#include <limits.h>
#include <urcu/uatomic.h>
-#include <urcu/futex.h>
+#include "futex.h"
#include <urcu/compiler.h>
+#include <lttng/urcu/urcu-ust.h>
#include <lttng/ust-events.h>
#include <lttng/ust-abi.h>
#include <ust-comm.h>
#include <ust-fd.h>
#include <usterr-signal-safe.h>
-#include <helper.h>
+#include <ust-helper.h>
#include "tracepoint-internal.h"
#include "lttng-tracer-core.h"
#include "compat.h"
#include "clock.h"
#include "../libringbuffer/getcpu.h"
#include "getenv.h"
+#include "ust-events-internal.h"
+#include "context-internal.h"
+#include "ust-compat.h"
/* Concatenate lttng ust shared library name with its major version number. */
#define LTTNG_UST_LIB_SO_NAME "liblttng-ust.so." __ust_stringify(CONFIG_LTTNG_UST_LIBRARY_VERSION_MAJOR)
int statedump_pending;
int initial_statedump_done;
/* Keep procname for statedump */
- char procname[LTTNG_UST_PROCNAME_LEN];
+ char procname[LTTNG_UST_ABI_PROCNAME_LEN];
};
/* Socket from app (connect) to session daemon (listen) for communication */
[ LTTNG_UST_REGISTER_DONE ] = "Registration Done",
[ LTTNG_UST_TRACEPOINT_FIELD_LIST ] = "Create Tracepoint Field List",
+ [ LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE ] = "Create event notifier group",
+
/* Session FD commands */
[ LTTNG_UST_CHANNEL ] = "Create Channel",
[ LTTNG_UST_SESSION_START ] = "Start Session",
/* Event FD commands */
[ LTTNG_UST_FILTER ] = "Create Filter",
[ LTTNG_UST_EXCLUSION ] = "Add exclusions to event",
+
+ /* Event notifier group commands */
+ [ LTTNG_UST_EVENT_NOTIFIER_CREATE ] = "Create event notifier",
+
+ /* Session and event notifier group commands */
+ [ LTTNG_UST_COUNTER ] = "Create Counter",
+
+ /* Counter commands */
+ [ LTTNG_UST_COUNTER_GLOBAL ] = "Create Counter Global",
+ [ LTTNG_UST_COUNTER_CPU ] = "Create Counter CPU",
};
static const char *str_timeout;
extern void lttng_ring_buffer_client_discard_exit(void);
extern void lttng_ring_buffer_client_discard_rt_exit(void);
extern void lttng_ring_buffer_metadata_client_exit(void);
+LTTNG_HIDDEN
+extern void lttng_counter_client_percpu_32_modular_init(void);
+LTTNG_HIDDEN
+extern void lttng_counter_client_percpu_32_modular_exit(void);
+LTTNG_HIDDEN
+extern void lttng_counter_client_percpu_64_modular_init(void);
+LTTNG_HIDDEN
+extern void lttng_counter_client_percpu_64_modular_exit(void);
static char *get_map_shm(struct sock_info *sock_info);
{
const char *val;
- val = (const char *) lttng_getenv("LTTNG_HOME");
+ val = (const char *) lttng_ust_getenv("LTTNG_HOME");
if (val != NULL) {
return val;
}
- return (const char *) lttng_getenv("HOME");
+ return (const char *) lttng_ust_getenv("HOME");
}
/*
}
/*
- * Fixup urcu bp TLS.
+ * Fixup lttng-ust urcu TLS.
*/
static
-void lttng_fixup_urcu_bp_tls(void)
+void lttng_fixup_lttng_ust_urcu_tls(void)
{
- rcu_read_lock();
- rcu_read_unlock();
+ (void) lttng_ust_urcu_read_ongoing();
}
void lttng_ust_fixup_tls(void)
{
- lttng_fixup_urcu_bp_tls();
+ lttng_fixup_lttng_ust_urcu_tls();
lttng_fixup_ringbuffer_tls();
lttng_fixup_vtid_tls();
lttng_fixup_nest_count_tls();
}
global_apps.allowed = 1;
- lttng_ust_getprocname(global_apps.procname);
+ lttng_pthread_getname_np(global_apps.procname, LTTNG_UST_ABI_PROCNAME_LEN);
error:
return ret;
}
goto end;
}
- lttng_ust_getprocname(local_apps.procname);
+ lttng_pthread_getname_np(local_apps.procname, LTTNG_UST_ABI_PROCNAME_LEN);
end:
return ret;
}
long constructor_delay_ms = LTTNG_UST_DEFAULT_CONSTRUCTOR_TIMEOUT_MS;
if (!got_timeout_env) {
- str_timeout = lttng_getenv("LTTNG_UST_REGISTER_TIMEOUT");
+ str_timeout = lttng_ust_getenv("LTTNG_UST_REGISTER_TIMEOUT");
got_timeout_env = 1;
}
if (str_timeout)
void get_allow_blocking(void)
{
const char *str_allow_blocking =
- lttng_getenv("LTTNG_UST_ALLOW_BLOCKING");
+ lttng_ust_getenv("LTTNG_UST_ALLOW_BLOCKING");
if (str_allow_blocking) {
DBG("%s environment variable is set",
}
}
+static inline
+const char *bytecode_type_str(uint32_t cmd)
+{
+ switch (cmd) {
+ case LTTNG_UST_CAPTURE:
+ return "capture";
+ case LTTNG_UST_FILTER:
+ return "filter";
+ default:
+ abort();
+ }
+}
+
+static
+int handle_bytecode_recv(struct sock_info *sock_info,
+ int sock, struct ustcomm_ust_msg *lum)
+{
+ struct lttng_ust_bytecode_node *bytecode = NULL;
+ enum lttng_ust_bytecode_node_type type;
+ const struct lttng_ust_objd_ops *ops;
+ uint32_t data_size, data_size_max, reloc_offset;
+ uint64_t seqnum;
+ ssize_t len;
+ int ret = 0;
+
+ switch (lum->cmd) {
+ case LTTNG_UST_FILTER:
+ type = LTTNG_UST_BYTECODE_NODE_TYPE_FILTER;
+ data_size = lum->u.filter.data_size;
+ data_size_max = FILTER_BYTECODE_MAX_LEN;
+ reloc_offset = lum->u.filter.reloc_offset;
+ seqnum = lum->u.filter.seqnum;
+ break;
+ case LTTNG_UST_CAPTURE:
+ type = LTTNG_UST_BYTECODE_NODE_TYPE_CAPTURE;
+ data_size = lum->u.capture.data_size;
+ data_size_max = CAPTURE_BYTECODE_MAX_LEN;
+ reloc_offset = lum->u.capture.reloc_offset;
+ seqnum = lum->u.capture.seqnum;
+ break;
+ default:
+ abort();
+ }
+
+ if (data_size > data_size_max) {
+ ERR("Bytecode %s data size is too large: %u bytes",
+ bytecode_type_str(lum->cmd), data_size);
+ ret = -EINVAL;
+ goto end;
+ }
+
+ if (reloc_offset > data_size) {
+ ERR("Bytecode %s reloc offset %u is not within data",
+ bytecode_type_str(lum->cmd), reloc_offset);
+ ret = -EINVAL;
+ goto end;
+ }
+
+ /* Allocate the structure AND the `data[]` field. */
+ bytecode = zmalloc(sizeof(*bytecode) + data_size);
+ if (!bytecode) {
+ ret = -ENOMEM;
+ goto end;
+ }
+
+ bytecode->bc.len = data_size;
+ bytecode->bc.reloc_offset = reloc_offset;
+ bytecode->bc.seqnum = seqnum;
+ bytecode->type = type;
+
+ len = ustcomm_recv_unix_sock(sock, bytecode->bc.data, bytecode->bc.len);
+ switch (len) {
+ case 0: /* orderly shutdown */
+ ret = 0;
+ goto end;
+ default:
+ if (len == bytecode->bc.len) {
+ DBG("Bytecode %s data received",
+ bytecode_type_str(lum->cmd));
+ break;
+ } else if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d",
+ (int) -len);
+ if (len == -ECONNRESET) {
+ ERR("%s remote end closed connection",
+ sock_info->name);
+ ret = len;
+ goto end;
+ }
+ ret = len;
+ goto end;
+ } else {
+ DBG("Incorrect %s bytecode data message size: %zd",
+ bytecode_type_str(lum->cmd), len);
+ ret = -EINVAL;
+ goto end;
+ }
+ }
+
+ ops = objd_ops(lum->handle);
+ if (!ops) {
+ ret = -ENOENT;
+ goto end;
+ }
+
+ if (ops->cmd)
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) &bytecode,
+ NULL, sock_info);
+ else
+ ret = -ENOSYS;
+
+end:
+ free(bytecode);
+ return ret;
+}
+
static
int handle_message(struct sock_info *sock_info,
int sock, struct ustcomm_ust_msg *lum)
else
ret = lttng_ust_objd_unref(lum->handle, 1);
break;
+ case LTTNG_UST_CAPTURE:
case LTTNG_UST_FILTER:
- {
- /* Receive filter data */
- struct lttng_ust_filter_bytecode_node *bytecode;
-
- if (lum->u.filter.data_size > FILTER_BYTECODE_MAX_LEN) {
- ERR("Filter data size is too large: %u bytes",
- lum->u.filter.data_size);
- ret = -EINVAL;
- goto error;
- }
-
- if (lum->u.filter.reloc_offset > lum->u.filter.data_size) {
- ERR("Filter reloc offset %u is not within data",
- lum->u.filter.reloc_offset);
- ret = -EINVAL;
+ ret = handle_bytecode_recv(sock_info, sock, lum);
+ if (ret)
goto error;
- }
-
- bytecode = zmalloc(sizeof(*bytecode) + lum->u.filter.data_size);
- if (!bytecode) {
- ret = -ENOMEM;
- goto error;
- }
- len = ustcomm_recv_unix_sock(sock, bytecode->bc.data,
- lum->u.filter.data_size);
- switch (len) {
- case 0: /* orderly shutdown */
- ret = 0;
- free(bytecode);
- goto error;
- default:
- if (len == lum->u.filter.data_size) {
- DBG("filter data received");
- break;
- } else if (len < 0) {
- DBG("Receive failed from lttng-sessiond with errno %d", (int) -len);
- if (len == -ECONNRESET) {
- ERR("%s remote end closed connection", sock_info->name);
- ret = len;
- free(bytecode);
- goto error;
- }
- ret = len;
- free(bytecode);
- goto error;
- } else {
- DBG("incorrect filter data message size: %zd", len);
- ret = -EINVAL;
- free(bytecode);
- goto error;
- }
- }
- bytecode->bc.len = lum->u.filter.data_size;
- bytecode->bc.reloc_offset = lum->u.filter.reloc_offset;
- bytecode->bc.seqnum = lum->u.filter.seqnum;
- if (ops->cmd) {
- ret = ops->cmd(lum->handle, lum->cmd,
- (unsigned long) bytecode,
- &args, sock_info);
- if (ret) {
- free(bytecode);
- }
- /* don't free bytecode if everything went fine. */
- } else {
- ret = -ENOSYS;
- free(bytecode);
- }
break;
- }
case LTTNG_UST_EXCLUSION:
{
/* Receive exclusion names */
goto error;
}
}
- if (ops->cmd) {
+ if (ops->cmd)
ret = ops->cmd(lum->handle, lum->cmd,
- (unsigned long) node,
+ (unsigned long) &node,
&args, sock_info);
- if (ret) {
- free(node);
+ else
+ ret = -ENOSYS;
+ free(node);
+ break;
+ }
+ case LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE:
+ {
+ int event_notifier_notif_fd, close_ret;
+
+ len = ustcomm_recv_event_notifier_notif_fd_from_sessiond(sock,
+ &event_notifier_notif_fd);
+ switch (len) {
+ case 0: /* orderly shutdown */
+ ret = 0;
+ goto error;
+ case 1:
+ break;
+ default:
+ if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d",
+ (int) -len);
+ if (len == -ECONNRESET) {
+ ERR("%s remote end closed connection",
+ sock_info->name);
+ ret = len;
+ goto error;
+ }
+ ret = len;
+ goto error;
+ } else {
+ DBG("Incorrect event notifier fd message size: %zd",
+ len);
+ ret = -EINVAL;
+ goto error;
}
- /* Don't free exclusion data if everything went fine. */
- } else {
+ }
+ args.event_notifier_handle.event_notifier_notif_fd =
+ event_notifier_notif_fd;
+ if (ops->cmd)
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) &lum->u,
+ &args, sock_info);
+ else
ret = -ENOSYS;
- free(node);
+ if (args.event_notifier_handle.event_notifier_notif_fd >= 0) {
+ lttng_ust_lock_fd_tracker();
+ close_ret = close(args.event_notifier_handle.event_notifier_notif_fd);
+ lttng_ust_unlock_fd_tracker();
+ if (close_ret)
+ PERROR("close");
}
break;
}
&args, sock_info);
else
ret = -ENOSYS;
+ if (args.channel.wakeup_fd >= 0) {
+ int close_ret;
+
+ lttng_ust_lock_fd_tracker();
+ close_ret = close(args.channel.wakeup_fd);
+ lttng_ust_unlock_fd_tracker();
+ args.channel.wakeup_fd = -1;
+ if (close_ret)
+ PERROR("close");
+ }
+ free(args.channel.chan_data);
break;
}
case LTTNG_UST_STREAM:
{
+ int close_ret;
+
/* Receive shm_fd, wakeup_fd */
ret = ustcomm_recv_stream_from_sessiond(sock,
NULL,
&args, sock_info);
else
ret = -ENOSYS;
+ if (args.stream.shm_fd >= 0) {
+ lttng_ust_lock_fd_tracker();
+ close_ret = close(args.stream.shm_fd);
+ lttng_ust_unlock_fd_tracker();
+ args.stream.shm_fd = -1;
+ if (close_ret)
+ PERROR("close");
+ }
+ if (args.stream.wakeup_fd >= 0) {
+ lttng_ust_lock_fd_tracker();
+ close_ret = close(args.stream.wakeup_fd);
+ lttng_ust_unlock_fd_tracker();
+ args.stream.wakeup_fd = -1;
+ if (close_ret)
+ PERROR("close");
+ }
break;
}
case LTTNG_UST_CONTEXT:
ret = -ENOSYS;
}
break;
+ case LTTNG_UST_COUNTER:
+ {
+ void *counter_data;
+
+ len = ustcomm_recv_counter_from_sessiond(sock,
+ &counter_data, lum->u.counter.len);
+ switch (len) {
+ case 0: /* orderly shutdown */
+ ret = 0;
+ goto error;
+ default:
+ if (len == lum->u.counter.len) {
+ DBG("counter data received");
+ break;
+ } else if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d", (int) -len);
+ if (len == -ECONNRESET) {
+ ERR("%s remote end closed connection", sock_info->name);
+ ret = len;
+ goto error;
+ }
+ ret = len;
+ goto error;
+ } else {
+ DBG("incorrect counter data message size: %zd", len);
+ ret = -EINVAL;
+ goto error;
+ }
+ }
+ args.counter.counter_data = counter_data;
+ if (ops->cmd)
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) &lum->u,
+ &args, sock_info);
+ else
+ ret = -ENOSYS;
+ free(args.counter.counter_data);
+ break;
+ }
+ case LTTNG_UST_COUNTER_GLOBAL:
+ {
+ /* Receive shm_fd */
+ ret = ustcomm_recv_counter_shm_from_sessiond(sock,
+ &args.counter_shm.shm_fd);
+ if (ret) {
+ goto error;
+ }
+
+ if (ops->cmd)
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) &lum->u,
+ &args, sock_info);
+ else
+ ret = -ENOSYS;
+ if (args.counter_shm.shm_fd >= 0) {
+ int close_ret;
+
+ lttng_ust_lock_fd_tracker();
+ close_ret = close(args.counter_shm.shm_fd);
+ lttng_ust_unlock_fd_tracker();
+ args.counter_shm.shm_fd = -1;
+ if (close_ret)
+ PERROR("close");
+ }
+ break;
+ }
+ case LTTNG_UST_COUNTER_CPU:
+ {
+ /* Receive shm_fd */
+ ret = ustcomm_recv_counter_shm_from_sessiond(sock,
+ &args.counter_shm.shm_fd);
+ if (ret) {
+ goto error;
+ }
+
+ if (ops->cmd)
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) &lum->u,
+ &args, sock_info);
+ else
+ ret = -ENOSYS;
+ if (args.counter_shm.shm_fd >= 0) {
+ int close_ret;
+
+ lttng_ust_lock_fd_tracker();
+ close_ret = close(args.counter_shm.shm_fd);
+ lttng_ust_unlock_fd_tracker();
+ args.counter_shm.shm_fd = -1;
+ if (close_ret)
+ PERROR("close");
+ }
+ break;
+ }
+ case LTTNG_UST_EVENT_NOTIFIER_CREATE:
+ {
+ /* Receive struct lttng_ust_event_notifier */
+ struct lttng_ust_event_notifier event_notifier;
+
+ if (sizeof(event_notifier) != lum->u.event_notifier.len) {
+ DBG("incorrect event notifier data message size: %u", lum->u.event_notifier.len);
+ ret = -EINVAL;
+ goto error;
+ }
+ len = ustcomm_recv_unix_sock(sock, &event_notifier, sizeof(event_notifier));
+ switch (len) {
+ case 0: /* orderly shutdown */
+ ret = 0;
+ goto error;
+ default:
+ if (len == sizeof(event_notifier)) {
+ DBG("event notifier data received");
+ break;
+ } else if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d", (int) -len);
+ if (len == -ECONNRESET) {
+ ERR("%s remote end closed connection", sock_info->name);
+ ret = len;
+ goto error;
+ }
+ ret = len;
+ goto error;
+ } else {
+ DBG("incorrect event notifier data message size: %zd", len);
+ ret = -EINVAL;
+ goto error;
+ }
+ }
+ if (ops->cmd)
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) &event_notifier,
+ &args, sock_info);
+ else
+ ret = -ENOSYS;
+ break;
+ }
+
default:
if (ops->cmd)
ret = ops->cmd(lum->handle, lum->cmd,
if (sock_info->wait_shm_mmap) {
long page_size;
- page_size = sysconf(_SC_PAGE_SIZE);
+ page_size = LTTNG_UST_PAGE_SIZE;
if (page_size <= 0) {
if (!page_size) {
errno = EINVAL;
if (uatomic_read((int32_t *) sock_info->wait_shm_mmap))
goto end_wait;
- while (futex_async((int32_t *) sock_info->wait_shm_mmap,
+ while (lttng_ust_futex_async((int32_t *) sock_info->wait_shm_mmap,
FUTEX_WAIT, 0, NULL, NULL, 0)) {
switch (errno) {
case EWOULDBLOCK:
"Please upgrade your kernel "
"(fix is commit 9ea71503a8ed9184d2d0b8ccc4d269d05f7940ae in Linux kernel "
"mainline). LTTng-UST will use polling mode fallback.");
- if (ust_debug())
+ if (ust_err_debug_enabled())
PERROR("futex");
goto end_wait;
}
* sessiond (otherwise leading to errors when trying to create
* sessiond before the init functions are completed).
*/
- init_usterr();
- lttng_ust_getenv_init(); /* Needs init_usterr() to be completed. */
+ ust_err_init();
+ lttng_ust_getenv_init(); /* Needs ust_err_init() to be completed. */
init_tracepoint();
lttng_ust_init_fd_tracker();
lttng_ust_clock_init();
lttng_ring_buffer_client_overwrite_rt_init();
lttng_ring_buffer_client_discard_init();
lttng_ring_buffer_client_discard_rt_init();
+ lttng_counter_client_percpu_32_modular_init();
+ lttng_counter_client_percpu_64_modular_init();
lttng_perf_counter_init();
/*
* Invoke ust malloc wrapper init before starting other threads.
lttng_ring_buffer_client_overwrite_rt_exit();
lttng_ring_buffer_client_overwrite_exit();
lttng_ring_buffer_metadata_client_exit();
+ lttng_counter_client_percpu_32_modular_exit();
+ lttng_counter_client_percpu_64_modular_exit();
lttng_ust_statedump_destroy();
exit_tracepoint();
if (!exiting) {
pthread_mutex_lock(&ust_fork_mutex);
ust_lock_nocheck();
- urcu_bp_before_fork();
+ lttng_ust_urcu_before_fork();
lttng_ust_lock_fd_tracker();
lttng_perf_lock();
}
if (URCU_TLS(lttng_ust_nest_count))
return;
DBG("process %d", getpid());
- urcu_bp_after_fork_parent();
+ lttng_ust_urcu_after_fork_parent();
/* Release mutexes and reenable signals */
ust_after_fork_common(restore_sigset);
}
ust_context_vgids_reset();
DBG("process %d", getpid());
/* Release urcu mutexes */
- urcu_bp_after_fork_child();
+ lttng_ust_urcu_after_fork_child();
lttng_ust_cleanup(0);
/* Release mutexes and reenable signals */
ust_after_fork_common(restore_sigset);