#include <linux/file.h>
#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"
/*
* This is LTTng's own personal way to create a system call as an external
static const struct file_operations lttng_channel_fops;
static const struct file_operations lttng_metadata_fops;
static const struct file_operations lttng_event_fops;
+static struct file_operations lttng_stream_ring_buffer_file_operations;
/*
* Teardown management: opened file descriptors keep a refcount on the module,
* so it can only exit when all file descriptors are closed.
*/
-enum channel_type {
- PER_CPU_CHANNEL,
- METADATA_CHANNEL,
-};
-
static
int lttng_abi_create_session(void)
{
session = lttng_session_create();
if (!session)
return -ENOMEM;
- session_fd = get_unused_fd();
+ session_fd = lttng_get_unused_fd();
if (session_fd < 0) {
ret = session_fd;
goto fd_error;
struct file *tracepoint_list_file;
int file_fd, ret;
- file_fd = get_unused_fd();
+ file_fd = lttng_get_unused_fd();
if (file_fd < 0) {
ret = file_fd;
goto fd_error;
}
- tracepoint_list_file = anon_inode_getfile("[lttng_session]",
+ tracepoint_list_file = anon_inode_getfile("[lttng_tracepoint_list]",
<tng_tracepoint_list_fops,
NULL, O_RDWR);
if (IS_ERR(tracepoint_list_file)) {
v->patchlevel = LTTNG_MODULES_PATCHLEVEL_VERSION;
}
+static
+void lttng_abi_tracer_abi_version(struct lttng_kernel_tracer_abi_version *v)
+{
+ v->major = LTTNG_MODULES_ABI_MAJOR_VERSION;
+ v->minor = LTTNG_MODULES_ABI_MINOR_VERSION;
+}
+
static
long lttng_abi_add_context(struct file *file,
struct lttng_kernel_context *context_param,
* Returns a file descriptor listing available tracepoints
* LTTNG_KERNEL_WAIT_QUIESCENT
* Returns after all previously running probes have completed
+ * LTTNG_KERNEL_TRACER_ABI_VERSION
+ * Returns the LTTng kernel tracer ABI version
*
* The returned session will be deleted when its file descriptor is closed.
*/
(struct lttng_kernel_tracer_version __user *) arg;
lttng_abi_tracer_version(&version);
-
+
+ if (copy_to_user(uversion, &version, sizeof(version)))
+ return -EFAULT;
+ return 0;
+ }
+ case LTTNG_KERNEL_TRACER_ABI_VERSION:
+ {
+ struct lttng_kernel_tracer_abi_version version;
+ struct lttng_kernel_tracer_abi_version *uversion =
+ (struct lttng_kernel_tracer_abi_version __user *) arg;
+
+ lttng_abi_tracer_abi_version(&version);
+
if (copy_to_user(uversion, &version, sizeof(version)))
return -EFAULT;
return 0;
case LTTNG_KERNEL_OLD_TRACEPOINT_LIST:
case LTTNG_KERNEL_TRACEPOINT_LIST:
return lttng_abi_tracepoint_list();
+ case LTTNG_KERNEL_SYSCALL_LIST:
+ return lttng_abi_syscall_list();
case LTTNG_KERNEL_OLD_WAIT_QUIESCENT:
case LTTNG_KERNEL_WAIT_QUIESCENT:
synchronize_trace();
int chan_fd;
int ret = 0;
- chan_fd = get_unused_fd();
+ chan_fd = lttng_get_unused_fd();
if (chan_fd < 0) {
ret = chan_fd;
goto fd_error;
chan_param->subbuf_size,
chan_param->num_subbuf,
chan_param->switch_timer_interval,
- chan_param->read_timer_interval);
+ chan_param->read_timer_interval,
+ channel_type);
if (!chan) {
ret = -EINVAL;
goto chan_error;
chan->file = chan_file;
chan_file->private_data = chan;
fd_install(chan_fd, chan_file);
- if (channel_type == METADATA_CHANNEL) {
- session->metadata = chan;
- }
-
- /* The channel created holds a reference on the session */
atomic_long_inc(&session_file->f_count);
return chan_fd;
#endif
};
+/**
+ * lttng_metadata_ring_buffer_poll - LTTng ring buffer poll file operation
+ * @filp: the file
+ * @wait: poll table
+ *
+ * Handles the poll operations for the metadata channels.
+ */
static
-int lttng_abi_open_stream(struct file *channel_file)
+unsigned int lttng_metadata_ring_buffer_poll(struct file *filp,
+ poll_table *wait)
+{
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+ int finalized;
+ unsigned int mask = 0;
+
+ if (filp->f_mode & FMODE_READ) {
+ poll_wait_set_exclusive(wait);
+ poll_wait(filp, &stream->read_wait, wait);
+
+ finalized = stream->finalized;
+
+ /*
+ * lib_ring_buffer_is_finalized() contains a smp_rmb()
+ * ordering finalized load before offsets loads.
+ */
+ WARN_ON(atomic_long_read(&buf->active_readers) != 1);
+
+ if (finalized)
+ mask |= POLLHUP;
+
+ if (stream->metadata_cache->metadata_written >
+ stream->metadata_out)
+ mask |= POLLIN;
+ }
+
+ return mask;
+}
+
+static
+void lttng_metadata_ring_buffer_ioctl_put_next_subbuf(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ struct lttng_metadata_stream *stream = filp->private_data;
+
+ stream->metadata_out = stream->metadata_in;
+}
+
+static
+long lttng_metadata_ring_buffer_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ int ret;
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+
+ switch (cmd) {
+ case RING_BUFFER_GET_NEXT_SUBBUF:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+ struct channel *chan = buf->backend.chan;
+
+ ret = lttng_metadata_output_channel(stream, chan);
+ if (ret > 0) {
+ lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
+ ret = 0;
+ } else if (ret < 0)
+ goto err;
+ break;
+ }
+ case RING_BUFFER_GET_SUBBUF:
+ {
+ /*
+ * Random access is not allowed for metadata channel.
+ */
+ return -ENOSYS;
+ }
+ 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;
+ }
+ default:
+ break;
+ }
+ /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
+
+ /* Performing lib ring buffer ioctl after our own. */
+ ret = lib_ring_buffer_ioctl(filp, cmd, arg, buf);
+ if (ret < 0)
+ goto err;
+
+ switch (cmd) {
+ case RING_BUFFER_PUT_NEXT_SUBBUF:
+ {
+ lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
+ cmd, arg);
+ break;
+ }
+ default:
+ break;
+ }
+err:
+ return ret;
+}
+
+#ifdef CONFIG_COMPAT
+static
+long lttng_metadata_ring_buffer_compat_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ int ret;
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+
+ switch (cmd) {
+ case RING_BUFFER_GET_NEXT_SUBBUF:
+ {
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+ struct channel *chan = buf->backend.chan;
+
+ ret = lttng_metadata_output_channel(stream, chan);
+ if (ret > 0) {
+ lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
+ ret = 0;
+ } else if (ret < 0)
+ goto err;
+ break;
+ }
+ case RING_BUFFER_GET_SUBBUF:
+ {
+ /*
+ * Random access is not allowed for metadata channel.
+ */
+ return -ENOSYS;
+ }
+ default:
+ break;
+ }
+ /* PUT_SUBBUF is the one from lib ring buffer, unmodified. */
+
+ /* Performing lib ring buffer ioctl after our own. */
+ ret = lib_ring_buffer_compat_ioctl(filp, cmd, arg, buf);
+ if (ret < 0)
+ goto err;
+
+ switch (cmd) {
+ case RING_BUFFER_PUT_NEXT_SUBBUF:
+ {
+ lttng_metadata_ring_buffer_ioctl_put_next_subbuf(filp,
+ cmd, arg);
+ break;
+ }
+ default:
+ break;
+ }
+err:
+ return ret;
+}
+#endif
+
+/*
+ * This is not used by anonymous file descriptors. This code is left
+ * there if we ever want to implement an inode with open() operation.
+ */
+static
+int lttng_metadata_ring_buffer_open(struct inode *inode, struct file *file)
+{
+ struct lttng_metadata_stream *stream = inode->i_private;
+ struct lib_ring_buffer *buf = stream->priv;
+
+ file->private_data = buf;
+ /*
+ * Since life-time of metadata cache differs from that of
+ * session, we need to keep our own reference on the transport.
+ */
+ if (!try_module_get(stream->transport->owner)) {
+ printk(KERN_WARNING "LTT : Can't lock transport module.\n");
+ return -EBUSY;
+ }
+ return lib_ring_buffer_open(inode, file, buf);
+}
+
+static
+int lttng_metadata_ring_buffer_release(struct inode *inode, struct file *file)
+{
+ struct lttng_metadata_stream *stream = file->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+
+ kref_put(&stream->metadata_cache->refcount, metadata_cache_destroy);
+ module_put(stream->transport->owner);
+ return lib_ring_buffer_release(inode, file, buf);
+}
+
+static
+ssize_t lttng_metadata_ring_buffer_splice_read(struct file *in, loff_t *ppos,
+ struct pipe_inode_info *pipe, size_t len,
+ unsigned int flags)
+{
+ struct lttng_metadata_stream *stream = in->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+
+ return lib_ring_buffer_splice_read(in, ppos, pipe, len,
+ flags, buf);
+}
+
+static
+int lttng_metadata_ring_buffer_mmap(struct file *filp,
+ struct vm_area_struct *vma)
+{
+ struct lttng_metadata_stream *stream = filp->private_data;
+ struct lib_ring_buffer *buf = stream->priv;
+
+ return lib_ring_buffer_mmap(filp, vma, buf);
+}
+
+static
+const struct file_operations lttng_metadata_ring_buffer_file_operations = {
+ .owner = THIS_MODULE,
+ .open = lttng_metadata_ring_buffer_open,
+ .release = lttng_metadata_ring_buffer_release,
+ .poll = lttng_metadata_ring_buffer_poll,
+ .splice_read = lttng_metadata_ring_buffer_splice_read,
+ .mmap = lttng_metadata_ring_buffer_mmap,
+ .unlocked_ioctl = lttng_metadata_ring_buffer_ioctl,
+ .llseek = vfs_lib_ring_buffer_no_llseek,
+#ifdef CONFIG_COMPAT
+ .compat_ioctl = lttng_metadata_ring_buffer_compat_ioctl,
+#endif
+};
+
+static
+int lttng_abi_create_stream_fd(struct file *channel_file, void *stream_priv,
+ const struct file_operations *fops)
{
- struct lttng_channel *channel = channel_file->private_data;
- struct lib_ring_buffer *buf;
int stream_fd, ret;
struct file *stream_file;
- buf = channel->ops->buffer_read_open(channel->chan);
- if (!buf)
- return -ENOENT;
-
- stream_fd = get_unused_fd();
+ stream_fd = lttng_get_unused_fd();
if (stream_fd < 0) {
ret = stream_fd;
goto fd_error;
}
- stream_file = anon_inode_getfile("[lttng_stream]",
- &lib_ring_buffer_file_operations,
- buf, O_RDWR);
+ stream_file = anon_inode_getfile("[lttng_stream]", fops,
+ stream_priv, O_RDWR);
if (IS_ERR(stream_file)) {
ret = PTR_ERR(stream_file);
goto file_error;
file_error:
put_unused_fd(stream_fd);
fd_error:
+ return ret;
+}
+
+static
+int lttng_abi_open_stream(struct file *channel_file)
+{
+ struct lttng_channel *channel = channel_file->private_data;
+ struct lib_ring_buffer *buf;
+ int ret;
+ void *stream_priv;
+
+ buf = channel->ops->buffer_read_open(channel->chan);
+ if (!buf)
+ return -ENOENT;
+
+ stream_priv = buf;
+ ret = lttng_abi_create_stream_fd(channel_file, stream_priv,
+ <tng_stream_ring_buffer_file_operations);
+ if (ret < 0)
+ goto fd_error;
+
+ return ret;
+
+fd_error:
+ channel->ops->buffer_read_close(buf);
+ return ret;
+}
+
+static
+int lttng_abi_open_metadata_stream(struct file *channel_file)
+{
+ struct lttng_channel *channel = channel_file->private_data;
+ struct lttng_session *session = channel->session;
+ struct lib_ring_buffer *buf;
+ int ret;
+ struct lttng_metadata_stream *metadata_stream;
+ void *stream_priv;
+
+ buf = channel->ops->buffer_read_open(channel->chan);
+ if (!buf)
+ return -ENOENT;
+
+ metadata_stream = kzalloc(sizeof(struct lttng_metadata_stream),
+ GFP_KERNEL);
+ if (!metadata_stream) {
+ ret = -ENOMEM;
+ goto nomem;
+ }
+ metadata_stream->metadata_cache = session->metadata_cache;
+ init_waitqueue_head(&metadata_stream->read_wait);
+ 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
+ * session, we need to keep our own reference on the transport.
+ */
+ if (!try_module_get(metadata_stream->transport->owner)) {
+ printk(KERN_WARNING "LTT : Can't lock transport module.\n");
+ ret = -EINVAL;
+ goto notransport;
+ }
+
+ 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:
+ module_put(metadata_stream->transport->owner);
+notransport:
+ kfree(metadata_stream);
+nomem:
channel->ops->buffer_read_close(buf);
return ret;
}
}
switch (event_param->instrumentation) {
default:
- event_fd = get_unused_fd();
+ event_fd = lttng_get_unused_fd();
if (event_fd < 0) {
ret = event_fd;
goto fd_error;
* will stay invariant for the rest of the session.
*/
event = lttng_event_create(channel, event_param, NULL, NULL);
- if (!event) {
- ret = -EINVAL;
+ WARN_ON_ONCE(!event);
+ if (IS_ERR(event)) {
+ ret = PTR_ERR(event);
goto event_error;
}
event_file->private_data = event;
atomic_long_inc(&channel_file->f_count);
break;
case LTTNG_KERNEL_SYSCALL:
- /*
- * Only all-syscall tracing supported for now.
- */
- if (event_param->name[0] != '\0')
- return -EINVAL;
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,
+ event_param->name[0] == '\0' ?
+ NULL : event_param->name);
+ if (ret)
+ goto fd_error;
+
+ } else {
+ ret = lttng_syscall_filter_disable(channel,
+ event_param->name[0] == '\0' ?
+ NULL : event_param->name);
+ if (ret)
+ goto fd_error;
+ }
break;
}
return event_fd;
case LTTNG_KERNEL_OLD_DISABLE:
case LTTNG_KERNEL_DISABLE:
return lttng_channel_disable(channel);
+ case LTTNG_KERNEL_SYSCALL_MASK:
+ return lttng_channel_syscall_mask(channel,
+ (struct lttng_kernel_syscall_mask __user *) arg);
default:
return -ENOIOCTLCMD;
}
switch (cmd) {
case LTTNG_KERNEL_OLD_STREAM:
case LTTNG_KERNEL_STREAM:
- return lttng_abi_open_stream(file);
+ return lttng_abi_open_metadata_stream(file);
default:
return -ENOIOCTLCMD;
}
return 0;
}
+static
+int lttng_metadata_channel_release(struct inode *inode, struct file *file)
+{
+ struct lttng_channel *channel = file->private_data;
+
+ if (channel) {
+ lttng_metadata_channel_destroy(channel);
+ fput(channel->session->file);
+ }
+
+ return 0;
+}
+
static const struct file_operations lttng_channel_fops = {
.owner = THIS_MODULE,
.release = lttng_channel_release,
static const struct file_operations lttng_metadata_fops = {
.owner = THIS_MODULE,
- .release = lttng_channel_release,
+ .release = lttng_metadata_channel_release,
.unlocked_ioctl = lttng_metadata_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = lttng_metadata_ioctl,
#endif
};
+static int put_u64(uint64_t val, unsigned long arg)
+{
+ return put_user(val, (uint64_t __user *) arg);
+}
+
+static long lttng_stream_ring_buffer_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ struct lib_ring_buffer *buf = filp->private_data;
+ struct channel *chan = buf->backend.chan;
+ const struct lib_ring_buffer_config *config = &chan->backend.config;
+ const struct lttng_channel_ops *ops = chan->backend.priv_ops;
+ int ret;
+
+ if (atomic_read(&chan->record_disabled))
+ return -EIO;
+
+ switch (cmd) {
+ case LTTNG_RING_BUFFER_GET_TIMESTAMP_BEGIN:
+ {
+ uint64_t ts;
+
+ ret = ops->timestamp_begin(config, buf, &ts);
+ if (ret < 0)
+ goto error;
+ return put_u64(ts, arg);
+ }
+ case LTTNG_RING_BUFFER_GET_TIMESTAMP_END:
+ {
+ uint64_t ts;
+
+ ret = ops->timestamp_end(config, buf, &ts);
+ if (ret < 0)
+ goto error;
+ return put_u64(ts, arg);
+ }
+ case LTTNG_RING_BUFFER_GET_EVENTS_DISCARDED:
+ {
+ uint64_t ed;
+
+ ret = ops->events_discarded(config, buf, &ed);
+ if (ret < 0)
+ goto error;
+ return put_u64(ed, arg);
+ }
+ case LTTNG_RING_BUFFER_GET_CONTENT_SIZE:
+ {
+ uint64_t cs;
+
+ ret = ops->content_size(config, buf, &cs);
+ if (ret < 0)
+ goto error;
+ return put_u64(cs, arg);
+ }
+ case LTTNG_RING_BUFFER_GET_PACKET_SIZE:
+ {
+ uint64_t ps;
+
+ ret = ops->packet_size(config, buf, &ps);
+ if (ret < 0)
+ goto error;
+ return put_u64(ps, arg);
+ }
+ case LTTNG_RING_BUFFER_GET_STREAM_ID:
+ {
+ uint64_t si;
+
+ ret = ops->stream_id(config, buf, &si);
+ if (ret < 0)
+ goto error;
+ return put_u64(si, arg);
+ }
+ case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP:
+ {
+ uint64_t ts;
+
+ ret = ops->current_timestamp(config, buf, &ts);
+ if (ret < 0)
+ goto error;
+ return put_u64(ts, arg);
+ }
+ default:
+ return lib_ring_buffer_file_operations.unlocked_ioctl(filp,
+ cmd, arg);
+ }
+
+error:
+ return -ENOSYS;
+}
+
+#ifdef CONFIG_COMPAT
+static long lttng_stream_ring_buffer_compat_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long arg)
+{
+ struct lib_ring_buffer *buf = filp->private_data;
+ struct channel *chan = buf->backend.chan;
+ const struct lib_ring_buffer_config *config = &chan->backend.config;
+ const struct lttng_channel_ops *ops = chan->backend.priv_ops;
+ int ret;
+
+ if (atomic_read(&chan->record_disabled))
+ return -EIO;
+
+ switch (cmd) {
+ case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_BEGIN:
+ {
+ uint64_t ts;
+
+ ret = ops->timestamp_begin(config, buf, &ts);
+ if (ret < 0)
+ goto error;
+ return put_u64(ts, arg);
+ }
+ case LTTNG_RING_BUFFER_COMPAT_GET_TIMESTAMP_END:
+ {
+ uint64_t ts;
+
+ ret = ops->timestamp_end(config, buf, &ts);
+ if (ret < 0)
+ goto error;
+ return put_u64(ts, arg);
+ }
+ case LTTNG_RING_BUFFER_COMPAT_GET_EVENTS_DISCARDED:
+ {
+ uint64_t ed;
+
+ ret = ops->events_discarded(config, buf, &ed);
+ if (ret < 0)
+ goto error;
+ return put_u64(ed, arg);
+ }
+ case LTTNG_RING_BUFFER_COMPAT_GET_CONTENT_SIZE:
+ {
+ uint64_t cs;
+
+ ret = ops->content_size(config, buf, &cs);
+ if (ret < 0)
+ goto error;
+ return put_u64(cs, arg);
+ }
+ case LTTNG_RING_BUFFER_COMPAT_GET_PACKET_SIZE:
+ {
+ uint64_t ps;
+
+ ret = ops->packet_size(config, buf, &ps);
+ if (ret < 0)
+ goto error;
+ return put_u64(ps, arg);
+ }
+ case LTTNG_RING_BUFFER_COMPAT_GET_STREAM_ID:
+ {
+ uint64_t si;
+
+ ret = ops->stream_id(config, buf, &si);
+ if (ret < 0)
+ goto error;
+ return put_u64(si, arg);
+ }
+ case LTTNG_RING_BUFFER_GET_CURRENT_TIMESTAMP:
+ {
+ uint64_t ts;
+
+ ret = ops->current_timestamp(config, buf, &ts);
+ if (ret < 0)
+ goto error;
+ return put_u64(ts, arg);
+ }
+ default:
+ return lib_ring_buffer_file_operations.compat_ioctl(filp,
+ cmd, arg);
+ }
+
+error:
+ return -ENOSYS;
+}
+#endif /* CONFIG_COMPAT */
+
+static void lttng_stream_override_ring_buffer_fops(void)
+{
+ lttng_stream_ring_buffer_file_operations.owner = THIS_MODULE;
+ lttng_stream_ring_buffer_file_operations.open =
+ lib_ring_buffer_file_operations.open;
+ lttng_stream_ring_buffer_file_operations.release =
+ lib_ring_buffer_file_operations.release;
+ lttng_stream_ring_buffer_file_operations.poll =
+ lib_ring_buffer_file_operations.poll;
+ lttng_stream_ring_buffer_file_operations.splice_read =
+ lib_ring_buffer_file_operations.splice_read;
+ lttng_stream_ring_buffer_file_operations.mmap =
+ lib_ring_buffer_file_operations.mmap;
+ lttng_stream_ring_buffer_file_operations.unlocked_ioctl =
+ lttng_stream_ring_buffer_ioctl;
+ lttng_stream_ring_buffer_file_operations.llseek =
+ lib_ring_buffer_file_operations.llseek;
+#ifdef CONFIG_COMPAT
+ lttng_stream_ring_buffer_file_operations.compat_ioctl =
+ lttng_stream_ring_buffer_compat_ioctl;
+#endif
+}
+
int __init lttng_abi_init(void)
{
int ret = 0;
ret = -ENOMEM;
goto error;
}
+ lttng_stream_override_ring_buffer_fops();
+
error:
return ret;
}
-void __exit lttng_abi_exit(void)
+/* No __exit annotation because used by init error path too. */
+void lttng_abi_exit(void)
{
if (lttng_proc_dentry)
remove_proc_entry("lttng", NULL);
projects / lttng-modules.git / blobdiff