Installation d'un OS linux sur le Pekee

Travail fait par Amaury Negre juil-sept 2004 : cf $ROBOTIQUE/Robots/Pekee/linux/INSTALL

Pour installer Linux sur le PC embarque de Pekee, j'ai suivi la procedure expliquee dans l'ouvrage de Karim Yaghmour "Building Embedded Linux System".

Mise en place de l'organisation du projet

Voici la structure que j'ai utilise pour les dossiers :
  • build-tools : contient les packages et les dossier necessaire pour construire la chaine de cross-compil
  • images : contient les images noyaux
  • rootfs : la racine du systeme de fichier vu par la cible
  • sysapps : applications utilisees sur lq plateforme
  • tools : contient toute la chaine de cross-compilation

Pour simplifier les commandes a venir, il est preferable d'utiliser des variables pour designer les dossiers precedants :

export PROJECT=stpc
export PRJROOT=/scratch/REPNAME/${PROJECT}
export TARGET=i486-pc-linux-gnu
export PREFIX=${PRJROOT}/tools
export TARGET_PREFIX=${PREFIX}/${TARGET}
export PATH=${PREFIX}/bin:${PATH}

Installation du cross-compiler

Les versions des outils utlises dans mon projet sont les suivantes :
  • binutils-2.15
  • gcc-2.95.3
  • glibc-2.2.4

Remarques : j'ai essaye des versions plus recentes de ces outils, mais ayant rencontre des problemes a chaque tentatives, j'en suis reste aux versions ci-dessus.

On cree tout d'abord les dossiers dans build-tools utilise pour compiler les differents outils
$ cd ${PRJROOT}/build-tools
$ mkdir build-binutils build-boot-gcc build-gcc build-glibc

KERNEL HEADERS

Pour construire la tool-chain, il on a tout d'abord besoin des fichiers headers du noyau, on commence donc par desarchiver le noyau. Le noyau que j'ai utilise est linux-2.4.25 avec le patch hrt (low-latency + preemptible + hight-resolution-timer).

  1. On copie donc la tarball et le patch dans le repertoire kernel puis, on desarchive le noyau :
    $ cd ${PRJROOT}/kernel
    $ tar zxvf linux-2.4.25.tar.gz
       
  2. On applique le patch :
    $ patch -p0 < patch-ll+pr+hrt+sup-2.4.25
       
  3. On change le nom du repertoire :
    $ mv linux-2.4.25 linux-2.4.25-hrt
       
  4. On peut alors configurer le noyau :
    $ cd linux-2.4.25-hrt
    $ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- menuconfig
       
  5. On peut maintenant creer le dossier "include" necessaire pour compiler la tool-chain et copier les "kernel headers"
    $ mkdir -p ${TARGET_PREFIX}/include
    $ cp -r include/linux/ ${TARGET_PREFIX}/include
    $ cp -r include/asm-i386/ ${TARGET_PREFIX}/include/asm
    $ cp -r include/asm-generic/ ${TARGET_PREFIX}/include
       

BINUTILS

  1. Ensuite, on compile binutils :
    $ cd ${PRJROOT}/build-tools
    $ tar zxvf binutils-2.15.tar.gz
    
    $ cd build-binutils
    $ ../binutils-2.15/configure --target=$TARGET --prefix=${PREFIX}
    $ make
    $ make install
       
  2. On peut verifier le bon fonctionnement de l'installation :
    $ ls ${PREFIX}/bin
    i486-pc-linux-gnu-addr2line  i486-pc-linux-gnu-nm       i486-pc-linux-gnu-size
    i486-pc-linux-gnu-ar         i486-pc-linux-gnu-objcopy  i486-pc-linux-gnu-string
    s
    i486-pc-linux-gnu-as         i486-pc-linux-gnu-objdump  i486-pc-linux-gnu-strip
    i486-pc-linux-gnu-c++filt    i486-pc-linux-gnu-ranlib
    i486-pc-linux-gnu-ld         i486-pc-linux-gnu-readelf
       

BOOTSTRAP GCC

  1. On construit ensuite le bootstrap gcc
    $ cd ${PRJROOT}/build-tools
    $ tar zxvf gcc-2.95.3.tar.gz
    
    $ cd build-boot-gcc
    $ ../gcc-2.95.3/configure --target=$TARGET --prefix=${PREFIX} \
    > --without-headers --with-newlib --enable-languages=c --host=i686-pc-linux-gnu
    $ make all-gcc
    $ make install-gcc
       
  2. On verifie qu'on a bien le fichier i486-pc-linux-gnu-gcc dans le repertoire ${PREFIX}/bin

GLIBC

  1. On installe alors la glibc contenant les librairies C couramment utilises
    $ cd ${PRJROOT}/build-tools
    $ tar zxvf glibc-2.2.4.tar.gz
       
  2. On installe aussi le package linuxthreads
    $ tar zxvf glibc-linuxthreads-2.2.4.tar.gz --directory=glibc-2.2.4
       
  3. On compile tout ca :
    $ cd build-glibc
    $ CC=i486-pc-linux-gnu-gcc ../glibc-2.2.4/configure --host=$TARGET \
    > --prefix="/usr" --enable-add-ons \
    > --with-headers=${TARGET_PREFIX}/include
    $ make
    $ make install_root=${TARGET_PREFIX} prefix="" install
       
  4. Il faut modifier le fichier libc.so present dans le repertoire ${TARGET_PREFIX}/lib. Le fichier original ressemble a ceci :
    /* GNU ld script
      Use the shared library, but some functions are only in
       the static library, so try that secondarily.  */
    GROUP ( /lib/libc.so.6 /lib/libc_nonshared.a )
    
    1. On commence par le sauvegarder :
      $ cd ${TARGET_PREFIX}/lib
      $ cp ./libc.so ./libc.so.orig
            
    2. Puis on edite le fichier libv.so et on supprime les lib/ :
      /* GNU ld script
         Use the shared library, but some functions are only in
         the static library, so try that secondarily.  */
      GROUP ( libc.so.6 libc_nonshared.a )
            

FULL GCC

  1. On peut alors terminer l'installation de gcc :
    $ cd ${PRJROOT}/build-tools/buid-gcc
    $ ../gcc-2.95.3/configure --target=$TARGET --prefix=${PREFIX} \
    > --enable-languages=c,c++ --host=i686-pc-linux-gnu
    
    $ make all
    $ make install
       
  2. Il ne reste plus qu'a deplacer les binaires et a creer des liens symboliques vers ceux-ci:
    $ cd ${PREFIX}/${TARGET}/bin
    $ mv as ar gcc ld nm ranlib strip \
    > ${PREFIX}/lib/gcc-lib/i486-pc-linux-gnu/2.95.3
    
    $ for file in as ar gcc ld nm ranlib strip
    > do
    > ln -s ${PREFIX}/lib/gcc-lib/i486-pc-linux-gnu/2.95.3/$file .
    > done
       

La chaine de Cross-compilation est maintenant achevee.

Configuration et installation du noyau

  1. On commence par configurer le noyau :
    $ cd ${PRJROOT}/kernel/linux-2.4.25-hrt
    $ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- menuconfig
       
  2. Puis on le compile :
    $ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- clean dep
    $ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- bzImage
       
  3. On construit les modules :
    $ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- modules
       
  4. On peut placer les images dans le repertore ${PRJROOT}/images pour pouvoir tester facilement plusieurs noyaux par la suite :
    $ cp arch/i386/boot/bzImage ${PRJROOT}/images/bzImage-2.4.25-hrt
    $ cp System.map ${PRJROOT}/images/System.map-2.4.25-hrt
    $ cp vmlinux ${PRJROOT}/images/vmlinux-2.4.25-hrt
       
  5. On installe ensuite les modules, dans le repertoire images :
    $ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- \
    > INSTALL_MOD_PATH=${PRJROOT}/images/modules-2.4.25-hrt \
    > modules_install
       

Construction du systeme

  1. Squelette du systeme : Afin d'avoir l'arborescence et les fichiers generiques du systeme, j'ai cree l'archive squelette.tar.gz. On desarchive ce fichier dans ${PRJROOT}/rootfs en mode root pour pouvoir creer les fichiers speciaux
    $ cd ${PRJROOT}/rootfs
    $ su
    Password:
    $ tar zxvf squelette.tar.gz
    $ exit
       
  2. Copie des librairies : Il est indispensable d'installer les librairies partagees de la glibc :
    $ cd ${TARGET_PREFIX)/lib
    $ cp *-*.so ${PRJ_ROOT}/rootfs/lib
    $ cp -d *.so.[*0-9] ${PRJROOT}/rootfs/lib
    $ cp libSegFault.so libmemusage.so libpcprocfile.so \
    > ${PRJROOT}/rootfs/lib
       
  3. Copie du noyau et des modules : On copie le noyau compile precedemment
    $ cd ${PRJROOT}/images
    $ cp bzImage-2.4.25-hrt ${PRJROOT}/rootfs/boot
       
    Puis on copie les modules :
    $ cp -a ${PRJROOT}/images/modules-2.4.25-hrt/* ${PRJROOT}/rootfs
       
  4. Installation de Busybox : Ensuite, j'ai choisi d'utiliser la busybox, qui contient un bon nombre d'utilitaires de base tout en prenant un espace tres faible. J'ai donc les sources de busybox dans ${PRJROOT}/sysapps la version que j'utilise actuellement est la 1.00-rc2, mais des nouvelles versions devraient sortir rapidement...
    $ cd ${PRJROOT}/sysapps
    $ tar zxvf busybox-1.00-rc2.tar.gz
    $ cd busybox-1.00-rc2
    
    $ make menuconfig
       
    Lors de cette configuration, il faut indiquer qu'on utilise un cross-compilateur et mettre la valeur i486-pc-linux-gnu- dans le champ Cross Compiler prefix. Dans les options d'installation, on indique la racine du systeme de fichier ${PRJROOT}/rootfs dans le champ BusyBox installation prefix. Ensuite, on choisit les elements a installer, et on compile le tout :
    $ make all install
       

Copie sur carte memoire et systeme de boot

Copie sur carte memoire

Pour installer le systeme sur la carte smartmedia utilisee dans le pc du robot, j'ai utilise un lecteur de carte usb reconnu sous linux comme lecteur sda.

  1. On commence par partitionner la carte :
    $ fdisk /dev/sda
       
    J'ai cree une premiere partition swap de 32 Mo et une deuxieme au format ext3.
  2. Ensuite on formate ces partitions :
    $ mkswap /dev/sda1
    $ mkfs.ext3 /dev/sda2
       
  3. On monte alors la partition sda2 :
    $ mount /dev/sda2 /mnt/usbkey
       
  4. On copie le systeme :
    $ cp -a ${PRJROOT}/rootfs/*
       

Systeme de boot

Ensuite, il faut rendre la partition bootable, pour cela j'ai utilise le chargeur Grub.

  1. Il faut tout d'abord copier les fichier stage1, stage2, e2fs_stage1_5 et grub.conf dans le repertoire /boot/grub de la carte memoire (ils sont deja present dans le squelette)
  2. Puis on ouvre un shell grub :
    $ grub
       
  3. Puis on tape la commande suivante pour installer grub sur la carte memoire :
    grub> root (hd1,1)
    grub> setup (hd1,1)
       
    HELP hd1 correspond au device de la carte memoire et peut changer suivant la machine

Si tout se passe bien, on peut maintenant demarrer Pekee sous linux...

-- SorayaArias - 18 May 2005
Topic revision: r2 - 18 May 2005, SorayaArias
This site is powered by FoswikiCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding SedWiki? Send feedback