Preparación para el examen de certificación 101 del LPI (segundo lanzamiento), Parte 2

1.  Antes de comenzar

Acerca de este tutorial

Bienvenido a “Administración básica”, el segundo de cuatro tutoriales diseñado para prepararlo para el examen 101 del Instituto Profesional de Linux (LPI por sus siglas en inglés). En este tutorial, le mostraremos como utilizar expresiones regulares para buscar archivos utilizando patrones de texto. Después, haremos una introducción al estándar de jerarquía del sistema de archivos (FHS, por sus siglas en inglés), y le mostraremos como encontrar archivos en su sistema. Además le diremos como tomar control total de los procesos de Linux, ejecutándolos en segundo plano, listándolos, separándolos de la terminal y más. También, le daremos una rápida introducción a tuberías de la interfaz de comandos, redireccionamiento, y órdenes de procesamiento de texto. Por último, haremos una introducción a los módulos del núcleo Linux.

Este tutorial en particular (parte 2) es ideal para quienes tienen un buen conocimiento básico de bash y quieren recibir una sólida introducción a tareas básicas de administración Linux. Si es nuevo en Linux, le recomendamos que complete la parte 1 de esta serie de tutoriales antes de continuar. Para algunos, este material será nuevo, pero los usuarios Linux más experimentados encontrarán en este tutorial una buena manera de complementar sus conocimientos básicos de administración Linux.

Para aquellos que han tomado el lanzamiento 1 de este tutorial por razones diferentes a la preparación para el examen LPI, probablemente no sea necesario tomar esta versión. Sin embargo, si planea presentarse a los exámenes, debe considerar seriamente leer este tutorial.

Acerca del autor

Con residencia en Albuquerque, Nuevo México, Daniel Robbins es el arquitecto en jefe de Gentoo Linux, una metadistribución Linux avanzada basada en puertos (ports). Además escribe artículos, tutoriales y sugerencias para IBM developerWorks zona Linux y servicios de desarrollo Intel. También ha contribuido como autor de muchos libros, incluyendo Samba y SuSE Unleashead. Daniel disfruta pasar tiempo con su esposa Mary y su hija Hadassha. Puede contactar a Daniel en drobbins@gentoo.org.

Chris Houser, conocido por sus amigos como "Chouser," ha sido un partidario de UNIX desde 1994 cuando se unió al equipo de administración de la red de informática en la Universidad Taylor en Indiana, donde obtuvo su licenciatura en Ciencias de la Computación y Matemáticas. Desde entonces ha trabajado en programación de aplicaciones web, diseño de interfaz de usuario, soporte para programas de vídeo profesional y ahora programando el controlador del dispositivo Tru4 UNIX en Compaq. Además ha contribuido en varios proyectos de programas libres (recientemente en Gentoo Linux). Vive con su esposa y dos gatos en New Shapire. Puede contactarlo en chouser@gentoo.org.

Aron Griffis, graduado de la Universidad Taylor con título en Ciencias de la Computación y premiado con el título "Futuro fundador de una comunidad UNIX utópica". Trabajando para conseguir ese objetivo Aron es empleado de Compaq, escribe controladores de red para Tru64 UNIX y utiliza su tiempo libre tocando melodías en el piano o desarrollando Gentoo Linux. Vive con su esposa Amy (también ingeniera UNIX) en Nashua, New Hampshire.

2.  Expresiones regulares

¿Qué es una expresión regular?

Una expresión regular (también llamada "regex" o "regexp") es una sintaxis especial usada para describir patrones de texto. En los sistemas Linux, las expresiones regulares son comúnmente usadas para encontrar patrones de texto, así como para realizar operaciones de buscar y reemplazar en cadenas de texto.

Comparación con Glob

Cuando veamos expresiones regulares, puede notar que la sintaxis de expresiones regulares es similar a la del archivo de nombre "englobamiento" que vimos en la parte 1. Sin embargo, no permita que esto lo confunda, su parecido es solo superficial. Ambos, expresiones regulares y los patrones de englobamiento, si bien parecen similares son fundamentalmente diferentes.

La subcadena simple

Con la advertencia anterior, veamos lo más básico de expresiones regulares, la subcadena simple. Para hacer esto usaremos grep, una orden que busca en el contenido de un archivo una expresión regular determinada. grep imprime cada línea que coincide con la expresión regular e ignora cada línea que no lo hace:

$ grep bash /etc/passwd
operator:x:11:0:operator:/root:/bin/bash
root:x:0:0::/root:/bin/bash
ftp:x:40:1::/home/ftp:/bin/bash

Arriba, el primer parámetro grep es una expresión regular; el segundo es el nombre de un archivo. grep lee cada línea en /etc/passwd y le aplica la expresión regular subcadena simple bash, buscando coincidencias. Si una coincidencia es encontrada, grep imprime cada línea que coincide, de lo contrario, la línea es ignorada.

Entendiendo la subcadena simple

En general, si está buscando una subcadena, puede especificar el texto literal sin proporcionar caracteres "especiales". El único momento en el que necesitará hacer algo especial sería si su subcadena contiene +, ., *, [, ], o \, en cuyo caso estos caracteres tendrían que estar entre comillas precedidos por una barra invertida. Estos son algunos ejemplos de la subcadena simple de expresiones regulares:

• /tmp (busca por la cadena literal /tmp)
• "\[box\]" (busca por la cadena literal [box])
• "\*funny\*" (busca por la cadena literal *funny*)
• "ld\.so" (busca por la cadena literal ld.so)

Metacaracteres

Con expresiones regulares, puede realizar búsquedas mucho más complejas que los ejemplos que hemos visto hasta el momento tomando ventaja de los metacaracteres. Uno de estos caracteres es el . (punto) el cual coincide con cualquier carácter:

$ grep dev.hda /etc/fstab
/dev/hda3      /              reiserfs      noatime,ro 1 1
/dev/hda1      /boot          reiserfs      noauto,noatime,notail 1 2
/dev/hda2      swap           swap          sw 0 0
#/dev/hda4     /mnt/extra     reiserfs        noatime,rw 1 1

En este ejemplo, el texto literal dev.hda no aparece en ninguna de las líneas de /etc/fstab. Sin embargo, grep no buscaba la cadena literal dev.hda, pero si el patrón dev.hda. Recuerde que . coincidirá con cualquier carácter. Como puede ver el metacarácter . es equivalente en su funcionamiento al metacarácter ? de las expansiones "globales".

Uso de []

Si quisiéramos hacer coincidir un carácter más específicamente que con ., podemos utilizar [ y ] (corchetes) para especificar un subconjunto de caracteres que pueden coincidir:

$ grep dev.hda[12] /etc/fstab
/dev/hda1     /boot        reiserfs        noauto,noatime,notail 1 2
/dev/hda2     swap         swap            sw 0 0

Como puede ver, esta función sintáctica particular funciona idéntica a [] de expansiones de "englobamiento". De nuevo, esta es una de las cosas complicadas sobre aprender expresiones regulares -- la sintaxis es similar pero no idéntica a la de expansiones de "englobamiento", lo cual hace que las expresiones regulares sean un tanto confusas de aprender.

Usando [^]

Puede invertir el significado de los corchetes agregando un ^ inmediatamente después de [. En este caso, los corchetes encontrarán una coincidencia con cualquier carácter que no sea mencionado dentro de los mismos. Una vez más, note que usamos [^] con expresiones regulares y [!] con englobamiento:

$ grep dev.hda[^12] /etc/fstab
/dev/hda3       /               reiserfs        noatime,ro 1 1
#/dev/hda4      /mnt/extra      reiserfs        noatime,rw 1 1

Diferentes sintaxis

Es importante notar que la sintaxis entre corchetes es fundamentalmente diferente de la utilizada en otras partes de la expresión regular. Por ejemplo, si pone un . dentro de corchetes, esto le permite encontrar una coincidencia literal con ., justo como en los ejemplos 1 y 2 mencionados arriba. En cambio, un . literal fuera de los corchetes se interpreta como un metacarácter a menos que sea precedido de una \. Podemos aprovechar este hecho para imprimir una lista de todas las líneas en /etc/fstab que contengan la cadena literal dev.hda tecleando:

$ grep dev[.]hda /etc/fstab

Alternativamente podemos escribir:

$ grep "dev\.hda" /etc/fstab

Es probable que ninguna expresión regular coincida con las líneas del archivo /etc/fstab.

El metacarácter "*"

Algunos metacaracteres no coinciden con nada por si solos, pero modifican el significado del carácter previo. Un ejemplo de esto es el metacarácter * (asterisco), el cual es usado para coincidir con cero o más ocurrencias del carácter anterior. Tenga en cuenta que esto significa que * tiene un significado diferente en expresiones regulares que en englobamiento:

• ab*c coincide con abbbbc pero no con abqc (si fuese englobamiento, coincidiría con ambas cadenas -- ¿Puede determinar por qué?)
• ab*c coincide con abc pero no con abbqbbc (de nuevo, si fuese englobamiento coincidiría con ambas cadenas)
• ab*c coincide con ac pero no con cba (si fuese englobamiento, ac no coincidiría, ni tampoco cba)
• b[cq]*e coincide con bqe y be (si fuese englobamiento, coincidiría bqe pero no be)
• b[cq]*e coincide con bccqqe pero no con bccc (si fuese englobamiento, coincidiría con la primera pero no con la segunda)
• b[cq]*e coincide con bqqcce pero no con cqe (si fuese englobamiento, coincidiría con la primera pero no con la segunda)
• b[cq]*e coincide con bbbeee (no sería el caso con englobamiento)
• .* coincide con cualquier cadena. (si fuese englobamiento, coincidiría con cualquier cadena que comience con .)
• foo.* coincidiría con cualquier cadena que comience con foo (si fuese englobamiento, coincidiría con cualquier cadena que comience con los cuatro caracteres literales foo.)

Ahora un pequeño repaso: la línea ac coincide con la expresión regular ab*c por que el asterisco también le permite a la expresión anterior (b) aparecer cero veces. Nuevamente, es fundamental tener en cuenta que el metacarácter * de expresiones regulares se interpreta de manera fundamentalmente diferente que el carácter * de englobamiento.

Principio y final de línea

Los últimos metacaracteres que cubriremos aquí a detalle son ^ y $, utilizados para encontrar coincidencias al principio y al final de la línea respectivamente. Mediante el uso de ^ al principio de su expresión regular, puede hacer que su patrón esté "anclado" al inicio de la línea. En el siguiente ejemplo, usamos la expresión regular ^# para encontrar cualquier línea que comience con el carácter #:

$ grep ^# /etc/fstab
# /etc/fstab: static file system information.
#

Expresiones regulares de línea completa

^ y $ se pueden combinar para coincidir con una línea completa. Por ejemplo, la siguiente expresión regular coincidirá con una línea que comience con el carácter # y termine con el carácter ., con cualquier número de caracteres entre ellos:

$ grep '^#.*\.$' /etc/fstab
# /etc/fstab: static file system information.

En el ejemplo anterior, encerramos la expresión regular entre comillas simples para prevenir que $ sea interpretado por el intérprete de comandos. Sin las comillas simples, el $ desaparecería de la expresión regular antes de darle a grep la oportunidad de verlo.

3.  FHS y búsqueda de archivos

Estándar de jerarquía del sistema de archivos (FHS)

El Estándar de Jerarquía del sistema de archivos es un documento que especifica la disposición de los directorios en un sistema Linux. El FHS se diseñó para proporcionar un esquema común para simplificar la distribución de software independiente -- así que este material es en general el mismo entre las distintas distribuciones de Linux. El FHS especifica el siguiente árbol de directorios (tomados directamente de la especificación FHS):

• / (el directorio root)
• /boot (archivos estáticos del boot loader)
• /dev (archivos de dispositivos)
• /etc (anfitrión-configuración específica del sistema)
• /lib (librerías compartidas esenciales y módulos del núcleo)
• /mnt (punto de montaje para el montaje temporal de un sistema de archivos)
• /opt (paquetes de complementos de aplicaciones)
• /sbin (binarios esenciales del sistema)
• /tmp (archivos temporales)
• /usr (jerarquía secundaria)
• /var (datos variables)

Las dos categorías independientes del FHS

El FHS basa su especificación de diseño en la idea de que existen dos categorías independientes de archivos: compartidos vs no compartidos, y variables vs estáticos. Los archivos compartidos pueden, como su nombre lo dice, ser compartidos entre anfitriones; los datos no compartidos son específicos de un anfitrión (por ejemplo, los archivos de configuración). Los datos variables pueden ser modificados; los estáticos no son modificables (excepto en la instalación y mantenimiento de un sistema).

El siguiente cuadro resume las cuatro combinaciones posibles, con ejemplos de directorios que pueden formar parte de esas categorías. Una vez más, esta tabla es tomada directamente de la especificación FHS:

+----------+-----------------+----------------+
|          | compartidos     | no compartidos |
+----------+-----------------+----------------+
|estáticos | /usr            | /etc           |
|          | /opt            | /boot          |
+----------+-----------------+----------------+
|variables | /var/mail       | /var/run       |
|          | /var/spool/news | /var/lock      |
+----------+-----------------+----------------+

Jerarquía secundaria en /usr

En /usr encontrará una jerarquía secundaria que luce muy parecida al sistema de archivos de root. No es crítico para /user existir cuando la máquina encienda, puede estar compartido en una red (compartido), o montado en un CD-ROM (estático). La mayoría de las configuraciones de Linux no hacen uso del intercambio de /usr, pero es valioso comprender la utilidad de distinguir entre la jerarquía primaria en un directorio root y la jerarquía secundaria en /usr.

Esto es todo lo que veremos acerca del Estándar de la Jerarquía del Sistema de Archivos. El documento mismo es bastante fácil de leer, así que debería de darle un vistazo. Si lo lee, comprenderá mucho más acerca del sistema de archivos Linux. Puede encontrarlo en http://www.pathname.com/fhs/.

Búsqueda de archivos

Los sistemas frecuentemente contienen cientos de miles de archivos. Tal vez tiene la experiencia suficiente para no perderles el rastro, pero es probable que ocasionalmente necesite ayuda para encontrar alguno. Existen algunas herramientas en Linux para encontrar archivos. Esta introducción le ayudará a elegir la herramienta adecuada para este trabajo.

El PATH

Cuando ejecuta un programa en la línea de comandos, bash en realidad busca dentro de una lista de directorios para encontrar el programa que solicitó. Por ejemplo cuando teclea ls, bash intrínsecamente desconoce que el programa ls vive en /usr/bin . En cambio, bash hace referencia a una variable llamada PATH, la cual es una lista de directorios separada por dos puntos (:). Podemos examinar el valor de PATH:

$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin

Considerando este valor de PATH (el suyo puede ser diferente), bash revisará primero /usr/local/bin, luego /usr/bin en búsqueda del programa ls. Lo más probable es que ls se encuentre en /usr/bin, por lo que bash se detendrá en ese punto.

Modificando PATH

Puede aumentar su PATH asignándolo en la línea de comandos:

$ PATH=$PATH:~/bin
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin:/home/yo/bi
n

También puede eliminar elementos de PATH, aunque no es tan fácil porque no puede hacer referencia al $PATH existente. Lo mejor es simplemente escribir el nuevo PATH que desea:

$ PATH=/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:~/bin
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/home/agriffis/bin

Para hacer que sus cambios en PATH estén disponibles para cualquier proceso futuro puede comenzar en esta interfaz de comandos, exportar sus cambios utilizando el comando export:

$ export PATH

Todo sobre "which"

Puede revisar si existe un programa dado en PATH utilizando which. Por ejemplo, aquí nos encontramos con que nuestro sistema Linux no tiene sentido (común):

$ which sentido
which: no sentido in
(/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin)

En este ejemplo, encontramos ls:

$ which ls
/usr/bin/ls

"which -a"

Finalmente, debe saber que la bandera -a, ocasiona que which le muestre todas las instancias de un programa determinado en su PATH:

$ which -a ls
/usr/bin/ls
/bin/ls

whereis

Si está interesado en conocer más información de un programa en lugar de su simple ubicación, puede probar el programa whereis:

$ whereis ls
ls: /bin/ls /usr/bin/ls /usr/share/man/man1/ls.1.gz

Podemos ver que ls aparece en dos lugares binarios comunes, /bin y /usr/bin. Adicionalmente, estamos informados de que existe una página de manual localizada en /usr/share/man. Esta es la página del manual que vería si teclea man ls.

El programa whereis también tiene la habilidad de buscar fuentes, especificar rutas de búsqueda alternativas y buscar entradas inusuales. Consulte la página del manual para más información.

find

La orden find es otra herramienta útil para su caja de herramientas. Con find no está limitado solo a programas; puede buscar cualquier archivo que desee, utilizando una variedad de criterios de búsqueda. Por ejemplo, para buscar un archivo de nombre LEEME, que comienza en /usr/share/doc:

$ find /usr/share/doc -name LEEME
/usr/share/doc/ion-20010523/LEEME
/usr/share/doc/bind-9.1.3-r6/dhcp-dynamic-dns-examples/LEEME
/usr/share/doc/sane-1.0.5/LEEME

find y comodines

Puede usar los comodines de "englobamiento" en el argumento -name, siempre que los encierre entre comillas o barras invertidas (así son buscados intactos y no son ampliados por bash). Por ejemplo, puede que quiera buscar archivos LEEME con extensiones:

$ find /usr/share/doc -name LEEME\*
/usr/share/doc/iproute2-2.4.7/LEEME.gz
/usr/share/doc/iproute2-2.4.7/LEEME.iproute2+tc.gz
/usr/share/doc/iproute2-2.4.7/LEEME.decnet.gz
/usr/share/doc/iproute2-2.4.7/examples/diffserv/LEEME.gz
/usr/share/doc/pilot-link-0.9.6-r2/LEEME.gz
/usr/share/doc/gnome-pilot-conduits-0.8/LEEME.gz
/usr/share/doc/gimp-1.2.2/LEEME.i18n.gz
/usr/share/doc/gimp-1.2.2/LEEME.win32.gz
/usr/share/doc/gimp-1.2.2/LEEME.gz
/usr/share/doc/gimp-1.2.2/LEEME.perl.gz
[578 líneas adicionales omitidas]

Ignorando distinción entre mayúsculas y minúsculas con find

Por supuesto, puede querer ignorar la distinción entre mayúsculas y minúsculas en su búsqueda:

$ find /usr/share/doc -name '[Ll][Ee][Ee][Mm][Ee]*'

O, más simple:

$ find /usr/share/doc -iname leeme\*

Como puede ver, -iname realiza una búsqueda insensible a la distinción entre mayúsculas y minúsculas.

find y expresiones regulares

Si está familiarizado con expresiones regulares, puede utilizar la opción-regex para limitar los resultados a los nombres de archivos que coincidan con un patrón. Y similar a la opción -iname, existe un opción correspondiente -iregex que ignora la distinción entre mayúsculas y minúsculas en un patrón. Por ejemplo:

$ find /etc -iregex '.*xt.*'
/etc/X11/xkb/types/extra
/etc/X11/xkb/semantics/xtest
/etc/X11/xkb/compat/xtest
/etc/X11/app-defaults/XTerm
/etc/X11/app-defaults/XTerm-color

Tenga en cuenta que find a diferencia de muchos programas, requiere que la expresión regular especificada coincida con la ruta completa, no solo una parte de ella. Por esa razón, es necesario especificar el .* anterior y posterior; con simplemente xt como expresión regular no sería suficiente.

find y tipos

La opción -type le permite encontrar objetos del sistema de archivos de un cierto tipo. Los argumentos posibles para -type son b (dispositivo de bloques), c (dispositivo de caracteres), d (directorio), p (tubería con nombre), f (archivo regular), l (enlace simbólico), y s (socket). Por ejemplo, para buscar archivos simbólicos en /usr/bin que contengan la cadena vim:

$ find /usr/bin -name '*vim*' -type l
/usr/bin/rvim
/usr/bin/vimdiff
/usr/bin/gvimdiff

find y mtimes (tiempo de la última modificación)

La opción -mtime le permite seleccionar archivos basada en el tiempo de su última modificación. El argumento para mtime está dado en periodos de 24 horas, y es más útil cuando se utiliza un signo más (que significa "después") o un signo menos (que significa "antes". Por ejemplo, consideremos el siguiente escenario:

$ ls -l ?
-rw-------    1 root     root            0 Jan  7 18:00 a
-rw-------    1 root     root            0 Jan  6 18:00 b
-rw-------    1 root     root            0 Jan  5 18:00 c
-rw-------    1 root     root            0 Jan  4 18:00 d
$ date
Mon May  7 18:14:52 EST 2003

Puede buscar archivos que hayan sido creados en las últimas 24 horas:

$ find . -name \? -mtime -1
./a

O puede buscar archivos que hayan sido creados antes del actual periodo de 24 horas:

$ find . -name \? -mtime +0
./b
./c
./d

La opción -daystart

Si adicionalmente especifica la opción -daystart, entonces los periodos de tiempo inician al comienzo del día actual en lugar de 24 horas atrás. Por ejemplo, aquí se muestra un conjunto de archivos creados ayer y anteayer.

$ find . -name \? -daystart -mtime +0 -mtime -3
./b
./c
$ ls -l b c
-rw-------    1 root     root            0 May  6 18:00 b
-rw-------    1 root     root            0 May  5 18:00 c

La opción -size

La opción -size le permite buscar archivos basados en su tamaño. De forma predeterminada el argumento de -size es de bloques de 512 bytes, pero agregando un sufijo puede ser más sencillo. Los sufijos disponibles son b (bloques de 512 bytes), c (bytes), k (kilobytes), y w (palabras de 2 bytes). Además, puede anteponer un signo más ("mayor que") o un signo menos ("menor que").

Por ejemplo para buscar archivos regulares en /usr/bin que son más pequeños que 50 bytes:

$ find /usr/bin -type f -size -50c
/usr/bin/krdb
/usr/bin/run-nautilus
/usr/bin/sgmlwhich
/usr/bin/muttbug

Procesamiento de los archivos encontrados

¡Tal vez se esté preguntando qué puede hacer con todos los archivos que ha encontrado! Bueno, find tiene la habilidad de actuar sobre los archivos que encuentra usando la opción -exec. Esta opción acepta una línea de comandos para ejecutarse como su argumento, terminado con ;, y reemplaza cualquier ocurrencia de {} con el nombre del archivo. Esto se entiende mejor con un ejemplo:

$ find /usr/bin -type f -size -50c -exec ls -l '{}' ';'
-rwxr-xr-x    1 root     root    27 Oct 28 07:13    /usr/bin/krdb
-rwxr-xr-x    1 root     root    35 Nov 28 18:26    /usr/bin/run-nautilus
-rwxr-xr-x    1 root     root    25 Oct 21 17:51    /usr/bin/sgmlwhich
-rwxr-xr-x    1 root     root    26 Sep 26 08:00    /usr/bin/muttbug

Como puede ver, find es una orden muy poderosa. Ha crecido a través de los años de UNIX y el desarrollo de Linux. Hay muchas más opciones útiles para realizar búsquedas. Puede aprender más acerca de ellas en la página del manual find.

locate

Hemos cubierto which, whereis, y find. Tal vez haya notado que find puede tomar un tiempo en ejecutarse, ya que necesita leer cada directorio que está buscando. Resulta entonces que la orden locate puede acelerar las cosas apoyándose en una base de datos externa generada por updatedb (la cual trataremos en el siguiente panel).

La orden locate puede encontrar una coincidencia con cualquier parte del nombre de la ruta, no solo con el nombre del archivo. Por ejemplo:

$ locate bin/ls
/var/ftp/bin/ls
/bin/ls
/sbin/lsmod
/sbin/lspci
/usr/bin/lsattr
/usr/bin/lspgpot
/usr/sbin/lsof

Uso de updatedb

La mayoría de los sistemas Linux tiene un "trabajo programado" para actualizar la base de datos periódicamente. Si su locate devuelve un error como el siguiente, entonces debe ejecutar como usuario root updatedb para generar la base de datos de búsqueda:

$ locate bin/ls
locate: /var/spool/locate/locatedb: No such file or directory
$ su -
Password:
# updatedb

La orden updatedb puede tomar mucho tiempo en ejecutarse. Si tiene un disco duro ruidoso, escuchará una gran cantidad de ruidos mientras que el sistema de archivos entero es indexado. :)

mlocate

En muchas distribuciones Linux, la orden locate ha sido reemplazada por mlocate. Normalmente existe un enlace simbólico a locate, de modo que no es necesario recordar cual tiene. mlocate viene de "localización segura". Almacena información de permisos en la base de datos de manera que los usuarios normales no pueden inmiscuirse en directorios que, de algún otro modo, serían incapaces de leer. El uso de la información para mlocate es esencialmente la misma que para locate, aunque la salida puede ser diferente dependiendo del usuario que ejecuta los comandos.

4.  Control de procesos

Iniciando xeyes

Para aprender acerca de control de procesos, primero tenemos que iniciar un proceso. Asegúrese que está utilizando X y ejecute la siguiente orden:

$ xeyes -center red

Habrá notado que una ventana xeyes apareció, y que los globos oculares rojos siguen su ratón por la pantalla. Además habrá notado que no tiene un nuevo prompt en su terminal.

Deteniendo un proceso

Para tener de nuevo el prompt, puede teclear Control-C (a menudo escrito como Crtl-C o ^C):

De nuevo tiene un prompt bash, pero la ventana xeyes desapareció. De hecho el proceso entero fue terminado. En lugar de terminarlo con Control-C, podemos solamente detenerlo con Control-Z:

$ xeyes -center red
Control-Z
[1]+  Stopped                 xeyes -center red
$

En este momento tiene un nuevo prompt bash, y la ventana xeyes se mantiene arriba. Sin embargo, si juega un poco con ella, notará que los globos oculares están estáticos. Si la ventana xeyes es cubierta por otra ventana y después descubierta de nuevo, notará que ni siquiera se han redibujado lo ojos. El proceso no está haciendo nada. De hecho, está "Detenido".

fg y bg

Para tener el proceso "no-detenido" y ejecutándose nuevamente, podemos traerlo al primer plano con el bash incorporado fg:

$ fg
(pruébelo, luego detenga el proceso de nuevo)
Control-Z
[1]+  Stopped                 xeyes -center red
$

Ahora continúelo en el segundo plano con el bash incorporado bg:

$ bg
[1]+ xeyes -center red &
$

¡Muy bien! El proceso xeyes está ahora ejecutándose en el segundo plano, y tenemos de nuevo, un prompt bash trabajando.

Uso de "&"

Si deseamos iniciar xeyes en segundo plano dese el inicio (en lugar de usar Control-Z y bg), podemos agregar un "&" (signo &) al final de xeyes en la línea de comando:

$ xeyes -center blue &
[2] 16224

Múltiples procesos en segundo plano

Ahora tenemos xeyes rojos y azules ambos ejecutándose en segundo plano. Podemos listar estos trabajos con el bash incorporado jobs:

$ jobs -l
[1]- 16217 Running                 xeyes -center red &
[2]+ 16224 Running                 xeyes -center blue &

Los números en la columna izquierda son los números asignados por bash cuando fueron iniciados. El trabajo 2 tiene un + (más) para indicar que este es el "trabajo actual", lo cual significa que escribiendo fg lo traeremos al primer plano. Puede también traer a primer plano un trabajo especificando su número; por ejemplo fg hará a xeyes rojos la tarea de primer plano. La siguiente columna es el identificador de proceso o pid, incluido en la lista cortesía de la opción -l de jobs. Finalmente, ambos trabajos estan actualmente "ejecutándose", y sus líneas de comando son mencionadas a la derecha.

Introducción a señales

Para terminar, detener o continuar procesos, Linux usa una forma especial de comunicación llamada "señales". Enviando cierto tipo de señal a un proceso, puede terminarlo, detenerlo, o hacer otras cosas. Esto es lo que en realidad hace cuando escribe Control-C, Control-Z o utiliza los incorporados bg o fg -- está usando bash para enviar una señal en particular a el proceso. Estas señales pueden ser enviadas también usando la orden kill y especificando el pid (identificador de proceso) en la línea de comandos:

$ kill -s SIGSTOP 16224
$ jobs -l
[1]- 16217 Running                 xeyes -center red &
[2]+ 16224 Stopped (signal)        xeyes -center blue

Como puede ver, kill no necesariamente "mata" un proceso, aunque puede. Usando la opción "-s", kill puede enviar cualquier señal a un proceso. Linux termina, detiene o continúa procesos cuando son enviadas las señales SIGINT, SIGSTOP, o SIGCONT respectivamente. También existen otras señales que puede enviar a un proceso; algunas de estas señales pueden ser interpretadas de un modo dependiente de la aplicación. Puede aprender que señales reconoce un proceso en particular mirando la página del manual y buscando la sección SIGNALS.

SIGTERM y SIGINT

Si desea terminar un proceso, tiene muchas opciones. De manera predeterminada, kill envía SIGTERM, que no es idéntico al famoso SIGINT de Control-C, pero usualmente tiene los mismos resultados:

$ kill 16217
$ jobs -l
[1]- 16217 Terminated              xeyes -center red
[2]+ 16224 Stopped (signal)        xeyes -center blue

El gran kill

Los procesos pueden ignorar tanto SIGTERM como SIGINT, ya sea por elección o porque están detenidos o de alguna manera "atascados". En estos casos puede ser necesario utilizar artillería pesada, la señal SIGKILL. Un proceso no puede ignorar SIGKILL:

$ kill 16224
$ jobs -l
[2]+ 16224 Stopped (signal)        xeyes -center blue
$ kill -s SIGKILL
$ jobs -l
[2]+ 16224 Interrupt               xeyes -center blue

nohup

La terminal donde inicia un trabajo es llamada la terminal controladora del trabajo. Algunas interfaces de comandos (no bash por omisión), enviarán una señal SIGHUP para enviar a segundo plano trabajos cuando cierre sesión, ocasionando que terminen. Para proteger procesos de este comportamiento, use nohup cuando inicie un proceso:

$ nohup make &
[1] 15632
$ exit

Uso de ps para listar procesos

La orden jobs que usamos anteriormente solo lista los procesos que fueron iniciados desde su sesión de bash. Para ver todos los procesos de su sistema, use ps con las opciones a y x juntas:

$ ps ax
  PID TTY      STAT   TIME COMMAND
    1 ?        S      0:04 init [3]
    2 ?        SW     0:11 [keventd]
    3 ?        SWN    0:13 [ksoftirqd_CPU0]
    4 ?        SW     2:33 [kswapd]
    5 ?        SW     0:00 [bdflush]

Solo fueron listados los primeros porque usualmente es una lista muy larga. Esto le da una idea rápida de que está haciendo la máquina, pero es mucha información para filtrar. Si deja fuera a ax, solo verá los procesos que le pertenecen, y que tienen su control en una terminal. La orden ps x le mostrará todos los procesos, incluso aquellos que no son controlados por una terminal. Si usa ps a, obtendrá una lista de todos los procesos que están unidos a una terminal.

Mirando el bosque y los árboles

Puede además listar información diferente acerca de cada proceso. La opción --forest hace más fácil ver la jerarquía del proceso, la cual le da una indicación de como se interrelacionan los diversos procesos en su sistema. Cuando un proceso inicia un nuevo proceso, el nuevo proceso es llamado proceso "hijo". En un listado de --forest , los padres aparecen en la izquierda y los hijos aparecen como ramas del lado derecho:

$ ps x --forest
  PID TTY      STAT   TIME COMMAND
  927 pts/1    S      0:00 bash
 6690 pts/1    S      0:00  \_ bash
26909 pts/1    R      0:00      \_ ps x --forest
19930 pts/4    S      0:01 bash
25740 pts/4    S      0:04  \_ vi processes.txt

Las opciones "u" y "l" de ps

Las opciones u y l pueden ser agregadas a la combinación de a y x con el objetivo de incluir más información acerca de cada proceso:

$ ps au
USER       PID %CPU %MEM   VSZ  RSS TTY   STAT START  TIME  COMMAND
agriffis   403  0.0  0.0  2484   72 tty1  S     2001  0:00  -bash
chouser    404  0.0  0.0  2508   92 tty2  S     2001  0:00  -bash
root       408  0.0  0.0  1308  248 tty6  S     2001  0:00  /sbin/agetty 3
agriffis   434  0.0  0.0  1008    4 tty1  S     2001  0:00  /bin/sh/usr/X
chouser    927  0.0  0.0  2540   96 pts/1 S     2001  0:00  bash

$ ps al
  F   UID  PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY    TIME  COMMAND
100  1001  403     1   9   0  2484   72 wait4  S    tty1   0:00  -bash
100  1000  404     1   9   0  2508   92 wait4  S    tty2   0:00  -bash
000     0  408     1   9   0  1308  248 read_c S    tty6   0:00   /sbin/ag
000  1001  434   403   9   0  1008    4 wait4  S    tty1   0:00   /bin/sh
000  1000  927   652   9   0  2540   96 wait4  S    pts/1  0:00   bash

Usando top

Si se encuentra ejecutando ps varias veces en fila, intentando ver cambios, lo que probablemente quiera es top. top despliega continuamente una lista actualizada de procesos, junto con un resumen de información útil:

$ top
 10:02pm  up 19 days,  6:24,  8 users,  load average: 0.04, 0.05, 0.00
75 processes: 74 sleeping, 1 running, 0 zombie, 0 stopped
CPU states:  1.3% user,  2.5% system,  0.0% nice, 96.0% idle
Mem:   256020K av,  226580K used,  29440K free, 0K shrd,  3804K buff
Swap:  136544K av,   80256K used,  56288K free            101760K
cached

  PID USER    PRI NI  SIZE  RSS SHARE STAT LIB %CPU %MEM  TIME  COMMAND
  628 root     16  0  213M  31M  2304 S      0  1.9 12.5  91:43 X
26934 chouser  17  0  1272 1272  1076 R      0  1.1  0.4   0:00 top
  652 chouser  11  0 12016 8840  1604 S      0  0.5  3.4   3:52 gnome-termin
  641 chouser   9  0  2936 2808  1416 S      0  0.1  1.0   2:13 sawfish

nice

Cada proceso tiene una definición de prioridades que Linux utiliza para determinar cómo son compartidas las porciones de tiempo del CPU. Puede fijar la prioridad de un proceso iniciándolo con la orden nice:

$ nice -n 10 oggenc /tmp/song.wav

Dado que la definición de prioridad es llamada nice, debe ser sencillo recordar que un valor mayor será mejor que otros procesos, lo que les permite tener prioridad para acceder al CPU. De forma predeterminada, los procesos inician con un valor de 0, por lo que el darles un valor de 10 significa que oggenc le dará facilidad a otros procesos en el CPU. En general, esto significa que oggenc le permitirá a otros procesos funcionar a su velocidad normal, independientemente de cómo sea el hambre de CPU de oggenc. Puede ver los niveles mejorados en la columna NI en el ps y top listados arriba.

renice

La orden nice solo puede cambiar la prioridad de un proceso cuando este se inicia. Si desea cambiar la definición de prioridad de un proceso que está en ejecución, use renice:

$ ps l 641
  F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY   TIME COMMAND
000  1000   641     1   9   0  5876 2808 do_sel S    ?     2:14 sawfish
$ renice 10 641
641: old priority 0, new priority 10
$ ps l 641
  F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY   TIME COMMAND
000  1000   641     1   9  10  5876 2808 do_sel S    ?     2:14 sawfish

5.  Procesamiento de texto

Redirección revisada

Anteriormente en esta serie de tutoriales, vimos un ejemplo de cómo usar el operador > para redireccionar la salida de una orden a un archivo, como se muestra a continuación:

$ echo "primerarchivo" > copiame

Además de redirigir una salida a un archivo, podemos tomar ventaja de una poderosa característica de la interfaz de comandos llamada tuberías. Con el uso de tuberías podemos pasar la salida de una orden a la entrada de otra orden. Considere el siguiente ejemplo:

$ echo "hola" | wc
     1       2       9

El carácter | es usado para conectar la salida de la orden de la izquierda a la entrada de la orden de la derecha. En el ejemplo de arriba, la orden echo imprime la cadena "hola" seguido de un salto de línea. Esta salida normalmente aparecería en la terminal, pero el tubo lo redirecciona a la orden wc, la cual despliega el número de líneas, palabras y caracteres de su entrada.

Un ejemplo de tubería

Aquí está otro ejemplo simple:

$ ls -s | sort -n

En este caso, ls -s normalmente imprimiría una lista del directorio actual en la terminal, con cada archivo precedido por su tamaño. Pero en su lugar enviamos por la tubería la salida a sort -n, el cual ordena la salida numéricamente. ¡Esto es una manera realmente útil de encontrar archivos grandes en su directorio home!

Los siguientes ejemplos son más complejos, pero demuestran el poder que puede ser aprovechado usando tuberías. Vamos a utilizar algunas órdenes que no hemos cubierto aun, pero no deje que eso lo haga más lento. Concéntrese en entender cómo funcionan las tuberías, así podrá emplearlas en sus tareas Linux cotidianas.

La tubería de descompresión

Normalmente para descomprimir y desempaquetar un archivo, puede hacer los siguiente:

$ bzip2 -d linux-2.4.16.tar.bz2
$ tar xvf linux-2.4.16.tar

La desventaja de este método es que requiere de la creación de un archivo intermediario y descomprimido en su disco. Dado que tar tiene la habilidad de leer directamente desde su entrada (en lugar de especificar un archivo), podemos producir el mismo resultado usando una tubería:

$ bzip2 -dc linux-2.4.16.tar.bz2 | tar xvf -

¡Hurra! Nuestro archivo tar comprimido se ha extraído y no hemos necesitado de un archivo intermedio.

Una tubería más larga

Aquí está otro ejemplo de tubería:

$ cat miarchivo.txt | sort | uniq | wc -l

Usamos cat para enviar el contenido de miarchivo.txt a la orden sort. Cuando la orden sort recibe la entrada, ordena todas las líneas para que estén en orden alfabético, y envía la salida a uniq. uniq elimina cualquier línea duplicada (por cierto, requiere que la entrada esté ordenada) enviando la salida que ya ha sido borrada a wc -l. Hemos visto la orden wc anteriormente, pero sin las opciones de la línea de comando. Cuando se da la opción -l, solamente imprime el número de líneas en su entrada, en lugar de incluir también palabras y caracteres. Como puede ver esta tubería imprime el número líneas únicas (no idénticas) en un archivo de texto.

Trate de crear un par de archivos de prueba con su editor de texto favorito y utilice esta tubería para ver qué resultados obtiene.

El curso exprés de procesamiento de texto comienza

Ahora nos embarcamos en un viaje relámpago a las órdenes estándar Linux de procesamiento de texto. Debido a que estamos cubriendo mucho material en este tutorial, no tenemos el espacio para dar ejemplos de cada orden. En cambio, lo animamos para que lea cada página del manual de las ordenes (escribiendo man echo, por ejemplo) y aprenda cada orden y como trabajan sus opciones jugando un rato con cada una. Como regla, estas órdenes imprimen los resultados de cualquier procesamiento a una terminal en vez de modificar algún archivo. Después de haber tomado nuestro un viaje relámpago a las órdenes estándar Linux de procesamiento de texto, veremos más de cerca la redirección de la salida y entrada. Así que sí, hay una luz al final del túnel :).

echo imprime sus argumentos a la terminal. Use la opción -e si quiere integrar secuencias de escape con la barra invertida; por ejemplo echo -e "foo\nfoo" imprimirá foo, luego un salto de línea y después foo otra vez. Use la opción -n para decirle a echo que omita el salto de línea final que es anexado a la salida por defecto.

cat imprimirá en la terminal el contenido de los archivos especificados como argumentos. Es útil como primer comando de una tubería, por ejemplo, cat foo.txt | bla.

sort imprimirá el contenido de un archivo especificado en la línea de comandos en orden alfabético. Por supuesto, sort también acepta entradas desde una tubería. Escriba man sort para familiarizarse con las diversas opciones que controlan la conducta del ordenamiento.

uniq toma un archivo ya ordenado o una secuencia de datos (a través de una tubería) y elimina las líneas duplicadas.

wc imprime el número de líneas, palabras y bytes en un archivo determinado o en la secuencia de entrada (de una tubería). Escriba man wc para aprender como ajustar los resultados que son desplegados.

head imprime las primeras diez líneas de un archivo o una secuencia. Use la opción -n para especificar cuantas líneas se desea mostrar.

tail imprime las últimas diez líneas de un archivo o secuencia. Use la opción -n para especificar cuantas líneas se desea mostrar.

tac es como cat, pero imprime todas las líneas en orden inverso; en otras palabras, la última línea se imprime primero.

expand convierte las tabulaciones en espacios. Use la opción -t para especificar la posición del tabulador.

unexpand convierte los espacios de entrada en tabulaciones. Use la opción -t para especificar la posición del tabulador.

cut es usado para extraer campos delimitados por caracteres de cada línea de un archivo de entrada o secuencia.

La orden nl agrega una número a cada línea de entrada. Útil para impresiones.

pr es usado para romper archivos en varias páginas de salida; normalmente es usado para impresión.

tr es una herramienta de traducción de caracteres; es usada para asignar a ciertos caracteres de la secuencia de entrada otros caracteres en la secuencia de salida.

sed es un poderoso editor de texto orientado a secuencias. Puede aprender más acerca de sed en los siguientes artículos de IBM developerWorks:

• Sed mediante ejemplos, Parte 1
• Sed mediante ejemplos, Parte 2
• Sed mediante ejemplos, Parte 3

Si está planeando tomar el examen LPI, asegúrese de leer los primeros dos artículos de esta serie.

awk es un lenguaje práctico de procesamiento de texto. Para aprender más acerca de awk, lea los siguientes artículos de IBM developerWorks:

• Awk mediante ejemplos, Parte 1
• Awk mediante ejemplos, Parte 2
• Awk mediante ejemplos, Parte 3

od está diseñado para transformar una secuencia de entrada en un formato octal o hexadecimal "volcado".

split es una orden utilizada para dividir un archivo grande en pedazos más pequeños y más manejables.

fmt dará formato a párrafos para que estos se ajusten al margen. Hoy en día es menos útil, ya que esta habilidad la poseen la mayoría de los editores de texto, pero aún así es bueno saber.

paste toma dos o más archivos como entrada, concatena cada línea secuencial de los archivos de entrada, e imprime las líneas resultantes. Puede ser útil para crear tablas o columnas de texto.

join es similar a paste, pero utiliza un campo (el primero de modo predeterminado) en cada línea para que coincida lo que debe combinarse en una sola línea.

tee imprime su entrada tanto en un archivo como en la pantalla. Esto es útil cuando quiera crear un registro de algo, pero además quiere verlo en pantalla.

¡El curso exprés termina!. Redirección

Similar a usar > en la línea de comando de bash, puede usar para redireccionar un archivo a una orden. Para muchas órdenes, puede simplemente especificar el nombre de archivo en la línea de comando, sin embargo algunas órdenes solo funcionan desde la entrada estándar.

Bash y otros intérpretes de comando respaldan el concepto de un "archivoaquí". Esto le permite especificar la entrada de una orden en las líneas siguientes a la invocación de la orden, terminándola con un valor especial. Es más fácil mediante un ejemplo:

$ sort <<END
manzana
arándano
plátano
END
arándano
manzana
plátano

En el ejemplo de arriba, escribimos las palabras manzana, arándano y plátano seguidos por "END" lo que significa el fin de la entrada. El programa sort regresa nuestras palabras ordenadas alfabéticamente.

Uso de >>

Tal vez esperaría que >> fuera de alguna manera análogo a <<, pero en realidad no lo es. Significa simplemente agregar la salida a un archivo, en lugar de sobreescribir como > lo haría. Por ejemplo:

$ echo Hola > miarchivo
$ echo allá. > miarchivo
$ cat miarchivo
allá.

¡Uy! ¡Perdimos la porción "Hola"! Lo que queríamos decir era esto:

$ echo Hola > miarchivo
$ echo allá. >> miarchivo
$ cat miarchivo
Hola
allá.

¡Mucho mejor!

6.  Módulos del núcleo

Conozca "uname"

La orden uname le provee una variedad de información interesante acerca de su sistema. Aquí está lo que se despliega en mi estación de desarrollo cuando tecleo uname -a el cual le dice a la orden uname que imprima toda la información de una sola vez:

$ uname -a
Linux inventor 2.4.20-gaming-r1 #1 Fri Apr 11 18:33:35 MDT 2003 i686
AMD Athlon(tm) XP 2100+ AuthenticAMD GNU/Linux

Más locura uname

Ahora, veamos la información que provee uname:

info. opción                   arg     ejemplo
nombre de núcleo               -s      "Linux"
nombre del anfitrión           -n      "inventor"
revisión del núcleo            -r      "2.4.20-gaming-r1"
versión de núcleo              -v      "#1 Fri Apr 11 18:33:35 MDT 2003"
máquina                        -m      "i686"
procesador                     -p      "AMD Athlon(tm) XP 2100+"
plataforma de hardware         -i      "AuthenticAMD"
sistema operativo              -o      "GNU/Linux"

¡Intrigante! ¿Qué imprime la salida de su orden uname -a?

La revisión del núcleo

He aquí un truco de magia. Primero, escriba uname -r para que la orden uname imprima la revisión del núcleo Linux que se está ejecutando actualmente.

Ahora, mire en el directorio /lib/modules y, ¡presto! ¡Apuesto que encontrará un directorio con el mismo nombre! Está bien, no es tan mágico, pero ahora es un buen momento para hablar del significado de los directorios en /lib/modules y explicar que son los módulos.

El núcleo

El núcleo Linux es el corazón de lo que comúnmente llamamos "Linux" -- es la pieza de código que accede a su hardware directamente y provee abstracciones para que los programas regulares antiguos puedan ejecutarse. Gracias al núcleo, su editor de texto no necesita preocuparse acerca de si está escribiendo en un disco SCSI o IDE -- o incluso en un disco RAM. Simplemente escribe a un archivo de sistema, y el núcleo se encarga del resto.

Introducción a los módulos del núcleo

Entonces, ¿qué son los módulos del núcleo? Bueno, son partes del núcleo que han sido almacenadas en el disco con un formato especial. A su orden, podrán ser cargados en el núcleo en ejecución y proveer funcionalidades adicionales.

Debido a que los módulos del núcleo son cargados a demanda, puede tener en su núcleo soporte para una gran cantidad de funciones adicionales que normalmente no quiere tener habilitadas. Pero en alguna rara ocasión, aquellos módulos del núcleo pueden sernos útiles y pueden cargarse -- a menudo de manera automática -- para apoyar ese raro sistema de archivos o dispositivo que raramente usa.

Módulos del núcleo en pocas palabras

En resumen, los módulos del núcleo le permiten al núcleo en ejecución habilitar capacidades en base a la demanda. Sin los módulos del núcleo, tendría que compilar un nuevo núcleo completo y reiniciar para tener el apoyo de las nuevas características.

lsmod

Para ver cuales módulos están cargados actualmente en su sistema, use la orden lsmod:

# lsmod
Module                  Size  Used by    Tainted: PF
vmnet                  20520   5
vmmon                  22484  11
nvidia               1547648  10
mousedev                3860   2
hid                    16772   0  (unused)
usbmouse                1848   0  (unused)
input                   3136   0  [mousedev hid usbmouse]
usb-ohci               15976   0  (unused)
ehci-hcd               13288   0  (unused)
emu10k1                64264   2
ac97_codec              9000   0  [emu10k1]
sound                  51508   0  [emu10k1]
usbcore                55168   1  [hid usbmouse usb-ohci ehci-hcd]

Listado de módulos

Como puede ver, mi sistema tiene unos cuantos módulos cargados. Los módulos vmnet y vmmon proveen la funcionalidad necesaria para mi programa VMWare, el cual me permite ejecutar una PC virtual en una ventana del escritorio. El módulo de "nvidia" viene de la corporación NVIDIA la cual me permite utilizar mi tarjeta de gráficos de gran desempeño con aceleración para 3D bajo Linux al tiempo que toma ventaja de sus características.

Además tengo un montón de módulos usados para darle respaldo a mis dispositivos de entrada basados en USB --llamados "mousedev", "hid", "usbmouse", "input", "usb-ohci", "ehci-hcd" y "usbcore." Algunas veces tiene sentido configurar su núcleo para darle soporte al USB en forma de módulos. ¿Por qué? Porque los dispositivos USB son del tipo "conecta y usa" y cuando tiene el respaldo USB como módulo, entonces puede ir a comprar un nuevo dispositivo USB, conectarlo a su sistema, y que el sistema cargue automáticamente los módulos apropiados para habilitar ese dispositivo. Es práctico hacer las cosas de esta manera.

Módulos de terceras partes

Para completar mi lista de módulos están "emu10k1", "ac97_codec" y "sound", que juntos proveen soporte para mi tarjeta de sonido SoundBlaster Audigy.

Cabe señalar que algunos de mis módulos de núcleo provienen de las fuentes del núcleo mismo. Por ejemplo, todos los módulos relacionados al USB son compilados desde las fuentes del núcleo estándar de Linux. Sin embargo, el nvidia, emul10k1 y los relacionados a VMWare, provienen de otras fuentes. Esto resalta otra ventaja importante de los módulos del núcleo -- permiten a terceras partes proveer funcionalidades necesarias al núcleo y además permiten la funcionalidad de "conectarse" a un núcleo Linux que se encuentra ejecutándose. No es necesario reiniciar el sistema.

depmod y amigos

En el directorio /lib/modules/2.4.20-gaming-r1/, tengo un número de archivos que inician con la cadena "modules.":

$ ls /lib/modules/2.4.20-gaming-r1/modules.*
/lib/modules/2.4.20-gaming-r1/modules.dep
/lib/modules/2.4.20-gaming-r1/modules.generic_string
/lib/modules/2.4.20-gaming-r1/modules.ieee1394map
/lib/modules/2.4.20-gaming-r1/modules.isapnpmap
/lib/modules/2.4.20-gaming-r1/modules.parportmap
/lib/modules/2.4.20-gaming-r1/modules.pcimap
/lib/modules/2.4.20-gaming-r1/modules.pnpbiosmap
/lib/modules/2.4.20-gaming-r1/modules.usbmap

Estos archivos contienen algunas porciones de información de dependencias. Por un lado, registran la información de *dependencia* para módulos -- algunos módulos requieren que otros módulos sean cargados antes de ejecutarse. Esta información es almacenada en estos archivos.

¿Cómo obtener módulos?

Algunos módulos del núcleo están diseñados para trabajar con dispositivos específicos de hardware, como mi módulo "emuk10k1", el cual es para mi tarjeta SoundBlaster Audigy. Para ese tipo de módulos, existen archivos que además graban los identificadores PCI y marcas de identificación de los dispositivos de hardware que respaldan. Esta información puede ser utilizada para actividades como los guiones "conexión rápida" (de los cuales hablaremos en los siguientes tutoriales) para autodetectar hardware y cargar los módulos apropiados para respaldar dicho hardware de manera automática.

Uso de depmod

Si alguna vez ha instalado un módulo nuevo, la información de dependencia puede estar obsoleta. Para actualizarla simplemente teclee depmod -a. El programa depmod hará un análisis de todos los módulos en los directorios /lib/modules y actualizará la información de dependencias. Esto se logra analizando los archivos de módulos en /lib/modules y revisando lo que se le conoce como "símbolos" dentro de los módulos.

Localizando módulos del núcleo

Entonces, ¿qué apariencia tienen los módulos del núcleo?, Para los núcleos 2.4, los módulos son generalmente cualquier archivo del árbol /lib/modules que termine en ".o". Para ver todos los módulos en /lib/modules, escriba lo siguiente:

# find /lib/modules -name '*.o'
/lib/modules/2.4.20-gaming-r1/misc/vmmon.o
/lib/modules/2.4.20-gaming-r1/misc/vmnet.o
/lib/modules/2.4.20-gaming-r1/video/nvidia.o
/lib/modules/2.4.20-gaming-r1/kernel/fs/fat/fat.o
/lib/modules/2.4.20-gaming-r1/kernel/fs/vfat/vfat.o
/lib/modules/2.4.20-gaming-r1/kernel/fs/minix/minix.o
[lista truncada para hacerla más breve]

insmod vs. modprobe

Bien, ¿cómo se realiza la carga de un módulo en un núcleo en ejecución? Un modo es utilizar la orden insmod para especificar la ruta completa a el módulo que se desea cargar:

# insmod /lib/modules/2.4.20-gaming-r1/kernel/fs/fat/fat.o
# lsmod | grep fat
fat                    29272   0  (unused)

Sin embargo, normalmente las cargas de módulos se realizan usando la orden modprobe. Una de las cosas buenas acerca de la orden modprobe es que automáticamente se encarga de cargar módulos dependientes. Además, no es necesario especificar la ruta al módulo que desee cargar, ni especificar al final el ".o".

rmmod y modprobe en acción

Descarguemos nuestro módulo "fat.o" y carguémoslo de nuevo usando modprobe:

# rmmod fat
# lsmod | grep fat
# modprobe fat
# lsmod | grep fat
fat                    29272   0  (unused)

Como puede ver, la orden rmmod trabaja de manera similar a modprobe, pero tiene el efecto contrario: desactivar el módulo que le ha especificado.

Sus amigos modinfo y modules.conf

Puede utilizar la orden modinfo para aprender cosas interesantes acerca de sus módulos favoritos:

# modinfo fat
filename:    /lib/modules/2.4.20-gaming-r1/kernel/fs/fat/fat.o
description: <none>
author:      <none>
license:     "GPL"

Tome nota especial del archivo /etc/modules.conf. Este archivo contiene información de configuración para modprobe. Le permite ajustar la funcionalidad de modprobe mencionando cuales módulos debe ser cargados antes/después de cargar otros, ejecutar guiones antes/después de cargar módulos y más.

Aspectos relevantes de modules.conf

La sintaxis y funcionalidad de modules.conf es un poco complicada y no veremos su sintaxis ahora (teclee man modules.conf para ver todos los detalles), pero aquí están algunas cosas que *debería* saber acerca de este archivo.

Muchas distribuciones generan este archivo de manera automática a partir de un grupo de archivos en otro directorio, como /etc/modules.d/. Por ejemplo, Gentoo Linux tiene un directorio /etc/modules.d/, y al ejecutar la orden update-modules tomará cada archivo en /etc/modules.d/ y los concatenará para producir un nuevo /etc/modules.conf/. Por lo tanto, haga sus cambios a los archivos en /etc/modules.d/ y ejecute update-modules si está usando Gentoo. Si está usando Debian, el procedimiento es similar excepto que el directorio es llamado /etc/modutils/.

7.  Resumen y bibliografía

Resumen

¡Felicidades; ha alcanzado el final de este tutorial en administración Linux básica! Esperamos que le haya ayudado a reafirmar sus conocimientos fundamentales de Linux. Por favor, únase a nosotros en el siguiente tutorial que cubre administración intermedia donde, partiendo de los fundamentos vistos aquí, veremos temas como permisos de Linux y el modelo de propiedad, manejo de cuentas de usuario, creación y montaje de sistema de archivos y más. Y recuerde, continuando con esta serie de tutoriales, pronto estará listo para obtener su certificación LPIC Nivel 1 del Instituto Profesional Linux.

Bibliografía

Hablando de certificación LPIC, si es algo en lo que está interesado, entonces le recomendamos que estudie la siguiente bibliografía, la cual ha sido seleccionada cuidadosamente para aumentar el material cubierto en este tutorial:

Existe gran cantidad de buena bibliografía de expresiones regulares en Internet. Aquí hay dos que hemos encontrado:

• Regular Expressions Reference
• Regular Expressions Explained

Asegúrese de leer el Estándar de la jerarquía del sistema de archivos en http://www.pathname.com/fhs/.

En Bash con ejemplos, serie de artículos, le mostraré como usar programación de bash para crear sus propios guiones. Esta serie (particularmente parte uno y dos) le darán una buena preparación para el examen nivel 1 del LPIC:

Puede aprender más acerca de sed en los relevent IBM developerWorks articles. Si está planeando tomar el examen LPI, asegúrese de leer los dos primeros artículos de esta serie.

Para aprender más acerca de awk, lea relevent IBM developerWorks articles.

Es altamente recomendable revisar Technical FAQ for Linux users, un listado de 50 páginas que muestran la lista de preguntas más frecuentes de Linux con respuestas detalladas. El FAQ es un archivo formato PDF (Acrobat). Si es un usuario Linux principiante o intermedio, definitivamente debe revisar este FAQ.

Si no está familiarizado con el editor vi, es altamente recomendable que revise el tutorial Vi -- the cheat sheet method. Este tutorial le da una introducción rápida a este poderoso editor de texto. Considérelo como un material del tipo "debe leer" si no sabe cómo utilizar vi.