lib/ctf-ir/stream.c

   1 /*
   2  * stream.c
   3  *
   4  * Babeltrace CTF IR - Stream
   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
  29 #define BT_LOG_TAG "STREAM"
  30 #include <babeltrace/lib-logging-internal.h>
  31
  32 #include <babeltrace/assert-pre-internal.h>
  33 #include <babeltrace/ctf-ir/stream.h>
  34 #include <babeltrace/ctf-ir/stream-internal.h>
  35 #include <babeltrace/ctf-ir/stream-class.h>
  36 #include <babeltrace/ctf-ir/stream-class-internal.h>
  37 #include <babeltrace/ctf-ir/trace.h>
  38 #include <babeltrace/ctf-ir/trace-internal.h>
  39 #include <babeltrace/ref.h>
  40 #include <babeltrace/compiler-internal.h>
  41 #include <babeltrace/align-internal.h>
  42 #include <babeltrace/assert-internal.h>
  43 #include <inttypes.h>
  44 #include <unistd.h>
  45
  46 BT_HIDDEN
  47 void bt_stream_common_finalize(struct bt_stream_common *stream)
  48 {
  49         int i;
  50
  51         BT_LOGD("Finalizing common stream object: addr=%p, name=\"%s\"",
  52                 stream, bt_stream_common_get_name(stream));
  53
  54         /* Call destroy listeners in reverse registration order */
  55         if (stream->destroy_listeners) {
  56                 for (i = stream->destroy_listeners->len - 1; i >= 0; i--) {
  57                         struct bt_stream_common_destroy_listener *listener =
  58                                 &g_array_index(stream->destroy_listeners,
  59                                         struct bt_stream_common_destroy_listener, i);
  60
  61                         BT_LOGD("Calling destroy listener: func=%p, data=%p, index=%d",
  62                                 listener->func, listener->data, i);
  63                         listener->func(stream, listener->data);
  64                 }
  65         }
  66
  67         if (stream->name) {
  68                 g_string_free(stream->name, TRUE);
  69         }
  70
  71         if (stream->destroy_listeners) {
  72                 g_array_free(stream->destroy_listeners, TRUE);
  73         }
  74 }
  75
  76 static
  77 void bt_stream_destroy(struct bt_object *obj)
  78 {
  79         struct bt_stream *stream = (void *) obj;
  80
  81         BT_LOGD("Destroying stream object: addr=%p, name=\"%s\"",
  82                 stream, bt_stream_get_name(stream));
  83         bt_stream_common_finalize((void *) obj);
  84         g_free(stream);
  85 }
  86
  87 BT_HIDDEN
  88 int bt_stream_common_initialize(
  89                 struct bt_stream_common *stream,
  90                 struct bt_stream_class_common *stream_class, const char *name,
  91                 uint64_t id, bt_object_release_func release_func)
  92 {
  93         int ret = 0;
  94         struct bt_trace_common *trace = NULL;
  95
  96         bt_object_init(stream, release_func);
  97
  98         if (!stream_class) {
  99                 BT_LOGW_STR("Invalid parameter: stream class is NULL.");
 100                 goto error;
 101         }
 102
 103         BT_LOGD("Initializing common stream object: stream-class-addr=%p, "
 104                 "stream-class-name=\"%s\", stream-name=\"%s\", "
 105                 "stream-id=%" PRIu64,
 106                 stream_class, bt_stream_class_common_get_name(stream_class),
 107                 name, id);
 108         trace = bt_stream_class_common_borrow_trace(stream_class);
 109         if (!trace) {
 110                 BT_LOGW("Invalid parameter: cannot create stream from a stream class which is not part of trace: "
 111                         "stream-class-addr=%p, stream-class-name=\"%s\", "
 112                         "stream-name=\"%s\"",
 113                         stream_class,
 114                         bt_stream_class_common_get_name(stream_class), name);
 115                 goto error;
 116         }
 117
 118         if (id != -1ULL) {
 119                 /*
 120                  * Validate that the given ID is unique amongst all the
 121                  * existing trace's streams created from the same stream
 122                  * class.
 123                  */
 124                 size_t i;
 125
 126                 for (i = 0; i < trace->streams->len; i++) {
 127                         struct bt_stream_common *trace_stream =
 128                                 g_ptr_array_index(trace->streams, i);
 129
 130                         if (trace_stream->stream_class != (void *) stream_class) {
 131                                 continue;
 132                         }
 133
 134                         if (trace_stream->id == id) {
 135                                 BT_LOGW_STR("Invalid parameter: another stream in the same trace already has this ID.");
 136                                 goto error;
 137                         }
 138                 }
 139         }
 140
 141         /*
 142          * Acquire reference to parent since stream will become publicly
 143          * reachable; it needs its parent to remain valid.
 144          */
 145         bt_object_set_parent(stream, trace);
 146         stream->stream_class = stream_class;
 147         stream->id = (int64_t) id;
 148         stream->destroy_listeners = g_array_new(FALSE, TRUE,
 149                 sizeof(struct bt_stream_common_destroy_listener));
 150         if (!stream->destroy_listeners) {
 151                 BT_LOGE_STR("Failed to allocate a GArray.");
 152                 goto error;
 153         }
 154
 155         if (name) {
 156                 stream->name = g_string_new(name);
 157                 if (!stream->name) {
 158                         BT_LOGE_STR("Failed to allocate a GString.");
 159                         goto error;
 160                 }
 161         }
 162
 163         BT_LOGD("Set common stream's trace parent: trace-addr=%p", trace);
 164
 165         /* Add this stream to the trace's streams */
 166         BT_LOGD("Created common stream object: addr=%p", stream);
 167         goto end;
 168
 169 error:
 170         ret = -1;
 171
 172 end:
 173         return ret;
 174 }
 175
 176 static
 177 struct bt_stream *bt_stream_create_with_id_no_check(
 178                 struct bt_stream_class *stream_class,
 179                 const char *name, uint64_t id)
 180 {
 181         int ret;
 182         struct bt_stream *stream = NULL;
 183         struct bt_trace *trace = NULL;
 184
 185         BT_LOGD("Creating stream object: stream-class-addr=%p, "
 186                 "stream-class-name=\"%s\", stream-name=\"%s\", "
 187                 "stream-id=%" PRIu64,
 188                 stream_class, bt_stream_class_get_name(stream_class),
 189                 name, id);
 190
 191         trace = BT_FROM_COMMON(bt_stream_class_common_borrow_trace(
 192                 BT_TO_COMMON(stream_class)));
 193         if (!trace) {
 194                 BT_LOGW("Invalid parameter: cannot create stream from a stream class which is not part of trace: "
 195                         "stream-class-addr=%p, stream-class-name=\"%s\", "
 196                         "stream-name=\"%s\"",
 197                         stream_class, bt_stream_class_get_name(stream_class),
 198                         name);
 199                 goto error;
 200         }
 201
 202         if (bt_trace_is_static(trace)) {
 203                 /*
 204                  * A static trace has the property that all its stream
 205                  * classes, clock classes, and streams are definitive:
 206                  * no more can be added, and each object is also frozen.
 207                  */
 208                 BT_LOGW("Invalid parameter: cannot create stream from a stream class which is part of a static trace: "
 209                         "stream-class-addr=%p, stream-class-name=\"%s\", "
 210                         "stream-name=\"%s\", trace-addr=%p",
 211                         stream_class, bt_stream_class_get_name(stream_class),
 212                         name, trace);
 213                 goto error;
 214         }
 215
 216         stream = g_new0(struct bt_stream, 1);
 217         if (!stream) {
 218                 BT_LOGE_STR("Failed to allocate one stream.");
 219                 goto error;
 220         }
 221
 222         ret = bt_stream_common_initialize(BT_TO_COMMON(stream),
 223                 BT_TO_COMMON(stream_class), name, id, bt_stream_destroy);
 224         if (ret) {
 225                 /* bt_stream_common_initialize() logs errors */
 226                 goto error;
 227         }
 228
 229         g_ptr_array_add(trace->common.streams, stream);
 230         BT_LOGD("Created stream object: addr=%p", stream);
 231         goto end;
 232
 233 error:
 234         BT_PUT(stream);
 235
 236 end:
 237         return stream;
 238 }
 239
 240 struct bt_stream *bt_stream_create(struct bt_stream_class *stream_class,
 241                 const char *name, uint64_t id_param)
 242 {
 243         struct bt_stream *stream = NULL;
 244         int64_t id = (int64_t) id_param;
 245
 246         if (!stream_class) {
 247                 BT_LOGW_STR("Invalid parameter: stream class is NULL.");
 248                 goto end;
 249         }
 250
 251         if (id < 0) {
 252                 BT_LOGW("Invalid parameter: invalid stream's ID: "
 253                         "name=\"%s\", id=%" PRIu64,
 254                         name, id_param);
 255                 goto end;
 256         }
 257
 258         stream = bt_stream_create_with_id_no_check(stream_class,
 259                 name, id_param);
 260
 261 end:
 262         return stream;
 263 }
 264
 265 struct bt_stream_class *bt_stream_borrow_class(struct bt_stream *stream)
 266 {
 267         return BT_FROM_COMMON(bt_stream_common_borrow_class(BT_TO_COMMON(stream)));
 268 }
 269
 270 const char *bt_stream_get_name(struct bt_stream *stream)
 271 {
 272         return bt_stream_common_get_name(BT_TO_COMMON(stream));
 273 }
 274
 275 int64_t bt_stream_get_id(struct bt_stream *stream)
 276 {
 277         return bt_stream_common_get_id(BT_TO_COMMON(stream));
 278 }
 279
 280 BT_HIDDEN
 281 void bt_stream_common_add_destroy_listener(struct bt_stream_common *stream,
 282                 bt_stream_common_destroy_listener_func func, void *data)
 283 {
 284         struct bt_stream_common_destroy_listener listener;
 285
 286         BT_ASSERT(stream);
 287         BT_ASSERT(func);
 288         listener.func = func;
 289         listener.data = data;
 290         g_array_append_val(stream->destroy_listeners, listener);
 291         BT_LOGV("Added stream destroy listener: stream-addr=%p, "
 292                 "stream-name=\"%s\", func=%p, data=%p",
 293                 stream, bt_stream_common_get_name(stream), func, data);
 294 }
 295
 296 BT_HIDDEN
 297 void bt_stream_common_remove_destroy_listener(struct bt_stream_common *stream,
 298                 bt_stream_common_destroy_listener_func func, void *data)
 299 {
 300         size_t i;
 301
 302         BT_ASSERT(stream);
 303         BT_ASSERT(func);
 304
 305         for (i = 0; i < stream->destroy_listeners->len; i++) {
 306                 struct bt_stream_common_destroy_listener *listener =
 307                         &g_array_index(stream->destroy_listeners,
 308                                 struct bt_stream_common_destroy_listener, i);
 309
 310                 if (listener->func == func && listener->data == data) {
 311                         g_array_remove_index(stream->destroy_listeners, i);
 312                         i--;
 313                         BT_LOGV("Removed stream destroy listener: stream-addr=%p, "
 314                                 "stream-name=\"%s\", func=%p, data=%p",
 315                                 stream, bt_stream_common_get_name(stream),
 316                                 func, data);
 317                 }
 318         }
 319 }