Blog de Alexis Abarca

Hace unos días tuve que compilar el kernel para el Raspberry Pi ya que necesitaba agregar un módulo del kernel para una impresora térmica (usblp.ko), ya que no viene incluido en raspbian.

Para que necesitas compilar el kernel?

• Soporte dispositivos o tecnologías no incluidas en raspbian (mi caso)
• Actualizar a nueva versión
• Personalizar el kernel removiendo módulos o características que no son necesarias para el uso que le das al equipo.

Requerimientos

• SD con Raspbian instalado y ejecutándose (aquí sólo compilamos el kernel, igual necesitarás el resto de la distribución).
• Una distribución linux para compilar, aquí usé Ubuntu Server (que era la que tenía a mano xD).
• Lector de tarjetas para modificar los archivos (reitero la necesidad de linux, ya que debes acceder a la partición ext3).
• Un buen procesador, mientras mejor sea la compilación será más rápida.
• 2 GB de espacio mínimo aprox (mi carpeta pesa 1819 MB, en 71418 archivos)

Proceso

• Primero debes descargar el código fuente de Linux, aquí usaré la versión 3.6 que corresponde a la rama estable. Puedes clonar el repositorio git, pero como son muchos archivos conviene más descargar el archivo comprimido.

mkdir rpi
cd rpi
wget https://github.com/raspberrypi/linux/archive/rpi-3.6.y.tar.gz
tar xfv rpi-3.6.y.tar.gz

• Luego debes descargar el cross-compiler, ya que estarás compilando para ARM desde x86/x64, al igual que Linux también puedes clonar el repositorio o descargar el archivo comprimido

wget https://github.com/raspberrypi/tools/archive/master.tar.gz
tar xfv master.tar.gz
apt-get install gcc-arm-linux-gnueabi make ncurses-dev

• Ejecuta este comando para limpiar la carpeta del kernel

cd rpi-3.6.y
make rproper

• Luego debes copiar la configuración de kernel, para eso necesitas obtener el archivo .config de un raspbian en ejecución

scp root@raspberryip:/proc/config.gz config.gz
zcat config.gz > .config

• Debes exportar esta variable que define el path del compilador y el prefijo de los comandos.

export CCPREFIX=/home/usuario/rpi/tools/arm-bcm2708/arm-bcm2708-linux-gnueabi/bin/arm-bcm2708-linux-gnueabi-

• Actualizar la configuración

make ARCH=arm CROSS_COMPILE=${CCPREFIX} oldconfig

• Si deseas agregar o quitar características y módulos al kernel debes entrar al menú de configuración

make ARCH=arm CROSS_COMPILE=${CCPREFIX} menuconfig

• Compilar el kernel!, esto tardará varios minutos e incluso horas

make ARCH=arm CROSS_COMPILE=${CCPREFIX}
make ARCH=arm CROSS_COMPILE=${CCPREFIX} modules

• Ahora debes pasar el kernel a la tarjeta SD, si está en ejecución apaga el rPi e inserta la tarjeta en el lector de tu computador (aqui supondré que la SD está en /mnt/sdsys la partición ext3 del sistema y /mnt/sdboot la fat32 de booteo)

mv /mnt/sdboot/kernel.img /mnt/sdboot/kernel-original.img
cp arch/arm/boot/Image /mnt/sdboot/kernel.img

• Ahora debes copiar los módulos, primero se pondrán todos juntos en una carpeta y luego se copiarán

mkdir /home/usuario/rpi/modules
export MODULES_TEMP=/home/usuario/rpi/modules
make ARCH=arm CROSS_COMPILE=${CCPREFIX} \
INSTALL_MOD_PATH=${MODULES_TEMP} modules_install

mv /mnt/sdsys/lib/modules /mnt/sdsys/lib/modules.old
mv /mnt/sdsys/lib/firmware /mnt/sdsys/lib/firmware.old
cp –rv /home/usuario/rpi/modules/lib/* /mnt/sdsys/lib/

• Luego se debe actualizar el firmware, se debe descargar y copiar a la SD

cd ..   (para volver a /home/usuario/rpi)
wget https://github.com/raspberrypi/firmware/archive/next.tar.gz
tar xfv next.tar.gz
cd firmware-next
mv /mnt/sdsys/opt/vc /mnt/sdsys/opt/vc.original
cp –rv /opt/vc /mnt/sdsys/opt/
mv /mnt/sdboot/bootcode.bin /mnt/sdboot/bootcode.bin.original
mv /mnt/sdboot/fixup.dat /mnt/sdboot/fixup.dat.original
mv /mnt/sdboot/start.elf /mnt/sdboot/start.elf.original
cp boot/bootcode.bin /mnt/sdboot/
cp boot/fixup.date /mnt/sdboot/
cp boot/startr.elf /mnt/sdboot/

• Llegó el momento de probar el nuevo kernel. Extrae la SD e insértala en el Raspberry Pi y enciéndelo. Si inicia el SO y llegas al login el kernel se compiló exitosamente.
• Opcionalmente puedes eliminar todos los archivos que se renombraron para liberar espacio una vez que compruebes que el kernel funcionó correctamente.

Fuente: http://elinux.org/RPi_Kernel_Compilation

Luego de usar DD-WRT en este router por más de un año, decidí probar OpenWRT, ya que se le puede agregar soporte de IPv6, protocolo que no está en DD-WRT para este modelo.

Es importante mencionar que OpenWRT sólo es compatible con este modelo (DIR-600) revisión A1, B1 y B2, no es compatible con la versión C1.

OpenWRT a diferencia de DD-WRT es software libre, y como ocurre en la mayoría de los casos, en la página sólo se puede obtener el código fuente, para que uno mismo compile su firmware según las necesidades del usuario.

Para la instalación necesitarás:

• Router Dlink DIR 600 A1, B1 o B2
• Un equipo con una distro de Linux para compilar el firmware, yo utilicé Ubuntu.
• El router conectado a tu equipo por cable de red.
• 4,5 GB mínimo de espacio libre en disco.
• Mucho tiempo.

Para compilar debe seguir estos pasos:

• Instalar subversion y build-essential, ya que desde el repo svn se descargarán las fuentes
• sudo apt-get install subversion build-essential
• Instalar las librerias necesarias
• sudo apt-get install build-essential subversion git-core libncurses5-dev zlib1g-dev gawk flex quilt
• Crear una carpeta para las fuentes e iniciar la descarga
• mkdir openwrt
• cd openwrt
• svn co svn://svn.openwrt.org/openwrt/trunk/
• cd trunk
• Comprobar si se dispone de todas las dependencias
• make defconfig
• make prereq
• Estos comandos mostrarán error si faltan dependencias, en el mensaje se identifica cuál dependencia falta para instalarla y reintentar.
• Igual que en la compilación del kernel, este comando abre una pantalla donde puedes seleccionar lo que se va a incluir en el firmware, ahí es donde seleccioné los módulos de IPv6. Para que se incluyan en el firmware deben salir con [*], los con [M] se compilan, pero no se incluyen, eso se pueden instalar aparte y los [ ] no se compilan ni incluyen. Para volver atrás se presiona dos veces ESC.
• En esta pantalla debes seleccionar como target “Ralink RT288x/RT305x”  y luego como subtarget “RT305x based boards”.
• make menuconfig
• 
• Para iniciar la compilación
• make
• Ahora a esperar, en mi equipo se demoro más de 1 hora, así que a tener paciencia xD. La compilación es larga porque antes de compilar el firmware, compila las herramientas necesarias, como el cross-compiler.
• 
• Ya terminó la compilación, ahora a instalar! El firmware estará ubicado en la carpeta bin/ramips y estarán todos los modelos compatibles, buscar el correspondiente a tu modelo.
• 
• Como en el router tenía DD-WRT utilicé el modo de emergencia para instalar OpenWRT. Si tienes el firmware stock puedes usar la sección de actualización de firmware.
• Para activar el modo de emergencia se debe desenchufar el router, luego presionar el botón de reset y teniéndolo presionado se conecta el router de nuevo. Se habrá accedido a ese modo si la luz de power está parpadeando. El computador se debe configurar con una IP  manual dentro del rango 192.168.0.0/24 y se debe entrar con el navegador a http://192.168.0.1
• Una vez flasheado el firmware se reiniciará automáticamente el router y si tienes IP manual, ahora debes ponerla automática, donde recibirás una dirección dentro del rango 192.168.1.0/24.
• Para comenzar se debe conectar con un cliente telnet (como puTTY) a la dirección 192.168.1.1
• 
• Ahí se debe ejecutar el comando passwd para establecer la contraseña de administrador. Una vez establecida poner exit para salir. En este momento el servidor telnet queda desactivado y se activa el SSH en su lugar. Ahora conectar con SSH al router, utilizado como nombre de usuario root y como contraseña la recién establecida.
• 
• Corriendo ifconfig puedo comprobar que el soporte IPv6 está activado.
• 
• Conectando el cable ethernet a la boca WAN obtuvo dirección IP, si te conectas a Internet por PPPoE, IP estática u otro método, consultar instrucciones en la página http://wiki.openwrt.org/doc/howto/internet.connection .
• 
• Como hay un servidor con radvd enviando router advertisements, OpenWRT también obtuvo su dirección IPv6 automáticamente.
• OpenWRT no incluye interfaz de administración web, ésta se instala por separado con los comandos: (también se puede incluir en la compilación del firmware, lo tendré presente para la próxima xD)
• opkg update
• opkg install luci-ssl
• /etc/init.d/uhttpd enable
• /etc/init.d/uhttpd start
• 
• Ahora puedes conectarte a https://192.168.1.1
• 
• 
• La instalación está completa, ahora puedes configurar el router xD.

Fuentes:

Preparar entorno de compilación: http://wiki.openwrt.org/doc/howto/buildroot.exigence

Compilación: http://wiki.openwrt.org/doc/howto/build

Detalles de compilación para Dlink DIR600 B: http://wiki.openwrt.org/toh/d-link/dir-300revb

Primer login: http://wiki.openwrt.org/doc/howto/firstlogin

IPv6: http://wiki.openwrt.org/doc/howto/ipv6.essentials

Configuración inicial: http://wiki.openwrt.org/doc/howto/basic.config

Instalar LuCI (interfaz web): http://wiki.openwrt.org/doc/howto/luci.essentials

Hace unos pocos dias salió la última versión del kernel, la versión 3.2 que incorpora estos arreglos, para que lleguen al sistema de paquetes de la distribución que estés usando puede tardar un tiempo, además puedes parcharlo para arreglar cosas como el bug donde el aircrack-ng siempre permanece en canal –1, eso último lo explicaré en otro post.

El Kernel compilado será usado en Linux Mint, derivada de Ubuntu que a su vez es derivada de Debian, así que el kernel es compatible con esas tres distro.

Primero debes ir a http://kernel.org y descargar el código fuente de la última versión, en este caso bajaré la versión 3.2, para eso hay que hacer clic en “Full Source”

Descargar el kernel

cd /usr/src
sudo wget http://www.kernel.org/pub/linux/kernel/v3.0/linux-3.2.tar.bz2
tar xvjf linux-3.2.tar.bz2
cd linux-3.1.5/

Ahora hay que configurar el kernel agregandole los modulos que uno va a usar, primero copiamos la configuracion del kernel actual

sudo cp /boot/config-`uname -r` ./.config
sudo make menuconfig

En el último comando puedes agregar módulos al kernel para soportar dispositivos y funciones adicionales. Si luego de compilado te falta algún módulo repite el comando cd /usr/src… luego sudo make menuconfig, habilitas el módulo que falte y compilas de nuevo, para no comenzar desde 0 no ejecutes el comando make-kpkg clean.

Para la primera compilación limpiamos y luego finalmente compilamos

sudo make-kpkg clean
sudo fakeroot make-kpkg –initrd –append-to-version=-alexisabarca kernel-image kernel-headers

(antes de initrd y append-to-version van guiones dobles, asegúrate de copiarlos así)

Ahora espera que se compile, puede tardar por lo menos 30 minutos dependiendo de la velocidad del procesador. La parte en negrita la debes cambiar por un nombre que identifique tu kernel, en el grub y para el sistema se llamará linux-image-3.2-alexisabarca siguiendo el ejemplo anterior.

Luego de finalizada la compilacion puedes instalar tu nuevo kernel y reiniciamos para iniciar el sistema con él

cd /usr/src
sudo dpkg -i *.deb
reboot

(Antes de i va un guión simple)

Finalizado!, ya estás corriendo tu propio kernel  y la última versión del mismo. No desinstales el kernel obtenido de los repositorios o junto a la distro por si tienes problemas o te faltan módulos. En ese último caso debes ingresar a la configuración nuevamente, agregar el módulo que falta, compilar nuevamente, desinstalar el kernel y volver a instalarlo.

Este procedimiento lo probé exitosamente en mi computador corriendo Linux Mint Katya, debería funcionar en otra distro con sistema de paquetes deb.