DialTCP()->dialTCP()->internetSocket()->socket()
在socket()函数内首先会走到这个分支 sysSocket()->syscall.SetNonblock(s, true); 这里设置NonBlock 为true,即IO是非阻塞的

1. net/tcpsock.go/DialTCP
   

   func DialTCP(net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
       c, err := dialTCP(context.Background(), net, laddr, raddr)
   }
   

2. net/tcpsockopt_posix.go
   

          func dialTCP(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
   	   if testHookDialTCP != nil {
   	       return testHookDialTCP(ctx, net, laddr, raddr)
   	   }
   	   return doDialTCP(ctx, net, laddr, raddr)
          }
   
          func doDialTCP(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
   	   fd, err := internetSocket(ctx, net, laddr, raddr, syscall.SOCK_STREAM, 0, "dial")
   
   	   return newTCPConn(fd), nil
          }
   func internetSocket(ctx context.Context, net string, laddr, raddr sockaddr, sotype, proto int, mode string) (fd *netFD, err error) {
       family, ipv6only := favoriteAddrFamily(net, laddr, raddr, mode)
       return socket(ctx, net, family, sotype, proto, ipv6only, laddr, raddr)
   }
   
   

3. net/sock_posix.go
   

   // socket returns a network file descriptor that is ready for
   // asynchronous I/O using the network poller.
   func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr) (fd *netFD, err error) {
       s, err := sysSocket(family, sotype, proto)  // 里面设置NonBlock 为true,即IO是非阻塞的
       if err != nil {
   	return nil, err
       }
       //重要的一行,这里创建了 netFD结构体，
       if fd, err = newFD(s, family, sotype, net); err != nil {
   	closeFunc(s)
   	return nil, err
       }
        if err := fd.dial(ctx, laddr, raddr); err != nil { //这里call dial 函数
   	 fd.Close()
   	 return nil, err
        }
   
   
       return fd, nil
   }
   

4. net/sock_cloexec.go
   

   func sysSocket(family, sotype, proto int) (int, error) {
       if err = syscall.SetNonblock(s, true); err != nil { //这里设置NonBlock 为true,即IO是非阻塞的
   	closeFunc(s)
   	return -1, os.NewSyscallError("setnonblock", err)
       }
   }
   

接着上面的socket()函数看
然后socket()内的流程 -> fd.dial()->fd.connect()->fd.init()
会看到 流程会走到fd.init()的调用，这里的fd 是一个netFD结构

1. net/sock_posix.go
   

   // socket returns a network file descriptor that is ready for
   // asynchronous I/O using the network poller.
   func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr) (fd *netFD, err error) {
       s, err := sysSocket(family, sotype, proto)  // 里面设置NonBlock 为true,即IO是非阻塞的
       if err != nil {
   	return nil, err
       }
   	if err := fd.dial(ctx, laddr, raddr); err != nil { //这里call dial 函数
   	    fd.Close()
   	    return nil, err
   	}
   
   
       return fd, nil
   }
   
   func (fd *netFD) dial(ctx context.Context, laddr, raddr sockaddr) error {
       //这个函数 无论哪个分支 最终都会走到 fd.init()  下面有注释
       if raddr != nil {
   	if rsa, err = raddr.sockaddr(fd.family); err != nil {
   	    return err
   	}
   	if err := fd.connect(ctx, lsa, rsa); err != nil {
   	    return err
   	}
   	fd.isConnected = true
       } else {
   	if err := fd.init(); err != nil {//最终会走到 fd.init()
   	    return err
   	}
       }
       return nil
   }
   func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (ret error) {
       if err := fd.init(); err != nil { // 最终会call到 fd.init()
   	return err
       }
   
   

2. net/fd_unix.go 然后看看netFD结构体的init(),就是上面的fd.init()
   

   // Network file descriptor.
   type netFD struct {
       // locking/lifetime of sysfd + serialize access to Read and Write methods
       fdmu fdMutex
   
       // immutable until Close
       sysfd       int
       family      int
       sotype      int
       isConnected bool
       net         string
       laddr       Addr
       raddr       Addr
   
       // wait server
       pd pollDesc //这个结构体很重要
   }
   func (fd *netFD) init() error {
       //fd.pd 是个pollDesc类型,具体的pd.init()见下面
       if err := fd.pd.init(fd); err != nil {
   	return err
       }
       return nil
   }
   
   
   

3. net/fd_poll_runtime.go 注意找到文件
   

   // runtimeNano returns the current value of the runtime clock in nanoseconds.
   func runtimeNano() int64
   
   func runtime_pollServerInit()
   func runtime_pollOpen(fd uintptr) (uintptr, int)
   func runtime_pollClose(ctx uintptr)
   func runtime_pollWait(ctx uintptr, mode int) int
   func runtime_pollWaitCanceled(ctx uintptr, mode int) int
   func runtime_pollReset(ctx uintptr, mode int) int
   func runtime_pollSetDeadline(ctx uintptr, d int64, mode int)
   func runtime_pollUnblock(ctx uintptr)
   
   type pollDesc struct {
       runtimeCtx uintptr
   }
   
   var serverInit sync.Once
   
   func (pd *pollDesc) init(fd *netFD) error {
       // 这里的代码开始进入真正的初始化，通过sync.Once来保证runtime_pollServerInit这个函数只会被调用一次
       //文件开头却只是声明了runtime_pollServerInit一个空函数
       serverInit.Do(runtime_pollServerInit)
        上面是epoll_create的初始化
         下面这句则是本fd的open过程
   
        //runtime_pollOpen的跟踪，直接看本文 runtime_pollOpen分支
       ctx, errno := runtime_pollOpen(uintptr(fd.sysfd))
       if errno != 0 {
   	return syscall.Errno(errno)
       }
       pd.runtimeCtx = ctx
       return nil
   }
   

net/fd_poll_runtime.go 文件中声明的 runtime_pollServerInit是个空函数，导致似乎跟踪到此就结束了
然后似乎没非如此，用grep在整个代码搜索runtime_pollServerInit 会有以下结果

./net/fd_poll_runtime.go:18:func runtime_pollServerInit()
./net/fd_poll_runtime.go:34: serverInit.Do(runtime_pollServerInit)
./runtime/netpoll.go:80://go:linkname net_runtime_pollServerInit net.runtime_pollServerInit
./runtime/netpoll.go:81:func net_runtime_pollServerInit() {

我们打开./runtime/netpoll.go找到80行左右有如下代码

  //从这行注释来看 net.runtime_pollServerInit 似乎是有关联的，
  //怀疑 go compile时会对其进行相应的处理,
  //这里暂且就认为 net.runtime_pollServerInit() == runtime.net_runtime_pollServerInit()
//go:linkname net_runtime_pollServerInit net.runtime_pollServerInit
func net_runtime_pollServerInit() {
    netpollinit()
    atomic.Store(&netpollInited, 1)
}

runtime/netpoll_epoll.go

  var (
      epfd int32 = -1 // epoll descriptor
  )

func netpollinit() {
    epfd = epollcreate1(_EPOLL_CLOEXEC)
    if epfd >= 0 {
	return
    }
    epfd = epollcreate(1024) // 看到这里就看到了epollcreate的身影了
    if epfd >= 0 {
	closeonexec(epfd)
	return
    }
    println("netpollinit: failed to create epoll descriptor", -epfd)
    throw("netpollinit: failed to create descriptor")
}