[PATCH] ktime: Fix ktime_divns to do signed division

[John Stultz <john.stultz@linaro.org>]

It was noted that the 32bit implementation of ktime_divns
was doing unsgined division adn didn't properly handle
negative values.

This patch fixes the problem by checking and preserving
the sign bit, and then reapplying it if appropriate
after the division.

Unfortunately there is some duplication since we have
the optimized version for constant 32bit divider. I
was considering reworkign the __ktime_divns helper
to simplify the sign-handling logic, but then it
would likely just be a s64/s64 divide, and probably
should be more generic.

Thoughts?

Nicolas also notes that the ktime_divns() function
breaks if someone passes in a negative divisor as
well. This patch doesn't yet address that issue.

Cc: Nicolas Pitre <nicolas.pitre@linaro.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: One Thousand Gnomes <gnomes@lxorguk.ukuu.org.uk>
Reported-by: Trevor Cordes <trevor@tecnopolis.ca>
Signed-off-by: John Stultz <john.stultz@linaro.org>
---
 include/linux/ktime.h | 12 ++++++++++--
 kernel/time/hrtimer.c | 11 +++++++++--
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index 5fc3d10..d947263 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -166,12 +166,20 @@ static inline bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)
 }
 
 #if BITS_PER_LONG < 64
-extern u64 __ktime_divns(const ktime_t kt, s64 div);
+extern s64 __ktime_divns(const ktime_t kt, s64 div);
 static inline u64 ktime_divns(const ktime_t kt, s64 div)
 {
 	if (__builtin_constant_p(div) && !(div >> 32)) {
-		u64 ns = kt.tv64;
+		s64 ns = kt.tv64;
+		int neg = 0;
+
+		if (ns < 0) {
+			neg = 1;
+			ns = -ns;
+		}
 		do_div(ns, div);
+		if (neg)
+			ns = -ns;
 		return ns;
 	} else {
 		return __ktime_divns(kt, div);
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index 76d4bd9..4c1b294 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -266,12 +266,17 @@ lock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
 /*
  * Divide a ktime value by a nanosecond value
  */
-u64 __ktime_divns(const ktime_t kt, s64 div)
+s64 __ktime_divns(const ktime_t kt, s64 div)
 {
-	u64 dclc;
+	s64 dclc;
 	int sft = 0;
+	int neg = 0;
 
 	dclc = ktime_to_ns(kt);
+	if (dclc < 0) {
+		neg = 1;
+		dclc = -dclc;
+	}
 	/* Make sure the divisor is less than 2^32: */
 	while (div >> 32) {
 		sft++;
@@ -279,6 +284,8 @@ u64 __ktime_divns(const ktime_t kt, s64 div)
 	}
 	dclc >>= sft;
 	do_div(dclc, (unsigned long) div);
+	if (neg)
+		dclc = -dclc;
 
 	return dclc;
 }
-- 
1.9.1