2 * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
3 * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * SPDX-License-Identifier: GPL-2.0-only
11 #include <urcu/uatomic.h>
12 #include <urcu/rculist.h>
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/event-rule.h>
20 #include <common/common.h>
21 #include <common/sessiond-comm/agent.h>
23 #include <common/compat/endian.h>
28 #include "common/error.h"
30 #define AGENT_RET_CODE_INDEX(code) (code - AGENT_RET_CODE_SUCCESS)
33 * Agent application context representation.
35 struct agent_app_ctx
{
39 /* agent_app_ctx are part of the agent app_ctx_list. */
40 struct cds_list_head list_node
;
42 /* For call_rcu teardown. */
43 struct rcu_head rcu_node
;
47 * Human readable agent return code.
49 static const char *error_string_array
[] = {
50 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_SUCCESS
) ] = "Success",
51 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_INVALID
) ] = "Invalid command",
52 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_UNKNOWN_NAME
) ] = "Unknown logger name",
55 [ AGENT_RET_CODE_INDEX(AGENT_RET_CODE_NR
) ] = "Unknown code",
59 void log_reply_code(uint32_t in_reply_ret_code
)
61 int level
= PRINT_DBG3
;
63 * reply_ret_code and in_reply_ret_code are kept separate to have a
64 * sanitized value (used to retrieve the human readable string) and the
65 * original value which is logged as-is.
67 uint32_t reply_ret_code
= in_reply_ret_code
;
69 if (reply_ret_code
< AGENT_RET_CODE_SUCCESS
||
70 reply_ret_code
>= AGENT_RET_CODE_NR
) {
71 reply_ret_code
= AGENT_RET_CODE_NR
;
75 LOG(level
, "Agent replied with retcode: %s (%"PRIu32
")",
76 error_string_array
[AGENT_RET_CODE_INDEX(
82 * Match function for the events hash table lookup by name.
84 static int ht_match_event_by_name(struct cds_lfht_node
*node
,
87 struct agent_event
*event
;
88 const struct agent_ht_key
*key
;
93 event
= caa_container_of(node
, struct agent_event
, node
.node
);
96 /* Match 1 elements of the key: name. */
99 if (strncmp(event
->name
, key
->name
, sizeof(event
->name
)) != 0) {
110 * Match function for the events hash table lookup by name, loglevel and
113 static int ht_match_event(struct cds_lfht_node
*node
,
116 struct agent_event
*event
;
117 const struct agent_ht_key
*key
;
123 event
= caa_container_of(node
, struct agent_event
, node
.node
);
126 /* Match 2 elements of the key: name and loglevel. */
129 if (strncmp(event
->name
, key
->name
, sizeof(event
->name
)) != 0) {
133 /* Event loglevel value and type. */
134 ll_match
= loglevels_match(event
->loglevel_type
,
135 event
->loglevel_value
, key
->loglevel_type
,
136 key
->loglevel_value
, LTTNG_EVENT_LOGLEVEL_ALL
);
142 /* Filter expression */
143 if (!!event
->filter_expression
!= !!key
->filter_expression
) {
144 /* One has a filter expression, the other does not */
148 if (event
->filter_expression
) {
149 if (strncmp(event
->filter_expression
, key
->filter_expression
,
150 strlen(event
->filter_expression
)) != 0) {
162 * Add unique agent event based on the event name and loglevel.
164 static void add_unique_agent_event(struct lttng_ht
*ht
,
165 struct agent_event
*event
)
167 struct cds_lfht_node
*node_ptr
;
168 struct agent_ht_key key
;
174 key
.name
= event
->name
;
175 key
.loglevel_value
= event
->loglevel_value
;
176 key
.loglevel_type
= event
->loglevel_type
;
177 key
.filter_expression
= event
->filter_expression
;
179 node_ptr
= cds_lfht_add_unique(ht
->ht
,
180 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
181 ht_match_event
, &key
, &event
->node
.node
);
182 assert(node_ptr
== &event
->node
.node
);
186 * URCU delayed agent event reclaim.
188 static void destroy_event_agent_rcu(struct rcu_head
*head
)
190 struct lttng_ht_node_str
*node
=
191 caa_container_of(head
, struct lttng_ht_node_str
, head
);
192 struct agent_event
*event
=
193 caa_container_of(node
, struct agent_event
, node
);
195 agent_destroy_event(event
);
199 * URCU delayed agent app reclaim.
201 static void destroy_app_agent_rcu(struct rcu_head
*head
)
203 struct lttng_ht_node_ulong
*node
=
204 caa_container_of(head
, struct lttng_ht_node_ulong
, head
);
205 struct agent_app
*app
=
206 caa_container_of(node
, struct agent_app
, node
);
212 * Communication with the agent. Send the message header to the given socket in
215 * Return 0 on success or else a negative errno message of sendmsg() op.
217 static int send_header(struct lttcomm_sock
*sock
, uint64_t data_size
,
218 uint32_t cmd
, uint32_t cmd_version
)
222 struct lttcomm_agent_hdr msg
;
226 memset(&msg
, 0, sizeof(msg
));
227 msg
.data_size
= htobe64(data_size
);
228 msg
.cmd
= htobe32(cmd
);
229 msg
.cmd_version
= htobe32(cmd_version
);
231 size
= sock
->ops
->sendmsg(sock
, &msg
, sizeof(msg
), 0);
232 if (size
< sizeof(msg
)) {
243 * Communication call with the agent. Send the payload to the given socket. The
244 * header MUST be sent prior to this call.
246 * Return 0 on success or else a negative errno value of sendmsg() op.
248 static int send_payload(struct lttcomm_sock
*sock
, const void *data
,
257 len
= sock
->ops
->sendmsg(sock
, data
, size
, 0);
269 * Communication call with the agent. Receive reply from the agent using the
272 * Return 0 on success or else a negative errno value from recvmsg() op.
274 static int recv_reply(struct lttcomm_sock
*sock
, void *buf
, size_t size
)
282 len
= sock
->ops
->recvmsg(sock
, buf
, size
, 0);
294 * Internal event listing for a given app. Populate events.
296 * Return number of element in the list or else a negative LTTNG_ERR* code.
297 * On success, the caller is responsible for freeing the memory
298 * allocated for "events".
300 static ssize_t
list_events(struct agent_app
*app
, struct lttng_event
**events
)
302 int ret
, i
, len
= 0, offset
= 0;
305 uint32_t reply_ret_code
;
306 struct lttng_event
*tmp_events
= NULL
;
307 struct lttcomm_agent_list_reply
*reply
= NULL
;
308 struct lttcomm_agent_list_reply_hdr reply_hdr
;
314 DBG2("Agent listing events for app pid: %d and socket %d", app
->pid
,
317 ret
= send_header(app
->sock
, 0, AGENT_CMD_LIST
, 0);
322 /* Get list header so we know how much we'll receive. */
323 ret
= recv_reply(app
->sock
, &reply_hdr
, sizeof(reply_hdr
));
328 reply_ret_code
= be32toh(reply_hdr
.ret_code
);
329 log_reply_code(reply_ret_code
);
330 switch (reply_ret_code
) {
331 case AGENT_RET_CODE_SUCCESS
:
332 data_size
= be32toh(reply_hdr
.data_size
) + sizeof(*reply
);
339 reply
= zmalloc(data_size
);
341 ret
= LTTNG_ERR_NOMEM
;
345 /* Get the list with the appropriate data size. */
346 ret
= recv_reply(app
->sock
, reply
, data_size
);
351 nb_event
= be32toh(reply
->nb_event
);
352 tmp_events
= zmalloc(sizeof(*tmp_events
) * nb_event
);
354 ret
= LTTNG_ERR_NOMEM
;
358 for (i
= 0; i
< nb_event
; i
++) {
360 if (lttng_strncpy(tmp_events
[i
].name
, reply
->payload
+ offset
,
361 sizeof(tmp_events
[i
].name
))) {
362 ret
= LTTNG_ERR_INVALID
;
365 tmp_events
[i
].pid
= app
->pid
;
366 tmp_events
[i
].enabled
= -1;
367 len
= strlen(reply
->payload
+ offset
) + 1;
370 *events
= tmp_events
;
376 ret
= LTTNG_ERR_UST_LIST_FAIL
;
385 * Internal enable agent event on a agent application. This function
386 * communicates with the agent to enable a given event.
388 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
390 static int enable_event(struct agent_app
*app
, struct agent_event
*event
)
395 size_t filter_expression_length
;
396 uint32_t reply_ret_code
;
397 struct lttcomm_agent_enable_event msg
;
398 struct lttcomm_agent_generic_reply reply
;
404 DBG2("Agent enabling event %s for app pid: %d and socket %d", event
->name
,
405 app
->pid
, app
->sock
->fd
);
408 * Calculate the payload's size, which is the fixed-size struct followed
409 * by the variable-length filter expression (+1 for the ending \0).
411 if (!event
->filter_expression
) {
412 filter_expression_length
= 0;
414 filter_expression_length
= strlen(event
->filter_expression
) + 1;
416 data_size
= sizeof(msg
) + filter_expression_length
;
418 memset(&msg
, 0, sizeof(msg
));
419 msg
.loglevel_value
= htobe32(event
->loglevel_value
);
420 msg
.loglevel_type
= htobe32(event
->loglevel_type
);
421 if (lttng_strncpy(msg
.name
, event
->name
, sizeof(msg
.name
))) {
422 ret
= LTTNG_ERR_INVALID
;
425 msg
.filter_expression_length
= htobe32(filter_expression_length
);
427 ret
= send_header(app
->sock
, data_size
, AGENT_CMD_ENABLE
, 0);
432 bytes_to_send
= zmalloc(data_size
);
433 if (!bytes_to_send
) {
434 ret
= LTTNG_ERR_NOMEM
;
438 memcpy(bytes_to_send
, &msg
, sizeof(msg
));
439 if (filter_expression_length
> 0) {
440 memcpy(bytes_to_send
+ sizeof(msg
), event
->filter_expression
,
441 filter_expression_length
);
444 ret
= send_payload(app
->sock
, bytes_to_send
, data_size
);
450 ret
= recv_reply(app
->sock
, &reply
, sizeof(reply
));
455 reply_ret_code
= be32toh(reply
.ret_code
);
456 log_reply_code(reply_ret_code
);
457 switch (reply_ret_code
) {
458 case AGENT_RET_CODE_SUCCESS
:
460 case AGENT_RET_CODE_UNKNOWN_NAME
:
461 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
471 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
477 * Send Pascal-style string. Size is sent as a 32-bit big endian integer.
480 int send_pstring(struct lttcomm_sock
*sock
, const char *str
, uint32_t len
)
485 len_be
= htobe32(len
);
486 ret
= send_payload(sock
, &len_be
, sizeof(len_be
));
491 ret
= send_payload(sock
, str
, len
);
500 * Internal enable application context on an agent application. This function
501 * communicates with the agent to enable a given application context.
503 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
505 static int app_context_op(struct agent_app
*app
,
506 struct agent_app_ctx
*ctx
, enum lttcomm_agent_command cmd
)
509 uint32_t reply_ret_code
;
510 struct lttcomm_agent_generic_reply reply
;
511 size_t app_ctx_provider_name_len
, app_ctx_name_len
, data_size
;
516 assert(cmd
== AGENT_CMD_APP_CTX_ENABLE
||
517 cmd
== AGENT_CMD_APP_CTX_DISABLE
);
519 DBG2("Agent %s application %s:%s for app pid: %d and socket %d",
520 cmd
== AGENT_CMD_APP_CTX_ENABLE
? "enabling" : "disabling",
521 ctx
->provider_name
, ctx
->ctx_name
,
522 app
->pid
, app
->sock
->fd
);
525 * Calculate the payload's size, which consists of the size (u32, BE)
526 * of the provider name, the NULL-terminated provider name string, the
527 * size (u32, BE) of the context name, followed by the NULL-terminated
528 * context name string.
530 app_ctx_provider_name_len
= strlen(ctx
->provider_name
) + 1;
531 app_ctx_name_len
= strlen(ctx
->ctx_name
) + 1;
532 data_size
= sizeof(uint32_t) + app_ctx_provider_name_len
+
533 sizeof(uint32_t) + app_ctx_name_len
;
535 ret
= send_header(app
->sock
, data_size
, cmd
, 0);
540 if (app_ctx_provider_name_len
> UINT32_MAX
||
541 app_ctx_name_len
> UINT32_MAX
) {
542 ERR("Application context name > MAX_UINT32");
543 ret
= LTTNG_ERR_INVALID
;
547 ret
= send_pstring(app
->sock
, ctx
->provider_name
,
548 (uint32_t) app_ctx_provider_name_len
);
553 ret
= send_pstring(app
->sock
, ctx
->ctx_name
,
554 (uint32_t) app_ctx_name_len
);
559 ret
= recv_reply(app
->sock
, &reply
, sizeof(reply
));
564 reply_ret_code
= be32toh(reply
.ret_code
);
565 log_reply_code(reply_ret_code
);
566 switch (reply_ret_code
) {
567 case AGENT_RET_CODE_SUCCESS
:
577 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
583 * Internal disable agent event call on a agent application. This function
584 * communicates with the agent to disable a given event.
586 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
588 static int disable_event(struct agent_app
*app
, struct agent_event
*event
)
592 uint32_t reply_ret_code
;
593 struct lttcomm_agent_disable_event msg
;
594 struct lttcomm_agent_generic_reply reply
;
600 DBG2("Agent disabling event %s for app pid: %d and socket %d", event
->name
,
601 app
->pid
, app
->sock
->fd
);
603 data_size
= sizeof(msg
);
604 memset(&msg
, 0, sizeof(msg
));
605 if (lttng_strncpy(msg
.name
, event
->name
, sizeof(msg
.name
))) {
606 ret
= LTTNG_ERR_INVALID
;
610 ret
= send_header(app
->sock
, data_size
, AGENT_CMD_DISABLE
, 0);
615 ret
= send_payload(app
->sock
, &msg
, sizeof(msg
));
620 ret
= recv_reply(app
->sock
, &reply
, sizeof(reply
));
625 reply_ret_code
= be32toh(reply
.ret_code
);
626 log_reply_code(reply_ret_code
);
627 switch (reply_ret_code
) {
628 case AGENT_RET_CODE_SUCCESS
:
630 case AGENT_RET_CODE_UNKNOWN_NAME
:
631 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
641 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
647 * Send back the registration DONE command to a given agent application.
649 * Return 0 on success or else a negative value.
651 int agent_send_registration_done(struct agent_app
*app
)
656 DBG("Agent sending registration done to app socket %d", app
->sock
->fd
);
658 return send_header(app
->sock
, 0, AGENT_CMD_REG_DONE
, 0);
662 * Enable agent event on every agent applications registered with the session
665 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
667 int agent_enable_event(struct agent_event
*event
,
668 enum lttng_domain_type domain
)
671 struct agent_app
*app
;
672 struct lttng_ht_iter iter
;
678 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
680 if (app
->domain
!= domain
) {
684 /* Enable event on agent application through TCP socket. */
685 ret
= enable_event(app
, event
);
686 if (ret
!= LTTNG_OK
) {
692 event
->user_refcount
++;
701 void destroy_app_ctx(struct agent_app_ctx
*ctx
)
703 free(ctx
->provider_name
);
709 struct agent_app_ctx
*create_app_ctx(const struct lttng_event_context
*ctx
)
711 struct agent_app_ctx
*agent_ctx
= NULL
;
717 assert(ctx
->ctx
== LTTNG_EVENT_CONTEXT_APP_CONTEXT
);
718 agent_ctx
= zmalloc(sizeof(*ctx
));
723 agent_ctx
->provider_name
= strdup(ctx
->u
.app_ctx
.provider_name
);
724 agent_ctx
->ctx_name
= strdup(ctx
->u
.app_ctx
.ctx_name
);
725 if (!agent_ctx
->provider_name
|| !agent_ctx
->ctx_name
) {
726 destroy_app_ctx(agent_ctx
);
734 * Enable agent context on every agent applications registered with the session
737 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
739 int agent_enable_context(const struct lttng_event_context
*ctx
,
740 enum lttng_domain_type domain
)
743 struct agent_app
*app
;
744 struct lttng_ht_iter iter
;
747 if (ctx
->ctx
!= LTTNG_EVENT_CONTEXT_APP_CONTEXT
) {
748 ret
= LTTNG_ERR_INVALID
;
754 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
756 struct agent_app_ctx
*agent_ctx
;
758 if (app
->domain
!= domain
) {
762 agent_ctx
= create_app_ctx(ctx
);
764 ret
= LTTNG_ERR_NOMEM
;
768 /* Enable event on agent application through TCP socket. */
769 ret
= app_context_op(app
, agent_ctx
, AGENT_CMD_APP_CTX_ENABLE
);
770 destroy_app_ctx(agent_ctx
);
771 if (ret
!= LTTNG_OK
) {
785 * Disable agent event on every agent application registered with the session
788 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
790 int agent_disable_event(struct agent_event
*event
,
791 enum lttng_domain_type domain
)
794 struct agent_app
*app
;
795 struct lttng_ht_iter iter
;
798 if (!event
->enabled
) {
802 if (event
->user_refcount
- 1 != 0) {
804 * Disable the agent event only when all users (trigger etc.)
808 event
->user_refcount
--;
815 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
817 if (app
->domain
!= domain
) {
821 /* Enable event on agent application through TCP socket. */
822 ret
= disable_event(app
, event
);
823 if (ret
!= LTTNG_OK
) {
828 event
->user_refcount
= 0;
838 * Disable agent context on every agent application registered with the session
841 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
843 static int disable_context(struct agent_app_ctx
*ctx
,
844 enum lttng_domain_type domain
)
847 struct agent_app
*app
;
848 struct lttng_ht_iter iter
;
853 DBG2("Disabling agent application context %s:%s",
854 ctx
->provider_name
, ctx
->ctx_name
);
855 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
857 if (app
->domain
!= domain
) {
861 ret
= app_context_op(app
, ctx
, AGENT_CMD_APP_CTX_DISABLE
);
862 if (ret
!= LTTNG_OK
) {
872 * Ask every agent for the list of possible event. Events is allocated with the
873 * events of every agent application.
875 * Return the number of events or else a negative value.
877 int agent_list_events(struct lttng_event
**events
,
878 enum lttng_domain_type domain
)
881 size_t nbmem
, count
= 0;
882 struct agent_app
*app
;
883 struct lttng_event
*tmp_events
= NULL
;
884 struct lttng_ht_iter iter
;
888 DBG2("Agent listing events for domain %d", domain
);
890 nbmem
= UST_APP_EVENT_LIST_SIZE
;
891 tmp_events
= zmalloc(nbmem
* sizeof(*tmp_events
));
893 PERROR("zmalloc agent list events");
899 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, app
,
902 struct lttng_event
*agent_events
;
904 /* Skip domain not asked by the list. */
905 if (app
->domain
!= domain
) {
909 nb_ev
= list_events(app
, &agent_events
);
915 if (count
+ nb_ev
> nbmem
) {
916 /* In case the realloc fails, we free the memory */
917 struct lttng_event
*new_tmp_events
;
920 new_nbmem
= max_t(size_t, count
+ nb_ev
, nbmem
<< 1);
921 DBG2("Reallocating agent event list from %zu to %zu entries",
923 new_tmp_events
= realloc(tmp_events
,
924 new_nbmem
* sizeof(*new_tmp_events
));
925 if (!new_tmp_events
) {
926 PERROR("realloc agent events");
931 /* Zero the new memory */
932 memset(new_tmp_events
+ nbmem
, 0,
933 (new_nbmem
- nbmem
) * sizeof(*new_tmp_events
));
935 tmp_events
= new_tmp_events
;
937 memcpy(tmp_events
+ count
, agent_events
,
938 nb_ev
* sizeof(*tmp_events
));
945 *events
= tmp_events
;
956 * Create a agent app object using the given PID.
958 * Return newly allocated object or else NULL on error.
960 struct agent_app
*agent_create_app(pid_t pid
, enum lttng_domain_type domain
,
961 struct lttcomm_sock
*sock
)
963 struct agent_app
*app
;
967 app
= zmalloc(sizeof(*app
));
969 PERROR("zmalloc agent create");
974 app
->domain
= domain
;
976 lttng_ht_node_init_ulong(&app
->node
, (unsigned long) app
->sock
->fd
);
983 * Lookup agent app by socket in the global hash table.
985 * RCU read side lock MUST be acquired.
987 * Return object if found else NULL.
989 struct agent_app
*agent_find_app_by_sock(int sock
)
991 struct lttng_ht_node_ulong
*node
;
992 struct lttng_ht_iter iter
;
993 struct agent_app
*app
;
997 lttng_ht_lookup(agent_apps_ht_by_sock
, (void *)((unsigned long) sock
), &iter
);
998 node
= lttng_ht_iter_get_node_ulong(&iter
);
1002 app
= caa_container_of(node
, struct agent_app
, node
);
1004 DBG3("Agent app pid %d found by sock %d.", app
->pid
, sock
);
1008 DBG3("Agent app NOT found by sock %d.", sock
);
1013 * Add agent application object to the global hash table.
1015 void agent_add_app(struct agent_app
*app
)
1019 DBG3("Agent adding app sock: %d and pid: %d to ht", app
->sock
->fd
, app
->pid
);
1020 lttng_ht_add_unique_ulong(agent_apps_ht_by_sock
, &app
->node
);
1024 * Delete agent application from the global hash table.
1026 * rcu_read_lock() must be held by the caller.
1028 void agent_delete_app(struct agent_app
*app
)
1031 struct lttng_ht_iter iter
;
1035 DBG3("Agent deleting app pid: %d and sock: %d", app
->pid
, app
->sock
->fd
);
1037 iter
.iter
.node
= &app
->node
.node
;
1038 ret
= lttng_ht_del(agent_apps_ht_by_sock
, &iter
);
1043 * Destroy an agent application object by detaching it from its corresponding
1044 * UST app if one is connected by closing the socket. Finally, perform a
1045 * delayed memory reclaim.
1047 void agent_destroy_app(struct agent_app
*app
)
1052 app
->sock
->ops
->close(app
->sock
);
1053 lttcomm_destroy_sock(app
->sock
);
1056 call_rcu(&app
->node
.head
, destroy_app_agent_rcu
);
1060 * Initialize an already allocated agent object.
1062 * Return 0 on success or else a negative errno value.
1064 int agent_init(struct agent
*agt
)
1070 agt
->events
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
1075 lttng_ht_node_init_u64(&agt
->node
, agt
->domain
);
1077 CDS_INIT_LIST_HEAD(&agt
->app_ctx_list
);
1085 * Add agent object to the given hash table.
1087 void agent_add(struct agent
*agt
, struct lttng_ht
*ht
)
1092 DBG3("Agent adding from domain %d", agt
->domain
);
1094 lttng_ht_add_unique_u64(ht
, &agt
->node
);
1098 * Create an agent object for the given domain.
1100 * Return the allocated agent or NULL on error.
1102 struct agent
*agent_create(enum lttng_domain_type domain
)
1107 agt
= zmalloc(sizeof(struct agent
));
1111 agt
->domain
= domain
;
1113 ret
= agent_init(agt
);
1125 * Create a newly allocated agent event data structure.
1126 * Ownership of filter_expression is taken.
1128 * Return a new object else NULL on error.
1130 struct agent_event
*agent_create_event(const char *name
,
1131 enum lttng_loglevel_type loglevel_type
, int loglevel_value
,
1132 struct lttng_filter_bytecode
*filter
, char *filter_expression
)
1134 struct agent_event
*event
= NULL
;
1136 DBG3("Agent create new event with name %s, loglevel type %d, \
1137 loglevel value %d and filter %s",
1138 name
, loglevel_type
, loglevel_value
,
1139 filter_expression
? filter_expression
: "NULL");
1142 ERR("Failed to create agent event; no name provided.");
1146 event
= zmalloc(sizeof(*event
));
1151 strncpy(event
->name
, name
, sizeof(event
->name
));
1152 event
->name
[sizeof(event
->name
) - 1] = '\0';
1153 lttng_ht_node_init_str(&event
->node
, event
->name
);
1155 event
->loglevel_value
= loglevel_value
;
1156 event
->loglevel_type
= loglevel_type
;
1157 event
->filter
= filter
;
1158 event
->filter_expression
= filter_expression
;
1164 * Unique add of a agent event to an agent object.
1166 void agent_add_event(struct agent_event
*event
, struct agent
*agt
)
1170 assert(agt
->events
);
1172 DBG3("Agent adding event %s", event
->name
);
1173 add_unique_agent_event(agt
->events
, event
);
1174 agt
->being_used
= 1;
1178 * Unique add of a agent context to an agent object.
1180 int agent_add_context(const struct lttng_event_context
*ctx
, struct agent
*agt
)
1183 struct agent_app_ctx
*agent_ctx
= NULL
;
1187 assert(agt
->events
);
1188 assert(ctx
->ctx
== LTTNG_EVENT_CONTEXT_APP_CONTEXT
);
1190 agent_ctx
= create_app_ctx(ctx
);
1192 ret
= LTTNG_ERR_NOMEM
;
1196 DBG3("Agent adding context %s:%s", ctx
->u
.app_ctx
.provider_name
,
1197 ctx
->u
.app_ctx
.ctx_name
);
1198 cds_list_add_tail_rcu(&agent_ctx
->list_node
, &agt
->app_ctx_list
);
1204 * Find multiple agent events sharing the given name.
1206 * RCU read side lock MUST be acquired. It must be held for the
1207 * duration of the iteration.
1209 * Sets the given iterator.
1211 void agent_find_events_by_name(const char *name
, struct agent
*agt
,
1212 struct lttng_ht_iter
* iter
)
1214 struct lttng_ht
*ht
;
1215 struct agent_ht_key key
;
1219 assert(agt
->events
);
1225 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) name
, lttng_ht_seed
),
1226 ht_match_event_by_name
, &key
, &iter
->iter
);
1230 * Find the agent event matching the trigger.
1232 * RCU read side lock MUST be acquired. It must be kept for as long as
1233 * the returned agent_event is used.
1235 * Return object if found else NULL.
1237 struct agent_event
*agent_find_event_by_trigger(
1238 const struct lttng_trigger
*trigger
, struct agent
*agt
)
1240 enum lttng_condition_status c_status
;
1241 enum lttng_event_rule_status er_status
;
1242 enum lttng_domain_type d_type
;
1243 const struct lttng_condition
*condition
;
1244 const struct lttng_event_rule
*rule
;
1246 const char *filter_expression
;
1247 /* TODO validate if this is the unset value or no */
1248 int loglevel_value
= 0;
1249 enum lttng_loglevel_type loglevel_type
;
1252 assert(agt
->events
);
1254 condition
= lttng_trigger_get_const_condition(trigger
);
1256 assert(lttng_condition_get_type(condition
) ==
1257 LTTNG_CONDITION_TYPE_EVENT_RULE_HIT
);
1259 c_status
= lttng_condition_event_rule_get_rule(condition
, &rule
);
1260 assert(c_status
== LTTNG_CONDITION_STATUS_OK
);
1262 assert(lttng_event_rule_get_type(rule
) ==
1263 LTTNG_EVENT_RULE_TYPE_TRACEPOINT
);
1265 d_type
= lttng_event_rule_get_domain_type(rule
);
1266 assert(d_type
== LTTNG_DOMAIN_JUL
|| d_type
== LTTNG_DOMAIN_LOG4J
||
1267 d_type
== LTTNG_DOMAIN_PYTHON
);
1269 /* Get the name (aka pattern) */
1270 er_status
= lttng_event_rule_tracepoint_get_pattern(rule
, &name
);
1271 assert(er_status
== LTTNG_EVENT_RULE_STATUS_OK
);
1273 /* Get the internal filter_expression */
1274 filter_expression
= lttng_event_rule_get_filter(rule
);
1276 er_status
= lttng_event_rule_tracepoint_get_loglevel_type(
1277 rule
, &loglevel_type
);
1278 assert(er_status
== LTTNG_EVENT_RULE_STATUS_OK
);
1279 if (loglevel_type
!= LTTNG_EVENT_LOGLEVEL_ALL
) {
1280 er_status
= lttng_event_rule_tracepoint_get_loglevel(
1281 rule
, &loglevel_value
);
1282 assert(er_status
== LTTNG_EVENT_RULE_STATUS_OK
);
1285 return agent_find_event(name
, loglevel_type
, loglevel_value
,
1286 filter_expression
, agt
);
1290 * Get the next agent event duplicate by name. This should be called
1291 * after a call to agent_find_events_by_name() to iterate on events.
1293 * The RCU read lock must be held during the iteration and for as long
1294 * as the object the iterator points to remains in use.
1296 void agent_event_next_duplicate(const char *name
,
1297 struct agent
*agt
, struct lttng_ht_iter
* iter
)
1299 struct agent_ht_key key
;
1303 cds_lfht_next_duplicate(agt
->events
->ht
, ht_match_event_by_name
,
1308 * Find a agent event in the given agent using name, loglevel and filter.
1310 * RCU read side lock MUST be acquired. It must be kept for as long as
1311 * the returned agent_event is used.
1313 * Return object if found else NULL.
1315 struct agent_event
*agent_find_event(const char *name
,
1316 enum lttng_loglevel_type loglevel_type
,
1318 const char *filter_expression
,
1321 struct lttng_ht_node_str
*node
;
1322 struct lttng_ht_iter iter
;
1323 struct lttng_ht
*ht
;
1324 struct agent_ht_key key
;
1328 assert(agt
->events
);
1332 key
.loglevel_value
= loglevel_value
;
1333 key
.loglevel_type
= loglevel_type
;
1334 key
.filter_expression
= filter_expression
;
1336 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) name
, lttng_ht_seed
),
1337 ht_match_event
, &key
, &iter
.iter
);
1338 node
= lttng_ht_iter_get_node_str(&iter
);
1343 DBG3("Agent event found %s.", name
);
1344 return caa_container_of(node
, struct agent_event
, node
);
1347 DBG3("Agent event NOT found %s.", name
);
1352 * Free given agent event. This event must not be globally visible at this
1353 * point (only expected to be used on failure just after event creation). After
1354 * this call, the pointer is not usable anymore.
1356 void agent_destroy_event(struct agent_event
*event
)
1360 free(event
->filter
);
1361 free(event
->filter_expression
);
1362 free(event
->exclusion
);
1367 void destroy_app_ctx_rcu(struct rcu_head
*head
)
1369 struct agent_app_ctx
*ctx
=
1370 caa_container_of(head
, struct agent_app_ctx
, rcu_node
);
1372 destroy_app_ctx(ctx
);
1376 * Destroy an agent completely.
1378 void agent_destroy(struct agent
*agt
)
1380 struct lttng_ht_node_str
*node
;
1381 struct lttng_ht_iter iter
;
1382 struct agent_app_ctx
*ctx
;
1386 DBG3("Agent destroy");
1389 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, node
, node
) {
1391 struct agent_event
*event
;
1394 * When destroying an event, we have to try to disable it on the
1395 * agent side so the event stops generating data. The return
1396 * value is not important since we have to continue anyway
1397 * destroying the object.
1399 event
= caa_container_of(node
, struct agent_event
, node
);
1400 (void) agent_disable_event(event
, agt
->domain
);
1402 ret
= lttng_ht_del(agt
->events
, &iter
);
1404 call_rcu(&node
->head
, destroy_event_agent_rcu
);
1407 cds_list_for_each_entry_rcu(ctx
, &agt
->app_ctx_list
, list_node
) {
1408 (void) disable_context(ctx
, agt
->domain
);
1409 cds_list_del(&ctx
->list_node
);
1410 call_rcu(&ctx
->rcu_node
, destroy_app_ctx_rcu
);
1413 ht_cleanup_push(agt
->events
);
1418 * Allocate agent_apps_ht_by_sock.
1420 int agent_app_ht_alloc(void)
1424 agent_apps_ht_by_sock
= lttng_ht_new(0, LTTNG_HT_TYPE_ULONG
);
1425 if (!agent_apps_ht_by_sock
) {
1433 * Allocate agent_apps_ht_by_sock.
1435 int trigger_agent_ht_alloc(void)
1439 trigger_agents_ht_by_domain
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
1440 if (!trigger_agents_ht_by_domain
) {
1448 * Destroy a agent application by socket.
1450 void agent_destroy_app_by_sock(int sock
)
1452 struct agent_app
*app
;
1457 * Not finding an application is a very important error that should NEVER
1458 * happen. The hash table deletion is ONLY done through this call when the
1459 * main sessiond thread is torn down.
1462 app
= agent_find_app_by_sock(sock
);
1465 /* RCU read side lock is assumed to be held by this function. */
1466 agent_delete_app(app
);
1468 /* The application is freed in a RCU call but the socket is closed here. */
1469 agent_destroy_app(app
);
1474 * Clean-up the agent app hash table and destroy it.
1476 void agent_app_ht_clean(void)
1478 struct lttng_ht_node_ulong
*node
;
1479 struct lttng_ht_iter iter
;
1481 if (!agent_apps_ht_by_sock
) {
1485 cds_lfht_for_each_entry(agent_apps_ht_by_sock
->ht
, &iter
.iter
, node
, node
) {
1486 struct agent_app
*app
;
1488 app
= caa_container_of(node
, struct agent_app
, node
);
1489 agent_destroy_app_by_sock(app
->sock
->fd
);
1493 lttng_ht_destroy(agent_apps_ht_by_sock
);
1497 * Clean-up the trigger agent hash table and destroy it.
1499 void trigger_agent_ht_clean(void)
1501 struct lttng_ht_node_u64
*node
;
1502 struct lttng_ht_iter iter
;
1504 if (!trigger_agents_ht_by_domain
) {
1508 cds_lfht_for_each_entry (trigger_agents_ht_by_domain
->ht
, &iter
.iter
,
1510 struct agent
*agent
;
1512 (void) lttng_ht_del(trigger_agents_ht_by_domain
, &iter
);
1514 agent
= caa_container_of(node
, struct agent
, node
);
1515 agent_destroy(agent
);
1519 lttng_ht_destroy(trigger_agents_ht_by_domain
);
1523 * Update a agent application (given socket) using the given agent.
1525 * Note that this function is most likely to be used with a tracing session
1526 * thus the caller should make sure to hold the appropriate lock(s).
1528 void agent_update(struct agent
*agt
, int sock
)
1531 struct agent_app
*app
;
1532 struct agent_event
*event
;
1533 struct lttng_ht_iter iter
;
1534 struct agent_app_ctx
*ctx
;
1539 DBG("Agent updating app socket %d", sock
);
1542 app
= agent_find_app_by_sock(sock
);
1544 * We are in the registration path thus if the application is gone,
1545 * there is a serious code flow error.
1548 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, event
, node
.node
) {
1549 /* Skip event if disabled. */
1550 if (!event
->enabled
) {
1554 ret
= enable_event(app
, event
);
1555 if (ret
!= LTTNG_OK
) {
1556 DBG2("Agent update unable to enable event %s on app pid: %d sock %d",
1557 event
->name
, app
->pid
, app
->sock
->fd
);
1558 /* Let's try the others here and don't assume the app is dead. */
1563 cds_list_for_each_entry_rcu(ctx
, &agt
->app_ctx_list
, list_node
) {
1564 ret
= app_context_op(app
, ctx
, AGENT_CMD_APP_CTX_ENABLE
);
1565 if (ret
!= LTTNG_OK
) {
1566 DBG2("Agent update unable to add application context %s:%s on app pid: %d sock %d",
1567 ctx
->provider_name
, ctx
->ctx_name
,
1568 app
->pid
, app
->sock
->fd
);
1576 struct agent
*trigger_find_agent(enum lttng_domain_type domain_type
)
1578 struct agent
*agt
= NULL
;
1579 struct lttng_ht_node_u64
*node
;
1580 struct lttng_ht_iter iter
;
1583 assert(trigger_agents_ht_by_domain
);
1585 DBG3("Trigger agent lookup for domain %d", domain_type
);
1589 lttng_ht_lookup(trigger_agents_ht_by_domain
, &key
, &iter
);
1590 node
= lttng_ht_iter_get_node_u64(&iter
);
1594 agt
= caa_container_of(node
, struct agent
, node
);