mirror of
https://github.com/golang/go
synced 2024-11-19 14:54:43 -07:00
eff2b2620d
Currently, threads created by the runtime exist until the whole program exits. For #14592 and #20395, we want to be able to exit and clean up threads created by the runtime. This commit implements that mechanism. The main difficulty is how to clean up the g0 stack. In cgo mode and on Solaris and Windows where the OS manages thread stacks, we simply arrange to return from mstart and let the system clean up the thread. If the runtime allocated the g0 stack, then we use a new exitThread syscall wrapper that arranges to clear a flag in the M once the stack can safely be reaped and call the thread termination syscall. exitThread is based on the existing exit1 wrapper, which was always meant to terminate the calling thread. However, exit1 has never been used since it was introduced 9 years ago, so it was broken on several platforms. exitThread also has the additional complication of having to flag that the stack is unused, which requires some tricks on platforms that use the stack for syscalls. This still leaves the problem of how to reap the unused g0 stacks. For this, we move the M from allm to a new freem list as part of the M exiting. Later, allocm scans the freem list, finds Ms that are marked as done with their stack, removes these from the list and frees their g0 stacks. This also allows these Ms to be garbage collected. This CL does not yet use any of this functionality. Follow-up CLs will. Likewise, there are no new tests in this CL because we'll need follow-up functionality to test it. Change-Id: Ic851ee74227b6d39c6fc1219fc71b45d3004bc63 Reviewed-on: https://go-review.googlesource.com/46037 Run-TryBot: Austin Clements <austin@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
379 lines
8.4 KiB
ArmAsm
379 lines
8.4 KiB
ArmAsm
// Copyright 2013 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
#include "go_asm.h"
|
|
#include "go_tls.h"
|
|
#include "textflag.h"
|
|
#include "syscall_nacl.h"
|
|
|
|
#define NACL_SYSCALL(code) \
|
|
MOVL $(0x10000 + ((code)<<5)), AX; CALL AX
|
|
|
|
TEXT runtime·exit(SB),NOSPLIT,$4
|
|
MOVL code+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_exit)
|
|
JMP 0(PC)
|
|
|
|
// func exitThread(wait *uint32)
|
|
TEXT runtime·exitThread(SB),NOSPLIT,$4-4
|
|
MOVL wait+0(FP), AX
|
|
// SYS_thread_exit will clear *wait when the stack is free.
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_thread_exit)
|
|
JMP 0(PC)
|
|
|
|
TEXT runtime·open(SB),NOSPLIT,$12
|
|
MOVL name+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL mode+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
MOVL perm+8(FP), AX
|
|
MOVL AX, 8(SP)
|
|
NACL_SYSCALL(SYS_open)
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT runtime·closefd(SB),NOSPLIT,$4
|
|
MOVL fd+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_close)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·read(SB),NOSPLIT,$12
|
|
MOVL fd+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL p+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
MOVL n+8(FP), AX
|
|
MOVL AX, 8(SP)
|
|
NACL_SYSCALL(SYS_read)
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT syscall·naclWrite(SB), NOSPLIT, $16-16
|
|
MOVL arg1+0(FP), DI
|
|
MOVL arg2+4(FP), SI
|
|
MOVL arg3+8(FP), DX
|
|
MOVL DI, 0(SP)
|
|
MOVL SI, 4(SP)
|
|
MOVL DX, 8(SP)
|
|
CALL runtime·write(SB)
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·write(SB),NOSPLIT,$12
|
|
MOVL fd+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL p+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
MOVL n+8(FP), AX
|
|
MOVL AX, 8(SP)
|
|
NACL_SYSCALL(SYS_write)
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_exception_stack(SB),NOSPLIT,$8
|
|
MOVL p+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL size+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
NACL_SYSCALL(SYS_exception_stack)
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_exception_handler(SB),NOSPLIT,$8
|
|
MOVL fn+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL arg+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
NACL_SYSCALL(SYS_exception_handler)
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_sem_create(SB),NOSPLIT,$4
|
|
MOVL flag+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_sem_create)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_sem_wait(SB),NOSPLIT,$4
|
|
MOVL sem+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_sem_wait)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_sem_post(SB),NOSPLIT,$4
|
|
MOVL sem+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_sem_post)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_mutex_create(SB),NOSPLIT,$4
|
|
MOVL flag+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_mutex_create)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_mutex_lock(SB),NOSPLIT,$4
|
|
MOVL mutex+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_mutex_lock)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_mutex_trylock(SB),NOSPLIT,$4
|
|
MOVL mutex+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_mutex_trylock)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_mutex_unlock(SB),NOSPLIT,$4
|
|
MOVL mutex+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_mutex_unlock)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_cond_create(SB),NOSPLIT,$4
|
|
MOVL flag+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_cond_create)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_cond_wait(SB),NOSPLIT,$8
|
|
MOVL cond+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL n+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
NACL_SYSCALL(SYS_cond_wait)
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_cond_signal(SB),NOSPLIT,$4
|
|
MOVL cond+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_cond_signal)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_cond_broadcast(SB),NOSPLIT,$4
|
|
MOVL cond+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
NACL_SYSCALL(SYS_cond_broadcast)
|
|
MOVL AX, ret+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_cond_timed_wait_abs(SB),NOSPLIT,$12
|
|
MOVL cond+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL lock+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
MOVL ts+8(FP), AX
|
|
MOVL AX, 8(SP)
|
|
NACL_SYSCALL(SYS_cond_timed_wait_abs)
|
|
MOVL AX, ret+12(FP)
|
|
RET
|
|
|
|
TEXT runtime·nacl_thread_create(SB),NOSPLIT,$16
|
|
MOVL fn+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL stk+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
MOVL tls+8(FP), AX
|
|
MOVL AX, 8(SP)
|
|
MOVL xx+12(FP), AX
|
|
MOVL AX, 12(SP)
|
|
NACL_SYSCALL(SYS_thread_create)
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·mstart_nacl(SB),NOSPLIT,$0
|
|
JMP runtime·mstart(SB)
|
|
|
|
TEXT runtime·nacl_nanosleep(SB),NOSPLIT,$8
|
|
MOVL ts+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL extra+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
NACL_SYSCALL(SYS_nanosleep)
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·osyield(SB),NOSPLIT,$0
|
|
NACL_SYSCALL(SYS_sched_yield)
|
|
RET
|
|
|
|
TEXT runtime·mmap(SB),NOSPLIT,$32
|
|
MOVL addr+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL n+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
MOVL prot+8(FP), AX
|
|
MOVL AX, 8(SP)
|
|
MOVL flags+12(FP), AX
|
|
MOVL AX, 12(SP)
|
|
MOVL fd+16(FP), AX
|
|
MOVL AX, 16(SP)
|
|
MOVL off+20(FP), AX
|
|
MOVL AX, 24(SP)
|
|
MOVL $0, 28(SP)
|
|
LEAL 24(SP), AX
|
|
MOVL AX, 20(SP)
|
|
NACL_SYSCALL(SYS_mmap)
|
|
CMPL AX, $-4095
|
|
JNA 2(PC)
|
|
NEGL AX
|
|
MOVL AX, ret+24(FP)
|
|
RET
|
|
|
|
TEXT runtime·walltime(SB),NOSPLIT,$20
|
|
MOVL $0, 0(SP) // real time clock
|
|
LEAL 8(SP), AX
|
|
MOVL AX, 4(SP) // timespec
|
|
NACL_SYSCALL(SYS_clock_gettime)
|
|
MOVL 8(SP), AX // low 32 sec
|
|
MOVL 12(SP), CX // high 32 sec
|
|
MOVL 16(SP), BX // nsec
|
|
|
|
// sec is in AX, nsec in BX
|
|
MOVL AX, sec_lo+0(FP)
|
|
MOVL CX, sec_hi+4(FP)
|
|
MOVL BX, nsec+8(FP)
|
|
RET
|
|
|
|
TEXT syscall·now(SB),NOSPLIT,$0
|
|
JMP runtime·walltime(SB)
|
|
|
|
TEXT runtime·nacl_clock_gettime(SB),NOSPLIT,$8
|
|
MOVL arg1+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL arg2+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
NACL_SYSCALL(SYS_clock_gettime)
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·nanotime(SB),NOSPLIT,$20
|
|
MOVL $0, 0(SP) // real time clock
|
|
LEAL 8(SP), AX
|
|
MOVL AX, 4(SP) // timespec
|
|
NACL_SYSCALL(SYS_clock_gettime)
|
|
MOVL 8(SP), AX // low 32 sec
|
|
MOVL 16(SP), BX // nsec
|
|
|
|
// sec is in AX, nsec in BX
|
|
// convert to DX:AX nsec
|
|
MOVL $1000000000, CX
|
|
MULL CX
|
|
ADDL BX, AX
|
|
ADCL $0, DX
|
|
|
|
MOVL AX, ret_lo+0(FP)
|
|
MOVL DX, ret_hi+4(FP)
|
|
RET
|
|
|
|
TEXT runtime·setldt(SB),NOSPLIT,$8
|
|
MOVL addr+4(FP), BX // aka base
|
|
ADDL $0x8, BX
|
|
MOVL BX, 0(SP)
|
|
NACL_SYSCALL(SYS_tls_init)
|
|
RET
|
|
|
|
TEXT runtime·sigtramp(SB),NOSPLIT,$0
|
|
get_tls(CX)
|
|
|
|
// check that g exists
|
|
MOVL g(CX), DI
|
|
CMPL DI, $0
|
|
JNE 6(PC)
|
|
MOVL $11, BX
|
|
MOVL $0, 0(SP)
|
|
MOVL $runtime·badsignal(SB), AX
|
|
CALL AX
|
|
JMP ret
|
|
|
|
// save g
|
|
MOVL DI, 20(SP)
|
|
|
|
// g = m->gsignal
|
|
MOVL g_m(DI), BX
|
|
MOVL m_gsignal(BX), BX
|
|
MOVL BX, g(CX)
|
|
|
|
// copy arguments for sighandler
|
|
MOVL $11, 0(SP) // signal
|
|
MOVL $0, 4(SP) // siginfo
|
|
LEAL ctxt+4(FP), AX
|
|
MOVL AX, 8(SP) // context
|
|
MOVL DI, 12(SP) // g
|
|
|
|
CALL runtime·sighandler(SB)
|
|
|
|
// restore g
|
|
get_tls(CX)
|
|
MOVL 20(SP), BX
|
|
MOVL BX, g(CX)
|
|
|
|
ret:
|
|
// Enable exceptions again.
|
|
NACL_SYSCALL(SYS_exception_clear_flag)
|
|
|
|
// NaCl has abdicated its traditional operating system responsibility
|
|
// and declined to implement 'sigreturn'. Instead the only way to return
|
|
// to the execution of our program is to restore the registers ourselves.
|
|
// Unfortunately, that is impossible to do with strict fidelity, because
|
|
// there is no way to do the final update of PC that ends the sequence
|
|
// without either (1) jumping to a register, in which case the register ends
|
|
// holding the PC value instead of its intended value or (2) storing the PC
|
|
// on the stack and using RET, which imposes the requirement that SP is
|
|
// valid and that is okay to smash the word below it. The second would
|
|
// normally be the lesser of the two evils, except that on NaCl, the linker
|
|
// must rewrite RET into "POP reg; AND $~31, reg; JMP reg", so either way
|
|
// we are going to lose a register as a result of the incoming signal.
|
|
// Similarly, there is no way to restore EFLAGS; the usual way is to use
|
|
// POPFL, but NaCl rejects that instruction. We could inspect the bits and
|
|
// execute a sequence of instructions designed to recreate those flag
|
|
// settings, but that's a lot of work.
|
|
//
|
|
// Thankfully, Go's signal handlers never try to return directly to the
|
|
// executing code, so all the registers and EFLAGS are dead and can be
|
|
// smashed. The only registers that matter are the ones that are setting
|
|
// up for the simulated call that the signal handler has created.
|
|
// Today those registers are just PC and SP, but in case additional registers
|
|
// are relevant in the future (for example DX is the Go func context register)
|
|
// we restore as many registers as possible.
|
|
//
|
|
// We smash BP, because that's what the linker smashes during RET.
|
|
//
|
|
LEAL ctxt+4(FP), BP
|
|
ADDL $64, BP
|
|
MOVL 0(BP), AX
|
|
MOVL 4(BP), CX
|
|
MOVL 8(BP), DX
|
|
MOVL 12(BP), BX
|
|
MOVL 16(BP), SP
|
|
// 20(BP) is saved BP, never to be seen again
|
|
MOVL 24(BP), SI
|
|
MOVL 28(BP), DI
|
|
// 36(BP) is saved EFLAGS, never to be seen again
|
|
MOVL 32(BP), BP // saved PC
|
|
JMP BP
|
|
|
|
// func getRandomData([]byte)
|
|
TEXT runtime·getRandomData(SB),NOSPLIT,$8-12
|
|
MOVL arg_base+0(FP), AX
|
|
MOVL AX, 0(SP)
|
|
MOVL arg_len+4(FP), AX
|
|
MOVL AX, 4(SP)
|
|
NACL_SYSCALL(SYS_get_random_bytes)
|
|
RET
|