forked from google/gvisor
-
Notifications
You must be signed in to change notification settings - Fork 0
/
timekeeper.go
270 lines (231 loc) · 7.46 KB
/
timekeeper.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
// Copyright 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package kernel
import (
"sync"
"time"
"gvisor.googlesource.com/gvisor/pkg/log"
ktime "gvisor.googlesource.com/gvisor/pkg/sentry/kernel/time"
"gvisor.googlesource.com/gvisor/pkg/sentry/platform"
sentrytime "gvisor.googlesource.com/gvisor/pkg/sentry/time"
)
// Timekeeper manages all of the kernel clocks.
type Timekeeper struct {
// clocks are the clock sources.
//
// These are not saved directly, as the new machine's clock may behave
// differently.
//
// It is set only once, by SetClocks.
clocks sentrytime.Clocks `state:"nosave"`
// bootTime is the realtime when the system "booted". i.e., when
// SetClocks was called in the initial (not restored) run.
bootTime ktime.Time
// monotonicOffset is the offset to apply to the monotonic clock output
// from clocks.
//
// It is set only once, by SetClocks.
monotonicOffset int64 `state:"nosave"`
// restored indicates that this Timekeeper was restored from a state
// file.
restored bool `state:"nosave"`
// saveMonotonic is the (offset) value of the monotonic clock at the
// time of save.
//
// It is only valid if restored is true.
//
// It is only used in SetClocks after restore to compute the new
// monotonicOffset.
saveMonotonic int64
// saveRealtime is the value of the realtime clock at the time of save.
//
// It is only valid if restored is true.
//
// It is only used in SetClocks after restore to compute the new
// monotonicOffset.
saveRealtime int64
// params manages the parameter page.
params *VDSOParamPage
// mu protects destruction with stop and wg.
mu sync.Mutex `state:"nosave"`
// stop is used to tell the update goroutine to exit.
stop chan struct{} `state:"nosave"`
// wg is used to indicate that the update goroutine has exited.
wg sync.WaitGroup `state:"nosave"`
}
// NewTimekeeper returns a Timekeeper that is automatically kept up-to-date.
// NewTimekeeper does not take ownership of paramPage.
//
// SetClocks must be called on the returned Timekeeper before it is usable.
func NewTimekeeper(platform platform.Platform, paramPage platform.FileRange) (*Timekeeper, error) {
return &Timekeeper{
params: NewVDSOParamPage(platform, paramPage),
}, nil
}
// SetClocks the backing clock source.
//
// SetClocks must be called before the Timekeeper is used, and it may not be
// called more than once, as changing the clock source without extra correction
// could cause time discontinuities.
//
// It must also be called after Load.
func (t *Timekeeper) SetClocks(c sentrytime.Clocks) {
// Update the params, marking them "not ready", as we may need to
// restart calibration on this new machine.
if t.restored {
if err := t.params.Write(func() vdsoParams {
return vdsoParams{}
}); err != nil {
panic("unable to reset VDSO params: " + err.Error())
}
}
if t.clocks != nil {
panic("SetClocks called on previously-initialized Timekeeper")
}
t.clocks = c
// Compute the offset of the monotonic clock from the base Clocks.
//
// In a fresh (not restored) sentry, monotonic time starts at zero.
//
// In a restored sentry, monotonic time jumps forward by approximately
// the same amount as real time. There are no guarantees here, we are
// just making a best-effort attempt to to make it appear that the app
// was simply not scheduled for a long period, rather than that the
// real time clock was changed.
//
// If real time went backwards, it remains the same.
wantMonotonic := int64(0)
nowMonotonic, err := t.clocks.GetTime(sentrytime.Monotonic)
if err != nil {
panic("Unable to get current monotonic time: " + err.Error())
}
nowRealtime, err := t.clocks.GetTime(sentrytime.Realtime)
if err != nil {
panic("Unable to get current realtime: " + err.Error())
}
if t.restored {
wantMonotonic = t.saveMonotonic
elapsed := nowRealtime - t.saveRealtime
if elapsed > 0 {
wantMonotonic += elapsed
}
}
t.monotonicOffset = wantMonotonic - nowMonotonic
if !t.restored {
// Hold on to the initial "boot" time.
t.bootTime = ktime.FromNanoseconds(nowRealtime)
}
t.mu.Lock()
defer t.mu.Unlock()
t.startUpdater()
}
// startUpdater starts an update goroutine that keeps the clocks updated.
//
// mu must be held.
func (t *Timekeeper) startUpdater() {
if t.stop != nil {
// Timekeeper already started
return
}
t.stop = make(chan struct{})
// Keep the clocks up to date.
//
// Note that the Go runtime uses host CLOCK_MONOTONIC to service the
// timer, so it may run at a *slightly* different rate from the
// application CLOCK_MONOTONIC. That is fine, as we only need to update
// at approximately this rate.
timer := time.NewTicker(sentrytime.ApproxUpdateInterval)
t.wg.Add(1)
go func() { // S/R-SAFE: stopped during save.
for {
// Start with an update immediately, so the clocks are
// ready ASAP.
// Call Update within a Write block to prevent the VDSO
// from using the old params between Update and
// Write.
if err := t.params.Write(func() vdsoParams {
monotonicParams, monotonicOk, realtimeParams, realtimeOk := t.clocks.Update()
var p vdsoParams
if monotonicOk {
p.monotonicReady = 1
p.monotonicBaseCycles = int64(monotonicParams.BaseCycles)
p.monotonicBaseRef = int64(monotonicParams.BaseRef) + t.monotonicOffset
p.monotonicFrequency = monotonicParams.Frequency
}
if realtimeOk {
p.realtimeReady = 1
p.realtimeBaseCycles = int64(realtimeParams.BaseCycles)
p.realtimeBaseRef = int64(realtimeParams.BaseRef)
p.realtimeFrequency = realtimeParams.Frequency
}
log.Debugf("Updating VDSO parameters: %+v", p)
return p
}); err != nil {
log.Warningf("Unable to update VDSO parameter page: %v", err)
}
select {
case <-timer.C:
case <-t.stop:
t.wg.Done()
return
}
}
}()
}
// stopUpdater stops the update goroutine, blocking until it exits.
//
// mu must be held.
func (t *Timekeeper) stopUpdater() {
if t.stop == nil {
// Updater not running.
return
}
close(t.stop)
t.wg.Wait()
t.stop = nil
}
// Destroy destroys the Timekeeper, freeing all associated resources.
func (t *Timekeeper) Destroy() {
t.mu.Lock()
defer t.mu.Unlock()
t.stopUpdater()
}
// PauseUpdates stops clock parameter updates. This should only be used when
// Tasks are not running and thus cannot access the clock.
func (t *Timekeeper) PauseUpdates() {
t.mu.Lock()
defer t.mu.Unlock()
t.stopUpdater()
}
// ResumeUpdates restarts clock parameter updates stopped by PauseUpdates.
func (t *Timekeeper) ResumeUpdates() {
t.mu.Lock()
defer t.mu.Unlock()
t.startUpdater()
}
// GetTime returns the current time in nanoseconds.
func (t *Timekeeper) GetTime(c sentrytime.ClockID) (int64, error) {
if t.clocks == nil {
panic("Timekeeper used before initialized with SetClocks")
}
now, err := t.clocks.GetTime(c)
if err == nil && c == sentrytime.Monotonic {
now += t.monotonicOffset
}
return now, err
}
// BootTime returns the system boot real time.
func (t *Timekeeper) BootTime() ktime.Time {
return t.bootTime
}