mirror of
https://github.com/hanzoai/visor.git
synced 2026-09-24 17:04:14 +00:00
Michael PrattandgVisor bot
06ddfa54e8
Go 1.17 is adding a new register-based calling convention [1] ("ABIInternal"),
which used is when calling between Go functions. Assembly functions are still
written using the old ABI ("ABI0"). That is, they still accept arguments on the
stack, and pass arguments to other functions on the stack. The call rules look
approximately like this:
1. Direct call from Go function to Go function: compiler emits direct
ABIInternal call.
2. Indirect call from Go function to Go function: compiler emits indirect
ABIInternal call.
3. Direct call from Go function to assembly function: compiler emits direct
ABI0 call.
4. Indirect call from Go function to assembly function: compiler emits indirect
ABIInternal call to ABI conversion wrapper function.
5. Direct or indirect call from assembly function to assembly function:
assembly/linker emits call to original ABI0 function.
6. Direct or indirect call from assembly function to Go function:
assembly/linker emits ABI0 call to ABI conversion wrapper function.
Case 4 is the interesting one here. Since the compiler can't know the ABI of an
indirect call, all indirect calls are made with ABIInternal. In order to
support indirect ABI0 assembly function calls, a wrapper is generated that
translates ABIInternal arguments to ABI0 arguments, calls the target function,
and then converts results back.
When the address of an ABI0 function is taken from Go code, it evaluates to the
address of this wrapper function rather than the target function so that later
indirect calls will work as expected.
This is normally fine, but gVisor does more than just call some of the assembly
functions we take the address of: either noting the start and end address for
future reference from a signal handler (safecopy), or copying the function text
to a new mapping (platforms).
Both of these fail with wrappers enabled (currently, this is Go tip with
GOEXPERIMENT=regabiwrappers) because these operations end up operating on the
wrapper instead of the target function.
We work around this issue by taking advantage of case 5: references to assembly
symbols from other assembly functions resolve directly to the desired target
symbol. Thus, rather than using reflect to get the address of a Go reference to
the functions, we create assembly stubs that return the address of the
function. This approach works just as well on current versions of Go, so the
change can be made immediately and doesn't require any build tags.
[1] https://go.googlesource.com/go/+/refs/heads/master/src/cmd/compile/abi-internal.md
PiperOrigin-RevId: 368505655
150 lines
3.8 KiB
ArmAsm
150 lines
3.8 KiB
ArmAsm
// 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.
|
|
|
|
#include "textflag.h"
|
|
|
|
// The signals handled by sigHandler.
|
|
#define SIGBUS 7
|
|
#define SIGSEGV 11
|
|
|
|
// Offsets to the registers in context->uc_mcontext.gregs[].
|
|
#define REG_R0 0xB8
|
|
#define REG_R1 0xC0
|
|
#define REG_PC 0x1B8
|
|
|
|
// Offset to the si_addr field of siginfo.
|
|
#define SI_CODE 0x08
|
|
#define SI_ADDR 0x10
|
|
|
|
// signalHandler is the signal handler for SIGSEGV and SIGBUS signals. It must
|
|
// not be set up as a handler to any other signals.
|
|
//
|
|
// If the instruction causing the signal is within a safecopy-protected
|
|
// function, the signal is handled such that execution resumes in the
|
|
// appropriate fault handling stub with R0 containing the faulting address and
|
|
// R1 containing the signal number. Otherwise control is transferred to the
|
|
// previously configured signal handler (savedSigSegvHandler or
|
|
// savedSigBusHandler).
|
|
//
|
|
// This function cannot be written in go because it runs whenever a signal is
|
|
// received by the thread (preempting whatever was running), which includes when
|
|
// garbage collector has stopped or isn't expecting any interactions (like
|
|
// barriers).
|
|
//
|
|
// The arguments are the following:
|
|
// R0 - The signal number.
|
|
// R1 - Pointer to siginfo_t structure.
|
|
// R2 - Pointer to ucontext structure.
|
|
TEXT ·signalHandler(SB),NOSPLIT,$0
|
|
// Check if the signal is from the kernel, si_code > 0 means a kernel signal.
|
|
MOVD SI_CODE(R1), R7
|
|
CMPW $0x0, R7
|
|
BLE original_handler
|
|
|
|
// Check if PC is within the area we care about.
|
|
MOVD REG_PC(R2), R7
|
|
MOVD ·memcpyBegin(SB), R8
|
|
CMP R8, R7
|
|
BLO not_memcpy
|
|
MOVD ·memcpyEnd(SB), R8
|
|
CMP R8, R7
|
|
BHS not_memcpy
|
|
|
|
// Modify the context such that execution will resume in the fault handler.
|
|
MOVD $handleMemcpyFault(SB), R7
|
|
B handle_fault
|
|
|
|
not_memcpy:
|
|
MOVD ·memclrBegin(SB), R8
|
|
CMP R8, R7
|
|
BLO not_memclr
|
|
MOVD ·memclrEnd(SB), R8
|
|
CMP R8, R7
|
|
BHS not_memclr
|
|
|
|
MOVD $handleMemclrFault(SB), R7
|
|
B handle_fault
|
|
|
|
not_memclr:
|
|
MOVD ·swapUint32Begin(SB), R8
|
|
CMP R8, R7
|
|
BLO not_swapuint32
|
|
MOVD ·swapUint32End(SB), R8
|
|
CMP R8, R7
|
|
BHS not_swapuint32
|
|
|
|
MOVD $handleSwapUint32Fault(SB), R7
|
|
B handle_fault
|
|
|
|
not_swapuint32:
|
|
MOVD ·swapUint64Begin(SB), R8
|
|
CMP R8, R7
|
|
BLO not_swapuint64
|
|
MOVD ·swapUint64End(SB), R8
|
|
CMP R8, R7
|
|
BHS not_swapuint64
|
|
|
|
MOVD $handleSwapUint64Fault(SB), R7
|
|
B handle_fault
|
|
|
|
not_swapuint64:
|
|
MOVD ·compareAndSwapUint32Begin(SB), R8
|
|
CMP R8, R7
|
|
BLO not_casuint32
|
|
MOVD ·compareAndSwapUint32End(SB), R8
|
|
CMP R8, R7
|
|
BHS not_casuint32
|
|
|
|
MOVD $handleCompareAndSwapUint32Fault(SB), R7
|
|
B handle_fault
|
|
|
|
not_casuint32:
|
|
MOVD ·loadUint32Begin(SB), R8
|
|
CMP R8, R7
|
|
BLO not_loaduint32
|
|
MOVD ·loadUint32End(SB), R8
|
|
CMP R8, R7
|
|
BHS not_loaduint32
|
|
|
|
MOVD $handleLoadUint32Fault(SB), R7
|
|
B handle_fault
|
|
|
|
not_loaduint32:
|
|
original_handler:
|
|
// Jump to the previous signal handler, which is likely the golang one.
|
|
MOVD ·savedSigBusHandler(SB), R7
|
|
MOVD ·savedSigSegVHandler(SB), R8
|
|
CMPW $SIGSEGV, R0
|
|
CSEL EQ, R8, R7, R7
|
|
B (R7)
|
|
|
|
handle_fault:
|
|
// Entered with the address of the fault handler in R7; store it in PC.
|
|
MOVD R7, REG_PC(R2)
|
|
|
|
// Store the faulting address in R0.
|
|
MOVD SI_ADDR(R1), R7
|
|
MOVD R7, REG_R0(R2)
|
|
|
|
// Store the signal number in R1.
|
|
MOVW R0, REG_R1(R2)
|
|
|
|
RET
|
|
|
|
// func addrOfSignalHandler() uintptr
|
|
TEXT ·addrOfSignalHandler(SB), $0-8
|
|
MOVD $·signalHandler(SB), R0
|
|
MOVD R0, ret+0(FP)
|
|
RET
|