|
Linux Professional Institute Certificate. LPIC-1  | |
|---|---|
| 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 |
| 103.5. Crear, monitoritzar o matar processos | |
|---|---|
|
|
|
Àrees Clau de Coneixement: |
|
La següent és una llista parcial de fitxers, termes i utilitats utilitzades: |
|
Apunts: LPI 103.5. Crear, monitoritzar o matar processos |
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:
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.
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:
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
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.
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).
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
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:
Acacha Wiki 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:
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:
É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
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 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
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
És la forma més habitual i el mode per defecte en que s'executen les ordres. Vegeu també l'ordre fg.
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
Consulteu exec.
Consulteu Control de tasques Unix. El control de tasques es realitza amb les ordres:
Hi ha 3 formes d'acabar prematurament un procés que s'està executant en primer pla:
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.
Aquestes dues comandes mostren una llista dels processos que s’estan executant en el sistema.
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:
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:
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:
.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.
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:
Per mostrar el PPID podem executar executar:
$ ps -eo ppid,pid,command
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.
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:
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:
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:
Consulteu també:
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
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.
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ó:
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).
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
Consulteu htop.
Consulteu atop.
Consulteu l'objectiu LPI 103.6. Modificar les prioritats d'execució dels processos
Consulteu:
History#Mantenir_la_historia_de_bash_sincronitzada_amb_el_fitxer_.bash_history_i_entre_m.C3.BAltiples_terminals
Consulteu Processos_Linux#Comandes
Consulteu ps.
Consulteu top
Consulteu kill
Consulteu killall
Consulteu pidof.
Consulteu htop.
Consulteu atop.
Consulteu jobs.
Consulteu bg.
Consulteu fg.
Consulteu nohup.
Consulteu free.
Consulteu uptime.
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
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
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