lib: add aliases for Babeltrace enumeration types
[babeltrace.git] / plugins / ctf / fs-sink / writer.c
1 /*
2 * writer.c
3 *
4 * Babeltrace CTF Writer Output Plugin
5 *
6 * Copyright 2016 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
29 #define BT_LOG_TAG "PLUGIN-CTF-FS-SINK-WRITER"
30 #include "logging.h"
31
32 #include <babeltrace/babeltrace.h>
33 #include <plugins-common.h>
34 #include <stdio.h>
35 #include <stdbool.h>
36 #include <glib.h>
37 #include "writer.h"
38 #include <babeltrace/assert-internal.h>
39
40 static
41 gboolean empty_trace_map(gpointer key, gpointer value, gpointer user_data)
42 {
43 struct fs_writer *fs_writer = value;
44 struct writer_component *writer_component = user_data;
45
46 fs_writer->trace_static = 1;
47 writer_close(writer_component, fs_writer);
48
49 return TRUE;
50 }
51
52 static
53 void destroy_writer_component_data(struct writer_component *writer_component)
54 {
55 bt_object_put_ref(writer_component->input_iterator);
56
57 g_hash_table_foreach_remove(writer_component->trace_map,
58 empty_trace_map, writer_component);
59 g_hash_table_destroy(writer_component->trace_map);
60
61 g_string_free(writer_component->base_path, true);
62 g_string_free(writer_component->trace_name_base, true);
63 }
64
65 BT_HIDDEN
66 void writer_component_finalize(bt_self_component *component)
67 {
68 struct writer_component *writer_component = (struct writer_component *)
69 bt_self_component_get_user_data(component);
70
71 destroy_writer_component_data(writer_component);
72 g_free(writer_component);
73 }
74
75 static
76 void free_fs_writer(struct fs_writer *fs_writer)
77 {
78 bt_object_put_ref(fs_writer->writer);
79 g_free(fs_writer);
80 }
81
82 static
83 struct writer_component *create_writer_component(void)
84 {
85 struct writer_component *writer_component;
86
87 writer_component = g_new0(struct writer_component, 1);
88 if (!writer_component) {
89 goto end;
90 }
91
92 writer_component->err = stderr;
93 writer_component->trace_id = 0;
94 writer_component->trace_name_base = g_string_new("trace");
95 if (!writer_component->trace_name_base) {
96 g_free(writer_component);
97 writer_component = NULL;
98 goto end;
99 }
100
101 /*
102 * Reader to writer corresponding structures.
103 */
104 writer_component->trace_map = g_hash_table_new_full(g_direct_hash,
105 g_direct_equal, NULL, (GDestroyNotify) free_fs_writer);
106
107 end:
108 return writer_component;
109 }
110
111 static
112 bt_component_status handle_message(
113 struct writer_component *writer_component,
114 const bt_message *message)
115 {
116 bt_component_status ret = BT_COMPONENT_STATUS_OK;
117
118 if (!writer_component) {
119 ret = BT_COMPONENT_STATUS_ERROR;
120 goto end;
121 }
122
123 switch (bt_message_get_type(message)) {
124 case BT_MESSAGE_TYPE_PACKET_BEGINNING:
125 {
126 const bt_packet *packet =
127 bt_message_packet_beginning_get_packet(message);
128
129 if (!packet) {
130 ret = BT_COMPONENT_STATUS_ERROR;
131 goto end;
132 }
133
134 ret = writer_new_packet(writer_component, packet);
135 bt_packet_put_ref(packet);
136 break;
137 }
138 case BT_MESSAGE_TYPE_PACKET_END:
139 {
140 const bt_packet *packet =
141 bt_message_packet_end_get_packet(message);
142
143 if (!packet) {
144 ret = BT_COMPONENT_STATUS_ERROR;
145 goto end;
146 }
147 ret = writer_close_packet(writer_component, packet);
148 bt_packet_put_ref(packet);
149 break;
150 }
151 case BT_MESSAGE_TYPE_EVENT:
152 {
153 const bt_event *event = bt_message_event_get_event(
154 message);
155
156 if (!event) {
157 ret = BT_COMPONENT_STATUS_ERROR;
158 goto end;
159 }
160 ret = writer_output_event(writer_component, event);
161 bt_object_put_ref(event);
162 if (ret != BT_COMPONENT_STATUS_OK) {
163 goto end;
164 }
165 break;
166 }
167 case BT_MESSAGE_TYPE_STREAM_BEGINNING:
168 {
169 const bt_stream *stream =
170 bt_message_stream_beginning_get_stream(message);
171
172 if (!stream) {
173 ret = BT_COMPONENT_STATUS_ERROR;
174 goto end;
175 }
176 ret = writer_stream_begin(writer_component, stream);
177 bt_stream_put_ref(stream);
178 break;
179 }
180 case BT_MESSAGE_TYPE_STREAM_END:
181 {
182 const bt_stream *stream =
183 bt_message_stream_end_get_stream(message);
184
185 if (!stream) {
186 ret = BT_COMPONENT_STATUS_ERROR;
187 goto end;
188 }
189 ret = writer_stream_end(writer_component, stream);
190 bt_stream_put_ref(stream);
191 break;
192 }
193 default:
194 break;
195 }
196 end:
197 return ret;
198 }
199
200 BT_HIDDEN
201 void writer_component_port_connected(
202 bt_self_component *component,
203 struct bt_private_port *self_port,
204 const bt_port *other_port)
205 {
206 struct bt_private_connection *connection;
207 struct writer_component *writer;
208 bt_connection_status conn_status;
209
210 writer = bt_self_component_get_user_data(component);
211 BT_ASSERT(writer);
212 BT_ASSERT(!writer->input_iterator);
213 connection = bt_private_port_get_connection(self_port);
214 BT_ASSERT(connection);
215 conn_status = bt_private_connection_create_message_iterator(
216 connection, &writer->input_iterator);
217 if (conn_status != BT_CONNECTION_STATUS_OK) {
218 writer->error = true;
219 }
220
221 bt_object_put_ref(connection);
222 }
223
224 BT_HIDDEN
225 bt_component_status writer_run(bt_self_component *component)
226 {
227 bt_component_status ret;
228 const bt_message *message = NULL;
229 bt_message_iterator *it;
230 struct writer_component *writer_component =
231 bt_self_component_get_user_data(component);
232 bt_message_iterator_status it_ret;
233
234 if (unlikely(writer_component->error)) {
235 ret = BT_COMPONENT_STATUS_ERROR;
236 goto end;
237 }
238
239 it = writer_component->input_iterator;
240 BT_ASSERT(it);
241 it_ret = bt_message_iterator_next(it);
242
243 switch (it_ret) {
244 case BT_MESSAGE_ITERATOR_STATUS_END:
245 ret = BT_COMPONENT_STATUS_END;
246 BT_OBJECT_PUT_REF_AND_RESET(writer_component->input_iterator);
247 goto end;
248 case BT_MESSAGE_ITERATOR_STATUS_AGAIN:
249 ret = BT_COMPONENT_STATUS_AGAIN;
250 goto end;
251 case BT_MESSAGE_ITERATOR_STATUS_OK:
252 break;
253 default:
254 ret = BT_COMPONENT_STATUS_ERROR;
255 goto end;
256 }
257
258 message = bt_message_iterator_get_message(it);
259 BT_ASSERT(message);
260 ret = handle_message(writer_component, message);
261 end:
262 bt_object_put_ref(message);
263 return ret;
264 }
265
266 static
267 bt_component_status apply_one_bool(const char *key,
268 bt_value *params,
269 bool *option,
270 bool *found)
271 {
272 bt_component_status ret = BT_COMPONENT_STATUS_OK;
273 bt_value *value = NULL;
274 bt_value_status status;
275 bt_bool bool_val;
276
277 value = bt_value_map_get(params, key);
278 if (!value) {
279 goto end;
280 }
281 bool_val = bt_value_bool_get(value);
282
283 *option = (bool) bool_val;
284 if (found) {
285 *found = true;
286 }
287 end:
288 bt_value_put_ref(value);
289 return ret;
290 }
291
292 BT_HIDDEN
293 bt_component_status writer_component_init(
294 bt_self_component *component, bt_value *params,
295 UNUSED_VAR void *init_method_data)
296 {
297 bt_component_status ret;
298 bt_value_status value_ret;
299 struct writer_component *writer_component = create_writer_component();
300 bt_value *value = NULL;
301 const char *path;
302
303 if (!writer_component) {
304 ret = BT_COMPONENT_STATUS_NOMEM;
305 goto end;
306 }
307
308 ret = bt_self_component_sink_add_input_port(component,
309 "in", NULL, NULL);
310 if (ret != BT_COMPONENT_STATUS_OK) {
311 goto end;
312 }
313
314 value = bt_value_map_get(params, "path");
315 if (!value || bt_value_is_null(value) || !bt_value_is_string(value)) {
316 BT_LOGE_STR("Missing mandatory \"path\" parameter.");
317 ret = BT_COMPONENT_STATUS_INVALID;
318 goto error;
319 }
320
321 value_ret = bt_value_string_get(value, &path);
322 if (value_ret != BT_VALUE_STATUS_OK) {
323 ret = BT_COMPONENT_STATUS_INVALID;
324 goto error;
325 }
326 bt_object_put_ref(value);
327
328 writer_component->base_path = g_string_new(path);
329 if (!writer_component->base_path) {
330 ret = BT_COMPONENT_STATUS_ERROR;
331 goto error;
332 }
333
334 writer_component->single_trace = false;
335 ret = apply_one_bool("single-trace", params,
336 &writer_component->single_trace, NULL);
337 if (ret != BT_COMPONENT_STATUS_OK) {
338 goto end;
339 }
340
341 ret = bt_self_component_set_user_data(component, writer_component);
342 if (ret != BT_COMPONENT_STATUS_OK) {
343 goto error;
344 }
345
346 end:
347 return ret;
348 error:
349 destroy_writer_component_data(writer_component);
350 g_free(writer_component);
351 return ret;
352 }
This page took 0.03673 seconds and 4 git commands to generate.