Gestió de processos Unix
Una de les funcionalitat principals dels sistemes operatius Unix o similars (Unix-like) és gestionar de forma correcte l'execució de processos. Podem dividir la gestió de processos en 4 parts:
- Creació: El sistemes operatius ofereixen mecanisme de creació de processos com la crida de sistema
forko els fils d'execució. - Planificació i sincronització: Existeixen diferents models a l'hora d'executar processos i diferents algorismes per a planificar-ne l'execució de la forma més eficient possible.
- Protecció i control d'accés als recursos del sistema: La seguretat de tot el sistema depèn en gran part de la capacitat de controlar l'accés que els processos tenen a recursos del sistema o a recursos de altres processos.
- Comunicació entre processos: Els processos han de disposar de mecanismes per a comunicar-se entre ells i poden així treballar de forma coordinada.
Creació de processos Unix
La creació de processos és una tasca que gestiona el sistema operatiu del sistema. Les aplicacions que s'executen en l'espai d'usuari del sistema, no poden crear directament nous processos i han de delegar aquesta tasca al sistema operatiu. Aquesta delegació es du a terme mitjançant crides al sistema.
A UNIX, un procés pot crear un altre procés mitjançant la crida al sistema fork. El procés original és anomenat procés pare i el nou procés és anomenat procés fill.
Aquest sistema de generació de processos crea el que es coneix com l'arbre de processos del sistema. Tots els processos del sistema tenen un procés pare, formant una estructura de dades arbre. L'arrel d'aquest arbre és el procés inicial del sistema, que en Unix se sol anomenar procés init. L'ordre pstree mostra aquest arbre de processos.
El procés init és considerat el primer procés d'usuari del sistema i per aquest raó se li assigna l'identificador de procés (PID) 1. Aquest procés és executat pel nucli (del terme anglès kernel) del sistema operatiu durant l'arrancada del sistema.
La gestió de tots els processos d'un sistema la duu a terme el nucli del sistema operatiu, el procés del nucli encarregat d'aquesta tasca es conegut com a Planificador, també conegut pels termes anglesos swapper o scheduler. És diu que aquest procés té l'identificador de procés 0 (PID 0) per que la seva execució es prèvia a l'execució del procés init (PID 1).
Crida de sistema fork
La crida de sistema fork és l'encarregada de crear nous processos a partir d'altres processos.
Fils d'execució
La generació de nous processos amb la crida de sistema fork() és un força costosa i per aquesta raó molts sistemes operatius tenen l'opció de crear fils d'execució, també coneguts com a processos lleugers.
Altres crides de sistema
Més enllà de la crida de sistema fork(), existeixen altres crides relacionades amb la gestió de processos:
- Crear un procés;
fork() - Destruir un procés:
exit() - Esperar l'acabament d'un fill:
wait()
Unix guarda l'estat d'acabament dels processos destruïts en el seu bloc de control de procés en espera que el procés pare reculli aquest estat mitjançant la crida wait. Els processos que estan en aquest estat intermedi entre vius i morts se'ls anomena zombies.
Crides de sistema per a canviar d'executable:
- Executar un altre aplicació des d'una aplicació concreta:
execi similars.
Manipulació de descriptors de fitxer:
Aquestes crides de sistema són necessàries per a la gestió de la comunicació entre processos pares i fills.
- Tancar un descriptor de fitxer:
close() - Assignar un descriptor de fitxers a la taula de descriptors de fitxers d'un procés:
dup()assigna un descriptor de fitxer a la primera posició lliure de la taula.
Planificació i sincronització
L'encarregat de la sincronització i de la planificació de processos és el nucli del sistema operatiu, més concretament el component del nucli que es coneix com a Planificador. El planificador s'executa a l'inici del sistema com a procés del nucli del sistema operatiu i abans de l'execució de qualsevol procés de sistema (incloent el procés init).
El planificador també es conegut pels termes anglesos swapper o scheduler. És diu que aquest procés té l'identificador de procés 0 (PID 0) per que la seva execució es prèvia a l'execució del procés init (PID 1).
Model d'estats Unix
UNIX com la majoria de sistemes operatius moderns, utilitza un model de 7 estats on intervé el concepte d'intercanvi (swapping) de memòria virtual. Els processos poden romandré en espera de ser executats o aturats en memòria principal (sovint memòria RAM) o en memòria secundària (sovint al disc dur del sistema).
Segons el manual de l'ordre ps, existeixen 6 estats possibles de procés:
- En execució (R del terme anglès Running): La CPU del sistema està executant el procés. En un instant concret de temps, si el sistema és monoprocessador, només un procés pot esta fent ús de la CPU.
- En espera (Waiting): El procés esta esperant un esdeveniment o un recurs d'E/S. Linux diferencia dos tipus de processos en espera:
- En espera interrumpible (S, Waiting interruptible): Són processos que estan en espera i que poden ser interromputs per senyals.
- En espera no interrumpible (D. Waiting uninterruptible): Procés en espera que no pot ser interromput.
- Atura (T, Stopped): El procés esta aturat segurament per un senyal. Per exemple un procés que esta sent depurat per un depurador.
- Zombie (Z): és un procés finalitzat però que encara està la seva estructura de dades (BCP) en memòria.
- Terminat (X): El procés ha finalitzat.
A aquest esta cal afegir-li l'estat creat, que indica que un procés ha estat acabat de crear però que encara no està disponible per a la seva execució.
A Linux també es diferencia entre els processos que estan sent executats en mode nucli o en mode usuari.
Jerarquia de processos Unix
A Unix, un procés pot crear un altre procés mitjançant la crida al sistema fork.
Aquest sistema de generació de processos crea el que es coneix com larbre de processos del sistema. Tots els processos del sistema tenen un procés pare, formant una estructura de dades arbre. L'arrel d'aquest arbre és el procés inicial del sistema, que en Unix se sol anomenar procés init. Podeu consultar l'arbre de processos d'un sistema Unix amb l'ordre pstree.
El procés init és considerat el primer procés d'usuari del sistema i per aquest raó se li assigna l'identificador de procés (PID) 1. Aquest procés és executat pel nucli del sistema operatiu (del terme anglès kernel) del sistema operatiu durant l'arrancada del sistema.
La gestió de tots els processos d'un sistema la duu a terme el nucli del sistema operatiu. El procés del nucli encarregat d'aquesta tasca és conegut com a Planificador. És diu que aquest procés té l'identificador de procés 0 (PID 0) per que la seva execució es prèvia a l'execució del procés init (PID 1).
El planificador, també és conegut pels termes anglesos swapper o scheduler
Procés pare i procés fill
Els processos és creen amb la crida de sistema fork. El procés que executa fork és el pare i el nou procés és el fill. Podem observar la jerarquia dels processos de Unix amb l'ordre pstree:
$ pstree
init-+-NetworkManager
|-NetworkManagerD
|-acpid
|-amarokapp-+-ruby
| `-8*[{amarokapp}]
|-apache2---6*[apache2]
|-atd
|-avahi-daemon---avahi-daemon
|-bonobo-activati---{bonobo-activati}
|-console-kit-dae---61*[{console-kit-dae}]
|-cron
|-cupsd---{cupsd}
|-2*[dbus-daemon]
...
Els processos executats en una línia de comandes (per exemple bash) són fills de la línia de comandes
$ pstree ... |-gnome-terminal-+-bash-+-more | | |-pstree | | `-2*[sleep]
Recursos:
Procés orfe
Un procés orfe, és aquell procés que el procés pare ha finalitzat la seva execució.
En sistemes Unix els processos orfes són adoptats immediatament pel procés init (llevat que els senyals del pare facin acabar també el procés fill en el cas que mori el procés pare com poden ser aquells processos que es tanquen al tancar el terminal des del qual s'han executat).
Procés zombi
A Unix, un procés zombi o "defunct" (mort) és un procés que ha completat la seva execució però que encara té entrades a la taula de processos. Això permet al pare llegir l'estat de sortida del procés. Metafòricament, el procés fill ha mort però la seva ànima encara no ha estat recollida pel seu pare.
El pare rep un senyal SIGCHLD indicant que el procés fill ha mort. El controlador per defecte d'aquest senyal serà llegir l'estat del procés fill amb wait i esborrar el zombi.
Els processos zombi es poden identificar per la presència d'una Z a la columna d'estat:
$ ps aux| grep Z USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 5689 0.0 0.3 7772 3920 ? Ss 10:28 0:00 /usr/bin/python2.4 /usr/lib/zope2.9/lib/python/zdaemon/zdrun.py -S sergi 6138 0.0 0.0 0 0 ? Z 10:31 0:00 [python] <defunct> sergi 15727 0.0 0.0 2896 760 pts/3 R+ 14:30 0:00 grep Z
Procés aturat
En qualsevol moment es pot aturar un procés amb la combinació de tecles Ctrl+Z. També es pot fer des de el monitor del sistema. Els processos aturats estan en estat T (aturat).
Exemple:
$ sleep 20
Premeu la combinació de tecles: Ctrl+Z
[2]+ Stopped sleep 20
$ ps aux | grep sleep sergi 477 0.0 0.0 2892 612 pts/0 T 18:33 0:00 sleep 20
Protecció i control d'accés als recursos del sistema
En el dissenys d'un sistema operatiu és molt important tenir en compte la protecció del sistema tant contra errors no provocats (tolerància d'errors del sistema) com contra usos il·lícits (Seguretat del sistema).
Es diferencien dos espais o modes de treball que separen l'accés a la memòria virtual
- Mode supervisor o mode kernel: No té restriccions d'accés a la memòria i pot accedir a qualsevol adreça, de qualsevol procés o de qualsevol dispositiu que estigui en memòria i per tant no té cap mena de restricció d'accés. Aquest espai esta reservat per a ús del nucli o dels seus mòduls o d'alguns drivers. Programar en aquest espai és molt més complicat ja que s'ha de tenir molta cura de no interferir entre diferents espais de memòria de processos. Un programa en l'espai de supervisor s'ha de dissenyar amb la idea de no fallar mai, ja que un error en aquest programa pot desencadenar un error en tot el sistema.
- Mode usuari o espai d'usuari : En contrast, l'espai d'usuari és la zona on s'executen les aplicacions d'usuari. En la majoria de sistemes operatius actual cada procés té el seu propi espai de memòria i no pot accedir a la memòria d'altres processos i d'aquesta manera s'evita la interferència entre processos.
L'única forma en que un procés de l'espai d'usuari pot accedir a la memòria d'altres processos és a través de les crides de sistema (interfície) del sistema operatiu, de forma que el sistema operatiu pot gestionar el control d'accés als recursos.
Unix separa la protecció de memòria del sistema en mode usuari i mode administrador. És per tant un sistema d'anells de protecció de 2 capes o anells
La tolerància a errors és especialment important en els sistemes multiprocés on és necessari protegir els processos entre si (és a dir evitar que un procés pugui afectar el correcte funcionament d'un altre procés). És evident que certs processos han de ser especialment tolerants a errors per a evitar penjades del sistema.
L'ordre time és permet executar un procés i mostrar les estadístiques del temps que un procés s'executa en mode usuari o en mode nucli.
Comunicació entre processos
Vegeu també
- Gestió de processos
- Control de tasques (Unix)
- Ordre ps
- Ordre pstree
- Ordre jobs
- Ordre sleep
- bg
- fg
- Ordres Unix
Fonts
- Process States a la Wikipedia anglesa (anglès)