Commit | Line | Data |
---|---|---|
16ca5ff0 PP |
1 | /* |
2 | * clock-class.c | |
3 | * | |
4 | * Babeltrace CTF writer - Clock class | |
5 | * | |
6 | * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
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 | ||
350ad6c1 | 29 | #define BT_LOG_TAG "CTF-WRITER/CLOCK-CLASS" |
67d2ce02 | 30 | #include "logging.h" |
16ca5ff0 | 31 | |
6162e6b7 | 32 | #include "common/uuid.h" |
217cf9d3 PP |
33 | #include <babeltrace2-ctf-writer/utils.h> |
34 | #include <babeltrace2-ctf-writer/object.h> | |
578e048b | 35 | #include "compat/compiler.h" |
3fadfbc0 | 36 | #include <babeltrace2/types.h> |
578e048b | 37 | #include "compat/string.h" |
c4f23e30 | 38 | #include <stdbool.h> |
16ca5ff0 | 39 | #include <inttypes.h> |
578e048b MJ |
40 | #include "common/assert.h" |
41 | ||
42 | #include "assert-pre.h" | |
43 | #include "clock-class.h" | |
44 | #include "object.h" | |
16ca5ff0 PP |
45 | |
46 | static | |
e1e02a22 | 47 | void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj); |
16ca5ff0 PP |
48 | |
49 | BT_HIDDEN | |
00409097 | 50 | bt_ctf_bool bt_ctf_clock_class_is_valid(struct bt_ctf_clock_class *clock_class) |
16ca5ff0 PP |
51 | { |
52 | return clock_class && clock_class->name; | |
53 | } | |
54 | ||
55 | BT_HIDDEN | |
56 | int bt_ctf_clock_class_set_name(struct bt_ctf_clock_class *clock_class, | |
57 | const char *name) | |
58 | { | |
59 | int ret = 0; | |
60 | ||
61 | if (!clock_class) { | |
62 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
63 | ret = -1; | |
64 | goto end; | |
65 | } | |
66 | ||
67 | if (clock_class->frozen) { | |
68 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
69 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
70 | ret = -1; | |
71 | goto end; | |
72 | } | |
73 | ||
74 | if (!bt_ctf_identifier_is_valid(name)) { | |
75 | BT_LOGW("Clock class's name is not a valid CTF identifier: " | |
76 | "addr=%p, name=\"%s\"", | |
77 | clock_class, name); | |
78 | ret = -1; | |
79 | goto end; | |
80 | } | |
81 | ||
82 | if (clock_class->name) { | |
83 | g_string_assign(clock_class->name, name); | |
84 | } else { | |
85 | clock_class->name = g_string_new(name); | |
86 | if (!clock_class->name) { | |
87 | BT_LOGE_STR("Failed to allocate a GString."); | |
88 | ret = -1; | |
89 | goto end; | |
90 | } | |
91 | } | |
92 | ||
ef267d12 | 93 | BT_LOGT("Set clock class's name: addr=%p, name=\"%s\"", |
16ca5ff0 PP |
94 | clock_class, name); |
95 | ||
96 | end: | |
97 | return ret; | |
98 | } | |
99 | ||
100 | static | |
101 | bool validate_freq(struct bt_ctf_clock_class *clock_class, | |
102 | const char *name, uint64_t freq) | |
103 | { | |
104 | bool is_valid = true; | |
105 | ||
106 | if (freq == -1ULL || freq == 0) { | |
107 | BT_LOGW("Invalid parameter: frequency is invalid: " | |
108 | "addr=%p, name=\"%s\", freq=%" PRIu64, | |
109 | clock_class, name, freq); | |
110 | is_valid = false; | |
111 | goto end; | |
112 | } | |
113 | ||
114 | end: | |
115 | return is_valid; | |
116 | } | |
117 | ||
118 | BT_HIDDEN | |
119 | struct bt_ctf_clock_class *bt_ctf_clock_class_create(const char *name, | |
120 | uint64_t freq) | |
121 | { | |
122 | int ret; | |
123 | struct bt_ctf_clock_class *clock_class = NULL; | |
124 | ||
125 | BT_LOGD("Creating default clock class object: name=\"%s\"", | |
126 | name); | |
127 | ||
128 | if (!validate_freq(NULL, name, freq)) { | |
129 | /* validate_freq() logs errors */ | |
130 | goto error; | |
131 | } | |
132 | ||
133 | clock_class = g_new0(struct bt_ctf_clock_class, 1); | |
134 | if (!clock_class) { | |
135 | BT_LOGE_STR("Failed to allocate one clock class."); | |
136 | goto error; | |
137 | } | |
138 | ||
139 | clock_class->precision = 1; | |
140 | clock_class->frequency = freq; | |
e1e02a22 | 141 | bt_ctf_object_init_shared(&clock_class->base, bt_ctf_clock_class_destroy); |
16ca5ff0 PP |
142 | |
143 | if (name) { | |
144 | ret = bt_ctf_clock_class_set_name(clock_class, name); | |
145 | if (ret) { | |
146 | /* bt_ctf_clock_class_set_name() logs errors */ | |
147 | goto error; | |
148 | } | |
149 | } | |
150 | ||
151 | BT_LOGD("Created clock class object: addr=%p, name=\"%s\"", | |
152 | clock_class, name); | |
153 | return clock_class; | |
154 | error: | |
e1e02a22 | 155 | BT_CTF_OBJECT_PUT_REF_AND_RESET(clock_class); |
16ca5ff0 PP |
156 | return clock_class; |
157 | } | |
158 | ||
159 | BT_HIDDEN | |
160 | const char *bt_ctf_clock_class_get_name(struct bt_ctf_clock_class *clock_class) | |
161 | { | |
162 | const char *ret = NULL; | |
163 | ||
164 | if (!clock_class) { | |
165 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
166 | goto end; | |
167 | } | |
168 | ||
169 | if (clock_class->name) { | |
170 | ret = clock_class->name->str; | |
171 | } | |
172 | ||
173 | end: | |
174 | return ret; | |
175 | } | |
176 | ||
177 | BT_HIDDEN | |
178 | const char *bt_ctf_clock_class_get_description( | |
179 | struct bt_ctf_clock_class *clock_class) | |
180 | { | |
181 | const char *ret = NULL; | |
182 | ||
183 | if (!clock_class) { | |
184 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
185 | goto end; | |
186 | } | |
187 | ||
188 | if (clock_class->description) { | |
189 | ret = clock_class->description->str; | |
190 | } | |
191 | end: | |
192 | return ret; | |
193 | } | |
194 | ||
195 | BT_HIDDEN | |
196 | int bt_ctf_clock_class_set_description(struct bt_ctf_clock_class *clock_class, | |
197 | const char *desc) | |
198 | { | |
199 | int ret = 0; | |
200 | ||
201 | if (!clock_class || !desc) { | |
202 | BT_LOGW("Invalid parameter: clock class or description is NULL: " | |
203 | "clock-class-addr=%p, name=\"%s\", desc-addr=%p", | |
204 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
205 | desc); | |
206 | ret = -1; | |
207 | goto end; | |
208 | } | |
209 | ||
210 | if (clock_class->frozen) { | |
211 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
212 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
213 | ret = -1; | |
214 | goto end; | |
215 | } | |
216 | ||
217 | clock_class->description = g_string_new(desc); | |
218 | ret = clock_class->description ? 0 : -1; | |
ef267d12 | 219 | BT_LOGT("Set clock class's description: addr=%p, " |
16ca5ff0 PP |
220 | "name=\"%s\", desc=\"%s\"", |
221 | clock_class, bt_ctf_clock_class_get_name(clock_class), desc); | |
222 | end: | |
223 | return ret; | |
224 | } | |
225 | ||
226 | BT_HIDDEN | |
227 | uint64_t bt_ctf_clock_class_get_frequency( | |
228 | struct bt_ctf_clock_class *clock_class) | |
229 | { | |
230 | uint64_t ret = -1ULL; | |
231 | ||
232 | if (!clock_class) { | |
233 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
234 | goto end; | |
235 | } | |
236 | ||
237 | ret = clock_class->frequency; | |
238 | end: | |
239 | return ret; | |
240 | } | |
241 | ||
242 | BT_HIDDEN | |
243 | int bt_ctf_clock_class_set_frequency(struct bt_ctf_clock_class *clock_class, | |
244 | uint64_t freq) | |
245 | { | |
246 | int ret = 0; | |
247 | ||
248 | if (!clock_class) { | |
249 | BT_LOGW("Invalid parameter: clock class is NULL or frequency is invalid: " | |
250 | "addr=%p, name=\"%s\"", | |
251 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
252 | ret = -1; | |
253 | goto end; | |
254 | } | |
255 | ||
256 | if (!validate_freq(clock_class, bt_ctf_clock_class_get_name(clock_class), | |
257 | freq)) { | |
258 | /* validate_freq() logs errors */ | |
259 | goto end; | |
260 | } | |
261 | ||
262 | if (clock_class->frozen) { | |
263 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
264 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
265 | ret = -1; | |
266 | goto end; | |
267 | } | |
268 | ||
269 | clock_class->frequency = freq; | |
ef267d12 | 270 | BT_LOGT("Set clock class's frequency: addr=%p, name=\"%s\", freq=%" PRIu64, |
16ca5ff0 PP |
271 | clock_class, bt_ctf_clock_class_get_name(clock_class), freq); |
272 | end: | |
273 | return ret; | |
274 | } | |
275 | ||
276 | BT_HIDDEN | |
277 | uint64_t bt_ctf_clock_class_get_precision(struct bt_ctf_clock_class *clock_class) | |
278 | { | |
279 | uint64_t ret = -1ULL; | |
280 | ||
281 | if (!clock_class) { | |
282 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
283 | goto end; | |
284 | } | |
285 | ||
286 | ret = clock_class->precision; | |
287 | end: | |
288 | return ret; | |
289 | } | |
290 | ||
291 | BT_HIDDEN | |
292 | int bt_ctf_clock_class_set_precision(struct bt_ctf_clock_class *clock_class, | |
293 | uint64_t precision) | |
294 | { | |
295 | int ret = 0; | |
296 | ||
297 | if (!clock_class || precision == -1ULL) { | |
298 | BT_LOGW("Invalid parameter: clock class is NULL or precision is invalid: " | |
299 | "addr=%p, name=\"%s\", precision=%" PRIu64, | |
300 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
301 | precision); | |
302 | ret = -1; | |
303 | goto end; | |
304 | } | |
305 | ||
306 | if (clock_class->frozen) { | |
307 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
308 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
309 | ret = -1; | |
310 | goto end; | |
311 | } | |
312 | ||
313 | clock_class->precision = precision; | |
ef267d12 | 314 | BT_LOGT("Set clock class's precision: addr=%p, name=\"%s\", precision=%" PRIu64, |
16ca5ff0 PP |
315 | clock_class, bt_ctf_clock_class_get_name(clock_class), |
316 | precision); | |
317 | end: | |
318 | return ret; | |
319 | } | |
320 | ||
321 | BT_HIDDEN | |
322 | int bt_ctf_clock_class_get_offset_s(struct bt_ctf_clock_class *clock_class, | |
323 | int64_t *offset_s) | |
324 | { | |
325 | int ret = 0; | |
326 | ||
327 | if (!clock_class || !offset_s) { | |
328 | BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: " | |
329 | "clock-class-addr=%p, name=\"%s\", offset-addr=%p", | |
330 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
331 | offset_s); | |
332 | ret = -1; | |
333 | goto end; | |
334 | } | |
335 | ||
336 | *offset_s = clock_class->offset_s; | |
337 | end: | |
338 | return ret; | |
339 | } | |
340 | ||
341 | BT_HIDDEN | |
342 | int bt_ctf_clock_class_set_offset_s(struct bt_ctf_clock_class *clock_class, | |
343 | int64_t offset_s) | |
344 | { | |
345 | int ret = 0; | |
346 | ||
347 | if (!clock_class) { | |
348 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
349 | ret = -1; | |
350 | goto end; | |
351 | } | |
352 | ||
353 | if (clock_class->frozen) { | |
354 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
355 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
356 | ret = -1; | |
357 | goto end; | |
358 | } | |
359 | ||
360 | clock_class->offset_s = offset_s; | |
ef267d12 | 361 | BT_LOGT("Set clock class's offset (seconds): " |
16ca5ff0 PP |
362 | "addr=%p, name=\"%s\", offset-s=%" PRId64, |
363 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
364 | offset_s); | |
365 | end: | |
366 | return ret; | |
367 | } | |
368 | ||
369 | BT_HIDDEN | |
370 | int bt_ctf_clock_class_get_offset_cycles(struct bt_ctf_clock_class *clock_class, | |
371 | int64_t *offset) | |
372 | { | |
373 | int ret = 0; | |
374 | ||
375 | if (!clock_class || !offset) { | |
376 | BT_LOGW("Invalid parameter: clock class or offset pointer is NULL: " | |
377 | "clock-class-addr=%p, name=\"%s\", offset-addr=%p", | |
378 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
379 | offset); | |
380 | ret = -1; | |
381 | goto end; | |
382 | } | |
383 | ||
384 | *offset = clock_class->offset; | |
385 | end: | |
386 | return ret; | |
387 | } | |
388 | ||
389 | BT_HIDDEN | |
390 | int bt_ctf_clock_class_set_offset_cycles(struct bt_ctf_clock_class *clock_class, | |
391 | int64_t offset) | |
392 | { | |
393 | int ret = 0; | |
394 | ||
395 | if (!clock_class) { | |
396 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
397 | ret = -1; | |
398 | goto end; | |
399 | } | |
400 | ||
401 | if (clock_class->frozen) { | |
402 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
403 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
404 | ret = -1; | |
405 | goto end; | |
406 | } | |
407 | ||
408 | clock_class->offset = offset; | |
ef267d12 | 409 | BT_LOGT("Set clock class's offset (cycles): addr=%p, name=\"%s\", offset-cycles=%" PRId64, |
16ca5ff0 PP |
410 | clock_class, bt_ctf_clock_class_get_name(clock_class), offset); |
411 | end: | |
412 | return ret; | |
413 | } | |
414 | ||
415 | BT_HIDDEN | |
00409097 | 416 | bt_ctf_bool bt_ctf_clock_class_is_absolute(struct bt_ctf_clock_class *clock_class) |
16ca5ff0 PP |
417 | { |
418 | int ret = -1; | |
419 | ||
420 | if (!clock_class) { | |
421 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
422 | goto end; | |
423 | } | |
424 | ||
425 | ret = clock_class->absolute; | |
426 | end: | |
427 | return ret; | |
428 | } | |
429 | ||
430 | BT_HIDDEN | |
431 | int bt_ctf_clock_class_set_is_absolute(struct bt_ctf_clock_class *clock_class, | |
00409097 | 432 | bt_ctf_bool is_absolute) |
16ca5ff0 PP |
433 | { |
434 | int ret = 0; | |
435 | ||
436 | if (!clock_class) { | |
437 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
438 | ret = -1; | |
439 | goto end; | |
440 | } | |
441 | ||
442 | if (clock_class->frozen) { | |
443 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
444 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
445 | ret = -1; | |
446 | goto end; | |
447 | } | |
448 | ||
449 | clock_class->absolute = !!is_absolute; | |
ef267d12 | 450 | BT_LOGT("Set clock class's absolute flag: addr=%p, name=\"%s\", is-absolute=%d", |
16ca5ff0 PP |
451 | clock_class, bt_ctf_clock_class_get_name(clock_class), |
452 | is_absolute); | |
453 | end: | |
454 | return ret; | |
455 | } | |
456 | ||
457 | BT_HIDDEN | |
6162e6b7 | 458 | const uint8_t *bt_ctf_clock_class_get_uuid( |
16ca5ff0 PP |
459 | struct bt_ctf_clock_class *clock_class) |
460 | { | |
6162e6b7 | 461 | const uint8_t *ret; |
16ca5ff0 PP |
462 | |
463 | if (!clock_class) { | |
464 | BT_LOGW_STR("Invalid parameter: clock class is NULL."); | |
465 | ret = NULL; | |
466 | goto end; | |
467 | } | |
468 | ||
469 | if (!clock_class->uuid_set) { | |
ef267d12 | 470 | BT_LOGT("Clock class's UUID is not set: addr=%p, name=\"%s\"", |
16ca5ff0 PP |
471 | clock_class, bt_ctf_clock_class_get_name(clock_class)); |
472 | ret = NULL; | |
473 | goto end; | |
474 | } | |
475 | ||
476 | ret = clock_class->uuid; | |
477 | end: | |
478 | return ret; | |
479 | } | |
480 | ||
481 | BT_HIDDEN | |
482 | int bt_ctf_clock_class_set_uuid(struct bt_ctf_clock_class *clock_class, | |
6162e6b7 | 483 | const uint8_t *uuid) |
16ca5ff0 PP |
484 | { |
485 | int ret = 0; | |
486 | ||
487 | if (!clock_class || !uuid) { | |
488 | BT_LOGW("Invalid parameter: clock class or UUID is NULL: " | |
489 | "clock-class-addr=%p, name=\"%s\", uuid-addr=%p", | |
490 | clock_class, bt_ctf_clock_class_get_name(clock_class), | |
491 | uuid); | |
492 | ret = -1; | |
493 | goto end; | |
494 | } | |
495 | ||
496 | if (clock_class->frozen) { | |
497 | BT_LOGW("Invalid parameter: clock class is frozen: addr=%p, name=\"%s\"", | |
498 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
499 | ret = -1; | |
500 | goto end; | |
501 | } | |
502 | ||
6162e6b7 | 503 | bt_uuid_copy(clock_class->uuid, uuid); |
16ca5ff0 | 504 | clock_class->uuid_set = 1; |
6162e6b7 | 505 | BT_LOGT("Set clock class's UUID: addr=%p, name=\"%s\", uuid=\"" BT_UUID_FMT "\"", |
16ca5ff0 | 506 | clock_class, bt_ctf_clock_class_get_name(clock_class), |
6162e6b7 | 507 | BT_UUID_FMT_VALUES(uuid)); |
16ca5ff0 PP |
508 | end: |
509 | return ret; | |
510 | } | |
511 | ||
512 | BT_HIDDEN | |
513 | void bt_ctf_clock_class_freeze(struct bt_ctf_clock_class *clock_class) | |
514 | { | |
515 | if (!clock_class || clock_class->frozen) { | |
516 | return; | |
517 | } | |
518 | ||
519 | BT_LOGD("Freezing clock class: addr=%p, name=\"%s\"", | |
520 | clock_class, bt_ctf_clock_class_get_name(clock_class)); | |
521 | clock_class->frozen = 1; | |
522 | } | |
523 | ||
524 | static | |
e1e02a22 | 525 | void bt_ctf_clock_class_destroy(struct bt_ctf_object *obj) |
16ca5ff0 PP |
526 | { |
527 | struct bt_ctf_clock_class *clock_class; | |
528 | ||
529 | clock_class = container_of(obj, struct bt_ctf_clock_class, base); | |
530 | BT_LOGD("Destroying clock class: addr=%p, name=\"%s\"", | |
531 | obj, bt_ctf_clock_class_get_name(clock_class)); | |
532 | ||
533 | if (clock_class->name) { | |
534 | g_string_free(clock_class->name, TRUE); | |
535 | } | |
536 | ||
537 | if (clock_class->description) { | |
538 | g_string_free(clock_class->description, TRUE); | |
539 | } | |
540 | ||
541 | g_free(clock_class); | |
542 | } | |
543 | ||
544 | BT_HIDDEN | |
545 | int bt_ctf_clock_class_compare(struct bt_ctf_clock_class *clock_class_a, | |
546 | struct bt_ctf_clock_class *clock_class_b) | |
547 | { | |
548 | int ret = 1; | |
98b15851 PP |
549 | BT_ASSERT_DBG(clock_class_a); |
550 | BT_ASSERT_DBG(clock_class_b); | |
16ca5ff0 PP |
551 | |
552 | /* Name */ | |
553 | if (strcmp(clock_class_a->name->str, clock_class_b->name->str) != 0) { | |
ef267d12 | 554 | BT_LOGT("Clock classes differ: different names: " |
16ca5ff0 PP |
555 | "cc-a-name=\"%s\", cc-b-name=\"%s\"", |
556 | clock_class_a->name->str, | |
557 | clock_class_b->name->str); | |
558 | goto end; | |
559 | } | |
560 | ||
561 | /* Description */ | |
562 | if (clock_class_a->description) { | |
563 | if (!clock_class_b->description) { | |
ef267d12 | 564 | BT_LOGT_STR("Clock classes differ: clock class A has a " |
16ca5ff0 PP |
565 | "description, but clock class B does not."); |
566 | goto end; | |
567 | } | |
568 | ||
569 | if (strcmp(clock_class_a->name->str, clock_class_b->name->str) | |
570 | != 0) { | |
ef267d12 | 571 | BT_LOGT("Clock classes differ: different descriptions: " |
16ca5ff0 PP |
572 | "cc-a-descr=\"%s\", cc-b-descr=\"%s\"", |
573 | clock_class_a->description->str, | |
574 | clock_class_b->description->str); | |
575 | goto end; | |
576 | } | |
577 | } else { | |
578 | if (clock_class_b->description) { | |
ef267d12 | 579 | BT_LOGT_STR("Clock classes differ: clock class A has " |
16ca5ff0 PP |
580 | "no description, but clock class B has one."); |
581 | goto end; | |
582 | } | |
583 | } | |
584 | ||
585 | /* Frequency */ | |
586 | if (clock_class_a->frequency != clock_class_b->frequency) { | |
ef267d12 | 587 | BT_LOGT("Clock classes differ: different frequencies: " |
16ca5ff0 PP |
588 | "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64, |
589 | clock_class_a->frequency, | |
590 | clock_class_b->frequency); | |
591 | goto end; | |
592 | } | |
593 | ||
594 | /* Precision */ | |
595 | if (clock_class_a->precision != clock_class_b->precision) { | |
ef267d12 | 596 | BT_LOGT("Clock classes differ: different precisions: " |
16ca5ff0 PP |
597 | "cc-a-freq=%" PRIu64 ", cc-b-freq=%" PRIu64, |
598 | clock_class_a->precision, | |
599 | clock_class_b->precision); | |
600 | goto end; | |
601 | } | |
602 | ||
603 | /* Offset (seconds) */ | |
604 | if (clock_class_a->offset_s != clock_class_b->offset_s) { | |
ef267d12 | 605 | BT_LOGT("Clock classes differ: different offsets (seconds): " |
16ca5ff0 PP |
606 | "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64, |
607 | clock_class_a->offset_s, | |
608 | clock_class_b->offset_s); | |
609 | goto end; | |
610 | } | |
611 | ||
612 | /* Offset (cycles) */ | |
613 | if (clock_class_a->offset != clock_class_b->offset) { | |
ef267d12 | 614 | BT_LOGT("Clock classes differ: different offsets (cycles): " |
16ca5ff0 PP |
615 | "cc-a-offset-s=%" PRId64 ", cc-b-offset-s=%" PRId64, |
616 | clock_class_a->offset, | |
617 | clock_class_b->offset); | |
618 | goto end; | |
619 | } | |
620 | ||
621 | /* UUIDs */ | |
622 | if (clock_class_a->uuid_set) { | |
623 | if (!clock_class_b->uuid_set) { | |
ef267d12 | 624 | BT_LOGT_STR("Clock classes differ: clock class A has a " |
16ca5ff0 PP |
625 | "UUID, but clock class B does not."); |
626 | goto end; | |
627 | } | |
628 | ||
6162e6b7 | 629 | if (bt_uuid_compare(clock_class_a->uuid, clock_class_b->uuid) != 0) { |
ef267d12 | 630 | BT_LOGT("Clock classes differ: different UUIDs: " |
6162e6b7 MJ |
631 | "cc-a-uuid=\"" BT_UUID_FMT "\", " |
632 | "cc-b-uuid=\"" BT_UUID_FMT "\"", | |
633 | BT_UUID_FMT_VALUES(clock_class_a->uuid), | |
634 | BT_UUID_FMT_VALUES(clock_class_b->uuid)); | |
16ca5ff0 PP |
635 | goto end; |
636 | } | |
637 | } else { | |
638 | if (clock_class_b->uuid_set) { | |
ef267d12 | 639 | BT_LOGT_STR("Clock classes differ: clock class A has " |
16ca5ff0 PP |
640 | "no UUID, but clock class B has one."); |
641 | goto end; | |
642 | } | |
643 | } | |
644 | ||
645 | /* Absolute */ | |
646 | if (!!clock_class_a->absolute != !!clock_class_b->absolute) { | |
ef267d12 | 647 | BT_LOGT("Clock classes differ: one is absolute, the other " |
16ca5ff0 PP |
648 | "is not: cc-a-is-absolute=%d, cc-b-is-absolute=%d", |
649 | !!clock_class_a->absolute, | |
650 | !!clock_class_b->absolute); | |
651 | goto end; | |
652 | } | |
653 | ||
654 | /* Equal */ | |
655 | ret = 0; | |
656 | ||
657 | end: | |
658 | return ret; | |
659 | } |