449cb9d7 |
1 | |
6cd62ccf |
2 | #include <ltt/event.h> |
d27446d1 |
3 | #include <ltt/ltt-types.h> |
6cd62ccf |
4 | |
eed2ef37 |
5 | /***************************************************************************** |
6 | *Function name |
7 | * ltt_event_position_get : get the event position data |
8 | *Input params |
9 | * e : an instance of an event type |
10 | * ep : a pointer to event's position structure |
11 | * tf : tracefile pointer |
12 | * block : current block |
13 | * offset : current offset |
14 | * tsc : current tsc |
15 | ****************************************************************************/ |
16 | void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf, |
17 | guint *block, guint *offset, guint64 *tsc) |
18 | { |
19 | *tf = ep->tracefile; |
20 | *block = ep->block; |
21 | *offset = ep->offset; |
22 | *tsc = ep->tsc; |
23 | } |
24 | |
25 | |
6d0cdf22 |
26 | void ltt_event_position_set(LttEventPosition *ep, LttTracefile *tf, |
27 | guint block, guint offset, guint64 tsc) |
28 | { |
29 | ep->tracefile = tf; |
30 | ep->block = block; |
31 | ep->offset = offset; |
32 | ep->tsc = tsc; |
33 | } |
34 | |
35 | |
80da81ad |
36 | /***************************************************************************** |
37 | *Function name |
38 | * ltt_event_position : get the event's position |
39 | *Input params |
40 | * e : an instance of an event type |
41 | * ep : a pointer to event's position structure |
42 | ****************************************************************************/ |
43 | |
44 | void ltt_event_position(LttEvent *e, LttEventPosition *ep) |
45 | { |
3aee1200 |
46 | ep->tracefile = e->tracefile; |
47 | ep->block = e->block; |
48 | ep->offset = e->offset; |
49 | ep->tsc = e->tsc; |
80da81ad |
50 | } |
51 | |
a5dcde2f |
52 | LttEventPosition * ltt_event_position_new() |
53 | { |
54 | return g_new(LttEventPosition, 1); |
55 | } |
56 | |
80da81ad |
57 | |
96da5c0d |
58 | /***************************************************************************** |
59 | * Function name |
60 | * ltt_event_position_compare : compare two positions |
a00149f6 |
61 | * A NULL value is infinite. |
96da5c0d |
62 | * Input params |
63 | * ep1 : a pointer to event's position structure |
64 | * ep2 : a pointer to event's position structure |
65 | * Return |
66 | * -1 is ep1 < ep2 |
67 | * 1 if ep1 > ep2 |
68 | * 0 if ep1 == ep2 |
69 | ****************************************************************************/ |
70 | |
71 | |
72 | gint ltt_event_position_compare(const LttEventPosition *ep1, |
73 | const LttEventPosition *ep2) |
74 | { |
a00149f6 |
75 | if(ep1 == NULL && ep2 == NULL) |
76 | return 0; |
77 | if(ep1 != NULL && ep2 == NULL) |
78 | return -1; |
79 | if(ep1 == NULL && ep2 != NULL) |
80 | return 1; |
96da5c0d |
81 | |
3aee1200 |
82 | if(ep1->tracefile != ep2->tracefile) |
83 | g_error("ltt_event_position_compare on different tracefiles makes no sense"); |
84 | |
85 | if(ep1->block < ep2->block) |
96da5c0d |
86 | return -1; |
3aee1200 |
87 | if(ep1->block > ep2->block) |
96da5c0d |
88 | return 1; |
3aee1200 |
89 | if(ep1->offset < ep2->offset) |
96da5c0d |
90 | return -1; |
3aee1200 |
91 | if(ep1->offset > ep2->offset) |
96da5c0d |
92 | return 1; |
93 | return 0; |
94 | } |
95 | |
2a74fbf4 |
96 | /***************************************************************************** |
97 | * Function name |
98 | * ltt_event_position_copy : copy position |
99 | * Input params |
100 | * src : a pointer to event's position structure source |
101 | * dest : a pointer to event's position structure dest |
102 | * Return |
103 | * void |
104 | ****************************************************************************/ |
105 | void ltt_event_position_copy(LttEventPosition *dest, |
106 | const LttEventPosition *src) |
107 | { |
a00149f6 |
108 | if(src == NULL) |
109 | dest = NULL; |
110 | else |
111 | *dest = *src; |
2a74fbf4 |
112 | } |
96da5c0d |
113 | |
114 | |
27304273 |
115 | |
116 | LttTracefile *ltt_event_position_tracefile(LttEventPosition *ep) |
117 | { |
118 | return ep->tracefile; |
119 | } |
120 | |
c37440c8 |
121 | /***************************************************************************** |
122 | * These functions extract data from an event after architecture specific |
123 | * conversions |
124 | ****************************************************************************/ |
125 | guint32 ltt_event_get_unsigned(LttEvent *e, struct marker_field *f) |
126 | { |
127 | gboolean reverse_byte_order; |
128 | if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) { |
129 | reverse_byte_order = (g_ntohs(0x1) != 0x1); |
130 | } else { |
131 | reverse_byte_order = LTT_GET_BO(e->tracefile); |
132 | } |
133 | |
134 | switch(f->size) { |
135 | case 1: |
136 | { |
137 | guint8 x = *(guint8 *)(e->data + f->offset); |
138 | return (guint32) x; |
139 | } |
140 | break; |
141 | case 2: |
142 | return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset); |
143 | break; |
144 | case 4: |
145 | return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset); |
146 | break; |
147 | case 8: |
148 | default: |
149 | g_critical("ltt_event_get_unsigned : field size %i unknown", f->size); |
150 | return 0; |
151 | break; |
152 | } |
153 | } |
154 | |
155 | gint32 ltt_event_get_int(LttEvent *e, struct marker_field *f) |
156 | { |
157 | gboolean reverse_byte_order; |
158 | if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) { |
159 | reverse_byte_order = (g_ntohs(0x1) != 0x1); |
160 | } else { |
161 | reverse_byte_order = LTT_GET_BO(e->tracefile); |
162 | } |
163 | |
164 | switch(f->size) { |
165 | case 1: |
166 | { |
167 | gint8 x = *(gint8 *)(e->data + f->offset); |
168 | return (gint32) x; |
169 | } |
170 | break; |
171 | case 2: |
172 | return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset); |
173 | break; |
174 | case 4: |
175 | return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset); |
176 | break; |
177 | case 8: |
178 | default: |
179 | g_critical("ltt_event_get_int : field size %i unknown", f->size); |
180 | return 0; |
181 | break; |
182 | } |
183 | } |
184 | |
185 | guint64 ltt_event_get_long_unsigned(LttEvent *e, struct marker_field *f) |
186 | { |
187 | gboolean reverse_byte_order; |
188 | if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) { |
189 | reverse_byte_order = (g_ntohs(0x1) != 0x1); |
190 | } else { |
191 | reverse_byte_order = LTT_GET_BO(e->tracefile); |
192 | } |
193 | |
194 | switch(f->size) { |
195 | case 1: |
196 | { |
197 | guint8 x = *(guint8 *)(e->data + f->offset); |
198 | return (guint64) x; |
199 | } |
200 | break; |
201 | case 2: |
202 | return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset); |
203 | break; |
204 | case 4: |
205 | return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset); |
206 | break; |
207 | case 8: |
208 | return ltt_get_uint64(reverse_byte_order, e->data + f->offset); |
209 | break; |
210 | default: |
211 | g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->size); |
212 | return 0; |
213 | break; |
214 | } |
215 | } |
216 | |
217 | gint64 ltt_event_get_long_int(LttEvent *e, struct marker_field *f) |
218 | { |
219 | gboolean reverse_byte_order; |
220 | if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) { |
221 | reverse_byte_order = (g_ntohs(0x1) != 0x1); |
222 | } else { |
223 | reverse_byte_order = LTT_GET_BO(e->tracefile); |
224 | } |
225 | |
226 | switch(f->size) { |
227 | case 1: |
228 | { |
229 | gint8 x = *(gint8 *)(e->data + f->offset); |
230 | return (gint64) x; |
231 | } |
232 | break; |
233 | case 2: |
234 | return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset); |
235 | break; |
236 | case 4: |
237 | return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset); |
238 | break; |
239 | case 8: |
240 | return ltt_get_int64(reverse_byte_order, e->data + f->offset); |
241 | break; |
242 | default: |
243 | g_critical("ltt_event_get_long_int : field size %i unknown", f->size); |
244 | return 0; |
245 | break; |
246 | } |
247 | } |
248 | |
249 | #if 0 |
250 | float ltt_event_get_float(LttEvent *e, struct marker_field *f) |
251 | { |
252 | gboolean reverse_byte_order; |
253 | if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) { |
254 | reverse_byte_order = (g_ntohs(0x1) != 0x1); |
255 | } else { |
256 | g_assert(LTT_HAS_FLOAT(e->tracefile)); |
257 | reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile); |
258 | } |
259 | |
260 | g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 4); |
261 | |
262 | if(reverse_byte_order == 0) return *(float *)(e->data + f->offset); |
263 | else{ |
264 | void *ptr = e->data + f->offset; |
265 | guint32 value = bswap_32(*(guint32*)ptr); |
266 | return *(float*)&value; |
267 | } |
268 | } |
269 | |
270 | double ltt_event_get_double(LttEvent *e, struct marker_field *f) |
271 | { |
272 | gboolean reverse_byte_order; |
273 | if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) { |
274 | reverse_byte_order = (g_ntohs(0x1) != 0x1); |
275 | } else { |
276 | g_assert(LTT_HAS_FLOAT(e->tracefile)); |
277 | reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile); |
278 | } |
279 | |
280 | if(f->size == 4) |
281 | return ltt_event_get_float(e, f); |
282 | |
283 | g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 8); |
284 | |
285 | if(reverse_byte_order == 0) return *(double *)(e->data + f->offset); |
286 | else { |
287 | void *ptr = e->data + f->offset; |
288 | guint64 value = bswap_64(*(guint64*)ptr); |
289 | return *(double*)&value; |
290 | } |
291 | } |
292 | #endif |
293 | |
294 | /***************************************************************************** |
295 | * The string obtained is only valid until the next read from |
296 | * the same tracefile. |
297 | ****************************************************************************/ |
298 | char *ltt_event_get_string(LttEvent *e, struct marker_field *f) |
299 | { |
300 | g_assert(f->type == LTT_TYPE_STRING); |
301 | |
302 | return (gchar*)g_strdup((gchar*)(e->data + f->offset)); |
303 | } |
304 | |
305 | |