/* Copyright (C) 2003-2018 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, see <http://www.gnu.org/licenses/>.  */

#include <errno.h>

#include <pthread.h>

#include <signal.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <sysdep.h>

#include <internaltypes.h>

#include <nptl/pthreadP.h>

#include "kernel-posix-timers.h"

#include "kernel-posix-cpu-timers.h"

#ifdef timer_create_alias

# define timer_create timer_create_alias

#endif

int

timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid)

{

#undef timer_create

  {

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

	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;

      }

    else

      {

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

      }

  }

}