Come sono le dimensioni dello stack del processo su linux relative a pthread, fork ed exec

Question

Ho una domanda sulla dimensione dello stack di un processo su Linux. Questa dimensione dello stack è determinata al momento del collegamento ed è codificata nel file ELF?

Ho scritto un programma che stampa le dimensioni dello stack per pthread_attr_getstacksize(&attr, &stacksize);. E se eseguo questo programma direttamente da una shell, dà un valore di circa 10 MB. Ma quando I exec da una discussione che appartiene a un programma multi-thread, dà un valore di circa 2 MB.

Quindi voglio sapere quali fattori influenzano la dimensione dello stack di un processo che è fork and exec -ed da qualche processo padre. Ed è possibile impostare la dimensione dello stack di un processo nel suo genitore in fase di esecuzione prima del fork and exec figlio?
Grazie in anticipo.

Answer 1

quanto la pagina di manuale per pthread_create(3) dice:

"Su Linux/x86-32, la dimensione dello stack di default per un nuovo thread è 2 megabyte", A meno che non sia impostato il limite RLIMIT_STACK risorsa (ulimit -s): in In tal caso, "determina la dimensione predefinita dello stack di nuovi thread".

È possibile verificare questo fatto recuperando il valore corrente di RLIMIT_STACK con getrlimit(2), come nel seguente programma:

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

int main() 
{ 
    /* Warning: error checking removed to keep the example small */ 
    pthread_attr_t attr; 
    size_t stacksize; 
    struct rlimit rlim; 

    pthread_attr_init(&attr); 
    pthread_attr_getstacksize(&attr, &stacksize); 
    getrlimit(RLIMIT_STACK, &rlim); 
    /* Don't know the exact type of rlim_t, but surely it will 
     fit into a size_t variable. */ 
    printf("%zd\n", (size_t) rlim.rlim_cur); 
    printf("%zd\n", stacksize); 
    pthread_attr_destroy(&attr); 

    return 0; 
} 

Questi sono i risultati quando si cerca di eseguirlo (compilato a a.out) dalla riga di comando :

$ ulimit -s 
8192 
$ ./a.out 
8388608 
8388608 
$ ulimit -s unlimited 
$ ./a.out 
-1 
2097152 
$ ulimit -s 4096 
$ ./a.out 
4194304 
4194304 

Answer 2

Secondo il man page for fork(), "il processo figlio è creato con un singolo filo, quello che ha chiamato fork()."

Quindi, la dimensione dello stack del thread principale per il processo figlio sarà la dimensione dello stack del thread che chiama fork().

Tuttavia, quando viene chiamato il numero one of the exec() functions (che in definitiva chiama execve() per eseguire il lavoro reale), l'immagine del processo viene sostituita con il nuovo programma. A quel punto, lo stack viene ricreato in base al limite di dimensioni dello stack (kernel 2.6.23 e successivi), che può essere visto chiamando lo getrlimit(RLIMIT_STACK, &rlimitStruct).

È possibile controllare questo prima di chiamare exec impostando il limite soft utilizzando setrlimit(RLIMIT_STACK, &rlimitStruct) (a patto di non cercare di aumentare il limite rigido o impostare il limite soft superiore al limite duro).