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
|
// Copyright 2020 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 kernfs
import (
"gvisor.dev/gvisor/pkg/context"
"gvisor.dev/gvisor/pkg/safemem"
"gvisor.dev/gvisor/pkg/sentry/fs/fsutil"
"gvisor.dev/gvisor/pkg/sentry/memmap"
"gvisor.dev/gvisor/pkg/sync"
"gvisor.dev/gvisor/pkg/usermem"
)
// inodePlatformFile implements memmap.File. It exists solely because inode
// cannot implement both kernfs.Inode.IncRef and memmap.File.IncRef.
//
// +stateify savable
type inodePlatformFile struct {
// hostFD contains the host fd that this file was originally created from,
// which must be available at time of restore.
//
// This field is initialized at creation time and is immutable.
// inodePlatformFile does not own hostFD and hence should not close it.
hostFD int
// fdRefsMu protects fdRefs.
fdRefsMu sync.Mutex `state:"nosave"`
// fdRefs counts references on memmap.File offsets. It is used solely for
// memory accounting.
fdRefs fsutil.FrameRefSet
// fileMapper caches mappings of the host file represented by this inode.
fileMapper fsutil.HostFileMapper
// fileMapperInitOnce is used to lazily initialize fileMapper.
fileMapperInitOnce sync.Once `state:"nosave"`
}
var _ memmap.File = (*inodePlatformFile)(nil)
// IncRef implements memmap.File.IncRef.
func (i *inodePlatformFile) IncRef(fr memmap.FileRange) {
i.fdRefsMu.Lock()
i.fdRefs.IncRefAndAccount(fr)
i.fdRefsMu.Unlock()
}
// DecRef implements memmap.File.DecRef.
func (i *inodePlatformFile) DecRef(fr memmap.FileRange) {
i.fdRefsMu.Lock()
i.fdRefs.DecRefAndAccount(fr)
i.fdRefsMu.Unlock()
}
// MapInternal implements memmap.File.MapInternal.
func (i *inodePlatformFile) MapInternal(fr memmap.FileRange, at usermem.AccessType) (safemem.BlockSeq, error) {
return i.fileMapper.MapInternal(fr, i.hostFD, at.Write)
}
// FD implements memmap.File.FD.
func (i *inodePlatformFile) FD() int {
return i.hostFD
}
// CachedMappable implements memmap.Mappable. This utility can be embedded in a
// kernfs.Inode that represents a host file to make the inode mappable.
// CachedMappable caches the mappings of the host file. CachedMappable must be
// initialized (via Init) with a hostFD before use.
//
// +stateify savable
type CachedMappable struct {
// mapsMu protects mappings.
mapsMu sync.Mutex `state:"nosave"`
// mappings tracks mappings of hostFD into memmap.MappingSpaces.
mappings memmap.MappingSet
// pf implements memmap.File for mappings backed by a host fd.
pf inodePlatformFile
}
var _ memmap.Mappable = (*CachedMappable)(nil)
// Init initializes i.pf. This must be called before using CachedMappable.
func (i *CachedMappable) Init(hostFD int) {
i.pf.hostFD = hostFD
}
// AddMapping implements memmap.Mappable.AddMapping.
func (i *CachedMappable) AddMapping(ctx context.Context, ms memmap.MappingSpace, ar usermem.AddrRange, offset uint64, writable bool) error {
i.mapsMu.Lock()
mapped := i.mappings.AddMapping(ms, ar, offset, writable)
for _, r := range mapped {
i.pf.fileMapper.IncRefOn(r)
}
i.mapsMu.Unlock()
return nil
}
// RemoveMapping implements memmap.Mappable.RemoveMapping.
func (i *CachedMappable) RemoveMapping(ctx context.Context, ms memmap.MappingSpace, ar usermem.AddrRange, offset uint64, writable bool) {
i.mapsMu.Lock()
unmapped := i.mappings.RemoveMapping(ms, ar, offset, writable)
for _, r := range unmapped {
i.pf.fileMapper.DecRefOn(r)
}
i.mapsMu.Unlock()
}
// CopyMapping implements memmap.Mappable.CopyMapping.
func (i *CachedMappable) CopyMapping(ctx context.Context, ms memmap.MappingSpace, srcAR, dstAR usermem.AddrRange, offset uint64, writable bool) error {
return i.AddMapping(ctx, ms, dstAR, offset, writable)
}
// Translate implements memmap.Mappable.Translate.
func (i *CachedMappable) Translate(ctx context.Context, required, optional memmap.MappableRange, at usermem.AccessType) ([]memmap.Translation, error) {
mr := optional
return []memmap.Translation{
{
Source: mr,
File: &i.pf,
Offset: mr.Start,
Perms: usermem.AnyAccess,
},
}, nil
}
// InvalidateUnsavable implements memmap.Mappable.InvalidateUnsavable.
func (i *CachedMappable) InvalidateUnsavable(ctx context.Context) error {
// We expect the same host fd across save/restore, so all translations
// should be valid.
return nil
}
// InvalidateRange invalidates the passed range on i.mappings.
func (i *CachedMappable) InvalidateRange(r memmap.MappableRange) {
i.mapsMu.Lock()
i.mappings.Invalidate(r, memmap.InvalidateOpts{
// Compare Linux's mm/truncate.c:truncate_setsize() =>
// truncate_pagecache() =>
// mm/memory.c:unmap_mapping_range(evencows=1).
InvalidatePrivate: true,
})
i.mapsMu.Unlock()
}
// InitFileMapperOnce initializes the host file mapper. It ensures that the
// file mapper is initialized just once.
func (i *CachedMappable) InitFileMapperOnce() {
i.pf.fileMapperInitOnce.Do(i.pf.fileMapper.Init)
}
|
