/* 할당은 약속이다 --- 8 GiB 를 빌려도, 만지기 전에는 기억이 오지 않는다.

   VmSize 는 *배치도에 그은 넓이*이고 VmRSS 는 *실제로 붙은 쪽*이다. 이 둘이
   갈라지는 것이 번역이 있는 기계의 성격이다. */
#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);
}

/* ★ 버퍼를 *바깥에서도 보이는 기억*으로 만든다. 지역 포인터로만 쥐고 있으면 컴파일러는
     「아무도 읽지 않는 기억」으로 보고 malloc 과 쪽마다의 쓰기를 통째로 지운다 --- Clang 22 는 그랬고
     8 GiB 약속이 아예 사라졌다. 이 기계의 GCC 14 에서만 우연히 살아 있었다(폰에서 드러났다).
     volatile 전역에 한 번 담으면, 바깥 호출(fopen)이 그 기억을 볼 수 있다고 가정해야 한다. */
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");

    /* 쪽마다 한 바이트씩 --- 쪽 하나를 붙이는 데 접촉 한 번이면 된다. */
    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;
}

/* 약속의 값은 나중에 치른다 --- 쪽을 처음 만지는 접촉과 두 번째 접촉을 견준다.

   첫 접촉에서 벌어지는 일: 번역이 없어 오류가 나고, 커널이 쪽 하나를 찾아
   0 으로 채우고, 쪽 표에 적고, 돌아온다. 두 번째 접촉은 그냥 쓰기다. */
#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;
}

/* 복사-후-쓰기를 눈으로 본다 --- fork 는 512 MiB 를 복사하지 않는다.

   세는 것은 RSS 가 아니라 *사유 더러운 쪽*(Private_Dirty)이다. RSS 는 공유하는
   쪽까지 세기 때문에, 나누어 쓰는 중인지 갈라선 뒤인지를 구별하지 못한다. */
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

/* ★ smaps_rollup 은 커널 4.14 부터다. 읽을 수 없으면 영역마다 적힌 smaps 를 더한다.
     둘 다 못 읽으면 -1 --- 예전에는 그 -1 을 1024 로 나눠 「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);
}

/* ★ 버퍼를 *바깥에서도 보이는 기억*으로 만든다. 지역 포인터로만 쥐고 있으면 컴파일러는
     「아무도 읽지 않는 기억」으로 보고 malloc·memset·쓰기를 통째로 지운다 --- Clang 22 는 그랬고
     GCC 16 은 부모의 채우기를 지웠다. 이 기계의 GCC 14 에서만 우연히 살아 있었다(폰에서 드러났다).
     volatile 전역에 한 번 담으면, 바깥 호출(fopen·fork)이 그 기억을 볼 수 있다고 가정해야 한다. */
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);                     /* ★ 자식이 부모의 버퍼를 물려받지 않도록 */

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

/* 배치도는 막는 장치이자 *쓰는* 장치다.

   셋을 보인다.
     ① 같은 물리 기억을 주소 공간에 두 번 이어 붙여 「감기지 않는 고리 버퍼」를 만든다.
     ② 마지막 쪽의 권한을 거두어 경비 쪽으로 삼는다 --- 넘겨 쓰면 거기서 멈춘다.
     ③ 이 프로그램 자신의 사상 목록에서 권한 조합을 세어 본다. */
#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__)
/* ★ Termux 가 겨누는 옛 안드로이드 API 에서는 Bionic 이 memfd_create 선언을 감춘다(API 30 부터
     보인다). 시스템 호출은 커널에 있으므로 번호로 직접 부른다. */
#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;
}

/* 이름 붙은 주소 공간을 눈으로 --- AVR 의 `__flash`.

   이 파일은 이 기계(x86-64)에서 도는 프로그램이 아니다. *컴파일되는 것 자체가
   실험*이라, 옆의 `run.sh` 가 AVR 교차 컴파일러로 이 파일을 세 번 짓고 그때
   나온 것을 보인다.

   보이려는 것 셋.
     ① `const __flash` 는 선언에 붙는 *타입 한정자*다 --- `const` 와 같은 자리.
     ② 그런데 표준 C 의 낱말이 아니다. `-std=c23`(엄격 ISO)에서는 이 파일이
        아예 컴파일되지 않는다. `-std=gnu23` 이라야 선다.
     ③ 같은 첨자 `x[i]` 인데 어느 공간의 것이냐에 따라 *다른 기계 명령*이 나가고,
        자료도 다른 구역에 놓인다.                                             */

const char         ram[] = "hi";      /* RAM(.rodata) 에 놓인다              */
const __flash char rom[] = "hi";      /* 플래시(.progmem.data) 에 놓인다      */

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

/* ★ 그리고 이것 --- 공간이 다른 두 포인터를 섞는다.
      한쪽은 RAM 을, 다른 쪽은 플래시를 가리키는데 그냥 대입된다.            */
const char         *p;
const __flash char *q;
void mix(void) { p = q; }