TCP：何时生成EPOLLHUP？

Question

另请参阅此问题，到目前为止尚未回答。

EPOLLHUP即使在man和内核文档中也有很多关于的困惑。人们似乎相信，当一个描述符轮询它返回本地关闭书写，即shutdown(SHUT_WR)，即导致相同的呼叫EPOLLRDHUP 在对等。但这是不正确的，在我的实验中，我得到了EPOLLOUT，EPOLLHUP之后没有得到shutdown(SHUT_WR)（是的，变得可写是违反直觉的，因为写作的一半是封闭的，但这不是问题的重点）。

这个人很穷，因为它EPOLLHUP说到挂起发生在关联的文件描述符上时，而没有说“挂断”是什么意思-对方做了什么？发送了什么数据包？另一篇文章只是使事情更加混乱，对我来说似乎是完全错误的。

我的实验表明，EPOLLHUP一旦双向交换EOF（FIN数据包），即双方都发出，就到达了shutdown(SHUT_WR)。它与无关SHUT_RD，我从不称呼它。也与无关close。在数据包方面，我怀疑EPOLLHUP主机发送的FIN会引起确认，即终止发起方在4向关机握手的第3步中引发此事件，而对等方在第4步中引发（请参见此处））。如果得到确认，那就太好了，因为它填补了我一直在寻找的空白，即如何在不使用LINGER的情况下轮询非阻塞套接字以获得最终的确认。它是否正确？

（注意：我正在使用ET，但我认为与此无关）

示例代码和输出。

该代码在一个框架之中，我提取它的肉，用之外TcpSocket::createListener，TcpSocket::connect和TcpSocket::accept，它做你所期望（这里没有显示）。

void registerFd(int pollFd, int fd, const char* description)
{
    epoll_event ev = {
        EPOLLIN | EPOLLOUT | EPOLLRDHUP | EPOLLET,
        const_cast<char*>(description) // union aggregate initialisation, initialises first member (void* ptr)
    };
    epoll_ctl(pollFd, EPOLL_CTL_ADD, fd, &ev);
}

struct EventPrinter
{
    friend std::ostream& operator<<(std::ostream& stream, const EventPrinter& obj)
    {
        return stream << "0x" << std::hex << obj.events_ << " = "
            << ((obj.events_& EPOLLIN) ? "EPOLLIN " : " ")
            << ((obj.events_& EPOLLOUT) ? "EPOLLOUT " : " ")
            << ((obj.events_& EPOLLERR) ? "EPOLLERR " : " ")
            << ((obj.events_& EPOLLRDHUP) ? "EPOLLRDHUP " : " ")
            << ((obj.events_& EPOLLHUP) ? "EPOLLHUP " : " ");
    }

    const uint32_t events_;
};

void processEvents(int pollFd)
{
    static int iterationCount = 0;
    ++iterationCount;

    std::array<epoll_event, 25> events;
    int eventCount;
    if (-1 ==
        (eventCount = epoll_wait(pollFd, events.data(), events.size(), 1)))
    {
        throw Exception("fatal: epoll_wait failed");
    }

    for (int i = 0; i < eventCount; ++i)
    {
        std::cout << "iteration #" << iterationCount << ": events on [" << static_cast<const char*>(events[i].data.ptr) << "]: [" << EventPrinter{events[i].events} << "]" << std::endl;
    }
}

TEST(EpollhupExample, SmokeTest)
{
    int pollFd_;
    if (-1 ==
        (pollFd_ = epoll_create1(0)))
    {
        throw Exception("fatal: could not create epoll socket");
    }

    const TcpSocket listener_ = TcpSocket::createListener(13500);
    if (!listener_.setFileStatusFlag(O_NONBLOCK, true))
        throw Exception("could not make listener socket non-blocking");
    registerFd(pollFd_, listener_.fd(), "listenerFD");

    const TcpSocket client = TcpSocket::connect("127.0.0.1", AF_INET, 13500);
    if (!client.valid()) throw;
    registerFd(pollFd_, client.fd(), "clientFD");





    //////////////////////////////////////////////
    /// start event processing ///////////////////
    //////////////////////////////////////////////

    processEvents(pollFd_); // iteration 1

    const TcpSocket conn = listener_.accept();
    if (!conn.valid()) throw;
    registerFd(pollFd_, conn.fd(), "serverFD");

    processEvents(pollFd_); // iteration 2

    conn.shutdown(SHUT_WR);

    processEvents(pollFd_); // iteration 3

    client.shutdown(SHUT_WR);

    processEvents(pollFd_); // iteration 4
}

输出：

    Info| TCP connection established to [127.0.0.1:13500]
iteration #1: events on [listenerFD]: [1 = EPOLLIN     ]
iteration #1: events on [clientFD]: [4 =  EPOLLOUT    ]
    Info| TCP connection accepted from [127.0.0.1:35160]

iteration #2: events on [serverFD]: [4 =  EPOLLOUT    ]
    // calling serverFD.shutdown(SHUT_WR) here

iteration #3: events on [clientFD]: [2005 = EPOLLIN EPOLLOUT  EPOLLRDHUP  ]           // EPOLLRDHUP arrives, nice.
iteration #3: events on [serverFD]: [4 =  EPOLLOUT    ]                               // serverFD (on which I called SHUT_WR) just reported as writable, not cool... but not the main point of the question
    // calling clientFD.shutdown(SHUT_WR) here

iteration #4: events on [serverFD]: [2015 = EPOLLIN EPOLLOUT  EPOLLRDHUP EPOLLHUP ]   // EPOLLRDHUP arrives, nice. EPOLLHUP too!
iteration #4: events on [clientFD]: [2015 = EPOLLIN EPOLLOUT  EPOLLRDHUP EPOLLHUP ]   // EPOLLHUP on the other side as well. Why? What does EPOLLHUP mean actually?

除了EPOLLHUP是什么意思以外，没有更好的方法来重述该问题。我认为文档很差，其他地方（例如here和here）的信息是错误的或无用的。

注意：要考虑回答的Q，我想确认在两个方向的最终FIN-ACK上都产生了EPOLLHUP。

Answer 1

对于此类问题，请使用源！除其他有趣的评论外，还有以下文本：

EPOLLHUP是UNMASKABLE事件（...）。这意味着，我们收到后EOF，poll总是立即返回，使不可能poll()的write()状态CLOSE_WAIT。一个解决方案很明显--- EPOLLHUP仅当shutdown在两个方向上都进行了设置。

然后是唯一设置的代码EPOLLHUP：

if (sk->sk_shutdown == SHUTDOWN_MASK || state == TCP_CLOSE)
    mask |= EPOLLHUP;

作为SHUTDOWN_MASK相等RCV_SHUTDOWN |SEND_SHUTDOWN。

TL; DR; 没错，仅当读写同时关闭时才发送此标志（我认为对等的关闭写入等同于我关闭读取）。当然，或者当连接关闭时。

更新：通过更详细地阅读源代码，这些是我的结论。

关于shutdown：

1. 正在shutdown(SHUT_WR)发送FIN并用标记套接字SEND_SHUTDOWN。
2. 这样做shutdown(SHUT_RD)不会发送任何内容，并用标记套接字RCV_SHUTDOWN。
3. 接收FIN标记与插座RCV_SHUTDOWN。

关于epoll：

1. 如果插座上标有SEND_SHUTDOWN和RCV_SHUTDOWN，poll将返回EPOLLHUP。
2. 如果插座标有RCV_SHUTDOWN，poll将返回EPOLLRDHUP。

因此，HUP事件可以理解为：

1. EPOLLRDHUP：您已收到FIN或致电shutdown(SHUT_RD)。无论如何，您的读取半插槽已挂起，也就是说，您将不再读取任何数据。
2. EPOLLHUP：你们两个都挂了一半。读取半插口就像上一点，对于发送半插口，您做了类似的操作shutdown(SHUT_WR)。

要完成正常关机，我将执行以下操作：

1. 做shutdown(SHUT_WR)派FIN和标记发送数据的结束。
2. 等待对方通过轮询进行相同的操作，直到得到EPOLLRDHUP。
3. 现在，您可以优雅地关闭套接字。

PS：关于您的评论：

写作是封闭的，违反直觉

实际上，如果您理解的epoll不是准备好但不会阻塞的输出，这实际上是可以预期的。也就是说，如果您得到EPOLLOUT保证，write()则不会阻塞调用。当然，在之后shutdown(SHUT_WR)，write()将立即返回。