sysdeps/unix/sysv/linux/mq_notify.c

   1 /* Copyright (C) 2004-2021 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contribute by Ulrich Drepper <drepper@redhat.com>, 2004.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library 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 GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <mqueue.h>
  23 #include <pthread.h>
  24 #include <signal.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sysdep.h>
  28 #include <unistd.h>
  29 #include <sys/socket.h>
  30 #include <not-cancel.h>
  31 #include <pthreadP.h>
  32
  33
  34 /* Defined in the kernel headers: */
  35 #define NOTIFY_COOKIE_LEN       32      /* Length of the cookie used.  */
  36 #define NOTIFY_WOKENUP          1       /* Code for notifcation.  */
  37 #define NOTIFY_REMOVED          2       /* Code for closed message queue
  38                                            of de-notifcation.  */
  39
  40
  41 /* Data structure for the queued notification requests.  */
  42 union notify_data
  43 {
  44   struct
  45   {
  46     void (*fct) (union sigval); /* The function to run.  */
  47     union sigval param;         /* The parameter to pass.  */
  48     pthread_attr_t *attr;       /* Attributes to create the thread with.  */
  49     /* NB: on 64-bit machines the struct as a size of 24 bytes.  Which means
  50        byte 31 can still be used for returning the status.  */
  51   };
  52   char raw[NOTIFY_COOKIE_LEN];
  53 };
  54
  55
  56 /* Keep track of the initialization.  */
  57 static pthread_once_t once = PTHREAD_ONCE_INIT;
  58
  59
  60 /* The netlink socket.  */
  61 static int netlink_socket = -1;
  62
  63
  64 /* Barrier used to make sure data passed to the new thread is not
  65    resused by the parent.  */
  66 static pthread_barrier_t notify_barrier;
  67
  68
  69 /* Modify the signal mask.  We move this into a separate function so
  70    that the stack space needed for sigset_t is not deducted from what
  71    the thread can use.  */
  72 static int
  73 __attribute__ ((noinline))
  74 change_sigmask (int how, sigset_t *oss)
  75 {
  76   sigset_t ss;
  77   sigfillset (&ss);
  78   return pthread_sigmask (how, &ss, oss);
  79 }
  80
  81
  82 /* The function used for the notification.  */
  83 static void *
  84 notification_function (void *arg)
  85 {
  86   /* Copy the function and parameter so that the parent thread can go
  87      on with its life.  */
  88   volatile union notify_data *data = (volatile union notify_data *) arg;
  89   void (*fct) (union sigval) = data->fct;
  90   union sigval param = data->param;
  91
  92   /* Let the parent go.  */
  93   (void) __pthread_barrier_wait (&notify_barrier);
  94
  95   /* Make the thread detached.  */
  96   (void) pthread_detach (pthread_self ());
  97
  98   /* The parent thread has all signals blocked.  This is probably a
  99      bit surprising for this thread.  So we unblock all of them.  */
 100   (void) change_sigmask (SIG_UNBLOCK, NULL);
 101
 102   /* Now run the user code.  */
 103   fct (param);
 104
 105   /* And we are done.  */
 106   return NULL;
 107 }
 108
 109
 110 /* Helper thread.  */
 111 static void *
 112 helper_thread (void *arg)
 113 {
 114   while (1)
 115     {
 116       union notify_data data;
 117
 118       ssize_t n = __recv (netlink_socket, &data, sizeof (data),
 119                           MSG_NOSIGNAL | MSG_WAITALL);
 120       if (n < NOTIFY_COOKIE_LEN)
 121         continue;
 122
 123       if (data.raw[NOTIFY_COOKIE_LEN - 1] == NOTIFY_WOKENUP)
 124         {
 125           /* Just create the thread as instructed.  There is no way to
 126              report a problem with creating a thread.  */
 127           pthread_t th;
 128           if (__builtin_expect (pthread_create (&th, data.attr,
 129                                                 notification_function, &data)
 130                                 == 0, 0))
 131             /* Since we passed a pointer to DATA to the new thread we have
 132                to wait until it is done with it.  */
 133             (void) __pthread_barrier_wait (&notify_barrier);
 134         }
 135       else if (data.raw[NOTIFY_COOKIE_LEN - 1] == NOTIFY_REMOVED)
 136         {
 137           /* The only state we keep is the copy of the thread attributes.  */
 138           pthread_attr_destroy (data.attr);
 139           free (data.attr);
 140         }
 141     }
 142   return NULL;
 143 }
 144
 145
 146 static void
 147 reset_once (void)
 148 {
 149   once = PTHREAD_ONCE_INIT;
 150 }
 151
 152
 153 static void
 154 init_mq_netlink (void)
 155 {
 156   /* This code might be called a second time after fork().  The file
 157      descriptor is inherited from the parent.  */
 158   if (netlink_socket == -1)
 159     {
 160       /* Just a normal netlink socket, not bound.  */
 161       netlink_socket = __socket (AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, 0);
 162       /* No need to do more if we have no socket.  */
 163       if (netlink_socket == -1)
 164         return;
 165     }
 166
 167   int err = 1;
 168
 169   /* Initialize the barrier.  */
 170   if (__builtin_expect (__pthread_barrier_init (&notify_barrier, NULL, 2) == 0,
 171                         0))
 172     {
 173       /* Create the helper thread.  */
 174       pthread_attr_t attr;
 175       (void) pthread_attr_init (&attr);
 176       (void) pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 177       /* We do not need much stack space, the bare minimum will be enough.  */
 178       (void) pthread_attr_setstacksize (&attr, __pthread_get_minstack (&attr));
 179
 180       /* Temporarily block all signals so that the newly created
 181          thread inherits the mask.  */
 182       sigset_t oss;
 183       int have_no_oss = change_sigmask (SIG_BLOCK, &oss);
 184
 185       pthread_t th;
 186       err = pthread_create (&th, &attr, helper_thread, NULL);
 187
 188       /* Reset the signal mask.  */
 189       if (!have_no_oss)
 190         pthread_sigmask (SIG_SETMASK, &oss, NULL);
 191
 192       (void) pthread_attr_destroy (&attr);
 193
 194       if (err == 0)
 195         {
 196           static int added_atfork;
 197
 198           if (added_atfork == 0
 199               && pthread_atfork (NULL, NULL, reset_once) != 0)
 200             {
 201               /* The child thread will call recv() which is a
 202                  cancellation point.  */
 203               (void) pthread_cancel (th);
 204               err = 1;
 205             }
 206           else
 207             added_atfork = 1;
 208         }
 209     }
 210
 211   if (err != 0)
 212     {
 213       __close_nocancel_nostatus (netlink_socket);
 214       netlink_socket = -1;
 215     }
 216 }
 217
 218
 219 /* Register notification upon message arrival to an empty message queue
 220    MQDES.  */
 221 int
 222 mq_notify (mqd_t mqdes, const struct sigevent *notification)
 223 {
 224   /* Make sure the type is correctly defined.  */
 225   assert (sizeof (union notify_data) == NOTIFY_COOKIE_LEN);
 226
 227   /* Special treatment needed for SIGEV_THREAD.  */
 228   if (notification == NULL || notification->sigev_notify != SIGEV_THREAD)
 229     return INLINE_SYSCALL (mq_notify, 2, mqdes, notification);
 230
 231   /* The kernel cannot directly start threads.  This will have to be
 232      done at userlevel.  Since we cannot start threads from signal
 233      handlers we have to create a dedicated thread which waits for
 234      notifications for arriving messages and creates threads in
 235      response.  */
 236
 237   /* Initialize only once.  */
 238   pthread_once (&once, init_mq_netlink);
 239
 240   /* If we cannot create the netlink socket we cannot provide
 241      SIGEV_THREAD support.  */
 242   if (__glibc_unlikely (netlink_socket == -1))
 243     {
 244       __set_errno (ENOSYS);
 245       return -1;
 246     }
 247
 248   /* Create the cookie.  It will hold almost all the state.  */
 249   union notify_data data;
 250   memset (&data, '\0', sizeof (data));
 251   data.fct = notification->sigev_notify_function;
 252   data.param = notification->sigev_value;
 253
 254   if (notification->sigev_notify_attributes != NULL)
 255     {
 256       /* The thread attribute has to be allocated separately.  */
 257       data.attr = (pthread_attr_t *) malloc (sizeof (pthread_attr_t));
 258       if (data.attr == NULL)
 259         return -1;
 260
 261       int ret = __pthread_attr_copy (data.attr,
 262                                      notification->sigev_notify_attributes);
 263       if (ret != 0)
 264         {
 265           free (data.attr);
 266           __set_errno (ret);
 267           return -1;
 268         }
 269     }
 270
 271   /* Construct the new request.  */
 272   struct sigevent se;
 273   se.sigev_notify = SIGEV_THREAD;
 274   se.sigev_signo = netlink_socket;
 275   se.sigev_value.sival_ptr = &data;
 276
 277   /* Tell the kernel.  */
 278   int retval = INLINE_SYSCALL (mq_notify, 2, mqdes, &se);
 279
 280   /* If it failed, free the allocated memory.  */
 281   if (retval != 0 && data.attr != NULL)
 282     {
 283       pthread_attr_destroy (data.attr);
 284       free (data.attr);
 285     }
 286
 287   return retval;
 288 }