Logical Address =(Segmentation)=> Linear Address =(Paging)=> Physical Address

             Logical Address
             (or Far Pointer)
         +---------------------+
         v                     v                                                          Linear Address
+------------------+ +------------------+    Linear Address                          +-----+-------+--------+         Physical Address
| Segment Selector | |      Offset      |        Space                   +---------->| Dir | Table | Offset |               Space
+--------+---------+ +---------+--------+  +----------------+            |           +--+--+---+---+----+---+       +------------------+
         |                     |           |                |            |              |      |        |           |                  |
         |                     |           |                |            |              |      |        +--------+  +- - - - - - - - - +<-+ Page
         |  Global Descriptor  +--+        |                |            |              |      |   Page Table    |  +------------------+  |
         |     Table (GDT)        |        +================+<-+ Segment |              |      |  +-----------+ ++->| Physical Address |  |
         |  +---------------+     |        |                |  |         |  +-----------+      |  |           | |   +------------------+  |
         |  |               |     |        +----------------+<----+ Page |  |  Page Directory  |  +-----------+ |   |                  |  |
         |  +---------------+     |        |                |  |  |      |  |  +------------+ ++->|   Entry   |-+-->+ - - - - - - - - -+<-+
         |  |    Segment    |     |        +- - - - - - - - +  |  |      |  |  |            | |   +-----------+     |                  |
         |  |  Descriptor   +-+   |  +---->| Linear Address +------------+  |  +------------+ |   |           |     |                  |
         +->+---------------+ |   +->|     + - - - - - - - -+  |  |         +->|    Entry   |-+-->+-----------+     |                  |
            |               | |      |     +----------------+<----+            +------------+                       |                  |
            |               | +------+---->+================+<-+               |            |                       |                  |
            +---------------+   Segment    |                |                  +------------+                       |                  |
                              Base Address |                |                                                       +------------------+
                                           +----------------+

|------------------------- Segmentation ---------------------------|------------------------------- Paging ---------------------------------|

       #include <sys/epoll.h>

       int epoll_create(int size);
       int epoll_create1(int flags);

       #include <sys/epoll.h>

       int epoll_ctl(int epfd, int op, int fd,
                     struct epoll_event *_Nullable event);

       #include <sys/epoll.h>

       struct epoll_event {
           uint32_t      events;  /* Epoll events */
           epoll_data_t  data;    /* User data variable */
       };

       union epoll_data {
           void     *ptr;
           int       fd;
           uint32_t  u32;
           uint64_t  u64;
       };

       typedef union epoll_data  epoll_data_t;

$ ./server
=== evt #0 ===
new conection #5
=== evt #0 ===
new conection #6
=== evt #0 ===
new conection #7
=== evt #0 ===
new conection #8
=== evt #0 ===
new conection #9
=== evt #0 ===
connection closed by peer #5
=== evt #1 ===
echo #6: Hello, this is client #1.
=== evt #0 ===
echo #7: Hello, this is client #2.
=== evt #0 ===
echo #8: Hello, this is client #3. Sending
=== evt #0 ===
echo #8:  a message longer than buffer siz
=== evt #0 ===
echo #8: e on the server side!
=== evt #0 ===
connection closed by peer #8
=== evt #1 ===
read(): Connection reset by peer
=== evt #2 ===
connection closed by peer #6
=== evt #3 ===
connection closed by peer #9

$ python3 client.py
Got a message on client #1: b'Hello, this is client #1.'
Got a message on client #3: b'Hello, this is client #3. Sending'
Got a message on client #3: b' a message longer than buffer siz'
Got a message on client #3: b'e on the server side!'

#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SERV_PORT 11111
#define BACKLOG 10
#define MAXEVTS 10
#define BUFSIZE 32


void die(const char *msg)
{
    perror(msg);
    exit(EXIT_FAILURE);
}

int setup_listener_socket() {
    int sock, ret, optval;
    struct sockaddr_in addr;

    // create a socket.
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if (sock < 0)
        die("socket()");

    // allow to reuse port.
    optval = 1;
    ret = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
    if (ret < 0) {
        close(sock);
        die("setsockopt()");
    }

    // construct a socket address.
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(SERV_PORT);

    // bind the address to the socket.
    ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0) {
        close(sock);
        die("bind()");
    }

    // listen on the socket.
    ret = listen(sock, BACKLOG);
    if (ret < 0) {
        close(sock);
        die("listen()");
    }

    return sock;
}

int get_client_socket(int listener) {
    int sock, flags;
    socklen_t len;
    struct sockaddr_in addr;

    // accept a new connection.
    sock = accept(listener, (struct sockaddr *)&addr, &len);
    if (sock < 0) {
        perror("accept()");
        return -1;
    }

    // set non-blocking
    flags = fcntl(sock, F_GETFL, 0);
    fcntl(sock, F_SETFL, flags | O_NONBLOCK);

    return sock;
}

int main()
{
    int epollfd, listener, i, nfds, client, rd, wr, sent;
    struct epoll_event evt, evts[MAXEVTS];
    char buffer[BUFSIZE + 1];

    // create an epoll instance.
    epollfd = epoll_create1(0);
    if (epollfd < 0)
        die("epoll_create1()");

    // set up a listener socket.
    listener = setup_listener_socket();

    // register 'read' event for the listener socket.
    memset(&evt, 0, sizeof(evt));
    // evt.events = EPOLLIN | EPOLLET;
    evt.events = EPOLLIN;
    evt.data.fd = listener;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, listener, &evt);

    for (;;) {
        // wait for events available on the epoll instance.
        nfds = epoll_wait(epollfd, evts, MAXEVTS, -1);

        for (i = 0; i < nfds; i++) {
            printf("=== evt #%d ===\n", i);
            if (evts[i].data.fd == listener) {
                // new connection requested.
                client = get_client_socket(listener);
                if (client < 0)
                    continue;
                printf("new conection #%d\n", client);

                // register 'read' event for the client socket.
                memset(&evt, 0, sizeof(evt));
                evt.events = EPOLLIN;
                evt.data.fd = client;
                epoll_ctl(epollfd, EPOLL_CTL_ADD, client, &evt);
            } else {
                // message received on client sockets
                client = evts[i].data.fd;

                rd = read(client, buffer, sizeof(buffer));
                if (rd > 0) {
                    sent = 0;
                    do {
                        wr = write(client, buffer + sent, rd - sent);
                        if (wr < 0) {
                            perror("write()");
                            epoll_ctl(epollfd, EPOLL_CTL_DEL, client, &evt);
                            close(client);
                            break;
                        }
                        sent += wr;
                    } while (sent != rd);

                    buffer[sent] = '\0';
                    printf("echo #%d: %s\n", client, buffer);
                } else {
                    if (rd == 0)
                        printf("connection closed by peer #%d\n", client);
                    else
                        perror("read()");

                    epoll_ctl(epollfd, EPOLL_CTL_DEL, client, &evt);
                    close(client);
                }
            }
        }
    }

    return 0;
}

import time
import socket

HOST = "localhost"
PORT = 11111
BUFSIZE = 4096
N = 5

socks = [socket.socket(socket.AF_INET, socket.SOCK_STREAM) for i in range(N)]

for sock in socks:
    sock.connect((HOST, PORT))
    sock.settimeout(0.1)

time.sleep(1)


# client 0 just closes the socket.
socks[0].close()

# client 1 sends a message and receives a response.
msg = "Hello, this is client #1."
socks[1].sendall(msg.encode("utf-8"))
data = socks[1].recv(BUFSIZE)
print(f"Got a message on client #1: {data}")

# client 2 sends a message but ignores a response.
msg = "Hello, this is client #2."
socks[2].sendall(msg.encode("utf-8"))

# client 3 sends a message longer than the buffer size on the server size.
msg = "Hello, this is client #3. Sending a message longer than buffer size on the server side!"
socks[3].sendall(msg.encode("utf-8"))
while True:
    try:
        data = socks[3].recv(BUFSIZE)
    except socket.timeout:
        break
    print(f"Got a message on client #3: {data}")

# client 4 does nothing.

time.sleep(1)

       #include <unistd.h>

       int fsync(int fd);

       #include <unistd.h>

       void sync(void);

$ ./a.out
Memfd content: Hello, memfd!

#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>

int main() {
	int ret, memfd;
	const char *content = "Hello, memfd!";
	size_t length = strlen(content) + 1;
	char *map;

	// Create an anonymous memory file.
	memfd = memfd_create("memfd", 0);
	if (memfd < 0) {
		perror("memfd_create");
		return 1;
	}

	// Resize the memory file.
	ret = ftruncate(memfd, length);
	if (ret == -1) {
		perror("ftruncate");
		close(memfd);
		return 1;
	}

	// Write content to the memory file.
	ret = write(memfd, content, length);
	if (ret != length) {
		perror("write");
		close(memfd);
		return 1;
	}

	// Map the memory file into memory.
	map = mmap(NULL, length, PROT_READ, MAP_PRIVATE, memfd, 0);
	if (map == MAP_FAILED) {
		perror("mmap");
		close(memfd);
		return 1;
	}

	// print the content of the memory file.
	printf("Memfd content: %s\n", map);

	// Clean up.
	munmap(map, length);
	close(memfd);

	return 0;
}

$ python3 main.py
b'Hello, memfd!'

import os

memfd = os.memfd_create("memfd")

data = b"Hello, memfd!"
os.write(memfd, data)

os.lseek(memfd, 0, os.SEEK_SET)

size = len(data)
print(os.read(memfd, size))

os.close(memfd)

$ ./a.out
Parent process, pid = 114657
Child process, pid = 114658
New session created, pid = 114658

$ sudo tail -f /var/log/messages
Jan 29 21:32:28 ip-172-31-70-218 daemon-example[114658]: Hello from daemon
Jan 29 21:32:31 ip-172-31-70-218 daemon-example[114658]: Hello from daemon
Jan 29 21:32:34 ip-172-31-70-218 daemon-example[114658]: Hello from daemon
Jan 29 21:32:37 ip-172-31-70-218 daemon-example[114658]: Hello from daemon
Jan 29 21:32:40 ip-172-31-70-218 daemon-example[114658]: Hello from daemon
Jan 29 21:32:43 ip-172-31-70-218 daemon-example[114658]: Hello from daemon
^C

$ sudo kill -9 `pidof ./a.out`

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <syslog.h>
#include <stdbool.h>

int main() {
    pid_t pid;

    /* Fork the current process */
    pid = fork();

    if (pid < 0) {
        /* Error occurred */
        perror("fork");
        return -1;
    } else if (pid > 0) {
        /* Parent process */
        printf("Parent process, pid = %d\n", getpid());
        return 0; // Parent exits
    } else {
        /* Child process */
        printf("Child process, pid = %d\n", getpid());

        /* Create a new session */
        if (setsid() < 0) {
            perror("setsid");
            return -1;
        }

        printf("New session created, pid = %d\n", getpid());

        /* Open the syslog for logging */
        openlog("daemon-example", LOG_PID, LOG_DAEMON);

        while (true) {
            /* Write a log message */
            syslog(LOG_INFO, "Hello from daemon");

            /* Sleep for 3 seconds */
            sleep(3);
        }

        /* Close the syslog (not reached in this example) */
        closelog();

        return 0;
    }
}