Tests: Fix nprocesses applications shutdown
[lttng-tools.git] / src / bin / lttng-sessiond / ust-registry.c
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 #define _GNU_SOURCE
18 #include <assert.h>
19 #include <inttypes.h>
20
21 #include <common/common.h>
22 #include <common/hashtable/utils.h>
23 #include <lttng/lttng.h>
24
25 #include "ust-registry.h"
26
27 /*
28 * Hash table match function for event in the registry.
29 */
30 static int ht_match_event(struct cds_lfht_node *node, const void *_key)
31 {
32 struct ust_registry_event *event;
33 const struct ust_registry_event *key;
34
35 assert(node);
36 assert(_key);
37
38 event = caa_container_of(node, struct ust_registry_event, node.node);
39 assert(event);
40 key = _key;
41
42 /* It has to be a perfect match. */
43 if (strncmp(event->name, key->name, sizeof(event->name)) != 0) {
44 goto no_match;
45 }
46
47 /* It has to be a perfect match. */
48 if (strncmp(event->signature, key->signature,
49 strlen(event->signature) != 0)) {
50 goto no_match;
51 }
52
53 /* Match */
54 return 1;
55
56 no_match:
57 return 0;
58 }
59
60 static unsigned long ht_hash_event(void *_key, unsigned long seed)
61 {
62 uint64_t xored_key;
63 struct ust_registry_event *key = _key;
64
65 assert(key);
66
67 xored_key = (uint64_t) (hash_key_str(key->name, seed) ^
68 hash_key_str(key->signature, seed));
69
70 return hash_key_u64(&xored_key, seed);
71 }
72
73 /*
74 * Allocate event and initialize it. This does NOT set a valid event id from a
75 * registry.
76 */
77 static struct ust_registry_event *alloc_event(int session_objd,
78 int channel_objd, char *name, char *sig, size_t nr_fields,
79 struct ustctl_field *fields, int loglevel, char *model_emf_uri)
80 {
81 struct ust_registry_event *event = NULL;
82
83 event = zmalloc(sizeof(*event));
84 if (!event) {
85 PERROR("zmalloc ust registry event");
86 goto error;
87 }
88
89 event->session_objd = session_objd;
90 event->channel_objd = channel_objd;
91 /* Allocated by ustctl. */
92 event->signature = sig;
93 event->nr_fields = nr_fields;
94 event->fields = fields;
95 event->loglevel = loglevel;
96 event->model_emf_uri = model_emf_uri;
97 if (name) {
98 /* Copy event name and force NULL byte. */
99 strncpy(event->name, name, sizeof(event->name));
100 event->name[sizeof(event->name) - 1] = '\0';
101 }
102 cds_lfht_node_init(&event->node.node);
103
104 error:
105 return event;
106 }
107
108 /*
109 * Free event data structure. This does NOT delete it from any hash table. It's
110 * safe to pass a NULL pointer. This shoudl be called inside a call RCU if the
111 * event is previously deleted from a rcu hash table.
112 */
113 static void destroy_event(struct ust_registry_event *event)
114 {
115 if (!event) {
116 return;
117 }
118
119 free(event->fields);
120 free(event->model_emf_uri);
121 free(event->signature);
122 free(event);
123 }
124
125 /*
126 * Destroy event function call of the call RCU.
127 */
128 static void destroy_event_rcu(struct rcu_head *head)
129 {
130 struct lttng_ht_node_u64 *node =
131 caa_container_of(head, struct lttng_ht_node_u64, head);
132 struct ust_registry_event *event =
133 caa_container_of(node, struct ust_registry_event, node);
134
135 destroy_event(event);
136 }
137
138 /*
139 * Find an event using the name and signature in the given registry. RCU read
140 * side lock MUST be acquired before calling this function and as long as the
141 * event reference is kept by the caller.
142 *
143 * On success, the event pointer is returned else NULL.
144 */
145 struct ust_registry_event *ust_registry_find_event(
146 struct ust_registry_channel *chan, char *name, char *sig)
147 {
148 struct lttng_ht_node_u64 *node;
149 struct lttng_ht_iter iter;
150 struct ust_registry_event *event = NULL;
151 struct ust_registry_event key;
152
153 assert(chan);
154 assert(name);
155 assert(sig);
156
157 /* Setup key for the match function. */
158 strncpy(key.name, name, sizeof(key.name));
159 key.name[sizeof(key.name) - 1] = '\0';
160 key.signature = sig;
161
162 cds_lfht_lookup(chan->ht->ht, chan->ht->hash_fct(&key, lttng_ht_seed),
163 chan->ht->match_fct, &key, &iter.iter);
164 node = lttng_ht_iter_get_node_u64(&iter);
165 if (!node) {
166 goto end;
167 }
168 event = caa_container_of(node, struct ust_registry_event, node);
169
170 end:
171 return event;
172 }
173
174 /*
175 * Create a ust_registry_event from the given parameters and add it to the
176 * registry hash table. If event_id is valid, it is set with the newly created
177 * event id.
178 *
179 * On success, return 0 else a negative value. The created event MUST be unique
180 * so on duplicate entry -EINVAL is returned. On error, event_id is untouched.
181 *
182 * Should be called with session registry mutex held.
183 */
184 int ust_registry_create_event(struct ust_registry_session *session,
185 uint64_t chan_key, int session_objd, int channel_objd, char *name,
186 char *sig, size_t nr_fields, struct ustctl_field *fields, int loglevel,
187 char *model_emf_uri, int buffer_type, uint32_t *event_id_p)
188 {
189 int ret;
190 uint32_t event_id;
191 struct cds_lfht_node *nptr;
192 struct ust_registry_event *event = NULL;
193 struct ust_registry_channel *chan;
194
195 assert(session);
196 assert(name);
197 assert(sig);
198 assert(event_id_p);
199
200 /*
201 * This should not happen but since it comes from the UST tracer, an
202 * external party, don't assert and simply validate values.
203 */
204 if (session_objd < 0 || channel_objd < 0) {
205 ret = -EINVAL;
206 goto error;
207 }
208
209 rcu_read_lock();
210
211 chan = ust_registry_channel_find(session, chan_key);
212 if (!chan) {
213 ret = -EINVAL;
214 goto error_unlock;
215 }
216
217 /* Check if we've reached the maximum possible id. */
218 if (ust_registry_is_max_id(chan->used_event_id)) {
219 ret = -ENOENT;
220 goto error_unlock;
221 }
222
223 event = alloc_event(session_objd, channel_objd, name, sig, nr_fields,
224 fields, loglevel, model_emf_uri);
225 if (!event) {
226 ret = -ENOMEM;
227 goto error_unlock;
228 }
229
230 DBG3("UST registry creating event with event: %s, sig: %s, id: %u, "
231 "chan_objd: %u, sess_objd: %u, chan_id: %u", event->name,
232 event->signature, event->id, event->channel_objd,
233 event->session_objd, chan->chan_id);
234
235 /*
236 * This is an add unique with a custom match function for event. The node
237 * are matched using the event name and signature.
238 */
239 nptr = cds_lfht_add_unique(chan->ht->ht, chan->ht->hash_fct(event,
240 lttng_ht_seed), chan->ht->match_fct, event, &event->node.node);
241 if (nptr != &event->node.node) {
242 if (buffer_type == LTTNG_BUFFER_PER_UID) {
243 /*
244 * This is normal, we just have to send the event id of the
245 * returned node and make sure we destroy the previously allocated
246 * event object.
247 */
248 destroy_event(event);
249 event = caa_container_of(nptr, struct ust_registry_event,
250 node.node);
251 assert(event);
252 event_id = event->id;
253 } else {
254 ERR("UST registry create event add unique failed for event: %s, "
255 "sig: %s, id: %u, chan_objd: %u, sess_objd: %u",
256 event->name, event->signature, event->id,
257 event->channel_objd, event->session_objd);
258 ret = -EINVAL;
259 goto error_unlock;
260 }
261 } else {
262 /* Request next event id if the node was successfully added. */
263 event_id = event->id = ust_registry_get_next_event_id(chan);
264 }
265
266 *event_id_p = event_id;
267
268 if (!event->metadata_dumped) {
269 /* Append to metadata */
270 ret = ust_metadata_event_statedump(session, chan, event);
271 if (ret) {
272 ERR("Error appending event metadata (errno = %d)", ret);
273 rcu_read_unlock();
274 return ret;
275 }
276 }
277
278 rcu_read_unlock();
279 return 0;
280
281 error_unlock:
282 rcu_read_unlock();
283 error:
284 destroy_event(event);
285 return ret;
286 }
287
288 /*
289 * For a given event in a registry, delete the entry and destroy the event.
290 * This MUST be called within a RCU read side lock section.
291 */
292 void ust_registry_destroy_event(struct ust_registry_channel *chan,
293 struct ust_registry_event *event)
294 {
295 int ret;
296 struct lttng_ht_iter iter;
297
298 assert(chan);
299 assert(event);
300
301 /* Delete the node first. */
302 iter.iter.node = &event->node.node;
303 ret = lttng_ht_del(chan->ht, &iter);
304 assert(!ret);
305
306 call_rcu(&event->node.head, destroy_event_rcu);
307
308 return;
309 }
310
311 /*
312 * Destroy every element of the registry and free the memory. This does NOT
313 * free the registry pointer since it might not have been allocated before so
314 * it's the caller responsability.
315 *
316 * This MUST be called within a RCU read side lock section.
317 */
318 static void destroy_channel(struct ust_registry_channel *chan)
319 {
320 struct lttng_ht_iter iter;
321 struct ust_registry_event *event;
322
323 assert(chan);
324
325 /* Destroy all event associated with this registry. */
326 cds_lfht_for_each_entry(chan->ht->ht, &iter.iter, event, node.node) {
327 /* Delete the node from the ht and free it. */
328 ust_registry_destroy_event(chan, event);
329 }
330 lttng_ht_destroy(chan->ht);
331
332 free(chan);
333 }
334
335 /*
336 * Initialize registry with default values.
337 */
338 int ust_registry_channel_add(struct ust_registry_session *session,
339 uint64_t key)
340 {
341 int ret = 0;
342 struct ust_registry_channel *chan;
343
344 assert(session);
345
346 chan = zmalloc(sizeof(*chan));
347 if (!chan) {
348 PERROR("zmalloc ust registry channel");
349 ret = -ENOMEM;
350 goto error;
351 }
352
353 chan->ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
354 if (!chan->ht) {
355 ret = -ENOMEM;
356 goto error;
357 }
358
359 /* Set custom match function. */
360 chan->ht->match_fct = ht_match_event;
361 chan->ht->hash_fct = ht_hash_event;
362
363 /*
364 * Assign a channel ID right now since the event notification comes
365 * *before* the channel notify so the ID needs to be set at this point so
366 * the metadata can be dumped for that event.
367 */
368 if (ust_registry_is_max_id(session->used_channel_id)) {
369 ret = -1;
370 goto error;
371 }
372 chan->chan_id = ust_registry_get_next_chan_id(session);
373
374 rcu_read_lock();
375 lttng_ht_node_init_u64(&chan->node, key);
376 lttng_ht_add_unique_u64(session->channels, &chan->node);
377 rcu_read_unlock();
378
379 error:
380 return ret;
381 }
382
383 /*
384 * Find a channel in the given registry. RCU read side lock MUST be acquired
385 * before calling this function and as long as the event reference is kept by
386 * the caller.
387 *
388 * On success, the pointer is returned else NULL.
389 */
390 struct ust_registry_channel *ust_registry_channel_find(
391 struct ust_registry_session *session, uint64_t key)
392 {
393 struct lttng_ht_node_u64 *node;
394 struct lttng_ht_iter iter;
395 struct ust_registry_channel *chan = NULL;
396
397 assert(session);
398 assert(session->channels);
399
400 DBG3("UST registry channel finding key %" PRIu64, key);
401
402 lttng_ht_lookup(session->channels, &key, &iter);
403 node = lttng_ht_iter_get_node_u64(&iter);
404 if (!node) {
405 goto end;
406 }
407 chan = caa_container_of(node, struct ust_registry_channel, node);
408
409 end:
410 return chan;
411 }
412
413 /*
414 * Remove channel using key from registry and free memory.
415 */
416 void ust_registry_channel_del_free(struct ust_registry_session *session,
417 uint64_t key)
418 {
419 struct lttng_ht_iter iter;
420 struct ust_registry_channel *chan;
421
422 assert(session);
423
424 rcu_read_lock();
425 chan = ust_registry_channel_find(session, key);
426 if (!chan) {
427 goto end;
428 }
429
430 iter.iter.node = &chan->node.node;
431 lttng_ht_del(session->channels, &iter);
432
433 destroy_channel(chan);
434
435 end:
436 rcu_read_unlock();
437 return;
438 }
439
440 /*
441 * Initialize registry with default values and set the newly allocated session
442 * pointer to sessionp.
443 *
444 * Return 0 on success and sessionp is set or else return -1 and sessionp is
445 * kept untouched.
446 */
447 int ust_registry_session_init(struct ust_registry_session **sessionp,
448 struct ust_app *app,
449 uint32_t bits_per_long,
450 uint32_t uint8_t_alignment,
451 uint32_t uint16_t_alignment,
452 uint32_t uint32_t_alignment,
453 uint32_t uint64_t_alignment,
454 uint32_t long_alignment,
455 int byte_order)
456 {
457 int ret;
458 struct ust_registry_session *session;
459
460 assert(sessionp);
461 assert(app);
462
463 session = zmalloc(sizeof(*session));
464 if (!session) {
465 PERROR("zmalloc ust registry session");
466 goto error;
467 }
468
469 pthread_mutex_init(&session->lock, NULL);
470 session->bits_per_long = bits_per_long;
471 session->uint8_t_alignment = uint8_t_alignment;
472 session->uint16_t_alignment = uint16_t_alignment;
473 session->uint32_t_alignment = uint32_t_alignment;
474 session->uint64_t_alignment = uint64_t_alignment;
475 session->long_alignment = long_alignment;
476 session->byte_order = byte_order;
477
478 session->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
479 if (!session->channels) {
480 goto error;
481 }
482
483 ret = lttng_uuid_generate(session->uuid);
484 if (ret) {
485 ERR("Failed to generate UST uuid (errno = %d)", ret);
486 goto error;
487 }
488
489 pthread_mutex_lock(&session->lock);
490 ret = ust_metadata_session_statedump(session, app);
491 pthread_mutex_unlock(&session->lock);
492 if (ret) {
493 ERR("Failed to generate session metadata (errno = %d)", ret);
494 goto error;
495 }
496
497 *sessionp = session;
498
499 return 0;
500
501 error:
502 return -1;
503 }
504
505 /*
506 * Destroy session registry. This does NOT free the given pointer since it
507 * might get passed as a reference. The registry lock should NOT be acquired.
508 */
509 void ust_registry_session_destroy(struct ust_registry_session *reg)
510 {
511 int ret;
512 struct lttng_ht_iter iter;
513 struct ust_registry_channel *chan;
514
515 /* On error, EBUSY can be returned if lock. Code flow error. */
516 ret = pthread_mutex_destroy(&reg->lock);
517 assert(!ret);
518
519 rcu_read_lock();
520 /* Destroy all event associated with this registry. */
521 cds_lfht_for_each_entry(reg->channels->ht, &iter.iter, chan, node.node) {
522 /* Delete the node from the ht and free it. */
523 ret = lttng_ht_del(reg->channels, &iter);
524 assert(!ret);
525 destroy_channel(chan);
526 }
527 lttng_ht_destroy(reg->channels);
528 rcu_read_unlock();
529
530 free(reg->metadata);
531 }
This page took 0.049155 seconds and 4 git commands to generate.