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