1/* 根据POSIX.1-2001, POSIX.1-2008标准 */
 2#include <sys/select.h>
 3
 4/* 根据以前的标准 */
 5#include <sys/time.h>
 6#include <sys/types.h>
 7#include <unistd.h>
 8
 9int select(int nfds, fd_set *readfds, fd_set *writefds,
10           fd_set *exceptfds, struct timeval *timeout);

1ready = pselect(nfds, &readfds, &writefds, &exceptfds,
2                timeout, &sigmask);

1sigset_t origmask;
2
3pthread_sigmask(SIG_SETMASK, &sigmask, &origmask);
4ready = select(nfds, &readfds, &writefds, &exceptfds, timeout);
5pthread_sigmask(SIG_SETMASK, &origmask, NULL);

 1//超时,涉及的时间结构定义在<sys/time.h>中，类似于
 2struct timeval {
 3    long    tv_sec;         /* seconds */
 4    long    tv_usec;        /* microseconds */
 5};
 6
 7struct timespec {
 8    long    tv_sec;         /* seconds */
 9    long    tv_nsec;        /* nanoseconds */
10};

 1//system/core/libcutils/socket_network_client_unix.cpp
 2int socket_network_client_timeout(const char* host, int port, int type, int timeout,
 3                                  int* getaddrinfo_error) {
 4    ...
 5    int result = -1;
 6    for (struct addrinfo* addr = addrs; addr != NULL; addr = addr->ai_next) {
 7        // The Mac doesn't have SOCK_NONBLOCK.
 8        int s = socket(addr->ai_family, type, addr->ai_protocol);
 9        if (s == -1 || toggle_O_NONBLOCK(s) == -1) break;
10
11        int rc = connect(s, addr->ai_addr, addr->ai_addrlen);
12        if (rc == 0) {
13            result = toggle_O_NONBLOCK(s);
14            break;
15        } else if (rc == -1 && errno != EINPROGRESS) {
16            close(s);
17            continue;
18        }
19
20        fd_set r_set;
21        FD_ZERO(&r_set);
22        FD_SET(s, &r_set);
23        fd_set w_set = r_set;
24
25        struct timeval ts;
26        ts.tv_sec = timeout;
27        ts.tv_usec = 0;
28        if ((rc = select(s + 1, &r_set, &w_set, NULL, (timeout != 0) ? &ts : NULL)) == -1) {
29            close(s);
30            break;
31        }
32        if (rc == 0) {  // we had a timeout
33            errno = ETIMEDOUT;
34            close(s);
35            break;
36        }
37		...
38    }
39
40    freeaddrinfo(addrs);
41    return result;
42}

 1//bionic/libc/include/netdb.h
 2struct addrinfo {
 3	int	ai_flags;	/* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
 4	int	ai_family;	/* PF_xxx */
 5	int	ai_socktype;	/* SOCK_xxx */
 6	int	ai_protocol;	/* 0 or IPPROTO_xxx for IPv4 and IPv6 */
 7	socklen_t ai_addrlen;	/* length of ai_addr */
 8	char	*ai_canonname;	/* canonical name for hostname */
 9	struct	sockaddr *ai_addr;	/* binary address */
10	struct	addrinfo *ai_next;	/* next structure in linked list */
11};

 1#include <poll.h>
 2
 3int poll(struct pollfd *fds, nfds_t nfds, int timeout);
 4
 5#define _GNU_SOURCE         /* See feature_test_macros(7) */
 6#include <signal.h>
 7#include <poll.h>
 8
 9int ppoll(struct pollfd *fds, nfds_t nfds,
10          const struct timespec *tmo_p, const sigset_t *sigmask);

1struct pollfd {
2    int   fd;         /* file descriptor */
3    short events;     /* requested events */
4    short revents;    /* returned events */
5};

  1//system/core/init/property_service.cpp
  2class SocketConnection {
  3  public:
  4    SocketConnection(int socket, const ucred& cred) : socket_(socket), cred_(cred) {}
  5	...
  6    //以接收string为例，另外的int和char都是类似    
  7    bool RecvString(std::string* value, uint32_t* timeout_ms) {
  8        uint32_t len = 0;
  9        /
 10        if (!RecvUint32(&len, timeout_ms)) {
 11            return false;
 12        }
 13
 14        std::vector<char> chars(len);
 15        if (!RecvChars(&chars[0], len, timeout_ms)) {
 16            return false;
 17        }
 18
 19        *value = std::string(&chars[0], len);
 20        return true;
 21    }
 22
 23    bool SendUint32(uint32_t value) {
 24        if (!socket_.ok()) {
 25            return true;
 26        }
 27        //发送的话，直接发送
 28        int result = TEMP_FAILURE_RETRY(send(socket_, &value, sizeof(value), 0));
 29        return result == sizeof(value);
 30    }
 31
 32    const ucred& cred() { return cred_; }
 33
 34  private:
 35    //接收的过程用到了poll机制,这里传递进来的timeout_ms为2s
 36    bool PollIn(uint32_t* timeout_ms) {
 37        struct pollfd ufds[1];
 38        ufds[0].fd = socket_;
 39        ufds[0].events = POLLIN;
 40        ufds[0].revents = 0;
 41        while (*timeout_ms > 0) {
 42            auto start_time = std::chrono::steady_clock::now();
 43            //对socket_，其实就是s进行监听，是否会超时。只有fds中准备好读写，返回值nr大于0为s
 44            int nr = poll(ufds, 1, *timeout_ms);
 45            auto now = std::chrono::steady_clock::now();
 46            auto time_elapsed =
 47                std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
 48            uint64_t millis = time_elapsed.count();
 49            *timeout_ms = (millis > *timeout_ms) ? 0 : *timeout_ms - millis;
 50
 51            if (nr > 0) {
 52                return true;
 53            }
 54
 55            if (nr == 0) {
 56                // Timeout
 57                break;
 58            }
 59
 60            if (nr < 0 && errno != EINTR) {
 61                PLOG(ERROR) << "sys_prop: error waiting for uid " << cred_.uid
 62                            << " to send property message";
 63                return false;
 64            } else {  // errno == EINTR
 65                // Timer rounds milliseconds down in case of EINTR we want it to be rounded up
 66                // to avoid slowing init down by causing EINTR with under millisecond timeout.
 67                if (*timeout_ms > 0) {
 68                    --(*timeout_ms);
 69                }
 70            }
 71        }
 72
 73        LOG(ERROR) << "sys_prop: timeout waiting for uid " << cred_.uid
 74                   << " to send property message.";
 75        return false;
 76    }
 77	
 78    bool RecvFully(void* data_ptr, size_t size, uint32_t* timeout_ms) {
 79        size_t bytes_left = size;
 80        char* data = static_cast<char*>(data_ptr);
 81        while (*timeout_ms > 0 && bytes_left > 0) {
 82            //用于判断接收是否超时2s，这里是不允许超时的
 83            if (!PollIn(timeout_ms)) {
 84                return false;
 85            }
 86			//这里实际上是流的形式，所以或循环去读取的操作
 87            int result = TEMP_FAILURE_RETRY(recv(socket_, data, bytes_left, MSG_DONTWAIT));
 88            if (result <= 0) {
 89                PLOG(ERROR) << "sys_prop: recv error";
 90                return false;
 91            }
 92
 93            bytes_left -= result;
 94            data += result;
 95        }
 96
 97        if (bytes_left != 0) {
 98            LOG(ERROR) << "sys_prop: recv data is not properly obtained.";
 99        }
100
101        return bytes_left == 0;
102    }
103
104    unique_fd socket_;
105    ucred cred_;
106
107    DISALLOW_IMPLICIT_CONSTRUCTORS(SocketConnection);
108};

1 #include <sys/epoll.h>

 1//system/core/init/epoll.cpp
 2Result<void> Epoll::Open() {
 3    epoll_fd_.reset(epoll_create1(EPOLL_CLOEXEC));
 4    ...
 5}
 6
 7Result<void> Epoll::RegisterHandler(int fd, Handler handler, uint32_t events) {
 8    Info info;
 9    info.events = events;
10    info.handler = std::make_shared<decltype(handler)>(std::move(handler));
11    
12    auto [it, inserted] = epoll_handlers_.emplace(fd, std::move(info));
13    epoll_event ev;
14    ev.events = events;
15    ev.data.ptr = reinterpret_cast<void*>(&it->second);
16	epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &ev);
17}
18
19Result<std::vector<std::shared_ptr<Epoll::Handler>>> Epoll::Wait(
20        std::optional<std::chrono::milliseconds> timeout) {
21    int timeout_ms = -1;
22    
23    const auto max_events = epoll_handlers_.size();
24    epoll_event ev[max_events];
25    //默认无限阻塞，直到有EPOLLIN事件过来
26    auto num_events = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd_, ev, max_events, timeout_ms));
27    
28    std::vector<std::shared_ptr<Handler>> pending_functions;
29    for (int i = 0; i < num_events; ++i) {
30        //取出事件中的ptr，即对应的info指针
31        auto& info = *reinterpret_cast<Info*>(ev[i].data.ptr);
32        //将对应事件放入到数组中，通过数组来依次排队输出
33        pending_functions.emplace_back(info.handler);
34    }
35
36    return pending_functions;
37}

 1int listenfd = socket(PF_INET, SOCK_STREAM, 0);
 2bind(listenfd, (struct sockaddr*)&address, sizeof(address));
 3listen(listenfd, 5);
 4fd_set read_fds;
 5
 6for(int i = 0; i < 5; i++)
 7{
 8    fd[i] = accept(listenfd, (struct sockaddr*)&client, &addr_len);
 9    if (fd[i] > max)
10    {
11        max = fd[i];
12    }
13}
14while(1)
15{
16    FD_ZERO(&read_fds);
17    for(int i = 0; i < 5; i++)
18    {
19        FD_SET(fd[i], &read_fds);
20    }
21    //第一个参数是最大文件描述符+1，在内核遍历中限制长度，减少无谓的遍历
22    //第二个参数是读文件描述符集合
23    //第三个参数是写文件描述符集合
24    //第四个参数是异常事件文件描述符集合
25    //第五个参数是超时时间，NULL是永不超时一直阻塞，直到有数据
26    //服务端主要需要读文件描述符集合
27    ret = select(max + 1, &read_fds, NULL, NULL, NULL);
28    for (int i = 0; i < 5; i++)
29    {
30        if (FD_ISSET(fd[i], &read_fds))
31        {
32            ret = recv(fd[i], buff, sizeof(buff) - 1, 0);
33        }
34    }
35}

1struct pollfd {
2    int fd; 			/*文件描述符*/
3    short events; 		/*注册的事件*/
4    short revents; 		/*实际发生的事件，由内核填充*/
5};

 1int sscfd = socket(PF_INET, SOCK_STREAM, 0);
 2bind(sscfd, (struct sockaddr*)&address, sizeof(address));
 3listen(sscfd, 4);
 4struct pollfd fds[4];
 5for(int i = 0; i < 4; i++)
 6{
 7    fds[i].fd = accept(sscfd, (struct sockaddr*)&cliAddr, &addrLen);
 8    fd[i].events = POLLIN;
 9}
10sleep(1);
11while(1)
12{
13    //第一个参数，fds就是传入的文件描述符的结构体数组
14    //第二个参数，就是这个结构体数组最大长度
15    //第三个参数，阻塞等待时间
16    ret = poll(fds, 4, 4000);
17    for(int i = 0; i < 4; i++)
18    {
19        if(fds[i].revents & POLLIN)
20        {
21            fds[i].revents = 0;
22            ret = recv(fds[i].fd, buff, sizeof(buff) - 1, 0);
23		}
24    }
25}

 1int sscfd = socket(PF_INET, SOCK_STREAM, 0);
 2bind(sscfd, (struct sockaddr*)&address, sizeof(address));
 3listen(sscfd, 4);
 4struct epoll_event events[5];
 5//内核会去创建eventpoll结构体
 6//eventpoll中有三个重要字段
 7//rdyList已就绪的文件描述双链表
 8//rbr就是一颗红黑树，用红黑树去管理用户进程放进来的所有socket连接
 9//wq为等待队列，当某个进程他需要关注的事件未就绪的时候，就会把当前进程的描述符和回调函数放到进程等待队列中去
10int epoll_fd = epoll_create(5);
11for (int i = 0; i < 5; i++)
12{
13    struct epoll_event event;
14    event.data.fd = accept(sscfd, (struct sockaddr*)&cliAddr, &addrLen);
15    //将对应事件注册到eventpoll中
16    event.events = EPOLLIN;
17    //每个socket连接在epoll_ctl后会分配一个epitem
18    //
19    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, event.data.fd, &event);
20}
21
22while (1)
23{
24    //检查内核中的双链表是否有就绪的事件，存在事件立刻返回
25    int ret = epoll_wait(epoll_fd, events, 5, 2000);
26    for (int i = 0; i < ret; i++)
27    {
28        if (events[i].events & EPOLLIN)
29        {
30            recv(sockfd, buf, BUFFER_SIZE - 1, 0);
31        }
32    }
33}

 1struct union epoll_data {
 2    void *ptr;
 3    int fd;
 4    __uint32_t u32;
 5    __uint64_t u64;
 6} epoll_data_t;
 7
 8struct epoll_event {
 9    __uint32_t events;
10    epoll_data_t data;
11};

1//有很多fd都支持，这里列举几个常用的：
2./fs/notify/fanotify/fanotify_user.c-520- .poll = fanotify_poll,
3./fs/notify/inotify/inotify_user.c-322- .poll = inotify_poll,
4./fs/proc/inode.c-404- .poll = proc_reg_poll,
5./fs/signalfd.c-258- .poll = signalfd_poll,
6./fs/timerfd.c-370- .poll = timerfd_poll,
7./fs/userfaultfd.c-1928- .poll = userfaultfd_poll,
8./ipc/mqueue.c-1632- .poll = mqueue_poll_file,
9./net/socket.c-154- .poll = sock_poll,