En esta entrada de hoy voy a comentar el proceso a seguir para poder arrancar desde la tarjeta SD en lugar del arranque tradicional desde la memoria flash del dispositivo. ¿Que por qué se hace esto?. Bueno, hay varias razones, y la principal yo creo que es el espacio. Configurando una tarjeta SD, bien sea de 1Gb, o incluso una SDHC de 8Gb, conseguiremos tener mucho más espacio para instalar aplicaciones que el que viene por defecto en la memoria flash de la N800. Otra razón que se aduce para realizar este cambio es la seguridad. Si tenemos el sistema en la tarjeta, nos es más sencillo realizar backups del mismo, no corremos peligro de cargarnos nada en la flash interna de la N800, y tendremos más libertad para “experimentar” instalando cosas, desarrollando, etc.
Por otro lado, una vez instalado el sistema en la tarjeta SD, se puede configurar un arranque dual que nos permita elegir desde dónde queremos arrancar el sistema. Otra medida más de “seguridad” por si tenemos algún problema inesperado.
Aparte de estas razones, hay otras ya que no son tan importantes, pero que voy a comentar de todas formas. Por un lado, como las memorias flash tienen un número finito de ciclos de lectura/escritura, al trabajar sobre la tarjeta SD no estaremos “quemando” la flash interna, con lo que su vida útil se alargará. (De todas formas, a la velocidad que evoluciona el mercado, yo creo que habremos cambiado de dispositivo 3 veces para cuando la memoria flash de la N800 empiece a resentirse).
Por otro lado, el sistema de ficheros empleado en la flash interna de la N800 es jffs2, un sistema de archivos comprimido para poder dar cabida al mayor número de aplicaciones. Al instalar el sistema en la SD, lo haremos con un sistema de ficheros ext2, que no está comprimido, con lo que teóricamente se ganará en velocidad. (Y digo teóricamente porque ya ha habido gente que ha hecho pruebas de rendimiento y no parece muy apreciable la diferencia).
Bien, al grano, yo voy a intentar instalar el sistema en una tarjeta SDHC de 4Gb de Kingston, con Speed Class 2. En realidad, a día de hoy, me la estoy jugando un poco, ya que, como he comentado en alguna entrada anterior, parece ser que la N800 tiene cierta tendencia a corromper tarjetas SDHC, con lo que hay que avisar que peligra la integridad del artista, en este caso la SDHC. Aún a costa de este riesgo, voy a realizar el proceso y si al final se corrompe la SDHC al cabo de unos días, informaré en alguna entrada posterior.
La guía “oficial” para realizar esto se encuentra en el site de maemo.org, concretamente en la página:
http://maemo.org/community/wiki/HowTo_EASILY_Boot_From_MMC_card
(Vamos a ver si lo de EASILY es de verdad)…
Lo primero que debemos hacer es utilizar el usuario root. En una entrada anterior explico los pasos necesarios para acceder a dicho usuario.
Por cierto, todo este proceso lo voy a realizar desde un terminal, como el Putty, por la comodidad de usar un teclado físico y no el de la pantalla. En cualquier caso el proceso sería el mismo.
Una vez en la sesión de xterm con el usuario root, pasaremos a particionar la tarjeta SD, con lo que perderemos toda la información que pudiera haber en la misma, así que se impone un backup previo de la tarjeta si contuviese algo de información.
Para particionar la tarjeta, hay otro wiki en maemo, que está en
http://maemo.org/community/wiki/HowTo_EASILY_Partition_your_MMC_card
, y es el que seguiríamos paso a paso para crear las particiones en una tarjeta de 1Gb como viene en el wiki:
Como la tarjeta SD está en el slot interno, está montada en /media/mmc2, y el dispositivo es el /dev/mmcblk0. (Porque es una N800, no una 770).
Lo primero será instalar el paquete e2fsprogs, así que ejecutaremos el comando:
apt-get install e2fsprogs
, con lo que nos instalará dicho paquete. Una vez instalado, desmontamos las tarjetas:
umount /media/mmc1
umount /media/mmc2
(estos comandos no generan ninguna salida, pero si vamos a los directorios /media/mmc1 y /media/mmc2, no veremos nada en ellos).
Y ahora, a particionar, con el programa sfdisk. Normalmente se creará una partición al principio que será de tipo VFAT (o FAT32, dependiendo del tamaño), y tras ésta se creará la partición linux que contendrá el sistema. Los tamaños, claro está dependerán de la tarjeta y de cuánto espacio le queramos asignar a cada cosa. Por ejemplo, en el tutorial de maemo, están usando una tarjeta de 1Gb, con lo que asignan 480Mb a la partición VFAT, y el resto a la partición Linux. (Esto NO es lo que yo voy a hacer en mi tarjeta, pero lo pongo aquí para explicar el proceso). Para ello, utilizan los siguientes comandos en el sfdisk:
# sfdisk /dev/mmcblk0
/dev/mmcblk0p1:1,15000,6
/dev/mmcblk0p2:15001,,
/dev/mmcblk0p3:
/dev/mmcblk0p4:
Voy a comentar un poco estos números. Una vez entramos en el sfdisk para el dispositivo /dev/mmcblk0, nos aparecen las 4 particiones que se pueden crear. Pues bien, en la primera se introduce 1, 15000, 6
El primer número es el primer “cilindro” de la partición, el segundo número es el tamaño en “cilindros” de la partición, y el tercer número, 6, es el tipo de partición, en este caso VFAT.
Para la segunda partición, introducen 15001,, . Esto significa que la segunda partición empieza en el cilindro 15001, y como no se introduce nada más, ésta partición llega hasta el final de la tarjeta. Además, al no poner tampoco el tercer número, se asume que será una partición Linux tipo 83.
Las otras dos particiones no se crearán, así que no se introduce nada. (Se le da al Enter simplemente).
Pero bueno, como esto de las tarjetas avanza que es una barbaridad, esta configuración de 1Gb se nos queda pequeña, así que voy a emplear una configuración para mi SDHC de 4Gb, en la que asignaré 3Gb para la partición FAT, y 1Gb para la partición Linux.
En principio intenté particionar y formatear desde Windows en el Administrador de equipos, pero la opción de borrar partición estaba deshabilitada, así que no fue posible. Con lo que decidí particionar desde la N800, y luego, una vez creadas las particiones, ya podría formatear en FAT32 desde Windows.
Para crear las particiones, ejecuto el sfdisk sobre /dev/mmcblk0, y creo las particiones:
1,93600,6
93601,,
<enter>
<enter>
Y le introduzco “y” para que cree la tabla de particiones.
Con esto he creado una partición de 93600 “cilindros”, ya que al entrar en sfdisk me decía que la tarjeta en total tenía 124800, que se usará para FAT, y el resto lo he dejado en una segunda partición que será Linux.
Ahora bien, como hemos creado una partición mayor de los 2Gb de límite, la formateo especificando que sea FAT32 con el siguiente comando:
mkfs.vfat -S 1024 -F 32 /dev/mmcblk0p1
Una vez hecho esto, y no fiándome del todo, vuelvo a enchufar la N800 al PC, y en el Administrador de equipos me aparece la partición con el tamaño correcto, pero no aparece como FAT32, así que la “reformateo” desde Windows, ahora que he conseguido crear una partición del tamaño adecuado. Ahora en Windows sí aparece como FAT32, desenchufo la N800 para que monte las tarjetas, y en el panel de control->memoria veo la partición de 3Gb que he creado.
Para estar más seguro, desde el xterm ejecuto el comando df y me aparece lo siguiente:
Nokia-N800-26:~# df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/mtdblock4 2048 2048 0 100% /mnt/initfs
none 512 84 428 16% /mnt/initfs/tmp
/dev/mtdblock4 257536 167172 90364 65% /
none 512 84 428 16% /tmp
none 1024 68 956 7% /dev
/dev/mmcblk1p1 971632 52912 918720 5% /media/mmc1
/dev/mmcblk0p1 2989344 4 2989340 0% /media/mmc2
Y compruebo el tamaño de la partición, 3Gb.
Una vez formateada la partición FAT, formateamos la partición Linux:
mke2fs /dev/mmcblk0p2
Y reiniciamos el sistema:
shutdown -r now
La partición FAT la monta el sistema automáticamente, en cambio la Linux hay que montarla a mano. Para ello primero cargaremos un par de módulos, el mbcache.ko y el ext2.ko.
En mi caso estos módulos están en /mnt/initfs/lib/modules/2.6.18-omap1 (no me ha funcionado usando el enlace current, así que pongo el directorio 2.6.18-omap1 en su lugar).
Cargamos el mbcache:
insmod /mnt/initfs/lib/modules/2.6.18-omap1/mbcache.ko
Y luego el ext2:
insmod /mnt/initfs/lib/modules/2.6.18-omap1/ext2.ko
Y ya se puede montar la partición:
mount /dev/mmcblk0p2 /media/mmc2
Muy bien, si hemos llegado hasta aquí, es la hora de cargar el gestor de arranque que nos permitirá escoger la partición desde la que se iniciará el sistema. Este gestor de arranque está hecho por un usuario, fanoush, que contribuye con muchos hacks al desarrollo de la N800, y se puede bajar de su página. Debemos bajarlo navegando desde la propia N800, para almacenarlo en nuestra flash.
El gestor de arranque está en http://fanoush.wz.cz/maemo/initfs_flasher.tgz
Si lo hemos bajado a nuestra carpeta de documentos, lo tendremos en /home/user/MyDocs/.documents. Vamos a ese directorio, lo descomprimimos y lo ejecutamos:
# cd /home/user/MyDocs/.documents/
# tar zxvf initfs_flasher.tgz
# cd initfs_flasher/
# ./initfs_flash
El initfs_flash nos hará una serie de preguntas, a las que yo he respondido:
Are you sure to continue? (yes/no) : yes
Create backup of current initfs (yes/no) : yes
Press enter to continue <enter>
Remove unneeded extra (and factory testing) stuff? (yes/no) : no
Part 2 – Ready for flashing this image? (yes/no) : yes
y <enter> para reiniciar.
Al reiniciar ya nos aparecerá el menú del gestor de arranque, arrancamos desde la flash interna para continuar con el proceso.
Ahora lo que queda es clonar nuestro sistema original, el que está en la flash interna, a la tarjeta SD. Volvemos a cargar los módulos mbcache y ext2:
insmod /mnt/initfs/lib/modules/2.6.18-omap1/mbcache.ko
insmod /mnt/initfs/lib/modules/2.6.18-omap1/ext2.ko
Y creamos un par de directorios para montar la tarjeta y el sistema de archivos raíz:
mkdir /opt/
mount /dev/mmcblk0p2 /opt
mkdir /floppy/
mount -t jffs2 /dev/mtdblock4 /floppy
(Podemos comprobar esto ejecutando el comando df):
Nokia-N800-26:/# df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/mtdblock4 2048 2048 0 100% /mnt/initfs
none 512 76 436 15% /mnt/initfs/tmp
/dev/mtdblock4 257536 170912 86624 66% /
none 512 76 436 15% /tmp
none 1024 68 956 7% /dev
/dev/mmcblk1p1 971632 52912 918720 5% /media/mmc1
/dev/mmcblk0p1 2989344 4 2989340 0% /media/mmc2
/dev/mmcblk0p2 982648 20 932712 0% /opt
/dev/mtdblock4 257536 170912 86624 66% /floppy
Ahora bajamos el programa tar para descomprimir ficheros (ya existe en el sistema, pero no es la versión de GNU, y puede dar problemas, así que usamos éste que es más seguro):
apt-get -d install tar
(nos puede dar algunos warnings, pero le decimos Yes). Luego lo ejecutamos en el directorio /tar-temp:
cd /var/cache/apt/archives/
mkdir /tar-temp/
dpkg -x tar*.deb /tar-temp/
/tar-temp/bin/tar cf – -C /floppy . | /tar-temp/bin/tar xvf – -C /opt
(Este último comando copia todo el sistema al directorio /opt, así que llevará unos minutos, dependiendo de lo que tuviésemos instalado en la flash original. En mi caso fueron 8 minutos).
Para finalizar, desmontamos los directorios creados, cambiamos el arranque a la tarjeta, y reiniciamos el sistema:
umount /opt
umount /floppy
chroot /mnt/initfs cal-tool -–set-root-device ask:mmc2
shutdown -r now
Como curiosidad y para terminar, una prueba bastante simple, el tiempo transcurrido desde la selección de la opción de arranque hasta que el sistema está activo y conectado, fue de 48.29 segundos para la flash interna, y de 32.70 segundos para la SDHC. Si esta diferencia se mantiene, el sistema sería un 30% más rápido desde la tarjeta, lo que no está nada mal.
Y, cómo no, otra vez, otro tostón macanudo. Volveremos con el próximo testamento cuando tenga un “rato” para seguir hablando de este fantástico cacharrito