[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.
 *   - Takes a session file descriptor parameter
 *   - Takes all channel options as parameters.
 * - event creation, returns a file descriptor or failure.
 *   - 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>

/*
 * 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;

/*
 * LTTng DebugFS ABI structures.
 */

struct lttng_channel {
	int session;			/* Session file descriptor */
	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 {
	int channel;			/* Channel file descriptor */
	enum instrum_type itype;
	char name[];
};

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_fops,
					  session, O_RDWR);
	if (IS_ERR(session_file)) {
		ret = PTR_ERR(session_file);
		goto file_error;
	}
	return session_fd;

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

int lttng_abi_create_channel(struct lttng_channel __user *uchan_param)
{
	struct ltt_channel *chan;
	struct file *chan_file;
	struct lttng_channel chan_param;
	int chan_fd;

	if (copy_from_user(&chan_param, ucham_param, sizeof(chan_param)))
		return -EFAULT;
	/* TODO: fetch session pointer from file descriptor */
	chan = ltt_channel_create();
	if (!chan)
		return -ENOMEM;
	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_fops,
				       chan, O_RDWR);
	if (IS_ERR(chan_file)) {
		ret = PTR_ERR(chan_file);
		goto file_error;
	}
	return chan_fd;

file_error:
	put_unused_fd(chan_fd);
fd_error:
	ltt_channel_destroy(chan);
	return ret;
}

/**
 *	lttng_ioctl - lttng syscall through ioctl
 *
 *	@filp: the file
 *	@cmd: the command
 *	@arg: command arg
 *
 *	This ioctl implements lttng commands:
 *	LTTNG_SESSION
 *		Returns a LTTng trace session file descriptor
 *	LTTNG_CHANNEL
 *		Returns a LTTng channel file descriptor
 *	LTTNG_EVENT
 *		Returns a 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.
 */
long lttng_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = filp->f_dentry->d_inode;

	switch (cmd) {
	case LTTNG_SESSION:
		return lttng_abi_create_session();
	case LTTNG_CHANNEL:
		return lttng_abi_create_channel((struct lttng_channel __user *)arg);
	case LTTNG_EVENT:
		return lttng_abi_create_event((struct lttng_event __user *)arg);
	default:
		return -ENOIOCTLCMD;
	}
}

#ifdef CONFIG_COMPAT
long lttng_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = filp->f_dentry->d_inode;

	switch (cmd) {
	case LTTNG_SESSION:
		return lttng_abi_create_session();
	case LTTNG_CHANNEL:
		return lttng_abi_create_channel((struct lttng_channel __user *)arg);
	case LTTNG_EVENT:
		return lttng_abi_create_event((struct lttng_event __user *)arg);
	default:
		return -ENOIOCTLCMD;
	}
}
#endif

const struct file_operations lttng_file_operations = {
	.unlocked_ioctl = lttng_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = lttng_compat_ioctl,
#endif
}

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
baf20995 MD	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	* - Takes a session file descriptor parameter
	12	* - Takes all channel options as parameters.
	13	* - event creation, returns a file descriptor or failure.
	14	* - Takes an event name as parameter
	15	* - Takes an instrumentation source as parameter
	16	* - e.g. tracepoints, dynamic_probes...
	17	* - Takes instrumentation source specific arguments.
	18	*/
	19
	20	#include <linux/debugfs.h>
	21
	22	/*
	23	* This is LTTng's own personal way to create a system call as an external
	24	* module. We use ioctl() on /sys/kernel/debug/lttng.
	25	*/
	26
	27	static struct dentry *lttng_dentry;
	28
	29	/*
	30	* LTTng DebugFS ABI structures.
	31	*/
	32
	33	struct lttng_channel {
	34	int session; /* Session file descriptor */
	35	int overwrite; /* 1: overwrite, 0: discard */
	36	u64 subbuf_size;
	37	u64 num_subbuf;
	38	unsigned int switch_timer_interval;
	39	unsigned int read_timer_interval;
	40	};
	41
	42	struct lttng_event {
	43	int channel; /* Channel file descriptor */
	44	enum instrum_type itype;
	45	char name[];
	46	};
	47
	48	int lttng_abi_create_session(void)
	49	{
	50	struct ltt_session *session;
	51	struct file *session_file;
	52	int session_fd;
	53
	54	session = ltt_session_create()
	55	if (!session)
	56	return -ENOMEM;
	57	session_fd = get_unused_fd_flags(O_RDWR);
	58	if (session_fd < 0) {
	59	ret = session_fd;
	60	goto fd_error;
	61	}
	62	session_file = anon_inode_getfile("[lttng_session]",
	63	&lttng_fops,
	64	session, O_RDWR);
65	if (IS_ERR(session_file)) {
66	ret = PTR_ERR(session_file);
67	goto file_error;
68	}
69	return session_fd;
70
71	file_error:
72	put_unused_fd(session_fd);
73	fd_error:
74	ltt_session_destroy(session);
75	return ret;
76	}
77
78	int lttng_abi_create_channel(struct lttng_channel __user *uchan_param)
79	{
80	struct ltt_channel *chan;
81	struct file *chan_file;
82	struct lttng_channel chan_param;
83	int chan_fd;
84
85	if (copy_from_user(&chan_param, ucham_param, sizeof(chan_param)))
86	return -EFAULT;
87	/* TODO: fetch session pointer from file descriptor */
88	chan = ltt_channel_create();
89	if (!chan)
90	return -ENOMEM;
91	chan_fd = get_unused_fd_flags(O_RDWR);
92	if (chan_fd < 0) {
93	ret = chan_fd;
94	goto fd_error;
95	}
96	chan_file = anon_inode_getfile("[lttng_channel]",
97	&lttng_fops,
98	chan, O_RDWR);
99	if (IS_ERR(chan_file)) {
100	ret = PTR_ERR(chan_file);
101	goto file_error;
102	}
103	return chan_fd;
104
105	file_error:
106	put_unused_fd(chan_fd);
107	fd_error:
108	ltt_channel_destroy(chan);
109	return ret;
110	}
111
112	/**
113	* lttng_ioctl - lttng syscall through ioctl
114	*
115	* @filp: the file
116	* @cmd: the command
117	* @arg: command arg
118	*
119	* This ioctl implements lttng commands:
120	* LTTNG_SESSION
121	* Returns a LTTng trace session file descriptor
122	* LTTNG_CHANNEL
123	* Returns a LTTng channel file descriptor
124	* LTTNG_EVENT
125	* Returns a file descriptor or failure.
126	*
127	* The returned session will be deleted when its file descriptor is closed.
128	* Channel and event file descriptors also hold a reference on the session.
129	*/
130	long lttng_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
131	{
132	struct inode *inode = filp->f_dentry->d_inode;
133
134	switch (cmd) {
135	case LTTNG_SESSION:
136	return lttng_abi_create_session();
137	case LTTNG_CHANNEL:
138	return lttng_abi_create_channel((struct lttng_channel __user *)arg);
139	case LTTNG_EVENT:
140	return lttng_abi_create_event((struct lttng_event __user *)arg);
141	default:
142	return -ENOIOCTLCMD;
143	}
144	}
145
146	#ifdef CONFIG_COMPAT
147	long lttng_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
148	{
149	struct inode *inode = filp->f_dentry->d_inode;
150
151	switch (cmd) {
152	case LTTNG_SESSION:
153	return lttng_abi_create_session();
154	case LTTNG_CHANNEL:
155	return lttng_abi_create_channel((struct lttng_channel __user *)arg);
156	case LTTNG_EVENT:
157	return lttng_abi_create_event((struct lttng_event __user *)arg);
158	default:
159	return -ENOIOCTLCMD;
160	}
161	}
162	#endif
163
164	const struct file_operations lttng_file_operations = {
165	.unlocked_ioctl = lttng_ioctl,
166	#ifdef CONFIG_COMPAT
167	.compat_ioctl = lttng_compat_ioctl,
168	#endif
169	}
170
171	static int __init ltt_debugfs_abi_init(void)
172	{
173	int ret = 0;
174
175	lttng_dentry = debugfs_create_file("lttng", NULL);
176	if (IS_ERR(lttng_dentry) \|\| !lttng_dentry)
177	printk(KERN_ERR "Error creating LTTng control file\n");
178	ret = -ENOMEM;
179	goto error;
180	}
181	error:
182	return ret;
183	}
184
185	static void __exit ltt_debugfs_abi_exit(void)
186	{
187	debugfs_remote(lttng_dentry);
188	}