time: Introduce CLOCK_REALTIME_COARSE

After talking with some application writers who want very fast, but not
fine-grained timestamps, I decided to try to implement new clock_ids
to clock_gettime(): CLOCK_REALTIME_COARSE and CLOCK_MONOTONIC_COARSE
which returns the time at the last tick. This is very fast as we don't
have to access any hardware (which can be very painful if you're using
something like the acpi_pm clocksource), and we can even use the vdso
clock_gettime() method to avoid the syscall. The only trade off is you
only get low-res tick grained time resolution.

This isn't a new idea, I know Ingo has a patch in the -rt tree that made
the vsyscall gettimeofday() return coarse grained time when the
vsyscall64 sysctrl was set to 2. However this affects all applications
on a system.

With this method, applications can choose the proper speed/granularity
trade-off for themselves.

Signed-off-by: John Stultz <johnstul@us.ibm.com>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: nikolag@ca.ibm.com
Cc: Darren Hart <dvhltc@us.ibm.com>
Cc: arjan@infradead.org
Cc: jonathan@jonmasters.org
LKML-Reference: <1250734414.6897.5.camel@localhost.localdomain>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

2 files changed, 56 insertions, 0 deletions

diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index d089d052c4a9..495440779ce3 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -242,6 +242,25 @@ static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec *tp)
         return 0;
 }
 
+
+static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec *tp)
+{
+        *tp = current_kernel_time();
+        return 0;
+}
+
+static int posix_get_monotonic_coarse(clockid_t which_clock,
+                                                struct timespec *tp)
+{
+        *tp = get_monotonic_coarse();
+        return 0;
+}
+
+int posix_get_coarse_res(const clockid_t which_clock, struct timespec *tp)
+{
+        *tp = ktime_to_timespec(KTIME_LOW_RES);
+        return 0;
+}
 /*
  * Initialize everything, well, just everything in Posix clocks/timers ;)
  */
@@ -262,10 +281,26 @@ static __init int init_posix_timers(void)
                 .timer_create = no_timer_create,
                 .nsleep = no_nsleep,
         };
+        struct k_clock clock_realtime_coarse = {
+                .clock_getres = posix_get_coarse_res,
+                .clock_get = posix_get_realtime_coarse,
+                .clock_set = do_posix_clock_nosettime,
+                .timer_create = no_timer_create,
+                .nsleep = no_nsleep,
+        };
+        struct k_clock clock_monotonic_coarse = {
+                .clock_getres = posix_get_coarse_res,
+                .clock_get = posix_get_monotonic_coarse,
+                .clock_set = do_posix_clock_nosettime,
+                .timer_create = no_timer_create,
+                .nsleep = no_nsleep,
+        };
 
         register_posix_clock(CLOCK_REALTIME, &clock_realtime);
         register_posix_clock(CLOCK_MONOTONIC, &clock_monotonic);
         register_posix_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw);
+        register_posix_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse);
+        register_posix_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse);
 
         posix_timers_cache = kmem_cache_create("posix_timers_cache",
                                         sizeof (struct k_itimer), 0, SLAB_PANIC,
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 15e06defca55..03cbeb34d141 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -847,6 +847,10 @@ unsigned long get_seconds(void)
 }
 EXPORT_SYMBOL(get_seconds);
 
+struct timespec __current_kernel_time(void)
+{
+        return xtime_cache;
+}
 
 struct timespec current_kernel_time(void)
 {
@@ -862,3 +866,20 @@ struct timespec current_kernel_time(void)
         return now;
 }
 EXPORT_SYMBOL(current_kernel_time);
+
+struct timespec get_monotonic_coarse(void)
+{
+        struct timespec now, mono;
+        unsigned long seq;
+
+        do {
+                seq = read_seqbegin(&xtime_lock);
+
+                now = xtime_cache;
+                mono = wall_to_monotonic;
+        } while (read_seqretry(&xtime_lock, seq));
+
+        set_normalized_timespec(&now, now.tv_sec + mono.tv_sec,
+                                now.tv_nsec + mono.tv_nsec);
+        return now;
+}