`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‑2.0 [1]).

[1]: https://diamon.org/ctf/CTF2-SPEC-2.0.html#metadata-stream

Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Id869bb4fc735a75fbe16827dfb6abed62d13467b
Reviewed-on: https://review.lttng.org/c/babeltrace/+/12737
Tested-by: jenkins <jenkins@lttng.org>
CI-Build: Simon Marchi <simon.marchi@efficios.com>

diff --git a/src/Makefile.am b/src/Makefile.am
index 9a943ce583bc83d274997051693c6854397afcaa..b785e3531faa4254522a29b06c1b74b95952d4cf 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -725,6 +725,8 @@ plugins_ctf_babeltrace_plugin_ctf_la_SOURCES = \
        plugins/ctf/common/src/metadata/json/validate-scope-fc-roles.hpp \
        plugins/ctf/common/src/metadata/metadata-stream-parser.cpp \
        plugins/ctf/common/src/metadata/metadata-stream-parser.hpp \
+       plugins/ctf/common/src/metadata/metadata-stream-parser-utils.cpp \
+       plugins/ctf/common/src/metadata/metadata-stream-parser-utils.hpp \
        plugins/ctf/common/src/metadata/normalize-clk-offset.cpp \
        plugins/ctf/common/src/metadata/normalize-clk-offset.hpp \
        plugins/ctf/common/src/metadata/tsdl/ctf-1-metadata-stream-parser.cpp \

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..780fd0c
--- /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/bt2s/make-unique.hpp"
+
+#include "json/ctf-2-metadata-stream-parser.hpp"
+#include "metadata-stream-parser-utils.hpp"
+#include "tsdl/ctf-1-metadata-stream-parser.hpp"
+
+namespace ctf {
+namespace src {
+
+MetadataStreamMajorVersion getMetadataStreamMajorVersion(const bt2c::ConstBytes buffer) noexcept
+{
+    BT_ASSERT(buffer.data());
+
+    /* CTF 2 if it starts with an RS byte, otherwise CTF 1 */
+    return (buffer[0] == 30) ? MetadataStreamMajorVersion::V2 : MetadataStreamMajorVersion::V1;
+}
+
+std::unique_ptr<MetadataStreamParser>
+createMetadataStreamParser(const MetadataStreamMajorVersion majorVersion,
+                           const bt2::OptionalBorrowedObject<bt2::SelfComponent> selfComp,
+                           const ClkClsCfg& clkClsCfg, const bt2c::Logger& parentLogger)
+{
+    if (majorVersion == MetadataStreamMajorVersion::V1) {
+        return bt2s::make_unique<Ctf1MetadataStreamParser>(selfComp, clkClsCfg, parentLogger);
+    } else {
+        BT_ASSERT(majorVersion == MetadataStreamMajorVersion::V2);
+        return bt2s::make_unique<Ctf2MetadataStreamParser>(selfComp, clkClsCfg, parentLogger);
+    }
+}
+
+std::unique_ptr<MetadataStreamParser>
+createMetadataStreamParser(const bt2c::ConstBytes buffer,
+                           const bt2::OptionalBorrowedObject<bt2::SelfComponent> selfComp,
+                           const ClkClsCfg& clkClsCfg, const bt2c::Logger& parentLogger)
+{
+    return createMetadataStreamParser(getMetadataStreamMajorVersion(buffer), selfComp, clkClsCfg,
+                                      parentLogger);
+}
+
+MetadataStreamParser::ParseRet
+parseMetadataStream(const bt2::OptionalBorrowedObject<bt2::SelfComponent> selfComp,
+                    const ClkClsCfg& clkClsCfg, const bt2c::ConstBytes buffer,
+                    const bt2c::Logger& parentLogger)
+{
+    const auto majorVersion = getMetadataStreamMajorVersion(buffer);
+
+    if (majorVersion == MetadataStreamMajorVersion::V1) {
+        return Ctf1MetadataStreamParser::parse(selfComp, clkClsCfg, buffer, parentLogger);
+    } else {
+        BT_ASSERT(majorVersion == MetadataStreamMajorVersion::V2);
+        return Ctf2MetadataStreamParser::parse(selfComp, clkClsCfg, buffer, parentLogger);
+    }
+}
+
+} /* 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..4181633
--- /dev/null
+++ b/src/plugins/ctf/common/src/metadata/metadata-stream-parser-utils.hpp
@@ -0,0 +1,74 @@
+/*
+ * SPDX-License-Identifier: MIT
+ *
+ * Copyright 2022-2024 Philippe Proulx <pproulx@efficios.com>
+ */
+
+#ifndef BABELTRACE_PLUGINS_CTF_COMMON_SRC_METADATA_METADATA_STREAM_PARSER_UTILS_HPP
+#define BABELTRACE_PLUGINS_CTF_COMMON_SRC_METADATA_METADATA_STREAM_PARSER_UTILS_HPP
+
+#include <memory>
+
+#include "cpp-common/bt2c/aliases.hpp"
+#include "cpp-common/bt2c/logging.hpp"
+
+#include "../clk-cls-cfg.hpp"
+#include "metadata-stream-parser.hpp"
+
+namespace ctf {
+namespace src {
+
+enum class MetadataStreamMajorVersion
+{
+    V1 = 1,
+    V2,
+};
+
+/*
+ * Returns the major CTF version (1 or 2) of the metadata stream
+ * in `buffer`.
+ */
+MetadataStreamMajorVersion getMetadataStreamMajorVersion(bt2c::ConstBytes buffer) 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,
+                           bt2::OptionalBorrowedObject<bt2::SelfComponent> selfComp,
+                           const ClkClsCfg& clkClsCfg, const bt2c::Logger& parentLogger);
+
+/*
+ * Creates and returns a CTF metadata stream parser of which the
+ * concrete class depends on the first byte of `buffer`, the beginning
+ * of the metadata stream.
+ *
+ * Forwards other parameters to the CTF metadata stream
+ * parser constructor.
+ */
+std::unique_ptr<MetadataStreamParser>
+createMetadataStreamParser(bt2c::ConstBytes buffer,
+                           bt2::OptionalBorrowedObject<bt2::SelfComponent> selfComp,
+                           const ClkClsCfg& clkClsCfg, const bt2c::Logger& parentLogger);
+
+/*
+ * Parses the metadata stream in `buffer` using a parser of which the
+ * concrete class depends on the first byte of `buffer`, the beginning
+ * of the metadata stream.
+ *
+ * Forwards other parameters to the CTF metadata stream
+ * parser constructor.
+ */
+MetadataStreamParser::ParseRet
+parseMetadataStream(bt2::OptionalBorrowedObject<bt2::SelfComponent> selfComp,
+                    const ClkClsCfg& clkClsCfg, bt2c::ConstBytes buffer,
+                    const bt2c::Logger& parentLogger);
+
+} /* namespace src */
+} /* namespace ctf */
+
+#endif /* BABELTRACE_PLUGINS_CTF_COMMON_SRC_METADATA_METADATA_STREAM_PARSER_UTILS_HPP */