projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
batchtest partially working
[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
4e4d11b3 19#ifdef HAVE_CONFIG_H
20#include <config.h>
21#endif
22
6cd62ccf 23#include <stdio.h>
8d1e6362 24#include <string.h>
25#include <stdlib.h>
3aee1200 26#include <glib.h>
8d1e6362 27
6cd62ccf 28#include <asm/types.h>
29#include <linux/byteorder/swab.h>
a5dcde2f 30
6cd62ccf 31#include "parser.h"
a5dcde2f 32#include <ltt/ltt.h>
33#include "ltt-private.h"
6cd62ccf 34#include <ltt/event.h>
a5dcde2f 35#include <ltt/trace.h>
0f7f40c1 36#include <ltt/ltt-types.h>
6cd62ccf 37
c02ea99f 38LttEvent *ltt_event_new()
39{
40 return g_new(LttEvent, 1);
41}
42
43void ltt_event_destroy(LttEvent *event)
44{
45 g_free(event);
46}
47
48
3aee1200 49#if 0
50/* Use get_field_type_size instead */
908f42fa 51/*****************************************************************************
52 *Function name
53 * ltt_event_refresh_fields : refresh fields of an event
54 *Input params
55 * offsetRoot : offset from the root
18206708 56 * offsetParent : offset from the parent
908f42fa 57 * fld : field
58 * evD : event data
0f7f40c1 59 * reverse_byte_order : 1 or 0
908f42fa 60 *Return value
61 * int : size of the field
62 ****************************************************************************/
63
64int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
0f7f40c1 65 LttField * fld, void *evD, gboolean reverse_byte_order)
908f42fa 66{
67 int size, size1, element_number, i, offset1, offset2;
68 LttType * type = fld->field_type;
69
cf74a6f1 70 switch(type->type_class) {
71 case LTT_ARRAY:
72 element_number = (int) type->element_number;
73 if(fld->field_fixed == 0){// has string or sequence
74 size = 0;
75 for(i=0;i<element_number;i++){
76 size += ltt_event_refresh_fields(offsetRoot+size,size,
0f7f40c1 77 fld->child[0], evD+size, reverse_byte_order);
cf74a6f1 78 }
79 }else size = fld->field_size;
80 break;
81
82 case LTT_SEQUENCE:
83 size1 = fld->sequ_number_size;
0f7f40c1 84 element_number = getIntNumber(reverse_byte_order,size1,evD);
cf74a6f1 85 type->element_number = element_number;
86 if(fld->element_size > 0){
87 size = element_number * fld->element_size;
88 }else{//sequence has string or sequence
89 size = 0;
90 for(i=0;i<element_number;i++){
91 size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
0f7f40c1 92 fld->child[0], evD+size+size1, reverse_byte_order);
cf74a6f1 93 }
94 size += size1;
95 }
96 break;
97
98 case LTT_STRING:
45e14832 99 size = strlen((gchar*)evD) + 1; //include end : '\0'
cf74a6f1 100 break;
101
102 case LTT_STRUCT:
103 element_number = (int) type->element_number;
104 if(fld->field_fixed == 0){
105 offset1 = offsetRoot;
106 offset2 = 0;
107 for(i=0;i<element_number;i++){
108 size=ltt_event_refresh_fields(offset1,offset2,
0f7f40c1 109 fld->child[i],evD+offset2, reverse_byte_order);
cf74a6f1 110 offset1 += size;
111 offset2 += size;
112 }
113 size = offset2;
114 }else size = fld->field_size;
115 break;
e52d9126 116
117 case LTT_UNION:
118 size = fld->field_size;
119 break;
cf74a6f1 120
121 default:
122 size = fld->field_size;
123 }
124
125#if 0
908f42fa 126 if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
127 type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
128 size = fld->field_size;
129 }else if(type->type_class == LTT_ARRAY){
130 element_number = (int) type->element_number;
131 if(fld->field_fixed == 0){// has string or sequence
132 size = 0;
133 for(i=0;i<element_number;i++){
cf74a6f1 134 size += ltt_event_refresh_fields(offsetRoot+size,size,
908f42fa 135 fld->child[0], evD+size);
cf74a6f1 136 }
908f42fa 137 }else size = fld->field_size;
138 }else if(type->type_class == LTT_SEQUENCE){
139 size1 = fld->sequ_number_size;
140 element_number = getIntNumber(size1,evD);
141 type->element_number = element_number;
142 if(fld->element_size > 0){
143 size = element_number * fld->element_size;
144 }else{//sequence has string or sequence
145 size = 0;
146 for(i=0;i<element_number;i++){
cf74a6f1 147 size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
148 fld->child[0], evD+size+size1);
908f42fa 149 }
150 size += size1;
151 }
152 }else if(type->type_class == LTT_STRING){
153 size = strlen((char*)evD) + 1; //include end : '\0'
154 }else if(type->type_class == LTT_STRUCT){
155 element_number = (int) type->element_number;
156 if(fld->field_fixed == 0){
157 offset1 = offsetRoot;
158 offset2 = 0;
159 for(i=0;i<element_number;i++){
cf74a6f1 160 size=ltt_event_refresh_fields(offset1,offset2,
161 fld->child[i],evD+offset2);
162 offset1 += size;
163 offset2 += size;
908f42fa 164 }
165 size = offset2;
166 }else size = fld->field_size;
167 }
cf74a6f1 168#endif //0
908f42fa 169 fld->offset_root = offsetRoot;
170 fld->offset_parent = offsetParent;
171 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
172 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
173 fld->field_size = size;
174
175 return size;
176}
3aee1200 177#endif //0
178
908f42fa 179
6cd62ccf 180/*****************************************************************************
181 *Function name
963b5f2d 182 * ltt_event_eventtype_id: get event type id
183 * (base id + position of the event)
6cd62ccf 184 *Input params
963b5f2d 185 * e : an instance of an event type
6cd62ccf 186 *Return value
963b5f2d 187 * unsigned : event type id
6cd62ccf 188 ****************************************************************************/
189
eed2ef37 190unsigned ltt_event_eventtype_id(const LttEvent *e)
6cd62ccf 191{
192 return (unsigned) e->event_id;
193}
194
195/*****************************************************************************
196 *Function name
197 * ltt_event_facility : get the facility of the event
198 *Input params
199 * e : an instance of an event type
200 *Return value
963b5f2d 201 * LttFacility * : the facility of the event
6cd62ccf 202 ****************************************************************************/
203
eed2ef37 204LttFacility *ltt_event_facility(const LttEvent *e)
6cd62ccf 205{
963b5f2d 206 LttTrace * trace = e->tracefile->trace;
27304273 207 unsigned id = e->facility_id;
208 LttFacility *facility = ltt_trace_facility_by_id(trace,id);
209
210 g_assert(facility->exists);
211
212 return facility;
6cd62ccf 213}
214
eed2ef37 215/*****************************************************************************
216 *Function name
217 * ltt_event_facility_id : get the facility id of the event
218 *Input params
219 * e : an instance of an event type
220 *Return value
221 * unsigned : the facility of the event
222 ****************************************************************************/
223
224unsigned ltt_event_facility_id(const LttEvent *e)
225{
226 return e->facility_id;
227}
228
6cd62ccf 229/*****************************************************************************
230 *Function name
231 * ltt_event_eventtype : get the event type of the event
232 *Input params
233 * e : an instance of an event type
234 *Return value
963b5f2d 235 * LttEventType * : the event type of the event
6cd62ccf 236 ****************************************************************************/
237
eed2ef37 238LttEventType *ltt_event_eventtype(const LttEvent *e)
6cd62ccf 239{
963b5f2d 240 LttFacility* facility = ltt_event_facility(e);
241 if(!facility) return NULL;
3aee1200 242 return &g_array_index(facility->events, LttEventType, e->event_id);
6cd62ccf 243}
244
245/*****************************************************************************
246 *Function name
963b5f2d 247 * ltt_event_field : get the root field of the event
6cd62ccf 248 *Input params
963b5f2d 249 * e : an instance of an event type
6cd62ccf 250 *Return value
963b5f2d 251 * LttField * : the root field of the event
6cd62ccf 252 ****************************************************************************/
253
963b5f2d 254LttField *ltt_event_field(LttEvent *e)
6cd62ccf 255{
908f42fa 256 LttField * field;
963b5f2d 257 LttEventType * event_type = ltt_event_eventtype(e);
1d1df11d 258 if(unlikely(!event_type)) return NULL;
908f42fa 259 field = event_type->root_field;
1d1df11d 260 if(unlikely(!field)) return NULL;
908f42fa 261
3aee1200 262 get_field_type_size(e->tracefile, event_type, 0, 0,
263 field, e->data);
264
908f42fa 265 return field;
6cd62ccf 266}
267
268/*****************************************************************************
269 *Function name
963b5f2d 270 * ltt_event_time : get the time of the event
6cd62ccf 271 *Input params
272 * e : an instance of an event type
273 *Return value
963b5f2d 274 * LttTime : the time of the event
6cd62ccf 275 ****************************************************************************/
276
eed2ef37 277LttTime ltt_event_time(const LttEvent *e)
6cd62ccf 278{
963b5f2d 279 return e->event_time;
6cd62ccf 280}
281
282/*****************************************************************************
283 *Function name
963b5f2d 284 * ltt_event_time : get the cycle count of the event
6cd62ccf 285 *Input params
286 * e : an instance of an event type
287 *Return value
963b5f2d 288 * LttCycleCount : the cycle count of the event
6cd62ccf 289 ****************************************************************************/
290
eed2ef37 291LttCycleCount ltt_event_cycle_count(const LttEvent *e)
6cd62ccf 292{
3aee1200 293 return e->tsc;
6cd62ccf 294}
295
eed2ef37 296
297
298/*****************************************************************************
299 *Function name
300 * ltt_event_position_get : get the event position data
301 *Input params
302 * e : an instance of an event type
303 * ep : a pointer to event's position structure
304 * tf : tracefile pointer
305 * block : current block
306 * offset : current offset
307 * tsc : current tsc
308 ****************************************************************************/
309void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf,
310 guint *block, guint *offset, guint64 *tsc)
311{
312 *tf = ep->tracefile;
313 *block = ep->block;
314 *offset = ep->offset;
315 *tsc = ep->tsc;
316}
317
318
80da81ad 319/*****************************************************************************
320 *Function name
321 * ltt_event_position : get the event's position
322 *Input params
323 * e : an instance of an event type
324 * ep : a pointer to event's position structure
325 ****************************************************************************/
326
327void ltt_event_position(LttEvent *e, LttEventPosition *ep)
328{
3aee1200 329 ep->tracefile = e->tracefile;
330 ep->block = e->block;
331 ep->offset = e->offset;
332 ep->tsc = e->tsc;
80da81ad 333}
334
a5dcde2f 335LttEventPosition * ltt_event_position_new()
336{
337 return g_new(LttEventPosition, 1);
338}
339
80da81ad 340
96da5c0d 341/*****************************************************************************
342 * Function name
343 * ltt_event_position_compare : compare two positions
a00149f6 344 * A NULL value is infinite.
96da5c0d 345 * Input params
346 * ep1 : a pointer to event's position structure
347 * ep2 : a pointer to event's position structure
348 * Return
349 * -1 is ep1 < ep2
350 * 1 if ep1 > ep2
351 * 0 if ep1 == ep2
352 ****************************************************************************/
353
354
355gint ltt_event_position_compare(const LttEventPosition *ep1,
356 const LttEventPosition *ep2)
357{
a00149f6 358 if(ep1 == NULL && ep2 == NULL)
359 return 0;
360 if(ep1 != NULL && ep2 == NULL)
361 return -1;
362 if(ep1 == NULL && ep2 != NULL)
363 return 1;
96da5c0d 364
3aee1200 365 if(ep1->tracefile != ep2->tracefile)
366 g_error("ltt_event_position_compare on different tracefiles makes no sense");
367
368 if(ep1->block < ep2->block)
96da5c0d 369 return -1;
3aee1200 370 if(ep1->block > ep2->block)
96da5c0d 371 return 1;
3aee1200 372 if(ep1->offset < ep2->offset)
96da5c0d 373 return -1;
3aee1200 374 if(ep1->offset > ep2->offset)
96da5c0d 375 return 1;
376 return 0;
377}
378
2a74fbf4 379/*****************************************************************************
380 * Function name
381 * ltt_event_position_copy : copy position
382 * Input params
383 * src : a pointer to event's position structure source
384 * dest : a pointer to event's position structure dest
385 * Return
386 * void
387 ****************************************************************************/
388void ltt_event_position_copy(LttEventPosition *dest,
389 const LttEventPosition *src)
390{
a00149f6 391 if(src == NULL)
392 dest = NULL;
393 else
394 *dest = *src;
2a74fbf4 395}
96da5c0d 396
397
27304273 398
399LttTracefile *ltt_event_position_tracefile(LttEventPosition *ep)
400{
401 return ep->tracefile;
402}
403
6cd62ccf 404/*****************************************************************************
405 *Function name
963b5f2d 406 * ltt_event_cpu_i: get the cpu id where the event happens
6cd62ccf 407 *Input params
408 * e : an instance of an event type
409 *Return value
963b5f2d 410 * unsigned : the cpu id
6cd62ccf 411 ****************************************************************************/
412
963b5f2d 413unsigned ltt_event_cpu_id(LttEvent *e)
3aee1200 414{
415 return e->tracefile->cpu_num;
6cd62ccf 416}
417
418/*****************************************************************************
419 *Function name
420 * ltt_event_data : get the raw data for the event
421 *Input params
422 * e : an instance of an event type
423 *Return value
424 * void * : pointer to the raw data for the event
425 ****************************************************************************/
426
963b5f2d 427void *ltt_event_data(LttEvent *e)
6cd62ccf 428{
429 return e->data;
430}
431
432/*****************************************************************************
433 *Function name
434 * ltt_event_field_element_number
435 * : The number of elements in a sequence field is specific
436 * to each event. This function returns the number of
437 * elements for an array or sequence field in an event.
438 *Input params
908f42fa 439 * e : an instance of an event type
6cd62ccf 440 * f : a field of the instance
441 *Return value
442 * unsigned : the number of elements for an array/sequence field
443 ****************************************************************************/
3aee1200 444guint64 ltt_event_field_element_number(LttEvent *e, LttField *f)
6cd62ccf 445{
446 if(f->field_type->type_class != LTT_ARRAY &&
447 f->field_type->type_class != LTT_SEQUENCE)
448 return 0;
908f42fa 449
450 if(f->field_type->type_class == LTT_ARRAY)
451 return f->field_type->element_number;
eed2ef37 452 return ltt_get_uint(LTT_GET_BO(e->tracefile), f->sequ_number_size,
3aee1200 453 e + f->offset_root);
6cd62ccf 454}
455
456/*****************************************************************************
457 *Function name
458 * ltt_event_field_element_select
459 * : Set the currently selected element for a sequence or
460 * array field
3aee1200 461 * O(1) if fields are of fixed size, else O(n) if fields are
462 * of variable size.
6cd62ccf 463 *Input params
908f42fa 464 * e : an instance of an event type
6cd62ccf 465 * f : a field of the instance
3aee1200 466 * i : the ith element (0, ...)
6cd62ccf 467 ****************************************************************************/
963b5f2d 468void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
6cd62ccf 469{
908f42fa 470 unsigned element_number;
3aee1200 471 LttField *field;
8d1e6362 472 unsigned int k;
3aee1200 473 size_t size;
474 LttEventType *event_type;
908f42fa 475
476 if(f->field_type->type_class != LTT_ARRAY &&
6cd62ccf 477 f->field_type->type_class != LTT_SEQUENCE)
908f42fa 478 return ;
479
480 element_number = ltt_event_field_element_number(e,f);
3aee1200 481 event_type = ltt_event_eventtype(e);
482 /* Sanity check for i : 0..n-1 only, and must be lower or equal element_number
8d1e6362 483 */
3aee1200 484 if(i >= element_number) return;
908f42fa 485
3aee1200 486 field = f->child[0];
487
488 if(f->field_type->type_class == LTT_SEQUENCE)
489 size = f->sequ_number_size;
490 else
491 size = 0;
908f42fa 492
3aee1200 493 if(field->fixed_size == FIELD_FIXED) {
494 size += field->field_size * i;
495
496 get_field_type_size(e->tracefile, event_type,
497 f->offset_root+size, size, field, e->data);
498
499 } else {
500 for(k=0;k<=i;k++){
501 size += get_field_type_size(e->tracefile, event_type,
502 f->offset_root+size, size, field, e->data);
503 }
908f42fa 504 }
3aee1200 505 f->current_element = i;
6cd62ccf 506}
507
508/*****************************************************************************
509 * These functions extract data from an event after architecture specific
510 * conversions
511 ****************************************************************************/
63c35f6c 512guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f)
6cd62ccf 513{
3aee1200 514 gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
0f7f40c1 515
963b5f2d 516 LttTypeEnum t = f->field_type->type_class;
6cd62ccf 517
2a74fbf4 518 g_assert(t == LTT_UINT || t == LTT_ENUM);
6cd62ccf 519
b7b36242 520 if(f->field_size == 1){
cbd41522 521 guint8 x = *(guint8 *)(e->data + f->offset_root);
63c35f6c 522 return (guint32) x;
b7b36242 523 }else if(f->field_size == 2){
0f7f40c1 524 return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
b7b36242 525 }else if(f->field_size == 4){
0f7f40c1 526 return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
63c35f6c 527 }
528#if 0
529 else if(f->field_size == 8){
cbd41522 530 guint64 x = *(guint64 *)(e->data + f->offset_root);
531 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
532 return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x);
533 else
534 return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x);
6cd62ccf 535 }
63c35f6c 536#endif //0
8d1e6362 537 g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size);
538 return 0;
6cd62ccf 539}
540
63c35f6c 541gint32 ltt_event_get_int(LttEvent *e, LttField *f)
6cd62ccf 542{
3aee1200 543 gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
6cd62ccf 544
2a74fbf4 545 g_assert(f->field_type->type_class == LTT_INT);
6cd62ccf 546
b7b36242 547 if(f->field_size == 1){
cbd41522 548 gint8 x = *(gint8 *)(e->data + f->offset_root);
63c35f6c 549 return (gint32) x;
b7b36242 550 }else if(f->field_size == 2){
0f7f40c1 551 return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
b7b36242 552 }else if(f->field_size == 4){
0f7f40c1 553 return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
63c35f6c 554 }
555#if 0
556 else if(f->field_size == 8){
cbd41522 557 gint64 x = *(gint64 *)(e->data + f->offset_root);
558 if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
559 return (int) (revFlag ? GINT64_FROM_BE(x): x);
560 else
561 return (int) (revFlag ? GINT64_FROM_LE(x): x);
6cd62ccf 562 }
63c35f6c 563#endif //0
8d1e6362 564 g_critical("ltt_event_get_int : field size %i unknown", f->field_size);
565 return 0;
6cd62ccf 566}
567
63c35f6c 568guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
6cd62ccf 569{
3aee1200 570 gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
571
963b5f2d 572 LttTypeEnum t = f->field_type->type_class;
6cd62ccf 573
2a74fbf4 574 g_assert(t == LTT_UINT || t == LTT_ENUM);
6cd62ccf 575
b7b36242 576 if(f->field_size == 1){
cbd41522 577 guint8 x = *(guint8 *)(e->data + f->offset_root);
63c35f6c 578 return (guint64) x;
b7b36242 579 }else if(f->field_size == 2){
0f7f40c1 580 return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
b7b36242 581 }else if(f->field_size == 4){
0f7f40c1 582 return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
b7b36242 583 }else if(f->field_size == 8){
0f7f40c1 584 return ltt_get_uint64(reverse_byte_order, e->data + f->offset_root);
6cd62ccf 585 }
8d1e6362 586 g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size);
587 return 0;
6cd62ccf 588}
589
63c35f6c 590gint64 ltt_event_get_long_int(LttEvent *e, LttField *f)
6cd62ccf 591{
0f7f40c1 592 //int revFlag = e->tracefile->trace->my_arch_endian ==
593 // e->tracefile->trace->system_description->endian ? 0:1;
3aee1200 594 gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
6cd62ccf 595
2a74fbf4 596 g_assert( f->field_type->type_class == LTT_INT);
6cd62ccf 597
b7b36242 598 if(f->field_size == 1){
cbd41522 599 gint8 x = *(gint8 *)(e->data + f->offset_root);
63c35f6c 600 return (gint64) x;
b7b36242 601 }else if(f->field_size == 2){
0f7f40c1 602 return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
b7b36242 603 }else if(f->field_size == 4){
0f7f40c1 604 return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
b7b36242 605 }else if(f->field_size == 8){
0f7f40c1 606 return ltt_get_int64(reverse_byte_order, e->data + f->offset_root);
6cd62ccf 607 }
8d1e6362 608 g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size);
609 return 0;
6cd62ccf 610}
611
963b5f2d 612float ltt_event_get_float(LttEvent *e, LttField *f)
6cd62ccf 613{
3aee1200 614 gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
6cd62ccf 615
2a74fbf4 616 g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4);
6cd62ccf 617
0f7f40c1 618 if(reverse_byte_order == 0) return *(float *)(e->data + f->offset_root);
6cd62ccf 619 else{
cbd41522 620 guint32 aInt;
6cd62ccf 621 memcpy((void*)&aInt, e->data + f->offset_root, 4);
622 aInt = ___swab32(aInt);
cf74a6f1 623 return ((float)aInt);
6cd62ccf 624 }
625}
626
963b5f2d 627double ltt_event_get_double(LttEvent *e, LttField *f)
6cd62ccf 628{
3aee1200 629 gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
6cd62ccf 630
2a74fbf4 631 g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8);
6cd62ccf 632
0f7f40c1 633 if(reverse_byte_order == 0) return *(double *)(e->data + f->offset_root);
6cd62ccf 634 else{
cbd41522 635 guint64 aInt;
6cd62ccf 636 memcpy((void*)&aInt, e->data + f->offset_root, 8);
637 aInt = ___swab64(aInt);
cf74a6f1 638 return ((double)aInt);
6cd62ccf 639 }
640}
641
642/*****************************************************************************
643 * The string obtained is only valid until the next read from
908f42fa 644 * the same tracefile.
6cd62ccf 645 ****************************************************************************/
963b5f2d 646char *ltt_event_get_string(LttEvent *e, LttField *f)
6cd62ccf 647{
2a74fbf4 648 g_assert(f->field_type->type_class == LTT_STRING);
649
45e14832 650 return (gchar*)g_strdup((gchar*)(e->data + f->offset_root));
6cd62ccf 651}
eed2ef37 652
653
654/*****************************************************************************
655 *Function name
656 * get_field_type_size : set the fixed and dynamic sizes of the field type
657 * from the data read.
658 *Input params
659 * tf : tracefile
660 * event_type : event type
661 * offset_root : offset from the root
662 * offset_parent : offset from the parent
663 * field : field
664 * data : a pointer to the event data.
665 *Returns the field type size.
666 ****************************************************************************/
667size_t get_field_type_size(LttTracefile *tf, LttEventType *event_type,
668 off_t offset_root, off_t offset_parent,
669 LttField *field, void *data)
670{
671 size_t size = 0;
672 guint i;
673 LttType *type;
674
675 g_assert(field->fixed_root != FIELD_UNKNOWN);
676 g_assert(field->fixed_parent != FIELD_UNKNOWN);
677 g_assert(field->fixed_size != FIELD_UNKNOWN);
678
679 field->offset_root = offset_root;
680 field->offset_parent = offset_parent;
681
682 type = field->field_type;
683
684 switch(type->type_class) {
685 case LTT_INT:
686 case LTT_UINT:
687 case LTT_FLOAT:
688 case LTT_ENUM:
689 case LTT_POINTER:
690 case LTT_LONG:
691 case LTT_ULONG:
692 case LTT_SIZE_T:
693 case LTT_SSIZE_T:
694 case LTT_OFF_T:
695 g_assert(field->fixed_size == FIELD_FIXED);
696 size = field->field_size;
697 break;
698 case LTT_SEQUENCE:
699 {
700 gint seqnum = ltt_get_uint(LTT_GET_BO(tf),
701 field->sequ_number_size,
702 data + offset_root);
703
704 if(field->child[0]->fixed_size == FIELD_FIXED) {
705 size = field->sequ_number_size +
706 (seqnum * get_field_type_size(tf, event_type,
707 offset_root, offset_parent,
708 field->child[0], data));
709 } else {
710 size += field->sequ_number_size;
711 for(i=0;i<seqnum;i++) {
712 size_t child_size;
713 child_size = get_field_type_size(tf, event_type,
714 offset_root, offset_parent,
715 field->child[0], data);
716 offset_root += child_size;
717 offset_parent += child_size;
718 size += child_size;
719 }
720 }
721 field->field_size = size;
722 }
723 break;
724 case LTT_STRING:
725 size = strlen((char*)(data+offset_root)) + 1;// length + \0
726 field->field_size = size;
727 break;
728 case LTT_ARRAY:
729 if(field->fixed_size == FIELD_FIXED)
730 size = field->field_size;
731 else {
732 for(i=0;i<field->field_type->element_number;i++) {
733 size_t child_size;
734 child_size = get_field_type_size(tf, event_type,
735 offset_root, offset_parent,
736 field->child[0], data);
737 offset_root += child_size;
738 offset_parent += child_size;
739 size += child_size;
740 }
741 field->field_size = size;
742 }
743 break;
744 case LTT_STRUCT:
745 if(field->fixed_size == FIELD_FIXED)
746 size = field->field_size;
747 else {
748 size_t current_root_offset = offset_root;
749 size_t current_offset = 0;
750 size_t child_size = 0;
751 for(i=0;i<type->element_number;i++) {
752 child_size = get_field_type_size(tf,
753 event_type, current_root_offset, current_offset,
754 field->child[i], data);
755 current_offset += child_size;
756 current_root_offset += child_size;
757
758 }
759 size = current_offset;
760 field->field_size = size;
761 }
762 break;
763 case LTT_UNION:
764 if(field->fixed_size == FIELD_FIXED)
765 size = field->field_size;
766 else {
767 size_t current_root_offset = field->offset_root;
768 size_t current_offset = 0;
769 for(i=0;i<type->element_number;i++) {
770 size = get_field_type_size(tf, event_type,
771 current_root_offset, current_offset,
772 field->child[i], data);
773 size = max(size, field->child[i]->field_size);
774 }
775 field->field_size = size;
776 }
777 break;
778 }
779
780 return size;
781}
782
783
LTTng 2.x Viewer (LTTV)
This page took 0.070359 seconds and 4 git commands to generate.