From ca938aa52e0d841fc638ecffb4261a80d846831f Mon Sep 17 00:00:00 2001 From: Olivier Dion Date: Mon, 6 Feb 2023 15:55:39 -0500 Subject: [PATCH] lttng: Add list_sessions utility MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Get a list of sessions given a session specification. The `NAME' specification returns the session that has the given name. The `GLOB_PATTERN' specification returns all sessions that match a pattern. The `ALL' specification returns all sessions. Change-Id: If69698d6dd59d54ba16669571ef49ed5bb9b8997 Signed-off-by: Olivier Dion Signed-off-by: Jérémie Galarneau --- src/bin/lttng/utils.cpp | 81 ++++++++++++++++++++++++++ src/bin/lttng/utils.hpp | 126 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 207 insertions(+) diff --git a/src/bin/lttng/utils.cpp b/src/bin/lttng/utils.cpp index 90ca90fde..5b0c461d9 100644 --- a/src/bin/lttng/utils.cpp +++ b/src/bin/lttng/utils.cpp @@ -12,10 +12,13 @@ #include #include +#include +#include #include #include #include +#include #include #include #include @@ -659,3 +662,81 @@ end: } return ret; } + +namespace { +template +session_list get_sessions(const FilterFunctionType& filter, bool return_first_match_only = false) +{ + session_list list; + + { + int list_ret; + struct lttng_session *psessions; + + list_ret = lttng_list_sessions(&psessions); + + if (list_ret < 0) { + LTTNG_THROW_CTL("Failed to list sessions", + static_cast(list_ret)); + } + + list = session_list(psessions, list_ret); + } + + std::size_t write_to = 0; + for (std::size_t read_from = 0; read_from < list.size(); ++read_from) { + if (!filter(list[read_from])) { + continue; + } + + if (read_from != write_to) { + list[write_to] = list[read_from]; + } + + ++write_to; + + if (return_first_match_only) { + return session_list(std::move(list), 1); + } + } + + list.resize(write_to); + + return list; +} +} /* namespace */ + +session_list list_sessions(const struct session_spec& spec) +{ + switch (spec.type) { + case session_spec::NAME: + if (spec.value == nullptr) { + const auto configured_name = + lttng::make_unique_wrapper(get_session_name()); + + if (configured_name) { + const struct session_spec new_spec = { + .type = session_spec::NAME, .value = configured_name.get() + }; + + return list_sessions(new_spec); + } + + return session_list(); + } + + return get_sessions( + [&spec](const lttng_session& session) { + return strcmp(session.name, spec.value) == 0; + }, + true); + case session_spec::GLOB_PATTERN: + return get_sessions([&spec](const lttng_session& session) { + return fnmatch(spec.value, session.name, 0) == 0; + }); + case session_spec::ALL: + return get_sessions([](const lttng_session&) { return true; }); + } + + return session_list(); +} diff --git a/src/bin/lttng/utils.hpp b/src/bin/lttng/utils.hpp index 64605575e..c3b442056 100644 --- a/src/bin/lttng/utils.hpp +++ b/src/bin/lttng/utils.hpp @@ -10,9 +10,12 @@ #include #include +#include #include +#include +#include #include extern char *opt_relayd_path; @@ -22,6 +25,127 @@ extern pid_t sessiond_pid; struct cmd_struct; +struct session_spec { + enum type { + NAME, + GLOB_PATTERN, + ALL, + }; + + type type; + const char *value; +}; + +/* + * We don't use a std::vector here because it would make a copy of the C array. + */ +class session_list { + class iterator : public std::iterator { + public: + explicit iterator(session_list& list, std::size_t k) : _list(list), _index(k) + { + } + + iterator& operator++() noexcept + { + ++_index; + return *this; + } + + iterator& operator--() noexcept + { + --_index; + return *this; + } + + iterator& operator++(int) noexcept + { + _index++; + return *this; + } + + iterator& operator--(int) noexcept + { + _index--; + return *this; + } + + bool operator==(iterator other) const noexcept + { + return _index == other._index; + } + + bool operator!=(iterator other) const noexcept + { + return !(*this == other); + } + + lttng_session& operator*() const noexcept + { + return _list[_index]; + } + + private: + session_list& _list; + std::size_t _index; + }; + +public: + session_list() : _sessions_count(0), _sessions(nullptr) + { + } + + session_list(session_list&& original, std::size_t new_count) + { + _sessions_count = new_count; + _sessions = std::move(original._sessions); + } + + session_list(struct lttng_session *raw_sessions, std::size_t raw_sessions_count) + { + _sessions_count = raw_sessions_count; + _sessions.reset(raw_sessions); + } + + iterator begin() noexcept + { + return iterator(*this, 0); + } + + iterator end() noexcept + { + return iterator(*this, _sessions_count); + } + + std::size_t size() const noexcept + { + return _sessions_count; + } + + void resize(std::size_t new_size) noexcept + { + _sessions_count = new_size; + } + + lttng_session& operator[](std::size_t index) + { + LTTNG_ASSERT(index < _sessions_count); + return _sessions.get()[index]; + } + + const lttng_session& operator[](std::size_t index) const + { + LTTNG_ASSERT(index < _sessions_count); + return _sessions.get()[index]; + } + +private: + std::size_t _sessions_count; + std::unique_ptr> + _sessions; +}; + char *get_session_name(void); char *get_session_name_quiet(void); void list_commands(struct cmd_struct *commands, FILE *ofp); @@ -62,4 +186,6 @@ int print_trace_archive_location(const struct lttng_trace_archive_location *loca int validate_exclusion_list(const char *event_name, const struct lttng_dynamic_pointer_array *exclusions); +session_list list_sessions(const struct session_spec& spec); + #endif /* _LTTNG_UTILS_H */ -- 2.34.1