SplitEmptyFunction: true
BreakBeforeBinaryOperators: None
BreakBeforeTernaryOperators: false
-BreakConstructorInitializers: AfterColon
BreakStringLiterals: false
ColumnLimit: 100
ConstructorInitializerAllOnOneLineOrOnePerLine: true
static unsigned long trace_chunk_registry_ht_key_hash(const struct trace_chunk_registry_ht_key *key)
{
- const uint64_t uuid_h1 = *reinterpret_cast<const uint64_t *>(&key->sessiond_uuid[0]);
- const uint64_t uuid_h2 = *reinterpret_cast<const uint64_t *>(&key->sessiond_uuid[1]);
+ const uint64_t uuid_h1 = reinterpret_cast<const uint64_t *>(key->sessiond_uuid.data())[0];
+ const uint64_t uuid_h2 = reinterpret_cast<const uint64_t *>(key->sessiond_uuid.data())[1];
return hash_key_u64(&uuid_h1, lttng_ht_seed) ^ hash_key_u64(&uuid_h2, lttng_ht_seed);
}
}
for (i = 0; i < count; i++) {
- struct lttng_condition *condition;
- struct lttng_event_rule *event_rule;
+ const struct lttng_condition *condition;
+ const struct lttng_event_rule *event_rule;
struct lttng_trigger *trigger;
const struct ust_app_event_notifier_rule *looked_up_event_notifier_rule;
enum lttng_condition_status condition_status;
LTTNG_ASSERT(trigger);
token = lttng_trigger_get_tracer_token(trigger);
- condition = lttng_trigger_get_condition(trigger);
+ condition = lttng_trigger_get_const_condition(trigger);
if (lttng_condition_get_type(condition) !=
LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES) {
continue;
}
- condition_status = lttng_condition_event_rule_matches_borrow_rule_mutable(
- condition, &event_rule);
+ condition_status =
+ lttng_condition_event_rule_matches_get_rule(condition, &event_rule);
LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
if (lttng_event_rule_get_domain_type(event_rule) == LTTNG_DOMAIN_KERNEL) {
time.cpp \
tracker.cpp tracker.hpp \
trigger.cpp \
+ type-traits.hpp \
unix.cpp unix.hpp \
uri.cpp uri.hpp \
userspace-probe.cpp \
# libstring-utils
noinst_LTLIBRARIES += libstring-utils.la
libstring_utils_la_SOURCES = \
+ string-utils/c-string-view.hpp \
string-utils/format.hpp \
string-utils/string-utils.cpp \
string-utils/string-utils.hpp
* on error.
*/
int lttng_consumer_send_error(struct lttng_consumer_local_data *ctx,
- enum lttcomm_return_code error_code);
+ enum lttcomm_return_code error_code);
/*
* Called from signal handler to ensure a clean exit.
goto end;
}
+ if (a->emission_site != b->emission_site) {
+ goto end;
+ }
+
is_equal = true;
end:
return is_equal;
--- /dev/null
+/*
+ * Copyright (c) 2023 Philippe Proulx <pproulx@efficios.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef LTTNG_C_STRING_VIEW_HPP
+#define LTTNG_C_STRING_VIEW_HPP
+
+#include <common/format.hpp>
+#include <common/type-traits.hpp>
+
+#include <cstddef>
+#include <cstring>
+#include <functional>
+#include <string>
+
+namespace lttng {
+
+/*
+ * A view on a constant null-terminated C string.
+ */
+class c_string_view final {
+public:
+ /*
+ * Builds an empty view (data() returns `nullptr`).
+ *
+ * Intentionally not explicit.
+ */
+ constexpr c_string_view() noexcept = default;
+
+ /*
+ * Builds a view of the C string `str` (may be `nullptr`).
+ *
+ * Intentionally not explicit.
+ */
+ /* NOLINTBEGIN(google-explicit-constructor) */
+ constexpr c_string_view(const char *const str) noexcept : _str{ str }
+ {
+ }
+ /* NOLINTEND(google-explicit-constructor) */
+
+ /*
+ * Builds a view of the string `str`.
+ */
+ /* NOLINTBEGIN(google-explicit-constructor) */
+ c_string_view(const std::string& str) noexcept : _str{ str.c_str() }
+ {
+ }
+ /* NOLINTEND */
+
+ /*
+ * Makes this view view the C string `str` (may be `nullptr`).
+ */
+ c_string_view& operator=(const char *const str) noexcept
+ {
+ _str = str;
+ return *this;
+ }
+
+ /*
+ * Viewed null-terminated C string (may be `nullptr`).
+ */
+ const char *data() const noexcept
+ {
+ return _str;
+ }
+
+ /*
+ * Alias of data().
+ */
+ operator const char *() const noexcept /* NOLINT(google-explicit-constructor) */
+ {
+ return this->data();
+ }
+
+ /*
+ * Evaluate as boolean (false means an empty string).
+ */
+ operator bool() const noexcept /* NOLINT(google-explicit-constructor) */
+ {
+ return *this->data();
+ }
+
+ /*
+ * Alias of data().
+ */
+ const char *operator*() const noexcept
+ {
+ return this->data();
+ }
+
+ /*
+ * Alias of data().
+ *
+ * data() must not return `nullptr`.
+ */
+ const char *begin() const noexcept
+ {
+ return this->data();
+ }
+
+ /*
+ * Pointer to the null character of the viewed C string.
+ *
+ * data() must not return `nullptr`.
+ */
+ const char *end() const noexcept
+ {
+ return _str + this->len();
+ }
+
+ /*
+ * Length of the viewed C string, excluding the null character.
+ *
+ * data() must not return `nullptr`.
+ */
+ std::size_t len() const noexcept
+ {
+ return std::strlen(_str);
+ }
+
+ /*
+ * Returns an `std::string` instance containing a copy of the viewed
+ * C string.
+ *
+ * data() must not return `nullptr`.
+ */
+ std::string str() const
+ {
+ return std::string{ _str };
+ }
+
+ /*
+ * Alias of str().
+ */
+ operator std::string() const /* NOLINT(google-explicit-constructor) */
+ {
+ return this->str();
+ }
+
+ /*
+ * Returns the character at index `i`.
+ *
+ * `i` must be less than what len() returns.
+ *
+ * data() must not return `nullptr`.
+ */
+ char operator[](const std::size_t i) const noexcept
+ {
+ return _str[i];
+ }
+
+ bool startsWith(const lttng::c_string_view prefix) const noexcept
+ {
+ return std::strncmp(_str, (const char *) prefix, prefix.len()) == 0;
+ }
+
+private:
+ const char *_str = nullptr;
+};
+
+inline const char *format_as(const c_string_view& str)
+{
+ return str ? *str : "(null)";
+}
+
+namespace internal {
+
+template <typename StrT>
+const char *as_const_char_ptr(StrT&& val) noexcept
+{
+ return val.data();
+}
+
+inline const char *as_const_char_ptr(const char *const val) noexcept
+{
+ return val;
+}
+
+template <typename StrT>
+using comparable_with_c_string_view = lttng::traits::
+ is_one_of<typename std::decay<StrT>::type, c_string_view, std::string, const char *>;
+
+} /* namespace internal */
+
+/*
+ * Returns true if `lhs` is equal to `rhs`.
+ *
+ * `LhsT` and `RhsT` may be any of:
+ *
+ * • `const char *`
+ * • `std::string`
+ * • `c_string_view`
+ *
+ * Both `lhs` and `rhs` must not have an underlying `nullptr` raw data.
+ */
+template <
+ typename LhsT,
+ typename RhsT,
+ typename =
+ typename std::enable_if<internal::comparable_with_c_string_view<LhsT>::value>::type,
+ typename =
+ typename std::enable_if<internal::comparable_with_c_string_view<RhsT>::value>::type>
+bool operator==(LhsT&& lhs, RhsT&& rhs) noexcept
+{
+ const auto raw_lhs = internal::as_const_char_ptr(lhs);
+ const auto raw_rhs = internal::as_const_char_ptr(rhs);
+
+ return std::strcmp(raw_lhs, raw_rhs) == 0;
+}
+
+/*
+ * Returns true if `lhs` is not equal to `rhs`.
+ *
+ * `LhsT` and `RhsT` may be any of:
+ *
+ * • `const char *`
+ * • `std::string`
+ * • `c_string_view`
+ *
+ * Both `lhs` and `rhs` must not have an underlying `nullptr` raw data.
+ */
+template <
+ typename LhsT,
+ typename RhsT,
+ typename =
+ typename std::enable_if<internal::comparable_with_c_string_view<LhsT>::value>::type,
+ typename =
+ typename std::enable_if<internal::comparable_with_c_string_view<RhsT>::value>::type>
+bool operator!=(LhsT&& lhs, RhsT&& rhs) noexcept
+{
+ return !(std::forward<LhsT>(lhs) == std::forward<RhsT>(rhs));
+}
+
+} /* namespace lttng */
+
+/*
+ * Appends `rhs` to `lhs`.
+ */
+inline void operator+=(std::string& lhs, lttng::c_string_view rhs)
+{
+ lhs += rhs.data();
+}
+
+namespace std {
+template <>
+struct hash<lttng::c_string_view> {
+ std::size_t operator()(const lttng::c_string_view& str) const
+ {
+ auto hash_value = std::hash<char>{}('\0');
+
+ for (auto character : str) {
+ hash_value ^= std::hash<decltype(character)>{}(character);
+ }
+
+ return hash_value;
+ }
+};
+} /* namespace std */
+
+#endif /* LTTNG_C_STRING_VIEW_HPP */
--- /dev/null
+/*
+ * Copyright (c) 2023 Philippe Proulx <pproulx@efficios.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef LTTNG_TYPE_TRAITS_HPP
+#define LTTNG_TYPE_TRAITS_HPP
+
+#include <type_traits>
+
+namespace lttng {
+namespace traits {
+
+/*
+ * Provides the member constant `value` equal to:
+ *
+ * `T` is in the list of types `Ts`:
+ * `true`
+ *
+ * Otherwise:
+ * `false`
+ */
+template <typename T, typename... Ts>
+struct is_one_of : std::false_type {
+};
+
+template <typename T, typename... Ts>
+struct is_one_of<T, T, Ts...> : std::true_type {
+};
+
+template <typename T, typename U, typename... Ts>
+struct is_one_of<T, U, Ts...> : is_one_of<T, Ts...> {
+};
+} /* namespace traits */
+} /* namespace lttng */
+
+#endif /* LTTNG_TYPE_TRAITS_HPP */
# SPDX-License-Identifier: GPL-2.0-only
+EXTRA_DIST = common.hpp
+
noinst_PROGRAMS = validate_xml extract_xml pretty_xml
validate_xml_SOURCES = validate_xml.cpp
validate_xml_CPPFLAGS = $(libxml2_CFLAGS) $(AM_CPPFLAGS)
extract_xml_CPPFLAGS = $(libxml2_CFLAGS) $(AM_CPPFLAGS)
extract_xml_LDADD = $(libxml2_LIBS)
-pretty_xml_SOURCES = pretty_xml.c
+pretty_xml_SOURCES = pretty_xml.cpp
pretty_xml_CPPFLAGS = $(libxml2_CFLAGS) $(AM_CPPFLAGS)
pretty_xml_LDADD = $(libxml2_LIBS)
--- /dev/null
+/*
+ * Copyright (C) 2024 EfficiOS Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ */
+
+#ifndef TESTS_UTILS_XML_UTILS_COMMON_HPP
+#define TESTS_UTILS_XML_UTILS_COMMON_HPP
+
+#include "common/make-unique-wrapper.hpp"
+
+#include <libxml/parser.h>
+#include <memory>
+
+namespace lttng {
+namespace libxml {
+
+using parser_ctx_uptr = std::unique_ptr<
+ xmlParserCtxt,
+ lttng::memory::create_deleter_class<xmlParserCtxt, xmlFreeParserCtxt>::deleter>;
+using doc_uptr =
+ std::unique_ptr<xmlDoc, lttng::memory::create_deleter_class<xmlDoc, xmlFreeDoc>::deleter>;
+
+/*
+ * Manage the global parser context of libxml2.
+ * There should only be one instance of this class per process.
+ */
+class global_parser_context {
+public:
+ global_parser_context()
+ {
+ xmlInitParser();
+ }
+
+ ~global_parser_context()
+ {
+ xmlCleanupParser();
+ }
+
+ /* Deactivate copy and assignment. */
+ global_parser_context(const global_parser_context&) = delete;
+ global_parser_context(global_parser_context&&) = delete;
+ global_parser_context& operator=(const global_parser_context&) = delete;
+ global_parser_context& operator=(global_parser_context&&) = delete;
+};
+} /* namespace libxml */
+} /* namespace lttng */
+#endif /* TESTS_UTILS_XML_UTILS_COMMON_HPP */
* node;b;
* node;c;
*/
+#include "common.hpp"
+
#include <common/defaults.hpp>
#include <libxml/parser.h>
#include <string.h>
#include <unistd.h>
+namespace ll = lttng::libxml;
+
#if defined(LIBXML_XPATH_ENABLED)
static int opt_verbose;
LTTNG_ASSERT(xml_path);
LTTNG_ASSERT(xpath);
+ ll::parser_ctx_uptr parserCtx{ xmlNewParserCtxt() };
+
+ if (!parserCtx) {
+ fprintf(stderr, "ERR: could not allocate an XML parser context\n");
+ return -1;
+ }
+
/* Parse the xml file */
- doc = xmlParseFile(xml_path);
+ doc = xmlCtxtReadFile(parserCtx.get(), xml_path, nullptr, XML_PARSE_NOBLANKS);
if (!doc) {
fprintf(stderr, "ERR parsing: xml file invalid \"%s\"\n", xml_path);
return -1;
/* Init libxml */
xmlInitParser();
- xmlKeepBlanksDefault(0);
if (access(argv[optind], F_OK)) {
fprintf(stderr, "ERR:%s\n", "Xml path not valid");
return -1;
+++ /dev/null
-/*
- * Copyright (C) 2021 EfficiOS Inc.
- *
- * SPDX-License-Identifier: GPL-2.0-only
- *
- */
-
-/*
- * Prettyfi a xml input from stdin to stddout.
- * This allows a more human friendly format for xml testing when problems occur.
- */
-
-#include <libxml/parser.h>
-
-int main(void)
-{
- xmlDocPtr doc = NULL;
-
- /* Init libxml. */
- xmlInitParser();
- xmlKeepBlanksDefault(0);
-
- /* Parse the XML document from stdin. */
- doc = xmlParseFile("-");
- if (!doc) {
- fprintf(stderr, "ERR parsing: xml input invalid");
- return -1;
- }
-
- xmlDocFormatDump(stdout, doc, 1);
-
- xmlFreeDoc(doc);
- /* Shutdown libxml. */
- xmlCleanupParser();
-
- return 0;
-}
--- /dev/null
+/*
+ * Copyright (C) 2021 EfficiOS Inc.
+ *
+ * SPDX-License-Identifier: GPL-2.0-only
+ *
+ */
+
+/*
+ * Prettyfi a xml input from stdin to stddout.
+ * This allows a more human friendly format for xml testing when problems occur.
+ */
+
+#include "common.hpp"
+
+#include <common/scope-exit.hpp>
+
+#include <iostream>
+#include <libxml/parser.h>
+#include <unistd.h>
+
+namespace ll = lttng::libxml;
+
+int main()
+{
+ const ll::global_parser_context global_parser_context;
+ const ll::parser_ctx_uptr parserCtx{ xmlNewParserCtxt() };
+
+ /* Parse the XML document from stdin. */
+ const ll::doc_uptr doc{ xmlCtxtReadFd(
+ parserCtx.get(), STDIN_FILENO, nullptr, nullptr, XML_PARSE_NOBLANKS) };
+ if (!doc) {
+ std::cerr << "Error: invalid XML input on stdin\n";
+ return -1;
+ }
+
+ xmlDocFormatDump(stdout, doc.get(), 1);
+
+ return 0;
+}
projects / lttng-tools.git / commitdiff
