Macros
#define	__LITL_WRITE_ADD_ARG(ptr, param)
	For internal use only. Adds a parameter to a packed event. More...

#define	litl_write_probe_pack_0(trace, code, retval)
	Records a packed event without parameters. More...

#define	litl_write_probe_pack_1(trace, code, param1, retval)
	Records a packed event with 1 parameter. More...

#define	litl_write_probe_pack_2(trace, code, param1, param2, retval)
	Records a packed event with 2 parameters. More...

#define	litl_write_probe_pack_3(trace, code, param1, param2, param3, retval)
	Records a packed event with 3 parameters. More...

#define	litl_write_probe_pack_4(trace, code, param1, param2, param3, param4, retval)
	Records a packed event with 4 parameters. More...

#define	litl_write_probe_pack_5(trace, code, param1, param2, param3, param4, param5, retval)
	Records a packed event with 5 parameters. More...

#define	litl_write_probe_pack_6(trace, code, param1, param2, param3, param4, param5, param6, retval)
	Records a packed event with 6 parameters. More...

#define	litl_write_probe_pack_7(trace, code, param1, param2, param3, param4, param5, param6, param7, retval)
	Records a packed event with 7 parameters. More...

#define	litl_write_probe_pack_8(trace, code, param1, param2, param3, param4, param5, param6, param7, param8, retval)
	Records a packed event with 8 parameters. More...

#define	litl_write_probe_pack_9(trace, code, param1, param2, param3, param4, param5, param6, param7, param8, param9, retval)
	Records a packed event with 9 parameters. More...

#define	litl_write_probe_pack_10(trace, code, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, retval)
	Records a packed event with 10 parameters. More...

Functions
litl_t *	__litl_write_get_event (litl_write_trace_t *trace, litl_type_t type, litl_code_t code, int size)
	For internal use only. Allocates an event. More...

Detailed Description

Macro Definition Documentation

◆ __LITL_WRITE_ADD_ARG

#define __LITL_WRITE_ADD_ARG	(	ptr,
		param
	)

Value:

do {    \
    typeof(param) _param = param;       \
    memcpy(ptr, &_param, sizeof(_param));   \
    ptr = ((char*) ptr)+sizeof(_param);     \
  } while(0)

For internal use only. Adds a parameter to a packed event.

Parameters

ptr	A pointer to an event where the parameter should be stored
param	A parameter to store

Definition at line 339 of file litl_write.h.

◆ litl_write_probe_pack_0

#define litl_write_probe_pack_0	(	trace,
		code,
		retval
	)

Value:

do {            \
    int total_size = 0;                     \
    litl_t* p_evt = __litl_write_get_event(trace,       \
                       LITL_TYPE_PACKED,    \
                       code, total_size);   \
    retval = p_evt;                     \
  } while(0)

Records a packed event without parameters.

Parameters

trace	A pointer to the event recording object
code	An event code

Definition at line 353 of file litl_write.h.

◆ litl_write_probe_pack_1

#define litl_write_probe_pack_1	(	trace,
		code,
		param1,
		retval
	)

Value:

do {                                \
    int total_size =  sizeof(param1);               \
    litl_t* p_evt = __litl_write_get_event(trace,       \
                       LITL_TYPE_PACKED,    \
                       code,        \
                       total_size);     \
    if(p_evt){                          \
      void* _ptr_ = &p_evt->parameters.packed.param[0];     \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);          \
    }                               \
    retval = p_evt;                     \
  } while(0)

Records a packed event with 1 parameter.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event

Definition at line 370 of file litl_write.h.

◆ litl_write_probe_pack_10

#define litl_write_probe_pack_10	(	trace,
		code,
		param1,
		param2,
		param3,
		param4,
		param5,
		param6,
		param7,
		param8,
		param9,
		param10,
		retval
	)

Value:

do {                \
    int total_size =  sizeof(param1) + sizeof(param2) +         \
      sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) + \
      sizeof(param7) + sizeof(param8) + sizeof(param9) + sizeof(param10); \
    litl_t* p_evt = __litl_write_get_event(trace,           \
                       LITL_TYPE_PACKED,        \
                       code,            \
                       total_size);         \
    if(p_evt){                              \
      void* _ptr_ = &p_evt->parameters.packed.param[0];         \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param4);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param5);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param6);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param7);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param8);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param9);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param10);             \
    }                                   \
    retval = p_evt;                         \
  } while(0)

Records a packed event with 10 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event
param4	4th parameter for this event
param5	5th parameter for this event
param6	6th parameter for this event
param7	7th parameter for this event
param8	8th parameter for this event
param9	9th parameter for this event
param10	10th parameter for this event

Definition at line 707 of file litl_write.h.

◆ litl_write_probe_pack_2

#define litl_write_probe_pack_2	(	trace,
		code,
		param1,
		param2,
		retval
	)

Value:

do {                                \
    int total_size =  sizeof(param1) + sizeof(param2);      \
    litl_t* p_evt = __litl_write_get_event(trace,       \
                       LITL_TYPE_PACKED,    \
                       code,        \
                       total_size);     \
    if(p_evt){                          \
      void* _ptr_ = &p_evt->parameters.packed.param[0];     \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);          \
    }                               \
    retval = p_evt;                     \
  } while(0)

Records a packed event with 2 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event

Definition at line 395 of file litl_write.h.

◆ litl_write_probe_pack_3

#define litl_write_probe_pack_3	(	trace,
		code,
		param1,
		param2,
		param3,
		retval
	)

Value:

do {            \
    int total_size =  sizeof(param1) + sizeof(param2) +     \
      sizeof(param3);                       \
    litl_t* p_evt = __litl_write_get_event(trace,       \
                       LITL_TYPE_PACKED,    \
                       code,        \
                       total_size);     \
    if(p_evt){                          \
      void* _ptr_ = &p_evt->parameters.packed.param[0];     \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);          \
    }                               \
    retval = p_evt;                     \
  } while(0)

Records a packed event with 3 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event

Definition at line 423 of file litl_write.h.

◆ litl_write_probe_pack_4

#define litl_write_probe_pack_4	(	trace,
		code,
		param1,
		param2,
		param3,
		param4,
		retval
	)

Value:

do {            \
    int total_size =  sizeof(param1) + sizeof(param2) +     \
      sizeof(param3) + sizeof(param4);              \
    litl_t* p_evt = __litl_write_get_event(trace,       \
                       LITL_TYPE_PACKED,    \
                       code,        \
                       total_size);     \
    if(p_evt){                          \
      void* _ptr_ = &p_evt->parameters.packed.param[0];     \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param4);          \
    }                               \
    retval = p_evt;                     \
  } while(0)

Records a packed event with 4 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event
param4	4th parameter for this event

Definition at line 454 of file litl_write.h.

◆ litl_write_probe_pack_5

#define litl_write_probe_pack_5	(	trace,
		code,
		param1,
		param2,
		param3,
		param4,
		param5,
		retval
	)

Value:

do {            \
    int total_size =  sizeof(param1) + sizeof(param2) +     \
      sizeof(param3) + sizeof(param4) +sizeof(param5);      \
    litl_t* p_evt = __litl_write_get_event(trace,       \
                       LITL_TYPE_PACKED,    \
                       code,        \
                       total_size);     \
    if(p_evt){                          \
      void* _ptr_ = &p_evt->parameters.packed.param[0];     \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param4);          \
      __LITL_WRITE_ADD_ARG(_ptr_, param5);          \
    }                               \
    retval = p_evt;                     \
  } while(0)

Records a packed event with 5 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event
param4	4th parameter for this event
param5	5th parameter for this event

Definition at line 488 of file litl_write.h.

◆ litl_write_probe_pack_6

#define litl_write_probe_pack_6	(	trace,
		code,
		param1,
		param2,
		param3,
		param4,
		param5,
		param6,
		retval
	)

Value:

do {                \
    int total_size = sizeof(param1) + sizeof(param2) +          \
      sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6); \
    litl_t* p_evt = __litl_write_get_event(trace,           \
                       LITL_TYPE_PACKED,        \
                       code,            \
                       total_size);         \
    if(p_evt){                              \
      void* _ptr_ = &p_evt->parameters.packed.param[0];         \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param4);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param5);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param6);              \
    }                                   \
    retval = p_evt;                         \
  } while(0)

Records a packed event with 6 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event
param4	4th parameter for this event
param5	5th parameter for this event
param6	6th parameter for this event

Definition at line 525 of file litl_write.h.

◆ litl_write_probe_pack_7

#define litl_write_probe_pack_7	(	trace,
		code,
		param1,
		param2,
		param3,
		param4,
		param5,
		param6,
		param7,
		retval
	)

Value:

do {                \
    int total_size = sizeof(param1) + sizeof(param2) +          \
      sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
      + sizeof(param7);                         \
    litl_t* p_evt = __litl_write_get_event(trace,           \
                       LITL_TYPE_PACKED,        \
                       code,            \
                       total_size);         \
    if(p_evt){                              \
      void* _ptr_ = &p_evt->parameters.packed.param[0];         \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param4);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param5);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param6);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param7);              \
    }                                   \
    retval = p_evt;                         \
  } while(0)

Records a packed event with 7 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event
param4	4th parameter for this event
param5	5th parameter for this event
param6	6th parameter for this event
param7	7th parameter for this event

Definition at line 565 of file litl_write.h.

◆ litl_write_probe_pack_8

#define litl_write_probe_pack_8	(	trace,
		code,
		param1,
		param2,
		param3,
		param4,
		param5,
		param6,
		param7,
		param8,
		retval
	)

Value:

do {                \
    int total_size =  sizeof(param1) + sizeof(param2) +         \
      sizeof(param3) + sizeof(param4) + sizeof(param5) + sizeof(param6) \
      + sizeof(param7) + sizeof(param8);                \
    litl_t* p_evt = __litl_write_get_event(trace,           \
                       LITL_TYPE_PACKED,        \
                       code,            \
                       total_size);         \
    if(p_evt){                              \
      void* _ptr_ = &p_evt->parameters.packed.param[0];         \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param4);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param5);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param6);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param7);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param8);              \
    }                                   \
    retval = p_evt;                         \
  } while(0)

Records a packed event with 8 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event
param4	4th parameter for this event
param5	5th parameter for this event
param6	6th parameter for this event
param7	7th parameter for this event
param8	8th parameter for this event

Definition at line 609 of file litl_write.h.

◆ litl_write_probe_pack_9

#define litl_write_probe_pack_9	(	trace,
		code,
		param1,
		param2,
		param3,
		param4,
		param5,
		param6,
		param7,
		param8,
		param9,
		retval
	)

Value:

do {                \
    int total_size =  sizeof(param1) + sizeof(param2) +         \
      sizeof(param3) + sizeof(param4)  + sizeof(param5) + sizeof(param6) \
      + sizeof(param7) + sizeof(param8) + sizeof(param9);       \
    litl_t* p_evt = __litl_write_get_event(trace,           \
                       LITL_TYPE_PACKED,        \
                       code,            \
                       total_size);         \
    if(p_evt){                              \
      void* _ptr_ = &p_evt->parameters.packed.param[0];         \
      __LITL_WRITE_ADD_ARG(_ptr_, param1);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param2);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param3);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param4);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param5);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param6);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param7);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param8);              \
      __LITL_WRITE_ADD_ARG(_ptr_, param9);              \
    }                                   \
    retval = p_evt;                         \
  } while(0)

Records a packed event with 9 parameters.

Parameters

trace	A pointer to the event recording object
code	An event code
param1	1st parameter for this event
param2	2nd parameter for this event
param3	3rd parameter for this event
param4	4th parameter for this event
param5	5th parameter for this event
param6	6th parameter for this event
param7	7th parameter for this event
param8	8th parameter for this event
param9	9th parameter for this event

Definition at line 657 of file litl_write.h.

Function Documentation

◆ __litl_write_get_event()

litl_t* __litl_write_get_event	(	litl_write_trace_t *	trace,
		litl_type_t	type,
		litl_code_t	code,
		int	size
	)

For internal use only. Allocates an event.

Parameters

trace	A pointer to the event recording object
type	An event type
code	An event code
size	Size of the event (in Bytes)

Returns: The allocated event or NULL in case of error

Definition at line 592 of file litl_write.c.

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ __LITL_WRITE_ADD_ARG

◆ litl_write_probe_pack_0

◆ litl_write_probe_pack_1

◆ litl_write_probe_pack_10

◆ litl_write_probe_pack_2

◆ litl_write_probe_pack_3

◆ litl_write_probe_pack_4

◆ litl_write_probe_pack_5

◆ litl_write_probe_pack_6

◆ litl_write_probe_pack_7

◆ litl_write_probe_pack_8

◆ litl_write_probe_pack_9

Function Documentation

◆ __litl_write_get_event()