code review 5309070: runtime: lock the main goroutine to the main OS 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.h"
 #include "defs.h"
 #include "malloc.h"
 #include "os.h"
 #include "stack.h"
@@ skipping 54 matching lines @@
         int32 gcount;   // number of g's that are alive
         int32 grunning; // number of g's running on cpu or in syscall
 
         M *mhead;       // m's waiting for work
         int32 mwait;    // number of m's waiting for work
         int32 mcount;   // number of m's that have been created
 
         volatile uint32 atomic; // atomic scheduling word (see below)
 
         int32 profilehz;        // cpu profiling rate
+········
+        bool init;  // running initialization
+        bool lockmain;  // init called runtime.LockOSThread
 
         Note    stopped;        // one g can set waitstop and wait here for m's to stop
 };
 
 // The atomic word in sched is an atomic uint32 that
 // holds these fields.
 //
 //      [15 bits] mcpu          number of m's executing on cpu
 //      [15 bits] mcpumax       max number of m's allowed on cpu
 //      [1 bit] waitstop        some g is waiting on stopped
@@ skipping 79 matching lines @@
         }
 }
 
 // The bootstrap sequence is:
 //
 //      call osinit
 //      call schedinit
 //      make & queue new G
 //      call runtime·mstart
 //
-// The new G does:
-//
-//      call main·init_function
-//      call initdone
-//      call main·main
+// The new G calls runtime·main.
 void
 runtime·schedinit(void)
 {
         int32 n;
         byte *p;
 
         m->nomemprof++;
         runtime·mallocinit();
         mcommoninit(m);
 
@@ skipping 14 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--;
+}
+
+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;
+        main·init();
+        runtime·sched.init = false;
+        if(!runtime·sched.lockmain)
+                runtime·UnlockOSThread();
+
+        main·main();
+        runtime·exit(0);
+        for(;;)
+                *(int32*)runtime·main = 0;
 }
 
 // Lock the scheduler.
 static void
 schedlock(void)
 {
         runtime·lock(&runtime·sched);
 }
 
 // Unlock the scheduler.
@@ skipping 1264 matching lines @@
         rundefer();
         runtime·goexit();
 }
 
 void
 runtime·Gosched(void)
 {
         runtime·gosched();
 }
 
-void
-runtime·LockOSThread(void)
-{
-        m->lockedg = g;
-        g->lockedm = m;
-}
-
 // delete when scheduler is stronger
 int32
 runtime·gomaxprocsfunc(int32 n)
 {
         int32 ret;
         uint32 v;
 
         schedlock();
         ret = runtime·gomaxprocs;
         if(n <= 0)
@@ skipping 20 matching lines @@
                 runtime·gosched();
                 return ret;
         }
         // handle more procs
         matchmg();
         schedunlock();
         return ret;
 }
 
 void
+runtime·LockOSThread(void)
+{
+        if(m == &runtime·m0 && runtime·sched.init) {
+                runtime·sched.lockmain = true;
+                return;
+        }
+        m->lockedg = g;
+        g->lockedm = m;
+}
+
+void
 runtime·UnlockOSThread(void)
 {
+        if(m == &runtime·m0 && runtime·sched.init) {
+                runtime·sched.lockmain = false;
+                return;
+        }
         m->lockedg = nil;
         g->lockedm = nil;
 }
 
 bool
 runtime·lockedOSThread(void)
 {
         return g->lockedm != nil && m->lockedg != nil;
 }
 
@@ skipping 99 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]);
 }