Fix: enable-consumer for all domains missing dir
[lttng-tools.git] / src / bin / lttng-consumerd / lttng-consumerd.c
1 /*
2 * Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
3 * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License, version 2 only,
7 * as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #define _GNU_SOURCE
20 #include <fcntl.h>
21 #include <getopt.h>
22 #include <grp.h>
23 #include <limits.h>
24 #include <pthread.h>
25 #include <signal.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/ipc.h>
30 #include <sys/resource.h>
31 #include <sys/shm.h>
32 #include <sys/socket.h>
33 #include <sys/stat.h>
34 #include <sys/types.h>
35 #include <urcu/list.h>
36 #include <poll.h>
37 #include <unistd.h>
38 #include <sys/mman.h>
39 #include <assert.h>
40 #include <config.h>
41 #include <urcu/compiler.h>
42 #include <ulimit.h>
43
44 #include <common/defaults.h>
45 #include <common/common.h>
46 #include <common/consumer.h>
47 #include <common/compat/poll.h>
48 #include <common/sessiond-comm/sessiond-comm.h>
49
50 #include "lttng-consumerd.h"
51
52 /* TODO : support UST (all direct kernel-ctl accesses). */
53
54 /* the two threads (receive fd, poll and metadata) */
55 static pthread_t data_thread, metadata_thread, sessiond_thread;
56
57 /* to count the number of times the user pressed ctrl+c */
58 static int sigintcount = 0;
59
60 /* Argument variables */
61 int lttng_opt_quiet; /* not static in error.h */
62 int lttng_opt_verbose; /* not static in error.h */
63 static int opt_daemon;
64 static const char *progname;
65 static char command_sock_path[PATH_MAX]; /* Global command socket path */
66 static char error_sock_path[PATH_MAX]; /* Global error path */
67 static enum lttng_consumer_type opt_type = LTTNG_CONSUMER_KERNEL;
68
69 /* the liblttngconsumerd context */
70 static struct lttng_consumer_local_data *ctx;
71
72 /*
73 * Signal handler for the daemon
74 */
75 static void sighandler(int sig)
76 {
77 if (sig == SIGINT && sigintcount++ == 0) {
78 DBG("ignoring first SIGINT");
79 return;
80 }
81
82 /*
83 * Ignore SIGPIPE because it should not stop the consumer whenever a
84 * SIGPIPE is catched through a FD operation.
85 */
86 if (sig == SIGPIPE) {
87 return;
88 }
89
90 lttng_consumer_should_exit(ctx);
91 }
92
93 /*
94 * Setup signal handler for :
95 * SIGINT, SIGTERM, SIGPIPE
96 */
97 static int set_signal_handler(void)
98 {
99 int ret = 0;
100 struct sigaction sa;
101 sigset_t sigset;
102
103 if ((ret = sigemptyset(&sigset)) < 0) {
104 perror("sigemptyset");
105 return ret;
106 }
107
108 sa.sa_handler = sighandler;
109 sa.sa_mask = sigset;
110 sa.sa_flags = 0;
111 if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
112 perror("sigaction");
113 return ret;
114 }
115
116 if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
117 perror("sigaction");
118 return ret;
119 }
120
121 if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
122 perror("sigaction");
123 return ret;
124 }
125
126 return ret;
127 }
128
129 /*
130 * Usage function on stream file.
131 */
132 static void usage(FILE *fp)
133 {
134 fprintf(fp, "Usage: %s OPTIONS\n\nOptions:\n", progname);
135 fprintf(fp, " -h, --help "
136 "Display this usage.\n");
137 fprintf(fp, " -c, --consumerd-cmd-sock PATH "
138 "Specify path for the command socket\n");
139 fprintf(fp, " -e, --consumerd-err-sock PATH "
140 "Specify path for the error socket\n");
141 fprintf(fp, " -d, --daemonize "
142 "Start as a daemon.\n");
143 fprintf(fp, " -q, --quiet "
144 "No output at all.\n");
145 fprintf(fp, " -v, --verbose "
146 "Verbose mode. Activate DBG() macro.\n");
147 fprintf(fp, " -V, --version "
148 "Show version number.\n");
149 fprintf(fp, " -k, --kernel "
150 "Consumer kernel buffers (default).\n");
151 fprintf(fp, " -u, --ust "
152 "Consumer UST buffers.%s\n",
153 #ifdef HAVE_LIBLTTNG_UST_CTL
154 ""
155 #else
156 " (support not compiled in)"
157 #endif
158 );
159 }
160
161 /*
162 * daemon argument parsing
163 */
164 static void parse_args(int argc, char **argv)
165 {
166 int c;
167
168 static struct option long_options[] = {
169 { "consumerd-cmd-sock", 1, 0, 'c' },
170 { "consumerd-err-sock", 1, 0, 'e' },
171 { "daemonize", 0, 0, 'd' },
172 { "help", 0, 0, 'h' },
173 { "quiet", 0, 0, 'q' },
174 { "verbose", 0, 0, 'v' },
175 { "version", 0, 0, 'V' },
176 { "kernel", 0, 0, 'k' },
177 #ifdef HAVE_LIBLTTNG_UST_CTL
178 { "ust", 0, 0, 'u' },
179 #endif
180 { NULL, 0, 0, 0 }
181 };
182
183 while (1) {
184 int option_index = 0;
185 c = getopt_long(argc, argv, "dhqvVku" "c:e:", long_options, &option_index);
186 if (c == -1) {
187 break;
188 }
189
190 switch (c) {
191 case 0:
192 fprintf(stderr, "option %s", long_options[option_index].name);
193 if (optarg) {
194 fprintf(stderr, " with arg %s\n", optarg);
195 }
196 break;
197 case 'c':
198 snprintf(command_sock_path, PATH_MAX, "%s", optarg);
199 break;
200 case 'e':
201 snprintf(error_sock_path, PATH_MAX, "%s", optarg);
202 break;
203 case 'd':
204 opt_daemon = 1;
205 break;
206 case 'h':
207 usage(stdout);
208 exit(EXIT_SUCCESS);
209 case 'q':
210 lttng_opt_quiet = 1;
211 break;
212 case 'v':
213 lttng_opt_verbose = 1;
214 break;
215 case 'V':
216 fprintf(stdout, "%s\n", VERSION);
217 exit(EXIT_SUCCESS);
218 case 'k':
219 opt_type = LTTNG_CONSUMER_KERNEL;
220 break;
221 #ifdef HAVE_LIBLTTNG_UST_CTL
222 case 'u':
223 # if (CAA_BITS_PER_LONG == 64)
224 opt_type = LTTNG_CONSUMER64_UST;
225 # elif (CAA_BITS_PER_LONG == 32)
226 opt_type = LTTNG_CONSUMER32_UST;
227 # else
228 # error "Unknown bitness"
229 # endif
230 break;
231 #endif
232 default:
233 usage(stderr);
234 exit(EXIT_FAILURE);
235 }
236 }
237 }
238
239 /*
240 * Set open files limit to unlimited. This daemon can open a large number of
241 * file descriptors in order to consumer multiple kernel traces.
242 */
243 static void set_ulimit(void)
244 {
245 int ret;
246 struct rlimit lim;
247
248 /* The kernel does not allowed an infinite limit for open files */
249 lim.rlim_cur = 65535;
250 lim.rlim_max = 65535;
251
252 ret = setrlimit(RLIMIT_NOFILE, &lim);
253 if (ret < 0) {
254 PERROR("failed to set open files limit");
255 }
256 }
257
258 /*
259 * main
260 */
261 int main(int argc, char **argv)
262 {
263 int ret = 0;
264 void *status;
265
266 /* Parse arguments */
267 progname = argv[0];
268 parse_args(argc, argv);
269
270 /* Daemonize */
271 if (opt_daemon) {
272 int i;
273
274 /*
275 * fork
276 * child: setsid, close FD 0, 1, 2, chdir /
277 * parent: exit (if fork is successful)
278 */
279 ret = daemon(0, 0);
280 if (ret < 0) {
281 PERROR("daemon");
282 goto error;
283 }
284 /*
285 * We are in the child. Make sure all other file
286 * descriptors are closed, in case we are called with
287 * more opened file descriptors than the standard ones.
288 */
289 for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
290 (void) close(i);
291 }
292 }
293
294 /* Set up max poll set size */
295 lttng_poll_set_max_size();
296
297 if (strlen(command_sock_path) == 0) {
298 switch (opt_type) {
299 case LTTNG_CONSUMER_KERNEL:
300 snprintf(command_sock_path, PATH_MAX, DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
301 DEFAULT_LTTNG_RUNDIR);
302 break;
303 case LTTNG_CONSUMER64_UST:
304 snprintf(command_sock_path, PATH_MAX,
305 DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
306 break;
307 case LTTNG_CONSUMER32_UST:
308 snprintf(command_sock_path, PATH_MAX,
309 DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
310 break;
311 default:
312 WARN("Unknown consumerd type");
313 goto error;
314 }
315 }
316
317 /* Init */
318 lttng_consumer_init();
319
320 if (!getuid()) {
321 /* Set limit for open files */
322 set_ulimit();
323 }
324
325 /* create the consumer instance with and assign the callbacks */
326 ctx = lttng_consumer_create(opt_type, lttng_consumer_read_subbuffer,
327 NULL, lttng_consumer_on_recv_stream, NULL);
328 if (ctx == NULL) {
329 goto error;
330 }
331
332 lttng_consumer_set_command_sock_path(ctx, command_sock_path);
333 if (strlen(error_sock_path) == 0) {
334 switch (opt_type) {
335 case LTTNG_CONSUMER_KERNEL:
336 snprintf(error_sock_path, PATH_MAX, DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
337 DEFAULT_LTTNG_RUNDIR);
338 break;
339 case LTTNG_CONSUMER64_UST:
340 snprintf(error_sock_path, PATH_MAX,
341 DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
342 break;
343 case LTTNG_CONSUMER32_UST:
344 snprintf(error_sock_path, PATH_MAX,
345 DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
346 break;
347 default:
348 WARN("Unknown consumerd type");
349 goto error;
350 }
351 }
352
353 if (set_signal_handler() < 0) {
354 goto error;
355 }
356
357 /* Connect to the socket created by lttng-sessiond to report errors */
358 DBG("Connecting to error socket %s", error_sock_path);
359 ret = lttcomm_connect_unix_sock(error_sock_path);
360 /* not a fatal error, but all communication with lttng-sessiond will fail */
361 if (ret < 0) {
362 WARN("Cannot connect to error socket (is lttng-sessiond started?)");
363 }
364 lttng_consumer_set_error_sock(ctx, ret);
365
366 /* Create thread to manage the polling/writing of trace metadata */
367 ret = pthread_create(&metadata_thread, NULL, consumer_thread_metadata_poll,
368 (void *) ctx);
369 if (ret != 0) {
370 perror("pthread_create");
371 goto error;
372 }
373
374 /* Create thread to manage the polling/writing of trace data */
375 ret = pthread_create(&data_thread, NULL, consumer_thread_data_poll,
376 (void *) ctx);
377 if (ret != 0) {
378 perror("pthread_create");
379 goto data_error;
380 }
381
382 /* Create the thread to manage the receive of fd */
383 ret = pthread_create(&sessiond_thread, NULL, consumer_thread_sessiond_poll,
384 (void *) ctx);
385 if (ret != 0) {
386 perror("pthread_create");
387 goto sessiond_error;
388 }
389
390 ret = pthread_join(sessiond_thread, &status);
391 if (ret != 0) {
392 perror("pthread_join");
393 goto error;
394 }
395
396 sessiond_error:
397 ret = pthread_join(data_thread, &status);
398 if (ret != 0) {
399 perror("pthread_join");
400 goto error;
401 }
402
403 data_error:
404 ret = pthread_join(metadata_thread, &status);
405 if (ret != 0) {
406 perror("pthread_join");
407 goto error;
408 }
409
410 if (!ret) {
411 ret = EXIT_SUCCESS;
412 lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_SUCCESS);
413 goto end;
414 }
415
416 error:
417 ret = EXIT_FAILURE;
418 lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_FAILURE);
419
420 end:
421 lttng_consumer_destroy(ctx);
422 lttng_consumer_cleanup();
423
424 return ret;
425 }
This page took 0.058507 seconds and 4 git commands to generate.