code review 131580043: runtime: Start and stop individual goroutines at gc saf...

src/pkg/runtime/stack.c

 // 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 "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "stack.h"
 #include "funcdata.h"
 #include "typekind.h"
@@ skipping 188 matching lines @@
         // Doing so would cause a deadlock (issue 1547).
         if(g != g->m->g0)
                 runtime·throw("stackalloc not on scheduler stack");
         if((n & (n-1)) != 0)
                 runtime·throw("stack size not a power of 2");
         if(StackDebug >= 1)
                 runtime·printf("stackalloc %d\n", n);
 
         gp->stacksize += n;
         if(runtime·debug.efence || StackFromSystem) {
-                v = runtime·SysAlloc(ROUND(n, PageSize), &mstats.stacks_sys);
+                v = runtime·sysAlloc(ROUND(n, PageSize), &mstats.stacks_sys);
                 if(v == nil)
                         runtime·throw("out of memory (stackalloc)");
                 return v;
         }
 
         // Small stacks are allocated with a fixed-size free-list allocator.
         // If we need a stack of a bigger size, we fall back on allocating
         // a dedicated span.
         if(StackCache && n < FixedStack << NumStackOrders && n < StackCacheSize) {
                 order = 0;
@@ skipping 192 matching lines @@
 {
         CopyableInfo *cinfo;
         Func *f;
         StackMap *stackmap;
 
         cinfo = arg;
         f = frame->fn;
         if(StackDebug >= 2)
                 runtime·printf("    checking %s frame=[%p,%p] stk=[%p,%p]\n", runtime·funcname(f), frame->sp, frame->fp, cinfo->stk, cinfo->base);
         // if we're not in the segment any more, return immediately.
-        if(frame->varp < cinfo->stk || frame->varp >= cinfo->base) {
+        if((byte*)frame->varp < cinfo->stk || (byte*)frame->varp >= cinfo->base) {
                 if(StackDebug >= 2)
                         runtime·printf("    <next segment>\n");
                 return false; // stop traceback
         }
         if(f->entry == (uintptr)runtime·main) {
                 // A special routine at the TOS of the main routine.
                 // We will allow it to be copied even though we don't
                 // have full GC info for it (because it is written in C).
                 cinfo->frames++;
                 return false; // stop traceback
         }
         if(f->entry == (uintptr)runtime·switchtoM) {
                 // A special routine at the bottom of stack of a goroutine that does onM call.
                 // We will allow it to be copied even though we don't
                 // have full GC info for it (because it is written in asm).
                 cinfo->frames++;
                 return true;
         }
-        if(frame->varp != (byte*)frame->sp) { // not in prologue (and has at least one local or outarg)
+        if((byte*)frame->varp != (byte*)frame->sp) { // not in prologue (and has at least one local or outarg)
                 stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
                 if(stackmap == nil) {
                         cinfo->frames = -1;
                         if(StackDebug >= 1)
                                 runtime·printf("copystack: no locals info for %s\n", runtime·funcname(f));
                         return false;
                 }
                 if(stackmap->n <= 0) {
                         cinfo->frames = -1;
                         if(StackDebug >= 1)
@@ skipping 18 matching lines @@
 // frame, return -1.  Otherwise return the number of frames
 // in the top segment, all of which are copyable.
 static int32
 copyabletopsegment(G *gp)
 {
         CopyableInfo cinfo;
         Defer *d;
         Func *f;
         FuncVal *fn;
         StackMap *stackmap;
+        bool (*cb)(Stkframe*, void*);
 
         if(gp->stackbase == 0)
                 runtime·throw("stackbase == 0");
         cinfo.stk = (byte*)gp->stackguard - StackGuard;
         cinfo.base = (byte*)gp->stackbase + sizeof(Stktop);
         cinfo.frames = 0;
 
         // Check that each frame is copyable.  As a side effect,
         // count the frames.
-        runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, checkframecopy, &cinfo, false);
+        cb = checkframecopy;
+        runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, &cb, &cinfo, false);
         if(StackDebug >= 1 && cinfo.frames != -1)
                 runtime·printf("copystack: %d copyable frames\n", cinfo.frames);
 
         if(cinfo.frames == -1)
                 return -1;
 
         // Check to make sure all Defers are copyable
         for(d = gp->defer; d != nil; d = d->link) {
                 if(cinfo.stk <= (byte*)d && (byte*)d < cinfo.base) {
                         // Defer is on the stack.  Its copyableness has
                         // been established during stack walking.
                         // For now, this only happens with the Defer in runtime.main.
                         continue;
                 }
-                if(d->argp < cinfo.stk || cinfo.base <= d->argp)
+                if((byte*)d->argp < cinfo.stk || cinfo.base <= (byte*)d->argp)
                         break; // a defer for the next segment
                 fn = d->fn;
                 if(fn == nil) // See issue 8047
                         continue;
                 f = runtime·findfunc((uintptr)fn->fn);
                 if(f == nil) {
                         if(StackDebug >= 1)
                                 runtime·printf("copystack: no func for deferred pc %p\n", fn->fn);
                         return -1;
                 }
@@ skipping 144 matching lines @@
                 // Frame is dead.
                 return true;
         }
         if(targetpc != f->entry)
                 targetpc--;
         pcdata = runtime·pcdatavalue(f, PCDATA_StackMapIndex, targetpc);
         if(pcdata == -1)
                 pcdata = 0; // in prologue
 
         // adjust local pointers
-        if(frame->varp != (byte*)frame->sp) {
+        if((byte*)frame->varp != (byte*)frame->sp) {
                 stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
                 if(stackmap == nil)
                         runtime·throw("no locals info");
                 if(stackmap->n <= 0)
                         runtime·throw("locals size info only");
                 bv = runtime·stackmapdata(stackmap, pcdata);
                 if(StackDebug >= 3)
                         runtime·printf("      locals\n");
                 adjustpointers((byte**)frame->varp - bv.n / BitsPerPointer, &bv, adjinfo, f);
         }
         // adjust inargs and outargs
         if(frame->arglen != 0) {
                 stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
-                if(stackmap == nil)
+                if(stackmap == nil) {
+                        runtime·printf("size %d\n", (int32)frame->arglen);
                         runtime·throw("no arg info");
+                }
                 bv = runtime·stackmapdata(stackmap, pcdata);
                 if(StackDebug >= 3)
                         runtime·printf("      args\n");
                 adjustpointers((byte**)frame->argp, &bv, adjinfo, nil);
         }
         return true;
 }
 
 static void
 adjustctxt(G *gp, AdjustInfo *adjinfo)
@@ skipping 13 matching lines @@
 
         for(dp = &gp->defer, d = *dp; d != nil; dp = &d->link, d = *dp) {
                 if(adjinfo->oldstk <= (byte*)d && (byte*)d < adjinfo->oldbase) {
                         // The Defer record is on the stack.  Its fields will
                         // get adjusted appropriately.
                         // This only happens for runtime.main now, but a compiler
                         // optimization could do more of this.
                         *dp = (Defer*)((byte*)d + adjinfo->delta);
                         continue;
                 }
-                if(d->argp < adjinfo->oldstk || adjinfo->oldbase <= d->argp)
+                if((byte*)d->argp < adjinfo->oldstk || adjinfo->oldbase <= (byte*)d->argp)
                         break; // a defer for the next segment
                 fn = d->fn;
                 if(fn == nil) {
                         // Defer of nil function.  It will panic when run, and there
                         // aren't any args to adjust.  See issue 8047.
                         d->argp += adjinfo->delta;
                         continue;
                 }
                 f = runtime·findfunc((uintptr)fn->fn);
                 if(f == nil)
@@ skipping 24 matching lines @@
 {
         SudoG *s;
         byte *e;
 
         // the data elements pointed to by a SudoG structure
         // might be in the stack.
         for(s = gp->waiting; s != nil; s = s->waitlink) {
                 e = s->elem;
                 if(adjinfo->oldstk <= e && e < adjinfo->oldbase)
                         s->elem = e + adjinfo->delta;
+                e = (byte*)s->selectdone;
+                if(adjinfo->oldstk <= e && e < adjinfo->oldbase)
+                        s->selectdone = (uint32*)(e + adjinfo->delta);
         }
 }
 
 // Copies the top stack segment of gp to a new stack segment of a
 // different size.  The top segment must contain nframes frames.
 static void
 copystack(G *gp, uintptr nframes, uintptr newsize)
 {
         byte *oldstk, *oldbase, *newstk, *newbase;
         uintptr oldsize, used;
         AdjustInfo adjinfo;
         Stktop *oldtop, *newtop;
         uint32 oldstatus;
+        bool (*cb)(Stkframe*, void*);
 
         if(gp->syscallstack != 0)
                 runtime·throw("can't handle stack copy in syscall yet");
         oldstk = (byte*)gp->stackguard - StackGuard;
         if(gp->stackbase == 0)
                 runtime·throw("nil stackbase");
         oldbase = (byte*)gp->stackbase + sizeof(Stktop);
         oldsize = oldbase - oldstk;
         used = oldbase - (byte*)gp->sched.sp;
         oldtop = (Stktop*)gp->stackbase;
 
         // allocate new stack
         newstk = runtime·stackalloc(gp, newsize);
         newbase = newstk + newsize;
         newtop = (Stktop*)(newbase - sizeof(Stktop));
 
         if(StackDebug >= 1)
                 runtime·printf("copystack gp=%p [%p %p]/%d -> [%p %p]/%d\n", gp, oldstk, oldbase, (int32)oldsize, newstk, newbase, (int32)newsize);
         USED(oldsize);
 ········
         // adjust pointers in the to-be-copied frames
         adjinfo.oldstk = oldstk;
         adjinfo.oldbase = oldbase;
         adjinfo.delta = newbase - oldbase;
-        runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, nframes, adjustframe, &adjinfo, false);
+        cb = adjustframe;
+        runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, nframes, &cb, &adjinfo, false);
 ········
         // adjust other miscellaneous things that have pointers into stacks.
         adjustctxt(gp, &adjinfo);
         adjustdefers(gp, &adjinfo);
         adjustsudogs(gp, &adjinfo);
 ········
         // copy the stack (including Stktop) to the new location
         runtime·memmove(newbase - used, oldbase - used, used);
         oldstatus = runtime·readgstatus(gp);
         oldstatus &= ~Gscan;
@@ skipping 295 matching lines @@
         if(gp->m != nil && gp->m->libcallsp != 0)
                 return;
 #endif
         if(StackDebug > 0)
                 runtime·printf("shrinking stack %D->%D\n", (uint64)oldsize, (uint64)newsize);
         nframes = copyabletopsegment(gp);
         if(nframes == -1)
                 return;
         copystack(gp, nframes, newsize);
 }