https://peteris.rocks/blog/htop/
Consulteu la pàgina web:
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.
É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ó.
É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:
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:
Estats dels processos Unix:
Del manual de ps:
Acacha Wiki
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:
Recursos
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:
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:
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:
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.
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:
Consulteu:
Programació_de_Dimonis_Linux
per obtenir més informació sobre els dimonis Linux.
Consulteu l'apartat Senyals de l'article crides al sistema.
La comanda per enviar senyals és kill.
Consulteu LPI_103.5._Crear,_monitoritzar_o_matar_processos#Variables_de_shell_i_d.27entorn.
Consulteu ps.
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:
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:
Consulteu pstree
Consulteu top.
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.
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:
NOTA: No confongueu la comanda time amb la comanda interna de bash times.
$ sudo apt-get install atop
$ atop
https://peteris.rocks/blog/htop/
$ sudo apt-get install htop
$ htop
Ntop és realment una aplicació web que no gestiona processos, sinó que monitoritza l'ús que s'està fent de la xarxa.
Consulteu Ntop.
Mostra la càrrega del sistema
$ tload
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
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
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 ...
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
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:
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
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:
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.
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
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
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:
memory:
swap
io
I/O-related fields are:
system
cpuPercentatges del total d'ús de CPU
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
Consulteu: Comanda ruptime.
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:
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é:
Permet establir límits a usuaris i al sistema des de PAM.
Vegeu també:
PAM#Carpeta_.2Fetc.2Fsecurity
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:
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:
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
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:
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:
$ echo command | at now.
Vegeu també:
Recursos:
Consulteu l'article Gestió de l'aturada del sistema.
Consulteu l'article halt.
Consulteu l'article reboot.
Consulteu l'article shutdown.
Consulteu l'article poweroff.
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:
Consulteu la comanda runlevel
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
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
Consulteu l'article Estadístiques del sistema. Sysstat i acct.
Mostra les estadístiques dels processos (usos de CPU):
$ sudo pidstat
Consulteu l'article Sistema de fitxers proc.
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:
Seleccioneu el monitor del sistema:
Veureu que s'afegeix un petit quadre negre, que us anirà mostrant una gràfica de l'ús de la CPU:
Fent clic a sobre del monitor del sistema podeu accedir als detalls del sistema. Hi ha 4 finestres:
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
$ ksysguard
També es pot accedir al monitor amb la combinació de tecles Ctrl+Esc