code review 4306043: runtime: cpu profiling support

src/pkg/runtime/linux/amd64/signal.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.h"
 #include "signals.h"
 #include "os.h"
 
 void
@@ skipping 42 matching lines @@
 runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp)
 {
         Ucontext *uc;
         Mcontext *mc;
         Sigcontext *r;
         uintptr *sp;
 
         uc = context;
         mc = &uc->uc_mcontext;
         r = (Sigcontext*)mc;    // same layout, more conveient names
+
+        if(sig == SIGPROF) {
+                runtime·sigprof((uint8*)r->rip, (uint8*)r->rsp, nil, gp);
+                return;
+        }
 
         if(gp != nil && (runtime·sigtab[sig].flags & SigPanic)) {
                 // Make it look like a call to the signal func.
                 // Have to pass arguments out of band since
                 // augmenting the stack frame would break
                 // the unwinding code.
                 gp->sig = sig;
                 gp->sigcode0 = info->si_code;
                 gp->sigcode1 = ((uintptr*)info)[2];
                 gp->sigpc = r->rip;
@@ skipping 44 matching lines @@
 runtime·signalstack(byte *p, int32 n)
 {
         Sigaltstack st;
 
         st.ss_sp = p;
         st.ss_size = n;
         st.ss_flags = 0;
         runtime·sigaltstack(&st, nil);
 }
 
+static void
+sigaction(int32 i, void (*fn)(int32, Siginfo*, void*, G*), bool restart)
+{
+        Sigaction sa;
+
+        runtime·memclr((byte*)&sa, sizeof sa);
+        sa.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESTORER;
+        if(restart)
+                sa.sa_flags |= SA_RESTART;
+        sa.sa_mask = ~0ULL;
+        sa.sa_restorer = (void*)runtime·sigreturn;
+        if(fn == runtime·sighandler)
+                fn = (void*)runtime·sigtramp;
+        sa.sa_handler = fn;
+        runtime·rt_sigaction(i, &sa, nil, 8);
+}
+
 void
 runtime·initsig(int32 queue)
 {
-        static Sigaction sa;
+        int32 i;
+        void *fn;
 
         runtime·siginit();
 
-        int32 i;
-        sa.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESTORER;
-        sa.sa_mask = 0xFFFFFFFFFFFFFFFFULL;
-        sa.sa_restorer = (void*)runtime·sigreturn;
         for(i = 0; i<NSIG; i++) {
                 if(runtime·sigtab[i].flags) {
                         if((runtime·sigtab[i].flags & SigQueue) != queue)
                                 continue;
                         if(runtime·sigtab[i].flags & (SigCatch | SigQueue))
-                                sa.sa_handler = (void*)runtime·sigtramp;
+                                fn = runtime·sighandler;
                         else
-                                sa.sa_handler = (void*)runtime·sigignore;
-                        if(runtime·sigtab[i].flags & SigRestart)
-                                sa.sa_flags |= SA_RESTART;
-                        else
-                                sa.sa_flags &= ~SA_RESTART;
-                        runtime·rt_sigaction(i, &sa, nil, 8);
+                                fn = runtime·sigignore;
+                        sigaction(i, fn, (runtime·sigtab[i].flags & SigRestart) != 0);
                 }
         }
 }
+
+void
+runtime·resetcpuprofiler(int32 hz)
+{
+        Itimerval it;
+········
+        runtime·memclr((byte*)&it, sizeof it);
+        if(hz == 0) {
+                runtime·setitimer(ITIMER_PROF, &it, nil);
+                sigaction(SIGPROF, SIG_IGN, true);
+        } else {
+                sigaction(SIGPROF, runtime·sighandler, true);
+                it.it_interval.tv_sec = 0;
+                it.it_interval.tv_usec = 1000000 / hz;
+                it.it_value = it.it_interval;
+                runtime·setitimer(ITIMER_PROF, &it, nil);
+        }
+        m->profilehz = hz;
+}