HowToInstallLinux < Platforms/Misc

You are here: SedWiki>Platforms/Misc Web>PlatformsObsolete>PekeeRobot>PekeeSystemInfo>HowToInstallLinux (18 May 2005, SorayaArias)Edit Attach

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}

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).

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
   
```

On applique le patch :

$ patch -p0 < patch-ll+pr+hrt+sup-2.4.25

On change le nom du repertoire :
```
$ mv linux-2.4.25 linux-2.4.25-hrt
   
```

On peut alors configurer le noyau :

$ cd linux-2.4.25-hrt
$ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- menuconfig

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

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

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

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

On verifie qu'on a bien le fichier i486-pc-linux-gnu-gcc dans le repertoire ${PREFIX}/bin

GLIBC

On installe alors la glibc contenant les librairies C couramment utilises
```
$ cd ${PRJROOT}/build-tools
$ tar zxvf glibc-2.2.4.tar.gz
   
```

On installe aussi le package linuxthreads

$ tar zxvf glibc-linuxthreads-2.2.4.tar.gz --directory=glibc-2.2.4

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

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 )

On commence par le sauvegarder :

$ cd ${TARGET_PREFIX}/lib
$ cp ./libc.so ./libc.so.orig

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

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

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

On commence par configurer le noyau :

$ cd ${PRJROOT}/kernel/linux-2.4.25-hrt
$ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- menuconfig

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

On construit les modules :

$ make ARCH=i386 CROSS_COMPILE=i486-pc-linux-gnu- modules

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

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

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
   
```

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

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

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.

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.

Ensuite on formate ces partitions :

$ mkswap /dev/sda1
$ mkfs.ext3 /dev/sda2

On monte alors la partition sda2 :
```
$ mount /dev/sda2 /mnt/usbkey
   
```
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.

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)
Puis on ouvre un shell grub :
```
$ grub
   
```
Puis on tape la commande suivante pour installer grub sur la carte memoire :
```
grub> root (hd1,1)
grub> setup (hd1,1)
   
```
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

Platforms/Misc

Copyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding SedWiki? Send feedback