Clean-up: sessiond: prepend `the_` to global variable names
[lttng-tools.git] / src / bin / lttng-sessiond / agent.c
1 /*
2 * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 *
7 */
8
9 #define _LGPL_SOURCE
10 #include <assert.h>
11 #include <urcu/uatomic.h>
12 #include <urcu/rculist.h>
13
14 #include <lttng/event-rule/event-rule.h>
15 #include <lttng/event-rule/event-rule-internal.h>
16 #include <lttng/event-rule/tracepoint.h>
17 #include <lttng/condition/condition.h>
18 #include <lttng/condition/on-event.h>
19 #include <lttng/domain-internal.h>
20 #include <lttng/log-level-rule-internal.h>
21
22 #include <common/common.h>
23 #include <common/sessiond-comm/agent.h>
24
25 #include <common/compat/endian.h>
26
27 #include "agent.h"
28 #include "ust-app.h"
29 #include "utils.h"
30 #include "common/error.h"
31
32 #define AGENT_RET_CODE_INDEX(code) (code - AGENT_RET_CODE_SUCCESS)
33
34 /*
35 * Agent application context representation.
36 */
37 struct agent_app_ctx {
38 char *provider_name;
39 char *ctx_name;
40
41 /* agent_app_ctx are part of the agent app_ctx_list. */
42 struct cds_list_head list_node;
43
44 /* For call_rcu teardown. */
45 struct rcu_head rcu_node;
46 };
47
48 /*
49 * Human readable agent return code.
50 */
51 static const char *error_string_array[] = {
52 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_SUCCESS) ] = "Success",
53 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_INVALID) ] = "Invalid command",
54 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_UNKNOWN_NAME) ] = "Unknown logger name",
55
56 /* Last element */
57 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_NR) ] = "Unknown code",
58 };
59
60 static
61 void log_reply_code(uint32_t in_reply_ret_code)
62 {
63 int level = PRINT_DBG3;
64 /*
65 * reply_ret_code and in_reply_ret_code are kept separate to have a
66 * sanitized value (used to retrieve the human readable string) and the
67 * original value which is logged as-is.
68 */
69 uint32_t reply_ret_code = in_reply_ret_code;
70
71 if (reply_ret_code < AGENT_RET_CODE_SUCCESS ||
72 reply_ret_code >= AGENT_RET_CODE_NR) {
73 reply_ret_code = AGENT_RET_CODE_NR;
74 level = PRINT_ERR;
75 }
76
77 LOG(level, "Agent replied with retcode: %s (%"PRIu32")",
78 error_string_array[AGENT_RET_CODE_INDEX(
79 reply_ret_code)],
80 in_reply_ret_code);
81 }
82
83 /*
84 * Match function for the events hash table lookup by name.
85 */
86 static int ht_match_event_by_name(struct cds_lfht_node *node,
87 const void *_key)
88 {
89 struct agent_event *event;
90 const struct agent_ht_key *key;
91
92 assert(node);
93 assert(_key);
94
95 event = caa_container_of(node, struct agent_event, node.node);
96 key = _key;
97
98 /* Match 1 elements of the key: name. */
99
100 /* Event name */
101 if (strncmp(event->name, key->name, sizeof(event->name)) != 0) {
102 goto no_match;
103 }
104 /* Match. */
105 return 1;
106
107 no_match:
108 return 0;
109 }
110
111 /*
112 * Match function for the events hash table lookup by name, log level and
113 * filter expression.
114 */
115 static int ht_match_event(struct cds_lfht_node *node,
116 const void *_key)
117 {
118 struct agent_event *event;
119 const struct agent_ht_key *key;
120 int ll_match;
121
122 assert(node);
123 assert(_key);
124
125 event = caa_container_of(node, struct agent_event, node.node);
126 key = _key;
127
128 /* Match 2 elements of the key: name and loglevel. */
129
130 /* Event name */
131 if (strncmp(event->name, key->name, sizeof(event->name)) != 0) {
132 goto no_match;
133 }
134
135 /* Event loglevel value and type. */
136 ll_match = loglevels_match(event->loglevel_type,
137 event->loglevel_value, key->loglevel_type,
138 key->loglevel_value, LTTNG_EVENT_LOGLEVEL_ALL);
139
140 if (!ll_match) {
141 goto no_match;
142 }
143
144 /* Filter expression */
145 if (!!event->filter_expression != !!key->filter_expression) {
146 /* One has a filter expression, the other does not */
147 goto no_match;
148 }
149
150 if (event->filter_expression) {
151 if (strncmp(event->filter_expression, key->filter_expression,
152 strlen(event->filter_expression)) != 0) {
153 goto no_match;
154 }
155 }
156
157 return 1;
158
159 no_match:
160 return 0;
161 }
162
163 /*
164 * Add unique agent event based on the event name and loglevel.
165 */
166 static void add_unique_agent_event(struct lttng_ht *ht,
167 struct agent_event *event)
168 {
169 struct cds_lfht_node *node_ptr;
170 struct agent_ht_key key;
171
172 assert(ht);
173 assert(ht->ht);
174 assert(event);
175
176 key.name = event->name;
177 key.loglevel_value = event->loglevel_value;
178 key.loglevel_type = event->loglevel_type;
179 key.filter_expression = event->filter_expression;
180
181 node_ptr = cds_lfht_add_unique(ht->ht,
182 ht->hash_fct(event->node.key, lttng_ht_seed),
183 ht_match_event, &key, &event->node.node);
184 assert(node_ptr == &event->node.node);
185 }
186
187 /*
188 * URCU delayed agent event reclaim.
189 */
190 static void destroy_event_agent_rcu(struct rcu_head *head)
191 {
192 struct lttng_ht_node_str *node =
193 caa_container_of(head, struct lttng_ht_node_str, head);
194 struct agent_event *event =
195 caa_container_of(node, struct agent_event, node);
196
197 agent_destroy_event(event);
198 }
199
200 /*
201 * URCU delayed agent app reclaim.
202 */
203 static void destroy_app_agent_rcu(struct rcu_head *head)
204 {
205 struct lttng_ht_node_ulong *node =
206 caa_container_of(head, struct lttng_ht_node_ulong, head);
207 struct agent_app *app =
208 caa_container_of(node, struct agent_app, node);
209
210 free(app);
211 }
212
213 /*
214 * Communication with the agent. Send the message header to the given socket in
215 * big endian.
216 *
217 * Return 0 on success or else a negative errno message of sendmsg() op.
218 */
219 static int send_header(struct lttcomm_sock *sock, uint64_t data_size,
220 uint32_t cmd, uint32_t cmd_version)
221 {
222 int ret;
223 ssize_t size;
224 struct lttcomm_agent_hdr msg;
225
226 assert(sock);
227
228 memset(&msg, 0, sizeof(msg));
229 msg.data_size = htobe64(data_size);
230 msg.cmd = htobe32(cmd);
231 msg.cmd_version = htobe32(cmd_version);
232
233 size = sock->ops->sendmsg(sock, &msg, sizeof(msg), 0);
234 if (size < sizeof(msg)) {
235 ret = -errno;
236 goto error;
237 }
238 ret = 0;
239
240 error:
241 return ret;
242 }
243
244 /*
245 * Communication call with the agent. Send the payload to the given socket. The
246 * header MUST be sent prior to this call.
247 *
248 * Return 0 on success or else a negative errno value of sendmsg() op.
249 */
250 static int send_payload(struct lttcomm_sock *sock, const void *data,
251 size_t size)
252 {
253 int ret;
254 ssize_t len;
255
256 assert(sock);
257 assert(data);
258
259 len = sock->ops->sendmsg(sock, data, size, 0);
260 if (len < size) {
261 ret = -errno;
262 goto error;
263 }
264 ret = 0;
265
266 error:
267 return ret;
268 }
269
270 /*
271 * Communication call with the agent. Receive reply from the agent using the
272 * given socket.
273 *
274 * Return 0 on success or else a negative errno value from recvmsg() op.
275 */
276 static int recv_reply(struct lttcomm_sock *sock, void *buf, size_t size)
277 {
278 int ret;
279 ssize_t len;
280
281 assert(sock);
282 assert(buf);
283
284 len = sock->ops->recvmsg(sock, buf, size, 0);
285 if (len < size) {
286 ret = -errno;
287 goto error;
288 }
289 ret = 0;
290
291 error:
292 return ret;
293 }
294
295 /*
296 * Internal event listing for a given app. Populate events.
297 *
298 * Return number of element in the list or else a negative LTTNG_ERR* code.
299 * On success, the caller is responsible for freeing the memory
300 * allocated for "events".
301 */
302 static ssize_t list_events(struct agent_app *app, struct lttng_event **events)
303 {
304 int ret, i, len = 0, offset = 0;
305 uint32_t nb_event;
306 size_t data_size;
307 uint32_t reply_ret_code;
308 struct lttng_event *tmp_events = NULL;
309 struct lttcomm_agent_list_reply *reply = NULL;
310 struct lttcomm_agent_list_reply_hdr reply_hdr;
311
312 assert(app);
313 assert(app->sock);
314 assert(events);
315
316 DBG2("Agent listing events for app pid: %d and socket %d", app->pid,
317 app->sock->fd);
318
319 ret = send_header(app->sock, 0, AGENT_CMD_LIST, 0);
320 if (ret < 0) {
321 goto error_io;
322 }
323
324 /* Get list header so we know how much we'll receive. */
325 ret = recv_reply(app->sock, &reply_hdr, sizeof(reply_hdr));
326 if (ret < 0) {
327 goto error_io;
328 }
329
330 reply_ret_code = be32toh(reply_hdr.ret_code);
331 log_reply_code(reply_ret_code);
332 switch (reply_ret_code) {
333 case AGENT_RET_CODE_SUCCESS:
334 data_size = be32toh(reply_hdr.data_size) + sizeof(*reply);
335 break;
336 default:
337 ret = LTTNG_ERR_UNK;
338 goto error;
339 }
340
341 reply = zmalloc(data_size);
342 if (!reply) {
343 ret = LTTNG_ERR_NOMEM;
344 goto error;
345 }
346
347 /* Get the list with the appropriate data size. */
348 ret = recv_reply(app->sock, reply, data_size);
349 if (ret < 0) {
350 goto error_io;
351 }
352
353 nb_event = be32toh(reply->nb_event);
354 tmp_events = zmalloc(sizeof(*tmp_events) * nb_event);
355 if (!tmp_events) {
356 ret = LTTNG_ERR_NOMEM;
357 goto error;
358 }
359
360 for (i = 0; i < nb_event; i++) {
361 offset += len;
362 if (lttng_strncpy(tmp_events[i].name, reply->payload + offset,
363 sizeof(tmp_events[i].name))) {
364 ret = LTTNG_ERR_INVALID;
365 goto error;
366 }
367 tmp_events[i].pid = app->pid;
368 tmp_events[i].enabled = -1;
369 len = strlen(reply->payload + offset) + 1;
370 }
371
372 *events = tmp_events;
373
374 free(reply);
375 return nb_event;
376
377 error_io:
378 ret = LTTNG_ERR_UST_LIST_FAIL;
379 error:
380 free(reply);
381 free(tmp_events);
382 return -ret;
383
384 }
385
386 /*
387 * Internal enable agent event on a agent application. This function
388 * communicates with the agent to enable a given event.
389 *
390 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
391 */
392 static int enable_event(const struct agent_app *app, struct agent_event *event)
393 {
394 int ret;
395 char *bytes_to_send;
396 uint64_t data_size;
397 size_t filter_expression_length;
398 uint32_t reply_ret_code;
399 struct lttcomm_agent_enable_event msg;
400 struct lttcomm_agent_generic_reply reply;
401
402 assert(app);
403 assert(app->sock);
404 assert(event);
405
406 DBG2("Agent enabling event %s for app pid: %d and socket %d", event->name,
407 app->pid, app->sock->fd);
408
409 /*
410 * Calculate the payload's size, which is the fixed-size struct followed
411 * by the variable-length filter expression (+1 for the ending \0).
412 */
413 if (!event->filter_expression) {
414 filter_expression_length = 0;
415 } else {
416 filter_expression_length = strlen(event->filter_expression) + 1;
417 }
418 data_size = sizeof(msg) + filter_expression_length;
419
420 memset(&msg, 0, sizeof(msg));
421 msg.loglevel_value = htobe32(event->loglevel_value);
422 msg.loglevel_type = htobe32(event->loglevel_type);
423 if (lttng_strncpy(msg.name, event->name, sizeof(msg.name))) {
424 ret = LTTNG_ERR_INVALID;
425 goto error;
426 }
427 msg.filter_expression_length = htobe32(filter_expression_length);
428
429 ret = send_header(app->sock, data_size, AGENT_CMD_ENABLE, 0);
430 if (ret < 0) {
431 goto error_io;
432 }
433
434 bytes_to_send = zmalloc(data_size);
435 if (!bytes_to_send) {
436 ret = LTTNG_ERR_NOMEM;
437 goto error;
438 }
439
440 memcpy(bytes_to_send, &msg, sizeof(msg));
441 if (filter_expression_length > 0) {
442 memcpy(bytes_to_send + sizeof(msg), event->filter_expression,
443 filter_expression_length);
444 }
445
446 ret = send_payload(app->sock, bytes_to_send, data_size);
447 free(bytes_to_send);
448 if (ret < 0) {
449 goto error_io;
450 }
451
452 ret = recv_reply(app->sock, &reply, sizeof(reply));
453 if (ret < 0) {
454 goto error_io;
455 }
456
457 reply_ret_code = be32toh(reply.ret_code);
458 log_reply_code(reply_ret_code);
459 switch (reply_ret_code) {
460 case AGENT_RET_CODE_SUCCESS:
461 break;
462 case AGENT_RET_CODE_UNKNOWN_NAME:
463 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
464 goto error;
465 default:
466 ret = LTTNG_ERR_UNK;
467 goto error;
468 }
469
470 return LTTNG_OK;
471
472 error_io:
473 ret = LTTNG_ERR_UST_ENABLE_FAIL;
474 error:
475 return ret;
476 }
477
478 /*
479 * Send Pascal-style string. Size is sent as a 32-bit big endian integer.
480 */
481 static
482 int send_pstring(struct lttcomm_sock *sock, const char *str, uint32_t len)
483 {
484 int ret;
485 uint32_t len_be;
486
487 len_be = htobe32(len);
488 ret = send_payload(sock, &len_be, sizeof(len_be));
489 if (ret) {
490 goto end;
491 }
492
493 ret = send_payload(sock, str, len);
494 if (ret) {
495 goto end;
496 }
497 end:
498 return ret;
499 }
500
501 /*
502 * Internal enable application context on an agent application. This function
503 * communicates with the agent to enable a given application context.
504 *
505 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
506 */
507 static int app_context_op(const struct agent_app *app,
508 const struct agent_app_ctx *ctx, enum lttcomm_agent_command cmd)
509 {
510 int ret;
511 uint32_t reply_ret_code;
512 struct lttcomm_agent_generic_reply reply;
513 size_t app_ctx_provider_name_len, app_ctx_name_len, data_size;
514
515 assert(app);
516 assert(app->sock);
517 assert(ctx);
518 assert(cmd == AGENT_CMD_APP_CTX_ENABLE ||
519 cmd == AGENT_CMD_APP_CTX_DISABLE);
520
521 DBG2("Agent %s application %s:%s for app pid: %d and socket %d",
522 cmd == AGENT_CMD_APP_CTX_ENABLE ? "enabling" : "disabling",
523 ctx->provider_name, ctx->ctx_name,
524 app->pid, app->sock->fd);
525
526 /*
527 * Calculate the payload's size, which consists of the size (u32, BE)
528 * of the provider name, the NULL-terminated provider name string, the
529 * size (u32, BE) of the context name, followed by the NULL-terminated
530 * context name string.
531 */
532 app_ctx_provider_name_len = strlen(ctx->provider_name) + 1;
533 app_ctx_name_len = strlen(ctx->ctx_name) + 1;
534 data_size = sizeof(uint32_t) + app_ctx_provider_name_len +
535 sizeof(uint32_t) + app_ctx_name_len;
536
537 ret = send_header(app->sock, data_size, cmd, 0);
538 if (ret < 0) {
539 goto error_io;
540 }
541
542 if (app_ctx_provider_name_len > UINT32_MAX ||
543 app_ctx_name_len > UINT32_MAX) {
544 ERR("Application context name > MAX_UINT32");
545 ret = LTTNG_ERR_INVALID;
546 goto error;
547 }
548
549 ret = send_pstring(app->sock, ctx->provider_name,
550 (uint32_t) app_ctx_provider_name_len);
551 if (ret < 0) {
552 goto error_io;
553 }
554
555 ret = send_pstring(app->sock, ctx->ctx_name,
556 (uint32_t) app_ctx_name_len);
557 if (ret < 0) {
558 goto error_io;
559 }
560
561 ret = recv_reply(app->sock, &reply, sizeof(reply));
562 if (ret < 0) {
563 goto error_io;
564 }
565
566 reply_ret_code = be32toh(reply.ret_code);
567 log_reply_code(reply_ret_code);
568 switch (reply_ret_code) {
569 case AGENT_RET_CODE_SUCCESS:
570 break;
571 default:
572 ret = LTTNG_ERR_UNK;
573 goto error;
574 }
575
576 return LTTNG_OK;
577
578 error_io:
579 ret = LTTNG_ERR_UST_ENABLE_FAIL;
580 error:
581 return ret;
582 }
583
584 /*
585 * Internal disable agent event call on a agent application. This function
586 * communicates with the agent to disable a given event.
587 *
588 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
589 */
590 static int disable_event(struct agent_app *app, struct agent_event *event)
591 {
592 int ret;
593 uint64_t data_size;
594 uint32_t reply_ret_code;
595 struct lttcomm_agent_disable_event msg;
596 struct lttcomm_agent_generic_reply reply;
597
598 assert(app);
599 assert(app->sock);
600 assert(event);
601
602 DBG2("Agent disabling event %s for app pid: %d and socket %d", event->name,
603 app->pid, app->sock->fd);
604
605 data_size = sizeof(msg);
606 memset(&msg, 0, sizeof(msg));
607 if (lttng_strncpy(msg.name, event->name, sizeof(msg.name))) {
608 ret = LTTNG_ERR_INVALID;
609 goto error;
610 }
611
612 ret = send_header(app->sock, data_size, AGENT_CMD_DISABLE, 0);
613 if (ret < 0) {
614 goto error_io;
615 }
616
617 ret = send_payload(app->sock, &msg, sizeof(msg));
618 if (ret < 0) {
619 goto error_io;
620 }
621
622 ret = recv_reply(app->sock, &reply, sizeof(reply));
623 if (ret < 0) {
624 goto error_io;
625 }
626
627 reply_ret_code = be32toh(reply.ret_code);
628 log_reply_code(reply_ret_code);
629 switch (reply_ret_code) {
630 case AGENT_RET_CODE_SUCCESS:
631 break;
632 case AGENT_RET_CODE_UNKNOWN_NAME:
633 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
634 goto error;
635 default:
636 ret = LTTNG_ERR_UNK;
637 goto error;
638 }
639
640 return LTTNG_OK;
641
642 error_io:
643 ret = LTTNG_ERR_UST_DISABLE_FAIL;
644 error:
645 return ret;
646 }
647
648 /*
649 * Send back the registration DONE command to a given agent application.
650 *
651 * Return 0 on success or else a negative value.
652 */
653 int agent_send_registration_done(struct agent_app *app)
654 {
655 assert(app);
656 assert(app->sock);
657
658 DBG("Agent sending registration done to app socket %d", app->sock->fd);
659
660 return send_header(app->sock, 0, AGENT_CMD_REG_DONE, 0);
661 }
662
663 /*
664 * Enable agent event on every agent applications registered with the session
665 * daemon.
666 *
667 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
668 */
669 int agent_enable_event(struct agent_event *event,
670 enum lttng_domain_type domain)
671 {
672 int ret;
673 struct agent_app *app;
674 struct lttng_ht_iter iter;
675
676 assert(event);
677
678 rcu_read_lock();
679
680 cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
681 node.node) {
682 if (app->domain != domain) {
683 continue;
684 }
685
686 /* Enable event on agent application through TCP socket. */
687 ret = enable_event(app, event);
688 if (ret != LTTNG_OK) {
689 goto error;
690 }
691 }
692
693 event->enabled_count++;
694 ret = LTTNG_OK;
695
696 error:
697 rcu_read_unlock();
698 return ret;
699 }
700
701 static
702 void destroy_app_ctx(struct agent_app_ctx *ctx)
703 {
704 free(ctx->provider_name);
705 free(ctx->ctx_name);
706 free(ctx);
707 }
708
709 static
710 struct agent_app_ctx *create_app_ctx(const struct lttng_event_context *ctx)
711 {
712 struct agent_app_ctx *agent_ctx = NULL;
713
714 if (!ctx) {
715 goto end;
716 }
717
718 assert(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
719 agent_ctx = zmalloc(sizeof(*ctx));
720 if (!agent_ctx) {
721 goto end;
722 }
723
724 agent_ctx->provider_name = strdup(ctx->u.app_ctx.provider_name);
725 agent_ctx->ctx_name = strdup(ctx->u.app_ctx.ctx_name);
726 if (!agent_ctx->provider_name || !agent_ctx->ctx_name) {
727 destroy_app_ctx(agent_ctx);
728 agent_ctx = NULL;
729 }
730 end:
731 return agent_ctx;
732 }
733
734 /*
735 * Enable agent context on every agent applications registered with the session
736 * daemon.
737 *
738 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
739 */
740 int agent_enable_context(const struct lttng_event_context *ctx,
741 enum lttng_domain_type domain)
742 {
743 int ret;
744 struct agent_app *app;
745 struct lttng_ht_iter iter;
746
747 assert(ctx);
748 if (ctx->ctx != LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
749 ret = LTTNG_ERR_INVALID;
750 goto error;
751 }
752
753 rcu_read_lock();
754
755 cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
756 node.node) {
757 struct agent_app_ctx *agent_ctx;
758
759 if (app->domain != domain) {
760 continue;
761 }
762
763 agent_ctx = create_app_ctx(ctx);
764 if (!agent_ctx) {
765 ret = LTTNG_ERR_NOMEM;
766 goto error_unlock;
767 }
768
769 /* Enable event on agent application through TCP socket. */
770 ret = app_context_op(app, agent_ctx, AGENT_CMD_APP_CTX_ENABLE);
771 destroy_app_ctx(agent_ctx);
772 if (ret != LTTNG_OK) {
773 goto error_unlock;
774 }
775 }
776
777 ret = LTTNG_OK;
778
779 error_unlock:
780 rcu_read_unlock();
781 error:
782 return ret;
783 }
784
785 /*
786 * Disable agent event on every agent application registered with the session
787 * daemon.
788 *
789 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
790 */
791 int agent_disable_event(struct agent_event *event,
792 enum lttng_domain_type domain)
793 {
794 int ret = LTTNG_OK;
795 struct agent_app *app;
796 struct lttng_ht_iter iter;
797
798 assert(event);
799 if (!AGENT_EVENT_IS_ENABLED(event)) {
800 goto end;
801 }
802
803 if (--event->enabled_count != 0) {
804 /*
805 * Agent event still enabled. Disable the agent event only when
806 * all "users" have disabled it (event notifiers, event rules,
807 * etc.).
808 */
809 ret = LTTNG_OK;
810 goto end;
811 }
812
813 rcu_read_lock();
814
815 cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
816 node.node) {
817 if (app->domain != domain) {
818 continue;
819 }
820
821 /* Enable event on agent application through TCP socket. */
822 ret = disable_event(app, event);
823 if (ret != LTTNG_OK) {
824 goto error;
825 }
826 }
827
828 /* event->enabled_count is now 0. */
829 assert(!AGENT_EVENT_IS_ENABLED(event));
830
831 error:
832 rcu_read_unlock();
833 end:
834 return ret;
835 }
836
837 /*
838 * Disable agent context on every agent application registered with the session
839 * daemon.
840 *
841 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
842 */
843 static int disable_context(struct agent_app_ctx *ctx,
844 enum lttng_domain_type domain)
845 {
846 int ret = LTTNG_OK;
847 struct agent_app *app;
848 struct lttng_ht_iter iter;
849
850 assert(ctx);
851
852 rcu_read_lock();
853 DBG2("Disabling agent application context %s:%s",
854 ctx->provider_name, ctx->ctx_name);
855 cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
856 node.node) {
857 if (app->domain != domain) {
858 continue;
859 }
860
861 ret = app_context_op(app, ctx, AGENT_CMD_APP_CTX_DISABLE);
862 if (ret != LTTNG_OK) {
863 goto end;
864 }
865 }
866 end:
867 rcu_read_unlock();
868 return ret;
869 }
870
871 /*
872 * Ask every agent for the list of possible event. Events is allocated with the
873 * events of every agent application.
874 *
875 * Return the number of events or else a negative value.
876 */
877 int agent_list_events(struct lttng_event **events,
878 enum lttng_domain_type domain)
879 {
880 int ret;
881 size_t nbmem, count = 0;
882 struct agent_app *app;
883 struct lttng_event *tmp_events = NULL;
884 struct lttng_ht_iter iter;
885
886 assert(events);
887
888 DBG2("Agent listing events for domain %d", domain);
889
890 nbmem = UST_APP_EVENT_LIST_SIZE;
891 tmp_events = zmalloc(nbmem * sizeof(*tmp_events));
892 if (!tmp_events) {
893 PERROR("zmalloc agent list events");
894 ret = -ENOMEM;
895 goto error;
896 }
897
898 rcu_read_lock();
899 cds_lfht_for_each_entry(the_agent_apps_ht_by_sock->ht, &iter.iter, app,
900 node.node) {
901 ssize_t nb_ev;
902 struct lttng_event *agent_events;
903
904 /* Skip domain not asked by the list. */
905 if (app->domain != domain) {
906 continue;
907 }
908
909 nb_ev = list_events(app, &agent_events);
910 if (nb_ev < 0) {
911 ret = nb_ev;
912 goto error_unlock;
913 }
914
915 if (count + nb_ev > nbmem) {
916 /* In case the realloc fails, we free the memory */
917 struct lttng_event *new_tmp_events;
918 size_t new_nbmem;
919
920 new_nbmem = max_t(size_t, count + nb_ev, nbmem << 1);
921 DBG2("Reallocating agent event list from %zu to %zu entries",
922 nbmem, new_nbmem);
923 new_tmp_events = realloc(tmp_events,
924 new_nbmem * sizeof(*new_tmp_events));
925 if (!new_tmp_events) {
926 PERROR("realloc agent events");
927 ret = -ENOMEM;
928 free(agent_events);
929 goto error_unlock;
930 }
931 /* Zero the new memory */
932 memset(new_tmp_events + nbmem, 0,
933 (new_nbmem - nbmem) * sizeof(*new_tmp_events));
934 nbmem = new_nbmem;
935 tmp_events = new_tmp_events;
936 }
937 memcpy(tmp_events + count, agent_events,
938 nb_ev * sizeof(*tmp_events));
939 free(agent_events);
940 count += nb_ev;
941 }
942 rcu_read_unlock();
943
944 ret = count;
945 *events = tmp_events;
946 return ret;
947
948 error_unlock:
949 rcu_read_unlock();
950 error:
951 free(tmp_events);
952 return ret;
953 }
954
955 /*
956 * Create a agent app object using the given PID.
957 *
958 * Return newly allocated object or else NULL on error.
959 */
960 struct agent_app *agent_create_app(pid_t pid, enum lttng_domain_type domain,
961 struct lttcomm_sock *sock)
962 {
963 struct agent_app *app;
964
965 assert(sock);
966
967 app = zmalloc(sizeof(*app));
968 if (!app) {
969 PERROR("Failed to allocate agent application instance");
970 goto error;
971 }
972
973 app->pid = pid;
974 app->domain = domain;
975 app->sock = sock;
976 lttng_ht_node_init_ulong(&app->node, (unsigned long) app->sock->fd);
977
978 error:
979 return app;
980 }
981
982 /*
983 * Lookup agent app by socket in the global hash table.
984 *
985 * RCU read side lock MUST be acquired.
986 *
987 * Return object if found else NULL.
988 */
989 struct agent_app *agent_find_app_by_sock(int sock)
990 {
991 struct lttng_ht_node_ulong *node;
992 struct lttng_ht_iter iter;
993 struct agent_app *app;
994
995 assert(sock >= 0);
996
997 lttng_ht_lookup(the_agent_apps_ht_by_sock,
998 (void *) ((unsigned long) sock), &iter);
999 node = lttng_ht_iter_get_node_ulong(&iter);
1000 if (node == NULL) {
1001 goto error;
1002 }
1003 app = caa_container_of(node, struct agent_app, node);
1004
1005 DBG3("Agent app pid %d found by sock %d.", app->pid, sock);
1006 return app;
1007
1008 error:
1009 DBG3("Agent app NOT found by sock %d.", sock);
1010 return NULL;
1011 }
1012
1013 /*
1014 * Add agent application object to the global hash table.
1015 */
1016 void agent_add_app(struct agent_app *app)
1017 {
1018 assert(app);
1019
1020 DBG3("Agent adding app sock: %d and pid: %d to ht", app->sock->fd, app->pid);
1021 lttng_ht_add_unique_ulong(the_agent_apps_ht_by_sock, &app->node);
1022 }
1023
1024 /*
1025 * Delete agent application from the global hash table.
1026 *
1027 * rcu_read_lock() must be held by the caller.
1028 */
1029 void agent_delete_app(struct agent_app *app)
1030 {
1031 int ret;
1032 struct lttng_ht_iter iter;
1033
1034 assert(app);
1035
1036 DBG3("Agent deleting app pid: %d and sock: %d", app->pid, app->sock->fd);
1037
1038 iter.iter.node = &app->node.node;
1039 ret = lttng_ht_del(the_agent_apps_ht_by_sock, &iter);
1040 assert(!ret);
1041 }
1042
1043 /*
1044 * Destroy an agent application object by detaching it from its corresponding
1045 * UST app if one is connected by closing the socket. Finally, perform a
1046 * delayed memory reclaim.
1047 */
1048 void agent_destroy_app(struct agent_app *app)
1049 {
1050 assert(app);
1051
1052 if (app->sock) {
1053 app->sock->ops->close(app->sock);
1054 lttcomm_destroy_sock(app->sock);
1055 }
1056
1057 call_rcu(&app->node.head, destroy_app_agent_rcu);
1058 }
1059
1060 /*
1061 * Initialize an already allocated agent object.
1062 *
1063 * Return 0 on success or else a negative errno value.
1064 */
1065 int agent_init(struct agent *agt)
1066 {
1067 int ret;
1068
1069 assert(agt);
1070
1071 agt->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
1072 if (!agt->events) {
1073 ret = -ENOMEM;
1074 goto error;
1075 }
1076 lttng_ht_node_init_u64(&agt->node, agt->domain);
1077
1078 CDS_INIT_LIST_HEAD(&agt->app_ctx_list);
1079 return 0;
1080
1081 error:
1082 return ret;
1083 }
1084
1085 /*
1086 * Add agent object to the given hash table.
1087 */
1088 void agent_add(struct agent *agt, struct lttng_ht *ht)
1089 {
1090 assert(agt);
1091 assert(ht);
1092
1093 DBG3("Agent adding from domain %d", agt->domain);
1094
1095 lttng_ht_add_unique_u64(ht, &agt->node);
1096 }
1097
1098 /*
1099 * Create an agent object for the given domain.
1100 *
1101 * Return the allocated agent or NULL on error.
1102 */
1103 struct agent *agent_create(enum lttng_domain_type domain)
1104 {
1105 int ret;
1106 struct agent *agt;
1107
1108 agt = zmalloc(sizeof(struct agent));
1109 if (!agt) {
1110 goto error;
1111 }
1112 agt->domain = domain;
1113
1114 ret = agent_init(agt);
1115 if (ret < 0) {
1116 free(agt);
1117 agt = NULL;
1118 goto error;
1119 }
1120
1121 error:
1122 return agt;
1123 }
1124
1125 /*
1126 * Create a newly allocated agent event data structure.
1127 * Ownership of filter_expression is taken.
1128 *
1129 * Return a new object else NULL on error.
1130 */
1131 struct agent_event *agent_create_event(const char *name,
1132 enum lttng_loglevel_type loglevel_type, int loglevel_value,
1133 struct lttng_bytecode *filter, char *filter_expression)
1134 {
1135 struct agent_event *event = NULL;
1136
1137 DBG3("Agent create new event with name %s, loglevel type %d, \
1138 loglevel value %d and filter %s",
1139 name, loglevel_type, loglevel_value,
1140 filter_expression ? filter_expression : "NULL");
1141
1142 if (!name) {
1143 ERR("Failed to create agent event; no name provided.");
1144 goto error;
1145 }
1146
1147 event = zmalloc(sizeof(*event));
1148 if (!event) {
1149 goto error;
1150 }
1151
1152 strncpy(event->name, name, sizeof(event->name));
1153 event->name[sizeof(event->name) - 1] = '\0';
1154 lttng_ht_node_init_str(&event->node, event->name);
1155
1156 event->loglevel_value = loglevel_value;
1157 event->loglevel_type = loglevel_type;
1158 event->filter = filter;
1159 event->filter_expression = filter_expression;
1160 error:
1161 return event;
1162 }
1163
1164 /*
1165 * Unique add of a agent event to an agent object.
1166 */
1167 void agent_add_event(struct agent_event *event, struct agent *agt)
1168 {
1169 assert(event);
1170 assert(agt);
1171 assert(agt->events);
1172
1173 DBG3("Agent adding event %s", event->name);
1174 add_unique_agent_event(agt->events, event);
1175 agt->being_used = 1;
1176 }
1177
1178 /*
1179 * Unique add of a agent context to an agent object.
1180 */
1181 int agent_add_context(const struct lttng_event_context *ctx, struct agent *agt)
1182 {
1183 int ret = LTTNG_OK;
1184 struct agent_app_ctx *agent_ctx = NULL;
1185
1186 assert(ctx);
1187 assert(agt);
1188 assert(agt->events);
1189 assert(ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT);
1190
1191 agent_ctx = create_app_ctx(ctx);
1192 if (!agent_ctx) {
1193 ret = LTTNG_ERR_NOMEM;
1194 goto end;
1195 }
1196
1197 DBG3("Agent adding context %s:%s", ctx->u.app_ctx.provider_name,
1198 ctx->u.app_ctx.ctx_name);
1199 cds_list_add_tail_rcu(&agent_ctx->list_node, &agt->app_ctx_list);
1200 end:
1201 return ret;
1202 }
1203
1204 /*
1205 * Find multiple agent events sharing the given name.
1206 *
1207 * RCU read side lock MUST be acquired. It must be held for the
1208 * duration of the iteration.
1209 *
1210 * Sets the given iterator.
1211 */
1212 void agent_find_events_by_name(const char *name, struct agent *agt,
1213 struct lttng_ht_iter* iter)
1214 {
1215 struct lttng_ht *ht;
1216 struct agent_ht_key key;
1217
1218 assert(name);
1219 assert(agt);
1220 assert(agt->events);
1221 assert(iter);
1222
1223 ht = agt->events;
1224 key.name = name;
1225
1226 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
1227 ht_match_event_by_name, &key, &iter->iter);
1228 }
1229
1230 /*
1231 * Find the agent event matching a trigger.
1232 *
1233 * RCU read side lock MUST be acquired. It must be held for as long as
1234 * the returned agent_event is used.
1235 *
1236 * Return object if found else NULL.
1237 */
1238 struct agent_event *agent_find_event_by_trigger(
1239 const struct lttng_trigger *trigger, struct agent *agt)
1240 {
1241 enum lttng_condition_status c_status;
1242 enum lttng_event_rule_status er_status;
1243 enum lttng_domain_type domain;
1244 const struct lttng_condition *condition;
1245 const struct lttng_event_rule *rule;
1246 const char *name;
1247 const char *filter_expression;
1248 const struct lttng_log_level_rule *log_level_rule;
1249 /* Unused when loglevel_type is 'ALL'. */
1250 int loglevel_value = 0;
1251 enum lttng_loglevel_type loglevel_type;
1252
1253 assert(agt);
1254 assert(agt->events);
1255
1256 condition = lttng_trigger_get_const_condition(trigger);
1257
1258 assert(lttng_condition_get_type(condition) ==
1259 LTTNG_CONDITION_TYPE_ON_EVENT);
1260
1261 c_status = lttng_condition_on_event_get_rule(condition, &rule);
1262 assert(c_status == LTTNG_CONDITION_STATUS_OK);
1263
1264 assert(lttng_event_rule_get_type(rule) ==
1265 LTTNG_EVENT_RULE_TYPE_TRACEPOINT);
1266
1267 domain = lttng_event_rule_get_domain_type(rule);
1268 assert(domain == LTTNG_DOMAIN_JUL || domain == LTTNG_DOMAIN_LOG4J ||
1269 domain == LTTNG_DOMAIN_PYTHON);
1270
1271 /* Get the event's pattern ('name' in the legacy terminology). */
1272 er_status = lttng_event_rule_tracepoint_get_pattern(rule, &name);
1273 assert(er_status == LTTNG_EVENT_RULE_STATUS_OK);
1274
1275 /* Get the internal filter expression. */
1276 filter_expression = lttng_event_rule_get_filter(rule);
1277
1278 /* Map log_level_rule to loglevel value. */
1279 er_status = lttng_event_rule_tracepoint_get_log_level_rule(
1280 rule, &log_level_rule);
1281 if (er_status == LTTNG_EVENT_RULE_STATUS_UNSET) {
1282 loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
1283 loglevel_value = 0;
1284 } else if (er_status == LTTNG_EVENT_RULE_STATUS_OK) {
1285 lttng_log_level_rule_to_loglevel(log_level_rule, &loglevel_type, &loglevel_value);
1286 } else {
1287 abort();
1288 }
1289
1290 return agent_find_event(name, loglevel_type, loglevel_value,
1291 filter_expression, agt);
1292 }
1293
1294 /*
1295 * Get the next agent event duplicate by name. This should be called
1296 * after a call to agent_find_events_by_name() to iterate on events.
1297 *
1298 * The RCU read lock must be held during the iteration and for as long
1299 * as the object the iterator points to remains in use.
1300 */
1301 void agent_event_next_duplicate(const char *name,
1302 struct agent *agt, struct lttng_ht_iter* iter)
1303 {
1304 struct agent_ht_key key;
1305
1306 key.name = name;
1307
1308 cds_lfht_next_duplicate(agt->events->ht, ht_match_event_by_name,
1309 &key, &iter->iter);
1310 }
1311
1312 /*
1313 * Find a agent event in the given agent using name, loglevel and filter.
1314 *
1315 * RCU read side lock MUST be acquired. It must be kept for as long as
1316 * the returned agent_event is used.
1317 *
1318 * Return object if found else NULL.
1319 */
1320 struct agent_event *agent_find_event(const char *name,
1321 enum lttng_loglevel_type loglevel_type,
1322 int loglevel_value,
1323 const char *filter_expression,
1324 struct agent *agt)
1325 {
1326 struct lttng_ht_node_str *node;
1327 struct lttng_ht_iter iter;
1328 struct lttng_ht *ht;
1329 struct agent_ht_key key;
1330
1331 assert(name);
1332 assert(agt);
1333 assert(agt->events);
1334
1335 ht = agt->events;
1336 key.name = name;
1337 key.loglevel_value = loglevel_value;
1338 key.loglevel_type = loglevel_type;
1339 key.filter_expression = filter_expression;
1340
1341 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
1342 ht_match_event, &key, &iter.iter);
1343 node = lttng_ht_iter_get_node_str(&iter);
1344 if (node == NULL) {
1345 goto error;
1346 }
1347
1348 DBG3("Agent event found %s.", name);
1349 return caa_container_of(node, struct agent_event, node);
1350
1351 error:
1352 DBG3("Agent event NOT found %s.", name);
1353 return NULL;
1354 }
1355
1356 /*
1357 * Free given agent event. This event must not be globally visible at this
1358 * point (only expected to be used on failure just after event creation). After
1359 * this call, the pointer is not usable anymore.
1360 */
1361 void agent_destroy_event(struct agent_event *event)
1362 {
1363 assert(event);
1364
1365 free(event->filter);
1366 free(event->filter_expression);
1367 free(event->exclusion);
1368 free(event);
1369 }
1370
1371 static
1372 void destroy_app_ctx_rcu(struct rcu_head *head)
1373 {
1374 struct agent_app_ctx *ctx =
1375 caa_container_of(head, struct agent_app_ctx, rcu_node);
1376
1377 destroy_app_ctx(ctx);
1378 }
1379
1380 /*
1381 * Destroy an agent completely.
1382 */
1383 void agent_destroy(struct agent *agt)
1384 {
1385 struct lttng_ht_node_str *node;
1386 struct lttng_ht_iter iter;
1387 struct agent_app_ctx *ctx;
1388
1389 assert(agt);
1390
1391 DBG3("Agent destroy");
1392
1393 rcu_read_lock();
1394 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, node, node) {
1395 int ret;
1396 struct agent_event *event;
1397
1398 /*
1399 * When destroying an event, we have to try to disable it on the
1400 * agent side so the event stops generating data. The return
1401 * value is not important since we have to continue anyway
1402 * destroying the object.
1403 */
1404 event = caa_container_of(node, struct agent_event, node);
1405 (void) agent_disable_event(event, agt->domain);
1406
1407 ret = lttng_ht_del(agt->events, &iter);
1408 assert(!ret);
1409 call_rcu(&node->head, destroy_event_agent_rcu);
1410 }
1411
1412 cds_list_for_each_entry_rcu(ctx, &agt->app_ctx_list, list_node) {
1413 (void) disable_context(ctx, agt->domain);
1414 cds_list_del(&ctx->list_node);
1415 call_rcu(&ctx->rcu_node, destroy_app_ctx_rcu);
1416 }
1417 rcu_read_unlock();
1418 ht_cleanup_push(agt->events);
1419 free(agt);
1420 }
1421
1422 /*
1423 * Allocate agent_apps_ht_by_sock.
1424 */
1425 int agent_app_ht_alloc(void)
1426 {
1427 the_agent_apps_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
1428 return the_agent_apps_ht_by_sock ? 0 : -1;
1429 }
1430
1431 /*
1432 * Destroy a agent application by socket.
1433 */
1434 void agent_destroy_app_by_sock(int sock)
1435 {
1436 struct agent_app *app;
1437
1438 assert(sock >= 0);
1439
1440 /*
1441 * Not finding an application is a very important error that should NEVER
1442 * happen. The hash table deletion is ONLY done through this call when the
1443 * main sessiond thread is torn down.
1444 */
1445 rcu_read_lock();
1446 app = agent_find_app_by_sock(sock);
1447 assert(app);
1448
1449 /* RCU read side lock is assumed to be held by this function. */
1450 agent_delete_app(app);
1451
1452 /* The application is freed in a RCU call but the socket is closed here. */
1453 agent_destroy_app(app);
1454 rcu_read_unlock();
1455 }
1456
1457 /*
1458 * Clean-up the agent app hash table and destroy it.
1459 */
1460 void agent_app_ht_clean(void)
1461 {
1462 struct lttng_ht_node_ulong *node;
1463 struct lttng_ht_iter iter;
1464
1465 if (!the_agent_apps_ht_by_sock) {
1466 return;
1467 }
1468 rcu_read_lock();
1469 cds_lfht_for_each_entry(
1470 the_agent_apps_ht_by_sock->ht, &iter.iter, node, node) {
1471 struct agent_app *app;
1472
1473 app = caa_container_of(node, struct agent_app, node);
1474 agent_destroy_app_by_sock(app->sock->fd);
1475 }
1476 rcu_read_unlock();
1477
1478 lttng_ht_destroy(the_agent_apps_ht_by_sock);
1479 }
1480
1481 /*
1482 * Update a agent application (given socket) using the given agent.
1483 *
1484 * Note that this function is most likely to be used with a tracing session
1485 * thus the caller should make sure to hold the appropriate lock(s).
1486 */
1487 void agent_update(const struct agent *agt, const struct agent_app *app)
1488 {
1489 int ret;
1490 struct agent_event *event;
1491 struct lttng_ht_iter iter;
1492 struct agent_app_ctx *ctx;
1493
1494 assert(agt);
1495 assert(app);
1496
1497 DBG("Agent updating app: pid = %ld", (long) app->pid);
1498
1499 rcu_read_lock();
1500 /*
1501 * We are in the registration path thus if the application is gone,
1502 * there is a serious code flow error.
1503 */
1504
1505 cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) {
1506 /* Skip event if disabled. */
1507 if (!AGENT_EVENT_IS_ENABLED(event)) {
1508 continue;
1509 }
1510
1511 ret = enable_event(app, event);
1512 if (ret != LTTNG_OK) {
1513 DBG2("Agent update unable to enable event %s on app pid: %d sock %d",
1514 event->name, app->pid, app->sock->fd);
1515 /* Let's try the others here and don't assume the app is dead. */
1516 continue;
1517 }
1518 }
1519
1520 cds_list_for_each_entry_rcu(ctx, &agt->app_ctx_list, list_node) {
1521 ret = app_context_op(app, ctx, AGENT_CMD_APP_CTX_ENABLE);
1522 if (ret != LTTNG_OK) {
1523 DBG2("Agent update unable to add application context %s:%s on app pid: %d sock %d",
1524 ctx->provider_name, ctx->ctx_name,
1525 app->pid, app->sock->fd);
1526 continue;
1527 }
1528 }
1529
1530 rcu_read_unlock();
1531 }
1532
1533 /*
1534 * Allocate the per-event notifier domain agent hash table. It is lazily
1535 * populated as domains are used.
1536 */
1537 int agent_by_event_notifier_domain_ht_create(void)
1538 {
1539 the_trigger_agents_ht_by_domain = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
1540 return the_trigger_agents_ht_by_domain ? 0 : -1;
1541 }
1542
1543 /*
1544 * Clean-up the per-event notifier domain agent hash table and destroy it.
1545 */
1546 void agent_by_event_notifier_domain_ht_destroy(void)
1547 {
1548 struct lttng_ht_node_u64 *node;
1549 struct lttng_ht_iter iter;
1550
1551 if (!the_trigger_agents_ht_by_domain) {
1552 return;
1553 }
1554
1555 rcu_read_lock();
1556 cds_lfht_for_each_entry(the_trigger_agents_ht_by_domain->ht,
1557 &iter.iter, node, node) {
1558 struct agent *agent =
1559 caa_container_of(node, struct agent, node);
1560 const int ret = lttng_ht_del(
1561 the_trigger_agents_ht_by_domain, &iter);
1562
1563 assert(ret == 0);
1564 agent_destroy(agent);
1565 }
1566
1567 rcu_read_unlock();
1568 lttng_ht_destroy(the_trigger_agents_ht_by_domain);
1569 }
1570
1571 struct agent *agent_find_by_event_notifier_domain(
1572 enum lttng_domain_type domain_type)
1573 {
1574 struct agent *agt = NULL;
1575 struct lttng_ht_node_u64 *node;
1576 struct lttng_ht_iter iter;
1577 const uint64_t key = (uint64_t) domain_type;
1578
1579 assert(the_trigger_agents_ht_by_domain);
1580
1581 DBG3("Per-event notifier domain agent lookup for domain '%s'",
1582 lttng_domain_type_str(domain_type));
1583
1584 lttng_ht_lookup(the_trigger_agents_ht_by_domain, &key, &iter);
1585 node = lttng_ht_iter_get_node_u64(&iter);
1586 if (!node) {
1587 goto end;
1588 }
1589
1590 agt = caa_container_of(node, struct agent, node);
1591
1592 end:
1593 return agt;
1594 }
This page took 0.067606 seconds and 4 git commands to generate.