#include <wrapper/random.h>
#include <wrapper/tracepoint.h>
#include <wrapper/list.h>
+#include <wrapper/types.h>
#include <lttng-kernel-version.h>
#include <lttng-events.h>
#include <lttng-tracer.h>
#include <lttng-abi-old.h>
#include <lttng-endian.h>
+#include <lttng-string-utils.h>
#include <wrapper/vzalloc.h>
+#include <wrapper/ringbuffer/backend.h>
+#include <wrapper/ringbuffer/frontend.h>
+#include <wrapper/time.h>
#define METADATA_CACHE_DEFAULT_SIZE 4096
void synchronize_trace(void)
{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0))
+ synchronize_rcu();
+#else
synchronize_sched();
+#endif
+
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
#ifdef CONFIG_PREEMPT_RT_FULL
synchronize_rcu();
int i;
mutex_lock(&sessions_mutex);
- session = kzalloc(sizeof(struct lttng_session), GFP_KERNEL);
+ session = lttng_kvzalloc(sizeof(struct lttng_session), GFP_KERNEL);
if (!session)
goto err;
INIT_LIST_HEAD(&session->chan);
err_free_cache:
kfree(metadata_cache);
err_free_session:
- kfree(session);
+ lttng_kvfree(session);
err:
mutex_unlock(&sessions_mutex);
return NULL;
int ret;
mutex_lock(&sessions_mutex);
- ACCESS_ONCE(session->active) = 0;
+ WRITE_ONCE(session->active, 0);
list_for_each_entry(chan, &session->chan, list) {
ret = lttng_syscalls_unregister(chan);
WARN_ON(ret);
kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
list_del(&session->list);
mutex_unlock(&sessions_mutex);
- kfree(session);
+ lttng_kvfree(session);
+}
+
+int lttng_session_statedump(struct lttng_session *session)
+{
+ int ret;
+
+ mutex_lock(&sessions_mutex);
+ ret = lttng_statedump_start(session);
+ mutex_unlock(&sessions_mutex);
+ return ret;
}
int lttng_session_enable(struct lttng_session *session)
/* We need to sync enablers with session before activation. */
lttng_session_sync_enablers(session);
- ACCESS_ONCE(session->active) = 1;
- ACCESS_ONCE(session->been_active) = 1;
+ /* Clear each stream's quiescent state. */
+ list_for_each_entry(chan, &session->chan, list) {
+ if (chan->channel_type != METADATA_CHANNEL)
+ lib_ring_buffer_clear_quiescent_channel(chan->chan);
+ }
+
+ WRITE_ONCE(session->active, 1);
+ WRITE_ONCE(session->been_active, 1);
ret = _lttng_session_metadata_statedump(session);
if (ret) {
- ACCESS_ONCE(session->active) = 0;
+ WRITE_ONCE(session->active, 0);
goto end;
}
ret = lttng_statedump_start(session);
if (ret)
- ACCESS_ONCE(session->active) = 0;
+ WRITE_ONCE(session->active, 0);
end:
mutex_unlock(&sessions_mutex);
return ret;
int lttng_session_disable(struct lttng_session *session)
{
int ret = 0;
+ struct lttng_channel *chan;
mutex_lock(&sessions_mutex);
if (!session->active) {
ret = -EBUSY;
goto end;
}
- ACCESS_ONCE(session->active) = 0;
+ WRITE_ONCE(session->active, 0);
/* Set transient enabler state to "disabled" */
session->tstate = 0;
lttng_session_sync_enablers(session);
+
+ /* Set each stream's quiescent state. */
+ list_for_each_entry(chan, &session->chan, list) {
+ if (chan->channel_type != METADATA_CHANNEL)
+ lib_ring_buffer_set_quiescent_channel(chan->chan);
+ }
end:
mutex_unlock(&sessions_mutex);
return ret;
channel->tstate = 1;
lttng_session_sync_enablers(channel->session);
/* Set atomically the state to "enabled" */
- ACCESS_ONCE(channel->enabled) = 1;
+ WRITE_ONCE(channel->enabled, 1);
end:
mutex_unlock(&sessions_mutex);
return ret;
goto end;
}
/* Set atomically the state to "disabled" */
- ACCESS_ONCE(channel->enabled) = 0;
+ WRITE_ONCE(channel->enabled, 0);
/* Set transient enabler state to "enabled" */
channel->tstate = 0;
lttng_session_sync_enablers(channel->session);
case LTTNG_KERNEL_KPROBE:
case LTTNG_KERNEL_FUNCTION:
case LTTNG_KERNEL_NOOP:
- ACCESS_ONCE(event->enabled) = 1;
+ WRITE_ONCE(event->enabled, 1);
break;
case LTTNG_KERNEL_KRETPROBE:
ret = lttng_kretprobes_event_enable_state(event, 1);
case LTTNG_KERNEL_KPROBE:
case LTTNG_KERNEL_FUNCTION:
case LTTNG_KERNEL_NOOP:
- ACCESS_ONCE(event->enabled) = 0;
+ WRITE_ONCE(event->enabled, 0);
break;
case LTTNG_KERNEL_KRETPROBE:
ret = lttng_kretprobes_event_enable_state(event, 0);
ret = PTR_ERR(tracker_pids_list_file);
goto file_error;
}
- if (atomic_long_add_unless(&session->file->f_count,
- 1, INT_MAX) == INT_MAX) {
+ if (!atomic_long_add_unless(&session->file->f_count, 1, LONG_MAX)) {
+ ret = -EOVERFLOW;
goto refcount_error;
}
ret = lttng_tracker_pids_list_fops.open(NULL, tracker_pids_list_file);
* Enabler management.
*/
static
-int lttng_match_enabler_wildcard(const char *desc_name,
- const char *name)
+int lttng_match_enabler_star_glob(const char *desc_name,
+ const char *pattern)
{
- /* Compare excluding final '*' */
- if (strncmp(desc_name, name, strlen(name) - 1))
+ if (!strutils_star_glob_match(pattern, LTTNG_SIZE_MAX,
+ desc_name, LTTNG_SIZE_MAX))
return 0;
return 1;
}
return -EINVAL;
}
switch (enabler->type) {
- case LTTNG_ENABLER_WILDCARD:
- return lttng_match_enabler_wildcard(desc_name, enabler_name);
+ case LTTNG_ENABLER_STAR_GLOB:
+ return lttng_match_enabler_star_glob(desc_name, enabler_name);
case LTTNG_ENABLER_NAME:
return lttng_match_enabler_name(desc_name, enabler_name);
default:
*/
enabled = enabled && session->tstate && event->chan->tstate;
- ACCESS_ONCE(event->enabled) = enabled;
+ WRITE_ONCE(event->enabled, enabled);
/*
* Sync tracepoint registration with event enabled
* state.
va_list ap;
struct lttng_metadata_stream *stream;
- WARN_ON_ONCE(!ACCESS_ONCE(session->active));
+ WARN_ON_ONCE(!READ_ONCE(session->active));
va_start(ap, fmt);
str = kvasprintf(GFP_KERNEL, fmt, ap);
return ret;
}
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_enum_statedump(struct lttng_session *session,
+ const struct lttng_event_field *field,
+ size_t nesting)
+{
+ const struct lttng_enum_desc *enum_desc;
+ const struct lttng_integer_type *container_type;
+ int ret;
+ unsigned int i, nr_entries;
+
+ enum_desc = field->type.u.basic.enumeration.desc;
+ container_type = &field->type.u.basic.enumeration.container_type;
+ nr_entries = enum_desc->nr_entries;
+
+ ret = print_tabs(session, nesting);
+ if (ret)
+ goto end;
+ ret = lttng_metadata_printf(session,
+ "enum : integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } {\n",
+ container_type->size,
+ container_type->alignment,
+ container_type->signedness,
+ (container_type->encoding == lttng_encode_none)
+ ? "none"
+ : (container_type->encoding == lttng_encode_UTF8)
+ ? "UTF8"
+ : "ASCII",
+ container_type->base,
+#if __BYTE_ORDER == __BIG_ENDIAN
+ container_type->reverse_byte_order ? " byte_order = le;" : ""
+#else
+ container_type->reverse_byte_order ? " byte_order = be;" : ""
+#endif
+ );
+ if (ret)
+ goto end;
+ /* Dump all entries */
+ for (i = 0; i < nr_entries; i++) {
+ const struct lttng_enum_entry *entry = &enum_desc->entries[i];
+ int j, len;
+
+ ret = print_tabs(session, nesting + 1);
+ if (ret)
+ goto end;
+ ret = lttng_metadata_printf(session,
+ "\"");
+ if (ret)
+ goto end;
+ len = strlen(entry->string);
+ /* Escape the character '"' */
+ for (j = 0; j < len; j++) {
+ char c = entry->string[j];
+
+ switch (c) {
+ case '"':
+ ret = lttng_metadata_printf(session,
+ "\\\"");
+ break;
+ case '\\':
+ ret = lttng_metadata_printf(session,
+ "\\\\");
+ break;
+ default:
+ ret = lttng_metadata_printf(session,
+ "%c", c);
+ break;
+ }
+ if (ret)
+ goto end;
+ }
+ ret = lttng_metadata_printf(session, "\"");
+ if (ret)
+ goto end;
+
+ if (entry->options.is_auto) {
+ ret = lttng_metadata_printf(session, ",\n");
+ if (ret)
+ goto end;
+ } else {
+ ret = lttng_metadata_printf(session,
+ " = ");
+ if (ret)
+ goto end;
+ if (entry->start.signedness)
+ ret = lttng_metadata_printf(session,
+ "%lld", (long long) entry->start.value);
+ else
+ ret = lttng_metadata_printf(session,
+ "%llu", entry->start.value);
+ if (ret)
+ goto end;
+ if (entry->start.signedness == entry->end.signedness &&
+ entry->start.value
+ == entry->end.value) {
+ ret = lttng_metadata_printf(session,
+ ",\n");
+ } else {
+ if (entry->end.signedness) {
+ ret = lttng_metadata_printf(session,
+ " ... %lld,\n",
+ (long long) entry->end.value);
+ } else {
+ ret = lttng_metadata_printf(session,
+ " ... %llu,\n",
+ entry->end.value);
+ }
+ }
+ if (ret)
+ goto end;
+ }
+ }
+ ret = print_tabs(session, nesting);
+ if (ret)
+ goto end;
+ ret = lttng_metadata_printf(session, "} _%s;\n",
+ field->name);
+end:
+ return ret;
+}
+
/*
* Must be called with sessions_mutex held.
*/
field->name);
break;
case atype_enum:
- ret = print_tabs(session, nesting);
- if (ret)
- return ret;
- ret = lttng_metadata_printf(session,
- "%s _%s;\n",
- field->type.u.basic.enumeration.name,
- field->name);
+ ret = _lttng_enum_statedump(session, field, nesting);
break;
case atype_array:
{
{
int ret = 0;
- if (event->metadata_dumped || !ACCESS_ONCE(session->active))
+ if (event->metadata_dumped || !READ_ONCE(session->active))
return 0;
if (chan->channel_type == METADATA_CHANNEL)
return 0;
{
int ret = 0;
- if (chan->metadata_dumped || !ACCESS_ONCE(session->active))
+ if (chan->metadata_dumped || !READ_ONCE(session->active))
return 0;
if (chan->channel_type == METADATA_CHANNEL)
* in future versions.
* This function may return a negative offset. It may happen if the
* system sets the REALTIME clock to 0 after boot.
+ *
+ * Use 64bit timespec on kernels that have it, this makes 32bit arch
+ * y2038 compliant.
*/
static
int64_t measure_clock_offset(void)
uint64_t monotonic_avg, monotonic[2], realtime;
uint64_t tcf = trace_clock_freq();
int64_t offset;
- struct timespec rts = { 0, 0 };
unsigned long flags;
+#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
+ struct timespec64 rts = { 0, 0 };
+#else
+ struct timespec rts = { 0, 0 };
+#endif
/* Disable interrupts to increase correlation precision. */
local_irq_save(flags);
monotonic[0] = trace_clock_read64();
- getnstimeofday(&rts);
+#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
+ ktime_get_real_ts64(&rts);
+#else
+ getnstimeofday(&rts);
+#endif
monotonic[1] = trace_clock_read64();
local_irq_restore(flags);
struct lttng_event *event;
int ret = 0;
- if (!ACCESS_ONCE(session->active))
+ if (!READ_ONCE(session->active))
return 0;
if (session->metadata_dumped)
goto skip_session;
}
EXPORT_SYMBOL_GPL(lttng_transport_unregister);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
+
+enum cpuhp_state lttng_hp_prepare;
+enum cpuhp_state lttng_hp_online;
+
+static int lttng_hotplug_prepare(unsigned int cpu, struct hlist_node *node)
+{
+ struct lttng_cpuhp_node *lttng_node;
+
+ lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+ switch (lttng_node->component) {
+ case LTTNG_RING_BUFFER_FRONTEND:
+ return 0;
+ case LTTNG_RING_BUFFER_BACKEND:
+ return lttng_cpuhp_rb_backend_prepare(cpu, lttng_node);
+ case LTTNG_RING_BUFFER_ITER:
+ return 0;
+ case LTTNG_CONTEXT_PERF_COUNTERS:
+ return 0;
+ default:
+ return -EINVAL;
+ }
+}
+
+static int lttng_hotplug_dead(unsigned int cpu, struct hlist_node *node)
+{
+ struct lttng_cpuhp_node *lttng_node;
+
+ lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+ switch (lttng_node->component) {
+ case LTTNG_RING_BUFFER_FRONTEND:
+ return lttng_cpuhp_rb_frontend_dead(cpu, lttng_node);
+ case LTTNG_RING_BUFFER_BACKEND:
+ return 0;
+ case LTTNG_RING_BUFFER_ITER:
+ return 0;
+ case LTTNG_CONTEXT_PERF_COUNTERS:
+ return lttng_cpuhp_perf_counter_dead(cpu, lttng_node);
+ default:
+ return -EINVAL;
+ }
+}
+
+static int lttng_hotplug_online(unsigned int cpu, struct hlist_node *node)
+{
+ struct lttng_cpuhp_node *lttng_node;
+
+ lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+ switch (lttng_node->component) {
+ case LTTNG_RING_BUFFER_FRONTEND:
+ return lttng_cpuhp_rb_frontend_online(cpu, lttng_node);
+ case LTTNG_RING_BUFFER_BACKEND:
+ return 0;
+ case LTTNG_RING_BUFFER_ITER:
+ return lttng_cpuhp_rb_iter_online(cpu, lttng_node);
+ case LTTNG_CONTEXT_PERF_COUNTERS:
+ return lttng_cpuhp_perf_counter_online(cpu, lttng_node);
+ default:
+ return -EINVAL;
+ }
+}
+
+static int lttng_hotplug_offline(unsigned int cpu, struct hlist_node *node)
+{
+ struct lttng_cpuhp_node *lttng_node;
+
+ lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+ switch (lttng_node->component) {
+ case LTTNG_RING_BUFFER_FRONTEND:
+ return lttng_cpuhp_rb_frontend_offline(cpu, lttng_node);
+ case LTTNG_RING_BUFFER_BACKEND:
+ return 0;
+ case LTTNG_RING_BUFFER_ITER:
+ return 0;
+ case LTTNG_CONTEXT_PERF_COUNTERS:
+ return 0;
+ default:
+ return -EINVAL;
+ }
+}
+
+static int __init lttng_init_cpu_hotplug(void)
+{
+ int ret;
+
+ ret = cpuhp_setup_state_multi(CPUHP_BP_PREPARE_DYN, "lttng:prepare",
+ lttng_hotplug_prepare,
+ lttng_hotplug_dead);
+ if (ret < 0) {
+ return ret;
+ }
+ lttng_hp_prepare = ret;
+ lttng_rb_set_hp_prepare(ret);
+
+ ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, "lttng:online",
+ lttng_hotplug_online,
+ lttng_hotplug_offline);
+ if (ret < 0) {
+ cpuhp_remove_multi_state(lttng_hp_prepare);
+ lttng_hp_prepare = 0;
+ return ret;
+ }
+ lttng_hp_online = ret;
+ lttng_rb_set_hp_online(ret);
+
+ return 0;
+}
+
+static void __exit lttng_exit_cpu_hotplug(void)
+{
+ lttng_rb_set_hp_online(0);
+ cpuhp_remove_multi_state(lttng_hp_online);
+ lttng_rb_set_hp_prepare(0);
+ cpuhp_remove_multi_state(lttng_hp_prepare);
+}
+
+#else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+static int lttng_init_cpu_hotplug(void)
+{
+ return 0;
+}
+static void lttng_exit_cpu_hotplug(void)
+{
+}
+#endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
+
+
static int __init lttng_events_init(void)
{
int ret;
ret = lttng_logger_init();
if (ret)
goto error_logger;
+ ret = lttng_init_cpu_hotplug();
+ if (ret)
+ goto error_hotplug;
+ printk(KERN_NOTICE "LTTng: Loaded modules v%s.%s.%s%s (%s)%s%s\n",
+ __stringify(LTTNG_MODULES_MAJOR_VERSION),
+ __stringify(LTTNG_MODULES_MINOR_VERSION),
+ __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
+ LTTNG_MODULES_EXTRAVERSION,
+ LTTNG_VERSION_NAME,
+#ifdef LTTNG_EXTRA_VERSION_GIT
+ LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
+#else
+ "",
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+ LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
+#else
+ "");
+#endif
return 0;
+error_hotplug:
+ lttng_logger_exit();
error_logger:
lttng_abi_exit();
error_abi:
lttng_tracepoint_exit();
error_tp:
lttng_context_exit();
+ printk(KERN_NOTICE "LTTng: Failed to load modules v%s.%s.%s%s (%s)%s%s\n",
+ __stringify(LTTNG_MODULES_MAJOR_VERSION),
+ __stringify(LTTNG_MODULES_MINOR_VERSION),
+ __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
+ LTTNG_MODULES_EXTRAVERSION,
+ LTTNG_VERSION_NAME,
+#ifdef LTTNG_EXTRA_VERSION_GIT
+ LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
+#else
+ "",
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+ LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
+#else
+ "");
+#endif
return ret;
}
{
struct lttng_session *session, *tmpsession;
+ lttng_exit_cpu_hotplug();
lttng_logger_exit();
lttng_abi_exit();
list_for_each_entry_safe(session, tmpsession, &sessions, list)
kmem_cache_destroy(event_cache);
lttng_tracepoint_exit();
lttng_context_exit();
+ printk(KERN_NOTICE "LTTng: Unloaded modules v%s.%s.%s%s (%s)%s%s\n",
+ __stringify(LTTNG_MODULES_MAJOR_VERSION),
+ __stringify(LTTNG_MODULES_MINOR_VERSION),
+ __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
+ LTTNG_MODULES_EXTRAVERSION,
+ LTTNG_VERSION_NAME,
+#ifdef LTTNG_EXTRA_VERSION_GIT
+ LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
+#else
+ "",
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+ LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
+#else
+ "");
+#endif
}
module_exit(lttng_events_exit);
+#include "extra_version/patches.i"
+#ifdef LTTNG_EXTRA_VERSION_GIT
+MODULE_INFO(extra_version_git, LTTNG_EXTRA_VERSION_GIT);
+#endif
+#ifdef LTTNG_EXTRA_VERSION_NAME
+MODULE_INFO(extra_version_name, LTTNG_EXTRA_VERSION_NAME);
+#endif
MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
MODULE_DESCRIPTION("LTTng Events");