Go socket 编程源码解析(下)

ListenAcceptReadWrite

Accept 的核心逻辑在于：

func (ln *TCPListener) accept() (*TCPConn, error) {

	fd, err := ln.fd.accept()

	if err != nil {

		return nil, err

	}

	tc := newTCPConn(fd)

	if ln.lc.KeepAlive >= 0 {

		setKeepAlive(fd, true)

		ka := ln.lc.KeepAlive

		if ln.lc.KeepAlive == 0 {

			ka = defaultTCPKeepAlive

		}

		setKeepAlivePeriod(fd, ka)

	}

	return tc, nil

}

acceptsetKeepAlivesetKeepAlivePeriodtcp_keepalive_timetcp_keepalive_intvltcp_keepalive_probes

runtime.KeepAlive

func setKeepAlive(fd *netFD, keepalive bool) error {

	err := fd.pfd.SetsockoptInt(syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, boolint(keepalive))

	runtime.KeepAlive(fd)

	return wrapSyscallError("setsockopt", err)

}

它的存在是为了让 fd 不会被 GC 回收，更多信息可参考 issue_21402 和 go 变量逃逸分析。

accept

func (fd *netFD) accept() (netfd *netFD, err error) {

	d, rsa, errcall, err := fd.pfd.Accept()

	...

	if netfd, err = newFD(d, fd.family, fd.sotype, fd.net); err != nil {

		poll.CloseFunc(d)

		return nil, err

	}
	netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))

	return netfd, nil

}

netFDpoll.FDAcceptddnetfdsetAddr

poll.FDAccept

func (fd *FD) Accept() (int, syscall.Sockaddr, string, error) {

	for {

		s, rsa, errcall, err := accept(fd.Sysfd)

		if err == nil {

			return s, rsa, "", err

		}

		switch err {

		case syscall.EINTR:

			continue

		case syscall.EAGAIN:

			if fd.pd.pollable() {

				if err = fd.pd.waitRead(fd.isFile); err == nil {

					continue

				}

			}

		...

	}

}
func accept(s int) (int, syscall.Sockaddr, string, error) {

	ns, sa, err := Accept4Func(s, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC)

	switch err {

	case nil:

		return ns, sa, "", nil

	...

    }

}
func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {

	r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0)

	fd = int(r0)

	if e1 != 0 {

		err = errnoErr(e1)

	}

	return

}

accept

acceptAccept4Funcaccept4SYS_ACCEPT4fd.Sysfdsyscall.EAGAINfd.pd.pollabletruetrue

ReadWrite

2.1 Read

Read

func (fd *FD) Read(p []byte) (int, error) {

	...

	if err := fd.pd.prepareRead(fd.isFile); err != nil {

		return 0, err

	}

	if fd.IsStream && len(p) > maxRW {

		p = p[:maxRW]

	}

	for {

		n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)

		if err != nil {

			n = 0

			if err == syscall.EAGAIN && fd.pd.pollable() {

				if err = fd.pd.waitRead(fd.isFile); err == nil {

					continue

				}

			}

		}

		err = fd.eofError(n, err)

		return n, err

	}

}

从上述代码可以发现：

ReadprepareReadfd.isFilemaxRW

// Darwin and FreeBSD can't read or write 2GB+ files at a time,

// even on 64-bit systems.

// The same is true of socket implementations on many systems.

// See golang.org/issue/7812 and golang.org/issue/16266.

// Use 1GB instead of, say, 2GB-1, to keep subsequent reads aligned.

ignoringEINTRIOsyscall.Readfd.SysfdignoringEINTRIOsyscall.EAGAINfd.pd.pollableeofErrorEOF

Write

ReadWrite

// Write implements io.Writer.

func (fd *FD) Write(p []byte) (int, error) {

	...

	for {

		max := len(p)

		if fd.IsStream && max-nn > maxRW {

			max = nn + maxRW

		}

		n, err := ignoringEINTRIO(syscall.Write, fd.Sysfd, p[nn:max])

		if n > 0 {

			nn += n

		}

		if nn == len(p) {

			return nn, err

		}

		if err == syscall.EAGAIN && fd.pd.pollable() {

			if err = fd.pd.waitWrite(fd.isFile); err == nil {

				continue

			}

		}

		if err != nil {

			return nn, err

		}

		if n == 0 {

			return nn, io.ErrUnexpectedEOF

		}

	}

}

syscall.WriteWritefd.SysfdpEAGAINpollabletruewaitWrite