2fc2dff87b8e72f074d8e524f33580aae01f1550
[lttng-tools.git] / 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
37 * the registry. Can nest within the ust app session lock.
38 * Also acts as a registry serialization lock. Used by registry
39 * readers to serialize the registry information sent from the
40 * sessiond to the consumerd.
41 * The consumer socket lock nests within this lock.
42 */
43 pthread_mutex_t lock;
44 /* Next channel ID available for a newly registered channel. */
45 uint32_t next_channel_id;
46 /* Once this value reaches UINT32_MAX, no more id can be allocated. */
47 uint32_t used_channel_id;
48 /* Next enumeration ID available. */
49 uint64_t next_enum_id;
50 /* Universal unique identifier used by the tracer. */
51 unsigned char uuid[UUID_LEN];
52
53 /* session ABI description */
54
55 /* Size of long, in bits */
56 unsigned int bits_per_long;
57 /* Alignment, in bits */
58 unsigned int uint8_t_alignment,
59 uint16_t_alignment,
60 uint32_t_alignment,
61 uint64_t_alignment,
62 long_alignment;
63 /* endianness */
64 int byte_order; /* BIG_ENDIAN or LITTLE_ENDIAN */
65
66 /* Generated metadata. */
67 char *metadata; /* NOT null-terminated ! Use memcpy. */
68 size_t metadata_len, metadata_alloc_len;
69 /* Length of bytes sent to the consumer. */
70 size_t metadata_len_sent;
71 /* Current version of the metadata. */
72 uint64_t metadata_version;
73
74 /*
75 * Those fields are only used when a session is created with
76 * the --shm-path option. In this case, the metadata is output
77 * twice: once to the consumer, as ususal, but a second time
78 * also in the shm path directly. This is done so that a copy
79 * of the metadata that is as fresh as possible is available
80 * on the event of a crash.
81 *
82 * root_shm_path contains the shm-path provided by the user, along with
83 * the session's name and timestamp:
84 * e.g. /tmp/my_shm/my_session-20180612-135822
85 *
86 * shm_path contains the full path of the memory buffers:
87 * e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit
88 *
89 * metadata_path contains the full path to the metadata file that
90 * is kept for the "crash buffer" extraction:
91 * e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit/metadata
92 *
93 * Note that this is not the trace's final metadata file. It is
94 * only meant to be used to read the contents of the ring buffers
95 * in the event of a crash.
96 *
97 * metadata_fd is a file descriptor that points to the file at
98 * 'metadata_path'.
99 */
100 char root_shm_path[PATH_MAX];
101 char shm_path[PATH_MAX];
102 char metadata_path[PATH_MAX];
103 int metadata_fd; /* file-backed metadata FD */
104
105 /*
106 * Hash table containing channels sent by the UST tracer. MUST
107 * be accessed with a RCU read side lock acquired.
108 */
109 struct lttng_ht *channels;
110 /*
111 * Unique key to identify the metadata on the consumer side.
112 */
113 uint64_t metadata_key;
114 /*
115 * Indicates if the metadata is closed on the consumer side. This is to
116 * avoid double close of metadata when an application unregisters AND
117 * deletes its sessions.
118 */
119 unsigned int metadata_closed;
120
121 /* User and group owning the session. */
122 uid_t uid;
123 gid_t gid;
124
125 /* Enumerations table. */
126 struct lttng_ht *enums;
127
128 /*
129 * Copy of the tracer version when the first app is registered.
130 * It is used if we need to regenerate the metadata.
131 */
132 uint32_t major;
133 uint32_t minor;
134
135 /* The id of the parent session */
136 uint64_t tracing_id;
137 uid_t tracing_uid;
138 };
139
140 struct ust_registry_channel {
141 uint64_t key;
142 uint64_t consumer_key;
143 /* Id set when replying to a register channel. */
144 uint32_t chan_id;
145 enum ustctl_channel_header header_type;
146
147 /*
148 * Flag for this channel if the metadata was dumped once during
149 * registration. 0 means no, 1 yes.
150 */
151 unsigned int metadata_dumped;
152 /* Indicates if this channel registry has already been registered. */
153 unsigned int register_done;
154
155 /*
156 * Hash table containing events sent by the UST tracer. MUST be accessed
157 * with a RCU read side lock acquired.
158 */
159 struct lttng_ht *ht;
160 /* Next event ID available for a newly registered event. */
161 uint32_t next_event_id;
162 /* Once this value reaches UINT32_MAX, no more id can be allocated. */
163 uint32_t used_event_id;
164 /*
165 * Context fields of the registry. Context are per channel. Allocated by a
166 * register channel notification from the UST tracer.
167 */
168 size_t nr_ctx_fields;
169 struct ustctl_field *ctx_fields;
170 struct lttng_ht_node_u64 node;
171 /* For delayed reclaim */
172 struct rcu_head rcu_head;
173 };
174
175 /*
176 * Event registered from a UST tracer sent to the session daemon. This is
177 * indexed and matched by <event_name/signature>.
178 */
179 struct ust_registry_event {
180 int id;
181 /* Both objd are set by the tracer. */
182 int session_objd;
183 int channel_objd;
184 /* Name of the event returned by the tracer. */
185 char name[LTTNG_UST_SYM_NAME_LEN];
186 char *signature;
187 int loglevel_value;
188 size_t nr_fields;
189 struct ustctl_field *fields;
190 char *model_emf_uri;
191 /*
192 * Flag for this channel if the metadata was dumped once during
193 * registration. 0 means no, 1 yes.
194 */
195 unsigned int metadata_dumped;
196 /*
197 * Node in the ust-registry hash table. The event name is used to
198 * initialize the node and the event_name/signature for the match function.
199 */
200 struct lttng_ht_node_u64 node;
201 };
202
203 struct ust_registry_enum {
204 char name[LTTNG_UST_SYM_NAME_LEN];
205 struct ustctl_enum_entry *entries;
206 size_t nr_entries;
207 uint64_t id; /* enum id in session */
208 /* Enumeration node in session hash table. */
209 struct lttng_ht_node_str node;
210 /* For delayed reclaim. */
211 struct rcu_head rcu_head;
212 };
213
214 /*
215 * Validate that the id has reached the maximum allowed or not.
216 *
217 * Return 0 if NOT else 1.
218 */
219 static inline int ust_registry_is_max_id(uint32_t id)
220 {
221 return (id == UINT32_MAX) ? 1 : 0;
222 }
223
224 /*
225 * Return next available event id and increment the used counter. The
226 * ust_registry_is_max_id function MUST be called before in order to validate
227 * if the maximum number of IDs have been reached. If not, it is safe to call
228 * this function.
229 *
230 * Return a unique channel ID. If max is reached, the used_event_id counter is
231 * returned.
232 */
233 static inline uint32_t ust_registry_get_next_event_id(
234 struct ust_registry_channel *r)
235 {
236 if (ust_registry_is_max_id(r->used_event_id)) {
237 return r->used_event_id;
238 }
239
240 r->used_event_id++;
241 return r->next_event_id++;
242 }
243
244 /*
245 * Return next available channel id and increment the used counter. The
246 * ust_registry_is_max_id function MUST be called before in order to validate
247 * if the maximum number of IDs have been reached. If not, it is safe to call
248 * this function.
249 *
250 * Return a unique channel ID. If max is reached, the used_channel_id counter
251 * is returned.
252 */
253 static inline uint32_t ust_registry_get_next_chan_id(
254 struct ust_registry_session *r)
255 {
256 if (ust_registry_is_max_id(r->used_channel_id)) {
257 return r->used_channel_id;
258 }
259
260 r->used_channel_id++;
261 return r->next_channel_id++;
262 }
263
264 /*
265 * Return registry event count. This is read atomically.
266 */
267 static inline uint32_t ust_registry_get_event_count(
268 struct ust_registry_channel *r)
269 {
270 return (uint32_t) uatomic_read(&r->used_event_id);
271 }
272
273 #ifdef HAVE_LIBLTTNG_UST_CTL
274
275 void ust_registry_channel_destroy(struct ust_registry_session *session,
276 struct ust_registry_channel *chan);
277 struct ust_registry_channel *ust_registry_channel_find(
278 struct ust_registry_session *session, uint64_t key);
279 int ust_registry_channel_add(struct ust_registry_session *session,
280 uint64_t key);
281 void ust_registry_channel_del_free(struct ust_registry_session *session,
282 uint64_t key, bool notif);
283
284 int ust_registry_session_init(struct ust_registry_session **sessionp,
285 struct ust_app *app,
286 uint32_t bits_per_long,
287 uint32_t uint8_t_alignment,
288 uint32_t uint16_t_alignment,
289 uint32_t uint32_t_alignment,
290 uint32_t uint64_t_alignment,
291 uint32_t long_alignment,
292 int byte_order,
293 uint32_t major,
294 uint32_t minor,
295 const char *root_shm_path,
296 const char *shm_path,
297 uid_t euid,
298 gid_t egid,
299 uint64_t tracing_id,
300 uid_t tracing_uid);
301 void ust_registry_session_destroy(struct ust_registry_session *session);
302
303 int ust_registry_create_event(struct ust_registry_session *session,
304 uint64_t chan_key, int session_objd, int channel_objd, char *name,
305 char *sig, size_t nr_fields, struct ustctl_field *fields,
306 int loglevel_value, char *model_emf_uri, int buffer_type,
307 uint32_t *event_id_p, struct ust_app *app);
308 struct ust_registry_event *ust_registry_find_event(
309 struct ust_registry_channel *chan, char *name, char *sig);
310 void ust_registry_destroy_event(struct ust_registry_channel *chan,
311 struct ust_registry_event *event);
312
313 /* app can be NULL for registry shared across applications. */
314 int ust_metadata_session_statedump(struct ust_registry_session *session,
315 struct ust_app *app, uint32_t major, uint32_t minor);
316 int ust_metadata_channel_statedump(struct ust_registry_session *session,
317 struct ust_registry_channel *chan);
318 int ust_metadata_event_statedump(struct ust_registry_session *session,
319 struct ust_registry_channel *chan,
320 struct ust_registry_event *event);
321 int ust_registry_create_or_find_enum(struct ust_registry_session *session,
322 int session_objd, char *name,
323 struct ustctl_enum_entry *entries, size_t nr_entries,
324 uint64_t *enum_id);
325 struct ust_registry_enum *
326 ust_registry_lookup_enum_by_id(struct ust_registry_session *session,
327 const char *name, uint64_t id);
328
329 #else /* HAVE_LIBLTTNG_UST_CTL */
330
331 static inline
332 void ust_registry_channel_destroy(struct ust_registry_session *session,
333 struct ust_registry_channel *chan)
334 {}
335 static inline
336 struct ust_registry_channel *ust_registry_channel_find(
337 struct ust_registry_session *session, uint64_t key)
338 {
339 return NULL;
340 }
341 static inline
342 int ust_registry_channel_add(struct ust_registry_session *session,
343 uint64_t key)
344 {
345 return 0;
346 }
347 static inline
348 void ust_registry_channel_del_free(struct ust_registry_session *session,
349 uint64_t key, bool notif)
350 {}
351 static inline
352 int ust_registry_session_init(struct ust_registry_session **sessionp,
353 struct ust_app *app,
354 uint32_t bits_per_long,
355 uint32_t uint8_t_alignment,
356 uint32_t uint16_t_alignment,
357 uint32_t uint32_t_alignment,
358 uint32_t uint64_t_alignment,
359 uint32_t long_alignment,
360 int byte_order,
361 uint32_t major,
362 uint32_t minor,
363 const char *root_shm_path,
364 const char *shm_path,
365 uid_t euid,
366 gid_t egid,
367 uint64_t tracing_id,
368 uid_t tracing_uid);
369 {
370 return 0;
371 }
372 static inline
373 void ust_registry_session_destroy(struct ust_registry_session *session)
374 {}
375 static inline
376 int ust_registry_create_event(struct ust_registry_session *session,
377 uint64_t chan_key, int session_objd, int channel_objd, char *name,
378 char *sig, size_t nr_fields, struct ustctl_field *fields,
379 int loglevel_value, char *model_emf_uri, int buffer_type,
380 uint32_t *event_id_p)
381 {
382 return 0;
383 }
384 static inline
385 struct ust_registry_event *ust_registry_find_event(
386 struct ust_registry_channel *chan, char *name, char *sig)
387 {
388 return NULL;
389 }
390 static inline
391 void ust_registry_destroy_event(struct ust_registry_channel *chan,
392 struct ust_registry_event *event)
393 {}
394
395 /* The app object can be NULL for registry shared across applications. */
396 static inline
397 int ust_metadata_session_statedump(struct ust_registry_session *session,
398 struct ust_app *app, uint32_t major, uint32_t minor)
399 {
400 return 0;
401 }
402 static inline
403 int ust_metadata_channel_statedump(struct ust_registry_session *session,
404 struct ust_registry_channel *chan)
405 {
406 return 0;
407 }
408 static inline
409 int ust_metadata_event_statedump(struct ust_registry_session *session,
410 struct ust_registry_channel *chan,
411 struct ust_registry_event *event)
412 {
413 return 0;
414 }
415 static inline
416 int ust_registry_create_or_find_enum(struct ust_registry_session *session,
417 int session_objd, char *name,
418 struct ustctl_enum_entry *entries, size_t nr_entries,
419 uint64_t *enum_id)
420 {
421 return 0;
422 }
423 static inline
424 struct ust_registry_enum *
425 ust_registry_lookup_enum_by_id(struct ust_registry_session *session,
426 const char *name, uint64_t id)
427 {
428 return NULL;
429 }
430
431 #endif /* HAVE_LIBLTTNG_UST_CTL */
432
433 #endif /* LTTNG_UST_REGISTRY_H */
This page took 0.057027 seconds and 3 git commands to generate.