Commit | Line | Data |
---|---|---|
2d0e6286 JG |
1 | /* |
2 | * trigger_name.c | |
3 | * | |
4 | * Tests suite for anonymous, named, and automatic name triggers. | |
5 | * | |
6 | * Copyright (C) 2021 Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
7 | * | |
8 | * SPDX-License-Identifier: MIT | |
9 | * | |
10 | */ | |
11 | ||
28ab034a JG |
12 | #include <common/macros.hpp> |
13 | ||
14 | #include <lttng/lttng.h> | |
15 | ||
2d0e6286 | 16 | #include <stdint.h> |
28ab034a | 17 | #include <stdio.h> |
2d0e6286 | 18 | #include <string.h> |
28ab034a JG |
19 | #include <tap/tap.h> |
20 | #include <unistd.h> | |
2d0e6286 JG |
21 | |
22 | #define TEST_COUNT 70 | |
23 | ||
24 | enum unregistration_trigger_instance { | |
25 | UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION, | |
26 | UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING, | |
27 | }; | |
28 | ||
e665dfbc | 29 | using test_function = void (*)(enum unregistration_trigger_instance); |
2d0e6286 | 30 | |
28ab034a | 31 | static const char *get_trigger_name(const struct lttng_trigger *trigger) |
2d0e6286 JG |
32 | { |
33 | const char *trigger_name; | |
34 | enum lttng_trigger_status trigger_status; | |
35 | ||
36 | trigger_status = lttng_trigger_get_name(trigger, &trigger_name); | |
37 | switch (trigger_status) { | |
38 | case LTTNG_TRIGGER_STATUS_OK: | |
39 | break; | |
40 | case LTTNG_TRIGGER_STATUS_UNSET: | |
41 | trigger_name = "(anonymous)"; | |
42 | break; | |
43 | default: | |
44 | trigger_name = "(failed to get name)"; | |
45 | break; | |
46 | } | |
47 | ||
48 | return trigger_name; | |
49 | } | |
50 | ||
28ab034a JG |
51 | static const char * |
52 | unregistration_trigger_instance_name(enum unregistration_trigger_instance unregistration_trigger) | |
2d0e6286 JG |
53 | { |
54 | const char *name; | |
55 | ||
56 | switch (unregistration_trigger) { | |
57 | case UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING: | |
58 | name = "from listing"; | |
59 | break; | |
60 | case UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION: | |
61 | name = "used for registration"; | |
62 | break; | |
63 | default: | |
64 | abort(); | |
65 | } | |
66 | ||
67 | return name; | |
68 | } | |
69 | ||
70 | /* | |
71 | * Returns a negative error code on error, else the number of unregistered | |
72 | * triggers. | |
73 | */ | |
cd9adb8b | 74 | static int unregister_all_triggers() |
2d0e6286 JG |
75 | { |
76 | int ret; | |
77 | enum lttng_error_code ret_code; | |
78 | enum lttng_trigger_status trigger_status; | |
cd9adb8b | 79 | struct lttng_triggers *triggers = nullptr; |
2d0e6286 JG |
80 | unsigned int trigger_count, i, unregistered_trigger_count = 0; |
81 | ||
82 | ret_code = lttng_list_triggers(&triggers); | |
83 | if (ret_code != LTTNG_OK) { | |
84 | fail("Failed to list triggers"); | |
85 | ret = -1; | |
86 | goto end; | |
87 | } | |
88 | ||
89 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
90 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
91 | fail("Failed to get count of triggers returned by listing"); | |
92 | ret = -1; | |
93 | goto end; | |
94 | } | |
95 | ||
96 | for (i = 0; i < trigger_count; i++) { | |
97 | const struct lttng_trigger *trigger; | |
98 | ||
99 | trigger = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 100 | LTTNG_ASSERT(trigger); |
2d0e6286 JG |
101 | |
102 | ret = lttng_unregister_trigger(trigger); | |
103 | if (ret) { | |
9f4a25d3 SM |
104 | const char *name; |
105 | enum lttng_trigger_status get_name_status = | |
106 | lttng_trigger_get_name(trigger, &name); | |
107 | if (get_name_status == LTTNG_TRIGGER_STATUS_OK) { | |
108 | fail("Failed to unregister trigger: trigger name = '%s'", name); | |
109 | } else { | |
110 | fail("Failed to unregister trigger"); | |
111 | } | |
2d0e6286 JG |
112 | goto end; |
113 | } | |
114 | ||
115 | unregistered_trigger_count++; | |
116 | } | |
117 | ||
118 | ret = (int) unregistered_trigger_count; | |
119 | ||
120 | end: | |
121 | lttng_triggers_destroy(triggers); | |
122 | return ret; | |
123 | } | |
124 | ||
cd9adb8b | 125 | static int get_registered_triggers_count() |
2d0e6286 JG |
126 | { |
127 | int ret; | |
128 | enum lttng_error_code ret_code; | |
129 | enum lttng_trigger_status trigger_status; | |
cd9adb8b | 130 | struct lttng_triggers *triggers = nullptr; |
2d0e6286 JG |
131 | unsigned int trigger_count; |
132 | ||
133 | ret_code = lttng_list_triggers(&triggers); | |
134 | if (ret_code != LTTNG_OK) { | |
135 | fail("Failed to list triggers"); | |
136 | ret = -1; | |
137 | goto end; | |
138 | } | |
139 | ||
140 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
141 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
142 | fail("Failed to get count of triggers returned by listing"); | |
143 | ret = -1; | |
144 | goto end; | |
145 | } | |
146 | ||
147 | ret = (int) trigger_count; | |
148 | ||
149 | end: | |
150 | lttng_triggers_destroy(triggers); | |
151 | return ret; | |
152 | } | |
153 | ||
154 | /* | |
155 | * Create a generic trigger. The specifics of the condition and action are not | |
156 | * important for the purposes of this test. | |
157 | */ | |
28ab034a | 158 | static struct lttng_trigger *create_trigger(uint64_t threshold) |
2d0e6286 | 159 | { |
cd9adb8b JG |
160 | struct lttng_condition *condition = nullptr; |
161 | struct lttng_action *action = nullptr; | |
162 | struct lttng_trigger *trigger = nullptr; | |
2d0e6286 | 163 | enum lttng_condition_status condition_status; |
28ab034a | 164 | const char *const session_name = "test session"; |
2d0e6286 JG |
165 | |
166 | condition = lttng_condition_session_consumed_size_create(); | |
167 | if (!condition) { | |
168 | fail("Failed to create 'session consumed size' condition"); | |
169 | goto end; | |
170 | } | |
171 | ||
28ab034a JG |
172 | condition_status = |
173 | lttng_condition_session_consumed_size_set_session_name(condition, session_name); | |
2d0e6286 JG |
174 | if (condition_status != LTTNG_CONDITION_STATUS_OK) { |
175 | fail("Failed to set session name on 'session consumed size' condition"); | |
176 | goto end; | |
177 | } | |
178 | ||
28ab034a JG |
179 | condition_status = |
180 | lttng_condition_session_consumed_size_set_threshold(condition, threshold); | |
2d0e6286 JG |
181 | if (condition_status != LTTNG_CONDITION_STATUS_OK) { |
182 | fail("Failed to set threshold on 'session consumed size' condition"); | |
183 | goto end; | |
184 | } | |
185 | ||
186 | action = lttng_action_notify_create(); | |
187 | if (!action) { | |
188 | fail("Failed to create 'notify' action"); | |
189 | goto end; | |
190 | } | |
191 | ||
192 | trigger = lttng_trigger_create(condition, action); | |
193 | if (!trigger) { | |
194 | fail("Failed to create trigger"); | |
195 | goto end; | |
196 | } | |
197 | ||
198 | end: | |
199 | lttng_condition_destroy(condition); | |
200 | lttng_action_destroy(action); | |
201 | return trigger; | |
202 | } | |
203 | ||
28ab034a | 204 | static void register_anonymous_trigger(enum unregistration_trigger_instance unregistration_trigger) |
2d0e6286 JG |
205 | { |
206 | int ret; | |
207 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
208 | enum lttng_trigger_status trigger_status; | |
209 | const char *trigger_name; | |
cd9adb8b | 210 | struct lttng_triggers *triggers = nullptr; |
2d0e6286 JG |
211 | unsigned int trigger_count, i; |
212 | enum lttng_error_code ret_code; | |
213 | ||
214 | diag("Register an anonymous trigger (Unregistration performed with the trigger instance %s)", | |
28ab034a | 215 | unregistration_trigger_instance_name(unregistration_trigger)); |
2d0e6286 JG |
216 | |
217 | if (!trigger) { | |
218 | fail("Failed to create trigger"); | |
219 | goto end; | |
220 | } | |
221 | ||
222 | ret = lttng_register_trigger(trigger); | |
223 | ok(ret == 0, "Registered anonymous trigger"); | |
224 | ||
225 | trigger_status = lttng_trigger_get_name(trigger, &trigger_name); | |
226 | ok(trigger_status == LTTNG_TRIGGER_STATUS_UNSET, | |
28ab034a JG |
227 | "Anonymous trigger name remains unset after registration: trigger name = '%s'", |
228 | get_trigger_name(trigger)); | |
2d0e6286 JG |
229 | |
230 | ret_code = lttng_list_triggers(&triggers); | |
231 | if (ret_code != LTTNG_OK) { | |
232 | fail("Failed to list triggers"); | |
233 | ret = -1; | |
234 | goto end; | |
235 | } | |
236 | ||
237 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
238 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
239 | fail("Failed to get count of triggers returned by listing"); | |
240 | ret = -1; | |
241 | goto end; | |
242 | } | |
243 | ||
244 | ok(trigger_count == 1, "Trigger listing returns 1 trigger"); | |
245 | ||
246 | for (i = 0; i < trigger_count; i++) { | |
247 | const struct lttng_trigger *trigger_from_listing; | |
248 | ||
249 | trigger_from_listing = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 250 | LTTNG_ASSERT(trigger_from_listing); |
2d0e6286 JG |
251 | |
252 | trigger_status = lttng_trigger_get_name(trigger_from_listing, &trigger_name); | |
253 | ok(trigger_status == LTTNG_TRIGGER_STATUS_UNSET, | |
28ab034a JG |
254 | "Anonymous trigger returned by listing has an unset name: trigger name = '%s'", |
255 | get_trigger_name(trigger_from_listing)); | |
2d0e6286 JG |
256 | |
257 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { | |
258 | ret = lttng_unregister_trigger(trigger_from_listing); | |
28ab034a JG |
259 | ok(ret == 0, |
260 | "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); | |
2d0e6286 JG |
261 | } |
262 | } | |
263 | ||
264 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
265 | ret = lttng_unregister_trigger(trigger); | |
28ab034a JG |
266 | ok(ret == 0, |
267 | "Successfully unregistered anonymous trigger using the trigger instance used on registration"); | |
2d0e6286 JG |
268 | } |
269 | ||
270 | end: | |
271 | lttng_triggers_destroy(triggers); | |
272 | lttng_trigger_destroy(trigger); | |
273 | } | |
274 | ||
28ab034a | 275 | static void register_named_trigger(enum unregistration_trigger_instance unregistration_trigger) |
2d0e6286 JG |
276 | { |
277 | int ret; | |
278 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
279 | enum lttng_trigger_status trigger_status; | |
280 | const char *returned_trigger_name; | |
cd9adb8b | 281 | struct lttng_triggers *triggers = nullptr; |
2d0e6286 JG |
282 | unsigned int trigger_count, i; |
283 | enum lttng_error_code ret_code; | |
28ab034a | 284 | const char *const trigger_name = "some name that is hopefully unique"; |
2d0e6286 JG |
285 | |
286 | diag("Register a named trigger (Unregistration performed with the trigger instance %s)", | |
28ab034a | 287 | unregistration_trigger_instance_name(unregistration_trigger)); |
2d0e6286 JG |
288 | |
289 | if (!trigger) { | |
290 | fail("Failed to create trigger"); | |
291 | goto end; | |
292 | } | |
293 | ||
294 | ret_code = lttng_register_trigger_with_name(trigger, trigger_name); | |
28ab034a JG |
295 | ok(ret_code == LTTNG_OK, |
296 | "Registered trigger with name: trigger name = '%s'", | |
297 | get_trigger_name(trigger)); | |
2d0e6286 JG |
298 | |
299 | trigger_status = lttng_trigger_get_name(trigger, &returned_trigger_name); | |
300 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, | |
28ab034a JG |
301 | "Trigger name is set after registration: trigger name = '%s'", |
302 | get_trigger_name(trigger)); | |
2d0e6286 JG |
303 | |
304 | ok(!strcmp(get_trigger_name(trigger), trigger_name), | |
28ab034a | 305 | "Name set on trigger after registration is correct"); |
2d0e6286 JG |
306 | |
307 | ret_code = lttng_list_triggers(&triggers); | |
308 | if (ret_code != LTTNG_OK) { | |
309 | fail("Failed to list triggers"); | |
310 | ret = -1; | |
311 | goto end; | |
312 | } | |
313 | ||
314 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
315 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
316 | fail("Failed to get count of triggers returned by listing"); | |
317 | ret = -1; | |
318 | goto end; | |
319 | } | |
320 | ||
321 | ok(trigger_count == 1, "Trigger listing returns 1 trigger"); | |
322 | ||
323 | for (i = 0; i < trigger_count; i++) { | |
324 | const struct lttng_trigger *trigger_from_listing; | |
325 | ||
326 | trigger_from_listing = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 327 | LTTNG_ASSERT(trigger_from_listing); |
2d0e6286 | 328 | |
28ab034a JG |
329 | trigger_status = |
330 | lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); | |
2d0e6286 | 331 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, |
28ab034a JG |
332 | "Trigger returned by listing has a name: trigger name = '%s'", |
333 | get_trigger_name(trigger_from_listing)); | |
2d0e6286 | 334 | |
28ab034a JG |
335 | ok(!strcmp(get_trigger_name(trigger_from_listing), trigger_name), |
336 | "Name set on trigger returned from listing is correct: name returned from listing = '%s', expected name = '%s'", | |
337 | get_trigger_name(trigger_from_listing), | |
338 | trigger_name); | |
2d0e6286 JG |
339 | |
340 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { | |
341 | ret = lttng_unregister_trigger(trigger_from_listing); | |
28ab034a JG |
342 | ok(ret == 0, |
343 | "Successfully unregistered named trigger using the trigger instance returned by the listing"); | |
2d0e6286 JG |
344 | } |
345 | } | |
346 | ||
347 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
348 | ret = lttng_unregister_trigger(trigger); | |
28ab034a JG |
349 | ok(ret == 0, |
350 | "Successfully unregistered named trigger using the trigger instance used on registration"); | |
2d0e6286 JG |
351 | } |
352 | ||
353 | end: | |
354 | lttng_triggers_destroy(triggers); | |
355 | lttng_trigger_destroy(trigger); | |
356 | } | |
357 | ||
28ab034a JG |
358 | static void |
359 | register_automatic_name_trigger(enum unregistration_trigger_instance unregistration_trigger) | |
2d0e6286 JG |
360 | { |
361 | int ret; | |
362 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
363 | enum lttng_trigger_status trigger_status; | |
364 | const char *returned_trigger_name; | |
cd9adb8b | 365 | struct lttng_triggers *triggers = nullptr; |
2d0e6286 JG |
366 | unsigned int trigger_count, i; |
367 | enum lttng_error_code ret_code; | |
368 | ||
369 | diag("Register an automatic name trigger (Unregistration performed with the trigger instance %s)", | |
28ab034a | 370 | unregistration_trigger_instance_name(unregistration_trigger)); |
2d0e6286 JG |
371 | |
372 | if (!trigger) { | |
373 | fail("Failed to create trigger"); | |
374 | goto end; | |
375 | } | |
376 | ||
377 | ret_code = lttng_register_trigger_with_automatic_name(trigger); | |
378 | ok(ret_code == LTTNG_OK, "Registered trigger with automatic name"); | |
379 | ||
380 | trigger_status = lttng_trigger_get_name(trigger, &returned_trigger_name); | |
381 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, | |
28ab034a JG |
382 | "Trigger name is set after registration: trigger name = '%s'", |
383 | get_trigger_name(trigger)); | |
2d0e6286 JG |
384 | |
385 | ok(returned_trigger_name && strlen(returned_trigger_name) > 0, | |
28ab034a | 386 | "Automatic name set on trigger after registration longer is not an empty string"); |
2d0e6286 JG |
387 | |
388 | ret_code = lttng_list_triggers(&triggers); | |
389 | if (ret_code != LTTNG_OK) { | |
390 | fail("Failed to list triggers"); | |
391 | ret = -1; | |
392 | goto end; | |
393 | } | |
394 | ||
395 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
396 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
397 | fail("Failed to get count of triggers returned by listing"); | |
398 | ret = -1; | |
399 | goto end; | |
400 | } | |
401 | ||
402 | ok(trigger_count == 1, "Trigger listing returns 1 trigger"); | |
403 | ||
404 | for (i = 0; i < trigger_count; i++) { | |
405 | const struct lttng_trigger *trigger_from_listing; | |
406 | ||
407 | trigger_from_listing = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 408 | LTTNG_ASSERT(trigger_from_listing); |
2d0e6286 | 409 | |
28ab034a JG |
410 | trigger_status = |
411 | lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); | |
2d0e6286 | 412 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, |
28ab034a JG |
413 | "Trigger returned by listing has a name: trigger name = '%s'", |
414 | get_trigger_name(trigger_from_listing)); | |
2d0e6286 JG |
415 | |
416 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { | |
417 | ret = lttng_unregister_trigger(trigger_from_listing); | |
28ab034a JG |
418 | ok(ret == 0, |
419 | "Successfully unregistered automatic name trigger using the trigger instance returned by the listing"); | |
2d0e6286 JG |
420 | } |
421 | } | |
422 | ||
423 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
424 | ret = lttng_unregister_trigger(trigger); | |
28ab034a JG |
425 | ok(ret == 0, |
426 | "Successfully unregistered automatic trigger using the trigger instance used on registration"); | |
2d0e6286 JG |
427 | } |
428 | ||
429 | end: | |
430 | lttng_triggers_destroy(triggers); | |
431 | lttng_trigger_destroy(trigger); | |
432 | } | |
433 | ||
28ab034a JG |
434 | static void |
435 | double_register_anonymous_trigger(enum unregistration_trigger_instance unregistration_trigger) | |
2d0e6286 JG |
436 | { |
437 | int ret; | |
438 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
cd9adb8b | 439 | struct lttng_triggers *triggers = nullptr; |
2d0e6286 JG |
440 | |
441 | diag("Register duplicate anonymous trigger (Unregistration performed with the trigger instance %s)", | |
28ab034a | 442 | unregistration_trigger_instance_name(unregistration_trigger)); |
2d0e6286 JG |
443 | |
444 | if (!trigger) { | |
445 | fail("Failed to create trigger"); | |
446 | goto end; | |
447 | } | |
448 | ||
449 | ret = lttng_register_trigger(trigger); | |
450 | ok(ret == 0, "Registered anonymous trigger"); | |
451 | ||
452 | ret = lttng_register_trigger(trigger); | |
453 | ok(ret == -LTTNG_ERR_TRIGGER_EXISTS, | |
28ab034a | 454 | "Registering identical anonymous trigger fails with `LTTNG_ERR_TRIGGER_EXISTS`"); |
2d0e6286 JG |
455 | |
456 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
457 | ret = lttng_unregister_trigger(trigger); | |
28ab034a JG |
458 | ok(ret == 0, |
459 | "Successfully unregistered anonymous trigger using the trigger instance used on registration"); | |
2d0e6286 | 460 | } else { |
28ab034a | 461 | ok(get_registered_triggers_count() == 1, "Trigger listing returns 1 trigger"); |
2d0e6286 | 462 | ok(unregister_all_triggers() == 1, |
28ab034a | 463 | "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); |
2d0e6286 JG |
464 | } |
465 | ||
466 | end: | |
467 | lttng_triggers_destroy(triggers); | |
468 | lttng_trigger_destroy(trigger); | |
469 | } | |
470 | ||
28ab034a JG |
471 | static void |
472 | double_register_named_trigger(enum unregistration_trigger_instance unregistration_trigger) | |
2d0e6286 JG |
473 | { |
474 | int ret; | |
475 | struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); | |
476 | struct lttng_trigger *trigger_b = create_trigger(0xbadc0ffee); | |
cd9adb8b | 477 | struct lttng_triggers *triggers = nullptr; |
28ab034a | 478 | const char *const trigger_name = "a unique trigger name"; |
2d0e6286 JG |
479 | enum lttng_error_code ret_code; |
480 | ||
481 | diag("Register duplicate named trigger (Unregistration performed with the trigger instance %s)", | |
28ab034a | 482 | unregistration_trigger_instance_name(unregistration_trigger)); |
2d0e6286 JG |
483 | |
484 | if (!trigger_a || !trigger_b) { | |
485 | fail("Failed to create triggers"); | |
486 | goto end; | |
487 | } | |
488 | ||
489 | ret_code = lttng_register_trigger_with_name(trigger_a, trigger_name); | |
490 | ok(ret_code == LTTNG_OK, "Registered named trigger"); | |
491 | ||
492 | ret = lttng_register_trigger(trigger_a); | |
493 | ok(ret == -LTTNG_ERR_INVALID, | |
28ab034a | 494 | "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (anonymous registration)"); |
2d0e6286 JG |
495 | |
496 | ret_code = lttng_register_trigger_with_name(trigger_a, trigger_name); | |
497 | ok(ret_code == LTTNG_ERR_INVALID, | |
28ab034a | 498 | "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with name)"); |
2d0e6286 JG |
499 | |
500 | ret_code = lttng_register_trigger_with_automatic_name(trigger_a); | |
501 | ok(ret_code == LTTNG_ERR_INVALID, | |
28ab034a | 502 | "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with automatic name)"); |
2d0e6286 JG |
503 | |
504 | ret_code = lttng_register_trigger_with_name(trigger_b, trigger_name); | |
28ab034a JG |
505 | ok(ret_code == LTTNG_ERR_TRIGGER_EXISTS, |
506 | "Registering trigger with an already used name fails with `LTTNG_ERR_TRIGGER_EXISTS`"); | |
2d0e6286 JG |
507 | |
508 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
509 | ret = lttng_unregister_trigger(trigger_a); | |
28ab034a JG |
510 | ok(ret == 0, |
511 | "Successfully unregistered named trigger using the trigger instance used on registration"); | |
2d0e6286 | 512 | } else { |
28ab034a | 513 | ok(get_registered_triggers_count() == 1, "Trigger listing returns 1 trigger"); |
2d0e6286 | 514 | ok(unregister_all_triggers() == 1, |
28ab034a | 515 | "Successfully unregistered named trigger using the trigger instance returned by the listing"); |
2d0e6286 JG |
516 | } |
517 | ||
518 | end: | |
519 | lttng_triggers_destroy(triggers); | |
520 | lttng_trigger_destroy(trigger_a); | |
521 | lttng_trigger_destroy(trigger_b); | |
522 | } | |
523 | ||
28ab034a JG |
524 | static void |
525 | double_register_automatic_name_trigger(enum unregistration_trigger_instance unregistration_trigger) | |
2d0e6286 JG |
526 | { |
527 | int ret; | |
528 | struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); | |
529 | struct lttng_trigger *trigger_b = create_trigger(0xbadc0ffee); | |
cd9adb8b | 530 | struct lttng_triggers *triggers = nullptr; |
2d0e6286 JG |
531 | enum lttng_error_code ret_code; |
532 | ||
533 | diag("Register duplicate automatic name trigger (Unregistration performed with the trigger instance %s)", | |
28ab034a | 534 | unregistration_trigger_instance_name(unregistration_trigger)); |
2d0e6286 JG |
535 | |
536 | if (!trigger_a || !trigger_b) { | |
537 | fail("Failed to create triggers"); | |
538 | goto end; | |
539 | } | |
540 | ||
541 | ret_code = lttng_register_trigger_with_automatic_name(trigger_a); | |
28ab034a JG |
542 | ok(ret_code == LTTNG_OK, |
543 | "Registered automatic name trigger: trigger name = '%s'", | |
544 | get_trigger_name(trigger_a)); | |
2d0e6286 JG |
545 | |
546 | ret = lttng_register_trigger_with_automatic_name(trigger_b); | |
28ab034a JG |
547 | ok(ret_code == LTTNG_OK, |
548 | "Registering an identical trigger instance with an automatic name succeeds: trigger name = '%s'", | |
549 | get_trigger_name(trigger_b)); | |
2d0e6286 JG |
550 | |
551 | ok(strcmp(get_trigger_name(trigger_a), get_trigger_name(trigger_b)), | |
28ab034a | 552 | "Two identical triggers registered with an automatic name have different names"); |
2d0e6286 JG |
553 | |
554 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
555 | ret = lttng_unregister_trigger(trigger_a); | |
28ab034a JG |
556 | ok(ret == 0, |
557 | "Successfully unregistered automatic trigger A using the trigger instance used on registration"); | |
2d0e6286 JG |
558 | |
559 | ret = lttng_unregister_trigger(trigger_b); | |
28ab034a JG |
560 | ok(ret == 0, |
561 | "Successfully unregistered automatic trigger B using the trigger instance used on registration"); | |
2d0e6286 | 562 | } else { |
28ab034a | 563 | ok(get_registered_triggers_count() == 2, "Trigger listing returns 2 trigger"); |
2d0e6286 | 564 | ok(unregister_all_triggers() == 2, |
28ab034a | 565 | "Successfully unregistered automatic name triggers using the trigger instance returned by the listing"); |
2d0e6286 JG |
566 | } |
567 | ||
568 | end: | |
569 | lttng_triggers_destroy(triggers); | |
570 | lttng_trigger_destroy(trigger_a); | |
571 | lttng_trigger_destroy(trigger_b); | |
572 | } | |
573 | ||
cd9adb8b | 574 | static void register_multiple_anonymous_triggers() |
2d0e6286 JG |
575 | { |
576 | int ret; | |
577 | struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); | |
578 | struct lttng_trigger *trigger_b = create_trigger(0xbadf00d); | |
579 | ||
580 | diag("Register two different anonymous triggers"); | |
581 | ||
582 | if (!trigger_a || !trigger_b) { | |
583 | fail("Failed to create triggers"); | |
584 | goto end; | |
585 | } | |
586 | ||
587 | ret = lttng_register_trigger(trigger_a); | |
588 | ok(ret == 0, "Registered first anonymous trigger"); | |
589 | ||
590 | ret = lttng_register_trigger(trigger_b); | |
591 | ok(ret == 0, "Registered second anonymous trigger"); | |
592 | ||
28ab034a JG |
593 | ok(get_registered_triggers_count() == 2, "Trigger listing returns 2 trigger"); |
594 | ok(unregister_all_triggers() == 2, "Successfully unregistered two anonymous triggers"); | |
2d0e6286 JG |
595 | |
596 | end: | |
597 | lttng_trigger_destroy(trigger_a); | |
598 | lttng_trigger_destroy(trigger_b); | |
599 | } | |
600 | ||
601 | const test_function test_functions[] = { | |
28ab034a JG |
602 | register_anonymous_trigger, register_named_trigger, |
603 | register_automatic_name_trigger, double_register_anonymous_trigger, | |
604 | double_register_named_trigger, double_register_automatic_name_trigger, | |
2d0e6286 JG |
605 | }; |
606 | ||
cd9adb8b | 607 | int main() |
2d0e6286 JG |
608 | { |
609 | size_t i; | |
610 | ||
611 | plan_tests(TEST_COUNT); | |
612 | ||
613 | if (get_registered_triggers_count() != 0) { | |
614 | fail("Session daemon already has registered triggers, bailing out"); | |
615 | goto end; | |
616 | } | |
617 | ||
618 | for (i = 0; i < ARRAY_SIZE(test_functions); i++) { | |
619 | const test_function fn = test_functions[i]; | |
620 | ||
621 | fn(UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING); | |
622 | if (get_registered_triggers_count() != 0) { | |
623 | fail("Previous test left registered triggers, bailing out"); | |
624 | goto end; | |
625 | } | |
626 | } | |
627 | ||
628 | for (i = 0; i < ARRAY_SIZE(test_functions); i++) { | |
629 | const test_function fn = test_functions[i]; | |
630 | ||
631 | fn(UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION); | |
632 | if (get_registered_triggers_count() != 0) { | |
633 | fail("Previous test left registered triggers, bailing out"); | |
634 | goto end; | |
635 | } | |
636 | } | |
637 | ||
638 | register_multiple_anonymous_triggers(); | |
639 | end: | |
640 | return exit_status(); | |
641 | } |