Commit | Line | Data |
---|---|---|
7af192c9 GH |
1 | /* paravirtual clock -- common code used by kvm/xen |
2 | ||
3 | This program is free software; you can redistribute it and/or modify | |
4 | it under the terms of the GNU General Public License as published by | |
5 | the Free Software Foundation; either version 2 of the License, or | |
6 | (at your option) any later version. | |
7 | ||
8 | This program is distributed in the hope that it will be useful, | |
9 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | GNU General Public License for more details. | |
12 | ||
13 | You should have received a copy of the GNU General Public License | |
14 | along with this program; if not, write to the Free Software | |
15 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
16 | */ | |
17 | ||
18 | #include <linux/kernel.h> | |
19 | #include <linux/percpu.h> | |
71056ae2 MT |
20 | #include <linux/notifier.h> |
21 | #include <linux/sched.h> | |
22 | #include <linux/gfp.h> | |
23 | #include <linux/bootmem.h> | |
38b8d208 IM |
24 | #include <linux/nmi.h> |
25 | ||
71056ae2 | 26 | #include <asm/fixmap.h> |
7af192c9 | 27 | #include <asm/pvclock.h> |
9f08890a | 28 | #include <asm/vgtod.h> |
7af192c9 | 29 | |
424c32f1 | 30 | static u8 valid_flags __read_mostly = 0; |
9f08890a | 31 | static struct pvclock_vsyscall_time_info *pvti_cpu0_va __read_mostly; |
424c32f1 GC |
32 | |
33 | void pvclock_set_flags(u8 flags) | |
34 | { | |
35 | valid_flags = flags; | |
36 | } | |
37 | ||
3807f345 GC |
38 | unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src) |
39 | { | |
a0854600 | 40 | u64 pv_tsc_khz = 1000000ULL << 32; |
3807f345 | 41 | |
a0854600 | 42 | do_div(pv_tsc_khz, src->tsc_to_system_mul); |
3807f345 | 43 | if (src->tsc_shift < 0) |
a0854600 | 44 | pv_tsc_khz <<= -src->tsc_shift; |
3807f345 | 45 | else |
a0854600 HH |
46 | pv_tsc_khz >>= src->tsc_shift; |
47 | return pv_tsc_khz; | |
3807f345 GC |
48 | } |
49 | ||
d63285e9 MT |
50 | void pvclock_touch_watchdogs(void) |
51 | { | |
52 | touch_softlockup_watchdog_sync(); | |
53 | clocksource_touch_watchdog(); | |
54 | rcu_cpu_stall_reset(); | |
8b414521 | 55 | reset_hung_task_detector(); |
d63285e9 MT |
56 | } |
57 | ||
489fb490 GC |
58 | static atomic64_t last_value = ATOMIC64_INIT(0); |
59 | ||
e7a3481c JF |
60 | void pvclock_resume(void) |
61 | { | |
62 | atomic64_set(&last_value, 0); | |
63 | } | |
64 | ||
2697902b MT |
65 | u8 pvclock_read_flags(struct pvclock_vcpu_time_info *src) |
66 | { | |
67 | unsigned version; | |
2697902b MT |
68 | u8 flags; |
69 | ||
70 | do { | |
3aed64f6 | 71 | version = pvclock_read_begin(src); |
ed911b43 | 72 | flags = src->flags; |
3aed64f6 | 73 | } while (pvclock_read_retry(src, version)); |
2697902b MT |
74 | |
75 | return flags & valid_flags; | |
76 | } | |
77 | ||
a5a1d1c2 | 78 | u64 pvclock_clocksource_read(struct pvclock_vcpu_time_info *src) |
7af192c9 | 79 | { |
7af192c9 | 80 | unsigned version; |
a5a1d1c2 | 81 | u64 ret; |
489fb490 | 82 | u64 last; |
42b5637d | 83 | u8 flags; |
7af192c9 GH |
84 | |
85 | do { | |
3aed64f6 | 86 | version = pvclock_read_begin(src); |
108b249c | 87 | ret = __pvclock_read_cycles(src, rdtsc_ordered()); |
3aed64f6 PB |
88 | flags = src->flags; |
89 | } while (pvclock_read_retry(src, version)); | |
7af192c9 | 90 | |
d63285e9 MT |
91 | if (unlikely((flags & PVCLOCK_GUEST_STOPPED) != 0)) { |
92 | src->flags &= ~PVCLOCK_GUEST_STOPPED; | |
93 | pvclock_touch_watchdogs(); | |
94 | } | |
95 | ||
3a0d7256 | 96 | if ((valid_flags & PVCLOCK_TSC_STABLE_BIT) && |
42b5637d | 97 | (flags & PVCLOCK_TSC_STABLE_BIT)) |
3a0d7256 GC |
98 | return ret; |
99 | ||
489fb490 GC |
100 | /* |
101 | * Assumption here is that last_value, a global accumulator, always goes | |
102 | * forward. If we are less than that, we should not be much smaller. | |
103 | * We assume there is an error marging we're inside, and then the correction | |
104 | * does not sacrifice accuracy. | |
105 | * | |
106 | * For reads: global may have changed between test and return, | |
107 | * but this means someone else updated poked the clock at a later time. | |
108 | * We just need to make sure we are not seeing a backwards event. | |
109 | * | |
110 | * For updates: last_value = ret is not enough, since two vcpus could be | |
111 | * updating at the same time, and one of them could be slightly behind, | |
112 | * making the assumption that last_value always go forward fail to hold. | |
113 | */ | |
114 | last = atomic64_read(&last_value); | |
115 | do { | |
116 | if (ret < last) | |
117 | return last; | |
118 | last = atomic64_cmpxchg(&last_value, last, ret); | |
119 | } while (unlikely(last != ret)); | |
120 | ||
7af192c9 GH |
121 | return ret; |
122 | } | |
123 | ||
124 | void pvclock_read_wallclock(struct pvclock_wall_clock *wall_clock, | |
125 | struct pvclock_vcpu_time_info *vcpu_time, | |
126 | struct timespec *ts) | |
127 | { | |
128 | u32 version; | |
129 | u64 delta; | |
130 | struct timespec now; | |
131 | ||
132 | /* get wallclock at system boot */ | |
133 | do { | |
134 | version = wall_clock->version; | |
135 | rmb(); /* fetch version before time */ | |
136 | now.tv_sec = wall_clock->sec; | |
137 | now.tv_nsec = wall_clock->nsec; | |
138 | rmb(); /* fetch time before checking version */ | |
139 | } while ((wall_clock->version & 1) || (version != wall_clock->version)); | |
140 | ||
141 | delta = pvclock_clocksource_read(vcpu_time); /* time since system boot */ | |
142 | delta += now.tv_sec * (u64)NSEC_PER_SEC + now.tv_nsec; | |
143 | ||
144 | now.tv_nsec = do_div(delta, NSEC_PER_SEC); | |
145 | now.tv_sec = delta; | |
146 | ||
147 | set_normalized_timespec(ts, now.tv_sec, now.tv_nsec); | |
148 | } | |
9f08890a JM |
149 | |
150 | void pvclock_set_pvti_cpu0_va(struct pvclock_vsyscall_time_info *pvti) | |
151 | { | |
152 | WARN_ON(vclock_was_used(VCLOCK_PVCLOCK)); | |
153 | pvti_cpu0_va = pvti; | |
154 | } | |
155 | ||
156 | struct pvclock_vsyscall_time_info *pvclock_get_pvti_cpu0_va(void) | |
157 | { | |
158 | return pvti_cpu0_va; | |
159 | } | |
160 | EXPORT_SYMBOL_GPL(pvclock_get_pvti_cpu0_va); |