code review 35990043: runtime: add support for GOOS=solaris

src/pkg/runtime/os_solaris.c

 // Copyright 2011 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"
 
 #pragma dynexport end _end
 #pragma dynexport etext _etext
 #pragma dynexport edata _edata
 
 #pragma dynimport libc·___errno ___errno "libc.so"
 #pragma dynimport libc·clock_gettime clock_gettime "libc.so"
 #pragma dynimport libc·close close "libc.so"
 #pragma dynimport libc·exit exit "libc.so"
-#pragma dynimport libc·fcntl fcntl "libc.so"
 #pragma dynimport libc·fstat fstat "libc.so"
 #pragma dynimport libc·getcontext getcontext "libc.so"
 #pragma dynimport libc·getrlimit getrlimit "libc.so"
 #pragma dynimport libc·malloc malloc "libc.so"
 #pragma dynimport libc·mmap mmap "libc.so"
 #pragma dynimport libc·munmap munmap "libc.so"
 #pragma dynimport libc·open open "libc.so"
 #pragma dynimport libc·pthread_attr_destroy pthread_attr_destroy "libc.so"
 #pragma dynimport libc·pthread_attr_getstack pthread_attr_getstack "libc.so"
 #pragma dynimport libc·pthread_attr_init pthread_attr_init "libc.so"
@@ skipping 13 matching lines @@
 #pragma dynimport libc·sigaltstack sigaltstack "libc.so"
 #pragma dynimport libc·sigprocmask sigprocmask "libc.so"
 #pragma dynimport libc·sysconf sysconf "libc.so"
 #pragma dynimport libc·usleep usleep "libc.so"
 #pragma dynimport libc·write write "libc.so"
 
 extern uintptr libc·___errno;
 extern uintptr libc·clock_gettime;
 extern uintptr libc·close;
 extern uintptr libc·exit;
-extern uintptr libc·fcntl;
 extern uintptr libc·fstat;
 extern uintptr libc·getcontext;
 extern uintptr libc·getrlimit;
 extern uintptr libc·malloc;
 extern uintptr libc·mmap;
 extern uintptr libc·munmap;
 extern uintptr libc·open;
 extern uintptr libc·pthread_attr_destroy;
 extern uintptr libc·pthread_attr_getstack;
 extern uintptr libc·pthread_attr_init;
@@ skipping 45 matching lines @@
         for(;count; count--)
                 m->scratch.v[count - 1] = *((uintptr*)&count + count);
         m->libcall.args = (uintptr*)&m->scratch.v[0];
         runtime·asmcgocall(runtime·asmsysvicall6, &m->libcall);
         return m->libcall.r1;
 }
 
 static int32
 getncpu(void)·
 {
-        int32 n = (int32)runtime·sysconf(_SC_NPROCESSORS_ONLN);
-        return n > 1 ? n : 1;
+        int32 n;
+ ·······
+        n = (int32)runtime·sysconf(_SC_NPROCESSORS_ONLN);
+        if(n < 1)
+                return 1;
+        return n;
 }
 
 void
 runtime·osinit(void)
 {
         runtime·ncpu = getncpu();·
 }
 
 void
 runtime·newosproc(M *mp, void *stk)
@@ skipping 11 matching lines @@
         if(runtime·pthread_attr_getstack(&attr, (void**)&mp->g0->stackbase, &mp->g0->stacksize) != 0)
                 runtime·throw("pthread_attr_getstack");·
         if(runtime·pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
                 runtime·throw("pthread_attr_setdetachstate");
 
         // Disable signals during create, so that the new thread starts
         // with signals disabled.  It will enable them in minit.
         runtime·sigprocmask(SIG_SETMASK, &sigset_all, &oset);
         ret = runtime·pthread_create(&tid, &attr, (void (*)(void))runtime·tstart_sysvicall, mp);
         runtime·sigprocmask(SIG_SETMASK, &oset, nil);
-        if (ret != 0) {
+        if(ret != 0) {
                 runtime·printf("runtime: failed to create new OS thread (have %d already; errno=%d)\n", runtime·mcount(), ret);
                 runtime·throw("runtime.newosproc");
         }
 }
 
 void
 runtime·get_random_data(byte **rnd, int32 *rnd_len)
 {
         static byte urandom_data[HashRandomBytes];
         int32 fd;
@@ skipping 145 matching lines @@
         StackT st;
 
         st.ss_sp = (void*)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·sigprocmask(SIG_SETMASK, &sigset_none, nil);
+}
+
 #pragma textflag NOSPLIT
 uintptr
 runtime·semacreate(void)
 {
         SemT* sem;
 
         // Call libc's malloc rather than runtime·malloc.  This will
         // allocate space on the C heap.  We can't call runtime·malloc
         // here because it could cause a deadlock.
         m->libcall.fn = (void*)libc·malloc;
         m->libcall.n = 1;
         runtime·memclr((byte*)&m->scratch, sizeof(m->scratch));
         m->scratch.v[0] = (uintptr)sizeof(*sem);
         m->libcall.args = (uintptr*)&m->scratch;
         runtime·asmcgocall(runtime·asmsysvicall6, &m->libcall);
         sem = (void*)m->libcall.r1;
-        if (runtime·sem_init(sem, 0, 0) != 0)
+        if(runtime·sem_init(sem, 0, 0) != 0)
                 runtime·throw("sem_init");
         return (uintptr)sem;
 }
 
 #pragma textflag NOSPLIT
 int32
 runtime·semasleep(int64 ns)
 {
         if(ns >= 0) {
                 m->ts.tv_sec = ns / 1000000000LL;
                 m->ts.tv_nsec = ns % 1000000000LL;
 
                 m->libcall.fn = (void*)libc·sem_reltimedwait_np;
                 m->libcall.n = 2;
                 runtime·memclr((byte*)&m->scratch, sizeof(m->scratch));
                 m->scratch.v[0] = m->waitsema;
                 m->scratch.v[1] = (uintptr)&m->ts;
                 m->libcall.args = (uintptr*)&m->scratch;
                 runtime·asmcgocall(runtime·asmsysvicall6, &m->libcall);
-                if(*((int32*)(m->perrno)) != 0) {
-                        if(*((int32*)(m->perrno)) == ETIMEDOUT || *((int32*)(m->perrno)) == EAGAIN || *((int32*)(m->perrno)) == EINTR)
+                if(*m->perrno != 0) {
+                        if(*m->perrno == ETIMEDOUT || *m->perrno == EAGAIN || *m->perrno == EINTR)
                                 return -1;
                         runtime·throw("sem_reltimedwait_np");
                 }
                 return 0;
         }
         for(;;) {
                 m->libcall.fn = (void*)libc·sem_wait;
                 m->libcall.n = 1;
                 runtime·memclr((byte*)&m->scratch, sizeof(m->scratch));
                 m->scratch.v[0] = m->waitsema;
                 m->libcall.args = (uintptr*)&m->scratch;
                 runtime·asmcgocall(runtime·asmsysvicall6, &m->libcall);
                 if(m->libcall.r1 == 0)
                         break;
-                if(*((int32*)(m->perrno)) == EINTR)·
+                if(*m->perrno == EINTR)·
                         continue;
                 runtime·throw("sem_wait");
         }
         return 0;
 }
 
 #pragma textflag NOSPLIT
 void
 runtime·semawakeup(M *mp)
 {
         SemT* sem = (SemT*)mp->waitsema;
-        if (runtime·sem_post(sem) != 0)
+        if(runtime·sem_post(sem) != 0)
                 runtime·throw("sem_post");
 }
 
 int32
 runtime·close(int32 fd)
 {
         return runtime·sysvicall6(libc·close, 1, (uintptr)fd);
 }
 
 void
@@ skipping 168 matching lines @@
 runtime·write(int32 fd, void* buf, int32 nbyte)
 {
         return runtime·sysvicall6(libc·write, 3, (uintptr)fd, (uintptr)buf, (uintptr)nbyte);
 }
 
 void
 runtime·osyield(void)
 {
         runtime·sysvicall6(libc·sched_yield, 0);
 }