TP6 – Programmes exécutables

Introduction

L'arborescence d'un système d'exploitation contient des fichiers particuliers appelés programmes exécutables. Ces exécutables ont pour vocation d'être exécutés par le processeur central de l'ordinateur (CPU) pour modifier son état interne (contenu de la mémoire) ou agir sur ses périphériques (afficher un message à l'écran, accéder à des données sur le disque, envoyer une information sur le réseau, etc).

Les fichiers exécutables contiennent un programme informatique pouvant être stockés sous deux formes :

• sous forme textuelle. Le code exécutable est le code source du programme écrit dans un langage informatique, compréhensible par un programmeur. Son exécution nécessite un interpréteur, un autre programme qui va exécuter le programme source, instruction par instruction. On dit que de tels programmes sont des programmes interprétés. On les appelle aussi des scripts, comme ceux que vous avez écrits dans les TPs précédents.
• sous forme binaire. Les instructions à exécuter sont ici stockées sous forme numérique, en codage binaire. Cette suite de 0 et de 1 est un langage machine qui est le langage natif du processeur, c'est à dire le seul langage que le processeur puisse traiter directement. Ces fichiers exécutables ne sont plus compréhensibles par un programmeur, le langage source initial a été traduit par un compilateur. On dit que de tels programmes sont des programmes compilés.

Pour un système d'exploitation, un exécutable est un fichier qui a reçu le droit d'exécution, au sens des permissions accordées aux fichiers (lecture, écriture et exécution). Il s'agit par exemple des commandes accessibles dans un terminal.

 # emplacement de cp :
 which cp
 /bin/cp
 # permissions de cp (x : exécution)
 ls -l /bin/cp
 -rwxr-xr-x 1 root root 130304 janv. 14  2015 /bin/cp
 # format de l'exécutable
 file /bin/cp
 /bin/cp: ELF 64-bit LSB  executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]=ad985d5fbb3036a578c8e7f61a2d8756f373d448, stripped
 # ELF 64-bit indique que le fichier est stocké en langage machine.
 # Il n'est pas lisible par un humain :
 head /bin/cp
 # la commande head affiche les premières ligne d'un fichier

Chemin vers un exécutable

Un exécutable n'est donc rien d'autre qu'un fichier stocké dans l'arborescence de fichiers et dont les droits d'exécution ont été donnés. Comme tout fichier il est nécessaire de connaître son emplacement dans l'arborescence pour l'invoquer. Par exemple : /bin/ls appelle la commande ls.

Or vous remarquerez que les commandes sont appelables sans préciser leur chemin. Cela est rendu possible par le système d'exploitation pour le confort d'utilisation en précisant dans une variable d'environnement tous les emplacements dans lesquels des exécutables sont susceptibles d'être appelés.

Cette variable s'appelle PATH et vous pouvez en voir le contenu ainsi :

printenv PATH
/bin:/usr/bin:/usr/local/bin

Il s'agit d'une liste de chemins séparés par le caractère ' :'.

Nous pouvons continuer à ajouter d'autres chemins à la variable PATH pour invoquer des exécutables qui s'y trouveraient.

Création d'exécutables

Pour illustrer la notion de fichiers exécutables, nous allons créer deux programmes qui pourront être exécuté dans un terminal. Un sous forme textuelle (programme interprété), l'autre sous forme binaire (programme compilé).

Programme interprété

Nous ne pouvons pas passer à côté du fameux « Hello Word », le programme de référence des débutants !

D'abord avec le langage de script bash. Dans un dossier TP6, recopiez dans un fichier hello.sh :

 #!/bin/bash
 echo "Hello, World!"

Vous pouvez l'exécuter en invoquant l'interpréteur bash pour ce script :

 bash hello.sh

Vous pouvez aussi le rendre exécutable en lui fournissant les permissions adéquates :

chmod +x hello.sh

Il peut alors être appelé directement en précisant son chemin d'accès car le répertoire courant ne se trouve pas référencé dans la variable d'environnement PATH :

./hello.sh

Maintenant avec le langage Python, un autre langage interprété. Créez un fichier hello.py :

 #! /usr/bin/python
 print "Hello World!"

On peut l'exécuter avec son interpréteur :

python hello.py

Exécutez-le maintenant directement après lui avoir donné les droits d'exécution.

Programme compilé

Avec le langage C. Créez un fichier hello.c :

 /* Hello World program */
 #include <stdio.h>
 int main() {
   printf("Hello World \n");
   return 0; /* code retour : tout s'est bien passé */
 }

Compilation et création de la commande hello :

gcc -o hello hello.c

gcc est le compilateur et l'option -o indique le nom de l'exécutable qui doit être généré.

Vérifiez que la compilation a bien créé un programme exécutable en format binaire.

Exécutez ce programme.

Intégration d'un exécutable dans le gestionnaire de bureau

Nous avons vu la variable d'environnement PATH qui permet d'invoquer un programme dans un terminal sans préciser son chemin. Il existe un mécanisme similaire au niveau du gestionnaire de bureau Unity d'Ubuntu. Il s'agit de fichiers de configuration d'extension .desktop qui accompagnent les programmes exécutables pour préciser leur emplacement, un nom et éventuellement une icône. Cette méthode de faire résulte d'un effort de standardisation mutualisé entre plusieurs gestionnaires de bureau (Unity, Gnome, KDE).

L'objectif de cette partie est de créer de tels fichiers de configuration en partant d'une version minimale.

Les fichiers de configuration fournis par le gestionnaire de bureau sont rassemblés dans le dossier /usr/share/applications/ (allez voir le nombre d'applications disponibles). Ils servent à trouver une application via l'interface graphique.

Les fichiers .desktop sont des fichiers texte dans lesquels trois mots clés doivent être renseignés au minimum :

• Type  : soit Application, Link ou Directory ;
• Name  : Nom du programme tel qu'il apparaitra dans dans l'interface graphique ;
• Exec  : nom de l'exécutable accessible par la variable PATH ou chemin complet.

Nous allons voir maintenant comment créer nos propres fichiers .desktop pour accéder à des exécutables par l'interface graphique.

Programme Xeyes

Cette application affiche des yeux qui suivent le curseur à l'écran. Elle est inutile donc indispensable !

On la lance dans le terminal par xeyes.

Vous pouvez faire un clic_droit sur la barre de titre et sélectionner « Toujours au premier plan » pour qu'aucune fenêtre ne puisse la recouvrir.

Vous pouvez vérifier que la recherche de xeyes par l'interface graphique (touche Super) n'aboutit pas. Cela s'explique par l'absence d'un fichier .desktop pour ce programme. Nous allons donc en créer un.

Création d'un fichier xeyes.desktop

N'ayant pas la permission d'écrire dans le dossier /usr/share/applications, il est prévu un autre emplacement pour stocker les fichiers de configuration de chaque utilisateur. Il s'agit du dossier ~/.local/share/applications/.

Ajouter une icône

Il est possible d'ajouter des clés supplémentaires dans le fichier xeyes.desktop. On peut par exemple ajouter une icône pour ce programme.

Utiliser sa propre icône

Il est possible d'utiliser une icône personnalisée stockée dans un dossier sous sa racine personnelle.

Application dans un terminal

Il est possible de créer un fichier de configuration .desktop pour un programme s'exécutant dans un terminal. Pour cela il suffit d'ajouter une clé « Terminal=true ».

Nous allons l'illustrer avec la commande top qui affiche les programmes en cours de fonctionnement.