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