Manual medio
Linux nivel medio

1. EL gestor de arranque lilo

LILO (LInux LOader) es el sistema mas flexible y potente para arrancar linux. Seguramente ya lo tienes instalado en el sistema, si no es así buscalo en tu CD de Linux que seguro que esta.

Ejecución: simple, pulsa lilo y aparecerán una serie de nombres correspondientes a las etiquetas de los sistemas operativos que lilo va a ser capaz de arrancar, ademas pone un "*" en la etiqueta que arranca por defecto, por ejemplo en mi caso: 

[root:/]# lilo
Added linux *
Added 2.2.0
Added dos
Según esto, tengo un kernel "linux" (2.2.1) que se arranca por defecto, un kernel "2.2.0" como linux accesorio y una partición "dos".

Parámetros: se le pueden pasar un gran numero de parámetros para ver la configuración actual sin reescribir lilo (-q), dar mas información (-v), aun mas (-v -v), para ver lo que lilo va a hacer (-t), indicarle un archivo de configuración opcional (-C) ... Mas información en man lilo

Durante el arranque veremos algo como:

LILO boot:

 Tras lo cual deberemos poner alguna de las etiquetas de los kernels que lilo conoce o dejar que arranque el que tiene por defecto.

Opcionalmente se le pueden pasar parámetros para ayudar a detectar hardware, como RAM, IRQ, DMA, I/O ... por ejemplo:

LILO boot: mem=128M

 Fuerza a que linux reconozca 128 megas de RAM. O por ejemplo:

LILO boot: hd=64,32,202

 Para forzar la detección de los parámetros del disco duro, independientemente de lo que diga la BIOS.

Otras opciones son especificas para linux, como:

LILO boot: linux single

 Entra en linux en modo monousuario (para cuando olvidamos el password de root o para tareas de administracion/reparacion del sistema)

lilo.conf: Este es el archivo de configuración para lilo, esta en /etc y dentro se definen todas las opciones globales para lilo, así como los parámetros que le queremos pasar durante el arranque y se definen todos los sistemas operativos que gestiona lilo. Un ejemplo de lilo.conf seria: 

boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50

image=/boot/vmlinuz-2.2.1
        label=linux
        root=/dev/hda3
        read-only
image=/boot/vmlinuz-2.2.0
        label=2.2.0
        root=/dev/hda3
        read-only
other=/dev/hda1
        label=dos
        table=/dev/hda
Se pueden ver una serie de opciones globales, mas tres sistemas operativos con sus propias opciones. Mas información sobre las sintaxis de lilo.conf en man lilo.conf y una configuración real comentada en lilo.txt. Algo a tener en cuenta es que lilo arranca por defecto la primera imagen en lilo.conf, por lo que si quisieras arrancar la partición "dos" por defecto solo tendrías que poner las lineas que definen la partición "dos" (las tres ultimas) antes que la primera imagen de linux. Este comportamiento puede ser modificado con la linea:

default=label_del_sistema_a_arrancar_por_defecto
 
 

2. Programas para la red en modo texto

La mayoría de estos programas puedes encontrarlos en tu propio CD de linux o a través del servidor ftp de tu distribución.

El uso de estos programas en lugar de sus equivalentes gráficos tiene como resultado un aprovechamiento mucho mas eficiente de nuestros recursos locales (al no necesitar entorno gráfico) y de los recursos de la red (pues en general están mucho mas optimizados).
Sin embargo las desventajas son claras, nada de multimedia (al menos no tan fácil como en programas gráficos) y la dificultad inicial para los usuarios provenientes de sistemas operativos gráficos.

Personalmente creo que vale la pena usarlos, y si tenemos necesidad de un entorno gráfico siempre estamos a tiempo de lanzarlos desde una xterm o cualquier otro terminal X.

3. Cambiando el gestor de ventanas X

La gran cantidad de gestores de ventanas disponibles hacen que de tanto en tanto nos decidamos por cambiar el que tenemos o instalar dos o mas gestores y probar nuevas sensaciones.

La manera de hacerlo es sencilla, instalamos el nuevo gestor (en algunos casos puede ser necesario desinstalar el otro gestor de ventanas, aunque no es normal) y le indicamos a las X que usen el nuevo.

Para indicarselo se usa el archivo xinitrc. Existen dos topis de archivos xinitrc, uno (global) esta en /etc/X11/xinitrc/xinitrc (puede estar en otro directorio, pero siempre dentro de /etc) que se aplica a todos los usuarios; y el otro (particular) esta en ~/.xinitrc, este archivo, si existe, define un gestor de ventanas para el usuario propietario del HOME donde se encuentra, si no existe ~/.xinitrc se lee el global.

El formato del xinitrc (las dos versiones son iguales) es sencillo, aunque algunas distribuciones lo complican para conseguir mas opciones, gestores personalizados, arrancar programas en función del gestor usado ...
La sintaxis mas sencilla es:

#!/bin/bash
nombre_del_gestor

Donde nombre_del_gestor es el nombre del ejecutable del gestor de ventanas que queramos usar; por ejemplo: twm, fvwm, starkde ...
De esta manera para cambiar de gestor solo habrá que cambiar la linea correspondiente al nombre_del_gestor por la que queramos usar.

Este sencillo script puede complicarse mas y mas en función de las necesidades y preferencias de cada uno, el siguiente ejemplo arranca, si puede, KDE y si no puede arranca twm con un terminal y un reloj: 

#!/bin/bash
if [ /opt/kde/bin/startkde ]; then
        /opt/kde/bin/startkde
else
        xterm & 
        xclock & 
        twm 
fi
Como veis la cosa puede complicarse para mejorar la configuración y las posibilidades, como ejemplo aquí tenéis mi xinitrc original, a grandes rasgos define una serie de opciones globales, mas otras de usuario, ademas trata de encontrar el mejor gestor de ventanas posible y define un navegador HTML por defecto: 
#!/bin/sh
# $XConsortium: xinitrc.cpp,v 1.4 91/08/22 11:41:34 rws Exp $

userresources=$HOME/.Xresources
usermodmap=$HOME/.Xmodmap
sysresources=/usr/X11R6/lib/X11/xinit/.Xresources
sysmodmap=/usr/X11R6/lib/X11/xinit/.Xmodmap

# merge in defaults and keymaps

if [ -f $sysresources ]; then
    xrdb -merge $sysresources
fi

if [ -f $sysmodmap ]; then
    xmodmap $sysmodmap
fi

if [ -f $userresources ]; then
    xrdb -merge $userresources
fi

if [ -f $usermodmap ]; then
    xmodmap $usermodmap
fi

if [ -z "$BROWSER" ] ; then
        # we need to find a browser on this system
        BROWSER=hich netscape        if [ -z "$BROWSER" ] || [ ! -e
"$BROWSER" ] ; then
        # not found yet
                BROWSER=
        fi
fi
if [ -z "$BROWSER" ] ; then
        # we need to find a browser on this system
        BROWSER=hich lynx        if [ -z "$BROWSER" ] || [ ! -e "$BROWSER"
] ; then
        # not found yet
                BROWSER=
        else
                BROWSER="xterm -font 9x15 -e lynx"
        fi
fi
if [ -z "$BROWSER" ] ; then
        # we need to find a browser on this system
        BROWSER=hich arena        if [ -z "$BROWSER" ] || [ ! -e
"$BROWSER" ] ; then
        # not found yet
                BROWSER=
        fi
fi
export BROWSER

# start some nice programs

if [ -f $HOME/.Xclients ]; then
    exec $HOME/.Xclients
elif [ -f /etc/X11/xinit/Xclients ]; then
    exec /etc/X11/xinit/Xclients
else
       xclock -geometry 50x50-1+1 &
       xterm -geometry 80x50+494+51 &
       xterm -geometry 80x20+494-0 &
       if [ -f /usr/X11R6/bin/arena -a -f /usr/doc/HTML/index.html ]; then
               arena /usr/doc/HTML/index.html &
       fi
       if [ -f /usr/X11R6/bin/fvwm ]; then
               exec fvwm
       else
               exec twm
       fi
fi
4. Crear nuestros propios scripts

En el apartado anterior ya hemos visto mas o menos como son los scripts, vamos a analizarlos ahora con mas detalle.

Los scripts son archivos ejecutables que contienen grupos de instrucciones que el bash interpreta y ejecuta, no son compilados por lo que la velocidad no es su fuerte, aunque solo se usan para tareas sencillas en las que la velocidad no es limitante.

Requisitos: pocos, el archivo ha de ser ejecutable (chmod +x archivo) el nombre del archivo es indiferente, así como su extensión.
El segundo requisito es que el archivo debe empezar por una linea como esta:

#!/bin/bash

 Esta debe ser la primera linea, no pueden haber ni comentarios ni otras ordenes antes que ella.

Sintaxis: dentro de un script podemos usar todos los comandos reconocidos por bash (cd, ls, rm ...), mas todos los alias, mas todos los programas instalados, ademas se pueden usar pipes, redirecciones ...
Cada orden ira en una linea aunque también pueden separarse por ";" y las lineas que empiecen por "#" no serán leídas por bash (excepto la primera) y se usan para insertar comentarios.

Ejecutarlos: como seguramente el script no se encuentre en el PATH lo ejecutaremos como ./script si esta en el directorio actual, o /ruta_completa/script si esta en otro directorio.

Ejemplos:

El primer script: este es el típico programa "Hola mundo", como veréis es sencillísimo: 

#!/bin/bash

# Script Hola mundo                        
echo Hola mundo
Ademas de comandos normales, los scripts pueden usar variables, estructuras de control (if), bucles (while, until), estructuras iterativas (for) y otras. Para dominar el lenguaje de programación de scripts en bash os recomiendo que leáis el man bash o que sakeis algún buen manual de unix de alguna biblioteca publica.

Un sencillo script para conectarse a internet podría ser algo así: 

#!/bin/bash

# Script pppp-up
clear
echo Conectando ...
if [ pppd ]; then
        pppd
        tail -f /var/log/messages > /dev/tty12
        echo Mensajes de sistema en la consola 12
        echo (Pulsa Alt+F12 para verlos)
else
        echo No he podido encontrar pppd en tu sistema.
        echo Asegúrate que esta instalado y en el PATH
fi
El limite de los scripts solo esta en vuestro conocimiento en profundidad del bash y de la imaginación.

Algunos ejemplos útiles:

5. Compilar el kernel

Compilar el kernel es una de las primeras acciones que todo administrador debería hacer justo después de haber instalado el sistema y de haber creado un usuario.
aunque a primera vista pueda parecer algo complicado es un procedimiento muy sencillo y que nos permitirá optimizar el sistema eliminando componentes no usados y acceder a servicios hardware y software personalizados.

Pasos previos: lo primero es asegurarnos de que nuestro sistema esta preparado para compilar el kernel.
Necesitamos las fuentes del kernel (un archivo de mas de 7 megas que podemos encontrar en ftp.kernel.org) descomprimidas en el directorio /usr/src/linux.
Necesitaremos al rededor de 50 megas libres en el disco para que pueda hacerse la compilación.
Una vez conseguido y desempaquetado el kernel pasaremos a leer el archivo README, donde se explica con detenimiento las instrucciones para que todo salga bien.

Otros paquetes software que necesitaremos serán: libc-devel, gcc y make (para la compilación), bin86-utils (para la construcción del kernel), libncurses y libncurses-devel (solo si queremos menús para la selección de opciones), tcl/tk (solo si queremos ver los menús en una ventana X), lilo (si queremos usarlo para arrancar el kernel).

Tipos de compilación: aquí voy a explicar un poco el proceso general para la compilación del kernel.
Lo primero es seleccionar las opciones que queremos incluir en el kernel, esto se hace desde /usr/src/linux con uno de los siguientes comandos:

Las opciones a elegir dependerán de cada máquina y de las funciones que vaya a realizar, así como del hardware instalado, pulsando "?" en cada opción tenemos una breve explicación de su función, al final suele haber una recomendación para su uso, si esta ayuda no es suficiente las fuentes del kernel llevan abundante información en el directorio Documentación/

Una vez seleccionadas las opciones hay que realizar los siguientes comandos:

En este momento el kernel ya esta listo para empezar a compilarse, lo cual se hace con uno de los siguientes comandos: Nota: si el kernel es demasiado grande podemos reducir su tamaño colocando una "b" delante los targets de make, es decir, las ordenes quedarían: make bzImage, make bzdisk o make bzlilo.

Opcionalmente si hemos seleccionado el uso de módulos deberemos compilarlos con la orden make modules e instalarlos con la orden make modules_install

Un fallo muy común es el producido por módulos mal instalados, repetidos o no utilizados, para evitarlo asegúrate de eliminar (mejor mover a otro sitio) los módulos antiguos que se encuentran en el directorio /lib/modules.
También es conveniente hacer depmod -a después de haber instalado los nuevos módulos.

Pasos finales: si hemos hecho make zdisk o make zlilo y todo ha ido bien solo nos quda reiniciar la máquina para usar el nuevo kernel. Si hemos hecho make zImage (la opción mas recomendable) nos moveremos al directorio cd arch/i386/boot y copiaremos el archivo zImage (o bzImage, según el caso) al directorio donde tengamos los kernels (generalmente /boot o /, aunque esto es totalmente configurable), por ejemplo en mi caso están en /boot: 

[dani] [/]$ ls /boot
total 934
lrwxrwxrwx   1 root     root           17 Dec 28 21:33 System.map -> System.map-2.0.32
-rw-r--r--   1 root     root       104597 Nov 18  1997 System.map-2.0.32
-rw-r--r--   1 root     root          512 Dec 28 21:48 boot.0300
-rw-r--r--   1 root     root         4536 Oct 19  1997 boot.b
-rw-r--r--   1 root     root          300 Oct 19  1997 chain.b
-rw-------   1 root     root        15872 Feb 18 03:12 map
lrwxrwxrwx   1 root     root           18 Dec 28 21:33 module-info -> module-info-2.0.32
-rw-r--r--   1 root     root        11773 Nov 18  1997 module-info-2.0.32
-rw-r--r--   1 root     root          308 Oct 19  1997 os2_d.b
-rw-r--r--   1 root     root       403276 Jan 30 11:55 vmlinuz-2.2.1
-rw-r--r--   1 root     root       402114 Feb  6 14:54 vmlinuz-2.2.2
El ultimo paso es editar el archivo /etc/lilo.conf para asegurarnos de que apunta al nuevo kernel (ver el capitulo 1 si tenéis dudas), en mi caso: 
[dani] [/]$ cat /etc/lilo.conf
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50

image=/boot/vmlinuz-2.2.2
        label=linux
        root=/dev/hda3
        read-only
image=/boot/vmlinuz-2.2.1
        label=2.2.1
        root=/dev/hda3
        read-only
Nota: fijaos en que siempre es importante guardar una copia del anterior kernel, por si algo fallara poder arrancar con el.

Y ejecutar el comando /sbin/lilo para guardar los cambios, lilo informará de los cambios mas o menos así: 

[root] [/]$ /sbin/lilo
Added linux *
Added 2.2.1
Si lilo se keja aseguraos que los directorios y los nombres de archivo que aparecen en lilo.conf son correctos.

Solo nos quda reiniciar con la orden reboot para arrancar con el nuevo kernel.

Nota importante: Esto son unas instrucciones genericas, no os toméis al pie de la letra los nombres de archivo ni los directorios, pues pueden variar en cada caso. Este es un proceso critico para el sistema y hay que saber bien lo que se esta haciendo, una lectura obligada es el Kernel-como de LuCAS.

Si algo falla: algunos consejos, revisad que tenéis todo lo necesario, que el kernel esta bien descomprimido en /usr/src/linux, a veces es necesario el comando make mrproper (limpieza a fondo) justo después de descomprimirlo.
Procurad manteneros a la ultima en cuanto a versiones del kernel.
En el archivo Documentation/Changes hay una lista de los requerimientos software de cada kernel, aseguraos de cumplirlos.
Si aun así sigue fallando podría ser que las fuentes estuviesen corrompidas o que hayas encontrado un nuevo bug :-)

6. 


 


Volver a la pagina principal