code review 12418043: net: add special netFD mutex

src/pkg/runtime/sema.goc

 // 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.
 
 // Semaphore implementation exposed to Go.
 // Intended use is provide a sleep and wakeup
 // primitive that can be used in the contended case
 // of other synchronization primitives.
 // Thus it targets the same goal as Linux's futex,
 // but it has much simpler semantics.
@@ skipping 80 matching lines @@
 cansemacquire(uint32 *addr)
 {
         uint32 v;
 
         while((v = runtime·atomicload(addr)) > 0)
                 if(runtime·cas(addr, v, v-1))
                         return 1;
         return 0;
 }
 
-static void
-semacquireimpl(uint32 volatile *addr, int32 profile)
+void
+runtime·semacquire(uint32 volatile *addr, bool profile)
 {
         Sema s; // Needs to be allocated on stack, otherwise garbage collector could deallocate it
         SemaRoot *root;
         int64 t0;
 ········
         // Easy case.
         if(cansemacquire(addr))
                 return;
 
         // Harder case:
@@ skipping 25 matching lines @@
                 runtime·park(runtime·unlock, root, "semacquire");
                 if(cansemacquire(addr)) {
                         if(t0)
                                 runtime·blockevent(s.releasetime - t0, 3);
                         return;
                 }
         }
 }
 
 void
-runtime·semacquire(uint32 volatile *addr)
-{
-        semacquireimpl(addr, 0);
-}
-
-void
 runtime·semrelease(uint32 volatile *addr)
 {
         Sema *s;
         SemaRoot *root;
 
         root = semroot(addr);
         runtime·xadd(addr, 1);
 
         // Easy case: no waiters?
         // This check must happen after the xadd, to avoid a missed wakeup
@@ skipping 18 matching lines @@
         }
         runtime·unlock(root);
         if(s) {
                 if(s->releasetime)
                         s->releasetime = runtime·cputicks();
                 runtime·ready(s->g);
         }
 }
 
 func runtime_Semacquire(addr *uint32) {
-        semacquireimpl(addr, 1);
+        runtime·semacquire(addr, true);
 }
 
 func runtime_Semrelease(addr *uint32) {
         runtime·semrelease(addr);
 }
-
-void net·runtime_Semacquire(uint32 *addr) {
-        semacquireimpl(addr, 1);
-}
-
-void net·runtime_Semrelease(uint32 *addr) {
-        runtime·semrelease(addr);
-}