[dev.power64] code review 160200044: build: merge default into dev.power64

src/pkg/runtime/os_linux.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 "signal_unix.h"
 #include "stack.h"
-#include "../../cmd/ld/textflag.h"
+#include "textflag.h"
 
 extern SigTab runtime·sigtab[];
 
 static Sigset sigset_none;
 static Sigset sigset_all = { ~(uint32)0, ~(uint32)0 };
 
 // Linux futex.
 //
 //      futexsleep(uint32 *addr, uint32 val)
 //      futexwakeup(uint32 *addr)
@@ skipping 40 matching lines @@
 #ifdef _64BIT
         ts.tv_sec = ns / 1000000000LL;
         ts.tv_nsec = ns % 1000000000LL;
 #else
         ts.tv_nsec = 0;
         ts.tv_sec = runtime·timediv(ns, 1000000000LL, (int32*)&ts.tv_nsec);
 #endif
         runtime·futex(addr, FUTEX_WAIT, val, &ts, nil, 0);
 }
 
+static void badfutexwakeup(void);
+
 // If any procs are sleeping on addr, wake up at most cnt.
+#pragma textflag NOSPLIT
 void
 runtime·futexwakeup(uint32 *addr, uint32 cnt)
 {
         int64 ret;
+        void (*fn)(void);
 
         ret = runtime·futex(addr, FUTEX_WAKE, cnt, nil, nil, 0);
-
         if(ret >= 0)
                 return;
 
         // I don't know that futex wakeup can return
         // EAGAIN or EINTR, but if it does, it would be
         // safe to loop and call futex again.
+        g->m->ptrarg[0] = addr;
+        g->m->scalararg[0] = (int32)ret; // truncated but fine
+        fn = badfutexwakeup;
+        if(g == g->m->gsignal)
+                fn();
+        else
+                runtime·onM(&fn);
+        *(int32*)0x1006 = 0x1006;
+}
+
+static void
+badfutexwakeup(void)
+{
+        void *addr;
+        int64 ret;
+········
+        addr = g->m->ptrarg[0];
+        ret = (int32)g->m->scalararg[0];
         runtime·printf("futexwakeup addr=%p returned %D\n", addr, ret);
-        *(int32*)0x1006 = 0x1006;
 }
 
 extern runtime·sched_getaffinity(uintptr pid, uintptr len, uintptr *buf);
 static int32
 getproccount(void)
 {
         uintptr buf[16], t;
         int32 r, n, i;
 
         r = runtime·sched_getaffinity(0, sizeof(buf), buf);
@@ skipping 74 matching lines @@
 runtime·osinit(void)
 {
         runtime·ncpu = getproccount();
 }
 
 // Random bytes initialized at startup.  These come
 // from the ELF AT_RANDOM auxiliary vector (vdso_linux_amd64.c).
 byte*   runtime·startup_random_data;
 uint32  runtime·startup_random_data_len;
 
+#pragma textflag NOSPLIT
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
         if(runtime·startup_random_data != nil) {
                 *rnd = runtime·startup_random_data;
                 *rnd_len = runtime·startup_random_data_len;
         } else {
                 #pragma dataflag NOPTR
                 static byte urandom_data[HashRandomBytes];
                 int32 fd;
@@ skipping 73 matching lines @@
                 }
                 runtime·panicstring("floating point error");
         }
         runtime·panicstring(runtime·sigtab[g->sig].name);
 }
 
 uintptr
 runtime·memlimit(void)
 {
         Rlimit rl;
-        extern byte text[], end[];
+        extern byte runtime·text[], runtime·end[];
         uintptr used;
 
         if(runtime·getrlimit(RLIMIT_AS, &rl) != 0)
                 return 0;
         if(rl.rlim_cur >= 0x7fffffff)
                 return 0;
 
         // Estimate our VM footprint excluding the heap.
         // Not an exact science: use size of binary plus
         // some room for thread stacks.
-        used = end - text + (64<<20);
+        used = runtime·end - runtime·text + (64<<20);
         if(used >= rl.rlim_cur)
                 return 0;
 
         // If there's not at least 16 MB left, we're probably
         // not going to be able to do much.  Treat as no limit.
         rl.rlim_cur -= used;
         if(rl.rlim_cur < (16<<20))
                 return 0;
 
         return rl.rlim_cur - used;
 }
 
 #ifdef GOARCH_386
 #define sa_handler k_sa_handler
 #endif
 
 /*
  * This assembler routine takes the args from registers, puts them on the stack,
  * and calls sighandler().
  */
 extern void runtime·sigtramp(void);
 extern void runtime·sigreturn(void);    // calls rt_sigreturn, only used with SA_RESTORER
 
 void
 runtime·setsig(int32 i, GoSighandler *fn, bool restart)
 {
-        Sigaction sa;
+        SigactionT 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;
         // Although Linux manpage says "sa_restorer element is obsolete and
         // should not be used". x86_64 kernel requires it. Only use it on
         // x86.
 #ifdef GOARCH_386
         sa.sa_restorer = (void*)runtime·sigreturn;
 #endif
 #ifdef GOARCH_amd64
         sa.sa_restorer = (void*)runtime·sigreturn;
 #endif
         if(fn == runtime·sighandler)
                 fn = (void*)runtime·sigtramp;
         sa.sa_handler = fn;
         // Qemu rejects rt_sigaction of SIGRTMAX (64).
         if(runtime·rt_sigaction(i, &sa, nil, sizeof(sa.sa_mask)) != 0 && i != 64)
                 runtime·throw("rt_sigaction failure");
 }
 
 GoSighandler*
 runtime·getsig(int32 i)
 {
-        Sigaction sa;
+        SigactionT sa;
 
         runtime·memclr((byte*)&sa, sizeof sa);
         if(runtime·rt_sigaction(i, nil, &sa, sizeof(sa.sa_mask)) != 0)
                 runtime·throw("rt_sigaction read failure");
         if((void*)sa.sa_handler == runtime·sigtramp)
                 return runtime·sighandler;
         return (void*)sa.sa_handler;
 }
 
 void
 runtime·signalstack(byte *p, int32 n)
 {
-        Sigaltstack st;
+        SigaltstackT st;
 
         st.ss_sp = p;
         st.ss_size = n;
         st.ss_flags = 0;
         if(p == nil)
                 st.ss_flags = SS_DISABLE;
         runtime·sigaltstack(&st, nil);
 }
 
 void
 runtime·unblocksignals(void)
 {
         runtime·rtsigprocmask(SIG_SETMASK, &sigset_none, nil, sizeof sigset_none);
 }