Verarbeitet Ressourcen nicht begrenzt durch setrlimit

Question

Ich schrieb ein einfaches Programm, um seine Datengröße zu 65Kb zu beschränken und zu überprüfen, die ich bin ein Dummy-Speicher von mehr als 65Kb zuweisen und logisch, wenn ich alle richtigen (wie unten) malloc Anruf sollte scheitern, oder?

#include <sys/resource.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <errno.h> 

int main (int argc, char *argv[]) 
{ 
    struct rlimit limit; 


    /* Get max data size . */ 
    if (getrlimit(RLIMIT_DATA, &limit) != 0) { 
    printf("getrlimit() failed with errno=%d\n", errno); 
    return 1; 
    } 

    printf("The soft limit is %lu\n", limit.rlim_cur); 
    printf("The hard limit is %lu\n", limit.rlim_max); 

    limit.rlim_cur = 65 * 1024; 
    limit.rlim_max = 65 * 1024; 

    if (setrlimit(RLIMIT_DATA, &limit) != 0) { 
    printf("setrlimit() failed with errno=%d\n", errno); 
    return 1; 
    } 

    if (getrlimit(RLIMIT_DATA, &limit) != 0) { 
    printf("getrlimit() failed with errno=%d\n", errno); 
    return 1; 
    } 

    printf("The soft limit is %lu\n", limit.rlim_cur); 
    printf("The hard limit is %lu\n", limit.rlim_max); 
    system("bash -c 'ulimit -a'"); 
    int *new2 = NULL; 
    new2 = malloc(66666666); 
    if (new2 == NULL) 
    { 
     printf("malloc failed\n"); 
     return; 
    } 
    else 
    { 
     printf("success\n"); 
    } 

    return 0; 
} 

Überraschenderweise ist die ouput so etwas wie dieses -

The soft limit is 4294967295 
The hard limit is 4294967295 
The soft limit is 66560 
The hard limit is 66560 
core file size   (blocks, -c) 0 
data seg size   (kbytes, -d) 65 
scheduling priority    (-e) 0 
file size    (blocks, -f) unlimited 
pending signals     (-i) 14895 
max locked memory  (kbytes, -l) 64 
max memory size   (kbytes, -m) unlimited 
open files      (-n) 1024 
pipe size   (512 bytes, -p) 8 
POSIX message queues  (bytes, -q) 819200 
real-time priority    (-r) 0 
stack size    (kbytes, -s) 8192 
cpu time    (seconds, -t) unlimited 
max user processes    (-u) 14895 
virtual memory   (kbytes, -v) unlimited 
file locks      (-x) unlimited 
success 

Bin ich in irgendeiner Weise falsch? Bitte lassen Sie Ihre Eingaben fallen. Danke!

Answer 1

Vom setrlimit man page:

RLIMIT_DATA

Die maximale Größe des Datensegments des Prozesses ( Daten, nicht initialisierte Daten initialisiert und Heap). Diese Begrenzung wirkt sich auf Aufrufe auf brk (2) und sbrk (2) aus, die mit dem Fehler ENOMEM bei beim Auftreten der weichen Grenze dieser Ressource fehlschlagen.

Diese Ressource gilt nicht für den Speicher, der über mmap erhalten wird. Intern verwendet malloc verschiedene Mechanismen, um neuen Speicher zu erhalten. In diesem Fall finden Sie, dass es mmap und nicht sbrk oder brk verwendet. Sie können dies überprüfen, indem Sie die Systemaufrufe von Ihrem Programm mit strace dumpen.

Um zu erreichen, was Sie wollen, verwenden Sie stattdessen die Ressource RLIMIT_AS.

Answer 2

nach der Korrektur der Probleme mit der Kompilierung des Codes.

Dies ist der Code:

#include <sys/resource.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <errno.h> 

int main (void) 
{ 
    struct rlimit limit; 


    /* Get max data size . */ 
    if (getrlimit(RLIMIT_DATA, &limit) != 0) { 
    printf("getrlimit() failed with errno=%d\n", errno); 
    exit(EXIT_FAILURE); 
    } 

    printf("The soft limit is %lu\n", limit.rlim_cur); 
    printf("The hard limit is %lu\n", limit.rlim_max); 

    limit.rlim_cur = 65 * 1024; 
    limit.rlim_max = 65 * 1024; 

    if (setrlimit(RLIMIT_DATA, &limit) != 0) 
    { 
    printf("setrlimit() failed with errno=%d\n", errno); 
    exit(EXIT_FAILURE); 
    } 

    if (getrlimit(RLIMIT_DATA, &limit) != 0) 
    { 
    printf("getrlimit() failed with errno=%d\n", errno); 
    exit(EXIT_FAILURE); 
    } 

    printf("The soft limit is %lu\n", limit.rlim_cur); 
    printf("The hard limit is %lu\n", limit.rlim_max); 
    system("bash -c 'ulimit -a'"); 

    int *new2 = NULL; 
    new2 = malloc(66666666); 

    if (new2 == NULL) 
    { 
     printf("malloc failed\n"); 
     exit(EXIT_FAILURE); 
    } 
    else 
    { 
     printf("success\n"); 
    } 

    return 0; 
} 

und hier ist die Ausgabe:

The soft limit is 18446744073709551615 
The hard limit is 18446744073709551615 
The soft limit is 66560 
The hard limit is 66560 
bash: xmalloc: .././variables.c:2307: cannot allocate 48 bytes (16384 bytes allocated) 
success 

, die die Änderung der rlimit Werke zeigt, die system Aufruf war erfolgreich, die bash Befehl fehlgeschlagen ist, und die malloc war erfolgreich.

Mehrere Durchläufe des gleichen Code immer ausgegeben exakt die gleichen Werte, so dass keine dauerhafte Änderung des rlimit Wert

nach dem obigen Code mehrmals ausgeführt wird, während jedes Terminal-Fenster offen zu lassen, dann in noch das bash Befehl ausführen ein weiteres Terminal-Fenster ergab folgendes:

core file size   (blocks, -c) 0 
data seg size   (kbytes, -d) unlimited 
scheduling priority    (-e) 0 
file size    (blocks, -f) unlimited 
pending signals     (-i) 54511 
max locked memory  (kbytes, -l) 64 
max memory size   (kbytes, -m) unlimited 
open files      (-n) 1024 
pipe size   (512 bytes, -p) 8 
POSIX message queues  (bytes, -q) 819200 
real-time priority    (-r) 0 
stack size    (kbytes, -s) 8192 
cpu time    (seconds, -t) unlimited 
max user processes    (-u) 54511 
virtual memory   (kbytes, -v) unlimited 
file locks      (-x) unlimited 

dann noch in einem anderen Terminal den Code läuft dann in der gleichen Klemme Ausgang exakt die gleichen Ausgangswerte der bash Befehl ausgeführt wird.

Daher vermute ich, dass der Code den falschen Ansatz zur Begrenzung der verfügbaren Speichermenge verwendet.