/* Allocation is a promise: borrowing 8 GiB does not fetch pages until they are touched.

   VmSize is the map and VmRSS is what has arrived. Their separation is the character
   of a machine with address translation. */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>

static long field_kb(const char *key)
{
    FILE *f = fopen("/proc/self/status", "r");
    char line[256], pat[64];
    long v = -1;
    if (!f)
        return -1;
    snprintf(pat, sizeof pat, "%s %%ld", key);
    while (fgets(line, sizeof line, f))
        if (sscanf(line, pat, &v) == 1)
            break;
    fclose(f);
    return v;
}

static void show(const char *key, const char *when)
{
    long vsz = field_kb("VmSize:") / 1024, rss = field_kb("VmRSS:") / 1024;
    printf("  %-24s  map %6ld MB   real %6ld MB\n", when, vsz, rss);
    printf("#DATA %s %ld %ld\n", key, vsz, rss);
}

/* Make the buffer memory that can be seen from outside. Held only by a local pointer, the
   compiler treats it as memory nobody reads and removes the malloc and the per-page writes
   entirely --- Clang 22 did, and the 8 GiB promise vanished. It survived only by chance
   under this machine's GCC 14 (a phone run exposed it). Stored once in a volatile global,
   outside calls (fopen) must be assumed able to see that memory. */
static char *volatile held;

int main(void)
{
    const size_t GIB = 1024u * 1024u * 1024u;
    const size_t want = 8 * GIB;

    printf("== a promise of %zu MB ==\n\n", want / 1024 / 1024);
    printf("  %-24s  %-13s %s\n", "", "address space", "memory that arrived");
    printf("#DATA-BEGIN\n");
    show("before", "before the request");

    char *p = malloc(want);
    held = p;
    if (!p) {
        printf("#DATA-END\n");
        puts("\n  * this machine refused the promise; the point below still holds.");
        return 0;
    }
    show("malloc", "right after malloc");

    /* one byte per page: one touch brings one page in */
    for (size_t i = 0; i < want; i += 4096)
        p[i] = 1;
    show("touched", "after touching it all");

    free(p);
    show("freed", "after free");
    printf("#DATA-END\n");

    puts("\n  * malloc drew a map; it did not fetch memory. The memory arrived one page");
    puts("    at a time, as the program touched it.");
    puts("  * a block this large gets a mapping of its own, so free hands the whole map");
    puts("    back. A small block does not: it returns to the heap, and the address");
    puts("    space stays as wide as it was.");
    return 0;
}

/* The bill for a promise arrives later: compare a page's first and second touch.
   The first touch faults, allocates and zeroes a page, and updates the page table. */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/mman.h>

static double ns(void)
{
    struct timespec t;
    clock_gettime(CLOCK_MONOTONIC, &t);
    return (double)t.tv_sec * 1e9 + (double)t.tv_nsec;
}

static int cmp_d(const void *a, const void *b)
{
    double x = *(const double *)a, y = *(const double *)b;
    return x < y ? -1 : x > y;
}

int main(void)
{
    const size_t PAGE = 4096, PAGES = 64u * 1024;      /* 256 MiB */
    const int R = 5;
    double first[5], again[5];

    printf("== what a page costs the first time it is touched ==\n\n");
    printf("#DATA-BEGIN\n");

    for (int r = 0; r < R; r++) {
        char *p = mmap(NULL, PAGE * PAGES, PROT_READ | PROT_WRITE,
                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
        if (p == MAP_FAILED) {
            puts("mmap refused; this machine cannot run the experiment.");
            return 0;
        }
        double t0 = ns();
        for (size_t i = 0; i < PAGES; i++) p[i * PAGE] = 1;
        double t1 = ns();
        for (size_t i = 0; i < PAGES; i++) p[i * PAGE] = 2;
        double t2 = ns();
        first[r] = (t1 - t0) / (double)PAGES;
        again[r] = (t2 - t1) / (double)PAGES;
        munmap(p, PAGE * PAGES);
    }
    qsort(first, R, sizeof *first, cmp_d);
    qsort(again, R, sizeof *again, cmp_d);

    printf("  %-16s %10.1f ns per page\n", "first touch", first[R / 2]);
    printf("  %-16s %10.1f ns per page\n", "touched again", again[R / 2]);
    printf("  %-16s %10.1f x\n", "factor", first[R / 2] / again[R / 2]);
    printf("#DATA first %.1f\n", first[R / 2]);
    printf("#DATA again %.1f\n", again[R / 2]);
    printf("#DATA factor %.1f\n", first[R / 2] / again[R / 2]);
    printf("#DATA-END\n");

    puts("\n  * the second write is a write. The first one is a fault, a page, a zeroing");
    puts("    and an entry in the page table -- the bill for the memory that was");
    puts("    promised earlier and not delivered until now.");
    return 0;
}

/* See copy-on-write: fork does not copy 512 MiB.
   Count Private_Dirty rather than RSS, because RSS includes shared pages. */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

/* smaps_rollup exists from kernel 4.14. If it cannot be read, add up the per-region smaps.
   If neither can be read, return -1 --- dividing that -1 by 1024 used to print "0 MB". */
static long roll_kb(const char *key)
{
    char line[256], pat[64];
    long v, sum = -1;
    snprintf(pat, sizeof pat, "%s %%ld", key);
    FILE *f = fopen("/proc/self/smaps_rollup", "r");
    if (f) {
        while (fgets(line, sizeof line, f))
            if (sscanf(line, pat, &v) == 1) { sum = v; break; }
        fclose(f);
        if (sum >= 0)
            return sum;
    }
    f = fopen("/proc/self/smaps", "r");
    if (!f)
        return -1;
    while (fgets(line, sizeof line, f))
        if (sscanf(line, pat, &v) == 1)
            sum = (sum < 0 ? 0 : sum) + v;
    fclose(f);
    return sum;
}

static void show(const char *key, const char *who)
{
    long sh_kb = roll_kb("Shared_Dirty:"), pr_kb = roll_kb("Private_Dirty:");
    if (sh_kb < 0 || pr_kb < 0) {
        printf("  %-28s (unavailable: this system does not let the program read /proc/self/smaps)\n", who);
        printf("#DATA %s -1 -1\n", key);
        return;
    }
    long sh = sh_kb / 1024, pr = pr_kb / 1024;
    printf("  %-28s shared %5ld MB   private %5ld MB\n", who, sh, pr);
    printf("#DATA %s %ld %ld\n", key, sh, pr);
}

/* Make the buffer memory that can be seen from outside. Held only by a local pointer, the
   compiler treats it as memory nobody reads and removes the malloc, the fill and the writes
   entirely --- Clang 22 did, and GCC 16 removed the parent's fill. It survived only by chance
   under this machine's GCC 14 (a phone run exposed it). Stored once in a volatile global,
   outside calls (fopen, fork) must be assumed able to see that memory. */
static char *volatile held;

int main(void)
{
    const size_t N = 512u * 1024 * 1024;
    char *p = malloc(N);
    held = p;
    long sum = 0;

    if (!p) { puts("not enough memory for the experiment."); return 0; }
    memset(p, 7, N);

    printf("== what fork copies ==\n\n");
    printf("#DATA-BEGIN\n");
    show("parent0", "parent, 512 MB filled");
    fflush(stdout);                     /* keep the child from inheriting buffered parent output */

    pid_t kid = fork();
    if (kid == 0) {
        show("child0", "  child, just forked");
        for (size_t i = 0; i < N; i += 4096) sum += p[i];
        show("child_read", "  child, read every page");
        for (size_t i = 0; i < N; i += 4096) p[i] = 9;
        show("child_wrote", "  child, wrote every page");
        (void)sum;
        fflush(stdout);
        _exit(0);
    }
    wait(NULL);
    show("parent1", "parent, after the child");
    printf("#DATA-END\n");

    puts("\n  * forking cost nothing, and reading cost nothing. Writing cost everything.");
    puts("  * the pages were shared until the moment one side changed them: that is the");
    puts("    whole of copy-on-write, and it needs a machine that can translate.");
    free(p);
    return 0;
}

/* A map is both a guard and a tool. Demonstrate a double-mapped ring, a guard page,
   and the permission combinations in this process. */
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <setjmp.h>
#include <unistd.h>
#include <sys/mman.h>
#if defined(__ANDROID__)
/* At the older Android API level Termux targets, Bionic hides the memfd_create declaration
   (it appears from API 30). The kernel has the system call, so call it by number. */
#include <sys/syscall.h>
#define memfd_create(name, flags) ((int)syscall(__NR_memfd_create, (name), (flags)))
#endif
#if defined(__ANDROID__)
/* At the older Android API level Termux targets, Bionic hides the memfd_create declaration
   (it appears from API 30). The kernel has the system call, so call it by number. */
#include <sys/syscall.h>
#define memfd_create(name, flags) ((int)syscall(__NR_memfd_create, (name), (flags)))
#endif

static sigjmp_buf back;

static void on_segv(int sig)
{
    (void)sig;
    siglongjmp(back, 1);
}

static void ring_of_one_page(size_t pg)
{
    int fd = memfd_create("ring", 0);
    if (fd < 0 || ftruncate(fd, (long)pg) != 0) { puts("  (memfd unavailable)"); return; }

    /* 먼저 두 쪽 넓이의 자리를 잡아 두고, 그 위에 같은 기억을 두 번 덮어 사상한다. */
    char *base = mmap(NULL, pg * 2, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    char *a = mmap(base,      pg, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, fd, 0);
    char *b = mmap(base + pg, pg, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, fd, 0);
    if (a == MAP_FAILED || b == MAP_FAILED) { puts("  (mapping refused)"); return; }

    strcpy(a, "hello");
    printf("  two windows %zu bytes apart; wrote at the first, read \"%s\" at the second\n",
           (size_t)(b - a), b);

    /* 끝에서 8 바이트 앞에 12 바이트를 쓴다 --- 감기 검사 없이 그냥 이어 쓴다. */
    memcpy(a + pg - 8, "ABCDEFGHIJKL", 12);
    printf("  wrote 12 bytes 8 before the end; the last 4 came out at the start: \"%.4s\"\n", a);
    printf("#DATA ring %.4s\n", a);
    close(fd);
}

static void guard_page(size_t pg)
{
    struct sigaction sa;
    char *p = mmap(NULL, pg * 3, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (p == MAP_FAILED) { puts("  (mapping refused)"); return; }
    mprotect(p + pg * 2, pg, PROT_NONE);            /* 마지막 쪽의 권한을 거둔다 */

    memset(&sa, 0, sizeof sa);
    sa.sa_handler = on_segv;
    sigaction(SIGSEGV, &sa, NULL);

    if (sigsetjmp(back, 1) == 0) {
        for (size_t i = 0; i < pg * 3; i++) p[i] = 1;
        puts("  the overrun ran past the guard -- nothing stopped it");
        printf("#DATA guard none\n");
    } else {
        printf("  the overrun stopped at the guard page, %zu bytes in\n", pg * 2);
        printf("#DATA guard stopped\n");
    }
    signal(SIGSEGV, SIG_DFL);
}

static void permissions_of_this_program(void)
{
    FILE *f = fopen("/proc/self/maps", "r");
    char line[512], perm[8];
    long r = 0, x = 0, w = 0, none = 0, wx = 0, total = 0;
    if (!f) return;
    while (fgets(line, sizeof line, f)) {
        if (sscanf(line, "%*s %7s", perm) != 1) continue;
        total++;
        if (perm[0] == 'r' && perm[2] == 'x') x++;
        else if (perm[1] == 'w') w++;
        else if (perm[0] == 'r') r++;
        if (perm[0] == '-' && perm[1] == '-' && perm[2] == '-') none++;
        if (perm[1] == 'w' && perm[2] == 'x') wx++;
    }
    fclose(f);
    printf("  %ld regions: %ld read-only, %ld readable+writable, %ld executable, %ld with no access\n",
           total, r, w, x, none);
    printf("  regions that are writable AND executable: %ld\n", wx);
    printf("#DATA regions %ld\n", total);
    printf("#DATA wx %ld\n", wx);
}

int main(void)
{
    size_t pg = (size_t)sysconf(_SC_PAGESIZE);
    void *both;

    printf("== the page size of this machine: %zu bytes ==\n\n", pg);
    printf("#DATA-BEGIN\n");
    printf("#DATA pagesize %zu\n", pg);

    puts("-- one page of memory, mapped twice in a row --");
    ring_of_one_page(pg);

    puts("\n-- a page with its permissions taken away --");
    guard_page(pg);

    puts("\n-- the permissions this program is running under --");
    permissions_of_this_program();

    both = mmap(NULL, pg, PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    printf("  asking for one that is both writable and executable: %s\n",
           both == MAP_FAILED ? "refused" : "granted");
    printf("#DATA wxrequest %s\n", both == MAP_FAILED ? "refused" : "granted");
    printf("#DATA-END\n");

    puts("\n  * the same memory can sit at two addresses, and an address can have no");
    puts("    memory at all. What a pointer names is a place on a map.");
    return 0;
}

/* See a named address space: AVR `__flash`.

   This file does not run on this machine (x86-64). Compiling it is the experiment:
   run.sh builds it three times with an AVR cross compiler and shows the results.

   Three things to see:
     1. `const __flash` is a type qualifier in the same position as `const`.
     2. It is not standard C. Strict `-std=c23` rejects it; `-std=gnu23` accepts it.
     3. The same subscript `x[i]` emits different instructions for different spaces,
        and the data lands in different regions. */

const char         ram[] = "hi";      /* placed in RAM (.rodata)              */
const __flash char rom[] = "hi";      /* placed in flash (.progmem.data)      */

char from_ram(int i) { return ram[i]; }
char from_rom(int i) { return rom[i]; }

/* Mix pointers from different spaces: one points to RAM, the other to flash,
   yet the assignment silently drops the qualifier. */
const char         *p;
const __flash char *q;
void mix(void) { p = q; }