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

[Antonio Giovanni Colombo]

Marco,

qui sotto vedi le variazioni che io apporterei...
Come al solito, tendo ad allungare il brodo.

Ciao a tutti, Antonio
​
-- 
   /||\    | Antonio Colombo
  / || \   |  azc100 a gmail.com
 /  ()  \  | antonio a geekcorp.com
(___||___) |   azc10 a yahoo.com

========================================================

> (Per inciso, killer l'ho lasciato killer; si potrebbe tradurre con
> "processicida"?)
"terminare" (Terminator?)

A me viene naturale "processo-padre" "processo-figlio",
ma se tutto il resto ha "genitore", vada per "genitore".
***************

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 processo-figlio non deve ritornare
dalla funzione attuale e neppure chiamare
exit (3) (cosa che avrebbe l'effetto di attivare i gestori di exit
definiti dal processo-padre e svuotare i buffer di stdio (3)
del processo-padre), 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 un utilizzo temporaneo di memoria (si veda la
descrizione di /proc/sys/vm/overcommit_memory in proc (5)) usato
quando si innesca 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 qualora un
processo-padre di grosse dimensioni voglia eseguire un piccolo
programma ausiliario 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.
---
Viceversa, usando fork (2) in questo scenario richiede o di
dedicare una quantità di memoria uguale alla dimensione del
processo-padre (se è attivo l'overcommit rigoroso) o di utilizzare
più memoria di quella disponibile (overcommit) col rischio che un
processo venga fatto terminare (dall'OOM -- out-of-memory killer)
perché è stata esaurita la memoria disponibile.

["viceversa" suona meglio, ma non sono sicuro sia adeguato
al contesto. Anche la perifrasi per il "killer" va a scapito
della concisione.]
***************

.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 avrebbero
effetti sul processo-padre una volta che il processo-figlio
sia terminato oppure esegua 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 di segnale possono essere
particolarmente problematici: se un gestore di segnali che è
invocato nel processo-figlio di vfork () modifica la memoria, tale
modifica può determinare uno stato di processo incoerente
dal punto di vista del processo-padre (p.es., i cambiamenti di
memoria sarebbero visibili dal processo-padre, 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
(nel quale parti diverse dello stesso programma vengono
eseguite in parallelo),
solo il thread chiamante viene sospeso fino a quando il
processo-figlio termina o esegue un nuovo programma.
[Gli altri processi continuano in maniera indipendente.]
***************

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 della
memoria con dell'altro codice in esecuzione.  Questo può
essere pericoloso se un altro thread nel processo-padre cambia
le credenziali (usando setuid (2) o simili), poiché ci sono ora
due processi con differenti livelli di privilegio in esecuzione,
che utilizzano la stessa memoria.
***************

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 dei rischi che si corrono,
supponiamo che un programma multithread
in esecuzione come root crei un processo-figlio usando vfork ().
Dopo il vfork (), un thread nel processo-padre altera il
processo stesso attribuendolo a un utente senza privilegi
allo scopo di eseguire del
codice non sicuro (p.es., magari utilizzando un plug-in aperto con
dlopen (3)).
In tal caso sono possibili attacchi in
cui il processo-padre usa mmap (2) per rendere disponibile del codice
che verrà eseguito dal processo-figlio che ha i privilegi.
***************
​