lttv/lttv/sync/data_structures.h

   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 #ifndef DATA_STRUCTURES_H
  20 #define DATA_STRUCTURES_H
  21
  22 #include <glib.h>
  23 #include <stdbool.h>
  24 #include <stdint.h>
  25
  26 #include <ltt/ltt.h>
  27
  28 // Stage 1 to 2: These structures are passed from processing to matching modules
  29 // TCP events
  30 typedef struct
  31 {
  32         uint32_t saddr, daddr;
  33         uint16_t source, dest;
  34 } ConnectionKey;
  35
  36 typedef struct
  37 {
  38         ConnectionKey connectionKey;
  39         uint8_t ihl;
  40         uint16_t tot_len;
  41         uint32_t seq, ack_seq;
  42         uint8_t doff;
  43         uint8_t ack, rst, syn, fin;
  44 } SegmentKey;
  45
  46 enum Direction
  47 {
  48         OUT,
  49         IN,
  50 };
  51
  52 enum EventType
  53 {
  54         TCP,
  55         UDP,
  56         TYPE_COUNT,
  57 };
  58
  59 typedef struct
  60 {
  61         enum Direction direction;
  62         SegmentKey* segmentKey;
  63 } TCPEvent;
  64
  65 // UDP events
  66 typedef struct
  67 {
  68         uint32_t saddr, daddr;
  69         uint16_t source, dest;
  70         uint16_t ulen;
  71         uint8_t dataKey[8];
  72 } DatagramKey;
  73
  74 typedef struct
  75 {
  76         enum Direction direction;
  77         DatagramKey* datagramKey;
  78         bool unicast;
  79 } UDPEvent;
  80
  81 typedef struct _Event
  82 {
  83         unsigned long traceNum;
  84         uint64_t time;
  85
  86         // specific event structures and functions could be in separate files and
  87         // type could be an int
  88         enum EventType type;
  89         // event could be a void*, this union is to avoid having to cast
  90         union {
  91                 TCPEvent* tcpEvent;
  92                 UDPEvent* udpEvent;
  93         } event;
  94
  95         void (*destroy)(struct _Event* const event);
  96 } Event;
  97
  98 // Stage 2 to 3: These structures are passed from matching to analysis modules
  99 typedef struct _Message
 100 {
 101         Event* inE, * outE;
 102
 103         void (*print)(const struct _Message* const message);
 104 } Message;
 105
 106 typedef struct
 107 {
 108         Message* message;
 109         GQueue* acks;
 110 } Exchange;
 111
 112 typedef struct
 113 {
 114         GQueue* events;
 115 } Broadcast;
 116
 117 // One set of factors for each trace, this is the result of synchronization
 118 typedef struct
 119 {
 120         double drift, offset;
 121 } Factors;
 122
 123
 124 // ConnectionKey-related functions
 125 guint ghfConnectionKeyHash(gconstpointer key);
 126
 127 gboolean gefConnectionKeyEqual(gconstpointer a, gconstpointer b);
 128 bool connectionKeyEqual(const ConnectionKey* const a, const ConnectionKey*
 129         const b);
 130
 131 void gdnConnectionKeyDestroy(gpointer data);
 132
 133 // SegmentKey-related functions
 134 guint ghfSegmentKeyHash(gconstpointer key);
 135 gboolean gefSegmentKeyEqual(gconstpointer a, gconstpointer b);
 136
 137 // Event-related functions
 138 void gdnDestroyEvent(gpointer data);
 139 void destroyEvent(Event* const event);
 140 void destroyTCPEvent(Event* const event);
 141 void destroyUDPEvent(Event* const event);
 142 void gfDestroyEvent(gpointer data, gpointer user_data);
 143
 144 // Message-related functions
 145 void printTCPSegment(const Message* const segment);
 146 void convertIP(char* const str, const uint32_t addr);
 147
 148 gint gcfTCPSegmentAckCompare(gconstpointer a, gconstpointer b);
 149 bool isAcking(const Message* const ackSegment, const Message* const ackedSegment);
 150
 151 void gdnTCPSegmentListDestroy(gpointer data);
 152 void gfTCPSegmentDestroy(gpointer data, gpointer user_data);
 153 void destroyTCPSegment(Message* const segment);
 154
 155 // Exchange-related functions
 156 void destroyTCPExchange(Exchange* const exchange);
 157
 158 // Broadcast-related functions
 159 void gdnDestroyBroadcast(gpointer data);
 160 void destroyBroadcast(Broadcast* const broadcast);
 161
 162 #endif