#include "user_util.h"
#include "time_user.h"
#include "mode.h"
+#include "os.h"
u64 jiffies_64;
return(HZ);
}
+/*
+ * Scheduler clock - returns current time in nanosec units.
+ */
+unsigned long long sched_clock(void)
+{
+ return (unsigned long long)jiffies_64 * (1000000000 / HZ);
+}
+
/* Changed at early boot */
int timer_irq_inited = 0;
-/* missed_ticks will be modified after kernel memory has been
- * write-protected, so this puts it in a section which will be left
- * write-enabled.
- */
-int __attribute__ ((__section__ (".unprotected"))) missed_ticks[NR_CPUS];
+static int first_tick;
+static unsigned long long prev_usecs;
+#ifdef CONFIG_UML_REAL_TIME_CLOCK
+static long long delta; /* Deviation per interval */
+#endif
+
+#define MILLION 1000000
void timer_irq(union uml_pt_regs *regs)
{
- int cpu = current->thread_info->cpu, ticks = missed_ticks[cpu];
+ unsigned long long ticks = 0;
+
+ if(!timer_irq_inited){
+ /* This is to ensure that ticks don't pile up when
+ * the timer handler is suspended */
+ first_tick = 0;
+ return;
+ }
+
+ if(first_tick){
+#ifdef CONFIG_UML_REAL_TIME_CLOCK
+ /* We've had 1 tick */
+ unsigned long long usecs = os_usecs();
- if(!timer_irq_inited) return;
- missed_ticks[cpu] = 0;
- while(ticks--) do_IRQ(TIMER_IRQ, regs);
+ delta += usecs - prev_usecs;
+ prev_usecs = usecs;
+
+ /* Protect against the host clock being set backwards */
+ if(delta < 0)
+ delta = 0;
+
+ ticks += (delta * HZ) / MILLION;
+ delta -= (ticks * MILLION) / HZ;
+#else
+ ticks = 1;
+#endif
+ }
+ else {
+ prev_usecs = os_usecs();
+ first_tick = 1;
+ }
+
+ while(ticks > 0){
+ do_IRQ(TIMER_IRQ, regs);
+ ticks--;
+ }
}
void boot_timer_handler(int sig)
do_timer(®s);
}
-void um_timer(int irq, void *dev, struct pt_regs *regs)
+irqreturn_t um_timer(int irq, void *dev, struct pt_regs *regs)
{
+ unsigned long flags;
+
do_timer(regs);
- write_seqlock(&xtime_lock);
+ write_seqlock_irqsave(&xtime_lock, flags);
timer();
- write_sequnlock(&xtime_lock);
+ write_sequnlock_irqrestore(&xtime_lock, flags);
+ return(IRQ_HANDLED);
}
long um_time(int * tloc)
long um_stime(int * tptr)
{
int value;
- struct timeval new;
+ struct timespec new;
if (get_user(value, tptr))
return -EFAULT;
new.tv_sec = value;
- new.tv_usec = 0;
+ new.tv_nsec = 0;
do_settimeofday(&new);
return 0;
}
{
int i, n;
- n = (loops_per_jiffy * HZ * usecs) / 1000000;
+ n = (loops_per_jiffy * HZ * usecs) / MILLION;
for(i=0;i<n;i++) ;
}
{
int i, n;
- n = (loops_per_jiffy * HZ * usecs) / 1000000;
+ n = (loops_per_jiffy * HZ * usecs) / MILLION;
for(i=0;i<n;i++) ;
}
void timer_handler(int sig, union uml_pt_regs *regs)
{
#ifdef CONFIG_SMP
+ local_irq_disable();
update_process_times(user_context(UPT_SP(regs)));
+ local_irq_enable();
#endif
- if(current->thread_info->cpu == 0)
+ if(current_thread->cpu == 0)
timer_irq(regs);
}
unsigned long time_lock(void)
{
unsigned long flags;
+
spin_lock_irqsave(&timer_spinlock, flags);
return(flags);
}
int err;
CHOOSE_MODE(user_time_init_tt(), user_time_init_skas());
- if((err = request_irq(TIMER_IRQ, um_timer, SA_INTERRUPT, "timer",
- NULL)) != 0)
+ err = request_irq(TIMER_IRQ, um_timer, SA_INTERRUPT, "timer", NULL);
+ if(err != 0)
printk(KERN_ERR "timer_init : request_irq failed - "
"errno = %d\n", -err);
timer_irq_inited = 1;
__initcall(timer_init);
-
/*
* Overrides for Emacs so that we follow Linus's tabbing style.
* Emacs will notice this stuff at the end of the file and automatically