src/bin/lttng-sessiond/thread-utils.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *                      Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *               2013 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License, version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include "lttng-sessiond.h"
  21 #include "utils.h"
  22 #include <common/utils.h>
  23 #include <pthread.h>
  24
  25 /*
  26  * Quit pipe for all threads. This permits a single cancellation point
  27  * for all threads when receiving an event on the pipe.
  28  */
  29 static int thread_quit_pipe[2] = { -1, -1 };
  30
  31 /*
  32  * Init thread quit pipe.
  33  *
  34  * Return -1 on error or 0 if all pipes are created.
  35  */
  36 static int __init_thread_quit_pipe(int *a_pipe)
  37 {
  38         int ret, i;
  39
  40         ret = pipe(a_pipe);
  41         if (ret < 0) {
  42                 PERROR("thread quit pipe");
  43                 goto error;
  44         }
  45
  46         for (i = 0; i < 2; i++) {
  47                 ret = fcntl(a_pipe[i], F_SETFD, FD_CLOEXEC);
  48                 if (ret < 0) {
  49                         PERROR("fcntl");
  50                         goto error;
  51                 }
  52         }
  53
  54 error:
  55         return ret;
  56 }
  57
  58 int sessiond_init_thread_quit_pipe(void)
  59 {
  60         return __init_thread_quit_pipe(thread_quit_pipe);
  61 }
  62
  63 int sessiond_check_thread_quit_pipe(int fd, uint32_t events)
  64 {
  65         return (fd == thread_quit_pipe[0] && (events & LPOLLIN));
  66 }
  67
  68 /*
  69  * Wait for a notification on the quit pipe (with a timeout).
  70  *
  71  * A timeout value of -1U means no timeout.
  72  *
  73  * Returns 1 if the caller should quit, 0 if the timeout was reached, and
  74  * -1 if an error was encountered.
  75  */
  76 int sessiond_wait_for_quit_pipe(int timeout_ms)
  77 {
  78         int ret;
  79         struct lttng_poll_event events;
  80
  81         ret = lttng_poll_create(&events, 1, LTTNG_CLOEXEC);
  82         if (ret < 0) {
  83                 PERROR("Failed to initialize poll/epoll set");
  84                 ret = -1;
  85                 goto end;
  86         }
  87         ret = lttng_poll_add(&events, thread_quit_pipe[0], LPOLLIN | LPOLLERR);
  88         if (ret < 0) {
  89                 PERROR("Failed to add file descriptor to poll/epoll set");
  90                 ret = -1;
  91                 goto end_clean_poll;
  92         }
  93         ret = lttng_poll_wait(&events, timeout_ms);
  94         if (ret > 0) {
  95                 /* Should quit. */
  96                 ret = 1;
  97         } else if (ret < 0 && errno != EINTR) {
  98                 /* Unknown error. */
  99                 PERROR("Failed to epoll()/poll() thread quit pipe");
 100                 ret = -1;
 101         } else {
 102                 /* Timeout reached. */
 103                 ret = 0;
 104         }
 105 end_clean_poll:
 106         lttng_poll_clean(&events);
 107 end:
 108         return ret;
 109 }
 110
 111 int sessiond_notify_quit_pipe(void)
 112 {
 113         return notify_thread_pipe(thread_quit_pipe[1]);
 114 }
 115
 116 void sessiond_close_quit_pipe(void)
 117 {
 118         utils_close_pipe(thread_quit_pipe);
 119 }
 120
 121 static
 122 int __sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size,
 123                 int *a_pipe)
 124 {
 125         int ret;
 126
 127         assert(events);
 128
 129         ret = lttng_poll_create(events, size, LTTNG_CLOEXEC);
 130         if (ret < 0) {
 131                 goto error;
 132         }
 133
 134         /* Add quit pipe */
 135         ret = lttng_poll_add(events, a_pipe[0], LPOLLIN | LPOLLERR);
 136         if (ret < 0) {
 137                 goto error;
 138         }
 139
 140         return 0;
 141
 142 error:
 143         return ret;
 144 }
 145
 146 /*
 147  * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
 148  */
 149 int sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size)
 150 {
 151         return __sessiond_set_thread_pollset(events, size, thread_quit_pipe);
 152 }