IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

Linux Professional Institute Certificate. LPIC-1

Lpic1 large.gif
Certificat LPIC-1
Examen: 101 (torneu a la resta de temes)
Fitxers: LPI103.5_CrearmonitoritzarMatarProcessos.pdf (LPI103.5_CrearmonitoritzarMatarProcessos.odp) , UD_8_7_admin_processos.pdf
Objectius: http://www.lpi.org/eng/certification/the_lpic_program/lpic_1/exam_101_detailed_objectives
Dipòsit SVN: https://svn.projectes.lafarga.cat/svn/lpi/Materials/Examen_101/103.5
Usuari: anonymous
Paraula de pas: qualsevol paraula de pas

Objectius del tema

103.5. Crear, monitoritzar o matar processos
Objective.jpg
  • Objectiu: Els candidats han de ser capaços de gestionar els processos a un nivell bàsic.
  • Pes: 4
060317 Icon - Theory of Knowledge v01 pdc.jpg

Àrees Clau de Coneixement:

Icon list.jpg

La següent és una llista parcial de fitxers, termes i utilitats utilitzades:

Text-editor.svg

Apunts: LPI 103.5. Crear, monitoritzar o matar processos

Plantilla per prendre apunts

Definició de procés

En informàtica un procés és una instància d'una aplicació que esta essent executada per una computadora. Una aplicació o programa és solament una col·leció passiva d'instruccions que no esdevenen un procés fins que el programa és executat.

Un procés és el conjunt de recursos necessari per executar un programa. Des del punt de vista del sistema operatiu és un recurs més que s'ha de 
gestionar.

Cal destacar també que una sola aplicació o programa pot arribar a executar múltiples processos al mateix temps (per exemple un servidor com Apache pot tenir múltiples processos pendents de rebre peticions de connexió).

La concurrència real de processos (diferents processos executant-se al mateix temps) pot esdevenir de 2 formes diferents:

  • Sistemes operatius multitasca: Els processos aparentment s'executen al mateix temps tot i que realment, en un instant concret de temps, només hi ha un procés que estigui utilitzant la CPU. Un ordinador amb un sol processador executa les instruccions una a una, però pot intercalar diferents processos utilitzant una multiplexació en temps (Time-sharing), procés que a certes velocitats produeix la "il·lusió" que el sistema treballa amb diferents processos al mateix temps. Aquest procés és anomenat concurrència o multiprogramació
  • Sistemes operatius multiprocés: l'única forma de tenir un sistema multiprocés real és tenir més d'una CPU. Els sistemes operatius que suporten treballar amb més d'una CPU a l'hora s'anomenen multiprocés. Aquests sistemes també permeten al mateix temps la concurrència de processos en un mateix processador.

Recursos:

Linux és un sistema operatiu multitasca i pot executar diferents processos al mateix temps i és possible llançar vàries instàncies d’un mateix programa simultàniament.

Linux, com a sistema multitasca i multiprocés, conté tot un seguit d’eines per a la monitorització i gestió dels processos que estan en execució des de la línia de comandes.

Elements d'un procés

Els processos realment acaben sent estructures de dades que contenen informació sobre els programes que està executant el sistema operatiu. Aquestes estructures de dades tenen múltiples elements, però de forma resumida i per al que ens interessa per a aquest curs, parlarem de:

  • Identificador del procés (Process Identificator (PID) en anglès).
  • Identificador del procés pare (PPID).
  • Prioritat del procés (en el cas que s'utilitzi)
  • Estat del procés: hi han diferents models d'estats.
  • Senyals pendents de ser processades.

Consulteu:

http://acacha.org/wiki_privada/index.php/Usuari:Sergi/Temari/Tema_16_Sistemas_operativos:_Gesti%C3%B3n_de_procesos.#Elements_d.27un_proc.C3.A9s

Per obtenir més informació sobre els elements d'un procés

L'identificador de procés (PID)

Tot procés s’identifica amb un número únic, el PID (Process IDentifier). L'encarregat de gestionar els processos és el nucli del sistema operatiu (kernel) i disposa d'una taula de processos on cada procés es identificat pel seu PID.

Una aplicació no pot crear un procés directament. Es necessari demanar al sistema operatiu que crei el procés i el gestioni. Es disposa de dos crides de sistema per tal de poder crea processos:

fork: permet que un procés crei un nou procés. Aquest nou procés es anomenat procés fill
exec: permet executar una aplicació externa. 

NOTA: No confongueu la crida de sistema exec amb l'ordre del mateix nom. Al final exec (l'ordre) acaba utilitzant la crida de sistema exec però no són el mateix. De fet, al manual de Linux (man) trobareu una secció per a cada cas

La variable d'entorn $ conté el PID del procés que s'està executant en un moment donat:

$ echo $$
3546
$ ps aux | grep 3546
sergi     3546  0.0  0.1   6832  4124 pts/0    Ss   07:10   0:00 bash
...

Consulteu:

http://acacha.org/wiki_privada/index.php/Usuari:Sergi/Temari/Tema_16_Sistemas_operativos:_Gesti%C3%B3n_de_procesos.#Processos

Per tal d'obtenir més informació sobre la gestió de processos dels sistemes operatius.

L'identificador del procés pare (PPID)

Consulteu també la variable d'entorn $PPID

Com ja hem comentat anteriorment, tots els processos de Linux tenen un procés pare a partir del qual han estat generats. El identificador del procés pare (PPID) és la variable que conté el PID del procés pare d'un procés

Hi ha una variable d'entorn que conté aquesta informació:

$ echo $PPID
3459
$ ps aux | grep 3459
sergi     3459  0.0  0.3  49408 13776 ?        Rl   07:10   0:03 gnome-terminal

Observeu que normalment en el cas d'un emulador de terminal el procés pare de l'interpret d'ordres és precisament l'emulador de terminal (a l'exemple gnome-terminal).

Tipus de processos

Fils d'execució vs processos

Consulteu:

http://acacha.org/wiki_privada/index.php/Usuari:Sergi/Temari/Tema_16_Sistemas_operativos:_Gesti%C3%B3n_de_procesos.#Fils_d.27execuci.C3.B3

Estat dels processos

Existeixen múltiples models d'estats segons el tipus de sistema operatiu. Consulteu

Cicle de vida d'un procés. Estats

i també:

Processos_Linux#Estats_d.27un_proc.C3.A9s._Model_d.27estats

Per tal de consultar la teoria bàsica de sistemes operatius.

Els estats definits pel camp STAT de la sortida de l'ordre ps presenten tres caràcters. En Linux, els valors del primer signifiquen:

  R “Running”. Procés en curs d’execució (l'està utilitzant la CPU)
  T “sTopped”. Procés parat (amb les tecles Ctrl + Z per exemple)
  S “Sleeping”. Procés dormit, en espera del processador.
  D “Device”. Procés dormit en espera d’un recurs (generalment una
    entrada/sortida). Els processos en aquest estat no poden interrompre’s.
  Z “Zombie”. Procés terminat. Seguirà en aquest estat fins que el seu pare ho noti i recuperi el seu codi de retorn. 
    Com els anteriors (D), aquests processos no poden interrompre’s, però no consumeixen cap recurs, excepte una 
    entrada en la taula de processos.

El segon caràcter del camp STAT està posat a W si el procés s’ha mogut a l’espai de paginació.

Finalment apareix una N o un < com a tercer caràcter de la columna STAT si el procés és respectivament de menor o de major prioritat.

Extret del manual de ps:

$  man ps 
...
 
D    Uninterruptible sleep (usually IO)
R    Running or runnable (on run queue)
S    Interruptible sleep (waiting for an event to complete)
T    Stopped, either by a job control signal or because it is being
     traced.
W    paging (not valid since the 2.6.xx kernel)
X    dead (should never be seen)
Z    Defunct ("zombie") process, terminated but not reaped by its
          parent.

Es pot dir que Unix utilitza un model d'estats de 7 nivells:

Procesos-7estados.png

Jerarquia de processos Unix. L’arbre de processos

En Unix/Linux els processos només es poden executar a partir de processos ja existents fet que comporta que els processo acabin tenint una jerarquia i unes relacions pare/fill.

La crida de sistema que permet en Unix crear un nou procés és fork. Fork crea un procés fill que és una còpia exacte del procés pare i que 
s'executa en paral·lel al procés pare

Dos conceptes:

  • Herència: El procés hereta totes les propietats del pare (de fet és una còpia exacte del seu pare).
  • Sincronització entre processos pare i fill: un procés pare i el seu fill és poden comunicar utilitzar els sistemes que ofereix el sistema per a la comunicació entre processos.

El procés init

És l’arrel de la jerarquia de processos Linux. init, un procés a nivell de sistema que s’engega cada cop que iniciem el sistema.

El PID i PPID del procés init és 1, o dit d’una altra manera init és el seu propi pare.

Consulteu l'objectiu LPI 101.2. Arrancar el sistema

Exemple per visualitzar la jerarquia de processos Linux

Una de les formes més adequades de veure com funcionen els processos i la seves relacions és veure el funcionament de la línia de comandes de Unix (per exemple bash). En un sistema Linux amb entorn gràfic X-Windows amb Gnome podriem executar:

$ pstree
...
    ├─gnome-terminal─┬─8*[bash]
    │                ├─bash─┬─pstree
    │                │      └─sleep

Com podeu observar la terminal gràfica (aplicació gnome-terminal) és pare de 9 línies de comandes (aplicacions bash), cadascuna s'executa en un pestanya diferent. A una d'aquestes línies de comandes s'estan executant dos processos: pstree i sleep. Això o podem aconseguir executant:

$ sleep 10 &

El ampersand (&) indica que el procés s'executara en segon terme. També podem utilitzar la comanda equivalent

$ bg 


Els sistemes Unix tenen un procés que és el procés pare de tota la resta de processos. Aquest procés s'anomena init i té com identificador de procés (PID) el número 1. Aquesta jerarquia entre processos es pot observar executant la comanda pstree

$ pstree | more
init-+-NetworkManager
     |-NetworkManagerD
     |-acpid
     |-amarokapp-+-ruby

El sistema Unix va assignant el número de PID de forma incremental a mesura que s'executen els processos. La comanda ps ens mostra els processos ordenats per PID:

$ ps aux | more
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1   2952  1852 ?        Ss   09:07   0:01 /sbin/init

El nucli del sistema operatiu. scheduler

El gestor d'arrancada, el primer programa que executa és el sistema operatiu (kernel). El procés encarregat de la gestió dels processos se l'anomena scheduler i és diu que té el PID 0. No el podem visualitzar amb les ordres d'usuari.

Consulteu kernel. Consulteu LPI 101.2. Determinar i configurar el maquinari

Manipulació de processos

Com crear processos

La forma més senzilla de crear un procés es escrivint el nom d'una aplicació o ordre a un interpret d'ordres. Per exemple:

$ sleep 10

Executa un programa que no fa res durant 10 segons. Podem executar altres aplicacions menys de "juget", com per exemple:

$ find -n -r "text_a_buscar" /

Que iniciarà un procés que cercarà fitxers a tot el sistema que continguin un text concret.

Des de l'interpret d'ordres, també podem executar aplicacions gràfiques si ens trobem dins d'un emulador de terminal que s'executa dins d'un entorn X-Window. Per exemple, a Gnome podem llegir un document PDF amb:

$ evince  document.pdf

O un document Open Office:

$ oowriter document.odt

Executar processos en primer terme

És la forma més habitual i el mode per defecte en que s'executen les ordres. Vegeu també l'ordre fg.

Executar processos en segon terme

El mode per defecte en que s'executa una ordre a la línia d'ordres és en primer pla. Per executar una comanda en segon pla, s'utilitza l'operador &

$ ordre &

Per exemple:

$ sleep 10 &
[1] 2514
$ 
[1]+  Fet                     sleep 10

Substituir un programa en execució per un altre. Comanda exec

Consulteu exec.

Control de tasques en un interpret d'ordres

Consulteu Control de tasques Unix. El control de tasques es realitza amb les ordres:

Acabar un procés

Hi ha 3 formes d'acabar prematurament un procés que s'està executant en primer pla:

  • Ctrl-c: Envia el senyal 2 (SIGINT). La majoria d'aplicacions estan programades per finalitzar l'execució tan bon punt reben aquesta senyal (NOTA: cal tenir en compte que es pot programar una aplicació que capturi aquesta senyal i la ignori. Algunes comandes de no ho fan així ho requereixen d'una doble confirmació abans de finalitzar el procés)
  • Ctrl+\: S'envia el senyal 3 (SIGQUIT). També depèn de com estigui programada l'aplicació.
  • Utilitzar kill

L'única forma de finalitzar un procés que s’executa en segon pla és utilitzar la comanda kill apropiada ja que el procés ha passat el control a l’usuari i ja no pot controlar-se directament des del terminal mitjançant la combinació de tecles.

Informació sobre processos: ps i pstree

Aquestes dues comandes mostren una llista dels processos que s’estan executant en el sistema.

ps

A la majoria de sistemes operatius de la família Unix (UNIX-like), l'ordre ps (process status) permet visualitzar els processos que s'estàn executant.

Hi han diferents implementacions de la comanda ps, les quals difereixen sobretot en la forma d'utilitzar les opcions. Podem destacar 3 versions principals:

  1. Opcions UNIX: les opcions han d'estar totes agrupades i han d'estar precedides per un guió (-).
  2. Opcions BSD: poden estar agrupades i no utilitzen mai el guió (-).
  3. Opcions llargues de GNU: van precedides per dos guions (--)

Si executem aquesta comanda sense cap argument, només es mostraran aquells processos iniciats per l’usuari (tècnicament els processos amb el mateix EUID que el de l'usuari) i que fan referència al terminal que aquest està utilitzant:

$ ps
PID TTY          TIME CMD
31852 pts/7    00:00:00 bash
31884 pts/7    00:00:00 ps

El EUID (Effective User IDentifier) és una variable d'entorn que podeu consultar amb l'ordre id o directament amb echo:

$ id -u
1000
$ echo $EUID
1000

Podem veure dos processos:

  • Un és el propi shell o intèrpret de comandes desde el que s'ha executat l'ordre
  • L’altre és justament el procés generat per l'ordre ps. ps ens dóna informació del nom del procés, el PID associat, el temps que s’ha estat executant aquest procés, i el terminal des del que s’ha iniciat (TTY)


La primera columna mostra l'identificador del procés (de l'anglès Process Identifier PID), la terminal associada al procés (columna TTY), el temps acumulat d'ús de CPU (columna TIME) i finalment la comanda que ha generat el procés.

Per tal de mostrar tots els processos del sistema, tenim diferents opcions:

Format estàndard Unix:

$ ps -e
$ ps -ef
$ ps -eF
$ ps -ely

Sintaxi BSD:

$ ps ax
$ ps axu

On:

  • a: Amb l'estil BSD, per defecte només es mostren els processos de l'usuari que executa l'ordre ps. L'opció a treu aquesta restricció i mostra tots els processos associats a una terminal
  • x: Combinat amb a mostra tots els processos, associats o no a una terminal.
  • u: Mostra informació orientada a l'usuari. El resultat es certes columnes extres (USER, %CPU, MEM...) respecte a ax
  • -e: genera una llista amb informació de tots els processos.
  • -l: mostra una llista llarga (long format) d'informació dels processos
  • -f: mostra certa informació extra com el PPID i el UID. Realment
  • -y: combinat amb -ls no mostra els FLAGS.
  • -F: encara més informació extra que -f

NOTA: Algunes opcions com l'opció a o l'opció e no són exactament iguals si s'utilitzen en un estil o en un altre. Per exemple:

  • -a: Mostra tots els processos menys els processos líders de grup (group liders). Els líders de grup són els primers processos d'un grup de processos relacionat
.

Tingueu en compte el següent:

$ ps -aux > psmenysaux 
Warning: bad ps syntax, perhaps a bogus '-'? See http://procps.sf.net/faq.html

L'ordre ps normalment dona el mateix resultat si poseu:

$ ps aux
$ ps -aux

Excepte l'avís anterior (a l'ordre anterior hem redireccionat la sortida estàndard a un fitxer però l'error estàndard s'ha mostrat per la terminal). Això és així per que realment ps -aux us hauria de mostrar segons l'estàndard POSIX i UNIX, tots els processos amb una terminal associada (-a) per a l'usuari (-u) x. Si no teniu usuari x al sistema l'ordre suposa que realment volíeu fer ps aux sense guió.

Sovint per facilitar la lectura de la sortida, paginem amb les ordres more i less:

$ ps aux | more

o

$ ps aux |less
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0   3056  1888 ?        Ss   15:44   0:01 /sbin/init
root         2  0.0  0.0      0     0 ?        S<   15:44   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S<   15:44   0:00 [migration/0]
root         4  0.0  0.0      0     0 ?        S<   15:44   0:00 [ksoftirqd/0]
...

Sovint es combina l'ús de la comanda ps amb la comanda grep, per tal de mostrar només els processos que ens interessen:

$ ps -A | grep firefox-bin
11778 ?        02:40:08 firefox-bin
11779 ?        00:00:00 firefox-bin

També podeu utilitzar pidof:

$ pidof firefox-bin
11778

Per consultar tots els processos d'un usuari podeu utilitzar l'opció -u

$ ps -u root u

Això només inclou els processos executats per root. Si volem també els executat per un altre usuari però que tenen com a usuari efectiu (EUID) root hem d'executar:

$ ps -U root -u root u

NOTA: Tingueu en compte que un fitxer pot tenir els bits de permisos especials SGID i SUID, fet que permet executar un procés amb l'usuari que ha creat el fitxer i no pas amb l'usuari que executa el procés

Per veure només la informació d'un procés concret podem, tal com hem comentat anteriorment, combinar amb grep o utilitzar l'opció -C:

$ ps -C syslogd -o pid
 PID
5280

Fixeu-vos que el resultat és el mateix que utilitzar la comanda pidof.

Podem mostrar el nom d'un procés a partir del seu PID amb:

$ ps -p 7293 -o comm=
bash

Consulteu també l' ordre pstree per veure exemples d'ús de la comanda ps que proporcionin la sortida en forma d'arbre.

Interpretar i modificar la sortida

Vegem un parell d'exemple de sortida de l'ordre ps:

Exemple 1:

$ ps -u sergi --forest
 PID TTY             TIME CMD
3451 pts/3      00:00:00 bash
3551 pts/3      00:00:00 ps
3496 ?          00:00:00 kvt
3498 pts/1      00:00:00 bash
3504 pts/1      00:00:00 \_ nedit
3505 ?          00:00:00        \_ csh
3544 ?          00:00:00            \_ xeyes
...

Exemple 2:

$ ps u U sergi
USER         PID %CPU %MEM     VSZ  RSS TTY      STAT  START     TIME COMMAND
sergi 19221 0.0 1.5       4484  1984 ?        S     May07      0:01 dfm
sergi 2451 0.0 0.8        1856  1048 pts/3    S     16:13      0:00 -bash
sergi 2496 0.2 3.2        6232  4124 ?        S     16:17      0:00 /opt/kd
sergi 2498 0.0 0.8        1860  1044 pts/1    S     16:17      0:00 bash
sergi 2505 0.1 2.6        4784  3332 pts/1    S     16:17      0:00 nedit
sergi 2506 0.0 0.7        2124  1012 ?        S     16:17      0:00 /bin/cs
sergi 2544 0.0 1.0        2576  1360 ?        S     16:17      0:00 xeyes
sergi 2556 0.0 0.7        2588   916 pts/3    R     16:18      0:00 ps u U

Exemple 3:

$ ps -eo user,pid,ppid,uid,gid,command,stat,tty,time,%cpu,ni,rss,%mem,share,stime 
USER       PID  PPID   UID   GID COMMAND                     STAT TT           TIME %CPU  NI   RSS %MEM - STIME
root         1     0     0     0 /sbin/init                  Ss   ?        00:00:01  0.0   0  1496  0.1 - 16:38
root         2     0     0     0 [kthreadd]                  S<   ?        00:00:00  0.0  -5     0  0.0 - 16:38
root         3     2     0     0 [migration/0]               S<   ?        00:00:00  0.0   -     0  0.0 - 16:38
root         4     2     0     0 [ksoftirqd/0]               S<   ?        00:00:00  0.0  -5     0  0.0 - 16:38
...

La sortida de ps normalment comença per una capçalera on s'indiquen els noms dels diferents camps. A la sortida podem trobar les següents columnes:

  • Username (USER):​ És el nom de l'usuari que executa el programa
  • Process ID (PID): Mostra l'identificador de procés. Aquest és el valor que haurem d'utilitzar per tal de fer operacions amb el procés
  • Parent PID (PPID): Mostra el PID del procés pare.

Per mostrar el PPID podem executar executar:

$ ps -eo ppid,pid,command
  • UID: és l'identificador de l’usuari sota el qual s’executa el procés.
  • GID: Mostra l'identificador del grup ('Group IDentifier) que executa aquest procés
  • COMMAND: mostra l'ordre que ha generat aquest procés.
  • STAT: mostra l'estat del procés.
  • Teletype (TTY o TT): el codi que identifica la terminal on s'està executant el procés. Cal tenir en compte que els dimonis (serveis Linux), són un tipus de processos especials una de les característiques dels quals és no tenir cap terminal associada. En el cas d’un procés no associat a un terminal com un dimoni, aquest camp conté el caràcter “?”.
  • Temps de CPU:
  • TIME: TIME indica el tota de temps de CPU utilitzat pel procés des de la seva execució.
  • %CPU: %CPU és (o era) el tant per cent de CPU ocupada pel procés en el moment que vam executar ps. Per obtenir aquestes mesures en temps real cal utilitzar top.
  • Prioritat de la CPU: Consulte l'objectiu LPI 103.6. Modificar les prioritats d'execució dels processos.
  • NI: mostra el nivell de prioritat del procés. La columna NI mostra el codis de prioritat.
  • Memòria: Hi ha múltiples capçaleres relacionades amb la memòria.
  • RSS (resident set size): La memòria utilitzada pel proces i les seves dades.
  • %MEM': és el percentatge de memòria que el programa està (o millor dit estava) consumint durant l'execució de ps
  • SHARE: Memòria compartida amb altres processos (com biblioteques compartides)
  • START o STIME: Mostra la data de llançament del procés.

Es pot controlar les columnes que mostrarà ps amb l'opció -o (output). Per exemple per mostrar només els pids:

$ ps -o pid

Si ho combinem amb la opció e (mostrar tots els processos):

$ ps -eo pid

Altres exemples:

$ ps -eo pid,tid,class,rtprio,ni,pri,psr,pcpu,stat,wchan:14,comm
$ ps axo stat,euid,ruid,tty,tpgid,sess,pgrp,ppid,pid,pcpu,comm
$ ps -eopid,tt,user,fname,tmout,f,wchan

També podem controla l'amplada de les columnes de sortida amb l'opció wide-column.correctament.

pstree

La comanda pstree mostra una llista de processos en forma d’una estructura d’arbre (jerarquia de processos Unix). Un avantatge immediat és que de seguida podem veure quin és el procés pare d’un altre. Així, si per exemple volem matar tots els processos fills d’un procés pare, podem utilitzar pstree per veure quin és el procés pare i matar directament al procés pare.

Normalment utilitzarem les opcions –p per veure el PID de cada procés i la opció –u per veure el nom d’usuari que va iniciar el procés. Com que l’arbre de processos sol ser llarg, normalment es fa servir la comanda less per poder-los veure de forma adient:

$ pstree –up | less

L'ordre pstree mostra la jerarquia de processos Linux:

$ pstree
init-+-NetworkManager
    |-acpid
    |-apache2---6*[apache2]
    |-atd
    |-avahi-daemon---avahi-daemon
    |-bluetoothd
    |-bonobo-activati---{bonobo-activati}
    |-console-kit-dae---63*[{console-kit-dae}]
    |-cpufreq-applet
    |-cron
...
    |-gdm---gdm-+-Xorg
    |           `-gnome-session-+-bluetooth-apple
    |                           |-evolution-alarm---{evolution-alarm}
    |                           |-gnome-do---3*[{gnome-do}]
    |                           |-gnome-keyring-d
    |                           |-gnome-panel
    |                           |-metacity
    |                           |-nautilus
    |                           |-nm-applet
    |                           |-python
    |                           |-seahorse-agent
    |                           |-tracker-applet
    |                           |-trackerd---2*[{trackerd}]
    |                           |-update-notifier
    |                           |-vino-server
    |                           `-{gnome-session}
...

Mostra l'arbre de processos (ordenats per relacions pare fill i segons els seu PID)

Com podeu observar, el primer procés sempre és el procés init, que té el PID 1:

$ pidof init
1

L'opció -a mostra les comandes completes:

$ pstree -a
init
  |-NetworkManager
  |-acpid -c /etc/acpi/events -s /var/run/acpid.socket
  |-apache2 -k start
  |   |-apache2 -k start
...

I l'opció -p mostra l'identificador del procés:

$ top -pa
init,1
  |-NetworkManager,6507
  |-acpid,5156 -c /etc/acpi/events -s /var/run/acpid.socket
  |-apache2,6712 -k start
  |   |-apache2,6785 -k start
  |   |-apache2,6786 -k start
  |   |-apache2,6787 -k start
  |   |-apache2,6788 -k start
  |   |-apache2,6789 -k start 
  |   `-apache2,7435 -k start

Amb la comanda ps també es poden obtenir estructures en forma d'arbre:

$ ps -ejH | more
...
6546  6546  6546 ?        00:00:00   gdm
6549  6549  6546 ?        00:00:00     gdm
6554  6554  6554 tty7     00:06:13       Xorg
6830  6830  6830 ?        00:00:00       gnome-session
6974  6974  6974 ?        00:00:00         seahorse-agent
6989  6830  6830 ?        00:00:00         gnome-keyring-d
6993  6830  6830 ?        00:00:13         metacity
7000  6830  6830 ?        00:00:08         gnome-panel
7005  6830  6830 ?        00:00:02         nautilus
7109  6830  6830 ?        00:00:00         python
7112  6830  6830 ?        00:00:10         trackerd
7116  6830  6830 ?        00:00:00         nm-applet
7118  6830  6830 ?        00:00:00         tracker-applet
7119  6830  6830 ?        00:00:00         evolution-alarm
7122  6830  6830 ?        00:00:00         bluetooth-apple
7125  6830  6830 ?        00:00:04         gnome-do
7126  6830  6830 ?        00:00:01         vino-server
7137  6830  6830 ?        00:00:00         update-notifier

o també amb:

$ ps axjf | more
...
1  6546  6546  6546 ?           -1 Ss       0   0:00 /usr/sbin/gdm
6546  6549  6549  6546 ?           -1 S        0   0:00  \_ /usr/sbin/gdm
6549  6554  6554  6554 tty7      6554 Ss+      0   6:19      \_ /usr/X11R6/bin/X :0 -br -audit 0 -auth /var/lib/gdm/:0.Xauth -nolisten tcp vt7
6549  6830  6830  6830 ?           -1 Ssl   1001   0:00      \_ /usr/bin/gnome-session
6830  6974  6974  6974 ?           -1 Ss    1001   0:00          \_ /usr/bin/seahorse-agent --execute /usr/bin/gnome-session
6830  6989  6830  6830 ?           -1 S     1001   0:00          \_ /usr/lib/gnome-session/helpers/gnome-keyring-daemon-wrapper
6830  6993  6830  6830 ?           -1 S     1001   0:13          \_ /usr/bin/metacity
6830  7000  6830  6830 ?           -1 S     1001   0:08          \_ gnome-panel
6830  7005  6830  6830 ?           -1 S     1001   0:02          \_ nautilus --no-desktop --browser
6830  7109  6830  6830 ?           -1 S     1001   0:00          \_ python /usr/share/system-config-printer/applet.py
6830  7112  6830  6830 ?           -1 SNl   1001   0:10          \_ trackerd
6830  7116  6830  6830 ?           -1 S     1001   0:00          \_ nm-applet --sm-disable
6830  7118  6830  6830 ?           -1 S     1001   0:00          \_ tracker-applet
6830  7119  6830  6830 ?           -1 Sl    1001   0:00          \_ /usr/lib/evolution/2.24/evolution-alarm-notify
6830  7122  6830  6830 ?           -1 S     1001   0:00          \_ bluetooth-applet
6830  7125  6830  6830 ?           -1 Sl    1001   0:04          \_ /usr/bin/cli /usr/lib/gnome-do/Do.exe
6830  7126  6830  6830 ?           -1 S     1001   0:01          \_ /usr/lib/vino/vino-server
6830  7137  6830  6830 ?           -1 S     1001   0:00          \_ update-notifier


Recursos:

Senyals

Les senyals són un mecanisme bàsic de comunicació entre processos (IPC o Inter-Process Communication) proporcionat pel nucli del sistema operatiu.

Cada procés en UNIX/Linux, reacciona davant dels senyals que els hi podem enviar. En total hi ha 64 senyals diferents que podem enviar un procés, els quals estan identificats o bé pel seu número (començant per 1), o bé pels seus noms simbòlics (SIGx on x és el nom del senyal).

Per cadascun d’aquests senyals, el procés pot definir el seu comportament, excepte per 2:

  • SIGKILL(9): serveix per matar (acabar abruptament) un procés
  • SIGSTOP(19): que serveix per aturar temporalment un procés. Quan la senyal SIGSTOP és enviada a un procés, el comportament habitual és aturara aquest procés. El procés només tornarà a executar-se si se li envia la senyal SIGCONT. La senyal SIGSTOP no pot ser capturada ni ignorada.

NOTA: La senyal SIGSTP (20) és similar en comportament a la senyal SIGSTOP(19) però són diferents. La senyal 20 es pot capturar i modificar en canvi la 19 no. Les terminals poden enviar la senyal SIGSTP (20) amb Ctrl+Z.

El senyal 9 acaba amb la execució d’un procés de forma irrevocable, sense donar-li temps d’acabar de forma adequada (si acabem un procés corresponent a un programa amb aquest senyal, es perdrien les dades amb les que està treballant amb aquell programa).

Podem obtenir una llista dels senyals disponibles escrivint aquesta comanda des d’una consola:

$ kill –l 
1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX	


Senyals més freqüents:

  • INT (2): Interrupt. Atura el programa de forma controlada. Els programes poden ignorar aquesta senyal, simplement aturar el programa o realitzar una sèrie de tasques abans d'aturar-se. Es enviada quan polsem ctrl+C. Pausa
  • KILL (9): elimina el procés aturant-lo immediatament i de forma incondicional. Aquesta senyal no pot ser ignorada pel procés.
  • TERM (15): Terminate. Finalitza el procés de forma correcta (sempre i quan el programa hagi implementat la senyal).
  • STOP (19): Para l’execució temporalment (Ctrl+Z). Es pot continuar l'execució de l'aplicació, per exemple amb les ordres fg o bg o amb la senyal SIGCONT (18).

Consulteu també:

Enviant senyals a processos : kill, killall i top

kill, killall

Aquestes dues comandes es fan servir per enviar senyals a processos. La comanda kill necessita com a argument el PID (un número), mentre killall té com a argument el nom del procés.

La sintaxi de l'ordre és:

kill [ -signal | -s signal ] pid ...

Indicar la senyal a enviar és opcional. Per defecte, totes dues envien el senyal 15 (TERM: acabament del programa). Tant kill com killall poden rebre com a argument el senyal que hem d’enviar al procés.

Per exemple, si volem matar el procés amb PID 785 hauríem d’escriure la comanda següent:

$ kill 785

Si volguéssim enviar el senyal 19 (STOP) per aturar el procés:

$ kill -19 785

El procés habitual per matar un procés és, primer trobar el seu pid amb ps+grep o pidof i després matar el procés amb kill:

$ ps aux | grep "nom_proces"
sergi     4643  0.0  0.0   3036   ............
$ kill 4643

Si no contesta per què està penjat aleshores, el podem intentar matar:

$ kill -9 4643

Suposem que en comptes de voler matar un procés a partir del seu PID, volem matar un procés a partir del nom de la comanda que l’invoca. En comptes d’intentar cercar el seu PID a utilitzant ps, podem matar el procés a partir del seu nom.

Per exemple si se’ns penja el navegador mozilla, podem matar el procés amb la comanda:

$ killall -9 mozilla

o de forma equivalent:

$ kill -s 8 mozilla

Passi el què passi, només es pot matar els processos de l’usuari amb el què hem iniciat el sistema (excepte si hem entrat com a root).

Val a dir que si estem treballant en l’entorn gràfic, i hi ha una finestra d’un programa que s’ha penjat, podem utilitzar la comanda xkill o qualsevol dels múltiples programes de gestió de processos existents.

Altres exemples:

Mostrar totes les senyals:

$ kill -l

Mostra-les en una taula:

$ sudo kill -L 
1 HUP      2 INT      3 QUIT     4 ILL      5 TRAP     6 ABRT     7 BUS
8 FPE      9 KILL    10 USR1    11 SEGV    12 USR2    13 PIPE    14 ALRM
15 TERM    16 STKFLT  17 CHLD    18 CONT    19 STOP    20 TSTP    21 TTIN
22 TTOU    23 URG     24 XCPU    25 XFSZ    26 VTALRM  27 PROF    28 WINCH
29 POLL    30 PWR     31 SYS     


Mostrar el nom d'una senyal a partir del seu codi de senyal:

$ kill -l 19
STOP

Matar tots els processos que un usuari pot matar (COMPTE!!)

$ kill -9 -1

xkill

L'ordre xkill que s’ha d’invocar o bé des d’una consola, o bé des del menú d’inici - > execució, genera un cursor en forma de X. Si aquest cursor el situem sobre la finestra de l’aplicació que l’ha penjat i premem el botó esquerre del ratolí, matarà el procés que ha generat aquella finestra, sense necessitat que hagem de cercar quin és el seu PID o bé el nom de la comanda que l’ha invocat.

top

Mostra els processos ordenats per percentatge d'ús de CPU (de més a menys).

 $ top
 top - 11:34:41 up  1:13,  2 users,  load average: 0.14, 0.23, 0.22
 Tasks: 155 total,   2 running, 153 sleeping,   0 stopped,   0 zombie
 Cpu(s):  1.8%us,  0.5%sy,  0.0%ni, 97.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
 Mem:   2063192k total,  1192316k used,   870876k free,    70848k buffers
 Swap:  4594548k total,        0k used,  4594548k free,   424452k cached
 
   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  OMMAND                                                                                                              
 6554 root      20   0  356m  24m 8776 R    3  1.2   4:20.86 Xorg                                                                                                                
 7283 sergi     20   0  102m  28m  14m S    2  1.4   0:04.04 gnome-terminal                                                                                                      
 7279 sergi     20   0  333m 175m  25m S    1  8.7   4:33.38 firefox                                                                                                             
 6202 root      10 -10  1768  408  332 S    1  0.0   0:03.42 mouseemu                                                                                                            
 7000 sergi     20   0 54368  24m  15m S    1  1.2   0:06.38 gnome-panel                                                                                                         
 7025 sergi     20   0 21460 3100 1756 S    1  0.2   0:07.22 gnome-screensav                                                                                                     
    1 root      20   0  3056 1888  564 S    0  0.1   0:01.58 init                                                                                                                
    2 root      15  -5     0    0    0 S    0  0.0   0:00.00 kthreadd              

Una de les aportacions més valuoses de la comanda top és el resum de l'estat del sistema que apareix a l'inici de la comanda:

 top - 11:37:13 up  1:16,  2 users,  load average: 0.31, 0.25, 0.23
 Tasks: 155 total,   1 running, 154 sleeping,   0 stopped,   0 zombie
 Cpu(s):  1.9%us,  0.8%sy,  0.0%ni, 97.3%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
 Mem:   2063192k total,  1193276k used,   869916k free,    71252k buffers
 Swap:  4594548k total,        0k used,  4594548k free,   424468k cached

Ens aporta la següent informació:

  • up 1:17 és la quantitat de temps que porta encesa la màquina.
  • 2 users: nombre d'usuaris en el sistema (inclou un mateix usuari que estigui "logat" en diferents terminals )
  • load average: 0.31, 0.25, 0.23: Càrrega mitjana del sistema (tots els valors estan sobre 1)
  • Tasks: 155 total, 1 running, 154 sleeping, 0 stopped, 0 zombie: estadístiques de les tasques.
  • Cpu(s): 1.9%us, 0.8%sy, 0.0%ni, 97.3%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st: estadístiques de la CPU.
  • Mem: 2063192k total, 1193276k used, 869916k free, 71252k buffers: estadístiques de la memòria del sistema
  • Swap: 4594548k total, 0k used, 4594548k free, 424468k cached: Estadístiques de la memòria swap.

Podem activar els colors de top prement la tecla z.

També permet manipular els processos mitjançant les tecles adequades. Per saber quines tecles podem utilitzar podem prémer la tecla h (help):

Help for Interactive Commands - procps version 3.2.7
Window 1:Def: Cumulative mode Off.  System: Delay 3.0 secs; Secure mode Off.

 Z,B       Global: 'Z' change color mappings; 'B' disable/enable bold
 l,t,m     Toggle Summaries: 'l' load avg; 't' task/cpu stats; 'm' mem info
 1,I       Toggle SMP view: '1' single/separate states; 'I' Irix/Solaris mode

 f,o     . Fields/Columns: 'f' add or remove; 'o' change display order
 F or O  . Select sort field
 <,>     . Move sort field: '<' next col left; '>' next col right
 R,H     . Toggle: 'R' normal/reverse sort; 'H' show threads
 c,i,S   . Toggle: 'c' cmd name/line; 'i' idle tasks; 'S' cumulative time
 x,y     . Toggle highlights: 'x' sort field; 'y' running tasks
 z,b     . Toggle: 'z' color/mono; 'b' bold/reverse (only if 'x' or 'y')
 u       . Show specific user only
 n or #  . Set maximum tasks displayed

 k,r       Manipulate tasks: 'k' kill; 'r' renice
 d or s    Set update interval
 W         Write configuration file
 q         Quit
         ( commands shown with '.' require a visible task display window ) 
Press 'h' or '?' for help with Windows,
any other key to continue 

Podeu prémer h un altre cop per tal d'obtenir més ajuda.

Enviant senyals a processos i renice:

Les tecles k i r ens permeten utilitzar les comandes kill i nice(renice) respectivament.

Premeu k. Introduiu el PID del procés (normalment es mostra a la primera columna de la sortida de top). Després us demana el número de la senyal que voleu enviar. Podeu obtenir més informació sobre senyals a l' apartat senyals de l'article Crides al sistema.

La tecla r funciona de forma similar a la tecla k.

Canviar les dades de sortida:

Amb la tecla f, entrem a un mode que permet escollir quines columnes mostrar i quines no. Un cop dins d'aquest mode podem activar/desactivar columnes prement la tecla que correspongui:

Current Fields:  AEHIOQTWKNMbcdfgjplrsuvyzX  for window 1:Def

Toggle fields via field letter, type any other key to return

* A: PID        = Process Id
* E: USER       = User Name
* H: PR         = Priority
* I: NI         = Nice value
* O: VIRT       = Virtual Image (kb)
* Q: RES        = Resident size (kb)
* T: SHR        = Shared Mem size (kb)
* W: S          = Process Status
* K: %CPU       = CPU usage
* N: %MEM       = Memory usage (RES)
* M: TIME+      = CPU Time, hundredths
  b: PPID       = Parent Process Pid
  c: RUSER      = Real user name
  d: UID        = User Id
  f: GROUP      = Group Name
  g: TTY        = Controlling Tty
  j: P          = Last used cpu (SMP)
  p: SWAP       = Swapped size (kb)
  l: TIME       = CPU Time
  r: CODE       = Code size (kb)
  s: DATA       = Data+Stack size (kb)
  u: nFLT       = Page Fault count
  v: nDRT       = Dirty Pages count
  y: WCHAN      = Sleeping in Function
  z: Flags      = Task Flags <sched.h>
* X: COMMAND    = Command name/line

Les línies amb asterisc (*). són les columnes que es mostren actualment. Per sortir d'aquest mode cal prémer la tecla Esc.

De forma similar la tecla o, ens permet ordenar les columnes.

La tecla c, ens permet veure la comanda completa que ha generat els processos.

Mostrar processos d'un usuari concret:

Podem mostrar les tasques d'un sol usuari, prement la tecla u.

Altres:

La tecla i mostra només els processos actius (amb consum de CPU).

Top.png


Altres opcions:

M : ordena els processos en funció de la memòria que utilitzen
P: ordena els processos en funció de la seva ocupació de CPU

Alternatives a top

htop

Consulteu htop.

atop

Consulteu atop.

Prioritat dels processos

Consulteu l'objectiu LPI 103.6. Modificar les prioritats d'execució dels processos

Executar un programa abans de l'execució de cada comanda (execució de l'interpret d'ordres)

Consulteu:

History#Mantenir_la_historia_de_bash_sincronitzada_amb_el_fitxer_.bash_history_i_entre_m.C3.BAltiples_terminals

Ordres relacionades amb processos

Consulteu Processos_Linux#Comandes

ps

Consulteu ps.

top

Consulteu top

kill

Consulteu kill

killall

Consulteu killall

pidof

Consulteu pidof.

htop

Consulteu htop.

atop

Consulteu atop.

jobs

Consulteu jobs.

bg

Consulteu bg.

fg

Consulteu fg.

nohup

Consulteu nohup.

free

Consulteu free.

uptime

Consulteu uptime.


watch

Permet executar un procés/comanda de forma repetitiva (cada x segons). Per exemple per veure les normes d'iptables funcionant:

$ sudo watch iptables -nvL --line-numbers

Per defecte es repeteix l'ordre cada 2 segons. Observeu la capçalera de la sortida:

Every 2,0s: iptables -nvL --line-numbers                                                     Wed Feb  3 10:15:16 2010

Podeu canviar el nombre de segons amb l'opció -n:

$ sudo watch -n 1 iptables -nvL --line-numbers

NOTA: No es poden utilitzar valors menors al segon

Variables de shell i d'entorn

$$

Si executem:

$ echo $$

Ens mostrarà el PID del procés que estem executant. Si ho executem des de una terminal, ens retorna el PID d'aquesta terminal:

$ echo $$
16256
 ps aux | grep bash
sergi    16148  0.0  0.0   4276   580 ?        S    07:04   0:00 /bin/bash /usr/bin/ica-launcher
sergi    16256  0.0  0.1   6084  1820 pts/0    Ss   07:04   0:00 bash
sergi    22329  0.0  0.0   3016   792 pts/0    R+   09:11   0:00 grep bash

$?

Conté el codi de sortida de l'última ordre executada. També conegut com a exit status:

$ echo hola
hola
$ echo $?
0

Normalment el conveni es retornar un 0 si l'ordre s'ha executat correctament i retornar un valor diferent de 0 si hi ha hagut algun error. Els diferents valors diferents de 0 serveixen per indicar codis d'error diferents.

$ mkdir prova1
$ echo $?
0
$ mkdir prova1
mkdir: no s’ha pogut crear el directori «prova1»: File exists
$ echo $?
1

$PPID

Vegeu també l'apartat L'identificador de procés pare

Retorna el PID del pare del procés que estem executant:

$ echo $PPID
16253

Alternativament podem utilitzar:

$ ps -p $$ -o ppid=


Per saber quin és aquest procés pare:

$ ps -p 16253
PID TTY          TIME CMD
16253 ?        00:00:01 gnome-terminal

o

$ ps -p `ps -p $$ -o ppid=`
 PID TTY          TIME CMD
16253 ?        00:00:01 gnome-terminal

Conceptes. Glossari de termes

  • Temps de vida (Lifetime): Temps que dura la execució d’un procés
  • [Identificador del procés]] (PID). Nombre únic associat al procés i assignat en el moment d’arrencar-lo
  • Identificador d’usuari (UID): Els privilegis que tindrà el procés al accedir al sistema de fitxers seran els associats a l’usuari i grup que llenci aquest procés
  • Identificador del procés pare (Parent process): Serà el PID del procés pare (PPID)

Vegeu també