aeeece7e316abad31884c5498667b1fb09f60f3c
[lttng-tools.git] / src / lib / lttng-ctl / destruction-handle.c
1 /*
2 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * SPDX-License-Identifier: LGPL-2.1-only
5 *
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
24 enum 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
32 struct 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
46 void 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 }
59 }
60 lttng_poll_clean(&handle->communication.events);
61 lttng_dynamic_buffer_reset(&handle->communication.buffer);
62 lttng_trace_archive_location_destroy(handle->location);
63 free(handle);
64 }
65
66 static
67 struct 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);
85 if (ret) {
86 goto error;
87 }
88
89 handle->communication.bytes_left_to_receive =
90 sizeof(struct lttcomm_lttng_msg);
91 handle->communication.state = COMMUNICATION_STATE_RECEIVE_LTTNG_MSG;
92 end:
93 return handle;
94 error:
95 lttng_destruction_handle_destroy(handle);
96 return NULL;
97 }
98
99 static
100 int 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
192 static
193 int 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 }
222 end:
223 return ret;
224 }
225
226 enum lttng_destruction_handle_status
227 lttng_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;
234 struct timespec initial_time;
235
236 if (!handle) {
237 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
238 goto end;
239 }
240
241 if (handle->communication.state == COMMUNICATION_STATE_ERROR) {
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 }
248 if (has_timeout) {
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;
255 }
256
257 while (handle->communication.state != COMMUNICATION_STATE_END &&
258 (time_left_ms || !has_timeout)) {
259 int ret;
260 uint32_t revents;
261 struct timespec current_time, diff;
262 unsigned long diff_ms;
263
264 ret = lttng_poll_wait(&handle->communication.events,
265 has_timeout ? time_left_ms : -1);
266 if (ret == 0) {
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;
315 end:
316 return status;
317 }
318
319 enum lttng_destruction_handle_status
320 lttng_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
327 if (!handle || !rotation_state) {
328 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
329 goto end;
330 }
331
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;
337 end:
338 return status;
339 }
340
341 enum lttng_destruction_handle_status
342 lttng_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
349 if (!handle || !location) {
350 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
351 goto end;
352 }
353
354 if (!handle->location) {
355 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
356 goto end;
357 }
358 *location = handle->location;
359 end:
360 return status;
361 }
362
363 enum lttng_destruction_handle_status
364 lttng_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
371 if (!handle || !result) {
372 status = LTTNG_DESTRUCTION_HANDLE_STATUS_INVALID;
373 goto end;
374 }
375
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;
381 end:
382 return status;
383 }
384
385 enum 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;
391 struct lttcomm_session_msg lsm = {
392 .cmd_type = LTTNG_DESTROY_SESSION,
393 };
394 int sessiond_socket = -1;
395 struct lttng_destruction_handle *handle = NULL;
396
397 if (!session_name) {
398 ret_code = LTTNG_ERR_INVALID;
399 goto error;
400 }
401
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
423 comm_ret = lttcomm_send_creds_unix_sock(sessiond_socket, &lsm, sizeof(lsm));
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 }
435 error:
436 if (sessiond_socket >= 0) {
437 ret = close(sessiond_socket);
438 if (ret < 0) {
439 PERROR("Failed to close the LTTng session daemon connection socket");
440 }
441 }
442 if (handle) {
443 lttng_destruction_handle_destroy(handle);
444 }
445 return ret_code;
446 }
This page took 0.058826 seconds and 3 git commands to generate.