// 开发者视角：逻辑是线性的
listener, _ := net.Listen("tcp", ":8080")
for {
    conn, _ := listener.Accept() // 看起来这里阻塞了，直到有新连接
    go func(c net.Conn) {
        buf := make([]byte, 1024)
        n, _ := c.Read(buf) // 看起来这里阻塞了，直到有数据
        // 处理数据...
    }(conn)
}

// int32 runtime·epollcreate(int32 size);
TEXT runtime·epollcreate(SB),NOSPLIT,$0
	MOVL    size+0(FP), DI
	MOVL    $SYS_epoll_create, AX
	SYSCALL
	MOVL	AX, ret+8(FP)
	RET

// func epollctl(epfd, op, fd int32, ev *epollEvent) int
TEXT runtime·epollctl(SB),NOSPLIT,$0
	MOVL	epfd+0(FP), DI
	MOVL	op+4(FP), SI
	MOVL	fd+8(FP), DX
	MOVQ	ev+16(FP), R10
	MOVL	$SYS_epoll_ctl, AX
	SYSCALL
	MOVL	AX, ret+24(FP)
	RET

// Syscall6 calls system call number 'num' with arguments a1-6.
func Syscall6(num, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr)

//go:uintptrkeepalive
//go:nosplit
//go:linkname Syscall6
func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
	runtime_entersyscall()
	r1, r2, err = RawSyscall6(trap, a1, a2, a3, a4, a5, a6)
	runtime_exitsyscall()
	return
}

//go:uintptrkeepalive
//go:nosplit
//go:norace
//go:linkname RawSyscall6
func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
	var errno uintptr
	r1, r2, errno = runtimesyscall.Syscall6(trap, a1, a2, a3, a4, a5, a6)
	err = Errno(errno)
	return
}

func EpollCreate1(flags int32) (fd int32, errno uintptr) {
	r1, _, e := Syscall6(SYS_EPOLL_CREATE1, uintptr(flags), 0, 0, 0, 0, 0)
	return int32(r1), e
}

var _zero uintptr

func EpollWait(epfd int32, events []EpollEvent, maxev, waitms int32) (n int32, errno uintptr) {
	var ev unsafe.Pointer
	if len(events) > 0 {
		ev = unsafe.Pointer(&events[0])
	} else {
		ev = unsafe.Pointer(&_zero)
	}
	r1, _, e := Syscall6(SYS_EPOLL_PWAIT, uintptr(epfd), uintptr(ev), uintptr(maxev), uintptr(waitms), 0, 0)
	return int32(r1), e
}

func EpollCtl(epfd, op, fd int32, event *EpollEvent) (errno uintptr) {
	_, _, e := Syscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
	return e
}

SYS_EPOLL_CREATE1 = 291

func EpollCreate1(flags int32) (fd int32, errno uintptr) {
	r1, _, e := Syscall6(SYS_EPOLL_CREATE1, uintptr(flags), 0, 0, 0, 0, 0)
	return int32(r1), e
}

func netpollinit() {
	var errno uintptr
	epfd, errno = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC)
  // ...
}

// 新建多路复用器，这个函数在 Go 程序启动时被调用一次，用于初始化 Linux 平台的网络轮询器（netpoller）
func netpollinit() {
	var errno uintptr
  // 1. 创建一个 epoll 实例，返回的文件描述符存储在全局变量 `epfd` 中
  //		`EPOLL_CLOEXEC` 标志确保在 `exec` 时自动关闭这个 fd
	epfd, errno = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC)
	if errno != 0 {
		println("runtime: epollcreate failed with", errno)
		throw("runtime: netpollinit failed")
	}
  // 2. 创建一个 eventfd，这是 Linux 的一种特殊文件描述符
  // 		设置为非阻塞模式（EFD_NONBLOCK）和 exec 时关闭（EFD_CLOEXEC）
  // 		eventfd 用于唤醒阻塞在 `epoll_wait` 上的线程。这是 Go netpoller 的关键机制！
	efd, errno := syscall.Eventfd(0, syscall.EFD_CLOEXEC|syscall.EFD_NONBLOCK)
	if errno != 0 {
		println("runtime: eventfd failed with", -errno)
		throw("runtime: eventfd failed")
	}
  // 3. 构造 epollo 事件结构，syscall.EPOLLIN 表示监听可读事件
	ev := syscall.EpollEvent{
		Events: syscall.EPOLLIN,
	}
  // 4. 将 netpollEventFd 的地址存储到 ev.Data 中
  //		当 epoll 返回事件时，我们需要知道是哪个 fd 触发的事件。
  //		通过 Data 字段，我们可以区分：
  //			- 是 eventfd 触发的（唤醒信号）
  //			- 还是某个网络连接 fd 触发的（真正的网络 I/O）
	*(**uintptr)(unsafe.Pointer(&ev.Data)) = &netpollEventFd
  // 5. 使用 `EPOLL_CTL_ADD` 操作将 eventfd 添加到 epoll 实例中
  //		当 eventfd 变为可读时，epoll_wait 会返回
	errno = syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, efd, &ev)
	if errno != 0 {
		println("runtime: epollctl failed with", errno)
		throw("runtime: epollctl failed")
	}
  // 6. 将 eventfd 保存到全局变量中
  //		后续 `netpollBreak()` 函数会使用这个 fd 来唤醒阻塞的 epoll_wait
	netpollEventFd = uintptr(efd)
}

SYS_EPOLL_CTL     = 233

func EpollCtl(epfd, op, fd int32, event *EpollEvent) (errno uintptr) {
	_, _, e := Syscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0)
	return e
}

// 将 fd 的四个事件 syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP | syscall.EPOLLET 注册到 epfd 上
// 开始监控其 I/O 事件
func netpollopen(fd uintptr, pd *pollDesc) uintptr {
	var ev syscall.EpollEvent
	ev.Events = syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP | syscall.EPOLLET
	tp := taggedPointerPack(unsafe.Pointer(pd), pd.fdseq.Load())
	*(*taggedPointer)(unsafe.Pointer(&ev.Data)) = tp
	return syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, int32(fd), &ev)
}

SYS_EPOLL_PWAIT   = 281

func EpollWait(epfd int32, events []EpollEvent, maxev, waitms int32) (n int32, errno uintptr) {
	var ev unsafe.Pointer
	if len(events) > 0 {
		ev = unsafe.Pointer(&events[0])
	} else {
		ev = unsafe.Pointer(&_zero)
	}
	r1, _, e := Syscall6(SYS_EPOLL_PWAIT, uintptr(epfd), uintptr(ev), uintptr(maxev), uintptr(waitms), 0, 0)
	return int32(r1), e
}

// 注意返回的是一个可执行的 Goroutine 列表
func netpoll(delay int64) (gList, int32) {
	// 1. 计算超时时间
	var waitms int32
	if delay < 0 {  // 无限等待，阻塞直到有事件
		waitms = -1
	} else if delay == 0 {  // 非阻塞，立即返回
		waitms = 0
	} else if delay < 1e6 {
		waitms = 1 // 小于 1 微秒的延迟，至少等待 1 毫秒，毫秒是最小粒度，0 会变成非阻塞
	} else if delay < 1e15 {
		waitms = int32(delay / 1e6)  // 正常范围：转换纳秒到毫秒 (1ms = 1e6 ns)
	} else {
		waitms = 1e9 // 超大延迟，限制为约 11.5 天
	}

	// 2. 准备接收最多 128 个就绪事件
	var events [128]syscall.EpollEvent

retry:
	// 3. 调用 epoll_wait 等待事件
	n, errno := syscall.EpollWait(epfd, events[:], int32(len(events)), waitms)
	if errno != 0 {
		if errno != _EINTR {
			println("runtime: epollwait on fd", epfd, "failed with", errno)
			throw("runtime: netpoll failed")
		}
		if waitms > 0 {
			return gList{}, 0
		}
		goto retry
	}

	// 4. 初始化返回值
	var toRun gList      // 就绪的 goroutine 列表
	delta := int32(0)    // netpollWaiters 的调整值

	// 5.处理所有返回的事件
	for i := int32(0); i < n; i++ {
		ev := events[i]
		if ev.Events == 0 {
			continue
		}

		// 6. 判断是否是 eventfd 的唤醒信号，eventfd 用于从外部唤醒 epoll_wait
		if *(**uintptr)(unsafe.Pointer(&ev.Data)) == &netpollEventFd {
			// eventfd 应该只产生 EPOLLIN 事件
			if ev.Events != syscall.EPOLLIN {
				println("runtime: netpoll: eventfd ready for", ev.Events)
				throw("runtime: netpoll: eventfd ready for something unexpected")
			}

			// 消费唤醒信号
			if delay != 0 {
				var one uint64
				read(int32(netpollEventFd), noescape(unsafe.Pointer(&one)), int32(unsafe.Sizeof(one)))
				// 清除唤醒标志，允许下次 netpollBreak
				netpollWakeSig.Store(0)
			}
			// 跳过 eventfd，继续处理其他事件，eventfd 只是唤醒机制，不对应真实的网络 I/O
			continue
		}

		// 7.根据触发的事件设置读写模式
		var mode int32

		// [可读事件] 检查各种可读条件
		if ev.Events&(syscall.EPOLLIN|syscall.EPOLLRDHUP|syscall.EPOLLHUP|syscall.EPOLLERR) != 0 {
			// EPOLLIN: 有数据可读
			// EPOLLRDHUP: 对端关闭写端（半关闭）
			// EPOLLHUP: 连接挂断
			// EPOLLERR: 发生错误
			mode += 'r'
		}

		// [可写事件] 检查各种可写条件
		if ev.Events&(syscall.EPOLLOUT|syscall.EPOLLHUP|syscall.EPOLLERR) != 0 {
			// EPOLLOUT: 可以写入数据
			// EPOLLHUP: 连接挂断
			// EPOLLERR: 发生错误
			mode += 'w'
		}
		// 注意：mode 可能是 'r'(114), 'w'(119), 或 'r'+'w'(233)

		if mode != 0 {
			// 8. 获取 netpoller 对 socket 的抽象实例 pollDesc
			tp := *(*taggedPointer)(unsafe.Pointer(&ev.Data))
			pd := (*pollDesc)(tp.pointer())
			tag := tp.tag() // 提取序列号标签

			// 9. 检查是否是过期事件
			if pd.fdseq.Load() == tag {
				// 序列号匹配，这是有效的事件
				// 原因：防止 ABA 问题（fd 被关闭后重新打开复用）
				pd.setEventErr(ev.Events == syscall.EPOLLERR, tag)

				// 10. 将就绪的 goroutine 加入运行队列
				delta += netpollready(&toRun, pd, mode)
			}
			// else: 序列号不匹配，忽略过期事件，说明这个 pollDesc 已经被新的连接复用了
		}
	}

	// 11. 返回就绪的 goroutine 列表和等待计数调整值
	return toRun, delta
}

func netpollready(toRun *gList, pd *pollDesc, mode int32) int32 {
	delta := int32(0)
	var rg, wg *g
	if mode == 'r' || mode == 'r'+'w' {
		rg = netpollunblock(pd, 'r', true, &delta)
	}
	if mode == 'w' || mode == 'r'+'w' {
		wg = netpollunblock(pd, 'w', true, &delta)
	}
	if rg != nil {
		toRun.push(rg)
	}
	if wg != nil {
		toRun.push(wg)
	}
	return delta
}

func startTheWorldWithSema(emitTraceEvent bool) int64 {
	...
	if netpollinited() {
		list := netpoll(0)   //调用 netpoll
		injectglist(&list)
  }
  ...
}

// gcStart starts the GC.
func gcStart(trigger gcTrigger) {
  ...
  // Concurrent mark.
  systemstack(func() {
    now = startTheWorldWithSema(trace.enabled)	// 调用 startTheWorldWithSema
    ...
  })
  ...
}

func schedule() {
	// ..
	gp, inheritTime, tryWakeP := findRunnable() // blocks until work is available
	// ...
}

func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
	// ..
	// Poll network until next timer.
	if netpollinited() && (netpollAnyWaiters() || pollUntil != 0) && sched.lastpoll.Swap(0) != 0 {
		//..
		list, delta := netpoll(delay) // block until new work is available
    // ...
	}
	// ..
}

// Network poller descriptor.
//
// No heap pointers.
type pollDesc struct {
	_     sys.NotInHeap
	link  *pollDesc      // in pollcache, protected by pollcache.lock
	fd    uintptr        // constant for pollDesc usage lifetime
	fdseq atomic.Uintptr // protects against stale pollDesc

	// atomicInfo holds bits from closing, rd, and wd,
	// which are only ever written while holding the lock,
	// summarized for use by netpollcheckerr,
	// which cannot acquire the lock.
	// After writing these fields under lock in a way that
	// might change the summary, code must call publishInfo
	// before releasing the lock.
	// Code that changes fields and then calls netpollunblock
	// (while still holding the lock) must call publishInfo
	// before calling netpollunblock, because publishInfo is what
	// stops netpollblock from blocking anew
	// (by changing the result of netpollcheckerr).
	// atomicInfo also holds the eventErr bit,
	// recording whether a poll event on the fd got an error;
	// atomicInfo is the only source of truth for that bit.
	atomicInfo atomic.Uint32 // atomic pollInfo

	// rg, wg are accessed atomically and hold g pointers.
	// (Using atomic.Uintptr here is similar to using guintptr elsewhere.)
	rg atomic.Uintptr // pdReady, pdWait, G waiting for read or pdNil
	wg atomic.Uintptr // pdReady, pdWait, G waiting for write or pdNil

	lock    mutex // protects the following fields
	closing bool
	rrun    bool      // whether rt is running
	wrun    bool      // whether wt is running
	user    uint32    // user settable cookie
	rseq    uintptr   // protects from stale read timers
	rt      timer     // read deadline timer
	rd      int64     // read deadline (a nanotime in the future, -1 when expired)
	wseq    uintptr   // protects from stale write timers
	wt      timer     // write deadline timer
	wd      int64     // write deadline (a nanotime in the future, -1 when expired)
	self    *pollDesc // storage for indirect interface. See (*pollDesc).makeArg.
}

type pollCache struct {
	lock  mutex					// 锁
	first *pollDesc			// 指向 pollDesc 链表的第一个节点，即下一个可用的空闲节点（头插法）
	// PollDesc objects must be type-stable,
	// because we can get ready notification from epoll/kqueue
	// after the descriptor is closed/reused.
	// Stale notifications are detected using seq variable,
	// seq is incremented when deadlines are changed or descriptor is reused.
}

// PollDesc objects must be type-stable,

func (c *pollCache) alloc() *pollDesc {
	lock(&c.lock)
  // 1. 未初始化，则先进行初始化，一次性分配 n 个 pollDesc
	if c.first == nil {
		type pollDescPadded struct {
			pollDesc
			pad [tagAlign - unsafe.Sizeof(pollDesc{})]byte
		}
		const pdSize = unsafe.Sizeof(pollDescPadded{})
		n := pollBlockSize / pdSize
		if n == 0 {
			n = 1
		}
		// Must be in non-GC memory because can be referenced
		// only from epoll/kqueue internals.
		mem := persistentalloc(n*pdSize, tagAlign, &memstats.other_sys)
		for i := uintptr(0); i < n; i++ {
			pd := (*pollDesc)(add(mem, i*pdSize))
			lockInit(&pd.lock, lockRankPollDesc)
			pd.rt.init(nil, nil)
			pd.wt.init(nil, nil)
			pd.link = c.first
			c.first = pd
		}
	}
  // 2. 取出链表头部的空闲节点
	pd := c.first
  // 3. 移动到下一个空闲节点
	c.first = pd.link
	unlock(&c.lock)
	return pd
}

func (c *pollCache) free(pd *pollDesc) {
	// pd can't be shared here, but lock anyhow because
	// that's what publishInfo documents.
	lock(&pd.lock)

  // 1. 自增 fdseq，避免处理过期事件造成生命周期错位问题
	fdseq := pd.fdseq.Load()
	fdseq = (fdseq + 1) & (1<<tagBits - 1)
	pd.fdseq.Store(fdseq)

  // 2. 重置 pollDesc
	pd.publishInfo()

	unlock(&pd.lock)

	lock(&c.lock)

  // 3. 放回链表头部
	pd.link = c.first
	c.first = pd
	unlock(&c.lock)
}

//go:linkname poll_runtime_pollServerInit internal/poll.runtime_pollServerInit
func poll_runtime_pollServerInit() {
	netpollGenericInit()
}

func netpollGenericInit() {
  // 类似于 双重检查 的单例模式
  // 保证只执行一次 netpollinit()
	if netpollInited.Load() == 0 {
		lockInit(&netpollInitLock, lockRankNetpollInit)
		lockInit(&pollcache.lock, lockRankPollCache)
		lock(&netpollInitLock)
		if netpollInited.Load() == 0 {
			netpollinit() // epoll_create() 创建一个多路复用器
			netpollInited.Store(1)
		}
		unlock(&netpollInitLock)
	}
}

//go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
  // 1. 分配一个 pollDesc，用来描述要新增监听的 socket
	pd := pollcache.alloc()
  // 2. 上锁
	lock(&pd.lock)
	wg := pd.wg.Load()
	if wg != pdNil && wg != pdReady {
		throw("runtime: blocked write on free polldesc")
	}
	rg := pd.rg.Load()
	if rg != pdNil && rg != pdReady {
		throw("runtime: blocked read on free polldesc")
	}
  // 3. 赋值
	pd.fd = fd
	if pd.fdseq.Load() == 0 {
		// The value 0 is special in setEventErr, so don't use it.
		pd.fdseq.Store(1)
	}
	pd.closing = false
	pd.setEventErr(false, 0)
	pd.rseq++
	pd.rg.Store(pdNil)	// 初始值，还没感兴趣的 Goroutine
	pd.rd = 0
	pd.wseq++
	pd.wg.Store(pdNil)	// 初始化，还没感兴趣的 Goroutine
	pd.wd = 0
	pd.self = pd
	pd.publishInfo()
  // 4. 解锁
	unlock(&pd.lock)

  // 5. 调用 netpollopen  -> epoll_ctl
  // 将 pd 关联的 fd 的相关事件注册到 epoll 上
	errno := netpollopen(fd, pd)
	if errno != 0 {
		pollcache.free(pd)
		return nil, int(errno)
	}
	return pd, 0
}

func (pd *pollDesc) wait(mode int, isFile bool) error {
	if pd.runtimeCtx == 0 {
		return errors.New("waiting for unsupported file type")
	}
	res := runtime_pollWait(pd.runtimeCtx, mode)
	return convertErr(res, isFile)
}

func runtime_pollWait(ctx uintptr, mode int) int

//go:linkname poll_runtime_pollWait internal/poll.runtime_pollWait
func poll_runtime_pollWait(pd *pollDesc, mode int) int {
   ...
   // 循环调用 netpollblock，直到 netpollblock 返回 true
   // 也就是 rg 或 wg 已经置为 pdReady 了，可以读 / 写了
   for !netpollblock(pd, int32(mode), false) {
      ...
   }
   return pollNoError
}

// returns true if IO is ready, or false if timed out or closed
// waitio - wait only for completed IO, ignore errors
// Concurrent calls to netpollblock in the same mode are forbidden, as pollDesc
// can hold only a single waiting goroutine for each mode.
func netpollblock(pd *pollDesc, mode int32, waitio bool) bool {
  // 1. 根据 mode，看看是要读还是要写
	gpp := &pd.rg
	if mode == 'w' {
		gpp = &pd.wg
	}

	for {
    // 2. 已经 pdReady 了，返回 true，完成
		if gpp.CompareAndSwap(pdReady, pdNil) {
			return true
		}

    // 3. 没有 pdReady，则先置为 pdWait，再往下走
		if gpp.CompareAndSwap(pdNil, pdWait) {
			break
		}
	}

	// 4. 调用 gopark 阻塞当前 goroutine
	if waitio || netpollcheckerr(pd, mode) == pollNoError {
		gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceBlockNet, 5)
	}
	// 5. 当 gopark 返回时，表示被唤醒，重置为 pdNil
	old := gpp.Swap(pdNil)

  // 6. 如果是 pdReady，则返回 true，否则可能是超时等原因，返回 false
	return old == pdReady
}

func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
	r := atomic.Casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
	if r {
		// Bump the count of goroutines waiting for the poller.
		// The scheduler uses this to decide whether to block
		// waiting for the poller if there is nothing else to do.
		netpollAdjustWaiters(1)
	}
	return r
}

// Network file descriptor.
type netFD struct {
	pfd poll.FD

	// immutable until Close
	family      int
	sotype      int
	isConnected bool // handshake completed or use of association with peer
	net         string
	laddr       Addr
	raddr       Addr
}

func Listen(network, address string) (Listener, error) {
	var lc ListenConfig
	return lc.Listen(context.Background(), network, address)
}

// Accept implements the Accept method in the [Listener] interface; it
// waits for the next call and returns a generic [Conn].
func (l *TCPListener) Accept() (Conn, error) {
	if !l.ok() {
		return nil, syscall.EINVAL
	}
	c, err := l.accept()
	if err != nil {
		return nil, &OpError{Op: "accept", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}
	}
	return c, nil
}

// Read implements the Conn Read method.
func (c *conn) Read(b []byte) (int, error) {
   ...
   n, err := c.fd.Read(b)
	 ...
}

// Read implements io.Reader.
func (fd *FD) Read(p []byte) (int, error) {
	// ...
  // 循环读数据
	for {
   	// 1. 调用系统命令 syscall.Read，读取 sysfd 上的数据，然后往 p 写数据
		n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
		if err != nil {
			n = 0
      // 2. syscall.EAGAIN 说明还没数据，得先等等
			if err == syscall.EAGAIN && fd.pd.pollable() {
        // 3. 挂起，休眠等待
				if err = fd.pd.waitRead(fd.isFile); err == nil {
          // 4. 当有数据来的时候，会被唤醒走到这里，然后在回到 for 循环读取数据
					continue
				}
			}
		}
		err = fd.eofError(n, err)
		return n, err
	}
}

func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error) {
  // 1. 看看具体是哪种 tcp 连接
	switch network {
	case "tcp", "tcp4", "tcp6":
	default:
		return nil, &OpError{Op: "dial", Net: network, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: UnknownNetworkError(network)}
	}
	if raddr == nil {
		return nil, &OpError{Op: "dial", Net: network, Source: laddr.opAddr(), Addr: nil, Err: errMissingAddress}
	}

  // 2. 创建一个系统的网络连接工具
	sd := &sysDialer{network: network, address: raddr.String()}
	var (
		c   *TCPConn
		err error
	)

  // 3. 进行 TCP 连接
	if sd.MultipathTCP() {
		c, err = sd.dialMPTCP(context.Background(), laddr, raddr)
	} else {
		c, err = sd.dialTCP(context.Background(), laddr, raddr)
	}
	if err != nil {
		return nil, &OpError{Op: "dial", Net: network, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: err}
	}
	return c, nil
}

func (sd *sysDialer) dialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
	if h := sd.testHookDialTCP; h != nil {
		return h(ctx, sd.network, laddr, raddr)
	}
	if h := testHookDialTCP; h != nil {
		return h(ctx, sd.network, laddr, raddr)
	}
  // 4. 进入 doDialTCP
	return sd.doDialTCP(ctx, laddr, raddr)
}

func (sd *sysDialer) doDialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error) {
	return sd.doDialTCPProto(ctx, laddr, raddr, 0)
}

func (sd *sysDialer) doDialTCPProto(ctx context.Context, laddr, raddr *TCPAddr, proto int) (*TCPConn, error) {
	ctrlCtxFn := sd.Dialer.ControlContext
	if ctrlCtxFn == nil && sd.Dialer.Control != nil {
		ctrlCtxFn = func(ctx context.Context, network, address string, c syscall.RawConn) error {
			return sd.Dialer.Control(network, address, c)
		}
	}
 	// 5. 有了前面的基础，到这就明白了
 	// internetSocket 创建一个 fd，生成一个新的 socket，并注册到 epoll 中监听
	fd, err := internetSocket(ctx, sd.network, laddr, raddr, syscall.SOCK_STREAM, proto, "dial", ctrlCtxFn)
	for i := 0; i < 2 && (laddr == nil || laddr.Port == 0) && (selfConnect(fd, err) || spuriousENOTAVAIL(err)); i++ {
		if err == nil {
			fd.Close()
		}
		fd, err = internetSocket(ctx, sd.network, laddr, raddr, syscall.SOCK_STREAM, proto, "dial", ctrlCtxFn)
	}

	if err != nil {
		return nil, err
	}
  // 6. 返回一个 TCPConn
	return newTCPConn(fd, sd.Dialer.KeepAlive, sd.Dialer.KeepAliveConfig, testPreHookSetKeepAlive, testHookSetKeepAlive), nil
}