projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
compilation warning fixes, types for cycle counter corrected
[lttv.git] / ltt / branches / poly / ltt / event.c
CommitLineData
449cb9d7 1/* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Xiangxiu Yang
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
6cd62ccf 19#include <stdio.h>
20#include <asm/types.h>
21#include <linux/byteorder/swab.h>
a5dcde2f 22
6cd62ccf 23#include "parser.h"
a5dcde2f 24#include <ltt/ltt.h>
25#include "ltt-private.h"
6cd62ccf 26#include <ltt/event.h>
a5dcde2f 27#include <ltt/trace.h>
6cd62ccf 28
c02ea99f 29
30LttEvent *ltt_event_new()
31{
32 return g_new(LttEvent, 1);
33}
34
35void ltt_event_destroy(LttEvent *event)
36{
37 g_free(event);
38}
39
40
908f42fa 41/*****************************************************************************
42 *Function name
43 * ltt_event_refresh_fields : refresh fields of an event
44 *Input params
45 * offsetRoot : offset from the root
18206708 46 * offsetParent : offset from the parent
908f42fa 47 * fld : field
48 * evD : event data
49 *Return value
50 * int : size of the field
51 ****************************************************************************/
52
53int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
54 LttField * fld, void *evD)
55{
56 int size, size1, element_number, i, offset1, offset2;
57 LttType * type = fld->field_type;
58
59 if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
60 type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
61 size = fld->field_size;
62 }else if(type->type_class == LTT_ARRAY){
63 element_number = (int) type->element_number;
64 if(fld->field_fixed == 0){// has string or sequence
65 size = 0;
66 for(i=0;i<element_number;i++){
67 size += ltt_event_refresh_fields(offsetRoot+size,size,
68 fld->child[0], evD+size);
69 }
70 }else size = fld->field_size;
71 }else if(type->type_class == LTT_SEQUENCE){
72 size1 = fld->sequ_number_size;
73 element_number = getIntNumber(size1,evD);
74 type->element_number = element_number;
75 if(fld->element_size > 0){
76 size = element_number * fld->element_size;
77 }else{//sequence has string or sequence
78 size = 0;
79 for(i=0;i<element_number;i++){
80 size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
81 fld->child[0], evD+size+size1);
82 }
83 size += size1;
84 }
85 }else if(type->type_class == LTT_STRING){
86 size = strlen((char*)evD) + 1; //include end : '\0'
87 }else if(type->type_class == LTT_STRUCT){
88 element_number = (int) type->element_number;
89 if(fld->field_fixed == 0){
90 offset1 = offsetRoot;
91 offset2 = 0;
92 for(i=0;i<element_number;i++){
93 size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2);
94 offset1 += size;
95 offset2 += size;
96 }
97 size = offset2;
98 }else size = fld->field_size;
99 }
100
101 fld->offset_root = offsetRoot;
102 fld->offset_parent = offsetParent;
103 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
104 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
105 fld->field_size = size;
106
107 return size;
108}
109
6cd62ccf 110/*****************************************************************************
111 *Function name
963b5f2d 112 * ltt_event_eventtype_id: get event type id
113 * (base id + position of the event)
6cd62ccf 114 *Input params
963b5f2d 115 * e : an instance of an event type
6cd62ccf 116 *Return value
963b5f2d 117 * unsigned : event type id
6cd62ccf 118 ****************************************************************************/
119
963b5f2d 120unsigned ltt_event_eventtype_id(LttEvent *e)
6cd62ccf 121{
122 return (unsigned) e->event_id;
123}
124
125/*****************************************************************************
126 *Function name
127 * ltt_event_facility : get the facility of the event
128 *Input params
129 * e : an instance of an event type
130 *Return value
963b5f2d 131 * LttFacility * : the facility of the event
6cd62ccf 132 ****************************************************************************/
133
963b5f2d 134LttFacility *ltt_event_facility(LttEvent *e)
6cd62ccf 135{
963b5f2d 136 LttTrace * trace = e->tracefile->trace;
137 unsigned id = e->event_id;
138 return ltt_trace_facility_by_id(trace,id);
6cd62ccf 139}
140
141/*****************************************************************************
142 *Function name
143 * ltt_event_eventtype : get the event type of the event
144 *Input params
145 * e : an instance of an event type
146 *Return value
963b5f2d 147 * LttEventType * : the event type of the event
6cd62ccf 148 ****************************************************************************/
149
963b5f2d 150LttEventType *ltt_event_eventtype(LttEvent *e)
6cd62ccf 151{
963b5f2d 152 LttFacility* facility = ltt_event_facility(e);
153 if(!facility) return NULL;
154 return facility->events[e->event_id - facility->base_id];
6cd62ccf 155}
156
157/*****************************************************************************
158 *Function name
963b5f2d 159 * ltt_event_field : get the root field of the event
6cd62ccf 160 *Input params
963b5f2d 161 * e : an instance of an event type
6cd62ccf 162 *Return value
963b5f2d 163 * LttField * : the root field of the event
6cd62ccf 164 ****************************************************************************/
165
963b5f2d 166LttField *ltt_event_field(LttEvent *e)
6cd62ccf 167{
908f42fa 168 LttField * field;
963b5f2d 169 LttEventType * event_type = ltt_event_eventtype(e);
170 if(!event_type) return NULL;
908f42fa 171 field = event_type->root_field;
a2331fa0 172 if(!field) return NULL;
908f42fa 173
174 //check if the field need refresh
175 if(e->which_block != event_type->latest_block ||
176 e->which_event != event_type->latest_event){
177
178 event_type->latest_block = e->which_block;
179 event_type->latest_event = e->which_event;
180
181 if(field->field_fixed == 1)return field;
182
183 //refresh the field
184 ltt_event_refresh_fields(0, 0, field, e->data);
185 }
186 return field;
6cd62ccf 187}
188
189/*****************************************************************************
190 *Function name
963b5f2d 191 * ltt_event_time : get the time of the event
6cd62ccf 192 *Input params
193 * e : an instance of an event type
194 *Return value
963b5f2d 195 * LttTime : the time of the event
6cd62ccf 196 ****************************************************************************/
197
963b5f2d 198LttTime ltt_event_time(LttEvent *e)
6cd62ccf 199{
963b5f2d 200 return e->event_time;
6cd62ccf 201}
202
203/*****************************************************************************
204 *Function name
963b5f2d 205 * ltt_event_time : get the cycle count of the event
6cd62ccf 206 *Input params
207 * e : an instance of an event type
208 *Return value
963b5f2d 209 * LttCycleCount : the cycle count of the event
6cd62ccf 210 ****************************************************************************/
211
963b5f2d 212LttCycleCount ltt_event_cycle_count(LttEvent *e)
6cd62ccf 213{
963b5f2d 214 return e->event_cycle_count;
6cd62ccf 215}
216
80da81ad 217/*****************************************************************************
218 *Function name
219 * ltt_event_position : get the event's position
220 *Input params
221 * e : an instance of an event type
222 * ep : a pointer to event's position structure
223 ****************************************************************************/
224
225void ltt_event_position(LttEvent *e, LttEventPosition *ep)
226{
227 ep->block_num = e->which_block;
228 ep->event_num = e->which_event;
229 ep->event_time = e->event_time;
230 ep->event_cycle_count = e->event_cycle_count;
231 ep->heart_beat_number = e->tracefile->cur_heart_beat_number;
18206708 232 ep->old_position = TRUE;
80da81ad 233 ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
e4eced0f 234 ep->tf = e->tracefile;
18206708 235
236 /* This is a workaround for fast position seek */
237 ep->last_event_pos = e->last_event_pos;
238 ep->prev_block_end_time = e->prev_block_end_time;
239 ep->prev_event_time = e->prev_event_time;
240 ep->pre_cycle_count = e->pre_cycle_count;
241 ep->count = e->count;
242 /* end of workaround */
80da81ad 243}
244
a5dcde2f 245LttEventPosition * ltt_event_position_new()
246{
247 return g_new(LttEventPosition, 1);
248}
249
80da81ad 250/*****************************************************************************
251 *Function name
252 * ltt_event_position_get : get the block number and index of the event
253 *Input params
254 * ep : a pointer to event's position structure
255 * block_number : the block number of the event
256 * index_in_block : the index of the event within the block
257 ****************************************************************************/
258
259void ltt_event_position_get(LttEventPosition *ep,
e4eced0f 260 unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf)
80da81ad 261{
262 *block_number = ep->block_num;
263 *index_in_block = ep->event_num;
e4eced0f 264 *tf = ep->tf;
80da81ad 265}
266
267/*****************************************************************************
268 *Function name
269 * ltt_event_position_set : set the block number and index of the event
537b2d7f 270 * It does put the old_position gboolean to FALSE, as it is impossible
271 * to know the quick position to seek in the tracefile.
80da81ad 272 *Input params
273 * ep : a pointer to event's position structure
274 * block_number : the block number of the event
275 * index_in_block : the index of the event within the block
276 ****************************************************************************/
277
278void ltt_event_position_set(LttEventPosition *ep,
279 unsigned block_number, unsigned index_in_block)
280{
537b2d7f 281 if(ep->block_num != block_number || ep->event_num != index_in_block)
282 ep->old_position = FALSE;
283
80da81ad 284 ep->block_num = block_number;
537b2d7f 285 ep->event_num = index_in_block;
286
80da81ad 287}
288
96da5c0d 289/*****************************************************************************
290 * Function name
291 * ltt_event_position_compare : compare two positions
a00149f6 292 * A NULL value is infinite.
96da5c0d 293 * Input params
294 * ep1 : a pointer to event's position structure
295 * ep2 : a pointer to event's position structure
296 * Return
297 * -1 is ep1 < ep2
298 * 1 if ep1 > ep2
299 * 0 if ep1 == ep2
300 ****************************************************************************/
301
302
303gint ltt_event_position_compare(const LttEventPosition *ep1,
304 const LttEventPosition *ep2)
305{
306 if(ep1->tf != ep2->tf)
307 g_error("ltt_event_position_compare on different tracefiles makes no sense");
a00149f6 308 if(ep1 == NULL && ep2 == NULL)
309 return 0;
310 if(ep1 != NULL && ep2 == NULL)
311 return -1;
312 if(ep1 == NULL && ep2 != NULL)
313 return 1;
314
96da5c0d 315 if(ep1->block_num < ep2->block_num)
316 return -1;
317 if(ep1->block_num > ep2->block_num)
318 return 1;
319 if(ep1->event_num < ep2->event_num)
320 return -1;
321 if(ep1->event_num > ep2->event_num)
322 return 1;
323 return 0;
324}
325
326/*****************************************************************************
327 * Function name
328 * ltt_event_event_position_compare : compare two positions, one in event,
329 * other in position opaque structure.
330 * Input params
331 * event : a pointer to event structure
332 * ep : a pointer to event's position structure
333 * Return
334 * -1 is event < ep
335 * 1 if event > ep
336 * 0 if event == ep
337 ****************************************************************************/
338
339gint ltt_event_event_position_compare(const LttEvent *event,
340 const LttEventPosition *ep)
341{
a00149f6 342 if(event == NULL && ep == NULL)
343 return 0;
344 if(event != NULL && ep == NULL)
345 return -1;
346 if(event == NULL && ep != NULL)
347 return 1;
2a74fbf4 348
a00149f6 349 g_assert(event->tracefile == ep->tf);
350
0dfebcb9 351 if(event->which_block < ep->block_num)
96da5c0d 352 return -1;
0dfebcb9 353 if(event->which_block > ep->block_num)
96da5c0d 354 return 1;
0dfebcb9 355 if(event->which_event < ep->event_num)
96da5c0d 356 return -1;
0dfebcb9 357 if(event->which_event > ep->event_num)
96da5c0d 358 return 1;
359 return 0;
360}
361
2a74fbf4 362/*****************************************************************************
363 * Function name
364 * ltt_event_position_copy : copy position
365 * Input params
366 * src : a pointer to event's position structure source
367 * dest : a pointer to event's position structure dest
368 * Return
369 * void
370 ****************************************************************************/
371void ltt_event_position_copy(LttEventPosition *dest,
372 const LttEventPosition *src)
373{
a00149f6 374 if(src == NULL)
375 dest = NULL;
376 else
377 *dest = *src;
2a74fbf4 378}
96da5c0d 379
380
6cd62ccf 381/*****************************************************************************
382 *Function name
963b5f2d 383 * ltt_event_cpu_i: get the cpu id where the event happens
6cd62ccf 384 *Input params
385 * e : an instance of an event type
386 *Return value
963b5f2d 387 * unsigned : the cpu id
6cd62ccf 388 ****************************************************************************/
389
963b5f2d 390unsigned ltt_event_cpu_id(LttEvent *e)
dd691a2e 391{
392 char * c1, * c2, * c3;
393 c1 = strrchr(e->tracefile->name,'\\');
394 c2 = strrchr(e->tracefile->name,'/');
395 if(c1 == NULL && c2 == NULL){
396 return (unsigned)atoi(e->tracefile->name);
397 }else if(c1 == NULL){
398 c2++;
399 return (unsigned)atoi(c2);
400 }else if(c2 == NULL){
401 c1++;
402 return (unsigned)atoi(c1);
403 }else{
404 c3 = (c1 > c2) ? c1 : c2;
405 c3++;
406 return (unsigned)atoi(c3);
407 }
6cd62ccf 408}
409
410/*****************************************************************************
411 *Function name
412 * ltt_event_data : get the raw data for the event
413 *Input params
414 * e : an instance of an event type
415 *Return value
416 * void * : pointer to the raw data for the event
417 ****************************************************************************/
418
963b5f2d 419void *ltt_event_data(LttEvent *e)
6cd62ccf 420{
421 return e->data;
422}
423
424/*****************************************************************************
425 *Function name
426 * ltt_event_field_element_number
427 * : The number of elements in a sequence field is specific
428 * to each event. This function returns the number of
429 * elements for an array or sequence field in an event.
430 *Input params
908f42fa 431 * e : an instance of an event type
6cd62ccf 432 * f : a field of the instance
433 *Return value
434 * unsigned : the number of elements for an array/sequence field
435 ****************************************************************************/
436
963b5f2d 437unsigned ltt_event_field_element_number(LttEvent *e, LttField *f)
6cd62ccf 438{
439 if(f->field_type->type_class != LTT_ARRAY &&
440 f->field_type->type_class != LTT_SEQUENCE)
441 return 0;
908f42fa 442
443 if(f->field_type->type_class == LTT_ARRAY)
444 return f->field_type->element_number;
445 return (unsigned) getIntNumber(f->sequ_number_size, e + f->offset_root);
6cd62ccf 446}
447
448/*****************************************************************************
449 *Function name
450 * ltt_event_field_element_select
451 * : Set the currently selected element for a sequence or
452 * array field
453 *Input params
908f42fa 454 * e : an instance of an event type
6cd62ccf 455 * f : a field of the instance
456 * i : the ith element
6cd62ccf 457 ****************************************************************************/
458
963b5f2d 459void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
6cd62ccf 460{
908f42fa 461 unsigned element_number;
462 LttField *fld;
463 int k, size;
464 void *evD;
465
466 if(f->field_type->type_class != LTT_ARRAY &&
6cd62ccf 467 f->field_type->type_class != LTT_SEQUENCE)
908f42fa 468 return ;
469
470 element_number = ltt_event_field_element_number(e,f);
89d4760c 471 if((element_number-1) < i || i < 0) return;
908f42fa 472
473 fld = f->child[0];
474
475 evD = e->data + f->offset_root;
476 size = 0;
477 for(k=0;k<i;k++){
478 size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
479 }
6cd62ccf 480
908f42fa 481 f->current_element = i - 1;
6cd62ccf 482}
483
484/*****************************************************************************
485 * These functions extract data from an event after architecture specific
486 * conversions
487 ****************************************************************************/
488
963b5f2d 489unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
6cd62ccf 490{
963b5f2d 491 int revFlag = e->tracefile->trace->my_arch_endian ==
492 e->tracefile->trace->system_description->endian ? 0:1;
493 LttTypeEnum t = f->field_type->type_class;
6cd62ccf 494
2a74fbf4 495 g_assert(t == LTT_UINT || t == LTT_ENUM);
6cd62ccf 496
b7b36242 497 if(f->field_size == 1){
cbd41522 498 guint8 x = *(guint8 *)(e->data + f->offset_root);
b7b36242 499 return (unsigned int) x;
500 }else if(f->field_size == 2){
cbd41522 501 guint16 x = *(guint16 *)(e->data + f->offset_root);
502 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
503 return (unsigned int) (revFlag ? GUINT16_FROM_BE(x): x);
504 else
505 return (unsigned int) (revFlag ? GUINT16_FROM_LE(x): x);
b7b36242 506 }else if(f->field_size == 4){
cbd41522 507 guint32 x = *(guint32 *)(e->data + f->offset_root);
508 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
509 return (unsigned int) (revFlag ? GUINT32_FROM_BE(x): x);
510 else
511 return (unsigned int) (revFlag ? GUINT32_FROM_LE(x): x);
b7b36242 512 }else if(f->field_size == 8){
cbd41522 513 guint64 x = *(guint64 *)(e->data + f->offset_root);
514 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
515 return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x);
516 else
517 return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x);
6cd62ccf 518 }
519}
520
963b5f2d 521int ltt_event_get_int(LttEvent *e, LttField *f)
6cd62ccf 522{
963b5f2d 523 int revFlag = e->tracefile->trace->my_arch_endian ==
524 e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf 525
2a74fbf4 526 g_assert(f->field_type->type_class == LTT_INT);
6cd62ccf 527
b7b36242 528 if(f->field_size == 1){
cbd41522 529 gint8 x = *(gint8 *)(e->data + f->offset_root);
b7b36242 530 return (int) x;
531 }else if(f->field_size == 2){
cbd41522 532 gint16 x = *(gint16 *)(e->data + f->offset_root);
533 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
534 return (int) (revFlag ? GINT16_FROM_BE(x): x);
535 else
536 return (int) (revFlag ? GINT16_FROM_LE(x): x);
b7b36242 537 }else if(f->field_size == 4){
cbd41522 538 gint32 x = *(gint32 *)(e->data + f->offset_root);
539 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
540 return (int) (revFlag ? GINT32_FROM_BE(x): x);
541 else
542 return (int) (revFlag ? GINT32_FROM_LE(x): x);
b7b36242 543 }else if(f->field_size == 8){
cbd41522 544 gint64 x = *(gint64 *)(e->data + f->offset_root);
545 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
546 return (int) (revFlag ? GINT64_FROM_BE(x): x);
547 else
548 return (int) (revFlag ? GINT64_FROM_LE(x): x);
6cd62ccf 549 }
550}
551
963b5f2d 552unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
6cd62ccf 553{
963b5f2d 554 int revFlag = e->tracefile->trace->my_arch_endian ==
555 e->tracefile->trace->system_description->endian ? 0:1;
556 LttTypeEnum t = f->field_type->type_class;
6cd62ccf 557
2a74fbf4 558 g_assert(t == LTT_UINT || t == LTT_ENUM);
6cd62ccf 559
b7b36242 560 if(f->field_size == 1){
cbd41522 561 guint8 x = *(guint8 *)(e->data + f->offset_root);
b7b36242 562 return (unsigned long) x;
563 }else if(f->field_size == 2){
cbd41522 564 guint16 x = *(guint16 *)(e->data + f->offset_root);
565 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
566 return (unsigned long) (revFlag ? GUINT16_FROM_BE(x): x);
567 else
568 return (unsigned long) (revFlag ? GUINT16_FROM_LE(x): x);
b7b36242 569 }else if(f->field_size == 4){
cbd41522 570 guint32 x = *(guint32 *)(e->data + f->offset_root);
571 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
572 return (unsigned long) (revFlag ? GUINT32_FROM_BE(x): x);
573 else
574 return (unsigned long) (revFlag ? GUINT32_FROM_LE(x): x);
b7b36242 575 }else if(f->field_size == 8){
cbd41522 576 guint64 x = *(guint64 *)(e->data + f->offset_root);
577 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
578 return (unsigned long) (revFlag ? GUINT64_FROM_BE(x): x);
579 else
580 return (unsigned long) (revFlag ? GUINT64_FROM_LE(x): x);
6cd62ccf 581 }
582}
583
963b5f2d 584long int ltt_event_get_long_int(LttEvent *e, LttField *f)
6cd62ccf 585{
963b5f2d 586 int revFlag = e->tracefile->trace->my_arch_endian ==
587 e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf 588
2a74fbf4 589 g_assert( f->field_type->type_class == LTT_INT);
6cd62ccf 590
b7b36242 591 if(f->field_size == 1){
cbd41522 592 gint8 x = *(gint8 *)(e->data + f->offset_root);
b7b36242 593 return (long) x;
594 }else if(f->field_size == 2){
cbd41522 595 gint16 x = *(gint16 *)(e->data + f->offset_root);
596 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
597 return (long) (revFlag ? GINT16_FROM_BE(x): x);
598 else
599 return (long) (revFlag ? GINT16_FROM_LE(x): x);
b7b36242 600 }else if(f->field_size == 4){
cbd41522 601 gint32 x = *(gint32 *)(e->data + f->offset_root);
602 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
603 return (long) (revFlag ? GINT32_FROM_BE(x): x);
604 else
605 return (long) (revFlag ? GINT32_FROM_LE(x): x);
b7b36242 606 }else if(f->field_size == 8){
cbd41522 607 gint64 x = *(gint64 *)(e->data + f->offset_root);
608 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
609 return (long) (revFlag ? GINT64_FROM_BE(x): x);
610 else
611 return (long) (revFlag ? GINT64_FROM_LE(x): x);
6cd62ccf 612 }
613}
614
963b5f2d 615float ltt_event_get_float(LttEvent *e, LttField *f)
6cd62ccf 616{
963b5f2d 617 int revFlag = e->tracefile->trace->my_arch_endian ==
618 e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf 619
2a74fbf4 620 g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4);
6cd62ccf 621
622 if(revFlag == 0) return *(float *)(e->data + f->offset_root);
623 else{
cbd41522 624 guint32 aInt;
6cd62ccf 625 memcpy((void*)&aInt, e->data + f->offset_root, 4);
626 aInt = ___swab32(aInt);
627 return *((float*)&aInt);
628 }
629}
630
963b5f2d 631double ltt_event_get_double(LttEvent *e, LttField *f)
6cd62ccf 632{
963b5f2d 633 int revFlag = e->tracefile->trace->my_arch_endian ==
634 e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf 635
2a74fbf4 636 g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8);
6cd62ccf 637
638 if(revFlag == 0) return *(double *)(e->data + f->offset_root);
639 else{
cbd41522 640 guint64 aInt;
6cd62ccf 641 memcpy((void*)&aInt, e->data + f->offset_root, 8);
642 aInt = ___swab64(aInt);
643 return *((double *)&aInt);
644 }
645}
646
647/*****************************************************************************
648 * The string obtained is only valid until the next read from
908f42fa 649 * the same tracefile.
6cd62ccf 650 ****************************************************************************/
651
963b5f2d 652char *ltt_event_get_string(LttEvent *e, LttField *f)
6cd62ccf 653{
2a74fbf4 654 g_assert(f->field_type->type_class == LTT_STRING);
655
6cd62ccf 656 return (char*)g_strdup((char*)(e->data + f->offset_root));
657}
LTTng 2.x Viewer (LTTV)
This page took 0.056272 seconds and 4 git commands to generate.