X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-comm.c;h=204db9de37c6ace3f9a99041b27e4dd95fd52698;hb=dc325c1d762bbbdc1866e590f4649078f8600664;hp=ead0d7fecbc6d15f03ab120ff9f3524b063bf454;hpb=867942fdcdf016a65df7165b4b8135801e2832c2;p=lttng-ust.git diff --git a/liblttng-ust/lttng-ust-comm.c b/liblttng-ust/lttng-ust-comm.c index ead0d7fe..204db9de 100644 --- a/liblttng-ust/lttng-ust-comm.c +++ b/liblttng-ust/lttng-ust-comm.c @@ -1,22 +1,8 @@ /* - * lttng-ust-comm.c + * SPDX-License-Identifier: LGPL-2.1-only * * Copyright (C) 2011 David Goulet * Copyright (C) 2011 Mathieu Desnoyers - * - * 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 @@ -43,17 +29,19 @@ #include #include -#include +#include #include #include -#include +#include #include #include +#include +#include #include #include #include #include -#include +#include #include "tracepoint-internal.h" #include "lttng-tracer-core.h" #include "compat.h" @@ -63,9 +51,8 @@ #include "../libringbuffer/getcpu.h" #include "getenv.h" #include "ust-events-internal.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) +#include "context-internal.h" +#include "ust-compat.h" /* * Has lttng ust comm constructor been called ? @@ -313,51 +300,51 @@ struct sock_info local_apps = { static int wait_poll_fallback; static const char *cmd_name_mapping[] = { - [ LTTNG_UST_RELEASE ] = "Release", - [ LTTNG_UST_SESSION ] = "Create Session", - [ LTTNG_UST_TRACER_VERSION ] = "Get Tracer Version", + [ LTTNG_UST_ABI_RELEASE ] = "Release", + [ LTTNG_UST_ABI_SESSION ] = "Create Session", + [ LTTNG_UST_ABI_TRACER_VERSION ] = "Get Tracer Version", - [ LTTNG_UST_TRACEPOINT_LIST ] = "Create Tracepoint List", - [ LTTNG_UST_WAIT_QUIESCENT ] = "Wait for Quiescent State", - [ LTTNG_UST_REGISTER_DONE ] = "Registration Done", - [ LTTNG_UST_TRACEPOINT_FIELD_LIST ] = "Create Tracepoint Field List", + [ LTTNG_UST_ABI_TRACEPOINT_LIST ] = "Create Tracepoint List", + [ LTTNG_UST_ABI_WAIT_QUIESCENT ] = "Wait for Quiescent State", + [ LTTNG_UST_ABI_REGISTER_DONE ] = "Registration Done", + [ LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST ] = "Create Tracepoint Field List", - [ LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE ] = "Create event notifier group", + [ LTTNG_UST_ABI_EVENT_NOTIFIER_GROUP_CREATE ] = "Create event notifier group", /* Session FD commands */ - [ LTTNG_UST_CHANNEL ] = "Create Channel", - [ LTTNG_UST_SESSION_START ] = "Start Session", - [ LTTNG_UST_SESSION_STOP ] = "Stop Session", + [ LTTNG_UST_ABI_CHANNEL ] = "Create Channel", + [ LTTNG_UST_ABI_SESSION_START ] = "Start Session", + [ LTTNG_UST_ABI_SESSION_STOP ] = "Stop Session", /* Channel FD commands */ - [ LTTNG_UST_STREAM ] = "Create Stream", - [ LTTNG_UST_EVENT ] = "Create Event", + [ LTTNG_UST_ABI_STREAM ] = "Create Stream", + [ LTTNG_UST_ABI_EVENT ] = "Create Event", /* Event and Channel FD commands */ - [ LTTNG_UST_CONTEXT ] = "Create Context", - [ LTTNG_UST_FLUSH_BUFFER ] = "Flush Buffer", + [ LTTNG_UST_ABI_CONTEXT ] = "Create Context", + [ LTTNG_UST_ABI_FLUSH_BUFFER ] = "Flush Buffer", /* Event, Channel and Session commands */ - [ LTTNG_UST_ENABLE ] = "Enable", - [ LTTNG_UST_DISABLE ] = "Disable", + [ LTTNG_UST_ABI_ENABLE ] = "Enable", + [ LTTNG_UST_ABI_DISABLE ] = "Disable", /* Tracepoint list commands */ - [ LTTNG_UST_TRACEPOINT_LIST_GET ] = "List Next Tracepoint", - [ LTTNG_UST_TRACEPOINT_FIELD_LIST_GET ] = "List Next Tracepoint Field", + [ LTTNG_UST_ABI_TRACEPOINT_LIST_GET ] = "List Next Tracepoint", + [ LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST_GET ] = "List Next Tracepoint Field", /* Event FD commands */ - [ LTTNG_UST_FILTER ] = "Create Filter", - [ LTTNG_UST_EXCLUSION ] = "Add exclusions to event", + [ LTTNG_UST_ABI_FILTER ] = "Create Filter", + [ LTTNG_UST_ABI_EXCLUSION ] = "Add exclusions to event", /* Event notifier group commands */ - [ LTTNG_UST_EVENT_NOTIFIER_CREATE ] = "Create event notifier", + [ LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE ] = "Create event notifier", /* Session and event notifier group commands */ - [ LTTNG_UST_COUNTER ] = "Create Counter", + [ LTTNG_UST_ABI_COUNTER ] = "Create Counter", /* Counter commands */ - [ LTTNG_UST_COUNTER_GLOBAL ] = "Create Counter Global", - [ LTTNG_UST_COUNTER_CPU ] = "Create Counter CPU", + [ LTTNG_UST_ABI_COUNTER_GLOBAL ] = "Create Counter Global", + [ LTTNG_UST_ABI_COUNTER_CPU ] = "Create Counter CPU", }; static const char *str_timeout; @@ -373,9 +360,17 @@ extern void lttng_ring_buffer_client_overwrite_rt_exit(void); 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); + +__attribute__((visibility("hidden"))) extern void lttng_counter_client_percpu_32_modular_init(void); + +__attribute__((visibility("hidden"))) extern void lttng_counter_client_percpu_32_modular_exit(void); + +__attribute__((visibility("hidden"))) extern void lttng_counter_client_percpu_64_modular_init(void); + +__attribute__((visibility("hidden"))) extern void lttng_counter_client_percpu_64_modular_exit(void); static char *get_map_shm(struct sock_info *sock_info); @@ -407,11 +402,11 @@ const char *get_lttng_home_dir(void) { 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"); } /* @@ -430,17 +425,17 @@ void lttng_fixup_ust_mutex_nest_tls(void) } /* - * 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(); @@ -463,7 +458,6 @@ int lttng_get_notify_socket(void *owner) } -LTTNG_HIDDEN char* lttng_ust_sockinfo_get_procname(void *owner) { struct sock_info *info = owner; @@ -561,7 +555,7 @@ long get_timeout(void) 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) @@ -628,7 +622,7 @@ static 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", @@ -643,11 +637,11 @@ int register_to_sessiond(int socket, enum ustctl_socket_type type) return ustcomm_send_reg_msg(socket, type, CAA_BITS_PER_LONG, - lttng_alignof(uint8_t) * CHAR_BIT, - lttng_alignof(uint16_t) * CHAR_BIT, - lttng_alignof(uint32_t) * CHAR_BIT, - lttng_alignof(uint64_t) * CHAR_BIT, - lttng_alignof(unsigned long) * CHAR_BIT); + lttng_ust_rb_alignof(uint8_t) * CHAR_BIT, + lttng_ust_rb_alignof(uint16_t) * CHAR_BIT, + lttng_ust_rb_alignof(uint32_t) * CHAR_BIT, + lttng_ust_rb_alignof(uint64_t) * CHAR_BIT, + lttng_ust_rb_alignof(unsigned long) * CHAR_BIT); } static @@ -759,9 +753,9 @@ static inline const char *bytecode_type_str(uint32_t cmd) { switch (cmd) { - case LTTNG_UST_CAPTURE: + case LTTNG_UST_ABI_CAPTURE: return "capture"; - case LTTNG_UST_FILTER: + case LTTNG_UST_ABI_FILTER: return "filter"; default: abort(); @@ -772,26 +766,26 @@ static int handle_bytecode_recv(struct sock_info *sock_info, int sock, struct ustcomm_ust_msg *lum) { - struct lttng_ust_bytecode_node *bytecode; - enum lttng_ust_bytecode_node_type type; - const struct lttng_ust_objd_ops *ops; + struct lttng_ust_bytecode_node *bytecode = NULL; + enum lttng_ust_bytecode_type type; + const struct lttng_ust_abi_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; + case LTTNG_UST_ABI_FILTER: + type = LTTNG_UST_BYTECODE_TYPE_FILTER; data_size = lum->u.filter.data_size; - data_size_max = FILTER_BYTECODE_MAX_LEN; + data_size_max = LTTNG_UST_ABI_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; + case LTTNG_UST_ABI_CAPTURE: + type = LTTNG_UST_BYTECODE_TYPE_CAPTURE; data_size = lum->u.capture.data_size; - data_size_max = CAPTURE_BYTECODE_MAX_LEN; + data_size_max = LTTNG_UST_ABI_CAPTURE_BYTECODE_MAX_LEN; reloc_offset = lum->u.capture.reloc_offset; seqnum = lum->u.capture.seqnum; break; @@ -829,7 +823,7 @@ int handle_bytecode_recv(struct sock_info *sock_info, 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", @@ -842,41 +836,33 @@ int handle_bytecode_recv(struct sock_info *sock_info, 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); + ops = lttng_ust_abi_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; } @@ -885,10 +871,10 @@ int handle_message(struct sock_info *sock_info, int sock, struct ustcomm_ust_msg *lum) { int ret = 0; - const struct lttng_ust_objd_ops *ops; + const struct lttng_ust_abi_objd_ops *ops; struct ustcomm_ust_reply lur; - union ust_args args; - char ctxstr[LTTNG_UST_SYM_NAME_LEN]; /* App context string. */ + union lttng_ust_abi_args args; + char ctxstr[LTTNG_UST_ABI_SYM_NAME_LEN]; /* App context string. */ ssize_t len; memset(&lur, 0, sizeof(lur)); @@ -898,32 +884,32 @@ int handle_message(struct sock_info *sock_info, goto error; } - ops = objd_ops(lum->handle); + ops = lttng_ust_abi_objd_ops(lum->handle); if (!ops) { ret = -ENOENT; goto error; } switch (lum->cmd) { - case LTTNG_UST_REGISTER_DONE: - if (lum->handle == LTTNG_UST_ROOT_HANDLE) + case LTTNG_UST_ABI_REGISTER_DONE: + if (lum->handle == LTTNG_UST_ABI_ROOT_HANDLE) ret = handle_register_done(sock_info); else ret = -EINVAL; break; - case LTTNG_UST_RELEASE: - if (lum->handle == LTTNG_UST_ROOT_HANDLE) + case LTTNG_UST_ABI_RELEASE: + if (lum->handle == LTTNG_UST_ABI_ROOT_HANDLE) ret = -EPERM; else - ret = lttng_ust_objd_unref(lum->handle, 1); + ret = lttng_ust_abi_objd_unref(lum->handle, 1); break; - case LTTNG_UST_CAPTURE: - case LTTNG_UST_FILTER: + case LTTNG_UST_ABI_CAPTURE: + case LTTNG_UST_ABI_FILTER: ret = handle_bytecode_recv(sock_info, sock, lum); if (ret) goto error; break; - case LTTNG_UST_EXCLUSION: + case LTTNG_UST_ABI_EXCLUSION: { /* Receive exclusion names */ struct lttng_ust_excluder_node *node; @@ -936,21 +922,21 @@ int handle_message(struct sock_info *sock_info, goto error; } node = zmalloc(sizeof(*node) + - count * LTTNG_UST_SYM_NAME_LEN); + count * LTTNG_UST_ABI_SYM_NAME_LEN); if (!node) { ret = -ENOMEM; goto error; } node->excluder.count = count; len = ustcomm_recv_unix_sock(sock, node->excluder.names, - count * LTTNG_UST_SYM_NAME_LEN); + count * LTTNG_UST_ABI_SYM_NAME_LEN); switch (len) { case 0: /* orderly shutdown */ ret = 0; free(node); goto error; default: - if (len == count * LTTNG_UST_SYM_NAME_LEN) { + if (len == count * LTTNG_UST_ABI_SYM_NAME_LEN) { DBG("Exclusion data received"); break; } else if (len < 0) { @@ -971,23 +957,18 @@ int handle_message(struct sock_info *sock_info, 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: + case LTTNG_UST_ABI_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); @@ -1024,9 +1005,16 @@ int handle_message(struct sock_info *sock_info, &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: + case LTTNG_UST_ABI_CHANNEL: { void *chan_data; int wakeup_fd; @@ -1078,8 +1066,10 @@ int handle_message(struct sock_info *sock_info, free(args.channel.chan_data); break; } - case LTTNG_UST_STREAM: + case LTTNG_UST_ABI_STREAM: { + int close_ret; + /* Receive shm_fd, wakeup_fd */ ret = ustcomm_recv_stream_from_sessiond(sock, NULL, @@ -1095,18 +1085,34 @@ int handle_message(struct sock_info *sock_info, &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: + case LTTNG_UST_ABI_CONTEXT: switch (lum->u.context.ctx) { - case LTTNG_UST_CONTEXT_APP_CONTEXT: + case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT: { char *p; size_t ctxlen, recvlen; ctxlen = strlen("$app.") + lum->u.context.u.app_ctx.provider_name_len - 1 + strlen(":") + lum->u.context.u.app_ctx.ctx_name_len; - if (ctxlen >= LTTNG_UST_SYM_NAME_LEN) { + if (ctxlen >= LTTNG_UST_ABI_SYM_NAME_LEN) { ERR("Application context string length size is too large: %zu bytes", ctxlen); ret = -EINVAL; @@ -1155,7 +1161,7 @@ int handle_message(struct sock_info *sock_info, ret = -ENOSYS; } break; - case LTTNG_UST_COUNTER: + case LTTNG_UST_ABI_COUNTER: { void *counter_data; @@ -1191,9 +1197,10 @@ int handle_message(struct sock_info *sock_info, &args, sock_info); else ret = -ENOSYS; + free(args.counter.counter_data); break; } - case LTTNG_UST_COUNTER_GLOBAL: + case LTTNG_UST_ABI_COUNTER_GLOBAL: { /* Receive shm_fd */ ret = ustcomm_recv_counter_shm_from_sessiond(sock, @@ -1208,9 +1215,19 @@ int handle_message(struct sock_info *sock_info, &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: + case LTTNG_UST_ABI_COUNTER_CPU: { /* Receive shm_fd */ ret = ustcomm_recv_counter_shm_from_sessiond(sock, @@ -1225,12 +1242,22 @@ int handle_message(struct sock_info *sock_info, &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: + case LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE: { /* Receive struct lttng_ust_event_notifier */ - struct lttng_ust_event_notifier event_notifier; + struct lttng_ust_abi_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); @@ -1320,10 +1347,10 @@ int handle_message(struct sock_info *sock_info, } if (ret >= 0) { switch (lum->cmd) { - case LTTNG_UST_TRACER_VERSION: + case LTTNG_UST_ABI_TRACER_VERSION: lur.u.version = lum->u.version; break; - case LTTNG_UST_TRACEPOINT_LIST_GET: + case LTTNG_UST_ABI_TRACEPOINT_LIST_GET: memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint)); break; } @@ -1356,7 +1383,7 @@ int handle_message(struct sock_info *sock_info, */ if (lur.ret_code == LTTNG_UST_OK) { switch (lum->cmd) { - case LTTNG_UST_TRACEPOINT_FIELD_LIST_GET: + case LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST_GET: len = ustcomm_send_unix_sock(sock, &args.field_list.entry, sizeof(args.field_list.entry)); @@ -1383,7 +1410,7 @@ void cleanup_sock_info(struct sock_info *sock_info, int exiting) int ret; if (sock_info->root_handle != -1) { - ret = lttng_ust_objd_unref(sock_info->root_handle, 1); + ret = lttng_ust_abi_objd_unref(sock_info->root_handle, 1); if (ret) { ERR("Error unref root handle"); } @@ -1694,7 +1721,7 @@ void wait_for_sessiond(struct sock_info *sock_info) "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; } @@ -2011,7 +2038,7 @@ end: goto quit; } /* Cleanup socket handles before trying to reconnect */ - lttng_ust_objd_table_owner_cleanup(sock_info); + lttng_ust_abi_objd_table_owner_cleanup(sock_info); ust_unlock(); goto restart; /* try to reconnect */ @@ -2028,7 +2055,7 @@ quit: * 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) { } @@ -2064,7 +2091,7 @@ void __attribute__((constructor)) lttng_ust_init(void) * liblttng-ust.so to increment the dynamic loader's internal refcount for * this library so it never becomes zero, thus never gets unloaded from the * address space of the process. Since we are already running in the - * constructor of the LTTNG_UST_LIB_SO_NAME library, calling dlopen will + * constructor of the LTTNG_UST_LIB_SONAME library, calling dlopen will * simply increment the refcount and no additionnal work is needed by the * dynamic loader as the shared library is already loaded in the address * space. As a safe guard, we use the RTLD_NODELETE flag to prevent @@ -2072,9 +2099,9 @@ void __attribute__((constructor)) lttng_ust_init(void) * never happen). Do the return value check but discard the handle at the * end of the function as it's not needed. */ - handle = dlopen(LTTNG_UST_LIB_SO_NAME, RTLD_LAZY | RTLD_NODELETE); + handle = dlopen(LTTNG_UST_LIB_SONAME, RTLD_LAZY | RTLD_NODELETE); if (!handle) { - ERR("dlopen of liblttng-ust shared library (%s).", LTTNG_UST_LIB_SO_NAME); + ERR("dlopen of liblttng-ust shared library (%s).", LTTNG_UST_LIB_SONAME); } /* @@ -2083,9 +2110,9 @@ void __attribute__((constructor)) lttng_ust_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(); @@ -2101,7 +2128,7 @@ void __attribute__((constructor)) lttng_ust_init(void) /* * 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); @@ -2235,7 +2262,7 @@ void lttng_ust_cleanup(int exiting) * point. */ lttng_ust_abi_exit(); - lttng_ust_events_exit(); + lttng_ust_abi_events_exit(); lttng_perf_counter_exit(); lttng_ring_buffer_client_discard_rt_exit(); lttng_ring_buffer_client_discard_exit(); @@ -2245,7 +2272,7 @@ void lttng_ust_cleanup(int exiting) 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; @@ -2342,7 +2369,7 @@ void ust_context_vgids_reset(void) * in the middle of an tracepoint or ust tracing state modification. * Holding this mutex protects these structures across fork and clone. */ -void ust_before_fork(sigset_t *save_sigset) +void lttng_ust_before_fork(sigset_t *save_sigset) { /* * Disable signals. This is to avoid that the child intervenes @@ -2369,8 +2396,6 @@ void ust_before_fork(sigset_t *save_sigset) 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(); } @@ -2393,14 +2418,12 @@ static void ust_after_fork_common(sigset_t *restore_sigset) } } -void ust_after_fork_parent(sigset_t *restore_sigset) +void lttng_ust_after_fork_parent(sigset_t *restore_sigset) { if (URCU_TLS(lttng_ust_nest_count)) 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); } @@ -2414,77 +2437,75 @@ void ust_after_fork_parent(sigset_t *restore_sigset) * This is meant for forks() that have tracing in the child between the * fork and following exec call (if there is any). */ -void ust_after_fork_child(sigset_t *restore_sigset) +void lttng_ust_after_fork_child(sigset_t *restore_sigset) { if (URCU_TLS(lttng_ust_nest_count)) return; lttng_context_vpid_reset(); lttng_context_vtid_reset(); - lttng_context_procname_reset(); + lttng_ust_context_procname_reset(); ust_context_ns_reset(); ust_context_vuids_reset(); ust_context_vgids_reset(); 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); lttng_ust_init(); } -void ust_after_setns(void) +void lttng_ust_after_setns(void) { ust_context_ns_reset(); ust_context_vuids_reset(); ust_context_vgids_reset(); } -void ust_after_unshare(void) +void lttng_ust_after_unshare(void) { ust_context_ns_reset(); ust_context_vuids_reset(); ust_context_vgids_reset(); } -void ust_after_setuid(void) +void lttng_ust_after_setuid(void) { ust_context_vuids_reset(); } -void ust_after_seteuid(void) +void lttng_ust_after_seteuid(void) { ust_context_vuids_reset(); } -void ust_after_setreuid(void) +void lttng_ust_after_setreuid(void) { ust_context_vuids_reset(); } -void ust_after_setresuid(void) +void lttng_ust_after_setresuid(void) { ust_context_vuids_reset(); } -void ust_after_setgid(void) +void lttng_ust_after_setgid(void) { ust_context_vgids_reset(); } -void ust_after_setegid(void) +void lttng_ust_after_setegid(void) { ust_context_vgids_reset(); } -void ust_after_setregid(void) +void lttng_ust_after_setregid(void) { ust_context_vgids_reset(); } -void ust_after_setresgid(void) +void lttng_ust_after_setresgid(void) { ust_context_vgids_reset(); }