trigger: consider domain on register and unregister
[lttng-tools.git] / src / lib / lttng-ctl / destruction-handle.c
CommitLineData
3e3665b8 1/*
ab5be9fa 2 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3e3665b8 3 *
ab5be9fa 4 * SPDX-License-Identifier: LGPL-2.1-only
3e3665b8 5 *
3e3665b8
JG
6 */
7
8#include <lttng/destruction-handle.h>
9#include <lttng/rotation.h>
10
11#include <common/optional.h>
12#include <common/compat/poll.h>
13#include <common/compat/time.h>
14#include <common/macros.h>
15#include <common/compat/poll.h>
16#include <common/dynamic-buffer.h>
17#include <common/buffer-view.h>
18#include <common/sessiond-comm/sessiond-comm.h>
19#include <lttng/location-internal.h>
20#include "lttng-ctl-helper.h"
21
22#include <stdbool.h>
23
24enum communication_state {
25 COMMUNICATION_STATE_RECEIVE_LTTNG_MSG,
26 COMMUNICATION_STATE_RECEIVE_COMMAND_HEADER,
27 COMMUNICATION_STATE_RECEIVE_PAYLOAD,
28 COMMUNICATION_STATE_END,
29 COMMUNICATION_STATE_ERROR,
30};
31
32struct lttng_destruction_handle {
33 LTTNG_OPTIONAL(enum lttng_error_code) destruction_return_code;
34 LTTNG_OPTIONAL(enum lttng_rotation_state) rotation_state;
35 struct lttng_trace_archive_location *location;
36 struct {
37 int socket;
38 struct lttng_poll_event events;
39 size_t bytes_left_to_receive;
40 enum communication_state state;
41 struct lttng_dynamic_buffer buffer;
42 LTTNG_OPTIONAL(size_t) data_size;
43 } communication;
44};
45
46void lttng_destruction_handle_destroy(struct lttng_destruction_handle *handle)
47{
48 int ret;
49
50 if (!handle) {
51 return;
52 }
53
54 if (handle->communication.socket >= 0) {
55 ret = close(handle->communication.socket);
56 if (ret) {
57 PERROR("Failed to close lttng-sessiond command socket");
58 }
96c5e4c3
JG
59 }
60 lttng_poll_clean(&handle->communication.events);
3e3665b8
JG
61 lttng_dynamic_buffer_reset(&handle->communication.buffer);
62 lttng_trace_archive_location_destroy(handle->location);
63 free(handle);
64}
65
66static
67struct lttng_destruction_handle *lttng_destruction_handle_create(
68 int sessiond_socket)
69{
70 int ret;
71 struct lttng_destruction_handle *handle = zmalloc(sizeof(*handle));
72
73 if (!handle) {
74 goto end;
75 }
76 lttng_dynamic_buffer_init(&handle->communication.buffer);
77 handle->communication.socket = sessiond_socket;
78 ret = lttng_poll_create(&handle->communication.events, 1, 0);
79 if (ret) {
80 goto error;
81 }
82
83 ret = lttng_poll_add(&handle->communication.events, sessiond_socket,
84 LPOLLIN | LPOLLHUP | LPOLLRDHUP | LPOLLERR);
96c5e4c3 85 if (ret) {
3e3665b8 86 goto error;
96c5e4c3 87 }
3e3665b8
JG
88
89 handle->communication.bytes_left_to_receive =
90 sizeof(struct lttcomm_lttng_msg);
91 handle->communication.state = COMMUNICATION_STATE_RECEIVE_LTTNG_MSG;
92end:
93 return handle;
94error:
95 lttng_destruction_handle_destroy(handle);
96 return NULL;
97}
98
99static
100int handle_state_transition(struct lttng_destruction_handle *handle)
101{
102 int ret = 0;
103
104 assert(handle->communication.bytes_left_to_receive == 0);
105
106 switch (handle->communication.state) {
107 case COMMUNICATION_STATE_RECEIVE_LTTNG_MSG:
108 {
109 const struct lttcomm_lttng_msg *msg =
110 (typeof(msg)) handle->communication.buffer.data;
111
112 LTTNG_OPTIONAL_SET(&handle->destruction_return_code,
113 (enum lttng_error_code) msg->ret_code);
114 if (handle->destruction_return_code.value != LTTNG_OK) {
115 handle->communication.state = COMMUNICATION_STATE_END;
116 break;
117 } else if (msg->cmd_header_size != sizeof(struct lttcomm_session_destroy_command_header) ||
118 msg->data_size > DEFAULT_MAX_TRACE_ARCHIVE_LOCATION_PAYLOAD_SIZE) {
119 handle->communication.state = COMMUNICATION_STATE_ERROR;
120 ret = -1;
121 break;
122 }
123
124 handle->communication.state =
125 COMMUNICATION_STATE_RECEIVE_COMMAND_HEADER;
126 handle->communication.bytes_left_to_receive =
127 msg->cmd_header_size;
128 LTTNG_OPTIONAL_SET(&handle->communication.data_size,
129 msg->data_size);
130 ret = lttng_dynamic_buffer_set_size(
131 &handle->communication.buffer, 0);
132 assert(!ret);
133 break;
134 }
135 case COMMUNICATION_STATE_RECEIVE_COMMAND_HEADER:
136 {
137 const struct lttcomm_session_destroy_command_header *hdr =
138 (typeof(hdr)) handle->communication.buffer.data;
139
140 LTTNG_OPTIONAL_SET(&handle->rotation_state,
141 (enum lttng_rotation_state) hdr->rotation_state);
142 switch (handle->rotation_state.value) {
143 case LTTNG_ROTATION_STATE_COMPLETED:
144 handle->communication.state =
145 COMMUNICATION_STATE_RECEIVE_PAYLOAD;
146 handle->communication.bytes_left_to_receive =
147 LTTNG_OPTIONAL_GET(handle->communication.data_size);
148 break;
149 case LTTNG_ROTATION_STATE_ERROR:
150 case LTTNG_ROTATION_STATE_NO_ROTATION:
151 handle->communication.state = COMMUNICATION_STATE_END;
152 break;
153 default:
154 handle->communication.state = COMMUNICATION_STATE_ERROR;
155 ret = -1;
156 break;
157 }
158 break;
159 }
160 case COMMUNICATION_STATE_RECEIVE_PAYLOAD:
161 {
162 ssize_t location_ret;
163 struct lttng_trace_archive_location *location;
164 const struct lttng_buffer_view view =
165 lttng_buffer_view_from_dynamic_buffer(
166 &handle->communication.buffer, 0, -1);
167
168 location_ret = lttng_trace_archive_location_create_from_buffer(
169 &view, &location);
170 if (location_ret < 0) {
171 ERR("Failed to deserialize trace archive location");
172 handle->communication.state = COMMUNICATION_STATE_ERROR;
173 ret = -1;
174 break;
175 } else {
176 handle->location = location;
177 handle->communication.state = COMMUNICATION_STATE_END;
178 }
179 break;
180 }
181 default:
182 abort();
183 }
184
185 /* Clear reception buffer on state transition. */
186 if (lttng_dynamic_buffer_set_size(&handle->communication.buffer, 0)) {
187 abort();
188 }
189 return ret;
190}
191
192static
193int handle_incoming_data(struct lttng_destruction_handle *handle)
194{
195 int ret;
196 ssize_t comm_ret;
197 const size_t original_buffer_size = handle->communication.buffer.size;
198
199 /* Reserve space for reception. */
200 ret = lttng_dynamic_buffer_set_size(&handle->communication.buffer,
201 original_buffer_size + handle->communication.bytes_left_to_receive);
202 if (ret) {
203 goto end;
204 }
205
206 comm_ret = lttcomm_recv_unix_sock(handle->communication.socket,
207 handle->communication.buffer.data + original_buffer_size,
208 handle->communication.bytes_left_to_receive);
209 if (comm_ret <= 0) {
210 ret = -1;
211 goto end;
212 }
213
214 handle->communication.bytes_left_to_receive -= comm_ret;
215 if (handle->communication.bytes_left_to_receive == 0) {
216 ret = handle_state_transition(handle);
217 } else {
218 ret = lttng_dynamic_buffer_set_size(
219 &handle->communication.buffer,
220 original_buffer_size + comm_ret);
221 }
222end:
223 return ret;
224}
225
226enum lttng_destruction_handle_status
227lttng_destruction_handle_wait_for_completion(
228 struct lttng_destruction_handle *handle, int timeout_ms)
229{
230 int ret;
231 enum lttng_destruction_handle_status status;
232 unsigned long time_left_ms = 0;
233 const bool has_timeout = timeout_ms > 0;
96c5e4c3 234 struct timespec initial_time;
3e3665b8 235
0f7e4628
JG
236 if (!handle) {
237 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
238 goto end;
239 }
240
96c5e4c3 241 if (handle->communication.state == COMMUNICATION_STATE_ERROR) {
3e3665b8
JG
242 status = LTTNG_DESTRUCTION_HANDLE_STATUS_ERROR;
243 goto end;
244 } else if (handle->communication.state == COMMUNICATION_STATE_END) {
245 status = LTTNG_DESTRUCTION_HANDLE_STATUS_COMPLETED;
246 goto end;
247 }
96c5e4c3 248 if (has_timeout) {
3e3665b8
JG
249 ret = lttng_clock_gettime(CLOCK_MONOTONIC, &initial_time);
250 if (ret) {
251 status = LTTNG_DESTRUCTION_HANDLE_STATUS_ERROR;
252 goto end;
253 }
254 time_left_ms = (unsigned long) timeout_ms;
96c5e4c3 255 }
3e3665b8 256
96c5e4c3 257 while (handle->communication.state != COMMUNICATION_STATE_END &&
3e3665b8
JG
258 (time_left_ms || !has_timeout)) {
259 int ret;
260 uint32_t revents;
96c5e4c3 261 struct timespec current_time, diff;
3e3665b8
JG
262 unsigned long diff_ms;
263
96c5e4c3 264 ret = lttng_poll_wait(&handle->communication.events,
3e3665b8 265 has_timeout ? time_left_ms : -1);
96c5e4c3 266 if (ret == 0) {
3e3665b8
JG
267 /* timeout */
268 break;
269 } else if (ret < 0) {
270 status = LTTNG_DESTRUCTION_HANDLE_STATUS_ERROR;
271 goto end;
272 }
273
274 /* The sessiond connection socket is the only monitored fd. */
275 revents = LTTNG_POLL_GETEV(&handle->communication.events, 0);
276 if (revents & LPOLLIN) {
277 ret = handle_incoming_data(handle);
278 if (ret) {
279 handle->communication.state =
280 COMMUNICATION_STATE_ERROR;
281 status = LTTNG_DESTRUCTION_HANDLE_STATUS_ERROR;
282 goto end;
283 }
284 } else {
285 handle->communication.state = COMMUNICATION_STATE_ERROR;
286 status = LTTNG_DESTRUCTION_HANDLE_STATUS_ERROR;
287 goto end;
288 }
289 if (!has_timeout) {
290 continue;
291 }
292
293 ret = lttng_clock_gettime(CLOCK_MONOTONIC, &current_time);
294 if (ret) {
295 status = LTTNG_DESTRUCTION_HANDLE_STATUS_ERROR;
296 goto end;
297 }
298 diff = timespec_abs_diff(initial_time, current_time);
299 ret = timespec_to_ms(diff, &diff_ms);
300 if (ret) {
301 ERR("Failed to compute elapsed time while waiting for completion");
302 status = LTTNG_DESTRUCTION_HANDLE_STATUS_ERROR;
303 goto end;
304 }
305 DBG("%lums elapsed while waiting for session destruction completion",
306 diff_ms);
307 diff_ms = max_t(unsigned long, diff_ms, 1);
308 diff_ms = min_t(unsigned long, diff_ms, time_left_ms);
309 time_left_ms -= diff_ms;
310 }
311
312 status = handle->communication.state == COMMUNICATION_STATE_END ?
313 LTTNG_DESTRUCTION_HANDLE_STATUS_COMPLETED :
314 LTTNG_DESTRUCTION_HANDLE_STATUS_TIMEOUT;
315end:
316 return status;
317}
318
319enum lttng_destruction_handle_status
320lttng_destruction_handle_get_rotation_state(
321 const struct lttng_destruction_handle *handle,
322 enum lttng_rotation_state *rotation_state)
323{
324 enum lttng_destruction_handle_status status =
325 LTTNG_DESTRUCTION_HANDLE_STATUS_OK;
326
0f7e4628
JG
327 if (!handle || !rotation_state) {
328 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
329 goto end;
330 }
331
3e3665b8
JG
332 if (!handle->rotation_state.is_set) {
333 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
334 goto end;
335 }
336 *rotation_state = handle->rotation_state.value;
337end:
338 return status;
339}
340
341enum lttng_destruction_handle_status
342lttng_destruction_handle_get_archive_location(
343 const struct lttng_destruction_handle *handle,
344 const struct lttng_trace_archive_location **location)
345{
346 enum lttng_destruction_handle_status status =
347 LTTNG_DESTRUCTION_HANDLE_STATUS_OK;
348
0f7e4628
JG
349 if (!handle || !location) {
350 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
351 goto end;
352 }
353
3e3665b8
JG
354 if (!handle->location) {
355 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
356 goto end;
357 }
358 *location = handle->location;
359end:
360 return status;
361}
362
363enum lttng_destruction_handle_status
364lttng_destruction_handle_get_result(
365 const struct lttng_destruction_handle *handle,
366 enum lttng_error_code *result)
367{
368 enum lttng_destruction_handle_status status =
369 LTTNG_DESTRUCTION_HANDLE_STATUS_OK;
370
0f7e4628
JG
371 if (!handle || !result) {
372 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
373 goto end;
374 }
375
3e3665b8
JG
376 if (!handle->destruction_return_code.is_set) {
377 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
378 goto end;
379 }
380 *result = handle->destruction_return_code.value;
381end:
382 return status;
383}
384
385enum lttng_error_code lttng_destroy_session_ext(const char *session_name,
386 struct lttng_destruction_handle **_handle)
387{
388 int ret;
389 ssize_t comm_ret;
390 enum lttng_error_code ret_code = LTTNG_OK;
96c5e4c3 391 struct lttcomm_session_msg lsm = {
3e3665b8
JG
392 .cmd_type = LTTNG_DESTROY_SESSION,
393 };
394 int sessiond_socket = -1;
395 struct lttng_destruction_handle *handle = NULL;
396
1e2bb0af 397 if (!session_name) {
0f7e4628
JG
398 ret_code = LTTNG_ERR_INVALID;
399 goto error;
400 }
401
3e3665b8
JG
402 ret = lttng_strncpy(lsm.session.name, session_name,
403 sizeof(lsm.session.name));
404 if (ret) {
405 ret_code = LTTNG_ERR_INVALID;
406 goto error;
407 }
408
409 ret = connect_sessiond();
410 if (ret < 0) {
411 ret_code = LTTNG_ERR_NO_SESSIOND;
412 goto error;
413 } else {
414 sessiond_socket = ret;
415 }
416
417 handle = lttng_destruction_handle_create(sessiond_socket);
418 if (!handle) {
419 ret_code = LTTNG_ERR_NOMEM;
420 goto error;
421 }
422
ee98f686 423 comm_ret = lttcomm_send_creds_unix_sock(sessiond_socket, &lsm, sizeof(lsm));
3e3665b8
JG
424 if (comm_ret < 0) {
425 ret_code = LTTNG_ERR_FATAL;
426 goto error;
427 }
428 sessiond_socket = -1;
429
430 /* Transfer the handle to the caller. */
431 if (_handle) {
432 *_handle = handle;
433 handle = NULL;
434 }
435error:
436 if (sessiond_socket >= 0) {
437 ret = close(sessiond_socket);
b6d816c5
JG
438 if (ret < 0) {
439 PERROR("Failed to close the LTTng session daemon connection socket");
440 }
3e3665b8
JG
441 }
442 if (handle) {
443 lttng_destruction_handle_destroy(handle);
444 }
445 return ret_code;
446}
This page took 0.0438539999999999 seconds and 4 git commands to generate.