posix-timers: Prevents overrun counter overflow, adds DELAYTIMER_MAX
Subsystems (2)
A message that is not in the archive (sent off-list or not yet received): [PATCH 0/2] posix-timers: Prevents overrun counter overflow, adds DELAYTIMER_MAX
v2 cover posix-timers: Prevents overrun counter overflow, adds DELAYTIMER_MAX
If a timer overruns too many times before a call to timer_getoverrun the overrun count can overflow and go negative. POSIX.1-2001 specification of timer_getoverrun() supports constant DELAYTIMER_MAX which prevents overflow and caps overrun count. Adds delaytimer_max value, caps overrun count, and exposes value to userland via /proc/sys/kernel/delaytimer_max.
Resolves https://bugzilla.kernel.org/show_bug.cgi?id=12665 - POSIX timers API does not support DELAYTIMER_MAX
v2: Consolidates overflow logic into helper function as suggested by Thomas Gleixner <[email protected]>
PATCH v2 1/2 posix-timers: Prevents overrun counter overflow
If a timer overruns too many times before a call to timer_getoverrun the overrun count can overflow and go negative. Adds delaytimer_max value to cap overrun count and prevent overflow.
--- include/linux/posix-timers.h | 3 +++ kernel/time/posix-timers.c | 45 ++++++++++++++++++++++++++++++++++++-------- 2 files changed, 40 insertions(+), 8 deletions(-)
include/linux/posix-timers.h +3 -0
@@ -138,4 +138,7 @@ long clock_nanosleep_restart(struct restart_block *restart_block);void update_rlimit_cpu (struct task_struct *task,unsigned long rlim_new); +#define DELAYTIMER_MAX_DEFAULT 1000000 +extern int delaytimer_max; +#endif
kernel/time/posix-timers.c +37 -8
95 lines not on this page · raw message
Signature · 1 line
1.9.1
Re: [PATCH v2 1/2] posix-timers: Prevents overrun counter overflow
kernel/time/posix-timers.c static inline void unlock_timer(struct k_itimer *timr, unsigned long flags) · line 216
Quoted 10 lines · Daniel Church
kernel/time/posix-timers.c +10
-0+/* +* Updates a timer's overrun count while capping it to delaytimer_max +*/ +static void posix_timer_update_overrun_count (struct k_itimer *timer, +unsigned int overruns) +{ +const bool newOverrunsAboveMax = overruns >= delaytimer_max; +const bool totalOverrunsAboveMax = + timer->it_overrun >=0 && + timer->it_overrun >= delaytimer_max - overruns;
Lower camel case is not a part of the kernel coding style.
Also, the 'const' keyword is useless in this context.
Quoted 12 lines
kernel/time/posix-timers.c +8
-0+ +if (newOverrunsAboveMax || totalOverrunsAboveMax) { + timer->it_overrun = delaytimer_max; + }else { + timer->it_overrun += overruns; + } +} +/* Get clock_realtime */ static int posix_clock_realtime_get (clockid_t which_clock,struct timespec *tp) {
kernel/time/posix-timers.c long clock_nanosleep_restart(struct restart_block *restart_block) · line 1153
Quoted 4 lines
kernel/time/posix-timers.c +1
-0@@ -1122,3 +1150,4 @@ long clock_nanosleep_restart(struct restart_block *restart_block)return kc->nsleep_restart (restart_block); } +
This stray newline and the camel case are the kinds of things that checkpatch.pl will catch.
Thanks,
Richard
Re: [PATCH v2 1/2] posix-timers: Prevents overrun counter overflow
In reply to Daniel Churchkernel/time/posix-timers.c static inline void unlock_timer(struct k_itimer *timr, unsigned long flags) · line 216
Quoted 10 lines · Daniel Church
kernel/time/posix-timers.c +10
-0+/* +* Updates a timer's overrun count while capping it to delaytimer_max +*/ +static void posix_timer_update_overrun_count (struct k_itimer *timer, +unsigned int overruns) +{ +const bool newOverrunsAboveMax = overruns >= delaytimer_max; +const bool totalOverrunsAboveMax = + timer->it_overrun >=0 && + timer->it_overrun >= delaytimer_max - overruns;
No CaMelCaSe please. And the const here is pointless.
Aside of that in a function like this we really want short local variables so we can avoid the horrible to read multi line code.
Quoted 16 lines
kernel/time/posix-timers.c +8
-0+if (newOverrunsAboveMax || totalOverrunsAboveMax) { + timer->it_overrun = delaytimer_max; + }else { + timer->it_overrun += overruns; + } +} +/* Get clock_realtime */ static int posix_clock_realtime_get (clockid_t which_clock,struct timespec *tp) {@@ -350,14 +370,17 @@ __initcall(init_posix_timers);static void schedule_next_timer (struct k_itimer *timr) { +unsigned int overruns;struct hrtimer *timer = &timr->it.real.timer;
kernel/time/posix-timers.c __initcall(init_posix_timers); · line 381
Quoted 10 lines
kernel/time/posix-timers.c +3
-3if (timr->it.real.interval.tv64 ==0 )return ; - timr->it_overrun += (unsigned int )hrtimer_forward (timer, - timer->base->get_time (), - timr->it.real.interval); + overruns = (unsigned int )hrtimer_forward (timer, + timer->base->get_time (), + timr->it.real.interval);
Why not:
posix_timer_forward(struct hrtimer *hrt, struct k_itimer *tmr)
and doing the forward there as well? The now optimization in common_timer_get is not that important and if we really want to keep it, we can hand in a pointer and read the time in the function if the pointer is NULL.
Thanks,
tglx
Re: [PATCH v2 1/2] posix-timers: Prevents overrun counter overflow
In reply to Daniel ChurchQuoted 1 line · Daniel Church
+#define
DELAYTIMER_MAX_DEFAULT1000000
Why did you chose 1 million?
Have you reviewed what constant userspace, particularly glibc, is using?
Cheers,
Carlos.
PATCH v2 2/2 posix-timers: Exposes DELAYTIMER_MAX constant used to govern overruns
In reply to Daniel ChurchPOSIX.1-2001 specification of timer_getoverrun() supports constant DELAYTIMER_MAX which prevents overflow and caps overrun count. Exposes delaytimer_max value to userland via /proc/sys/kernel/delaytimer_max such that GLIBC can support DELAYTIMER_MAX constant.
--- kernel/sysctl.c | 8 ++++++++ 1 file changed, 8 insertions(+)
kernel/sysctl.c +8 -0
@@ -63,6 +63,7 @@#include <linux/binfmts.h> #include <linux/sched/sysctl.h> #include <linux/kexec.h> +#include <linux/posix-timers.h> #include <asm/uaccess.h> #include <asm/processor.h>
@@ -761,6 +762,13 @@ static struct ctl_table kern_table[] = { },#endif { + .procname = "delaytimer_max", + .data = &delaytimer_max, + .maxlen = sizeof(int), + .mode = 0644, + .proc_handler = proc_dointvec, + }, + { .procname = "pid_max", .data = &pid_max, .maxlen = sizeof (int),
Signature · 1 line
1.9.1
Re: [PATCH v2 2/2] posix-timers: Exposes DELAYTIMER_MAX constant used to govern overruns
Quoted 3 lines · Daniel Church
POSIX.1-2001 specification of
timer_getoverrun()supports constantDELAYTIMER_MAXwhich prevents overflow and caps overrun count. Exposesdelaytimer_maxvalue to userland via/proc/sys/kernel/delaytimer_maxsuch
I know that you try to match the posix name, but when looking at the prctl w/o knowing about DELAYTIMER_MAX, it's non intuitive.
Something like posixtimer_max_overruns or if you insist on the delaytimer_max part, then let us prepend it with posixtimer_ at least.
New prctls require an update of Documentation/sysctl/kernel.txt.
Thanks,
tglx
Re: [PATCH v2 2/2] posix-timers: Exposes DELAYTIMER_MAX constant used to govern overruns
Quoted 6 lines · Thomas Gleixner
Quoted 3 lines · Daniel Church
POSIX.1-2001 specification of
timer_getoverrun()supports constantDELAYTIMER_MAXwhich prevents overflow and caps overrun count. Exposesdelaytimer_maxvalue to userland via/proc/sys/kernel/delaytimer_maxsuch
Quoted 7 lines
I know that you try to match the posix name, but when looking at the prctl w/o knowing about
DELAYTIMER_MAX, it's non intuitive.Something like
posixtimer_max_overrunsor if you insist on thedelaytimer_maxpart, then let us prepend it withposixtimer_at least.New prctls require an update of
Documentation/sysctl/kernel.txt.
Agreed, the name should be self-explanatory and point at POSIX.
The documentation should be detailed and explain exactly what this is for, what are valid values, and why you would ever want to change them.
Cheers,
Carlos.