La guía muy explicada para Actualizar y Compilar tu kernel en Debian

La
guía muy explicada para Actualizar y Compilar tu kernel en Debian

 
Por Clinton De Young
- Posteado el 2003-03-03 03:07:03
en OSNews
[http://www.osnews.com/]

Si estás
leyendo esto, asumo que ya conoces qué es kernel Linux [http://www.kernel.org/] y porqué tal vez quieras
actualizarlo. De cualquier manera, si accidentalmente estás
leyendo esto \'al paso\' y solo estás \'corriendo Linux\' y no
tienes idea de que es el kernel o por qué querrías
actualizarlo, los siguientes dos párrafos son para tí.
Si estás buscando una guía más general, y
orientada a cualquier distribución en general lee aquí [http://www.osnews.com/story.php?news_id=443].

En
lo que entiende un novato, el kernel de Linux es el cerebro del
sistema. Le dice a tu sistema cual sistema de archivo, hardware,
protocolos, etc. están soportados. Hay mucho más que
eso claro, pero esta breve descripción es suficiente por
ahora.

Introducción,
Descargando el kernel

AGRADECIMIENTOS
Antes
de comenzar, me gustaría agradecer sinceramente a toda la
gente que colaboró con feedback en mi artículo \"The
Very Verbose Debian 3.0 Installation Walkthrough\" (la traducción la pueden leer desde aquí.). Estoy agradecido por su comprensión,
correcciones y comentarios. También quisiera disculparme por
la tardanza de este artículo. Mi vida ha cambiado de rumbo
imprevistamente durante los últimos meses; estoy feliz de
sentirme de nuevo en marcha.

INTRODUCCIÓN Y
EXPECTATIVAS

¿Por qué querrías
meterte con el kernel? Bien, toda la gente (los que están un
paso por delante de los meros mortales y son mucho más
inteligentes que yo), que trabaja en el kernel Linux está
constantemente añadiendo soporte para nuevo hardware, nueva
tecnología, nuevos arreglos de bugs, y haciendo míriadas
de otras mejoras. Actualizando nuestro kernel, incrementamos las
capacidades y el soporte de nuestro sistema Linux. También, no
ha sido construída una computadora que utilice todo el
hardware y otras características soportadas por el kernel. En
consecuencia, por qué cargarlo de soporte para muchas cosas
que no necesitas y no tienes.

Con esta idea, intento
describir el proceso de actualizar y compilar un kernel Linux bajo
Debian. Intentaré explicar los pasos necesarios de manera de
disipar cualquier misterio y temor. Mi esperanza es que alguien nuevo
en Linux sea capaz de llegar hasta el final del proceso
confortablemente y terminar con un sistema actualizado.

A pesar de querer hacer
de este un proceso indoloro, uno puede fallar; algo que no puedo
tener es una descripción detallada de tu hardware o de las
cosas de las que quieres soporte. Así que estoy enfocándome
en tres de los tópicos más requeridos: sonido, sistema
de archivo journaling, y la posibilidad de grabar Cds. De cualquier
manera, siento que estoy dando demasiados detalles como para que
no tengas ningún problema con el resto del proceso de
configuración y al habilitar algunas cosas como USB.

Saber que hardware está
en tu sistema es absolutamente necesario si quieres optimizar tu
kernel específicamente para él. Por ejemplo, para
compilar soporte para tu placa de sonido, debes saber que tipo de
placa de sonido tienes. A menudo puedes hallar esta información
en los manuales que vienen con la computadora, también desde
del Administrador de Dispositivos de Windows (si lo usas), o desde el
sitio web del fabricante si compraste tu computadora de una compañía
como Gateway, HP o Dell.

Por favor no te
desalientes si no sabes que hardware tienes en tu máquina. Tal
vez no tengas suerte como para configurar el kernel para el chipset
específico de tu motherboard, pero hay muchas mejoras que
puedes hacer a tu sistema, como el soporte para el sistema de
archivos journaling EXT3, lo que vale la pena.

Una cosa más antes

de comenzar. Partes de lo que voy a presentar en esta explicación
son aplicables a todas las distribuciones Linux, mientras que otras
son específicas para Debian y similares,como Libranet y
Xandros. A pesar de que no voy cubrir el modo no-debian de actualizar
y compilar el kernel, la parte de la configuración es
aplicable a todas las distribuciones.

OK, actualicemos el
kernel

BAJANDO UN NUEVO
KERNEL

Si leíste y
seguiste los pasos de \"The Very Verbose Debian 3.0 Installation
Walkthrough\", deberías tener ahora un kernel 2.2.20
instalado en tu sistema. Este kernel carece de soporte para USB y el
sistema de archivos EXT3. Si tienes un disco grande y tienes que
esperar sentado hasta tu próximo cumpleaños para
checkear tus particiones luego de un apagado \'incorrecto\' , amarás
el sistema de archivos journaling EXT3 y definitivamente querrás
soporte para él en tu kernel.

Con esta idea en mente,
vamos a actualizar nuestro kernel a la versión 2.4.20 (la cual
era la última estable cuando comencé a escribir esto.
Por favor siéntete libre de trabajar con kernels más
nuevos si quieres). Para hacerlo, necesitamos bajar el código
fuente de ese kernel. Para hacerlo, puedes usar cualquiera de tus
métodos favoritos (wget, ncftp, etc.), de todos modos en este
tutorial voy a bajar el kernel vía Mozilla ya que lo tengo
instalado y mucha gente sabe como bajar archivos con un navegador
web.

Para bajar el último
kernel, ejecuta Mozilla (o tu navegador favorito), y ve al Linux
Kernel Archives (www.kernel.org).
En la página principal verás una caja de texto bajo el
título, la cual contiene links hasta los servidores HTTP, FTP
y RSYNC. Bajo la caja dice \'La última versión estable
del kernel de Linux es .....\' (2.4.20 sería en este caso), con
el número de versión como link. Para este tutorial, no
bajaremos el kernel usando este link ya que es solo un parche. De
todos modos esta información es importante, ya que te dice
cual es la última versión estable disponible. Así
que cuando vayas al área de download, sabrás cual
kernel bajar.

Para ir al área de
download, donde podrás obtener la versión completa y
actualizada del kernel, clickea en el link HTTP en la caja gris el
encabezado de la página
[http://www.kernel.org/pub].

Deberías estar
ahora en una página titulada \"The Public Linux Archive -
(como si hubiera una privada de donde lo puedes obtener) . Hay otra
caja gris en el encabezado de la página. Por favor clickea el
primer link listado (http://www.kernel.org/pub/linux).

Deberías estar
ahora en otra página llamada, \"Index of /pub/linux\".
En la estructura de directorio en esta página, clickea en el
link \"kernel\".

Deberías estar
ahora en otra página llamada, \"Index of
/pub/linux/kernel\". En la estructura de directorio en esta
página, clickea en el link \"v2.4/\".

Deberías estar
ahora en una página titulada \"Index of
/pub/linux/kernel/v2.4\". Ahí es donde encontraremos el
kernel. Hay muchos archivos listados en el directorio en esta página.
Asegúrate de bajar el archivo llamado \"linux-2.4.20.tar.gz\".
Notarás que hay también un archivo bz2 y un bz2.sign.
Bz2 es otro formato de compresión, pero la utilidad para
descomprimir este archivo no está cargada en tu máquina
Debian por defecto (a pesar de que no sería mucho trabajo
instalarla usando \'apt\'). La utilidad tar, sí está
instalada, así que elegí bajar el .tar.gz. Baja el
archivo y guardalo en tu directorio de usuario. (/home/usuario)

Construcción
del Kernel, paso a paso, requerimientos

PREPARANDO EL CÓDIGO
FUENTE DEL KERNEL 2.4.20

En la sección
anterior, bajamos el código fuente del kernel. Ahora está
contenido en un archivo comprimido (linux-2.4.20.tar.gz), en tu
directorio de usuario. En esta sección moveremos el archivo a
la localización apropiada y descomprimiremos el código
fuente

Para compilar un nuevo
kernel, necesitamos ponerlo en el directorio /usr/src. Te estarás
preguntando, \'Si quiero el kernel en /usr/src, por qué no lo
guardé ahí desde el principio?\' La respuesta que no
tenías derechos para hacerlo ya que estabas logueado como
usuario normal (por lo menos eso espero).

No recomiendo surfear la
web como root. Tu computadora no va a explotar ni nada parecido, pero
es riesgoso hacer todo como root. En consecuencia, sugiero bajar
archivos de Internet como un usuario regular y guardarlos en tu
directorio de usuario. Una vez completada la bajada, puedes usar el
comando \'su\' para logearte como root y mover los archivos a lugares
más seguros si fuera necesario.

Si estás
familiarizado con Linux (no te preocupes si no lo estás, te
ayudaré más en un minuto), logeate como root y mueve el
archivo \"linux-2.4.20.tar.gz\" desde tu directorio de
usuario, donde lo guardaste, al directorio \'/usr/src\'.

Luego, descomprime el
archivo ingresando \"tar -xvzf linux-2.4.20.tar.gz\" en la
línea de comando. Esto creará un directorio
\'linux-2.4.20\' dentro de \'/usr/src\'.

A continuación,
crea un enlace simbólico llamado \'linux\' el cual apuntará
al directorio \'linux-2.4.20\', ingresando \'ln -s linux-2.4.20 linux\' en la
línea de comando. Si este enlace simbólico ya existe,
bórralo y crealo de nuevo como se describió antes.

Tal vez quieras saltarte
el resto de esta sección e ir a la sección \'ARCHIVOS
APT NECESARIOS PARA CONFIGURAR Y COMPILAR TU KERNEL\'.

Si los párrafos
anteriores fueron confusos para ti, aquí están los
mismos pasos en mucho más detallados.

Para mover el archivo
\'linux-2.4.20\' a la ubicación correcta, sigue estos pasos:

Paso 1: (Abre una ventana
de terminal)
Si seguiste el documento de instalación (del
artículo anterior), estarás ejecutando el manejador de
ventanas WindowMaker. Si estás ahí, clickea en el
escritorio para traer el menú, clickea en Xshells, y luego
clickea en Xterm para iniciar la ventana de terminal. Si tu estás
ejecutando un manejador de ventana diferente, usa el método
que tu manejador de ventana te permita para lanzar una ventana de
terminal.

Paso 2: (Ve al directorio
donde bajaste el archivo \'linux-2.4.20.tar.gz\')
Asegúrate
de estar en tu directorio dentro de \'/home\' (o donde sea que
guardaras el archivo linux-2.4.20.tar.gz. Para hacer esto, ingresa
\'pwd\' en la línea de comando. Pwd te dirá en cual
directorio estás ahora. Si pwd regresa otra cosa que no sea tu
directorio home, ingresa \'cd /home/\' en la línea de comando
para ir a tu directorio de usuario.

Paso 3: (Logéate
como \'root\' usando \'su\')
Ahora necesitas logearte como root
ingresando \'su\' en la línea de comando, si ya no lo hiciste
antes. Ingresa el password del root cuando te lo pida.

Paso 4: (Mueve el archivo
\'linux-2.4.20\' al directorio \'/usr/src\')
Ahora ingresa \'mv
linux-2.4.20.tar.gz /usr/src\' en la línea de comando. Esto
moverá el archivo \'linux-2.4.20\' desde tu directorio de
usuario al directorio \'/usr/src\'. Si obtienes un error \'no such file
of directory\' (\'no hay tal archivo o directorio\'), o tu no bajaste el
archivo del kernel o no estás en el directorio adonde fue el
archivo. Ve al directorio donde bajaste el código fuente del
kernel e intenta este paso de nuevo.

Paso 5: (Checkea el
directorio /usr/src)
Cambia al directorio \'/usr/src\' ingresando
\'cd /usr/src\' en la línea de comando. En el prompt de comando,
ingresa el comando \'ls -l\'. Como probablemente sepas, el comando \'ls\'
te muestra una lista de todos los archivos en el directorio actual.
El modificador \'-l\' te muestra más información que
cuando tipeas solo \'ls\'. Te muestra el formato \'largo\'; por lo tanto
deberías ver al archivo \'linux-2.4.20\' que recién
copiamos dentro de este directorio. Debería ser el único
archivo que hubiera, si este es el caso, sáltate el resto de
esta sección y ve al Paso 6.

Es posible que el
directorio tenga otros archivos distintos al archivo \'linux-2.4.20\'
que recién copiamos aquí. Si tu tienes el código
fuente de un kernel viejo en tu máquina, estará en este
directorio también. Además, tal vez tengas un enlace
simbólico apuntando a este kernel viejo.

Antes de continuar,
déjame explicar que es un enlace simbólico. Un enlace
simbólico es un enlace o alias que apunta a otro archivo o
directorio. Si conoces Windows, un enlace simbólico es similar
a un Acceso Directo. Crearemos un enlace simbólico en el Paso
6, así que si todavía no lo tienes claro, con algo de
suerte lo entenderás bien luego de hacer uno.

Ahora, por favor, mira
los otros archivos en el directorio \'/usr/src\'. Hay uno llamado
\'linux\'? Si no lo hay, puedes saltarte el resto de esta sección
e ir al Paso 6. Si hay un ítem en este directorio llamado
\'linux\', checkea para ver tanto si es un enlace simbólico o un
directorio normal. Puedes determinarlo usando el comando \'ls -l\' y
viendo la salida (\'output\'). Ingresa \'ls -l\' en la línea de
comando. La salida puede ser algo como esto (solo que mejor
formateada)

lrwxrwxrwx    1 root src 12 Oct 31 13:03 linux -> linux-2.4.18
drwxr-xr-x   14 573      573          4096 Aug  2 18:39 linux-2.4.18
-rw-------    1 clinton  clinton  32219641 Oct 30 14:40 linux-2.4.20.tar.gz

Permiteme usar el primer
archivo listado como ejemplo para explicar donde necesitas ver. La
primera parte \' lrwxrwxrwx\' muestra el tipo de archivo y permisos de
él.

El primer carácter,
\'I\' indica que este archivo es un enlace simbólico. Los
directorios por otra parte, están indicados con una \'d\' en
esta posición en vez del una \'l\'. Los archivos regulares son
indicados con un \'-\' en la primera posición (hay otros
caracteres que pueden aparecer aquí también, pero están
más allá del alcance de este documento). Los demás
caracteres se refieren a los permisos del archivo para el usuario,
grupo, y otros usuarios respectivamente. Voy a ignorarlos por ahora.

También voy a
saltarme la sección media del listado e iré al final de
éste, en donde está el nombre de archivo. Si miras en
los tres archivos listados arriba, verás que el que está
primero se llama \'linux\', seguido de un \'->\' y luego
\'linux-2.4.18\'. Esto significa que el archivo \'linux\' es un enlace
simbólico que apunta (lo que hace que esté la \'->\'),
a \'linux-2.4.18\'. Si miras en linux.2.4.18 verás que es un
directorio (fíjate que el primer carácter de la línea
de \'linux.2.4.18\' es una \'d\' lo que significa \'directorio\').

Una vez que has
determinado que tienes un archivo \'linux\' en el directorio
\'/usr/src\', haz lo siguiente.

Si el archivo \'linux\' es
un enlace simbólico, borralo ingresando \'rm linux\' en la línea
de comando.

Si el archivo \'linux\' es
un directorio, renómbralo ingresando \'mv linux
linux-mas-viejo\' en la línea de comando.

Ahora deberías
estar listo para continuar.

Paso 6: (Descomprime el
archivo \"linux-2.4.20.tar.gz\")
Ahora necesitamos
descomprimir el archivo linux-2.4.20.tar.gz para poder acceder al
código fuente. Para hacerlo, ingresa \' tar xvzf
linux-2.4.20.tar.gz\' en el prompt de comandos. Tomará un
momento descomprimir el archivo. Cuando termine, deberías
estar de vuelta en el prompt (\'#\'), de nuevo.

Paso 7: (Creando un
enlace simbólico llamado \'linux\' que apunte a
\'linux-2.4.20\')
Finalmente podemos crear un enlace simbólico
llamado \'linux\' que apuntará a nuestro nuevo código del
kernel, el cual está ubicado en el directorio \'linux-2.4.20\'.
Ingresa \'ln -s linux-2.4.20\' en la línea de comando para crear
este enlace. Si tipeas ahora \'ls -l\' deberías ver un nuevo
enlace simbólico llamado \'linux\' el cual apunta al directorio
\' linux-2.4.20\' (o al directorio para cualquiera sea la versión
del kernel que decidiste antes bajar).

ARCHIVOS APT
NECESARIOS PARA CONFIGURAR Y COMPILAR TU KERNEL

Para configurar y
compilar nuestro kernel, vamos a necesitar usar apt (o Synaptic si
prefieres), para bajar unas cuantas cosas.

Ingresa el siguiente
comando, estando logeado como root, para bajar lo que necesitamos (o
selecciona cada uno de los items en esta lista dentro de Synaptic e
instálalos):

\"apt-get install
tk8.2 make gcc bin86 libc6-dev kernel-package\"

En este tutorial, estaré
usando la herramienta de configuración gráfica del
kernel dentro de X. Si tu más bien quieres usar la herramienta
de línea de comando, tendrás que reemplazar \'tk8.2\' con
\'libncurses5-dev\' en el comando anterior (o puedes instalarlos a
ambos y hacerlo como prefieras según tu ánimo).

Luego que todo es bajado
e instalado, una pantalla llamada \'Configurando Binutils\' aparecerá.
Es bueno advertir que esta versión de binutils no funciona con
algunos kernels. Ya que estamos usando la última versión
estable del kernel, no tendremos problemas. Solo presiona enter para
continuar.

Configurando
el kernel

INICIANDO LA
HERRAMIENTA DE CONFIGURACIÓN DEL KERNEL DE LINUX

Asumiendo que estás
todavía en el directorio \'/usr/src\' y has seguido las
instrucciones anteriores, ingresa \'cd linux\' para ir a ese directorio
(el cual si recuerdas es un enlace simbólico al directorio
linux-2.4.20).

Una vez que estes en
\"/usr/src/linux\", estás listo para iniciar la
herramienta de configuración del kernel. Ingresa \'make
xconfig\' en la línea de comando para iniciarla.

Si tu usas la versión
de línea de comando de esta herramienta en vez de la version
gráfica, tendrás que ingresar \'make menuconfig\' en el
prompt de comandos. No voy a explicar el procedimiento con esta
herramienta, pero pienso que debería ser similar al de la
otra.

Ahora deberías
estar viendo una pantalla gris con muchos botones en ella. Si recibes
un error en la línea de comandos, y el programa no se inicia,
abre otra terminal e ingresa \'xhost +\' como usuario regular para
permitir a otros usuarios (en este caso, el root), ejecutar
aplicaciones gráficas desde dentro del entorno Xwindow. Una
vez hecho esto, ingresa \'make xconfig\' como root de nuevo para
ejecutar el programa de Configuración del Kernel Linux.

Si el programa no si
inicia aún, y sigues obteniendo mensajes de error, asegúrate
de que instalaste los paquetes mencionados antes, esto son:

tk8.2, make, gcc, bin86,
libc6-dev, kernel-package, libncurses5-dev (este último solo
es necesario si quieres la version de línea de comando del
configurador)

Si fuiste capaz de
ejecutar exitosamente la herramienta de Configuración del
Kernel Linux, podemos seguir con la sección siguiente.

CONFIGURANDO EL KERNEL
DE LINUX

Deberías tener
abierta ahora el programa de Configuración del Kernel de
Linux. Antes de comenzar, recomiendo mover la ventana del programa a
la parte de arriba de tu pantalla, ya que luego abriremo muchas
ventanas durante el proceso de configurar el kernel, y se abrirán
según donde esté la ventana principal (la que tiene los
botones). Si ubicas la ventana principal cerca del fondo de la
pantalla, las ventanas \'hijas\' aparecerán más
confusamente solpándose excesivamente o saliendo incluso de la
pantalla y estarás arrastrándolas de un lado para otro
para poder verlas. Puedes ahorrarte la molestia, y colocar la ventana
en la parte de arriba de la pantalla.

Configurar el kernel
suena como una tarea que asusta, pero en realidad, todo lo que tienes
que hacer es contestar muchas preguntas para las que tienes múltiples
respuestas posibles. Para la mayor parte, el programa de
Configuración, te preguntará si quieres cargar soporte
para algo, y tu responderás \'Y\' (Si) para cargar el soporte
para ese item, \'N\' (No), para no cargar el soporte para el item, y
\'M\' (Modulo), para cargar soporte para ese item como un modulo.

El beneficio de cargar
cosas como módulos es que el kernel será más
pequeño (y probablemente más rápido), y puedes
cargar y descargar ese módulo a voluntad sin tener que
recompilar el kernel. La primera vez, te recomiendo seleccionar \'Y\'
para las cosas que quieras tener soporte. Luego puedes leer acerca de
como usar módulos; una vez que te familiarices y sientas
cómodo con la recompilación del kernel.

Ahora realmente no hay
una manera de seguir cada configuración del kernel, ya que
cada hardware es diferente. Como sea, el programa de configuración
del kernel tiene mucha ayuda disponible. En efecto, cada línea
de las múltiples opciones del programa tiene un botón
de ayuda asociado, y casi siempre hay buena información en los
diálogos de ayuda. Recomiendo fervientemente leer esos
diálogos para cada línea mientras avanzas por la
configuración. Te ayudarán a elegir las opciones
correctas para tu hardware, y también te ayudarán a
familiarizarte con los servicios que el kernel provee.

Opciones de nivel de
madurez del código (Code maturity level options):
Para ver
un ejemplo de como funciona la herramienta de Configuración,
incluídos los diálogos de ayuda, clickea en el botón
\"Code maturity level options\", el cual está en la
parte superior izquierda de la ventana. Verás que una nueva
ventana aparece. En el caso de \"Code maturity level options\",
solo hay una cuestión que necesitas resolver: \"Prompt for
development and/or incomplete code/drivers\" (\'Preguntar por
código/drivers en desarrollo y/o incompletos\').

Antes de decidir si
queremos o no soporte para esto en nuestro kernel, miremos el diálogo
de ayuda. Para ello, clickea en el botón Ayuda (\"Help\"),
a la derecha del texto \"Prompt for development and/or incomplete
code/drivers\".

Luego de leer el diálogo
de ayuda, ve al último párrafo y mira la primera
oración de nuevo. Se lee \"Unless you intend to help test
and develop a feature or driver that falls into this category, or you
have a situation that requires using these features, you should
probably say N here.\" (\' A menos que pretendas ayudar y
desarrollar una característica o driver que caiga en esta
categoría, o tu situación requiera que uses estas
características, probablemente deberías decir N aquí
\'). Mucha de la ayuda que está disponible en la herramienta de
configuración del Kernel de Linux te explicará que es
lo que estás viendo y también te sugerirá
respuestas. Creo que esto es muy útil para aquellos que no
están familiarizados con compilar su propio kernel. Si estás
inseguro acerca de una línea de un item en particular,
recomiendo seguir la sugerencia ofrecida por el diálogo de
ayuda. Si ninguna sugerencia es dada, el valor por defecto es
usualmente una apuesta segura.

Solo en caso que nadie
tenga preguntas acerca de esto, habilitando \"Prompt for
development and/or incomplete code/drivers\", habilitarás
secciones en la utilidad de Configuración las cuales son
consideradas experimentales o todavía un poco inestables. El
soporte Firewire es un ejemplo de esto. Si miras la ventana principal
de la utilidad de Configuración, verás que hay un botón
para soporte Firewire que está deshabilitado (por lo que un
click sobre él no tiene efecto). Si tu seleccionaras \"Prompt
for development and/or incomplete code/drivers\", ese botón
estaría habilitado luego. No recomiendo habilitarlo por ahora.
Espera a familiarizarte con la configuración del kernel.

Ahora que conocemos que
es \"Prompt for development and/or incomplete code/drivers\",
podemos seleccionar con seguridad \'N\' (lo cual está por
defecto), en el lado izquierdo de la línea. También
notarás que solo hay opciones para \'Y\' y \'N\' (si y no), M
(Modulo), no está. Si alguna de las tres opciones (Y, N, o M),
no está disponible para una opción específica
del kernel, no será mostrada (como en este caso).

Ya que no hay más
seteos del kernel en este diálogo, clickea \"Next\"
(Siguiente), en el botón del diálogo para ir al
siguiente diálogo en la lista. Podrías también
clickear el botón \"Main Menu\" (Menu Principal), y
luego seleccionar el siguiente botón bajo \"Code maturity
level options\", el cual es \"Loadable module support\"
(\'Soporte de Módulos Cargables\'), pero es más fácil
en mi opinión simplemente clickear el botón Siguiente,
cuando termines con cada diálogo, y moverte a través
del proceso de configuración de modo lineal.

Soporte de Módulos
Cargables (Loadable Module Support):
En este diálogo, verás
que hay tres opciones que necesitas configurar. Por favor lee las
descripciones de las tres y selecciona \'Y\' para cada una. Presiona
\'siguiente\' cuando termines.

Característica y
Tipo de Procesador (Processor Type and Features):
Este es el punto
de la configuración del kernel donde se vuelve específico
para tu hardware. La sola razón por la que estoy explicando
este item es explicar es mostrar las listas desplegables que existen
en el programa de configuración del kernel y te ayudarán
con unas cuantas opciones un tanto crípticas.

El primer item en este
diálogo es la opción de \'familia de procesador\'
(\"Processor family\"), ya verás que ésta, en
vez de tener las opciones estándar (Y-N-M), que viste antes,
tiene un botón y (creo), la opción por defecto que se
ve seleccionada en él es \"Pentium-III/Celeron
(Coppermine)\". Clickea este botón y selecciona el
procesador de tu computadora de la lista. Si no sabes que tipo de
procesador tienes, el que está por defecto funcionará
bien, pero no estará optimizado para tu máquina. La mía
por ejemplo tiene un AMD Athlon, así que seleccioné la
opción que dice \"Athlon/Duron/K7\". Si no sabes qué
procesador tienes (no la familia, sino el tipo), elegir \'386\' es una
opción segura aunque poco optimizada.

Por favor lee los
diálogos de ayuda disponibles para cada opción restante
y elije lo que sea apropiado (Y-N-M), para cada una. Cuando termines,
presiona el botón \'Siguiente\'. También debes saber que
algunas de las opciones entre las que vas a seleccionar no son ni
cajas de selección (checkboxes), ni listas desplegables, sino
que estos botones desplegan nuevas ventanas. Bueno, asegúrate
de clickear en todas las opciones. Si clickeas \'Siguiente\' al final
de cada ventana, te aseguras de recorrer todas las ventanas y
opciones de configuración del kernel. Si no lo haces podrías
olvidarte de alguna.

Te ayudaré a
configurar los dispositivos CD-R/RW, los sistemas de archivo
jounaling, y las placas de sonido en un minuto, pero mientras tanto
continua el procedimiento leyendo la ayuda para cada opción,
haciendo luego la selección apropiada, y clickeando
\'Siguiente\' al final, hasta haber completado la configuración
del kernel. Esto te tomará algún tiempo, pero está
bien invertido.

Me gustaría poder
ofrecerte más ayuda durante este proceso, pero no conozco tu
hardware ni sé específicamente para qué usas tu
máquina. Así que te dejo en las competentes manos de
las pantallas de ayuda (no te preocupes ya han hecho esto cientos de
veces con otros usuarios novatos, y todo salió bien).

Me gustaría
sugerir que siguieras los siguientes consejos, por lo menos hasta que
te familiarices con el kernel de Linux. Muchas veces la gente piensa
\'instalaré soporte para todo\'. Esto es una mala idea. Solo
deberías compilar soporte para las cosas que tu sabes que
necesitarás. También, si no sabes qué es
determinada \'cosa\', solo acepta la opción por defecto. Si
tienes alguna duda, por favor usa algún mecanismo de búsqueda
en Internet, como Google y busca información acerca de ello.
También puedes mandarme un email si quieres y te ayudaré
tanto como pueda.

Por favor termina la
configuración completa del kernel antes de continuar.

Configurando
el sonido, ext3 y grabadoras de CD

CONFIGURANDO EL SONIDO
EN TU KERNEL

Ahora que terminaste de
configurar el kernel, vamos a regresar y configurar el soporte para
el sonido, los sistemas de archivo jounaling y las grabadoras de CD.
Empezaremos con el sonido.

Clickea el botón
\'Sonido\' (\'Sound\'), el tercero en la tercer columna (tal vez esté
ubicado en un lugar diferente si estás usando una versión
diferente del kernel, pero aún así se va a llamar
\'Sonido\'). Al hacer esto aparecerá la ventana \'Sonido\'.

El primer item en esta
ventana dice, \'Soporte para Placas de Sonido\' (\"Sound Card
Support\"). Necesitarás decir que sí (\'Y\'), a esto.
Luego elige la placa de sonido apropiada de la lista de placas
presentadas. Por ejemplo, yo tengo una Sound Blaster Live! Value,
para configurar el soporte para esta placa, seteé la opción
\"Creative SBLive! (EMU10K1)\" a sí (\'Y\').

Otra placa popular es la
\"Creative Ensoniq AudioPCI 97 (ES1371)\". Si no estás
seguro de que placa tienes, o si tu placa está \'onboard\'
(interconstruída en la placa madre), intenta setear esta
opción a \'Y\'. Aunque no es seguro que funcione.

Si sabes qué placa
tienes, setea la apropiada a \'Y\' y setea todo lo demás a \'N\'
(excepto la primera opción, \'Soporte para Placas de Sonido\'
(\"Sound Card Support\"), Cuando termines, clickea el botón
\'Menú Principal\' (\"Main Menu\").

CONFIGURANDO EL
SOPORTE PARA GRABADORAS DE CD EN DEBIAN

Ahora, vamos a configurar
tu máquina para que soporte grabadoras de CD. Linux solo
soporta grabadoras SCSI, así si ya tienes una será
posible que grabes Cds bajo Linux. Mucha gente tiene grabadora de CD
y no están soportadas por defecto en su Linux.

Afortunadamente, el
kernel de Linux puede ser configurar para soportar tu grabadora IDE a
través de emulación SCSI. Para setear esto necesitarás
configurar opciones en diferentes áreas de la configuración
del kernel.

La primera área a
configurar es \'Soporte ATA/IDE/MFM/RLL\' (\"ATA/IDE/MFM/RLL
Support\"), De la ventana principal de configuración
clickea el botón que dice \"ATA/IDE/MFM/RLL Support\".
Aparecerá un ventana con solo dos items en ella. El segundo
item es un botón llamado \'Dispositivos de Bloque IDE, ATA y
ATAPI\' (\"IDE, ATA and ATAPI Block Devices\"), al clickearlo
aparecerá una nueva ventana.

Ahora deberías
estar en la ventana \'Dispositivos de Bloque IDE, ATA y ATAPI\' (\"IDE,
ATA and ATAPI Block Devices\"), Hay muchas maneras de configurar
tu máquina para soportar tu grabadora IDE como un dispositivo
SCSI, pero buscaremos la simplicidad; he elegido el camino para ello
y te lo voy a mostrar a continuación.

Primero necesitas
deshabilitar el soporte en tu kernel para unidades IDE CD-ROM. Hazlo
seteando la opción \"Include IDE/ATAPI CDROM Support\"
a \'N\'.

Luego setea la emulación
SCSI habilitandola con \'Y\' en \"SCSI Emulation\"

NOTA: Para aquellos que
le gustaría decirme que no estoy haciendo algo de la manera en
que creen que debería ser, sé que ésta no es el
método favorito para añadir soporte para un grabadora
de CD, pero funciona y es simple (después de todo este
artículo está dirigido a usuarios nuevos). Una vez que
te sientas cómodo configurando el kernel, siéntete
libre de añadir soporte para unidades CDROM IDE de nuevo y
especificar cuales unidades deberían considerarse SCSI con el
parámetro \'append=\"hdx=ide-scsi\' en el lilo.conf. No voy
a cubrir la explicación de este método aquí.

Clickea el botón
\'OK\' para cerrar esta ventana, y luego clickea el botón \'Menu
Principal\' (\"Main Menu\"), de \"ATA/IDE/MFM/RLL Support\"
para cerrar esa ventana. Ahora estás de nuevo en la ventana
principal.

Luego clickea en el botón
\'Soporte SCSI\' (\"SCSI Support\"), en el menu principal.

En la ventana \'Soporte
SCSI\' (\"SCSI Support\"), setea las opciones siguientes a \'Y\'

SCSI Support
SCSI Disk
Support
SCSI CD-ROM Support
SCSI Generic Support
Enable
Extra Checks in New Queuing Code

Setea todo lo demás
a \'N\'.

NOTA: es casi siempre
difícil para nuevos usuarios seguirle la huella a los seteos
SCSI, y generalmente no es necesario cuando solo estás usando
emulación SCSI como lo estamos haciendo ahora. Si te parece
bien setear soporte para el logeo de errores SCSI (por diversión
o porque estás teniendo algún tipo de problema),
deberás habilitar las opciones siguientes también:

Verbose SCSI Error
Reporting
SCSI Logging Facility

Eso es todo. Clickea en
el botón \'Menu Principal\' (\"Main Menu\"), para cerrar
la ventana SCSI.

HABILITANDO EL SOPORTE
PARA EL SISTEMA DE ARCHIVOS EXT3 (TU QUIERES HACER ESTO)

Finalmente vamos a
habilitar el soporte para el sistema de archivos EXT3. Hay otros
sistemas de archivo jounaling soportados por el kernel también,
como JFS y ReiserFS, pero solo me voy a enfocar en EXT3 en este
artículo. EXT3 es muy estable y si algo va mal, tu ya tienes
las herramientas para trabajar y hacer las correcciones al sistema de
archivos ya que es compatible con el sistema de archivos estándar
EXT2.

Para habilitar el soporte
EXT3, desde la ventana principal de configuración, clickea en
el botón \'Sistemas de Archivo\' (\"File Systems\"),
luego aparecerá la ventana Sistemas de Archivo. Baja hasta la
opción \"EXT3 Jounaling File System Support\" y
setéala a \'Y\'. Deja todo lo demás en esta ventana como
está por defecto (a menos que quieras usar otros sistemas de
archivo, como vfat, el cual te permitiría montar particiones
Windows FAT32).

Cuando setees a \'Y\' la
opción \"EXT3 Jounaling File System Support\", el item
de al lado, \'EXT3 debugging\' será habilitado, déjalo
por defecto en \'N\'

El soporte de sonido y
SCSI ya están configurados (bueno, excepto por el cambio para
cambiar el dispositivo /dev/cdrom para que apunte al lugar correcto,
lo cual haremos más tarde), pero todavía no terminamos
con el soporte EXT3. Pero de todas maneras tenemos que compilar el
kernel antes de hacer todo esto.

Clickea el botón
\'Menu Principal\' para cerrar esta ventana.

Compilación
e Instalación del kernel

GUARDANDO LA
CONFIGURACIÓN DEL KERNEL Y COMPILANDO

Ahora ya estamos listos
para compilar el kernel. Antes de hacerlo, me gustaría
mencionar una cosa. Si tienes muchas máquinas donde quieras
instalar el mismo kernel (esto no funcionará bien si el
hardware de esas máquinas no es el mismo en todas ellas),
clickea \'Guardar la configuración a archivo\' (\"Store
Configuration to File\"), esto guardará los cambios que
acabas de hacer a un archivo. Tu puedes copiar ese archivo a tus
otras máquinas y cuando abras la utilidad de Configuración
del Kernel en ellas, solo tendrás que clickear en \'Cargar
Configuración de Archivo\' (\"Load Configuration from
File\"). Esto te ahorrará el que tengas que pasar por el
proceso de configuración para cada máquina.

Ahora compilemos el
kernel. Desde la ventana principal de la Configuración del
Kernel de Linux, clickea en el botón llamado \'Guardar y Salir\'
(\"Save and Exit\"). Aparecerá una ventana diciéndote
que chequees el makefile de nivel superior y ejecutes make dep. No
tienes que hacer ninguna de estas cosas, así que clickea el
botón \'OK\'. Deberías estar ahora de regreso en el
prompt de la línea de comando.

En el prompt de la
consola, tipea \'pwd\' par ver el directorio donde te encuentras,
debería ser \'/usr/src/linux\' (si ves algo diferente, tipea \'cd
/usr/src/linux\' para ir al directorio que contiene tu código
fuente del kernel).

Una vez en este
directorio, tipea los siguientes dos comandos:

make-kpkg clean
make-kpkg --revision=786:MyKernel2.4.20 kernel_image 

El segundo de estos
comandos es donde la compilación en sí comienza. En mi
AMD Athlon 1800+, el proceso de compilación toma alrededor de
10 minutos. En una de mis máquinas viejas, puede llegar a
durar una hora (en un 486, probablemente lo estés \'mirando\'
unos cuantos días). Si tienes un máquina más
vieja, ve, come algo y disfruta de alguna buena película de
comedia. La compilación debería estar terminada al
momento en que tu regreses. Probablemente necesites un descanso de
todos modos.

Si realmente quieres
entender los profundos conceptos de \'qué está
ocurriendo aquí\', puedes leer la documentación que está
ubicada en /usr/doc/kernel-package/ para más información.
En pocas palabras, lo que estás haciendo es crear un archivo
.deb que vamos a instalar exactamente de la misma manera que
instalamos programas, usando la utilidad dpkg. Este archivo contiene
las tareas de configuración que va a realizar automáticamente
y que los pobres usuarios de otras distribuciones de Linux tienen que
hacer manualmente. Esto es algo bastante bueno.

INSTALANDO EL NUEVO
KERNEL

Una vez que hayas
terminado de comer y ver la película, tu máquina
debería haber terminado de compilar el kernel y regresado al
prompt. Deberías tener también un nuevo archivo en tu
directorio /usr/src

Ve ahí tipeando
\'cd /usr/src\' en la línea de comando. Si tu tipeas \'ls -l\' en
el prompt de comandos, asumiendo que no tuviste ningun error de
compilación, deberías ver un archivo llamado
\"kernel-image-2.4.20_MyKernel2.4.20.deb\"; o algo parecido.

Ahora necesitamos
instalar el kernel, justo como lo haríamos con cualquier .deb,
usando la utilidad dpkg. Tipea \"dpkg -i
kernel-image-2.4.20_MyKernel2.4.20.deb\" (o el nombre del archivo
que corresponda si el tuyo es diferente), en el prompt de comandos y
presiona enter.

Una vez terminada la
instalación, se te preguntará si quieres crear un
diskette de booteo. Sugiero que lo hagas, pero no es obligatorio.

Luego, se te preguntará
si quieres instalar un nuevo bloque de booteo usando el
/etc/lilo.conf existente. Si no dices que sí aquí, no
serás capaz de bootear tu nuevo kernel (a menos que digas que
sí a la pregunta del diskette, pero luego solo prodrás
hacerlo con ese diskette). Sin importar qué elijas, asegúrate
de decir que sí a una de las dos preguntas; de otra manera te
quedarás sin la posibilidad de bootear tu nuevo y reluciente
kernel 2.4.20.

Una vez terminado el
proceso, necesitas rebootear tu máquina. Después del
rebooteo tipea \'dmesg\' y mira el output (la salida), busca errores.
También notarás (si es que puedes leer los crípticos
mensajes de Linux), que tu placa de sonido ha sido reconocida. Si
encuentras algún problema, como que elegiste la placa de
sonido incorrecta, tendrás hacer el cambio en el kernel e
intentar de nuevo. Si eso sucede, lee la última sección
de este artículo.

ext3
journaling, solución de problemas, conclusión

SETEANDO TU MÁQUINA
PARA USAR EL SISTEMA DE ARCHIVOS JOURNALING EXT3

Recuerda lo que dije
antes acerca de que no habíamos terminado con todo lo
necesario para EXT3, bien ahora es tiempo de completarlo. Antes de
comenzar, necesitarás un editor de textos como vim, nano, pico
o alguno de los editores gráficos (kedit, gedit, etc.). Por
favor elige uno que te guste y luego continúa.

Primero necesitarás
saber que particiones tienes en tu máquina. Si no recuerdas,
puedes tipear el comando \'df\' y te mostrará una lista de las
particiones montadas en tu máquina. Aquí hay un ejemplo
de la salida de \'df\':

Filesystem Mounted on
/dev/hda1       . . .   /
/dev/hda3       . . .   /usr
/dev/hda5       . . .   /var
/dev/hda6       . . .   /home

Ahora necesitarás
usar esta información en el siguiente comando.

Ahora usaremos esta
información en el siguiente comando. Puedes tipear:
\"/sbin/tune2fs -j /dev/hdxx\" (donde x es la unidad y número
de partición, como /dev/hda1 o /deb/hdb3), en la línea
de comando para cada partición que tengas, o puedes hacerlo
todo de una vez usando el siguiente script (no tipees el \'#\' o \'>\',
eso es el prompt, también debes presionar enter luego de cada
línea, y asegúrate de que tus dispositivos están
separados por un espacio).

# for each in /dev/hda1 /dev/hda3 /dev/hda5 /dev/hda6
>  do
>  /sbin/tune2fs -j $each
>  done

Si cometes un error, o no
tipeaste bien, o tienes algún dispositivo inválido en
la lista. Haz la corrección apropiada y retipea el comando.

Esto convertirá
todas tus particiones de ext2 a ext3. Una vez hecho esto, necesitas
decirle a Linux que monte todas tus particiones como particiones de
tipo ext3. Aquí es donde necesitaremos el editor de textos.

Como root, abre el
archivo /etc/fstab. Donde quiera que veas la palabra \'ext2\', cámbiala
a \'ext3\'. Cuando termines guarda el archivo y sal del editor.

Ahora tenemos que hacer
una cosa más antes de rebootear de nuevo (podría
desmontar y remontar manualmente todas tus particiones a ext3, pero
probablemente sea más fácil que simplemente rebootees
de nuevo y Linux tenga monte automáticamente todo usando
ext3).

Toqué este punto
brevemente antes, pero necesitamos arreglar nuestro dispositivo
/mnt/cdrom. Actualmente apunta a algo como /dev/hdb, así que
como que nuestras unidades de CD emulen SCSI, nuestro CDROM no exite
más. Así que necesitamos arreglar el enlace (\'link\')
/dev/cdrom.

Para hacerlo, primero hay
que saber adonde apunta el enlace. Normalmente, será a
/dev/scd0, pero aseguremosnos. Pon un CD de datos en la unidad CDROM
y tipea:

\"Mount /dev/scd0
/cdrom\"

Si todo sale bien,
deberías ser capaz de tipear \'ls /cdrom\' en el prompt y llegar
a la lista de directorios de tu CD. Si no, y especialmente si tienes
más de un dispositivo CD en tu computadora, intenta otros
dispositivos como /dev/scd1, /dev/scd2, etc.

Una vez que sepas que
dispositivo quieres que sea el \'por defecto\' cambia el enlace
simbólico /dev/cdrom para que apunte a él
(probablemente recuerdes los enlaces simbólicos de nuestra
discusión acerca de donde guardar el código fuente del
kernel). /dev/cdrom es solo un enlace simbólico que apunta a
un dispositivo en tu computadora). Para demostrar como hacer esto,
voy a usar mi sistema en el cual la unidad por defecto es /dev/scd0.
Para cambiar el enlace simbólico para que apunte al
dispositivo correcto, tipee esto en la línea de comando:

\"rm /dev/cdrom\"
(esto borra el enlace incorrecto a /dev/cdrom)
\"ln -s
/dev/scd0 /dev/cdrom\" (esto crea un nuevo enlace /dev/cdrom que
apunta al dispositivo correcto)

Ahora debería
estar listo. Para asegurarnos, en la línea de comando, tipea
\'unmount /cdrom\' para desmontar el CD que montaste hace un minuto.
Luego tipea \'mount /cdrom\' en la línea de comando. Deberías
ser capaz de tipear ahora \'ls /cdrom\' y ver un listado de directorios
de tu CD. Si es así, hiciste todo correctamente. Si no,
retrocede y checkea tus pasos de nuevo. También, aunque ya
debería estar ahí, tipea \'cat /etc/fstab\' para ver si
tu archivo tiene una línea que comienza con \'/dev/cdrom
/cdrom\', si no la tiene agrégala la siguiente línea:

/dev/acd0c /cdrom cd9660
ro,noauto 0 0

Si todo está
funcionando, es momento de rebootear. Si pusiste un CD bootable en tu
unidad durante el proceso, retíralo ants de rebootear.

QUE PASA SI ALGO NO
FUNCIONA?

Viéndolo así
es probable que la primera vez que compiles tu kernel, es posible,
que aunque sin querer, hayas cometido un error. (como incluir la
placa de sonido equivocada en el kernel).

Hay pocas cosas que
necesitas hacer antes de intentar recompilar tu kernel de nuevo.
Primero, necesitas borrar o renombrar el archivo .deb en tu
directorio /usr/src (o cambiar el nombre que le des durante el paso
\'make kpkg\' explicado antes en el artículo).

Lo siguiente, si está
intentando recompilar el mismo kernel que antes (por ejemplo,
2.4.20), necesitarás renombrar o borrar algunas cosas antes de
recompilarlo. Lo bueno que durante el \'dpkg -i\' obtendrás un
mensaje diciéndote exactamente que es lo que hay que borrar o
renombrar. Cuando lo leas, abre un ventana xterm, borra o mueve el
directorio en cuestion, haz CTRL+C para cortar el proceso \'dpkg -i\'
en la primera ventana xterm, y luego reinicia \'dpkg -i\' otra vez.
Todo debería ir bien luego.

Si hay un punto en el
quiero hacer énfasis en este artículo es en leerlo
todo, tanto el documento como las pantallas de ayuda. No adivines;
eso es casi una garantía de cometer errores

CONCLUSION

Esto es todo. Con algo de
suerte estarás un poco más contento habiendo obtenido,
configurado y compilado tu kernel Linux bajo Debian. Espero que te
diviertas aprendiendo con Debian.

Acerca del
Autor:
Mi nombre es Clinton De Young y trabajo como
Administrador de Desarrollo en una compañía de software
llamada Altiris. Hablo inglés y tengo manejo de japonés.
Cuando tengo tiempo traduzco documentos desde y al japonés y a
veces en forma independiente junto con otras empresas escribo
software para el mercado japonés. Pero mi familia está
primero. Ellos son la gente más importante en mi vida.

( El artículo
original en URL at http://www.osnews.com/story.php?news_id=2949
)

0)
{ r=document.referrer;
nav=navigator.appCodeName;
if(navigator.appName.substring(0,9)==\"Microsoft\") {nav=\"MSIE\";}
jae=0; sc=0; pix=0; sw=0; plug=0; d=new Date; h=d.getHours()+1; }

if(jsv>1){
jae=(navigator.javaEnabled() == true)?\"1\":\"0\";
if(nav==\"Mozilla\"){if(navigator.plugins.length>0){
plug=escape(navigator.plugins[0].name);
for(i=1;i2){sw=screen.width;pix=sw*screen.height;
sc=(nav==\"MSIE\")?screen.colorDepth:screen.pixelDepth;}
document.write(\"\");
document.write(\"\");
document.write(\"\");
//-->

Copyright
OSNews.com 2001-2002. All Rights
Reserved.