sequenceDiagram
participant P as Pare
participant K as Kernel
participant C as Fill
Note over P: Estat abans de fork()<br>RAX = ?, PC = adreça_crida_fork
P->>K: `fork()`
activate K
K-->>P: Retorn al Pare:<br>RAX = Child PID <br>PC = adreça_següent_instrucció
K-->>C: Retorn al Fill:<br>RAX = 0<br>PC = adreça_següent_instrucció
deactivate K
par Execució paral·lela des del mateix punt
P-->>P: Pare: Continua l'execució.(`if (RAX > 0)`)
C-->>C: Fill: Continua l'execució.(`if (RAX == 0)`)
end
Note over P,C: Ambdós processos s'executen de manera independent
Creació de Processos a Linux
Unitat 3 · Sistemes Operatius (SO)
Mecanisme de Creació fork()
fork() crea una còpia exacta del procés actual (el pare). Aquesta còpia esdevé el procés fill i s’executa independentment i simultàniament.
#include <sys/types.h> # pid_t
#include <unistd.h> # fork()
int main() {
pid_t pid = fork();
exit(0);
}Espai de Memòria
Els processos pare (A) i fill (B) no comparteixen espai de memòria. Cada procés té el seu propi espai d’adreces virtuals. No obstant això, el contingut inicial de la memòria del procés pare es copia a l’espai d’adreces del fill.
Gestió de Memòria · fork()
Observacions
- En el moment de
fork()\(\rightarrow\) El pare i el fill comparteixen el mateix espai d’adreces físic. - Cada procés té el seu propi espai d’adreces virtual, que tradueix a l’espai d’adreces físic compartit.
Duplicats idèntics
Inicialment, el pare i el fill són duplicats idèntics. A partir d’aquest moment, cada procés té el seu propi espai d’adreces virtual, i qualsevol modificació en un no afecta l’altre.
Indeterminisme fork()
int main() {
pid_t pid;
if ((pid = fork()) < 0) {
exit(-1);
} else if (pid == 0) {
printf("My name is Rhaenyra")
} else {
printf("My name is King Viserys");
}
exit(0);
}
Observacions
- La execució del programa és no determinista.
- El procés pare i el fill poden executar-se en qualsevol ordre.
- L’planificador del sistema operatiu decideix quin procés s’executa en un moment donat.
Exemple: waitpid() & Macros
int main(int argc, char *argv[]){
pid_t pid, w; int status;
pid = fork();
if (pid == 0) {
if (argc == 1) pause(); exit(atoi(argv[1]));
} else {
do {
w = waitpid(pid, &status, WUNTRACED | WCONTINUED);
if (w == -1) {
perror("waitpid"); exit(EXIT_FAILURE);
}
if (WIFEXITED(status)) {
printf("exited, [%d] status=%d\n",
pid, WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
printf("killed by signal,
[%d] -> %d\n", pid, WTERMSIG(status));
} else if (WIFSTOPPED(status)) {
printf("stopped by signal [%d]
-> %d\n", pid, WSTOPSIG(status));
} else if (WIFCONTINUED(status)) {
printf("continued\n"); }
} while (!WIFEXITED(status) && !WIFSIGNALED(status));
exit(0);
}
Pregunta?
Quin serà el resultat després d’executar ./ex8 42?
Familia exec()
Valors de retorn
- Mai retorna en cas d’èxit (substitueix completament el procés).
- Retorna -1 només en cas d’error (s’estableix
errno).
#include <unistd.h>
// Variants with argument list (variable arguments)
int execl(const char *path, const char *arg0, ..., NULL);
int execlp(const char *file, const char *arg0, ..., NULL);
int execle(const char *path, const char *arg0, ..., NULL,
char *const envp[]);#include <unistd.h>
// Variants with argument vector (array)
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[],
char *const envp[]); Això és tot per avui
TAKE HOME MESSAGE
La creació i gestió de processos és fonamental en els sistemes operatius. Hem explorat com fork() crea nous processos, com exec() permet la transformació de processos, i com wait() i waitpid() gestionen la sincronització entre pares i fills. A més, hem vist com es gestionen els processos zombies i orfes, i la importància de les macros per interpretar els estats dels processos fills.
