code review 5714049: runtime: run init on main thread

src/pkg/runtime/proc.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 "arch_GOARCH.h"
 #include "defs_GOOS_GOARCH.h"
 #include "malloc.h"
 #include "os_GOOS.h"
 #include "stack.h"
@@ skipping 191 matching lines @@
         }
         setmcpumax(runtime·gomaxprocs);
         runtime·singleproc = runtime·gomaxprocs == 1;
 
         canaddmcpu();   // mcpu++ to account for bootstrap m
         m->helpgc = 1;  // flag to tell schedule() to mcpu--
         runtime·sched.grunning++;
 
         mstats.enablegc = 1;
         m->nomemprof--;
-
-        scvg = runtime·newproc1((byte*)runtime·MHeap_Scavenger, nil, 0, 0, runtime·schedinit);
 }
 
 extern void main·init(void);
 extern void main·main(void);
 
 // The main goroutine.
 void
 runtime·main(void)
 {
         // Lock the main goroutine onto this, the main OS thread,
         // during initialization.  Most programs won't care, but a few
         // do require certain calls to be made by the main thread.
         // Those can arrange for main.main to run in the main thread
         // by calling runtime.LockOSThread during initialization
         // to preserve the lock.
         runtime·LockOSThread();
         runtime·sched.init = true;
+        scvg = runtime·newproc1((byte*)runtime·MHeap_Scavenger, nil, 0, 0, runtime·main);
         main·init();
         runtime·sched.init = false;
         if(!runtime·sched.lockmain)
                 runtime·UnlockOSThread();
 
         main·main();
         runtime·exit(0);
         for(;;)
                 *(int32*)runtime·main = 0;
 }
@@ skipping 339 matching lines @@
                 // We hold the sched lock, so no one else is manipulating the
                 // g queue or changing mcpumax.  Entersyscall can decrement
                 // mcpu, but if does so when there is something on the g queue,
                 // the gwait bit will be set, so entersyscall will take the slow path
                 // and use the sched lock.  So it cannot invalidate our decision.
                 //
                 // Wait on global m queue.
                 mput(m);
         }
 
-        // Look for deadlock situation: one single active g which happens to be scvg.
-        if(runtime·sched.grunning == 1 && runtime·sched.gwait == 0) {
-                if(scvg->status == Grunning || scvg->status == Gsyscall)
-                        runtime·throw("all goroutines are asleep - deadlock!");
+        // Look for deadlock situation.
+        if((scvg == nil && runtime·sched.grunning == 0) ||
+           (scvg != nil && runtime·sched.grunning == 1 && runtime·sched.gwait == 0 &&
+            (scvg->status == Grunning || scvg->status == Gsyscall))) {
+                runtime·throw("all goroutines are asleep - deadlock!");
         }
 
         m->nextg = nil;
         m->waitnextg = 1;
         runtime·noteclear(&m->havenextg);
 
         // Stoptheworld is waiting for all but its cpu to go to stop.
         // Entersyscall might have decremented mcpu too, but if so
         // it will see the waitstop and take the slow path.
         // Exitsyscall never increments mcpu beyond mcpumax.
@@ skipping 1162 matching lines @@
         arg[0][k.len] = 0;
 
         arg[1] = runtime·malloc(v.len + 1);
         runtime·memmove(arg[1], v.str, v.len);
         arg[1][v.len] = 0;
 
         runtime·asmcgocall((void*)libcgo_setenv, arg);
         runtime·free(arg[0]);
         runtime·free(arg[1]);
 }