Skip to contentSkip to conversation

posix-timers: Prevents overrun counter overflow, adds DELAYTIMER_MAX

PATCH In review Daniel Church 4 participants 8 messages Jan 24, 2015 1 message not in the archive

Subsystems (2)
lore
Share & tools
lore

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

#1 lore raw

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]>

#2 lore raw

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
index 907f3fd..dc8a1e7 100644
@@ -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
#3 lore raw

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

#4 lore raw

Re: [PATCH v2 1/2] posix-timers: Prevents overrun counter overflow

In reply to Daniel Church

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;

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 -3
 
 	if (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

#5 lore raw

Re: [PATCH v2 1/2] posix-timers: Prevents overrun counter overflow

In reply to Daniel Church
Quoted 1 line · Daniel Church

+#define DELAYTIMER_MAX_DEFAULT 1000000

Why did you chose 1 million?

Have you reviewed what constant userspace, particularly glibc, is using?

Cheers,
Carlos.

#6 lore raw

PATCH v2 2/2 posix-timers: Exposes DELAYTIMER_MAX constant used to govern overruns

In reply to Daniel Church

POSIX.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
index 137c7f6..b283808 100644
@@ -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
#7 lore raw

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 constant DELAYTIMER_MAX which prevents overflow and caps overrun count. Exposes delaytimer_max value to userland via /proc/sys/kernel/delaytimer_max such

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

#8 lore raw

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 constant DELAYTIMER_MAX which prevents overflow and caps overrun count. Exposes delaytimer_max value to userland via /proc/sys/kernel/delaytimer_max such

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_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.

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.