[PLUTO-ildp] aiuto pagina man vfork.2 in man-pages-4.10

[Marco Curreli]

Un saluto a tutti,

finito l'aggiornamento alla versione 4.09 delle man-pages, sono
alle prese con la versione 4.10. Sono quasi tutti minimi
aggiornamenti, tranne alcuni. In particolare mi servirebbe una
controllata alla traduzione delle aggiunte di vfork.2, che riporto
di seguito.
(Per inciso, killer l'ho lasciato killer; si potrebbe tradurre con
"processicida"?)

Grazie,
  Marco

***************
The child must not return from the current function or call 
exit (3) (which would have the effect of calling exit handlers
established by the parent process and flushing the parent's 
stdio (3) buffers), but may call  _exit (2).
--- 
Il figlio non deve tornare dalla funzione attuale o chiamare
exit (3) (che avrebbe l'effetto di chiamare i gestori di exit
definiti dal processo genitore e svuotare i buffer di stdio (3)
del processo genitore), ma può chiamare _exit (2).
***************
On systems where memory is constrained, vfork () avoids the need
to temporarily commit memory (see the description of
/proc/sys/vm/overcommit_memory in proc (5)) in order to execute a
new program.
--- 
Su sistemi in cui la memoria è limitata, vfork () permette di
evitare di utilizzare memoria temporaneamente (si veda la
descrizione di /proc/sys/vm/overcommit_memory in proc (5)) per
l'esecuzione di un nuovo programma.
***************
(This can be especially beneficial where a large parent process
wishes to execute a small helper program in a child process.)
--- 
(Ciò può essere particolarmente vantaggioso dove un processo
genitore ampio vuole eseguire un piccolo programma di aiuto in un
processo figlio.)

***************
By contrast, using fork (2) in this scenario requires either
committing an amount of memory equal to the size of the parent
process (if strict overcommitting is in force) or overcommiting
memory with the risk that a process is terminated by the
out-of-memory (OOM) killer.
--- 
Di converso, usando fork (2) in questo scenario richiede o di
dedicare una quantità di memoria uguale alla dimensione del
processo genitore (se è attivo l'overcommit rigoroso) o utilizzare
più memoria di quella disponibile (overcommit) col rischio che un
processo venga fatto terminare dal killer OOM (out-of-memory).
***************
.SS Caveats
The child process should take care not to modify the memory in
unintended ways, since such changes will be seen by the parent
process once the child terminates or executes another program.
--- 
.SS Avvertenze
Il processo figlio dovrebbe stare attento a non modificare la
memoria inavvertitamente, poiché tali cambiamenti verranno visti
dal processo genitore una volta che il processo figlio termina o
esegue un altro programma.
***************
In this regard, signal handlers can be especially problematic: if
a signal handler that is invoked in the child of vfork () changes
memory, those changes may result in an inconsistent process state
from the perspective of the parent process (e.g., memory changes
would be visible in the parent, but changes to the state of open
file descriptors would not be visible).
--- 
A tale proposito, i gestori dei segnali possono essere
particolarmente problematici: se un gestore di segnali che è
invocato nel processo figlio di vfork () cambia memoria, quei
cambiamenti possono determinare uno stato di processo incoerente
dal punto di vista del processo genitore (p.es., i cambiamenti di
memoria sarebbero visibili nel processo genitore, ma i cambiamenti
allo stato dei descrittori dei file aperti non sarebbero
visibili).
***************
When vfork () is called in a multithreaded process, only the
calling thread is suspended until the child terminates or executes
a new program.
--- 
Quando vfork () viene chiamato in un processo multithread, solo il
thread chiamante viene sospeso fino a quando il processo figlio
termina o esegue un nuovo programma.
***************
This means that the child is sharing an address space with other
running code.  This can be dangerous if another thread in the
parent process changes credentials (using setuid (2) or similar),
since there are now two processes with different privilege levels
running in the same address space.
--- 
Ciò significa che il processo figlio sta condividendo uno spazio
di indirizzo con dell'altro codice in esecuzione.  Questo può
essere pericoloso se un altro thread nel processo genitore cambie
le credenziali (usando setuid (2) o simili), poiché ci sono ora
due processi con differenti livelli di privilegio in esecuzione
sullo stesso spazio di indirizzo.
***************
As an example of the dangers, suppose that a multithreaded program
running as root creates a child using vfork ().  After the vfork
(), a thread in the parent process drops the process to an
unprivileged user in order to run some untrusted code (e.g.,
perhaps via plug-in opened with dlopen (3)).  In this case,
attacks are possible where the parent process uses mmap (2) to map
in code that will be executed by the privileged child process.
--- 
Come esempio di pericolo, supponiamo che un programma multithread
in esecuzione come root crei un processo figlio usando vfork ().
Dopo il vfork (), un thread nel processo genitore cancella il
processo a un utente senza privilegi allo scopo di eseguire del
codice non sicuro (p.es., forse attraverso un plug-in aperto con
dlopen (3)).  In questo caso, sono possibili attacchi nel caso in
cui il processo genitore usi mmap (2) per mappare nel codice che
verrà eseguito dal processo figlio che ha i privilegi.
***************