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