lib: use common precond. assert. macros from `assert-cond.h` thru lib
[babeltrace.git] / src / lib / graph / message / discarded-items.c
CommitLineData
4c833281 1/*
0235b0db 2 * SPDX-License-Identifier: MIT
4c833281 3 *
0235b0db 4 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
4c833281
PP
5 */
6
350ad6c1 7#define BT_LOG_TAG "LIB/MSG-DISCARDED-ITEMS"
c2d9d9cf 8#include "lib/logging.h"
4c833281 9
c4f23e30
FD
10#include <stdbool.h>
11
d98421f2 12#include "lib/assert-cond.h"
578e048b
MJ
13#include "lib/object.h"
14#include "compat/compiler.h"
3fadfbc0 15#include <babeltrace2/trace-ir/clock-class.h>
578e048b
MJ
16#include "lib/trace-ir/clock-snapshot.h"
17#include "lib/trace-ir/stream-class.h"
18#include "lib/trace-ir/stream.h"
19#include "lib/property.h"
20#include "lib/graph/message/message.h"
4c833281 21
578e048b
MJ
22#include "discarded-items.h"
23
4c833281
PP
24static
25void destroy_discarded_items_message(struct bt_object *obj)
26{
27 struct bt_message_discarded_items *message = (void *) obj;
28
29 BT_LIB_LOGD("Destroying discarded items message: %!+n", message);
30 BT_LIB_LOGD("Putting stream: %!+s", message->stream);
31 BT_OBJECT_PUT_REF_AND_RESET(message->stream);
32
33 if (message->default_begin_cs) {
34 bt_clock_snapshot_recycle(message->default_begin_cs);
35 message->default_begin_cs = NULL;
36 }
37
38 if (message->default_end_cs) {
39 bt_clock_snapshot_recycle(message->default_end_cs);
40 message->default_end_cs = NULL;
41 }
42
43 g_free(message);
44}
45
46static inline
47struct bt_message *create_discarded_items_message(
48 struct bt_self_message_iterator *self_msg_iter,
49 enum bt_message_type type, struct bt_stream *stream,
50 bool with_cs,
51 uint64_t beginning_raw_value, uint64_t end_raw_value)
52{
53 struct bt_message_discarded_items *message;
54 struct bt_stream_class *stream_class;
2e90378a 55 bool has_support;
8cc5f12b 56 bool need_cs;
4c833281 57
d5b13b9b
PP
58 BT_ASSERT_PRE_MSG_ITER_NON_NULL(self_msg_iter);
59 BT_ASSERT_PRE_STREAM_NON_NULL(stream);
4c833281
PP
60 stream_class = bt_stream_borrow_class(stream);
61 BT_ASSERT(stream_class);
2e90378a
PP
62
63 if (type == BT_MESSAGE_TYPE_DISCARDED_EVENTS) {
64 has_support = stream_class->supports_discarded_events;
8cc5f12b 65 need_cs = stream_class->discarded_events_have_default_clock_snapshots;
2e90378a
PP
66 } else {
67 has_support = stream_class->supports_discarded_packets;
8cc5f12b 68 need_cs = stream_class->discarded_packets_have_default_clock_snapshots;
2e90378a
PP
69 }
70
71 BT_ASSERT_PRE(has_support,
72 "Stream class does not support discarded events or packets: "
73 "type=%s, %![stream-]+s, %![sc-]+S",
74 bt_message_type_string(type), stream, stream_class);
8cc5f12b 75 BT_ASSERT_PRE(need_cs ? with_cs : true,
2e90378a 76 "Unexpected stream class configuration when creating "
8cc5f12b
PP
77 "a discarded events or discarded packets message: "
78 "default clock snapshots are needed, but none was provided: "
79 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
80 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
81 bt_message_type_string(type), stream, stream_class,
82 with_cs, beginning_raw_value, end_raw_value);
83 BT_ASSERT_PRE(!need_cs ? !with_cs : true,
84 "Unexpected stream class configuration when creating "
85 "a discarded events or discarded packets message: "
86 "no default clock snapshots are needed, but two were provided: "
aa12059b
PP
87 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
88 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
89 bt_message_type_string(type), stream, stream_class,
90 with_cs, beginning_raw_value, end_raw_value);
4c833281
PP
91 BT_LIB_LOGD("Creating discarded items message object: "
92 "type=%s, %![stream-]+s, %![sc-]+S, with-cs=%d, "
93 "cs-begin-val=%" PRIu64 ", cs-end-val=%" PRIu64,
94 bt_message_type_string(type), stream, stream_class,
95 with_cs, beginning_raw_value, end_raw_value);
96 message = g_new0(struct bt_message_discarded_items, 1);
97 if (!message) {
870631a2
PP
98 BT_LIB_LOGE_APPEND_CAUSE(
99 "Failed to allocate one discarded items message.");
4c833281
PP
100 goto error;
101 }
102
103 bt_message_init(&message->parent, type,
104 destroy_discarded_items_message, NULL);
105 message->stream = stream;
6871026b 106 bt_object_get_ref_no_null_check(message->stream);
4c833281
PP
107
108 if (with_cs) {
aa12059b 109 BT_ASSERT(stream_class->default_clock_class);
4c833281
PP
110 message->default_begin_cs = bt_clock_snapshot_create(
111 stream_class->default_clock_class);
112 if (!message->default_begin_cs) {
113 goto error;
114 }
115
116 bt_clock_snapshot_set_raw_value(message->default_begin_cs,
117 beginning_raw_value);
118
119 message->default_end_cs = bt_clock_snapshot_create(
120 stream_class->default_clock_class);
121 if (!message->default_end_cs) {
122 goto error;
123 }
124
125 bt_clock_snapshot_set_raw_value(message->default_end_cs,
126 end_raw_value);
127 }
128
129 bt_property_uint_init(&message->count,
130 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE, 0);
131 BT_LIB_LOGD("Created discarded items message object: "
132 "%![msg-]+n, %![stream-]+s, %![sc-]+S", message,
133 stream, stream_class);
134
135 return (void *) &message->parent;
136
137error:
138 return NULL;
139}
140
141static inline
142struct bt_stream *borrow_discarded_items_message_stream(
143 struct bt_message *message)
144{
145 struct bt_message_discarded_items *disc_items_msg = (void *) message;
146
98b15851 147 BT_ASSERT_DBG(message);
4c833281
PP
148 return disc_items_msg->stream;
149}
150
151static inline
152void set_discarded_items_message_count(struct bt_message *message,
153 uint64_t count)
154{
155 struct bt_message_discarded_items *disc_items_msg = (void *) message;
156
157 BT_ASSERT(message);
d5b13b9b 158 BT_ASSERT_PRE_DEV_MSG_HOT(message);
4c833281
PP
159 bt_property_uint_set(&disc_items_msg->count, count);
160}
161
162static inline
163enum bt_property_availability get_discarded_items_message_count(
164 const struct bt_message *message, uint64_t *count)
165{
166 struct bt_message_discarded_items *disc_items_msg = (void *) message;
167
bdb288b3 168 BT_ASSERT_PRE_DEV_NON_NULL(count, "Count (output)");
98b15851 169 BT_ASSERT_DBG(message);
4c833281
PP
170 *count = disc_items_msg->count.value;
171 return disc_items_msg->count.base.avail;
172}
173
174static inline
0cbc2c33 175const struct bt_clock_snapshot *
9b24b6aa 176borrow_discarded_items_message_beginning_default_clock_snapshot_const(
0cbc2c33 177 const struct bt_message *message)
4c833281
PP
178{
179 struct bt_message_discarded_items *disc_items_msg = (void *) message;
180
98b15851 181 BT_ASSERT_DBG(message);
d5b13b9b
PP
182 BT_ASSERT_PRE_DEV_MSG_SC_DEF_CLK_CLS(message,
183 disc_items_msg->stream->class);
0cbc2c33 184 return disc_items_msg->default_begin_cs;
4c833281
PP
185}
186
187static inline
0cbc2c33 188const struct bt_clock_snapshot *
9b24b6aa 189borrow_discarded_items_message_end_default_clock_snapshot_const(
0cbc2c33 190 const struct bt_message *message)
4c833281
PP
191{
192 struct bt_message_discarded_items *disc_items_msg = (void *) message;
193
98b15851 194 BT_ASSERT_DBG(message);
d5b13b9b
PP
195 BT_ASSERT_PRE_DEV_MSG_SC_DEF_CLK_CLS(message,
196 disc_items_msg->stream->class);
0cbc2c33 197 return disc_items_msg->default_end_cs;
4c833281
PP
198}
199
200struct bt_message *bt_message_discarded_events_create(
201 struct bt_self_message_iterator *message_iterator,
58085ca4 202 const struct bt_stream *stream)
4c833281 203{
17f3083a
SM
204 BT_ASSERT_PRE_DEV_NO_ERROR();
205
4c833281 206 return create_discarded_items_message(message_iterator,
58085ca4 207 BT_MESSAGE_TYPE_DISCARDED_EVENTS, (void *) stream,
4c833281
PP
208 false, 0, 0);
209}
210
211struct bt_message *bt_message_discarded_events_create_with_default_clock_snapshots(
212 struct bt_self_message_iterator *message_iterator,
58085ca4 213 const struct bt_stream *stream, uint64_t beginning_raw_value,
4c833281
PP
214 uint64_t end_raw_value)
215{
17f3083a 216 BT_ASSERT_PRE_DEV_NO_ERROR();
d5b13b9b
PP
217 BT_ASSERT_PRE_BEGIN_LE_END(message_iterator,
218 beginning_raw_value, end_raw_value);
17f3083a 219
4c833281 220 return create_discarded_items_message(message_iterator,
58085ca4 221 BT_MESSAGE_TYPE_DISCARDED_EVENTS, (void *) stream,
4c833281
PP
222 true, beginning_raw_value, end_raw_value);
223}
224
225struct bt_stream *bt_message_discarded_events_borrow_stream(
226 struct bt_message *message)
227{
d5b13b9b
PP
228 BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
229 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message,
230 BT_MESSAGE_TYPE_DISCARDED_EVENTS);
4c833281
PP
231 return borrow_discarded_items_message_stream(message);
232}
233
234void bt_message_discarded_events_set_count(struct bt_message *message,
235 uint64_t count)
236{
d5b13b9b 237 BT_ASSERT_PRE_MSG_NON_NULL(message);
0a83319b 238 BT_ASSERT_PRE_MSG_HAS_TYPE(message, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
e5a41ca3 239 BT_ASSERT_PRE(count > 0, "Discarded event count is 0.");
4c833281
PP
240 set_discarded_items_message_count(message, count);
241}
242
0cbc2c33 243const struct bt_clock_snapshot *
9b24b6aa 244bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
0cbc2c33 245 const struct bt_message *msg)
4c833281 246{
d5b13b9b 247 BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
0a83319b 248 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
9b24b6aa 249 return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
0cbc2c33 250 msg);
4c833281
PP
251}
252
0cbc2c33 253const struct bt_clock_snapshot *
9b24b6aa 254bt_message_discarded_events_borrow_end_default_clock_snapshot_const(
0cbc2c33 255 const struct bt_message *msg)
4c833281 256{
d5b13b9b 257 BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
0a83319b 258 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
9b24b6aa 259 return borrow_discarded_items_message_end_default_clock_snapshot_const(
0cbc2c33 260 msg);
4c833281
PP
261}
262
263const struct bt_stream *
264bt_message_discarded_events_borrow_stream_const(const struct bt_message *message)
265{
266 return (void *) bt_message_discarded_events_borrow_stream(
267 (void *) message);
268}
269
270enum bt_property_availability bt_message_discarded_events_get_count(
271 const struct bt_message *message, uint64_t *count)
272{
d5b13b9b 273 BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
0a83319b 274 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message,
bdb288b3 275 BT_MESSAGE_TYPE_DISCARDED_EVENTS);
4c833281
PP
276 return get_discarded_items_message_count(message, count);
277}
4237f1f2
PP
278
279struct bt_message *bt_message_discarded_packets_create(
280 struct bt_self_message_iterator *message_iterator,
58085ca4 281 const struct bt_stream *stream)
4237f1f2 282{
17f3083a
SM
283 BT_ASSERT_PRE_DEV_NO_ERROR();
284
4237f1f2 285 return create_discarded_items_message(message_iterator,
58085ca4 286 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
4237f1f2
PP
287 false, 0, 0);
288}
289
290struct bt_message *bt_message_discarded_packets_create_with_default_clock_snapshots(
291 struct bt_self_message_iterator *message_iterator,
58085ca4 292 const struct bt_stream *stream, uint64_t beginning_raw_value,
4237f1f2
PP
293 uint64_t end_raw_value)
294{
17f3083a 295 BT_ASSERT_PRE_DEV_NO_ERROR();
d5b13b9b
PP
296 BT_ASSERT_PRE_BEGIN_LE_END(message_iterator,
297 beginning_raw_value, end_raw_value);
17f3083a 298
4237f1f2 299 return create_discarded_items_message(message_iterator,
58085ca4 300 BT_MESSAGE_TYPE_DISCARDED_PACKETS, (void *) stream,
4237f1f2
PP
301 true, beginning_raw_value, end_raw_value);
302}
303
304struct bt_stream *bt_message_discarded_packets_borrow_stream(
305 struct bt_message *message)
306{
d5b13b9b 307 BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
0a83319b 308 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message,
bdb288b3 309 BT_MESSAGE_TYPE_DISCARDED_PACKETS);
4237f1f2
PP
310 return borrow_discarded_items_message_stream(message);
311}
312
313void bt_message_discarded_packets_set_count(struct bt_message *message,
314 uint64_t count)
315{
d5b13b9b 316 BT_ASSERT_PRE_MSG_NON_NULL(message);
0a83319b 317 BT_ASSERT_PRE_MSG_HAS_TYPE(message, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
e5a41ca3 318 BT_ASSERT_PRE(count > 0, "Discarded packet count is 0.");
4237f1f2
PP
319 set_discarded_items_message_count(message, count);
320}
321
0cbc2c33 322const struct bt_clock_snapshot *
9b24b6aa 323bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
0cbc2c33 324 const struct bt_message *msg)
4237f1f2 325{
d5b13b9b 326 BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
0a83319b 327 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
9b24b6aa 328 return borrow_discarded_items_message_beginning_default_clock_snapshot_const(
0cbc2c33 329 msg);
4237f1f2
PP
330}
331
0cbc2c33 332const struct bt_clock_snapshot *
9b24b6aa 333bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
0cbc2c33 334 const struct bt_message *msg)
4237f1f2 335{
d5b13b9b 336 BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
0a83319b 337 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
9b24b6aa 338 return borrow_discarded_items_message_end_default_clock_snapshot_const(
0cbc2c33 339 msg);
4237f1f2
PP
340}
341
342const struct bt_stream *
343bt_message_discarded_packets_borrow_stream_const(const struct bt_message *message)
344{
345 return (void *) bt_message_discarded_packets_borrow_stream(
346 (void *) message);
347}
348
349enum bt_property_availability bt_message_discarded_packets_get_count(
350 const struct bt_message *message, uint64_t *count)
351{
d5b13b9b 352 BT_ASSERT_PRE_DEV_MSG_NON_NULL(message);
0a83319b 353 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message,
bdb288b3 354 BT_MESSAGE_TYPE_DISCARDED_PACKETS);
4237f1f2
PP
355 return get_discarded_items_message_count(message, count);
356}
33931ab8
PP
357
358static inline
359const struct bt_clock_class *
360borrow_discarded_items_message_stream_class_default_clock_class(
361 const struct bt_message *msg)
362{
363 struct bt_message_discarded_items *disc_items_msg = (void *) msg;
364
98b15851 365 BT_ASSERT_DBG(msg);
33931ab8
PP
366 return disc_items_msg->stream->class->default_clock_class;
367}
368
369const struct bt_clock_class *
370bt_message_discarded_events_borrow_stream_class_default_clock_class_const(
371 const struct bt_message *msg)
372{
d5b13b9b 373 BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
0a83319b 374 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_EVENTS);
33931ab8
PP
375 return borrow_discarded_items_message_stream_class_default_clock_class(
376 msg);
377}
378
379const struct bt_clock_class *
380bt_message_discarded_packets_borrow_stream_class_default_clock_class_const(
381 const struct bt_message *msg)
382{
d5b13b9b 383 BT_ASSERT_PRE_DEV_MSG_NON_NULL(msg);
0a83319b 384 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg, BT_MESSAGE_TYPE_DISCARDED_PACKETS);
33931ab8
PP
385 return borrow_discarded_items_message_stream_class_default_clock_class(
386 msg);
387}
This page took 0.073435 seconds and 4 git commands to generate.