Configuración y Compilación del Kernel

Autor: PinkX
La intención de este documento es orientar a quienes quieren, por primera vez, compilar ellos mismos el kernel de su máquina. Comenzaré por explicar conceptos básicos como qué es el kernel, y describiré algunas de las características más comunes e importantes.

En ningún caso pretendo describir la funcionalidad de cada una de las opciones que forman parte del kernel, sino únicamente servir de guía en este importante paso.

¿Qué es el Kernel?
Debemos comenzar por respondernos esta pregunta. El Kernel en sí es el corazón o núcleo del Sistema Operativo. En nuestro caso, el kernel se llama Linux, y el Sistema Operativo en sí lo compone el kernel junto con una serie de programas y aplicaciones.

¿Para qué compilar el Kernel?
Una pregunta que a veces los usuarios principiantes se hacen es justamente esta: para qué compilar el kernel si ya tienen su máquina funcionando. La respuesta es simple, y es que entre una versión y otra de los distintos kernel se agregan caracterísitcas nuevas al mismo además de una serie de mejoras. Por otro lado, el kernel que acompaña a las distribuciones es un kernel genérico, esto quiere decir que no tiene ningún tipo de optimización para nuestro hardware específico, viene por defecto para procesadores i386, y lo más probable que tenga soporte para una gran cantidad de dispositivos que es innecesaria puesto que no los poseemos.

Por último, el compilar el kernel es un paso altamente educativo y didáctico para comprender en mayor profundidad el funcionamiento del sistema, y siempre es bueno saberlo por si alguien lo pregunta ;-)

¿Qué necesito para poder compilar el kernel?
En primer lugar, un compilador (gcc). Necesitamos además las librerías de desarrollo correspondientes al sistema (glibc), y en algunos casos requeriremos también del ensamblador as que se distribuye en el paquete binutils. Otros ensambladores disponibles para Linux son gasm o nasm.

Una vez que confirmemos la existencia de todas estas herramientas en nuestro sistema, es necesario contar, obviamente, con las fuentes del kernel.

En la mayoría de las distribuciones estas se incluyen en el disco de instalación, pero no se instalan por defecto. De todas maneras es recomendable bajar siempre la última versión puesto que la mayoría de los fabricantes de distribuciones incluye código adicional en su kernel que no forma parte del original.

Si tienes la seguridad que cuentas con los fuentes 100% originales sin modificaciones, es posible que te actualices a la última versión a través de parches.

Los parches son archivos que contienen las diferencias entre un árbol de fuentes y otro. Por ende, es mucho más conveniente actualizar nuestro kernel a través de este metodo sobre todo si contamos con una conexión a internet relativamente lenta, puesto que los parches son de muy pequeño tamaño.

Parchando el kernel
Si tienes una versión completa del kernel, no es necesario que leas esta sección, aunque puedes hacerlo para fines educativos.

Los parches se aplican en forma consecutiva. Esto quiere decir que, si por ejemplo, tu versión actual del kernel es la 2.2.13 y deseas actualizarte a la 2.2.16, necesitas los parches 2.2.14, 2.2.15 y 2.2.16. Estos deben ser aplicados en ese orden, uno después del otro, y no es necesario realizar una compilación en cada paso. Es necesario remarcar que no es posible parchar una versión mayor del kernel: del 2.0.36 no se puede parchar al 2.2.

Siguiendo el ejemplo anterior en que actualizaremos el kernel 2.2.13 al 2.2.16, supondremos que los parches se encuentran en nuestro directorio home para el usuario usuario, en formato gzip. El árbol de nuestro kernel actual se encuentra en /usr/src/linux, que a su vez debe ser un link simbólico a /usr/src/linux-2.2.13. Dentro de ese directorio, llamamos el siguiente comando:

localhost:/usr/src/linux# gzip -cd /home/usuario/patch-2.2.14.gz | patch -p0
localhost:/usr/src/linux# gzip -cd /home/usuario/patch-2.2.15.gz | patch -p0
localhost:/usr/src/linux# gzip -cd /home/usuario/patch-2.2.16.gz | patch -p0

Esta serie de comandos puede ser reemplazada por el siguiente, siempre y cuando tengamos solo aquellos parches en dicha ubicación:

localhost:/usr/src/linux# gzip -cd /home/usuario/patch-2.2.1* | patch -p0

Si después de lo anterior no obtenemos ningún mensaje de error (y espero que así sea), todo está bien y ahora contamos con un árbol actualizado con la última versión del kernel. Entonces actualizamos el link simbólico, renombrando el directorio primero:

localhost:/usr/src# mv linux-2.2.13 linux-2.2.16
localhost:/usr/src# ln -sf linux-2.2.16 linux

Finalmente tenemos todo listo para configurar y compilar.

El proceso de configuración
Como mencioné en un principio, una de las razones por la cual compilar el kernel es para ajustarlo y optimizarlo a nuestro hardware. Esto se hace por medio de la configuración, un proceso con una gran cantidad de opciones. Acá trataré de describir solo aquellas más comunes e importantes.

Antes de comenzar, es necesario tomar en cuenta lo siguiente: muchas de las características propias del kernel pueden ser compiladas dentro del mismo o como módulos. La diferencia radica principalmente en que, mientras más modularizado sea nuestro kernel, más pequeño será el tamaño de su imagen, lo que por ende nos lleva a una mejor utilización de la memoria.

Por otro lado, la utilización de módulos tiene otra gran ventaja: un kernel dinámico hace más facil la tarea de agregar o eliminar hardware, puesto que solamente es necesario compilar e instalar o eliminar el módulo correspondiente, respectivamente, y no reconfigurar todas las opciones del sistema y compilar un nuevo kernel. Además, los módulos son cargados en memoria y eliminados de ella en demanda, haciendo nuevamente un manejo más eficiente de los recursos.

Por último, cabe decir que hay quienes ven en la existencia de módulos un gran riesgo de seguridad: un módulo malicioso puede ser capaz de esconder procesos, usuarios, etc. (por ejemplo el módulo heroine). Por supuesto, los módulos requieren de privilegios root para ser instalados, por lo que la máquina debe tener un compromiso de seguridad previo para que esto suceda (cosa que un buen administrador no permitirá ;-)).

Dicho todo esto, vamos a lo nuestro. La configuración del kernel se lleva a cabo a través de un programa interactivo que muestra todas las posibles opciones. En este sentido, existen tres posibilidades: un sencillo programa de consola que consta en una serie de preguntas (no recomendado, es muy tedioso y no da la posibilidad de retroceder), otro es un programa al igual de consola pero con una interfaz basada en ncurses lo que lo hace mucho más amigable para el usuario (definitivamente la mejor alternativa), y por último un programa similar pero para X11 (no recomendado puesto que puede presentar problemas de estabilidad). Estos programas se ejecutan, respectivamente, de la siguiente manera:

localhost:/usr/src/linux# make config

localhost:/usr/src/linux# make menuconfig

localhost:/usr/src/linux# make xconfig

Todos estos cuentan con pantallas de ayuda para la gran mayoría de cada una de las opciones de configuración. Como mencioné más arriba, la segunda alternativa es la más segura, y es según la cual me guiaré en el resto de este documento.

Al ejecutar este comando, nos encontraremos luego de un instante frente a una pantalla con una serie de opciones.

¿Qué elegir?
Las opciones a elegir pueden presentarse de la siguiente manera:

[*] Caracteristica que solo es posible compilar dentro del kernel
< > Opcion que puede ser compilada como modulo independiente

Como la primera, las opciones que presentan ese tipo de paréntesis solamente se pueden compilar como parte del kernel y las opciones son "Y" o "N", mientras que en la segunda se nos da la posibilidad de implantarlas como módulo donde las opciones son "Y", "M" (módulo, o también interpretado como maybe, quizás) o "N".

A continuación, describiré brevemente las categorías y opciones más importantes:

Code maturity level options --->
[*] Prompt for development and/or incomplete code/drivers

Al seleccionar esta opción se nos preguntará durante el proceso de configuración si queremos incluir en nuestro kernel características muy nuevas y/o experimentales, incrementando la cantidad de posibilidades.

Processor type and features --->
(386) Processor family
(1GB) Maximum Physical Memory
[ ] Math emulation
[*] MTRR (Memory Type Range Register) support
[ ] Symmetric multi-processing support

En esta sección se indica el tipo de procesador y sus características: primero seleccionamos la familia de la CPU (386, 486, 586, 686, etc.), es importante elegir la que corresponde y no una mayor a la nuestra.

El resto de las opciones debieran de ser comunes para la mayoría de los usuarios: la cantidad máxima de memoria física (1 o 2 Gb), emulación matemática (no es necesario a menos que tengamos un 386 sin coprocesador), MTRR (muy importante para quienes poseen aceleradores gráficos), y SMP (sólo para quienes tienen procesadores duales/múltiples).

Loadable module support --->
[*] Enable loadable module support
[*] Set version information on all symbols for modules
[*] Kernel module loader

Definitivamente queremos soporte para las 3 ;-)

General setup --->

Opciones generales de configuración: soporte para redes, PCI, entre otros. De suma importancia:

[*] System V IPC
[*] BSD Process Accounting
[*] Sysctl support
<*> Kernel support for a.out binaries
<*> Kernel support for ELF binaries

Recomendado leer las pantallas de ayuda para cada una de las opciones ("?")

Plug and Play support --->

Sorpresa: soporte para dispositivos PnP (plug 'n pray)

Block devices --->

Configuración de dispositivos adicionales: de suma importancia, no olvidar: Si contamos con un disco duro IDE desde el cual booteamos Linux, el soporte para este tipo de dispositivos NO debe ser configurado como módulo; esto es motivo para un kernel panic al momento de iniciar el sistema. Lo mismo va para quienes poseen discos SCSI.

<*> Enhanced IDE/MFM/RLL disk/cdrom/tape/floppy support
<*> Include IDE/ATA-2 DISK support

El resto de las opciones son para dispositivos específicos en su mayoría, nuevamente "?".

Networking options --->

Opciones de red: soporte para firewall, IP aliasing, masquerading, entre otros. No olvidar "?".

SCSI support --->

Soporte para dispositivos SCSI, desde controladoras hasta una variedad de periféricos.

Network device support --->

Soporte para diversos dispositivos de red, como adaptadores Ethernet, Token Ring, X.25, etc. ("?").

ISDN subsystem --->

Configuración ISDN. "?".

Character devices --->

Diversas opciones de dispositivos tales como soporte para terminales virtuales, consolas, puertos seriales, autodetección de IRQs, mouse, joysticks, adaptadores de captura de video y otros. "?".

Filesystems --->

Soporte para diversos sistemas de archivos: Ni se te ocurra compilar el soporte para ext2 como módulo. Como siempre, "?".

Console drivers --->

Drivers para la consola de texto, desde el normal VGA hasta extensión framebuffer. Nuevamente "?".

Sound --->

Soporte para sonido, junto con módulos para una gran cantidad de tarjetas. Muy importante ver la ayuda correspondiente a la tuya ("?") además de la documentación existente en /usr/src/linux/Documentation/sound.

Kernel hacking --->

La única opción que encontraremos dentro de esta categoría es Magic SysRq key, la cual nos permite, si la habilitamos, poder acceder a pantallas informativas y otras funciones muy útiles (sobre todo si se cae el sistema) a través de combinaciones de teclas. Una vez más recomiendo leer la ayuda correspondiente ("?").

Y a continuación, ¿qué?
Una vez finalizada la configuración del kernel (y estando seguros de que todo está como corresponde), debemos salir del programa y guardar los cambios.

Hecho esto, procedemos a generar las dependencias y limpiar los objetos residentes anteriores que puedan andar por ahi:

localhost:/usr/src/linux# make dep && make clean

Pregunta (para quienes no saben): ¿qué significa el &&? Respuesta: es un operador lógico que significa and (y), en términos prácticos, separa dos comandos, y siempre y cuando la salida del primero haya sido true (verdadero), o sea, haya tenido éxito, ejecutará el siguiente. De esta forma, nos aseguramos que solo se continuará si es que no hay errores.

A continuación, la parte más larga: la compilación de la imagen del kernel:

localhost:/usr/src/linux# make zImage

Mientras esto ocurre, podemos disfrutar de una taza de café, aunque en los procesadores actuales esto es cada vez menos posible ;-)

Si al finalizar este proceso obtenemos un mensaje diciéndonos que el sistema es demasiado grande (system too big) tenemos dos posibilidades: tratar de compilar la imagen en un formato comprimido reemplazando el comando anterior por:

localhost:/usr/src/linux# make bzImage

o bien modularizando en mayor forma nuestro sistema, esto es, eliminando aquellas opciones innecesarias y utilizar la mayor cantidad de módulos posibles. Luego repetir el paso anterior.

Si, por el contrario, el sistema no nos arrojó ningún mensaje de error, estamos listos para el siguiente paso: compilar los módulos, e instalarlos:

localhost:/usr/src/linux# make modules && make modules_install

Otra pequeña espera (quizás mayor que la primera). Una vez terminado, estamos listos para nuestro siguiente paso.

La instalación del nuevo kernel
Si estás aquís es porque (espero) durante todo el proceso no has sufrido ningún fallo. Nuestro siguiente paso puede ser el más complejo y es instalar de forma definitiva el nuevo kernel en el sistema.

Aunque, según me han dicho, esto se puede hacer fácilmente en forma automática a través del siguiente comando:

localhost:/usr/src/linux:# make install

El asunto es que nunca lo he probado yo personalmente, ni me llama la atención hacerlo. Si eres de esas personas como yo, quienes prefieren hacer todo manualmente y entender un poco mejor como funciona todo esto, entonces sigue las instrucciones que se dan a continuación (en caso contrario y asumiendo que el comando anterior funcionó puedes dejar de leer):

Lo primero es copiar la imagen generada al directorio /boot del sistema. La ubicacion original de la imagen depende de la arquitectura, En este caso utilizaremos la del x86:

localhost:/usr/src/linux:# cp arch/i386/boot/zImage /boot/vmlinuz-2.2.16

Donde, por supuesto, reemplazaremos zImage con bzImage en caso de que hayamos generado la imagen con ese procedimiento, y tambien cambiamos el nombre del destino a la versión del kernel correspondiente. A modo de idea: yo mantengo links simbólicos a dos versiones del kernel, de esta manera al actualizarlo solo debo además actualizar los links, y no reconfigurar LILO:

localhost:/:# ln -sf /boot/vmlinuz-2.2.16 /boot/vmlinuz
localhost:/:# ln -sf /boot/vmlinuz-2.2.13 /boot/vmlinuz-old

Esto es, por supuesto, siguiendo nuestro primer ejemplo en el cual deseamos actualizar desde la versión 2.2.13 a la 2.2.16. Paso siguiente: actualizar el LILO.

Como mencioné anteriormente, si utilizas el sistema de links simbólicos descrito arriba solo será necesario que el LILO lo modifiques una primera vez. Lo que a continuación se muestra es un extracto del archivo de configuración de LILO, ubicado en /etc/lilo.conf correspondiente a la sección de la imagen de Linux:

image = /boot/vmlinuz
root = /dev/hda1
label = Linux
read-only

La idea es agregar una nueva sección, correspondiente a la nueva imagen, y cambiar el nombre de etiqueta de la actual, por lo que esta parte de nuestro archivo debiera de quedar de la siguiente manera:

image = /boot/vmlinuz
root = /dev/hda1
label = Linux
read-only

image = /boot/vmlinuz-old
root = /dev/hda1
label = Linux-old
read-only

No es mi intención en este caso describir la sintaxis de la configuración del LILO sino citarlo para lo que es necesario. Si deseas más detalles al respecto puedes referirte a la página del manual del lilo.conf(5).

El último paso: actualizar el LILO. Para eso, simplemente, lo ejecutamos:

localhost:/# lilo
Added Linux *
Added Linux-old

Lo olvidaba. Recomiendo también crear un link simbólico para el archivo System.map con el fin de no tener que copiarlo cada vez que compilemos un nuevo kernel (este archivo contiene información específica de la versión sobre los símbolos en los módulos):

localhost:/# ln -sf /usr/src/linux/System.map /boot/System.map

Fin
Eso es todo. Fin. Reinicia el nuevo kernel. Si funciona, felicitaciones. Si no, revisa cual pudo haber sido tu error.

Que es el kernel?

* Qué es el Kernel?
* Dónde conseguir el kernel
* Configuración e instalación del kernel
* Parches(patches) para el kernel
* Consejos sobre el kernel
* Enlaces sobre el kernel
* Directorio del kernel


Que es el kernel?

El kernel o nucleo de linux se podria definir como el corazon de este sistema operativo. Es el encargado de que el software y el hardware de tu ordenador puedan trabajar juntos.

Las funciones mas importantes del mismo, aunque no las unicas, son:

* Administracion de la memoria, para todos los programas en ejecucion.
* Administracion del tiempo de procesador, que estos programas en ejecucion utilizan.
* Es el encargado de que podamos acceder a los perifericos/elementos de nuestro ordenador de una manera comoda.

Existen dos versiones del Linux kernel:

* Version de produccion: La version de produccion, es la version estable hasta el momento. Esta version es el resultado final de las versiones de desarrollo o experimentales.

Cuando el equipo de desarrollo del kernel experimental, decide que ha conseguido un kernel estable y con la suficiente calidad, se lanza una nueva version de producion o estable. Esta version es la que se deberia utilizar para un uso normal del sistema, ya que son las versiones consideradas mas estables y libres de fallos en el momento de su lanzamiento.

* Version de desarrollo: Esta version es experimental y es la que utilizan los desarrolladores para programar, comprobar y verificar nuevas caracteristicas, correcciones, etc. Estos nucleos suelen ser inestables y no se deberian usar, a no ser que sepas lo que haces.

Como interpretar los numeros de las versiones:

* Las versiones del kernel se numeran con 3 numeros, de la siguiente forma: XX.YY.ZZ

XX: Indica la serie principal del kernel. Hasta el momento solo existen la 1 y 2. Este numero cambia cuando la manera de funcionamiento del kernel ha sufrido un cambio muy importante.
YY: Indica si la version es de desarrollo o de produccion. Un numero impar, significa que es de desarrollo, uno par, que es de produccion.
ZZ: Indica nuevas revisiones dentro de una version, en las que lo unico que se ha modificado, son fallos de programacion/bugs.

* Unos ejemplos nos ayudaran a entenderlo mejor:

ej1: version del kernel 2.4.0: Kernel de la serie 2 (XX=2), version de produccion 4 (YY=4 par), primera version de 2.4 (ZZ=0)
ej2: version del kernel 2.4.1: Kernel de la serie 2, version 4, en el que se han corregido errores de programacion presentes en la version 2.4.0 (ZZ=1)
ej3: version del kernel 2.5.0: version 0 del kernel de desarrollo 2.5.

Donde conseguir el kernel

El kernel se puede bajar de un gran numero de servidores en internet. En el directorio del kernel en este servidor, podras bajar las ultimas versiones del Kernel, bajadas directamente de http://www.kernel.org/.

En este enlace tienes la lista internacional oficial de servidores espejos, de donde es posible bajarse cualquier version del kernel (ultima y antiguas).

Configuracion e instalacion de un nuevo kernel

Este es uno de los temas que asustan a los nuevos usuarios de Linux. Lo primero deciros que no hay razon para asustarse, la configuracion e instalacion de un nuevo kernel en nuestro sistema es mas facil de lo suena.

Lo que si hay que hacer es tener claro una serie de cosas antes de ponernos a trabajar, para asi evitar problemas. A continuacion tienes una pequena guia sobre como configurar e instalar un nuevo kernel en tu sistema.

Has decidido instalar un nuevo kernel en tu sistema, que es lo que tenemos que hacer?

1. Bajarte la ultima version. De donde? Leete la seccion anterior.

NOTA: Si vais a instalar un kernel de las ultimas series de produccion, teneis que tener en cuenta que algunas distribuciones (si son antiguas) pueden no estar preparadas para hacer uso de estas series. Si vuestra distribucion no viene preparada para soportar los ultimos kernels, teneis que actualizar una serie de paquetes/programas antes de instalar el nuevo kernel (mas informacion en la documentacion que acompaña al kernel). o actualizar a una distribucion o version de vuestra distribucion que los soporte.

2. Tener claro lo que vamos a hacer, leete el documento HOWTO sobre el kernel (Ingles / Castellano)
3. Tener claro las opciones que tenemos que configurar, para poder utilizar el hardware de nuestro sistema, asi como las caracteristicas que queremos utilizar. Por ejemplo, si no utilizamos un dispositivo SCSI, no tenemos que configurar nada en el apartado SCSI de nuestro kernel. Asi nos ahorramos espacio y tiempo.

4. Entrar como root: su root
5. Copiar el archivo que te has bajado al directorio /usr/src/ cp linux-xx.xx.xx.tar.bz2 /usr/src/
6. Descomprimirlo y desempaquetarlo: tar -xvzpf linux-xx.yy.zz.tar.gz

NOTA IMPORTANTE: El archivo linux-xx.yy.zz.tar se desempaquetara en el directorio /usr/src/linux
Si ya existe un directorio llamado linux en tu sistema, renombralo, p.ej: mv linux linux-old . En algunas distribuciones, linux es un enlace simbolico a linux-xx.yy.zz, borra este enlace simbolico. Es importante que no exista ningun directorio/enlace simbolico llamado linux, antes de desempaquetar la nueva version.

7. Entrar en /usr/src/linux: cd /usr/src/linux
8. Configurar el kernel, esto se puede hacer de tres maneras diferentes:

make config (modo texto)

make menuconfig (modo texto con menus)

make xconfig (X-windows version)

9. Os recomiendo el ultimo comando o el segundo, totalmente desaconsejado usar el primero.

10. Os recomiendo que las opciones que vienen por defecto no las toqueis, si no sabeis lo que haceis. Configurar las opciones que quereis tener en vuestro nuevo kernel. Una vez terminada la configuracion, grabar los cambios y salir del programa de configuracion.

11. Una vez terminado el proceso de configuracion, tenemos que compilar nuestro nuevo nucleo. Para ello hay que hacer lo siguiente:

make dep
make clean
make bzImage

12. Si en el proceso de configuracion, elegimos alguna opcion como modulo, tendremos que compilar/instalar dichos modulos:

make modules
make modules_install

NOTA: No olvidar ejecutar como root el comando depmod -a la primera vez que arranqueis con vuestro nuevo kernel, para computar las dependencias entre modulos.

13. Ya tenemos el kernel y los modulos compilados, ahora tenemos que instalarlo. Casi todo el mundo utiliza LILO para arrancar el sistema, por ello explicare como instalarlo utilizando LILO.

Todavia estamos en /usr/src/linux ejecutar el comando make install , esto copiara el kernel que acabamos de crear, a el directorio /boot de nuestro sistema, con el nombre vmlinuz., o como un enlace simbolico vmlinuz -> vmlinuz-xx.yy.zz

14. Ahora tenemos que configurar LILO para que reconozca el nuevo kernel. Tendremos que modificar el fichero /etc/lilo.conf

Aqui teneis un ejemplo, del fichero /etc/lilo.conf antes de modificarlo:

boot=/dev/hda
prompt
timeout=50
image=/boot/vmlinuz-2.0.34
label=linux
root=/dev/hda1
read-only

Y aqui como quedaria despues de la modificacion para que reconozca nuestro nuevo kernel al arrancar:

boot=/dev/hda
prompt
timeout=50
image=/boot/vmlinuz
label=nuevokernel
root=/dev/hda1
read-only
image=/boot/vmlinuz-2.0.34
label=linux
root=/dev/hda1
read-only

15. Ahora solo tenemos que ejecutar el comando /sbin/lilo y arrancar el sistema de nuevo. Si tuviesemos algun problema con el nuevo kernel, siempre podriamos arrancar con el antiguo escribiendo linux cuando arrancamos y nos sale en pantalla lilo: De esta manera podemos entrar y ver que es lo que ha fallado.

NOTA: Recordar que existen multitud de opciones para configurar LILO, y que los ejemplos anteriores, son ejemplos. Puede que vuestro sistema necesite diferentes parametros y opciones. Leeros los documentos HOWTOS sobre el kernel y LILO antes de cambiar nada en vuestro sistema. Al final de esta pagina teneis enlaces a los mismos. Suerte y espero que tengais las cosas un poco mas claras.


Parches (patches) para el Kernel

* Que son los parches y para que sirven:

Un parche para el kernel no es mas que un fichero, que solamente contiene informacion sobre las lineas de codigo que han cambiado desde la version precedente del nucleo. De esta manera, solamente te tienes que bajar un fichero con los cambios, en vez del nucleo al completo. El ahorro en cantidad de Mb bajados es bastante considerable, sobre todo para aquellos que dependen del modem y no tiene una conexion rapida a internet.

Algo a tener muy en cuenta si vais a actualizar el nucleo por medio de parches en vez de bajaros el nucleo al completo, es que teneis que ir actualizando de version a version. Para que se entienda un poco mejor, aqui teneis un ejemplo:

Si teneis el nucleo 2.2.0 y vais a actualizarlo al 2.2.1, os podeis bajar el fichero patch-2.2.1.gz [70Kb] en vez, del nucleo 2.2.1 al completo [12.5Mb]. Pero si teneis el nucleo 2.2.0 y vais a actualizar al 2.2.4, NO os vale bajaros el fichero patch-2.2.4.gz nada mas, tendriais que bajaros el 2.2.1, 2.2.2, 2.2.3 y 2.2.4. Esto es porque los ficheros patch solamente contienen los cambios de version a version.

Si la diferencia entre la version que teneis y la que quereis instalar, es muy grande (p.ej: del 2.2.0 al 2.2.35), no os merece la pena actualizar por medio de parches, en este caso bajaros la version completa.

* Que hacer con un fichero patch-XX.YY.ZZ.gz?:

Ya te has bajado el fichero patch (se pueden bajar del mismo subdirectorio donde esta la version completa), que necesitas para actualizar el kernel, y ahora que haces?. Ahora, hay que aplicarlo al nucleo que tienes y compilar de nuevo. El procedimiento para actualizar el nucleo por medio de ficheros patch es el siguiente:
1. Copia el fichero patch-XX.YY.ZZ.gz al directorio /usr/src : cp patch-XX.YY.ZZ.gz /usr/src/
2. Cambia a este subdirectorio y descomprime el fichero: gunzip patch-XX.YY.ZZ.gz
3. Aplica el parche: patch -s -p0 < patch-XX.YY.ZZ
4. La opcion -s hara que solo se impriman mensajes de error. Si no recibes ningun mensaje de error (como deberia de ser ;-)) solamente te queda entrar en /usr/src/linux: cd /usr/src/linux
5. Y ejecutar make clean, make xconfig, make dep, make bzImage, el resto es igual que en la seccion anterior a partir del punto 12)


Consejos

* Pregunta: Necesito actualizar el kernel que utilizo, cada vez que una nueva version aparece?

Respuesta: NO. Porque? La explicacion es la siguiente:

Cuando un nuevo kernel aparece, puede ser por las siguientes causas:
o Nuevas caracteristicas se han anadido.
o Fallos de programacion se han corregido
o Fallos de seguridad se han corregido.
o Nuevo hardware es soportado.

Si las caracteristicas que se han anadido, no las vamos a utilizar, es evidente que no necesitamos actualizar.
Si los fallos de programacion que se han corregido, afectan a caracteristicas/drivers que no utilizamos, no necesitamos actualizar.
Si no utilizamos el nuevo hardware soportado, tampoco necesitamos actualizar.

De todas maneras es recomendable, actualizar de vez en cuando, sobre todo cuando se corrigen fallos de seguridad o cuando los cambios en el nuevo kernel afectan a caracteristicas/funciones/hardware que utilicemos.

El codigo esta ahi, libre y esperando a ser compilado en un nuevo ordenador, cada usuario debe de decidir cuando es hora de una actualizacion.

* Pregunta: Soy nuevo en Linux y acabo de instalar una distribucion, como actualizo el kernel?

Respuesta: Te aconsejo que esperes un poquito. La distribucion que acabas de instalar (si es de las ultimas) viene con un kernel de los "ultimos", totalmente funcional y que te sirve sin problemas.

Utiliza el sistema un tiempo, familiarizate con el nuevo sistema que acabas de instalar, y cuando comprendas un poco mas como funcionan las cosas, actualiza el kernel. Un buen punto de partida para encontrar informacion sobre el kernel, lo tienes en estas paginas.

Enlaces sobre el kernel

* The Linux Kernel Archives Pagina principal/oficial sobre el kernel
* KernelNotes Mucha informacion sobre kernel
* Linux Mama Actualizaciones no oficiales
* Kernel Howto (Ingles)
* Kernel Como (castellano)
* LILO MiniHowto (Ingles)
* Guia de programacion de modulos para el kernel (ingles)
* The Linux Kernel Libro (ingles)

Configurar Slackware en Español

Configuraciones de varias aplicaciones y configuraciones para dejar slackware en Español.
Algunas de estas opciones ya se toman por defecto, pero estan anotadas por si no ocurrió esto y por defecto esta en inglés.

1: Perfil
a - Editar /etc/profile
b - agregar export LC_ALL=es_ES
c - logout/login y comprobar con el comando locale

2: Teclado de Xwindow:

a - editar /etc/X11/xorg.conf
b - en Section "Input Device", debajo de Driver "kbd" agregar Option "XkbModel" "pc105" Option "XkbLayout" "es"
c - Si tienes un teclado diferente (Como los de Compaq para Internet por ejemplo), podes buscar los modelos con less /etc/X11/xkb/rules/xorg.lst (q para salir del programa)

3: Manuales.

a - baja las paginas del manual man-pages-es-0.2.tar.gz
b - descomprimi los archivos con tar -xjvf man-pages-es-0.2.tar.gz
c - cd man-pages-es-1.28/
d - su (enter) Password root (enter)
e - make install.

4: KDE:

Si el comando:

ls /var/adm/packages/kde*18*es* Muestra un paquete, entonces:

Desde KDE:
a - ALT+F2 en ejecutar escribir: kcontrol
b - Ir a Regional & accessibility
c - Contry/Reg...
d - Country -> el pais
e - Keyboard Layout
f - Add spanish; remove English
g - logout/login KDE.

Si no muestra paquete, como root:
h - Montar el CD 2 de Slack mount /dev/cdrom /mnt/cdrom
i - installpkg /mnt/cdrom/Slackware/kdei/kde*18*es*
j - logout/login de KDE. comenzar desde 4a

5: Correcion en español sobre KDE
Para que soporte correcion en entorno KDE, Bajar este paquete descomprimir, luego make build y copiar el .aff y el .hash (se le puede cambiar el nombre que tiene la ~ ) y moverlos a /usr/lib/ispell, luego en Centro de Control de KDE > Componentes de KDE > Corrector, seleccionar el diccionario y listo.

Por: Jorge Mestre