ia64/xen-unstable

view linux-2.4.27-xen-sparse/arch/xen/kernel/time.c @ 2621:9402048e2325

bitkeeper revision 1.1159.1.218 (416a8128OiHXHyk_Sy8FsA0YUQcEnA)

Merge freefall.cl.cam.ac.uk:/auto/groups/xeno/users/cl349/BK/xeno.bk-26dom0
into freefall.cl.cam.ac.uk:/local/scratch/cl349/xeno.bk-26dom0
author cl349@freefall.cl.cam.ac.uk
date Mon Oct 11 12:48:40 2004 +0000 (2004-10-11)
parents e1abd8945ded
children 756c16a98f27 d7ee91c5f868
line source
1 /* -*- Mode:C; c-basic-offset:4; tab-width:4 -*-
2 ****************************************************************************
3 * (C) 2002-2003 - Rolf Neugebauer - Intel Research Cambridge
4 * (C) 2002-2003 - Keir Fraser - University of Cambridge
5 ****************************************************************************
6 *
7 * File: arch/xen/kernel/time.c
8 * Author: Rolf Neugebauer and Keir Fraser
9 *
10 * Description: Interface with Xen to get correct notion of time
11 */
13 /*
14 * linux/arch/i386/kernel/time.c
15 *
16 * Copyright (C) 1991, 1992, 1995 Linus Torvalds
17 *
18 * This file contains the PC-specific time handling details:
19 * reading the RTC at bootup, etc..
20 * 1994-07-02 Alan Modra
21 * fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
22 * 1995-03-26 Markus Kuhn
23 * fixed 500 ms bug at call to set_rtc_mmss, fixed DS12887
24 * precision CMOS clock update
25 * 1996-05-03 Ingo Molnar
26 * fixed time warps in do_[slow|fast]_gettimeoffset()
27 * 1997-09-10 Updated NTP code according to technical memorandum Jan '96
28 * "A Kernel Model for Precision Timekeeping" by Dave Mills
29 * 1998-09-05 (Various)
30 * More robust do_fast_gettimeoffset() algorithm implemented
31 * (works with APM, Cyrix 6x86MX and Centaur C6),
32 * monotonic gettimeofday() with fast_get_timeoffset(),
33 * drift-proof precision TSC calibration on boot
34 * (C. Scott Ananian <cananian@alumni.princeton.edu>, Andrew D.
35 * Balsa <andrebalsa@altern.org>, Philip Gladstone <philip@raptor.com>;
36 * ported from 2.0.35 Jumbo-9 by Michael Krause <m.krause@tu-harburg.de>).
37 * 1998-12-16 Andrea Arcangeli
38 * Fixed Jumbo-9 code in 2.1.131: do_gettimeofday was missing 1 jiffy
39 * because was not accounting lost_ticks.
40 * 1998-12-24 Copyright (C) 1998 Andrea Arcangeli
41 * Fixed a xtime SMP race (we need the xtime_lock rw spinlock to
42 * serialize accesses to xtime/lost_ticks).
43 */
45 #include <asm/smp.h>
46 #include <asm/irq.h>
47 #include <asm/msr.h>
48 #include <asm/delay.h>
49 #include <asm/mpspec.h>
50 #include <asm/uaccess.h>
51 #include <asm/processor.h>
53 #include <asm/div64.h>
54 #include <asm/hypervisor.h>
55 #include <asm/hypervisor-ifs/dom0_ops.h>
57 #include <linux/mc146818rtc.h>
58 #include <linux/kernel.h>
59 #include <linux/interrupt.h>
60 #include <linux/time.h>
61 #include <linux/init.h>
62 #include <linux/smp.h>
63 #include <linux/irq.h>
64 #include <linux/sysctl.h>
65 #include <linux/sysrq.h>
67 spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED;
68 extern rwlock_t xtime_lock;
69 extern unsigned long wall_jiffies;
71 unsigned long cpu_khz; /* get this from Xen, used elsewhere */
73 static unsigned int rdtsc_bitshift;
74 static u32 st_scale_f; /* convert ticks -> usecs */
75 static u32 st_scale_i; /* convert ticks -> usecs */
77 /* These are peridically updated in shared_info, and then copied here. */
78 static u32 shadow_tsc_stamp;
79 static u64 shadow_system_time;
80 static u32 shadow_time_version;
81 static struct timeval shadow_tv;
83 /*
84 * We use this to ensure that gettimeofday() is monotonically increasing. We
85 * only break this guarantee if the wall clock jumps backwards "a long way".
86 */
87 static struct timeval last_seen_tv = {0,0};
89 #ifdef CONFIG_XEN_PRIVILEGED_GUEST
90 /* Periodically propagate synchronised time base to the RTC and to Xen. */
91 static long last_update_to_rtc, last_update_to_xen;
92 #endif
94 /* Periodically take synchronised time base from Xen, if we need it. */
95 static long last_update_from_xen; /* UTC seconds when last read Xen clock. */
97 /* Keep track of last time we did processing/updating of jiffies and xtime. */
98 static u64 processed_system_time; /* System time (ns) at last processing. */
100 #define NS_PER_TICK (1000000000ULL/HZ)
102 #define HANDLE_USEC_UNDERFLOW(_tv) \
103 do { \
104 while ( (_tv).tv_usec < 0 ) \
105 { \
106 (_tv).tv_usec += 1000000; \
107 (_tv).tv_sec--; \
108 } \
109 } while ( 0 )
110 #define HANDLE_USEC_OVERFLOW(_tv) \
111 do { \
112 while ( (_tv).tv_usec >= 1000000 ) \
113 { \
114 (_tv).tv_usec -= 1000000; \
115 (_tv).tv_sec++; \
116 } \
117 } while ( 0 )
119 /* Dynamically-mapped IRQs. */
120 static int time_irq, debug_irq;
122 /* Does this guest OS track Xen time, or set its wall clock independently? */
123 static int independent_wallclock = 0;
124 static int __init __independent_wallclock(char *str)
125 {
126 independent_wallclock = 1;
127 return 1;
128 }
129 __setup("independent_wallclock", __independent_wallclock);
130 #define INDEPENDENT_WALLCLOCK() \
131 (independent_wallclock || (xen_start_info.flags & SIF_INITDOMAIN))
133 #ifdef CONFIG_XEN_PRIVILEGED_GUEST
134 /*
135 * In order to set the CMOS clock precisely, set_rtc_mmss has to be
136 * called 500 ms after the second nowtime has started, because when
137 * nowtime is written into the registers of the CMOS clock, it will
138 * jump to the next second precisely 500 ms later. Check the Motorola
139 * MC146818A or Dallas DS12887 data sheet for details.
140 *
141 * BUG: This routine does not handle hour overflow properly; it just
142 * sets the minutes. Usually you'll only notice that after reboot!
143 */
144 static int set_rtc_mmss(unsigned long nowtime)
145 {
146 int retval = 0;
147 int real_seconds, real_minutes, cmos_minutes;
148 unsigned char save_control, save_freq_select;
150 /* gets recalled with irq locally disabled */
151 spin_lock(&rtc_lock);
152 save_control = CMOS_READ(RTC_CONTROL);
153 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
155 save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
156 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
158 cmos_minutes = CMOS_READ(RTC_MINUTES);
159 if ( !(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD )
160 BCD_TO_BIN(cmos_minutes);
162 /*
163 * since we're only adjusting minutes and seconds, don't interfere with
164 * hour overflow. This avoids messing with unknown time zones but requires
165 * your RTC not to be off by more than 15 minutes
166 */
167 real_seconds = nowtime % 60;
168 real_minutes = nowtime / 60;
169 if ( ((abs(real_minutes - cmos_minutes) + 15)/30) & 1 )
170 real_minutes += 30; /* correct for half hour time zone */
171 real_minutes %= 60;
173 if ( abs(real_minutes - cmos_minutes) < 30 )
174 {
175 if ( !(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD )
176 {
177 BIN_TO_BCD(real_seconds);
178 BIN_TO_BCD(real_minutes);
179 }
180 CMOS_WRITE(real_seconds,RTC_SECONDS);
181 CMOS_WRITE(real_minutes,RTC_MINUTES);
182 }
183 else
184 {
185 printk(KERN_WARNING
186 "set_rtc_mmss: can't update from %d to %d\n",
187 cmos_minutes, real_minutes);
188 retval = -1;
189 }
191 /* The following flags have to be released exactly in this order,
192 * otherwise the DS12887 (popular MC146818A clone with integrated
193 * battery and quartz) will not reset the oscillator and will not
194 * update precisely 500 ms later. You won't find this mentioned in
195 * the Dallas Semiconductor data sheets, but who believes data
196 * sheets anyway ... -- Markus Kuhn
197 */
198 CMOS_WRITE(save_control, RTC_CONTROL);
199 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
200 spin_unlock(&rtc_lock);
202 return retval;
203 }
204 #endif
207 /*
208 * Reads a consistent set of time-base values from Xen, into a shadow data
209 * area. Must be called with the xtime_lock held for writing.
210 */
211 static void __get_time_values_from_xen(void)
212 {
213 do {
214 shadow_time_version = HYPERVISOR_shared_info->time_version2;
215 rmb();
216 shadow_tv.tv_sec = HYPERVISOR_shared_info->wc_sec;
217 shadow_tv.tv_usec = HYPERVISOR_shared_info->wc_usec;
218 shadow_tsc_stamp =
219 (u32)(HYPERVISOR_shared_info->tsc_timestamp >> rdtsc_bitshift);
220 shadow_system_time = HYPERVISOR_shared_info->system_time;
221 rmb();
222 }
223 while ( shadow_time_version != HYPERVISOR_shared_info->time_version1 );
224 }
226 #define TIME_VALUES_UP_TO_DATE \
227 ({ rmb(); (shadow_time_version == HYPERVISOR_shared_info->time_version2); })
230 /*
231 * Returns the system time elapsed, in ns, since the current shadow_timestamp
232 * was calculated. Must be called with the xtime_lock held for reading.
233 */
234 static inline unsigned long __get_time_delta_usecs(void)
235 {
236 s32 delta_tsc;
237 u32 low;
238 u64 delta, tsc;
240 rdtscll(tsc);
241 low = (u32)(tsc >> rdtsc_bitshift);
242 delta_tsc = (s32)(low - shadow_tsc_stamp);
243 if ( unlikely(delta_tsc < 0) ) delta_tsc = 0;
244 delta = ((u64)delta_tsc * st_scale_f);
245 delta >>= 32;
246 delta += ((u64)delta_tsc * st_scale_i);
248 return (unsigned long)delta;
249 }
252 /*
253 * Returns the current time-of-day in UTC timeval format.
254 */
255 void do_gettimeofday(struct timeval *tv)
256 {
257 unsigned long flags, lost;
258 struct timeval _tv;
260 again:
261 read_lock_irqsave(&xtime_lock, flags);
263 _tv.tv_usec = __get_time_delta_usecs();
264 if ( (lost = (jiffies - wall_jiffies)) != 0 )
265 _tv.tv_usec += lost * (1000000 / HZ);
266 _tv.tv_sec = xtime.tv_sec;
267 _tv.tv_usec += xtime.tv_usec;
269 if ( unlikely(!TIME_VALUES_UP_TO_DATE) )
270 {
271 /*
272 * We may have blocked for a long time, rendering our calculations
273 * invalid (e.g. the time delta may have overflowed). Detect that
274 * and recalculate with fresh values.
275 */
276 read_unlock_irqrestore(&xtime_lock, flags);
277 write_lock_irqsave(&xtime_lock, flags);
278 __get_time_values_from_xen();
279 write_unlock_irqrestore(&xtime_lock, flags);
280 goto again;
281 }
283 HANDLE_USEC_OVERFLOW(_tv);
285 /* Ensure that time-of-day is monotonically increasing. */
286 if ( (_tv.tv_sec < last_seen_tv.tv_sec) ||
287 ((_tv.tv_sec == last_seen_tv.tv_sec) &&
288 (_tv.tv_usec < last_seen_tv.tv_usec)) )
289 _tv = last_seen_tv;
290 last_seen_tv = _tv;
292 read_unlock_irqrestore(&xtime_lock, flags);
294 *tv = _tv;
295 }
298 /*
299 * Sets the current time-of-day based on passed-in UTC timeval parameter.
300 */
301 void do_settimeofday(struct timeval *tv)
302 {
303 struct timeval newtv;
304 suseconds_t usec;
306 if ( !INDEPENDENT_WALLCLOCK() )
307 return;
309 write_lock_irq(&xtime_lock);
311 /*
312 * Ensure we don't get blocked for a long time so that our time delta
313 * overflows. If that were to happen then our shadow time values would
314 * be stale, so we can retry with fresh ones.
315 */
316 again:
317 usec = tv->tv_usec - __get_time_delta_usecs();
318 if ( unlikely(!TIME_VALUES_UP_TO_DATE) )
319 {
320 __get_time_values_from_xen();
321 goto again;
322 }
323 tv->tv_usec = usec;
325 HANDLE_USEC_UNDERFLOW(*tv);
327 newtv = *tv;
329 tv->tv_usec -= (jiffies - wall_jiffies) * (1000000 / HZ);
330 HANDLE_USEC_UNDERFLOW(*tv);
332 xtime = *tv;
333 time_adjust = 0; /* stop active adjtime() */
334 time_status |= STA_UNSYNC;
335 time_maxerror = NTP_PHASE_LIMIT;
336 time_esterror = NTP_PHASE_LIMIT;
338 /* Reset all our running time counts. They make no sense now. */
339 last_seen_tv.tv_sec = 0;
340 last_update_from_xen = 0;
342 #ifdef CONFIG_XEN_PRIVILEGED_GUEST
343 if ( xen_start_info.flags & SIF_INITDOMAIN )
344 {
345 dom0_op_t op;
346 last_update_to_rtc = last_update_to_xen = 0;
347 op.cmd = DOM0_SETTIME;
348 op.u.settime.secs = newtv.tv_sec;
349 op.u.settime.usecs = newtv.tv_usec;
350 op.u.settime.system_time = shadow_system_time;
351 write_unlock_irq(&xtime_lock);
352 HYPERVISOR_dom0_op(&op);
353 }
354 else
355 #endif
356 {
357 write_unlock_irq(&xtime_lock);
358 }
359 }
362 asmlinkage long sys_stime(int *tptr)
363 {
364 int value;
365 struct timeval tv;
367 if ( !capable(CAP_SYS_TIME) )
368 return -EPERM;
370 if ( get_user(value, tptr) )
371 return -EFAULT;
373 tv.tv_sec = value;
374 tv.tv_usec = 0;
376 do_settimeofday(&tv);
378 return 0;
379 }
382 /* Convert jiffies to system time. Call with xtime_lock held for reading. */
383 static inline u64 __jiffies_to_st(unsigned long j)
384 {
385 return processed_system_time + ((j - jiffies) * NS_PER_TICK);
386 }
389 static inline void do_timer_interrupt(int irq, void *dev_id,
390 struct pt_regs *regs)
391 {
392 s64 delta;
393 unsigned long ticks = 0;
394 long sec_diff;
396 retry:
397 __get_time_values_from_xen();
399 if ( (delta = (s64)(shadow_system_time + __get_time_delta_usecs() * 1000 -
400 processed_system_time)) < 0 )
401 {
402 if (!TIME_VALUES_UP_TO_DATE)
403 goto retry;
404 printk("Timer ISR: Time went backwards: %lld\n", delta);
405 return;
406 }
408 /* Process elapsed jiffies since last call. */
409 while ( delta >= NS_PER_TICK )
410 {
411 ticks++;
412 delta -= NS_PER_TICK;
413 processed_system_time += NS_PER_TICK;
414 }
416 if ( ticks != 0 )
417 {
418 do_timer_ticks(ticks);
420 if ( user_mode(regs) )
421 update_process_times_us(ticks, 0);
422 else
423 update_process_times_us(0, ticks);
424 }
426 /*
427 * Take synchronised time from Xen once a minute if we're not
428 * synchronised ourselves, and we haven't chosen to keep an independent
429 * time base.
430 */
431 if ( !INDEPENDENT_WALLCLOCK() &&
432 ((time_status & STA_UNSYNC) != 0) &&
433 (xtime.tv_sec > (last_update_from_xen + 60)) )
434 {
435 /* Adjust shadow timeval for jiffies that haven't updated xtime yet. */
436 shadow_tv.tv_usec -= (jiffies - wall_jiffies) * (1000000/HZ);
437 HANDLE_USEC_UNDERFLOW(shadow_tv);
439 /*
440 * Reset our running time counts if they are invalidated by a warp
441 * backwards of more than 500ms.
442 */
443 sec_diff = xtime.tv_sec - shadow_tv.tv_sec;
444 if ( unlikely(abs(sec_diff) > 1) ||
445 unlikely(((sec_diff * 1000000) +
446 xtime.tv_usec - shadow_tv.tv_usec) > 500000) )
447 {
448 #ifdef CONFIG_XEN_PRIVILEGED_GUEST
449 last_update_to_rtc = last_update_to_xen = 0;
450 #endif
451 last_seen_tv.tv_sec = 0;
452 }
454 /* Update our unsynchronised xtime appropriately. */
455 xtime = shadow_tv;
457 last_update_from_xen = xtime.tv_sec;
458 }
460 #ifdef CONFIG_XEN_PRIVILEGED_GUEST
461 if ( (xen_start_info.flags & SIF_INITDOMAIN) &&
462 ((time_status & STA_UNSYNC) == 0) )
463 {
464 /* Send synchronised time to Xen approximately every minute. */
465 if ( xtime.tv_sec > (last_update_to_xen + 60) )
466 {
467 dom0_op_t op;
468 struct timeval tv = xtime;
470 tv.tv_usec += (jiffies - wall_jiffies) * (1000000/HZ);
471 HANDLE_USEC_OVERFLOW(tv);
473 op.cmd = DOM0_SETTIME;
474 op.u.settime.secs = tv.tv_sec;
475 op.u.settime.usecs = tv.tv_usec;
476 op.u.settime.system_time = shadow_system_time;
477 HYPERVISOR_dom0_op(&op);
479 last_update_to_xen = xtime.tv_sec;
480 }
482 /*
483 * If we have an externally synchronized Linux clock, then update CMOS
484 * clock accordingly every ~11 minutes. Set_rtc_mmss() has to be called
485 * as close as possible to 500 ms before the new second starts.
486 */
487 if ( (xtime.tv_sec > (last_update_to_rtc + 660)) &&
488 (xtime.tv_usec >= (500000 - ((unsigned) tick) / 2)) &&
489 (xtime.tv_usec <= (500000 + ((unsigned) tick) / 2)) )
490 {
491 if ( set_rtc_mmss(xtime.tv_sec) == 0 )
492 last_update_to_rtc = xtime.tv_sec;
493 else
494 last_update_to_rtc = xtime.tv_sec - 600;
495 }
496 }
497 #endif
498 }
501 static void timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
502 {
503 write_lock(&xtime_lock);
504 do_timer_interrupt(irq, NULL, regs);
505 write_unlock(&xtime_lock);
506 }
508 static struct irqaction irq_timer = {
509 timer_interrupt,
510 SA_INTERRUPT,
511 0,
512 "timer",
513 NULL,
514 NULL
515 };
518 /*
519 * This function works out when the the next timer function has to be
520 * executed (by looking at the timer list) and sets the Xen one-shot
521 * domain timer to the appropriate value. This is typically called in
522 * cpu_idle() before the domain blocks.
523 *
524 * The function returns a non-0 value on error conditions.
525 *
526 * It must be called with interrupts disabled.
527 */
528 extern spinlock_t timerlist_lock;
529 int set_timeout_timer(void)
530 {
531 struct timer_list *timer;
532 u64 alarm = 0;
533 int ret = 0;
535 spin_lock(&timerlist_lock);
537 /*
538 * This is safe against long blocking (since calculations are not based on
539 * TSC deltas). It is also safe against warped system time since
540 * suspend-resume is cooperative and we would first get locked out. It is
541 * safe against normal updates of jiffies since interrupts are off.
542 */
543 if ( (timer = next_timer_event()) != NULL )
544 alarm = __jiffies_to_st(timer->expires);
546 /* Tasks on the timer task queue expect to be executed on the next tick. */
547 if ( TQ_ACTIVE(tq_timer) )
548 alarm = __jiffies_to_st(jiffies + 1);
550 /* Failure is pretty bad, but we'd best soldier on. */
551 if ( HYPERVISOR_set_timer_op(alarm) != 0 )
552 ret = -1;
554 spin_unlock(&timerlist_lock);
556 return ret;
557 }
560 /* Time debugging. */
561 static void dbg_time_int(int irq, void *dev_id, struct pt_regs *ptregs)
562 {
563 unsigned long flags, j;
564 u64 s_now, j_st;
565 struct timeval s_tv, tv;
567 struct timer_list *timer;
568 u64 t_st;
570 read_lock_irqsave(&xtime_lock, flags);
571 s_tv.tv_sec = shadow_tv.tv_sec;
572 s_tv.tv_usec = shadow_tv.tv_usec;
573 s_now = shadow_system_time;
574 read_unlock_irqrestore(&xtime_lock, flags);
576 do_gettimeofday(&tv);
578 j = jiffies;
579 j_st = __jiffies_to_st(j);
581 timer = next_timer_event();
582 t_st = __jiffies_to_st(timer->expires);
584 printk(KERN_ALERT "time: shadow_st=0x%X:%08X\n",
585 (u32)(s_now>>32), (u32)s_now);
586 printk(KERN_ALERT "time: wct=%lds %ldus shadow_wct=%lds %ldus\n",
587 tv.tv_sec, tv.tv_usec, s_tv.tv_sec, s_tv.tv_usec);
588 printk(KERN_ALERT "time: jiffies=%lu(0x%X:%08X) timeout=%lu(0x%X:%08X)\n",
589 jiffies,(u32)(j_st>>32), (u32)j_st,
590 timer->expires,(u32)(t_st>>32), (u32)t_st);
591 printk(KERN_ALERT "time: processed_system_time=0x%X:%08X\n",
592 (u32)(processed_system_time>>32), (u32)processed_system_time);
594 #ifdef CONFIG_MAGIC_SYSRQ
595 handle_sysrq('t',NULL,NULL,NULL);
596 #endif
597 }
599 static struct irqaction dbg_time = {
600 dbg_time_int,
601 SA_SHIRQ,
602 0,
603 "timer_dbg",
604 &dbg_time_int,
605 NULL
606 };
608 void __init time_init(void)
609 {
610 unsigned long long alarm;
611 u64 __cpu_khz, __cpu_ghz, cpu_freq, scale, scale2;
612 unsigned int cpu_ghz;
614 __cpu_khz = __cpu_ghz = cpu_freq = HYPERVISOR_shared_info->cpu_freq;
615 do_div(__cpu_khz, 1000UL);
616 cpu_khz = (u32)__cpu_khz;
617 do_div(__cpu_ghz, 1000000000UL);
618 cpu_ghz = (unsigned int)__cpu_ghz;
620 printk("Xen reported: %lu.%03lu MHz processor.\n",
621 cpu_khz / 1000, cpu_khz % 1000);
623 xtime.tv_sec = HYPERVISOR_shared_info->wc_sec;
624 xtime.tv_usec = HYPERVISOR_shared_info->wc_usec;
625 processed_system_time = shadow_system_time;
627 for ( rdtsc_bitshift = 0; cpu_ghz != 0; rdtsc_bitshift++, cpu_ghz >>= 1 )
628 continue;
630 scale = 1000000LL << (32 + rdtsc_bitshift);
631 do_div(scale, (u32)cpu_freq);
633 if ( (cpu_freq >> 32) != 0 )
634 {
635 scale2 = 1000000LL << rdtsc_bitshift;
636 do_div(scale2, (u32)(cpu_freq>>32));
637 scale += scale2;
638 }
640 st_scale_f = scale & 0xffffffff;
641 st_scale_i = scale >> 32;
643 __get_time_values_from_xen();
644 processed_system_time = shadow_system_time;
646 time_irq = bind_virq_to_irq(VIRQ_TIMER);
647 debug_irq = bind_virq_to_irq(VIRQ_DEBUG);
649 (void)setup_irq(time_irq, &irq_timer);
650 (void)setup_irq(debug_irq, &dbg_time);
652 rdtscll(alarm);
653 }
655 void time_suspend(void)
656 {
657 }
659 void time_resume(void)
660 {
661 unsigned long flags;
662 write_lock_irqsave(&xtime_lock, flags);
663 /* Get timebases for new environment. */
664 __get_time_values_from_xen();
665 /* Reset our own concept of passage of system time. */
666 processed_system_time = shadow_system_time;
667 /* Accept a warp in UTC (wall-clock) time. */
668 last_seen_tv.tv_sec = 0;
669 /* Make sure we resync UTC time with Xen on next timer interrupt. */
670 last_update_from_xen = 0;
671 write_unlock_irqrestore(&xtime_lock, flags);
672 }
674 /*
675 * /proc/sys/xen: This really belongs in another file. It can stay here for
676 * now however.
677 */
678 static ctl_table xen_subtable[] = {
679 {1, "independent_wallclock", &independent_wallclock,
680 sizeof(independent_wallclock), 0644, NULL, proc_dointvec},
681 {0}
682 };
683 static ctl_table xen_table[] = {
684 {123, "xen", NULL, 0, 0555, xen_subtable},
685 {0}
686 };
687 static int __init xen_sysctl_init(void)
688 {
689 (void)register_sysctl_table(xen_table, 0);
690 return 0;
691 }
692 __initcall(xen_sysctl_init);