Add lttng_notification_channel_has_pending_notification()
[lttng-tools.git] / src / bin / lttng-sessiond / rotate.c
CommitLineData
db66e574
JD
1/*
2 * Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18#define _LGPL_SOURCE
19#include <lttng/trigger/trigger.h>
20#include <common/error.h>
21#include <common/config/session-config.h>
22#include <common/defaults.h>
23#include <common/utils.h>
24#include <common/futex.h>
25#include <common/align.h>
26#include <common/time.h>
27#include <common/hashtable/utils.h>
28#include <common/kernel-ctl/kernel-ctl.h>
29#include <sys/eventfd.h>
30#include <sys/stat.h>
31#include <time.h>
32#include <signal.h>
33#include <inttypes.h>
34
d88744a4
JD
35#include <lttng/rotate-internal.h>
36
db66e574
JD
37#include "session.h"
38#include "rotate.h"
39#include "rotation-thread.h"
40#include "lttng-sessiond.h"
41#include "health-sessiond.h"
42#include "cmd.h"
43#include "utils.h"
44
45#include <urcu.h>
46#include <urcu/list.h>
47#include <urcu/rculfhash.h>
48
49unsigned long hash_channel_key(struct rotation_channel_key *key)
50{
51 return hash_key_u64(&key->key, lttng_ht_seed) ^ hash_key_ulong(
52 (void *) (unsigned long) key->domain, lttng_ht_seed);
53}
54
5c408ad8
JD
55int rotate_add_channel_pending(uint64_t key, enum lttng_domain_type domain,
56 struct ltt_session *session)
57{
58 int ret;
59 struct rotation_channel_info *new_info;
60 struct rotation_channel_key channel_key = { .key = key,
61 .domain = domain };
62
63 new_info = zmalloc(sizeof(struct rotation_channel_info));
64 if (!new_info) {
65 goto error;
66 }
67
68 new_info->channel_key.key = key;
69 new_info->channel_key.domain = domain;
70 new_info->session_id = session->id;
71 cds_lfht_node_init(&new_info->rotate_channels_ht_node);
72
73 session->nr_chan_rotate_pending++;
74 cds_lfht_add(channel_pending_rotate_ht,
75 hash_channel_key(&channel_key),
76 &new_info->rotate_channels_ht_node);
77
78 ret = 0;
79 goto end;
80
81error:
82 ret = -1;
83end:
84 return ret;
85}
86
db66e574
JD
87/* The session's lock must be held by the caller. */
88static
89int session_rename_chunk(struct ltt_session *session, char *current_path,
90 char *new_path)
91{
92 int ret;
93 struct consumer_socket *socket;
94 struct consumer_output *output;
95 struct lttng_ht_iter iter;
96 uid_t uid;
97 gid_t gid;
98
99 DBG("Renaming session chunk path of session \"%s\" from %s to %s",
100 session->name, current_path, new_path);
101
102 /*
103 * Either one of the sessions is enough to find the consumer_output
104 * and uid/gid.
105 */
106 if (session->kernel_session) {
107 output = session->kernel_session->consumer;
108 uid = session->kernel_session->uid;
109 gid = session->kernel_session->gid;
110 } else if (session->ust_session) {
111 output = session->ust_session->consumer;
112 uid = session->ust_session->uid;
113 gid = session->ust_session->gid;
114 } else {
115 assert(0);
116 }
117
118 if (!output || !output->socks) {
119 ERR("No consumer output found for session \"%s\"",
120 session->name);
121 ret = -1;
122 goto end;
123 }
124
125 rcu_read_lock();
126 /*
127 * We have to iterate to find a socket, but we only need to send the
128 * rename command to one consumer, so we break after the first one.
129 */
130 cds_lfht_for_each_entry(output->socks->ht, &iter.iter, socket, node.node) {
131 pthread_mutex_lock(socket->lock);
132 ret = consumer_rotate_rename(socket, session->id, output,
133 current_path, new_path, uid, gid);
134 pthread_mutex_unlock(socket->lock);
135 if (ret) {
136 ret = -1;
137 goto end_unlock;
138 }
139 break;
140 }
141
142 ret = 0;
143
144end_unlock:
145 rcu_read_unlock();
146end:
147 return ret;
148}
149
150/* The session's lock must be held by the caller. */
151static
152int rename_first_chunk(struct ltt_session *session,
153 struct consumer_output *consumer, char *new_path)
154{
155 int ret;
156 char current_full_path[LTTNG_PATH_MAX], new_full_path[LTTNG_PATH_MAX];
157
158 /* Current domain path: <session>/kernel */
159 if (session->net_handle > 0) {
160 ret = snprintf(current_full_path, sizeof(current_full_path), "%s/%s",
161 consumer->dst.net.base_dir, consumer->subdir);
162 if (ret < 0 || ret >= sizeof(current_full_path)) {
163 ERR("Failed to initialize current full path while renaming first rotation chunk of session \"%s\"",
164 session->name);
165 ret = -1;
166 goto error;
167 }
168 } else {
169 ret = snprintf(current_full_path, sizeof(current_full_path), "%s/%s",
170 consumer->dst.session_root_path, consumer->subdir);
171 if (ret < 0 || ret >= sizeof(current_full_path)) {
172 ERR("Failed to initialize current full path while renaming first rotation chunk of session \"%s\"",
173 session->name);
174 ret = -1;
175 goto error;
176 }
177 }
178 /* New domain path: <session>/<start-date>-<end-date>-<rotate-count>/kernel */
179 ret = snprintf(new_full_path, sizeof(new_full_path), "%s/%s",
180 new_path, consumer->subdir);
181 if (ret < 0 || ret >= sizeof(new_full_path)) {
182 ERR("Failed to initialize new full path while renaming first rotation chunk of session \"%s\"",
183 session->name);
184 ret = -1;
185 goto error;
186 }
187 /*
188 * Move the per-domain fcurrenter inside the first rotation
189 * fcurrenter.
190 */
191 ret = session_rename_chunk(session, current_full_path, new_full_path);
192 if (ret < 0) {
193 ret = -LTTNG_ERR_UNK;
194 goto error;
195 }
196
197 ret = 0;
198
199error:
200 return ret;
201}
202
203/*
204 * Rename a chunk folder after a rotation is complete.
205 * session_lock_list and session lock must be held.
206 *
207 * Returns 0 on success, a negative value on error.
208 */
209int rename_complete_chunk(struct ltt_session *session, time_t ts)
210{
211 struct tm *timeinfo;
db66e574 212 char new_path[LTTNG_PATH_MAX];
fc58be13 213 char datetime[21], start_datetime[21];
db66e574
JD
214 int ret;
215 size_t strf_ret;
216
217 DBG("Renaming completed chunk for session %s", session->name);
218 timeinfo = localtime(&ts);
219 if (!timeinfo) {
220 ERR("Failed to retrieve local time while renaming completed chunk");
221 ret = -1;
222 goto end;
223 }
fc58be13
JD
224
225 strf_ret = strftime(datetime, sizeof(datetime), "%Y%m%dT%H%M%S%z",
db66e574
JD
226 timeinfo);
227 if (strf_ret == 0) {
228 ERR("Failed to format timestamp while renaming completed session chunk");
229 ret = -1;
230 goto end;
231 }
232
233 if (session->rotate_count == 1) {
fc58be13 234 char start_time[21];
db66e574
JD
235
236 timeinfo = localtime(&session->last_chunk_start_ts);
237 if (!timeinfo) {
238 ERR("Failed to retrieve local time while renaming completed chunk");
239 ret = -1;
240 goto end;
241 }
242
243 strf_ret = strftime(start_time, sizeof(start_time),
fc58be13 244 "%Y%m%dT%H%M%S%z", timeinfo);
db66e574
JD
245 if (strf_ret == 0) {
246 ERR("Failed to format timestamp while renaming completed session chunk");
247 ret = -1;
248 goto end;
249 }
250
251 /*
252 * On the first rotation, the current_rotate_path is the
253 * session_root_path, so we need to create the chunk folder
254 * and move the domain-specific folders inside it.
255 */
256 ret = snprintf(new_path, sizeof(new_path), "%s/%s-%s-%" PRIu64,
257 session->rotation_chunk.current_rotate_path,
258 start_time,
259 datetime, session->rotate_count);
260 if (ret < 0 || ret >= sizeof(new_path)) {
261 ERR("Failed to format new chunk path while renaming session \"%s\"'s first chunk",
262 session->name);
263 ret = -1;
264 goto end;
265 }
266
267 if (session->kernel_session) {
268 ret = rename_first_chunk(session,
269 session->kernel_session->consumer,
270 new_path);
271 if (ret) {
272 ERR("Failed to rename kernel session trace folder to %s", new_path);
273 /*
274 * This is not a fatal error for the rotation
275 * thread, we just need to inform the client
276 * that a problem occurred with the rotation.
277 * Returning 0, same for the other errors
278 * below.
279 */
280 ret = 0;
281 goto error;
282 }
283 }
284 if (session->ust_session) {
285 ret = rename_first_chunk(session,
286 session->ust_session->consumer,
287 new_path);
288 if (ret) {
289 ERR("Failed to rename userspace session trace folder to %s", new_path);
290 ret = 0;
291 goto error;
292 }
293 }
294 } else {
295 /*
296 * After the first rotation, all the trace data is already in
297 * its own chunk folder, we just need to append the suffix.
298 */
299 /* Recreate the session->rotation_chunk.current_rotate_path */
300 timeinfo = localtime(&session->last_chunk_start_ts);
301 if (!timeinfo) {
302 ERR("Failed to retrieve local time while renaming completed chunk");
303 ret = -1;
304 goto end;
305 }
fc58be13
JD
306 strf_ret = strftime(start_datetime, sizeof(start_datetime),
307 "%Y%m%dT%H%M%S%z", timeinfo);
db66e574
JD
308 if (!strf_ret) {
309 ERR("Failed to format timestamp while renaming completed session chunk");
310 ret = -1;
311 goto end;
312 }
313 ret = snprintf(new_path, sizeof(new_path), "%s/%s-%s-%" PRIu64,
314 session_get_base_path(session),
315 start_datetime,
316 datetime, session->rotate_count);
317 if (ret < 0 || ret >= sizeof(new_path)) {
318 ERR("Failed to format new chunk path while renaming chunk of session \"%s\"",
319 session->name);
320 ret = -1;
321 goto error;
322 }
323 ret = session_rename_chunk(session,
324 session->rotation_chunk.current_rotate_path,
325 new_path);
326 if (ret) {
327 ERR("Failed to rename session trace folder from %s to %s",
328 session->rotation_chunk.current_rotate_path,
329 new_path);
330 ret = 0;
331 goto error;
332 }
333 }
334
335 /*
336 * Store the path where the readable chunk is. This path is valid
337 * and can be queried by the client with rotate_pending until the next
338 * rotation is started.
339 */
340 ret = lttng_strncpy(session->rotation_chunk.current_rotate_path,
341 new_path,
342 sizeof(session->rotation_chunk.current_rotate_path));
343 if (ret) {
344 ERR("Failed the current chunk's path of session \"%s\"",
345 session->name);
346 ret = -1;
347 goto error;
348 }
349
350 goto end;
351
352error:
d68c9a04 353 session->rotation_state = LTTNG_ROTATION_STATE_ERROR;
db66e574
JD
354end:
355 return ret;
356}
d88744a4
JD
357
358int relay_rotate_pending(struct ltt_session *session, uint64_t chunk_id)
359{
360 int ret;
361 struct consumer_socket *socket;
362 struct consumer_output *output;
363 struct lttng_ht_iter iter;
364
365 /*
366 * Either one of the sessions is enough to find the consumer_output
367 * and uid/gid.
368 */
369 if (session->kernel_session) {
370 output = session->kernel_session->consumer;
371 } else if (session->ust_session) {
372 output = session->ust_session->consumer;
373 } else {
374 assert(0);
375 }
376
377 if (!output || !output->socks) {
378 ERR("No consumer output found");
379 ret = -1;
380 goto end;
381 }
382
383 ret = -1;
384
385 rcu_read_lock();
386 /*
387 * We have to iterate to find a socket, but we only need to send the
388 * rotate pending command to one consumer, so we break after the first
389 * one.
390 */
391 cds_lfht_for_each_entry(output->socks->ht, &iter.iter, socket,
392 node.node) {
393 pthread_mutex_lock(socket->lock);
394 ret = consumer_rotate_pending_relay(socket, output, session->id,
395 chunk_id);
396 pthread_mutex_unlock(socket->lock);
397 break;
398 }
399 rcu_read_unlock();
400
401end:
402 return ret;
403}
This page took 0.060423 seconds and 5 git commands to generate.