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)

https://peteris.rocks/blog/htop/

Sistemes operatius i gestió de processos

Consulteu la pàgina web:

Processos

Estats d'un procés. Model d'estats

Per representar el cicle de vida d'un procés s'acostuma a utilitzar un diagrama d'estats. L'estat en què esta un procés en un instant de temps es guarda com una dada més al Bloc de control del procés (BCP).

L'estat del procés depèn en gran part de la seva relació amb el microprocessador. Tots els sistemes operatius tenen un component anomenat Planificador (de l'anglès scheduler) que és l'encarregat de decidir quin procés s'executa en cada moment. També esta clar que s'haurà d'implementar una cua on emmagatzemar temporalment els processos que esta a l'espera de ser executats.

Model de dos estats

És el model més simple i només diferència entre processos en execució i processos que no s'estan executant. Aquest model funciona bé quan es treballa amb una cua FIFO i una planificació Round Robin o per torn rotatori. Cada cop que un procés canvia d'un estat d'execució (ús de CPU) a un estat de no execució (anomenats en anglès: wait o ready) és produeix una operació que s'anomena canvi de context. Aquest procés commuta un procés en espera per un procés en execució.

Model de cinc estats

Fitxer:Diagrames5Estats.png
Diagrama d'estats d'un model de 5 estats

És el sistema més utilitzat i té en compte que realment els processos no sempre estan preparats per a ser executats. Els processos necessiten de dades per funcionar i sovint aquestes dades s'han d'obtenir de "l'exterior" a través d'operacions d'E/S. Aquestes operacions normalment són d'ordres de magnitud més lentes que la velocitat de la CPU. Els sistemes que disposen de planificació expulsiva permeten que la CPU "expulsi" un procés en execució que esta a l'espera d'una operació d'E/S i permetrà això un ús més eficient de la CPU. Aquest processos passen a una estat normalment anomenat d'espera (wait). Per tant els processos que no s'estan executant poden estar en espera (wait) o llestos (ready). A més s'afegeixen dos estats: Nou i Terminat.

Els estats Nou i Terminat són útils per a la gestió de processos.

Pel que fa a les cues d'espera i han diferents implementacions:

  • Cues FIFO (First In First Out): sistemes on no hi han prioritats
  • Diferents cues una per cada nivell de prioritat: O una sola cua on s'ordenin els elements per la seva prioritat i en cas d'empat per FIFO.
  • Una cua d'espera per cada dispositiu E/S: Aquí s'emmagatzemen els processos en espera d'operacions d'E/S.

Model de 7 estats

Diagrama d'estats d'un model de 7 estats

El fet d'utilitzar un estat en espera pot arribar a augmentar tant la exigència d'espai de memòria (múltiples processos a l'espera) fins al punt d'esgotar la memòria principal. La solució és utilitzar el procés d'intercanvi (de l'anglès swapping). Aquest procés correspon a moure un procés de la memòria principal a la memòria secundària (normalment disc). En aquest casos s'utilitza un nou esta anomenat Suspès

Els estats són per tant:

  • Nou (created)
  • Llest (ready) o en Espera (waiting): Pot estar en memòria principal o memòria secundaria (swapping)
  • Executant-se (running):
  • Dormint (sleeping) o bloquejat (blocked): : Pot estar en memòria principal o memòria secundaria (swapping)
  • Terminat (terminated)

Estats dels processos a UNIX

Estats dels processos Unix:

  • (R) Running: Està utilitzant la CPU
  • Waiting: El procés esta esperant un esdeveniment o un recurs d'E/S. Linux diferencia entre dos tipus de processos en espera:
    • (S) Waiting interruptible: Processos que poden ser interromputs per senyals
    • (D) Waiting uninterruptible: Interrupcions de maquinari que no es poden interrompre
  • (T) Stopped: El procés esta aturat segurament per una senyal. Per exemple un procés que esta dent depurat per un depurador.
  • (Z) Zombie: és un procés finalitzat però que encara esta la seva estructura de dades en memòria.

Del manual de 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

Recursos

Procés fill

Els processos és creen amb la crida de sistema fork. El procés que executa fork és el pare i el nou procés és el fill. Podem observar la jerarquia dels processos de Unix amb la comanda pstree:

$ pstree 
init-+-NetworkManager
    |-NetworkManagerD
    |-acpid
    |-amarokapp-+-ruby
    |           `-8*[{amarokapp}]
    |-apache2---6*[apache2]
    |-atd
    |-avahi-daemon---avahi-daemon
    |-bonobo-activati---{bonobo-activati}
    |-console-kit-dae---61*[{console-kit-dae}]
    |-cron
    |-cupsd---{cupsd}
    |-2*[dbus-daemon]
...

Els processos executats en una línia de comandes (per exemple bash) són fills de la línia de comandes

$ pstree 
...
    |-gnome-terminal-+-bash-+-more
    |                |      |-pstree
    |                |      `-2*[sleep]

Recursos:

Procés orfe

Un procés orfe, és aquell procés que el procés pare ha finalitzat la seva execució.

En sistemes Unix els processos orfes són adoptats immediatament pel procés init (a no ser que les 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).

Vegeu nohup

Recursos:

Procés zombie

A Unix, un procés zombie 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 Déu/pare.

El pare rep una senyal SIGCHLD indicant que el procés fill ha mort. El controlador per defecte d'aquesta senyal serà llegir l'estat del procés fill amb wait i esborrar el zombi.

Els processos Unix 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   /usr/lib/zope2.9/lib/
python/Zope2/Startup/zopeschema.xml -b 10 -d -s /var/lib/zope2.9/instance/plone-site/var/zopectlsock -x 0,2 -z /var/lib/zope2.9/instance/plone-site /var/
lib/zope2.9/instance/plone-site/bin/runzope
zope      5690  0.0  6.9  76868 72020 ?        S    10:28   0:09 /usr/bin/python2.4 /usr/lib/zope2.9/lib/python/Zope2/Startup/run.py -C  /var/lib/zope2.9/ 
instance/plone-site/etc/zope.conf
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

Recursos:

Procés parat

En qualsevol moment es pot parar un procés amb Ctrl+Z. També es pot fer des de el monitor del sistema. Els processos aturats estan en estat T (aturat).

Exemple:

$ sleep 20

Premeu la combinació de tecles: Ctrl+Z

[2]+  Stopped                 sleep 20
$ ps aux | grep sleep
sergi      477  0.0  0.0   2892   612 pts/0    T    18:33   0:00 sleep 20 

Veieu les comandes [#bg| bg] i [#fg | fg] que ens permeten tornar a executar processos aturats.

Procés dimoni

Un procés dimoni és un procés que s’executa de forma permanent i en segon pla; el seu codi es repeteix fins a l’infinit per esperar i estar a punt quan un usuari sol·licita el servei al qual està vinculat. Els noms dels dimonis terminen generalment en d. Per exemple existeix el dimoni crond (planificador de tasques), httpd (servidor Web Apache) i syslogd (registre de missatges) en un sistema Linux.

Un dimoni té les següents característiques:

  • És un procés no interactiu (no disposa d'interfície amb l'usuari).
  • Típicament el nom dels dimonis en Linux acaben en -d (httpd, sshd, etc.)
  • Origen del nom: terme grec (daimon) una mena “d'àngel de la guarda”. També es parla de l'abreviació de “Disk And Environment MONitor".
  • No són interactius. No disposen d'interfície directa amb l'usuari, ni gràfica ni textual.
  • No utilitzen les entrades i sortides estàndard per comunicar errors o registrar el seu funcionament.
  • Utilitzen fitxers de log (/var/log) per enregistrar els errors o esdeveniments del dimoni.

Consulteu:

Programació_de_Dimonis_Linux

per obtenir més informació sobre els dimonis Linux.

SENYALS

Consulteu l'apartat Senyals de l'article crides al sistema.

La comanda per enviar senyals és kill.

Variables de shell i d'entorn

Consulteu LPI_103.5._Crear,_monitoritzar_o_matar_processos#Variables_de_shell_i_d.27entorn.

Comandes

Gestió de processos

ps

Consulteu ps.

Fils d'execució

Els fils d'execució no són processos en si, sinó que formen part d'un procés. Es pot dir que tots els fils d'execució d'un procés són germans perquè comparteixen el mateix procés. Podem observar aquest fet utilitzant l' ordre ps quan una aplicació que utilitza fils com Firefox s'està executant:

$ ps ax|grep firefox
6952 ?        Sl    11:39 /usr/lib/firefox-3.0.4/firefox
...

Com podeu veure només hi ha un procés, però múltiples fils d'execució (que es poden mostrar amb l'opció H):

$ ps axH|grep firefox
6952 ?        Sl    11:13 /usr/lib/firefox-3.0.4/firefox
6952 ?        Sl     0:02 /usr/lib/firefox-3.0.4/firefox
6952 ?        Sl     0:19 /usr/lib/firefox-3.0.4/firefox
6952 ?        Sl     0:00 /usr/lib/firefox-3.0.4/firefox
6952 ?        Sl     0:00 /usr/lib/firefox-3.0.4/firefox
6952 ?        Sl     0:02 /usr/lib/firefox-3.0.4/firefox
24872 pts/6    S+     0:00 grep firefox

Els fils s'identifiquen per la l de la columna STAT, i com podeu veure formen part tots del mateix procés(amb identificador de procés 6952)


Recursos:

pidof

Permet obtenir el pid d'un procés a partir del seu nom. Per exemple, si tenim executat el navegador de fitxers de Gnome (Nautilus)

$ pidof nautilus
6793

Si tenim diferents Nautilus oberts pot sorgir més d'un pid:

$ pidof nautilus
10033 6793

En cas que no trobem un procés pel seu nom podeu provar amb -x (busca també scripts, és una cerca més profunda...):

$ pidof -x firefox
6989

El primer procés del sistema sempre és el procés init:

$ pidof init
1

El paquet que proporciona aquesta comanda a Debian i Ubuntu és:

sysvinit-utils

Tal com podem comprovar executant la següent seqüència de comandes:

$ which pidof
/bin/pidof
$ dpkg -S /bin/pidof
sysvinit-utils: /bin/pidof

Sovint la comanda pidof no és res més que un enllaç simbòlic a la comanda original de System V killall5, que és una comanda utilitzada pels runlevel Scripts (guions de shell que s'executen a l'inici del sistema):

$ ls -la /bin/pidof
lrwxrwxrwx 1 root root 16 2008-11-18 08:54 /bin/pidof -> ../sbin/killall5

Podem obtenir resultats similars als de l'ordre pidof directament amb l'ordre ps:

$ ps -C syslogd -o pid
 PID
5280

Recursos:

pstree

Consulteu pstree

top

Consulteu top.

free

Segons el manual:

$ man free

Mostra a quantitat de memòria lliure i utilitzada al sistema:

$ free
             total       used       free     shared    buffers     cached
Mem:       1026560     669388     357172          0      94816     240656
-/+ buffers/cache:     333916     692644
Swap:      4104596          0    4104596

Les opcions més interessant són les que permeten mostrar la informació en mesures més fàcils de llegir:

$ free -m
             total       used       free     shared    buffers     cached
Mem:          1002        653        348          0         92        235
-/+ buffers/cache:        326        676
Swap:         4008          0       4008

Mostra les dades en MB. Podeu utilitzar:

-b,-k,-m,-g show output in bytes, KB, MB, or G


També podem mostrar un total:

$ free -mt
             total       used       free     shared    buffers     cached
Mem:          1002        653        348          0         92        235
-/+ buffers/cache:        326        676
Swap:         4008          0       4008
Total:        5010        653       4356

I executar-la periòdicament:

$ free -mt -s 1
             total       used       free     shared    buffers     cached
Mem:          1002        655        347          0         92        235
-/+ buffers/cache:        327        675
Swap:         4008          0       4008
Total:        5010        655       4355 

             total       used       free     shared    buffers     cached
Mem:          1002        655        347          0         92        235
-/+ buffers/cache:        327        675
Swap:         4008          0       4008
Total:        5010        655       4355

             total       used       free     shared    buffers     cached
Mem:          1002        655        347          0         92        235
-/+ buffers/cache:        327        675
Swap:         4008          0       4008
Total:        5010        655       4355

També ho podríem fer amb watch.

time

La comanda time ens permet conèixer el temps que utilitza el sistema per tal d'executar una comanda. Per exemple:

$ time ls -la
total 20
drwxr-xr-x  2 sergi sergi 4096 2008-10-18 11:30 .
drwxr-xr-x 69 sergi sergi 4096 2008-10-18 13:22 ..
-rwxr-xr-x  1 sergi sergi  347 2008-10-12 20:57 iconv.sh
-rwxr-xr-x  1 sergi sergi  187 2008-10-18 11:25 script_seguretat_xarxes_uoc.sh
-rwxr-xr-x  1 sergi sergi  185 2008-10-18 11:25 script_seguretat_xarxes_uoc.sh~

real	0m0.187s
user	0m0.004s
sys   0m0.000s

Si us fixeu, després de l'execució de la comanda veureu un resum dels temps empleats per a l'execució de la comanda. Es mostren 3 temps:

  • Temps total d'execució: també conegut com a temps real.
  • Temps d'ús de la CPU d'usuari: temps d'execució de la comanda en espai d'usuari.
  • Temps d'ús de la CPU de sistema: temps d'execució de la comanda en espai de sistema.
NOTA: No confongueu la comanda time amb la comanda interna de bash times.

atop

$ sudo apt-get install atop
$ atop

htop

https://peteris.rocks/blog/htop/
$ sudo apt-get install htop
$ htop

ntop

Ntop és realment una aplicació web que no gestiona processos, sinó que monitoritza l'ús que s'està fent de la xarxa.

Consulteu Ntop.

tload

Mostra la càrrega del sistema

$ tload

mpstat

Mostra estadístiques de la CPU

$ mpstat
Linux 2.6.22-14-generic (ubuntu-sala)   06/06/08

08:16:41     CPU   %user   %nice    %sys %iowait    %irq   %soft  %steal   %idle    intr/s
08:16:41     all    9,59    0,63    3,65   44,90    0,11    0,21    0,00   40,91    362,77

fuser

Identifica els processos que esta utilitzant un fitxer concret o un socket:

$ fuser /dev/pts/5 
/dev/pts/5:          32470
$ fuser /home/sergi/
/home/sergi/:         7142c  7217c  7220c  7223c  7232c  7233c  7239c  7244c  7251c  7254c  7255c  7369c  7382c  7394c  7398c  7402c  7406c  7436c   
7448c  7452c 10537c 10575c 10578c 10581c 10584c 10586c 10603c 29053c 29076c 29122c 29143c 29171c 32470c

És molt útil per poder desmuntar unitats que estan sent utilitzades i no sabem per qui. Per exemple un error:

Device /usr is busy

Podríem identificar els processos que l'estan utilitzant amb:

$ fuser -avm /usr
                    USER        PID ACCESS COMMAND
/usr:                sergi      1575 .r.e. amarokcollectio
                     sergi      7139 .r.e. gnome-keyring-d
                     sergi      7142 .r.e. x-session-manag
                     sergi      7194 .rce. dbus-launch
                     sergi      7195 frce. dbus-daemon
                     sergi      7197 Frce. gconfd-2
                     sergi      7203 .rce. seahorse-agent
                     sergi      7211 frce. gnome-settings-
                     sergi      7217 .r.e. metacity
                     sergi      7220 .r.e. gnome-panel
                     sergi      7223 .r.e. nautilus

lsof

Mostra els fitxers oberts d'un sistema. Els podem mostrar tots amb:

$ sudo lsof | more
COMMAND     PID        USER   FD      TYPE     DEVICE      SIZE       NODE NAME
init          1        root  cwd       DIR        8,2      4096          2 /
init          1        root  rtd       DIR        8,2      4096          2 /
init          1        root  txt       REG        8,2     88672    1175092 /sbin/init
init          1        root  mem       REG        8,2   1339816    2025090 /lib/tls/i686/cmov/libc-2.6.1.so
init          1        root  mem       REG        8,2    109148    1991830 /lib/ld-2.6.1.so
init          1        root    0u      CHR        5,1                 2261 /dev/console (deleted)
init          1        root    1u      CHR        5,1                 2261 /dev/console (deleted)
init          1        root    2u      CHR        5,1                 2261 /dev/console (deleted)
...

Es pot utilitzar per localitzar quin procés bloqueja un fitxer i matar el procés:

$ sudo lsof /u/abe/foo
$ sudo kill -HUP ‘lsof -t /u/abe/bar‘
$ ps
  PID TTY          TIME CMD
 1665 pts/5    00:00:00 ps
 32470 pts/5    00:00:00 bash
$ lsof -p 32470
COMMAND   PID  USER   FD   TYPE DEVICE    SIZE    NODE NAME
bash    32470 sergi  cwd    DIR    8,6   12288 4734977 /home/sergi
bash    32470 sergi  rtd    DIR    8,2    4096       2 /
bash    32470 sergi  txt    REG    8,2  701680 2464325 /bin/bash
bash    32470 sergi  mem    REG    8,2   38420 2025099 /lib/tls/i686/cmov/libnss_files-2.6.1.so
bash    32470 sergi  mem    REG    8,2   34352 2025101 /lib/tls/i686/cmov/libnss_nis-2.6.1.so
bash    32470 sergi  mem    REG    8,2   83712 2025096 /lib/tls/i686/cmov/libnsl-2.6.1.so
bash    32470 sergi  mem    REG    8,2   30436 2025097 /lib/tls/i686/cmov/libnss_compat-2.6.1.so
bash    32470 sergi  mem    REG    8,2  254020 1584109 /usr/lib/locale/ca_ES.utf8/LC_CTYPE
bash    32470 sergi  mem    REG    8,2  915338 1832520 /usr/lib/locale/ca_ES.utf8/LC_COLLATE
bash    32470 sergi  mem    REG    8,2 1339816 2025090 /lib/tls/i686/cmov/libc-2.6.1.so
...

jobs

Vegeu també job en referència al concepte de tasca en programació.

$ jobs

Mostra els treballs de la shell actual. Consulteu l'article Control de tasques Unix

bg

Envia un treball a executar-se en background. Amb la combinació de tecles

control-Z 

s'atura un proces. Si tenim un procés en foreground que no ens deixa fer res i volem passar-lo a background podem utilitzar Ctrl-Z o sleep.

Exemple:

$ sleep 20

[1]+  Stopped                 sleep 20
$ ps
PID TTY          TIME CMD
31371 pts/10   00:00:00 bash
31387 pts/10   00:00:00 sleep
31388 pts/10   00:00:00 ps

$ bg sleep
[1]+ sleep 20 &

Recursos:

fg

Foreground. Passa a primer pla un procés dormit:

$ sleep 20

[1]+  Stopped                 sleep 20
$ ps
PID TTY          TIME CMD
31371 pts/10   00:00:00 bash
31387 pts/10   00:00:00 sleep
31388 pts/10   00:00:00 ps

$ fg sleep
sleep 20

disown

Permet dessasociar una tasca de la terminal on s'ha executat

# sleep 30&
[1] 12642
root@dell-desktop:/home/sergi# sleep 30&
[2] 12643
root@dell-desktop:/home/sergi# sleep 30&
[3] 12644
root@dell-desktop:/home/sergi# jobs
[1]   Running                 sleep 30 &
[2]-  Running                 sleep 30 &
[3]+  Running                 sleep 30 &
root@dell-desktop:/home/sergi# disown %1
root@dell-desktop:/home/sergi# jobs
[2]-  Running                 sleep 30 &
[3]+  Running                 sleep 30 &

Les podem dessasociar totes amb:

$ disown -a

Recursos:

sleep

Envia a dormir un procés durant x segons

$sleep 10
$sleep 10 && ls 

L'últim exemple executa un ls passats 10 segons. L'ordre és molt útil per a explicar com funcionen els processos i posar exemples d'execució en primer i segon pla.

Valor nice. Comanda nice

Pots prendre valors entre -20 a 19. 19 és mínima prioritat!

$nice
$renice
$ nice -n -20 gimp

Podem consultar la prioritat amb ps i la columna ni (també apareix al monitor del sistema)

$ watch ps -eo pid,tid,class,rtprio,ni,command | grep gimp

vmstat

Aquesta comanda mostra l'estat de memòria però també és útil per saber quants processos estan experant per executar-se i quants en espera per una interrupció

$ vmstat -a
procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
 r  b   swpd   free  inact active   si   so    bi    bo   in   cs us sy id wa
 0  0  34868  38172 154612 789904    0    2   246  1040  205 1740 33  5 55  7
  • r: esperant per execució.
  • b: dormits per una interrupció.

Es pot executar contínuament indicant un delay en segons. Per exemple cada segon:

$ vmstat 1
procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa
 3  0 194392  20276  30156 952556    0    1    14    38    9    9  0  1 98  0
 0  0 194392  20028  30164 952792    0    0     0   292 2153 3595  2  2 96  0
 0  0 194392  19656  30164 953068    0    0   128     0 1304 2160  1  2 95  2
 0  0 194392  19656  30164 953176    0    0     0     0 1345 2219  0  2 98  0
...

On:

procs:

  • r: El número de processos esperant per ser executats
  • b: El número de processos que estan dormint a l'espera d'una interrupció

memory:

  • swpd: la quantitat de memòria virtual utilitzada.
  • free: la quantitat de memoria sense utilitzar
  • buff: la quantitat de memòria utilitzada com a buffers
  • cache: la quantitat de memòria utilitzada com a cache

swap

  • si: Quantitat de memòria swap que s'ha extret del disc
  • so: Quantitat de memòria swap que s'ha guardat al disc

io

I/O-related fields are:

  • bi: Blocs rebuts d'un dispositiu de blocs
  • bo: Blocs enviats d'un dispositiu de blocs

system

  • in: El número d'interrupcions per segon, incloent el rellotge
  • cs: El nombre de canvis de context (context switches) per segon

cpuPercentatges del total d'ús de CPU

  • us: Temps gastat executant codi que no és del nucli (user time including nice time)
  • sy: Temps gastat executant codi que del nucli (system time)
  • id: Temps gastat sense fer res (idle). Inclou els temps de IO-wait
  • wa: Temps gastat esperant una operació I/O.

uptime

Mostra el temps que porta en execució una màquina i algunes estadístiques:

$ uptime
14:14:18 up  5:06, 10 users,  load average: 3.55, 3.80, 3.32

ruptime

Consulteu: Comanda ruptime.

ulimit

Vegeu també: /etc/security/limits.conf

Permet limitar el nombre de processos que un usuari pot executar (ús per defecte) i altres limitacions

Per exemple podem consultar les limitacions de processos amb:

$ ulimit
unlimited

I establir un limit amb:

$ ulimit 1000

Això pot ser útil per tal d'evitar atacs del tipus Fork Bomb.

NOTA: Si executeu aquesta comanda i no teniu un limit de processos el vostre sistema es penjarà:
:(){ :|:& };:

En Windows es pot executar:

:s
START %0
GOTO :s

o en C:

#include <unistd.h>
 
int main(int argc, char* args[])
{
  while(1)
    fork();
  return 0;
}

Podem consultar la resta de limitacions amb:

$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 8191
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 8191
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

On:

  • core file size:

Per modificar qualsevol de les opcions utilitzeu el que s'indica entre parèntesis.

ulimit és un ordre interna de bash i com a tal no té un manual propi (està inclòs al manual de bash):

$ man bash | grep -A 30  ulimit
       ulimit [-HSTabcdefilmnpqrstuvx [limit]]

          Provides  control over the resources available to the shell and to processes started by it, on systems that allow such control.  The -H 
          and -S options specify that the hard or soft limit is set for the given resource.  A hard limit cannot be increased by a non-root user 
          once it is set; a soft limit may be  increased up  to the value of the hard limit.  If neither -H nor -S is specified, both the soft and 
          hard limits are set.  The value of limit can be a number in the unit specified for the resource or one of the special values hard, soft, 
          or unlimited, which stand for the current hard limit,  the  current  soft  limit,  and  no limit,  respectively.  If limit is omitted, the 
          current value of the soft limit of the resource is printed, unless the -H option is given.  When more than one resource is specified, the 
          limit name and unit are printed before the value.  Other options are interpreted as follows:
             -a     All current limits are reported
             -b     The maximum socket buffer size
             -c     The maximum size of core files created
             -d     The maximum size of a process's data segment
             -e     The maximum scheduling priority ("nice")
             -f     The maximum size of files written by the shell and its children
             -i     The maximum number of pending signals
             -l     The maximum size that may be locked into memory
             -m     The maximum resident set size (many systems do not honor this limit)
             -n     The maximum number of open file descriptors (most systems do not allow this value to be set)
             -p     The pipe size in 512-byte blocks (this may not be set)
             -q     The maximum number of bytes in POSIX message queues
             -r     The maximum real-time scheduling priority
             -s     The maximum stack size
             -t     The maximum amount of cpu time in seconds
             -u     The maximum number of processes available to a single user
             -v     The maximum amount of virtual memory available to the shell
             -x     The maximum number of file locks
             -T     The maximum number of threads
     If limit is given, it is the new value of the specified resource (the -a option is display only).  If no option is given, then -f is assumed.  
     Values  are  in 1024-byte  increments,  except  for -t, which is in seconds, -p, which is in units of 512-byte blocks, and -T, -b, -n, and -u, 
     which are unscaled values.  The return status is 0 unless an invalid option or argument is supplied, or an error occurs while setting a new 
     limit.

Vegeu també:

Fitxer /etc/security/limits.conf

Permet establir límits a usuaris i al sistema des de PAM.

Vegeu també:

PAM#Carpeta_.2Fetc.2Fsecurity

kill

La comanda:

$ 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

Mostra tots els tipus de senyals. Les més importants són:

  • 1 --> SIGHUP S'utilitza per als daemons que tornin a llegir el fitxer de configuració
  • 2 --> Ctrl-C (Depèn del programador)
  • 9 --> SIGKILL. Mata Mata Mata
  • 15 --> TERM. Mata però depende del programador (un stop como dios manda). Per defecte.
  • 18 --> Continuación.
  • 19 --> STOP (no se puede ignorar)
  • 20 --> Tstp (disponibilidad del programador). (Ctrl- Z)

Per defecte kill envia la senyal SIGTERM (15) que demana a l'aplicació la seva finalització:

$ sudo kill pid

L'aplicació pot respondre a la crida o ignorar-la. En aquests cas per matar una aplicació tant si com no podem utilitzar

$ sudo kill -9 pid

Només podem acabar processos nostres o qualsevol procés si som el superusuari.

Consulteu també la comanda top per saber com es poden aturar processos amb aquesta comanda.

Recursos:

pgrep i pkill

Permeten cercar procesos i en el cas de pkill enviar-lis una senyal un cop trobats.

Exemples:

$ pgreg ssh

Es poden utilitzar paràmetres per

$ pgrep -u root

o

$ pgrep -u root sshd

I matar processos amb:

$ sudo pkill -u root sshd

killall5

Envia una senyal a tots els processos del sistema que compleixen amb un criteri. Només s'utilitza en els scripts d'inici (carpetes /etc/rcx)

La comanda pidof és un link a aquesta comanda:

$ ls -la /bin/pidof 
lrwxrwxrwx 1 root root 16 2008-11-18 08:54 /bin/pidof -> ../sbin/killall5

Però el seu comportament no és exactament igual (això es degut a que un programa pot consultar des de on ha estat executat).

Consulteu també kill.

Recursos:

nohup

Executa una comanda immune als hangups. Evita que un procés engegat en una terminal especifica s'aturi al finalitzar aquest terminal. El nou procés no té cap relació amb la terminal i per aquesta raó no es finalitzarà el procés al tancar la terminal.

Per comprovar-ho executeu dos terminals. En una executeu:

$ sleep 10000

Comproveu a l'altre terminal que el procés sleep s'està executant amb:

$ ps aux | grep sleep

Tanqueu la terminal on heu executat sleep 10000:

$ exit

Comproveu a la terminal que us ha quedat com també s'atura el procés sleep al tancar la terminal des de on s'ha executat:

NOTA: podeu comprovar que encara que executeu l'sleep en segon terme (amb $ sleep 10000&) el resultat és el mateix.

Si ara torneu a executar tot el procés però substituint:

$ sleep 10000

Per

$ nohup sleep 10000

Veureu que el procés sleep continua després de tancar la terminal des d'on hem executat el procés.

La comanda nohup és una comanda que forma part de la shell (interpret d'ordres) - shell builtin - (com cd, fg, o bg). Consulteu bash.

NOTA: A vegades nohup no funciona correctament i l'aplicació es penja quan es tanca la connexió. També cal tenir el compte que no posa directament els processos a executar-se en segon pla. Segons aquesta web hi ha un bug conforme no es tanca la entrada estàndard. Es pot solucionar amb:

$ nohup rsync ... </dev/null &

O millor encara si redireccionem totes les sortides:

nohup ./myprogram > foo.out 2> foo.err < /dev/null &

Per exemple:

$ nohup /usr/bin/rsync -rtlvp --delete --progress --stats rsync://rsync.mirrorservice.org/download.eclipse.org/eclipseMirror/ /mnt/sdb1 < /dev/null &

Hi han altres alternatives com:

  • Utilitzar screen o una versió moderna i millorada anomenada byobu
  • Utilitzar setsid que permet executar un programa en una nova sessión
  • Utilitzar dislocate que és similar a l'anterior
  • A Debian es pot demonitzar un procés amb /sbin/start-stop-daemon
  • Es pot utilitzar at:
$ echo command | at now.

Vegeu també:

Recursos:

Gestió de l'aturada del sistema

Consulteu l'article Gestió de l'aturada del sistema.

halt

Consulteu l'article halt.

reboot

Consulteu l'article reboot.

shutdown

Consulteu l'article shutdown.

poweroff

Consulteu l'article poweroff.

Gestió dels nivells d'execució

init i telinit

Permet canviar el nivell d'execució:

Per exemple per passar el nostre usuari a línia de comandes monousuari (només root):

$ sudo init 1

A la wikipedia, a l'article RunLevel podeu trobar els diferents nivells d'execució de les diferents distribucions Linux.

Init realment executa la comanda telinit.

Podeu consultar el nivell d'execució que us trobeu amb l'ordre:

$ runlevel
N 2

Vegeu també:

Recursos:

runlevel

Consulteu la comanda runlevel

Comandes batch. at, batch, atq, atrm

La comanda at permet executar un comanda en un moment específic:

$ echo "hola" | at 1145

Executarà:

$ echo "hola"

a les 1145.

La comanda atq mostra la llista de tasques pendents:

$ atq
1       Wed May  7 11:45:00 2008 a sergi

I la comanda

$ atrm 1

Elimina un tasca pendent. Si torneu a executar:

$ atq

No us mostrarà cap tasca pendent.

La comanda batch executa un procés només quan la carrega del sistema es baixa (inferior a 1.5):

$ batch updatedb

Paquets de programari

Paquet procps

Proporciona moltes de les comandes bàsiques de processos del sistema (com ps o kill):

$ dpkg -L procps | grep bin

/sbin/sysctl
/bin
/bin/kill
/bin/ps
/usr/bin
/usr/bin/uptime
/usr/bin/tload
/usr/bin/free
/usr/bin/top
/usr/bin/vmstat
/usr/bin/watch
/usr/bin/skill
/usr/bin/pmap
/usr/bin/pgrep
/usr/bin/slabtop
/usr/bin/pwdx
/usr/bin/w.procps
/usr/bin/snice
/usr/bin/pkill  

Paquet sysstat

Consulteu l'article Estadístiques del sistema. Sysstat i acct.

pidstat

Mostra les estadístiques dels processos (usos de CPU):

$ sudo pidstat

Carpeta /proc

Consulteu l'article Sistema de fitxers proc.

Monitors de sistema

Monitor del sistema. Gnome

El podem afegir com un applet a qualsevol dels panells seguint les següents passes:

Feu botó dret sobre el panell del vostre sistema i seleccioneu Afegeix al quadre:

EchoDMonitorSistema1.png

Seleccioneu el monitor del sistema:

EchoDMonitorSistema2.png

Veureu que s'afegeix un petit quadre negre, que us anirà mostrant una gràfica de l'ús de la CPU:

EchoDMonitorSistema3.png

Fent clic a sobre del monitor del sistema podeu accedir als detalls del sistema. Hi ha 4 finestres:

  • Sistema: Informació generals del sistema (CPU, RAM, espai lliure, etc.)
  • Processos: Mostra els processos en execució (similar a la comanda ps). El menú visualitza permet controlar la forma en que es mostren els processos.
  • Recursos: Mostra gràfiques del sistema (CPU, Memòria lliure, etc.)
  • Sistema de fitxers: Mostra els diferents sistemes de fitxers i l'ús que se n'està fent.


També podem executar des de la línia de comandes:

$ gnome-system-monitor

Si per alguna raó no el tinguessiu instal·lat (normalment està instal·lat per defecte), el podeu instal·lar amb:

$ sudo apt-get install gnome-system-monitor

Recursos

Monitor de sistema KDE

$ ksysguard

També es pot accedir al monitor amb la combinació de tecles Ctrl+Esc

Altres monitors

Oxygen

Vegeu també

  • LPI 103.5. Crear, monitoritzar o matar processos