[lttv.git] / lttv / lttv / sync / sync_chain_lttv.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 <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <lttv/module.h>
#include <lttv/option.h>

#include "sync_chain.h"
#include "sync_chain_lttv.h"


static void init();
static void destroy();

static void gfAddModuleOption(gpointer data, gpointer user_data);
static void gfRemoveModuleOption(gpointer data, gpointer user_data);

static ModuleOption optionSync= {
	.longName= "sync",
	.hasArg= NO_ARG,
	.optionHelp= "synchronize the time between the traces",
};
static ModuleOption optionSyncStats= {
	.longName= "sync-stats",
	.hasArg= NO_ARG,
	.optionHelp= "print statistics about the time synchronization",
};
static ModuleOption optionSyncNull= {
	.longName= "sync-null",
	.hasArg= NO_ARG,
	.optionHelp= "read the events but do not perform any processing",
};
static GString* analysisModulesNames;
static ModuleOption optionSyncAnalysis= {
	.longName= "sync-analysis",
	.hasArg= REQUIRED_ARG,
	.optionHelp= "specify the algorithm to use for event analysis",
};
static ModuleOption optionSyncGraphs= {
	.longName= "sync-graphs",
	.hasArg= NO_ARG,
	.optionHelp= "output gnuplot graph showing synchronization points",
};
static char graphsDir[20];
static ModuleOption optionSyncGraphsDir= {
	.longName= "sync-graphs-dir",
	.hasArg= REQUIRED_ARG,
	.optionHelp= "specify the directory where to store the graphs",
};


/*
 * Module init function
 *
 * This function is declared to be the module initialization function. Event
 * modules are registered with a "constructor (102)" attribute except one in
 * each class (processing, matching, analysis) which is chosen to be the
 * default and which is registered with a "constructor (101)" attribute.
 * Constructors with no priority are called after constructors with
 * priorities. The result is that the list of event modules is known when this
 * function is executed.
 */
static void init()
{
	int retval;

	g_debug("Sync init");

	g_assert(g_queue_get_length(&analysisModules) > 0);
	optionSyncAnalysis.arg= ((AnalysisModule*)
		g_queue_peek_head(&analysisModules))->name;
	analysisModulesNames= g_string_new("");
	g_queue_foreach(&analysisModules, &gfAppendAnalysisName,
		analysisModulesNames);
	// remove the last ", "
	g_string_truncate(analysisModulesNames, analysisModulesNames->len - 2);
	optionSyncAnalysis.argHelp= analysisModulesNames->str;

	retval= snprintf(graphsDir, sizeof(graphsDir), "graphs-%d", getpid());
	if (retval > sizeof(graphsDir) - 1)
	{
		graphsDir[sizeof(graphsDir) - 1]= '\0';
	}
	optionSyncGraphsDir.arg= graphsDir;
	optionSyncGraphsDir.argHelp= graphsDir;

	g_queue_push_head(&moduleOptions, &optionSyncGraphsDir);
	g_queue_push_head(&moduleOptions, &optionSyncGraphs);
	g_queue_push_head(&moduleOptions, &optionSyncAnalysis);
	g_queue_push_head(&moduleOptions, &optionSyncNull);
	g_queue_push_head(&moduleOptions, &optionSyncStats);
	g_queue_push_head(&moduleOptions, &optionSync);

	g_queue_foreach(&moduleOptions, &gfAddModuleOption, NULL);
}


/*
 * Module unload function
 */
static void destroy()
{
	g_debug("Sync destroy");

	g_queue_foreach(&moduleOptions, &gfRemoveModuleOption, NULL);
	g_string_free(analysisModulesNames, TRUE);

	g_queue_clear(&processingModules);
	g_queue_clear(&matchingModules);
	g_queue_clear(&analysisModules);
	g_queue_clear(&moduleOptions);
}


/*
 * Calculate a traceset's drift and offset values based on network events
 *
 * The individual correction factors are written out to each trace.
 *
 * Args:
 *   traceSetContext: traceset
 */
void syncTraceset(LttvTracesetContext* const traceSetContext)
{
	SyncState* syncState;
	struct timeval startTime, endTime;
	struct rusage startUsage, endUsage;
	GList* result;
	unsigned int i;
	int retval;

	if (!optionSync.present)
	{
		g_debug("Not synchronizing traceset because option is disabled");
		return;
	}

	if (optionSyncStats.present)
	{
		gettimeofday(&startTime, 0);
		getrusage(RUSAGE_SELF, &startUsage);
	}

	// Initialize data structures
	syncState= malloc(sizeof(SyncState));

	if (optionSyncStats.present)
	{
		syncState->stats= true;
	}
	else
	{
		syncState->stats= false;
	}

	if (!optionSyncNull.present && optionSyncGraphs.present)
	{
		// Create the graph directory right away in case the module initialization
		// functions have something to write in it.
		syncState->graphsDir= optionSyncGraphsDir.arg;
		syncState->graphsStream= createGraphsDir(syncState->graphsDir);
	}
	else
	{
		syncState->graphsStream= NULL;
		syncState->graphsDir= NULL;
	}

	// Identify and initialize modules
	syncState->processingData= NULL;
	if (optionSyncNull.present)
	{
		result= g_queue_find_custom(&processingModules, "LTTV-null",
			&gcfCompareProcessing);
	}
	else
	{
		result= g_queue_find_custom(&processingModules, "LTTV-standard",
			&gcfCompareProcessing);
	}
	g_assert(result != NULL);
	syncState->processingModule= (ProcessingModule*) result->data;

	syncState->matchingData= NULL;
	result= g_queue_find_custom(&matchingModules, "TCP", &gcfCompareMatching);
	g_assert(result != NULL);
	syncState->matchingModule= (MatchingModule*) result->data;

	syncState->analysisData= NULL;
	result= g_queue_find_custom(&analysisModules, optionSyncAnalysis.arg,
		&gcfCompareAnalysis);
	if (result != NULL)
	{
		syncState->analysisModule= (AnalysisModule*) result->data;
	}
	else
	{
		g_error("Analysis module '%s' not found", optionSyncAnalysis.arg);
	}

	syncState->processingModule->initProcessing(syncState, traceSetContext);
	if (!optionSyncNull.present)
	{
		syncState->matchingModule->initMatching(syncState);
		syncState->analysisModule->initAnalysis(syncState);
	}

	// Process traceset
	lttv_process_traceset_seek_time(traceSetContext, ltt_time_zero);
	lttv_process_traceset_middle(traceSetContext, ltt_time_infinite,
		G_MAXULONG, NULL);
	lttv_process_traceset_seek_time(traceSetContext, ltt_time_zero);

	syncState->processingModule->finalizeProcessing(syncState);

	// Write graphs file
	if (!optionSyncNull.present && optionSyncGraphs.present)
	{
		writeGraphsScript(syncState);

		if (fclose(syncState->graphsStream) != 0)
		{
			g_error(strerror(errno));
		}
	}

	if (!optionSyncNull.present && optionSyncStats.present)
	{
		printStats(syncState);

		printf("Resulting synchronization factors:\n");
		for (i= 0; i < syncState->traceNb; i++)
		{
			LttTrace* t;

			t= traceSetContext->traces[i]->t;

			printf("\ttrace %u drift= %g offset= %g (%f) start time= %ld.%09ld\n",
				i, t->drift, t->offset, (double) tsc_to_uint64(t->freq_scale,
					t->start_freq, t->offset) / NANOSECONDS_PER_SECOND,
				t->start_time_from_tsc.tv_sec,
				t->start_time_from_tsc.tv_nsec);
		}
	}

	syncState->processingModule->destroyProcessing(syncState);
	if (syncState->matchingModule != NULL)
	{
		syncState->matchingModule->destroyMatching(syncState);
	}
	if (syncState->analysisModule != NULL)
	{
		syncState->analysisModule->destroyAnalysis(syncState);
	}

	free(syncState);

	if (optionSyncStats.present)
	{
		gettimeofday(&endTime, 0);
		retval= getrusage(RUSAGE_SELF, &endUsage);

		timeDiff(&endTime, &startTime);
		timeDiff(&endUsage.ru_utime, &startUsage.ru_utime);
		timeDiff(&endUsage.ru_stime, &startUsage.ru_stime);

		printf("Synchronization time:\n");
		printf("\treal time: %ld.%06ld\n", endTime.tv_sec, endTime.tv_usec);
		printf("\tuser time: %ld.%06ld\n", endUsage.ru_utime.tv_sec,
			endUsage.ru_utime.tv_usec);
		printf("\tsystem time: %ld.%06ld\n", endUsage.ru_stime.tv_sec,
			endUsage.ru_stime.tv_usec);
	}
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Args:
 *   data:         ModuleOption*
 *   user_data:    NULL
 */
static void gfAddModuleOption(gpointer data, gpointer user_data)
{
	ModuleOption* option= data;
	LttvOptionType conversion[]= {
		[NO_ARG]= LTTV_OPT_NONE,
		[OPTIONAL_ARG]= LTTV_OPT_NONE,
		[REQUIRED_ARG]= LTTV_OPT_STRING,
	};
	size_t fieldOffset[]= {
		[NO_ARG]= offsetof(ModuleOption, present),
		[REQUIRED_ARG]= offsetof(ModuleOption, arg),
	};
	static const char* argHelpNone= "none";

	g_assert_cmpuint(sizeof(conversion) / sizeof(*conversion), ==,
		HAS_ARG_COUNT);
	if (option->hasArg == OPTIONAL_ARG)
	{
		g_warning("Parameters with optional arguments not supported by the "
			"lttv option scheme, parameter '%s' will not be available",
			option->longName);
	}
	else
	{
		lttv_option_add(option->longName, '\0', option->optionHelp,
			option->argHelp ? option->argHelp : argHelpNone,
			conversion[option->hasArg], (void*) option + fieldOffset[option->hasArg],
			NULL, NULL);
	}
}


/*
 * A GFunc for g_queue_foreach()
 *
 * Args:
 *   data:         ModuleOption*
 *   user_data:    NULL
 */
static void gfRemoveModuleOption(gpointer data, gpointer user_data)
{
	lttv_option_remove(((ModuleOption*) data)->longName);
}


LTTV_MODULE("sync", "Synchronize traces", \
	"Synchronizes a traceset based on the correspondance of network events", \
	init, destroy, "option")
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
08365995 BP	23	#include <errno.h>
	24	#include <fcntl.h>
	25	#include <stdio.h>
70407e86	26	#include <stdlib.h>
70407e86	27	#include <sys/resource.h>
08365995	28	#include <sys/stat.h>
08365995 BP	29	#include <sys/types.h>
	30	#include <sys/stat.h>
	31	#include <unistd.h>
70407e86 BP	32
	33	#include <lttv/module.h>
	34	#include <lttv/option.h>
	35
2bd4b3e4	36	#include "sync_chain.h"
2f076594	37	#include "sync_chain_lttv.h"
70407e86 BP	38
70407e86 BP	39
70407e86 BP	40	static void init();
	41	static void destroy();
	42
2bd4b3e4 BP	43	static void gfAddModuleOption(gpointer data, gpointer user_data);
2bd4b3e4 BP	44	static void gfRemoveModuleOption(gpointer data, gpointer user_data);
70407e86	45
2bd4b3e4 BP	46	static ModuleOption optionSync= {
	47	.longName= "sync",
	48	.hasArg= NO_ARG,
2bd4b3e4 BP	49	.optionHelp= "synchronize the time between the traces",
2bd4b3e4 BP	50	};
2bd4b3e4 BP	51	static ModuleOption optionSyncStats= {
	52	.longName= "sync-stats",
	53	.hasArg= NO_ARG,
2bd4b3e4 BP	54	.optionHelp= "print statistics about the time synchronization",
	55	};
	56	static ModuleOption optionSyncNull= {
	57	.longName= "sync-null",
	58	.hasArg= NO_ARG,
2bd4b3e4 BP	59	.optionHelp= "read the events but do not perform any processing",
	60	};
	61	static GString* analysisModulesNames;
	62	static ModuleOption optionSyncAnalysis= {
	63	.longName= "sync-analysis",
	64	.hasArg= REQUIRED_ARG,
	65	.optionHelp= "specify the algorithm to use for event analysis",
	66	};
	67	static ModuleOption optionSyncGraphs= {
	68	.longName= "sync-graphs",
	69	.hasArg= NO_ARG,
2bd4b3e4 BP	70	.optionHelp= "output gnuplot graph showing synchronization points",
2bd4b3e4 BP	71	};
49c335f1	72	static char graphsDir[20];
2bd4b3e4 BP	73	static ModuleOption optionSyncGraphsDir= {
	74	.longName= "sync-graphs-dir",
	75	.hasArg= REQUIRED_ARG,
	76	.optionHelp= "specify the directory where to store the graphs",
	77	};
70407e86	78
49c335f1	79
70407e86 BP	80	/*
	81	* Module init function
	82	*
	83	* This function is declared to be the module initialization function. Event
	84	* modules are registered with a "constructor (102)" attribute except one in
	85	* each class (processing, matching, analysis) which is chosen to be the
	86	* default and which is registered with a "constructor (101)" attribute.
	87	* Constructors with no priority are called after constructors with
	88	* priorities. The result is that the list of event modules is known when this
	89	* function is executed.
	90	*/
	91	static void init()
	92	{
08365995	93	int retval;
70407e86	94
d5b038ec	95	g_debug("Sync init");
70407e86	96
70407e86	97	g_assert(g_queue_get_length(&analysisModules) > 0);
49c335f1	98	optionSyncAnalysis.arg= ((AnalysisModule*)
70407e86 BP	99	g_queue_peek_head(&analysisModules))->name;
	100	analysisModulesNames= g_string_new("");
	101	g_queue_foreach(&analysisModules, &gfAppendAnalysisName,
	102	analysisModulesNames);
	103	// remove the last ", "
	104	g_string_truncate(analysisModulesNames, analysisModulesNames->len - 2);
2bd4b3e4	105	optionSyncAnalysis.argHelp= analysisModulesNames->str;
08365995 BP	106
	107	retval= snprintf(graphsDir, sizeof(graphsDir), "graphs-%d", getpid());
	108	if (retval > sizeof(graphsDir) - 1)
	109	{
	110	graphsDir[sizeof(graphsDir) - 1]= '\0';
	111	}
2bd4b3e4 BP	112	optionSyncGraphsDir.arg= graphsDir;
	113	optionSyncGraphsDir.argHelp= graphsDir;
	114
	115	g_queue_push_head(&moduleOptions, &optionSyncGraphsDir);
	116	g_queue_push_head(&moduleOptions, &optionSyncGraphs);
	117	g_queue_push_head(&moduleOptions, &optionSyncAnalysis);
	118	g_queue_push_head(&moduleOptions, &optionSyncNull);
	119	g_queue_push_head(&moduleOptions, &optionSyncStats);
	120	g_queue_push_head(&moduleOptions, &optionSync);
	121
	122	g_queue_foreach(&moduleOptions, &gfAddModuleOption, NULL);
70407e86 BP	123	}
	124
	125
	126	/*
	127	* Module unload function
	128	*/
	129	static void destroy()
	130	{
d5b038ec	131	g_debug("Sync destroy");
70407e86	132
2bd4b3e4 BP	133	g_queue_foreach(&moduleOptions, &gfRemoveModuleOption, NULL);
	134	g_string_free(analysisModulesNames, TRUE);
	135
	136	g_queue_clear(&processingModules);
	137	g_queue_clear(&matchingModules);
	138	g_queue_clear(&analysisModules);
	139	g_queue_clear(&moduleOptions);
70407e86 BP	140	}
	141
	142
	143	/*
	144	* Calculate a traceset's drift and offset values based on network events
	145	*
	146	* The individual correction factors are written out to each trace.
	147	*
	148	* Args:
	149	* traceSetContext: traceset
	150	*/
	151	void syncTraceset(LttvTracesetContext* const traceSetContext)
	152	{
	153	SyncState* syncState;
	154	struct timeval startTime, endTime;
	155	struct rusage startUsage, endUsage;
	156	GList* result;
467066ee	157	unsigned int i;
70407e86 BP	158	int retval;
70407e86 BP	159
2bd4b3e4	160	if (!optionSync.present)
70407e86 BP	161	{
	162	g_debug("Not synchronizing traceset because option is disabled");
	163	return;
	164	}
	165
2bd4b3e4	166	if (optionSyncStats.present)
70407e86 BP	167	{
	168	gettimeofday(&startTime, 0);
	169	getrusage(RUSAGE_SELF, &startUsage);
	170	}
	171
	172	// Initialize data structures
	173	syncState= malloc(sizeof(SyncState));
70407e86	174
2bd4b3e4	175	if (optionSyncStats.present)
70407e86 BP	176	{
	177	syncState->stats= true;
	178	}
	179	else
	180	{
	181	syncState->stats= false;
	182	}
	183
1ed11971	184	if (!optionSyncNull.present && optionSyncGraphs.present)
08365995 BP	185	{
	186	// Create the graph directory right away in case the module initialization
	187	// functions have something to write in it.
8d7d16dd	188	syncState->graphsDir= optionSyncGraphsDir.arg;
1d597550	189	syncState->graphsStream= createGraphsDir(syncState->graphsDir);
08365995	190	}
8d7d16dd BP	191	else
	192	{
	193	syncState->graphsStream= NULL;
	194	syncState->graphsDir= NULL;
	195	}
08365995	196
d4721e1a BP	197	// Identify and initialize modules
	198	syncState->processingData= NULL;
	199	if (optionSyncNull.present)
	200	{
	201	result= g_queue_find_custom(&processingModules, "LTTV-null",
	202	&gcfCompareProcessing);
	203	}
	204	else
	205	{
	206	result= g_queue_find_custom(&processingModules, "LTTV-standard",
	207	&gcfCompareProcessing);
	208	}
	209	g_assert(result != NULL);
	210	syncState->processingModule= (ProcessingModule*) result->data;
	211
	212	syncState->matchingData= NULL;
f10c27a8 BP	213	result= g_queue_find_custom(&matchingModules, "TCP", &gcfCompareMatching);
	214	g_assert(result != NULL);
	215	syncState->matchingModule= (MatchingModule*) result->data;
70407e86	216
d4721e1a	217	syncState->analysisData= NULL;
2bd4b3e4	218	result= g_queue_find_custom(&analysisModules, optionSyncAnalysis.arg,
f6691532 BP	219	&gcfCompareAnalysis);
f6691532 BP	220	if (result != NULL)
70407e86	221	{
f6691532	222	syncState->analysisModule= (AnalysisModule*) result->data;
70407e86 BP	223	}
	224	else
	225	{
2bd4b3e4	226	g_error("Analysis module '%s' not found", optionSyncAnalysis.arg);
f6691532	227	}
70407e86	228
09857093	229	syncState->processingModule->initProcessing(syncState, traceSetContext);
2bd4b3e4	230	if (!optionSyncNull.present)
f6691532	231	{
d4721e1a	232	syncState->matchingModule->initMatching(syncState);
09857093	233	syncState->analysisModule->initAnalysis(syncState);
70407e86 BP	234	}
	235
	236	// Process traceset
	237	lttv_process_traceset_seek_time(traceSetContext, ltt_time_zero);
	238	lttv_process_traceset_middle(traceSetContext, ltt_time_infinite,
	239	G_MAXULONG, NULL);
	240	lttv_process_traceset_seek_time(traceSetContext, ltt_time_zero);
	241
	242	syncState->processingModule->finalizeProcessing(syncState);
	243
08365995	244	// Write graphs file
1ed11971	245	if (!optionSyncNull.present && optionSyncGraphs.present)
08365995	246	{
467066ee	247	writeGraphsScript(syncState);
08365995	248
8d7d16dd	249	if (fclose(syncState->graphsStream) != 0)
08365995 BP	250	{
	251	g_error(strerror(errno));
	252	}
	253	}
	254
1ed11971	255	if (!optionSyncNull.present && optionSyncStats.present)
70407e86	256	{
1ed11971	257	printStats(syncState);
d6ee5003	258
d6ee5003 BP	259	printf("Resulting synchronization factors:\n");
	260	for (i= 0; i < syncState->traceNb; i++)
	261	{
	262	LttTrace* t;
	263
	264	t= traceSetContext->traces[i]->t;
	265
	266	printf("\ttrace %u drift= %g offset= %g (%f) start time= %ld.%09ld\n",
	267	i, t->drift, t->offset, (double) tsc_to_uint64(t->freq_scale,
	268	t->start_freq, t->offset) / NANOSECONDS_PER_SECOND,
	269	t->start_time_from_tsc.tv_sec,
	270	t->start_time_from_tsc.tv_nsec);
	271	}
	272	}
70407e86 BP	273
	274	syncState->processingModule->destroyProcessing(syncState);
	275	if (syncState->matchingModule != NULL)
	276	{
	277	syncState->matchingModule->destroyMatching(syncState);
	278	}
	279	if (syncState->analysisModule != NULL)
	280	{
	281	syncState->analysisModule->destroyAnalysis(syncState);
	282	}
	283
	284	free(syncState);
	285
2bd4b3e4	286	if (optionSyncStats.present)
70407e86 BP	287	{
	288	gettimeofday(&endTime, 0);
	289	retval= getrusage(RUSAGE_SELF, &endUsage);
	290
	291	timeDiff(&endTime, &startTime);
	292	timeDiff(&endUsage.ru_utime, &startUsage.ru_utime);
	293	timeDiff(&endUsage.ru_stime, &startUsage.ru_stime);
	294
	295	printf("Synchronization time:\n");
	296	printf("\treal time: %ld.%06ld\n", endTime.tv_sec, endTime.tv_usec);
	297	printf("\tuser time: %ld.%06ld\n", endUsage.ru_utime.tv_sec,
	298	endUsage.ru_utime.tv_usec);
	299	printf("\tsystem time: %ld.%06ld\n", endUsage.ru_stime.tv_sec,
	300	endUsage.ru_stime.tv_usec);
	301	}
	302	}
	303
	304
2bd4b3e4 BP	305	/*
	306	* A GFunc for g_queue_foreach()
	307	*
	308	* Args:
	309	* data: ModuleOption*
	310	* user_data: NULL
	311	*/
	312	static void gfAddModuleOption(gpointer data, gpointer user_data)
	313	{
49c335f1	314	ModuleOption* option= data;
2bd4b3e4 BP	315	LttvOptionType conversion[]= {
2bd4b3e4 BP	316	[NO_ARG]= LTTV_OPT_NONE,
49c335f1	317	[OPTIONAL_ARG]= LTTV_OPT_NONE,
2bd4b3e4 BP	318	[REQUIRED_ARG]= LTTV_OPT_STRING,
2bd4b3e4 BP	319	};
49c335f1 BP	320	size_t fieldOffset[]= {
	321	[NO_ARG]= offsetof(ModuleOption, present),
	322	[REQUIRED_ARG]= offsetof(ModuleOption, arg),
	323	};
	324	static const char* argHelpNone= "none";
2bd4b3e4 BP	325
	326	g_assert_cmpuint(sizeof(conversion) / sizeof(*conversion), ==,
	327	HAS_ARG_COUNT);
49c335f1 BP	328	if (option->hasArg == OPTIONAL_ARG)
	329	{
	330	g_warning("Parameters with optional arguments not supported by the "
	331	"lttv option scheme, parameter '%s' will not be available",
	332	option->longName);
	333	}
	334	else
	335	{
	336	lttv_option_add(option->longName, '\0', option->optionHelp,
	337	option->argHelp ? option->argHelp : argHelpNone,
	338	conversion[option->hasArg], (void*) option + fieldOffset[option->hasArg],
	339	NULL, NULL);
	340	}
2bd4b3e4 BP	341	}
	342
	343
	344	/*
	345	* A GFunc for g_queue_foreach()
	346	*
	347	* Args:
	348	* data: ModuleOption*
	349	* user_data: NULL
	350	*/
	351	static void gfRemoveModuleOption(gpointer data, gpointer user_data)
	352	{
	353	lttv_option_remove(((ModuleOption*) data)->longName);
	354	}
	355
	356
70407e86 BP	357	LTTV_MODULE("sync", "Synchronize traces", \
	358	"Synchronizes a traceset based on the correspondance of network events", \
	359	init, destroy, "option")