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