-/*
+/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
+ *
* lttng-abi.c
*
* LTTng ABI
*
* Copyright (C) 2010-2012 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
- *
- *
* Mimic system calls for:
* - session creation, returns a file descriptor or failure.
* - channel creation, returns a file descriptor or failure.
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/err.h>
-#include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */
-#include "wrapper/ringbuffer/vfs.h"
-#include "wrapper/ringbuffer/backend.h"
-#include "wrapper/ringbuffer/frontend.h"
-#include "wrapper/poll.h"
-#include "wrapper/file.h"
-#include "lttng-abi.h"
-#include "lttng-abi-old.h"
-#include "lttng-events.h"
-#include "lttng-tracer.h"
-#include "lib/ringbuffer/frontend_types.h"
+#include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_all() */
+#include <wrapper/ringbuffer/vfs.h>
+#include <wrapper/ringbuffer/backend.h>
+#include <wrapper/ringbuffer/frontend.h>
+#include <wrapper/poll.h>
+#include <wrapper/file.h>
+#include <wrapper/kref.h>
+#include <lttng-string-utils.h>
+#include <lttng-abi.h>
+#include <lttng-abi-old.h>
+#include <lttng-events.h>
+#include <lttng-tracer.h>
+#include <lttng-tp-mempool.h>
+#include <lib/ringbuffer/frontend_types.h>
/*
* This is LTTng's own personal way to create a system call as an external
static const struct file_operations lttng_event_fops;
static struct file_operations lttng_stream_ring_buffer_file_operations;
+static int put_u64(uint64_t val, unsigned long arg);
+
/*
* Teardown management: opened file descriptors keep a refcount on the module,
* so it can only exit when all file descriptors are closed.
if (ret < 0)
goto open_error;
fd_install(file_fd, tracepoint_list_file);
+ return file_fd;
+
+open_error:
+ fput(tracepoint_list_file);
+file_error:
+ put_unused_fd(file_fd);
+fd_error:
+ return ret;
+}
+
+#ifndef CONFIG_HAVE_SYSCALL_TRACEPOINTS
+static inline
+int lttng_abi_syscall_list(void)
+{
+ return -ENOSYS;
+}
+#else
+static
+int lttng_abi_syscall_list(void)
+{
+ struct file *syscall_list_file;
+ int file_fd, ret;
+
+ file_fd = lttng_get_unused_fd();
if (file_fd < 0) {
ret = file_fd;
goto fd_error;
}
+
+ syscall_list_file = anon_inode_getfile("[lttng_syscall_list]",
+ <tng_syscall_list_fops,
+ NULL, O_RDWR);
+ if (IS_ERR(syscall_list_file)) {
+ ret = PTR_ERR(syscall_list_file);
+ goto file_error;
+ }
+ ret = lttng_syscall_list_fops.open(NULL, syscall_list_file);
+ if (ret < 0)
+ goto open_error;
+ fd_install(file_fd, syscall_list_file);
return file_fd;
open_error:
- fput(tracepoint_list_file);
+ fput(syscall_list_file);
file_error:
put_unused_fd(file_fd);
fd_error:
return ret;
}
+#endif
static
void lttng_abi_tracer_version(struct lttng_kernel_tracer_version *v)
return lttng_add_procname_to_ctx(ctx);
case LTTNG_KERNEL_CONTEXT_HOSTNAME:
return lttng_add_hostname_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_CPU_ID:
+ return lttng_add_cpu_id_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE:
+ return lttng_add_interruptible_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE:
+ return lttng_add_need_reschedule_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE:
+ return lttng_add_preemptible_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_MIGRATABLE:
+ return lttng_add_migratable_to_ctx(ctx);
+ case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL:
+ case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER:
+ return lttng_add_callstack_to_ctx(ctx, context_param->ctx);
default:
return -EINVAL;
}
fops = <tng_metadata_fops;
break;
}
-
+
chan_file = anon_inode_getfile("[lttng_channel]",
fops,
NULL, O_RDWR);
transport_name = "<unknown>";
break;
}
+ if (atomic_long_add_unless(&session_file->f_count,
+ 1, INT_MAX) == INT_MAX) {
+ goto refcount_error;
+ }
/*
* We tolerate no failure path after channel creation. It will stay
* invariant for the rest of the session.
chan->file = chan_file;
chan_file->private_data = chan;
fd_install(chan_fd, chan_file);
- atomic_long_inc(&session_file->f_count);
return chan_fd;
chan_error:
+ atomic_long_dec(&session_file->f_count);
+refcount_error:
fput(chan_file);
file_error:
put_unused_fd(chan_fd);
return lttng_session_untrack_pid(session, (int) arg);
case LTTNG_KERNEL_SESSION_LIST_TRACKER_PIDS:
return lttng_session_list_tracker_pids(session);
+ case LTTNG_KERNEL_SESSION_METADATA_REGEN:
+ return lttng_session_metadata_regenerate(session);
+ case LTTNG_KERNEL_SESSION_STATEDUMP:
+ return lttng_session_statedump(session);
default:
return -ENOIOCTLCMD;
}
if (finalized)
mask |= POLLHUP;
+ mutex_lock(&stream->metadata_cache->lock);
if (stream->metadata_cache->metadata_written >
stream->metadata_out)
mask |= POLLIN;
+ mutex_unlock(&stream->metadata_cache->lock);
}
return mask;
stream->metadata_out = stream->metadata_in;
}
+/*
+ * Reset the counter of how much metadata has been consumed to 0. That way,
+ * the consumer receives the content of the metadata cache unchanged. This is
+ * different from the metadata_regenerate where the offset from epoch is
+ * resampled, here we want the exact same content as the last time the metadata
+ * was generated. This command is only possible if all the metadata written
+ * in the cache has been output to the metadata stream to avoid corrupting the
+ * metadata file.
+ *
+ * Return 0 on success, a negative value on error.
+ */
+static
+int lttng_metadata_cache_dump(struct lttng_metadata_stream *stream)
+{
+ int ret;
+ struct lttng_metadata_cache *cache = stream->metadata_cache;
+
+ mutex_lock(&cache->lock);
+ if (stream->metadata_out != cache->metadata_written) {
+ ret = -EBUSY;
+ goto end;
+ }
+ stream->metadata_out = 0;
+ stream->metadata_in = 0;
+ wake_up_interruptible(&stream->read_wait);
+ ret = 0;
+
+end:
+ mutex_unlock(&cache->lock);
+ return ret;
+}
+
static
long lttng_metadata_ring_buffer_ioctl(struct file *filp,
unsigned int cmd, unsigned long arg)
*/
return -ENOSYS;
}
+ case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
case RING_BUFFER_FLUSH:
{
struct lttng_metadata_stream *stream = filp->private_data;
goto err;
break;
}
+ case RING_BUFFER_GET_METADATA_VERSION:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+
+ return put_u64(stream->version, arg);
+ }
+ case RING_BUFFER_METADATA_CACHE_DUMP:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+
+ return lttng_metadata_cache_dump(stream);
+ }
default:
break;
}
*/
return -ENOSYS;
}
+ case RING_BUFFER_FLUSH_EMPTY: /* Fall-through. */
+ case RING_BUFFER_FLUSH:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+ struct channel *chan = buf->backend.chan;
+
+ /*
+ * Before doing the actual ring buffer flush, write up to one
+ * packet of metadata in the ring buffer.
+ */
+ ret = lttng_metadata_output_channel(stream, chan);
+ if (ret < 0)
+ goto err;
+ break;
+ }
+ case RING_BUFFER_GET_METADATA_VERSION:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+
+ return put_u64(stream->version, arg);
+ }
+ case RING_BUFFER_METADATA_CACHE_DUMP:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+
+ return lttng_metadata_cache_dump(stream);
+ }
default:
break;
}
metadata_stream->priv = buf;
stream_priv = metadata_stream;
metadata_stream->transport = channel->transport;
- mutex_init(&metadata_stream->lock);
/*
* Since life-time of metadata cache differs from that of
goto notransport;
}
+ if (!lttng_kref_get(&session->metadata_cache->refcount)) {
+ ret = -EOVERFLOW;
+ goto kref_error;
+ }
+
ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
<tng_metadata_ring_buffer_file_operations);
if (ret < 0)
goto fd_error;
- kref_get(&session->metadata_cache->refcount);
list_add(&metadata_stream->list,
&session->metadata_cache->metadata_stream);
return ret;
fd_error:
+ kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
+kref_error:
module_put(metadata_stream->transport->owner);
notransport:
kfree(metadata_stream);
default:
break;
}
- switch (event_param->instrumentation) {
- default:
- event_fd = lttng_get_unused_fd();
- if (event_fd < 0) {
- ret = event_fd;
- goto fd_error;
- }
- event_file = anon_inode_getfile("[lttng_event]",
- <tng_event_fops,
- NULL, O_RDWR);
- if (IS_ERR(event_file)) {
- ret = PTR_ERR(event_file);
- goto file_error;
- }
- if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT) {
- struct lttng_enabler *enabler;
-
- if (event_param->name[strlen(event_param->name) - 1] == '*') {
- enabler = lttng_enabler_create(LTTNG_ENABLER_WILDCARD,
- event_param, channel);
- } else {
- enabler = lttng_enabler_create(LTTNG_ENABLER_NAME,
- event_param, channel);
- }
- priv = enabler;
- } else {
- struct lttng_event *event;
+ event_fd = lttng_get_unused_fd();
+ if (event_fd < 0) {
+ ret = event_fd;
+ goto fd_error;
+ }
+ event_file = anon_inode_getfile("[lttng_event]",
+ <tng_event_fops,
+ NULL, O_RDWR);
+ if (IS_ERR(event_file)) {
+ ret = PTR_ERR(event_file);
+ goto file_error;
+ }
+ /* The event holds a reference on the channel */
+ if (atomic_long_add_unless(&channel_file->f_count,
+ 1, INT_MAX) == INT_MAX) {
+ ret = -EOVERFLOW;
+ goto refcount_error;
+ }
+ if (event_param->instrumentation == LTTNG_KERNEL_TRACEPOINT
+ || event_param->instrumentation == LTTNG_KERNEL_SYSCALL) {
+ struct lttng_enabler *enabler;
+ if (strutils_is_star_glob_pattern(event_param->name)) {
/*
- * We tolerate no failure path after event creation. It
- * will stay invariant for the rest of the session.
+ * If the event name is a star globbing pattern,
+ * we create the special star globbing enabler.
*/
- event = lttng_event_create(channel, event_param,
- NULL, NULL,
- event_param->instrumentation);
- WARN_ON_ONCE(!event);
- if (IS_ERR(event)) {
- ret = PTR_ERR(event);
- goto event_error;
- }
- priv = event;
+ enabler = lttng_enabler_create(LTTNG_ENABLER_STAR_GLOB,
+ event_param, channel);
+ } else {
+ enabler = lttng_enabler_create(LTTNG_ENABLER_NAME,
+ event_param, channel);
}
- event_file->private_data = priv;
- fd_install(event_fd, event_file);
- /* The event holds a reference on the channel */
- atomic_long_inc(&channel_file->f_count);
- break;
- case LTTNG_KERNEL_SYSCALL:
- ret = lttng_syscalls_register(channel, NULL);
- if (ret)
- goto fd_error;
- event_fd = 0;
- if (event_param->u.syscall.enable) {
- ret = lttng_syscall_filter_enable(channel,
- !strcmp(event_param->name, "*") ?
- NULL : event_param->name);
- if (ret)
- goto fd_error;
+ priv = enabler;
+ } else {
+ struct lttng_event *event;
- } else {
- ret = lttng_syscall_filter_disable(channel,
- !strcmp(event_param->name, "*") ?
- NULL : event_param->name);
- if (ret)
- goto fd_error;
+ /*
+ * We tolerate no failure path after event creation. It
+ * will stay invariant for the rest of the session.
+ */
+ event = lttng_event_create(channel, event_param,
+ NULL, NULL,
+ event_param->instrumentation);
+ WARN_ON_ONCE(!event);
+ if (IS_ERR(event)) {
+ ret = PTR_ERR(event);
+ goto event_error;
}
- break;
+ priv = event;
}
+ event_file->private_data = priv;
+ fd_install(event_fd, event_file);
return event_fd;
event_error:
+ atomic_long_dec(&channel_file->f_count);
+refcount_error:
fput(event_file);
file_error:
put_unused_fd(event_fd);
default:
return -ENOIOCTLCMD;
}
-
}
/**
struct lttng_channel *channel = file->private_data;
if (channel) {
- lttng_metadata_channel_destroy(channel);
fput(channel->session->file);
+ lttng_metadata_channel_destroy(channel);
}
return 0;
WARN_ON_ONCE(1);
return -ENOSYS;
}
+ case LTTNG_KERNEL_FILTER:
+ switch (*evtype) {
+ case LTTNG_TYPE_EVENT:
+ return -EINVAL;
+ case LTTNG_TYPE_ENABLER:
+ {
+ enabler = file->private_data;
+ return lttng_enabler_attach_bytecode(enabler,
+ (struct lttng_kernel_filter_bytecode __user *) arg);
+ }
+ default:
+ WARN_ON_ONCE(1);
+ return -ENOSYS;
+ }
+ case LTTNG_KERNEL_ADD_CALLSITE:
+ switch (*evtype) {
+ case LTTNG_TYPE_EVENT:
+ event = file->private_data;
+ return lttng_event_add_callsite(event,
+ (struct lttng_kernel_event_callsite __user *) arg);
+ case LTTNG_TYPE_ENABLER:
+ return -EINVAL;
+ }
default:
return -ENOIOCTLCMD;
}
goto error;
return put_u64(ts, arg);
}
+ case LTTNG_RING_BUFFER_GET_SEQ_NUM:
+ {
+ uint64_t seq;
+
+ ret = ops->sequence_number(config, buf, &seq);
+ if (ret < 0)
+ goto error;
+ return put_u64(seq, arg);
+ }
+ case LTTNG_RING_BUFFER_INSTANCE_ID:
+ {
+ uint64_t id;
+
+ ret = ops->instance_id(config, buf, &id);
+ if (ret < 0)
+ goto error;
+ return put_u64(id, arg);
+ }
default:
return lib_ring_buffer_file_operations.unlocked_ioctl(filp,
cmd, arg);
goto error;
return put_u64(ts, arg);
}
+ case LTTNG_RING_BUFFER_COMPAT_GET_SEQ_NUM:
+ {
+ uint64_t seq;
+
+ ret = ops->sequence_number(config, buf, &seq);
+ if (ret < 0)
+ goto error;
+ return put_u64(seq, arg);
+ }
+ case LTTNG_RING_BUFFER_COMPAT_INSTANCE_ID:
+ {
+ uint64_t id;
+
+ ret = ops->instance_id(config, buf, &id);
+ if (ret < 0)
+ goto error;
+ return put_u64(id, arg);
+ }
default:
return lib_ring_buffer_file_operations.compat_ioctl(filp,
cmd, arg);
int ret = 0;
wrapper_vmalloc_sync_all();
+ lttng_clock_ref();
+
+ ret = lttng_tp_mempool_init();
+ if (ret) {
+ goto error;
+ }
+
lttng_proc_dentry = proc_create_data("lttng", S_IRUSR | S_IWUSR, NULL,
<tng_fops, NULL);
-
+
if (!lttng_proc_dentry) {
printk(KERN_ERR "Error creating LTTng control file\n");
ret = -ENOMEM;
goto error;
}
lttng_stream_override_ring_buffer_fops();
+ return 0;
error:
+ lttng_tp_mempool_destroy();
+ lttng_clock_unref();
return ret;
}
/* No __exit annotation because used by init error path too. */
void lttng_abi_exit(void)
{
+ lttng_tp_mempool_destroy();
+ lttng_clock_unref();
if (lttng_proc_dentry)
remove_proc_entry("lttng", NULL);
}
projects / lttng-modules.git / blobdiff