`ctf` plugin: add metadata stream parser utilities

This patch adds:

ctf::src::getMetadataStreamMajorVersion():
    Returns the major version of a metadata stream based on its first
    byte.

ctf::src::createMetadataStreamParser(MetadataStreamMajorVersion, ...):
    Creates and returns a CTF metadata stream parser of which the
    concrete class depends on some major version.

ctf::src::createMetadataStreamParser(const std::uint8_t *, ...):
    Creates and returns a CTF metadata stream parser of which the
    concrete class depends on the first byte of some data.

ctf::src::parseMetadataStream():
    Parses a whole metadata stream, returning the resulting trace class
    and optional metadata stream UUID.

    This is the preferred way to parse a whole metadata stream as it
    calls the static parse() method of some concrete parser class which
    may contain more validation. For example,
    ctf::src::Ctf2MetadataStreamParser::parse() throws if there's no
    resulting trace class or if the current resulting trace class has no
    data stream classes (required by CTF2-SPEC-6.0 [1]).

[1]: https://diamon.org/ctf/files/CTF2-SPECRC-6.0rB.html#metadata-stream

Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Id869bb4fc735a75fbe16827dfb6abed62d13467b

Change-Id: I9249645496012f8bddccbdc866af087c3d3bc549

diff --git a/src/plugins/ctf/common/src/metadata/Makefile.am b/src/plugins/ctf/common/src/metadata/Makefile.am
index 1470407b8eb52c6e7697e8cd0ea730c087f41301..8daed1cb4a2d3846323fae14f661cd5cdc7f853a 100644 (file)
--- a/src/plugins/ctf/common/src/metadata/Makefile.am
+++ b/src/plugins/ctf/common/src/metadata/Makefile.am
@@ -7,7 +7,8 @@ noinst_LTLIBRARIES = libctf-src-metadata.la
 libctf_src_metadata_la_SOURCES = \
        ctf-ir.hpp ctf-ir.cpp \
        normalize-clk-offset.hpp normalize-clk-offset.cpp \
-       metadata-stream-parser.hpp metadata-stream-parser.cpp
+       metadata-stream-parser.hpp metadata-stream-parser.cpp \
+       metadata-stream-parser-utils.hpp metadata-stream-parser-utils.cpp
 
 libctf_src_metadata_la_LIBADD = \
        $(builddir)/tsdl/libctf-parser.la \

diff --git a/src/plugins/ctf/common/src/metadata/metadata-stream-parser-utils.cpp b/src/plugins/ctf/common/src/metadata/metadata-stream-parser-utils.cpp
new file mode 100644 (file)
index 0000000..b2dbe64
--- /dev/null
+++ b/src/plugins/ctf/common/src/metadata/metadata-stream-parser-utils.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2022 Philippe Proulx <pproulx@efficios.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include "common/assert.h"
+#include "cpp-common/make-unique.hpp"
+#include "tsdl/ctf-1-metadata-stream-parser.hpp"
+#include "json/ctf-2-metadata-stream-parser.hpp"
+#include "metadata-stream-parser-utils.hpp"
+
+namespace ctf {
+namespace src {
+
+MetadataStreamMajorVersion getMetadataStreamMajorVersion(const std::uint8_t * const data) noexcept
+{
+    BT_ASSERT(data);
+
+    /* CTF 2 if it starts with an RS byte, otherwise CTF 1 */
+    return (*data == 30) ? MetadataStreamMajorVersion::V2 : MetadataStreamMajorVersion::V1;
+}
+
+std::unique_ptr<MetadataStreamParser>
+createMetadataStreamParser(const MetadataStreamMajorVersion majorVersion,
+                           const ClkClsCfg& clkClsCfg, bt_self_component * const selfComp,
+                           const bt2_common::LogCfg& logCfg)
+{
+    if (majorVersion == MetadataStreamMajorVersion::V1) {
+        return bt2_common::makeUnique<Ctf1MetadataStreamParser>(clkClsCfg, selfComp, logCfg);
+    } else {
+        BT_ASSERT(majorVersion == MetadataStreamMajorVersion::V2);
+        return bt2_common::makeUnique<Ctf2MetadataStreamParser>(clkClsCfg, selfComp, logCfg);
+    }
+}
+
+std::unique_ptr<MetadataStreamParser> createMetadataStreamParser(const std::uint8_t * const data,
+                                                                 const ClkClsCfg& clkClsCfg,
+                                                                 bt_self_component * const selfComp,
+                                                                 const bt2_common::LogCfg& logCfg)
+{
+    return createMetadataStreamParser(getMetadataStreamMajorVersion(data), clkClsCfg, selfComp,
+                                      logCfg);
+}
+
+MetadataStreamParser::ParseRet parseMetadataStream(const ClkClsCfg& clkClsCfg,
+                                                   bt_self_component * const selfComp,
+                                                   const uint8_t * const begin,
+                                                   const uint8_t * const end,
+                                                   const bt2_common::LogCfg& logCfg)
+{
+    const auto majorVersion = getMetadataStreamMajorVersion(begin);
+
+    if (majorVersion == MetadataStreamMajorVersion::V1) {
+        return Ctf1MetadataStreamParser::parse(clkClsCfg, selfComp, begin, end, logCfg);
+    } else {
+        BT_ASSERT(majorVersion == MetadataStreamMajorVersion::V2);
+        return Ctf2MetadataStreamParser::parse(clkClsCfg, selfComp, begin, end, logCfg);
+    }
+}
+
+} /* namespace src */
+} /* namespace ctf */

diff --git a/src/plugins/ctf/common/src/metadata/metadata-stream-parser-utils.hpp b/src/plugins/ctf/common/src/metadata/metadata-stream-parser-utils.hpp
new file mode 100644 (file)
index 0000000..a272b27
--- /dev/null
+++ b/src/plugins/ctf/common/src/metadata/metadata-stream-parser-utils.hpp
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: MIT
+ *
+ * Copyright 2022 Philippe Proulx <pproulx@efficios.com>
+ */
+
+#ifndef _CTF_SRC_METADATA_METADATA_STREAM_PARSER_UTILS_HPP
+#define _CTF_SRC_METADATA_METADATA_STREAM_PARSER_UTILS_HPP
+
+#include <cstdint>
+#include <memory>
+
+#include "metadata-stream-parser.hpp"
+#include "cpp-common/log-cfg.hpp"
+#include "../clk-cls-cfg.hpp"
+
+namespace ctf {
+namespace src {
+
+enum class MetadataStreamMajorVersion
+{
+    V1 = 1,
+    V2,
+};
+
+/*
+ * Returns the major CTF version (1 or 2) of the metadata stream
+ * starting with `data`.
+ */
+MetadataStreamMajorVersion getMetadataStreamMajorVersion(const std::uint8_t *data) noexcept;
+
+/*
+ * Creates and returns a CTF metadata stream parser of which the
+ * concrete class depends on `majorVersion`.
+ *
+ * Forwards other parameters to the CTF metadata stream parser
+ * constructor.
+ */
+std::unique_ptr<MetadataStreamParser>
+createMetadataStreamParser(MetadataStreamMajorVersion majorVersion, const ClkClsCfg& clkClsCfg,
+                           bt_self_component *selfComp, const bt2_common::LogCfg& logCfg);
+
+/*
+ * Creates and returns a CTF metadata stream parser of which the
+ * concrete class depends on the first byte of `data`, the beginning of
+ * the metadata stream.
+ *
+ * Forwards other parameters to the CTF metadata stream parser
+ * constructor.
+ */
+std::unique_ptr<MetadataStreamParser> createMetadataStreamParser(const std::uint8_t *data,
+                                                                 const ClkClsCfg& clkClsCfg,
+                                                                 bt_self_component *selfComp,
+                                                                 const bt2_common::LogCfg& logCfg);
+
+/*
+ * Parses the metadata stream between `begin` and `end` using a parser
+ * of which the concrete class depends on the first byte of `begin`, the
+ * beginning of the metadata stream.
+ *
+ * Forwards other parameters to the CTF metadata stream parser
+ * constructor.
+ */
+MetadataStreamParser::ParseRet parseMetadataStream(const ClkClsCfg& clkClsCfg,
+                                                   bt_self_component *selfComp,
+                                                   const uint8_t *begin, const uint8_t *end,
+                                                   const bt2_common::LogCfg& logCfg);
+
+} /* namespace src */
+} /* namespace ctf */
+
+#endif /* _CTF_SRC_METADATA_METADATA_STREAM_PARSER_UTILS_HPP */