¡Esta es una revisión vieja del documento!
Tabla de Contenidos
Control de procesos
Los sistemas Slackware a menudo ejecutan cientos o miles de programas, cada uno de los cuales se conoce como un proceso. El manejo de estos procesos es una parte importante de la administración de sistemas. Entonces, ¿cómo manejamos exactamente todos estos procesos por separados?
ps
Los primeros pasos en manejar procesos es examinar qué procesos se están ejecutando actualmente. La herramienta más popular y poderosa para esto es ps(1). Sin ningún argumento, ps no te brindará mucha información. Por defecto, solo le indica qué procesos se están ejecutando en su shell activa actualmente. Si queremos más información, tendremos que profundizar sobre este tema.
darkstar:~$ ps PID TTY TIME CMD 12220 pts/4 00:00:00 bash 12236 pts/4 00:00:00 ps
Aquí se puede ver los procesos que están corriendo actualmente en tu shell o terminal activa y solo alguna información es incluida. El PID es el “ID del proceso”; a todos los procesos se les asigna un número único. El parámetro TTY le dice a qué dispositivo terminal se añade el proceso. Naturalmente, CMD es el comando que estaba corriendo. Sin embargo, usted podría estar un poco confundido con el parámetro TIME, ya que parece moverse muy lentamente. Esta no es la cantidad de tiempo real que el procesos ha estado ejecutándose, sino la cantidad de tiempo de CPU que el proceso ha consumido. Un proceso inactivo no usa virtualmente tiempo de CPU, por lo que este valor no puede aumentar rápidamente.
Ver solo nuestros propios procesos no es muy divertido, así que es posible ver todos los procesos con el argumento -e.
darkstar:~$ ps -e PID TTY TIME CMD 1 ? 00:00:00 init 2 ? 00:00:00 kthreadd 3 ? 00:00:00 migration/0 4 ? 00:00:00 ksoftirqd/0 7 ? 00:00:11 events/0 9 ? 00:00:01 work_on_cpu/0 11 ? 00:00:00 khelper 102 ? 00:00:02 kblockd/0 105 ? 00:01:19 kacpid 106 ? 00:00:01 kacpi_notify ... muchas más líneas han sido omitidas ...
Los ejemplos anteriores usan la sintaxis estándar de ps, pero mucha más información puede se descubierta si usamos la sintaxis BSD. Para hacerlo, debemos utilizar el argumento aux.
darkstar:~$ ps aux USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.0 3928 632 ? Ss Apr05 0:00 init [3] root 2 0.0 0.0 0 0 ? S Apr05 0:00 [kthreadd] root 3 0.0 0.0 0 0 ? S Apr05 0:00 [migration/0] root 4 0.0 0.0 0 0 ? S Apr05 0:00 [ksoftirqd/0] root 7 0.0 0.0 0 0 ? S Apr05 0:11 [events/0] root 9 0.0 0.0 0 0 ? S Apr05 0:01 [work_on_cpu/0] root 11 0.0 0.0 0 0 ? S Apr05 0:00 [khelper] ... muchas más líneas han sido omitidas ....
Como puedes ver, la sintaxis BSD ofrece mucha más información, incluyendo que usuario controla los procesos y que porcentaje de RAM y CPU está consumiendo cuando ps está corriendo.
Para lograr una parte de esto, en función del proceso, ps permite que se proporcionen uno o más ID de proceso (PIDs) en la línea de comando, y posee el argumento '-o' para mostrar un atributo particular de el PID.
darkstar:~$ ps -o cmd -o etime $$ CMD ELAPSED /bin/bash 12:22
Lo que se muestra es el nombre del comando PID's (cmd) y su tiempo transcurrido (etime). El PID en este ejemplo, es una variable shell para el PID de la shell actual. Como puede se puede observar en este ejemplo, el proceso de shell ha existido durante 12 minutos, 22 segundos.
Usando el comando pgrep(1), esto puede ser más automatizable.
darkstar:~$ ps -o cmd -o rss -o vsz $(pgrep httpd) CMD RSS VSZ /usr/sbin/httpd -k restart 33456 84816 /usr/sbin/httpd -k restart 33460 84716 /usr/sbin/httpd -k restart 33588 84472 /usr/sbin/httpd -k restart 30424 81608 /usr/sbin/httpd -k restart 33104 84900 /usr/sbin/httpd -k restart 33268 85112 /usr/sbin/httpd -k restart 30640 82724 /usr/sbin/httpd -k restart 15168 67396 /usr/sbin/httpd -k restart 33180 84416 /usr/sbin/httpd -k restart 33396 84592 /usr/sbin/httpd -k restart 32804 84232
En este ejemplo, una ejecución de sub-shell usando pgrep devuelve los PIDs de los procesos cuyos comandos incluyen 'httpd'. Entonces, ps muestra el nombre del comando, el tamaño de la memoria residente y de la memoria virtual.
Finalmente, ps puede también crear un árbol de procesos. Esto muestra que procesos tienen procesos hijos. Terminar un proceso padre que posee hijos también termina los procesos hijos que posea. Se puede hacer esto empleando el argumento -ejH.
darkstar:~$ ps -ejH ... many lines omitted ... 3660 3660 3660 tty1 00:00:00 bash 29947 29947 3660 tty1 00:00:00 startx 29963 29947 3660 tty1 00:00:00 xinit 29964 29964 29964 tty7 00:27:11 X 29972 29972 3660 tty1 00:00:00 sh 29977 29972 3660 tty1 00:00:05 xscreensaver 29988 29972 3660 tty1 00:00:04 xfce4-session 29997 29972 3660 tty1 00:00:16 xfwm4 29999 29972 3660 tty1 00:00:02 Thunar ... muchas más líneas han sido omitidas ...
Como se observa, ps(1) es una herramienta increíblemente poderosa para determinar no solo que procesos están actualmente activos en tu sistema, si no que también, permite obtener una gran cantidad de información importante acerca de los mismos.
Como es el caso con muchas de las aplicaciones, existen varias herramientas para el trabajo. Similar a la salida de ps -ejH, pero de una forma más concisa, está el comando pstree(1). Este comando muestra el árbol de procesos un poco más visual.
darkstar:~$ pstree init-+-atd |-crond |-dbus-daemon |-httpd---10*[httpd] |-inetd |-klogd |-mysqld_safe---mysqld---8*[{mysqld}] |-screen-+-4*[bash] | |-bash---pstree | |-2*[bash---ssh] | `-bash---irssi |-2*[sendmail] |-ssh-agent |-sshd---sshd---sshd---bash---screen `-syslogd
kill y killall
La gestión de los procesos no solo consiste en saber cuáles se están ejecutando, sino también en comunicarse con ellos para cambiar su comportamiento. La forma más común de administrar un programa es terminarlo. Por lo tanto, la herramienta para el trabajo se llama kill(1). A pesar del nombre, kill en realidad, no termina los procesos, sino que les envía señales. La señal más común es un SIGTERM, que le dice al proceso que termine lo que está haciendo y termine. Hay una variedad de otras señales que pueden enviarse, pero las tres más comunes son SIGTERM, SIGHUP y SIGKILL.
Managing processes isn't only about knowing which ones are running, but
also about communicating with them to change their behavior. The most
common way of managing a program is to terminate it. Thus, the tool for
the job is named kill(1). Despite the name,
kill doesn't actually terminate processes,
but sends signals to them. The most common signal is a SIGTERM, which
tells the process to finish up what it is doing and terminate. There
are a variety of other signals that can be sent, but the three most
common are SIGTERM, SIGHUP, and SIGKILL.
Lo que hace un proceso cuando recibe una señal varía. La mayoría de los programas terminarán (o intentarán terminar) cada vez que reciban una señal, pero hay algunas diferencias importantes.
What a process does when it receives a signal varies. Most programs
will terminate (or attempt to terminate) whenever they receive any
signal, but there are a few important differences.
Para empezar, la señal SIGTERM informa al proceso que debe terminarse a sí misma lo antes posible. Esto le da tiempo al proceso para finalizar cualquier actividad importante, como escribir información en el disco, antes de que se cierre. En contraste, la señal SIGKILL le dice al proceso que se termine de inmediato, sin preguntas. Esto es más útil para matar procesos que no responden y, en ocasiones, se denomina “bala de plata”. Algunos procesos (particularmente demonios) capturan la señal SIGHUP y re cargan su archivo de configuración cuando reciben esta.
For starters, the SIGTERM signal informs the process that it should terminate itself at its earliest convenience. This gives the process time to finish up any important activities, such as writing information to the disk, before it closes. In contrast, the SIGKILL signal tells the process to terminate itself immediately, no questions asked. This is most useful
for killing processes that are not responding and is sometimes called
the “silver bullet”. Some processes (particularly daemons) capture the SIGHUP signal and reload their configuration files whenever they
receive it.
Para señalar un proceso, primero necesitamos saber cual es el PID. Esto se puede obtener con ps como se discutió previamente. Para enviar diferentes señales a un proceso en ejecución, simplemente pase el número de señal y -s como un argumento. El argumento -l lista todas las señales que tu puedes elegir y sus números. También puede enviar señales por su nombre con -s.
In order to signal a process, we first need to know it's PID. You can
get this easily with ps as we discused.
In order to send different signals to a running process, you simply pass
the signal number and -s as an argument. The -l
argument lists all the signals you can choose and their number. You can
also send signals by their name with -s.
darkstar:~$ 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 ... many more lines omitted ... darkstar:~$ kill 1234 # SIGTERM darkstar:~$ kill -s 9 1234 # SIGKILL darkstar:~$ kill -s 1 1234 # SIGHUP darkstar:~$ kill -s HUP 1234 # SIGHUP
A veces es posible que desee terminar todos los procesos en ejecución con un nombre determinado. Puedes matar procesos por nombre con killall(1). Solo pasa los mismos argumentos a killall que pasarías a kill.
darkstar:~$ killall bash # SIGTERM darkstar:~$ killall -s 9 bash # SIGKILL darkstar:~$ killall -s 1 bash # SIGHUP darkstar:~$ killall -s HUP bash # SIGHUP
top
Hasta ahora hemos aprendido cómo mirar los procesos activos por un momento, pero ¿y si queremos monitorearlos durante un periodo de tiempo prolongado? top(1) nos permite hacer esto precisamente.
So far we've learned how to look at the active processes for a moment
in time, but what if we want to monitor them for an extended period?
top(1) allows us to do just that.
Muestra una lista ordenada de los procesos en su sistema, junto con información vital sobre ellos y actualizaciones periódicas.
De forma predeterminada, los procesos están ordenados por su porcentaje de CPU y las actualizaciones se producen cada tres segundos.
It displays an ordered list of the processes on your system, along with
vital information about them, and updates periodically. By default,
processes are ordered by their CPU percentage and updates occur every
three seconds.
darkstar:~$ top top - 16:44:15 up 26 days, 5:53, 5 users, load average: 0.08, 0.03, 0.03 Tasks: 122 total, 1 running, 119 sleeping, 0 stopped, 2 zombie Cpu(s): 3.4%us, 0.7%sy, 0.0%ni, 95.5%id, 0.1%wa, 0.0%hi, 0.2%si, 0.0%st Mem: 3058360k total, 2853780k used, 204580k free, 154956k buffers Swap: 0k total, 0k used, 0k free, 2082652k cached PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 1 root 20 0 3928 632 544 S 0 0.0 0:00.99 init 2 root 15 -5 0 0 0 S 0 0.0 0:00.00 kthreadd 3 root RT -5 0 0 0 S 0 0.0 0:00.82 migration/0 4 root 15 -5 0 0 0 S 0 0.0 0:00.01 ksoftirqd/0 7 root 15 -5 0 0 0 S 0 0.0 0:11.22 events/0 9 root 15 -5 0 0 0 S 0 0.0 0:01.19 work_on_cpu/0 11 root 15 -5 0 0 0 S 0 0.0 0:00.01 khelper 102 root 15 -5 0 0 0 S 0 0.0 0:02.04 kblockd/0 105 root 15 -5 0 0 0 S 0 0.0 1:20.08 kacpid 106 root 15 -5 0 0 0 S 0 0.0 0:01.92 kacpi_notify 175 root 15 -5 0 0 0 S 0 0.0 0:00.00 ata/0 177 root 15 -5 0 0 0 S 0 0.0 0:00.00 ata_aux 178 root 15 -5 0 0 0 S 0 0.0 0:00.00 ksuspend_usbd 184 root 15 -5 0 0 0 S 0 0.0 0:00.02 khubd 187 root 15 -5 0 0 0 S 0 0.0 0:00.00 kseriod 242 root 20 0 0 0 0 S 0 0.0 0:03.37 pdflush 243 root 15 -5 0 0 0 S 0 0.0 0:02.65 kswapd0
La página del manual tiene detalles útiles sobre cómo interactuar con top, como cambiar su intervalo de retardo, se muestran los procesos de orden, e incluso cómo terminar los procesos directamente desde top directamente.
The man page has helpful details on how to interact with
top such as changing its delay interval, the
order processes are displayed, and even how to terminate processes
right from within top itself.
cron
Bien, hemos aprendido muchas formas diferentes de visualizar los procesos activos en nuestro sistema y los medio de señalizarlo, pero ¿Y si queremos ejecutar un proceso periódicamente? Afortunadamente, Slackware incluye crond(8).
cron corre procesos para todos los usuarios en la fecha prevista.
Esto lo hace muy útil para los procesos que deben ejecutarse periódicamente, pero no requieren una demonización completa, como por ejemplo los scripts de copia de seguridad.
Ok, so we've learned many different ways of viewing the active
processes on our system and means of signalling them, but what if we
want to run a process periodically? Fortunately, Slackware includes
just the thing, crond(8). cron runs
processes for every user on the schedule that user demands. This makes
it very useful for processes that need to be run periodically, but
don't require full daemonization, such as backup scripts.
Todos los usuarios tienen su propia entrada en la base de datos de cron. Por lo tanto, los usuarios que no tienen privilegios de administrador también pueden correr procesos periódicamente.
Every usergets their own entry in the cron database, so non-root users can periodically run processes too.
Con el fin de correr programas desde el cron, necesitaras usar el crontab(1).
La página del manual enumera una variedad de formas de hacer esto, pero el método más común es empleando el argumento -e.
In order to run programs from cron, you'll need to use the
crontab(1). The man page lists a variety of
ways to do this, but the most common method is to pass the
-e argument.
Esto bloqueará la entrada del usuario en la base de datos de cron (para evitar que otro programa los sobre escriba), luego abra esa entrada con cualquier editor de texto especificado por la variable de entorno VISUAL.
This will lock the user's entry in the cron database (to prevent it from being overwritten by another program), then open that entry with whatever text editor is specified by the VISUAL environment variable.
En sistemas Slackware, típicamente el editor es vi. Antes de continuar, es posible que usted necesite consultar el capitulo de vi.
On Slackware systems, this is typically the vi editor. You may need to refer to the chapter on vi before continuing.
Las entradas de la base de datos de cron pueden parecer un poco arcaicas al principio, pero son muy flexibles. Cada línea descomentada es procesada por crond y el comando especificado se ejecuta si todas las condiciones temporales se cumplen.
The cron database entries may seem a little archaic at first, but they
are highly flexible. Each uncommented line is processed by
crond and the command specified is run if
all the time conditions match.
darkstar:~$ crontab -e # Keep current with slackware 30 02 * * * /usr/local/bin/rsync-slackware64.sh 1>/dev/null 2>&1
Como se menciono anteriormente, la sintaxis para las entradas cron es difícil de entender al principio, así que revisemos cada parte de forma individual. De izquierda a derecha, las diferentes secciones son: Minutos, Hora, Día, Mes, día de la semana y comando. Cualquier entrada asterisco * coincide con cada minuto, hora, día y así sucesivamente.
Así que, a partir del ejemplo anterior el comando es “/usr/local/bin/rsync-slackware64.sh 1>/dev/null 2>&1”, se ejecuta diariamente a las 2:30 a.m.
As mentioned before, the syntax for cron entries is a little difficult
to understand at first, so let's look at each part individually. From
left to right, the different sections are: Minute, Hour, Day, Month,
Week Day, and Command. Any asterisk * entry matches
every minute, hour, day, and so on. So from the example above, the
command is “/usr/local/bin/rsync-slackware64.sh 1>/dev/null 2>&1”, and
it runs every weekday or every week of every month at 2:30 a.m.
crond también enviará un correo electrónico al usuario local con cualquier salida que genere el comando. Por está razón, muchas tareas tienen su salidas re-dirigidas a /dev/null
, un dispositivo especial que inmediatamente descarta todo lo que recibe. Para que le resulte más fácil recordar estas reglas, puede pegar el siguiente texto comentado en la parte superior de sus propias entradas cron.
crond will also e-mail the local user with
any output the command generates. For this reason, many tasks have
their output redirected to
/dev/null
, a special
device file that immediately discards everything it receives. In order
to make it easier for you to remember these rules, you might wish to
paste the following commented text at the top of your own cron entries.
# Re-dirige todo a /dev/null con: # 1>/dev/null 2>&1 # # MIN HOUR DAY MONTH WEEKDAY COMMAND
Por defecto, Slackware incluye un número de entradas y comentarios en el contrab del administrador. Estas entradas facilitan la configuración periódica de las tareas del sistema al crear una serie de directorios en /etc
correspondientes a la frecuencia con la que se deben ejecutar las tareas. Cualquier script colocado dentro de estos directorios se ejecutará cada hora, diariamente, semanalmente o mensualmente. Los nombres deben ser autoexplicativos:
By default, Slackware includes a number of entries and comments in
root's crontab. These entries make it easier to setup periodic system
tasks by creating a number of directories in
/etc
corresponding to how often the tasks should run. Any script placed
within these directories will be run hourly, daily, weekly, or monthly.
The names should be self-explanatory:/etc/cron.hourly
,
/etc/cron.daily
,
/etc/cron.weekly
, y
/etc/cron.monthly
.
Navegación de capítulos
Capítulo previo: The Bourne Again Shell
Próximo capítulo: The X Window System
Fuentes
* Fuente original: http://www.slackbook.org/beta
* Escrito originalmente por Alan Hicks, Chris Lumens, David Cantrell, Logan Johnson