Gestió de processos Unix
 |
Aquest article necessita diverses millores. Ajudeu modificant-lo ara o participant a la pàgina de discussió.
|
La gestió de processos Unix és una de les funcionalitats principals dels sistemes operatius Unix o similars (Unix-like). Els sistemes operatius Unix es fan càrrec de la gestió de processos de forma correcta per tal de garantir que els processos es processin de manera eficient i que s'assignin els recursos de forma equitativa. Això permet que el sistema operatiu funcioni de forma òptima i ofereixi un rendiment acceptable per a les persones usuàries.
La gestió de processos Unix inclou la creació de processos mitjançant mecanismes com la crida de sistema fork o els fils d'execució. També inclou la planificació i sincronització dels processos, ja que hi ha diferents models d'execució i algorismes per a planificar-ne l'execució de la forma més eficient possible. La protecció i el control d'accés als recursos del sistema també formen part de la gestió de processos, ja que la seguretat del sistema depèn en gran manera de la capacitat de controlar l'accés que els processos tenen a recursos del sistema o a recursos d'altres processos. Finalment, la comunicació entre processos és un altre element clau de la gestió de processos, ja que els processos han de disposar de mecanismes per a comunicar-se entre ells i treballar de forma coordinada.
La gestió de processos és fonamental per a garantir l'eficiència del sistema operatiu i la seva capacitat de mantenir l'equilibri entre els diferents processos que s'executen al sistema.
Creació de processos Unix[modifica]
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 és conegut com a Planificador, també conegut pels termes anglesos swapper o scheduler. Es diu que aquest procés té l'identificador de procés 0 (PID 0) perquè la seva execució és prèvia a l'execució del procés init (PID 1).
Crida de sistema fork[modifica]
La crida de sistema fork és l'encarregada de crear nous processos a partir d'altres processos.
Fils d'execució[modifica]
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[modifica]
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 una altra 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ó[modifica]
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é és conegut pels termes anglesos swapper o scheduler. Es diu que aquest procés té l'identificador de procés 0 (PID 0) perquè la seva execució és prèvia a l'execució del procés init (PID 1).
Model d'estats Unix[modifica]
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 executa el procés. En un instant concret de temps, si el sistema és monoprocessador, només un procés pot utilitzar 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 està aturat segurament per un senyal. Per exemple un procés que està 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 s'ha 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[modifica]
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. Es diu que aquest procés té l'identificador de procés 0 (PID 0) perquè la seva execució és 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[modifica]
Els processos es 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 d'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 d'ordres (per exemple bash) són fills de la línia d'ordres
$ pstree ... |-gnome-terminal-+-bash-+-more | | |-pstree | | `-2*[sleep]
Procés orfe[modifica]
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[modifica]
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[modifica]
En qualsevol moment es pot aturar un procés amb la combinació de tecles Ctrl+Z. També es pot fer des del 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[modifica]
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 està 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 es 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.