lttng-ctl: Add error query interface
[lttng-tools.git] / src / common / error-query.c
CommitLineData
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>
13#include <common/sessiond-comm/sessiond-comm.h>
14#include <lttng/action/action-internal.h>
15#include <lttng/action/group-internal.h>
16#include <lttng/error-query-internal.h>
17#include <lttng/error-query.h>
18#include <lttng/trigger/trigger-internal.h>
19#include <stddef.h>
20
21struct lttng_error_query {
22 enum lttng_error_query_target_type target_type;
23};
24
25struct lttng_error_query_comm {
26 /* enum lttng_error_query_target_type */
27 int8_t target_type;
28 /* Target-specific payload. */
29 char payload[];
30};
31
32struct lttng_error_query_trigger {
33 struct lttng_error_query parent;
34 /* Mutable only because of the reference count. */
35 struct lttng_trigger *trigger;
36};
37
38struct lttng_error_query_action_comm {
39 LTTNG_OPTIONAL_COMM(uint32_t) action_index;
40 /* Trigger payload. */
41 char payload[];
42};
43
44struct lttng_error_query_action {
45 struct lttng_error_query parent;
46 /* Mutable only because of the reference count. */
47 struct lttng_trigger *trigger;
48 /*
49 * Index of the target action. Since action lists can't be nested,
50 * the targetted action is the top-level group if the action_index is
51 * unset. Otherwise, the index refers to the index within the top-level
52 * group.
53 */
54 LTTNG_OPTIONAL(unsigned int) action_index;
55};
56
57struct lttng_error_query_result {
58 enum lttng_error_query_result_type type;
59 char *name;
60 char *description;
61};
62
63struct lttng_error_query_result_comm {
64 /* enum lttng_error_query_result_type */
65 uint8_t type;
66 /* Length of name (including null-terminator). */
67 uint32_t name_len;
68 /* Length of description (including null-terminator). */
69 uint32_t description_len;
70 /* Name, description, and type-specific payload follow. */
71 char payload[];
72} LTTNG_PACKED;
73
74struct lttng_error_query_result_counter_comm {
75 uint64_t value;
76} LTTNG_PACKED;
77
78struct lttng_error_query_result_counter {
79 struct lttng_error_query_result parent;
80 uint64_t value;
81};
82
83struct lttng_error_query_results_comm {
84 uint32_t count;
85 /* `count` instances of `struct lttng_error_query_result` follow. */
86 char payload[];
87} LTTNG_PACKED;
88
89struct lttng_error_query_results {
90 struct lttng_dynamic_pointer_array results;
91};
92
93
94struct lttng_error_query *lttng_error_query_trigger_create(
95 const struct lttng_trigger *trigger)
96{
97 struct lttng_error_query_trigger *query = NULL;
98 struct lttng_trigger *trigger_copy;
99
100 trigger_copy = lttng_trigger_copy(trigger);
101 if (!trigger_copy) {
102 goto end;
103 }
104
105 if (!trigger) {
106 goto end;
107 }
108
109 query = zmalloc(sizeof(*query));
110 if (!query) {
111 PERROR("Failed to allocate trigger error query");
112 goto end;
113 }
114
115 query->parent.target_type = LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER;
116 query->trigger = trigger_copy;
117end:
118 return query ? &query->parent : NULL;
119}
120
121extern struct lttng_error_query *lttng_error_query_action_create(
122 const struct lttng_trigger *trigger,
123 const struct lttng_action *action)
124{
125 struct lttng_error_query_action *query = NULL;
126 typeof(query->action_index) action_index;
127 struct lttng_trigger *trigger_copy;
128
129 if (!trigger || !action) {
130 goto end;
131 }
132
133 trigger_copy = lttng_trigger_copy(trigger);
134 if (!trigger_copy) {
135 goto end;
136 }
137
138 /*
139 * If an action is not the top-level action of the trigger, our only
140 * hope of finding its position is if the top-level action is an
141 * action list.
142 *
143 * Note that action comparisons are performed by pointer since multiple
144 * otherwise identical actions can be found in an action group (two
145 * notify actions, for example).
146 */
147 if (action != trigger->action &&
148 lttng_action_get_type(trigger->action) ==
149 LTTNG_ACTION_TYPE_GROUP) {
150 unsigned int i, action_group_count;
151 enum lttng_action_status action_status;
152
153 action_status = lttng_action_group_get_count(
154 trigger->action, &action_group_count);
155 if (action_status != LTTNG_ACTION_STATUS_OK) {
156 goto end;
157 }
158
159 for (i = 0; i < action_group_count; i++) {
160 const struct lttng_action *candidate_action =
161 lttng_action_group_get_at_index(
162 trigger->action, i);
163
164 assert(candidate_action);
165 if (candidate_action == action) {
166 LTTNG_OPTIONAL_SET(&action_index, i);
167 break;
168 }
169 }
170
171 if (!action_index.is_set) {
172 /* Not found; invalid action. */
173 goto end;
174 }
175 } else {
176 /*
177 * Trigger action is not a group and not equal to the target
178 * action; invalid action provided.
179 */
180 goto end;
181 }
182
183 query = zmalloc(sizeof(*query));
184 if (!query) {
185 PERROR("Failed to allocate action error query");
186 goto end;
187 }
188
189 query->parent.target_type = LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION;
190 query->trigger = trigger_copy;
191 query->action_index = action_index;
192end:
193 return query ? &query->parent : NULL;
194}
195
196void lttng_error_query_destroy(struct lttng_error_query *query)
197{
198 struct lttng_error_query_trigger *trigger_query;
199
200 if (!query) {
201 return;
202 }
203
204 trigger_query = container_of(query, typeof(*trigger_query), parent);
205 lttng_trigger_put(trigger_query->trigger);
206 free(trigger_query);
207}
208
209static
210int lttng_error_query_result_counter_serialize(
211 const struct lttng_error_query_result *result,
212 struct lttng_payload *payload)
213{
214 const struct lttng_error_query_result_counter *counter_result;
215
216 assert(result->type == LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER);
217 counter_result = container_of(result, typeof(*counter_result), parent);
218
219 return lttng_dynamic_buffer_append(&payload->buffer,
220 &(struct lttng_error_query_result_counter_comm) {
221 .value = counter_result->value
222 },
223 sizeof(struct lttng_error_query_result_counter_comm));
224}
225
226LTTNG_HIDDEN
227int lttng_error_query_result_serialize(
228 const struct lttng_error_query_result *result,
229 struct lttng_payload *payload)
230{
231 int ret;
232 struct lttng_error_query_result_comm header = {
233 .type = (uint8_t) result->type,
234 .name_len = (typeof(header.name_len)) strlen(result->name) + 1,
235 .description_len = (typeof(header.name_len)) strlen(result->description) + 1,
236 };
237
238 /* Header. */
239 ret = lttng_dynamic_buffer_append(
240 &payload->buffer, &header, sizeof(header));
241 if (ret) {
242 ERR("Failed to append error query result communication header to payload");
243 goto end;
244 }
245
246 /* Name. */
247 ret = lttng_dynamic_buffer_append(
248 &payload->buffer, result->name, header.name_len);
249 if (ret) {
250 ERR("Failed to append error query result name to payload");
251 goto end;
252 }
253
254 /* Description. */
255 ret = lttng_dynamic_buffer_append(&payload->buffer, result->description,
256 header.description_len);
257 if (ret) {
258 ERR("Failed to append error query result description to payload");
259 goto end;
260 }
261
262 /* Type-specific payload. */
263 switch (result->type) {
264 case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER:
265 ret = lttng_error_query_result_counter_serialize(
266 result, payload);
267 if (ret) {
268 ERR("Failed to serialize counter error query result");
269 goto end;
270 }
271 break;
272 default:
273 abort();
274 }
275
276end:
277 return ret;
278}
279
280static
281int lttng_error_query_result_init(
282 struct lttng_error_query_result *result,
283 enum lttng_error_query_result_type result_type,
284 const char *name,
285 const char *description)
286{
287 int ret;
288
289 assert(name);
290 assert(description);
291
292 result->type = result_type;
293
294 result->name = strdup(name);
295 if (!result->name) {
296 PERROR("Failed to copy error query result name");
297 ret = -1;
298 goto end;
299 }
300
301 result->description = strdup(description);
302 if (!result->description) {
303 PERROR("Failed to copy error query result description");
304 ret = -1;
305 goto end;
306 }
307
308 ret = 0;
309end:
310 return ret;
311}
312
313LTTNG_HIDDEN
314void lttng_error_query_result_destroy(struct lttng_error_query_result *counter)
315{
316 if (!counter) {
317 return;
318 }
319
320 switch (counter->type) {
321 case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER:
322 /* Nothing to tear down. */
323 break;
324 default:
325 abort();
326 }
327
328 free(counter->name);
329 free(counter->description);
330 free(counter);
331}
332
333LTTNG_HIDDEN
334struct lttng_error_query_result *
335lttng_error_query_result_counter_create(
336 const char *name, const char *description, uint64_t value)
337{
338 int init_ret;
339 struct lttng_error_query_result_counter *counter;
340
341 counter = zmalloc(sizeof(*counter));
342 if (!counter) {
343 PERROR("Failed to allocate error query counter result");
344 goto end;
345 }
346
347 init_ret = lttng_error_query_result_init(&counter->parent,
348 LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER, name,
349 description);
350 if (init_ret) {
351 goto error;
352 }
353
354 goto end;
355error:
356 lttng_error_query_result_destroy(&counter->parent);
357end:
358 return counter ? &counter->parent : NULL;
359}
360
361static
362void destroy_result(void *ptr)
363{
364 struct lttng_error_query_result *result = (typeof(result)) ptr;
365
366 lttng_error_query_result_destroy(result);
367}
368
369LTTNG_HIDDEN
370struct lttng_error_query_results *lttng_error_query_results_create(void)
371{
372 struct lttng_error_query_results *set = zmalloc(sizeof(*set));
373
374 if (!set) {
375 PERROR("Failed to allocate an error query result set");
376 goto end;
377 }
378
379 lttng_dynamic_pointer_array_init(&set->results, destroy_result);
380end:
381 return set;
382}
383
384LTTNG_HIDDEN
385int lttng_error_query_results_add_result(
386 struct lttng_error_query_results *results,
387 struct lttng_error_query_result *result)
388{
389 return lttng_dynamic_pointer_array_add_pointer(
390 &results->results, result);
391}
392
393LTTNG_HIDDEN
394ssize_t lttng_error_query_result_create_from_payload(
395 struct lttng_payload_view *view,
396 struct lttng_error_query_result **result)
397{
398 ssize_t used_size = 0;
399 struct lttng_error_query_result_comm *header;
400 struct lttng_payload_view header_view =
401 lttng_payload_view_from_view(view, 0, sizeof(*header));
402 const char *name;
403 const char *description;
404
405 if (!lttng_payload_view_is_valid(&header_view)) {
406 used_size = -1;
407 goto end;
408 }
409
410 header = (typeof(header)) header_view.buffer.data;
411 used_size += sizeof(*header);
412
413 {
414 struct lttng_payload_view name_view =
415 lttng_payload_view_from_view(view, used_size,
416 header->name_len);
417
418 if (!lttng_payload_view_is_valid(&name_view) ||
419 !lttng_buffer_view_contains_string(
420 &name_view.buffer,
421 name_view.buffer.data,
422 header->name_len)) {
423 used_size = -1;
424 goto end;
425 }
426
427 name = name_view.buffer.data;
428 used_size += header->name_len;
429 }
430
431 {
432 struct lttng_payload_view description_view =
433 lttng_payload_view_from_view(view, used_size,
434 header->description_len);
435
436 if (!lttng_payload_view_is_valid(&description_view) ||
437 !lttng_buffer_view_contains_string(
438 &description_view.buffer,
439 description_view.buffer.data,
440 header->description_len)) {
441 used_size = -1;
442 goto end;
443 }
444
445 description = description_view.buffer.data;
446 used_size += header->description_len;
447 }
448
449 switch (header->type) {
450 case LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER:
451 {
452 struct lttng_error_query_result_counter_comm *counter;
453 struct lttng_payload_view counter_payload_view =
454 lttng_payload_view_from_view(view, used_size,
455 sizeof(*counter));
456
457 if (!lttng_payload_view_is_valid(&counter_payload_view)) {
458 used_size = -1;
459 goto end;
460 }
461
462 counter = (typeof(counter)) counter_payload_view.buffer.data;
463 *result = lttng_error_query_result_counter_create(
464 name, description, counter->value);
465 if (!*result) {
466 used_size = -1;
467 goto end;
468 }
469
470 used_size += sizeof(*counter);
471 break;
472 }
473 default:
474 used_size = -1;
475 goto end;
476 }
477
478end:
479 return used_size;
480}
481
482LTTNG_HIDDEN
483int lttng_error_query_results_serialize(
484 const struct lttng_error_query_results *results,
485 struct lttng_payload *payload)
486{
487 int ret;
488 size_t result_index;
489 const size_t result_count = lttng_dynamic_pointer_array_get_count(
490 &results->results);
491 const struct lttng_error_query_results_comm header = {
492 .count = (typeof(header.count)) result_count,
493 };
494
495 /* Header. */
496 ret = lttng_dynamic_buffer_append(&payload->buffer, &header, sizeof(header));
497 if (ret) {
498 ERR("Failed to append error query result set header to payload");
499 goto end;
500 }
501
502 /* Results. */
503 for (result_index = 0; result_index < result_count; result_index++) {
504 const struct lttng_error_query_result *result = (typeof(result))
505 lttng_dynamic_pointer_array_get_pointer(
506 &results->results,
507 result_index);
508
509 ret = lttng_error_query_result_serialize(result, payload);
510 if (ret) {
511 ERR("Failed to append error query result to payload");
512 goto end;
513 }
514 }
515end:
516 return ret;
517}
518
519LTTNG_HIDDEN
520ssize_t lttng_error_query_results_create_from_payload(
521 struct lttng_payload_view *view,
522 struct lttng_error_query_results **_results)
523{
524 size_t result_index;
525 ssize_t total_used_size = 0;
526 struct lttng_error_query_results_comm *header;
527 struct lttng_payload_view header_view =
528 lttng_payload_view_from_view(view, 0, sizeof(*header));
529 struct lttng_error_query_results *results = NULL;
530
531 if (!lttng_payload_view_is_valid(&header_view)) {
532 ERR("Failed to map view to error query result set header");
533 total_used_size = -1;
534 goto end;
535 }
536
537 header = (typeof(header)) header_view.buffer.data;
538 total_used_size += sizeof(*header);
539 results = lttng_error_query_results_create();
540 if (!results) {
541 total_used_size = -1;
542 goto end;
543 }
544
545 for (result_index = 0; result_index < header->count; result_index++) {
546 ssize_t used_size;
547 struct lttng_error_query_result *result;
548 struct lttng_payload_view result_view =
549 lttng_payload_view_from_view(
550 view, total_used_size, -1);
551
552 if (!lttng_payload_view_is_valid(&result_view)) {
553 total_used_size = -1;
554 goto end;
555 }
556
557 used_size = lttng_error_query_result_create_from_payload(
558 &result_view, &result);
559 if (used_size < 0) {
560 total_used_size = -1;
561 goto end;
562 }
563
564 total_used_size += used_size;
565
566 if (lttng_dynamic_pointer_array_add_pointer(
567 &results->results, result)) {
568 lttng_error_query_result_destroy(result);
569 total_used_size = -1;
570 goto end;
571 }
572 }
573
574 *_results = results;
575 results = NULL;
576end:
577 lttng_error_query_results_destroy(results);
578 return total_used_size;
579}
580
581static
582int lttng_error_query_trigger_serialize(const struct lttng_error_query *query,
583 struct lttng_payload *payload)
584{
585 int ret;
586 const struct lttng_error_query_trigger *query_trigger =
587 container_of(query, typeof(*query_trigger), parent);
588
589 if (!lttng_trigger_validate(query_trigger->trigger)) {
590 ret = -1;
591 goto end;
592 }
593
594 ret = lttng_trigger_serialize(query_trigger->trigger, payload);
595 if (ret) {
596 goto end;
597 }
598
599end:
600 return ret;
601}
602
603static
604int lttng_error_query_action_serialize(const struct lttng_error_query *query,
605 struct lttng_payload *payload)
606{
607 int ret;
608 const struct lttng_error_query_action *query_action =
609 container_of(query, typeof(*query_action), parent);
610 struct lttng_error_query_action_comm header = {
611 .action_index.is_set = query_action->action_index.is_set,
612 .action_index.value = query_action->action_index.value,
613 };
614
615 if (!lttng_trigger_validate(query_action->trigger)) {
616 ret = -1;
617 goto end;
618 }
619
620 ret = lttng_dynamic_buffer_append(
621 &payload->buffer, &header, sizeof(header));
622 if (ret) {
623 goto end;
624 }
625
626 ret = lttng_trigger_serialize(query_action->trigger, payload);
627 if (ret) {
628 goto end;
629 }
630end:
631 return ret;
632}
633
634LTTNG_HIDDEN
635enum lttng_error_query_target_type lttng_error_query_get_target_type(
636 const struct lttng_error_query *query)
637{
638 return query->target_type;
639}
640
641LTTNG_HIDDEN
642const struct lttng_trigger *lttng_error_query_trigger_borrow_target(
643 const struct lttng_error_query *query)
644{
645 const struct lttng_error_query_trigger *query_trigger =
646 container_of(query, typeof(*query_trigger), parent);
647
648 return query_trigger->trigger;
649}
650
651LTTNG_HIDDEN
652const struct lttng_trigger *lttng_error_query_action_borrow_trigger_target(
653 const struct lttng_error_query *query)
654{
655 const struct lttng_error_query_action *query_action =
656 container_of(query, typeof(*query_action), parent);
657
658 return query_action->trigger;
659}
660
661LTTNG_HIDDEN
662const struct lttng_action *lttng_error_query_action_borrow_action_target(
663 const struct lttng_error_query *query,
664 const struct lttng_trigger *trigger)
665{
666 const struct lttng_action *target_action = NULL;
667 const struct lttng_error_query_action *query_action =
668 container_of(query, typeof(*query_action), parent);
669 const struct lttng_action *trigger_action =
670 lttng_trigger_get_const_action(trigger);
671
672 if (!query_action->action_index.is_set) {
673 target_action = trigger_action;
674 } else {
675 if (lttng_action_get_type(trigger_action) !=
676 LTTNG_ACTION_TYPE_GROUP) {
677 ERR("Invalid action error query target index: trigger action is not a group");
678 goto end;
679 }
680
681 target_action = lttng_action_group_get_at_index(trigger_action,
682 LTTNG_OPTIONAL_GET(query_action->action_index));
683 }
684
685end:
686 return target_action;
687}
688
689LTTNG_HIDDEN
690int lttng_error_query_serialize(const struct lttng_error_query *query,
691 struct lttng_payload *payload)
692{
693 int ret;
694 struct lttng_error_query_comm header = {
695 .target_type = (typeof(header.target_type)) query->target_type,
696 };
697
698 ret = lttng_dynamic_buffer_append(
699 &payload->buffer, &header, sizeof(header));
700 if (ret) {
701 ERR("Failed to append error query header to payload");
702 goto end;
703 }
704
705 switch (query->target_type) {
706 case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
707 ret = lttng_error_query_trigger_serialize(query, payload);
708 if (ret) {
709 goto end;
710 }
711
712 break;
713 case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
714 ret = lttng_error_query_action_serialize(query, payload);
715 if (ret) {
716 goto end;
717 }
718
719 break;
720 default:
721 abort();
722 }
723end:
724 return ret;
725}
726
727LTTNG_HIDDEN
728ssize_t lttng_error_query_create_from_payload(struct lttng_payload_view *view,
729 struct lttng_error_query **query)
730{
731 ssize_t used_size = 0;
732 struct lttng_error_query_comm *header;
733 struct lttng_payload_view header_view =
734 lttng_payload_view_from_view(view, 0, sizeof(*header));
735
736 if (!lttng_payload_view_is_valid(&header_view)) {
737 ERR("Failed to map error query header");
738 used_size = -1;
739 goto end;
740 }
741
742 used_size = sizeof(*header);
743
744 header = (typeof(header)) header_view.buffer.data;
745 switch ((enum lttng_error_query_target_type) header->target_type) {
746 case LTTNG_ERROR_QUERY_TARGET_TYPE_TRIGGER:
747 {
748 struct lttng_trigger *trigger;
749 ssize_t trigger_used_size;
750 struct lttng_payload_view trigger_view =
751 lttng_payload_view_from_view(
752 view, used_size, -1);
753
754 if (!lttng_payload_view_is_valid(&trigger_view)) {
755 used_size = -1;
756 goto end;
757 }
758
759 trigger_used_size = lttng_trigger_create_from_payload(
760 &trigger_view, &trigger);
761 if (trigger_used_size < 0) {
762 used_size = -1;
763 goto end;
764 }
765
766 used_size += trigger_used_size;
767
768 *query = lttng_error_query_trigger_create(trigger);
769 lttng_trigger_put(trigger);
770 if (!*query) {
771 used_size = -1;
772 goto end;
773 }
774
775 break;
776 }
777 case LTTNG_ERROR_QUERY_TARGET_TYPE_ACTION:
778 {
779 struct lttng_trigger *trigger;
780 const struct lttng_action *target_action;
781 ssize_t trigger_used_size;
782 struct lttng_error_query_action_comm *action_header;
783
784 {
785 struct lttng_payload_view action_header_view =
786 lttng_payload_view_from_view(view,
787 used_size,
788 sizeof(*action_header));
789
790 if (!lttng_payload_view_is_valid(&action_header_view)) {
791 used_size = -1;
792 goto end;
793 }
794
795 action_header = (typeof(action_header)) action_header_view.buffer.data;
796 used_size += sizeof(*action_header);
797 }
798
799 {
800 struct lttng_payload_view trigger_view =
801 lttng_payload_view_from_view(
802 view, used_size, -1);
803
804 if (!lttng_payload_view_is_valid(&trigger_view)) {
805 used_size = -1;
806 goto end;
807 }
808
809 trigger_used_size = lttng_trigger_create_from_payload(
810 &trigger_view, &trigger);
811 if (trigger_used_size < 0) {
812 used_size = -1;
813 goto end;
814 }
815
816 used_size += trigger_used_size;
817 }
818
819 if (!action_header->action_index.is_set) {
820 target_action = trigger->action;
821 } else {
822 if (lttng_action_get_type(trigger->action) !=
823 LTTNG_ACTION_TYPE_GROUP) {
824 used_size = -1;
825 goto end;
826 }
827
828 target_action = lttng_action_group_get_at_index(
829 trigger->action,
830 action_header->action_index.value);
831 }
832
833 *query = lttng_error_query_action_create(
834 trigger, target_action);
835 lttng_trigger_put(trigger);
836 if (!*query) {
837 used_size = -1;
838 goto end;
839 }
840
841 break;
842 }
843 default:
844 used_size = -1;
845 goto end;
846 }
847
848end:
849 return used_size;
850}
851
852enum lttng_error_query_results_status lttng_error_query_results_get_count(
853 const struct lttng_error_query_results *results,
854 unsigned int *count)
855{
856 enum lttng_error_query_results_status status;
857
858 if (!results || !count) {
859 status = LTTNG_ERROR_QUERY_RESULTS_STATUS_INVALID_PARAMETER;
860 goto end;
861 }
862
863 *count = lttng_dynamic_pointer_array_get_count(&results->results);
864 status = LTTNG_ERROR_QUERY_RESULTS_STATUS_OK;
865end:
866 return status;
867}
868
869enum lttng_error_query_results_status
870lttng_error_query_results_get_result(
871 const struct lttng_error_query_results *results,
872 const struct lttng_error_query_result **result,
873 unsigned int index)
874{
875 unsigned int result_count;
876 enum lttng_error_query_results_status status;
877
878 if (!results || !result) {
879 status = LTTNG_ERROR_QUERY_RESULTS_STATUS_INVALID_PARAMETER;
880 goto end;
881 }
882
883 status = lttng_error_query_results_get_count(results, &result_count);
884 if (status != LTTNG_ERROR_QUERY_RESULTS_STATUS_OK) {
885 goto end;
886 }
887
888 if (index >= result_count) {
889 status = LTTNG_ERROR_QUERY_RESULTS_STATUS_INVALID_PARAMETER;
890 goto end;
891 }
892
893 *result = (typeof(*result)) lttng_dynamic_pointer_array_get_pointer(
894 &results->results, index);
895 assert(*result);
896 status = LTTNG_ERROR_QUERY_RESULTS_STATUS_OK;
897end:
898 return status;
899}
900
901void lttng_error_query_results_destroy(
902 struct lttng_error_query_results *results)
903{
904 if (!results) {
905 return;
906 }
907
908 lttng_dynamic_pointer_array_reset(&results->results);
909 free(results);
910}
911
912enum lttng_error_query_result_type
913lttng_error_query_result_get_type(const struct lttng_error_query_result *result)
914{
915 return result ? result->type : LTTNG_ERROR_QUERY_RESULT_TYPE_UNKNOWN;
916}
917
918enum lttng_error_query_result_status lttng_error_query_result_get_name(
919 const struct lttng_error_query_result *result,
920 const char **name)
921{
922 enum lttng_error_query_result_status status;
923
924 if (!result || !name) {
925 status = LTTNG_ERROR_QUERY_RESULT_STATUS_INVALID_PARAMETER;
926 goto end;
927 }
928
929 *name = result->name;
930 status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK;
931end:
932 return status;
933}
934
935enum lttng_error_query_result_status lttng_error_query_result_get_description(
936 const struct lttng_error_query_result *result,
937 const char **description)
938{
939 enum lttng_error_query_result_status status;
940
941 if (!result || !description) {
942 status = LTTNG_ERROR_QUERY_RESULT_STATUS_INVALID_PARAMETER;
943 goto end;
944 }
945
946 *description = result->description;
947 status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK;
948end:
949 return status;
950}
951
952enum lttng_error_query_result_status lttng_error_query_result_counter_get_value(
953 const struct lttng_error_query_result *result,
954 uint64_t *value)
955{
956 enum lttng_error_query_result_status status;
957 const struct lttng_error_query_result_counter *counter_result;
958
959 if (!result || !value ||
960 result->type != LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) {
961 status = LTTNG_ERROR_QUERY_RESULT_STATUS_INVALID_PARAMETER;
962 goto end;
963 }
964
965 counter_result = container_of(result, typeof(*counter_result), parent);
966
967 *value = counter_result->value;
968 status = LTTNG_ERROR_QUERY_RESULT_STATUS_OK;
969end:
970 return status;
971}
This page took 0.056426 seconds and 4 git commands to generate.