Commit | Line | Data |
---|---|---|
b99a0cb3 JG |
1 | /* |
2 | * error-query.c | |
3 | * | |
4 | * Copyright (C) 2021 Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
5 | * | |
6 | * SPDX-License-Identifier: GPL-2.1-only | |
7 | * | |
8 | */ | |
9 | ||
10 | #include <common/dynamic-array.h> | |
11 | #include <common/error.h> | |
12 | #include <common/macros.h> | |
0f7c2963 | 13 | #include <common/mi-lttng.h> |
b99a0cb3 JG |
14 | #include <common/sessiond-comm/sessiond-comm.h> |
15 | #include <lttng/action/action-internal.h> | |
ad63a966 | 16 | #include <lttng/action/list-internal.h> |
482b3452 | 17 | #include <lttng/action/path-internal.h> |
b99a0cb3 JG |
18 | #include <lttng/error-query-internal.h> |
19 | #include <lttng/error-query.h> | |
20 | #include <lttng/trigger/trigger-internal.h> | |
21 | #include <stddef.h> | |
22 | ||
23 | struct lttng_error_query { | |
24 | enum lttng_error_query_target_type target_type; | |
25 | }; | |
26 | ||
27 | struct lttng_error_query_comm { | |
28 | /* enum lttng_error_query_target_type */ | |
29 | int8_t target_type; | |
30 | /* Target-specific payload. */ | |
31 | char payload[]; | |
32 | }; | |
33 | ||
34 | struct lttng_error_query_trigger { | |
35 | struct lttng_error_query parent; | |
36 | /* Mutable only because of the reference count. */ | |
37 | struct lttng_trigger *trigger; | |
38 | }; | |
39 | ||
8ce7c93a JG |
40 | struct lttng_error_query_condition { |
41 | struct lttng_error_query parent; | |
42 | /* Mutable only because of the reference count. */ | |
43 | struct lttng_trigger *trigger; | |
44 | }; | |
45 | ||
b99a0cb3 JG |
46 | struct lttng_error_query_action { |
47 | struct lttng_error_query parent; | |
48 | /* Mutable only because of the reference count. */ | |
49 | struct lttng_trigger *trigger; | |
ab8fc98e | 50 | struct lttng_action_path *action_path; |
b99a0cb3 JG |
51 | }; |
52 | ||
53 | struct lttng_error_query_result { | |
54 | enum lttng_error_query_result_type type; | |
55 | char *name; | |
56 | char *description; | |
57 | }; | |
58 | ||
59 | struct lttng_error_query_result_comm { | |
60 | /* enum lttng_error_query_result_type */ | |
61 | uint8_t type; | |
62 | /* Length of name (including null-terminator). */ | |
63 | uint32_t name_len; | |
64 | /* Length of description (including null-terminator). */ | |
65 | uint32_t description_len; | |
66 | /* Name, description, and type-specific payload follow. */ | |
67 | char payload[]; | |
68 | } LTTNG_PACKED; | |
69 | ||
70 | struct lttng_error_query_result_counter_comm { | |
71 | uint64_t value; | |
72 | } LTTNG_PACKED; | |
73 | ||
74 | struct lttng_error_query_result_counter { | |
75 | struct lttng_error_query_result parent; | |
76 | uint64_t value; | |
77 | }; | |
78 | ||
79 | struct lttng_error_query_results_comm { | |
80 | uint32_t count; | |
81 | /* `count` instances of `struct lttng_error_query_result` follow. */ | |
82 | char payload[]; | |
83 | } LTTNG_PACKED; | |
84 | ||
85 | struct lttng_error_query_results { | |
86 | struct lttng_dynamic_pointer_array results; | |
87 | }; | |
88 | ||
0f7c2963 JR |
89 | static |
90 | enum lttng_error_code lttng_error_query_result_mi_serialize( | |
91 | const struct lttng_error_query_result *result, | |
92 | struct mi_writer *writer); | |
93 | ||
94 | static | |
95 | enum lttng_error_code lttng_error_query_result_counter_mi_serialize( | |
96 | const struct lttng_error_query_result *result, | |
97 | struct mi_writer *writer); | |
b99a0cb3 JG |
98 | |
99 | struct lttng_error_query *lttng_error_query_trigger_create( | |
100 | const struct lttng_trigger *trigger) | |
101 | { | |
102 | struct lttng_error_query_trigger *query = NULL; | |
3746c278 | 103 | struct lttng_trigger *trigger_copy = NULL; |
b99a0cb3 | 104 | |
3746c278 | 105 | if (!trigger) { |
b99a0cb3 JG |
106 | goto end; |
107 | } | |
108 | ||
3746c278 JG |
109 | trigger_copy = lttng_trigger_copy(trigger); |
110 | if (!trigger_copy) { | |
b99a0cb3 JG |
111 | goto end; |
112 | } | |
113 | ||
114 | query = zmalloc(sizeof(*query)); | |
115 | if (!query) { | |
116 | PERROR("Failed to allocate trigger error query"); | |
3746c278 | 117 | goto error; |
b99a0cb3 JG |
118 | } |
119 | ||
120 | query->parent.target_type = LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER; | |
121 | query->trigger = trigger_copy; | |
3746c278 JG |
122 | trigger_copy = NULL; |
123 | ||
124 | error: | |
125 | lttng_trigger_put(trigger_copy); | |
b99a0cb3 JG |
126 | end: |
127 | return query ? &query->parent : NULL; | |
128 | } | |
129 | ||
8ce7c93a JG |
130 | struct lttng_error_query *lttng_error_query_condition_create( |
131 | const struct lttng_trigger *trigger) | |
132 | { | |
133 | struct lttng_error_query_condition *query = NULL; | |
134 | struct lttng_trigger *trigger_copy = NULL; | |
135 | ||
136 | if (!trigger) { | |
137 | goto end; | |
138 | } | |
139 | ||
140 | trigger_copy = lttng_trigger_copy(trigger); | |
141 | if (!trigger_copy) { | |
142 | goto end; | |
143 | } | |
144 | ||
145 | query = zmalloc(sizeof(*query)); | |
146 | if (!query) { | |
147 | PERROR("Failed to allocate condition error query"); | |
148 | goto error; | |
149 | } | |
150 | ||
151 | query->parent.target_type = LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION; | |
152 | query->trigger = trigger_copy; | |
153 | trigger_copy = NULL; | |
154 | ||
155 | error: | |
156 | lttng_trigger_put(trigger_copy); | |
157 | end: | |
158 | return query ? &query->parent : NULL; | |
159 | } | |
160 | ||
2658b8b5 JG |
161 | static |
162 | struct lttng_action *get_trigger_action_from_path( | |
163 | struct lttng_trigger *trigger, | |
164 | const struct lttng_action_path *action_path) | |
b99a0cb3 | 165 | { |
2658b8b5 JG |
166 | size_t index_count, i; |
167 | enum lttng_action_path_status path_status; | |
168 | struct lttng_action *current_action = NULL; | |
b99a0cb3 | 169 | |
2658b8b5 JG |
170 | path_status = lttng_action_path_get_index_count( |
171 | action_path, &index_count); | |
172 | if (path_status != LTTNG_ACTION_PATH_STATUS_OK) { | |
b99a0cb3 JG |
173 | goto end; |
174 | } | |
175 | ||
2658b8b5 JG |
176 | current_action = lttng_trigger_get_action(trigger); |
177 | for (i = 0; i < index_count; i++) { | |
178 | uint64_t path_index; | |
179 | ||
180 | path_status = lttng_action_path_get_index_at_index( | |
181 | action_path, i, &path_index); | |
182 | current_action = lttng_action_list_borrow_mutable_at_index( | |
183 | current_action, path_index); | |
184 | if (!current_action) { | |
185 | /* Invalid action path. */ | |
186 | goto end; | |
187 | } | |
b99a0cb3 JG |
188 | } |
189 | ||
2658b8b5 JG |
190 | end: |
191 | return current_action; | |
192 | } | |
193 | ||
194 | static | |
195 | bool is_valid_action_path(const struct lttng_trigger *trigger, | |
196 | const struct lttng_action_path *action_path) | |
197 | { | |
b99a0cb3 | 198 | /* |
2658b8b5 JG |
199 | * While 'trigger's constness is casted-away, the trigger and resulting |
200 | * action are not modified; we merely check for the action's existence. | |
b99a0cb3 | 201 | */ |
2658b8b5 JG |
202 | return !!get_trigger_action_from_path( |
203 | (struct lttng_trigger *) trigger, action_path); | |
204 | } | |
b99a0cb3 | 205 | |
2658b8b5 JG |
206 | struct lttng_error_query *lttng_error_query_action_create( |
207 | const struct lttng_trigger *trigger, | |
208 | const struct lttng_action_path *action_path) | |
209 | { | |
210 | struct lttng_error_query_action *query = NULL; | |
211 | struct lttng_trigger *trigger_copy = NULL; | |
212 | int ret_copy; | |
b99a0cb3 | 213 | |
2658b8b5 JG |
214 | if (!trigger || !action_path || |
215 | !is_valid_action_path(trigger, action_path)) { | |
216 | goto end; | |
217 | } | |
b99a0cb3 | 218 | |
2658b8b5 JG |
219 | trigger_copy = lttng_trigger_copy(trigger); |
220 | if (!trigger_copy) { | |
221 | goto end; | |
b99a0cb3 JG |
222 | } |
223 | ||
224 | query = zmalloc(sizeof(*query)); | |
225 | if (!query) { | |
226 | PERROR("Failed to allocate action error query"); | |
3746c278 | 227 | goto error; |
b99a0cb3 JG |
228 | } |
229 | ||
2658b8b5 JG |
230 | ret_copy = lttng_action_path_copy(action_path, &query->action_path); |
231 | if (ret_copy) { | |
232 | goto error; | |
233 | } | |
234 | ||
b99a0cb3 JG |
235 | query->parent.target_type = LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION; |
236 | query->trigger = trigger_copy; | |
3746c278 | 237 | trigger_copy = NULL; |
2658b8b5 JG |
238 | goto end; |
239 | ||
3746c278 JG |
240 | error: |
241 | lttng_trigger_put(trigger_copy); | |
2658b8b5 | 242 | lttng_error_query_destroy(query ? &query->parent : NULL); |
b99a0cb3 JG |
243 | end: |
244 | return query ? &query->parent : NULL; | |
245 | } | |
246 | ||
247 | void lttng_error_query_destroy(struct lttng_error_query *query) | |
248 | { | |
b99a0cb3 JG |
249 | if (!query) { |
250 | return; | |
251 | } | |
252 | ||
ab8fc98e JG |
253 | switch (query->target_type) { |
254 | case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER: | |
255 | { | |
256 | struct lttng_error_query_trigger *trigger_query = | |
257 | container_of(query, typeof(*trigger_query), | |
258 | parent); | |
259 | ||
260 | lttng_trigger_put(trigger_query->trigger); | |
261 | free(trigger_query); | |
262 | break; | |
263 | } | |
264 | case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION: | |
265 | { | |
266 | struct lttng_error_query_condition *condition_query = | |
267 | container_of(query, typeof(*condition_query), | |
268 | parent); | |
269 | ||
270 | lttng_trigger_put(condition_query->trigger); | |
271 | free(condition_query); | |
272 | break; | |
273 | } | |
274 | case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION: | |
275 | { | |
276 | struct lttng_error_query_action *action_query = | |
277 | container_of(query, typeof(*action_query), | |
278 | parent); | |
279 | ||
280 | lttng_trigger_put(action_query->trigger); | |
281 | lttng_action_path_destroy(action_query->action_path); | |
282 | free(action_query); | |
283 | break; | |
284 | } | |
285 | default: | |
286 | abort(); | |
287 | } | |
b99a0cb3 JG |
288 | } |
289 | ||
290 | static | |
291 | int lttng_error_query_result_counter_serialize( | |
292 | const struct lttng_error_query_result *result, | |
293 | struct lttng_payload *payload) | |
294 | { | |
295 | const struct lttng_error_query_result_counter *counter_result; | |
296 | ||
297 | assert(result->type == LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER); | |
298 | counter_result = container_of(result, typeof(*counter_result), parent); | |
299 | ||
300 | return lttng_dynamic_buffer_append(&payload->buffer, | |
301 | &(struct lttng_error_query_result_counter_comm) { | |
302 | .value = counter_result->value | |
303 | }, | |
304 | sizeof(struct lttng_error_query_result_counter_comm)); | |
305 | } | |
306 | ||
307 | LTTNG_HIDDEN | |
308 | int lttng_error_query_result_serialize( | |
309 | const struct lttng_error_query_result *result, | |
310 | struct lttng_payload *payload) | |
311 | { | |
312 | int ret; | |
313 | struct lttng_error_query_result_comm header = { | |
314 | .type = (uint8_t) result->type, | |
315 | .name_len = (typeof(header.name_len)) strlen(result->name) + 1, | |
316 | .description_len = (typeof(header.name_len)) strlen(result->description) + 1, | |
317 | }; | |
318 | ||
319 | /* Header. */ | |
320 | ret = lttng_dynamic_buffer_append( | |
321 | &payload->buffer, &header, sizeof(header)); | |
322 | if (ret) { | |
323 | ERR("Failed to append error query result communication header to payload"); | |
324 | goto end; | |
325 | } | |
326 | ||
327 | /* Name. */ | |
328 | ret = lttng_dynamic_buffer_append( | |
329 | &payload->buffer, result->name, header.name_len); | |
330 | if (ret) { | |
331 | ERR("Failed to append error query result name to payload"); | |
332 | goto end; | |
333 | } | |
334 | ||
335 | /* Description. */ | |
336 | ret = lttng_dynamic_buffer_append(&payload->buffer, result->description, | |
337 | header.description_len); | |
338 | if (ret) { | |
339 | ERR("Failed to append error query result description to payload"); | |
340 | goto end; | |
341 | } | |
342 | ||
343 | /* Type-specific payload. */ | |
344 | switch (result->type) { | |
345 | case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER: | |
346 | ret = lttng_error_query_result_counter_serialize( | |
347 | result, payload); | |
348 | if (ret) { | |
349 | ERR("Failed to serialize counter error query result"); | |
350 | goto end; | |
351 | } | |
352 | break; | |
353 | default: | |
354 | abort(); | |
355 | } | |
356 | ||
357 | end: | |
358 | return ret; | |
359 | } | |
360 | ||
361 | static | |
362 | int lttng_error_query_result_init( | |
363 | struct lttng_error_query_result *result, | |
364 | enum lttng_error_query_result_type result_type, | |
365 | const char *name, | |
366 | const char *description) | |
367 | { | |
368 | int ret; | |
369 | ||
370 | assert(name); | |
371 | assert(description); | |
372 | ||
373 | result->type = result_type; | |
374 | ||
375 | result->name = strdup(name); | |
376 | if (!result->name) { | |
377 | PERROR("Failed to copy error query result name"); | |
378 | ret = -1; | |
379 | goto end; | |
380 | } | |
381 | ||
382 | result->description = strdup(description); | |
383 | if (!result->description) { | |
384 | PERROR("Failed to copy error query result description"); | |
385 | ret = -1; | |
386 | goto end; | |
387 | } | |
388 | ||
389 | ret = 0; | |
390 | end: | |
391 | return ret; | |
392 | } | |
393 | ||
394 | LTTNG_HIDDEN | |
395 | void lttng_error_query_result_destroy(struct lttng_error_query_result *counter) | |
396 | { | |
397 | if (!counter) { | |
398 | return; | |
399 | } | |
400 | ||
401 | switch (counter->type) { | |
402 | case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER: | |
403 | /* Nothing to tear down. */ | |
404 | break; | |
405 | default: | |
406 | abort(); | |
407 | } | |
408 | ||
409 | free(counter->name); | |
410 | free(counter->description); | |
411 | free(counter); | |
412 | } | |
413 | ||
414 | LTTNG_HIDDEN | |
415 | struct lttng_error_query_result * | |
416 | lttng_error_query_result_counter_create( | |
417 | const char *name, const char *description, uint64_t value) | |
418 | { | |
419 | int init_ret; | |
420 | struct lttng_error_query_result_counter *counter; | |
421 | ||
422 | counter = zmalloc(sizeof(*counter)); | |
423 | if (!counter) { | |
424 | PERROR("Failed to allocate error query counter result"); | |
425 | goto end; | |
426 | } | |
427 | ||
428 | init_ret = lttng_error_query_result_init(&counter->parent, | |
429 | LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER, name, | |
430 | description); | |
431 | if (init_ret) { | |
432 | goto error; | |
433 | } | |
434 | ||
588c4b0d | 435 | counter->value = value; |
b99a0cb3 JG |
436 | goto end; |
437 | error: | |
438 | lttng_error_query_result_destroy(&counter->parent); | |
439 | end: | |
440 | return counter ? &counter->parent : NULL; | |
441 | } | |
442 | ||
443 | static | |
444 | void destroy_result(void *ptr) | |
445 | { | |
446 | struct lttng_error_query_result *result = (typeof(result)) ptr; | |
447 | ||
448 | lttng_error_query_result_destroy(result); | |
449 | } | |
450 | ||
451 | LTTNG_HIDDEN | |
452 | struct lttng_error_query_results *lttng_error_query_results_create(void) | |
453 | { | |
454 | struct lttng_error_query_results *set = zmalloc(sizeof(*set)); | |
455 | ||
456 | if (!set) { | |
457 | PERROR("Failed to allocate an error query result set"); | |
458 | goto end; | |
459 | } | |
460 | ||
461 | lttng_dynamic_pointer_array_init(&set->results, destroy_result); | |
462 | end: | |
463 | return set; | |
464 | } | |
465 | ||
466 | LTTNG_HIDDEN | |
467 | int lttng_error_query_results_add_result( | |
468 | struct lttng_error_query_results *results, | |
469 | struct lttng_error_query_result *result) | |
470 | { | |
471 | return lttng_dynamic_pointer_array_add_pointer( | |
472 | &results->results, result); | |
473 | } | |
474 | ||
475 | LTTNG_HIDDEN | |
476 | ssize_t lttng_error_query_result_create_from_payload( | |
477 | struct lttng_payload_view *view, | |
478 | struct lttng_error_query_result **result) | |
479 | { | |
480 | ssize_t used_size = 0; | |
481 | struct lttng_error_query_result_comm *header; | |
482 | struct lttng_payload_view header_view = | |
483 | lttng_payload_view_from_view(view, 0, sizeof(*header)); | |
484 | const char *name; | |
485 | const char *description; | |
486 | ||
487 | if (!lttng_payload_view_is_valid(&header_view)) { | |
488 | used_size = -1; | |
489 | goto end; | |
490 | } | |
491 | ||
492 | header = (typeof(header)) header_view.buffer.data; | |
493 | used_size += sizeof(*header); | |
494 | ||
495 | { | |
496 | struct lttng_payload_view name_view = | |
497 | lttng_payload_view_from_view(view, used_size, | |
498 | header->name_len); | |
499 | ||
500 | if (!lttng_payload_view_is_valid(&name_view) || | |
501 | !lttng_buffer_view_contains_string( | |
502 | &name_view.buffer, | |
503 | name_view.buffer.data, | |
504 | header->name_len)) { | |
505 | used_size = -1; | |
506 | goto end; | |
507 | } | |
508 | ||
509 | name = name_view.buffer.data; | |
510 | used_size += header->name_len; | |
511 | } | |
512 | ||
513 | { | |
514 | struct lttng_payload_view description_view = | |
515 | lttng_payload_view_from_view(view, used_size, | |
516 | header->description_len); | |
517 | ||
518 | if (!lttng_payload_view_is_valid(&description_view) || | |
519 | !lttng_buffer_view_contains_string( | |
520 | &description_view.buffer, | |
521 | description_view.buffer.data, | |
522 | header->description_len)) { | |
523 | used_size = -1; | |
524 | goto end; | |
525 | } | |
526 | ||
527 | description = description_view.buffer.data; | |
528 | used_size += header->description_len; | |
529 | } | |
530 | ||
531 | switch (header->type) { | |
532 | case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER: | |
533 | { | |
534 | struct lttng_error_query_result_counter_comm *counter; | |
535 | struct lttng_payload_view counter_payload_view = | |
536 | lttng_payload_view_from_view(view, used_size, | |
537 | sizeof(*counter)); | |
538 | ||
539 | if (!lttng_payload_view_is_valid(&counter_payload_view)) { | |
540 | used_size = -1; | |
541 | goto end; | |
542 | } | |
543 | ||
544 | counter = (typeof(counter)) counter_payload_view.buffer.data; | |
545 | *result = lttng_error_query_result_counter_create( | |
546 | name, description, counter->value); | |
547 | if (!*result) { | |
548 | used_size = -1; | |
549 | goto end; | |
550 | } | |
551 | ||
552 | used_size += sizeof(*counter); | |
553 | break; | |
554 | } | |
555 | default: | |
556 | used_size = -1; | |
557 | goto end; | |
558 | } | |
559 | ||
560 | end: | |
561 | return used_size; | |
562 | } | |
563 | ||
564 | LTTNG_HIDDEN | |
565 | int lttng_error_query_results_serialize( | |
566 | const struct lttng_error_query_results *results, | |
567 | struct lttng_payload *payload) | |
568 | { | |
569 | int ret; | |
570 | size_t result_index; | |
571 | const size_t result_count = lttng_dynamic_pointer_array_get_count( | |
572 | &results->results); | |
573 | const struct lttng_error_query_results_comm header = { | |
574 | .count = (typeof(header.count)) result_count, | |
575 | }; | |
576 | ||
577 | /* Header. */ | |
578 | ret = lttng_dynamic_buffer_append(&payload->buffer, &header, sizeof(header)); | |
579 | if (ret) { | |
580 | ERR("Failed to append error query result set header to payload"); | |
581 | goto end; | |
582 | } | |
583 | ||
584 | /* Results. */ | |
585 | for (result_index = 0; result_index < result_count; result_index++) { | |
586 | const struct lttng_error_query_result *result = (typeof(result)) | |
587 | lttng_dynamic_pointer_array_get_pointer( | |
588 | &results->results, | |
589 | result_index); | |
590 | ||
591 | ret = lttng_error_query_result_serialize(result, payload); | |
592 | if (ret) { | |
593 | ERR("Failed to append error query result to payload"); | |
594 | goto end; | |
595 | } | |
596 | } | |
597 | end: | |
598 | return ret; | |
599 | } | |
600 | ||
601 | LTTNG_HIDDEN | |
602 | ssize_t lttng_error_query_results_create_from_payload( | |
603 | struct lttng_payload_view *view, | |
604 | struct lttng_error_query_results **_results) | |
605 | { | |
606 | size_t result_index; | |
607 | ssize_t total_used_size = 0; | |
608 | struct lttng_error_query_results_comm *header; | |
609 | struct lttng_payload_view header_view = | |
610 | lttng_payload_view_from_view(view, 0, sizeof(*header)); | |
611 | struct lttng_error_query_results *results = NULL; | |
612 | ||
613 | if (!lttng_payload_view_is_valid(&header_view)) { | |
614 | ERR("Failed to map view to error query result set header"); | |
615 | total_used_size = -1; | |
616 | goto end; | |
617 | } | |
618 | ||
619 | header = (typeof(header)) header_view.buffer.data; | |
620 | total_used_size += sizeof(*header); | |
621 | results = lttng_error_query_results_create(); | |
622 | if (!results) { | |
623 | total_used_size = -1; | |
624 | goto end; | |
625 | } | |
626 | ||
627 | for (result_index = 0; result_index < header->count; result_index++) { | |
628 | ssize_t used_size; | |
629 | struct lttng_error_query_result *result; | |
630 | struct lttng_payload_view result_view = | |
631 | lttng_payload_view_from_view( | |
632 | view, total_used_size, -1); | |
633 | ||
634 | if (!lttng_payload_view_is_valid(&result_view)) { | |
635 | total_used_size = -1; | |
636 | goto end; | |
637 | } | |
638 | ||
639 | used_size = lttng_error_query_result_create_from_payload( | |
640 | &result_view, &result); | |
641 | if (used_size < 0) { | |
642 | total_used_size = -1; | |
643 | goto end; | |
644 | } | |
645 | ||
646 | total_used_size += used_size; | |
647 | ||
648 | if (lttng_dynamic_pointer_array_add_pointer( | |
649 | &results->results, result)) { | |
650 | lttng_error_query_result_destroy(result); | |
651 | total_used_size = -1; | |
652 | goto end; | |
653 | } | |
654 | } | |
655 | ||
656 | *_results = results; | |
657 | results = NULL; | |
658 | end: | |
659 | lttng_error_query_results_destroy(results); | |
660 | return total_used_size; | |
661 | } | |
662 | ||
663 | static | |
664 | int lttng_error_query_trigger_serialize(const struct lttng_error_query *query, | |
665 | struct lttng_payload *payload) | |
666 | { | |
667 | int ret; | |
668 | const struct lttng_error_query_trigger *query_trigger = | |
669 | container_of(query, typeof(*query_trigger), parent); | |
670 | ||
671 | if (!lttng_trigger_validate(query_trigger->trigger)) { | |
672 | ret = -1; | |
673 | goto end; | |
674 | } | |
675 | ||
676 | ret = lttng_trigger_serialize(query_trigger->trigger, payload); | |
677 | if (ret) { | |
678 | goto end; | |
679 | } | |
680 | ||
681 | end: | |
682 | return ret; | |
683 | } | |
684 | ||
8ce7c93a JG |
685 | static |
686 | int lttng_error_query_condition_serialize(const struct lttng_error_query *query, | |
687 | struct lttng_payload *payload) | |
688 | { | |
689 | int ret; | |
690 | const struct lttng_error_query_condition *query_trigger = | |
691 | container_of(query, typeof(*query_trigger), parent); | |
692 | ||
693 | if (!lttng_trigger_validate(query_trigger->trigger)) { | |
694 | ret = -1; | |
695 | goto end; | |
696 | } | |
697 | ||
698 | ret = lttng_trigger_serialize(query_trigger->trigger, payload); | |
699 | if (ret) { | |
700 | goto end; | |
701 | } | |
702 | ||
703 | end: | |
704 | return ret; | |
705 | } | |
706 | ||
b99a0cb3 JG |
707 | static |
708 | int lttng_error_query_action_serialize(const struct lttng_error_query *query, | |
709 | struct lttng_payload *payload) | |
710 | { | |
711 | int ret; | |
712 | const struct lttng_error_query_action *query_action = | |
713 | container_of(query, typeof(*query_action), parent); | |
b99a0cb3 JG |
714 | |
715 | if (!lttng_trigger_validate(query_action->trigger)) { | |
716 | ret = -1; | |
717 | goto end; | |
718 | } | |
719 | ||
2658b8b5 | 720 | ret = lttng_trigger_serialize(query_action->trigger, payload); |
b99a0cb3 JG |
721 | if (ret) { |
722 | goto end; | |
723 | } | |
724 | ||
ab8fc98e | 725 | ret = lttng_action_path_serialize(query_action->action_path, payload); |
b99a0cb3 JG |
726 | if (ret) { |
727 | goto end; | |
728 | } | |
2658b8b5 | 729 | |
b99a0cb3 JG |
730 | end: |
731 | return ret; | |
732 | } | |
733 | ||
734 | LTTNG_HIDDEN | |
735 | enum lttng_error_query_target_type lttng_error_query_get_target_type( | |
736 | const struct lttng_error_query *query) | |
737 | { | |
738 | return query->target_type; | |
739 | } | |
740 | ||
741 | LTTNG_HIDDEN | |
742 | const struct lttng_trigger *lttng_error_query_trigger_borrow_target( | |
743 | const struct lttng_error_query *query) | |
744 | { | |
745 | const struct lttng_error_query_trigger *query_trigger = | |
746 | container_of(query, typeof(*query_trigger), parent); | |
747 | ||
748 | return query_trigger->trigger; | |
749 | } | |
750 | ||
8ce7c93a JG |
751 | LTTNG_HIDDEN |
752 | const struct lttng_trigger *lttng_error_query_condition_borrow_target( | |
753 | const struct lttng_error_query *query) | |
754 | { | |
755 | const struct lttng_error_query_condition *query_trigger = | |
756 | container_of(query, typeof(*query_trigger), parent); | |
757 | ||
758 | return query_trigger->trigger; | |
759 | } | |
760 | ||
b99a0cb3 JG |
761 | LTTNG_HIDDEN |
762 | const struct lttng_trigger *lttng_error_query_action_borrow_trigger_target( | |
763 | const struct lttng_error_query *query) | |
764 | { | |
765 | const struct lttng_error_query_action *query_action = | |
766 | container_of(query, typeof(*query_action), parent); | |
767 | ||
768 | return query_action->trigger; | |
769 | } | |
770 | ||
771 | LTTNG_HIDDEN | |
588c4b0d | 772 | struct lttng_action *lttng_error_query_action_borrow_action_target( |
b99a0cb3 | 773 | const struct lttng_error_query *query, |
588c4b0d | 774 | struct lttng_trigger *trigger) |
b99a0cb3 | 775 | { |
b99a0cb3 JG |
776 | const struct lttng_error_query_action *query_action = |
777 | container_of(query, typeof(*query_action), parent); | |
b99a0cb3 | 778 | |
2658b8b5 | 779 | return get_trigger_action_from_path( |
ab8fc98e | 780 | trigger, query_action->action_path); |
b99a0cb3 JG |
781 | } |
782 | ||
783 | LTTNG_HIDDEN | |
784 | int lttng_error_query_serialize(const struct lttng_error_query *query, | |
785 | struct lttng_payload *payload) | |
786 | { | |
787 | int ret; | |
e9867253 | 788 | const struct lttng_error_query_comm header = { |
b99a0cb3 JG |
789 | .target_type = (typeof(header.target_type)) query->target_type, |
790 | }; | |
791 | ||
792 | ret = lttng_dynamic_buffer_append( | |
793 | &payload->buffer, &header, sizeof(header)); | |
794 | if (ret) { | |
795 | ERR("Failed to append error query header to payload"); | |
796 | goto end; | |
797 | } | |
798 | ||
799 | switch (query->target_type) { | |
800 | case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER: | |
801 | ret = lttng_error_query_trigger_serialize(query, payload); | |
802 | if (ret) { | |
803 | goto end; | |
804 | } | |
805 | ||
8ce7c93a JG |
806 | break; |
807 | case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION: | |
808 | ret = lttng_error_query_condition_serialize(query, payload); | |
809 | if (ret) { | |
810 | goto end; | |
811 | } | |
812 | ||
b99a0cb3 JG |
813 | break; |
814 | case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION: | |
815 | ret = lttng_error_query_action_serialize(query, payload); | |
816 | if (ret) { | |
817 | goto end; | |
818 | } | |
819 | ||
820 | break; | |
821 | default: | |
822 | abort(); | |
823 | } | |
824 | end: | |
825 | return ret; | |
826 | } | |
827 | ||
828 | LTTNG_HIDDEN | |
829 | ssize_t lttng_error_query_create_from_payload(struct lttng_payload_view *view, | |
830 | struct lttng_error_query **query) | |
831 | { | |
832 | ssize_t used_size = 0; | |
833 | struct lttng_error_query_comm *header; | |
9de6375f | 834 | struct lttng_trigger *trigger = NULL; |
b99a0cb3 JG |
835 | struct lttng_payload_view header_view = |
836 | lttng_payload_view_from_view(view, 0, sizeof(*header)); | |
837 | ||
838 | if (!lttng_payload_view_is_valid(&header_view)) { | |
839 | ERR("Failed to map error query header"); | |
840 | used_size = -1; | |
841 | goto end; | |
842 | } | |
843 | ||
844 | used_size = sizeof(*header); | |
845 | ||
846 | header = (typeof(header)) header_view.buffer.data; | |
847 | switch ((enum lttng_error_query_target_type) header->target_type) { | |
848 | case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER: | |
849 | { | |
b99a0cb3 JG |
850 | ssize_t trigger_used_size; |
851 | struct lttng_payload_view trigger_view = | |
852 | lttng_payload_view_from_view( | |
853 | view, used_size, -1); | |
854 | ||
855 | if (!lttng_payload_view_is_valid(&trigger_view)) { | |
856 | used_size = -1; | |
857 | goto end; | |
858 | } | |
859 | ||
860 | trigger_used_size = lttng_trigger_create_from_payload( | |
861 | &trigger_view, &trigger); | |
862 | if (trigger_used_size < 0) { | |
863 | used_size = -1; | |
864 | goto end; | |
865 | } | |
866 | ||
867 | used_size += trigger_used_size; | |
868 | ||
869 | *query = lttng_error_query_trigger_create(trigger); | |
b99a0cb3 JG |
870 | if (!*query) { |
871 | used_size = -1; | |
872 | goto end; | |
873 | } | |
874 | ||
875 | break; | |
876 | } | |
8ce7c93a JG |
877 | case LTTNG_ERROR_QUERY_TARGET_TYPE_CONDITION: |
878 | { | |
879 | ssize_t trigger_used_size; | |
880 | struct lttng_payload_view trigger_view = | |
881 | lttng_payload_view_from_view( | |
882 | view, used_size, -1); | |
883 | ||
884 | if (!lttng_payload_view_is_valid(&trigger_view)) { | |
885 | used_size = -1; | |
886 | goto end; | |
887 | } | |
888 | ||
889 | trigger_used_size = lttng_trigger_create_from_payload( | |
890 | &trigger_view, &trigger); | |
891 | if (trigger_used_size < 0) { | |
892 | used_size = -1; | |
893 | goto end; | |
894 | } | |
895 | ||
896 | used_size += trigger_used_size; | |
897 | ||
898 | *query = lttng_error_query_condition_create(trigger); | |
899 | if (!*query) { | |
900 | used_size = -1; | |
901 | goto end; | |
902 | } | |
903 | ||
904 | break; | |
905 | } | |
b99a0cb3 JG |
906 | case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION: |
907 | { | |
2658b8b5 | 908 | struct lttng_action_path *action_path = NULL; |
b99a0cb3 JG |
909 | |
910 | { | |
2658b8b5 | 911 | ssize_t trigger_used_size; |
b99a0cb3 JG |
912 | struct lttng_payload_view trigger_view = |
913 | lttng_payload_view_from_view( | |
914 | view, used_size, -1); | |
915 | ||
916 | if (!lttng_payload_view_is_valid(&trigger_view)) { | |
917 | used_size = -1; | |
918 | goto end; | |
919 | } | |
920 | ||
921 | trigger_used_size = lttng_trigger_create_from_payload( | |
922 | &trigger_view, &trigger); | |
923 | if (trigger_used_size < 0) { | |
924 | used_size = -1; | |
925 | goto end; | |
926 | } | |
927 | ||
928 | used_size += trigger_used_size; | |
929 | } | |
930 | ||
2658b8b5 JG |
931 | { |
932 | ssize_t action_path_used_size; | |
933 | struct lttng_payload_view action_path_view = | |
934 | lttng_payload_view_from_view( | |
935 | view, used_size, -1); | |
936 | ||
937 | if (!lttng_payload_view_is_valid(&action_path_view)) { | |
938 | used_size = -1; | |
939 | goto end; | |
940 | } | |
941 | ||
942 | action_path_used_size = lttng_action_path_create_from_payload( | |
943 | &action_path_view, &action_path); | |
944 | if (action_path_used_size < 0) { | |
b99a0cb3 JG |
945 | used_size = -1; |
946 | goto end; | |
947 | } | |
948 | ||
2658b8b5 | 949 | used_size += action_path_used_size; |
b99a0cb3 JG |
950 | } |
951 | ||
952 | *query = lttng_error_query_action_create( | |
2658b8b5 JG |
953 | trigger, action_path); |
954 | lttng_action_path_destroy(action_path); | |
b99a0cb3 JG |
955 | if (!*query) { |
956 | used_size = -1; | |
957 | goto end; | |
958 | } | |
959 | ||
960 | break; | |
961 | } | |
962 | default: | |
963 | used_size = -1; | |
964 | goto end; | |
965 | } | |
966 | ||
967 | end: | |
9de6375f | 968 | lttng_trigger_put(trigger); |
b99a0cb3 JG |
969 | return used_size; |
970 | } | |
971 | ||
972 | enum lttng_error_query_results_status lttng_error_query_results_get_count( | |
973 | const struct lttng_error_query_results *results, | |
974 | unsigned int *count) | |
975 | { | |
976 | enum lttng_error_query_results_status status; | |
977 | ||
978 | if (!results || !count) { | |
979 | status = LTTNG_ERROR_QUERY_RESULTS_STATUS_INVALID_PARAMETER; | |
980 | goto end; | |
981 | } | |
982 | ||
983 | *count = lttng_dynamic_pointer_array_get_count(&results->results); | |
984 | status = LTTNG_ERROR_QUERY_RESULTS_STATUS_OK; | |
985 | end: | |
986 | return status; | |
987 | } | |
988 | ||
989 | enum lttng_error_query_results_status | |
990 | lttng_error_query_results_get_result( | |
991 | const struct lttng_error_query_results *results, | |
992 | const struct lttng_error_query_result **result, | |
993 | unsigned int index) | |
994 | { | |
995 | unsigned int result_count; | |
996 | enum lttng_error_query_results_status status; | |
997 | ||
998 | if (!results || !result) { | |
999 | status = LTTNG_ERROR_QUERY_RESULTS_STATUS_INVALID_PARAMETER; | |
1000 | goto end; | |
1001 | } | |
1002 | ||
1003 | status = lttng_error_query_results_get_count(results, &result_count); | |
1004 | if (status != LTTNG_ERROR_QUERY_RESULTS_STATUS_OK) { | |
1005 | goto end; | |
1006 | } | |
1007 | ||
1008 | if (index >= result_count) { | |
1009 | status = LTTNG_ERROR_QUERY_RESULTS_STATUS_INVALID_PARAMETER; | |
1010 | goto end; | |
1011 | } | |
1012 | ||
1013 | *result = (typeof(*result)) lttng_dynamic_pointer_array_get_pointer( | |
1014 | &results->results, index); | |
1015 | assert(*result); | |
1016 | status = LTTNG_ERROR_QUERY_RESULTS_STATUS_OK; | |
1017 | end: | |
1018 | return status; | |
1019 | } | |
1020 | ||
1021 | void lttng_error_query_results_destroy( | |
1022 | struct lttng_error_query_results *results) | |
1023 | { | |
1024 | if (!results) { | |
1025 | return; | |
1026 | } | |
1027 | ||
1028 | lttng_dynamic_pointer_array_reset(&results->results); | |
1029 | free(results); | |
1030 | } | |
1031 | ||
1032 | enum lttng_error_query_result_type | |
1033 | lttng_error_query_result_get_type(const struct lttng_error_query_result *result) | |
1034 | { | |
1035 | return result ? result->type : LTTNG_ERROR_QUERY_RESULT_TYPE_UNKNOWN; | |
1036 | } | |
1037 | ||
1038 | enum lttng_error_query_result_status lttng_error_query_result_get_name( | |
1039 | const struct lttng_error_query_result *result, | |
1040 | const char **name) | |
1041 | { | |
1042 | enum lttng_error_query_result_status status; | |
1043 | ||
1044 | if (!result || !name) { | |
1045 | status = LTTNG_ERROR_QUERY_RESULT_STATUS_INVALID_PARAMETER; | |
1046 | goto end; | |
1047 | } | |
1048 | ||
1049 | *name = result->name; | |
1050 | status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK; | |
1051 | end: | |
1052 | return status; | |
1053 | } | |
1054 | ||
1055 | enum lttng_error_query_result_status lttng_error_query_result_get_description( | |
1056 | const struct lttng_error_query_result *result, | |
1057 | const char **description) | |
1058 | { | |
1059 | enum lttng_error_query_result_status status; | |
1060 | ||
1061 | if (!result || !description) { | |
1062 | status = LTTNG_ERROR_QUERY_RESULT_STATUS_INVALID_PARAMETER; | |
1063 | goto end; | |
1064 | } | |
1065 | ||
1066 | *description = result->description; | |
1067 | status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK; | |
1068 | end: | |
1069 | return status; | |
1070 | } | |
1071 | ||
1072 | enum lttng_error_query_result_status lttng_error_query_result_counter_get_value( | |
1073 | const struct lttng_error_query_result *result, | |
1074 | uint64_t *value) | |
1075 | { | |
1076 | enum lttng_error_query_result_status status; | |
1077 | const struct lttng_error_query_result_counter *counter_result; | |
1078 | ||
1079 | if (!result || !value || | |
1080 | result->type != LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) { | |
1081 | status = LTTNG_ERROR_QUERY_RESULT_STATUS_INVALID_PARAMETER; | |
1082 | goto end; | |
1083 | } | |
1084 | ||
1085 | counter_result = container_of(result, typeof(*counter_result), parent); | |
1086 | ||
1087 | *value = counter_result->value; | |
1088 | status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK; | |
1089 | end: | |
1090 | return status; | |
1091 | } | |
0f7c2963 JR |
1092 | |
1093 | static | |
1094 | enum lttng_error_code lttng_error_query_result_counter_mi_serialize( | |
1095 | const struct lttng_error_query_result *result, | |
1096 | struct mi_writer *writer) | |
1097 | { | |
1098 | int ret; | |
1099 | enum lttng_error_code ret_code; | |
1100 | enum lttng_error_query_result_status status; | |
1101 | uint64_t value; | |
1102 | ||
1103 | assert(result); | |
1104 | assert(writer); | |
1105 | ||
1106 | status = lttng_error_query_result_counter_get_value(result, &value); | |
1107 | assert(status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK); | |
1108 | ||
1109 | /* Open error query result counter element. */ | |
1110 | ret = mi_lttng_writer_open_element( | |
1111 | writer, mi_lttng_element_error_query_result_counter); | |
1112 | if (ret) { | |
1113 | goto mi_error; | |
1114 | } | |
1115 | ||
1116 | /* Value. */ | |
1117 | ret = mi_lttng_writer_write_element_unsigned_int(writer, | |
1118 | mi_lttng_element_error_query_result_counter_value, | |
1119 | value); | |
1120 | if (ret) { | |
1121 | goto mi_error; | |
1122 | } | |
1123 | ||
1124 | /* Close error query result counter element. */ | |
1125 | ret = mi_lttng_writer_close_element(writer); | |
1126 | if (ret) { | |
1127 | goto mi_error; | |
1128 | } | |
1129 | ||
1130 | ret_code = LTTNG_OK; | |
1131 | goto end; | |
1132 | ||
1133 | mi_error: | |
1134 | ret_code = LTTNG_ERR_MI_IO_FAIL; | |
1135 | end: | |
1136 | return ret_code; | |
1137 | } | |
1138 | ||
1139 | static | |
1140 | enum lttng_error_code lttng_error_query_result_mi_serialize( | |
1141 | const struct lttng_error_query_result *result, | |
1142 | struct mi_writer *writer) | |
1143 | { | |
1144 | int ret; | |
1145 | enum lttng_error_code ret_code; | |
1146 | enum lttng_error_query_result_status result_status; | |
1147 | enum lttng_error_query_result_type type; | |
1148 | const char *name = NULL; | |
1149 | const char *description = NULL; | |
1150 | ||
1151 | assert(result); | |
1152 | assert(writer); | |
1153 | ||
1154 | type = lttng_error_query_result_get_type(result); | |
1155 | ||
1156 | result_status = lttng_error_query_result_get_name(result, &name); | |
1157 | assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK); | |
1158 | ||
1159 | result_status = lttng_error_query_result_get_description( | |
1160 | result, &description); | |
1161 | assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK); | |
1162 | ||
1163 | /* Open error query result element. */ | |
1164 | ret = mi_lttng_writer_open_element( | |
1165 | writer, mi_lttng_element_error_query_result); | |
1166 | if (ret) { | |
1167 | goto mi_error; | |
1168 | } | |
1169 | ||
1170 | /* Name. */ | |
1171 | ret = mi_lttng_writer_write_element_string( | |
1172 | writer, mi_lttng_element_error_query_result_name, name); | |
1173 | if (ret) { | |
1174 | goto mi_error; | |
1175 | } | |
1176 | ||
1177 | /* Description. */ | |
1178 | ret = mi_lttng_writer_write_element_string(writer, | |
1179 | mi_lttng_element_error_query_result_description, | |
1180 | description); | |
1181 | if (ret) { | |
1182 | goto mi_error; | |
1183 | } | |
1184 | ||
1185 | /* Serialize the result according to its sub type. */ | |
1186 | switch (type) { | |
1187 | case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER: | |
1188 | ret_code = lttng_error_query_result_counter_mi_serialize( | |
1189 | result, writer); | |
1190 | break; | |
1191 | default: | |
1192 | abort(); | |
1193 | } | |
1194 | ||
1195 | if (ret_code != LTTNG_OK) { | |
1196 | goto end; | |
1197 | } | |
1198 | ||
1199 | /* Close error query result element. */ | |
1200 | ret = mi_lttng_writer_close_element(writer); | |
1201 | if (ret) { | |
1202 | goto mi_error; | |
1203 | } | |
1204 | ||
1205 | ret_code = LTTNG_OK; | |
1206 | goto end; | |
1207 | ||
1208 | mi_error: | |
1209 | ret_code = LTTNG_ERR_MI_IO_FAIL; | |
1210 | end: | |
1211 | return ret_code; | |
1212 | } | |
1213 | ||
1214 | LTTNG_HIDDEN | |
1215 | enum lttng_error_code lttng_error_query_results_mi_serialize( | |
1216 | const struct lttng_error_query_results *results, | |
1217 | struct mi_writer *writer) | |
1218 | { | |
1219 | int ret; | |
1220 | enum lttng_error_code ret_code; | |
1221 | unsigned int i, count; | |
1222 | enum lttng_error_query_results_status results_status; | |
1223 | ||
1224 | assert(results); | |
1225 | assert(writer); | |
1226 | ||
1227 | /* Open error query results element. */ | |
1228 | ret = mi_lttng_writer_open_element( | |
1229 | writer, mi_lttng_element_error_query_results); | |
1230 | if (ret) { | |
1231 | goto mi_error; | |
1232 | } | |
1233 | ||
1234 | results_status = lttng_error_query_results_get_count(results, &count); | |
1235 | assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK); | |
1236 | ||
1237 | for (i = 0; i < count; i++) { | |
1238 | const struct lttng_error_query_result *result; | |
1239 | ||
1240 | results_status = lttng_error_query_results_get_result( | |
1241 | results, &result, i); | |
1242 | assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK); | |
1243 | ||
1244 | /* A single error query result. */ | |
1245 | ret_code = lttng_error_query_result_mi_serialize(result, writer); | |
1246 | if (ret_code != LTTNG_OK) { | |
1247 | goto end; | |
1248 | } | |
1249 | } | |
1250 | ||
1251 | /* Close error query results. */ | |
1252 | ret = mi_lttng_writer_close_element(writer); | |
1253 | if (ret) { | |
1254 | goto mi_error; | |
1255 | } | |
1256 | ||
1257 | ret_code = LTTNG_OK; | |
1258 | goto end; | |
1259 | ||
1260 | mi_error: | |
1261 | ret_code = LTTNG_ERR_MI_IO_FAIL; | |
1262 | end: | |
1263 | return ret_code; | |
1264 | } |