epoll.h 文件参考

浏览源代码.

结构体
union	epoll_data
struct	epoll_event

类型定义
typedef union epoll_data	epoll_data_t

函数
int	epoll_create1 (int flags)
int	epoll_close (int epfd)
int	epoll_ctl (int epfd, int op, int fd, struct epoll_event *ev)
int	epoll_wait (int epfd, FAR struct epoll_event *evs, int maxevents, int timeout)

类型定义说明

epoll_data_t

typedef union epoll_data epoll_data_t

函数说明

epoll_close()

int epoll_close

(

int

epfd

)

epoll_close, called by close

参数

epfd

epoll fd

返回

0 or -1

在文件 fs_epoll.c 第 219 行定义.

{
    struct epoll_head *epHead = NULL;
 
    epHead = EpollGetDataBuff(epfd);
    if (epHead == NULL) {
        set_errno(EBADF);
        return -1;
    }
 
    DoEpollClose(epHead);
    return EpollFreeSysFd(epfd);
}

函数调用图:

这是这个函数的调用关系图:

epoll_create1()

int epoll_create1

(

int

flags

)

epoll_create unsupported api

epoll_create is implemented by calling epoll_create1, it's parameter 'size' is useless.

epoll_create1, The simple version of epoll does not use red-black trees, so when fd is normal value (greater than 0), actually allocated epoll can manage num of EPOLL_DEFAULT_SIZE

参数

flags

not actually used

返回

epoll fd

在文件 fs_epoll.c 第 179 行定义.

{
    (void)flags;
    int fd = -1;
 
    struct epoll_head *epHead = (struct epoll_head *)malloc(sizeof(struct epoll_head));
    if (epHead == NULL) {
        set_errno(ENOMEM);
        return fd;
    }
 
    /* actually allocated epoll can manage num is EPOLL_DEFAULT_SIZE */
    epHead->size = EPOLL_DEFAULT_SIZE;
    epHead->nodeCount = 0;
    epHead->evs = malloc(sizeof(struct epoll_event) * EPOLL_DEFAULT_SIZE);
    if (epHead->evs == NULL) {
        free(epHead);
        set_errno(ENOMEM);
        return fd;
    }
 
    /* fd set, get sysfd, for close */
    (VOID)pthread_mutex_lock(&g_epollMutex);
    fd = EpollAllocSysFd(MAX_EPOLL_FD, epHead);
    if (fd == -1) {
        (VOID)pthread_mutex_unlock(&g_epollMutex);
        DoEpollClose(epHead);
        set_errno(EMFILE);
        return fd;
    }
    (VOID)pthread_mutex_unlock(&g_epollMutex);
    return fd;
}

函数调用图:

这是这个函数的调用关系图:

epoll_ctl()

int epoll_ctl	(	int	epfd,
		int	op,
		int	fd,
		struct epoll_event *	ev
	)

在文件 fs_epoll.c 第 233 行定义.

{
    struct epoll_head *epHead = NULL;
    int i;
    int ret = -1;
 
    epHead = EpollGetDataBuff(epfd);
    if (epHead == NULL) {
        set_errno(EBADF);
        return ret;
    }
 
    if (ev == NULL) {
        set_errno(EINVAL);
        return -1;
    }
 
    switch (op) {
        case EPOLL_CTL_ADD:
            ret = CheckFdExist(epHead, fd);
            if (ret == -1) {
                set_errno(EEXIST);
                return -1;
            }
 
            if (epHead->nodeCount == EPOLL_DEFAULT_SIZE) {
                set_errno(ENOMEM);
                return -1;
            }
 
            epHead->evs[epHead->nodeCount].events = ev->events | POLLERR | POLLHUP;
            epHead->evs[epHead->nodeCount].data.fd = fd;
            epHead->nodeCount++;
            return 0;
        case EPOLL_CTL_DEL:
            for (i = 0; i < epHead->nodeCount; i++) {
                if (epHead->evs[i].data.fd != fd) {
                    continue;
                }
 
                if (i != epHead->nodeCount - 1) {
                    memmove_s(&epHead->evs[i], epHead->nodeCount - i, &epHead->evs[i + 1],
                              epHead->nodeCount - i);
                }
                epHead->nodeCount--;
                return 0;
            }
            set_errno(ENOENT);
            return -1;
        case EPOLL_CTL_MOD:
            for (i = 0; i < epHead->nodeCount; i++) {
                if (epHead->evs[i].data.fd == fd) {
                    epHead->evs[i].events = ev->events | POLLERR | POLLHUP;
                    return 0;
                }
            }
            set_errno(ENOENT);
            return -1;
        default:
            set_errno(EINVAL);
            return -1;
    }
}

函数调用图:

这是这个函数的调用关系图:

epoll_wait()

int epoll_wait	(	int	epfd,
		FAR struct epoll_event *	evs,
		int	maxevents,
		int	timeout
	)

在文件 fs_epoll.c 第 297 行定义.

{
    struct epoll_head *epHead = NULL;
    int ret;
    int counter;
    int i;
    struct pollfd *pFd = NULL;
    int pollSize;
 
    epHead = EpollGetDataBuff(epfd);
    if (epHead== NULL) {
        set_errno(EBADF);
        return -1;
    }
 
    if ((maxevents <= 0) || (evs == NULL)) {
        set_errno(EINVAL);
        return -1;
    }
 
    if (maxevents > epHead->nodeCount) {
        pollSize = epHead->nodeCount;
    } else {
        pollSize = maxevents;
    }
 
    pFd = malloc(sizeof(struct pollfd) * pollSize);
    if (pFd == NULL) {
        set_errno(EINVAL);
        return -1;
    }
 
    for (i = 0; i < epHead->nodeCount; i++) {
        pFd[i].fd = epHead->evs[i].data.fd;
        pFd[i].events = (short)epHead->evs[i].events;
    }
 
 
    ret = poll(pFd, pollSize, timeout);
    if (ret <= 0) {
        free(pFd);
        return 0;
    }
 
    for (i = 0, counter = 0; i < ret && counter < pollSize; counter++) {
        if (pFd[counter].revents != 0) {
            evs[i].data.fd = pFd[counter].fd;
            evs[i].events  = pFd[counter].revents;
            i++;
        }
    }
 
    free(pFd);
    return i;
}

函数调用图:

这是这个函数的调用关系图: