Labs – Linux embebido Joaqu´ın de Andr´es – Lucas Chiesa Germ´an Bassi 4 de Marzo de 2011

´Indice 1. Utilizando la consola

2

2. Armando nuestro toolchain

7

3. Bootloader 10 3.1. Preparando la SD . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 3.2. Usando uBoot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 4. Trabajando con el kernel 4.1. Trabajando con el c´odigo fuente . . . . . . 4.2. Compilando un kernel para i386 . . . . . . 4.3. Armando un kernel para nuestra placa . . 4.4. Grabando un kernel en NAND con uBoot . 5. Usando un sistema para crear el rootfs

1

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

14 14 17 18 18 20

1.

Utilizando la consola

Objetivo: Aprender la estructura general y los comandos m´as importantes de un sistema GNU/Linux. Primero lo primero, baj´emonos una lista de los comandos de la siguiente URL: http://free-electrons.com/docs/command-line. Ahora s´ı, abramos una consola y entendamos lo que vemos. Dependiendo del entorno gr´afico que tengamos ser´a distinta la forma de abrir una consola. Como es com´ un a todos los entornos gr´aficos vamos a usar la xterm. usuario@host:~$ La primer parte nos indica el usuario con el que estamos logueados y en el host en el que estamos (separado por un ). Lo que viene despues del ‘:’ es el path en el que estamos parados. En este caso, el ‘˜’ indica que estamos parados en nuestro home. El s´ımbolo que viene a continuaci´on nos indica si somos un usuario raso ($) o un super usuario (#). El cursor titilando es bash (por as´ı decirlo). Bash es un interprete de comandos y es uno de los m´as usados en el mundo linux. Bash tiene un conjunto de variables de entorno que son las que le informan de cosas como cu´al es el home del usuario ($HOME), el path actual ($PATH) y as´ı. M´as adelante veremos c´omo imprimir estas variables. Veamos algunos comandos para trabajar con archivos y directorios:

ls, cd, mkdir: El primer comando nos permite listar los archivos y directorios contenidos en un directorio en particular. $ ls veremos los archivos y directorios contenidos en el lugar que estamos parados. Una opci´on muy importante es la de listar archivos ocultos $ ls -a y otra, que nos muestre la salida como una lista $ ls -la Como ven, hay algunos archivos ocultos que son muy importantes, el ‘.’ y el ‘..’ . El directorio ‘.’ es el directorio actual, por lo que si hacemos 2

$ ls -la . tendremos la misma salida. El directorio ‘..’ es el directorio padre del actual, por lo que si hacemos $ ls -la .. veremos los archivos de un nivel m´as arriba. Para navegar por los directorios se utiliza el comando cd que viene de “change directory”. Por ejemplo, para pasar al directorio padre podemos hacer: $ cd .. No hay mucho m´as que decir de este comando. Dos cosas muy interesantes son: $ cd y el $ cd El primer comando es un cd sin argumentos, y lo que hace es ir al home del usuario. Lo que hace el segundo comando es un cd al directorio en el que se estaba antes de hacer el u ´ltimo cd :). O sea, hace un undo del ultimo cd. Para crear directorios, utilizamos el comando mkdir (“make directory”) $ mkdir directorioA

cp, mv, rm: Para copiar archivos tenemos el comando cp (“copy”) $ cp archivoA archivoA2 Los par´ametros de este comando son primero qu´e queremos copiar y segundo a d´onde lo queremos copiar. Para poder copiar directorios es necesario pasarle la opci´on -r (“recursive”) $ cp -r directorioA directorioB Para mover un archivo utilizamos el comando mv (“move”) $ mv archivoA directorioA La forma de renombrar archivos es movi´endolos con un nuevo nombre $ mv archivoA archivoB Para borrar archivos usamos el rm (“remove”) $ rm archivoB 3

chmod, chroot: Como vimos con el comando ls -l los archivos y directorios tienen permisos: drwxr-xr-x 37 usuario grupo -rw-r--r-- 1 usuario grupo

4096 Feb 13 10:20 directorioA 20416 Jul 23 2010 archivoA

La primera columna de este listado contiene 10 caracteres, los cuales informan acerca del tipo de archivo y los derechos de acceso al mismo. El primer car´acter indica el tipo de entrada; los m´as comunes son: -: archivo normal. d: directorio. b: dispositivo orientado a bloques (como los discos r´ıgidos). c: dispositivo orientado a caracteres (como m´odems y puertas seriales). s: socket mapeado en archivo (para comunicaci´on entre procesos). p: FIFO o Named Pipe (otro medio de comunicaci´on entre procesos). Los dem´as caracteres, divididos en tres grupos de tres caracteres cada uno, indican los derechos de acceso del due˜ no del archivo, del grupo y de otros, respectivamente. r (Read): permiso de lectura. w (Write): permiso de escritura. x (eXecute): permiso de ejecuci´on. - : indica que el respectivo derecho est´a negado. Entonces en el caso de querer modificar estos permisos podemos utilizar el comando chmod (“change mode”) $ chmod u+x archivoA $ chmod 356 archivoA En el primer caso, le estoy diciendo que al usuario due˜ no le agregue el permiso de ejecuci´on sobre ese archivo, mientras que en el segundo estoy pas´andole directamente todos los permisos (3 5 6 = 011 101 110).

4

cat, more, less, tail, head: Veamos ahora algunos comandos para manejar el contenido de archivos. Para mostrar el contenido de uno o varios archivos utilizamos el comando cat $ cat archivoA archivoB Para verlo m´as lindo se puede paginar la salida con el comando more o less (este u ´ltimo tiene m´as opciones) $ more archivoA $ less archivoB Si no queremos ver todo el archivo, sino cierta cantidad de l´ıneas del inicio o del final $ head -10 archivoA $ tail -15 archivoB

ps, top, kill, du, df, su, tar: ´ Estos son algunos de los comandos m´as importantes entre todo el resto de aplicaciones que hay. Para trabajar con procesos tenemos ps, top y kill. El primero, nos permite ver los procesos que est´an corriendo en el momento. Con el comando $ ps -a podremos ver una lista de ellos. Un conjunto de opciones un poco m´as interesante es $ ps -aux que nos da un listado m´as completo. El comando top, es lo mismo que ps s´olo que posee a´ un m´as opciones y tiene una interfaz m´as linda. $ top El comando kill, por otro lado, nos permite, una vez identificado el proceso, matarlo $ kill 123 Un comando para saber cu´anto espacio ocupan los archivos y directorios es el du (“disk usage”) $ du -sh directorioA $ du -sh * 5

Si queremos saber el espacio libre en disco podemos utilizar el comando df (“disk free”) $ df -h Uno de los comandos m´as importantes para el manejo de m´ ultiples archivos es el tar, dado que nos permite comprimir y descomprimir archivos en muchos formatos distintos $ tar -czvf archivo-dirA.tar.gz direcotrioA $ mv directorioA directorioH $ tar -xzvf archivo-dirA.tar.gz Y el comando su, nos permite loguearnos como super usuario (root) en la consola que estamos. $ su Normalmente se intenta no trabajar como root (como medida de seguridad), por lo que si lo que se quiere es ejecutar s´olo un comando con permisos de super usuario se puede emplear el comando sudo (“super user do”). Este comando nos permite esto mismo pero usando la contrase˜ na del usuario $ sudo echo "hola soy root"

6

2.

Armando nuestro toolchain

Objetivo: Entender c´omo compilar un cross-compiling toolchain para la librer´ıa uClibc. Para armar el toolchain vamos a usar una herramienta llamada crosstool. Primero necesitamos bajar el crosstoolNG de http://ymorin.is-a-geek.org/ download/crosstool-ng/ (la versi´on 1.9.3 que pesa 1.7MB). Despu´es, descomprimimos el archivo $ tar xjf crosstool-ng-1.9.3.tar.bz2 Para instalarlo en el directorio local y no globalmente, ejecutamos $ ./configure --local Utilizamos la herramienta make para compilar $ make $ make install Una vez instalada, podemos ver las opciones de esta herramienta $ ./ct-ng help Las opciones que m´as nos interesan son las de configuraci´on, hay un par de formas de hacerlo: oldconfig utiliza una configuraci´on que le pasamos por par´ametro para actualizar la configuraci´on actual. menuconfig nos provee de una interfaz seudo gr´afica para modificar la configuraci´on. Con esta herramienta se pueden generar toolchains varios para distintas arquitecturas y usando distintas librer´ıas. Para esto, hay que modificar las configuraciones o usar alguna de las configuraciones ya hechas. Estas opciones se pueden ver con: $ ./ct-ng list-samples Elegimos una (arm-unknown-linux-uclibcgnueabi) y con el men´ u de configuraci´on refinamos las opciones $ ./ct-ng arm-unknown-linux-uclibcgnueabi $ ./ct-ng menuconfig 7

Algunas opciones importantes: Paths and misc options —> • Prefix directory: el directorio de instalaci´on del toolchain (Vamos a cambiarlo por /usr/local/xtools/${CT_TARGET}). • Number of parallel jobs: la cantidad de trabajos paralelos (Vamos a cambiarlo por 2*CANT-CPUs). • Forbid downloads: habilita que se baje los archivos de un mirror dado (Vamos a sacar la opci´on). Target options —> • Target Architecture (arm) —> ◦ arm: es la arquitectura que vamos a usar. ◦ mips: los routers D-Link tienen micros con esta arquitectura. • Use the MMU : activa la utilizaci´on de la MMU del microcoprocesador. Podr´ıamos querer armar un toolchain para compilar uClinux. • Endianness: (Little endian) —>: elegimos la forma en que se interpretan los bytes en memoria. Esto depende de la arquitectura y en el caso de arm se pueden usar las dos. • Bitness: (32-bit) —>: cantidad de bits del microcontrolador. • Default instruction set mode (arm) —>: set de instrucciones a utilizar. • Use EABI : para que genere binarios compatibles con el est´andar de interfaz para aplicaciones y binarios en embebidos (EABI). • Floating point: (software) —>: podemos elegir si nuestro micro soporta punto flotante. Toolchain options —> • Tuple’s alias: nos permite generar alias para los binarios, as´ı en vez de poner todo el nombre del binario (que va a ser muy largo) ponemos s´olo el alias (Vamos a cambiarlo por arm-linux). • Type (Cross) —>: elegimos el tipo de toolchain que queremos armar. En este caso es cross porque queremos compilar en x86 para arm. Operating System —>: podemos indicarle qu´e versi´on de kernel queremos usar. Binary utilities —> 8

• Binary format: (ELF) —>: tipo de binario que genera. ELF es el est´andar en linux. • binutils version (2.19.1) —>: versi´on del paquete de herramientas binutils que tiene el ensamblador, el linker y otras herramientas. C compiler —>: opciones para el compilador de C (gcc es el compilador en linux). C-library —> • C library (uClibc) —>: selecci´on de la librer´ıa con la que se armar´a el toolchain. Utilizaremos la librer´ıa uClibc. Antes de compilar creamos el directorio donde vamos a generar el toolchain y le ponemos permisos de escritura a nuestro usuario. $ sudo mkdir /usr/local/xtools $ sudo chown user:group -R /usr/local/xtools Adem´as, es necesario crear un directorio donde crosstoolNG va a bajar los tarballs que necesite $ mkdir $HOME/src Ahora s´ı compilamos el toolchain $ ./ct-ng build Cuando termina de compilar ya podemos probarlo compilando algo. Primero configuremos la variable de entorno PATH para no tener que poner todo el path al compilador $ export PATH=$PATH:/usr/local/xtools/arm-unknown-linux-uclibcgnueabi/bin $ arm-linux-gcc -Wall hello.c -o hello.bin

Podemos ver el tipo de archivo de la salida para corroborar que est´a crosscompilado. $ file hello.bin

9

3.

Bootloader

Objetivo: Compilar un bootloader y conectarse a la placa para utilizarlo. Aprender la diferencia entre bootloader en NAND y en SD.

3.1.

Preparando la SD

Antes de empezar a trabajar con el bootloader es necesario que configuremos nuestra tarjeta SD. Enchufemos la SD y veamos qu´e dispositivo aparece. $ dmesg sd 3:0:0:0: [sdb] 3842048 512 byte hardware sectors: (1.96 GB/1.83 GiB)

Esto nos est´a indicando que el kernel le asign´o el nombre sdb al dispositivo. Para particionar la tarjeta de memoria vamos a utilizar la herramienta fdisk $ sudo fdisk /dev/sdb Command (m for help): m Command action a toggle a bootable flag b edit bsd disklabel c toggle the dos compatibility flag d delete a partition l list known partition types m print this menu n add a new partition o create a new empty DOS partition table p print the partition table q quit without saving changes s create a new empty Sun disklabel t change a partition’s system id u change display/entry units v verify the partition table w write table to disk and exit x extra functionality (experts only) Como necesitamos setear par´ametros de geometr´ıa vamos a entrar en modo experto. Command (m for help): x Hay que setear la cantidad de cabezas (heads) en 255 y la cantidad de sectores en 63 y calcular la cantidad de cilindros seg´ un el tama˜ no de la memoria. 10

Expert command (m for help) : h Number of heads (1 256, default 4): 255 Expert command (m for help) : s Number of sectors (1 63, default 62): 63 Warning : setting sector offset for DOS compatibility En nuestro caso tenemos una memoria de 2GB, por lo tanto 2∗1024∗1024∗1024 = 2,1475e + 09 y dividido 255 ∗ 63 ∗ 512 = 8225280 da 261,08, redondeando seteamos la cantidad de cilindros en 261 Expert command (m for help) : c Number of cylinders (1 1048576, default 4): 261 Salimos del modo experto y vemos la tabla de particiones Expert command (m for help): r Command (m for help): p Disk /dev/mmcblk0: 1973 MB, 1973420032 bytes Ahora vamos a crear una partici´on chica de 64MB Command (m for help): n Command action e extended p primary partition (1-4) p Partition number (1-4): 1 First cylinder (1-239, default 1): 1 Last cylinder, +cylinders or +size{K,M,G} (1-239, default 239): +64M

La marcamos como booteable Command (m for help): a Partition number (1-4): 1 y le seteamos el tipo en FAT32 Command (m for help): t Selected partition 1 Hex code (type L to list codes): c Changed system type of partition 1 to c (W95 FAT32 (LBA)) Finalmente, escribimos todo en la tabla de particiones Command (m for help): w The partition table has been altered! ... Con fdisk s´olo creamos el espacio en la tarjeta, ahora es necesario darle un formato, para eso utilizamos la herramienta mkfs $ sudo mkfs.vfat -n beagleboot -F 32 /dev/sdb1 11

3.2.

Usando uBoot

Intentemos acceder a la placa. Para esto vamos a utilizar una consola serie $ minicom -s Configuramos el dispositivo en /dev/ttyUSB0 y el puerto en 115200 8N1. Reiniciamos la placa y veremos la secuencia de inicio de uBoot. Podemos parar esta secuencia tocando ENTER. OMAP3 beagleboard.org # Este uBoot es el que viene preinstalado en la memoria NAND de la beagleboard, pero ¿qu´e pasa si se rompe (o lo rompemos)? Se puede volver a instalar utilizando un uBoot en la tarjeta SD. Primero necesitamos copiar a la partici´on que hicimos en la tarjeta el X-Loader (MLO) y el uBoot (u-boot.bin) $ sudo mount /dev/sdb1 /mnt $ sudo cp archivos-boot/MLO archivos-boot/u-boot.bin /mnt/ $ sudo /mnt Para que tome el bootloader de la SD tenemos que reiniciarla sosteniendo el bot´on de USER apretado. Cuando tenemos la l´ınea de comando le pasamos las siguientes instrucciones: OMAP3 beagleboard.org # mmc init mmc1 is available OMAP3 beagleboard.org # fatload mmc 0:1 80000000 MLO reading MLO 19908 bytes read Esto lo que le dice es, primero que inicialice el sub sistema MMC para la SD y luego copia de la MMC 0 partici´on 1 el archivo MLO en la direcci´on 80000000 de la memoria RAM. Para poder escribir esta informaci´on en la NAND tenemos que habilitar esta funcionalidad OMAP3 beagleboard.org # nandecc hw HW ECC selected Borramos las direcciones en donde tenemos que escribir, el ROMCODE buscar´a en estas direcciones el X-Loader, dici´endole desde d´onde y cu´anto tiene que borrar

12

OMAP3 beagleboard.org # nand erase 0 80000 NAND erase: device 0 offset 0x0, size 0x80000 Erasing at 0x60000 -- 100% complete. OK y escribimos lo que tenemos en memoria (en la direcci´on 80000000) en la direcci´on 0 con un tama˜ no de 80000 OMAP3 beagleboard.org # nand write 80000000 0 80000 NAND write: device 0 offset 0x0, size 0x80000 524288 bytes written: OK Para escribir el uBoot hacemos lo mismo. OMAP3 beagleboard.org # mmc init mmc1 is available OMAP3 beagleboard.org # fatload mmc 0:1 80000000 u-boot.bin reading u-boot.bin 188600 bytes read OMAP3 beagleboard.org # nandecc sw SW ECC selected OMAP3 beagleboard.org # nand erase 80000 160000 NAND erase: device 0 offset 0x80000, size 0x160000 Erasing at 0x1c0000 -- 100% complete. OK OMAP3 beagleboard.org # nand write 80000000 80000 160000 NAND write: device 0 offset 0x80000, size 0x160000 1441792 bytes written: OK Y listo, ya podemos reiniciar el dispositivo sin la SD puesta y arrancar´a normalmente.

13

4.

Trabajando con el kernel

Objetivo: Aprender c´omo configurar y compilar un kernel.

4.1.

Trabajando con el c´ odigo fuente

Primero vamos a bajarnos un kernel. La versi´on 2.6.35 es con la que vamos a trabajar en el lab. Pero, para aprender a aplicar un parche de kernel nos vamos a bajar una versi´on mas vieja del kernel y todos los parches necesarios para pasar a la versi´on 2.6.35. Los archivos necesarios son los siguientes: Full source: http://www.kernel.org/pub/linux/kernel/v2.6/longterm/ v2.6.34/linux-2.6.34.tar.bz2 Patch: http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.35. bz2 Patch: http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.35. 9.bz2 Empezamos descomprimiendo las fuentes completas del kernel 2.6.34 $ tar -xzf linux-2.6.34.tar.bz2 Y utilizando la herramienta patch emparchamos el kernel $ $ $ $ $

mv patch-2.6.35.bz2 linux-2.6.34/ mv patch-2.6.35.9.bz2 linux-2.6.34/ cd linux-2.6.34 bzcat patch-2.6.35.bz2 | patch -p1 bzcat patch-2.6.35.9.bz2 | patch -p1

Como ahora es otra versi´on de kernel, renombramos el directorio $ mv linux-2.6.34.8/ linux-2.6.35.9/ Para configurar el kernel hay muchas formas. $ make help Este comando nos mostrar´a un listado de todas las opciones y formas de configuraci´on que tenemos. Una forma gr´afica de hacerlo es con $ make xconfig 14

Pero como queremos familiarizarnos con la interfaz ncurses utilizaremos $ make menuconfig General setup —> • Prompt for development/incomplete code: permite seleccionar drivers o caracter´ısticas que todav´ıa no son completamente estables. • Local version - append to kernel release: permite concatenar un string arbitrario a la versi´on del kernel, visible con el comando uname -r. Muy u ´til para dar soporte! • Support for swap: usualmente se puede desactivar en sistemas embebidos (Lo vamos a desactivar para la versi´on embebida del kernel). • Configure standard kernel features (for small systems): permite sacar algunas partes del kernel para achicarlo m´as. Poderoso, pero usar con cuidado! (CONFIG_EMBEDDED) Enable loadable module support —>: Permite habilitar o deshabilitar el soporte de m´odulos por completo. Si tu sistema no necesita m´odulos mejor no activarlo, ahorrando mucho lugar y memoria. Enable the block layer —>: Si se usa CONFIG_EMBEDDED, la capa de bloque se puede remover completamente. Si el dispositivo usa Flash, no es necesario. Processor type and features (x86) or System type (ARM) or CPU selection (MIPS): Permite seleccionar la CPU o m´aquina para la que el kernel se va a compilar. En x86, s´olo hay optimizaciones, en otras arquitecturas es muy importante ya que son incompatibles. Networking support: The network stack • Networking options ◦ Unix sockets, necesarios para generar la comunicaci´on entre procesos ◦ Protocolo TCP/IP con opciones para multicast, routing, tunneling, Ipsec, Ipv6, algoritmos de congesti´on, etc. ◦ Muchos otros protocolos como DCCP, SCTP, TIPC, ATM ◦ Ethernet bridging, QoS, etc. • Soporte para otros tipos de red ◦ CAN bus, Infrared, Bluetooth, WiFi stack, WiMax stack, etc. 15

Device drivers • Memory Technology Device (MTD) support —> MTD es el subsistema para Flash (NOR, NAND, etc.) • Parallel port support —> Soporte de puerto paralelo • Algunos dispositivos de bloques como loopback. • ATA/ATAPI, discos IDE, CD-ROM, tapes. • SCSI device support —> El n´ ucleo SCSI, no s´olo necesario para SCSI, sino que para almacenamiento USB, y discos SATA entre otros. Controladores SCSI • Serial ATA and Parallel ATA drivers —> SATA y PATA, el nuevo stack para discos. Depende de SCSI. • Network device support —>, drivers para placas. Ethernet, WiFi pero tambi´en PPP • Character devices, drivers de dispositivos de caracteres ◦ Serial drivers —> Puerto serie. ◦ Unix98 PTY support PTY, necesario para cosas como SSH o telnet • I2C, SPI, 1-wire, bases populares en embebidos • Watchdog Timer Support —> Soporte de watchdog • Graphics support —> Infraestructura para drivers y framebuffers • HID Devices —> Dispositivos HID (Human Input Devices) • USB support —> Soporte USB ◦ USB Gadget Support —> Gadget drivers, permiten el equipo funcionar como mass-storage, un puerto serie o un adaptador Ethernet. • MMC/SD/SDIO card support —> Soporte MMC/SD/SDIO • LED Support —> Soporte LED File systems • Linux filesystems comunes: ext2, ext3, ext4 • Filesystems menos comunes: XFS, JFS, ReiserFS, GFS2, OCFS2, • Btrfs • CD-ROM filesystems: ISO9660, UDF • DOS/Windows filesystems: FAT and NTFS • Pseudo filesystems: proc and sysfs 16

• Miscellanous filesystems, entre los que est´an los Flash filesystems como JFFS2, UBIFS, SquashFS, cramfs • Filesystems de red, principalmente NFS y SMB/CIFS

4.2.

Compilando un kernel para i386

Vamos a partir de una configuraci´on de ejemplo $ cp ../config-kernel-ejemplo .config Para ver qu´e opciones est´an seteadas $ make menuconfig Una vez terminada la configuraci´on, grabamos el archivo modificado y compilamos. $ make Para probar el kernel vamos a usar un emulador llamado qemu utilizando el filesystem que les dimos $ qemu -m 32 -kernel arch/x86/boot/bzImage -append "root=/dev/sda rw" -hda ../linux_i386.img El filesystem que les dimos armado no tiene consola, por lo que conviene agregarle una. Primero montamos el filesystem para poder modificarlo $ mkdir fs $ mount -o loop linux_i386.img fs/ $ cd fs/dev/ y creamos un dispositivo de caracteres que ser´a nuestra consola $ mknod -m 622 dev/console c 5 1 la opci´on ‘-m’ es para pasarle los permisos, ‘c’ indica que sera un “character device”. Los n´ umeros 5 y 1 son el major y minor number del dispositivo. Para la consola est´an definidos en el kernel y son estos. Ahora volvemos a ejecutar el qemu. $ qemu -m 32 -kernel arch/x86/boot/bzImage -append "root=/dev/sda rw" -hda ../linux_i386.img

17

4.3.

Armando un kernel para nuestra placa

Ahora la idea es que armemos un kernel pero utilizando nuestro crosscompilador y poni´endole las opciones espec´ıficas para la placa. Primero vamos a acondicionar un poco nuestro sistema. Le agregamos la ubicaci´on del crosscompilador al path de ejecuci´on del sistema export PATH=/usr/local/xtools/arm-unknown-linux-uclibcgnueabi/bin:$PATH

Vamos a utilizar el kernel que ya nos bajamos. Para indicarle que queremos compilar el kernel para otra arquitectura utilizamos la variable de entorno ARCH. $ export ARCH=arm $ export CROSS_COMPILE=arm-linux$ make help As´ı podemos ver que aparecen muchas m´as opciones de target. Elegimos el target omap3_beagle_defconfig y creamos un .config nuevo $ make omap3_beagle_defconfig Podemos ver las opciones que se han configurado con el comando anterior y compilar. $ make menuconfig $ make Como la imagen de kernel que se genera no sirve para ser booteada por uBoot, es necesario hacer un post proceso con la herramienta mkimage $ make uImage

4.4.

Grabando un kernel en NAND con uBoot

Borramos todos los archivos de la partici´on de booteo y copiamos la imagen de kernel en la SD. $ sudo rm /media/beagleboot/* $ cp arch/arm/boot/uImage /media/beagleboot Para poder grabar el kernel, primero tenemos que decirle a uBoot que inicialice el subsistema MMC OMAP3 beagleboard.org # mmc init

18

Cargamos la imagen en memoria, configuramos el chequeo de sectores defectuosos en la NAND, y grabamos el kernel en la flash. Como en toda memoria flash, antes de escribir se deben borrar todos los bloques. OMAP3 OMAP3 OMAP3 OMAP3

beagleboard.org beagleboard.org beagleboard.org beagleboard.org

# # # #

fatload mmc 0:1 80000000 uImage nandecc sw nand erase 280000 400000 nand write 80000000 280000 400000

Ahora, cada vez que querramos bootear el kernel desde la flash, debemos setear las opciones de booteo OMAP3 beagleboard.org # setenv bootargs console=ttyS2,115200n8 vram=12M root=/dev/mmcblk0p2 rw rootfstype=ext3 rootwait cargar el kernel en RAM OMAP3 beagleboard.org # nand read 80000000 280000 400000 y le decimos que bootee OMAP3 beagleboard.org # bootm 80000000 Todo esto se puede hacer autom´aticamente con el script boot.scr. Creamos el archivo boot.cmd con las tres l´ıneas anteriores, y convertimos este script a un formato legible por uBoot. $ mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n ’Nuestro script de booteo’ -d boot.cmd boot.scr

19

5.

Usando un sistema para crear el rootfs

Objetivo: Aprender c´omo crear un rootfs utilizando la herramienta Buildroot. Nuevamente lo primero es obtener los archivos, en este caso podemos sacarlos de http://www.buildroot.net. A continuaci´on, descomprimimos el archivo $ tar xjf buildroot-2010.08.tar.bz2 $ cd buildroot-2010.08 Y lo configuramos. Las configuraciones que vamos a querer hacer son: Target Architecture (arm) —> Que la arquitectura del target sea ARM Target Architecture Variant (cortex-A8) —> Que la variante de la arquitectura sea Cortex-A8 Target ABI (EABI) —> Que el ABI del target sea EABI Target options —> • Generic serial port config —> Habilitar una consola en el puerto serie ◦ Serial port to run a getty on (ttyS2) —> Consola serie en el dispositivo de caracteres ttyS2 Toolchain —> Que utilice un toolchain externo • Toolchain type: external toolchain • External toolchain C library: uClibc • External toolchain path: /usr/local/xtools/arm-unknown-linux-uclibcgnueabi • Seleccionar las mismas configuraciones que en el toolchain (Large File Support, RPC) Package Selection for the target —> Seleccionar los paquetes que queremos • Busybox Target filesystem options —> Cambiar las opciones de filesystem • ext2 root filesystem • jffs2 root filesystem ◦ Flash Type: NAND flash with 2kB Page and 128 kB erasesize 20

◦ Pad output • tar root filesystem Vamos a necesitar instalar adem´as subversion y gettext. Con esto listo, ahora s´ı compilamos $ make Los archivos de salida quedan en el directorio output/ en particular nos interesar´an las im´agenes. Para pasar la imagen a la SD podemos hacer varias cosas. Lo m´as sencillo es crear una partici´on (fdisk ) y copiar bit a bit la imagen. dd if=output/images/rootfs.ext2 of=/dev/sdb2 Otra opci´on es utilizar el .tar habiendo formateado la SD antes. Entonces: $ $ $ $ $ $

mkfs.ext3 -L rootfs /dev/sdb2 sudo mount /dev/sdb2 /mnt/ sudo cp output/images/rootfs.tar /mnt/ cd /mnt sudo tar xf rootfs.tar sudo rm rootfs.tar Antes de reiniciar pisamos los archivos que ya les dimos armados y listo.

21