Procesos

Los sistemas operativos modernos son normalmente multitarea, lo que significa que crean la ilusión de que hacen más de una cosa al mismo tiempo mediante un rápido cambio de un programa en ejecución a otro. El kernel Linux gestiona ésto a través de el uso de procesos. Los procesos son la forma en que Linux organiza los diferentes programas que esperan su turno en la CPU.

Algunas veces un ordenador se vuelve lento o una aplicación deja de responder. En este capítulo, veremos algunas de las herramientas disponibles en la línea de comandos que nos permitirá examinar qué están haciendo los programas, y como terminar procesos que están teniendo un mal comportamiento.

Éste capítulo presentará los siguientes comandos:

• ps – Muestra un listado de los procesos en funcionamiento
• top – Muestra las tareas
• jobs – Lista los trabajos activos
• bg – Coloca un trabajo al fondo (background)
• fg – Coloca un trabajo al frente (foreground)
• kill – Manda un señal a un proceso
• killall – Mata procesos por nombre
• shutdown – Apaga o reinicia el sistema

Cómo funciona un proceso

Cuando un sistema arranca, el kernel inicia algunas de sus propias actividades como procesos y arranca un programa llamado init. init, por orden, ejecuta una serie de scripts de shell (localizados en /etc) llamados init scripts, que arrancan todos los servicios del sistema. Muchos de estos servicios son implementados como daemon programs (demonios), programas que simplemente se sitúan en el fondo y hacen su trabajo sin tener ningún usuario en la interface. Así que incluso sin que estemos logueados, el sistema está un poco ocupado haciendo tareas rutinarias.

El hecho de que un programa pueda arrancar otros programas se expresa en el esquema de procesos como procesos padres produciendo procesos hijos.

El kernel mantiene información sobre cada proceso para ayudar a tener las cosas organizadas. Por ejemplo, cada proceso tiene asignado un número llamado process ID o PID. Los PIDs son asignados en orden creciente, con init siempre ocupando el PID1. El kernel también guarda la ruta a la memoria asignada a cada proceso, así como la disponibilidad de los procesos para reanudar la ejecución. Como los archivos, los procesos también tiene propietarios y IDs de usuario, IDs efectivas de usuarios, etc.

Viendo los procesos

El comando más comúnmente usado para ver procesos (hay varios) es ps. El programa ps tiene un montón de opciones, pero en su forma más simple se usa así:

 [me@linuxbox ~]$ ps
  PID  TTY         TIME CMD
  5198 pts/1   00:00:00 bash
 10129 pts/1   00:00:00 ps

El resultado de este ejemplo es un lista de dos procesos, el proceso 5198 y el proceso 10129, que son bash y ps respectivamente. Como podemos ver, por defecto, ps no nos muestra mucho, sólo los procesos asociados a la sesión de terminal actual. Para ver más, necesitamos añadir algunas opciones, pero antes de hacerlo, veamos los otros campos producidos por ps. TTY es la abreviatura de “Teletype”, y se refiere al terminal que controla el proceso. Unix muestra su edad aquí. El comando TIME es la cantidad de tiempo consumido por el proceso. Como podemos ver, ninguno de los procesos hace al ordenador trabajar mucho.

Si añadimos una opción, podemos tener una imagen más amplia de que está haciendo el sistema:

[me@linuxbox ~]$ ps x
PID   TTY STAT TIME COMMAND
2799  ?   Ssl  0:00 /usr/libexec/bonobo-activation-server –ac
2820  ?   Sl   0:01 /usr/libexec/evolution-data-server-1.10 --
15647 ?   Ss   0:00 /bin/sh /usr/bin/startkde
15751 ?   Ss   0:00 /usr/bin/ssh-agent /usr/bin/dbus-launch --
15754 ?   S    0:00 /uTTYsr/bin/dbus-launch --exit-with-session
15755 ?   Ss   0:01 /bin/dbus-daemon --fork --print-pid 4 –pr
15774 ?   Ss   0:02 /usr/bin/gpg-agent -s –daemon
15793 ?   S    0:00 start_kdeinit --new-startup +kcminit_start
15794 ?   Ss   0:00 kdeinit Running...
15797 ?   S    0:00 dcopserver –nosid
and many more...

Añadiendo la opción “x” (fíjate que no lleva un guión delante) le decimos a ps que muestre todos nuestros procesos independientemente de qué terminal (si hay alguno) los controla. La presencia de un “?” en la columna TTY indica que ningún terminal controla. Usando esta opción, vemos una lista de cada proceso que tenemos.

Como el sistema está ejecutando muchos procesos, ps produce una lista larga. A menudo ayuda pasar la salida por un pipe ps a less para verlo más fácilmente. Algunas combinaciones de opciones también producen salidas con listas largas, así que maximizar la ventana del emulador de terminal puede ser una buena idea también.

Una nueva columna llamada STAT se ha añadido a la salida. STAT es una abreviatura de “state” y revela elViendo los procesos

El comando más comúnmente usado para ver procesos (hay varios) es ps. El programa ps tiene un montón de opciones, pero en su forma más simple se usa así:

 [me@linuxbox ~]$ ps
   PID TTY         TIME CMD
  5198 pts/1   00:00:00 bash
 10129 pts/1   00:00:00 ps

El resultado de este ejemplo es un lista de dos procesos, el proceso 5198 y el proceso 10129, que son bash y ps respectivamente. Como podemos ver, por defecto, ps no nos muestra mucho, sólo los procesos asociados a la sesión de terminal actual. Para ver más, necesitamos añadir algunas opciones, pero antes de hacerlo, veamos los otros campos producidos por ps. TTY es la abreviatura de “Teletype”, y se refiere al terminal que controla el proceso. Unix muestra su edad aquí. El comando TIME es la cantidad de tiempo consumido por el proceso. Como podemos ver, ninguno de los procesos hace al ordenador trabajar mucho.

Si añadimos una opción, podemos tener una imagen más amplia de que está haciendo el sistema:

[me@linuxbox ~]$ ps x
PID   TTY STAT TIME COMMAND
2799  ?   Ssl  0:00 /usr/libexec/bonobo-activation-server –ac
2820  ?   Sl   0:01 /usr/libexec/evolution-data-server-1.10 --
15647 ?   Ss   0:00 /bin/sh /usr/bin/startkde
15751 ?   Ss   0:00 /usr/bin/ssh-agent /usr/bin/dbus-launch --
15754 ?   S    0:00 /usr/bin/dbus-launch --exit-with-session
15755 ?   Ss   0:01 /bin/dbus-daemon --fork --print-pid 4 –pr
15774 ?   Ss   0:02 /usr/bin/gpg-agent -s –daemon
15793 ?   S    0:00 start_kdeinit --new-startup +kcminit_start
15794 ?   Ss   0:00 kdeinit Running...
15797 ?   S    0:00 dcopserver –nosid
and many more...

Añadiendo la opción “x” (fíjate que no lleva un guión delante) le decimos a ps que muestre todos nuestros procesos independientemente de qué terminal (si hay alguno) los controla. La presencia de un “?” en la columna TTY indica que ningún terminal controla. Usando esta opción, vemos una lista de cada proceso que tenemos.

Como el sistema está ejecutando muchos procesos, ps produce una lista larga. A menudo ayuda pasar la salida por un pipe ps a less para verlo más fácilmente. Algunas combinaciones de opciones también producen salidas con listas largas, así que maximizar la ventana del emulador de terminal puede ser una buena idea también.

Una nueva columna llamada STAT se ha añadido a la salida. STAT es una abreviatura de “state” y revela el estado actual del proceso:

Estado de los procesos

R  Funcionando (running). Significa que el proceso está en ejecución o preparado para ser ejecutado.

S  Durmiendo (Sleeping). El proceso no está ejecutándose; en su lugar, está esperando a un evento, como una pulsación de teclado o un paquete de red.

D  Ininterrumpible dormido. El proceso está esperando un I/O como una unidad de disco.

T  Parado. El proceso ha sido ordenado a parar. Veremos más sobre esto más tarde.

Z  Proceso extinto o “zombie”. Es un proceso hijo que ha terminado, pero no ha sido limpiado por su padre.

<  Un proceso de alta prioridad. Es posible dar más importancia a un proceso, dándole más tiempo en la CPU. Esta propiedad de un proceso se llama simpatía. Un proceso con alta prioridad se dice que es menos simpático porque esta utilizando más tiempo de la CPU, lo que deja menos tiempo para todos los demás.

N  Un proceso de baja prioridad. Un proceso con baja prioridad (un proceso “amable”) sólo ocupará tiempo de procesador después de que otros procesos con mayor prioridad hayan sido servidos.El estado del proceso puede ir seguido de otros caracteres. Ésto indica varias características exóticas de los procesos. Mira la man page de ps para más detalles.

Otro popular grupo de opciones es “aux” (sin guión delante). Nos da incluso más información:

[me@linuxbox ~]$ ps aux
USER PID %CPU %MEM VSZ  RSS TTY STAT START TIME COMMAND
root 1   0.0  0.0  2136 644   ?   Ss Mar05 0:31 init
root 2   0.0  0.0     0   0   ?   S< Mar05 0:00 [kt]
root 3   0.0  0.0     0   0   ?   S< Mar05 0:00 [mi]
root 4   0.0  0.0     0   0   ?   S< Mar05 0:00 [ks]
root 5   0.0  0.0     0   0   ?   S< Mar05 0:06 [wa]
root 6   0.0  0.0     0   0   ?   S< Mar05 0:36 [ev]
root 7   0.0  0.0     0   0   ?   S< Mar05 0:00 [kh]
and many more...

Esta configuración de opciones muestras los procesos pertenecientes a cada usuario. Usando las opciones sin el guión al principio invoca el comando con comportamiento “estilo BSD”. La versión Linux de ps puede emular el comportamiento del programa ps que se encuentra en varias implementaciones de Unix. Con estas opciones, tendemos estas columnas adicionales:

Encabezados de Columnas en el Estilo BSD de ps

USER 
ID de usuario. Es el propietario del proceso.

%CPU 
Uso de CPU en porcentaje.

%MEM 
Uso de memoria en porcentaje.

VSZ 
Tamaño de la memoria virtual.

RSS 
Tamaño de configuración residente. La cantidad de memoria física (RAM) que el proceso usa en kilobytes.

START 
Hora en que comenzó el proceso. Para valores de más de 24 horas, se usa la fecha.Viendo los procesos dinámicamente con top

Mientras que el comando ps puede revelar mucho de lo que está haciendo la máquina, sólo proporciona una fotografía del estado de la máquina en el momento en que se ejecuta el comando ps. Para ver una vista más dinámica de la actividad de la máquina, usamos el comando top:

 [me@linuxbox ~]$ top

El programa top muestra una pantalla en actualización constante (por defecto, cada 3 segundos) con los procesos del sistema listados por orden de actividad de los procesos. El nombre “top” viene del hecho de que el programa top se usa para ver los procesos “top” del sistema. La pantalla de top contiene dos partes: un sumario del sistema en la parte de arriba de la pantalla, seguido de una tabla de los procesos ordenados por actividad de la CPU:

top - 14:59:20 up 6:30, 2 users, load average: 0.07, 0.02, 0.00
Tasks: 109 total, 1 running, 106 sleeping, 0 stopped, 2 zombie
Cpu(s): 0.7%us, 1.0%sy, 0.0%ni, 98.3%id, 0.0%wa, 0.0%hi, 0.0%si
Mem: 319496k total, 314860k used, 4636k free, 19392k buff
Swap: 875500k total, 149128k used, 726372k free, 114676k cach

PID  USER  PR NI  VIRT  RES  SHR  S %CPU %MEM   TIME+  COMMAND
6244  me   39 19 31752 3124 2188  S  6.3  1.0 16:24.42 trackerd
11071 me   20  0  2304 1092  840  R  1.3  0.3  0:00.14 top
6180  me   20  0  2700 1100  772  S  0.7  0.3  0:03.66 dbus-dae
6321  me   20  0 20944 7248 6560  S  0.7  2.3  2:51.38 multiloa
4955  root 20  0  104m 9668 5776  S  0.3  3.0  2:19.39 Xorg
1     root 20  0  2976  528  476  S  0.0  0.2  0:03.14 init
2     root 15 -5     0    0    0  S  0.0  0.0  0:00.00 kthreadd

3     root RT -5     0    0    0  S  0.0  0.0  0:00.00 migratio

4     root 15 -5     0    0    0  S  0.0  0.0  0:00.72 ksoftirq

5     root RT -5     0    0    0  S  0.0  0.0  0:00.04 watchdog

6     root 15 -5     0    0    0  S  0.0  0.0  0:00.42 events/0

7     root 15 -5     0    0    0  S  0.0  0.0  0:00.06 khelper

41    root 15 -5     0    0    0  S  0.0  0.0  0:01.08 kblockd/

67    root 15 -5     0    0    0  S  0.0  0.0  0:00.00 kseriod

114   root 20  0     0    0    0  S  0.0  0.0  0:01.62 pdflush

116   root 15 -5     0    0    0  S  0.0  0.0  0:02.44 kswapd0

El sumario del sistema contiene mucho material bueno. Aquí tenemos un repaso:

Campos de información de top

Columna Campo
1       top
Nombre del programa

        14:59:20
Hora actual del día.

        up 6:30
Ésto se llama uptime. Es la cantidad de tiempo desde que la máquina fue arrancada. En este ejemplo, el sistema ha estado funcionando seis horas y media.

        2 users
Hay dos usuarios logueados.

        Load average
Load average se refiere al número de procesos que están esperando para funcionar, o sea, el número de procesos que están en un estado ejecutable y están compartiendo la CPU. Se muestran tres valores, cada uno para un periodo de tiempo diferente. El primero es la media de los últimos 60 segundos, el siguiente los 5 minutos anteriores, y finalmente los últimos 15 minutos. Los valores menores de 1.0 indican que la máquina no está ocupada

2       Tasks
Resume el número de procesos y sus distintos estados de proceso.

3       Cpu(s)
Esta columna describe el carácter de las actividades que la CPU está realizando.

        0.7%us
El 0.7% de la CPU está siendo usada por procesos de usuario. Ésto significa que son procesos fuera del propio kernel.

        1.0%sy
El 1.0% de la CPU está siendo usada por procesos “del sistema (kernel)”

        0.0%ni
El 0.0% de la CPU está siendo usada por procesos “simpáticos” (de baja prioridad).

        98.3%id
El 98.3% de la CPU está desocupada.

        0.0%wa
0.0% de la CPU está esperado I/O.

4       Mem
Muestra como está siendo usada la memoria física RAM.

5       Swap
Muestra cómo está siendo usado el espacio de intercambio (memoria virtual).

El programa top acepta comandos de teclado. Los dos más interesantes son h, que muestra la pantalla de ayuda del programa, y q, que cierra top.

Los dos principales entornos de escritorio proveen aplicaciones gráficas que muestran información similar a top (de la misma forma que lo hace el Administrador de Tareas de Windows), pero encuentro que top es mejor que las versiones gráficas porque es más rápido y consume muchos menos recursos del sistema. Después de todo, nuestro programa monitor del sistema no debería ser la causa de la lentitud del sistema que estamos intentando encontrar.rente. El primero es la media de los últimos 60 segundos, el siguiente los 5 minutos anteriores, y finalmente los últimos 15 minutos. Los valores menores de 1.0 indican que la máquina no está ocupada.

Controlando procesos

Ahora que podemos ver y monitorizar procesos, consigamos controlarlos. Para nuestros experimentos, vamos a utilizar un pequeño programa llamado xlogo como conejillo de indias. El programa xlogo es un ejemplo de programa proporcionado por el sistema X Window (el motor en segundo plano que hace que los gráficos se vean en nuestra pantalla) que simplemente muestra una ventana modificable en tamaño que contiene el logo de X. Primero, vamos a conocer a nuestro sujeto de pruebas:

  [me@linuxbox ~]$ xlogo

Después de introducir el comando, una pequeña ventana conteniendo el logo debería aparecer en algún sitio de la pantalla. En nuestros sistemas, xlogo debería mostrar un mensaje de advertencia, pero puede ser ignorado tranquilamente.

Consejo: Si tu sistema no incluye el programa xlogo, preba a usar gedit o kwrite en su lugar.

Podemos verificar que xlogo está funcionando modificando el tamaño de la ventana. Si el logo se redibuja en el nuevo tamaño, el programa está funcionando.

¿Ves que nuestro prompt de shell no ha vuelto? Esto es porque el shell está esperando a que el programa termine, como todos los demás programas que hemos usado hasta ahora. Si cerramos la ventana de xlogo, el prompt vuelve.

Interrumpiendo un proceso

Observemos que ocurre cuando ejecutamos el programa xlogo de nuevo. Primero, introducimos el comando xlogo y verificamos que el programa está funcionando. A continuación, volvemos a la ventana del terminal y pulsamos Ctrl-c.

  [me@linuxbox ~]$ xlogo
  [me@linuxbox ~]$

En un terminal, pulsar Ctrl-c, interrumpe un programa. Esto significa que le pedimos educadamente al programa que termine. Después de pulsar Ctrl-c, la ventana de xlogo se cierra y el prompt de shell vuelve.

Muchos (pero no todos) programas de la línea de comandos pueden ser interrumpidos usando esta técnica.

Enviando procesos al fondo

Digamos que queremos traer de vuelta el prompt de shell sin terminar el programa xlogo. Lo haremos enviando el programa al fondo. Piensa en el terminal como si tuviera un frente (con cosas visibles en la superficie como el prompt del shell) y un fondo (con cosas ocultas bajo la superficie). Para arrancar un programa y que se coloque inmediatamente en el fondo, añadiremos al comando un carácter “&”:

 [me@linuxbox ~]$ xlogo &
 [1] 28236
 [me@linuxbox ~]$

Después de introducir el comando, aparece la ventana de xlogo y el prompt de shell vuelve, pero algunos números extraños también aparecen. Este mensaje es parte de una característica del shell llamada control de trabajo. Con este mensaje, el shell nos está diciendo que hemos comenzado el trabajo número 1 (“[1]”) y que tiene el PID 28236. Si ejecutamos ps, podemos ver nuestro proceso:

 [me@linuxbox ~]$ ps

   PID TTY         TIME CMD

 10603 pts/1   00:00:00 bash

 28236 pts/1   00:00:00 xlogo

 28239 pts/1   00:00:00 ps

La utilidad de control de trabajos del shell también nos da una forma de listar los trabajos que hemos arrancado desde nuestro terminal. Utilizando el comando jobs, podemos ver esta lista:

 [me@linuxbox ~]$ jobs
 [1]+ Running             xlogo &

Los resultados muestran que tenemos un trabajo, con el número “1”, y que esta funcionando, y que el comando fue xlogo &.

Devolviendo un proceso al frente

Un proceso en el fondo es inmune a nuestras entradas de teclado, incluyendo cualquier intento de interrumpirlo con Ctrl-c. Para devolver un proceso al frente, usa el comando fg, de esta forma:

 [me@linuxbox ~]$ jobs
 [1]+ Running             xlogo &

 [me@linuxbox ~]$ fg %1xlogo

El comando fg seguido de un signo de porcentaje y el número del trabajo (llamado jobspec) hace el truco. Si sólo tenemos un trabajo en el fondo, el jobspec es opcional. Para terminar xlogo, presiona Ctrl-c.

Parando (pausando) un proceso

A veces queremos parar un proceso sin terminarlo. Esto se hace a menudo para permitir que un proceso que está en el frente sea movido al fondo. Para parar un proceso que está en el frente, pulsa Ctrl-z. Pruébalo. En el prompt del comando, escribe xlogo, pulsa ENTER y luego Ctrl-z:

 [me@linuxbox ~]$ xlogo
 [1]+ Stopped                 xlogo
 [me@linuxbox ~]$

Después de parar xlogo, podemos verificar que el programa se ha detenido intentando redimensionar la ventana de xlogo. Veremos que parece un poco muerta. Podemos también devolver el programa al frente, usando el comando fg, o mover el programa al fondo con el comando bg:

 [me@linuxbox ~]$ bg %1
 [1]+ xlogo &
 [me@linuxbox ~]$ 

Como en el comando fg, el jobspec es opcional si sólo hay un trabajo.

Mover un proceso del frente al fondo es útil si arrancamos un programa gráfico desde comandos, pero olvidas colocarlo en el fondo añadiendo el “&” delante.

¿Por qué querrías arrancar un programa gráfico desde la línea de comandos? Hay dos razones. Primero, el programa que quieres iniciar no está incluido en los menús del gestor de ventanas (como xlogo). En segundo lugar, ejecutando un programa desde la línea de comando, podrías ver mensajes de error que sería invisibles si fuera ejecutado gráficamente. A veces, un programa puede fallar si se inicia desde el menú gráfico. Arrancándolo desde la línea de comandos verás un mensaje de error que revelará el problema. Además, algunos programas gráficos pueden tener muchas opciones interesantes y útiles en la línea de comandos.

Señales

El comando kill se usa para matar procesos. Esto nos permite terminar programas que necesitan ser matados. Aquí tenemos un ejemplo:

 [me@linuxbox ~]$ xlogo &
 [1] 28401
 [me@linuxbox ~]$ kill 28401
 [1]+ Terminated           xlogo

Primero arrancamos xlogo en el fondo. El shell muestra el jobspec y el PID del proceso en el fondo. A continuación, usamos el comando kill y especificamos el PID del proceso que queremos terminar. Podríamos haber especificado también el proceso usando un jobspec (por ejemplo, “%1”) en lugar de un PID.

Aunque que esto es todo muy sencillo, hay mucho más al respecto. El comando kill no mata exactamente los procesos, en su lugar les manda señales. Las señales son uno de los distintos caminos con que el sistema operativo se comunica con los programas. Ya hemos visto señales en acción con el uso de Ctrl-c y Ctrl-z. Cuando un terminal recibe una de estas pulsaciones de teclado, manda una señal al programa en el frente. En el caso de Ctrl-c, se manda una señal llamada INT (Interrumpción); con Ctrl-z, una señal llamada TSTP (Terminal Stop). Los programas, por turnos, “escuchan” las señales y las utilizan según las van recibiendo. El hecho de que un programa pueda escuchar y actuar mediante señales permite que el programa haga cosas como salvar el trabajo en proceso cuando se le envía una seña de terminación.

Enviando señales a un proceso con kill

El comando kill se usa para enviar señales a programas. Su sintaxis más común es así:    kill [-signal] PID...

Si no se especifican señales en la línea de comandos, la señal TERM (Terminar) se envía por defecto. El comando kill se usa la mayoría de las veces para enviar las siguientes señales:

Señales comunes

1 HUP 

Colgar. Es un vestigio de los buenos y viejos tiempos cuando los terminales estaban conectados a ordenadores remotos mediante líneas telefónicas y modems. La señal se usa para indicar a los programas que el terminal que controla ha “colgado”. El efecto de esta señal puede demostrarse cerrando una sesión de terminal. El programa en el frente que está corriendo en el terminal recibirá una señal y terminará.

Esta señal también se usa por muchos programas demonio para provocar una reinicialización. Esto significa que cuando se le envía esta señal a un demonio, se reiniciará y releerá su archivo de configuración. El servidor web Apache es un ejemplo de demonio que usa la señal HUP de esta forma.

2 INT 

Interrupción. Realiza la misma función que las teclas Ctrl-c enviadas desde el terminal. Normalmente termina un programa.

9 KILL 

Mata. Esta señal es especial. Mientras que los programas pueden elegir manejar las señales que les son enviadas de diferentes formas, incluso ignorarlas todas, la señal KILL realmente nunca se envía al programa objetivo. En su lugar, el kernel inmediatamente termina el proceso. Cuando un proceso es finalizado de esta forma, no tiene oportunidad de “limpiarse” por sí mismo o salvar su trabajo. Por esta razón, la señal KILL sólo debería ser utilizada como último recurso cuando otras señales de finalización fallan.

15 TERM 

Terminar. Esta es la señal por defecto enviada por el comando kill. Si un programa aún está lo suficientemente “vivo” como para recibir señales, se terminará.

18 CONT 

Continuar. Esta restaurará un proceso después de una señal STOP.

19 STOP 

Parar. Esta seña causa la pausa de un proceso sin terminarlo. Como la señal KILL, no se envía al proceso objetivo, y por lo tanto no puede ser ignorada.
Probemos el comando kill:

 [me@linuxbox ~]$ xlogo &[1]   
 13546
 [me@linuxbox ~]$ kill -1 13546
 [1]+ Hangup               xlogo

En este ejemplo, arrancamos el programa xlogo en el fondo y luego le enviamos una señal HUP con kill. El programa xlogo termina y el shell indica que el proceso en el fondo ha recibido una señal de cuelgue. Necesitarás pulsar la tecla intro un par de veces antes de ver el mensaje. Fíjate que las señales pueden ser especificadas con número o con nombre, incluyendo el nombre precedido de las letras “SIG”:

 [me@linuxbox ~]$ xlogo &
 [1] 13601
 [me@linuxbox ~]$ kill -INT 13601
 [1]+ Interrupt               xlogo
 [me@linuxbox ~]$ xlogo &
 [1] 13608
 [me@linuxbox ~]$ kill -SIGINT 13608
 [1]+ Interrupt xlogo

Repite el ejemplo anterior y prueba las otras señales. Recuerda, también puedes usar jobspecs en lugar de PIDs.

Los procesos, como los archivos, tienen propietarios, y debes ser el propietario de un proceso (o el superusuario) para enviarle señales con kill.

Además de la lista de señales anterior, cuya mayoría se usa con kill, hay otras señales usadas frecuentemente por el sistema. Aquí tenemos una lista de otras señales comunes:

3 QUIT 
Quit.

11 SEGV 
Violación de segmentación. Esta señal se envía si un programa hace un uso ilegal de la memoria, o sea, trata de escribir en un sitio en el que no está autorizado.

20 TSTP 
Stop de terminal. Esta es la señal enviada por el terminal cuando se pulsa Ctrl-z. Al contrario que la señal STOP, la señal TSTP la recibe el programa pero el programa puede elegir ignorarla.

28 WINCH 
Cambio de ventana. Es una señal enviada por el sistema cuando una ventana cambia de tamaño. Algunos programas, como top y less responden a esta señal redibujándose a sí mismos para ajustarse a las nuevas dimensiones de la ventana.Para los curiosos, una lista completa de las señales se puede ver con el siguiente comando:

 [me@linuxbox ~]$ kill -l

Enviando señales a múltiples procesos con killall

También es posible enviar señales a múltiples procesos eligiendo un programa específico o un nombre de usuario usando el comando killall. Aquí tenemos la sintaxis:

 killall [-u user] [-signal] name...

Para demostrarlo, iniciaremos un par de instancias del programa xlogo y las finalizaremos:

 [me@linuxbox ~]$ xlogo &
 [1] 18801
 [me@linuxbox ~]$ xlogo &
 [2] 18802
 [me@linuxbox ~]$ killall xlogo
 [1]- Terminated xlogo
 [2]+ Terminated xlogo

Recuerda, como con kill, debes tener privilegios de superusuario para enviar señales a procesos que no te pertenecen.

Más comandos relacionados con procesos

Como monitorizar procesos es una tarea importante para la administración de sistemas, hay muchos comandos para ello. Aquí tenemos algunos para jugar con ellos:

Otros comandos relacionados con procesos

pstree
Muestra una lista de procesos dispuestos en una estructura de árbol mostrando las relaciones padre/hijo entre los procesos.

vmstat
Muestra una instantánea de los recursos de sistema usados, incluyendo memoria, intercambio e I/O de disco. Para ver una pantalla continua, añade al comando un periodo de tiempo (en segundos) para las actualizaciones. Por ejemplo: vmstat 5. Finaliza la salida con Ctrl-c.

xload
Un programa gráfico que traza un gráfico mostrando la carga del sistema a lo largo del tiempo.

tload
Igual que el programa xload, pero dibuja el gráfico en el terminal. Finaliza la salida con Ctrl-c.

Resumiendo

Los sistemas más modernos proporcionan un mecanismo para manejar múltiples procesos. Linux provee un rico catálogo de herramientas para este propósito. Dado que Linux es el sistema operativo de servidores más expandido en el mundo, ésto tiene mucho sentido. Sin embargo, al contrario que otros sistemas, Linux se basa principalmente en herramientas de línea de comandos para el manejo de procesos. Aunque hay herramientas gráficas para procesos en Linux, las herramientas de línea comandos son ampliamente preferidas por su velocidad y ligereza. Aunque las herramientas de la GUI son más bonitas, a menudo crean una gran carga en el sistemas ellas mismas, lo cual estropean el propósito.