Commit | Line | Data |
---|---|---|
273b65be | 1 | /* |
ac0c6bdd | 2 | * clock-class.c |
273b65be | 3 | * |
ac0c6bdd | 4 | * Babeltrace CTF IR - Clock class |
273b65be | 5 | * |
de9dd397 | 6 | * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com> |
273b65be JG |
7 | * |
8 | * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
9 | * | |
10 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
11 | * of this software and associated documentation files (the "Software"), to deal | |
12 | * in the Software without restriction, including without limitation the rights | |
13 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
14 | * copies of the Software, and to permit persons to whom the Software is | |
15 | * furnished to do so, subject to the following conditions: | |
16 | * | |
17 | * The above copyright notice and this permission notice shall be included in | |
18 | * all copies or substantial portions of the Software. | |
19 | * | |
20 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
21 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
22 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
23 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
24 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
25 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
26 | * SOFTWARE. | |
27 | */ | |
28 | ||
0f5e83e5 | 29 | #define BT_LOG_TAG "CLOCK-CLASS" |
40547d22 | 30 | #include <babeltrace/lib-logging-internal.h> |
0f5e83e5 | 31 | |
75c3fca1 | 32 | #include <babeltrace/compat/uuid-internal.h> |
ac0c6bdd | 33 | #include <babeltrace/ctf-ir/clock-class-internal.h> |
654c1444 | 34 | #include <babeltrace/ctf-ir/utils.h> |
83509119 | 35 | #include <babeltrace/ref.h> |
3d9990ac | 36 | #include <babeltrace/compiler-internal.h> |
c55a9f58 | 37 | #include <babeltrace/types.h> |
ee389f01 | 38 | #include <babeltrace/compat/string-internal.h> |
273b65be | 39 | #include <inttypes.h> |
0f5e83e5 | 40 | #include <babeltrace/object-internal.h> |
5134570b | 41 | |
273b65be | 42 | static |
ac0c6bdd | 43 | void bt_ctf_clock_class_destroy(struct bt_object *obj); |
273b65be | 44 | |
4c426c17 | 45 | BT_HIDDEN |
c55a9f58 | 46 | bt_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class) |
c06116f3 | 47 | { |
ac0c6bdd | 48 | return clock_class && clock_class->name; |
c06116f3 PP |
49 | } |
50 | ||
ac0c6bdd | 51 | int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class, |
4c426c17 JG |
52 | const char *name) |
53 | { | |
54 | int ret = 0; | |
273b65be | 55 | |
5134570b PP |
56 | if (!clock_class) { |
57 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
58 | ret = -1; | |
59 | goto end; | |
60 | } | |
61 | ||
62 | if (clock_class->frozen) { | |
2cf0acd7 PP |
63 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
64 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
c06116f3 PP |
65 | ret = -1; |
66 | goto end; | |
67 | } | |
68 | ||
654c1444 | 69 | if (bt_ctf_validate_identifier(name)) { |
5134570b | 70 | BT_LOGE("Clock class's name is not a valid CTF identifier: " |
2cf0acd7 | 71 | "addr=%p, name=\"%s\"", |
5134570b | 72 | clock_class, name); |
4c426c17 JG |
73 | ret = -1; |
74 | goto end; | |
273b65be JG |
75 | } |
76 | ||
ac0c6bdd PP |
77 | if (clock_class->name) { |
78 | g_string_assign(clock_class->name, name); | |
e1ae7645 | 79 | } else { |
ac0c6bdd PP |
80 | clock_class->name = g_string_new(name); |
81 | if (!clock_class->name) { | |
5134570b | 82 | BT_LOGE_STR("Failed to allocate a GString."); |
e1ae7645 JG |
83 | ret = -1; |
84 | goto end; | |
85 | } | |
273b65be JG |
86 | } |
87 | ||
2cf0acd7 | 88 | BT_LOGV("Set clock class's name: addr=%p, name=\"%s\"", |
5134570b PP |
89 | clock_class, name); |
90 | ||
4c426c17 JG |
91 | end: |
92 | return ret; | |
93 | } | |
94 | ||
ac0c6bdd | 95 | struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name) |
4c426c17 JG |
96 | { |
97 | int ret; | |
5134570b | 98 | struct bt_ctf_clock_class *clock_class; |
4c426c17 | 99 | |
5134570b PP |
100 | BT_LOGD("Creating default clock class object: name=\"%s\"", |
101 | name); | |
102 | clock_class = g_new0(struct bt_ctf_clock_class, 1); | |
ac0c6bdd | 103 | if (!clock_class) { |
5134570b | 104 | BT_LOGE_STR("Failed to allocate one clock class."); |
4c426c17 JG |
105 | goto error; |
106 | } | |
107 | ||
ac0c6bdd PP |
108 | clock_class->precision = 1; |
109 | clock_class->frequency = 1000000000; | |
110 | bt_object_init(clock_class, bt_ctf_clock_class_destroy); | |
85380e99 JG |
111 | |
112 | if (name) { | |
ac0c6bdd | 113 | ret = bt_ctf_clock_class_set_name(clock_class, name); |
85380e99 | 114 | if (ret) { |
5134570b | 115 | BT_LOGE("Cannot set clock class's name: " |
2cf0acd7 | 116 | "addr=%p, name=\"%s\"", |
5134570b | 117 | clock_class, name); |
85380e99 JG |
118 | goto error; |
119 | } | |
273b65be JG |
120 | } |
121 | ||
2cf0acd7 PP |
122 | BT_LOGD("Created clock class object: addr=%p, name=\"%s\"", |
123 | clock_class, name); | |
ac0c6bdd | 124 | return clock_class; |
273b65be | 125 | error: |
ac0c6bdd PP |
126 | BT_PUT(clock_class); |
127 | return clock_class; | |
87d76bb1 JG |
128 | } |
129 | ||
ac0c6bdd | 130 | const char *bt_ctf_clock_class_get_name(struct bt_ctf_clock_class *clock_class) |
87d76bb1 JG |
131 | { |
132 | const char *ret = NULL; | |
133 | ||
ac0c6bdd | 134 | if (!clock_class) { |
5134570b | 135 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); |
87d76bb1 JG |
136 | goto end; |
137 | } | |
138 | ||
ac0c6bdd PP |
139 | if (clock_class->name) { |
140 | ret = clock_class->name->str; | |
87d76bb1 JG |
141 | } |
142 | ||
143 | end: | |
144 | return ret; | |
145 | } | |
146 | ||
ac0c6bdd PP |
147 | const char *bt_ctf_clock_class_get_description( |
148 | struct bt_ctf_clock_class *clock_class) | |
87d76bb1 JG |
149 | { |
150 | const char *ret = NULL; | |
151 | ||
ac0c6bdd | 152 | if (!clock_class) { |
5134570b | 153 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); |
87d76bb1 JG |
154 | goto end; |
155 | } | |
156 | ||
ac0c6bdd PP |
157 | if (clock_class->description) { |
158 | ret = clock_class->description->str; | |
87d76bb1 JG |
159 | } |
160 | end: | |
161 | return ret; | |
273b65be JG |
162 | } |
163 | ||
ac0c6bdd PP |
164 | int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class, |
165 | const char *desc) | |
273b65be JG |
166 | { |
167 | int ret = 0; | |
168 | ||
5134570b PP |
169 | if (!clock_class || !desc) { |
170 | BT_LOGW("Invalid parameter: clock class or description is NULL: " | |
2cf0acd7 PP |
171 | "clock-class-addr=%p, name=\"%s\", desc-addr=%p", |
172 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
173 | desc); | |
5134570b PP |
174 | ret = -1; |
175 | goto end; | |
176 | } | |
177 | ||
178 | if (clock_class->frozen) { | |
2cf0acd7 PP |
179 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
180 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
273b65be JG |
181 | ret = -1; |
182 | goto end; | |
183 | } | |
184 | ||
ac0c6bdd PP |
185 | clock_class->description = g_string_new(desc); |
186 | ret = clock_class->description ? 0 : -1; | |
2cf0acd7 PP |
187 | BT_LOGV("Set clock class's description: addr=%p, " |
188 | "name=\"%s\", desc=\"%s\"", | |
189 | clock_class, bt_ctf_clock_class_get_name(clock_class), desc); | |
273b65be JG |
190 | end: |
191 | return ret; | |
192 | } | |
193 | ||
ac0c6bdd PP |
194 | uint64_t bt_ctf_clock_class_get_frequency( |
195 | struct bt_ctf_clock_class *clock_class) | |
87d76bb1 JG |
196 | { |
197 | uint64_t ret = -1ULL; | |
198 | ||
ac0c6bdd | 199 | if (!clock_class) { |
5134570b | 200 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); |
87d76bb1 JG |
201 | goto end; |
202 | } | |
203 | ||
ac0c6bdd | 204 | ret = clock_class->frequency; |
87d76bb1 JG |
205 | end: |
206 | return ret; | |
207 | } | |
208 | ||
ac0c6bdd PP |
209 | int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class, |
210 | uint64_t freq) | |
273b65be JG |
211 | { |
212 | int ret = 0; | |
213 | ||
5134570b PP |
214 | if (!clock_class || freq == -1ULL) { |
215 | BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: " | |
2cf0acd7 PP |
216 | "addr=%p, name=\"%s\", freq=%" PRIu64, |
217 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
218 | freq); | |
5134570b PP |
219 | ret = -1; |
220 | goto end; | |
221 | } | |
222 | ||
223 | if (clock_class->frozen) { | |
2cf0acd7 PP |
224 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
225 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
273b65be JG |
226 | ret = -1; |
227 | goto end; | |
228 | } | |
229 | ||
ac0c6bdd | 230 | clock_class->frequency = freq; |
2cf0acd7 PP |
231 | BT_LOGV("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64, |
232 | clock_class, bt_ctf_clock_class_get_name(clock_class), freq); | |
273b65be JG |
233 | end: |
234 | return ret; | |
235 | } | |
236 | ||
ac0c6bdd | 237 | uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class) |
87d76bb1 JG |
238 | { |
239 | uint64_t ret = -1ULL; | |
240 | ||
ac0c6bdd | 241 | if (!clock_class) { |
5134570b | 242 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); |
87d76bb1 JG |
243 | goto end; |
244 | } | |
245 | ||
ac0c6bdd | 246 | ret = clock_class->precision; |
87d76bb1 JG |
247 | end: |
248 | return ret; | |
249 | } | |
250 | ||
ac0c6bdd PP |
251 | int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class, |
252 | uint64_t precision) | |
273b65be JG |
253 | { |
254 | int ret = 0; | |
255 | ||
5134570b PP |
256 | if (!clock_class || precision == -1ULL) { |
257 | BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: " | |
2cf0acd7 PP |
258 | "addr=%p, name=\"%s\", precision=%" PRIu64, |
259 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
260 | precision); | |
5134570b PP |
261 | ret = -1; |
262 | goto end; | |
263 | } | |
264 | ||
265 | if (clock_class->frozen) { | |
2cf0acd7 PP |
266 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
267 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
273b65be JG |
268 | ret = -1; |
269 | goto end; | |
270 | } | |
271 | ||
ac0c6bdd | 272 | clock_class->precision = precision; |
2cf0acd7 PP |
273 | BT_LOGV("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64, |
274 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
275 | precision); | |
273b65be JG |
276 | end: |
277 | return ret; | |
278 | } | |
279 | ||
ac0c6bdd PP |
280 | int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class, |
281 | int64_t *offset_s) | |
87d76bb1 | 282 | { |
61cf588b | 283 | int ret = 0; |
87d76bb1 | 284 | |
ac0c6bdd | 285 | if (!clock_class || !offset_s) { |
5134570b | 286 | BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: " |
2cf0acd7 PP |
287 | "clock-class-addr=%p, name=\"%s\", offset-addr=%p", |
288 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
289 | offset_s); | |
61cf588b | 290 | ret = -1; |
87d76bb1 JG |
291 | goto end; |
292 | } | |
293 | ||
ac0c6bdd | 294 | *offset_s = clock_class->offset_s; |
87d76bb1 JG |
295 | end: |
296 | return ret; | |
297 | } | |
298 | ||
ac0c6bdd PP |
299 | int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class, |
300 | int64_t offset_s) | |
273b65be JG |
301 | { |
302 | int ret = 0; | |
303 | ||
5134570b PP |
304 | if (!clock_class) { |
305 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
306 | ret = -1; | |
307 | goto end; | |
308 | } | |
309 | ||
310 | if (clock_class->frozen) { | |
2cf0acd7 PP |
311 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
312 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
273b65be JG |
313 | ret = -1; |
314 | goto end; | |
315 | } | |
316 | ||
ac0c6bdd | 317 | clock_class->offset_s = offset_s; |
2cf0acd7 PP |
318 | BT_LOGV("Set clock class's offset (seconds): " |
319 | "addr=%p, name=\"%s\", offset-s=%" PRId64, | |
320 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
321 | offset_s); | |
273b65be JG |
322 | end: |
323 | return ret; | |
324 | } | |
325 | ||
ac0c6bdd PP |
326 | int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class, |
327 | int64_t *offset) | |
87d76bb1 | 328 | { |
61cf588b | 329 | int ret = 0; |
87d76bb1 | 330 | |
ac0c6bdd | 331 | if (!clock_class || !offset) { |
5134570b | 332 | BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: " |
2cf0acd7 PP |
333 | "clock-class-addr=%p, name=\"%s\", offset-addr=%p", |
334 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
335 | offset); | |
61cf588b | 336 | ret = -1; |
87d76bb1 JG |
337 | goto end; |
338 | } | |
339 | ||
ac0c6bdd | 340 | *offset = clock_class->offset; |
87d76bb1 JG |
341 | end: |
342 | return ret; | |
343 | } | |
344 | ||
ac0c6bdd PP |
345 | int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class, |
346 | int64_t offset) | |
273b65be JG |
347 | { |
348 | int ret = 0; | |
349 | ||
5134570b PP |
350 | if (!clock_class) { |
351 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
352 | ret = -1; | |
353 | goto end; | |
354 | } | |
355 | ||
356 | if (clock_class->frozen) { | |
2cf0acd7 PP |
357 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
358 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
273b65be JG |
359 | ret = -1; |
360 | goto end; | |
361 | } | |
362 | ||
ac0c6bdd | 363 | clock_class->offset = offset; |
2cf0acd7 PP |
364 | BT_LOGV("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64, |
365 | clock_class, bt_ctf_clock_class_get_name(clock_class), offset); | |
273b65be JG |
366 | end: |
367 | return ret; | |
368 | } | |
369 | ||
a2b94977 | 370 | bt_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class) |
87d76bb1 JG |
371 | { |
372 | int ret = -1; | |
373 | ||
ac0c6bdd | 374 | if (!clock_class) { |
5134570b | 375 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); |
87d76bb1 JG |
376 | goto end; |
377 | } | |
378 | ||
ac0c6bdd | 379 | ret = clock_class->absolute; |
87d76bb1 JG |
380 | end: |
381 | return ret; | |
382 | } | |
383 | ||
ac0c6bdd | 384 | int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class, |
a2b94977 | 385 | bt_bool is_absolute) |
273b65be JG |
386 | { |
387 | int ret = 0; | |
388 | ||
5134570b PP |
389 | if (!clock_class) { |
390 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
391 | ret = -1; | |
392 | goto end; | |
393 | } | |
394 | ||
395 | if (clock_class->frozen) { | |
2cf0acd7 PP |
396 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
397 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
273b65be JG |
398 | ret = -1; |
399 | goto end; | |
400 | } | |
401 | ||
ac0c6bdd | 402 | clock_class->absolute = !!is_absolute; |
2cf0acd7 PP |
403 | BT_LOGV("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d", |
404 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
405 | is_absolute); | |
273b65be JG |
406 | end: |
407 | return ret; | |
408 | } | |
409 | ||
ac0c6bdd PP |
410 | const unsigned char *bt_ctf_clock_class_get_uuid( |
411 | struct bt_ctf_clock_class *clock_class) | |
85b743f4 JG |
412 | { |
413 | const unsigned char *ret; | |
414 | ||
5134570b PP |
415 | if (!clock_class) { |
416 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
417 | ret = NULL; | |
418 | goto end; | |
419 | } | |
420 | ||
421 | if (!clock_class->uuid_set) { | |
2cf0acd7 PP |
422 | BT_LOGV("Clock class's UUID is not set: addr=%p, name=\"%s\"", |
423 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
85b743f4 JG |
424 | ret = NULL; |
425 | goto end; | |
426 | } | |
427 | ||
ac0c6bdd | 428 | ret = clock_class->uuid; |
85b743f4 JG |
429 | end: |
430 | return ret; | |
431 | } | |
432 | ||
ac0c6bdd PP |
433 | int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class, |
434 | const unsigned char *uuid) | |
85b743f4 JG |
435 | { |
436 | int ret = 0; | |
437 | ||
5134570b PP |
438 | if (!clock_class || !uuid) { |
439 | BT_LOGW("Invalid parameter: clock class or UUID is NULL: " | |
2cf0acd7 PP |
440 | "clock-class-addr=%p, name=\"%s\", uuid-addr=%p", |
441 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
442 | uuid); | |
5134570b PP |
443 | ret = -1; |
444 | goto end; | |
445 | } | |
446 | ||
447 | if (clock_class->frozen) { | |
2cf0acd7 PP |
448 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", |
449 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
85b743f4 JG |
450 | ret = -1; |
451 | goto end; | |
452 | } | |
453 | ||
20eee76e | 454 | memcpy(clock_class->uuid, uuid, BABELTRACE_UUID_LEN); |
ac0c6bdd | 455 | clock_class->uuid_set = 1; |
2cf0acd7 | 456 | BT_LOGV("Set clock class's UUID: addr=%p, name=\"%s\", " |
5134570b | 457 | "uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"", |
2cf0acd7 | 458 | clock_class, bt_ctf_clock_class_get_name(clock_class), |
5134570b PP |
459 | (unsigned int) uuid[0], |
460 | (unsigned int) uuid[1], | |
461 | (unsigned int) uuid[2], | |
462 | (unsigned int) uuid[3], | |
463 | (unsigned int) uuid[4], | |
464 | (unsigned int) uuid[5], | |
465 | (unsigned int) uuid[6], | |
466 | (unsigned int) uuid[7], | |
467 | (unsigned int) uuid[8], | |
468 | (unsigned int) uuid[9], | |
469 | (unsigned int) uuid[10], | |
470 | (unsigned int) uuid[11], | |
471 | (unsigned int) uuid[12], | |
472 | (unsigned int) uuid[13], | |
473 | (unsigned int) uuid[14], | |
474 | (unsigned int) uuid[15]); | |
85b743f4 JG |
475 | end: |
476 | return ret; | |
477 | } | |
478 | ||
ac0c6bdd | 479 | static uint64_t ns_from_value(uint64_t frequency, uint64_t value) |
4ef18cab PP |
480 | { |
481 | uint64_t ns; | |
482 | ||
483 | if (frequency == 1000000000) { | |
484 | ns = value; | |
485 | } else { | |
486 | ns = (uint64_t) ((1e9 * (double) value) / (double) frequency); | |
487 | } | |
488 | ||
489 | return ns; | |
490 | } | |
491 | ||
273b65be | 492 | BT_HIDDEN |
ac0c6bdd | 493 | void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class) |
273b65be | 494 | { |
ac0c6bdd | 495 | if (!clock_class) { |
5134570b | 496 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); |
273b65be JG |
497 | return; |
498 | } | |
499 | ||
5134570b | 500 | if (!clock_class->frozen) { |
2cf0acd7 PP |
501 | BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"", |
502 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
5134570b PP |
503 | clock_class->frozen = 1; |
504 | } | |
273b65be JG |
505 | } |
506 | ||
507 | BT_HIDDEN | |
ac0c6bdd | 508 | void bt_ctf_clock_class_serialize(struct bt_ctf_clock_class *clock_class, |
273b65be JG |
509 | struct metadata_context *context) |
510 | { | |
511 | unsigned char *uuid; | |
512 | ||
5134570b | 513 | BT_LOGD("Serializing clock class's metadata: clock-class-addr=%p, " |
2cf0acd7 PP |
514 | "name=\"%s\", metadata-context-addr=%p", clock_class, |
515 | bt_ctf_clock_class_get_name(clock_class), context); | |
5134570b | 516 | |
ac0c6bdd | 517 | if (!clock_class || !context) { |
5134570b | 518 | BT_LOGW("Invalid parameter: clock class or metadata context is NULL: " |
2cf0acd7 PP |
519 | "clock-class-addr=%p, name=\"%s\", metadata-context-addr=%p", |
520 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
521 | context); | |
273b65be JG |
522 | return; |
523 | } | |
524 | ||
ac0c6bdd | 525 | uuid = clock_class->uuid; |
273b65be JG |
526 | g_string_append(context->string, "clock {\n"); |
527 | g_string_append_printf(context->string, "\tname = %s;\n", | |
ac0c6bdd | 528 | clock_class->name->str); |
273b65be JG |
529 | g_string_append_printf(context->string, |
530 | "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n", | |
531 | uuid[0], uuid[1], uuid[2], uuid[3], | |
532 | uuid[4], uuid[5], uuid[6], uuid[7], | |
533 | uuid[8], uuid[9], uuid[10], uuid[11], | |
534 | uuid[12], uuid[13], uuid[14], uuid[15]); | |
ac0c6bdd | 535 | if (clock_class->description) { |
273b65be | 536 | g_string_append_printf(context->string, "\tdescription = \"%s\";\n", |
ac0c6bdd | 537 | clock_class->description->str); |
273b65be JG |
538 | } |
539 | ||
540 | g_string_append_printf(context->string, "\tfreq = %" PRIu64 ";\n", | |
ac0c6bdd | 541 | clock_class->frequency); |
273b65be | 542 | g_string_append_printf(context->string, "\tprecision = %" PRIu64 ";\n", |
ac0c6bdd | 543 | clock_class->precision); |
273b65be | 544 | g_string_append_printf(context->string, "\toffset_s = %" PRIu64 ";\n", |
ac0c6bdd | 545 | clock_class->offset_s); |
273b65be | 546 | g_string_append_printf(context->string, "\toffset = %" PRIu64 ";\n", |
ac0c6bdd | 547 | clock_class->offset); |
273b65be | 548 | g_string_append_printf(context->string, "\tabsolute = %s;\n", |
ac0c6bdd | 549 | clock_class->absolute ? "TRUE" : "FALSE"); |
273b65be JG |
550 | g_string_append(context->string, "};\n\n"); |
551 | } | |
552 | ||
273b65be | 553 | static |
ac0c6bdd | 554 | void bt_ctf_clock_class_destroy(struct bt_object *obj) |
273b65be | 555 | { |
ac0c6bdd | 556 | struct bt_ctf_clock_class *clock_class; |
273b65be | 557 | |
ac0c6bdd | 558 | clock_class = container_of(obj, struct bt_ctf_clock_class, base); |
2cf0acd7 PP |
559 | BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"", |
560 | obj, bt_ctf_clock_class_get_name(clock_class)); | |
ac0c6bdd PP |
561 | if (clock_class->name) { |
562 | g_string_free(clock_class->name, TRUE); | |
273b65be | 563 | } |
ac0c6bdd PP |
564 | if (clock_class->description) { |
565 | g_string_free(clock_class->description, TRUE); | |
273b65be JG |
566 | } |
567 | ||
ac0c6bdd | 568 | g_free(clock_class); |
273b65be | 569 | } |
4ef18cab | 570 | |
61ec14e6 JG |
571 | static |
572 | void bt_ctf_clock_value_destroy(struct bt_object *obj) | |
573 | { | |
574 | struct bt_ctf_clock_value *value; | |
575 | ||
576 | if (!obj) { | |
577 | return; | |
578 | } | |
579 | ||
580 | value = container_of(obj, struct bt_ctf_clock_value, base); | |
2cf0acd7 PP |
581 | BT_LOGD("Destroying clock value: addr=%p, clock-class-addr=%p, " |
582 | "clock-class-name=\"%s\"", obj, value->clock_class, | |
583 | bt_ctf_clock_class_get_name(value->clock_class)); | |
61ec14e6 JG |
584 | bt_put(value->clock_class); |
585 | g_free(value); | |
586 | } | |
587 | ||
588 | struct bt_ctf_clock_value *bt_ctf_clock_value_create( | |
ac0c6bdd | 589 | struct bt_ctf_clock_class *clock_class, uint64_t value) |
4ef18cab | 590 | { |
61ec14e6 | 591 | struct bt_ctf_clock_value *ret = NULL; |
4ef18cab | 592 | |
5134570b | 593 | BT_LOGD("Creating clock value object: clock-class-addr=%p, " |
2cf0acd7 PP |
594 | "clock-class-name=\"%s\", value=%" PRIu64, clock_class, |
595 | bt_ctf_clock_class_get_name(clock_class), value); | |
5134570b | 596 | |
ac0c6bdd | 597 | if (!clock_class) { |
5134570b | 598 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); |
4ef18cab PP |
599 | goto end; |
600 | } | |
601 | ||
61ec14e6 JG |
602 | ret = g_new0(struct bt_ctf_clock_value, 1); |
603 | if (!ret) { | |
5134570b | 604 | BT_LOGE_STR("Failed to allocate one clock value."); |
61ec14e6 JG |
605 | goto end; |
606 | } | |
607 | ||
608 | bt_object_init(ret, bt_ctf_clock_value_destroy); | |
ac0c6bdd | 609 | ret->clock_class = bt_get(clock_class); |
61ec14e6 | 610 | ret->value = value; |
2cf0acd7 PP |
611 | BT_LOGD("Created clock value object: clock-value-addr=%p, " |
612 | "clock-class-addr=%p, clock-class-name=\"%s\"", | |
613 | ret, clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
61ec14e6 JG |
614 | end: |
615 | return ret; | |
616 | } | |
4ef18cab | 617 | |
61ec14e6 JG |
618 | int bt_ctf_clock_value_get_value( |
619 | struct bt_ctf_clock_value *clock_value, uint64_t *raw_value) | |
620 | { | |
621 | int ret = 0; | |
4ef18cab | 622 | |
61ec14e6 | 623 | if (!clock_value || !raw_value) { |
5134570b PP |
624 | BT_LOGW("Invalid parameter: clock value or raw value is NULL: " |
625 | "clock-value-addr=%p, raw-value-addr=%p", | |
626 | clock_value, raw_value); | |
61ec14e6 JG |
627 | ret = -1; |
628 | goto end; | |
629 | } | |
4ef18cab | 630 | |
61ec14e6 | 631 | *raw_value = clock_value->value; |
4ef18cab | 632 | end: |
61ec14e6 JG |
633 | return ret; |
634 | } | |
635 | ||
1556a1af | 636 | int bt_ctf_clock_value_get_value_ns_from_epoch(struct bt_ctf_clock_value *value, |
61ec14e6 JG |
637 | int64_t *ret_value_ns) |
638 | { | |
639 | int ret = 0; | |
640 | int64_t ns; | |
641 | ||
642 | if (!value || !ret_value_ns) { | |
5134570b PP |
643 | BT_LOGW("Invalid parameter: clock value or return value pointer is NULL: " |
644 | "clock-value-addr=%p, ret-value-addr=%p", | |
645 | value, ret_value_ns); | |
61ec14e6 JG |
646 | ret = -1; |
647 | goto end; | |
648 | } | |
649 | ||
650 | /* Initialize nanosecond timestamp to clock's offset in seconds. */ | |
9ac68eb1 | 651 | ns = value->clock_class->offset_s * (int64_t) 1000000000; |
61ec14e6 JG |
652 | |
653 | /* Add offset in cycles, converted to nanoseconds. */ | |
654 | ns += ns_from_value(value->clock_class->frequency, | |
655 | value->clock_class->offset); | |
656 | ||
657 | /* Add given value, converter to nanoseconds. */ | |
658 | ns += ns_from_value(value->clock_class->frequency, value->value); | |
659 | ||
660 | *ret_value_ns = ns; | |
661 | end: | |
662 | return ret; | |
4ef18cab | 663 | } |
6f57e458 PP |
664 | |
665 | struct bt_ctf_clock_class *bt_ctf_clock_value_get_class( | |
666 | struct bt_ctf_clock_value *clock_value) | |
667 | { | |
668 | struct bt_ctf_clock_class *clock_class = NULL; | |
669 | ||
670 | if (!clock_value) { | |
5134570b | 671 | BT_LOGW_STR("Invalid parameter: clock value is NULL."); |
6f57e458 PP |
672 | goto end; |
673 | } | |
674 | ||
675 | clock_class = bt_get(clock_value->clock_class); | |
676 | ||
677 | end: | |
678 | return clock_class; | |
679 | } |