src/bin/lttng/utils.hpp

   1 /*
   2  * Copyright (C) 2011 EfficiOS Inc.
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #ifndef _LTTNG_UTILS_H
   9 #define _LTTNG_UTILS_H
  10
  11 #include <common/argpar/argpar.h>
  12 #include <common/dynamic-array.hpp>
  13 #include <common/make-unique-wrapper.hpp>
  14
  15 #include <lttng/lttng.h>
  16
  17 #include <iterator>
  18 #include <memory>
  19 #include <popt.h>
  20
  21 extern char *opt_relayd_path;
  22 extern int opt_no_sessiond;
  23 extern char *opt_sessiond_path;
  24 extern pid_t sessiond_pid;
  25
  26 struct cmd_struct;
  27
  28 struct session_spec {
  29         enum type {
  30                 NAME,
  31                 GLOB_PATTERN,
  32                 ALL,
  33         };
  34
  35         type type;
  36         const char *value;
  37 };
  38
  39 /*
  40  * We don't use a std::vector here because it would make a copy of the C array.
  41  */
  42 class session_list {
  43         template <typename ContainerType, typename DereferenceReturnType>
  44         class iterator_template : public std::iterator<std::random_access_iterator_tag, std::size_t> {
  45         public:
  46                 explicit iterator_template(ContainerType& list, std::size_t k) : _list(list), _index(k)
  47                 {
  48                 }
  49
  50                 iterator_template& operator++() noexcept
  51                 {
  52                         ++_index;
  53                         return *this;
  54                 }
  55
  56                 iterator_template& operator--() noexcept
  57                 {
  58                         --_index;
  59                         return *this;
  60                 }
  61
  62                 iterator_template& operator++(int) noexcept
  63                 {
  64                         _index++;
  65                         return *this;
  66                 }
  67
  68                 iterator_template& operator--(int) noexcept
  69                 {
  70                         _index--;
  71                         return *this;
  72                 }
  73
  74                 bool operator==(iterator_template other) const noexcept
  75                 {
  76                         return _index == other._index;
  77                 }
  78
  79                 bool operator!=(iterator_template other) const noexcept
  80                 {
  81                         return !(*this == other);
  82                 }
  83
  84                 DereferenceReturnType& operator*() const noexcept
  85                 {
  86                         return _list[_index];
  87                 }
  88
  89         private:
  90                 ContainerType& _list;
  91                 std::size_t _index;
  92         };
  93
  94         using iterator = iterator_template<session_list, lttng_session>;
  95         using const_iterator = iterator_template<const session_list, const lttng_session>;
  96
  97 public:
  98         session_list() : _sessions_count(0), _sessions(nullptr)
  99         {
 100         }
 101
 102         session_list(session_list&& original, std::size_t new_count)
 103         {
 104                 _sessions_count = new_count;
 105                 _sessions = std::move(original._sessions);
 106         }
 107
 108         session_list(struct lttng_session *raw_sessions, std::size_t raw_sessions_count)
 109         {
 110                 _sessions_count = raw_sessions_count;
 111                 _sessions.reset(raw_sessions);
 112         }
 113
 114         iterator begin() noexcept
 115         {
 116                 return iterator(*this, 0);
 117         }
 118
 119         iterator end() noexcept
 120         {
 121                 return iterator(*this, _sessions_count);
 122         }
 123
 124         const_iterator begin() const noexcept
 125         {
 126                 return const_iterator(*this, 0);
 127         }
 128
 129         const_iterator end() const noexcept
 130         {
 131                 return const_iterator(*this, _sessions_count);
 132         }
 133
 134         std::size_t size() const noexcept
 135         {
 136                 return _sessions_count;
 137         }
 138
 139         void resize(std::size_t new_size) noexcept
 140         {
 141                 _sessions_count = new_size;
 142         }
 143
 144         lttng_session& operator[](std::size_t index)
 145         {
 146                 LTTNG_ASSERT(index < _sessions_count);
 147                 return _sessions.get()[index];
 148         }
 149
 150         const lttng_session& operator[](std::size_t index) const
 151         {
 152                 LTTNG_ASSERT(index < _sessions_count);
 153                 return _sessions.get()[index];
 154         }
 155
 156 private:
 157         std::size_t _sessions_count;
 158         std::unique_ptr<lttng_session,
 159                         lttng::memory::create_deleter_class<lttng_session, lttng::free>::deleter>
 160                 _sessions;
 161 };
 162
 163 char *get_session_name(void);
 164 char *get_session_name_quiet(void);
 165 void list_commands(struct cmd_struct *commands, FILE *ofp);
 166 void list_cmd_options(FILE *ofp, struct poptOption *options);
 167 void list_cmd_options_argpar(FILE *ofp, const struct argpar_opt_descr *options);
 168
 169 /*
 170  * Return the minimum order for which x <= (1UL << order).
 171  * Return -1 if x is 0.
 172  */
 173 int get_count_order_u32(uint32_t x);
 174
 175 /*
 176  * Return the minimum order for which x <= (1UL << order).
 177  * Return -1 if x is 0.
 178  */
 179 int get_count_order_u64(uint64_t x);
 180
 181 /*
 182  * Return the minimum order for which x <= (1UL << order).
 183  * Return -1 if x is 0.
 184  */
 185 int get_count_order_ulong(unsigned long x);
 186
 187 const char *get_event_type_str(enum lttng_event_type event_type);
 188
 189 int print_missing_or_multiple_domains(unsigned int domain_count, bool include_agent_domains);
 190
 191 int spawn_relayd(const char *pathname, int port);
 192 int check_relayd(void);
 193 void print_session_stats(const char *session_name);
 194 int get_session_stats_str(const char *session_name, char **str);
 195 int show_cmd_help(const char *cmd_name, const char *help_msg);
 196
 197 int print_trace_archive_location(const struct lttng_trace_archive_location *location,
 198                                  const char *session_name);
 199
 200 int validate_exclusion_list(const char *event_name,
 201                             const struct lttng_dynamic_pointer_array *exclusions);
 202
 203 session_list list_sessions(const struct session_spec& spec);
 204
 205 #endif /* _LTTNG_UTILS_H */