code review 12418043: net: add special netFD mutex

src/pkg/net/fd_unix.go

 // 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.
 
 // +build darwin freebsd linux netbsd openbsd
 
 package net
 
 import (
         "io"
@@ skipping 57 matching lines @@
         if fd.laddr != nil {
                 ls = fd.laddr.String()
         }
         if fd.raddr != nil {
                 rs = fd.raddr.String()
         }
         return fd.net + ":" + ls + "->" + rs
 }
 
 func (fd *netFD) connect(la, ra syscall.Sockaddr) error {
+        // Do not need to call fd.writeLock here,
+        // because fd is not yet accessible to user,
+        // so no concurrent operations are possible.
         if err := fd.pd.PrepareWrite(); err != nil {
                 return err
         }
         for {
                 err := syscall.Connect(fd.sysfd, ra)
                 if err == nil || err == syscall.EISCONN {
                         break
                 }
                 if err != syscall.EINPROGRESS && err != syscall.EALREADY && err != syscall.EINTR {
                         return err
@@ skipping 10 matching lines @@
         // so this must be executed before closesocket.
         fd.pd.Close()
         closesocket(fd.sysfd)
         fd.sysfd = -1
         runtime.SetFinalizer(fd, nil)
 }
 
 // Add a reference to this fd.
 // Returns an error if the fd cannot be used.
 func (fd *netFD) incref() error {
-        if fd == nil || !fd.fdmu.Incref() {
+        if !fd.fdmu.Incref() {
                 return errClosing
         }
         return nil
 }
 
 // Remove a reference to this FD and close if we've been asked to do so
 // (and there are no references left).
 func (fd *netFD) decref() {
-        if fd != nil && fd.fdmu.Decref() {
+        if fd.fdmu.Decref() {
                 fd.destroy()
         }
 }
 
 // Add a reference to this fd and lock for reading.
 // Returns an error if the fd cannot be used.
 func (fd *netFD) readLock() error {
-        if fd == nil || !fd.fdmu.RWLock(true) {
+        if !fd.fdmu.RWLock(true) {
                 return errClosing
         }
         return nil
 }
 
 // Unlock for reading and remove a reference to this FD.
 func (fd *netFD) readUnlock() {
-        if fd != nil && fd.fdmu.RWUnlock(true) {
+        if fd.fdmu.RWUnlock(true) {
                 fd.destroy()
         }
 }
 
 // Add a reference to this fd and lock for writing.
 // Returns an error if the fd cannot be used.
 func (fd *netFD) writeLock() error {
-        if fd == nil || !fd.fdmu.RWLock(false) {
+        if !fd.fdmu.RWLock(false) {
                 return errClosing
         }
         return nil
 }
 
 // Unlock for writing and remove a reference to this FD.
 func (fd *netFD) writeUnlock() {
-        if fd != nil && fd.fdmu.RWUnlock(false) {
+        if fd.fdmu.RWUnlock(false) {
                 fd.destroy()
         }
 }
 
 func (fd *netFD) Close() error {
         fd.pd.Lock() // needed for both fd.incref(true) and pollDesc.Evict
         if !fd.fdmu.IncrefAndClose() {
                 fd.pd.Unlock()
                 return errClosing
         }
@@ skipping 309 matching lines @@
         if err = syscall.SetNonblock(ns, false); err != nil {
                 return nil, &OpError{"setnonblock", fd.net, fd.laddr, err}
         }
 
         return os.NewFile(uintptr(ns), fd.name()), nil
 }
 
 func closesocket(s int) error {
         return syscall.Close(s)
 }