2.1.1 create servsocket

// linux in
servsock=socket(PF_INET,SOCK_STREAM,0) // establish socket

/* go netpoll in
* Call chain:Listen() -> ListenConfig.Listen() -> listenTCP() -> internetSocket() -> socket() 
* socket()The function is as follows
*/ 
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error) {
   s, err := sysSocket(family, sotype, proto) //establish servsock
   if err != nil {
      return nil, err
   }
   if err = setDefaultSockopts(s, family, sotype, ipv6only); err != nil {
      poll.CloseFunc(s)
      return nil, err
   }
   
   // initialization netFD
   if fd, err = newFD(s, family, sotype, net); err != nil {
      poll.CloseFunc(s)
      return nil, err
   }
   ...
   // call listenStream()
    if laddr != nil && raddr == nil {
       switch sotype {
       case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET:
          if err := fd.listenStream(laddr, listenerBacklog(), ctrlFn); err != nil {
             fd.Close()
             return nil, err
          }
          return fd, nil
       case syscall.SOCK_DGRAM:
          if err := fd.listenDatagram(laddr, ctrlFn); err != nil {
             fd.Close()
             return nil, err
          }
          return fd, nil
       }
    }
    ...
}

2.1.2 binding servsocket

// Linux in
bind(servsock,(struct sockaddr*)&servaddr,sizeof(servaddr) // take servsock With one sockaddr Structure binding for

/* go netpoll in
*/
func (fd *netFD) listenStream(laddr sockaddr, backlog int, ctrlFn func(string, string, syscall.RawConn) error) error {
   var err error
   if err = setDefaultListenerSockopts(fd.pfd.Sysfd); err != nil {
      return err
   }
   var lsa syscall.Sockaddr
   if lsa, err = laddr.sockaddr(fd.family); err != nil {
      return err
   }
   if ctrlFn != nil {
      c, err := newRawConn(fd)
      if err != nil {
         return err
      }
      if err := ctrlFn(fd.ctrlNetwork(), laddr.String(), c); err != nil {
         return err
      }
   }
   if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
      return os.NewSyscallError("bind", err)
   }
   if err = listenFunc(fd.pfd.Sysfd, backlog); err != nil {
      return os.NewSyscallError("listen", err)
   }
   // stay fd.init Implementation creation in epfd，monitor servsock
   if err = fd.init(); err != nil {
      return err
   }
   lsa, _ = syscall.Getsockname(fd.pfd.Sysfd)
   fd.setAddr(fd.addrFunc()(lsa), nil)
   return nil
}

2.1.3   Create epoll instance epfd

// linux in
epoll_event event
event.events=EPOLLIN //input monitoring 
event.data.fd=servsock
epfd=epoll_create(20) //establish epoll example

/* go netpoll in
* Call chain:netFD.init()->pollDesc.init()-> runtime_pollServerInit()->netpollinit()
*/

// pollDesc.init()
func (pd *pollDesc) init(fd *FD) error {
    // serverInit Defined as var serverInit sync.Once，Guarantee in init In function runtime_pollServerInit Execute only once; Subsequent net.Accpet Also called pollDesc.init，The main purpose is to call runtime_pollOpen Add client connections to epfd in
   serverInit.Do(runtime_pollServerInit) // establish epfd，The bottom layer is called according to the operating system netpollinit()
   ctx, errno := runtime_pollOpen(uintptr(fd.Sysfd)) // stay epfd Medium monitoring servsock
   if errno != 0 {
      if ctx != 0 {
         runtime_pollUnblock(ctx)
         runtime_pollClose(ctx)
      }
      return errnoErr(syscall.Errno(errno))
   }
   pd.runtimeCtx = ctx
   return nil
}

// establish epfd And create a pipe epfd signal communication, Equivalent to Linux of epoll_create
func netpollinit() {
   epfd = epollcreate1(_EPOLL_CLOEXEC) // establish epfd example
   if epfd < 0 {
      epfd = epollcreate(1024)
      if epfd < 0 {
         println("runtime: epollcreate failed with", -epfd)
         throw("runtime: netpollinit failed")
      }
      closeonexec(epfd)
   }
   r, w, errno := nonblockingPipe() // Create pipes to break epoll_wait Listening waiting for
   if errno != 0 {
      println("runtime: pipe failed with", -errno)
      throw("runtime: pipe failed")
   }
   ev := epollevent{
      events: _EPOLLIN,
   }
   *(**uintptr)(unsafe.Pointer(&ev.data)) = &netpollBreakRd
   errno = epollctl(epfd, _EPOLL_CTL_ADD, r, &ev) // The pipeline is used to listen for read events
   if errno != 0 {
      println("runtime: epollctl failed with", -errno)
      throw("runtime: epollctl failed")
   }
   netpollBreakRd = uintptr(r)
   netpollBreakWr = uintptr(w)
}

go netpoll bottom layer by identifying different operating system, netpollinit function has different implementation, for example, in Linux, calling epoll_. Create(), kqueue() for Mac OS and IOCP for windows. When other functions are called at the bottom, they will also be automatically bound to the specific implementation according to the operating system.

2.1.4   Add servsock to the listening object of epfd

// linux in
epoll_ctl(epfd,EPOLL_CTL_ADD,servsock,&event); //towards epfd add to fd Input listening event for

/* go netpoll in
* Call chain:pollDesc.init() -> runtime_pollOpen() -> poll_runtime_pollOpen() -> netpollopen()
*/

func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
   pd := pollcache.alloc() // Apply for one pollDesc, pollDesc Is a linked list structure, pre applied memory
   lock(&pd.lock)
   wg := atomic.Loaduintptr(&pd.wg)
   if wg != 0 && wg != pdReady {
      throw("runtime: blocked write on free polldesc")
   }
   rg := atomic.Loaduintptr(&pd.rg)
   if rg != 0 && rg != pdReady {
      throw("runtime: blocked read on free polldesc")
   }
   pd.fd = fd // take servsock Bind to pollDesc
   pd.closing = false
   pd.everr = false
   pd.rseq++
   atomic.Storeuintptr(&pd.rg, 0)
   pd.rd = 0
   pd.wseq++
   atomic.Storeuintptr(&pd.wg, 0)
   pd.wd = 0
   pd.self = pd
   unlock(&pd.lock) // initialization pd.rg and pd.wg，These two variables are used to indicate pd.fd Whether there are already readable and writable events for calling blocking in this fd Upper goroutine

   errno := netpollopen(fd, pd) // take servsock Add to epfd In the monitoring queue for
   if errno != 0 {
      pollcache.free(pd)
      return nil, int(errno)
   }
   return pd, 0
}

// netpollopen Concrete implementation of
func netpollopen(fd uintptr, pd *pollDesc) int32 {
   var ev epollevent
   ev.events = _EPOLLIN | _EPOLLOUT | _EPOLLRDHUP | _EPOLLET
   *(**pollDesc)(unsafe.Pointer(&ev.data)) = pd // Bind pollDesc struct to epoll_ On event.data
   return -epollctl(epfd, _EPOLL_CTL_ADD, int32(fd), &ev) // call epollctl
}

summary

// Listener.Accept Called is netFD.cccept. 
func (fd *netFD) accept() (netfd *netFD, err error) {
   d, rsa, errcall, err := fd.pfd.Accept() // The bottom layer is linux accept，Get to client socket
   if err != nil {
      if errcall != "" {
         err = wrapSyscallError(errcall, err)
      }
      return nil, err
   }
　　// Initialize netFD
   if netfd, err = newFD(d, fd.family, fd.sotype, fd.net); err != nil {
      poll.CloseFunc(d)
      return nil, err
   }
   // Follow net.Listen()Medium net.init()Is a function that is mainly used to socket Add to epfd in
   if err = netfd.init(); err != nil { 
      netfd.Close()
      return nil, err
   }
   lsa, _ := syscall.Getsockname(netfd.pfd.Sysfd)
   netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
   return netfd, nil
}