ltt/branches/poly/ltt-newlib/event.c

   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
  49 #if 0
  50 /* Use get_field_type_size instead */
  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 }
 177 #endif //0
 178
 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;
 224   return &g_array_index(facility->events, LttEventType, e->event_id);
 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
 244   get_field_type_size(e->tracefile, event_type, 0, 0,
 245       field, e->data);
 246
 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 {
 275   return e->tsc;
 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 {
 288   ep->tracefile = e->tracefile;
 289   ep->block = e->block;
 290   ep->offset = e->offset;
 291   ep->tsc = e->tsc;
 292 }
 293
 294 LttEventPosition * ltt_event_position_new()
 295 {
 296   return g_new(LttEventPosition, 1);
 297 }
 298
 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 {
 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;
 323
 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)
 328     return -1;
 329   if(ep1->block > ep2->block)
 330     return 1;
 331   if(ep1->offset < ep2->offset)
 332     return -1;
 333   if(ep1->offset > ep2->offset)
 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)
 367 {
 368   return e->tracefile->cpu_num;
 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  ****************************************************************************/
 397 guint64 ltt_event_field_element_number(LttEvent *e, LttField *f)
 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;
 405   return get_unsigned(LTT_GET_BO(e->tracefile), f->sequ_number_size,
 406       e + f->offset_root);
 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
 417  *    i              : the ith element (0, ...)
 418  ****************************************************************************/
 419 void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
 420 {
 421   unsigned element_number;
 422   LttField *field;
 423   unsigned int k;
 424   size_t size;
 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);
 431   /* Sanity check for i : 0..n-1 only, and must be lower or equal element_number
 432    */
 433   if(i >= element_number) return;
 434
 435   field = f->child[0];
 436
 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);
 445   }
 446   f->current_element = i;
 447 }
 448
 449 /*****************************************************************************
 450  * These functions extract data from an event after architecture specific
 451  * conversions
 452  ****************************************************************************/
 453 guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f)
 454 {
 455   gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
 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 {
 484   gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
 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 {
 511   gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
 512
 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;
 535   gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
 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 {
 555   gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
 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 {
 570   gboolean reverse_byte_order = LTT_GET_BO(e->tracefile);
 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  ****************************************************************************/
 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 }