2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-10-03 21:01:26 +00:00
|
|
|
* linux/kernel/posix-timers.c
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* 2002-10-15 Posix Clocks & timers
|
|
|
|
* by George Anzinger george@mvista.com
|
|
|
|
*
|
|
|
|
* Copyright (C) 2002 2003 by MontaVista Software.
|
|
|
|
*
|
|
|
|
* 2004-06-01 Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug.
|
|
|
|
* Copyright (C) 2004 Boris Hu
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
|
|
* your option) any later version.
|
|
|
|
*
|
|
|
|
* This program 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
|
|
|
|
* General Public License for more details.
|
|
|
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*
|
|
|
|
* MontaVista Software | 1237 East Arques Avenue | Sunnyvale | CA 94085 | USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* These are all the functions necessary to implement
|
|
|
|
* POSIX clocks & timers
|
|
|
|
*/
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/time.h>
|
2006-03-23 11:00:24 +00:00
|
|
|
#include <linux/mutex.h>
|
2017-02-05 13:35:41 +00:00
|
|
|
#include <linux/sched/task.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/compiler.h>
|
2013-03-11 09:12:21 +00:00
|
|
|
#include <linux/hash.h>
|
2011-02-01 13:52:35 +00:00
|
|
|
#include <linux/posix-clock.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/posix-timers.h>
|
|
|
|
#include <linux/syscalls.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/workqueue.h>
|
2011-05-23 18:51:41 +00:00
|
|
|
#include <linux/export.h>
|
2013-03-11 09:12:21 +00:00
|
|
|
#include <linux/hashtable.h>
|
2017-06-07 08:42:31 +00:00
|
|
|
#include <linux/compat.h>
|
2018-02-15 16:21:55 +00:00
|
|
|
#include <linux/nospec.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-07-16 21:04:02 +00:00
|
|
|
#include "timekeeping.h"
|
2017-05-30 21:15:41 +00:00
|
|
|
#include "posix-timers.h"
|
2014-07-16 21:04:02 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2013-03-11 09:12:21 +00:00
|
|
|
* Management arrays for POSIX timers. Timers are now kept in static hash table
|
|
|
|
* with 512 entries.
|
|
|
|
* Timer ids are allocated by local routine, which selects proper hash head by
|
|
|
|
* key, constructed from current->signal address and per signal struct counter.
|
|
|
|
* This keeps timer ids unique per process, but now they can intersect between
|
|
|
|
* processes.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lets keep our timers in a slab cache :-)
|
|
|
|
*/
|
2006-12-07 04:33:20 +00:00
|
|
|
static struct kmem_cache *posix_timers_cache;
|
2013-03-11 09:12:21 +00:00
|
|
|
|
|
|
|
static DEFINE_HASHTABLE(posix_timers_hashtable, 9);
|
|
|
|
static DEFINE_SPINLOCK(hash_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-30 21:15:39 +00:00
|
|
|
static const struct k_clock * const posix_clocks[];
|
|
|
|
static const struct k_clock *clockid_to_kclock(const clockid_t id);
|
2017-06-12 17:39:49 +00:00
|
|
|
static const struct k_clock clock_realtime, clock_monotonic;
|
2017-05-30 21:15:39 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* we assume that the new SIGEV_THREAD_ID shares no bits with the other
|
|
|
|
* SIGEV values. Here we put out an error if this assumption fails.
|
|
|
|
*/
|
|
|
|
#if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \
|
|
|
|
~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD))
|
|
|
|
#error "SIGEV_THREAD_ID must not share bit with other SIGEV values!"
|
|
|
|
#endif
|
|
|
|
|
2011-02-01 13:51:01 +00:00
|
|
|
/*
|
|
|
|
* parisc wants ENOTSUP instead of EOPNOTSUPP
|
|
|
|
*/
|
|
|
|
#ifndef ENOTSUP
|
|
|
|
# define ENANOSLEEP_NOTSUP EOPNOTSUPP
|
|
|
|
#else
|
|
|
|
# define ENANOSLEEP_NOTSUP ENOTSUP
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The timer ID is turned into a timer address by idr_find().
|
|
|
|
* Verifying a valid ID consists of:
|
|
|
|
*
|
|
|
|
* a) checking that idr_find() returns other than -1.
|
|
|
|
* b) checking that the timer id matches the one in the timer itself.
|
|
|
|
* c) that the timer owner is in the callers thread group.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CLOCKs: The POSIX standard calls for a couple of clocks and allows us
|
|
|
|
* to implement others. This structure defines the various
|
2011-02-01 13:52:15 +00:00
|
|
|
* clocks.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* RESOLUTION: Clock resolution is used to round up timer and interval
|
|
|
|
* times, NOT to report clock times, which are reported with as
|
|
|
|
* much resolution as the system can muster. In some cases this
|
|
|
|
* resolution may depend on the underlying clock hardware and
|
|
|
|
* may not be quantifiable until run time, and only then is the
|
|
|
|
* necessary code is written. The standard says we should say
|
|
|
|
* something about this issue in the documentation...
|
|
|
|
*
|
2011-02-01 13:52:15 +00:00
|
|
|
* FUNCTIONS: The CLOCKs structure defines possible functions to
|
|
|
|
* handle various clock functions.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2011-02-01 13:52:15 +00:00
|
|
|
* The standard POSIX timer management code assumes the
|
|
|
|
* following: 1.) The k_itimer struct (sched.h) is used for
|
|
|
|
* the timer. 2.) The list, it_lock, it_clock, it_id and
|
|
|
|
* it_pid fields are not modified by timer code.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Permissions: It is assumed that the clock_settime() function defined
|
|
|
|
* for each clock will take care of permission checks. Some
|
|
|
|
* clocks may be set able by any user (i.e. local process
|
|
|
|
* clocks) others not. Currently the only set able clock we
|
|
|
|
* have is CLOCK_REALTIME and its high res counter part, both of
|
|
|
|
* which we beg off on and pass to do_sys_settimeofday().
|
|
|
|
*/
|
2010-10-20 22:57:34 +00:00
|
|
|
static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags);
|
|
|
|
|
|
|
|
#define lock_timer(tid, flags) \
|
|
|
|
({ struct k_itimer *__timr; \
|
|
|
|
__cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \
|
|
|
|
__timr; \
|
|
|
|
})
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-03-11 09:12:21 +00:00
|
|
|
static int hash(struct signal_struct *sig, unsigned int nr)
|
|
|
|
{
|
|
|
|
return hash_32(hash32_ptr(sig) ^ nr, HASH_BITS(posix_timers_hashtable));
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct k_itimer *__posix_timers_find(struct hlist_head *head,
|
|
|
|
struct signal_struct *sig,
|
|
|
|
timer_t id)
|
|
|
|
{
|
|
|
|
struct k_itimer *timer;
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(timer, head, t_hash) {
|
|
|
|
if ((timer->it_signal == sig) && (timer->it_id == id))
|
|
|
|
return timer;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct k_itimer *posix_timer_by_id(timer_t id)
|
|
|
|
{
|
|
|
|
struct signal_struct *sig = current->signal;
|
|
|
|
struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)];
|
|
|
|
|
|
|
|
return __posix_timers_find(head, sig, id);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int posix_timer_add(struct k_itimer *timer)
|
|
|
|
{
|
|
|
|
struct signal_struct *sig = current->signal;
|
|
|
|
int first_free_id = sig->posix_timer_id;
|
|
|
|
struct hlist_head *head;
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
do {
|
|
|
|
spin_lock(&hash_lock);
|
|
|
|
head = &posix_timers_hashtable[hash(sig, sig->posix_timer_id)];
|
|
|
|
if (!__posix_timers_find(head, sig, sig->posix_timer_id)) {
|
|
|
|
hlist_add_head_rcu(&timer->t_hash, head);
|
|
|
|
ret = sig->posix_timer_id;
|
|
|
|
}
|
|
|
|
if (++sig->posix_timer_id < 0)
|
|
|
|
sig->posix_timer_id = 0;
|
|
|
|
if ((sig->posix_timer_id == first_free_id) && (ret == -ENOENT))
|
|
|
|
/* Loop over all possible ids completed */
|
|
|
|
ret = -EAGAIN;
|
|
|
|
spin_unlock(&hash_lock);
|
|
|
|
} while (ret == -ENOENT);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline void unlock_timer(struct k_itimer *timr, unsigned long flags)
|
|
|
|
{
|
|
|
|
spin_unlock_irqrestore(&timr->it_lock, flags);
|
|
|
|
}
|
|
|
|
|
2011-02-01 13:51:50 +00:00
|
|
|
/* Get clock_realtime */
|
2017-03-26 19:04:14 +00:00
|
|
|
static int posix_clock_realtime_get(clockid_t which_clock, struct timespec64 *tp)
|
2011-02-01 13:51:50 +00:00
|
|
|
{
|
2017-03-26 19:04:14 +00:00
|
|
|
ktime_get_real_ts64(tp);
|
2011-02-01 13:51:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-01 13:51:48 +00:00
|
|
|
/* Set clock_realtime */
|
|
|
|
static int posix_clock_realtime_set(const clockid_t which_clock,
|
2017-03-26 19:04:16 +00:00
|
|
|
const struct timespec64 *tp)
|
2011-02-01 13:51:48 +00:00
|
|
|
{
|
2017-03-26 19:04:16 +00:00
|
|
|
return do_sys_settimeofday64(tp, NULL);
|
2011-02-01 13:51:48 +00:00
|
|
|
}
|
|
|
|
|
2011-02-01 13:52:26 +00:00
|
|
|
static int posix_clock_realtime_adj(const clockid_t which_clock,
|
|
|
|
struct timex *t)
|
|
|
|
{
|
|
|
|
return do_adjtimex(t);
|
|
|
|
}
|
|
|
|
|
2006-01-10 04:52:38 +00:00
|
|
|
/*
|
|
|
|
* Get monotonic time for posix timers
|
|
|
|
*/
|
2017-03-26 19:04:14 +00:00
|
|
|
static int posix_ktime_get_ts(clockid_t which_clock, struct timespec64 *tp)
|
2006-01-10 04:52:38 +00:00
|
|
|
{
|
2017-03-26 19:04:14 +00:00
|
|
|
ktime_get_ts64(tp);
|
2006-01-10 04:52:38 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 23:37:30 +00:00
|
|
|
/*
|
2011-02-15 18:52:57 +00:00
|
|
|
* Get monotonic-raw time for posix timers
|
2008-08-20 23:37:30 +00:00
|
|
|
*/
|
2017-03-26 19:04:14 +00:00
|
|
|
static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec64 *tp)
|
2008-08-20 23:37:30 +00:00
|
|
|
{
|
2017-03-26 19:04:14 +00:00
|
|
|
getrawmonotonic64(tp);
|
2008-08-20 23:37:30 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-20 02:13:34 +00:00
|
|
|
|
2017-03-26 19:04:14 +00:00
|
|
|
static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec64 *tp)
|
2009-08-20 02:13:34 +00:00
|
|
|
{
|
2017-03-26 19:04:14 +00:00
|
|
|
*tp = current_kernel_time64();
|
2009-08-20 02:13:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int posix_get_monotonic_coarse(clockid_t which_clock,
|
2017-03-26 19:04:14 +00:00
|
|
|
struct timespec64 *tp)
|
2009-08-20 02:13:34 +00:00
|
|
|
{
|
2017-03-26 19:04:14 +00:00
|
|
|
*tp = get_monotonic_coarse64();
|
2009-08-20 02:13:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-26 19:04:15 +00:00
|
|
|
static int posix_get_coarse_res(const clockid_t which_clock, struct timespec64 *tp)
|
2009-08-20 02:13:34 +00:00
|
|
|
{
|
2017-03-26 19:04:15 +00:00
|
|
|
*tp = ktime_to_timespec64(KTIME_LOW_RES);
|
2009-08-20 02:13:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-02-15 18:52:57 +00:00
|
|
|
|
2018-04-25 13:33:38 +00:00
|
|
|
static int posix_get_boottime(const clockid_t which_clock, struct timespec64 *tp)
|
2011-02-15 18:52:57 +00:00
|
|
|
{
|
2018-04-25 13:33:38 +00:00
|
|
|
get_monotonic_boottime64(tp);
|
2011-02-15 18:52:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-04-25 13:33:38 +00:00
|
|
|
static int posix_get_tai(clockid_t which_clock, struct timespec64 *tp)
|
2012-05-03 19:43:40 +00:00
|
|
|
{
|
2018-04-25 13:33:38 +00:00
|
|
|
timekeeping_clocktai64(tp);
|
2012-05-03 19:43:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-02-15 18:52:57 +00:00
|
|
|
|
2017-03-26 19:04:15 +00:00
|
|
|
static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec64 *tp)
|
2015-04-14 21:08:32 +00:00
|
|
|
{
|
|
|
|
tp->tv_sec = 0;
|
|
|
|
tp->tv_nsec = hrtimer_resolution;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Initialize everything, well, just everything in Posix clocks/timers ;)
|
|
|
|
*/
|
|
|
|
static __init int init_posix_timers(void)
|
|
|
|
{
|
|
|
|
posix_timers_cache = kmem_cache_create("posix_timers_cache",
|
2007-10-17 06:26:10 +00:00
|
|
|
sizeof (struct k_itimer), 0, SLAB_PANIC,
|
|
|
|
NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
__initcall(init_posix_timers);
|
|
|
|
|
2017-05-30 21:15:47 +00:00
|
|
|
static void common_hrtimer_rearm(struct k_itimer *timr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-03-26 09:38:06 +00:00
|
|
|
struct hrtimer *timer = &timr->it.real.timer;
|
|
|
|
|
2017-05-30 21:15:43 +00:00
|
|
|
if (!timr->it_interval)
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
timerfd: new timerfd API
This is the new timerfd API as it is implemented by the following patch:
int timerfd_create(int clockid, int flags);
int timerfd_settime(int ufd, int flags,
const struct itimerspec *utmr,
struct itimerspec *otmr);
int timerfd_gettime(int ufd, struct itimerspec *otmr);
The timerfd_create() API creates an un-programmed timerfd fd. The "clockid"
parameter can be either CLOCK_MONOTONIC or CLOCK_REALTIME.
The timerfd_settime() API give new settings by the timerfd fd, by optionally
retrieving the previous expiration time (in case the "otmr" parameter is not
NULL).
The time value specified in "utmr" is absolute, if the TFD_TIMER_ABSTIME bit
is set in the "flags" parameter. Otherwise it's a relative time.
The timerfd_gettime() API returns the next expiration time of the timer, or
{0, 0} if the timerfd has not been set yet.
Like the previous timerfd API implementation, read(2) and poll(2) are
supported (with the same interface). Here's a simple test program I used to
exercise the new timerfd APIs:
http://www.xmailserver.org/timerfd-test2.c
[akpm@linux-foundation.org: coding-style cleanups]
[akpm@linux-foundation.org: fix ia64 build]
[akpm@linux-foundation.org: fix m68k build]
[akpm@linux-foundation.org: fix mips build]
[akpm@linux-foundation.org: fix alpha, arm, blackfin, cris, m68k, s390, sparc and sparc64 builds]
[heiko.carstens@de.ibm.com: fix s390]
[akpm@linux-foundation.org: fix powerpc build]
[akpm@linux-foundation.org: fix sparc64 more]
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Cc: Davide Libenzi <davidel@xmailserver.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-05 06:27:26 +00:00
|
|
|
timr->it_overrun += (unsigned int) hrtimer_forward(timer,
|
|
|
|
timer->base->get_time(),
|
2017-05-30 21:15:43 +00:00
|
|
|
timr->it_interval);
|
2006-03-26 09:38:06 +00:00
|
|
|
hrtimer_restart(timer);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function is exported for use by the signal deliver code. It is
|
|
|
|
* called just prior to the info block being released and passes that
|
|
|
|
* block to us. It's function is to update the overrun entry AND to
|
|
|
|
* restart the timer. It should only be called if the timer is to be
|
|
|
|
* restarted (i.e. we have flagged this in the sys_private entry of the
|
|
|
|
* info block).
|
|
|
|
*
|
2011-03-31 01:57:33 +00:00
|
|
|
* To protect against the timer going away while the interrupt is queued,
|
2005-04-16 22:20:36 +00:00
|
|
|
* we require that the it_requeue_pending flag be set.
|
|
|
|
*/
|
2017-05-30 21:15:46 +00:00
|
|
|
void posixtimer_rearm(struct siginfo *info)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct k_itimer *timr;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
timr = lock_timer(info->si_tid, &flags);
|
2017-05-30 21:15:42 +00:00
|
|
|
if (!timr)
|
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-30 21:15:42 +00:00
|
|
|
if (timr->it_requeue_pending == info->si_sys_private) {
|
2017-05-30 21:15:47 +00:00
|
|
|
timr->kclock->timer_rearm(timr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-30 21:15:48 +00:00
|
|
|
timr->it_active = 1;
|
2017-05-30 21:15:42 +00:00
|
|
|
timr->it_overrun_last = timr->it_overrun;
|
|
|
|
timr->it_overrun = -1;
|
|
|
|
++timr->it_requeue_pending;
|
|
|
|
|
2008-07-23 16:52:05 +00:00
|
|
|
info->si_overrun += timr->it_overrun_last;
|
2006-01-10 04:52:38 +00:00
|
|
|
}
|
|
|
|
|
2017-05-30 21:15:42 +00:00
|
|
|
unlock_timer(timr, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
posix-timers: fix posix_timer_event() vs dequeue_signal() race
The bug was reported and analysed by Mark McLoughlin <markmc@redhat.com>,
the patch is based on his and Roland's suggestions.
posix_timer_event() always rewrites the pre-allocated siginfo before sending
the signal. Most of the written info is the same all the time, but memset(0)
is very wrong. If ->sigq is queued we can race with collect_signal() which
can fail to find this siginfo looking at .si_signo, or copy_siginfo() can
copy the wrong .si_code/si_tid/etc.
In short, sys_timer_settime() can in fact stop the active timer, or the user
can receive the siginfo with the wrong .si_xxx values.
Move "memset(->info, 0)" from posix_timer_event() to alloc_posix_timer(),
change send_sigqueue() to set .si_overrun = 0 when ->sigq is not queued.
It would be nice to move the whole sigq->info initialization from send to
create path, but this is not easy to do without uglifying timer_create()
further.
As Roland rightly pointed out, we need more cleanups/fixes here, see the
"FIXME" comment in the patch. Hopefully this patch makes sense anyway, and
it can mask the most bad implications.
Reported-by: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Mark McLoughlin <markmc@redhat.com>
Cc: Oliver Pinter <oliver.pntr@gmail.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: stable@kernel.org
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
kernel/posix-timers.c | 17 +++++++++++++----
kernel/signal.c | 1 +
2 files changed, 14 insertions(+), 4 deletions(-)
2008-07-23 16:52:05 +00:00
|
|
|
int posix_timer_event(struct k_itimer *timr, int si_private)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-12-01 22:18:13 +00:00
|
|
|
struct task_struct *task;
|
|
|
|
int shared, ret = -1;
|
posix-timers: fix posix_timer_event() vs dequeue_signal() race
The bug was reported and analysed by Mark McLoughlin <markmc@redhat.com>,
the patch is based on his and Roland's suggestions.
posix_timer_event() always rewrites the pre-allocated siginfo before sending
the signal. Most of the written info is the same all the time, but memset(0)
is very wrong. If ->sigq is queued we can race with collect_signal() which
can fail to find this siginfo looking at .si_signo, or copy_siginfo() can
copy the wrong .si_code/si_tid/etc.
In short, sys_timer_settime() can in fact stop the active timer, or the user
can receive the siginfo with the wrong .si_xxx values.
Move "memset(->info, 0)" from posix_timer_event() to alloc_posix_timer(),
change send_sigqueue() to set .si_overrun = 0 when ->sigq is not queued.
It would be nice to move the whole sigq->info initialization from send to
create path, but this is not easy to do without uglifying timer_create()
further.
As Roland rightly pointed out, we need more cleanups/fixes here, see the
"FIXME" comment in the patch. Hopefully this patch makes sense anyway, and
it can mask the most bad implications.
Reported-by: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Mark McLoughlin <markmc@redhat.com>
Cc: Oliver Pinter <oliver.pntr@gmail.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: stable@kernel.org
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
kernel/posix-timers.c | 17 +++++++++++++----
kernel/signal.c | 1 +
2 files changed, 14 insertions(+), 4 deletions(-)
2008-07-23 16:52:05 +00:00
|
|
|
/*
|
|
|
|
* FIXME: if ->sigq is queued we can race with
|
2017-05-30 21:15:46 +00:00
|
|
|
* dequeue_signal()->posixtimer_rearm().
|
posix-timers: fix posix_timer_event() vs dequeue_signal() race
The bug was reported and analysed by Mark McLoughlin <markmc@redhat.com>,
the patch is based on his and Roland's suggestions.
posix_timer_event() always rewrites the pre-allocated siginfo before sending
the signal. Most of the written info is the same all the time, but memset(0)
is very wrong. If ->sigq is queued we can race with collect_signal() which
can fail to find this siginfo looking at .si_signo, or copy_siginfo() can
copy the wrong .si_code/si_tid/etc.
In short, sys_timer_settime() can in fact stop the active timer, or the user
can receive the siginfo with the wrong .si_xxx values.
Move "memset(->info, 0)" from posix_timer_event() to alloc_posix_timer(),
change send_sigqueue() to set .si_overrun = 0 when ->sigq is not queued.
It would be nice to move the whole sigq->info initialization from send to
create path, but this is not easy to do without uglifying timer_create()
further.
As Roland rightly pointed out, we need more cleanups/fixes here, see the
"FIXME" comment in the patch. Hopefully this patch makes sense anyway, and
it can mask the most bad implications.
Reported-by: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Mark McLoughlin <markmc@redhat.com>
Cc: Oliver Pinter <oliver.pntr@gmail.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: stable@kernel.org
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
kernel/posix-timers.c | 17 +++++++++++++----
kernel/signal.c | 1 +
2 files changed, 14 insertions(+), 4 deletions(-)
2008-07-23 16:52:05 +00:00
|
|
|
*
|
|
|
|
* If dequeue_signal() sees the "right" value of
|
2017-05-30 21:15:46 +00:00
|
|
|
* si_sys_private it calls posixtimer_rearm().
|
posix-timers: fix posix_timer_event() vs dequeue_signal() race
The bug was reported and analysed by Mark McLoughlin <markmc@redhat.com>,
the patch is based on his and Roland's suggestions.
posix_timer_event() always rewrites the pre-allocated siginfo before sending
the signal. Most of the written info is the same all the time, but memset(0)
is very wrong. If ->sigq is queued we can race with collect_signal() which
can fail to find this siginfo looking at .si_signo, or copy_siginfo() can
copy the wrong .si_code/si_tid/etc.
In short, sys_timer_settime() can in fact stop the active timer, or the user
can receive the siginfo with the wrong .si_xxx values.
Move "memset(->info, 0)" from posix_timer_event() to alloc_posix_timer(),
change send_sigqueue() to set .si_overrun = 0 when ->sigq is not queued.
It would be nice to move the whole sigq->info initialization from send to
create path, but this is not easy to do without uglifying timer_create()
further.
As Roland rightly pointed out, we need more cleanups/fixes here, see the
"FIXME" comment in the patch. Hopefully this patch makes sense anyway, and
it can mask the most bad implications.
Reported-by: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Mark McLoughlin <markmc@redhat.com>
Cc: Oliver Pinter <oliver.pntr@gmail.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: stable@kernel.org
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
kernel/posix-timers.c | 17 +++++++++++++----
kernel/signal.c | 1 +
2 files changed, 14 insertions(+), 4 deletions(-)
2008-07-23 16:52:05 +00:00
|
|
|
* We re-queue ->sigq and drop ->it_lock().
|
2017-05-30 21:15:46 +00:00
|
|
|
* posixtimer_rearm() locks the timer
|
posix-timers: fix posix_timer_event() vs dequeue_signal() race
The bug was reported and analysed by Mark McLoughlin <markmc@redhat.com>,
the patch is based on his and Roland's suggestions.
posix_timer_event() always rewrites the pre-allocated siginfo before sending
the signal. Most of the written info is the same all the time, but memset(0)
is very wrong. If ->sigq is queued we can race with collect_signal() which
can fail to find this siginfo looking at .si_signo, or copy_siginfo() can
copy the wrong .si_code/si_tid/etc.
In short, sys_timer_settime() can in fact stop the active timer, or the user
can receive the siginfo with the wrong .si_xxx values.
Move "memset(->info, 0)" from posix_timer_event() to alloc_posix_timer(),
change send_sigqueue() to set .si_overrun = 0 when ->sigq is not queued.
It would be nice to move the whole sigq->info initialization from send to
create path, but this is not easy to do without uglifying timer_create()
further.
As Roland rightly pointed out, we need more cleanups/fixes here, see the
"FIXME" comment in the patch. Hopefully this patch makes sense anyway, and
it can mask the most bad implications.
Reported-by: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Mark McLoughlin <markmc@redhat.com>
Cc: Oliver Pinter <oliver.pntr@gmail.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: stable@kernel.org
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
kernel/posix-timers.c | 17 +++++++++++++----
kernel/signal.c | 1 +
2 files changed, 14 insertions(+), 4 deletions(-)
2008-07-23 16:52:05 +00:00
|
|
|
* and re-schedules it while ->sigq is pending.
|
|
|
|
* Not really bad, but not that we want.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
timr->sigq->info.si_sys_private = si_private;
|
|
|
|
|
2008-12-01 22:18:13 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
task = pid_task(timr->it_pid, PIDTYPE_PID);
|
|
|
|
if (task) {
|
|
|
|
shared = !(timr->it_sigev_notify & SIGEV_THREAD_ID);
|
|
|
|
ret = send_sigqueue(timr->sigq, task, shared);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2008-09-22 21:42:46 +00:00
|
|
|
/* If we failed to send the signal the timer stops. */
|
|
|
|
return ret > 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function gets called when a POSIX.1b interval timer expires. It
|
|
|
|
* is used as a callback from the kernel internal timer. The
|
|
|
|
* run_timer_list code ALWAYS calls with interrupts on.
|
|
|
|
|
|
|
|
* This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
|
|
|
|
*/
|
2007-02-16 09:27:49 +00:00
|
|
|
static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-03-26 09:38:12 +00:00
|
|
|
struct k_itimer *timr;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
2006-01-10 04:52:38 +00:00
|
|
|
int si_private = 0;
|
2007-02-16 09:27:49 +00:00
|
|
|
enum hrtimer_restart ret = HRTIMER_NORESTART;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-03-26 09:38:12 +00:00
|
|
|
timr = container_of(timer, struct k_itimer, it.real.timer);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(&timr->it_lock, flags);
|
|
|
|
|
2017-05-30 21:15:48 +00:00
|
|
|
timr->it_active = 0;
|
2017-05-30 21:15:43 +00:00
|
|
|
if (timr->it_interval != 0)
|
2006-01-10 04:52:38 +00:00
|
|
|
si_private = ++timr->it_requeue_pending;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-10 04:52:38 +00:00
|
|
|
if (posix_timer_event(timr, si_private)) {
|
|
|
|
/*
|
|
|
|
* signal was not sent because of sig_ignor
|
|
|
|
* we will not get a call back to restart it AND
|
|
|
|
* it should be restarted.
|
|
|
|
*/
|
2017-05-30 21:15:43 +00:00
|
|
|
if (timr->it_interval != 0) {
|
2007-06-21 20:45:15 +00:00
|
|
|
ktime_t now = hrtimer_cb_get_time(timer);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: What we really want, is to stop this
|
|
|
|
* timer completely and restart it in case the
|
|
|
|
* SIG_IGN is removed. This is a non trivial
|
|
|
|
* change which involves sighand locking
|
|
|
|
* (sigh !), which we don't want to do late in
|
|
|
|
* the release cycle.
|
|
|
|
*
|
|
|
|
* For now we just let timers with an interval
|
|
|
|
* less than a jiffie expire every jiffie to
|
|
|
|
* avoid softirq starvation in case of SIG_IGN
|
|
|
|
* and a very small interval, which would put
|
|
|
|
* the timer right back on the softirq pending
|
|
|
|
* list. By moving now ahead of time we trick
|
|
|
|
* hrtimer_forward() to expire the timer
|
|
|
|
* later, while we still maintain the overrun
|
|
|
|
* accuracy, but have some inconsistency in
|
|
|
|
* the timer_gettime() case. This is at least
|
|
|
|
* better than a starved softirq. A more
|
|
|
|
* complex fix which solves also another related
|
|
|
|
* inconsistency is already in the pipeline.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_HIGH_RES_TIMERS
|
|
|
|
{
|
2016-12-25 11:30:41 +00:00
|
|
|
ktime_t kj = NSEC_PER_SEC / HZ;
|
2007-06-21 20:45:15 +00:00
|
|
|
|
2017-05-30 21:15:43 +00:00
|
|
|
if (timr->it_interval < kj)
|
2007-06-21 20:45:15 +00:00
|
|
|
now = ktime_add(now, kj);
|
|
|
|
}
|
|
|
|
#endif
|
timerfd: new timerfd API
This is the new timerfd API as it is implemented by the following patch:
int timerfd_create(int clockid, int flags);
int timerfd_settime(int ufd, int flags,
const struct itimerspec *utmr,
struct itimerspec *otmr);
int timerfd_gettime(int ufd, struct itimerspec *otmr);
The timerfd_create() API creates an un-programmed timerfd fd. The "clockid"
parameter can be either CLOCK_MONOTONIC or CLOCK_REALTIME.
The timerfd_settime() API give new settings by the timerfd fd, by optionally
retrieving the previous expiration time (in case the "otmr" parameter is not
NULL).
The time value specified in "utmr" is absolute, if the TFD_TIMER_ABSTIME bit
is set in the "flags" parameter. Otherwise it's a relative time.
The timerfd_gettime() API returns the next expiration time of the timer, or
{0, 0} if the timerfd has not been set yet.
Like the previous timerfd API implementation, read(2) and poll(2) are
supported (with the same interface). Here's a simple test program I used to
exercise the new timerfd APIs:
http://www.xmailserver.org/timerfd-test2.c
[akpm@linux-foundation.org: coding-style cleanups]
[akpm@linux-foundation.org: fix ia64 build]
[akpm@linux-foundation.org: fix m68k build]
[akpm@linux-foundation.org: fix mips build]
[akpm@linux-foundation.org: fix alpha, arm, blackfin, cris, m68k, s390, sparc and sparc64 builds]
[heiko.carstens@de.ibm.com: fix s390]
[akpm@linux-foundation.org: fix powerpc build]
[akpm@linux-foundation.org: fix sparc64 more]
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Davide Libenzi <davidel@xmailserver.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Michael Kerrisk <mtk.manpages@gmail.com>
Cc: Davide Libenzi <davidel@xmailserver.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-05 06:27:26 +00:00
|
|
|
timr->it_overrun += (unsigned int)
|
2007-06-21 20:45:15 +00:00
|
|
|
hrtimer_forward(timer, now,
|
2017-05-30 21:15:43 +00:00
|
|
|
timr->it_interval);
|
2006-01-10 04:52:38 +00:00
|
|
|
ret = HRTIMER_RESTART;
|
2006-03-17 07:04:01 +00:00
|
|
|
++timr->it_requeue_pending;
|
2017-05-30 21:15:48 +00:00
|
|
|
timr->it_active = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-10 04:52:38 +00:00
|
|
|
unlock_timer(timr, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-01 22:18:13 +00:00
|
|
|
static struct pid *good_sigevent(sigevent_t * event)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct task_struct *rtn = current->group_leader;
|
|
|
|
|
2017-12-15 09:32:03 +00:00
|
|
|
switch (event->sigev_notify) {
|
|
|
|
case SIGEV_SIGNAL | SIGEV_THREAD_ID:
|
|
|
|
rtn = find_task_by_vpid(event->sigev_notify_thread_id);
|
|
|
|
if (!rtn || !same_thread_group(rtn, current))
|
|
|
|
return NULL;
|
|
|
|
/* FALLTHRU */
|
|
|
|
case SIGEV_SIGNAL:
|
|
|
|
case SIGEV_THREAD:
|
|
|
|
if (event->sigev_signo <= 0 || event->sigev_signo > SIGRTMAX)
|
|
|
|
return NULL;
|
|
|
|
/* FALLTHRU */
|
|
|
|
case SIGEV_NONE:
|
|
|
|
return task_pid(rtn);
|
|
|
|
default:
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
2017-12-15 09:32:03 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct k_itimer * alloc_posix_timer(void)
|
|
|
|
{
|
|
|
|
struct k_itimer *tmr;
|
2007-02-10 09:45:03 +00:00
|
|
|
tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!tmr)
|
|
|
|
return tmr;
|
|
|
|
if (unlikely(!(tmr->sigq = sigqueue_alloc()))) {
|
|
|
|
kmem_cache_free(posix_timers_cache, tmr);
|
2008-10-02 21:50:14 +00:00
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2017-08-19 00:56:27 +00:00
|
|
|
clear_siginfo(&tmr->sigq->info);
|
2005-04-16 22:20:36 +00:00
|
|
|
return tmr;
|
|
|
|
}
|
|
|
|
|
2011-05-24 09:12:58 +00:00
|
|
|
static void k_itimer_rcu_free(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct k_itimer *tmr = container_of(head, struct k_itimer, it.rcu);
|
|
|
|
|
|
|
|
kmem_cache_free(posix_timers_cache, tmr);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define IT_ID_SET 1
|
|
|
|
#define IT_ID_NOT_SET 0
|
|
|
|
static void release_posix_timer(struct k_itimer *tmr, int it_id_set)
|
|
|
|
{
|
|
|
|
if (it_id_set) {
|
|
|
|
unsigned long flags;
|
2013-03-11 09:12:21 +00:00
|
|
|
spin_lock_irqsave(&hash_lock, flags);
|
|
|
|
hlist_del_rcu(&tmr->t_hash);
|
|
|
|
spin_unlock_irqrestore(&hash_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-12-01 22:18:15 +00:00
|
|
|
put_pid(tmr->it_pid);
|
2005-04-16 22:20:36 +00:00
|
|
|
sigqueue_free(tmr->sigq);
|
2011-05-24 09:12:58 +00:00
|
|
|
call_rcu(&tmr->it.rcu, k_itimer_rcu_free);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-02-01 13:51:58 +00:00
|
|
|
static int common_timer_create(struct k_itimer *new_timer)
|
|
|
|
{
|
|
|
|
hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Create a POSIX.1b interval timer. */
|
2017-06-07 08:42:39 +00:00
|
|
|
static int do_timer_create(clockid_t which_clock, struct sigevent *event,
|
|
|
|
timer_t __user *created_timer_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2008-09-22 21:42:47 +00:00
|
|
|
struct k_itimer *new_timer;
|
2008-09-22 21:42:49 +00:00
|
|
|
int error, new_timer_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
int it_id_set = IT_ID_NOT_SET;
|
|
|
|
|
2011-02-01 13:51:58 +00:00
|
|
|
if (!kc)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2011-02-01 13:51:58 +00:00
|
|
|
if (!kc->timer_create)
|
|
|
|
return -EOPNOTSUPP;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
new_timer = alloc_posix_timer();
|
|
|
|
if (unlikely(!new_timer))
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
spin_lock_init(&new_timer->it_lock);
|
2013-03-11 09:12:21 +00:00
|
|
|
new_timer_id = posix_timer_add(new_timer);
|
|
|
|
if (new_timer_id < 0) {
|
|
|
|
error = new_timer_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
it_id_set = IT_ID_SET;
|
|
|
|
new_timer->it_id = (timer_t) new_timer_id;
|
|
|
|
new_timer->it_clock = which_clock;
|
2017-05-30 21:15:44 +00:00
|
|
|
new_timer->kclock = kc;
|
2005-04-16 22:20:36 +00:00
|
|
|
new_timer->it_overrun = -1;
|
|
|
|
|
2017-06-07 08:42:39 +00:00
|
|
|
if (event) {
|
2008-09-22 21:42:48 +00:00
|
|
|
rcu_read_lock();
|
2017-06-07 08:42:39 +00:00
|
|
|
new_timer->it_pid = get_pid(good_sigevent(event));
|
2008-09-22 21:42:48 +00:00
|
|
|
rcu_read_unlock();
|
2008-12-01 22:18:15 +00:00
|
|
|
if (!new_timer->it_pid) {
|
2005-04-16 22:20:36 +00:00
|
|
|
error = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2017-06-07 08:42:39 +00:00
|
|
|
new_timer->it_sigev_notify = event->sigev_notify;
|
|
|
|
new_timer->sigq->info.si_signo = event->sigev_signo;
|
|
|
|
new_timer->sigq->info.si_value = event->sigev_value;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2017-06-07 08:42:39 +00:00
|
|
|
new_timer->it_sigev_notify = SIGEV_SIGNAL;
|
|
|
|
new_timer->sigq->info.si_signo = SIGALRM;
|
|
|
|
memset(&new_timer->sigq->info.si_value, 0, sizeof(sigval_t));
|
|
|
|
new_timer->sigq->info.si_value.sival_int = new_timer->it_id;
|
2008-12-01 22:18:15 +00:00
|
|
|
new_timer->it_pid = get_pid(task_tgid(current));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-09-22 21:42:49 +00:00
|
|
|
new_timer->sigq->info.si_tid = new_timer->it_id;
|
2008-09-22 21:42:50 +00:00
|
|
|
new_timer->sigq->info.si_code = SI_TIMER;
|
2008-09-22 21:42:49 +00:00
|
|
|
|
2010-07-20 22:23:14 +00:00
|
|
|
if (copy_to_user(created_timer_id,
|
|
|
|
&new_timer_id, sizeof (new_timer_id))) {
|
|
|
|
error = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-02-01 13:51:58 +00:00
|
|
|
error = kc->timer_create(new_timer);
|
2010-05-24 19:15:33 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2008-09-22 21:42:48 +00:00
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
2008-12-01 22:18:13 +00:00
|
|
|
new_timer->it_signal = current->signal;
|
2008-09-22 21:42:48 +00:00
|
|
|
list_add(&new_timer->list, ¤t->signal->posix_timers);
|
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
2008-09-22 21:42:49 +00:00
|
|
|
|
|
|
|
return 0;
|
2011-02-01 13:51:58 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* In the case of the timer belonging to another task, after
|
|
|
|
* the task is unlocked, the timer is owned by the other task
|
|
|
|
* and may cease to exist at any time. Don't use or modify
|
|
|
|
* new_timer after the unlock call.
|
|
|
|
*/
|
|
|
|
out:
|
2008-09-22 21:42:49 +00:00
|
|
|
release_posix_timer(new_timer, it_id_set);
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-06-07 08:42:39 +00:00
|
|
|
SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock,
|
|
|
|
struct sigevent __user *, timer_event_spec,
|
|
|
|
timer_t __user *, created_timer_id)
|
|
|
|
{
|
|
|
|
if (timer_event_spec) {
|
|
|
|
sigevent_t event;
|
|
|
|
|
|
|
|
if (copy_from_user(&event, timer_event_spec, sizeof (event)))
|
|
|
|
return -EFAULT;
|
|
|
|
return do_timer_create(which_clock, &event, created_timer_id);
|
|
|
|
}
|
|
|
|
return do_timer_create(which_clock, NULL, created_timer_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
|
|
|
|
struct compat_sigevent __user *, timer_event_spec,
|
|
|
|
timer_t __user *, created_timer_id)
|
|
|
|
{
|
|
|
|
if (timer_event_spec) {
|
|
|
|
sigevent_t event;
|
|
|
|
|
|
|
|
if (get_compat_sigevent(&event, timer_event_spec))
|
|
|
|
return -EFAULT;
|
|
|
|
return do_timer_create(which_clock, &event, created_timer_id);
|
|
|
|
}
|
|
|
|
return do_timer_create(which_clock, NULL, created_timer_id);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Locking issues: We need to protect the result of the id look up until
|
|
|
|
* we get the timer locked down so it is not deleted under us. The
|
|
|
|
* removal is done under the idr spinlock so we use that here to bridge
|
|
|
|
* the find to the timer lock. To avoid a dead lock, the timer id MUST
|
|
|
|
* be release with out holding the timer lock.
|
|
|
|
*/
|
2010-10-20 22:57:34 +00:00
|
|
|
static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct k_itimer *timr;
|
2011-05-24 09:12:58 +00:00
|
|
|
|
2013-02-20 23:24:12 +00:00
|
|
|
/*
|
|
|
|
* timer_t could be any type >= int and we want to make sure any
|
|
|
|
* @timer_id outside positive int range fails lookup.
|
|
|
|
*/
|
|
|
|
if ((unsigned long long)timer_id > INT_MAX)
|
|
|
|
return NULL;
|
|
|
|
|
2011-05-24 09:12:58 +00:00
|
|
|
rcu_read_lock();
|
2013-03-11 09:12:21 +00:00
|
|
|
timr = posix_timer_by_id(timer_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (timr) {
|
2011-05-24 09:12:58 +00:00
|
|
|
spin_lock_irqsave(&timr->it_lock, *flags);
|
2008-12-01 22:18:15 +00:00
|
|
|
if (timr->it_signal == current->signal) {
|
2011-05-24 09:12:58 +00:00
|
|
|
rcu_read_unlock();
|
2008-09-22 21:42:51 +00:00
|
|
|
return timr;
|
|
|
|
}
|
2011-05-24 09:12:58 +00:00
|
|
|
spin_unlock_irqrestore(&timr->it_lock, *flags);
|
2008-09-22 21:42:51 +00:00
|
|
|
}
|
2011-05-24 09:12:58 +00:00
|
|
|
rcu_read_unlock();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-09-22 21:42:51 +00:00
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2017-05-30 21:15:50 +00:00
|
|
|
static ktime_t common_hrtimer_remaining(struct k_itimer *timr, ktime_t now)
|
|
|
|
{
|
|
|
|
struct hrtimer *timer = &timr->it.real.timer;
|
|
|
|
|
|
|
|
return __hrtimer_expires_remaining_adjusted(timer, now);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int common_hrtimer_forward(struct k_itimer *timr, ktime_t now)
|
|
|
|
{
|
|
|
|
struct hrtimer *timer = &timr->it.real.timer;
|
|
|
|
|
|
|
|
return (int)hrtimer_forward(timer, now, timr->it_interval);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Get the time remaining on a POSIX.1b interval timer. This function
|
|
|
|
* is ALWAYS called with spin_lock_irq on the timer, thus it must not
|
|
|
|
* mess with irq.
|
|
|
|
*
|
|
|
|
* We have a couple of messes to clean up here. First there is the case
|
|
|
|
* of a timer that has a requeue pending. These timers should appear to
|
|
|
|
* be in the timer list with an expiry as if we were to requeue them
|
|
|
|
* now.
|
|
|
|
*
|
|
|
|
* The second issue is the SIGEV_NONE timer which may be active but is
|
|
|
|
* not really ever put in the timer list (to save system resources).
|
|
|
|
* This timer may be expired, and if so, we will do it here. Otherwise
|
|
|
|
* it is the same as a requeue pending timer WRT to what we should
|
|
|
|
* report.
|
|
|
|
*/
|
2017-05-30 21:15:59 +00:00
|
|
|
void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-30 21:15:50 +00:00
|
|
|
const struct k_clock *kc = timr->kclock;
|
2006-03-26 09:38:07 +00:00
|
|
|
ktime_t now, remaining, iv;
|
2017-05-30 21:15:50 +00:00
|
|
|
struct timespec64 ts64;
|
|
|
|
bool sig_none;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-15 09:32:03 +00:00
|
|
|
sig_none = timr->it_sigev_notify == SIGEV_NONE;
|
2017-05-30 21:15:43 +00:00
|
|
|
iv = timr->it_interval;
|
2006-03-26 09:38:07 +00:00
|
|
|
|
2006-01-10 04:52:38 +00:00
|
|
|
/* interval timer ? */
|
2017-05-30 21:15:50 +00:00
|
|
|
if (iv) {
|
2017-03-26 19:04:17 +00:00
|
|
|
cur_setting->it_interval = ktime_to_timespec64(iv);
|
2017-05-30 21:15:50 +00:00
|
|
|
} else if (!timr->it_active) {
|
|
|
|
/*
|
|
|
|
* SIGEV_NONE oneshot timers are never queued. Check them
|
|
|
|
* below.
|
|
|
|
*/
|
|
|
|
if (!sig_none)
|
|
|
|
return;
|
|
|
|
}
|
2006-03-26 09:38:07 +00:00
|
|
|
|
2017-05-30 21:15:50 +00:00
|
|
|
/*
|
|
|
|
* The timespec64 based conversion is suboptimal, but it's not
|
|
|
|
* worth to implement yet another callback.
|
|
|
|
*/
|
|
|
|
kc->clock_get(timr->it_clock, &ts64);
|
|
|
|
now = timespec64_to_ktime(ts64);
|
2006-03-26 09:38:07 +00:00
|
|
|
|
2006-01-10 04:52:38 +00:00
|
|
|
/*
|
2017-05-30 21:15:50 +00:00
|
|
|
* When a requeue is pending or this is a SIGEV_NONE timer move the
|
|
|
|
* expiry time forward by intervals, so expiry is > now.
|
2006-01-10 04:52:38 +00:00
|
|
|
*/
|
2017-05-30 21:15:50 +00:00
|
|
|
if (iv && (timr->it_requeue_pending & REQUEUE_PENDING || sig_none))
|
|
|
|
timr->it_overrun += kc->timer_forward(timr, now);
|
2006-03-26 09:38:07 +00:00
|
|
|
|
2017-05-30 21:15:50 +00:00
|
|
|
remaining = kc->timer_remaining(timr, now);
|
2006-01-10 04:52:38 +00:00
|
|
|
/* Return 0 only, when the timer is expired and not pending */
|
2016-12-25 10:38:40 +00:00
|
|
|
if (remaining <= 0) {
|
2006-03-26 09:38:07 +00:00
|
|
|
/*
|
|
|
|
* A single shot SIGEV_NONE timer must return 0, when
|
|
|
|
* it is expired !
|
|
|
|
*/
|
2017-05-30 21:15:50 +00:00
|
|
|
if (!sig_none)
|
2006-03-26 09:38:07 +00:00
|
|
|
cur_setting->it_value.tv_nsec = 1;
|
2017-05-30 21:15:50 +00:00
|
|
|
} else {
|
2017-03-26 19:04:17 +00:00
|
|
|
cur_setting->it_value = ktime_to_timespec64(remaining);
|
2017-05-30 21:15:50 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the time remaining on a POSIX.1b interval timer. */
|
2017-06-07 08:42:36 +00:00
|
|
|
static int do_timer_gettime(timer_t timer_id, struct itimerspec64 *setting)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-02-01 13:52:04 +00:00
|
|
|
struct k_itimer *timr;
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
2011-02-01 13:52:04 +00:00
|
|
|
int ret = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
timr = lock_timer(timer_id, &flags);
|
|
|
|
if (!timr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-07 08:42:36 +00:00
|
|
|
memset(setting, 0, sizeof(*setting));
|
2017-05-30 21:15:44 +00:00
|
|
|
kc = timr->kclock;
|
2011-02-01 13:52:04 +00:00
|
|
|
if (WARN_ON_ONCE(!kc || !kc->timer_get))
|
|
|
|
ret = -EINVAL;
|
|
|
|
else
|
2017-06-07 08:42:36 +00:00
|
|
|
kc->timer_get(timr, setting);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unlock_timer(timr, flags);
|
2017-06-07 08:42:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-07 08:42:36 +00:00
|
|
|
/* Get the time remaining on a POSIX.1b interval timer. */
|
|
|
|
SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
|
|
|
|
struct itimerspec __user *, setting)
|
|
|
|
{
|
2017-06-24 18:45:08 +00:00
|
|
|
struct itimerspec64 cur_setting;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-24 18:45:08 +00:00
|
|
|
int ret = do_timer_gettime(timer_id, &cur_setting);
|
2017-06-07 08:42:36 +00:00
|
|
|
if (!ret) {
|
2017-06-24 18:45:08 +00:00
|
|
|
if (put_itimerspec64(&cur_setting, setting))
|
2017-06-07 08:42:36 +00:00
|
|
|
ret = -EFAULT;
|
|
|
|
}
|
2011-02-01 13:52:04 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-01-10 04:52:38 +00:00
|
|
|
|
2017-06-07 08:42:36 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
|
|
|
|
struct compat_itimerspec __user *, setting)
|
|
|
|
{
|
2017-06-24 18:45:08 +00:00
|
|
|
struct itimerspec64 cur_setting;
|
2017-06-07 08:42:36 +00:00
|
|
|
|
2017-06-24 18:45:08 +00:00
|
|
|
int ret = do_timer_gettime(timer_id, &cur_setting);
|
2017-06-07 08:42:36 +00:00
|
|
|
if (!ret) {
|
2017-06-24 18:45:08 +00:00
|
|
|
if (put_compat_itimerspec64(&cur_setting, setting))
|
2017-06-07 08:42:36 +00:00
|
|
|
ret = -EFAULT;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Get the number of overruns of a POSIX.1b interval timer. This is to
|
|
|
|
* be the overrun of the timer last delivered. At the same time we are
|
|
|
|
* accumulating overruns on the next timer. The overrun is frozen when
|
|
|
|
* the signal is delivered, either at the notify time (if the info block
|
|
|
|
* is not queued) or at the actual delivery time (as we are informed by
|
2017-05-30 21:15:46 +00:00
|
|
|
* the call back to posixtimer_rearm(). So all we need to do is
|
2005-04-16 22:20:36 +00:00
|
|
|
* to pick up the frozen overrun.
|
|
|
|
*/
|
2009-01-14 13:14:07 +00:00
|
|
|
SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct k_itimer *timr;
|
|
|
|
int overrun;
|
2007-10-14 18:35:50 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
timr = lock_timer(timer_id, &flags);
|
|
|
|
if (!timr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
overrun = timr->it_overrun_last;
|
|
|
|
unlock_timer(timr, flags);
|
|
|
|
|
|
|
|
return overrun;
|
|
|
|
}
|
|
|
|
|
2017-05-30 21:15:53 +00:00
|
|
|
static void common_hrtimer_arm(struct k_itimer *timr, ktime_t expires,
|
|
|
|
bool absolute, bool sigev_none)
|
|
|
|
{
|
|
|
|
struct hrtimer *timer = &timr->it.real.timer;
|
|
|
|
enum hrtimer_mode mode;
|
|
|
|
|
|
|
|
mode = absolute ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
|
2017-06-12 17:39:49 +00:00
|
|
|
/*
|
|
|
|
* Posix magic: Relative CLOCK_REALTIME timers are not affected by
|
|
|
|
* clock modifications, so they become CLOCK_MONOTONIC based under the
|
|
|
|
* hood. See hrtimer_init(). Update timr->kclock, so the generic
|
|
|
|
* functions which use timr->kclock->clock_get() work.
|
|
|
|
*
|
|
|
|
* Note: it_clock stays unmodified, because the next timer_set() might
|
|
|
|
* use ABSTIME, so it needs to switch back.
|
|
|
|
*/
|
|
|
|
if (timr->it_clock == CLOCK_REALTIME)
|
|
|
|
timr->kclock = absolute ? &clock_realtime : &clock_monotonic;
|
|
|
|
|
2017-05-30 21:15:53 +00:00
|
|
|
hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
|
|
|
|
timr->it.real.timer.function = posix_timer_fn;
|
|
|
|
|
|
|
|
if (!absolute)
|
|
|
|
expires = ktime_add_safe(expires, timer->base->get_time());
|
|
|
|
hrtimer_set_expires(timer, expires);
|
|
|
|
|
|
|
|
if (!sigev_none)
|
|
|
|
hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int common_hrtimer_try_to_cancel(struct k_itimer *timr)
|
|
|
|
{
|
|
|
|
return hrtimer_try_to_cancel(&timr->it.real.timer);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Set a POSIX.1b interval timer. */
|
2017-05-30 21:15:59 +00:00
|
|
|
int common_timer_set(struct k_itimer *timr, int flags,
|
|
|
|
struct itimerspec64 *new_setting,
|
|
|
|
struct itimerspec64 *old_setting)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-30 21:15:53 +00:00
|
|
|
const struct k_clock *kc = timr->kclock;
|
|
|
|
bool sigev_none;
|
|
|
|
ktime_t expires;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (old_setting)
|
|
|
|
common_timer_get(timr, old_setting);
|
|
|
|
|
2017-05-30 21:15:53 +00:00
|
|
|
/* Prevent rearming by clearing the interval */
|
2017-05-30 21:15:43 +00:00
|
|
|
timr->it_interval = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2017-05-30 21:15:53 +00:00
|
|
|
* Careful here. On SMP systems the timer expiry function could be
|
|
|
|
* active and spinning on timr->it_lock.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2017-05-30 21:15:53 +00:00
|
|
|
if (kc->timer_try_to_cancel(timr) < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return TIMER_RETRY;
|
|
|
|
|
2017-05-30 21:15:48 +00:00
|
|
|
timr->it_active = 0;
|
|
|
|
timr->it_requeue_pending = (timr->it_requeue_pending + 2) &
|
2005-04-16 22:20:36 +00:00
|
|
|
~REQUEUE_PENDING;
|
|
|
|
timr->it_overrun_last = 0;
|
|
|
|
|
2017-05-30 21:15:53 +00:00
|
|
|
/* Switch off the timer when it_value is zero */
|
2006-01-10 04:52:38 +00:00
|
|
|
if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-30 21:15:43 +00:00
|
|
|
timr->it_interval = timespec64_to_ktime(new_setting->it_interval);
|
2017-05-30 21:15:53 +00:00
|
|
|
expires = timespec64_to_ktime(new_setting->it_value);
|
2017-12-15 09:32:03 +00:00
|
|
|
sigev_none = timr->it_sigev_notify == SIGEV_NONE;
|
2006-01-10 04:52:38 +00:00
|
|
|
|
2017-05-30 21:15:53 +00:00
|
|
|
kc->timer_arm(timr, expires, flags & TIMER_ABSTIME, sigev_none);
|
|
|
|
timr->it_active = !sigev_none;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-07 08:42:35 +00:00
|
|
|
static int do_timer_settime(timer_t timer_id, int flags,
|
|
|
|
struct itimerspec64 *new_spec64,
|
|
|
|
struct itimerspec64 *old_spec64)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-06-07 08:42:35 +00:00
|
|
|
const struct k_clock *kc;
|
2017-03-26 19:04:17 +00:00
|
|
|
struct k_itimer *timr;
|
2007-10-14 18:35:50 +00:00
|
|
|
unsigned long flag;
|
2017-03-26 19:04:17 +00:00
|
|
|
int error = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-07 08:42:35 +00:00
|
|
|
if (!timespec64_valid(&new_spec64->it_interval) ||
|
|
|
|
!timespec64_valid(&new_spec64->it_value))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-07 08:42:35 +00:00
|
|
|
if (old_spec64)
|
|
|
|
memset(old_spec64, 0, sizeof(*old_spec64));
|
2005-04-16 22:20:36 +00:00
|
|
|
retry:
|
|
|
|
timr = lock_timer(timer_id, &flag);
|
|
|
|
if (!timr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-05-30 21:15:44 +00:00
|
|
|
kc = timr->kclock;
|
2011-02-01 13:52:01 +00:00
|
|
|
if (WARN_ON_ONCE(!kc || !kc->timer_set))
|
|
|
|
error = -EINVAL;
|
|
|
|
else
|
2017-06-07 08:42:35 +00:00
|
|
|
error = kc->timer_set(timr, flags, new_spec64, old_spec64);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unlock_timer(timr, flag);
|
|
|
|
if (error == TIMER_RETRY) {
|
2017-06-07 08:42:35 +00:00
|
|
|
old_spec64 = NULL; // We already got the old time...
|
2005-04-16 22:20:36 +00:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2017-06-07 08:42:35 +00:00
|
|
|
return error;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-07 08:42:35 +00:00
|
|
|
/* Set a POSIX.1b interval timer */
|
|
|
|
SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
|
|
|
|
const struct itimerspec __user *, new_setting,
|
|
|
|
struct itimerspec __user *, old_setting)
|
|
|
|
{
|
2017-06-24 18:45:08 +00:00
|
|
|
struct itimerspec64 new_spec, old_spec;
|
|
|
|
struct itimerspec64 *rtn = old_setting ? &old_spec : NULL;
|
2017-06-07 08:42:35 +00:00
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (!new_setting)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-24 18:45:08 +00:00
|
|
|
if (get_itimerspec64(&new_spec, new_setting))
|
2017-06-07 08:42:35 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
2017-06-24 18:45:08 +00:00
|
|
|
error = do_timer_settime(timer_id, flags, &new_spec, rtn);
|
2017-06-07 08:42:35 +00:00
|
|
|
if (!error && old_setting) {
|
2017-06-24 18:45:08 +00:00
|
|
|
if (put_itimerspec64(&old_spec, old_setting))
|
2017-06-07 08:42:35 +00:00
|
|
|
error = -EFAULT;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
|
|
|
|
struct compat_itimerspec __user *, new,
|
|
|
|
struct compat_itimerspec __user *, old)
|
|
|
|
{
|
2017-06-24 18:45:08 +00:00
|
|
|
struct itimerspec64 new_spec, old_spec;
|
|
|
|
struct itimerspec64 *rtn = old ? &old_spec : NULL;
|
2017-06-07 08:42:35 +00:00
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (!new)
|
|
|
|
return -EINVAL;
|
2017-06-24 18:45:08 +00:00
|
|
|
if (get_compat_itimerspec64(&new_spec, new))
|
2017-06-07 08:42:35 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
2017-06-24 18:45:08 +00:00
|
|
|
error = do_timer_settime(timer_id, flags, &new_spec, rtn);
|
2017-06-07 08:42:35 +00:00
|
|
|
if (!error && old) {
|
2017-06-24 18:45:08 +00:00
|
|
|
if (put_compat_itimerspec64(&old_spec, old))
|
2017-06-07 08:42:35 +00:00
|
|
|
error = -EFAULT;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
|
|
|
}
|
2017-06-07 08:42:35 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-30 21:15:59 +00:00
|
|
|
int common_timer_del(struct k_itimer *timer)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-30 21:15:53 +00:00
|
|
|
const struct k_clock *kc = timer->kclock;
|
2005-06-23 07:09:00 +00:00
|
|
|
|
2017-05-30 21:15:53 +00:00
|
|
|
timer->it_interval = 0;
|
|
|
|
if (kc->timer_try_to_cancel(timer) < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return TIMER_RETRY;
|
2017-05-30 21:15:48 +00:00
|
|
|
timer->it_active = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int timer_delete_hook(struct k_itimer *timer)
|
|
|
|
{
|
2017-05-30 21:15:44 +00:00
|
|
|
const struct k_clock *kc = timer->kclock;
|
2011-02-01 13:52:07 +00:00
|
|
|
|
|
|
|
if (WARN_ON_ONCE(!kc || !kc->timer_del))
|
|
|
|
return -EINVAL;
|
|
|
|
return kc->timer_del(timer);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Delete a POSIX.1b interval timer. */
|
2009-01-14 13:14:07 +00:00
|
|
|
SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct k_itimer *timer;
|
2007-10-14 18:35:50 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
retry_delete:
|
|
|
|
timer = lock_timer(timer_id, &flags);
|
|
|
|
if (!timer)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-01-10 04:52:38 +00:00
|
|
|
if (timer_delete_hook(timer) == TIMER_RETRY) {
|
2005-04-16 22:20:36 +00:00
|
|
|
unlock_timer(timer, flags);
|
|
|
|
goto retry_delete;
|
|
|
|
}
|
2006-01-10 04:52:38 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock(¤t->sighand->siglock);
|
|
|
|
list_del(&timer->list);
|
|
|
|
spin_unlock(¤t->sighand->siglock);
|
|
|
|
/*
|
|
|
|
* This keeps any tasks waiting on the spin lock from thinking
|
|
|
|
* they got something (see the lock code above).
|
|
|
|
*/
|
2008-12-01 22:18:15 +00:00
|
|
|
timer->it_signal = NULL;
|
2008-07-25 08:47:26 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unlock_timer(timer, flags);
|
|
|
|
release_posix_timer(timer, IT_ID_SET);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-01-10 04:52:38 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* return timer owned by the process, used by exit_itimers
|
|
|
|
*/
|
2006-01-14 21:20:43 +00:00
|
|
|
static void itimer_delete(struct k_itimer *timer)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
retry_delete:
|
|
|
|
spin_lock_irqsave(&timer->it_lock, flags);
|
|
|
|
|
2006-01-10 04:52:38 +00:00
|
|
|
if (timer_delete_hook(timer) == TIMER_RETRY) {
|
2005-04-16 22:20:36 +00:00
|
|
|
unlock_timer(timer, flags);
|
|
|
|
goto retry_delete;
|
|
|
|
}
|
|
|
|
list_del(&timer->list);
|
|
|
|
/*
|
|
|
|
* This keeps any tasks waiting on the spin lock from thinking
|
|
|
|
* they got something (see the lock code above).
|
|
|
|
*/
|
2008-12-01 22:18:15 +00:00
|
|
|
timer->it_signal = NULL;
|
2008-07-25 08:47:26 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unlock_timer(timer, flags);
|
|
|
|
release_posix_timer(timer, IT_ID_SET);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-10-21 22:03:29 +00:00
|
|
|
* This is called by do_exit or de_thread, only when there are no more
|
2005-04-16 22:20:36 +00:00
|
|
|
* references to the shared signal_struct.
|
|
|
|
*/
|
|
|
|
void exit_itimers(struct signal_struct *sig)
|
|
|
|
{
|
|
|
|
struct k_itimer *tmr;
|
|
|
|
|
|
|
|
while (!list_empty(&sig->posix_timers)) {
|
|
|
|
tmr = list_entry(sig->posix_timers.next, struct k_itimer, list);
|
|
|
|
itimer_delete(tmr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-14 13:14:07 +00:00
|
|
|
SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
|
|
|
|
const struct timespec __user *, tp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:05 +00:00
|
|
|
struct timespec64 new_tp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-02-01 13:51:48 +00:00
|
|
|
if (!kc || !kc->clock_set)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2011-02-01 13:51:48 +00:00
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
if (get_timespec64(&new_tp, tp))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
return kc->clock_set(which_clock, &new_tp);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 13:14:07 +00:00
|
|
|
SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock,
|
|
|
|
struct timespec __user *,tp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:05 +00:00
|
|
|
struct timespec64 kernel_tp;
|
2005-04-16 22:20:36 +00:00
|
|
|
int error;
|
|
|
|
|
2011-02-01 13:51:50 +00:00
|
|
|
if (!kc)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2011-02-01 13:51:50 +00:00
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
error = kc->clock_get(which_clock, &kernel_tp);
|
2011-02-01 13:51:50 +00:00
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
if (!error && put_timespec64(&kernel_tp, tp))
|
2005-04-16 22:20:36 +00:00
|
|
|
error = -EFAULT;
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2011-02-01 13:52:26 +00:00
|
|
|
SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock,
|
|
|
|
struct timex __user *, utx)
|
|
|
|
{
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2011-02-01 13:52:26 +00:00
|
|
|
struct timex ktx;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!kc)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!kc->clock_adj)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (copy_from_user(&ktx, utx, sizeof(ktx)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
err = kc->clock_adj(which_clock, &ktx);
|
|
|
|
|
2013-01-11 10:58:58 +00:00
|
|
|
if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx)))
|
2011-02-01 13:52:26 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-06-07 08:42:38 +00:00
|
|
|
SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock,
|
|
|
|
struct timespec __user *, tp)
|
|
|
|
{
|
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:05 +00:00
|
|
|
struct timespec64 rtn_tp;
|
2017-06-07 08:42:38 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!kc)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
error = kc->clock_getres(which_clock, &rtn_tp);
|
2017-06-07 08:42:38 +00:00
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
if (!error && tp && put_timespec64(&rtn_tp, tp))
|
2017-06-07 08:42:38 +00:00
|
|
|
error = -EFAULT;
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-06-07 08:42:34 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
|
2017-06-07 08:42:38 +00:00
|
|
|
COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
|
|
|
|
struct compat_timespec __user *, tp)
|
|
|
|
{
|
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:05 +00:00
|
|
|
struct timespec64 ts;
|
2017-06-07 08:42:38 +00:00
|
|
|
|
|
|
|
if (!kc || !kc->clock_set)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
if (compat_get_timespec64(&ts, tp))
|
2017-06-07 08:42:38 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
return kc->clock_set(which_clock, &ts);
|
2017-06-07 08:42:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
|
|
|
|
struct compat_timespec __user *, tp)
|
|
|
|
{
|
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:05 +00:00
|
|
|
struct timespec64 ts;
|
|
|
|
int err;
|
2017-06-07 08:42:38 +00:00
|
|
|
|
|
|
|
if (!kc)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
err = kc->clock_get(which_clock, &ts);
|
2017-06-07 08:42:38 +00:00
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
if (!err && compat_put_timespec64(&ts, tp))
|
|
|
|
err = -EFAULT;
|
2017-06-07 08:42:38 +00:00
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
return err;
|
2017-06-07 08:42:38 +00:00
|
|
|
}
|
|
|
|
|
2017-06-07 08:42:34 +00:00
|
|
|
COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
|
|
|
|
struct compat_timex __user *, utp)
|
|
|
|
{
|
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
|
|
|
struct timex ktx;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!kc)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!kc->clock_adj)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
err = compat_get_timex(&ktx, utp);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = kc->clock_adj(which_clock, &ktx);
|
|
|
|
|
|
|
|
if (err >= 0)
|
|
|
|
err = compat_put_timex(utp, &ktx);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-06-07 08:42:38 +00:00
|
|
|
COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
|
|
|
|
struct compat_timespec __user *, tp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:05 +00:00
|
|
|
struct timespec64 ts;
|
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-02-01 13:51:53 +00:00
|
|
|
if (!kc)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
err = kc->clock_getres(which_clock, &ts);
|
|
|
|
if (!err && tp && compat_put_timespec64(&ts, tp))
|
|
|
|
return -EFAULT;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-24 18:45:05 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2017-06-24 18:45:05 +00:00
|
|
|
|
2017-06-07 08:42:38 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-10 04:52:37 +00:00
|
|
|
/*
|
|
|
|
* nanosleep for monotonic and realtime clocks
|
|
|
|
*/
|
|
|
|
static int common_nsleep(const clockid_t which_clock, int flags,
|
2017-06-13 21:34:33 +00:00
|
|
|
const struct timespec64 *rqtp)
|
2006-01-10 04:52:37 +00:00
|
|
|
{
|
2017-06-13 21:34:33 +00:00
|
|
|
return hrtimer_nanosleep(rqtp, flags & TIMER_ABSTIME ?
|
2008-02-01 14:29:05 +00:00
|
|
|
HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
|
|
|
|
which_clock);
|
2006-01-10 04:52:37 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-14 13:14:07 +00:00
|
|
|
SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags,
|
|
|
|
const struct timespec __user *, rqtp,
|
|
|
|
struct timespec __user *, rmtp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:06 +00:00
|
|
|
struct timespec64 t;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-02-01 13:51:11 +00:00
|
|
|
if (!kc)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2011-02-01 13:51:11 +00:00
|
|
|
if (!kc->nsleep)
|
|
|
|
return -ENANOSLEEP_NOTSUP;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-24 18:45:06 +00:00
|
|
|
if (get_timespec64(&t, rqtp))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
|
2017-06-24 18:45:06 +00:00
|
|
|
if (!timespec64_valid(&t))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
2017-06-07 08:42:30 +00:00
|
|
|
if (flags & TIMER_ABSTIME)
|
|
|
|
rmtp = NULL;
|
2017-06-07 08:42:31 +00:00
|
|
|
current->restart_block.nanosleep.type = rmtp ? TT_NATIVE : TT_NONE;
|
2017-06-07 08:42:30 +00:00
|
|
|
current->restart_block.nanosleep.rmtp = rmtp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-24 18:45:06 +00:00
|
|
|
return kc->nsleep(which_clock, flags, &t);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-09-29 09:00:28 +00:00
|
|
|
|
2017-06-07 08:42:31 +00:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
|
|
|
|
struct compat_timespec __user *, rqtp,
|
|
|
|
struct compat_timespec __user *, rmtp)
|
2006-09-29 09:00:28 +00:00
|
|
|
{
|
2017-05-26 09:03:11 +00:00
|
|
|
const struct k_clock *kc = clockid_to_kclock(which_clock);
|
2017-06-24 18:45:06 +00:00
|
|
|
struct timespec64 t;
|
2011-02-01 13:51:17 +00:00
|
|
|
|
2017-06-07 08:42:31 +00:00
|
|
|
if (!kc)
|
2011-02-01 13:51:17 +00:00
|
|
|
return -EINVAL;
|
2017-06-07 08:42:31 +00:00
|
|
|
if (!kc->nsleep)
|
|
|
|
return -ENANOSLEEP_NOTSUP;
|
|
|
|
|
2017-06-24 18:45:06 +00:00
|
|
|
if (compat_get_timespec64(&t, rqtp))
|
2017-06-07 08:42:31 +00:00
|
|
|
return -EFAULT;
|
2006-09-29 09:00:28 +00:00
|
|
|
|
2017-06-24 18:45:06 +00:00
|
|
|
if (!timespec64_valid(&t))
|
2017-06-07 08:42:31 +00:00
|
|
|
return -EINVAL;
|
|
|
|
if (flags & TIMER_ABSTIME)
|
|
|
|
rmtp = NULL;
|
|
|
|
current->restart_block.nanosleep.type = rmtp ? TT_COMPAT : TT_NONE;
|
|
|
|
current->restart_block.nanosleep.compat_rmtp = rmtp;
|
|
|
|
|
2017-06-24 18:45:06 +00:00
|
|
|
return kc->nsleep(which_clock, flags, &t);
|
2006-09-29 09:00:28 +00:00
|
|
|
}
|
2017-06-07 08:42:31 +00:00
|
|
|
#endif
|
2017-05-30 21:15:39 +00:00
|
|
|
|
|
|
|
static const struct k_clock clock_realtime = {
|
2017-05-30 21:15:53 +00:00
|
|
|
.clock_getres = posix_get_hrtimer_res,
|
|
|
|
.clock_get = posix_clock_realtime_get,
|
|
|
|
.clock_set = posix_clock_realtime_set,
|
|
|
|
.clock_adj = posix_clock_realtime_adj,
|
|
|
|
.nsleep = common_nsleep,
|
|
|
|
.timer_create = common_timer_create,
|
|
|
|
.timer_set = common_timer_set,
|
|
|
|
.timer_get = common_timer_get,
|
|
|
|
.timer_del = common_timer_del,
|
|
|
|
.timer_rearm = common_hrtimer_rearm,
|
|
|
|
.timer_forward = common_hrtimer_forward,
|
|
|
|
.timer_remaining = common_hrtimer_remaining,
|
|
|
|
.timer_try_to_cancel = common_hrtimer_try_to_cancel,
|
|
|
|
.timer_arm = common_hrtimer_arm,
|
2017-05-30 21:15:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct k_clock clock_monotonic = {
|
2017-05-30 21:15:53 +00:00
|
|
|
.clock_getres = posix_get_hrtimer_res,
|
|
|
|
.clock_get = posix_ktime_get_ts,
|
|
|
|
.nsleep = common_nsleep,
|
|
|
|
.timer_create = common_timer_create,
|
|
|
|
.timer_set = common_timer_set,
|
|
|
|
.timer_get = common_timer_get,
|
|
|
|
.timer_del = common_timer_del,
|
|
|
|
.timer_rearm = common_hrtimer_rearm,
|
|
|
|
.timer_forward = common_hrtimer_forward,
|
|
|
|
.timer_remaining = common_hrtimer_remaining,
|
|
|
|
.timer_try_to_cancel = common_hrtimer_try_to_cancel,
|
|
|
|
.timer_arm = common_hrtimer_arm,
|
2017-05-30 21:15:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct k_clock clock_monotonic_raw = {
|
2017-05-30 21:15:53 +00:00
|
|
|
.clock_getres = posix_get_hrtimer_res,
|
|
|
|
.clock_get = posix_get_monotonic_raw,
|
2017-05-30 21:15:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct k_clock clock_realtime_coarse = {
|
2017-05-30 21:15:53 +00:00
|
|
|
.clock_getres = posix_get_coarse_res,
|
|
|
|
.clock_get = posix_get_realtime_coarse,
|
2017-05-30 21:15:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct k_clock clock_monotonic_coarse = {
|
2017-05-30 21:15:53 +00:00
|
|
|
.clock_getres = posix_get_coarse_res,
|
|
|
|
.clock_get = posix_get_monotonic_coarse,
|
2017-05-30 21:15:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct k_clock clock_tai = {
|
2017-05-30 21:15:53 +00:00
|
|
|
.clock_getres = posix_get_hrtimer_res,
|
|
|
|
.clock_get = posix_get_tai,
|
|
|
|
.nsleep = common_nsleep,
|
|
|
|
.timer_create = common_timer_create,
|
|
|
|
.timer_set = common_timer_set,
|
|
|
|
.timer_get = common_timer_get,
|
|
|
|
.timer_del = common_timer_del,
|
|
|
|
.timer_rearm = common_hrtimer_rearm,
|
|
|
|
.timer_forward = common_hrtimer_forward,
|
|
|
|
.timer_remaining = common_hrtimer_remaining,
|
|
|
|
.timer_try_to_cancel = common_hrtimer_try_to_cancel,
|
|
|
|
.timer_arm = common_hrtimer_arm,
|
2017-05-30 21:15:39 +00:00
|
|
|
};
|
|
|
|
|
2018-04-25 13:33:38 +00:00
|
|
|
static const struct k_clock clock_boottime = {
|
2017-05-30 21:15:53 +00:00
|
|
|
.clock_getres = posix_get_hrtimer_res,
|
2018-04-25 13:33:38 +00:00
|
|
|
.clock_get = posix_get_boottime,
|
|
|
|
.nsleep = common_nsleep,
|
|
|
|
.timer_create = common_timer_create,
|
|
|
|
.timer_set = common_timer_set,
|
|
|
|
.timer_get = common_timer_get,
|
|
|
|
.timer_del = common_timer_del,
|
|
|
|
.timer_rearm = common_hrtimer_rearm,
|
|
|
|
.timer_forward = common_hrtimer_forward,
|
|
|
|
.timer_remaining = common_hrtimer_remaining,
|
|
|
|
.timer_try_to_cancel = common_hrtimer_try_to_cancel,
|
|
|
|
.timer_arm = common_hrtimer_arm,
|
2017-05-30 21:15:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct k_clock * const posix_clocks[] = {
|
|
|
|
[CLOCK_REALTIME] = &clock_realtime,
|
|
|
|
[CLOCK_MONOTONIC] = &clock_monotonic,
|
|
|
|
[CLOCK_PROCESS_CPUTIME_ID] = &clock_process,
|
|
|
|
[CLOCK_THREAD_CPUTIME_ID] = &clock_thread,
|
|
|
|
[CLOCK_MONOTONIC_RAW] = &clock_monotonic_raw,
|
|
|
|
[CLOCK_REALTIME_COARSE] = &clock_realtime_coarse,
|
|
|
|
[CLOCK_MONOTONIC_COARSE] = &clock_monotonic_coarse,
|
2018-04-25 13:33:38 +00:00
|
|
|
[CLOCK_BOOTTIME] = &clock_boottime,
|
2017-05-30 21:15:39 +00:00
|
|
|
[CLOCK_REALTIME_ALARM] = &alarm_clock,
|
|
|
|
[CLOCK_BOOTTIME_ALARM] = &alarm_clock,
|
|
|
|
[CLOCK_TAI] = &clock_tai,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct k_clock *clockid_to_kclock(const clockid_t id)
|
|
|
|
{
|
2018-02-15 16:21:55 +00:00
|
|
|
clockid_t idx = id;
|
|
|
|
|
|
|
|
if (id < 0) {
|
2017-05-30 21:15:39 +00:00
|
|
|
return (id & CLOCKFD_MASK) == CLOCKFD ?
|
|
|
|
&clock_posix_dynamic : &clock_posix_cpu;
|
2018-02-15 16:21:55 +00:00
|
|
|
}
|
2017-05-30 21:15:39 +00:00
|
|
|
|
2018-02-15 16:21:55 +00:00
|
|
|
if (id >= ARRAY_SIZE(posix_clocks))
|
2017-05-30 21:15:39 +00:00
|
|
|
return NULL;
|
2018-02-15 16:21:55 +00:00
|
|
|
|
|
|
|
return posix_clocks[array_index_nospec(idx, ARRAY_SIZE(posix_clocks))];
|
2017-05-30 21:15:39 +00:00
|
|
|
}
|