fs_epoll.c 文件参考

浏览源代码.

结构体
struct	epoll_head

函数
static int	EpollAllocSysFd (int maxfdp, struct epoll_head *head)
static int	EpollFreeSysFd (int fd)
static struct epoll_head *	EpollGetDataBuff (int fd)
static int	CheckFdExist (struct epoll_head *epHead, int fd)
static VOID	DoEpollClose (struct epoll_head *epHead)
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)

变量
STATIC pthread_mutex_t	g_epollMutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
STATIC fd_set	g_epollFdSet
STATIC struct epoll_head *	g_epPrivBuf [MAX_EPOLL_FD]

函数说明

CheckFdExist()

static int CheckFdExist ( struct epoll_head *  epHead, int  fd  )

static

when do EPOLL_CTL_ADD, need check if fd exist

参数

epHead	epoll control head, find by epoll id .
fd	ctl add fd.

返回

0 or -1

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

{
    int i;
    for (i = 0; i < epHead->nodeCount; i++) {
        if (epHead->evs[i].data.fd == fd) {
            return -1;
        }
    }
 
    return 0;
}

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

DoEpollClose()

static VOID DoEpollClose ( struct epoll_head *  epHead )

static

close epoll

参数

epHead

epoll control head.

返回

void

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

{
    if (epHead != NULL) {
        if (epHead->evs != NULL) {
            free(epHead->evs);
        }
 
        free(epHead);
    }
 
    return;
}

函数调用图:

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

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;
}

函数调用图:

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

EpollAllocSysFd()

static int EpollAllocSysFd ( int  maxfdp, struct epoll_head *  head  )

static

Alloc sysFd, storage epoll private data, set using bit.

参数

maxfdp	Maximum allowed application of sysFd.
head	Private data.

返回

the index of the new fd; -1 on error

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

{
    int i;
 
    fd_set *fdset = &g_epollFdSet;
 
    for (i = 0; i < maxfdp; i++) {
        if (fdset && !(FD_ISSET(i, fdset))) {
            FD_SET(i, fdset);
            if (!g_epPrivBuf[i]) {
                g_epPrivBuf[i] = head;
                return i + EPOLL_FD_OFFSET;
            }
        }
    }
 
    set_errno(EMFILE);
    return -1;
}

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

EpollFreeSysFd()

static int EpollFreeSysFd ( int  fd )

static

free sysFd, delete epoll private data, clear using bit.

参数

fd

epoll fd.

返回

0 or -1

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

{
    int efd = fd - EPOLL_FD_OFFSET;
 
    if ((efd < 0) || (efd >= MAX_EPOLL_FD)) {
        set_errno(EMFILE);
        return -1;
    }
 
    fd_set *fdset = &g_epollFdSet;
    if (fdset && FD_ISSET(efd, fdset)) {
        FD_CLR(efd, fdset);
        g_epPrivBuf[efd] = NULL;
    }
 
    return 0;
}

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

EpollGetDataBuff()

static struct epoll_head * EpollGetDataBuff ( int  fd )

static

get private data by epoll fd

参数

fd

epoll fd.

返回

point to epoll_head

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

{
    int id = fd - EPOLL_FD_OFFSET;
 
    if ((id < 0) || (id >= MAX_EPOLL_FD)) {
        return NULL;
    }
 
    return g_epPrivBuf[id];
}

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

变量说明

g_epollFdSet

STATIC fd_set g_epollFdSet

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

g_epollMutex

STATIC pthread_mutex_t g_epollMutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP

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

g_epPrivBuf

STATIC struct epoll_head* g_epPrivBuf[MAX_EPOLL_FD]

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