lttv/lttv/sync/event_processing_lttng_common.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2009, 2010 Benjamin Poirier <benjamin.poirier@polymtl.ca>
   3  *
   4  * This program is free software: you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation, either version 2.1 of the License, or (at
   7  * your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  12  * License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #include "data_structures.h"
  23 #include "event_processing_lttng_common.h"
  24
  25
  26 /*
  27  * Initialize the GQuarks needed to register the event hooks for
  28  * synchronization
  29  */
  30 void createQuarks()
  31 {
  32         LTT_CHANNEL_NET= g_quark_from_static_string("net");
  33
  34         LTT_EVENT_DEV_XMIT_EXTENDED= g_quark_from_static_string("dev_xmit_extended");
  35         LTT_EVENT_DEV_RECEIVE= g_quark_from_static_string("dev_receive");
  36         LTT_EVENT_TCPV4_RCV_EXTENDED= g_quark_from_static_string("tcpv4_rcv_extended");
  37         LTT_EVENT_UDPV4_RCV_EXTENDED= g_quark_from_static_string("udpv4_rcv_extended");
  38
  39         LTT_FIELD_SKB= g_quark_from_static_string("skb");
  40         LTT_FIELD_PROTOCOL= g_quark_from_static_string("protocol");
  41         LTT_FIELD_NETWORK_PROTOCOL=
  42                 g_quark_from_static_string("network_protocol");
  43         LTT_FIELD_TRANSPORT_PROTOCOL=
  44                 g_quark_from_static_string("transport_protocol");
  45         LTT_FIELD_SADDR= g_quark_from_static_string("saddr");
  46         LTT_FIELD_DADDR= g_quark_from_static_string("daddr");
  47         LTT_FIELD_TOT_LEN= g_quark_from_static_string("tot_len");
  48         LTT_FIELD_IHL= g_quark_from_static_string("ihl");
  49         LTT_FIELD_SOURCE= g_quark_from_static_string("source");
  50         LTT_FIELD_DEST= g_quark_from_static_string("dest");
  51         LTT_FIELD_SEQ= g_quark_from_static_string("seq");
  52         LTT_FIELD_ACK_SEQ= g_quark_from_static_string("ack_seq");
  53         LTT_FIELD_DOFF= g_quark_from_static_string("doff");
  54         LTT_FIELD_ACK= g_quark_from_static_string("ack");
  55         LTT_FIELD_RST= g_quark_from_static_string("rst");
  56         LTT_FIELD_SYN= g_quark_from_static_string("syn");
  57         LTT_FIELD_FIN= g_quark_from_static_string("fin");
  58         LTT_FIELD_UNICAST= g_quark_from_static_string("unicast");
  59         LTT_FIELD_ULEN= g_quark_from_static_string("ulen");
  60         LTT_FIELD_DATA_START= g_quark_from_static_string("data_start");
  61 }
  62
  63
  64 /* Fill hookListList and add event hooks
  65  *
  66  * Note: possibilité de remettre le code avec lttv_trace_find_marker_ids (voir
  67  * r328)
  68  *
  69  * Args:
  70  *   hookListList: LttvTraceHook hookListList[traceNum][hookNum]
  71  *   traceSetContext: LTTV traceset
  72  *   hookFunction: call back function when event is encountered
  73  *   hookData:     data that will be made accessible to hookFunction in
  74  *                 arg0->hook_data
  75  *   eventTypes:   types of events for which to register hooks
  76  */
  77 void registerHooks(GArray* hookListList, LttvTracesetContext* const
  78         traceSetContext, LttvHook hookFunction, gpointer hookData, const bool
  79         const* eventTypes)
  80 {
  81         unsigned int i, j, k;
  82         unsigned int traceNb= lttv_traceset_number(traceSetContext->ts);
  83         struct {
  84                 GQuark channelName;
  85                 GQuark eventName;
  86                 GQuark* fields;
  87                 bool eventTypes[TYPE_COUNT];
  88         } eventHookInfoList[] = {
  89                 {
  90                         .channelName= LTT_CHANNEL_NET,
  91                         .eventName= LTT_EVENT_DEV_XMIT_EXTENDED,
  92                         .fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_NETWORK_PROTOCOL,
  93                                 LTT_FIELD_TRANSPORT_PROTOCOL, LTT_FIELD_SADDR,
  94                                 LTT_FIELD_DADDR, LTT_FIELD_TOT_LEN, LTT_FIELD_IHL,
  95                                 LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_SEQ,
  96                                 LTT_FIELD_ACK_SEQ, LTT_FIELD_DOFF, LTT_FIELD_ACK,
  97                                 LTT_FIELD_RST, LTT_FIELD_SYN, LTT_FIELD_FIN),
  98                         .eventTypes[TCP]= true,
  99                         .eventTypes[UDP]= true,
 100                 }, {
 101                         .channelName= LTT_CHANNEL_NET,
 102                         .eventName= LTT_EVENT_DEV_RECEIVE,
 103                         .fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_PROTOCOL),
 104                         .eventTypes[TCP]= true,
 105                         .eventTypes[UDP]= true,
 106                 }, {
 107                         .channelName= LTT_CHANNEL_NET,
 108                         .eventName= LTT_EVENT_TCPV4_RCV_EXTENDED,
 109                         .fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_SADDR,
 110                                 LTT_FIELD_DADDR, LTT_FIELD_TOT_LEN, LTT_FIELD_IHL,
 111                                 LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_SEQ,
 112                                 LTT_FIELD_ACK_SEQ, LTT_FIELD_DOFF, LTT_FIELD_ACK,
 113                                 LTT_FIELD_RST, LTT_FIELD_SYN, LTT_FIELD_FIN),
 114                         .eventTypes[TCP]= true,
 115                         .eventTypes[UDP]= false,
 116                 }, {
 117                         .channelName= LTT_CHANNEL_NET,
 118                         .eventName= LTT_EVENT_UDPV4_RCV_EXTENDED,
 119                         .fields= FIELD_ARRAY(LTT_FIELD_SKB, LTT_FIELD_SADDR,
 120                                 LTT_FIELD_DADDR, LTT_FIELD_UNICAST, LTT_FIELD_ULEN,
 121                                 LTT_FIELD_SOURCE, LTT_FIELD_DEST, LTT_FIELD_DATA_START),
 122                         .eventTypes[TCP]= false,
 123                         .eventTypes[UDP]= true,
 124                 }
 125         }; // This is called a compound literal
 126         unsigned int hookNb= sizeof(eventHookInfoList) / sizeof(*eventHookInfoList);
 127
 128         for(i= 0; i < traceNb; i++)
 129         {
 130                 LttvTraceContext* tc;
 131                 GArray* hookList;
 132                 int retval;
 133
 134                 tc= traceSetContext->traces[i];
 135                 hookList= g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
 136                 g_array_append_val(hookListList, hookList);
 137
 138                 // Find the hooks
 139                 for (j= 0; j < hookNb; j++)
 140                 {
 141                         guint old_len;
 142                         bool registerHook;
 143
 144                         registerHook= false;
 145                         for (k= 0; k < TYPE_COUNT; k++)
 146                         {
 147                                 if (eventTypes[k] && eventHookInfoList[j].eventTypes[k])
 148                                 {
 149                                         registerHook= true;
 150                                         break;
 151                                 }
 152                         }
 153                         if (!registerHook)
 154                         {
 155                                 continue;
 156                         }
 157
 158                         old_len= hookList->len;
 159                         retval= lttv_trace_find_hook(tc->t,
 160                                 eventHookInfoList[j].channelName,
 161                                 eventHookInfoList[j].eventName, eventHookInfoList[j].fields,
 162                                 hookFunction, hookData, &hookList);
 163                         if (retval != 0)
 164                         {
 165                                 g_warning("Trace %d contains no %s.%s marker\n", i,
 166                                         g_quark_to_string(eventHookInfoList[j].channelName),
 167                                         g_quark_to_string(eventHookInfoList[j].eventName));
 168                         }
 169                         else
 170                         {
 171                                 g_assert(hookList->len - old_len == 1);
 172                         }
 173                 }
 174
 175                 // Add the hooks to each tracefile's event_by_id hook list
 176                 for(j= 0; j < tc->tracefiles->len; j++)
 177                 {
 178                         LttvTracefileContext* tfc;
 179
 180                         tfc= g_array_index(tc->tracefiles, LttvTracefileContext*, j);
 181
 182                         for(k= 0; k < hookList->len; k++)
 183                         {
 184                                 LttvTraceHook* traceHook;
 185
 186                                 traceHook= &g_array_index(hookList, LttvTraceHook, k);
 187                                 if (traceHook->hook_data != hookData)
 188                                 {
 189                                         g_assert_not_reached();
 190                                 }
 191                                 if (traceHook->mdata == tfc->tf->mdata)
 192                                 {
 193                                         lttv_hooks_add(lttv_hooks_by_id_find(tfc->event_by_id,
 194                                                         traceHook->id), traceHook->h, traceHook,
 195                                                 LTTV_PRIO_DEFAULT);
 196                                 }
 197                         }
 198                 }
 199         }
 200 }
 201
 202
 203 /* Remove event hooks and free hookListList
 204  *
 205  * Args:
 206  *   hookListList: LttvTraceHook hookListList[traceNum][hookNum]
 207  *   traceSetContext: LTTV traceset
 208  */
 209 void unregisterHooks(GArray* hookListList, LttvTracesetContext* const
 210         traceSetContext)
 211 {
 212         unsigned int i, j, k;
 213         unsigned int traceNb= lttv_traceset_number(traceSetContext->ts);
 214
 215         for(i= 0; i < traceNb; i++)
 216         {
 217                 LttvTraceContext* tc;
 218                 GArray* hookList;
 219
 220                 tc= traceSetContext->traces[i];
 221                 hookList= g_array_index(hookListList, GArray*, i);
 222
 223                 // Remove the hooks from each tracefile's event_by_id hook list
 224                 for(j= 0; j < tc->tracefiles->len; j++)
 225                 {
 226                         LttvTracefileContext* tfc;
 227
 228                         tfc= g_array_index(tc->tracefiles, LttvTracefileContext*, j);
 229
 230                         for(k= 0; k < hookList->len; k++)
 231                         {
 232                                 LttvTraceHook* traceHook;
 233
 234                                 traceHook= &g_array_index(hookList, LttvTraceHook, k);
 235                                 if (traceHook->mdata == tfc->tf->mdata)
 236                                 {
 237                                         lttv_hooks_remove_data(lttv_hooks_by_id_find(tfc->event_by_id,
 238                                                         traceHook->id), traceHook->h, traceHook);
 239                                 }
 240                         }
 241                 }
 242
 243                 g_array_free(hookList, TRUE);
 244         }
 245         g_array_free(hookListList, TRUE);
 246 }