2 * Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
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.
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
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.
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>
37 #include "rotation-thread.h"
38 #include "lttng-sessiond.h"
39 #include "health-sessiond.h"
43 #include <urcu/list.h>
44 #include <urcu/rculfhash.h>
46 unsigned long hash_channel_key(struct rotation_channel_key
*key
)
48 return hash_key_u64(&key
->key
, lttng_ht_seed
) ^ hash_key_ulong(
49 (void *) (unsigned long) key
->domain
, lttng_ht_seed
);
52 int rotate_add_channel_pending(uint64_t key
, enum lttng_domain_type domain
,
53 struct ltt_session
*session
)
56 struct rotation_channel_info
*new_info
;
57 struct rotation_channel_key channel_key
= { .key
= key
,
60 new_info
= zmalloc(sizeof(struct rotation_channel_info
));
65 new_info
->channel_key
.key
= key
;
66 new_info
->channel_key
.domain
= domain
;
67 new_info
->session_id
= session
->id
;
68 cds_lfht_node_init(&new_info
->rotate_channels_ht_node
);
70 session
->nr_chan_rotate_pending
++;
71 cds_lfht_add(channel_pending_rotate_ht
,
72 hash_channel_key(&channel_key
),
73 &new_info
->rotate_channels_ht_node
);
84 int session_rename_chunk(struct ltt_session
*session
, char *current_path
,
88 struct consumer_socket
*socket
;
89 struct consumer_output
*output
;
90 struct lttng_ht_iter iter
;
95 * Either one of the sessions is enough to find the consumer_output
98 if (session
->kernel_session
) {
99 output
= session
->kernel_session
->consumer
;
100 uid
= session
->kernel_session
->uid
;
101 gid
= session
->kernel_session
->gid
;
102 } else if (session
->ust_session
) {
103 output
= session
->ust_session
->consumer
;
104 uid
= session
->ust_session
->uid
;
105 gid
= session
->ust_session
->gid
;
110 if (!output
|| !output
->socks
) {
111 ERR("No consumer output found");
118 * We have to iterate to find a socket, but we only need to send the
119 * rename command to one consumer, so we break after the first one.
121 cds_lfht_for_each_entry(output
->socks
->ht
, &iter
.iter
, socket
, node
.node
) {
122 pthread_mutex_lock(socket
->lock
);
123 ret
= consumer_rotate_rename(socket
, session
->id
, output
,
124 current_path
, new_path
, uid
, gid
);
125 pthread_mutex_unlock(socket
->lock
);
127 ERR("Consumer rename chunk");
143 int rename_first_chunk(struct ltt_session
*session
,
144 struct consumer_output
*consumer
, char *new_path
)
147 char *tmppath
= NULL
, *tmppath2
= NULL
;
149 tmppath
= zmalloc(PATH_MAX
* sizeof(char));
151 ret
= -LTTNG_ERR_NOMEM
;
154 tmppath2
= zmalloc(PATH_MAX
* sizeof(char));
156 ret
= -LTTNG_ERR_NOMEM
;
160 /* Current domain path: <session>/kernel */
161 if (session
->net_handle
> 0) {
162 snprintf(tmppath
, PATH_MAX
, "%s/%s",
163 consumer
->dst
.net
.base_dir
, consumer
->subdir
);
165 snprintf(tmppath
, PATH_MAX
, "%s/%s",
166 consumer
->dst
.session_root_path
, consumer
->subdir
);
168 /* New domain path: <session>/<start-date>-<end-date>-<rotate-count>/kernel */
169 snprintf(tmppath2
, PATH_MAX
, "%s/%s",
170 new_path
, consumer
->subdir
);
172 * Move the per-domain folder inside the first rotation
175 ret
= session_rename_chunk(session
, tmppath
, tmppath2
);
177 ERR("Rename first trace directory");
178 ret
= -LTTNG_ERR_ROTATE_NO_DATA
;
191 int rename_complete_chunk(struct ltt_session
*session
, time_t ts
)
195 char *new_path
= NULL
;
198 timeinfo
= localtime(&ts
);
199 strftime(datetime
, sizeof(datetime
), "%Y%m%d-%H%M%S", timeinfo
);
201 new_path
= zmalloc(PATH_MAX
* sizeof(char));
203 session
->rotate_status
= LTTNG_ROTATE_ERROR
;
204 ERR("Alloc new_path");
209 if (session
->rotate_count
== 1) {
212 timeinfo
= localtime(&session
->last_chunk_start_ts
);
213 strftime(start_time
, sizeof(start_time
), "%Y%m%d-%H%M%S", timeinfo
);
216 * On the first rotation, the current_rotate_path is the
217 * session_root_path, so we need to create the chunk folder
218 * and move the domain-specific folders inside it.
220 snprintf(new_path
, PATH_MAX
, "%s/%s-%s-%" PRIu64
,
221 session
->rotation_chunk
.current_rotate_path
,
223 datetime
, session
->rotate_count
);
225 if (session
->kernel_session
) {
226 fprintf(stderr
, "rename %s/kernel to %s\n",
227 session
->rotation_chunk
.current_rotate_path
,
229 ret
= rename_first_chunk(session
,
230 session
->kernel_session
->consumer
,
233 ERR("Rename kernel session");
235 * This is not a fatal error for the rotation
236 * thread, we just need to inform the client
237 * that a problem occurred with the rotation.
238 * Returning 0, same for the other errors
245 if (session
->ust_session
) {
246 fprintf(stderr
, "rename %s/ust to %s\n",
247 session
->rotation_chunk
.current_rotate_path
,
249 ret
= rename_first_chunk(session
,
250 session
->ust_session
->consumer
,
253 ERR("Rename ust session");
260 * After the first rotation, all the trace data is already in
261 * its own chunk folder, we just need to append the suffix.
263 snprintf(new_path
, PATH_MAX
, "%s%s-%" PRIu64
,
264 session
->rotation_chunk
.current_rotate_path
,
265 datetime
, session
->rotate_count
);
267 fprintf(stderr
, "rename %s to %s\n",
268 session
->rotation_chunk
.current_rotate_path
,
271 ret
= session_rename_chunk(session
,
272 session
->rotation_chunk
.current_rotate_path
,
275 ERR("Session rename");
282 * Store the path where the readable chunk is. This path is valid
283 * and can be queried by the client with rotate_pending until the next
284 * rotation is started.
286 snprintf(session
->rotation_chunk
.current_rotate_path
, PATH_MAX
,
292 session
->rotate_status
= LTTNG_ROTATE_ERROR
;
298 int relay_rotate_pending(struct ltt_session
*session
, uint64_t chunk_id
)
301 struct consumer_socket
*socket
;
302 struct consumer_output
*output
;
303 struct lttng_ht_iter iter
;
306 * Either one of the sessions is enough to find the consumer_output
309 if (session
->kernel_session
) {
310 output
= session
->kernel_session
->consumer
;
311 } else if (session
->ust_session
) {
312 output
= session
->ust_session
->consumer
;
317 if (!output
|| !output
->socks
) {
318 ERR("No consumer output found");
327 * We have to iterate to find a socket, but we only need to send the
328 * rotate pending command to one consumer, so we break after the first
331 cds_lfht_for_each_entry(output
->socks
->ht
, &iter
.iter
, socket
, node
.node
) {
332 pthread_mutex_lock(socket
->lock
);
333 ret
= consumer_rotate_pending_relay(socket
, output
, session
->id
,
335 pthread_mutex_unlock(socket
->lock
);