(thread_expire_timer): Remove assertion for SIGEV_NONE.
[kopensolaris-gnu/glibc.git] / linuxthreads / sysdeps / pthread / timer_routines.c
1 /* Helper code for POSIX timer implementation on LinuxThreads.
2    Copyright (C) 2000, 2001, 2002, 2004 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 not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <pthread.h>
24 #include <stddef.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <sysdep.h>
28 #include <time.h>
29 #include <unistd.h>
30 #include <sys/syscall.h>
31
32 #include "posix-timer.h"
33
34
35 /* Number of threads used.  */
36 #define THREAD_MAXNODES 16
37
38 /* Array containing the descriptors for the used threads.  */
39 static struct thread_node thread_array[THREAD_MAXNODES];
40
41 /* Static array with the structures for all the timers.  */
42 struct timer_node __timer_array[TIMER_MAX];
43
44 /* Global lock to protect operation on the lists.  */
45 pthread_mutex_t __timer_mutex = PTHREAD_MUTEX_INITIALIZER;
46
47 /* Variable to protext initialization.  */
48 pthread_once_t __timer_init_once_control = PTHREAD_ONCE_INIT;
49
50 /* Nonzero if initialization of timer implementation failed.  */
51 int __timer_init_failed;
52
53 /* Node for the thread used to deliver signals.  */
54 struct thread_node __timer_signal_thread_rclk;
55 #ifdef _POSIX_CPUTIME
56 struct thread_node __timer_signal_thread_pclk;
57 #endif
58 #ifdef _POSIX_THREAD_CPUTIME
59 struct thread_node __timer_signal_thread_tclk;
60 #endif
61
62 /* Lists to keep free and used timers and threads.  */
63 struct list_links timer_free_list;
64 struct list_links thread_free_list;
65 struct list_links thread_active_list;
66
67
68 #ifdef __NR_rt_sigqueueinfo
69 extern int __syscall_rt_sigqueueinfo (int, int, siginfo_t *);
70 #endif
71
72
73 /* List handling functions.  */
74 static inline void
75 list_init (struct list_links *list)
76 {
77   list->next = list->prev = list;
78 }
79
80 static inline void
81 list_append (struct list_links *list, struct list_links *newp)
82 {
83   newp->prev = list->prev;
84   newp->next = list;
85   list->prev->next = newp;
86   list->prev = newp;
87 }
88
89 static inline void
90 list_insbefore (struct list_links *list, struct list_links *newp)
91 {
92   list_append (list, newp);
93 }
94
95 /*
96  * Like list_unlink_ip, except that calling it on a node that
97  * is already unlinked is disastrous rather than a noop.
98  */
99
100 static inline void
101 list_unlink (struct list_links *list)
102 {
103   struct list_links *lnext = list->next, *lprev = list->prev;
104
105   lnext->prev = lprev;
106   lprev->next = lnext;
107 }
108
109 static inline struct list_links *
110 list_first (struct list_links *list)
111 {
112   return list->next;
113 }
114
115 static inline struct list_links *
116 list_null (struct list_links *list)
117 {
118   return list;
119 }
120
121 static inline struct list_links *
122 list_next (struct list_links *list)
123 {
124   return list->next;
125 }
126
127 static inline int
128 list_isempty (struct list_links *list)
129 {
130   return list->next == list;
131 }
132
133
134 /* Functions build on top of the list functions.  */
135 static inline struct thread_node *
136 thread_links2ptr (struct list_links *list)
137 {
138   return (struct thread_node *) ((char *) list
139                                  - offsetof (struct thread_node, links));
140 }
141
142 static inline struct timer_node *
143 timer_links2ptr (struct list_links *list)
144 {
145   return (struct timer_node *) ((char *) list
146                                 - offsetof (struct timer_node, links));
147 }
148
149
150 /* Initialize a newly allocated thread structure.  */
151 static void
152 thread_init (struct thread_node *thread, const pthread_attr_t *attr, clockid_t clock_id)
153 {
154   if (attr != NULL)
155     thread->attr = *attr;
156   else
157     {
158       pthread_attr_init (&thread->attr);
159       pthread_attr_setdetachstate (&thread->attr, PTHREAD_CREATE_DETACHED);
160     }
161
162   thread->exists = 0;
163   list_init (&thread->timer_queue);
164   pthread_cond_init (&thread->cond, 0);
165   thread->current_timer = 0;
166   thread->captured = pthread_self ();
167   thread->clock_id = clock_id;
168 }
169
170
171 /* Initialize the global lists, and acquire global resources.  Error
172    reporting is done by storing a non-zero value to the global variable
173    timer_init_failed.  */
174 static void
175 init_module (void)
176 {
177   int i;
178
179   list_init (&timer_free_list);
180   list_init (&thread_free_list);
181   list_init (&thread_active_list);
182
183   for (i = 0; i < TIMER_MAX; ++i)
184     {
185       list_append (&timer_free_list, &__timer_array[i].links);
186       __timer_array[i].inuse = TIMER_FREE;
187     }
188
189   for (i = 0; i < THREAD_MAXNODES; ++i)
190     list_append (&thread_free_list, &thread_array[i].links);
191
192   thread_init (&__timer_signal_thread_rclk, 0, CLOCK_REALTIME);
193 #ifdef _POSIX_CPUTIME
194   thread_init (&__timer_signal_thread_pclk, 0, CLOCK_PROCESS_CPUTIME_ID);
195 #endif
196 #ifdef _POSIX_THREAD_CPUTIME
197   thread_init (&__timer_signal_thread_tclk, 0, CLOCK_THREAD_CPUTIME_ID);
198 #endif
199 }
200
201
202 /* This is a handler executed in a child process after a fork()
203    occurs.  It reinitializes the module, resetting all of the data
204    structures to their initial state.  The mutex is initialized in
205    case it was locked in the parent process.  */
206 static void
207 reinit_after_fork (void)
208 {
209   init_module ();
210   pthread_mutex_init (&__timer_mutex, 0);
211 }
212
213
214 /* Called once form pthread_once in timer_init. This initializes the
215    module and ensures that reinit_after_fork will be executed in any
216    child process.  */
217 void
218 __timer_init_once (void)
219 {
220   init_module ();
221   pthread_atfork (0, 0, reinit_after_fork);
222 }
223
224
225 /* Deinitialize a thread that is about to be deallocated.  */
226 static void
227 thread_deinit (struct thread_node *thread)
228 {
229   assert (list_isempty (&thread->timer_queue));
230   pthread_cond_destroy (&thread->cond);
231 }
232
233
234 /* Allocate a thread structure from the global free list.  Global
235    mutex lock must be held by caller.  The thread is moved to
236    the active list. */
237 struct thread_node *
238 __timer_thread_alloc (const pthread_attr_t *desired_attr, clockid_t clock_id)
239 {
240   struct list_links *node = list_first (&thread_free_list);
241
242   if (node != list_null (&thread_free_list))
243     {
244       struct thread_node *thread = thread_links2ptr (node);
245       list_unlink (node);
246       thread_init (thread, desired_attr, clock_id);
247       list_append (&thread_active_list, node);
248       return thread;
249     }
250
251   return 0;
252 }
253
254
255 /* Return a thread structure to the global free list.  Global lock
256    must be held by caller.  */
257 void
258 __timer_thread_dealloc (struct thread_node *thread)
259 {
260   thread_deinit (thread);
261   list_unlink (&thread->links);
262   list_append (&thread_free_list, &thread->links);
263 }
264
265
266 /* Each of our threads which terminates executes this cleanup
267    handler. We never terminate threads ourselves; if a thread gets here
268    it means that the evil application has killed it.  If the thread has
269    timers, these require servicing and so we must hire a replacement
270    thread right away.  We must also unblock another thread that may
271    have been waiting for this thread to finish servicing a timer (see
272    timer_delete()).  */
273
274 static void
275 thread_cleanup (void *val)
276 {
277   if (val != NULL)
278     {
279       struct thread_node *thread = val;
280
281       /* How did the signal thread get killed?  */
282       assert (thread != &__timer_signal_thread_rclk);
283 #ifdef _POSIX_CPUTIME
284       assert (thread != &__timer_signal_thread_pclk);
285 #endif
286 #ifdef _POSIX_THREAD_CPUTIME
287       assert (thread != &__timer_signal_thread_tclk);
288 #endif
289
290       pthread_mutex_lock (&__timer_mutex);
291
292       thread->exists = 0;
293
294       /* We are no longer processing a timer event.  */
295       thread->current_timer = 0;
296
297       if (list_isempty (&thread->timer_queue))
298           __timer_thread_dealloc (thread);
299       else
300         (void) __timer_thread_start (thread);
301
302       pthread_mutex_unlock (&__timer_mutex);
303
304       /* Unblock potentially blocked timer_delete().  */
305       pthread_cond_broadcast (&thread->cond);
306     }
307 }
308
309
310 /* Handle a timer which is supposed to go off now.  */
311 static void
312 thread_expire_timer (struct thread_node *self, struct timer_node *timer)
313 {
314   self->current_timer = timer; /* Lets timer_delete know timer is running. */
315
316   pthread_mutex_unlock (&__timer_mutex);
317
318   switch (__builtin_expect (timer->event.sigev_notify, SIGEV_SIGNAL))
319     {
320     case SIGEV_NONE:
321       break;
322
323     case SIGEV_SIGNAL:
324 #ifdef __NR_rt_sigqueueinfo
325       {
326         siginfo_t info;
327
328         /* First, clear the siginfo_t structure, so that we don't pass our
329            stack content to other tasks.  */
330         memset (&info, 0, sizeof (siginfo_t));
331         /* We must pass the information about the data in a siginfo_t
332            value.  */
333         info.si_signo = timer->event.sigev_signo;
334         info.si_code = SI_TIMER;
335         info.si_pid = timer->creator_pid;
336         info.si_uid = getuid ();
337         info.si_value = timer->event.sigev_value;
338
339         INLINE_SYSCALL (rt_sigqueueinfo, 3, info.si_pid, info.si_signo, &info);
340       }
341 #else
342       if (pthread_kill (self->captured, timer->event.sigev_signo) != 0)
343         {
344           if (pthread_kill (self->id, timer->event.sigev_signo) != 0)
345             abort ();
346         }
347 #endif
348       break;
349
350     case SIGEV_THREAD:
351       timer->event.sigev_notify_function (timer->event.sigev_value);
352       break;
353
354     default:
355       assert (! "unknown event");
356       break;
357     }
358
359   pthread_mutex_lock (&__timer_mutex);
360
361   self->current_timer = 0;
362
363   pthread_cond_broadcast (&self->cond);
364 }
365
366
367 /* Thread function; executed by each timer thread. The job of this
368    function is to wait on the thread's timer queue and expire the
369    timers in chronological order as close to their scheduled time as
370    possible.  */
371 static void
372 __attribute__ ((noreturn))
373 thread_func (void *arg)
374 {
375   struct thread_node *self = arg;
376
377   /* Register cleanup handler, in case rogue application terminates
378      this thread.  (This cannot happen to __timer_signal_thread, which
379      doesn't invoke application callbacks). */
380
381   pthread_cleanup_push (thread_cleanup, self);
382
383   pthread_mutex_lock (&__timer_mutex);
384
385   while (1)
386     {
387       struct list_links *first;
388       struct timer_node *timer = NULL;
389
390       /* While the timer queue is not empty, inspect the first node.  */
391       first = list_first (&self->timer_queue);
392       if (first != list_null (&self->timer_queue))
393         {
394           struct timespec now;
395
396           timer = timer_links2ptr (first);
397
398           /* This assumes that the elements of the list of one thread
399              are all for the same clock.  */
400           clock_gettime (timer->clock, &now);
401
402           while (1)
403             {
404               /* If the timer is due or overdue, remove it from the queue.
405                  If it's a periodic timer, re-compute its new time and
406                  requeue it.  Either way, perform the timer expiry. */
407               if (timespec_compare (&now, &timer->expirytime) < 0)
408                 break;
409
410               list_unlink_ip (first);
411
412               if (__builtin_expect (timer->value.it_interval.tv_sec, 0) != 0
413                   || timer->value.it_interval.tv_nsec != 0)
414                 {
415                   timer->overrun_count = 0;
416                   timespec_add (&timer->expirytime, &timer->expirytime,
417                                 &timer->value.it_interval);
418                   while (timespec_compare (&timer->expirytime, &now) < 0)
419                     {
420                       timespec_add (&timer->expirytime, &timer->expirytime,
421                                     &timer->value.it_interval);
422                       if (timer->overrun_count < DELAYTIMER_MAX)
423                         ++timer->overrun_count;
424                     }
425                   __timer_thread_queue_timer (self, timer);
426                 }
427
428               thread_expire_timer (self, timer);
429
430               first = list_first (&self->timer_queue);
431               if (first == list_null (&self->timer_queue))
432                 break;
433
434               timer = timer_links2ptr (first);
435             }
436         }
437
438       /* If the queue is not empty, wait until the expiry time of the
439          first node.  Otherwise wait indefinitely.  Insertions at the
440          head of the queue must wake up the thread by broadcasting
441          this condition variable.  */
442       if (timer != NULL)
443         pthread_cond_timedwait (&self->cond, &__timer_mutex,
444                                 &timer->expirytime);
445       else
446         pthread_cond_wait (&self->cond, &__timer_mutex);
447     }
448   /* This macro will never be executed since the while loop loops
449      forever - but we have to add it for proper nesting.  */
450   pthread_cleanup_pop (1);
451 }
452
453
454 /* Enqueue a timer in wakeup order in the thread's timer queue.
455    Returns 1 if the timer was inserted at the head of the queue,
456    causing the queue's next wakeup time to change. */
457
458 int
459 __timer_thread_queue_timer (struct thread_node *thread,
460                             struct timer_node *insert)
461 {
462   struct list_links *iter;
463   int athead = 1;
464
465   for (iter = list_first (&thread->timer_queue);
466        iter != list_null (&thread->timer_queue);
467         iter = list_next (iter))
468     {
469       struct timer_node *timer = timer_links2ptr (iter);
470
471       if (timespec_compare (&insert->expirytime, &timer->expirytime) < 0)
472           break;
473       athead = 0;
474     }
475
476   list_insbefore (iter, &insert->links);
477   return athead;
478 }
479
480
481 /* Start a thread and associate it with the given thread node.  Global
482    lock must be held by caller.  */
483 int
484 __timer_thread_start (struct thread_node *thread)
485 {
486   int retval = 1;
487
488   assert (!thread->exists);
489   thread->exists = 1;
490
491   if (pthread_create (&thread->id, &thread->attr,
492                       (void *(*) (void *)) thread_func, thread) != 0)
493     {
494       thread->exists = 0;
495       retval = -1;
496     }
497
498   return retval;
499 }
500
501
502 void
503 __timer_thread_wakeup (struct thread_node *thread)
504 {
505   pthread_cond_broadcast (&thread->cond);
506 }
507
508
509 /* Compare two pthread_attr_t thread attributes for exact equality.
510    Returns 1 if they are equal, otherwise zero if they are not equal or
511    contain illegal values.  This version is LinuxThreads-specific for
512    performance reason.  One could use the access functions to get the
513    values of all the fields of the attribute structure.  */
514 static int
515 thread_attr_compare (const pthread_attr_t *left, const pthread_attr_t *right)
516 {
517   return (left->__detachstate == right->__detachstate
518           && left->__schedpolicy == right->__schedpolicy
519           && left->__guardsize == right->__guardsize
520           && (left->__schedparam.sched_priority
521               == right->__schedparam.sched_priority)
522           && left->__inheritsched == right->__inheritsched
523           && left->__scope == right->__scope
524           && left->__stacksize == right->__stacksize
525           && left->__stackaddr_set == right->__stackaddr_set
526           && (left->__stackaddr_set
527               || left->__stackaddr == right->__stackaddr));
528 }
529
530
531 /* Search the list of active threads and find one which has matching
532    attributes.  Global mutex lock must be held by caller.  */
533 struct thread_node *
534 __timer_thread_find_matching (const pthread_attr_t *desired_attr,
535                               clockid_t desired_clock_id)
536 {
537   struct list_links *iter = list_first (&thread_active_list);
538
539   while (iter != list_null (&thread_active_list))
540     {
541       struct thread_node *candidate = thread_links2ptr (iter);
542
543       if (thread_attr_compare (desired_attr, &candidate->attr)
544           && desired_clock_id == candidate->clock_id)
545         return candidate;
546
547       iter = list_next (iter);
548     }
549
550   return NULL;
551 }
552
553
554 /* Grab a free timer structure from the global free list.  The global
555    lock must be held by the caller.  */
556 struct timer_node *
557 __timer_alloc (void)
558 {
559   struct list_links *node = list_first (&timer_free_list);
560
561   if (node != list_null (&timer_free_list))
562     {
563       struct timer_node *timer = timer_links2ptr (node);
564       list_unlink_ip (node);
565       timer->inuse = TIMER_INUSE;
566       timer->refcount = 1;
567       return timer;
568     }
569
570   return NULL;
571 }
572
573
574 /* Return a timer structure to the global free list.  The global lock
575    must be held by the caller.  */
576 void
577 __timer_dealloc (struct timer_node *timer)
578 {
579   assert (timer->refcount == 0);
580   timer->thread = NULL; /* Break association between timer and thread.  */
581   timer->inuse = TIMER_FREE;
582   list_append (&timer_free_list, &timer->links);
583 }
584
585
586 /* Thread cancellation handler which unlocks a mutex.  */
587 void
588 __timer_mutex_cancel_handler (void *arg)
589 {
590   pthread_mutex_unlock (arg);
591 }