2019-04-29 21:25:05 +00:00
|
|
|
// Copyright 2018 The gVisor Authors.
|
2018-04-27 17:37:02 +00:00
|
|
|
//
|
|
|
|
// 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 mm
|
|
|
|
|
|
|
|
import (
|
2019-06-13 23:49:09 +00:00
|
|
|
"gvisor.dev/gvisor/pkg/refs"
|
|
|
|
"gvisor.dev/gvisor/pkg/sentry/context"
|
|
|
|
"gvisor.dev/gvisor/pkg/sentry/memmap"
|
|
|
|
"gvisor.dev/gvisor/pkg/sentry/pgalloc"
|
|
|
|
"gvisor.dev/gvisor/pkg/sentry/platform"
|
|
|
|
"gvisor.dev/gvisor/pkg/sentry/usage"
|
|
|
|
"gvisor.dev/gvisor/pkg/sentry/usermem"
|
|
|
|
"gvisor.dev/gvisor/pkg/syserror"
|
2018-04-27 17:37:02 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// SpecialMappable implements memmap.MappingIdentity and memmap.Mappable with
|
|
|
|
// semantics similar to Linux's mm/mmap.c:_install_special_mapping(), except
|
|
|
|
// that SpecialMappable takes ownership of the memory that it represents
|
|
|
|
// (_install_special_mapping() does not.)
|
2018-08-02 17:41:44 +00:00
|
|
|
//
|
|
|
|
// +stateify savable
|
2018-04-27 17:37:02 +00:00
|
|
|
type SpecialMappable struct {
|
|
|
|
refs.AtomicRefCount
|
|
|
|
|
2019-03-14 15:11:36 +00:00
|
|
|
mfp pgalloc.MemoryFileProvider
|
2018-04-27 17:37:02 +00:00
|
|
|
fr platform.FileRange
|
|
|
|
name string
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewSpecialMappable returns a SpecialMappable that owns fr, which represents
|
2019-03-14 15:11:36 +00:00
|
|
|
// offsets in mfp.MemoryFile() that contain the SpecialMappable's data. The
|
2018-04-27 17:37:02 +00:00
|
|
|
// SpecialMappable will use the given name in /proc/[pid]/maps.
|
|
|
|
//
|
|
|
|
// Preconditions: fr.Length() != 0.
|
2019-03-14 15:11:36 +00:00
|
|
|
func NewSpecialMappable(name string, mfp pgalloc.MemoryFileProvider, fr platform.FileRange) *SpecialMappable {
|
2019-06-29 03:06:33 +00:00
|
|
|
m := SpecialMappable{mfp: mfp, fr: fr, name: name}
|
|
|
|
m.EnableLeakCheck("mm.SpecialMappable")
|
|
|
|
return &m
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// DecRef implements refs.RefCounter.DecRef.
|
|
|
|
func (m *SpecialMappable) DecRef() {
|
|
|
|
m.AtomicRefCount.DecRefWithDestructor(func() {
|
2019-03-14 15:11:36 +00:00
|
|
|
m.mfp.MemoryFile().DecRef(m.fr)
|
2018-04-27 17:37:02 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// MappedName implements memmap.MappingIdentity.MappedName.
|
|
|
|
func (m *SpecialMappable) MappedName(ctx context.Context) string {
|
|
|
|
return m.name
|
|
|
|
}
|
|
|
|
|
|
|
|
// DeviceID implements memmap.MappingIdentity.DeviceID.
|
|
|
|
func (m *SpecialMappable) DeviceID() uint64 {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
// InodeID implements memmap.MappingIdentity.InodeID.
|
|
|
|
func (m *SpecialMappable) InodeID() uint64 {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
// Msync implements memmap.MappingIdentity.Msync.
|
|
|
|
func (m *SpecialMappable) Msync(ctx context.Context, mr memmap.MappableRange) error {
|
|
|
|
// Linux: vm_file is NULL, causing msync to skip it entirely.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// AddMapping implements memmap.Mappable.AddMapping.
|
2018-12-12 21:09:10 +00:00
|
|
|
func (*SpecialMappable) AddMapping(context.Context, memmap.MappingSpace, usermem.AddrRange, uint64, bool) error {
|
2018-04-27 17:37:02 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// RemoveMapping implements memmap.Mappable.RemoveMapping.
|
2018-12-12 21:09:10 +00:00
|
|
|
func (*SpecialMappable) RemoveMapping(context.Context, memmap.MappingSpace, usermem.AddrRange, uint64, bool) {
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// CopyMapping implements memmap.Mappable.CopyMapping.
|
2018-12-12 21:09:10 +00:00
|
|
|
func (*SpecialMappable) CopyMapping(context.Context, memmap.MappingSpace, usermem.AddrRange, usermem.AddrRange, uint64, bool) error {
|
2018-04-27 17:37:02 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Translate implements memmap.Mappable.Translate.
|
|
|
|
func (m *SpecialMappable) Translate(ctx context.Context, required, optional memmap.MappableRange, at usermem.AccessType) ([]memmap.Translation, error) {
|
|
|
|
var err error
|
|
|
|
if required.End > m.fr.Length() {
|
|
|
|
err = &memmap.BusError{syserror.EFAULT}
|
|
|
|
}
|
|
|
|
if source := optional.Intersect(memmap.MappableRange{0, m.fr.Length()}); source.Length() != 0 {
|
|
|
|
return []memmap.Translation{
|
|
|
|
{
|
|
|
|
Source: source,
|
2019-03-14 15:11:36 +00:00
|
|
|
File: m.mfp.MemoryFile(),
|
2018-04-27 17:37:02 +00:00
|
|
|
Offset: m.fr.Start + source.Start,
|
2019-03-25 19:41:36 +00:00
|
|
|
Perms: usermem.AnyAccess,
|
2018-04-27 17:37:02 +00:00
|
|
|
},
|
|
|
|
}, err
|
|
|
|
}
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// InvalidateUnsavable implements memmap.Mappable.InvalidateUnsavable.
|
|
|
|
func (m *SpecialMappable) InvalidateUnsavable(ctx context.Context) error {
|
2019-03-14 15:11:36 +00:00
|
|
|
// Since data is stored in pgalloc.MemoryFile, the contents of which are
|
|
|
|
// preserved across save/restore, we don't need to do anything.
|
2018-04-27 17:37:02 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-03-14 15:11:36 +00:00
|
|
|
// MemoryFileProvider returns the MemoryFileProvider whose MemoryFile stores
|
|
|
|
// the SpecialMappable's contents.
|
|
|
|
func (m *SpecialMappable) MemoryFileProvider() pgalloc.MemoryFileProvider {
|
|
|
|
return m.mfp
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|
|
|
|
|
2019-03-14 15:11:36 +00:00
|
|
|
// FileRange returns the offsets into MemoryFileProvider().MemoryFile() that
|
|
|
|
// store the SpecialMappable's contents.
|
2018-04-27 17:37:02 +00:00
|
|
|
func (m *SpecialMappable) FileRange() platform.FileRange {
|
|
|
|
return m.fr
|
|
|
|
}
|
|
|
|
|
|
|
|
// Length returns the length of the SpecialMappable.
|
|
|
|
func (m *SpecialMappable) Length() uint64 {
|
|
|
|
return m.fr.Length()
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewSharedAnonMappable returns a SpecialMappable that implements the
|
|
|
|
// semantics of mmap(MAP_SHARED|MAP_ANONYMOUS) and mappings of /dev/zero.
|
|
|
|
//
|
2019-04-29 21:03:04 +00:00
|
|
|
// TODO(jamieliu): The use of SpecialMappable is a lazy code reuse hack. Linux
|
2018-04-27 17:37:02 +00:00
|
|
|
// uses an ephemeral file created by mm/shmem.c:shmem_zero_setup(); we should
|
|
|
|
// do the same to get non-zero device and inode IDs.
|
2019-03-14 15:11:36 +00:00
|
|
|
func NewSharedAnonMappable(length uint64, mfp pgalloc.MemoryFileProvider) (*SpecialMappable, error) {
|
2018-09-10 20:23:49 +00:00
|
|
|
if length == 0 {
|
2018-04-27 17:37:02 +00:00
|
|
|
return nil, syserror.EINVAL
|
|
|
|
}
|
2018-09-10 20:23:49 +00:00
|
|
|
alignedLen, ok := usermem.Addr(length).RoundUp()
|
|
|
|
if !ok {
|
|
|
|
return nil, syserror.EINVAL
|
|
|
|
}
|
2019-03-14 15:11:36 +00:00
|
|
|
fr, err := mfp.MemoryFile().Allocate(uint64(alignedLen), usage.Anonymous)
|
2018-04-27 17:37:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2019-03-14 15:11:36 +00:00
|
|
|
return NewSpecialMappable("/dev/zero (deleted)", mfp, fr), nil
|
2018-04-27 17:37:02 +00:00
|
|
|
}
|