[lttng-modules.git] / probes / lttng-types.c

/*
 * probes/lttng-types.c
 *
 * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * LTTng types.
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/seq_file.h>
#include <linux/jbd.h>	/* tid_t */
#include <linux/debugfs.h>
#include "lttng-types.h"

struct dentry *lttng_types_dentry;

#undef ENTRY
#define ENTRY(name)	[atype_##name] = #name

const char * const astract_types[NR_ABSTRACT_TYPES] = {
	ENTRY(integer),
	ENTRY(enum),
	ENTRY(array),
	ENTRY(sequence),
	ENTRY(string),
};

#undef ENTRY
#define ENTRY(name)	[lttng_encode_##name] = #name

const char * const string_encodings[NR_STRING_ENCODINGS] = {
	ENTRY(UTF8),
	ENTRY(ASCII),
};

#define STAGE_EXPORT_ENUMS
#include "lttng-types.h"
#include "lttng-type-list.h"
#undef STAGE_EXPORT_ENUMS

struct lttng_type lttng_types[] = {
#define STAGE_EXPORT_TYPES
#include "lttng-types.h"
#include "lttng-type-list.h"
#undef STAGE_EXPORT_TYPES
};

static void print_enum(struct seq_file *m, const struct lttng_enum *lttng_enum)
{
	int i;

	for (i = 0; i < lttng_enum->len; i++) {
		if (lttng_enum->entries[i].start == lttng_enum->entries[i].end)
			seq_printf(m,	"\t\t{ %llu, %s },\n",
					lttng_enum->entries[i].start,
					lttng_enum->entries[i].string);
		else
			seq_printf(m,	"\t\t{ { %llu, %llu }, %s },\n",
					lttng_enum->entries[i].start,
					lttng_enum->entries[i].end,
					lttng_enum->entries[i].string);
	}
}

static void print_event_type(struct seq_file *m, const struct lttng_type *type)
{
	switch(type->atype) {
	case atype_integer:
		seq_printf(m,	"type %s {\n"
				"\tparent = %s;\n"
				"\tsize = %u;\n"
				"\tsigned = %u;\n"
				"\talign = %u;\n",
				type->name,
				astract_types[type->atype],
				type->u.integer.size,
				type->u.integer.signedness,
				type->u.integer.alignment);
		if (type->u.integer.reverse_byte_order)
			seq_printf(m, 	"\tbyte_order = %s;\n",
					(__BYTE_ORDER == __LITTLE_ENDIAN) ?
					"be" : "le");
		seq_printf(m, 	"};\n");
		break;
	case atype_enum:
		seq_printf(m,	"type %s {\n"
				"\tparent = %s;\n"
				"\tparent.parent = %s;\n"
				"\tmap = {\n",
				type->name,
				astract_types[type->atype],
				type->u.enumeration.parent_type);
		print_enum(m, &type->u.enumeration.def);
		seq_printf(m,	"\t};\n"
				"};\n");
		break;
	case atype_array:
		seq_printf(m,	"type %s {\n"
				"\tparent = %s;\n"
				"\telem_type = %s;\n"
				"\tlength = %u;\n"
				"};\n", type->name,
				astract_types[type->atype],
				type->u.array.elem_type,
				type->u.array.length);
		break;
	case atype_sequence:
		seq_printf(m,	"type %s {\n"
				"\tparent = %s;\n"
				"\telem_type = %s;\n"
				"\tlength_type = %s;\n"
				"};\n", type->name,
				astract_types[type->atype],
				type->u.sequence.elem_type,
				type->u.sequence.length_type);
		break;
	case atype_string:
		seq_printf(m,	"type %s {\n"
				"\tparent = %s;\n"
				"\tencoding = %s;\n"
				"};\n", type->name,
				astract_types[type->atype],
				string_encodings[type->u.string.encoding]);
		break;
	default:
		seq_printf(m,	"<<< unknown abstract type %s for type %s >>>\n",
				astract_types[type->atype],
				type->name);
	}
}

static void *lttng_seq_start(struct seq_file *m, loff_t *pos)
{
	struct lttng_type *type = &lttng_types[*pos];

	if (type > &lttng_types[ARRAY_SIZE(lttng_types) - 1])
		return NULL;
	return type;
}

static void *lttng_seq_next(struct seq_file *m, void *v, loff_t *ppos)
{
	struct lttng_type *type = &lttng_types[++(*ppos)];

	if (type > &lttng_types[ARRAY_SIZE(lttng_types) - 1])
		return NULL;
	return type;
}

static void lttng_seq_stop(struct seq_file *m, void *v)
{
}

static int lttng_seq_show(struct seq_file *m, void *v)
{
	struct lttng_type *type = v;

	print_event_type(m, type);
	return 0;
}

static const struct seq_operations lttng_types_seq_ops = {
	.start = lttng_seq_start,
	.next = lttng_seq_next,
	.stop = lttng_seq_stop,
	.show = lttng_seq_show,
};

static int
lttng_types_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &lttng_types_seq_ops);
}

static const struct file_operations lttng_types_fops = {
	.open = lttng_types_open,
        .read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release_private,
};

static int lttng_types_init(void)
{
	int ret = 0;

	lttng_types_dentry = debugfs_create_file("lttng-types", S_IWUSR,
					NULL, NULL, &lttng_types_fops);
	if (IS_ERR(lttng_types_dentry) || !lttng_types_dentry) {
		printk(KERN_ERR "Error creating LTTng type export file\n");
		ret = -ENOMEM;
		goto error;
	}
error:
	return ret;
}

module_init(lttng_types_init);

static void lttng_types_exit(void)
{
	debugfs_remove(lttng_types_dentry);
}

module_exit(lttng_types_exit);

MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
MODULE_DESCRIPTION("LTTng types");
Commit	Line	Data
40652b65 MD	1	/*
	2	* probes/lttng-types.c
	3	*
	4	* Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	5	*
	6	* LTTng types.
	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/types.h>
	11	#include <linux/seq_file.h>
	12	#include <linux/jbd.h> /* tid_t */
	13	#include <linux/debugfs.h>
	14	#include "lttng-types.h"
	15
	16	struct dentry *lttng_types_dentry;
	17
1d12cebd MD	18	#undef ENTRY
1d12cebd MD	19	#define ENTRY(name) [atype_##name] = #name
40652b65 MD	20
40652b65 MD	21	const char * const astract_types[NR_ABSTRACT_TYPES] = {
1d12cebd MD	22	ENTRY(integer),
	23	ENTRY(enum),
	24	ENTRY(array),
	25	ENTRY(sequence),
	26	ENTRY(string),
	27	};
	28
	29	#undef ENTRY
	30	#define ENTRY(name) [lttng_encode_##name] = #name
	31
	32	const char * const string_encodings[NR_STRING_ENCODINGS] = {
	33	ENTRY(UTF8),
	34	ENTRY(ASCII),
40652b65 MD	35	};
	36
	37	#define STAGE_EXPORT_ENUMS
	38	#include "lttng-types.h"
	39	#include "lttng-type-list.h"
	40	#undef STAGE_EXPORT_ENUMS
	41
	42	struct lttng_type lttng_types[] = {
	43	#define STAGE_EXPORT_TYPES
	44	#include "lttng-types.h"
	45	#include "lttng-type-list.h"
	46	#undef STAGE_EXPORT_TYPES
	47	};
	48
	49	static void print_enum(struct seq_file m, const struct lttng_enum lttng_enum)
	50	{
	51	int i;
	52
	53	for (i = 0; i < lttng_enum->len; i++) {
	54	if (lttng_enum->entries[i].start == lttng_enum->entries[i].end)
	55	seq_printf(m, "\t\t{ %llu, %s },\n",
	56	lttng_enum->entries[i].start,
	57	lttng_enum->entries[i].string);
	58	else
	59	seq_printf(m, "\t\t{ { %llu, %llu }, %s },\n",
	60	lttng_enum->entries[i].start,
	61	lttng_enum->entries[i].end,
	62	lttng_enum->entries[i].string);
	63	}
	64	}
	65
	66	static void print_event_type(struct seq_file m, const struct lttng_type type)
	67	{
	68	switch(type->atype) {
	69	case atype_integer:
	70	seq_printf(m, "type %s {\n"
	71	"\tparent = %s;\n"
	72	"\tsize = %u;\n"
	73	"\tsigned = %u;\n"
1d12cebd MD	74	"\talign = %u;\n",
1d12cebd MD	75	type->name,
40652b65 MD	76	astract_types[type->atype],
	77	type->u.integer.size,
	78	type->u.integer.signedness,
	79	type->u.integer.alignment);
1d12cebd MD	80	if (type->u.integer.reverse_byte_order)
	81	seq_printf(m, "\tbyte_order = %s;\n",
	82	(__BYTE_ORDER == __LITTLE_ENDIAN) ?
	83	"be" : "le");
	84	seq_printf(m, "};\n");
40652b65 MD	85	break;
	86	case atype_enum:
	87	seq_printf(m, "type %s {\n"
	88	"\tparent = %s;\n"
	89	"\tparent.parent = %s;\n"
	90	"\tmap = {\n",
	91	type->name,
	92	astract_types[type->atype],
	93	type->u.enumeration.parent_type);
	94	print_enum(m, &type->u.enumeration.def);
	95	seq_printf(m, "\t};\n"
	96	"};\n");
	97	break;
	98	case atype_array:
	99	seq_printf(m, "type %s {\n"
	100	"\tparent = %s;\n"
	101	"\telem_type = %s;\n"
	102	"\tlength = %u;\n"
	103	"};\n", type->name,
	104	astract_types[type->atype],
	105	type->u.array.elem_type,
	106	type->u.array.length);
	107	break;
1d12cebd MD	108	case atype_sequence:
	109	seq_printf(m, "type %s {\n"
	110	"\tparent = %s;\n"
	111	"\telem_type = %s;\n"
	112	"\tlength_type = %s;\n"
	113	"};\n", type->name,
	114	astract_types[type->atype],
	115	type->u.sequence.elem_type,
	116	type->u.sequence.length_type);
	117	break;
	118	case atype_string:
	119	seq_printf(m, "type %s {\n"
	120	"\tparent = %s;\n"
	121	"\tencoding = %s;\n"
	122	"};\n", type->name,
	123	astract_types[type->atype],
	124	string_encodings[type->u.string.encoding]);
	125	break;
40652b65 MD	126	default:
	127	seq_printf(m, "<<< unknown abstract type %s for type %s >>>\n",
	128	astract_types[type->atype],
	129	type->name);
	130	}
	131	}
	132
	133	static void lttng_seq_start(struct seq_file m, loff_t *pos)
	134	{
	135	struct lttng_type type = &lttng_types[pos];
	136
	137	if (type > &lttng_types[ARRAY_SIZE(lttng_types) - 1])
	138	return NULL;
	139	return type;
	140	}
	141
	142	static void lttng_seq_next(struct seq_file m, void v, loff_t ppos)
	143	{
	144	struct lttng_type type = &lttng_types[++(ppos)];
	145
	146	if (type > &lttng_types[ARRAY_SIZE(lttng_types) - 1])
	147	return NULL;
	148	return type;
	149	}
	150
	151	static void lttng_seq_stop(struct seq_file m, void v)
	152	{
	153	}
	154
	155	static int lttng_seq_show(struct seq_file m, void v)
	156	{
	157	struct lttng_type *type = v;
	158
	159	print_event_type(m, type);
	160	return 0;
	161	}
	162
	163	static const struct seq_operations lttng_types_seq_ops = {
	164	.start = lttng_seq_start,
	165	.next = lttng_seq_next,
	166	.stop = lttng_seq_stop,
	167	.show = lttng_seq_show,
	168	};
	169
	170	static int
	171	lttng_types_open(struct inode inode, struct file file)
	172	{
	173	return seq_open(file, &lttng_types_seq_ops);
	174	}
	175
	176	static const struct file_operations lttng_types_fops = {
	177	.open = lttng_types_open,
	178	.read = seq_read,
	179	.llseek = seq_lseek,
	180	.release = seq_release_private,
	181	};
	182
	183	static int lttng_types_init(void)
	184	{
	185	int ret = 0;
	186
	187	lttng_types_dentry = debugfs_create_file("lttng-types", S_IWUSR,
	188	NULL, NULL, &lttng_types_fops);
	189	if (IS_ERR(lttng_types_dentry) \|\| !lttng_types_dentry) {
190	printk(KERN_ERR "Error creating LTTng type export file\n");
191	ret = -ENOMEM;
192	goto error;
193	}
194	error:
195	return ret;
196	}
197
198	module_init(lttng_types_init);
199
200	static void lttng_types_exit(void)
201	{
202	debugfs_remove(lttng_types_dentry);
203	}
204
205	module_exit(lttng_types_exit);
206
207	MODULE_LICENSE("GPL and additional rights");
208	MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
209	MODULE_DESCRIPTION("LTTng types");