2011-08-08 07:56:38 -06:00
|
|
|
// Use of this source file is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.`
|
|
|
|
|
|
|
|
#include "runtime.h"
|
|
|
|
#include "defs.h"
|
|
|
|
#include "os.h"
|
|
|
|
#include "stack.h"
|
|
|
|
|
2011-08-29 07:35:13 -06:00
|
|
|
enum
|
|
|
|
{
|
2011-10-08 07:56:13 -06:00
|
|
|
MUTEX_UNLOCKED = 0,
|
|
|
|
MUTEX_LOCKED = 1,
|
|
|
|
MUTEX_SLEEPING = 2,
|
|
|
|
|
|
|
|
ACTIVE_SPIN = 4,
|
|
|
|
ACTIVE_SPIN_CNT = 30,
|
|
|
|
PASSIVE_SPIN = 1,
|
|
|
|
|
|
|
|
ESRCH = 3,
|
2011-08-29 07:35:13 -06:00
|
|
|
ENOTSUP = 91,
|
2011-11-07 09:57:34 -07:00
|
|
|
|
|
|
|
// From OpenBSD's sys/time.h
|
|
|
|
CLOCK_REALTIME = 0,
|
|
|
|
CLOCK_VIRTUAL = 1,
|
|
|
|
CLOCK_PROF = 2,
|
|
|
|
CLOCK_MONOTONIC = 3
|
2011-08-29 07:35:13 -06:00
|
|
|
};
|
2011-08-08 07:56:38 -06:00
|
|
|
|
2011-10-08 07:56:13 -06:00
|
|
|
extern SigTab runtime·sigtab[];
|
|
|
|
|
|
|
|
extern int64 runtime·rfork_thread(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
|
2011-11-07 09:57:34 -07:00
|
|
|
extern int32 runtime·thrsleep(void *ident, int32 clock_id, void *tsp, void *lock);
|
|
|
|
extern int32 runtime·thrwakeup(void *ident, int32 n);
|
2011-10-08 07:56:13 -06:00
|
|
|
|
2011-10-05 11:16:43 -06:00
|
|
|
// From OpenBSD's <sys/sysctl.h>
|
|
|
|
#define CTL_HW 6
|
|
|
|
#define HW_NCPU 3
|
|
|
|
|
|
|
|
static int32
|
|
|
|
getncpu(void)
|
|
|
|
{
|
|
|
|
uint32 mib[2];
|
|
|
|
uint32 out;
|
|
|
|
int32 ret;
|
|
|
|
uintptr nout;
|
|
|
|
|
|
|
|
// Fetch hw.ncpu via sysctl.
|
|
|
|
mib[0] = CTL_HW;
|
|
|
|
mib[1] = HW_NCPU;
|
|
|
|
nout = sizeof out;
|
|
|
|
out = 0;
|
|
|
|
ret = runtime·sysctl(mib, 2, (byte*)&out, &nout, nil, 0);
|
|
|
|
if(ret >= 0)
|
|
|
|
return out;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-11-02 07:42:01 -06:00
|
|
|
uintptr
|
|
|
|
runtime·semacreate(void)
|
2011-08-08 07:56:38 -06:00
|
|
|
{
|
2011-11-02 07:42:01 -06:00
|
|
|
return 1;
|
2011-08-08 07:56:38 -06:00
|
|
|
}
|
|
|
|
|
runtime: add timer support, use for package time
This looks like it is just moving some code from
time to runtime (and translating it to C), but the
runtime can do a better job managing the goroutines,
and it needs this functionality for its own maintenance
(for example, for the garbage collector to hand back
unused memory to the OS on a time delay).
Might as well have just one copy of the timer logic,
and runtime can't depend on time, so vice versa.
It also unifies Sleep, NewTicker, and NewTimer behind
one mechanism, so that there are no claims that one
is more efficient than another. (For example, today
people recommend using time.After instead of time.Sleep
to avoid blocking an OS thread.)
Fixes #1644.
Fixes #1731.
Fixes #2190.
R=golang-dev, r, hectorchu, iant, iant, jsing, alex.brainman, dvyukov
CC=golang-dev
https://golang.org/cl/5334051
2011-11-09 13:17:05 -07:00
|
|
|
int32
|
|
|
|
runtime·semasleep(int64 ns)
|
2011-08-08 07:56:38 -06:00
|
|
|
{
|
runtime: add timer support, use for package time
This looks like it is just moving some code from
time to runtime (and translating it to C), but the
runtime can do a better job managing the goroutines,
and it needs this functionality for its own maintenance
(for example, for the garbage collector to hand back
unused memory to the OS on a time delay).
Might as well have just one copy of the timer logic,
and runtime can't depend on time, so vice versa.
It also unifies Sleep, NewTicker, and NewTimer behind
one mechanism, so that there are no claims that one
is more efficient than another. (For example, today
people recommend using time.After instead of time.Sleep
to avoid blocking an OS thread.)
Fixes #1644.
Fixes #1731.
Fixes #2190.
R=golang-dev, r, hectorchu, iant, iant, jsing, alex.brainman, dvyukov
CC=golang-dev
https://golang.org/cl/5334051
2011-11-09 13:17:05 -07:00
|
|
|
Timespec ts;
|
|
|
|
|
2011-11-02 07:42:01 -06:00
|
|
|
// spin-mutex lock
|
|
|
|
while(runtime·xchg(&m->waitsemalock, 1))
|
2011-10-08 07:56:13 -06:00
|
|
|
runtime·osyield();
|
runtime: add timer support, use for package time
This looks like it is just moving some code from
time to runtime (and translating it to C), but the
runtime can do a better job managing the goroutines,
and it needs this functionality for its own maintenance
(for example, for the garbage collector to hand back
unused memory to the OS on a time delay).
Might as well have just one copy of the timer logic,
and runtime can't depend on time, so vice versa.
It also unifies Sleep, NewTicker, and NewTimer behind
one mechanism, so that there are no claims that one
is more efficient than another. (For example, today
people recommend using time.After instead of time.Sleep
to avoid blocking an OS thread.)
Fixes #1644.
Fixes #1731.
Fixes #2190.
R=golang-dev, r, hectorchu, iant, iant, jsing, alex.brainman, dvyukov
CC=golang-dev
https://golang.org/cl/5334051
2011-11-09 13:17:05 -07:00
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
// lock held
|
|
|
|
if(m->waitsemacount == 0) {
|
|
|
|
// sleep until semaphore != 0 or timeout.
|
|
|
|
// thrsleep unlocks m->waitsemalock.
|
|
|
|
if(ns < 0)
|
|
|
|
runtime·thrsleep(&m->waitsemacount, 0, nil, &m->waitsemalock);
|
|
|
|
else {
|
|
|
|
ts.tv_sec = ns/1000000000LL;
|
|
|
|
ts.tv_nsec = ns%1000000000LL;
|
|
|
|
runtime·thrsleep(&m->waitsemacount, CLOCK_REALTIME, &ts, &m->waitsemalock);
|
|
|
|
}
|
|
|
|
// reacquire lock
|
|
|
|
while(runtime·xchg(&m->waitsemalock, 1))
|
|
|
|
runtime·osyield();
|
|
|
|
}
|
|
|
|
|
|
|
|
// lock held (again)
|
|
|
|
if(m->waitsemacount != 0) {
|
|
|
|
// semaphore is available.
|
|
|
|
m->waitsemacount--;
|
|
|
|
// spin-mutex unlock
|
|
|
|
runtime·atomicstore(&m->waitsemalock, 0);
|
|
|
|
return 0; // semaphore acquired
|
|
|
|
}
|
|
|
|
|
|
|
|
// semaphore not available.
|
|
|
|
// if there is a timeout, stop now.
|
|
|
|
// otherwise keep trying.
|
|
|
|
if(ns >= 0)
|
|
|
|
break;
|
2011-08-08 07:56:38 -06:00
|
|
|
}
|
runtime: add timer support, use for package time
This looks like it is just moving some code from
time to runtime (and translating it to C), but the
runtime can do a better job managing the goroutines,
and it needs this functionality for its own maintenance
(for example, for the garbage collector to hand back
unused memory to the OS on a time delay).
Might as well have just one copy of the timer logic,
and runtime can't depend on time, so vice versa.
It also unifies Sleep, NewTicker, and NewTimer behind
one mechanism, so that there are no claims that one
is more efficient than another. (For example, today
people recommend using time.After instead of time.Sleep
to avoid blocking an OS thread.)
Fixes #1644.
Fixes #1731.
Fixes #2190.
R=golang-dev, r, hectorchu, iant, iant, jsing, alex.brainman, dvyukov
CC=golang-dev
https://golang.org/cl/5334051
2011-11-09 13:17:05 -07:00
|
|
|
|
|
|
|
// lock held but giving up
|
2011-11-02 07:42:01 -06:00
|
|
|
// spin-mutex unlock
|
|
|
|
runtime·atomicstore(&m->waitsemalock, 0);
|
runtime: add timer support, use for package time
This looks like it is just moving some code from
time to runtime (and translating it to C), but the
runtime can do a better job managing the goroutines,
and it needs this functionality for its own maintenance
(for example, for the garbage collector to hand back
unused memory to the OS on a time delay).
Might as well have just one copy of the timer logic,
and runtime can't depend on time, so vice versa.
It also unifies Sleep, NewTicker, and NewTimer behind
one mechanism, so that there are no claims that one
is more efficient than another. (For example, today
people recommend using time.After instead of time.Sleep
to avoid blocking an OS thread.)
Fixes #1644.
Fixes #1731.
Fixes #2190.
R=golang-dev, r, hectorchu, iant, iant, jsing, alex.brainman, dvyukov
CC=golang-dev
https://golang.org/cl/5334051
2011-11-09 13:17:05 -07:00
|
|
|
return -1;
|
2011-08-08 07:56:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-11-02 07:42:01 -06:00
|
|
|
runtime·semawakeup(M *mp)
|
2011-08-08 07:56:38 -06:00
|
|
|
{
|
2011-11-02 07:42:01 -06:00
|
|
|
uint32 ret;
|
2011-08-08 07:56:38 -06:00
|
|
|
|
2011-11-02 07:42:01 -06:00
|
|
|
// spin-mutex lock
|
|
|
|
while(runtime·xchg(&mp->waitsemalock, 1))
|
|
|
|
runtime·osyield();
|
|
|
|
mp->waitsemacount++;
|
|
|
|
ret = runtime·thrwakeup(&mp->waitsemacount, 1);
|
|
|
|
if(ret != 0 && ret != ESRCH)
|
|
|
|
runtime·printf("thrwakeup addr=%p sem=%d ret=%d\n", &mp->waitsemacount, mp->waitsemacount, ret);
|
|
|
|
// spin-mutex unlock
|
|
|
|
runtime·atomicstore(&mp->waitsemalock, 0);
|
2011-08-08 07:56:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// From OpenBSD's sys/param.h
|
2011-10-05 11:16:43 -06:00
|
|
|
#define RFPROC (1<<4) /* change child (else changes curproc) */
|
|
|
|
#define RFMEM (1<<5) /* share `address space' */
|
|
|
|
#define RFNOWAIT (1<<6) /* parent need not wait() on child */
|
|
|
|
#define RFTHREAD (1<<13) /* create a thread, not a process */
|
2011-08-08 07:56:38 -06:00
|
|
|
|
|
|
|
void
|
|
|
|
runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void))
|
|
|
|
{
|
|
|
|
int32 flags;
|
|
|
|
int32 ret;
|
|
|
|
|
|
|
|
flags = RFPROC | RFTHREAD | RFMEM | RFNOWAIT;
|
|
|
|
|
|
|
|
if (0) {
|
|
|
|
runtime·printf(
|
|
|
|
"newosproc stk=%p m=%p g=%p fn=%p id=%d/%d ostk=%p\n",
|
|
|
|
stk, m, g, fn, m->id, m->tls[0], &m);
|
|
|
|
}
|
|
|
|
|
|
|
|
m->tls[0] = m->id; // so 386 asm can find it
|
|
|
|
|
|
|
|
if((ret = runtime·rfork_thread(flags, stk, m, g, fn)) < 0) {
|
|
|
|
runtime·printf("runtime: failed to create new OS thread (have %d already; errno=%d)\n", runtime·mcount() - 1, -ret);
|
2011-08-29 07:35:13 -06:00
|
|
|
if (ret == -ENOTSUP)
|
|
|
|
runtime·printf("runtime: is kern.rthreads disabled?\n");
|
2011-08-08 07:56:38 -06:00
|
|
|
runtime·throw("runtime.newosproc");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
runtime·osinit(void)
|
|
|
|
{
|
2011-10-05 11:16:43 -06:00
|
|
|
runtime·ncpu = getncpu();
|
2011-08-08 07:56:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
runtime·goenvs(void)
|
|
|
|
{
|
|
|
|
runtime·goenvs_unix();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Called to initialize a new m (including the bootstrap m).
|
|
|
|
void
|
|
|
|
runtime·minit(void)
|
|
|
|
{
|
|
|
|
// Initialize signal handling
|
|
|
|
m->gsignal = runtime·malg(32*1024);
|
|
|
|
runtime·signalstack(m->gsignal->stackguard - StackGuard, 32*1024);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
runtime·sigpanic(void)
|
|
|
|
{
|
|
|
|
switch(g->sig) {
|
|
|
|
case SIGBUS:
|
|
|
|
if(g->sigcode0 == BUS_ADRERR && g->sigcode1 < 0x1000)
|
|
|
|
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)
|
|
|
|
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);
|
|
|
|
}
|