]>
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> | |
24 | #include <asm/fixmap.h> | |
7af192c9 GH |
25 | #include <asm/pvclock.h> |
26 | ||
424c32f1 GC |
27 | static u8 valid_flags __read_mostly = 0; |
28 | ||
29 | void pvclock_set_flags(u8 flags) | |
30 | { | |
31 | valid_flags = flags; | |
32 | } | |
33 | ||
3807f345 GC |
34 | unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src) |
35 | { | |
a0854600 | 36 | u64 pv_tsc_khz = 1000000ULL << 32; |
3807f345 | 37 | |
a0854600 | 38 | do_div(pv_tsc_khz, src->tsc_to_system_mul); |
3807f345 | 39 | if (src->tsc_shift < 0) |
a0854600 | 40 | pv_tsc_khz <<= -src->tsc_shift; |
3807f345 | 41 | else |
a0854600 HH |
42 | pv_tsc_khz >>= src->tsc_shift; |
43 | return pv_tsc_khz; | |
3807f345 GC |
44 | } |
45 | ||
489fb490 GC |
46 | static atomic64_t last_value = ATOMIC64_INIT(0); |
47 | ||
e7a3481c JF |
48 | void pvclock_resume(void) |
49 | { | |
50 | atomic64_set(&last_value, 0); | |
51 | } | |
52 | ||
2697902b MT |
53 | u8 pvclock_read_flags(struct pvclock_vcpu_time_info *src) |
54 | { | |
55 | unsigned version; | |
56 | cycle_t ret; | |
57 | u8 flags; | |
58 | ||
59 | do { | |
60 | version = __pvclock_read_cycles(src, &ret, &flags); | |
61 | } while ((src->version & 1) || version != src->version); | |
62 | ||
63 | return flags & valid_flags; | |
64 | } | |
65 | ||
7af192c9 GH |
66 | cycle_t pvclock_clocksource_read(struct pvclock_vcpu_time_info *src) |
67 | { | |
7af192c9 | 68 | unsigned version; |
dce2db0a | 69 | cycle_t ret; |
489fb490 | 70 | u64 last; |
42b5637d | 71 | u8 flags; |
7af192c9 GH |
72 | |
73 | do { | |
dce2db0a | 74 | version = __pvclock_read_cycles(src, &ret, &flags); |
42b5637d | 75 | } while ((src->version & 1) || version != src->version); |
7af192c9 | 76 | |
3a0d7256 | 77 | if ((valid_flags & PVCLOCK_TSC_STABLE_BIT) && |
42b5637d | 78 | (flags & PVCLOCK_TSC_STABLE_BIT)) |
3a0d7256 GC |
79 | return ret; |
80 | ||
489fb490 GC |
81 | /* |
82 | * Assumption here is that last_value, a global accumulator, always goes | |
83 | * forward. If we are less than that, we should not be much smaller. | |
84 | * We assume there is an error marging we're inside, and then the correction | |
85 | * does not sacrifice accuracy. | |
86 | * | |
87 | * For reads: global may have changed between test and return, | |
88 | * but this means someone else updated poked the clock at a later time. | |
89 | * We just need to make sure we are not seeing a backwards event. | |
90 | * | |
91 | * For updates: last_value = ret is not enough, since two vcpus could be | |
92 | * updating at the same time, and one of them could be slightly behind, | |
93 | * making the assumption that last_value always go forward fail to hold. | |
94 | */ | |
95 | last = atomic64_read(&last_value); | |
96 | do { | |
97 | if (ret < last) | |
98 | return last; | |
99 | last = atomic64_cmpxchg(&last_value, last, ret); | |
100 | } while (unlikely(last != ret)); | |
101 | ||
7af192c9 GH |
102 | return ret; |
103 | } | |
104 | ||
105 | void pvclock_read_wallclock(struct pvclock_wall_clock *wall_clock, | |
106 | struct pvclock_vcpu_time_info *vcpu_time, | |
107 | struct timespec *ts) | |
108 | { | |
109 | u32 version; | |
110 | u64 delta; | |
111 | struct timespec now; | |
112 | ||
113 | /* get wallclock at system boot */ | |
114 | do { | |
115 | version = wall_clock->version; | |
116 | rmb(); /* fetch version before time */ | |
117 | now.tv_sec = wall_clock->sec; | |
118 | now.tv_nsec = wall_clock->nsec; | |
119 | rmb(); /* fetch time before checking version */ | |
120 | } while ((wall_clock->version & 1) || (version != wall_clock->version)); | |
121 | ||
122 | delta = pvclock_clocksource_read(vcpu_time); /* time since system boot */ | |
123 | delta += now.tv_sec * (u64)NSEC_PER_SEC + now.tv_nsec; | |
124 | ||
125 | now.tv_nsec = do_div(delta, NSEC_PER_SEC); | |
126 | now.tv_sec = delta; | |
127 | ||
128 | set_normalized_timespec(ts, now.tv_sec, now.tv_nsec); | |
129 | } | |
71056ae2 MT |
130 | |
131 | static struct pvclock_vsyscall_time_info *pvclock_vdso_info; | |
132 | ||
133 | static struct pvclock_vsyscall_time_info * | |
134 | pvclock_get_vsyscall_user_time_info(int cpu) | |
135 | { | |
136 | if (!pvclock_vdso_info) { | |
137 | BUG(); | |
138 | return NULL; | |
139 | } | |
140 | ||
141 | return &pvclock_vdso_info[cpu]; | |
142 | } | |
143 | ||
144 | struct pvclock_vcpu_time_info *pvclock_get_vsyscall_time_info(int cpu) | |
145 | { | |
146 | return &pvclock_get_vsyscall_user_time_info(cpu)->pvti; | |
147 | } | |
148 | ||
149 | #ifdef CONFIG_X86_64 | |
150 | static int pvclock_task_migrate(struct notifier_block *nb, unsigned long l, | |
151 | void *v) | |
152 | { | |
153 | struct task_migration_notifier *mn = v; | |
154 | struct pvclock_vsyscall_time_info *pvti; | |
155 | ||
156 | pvti = pvclock_get_vsyscall_user_time_info(mn->from_cpu); | |
157 | ||
158 | /* this is NULL when pvclock vsyscall is not initialized */ | |
159 | if (unlikely(pvti == NULL)) | |
160 | return NOTIFY_DONE; | |
161 | ||
162 | pvti->migrate_count++; | |
163 | ||
164 | return NOTIFY_DONE; | |
165 | } | |
166 | ||
167 | static struct notifier_block pvclock_migrate = { | |
168 | .notifier_call = pvclock_task_migrate, | |
169 | }; | |
170 | ||
171 | /* | |
172 | * Initialize the generic pvclock vsyscall state. This will allocate | |
173 | * a/some page(s) for the per-vcpu pvclock information, set up a | |
174 | * fixmap mapping for the page(s) | |
175 | */ | |
176 | ||
177 | int __init pvclock_init_vsyscall(struct pvclock_vsyscall_time_info *i, | |
178 | int size) | |
179 | { | |
180 | int idx; | |
181 | ||
182 | WARN_ON (size != PVCLOCK_VSYSCALL_NR_PAGES*PAGE_SIZE); | |
183 | ||
184 | pvclock_vdso_info = i; | |
185 | ||
186 | for (idx = 0; idx <= (PVCLOCK_FIXMAP_END-PVCLOCK_FIXMAP_BEGIN); idx++) { | |
187 | __set_fixmap(PVCLOCK_FIXMAP_BEGIN + idx, | |
3d2a80a2 | 188 | __pa(i) + (idx*PAGE_SIZE), |
71056ae2 MT |
189 | PAGE_KERNEL_VVAR); |
190 | } | |
191 | ||
192 | ||
193 | register_task_migration_notifier(&pvclock_migrate); | |
194 | ||
195 | return 0; | |
196 | } | |
197 | #endif |