# [guia] compilando un kernel manualmente (en construccion)

## asph

Compilando un kernel manualmente

0. Introducción

El kernel es el núcleo del sistema operativo GNU/Linux, actualizándolo lograremos mejorar el soporte para nuevo hardware [usb, firewire, video, audio, ...], gestion de memoria, schedulers, políticas de seguridad, etc. Es uno de los únicos procesos que requieren reiniciar el sistema, y aunque hay un proyecto para cambiar de kernel en caliente no es aconsejable usarlo.

En este manual se contempla la instalación de un kernel 2.6, ojo porque la instalación de un kernel antiguo de la rama 2.4 es ligeramente diferente!

1. Obtención del código fuente del Kernel

Para obtener las fuentes del kernel y proceder a su compilación e instalación hay dos formas:

       1) A TRAVES DE PORTAGE

Gentoo tiene varias versiones del kernel en portage, asi que puedes obtenerlas facilmente con el comando emerge:

gentoo-sources (rama 2.4.x del kernel con parches gentoo)

vanilla-sources ( version "original" de kernel.org)

gentoo-dev-sources (rama 2.6.x del kernel con parches gentoo)

...

Instalar vanilla-sources sería lo mismo que descargar el codigo manualmente y descomprimirlo (aunque al hacer el emerge y si no usas --oneshot cada vez que salga una versión nueva bajará e instalará el codigo fuente para que puedas compilarlo).

```
# emerge vanilla-sources
```

Nota: Portage nos instalará el codigo fuente del kernel en /usr/src/linux-2.6.8.1 

Hay varios más incluidos en portage aunque ya son específicos para usar en otras arquitecturas, kernels optimizados, kernels seguros, etc. Puedes ver los disponibles escribiendo:

```
# emerge -s sources | less
```

       2) MANUALMENTE

Hay varias versiones disponibles, pero lo recomendable es instalar la última versión estable. A fecha de hoy, sería la 2.6.8.1

Nota: Si haces los pasos manualmente (sin usar portage), no es necesario ser root hasta el momento de instalar la imagen del kernel, por lo que es aconsejable hacer todo el proceso como usuario normal, y identificarse como root al final del proceso (sección 5). Gracias ArsDangor por la observación.

```
# wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.8.1.tar.bz2
```

Una vez bajado el codigo fuente, procederemos a descomprimirlo (normalmente se ponen en /usr/src aunque puede ser cualquier directorio. por seguridad lo haremos en la home de nuestro usuario)

```
# tar xjf linux-2.6.8.1.tar.bz2
```

2. Parcheando el Kernel

Muchas veces puede interesarnos parchear el kernel para mejorar, optimizar o añadir funciones al kernel. Para ilustrarlo en este manual, pondemos el ejemplo del bootsplash (splashutils), que nos permite usar imagenes de fondo en nuestras consolas con framebuffer.

Lo primero es hacerse con el parche. Esto ya dependerá de cada parche, podemos buscar en google o en páginas relacionadas con el kernel. En el caso del bootsplash, el parche en cuestión esta en una web relacionada al proyecto.

```
 wget http://www.bootsplash.de/files/bootsplash-3.1.4-sp3-2.6.8.1.diff
```

Una vez tenemos el parche (y descomprimirlo en caso de ser necesario) ya podemos instalarlo mediante patch:

```
 cat bootsplash-3.1.4-sp3-2.6.8.1.diff | patch -p1
```

nota: en este ejemplo, se supone que el patch esta en el mismo directorio que el kernel, en caso de no ser asi simplemente especificas la ruta completa al patch, situandote en el directorio del kernel.

Una vez hecho esto, el código fuente del kernel habrá quedado parcheado, y en la configuración ya gozaremos de la nueva funcionalidad del bootsplash.

3. Configuración del kernel

Bueno, ya tenemos nuestro codigo fuente bajado y descomprimido, vamos a proceder a su configuración:

```
# cd linux-2.6.8.1 && make menuconfig
```

Una vez ejecutado este comando, se nos abre un menu basado en ncurses en el que podremos seleccionar todos los soportes que queramos incluir en nuestro kernel.

Cada una de las opciones podemos integrarla en el kernel [*] o bien compilarla como módulo [M]. La recomendación más extendida es la de integrar en el kernel los soportes que vamos a utilizar siempre, y dejar como módulos los soportes que usaremos ocasionalmente (usb, wireless, ntfs, nfs, etc.. dependerá de cada uno). Si queremos cargar alguno de estos modulos al inicio, bastará con añadirlos al fichero /etc/modules.autoload/kernel-2.6

Ejemplo Módulo:

Podemos cargar un módulo con la instrucción modprobe y tambien listar todos los modulos disponibles:

```
# modprobe -l

/lib/modules/2.6.8.1/kernel/misc/svgalib_helper.ko
```

Vemos que tenemos disponible el modulo svgalib_helper (en este caso proporcionado por el paquete svgalib, que nos permite usar links en consola en modo gráfico entre otras cosas), procedemos a cargarlo en memoria:

```
# modprobe svgalib_helper 
```

[se omite el proceso de configuración ya que es diferente en cada máquina y sería difícil detallar todas las opciones.]

4. /usr/src/linux

Este enlace simbolico debe apuntrse al nuevo kernel que vamos a usar, para que louego los paquetes que generen modulos y los modulos en si compilen sin problemas (puedan encontrar include/*):

```
 rm /usr/src/linux && cd /usr/src && ln -s linux-2.6.8.1 linux
```

5. Compilación del kernel

Procedemos a compilar el kernel:

La opción rápida y que compilará el kernel y los módulos es escribir simplemente make o make all. Si haceis un make help vereis todas las opciones, y como make crea la el kernel vmlinux, los módulos y la bzImage comprimida, basicamente. También ejecutaremos make modules_install para instalar los módulos que hayamos compilado, en el caso de que hayamos configurado alguna de las opciones como módulos.

```
make && make modules_install
```

6. Instalación del nuevo kernel

Una vez configurado y compilado nuestro kernel, procederemos a su instalación. Es el momento de identificarse como root si hemos realizado la instalación del código fuente via portage.

Primero montamos la partición boot en caso de que sea necesario (ya que por defecto siguiendo la instalación de gentoo la partición de boot no se monta cada vez que iniciamos el sistema):

```
# mount /boot
```

Ahora copiamos el System.map a la partición de boot, añadiendo el distintivo de la versión de kernel que estamos usando:

```
# cp System.map /boot/System.map-2.6.8.1
```

Copiamos también la imagen del kernel a la partición de boot:

```
# cp arch/i386/boot/bzImage /boot/bzImage-2.6.8.1
```

Desmontamos otra vez la partición de boot por seguridad.

```
# umount /boot
```

7. Modificando el bootloader

-en construcción-

----------

## alexlm78

Creo que deberias incluir en tu evaluacion/hotwo a loas gs-sources (GentooStables) son de lo mejor.

----------

## ArsDangor

Mi granito de arena, mientras completas la guía:

Sobre la descarga y la compilación manuales (directamente desde kernel.org),  *nastassja wrote:*   

> 
> 
> ```
> cd /usr/src && wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.8.1.tar.bz2
> ```
> ...

 

La primera parte no es necesaria. De hecho, descargar  directamente a /usr/src implica que harás todo el proceso (wget, make menuconfig, etc) como root. En realidad, sólo la instalación del núcleo (el bzImage) y sus módulos requieren privilegios de root. Y sólo estas fases deberían ser ejecutadas como superusuario. El resto sería preferible llevarlas a cabo como un usuario limitado.

Salu2.

----------

## navegante

Tambien sería bueno que añadieras un pequeño manual de grub y/o lilo para poder usar esos kernels, si no tienes tiempo yo te ayudo y te lo paso en forma de parche. Por otro lado tambien podrías incluir la forma de parchear el kernel, su forma de versionar, otros kernels disponibles (nitro, ck). Saludos.

----------

## SapoDriLo

A mi lo que me parece muy importante es como aplicar parches al kernel, he investigado esto en google y la verdad no he obtenido información muy concluyente acerca del porque y el como.

Porque: Hay varios parches que agregan alguna funcionalidad con un costo en la estabilidad. Me gustaría saber/entender como puedo valorar la inclusión de un determinado parche en el kernel que construya a mano. Hay tantos, que uno no sabe por donde empezar.

Como: como aplicar un parche parecería algo trivial para el usaurio expreimentado, y aunque yo mismo lo he hecho. Sería muy interesante esa explicación.

Seguiré investigando a ver que puedo aportar a este how-to.

Saludos.

----------

## asph

un poco mas de info.. falta ampliar y la seccion de lilo/grub

----------

## Franco Gotusso

El apartado 2 (Instalación del código fuente del kernel) ¿No sería mejor que estubiera dentro del 1.2? Lo digo porque esto sólo hace falta si te bajas el código fuente a pelo, ya que el ebuild te lo hace sólo.

Salud!

----------

## asph

gracias por el apunte, se me paso al numerar los pasos  :Smile: 

----------

## ArsDangor

Felicidades por la guía. Te está quedando de lujo.  :Smile: 

Una cosa que he comprobado que es muy útil es el make oldconfig, para reaprovechar la configuración de otros núcleos ya instalados y compilados. Igual te interesa tratarlo en tu guía...

Salu2.

----------

## lunatc

La verdad es que va quedando bien   :Very Happy: 

Otra cosilla que puede ser de utilidad es la extracción de la config de un kernel ya compilado.

NOTA: Que yo sepa esto es para kernels de la serie 2.6 (no se si la 2.4 lo soporta)

A veces me ha ocurrido que con el kernel del livecd (u otro kernel cualquiera que tenga la .config incluida) funciona tal o cual dispositivo, y con el que yo he compilado no.

Para eso suelo arrancar con el livecd (por ejemplo) y extraigo la configuración del kernel actual con:

```

zcat /proc/config.gz > fichero_conf_kernel

```

Después la uso copiando el fichero extraído al directorio del kernel como .config y haciendo un make oldconfig

Para hacer que un kernel incluya la configuración dentro de sí mismo hay que activar esto:

```

General setup

  [*] Kernel .config support

  [*]    Enable access to .config through /proc/config.gz  

```

Salu2

----------

## oCHARLIEo

yo ademas de copiar el System.map y el bzImage copio tb el .config con la configuracion actual del kernel... asi siempre puedo volver a la configuracion que tenia antes, si toco algo equivocado...

Usea:

```

# cp .config /boot/Config-2.6.8.1

# cp System.map /boot/System.map-2.6.8.1

# cp arch/i386/boot/bzImage /boot/bzImage-2.6.8.1

```

----------

## ArsDangor

 *oCHARLIEo wrote:*   

> yo ademas de copiar el System.map y el bzImage copio tb el .config con la configuracion actual del kernel... asi siempre puedo volver a la configuracion que tenia antes, si toco algo equivocado...
> 
> Usea:
> 
> ```
> ...

 Eso es precisamente lo que hace un make install. Además, te hace enlaces simbólicos para los ficheros de la última versión instalada.

Así te ahorras unos cuantos cp's.  :Wink: 

Salu2.

----------

## asph

aqui hay una descripcion de los kernels disponibles, o la mayoria de ellos:

http://www.canalgentoo.com/modules.php?name=Content&pa=showpage&pid=9

----------

## viei

Yo no soy partidario de usa el genkernel.....me gusta mas compilar mi kernel a mano....

Pero las cosas están ahi para ayudarnos, no??

Cada vez hay mas y mas opciones en los menus menuconfig de los kernel, asi que lo que yo hago es ejecutar primero sobre mi kernel un genkernel.

```

emerge genkernel

genkernel all

```

de esta forma cdo hacemos un 

```

cd /usr/src/linux

make menuconfig

```

Nos hemos quitado un monton de opciones en las que no tendremos que dudar si ponerlas o no.

A mi me va bien.....pero como no hay dos maquinas iguales....  :Laughing: 

Saludos 

Will

----------

## Franco Gotusso

He agregado el howto al wiki http://es.gentoo-wiki.com/HOWTO_Compilar_el_kernel_manualmente

----------

## gepi

En vez de copiar los archivos como hacéis en varios pasos, es más sencillo:

(dentro de /usr/src/linux)

installkernel 2.6.10 arch/i386/boot/bzImage System.map /boot

Y ya estará instalado en este caso, el kernel 2.6.10 en /boot.

----------

## Stolz

Otra cosa util es el siguiente comando. Permite recompilar los paquetes que, aunque no formen parte de kernel, han instalado modulos del kernel. Por ejemplo, lirc, nvidia, alsa ,... De estas forma, cada vez que compilemos un nuevo kernel,no nos tenemos que preocupar de recordar que paquetes hay que "reemerger" para dejar el sistema como estaba:

```
# emerge -av `grep -l /lib/modules /var/db/pkg/*/*/CONTENTS | sed -e 's/\/var\/db\/pkg\//=/' -e 's/\/CONTENTS//'`
```

----------

## esculapio

Me entró una duda sobre armar el kernel. Hace años que compilo el kernel con solo "bzImage", digamos. Nunca copie initrd ni System.map y ningun problema. ¿Cual es la necesidad de la mayoria de las distros de utilizar metodo de los tres archivos en vez de uno solo? En gentoo solo lo usa el genkernel, cuando es a mano no es necesario.¿Cual es la mejora o diferencia en usar estos archivos en el arranque?

----------

## ensarman

el initrd es  solamente una imagen de un minisistema operativo, es util para cargar modulos importantes que no esten comilados en el nucleo y son indispensables para el correcto booteo.

eso es util en kernels genericos que tiene que detectar el driver IDE, SATA(indispensables) para bootear, pero en kernels personalizados como los que hacemos en Gentoo, no veo mucho la necesidad de un initrd

----------

