Gestió de processos Unix

Una de les funcionalitat principals dels sistemes operatius Unix o similars (Unix-like) és gestionar de forma correcta l'execució de processos. Podem dividir la gestió de processos en 4 parts:

Creació de processos UnixModifica

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 forkModifica

Article principal: Fork (Unix)

La crida de sistema fork és l'encarregada de crear nous processos a partir d'altres processos.

Fils d'execucióModifica

Article principal: Fil 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 sistemaModifica

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: exec i 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 UnixModifica

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 està 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 està aturat segurament per un senyal. Per exemple un procés que està 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 UnixModifica

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 fillModifica

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 orfeModifica

Article principal: 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 zombiModifica

Article principal: 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 aturatModifica

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 sistemaModifica

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.

Comunicació entre processosModifica

Article principal: Comunicació entre processos

Vegeu tambéModifica

Enllaços externsModifica