Le Blog du grand loup Zeur » kernel http://blog.gaetan-grigis.eu Le blog qui vous fait connaitre ce que vous savez déjà Sun, 25 Jul 2010 20:48:03 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Compiler android sur ubuntu 9.10 http://blog.gaetan-grigis.eu/android/compiler-android-sur-ubuntu-9-10/ http://blog.gaetan-grigis.eu/android/compiler-android-sur-ubuntu-9-10/#comments Fri, 05 Mar 2010 20:51:54 +0000 Gaëtan http://blog.gaetan-grigis.eu/?p=711 Bijour à tous …
Après quelques semaines sans article, il me fallait du lourd pour affirmer ma virilité mon côté geek … j’ai donc décidé d’écrire un petit truc sur android parce que j’ai rien d’autre à foutre et que je voulais voir tourner mes proc à plein régime …


Pour ce faire il vous faudra :

  1. de la patience
  2. de la patience
  3. de la patience
  4. de la patience
  5. un ordi (facultatif si vous pouvez compiler de tête … pour ma part j’y arrive pas encore :s)
  6. 4Go de ram + un bon CPU
  7. linux

Il vous faudra aussi installer une machine java très ancienne (1.5) à télécharger ici. Installez-là en mode utilisateur simple dans un dossier dédié à la compilation d’android, chez moi : ~/Android/.

Ensuite, le super script, les quelques variables au début du fichier sont à modifier, le reste est automatisé.
Ce que fait le script :

      Téléchargement du fichier repo
      Récupération/Mise à jour du dépot d’android (très lourd, il faut 1 heures pour dl 2Giga de données)
      Compilation des sources d’android (tout les binaires, … c’est très long)
      et c’est tout!!

Faudra quand même attendre 3 ou 4 heures lors de la première compilation/récupération des fichiers…

  1. #!/bin/bash
  2. JDK15=/home/$USER/Documents/Android/jdk1.5.0_21/bin
  3. BINDIR=/home/$USER/Documents/Android
  4. MYDROID=/home/$USER/Documents/Android/mydroid
  5. TYPE_MACHINE=`uname -m`
  6. PATH=$JDK15:$PATH
  7. #Need 1.5 https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewProductDetail-Start?ProductRef=jdk-1.5.0_21-oth-JPR@CDS-CDS_Developer
  8. ##############DON'T TOUCH BELOW… OR SUFFER HUNDREDS PAINS … MUUAAHAHAHAHAHAHAHAHAAHAHHAAAA
  9. echo "Lancement de SIACAKDLM"
  10. echo "Système d'install automatisé de compilation d'android pour kikoolol dépressif en 1337n355 mode"
  11. echo "Temps requis pour arriver à la fin de ce script après execution : 2h00"
  12. echo "Installation des fichiers requis …"
  13. sudo apt-get -yqq install git-core gnupg sun-java6-jdk flex bison gperf libsdl-dev ncurses-dev libesd0-dev libwxgtk2.6-dev build-essential zip curl libncurses5-dev zlib1g-dev valgrind
  14. if [ $TYPE_MACHINE == "x86_64" ]
  15. then
  16. echo "Zetes en 64bits … on en rajoute une couche ;) "
  17. sudo apt-get -yqq install ia32-libs lib32z1-dev lib32ncurses5-dev gcc-multilib g++-multilib lib32readline5-dev
  18. fi
  19. if [ ! -f $BINDIR/repo ]
  20. then
  21. echo "Récupération du fichier repo"
  22. wget -qO $BINDIR/repo http://android.git.kernel.org/repo && chmod +x $BINDIR/repo
  23. fi
  24. if [ ! -d $MYDROID ]
  25. then
  26. echo "Création du dossier $MYDROID"
  27. mkdir $MYDROID
  28. fi
  29. cd $MYDROID
  30. if [ ! -d $MYDROID/prebuilt/ ]
  31. then
  32. $BINDIR/repo init -u git://android.git.kernel.org/platform/manifest.git
  33. fi
  34. echo "Mise à jour du dépôt … ça prend du temps … beaucoup de temps :s"
  35. $BINDIR/repo sync
  36. export CCOMPILER=$MYDROID/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin/arm-eabi-
  37.  
  38. cd $MYDROID && source build/envsetup.sh && sed -n -e "s/^add_lunch_combo//gp" vendor/*/vendorsetup.sh && lunch generic-eng && make -j4

Les fichiers de sorties de trouvent dans : $MYDROID/out/target/product/generic (les .img contiennent l’os , les logiciels et tout le bazard qu’embarque android).
Voilà, laisser mouliner, puis tester-le en machine virtuelle avant l’install sur votre phone (en n’oubliant pas bien sûr de faire une sauvegarde ;) ).

Pour tester votre système android fraichement compilé, il vous suffit d’utiliser AVD (fournit avec le SDK de dev de google), d’aller dans le dossier .android/avd/le nom d’une machine générée/, et d’y mettre votre image système (et vos autres img si ça vous chante).

Ce qui m’a donné la version éclair pour mon émulateur :

Quelques liens sympa (dont je me suis grandement inspirés, que j’ai plagiés) :

  1. [EN]Explicatif sur le fonctionnement d’android
  2. Article plus poussé en français d’unixgarden
  3. L’astuce pour tester son system.img
  4. le tuto de compilation de cyanogen + packaging pour aller plus haut loin

La compilation et l’installation d’un cyanogenmod sera pour plus tard ;)

Articles similaires :

Copyright © 2008-2010 - Gaetan Grigis - blog.gaetan-grigis.eu ]]> http://blog.gaetan-grigis.eu/android/compiler-android-sur-ubuntu-9-10/feed/ 0 Monter un cluster avec kerrighed sur son réseau http://blog.gaetan-grigis.eu/systeme/monter-un-cluster-avec-kerrighed-sur-son-reseau/ http://blog.gaetan-grigis.eu/systeme/monter-un-cluster-avec-kerrighed-sur-son-reseau/#comments Sat, 19 Dec 2009 18:50:54 +0000 Gaëtan http://blog.gaetan-grigis.eu/?p=637 Plopinou … encore un article de type « retour d’expérience geek »
Temps : 2h (en compilant le tout avec un AMD 3000+)
Niveau : Noob (faut quand même savoir jouer à WoW le temps de la compil’ qui peut prendre 1 heures)

Le but de cette technique était de recycler quelques PC sur mon réseau et gagner en puissance de calcul avec de vieux AMD 3000+ avec 1Go de ram.

Kerrighed est un cluster de type « Grappe de serveur » qui permet un truc assez sympa, il suffit que l’ensemble des machines du réseau utilisent le kernel modifié (un 2.6.20 obligatoire …) pour que l’ensemble de ces machines puissent être emulées comme une seul machine SMP partageant donc le CPU et la RAM des machines, assez sympa pour des logiciels qui bouffent de la ram et du cpu (genre firefox ?? xD).

Le gros intéret de ce type de réseaux face à des solutions comme les systèmes MPI est qu’il n’y a pas besoin d’avoir des logiciels spécifique qui utilisent l’interface en question, ici la plupart des softs qui peuvent tourner sur du kernel SMP (qui devient assez commun sur les dernières machine multi-core pour partager les calculs entre les cores d’une même machine) peuvent être susceptible d’utiliser le CPU/RAM des autres ordi.

Alors bon … d’un côté ça parait super intéressant de pouvoir ajouter la puissance de nos anciens PC, d’un autre ont se dit … c’est naze, faut installer le kernel à la main sur chacune de ces machines, de quoi repousser n’importe qu’elle geek en puissance devant le travail à fournir …

C’est là qu’intervient un truc super sympa que l’iut de stras utilisait pour faire booter les terminaux X (et que d’autre utilisent surement). Utiliser une machine comme serveur dhcp,nfs,tftpd-hpa pour faire booter d’autres machines sur un réseau (en clair, on installe le système sur une machine, et toute les autres boot dessus, permettant même de d’utiliser des machines sans disque dur, comme ça on peut ce faire une machine qui prend tt les dd et les partager sur le réseau et pouvoir rajouter une nouvelle machine en la connectant simplement au réseau et en la bootant dessus).

Pour ça, j’ai suivi un superbe tuto (en anglais, et pas trop vieux en plus) que je vais traduire et commenter avec mes superbes retour d’expériences ^^.

L’architecture :

J’ai ma machine HOST (serveur nfs,dhcp,tftpd, …) sur laquelle je fait toute mes manipulations, avec deux interfaces, la première connectée au net (histoire de pouvoir mettre à jour la machine), et la seconde connectée à mon réseau de cluster, qui a besoin d’un réseau à part, puisque j’utilise un serveur DHCP dédié à l’adressage de ces machines.

Donc voilà, pour les IPs : 192.168.0.1 est mon serveur principal, 192.168.0.10 et 192.168.0.11 sont mes deux nodes qui vont booter sur le réseaux.

L’ensemble des manipulations à suivre ce faisant depuis 192.168.0.1 (nommé HOST).

La première commande :

  1. apt-get install dhcp3-server tftpd-hpa portmap syslinux nfs-kernel-server nfs-common debootstrap

qui permettra d’installer l’ensemble des softs nécessaire à notre cluster.

Puis on modifie le fichier /etc/default/dhcp3-server et on spécifie l’interface sur laquelle est connecté notre cluster (eth0 étant ma connexion au net) :

  1. INTERFACES="eth1"

Puis le fichier /etc/dhcp3/dhcpd.conf

  1. # General options
  2. option dhcp-max-message-size 2048;
  3. use-host-decl-names on;
  4. deny unknown-clients;
  5. deny bootp;
  6.  
  7. option domain-name "cluster.lan";
  8. option domain-name-servers 192.168.0.1;
  9.  
  10. subnet 192.168.0.0 netmask 255.255.255.0 {
  11. option routers 192.168.0.1;
  12. option broadcast-address 192.168.0.255;
  13. }
  14.  
  15. group {
  16. filename "pxelinux.0";
  17. option root-path "192.168.0.11:/nfsroot/kerrighed";
  18.  
  19. host node1 {
  20. fixed-address 192.168.0.10;
  21. hardware ethernet 11:33:22:55:44:66;#à remplacer par l'adresse mac de votre machine 1
  22. }
  23. host node2 {
  24. fixed-address 192.168.0.11;
  25. hardware ethernet 11:22:33:44:55:66;#à remplacer par l'adresse mac de votre machine 2
  26. }
  27.  
  28. server-name "host";
  29. next-server 192.168.0.1; # Server IP
  30. }

On permet le lancement en daemon de tftp au démarrage de la machine en modifiant /etc/default/tftp-hpa

  1. RUN_DAEMON="yes"
  2. OPTIONS="-l -s /var/lib/tftpboot"

On copie notre loader pxe

  1. cp /usr/lib/syslinux/pxelinux.0 /var/lib/tftpboot

On créer notre dossier de conf :

  1. mkdir -p /var/lib/tftpboot/pxelinux.cfg

Et on edit notre fichier de boot réseau dans /var/lib/tftpboot/pxelinux.cfg/default :

  1. LABEL linux
  2. KERNEL vmlinuz-2.6.20-krg
  3. APPEND console=tty1 root=/dev/nfs nfsroot=192.168.0.1:/nfsroot/kerrighed ip=dhcp rw session_id=1

Maintenant que notre boot est prêt, il faut créer le système sur lequel les autres machines vont booter :

  1. mkdir -p /nfsroot/kerrighed

On prépare l’import en éditant le fichier /etc/exports :

  1. /nfsroot/kerrighed 192.168.0.1/255.255.255.0(rw,no_subtree_check,async,no_root_squash)

Puis un coup de

  1. exportfs -avr && debootstrap – -arch i386 lenny /nfsroot/kerrighed http://ftp.fr.debian.org/debian

Qui peut prendre un bon bout de temps (z’avez le temps de faire un warsong voir même une instance de 30 minutes sur WoW ^^) … puis on fait un coup de

  1. chroot /nfsroot/kerrighed

Pour changer les fichiers de config de notre « nouvelle machine » :

  1. mount -t proc none /proc && mkdir /config && mount -t configfs none /config && apt-get update && export LC_ALL=C && apt-get install dhcp3-common nfs-common nfsbooted openssh-server && ln -sf /etc/network/if-up.d/mountnfs /etc/rcS.d/S34mountnfs &&  apt-get install automake autoconf libtool pkg-config gawk rsync bzip2 libncurses5 libncurses5-dev wget lsb-release xmlto patchutils xutils-dev build-essential subversion && svn checkout svn://scm.gforge.inria.fr/svn/kerrighed/trunk /usr/src/kerrighed -r 5426

Puis modification du /etc/fstab

  1. proc /proc proc defaults 0 0
  2. /dev/nfs / nfs defaults 0 0
  3. configfs /config configfs defaults 0 0

On passe par /etc/network/interfaces pour configurer notre réseau … pour moi :

  1. auto lo
  2. iface lo inet loopback
  3. iface eth0 inet dhcp

Une fois que la plupart des configs sont faites, on peut passer par la compilation du kernel kerrighed.

  1. wget -O /usr/src/linux-2.6.20.tar.bz2 http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.20.tar.bz2 && cd /usr/src/kerrighed && ./autogen.sh && ./configure && cd kernel && make defconfig && make menuconfig

Dans le menu ‘super ecran bleu’ :
Allez dans « Device Drivers » puis « Network device support » et choisir sa carte réseau (sinon vous n’arriverez pas à monter le root une fois le kernel booté).
Revenir au premier menu et choisir « File systems » puis « Network File Systems » et permettre le nfsV3.
On quitte et on sauvegarde la configuration (en cliquant sur « exit »).

On reprend nos commandes (on peut faire un match sur HoN là, y’en a pour une heure) :

  1. cd .. && make kernel && make && make kernel-install && make install && ldconfig

On continue la configuration de notre systèmes en modifiant le fichier /etc/kerrighed_nodes

  1. session=1 #entre 1 et 254
  2. nbmin=1 #nombre de node minimal pour kerrighed.
  3. 192.168.0.10;1:eth0
  4. 192.168.0.11:2:eth0

et on termine ici en modifiant /etc/default/kerrighed

  1. ENABLE=true

on quitte notre chroot par un superbe :

  1. exit

On copie notre « booter » dans le boot et on redémarre tout nos soft :

  1. cp /nfsroot/kerrighed/boot/vmlinuz-2.6.20-krg /var/lib/tftpboot/ && /etc/init.d/tftpd-hpa start && /etc/init.d/dhcp3-server start && /etc/init.d/portmap start && /etc/init.d/nfs-kernel-server restart

A partir de maintenant, toute machine bootant en réseau sera capable d’utiliser le kernel compilé. (assez sympa en cyber café, ou … ;) ).

Par contre une fois lancer, il ne faut pas oublier d’autoriser la migration des processus en se connectant sur l’une des nodes :

  1. krgadm nodes && krgadm cluster start && /usr/local/bin/krg_legacy_scheduler && krgcapset -d +CAN_MIGRATE && krgcapset -k $$ -d +CAN_MIGRATE && krgcapset -d +USE_REMOTE_MEMORY && krgcapset -k $$ –inheritable-effective +CAN_MIGRATE

Et voilà … les geeks en puissance vont pouvoir faire revivre leurs premières machines ^^ (et les terminer dignement xD)

Articles similaires :

Copyright © 2008-2010 - Gaetan Grigis - blog.gaetan-grigis.eu ]]> http://blog.gaetan-grigis.eu/systeme/monter-un-cluster-avec-kerrighed-sur-son-reseau/feed/ 9