mirror of
https://github.com/golang/go
synced 2024-10-05 15:51:22 -06:00
4110271501
Delaying the runtime.throw until here will print more information. In particular it will print the signal and code values, which means it will show the fault address. The canpanic checks were added recently, in CL 75320043. They were just not added in exactly the right place. LGTM=iant R=dvyukov, iant CC=golang-codereviews https://golang.org/cl/83980043
529 lines
12 KiB
C
529 lines
12 KiB
C
// Copyright 2009 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 "runtime.h"
|
|
#include "defs_GOOS_GOARCH.h"
|
|
#include "os_GOOS.h"
|
|
#include "signal_unix.h"
|
|
#include "stack.h"
|
|
#include "../../cmd/ld/textflag.h"
|
|
|
|
extern SigTab runtime·sigtab[];
|
|
|
|
static Sigset sigset_none;
|
|
static Sigset sigset_all = ~(Sigset)0;
|
|
|
|
static void
|
|
unimplemented(int8 *name)
|
|
{
|
|
runtime·prints(name);
|
|
runtime·prints(" not implemented\n");
|
|
*(int32*)1231 = 1231;
|
|
}
|
|
|
|
void
|
|
runtime·semawakeup(M *mp)
|
|
{
|
|
runtime·mach_semrelease(mp->waitsema);
|
|
}
|
|
|
|
uintptr
|
|
runtime·semacreate(void)
|
|
{
|
|
return runtime·mach_semcreate();
|
|
}
|
|
|
|
// BSD interface for threading.
|
|
void
|
|
runtime·osinit(void)
|
|
{
|
|
// bsdthread_register delayed until end of goenvs so that we
|
|
// can look at the environment first.
|
|
|
|
// Use sysctl to fetch hw.ncpu.
|
|
uint32 mib[2];
|
|
uint32 out;
|
|
int32 ret;
|
|
uintptr nout;
|
|
|
|
mib[0] = 6;
|
|
mib[1] = 3;
|
|
nout = sizeof out;
|
|
out = 0;
|
|
ret = runtime·sysctl(mib, 2, (byte*)&out, &nout, nil, 0);
|
|
if(ret >= 0)
|
|
runtime·ncpu = out;
|
|
}
|
|
|
|
void
|
|
runtime·get_random_data(byte **rnd, int32 *rnd_len)
|
|
{
|
|
static byte urandom_data[HashRandomBytes];
|
|
int32 fd;
|
|
fd = runtime·open("/dev/urandom", 0 /* O_RDONLY */, 0);
|
|
if(runtime·read(fd, urandom_data, HashRandomBytes) == HashRandomBytes) {
|
|
*rnd = urandom_data;
|
|
*rnd_len = HashRandomBytes;
|
|
} else {
|
|
*rnd = nil;
|
|
*rnd_len = 0;
|
|
}
|
|
runtime·close(fd);
|
|
}
|
|
|
|
void
|
|
runtime·goenvs(void)
|
|
{
|
|
runtime·goenvs_unix();
|
|
|
|
// Register our thread-creation callback (see sys_darwin_{amd64,386}.s)
|
|
// but only if we're not using cgo. If we are using cgo we need
|
|
// to let the C pthread library install its own thread-creation callback.
|
|
if(!runtime·iscgo) {
|
|
if(runtime·bsdthread_register() != 0) {
|
|
if(runtime·getenv("DYLD_INSERT_LIBRARIES"))
|
|
runtime·throw("runtime: bsdthread_register error (unset DYLD_INSERT_LIBRARIES)");
|
|
runtime·throw("runtime: bsdthread_register error");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
runtime·newosproc(M *mp, void *stk)
|
|
{
|
|
int32 errno;
|
|
Sigset oset;
|
|
|
|
mp->tls[0] = mp->id; // so 386 asm can find it
|
|
if(0){
|
|
runtime·printf("newosproc stk=%p m=%p g=%p id=%d/%d ostk=%p\n",
|
|
stk, mp, mp->g0, mp->id, (int32)mp->tls[0], &mp);
|
|
}
|
|
|
|
runtime·sigprocmask(SIG_SETMASK, &sigset_all, &oset);
|
|
errno = runtime·bsdthread_create(stk, mp, mp->g0, runtime·mstart);
|
|
runtime·sigprocmask(SIG_SETMASK, &oset, nil);
|
|
|
|
if(errno < 0) {
|
|
runtime·printf("runtime: failed to create new OS thread (have %d already; errno=%d)\n", runtime·mcount(), -errno);
|
|
runtime·throw("runtime.newosproc");
|
|
}
|
|
}
|
|
|
|
// Called to initialize a new m (including the bootstrap m).
|
|
// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
|
|
void
|
|
runtime·mpreinit(M *mp)
|
|
{
|
|
mp->gsignal = runtime·malg(32*1024); // OS X wants >=8K, Linux >=2K
|
|
}
|
|
|
|
// Called to initialize a new m (including the bootstrap m).
|
|
// Called on the new thread, can not allocate memory.
|
|
void
|
|
runtime·minit(void)
|
|
{
|
|
// Initialize signal handling.
|
|
runtime·signalstack((byte*)m->gsignal->stackguard - StackGuard, 32*1024);
|
|
|
|
runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
|
|
}
|
|
|
|
// Called from dropm to undo the effect of an minit.
|
|
void
|
|
runtime·unminit(void)
|
|
{
|
|
runtime·signalstack(nil, 0);
|
|
}
|
|
|
|
// Mach IPC, to get at semaphores
|
|
// Definitions are in /usr/include/mach on a Mac.
|
|
|
|
#pragma textflag NOSPLIT
|
|
static void
|
|
macherror(int32 r, int8 *fn)
|
|
{
|
|
runtime·prints("mach error ");
|
|
runtime·prints(fn);
|
|
runtime·prints(": ");
|
|
runtime·printint(r);
|
|
runtime·prints("\n");
|
|
runtime·throw("mach error");
|
|
}
|
|
|
|
enum
|
|
{
|
|
DebugMach = 0
|
|
};
|
|
|
|
static MachNDR zerondr;
|
|
|
|
#define MACH_MSGH_BITS(a, b) ((a) | ((b)<<8))
|
|
|
|
static int32
|
|
mach_msg(MachHeader *h,
|
|
int32 op,
|
|
uint32 send_size,
|
|
uint32 rcv_size,
|
|
uint32 rcv_name,
|
|
uint32 timeout,
|
|
uint32 notify)
|
|
{
|
|
// TODO: Loop on interrupt.
|
|
return runtime·mach_msg_trap(h, op, send_size, rcv_size, rcv_name, timeout, notify);
|
|
}
|
|
|
|
// Mach RPC (MIG)
|
|
|
|
enum
|
|
{
|
|
MinMachMsg = 48,
|
|
Reply = 100,
|
|
};
|
|
|
|
#pragma pack on
|
|
typedef struct CodeMsg CodeMsg;
|
|
struct CodeMsg
|
|
{
|
|
MachHeader h;
|
|
MachNDR NDR;
|
|
int32 code;
|
|
};
|
|
#pragma pack off
|
|
|
|
static int32
|
|
machcall(MachHeader *h, int32 maxsize, int32 rxsize)
|
|
{
|
|
uint32 *p;
|
|
int32 i, ret, id;
|
|
uint32 port;
|
|
CodeMsg *c;
|
|
|
|
if((port = m->machport) == 0){
|
|
port = runtime·mach_reply_port();
|
|
m->machport = port;
|
|
}
|
|
|
|
h->msgh_bits |= MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE);
|
|
h->msgh_local_port = port;
|
|
h->msgh_reserved = 0;
|
|
id = h->msgh_id;
|
|
|
|
if(DebugMach){
|
|
p = (uint32*)h;
|
|
runtime·prints("send:\t");
|
|
for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
|
|
runtime·prints(" ");
|
|
runtime·printpointer((void*)p[i]);
|
|
if(i%8 == 7)
|
|
runtime·prints("\n\t");
|
|
}
|
|
if(i%8)
|
|
runtime·prints("\n");
|
|
}
|
|
|
|
ret = mach_msg(h, MACH_SEND_MSG|MACH_RCV_MSG,
|
|
h->msgh_size, maxsize, port, 0, 0);
|
|
if(ret != 0){
|
|
if(DebugMach){
|
|
runtime·prints("mach_msg error ");
|
|
runtime·printint(ret);
|
|
runtime·prints("\n");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
if(DebugMach){
|
|
p = (uint32*)h;
|
|
runtime·prints("recv:\t");
|
|
for(i=0; i<h->msgh_size/sizeof(p[0]); i++){
|
|
runtime·prints(" ");
|
|
runtime·printpointer((void*)p[i]);
|
|
if(i%8 == 7)
|
|
runtime·prints("\n\t");
|
|
}
|
|
if(i%8)
|
|
runtime·prints("\n");
|
|
}
|
|
|
|
if(h->msgh_id != id+Reply){
|
|
if(DebugMach){
|
|
runtime·prints("mach_msg reply id mismatch ");
|
|
runtime·printint(h->msgh_id);
|
|
runtime·prints(" != ");
|
|
runtime·printint(id+Reply);
|
|
runtime·prints("\n");
|
|
}
|
|
return -303; // MIG_REPLY_MISMATCH
|
|
}
|
|
|
|
// Look for a response giving the return value.
|
|
// Any call can send this back with an error,
|
|
// and some calls only have return values so they
|
|
// send it back on success too. I don't quite see how
|
|
// you know it's one of these and not the full response
|
|
// format, so just look if the message is right.
|
|
c = (CodeMsg*)h;
|
|
if(h->msgh_size == sizeof(CodeMsg)
|
|
&& !(h->msgh_bits & MACH_MSGH_BITS_COMPLEX)){
|
|
if(DebugMach){
|
|
runtime·prints("mig result ");
|
|
runtime·printint(c->code);
|
|
runtime·prints("\n");
|
|
}
|
|
return c->code;
|
|
}
|
|
|
|
if(h->msgh_size != rxsize){
|
|
if(DebugMach){
|
|
runtime·prints("mach_msg reply size mismatch ");
|
|
runtime·printint(h->msgh_size);
|
|
runtime·prints(" != ");
|
|
runtime·printint(rxsize);
|
|
runtime·prints("\n");
|
|
}
|
|
return -307; // MIG_ARRAY_TOO_LARGE
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Semaphores!
|
|
|
|
enum
|
|
{
|
|
Tmach_semcreate = 3418,
|
|
Rmach_semcreate = Tmach_semcreate + Reply,
|
|
|
|
Tmach_semdestroy = 3419,
|
|
Rmach_semdestroy = Tmach_semdestroy + Reply,
|
|
|
|
// Mach calls that get interrupted by Unix signals
|
|
// return this error code. We retry them.
|
|
KERN_ABORTED = 14,
|
|
KERN_OPERATION_TIMED_OUT = 49,
|
|
};
|
|
|
|
typedef struct Tmach_semcreateMsg Tmach_semcreateMsg;
|
|
typedef struct Rmach_semcreateMsg Rmach_semcreateMsg;
|
|
typedef struct Tmach_semdestroyMsg Tmach_semdestroyMsg;
|
|
// Rmach_semdestroyMsg = CodeMsg
|
|
|
|
#pragma pack on
|
|
struct Tmach_semcreateMsg
|
|
{
|
|
MachHeader h;
|
|
MachNDR ndr;
|
|
int32 policy;
|
|
int32 value;
|
|
};
|
|
|
|
struct Rmach_semcreateMsg
|
|
{
|
|
MachHeader h;
|
|
MachBody body;
|
|
MachPort semaphore;
|
|
};
|
|
|
|
struct Tmach_semdestroyMsg
|
|
{
|
|
MachHeader h;
|
|
MachBody body;
|
|
MachPort semaphore;
|
|
};
|
|
#pragma pack off
|
|
|
|
uint32
|
|
runtime·mach_semcreate(void)
|
|
{
|
|
union {
|
|
Tmach_semcreateMsg tx;
|
|
Rmach_semcreateMsg rx;
|
|
uint8 pad[MinMachMsg];
|
|
} m;
|
|
int32 r;
|
|
|
|
m.tx.h.msgh_bits = 0;
|
|
m.tx.h.msgh_size = sizeof(m.tx);
|
|
m.tx.h.msgh_remote_port = runtime·mach_task_self();
|
|
m.tx.h.msgh_id = Tmach_semcreate;
|
|
m.tx.ndr = zerondr;
|
|
|
|
m.tx.policy = 0; // 0 = SYNC_POLICY_FIFO
|
|
m.tx.value = 0;
|
|
|
|
while((r = machcall(&m.tx.h, sizeof m, sizeof(m.rx))) != 0){
|
|
if(r == KERN_ABORTED) // interrupted
|
|
continue;
|
|
macherror(r, "semaphore_create");
|
|
}
|
|
if(m.rx.body.msgh_descriptor_count != 1)
|
|
unimplemented("mach_semcreate desc count");
|
|
return m.rx.semaphore.name;
|
|
}
|
|
|
|
void
|
|
runtime·mach_semdestroy(uint32 sem)
|
|
{
|
|
union {
|
|
Tmach_semdestroyMsg tx;
|
|
uint8 pad[MinMachMsg];
|
|
} m;
|
|
int32 r;
|
|
|
|
m.tx.h.msgh_bits = MACH_MSGH_BITS_COMPLEX;
|
|
m.tx.h.msgh_size = sizeof(m.tx);
|
|
m.tx.h.msgh_remote_port = runtime·mach_task_self();
|
|
m.tx.h.msgh_id = Tmach_semdestroy;
|
|
m.tx.body.msgh_descriptor_count = 1;
|
|
m.tx.semaphore.name = sem;
|
|
m.tx.semaphore.disposition = MACH_MSG_TYPE_MOVE_SEND;
|
|
m.tx.semaphore.type = 0;
|
|
|
|
while((r = machcall(&m.tx.h, sizeof m, 0)) != 0){
|
|
if(r == KERN_ABORTED) // interrupted
|
|
continue;
|
|
macherror(r, "semaphore_destroy");
|
|
}
|
|
}
|
|
|
|
// The other calls have simple system call traps in sys_darwin_{amd64,386}.s
|
|
int32 runtime·mach_semaphore_wait(uint32 sema);
|
|
int32 runtime·mach_semaphore_timedwait(uint32 sema, uint32 sec, uint32 nsec);
|
|
int32 runtime·mach_semaphore_signal(uint32 sema);
|
|
int32 runtime·mach_semaphore_signal_all(uint32 sema);
|
|
|
|
#pragma textflag NOSPLIT
|
|
int32
|
|
runtime·semasleep(int64 ns)
|
|
{
|
|
int32 r, secs, nsecs;
|
|
|
|
if(ns >= 0) {
|
|
secs = runtime·timediv(ns, 1000000000, &nsecs);
|
|
r = runtime·mach_semaphore_timedwait(m->waitsema, secs, nsecs);
|
|
if(r == KERN_ABORTED || r == KERN_OPERATION_TIMED_OUT)
|
|
return -1;
|
|
if(r != 0)
|
|
macherror(r, "semaphore_wait");
|
|
return 0;
|
|
}
|
|
while((r = runtime·mach_semaphore_wait(m->waitsema)) != 0) {
|
|
if(r == KERN_ABORTED) // interrupted
|
|
continue;
|
|
macherror(r, "semaphore_wait");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
runtime·mach_semrelease(uint32 sem)
|
|
{
|
|
int32 r;
|
|
|
|
while((r = runtime·mach_semaphore_signal(sem)) != 0) {
|
|
if(r == KERN_ABORTED) // interrupted
|
|
continue;
|
|
macherror(r, "semaphore_signal");
|
|
}
|
|
}
|
|
|
|
void
|
|
runtime·sigpanic(void)
|
|
{
|
|
if(!runtime·canpanic(g))
|
|
runtime·throw("unexpected signal during runtime execution");
|
|
|
|
switch(g->sig) {
|
|
case SIGBUS:
|
|
if(g->sigcode0 == BUS_ADRERR && g->sigcode1 < 0x1000 || g->paniconfault) {
|
|
if(g->sigpc == 0)
|
|
runtime·panicstring("call of nil func value");
|
|
runtime·panicstring("invalid memory address or nil pointer dereference");
|
|
}
|
|
runtime·printf("unexpected fault address %p\n", g->sigcode1);
|
|
runtime·throw("fault");
|
|
case SIGSEGV:
|
|
if((g->sigcode0 == 0 || g->sigcode0 == SEGV_MAPERR || g->sigcode0 == SEGV_ACCERR) && g->sigcode1 < 0x1000 || g->paniconfault) {
|
|
if(g->sigpc == 0)
|
|
runtime·panicstring("call of nil func value");
|
|
runtime·panicstring("invalid memory address or nil pointer dereference");
|
|
}
|
|
runtime·printf("unexpected fault address %p\n", g->sigcode1);
|
|
runtime·throw("fault");
|
|
case SIGFPE:
|
|
switch(g->sigcode0) {
|
|
case FPE_INTDIV:
|
|
runtime·panicstring("integer divide by zero");
|
|
case FPE_INTOVF:
|
|
runtime·panicstring("integer overflow");
|
|
}
|
|
runtime·panicstring("floating point error");
|
|
}
|
|
runtime·panicstring(runtime·sigtab[g->sig].name);
|
|
}
|
|
|
|
#pragma textflag NOSPLIT
|
|
void
|
|
runtime·osyield(void)
|
|
{
|
|
runtime·usleep(1);
|
|
}
|
|
|
|
uintptr
|
|
runtime·memlimit(void)
|
|
{
|
|
// NOTE(rsc): Could use getrlimit here,
|
|
// like on FreeBSD or Linux, but Darwin doesn't enforce
|
|
// ulimit -v, so it's unclear why we'd try to stay within
|
|
// the limit.
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
runtime·setsig(int32 i, GoSighandler *fn, bool restart)
|
|
{
|
|
Sigaction sa;
|
|
|
|
runtime·memclr((byte*)&sa, sizeof sa);
|
|
sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
|
|
if(restart)
|
|
sa.sa_flags |= SA_RESTART;
|
|
sa.sa_mask = ~(uintptr)0;
|
|
sa.sa_tramp = (void*)runtime·sigtramp; // runtime·sigtramp's job is to call into real handler
|
|
*(uintptr*)sa.__sigaction_u = (uintptr)fn;
|
|
runtime·sigaction(i, &sa, nil);
|
|
}
|
|
|
|
GoSighandler*
|
|
runtime·getsig(int32 i)
|
|
{
|
|
Sigaction sa;
|
|
|
|
runtime·memclr((byte*)&sa, sizeof sa);
|
|
runtime·sigaction(i, nil, &sa);
|
|
return *(void**)sa.__sigaction_u;
|
|
}
|
|
|
|
void
|
|
runtime·signalstack(byte *p, int32 n)
|
|
{
|
|
StackT st;
|
|
|
|
st.ss_sp = (void*)p;
|
|
st.ss_size = n;
|
|
st.ss_flags = 0;
|
|
if(p == nil)
|
|
st.ss_flags = SS_DISABLE;
|
|
runtime·sigaltstack(&st, nil);
|
|
}
|
|
|
|
void
|
|
runtime·unblocksignals(void)
|
|
{
|
|
runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
|
|
}
|