epoll · select · poll —
I/O multiplexing.

#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

/* non-blocking read örneği */
char buf[4096];
ssize_t n = read(fd, buf, sizeof(buf));
if (n == -1) {
    if (errno == EAGAIN || errno == EWOULDBLOCK) {
        /* veri yok — daha sonra tekrar dene */
    } else {
        /* gerçek hata */
    }
}

#include <sys/select.h>

/* fd_set işlemleri */
FD_ZERO(&set);          /* seti sıfırla */
FD_SET(fd, &set);       /* fd'yi sete ekle */
FD_CLR(fd, &set);       /* fd'yi setten çıkar */
FD_ISSET(fd, &set);     /* fd sette mi? */

/* imza */
int select(int nfds,                  /* izlenecek en büyük fd + 1 */
           fd_set *readfds,            /* okuma izlenenler */
           fd_set *writefds,           /* yazma izlenenler */
           fd_set *exceptfds,          /* istisna (nadiren kullanılır) */
           struct timeval *timeout);   /* NULL = sonsuz bekle */

/* gcc -o select-stdin select-stdin.c */
#include <stdio.h>
#include <sys/select.h>
#include <unistd.h>

int main(void) {
    fd_set readfds;
    struct timeval tv;
    char buf[256];

    while (1) {
        /* DİKKAT: select() her çağrıda fd_set'i modifiye eder — her seferinde yeniden doldur */
        FD_ZERO(&readfds);
        FD_SET(STDIN_FILENO, &readfds);

        /* 3 saniye timeout */
        tv.tv_sec  = 3;
        tv.tv_usec = 0;

        int ret = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &tv);

        if (ret == -1) {
            perror("select");
            break;
        } else if (ret == 0) {
            printf("timeout — giriş yok\n");
        } else if (FD_ISSET(STDIN_FILENO, &readfds)) {
            ssize_t n = read(STDIN_FILENO, buf, sizeof(buf) - 1);
            if (n <= 0) break;
            buf[n] = '\0';
            printf("okunan: %s", buf);
        }
    }
    return 0;
}

# FD_SETSIZE değerini kontrol et
grep 'FD_SETSIZE' /usr/include/bits/typesizes.h
# #define FD_SETSIZE 1024

# fd sayısını artırmak için derleme zamanında override (taşınabilir değil)
gcc -DFD_SETSIZE=4096 myserver.c -o myserver
# ama bu kernel ABI'ını kırar — önerilmez

#include <poll.h>

struct pollfd {
    int   fd;       /* izlenecek fd */
    short events;   /* izlenecek olaylar (giriş) */
    short revents;  /* gerçekleşen olaylar (çıkış — kernel doldurur) */
};

int poll(struct pollfd *fds,   /* fd dizisi */
         nfds_t nfds,           /* dizi eleman sayısı */
         int timeout);          /* ms cinsinden, -1 = sonsuz */

/* gcc -o poll-multi poll-multi.c */
#include <stdio.h>
#include <poll.h>
#include <unistd.h>
#include <string.h>

int main(void) {
    /* stdin ve bir pipe fd'sini aynı anda izle */
    int pipefd[2];
    pipe(pipefd);

    struct pollfd fds[2] = {
        { .fd = STDIN_FILENO, .events = POLLIN },
        { .fd = pipefd[0],   .events = POLLIN },
    };

    /* pipe'a asenkron veri yaz (gerçek senaryoda başka thread/process) */
    write(pipefd[1], "pipe verisi\n", 12);

    int ret = poll(fds, 2, 3000); /* 3 saniye timeout */
    if (ret <= 0) {
        puts(ret == 0 ? "timeout" : "poll hatası");
        return 1;
    }

    char buf[256];
    for (int i = 0; i < 2; i++) {
        if (fds[i].revents & POLLIN) {
            ssize_t n = read(fds[i].fd, buf, sizeof(buf) - 1);
            buf[n] = '\0';
            printf("fd[%d] okunan: %s", i, buf);
        }
        if (fds[i].revents & POLLHUP) {
            printf("fd[%d] kapandı\n", i);
        }
    }

    close(pipefd[0]); close(pipefd[1]);
    return 0;
}

#include <sys/epoll.h>

/* epoll instance oluştur — epfd döner (bir fd) */
int epfd = epoll_create1(0);
/* EPOLL_CLOEXEC flag'i: exec() sonrası fd otomatik kapanır */
int epfd = epoll_create1(EPOLL_CLOEXEC);

/* fd'yi epoll'a ekle / değiştir / çıkar */
struct epoll_event ev;
ev.events   = EPOLLIN;  /* izlenecek olaylar */
ev.data.fd  = fd;       /* geri dönüşte tanımlama için veri */

epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);  /* ekle */
epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);  /* güncelle */
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL); /* çıkar */

/* hazır olayları bekle */
struct epoll_event events[64];
int n = epoll_wait(epfd, events, 64, -1); /* -1 = sonsuz bekle */
/* n: hazır fd sayısı, events[0..n-1] dolu */

struct epoll_event {
    uint32_t events;   /* EPOLLIN, EPOLLOUT, EPOLLERR, EPOLLHUP, EPOLLET ... */
    epoll_data_t data; /* kullanıcı verisi — union */
};

typedef union epoll_data {
    void    *ptr;  /* struct pointer — bağlam taşıma için */
    int      fd;   /* sadece fd numarası */
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

/* gcc -o epoll-echo epoll-echo-skeleton.c */
#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#define PORT      8080
#define MAX_EVENTS 64

static int make_listen_socket(int port);
static int set_nonblocking(int fd);

int main(void) {
    int listen_fd = make_listen_socket(PORT);
    set_nonblocking(listen_fd);

    int epfd = epoll_create1(EPOLL_CLOEXEC);

    struct epoll_event ev = { .events = EPOLLIN, .data.fd = listen_fd };
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);

    struct epoll_event events[MAX_EVENTS];

    printf("dinleniyor: port %d\n", PORT);

    while (1) {
        int n = epoll_wait(epfd, events, MAX_EVENTS, -1);
        for (int i = 0; i < n; i++) {
            int fd = events[i].data.fd;

            if (fd == listen_fd) {
                /* yeni bağlantı kabul et */
                int conn = accept(listen_fd, NULL, NULL);
                if (conn == -1) continue;
                set_nonblocking(conn);
                ev.events  = EPOLLIN;
                ev.data.fd = conn;
                epoll_ctl(epfd, EPOLL_CTL_ADD, conn, &ev);
            } else {
                /* istemciden veri */
                char buf[4096];
                ssize_t r = read(fd, buf, sizeof(buf));
                if (r <= 0) {
                    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    close(fd);
                } else {
                    write(fd, buf, r); /* echo */
                }
            }
        }
    }
}

static int make_listen_socket(int port) {
    int fd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
    int opt = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port = htons(port),
    };
    bind(fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(fd, SOMAXCONN);
    return fd;
}

static int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

/* ET modunda EPOLLIN geldiğinde çağrılır */
void handle_epollin_et(int fd) {
    char buf[4096];
    ssize_t total = 0;

    while (1) {
        ssize_t n = read(fd, buf, sizeof(buf));

        if (n == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                /* buffer boşaldı — döngüyü bitir, epoll_wait'e dön */
                break;
            }
            /* gerçek hata */
            perror("read");
            break;
        }
        if (n == 0) {
            /* bağlantı kapandı (EOF) */
            close(fd);
            break;
        }

        total += n;
        /* veriyi işle */
        write(fd, buf, n); /* echo */
    }
    printf("toplam okunan: %zd byte\n", total);
}

/* epoll_ctl ile ET modunda ekle */
struct epoll_event ev = {
    .events  = EPOLLIN | EPOLLET,  /* edge-triggered */
    .data.fd = client_fd,
};
epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);

#include <sys/epoll.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define BUF_SIZE 8192

/* bağlantı başına state yapısı */
typedef struct {
    int    fd;
    char   buf[BUF_SIZE];
    int    buf_len;
    int    bytes_sent;
    int    state;    /* 0=reading, 1=writing, 2=closing */
} conn_state_t;

conn_state_t* conn_new(int fd) {
    conn_state_t *c = calloc(1, sizeof(conn_state_t));
    c->fd = fd;
    return c;
}

void conn_free(conn_state_t *c) {
    if (c) { close(c->fd); free(c); }
}

/* yeni bağlantıyı epoll'a ptr ile ekle */
void add_conn(int epfd, int client_fd) {
    conn_state_t *c = conn_new(client_fd);
    struct epoll_event ev = {
        .events   = EPOLLIN | EPOLLET,
        .data.ptr = c,   /* fd yerine struct pointer */
    };
    epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);
}

/* event loop içinde bağlamı geri al */
void process_event(struct epoll_event *ev) {
    conn_state_t *c = (struct conn_state_t *)ev->data.ptr;

    if (ev->events & EPOLLIN) {
        ssize_t n = read(c->fd, c->buf + c->buf_len,
                          BUF_SIZE - c->buf_len);
        if (n > 0) {
            c->buf_len += n;
            /* protokol işleme buraya gelir */
        } else if (n == 0 || (n == -1 && errno != EAGAIN)) {
            conn_free(c);
        }
    }
}

/* gcc -o epoll-server epoll-server.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT       8080
#define MAX_EVENTS 128
#define BUF_SIZE   4096

static int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

static int create_listen_socket() {
    int fd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
    if (fd == -1) { perror("socket"); exit(1); }

    int opt = 1;
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

    struct sockaddr_in addr = {
        .sin_family      = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port        = htons(PORT),
    };
    if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("bind"); exit(1);
    }
    if (listen(fd, SOMAXCONN) == -1) {
        perror("listen"); exit(1);
    }
    return fd;
}

static void handle_accept(int epfd, int listen_fd) {
    while (1) {
        struct sockaddr_in client_addr;
        socklen_t addrlen = sizeof(client_addr);

        /* accept4: atomik olarak non-blocking + cloexec ayarla */
        int conn = accept4(listen_fd,
                            (struct sockaddr*)&client_addr,
                            &addrlen,
                            SOCK_NONBLOCK | SOCK_CLOEXEC);

        if (conn == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                break;  /* bekleyen bağlantı kalmadı */
            if (errno == EINTR)
                continue;  /* sinyal tarafından kesildi, tekrar dene */
            perror("accept4");
            break;
        }

        char ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &client_addr.sin_addr, ip, sizeof(ip));
        printf("yeni bağlantı: %s:%d (fd=%d)\n",
               ip, ntohs(client_addr.sin_port), conn);

        struct epoll_event ev = {
            .events  = EPOLLIN | EPOLLET | EPOLLRDHUP,
            .data.fd = conn,
        };
        if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn, &ev) == -1) {
            perror("epoll_ctl add conn");
            close(conn);
        }
    }
}

static void handle_client(int epfd, struct epoll_event *ev) {
    int fd = ev->data.fd;

    if (ev->events & (EPOLLHUP | EPOLLRDHUP | EPOLLERR)) {
        printf("bağlantı kapandı: fd=%d\n", fd);
        epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
        close(fd);
        return;
    }

    if (ev->events & EPOLLIN) {
        char buf[BUF_SIZE];
        while (1) {
            ssize_t n = read(fd, buf, sizeof(buf));
            if (n == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                    break;  /* buffer boşaldı */
                if (errno == ECONNRESET) {
                    printf("bağlantı sıfırlandı: fd=%d\n", fd);
                    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    close(fd);
                    return;
                }
                perror("read"); break;
            }
            if (n == 0) {
                /* EOF — bağlantı düzgün kapandı */
                epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                close(fd);
                return;
            }
            /* echo: okunanı geri yaz */
            ssize_t sent = 0;
            while (sent < n) {
                ssize_t w = write(fd, buf + sent, n - sent);
                if (w <= 0) break;
                sent += w;
            }
        }
    }
}

int main(void) {
    int listen_fd = create_listen_socket();
    set_nonblocking(listen_fd);

    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) { perror("epoll_create1"); exit(1); }

    struct epoll_event ev = {
        .events  = EPOLLIN | EPOLLET,
        .data.fd = listen_fd,
    };
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);

    struct epoll_event events[MAX_EVENTS];
    printf("epoll echo server başladı, port %d\n", PORT);

    while (1) {
        int n = epoll_wait(epfd, events, MAX_EVENTS, -1);
        if (n == -1) {
            if (errno == EINTR) continue; /* sinyal */
            perror("epoll_wait"); break;
        }
        for (int i = 0; i < n; i++) {
            if (events[i].data.fd == listen_fd)
                handle_accept(epfd, listen_fd);
            else
                handle_client(epfd, &events[i]);
        }
    }
    close(epfd);
    close(listen_fd);
    return 0;
}

import asyncio
import selectors

# çalışan selector tipini doğrula
loop = asyncio.get_event_loop()
print(type(loop._selector))
# <class 'selectors.EpollSelector'>  (Linux'ta)

# EpollSelector'ın altındaki epoll fd'sini al
selector = loop._selector
print(selector._epoll)
# <select.epoll object at 0x...>

import asyncio

async def handle_client(reader: asyncio.StreamReader,
                        writer: asyncio.StreamWriter):
    addr = writer.get_extra_info('peername')
    print(f"bağlantı: {addr}")

    try:
        while True:
            # await → coroutine askıya alınır, event loop epoll ile bekler
            data = await reader.read(4096)
            if not data:
                break
            writer.write(data)         # buffer'a yaz
            await writer.drain()       # kernel buffer'ı boşalana kadar bekle
    except (asyncio.CancelledError, ConnectionResetError):
        pass
    finally:
        writer.close()
        await writer.wait_closed()
        print(f"kapatıldı: {addr}")

async def main():
    server = await asyncio.start_server(
        handle_client, '0.0.0.0', 8080
    )
    async with server:
        await server.serve_forever()

asyncio.run(main())

import asyncio

async def tcp_client():
    reader, writer = await asyncio.open_connection('127.0.0.1', 8080)

    writer.write(b"merhaba\n")
    await writer.drain()

    data = await reader.readline()
    print(f"yanıt: {data.decode()!r}")

    writer.close()
    await writer.wait_closed()

asyncio.run(tcp_client())

/* macOS / FreeBSD — Linux'ta derlenmez */
#include <sys/event.h>
#include <unistd.h>

int main(void) {
    int kq = kqueue();           /* epoll_create1 gibi */

    struct kevent change;
    /* EV_SET: fd, filter, flags, fflags, data, udata */
    EV_SET(&change, STDIN_FILENO, EVFILT_READ, EV_ADD | EV_ENABLE,
           0, 0, NULL);

    kevent(kq, &change, 1, NULL, 0, NULL);  /* ekle */

    struct kevent events[16];
    int n = kevent(kq, NULL, 0, events, 16, NULL);  /* bekle */

    for (int i = 0; i < n; i++) {
        if (events[i].filter == EVFILT_READ)
            printf("fd %lu okumaya hazır\n", events[i].ident);
    }

    close(kq);
    return 0;
}

/* gcc -o io-uring-echo io-uring-echo.c -luring */
#include <liburing.h>
#include <stdio.h>
#include <unistd.h>

#define QUEUE_DEPTH 64

int main(void) {
    struct io_uring ring;
    int ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
    if (ret) { perror("io_uring_queue_init"); return 1; }

    char buf[256];

    /* submission queue'ya async read isteği ekle */
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_read(sqe, STDIN_FILENO, buf, sizeof(buf), 0);
    io_uring_sqe_set_data64(sqe, 1); /* kullanıcı veri = 1 */

    io_uring_submit(&ring);  /* tek syscall: tüm pending SQE'leri gönder */

    /* completion queue'dan sonuç al */
    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe);

    if (cqe->res > 0) {
        buf[cqe->res] = '\0';
        printf("okunan: %s", buf);
    }

    io_uring_cqe_seen(&ring, cqe);  /* CQE'yi tüketildi olarak işaretle */
    io_uring_queue_exit(&ring);
    return 0;
}