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

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2009, 2010 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 Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#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);
				}
			}
		}

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