Fedora-Fr - Communauté francophone Fedora - Linux

Planet de Fedora-Fr : la communauté francophone autour de la distribution Linux Fedora

A propos

Cette page est actualisée toutes les heures.

Cette page est une sélection de blogs autour de Fedora. Fedora-Fr.org décline toute responsabilité au sujet des propos tenus par les auteurs des blogs de ce planet. Leurs propos sont leur entière responsabilité.

Le contenu de ce planet appartient à leurs auteurs respectifs. Merci de consulter leur blogs pour obtenir les licences respectives.

Compte-rendu de l'Assemblée Générale Extraordinaire du 22 juillet

Emmanuel Seyman

Le 22 juillet, les adhérents de Fedora-Fr étaient conviés à la Cité des Sciences pour une Assemblé Générale Extraordinaire. Plusieurs points étaient à l'ordre du jour. Je vous propose un petit compte-rendu de l'évènement.

Le 22 juillet, les adhérents de Fedora-Fr étaient conviés à la Cité des Sciences pour une Assemblé Générale Extraordinaire. Plusieurs points étaient à l'ordre du jour.

Le premier était le changement de nom de l'association. Le projet Fedora nous demandait depuis quelques temps de changer le nom de l'association. Fedora étant une marque déposée, il faut leur autorisation pour l'utiliser et Fedora ne souhaite pas déléguer l'utilisation de son nom. En plus, le nom Fedora-Fr leur interdit de nous subventionner (le Fisc américain risquant de prendre ça pour de la fraude fiscale).

Ayant consulté la communauté, nous avions retenu trois noms (Yuzimo, Trilby, Borsalinux) avec, en option, un suffixe "-fr" pour marquer le côté francophone de l'association. Les adhérants ont choisi Borsalinux puis de garder le suffixe. L'association Fedora-Fr s'appelle donc désormais Borsalinux-Fr.

Depuis quelques années, nous avions accumulé un certain nombre de modifications aux statuts. Changer de nom implique un changement de statuts et nous avons profité de l'occasion pour voter ces modifications. S'il y en a qu'une à retenir, c'est que l'association a maintenant la possibilité de se réunir via un moyen électronique (là ou avant, les réunions était forcément physiques).

Enfin, on a discuté de reprendre le rôle de distributeur des DVDs de Fedora. En effet, Kevin venait tout juste de recevoir les DVDs de Fedora et on était tous d'accord pour dire que c'est dommage d'attendre 2 mois pour avoir des DVDs à distribuer.

L'assemblée clos, nous avons traversé la rue pour prendre un verre.

Anna Ternheim est de retour avec The Night Visitor !

Sébastien Natroll J’ai bien conscience que je serai l’un des seuls (sinon le seul) blogueur français à en parler. Qu’importe, j’en fais ma fierté. Dans 61 jours, elle sera de retour. Je parle bien sûr de la Suédoise la plus talentueuse de toutes : Anna Ternheim. Elle nous avait quitté en 2008 en nous laissant son petit La suite >

Configurer Mutt pour gmail

Patrice Ferlet

Il est évident que nous ne sommes pas tous accrocs aux outils en mode texte (dans un terminal) mais personnellement j'y trouve mon compte: vitesse, exécution claire, lisibilité... et modularité. Je suis un Google Fan (houuu je vais m'en prendre plein la poire moi) et j'ai beaucoup de mes données sur Google: mail, documents, agenda... Voici donc comment pouvoir envoyer des mails et lire ces derniers convenablement avec Mutt, y compris l'autocompletion des contacts Gmail

La configuration ne sera pas compliqué. Il faudra juste se farcir 3 fichiers de configurations:

  • un pour mutt lui même, configuration du compte
  • un pour permettre les macros de lecture de mail en HTML
  • un fichier netrc pour permettre à goobook de fonctionner

Bref, passons en premier lieu à l'installation proprement dite des logiciels:

su -c "yum install mutt python-setuptools links"
easy_install goobook

Le première commande installe mutt et les utilitaires pytyon pour installer un paquet python, puis links, le lecteur html en console. L'autre installe goobook, un outil qui permet de récupérer un carnet d'adresse google.

Goobook est un outil python que j'ai testé après en avoir essayé plusieurs, c'est de loin le plus pratique et le plus abouti que je connaisse. Vous pouvez voir la page du projet ici: http://pypi.python.org/pypi/goobook...

Maintenant, passons à la configuration de Mutt

#fichier ~/.muttrc

#enregistre les messages envoyés et brouillons dans Gmail
set record="+[Gmail]/Messages envoyés"
set postponed="+[Gmail]/Brouillons"

#configuration du serveur
set hostname=gmail.com
my_hdr From: PRENOM NOM <USER@gmail.com>
set use_envelope_from
set envelope_from_address="USER@gmail.com"

unignore Date Message-ID In-Reply-To

set move=no
set spoolfile=imaps://imap.gmail.com:993/INBOX
set imap_user = "USER@gmail.com"
set imap_pass= "VOTRE MOT DE PASSE"
set imap_authenticators="login"
set imap_passive="no"
set folder="imaps://imap.gmail.com:993"
set imap_check_subscribed="yes"
set imap_list_subscribed="yes"

set smtp_url="smtps://USER:VOTRE MOT DE PASSE@smtp.gmail.com:465"
set ssl_starttls="yes"

set locale="fr_FR"
set date_format="%A %d %b %Y à %H:%M:%S (%Z)"
set attribution="Le %d, %n à écrit:"
set forward_format="[Fwd: %s]"
set forward_quote

mailboxes !

set pager_index_lines="7"
set pager_stop

#gérer un cache
set message_cachedir="~/.mutt_msg_cache"
set header_cache="~/.mutt_header_cache"

#force l'utilisation d'un programme exterieur pour les mails en HTML
auto_view text/html

#et ici la config pour les contacts
set query_command="goobook query '%s'"
bind editor <Tab> complete-query
macro index,pager a "<pipe-message>goobook add<return>" "add the sender address to Google contacts"

Et enfin il faut configurer les commandes pour lire les mails HTML:

#fichier ~/.mailcap
text/html;  links %s; nametemplate=%s.html
text/html;  links -dump %s; nametemplate=%s.html; copiousoutput

Bien. Reste à gérer goobook, on commence par créer un fichier:

#~/.netrc
machine google.com
    login USER@gmail.com
    password Votre Mot de passe

Voilà, testez rapidement que ça passe en tapant:

goobook reload
goobook query un_nom_au_choix

Et bien voilà, lancez maintenant la commande mutt et appréciez un peu la lecture de mail dans un terminal.

Souvenez vous de quelques racourcis:

  • Maj+D pour supprimer un ensemble de mail correspondant à un motif que vous tapez (par exemple si vous tapez microsoft, tout les mails correspondants seront marqué comme "à supprimer")
  • d pour supprimer le message sélectionné
  • m pour envoyer un message (les contacts sont auto complétés via la touche tabulation)
  • r pour répondre
  • c por changer de dossier de mail
  • / pour chercher un mail, selon le nom, le sujet...
  • $ pour valider les changements (suppressions)

Voilà, personnellement j'ai adopté mutt et j'en suis très content. Je classe et nettoie ma boite mail en 4 fois moins de temps qu'avant.

Notez que nous pourrons ensuite utiliser mcabber pour tchater avec nos contacts google :)" class="smiley on en reparlera

EDIT: j'ai supprimé la phase de création de goobookrc qui est inutile en fait...

sécurisation d'une connexion ssh

Frédéric Thouin

Un simple logiciel est c'est "finit", certe cela ne fait pas tout mais ca permet de stopper les attaques en brute de force. j'ai nommé fail2ban

Le principe est simple, il regarde les fichiers de log sur les erreurs de login, et si une ip se trompe trop de fois dans une authentification SSH fail2ban demande à Shorewall de modifier dynamiquement NETFILTER pour ajouter aux règles du firewall l'IP incriminée en lui interdisant laccès.

Instalation :

yum install fail2ban

Les fichiers de conf :

/etc/fail2ban/fail2ban.conf

Permet de configurer le comportement general de fail2ban.

/etc/fail2ban/jail.conf

Permet de configurer les services surveillées par fail2ban, indiqué la durée de bannissement, etc..

Linux a 20 ans !

Patrice Kadionik

Salut.

Il y a tout juste 20 ans exactement (le 25 août 1991 à 20:57:08 GMT), Linus Torvalds postait son message mythique sur le newsgroup comp.os.minix :

From: torvalds@klaava.Helsinki.FI (Linus Benedict Torvalds)
Newsgroups: comp.os.minix
Subject: What would you like to see most in minix?
Summary: small poll for my new operating system
Message-ID:
Date: 25 Aug 91 20:57:08 GMT
Organization: University of Helsinki

Hello everybody out there using minix -

Im doing a (free) operating system (just a hobby, wont be big and
professional like gnu) for 386(486) AT clones. This has been brewing
since april, and is starting to get ready. Id like any feedback on
things people like/dislike in minix, as my OS resembles it somewhat
(same physical layout of the file-system (due to practical reasons)
among other things).

Ive currently ported bash(1.08) and gcc(1.40), and things seem to work.
This implies that Ill get something practical within a few months, and
Id like to know what features most people would want. Any suggestions
are welcome, but I wont promise Ill implement them :-)

Linus (torvalds@kruuna.helsinki.fi)


Bon anniversaire Linux !



++

Nouvelle FAQ

Remi Collet

Avez vous remarqué la nouvelle page FAQ en français, dans le menu de droite ?

Je compte l'alimenter au fur et à mesure des questions que je trouverais intéressantes ou récurrentes. N'hésitez pas à poster des commentaires sur ce billet pour me faire part de vos remarques, corrections : il y a tellement de choses que j'ai probablement oubliées, peut-être parce qu'elles me semblent triviales...... Lire Nouvelle FAQ

Comment stocker dans un tableau le résultat de la command find ?

Jonathan Mercier

Bonjour, Ce billet est destiné de prime a bord à être un pense bête, mais sait on jamais si des personnes ont le même beson. Comme annoncer dans le titre le bout de code suivant permet de récupérer les informations retourner par la commande find.


  1. unset result index
  2. while IFS= read -r -u3 -d $'\0' file; do
  3. result[index++]="$file"
  4. done 3< <(find . -type f -print0)
  5. echo ${result[0]}

La première ligne permet de supprimer les éventuels déclarations de ces variables. Le bloc while permet de lire la sortie standard qui est redirigé par l'opérateur <<. Ainsi fichier après fichier découvert par la commande find la variable index est incrémenté afin de stocker le résultat à l'index suivant du tableau.

En espérant que ce petit bout de code puisse aider un jour

Signé: bioinfornatics, Jonathan MERCIER

mini2440. Séance 8 : bilan... provisoire

Patrice Kadionik

Salut.

Pour cette séance 8 de mise en oeuvre de la carte mini2440, nous allons faire un bilan provisoire...

Nous avons pu voir au cours de 7 séances la construction détaillée et pas à pas d'un système Linux embarqué pour la carte mini2440 :

  • Séance 1 : mise en place de l'environnement de compilation croisée
  • Séance 2 : compilation et programmation du bootloader u-boot
  • Séance 3 : construction d'un système de fichiers root minimal
  • Séance 4 : configuration et compilation de busybox
  • Séance 5 : configuration et compilation du noyau Linux
  • Séance 6 : configuration et compilation de la bibliothèque tslib pour l'écran tactile
  • Séance 7 : configuration et compilation de Qt

La carte mini2440 offre d'autres ressources à explorer comme les GPIO, l'I2C, le SPI..., ce qui fera l'objet d'autres futurs billets.

Ces 7 séances doivent vous permettre maintenant dappréhender sereinement l'environnement Linux embarqué pour cette carte cible.

Une phase d'optimisation est de diminuer le temps de boot. Cela fera l'objet d'un prochain billet pour donner des références sur cet exercice particulier...

++

php-5.3.8

Remi Collet

Les RPM de la version finale de PHP 5.3.8 sont disponibles pour Fedora et pour Enterprise Linux (RHEL/CentOS) dans le dépôt remi. Cette version sera aussi très prochainement dans les mises à jour pour fedora ≥ 14 (après le passage en testing).

Lire l'annonce de cette version : PHP 5.3.8 Released!

Cette version corrige plusieurs problèmes de sécurité. La mise à jour est recommandée.

Utilisez YUM pour les installer : yum --enablerepo=remi update php-\* A noter : le package php fournit désolrmais les 2 extensions pour apache, en mode prefork ou en mode worker. Le paquet php-zts est donc supprimé. Pour fedora ≥ 12 et EL-5, la nouvelle extension php-fpm est disponible (une alternative à php-cgi). Voir les billets PHP-FPM et... Lire php-5.3.8

La fin de l’Internet illimité n’est que partie remise !

Sébastien Natroll Le 19 août dernier, Owni mettait la main sur un document de la Fédération Française des Télécoms. L’hydre à 3 têtes de l’Internet français, à savoir Orange, SFR, et Bouygues Télécom s’apprêtaient à mettre fin à l’Internet illimité. Concrètement, il s’agissait de plafonner (comme sur les mobiles) la consommation. Par exemple, n’autoriser que 250 Go La suite >

mini2440. Séance 7 : configuration et compilation de Qt/embedded

Patrice Kadionik

Salut.

Pour cette séance 7 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler Qt pour la carte mini2440. Nous avons ici utilisé un écran 7" de type A70. Qt utilise la bibliothèque tslib précédemment compilée.

On installe dans un premier temps les sources de Qt disponibles ici :

$ cd mini2440
$ tar -xvzf qt-everywhere-opensource-src-4.7.3.tar.gz

On configurera Qt avec le shell script goconfig :

$ cd qt-everywhere-opensource-src-4.7.3 
$ unset $CC
$ unset $CROSS_COMPILE
$ cat goconfig
./configure \
-embedded arm \
-xplatform qws/linux-arm-g++ \
-prefix /usr/local/qt \
-qt-mouse-tslib \
-little-endian
$ ./goconfig

On notera que linstallation ne se fera pas directement dans le système de fichiers root sous root_fs/ mais dans le répertoire absolu /usr/local/qt/ du PC hôte. Il faut procéder comme cela car Qt/embedded aura codé en dur ces chemins absolus et lon ne peut pas avoir un chemin en /home/… sous peine de non fonctionnement.

Il convient de modifier le fichier qt-everywhere-opensource-src-4.7.3/mkspecs/qws/linux-arm-g++/qmake.conf en suivant les indications dans le document Upgrade Qt4.6.2 in mini2440. On obtient au final le fichier qt-everywhere-opensource-src-4.7.3/mkspecs/qws/linux-arm-g++/qmake.conf suivant.

On compilera Qt avec le shell script go :

$ cat go
make
$ unset $CC
$ unset $CROSS_COMPILE
$ ./go

La compilation prend plusieurs dizaines de minutes… Il faut prendre garde à bien supprimer les variables denvironnement  $CC et $CROSS_COMPILE que l'on avait définies lors de la séance 1.

On installera Qt avec le shell script goinstall sous /usr/local/qt/ du PC hôte en étant superutilisateur :

$ cat goinstall
make install
$ su
# ./goinstall

Qt sera installé dans le système de fichiers root sous root_fs/ : cp -r /usr/local/qt/lib/* ./root_fs/usr/local/qt/lib/

Il faut au préalable configurer des variables denvironnement pour Qt en plus de celles pour tslib comme on a pu le voir lors de la séance 6. On placera ces variables denvironnement dans le fichier root_fs/etc/init.d/rcS :

# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

# Set Qt environment
export QWS_MOUSE_PROTO=tslib:/dev/input/event0
# Ecran 7" A70
export QWS_DISPLAY=LinuxFB:mmWidth=310:mmHeight=190
# Ecran 3"1/2 T35 #export QWS_DISPLAY=LinuxFB:mmWidth=160:mmHeight=100
export QWS_SIZE=800x480
export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib
export QTDIR=/usr/local/qt

if [ -f /etc/pointercal ]; then
echo "Touchscreen already calibrated..."
else
echo "Calibrating Touchscreen..."
/usr/local/tslib/bin/ts_calibrate
fi

On placera aussi ces variables denvironnement dans le fichier root_fs/etc/profile pour quelles soient renseignées quand on accède au shell Linux de la carte mini2440 :

$ cat root_fs/etc/profile
USER="`id -un`"
LOGNAME=$USER
PS1='[\u@\h \W]\# '

# PATH
PATH=/usr/local/jamvm/bin:/usr/local/tslib/bin/:$PATH
HOSTNAME=`/bin/hostname`
export USER LOGNAME PS1 PATH HOSTNAME

# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

# Set Qt environment
export QWS_MOUSE_PROTO=tslib:/dev/input/event0
# Ecran 3"1/2 T35 #export QWS_DISPLAY=LinuxFB:mmWidth=160:mmHeight=100
# Ecran 7" A70 export QWS_DISPLAY=LinuxFB:mmWidth=310:mmHeight=190
export QWS_SIZE=800x480

export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib
export QTDIR=/usr/local/qt

Le test de fonctionnement de Qt a été réalisé sur la carte mini2440 avec le système de fichiers root complet mis à jour en utilisant lapplication de démonstration Nokia patientcare exécutée sur la carte mini2440 :

# ./patientcare –qws

08-07-11_1749.jpg

28-06-11_1442.jpg

Il faut noter que l'on utilise ici le framebuffer qui a été validé lors de la configuration du noyau Linux...

Nous avons donc au final un système Linux embarqué opérationnel et minimal pour la carte mini2440 avec Qt et tslib pour pouvoir utiliser l'écran tactile (A70 pour ces séances).

Prochaine séance : petit bilan sur la mise en oeuvre de la carte mini2440...

++

Sources :

mini2440. Séance 6 : configuration et compilation de la bibliothèque tslib pour l'écran tactile

Patrice Kadionik

Salut.

Pour cette séance 6 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler la bibliothèque tslib pour l'écran tactile de la carte mini2440. Nous avons ici utilisé un écran 7" de type A70.

On installe dans un premier temps les sources de tslib :

$ cd mini2440
$ git clone http://github.com/kergoth/tslib.git

On  procédera comme précédemment maintenant. On configurera tslib avec le shell script goconfig :

$ cd tslib
$ cat goconfig
./autogen.sh
./configure --host=arm-none-linux-gnueabi --prefix=/usr/local/tslib --enable-static --enable-shared
$ ./goconfig

On notera que linstallation ne se fera pas directement dans le système de fichiers root sous root_fs/ mais dans le répertoire absolu /usr/local/tslib/ du PC hôte. Il faut procéder comme cela car Qt/embedded aura codé en dur ces chemins absolus et lon ne peut pas avoir un chemin en /home/… comme précédemment sous peine de non fonctionnement.

On compilera tslib avec le shell script go :

$ cat go
make
$ ./go

On installera tslib avec le shell script goinstall sous /usr/local/tslib/ du PC hôte en étant superutilisateur :

$ cat goinstall
make install
$ su
# ./goinstall

tslib sera installé dans le système de fichiers root sous root_fs/ :

$ cd mini2440
$ su
# cp -r /usr/local/tslib/* ./root_fs/usr/local/tslib/
On créera un fichier ts.conf dont le contenu est le suivant que l'on mettra sous ./root_fs/usr/local/tslib/etc :
module_raw input
module pthres pmin=1
module variance delta=30
module dejitter delta=100
module linear
Il faut au préalable configurer des variables denvironnement pour tslib. On placera ces variables denvironnement dans le fichier root_fs/etc/init.d/rcS :
# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib

if [ -f /etc/pointercal ]; then
echo "Touchscreen already calibrated..."
else
echo "Calibrating Touchscreen..."
/usr/local/tslib/bin/ts_calibrate
fi
On placera aussi ces variables denvironnement dans le fichier root_fs/etc/profile pour quelles soient renseignées quand on accède au shell Linux de la carte mini2440 :
PATH=/usr/local/tslib/bin/:$PATH 
HOSTNAME=`/bin/hostname`
export USER LOGNAME PS1 PATH HOSTNAME

# Set tslib environment
export TSLIB_TSEVENTTYPE=INPUT
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/etc/pointercal
export TSLIB_CONFFILE=/usr/local/tslib/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/local/tslib/lib/ts

export LD_LIBRARY_PATH=/usr/local/tslib/lib:/usr/local/qt/lib:/lib:/usr/lib
On mettra à jour le système de fichiers root de la carte mini2440 soit en NAND Flash, soit sur la carte SD.
On reboote la carte. Si on lance la commande ts_calibrate, on voit apparaître la fenêtre suivante :
# ts_calibrate

calibrate.png

Il faut noter que l'on utilise ici le framebuffer qui a été validé lors de la configuration du noyau Linux...

Prochaine séance : configuration et compilation de Qt/embedded pour la carte mini2440...

++

Sources :

Ajouter un de ses scripts au menu Applications de Gnome-Shell

Tom Dubin Lorsque lon utilise souvent ses propres scripts ou des logiciels non packagés, on na pas forcément envie dutiliser la ligne de commande pour les lancer. Voici comment créer un lanceur simplement. Ce launcher est un fichier .desktop qui peut se trouver soit dans ~/.local/share/applications/ si on veut que le lanceur soit visible uniquement de notre [...]

Xmonad, le bureau productif orienté terminal

Patrice Ferlet

Vous utilisez certainement Gnome, KDE, ou XFCE (entre autre) pour afficher vos programmes. Le gestionnaire de fenêtre vous permet de déplacer le programme sur votre écran via la souris, vous avez des menus, des racourcis qui vous permettent de gérer tout ça. Je ne critique pas ce principe, il est pratique, assez standard et bien adapté à la plupart des utilisateurs. Mais nous ne sommes pas tous identiques. Certains, comme moi, utilisent surtout des terminaux, et n'aiment pas devoir passer la main du clavier à la souris pour gérer son espace de travail. Pire encore, nous n'avons en général pas besoin de la barre de titre, et devoir placer les fenêtres sur le bureau est une chose qui peut vraiment être un frein à la productivité.

Outre le coté production, il y a l'ergonomie. L'ergnonomie ne signifie pas forcément "pouvoir tout déplacer à la souris et avoir plein d'infos sur les fenêtres". En fait, tout est relatif. Si un bureau me propose de placer mes fenêtres et que j'ai juste les informations nécessaires, je trouve cela ergonomique. Car je n'ai finalement que ce dont j'ai besoin. Mais sans pour autant me limiter, car dans tous les cas, je peux retrouver les informations supplémentaires si je connais mon outil.

Je trouve le terminal ergonomique. Ça peut vous étonner, mais la plupart des utilisateurs du terminal qui ont passé un peu de temps à apprendre à s'en servir vous le dira. Le terminal est finalement bien plus simple et plus adapté à un travail quotidien. Je n'enlève pas l'utilisation du navigateur internet, ni des outils de création (image, films, 3D, musique...) mais pour le reste, tout est gérable via des lignes de commande. Je sais ce que vous vous dites... "il est fou, tout faire en ligne de commande...", mais pourtant si vous passiez un peu de temps à apprendre le principe, vous vous rendrez compte de la puissance et de la simplicité de son utilisation.

Revenons au gestionnaire de fenêtre. J'ai toujours au moins 4 ou 5 terminaux ouverts, et passer de l'un à l'autre n'est pas si ergonomique que cela sous Gnome ou KDE pour ne citer qu'eux. ALT+TAB ou souris, dans tous les cas je ne vois pas clairement quelle fenêtre je vais avoir tant qu'elle n'est pas affiché. Le fait est que dans 80% des cas, les fenêtres se recouvrent les unes sur les autres. Encore une fois, je concois que cela peut être utile et agréable pour certain, mais pas pour moi.

Et là, une fois de plus, avoir un système d'exploitation libre vous donne un choix, adapté, et vraiment viable. Il existe une autre famille de gestionnaire de fenêtre nommé "tiling desktop" ou "bureau en mosaïque". Ce genre de gestionnaire de fenêtre permet de placer les fenêtre selon des "layout" (mise en page) automatisés et modifiables. Pour en citer quelques uns: awsome, wmii, ion3, Xmonad...

Alors pourquoi mon choix se porte sur XMonad ? Parce que ce dernier est très poussé en terme de configuration et n'a pas de décoration de fenêtre. C'est selon moi la meilleure gestion de bureau que je connaisse dans le domaine des tiling desktop.

Pour vous expliquer le fonctionnement, et surtout pour configurer votre bureau, je vais vous donner quelques clefs.

Tout d'abord, sous fedora, on va installer les outils nécessaires pour:

  • utiliser xmonad
  • avoir quelques outils pratiques
  • avoir des terminaux bien plus sympas
  • se passer de la plupart des outils "graphiques" forcés sous d'autres gestionnaires (navigation de fichier par exemple)

On commence:

su -c "yum install xmonad xmobar dmenu mc xscreensaver feh rxvt-unicode"

Bien, si vous quitter votre session, vous aurez donc le choix d'utiliser xmonad dans le gdm ou kdm (la fenêtre de connexion). Si vous choisissez Xmonad vous allez avoir un terminal qui va s'ouvrir avec le manuel de Xmonad... et rien d'autre.

C'est bien Xmonad... épuré au maximum. Vous avez compris... il va falloir configurer un peu le bureau pour avoir un truc plus sympa. En premier lieu, ne paniquez pas et pressez ALT+Shift+c pour fermet le manuel puis ouvrez un autre terminal avec ALT+shift+Enter.

Dans ce terminal, vous allez ouvrir avec vim le fichier ~/.xmonad/xmonad.hs

Placez y ce contenu:

import XMonad
import XMonad.Config.Azerty
import XMonad.Hooks.DynamicLog


-- The main function.
main = xmonad =<< statusBar myBar myPP toggleStrutsKey myConfig

-- Command to launch the bar.
myBar = "xmobar"

-- Custom PP, configure it as you like. It determines what's being written to the bar.
myPP = xmobarPP { ppCurrent = xmobarColor "#429942" "" . wrap "<" ">" }

-- Keybinding to toggle the gap for the bar.
toggleStrutsKey XConfig {XMonad.modMask = modMask} = (modMask, xK_b)

-- Main configuration, override the defaults to your liking.
myConfig = azertyConfig { 
    terminal           = "urxvt -depth 32 -tr -tint rgb:2222/2222/2222 +sb -fg white -bg rgba:0000/0000/0000/7777 -fade 15 -fadecolor black -pr black -pr2 white"
    , logHook = dynamicLog
 }

Fermez, et tenter de compiler la configuration:

xmonad --recompile

Si une erreur apparait, vérifiez bien le contenu du fichier.

Avant de relancer xmonad, on va aussi configurer xmobar... et ce dans le fichier ~/.xmobarrc

Config { font = "-*-Fixed-Bold-R-Normal-*-13-*-*-*-*-*-*-*"
       , bgColor = "black"
       , fgColor = "grey"
       , position = TopW L 100
       , commands = [ Run Weather "LFLY" ["-t"," <tempC>°","-L","64","-H","77","--normal","green","--high","red","--low","lightblue"] 36000
                    , Run Cpu ["-L","3","-H","50","--normal","green","--high","red"] 10
                    , Run Memory ["-t","Mem: <usedratio>%"] 10
                    , Run Swap [] 10
                    , Run Date "%a %b %_d %H:%M" "date" 10
                    , Run StdinReader
                    ]
       , sepChar = "%"
       , alignSep = "}{"
       , template = "%StdinReader% }{ %cpu% | %memory% * %swap%    <fc=#ee9a00>%date%</fc> | %LFLY%"
       }

Dans ce fichier, remplacer le code "LFLY" par celui de votre ville (ici Lyon Bron), dans le fichier il est à deux endroits, donc remplacez bien tout. Pour trouvez votre code, allez à la page http://weather.noaa.gov et prenez le code qui apparait dans l'url...

Bon, cette fois ci, on peu relancer xmonad... Pressez ALT+q

Hop, xmonad se recharge. Pressez ALT+1 ou 2, 3... changement de bureau. Le clavier azerty est donc bien géré et vous avez théoriquement une barre en haut qui indique quelques infos.

Bon, fermez le terminal en cours ALT+shift+c et relancez en un: ALT+shift+Enter... ha voulà urxvt en mode semi transparent :)" class="smiley ouvrez en un autre, hop l'écran se coupe en deux

Puis un autre... et un autre....

Pour vous déplacer, utilisez la souri (haaan) ou simplement alt+k ou alt+j. Et pour redimensionner les colonnes: alt+h ou alt+l

Pour augmenter le nombre de fenêtre possible sur la colonne principale (à gauche) alt+, et pour en retirer alt+.

Bon assez jouer... on va maintenant faire en sorte de lancer pulseaudio, xscreensaver et changer ce foutu fond d'écran.

Créé un fichier, par exemple j'utilise ~/bin/xmonad-startup et posez ceci dedans:

#!/bin/bash

#prevent running commands on xmonad restart
#I choose xscreensaver because it is stopped at xmonad shutdown
[ "$(ps --noheader -C xscreensaver -o pid)" ] && exit 0

#commands to lauch
xscreensaver &
feh --bg-fill ~/Images/backgrounds/OTHER-Tuxsta_1600x1200.png
synclient VertTwoFingerScroll=0 VertEdgeScroll=1
pulseaudio --start

Reste à demander à xmonad de les lancer au chargement:

import XMonad
import XMonad.Config.Azerty
import XMonad.Hooks.DynamicLog


-- The main function.
main = xmonad =<< statusBar myBar myPP toggleStrutsKey myConfig

-- Command to launch the bar.
myBar = "xmobar"

-- Custom PP, configure it as you like. It determines what's being written to the bar.
myPP = xmobarPP { ppCurrent = xmobarColor "#429942" "" . wrap "<" ">" }

-- Keybinding to toggle the gap for the bar.
toggleStrutsKey XConfig {XMonad.modMask = modMask} = (modMask, xK_b)


-- my startup
myStartup :: X ()
myStartup = do
    spawn "~/bin/xmonad-startup"

-- Main configuration, override the defaults to your liking.
myConfig = azertyConfig { 
    terminal           = "urxvt -depth 32 -tr -tint rgb:2222/2222/2222 +sb -fg white -bg rgba:0000/0000/0000/7777 -fade 15 -fadecolor black -pr black -pr2 white"
    , logHook = dynamicLog
    , startupHook = myStartup
 }

On recompile: xmonad --recompile et on relance ALT+q

Bon, reste à connaitre quelques outils pour utiliser xmonad sans avoir besoin d'utiliser trop d'outils graphique:

  • dans un terminal: alsamixer => gestion du volume
  • dans un terminal: mc => gestionnaire de fichier
  • pour lancer un programme sans passer par un terminal: ALT+p et commencez à taper le nom du programme, l'auto completion est gérée

Vous pourrez trovuer des fichier "ini" de "+mc" pour le rendre plus joli. Utilisez aussi weechat pour aller sur IRC, vous allez voir que finalement c'est plus clair et efficace.

Un dernier racourcis ? ALT+Shift+Q et vous quittez Xmonad :)" class="smiley

Bon, sinon, utilisez des petits scripts pratique pour votre utilisation, par exemple j'ai un script "~/bin/dodo" qui met en veille "mémoire" mon pc:

#!/bin/bash
su -c "echo -n mem > /sys/power/state"

ou encore un script pour lancer weechat en me connectant avec mon login/pass + ouverture des canaux que j'aime bien:

#!/bin/bash
weechat-curses irc://VOTREUSERICI:VOTREMOTDEPASSEICI@irc.freenode.net/#fedora-fr,#blender-fr,#node.js,#blendercoders,#xmonad

VOTREUSER et VOTREMOTDEPASSE sont les user et mot de passe que vous utilisez sur IRC...

Bon voilà... à vous d'apprendre les trucs et astuces, vim ou emacs, uzbl-brower au lieu de google-chrome (étonnant ce truc, merci WilQu) et j'en passe... vous allez vous rendre compte aussi que "mc" permet de connecter un serveru distant sur la vue de gauche (cherchez un peu dans les menu avec F10) et permet même l'édition. Essayez aussi le racourcis CTRL+O dans mc... sympa non ?

Bon allez une capture, parce que vous êtes gentils (faites avec scrot):

Xmonad

Voilà, bon ba à vous hein.

Hacking et ufologie : le cas McKinnon.

Sébastien Natroll Billet spécial que je vous propose aujourd’hui. Dans un souci d’originalité (et parce que j’affectionne l’ufologie), je vous propose de rapprocher les deux univers. Si vous suivez l’actualité informatique, le cas McKinnon ne doit pas vous être étranger. Gary McKinnon, né à Glasgow en 1966, également connu sous le nom Solo, est un hacker britannique La suite >

mini2440. Séance 5 : configuration et compilation du noyau Linux

Patrice Kadionik

Salut.

Pour cette séance 5 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler le noyau Linux qui sera ensuite installé dans la mémoire NAND Flash de la carte mini2440.

On installe dans un premier temps les sources du noyau Linux 2.6.32.2 pour la carte mini2440 ici :

$ cd mini2440
$ tar -xvzf linux-2.6.32.2-mini2440_20110305.tgz

Le noyau Linux est ensuite configuré puis compilé pour la carte mini2440.

On se placera dans le répertoire des sources du noyau. On créera au préalable le lien symbolique kernel :

$ ln -s linux-2.6.32.2 kernel
$ cd kernel


On configurera le noyau Linux avec le shell script goconfig :

$ cd kernel
$ cat goconfig
make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- menuconfig
$ ./goconfig


Le fichier de configuration est sauvegardé dans le fichier .config. On pourra utiliser les fichiers config suivants adaptés à la carte mini2440 que l'on recopiera en lieu et place du fichier .config (il existe des fichiers de configuration par défaut config_mini2440_* correspondant à différents types d'écrans LCD sous kernel/) :


On compile le noyau Linux avec le shell script go :

$ cat go
make -j4 ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi-
make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- uImage
$ ./go


On compile les modules éventuels du noyau Linux avec le shell script gomodules :

$ cat gomodules 
ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- make modules
$ ./gomodules


1.2.    Installation

On installera les modules du noyau Linux avec le shell script gomodules_install dans le système de fichiers root (répertoire root_fs/)  :

$ cat gomodules_install
make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- INSTALL_MOD_PATH=/home/eddy33/mini2440/root_fs modules_install
$ ./gomodules_install


On ajustera au préalable la variable INSTALL_MOD_PATH vers le chemin absolu du répertoire root_fs/ en fonction de son environnement de développement sur le PC hôte.

Il faudra bien sûr alors mettre à jour son système de fichiers root installé dans la mémoire NAND Flash ou sur la carte SD de la carte mini2440...

On installera le noyau Linux via le fichier uImage avec le shell script goinstall :

$ cat goinstall
cp arch/arm/boot/uImage /tftpboot
$ ./goinstall


Le noyau Linux uImage est installé dans le répertoire /tftpboot/. Il sera téléchargé via le protocole TFTP en RAM avec u-boot puis programmé dans la partition MTD 2 de la mémoire NAND Flash avec u-boot.

On télécharge donc le fichier uImage depuis u-boot en RAM de la carte mini2440 puis on le programme dans la partition MTD 2 de la mémoire NAND Flash. On suppose que le PC hôte a comme adresse IP 192.168.0.1 et la carte mini2440 a comme adresse IP 192.168.0.100. On configurera u-boot en conséquence :

MINI2440 # setenv netmask 255.255.255.0
MINI2440 # setenv ipaddr 192.168.0.100
MINI2440 # setenv serverip 192.168.0.1
MINI2440 # saveenv
MINI2440 # tftp 32000000 uImage
dm9000 i/o: 0x20000300, id: 0x90000a46
DM9000: running in 16 bit mode
MAC: 08:08:11:18:12:27
TFTP from server 192.168.0.1; our IP address is 192.168.0.100
Filename 'uImage'.
Load address: 0x32000000
Loading: T #################################################
###################################################
done
Bytes transferred = 2058212 (1f67e4 hex)
MINI2440 # nand erase kernel
MINI2440 # nand write.e 0x32000000 kernel

On pourra éventuellement créer la macro u-boot gokernel pour faciliter les prochaines programmations :

MINI2440 # setenv gokernel tftp 32000000 uImage\;nand erase kernel\;nand write.e 0x32000000 kernel
MINI2440 # saveenv

La programmation du fichier uImage se fera alors simplement par la commande u-boot :

MINI2440 # run gokernel

On précise enfin la variable u-boot bootargs qui correspond aux paramètres passés au noyau Linux :

MINI2440 # setenv bootargs root=/dev/mtdblock3 rootfstype=jffs2 console=ttySAC0,115200 mini2440=1tb rootnowait 
MINI2440 # saveenv

On rappelle que le paramètre mini2440 précise la taille de l'écran LCD :

  • mini2440=0tb : écran 3"1/2
  • mini2440=1tb : écran 7"


On fait un reset de la carte mini2440. On doit avoir les traces de boot du noyau Linux (qui ne trouve pas encore son système de fichiers root…) :

## Booting kernel from Legacy Image at 32000000 ...
Image Name: Linux-2.6.32.2
Created: 2011-06-24 11:33:32 UTC
Image Type: ARM Linux Kernel Image (uncompressed)
Data Size: 2058148 Bytes = 2 MB
Load Address: 30008000
Entry Point: 30008000
Verifying Checksum ... OK
Loading Kernel Image ... OK
OK
Starting kernel                                                                             
Uncompressing Linux.............................................................
Linux version 2.6.32.2 (kadionik@ipcchip) (gcc version 4.3.2 (Sourcery G++ Lite1
CPU: ARM920T [41129200] revision 0 (ARMv4T), cr=c0007177
CPU: VIVT data cache, VIVT instruction cache
Machine: FriendlyARM Mini2440 development board
Memory policy: ECC disabled, Data cache writeback
CPU S3C2440A (id 0x32440001)
S3C24XX Clocks, (c) 2004 Simtec Electronics
S3C244X: core 405.000 MHz, memory 101.250 MHz, peripheral 50.625 MHz
CLOCK: Slow mode (1.500 MHz), fast, MPLL on, UPLL on
. . .

On a alors accès au login. Cela valide ainsi toutes ces 5 séances. Nous avons au final un système Linux embarqué opérationnel sur la carte mini2440

Prochaine séance : configuration et compilation de la bibliothèque tslib pour l'écran tactile de la carte mini2440...

++

Sources :

  • Sources du noyau 2.6.32.2 pour la carte mini2440

mini2440. Séance 4 : configuration et compilation de busybox

Patrice Kadionik

Salut.

Pour cette séance 4 de mise en oeuvre de la carte mini2440, nous allons voir comment configurer et compiler busybox qui sera ensuite installé dans le système de fichiers root.

Busybox est LE couteau suisse quand on fait du Linux embarqué ! Il permet à l'aide d'un seul exécutable d'avoir accès à un ensemble configurable de commandes Linux. Chaque commande est un lien symbolique vers l'exécutable busybox : on exploite ainsi dans les sources C de busybox l'argument argv[0]...

On installe dans un premier temps les sources de busybox disponibles ici :

$ cd mini2440
$ tar -xvzf linux-busybox-mini2440-1.13.3.tgz
$ cd busybox-1.13.3

La configuration par défaut correspond au shell script godefconfig :

$ cd busybox-1.13.3
$ cat godefconfig
cp fa.config .config

On pourra éventuellement configurer busybox avec le shell script goconfig afin de sélectionner les commandes Linux (applets) que l'on veut en plus :

$ cat goconfig
make ARCH=arm CC=arm-linux-gcc menuconfig
$ ./goconfig

On compilera busybox avec le shell script go :

$ cat go
make ARCH=arm CC=arm-linux-gcc
$ ./go

On installera busybox avec le shell script goinstall dans le système de fichiers root que l'on a construit lors de la séance 3 (répertoire root_fs/)  :

$ cat goinstall
make ARCH=arm CC=arm-linux-gcc CONFIG_PREFIX=/home/eddy33/mini2440/root_fs install
$ su
# ./goinstall

On ajustera au préalable la variable CONFIG_PREFIX vers le chemin absolu du répertoire root_fs/ en fonction de son environnement de développement sur le PC hôte.

Notre système de fichiers root est presque opérationnel. Il reste à rajouter les bibliothèques pour le processeur ARM :

$ cd mini2440
$ su
# \cp -a ./arm-2008q3/arm-none-linux-gnueabi/libc/armv4t/lib/* ./root_fs/lib
# \cp ./arm-2008q3/arm-none-linux-gnueabi/libc/armv4t/usr/lib/* ./root_fs/usr/lib

Il manque éventuellement les modules Linux et le firmware des périphériques à rajouter sous root_fs/lib (on verra cela à la prochaine séance) mais le système de fichiers root sous root_fs/ doit être utilisable en l'état...

Les tests peuvent se faire en utilisant le système de fichiers root ainsi créé soit en mémoire NAND flash (partition MTD 3), soit sur la carte SD.

Pour mettre le système de fichiers root en mémoire NAND Flash de la carte mini2440, il faut au préalable le convertir en système de fichiers de type JFFS2. On utilisera la commande mkfs.jffs2. On utilisera le shell script gojffs2 :

$ cd mini2440
$ cat gojffs2
mkfs.jffs2 -lqnp -e 16 -r ./root_fs -o rootfs.jffs2
cp rootfs.jffs2 /tftpboot
$ su
# ./gojffs2
On suppose que le PC hôte a comme adresse IP 192.168.0.1 et la carte mini2440 a comme adresse IP 192.168.0.100. On configurera u-boot en conséquence :
MINI2440 # setenv netmask 255.255.255.0
MINI2440 # setenv ipaddr 192.168.0.100
MINI2440 # setenv serverip 192.168.0.1
MINI2440 # saveenv
On utilisera ensuite u-boot pour télécharger par TFTP le fichier image JFFS2 rootfs.jffs2 puis on le programmera dans la partition MTD 3 de la mémoire NAND Flash :
MINI2440 # tftp 32000000 rootfs.jffs2
MINI2440 # nand erase rootfs
MINI2440 # nand write.jffs2 32000000 rootfs $(filesize)

On pourra éventuellement créer la macro u-boot gorootfs pour faciliter les prochaines programmations :

MINI2440 # setenv gorootfs tftp 32000000 rootfs.jffs2\;nand erase rootfs\;nand write.jffs2 32000000 rootfs \$(filesize)
MINI2440 # saveenv

La programmation du fichier rootfs.jffs2 se fera alors simplement par la commande u-boot :

MINI2440 # run gorootfs

Pour recopier le système de fichiers root sur la carte SD, on utilisera le shell script gosd. On branchera au préalable un lecteur de cartes SD sur le PC hôte, la carte SD sera enfichée dans le lecteur.

Pour la première fois, la carte SD sera formatée au format ext3. On suppose que la carte SD est vue comme le périphérique /dev/sde :

$ cd mini2440
$ su
# fdisk -l
# fdisk /dev/sde
Command (m for help): n
Command action
e extended
p primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-1016, default 1):
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-1016, default 1016):
Using default value 1016
Command (m for help): w
The partition table has been altered!
Calling ioctl() to re-read partition table.
Syncing disks.
# mkfs.ext3 /dev/sde1

On copiera ensuite le répertoire root_fs/ sur la carte SD ainsi formatée à laide du shell script gosd :

# cat gosd
umount /dev/sde1
mount -t ext3 /dev/sde1 /mnt
\rm -rf /mnt/*
sync
\cp -r root_fs/* /mnt
sync
umount /dev/sde1
# ./gosd

Pour utiliser le système de fichiers root en mémoire NAND Flash, on configurera u-boot comme suit :

MINI2440 # setenv boot_nand setenv bootargs root=/dev/mtdblock3 rootfstype=jffs2 mini2440=1tb console=tty0,115200 console=ttySAC0,115200 rootwait \; nboot.e kernel \; bootm
MINI2440 # setenv bootcmd run boot_nand
MINI2440 # saveenv

Pour utiliser le système de fichiers root sur la carte SD, on configurera u-boot comme suit :

MINI2440 # setenv boot_sd setenv bootargs console=tty0,115200 console=ttySAC0,115200 mini2440=1tb rootfstype=ext3 root=/dev/mmcblk0p1 rw rootwait \; nboot.e kernel \; bootm
MINI2440 # bootcmd run boot_sd
MINI2440 # saveenv

Il faut noter que le paramètre mini2440 précise la taille de l'écran LCD :

  • mini2440=0tb : écran 3"1/2
  • mini2440=1tb : écran 7"

On pourra tester notre système de fichiers root une fois que l'on aura un noyau Linux opérationnel pour la carte mini2440, ce qui sera expliqué à la prochaine séance.

Prochaine séance : configuration et compilation du noyau Linux pour la carte mini2440...

++

Sources :

Point de montage d'archives

Patrice Ferlet

Si comme moi vous avez besoin d'utiliser le contenu d'un tar.gz, d'un zip, ou tout autre archive et que cela vous agace de devoir le décompacter pour le modifier et le compresser par la suite pour le déplacer... ce billet va vous intéresser. Nous allons parlons ici de "archivemount", un outil sympa comme tout, utilisant "fuse", et qui va vous faire gagner un peu de temps.

Il m'arrive souvent ce genre de chose. Devoir récupérer une archive tar.gz ou tar.bz2, ou encore un zip, et devoir le décompresser pour l'utiliser avec une application (par exemple un storage pour ezPublish que je déplace pour bosser chez moi, ou la création d'une archive de release que je veux manipuler et vérifier simplement). Le fait est que l'archive est parfois lourde, et devoir ajouter des fichiers ou en supprimer, ou même en modifier est parfois un peu... suante. Gnome, KDE, proposent bien un outil de montage dans le navigateur de fichier, mais moi je suis sur Xmonad et j'aime le terminal. C'est donc le moment de vous montrer l'outil qui rend bien service "archivemount"

Sur Fedora il est dans les dépôts standard, donc un simple:

su -c "yum install archivemount"

et le tour est joué.

Alors comment ça marche tout ça ?

Imaginons une archive monarchive.tar.gz que je veux utiliser comme un répertoire. Encore une fois, les systèmes UNIX sont bien sympa en ce qui concerne la gestion de point de montage. Fuse va être utilisé avec archivemount. C'est simple comme tout:

mkdir ~/monarchive
archivemount monarchive.tar.bz ~/monarchive

Et voilà... c'est tout. dans le répertoire ~/monarchive se trouve le contenu de l'archive. Toute modification dans ce répertoire se répercute (au démontage) dans monarchive.tar.gz.

C'est donc un point de montage, simple, clair et efficace. A peu près tout fonctionne: tar (compressé ou non en gz, bz2...), xv, cdrom iso, zip... et les options de mount sont évidemment utilisables (ro, rw, nosuid...) comme avec n'importe quel point de montage.

Notez que le mode d'écriture asynchrone force donc la recompression au démontage.

mini2440. Séance 3 : construction d'un système de fichiers root minimal

Patrice Kadionik

Salut.

Pour cette séance 3 de mise en oeuvre de la carte mini2440, nous allons voir comment construire un système de fichiers root minimal.

Avoir un système de fichiers root est indispensable pour avoir un noyau Linux fonctionnel car l'un ne marche pas sans l'autre. Le système de fichiers root peut être local en RAM, en mémoire NAND Flash ou sur la carte SD pour la carte mini2440 ou bien distant monté par NFS. Le choix se fera par des paramètres passés au boot du noyau Linux, paramètres sauvegardés comme variables d'environnement (setenv) du bootloader u-boot.

Pour construire le système de fichiers root, on doit respecter le standard FHS (Filesystem Hierarchy Standard) dont la structure globale est la suivante :

rootfs (/)
|--bin
|--dev
|--etc
| |--init.d
|--lib
|--mnt
|--proc
|--sys
|--sbin
|--tmp
|--usr
| |--bin
| |--sbin
|--var

Nous allons donc construire le système de fichiers root en s'aidant du document Build Root File System...

Tout sera mis dans le répertoire root_fs/ :

$ cd mini2440
$ mkdir root_fs

Le système de fichiers root ainsi construit sera minimal (et non opérationnel) car cela ne sera qu'un squelette qu'il faudra compléter avec busybox, avec les bibliothèques dynamiques pour le processeur ARM sous root_fs/lib/ ainsi qu'éventuellement les modules du noyau Linux. On verra cette étape à la prochaine séance consacrée à busybox...

On crée les répertoires de base :

$ cd root_fs
$ mkdir dev
$ mkdir -p etc/init.d
$ mkdir lib
$ mkdir mnt
$ mkdir proc
$ mkdir sys
$ mkdir -m 777 tmp
$ mkdir var

On crée l'entrée console sous root_fs/dev/ :

$ cd root_fs/dev
$ su
# mknod -m 622 console c 5 1

Les principaux fichiers de configuration, notamment ceux qui seront utilisés par busybox sont sous root_fs/etc/.

On créera le fichier root_fs/etc/inittab utilisé par le processus init dont le contenu est le suivant :

::sysinit:/etc/init.d/rcS
::askfirst:-/bin/sh
::ctrlaltdel:/sbin/reboot
::shutdown:/bin/umount -a -r
::shutdown:/sbin/swapoff -a
::restart:/sbin/init
#::respawn:/sbin/getty -L 115200 /dev/ttySAC0 vt100
console::respawn:/sbin/getty -L 9600 tty0 vt100

On créera le fichier root_fs/etc/init.d/rcS, shell script exécuté après le lancement du processus init dont le contenu est le suivant :

#! /bin/sh

# Setup the bin file location and export to system PATH
PATH=/sbin:/bin:/usr/sbin:/usr/bin
umask 022
export PATH

# mount the filesystem directories
mount -a
mkdir /dev/pts
mount -t devpts devpts /dev/pts -o mode=0622

# create device nodes and directories
echo /sbin/mdev>/proc/sys/kernel/hotplug
mdev -s
mkdir /var/lock

# start logging utility services
klogd
syslogd

# set system clock from RTC
hwclock -s

# set host and config loopback interface
ifconfig lo 127.0.0.1
ifconfig eth0 192.168.0.100

On créera le fichier root_fs/etc/mdev.conf pour le processus mdev de création dynamique des points d'entrée sous /dev dont le contenu est le suivant :

# system all-writable devices
full 0:0 0666
null 0:0 0666
ptmx 0:0 0666
random 0:0 0666
tty 0:0 0666
zero 0:0 0666

# console devices
tty[0-9]* 0:5 0660
vc/[0-9]* 0:5 0660

# serial port devices
s3c2410_serial0 0:5 0666 =ttySAC0
s3c2410_serial1 0:5 0666 =ttySAC1
s3c2410_serial2 0:5 0666 =ttySAC2
s3c2410_serial3 0:5 0666 =ttySAC3

# loop devices
loop[0-9]* 0:0 0660 =loop/

# i2c devices
i2c-0 0:0 0666 =i2c/0
i2c-1 0:0 0666 =i2c/1

# frame buffer devices
fb[0-9] 0:0 0666

# input devices
mice 0:0 0660 =input/
mouse.* 0:0 0660 =input/
event.* 0:0 0660 =input/
ts.* 0:0 0660 =input/

# rtc devices
rtc0 0:0 0644 >rtc
rtc[1-9] 0:0 0644

# misc devices
#mmcblk0p1 0:0 0600 =sdcard */bin/hotplug
#sda1 0:0 0600 =udisk * /bin/hotplug

On créera le fichier root_fs/etc/fstab pour le montage des divers systèmes de fichiers (virtuels) dont le contenu est le suivant :

# device mount-point type options dump fsck order
proc /proc proc defaults 0 0
sysfs /sys sysfs defaults 0 0
tmpfs /dev tmpfs defaults 0 0
tmpfs /tmp tmpfs defaults 0 0
var /var tmpfs defaults 0 0

On créera le fichier root_fs/etc/profile qui est exécuté quand on se connecte au système dont le contenu est le suivant :

USER="`id -un`"                                                 
LOGNAME=$USER
PS1='[\u@\h \W]\# '
PATH=$PATH
HOSTNAME=`/bin/hostname`
export USER LOGNAME PS1 PATH HOSTNAME

On créera le fichier root_fs/etc/issue qui contient le message de bienvenue dont le contenu est le suivant :

Welcome to Mini2440
Kernel \r on an \m (\l)
On créera le fichier root_fs/etc/passwd avec un seul utilisateur, root dont le contenu est le suivant :
root::0:0:root:/:/bin/sh
On créera le fichier root_fs/etc/group dont le contenu est le suivant :
root:x:0:root
Enfin, nous réajustons les droits attribués à root du répertoire root_fs/ qui sera recopié soit sur une carte SD, soit transformé en fichier image JFFS2 :
$ cd mini2440
$ su
# chown -R root:root root_fs
$
Nous en avons fini avec ce système de fichiers root minimal. Il n'est pas encore opérationnel car il convient de le compléter avec :
  • busybox
  • Les bibliothèques pour processeur ARM
  • les modules du noyau Linux ainsi que les firmwares si nécessaire

Le résultat de la construction de ce système de fichiers root est disponible ici.


Prochaine séance : compilation et mise en oeuvre de busybox et intégration dans le système de fichiers root minimal...

++

Sources :

La programmation parallèle avec python

Pierre-Yves Chibon

source.png

Un petit exemple basique de programmation parrallèle avec python

French version (English version)

L'autre jour je me suis penché sur la programmation asynchrone avec java et je suis tombé sur cet article : Asynchronous processing in Java applications – leveraging those multi-cores

Article vraiment clair et intéressant sur la programmation asynchrones avec Java.

Mais bon, mon langage de prédilection étant python, j'ai bien sûr cherché s'il était possible d'en faire autant avec.

Après quelques recherches sur internet je suis arrivé sur parallelpython, une petite bibliothèque python qui permet de faire de la programmation asynchrones facilement.

Revenons au début, quel est le but de la programmation asynchrones ? L'idée est de pouvoir faire plusieurs choses en même temps, de lancer plusieurs tâches en parallèles.

Commençons avec un script basique qui appelle deux fois une fonction qui attends 5 secondes avant de nous dire qu'elle a fini.

#!/usr/bin/python
 
"""
Exemple de programme python non-asynchrone.
"""
 
import time
 
def background_stuff(num):
  time.sleep(5) # wait 5 seconds
  return "%s J'ai fini" % num
 
if __name__ == "__main__":
    print "Commence a :" , time.asctime(time.localtime())
 
    print "Je commence"
    print background_stuff(1)
    print "Je fais quelque chose..."
    print " ... et autre chose..."
    print background_stuff(2)
 
    print "Fini a :", time.asctime(time.localtime())

L'idée est donc d'avoir une sortie comme ceci :

Commencé à : <date and time>
Je commence
Je fais quelque chose
 ... et autre chose...
1 J'ai fini
2 J'ai fini
Fini à: <date and time>

Mais c'est cette sortie que l'on obtient :

Commencé à : Fri Aug 19 13:35:15 2011
Je commence
1 J'ai fini
Je fais quelque chose
 ... et autre chose...
2 J'ai fini
Fini à: Fri Aug 19 13:35:25 2011

Donc python attend que la première fonction finisse avant de continuer. C'est le comportement par défaut, séquentiel et comme vous pouvez voir il faut 10 secondes pour éxécuter ce programme.

Mais bon on peux faire mieux que ça et on va re-écrire le programme pour faire appel aux fonctions en parallèle.

D'abord on installe la bibliothèque python voulue:

yum install python-pp

Et voici notre nouveau script

#!/usr/bin/python
 
"""
Exemple de programme python asynchrone.
"""
 
import pp
import time
 
def background_stuff(num):
  time.sleep(5)
  return "%s J'ai fini" % num
 
if __name__ == "__main__":
    print "Commence a :" , time.asctime(time.localtime())
    job_server = pp.Server()
 
    print "Je commence"
 
    f1 = job_server.submit(background_stuff, (1,) , modules=('time',))
    f2= job_server.submit(background_stuff, (2,), modules=('time',))
    print "Je fais quelque chose..."
    print " ... et autre chose..."
 
    print f1()
    print f2()
 
 
    print "Fini a :", time.asctime(time.localtime())

Les lignes importantes sont

import pp

On charge la bibliothèque parallel-python

job_server = pp.Server()

On crée un serveur de tâches.

f1 = job_server.submit(background_stuff, (1,) , modules=('time',))

On soumet une tâche au serveur.

Le premier argument est le nom de la fonction appelé, le second est un tuple des arguments à passer à la fonction et le troisième (dans cette exemple) est un tuple des bibliothèques python que la fonction doit avoir chargé. À noter que si la fonction background_stuff avait la ligne "import time" alors le troisième argument ne serait pas nécessaire.

Et maintenant la sortie est :

Commence a : Fri Aug 19 14:20:05 2011
Je commence
Je fais quelque chose...
 ... et autre chose...
1 J'ai fini
2 J'ai fini
Fini a : Fri Aug 19 14:20:10 2011

Comme vous pouvez voir, nous avons appelé deux fois la fonction background_stuff, fait quelque chose pendant qu'elle tournait, récupéré la sortie de la fonction et le tout en 5 secondes !

Page générée le 19 sept 2014 à 11:47