[lttv.git] / tags / LinuxTraceToolkitViewer-0.10.0-pre-115102007 / ltt / event.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2007 Mathieu Desnoyers
 *
 * Complete rewrite from the original version made by XangXiu Yang.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License Version 2.1 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <glib.h>

#include <ltt/event.h>
#include <ltt/ltt-types.h>
#include <ltt/ltt-private.h>

/*****************************************************************************
 *Function name
 *    ltt_event_position_get : get the event position data
 *Input params
 *    e                  : an instance of an event type   
 *    ep                 : a pointer to event's position structure
 *    tf                 : tracefile pointer
 *    block              : current block
 *    offset             : current offset
 *    tsc                : current tsc
 ****************************************************************************/
void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf,
        guint *block, guint *offset, guint64 *tsc)
{
  *tf = ep->tracefile;
  *block = ep->block;
  *offset = ep->offset;
  *tsc = ep->tsc;
}


void ltt_event_position_set(LttEventPosition *ep, LttTracefile *tf,
        guint block, guint offset, guint64 tsc)
{
  ep->tracefile = tf;
  ep->block = block;
  ep->offset = offset;
  ep->tsc = tsc;
}


/*****************************************************************************
 *Function name
 *    ltt_event_position : get the event's position
 *Input params
 *    e                  : an instance of an event type   
 *    ep                 : a pointer to event's position structure
 ****************************************************************************/

void ltt_event_position(LttEvent *e, LttEventPosition *ep)
{
  ep->tracefile = e->tracefile;
  ep->block = e->block;
  ep->offset = e->offset;
  ep->tsc = e->tsc;
}

LttEventPosition * ltt_event_position_new()
{
  return g_new(LttEventPosition, 1);
}


/*****************************************************************************
 * Function name
 *    ltt_event_position_compare : compare two positions
 *    A NULL value is infinite.
 * Input params
 *    ep1                    : a pointer to event's position structure
 *    ep2                    : a pointer to event's position structure
 * Return
 *    -1 is ep1 < ep2
 *    1 if ep1 > ep2
 *    0 if ep1 == ep2
 ****************************************************************************/


gint ltt_event_position_compare(const LttEventPosition *ep1,
                                const LttEventPosition *ep2)
{
  if(ep1 == NULL && ep2 == NULL)
      return 0;
  if(ep1 != NULL && ep2 == NULL)
      return -1;
  if(ep1 == NULL && ep2 != NULL)
      return 1;

   if(ep1->tracefile != ep2->tracefile)
    g_error("ltt_event_position_compare on different tracefiles makes no sense");
   
  if(ep1->block < ep2->block)
    return -1;
  if(ep1->block > ep2->block)
    return 1;
  if(ep1->offset < ep2->offset)
    return -1;
  if(ep1->offset > ep2->offset)
    return 1;
  return 0;
}

/*****************************************************************************
 * Function name
 *    ltt_event_position_copy : copy position
 * Input params
 *    src                    : a pointer to event's position structure source
 *    dest                   : a pointer to event's position structure dest
 * Return
 *    void
 ****************************************************************************/
void ltt_event_position_copy(LttEventPosition *dest,
                             const LttEventPosition *src)
{
  if(src == NULL)
    dest = NULL;
  else
    *dest = *src;
}


LttTracefile *ltt_event_position_tracefile(LttEventPosition *ep)
{
  return ep->tracefile;
}

/*****************************************************************************
 * These functions extract data from an event after architecture specific
 * conversions
 ****************************************************************************/
guint32 ltt_event_get_unsigned(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;

  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }

  switch(f->size) {
  case 1:
    {
      guint8 x = *(guint8 *)(e->data + f->offset);
      return (guint32) x;    
    }
    break;
  case 2:
    return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
  default:
    g_critical("ltt_event_get_unsigned : field size %i unknown", f->size);
    return 0;
    break;
  }
}

gint32 ltt_event_get_int(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }

  switch(f->size) {
  case 1:
    {
      gint8 x = *(gint8 *)(e->data + f->offset);
      return (gint32) x;    
    }
    break;
  case 2:
    return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
  default:
    g_critical("ltt_event_get_int : field size %i unknown", f->size);
    return 0;
    break;
  }
}

guint64 ltt_event_get_long_unsigned(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }
  
  switch(f->size) {
  case 1:
    {
      guint8 x = *(guint8 *)(e->data + f->offset);
      return (guint64) x;    
    }
    break;
  case 2:
    return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
    return ltt_get_uint64(reverse_byte_order, e->data + f->offset);
    break;
  default:
    g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->size);
    return 0;
    break;
  }
}

gint64 ltt_event_get_long_int(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }
  
  switch(f->size) {
  case 1:
    {
      gint8 x = *(gint8 *)(e->data + f->offset);
      return (gint64) x;    
    }
    break;
  case 2:
    return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
    return ltt_get_int64(reverse_byte_order, e->data + f->offset);
    break;
  default:
    g_critical("ltt_event_get_long_int : field size %i unknown", f->size);
    return 0;
    break;
  }
}

#if 0
float ltt_event_get_float(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    g_assert(LTT_HAS_FLOAT(e->tracefile));
    reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
  }

  g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 4);

  if(reverse_byte_order == 0) return *(float *)(e->data + f->offset);
  else{
    void *ptr = e->data + f->offset;
    guint32 value = bswap_32(*(guint32*)ptr);
    return *(float*)&value;
  }
}

double ltt_event_get_double(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    g_assert(LTT_HAS_FLOAT(e->tracefile));
    reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
  }

  if(f->size == 4)
    return ltt_event_get_float(e, f);
    
  g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 8);

  if(reverse_byte_order == 0) return *(double *)(e->data + f->offset);
  else {
    void *ptr = e->data + f->offset;
    guint64 value = bswap_64(*(guint64*)ptr);
    return *(double*)&value;
  }
}
#endif

/*****************************************************************************
 * The string obtained is only valid until the next read from
 * the same tracefile.
 ****************************************************************************/
char *ltt_event_get_string(LttEvent *e, struct marker_field *f)
{
  g_assert(f->type == LTT_TYPE_STRING);

  return (gchar*)g_strdup((gchar*)(e->data + f->offset));
}
Commit	Line	Data
0bc7c2cd	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2007 Mathieu Desnoyers
	3	*
	4	* Complete rewrite from the original version made by XangXiu Yang.
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License Version 2.1 as published by the Free Software Foundation.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public
	16	* License along with this library; if not, write to the
	17	* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	18	* Boston, MA 02111-1307, USA.
	19	*/
	20
	21	#ifdef HAVE_CONFIG_H
	22	#include <config.h>
	23	#endif
	24
	25	#include <glib.h>
	26
	27	#include <ltt/event.h>
	28	#include <ltt/ltt-types.h>
	29	#include <ltt/ltt-private.h>
	30
	31	/*****************************************************************************
	32	*Function name
	33	* ltt_event_position_get : get the event position data
	34	*Input params
	35	* e : an instance of an event type
	36	* ep : a pointer to event's position structure
	37	* tf : tracefile pointer
	38	* block : current block
	39	* offset : current offset
	40	* tsc : current tsc
	41	****************************************************************************/
	42	void ltt_event_position_get(LttEventPosition ep, LttTracefile *tf,
	43	guint block, guint offset, guint64 *tsc)
	44	{
	45	*tf = ep->tracefile;
	46	*block = ep->block;
	47	*offset = ep->offset;
	48	*tsc = ep->tsc;
	49	}
	50
	51
	52	void ltt_event_position_set(LttEventPosition ep, LttTracefile tf,
	53	guint block, guint offset, guint64 tsc)
	54	{
	55	ep->tracefile = tf;
	56	ep->block = block;
	57	ep->offset = offset;
	58	ep->tsc = tsc;
	59	}
	60
	61
	62	/*****************************************************************************
	63	*Function name
	64	* ltt_event_position : get the event's position
65	*Input params
66	* e : an instance of an event type
67	* ep : a pointer to event's position structure
68	****************************************************************************/
69
70	void ltt_event_position(LttEvent e, LttEventPosition ep)
71	{
72	ep->tracefile = e->tracefile;
73	ep->block = e->block;
74	ep->offset = e->offset;
75	ep->tsc = e->tsc;
76	}
77
78	LttEventPosition * ltt_event_position_new()
79	{
80	return g_new(LttEventPosition, 1);
81	}
82
83
84	/*****************************************************************************
85	* Function name
86	* ltt_event_position_compare : compare two positions
87	* A NULL value is infinite.
88	* Input params
89	* ep1 : a pointer to event's position structure
90	* ep2 : a pointer to event's position structure
91	* Return
92	* -1 is ep1 < ep2
93	* 1 if ep1 > ep2
94	* 0 if ep1 == ep2
95	****************************************************************************/
96
97
98	gint ltt_event_position_compare(const LttEventPosition *ep1,
99	const LttEventPosition *ep2)
100	{
101	if(ep1 == NULL && ep2 == NULL)
102	return 0;
103	if(ep1 != NULL && ep2 == NULL)
104	return -1;
105	if(ep1 == NULL && ep2 != NULL)
106	return 1;
107
108	if(ep1->tracefile != ep2->tracefile)
109	g_error("ltt_event_position_compare on different tracefiles makes no sense");
110
111	if(ep1->block < ep2->block)
112	return -1;
113	if(ep1->block > ep2->block)
114	return 1;
115	if(ep1->offset < ep2->offset)
116	return -1;
117	if(ep1->offset > ep2->offset)
118	return 1;
119	return 0;
120	}
121
122	/*****************************************************************************
123	* Function name
124	* ltt_event_position_copy : copy position
125	* Input params
126	* src : a pointer to event's position structure source
127	* dest : a pointer to event's position structure dest
128	* Return
129	* void
130	****************************************************************************/
131	void ltt_event_position_copy(LttEventPosition *dest,
132	const LttEventPosition *src)
133	{
134	if(src == NULL)
135	dest = NULL;
136	else
137	dest = src;
138	}
139
140
141
142	LttTracefile ltt_event_position_tracefile(LttEventPosition ep)
143	{
144	return ep->tracefile;
145	}
146
147	/*****************************************************************************
148	* These functions extract data from an event after architecture specific
149	* conversions
150	****************************************************************************/
151	guint32 ltt_event_get_unsigned(LttEvent e, struct marker_field f)
152	{
153	gboolean reverse_byte_order;
154
155	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
156	reverse_byte_order = (g_ntohs(0x1) != 0x1);
157	} else {
158	reverse_byte_order = LTT_GET_BO(e->tracefile);
159	}
160
161	switch(f->size) {
162	case 1:
163	{
164	guint8 x = (guint8 )(e->data + f->offset);
165	return (guint32) x;
166	}
167	break;
168	case 2:
169	return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
170	break;
171	case 4:
172	return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
173	break;
174	case 8:
175	default:
176	g_critical("ltt_event_get_unsigned : field size %i unknown", f->size);
177	return 0;
178	break;
179	}
180	}
181
182	gint32 ltt_event_get_int(LttEvent e, struct marker_field f)
183	{
184	gboolean reverse_byte_order;
185	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
186	reverse_byte_order = (g_ntohs(0x1) != 0x1);
187	} else {
188	reverse_byte_order = LTT_GET_BO(e->tracefile);
189	}
190
191	switch(f->size) {
192	case 1:
193	{
194	gint8 x = (gint8 )(e->data + f->offset);
195	return (gint32) x;
196	}
197	break;
198	case 2:
199	return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset);
200	break;
201	case 4:
202	return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset);
203	break;
204	case 8:
205	default:
206	g_critical("ltt_event_get_int : field size %i unknown", f->size);
207	return 0;
208	break;
209	}
210	}
211
212	guint64 ltt_event_get_long_unsigned(LttEvent e, struct marker_field f)
213	{
214	gboolean reverse_byte_order;
215	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
216	reverse_byte_order = (g_ntohs(0x1) != 0x1);
217	} else {
218	reverse_byte_order = LTT_GET_BO(e->tracefile);
219	}
220
221	switch(f->size) {
222	case 1:
223	{
224	guint8 x = (guint8 )(e->data + f->offset);
225	return (guint64) x;
226	}
227	break;
228	case 2:
229	return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
230	break;
231	case 4:
232	return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
233	break;
234	case 8:
235	return ltt_get_uint64(reverse_byte_order, e->data + f->offset);
236	break;
237	default:
238	g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->size);
239	return 0;
240	break;
241	}
242	}
243
244	gint64 ltt_event_get_long_int(LttEvent e, struct marker_field f)
245	{
246	gboolean reverse_byte_order;
247	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
248	reverse_byte_order = (g_ntohs(0x1) != 0x1);
249	} else {
250	reverse_byte_order = LTT_GET_BO(e->tracefile);
251	}
252
253	switch(f->size) {
254	case 1:
255	{
256	gint8 x = (gint8 )(e->data + f->offset);
257	return (gint64) x;
258	}
259	break;
260	case 2:
261	return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset);
262	break;
263	case 4:
264	return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset);
265	break;
266	case 8:
267	return ltt_get_int64(reverse_byte_order, e->data + f->offset);
268	break;
269	default:
270	g_critical("ltt_event_get_long_int : field size %i unknown", f->size);
271	return 0;
272	break;
273	}
274	}
275
276	#if 0
277	float ltt_event_get_float(LttEvent e, struct marker_field f)
278	{
279	gboolean reverse_byte_order;
280	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
281	reverse_byte_order = (g_ntohs(0x1) != 0x1);
282	} else {
283	g_assert(LTT_HAS_FLOAT(e->tracefile));
284	reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
285	}
286
287	g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 4);
288
289	if(reverse_byte_order == 0) return (float )(e->data + f->offset);
290	else{
291	void *ptr = e->data + f->offset;
292	guint32 value = bswap_32((guint32)ptr);
293	return (float)&value;
294	}
295	}
296
297	double ltt_event_get_double(LttEvent e, struct marker_field f)
298	{
299	gboolean reverse_byte_order;
300	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
301	reverse_byte_order = (g_ntohs(0x1) != 0x1);
302	} else {
303	g_assert(LTT_HAS_FLOAT(e->tracefile));
304	reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
305	}
306
307	if(f->size == 4)
308	return ltt_event_get_float(e, f);
309
310	g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 8);
311
312	if(reverse_byte_order == 0) return (double )(e->data + f->offset);
313	else {
314	void *ptr = e->data + f->offset;
315	guint64 value = bswap_64((guint64)ptr);
316	return (double)&value;
317	}
318	}
319	#endif
320
321	/*****************************************************************************
322	* The string obtained is only valid until the next read from
323	* the same tracefile.
324	****************************************************************************/
325	char ltt_event_get_string(LttEvent e, struct marker_field *f)
326	{
327	g_assert(f->type == LTT_TYPE_STRING);
328
329	return (gchar)g_strdup((gchar)(e->data + f->offset));
330	}
331
332