LINUX.ORG.RU

История изменений

Исправление hateyoufeel, (текущая версия) :

И я уже сказал – если ты делаешь на стороне отправителя memory sealing, никто никому поднасрать не может.

Да, но это ставит крест на CoW. Через F_SEAL_* можно только полностью запретить запись. Можно, конечно, копировать ручками, но ты понял.

С чего бы вдруг? Это буквально то, что ты хочешь – CoW + неизменяемость другими процессами.

Нет. Тут либо CoW, причём для этого получатель должен сам всё сделать (если успеет и туда не поднасрали, когда до него дошла очередь), либо неизменяемость через F_SEAL_*, и тогда опять же всё надо делать ручками.

Вот тебе пример:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHECK(cond, msg) do{ if(cond) { fprintf(stderr, "[!] ERROR: %s\n", (msg)); exit(EXIT_FAILURE);}}while(0)

// Messages are same length for consistency.
const char good_message[] = "hello there! :)))))))))))))))))))))))))))";
const char bad_message[] =  "HURR DURR YOUR MOTHER SUCKS COCKS IN HELL";

void map_and_print(int, size_t);

void map_and_print(int fd, size_t len) {
    char *ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
    CHECK(ptr == MAP_FAILED, "mmap failed");
    printf("%s\n", ptr);
    fflush(stdout);
    int r = munmap(ptr, len);
    CHECK(r == -1, "munmap failed");
}

int main(void) {
    int fd = memfd_create("message", 0);
    int r = 0;
    CHECK(fd == -1, "memfd_create failed");

    r = write(fd, good_message, sizeof(good_message));
    CHECK(r < (int)sizeof(good_message), "write failed");

    pid_t good_boy = fork();
    if(!good_boy) {
        sleep(3);
        map_and_print(fd, sizeof(good_message));
        close(fd);
        exit(EXIT_SUCCESS);
    }

    pid_t bad_boy = fork();
    if(!bad_boy) {
        r = ftruncate(fd, 0);
        CHECK(r == -1, "ftruncate failed");
        r = write(fd, bad_message, sizeof(bad_message));
        CHECK(r == -1, "write failed");
        close(fd);
        exit(EXIT_SUCCESS);
    }

    waitpid(bad_boy, NULL, 0);
    waitpid(good_boy, NULL, 0);

    return 0;
}

Что нужно сделать со стороны родителя, чтобы второй ребёнок тут не мог поднасрать первому, но при этом оба могли писать в замапленный буфер?

Лол нет. Dbus всё ещё говно, потому что не делает кучу того, что могла бы и должна делать шина, и заставляет приложения жонглировать fd.

Ок.

В общем, тут та же проблема, что с GTK, гнумом, выделением текста и реакциями с эмоджи: вместо нормальной приблуды у нас полусырая поделка, которую нужно самому вот так-то допиливать. При этом разрабы утверждают, что им норм, а эти все фичи не нужны.

Исправление hateyoufeel, :

И я уже сказал – если ты делаешь на стороне отправителя memory sealing, никто никому поднасрать не может.

Да, но это ставит крест на CoW. Через F_SEAL_* можно только полностью запретить запись. Можно, конечно, копировать ручками, но ты понял.

С чего бы вдруг? Это буквально то, что ты хочешь – CoW + неизменяемость другими процессами.

Нет. Тут либо CoW, причём для этого получатель должен сам всё сделать (если успеет и туда не поднасрали, когда до него дошла очередь), либо неизменяемость через F_SEAL_*.

Вот тебе пример:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHECK(cond, msg) do{ if(cond) { fprintf(stderr, "[!] ERROR: %s\n", (msg)); exit(EXIT_FAILURE);}}while(0)

// Messages are same length for consistency.
const char good_message[] = "hello there! :)))))))))))))))))))))))))))";
const char bad_message[] =  "HURR DURR YOUR MOTHER SUCKS COCKS IN HELL";

void map_and_print(int, size_t);

void map_and_print(int fd, size_t len) {
    char *ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
    CHECK(ptr == MAP_FAILED, "mmap failed");
    printf("%s\n", ptr);
    fflush(stdout);
    int r = munmap(ptr, len);
    CHECK(r == -1, "munmap failed");
}

int main(void) {
    int fd = memfd_create("message", 0);
    int r = 0;
    CHECK(fd == -1, "memfd_create failed");

    r = write(fd, good_message, sizeof(good_message));
    CHECK(r < (int)sizeof(good_message), "write failed");

    pid_t good_boy = fork();
    if(!good_boy) {
        sleep(3);
        map_and_print(fd, sizeof(good_message));
        close(fd);
        exit(EXIT_SUCCESS);
    }

    pid_t bad_boy = fork();
    if(!bad_boy) {
        r = ftruncate(fd, 0);
        CHECK(r == -1, "ftruncate failed");
        r = write(fd, bad_message, sizeof(bad_message));
        CHECK(r == -1, "write failed");
        close(fd);
        exit(EXIT_SUCCESS);
    }

    waitpid(bad_boy, NULL, 0);
    waitpid(good_boy, NULL, 0);

    return 0;
}

Что нужно сделать со стороны родителя, чтобы второй ребёнок тут не мог поднасрать первому, но при этом оба могли писать в замапленный буфер?

Лол нет. Dbus всё ещё говно, потому что не делает кучу того, что могла бы и должна делать шина, и заставляет приложения жонглировать fd.

Ок.

В общем, тут та же проблема, что с GTK, гнумом, выделением текста и реакциями с эмоджи: вместо нормальной приблуды у нас полусырая поделка, которую нужно самому вот так-то допиливать. При этом разрабы утверждают, что им норм, а эти все фичи не нужны.

Исправление hateyoufeel, :

И я уже сказал – если ты делаешь на стороне отправителя memory sealing, никто никому поднасрать не может.

Да, но это ставит крест на CoW. Через F_SEAL_* можно только полностью запретить запись.

С чего бы вдруг? Это буквально то, что ты хочешь – CoW + неизменяемость другими процессами.

Нет. Тут либо CoW, причём для этого получатель должен сам всё сделать (если успеет и туда не поднасрали, когда до него дошла очередь), либо неизменяемость через F_SEAL_*.

Вот тебе пример:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHECK(cond, msg) do{ if(cond) { fprintf(stderr, "[!] ERROR: %s\n", (msg)); exit(EXIT_FAILURE);}}while(0)

// Messages are same length for consistency.
const char good_message[] = "hello there! :)))))))))))))))))))))))))))";
const char bad_message[] =  "HURR DURR YOUR MOTHER SUCKS COCKS IN HELL";

void map_and_print(int, size_t);

void map_and_print(int fd, size_t len) {
    char *ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
    CHECK(ptr == MAP_FAILED, "mmap failed");
    printf("%s\n", ptr);
    fflush(stdout);
    int r = munmap(ptr, len);
    CHECK(r == -1, "munmap failed");
}

int main(void) {
    int fd = memfd_create("message", 0);
    int r = 0;
    CHECK(fd == -1, "memfd_create failed");

    r = write(fd, good_message, sizeof(good_message));
    CHECK(r < (int)sizeof(good_message), "write failed");

    pid_t good_boy = fork();
    if(!good_boy) {
        sleep(3);
        map_and_print(fd, sizeof(good_message));
        close(fd);
        exit(EXIT_SUCCESS);
    }

    pid_t bad_boy = fork();
    if(!bad_boy) {
        r = ftruncate(fd, 0);
        CHECK(r == -1, "ftruncate failed");
        r = write(fd, bad_message, sizeof(bad_message));
        CHECK(r == -1, "write failed");
        close(fd);
        exit(EXIT_SUCCESS);
    }

    waitpid(bad_boy, NULL, 0);
    waitpid(good_boy, NULL, 0);

    return 0;
}

Что нужно сделать со стороны родителя, чтобы второй ребёнок тут не мог поднасрать первому, но при этом оба могли писать в замапленный буфер?

Лол нет. Dbus всё ещё говно, потому что не делает кучу того, что могла бы и должна делать шина, и заставляет приложения жонглировать fd.

Ок.

В общем, тут та же проблема, что с GTK, гнумом, выделением текста и реакциями с эмоджи: вместо нормальной приблуды у нас полусырая поделка, которую нужно самому вот так-то допиливать. При этом разрабы утверждают, что им норм, а эти все фичи не нужны.

Исправление hateyoufeel, :

И я уже сказал – если ты делаешь на стороне отправителя memory sealing, никто никому поднасрать не может.

Да, но это ставит крест на CoW. Через F_SEAL_* можно только полностью запретить запись.

С чего бы вдруг? Это буквально то, что ты хочешь – CoW + неизменяемость другими процессами.

Нет. Тут либо CoW, причём для этого получатель должен сам всё сделать, либо неизменяемость через F_SEAL_*.

Вот тебе пример:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHECK(cond, msg) do{ if(cond) { fprintf(stderr, "[!] ERROR: %s\n", (msg)); exit(EXIT_FAILURE);}}while(0)

// Messages are same length for consistency.
const char good_message[] = "hello there! :)))))))))))))))))))))))))))";
const char bad_message[] =  "HURR DURR YOUR MOTHER SUCKS COCKS IN HELL";

void map_and_print(int, size_t);

void map_and_print(int fd, size_t len) {
    char *ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
    CHECK(ptr == MAP_FAILED, "mmap failed");
    printf("%s\n", ptr);
    fflush(stdout);
    int r = munmap(ptr, len);
    CHECK(r == -1, "munmap failed");
}

int main(void) {
    int fd = memfd_create("message", 0);
    int r = 0;
    CHECK(fd == -1, "memfd_create failed");

    r = write(fd, good_message, sizeof(good_message));
    CHECK(r < (int)sizeof(good_message), "write failed");

    pid_t good_boy = fork();
    if(!good_boy) {
        sleep(3);
        map_and_print(fd, sizeof(good_message));
        close(fd);
        exit(EXIT_SUCCESS);
    }

    pid_t bad_boy = fork();
    if(!bad_boy) {
        r = ftruncate(fd, 0);
        CHECK(r == -1, "ftruncate failed");
        r = write(fd, bad_message, sizeof(bad_message));
        CHECK(r == -1, "write failed");
        close(fd);
        exit(EXIT_SUCCESS);
    }

    waitpid(bad_boy, NULL, 0);
    waitpid(good_boy, NULL, 0);

    return 0;
}

Что нужно сделать со стороны родителя, чтобы второй ребёнок тут не мог поднасрать первому, но при этом оба могли писать в замапленный буфер?

Лол нет. Dbus всё ещё говно, потому что не делает кучу того, что могла бы и должна делать шина, и заставляет приложения жонглировать fd.

Ок.

В общем, тут та же проблема, что с GTK, гнумом, выделением текста и реакциями с эмоджи: вместо нормальной приблуды у нас полусырая поделка, которую нужно самому вот так-то допиливать. При этом разрабы утверждают, что им норм, а эти все фичи не нужны.

Исправление hateyoufeel, :

И я уже сказал – если ты делаешь на стороне отправителя memory sealing, никто никому поднасрать не может.

Да, но это ставит крест на CoW. Через F_SEAL_* можно только полностью запретить запись.

С чего бы вдруг? Это буквально то, что ты хочешь – CoW + неизменяемость другими процессами.

Нет. Тут либо CoW, причём для этого получатель должен сам всё сделать, либо неизменяемость через F_SEAL_*.

Вот тебе пример:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHECK(cond, msg) do{ if(cond) { fprintf(stderr, "[!] ERROR: %s\n", (msg)); exit(EXIT_FAILURE);}}while(0)

// Messages are same length for consistency.
const char good_message[] = "hello there! :)))))))))))))))))))))))))))";
const char bad_message[] =  "HURR DURR YOUR MOTHER SUCKS COCKS IN HELL";

void map_and_print(int, size_t);

void map_and_print(int fd, size_t len) {
    char *ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
    CHECK(ptr == MAP_FAILED, "mmap failed");
    printf("%s\n", ptr);
    fflush(stdout);
    int r = munmap(ptr, len);
    CHECK(r == -1, "munmap failed");
}

int main(void) {
    int fd = memfd_create("message", 0);
    int r = 0;
    CHECK(fd == -1, "memfd_create failed");

    r = write(fd, good_message, sizeof(good_message));
    CHECK(r < (int)sizeof(good_message), "write failed");

    pid_t good_boy = fork();
    if(!good_boy) {
        sleep(3);
        map_and_print(fd, sizeof(good_message));
        close(fd);
        exit(EXIT_SUCCESS);
    }

    pid_t bad_boy = fork();
    if(!bad_boy) {
        r = ftruncate(fd, 0);
        CHECK(r == -1, "ftruncate failed");
        r = write(fd, bad_message, sizeof(bad_message));
        CHECK(r == -1, "write failed");
        close(fd);
        exit(EXIT_SUCCESS);
    }

    waitpid(bad_boy, NULL, 0);
    waitpid(good_boy, NULL, 0);

    return 0;
}

Что нужно сделать со стороны родителя, чтобы второй ребёнок тут не мог поднасрать первому, но при этом оба могли писать в замапленный буфер?

Лол нет. Dbus всё ещё говно, потому что не делает кучу того, что могла бы и должна делать шина, и заставляет приложения жонглировать fd.

Ок.

В общем, тут та же проблема, что в GTK, гноме, выделением текста и реакциями с эмоджи: вместо нормальной приблуды у нас полусырая поделка, которую нужно самому вот так-то допиливать. При этом разрабы утверждают, что им норм, а эти все фичи не нужны.

Исправление hateyoufeel, :

И я уже сказал – если ты делаешь на стороне отправителя memory sealing, никто никому поднасрать не может.

Да, но это ставит крест на CoW. Через F_SEAL_* можно только полностью запретить запись.

С чего бы вдруг? Это буквально то, что ты хочешь – CoW + неизменяемость другими процессами.

Нет. Тут либо CoW, причём для этого получатель должен сам всё сделать, либо неизменяемость через F_SEAL_*.

Вот тебе пример:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHECK(cond, msg) do{ if(cond) { fprintf(stderr, "[!] ERROR: %s\n", (msg)); exit(EXIT_FAILURE);}}while(0)

// Messages are same length for consistency.
const char good_message[] = "hello there! :)))))))))))))))))))))))))))";
const char bad_message[] =  "HURR DURR YOUR MOTHER SUCKS COCKS IN HELL";

void map_and_print(int, size_t);

void map_and_print(int fd, size_t len) {
    char *ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
    CHECK(ptr == MAP_FAILED, "mmap failed");
    printf("%s\n", ptr);
    fflush(stdout);
    int r = munmap(ptr, len);
    CHECK(r == -1, "munmap failed");
}

int main(void) {
    int fd = memfd_create("message", 0);
    int r = 0;
    CHECK(fd == -1, "memfd_create failed");

    r = write(fd, good_message, sizeof(good_message));
    CHECK(r < (int)sizeof(good_message), "write failed");

    pid_t good_boy = fork();
    if(!good_boy) {
        sleep(3);
        map_and_print(fd, sizeof(good_message));
        close(fd);
        exit(EXIT_SUCCESS);
    }

    pid_t bad_boy = fork();
    if(!bad_boy) {
        r = ftruncate(fd, 0);
        CHECK(r == -1, "ftruncate failed");
        r = write(fd, bad_message, sizeof(bad_message));
        CHECK(r == -1, "write failed");
        close(fd);
        exit(EXIT_SUCCESS);
    }

    waitpid(bad_boy, NULL, 0);
    waitpid(good_boy, NULL, 0);

    return 0;
}

Что нужно сделать со стороны родителя, чтобы второй ребёнок тут не мог поднасрать первому?

Лол нет. Dbus всё ещё говно, потому что не делает кучу того, что могла бы и должна делать шина, и заставляет приложения жонглировать fd.

Ок.

В общем, тут та же проблема, что в GTK, гноме, выделением текста и реакциями с эмоджи: вместо нормальной приблуды у нас полусырая поделка, которую нужно самому вот так-то допиливать. При этом разрабы утверждают, что им норм, а эти все фичи не нужны.

Исходная версия hateyoufeel, :

И я уже сказал – если ты делаешь на стороне отправителя memory sealing, никто никому поднасрать не может.

Да, но это ставит крест на CoW. Через F_SEAL_* можно только полностью запретить запись.

С чего бы вдруг? Это буквально то, что ты хочешь – CoW + неизменяемость другими процессами.

Нет. Тут либо CoW, причём для этого получатель должен сам всё сделать, либо неизменяемость через F_SEAL_*.

Вот тебе пример:

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHECK(cond, msg) do{ if(cond) { fprintf(stderr, "[!] ERROR: %s\n", (msg)); exit(EXIT_FAILURE);}}while(0)

// Messages are same length for consistency.
const char good_message[] = "hello there! :)))))))))))))))))))))))))))";
const char bad_message[] =  "HURR DURR YOUR MOTHER SUCKS COCKS IN HELL";

void map_and_print(int, size_t);

void map_and_print(int fd, size_t len) {
    char *ptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, 0);
    CHECK(ptr == MAP_FAILED, "mmap failed");
    printf("%s\n", ptr);
    fflush(stdout);
    int r = munmap(ptr, len);
    CHECK(r == -1, "munmap failed");
}

int main(void) {
    int fd = memfd_create("message", 0);
    int r = 0;
    CHECK(fd == -1, "memfd_create failed");

    r = write(fd, good_message, sizeof(good_message));
    CHECK(r < (int)sizeof(good_message), "write failed");

    pid_t good_boy = fork();
    if(!good_boy) {
        sleep(3);
        map_and_print(fd, sizeof(good_message));
        close(fd);
        exit(EXIT_SUCCESS);
    }

    pid_t bad_boy = fork();
    if(!bad_boy) {
        r = ftruncate(fd, 0);
        CHECK(r == -1, "ftruncate failed");
        r = write(fd, bad_message, sizeof(bad_message));
        CHECK(r == -1, "write failed");
        close(fd);
        exit(EXIT_SUCCESS);
    }

    waitpid(bad_boy, NULL, 0);
    waitpid(good_boy, NULL, 0);

    return 0;
}

Что нужно сделать со стороны родителя, чтобы второй ребёнок тут не мог поднасрать первому?