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
|
// Copyright 2018 Google LLC
//
// 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 ptrace
import (
"reflect"
"syscall"
"unsafe"
"gvisor.googlesource.com/gvisor/pkg/sentry/platform/safecopy"
"gvisor.googlesource.com/gvisor/pkg/sentry/usermem"
)
// stub is defined in arch-specific assembly.
func stub()
// stubCall calls the stub at the given address with the given pid.
func stubCall(addr, pid uintptr)
// unsafeSlice returns a slice for the given address and length.
func unsafeSlice(addr uintptr, length int) (slice []byte) {
sh := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
sh.Data = addr
sh.Len = length
sh.Cap = length
return
}
// stubInit initializes the stub.
func stubInit() {
// Grab the existing stub.
stubBegin := reflect.ValueOf(stub).Pointer()
stubLen := int(safecopy.FindEndAddress(stubBegin) - stubBegin)
stubSlice := unsafeSlice(stubBegin, stubLen)
mapLen := uintptr(stubLen)
if offset := mapLen % usermem.PageSize; offset != 0 {
mapLen += usermem.PageSize - offset
}
for stubStart > 0 {
// Map the target address for the stub.
//
// We don't use FIXED here because we don't want to unmap
// something that may have been there already. We just walk
// down the address space until we find a place where the stub
// can be placed.
addr, _, errno := syscall.RawSyscall6(
syscall.SYS_MMAP,
stubStart,
mapLen,
syscall.PROT_WRITE|syscall.PROT_READ,
syscall.MAP_PRIVATE|syscall.MAP_ANONYMOUS,
0 /* fd */, 0 /* offset */)
if addr != stubStart || errno != 0 {
if addr != 0 {
// Unmap the region we've mapped accidentally.
syscall.RawSyscall(syscall.SYS_MUNMAP, addr, mapLen, 0)
}
// Attempt to begin at a lower address.
stubStart -= uintptr(usermem.PageSize)
continue
}
// Copy the stub to the address.
targetSlice := unsafeSlice(addr, stubLen)
copy(targetSlice, stubSlice)
// Make the stub executable.
if _, _, errno := syscall.RawSyscall(
syscall.SYS_MPROTECT,
stubStart,
mapLen,
syscall.PROT_EXEC|syscall.PROT_READ); errno != 0 {
panic("mprotect failed: " + errno.Error())
}
// Set the end.
stubEnd = stubStart + mapLen
return
}
// This will happen only if we exhaust the entire address
// space, and it will take a long, long time.
panic("failed to map stub")
}
|
