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
  45                 : public std::iterator<std::random_access_iterator_tag, std::size_t> {
  46         public:
  47                 explicit _iterator(ContainerType& list, std::size_t k) :
  48                         _list(list), _index(k)
  49                 {
  50                 }
  51
  52                 _iterator& operator++() noexcept
  53                 {
  54                         ++_index;
  55                         return *this;
  56                 }
  57
  58                 _iterator& operator--() noexcept
  59                 {
  60                         --_index;
  61                         return *this;
  62                 }
  63
  64                 _iterator& operator++(int) noexcept
  65                 {
  66                         _index++;
  67                         return *this;
  68                 }
  69
  70                 _iterator& operator--(int) noexcept
  71                 {
  72                         _index--;
  73                         return *this;
  74                 }
  75
  76                 bool operator==(_iterator other) const noexcept
  77                 {
  78                         return _index == other._index;
  79                 }
  80
  81                 bool operator!=(_iterator other) const noexcept
  82                 {
  83                         return !(*this == other);
  84                 }
  85
  86                 DereferenceReturnType& operator*() const noexcept
  87                 {
  88                         return _list[_index];
  89                 }
  90
  91         private:
  92                 ContainerType& _list;
  93                 std::size_t _index;
  94         };
  95
  96         using iterator = _iterator<session_list, lttng_session>;
  97         using const_iterator = _iterator<const session_list, const lttng_session>;
  98
  99 public:
 100         session_list() : _sessions_count(0), _sessions(nullptr)
 101         {
 102         }
 103
 104         session_list(session_list&& original, std::size_t new_count)
 105         {
 106                 _sessions_count = new_count;
 107                 _sessions = std::move(original._sessions);
 108         }
 109
 110         session_list(struct lttng_session *raw_sessions, std::size_t raw_sessions_count)
 111         {
 112                 _sessions_count = raw_sessions_count;
 113                 _sessions.reset(raw_sessions);
 114         }
 115
 116         iterator begin() noexcept
 117         {
 118                 return iterator(*this, 0);
 119         }
 120
 121         iterator end() noexcept
 122         {
 123                 return iterator(*this, _sessions_count);
 124         }
 125
 126         const_iterator begin() const noexcept
 127         {
 128                 return const_iterator(*this, 0);
 129         }
 130
 131         const_iterator end() const noexcept
 132         {
 133                 return const_iterator(*this, _sessions_count);
 134         }
 135
 136         std::size_t size() const noexcept
 137         {
 138                 return _sessions_count;
 139         }
 140
 141         void resize(std::size_t new_size) noexcept
 142         {
 143                 _sessions_count = new_size;
 144         }
 145
 146         lttng_session& operator[](std::size_t index)
 147         {
 148                 LTTNG_ASSERT(index < _sessions_count);
 149                 return _sessions.get()[index];
 150         }
 151
 152         const lttng_session& operator[](std::size_t index) const
 153         {
 154                 LTTNG_ASSERT(index < _sessions_count);
 155                 return _sessions.get()[index];
 156         }
 157
 158 private:
 159         std::size_t _sessions_count;
 160         std::unique_ptr<lttng_session,
 161                         lttng::memory::create_deleter_class<lttng_session, lttng::free>::deleter>
 162                 _sessions;
 163 };
 164
 165 char *get_session_name(void);
 166 char *get_session_name_quiet(void);
 167 void list_commands(struct cmd_struct *commands, FILE *ofp);
 168 void list_cmd_options(FILE *ofp, struct poptOption *options);
 169 void list_cmd_options_argpar(FILE *ofp, const struct argpar_opt_descr *options);
 170
 171 /*
 172  * Return the minimum order for which x <= (1UL << order).
 173  * Return -1 if x is 0.
 174  */
 175 int get_count_order_u32(uint32_t x);
 176
 177 /*
 178  * Return the minimum order for which x <= (1UL << order).
 179  * Return -1 if x is 0.
 180  */
 181 int get_count_order_u64(uint64_t x);
 182
 183 /*
 184  * Return the minimum order for which x <= (1UL << order).
 185  * Return -1 if x is 0.
 186  */
 187 int get_count_order_ulong(unsigned long x);
 188
 189 const char *get_event_type_str(enum lttng_event_type event_type);
 190
 191 int print_missing_or_multiple_domains(unsigned int domain_count, bool include_agent_domains);
 192
 193 int spawn_relayd(const char *pathname, int port);
 194 int check_relayd(void);
 195 void print_session_stats(const char *session_name);
 196 int get_session_stats_str(const char *session_name, char **str);
 197 int show_cmd_help(const char *cmd_name, const char *help_msg);
 198
 199 int print_trace_archive_location(const struct lttng_trace_archive_location *location,
 200                                  const char *session_name);
 201
 202 int validate_exclusion_list(const char *event_name,
 203                             const struct lttng_dynamic_pointer_array *exclusions);
 204
 205 session_list list_sessions(const struct session_spec& spec);
 206
 207 #endif /* _LTTNG_UTILS_H */