mirror of
https://github.com/netbirdio/gvisor.git
synced 2026-05-22 17:12:49 -07:00
Jamie Liu
3f1642e4bc
ring0.Save/LoadFloatingPoint() are only usable if the caller can ensure that Go will not clobber floating point registers before/after calling them respectively. Due to regabig in Go 1.17, this is no longer the case; regabig (among other things) maintains a zeroed XMM15 during ABIInternal execution, including by zeroing it after ABI0-to-ABIInternal transitions. In ring0.sysenter/exception, this happens in ring0.kernelSyscall/kernelException.abi0 respectively; in ring0.CPU.SwitchToUser, this happens after returning from ring0.sysret/iret.abi0. Delete these functions and do floating point save/load in assembly. While arm64 doesn't appear to be immediately affected (so this CL permits us to resume usage of Go 1.17), its use of Save/LoadFloatingPoint() still seems to be incorrect for the same fundamental reason (Go code can't sanely assume what registers the Go compiler will or won't use) and should be fixed eventually. PiperOrigin-RevId: 401895658
96 lines
2.3 KiB
Go
96 lines
2.3 KiB
Go
// 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 ring0
|
|
|
|
import (
|
|
"gvisor.dev/gvisor/pkg/sentry/arch/fpu"
|
|
)
|
|
|
|
// Init initializes a new kernel.
|
|
//
|
|
//go:nosplit
|
|
func (k *Kernel) Init(maxCPUs int) {
|
|
k.init(maxCPUs)
|
|
}
|
|
|
|
// Halt halts execution.
|
|
func Halt()
|
|
|
|
// defaultHooks implements hooks.
|
|
type defaultHooks struct{}
|
|
|
|
// KernelSyscall implements Hooks.KernelSyscall.
|
|
//
|
|
// +checkescape:all
|
|
//
|
|
//go:nosplit
|
|
func (defaultHooks) KernelSyscall() {
|
|
Halt()
|
|
}
|
|
|
|
// KernelException implements Hooks.KernelException.
|
|
//
|
|
// +checkescape:all
|
|
//
|
|
//go:nosplit
|
|
func (defaultHooks) KernelException(Vector) {
|
|
Halt()
|
|
}
|
|
|
|
// kernelSyscall is a trampoline.
|
|
//
|
|
// When in amd64, it is called with %rip on the upper half, so it can
|
|
// NOT access to any global data which is not mapped on upper and must
|
|
// call to function pointers or interfaces to switch to the lower half
|
|
// so that callee can access to global data.
|
|
//
|
|
// +checkescape:hard,stack
|
|
//
|
|
//go:nosplit
|
|
func kernelSyscall(c *CPU) {
|
|
c.hooks.KernelSyscall()
|
|
}
|
|
|
|
// kernelException is a trampoline.
|
|
//
|
|
// When in amd64, it is called with %rip on the upper half, so it can
|
|
// NOT access to any global data which is not mapped on upper and must
|
|
// call to function pointers or interfaces to switch to the lower half
|
|
// so that callee can access to global data.
|
|
//
|
|
// +checkescape:hard,stack
|
|
//
|
|
//go:nosplit
|
|
func kernelException(c *CPU, vector Vector) {
|
|
c.hooks.KernelException(vector)
|
|
}
|
|
|
|
// Init initializes a new CPU.
|
|
//
|
|
// Init allows embedding in other objects.
|
|
func (c *CPU) Init(k *Kernel, cpuID int, hooks Hooks) {
|
|
c.self = c // Set self reference.
|
|
c.kernel = k // Set kernel reference.
|
|
c.init(cpuID) // Perform architectural init.
|
|
c.floatingPointState = fpu.NewState()
|
|
|
|
// Require hooks.
|
|
if hooks != nil {
|
|
c.hooks = hooks
|
|
} else {
|
|
c.hooks = defaultHooks{}
|
|
}
|
|
}
|