Aller au menu - Aller au contenu

Icône Avant-propos

Mise à jour : 15/03/2011
Difficulté : Facile Facile Creative Commons BY-NC-ND
1 557 visites depuis 7 jours, dont 109 sur ce chapitre classé 83/786
Avant de nous jeter corps et âme dans la programmation système, commençons par étudier quelques notions théoriques sur la programmation système et sur la famille Unix.
A la fin de ce premier chapitre, vous saurez :

  • définir précisément la programmation système ;
  • le fonctionnement général de la programmation sous Unix ;
  • gérer correctement vos erreurs.
Sommaire du chapitre :
Icône du chapitre
Sommaire Chapitre suivant

Introduction

Quel est le but de ce tutoriel ?

Ce cours a pour but de vous apprendre à maîtriser toutes les finesses de la programmation système.

Qu'est-ce que nous allons savoir faire ?


La programmation système permet de créer des drivers, communiquer avec les périphériques, voire même créer un système d'exploitation !

(mais bon on en est pas encore là hein :honte: )

Par exemple, les emblématiques Apache, Emacs, gcc, gdb ou encore glibc sont des programmes systèmes.

Généralités sur le développement sous Unix

Dans cette troisième partie, nous allons aborder quelques termes de vocabulaire indispensables pour la suite du cours.

Les systèmes Unix sont des systèmes d'exploitation qui sont constitués de plusieurs programmes, et chacun d'eux fournit un service au système. Tous les programmes qui fournissent des services similaires sont regroupés dans une couche logicielle.

Une couche logicielle qui a accès au matériel informatique s'appelle une couche d'abstraction matérielle.

Le noyau est une sorte de logiciel d'arrière-plan qui assure les communications entre ces programmes. C'est donc par lui qu'il va nous falloir passer pour avoir accès aux informations du système.

Pour accéder à ces informations, nous allons utiliser des fonctions qui permettent de communiquer avec le noyau. Ces fonctions s'appellent des appels-systèmes.
De manière plus théorique, le terme « appel-système » désigne l'appel d'une fonction, qui, depuis l'espace utilisateur, demande des services ou des ressources au système d'exploitation. Par exemple, les fonctions read et write sont des appels-systèmes.
Chaque architecture matérielle ne supporte que sa propre liste d'appels-systèmes, c'est pourquoi les appels-systèmes diffèrent d'une machine à l'autre. Heureusement, la plupart d'entre eux (90% environ) sont implémentés sur toutes les machines. Les 10% restants ne seront pas utilisés dans ce cours. ;)
Pour des raisons de sécurité évidentes, les applications de l'espace utilisateur ne peuvent pas directement exécuter le code du noyau ou manipuler ses données. Par conséquent, un mécanisme de signaux a été mis en place. Quand une application exécute un appel-système, elle peut alors effectuer un trap, et peut exécuter le code, du moment que le noyau le lui autorise.

On peut également qualifier le système de multitâche, ce qui signifie qu'il est capable de gérer l'exécution de plusieurs programmes en simultanée et de multi-utilisateur car il permet que plusieurs utilisateurs aient accès au même ordinateur en même temps, et qu'ils puissent profiter des mêmes ressources.

Conventions typographiques

Derrière ce titre un peu barbare, je vais vous montrer comment ce cours va être administré pour mettre en valeur les expressions :

Noms propres, matériaux en italique



Exemple : Sous un environnement GNOME de Linux, quand j'ai ouvert l'analyseur d'utilisation des disques, rien ne s'est passé.

Police courrier pour les chemins ou noms de répertoire/fichiers



Exemple : Rendez-vous dans le répertoire/usr/include et ouvrez le fichier nommé passwd.

Mots importants en gras



Exemple : Nous allons utiliser un appel-système qui va dupliquer le processus appelant.

Constantes définies par le système en violet



Exemple : Il existe deux constantes pour cela : STDIN_FILENO et STDOUT_FILENO.

Gestion des erreurs

Avec la programmation système, nous allons étudier et manipuler tout ce qui touche à votre système d'exploitation.
Ainsi, nous devrons faire face assez souvent à des codes d'erreurs. La gestion des erreurs est donc un élément primordial dans la programmation système.

La variable globale errno



Pour signaler une erreur, les fonctions renvoient une valeur spéciale, indiquée dans leur documentation. Celle-ci est généralement -1 (sauf pour quelques exceptions). La valeur d'erreur alerte l'appelant de la survenance d'une erreur, mais elle ne fournit pas la description de ce qui s'est produit. La variable globale errno est alors utilisée pour en trouver la cause.

Cette variable est définie dans <errno.h> comme suit :

Code : C
1
2
3
#include <errno.h>

extern int errno;


Sa valeur est valable uniquement juste après l'utilisation de la fonction que l'on veut tester. En effet, si on utilise une autre fonction entre le retour que l'on veut tester et l'exploitation de la variable de errno, la valeur de errno peut être modifiée entre temps.

A chaque valeur possible de errno correspond une constante du préprocesseur. Pour les connaître, je vous conseille de taper la commande man errno. Une description de chaque erreur y est disponible (en anglais ! :ange: ). Bon, allez, je suis sympa, je vous donne une page de man avec les principales erreurs, en français : ici.

La fonction perror



La bibliothèque C met également à notre disposition une fonction permettant d'associer à l'utilisation d'une fonction une description de l'erreur (si il y en a eu une) qui s'est produite. Cette fonction, la voici :

Code : C
1
2
3
#include <stdio.h>

void perror(const char *s);


Cette fonction affiche sur stderr (sortie d'erreur standard) une représentation en une chaîne de caractère de l'erreur décrite par errno, précédée par la chaîne de caractère pointée par s ainsi que d'un espace.

Par convention, le nom de la fonction qui a produit cette erreur doit être inclus dans la chaîne. Par exemple :


Exemple :

Code : C
1
2
3
if (fork() == -1) {
    perror("fork");
}
Eh bien voilà, ce premier chapitre est terminé.
Nous avons fait un tour d'horizon de ce qui nous attend, et comment l'aborder.

Dans le prochain chapitre, on entre enfin la programmation système, avec une étude des processus.
Sommaire Chapitre suivant

Partager

4 commentaires pour "Avant-propos"
Note moyenne : 3.58 / 4 (78 votes)
Pseudo Commentaire
Hors ligne Blueeyes # Posté le 26/12/2010 à 13:13:44
Avatar

Études : Université Paul Sabatier Toulouse

Salut,

Ce tuto m'a l'air très intéressant.
J'ai juste 2 point a noter dans l'introduction. Au niveau des outils nécessaire il faut un compilateur ^^ (ça parait évident mais bon on sait jamais). Je suis en troisième année de licence info et on a fait la programmation système en 2ème il me semble qu'on nous avais parler de la norme POSIX et qu'on avait utilisé uniquement des "primitive unix" et la bibliothèque standard. Si tu en a besoin il me semble que j'ai mes cours encore mais je ne pense pas avoir le droit de les diffuser.

Bonne continuation.
Hors ligne Lucas-84 # Posté le 26/12/2010 à 14:24:43
[Tomber en marche]
Avatar

Avis : Très bon Validateurs
Flux RSS

Ville : Uchaux
Pays : France métropolitaine

Bien je vais rajouter un petit paragraphe sur la norme Posix, et dans les outils je vais rajouter le compilateur

Merci :)
 
Hors ligne GeekMeister # Posté le 03/01/2011 à 15:58:38
Avatar

Petite remarque dans la partie "Généralités sur le développement sous Linux", je pense qu'il serait préférable de dire que GNU/Linux est un système d'exploitation et non Linux qui est simplement le noyau de celui ci.
Je sais je chipote mais bon ...
Hors ligne Lucas-84 # Posté le 03/01/2011 à 18:05:10
[Tomber en marche]
Avatar

Avis : Très bon Validateurs
Flux RSS

Ville : Uchaux
Pays : France métropolitaine

Non, non tu as tout à fait raison. J'ai d'ailleurs moi-même fait la remarque plusieurs fois à d'autres personnes.... ^^
 

Voir tous les commentaires