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

/* Copyright (C) 2003 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@redhat.com>, 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 <errno.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sysdep.h>
#include <kernel-features.h>
#include <internaltypes.h>
#include "kernel-posix-timers.h"


#ifdef __NR_timer_create
# ifndef __ASSUME_POSIX_TIMERS
#  define timer_create static compat_timer_create
#  include <nptl/sysdeps/pthread/timer_create.c>
#  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 <nptl/sysdeps/pthread/timer_create.c>
#endif