2018-10-31 18:21:09 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2006-01-10 04:52:32 +00:00
|
|
|
/*
|
|
|
|
* hrtimers - High-resolution kernel timers
|
|
|
|
*
|
|
|
|
* Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
|
|
|
|
* Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
|
|
|
|
*
|
|
|
|
* data type definitions, declarations, prototypes
|
|
|
|
*
|
|
|
|
* Started by: Thomas Gleixner and Ingo Molnar
|
|
|
|
*/
|
|
|
|
#ifndef _LINUX_HRTIMER_H
|
|
|
|
#define _LINUX_HRTIMER_H
|
|
|
|
|
2019-06-22 13:02:07 +00:00
|
|
|
#include <linux/hrtimer_defs.h>
|
2006-01-10 04:52:32 +00:00
|
|
|
#include <linux/rbtree.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/list.h>
|
2008-10-15 03:20:28 +00:00
|
|
|
#include <linux/percpu.h>
|
2020-08-06 12:35:11 +00:00
|
|
|
#include <linux/seqlock.h>
|
2009-06-23 15:38:15 +00:00
|
|
|
#include <linux/timer.h>
|
2010-09-21 02:19:17 +00:00
|
|
|
#include <linux/timerqueue.h>
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2007-02-16 09:27:50 +00:00
|
|
|
struct hrtimer_clock_base;
|
|
|
|
struct hrtimer_cpu_base;
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/*
|
|
|
|
* Mode arguments of xxx_hrtimer functions:
|
2017-12-21 10:41:36 +00:00
|
|
|
*
|
|
|
|
* HRTIMER_MODE_ABS - Time value is absolute
|
|
|
|
* HRTIMER_MODE_REL - Time value is relative to now
|
|
|
|
* HRTIMER_MODE_PINNED - Timer is bound to CPU (is only considered
|
|
|
|
* when starting the timer)
|
2017-12-21 10:41:55 +00:00
|
|
|
* HRTIMER_MODE_SOFT - Timer callback function will be executed in
|
|
|
|
* soft irq context
|
2019-08-23 11:38:44 +00:00
|
|
|
* HRTIMER_MODE_HARD - Timer callback function will be executed in
|
|
|
|
* hard irq context even on PREEMPT_RT.
|
2006-01-10 04:52:32 +00:00
|
|
|
*/
|
|
|
|
enum hrtimer_mode {
|
2017-12-21 10:41:36 +00:00
|
|
|
HRTIMER_MODE_ABS = 0x00,
|
|
|
|
HRTIMER_MODE_REL = 0x01,
|
|
|
|
HRTIMER_MODE_PINNED = 0x02,
|
2017-12-21 10:41:55 +00:00
|
|
|
HRTIMER_MODE_SOFT = 0x04,
|
2019-07-26 18:30:51 +00:00
|
|
|
HRTIMER_MODE_HARD = 0x08,
|
2017-12-21 10:41:36 +00:00
|
|
|
|
|
|
|
HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
|
|
|
|
HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
|
2017-12-21 10:41:55 +00:00
|
|
|
|
|
|
|
HRTIMER_MODE_ABS_SOFT = HRTIMER_MODE_ABS | HRTIMER_MODE_SOFT,
|
|
|
|
HRTIMER_MODE_REL_SOFT = HRTIMER_MODE_REL | HRTIMER_MODE_SOFT,
|
|
|
|
|
|
|
|
HRTIMER_MODE_ABS_PINNED_SOFT = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_SOFT,
|
|
|
|
HRTIMER_MODE_REL_PINNED_SOFT = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_SOFT,
|
|
|
|
|
2019-07-26 18:30:51 +00:00
|
|
|
HRTIMER_MODE_ABS_HARD = HRTIMER_MODE_ABS | HRTIMER_MODE_HARD,
|
|
|
|
HRTIMER_MODE_REL_HARD = HRTIMER_MODE_REL | HRTIMER_MODE_HARD,
|
|
|
|
|
|
|
|
HRTIMER_MODE_ABS_PINNED_HARD = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_HARD,
|
|
|
|
HRTIMER_MODE_REL_PINNED_HARD = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_HARD,
|
2006-01-10 04:52:32 +00:00
|
|
|
};
|
|
|
|
|
2007-02-16 09:27:49 +00:00
|
|
|
/*
|
|
|
|
* Return values for the callback function
|
|
|
|
*/
|
2006-01-10 04:52:32 +00:00
|
|
|
enum hrtimer_restart {
|
2007-02-16 09:27:49 +00:00
|
|
|
HRTIMER_NORESTART, /* Timer is not restarted */
|
|
|
|
HRTIMER_RESTART, /* Timer must be restarted */
|
2006-01-10 04:52:32 +00:00
|
|
|
};
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
/*
|
|
|
|
* Values to track state of the timer
|
2007-02-16 09:27:51 +00:00
|
|
|
*
|
|
|
|
* Possible states:
|
|
|
|
*
|
|
|
|
* 0x00 inactive
|
|
|
|
* 0x01 enqueued into rbtree
|
2007-02-16 09:28:11 +00:00
|
|
|
*
|
2015-06-11 12:46:48 +00:00
|
|
|
* The callback state is not part of the timer->state because clearing it would
|
|
|
|
* mean touching the timer after the callback, this makes it impossible to free
|
|
|
|
* the timer from the callback function.
|
2011-03-10 17:26:33 +00:00
|
|
|
*
|
2015-06-11 12:46:48 +00:00
|
|
|
* Therefore we track the callback state in:
|
|
|
|
*
|
|
|
|
* timer->base->cpu_base->running == timer
|
|
|
|
*
|
|
|
|
* On SMP it is possible to have a "callback function running and enqueued"
|
|
|
|
* status. It happens for example when a posix timer expired and the callback
|
2007-02-16 09:27:51 +00:00
|
|
|
* queued a signal. Between dropping the lock which protects the posix timer
|
|
|
|
* and reacquiring the base lock of the hrtimer, another CPU can deliver the
|
2015-06-11 12:46:48 +00:00
|
|
|
* signal and rearm the timer.
|
2007-02-16 09:27:51 +00:00
|
|
|
*
|
|
|
|
* All state transitions are protected by cpu_base->lock.
|
|
|
|
*/
|
|
|
|
#define HRTIMER_STATE_INACTIVE 0x00
|
|
|
|
#define HRTIMER_STATE_ENQUEUED 0x01
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/**
|
|
|
|
* struct hrtimer - the basic hrtimer structure
|
2010-09-21 02:19:17 +00:00
|
|
|
* @node: timerqueue node, which also manages node.expires,
|
|
|
|
* the absolute expiry time in the hrtimers internal
|
2006-01-10 04:52:32 +00:00
|
|
|
* representation. The time is related to the clock on
|
2008-10-20 14:38:19 +00:00
|
|
|
* which the timer is based. Is setup by adding
|
|
|
|
* slack to the _softexpires value. For non range timers
|
|
|
|
* identical to _softexpires.
|
|
|
|
* @_softexpires: the absolute earliest expiry time of the hrtimer.
|
|
|
|
* The time which was given as expiry time when the timer
|
|
|
|
* was armed.
|
2006-01-10 04:52:32 +00:00
|
|
|
* @function: timer expiry callback function
|
|
|
|
* @base: pointer to the timer base (per cpu and per clock)
|
2007-02-16 09:27:51 +00:00
|
|
|
* @state: state information (See bit values above)
|
2016-01-14 16:54:46 +00:00
|
|
|
* @is_rel: Set if the timer was armed relative
|
2017-12-21 10:41:57 +00:00
|
|
|
* @is_soft: Set if hrtimer will be expired in soft interrupt context.
|
2019-07-30 18:15:25 +00:00
|
|
|
* @is_hard: Set if hrtimer will be expired in hard interrupt context
|
|
|
|
* even on RT.
|
2006-01-10 04:52:32 +00:00
|
|
|
*
|
2007-02-16 09:28:11 +00:00
|
|
|
* The hrtimer structure must be initialized by hrtimer_init()
|
2006-01-10 04:52:32 +00:00
|
|
|
*/
|
|
|
|
struct hrtimer {
|
2010-09-21 02:19:17 +00:00
|
|
|
struct timerqueue_node node;
|
2008-09-01 22:47:08 +00:00
|
|
|
ktime_t _softexpires;
|
2007-02-16 09:27:50 +00:00
|
|
|
enum hrtimer_restart (*function)(struct hrtimer *);
|
|
|
|
struct hrtimer_clock_base *base;
|
2016-01-14 16:54:46 +00:00
|
|
|
u8 state;
|
|
|
|
u8 is_rel;
|
2017-12-21 10:41:57 +00:00
|
|
|
u8 is_soft;
|
2019-07-30 18:15:25 +00:00
|
|
|
u8 is_hard;
|
2006-01-10 04:52:32 +00:00
|
|
|
};
|
|
|
|
|
2006-03-31 10:31:17 +00:00
|
|
|
/**
|
|
|
|
* struct hrtimer_sleeper - simple sleeper structure
|
|
|
|
* @timer: embedded timer structure
|
|
|
|
* @task: task to wake up
|
|
|
|
*
|
|
|
|
* task is set to NULL, when the timer expires.
|
|
|
|
*/
|
|
|
|
struct hrtimer_sleeper {
|
|
|
|
struct hrtimer timer;
|
|
|
|
struct task_struct *task;
|
|
|
|
};
|
|
|
|
|
2015-04-14 21:08:44 +00:00
|
|
|
#ifdef CONFIG_64BIT
|
2017-12-21 10:41:40 +00:00
|
|
|
# define __hrtimer_clock_base_align ____cacheline_aligned
|
2015-04-14 21:08:44 +00:00
|
|
|
#else
|
2017-12-21 10:41:40 +00:00
|
|
|
# define __hrtimer_clock_base_align
|
2015-04-14 21:08:44 +00:00
|
|
|
#endif
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/**
|
2007-03-06 09:42:07 +00:00
|
|
|
* struct hrtimer_clock_base - the timer base for a specific clock
|
2007-03-01 04:12:13 +00:00
|
|
|
* @cpu_base: per cpu clock base
|
2007-02-16 09:27:50 +00:00
|
|
|
* @index: clock type index for per_cpu support when moving a
|
|
|
|
* timer to a base on another cpu.
|
2011-06-27 16:07:08 +00:00
|
|
|
* @clockid: clock id for per_cpu support
|
2017-12-21 10:41:40 +00:00
|
|
|
* @seq: seqcount around __run_hrtimer
|
|
|
|
* @running: pointer to the currently running hrtimer
|
2006-03-26 09:38:05 +00:00
|
|
|
* @active: red black tree root node for the active timers
|
|
|
|
* @get_time: function to retrieve the current time of the clock
|
2007-02-16 09:28:11 +00:00
|
|
|
* @offset: offset of this clock to the monotonic base
|
2006-01-10 04:52:32 +00:00
|
|
|
*/
|
2007-02-16 09:27:50 +00:00
|
|
|
struct hrtimer_clock_base {
|
|
|
|
struct hrtimer_cpu_base *cpu_base;
|
2017-12-21 10:41:40 +00:00
|
|
|
unsigned int index;
|
2011-05-20 11:05:15 +00:00
|
|
|
clockid_t clockid;
|
2020-07-20 15:55:30 +00:00
|
|
|
seqcount_raw_spinlock_t seq;
|
2017-12-21 10:41:40 +00:00
|
|
|
struct hrtimer *running;
|
2010-09-21 02:19:17 +00:00
|
|
|
struct timerqueue_head active;
|
2006-01-10 04:52:32 +00:00
|
|
|
ktime_t (*get_time)(void);
|
2007-02-16 09:28:11 +00:00
|
|
|
ktime_t offset;
|
2017-12-21 10:41:40 +00:00
|
|
|
} __hrtimer_clock_base_align;
|
2007-02-16 09:27:50 +00:00
|
|
|
|
2010-12-15 03:37:07 +00:00
|
|
|
enum hrtimer_base_type {
|
|
|
|
HRTIMER_BASE_MONOTONIC,
|
2011-05-20 21:14:04 +00:00
|
|
|
HRTIMER_BASE_REALTIME,
|
2018-04-25 13:33:38 +00:00
|
|
|
HRTIMER_BASE_BOOTTIME,
|
2013-01-22 01:00:11 +00:00
|
|
|
HRTIMER_BASE_TAI,
|
2017-12-21 10:41:55 +00:00
|
|
|
HRTIMER_BASE_MONOTONIC_SOFT,
|
|
|
|
HRTIMER_BASE_REALTIME_SOFT,
|
2018-04-25 13:33:38 +00:00
|
|
|
HRTIMER_BASE_BOOTTIME_SOFT,
|
2017-12-21 10:41:55 +00:00
|
|
|
HRTIMER_BASE_TAI_SOFT,
|
2010-12-15 03:37:07 +00:00
|
|
|
HRTIMER_MAX_CLOCK_BASES,
|
|
|
|
};
|
2007-02-16 09:27:50 +00:00
|
|
|
|
2017-12-21 10:41:32 +00:00
|
|
|
/**
|
2007-02-16 09:27:50 +00:00
|
|
|
* struct hrtimer_cpu_base - the per cpu clock bases
|
|
|
|
* @lock: lock protecting the base and associated clock bases
|
|
|
|
* and timers
|
2014-06-21 23:29:15 +00:00
|
|
|
* @cpu: cpu number
|
2011-05-20 11:05:15 +00:00
|
|
|
* @active_bases: Bitfield to mark bases with active timers
|
2015-04-14 21:08:37 +00:00
|
|
|
* @clock_was_set_seq: Sequence counter of clock was set events
|
2007-02-16 09:28:11 +00:00
|
|
|
* @hres_active: State of high resolution mode
|
2017-12-21 10:41:42 +00:00
|
|
|
* @in_hrtirq: hrtimer_interrupt() is currently executing
|
2009-11-13 16:05:44 +00:00
|
|
|
* @hang_detected: The last hrtimer interrupt detected a hang
|
2017-12-21 10:41:57 +00:00
|
|
|
* @softirq_activated: displays, if the softirq is raised - update of softirq
|
|
|
|
* related settings is not required then.
|
2009-11-13 16:05:44 +00:00
|
|
|
* @nr_events: Total number of hrtimer interrupt events
|
|
|
|
* @nr_retries: Total number of hrtimer interrupt retries
|
|
|
|
* @nr_hangs: Total number of hrtimer interrupt hangs
|
|
|
|
* @max_hang_time: Maximum time spent in hrtimer_interrupt
|
2019-07-26 18:30:59 +00:00
|
|
|
* @softirq_expiry_lock: Lock which is taken while softirq based hrtimer are
|
|
|
|
* expired
|
|
|
|
* @timer_waiters: A hrtimer_cancel() invocation waits for the timer
|
|
|
|
* callback to finish.
|
2017-12-21 10:41:44 +00:00
|
|
|
* @expires_next: absolute time of the next event, is required for remote
|
2017-12-21 10:41:57 +00:00
|
|
|
* hrtimer enqueue; it is the total first expiry time (hard
|
|
|
|
* and soft hrtimer are taken into account)
|
2017-12-21 10:41:45 +00:00
|
|
|
* @next_timer: Pointer to the first expiring timer
|
2017-12-21 10:41:57 +00:00
|
|
|
* @softirq_expires_next: Time to check, if soft queues needs also to be expired
|
|
|
|
* @softirq_next_timer: Pointer to the first expiring softirq based timer
|
2011-05-20 11:05:15 +00:00
|
|
|
* @clock_base: array of clock bases for this cpu
|
2015-04-14 21:08:49 +00:00
|
|
|
*
|
|
|
|
* Note: next_timer is just an optimization for __remove_hrtimer().
|
|
|
|
* Do not dereference the pointer because it is not reliable on
|
|
|
|
* cross cpu removals.
|
2007-02-16 09:27:50 +00:00
|
|
|
*/
|
|
|
|
struct hrtimer_cpu_base {
|
2009-11-17 15:36:54 +00:00
|
|
|
raw_spinlock_t lock;
|
2014-06-21 23:29:15 +00:00
|
|
|
unsigned int cpu;
|
2012-07-10 22:43:19 +00:00
|
|
|
unsigned int active_bases;
|
2015-04-14 21:08:37 +00:00
|
|
|
unsigned int clock_was_set_seq;
|
2017-12-21 10:41:57 +00:00
|
|
|
unsigned int hres_active : 1,
|
|
|
|
in_hrtirq : 1,
|
|
|
|
hang_detected : 1,
|
|
|
|
softirq_activated : 1;
|
2017-12-21 10:41:46 +00:00
|
|
|
#ifdef CONFIG_HIGH_RES_TIMERS
|
2015-04-14 21:08:34 +00:00
|
|
|
unsigned int nr_events;
|
2017-12-21 10:41:41 +00:00
|
|
|
unsigned short nr_retries;
|
|
|
|
unsigned short nr_hangs;
|
2015-04-14 21:08:34 +00:00
|
|
|
unsigned int max_hang_time;
|
2019-07-26 18:30:59 +00:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_PREEMPT_RT
|
|
|
|
spinlock_t softirq_expiry_lock;
|
|
|
|
atomic_t timer_waiters;
|
2007-02-16 09:28:11 +00:00
|
|
|
#endif
|
2017-12-21 10:41:44 +00:00
|
|
|
ktime_t expires_next;
|
2017-12-21 10:41:45 +00:00
|
|
|
struct hrtimer *next_timer;
|
2017-12-21 10:41:57 +00:00
|
|
|
ktime_t softirq_expires_next;
|
|
|
|
struct hrtimer *softirq_next_timer;
|
2011-05-20 11:02:58 +00:00
|
|
|
struct hrtimer_clock_base clock_base[HRTIMER_MAX_CLOCK_BASES];
|
2015-04-14 21:08:42 +00:00
|
|
|
} ____cacheline_aligned;
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2008-09-01 21:35:02 +00:00
|
|
|
static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = time;
|
2008-09-01 22:47:08 +00:00
|
|
|
timer->_softexpires = time;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
2008-09-01 22:47:08 +00:00
|
|
|
|
|
|
|
static inline void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta)
|
|
|
|
{
|
|
|
|
timer->_softexpires = time;
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_safe(time, delta);
|
2008-09-01 22:47:08 +00:00
|
|
|
}
|
|
|
|
|
timer: convert timer_slack_ns from unsigned long to u64
This patchset introduces a /proc/<pid>/timerslack_ns interface which
would allow controlling processes to be able to set the timerslack value
on other processes in order to save power by avoiding wakeups (Something
Android currently does via out-of-tree patches).
The first patch tries to fix the internal timer_slack_ns usage which was
defined as a long, which limits the slack range to ~4 seconds on 32bit
systems. It converts it to a u64, which provides the same basically
unlimited slack (500 years) on both 32bit and 64bit machines.
The second patch introduces the /proc/<pid>/timerslack_ns interface
which allows the full 64bit slack range for a task to be read or set on
both 32bit and 64bit machines.
With these two patches, on a 32bit machine, after setting the slack on
bash to 10 seconds:
$ time sleep 1
real 0m10.747s
user 0m0.001s
sys 0m0.005s
The first patch is a little ugly, since I had to chase the slack delta
arguments through a number of functions converting them to u64s. Let me
know if it makes sense to break that up more or not.
Other than that things are fairly straightforward.
This patch (of 2):
The timer_slack_ns value in the task struct is currently a unsigned
long. This means that on 32bit applications, the maximum slack is just
over 4 seconds. However, on 64bit machines, its much much larger (~500
years).
This disparity could make application development a little (as well as
the default_slack) to a u64. This means both 32bit and 64bit systems
have the same effective internal slack range.
Now the existing ABI via PR_GET_TIMERSLACK and PR_SET_TIMERSLACK specify
the interface as a unsigned long, so we preserve that limitation on
32bit systems, where SET_TIMERSLACK can only set the slack to a unsigned
long value, and GET_TIMERSLACK will return ULONG_MAX if the slack is
actually larger then what can be stored by an unsigned long.
This patch also modifies hrtimer functions which specified the slack
delta as a unsigned long.
Signed-off-by: John Stultz <john.stultz@linaro.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Oren Laadan <orenl@cellrox.com>
Cc: Ruchi Kandoi <kandoiruchi@google.com>
Cc: Rom Lemarchand <romlem@android.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Android Kernel Team <kernel-team@android.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-03-17 21:20:51 +00:00
|
|
|
static inline void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, u64 delta)
|
2008-09-01 22:47:08 +00:00
|
|
|
{
|
|
|
|
timer->_softexpires = time;
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_safe(time, ns_to_ktime(delta));
|
2008-09-01 22:47:08 +00:00
|
|
|
}
|
|
|
|
|
2008-09-01 21:35:02 +00:00
|
|
|
static inline void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
|
|
|
|
{
|
2016-12-25 10:38:40 +00:00
|
|
|
timer->node.expires = tv64;
|
|
|
|
timer->_softexpires = tv64;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_safe(timer->node.expires, time);
|
2008-09-01 22:47:08 +00:00
|
|
|
timer->_softexpires = ktime_add_safe(timer->_softexpires, time);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2008-11-05 17:38:47 +00:00
|
|
|
static inline void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns)
|
2008-09-01 21:35:02 +00:00
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
timer->node.expires = ktime_add_ns(timer->node.expires, ns);
|
2008-09-01 22:47:08 +00:00
|
|
|
timer->_softexpires = ktime_add_ns(timer->_softexpires, ns);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline ktime_t hrtimer_get_expires(const struct hrtimer *timer)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
return timer->node.expires;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2008-09-01 22:47:08 +00:00
|
|
|
static inline ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->_softexpires;
|
|
|
|
}
|
|
|
|
|
2008-09-01 21:35:02 +00:00
|
|
|
static inline s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
|
|
|
|
{
|
2016-12-25 10:38:40 +00:00
|
|
|
return timer->node.expires;
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
2008-09-01 22:47:08 +00:00
|
|
|
static inline s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
|
|
|
|
{
|
2016-12-25 10:38:40 +00:00
|
|
|
return timer->_softexpires;
|
2008-09-01 22:47:08 +00:00
|
|
|
}
|
2008-09-01 21:35:02 +00:00
|
|
|
|
|
|
|
static inline s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
return ktime_to_ns(timer->node.expires);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
|
|
|
|
{
|
2010-09-21 02:19:17 +00:00
|
|
|
return ktime_sub(timer->node.expires, timer->base->get_time());
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return timer->base->get_time();
|
|
|
|
}
|
|
|
|
|
2017-12-21 10:41:42 +00:00
|
|
|
static inline int hrtimer_is_hres_active(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return IS_ENABLED(CONFIG_HIGH_RES_TIMERS) ?
|
|
|
|
timer->base->cpu_base->hres_active : 0;
|
|
|
|
}
|
|
|
|
|
2015-04-14 21:08:35 +00:00
|
|
|
#ifdef CONFIG_HIGH_RES_TIMERS
|
|
|
|
struct clock_event_device;
|
|
|
|
|
|
|
|
extern void hrtimer_interrupt(struct clock_event_device *dev);
|
|
|
|
|
2012-07-10 22:43:19 +00:00
|
|
|
extern void clock_was_set_delayed(void);
|
|
|
|
|
2015-04-14 21:08:27 +00:00
|
|
|
extern unsigned int hrtimer_resolution;
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
#else
|
|
|
|
|
2015-06-06 09:30:00 +00:00
|
|
|
#define hrtimer_resolution (unsigned int)LOW_RES_NSEC
|
2015-04-14 21:08:27 +00:00
|
|
|
|
2012-07-10 22:43:19 +00:00
|
|
|
static inline void clock_was_set_delayed(void) { }
|
|
|
|
|
2007-02-16 09:28:11 +00:00
|
|
|
#endif
|
|
|
|
|
2016-01-14 16:54:46 +00:00
|
|
|
static inline ktime_t
|
|
|
|
__hrtimer_expires_remaining_adjusted(const struct hrtimer *timer, ktime_t now)
|
|
|
|
{
|
|
|
|
ktime_t rem = ktime_sub(timer->node.expires, now);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Adjust relative timers for the extra we added in
|
|
|
|
* hrtimer_start_range_ns() to prevent short timeouts.
|
|
|
|
*/
|
|
|
|
if (IS_ENABLED(CONFIG_TIME_LOW_RES) && timer->is_rel)
|
2016-12-25 10:38:40 +00:00
|
|
|
rem -= hrtimer_resolution;
|
2016-01-14 16:54:46 +00:00
|
|
|
return rem;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline ktime_t
|
|
|
|
hrtimer_expires_remaining_adjusted(const struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return __hrtimer_expires_remaining_adjusted(timer,
|
|
|
|
timer->base->get_time());
|
|
|
|
}
|
|
|
|
|
2011-05-02 14:48:57 +00:00
|
|
|
extern void clock_was_set(void);
|
2011-05-20 14:18:50 +00:00
|
|
|
#ifdef CONFIG_TIMERFD
|
|
|
|
extern void timerfd_clock_was_set(void);
|
|
|
|
#else
|
|
|
|
static inline void timerfd_clock_was_set(void) { }
|
|
|
|
#endif
|
2011-05-02 14:48:57 +00:00
|
|
|
extern void hrtimers_resume(void);
|
|
|
|
|
2008-09-10 23:06:00 +00:00
|
|
|
DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
|
|
|
|
|
2019-07-26 18:30:59 +00:00
|
|
|
#ifdef CONFIG_PREEMPT_RT
|
|
|
|
void hrtimer_cancel_wait_running(const struct hrtimer *timer);
|
|
|
|
#else
|
|
|
|
static inline void hrtimer_cancel_wait_running(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
#endif
|
2008-09-10 23:06:00 +00:00
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Exported timer functions: */
|
|
|
|
|
|
|
|
/* Initialize timers: */
|
2006-02-01 11:05:11 +00:00
|
|
|
extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
|
|
|
|
enum hrtimer_mode mode);
|
2019-07-26 18:30:50 +00:00
|
|
|
extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, clockid_t clock_id,
|
|
|
|
enum hrtimer_mode mode);
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2008-04-30 07:55:04 +00:00
|
|
|
#ifdef CONFIG_DEBUG_OBJECTS_TIMERS
|
|
|
|
extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock,
|
|
|
|
enum hrtimer_mode mode);
|
2019-07-26 18:30:50 +00:00
|
|
|
extern void hrtimer_init_sleeper_on_stack(struct hrtimer_sleeper *sl,
|
|
|
|
clockid_t clock_id,
|
|
|
|
enum hrtimer_mode mode);
|
2008-04-30 07:55:04 +00:00
|
|
|
|
|
|
|
extern void destroy_hrtimer_on_stack(struct hrtimer *timer);
|
|
|
|
#else
|
|
|
|
static inline void hrtimer_init_on_stack(struct hrtimer *timer,
|
|
|
|
clockid_t which_clock,
|
|
|
|
enum hrtimer_mode mode)
|
|
|
|
{
|
|
|
|
hrtimer_init(timer, which_clock, mode);
|
|
|
|
}
|
2019-07-26 18:30:50 +00:00
|
|
|
|
|
|
|
static inline void hrtimer_init_sleeper_on_stack(struct hrtimer_sleeper *sl,
|
|
|
|
clockid_t clock_id,
|
|
|
|
enum hrtimer_mode mode)
|
|
|
|
{
|
|
|
|
hrtimer_init_sleeper(sl, clock_id, mode);
|
|
|
|
}
|
|
|
|
|
2008-04-30 07:55:04 +00:00
|
|
|
static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
|
|
|
|
#endif
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Basic timer operations: */
|
2015-04-14 21:09:23 +00:00
|
|
|
extern void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
|
timer: convert timer_slack_ns from unsigned long to u64
This patchset introduces a /proc/<pid>/timerslack_ns interface which
would allow controlling processes to be able to set the timerslack value
on other processes in order to save power by avoiding wakeups (Something
Android currently does via out-of-tree patches).
The first patch tries to fix the internal timer_slack_ns usage which was
defined as a long, which limits the slack range to ~4 seconds on 32bit
systems. It converts it to a u64, which provides the same basically
unlimited slack (500 years) on both 32bit and 64bit machines.
The second patch introduces the /proc/<pid>/timerslack_ns interface
which allows the full 64bit slack range for a task to be read or set on
both 32bit and 64bit machines.
With these two patches, on a 32bit machine, after setting the slack on
bash to 10 seconds:
$ time sleep 1
real 0m10.747s
user 0m0.001s
sys 0m0.005s
The first patch is a little ugly, since I had to chase the slack delta
arguments through a number of functions converting them to u64s. Let me
know if it makes sense to break that up more or not.
Other than that things are fairly straightforward.
This patch (of 2):
The timer_slack_ns value in the task struct is currently a unsigned
long. This means that on 32bit applications, the maximum slack is just
over 4 seconds. However, on 64bit machines, its much much larger (~500
years).
This disparity could make application development a little (as well as
the default_slack) to a u64. This means both 32bit and 64bit systems
have the same effective internal slack range.
Now the existing ABI via PR_GET_TIMERSLACK and PR_SET_TIMERSLACK specify
the interface as a unsigned long, so we preserve that limitation on
32bit systems, where SET_TIMERSLACK can only set the slack to a unsigned
long value, and GET_TIMERSLACK will return ULONG_MAX if the slack is
actually larger then what can be stored by an unsigned long.
This patch also modifies hrtimer functions which specified the slack
delta as a unsigned long.
Signed-off-by: John Stultz <john.stultz@linaro.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Oren Laadan <orenl@cellrox.com>
Cc: Ruchi Kandoi <kandoiruchi@google.com>
Cc: Rom Lemarchand <romlem@android.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Android Kernel Team <kernel-team@android.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-03-17 21:20:51 +00:00
|
|
|
u64 range_ns, const enum hrtimer_mode mode);
|
2009-03-13 11:21:27 +00:00
|
|
|
|
2015-04-14 21:09:10 +00:00
|
|
|
/**
|
2017-12-21 10:41:34 +00:00
|
|
|
* hrtimer_start - (re)start an hrtimer
|
2015-04-14 21:09:10 +00:00
|
|
|
* @timer: the timer to be added
|
|
|
|
* @tim: expiry time
|
2017-12-21 10:41:34 +00:00
|
|
|
* @mode: timer mode: absolute (HRTIMER_MODE_ABS) or
|
2017-12-21 10:41:57 +00:00
|
|
|
* relative (HRTIMER_MODE_REL), and pinned (HRTIMER_MODE_PINNED);
|
|
|
|
* softirq based mode is considered for debug purpose only!
|
2015-04-14 21:09:10 +00:00
|
|
|
*/
|
2015-04-14 21:09:23 +00:00
|
|
|
static inline void hrtimer_start(struct hrtimer *timer, ktime_t tim,
|
|
|
|
const enum hrtimer_mode mode)
|
2015-04-14 21:09:10 +00:00
|
|
|
{
|
2015-04-14 21:09:23 +00:00
|
|
|
hrtimer_start_range_ns(timer, tim, 0, mode);
|
2015-04-14 21:09:10 +00:00
|
|
|
}
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
extern int hrtimer_cancel(struct hrtimer *timer);
|
|
|
|
extern int hrtimer_try_to_cancel(struct hrtimer *timer);
|
|
|
|
|
2015-04-14 21:09:23 +00:00
|
|
|
static inline void hrtimer_start_expires(struct hrtimer *timer,
|
|
|
|
enum hrtimer_mode mode)
|
2008-09-01 21:35:02 +00:00
|
|
|
{
|
timer: convert timer_slack_ns from unsigned long to u64
This patchset introduces a /proc/<pid>/timerslack_ns interface which
would allow controlling processes to be able to set the timerslack value
on other processes in order to save power by avoiding wakeups (Something
Android currently does via out-of-tree patches).
The first patch tries to fix the internal timer_slack_ns usage which was
defined as a long, which limits the slack range to ~4 seconds on 32bit
systems. It converts it to a u64, which provides the same basically
unlimited slack (500 years) on both 32bit and 64bit machines.
The second patch introduces the /proc/<pid>/timerslack_ns interface
which allows the full 64bit slack range for a task to be read or set on
both 32bit and 64bit machines.
With these two patches, on a 32bit machine, after setting the slack on
bash to 10 seconds:
$ time sleep 1
real 0m10.747s
user 0m0.001s
sys 0m0.005s
The first patch is a little ugly, since I had to chase the slack delta
arguments through a number of functions converting them to u64s. Let me
know if it makes sense to break that up more or not.
Other than that things are fairly straightforward.
This patch (of 2):
The timer_slack_ns value in the task struct is currently a unsigned
long. This means that on 32bit applications, the maximum slack is just
over 4 seconds. However, on 64bit machines, its much much larger (~500
years).
This disparity could make application development a little (as well as
the default_slack) to a u64. This means both 32bit and 64bit systems
have the same effective internal slack range.
Now the existing ABI via PR_GET_TIMERSLACK and PR_SET_TIMERSLACK specify
the interface as a unsigned long, so we preserve that limitation on
32bit systems, where SET_TIMERSLACK can only set the slack to a unsigned
long value, and GET_TIMERSLACK will return ULONG_MAX if the slack is
actually larger then what can be stored by an unsigned long.
This patch also modifies hrtimer functions which specified the slack
delta as a unsigned long.
Signed-off-by: John Stultz <john.stultz@linaro.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Oren Laadan <orenl@cellrox.com>
Cc: Ruchi Kandoi <kandoiruchi@google.com>
Cc: Rom Lemarchand <romlem@android.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Android Kernel Team <kernel-team@android.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-03-17 21:20:51 +00:00
|
|
|
u64 delta;
|
2008-09-07 17:47:46 +00:00
|
|
|
ktime_t soft, hard;
|
|
|
|
soft = hrtimer_get_softexpires(timer);
|
|
|
|
hard = hrtimer_get_expires(timer);
|
|
|
|
delta = ktime_to_ns(ktime_sub(hard, soft));
|
2015-04-14 21:09:23 +00:00
|
|
|
hrtimer_start_range_ns(timer, soft, delta, mode);
|
2008-09-01 21:35:02 +00:00
|
|
|
}
|
|
|
|
|
2019-07-30 19:03:53 +00:00
|
|
|
void hrtimer_sleeper_start_expires(struct hrtimer_sleeper *sl,
|
|
|
|
enum hrtimer_mode mode);
|
|
|
|
|
2015-04-14 21:09:23 +00:00
|
|
|
static inline void hrtimer_restart(struct hrtimer *timer)
|
2007-02-16 09:27:49 +00:00
|
|
|
{
|
2015-04-14 21:09:23 +00:00
|
|
|
hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
|
2007-02-16 09:27:49 +00:00
|
|
|
}
|
2006-01-10 04:52:32 +00:00
|
|
|
|
|
|
|
/* Query timers: */
|
2016-01-14 16:54:46 +00:00
|
|
|
extern ktime_t __hrtimer_get_remaining(const struct hrtimer *timer, bool adjust);
|
|
|
|
|
|
|
|
static inline ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
return __hrtimer_get_remaining(timer, false);
|
|
|
|
}
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2015-04-14 21:08:58 +00:00
|
|
|
extern u64 hrtimer_get_next_event(void);
|
2018-04-03 21:17:00 +00:00
|
|
|
extern u64 hrtimer_next_event_without(const struct hrtimer *exclude);
|
2006-03-06 23:42:45 +00:00
|
|
|
|
2015-06-11 12:46:48 +00:00
|
|
|
extern bool hrtimer_active(const struct hrtimer *timer);
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2019-11-06 17:48:04 +00:00
|
|
|
/**
|
|
|
|
* hrtimer_is_queued = check, whether the timer is on one of the queues
|
|
|
|
* @timer: Timer to check
|
|
|
|
*
|
|
|
|
* Returns: True if the timer is queued, false otherwise
|
|
|
|
*
|
|
|
|
* The function can be used lockless, but it gives only a current snapshot.
|
2007-02-16 09:28:11 +00:00
|
|
|
*/
|
2019-11-06 17:48:04 +00:00
|
|
|
static inline bool hrtimer_is_queued(struct hrtimer *timer)
|
2007-02-16 09:28:11 +00:00
|
|
|
{
|
2019-11-06 17:48:04 +00:00
|
|
|
/* The READ_ONCE pairs with the update functions of timer->state */
|
|
|
|
return !!(READ_ONCE(timer->state) & HRTIMER_STATE_ENQUEUED);
|
2007-02-16 09:28:11 +00:00
|
|
|
}
|
|
|
|
|
2008-04-30 21:04:37 +00:00
|
|
|
/*
|
|
|
|
* Helper function to check, whether the timer is running the callback
|
|
|
|
* function
|
|
|
|
*/
|
|
|
|
static inline int hrtimer_callback_running(struct hrtimer *timer)
|
|
|
|
{
|
2017-12-21 10:41:40 +00:00
|
|
|
return timer->base->running == timer;
|
2008-04-30 21:04:37 +00:00
|
|
|
}
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Forward a hrtimer so it expires after now: */
|
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
|
|
|
extern u64
|
2006-03-26 09:38:06 +00:00
|
|
|
hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
|
2006-01-10 04:52:32 +00:00
|
|
|
|
2015-04-13 21:02:22 +00:00
|
|
|
/**
|
|
|
|
* hrtimer_forward_now - forward the timer expiry so it expires after now
|
|
|
|
* @timer: hrtimer to forward
|
|
|
|
* @interval: the interval to forward
|
|
|
|
*
|
|
|
|
* Forward the timer expiry so it will expire after the current time
|
|
|
|
* of the hrtimer clock base. Returns the number of overruns.
|
|
|
|
*
|
|
|
|
* Can be safely called from the callback function of @timer. If
|
|
|
|
* called from other contexts @timer must neither be enqueued nor
|
|
|
|
* running the callback and the caller needs to take care of
|
|
|
|
* serialization.
|
|
|
|
*
|
|
|
|
* Note: This only updates the timer expiry value and does not requeue
|
|
|
|
* the timer.
|
|
|
|
*/
|
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
|
|
|
static inline u64 hrtimer_forward_now(struct hrtimer *timer,
|
|
|
|
ktime_t interval)
|
2008-02-05 06:27:25 +00:00
|
|
|
{
|
|
|
|
return hrtimer_forward(timer, timer->base->get_time(), interval);
|
|
|
|
}
|
|
|
|
|
2006-01-10 04:52:35 +00:00
|
|
|
/* Precise sleep: */
|
2017-06-07 08:42:32 +00:00
|
|
|
|
2017-06-24 18:45:06 +00:00
|
|
|
extern int nanosleep_copyout(struct restart_block *, struct timespec64 *);
|
2019-11-12 01:27:05 +00:00
|
|
|
extern long hrtimer_nanosleep(ktime_t rqtp, const enum hrtimer_mode mode,
|
2006-01-10 04:52:35 +00:00
|
|
|
const clockid_t clockid);
|
|
|
|
|
timer: convert timer_slack_ns from unsigned long to u64
This patchset introduces a /proc/<pid>/timerslack_ns interface which
would allow controlling processes to be able to set the timerslack value
on other processes in order to save power by avoiding wakeups (Something
Android currently does via out-of-tree patches).
The first patch tries to fix the internal timer_slack_ns usage which was
defined as a long, which limits the slack range to ~4 seconds on 32bit
systems. It converts it to a u64, which provides the same basically
unlimited slack (500 years) on both 32bit and 64bit machines.
The second patch introduces the /proc/<pid>/timerslack_ns interface
which allows the full 64bit slack range for a task to be read or set on
both 32bit and 64bit machines.
With these two patches, on a 32bit machine, after setting the slack on
bash to 10 seconds:
$ time sleep 1
real 0m10.747s
user 0m0.001s
sys 0m0.005s
The first patch is a little ugly, since I had to chase the slack delta
arguments through a number of functions converting them to u64s. Let me
know if it makes sense to break that up more or not.
Other than that things are fairly straightforward.
This patch (of 2):
The timer_slack_ns value in the task struct is currently a unsigned
long. This means that on 32bit applications, the maximum slack is just
over 4 seconds. However, on 64bit machines, its much much larger (~500
years).
This disparity could make application development a little (as well as
the default_slack) to a u64. This means both 32bit and 64bit systems
have the same effective internal slack range.
Now the existing ABI via PR_GET_TIMERSLACK and PR_SET_TIMERSLACK specify
the interface as a unsigned long, so we preserve that limitation on
32bit systems, where SET_TIMERSLACK can only set the slack to a unsigned
long value, and GET_TIMERSLACK will return ULONG_MAX if the slack is
actually larger then what can be stored by an unsigned long.
This patch also modifies hrtimer functions which specified the slack
delta as a unsigned long.
Signed-off-by: John Stultz <john.stultz@linaro.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Oren Laadan <orenl@cellrox.com>
Cc: Ruchi Kandoi <kandoiruchi@google.com>
Cc: Rom Lemarchand <romlem@android.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Android Kernel Team <kernel-team@android.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-03-17 21:20:51 +00:00
|
|
|
extern int schedule_hrtimeout_range(ktime_t *expires, u64 delta,
|
2019-07-26 18:30:50 +00:00
|
|
|
const enum hrtimer_mode mode);
|
2010-04-02 20:40:19 +00:00
|
|
|
extern int schedule_hrtimeout_range_clock(ktime_t *expires,
|
timer: convert timer_slack_ns from unsigned long to u64
This patchset introduces a /proc/<pid>/timerslack_ns interface which
would allow controlling processes to be able to set the timerslack value
on other processes in order to save power by avoiding wakeups (Something
Android currently does via out-of-tree patches).
The first patch tries to fix the internal timer_slack_ns usage which was
defined as a long, which limits the slack range to ~4 seconds on 32bit
systems. It converts it to a u64, which provides the same basically
unlimited slack (500 years) on both 32bit and 64bit machines.
The second patch introduces the /proc/<pid>/timerslack_ns interface
which allows the full 64bit slack range for a task to be read or set on
both 32bit and 64bit machines.
With these two patches, on a 32bit machine, after setting the slack on
bash to 10 seconds:
$ time sleep 1
real 0m10.747s
user 0m0.001s
sys 0m0.005s
The first patch is a little ugly, since I had to chase the slack delta
arguments through a number of functions converting them to u64s. Let me
know if it makes sense to break that up more or not.
Other than that things are fairly straightforward.
This patch (of 2):
The timer_slack_ns value in the task struct is currently a unsigned
long. This means that on 32bit applications, the maximum slack is just
over 4 seconds. However, on 64bit machines, its much much larger (~500
years).
This disparity could make application development a little (as well as
the default_slack) to a u64. This means both 32bit and 64bit systems
have the same effective internal slack range.
Now the existing ABI via PR_GET_TIMERSLACK and PR_SET_TIMERSLACK specify
the interface as a unsigned long, so we preserve that limitation on
32bit systems, where SET_TIMERSLACK can only set the slack to a unsigned
long value, and GET_TIMERSLACK will return ULONG_MAX if the slack is
actually larger then what can be stored by an unsigned long.
This patch also modifies hrtimer functions which specified the slack
delta as a unsigned long.
Signed-off-by: John Stultz <john.stultz@linaro.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Oren Laadan <orenl@cellrox.com>
Cc: Ruchi Kandoi <kandoiruchi@google.com>
Cc: Rom Lemarchand <romlem@android.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Android Kernel Team <kernel-team@android.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-03-17 21:20:51 +00:00
|
|
|
u64 delta,
|
|
|
|
const enum hrtimer_mode mode,
|
2017-12-21 10:41:33 +00:00
|
|
|
clockid_t clock_id);
|
2008-08-31 15:05:58 +00:00
|
|
|
extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
/* Soft interrupt function to run the hrtimer queues: */
|
|
|
|
extern void hrtimer_run_queues(void);
|
|
|
|
|
|
|
|
/* Bootup initialization: */
|
|
|
|
extern void __init hrtimers_init(void);
|
|
|
|
|
2007-02-16 09:28:16 +00:00
|
|
|
/* Show pending timers: */
|
|
|
|
extern void sysrq_timer_list_show(void);
|
|
|
|
|
2016-07-15 08:41:04 +00:00
|
|
|
int hrtimers_prepare_cpu(unsigned int cpu);
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
int hrtimers_dead_cpu(unsigned int cpu);
|
|
|
|
#else
|
|
|
|
#define hrtimers_dead_cpu NULL
|
|
|
|
#endif
|
|
|
|
|
2006-01-10 04:52:32 +00:00
|
|
|
#endif
|