net: separate pollster initialization from network file descriptor allocation

Unlike the existing net package own pollster, runtime-integrated
network pollster on BSD variants, actually kqueue, requires a socket
that has beed passed to syscall.Listen previously for a stream
listener.

This CL separates pollDesc.Init (actually runtime_pollOpen) from newFD
to allow control of each state of sockets and adds init method to netFD
instead. Upcoming CLs will rearrange the call order of runtime-integrated
pollster and syscall functions like the following;

- For dialers that open active connections, runtime_pollOpen will be
  called in between syscall.Bind and syscall.Connect.

- For stream listeners that open passive stream connections,
  runtime_pollOpen will be called just after syscall.Listen.

- For datagram listeners that open datagram connections,
  runtime_pollOpen will be called just after syscall.Bind.

This is in preparation for runtime-integrated network pollster for BSD
variants.

Update #5199

R=dvyukov, alex.brainman, minux.ma
CC=golang-dev
https://golang.org/cl/8608044

diff --git a/src/pkg/net/fd_poll_runtime.go b/src/pkg/net/fd_poll_runtime.go
index 4f20a7e062363b276d8d1b24f4a6cec0b473f4fb..6ae5c609ac4e32bf2464d0d09ffb71a92904dc94 100644 (file)
--- a/src/pkg/net/fd_poll_runtime.go
+++ b/src/pkg/net/fd_poll_runtime.go
@@ -38,7 +38,11 @@ func (pd *pollDesc) Init(fd *netFD) error {
 }
 
 func (pd *pollDesc) Close() {
+       if pd.runtimeCtx == 0 {
+               return
+       }
        runtime_pollClose(pd.runtimeCtx)
+       pd.runtimeCtx = 0
 }
 
 func (pd *pollDesc) Lock() {
@@ -53,6 +57,9 @@ func (pd *pollDesc) Wakeup() {
 // Evict evicts fd from the pending list, unblocking any I/O running on fd.
 // Return value is whether the pollServer should be woken up.
 func (pd *pollDesc) Evict() bool {
+       if pd.runtimeCtx == 0 {
+               return false
+       }
        runtime_pollUnblock(pd.runtimeCtx)
        return false
 }

diff --git a/src/pkg/net/fd_unix.go b/src/pkg/net/fd_unix.go
index 14a3187ea564e41e39ff3a45e2bd97ba057d5875..a2a771491e475a33750b9aacafeae9af7bfb4634 100644 (file)
--- a/src/pkg/net/fd_unix.go
+++ b/src/pkg/net/fd_unix.go
@@ -55,17 +55,15 @@ func resolveAndDial(net, addr string, localAddr Addr, deadline time.Time) (Conn,
        return dial(net, addr, localAddr, ra, deadline)
 }
 
-func newFD(fd, family, sotype int, net string) (*netFD, error) {
-       netfd := &netFD{
-               sysfd:  fd,
-               family: family,
-               sotype: sotype,
-               net:    net,
-       }
-       if err := netfd.pd.Init(netfd); err != nil {
-               return nil, err
+func newFD(sysfd, family, sotype int, net string) (*netFD, error) {
+       return &netFD{sysfd: sysfd, family: family, sotype: sotype, net: net}, nil
+}
+
+func (fd *netFD) init() error {
+       if err := fd.pd.Init(fd); err != nil {
+               return err
        }
-       return netfd, nil
+       return nil
 }
 
 func (fd *netFD) setAddr(laddr, raddr Addr) {
@@ -401,6 +399,10 @@ func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (netfd *netFD, err e
                closesocket(s)
                return nil, err
        }
+       if err = netfd.init(); err != nil {
+               fd.Close()
+               return nil, err
+       }
        lsa, _ := syscall.Getsockname(netfd.sysfd)
        netfd.setAddr(toAddr(lsa), toAddr(rsa))
        return netfd, nil

diff --git a/src/pkg/net/fd_windows.go b/src/pkg/net/fd_windows.go
index 9ed99edb4c9770d3d8fee96eae40a32fdb706fb0..974a542a9672a514904d0b9e3ebfb838d853b31b 100644 (file)
--- a/src/pkg/net/fd_windows.go
+++ b/src/pkg/net/fd_windows.go
@@ -242,14 +242,12 @@ func newFD(sysfd syscall.Handle, family, sotype int, net string) (*netFD, error)
                return nil, initErr
        }
        onceStartServer.Do(startServer)
-       fd := &netFD{
-               sysfd:  sysfd,
-               family: family,
-               sotype: sotype,
-               net:    net,
-       }
+       return &netFD{sysfd: sysfd, family: family, sotype: sotype, net: net}, nil
+}
+
+func (fd *netFD) init() error {
        if err := fd.pd.Init(fd); err != nil {
-               return nil, err
+               return err
        }
        fd.rop.mode = 'r'
        fd.wop.mode = 'w'
@@ -261,7 +259,7 @@ func newFD(sysfd syscall.Handle, family, sotype int, net string) (*netFD, error)
                fd.rop.errc = make(chan error)
                fd.rop.errc = make(chan error)
        }
-       return fd, nil
+       return nil
 }
 
 func (fd *netFD) setAddr(laddr, raddr Addr) {
@@ -473,6 +471,10 @@ func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (*netFD, error) {
                closesocket(s)
                return nil, &OpError{"accept", fd.net, fd.laddr, err}
        }
+       if err := netfd.init(); err != nil {
+               fd.Close()
+               return nil, err
+       }
 
        // Submit accept request.
        o := &fd.rop

diff --git a/src/pkg/net/file_unix.go b/src/pkg/net/file_unix.go
index 1e7420cf7745ce33520235c02b10b5aeb64fb066..fe01918a1ff087a41bfbe90023bae942e53c1e24 100644 (file)
--- a/src/pkg/net/file_unix.go
+++ b/src/pkg/net/file_unix.go
@@ -67,6 +67,10 @@ func newFileFD(f *os.File) (*netFD, error) {
                closesocket(fd)
                return nil, err
        }
+       if err := netfd.init(); err != nil {
+               netfd.Close()
+               return nil, err
+       }
        netfd.setAddr(laddr, raddr)
        return netfd, nil
 }

diff --git a/src/pkg/net/sock_posix.go b/src/pkg/net/sock_posix.go
index 1b66d3761bbaa6a5ba911604bb14e2e2d43ef1e6..5c6ca8d28a9a40fb0b173a99b7fbfab43ac8fb8a 100644 (file)
--- a/src/pkg/net/sock_posix.go
+++ b/src/pkg/net/sock_posix.go
@@ -93,6 +93,10 @@ func socket(net string, f, t, p int, ipv6only bool, laddr, raddr sockaddr, deadl
                closesocket(s)
                return nil, err
        }
+       if err := fd.init(); err != nil {
+               fd.Close()
+               return nil, err
+       }
 
        var rsa syscall.Sockaddr
        if raddr != nil {