code review 5697066: runtime/pprof: support OS X CPU profiling

src/pkg/runtime/thread_darwin.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 "stack.h"
 
 extern SigTab runtime·sigtab[];
 
 static Sigset sigset_all = ~(Sigset)0;
 static Sigset sigset_none;
+static Sigset sigset_prof = 1<<(SIGPROF-1);
 
 static void
 unimplemented(int8 *name)
 {
         runtime·prints(name);
         runtime·prints(" not implemented\n");
         *(int32*)1231 = 1231;
 }
 
 int32
 runtime·semasleep(int64 ns)
 {
-        return runtime·mach_semacquire(m->waitsema, ns);
+        int32 v;
+
+        if(m->profilehz > 0)
+                runtime·setprof(false);
+        v = runtime·mach_semacquire(m->waitsema, ns);
+        if(m->profilehz > 0)
+                runtime·setprof(true);
+        return v;
 }
 
 void
 runtime·semawakeup(M *mp)
 {
         runtime·mach_semrelease(mp->waitsema);
 }
 
 uintptr
 runtime·semacreate(void)
@@ skipping 40 matching lines @@
 
         m->tls[0] = m->id;      // so 386 asm can find it
         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);
         }
 
         runtime·sigprocmask(SIG_SETMASK, &sigset_all, &oset);
         errno = runtime·bsdthread_create(stk, m, g, fn);
         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).
 void
 runtime·minit(void)
 {
         // Initialize signal handling.
         m->gsignal = runtime·malg(32*1024);     // OS X wants >=8K, Linux >=2K
         runtime·signalstack(m->gsignal->stackguard - StackGuard, 32*1024);
-        runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
+
+        if(m->profilehz > 0)
+                runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
+        else
+                runtime·sigprocmask(SIG_SETMASK, &sigset_prof, nil);
 }
 
 // Mach IPC, to get at semaphores
 // Definitions are in /usr/include/mach on a Mac.
 
 static void
 macherror(int32 r, int8 *fn)
 {
         runtime·printf("mach error %s: %d\n", fn, r);
         runtime·throw("mach error");
@@ skipping 315 matching lines @@
 
 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;
 }
+
+// NOTE(rsc): On OS X, when the CPU profiling timer expires, the SIGPROF
+// signal is not guaranteed to be sent to the thread that was executing to
+// cause it to expire.  It can and often does go to a sleeping thread, which is
+// not interesting for our profile.  This is filed Apple Bug Report #9177434,
+// copied to http://code.google.com/p/go/source/detail?r=35b716c94225.
+// To work around this bug, we disable receipt of the profiling signal on
+// a thread while in blocking system calls.  This forces the kernel to deliver
+// the profiling signal to an executing thread.
+//
+// The workaround fails on OS X machines using a 64-bit Snow Leopard kernel.
+// In that configuration, the kernel appears to want to deliver SIGPROF to the
+// sleeping threads regardless of signal mask and, worse, does not deliver
+// the signal until the thread wakes up on its own.
+//
+// If necessary, we can switch to using ITIMER_REAL for OS X and handle
+// the kernel-generated SIGALRM by generating our own SIGALRMs to deliver
+// to all the running threads.  SIGALRM does not appear to be affected by
+// the 64-bit Snow Leopard bug.  However, as of this writing Mountain Lion
+// is in preview, making Snow Leopard two versions old, so it is unclear how
+// much effort we need to spend on one buggy kernel.
+
+// Control whether profiling signal can be delivered to this thread.
+void
+runtime·setprof(bool on)
+{
+        if(on)
+                runtime·sigprocmask(SIG_UNBLOCK, &sigset_prof, nil);
+        else
+                runtime·sigprocmask(SIG_BLOCK, &sigset_prof, nil);
+}