[lttv.git] / lttv / lttv / sync / event_processing_lttng_common.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2009 Benjamin Poirier <benjamin.poirier@polymtl.ca>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * 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.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "data_structures.h"
#include "event_processing_lttng_common.h"


/*
 * Initialize the GQuarks needed to register the event hooks for
 * synchronization
 */
void createQuarks()
{
	LTT_CHANNEL_NET= g_quark_from_static_string("net");

	LTT_EVENT_DEV_XMIT_EXTENDED= g_quark_from_static_string("dev_xmit_extended");
	LTT_EVENT_DEV_RECEIVE= g_quark_from_static_string("dev_receive");
	LTT_EVENT_TCPV4_RCV_EXTENDED= g_quark_from_static_string("tcpv4_rcv_extended");
	LTT_EVENT_UDPV4_RCV_EXTENDED= g_quark_from_static_string("udpv4_rcv_extended");

	LTT_FIELD_SKB= g_quark_from_static_string("skb");
	LTT_FIELD_PROTOCOL= g_quark_from_static_string("protocol");
	LTT_FIELD_NETWORK_PROTOCOL=
		g_quark_from_static_string("network_protocol");
	LTT_FIELD_TRANSPORT_PROTOCOL=
		g_quark_from_static_string("transport_protocol");
	LTT_FIELD_SADDR= g_quark_from_static_string("saddr");
	LTT_FIELD_DADDR= g_quark_from_static_string("daddr");
	LTT_FIELD_TOT_LEN= g_quark_from_static_string("tot_len");
	LTT_FIELD_IHL= g_quark_from_static_string("ihl");
	LTT_FIELD_SOURCE= g_quark_from_static_string("source");
	LTT_FIELD_DEST= g_quark_from_static_string("dest");
	LTT_FIELD_SEQ= g_quark_from_static_string("seq");
	LTT_FIELD_ACK_SEQ= g_quark_from_static_string("ack_seq");
	LTT_FIELD_DOFF= g_quark_from_static_string("doff");
	LTT_FIELD_ACK= g_quark_from_static_string("ack");
	LTT_FIELD_RST= g_quark_from_static_string("rst");
	LTT_FIELD_SYN= g_quark_from_static_string("syn");
	LTT_FIELD_FIN= g_quark_from_static_string("fin");
	LTT_FIELD_UNICAST= g_quark_from_static_string("unicast");
	LTT_FIELD_ULEN= g_quark_from_static_string("ulen");
	LTT_FIELD_DATA_START= g_quark_from_static_string("data_start");
}


/* Fill hookListList and add event hooks
 *
 * Note: possibilité de remettre le code avec lttv_trace_find_marker_ids (voir
 * r328)
 *
 * Args:
 *   hookListList: LttvTraceHook hookListList[traceNum][hookNum]
 *   traceSetContext: LTTV traceset
 *   hookFunction: call back function when event is encountered
 *   hookData:     data that will be made accessible to hookFunction in
 *                 arg0->hook_data
 *   eventTypes:   types of events for which to register hooks
 */
void registerHooks(GArray* hookListList, LttvTracesetContext* const
	traceSetContext, LttvHook hookFunction, gpointer hookData, const bool
	const* eventTypes)
{
	unsigned int i, j, k;
	unsigned int traceNb= lttv_traceset_number(traceSetContext->ts);
	struct {
		GQuark channelName;
		GQuark eventName;
		GQuark* fields;
		bool eventTypes[TYPE_COUNT];
	} eventHookInfoList[] = {
		{
			.channelName= LTT_CHANNEL_NET,
			.eventName= LTT_EVENT_DEV_XMIT_EXTENDED,
			.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_NETWORK_PROTOCOL,
				LTT_FIELD_TRANSPORT_PROTOCOL, LTT_FIELD_SADDR,
				LTT_FIELD_DADDR, LTT_FIELD_TOT_LEN, LTT_FIELD_IHL,
				LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_SEQ,
				LTT_FIELD_ACK_SEQ, LTT_FIELD_DOFF, LTT_FIELD_ACK,
				LTT_FIELD_RST, LTT_FIELD_SYN, LTT_FIELD_FIN),
			.eventTypes[TCP]= true,
			.eventTypes[UDP]= true,
		}, {
			.channelName= LTT_CHANNEL_NET,
			.eventName= LTT_EVENT_DEV_RECEIVE,
			.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_PROTOCOL),
			.eventTypes[TCP]= true,
			.eventTypes[UDP]= true,
		}, {
			.channelName= LTT_CHANNEL_NET,
			.eventName= LTT_EVENT_TCPV4_RCV_EXTENDED,
			.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_SADDR,
				LTT_FIELD_DADDR, LTT_FIELD_TOT_LEN, LTT_FIELD_IHL,
				LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_SEQ,
				LTT_FIELD_ACK_SEQ, LTT_FIELD_DOFF, LTT_FIELD_ACK,
				LTT_FIELD_RST, LTT_FIELD_SYN, LTT_FIELD_FIN),
			.eventTypes[TCP]= true,
			.eventTypes[UDP]= false,
		}, {
			.channelName= LTT_CHANNEL_NET,
			.eventName= LTT_EVENT_UDPV4_RCV_EXTENDED,
			.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_SADDR,
				LTT_FIELD_DADDR, LTT_FIELD_UNICAST, LTT_FIELD_ULEN,
				LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_DATA_START),
			.eventTypes[TCP]= false,
			.eventTypes[UDP]= true,
		}
	}; // This is called a compound literal
	unsigned int hookNb= sizeof(eventHookInfoList) / sizeof(*eventHookInfoList);

	for(i= 0; i < traceNb; i++)
	{
		LttvTraceContext* tc;
		GArray* hookList;
		int retval;

		tc= traceSetContext->traces[i];
		hookList= g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
		g_array_append_val(hookListList, hookList);

		// Find the hooks
		for (j= 0; j < hookNb; j++)
		{
			guint old_len;
			bool registerHook;

			registerHook= false;
			for (k= 0; k < TYPE_COUNT; k++)
			{
				if (eventTypes[k] && eventHookInfoList[j].eventTypes[k])
				{
					registerHook= true;
					break;
				}
			}
			if (!registerHook)
			{
				continue;
			}

			old_len= hookList->len;
			retval= lttv_trace_find_hook(tc->t,
				eventHookInfoList[j].channelName,
				eventHookInfoList[j].eventName, eventHookInfoList[j].fields,
				hookFunction, hookData, &hookList);
			if (retval != 0)
			{
				g_warning("Trace %d contains no %s.%s marker\n", i,
					g_quark_to_string(eventHookInfoList[j].channelName),
					g_quark_to_string(eventHookInfoList[j].eventName));
			}
			else
			{
				g_assert(hookList->len - old_len == 1);
			}
		}

		// Add the hooks to each tracefile's event_by_id hook list
		for(j= 0; j < tc->tracefiles->len; j++)
		{
			LttvTracefileContext* tfc;

			tfc= g_array_index(tc->tracefiles, LttvTracefileContext*, j);

			for(k= 0; k < hookList->len; k++)
			{
				LttvTraceHook* traceHook;

				traceHook= &g_array_index(hookList, LttvTraceHook, k);
				if (traceHook->hook_data != hookData)
				{
					g_assert_not_reached();
				}
				if (traceHook->mdata == tfc->tf->mdata)
				{
					lttv_hooks_add(lttv_hooks_by_id_find(tfc->event_by_id,
							traceHook->id), traceHook->h, traceHook,
						LTTV_PRIO_DEFAULT);
				}
			}
		}
	}
}


/* Remove event hooks and free hookListList
 *
 * Args:
 *   hookListList: LttvTraceHook hookListList[traceNum][hookNum]
 *   traceSetContext: LTTV traceset
 */
void unregisterHooks(GArray* hookListList, LttvTracesetContext* const
	traceSetContext)
{
	unsigned int i, j, k;
	unsigned int traceNb= lttv_traceset_number(traceSetContext->ts);

	for(i= 0; i < traceNb; i++)
	{
		LttvTraceContext* tc;
		GArray* hookList;

		tc= traceSetContext->traces[i];
		hookList= g_array_index(hookListList, GArray*, i);

		// Remove the hooks from each tracefile's event_by_id hook list
		for(j= 0; j < tc->tracefiles->len; j++)
		{
			LttvTracefileContext* tfc;

			tfc= g_array_index(tc->tracefiles, LttvTracefileContext*, j);

			for(k= 0; k < hookList->len; k++)
			{
				LttvTraceHook* traceHook;

				traceHook= &g_array_index(hookList, LttvTraceHook, k);
				if (traceHook->mdata == tfc->tf->mdata)
				{
					lttv_hooks_remove_data(lttv_hooks_by_id_find(tfc->event_by_id,
							traceHook->id), traceHook->h, traceHook);
				}
			}
		}

		g_array_free(hookList, TRUE);
	}
	g_array_free(hookListList, TRUE);
}
Commit	Line	Data
70407e86 BP	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2009 Benjamin Poirier <benjamin.poirier@polymtl.ca>
	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 Version 2 as
	6	* published by the Free Software Foundation;
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
	15	* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	16	* MA 02111-1307, USA.
	17	*/
	18
	19	#ifdef HAVE_CONFIG_H
	20	#include <config.h>
	21	#endif
	22
f6691532	23	#include "data_structures.h"
10341d26	24	#include "event_processing_lttng_common.h"
70407e86 BP	25
70407e86 BP	26
70407e86 BP	27	/*
	28	* Initialize the GQuarks needed to register the event hooks for
	29	* synchronization
	30	*/
	31	void createQuarks()
	32	{
	33	LTT_CHANNEL_NET= g_quark_from_static_string("net");
70407e86	34
fea7219b	35	LTT_EVENT_DEV_XMIT_EXTENDED= g_quark_from_static_string("dev_xmit_extended");
70407e86	36	LTT_EVENT_DEV_RECEIVE= g_quark_from_static_string("dev_receive");
fea7219b	37	LTT_EVENT_TCPV4_RCV_EXTENDED= g_quark_from_static_string("tcpv4_rcv_extended");
f6691532	38	LTT_EVENT_UDPV4_RCV_EXTENDED= g_quark_from_static_string("udpv4_rcv_extended");
70407e86 BP	39
	40	LTT_FIELD_SKB= g_quark_from_static_string("skb");
	41	LTT_FIELD_PROTOCOL= g_quark_from_static_string("protocol");
	42	LTT_FIELD_NETWORK_PROTOCOL=
	43	g_quark_from_static_string("network_protocol");
	44	LTT_FIELD_TRANSPORT_PROTOCOL=
	45	g_quark_from_static_string("transport_protocol");
	46	LTT_FIELD_SADDR= g_quark_from_static_string("saddr");
	47	LTT_FIELD_DADDR= g_quark_from_static_string("daddr");
	48	LTT_FIELD_TOT_LEN= g_quark_from_static_string("tot_len");
	49	LTT_FIELD_IHL= g_quark_from_static_string("ihl");
	50	LTT_FIELD_SOURCE= g_quark_from_static_string("source");
	51	LTT_FIELD_DEST= g_quark_from_static_string("dest");
	52	LTT_FIELD_SEQ= g_quark_from_static_string("seq");
	53	LTT_FIELD_ACK_SEQ= g_quark_from_static_string("ack_seq");
	54	LTT_FIELD_DOFF= g_quark_from_static_string("doff");
	55	LTT_FIELD_ACK= g_quark_from_static_string("ack");
	56	LTT_FIELD_RST= g_quark_from_static_string("rst");
	57	LTT_FIELD_SYN= g_quark_from_static_string("syn");
	58	LTT_FIELD_FIN= g_quark_from_static_string("fin");
f6691532 BP	59	LTT_FIELD_UNICAST= g_quark_from_static_string("unicast");
	60	LTT_FIELD_ULEN= g_quark_from_static_string("ulen");
	61	LTT_FIELD_DATA_START= g_quark_from_static_string("data_start");
70407e86 BP	62	}
	63
	64
	65	/* Fill hookListList and add event hooks
	66	*
	67	* Note: possibilité de remettre le code avec lttv_trace_find_marker_ids (voir
	68	* r328)
	69	*
	70	* Args:
08365995 BP	71	* hookListList: LttvTraceHook hookListList[traceNum][hookNum]
	72	* traceSetContext: LTTV traceset
	73	* hookFunction: call back function when event is encountered
	74	* hookData: data that will be made accessible to hookFunction in
	75	* arg0->hook_data
f6691532	76	* eventTypes: types of events for which to register hooks
70407e86 BP	77	*/
70407e86 BP	78	void registerHooks(GArray* hookListList, LttvTracesetContext* const
f6691532 BP	79	traceSetContext, LttvHook hookFunction, gpointer hookData, const bool
f6691532 BP	80	const* eventTypes)
70407e86 BP	81	{
70407e86 BP	82	unsigned int i, j, k;
08365995 BP	83	unsigned int traceNb= lttv_traceset_number(traceSetContext->ts);
	84	struct {
	85	GQuark channelName;
	86	GQuark eventName;
	87	GQuark* fields;
f6691532	88	bool eventTypes[TYPE_COUNT];
08365995 BP	89	} eventHookInfoList[] = {
	90	{
	91	.channelName= LTT_CHANNEL_NET,
fea7219b	92	.eventName= LTT_EVENT_DEV_XMIT_EXTENDED,
08365995 BP	93	.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_NETWORK_PROTOCOL,
	94	LTT_FIELD_TRANSPORT_PROTOCOL, LTT_FIELD_SADDR,
	95	LTT_FIELD_DADDR, LTT_FIELD_TOT_LEN, LTT_FIELD_IHL,
	96	LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_SEQ,
	97	LTT_FIELD_ACK_SEQ, LTT_FIELD_DOFF, LTT_FIELD_ACK,
	98	LTT_FIELD_RST, LTT_FIELD_SYN, LTT_FIELD_FIN),
f6691532 BP	99	.eventTypes[TCP]= true,
f6691532 BP	100	.eventTypes[UDP]= true,
08365995 BP	101	}, {
	102	.channelName= LTT_CHANNEL_NET,
	103	.eventName= LTT_EVENT_DEV_RECEIVE,
	104	.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_PROTOCOL),
f6691532 BP	105	.eventTypes[TCP]= true,
f6691532 BP	106	.eventTypes[UDP]= true,
08365995 BP	107	}, {
08365995 BP	108	.channelName= LTT_CHANNEL_NET,
fea7219b	109	.eventName= LTT_EVENT_TCPV4_RCV_EXTENDED,
08365995 BP	110	.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_SADDR,
	111	LTT_FIELD_DADDR, LTT_FIELD_TOT_LEN, LTT_FIELD_IHL,
	112	LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_SEQ,
	113	LTT_FIELD_ACK_SEQ, LTT_FIELD_DOFF, LTT_FIELD_ACK,
	114	LTT_FIELD_RST, LTT_FIELD_SYN, LTT_FIELD_FIN),
f6691532 BP	115	.eventTypes[TCP]= true,
f6691532 BP	116	.eventTypes[UDP]= false,
08365995	117	}, {
f6691532 BP	118	.channelName= LTT_CHANNEL_NET,
	119	.eventName= LTT_EVENT_UDPV4_RCV_EXTENDED,
	120	.fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_SADDR,
	121	LTT_FIELD_DADDR, LTT_FIELD_UNICAST, LTT_FIELD_ULEN,
6c16b6af	122	LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_DATA_START),
f6691532 BP	123	.eventTypes[TCP]= false,
f6691532 BP	124	.eventTypes[UDP]= true,
08365995 BP	125	}
	126	}; // This is called a compound literal
	127	unsigned int hookNb= sizeof(eventHookInfoList) / sizeof(*eventHookInfoList);
70407e86 BP	128
	129	for(i= 0; i < traceNb; i++)
	130	{
	131	LttvTraceContext* tc;
	132	GArray* hookList;
	133	int retval;
	134
	135	tc= traceSetContext->traces[i];
	136	hookList= g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
	137	g_array_append_val(hookListList, hookList);
	138
	139	// Find the hooks
	140	for (j= 0; j < hookNb; j++)
	141	{
	142	guint old_len;
f6691532 BP	143	bool registerHook;
f6691532 BP	144
d4721e1a	145	registerHook= false;
f6691532 BP	146	for (k= 0; k < TYPE_COUNT; k++)
f6691532 BP	147	{
d4721e1a	148	if (eventTypes[k] && eventHookInfoList[j].eventTypes[k])
f6691532	149	{
d4721e1a	150	registerHook= true;
f6691532 BP	151	break;
	152	}
	153	}
	154	if (!registerHook)
	155	{
	156	continue;
	157	}
70407e86 BP	158
	159	old_len= hookList->len;
	160	retval= lttv_trace_find_hook(tc->t,
	161	eventHookInfoList[j].channelName,
	162	eventHookInfoList[j].eventName, eventHookInfoList[j].fields,
	163	hookFunction, hookData, &hookList);
	164	if (retval != 0)
	165	{
	166	g_warning("Trace %d contains no %s.%s marker\n", i,
	167	g_quark_to_string(eventHookInfoList[j].channelName),
	168	g_quark_to_string(eventHookInfoList[j].eventName));
	169	}
	170	else
	171	{
	172	g_assert(hookList->len - old_len == 1);
	173	}
	174	}
	175
	176	// Add the hooks to each tracefile's event_by_id hook list
	177	for(j= 0; j < tc->tracefiles->len; j++)
	178	{
	179	LttvTracefileContext* tfc;
	180
	181	tfc= g_array_index(tc->tracefiles, LttvTracefileContext*, j);
	182
	183	for(k= 0; k < hookList->len; k++)
	184	{
	185	LttvTraceHook* traceHook;
	186
	187	traceHook= &g_array_index(hookList, LttvTraceHook, k);
	188	if (traceHook->hook_data != hookData)
	189	{
	190	g_assert_not_reached();
	191	}
	192	if (traceHook->mdata == tfc->tf->mdata)
	193	{
08365995	194	lttv_hooks_add(lttv_hooks_by_id_find(tfc->event_by_id,
70407e86 BP	195	traceHook->id), traceHook->h, traceHook,
	196	LTTV_PRIO_DEFAULT);
	197	}
	198	}
	199	}
	200	}
	201	}
	202
	203
	204	/* Remove event hooks and free hookListList
	205	*
	206	* Args:
	207	* hookListList: LttvTraceHook hookListList[traceNum][hookNum]
	208	* traceSetContext: LTTV traceset
70407e86 BP	209	*/
70407e86 BP	210	void unregisterHooks(GArray* hookListList, LttvTracesetContext* const
08365995	211	traceSetContext)
70407e86 BP	212	{
70407e86 BP	213	unsigned int i, j, k;
08365995	214	unsigned int traceNb= lttv_traceset_number(traceSetContext->ts);
70407e86 BP	215
	216	for(i= 0; i < traceNb; i++)
	217	{
	218	LttvTraceContext* tc;
	219	GArray* hookList;
	220
	221	tc= traceSetContext->traces[i];
	222	hookList= g_array_index(hookListList, GArray*, i);
	223
	224	// Remove the hooks from each tracefile's event_by_id hook list
	225	for(j= 0; j < tc->tracefiles->len; j++)
	226	{
	227	LttvTracefileContext* tfc;
	228
	229	tfc= g_array_index(tc->tracefiles, LttvTracefileContext*, j);
	230
	231	for(k= 0; k < hookList->len; k++)
	232	{
	233	LttvTraceHook* traceHook;
	234
	235	traceHook= &g_array_index(hookList, LttvTraceHook, k);
	236	if (traceHook->mdata == tfc->tf->mdata)
	237	{
	238	lttv_hooks_remove_data(lttv_hooks_by_id_find(tfc->event_by_id,
	239	traceHook->id), traceHook->h, traceHook);
	240	}
	241	}
	242	}
	243
	244	g_array_free(hookList, TRUE);
	245	}
	246	g_array_free(hookListList, TRUE);
	247	}