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
|
// Copyright 2018 The gVisor Authors.
//
// 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 state provides high-level state wrappers.
package state
import (
"fmt"
"io"
"gvisor.dev/gvisor/pkg/context"
"gvisor.dev/gvisor/pkg/errors/linuxerr"
"gvisor.dev/gvisor/pkg/fd"
"gvisor.dev/gvisor/pkg/log"
"gvisor.dev/gvisor/pkg/sentry/inet"
"gvisor.dev/gvisor/pkg/sentry/kernel"
"gvisor.dev/gvisor/pkg/sentry/pgalloc"
"gvisor.dev/gvisor/pkg/sentry/time"
"gvisor.dev/gvisor/pkg/sentry/vfs"
"gvisor.dev/gvisor/pkg/sentry/watchdog"
"gvisor.dev/gvisor/pkg/state/statefile"
)
var previousMetadata map[string]string
// ErrStateFile is returned when an error is encountered writing the statefile
// (which may occur during open or close calls in addition to write).
type ErrStateFile struct {
err error
}
// Error implements error.Error().
func (e ErrStateFile) Error() string {
return fmt.Sprintf("statefile error: %v", e.err)
}
// SaveOpts contains save-related options.
type SaveOpts struct {
// Destination is the save target.
Destination io.Writer
// PagesMetadata is the file into which MemoryFile metadata is stored if
// PagesMetadata is non-nil. Otherwise this content is stored in Destination.
PagesMetadata *fd.FD
// PagesFile is the file in which all MemoryFile pages are stored if
// PagesFile is non-nil. Otherwise this content is stored in Destination.
PagesFile *fd.FD
// Key is used for state integrity check.
Key []byte
// Metadata is save metadata.
Metadata map[string]string
// MemoryFileSaveOpts is passed to calls to pgalloc.MemoryFile.SaveTo().
MemoryFileSaveOpts pgalloc.SaveOpts
// Callback is called prior to unpause, with any save error.
Callback func(err error)
// Resume indicates if the statefile is used for save-resume.
Resume bool
}
// Save saves the system state.
func (opts SaveOpts) Save(ctx context.Context, k *kernel.Kernel, w *watchdog.Watchdog) error {
log.Infof("Sandbox save started, pausing all tasks.")
k.Pause()
k.ReceiveTaskStates()
defer func() {
k.Unpause()
log.Infof("Tasks resumed after save.")
}()
w.Stop()
defer w.Start()
// Supplement the metadata.
if opts.Metadata == nil {
opts.Metadata = make(map[string]string)
}
addSaveMetadata(opts.Metadata)
// Open the statefile.
wc, err := statefile.NewWriter(opts.Destination, opts.Key, opts.Metadata)
if err != nil {
err = ErrStateFile{err}
} else {
// Save the kernel.
err = k.SaveTo(ctx, wc, opts.PagesMetadata, opts.PagesFile, opts.MemoryFileSaveOpts)
// ENOSPC is a state file error. This error can only come from
// writing the state file, and not from fs.FileOperations.Fsync
// because we wrap those in kernel.TaskSet.flushWritesToFiles.
if linuxerr.Equals(linuxerr.ENOSPC, err) {
err = ErrStateFile{err}
}
if closeErr := wc.Close(); err == nil && closeErr != nil {
err = ErrStateFile{closeErr}
}
}
opts.Callback(err)
return err
}
// LoadOpts contains load-related options.
type LoadOpts struct {
// Source is the load source.
Source io.Reader
// PagesMetadata is the file into which MemoryFile metadata is stored if
// PagesMetadata is non-nil. Otherwise this content is stored in Source.
PagesMetadata *fd.FD
// PagesFile is the file in which all MemoryFile pages are stored if
// PagesFile is non-nil. Otherwise this content is stored in Source.
PagesFile *fd.FD
// Key is used for state integrity check.
Key []byte
}
// Load loads the given kernel, setting the provided platform and stack.
func (opts LoadOpts) Load(ctx context.Context, k *kernel.Kernel, timeReady chan struct{}, n inet.Stack, clocks time.Clocks, vfsOpts *vfs.CompleteRestoreOptions) error {
// Open the file.
r, m, err := statefile.NewReader(opts.Source, opts.Key)
if err != nil {
return ErrStateFile{err}
}
previousMetadata = m
// Restore the Kernel object graph.
return k.LoadFrom(ctx, r, opts.PagesMetadata, opts.PagesFile, timeReady, n, clocks, vfsOpts)
}
|
