code review 12418043: net: add special netFD mutex

src/pkg/net/fd_mutex.go

 // Copyright 2013 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.
 
 package net
 
 import "sync/atomic"
 
 // fdMutex is a specialized synchronization primitive
-// that manages lifetime of fd and serializes access
+// that manages lifetime of an fd and serializes access
 // to Read and Write methods on netFD.
 type fdMutex struct {
         state uint64
         rsema uint32
         wsema uint32
 }
 
 // fdMutex.state is organized as follows:
 // 1 bit - whether netFD is closed, if set all subsequent lock operations will fail.
 // 1 bit - lock for read operations.
@@ skipping 14 matching lines @@
 )
 
 // Read operations must do RWLock(true)/RWUnlock(true).
 // Write operations must do RWLock(false)/RWUnlock(false).
 // Misc operations must do Incref/Decref. Misc operations include functions like
 // setsockopt and setDeadline. They need to use Incref/Decref to ensure that
 // they operate on the correct fd in presence of a concurrent Close call
 // (otherwise fd can be closed under their feet).
 // Close operation must do IncrefAndClose/Decref.
 
-// All lock operations return false if fd is closed.
-// All unlock operations return true if fd is closed and it has dropped the last reference.
-
 // RWLock/Incref return whether fd is open.
 // RWUnlock/Decref return whether fd is closed and there are no remaining references.
 
 func (mu *fdMutex) Incref() bool {
         for {
                 old := atomic.LoadUint64(&mu.state)
                 if old&mutexClosed != 0 {
                         return false
                 }
                 new := old + mutexRef
@@ skipping 11 matching lines @@
                 old := atomic.LoadUint64(&mu.state)
                 if old&mutexClosed != 0 {
                         return false
                 }
                 // Mark as closed and acquire a reference.
                 new := (old | mutexClosed) + mutexRef
                 if new&mutexRefMask == 0 {
                         panic("net: inconsistent fdMutex")
                 }
                 // Remove all read and write waiters.
-                new &= ^uint64(mutexRMask | mutexWMask)
+                new &^= mutexRMask | mutexWMask
                 if atomic.CompareAndSwapUint64(&mu.state, old, new) {
                         // Wake all read and write waiters,
                         // they will observe closed flag after wakeup.
                         for old&mutexRMask != 0 {
                                 old -= mutexRWait
                                 runtime_Semrelease(&mu.rsema)
                         }
                         for old&mutexWMask != 0 {
                                 old -= mutexWWait
                                 runtime_Semrelease(&mu.wsema)
@@ skipping 88 matching lines @@
                                 runtime_Semrelease(mutexSema)
                         }
                         return new&(mutexClosed|mutexRef) == mutexClosed
                 }
         }
 }
 
 // Implemented in runtime package.
 func runtime_Semacquire(sema *uint32)
 func runtime_Semrelease(sema *uint32)