/*
- * 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
#include <urcu/compiler.h>
#include <lttng/urcu/urcu-ust.h>
-#include <lttng/align.h>
#include <lttng/ust-events.h>
#include <lttng/ust-abi.h>
#include <lttng/ust.h>
#include <lttng/ust-error.h>
#include <lttng/ust-ctl.h>
+#include <lttng/ust-libc-wrapper.h>
#include <urcu/tls-compat.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 "../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)
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)
{
(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();
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",
int handle_bytecode_recv(struct sock_info *sock_info,
int sock, struct ustcomm_ust_msg *lum)
{
- struct lttng_ust_bytecode_node *bytecode;
+ 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;
switch (len) {
case 0: /* orderly shutdown */
ret = 0;
- goto error_free_bytecode;
+ goto end;
default:
if (len == bytecode->bc.len) {
DBG("Bytecode %s data received",
ERR("%s remote end closed connection",
sock_info->name);
ret = len;
- goto error_free_bytecode;
+ goto end;
}
ret = len;
- goto error_free_bytecode;
+ goto end;
} else {
DBG("Incorrect %s bytecode data message size: %zd",
bytecode_type_str(lum->cmd), len);
ret = -EINVAL;
- goto error_free_bytecode;
+ goto end;
}
}
ops = objd_ops(lum->handle);
if (!ops) {
ret = -ENOENT;
- goto error_free_bytecode;
+ goto end;
}
- if (ops->cmd) {
+ if (ops->cmd)
ret = ops->cmd(lum->handle, lum->cmd,
- (unsigned long) bytecode,
+ (unsigned long) &bytecode,
NULL, sock_info);
- if (ret)
- goto error_free_bytecode;
- /* don't free bytecode if everything went fine. */
- } else {
+ else
ret = -ENOSYS;
- goto error_free_bytecode;
- }
- goto end;
-
-error_free_bytecode:
- free(bytecode);
end:
+ free(bytecode);
return ret;
}
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);
- }
- /* Don't free exclusion data if everything went fine. */
- } else {
+ else
ret = -ENOSYS;
- free(node);
- }
+ free(node);
break;
}
case LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE:
{
- int event_notifier_notif_fd;
+ int event_notifier_notif_fd, close_ret;
len = ustcomm_recv_event_notifier_notif_fd_from_sessiond(sock,
&event_notifier_notif_fd);
&args, sock_info);
else
ret = -ENOSYS;
+ 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;
}
case LTTNG_UST_CHANNEL:
&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:
&args, sock_info);
else
ret = -ENOSYS;
+ free(args.counter.counter_data);
break;
}
case LTTNG_UST_COUNTER_GLOBAL:
&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:
&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:
"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;
}
* Weak symbol to call when the ust malloc wrapper is not loaded.
*/
__attribute__((weak))
-void lttng_ust_malloc_wrapper_init(void)
+void lttng_ust_libc_wrapper_malloc_init(void)
{
}
* 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. */
- init_tracepoint();
+ ust_err_init();
+ lttng_ust_getenv_init(); /* Needs ust_err_init() to be completed. */
+ lttng_ust_tp_init();
lttng_ust_init_fd_tracker();
lttng_ust_clock_init();
lttng_ust_getcpu_init();
/*
* Invoke ust malloc wrapper init before starting other threads.
*/
- lttng_ust_malloc_wrapper_init();
+ lttng_ust_libc_wrapper_malloc_init();
timeout_mode = get_constructor_timeout(&constructor_timeout);
lttng_counter_client_percpu_32_modular_exit();
lttng_counter_client_percpu_64_modular_exit();
lttng_ust_statedump_destroy();
- exit_tracepoint();
+ lttng_ust_tp_exit();
if (!exiting) {
/* Reinitialize values for fork */
sem_count = sem_count_initial_value;
ust_lock_nocheck();
lttng_ust_urcu_before_fork();
- if (lttng_ust_liburcu_bp_before_fork)
- lttng_ust_liburcu_bp_before_fork();
lttng_ust_lock_fd_tracker();
lttng_perf_lock();
}
return;
DBG("process %d", getpid());
lttng_ust_urcu_after_fork_parent();
- if (lttng_ust_liburcu_bp_after_fork_parent)
- lttng_ust_liburcu_bp_after_fork_parent();
/* Release mutexes and reenable signals */
ust_after_fork_common(restore_sigset);
}
DBG("process %d", getpid());
/* Release urcu mutexes */
lttng_ust_urcu_after_fork_child();
- if (lttng_ust_liburcu_bp_after_fork_child)
- lttng_ust_liburcu_bp_after_fork_child();
lttng_ust_cleanup(0);
/* Release mutexes and reenable signals */
ust_after_fork_common(restore_sigset);
projects / lttng-ust.git / blobdiff