/* Copyright (C) 2003,2004, 2007, 2009 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 <nptl/pthreadP.h>
#include "kernel-posix-timers.h"
#include "kernel-posix-cpu-timers.h"


#ifdef __NR_timer_create
# ifndef __ASSUME_POSIX_TIMERS
static int compat_timer_create (clockid_t clock_id, struct sigevent *evp,
				timer_t *timerid);
#  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
    {
      clockid_t syscall_clockid = (clock_id == CLOCK_PROCESS_CPUTIME_ID
				   ? MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED)
				   : clock_id == CLOCK_THREAD_CPUTIME_ID
				   ? MAKE_THREAD_CPUCLOCK (0, CPUCLOCK_SCHED)
				   : clock_id);

      /* 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))
	{
	  struct sigevent local_evp;

	  /* 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.  */
	  struct timer *newp = (struct timer *) malloc (offsetof (struct timer,
								  thrfunc));
	  if (newp == NULL)
	    /* No more memory.  */
	    return -1;

	  if (evp == NULL)
	    {
	      /* The kernel has to pass up the timer ID which is a
		 userlevel object.  Therefore we cannot leave it up to
		 the kernel to determine it.  */
	      local_evp.sigev_notify = SIGEV_SIGNAL;
	      local_evp.sigev_signo = SIGALRM;
	      local_evp.sigev_value.sival_ptr = newp;

	      evp = &local_evp;
	    }

	  kernel_timer_t ktimerid;
	  int retval = INLINE_SYSCALL (timer_create, 3, syscall_clockid, evp,
				       &ktimerid);

# ifndef __ASSUME_POSIX_TIMERS
	  if (retval != -1 || errno != ENOSYS)
# endif
	    {
# ifndef __ASSUME_POSIX_TIMERS
	      __no_posix_timers = 1;
# endif

	      if (retval != -1)
		{
		  newp->sigev_notify = (evp != NULL
					? evp->sigev_notify : SIGEV_SIGNAL);
		  newp->ktimerid = ktimerid;

		  *timerid = (timer_t) newp;
		}
	      else
		{
		  /* Cannot allocate the timer, fail.  */
		  free (newp);
		  retval = -1;
		}

	      return retval;
	    }

	  free (newp);

# 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
	}
      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;
	      res = INTERNAL_SYSCALL (clock_getres, err, 2,
				      CLOCK_REALTIME, &ts);
	      __no_posix_timers = (INTERNAL_SYSCALL_ERROR_P (res, err)
				   ? -1 : 1);
	    }

	  if (__no_posix_timers > 0)
# endif
	    {
	      /* Create the helper thread.  */
	      pthread_once (&__helper_once, __start_helper_thread);
	      if (__helper_tid == 0)
		{
		  /* No resources to start the helper thread.  */
		  __set_errno (EAGAIN);
		  return -1;
		}

	      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;
	      newp->sigev_notify = SIGEV_THREAD;

	      /* 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);

	      /* Create the event structure for the kernel timer.  */
	      struct sigevent sev =
		{ .sigev_value.sival_ptr = newp,
		  .sigev_signo = SIGTIMER,
		  .sigev_notify = SIGEV_SIGNAL | SIGEV_THREAD_ID,
		  ._sigev_un = { ._pad = { [0] = __helper_tid } } };

	      /* Create the timer.  */
	      INTERNAL_SYSCALL_DECL (err);
	      int res;
	      res = INTERNAL_SYSCALL (timer_create, err, 3,
				      syscall_clockid, &sev, &newp->ktimerid);
	      if (! INTERNAL_SYSCALL_ERROR_P (res, err))
		{
		  /* Add to the queue of active timers with thread
		     delivery.  */
		  pthread_mutex_lock (&__active_timer_sigev_thread_lock);
		  newp->next = __active_timer_sigev_thread;
		  __active_timer_sigev_thread = newp;
		  pthread_mutex_unlock (&__active_timer_sigev_thread_lock);

		  *timerid = (timer_t) newp;
		  return 0;
		}

	      /* Free the resources.  */
	      free (newp);

	      __set_errno (INTERNAL_SYSCALL_ERRNO (res, err));

	      return -1;
	    }
	}
    }

# 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
