ad93031f2d667ceb9871561a12809fb2564e8c23
[babeltrace.git] / src / lib / graph / message / stream.c
1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
5 * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
6 */
7
8 #define BT_LOG_TAG "LIB/MSG-STREAM"
9 #include "lib/logging.h"
10
11 #include "lib/assert-cond.h"
12 #include "compat/compiler.h"
13 #include <babeltrace2/trace-ir/clock-snapshot.h>
14 #include "lib/trace-ir/stream.h"
15 #include <babeltrace2/trace-ir/stream-class.h>
16 #include "lib/trace-ir/stream-class.h"
17 #include <babeltrace2/graph/message.h>
18 #include "common/assert.h"
19 #include <inttypes.h>
20
21 #include "stream.h"
22
23 static
24 void destroy_stream_message(struct bt_object *obj)
25 {
26 struct bt_message_stream *message = (void *) obj;
27
28 BT_LIB_LOGD("Destroying stream message: %!+n", message);
29
30 if (message->default_cs) {
31 BT_LIB_LOGD("Putting default clock snapshot: %!+k",
32 message->default_cs);
33 bt_clock_snapshot_destroy(message->default_cs);
34 message->default_cs = NULL;
35 }
36
37 BT_LIB_LOGD("Putting stream: %!+s", message->stream);
38 BT_OBJECT_PUT_REF_AND_RESET(message->stream);
39 g_free(message);
40 }
41
42 static inline
43 struct bt_message *create_stream_message(
44 struct bt_self_message_iterator *self_msg_iter,
45 struct bt_stream *stream, enum bt_message_type type)
46 {
47 struct bt_message_stream *message;
48 struct bt_stream_class *stream_class;
49
50 BT_ASSERT_PRE_NON_NULL(self_msg_iter, "Message iterator");
51 BT_ASSERT_PRE_NON_NULL(stream, "Stream");
52 stream_class = bt_stream_borrow_class(stream);
53 BT_ASSERT(stream_class);
54 BT_LIB_LOGD("Creating stream message object: "
55 "type=%s, %![stream-]+s, %![sc-]+S",
56 bt_message_type_string(type), stream, stream_class);
57 message = g_new0(struct bt_message_stream, 1);
58 if (!message) {
59 BT_LIB_LOGE_APPEND_CAUSE(
60 "Failed to allocate one stream message.");
61 goto error;
62 }
63
64 bt_message_init(&message->parent, type,
65 destroy_stream_message, NULL);
66 message->stream = stream;
67 bt_object_get_ref_no_null_check(message->stream);
68
69 if (stream_class->default_clock_class) {
70 message->default_cs = bt_clock_snapshot_create(
71 stream_class->default_clock_class);
72 if (!message->default_cs) {
73 goto error;
74 }
75 }
76
77 BT_LIB_LOGD("Created stream message object: "
78 "%![msg-]+n, %![stream-]+s, %![sc-]+S", message,
79 stream, stream_class);
80
81 goto end;
82
83 error:
84 if (message) {
85 g_free(message);
86 message = NULL;
87 }
88
89 end:
90 return &message->parent;
91 }
92
93 struct bt_message *bt_message_stream_beginning_create(
94 struct bt_self_message_iterator *self_msg_iter,
95 const struct bt_stream *stream)
96 {
97 BT_ASSERT_PRE_DEV_NO_ERROR();
98
99 return create_stream_message(self_msg_iter, (void *) stream,
100 BT_MESSAGE_TYPE_STREAM_BEGINNING);
101 }
102
103 struct bt_message *bt_message_stream_end_create(
104 struct bt_self_message_iterator *self_msg_iter,
105 const struct bt_stream *stream)
106 {
107 BT_ASSERT_PRE_DEV_NO_ERROR();
108
109 return create_stream_message(self_msg_iter, (void *) stream,
110 BT_MESSAGE_TYPE_STREAM_END);
111 }
112
113 static inline
114 struct bt_stream *borrow_stream_message_stream(struct bt_message *message)
115 {
116 struct bt_message_stream *stream_msg;
117
118 BT_ASSERT_DBG(message);
119 stream_msg = (void *) message;
120 return stream_msg->stream;
121 }
122
123 struct bt_stream *bt_message_stream_beginning_borrow_stream(
124 struct bt_message *message)
125 {
126 BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
127 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message,
128 BT_MESSAGE_TYPE_STREAM_BEGINNING);
129 return borrow_stream_message_stream(message);
130 }
131
132 struct bt_stream *bt_message_stream_end_borrow_stream(
133 struct bt_message *message)
134 {
135 BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
136 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message,
137 BT_MESSAGE_TYPE_STREAM_END);
138 return borrow_stream_message_stream(message);
139 }
140
141 const struct bt_stream *bt_message_stream_beginning_borrow_stream_const(
142 const struct bt_message *message)
143 {
144 return bt_message_stream_beginning_borrow_stream(
145 (void *) message);
146 }
147
148 const struct bt_stream *bt_message_stream_end_borrow_stream_const(
149 const struct bt_message *message)
150 {
151 return bt_message_stream_end_borrow_stream(
152 (void *) message);
153 }
154
155 static
156 void bt_message_stream_set_default_clock_snapshot(
157 struct bt_message *msg, uint64_t raw_value)
158 {
159 struct bt_message_stream *stream_msg = (void *) msg;
160 struct bt_stream_class *sc;
161
162 BT_ASSERT(msg);
163 BT_ASSERT_PRE_DEV_HOT(msg, "Message", ": %!+n", msg);
164 sc = stream_msg->stream->class;
165 BT_ASSERT(sc);
166 BT_ASSERT_PRE(sc->default_clock_class,
167 "Message's stream's class has no default clock class: "
168 "%![msg-]+n, %![sc-]+S", msg, sc);
169 BT_ASSERT(stream_msg->default_cs);
170 bt_clock_snapshot_set_raw_value(stream_msg->default_cs, raw_value);
171 stream_msg->default_cs_state = BT_MESSAGE_STREAM_CLOCK_SNAPSHOT_STATE_KNOWN;
172 BT_LIB_LOGD("Set stream message's default clock snapshot: "
173 "%![msg-]+n, value=%" PRIu64, msg, raw_value);
174 }
175
176 void bt_message_stream_beginning_set_default_clock_snapshot(
177 struct bt_message *message, uint64_t raw_value)
178 {
179 BT_ASSERT_PRE_NON_NULL(message, "Message");
180 BT_ASSERT_PRE_MSG_HAS_TYPE(message, BT_MESSAGE_TYPE_STREAM_BEGINNING);
181
182 bt_message_stream_set_default_clock_snapshot(message, raw_value);
183 }
184
185 void bt_message_stream_end_set_default_clock_snapshot(
186 struct bt_message *message, uint64_t raw_value)
187 {
188 BT_ASSERT_PRE_NON_NULL(message, "Message");
189 BT_ASSERT_PRE_MSG_HAS_TYPE(message, BT_MESSAGE_TYPE_STREAM_END);
190
191 return bt_message_stream_set_default_clock_snapshot(message, raw_value);
192 }
193
194 static enum bt_message_stream_clock_snapshot_state
195 bt_message_stream_borrow_default_clock_snapshot_const(
196 const bt_message *msg, const bt_clock_snapshot **snapshot)
197 {
198 struct bt_message_stream *stream_msg = (void *) msg;
199 struct bt_stream_class *sc;
200
201 BT_ASSERT_DBG(msg);
202 sc = stream_msg->stream->class;
203 BT_ASSERT_DBG(sc);
204 BT_ASSERT_PRE_DEV(sc->default_clock_class,
205 "Message's stream's class has no default clock class: "
206 "%![msg-]+n, %![sc-]+S", msg, sc);
207 BT_ASSERT_DBG(stream_msg->default_cs);
208
209 *snapshot = stream_msg->default_cs;
210
211 return stream_msg->default_cs_state;
212 }
213
214 enum bt_message_stream_clock_snapshot_state
215 bt_message_stream_beginning_borrow_default_clock_snapshot_const(
216 const bt_message *message, const bt_clock_snapshot **snapshot)
217 {
218 BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
219 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message,
220 BT_MESSAGE_TYPE_STREAM_BEGINNING);
221 return bt_message_stream_borrow_default_clock_snapshot_const(
222 message, snapshot);
223 }
224
225 enum bt_message_stream_clock_snapshot_state
226 bt_message_stream_end_borrow_default_clock_snapshot_const(
227 const bt_message *message, const bt_clock_snapshot **snapshot)
228 {
229 BT_ASSERT_PRE_DEV_NON_NULL(message, "Message");
230 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(message, BT_MESSAGE_TYPE_STREAM_END);
231 return bt_message_stream_borrow_default_clock_snapshot_const(
232 message, snapshot);
233 }
234
235 static inline
236 const struct bt_clock_class *
237 borrow_stream_message_stream_class_default_clock_class(
238 const struct bt_message *msg)
239 {
240 struct bt_message_stream *stream_msg = (void *) msg;
241
242 BT_ASSERT_DBG(msg);
243 return stream_msg->stream->class->default_clock_class;
244 }
245
246 const struct bt_clock_class *
247 bt_message_stream_beginning_borrow_stream_class_default_clock_class_const(
248 const struct bt_message *msg)
249 {
250 BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
251 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg,
252 BT_MESSAGE_TYPE_STREAM_BEGINNING);
253 return borrow_stream_message_stream_class_default_clock_class(msg);
254 }
255
256 const struct bt_clock_class *
257 bt_message_stream_end_borrow_stream_class_default_clock_class_const(
258 const struct bt_message *msg)
259 {
260 BT_ASSERT_PRE_DEV_NON_NULL(msg, "Message");
261 BT_ASSERT_PRE_DEV_MSG_HAS_TYPE(msg, BT_MESSAGE_TYPE_STREAM_END);
262 return borrow_stream_message_stream_class_default_clock_class(msg);
263 }
This page took 0.034071 seconds and 3 git commands to generate.