[lttng-modules.git] / ltt-debugfs-abi.c

/*
 * ltt-debugfs-abi.c
 *
 * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * LTTng debugfs ABI
 *
 * Mimic system calls for:
 * - session creation, returns a file descriptor or failure.
 *   - channel creation, returns a file descriptor or failure.
 *     - Operates on a session file descriptor
 *     - Takes all channel options as parameters.
 *   - stream get, returns a file descriptor or failure.
 *     - Operates on a channel file descriptor.
 *   - stream notifier get, returns a file descriptor or failure.
 *     - Operates on a channel file descriptor.
 *   - event creation, returns a file descriptor or failure.
 *     - Operates on a channel file descriptor
 *     - Takes an event name as parameter
 *     - Takes an instrumentation source as parameter
 *       - e.g. tracepoints, dynamic_probes...
 *     - Takes instrumentation source specific arguments.
 */

#include <linux/debugfs.h>
#include "ltt-events.h"

/*
 * This is LTTng's own personal way to create a system call as an external
 * module. We use ioctl() on /sys/kernel/debug/lttng.
 */

static struct dentry *lttng_dentry;
static const struct file_operations lttng_fops;
static const struct file_operations lttng_session_fops;
static const struct file_operations lttng_channel_fops;
static const struct file_operations lttng_event_fops;

/*
 * LTTng DebugFS ABI structures.
 */

struct lttng_channel {
	int overwrite;			/* 1: overwrite, 0: discard */
	u64 subbuf_size;
	u64 num_subbuf;
	unsigned int switch_timer_interval;
	unsigned int read_timer_interval;
};

struct lttng_event {
	enum instrum_type itype;
	char name[];
};

static
int lttng_abi_create_session(void)
{
	struct ltt_session *session;
	struct file *session_file;
	int session_fd;

	session = ltt_session_create();
	if (!session)
		return -ENOMEM;
	session_fd = get_unused_fd_flags(O_RDWR);
	if (session_fd < 0) {
		ret = session_fd;
		goto fd_error;
	}
	session_file = anon_inode_getfile("[lttng_session]",
					  &lttng_session_fops,
					  session, O_RDWR);
	if (IS_ERR(session_file)) {
		ret = PTR_ERR(session_file);
		goto file_error;
	}
	session->file = session_file;
	fd_install(session_fd, session_file);
	return session_fd;

file_error:
	put_unused_fd(session_fd);
fd_error:
	ltt_session_destroy(session);
	return ret;
}

/**
 *	lttng_ioctl - lttng syscall through ioctl
 *
 *	@file: the file
 *	@cmd: the command
 *	@arg: command arg
 *
 *	This ioctl implements lttng commands:
 *	LTTNG_SESSION
 *		Returns a LTTng trace session file descriptor
 *
 * The returned session will be deleted when its file descriptor is closed.
 */
static
long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case LTTNG_SESSION:
		return lttng_abi_create_session();
	default:
		return -ENOIOCTLCMD;
	}
}

static const struct file_operations lttng_fops = {
	.unlocked_ioctl = lttng_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = lttng_ioctl,
#endif
}

int lttng_abi_create_channel(struct file *session_file,
			     struct lttng_channel __user *uchan_param)
{
	struct ltt_session *session = session_file->private_data;
	struct ltt_channel *chan;
	struct file *chan_file;
	struct lttng_channel chan_param;
	int chan_fd;
	int ret = 0;

	if (copy_from_user(&chan_param, uchan_param, sizeof(chan_param)))
		return -EFAULT;
	chan_fd = get_unused_fd_flags(O_RDWR);
	if (chan_fd < 0) {
		ret = chan_fd;
		goto fd_error;
	}
	chan_file = anon_inode_getfile("[lttng_channel]",
				       &lttng_channel_fops,
				       NULL, O_RDWR);
	if (IS_ERR(chan_file)) {
		ret = PTR_ERR(chan_file);
		goto file_error;
	}
	/*
	 * We tolerate no failure path after channel creation. It will stay
	 * invariant for the rest of the session.
	 */
	chan = ltt_channel_create(session, chan_param->overwrite, NULL,
				  chan_param->subbuf_size,
				  chan_param->num_subbuf,
				  chan_param->switch_timer_interval,
				  chan_param->read_timer_interval);
	if (!chan) {
		ret = -ENOMEM;
		goto chan_error;
	}
	channel->file = chan_file;
	chan_file->private_data = chan;
	fd_install(chan_fd, chan_file);
	/* The channel created holds a reference on the session */
	atomic_inc(&session_file->f_count);

	return chan_fd;

chan_error:
	fput(chan_file);
file_error:
	put_unused_fd(chan_fd);
fd_error:
	return ret;
}

/**
 *	lttng_session_ioctl - lttng session fd ioctl
 *
 *	@file: the file
 *	@cmd: the command
 *	@arg: command arg
 *
 *	This ioctl implements lttng commands:
 *	LTTNG_CHANNEL
 *		Returns a LTTng channel file descriptor
 *
 * The returned channel will be deleted when its file descriptor is closed.
 */
static
long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct ltt_session *session = file->private_data;

	switch (cmd) {
	case LTTNG_CHANNEL:
		return lttng_abi_create_channel(file, (struct lttng_channel __user *)arg);
	case LTTNG_SESSION_START:
		return ltt_session_start(session);
	case LTTNG_SESSION_STOP:
		return ltt_session_stop(session);
	case LTTNG_SESSION_FINALIZE:
		return ltt_session_finalize(session);
	default:
		return -ENOIOCTLCMD;
	}
}

/*
 * Called when the last file reference is dropped.
 *
 * Big fat note: channels and events are invariant for the whole session after
 * their creation. So this session destruction also destroys all channel and
 * event structures specific to this session (they are not destroyed when their
 * individual file is released).
 */
static
int lttng_session_release(struct inode *inode, struct file *file)
{
	struct ltt_session *session = file->private_data;
	return ltt_session_destroy(session);
}

static const struct file_operations lttng_session_fops = {
	.release = lttng_session_release,
	.unlocked_ioctl = lttng_session_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = lttng_session_ioctl,
#endif
}

static
int lttng_abi_open_stream(struct file *channel_file)
{
	struct ltt_channel *channel = channel_file->private_data;
	struct lib_ring_buffer *buf;
	int stream_fd, ret;

	buf = ltt_buffer_read_open(channel->chan);
	if (!buf)
		return -ENOENT;

	stream_fd = get_unused_fd_flags(O_RDWR);
	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);
	if (IS_ERR(stream_file)) {
		ret = PTR_ERR(stream_file);
		goto file_error;
	}
	fd_install(stream_fd, stream_file);
	/* The stream holds a reference on the channel */
	atomic_inc(&channel_file->f_count);
	return stream_fd;

file_error:
	put_unused_fd(stream_fd);
fd_error:
	ltt_buffer_read_close(buf);
	return ret;
}

static
int lttng_abi_create_event(struct file *channel_file,
			   struct lttng_event __user *uevent_param)
{
	struct ltt_channel *channel = channel_file->private_data;
	struct ltt_event *event;
	char *event_name;
	struct lttng_event event_param;
	int event_fd, ret;

	if (copy_from_user(&event_param, uevent_param, sizeof(event_param)))
		return -EFAULT;
	event_name = kmalloc(PATH_MAX, GFP_KERNEL);
	if (!event_name)
		return -ENOMEM;
	if (strncpy_from_user(event_name, &uevent_param->name, PATH_MAX)) {
		ret = -EFAULT;
		goto name_error;
	}
	event_name[PATH_MAX - 1] = '\0';
	event_fd = get_unused_fd_flags(O_RDWR);
	if (event_fd < 0) {
		ret = event_fd;
		goto fd_error;
	}
	event_file = anon_inode_getfile("[lttng_event]",
					&lttng_event_fops, /* TODO: filter */
					NULL, O_RDWR);
	if (IS_ERR(event_file)) {
		ret = PTR_ERR(event_file);
		goto file_error;
	}
	/*
	 * We tolerate no failure path after event creation. It will stay
	 * invariant for the rest of the session.
	 */
	event = ltt_event_create(channel, event_param->itype, event_name, NULL);
	if (!event) {
		goto event_error;
		ret = -EEXIST;
	}
	event_file->private_data = event;
	fd_install(event_fd, event_file);
	/* The event holds a reference on the channel */
	atomic_inc(&channel_file->f_count);
	kfree(event_name);
	return event_fd;

event_error:
	fput(event_file);
file_error:
	put_unused_fd(event_fd);
fd_error:
name_error:
	kfree(event_name);
	return ret;
}

/**
 *	lttng_channel_ioctl - lttng syscall through ioctl
 *
 *	@file: the file
 *	@cmd: the command
 *	@arg: command arg
 *
 *	This ioctl implements lttng commands:
 *      LTTNG_STREAM
 *              Returns an event stream file descriptor or failure.
 *              (typically, one event stream records events from one CPU)
 *	LTTNG_EVENT
 *		Returns an event file descriptor or failure.
 *
 * The returned session will be deleted when its file descriptor is closed.
 * Channel and event file descriptors also hold a reference on the session.
 */
static
long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case LTTNG_STREAM:
		return lttng_abi_open_stream(file);
	case LTTNG_EVENT:
		return lttng_abi_create_event(file, (struct lttng_event __user *)arg);
	default:
		return -ENOIOCTLCMD;
	}
}

/**
 *	lttng_channel_poll - lttng stream addition/removal monitoring
 *
 *	@file: the file
 *	@wait: poll table
 */
unsigned int lttng_channel_poll(struct file *file, poll_table *wait)
{
	struct ltt_channel *channel = file->private_data;
	unsigned int mask = 0;

	if (file->f_mode & FMODE_READ) {
		poll_wait_set_exclusive(wait);
		poll_wait(file, &channel->notify_wait, wait);

		/* TODO: identify when the channel is being finalized. */
		if (finalized)
			return POLLHUP;
		else
			return POLLIN | POLLRDNORM;
	}
	return mask;

}

static
int lttng_channel_release(struct inode *inode, struct file *file)
{
	struct ltt_channel *channel = file->private_data;
	fput(channel->session->file);
	return 0;
}

static const struct file_operations lttng_channel_fops = {
	.release = lttng_channel_release,
	.poll = lttng_channel_poll,
	.unlocked_ioctl = lttng_channel_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = lttng_channel_ioctl,
#endif
}

static
int lttng_event_release(struct inode *inode, struct file *file)
{
	struct ltt_event *event = file->private_data;
	fput(event->chan->file);
	return 0;
}

static const struct file_operations lttng_event_fops = {
	.release = lttng_event_release,
}

static int __init ltt_debugfs_abi_init(void)
{
	int ret = 0;

	lttng_dentry = debugfs_create_file("lttng", NULL);
	if (IS_ERR(lttng_dentry) || !lttng_dentry)
		printk(KERN_ERR "Error creating LTTng control file\n");
		ret = -ENOMEM;
		goto error;
	}
error:
	return ret;
}

static void __exit ltt_debugfs_abi_exit(void)
{
	debugfs_remote(lttng_dentry);
}
Commit	Line	Data
	1	/*
	2	* ltt-debugfs-abi.c
	3	*
	4	* Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	5	*
	6	* LTTng debugfs ABI
	7	*
	8	* Mimic system calls for:
	9	* - session creation, returns a file descriptor or failure.
	10	* - channel creation, returns a file descriptor or failure.
	11	* - Operates on a session file descriptor
	12	* - Takes all channel options as parameters.
	13	* - stream get, returns a file descriptor or failure.
	14	* - Operates on a channel file descriptor.
	15	* - stream notifier get, returns a file descriptor or failure.
	16	* - Operates on a channel file descriptor.
	17	* - event creation, returns a file descriptor or failure.
	18	* - Operates on a channel file descriptor
	19	* - Takes an event name as parameter
	20	* - Takes an instrumentation source as parameter
	21	* - e.g. tracepoints, dynamic_probes...
	22	* - Takes instrumentation source specific arguments.
	23	*/
	24
	25	#include <linux/debugfs.h>
	26	#include "ltt-events.h"
	27
	28	/*
	29	* This is LTTng's own personal way to create a system call as an external
	30	* module. We use ioctl() on /sys/kernel/debug/lttng.
	31	*/
	32
	33	static struct dentry *lttng_dentry;
	34	static const struct file_operations lttng_fops;
	35	static const struct file_operations lttng_session_fops;
	36	static const struct file_operations lttng_channel_fops;
	37	static const struct file_operations lttng_event_fops;
	38
	39	/*
	40	* LTTng DebugFS ABI structures.
	41	*/
	42
	43	struct lttng_channel {
	44	int overwrite; /* 1: overwrite, 0: discard */
	45	u64 subbuf_size;
	46	u64 num_subbuf;
	47	unsigned int switch_timer_interval;
	48	unsigned int read_timer_interval;
	49	};
	50
	51	struct lttng_event {
	52	enum instrum_type itype;
	53	char name[];
	54	};
	55
	56	static
	57	int lttng_abi_create_session(void)
	58	{
	59	struct ltt_session *session;
	60	struct file *session_file;
	61	int session_fd;
	62
	63	session = ltt_session_create();
	64	if (!session)
	65	return -ENOMEM;
	66	session_fd = get_unused_fd_flags(O_RDWR);
	67	if (session_fd < 0) {
	68	ret = session_fd;
	69	goto fd_error;
	70	}
	71	session_file = anon_inode_getfile("[lttng_session]",
	72	&lttng_session_fops,
	73	session, O_RDWR);
	74	if (IS_ERR(session_file)) {
	75	ret = PTR_ERR(session_file);
	76	goto file_error;
	77	}
	78	session->file = session_file;
	79	fd_install(session_fd, session_file);
	80	return session_fd;
	81
	82	file_error:
	83	put_unused_fd(session_fd);
	84	fd_error:
	85	ltt_session_destroy(session);
	86	return ret;
	87	}
	88
	89	/**
	90	* lttng_ioctl - lttng syscall through ioctl
	91	*
	92	* @file: the file
	93	* @cmd: the command
	94	* @arg: command arg
	95	*
	96	* This ioctl implements lttng commands:
	97	* LTTNG_SESSION
	98	* Returns a LTTng trace session file descriptor
	99	*
	100	* The returned session will be deleted when its file descriptor is closed.
	101	*/
	102	static
	103	long lttng_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	104	{
	105	switch (cmd) {
	106	case LTTNG_SESSION:
	107	return lttng_abi_create_session();
	108	default:
	109	return -ENOIOCTLCMD;
	110	}
	111	}
	112
	113	static const struct file_operations lttng_fops = {
	114	.unlocked_ioctl = lttng_ioctl,
	115	#ifdef CONFIG_COMPAT
	116	.compat_ioctl = lttng_ioctl,
	117	#endif
	118	}
	119
	120	int lttng_abi_create_channel(struct file *session_file,
	121	struct lttng_channel __user *uchan_param)
	122	{
	123	struct ltt_session *session = session_file->private_data;
	124	struct ltt_channel *chan;
	125	struct file *chan_file;
	126	struct lttng_channel chan_param;
	127	int chan_fd;
	128	int ret = 0;
	129
	130	if (copy_from_user(&chan_param, uchan_param, sizeof(chan_param)))
	131	return -EFAULT;
	132	chan_fd = get_unused_fd_flags(O_RDWR);
	133	if (chan_fd < 0) {
	134	ret = chan_fd;
	135	goto fd_error;
	136	}
	137	chan_file = anon_inode_getfile("[lttng_channel]",
	138	&lttng_channel_fops,
	139	NULL, O_RDWR);
	140	if (IS_ERR(chan_file)) {
	141	ret = PTR_ERR(chan_file);
	142	goto file_error;
	143	}
	144	/*
	145	* We tolerate no failure path after channel creation. It will stay
	146	* invariant for the rest of the session.
	147	*/
	148	chan = ltt_channel_create(session, chan_param->overwrite, NULL,
	149	chan_param->subbuf_size,
	150	chan_param->num_subbuf,
	151	chan_param->switch_timer_interval,
	152	chan_param->read_timer_interval);
	153	if (!chan) {
	154	ret = -ENOMEM;
	155	goto chan_error;
	156	}
	157	channel->file = chan_file;
	158	chan_file->private_data = chan;
	159	fd_install(chan_fd, chan_file);
	160	/* The channel created holds a reference on the session */
	161	atomic_inc(&session_file->f_count);
	162
	163	return chan_fd;
	164
	165	chan_error:
	166	fput(chan_file);
	167	file_error:
	168	put_unused_fd(chan_fd);
	169	fd_error:
	170	return ret;
	171	}
	172
	173	/**
	174	* lttng_session_ioctl - lttng session fd ioctl
	175	*
	176	* @file: the file
	177	* @cmd: the command
	178	* @arg: command arg
	179	*
	180	* This ioctl implements lttng commands:
	181	* LTTNG_CHANNEL
	182	* Returns a LTTng channel file descriptor
	183	*
	184	* The returned channel will be deleted when its file descriptor is closed.
	185	*/
	186	static
	187	long lttng_session_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	188	{
	189	struct ltt_session *session = file->private_data;
	190
	191	switch (cmd) {
	192	case LTTNG_CHANNEL:
	193	return lttng_abi_create_channel(file, (struct lttng_channel __user *)arg);
	194	case LTTNG_SESSION_START:
	195	return ltt_session_start(session);
	196	case LTTNG_SESSION_STOP:
	197	return ltt_session_stop(session);
	198	case LTTNG_SESSION_FINALIZE:
	199	return ltt_session_finalize(session);
	200	default:
	201	return -ENOIOCTLCMD;
	202	}
	203	}
	204
	205	/*
	206	* Called when the last file reference is dropped.
	207	*
	208	* Big fat note: channels and events are invariant for the whole session after
	209	* their creation. So this session destruction also destroys all channel and
	210	* event structures specific to this session (they are not destroyed when their
	211	* individual file is released).
	212	*/
	213	static
	214	int lttng_session_release(struct inode inode, struct file file)
	215	{
	216	struct ltt_session *session = file->private_data;
	217	return ltt_session_destroy(session);
	218	}
	219
	220	static const struct file_operations lttng_session_fops = {
	221	.release = lttng_session_release,
	222	.unlocked_ioctl = lttng_session_ioctl,
	223	#ifdef CONFIG_COMPAT
	224	.compat_ioctl = lttng_session_ioctl,
	225	#endif
	226	}
	227
	228	static
	229	int lttng_abi_open_stream(struct file *channel_file)
	230	{
	231	struct ltt_channel *channel = channel_file->private_data;
	232	struct lib_ring_buffer *buf;
	233	int stream_fd, ret;
	234
	235	buf = ltt_buffer_read_open(channel->chan);
	236	if (!buf)
	237	return -ENOENT;
	238
	239	stream_fd = get_unused_fd_flags(O_RDWR);
	240	if (stream_fd < 0) {
	241	ret = stream_fd;
	242	goto fd_error;
	243	}
	244	stream_file = anon_inode_getfile("[lttng_stream]",
	245	&lib_ring_buffer_file_operations,
	246	buf, O_RDWR);
	247	if (IS_ERR(stream_file)) {
	248	ret = PTR_ERR(stream_file);
	249	goto file_error;
	250	}
	251	fd_install(stream_fd, stream_file);
	252	/* The stream holds a reference on the channel */
	253	atomic_inc(&channel_file->f_count);
	254	return stream_fd;
	255
	256	file_error:
	257	put_unused_fd(stream_fd);
	258	fd_error:
	259	ltt_buffer_read_close(buf);
	260	return ret;
	261	}
	262
	263	static
	264	int lttng_abi_create_event(struct file *channel_file,
	265	struct lttng_event __user *uevent_param)
	266	{
	267	struct ltt_channel *channel = channel_file->private_data;
	268	struct ltt_event *event;
	269	char *event_name;
	270	struct lttng_event event_param;
	271	int event_fd, ret;
	272
	273	if (copy_from_user(&event_param, uevent_param, sizeof(event_param)))
	274	return -EFAULT;
	275	event_name = kmalloc(PATH_MAX, GFP_KERNEL);
	276	if (!event_name)
	277	return -ENOMEM;
	278	if (strncpy_from_user(event_name, &uevent_param->name, PATH_MAX)) {
	279	ret = -EFAULT;
	280	goto name_error;
	281	}
	282	event_name[PATH_MAX - 1] = '\0';
	283	event_fd = get_unused_fd_flags(O_RDWR);
	284	if (event_fd < 0) {
	285	ret = event_fd;
	286	goto fd_error;
	287	}
	288	event_file = anon_inode_getfile("[lttng_event]",
	289	&lttng_event_fops, /* TODO: filter */
	290	NULL, O_RDWR);
	291	if (IS_ERR(event_file)) {
	292	ret = PTR_ERR(event_file);
	293	goto file_error;
	294	}
	295	/*
	296	* We tolerate no failure path after event creation. It will stay
	297	* invariant for the rest of the session.
	298	*/
	299	event = ltt_event_create(channel, event_param->itype, event_name, NULL);
	300	if (!event) {
	301	goto event_error;
	302	ret = -EEXIST;
	303	}
	304	event_file->private_data = event;
	305	fd_install(event_fd, event_file);
	306	/* The event holds a reference on the channel */
	307	atomic_inc(&channel_file->f_count);
	308	kfree(event_name);
	309	return event_fd;
	310
	311	event_error:
	312	fput(event_file);
	313	file_error:
	314	put_unused_fd(event_fd);
	315	fd_error:
	316	name_error:
	317	kfree(event_name);
	318	return ret;
	319	}
	320
	321	/**
	322	* lttng_channel_ioctl - lttng syscall through ioctl
	323	*
	324	* @file: the file
	325	* @cmd: the command
	326	* @arg: command arg
	327	*
	328	* This ioctl implements lttng commands:
	329	* LTTNG_STREAM
	330	* Returns an event stream file descriptor or failure.
	331	* (typically, one event stream records events from one CPU)
	332	* LTTNG_EVENT
	333	* Returns an event file descriptor or failure.
	334	*
	335	* The returned session will be deleted when its file descriptor is closed.
	336	* Channel and event file descriptors also hold a reference on the session.
	337	*/
	338	static
	339	long lttng_channel_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
	340	{
	341	switch (cmd) {
	342	case LTTNG_STREAM:
	343	return lttng_abi_open_stream(file);
	344	case LTTNG_EVENT:
	345	return lttng_abi_create_event(file, (struct lttng_event __user *)arg);
	346	default:
	347	return -ENOIOCTLCMD;
	348	}
	349	}
	350
	351	/**
	352	* lttng_channel_poll - lttng stream addition/removal monitoring
	353	*
	354	* @file: the file
	355	* @wait: poll table
	356	*/
	357	unsigned int lttng_channel_poll(struct file file, poll_table wait)
	358	{
	359	struct ltt_channel *channel = file->private_data;
	360	unsigned int mask = 0;
	361
	362	if (file->f_mode & FMODE_READ) {
	363	poll_wait_set_exclusive(wait);
	364	poll_wait(file, &channel->notify_wait, wait);
	365
	366	/* TODO: identify when the channel is being finalized. */
	367	if (finalized)
	368	return POLLHUP;
	369	else
	370	return POLLIN \| POLLRDNORM;
	371	}
	372	return mask;
	373
	374	}
	375
	376	static
	377	int lttng_channel_release(struct inode inode, struct file file)
	378	{
	379	struct ltt_channel *channel = file->private_data;
	380	fput(channel->session->file);
	381	return 0;
	382	}
	383
	384	static const struct file_operations lttng_channel_fops = {
	385	.release = lttng_channel_release,
	386	.poll = lttng_channel_poll,
	387	.unlocked_ioctl = lttng_channel_ioctl,
	388	#ifdef CONFIG_COMPAT
	389	.compat_ioctl = lttng_channel_ioctl,
	390	#endif
	391	}
	392
	393	static
	394	int lttng_event_release(struct inode inode, struct file file)
	395	{
	396	struct ltt_event *event = file->private_data;
	397	fput(event->chan->file);
	398	return 0;
	399	}
	400
	401	static const struct file_operations lttng_event_fops = {
	402	.release = lttng_event_release,
	403	}
	404
	405	static int __init ltt_debugfs_abi_init(void)
	406	{
	407	int ret = 0;
	408
	409	lttng_dentry = debugfs_create_file("lttng", NULL);
	410	if (IS_ERR(lttng_dentry) \|\| !lttng_dentry)
	411	printk(KERN_ERR "Error creating LTTng control file\n");
	412	ret = -ENOMEM;
	413	goto error;
	414	}
	415	error:
	416	return ret;
	417	}
	418
	419	static void __exit ltt_debugfs_abi_exit(void)
	420	{
	421	debugfs_remote(lttng_dentry);
	422	}