[ust.git] / libust / marker-control.c

/*
 * Copyright (C) 2007 Mathieu Desnoyers
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * LTT marker control module over /proc
 */

//ust// #include <linux/proc_fs.h>
//ust// #include <linux/module.h>
//ust// #include <linux/stat.h>
//ust// #include <linux/vmalloc.h>
//ust// #include <linux/marker.h>
//ust// #include <linux/ltt-tracer.h>
//ust// #include <linux/uaccess.h>
//ust// #include <linux/string.h>
//ust// #include <linux/ctype.h>
//ust// #include <linux/list.h>
//ust// #include <linux/mutex.h>
//ust// #include <linux/seq_file.h>
//ust// #include <linux/slab.h>
#include "kernelcompat.h"
//#include "list.h"
#include "tracer.h"
#include "localerr.h"

#define DEFAULT_CHANNEL "cpu"
#define DEFAULT_PROBE "default"

LIST_HEAD(probes_list);

/*
 * Mutex protecting the probe slab cache.
 * Nests inside the traces mutex.
 */
DEFINE_MUTEX(probes_mutex);

struct ltt_available_probe default_probe = {
	.name = "default",
	.format = NULL,
	.probe_func = ltt_vtrace,
	.callbacks[0] = ltt_serialize_data,
};

//ust//static struct kmem_cache *markers_loaded_cachep;
static LIST_HEAD(markers_loaded_list);
/*
 * List sorted by name strcmp order.
 */
static LIST_HEAD(probes_registered_list);

//ust// static struct proc_dir_entry *pentry;

//ust// static struct file_operations ltt_fops;

static struct ltt_available_probe *get_probe_from_name(const char *pname)
{
	struct ltt_available_probe *iter;
	int comparison, found = 0;

	if (!pname)
		pname = DEFAULT_PROBE;
	list_for_each_entry(iter, &probes_registered_list, node) {
		comparison = strcmp(pname, iter->name);
		if (!comparison)
			found = 1;
		if (comparison <= 0)
			break;
	}
	if (found)
		return iter;
	else
		return NULL;
}

static char *skip_spaces(char *buf)
{
	while (*buf != '\0' && isspace(*buf))
		buf++;
	return buf;
}

static char *skip_nonspaces(char *buf)
{
	while (*buf != '\0' && !isspace(*buf))
		buf++;
	return buf;
}

static void get_marker_string(char *buf, char **start,
		char **end)
{
	*start = skip_spaces(buf);
	*end = skip_nonspaces(*start);
	**end = '\0';
}

int ltt_probe_register(struct ltt_available_probe *pdata)
{
	int ret = 0;
	int comparison;
	struct ltt_available_probe *iter;

	mutex_lock(&probes_mutex);
	list_for_each_entry_reverse(iter, &probes_registered_list, node) {
		comparison = strcmp(pdata->name, iter->name);
		if (!comparison) {
			ret = -EBUSY;
			goto end;
		} else if (comparison > 0) {
			/* We belong to the location right after iter. */
			list_add(&pdata->node, &iter->node);
			goto end;
		}
	}
	/* Should be added at the head of the list */
	list_add(&pdata->node, &probes_registered_list);
end:
	mutex_unlock(&probes_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(ltt_probe_register);

/*
 * Called when a probe does not want to be called anymore.
 */
int ltt_probe_unregister(struct ltt_available_probe *pdata)
{
	int ret = 0;
	struct ltt_active_marker *amark, *tmp;

	mutex_lock(&probes_mutex);
	list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) {
		if (amark->probe == pdata) {
			ret = marker_probe_unregister_private_data(
				pdata->probe_func, amark);
			if (ret)
				goto end;
			list_del(&amark->node);
			free(amark);
		}
	}
	list_del(&pdata->node);
end:
	mutex_unlock(&probes_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(ltt_probe_unregister);

/*
 * Connect marker "mname" to probe "pname".
 * Only allow _only_ probe instance to be connected to a marker.
 */
int ltt_marker_connect(const char *channel, const char *mname,
		       const char *pname)

{
	int ret;
	struct ltt_active_marker *pdata;
	struct ltt_available_probe *probe;

	ltt_lock_traces();
	mutex_lock(&probes_mutex);
	probe = get_probe_from_name(pname);
	if (!probe) {
		ret = -ENOENT;
		goto end;
	}
	pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
	if (pdata && !IS_ERR(pdata)) {
		ret = -EEXIST;
		goto end;
	}
	pdata = zmalloc(sizeof(struct ltt_active_marker));
	if (!pdata) {
		ret = -ENOMEM;
		goto end;
	}
	pdata->probe = probe;
	/*
	 * ID has priority over channel in case of conflict.
	 */
	ret = marker_probe_register(channel, mname, NULL,
		probe->probe_func, pdata);
	if (ret)
		free(pdata);
	else
		list_add(&pdata->node, &markers_loaded_list);
end:
	mutex_unlock(&probes_mutex);
	ltt_unlock_traces();
	return ret;
}
EXPORT_SYMBOL_GPL(ltt_marker_connect);

/*
 * Disconnect marker "mname", probe "pname".
 */
int ltt_marker_disconnect(const char *channel, const char *mname,
			  const char *pname)
{
	struct ltt_active_marker *pdata;
	struct ltt_available_probe *probe;
	int ret = 0;

	mutex_lock(&probes_mutex);
	probe = get_probe_from_name(pname);
	if (!probe) {
		ret = -ENOENT;
		goto end;
	}
	pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
	if (IS_ERR(pdata)) {
		ret = PTR_ERR(pdata);
		goto end;
	} else if (!pdata) {
		/*
		 * Not registered by us.
		 */
		ret = -EPERM;
		goto end;
	}
	ret = marker_probe_unregister(channel, mname, probe->probe_func, pdata);
	if (ret)
		goto end;
	else {
		list_del(&pdata->node);
		free(pdata);
	}
end:
	mutex_unlock(&probes_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(ltt_marker_disconnect);

/*
 * function handling proc entry write.
 *
 * connect <channel name> <marker name> [<probe name>]]
 * disconnect <channel name> <marker name> [<probe name>]
 */
//ust// static ssize_t ltt_write(struct file *file, const char __user *buffer,
//ust// 			   size_t count, loff_t *offset)
//ust// {
//ust// 	char *kbuf;
//ust// 	char *iter, *marker_action, *arg[4];
//ust// 	ssize_t ret;
//ust// 	int i;
//ust// 
//ust// 	if (!count)
//ust// 		return -EINVAL;
//ust// 
//ust// 	kbuf = vmalloc(count + 1);
//ust// 	kbuf[count] = '\0';		/* Transform into a string */
//ust// 	ret = copy_from_user(kbuf, buffer, count);
//ust// 	if (ret) {
//ust// 		ret = -EINVAL;
//ust// 		goto end;
//ust// 	}
//ust// 	get_marker_string(kbuf, &marker_action, &iter);
//ust// 	if (!marker_action || marker_action == iter) {
//ust// 		ret = -EINVAL;
//ust// 		goto end;
//ust// 	}
//ust// 	for (i = 0; i < 4; i++) {
//ust// 		arg[i] = NULL;
//ust// 		if (iter < kbuf + count) {
//ust// 			iter++;			/* skip the added '\0' */
//ust// 			get_marker_string(iter, &arg[i], &iter);
//ust// 			if (arg[i] == iter)
//ust// 				arg[i] = NULL;
//ust// 		}
//ust// 	}
//ust// 
//ust// 	if (!arg[0] || !arg[1]) {
//ust// 		ret = -EINVAL;
//ust// 		goto end;
//ust// 	}
//ust// 
//ust// 	if (!strcmp(marker_action, "connect")) {
//ust// 		ret = ltt_marker_connect(arg[0], arg[1], arg[2]);
//ust// 		if (ret)
//ust// 			goto end;
//ust// 	} else if (!strcmp(marker_action, "disconnect")) {
//ust// 		ret = ltt_marker_disconnect(arg[0], arg[1], arg[2]);
//ust// 		if (ret)
//ust// 			goto end;
//ust// 	}
//ust// 	ret = count;
//ust// end:
//ust// 	vfree(kbuf);
//ust// 	return ret;
//ust// }
//ust// 
//ust// static void *s_next(struct seq_file *m, void *p, loff_t *pos)
//ust// {
//ust// 	struct marker_iter *iter = m->private;
//ust// 
//ust// 	marker_iter_next(iter);
//ust// 	if (!iter->marker) {
//ust// 		/*
//ust// 		 * Setting the iter module to -1UL will make sure
//ust// 		 * that no module can possibly hold the current marker.
//ust// 		 */
//ust// 		iter->module = (void *)-1UL;
//ust// 		return NULL;
//ust// 	}
//ust// 	return iter->marker;
//ust// }
//ust// 
//ust// static void *s_start(struct seq_file *m, loff_t *pos)
//ust// {
//ust// 	struct marker_iter *iter = m->private;
//ust// 
//ust// 	if (!*pos)
//ust// 		marker_iter_reset(iter);
//ust// 	marker_iter_start(iter);
//ust// 	if (!iter->marker) {
//ust// 		/*
//ust// 		 * Setting the iter module to -1UL will make sure
//ust// 		 * that no module can possibly hold the current marker.
//ust// 		 */
//ust// 		iter->module = (void *)-1UL;
//ust// 		return NULL;
//ust// 	}
//ust// 	return iter->marker;
//ust// }
//ust// 
//ust// static void s_stop(struct seq_file *m, void *p)
//ust// {
//ust// 	marker_iter_stop(m->private);
//ust// }
//ust// 
//ust// static int s_show(struct seq_file *m, void *p)
//ust// {
//ust// 	struct marker_iter *iter = m->private;
//ust// 
//ust// 	seq_printf(m, "channel: %s marker: %s format: \"%s\" state: %d "
//ust// 		"event_id: %hu call: 0x%p probe %s : 0x%p\n",
//ust// 		iter->marker->channel,
//ust// 		iter->marker->name, iter->marker->format,
//ust// 		_imv_read(iter->marker->state),
//ust// 		iter->marker->event_id,
//ust// 		iter->marker->call,
//ust// 		iter->marker->ptype ? "multi" : "single",
//ust// 		iter->marker->ptype ?
//ust// 		(void*)iter->marker->multi : (void*)iter->marker->single.func);
//ust// 	return 0;
//ust// }
//ust// 
//ust// static const struct seq_operations ltt_seq_op = {
//ust// 	.start = s_start,
//ust// 	.next = s_next,
//ust// 	.stop = s_stop,
//ust// 	.show = s_show,
//ust// };
//ust// 
//ust// static int ltt_open(struct inode *inode, struct file *file)
//ust// {
//ust// 	/*
//ust// 	 * Iterator kept in m->private.
//ust// 	 * Restart iteration on all modules between reads because we do not lock
//ust// 	 * the module mutex between those.
//ust// 	 */
//ust// 	int ret;
//ust// 	struct marker_iter *iter;
//ust// 
//ust// 	iter = kzalloc(sizeof(*iter), GFP_KERNEL);
//ust// 	if (!iter)
//ust// 		return -ENOMEM;
//ust// 
//ust// 	ret = seq_open(file, &ltt_seq_op);
//ust// 	if (ret == 0)
//ust// 		((struct seq_file *)file->private_data)->private = iter;
//ust// 	else
//ust// 		kfree(iter);
//ust// 	return ret;
//ust// }
//ust// 
//ust// static struct file_operations ltt_fops = {
//ust// 	.write = ltt_write,
//ust// 	.open = ltt_open,
//ust// 	.read = seq_read,
//ust// 	.llseek = seq_lseek,
//ust// 	.release = seq_release_private,
//ust// };

static void disconnect_all_markers(void)
{
	struct ltt_active_marker *pdata, *tmp;

	list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) {
		marker_probe_unregister_private_data(pdata->probe->probe_func,
			pdata);
		list_del(&pdata->node);
		free(pdata);
	}
}

static char initialized = 0;

void __attribute__((constructor)) init_marker_control(void)
{
	if(!initialized) {
		int ret;

//ust//	pentry = create_proc_entry("ltt", S_IRUSR|S_IWUSR, NULL);
//ust//	if (!pentry)
//ust//		return -EBUSY;
//ust//	markers_loaded_cachep = KMEM_CACHE(ltt_active_marker, 0);

		ret = ltt_probe_register(&default_probe);
		BUG_ON(ret);
		ret = ltt_marker_connect("metadata", "core_marker_format",
					 DEFAULT_PROBE);
		BUG_ON(ret);
		ret = ltt_marker_connect("metadata", "core_marker_id", DEFAULT_PROBE);
		BUG_ON(ret);
//ust//	pentry->proc_fops = &ltt_fops;

		initialized = 1;
	}
}
//ust// module_init(marker_control_init);

static void __exit marker_control_exit(void)
{
	int ret;

//ust//	remove_proc_entry("ltt", NULL);
	ret = ltt_marker_disconnect("metadata", "core_marker_format",
				    DEFAULT_PROBE);
	BUG_ON(ret);
	ret = ltt_marker_disconnect("metadata", "core_marker_id",
				    DEFAULT_PROBE);
	BUG_ON(ret);
	ret = ltt_probe_unregister(&default_probe);
	BUG_ON(ret);
	disconnect_all_markers();
//ust//	kmem_cache_destroy(markers_loaded_cachep);
//ust//	marker_synchronize_unregister();
}
//ust// module_exit(marker_control_exit);

//ust// MODULE_LICENSE("GPL");
//ust// MODULE_AUTHOR("Mathieu Desnoyers");
//ust// MODULE_DESCRIPTION("Linux Trace Toolkit Marker Control");
Commit	Line	Data
ba6459ba PMF	1	/*
	2	* Copyright (C) 2007 Mathieu Desnoyers
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*
	18	* LTT marker control module over /proc
	19	*/
	20
	21	//ust// #include <linux/proc_fs.h>
	22	//ust// #include <linux/module.h>
	23	//ust// #include <linux/stat.h>
	24	//ust// #include <linux/vmalloc.h>
	25	//ust// #include <linux/marker.h>
	26	//ust// #include <linux/ltt-tracer.h>
	27	//ust// #include <linux/uaccess.h>
	28	//ust// #include <linux/string.h>
	29	//ust// #include <linux/ctype.h>
	30	//ust// #include <linux/list.h>
	31	//ust// #include <linux/mutex.h>
	32	//ust// #include <linux/seq_file.h>
	33	//ust// #include <linux/slab.h>
	34	#include "kernelcompat.h"
769d0157	35	//#include "list.h"
ba6459ba	36	#include "tracer.h"
d0b5f2b9	37	#include "localerr.h"
ba6459ba PMF	38
	39	#define DEFAULT_CHANNEL "cpu"
	40	#define DEFAULT_PROBE "default"
	41
	42	LIST_HEAD(probes_list);
	43
	44	/*
	45	* Mutex protecting the probe slab cache.
	46	* Nests inside the traces mutex.
	47	*/
	48	DEFINE_MUTEX(probes_mutex);
	49
	50	struct ltt_available_probe default_probe = {
	51	.name = "default",
	52	.format = NULL,
	53	.probe_func = ltt_vtrace,
	54	.callbacks[0] = ltt_serialize_data,
	55	};
	56
	57	//ust//static struct kmem_cache *markers_loaded_cachep;
	58	static LIST_HEAD(markers_loaded_list);
	59	/*
	60	* List sorted by name strcmp order.
	61	*/
	62	static LIST_HEAD(probes_registered_list);
	63
	64	//ust// static struct proc_dir_entry *pentry;
	65
	66	//ust// static struct file_operations ltt_fops;
	67
	68	static struct ltt_available_probe get_probe_from_name(const char pname)
	69	{
	70	struct ltt_available_probe *iter;
	71	int comparison, found = 0;
	72
	73	if (!pname)
	74	pname = DEFAULT_PROBE;
	75	list_for_each_entry(iter, &probes_registered_list, node) {
	76	comparison = strcmp(pname, iter->name);
	77	if (!comparison)
	78	found = 1;
	79	if (comparison <= 0)
	80	break;
	81	}
	82	if (found)
	83	return iter;
	84	else
	85	return NULL;
	86	}
	87
	88	static char skip_spaces(char buf)
	89	{
	90	while (buf != '\0' && isspace(buf))
	91	buf++;
	92	return buf;
	93	}
	94
	95	static char skip_nonspaces(char buf)
	96	{
	97	while (buf != '\0' && !isspace(buf))
	98	buf++;
	99	return buf;
	100	}
	101
102	static void get_marker_string(char buf, char *start,
103	char **end)
104	{
105	*start = skip_spaces(buf);
106	end = skip_nonspaces(start);
107	**end = '\0';
108	}
109
110	int ltt_probe_register(struct ltt_available_probe *pdata)
111	{
112	int ret = 0;
113	int comparison;
114	struct ltt_available_probe *iter;
115
116	mutex_lock(&probes_mutex);
117	list_for_each_entry_reverse(iter, &probes_registered_list, node) {
118	comparison = strcmp(pdata->name, iter->name);
119	if (!comparison) {
120	ret = -EBUSY;
121	goto end;
122	} else if (comparison > 0) {
123	/* We belong to the location right after iter. */
124	list_add(&pdata->node, &iter->node);
125	goto end;
126	}
127	}
128	/* Should be added at the head of the list */
129	list_add(&pdata->node, &probes_registered_list);
130	end:
131	mutex_unlock(&probes_mutex);
132	return ret;
133	}
134	EXPORT_SYMBOL_GPL(ltt_probe_register);
135
136	/*
137	* Called when a probe does not want to be called anymore.
138	*/
139	int ltt_probe_unregister(struct ltt_available_probe *pdata)
140	{
141	int ret = 0;
142	struct ltt_active_marker amark, tmp;
143
144	mutex_lock(&probes_mutex);
145	list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) {
146	if (amark->probe == pdata) {
147	ret = marker_probe_unregister_private_data(
148	pdata->probe_func, amark);
149	if (ret)
150	goto end;
151	list_del(&amark->node);
152	free(amark);
153	}
154	}
155	list_del(&pdata->node);
156	end:
157	mutex_unlock(&probes_mutex);
158	return ret;
159	}
160	EXPORT_SYMBOL_GPL(ltt_probe_unregister);
161
162	/*
163	* Connect marker "mname" to probe "pname".
164	* Only allow _only_ probe instance to be connected to a marker.
165	*/
166	int ltt_marker_connect(const char channel, const char mname,
167	const char *pname)
168
169	{
170	int ret;
171	struct ltt_active_marker *pdata;
172	struct ltt_available_probe *probe;
173
174	ltt_lock_traces();
175	mutex_lock(&probes_mutex);
176	probe = get_probe_from_name(pname);
177	if (!probe) {
178	ret = -ENOENT;
179	goto end;
180	}
181	pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
182	if (pdata && !IS_ERR(pdata)) {
183	ret = -EEXIST;
184	goto end;
185	}
186	pdata = zmalloc(sizeof(struct ltt_active_marker));
187	if (!pdata) {
188	ret = -ENOMEM;
189	goto end;
190	}
191	pdata->probe = probe;
192	/*
193	* ID has priority over channel in case of conflict.
194	*/
195	ret = marker_probe_register(channel, mname, NULL,
196	probe->probe_func, pdata);
197	if (ret)
198	free(pdata);
199	else
200	list_add(&pdata->node, &markers_loaded_list);
201	end:
202	mutex_unlock(&probes_mutex);
203	ltt_unlock_traces();
204	return ret;
205	}
206	EXPORT_SYMBOL_GPL(ltt_marker_connect);
207
208	/*
209	* Disconnect marker "mname", probe "pname".
210	*/
211	int ltt_marker_disconnect(const char channel, const char mname,
212	const char *pname)
213	{
214	struct ltt_active_marker *pdata;
215	struct ltt_available_probe *probe;
216	int ret = 0;
217
218	mutex_lock(&probes_mutex);
219	probe = get_probe_from_name(pname);
220	if (!probe) {
221	ret = -ENOENT;
222	goto end;
223	}
224	pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
225	if (IS_ERR(pdata)) {
226	ret = PTR_ERR(pdata);
227	goto end;
228	} else if (!pdata) {
229	/*
230	* Not registered by us.
231	*/
232	ret = -EPERM;
233	goto end;
234	}
235	ret = marker_probe_unregister(channel, mname, probe->probe_func, pdata);
236	if (ret)
237	goto end;
238	else {
239	list_del(&pdata->node);
240	free(pdata);
241	}
242	end:
243	mutex_unlock(&probes_mutex);
244	return ret;
245	}
246	EXPORT_SYMBOL_GPL(ltt_marker_disconnect);
247
248	/*
249	* function handling proc entry write.
250	*
251	* connect <channel name> <marker name> [<probe name>]]
252	* disconnect <channel name> <marker name> [<probe name>]
253	*/
254	//ust// static ssize_t ltt_write(struct file file, const char __user buffer,
255	//ust// size_t count, loff_t *offset)
256	//ust// {
257	//ust// char *kbuf;
258	//ust// char iter, marker_action, *arg[4];
259	//ust// ssize_t ret;
260	//ust// int i;
261	//ust//
262	//ust// if (!count)
263	//ust// return -EINVAL;
264	//ust//
265	//ust// kbuf = vmalloc(count + 1);
266	//ust// kbuf[count] = '\0'; /* Transform into a string */
267	//ust// ret = copy_from_user(kbuf, buffer, count);
268	//ust// if (ret) {
269	//ust// ret = -EINVAL;
270	//ust// goto end;
271	//ust// }
272	//ust// get_marker_string(kbuf, &marker_action, &iter);
273	//ust// if (!marker_action \|\| marker_action == iter) {
274	//ust// ret = -EINVAL;
275	//ust// goto end;
276	//ust// }
277	//ust// for (i = 0; i < 4; i++) {
278	//ust// arg[i] = NULL;
279	//ust// if (iter < kbuf + count) {
280	//ust// iter++; /* skip the added '\0' */
281	//ust// get_marker_string(iter, &arg[i], &iter);
282	//ust// if (arg[i] == iter)
283	//ust// arg[i] = NULL;
284	//ust// }
285	//ust// }
286	//ust//
287	//ust// if (!arg[0] \|\| !arg[1]) {
288	//ust// ret = -EINVAL;
289	//ust// goto end;
290	//ust// }
291	//ust//
292	//ust// if (!strcmp(marker_action, "connect")) {
293	//ust// ret = ltt_marker_connect(arg[0], arg[1], arg[2]);
294	//ust// if (ret)
295	//ust// goto end;
296	//ust// } else if (!strcmp(marker_action, "disconnect")) {
297	//ust// ret = ltt_marker_disconnect(arg[0], arg[1], arg[2]);
298	//ust// if (ret)
299	//ust// goto end;
300	//ust// }
301	//ust// ret = count;
302	//ust// end:
303	//ust// vfree(kbuf);
304	//ust// return ret;
305	//ust// }
306	//ust//
307	//ust// static void s_next(struct seq_file m, void p, loff_t pos)
308	//ust// {
309	//ust// struct marker_iter *iter = m->private;
310	//ust//
311	//ust// marker_iter_next(iter);
312	//ust// if (!iter->marker) {
313	//ust// /*
314	//ust// * Setting the iter module to -1UL will make sure
315	//ust// * that no module can possibly hold the current marker.
316	//ust// */
317	//ust// iter->module = (void *)-1UL;
318	//ust// return NULL;
319	//ust// }
320	//ust// return iter->marker;
321	//ust// }
322	//ust//
323	//ust// static void s_start(struct seq_file m, loff_t *pos)
324	//ust// {
325	//ust// struct marker_iter *iter = m->private;
326	//ust//
327	//ust// if (!*pos)
328	//ust// marker_iter_reset(iter);
329	//ust// marker_iter_start(iter);
330	//ust// if (!iter->marker) {
331	//ust// /*
332	//ust// * Setting the iter module to -1UL will make sure
333	//ust// * that no module can possibly hold the current marker.
334	//ust// */
335	//ust// iter->module = (void *)-1UL;
336	//ust// return NULL;
337	//ust// }
338	//ust// return iter->marker;
339	//ust// }
340	//ust//
341	//ust// static void s_stop(struct seq_file m, void p)
342	//ust// {
343	//ust// marker_iter_stop(m->private);
344	//ust// }
345	//ust//
346	//ust// static int s_show(struct seq_file m, void p)
347	//ust// {
348	//ust// struct marker_iter *iter = m->private;
349	//ust//
350	//ust// seq_printf(m, "channel: %s marker: %s format: \"%s\" state: %d "
351	//ust// "event_id: %hu call: 0x%p probe %s : 0x%p\n",
352	//ust// iter->marker->channel,
353	//ust// iter->marker->name, iter->marker->format,
354	//ust// _imv_read(iter->marker->state),
355	//ust// iter->marker->event_id,
356	//ust// iter->marker->call,
357	//ust// iter->marker->ptype ? "multi" : "single",
358	//ust// iter->marker->ptype ?
359	//ust// (void)iter->marker->multi : (void)iter->marker->single.func);
360	//ust// return 0;
361	//ust// }
362	//ust//
363	//ust// static const struct seq_operations ltt_seq_op = {
364	//ust// .start = s_start,
365	//ust// .next = s_next,
366	//ust// .stop = s_stop,
367	//ust// .show = s_show,
368	//ust// };
369	//ust//
370	//ust// static int ltt_open(struct inode inode, struct file file)
371	//ust// {
372	//ust// /*
373	//ust// * Iterator kept in m->private.
374	//ust// * Restart iteration on all modules between reads because we do not lock
375	//ust// * the module mutex between those.
376	//ust// */
377	//ust// int ret;
378	//ust// struct marker_iter *iter;
379	//ust//
380	//ust// iter = kzalloc(sizeof(*iter), GFP_KERNEL);
381	//ust// if (!iter)
382	//ust// return -ENOMEM;
383	//ust//
384	//ust// ret = seq_open(file, &ltt_seq_op);
385	//ust// if (ret == 0)
386	//ust// ((struct seq_file *)file->private_data)->private = iter;
387	//ust// else
388	//ust// kfree(iter);
389	//ust// return ret;
390	//ust// }
391	//ust//
392	//ust// static struct file_operations ltt_fops = {
393	//ust// .write = ltt_write,
394	//ust// .open = ltt_open,
395	//ust// .read = seq_read,
396	//ust// .llseek = seq_lseek,
397	//ust// .release = seq_release_private,
398	//ust// };
399
400	static void disconnect_all_markers(void)
401	{
402	struct ltt_active_marker pdata, tmp;
403
404	list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) {
405	marker_probe_unregister_private_data(pdata->probe->probe_func,
406	pdata);
407	list_del(&pdata->node);
408	free(pdata);
409	}
410	}
411
4db647c5 PMF	412	static char initialized = 0;
	413
	414	void __attribute__((constructor)) init_marker_control(void)
ba6459ba	415	{
4db647c5 PMF	416	if(!initialized) {
4db647c5 PMF	417	int ret;
ba6459ba PMF	418
	419	//ust// pentry = create_proc_entry("ltt", S_IRUSR\|S_IWUSR, NULL);
	420	//ust// if (!pentry)
	421	//ust// return -EBUSY;
	422	//ust// markers_loaded_cachep = KMEM_CACHE(ltt_active_marker, 0);
	423
4db647c5 PMF	424	ret = ltt_probe_register(&default_probe);
	425	BUG_ON(ret);
	426	ret = ltt_marker_connect("metadata", "core_marker_format",
	427	DEFAULT_PROBE);
	428	BUG_ON(ret);
	429	ret = ltt_marker_connect("metadata", "core_marker_id", DEFAULT_PROBE);
	430	BUG_ON(ret);
ba6459ba PMF	431	//ust// pentry->proc_fops = &ltt_fops;
ba6459ba PMF	432
4db647c5 PMF	433	initialized = 1;
4db647c5 PMF	434	}
ba6459ba PMF	435	}
	436	//ust// module_init(marker_control_init);
	437
	438	static void __exit marker_control_exit(void)
	439	{
	440	int ret;
	441
	442	//ust// remove_proc_entry("ltt", NULL);
	443	ret = ltt_marker_disconnect("metadata", "core_marker_format",
	444	DEFAULT_PROBE);
	445	BUG_ON(ret);
	446	ret = ltt_marker_disconnect("metadata", "core_marker_id",
	447	DEFAULT_PROBE);
	448	BUG_ON(ret);
	449	ret = ltt_probe_unregister(&default_probe);
	450	BUG_ON(ret);
	451	disconnect_all_markers();
	452	//ust// kmem_cache_destroy(markers_loaded_cachep);
	453	//ust// marker_synchronize_unregister();
	454	}
	455	//ust// module_exit(marker_control_exit);
	456
	457	//ust// MODULE_LICENSE("GPL");
	458	//ust// MODULE_AUTHOR("Mathieu Desnoyers");
	459	//ust// MODULE_DESCRIPTION("Linux Trace Toolkit Marker Control");