src/bin/lttng-sessiond/ust-registry.h

   1 /*
   2  * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License, version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 51
  15  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #ifndef LTTNG_UST_REGISTRY_H
  19 #define LTTNG_UST_REGISTRY_H
  20
  21 #include <pthread.h>
  22 #include <stdint.h>
  23
  24 #include <common/hashtable/hashtable.h>
  25 #include <common/compat/uuid.h>
  26
  27 #include "ust-ctl.h"
  28
  29 #define CTF_SPEC_MAJOR  1
  30 #define CTF_SPEC_MINOR  8
  31
  32 struct ust_app;
  33
  34 struct ust_registry_session {
  35         /*
  36          * With multiple writers and readers, use this lock to access the registry.
  37          * Can nest within the ust app session lock.
  38          */
  39         pthread_mutex_t lock;
  40         /* Next channel ID available for a newly registered channel. */
  41         uint32_t next_channel_id;
  42         /* Once this value reaches UINT32_MAX, no more id can be allocated. */
  43         uint32_t used_channel_id;
  44         /* Universal unique identifier used by the tracer. */
  45         unsigned char uuid[UUID_LEN];
  46
  47         /* session ABI description */
  48
  49         /* Size of long, in bits */
  50         unsigned int bits_per_long;
  51         /* Alignment, in bits */
  52         unsigned int uint8_t_alignment,
  53                 uint16_t_alignment,
  54                 uint32_t_alignment,
  55                 uint64_t_alignment,
  56                 long_alignment;
  57         /* endianness */
  58         int byte_order; /* BIG_ENDIAN or LITTLE_ENDIAN */
  59
  60         /* Generated metadata. */
  61         char *metadata;         /* NOT null-terminated ! Use memcpy. */
  62         size_t metadata_len, metadata_alloc_len;
  63         /* Length of bytes sent to the consumer. */
  64         size_t metadata_len_sent;
  65         /*
  66          * Hash table containing channels sent by the UST tracer. MUST be accessed
  67          * with a RCU read side lock acquired.
  68          */
  69         struct lttng_ht *channels;
  70         /* Unique key to identify the metadata on the consumer side. */
  71         uint64_t metadata_key;
  72         /*
  73          * Indicates if the metadata is closed on the consumer side. This is to
  74          * avoid double close of metadata when an application unregisters AND
  75          * deletes its sessions.
  76          */
  77         unsigned int metadata_closed;
  78 };
  79
  80 struct ust_registry_channel {
  81         uint64_t key;
  82         /* Id set when replying to a register channel. */
  83         uint32_t chan_id;
  84         enum ustctl_channel_header header_type;
  85
  86         /*
  87          * Flag for this channel if the metadata was dumped once during
  88          * registration. 0 means no, 1 yes.
  89          */
  90         unsigned int metadata_dumped;
  91         /* Indicates if this channel registry has already been registered. */
  92         unsigned int register_done;
  93
  94         /*
  95          * Hash table containing events sent by the UST tracer. MUST be accessed
  96          * with a RCU read side lock acquired.
  97          */
  98         struct lttng_ht *ht;
  99         /* Next event ID available for a newly registered event. */
 100         uint32_t next_event_id;
 101         /* Once this value reaches UINT32_MAX, no more id can be allocated. */
 102         uint32_t used_event_id;
 103         /*
 104          * Context fields of the registry. Context are per channel. Allocated by a
 105          * register channel notification from the UST tracer.
 106          */
 107         size_t nr_ctx_fields;
 108         struct ustctl_field *ctx_fields;
 109         struct lttng_ht_node_u64 node;
 110         /* For delayed reclaim */
 111         struct rcu_head rcu_head;
 112 };
 113
 114 /*
 115  * Event registered from a UST tracer sent to the session daemon. This is
 116  * indexed and matched by <event_name/signature>.
 117  */
 118 struct ust_registry_event {
 119         int id;
 120         /* Both objd are set by the tracer. */
 121         int session_objd;
 122         int channel_objd;
 123         /* Name of the event returned by the tracer. */
 124         char name[LTTNG_UST_SYM_NAME_LEN];
 125         char *signature;
 126         int loglevel;
 127         size_t nr_fields;
 128         struct ustctl_field *fields;
 129         char *model_emf_uri;
 130         /*
 131          * Flag for this channel if the metadata was dumped once during
 132          * registration. 0 means no, 1 yes.
 133          */
 134         unsigned int metadata_dumped;
 135         /*
 136          * Node in the ust-registry hash table. The event name is used to
 137          * initialize the node and the event_name/signature for the match function.
 138          */
 139         struct lttng_ht_node_u64 node;
 140 };
 141
 142 /*
 143  * Validate that the id has reached the maximum allowed or not.
 144  *
 145  * Return 0 if NOT else 1.
 146  */
 147 static inline int ust_registry_is_max_id(uint32_t id)
 148 {
 149         return (id == UINT32_MAX) ? 1 : 0;
 150 }
 151
 152 /*
 153  * Return next available event id and increment the used counter. The
 154  * ust_registry_is_max_id function MUST be called before in order to validate
 155  * if the maximum number of IDs have been reached. If not, it is safe to call
 156  * this function.
 157  *
 158  * Return a unique channel ID. If max is reached, the used_event_id counter is
 159  * returned.
 160  */
 161 static inline uint32_t ust_registry_get_next_event_id(
 162                 struct ust_registry_channel *r)
 163 {
 164         if (ust_registry_is_max_id(r->used_event_id)) {
 165                 return r->used_event_id;
 166         }
 167
 168         r->used_event_id++;
 169         return r->next_event_id++;
 170 }
 171
 172 /*
 173  * Return next available channel id and increment the used counter. The
 174  * ust_registry_is_max_id function MUST be called before in order to validate
 175  * if the maximum number of IDs have been reached. If not, it is safe to call
 176  * this function.
 177  *
 178  * Return a unique channel ID. If max is reached, the used_channel_id counter
 179  * is returned.
 180  */
 181 static inline uint32_t ust_registry_get_next_chan_id(
 182                 struct ust_registry_session *r)
 183 {
 184         if (ust_registry_is_max_id(r->used_channel_id)) {
 185                 return r->used_channel_id;
 186         }
 187
 188         r->used_channel_id++;
 189         return r->next_channel_id++;
 190 }
 191
 192 /*
 193  * Return registry event count. This is read atomically.
 194  */
 195 static inline uint32_t ust_registry_get_event_count(
 196                 struct ust_registry_channel *r)
 197 {
 198         return (uint32_t) uatomic_read(&r->used_event_id);
 199 }
 200
 201 #ifdef HAVE_LIBLTTNG_UST_CTL
 202
 203 void ust_registry_channel_destroy(struct ust_registry_session *session,
 204                 struct ust_registry_channel *chan);
 205 struct ust_registry_channel *ust_registry_channel_find(
 206                 struct ust_registry_session *session, uint64_t key);
 207 int ust_registry_channel_add(struct ust_registry_session *session,
 208                 uint64_t key);
 209 void ust_registry_channel_del_free(struct ust_registry_session *session,
 210                 uint64_t key);
 211
 212 int ust_registry_session_init(struct ust_registry_session **sessionp,
 213                 struct ust_app *app,
 214                 uint32_t bits_per_long,
 215                 uint32_t uint8_t_alignment,
 216                 uint32_t uint16_t_alignment,
 217                 uint32_t uint32_t_alignment,
 218                 uint32_t uint64_t_alignment,
 219                 uint32_t long_alignment,
 220                 int byte_order,
 221                 uint32_t major,
 222                 uint32_t minor);
 223 void ust_registry_session_destroy(struct ust_registry_session *session);
 224
 225 int ust_registry_create_event(struct ust_registry_session *session,
 226                 uint64_t chan_key, int session_objd, int channel_objd, char *name,
 227                 char *sig, size_t nr_fields, struct ustctl_field *fields, int loglevel,
 228                 char *model_emf_uri, int buffer_type, uint32_t *event_id_p);
 229 struct ust_registry_event *ust_registry_find_event(
 230                 struct ust_registry_channel *chan, char *name, char *sig);
 231 void ust_registry_destroy_event(struct ust_registry_channel *chan,
 232                 struct ust_registry_event *event);
 233
 234 /* app can be NULL for registry shared across applications. */
 235 int ust_metadata_session_statedump(struct ust_registry_session *session,
 236                 struct ust_app *app, uint32_t major, uint32_t minor);
 237 int ust_metadata_channel_statedump(struct ust_registry_session *session,
 238                 struct ust_registry_channel *chan);
 239 int ust_metadata_event_statedump(struct ust_registry_session *session,
 240                 struct ust_registry_channel *chan,
 241                 struct ust_registry_event *event);
 242
 243 #else /* HAVE_LIBLTTNG_UST_CTL */
 244
 245 static inline
 246 void ust_registry_channel_destroy(struct ust_registry_session *session,
 247                 struct ust_registry_channel *chan)
 248 {}
 249 static inline
 250 struct ust_registry_channel *ust_registry_channel_find(
 251                 struct ust_registry_session *session, uint64_t key)
 252 {
 253         return NULL;
 254 }
 255 static inline
 256 int ust_registry_channel_add(struct ust_registry_session *session,
 257                 uint64_t key)
 258 {
 259         return 0;
 260 }
 261 static inline
 262 void ust_registry_channel_del_free(struct ust_registry_session *session,
 263                 uint64_t key)
 264 {}
 265 static inline
 266 int ust_registry_session_init(struct ust_registry_session **sessionp,
 267                 struct ust_app *app,
 268                 uint32_t bits_per_long,
 269                 uint32_t uint8_t_alignment,
 270                 uint32_t uint16_t_alignment,
 271                 uint32_t uint32_t_alignment,
 272                 uint32_t uint64_t_alignment,
 273                 uint32_t long_alignment,
 274                 int byte_order)
 275 {
 276         return 0;
 277 }
 278 static inline
 279 void ust_registry_session_destroy(struct ust_registry_session *session)
 280 {}
 281 static inline
 282 int ust_registry_create_event(struct ust_registry_session *session,
 283                 uint64_t chan_key, int session_objd, int channel_objd, char *name,
 284                 char *sig, size_t nr_fields, struct ustctl_field *fields, int loglevel,
 285                 char *model_emf_uri, int buffer_type, uint32_t *event_id_p)
 286 {
 287         return 0;
 288 }
 289 static inline
 290 struct ust_registry_event *ust_registry_find_event(
 291                 struct ust_registry_channel *chan, char *name, char *sig)
 292 {
 293         return NULL;
 294 }
 295 static inline
 296 void ust_registry_destroy_event(struct ust_registry_channel *chan,
 297                 struct ust_registry_event *event)
 298 {}
 299
 300 /* The app object can be NULL for registry shared across applications. */
 301 static inline
 302 int ust_metadata_session_statedump(struct ust_registry_session *session,
 303                 struct ust_app *app)
 304 {
 305         return 0;
 306 }
 307 static inline
 308 int ust_metadata_channel_statedump(struct ust_registry_session *session,
 309                 struct ust_registry_channel *chan)
 310 {
 311         return 0;
 312 }
 313 static inline
 314 int ust_metadata_event_statedump(struct ust_registry_session *session,
 315                 struct ust_registry_channel *chan,
 316                 struct ust_registry_event *event)
 317 {
 318         return 0;
 319 }
 320
 321 #endif /* HAVE_LIBLTTNG_UST_CTL */
 322
 323 #endif /* LTTNG_UST_REGISTRY_H */