static
enum bt_self_notification_iterator_status ctf_fs_iterator_next_one(
struct ctf_fs_notif_iter_data *notif_iter_data,
- struct bt_notification **notif)
+ const struct bt_notification **notif)
{
enum bt_self_notification_iterator_status status;
- struct bt_private_notification *priv_notif;
+ struct bt_notification *priv_notif;
int ret;
BT_ASSERT(notif_iter_data->ds_file);
status = ctf_fs_ds_file_next(notif_iter_data->ds_file, &priv_notif);
- *notif = bt_private_notification_as_notification(priv_notif);
+ *notif = priv_notif;
if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK &&
bt_notification_get_type(*notif) ==
- BT_NOTIFICATION_TYPE_STREAM_BEGIN) {
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING) {
if (notif_iter_data->skip_stream_begin_notifs) {
/*
* We already emitted a
- * BT_NOTIFICATION_TYPE_STREAM_BEGIN
+ * BT_NOTIFICATION_TYPE_STREAM_BEGINNING
* notification: skip this one, get a new one.
*/
BT_OBJECT_PUT_REF_AND_RESET(*notif);
status = ctf_fs_ds_file_next(notif_iter_data->ds_file,
&priv_notif);
- *notif = bt_private_notification_as_notification(priv_notif);
+ *notif = priv_notif;
BT_ASSERT(status != BT_SELF_NOTIFICATION_ITERATOR_STATUS_END);
goto end;
} else {
/*
- * First BT_NOTIFICATION_TYPE_STREAM_BEGIN
+ * First BT_NOTIFICATION_TYPE_STREAM_BEGINNING
* notification: skip all following.
*/
notif_iter_data->skip_stream_begin_notifs = true;
}
status = ctf_fs_ds_file_next(notif_iter_data->ds_file, &priv_notif);
- *notif = bt_private_notification_as_notification(priv_notif);
+ *notif = priv_notif;
/*
* If we get a notification, we expect to get a
- * BT_NOTIFICATION_TYPE_STREAM_BEGIN notification
+ * BT_NOTIFICATION_TYPE_STREAM_BEGINNING notification
* because the iterator's state machine emits one before
* even requesting the first block of data from the
* medium. Skip this notification because we're not
* really starting a new stream here, and try getting a
* new notification (which, if it works, is a
- * BT_NOTIFICATION_TYPE_PACKET_BEGIN one). We're sure to
+ * BT_NOTIFICATION_TYPE_PACKET_BEGINNING one). We're sure to
* get at least one pair of
- * BT_NOTIFICATION_TYPE_PACKET_BEGIN and
+ * BT_NOTIFICATION_TYPE_PACKET_BEGINNING and
* BT_NOTIFICATION_TYPE_PACKET_END notifications in the
* case of a single, empty packet. We know there's at
* least one packet because the stream file group does
if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) {
BT_ASSERT(bt_notification_get_type(*notif) ==
- BT_NOTIFICATION_TYPE_STREAM_BEGIN);
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING);
BT_OBJECT_PUT_REF_AND_RESET(*notif);
status = ctf_fs_ds_file_next(notif_iter_data->ds_file,
&priv_notif);
- *notif = bt_private_notification_as_notification(priv_notif);
+ *notif = priv_notif;
BT_ASSERT(status != BT_SELF_NOTIFICATION_ITERATOR_STATUS_END);
}
}
BT_HIDDEN
enum bt_self_notification_iterator_status ctf_fs_iterator_next(
struct bt_self_notification_iterator *iterator,
- bt_notification_array notifs, uint64_t capacity,
+ bt_notification_array_const notifs, uint64_t capacity,
uint64_t *count)
{
enum bt_self_notification_iterator_status status =
g_ptr_array_free(ctf_fs_trace->ds_file_groups, TRUE);
}
+ BT_OBJECT_PUT_REF_AND_RESET(ctf_fs_trace->trace);
+
if (ctf_fs_trace->path) {
g_string_free(ctf_fs_trace->path, TRUE);
}
/* No stream ID: use 0 */
ds_file_group->stream = bt_stream_create_with_id(
ds_file_group->stream_class,
+ ctf_fs_trace->trace,
ctf_fs_trace->next_stream_id);
ctf_fs_trace->next_stream_id++;
} else {
/* Specific stream ID */
ds_file_group->stream = bt_stream_create_with_id(
ds_file_group->stream_class,
+ ctf_fs_trace->trace,
(uint64_t) ds_file_group->stream_id);
}
return ret;
}
+static
+int set_trace_name(struct bt_trace *trace, const char *name_suffix)
+{
+ int ret = 0;
+ const struct bt_trace_class *tc = bt_trace_borrow_class_const(trace);
+ const struct bt_value *val;
+ GString *name;
+
+ name = g_string_new(NULL);
+ if (!name) {
+ BT_LOGE_STR("Failed to allocate a GString.");
+ ret = -1;
+ goto end;
+ }
+
+ /*
+ * Check if we have a trace environment string value named `hostname`.
+ * If so, use it as the trace name's prefix.
+ */
+ val = bt_trace_class_borrow_environment_entry_value_by_name_const(
+ tc, "hostname");
+ if (val && bt_value_is_string(val)) {
+ g_string_append(name, bt_value_string_get(val));
+
+ if (name_suffix) {
+ g_string_append_c(name, G_DIR_SEPARATOR);
+ }
+ }
+
+ if (name_suffix) {
+ g_string_append(name, name_suffix);
+ }
+
+ ret = bt_trace_set_name(trace, name->str);
+ if (ret) {
+ goto end;
+ }
+
+ goto end;
+
+end:
+ if (name) {
+ g_string_free(name, TRUE);
+ }
+
+ return ret;
+}
+
BT_HIDDEN
struct ctf_fs_trace *ctf_fs_trace_create(const char *path, const char *name,
struct ctf_fs_metadata_config *metadata_config)
goto error;
}
- ret = ctf_fs_metadata_set_trace(ctf_fs_trace, metadata_config);
+ ret = ctf_fs_metadata_set_trace_class(ctf_fs_trace, metadata_config);
+ if (ret) {
+ goto error;
+ }
+
+ ctf_fs_trace->trace =
+ bt_trace_create(ctf_fs_trace->metadata->trace_class);
+ if (!ctf_fs_trace->trace) {
+ goto error;
+ }
+
+ ret = set_trace_name(ctf_fs_trace->trace, name);
if (ret) {
goto error;
}
* trace needs. There won't be any more. Therefore it is safe to
* make this trace static.
*/
- (void) bt_trace_make_static(ctf_fs_trace->metadata->trace);
+ (void) bt_trace_make_static(ctf_fs_trace->trace);
goto end;
BT_HIDDEN
enum bt_query_status ctf_fs_query(
struct bt_self_component_class_source *comp_class,
- struct bt_query_executor *query_exec,
+ const struct bt_query_executor *query_exec,
const char *object, const struct bt_value *params,
const struct bt_value **result)
{