arch/um/kernel/time_kern.c

   1 /*
   2  * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include "linux/kernel.h"
   7 #include "linux/module.h"
   8 #include "linux/unistd.h"
   9 #include "linux/stddef.h"
  10 #include "linux/spinlock.h"
  11 #include "linux/time.h"
  12 #include "linux/sched.h"
  13 #include "linux/interrupt.h"
  14 #include "linux/init.h"
  15 #include "linux/delay.h"
  16 #include "linux/hrtimer.h"
  17 #include "asm/irq.h"
  18 #include "asm/param.h"
  19 #include "asm/current.h"
  20 #include "kern_util.h"
  21 #include "user_util.h"
  22 #include "mode.h"
  23 #include "os.h"
  24
  25 int hz(void)
  26 {
  27         return(HZ);
  28 }
  29
  30 /*
  31  * Scheduler clock - returns current time in nanosec units.
  32  */
  33 unsigned long long sched_clock(void)
  34 {
  35         return (unsigned long long)jiffies_64 * (1000000000 / HZ);
  36 }
  37
  38 /* Changed at early boot */
  39 int timer_irq_inited = 0;
  40
  41 static int first_tick;
  42 static unsigned long long prev_nsecs;
  43 #ifdef CONFIG_UML_REAL_TIME_CLOCK
  44 static long long delta;                 /* Deviation per interval */
  45 #endif
  46
  47 void timer_irq(union uml_pt_regs *regs)
  48 {
  49         unsigned long long ticks = 0;
  50
  51         if(!timer_irq_inited){
  52                 /* This is to ensure that ticks don't pile up when
  53                  * the timer handler is suspended */
  54                 first_tick = 0;
  55                 return;
  56         }
  57
  58         if(first_tick){
  59 #ifdef CONFIG_UML_REAL_TIME_CLOCK
  60                 /* We've had 1 tick */
  61                 unsigned long long nsecs = os_nsecs();
  62
  63                 delta += nsecs - prev_nsecs;
  64                 prev_nsecs = nsecs;
  65
  66                 /* Protect against the host clock being set backwards */
  67                 if(delta < 0)
  68                         delta = 0;
  69
  70                 ticks += (delta * HZ) / BILLION;
  71                 delta -= (ticks * BILLION) / HZ;
  72 #else
  73                 ticks = 1;
  74 #endif
  75         }
  76         else {
  77                 prev_nsecs = os_nsecs();
  78                 first_tick = 1;
  79         }
  80
  81         while(ticks > 0){
  82                 do_IRQ(TIMER_IRQ, regs);
  83                 ticks--;
  84         }
  85 }
  86
  87
  88 void time_init_kern(void)
  89 {
  90         long long nsecs;
  91
  92         nsecs = os_nsecs();
  93         set_normalized_timespec(&wall_to_monotonic, -nsecs / BILLION,
  94                                 -nsecs % BILLION);
  95 }
  96
  97 void do_boot_timer_handler(struct sigcontext * sc)
  98 {
  99         struct pt_regs regs;
 100
 101         CHOOSE_MODE((void) (UPT_SC(&regs.regs) = sc),
 102                     (void) (regs.regs.skas.is_user = 0));
 103         do_timer(&regs);
 104 }
 105
 106 static DEFINE_SPINLOCK(timer_spinlock);
 107
 108 static unsigned long long local_offset = 0;
 109
 110 static inline unsigned long long get_time(void)
 111 {
 112         unsigned long long nsecs;
 113         unsigned long flags;
 114
 115         spin_lock_irqsave(&timer_spinlock, flags);
 116         nsecs = os_nsecs();
 117         nsecs += local_offset;
 118         spin_unlock_irqrestore(&timer_spinlock, flags);
 119
 120         return nsecs;
 121 }
 122
 123 irqreturn_t um_timer(int irq, void *dev, struct pt_regs *regs)
 124 {
 125         unsigned long long nsecs;
 126         unsigned long flags;
 127
 128         do_timer(regs);
 129
 130         write_seqlock_irqsave(&xtime_lock, flags);
 131         nsecs = get_time() + local_offset;
 132         xtime.tv_sec = nsecs / NSEC_PER_SEC;
 133         xtime.tv_nsec = nsecs - xtime.tv_sec * NSEC_PER_SEC;
 134         write_sequnlock_irqrestore(&xtime_lock, flags);
 135
 136         return(IRQ_HANDLED);
 137 }
 138
 139 long um_time(int __user *tloc)
 140 {
 141         long ret = get_time() / NSEC_PER_SEC;
 142
 143         if((tloc != NULL) && put_user(ret, tloc))
 144                 return -EFAULT;
 145
 146         return ret;
 147 }
 148
 149 void do_gettimeofday(struct timeval *tv)
 150 {
 151         unsigned long long nsecs = get_time();
 152
 153         tv->tv_sec = nsecs / NSEC_PER_SEC;
 154         /* Careful about calculations here - this was originally done as
 155          * (nsecs - tv->tv_sec * NSEC_PER_SEC) / NSEC_PER_USEC
 156          * which gave bogus (> 1000000) values.  Dunno why, suspect gcc
 157          * (4.0.0) miscompiled it, or there's a subtle 64/32-bit conversion
 158          * problem that I missed.
 159          */
 160         nsecs -= tv->tv_sec * NSEC_PER_SEC;
 161         tv->tv_usec = (unsigned long) nsecs / NSEC_PER_USEC;
 162 }
 163
 164 static inline void set_time(unsigned long long nsecs)
 165 {
 166         unsigned long long now;
 167         unsigned long flags;
 168
 169         spin_lock_irqsave(&timer_spinlock, flags);
 170         now = os_nsecs();
 171         local_offset = nsecs - now;
 172         spin_unlock_irqrestore(&timer_spinlock, flags);
 173
 174         clock_was_set();
 175 }
 176
 177 long um_stime(int __user *tptr)
 178 {
 179         int value;
 180
 181         if (get_user(value, tptr))
 182                 return -EFAULT;
 183
 184         set_time((unsigned long long) value * NSEC_PER_SEC);
 185
 186         return 0;
 187 }
 188
 189 int do_settimeofday(struct timespec *tv)
 190 {
 191         set_time((unsigned long long) tv->tv_sec * NSEC_PER_SEC + tv->tv_nsec);
 192
 193         return 0;
 194 }
 195
 196 void timer_handler(int sig, union uml_pt_regs *regs)
 197 {
 198         local_irq_disable();
 199         irq_enter();
 200         update_process_times(CHOOSE_MODE(
 201                              (UPT_SC(regs) && user_context(UPT_SP(regs))),
 202                              (regs)->skas.is_user));
 203         irq_exit();
 204         local_irq_enable();
 205         if(current_thread->cpu == 0)
 206                 timer_irq(regs);
 207 }
 208
 209 int __init timer_init(void)
 210 {
 211         int err;
 212
 213         user_time_init();
 214         err = request_irq(TIMER_IRQ, um_timer, SA_INTERRUPT, "timer", NULL);
 215         if(err != 0)
 216                 printk(KERN_ERR "timer_init : request_irq failed - "
 217                        "errno = %d\n", -err);
 218         timer_irq_inited = 1;
 219         return(0);
 220 }
 221
 222 arch_initcall(timer_init);