demikernel 1.5.13

Kernel-Bypass LibOS Architecture
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

#include "../epoll.h"
#include <assert.h>

struct epoll_table
{
    int used;
    int head;
    int tail;
    struct demi_event events[MAX_EVENTS];
};

static struct epoll_table epoll_table[EPOLL_MAX_FDS];

int epoll_table_alloc(void)
{
    for (int i = 0; i < EPOLL_MAX_FDS; i++)
    {
        if (epoll_table[i].used == 0)
        {
            epoll_table[i].used = 1;
            return i;
        }
    }

    return -1;
}

void epoll_table_init(void)
{
    for (int i = 0; i < EPOLL_MAX_FDS; i++)
    {
        epoll_table[i].used = 0;
        epoll_table[i].head = 0;
        epoll_table[i].tail = 0;
        for (int j = 0; j < MAX_EVENTS; j++)
        {
            /* We use an empty element in the start of the list, to
               make the checks for insertion and deletion simpler, thus
               mark the first element as being used. */
            epoll_table[i].events[j].used = j == 0? 1 : 0;

            epoll_table[i].events[j].id = j;
            epoll_table[i].events[j].qt = -1;
            epoll_table[i].events[j].next_ev = INVALID_EV;
            epoll_table[i].events[j].prev_ev = INVALID_EV;
        }
    }
}

int epoll_get_ready(int epfd, demi_qtoken_t *qts, struct demi_event **evs)
{
    int nevents = 0;

    struct demi_event *ev = epoll_get_head(epfd);
    while (ev != NULL)
    {
        if ((ev->used) && (ev->qt != (demi_qtoken_t)-1))
        {
            qts[nevents] = ev->qt;
            evs[nevents] = ev;
            nevents++;
        }

        ev = epoll_get_next(epfd, ev);
    }

    return nevents;
}

struct demi_event *epoll_get_event(int epfd, int i)
{
    assert(epoll_table[epfd].used == 1);
    return (&epoll_table[epfd].events[i]);
}

struct demi_event *epoll_get_head(int epfd)
{
    assert(epoll_table[epfd].used == 1);

    if (epoll_table[epfd].head == INVALID_EV)
        return NULL;

    return (&epoll_table[epfd].events[epoll_table[epfd].head]);
}

struct demi_event *epoll_get_tail(int epfd)
{
    assert(epoll_table[epfd].used == 1);

    if (epoll_table[epfd].tail == INVALID_EV)
        return NULL;

    return (&epoll_table[epfd].events[epoll_table[epfd].tail]);
}

void epoll_set_head(int epfd, int i)
{
    assert(epoll_table[epfd].used == 1);

    epoll_table[epfd].head = i;
}

void epoll_set_tail(int epfd, int i)
{
    assert(epoll_table[epfd].used == 1);

    epoll_table[epfd].tail = i;
}

struct demi_event *epoll_get_next(int epfd, struct demi_event *ev)
{
    if (ev == NULL || ev->next_ev == INVALID_EV)
        return NULL;

    int i = ev->next_ev;

    return (epoll_get_event(epfd, i));
}

struct demi_event *epoll_get_prev(int epfd, struct demi_event *ev)
{
    if (ev == NULL || ev->prev_ev == INVALID_EV)
        return NULL;

    int i = ev->prev_ev;

    return (epoll_get_event(epfd, i));
}