libpthread/nptl/sysdeps/unix/sysv/linux/timer_create.c

   1 /* Copyright (C) 2003,2004, 2007, 2009 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
   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 License as
   7    published by the Free Software Foundation; either version 2.1 of the
   8    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; see the file COPYING.LIB.  If
  17    not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include <errno.h>
  20 #include <pthread.h>
  21 #include <signal.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <sysdep.h>
  26 #include <bits/kernel-features.h>
  27 #include <internaltypes.h>
  28 #include <pthreadP.h>
  29 #include "kernel-posix-timers.h"
  30 #include "kernel-posix-cpu-timers.h"
  31
  32
  33 #ifdef __NR_timer_create
  34 # ifndef __ASSUME_POSIX_TIMERS
  35 static int compat_timer_create (clockid_t clock_id, struct sigevent *evp,
  36                                 timer_t *timerid);
  37 #  define timer_create static compat_timer_create
  38 #  include <nptl/sysdeps/pthread/timer_create.c>
  39 #  undef timer_create
  40
  41 /* Nonzero if the system calls are not available.  */
  42 int __no_posix_timers attribute_hidden;
  43 # endif
  44
  45 # ifdef timer_create_alias
  46 #  define timer_create timer_create_alias
  47 # endif
  48
  49
  50 int
  51 timer_create (
  52      clockid_t clock_id,
  53      struct sigevent *evp,
  54      timer_t *timerid)
  55 {
  56 # undef timer_create
  57 # ifndef __ASSUME_POSIX_TIMERS
  58   if  (__no_posix_timers >= 0)
  59 # endif
  60     {
  61       clockid_t syscall_clockid = (clock_id == CLOCK_PROCESS_CPUTIME_ID
  62                                    ? MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED)
  63                                    : clock_id == CLOCK_THREAD_CPUTIME_ID
  64                                    ? MAKE_THREAD_CPUCLOCK (0, CPUCLOCK_SCHED)
  65                                    : clock_id);
  66
  67       /* If the user wants notification via a thread we need to handle
  68          this special.  */
  69       if (evp == NULL
  70           || __builtin_expect (evp->sigev_notify != SIGEV_THREAD, 1))
  71         {
  72           struct sigevent local_evp;
  73
  74           /* We avoid allocating too much memory by basically
  75              using struct timer as a derived class with the
  76              first two elements being in the superclass.  We only
  77              need these two elements here.  */
  78           struct timer *newp = (struct timer *) malloc (offsetof (struct timer,
  79                                                                   thrfunc));
  80           if (newp == NULL)
  81             /* No more memory.  */
  82             return -1;
  83
  84           if (evp == NULL)
  85             {
  86               /* The kernel has to pass up the timer ID which is a
  87                  userlevel object.  Therefore we cannot leave it up to
  88                  the kernel to determine it.  */
  89               local_evp.sigev_notify = SIGEV_SIGNAL;
  90               local_evp.sigev_signo = SIGALRM;
  91               local_evp.sigev_value.sival_ptr = newp;
  92
  93               evp = &local_evp;
  94             }
  95
  96           kernel_timer_t ktimerid;
  97           int retval = INLINE_SYSCALL (timer_create, 3, syscall_clockid, evp,
  98                                        &ktimerid);
  99
 100 # ifndef __ASSUME_POSIX_TIMERS
 101           if (retval != -1 || errno != ENOSYS)
 102 # endif
 103             {
 104 # ifndef __ASSUME_POSIX_TIMERS
 105               __no_posix_timers = 1;
 106 # endif
 107
 108               if (retval != -1)
 109                 {
 110                   newp->sigev_notify = (evp != NULL
 111                                         ? evp->sigev_notify : SIGEV_SIGNAL);
 112                   newp->ktimerid = ktimerid;
 113
 114                   *timerid = (timer_t) newp;
 115                 }
 116               else
 117                 {
 118                   /* Cannot allocate the timer, fail.  */
 119                   free (newp);
 120                   retval = -1;
 121                 }
 122
 123               return retval;
 124             }
 125
 126           free (newp);
 127
 128 # ifndef __ASSUME_POSIX_TIMERS
 129           /* When we come here the syscall does not exist.  Make sure we
 130              do not try to use it again.  */
 131           __no_posix_timers = -1;
 132 # endif
 133         }
 134       else
 135         {
 136 # ifndef __ASSUME_POSIX_TIMERS
 137           /* Make sure we have the necessary kernel support.  */
 138           if (__no_posix_timers == 0)
 139             {
 140               INTERNAL_SYSCALL_DECL (err);
 141               struct timespec ts;
 142               int res;
 143 #if defined(__UCLIBC_USE_TIME64__) && defined(__NR_clock_getres_time64)
 144               res = INTERNAL_SYSCALL (clock_getres_time64, err, 2,
 145                                       CLOCK_REALTIME, &ts);
 146 #else
 147               res = INTERNAL_SYSCALL (clock_getres, err, 2,
 148                                       CLOCK_REALTIME, &ts);
 149 #endif
 150               __no_posix_timers = (INTERNAL_SYSCALL_ERROR_P (res, err)
 151                                    ? -1 : 1);
 152             }
 153
 154           if (__no_posix_timers > 0)
 155 # endif
 156             {
 157               /* Create the helper thread.  */
 158               pthread_once (&__helper_once, __start_helper_thread);
 159               if (__helper_tid == 0)
 160                 {
 161                   /* No resources to start the helper thread.  */
 162                   __set_errno (EAGAIN);
 163                   return -1;
 164                 }
 165
 166               struct timer *newp;
 167               newp = (struct timer *) malloc (sizeof (struct timer));
 168               if (newp == NULL)
 169                 return -1;
 170
 171               /* Copy the thread parameters the user provided.  */
 172               newp->sival = evp->sigev_value;
 173               newp->thrfunc = evp->sigev_notify_function;
 174               newp->sigev_notify = SIGEV_THREAD;
 175
 176               /* We cannot simply copy the thread attributes since the
 177                  implementation might keep internal information for
 178                  each instance.  */
 179               (void) pthread_attr_init (&newp->attr);
 180               if (evp->sigev_notify_attributes != NULL)
 181                 {
 182                   struct pthread_attr *nattr;
 183                   struct pthread_attr *oattr;
 184
 185                   nattr = (struct pthread_attr *) &newp->attr;
 186                   oattr = (struct pthread_attr *) evp->sigev_notify_attributes;
 187
 188                   nattr->schedparam = oattr->schedparam;
 189                   nattr->schedpolicy = oattr->schedpolicy;
 190                   nattr->flags = oattr->flags;
 191                   nattr->guardsize = oattr->guardsize;
 192                   nattr->stackaddr = oattr->stackaddr;
 193                   nattr->stacksize = oattr->stacksize;
 194                 }
 195
 196               /* In any case set the detach flag.  */
 197               (void) pthread_attr_setdetachstate (&newp->attr,
 198                                                   PTHREAD_CREATE_DETACHED);
 199
 200               /* Create the event structure for the kernel timer.  */
 201               struct sigevent sev =
 202                 { .sigev_value.sival_ptr = newp,
 203                   .sigev_signo = SIGTIMER,
 204                   .sigev_notify = SIGEV_SIGNAL | SIGEV_THREAD_ID,
 205                   ._sigev_un = { ._pad = { [0] = __helper_tid } } };
 206
 207               /* Create the timer.  */
 208               INTERNAL_SYSCALL_DECL (err);
 209               int res;
 210               res = INTERNAL_SYSCALL (timer_create, err, 3,
 211                                       syscall_clockid, &sev, &newp->ktimerid);
 212               if (! INTERNAL_SYSCALL_ERROR_P (res, err))
 213                 {
 214                   /* Add to the queue of active timers with thread
 215                      delivery.  */
 216                   pthread_mutex_lock (&__active_timer_sigev_thread_lock);
 217                   newp->next = __active_timer_sigev_thread;
 218                   __active_timer_sigev_thread = newp;
 219                   pthread_mutex_unlock (&__active_timer_sigev_thread_lock);
 220
 221                   *timerid = (timer_t) newp;
 222                   return 0;
 223                 }
 224
 225               /* Free the resources.  */
 226               free (newp);
 227
 228               __set_errno (INTERNAL_SYSCALL_ERRNO (res, err));
 229
 230               return -1;
 231             }
 232         }
 233     }
 234
 235 # ifndef __ASSUME_POSIX_TIMERS
 236   /* Compatibility code.  */
 237   return compat_timer_create (clock_id, evp, timerid);
 238 # endif
 239 }
 240 #else
 241 # ifdef timer_create_alias
 242 #  define timer_create timer_create_alias
 243 # endif
 244 /* The new system calls are not available.  Use the userlevel
 245    implementation.  */
 246 # include <nptl/sysdeps/pthread/timer_create.c>
 247 #endif