Configurar, parchear, cacharrear y compilar un Linux FÁCILMENTE

linux (el kernel, qué si no?)
A estas alturas, con tantas recetas como existen, hay todavía muchas cosas que no podemos hacer o que intentamos rodear para evitar lo inevitable: una compilación del núcleo. Existen por internet muchísimas recetas sobre compilaciones y tal, yo no pretendo hacer una receta completísima, ni tan siquiera completa, sólo pretendo hacer una miniguía del núcleo linux, que sirva como base para recetas más completas o que crezca (con la ayuda de todos) hasta convertirse en una guía útil de compilación de Linux. Así pues, los que no sepáis espero que lo encontréis interesante y no demasiado aburrido y los que ya sabéis leedlo para corregirlo y aportar nuevos apartados y trucos.

Añadir nuevos módulos/drivers


Bueno, este título es incorrecto (intencionadamente). Para los usuarios de sistemas tipo hasefroch 95, XP, etc. os puede resultar más cómodo pensar en los módulos del linux como en los drivers de los dispositivos. Esto no es del todo correcto ya que existen módulos que no hacen la función de drivers. A partir de ahora eliminaremos el calificativo de “drivers” y usaremos “módulos” (más correcto).

Generalmente, la compilación de nuevos módulos no incluídos de serie en el kernel, no requiere de una compilación completa del núcleo, ni tan siquiera tener los fuentes completos (linux-source), simplemente una parte de ellos: las cabeceras (linux-headers). Así pues, para compilar módulos para nuestro núcleo tendremos que instalarnos las cabeceras:

# apt-get install linux-headers-$(uname -r)

Puede que nuestra distro cuente con los fuentes del módulo que queremos instalar, entonces esta receta termina aquí, sólo tenéis que ejecutar modules-assistant y seguir las instrucciones. Si el módulo es “extraño” y los fuentes no vienen “de serie”, tendrán instrucciones apropiadas, que generalmente se resumirán en:

$ make
# make install
# depmod -ae

(Notad que el primer make se hace como usuario, el install y el depmod como superusuario) Todos los modulos se relacionan entre si por sus dependencias, esto es: para cargar un módulo se requiere cargar otro previamente (lógico). Con depmod volvemos a calcular todas esas interdependencias, siempre que añadáis un módulo (o lo eliminéis) ejecutar esa línea para actualizar cambios.

Instalar un módulo en realidad es copiar un fichero .ko en el directorio /lib/modules/$(uname -r)/ (y ahí se puede poner en cualquier subdirectorio, depmod los recorrerá todos).

Normalmente los módulos suelen compilarse e instalarse así sin ningún problema, pero los hay más rollazos y puede ser que necesitemos parchear nuestro kernel.

Esto es otro cantar.

Parcheando Linux


Diversos motivos pueden llevarnos al parcheo de un núcleo, el más común será el de instalar un módulo nuevo.

Para parchear el kernel necesitaremos los fuentes (aquí no nos sirve uname -r porque los paquetes no nombran las revisiones del núcleo):

# apt-get install linux-source-2.6.14
# cd /usr/src
# unp linux-source-2.6.14.tar.bz2

Si el parche no está en el repositorio oficial de la distribución vendrá con las oportunas intrucciones de uso, leedlas y que la fuerza os acompañe. Si el parche si está en vuestra distro, se instala, por ejemplo:

# apt-get install kernel-patch-mppe

Estos parches tienen una forma automática de aplicarse:

# cd /usr/src/linux-source-2.6.14
# ../kernel-patches/all/apply/mppe

Pero existe una forma mejor que se explicará más adelante…

Configurando un Linux


Antes de compilar un kernel debemos configurar sus parámetros, son muchos y una gran cantidad de ellos no sabremos para qué sirven (la dura realidad). Normalmente deberemos modificar algún que otro parámetro para ajustarlo a las necesidades de algún módulo o programa. Entonces… ¿cómo hacemos para no cambiar todas las opciones al tuntún?… fácil, en /boot/config-$(uname -r) tenemos la configuración de los parámetros actuales del kernel en ejecución. Para que nuestro núcleo use esos parámetros haremos lo siguiente:

# cp /boot/config-$(uname -r) /usr/src/linux-source-2.6.14/.config

Con esto asumimos que el linux en ejecución tiene una versión 2.6.14, no es muy recomendable usar archivos de configuración para versiones distintas, sobre todo porque os faltarán parámetros. Una vez copiado este archivo procederemos a cambiar los parámetros apropiados, esto es, reconfigurarlo:

# cd /usr/src/linux-source-2.6.14
# make menuconfig

o también:

# make xconfig

La primera opción requiere tener instaladas las librerias de desarrollo de ncurses y la segunda (más bonita) las de qt. Modificaremos los parámetros y finalmente salvaremos la configuración en el archivo .config.

Finalmente la compilación


Bueno, la compilación a la antigua se hace muy fácilmente:

# cd /usr/src/linux-source-2.6.14
# make

Si el parche se aplicó bien y el núcleo esta bien configurado se compilará todo tranquilamente. Eso si… obtendremos una gran cantidad de archivos binarios que no podremos utilizar para nada, la forma correcta de compilarlo será usando el programa kernel-package:

# cd /usr/src/linux-source-2.6.14
# make-kpkg —initrd —bzImage buildpackage

Esto creará un paquete .deb con nuestro nuevo núcleo, que podremos instalar y (teóricamente) usar.

Hacerlo todo junto en un sólo comando

Si tenemos el Linux sin parchear (pero configurado como se ha explicado antes) podemos parchearlo y compilarlo todo de una forma fácil; supongamos que tenemos instalado el parche mppe como se dijo anteriormente, para hacerlo todo de una basta con teclear:

# cd /usr/src/linux-source-2.6.14
# make-kpkg —initrd —bzImage —added-patches mppe buildpackage

Además, si quedó algún nuevo parámetro por configurar (debido al resultado de aplicar el parche) se pedirá por consola su valor. Normalmente, cuando se pregunta por el soporte de un módulo en el núcleo las opciones son: Y, N y M. Si se responde Y el módulo será incluído en la misma imagen del núcleo, esto aumenta la velocidad de carga pero también aumenta el consumo de memoria (el núcleo ocupa más). Si se responde N el núcleo no soportará esa característica (estad seguros cuando eliminéis algo!) y lo más normal M que creará un módulo para soportar dicha característica.

Enlaces de interés


La lista podría ser enorme, pero vamos a poner unos pocos (añadid vosotros los que queráis):

Hasta luego


En fin… creo que esto es todo lo que quería contar hasta ahora, el tema es muy extenso (sólo echad un ojo a make-kpkg) hay muchas cosas que se puedan hacer… bastante será que lo que haya aquí no contenga errores… así que espero que poco a poco se puedan añadir más cosillas y las que hay se corrijan y mejoren.

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de david.villa

Otro enlace

Parcheando a la Debian

No soy portavoz de ningún colectivo, grupo o facción. Mi opinión es personal e intransferible.

Incluir parches en núcleos 2.6

A partir de los núcleos 2.6 puedes parchear el núcleo usando un fichero con extensión .diff de la forma patch -p1 --dry-run < archivo.diff en el directorio /src/linux2.x.x/

Imagen de int-0

Uy chico...

El problema de parchearlo asi es muy simple: es hacerlo a pelo

Funciona? si...
Es recomendable? si hay un programa que lo haga, NO -> usa el programa!

make-kpkg aplica el parche, además te mantiene los archivos changelog y nombra el nuevo paquete según la Debian Policy.

Por cierto... --dry-run no efectua modificación alguna a los archivos, simplemente muestra los mensajes de lo que "debería" ir haciendo...

------------------------------------
init=/bin/bash to conquer the world!

------------------------------------------------------------
$ python -c "print 'VG9udG8gZWwgcXVlIGxvIGxlYSA6KQ==\n'.decode('base64')"
------------------------------------------------------------

Imagen de Lk2

Utilísimo

La verdad ... no es por pelotear, ya que no creo necesitar hacerle la pelota a nadie aquí, pero el manual es el más claro y mejor explicadod e los que yo he visto: corto, claro y con explicaciones muy asequibles ... la verdad, ¡felicidades!

Es más, voy a compilar mi núcleo de Debian para amd64 (un 2.6.15.1) para poder instalar el módulo de nvidia, que no me deja instalarlo porque tiene cargado soporte para no se que cosa en la configuración ... en fin

*************************************************************
A quien ubérrima conífera se adosa, óptima umbría le entolda

Imagen de magmax

Unos enlaces

Si a esta receta le añades algunos enlaces a más información, lo dejas niquelao ;)

Muy buena.

Miguel Ángel García
http://magmax.org

Imagen de arturo

links

Ahí va un link bastante bueno.

http://www.sinuh.org/web/content/view/268/27/

Un saludo, Arturo.

**********************************************************************************
Hay tontos que tontos parecen, hay tontos que tontos son, pero
hay una clase peor de tontos que hacen parecer tontos a los que
listos son.
**********************************************************************************

**********************************************************************************
Hay tontos que tontos parecen, hay tontos que tontos son, pero
hay una clase peor de tontos que hacen parecer tontos a los que
listos son.
*****************************