54ecbf38 |
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 | |
19 | #ifdef HAVE_CONFIG_H |
20 | #include <config.h> |
21 | #endif |
22 | |
23 | #include <stdio.h> |
24 | #include <string.h> |
25 | #include <stdlib.h> |
26 | |
27 | #include <asm/types.h> |
28 | #include <linux/byteorder/swab.h> |
29 | |
30 | #include "parser.h" |
31 | #include <ltt/ltt.h> |
32 | #include "ltt-private.h" |
33 | #include <ltt/event.h> |
34 | #include <ltt/trace.h> |
35 | #include <ltt/ltt-types.h> |
36 | |
37 | |
38 | LttEvent *ltt_event_new() |
39 | { |
40 | return g_new(LttEvent, 1); |
41 | } |
42 | |
43 | void ltt_event_destroy(LttEvent *event) |
44 | { |
45 | g_free(event); |
46 | } |
47 | |
48 | |
b59cd2f8 |
49 | #if 0 |
50 | /* Use get_field_type_size instead */ |
54ecbf38 |
51 | /***************************************************************************** |
52 | *Function name |
53 | * ltt_event_refresh_fields : refresh fields of an event |
54 | *Input params |
55 | * offsetRoot : offset from the root |
56 | * offsetParent : offset from the parent |
57 | * fld : field |
58 | * evD : event data |
59 | * reverse_byte_order : 1 or 0 |
60 | *Return value |
61 | * int : size of the field |
62 | ****************************************************************************/ |
63 | |
64 | int ltt_event_refresh_fields(int offsetRoot,int offsetParent, |
65 | LttField * fld, void *evD, gboolean reverse_byte_order) |
66 | { |
67 | int size, size1, element_number, i, offset1, offset2; |
68 | LttType * type = fld->field_type; |
69 | |
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, |
77 | fld->child[0], evD+size, reverse_byte_order); |
78 | } |
79 | }else size = fld->field_size; |
80 | break; |
81 | |
82 | case LTT_SEQUENCE: |
83 | size1 = fld->sequ_number_size; |
84 | element_number = getIntNumber(reverse_byte_order,size1,evD); |
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, |
92 | fld->child[0], evD+size+size1, reverse_byte_order); |
93 | } |
94 | size += size1; |
95 | } |
96 | break; |
97 | |
98 | case LTT_STRING: |
99 | size = strlen((gchar*)evD) + 1; //include end : '\0' |
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, |
109 | fld->child[i],evD+offset2, reverse_byte_order); |
110 | offset1 += size; |
111 | offset2 += size; |
112 | } |
113 | size = offset2; |
114 | }else size = fld->field_size; |
115 | break; |
116 | |
117 | case LTT_UNION: |
118 | size = fld->field_size; |
119 | break; |
120 | |
121 | default: |
122 | size = fld->field_size; |
123 | } |
124 | |
125 | #if 0 |
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++){ |
134 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
135 | fld->child[0], evD+size); |
136 | } |
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++){ |
147 | size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, |
148 | fld->child[0], evD+size+size1); |
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++){ |
160 | size=ltt_event_refresh_fields(offset1,offset2, |
161 | fld->child[i],evD+offset2); |
162 | offset1 += size; |
163 | offset2 += size; |
164 | } |
165 | size = offset2; |
166 | }else size = fld->field_size; |
167 | } |
168 | #endif //0 |
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 | } |
b59cd2f8 |
177 | #endif //0 |
178 | |
54ecbf38 |
179 | |
180 | /***************************************************************************** |
181 | *Function name |
182 | * ltt_event_eventtype_id: get event type id |
183 | * (base id + position of the event) |
184 | *Input params |
185 | * e : an instance of an event type |
186 | *Return value |
187 | * unsigned : event type id |
188 | ****************************************************************************/ |
189 | |
190 | unsigned ltt_event_eventtype_id(LttEvent *e) |
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 |
201 | * LttFacility * : the facility of the event |
202 | ****************************************************************************/ |
203 | |
204 | LttFacility *ltt_event_facility(LttEvent *e) |
205 | { |
206 | LttTrace * trace = e->tracefile->trace; |
207 | unsigned id = e->event_id; |
208 | return ltt_trace_facility_by_id(trace,id); |
209 | } |
210 | |
211 | /***************************************************************************** |
212 | *Function name |
213 | * ltt_event_eventtype : get the event type of the event |
214 | *Input params |
215 | * e : an instance of an event type |
216 | *Return value |
217 | * LttEventType * : the event type of the event |
218 | ****************************************************************************/ |
219 | |
220 | LttEventType *ltt_event_eventtype(LttEvent *e) |
221 | { |
222 | LttFacility* facility = ltt_event_facility(e); |
223 | if(!facility) return NULL; |
b59cd2f8 |
224 | return &g_array_index(facility->events, LttEventType, e->event_id); |
54ecbf38 |
225 | } |
226 | |
227 | /***************************************************************************** |
228 | *Function name |
229 | * ltt_event_field : get the root field of the event |
230 | *Input params |
231 | * e : an instance of an event type |
232 | *Return value |
233 | * LttField * : the root field of the event |
234 | ****************************************************************************/ |
235 | |
236 | LttField *ltt_event_field(LttEvent *e) |
237 | { |
238 | LttField * field; |
239 | LttEventType * event_type = ltt_event_eventtype(e); |
240 | if(unlikely(!event_type)) return NULL; |
241 | field = event_type->root_field; |
242 | if(unlikely(!field)) return NULL; |
243 | |
57b66efc |
244 | get_field_type_size(e->tracefile, event_type, 0, 0, |
245 | field, e->data); |
246 | |
54ecbf38 |
247 | return field; |
248 | } |
249 | |
250 | /***************************************************************************** |
251 | *Function name |
252 | * ltt_event_time : get the time of the event |
253 | *Input params |
254 | * e : an instance of an event type |
255 | *Return value |
256 | * LttTime : the time of the event |
257 | ****************************************************************************/ |
258 | |
259 | LttTime ltt_event_time(LttEvent *e) |
260 | { |
261 | return e->event_time; |
262 | } |
263 | |
264 | /***************************************************************************** |
265 | *Function name |
266 | * ltt_event_time : get the cycle count of the event |
267 | *Input params |
268 | * e : an instance of an event type |
269 | *Return value |
270 | * LttCycleCount : the cycle count of the event |
271 | ****************************************************************************/ |
272 | |
273 | LttCycleCount ltt_event_cycle_count(LttEvent *e) |
274 | { |
b59cd2f8 |
275 | return e->tsc; |
54ecbf38 |
276 | } |
277 | |
278 | /***************************************************************************** |
279 | *Function name |
280 | * ltt_event_position : get the event's position |
281 | *Input params |
282 | * e : an instance of an event type |
283 | * ep : a pointer to event's position structure |
284 | ****************************************************************************/ |
285 | |
286 | void ltt_event_position(LttEvent *e, LttEventPosition *ep) |
287 | { |
b59cd2f8 |
288 | ep->tracefile = e->tracefile; |
289 | ep->block = e->block; |
290 | ep->offset = e->offset; |
291 | ep->tsc = e->tsc; |
54ecbf38 |
292 | } |
293 | |
294 | LttEventPosition * ltt_event_position_new() |
295 | { |
296 | return g_new(LttEventPosition, 1); |
297 | } |
298 | |
54ecbf38 |
299 | |
300 | /***************************************************************************** |
301 | * Function name |
302 | * ltt_event_position_compare : compare two positions |
303 | * A NULL value is infinite. |
304 | * Input params |
305 | * ep1 : a pointer to event's position structure |
306 | * ep2 : a pointer to event's position structure |
307 | * Return |
308 | * -1 is ep1 < ep2 |
309 | * 1 if ep1 > ep2 |
310 | * 0 if ep1 == ep2 |
311 | ****************************************************************************/ |
312 | |
313 | |
314 | gint ltt_event_position_compare(const LttEventPosition *ep1, |
315 | const LttEventPosition *ep2) |
316 | { |
54ecbf38 |
317 | if(ep1 == NULL && ep2 == NULL) |
318 | return 0; |
319 | if(ep1 != NULL && ep2 == NULL) |
320 | return -1; |
321 | if(ep1 == NULL && ep2 != NULL) |
322 | return 1; |
54ecbf38 |
323 | |
b59cd2f8 |
324 | if(ep1->tracefile != ep2->tracefile) |
325 | g_error("ltt_event_position_compare on different tracefiles makes no sense"); |
326 | |
327 | if(ep1->block < ep2->block) |
54ecbf38 |
328 | return -1; |
b59cd2f8 |
329 | if(ep1->block > ep2->block) |
54ecbf38 |
330 | return 1; |
b59cd2f8 |
331 | if(ep1->offset < ep2->offset) |
54ecbf38 |
332 | return -1; |
b59cd2f8 |
333 | if(ep1->offset > ep2->offset) |
54ecbf38 |
334 | return 1; |
335 | return 0; |
336 | } |
337 | |
338 | /***************************************************************************** |
339 | * Function name |
340 | * ltt_event_position_copy : copy position |
341 | * Input params |
342 | * src : a pointer to event's position structure source |
343 | * dest : a pointer to event's position structure dest |
344 | * Return |
345 | * void |
346 | ****************************************************************************/ |
347 | void ltt_event_position_copy(LttEventPosition *dest, |
348 | const LttEventPosition *src) |
349 | { |
350 | if(src == NULL) |
351 | dest = NULL; |
352 | else |
353 | *dest = *src; |
354 | } |
355 | |
356 | |
357 | /***************************************************************************** |
358 | *Function name |
359 | * ltt_event_cpu_i: get the cpu id where the event happens |
360 | *Input params |
361 | * e : an instance of an event type |
362 | *Return value |
363 | * unsigned : the cpu id |
364 | ****************************************************************************/ |
365 | |
366 | unsigned ltt_event_cpu_id(LttEvent *e) |
b59cd2f8 |
367 | { |
368 | return e->tracefile->cpu_num; |
54ecbf38 |
369 | } |
370 | |
371 | /***************************************************************************** |
372 | *Function name |
373 | * ltt_event_data : get the raw data for the event |
374 | *Input params |
375 | * e : an instance of an event type |
376 | *Return value |
377 | * void * : pointer to the raw data for the event |
378 | ****************************************************************************/ |
379 | |
380 | void *ltt_event_data(LttEvent *e) |
381 | { |
382 | return e->data; |
383 | } |
384 | |
385 | /***************************************************************************** |
386 | *Function name |
387 | * ltt_event_field_element_number |
388 | * : The number of elements in a sequence field is specific |
389 | * to each event. This function returns the number of |
390 | * elements for an array or sequence field in an event. |
391 | *Input params |
392 | * e : an instance of an event type |
393 | * f : a field of the instance |
394 | *Return value |
395 | * unsigned : the number of elements for an array/sequence field |
396 | ****************************************************************************/ |
57b66efc |
397 | guint64 ltt_event_field_element_number(LttEvent *e, LttField *f) |
54ecbf38 |
398 | { |
399 | if(f->field_type->type_class != LTT_ARRAY && |
400 | f->field_type->type_class != LTT_SEQUENCE) |
401 | return 0; |
402 | |
403 | if(f->field_type->type_class == LTT_ARRAY) |
404 | return f->field_type->element_number; |
57b66efc |
405 | return get_unsigned(LTT_GET_BO(e->tracefile), f->sequ_number_size, |
406 | e + f->offset_root); |
54ecbf38 |
407 | } |
408 | |
409 | /***************************************************************************** |
410 | *Function name |
411 | * ltt_event_field_element_select |
412 | * : Set the currently selected element for a sequence or |
413 | * array field |
414 | *Input params |
415 | * e : an instance of an event type |
416 | * f : a field of the instance |
57b66efc |
417 | * i : the ith element (0, ...) |
54ecbf38 |
418 | ****************************************************************************/ |
54ecbf38 |
419 | void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i) |
420 | { |
421 | unsigned element_number; |
57b66efc |
422 | LttField *field; |
54ecbf38 |
423 | unsigned int k; |
b59cd2f8 |
424 | size_t size; |
54ecbf38 |
425 | |
426 | if(f->field_type->type_class != LTT_ARRAY && |
427 | f->field_type->type_class != LTT_SEQUENCE) |
428 | return ; |
429 | |
430 | element_number = ltt_event_field_element_number(e,f); |
57b66efc |
431 | /* Sanity check for i : 0..n-1 only, and must be lower or equal element_number |
54ecbf38 |
432 | */ |
57b66efc |
433 | if(i >= element_number) return; |
54ecbf38 |
434 | |
57b66efc |
435 | field = f->child[0]; |
54ecbf38 |
436 | |
57b66efc |
437 | if(f->field_type->type_class == LTT_SEQUENCE) |
438 | size = f->sequ_number_size; |
439 | else |
440 | size = 0; |
441 | |
442 | for(k=0;k<=i;k++){ |
443 | size += get_field_type_size(e->tracefile, event_type, |
444 | f->offset_root+size, size, field, e->data); |
54ecbf38 |
445 | } |
57b66efc |
446 | f->current_element = i; |
54ecbf38 |
447 | } |
448 | |
449 | /***************************************************************************** |
450 | * These functions extract data from an event after architecture specific |
451 | * conversions |
452 | ****************************************************************************/ |
54ecbf38 |
453 | guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f) |
454 | { |
b59cd2f8 |
455 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
54ecbf38 |
456 | |
457 | LttTypeEnum t = f->field_type->type_class; |
458 | |
459 | g_assert(t == LTT_UINT || t == LTT_ENUM); |
460 | |
461 | if(f->field_size == 1){ |
462 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
463 | return (guint32) x; |
464 | }else if(f->field_size == 2){ |
465 | return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root); |
466 | }else if(f->field_size == 4){ |
467 | return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root); |
468 | } |
469 | #if 0 |
470 | else if(f->field_size == 8){ |
471 | guint64 x = *(guint64 *)(e->data + f->offset_root); |
472 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
473 | return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x); |
474 | else |
475 | return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x); |
476 | } |
477 | #endif //0 |
478 | g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size); |
479 | return 0; |
480 | } |
481 | |
482 | gint32 ltt_event_get_int(LttEvent *e, LttField *f) |
483 | { |
b59cd2f8 |
484 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
54ecbf38 |
485 | |
486 | g_assert(f->field_type->type_class == LTT_INT); |
487 | |
488 | if(f->field_size == 1){ |
489 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
490 | return (gint32) x; |
491 | }else if(f->field_size == 2){ |
492 | return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset_root); |
493 | }else if(f->field_size == 4){ |
494 | return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset_root); |
495 | } |
496 | #if 0 |
497 | else if(f->field_size == 8){ |
498 | gint64 x = *(gint64 *)(e->data + f->offset_root); |
499 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
500 | return (int) (revFlag ? GINT64_FROM_BE(x): x); |
501 | else |
502 | return (int) (revFlag ? GINT64_FROM_LE(x): x); |
503 | } |
504 | #endif //0 |
505 | g_critical("ltt_event_get_int : field size %i unknown", f->field_size); |
506 | return 0; |
507 | } |
508 | |
509 | guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f) |
510 | { |
b59cd2f8 |
511 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
512 | |
54ecbf38 |
513 | LttTypeEnum t = f->field_type->type_class; |
514 | |
515 | g_assert(t == LTT_UINT || t == LTT_ENUM); |
516 | |
517 | if(f->field_size == 1){ |
518 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
519 | return (guint64) x; |
520 | }else if(f->field_size == 2){ |
521 | return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root); |
522 | }else if(f->field_size == 4){ |
523 | return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root); |
524 | }else if(f->field_size == 8){ |
525 | return ltt_get_uint64(reverse_byte_order, e->data + f->offset_root); |
526 | } |
527 | g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size); |
528 | return 0; |
529 | } |
530 | |
531 | gint64 ltt_event_get_long_int(LttEvent *e, LttField *f) |
532 | { |
533 | //int revFlag = e->tracefile->trace->my_arch_endian == |
534 | // e->tracefile->trace->system_description->endian ? 0:1; |
b59cd2f8 |
535 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
54ecbf38 |
536 | |
537 | g_assert( f->field_type->type_class == LTT_INT); |
538 | |
539 | if(f->field_size == 1){ |
540 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
541 | return (gint64) x; |
542 | }else if(f->field_size == 2){ |
543 | return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset_root); |
544 | }else if(f->field_size == 4){ |
545 | return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset_root); |
546 | }else if(f->field_size == 8){ |
547 | return ltt_get_int64(reverse_byte_order, e->data + f->offset_root); |
548 | } |
549 | g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size); |
550 | return 0; |
551 | } |
552 | |
553 | float ltt_event_get_float(LttEvent *e, LttField *f) |
554 | { |
b59cd2f8 |
555 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
54ecbf38 |
556 | |
557 | g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4); |
558 | |
559 | if(reverse_byte_order == 0) return *(float *)(e->data + f->offset_root); |
560 | else{ |
561 | guint32 aInt; |
562 | memcpy((void*)&aInt, e->data + f->offset_root, 4); |
563 | aInt = ___swab32(aInt); |
564 | return ((float)aInt); |
565 | } |
566 | } |
567 | |
568 | double ltt_event_get_double(LttEvent *e, LttField *f) |
569 | { |
b59cd2f8 |
570 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
54ecbf38 |
571 | |
572 | g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8); |
573 | |
574 | if(reverse_byte_order == 0) return *(double *)(e->data + f->offset_root); |
575 | else{ |
576 | guint64 aInt; |
577 | memcpy((void*)&aInt, e->data + f->offset_root, 8); |
578 | aInt = ___swab64(aInt); |
579 | return ((double)aInt); |
580 | } |
581 | } |
582 | |
583 | /***************************************************************************** |
584 | * The string obtained is only valid until the next read from |
585 | * the same tracefile. |
586 | ****************************************************************************/ |
54ecbf38 |
587 | char *ltt_event_get_string(LttEvent *e, LttField *f) |
588 | { |
589 | g_assert(f->field_type->type_class == LTT_STRING); |
590 | |
591 | return (gchar*)g_strdup((gchar*)(e->data + f->offset_root)); |
592 | } |