sysdeps/pthread/posix-timer.h

   1 /* Definitions for POSIX timer implementation on top of NPTL.
   2    Copyright (C) 2000-2016 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Kaz Kylheku <kaz@ashi.footprints.net>.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public License as
   8    published by the Free Software Foundation; either version 2.1 of the
   9    License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; see the file COPYING.LIB.  If
  18    not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include <limits.h>
  21 #include <signal.h>
  22 #include <list.h>
  23
  24
  25 /* Forward declaration.  */
  26 struct timer_node;
  27
  28
  29 /* Definitions for an internal thread of the POSIX timer implementation.  */
  30 struct thread_node
  31 {
  32   struct list_head links;
  33   pthread_attr_t attr;
  34   pthread_t id;
  35   unsigned int exists;
  36   struct list_head timer_queue;
  37   pthread_cond_t cond;
  38   struct timer_node *current_timer;
  39   pthread_t captured;
  40   clockid_t clock_id;
  41 };
  42
  43
  44 /* Internal representation of a timer.  */
  45 struct timer_node
  46 {
  47   struct list_head links;
  48   struct sigevent event;
  49   clockid_t clock;
  50   struct itimerspec value;
  51   struct timespec expirytime;
  52   pthread_attr_t attr;
  53   unsigned int abstime;
  54   unsigned int armed;
  55   enum {
  56     TIMER_FREE, TIMER_INUSE, TIMER_DELETED
  57   } inuse;
  58   struct thread_node *thread;
  59   pid_t creator_pid;
  60   int refcount;
  61   int overrun_count;
  62 };
  63
  64
  65 /* The limit is not published if we are compiled with kernel timer support.
  66    But we still compiled in this implementation with its limit unless built
  67    to require the kernel support.  */
  68 #ifndef TIMER_MAX
  69 # define TIMER_MAX 256
  70 #endif
  71
  72 /* Static array with the structures for all the timers.  */
  73 extern struct timer_node __timer_array[TIMER_MAX];
  74
  75 /* Global lock to protect operation on the lists.  */
  76 extern pthread_mutex_t __timer_mutex;
  77
  78 /* Variable to protext initialization.  */
  79 extern pthread_once_t __timer_init_once_control;
  80
  81 /* Nonzero if initialization of timer implementation failed.  */
  82 extern int __timer_init_failed;
  83
  84 /* Node for the thread used to deliver signals.  */
  85 extern struct thread_node __timer_signal_thread_rclk;
  86
  87
  88 /* Return pointer to timer structure corresponding to ID.  */
  89 #define timer_id2ptr(timerid) ((struct timer_node *) timerid)
  90 #define timer_ptr2id(timerid) ((void *) timerid)
  91
  92 /* Check whether timer is valid; global mutex must be held. */
  93 static inline int
  94 timer_valid (struct timer_node *timer)
  95 {
  96   return timer && timer->inuse == TIMER_INUSE;
  97 }
  98
  99 /* Timer refcount functions; need global mutex. */
 100 extern void __timer_dealloc (struct timer_node *timer);
 101
 102 static inline void
 103 timer_addref (struct timer_node *timer)
 104 {
 105   timer->refcount++;
 106 }
 107
 108 static inline void
 109 timer_delref (struct timer_node *timer)
 110 {
 111   if (--timer->refcount == 0)
 112     __timer_dealloc (timer);
 113 }
 114
 115 /* Timespec helper routines.  */
 116 static inline int
 117 __attribute ((always_inline))
 118 timespec_compare (const struct timespec *left, const struct timespec *right)
 119 {
 120   if (left->tv_sec < right->tv_sec)
 121     return -1;
 122   if (left->tv_sec > right->tv_sec)
 123     return 1;
 124
 125   if (left->tv_nsec < right->tv_nsec)
 126     return -1;
 127   if (left->tv_nsec > right->tv_nsec)
 128     return 1;
 129
 130   return 0;
 131 }
 132
 133 static inline void
 134 timespec_add (struct timespec *sum, const struct timespec *left,
 135               const struct timespec *right)
 136 {
 137   sum->tv_sec = left->tv_sec + right->tv_sec;
 138   sum->tv_nsec = left->tv_nsec + right->tv_nsec;
 139
 140   if (sum->tv_nsec >= 1000000000)
 141     {
 142       ++sum->tv_sec;
 143       sum->tv_nsec -= 1000000000;
 144     }
 145 }
 146
 147 static inline void
 148 timespec_sub (struct timespec *diff, const struct timespec *left,
 149               const struct timespec *right)
 150 {
 151   diff->tv_sec = left->tv_sec - right->tv_sec;
 152   diff->tv_nsec = left->tv_nsec - right->tv_nsec;
 153
 154   if (diff->tv_nsec < 0)
 155     {
 156       --diff->tv_sec;
 157       diff->tv_nsec += 1000000000;
 158     }
 159 }
 160
 161
 162 /* We need one of the list functions in the other modules.  */
 163 static inline void
 164 list_unlink_ip (struct list_head *list)
 165 {
 166   struct list_head *lnext = list->next, *lprev = list->prev;
 167
 168   lnext->prev = lprev;
 169   lprev->next = lnext;
 170
 171   /* The suffix ip means idempotent; list_unlink_ip can be called
 172    * two or more times on the same node.
 173    */
 174
 175   list->next = list;
 176   list->prev = list;
 177 }
 178
 179
 180 /* Functions in the helper file.  */
 181 extern void __timer_mutex_cancel_handler (void *arg);
 182 extern void __timer_init_once (void);
 183 extern struct timer_node *__timer_alloc (void);
 184 extern int __timer_thread_start (struct thread_node *thread);
 185 extern struct thread_node *__timer_thread_find_matching (const pthread_attr_t *desired_attr, clockid_t);
 186 extern struct thread_node *__timer_thread_alloc (const pthread_attr_t *desired_attr, clockid_t);
 187 extern void __timer_thread_dealloc (struct thread_node *thread);
 188 extern int __timer_thread_queue_timer (struct thread_node *thread,
 189                                        struct timer_node *insert);
 190 extern void __timer_thread_wakeup (struct thread_node *thread);