bcd0b828dcedc715712dbf06b22767ffef19fc2d
[deliverable/lttng-tools.git] / src / bin / lttng-sessiond / rotate.c
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
35 #include "session.h"
36 #include "rotate.h"
37 #include "rotation-thread.h"
38 #include "lttng-sessiond.h"
39 #include "health-sessiond.h"
40 #include "cmd.h"
41
42 #include <urcu.h>
43 #include <urcu/list.h>
44 #include <urcu/rculfhash.h>
45
46 unsigned long hash_channel_key(struct rotation_channel_key *key)
47 {
48 return hash_key_u64(&key->key, lttng_ht_seed) ^ hash_key_ulong(
49 (void *) (unsigned long) key->domain, lttng_ht_seed);
50 }
51
52 int rotate_add_channel_pending(uint64_t key, enum lttng_domain_type domain,
53 struct ltt_session *session)
54 {
55 int ret;
56 struct rotation_channel_info *new_info;
57 struct rotation_channel_key channel_key = { .key = key,
58 .domain = domain };
59
60 new_info = zmalloc(sizeof(struct rotation_channel_info));
61 if (!new_info) {
62 goto error;
63 }
64
65 new_info->channel_key.key = key;
66 new_info->channel_key.domain = domain;
67 new_info->session = session;
68 cds_lfht_node_init(&new_info->rotate_channels_ht_node);
69
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);
74
75 ret = 0;
76 goto end;
77
78 error:
79 ret = -1;
80 end:
81 return ret;
82 }
83
84 int session_rename_chunk(struct ltt_session *session, char *current_path,
85 char *new_path, uint32_t create)
86 {
87 int ret;
88 struct consumer_socket *socket;
89 struct consumer_output *output;
90 struct lttng_ht_iter iter;
91 uid_t uid;
92 gid_t gid;
93
94 /*
95 * Either one of the sessions is enough to find the consumer_output
96 * and uid/gid.
97 */
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;
106 } else {
107 assert(0);
108 }
109
110 if (!output || !output->socks) {
111 ERR("No consumer output found");
112 ret = -1;
113 goto end;
114 }
115
116 rcu_read_lock();
117 /*
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.
120 */
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, create, uid, gid);
125 pthread_mutex_unlock(socket->lock);
126 if (ret) {
127 ERR("Consumer rename chunk");
128 ret = -1;
129 rcu_read_unlock();
130 goto end;
131 }
132 break;
133 }
134 rcu_read_unlock();
135
136 ret = 0;
137
138 end:
139 return ret;
140 }
141
142 static
143 int rename_first_chunk(struct ltt_session *session,
144 struct consumer_output *consumer, char *new_path)
145 {
146 int ret;
147 char *tmppath = NULL, *tmppath2 = NULL;
148
149 tmppath = zmalloc(PATH_MAX * sizeof(char));
150 if (!tmppath) {
151 ret = -LTTNG_ERR_NOMEM;
152 goto error;
153 }
154 tmppath2 = zmalloc(PATH_MAX * sizeof(char));
155 if (!tmppath2) {
156 ret = -LTTNG_ERR_NOMEM;
157 goto error;
158 }
159
160 /* Current domain path: <session>/kernel */
161 snprintf(tmppath, PATH_MAX, "%s/%s",
162 consumer->dst.session_root_path, consumer->subdir);
163 /* New domain path: <session>/<start-date>-<end-date>-<rotate-count>/kernel */
164 snprintf(tmppath2, PATH_MAX, "%s/%s",
165 new_path, consumer->subdir);
166 /*
167 * Move the per-domain folder inside the first rotation
168 * folder.
169 */
170 ret = session_rename_chunk(session, tmppath, tmppath2, 1);
171 if (ret < 0) {
172 PERROR("Rename first trace directory");
173 ret = -LTTNG_ERR_ROTATE_NO_DATA;
174 goto error;
175 }
176
177 ret = 0;
178
179 error:
180 free(tmppath);
181 free(tmppath2);
182
183 return ret;
184 }
185
186 int rename_complete_chunk(struct ltt_session *session, time_t ts)
187 {
188 struct tm *timeinfo;
189 char datetime[16];
190 char *new_path = NULL;
191 int ret;
192
193 /*
194 * TODO 2: on first rotate, the current_rotate_path is the session root
195 * path, so move the kernel/ and ust/ folders inside the
196 * "session->last_chunk_start_ts-now()"
197 */
198
199 timeinfo = localtime(&ts);
200 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
201
202 new_path = zmalloc(PATH_MAX * sizeof(char));
203 if (!new_path) {
204 ERR("Alloc new_path");
205 ret = -1;
206 goto end;
207 }
208
209 fprintf(stderr, "COUNT: %d\n", session->rotate_count);
210
211 if (session->rotate_count == 1) {
212 char start_time[16];
213
214 timeinfo = localtime(&session->last_chunk_start_ts);
215 strftime(start_time, sizeof(start_time), "%Y%m%d-%H%M%S", timeinfo);
216
217 /*
218 * On the first rotation, the current_rotate_path is the
219 * session_root_path, so we need to create the chunk folder
220 * and move the domain-specific folders inside it.
221 */
222 snprintf(new_path, PATH_MAX, "%s/%s-%s-%" PRIu64,
223 session->rotation_chunk.current_rotate_path,
224 start_time,
225 datetime, session->rotate_count);
226
227 if (session->kernel_session) {
228 fprintf(stderr, "rename %s/kernel to %s\n",
229 session->rotation_chunk.current_rotate_path,
230 new_path);
231 ret = rename_first_chunk(session,
232 session->kernel_session->consumer,
233 new_path);
234 if (ret) {
235 ERR("Rename kernel session");
236 ret = -1;
237 goto end;
238 }
239 }
240 if (session->ust_session) {
241 fprintf(stderr, "rename %s/kernel to %s\n",
242 session->rotation_chunk.current_rotate_path,
243 new_path);
244 ret = rename_first_chunk(session,
245 session->ust_session->consumer,
246 new_path);
247 if (ret) {
248 ERR("Rename ust session");
249 ret = -1;
250 goto end;
251 }
252 }
253 } else {
254 /*
255 * After the first rotation, all the trace data is already in
256 * its own chunk folder, we just need to append the suffix.
257 */
258 snprintf(new_path, PATH_MAX, "%s%s-%" PRIu64,
259 session->rotation_chunk.current_rotate_path,
260 datetime, session->rotate_count);
261
262 fprintf(stderr, "rename %s to %s\n",
263 session->rotation_chunk.current_rotate_path,
264 new_path);
265
266 ret = session_rename_chunk(session,
267 session->rotation_chunk.current_rotate_path,
268 new_path, 0);
269 if (ret) {
270 ERR("Session rename");
271 ret = -1;
272 goto end;
273 }
274 }
275
276 /*
277 * Store the path where the readable chunk is. This path is valid
278 * and can be queried by the client with rotate_pending until the next
279 * rotation is started.
280 */
281 snprintf(session->rotation_chunk.current_rotate_path, PATH_MAX,
282 "%s", new_path);
283 session->rotate_pending = 0;
284
285 end:
286 free(new_path);
287 return ret;
288 }
289
This page took 0.041257 seconds and 5 git commands to generate.