Ist es falsch, sich "memfd" als "dem Prozess zuzuordnen, dem die Datei gehört"?

https://dvdhrm.wordpress.com/2014/06/10/memfd_create2/

Theoretisch könnten Sie [ memfd_create()] Verhalten erreichen, ohne neue Systemaufrufe einzuführen:

int fd = open("/tmp", O_RDWR | O_TMPFILE | O_EXCL, S_IRWXU);

(Beachten Sie, dass wir " /dev/shm" anstelle von " /tmp" verwenden können, um ein tmpfs hier besser zu gewährleisten .)

Daher ist die wichtigste Frage, warum zum Teufel wir einen dritten Weg brauchen?

[...]

Der Sicherungsspeicher wird dem Prozess zugeordnet, dem die Datei gehört, und unterliegt keinen Mount-Quoten.

^ Habe ich Recht, wenn ich denke, dass auf den ersten Teil dieses Satzes kein Verlass ist?

Der memfd_create () - Code wird buchstäblich als "nicht verknüpfte Datei in [a] tmpfs implementiert, die kernelintern sein muss ". Ich verstehe, dass die Verfolgung des Codes sich dadurch unterscheidet, dass keine LSM-Überprüfungen implementiert werden. Außerdem werden Memfds erstellt, um "Siegel" zu unterstützen, wie im Blog-Beitrag erläutert wird. Allerdings bin ich sehr skeptisch , dass memfds ist entfielen anders im Prinzip eine tmpfile.

Insbesondere, wenn der OOM-Killer klopft, denke ich nicht, dass er für den Speicher verantwortlich ist, der von memfds gehalten wird. Dies kann bis zu 50% des Arbeitsspeichers betragen - der Wert der Option size = für tmpfs . Der Kernel legt keinen anderen Wert für die internen tmpfs fest, daher würde er die Standardgröße von 50% verwenden.

Ich denke also, wir können generell damit rechnen, dass Prozesse, die eine große Speicherkapazität aufweisen, aber keine anderen signifikanten Speicherzuordnungen aufweisen, nicht durch OOM zerstört werden. Ist das korrekt?

— sourcejedi
quelle

Was die OOM-Scores angeht, scheint es sich um die Kernel-Funktion oom_badness zu handeln . Ich vermute also, wenn memfd_create nicht in einer / proc / {pid} / map auftaucht, wird es nicht gezählt. Die allgemeine Antwort ist also, dass sie getötet werden könnten, aber aufgrund der Verwendung von memfd_create keine große Punktzahl haben. Der Speicher für den fd kann von mehreren Prozessen gemeinsam genutzt werden, da mehrere Prozesse denselben fd erben / senden können.

— danblack

Aufbauend auf @ danblacks Antwort:

Die Entscheidung basiert auf oom_kill_process()(etwas aufgeräumt):

for_each_thread(p, t) {
        list_for_each_entry(child, &t->children, sibling) {
                unsigned int child_points;

                child_points = oom_badness(child,
                        oc->memcg, oc->nodemask, oc->totalpages);
                if (child_points > victim_points) {
                        put_task_struct(victim);
                        victim = child;
                        victim_points = child_points;
                        get_task_struct(victim);
                }
        }
}

( https://github.com/torvalds/linux/blob/master/mm/oom_kill.c#L974 )

Was davon abhängt oom_badness(), den besten Kandidaten zu finden:

child_points = oom_badness(child,
        oc->memcg, oc->nodemask, oc->totalpages);

oom_badness() macht:

points = get_mm_rss(p->mm) + get_mm_counter(p->mm, MM_SWAPENTS) +
        mm_pgtables_bytes(p->mm) / PAGE_SIZE;

( https://github.com/torvalds/linux/blob/master/mm/oom_kill.c#L233 )

Wo:

static inline unsigned long get_mm_rss(struct mm_struct *mm)
{
        return get_mm_counter(mm, MM_FILEPAGES) +
                get_mm_counter(mm, MM_ANONPAGES) +
                get_mm_counter(mm, MM_SHMEMPAGES);
}

( https://github.com/torvalds/linux/blob/master/mm/oom_kill.c#L966 )

Es sieht also so aus, als würde es anonyme Seiten zählen memfd_create().

— V13
quelle