/* Copyright (C) 2003 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper , 2003. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include #include #include #include "kernel-posix-timers.h" #ifdef __NR_timer_create # ifndef __ASSUME_POSIX_TIMERS # define timer_create static compat_timer_create # include # undef timer_create /* Nonzero if the system calls are not available. */ int __no_posix_timers attribute_hidden; # endif # ifdef timer_create_alias # define timer_create timer_create_alias # endif int timer_create (clock_id, evp, timerid) clockid_t clock_id; struct sigevent *evp; timer_t *timerid; { # undef timer_create # ifndef __ASSUME_POSIX_TIMERS if (__no_posix_timers >= 0) # endif { /* If the user wants notification via a thread we need to handle this special. */ if (evp == NULL || __builtin_expect (evp->sigev_notify != SIGEV_THREAD, 1)) { kernel_timer_t ktimerid; int retval = INLINE_SYSCALL (timer_create, 3, clock_id, evp, &ktimerid); # ifndef __ASSUME_POSIX_TIMERS if (retval != -1 || errno != ENOSYS) # endif { # ifndef __ASSUME_POSIX_TIMERS __no_posix_timers = 1; #endif if (retval != -1) { struct timer *newp; /* We avoid allocating too much memory by basically using struct timer as a derived class with the first two elements being in the superclass. We only need these two elements here. */ newp = (struct timer *) malloc (offsetof (struct timer, thrfunc)); if (newp != NULL) { newp->sigev_notify = (evp != NULL ? evp->sigev_notify : SIGEV_SIGNAL); newp->ktimerid = ktimerid; *timerid = (timer_t) newp; } else { /* No memory. Free the kernel timer. */ INTERNAL_SYSCALL_DECL (err); (void) INTERNAL_SYSCALL (timer_delete, err, 1, ktimerid); retval = -1; } } return retval; } } else { #ifndef __ASSUME_POSIX_TIMERS /* Make sure we have the necessary kernel support. */ if (__no_posix_timers == 0) { INTERNAL_SYSCALL_DECL (err); struct timespec ts; int res = INTERNAL_SYSCALL (clock_getres, err, 1, &ts); __no_posix_timers = (INTERNAL_SYSCALL_ERROR_P (res, err) ? -1 : 1); } if (__no_posix_timers > 0) #endif { sigset_t ss; sigemptyset (&ss); sigaddset (&ss, TIMER_SIG); pthread_sigmask (SIG_BLOCK, &ss, NULL); struct timer *newp; newp = (struct timer *) malloc (sizeof (struct timer)); if (newp == NULL) return -1; /* Copy the thread parameters the user provided. */ newp->sival = evp->sigev_value; newp->thrfunc = evp->sigev_notify_function; /* We cannot simply copy the thread attributes since the implementation might keep internal information for each instance. */ (void) pthread_attr_init (&newp->attr); if (evp->sigev_notify_attributes != NULL) { struct pthread_attr *nattr; struct pthread_attr *oattr; nattr = (struct pthread_attr *) &newp->attr; oattr = (struct pthread_attr *) evp->sigev_notify_attributes; nattr->schedparam = oattr->schedparam; nattr->schedpolicy = oattr->schedpolicy; nattr->flags = oattr->flags; nattr->guardsize = oattr->guardsize; nattr->stackaddr = oattr->stackaddr; nattr->stacksize = oattr->stacksize; } /* In any case set the detach flag. */ (void) pthread_attr_setdetachstate (&newp->attr, PTHREAD_CREATE_DETACHED); /* Set up the barrier for sychronization. */ (void) pthread_barrier_init (&newp->bar, NULL, 2); /* The helper thread needs only very little resources and should go away automatically when canceled. */ pthread_attr_t attr; (void) pthread_attr_init (&attr); (void) pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); (void) pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN); /* Create the helper thread for this timer. */ int res = pthread_create (&newp->th, &attr, __timer_helper_thread, newp); if (res != 0) goto err_out; /* No need for the attribute anymore. */ (void) pthread_attr_destroy (&attr); /* Create the event structure for the kernel timer. */ struct sigevent sev; sev.sigev_value.sival_ptr = newp; sev.sigev_signo = TIMER_SIG; sev.sigev_notify = SIGEV_SIGNAL | SIGEV_THREAD_ID; /* This is the thread ID of the helper thread. */ sev._sigev_un._pad[0] = ((struct pthread *) newp->th)->tid; /* Wait until the helper thread is set up. */ (void) pthread_barrier_wait (&newp->bar); /* No need for the barrier anymore. */ (void) pthread_barrier_destroy (&newp->bar); /* Create the timer. */ INTERNAL_SYSCALL_DECL (err); res = INTERNAL_SYSCALL (timer_create, err, 3, clock_id, &sev, &newp->ktimerid); if (! INTERNAL_SYSCALL_ERROR_P (res, err)) { *timerid = (timer_t) newp; return 0; } /* Something went wrong. Kill the thread. */ pthread_cancel (newp->th); /* Free the resources. */ res = INTERNAL_SYSCALL_ERRNO (res, err); err_out: free (newp); __set_errno (res); return -1; } } # ifndef __ASSUME_POSIX_TIMERS /* When we come here the syscall does not exist. Make sure we do not try to use it again. */ __no_posix_timers = -1; # endif } # ifndef __ASSUME_POSIX_TIMERS /* Compatibility code. */ return compat_timer_create (clock_id, evp, timerid); # endif } #else # ifdef timer_create_alias # define timer_create timer_create_alias # endif /* The new system calls are not available. Use the userlevel implementation. */ # include #endif