src/plugins/ctf/fs-src/fs.hpp

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
   6  *
   7  * BabelTrace - CTF on File System Component
   8  */
   9
  10 #ifndef BABELTRACE_PLUGIN_CTF_FS_H
  11 #define BABELTRACE_PLUGIN_CTF_FS_H
  12
  13 #include <stdbool.h>
  14 #include "common/macros.h"
  15 #include <babeltrace2/babeltrace.h>
  16 #include "data-stream-file.hpp"
  17 #include "metadata.hpp"
  18 #include "../common/metadata/decoder.hpp"
  19
  20 BT_HIDDEN
  21 extern bool ctf_fs_debug;
  22
  23 struct ctf_fs_file
  24 {
  25     bt_logging_level log_level;
  26
  27     /* Weak */
  28     bt_self_component *self_comp;
  29
  30     /* Owned by this */
  31     GString *path;
  32
  33     /* Owned by this */
  34     FILE *fp;
  35
  36     off_t size;
  37 };
  38
  39 struct ctf_fs_metadata
  40 {
  41     /* Owned by this */
  42     struct ctf_metadata_decoder *decoder;
  43
  44     /* Owned by this */
  45     bt_trace_class *trace_class;
  46
  47     /* Weak (owned by `decoder` above) */
  48     struct ctf_trace_class *tc;
  49
  50     /* Owned by this */
  51     char *text;
  52
  53     int bo;
  54 };
  55
  56 struct ctf_fs_component
  57 {
  58     bt_logging_level log_level;
  59
  60     /* Array of struct ctf_fs_port_data *, owned by this */
  61     GPtrArray *port_data;
  62
  63     /* Owned by this */
  64     struct ctf_fs_trace *trace;
  65
  66     struct ctf_fs_metadata_config metadata_config;
  67 };
  68
  69 struct ctf_fs_trace
  70 {
  71     bt_logging_level log_level;
  72
  73     /*
  74      * Weak. These are mostly used to generate log messages or to append
  75      * error causes. They are mutually exclusive, only one of them must be
  76      * set.
  77      */
  78     bt_self_component *self_comp;
  79     bt_self_component_class *self_comp_class;
  80
  81     /* Owned by this */
  82     struct ctf_fs_metadata *metadata;
  83
  84     /* Owned by this */
  85     bt_trace *trace;
  86
  87     /* Array of struct ctf_fs_ds_file_group *, owned by this */
  88     GPtrArray *ds_file_groups;
  89
  90     /* Owned by this */
  91     GString *path;
  92
  93     /* Next automatic stream ID when not provided by packet header */
  94     uint64_t next_stream_id;
  95 };
  96
  97 struct ctf_fs_ds_index_entry
  98 {
  99     /* Weak, belongs to ctf_fs_ds_file_info. */
 100     const char *path;
 101
 102     /* Position, in bytes, of the packet from the beginning of the file. */
 103     uint64_t offset;
 104
 105     /* Size of the packet, in bytes. */
 106     uint64_t packet_size;
 107
 108     /*
 109      * Extracted from the packet context, relative to the respective fields'
 110      * mapped clock classes (in cycles).
 111      */
 112     uint64_t timestamp_begin, timestamp_end;
 113
 114     /*
 115      * Converted from the packet context, relative to the trace's EPOCH
 116      * (in ns since EPOCH).
 117      */
 118     int64_t timestamp_begin_ns, timestamp_end_ns;
 119
 120     /*
 121      * Packet sequence number, or UINT64_MAX if not present in the index.
 122      */
 123     uint64_t packet_seq_num;
 124 };
 125
 126 struct ctf_fs_ds_index
 127 {
 128     /* Array of pointer to struct ctf_fs_ds_index_entry. */
 129     GPtrArray *entries;
 130 };
 131
 132 struct ctf_fs_ds_file_group
 133 {
 134     /*
 135      * Array of struct ctf_fs_ds_file_info, owned by this.
 136      *
 137      * This is an _ordered_ array of data stream file infos which
 138      * belong to this group (a single stream instance).
 139      *
 140      * You can call ctf_fs_ds_file_create() with one of those paths
 141      * and the trace IR stream below.
 142      */
 143     GPtrArray *ds_file_infos;
 144
 145     /* Owned by this */
 146     struct ctf_stream_class *sc;
 147
 148     /* Owned by this */
 149     bt_stream *stream;
 150
 151     /* Stream (instance) ID; -1ULL means none */
 152     uint64_t stream_id;
 153
 154     /* Weak, belongs to component */
 155     struct ctf_fs_trace *ctf_fs_trace;
 156
 157     /*
 158      * Owned by this.
 159      */
 160     struct ctf_fs_ds_index *index;
 161 };
 162
 163 struct ctf_fs_port_data
 164 {
 165     /* Weak, belongs to ctf_fs_trace */
 166     struct ctf_fs_ds_file_group *ds_file_group;
 167
 168     /* Weak */
 169     struct ctf_fs_component *ctf_fs;
 170 };
 171
 172 struct ctf_fs_msg_iter_data
 173 {
 174     bt_logging_level log_level;
 175
 176     /* Weak */
 177     bt_self_component *self_comp;
 178
 179     /* Weak */
 180     bt_self_message_iterator *self_msg_iter;
 181
 182     /* Weak, belongs to ctf_fs_trace */
 183     struct ctf_fs_ds_file_group *ds_file_group;
 184
 185     /* Owned by this */
 186     struct ctf_msg_iter *msg_iter;
 187
 188     /*
 189      * Saved error.  If we hit an error in the _next method, but have some
 190      * messages ready to return, we save the error here and return it on
 191      * the next _next call.
 192      */
 193     bt_message_iterator_class_next_method_status next_saved_status;
 194     const struct bt_error *next_saved_error;
 195
 196     struct ctf_fs_ds_group_medops_data *msg_iter_medops_data;
 197 };
 198
 199 BT_HIDDEN
 200 bt_component_class_initialize_method_status
 201 ctf_fs_init(bt_self_component_source *source, bt_self_component_source_configuration *config,
 202             const bt_value *params, void *init_method_data);
 203
 204 BT_HIDDEN
 205 void ctf_fs_finalize(bt_self_component_source *component);
 206
 207 BT_HIDDEN
 208 bt_component_class_query_method_status ctf_fs_query(bt_self_component_class_source *comp_class,
 209                                                     bt_private_query_executor *priv_query_exec,
 210                                                     const char *object, const bt_value *params,
 211                                                     void *method_data, const bt_value **result);
 212
 213 BT_HIDDEN
 214 bt_message_iterator_class_initialize_method_status
 215 ctf_fs_iterator_init(bt_self_message_iterator *self_msg_iter,
 216                      bt_self_message_iterator_configuration *config,
 217                      bt_self_component_port_output *self_port);
 218
 219 BT_HIDDEN
 220 void ctf_fs_iterator_finalize(bt_self_message_iterator *it);
 221
 222 BT_HIDDEN
 223 bt_message_iterator_class_next_method_status
 224 ctf_fs_iterator_next(bt_self_message_iterator *iterator, bt_message_array_const msgs,
 225                      uint64_t capacity, uint64_t *count);
 226
 227 BT_HIDDEN
 228 bt_message_iterator_class_seek_beginning_method_status
 229 ctf_fs_iterator_seek_beginning(bt_self_message_iterator *message_iterator);
 230
 231 /* Create and initialize a new, empty ctf_fs_component. */
 232
 233 BT_HIDDEN
 234 struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level,
 235                                                  bt_self_component *self_comp);
 236
 237 /*
 238  * Create one `struct ctf_fs_trace` from one trace, or multiple traces sharing
 239  * the same UUID.
 240  *
 241  * `paths_value` must be an array of strings,
 242  *
 243  * The created `struct ctf_fs_trace` is assigned to `ctf_fs->trace`.
 244  *
 245  * `self_comp` and `self_comp_class` are used for logging, only one of them
 246  * should be set.
 247  */
 248
 249 BT_HIDDEN
 250 int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs,
 251                                          const bt_value *paths_value,
 252                                          const bt_value *trace_name_value,
 253                                          bt_self_component *self_comp,
 254                                          bt_self_component_class *self_comp_class);
 255
 256 /* Free `ctf_fs` and everything it owns. */
 257
 258 BT_HIDDEN
 259 void ctf_fs_destroy(struct ctf_fs_component *ctf_fs);
 260
 261 /*
 262  * Read and validate parameters taken by the src.ctf.fs plugin.
 263  *
 264  *  - The mandatory `paths` parameter is returned in `*paths`.
 265  *  - The optional `clock-class-offset-s` and `clock-class-offset-ns`, if
 266  *    present, are recorded in the `ctf_fs` structure.
 267  *  - The optional `trace-name` parameter is returned in `*trace_name` if
 268  *    present, else `*trace_name` is set to NULL.
 269  *
 270  * `self_comp` and `self_comp_class` are used for logging, only one of them
 271  * should be set.
 272  *
 273  * Return true on success, false if any parameter didn't pass validation.
 274  */
 275
 276 BT_HIDDEN
 277 bool read_src_fs_parameters(const bt_value *params, const bt_value **paths,
 278                             const bt_value **trace_name, struct ctf_fs_component *ctf_fs,
 279                             bt_self_component *self_comp, bt_self_component_class *self_comp_class);
 280
 281 /*
 282  * Generate the port name to be used for a given data stream file group.
 283  *
 284  * The result must be freed using g_free by the caller.
 285  */
 286
 287 BT_HIDDEN
 288 gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group);
 289
 290 #endif /* BABELTRACE_PLUGIN_CTF_FS_H */