[lttv.git] / usertrace-generic / ltt / ltt-facility-user_generic.h

#ifndef _LTT_FACILITY_USER_GENERIC_H_
#define _LTT_FACILITY_USER_GENERIC_H_

#include <sys/types.h>
#include <ltt/ltt-facility-id-user_generic.h>
#include <ltt/ltt-generic.h>

/* Named types */

/* Event string structures */
static inline void lttng_write_string_user_generic_string_data(
		void *buffer,
		size_t *to_base,
		size_t *to,
		const void **from,
		size_t *len,
		const char * obj)
{
	size_t size;
	size_t align;

	/* Flush pending memcpy */
	if(*len != 0) {
		if(buffer != NULL)
			memcpy(buffer+*to_base+*to, *from, *len);
	}
	*to += *len;
	*len = 0;

	align = sizeof(char);

	if(*len == 0) {
		*to += ltt_align(*to, align); /* align output */
	} else {
		*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */
	}

	/* Contains variable sized fields : must explode the structure */

	size = strlen(obj) + 1; /* Include final NULL char. */
	if(buffer != NULL)
		memcpy(buffer+*to_base+*to, obj, size);
	*to += size;

	/* Realign the *to_base on arch size, set *to to 0 */
	*to += ltt_align(*to, sizeof(void *));
	*to_base = *to_base+*to;
	*to = 0;

	/* Put source *from just after the C string */
	*from += size;
}


/* Event string logging function */
static inline int trace_user_generic_string(
		const char * lttng_param_data)
#ifndef LTT_TRACE
{
}
#else
{
	void *buffer = NULL;
	size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */
	size_t *to_base = &real_to_base;
	size_t real_to = 0;
	size_t *to = &real_to;
	size_t real_len = 0;
	size_t *len = &real_len;
	size_t reserve_size;
	size_t slot_size;
	int ret = 0;
	const void *real_from;
	const void **from = &real_from;
		/* For each field, calculate the field size. */
	/* size = *to_base + *to + *len */
	/* Assume that the padding for alignment starts at a
	 * sizeof(void *) address. */

	*from = lttng_param_data;
	lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data);

	reserve_size = *to_base + *to + *len;
	{
		char stack_buffer[reserve_size];
		buffer = stack_buffer;

		*to_base = *to = *len = 0;

		*from = lttng_param_data;
		lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data);

		/* Flush pending memcpy */
		if(*len != 0) {
			memcpy(buffer+*to_base+*to, *from, *len);
			*to += *len;
			*len = 0;
		}

		ret = ltt_trace_generic(ltt_facility_user_generic_411B0F83, event_user_generic_string, stack_buffer, sizeof(stack_buffer), LTT_BLOCKING);
	}

	return ret;

}
#endif //LTT_TRACE

/* Event string_pointer structures */
static inline void lttng_write_string_user_generic_string_pointer_string(
		void *buffer,
		size_t *to_base,
		size_t *to,
		const void **from,
		size_t *len,
		const char * obj)
{
	size_t size;
	size_t align;

	/* Flush pending memcpy */
	if(*len != 0) {
		if(buffer != NULL)
			memcpy(buffer+*to_base+*to, *from, *len);
	}
	*to += *len;
	*len = 0;

	align = sizeof(char);

	if(*len == 0) {
		*to += ltt_align(*to, align); /* align output */
	} else {
		*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */
	}

	/* Contains variable sized fields : must explode the structure */

	size = strlen(obj) + 1; /* Include final NULL char. */
	if(buffer != NULL)
		memcpy(buffer+*to_base+*to, obj, size);
	*to += size;

	/* Realign the *to_base on arch size, set *to to 0 */
	*to += ltt_align(*to, sizeof(void *));
	*to_base = *to_base+*to;
	*to = 0;

	/* Put source *from just after the C string */
	*from += size;
}


/* Event string_pointer logging function */
static inline int trace_user_generic_string_pointer(
		const char * lttng_param_string,
		const void * lttng_param_pointer)
#ifndef LTT_TRACE
{
}
#else
{
	void *buffer = NULL;
	size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */
	size_t *to_base = &real_to_base;
	size_t real_to = 0;
	size_t *to = &real_to;
	size_t real_len = 0;
	size_t *len = &real_len;
	size_t reserve_size;
	size_t slot_size;
	int ret = 0;
	size_t align;
	const void *real_from;
	const void **from = &real_from;
		/* For each field, calculate the field size. */
	/* size = *to_base + *to + *len */
	/* Assume that the padding for alignment starts at a
	 * sizeof(void *) address. */

	*from = lttng_param_string;
	lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string);

	*from = &lttng_param_pointer;
	align = sizeof(const void *);

	if(*len == 0) {
		*to += ltt_align(*to, align); /* align output */
	} else {
		*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */
	}

	*len += sizeof(const void *);

	reserve_size = *to_base + *to + *len;
	{
		char stack_buffer[reserve_size];
		buffer = stack_buffer;

		*to_base = *to = *len = 0;

		*from = lttng_param_string;
		lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string);

		/* Flush pending memcpy */
		if(*len != 0) {
			memcpy(buffer+*to_base+*to, *from, *len);
			*to += *len;
			*len = 0;
		}

		*from = &lttng_param_pointer;
		align = sizeof(const void *);

		if(*len == 0) {
			*to += ltt_align(*to, align); /* align output */
		} else {
			*len += ltt_align(*to+*len, align); /* alignment, ok to do a memcpy of it */
		}

		*len += sizeof(const void *);

		/* Flush pending memcpy */
		if(*len != 0) {
			memcpy(buffer+*to_base+*to, *from, *len);
			*to += *len;
			*len = 0;
		}

		ret = ltt_trace_generic(ltt_facility_user_generic_411B0F83, event_user_generic_string_pointer, stack_buffer, sizeof(stack_buffer), LTT_BLOCKING);
	}

	return ret;

}
#endif //LTT_TRACE

#endif //_LTT_FACILITY_USER_GENERIC_H_
Commit	Line	Data
3d57eb5b	1	#ifndef _LTT_FACILITY_USER_GENERIC_H_
	2	#define _LTT_FACILITY_USER_GENERIC_H_
	3
	4	#include <sys/types.h>
	5	#include <ltt/ltt-facility-id-user_generic.h>
	6	#include <ltt/ltt-generic.h>
	7
	8	/* Named types */
	9
	10	/* Event string structures */
	11	static inline void lttng_write_string_user_generic_string_data(
	12	void *buffer,
	13	size_t *to_base,
	14	size_t *to,
	15	const void **from,
	16	size_t *len,
	17	const char * obj)
	18	{
	19	size_t size;
	20	size_t align;
	21
	22	/* Flush pending memcpy */
	23	if(*len != 0) {
	24	if(buffer != NULL)
	25	memcpy(buffer+to_base+to, from, len);
	26	}
	27	to += len;
	28	*len = 0;
	29
	30	align = sizeof(char);
	31
	32	if(*len == 0) {
	33	to += ltt_align(to, align); /* align output */
	34	} else {
	35	len += ltt_align(to+len, align); / alignment, ok to do a memcpy of it */
	36	}
	37
	38	/* Contains variable sized fields : must explode the structure */
	39
	40	size = strlen(obj) + 1; /* Include final NULL char. */
	41	if(buffer != NULL)
	42	memcpy(buffer+to_base+to, obj, size);
	43	*to += size;
	44
	45	/* Realign the to_base on arch size, set to to 0 */
	46	to += ltt_align(to, sizeof(void *));
	47	to_base = to_base+*to;
	48	*to = 0;
	49
	50	/* Put source from just after the C string /
	51	*from += size;
	52	}
	53
	54
	55	/* Event string logging function */
	56	static inline int trace_user_generic_string(
	57	const char * lttng_param_data)
	58	#ifndef LTT_TRACE
	59	{
	60	}
	61	#else
	62	{
	63	void *buffer = NULL;
	64	size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */
65	size_t *to_base = &real_to_base;
66	size_t real_to = 0;
67	size_t *to = &real_to;
68	size_t real_len = 0;
69	size_t *len = &real_len;
70	size_t reserve_size;
71	size_t slot_size;
72	int ret = 0;
73	const void *real_from;
74	const void **from = &real_from;
75	/* For each field, calculate the field size. */
76	/* size = to_base + to + len /
77	/* Assume that the padding for alignment starts at a
78	* sizeof(void ) address. /
79
80	*from = lttng_param_data;
81	lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data);
82
83	reserve_size = to_base + to + *len;
84	{
85	char stack_buffer[reserve_size];
86	buffer = stack_buffer;
87
88	to_base = to = *len = 0;
89
90	*from = lttng_param_data;
91	lttng_write_string_user_generic_string_data(buffer, to_base, to, from, len, lttng_param_data);
92
93	/* Flush pending memcpy */
94	if(*len != 0) {
95	memcpy(buffer+to_base+to, from, len);
96	to += len;
97	*len = 0;
98	}
99
972a52cf	100	ret = ltt_trace_generic(ltt_facility_user_generic_411B0F83, event_user_generic_string, stack_buffer, sizeof(stack_buffer), LTT_BLOCKING);
3d57eb5b	101	}
	102
	103	return ret;
	104
	105	}
	106	#endif //LTT_TRACE
	107
	108	/* Event string_pointer structures */
	109	static inline void lttng_write_string_user_generic_string_pointer_string(
	110	void *buffer,
	111	size_t *to_base,
	112	size_t *to,
	113	const void **from,
	114	size_t *len,
	115	const char * obj)
	116	{
	117	size_t size;
	118	size_t align;
	119
	120	/* Flush pending memcpy */
	121	if(*len != 0) {
	122	if(buffer != NULL)
	123	memcpy(buffer+to_base+to, from, len);
	124	}
	125	to += len;
	126	*len = 0;
	127
	128	align = sizeof(char);
	129
	130	if(*len == 0) {
	131	to += ltt_align(to, align); /* align output */
	132	} else {
	133	len += ltt_align(to+len, align); / alignment, ok to do a memcpy of it */
	134	}
	135
	136	/* Contains variable sized fields : must explode the structure */
	137
	138	size = strlen(obj) + 1; /* Include final NULL char. */
	139	if(buffer != NULL)
	140	memcpy(buffer+to_base+to, obj, size);
	141	*to += size;
	142
	143	/* Realign the to_base on arch size, set to to 0 */
	144	to += ltt_align(to, sizeof(void *));
	145	to_base = to_base+*to;
	146	*to = 0;
	147
	148	/* Put source from just after the C string /
	149	*from += size;
	150	}
	151
	152
	153	/* Event string_pointer logging function */
	154	static inline int trace_user_generic_string_pointer(
	155	const char * lttng_param_string,
	156	const void * lttng_param_pointer)
	157	#ifndef LTT_TRACE
	158	{
	159	}
	160	#else
	161	{
	162	void *buffer = NULL;
	163	size_t real_to_base = 0; /* The buffer is allocated on arch_size alignment */
	164	size_t *to_base = &real_to_base;
165	size_t real_to = 0;
166	size_t *to = &real_to;
167	size_t real_len = 0;
168	size_t *len = &real_len;
169	size_t reserve_size;
170	size_t slot_size;
171	int ret = 0;
172	size_t align;
173	const void *real_from;
174	const void **from = &real_from;
175	/* For each field, calculate the field size. */
176	/* size = to_base + to + len /
177	/* Assume that the padding for alignment starts at a
178	* sizeof(void ) address. /
179
180	*from = lttng_param_string;
181	lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string);
182
183	*from = &lttng_param_pointer;
184	align = sizeof(const void *);
185
186	if(*len == 0) {
187	to += ltt_align(to, align); /* align output */
188	} else {
189	len += ltt_align(to+len, align); / alignment, ok to do a memcpy of it */
190	}
191
192	len += sizeof(const void );
193
194	reserve_size = to_base + to + *len;
195	{
196	char stack_buffer[reserve_size];
197	buffer = stack_buffer;
198
199	to_base = to = *len = 0;
200
201	*from = lttng_param_string;
202	lttng_write_string_user_generic_string_pointer_string(buffer, to_base, to, from, len, lttng_param_string);
203
204	/* Flush pending memcpy */
205	if(*len != 0) {
206	memcpy(buffer+to_base+to, from, len);
207	to += len;
208	*len = 0;
209	}
210
211	*from = &lttng_param_pointer;
212	align = sizeof(const void *);
213
214	if(*len == 0) {
215	to += ltt_align(to, align); /* align output */
216	} else {
217	len += ltt_align(to+len, align); / alignment, ok to do a memcpy of it */
218	}
219
220	len += sizeof(const void );
221
222	/* Flush pending memcpy */
223	if(*len != 0) {
224	memcpy(buffer+to_base+to, from, len);
225	to += len;
226	*len = 0;
227	}
228
972a52cf	229	ret = ltt_trace_generic(ltt_facility_user_generic_411B0F83, event_user_generic_string_pointer, stack_buffer, sizeof(stack_buffer), LTT_BLOCKING);
3d57eb5b	230	}
	231
	232	return ret;
	233
	234	}
	235	#endif //LTT_TRACE
	236
	237	#endif //_LTT_FACILITY_USER_GENERIC_H_