projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Generate graphs of synchronization accuracy
[lttv.git] / lttv / lttv / sync / event_processing_lttng_standard.c
CommitLineData
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#define _ISOC99_SOURCE
20
21#ifdef HAVE_CONFIG_H
22#include <config.h>
23#endif
24
25#include <linux/if_ether.h>
26#include <math.h>
27#include <netinet/in.h>
28#include <stdint.h>
29#include <stdlib.h>
f6691532 30#include <string.h>
70407e86 31
2bd4b3e4 32#include "sync_chain.h"
10341d26 33#include "event_processing_lttng_common.h"
70407e86 34
10341d26 35#include "event_processing_lttng_standard.h"
70407e86
BP		 36
37
38#ifndef g_info
39#define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
40#endif
41
42
08365995 43// Functions common to all processing modules
70407e86
BP		 44static void initProcessingLTTVStandard(SyncState* const syncState,
45 LttvTracesetContext* const traceSetContext);
46static void destroyProcessingLTTVStandard(SyncState* const syncState);
47
48static void finalizeProcessingLTTVStandard(SyncState* const syncState);
49static void printProcessingStatsLTTVStandard(SyncState* const syncState);
66eaf2eb
BP		 50static void writeProcessingGraphVariablesLTTVStandard(SyncState* const
51 syncState, const unsigned int i);
467066ee
BP		 52static void writeProcessingTraceTraceOptionsLTTVStandard(SyncState* const
53 syncState, const unsigned int i, const unsigned int j);
54static void writeProcessingTraceTimeOptionsLTTVStandard(SyncState* const
8d7d16dd 55 syncState, const unsigned int i, const unsigned int j);
70407e86
BP		 56
57// Functions specific to this module
58static void registerProcessingLTTVStandard() __attribute__((constructor (102)));
59static gboolean processEventLTTVStandard(void* hookData, void* callData);
60static void partialDestroyProcessingLTTVStandard(SyncState* const syncState);
61
62
63static ProcessingModule processingModuleLTTVStandard = {
64 .name= "LTTV-standard",
65 .initProcessing= &initProcessingLTTVStandard,
66 .destroyProcessing= &destroyProcessingLTTVStandard,
67 .finalizeProcessing= &finalizeProcessingLTTVStandard,
68 .printProcessingStats= &printProcessingStatsLTTVStandard,
467066ee 69 .graphFunctions= {
66eaf2eb 70 .writeVariables= &writeProcessingGraphVariablesLTTVStandard,
467066ee
BP		 71 .writeTraceTraceOptions= &writeProcessingTraceTraceOptionsLTTVStandard,
72 .writeTraceTimeOptions= &writeProcessingTraceTimeOptionsLTTVStandard,
73 },
70407e86
BP		 74};
75
76
70407e86
BP		 77/*
78 * Processing Module registering function
79 */
80static void registerProcessingLTTVStandard()
81{
82 g_queue_push_tail(&processingModules, &processingModuleLTTVStandard);
83
84 createQuarks();
85}
86
87
88/*
89 * Allocate and initialize data structures for synchronizing a traceset.
90 * Register event hooks.
91 *
92 * Args:
93 * syncState: container for synchronization data.
94 * This function allocates these processingData members:
95 * traceNumTable
96 * pendingRecv
97 * hookListList
98 * stats
99 * traceSetContext: set of LTTV traces
100 */
101static void initProcessingLTTVStandard(SyncState* const syncState, LttvTracesetContext*
102 const traceSetContext)
103{
104 unsigned int i;
105 ProcessingDataLTTVStandard* processingData;
106
107 processingData= malloc(sizeof(ProcessingDataLTTVStandard));
108 syncState->processingData= processingData;
109 processingData->traceSetContext= traceSetContext;
110
111 if (syncState->stats)
112 {
113 processingData->stats= calloc(1, sizeof(ProcessingStatsLTTVStandard));
114 }
115 else
116 {
117 processingData->stats= NULL;
118 }
119
120 processingData->traceNumTable= g_hash_table_new(&g_direct_hash, NULL);
121 processingData->hookListList= g_array_sized_new(FALSE, FALSE,
122 sizeof(GArray*), syncState->traceNb);
123 processingData->pendingRecv= malloc(sizeof(GHashTable*) *
124 syncState->traceNb);
125
126 for(i= 0; i < syncState->traceNb; i++)
127 {
128 g_hash_table_insert(processingData->traceNumTable,
129 processingData->traceSetContext->traces[i]->t, (gpointer) i);
130 }
131
1633c5a5
BP		 132 if (syncState->graphsStream)
133 {
134 processingData->graphs= malloc(syncState->traceNb *
135 sizeof(ProcessingGraphsLTTVStandard));
136
137 for(i= 0; i < syncState->traceNb; i++)
138 {
139 LttTrace* traceI= traceSetContext->traces[i]->t;
140
141 processingData->graphs[i].startFreq= traceI->start_freq;
142 processingData->graphs[i].freqScale= traceI->freq_scale;
143 }
144 }
145 else
146 {
147 processingData->graphs= NULL;
148 }
149
70407e86
BP		 150 for(i= 0; i < syncState->traceNb; i++)
151 {
152 processingData->pendingRecv[i]= g_hash_table_new_full(&g_direct_hash,
10341d26 153 NULL, NULL, &gdnDestroyEvent);
70407e86
BP		 154 }
155
156 registerHooks(processingData->hookListList, traceSetContext,
f6691532
BP		 157 &processEventLTTVStandard, syncState,
158 syncState->matchingModule->canMatch);
70407e86
BP		 159}
160
161
162/*
163 * Call the partial processing destroyer, obtain and adjust the factors from
164 * downstream
165 *
166 * Args:
167 * syncState container for synchronization data.
168 */
169static void finalizeProcessingLTTVStandard(SyncState* const syncState)
170{
171 unsigned int i;
172 GArray* factors;
173 double minOffset, minDrift;
174 unsigned int refFreqTrace;
175 ProcessingDataLTTVStandard* processingData;
176
177 processingData= (ProcessingDataLTTVStandard*) syncState->processingData;
178
179 partialDestroyProcessingLTTVStandard(syncState);
180
181 factors= syncState->matchingModule->finalizeMatching(syncState);
182
183 /* The offsets are adjusted so the lowest one is 0. This is done because
184 * of a Lttv specific limitation: events cannot have negative times. By
185 * having non-negative offsets, events cannot be moved backwards to
186 * negative times.
187 */
188 minOffset= 0;
189 for (i= 0; i < syncState->traceNb; i++)
190 {
191 minOffset= MIN(g_array_index(factors, Factors, i).offset, minOffset);
192 }
193
194 for (i= 0; i < syncState->traceNb; i++)
195 {
196 g_array_index(factors, Factors, i).offset-= minOffset;
197 }
198
199 /* Because the timestamps are corrected at the TSC level (not at the
200 * LttTime level) all trace frequencies must be made equal. We choose to
201 * use the frequency of the system with the lowest drift
202 */
203 minDrift= INFINITY;
204 refFreqTrace= 0;
205 for (i= 0; i < syncState->traceNb; i++)
206 {
207 if (g_array_index(factors, Factors, i).drift < minDrift)
208 {
209 minDrift= g_array_index(factors, Factors, i).drift;
210 refFreqTrace= i;
211 }
212 }
213 g_assert(syncState->traceNb == 0 || minDrift != INFINITY);
214
215 // Write the factors to the LttTrace structures
216 for (i= 0; i < syncState->traceNb; i++)
217 {
218 LttTrace* t;
219 Factors* traceFactors;
220
221 t= processingData->traceSetContext->traces[i]->t;
222 traceFactors= &g_array_index(factors, Factors, i);
223
224 t->drift= traceFactors->drift;
225 t->offset= traceFactors->offset;
226 t->start_freq=
227 processingData->traceSetContext->traces[refFreqTrace]->t->start_freq;
228 t->freq_scale=
229 processingData->traceSetContext->traces[refFreqTrace]->t->freq_scale;
230 t->start_time_from_tsc =
231 ltt_time_from_uint64(tsc_to_uint64(t->freq_scale, t->start_freq,
232 t->drift * t->start_tsc + t->offset));
233 }
234
235 g_array_free(factors, TRUE);
236
237 lttv_traceset_context_compute_time_span(processingData->traceSetContext,
238 &processingData->traceSetContext->time_span);
239
240 g_debug("traceset start %ld.%09ld end %ld.%09ld\n",
241 processingData->traceSetContext->time_span.start_time.tv_sec,
242 processingData->traceSetContext->time_span.start_time.tv_nsec,
243 processingData->traceSetContext->time_span.end_time.tv_sec,
244 processingData->traceSetContext->time_span.end_time.tv_nsec);
70407e86
BP		 245}
246
247
248/*
d6ee5003
BP		 249 * Print statistics related to processing Must be called after
250 * finalizeProcessing.
70407e86
BP		 251 *
252 * Args:
253 * syncState container for synchronization data.
254 */
255static void printProcessingStatsLTTVStandard(SyncState* const syncState)
256{
70407e86
BP		 257 ProcessingDataLTTVStandard* processingData;
258
259 if (!syncState->stats)
260 {
261 return;
262 }
263
264 processingData= (ProcessingDataLTTVStandard*) syncState->processingData;
265
266 printf("LTTV processing stats:\n");
267 printf("\treceived frames: %d\n", processingData->stats->totRecv);
268 printf("\treceived frames that are IP: %d\n",
269 processingData->stats->totRecvIp);
f6691532
BP		 270 if (syncState->matchingModule->canMatch[TCP])
271 {
272 printf("\treceived and processed packets that are TCP: %d\n",
273 processingData->stats->totRecvTCP);
274 }
275 if (syncState->matchingModule->canMatch[UDP])
276 {
277 printf("\treceived and processed packets that are UDP: %d\n",
278 processingData->stats->totRecvUDP);
279 }
280 if (syncState->matchingModule->canMatch[TCP])
281 {
282 printf("\tsent packets that are TCP: %d\n",
283 processingData->stats->totOutE);
284 }
70407e86
BP		 285}
286
287
288/*
289 * Unregister event hooks. Deallocate processingData.
290 *
291 * Args:
292 * syncState: container for synchronization data.
293 * This function deallocates these processingData members:
294 * stats
295 */
296static void destroyProcessingLTTVStandard(SyncState* const syncState)
297{
298 ProcessingDataLTTVStandard* processingData;
299
300 processingData= (ProcessingDataLTTVStandard*) syncState->processingData;
301
302 if (processingData == NULL)
303 {
304 return;
305 }
306
307 partialDestroyProcessingLTTVStandard(syncState);
308
309 if (syncState->stats)
310 {
311 free(processingData->stats);
312 }
313
1633c5a5
BP		 314 if (syncState->graphsStream)
315 {
316 free(processingData->graphs);
317 }
318
70407e86
BP		 319 free(syncState->processingData);
320 syncState->processingData= NULL;
321}
322
323
324/*
325 * Unregister event hooks. Deallocate some of processingData.
326 *
327 * This function can be called right after the events have been processed to
328 * free some data structures that are not needed for finalization.
329 *
330 * Args:
331 * syncState: container for synchronization data.
332 * This function deallocates these members:
333 * traceNumTable
334 * hookListList
335 * pendingRecv
336 */
337static void partialDestroyProcessingLTTVStandard(SyncState* const syncState)
338{
339 unsigned int i;
340 ProcessingDataLTTVStandard* processingData;
341
342 processingData= (ProcessingDataLTTVStandard*) syncState->processingData;
343
344 if (processingData == NULL || processingData->traceNumTable == NULL)
345 {
346 return;
347 }
348
349 g_hash_table_destroy(processingData->traceNumTable);
350 processingData->traceNumTable= NULL;
351
352 for(i= 0; i < syncState->traceNb; i++)
353 {
354
355 g_debug("Cleaning up pendingRecv list\n");
356 g_hash_table_destroy(processingData->pendingRecv[i]);
357 }
358 free(processingData->pendingRecv);
359
360 unregisterHooks(processingData->hookListList,
08365995 361 processingData->traceSetContext);
70407e86
BP		 362}
363
364
365/*
366 * Lttv hook function that will be called for network events
367 *
368 * Args:
369 * hookData: LttvTraceHook* for the type of event that generated the call
370 * callData: LttvTracefileContext* at the moment of the event
371 *
372 * Returns:
373 * FALSE Always returns FALSE, meaning to keep processing hooks for
374 * this event
375 */
376static gboolean processEventLTTVStandard(void* hookData, void* callData)
377{
378 LttvTraceHook* traceHook;
379 LttvTracefileContext* tfc;
380 LttEvent* event;
70407e86 381 LttCycleCount tsc;
76be6fc2
BP		 382 LttTime time;
383 WallTime wTime;
70407e86
BP		 384 LttTrace* trace;
385 unsigned long traceNum;
386 struct marker_info* info;
387 SyncState* syncState;
388 ProcessingDataLTTVStandard* processingData;
389
390 traceHook= (LttvTraceHook*) hookData;
391 tfc= (LttvTracefileContext*) callData;
9a9ca632 392 trace= tfc->t_context->t;
70407e86
BP		 393 syncState= (SyncState*) traceHook->hook_data;
394 processingData= (ProcessingDataLTTVStandard*) syncState->processingData;
395 event= ltt_tracefile_get_event(tfc->tf);
70407e86 396 info= marker_get_info_from_id(tfc->tf->mdata, event->event_id);
76be6fc2
BP		 397 tsc= ltt_event_cycle_count(event);
398 time= ltt_event_time(event);
399 wTime.seconds= time.tv_sec;
400 wTime.nanosec= time.tv_nsec;
70407e86
BP		 401
402 g_assert(g_hash_table_lookup_extended(processingData->traceNumTable,
403 trace, NULL, (gpointer*) &traceNum));
404
405 g_debug("XXXX process event: time: %ld.%09ld trace: %ld (%p) name: %s ",
76be6fc2 406 time.tv_sec, time.tv_nsec, traceNum, trace,
70407e86
BP		 407 g_quark_to_string(info->name));
408
fea7219b 409 if (info->name == LTT_EVENT_DEV_XMIT_EXTENDED)
70407e86 410 {
10341d26 411 Event* outE;
70407e86
BP		 412
413 if (!ltt_event_get_unsigned(event,
414 lttv_trace_get_hook_field(traceHook, 1)) == ETH_P_IP ||
415 !ltt_event_get_unsigned(event,
416 lttv_trace_get_hook_field(traceHook, 2)) == IPPROTO_TCP)
417 {
418 return FALSE;
419 }
420
f6691532
BP		 421 if (!syncState->matchingModule->canMatch[TCP])
422 {
423 return FALSE;
424 }
425
70407e86
BP		 426 if (syncState->stats)
427 {
428 processingData->stats->totOutE++;
429 }
430
10341d26 431 outE= malloc(sizeof(Event));
70407e86 432 outE->traceNum= traceNum;
76be6fc2
BP		 433 outE->cpuTime= tsc;
434 outE->wallTime= wTime;
10341d26 435 outE->type= TCP;
d4721e1a 436 outE->copy= &copyTCPEvent;
10341d26
BP		 437 outE->destroy= &destroyTCPEvent;
438 outE->event.tcpEvent= malloc(sizeof(TCPEvent));
439 outE->event.tcpEvent->direction= OUT;
440 outE->event.tcpEvent->segmentKey= malloc(sizeof(SegmentKey));
441 outE->event.tcpEvent->segmentKey->connectionKey.saddr=
d4721e1a
BP		 442 htonl(ltt_event_get_unsigned(event,
443 lttv_trace_get_hook_field(traceHook, 3)));
10341d26 444 outE->event.tcpEvent->segmentKey->connectionKey.daddr=
d4721e1a
BP		 445 htonl(ltt_event_get_unsigned(event,
446 lttv_trace_get_hook_field(traceHook, 4)));
10341d26
BP		 447 outE->event.tcpEvent->segmentKey->tot_len=
448 ltt_event_get_unsigned(event, lttv_trace_get_hook_field(traceHook,
449 5));
450 outE->event.tcpEvent->segmentKey->ihl= ltt_event_get_unsigned(event,
70407e86 451 lttv_trace_get_hook_field(traceHook, 6));
10341d26
BP		 452 outE->event.tcpEvent->segmentKey->connectionKey.source=
453 ltt_event_get_unsigned(event, lttv_trace_get_hook_field(traceHook,
454 7));
455 outE->event.tcpEvent->segmentKey->connectionKey.dest=
456 ltt_event_get_unsigned(event, lttv_trace_get_hook_field(traceHook,
457 8));
458 outE->event.tcpEvent->segmentKey->seq= ltt_event_get_unsigned(event,
70407e86 459 lttv_trace_get_hook_field(traceHook, 9));
10341d26
BP		 460 outE->event.tcpEvent->segmentKey->ack_seq=
461 ltt_event_get_unsigned(event, lttv_trace_get_hook_field(traceHook,
462 10));
463 outE->event.tcpEvent->segmentKey->doff= ltt_event_get_unsigned(event,
70407e86 464 lttv_trace_get_hook_field(traceHook, 11));
10341d26 465 outE->event.tcpEvent->segmentKey->ack= ltt_event_get_unsigned(event,
70407e86 466 lttv_trace_get_hook_field(traceHook, 12));
10341d26 467 outE->event.tcpEvent->segmentKey->rst= ltt_event_get_unsigned(event,
70407e86 468 lttv_trace_get_hook_field(traceHook, 13));
10341d26 469 outE->event.tcpEvent->segmentKey->syn= ltt_event_get_unsigned(event,
70407e86 470 lttv_trace_get_hook_field(traceHook, 14));
10341d26 471 outE->event.tcpEvent->segmentKey->fin= ltt_event_get_unsigned(event,
70407e86
BP		 472 lttv_trace_get_hook_field(traceHook, 15));
473
10341d26 474 syncState->matchingModule->matchEvent(syncState, outE);
70407e86
BP		 475
476 g_debug("Output event done\n");
477 }
478 else if (info->name == LTT_EVENT_DEV_RECEIVE)
479 {
480 guint32 protocol;
481
482 if (syncState->stats)
483 {
484 processingData->stats->totRecv++;
485 }
486
487 protocol= ltt_event_get_unsigned(event,
488 lttv_trace_get_hook_field(traceHook, 1));
489
490 if (protocol == ETH_P_IP)
491 {
10341d26
BP		 492 Event* inE;
493 void* skb;
70407e86
BP		 494
495 if (syncState->stats)
496 {
497 processingData->stats->totRecvIp++;
498 }
499
10341d26 500 inE= malloc(sizeof(Event));
70407e86 501 inE->traceNum= traceNum;
76be6fc2
BP		 502 inE->cpuTime= tsc;
503 inE->wallTime= wTime;
10341d26 504 inE->event.tcpEvent= NULL;
d4721e1a 505 inE->copy= &copyEvent;
10341d26 506 inE->destroy= &destroyEvent;
70407e86 507
10341d26
BP		 508 skb= (void*) (long) ltt_event_get_long_unsigned(event,
509 lttv_trace_get_hook_field(traceHook, 0));
510 g_hash_table_replace(processingData->pendingRecv[traceNum], skb,
511 inE);
70407e86 512
10341d26 513 g_debug("Adding inE %p for skb %p to pendingRecv\n", inE, skb);
70407e86
BP		 514 }
515 else
516 {
517 g_debug("\n");
518 }
519 }
fea7219b 520 else if (info->name == LTT_EVENT_TCPV4_RCV_EXTENDED)
70407e86 521 {
10341d26 522 Event* inE;
70407e86
BP		 523 void* skb;
524
525 // Search pendingRecv for an event with the same skb
526 skb= (void*) (long) ltt_event_get_long_unsigned(event,
527 lttv_trace_get_hook_field(traceHook, 0));
528
10341d26 529 inE= (Event*)
70407e86
BP		 530 g_hash_table_lookup(processingData->pendingRecv[traceNum], skb);
531 if (inE == NULL)
532 {
533 // This should only happen in case of lost events
f6691532 534 g_warning("No matching pending receive event found");
70407e86
BP		 535 }
536 else
537 {
538 if (syncState->stats)
539 {
f6691532 540 processingData->stats->totRecvTCP++;
70407e86
BP		 541 }
542
543 // If it's there, remove it and proceed with a receive event
544 g_hash_table_steal(processingData->pendingRecv[traceNum], skb);
545
10341d26
BP		 546 inE->type= TCP;
547 inE->event.tcpEvent= malloc(sizeof(TCPEvent));
d4721e1a 548 inE->copy= &copyTCPEvent;
10341d26
BP		 549 inE->destroy= &destroyTCPEvent;
550 inE->event.tcpEvent->direction= IN;
551 inE->event.tcpEvent->segmentKey= malloc(sizeof(SegmentKey));
552 inE->event.tcpEvent->segmentKey->connectionKey.saddr=
d4721e1a
BP		 553 htonl(ltt_event_get_unsigned(event,
554 lttv_trace_get_hook_field(traceHook, 1)));
10341d26 555 inE->event.tcpEvent->segmentKey->connectionKey.daddr=
d4721e1a
BP		 556 htonl(ltt_event_get_unsigned(event,
557 lttv_trace_get_hook_field(traceHook, 2)));
10341d26
BP		 558 inE->event.tcpEvent->segmentKey->tot_len=
559 ltt_event_get_unsigned(event,
560 lttv_trace_get_hook_field(traceHook, 3));
561 inE->event.tcpEvent->segmentKey->ihl=
562 ltt_event_get_unsigned(event,
563 lttv_trace_get_hook_field(traceHook, 4));
564 inE->event.tcpEvent->segmentKey->connectionKey.source=
565 ltt_event_get_unsigned(event,
566 lttv_trace_get_hook_field(traceHook, 5));
567 inE->event.tcpEvent->segmentKey->connectionKey.dest=
568 ltt_event_get_unsigned(event,
569 lttv_trace_get_hook_field(traceHook, 6));
570 inE->event.tcpEvent->segmentKey->seq=
571 ltt_event_get_unsigned(event,
572 lttv_trace_get_hook_field(traceHook, 7));
573 inE->event.tcpEvent->segmentKey->ack_seq=
574 ltt_event_get_unsigned(event,
575 lttv_trace_get_hook_field(traceHook, 8));
576 inE->event.tcpEvent->segmentKey->doff=
577 ltt_event_get_unsigned(event,
578 lttv_trace_get_hook_field(traceHook, 9));
579 inE->event.tcpEvent->segmentKey->ack=
580 ltt_event_get_unsigned(event,
581 lttv_trace_get_hook_field(traceHook, 10));
582 inE->event.tcpEvent->segmentKey->rst=
583 ltt_event_get_unsigned(event,
584 lttv_trace_get_hook_field(traceHook, 11));
585 inE->event.tcpEvent->segmentKey->syn=
586 ltt_event_get_unsigned(event,
587 lttv_trace_get_hook_field(traceHook, 12));
588 inE->event.tcpEvent->segmentKey->fin=
589 ltt_event_get_unsigned(event,
590 lttv_trace_get_hook_field(traceHook, 13));
591
592 syncState->matchingModule->matchEvent(syncState, inE);
70407e86 593
f6691532 594 g_debug("TCP input event %p for skb %p done\n", inE, skb);
70407e86
BP		 595 }
596 }
f6691532 597 else if (info->name == LTT_EVENT_UDPV4_RCV_EXTENDED)
70407e86 598 {
f6691532
BP		 599 Event* inE;
600 void* skb;
70407e86 601
f6691532
BP		 602 // Search pendingRecv for an event with the same skb
603 skb= (void*) (long) ltt_event_get_long_unsigned(event,
604 lttv_trace_get_hook_field(traceHook, 0));
70407e86 605
f6691532
BP		 606 inE= (Event*)
607 g_hash_table_lookup(processingData->pendingRecv[traceNum], skb);
608 if (inE == NULL)
609 {
610 // This should only happen in case of lost events
611 g_warning("No matching pending receive event found");
612 }
613 else
614 {
615 guint64 dataStart;
70407e86 616
f6691532
BP		 617 if (syncState->stats)
618 {
619 processingData->stats->totRecvUDP++;
620 }
621
622 // If it's there, remove it and proceed with a receive event
623 g_hash_table_steal(processingData->pendingRecv[traceNum], skb);
624
625 inE->type= UDP;
626 inE->event.udpEvent= malloc(sizeof(UDPEvent));
d4721e1a 627 inE->copy= &copyUDPEvent;
f6691532
BP		 628 inE->destroy= &destroyUDPEvent;
629 inE->event.udpEvent->direction= IN;
630 inE->event.udpEvent->datagramKey= malloc(sizeof(DatagramKey));
631 inE->event.udpEvent->datagramKey->saddr=
d4721e1a
BP		 632 htonl(ltt_event_get_unsigned(event,
633 lttv_trace_get_hook_field(traceHook, 1)));
f6691532 634 inE->event.udpEvent->datagramKey->daddr=
d4721e1a
BP		 635 htonl(ltt_event_get_unsigned(event,
636 lttv_trace_get_hook_field(traceHook, 2)));
f6691532
BP		 637 inE->event.udpEvent->unicast= ltt_event_get_unsigned(event,
638 lttv_trace_get_hook_field(traceHook, 3)) == 0 ? false : true;
639 inE->event.udpEvent->datagramKey->ulen=
640 ltt_event_get_unsigned(event,
641 lttv_trace_get_hook_field(traceHook, 4));
642 inE->event.udpEvent->datagramKey->source=
643 ltt_event_get_unsigned(event,
644 lttv_trace_get_hook_field(traceHook, 5));
645 inE->event.udpEvent->datagramKey->dest=
646 ltt_event_get_unsigned(event,
647 lttv_trace_get_hook_field(traceHook, 6));
648 dataStart= ltt_event_get_long_unsigned(event,
649 lttv_trace_get_hook_field(traceHook, 7));
650 g_assert_cmpuint(sizeof(inE->event.udpEvent->datagramKey->dataKey),
651 ==, sizeof(guint64));
652 if (inE->event.udpEvent->datagramKey->ulen - 8 >=
653 sizeof(inE->event.udpEvent->datagramKey->dataKey))
654 {
655 memcpy(inE->event.udpEvent->datagramKey->dataKey, &dataStart,
656 sizeof(inE->event.udpEvent->datagramKey->dataKey));
657 }
658 else
659 {
660 memset(inE->event.udpEvent->datagramKey->dataKey, 0,
661 sizeof(inE->event.udpEvent->datagramKey->dataKey));
662 memcpy(inE->event.udpEvent->datagramKey->dataKey, &dataStart,
663 inE->event.udpEvent->datagramKey->ulen - 8);
664 }
665
666 syncState->matchingModule->matchEvent(syncState, inE);
667
668 g_debug("UDP input event %p for skb %p done\n", inE, skb);
669 }
70407e86
BP		 670 }
671 else
672 {
673 g_assert_not_reached();
674 }
675
676 return FALSE;
677}
08365995
BP		 678
679
66eaf2eb
BP		 680/*
681 * Write the processing-specific variables in the gnuplot script.
682 *
683 * Args:
684 * syncState: container for synchronization data
685 * i: trace number
686 */
687static void writeProcessingGraphVariablesLTTVStandard(SyncState* const
688 syncState, const unsigned int i)
689{
690 ProcessingDataLTTVStandard* processingData= syncState->processingData;
691 ProcessingGraphsLTTVStandard* traceI= &processingData->graphs[i];
692
693 fprintf(syncState->graphsStream, "clock_freq_%u= %.3f\n", i, (double)
694 traceI->startFreq / traceI->freqScale);
695}
696
697
08365995 698/*
d6ee5003 699 * Write the processing-specific options in the gnuplot script.
08365995
BP		 700 *
701 * Args:
08365995
BP		 702 * syncState: container for synchronization data
703 * i: first trace number
704 * j: second trace number, garanteed to be larger than i
705 */
467066ee 706static void writeProcessingTraceTraceOptionsLTTVStandard(SyncState* const
8d7d16dd 707 syncState, const unsigned int i, const unsigned int j)
08365995
BP		 708{
709 ProcessingDataLTTVStandard* processingData;
1633c5a5 710 ProcessingGraphsLTTVStandard* traceI, * traceJ;
08365995
BP		 711
712 processingData= (ProcessingDataLTTVStandard*) syncState->processingData;
713
1633c5a5
BP		 714 traceI= &processingData->graphs[i];
715 traceJ= &processingData->graphs[j];
08365995 716
8d7d16dd 717 fprintf(syncState->graphsStream,
d6ee5003
BP		 718 "set key inside right bottom\n"
719 "set xlabel \"Clock %1$u\"\n"
720 "set xtics nomirror\n"
66eaf2eb 721 "set ylabel \"Clock %2$u\"\n"
d6ee5003 722 "set ytics nomirror\n"
08365995 723 "set x2label \"Clock %1$d (s)\"\n"
66eaf2eb 724 "set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
08365995 725 "set x2tics\n"
66eaf2eb
BP		 726 "set y2label \"Clock %2$d (s)\"\n"
727 "set y2range [GPVAL_Y_MIN / clock_freq_%2$u : GPVAL_Y_MAX / clock_freq_%2$u]\n"
728 "set y2tics\n", i, j);
08365995 729}
467066ee
BP		 730
731
732/*
733 * Write the processing-specific options in the gnuplot script.
734 *
735 * Args:
736 * syncState: container for synchronization data
737 * i: first trace number
738 * j: second trace number, garanteed to be larger than i
739 */
740static void writeProcessingTraceTimeOptionsLTTVStandard(SyncState* const
741 syncState, const unsigned int i, const unsigned int j)
742{
743 ProcessingDataLTTVStandard* processingData;
744 ProcessingGraphsLTTVStandard* traceI, * traceJ;
745
746 processingData= (ProcessingDataLTTVStandard*) syncState->processingData;
747
748 traceI= &processingData->graphs[i];
749 traceJ= &processingData->graphs[j];
750
751 fprintf(syncState->graphsStream,
752 "set key inside right bottom\n"
753 "set xlabel \"Clock %1$u\"\n"
754 "set xtics nomirror\n"
755 "set ylabel \"time (s)\"\n"
756 "set ytics nomirror\n"
757 "set x2label \"Clock %1$d (s)\"\n"
66eaf2eb
BP		 758 "set x2range [GPVAL_X_MIN / clock_freq_%1$u : GPVAL_X_MAX / clock_freq_%1$u]\n"
759 "set x2tics\n", i);
467066ee 760}
LTTng 2.x Viewer (LTTV)
This page took 0.053463 seconds and 4 git commands to generate.