unix - e2i5 - introduction à la programmation système sous...

Unix - e2i5 - Introduction à la programmation systèmesous Linux

Laurent Bobelin

UJF

2011

L.Bobelin (MESCAL) 2011 1 / 31

1 Programmation système ?

2 Programmer en C sous linuxIDE

Editer son code

Compiler : gcc

Outil de build

Debugguer

3 Les includes importants de la programmation système

4 Gestion de �chierPourquoi ?Comment ?


Programmation système ?

Dé�nition

Dans les cours d'Unix précédents, vous avez appris à utiliser le systèmed'exploitation linux.

Programmation système

Développement de programmes qui font partie du système d'exploitation

d'un ordinateur, qui en réalisent les fonctions, qui utilisent les fonctions

avancées de celui-ci.

Exemples

L'accès aux �chiers, la gestion des processus, la programmation réseau, lesentrées/sorties, la gestion de la mémoire...

But du cours

Le but de ce cours est de vous apprendre comment interagir avec unsystème d'exploitation de type Unix, et mettre en oeuvre les di�érentsmécanismes système classiques.



Pourquoi la programmation système ?

Les principales applications :

La création de plusieurs processus

Tout ce qui a trait à l'accès de ressources de manière concurrente parplsuieurs processus s'exécutant sur le même processeur.

Partage de données entre plusieurs processus (un exemple classique estle producteur/consommateur)Partage de ressources entre plusieurs processus, avec une possibleexclusion mutuelle....

Les communications entre processus (échanger des données qui nesont pas partagées)

La synchronisation entre processus (ne pas lire des données qui nesont pas complètement écrite)



Pourquoi sous linux et comment

Les concepts sont généraux et se retrouvent dans tous les systèmesd'exploitation

Les sources du noyau de linux sont accessibles et open source,

Les interfaces sont normalisées (norme posix)

Le noyau linux est écrit en C,

Pour faire de la programmation système sous linux, il faut donc savoircomment coder en C sous linux.


Programmer en C sous linux



Editer son code

Compiler : gcc

Outil de build

Debugguer





Les di�érentes tâches

Pour programmer sous linux, on a besoin :

D'éditer son code,

De le compiler,

De le builder,

De le débugguer.

La plupart du temps, on utilise un IDE (Eclipse, Netbeans ... regroupentl'ensemble de ces fonctionnalités). Pourquoi utiliser autre chose ?

Lorsque l'on travaille sur des machines distantes, il est parfois di�ciled'utiliser des outils nécessitant d'exporter le X.

Les IDE reposent sur la plupart des outils que nous allons lister pourchacune des fonctionnalités qu'ils o�rent.

Il est parfois utile de comprendre ce que l'on génère avec un IDE (pourvoir ce qui ne va pas).



Eclipse

Eclipse (projet de la Fondation Eclipse) : environnement dedéveloppement libre, extensible, universel et polyvalent.

Créé en 2001 sous l'impulsion d'IBM pour contrer Sun qui a sonpropre IDE (NetBeans).

Architecture volontairement orienté vers l'ajout de plugin.

Permet de gérer des projets dans plus de 20 langages di�érents.

Maintenu, mis à jour régulièrement.

Très répandu en entreprise.

Mais ce n'est pas le seul !





Editer son code

Compiler : gcc

Outil de build

Debugguer





Les outils à disposition

Si l'on ne dispose pas d'a�chage graphique, on doit passer par un éditeuren ligne de commande, tels que :

vi : date de ... 1976. Installé par défaut sur l'immense majorité deslinux.

emacs : date aussi de 1976. A peine moins installé que vi. Utilise lisppour ses plug-in. A de nombreux fans.

nano : date de 2000. Inclus la coloration syntaxique par exemple.

pico : éditeur de texte par défaut pour le logiciel CLI pine (email).Sous licence. nano est basée sur l'interface pico.



Editeur de texte vi

vi : Visual Interface

Ecrit par Bill Joy en 1976 (Unix BSD),

Vi est l'un des éditeurs de texte CLI les plus populaires sous Linux(avec Emacs).

Editeur en mode texte, ce qui signi�e que chacune des actions se fait àl'aide de commandes texte. (Très pratique en cas de nonfonctionnement de l'interface graphique ...).

Très puissant par un système de commandes (et de macros)

On ne quitte jamais le clavier des doigts, donc très rapide quand on al'habitude



vi : modes de fonctionnement

Vi possède plusieurs modes de fonctionnement. Les 2 principaux modessont :

Mode commande : mode à l'appel de l'éditeur.De nombreusescommandes peuvent être e�ectuées avec des séquences de touchessimples :

Exemple1 : d3w pour "delete 3 words" e�ace les 3 mots qui suiventExemple2 : c2fa pour "change le texte jusqu'à ce qu'il trouve le 2ièmea"Les touches tapées en mode commande ne sont pas insérées dans letexte

Mode insertion :

Le texte tapé est inséré dans le documentPassage d'un mode à l'autre ESc ou a A i I ...



vi : commandes de base

Depuis le SHELL, pour appeler vi : vi nom_�chier . Crée le �chier si iln'existe pas (si on a les droits ...)

Pour sauvegarder un �chier, en mode commande : :w (pourenregistrer) q (pour quitter)

Pour sortir sans sauvegarder, en mode commande : :quit ! (ou q !)



Autres commandes de base

Déplacements :

h, j, k, l pour se déplacer caractère par caractèrew, b pour se déplacer par motngg pour aller à la nième ligne (identique à :n)$, ^

pour aller en �n ou en début de ligne

E�acement :

x pour e�acer un chardd pour e�acer une ligne (ndd pour e�acer n lignes)

Recherche :

/motif pour rechercher un motif (n pour trouver le suivant)

Remplacement :

r remplace le char sur lequel on se trouve par celui qui sera tape apresle rcw pour "change word"

Commande a l'appel :

vi -c "1,%s/Deux/Trois/g|:wq" mon_fichier



Conclusion sur vi

On utilisera une version améliorée : vim

Vim : logiciel libre. Son code source a été publié pour la première foisen 1991 par Bram Moolenaar, son principal développeur.

VI aMélioré car il possède un langage de macro.

Il existe aussi une version graphique de vi permettant l'utilisation de lasouris (gvim) non installée dans la salle Linux 216.



Compiler : gcc

GCC et gcc

GCC (GNU Compiler Collection, à l'origine GNU C Compiler).

Permet de compiler du C,Mais aussi du C++, Ada, Fortran, Pascal, VHDL, D, Objective C...On parle de gcc quand on veut compiler du C.

gcc (gnu c compiler)

gcc est utilisé pour compiler le noyau linuxgcc a de très nombreuses options (une quarantaine). Les plus utiliséessont :

-I : include-L : link-l : librairies à linker-O<number> : optimisation du code-Werror : Warning traités comme des erreurs-D : passer des paramètres



gcc

Beaucoup d'options : beaucoup de possibilités de se tromper !Un exemple d'appel gcc pris au hasard :

/usr/bin/gcc -Dgras_EXPORTS -O0 -Wall -Wunused

-Wmissing-prototypes -Wmissing-declarations

-Wpointer-arith -Wchar-subscripts -Wcomment

-Wformat -Wwrite-strings -Wno-unused-function

-Wno-unused-parameter -Wno-strict-aliasing

-Wno-format-nonliteral

-Werror -L/usr/lib -I/usr/include -g3 -fPIC

-I/home/lbobelin/postdoc/projects/simgrid/simgrid

-I/home/lbobelin/postdoc/projects/simgrid/simgrid/include

-I/home/lbobelin/postdoc/projects/simgrid/simgrid/src

-I/home/lbobelin/postdoc/projects/simgrid/simgrid/src/include

-I/home/lbobelin/postdoc/projects/simgrid/simgrid/build

-I/home/lbobelin/postdoc/projects/simgrid/simgrid/build/include

-I/home/lbobelin/postdoc/projects/simgrid/simgrid/build/src

-o CMakeFiles/gras.dir/src/gras/Virtu/gras_module.c.o

-c /home/lbobelin/postdoc/projects/simgrid/simgrid/src/gras/Virtu/gras_module.c



gcc

gcc est le compilateur standard sous linux

Il existe des portages sur les principaux OS (windows, macOS) et pourbeaucoup de microprocesseurs (AMD64, ARM, DEC Alpha, M68k,MIPS, PowerPC, SPARC, x86, Hitachi H8).

Il existe des alternatives (PathScale, TinyCC) mais leur utilisationreste exotique.

On utilisera gcc pour compiler. Mais comme tout compilateur, il a sesinconvénients ...

gcc est un outil très puissant ...

... Utilisable "à la main" quand on travaille sur des micro-projets,

Il est vital d'utiliser des outils de build dès que l'on passe à des projetsde taille même moyenne



Build ?

Dé�nition

construction de l'exécutable à partir des sources fournis et des bibliothèqueà lier.

Il existe beaucoup d'outils de build :

make : outil de build sous-jacent a pas mal de IDE. Se base sur desMake�le.ant : Même utilisation que make, mais plus facile d'accès. Utilisé parNetBeans pour générer du code. Orienté java à la base. Syntaxe XML.Automake/Autoconf : outil GNU pour faire du "make", mais portable.Génère un Make�le.cmake : moteur de production multiplate-forme. Permet de générer les�chier make (mais pas forcément) avec une interface de plus hautniveau. 2 phases : on génère les �chier de build (make�le par exemple)et ensuite on utilise ces �chiers. De plus en plus utilisé (gcc parexemple pour se compiler)



make

Maintient la cohérence entre un programme exécutable et les �chierssource permettant de le produire.

basé sur les dates de dernière modi�cation de �chiernécessite un script contenant des règleschaque règle indique le moyen de construire une cible particulière àpartir des ressources dont il a besoinsi une cible est moins récente que une de ses cibles, elle estautomatiquement reconstruite.

Exécution :

make -f [ fichier_script] [cible]

si l'option -f est absente, le �chier du répertoire courant appeléMake�le ou make�le est utilisé.Si cible est absente, la première cible est considérée



Make�le : syntaxe

# : commentaire jusqu'à �n de ligne Chaque règle contient : La premièreligne : une cible ' : ' un ensemble des ressources dont dépend la cible Leslignes suivantes : commencent par une tabulation expriment les commandesà exécuter pour construire la cibleExemple

# Construction du programme executable

executable : fich1.o fich2.o fich3.o

<tab> gcc -ansi -Wall -o executable fich1.o fich2.o fich3.o

# Construction du fichier fich1.o

fich1.o : fich1.c fich1.h fichier_entete.h

<tab> gcc -ansi -Wall -o fich1.o -c fich1.c



Make�le : un exemple

CC=gcc

RM=rm -f

CFLAGS= - ansi -Wall

OBJECTS = f1.o f2.o

all: executable

# %.o : %.c similaire .c.o

# $< premiere dependance

%.o: %.c fichier.h

$(CC) $(CFLAGS) -c $@ $<

# $@ indique le nom de la cible

executable: $(OBJECTS)

$(CC) $(CFLAGS) -o $@ $(OBJECTS)

# Si un fichier clean existe - execution de la commande

.PHONY : clean

clean:

$(RM) $(OBJECTS) executable *~

Construction automatique de la liste des �chiers objets

SRC= hello.c main.c

OBJECTS= $(SRC:.c=.o)

Commande silencieuse pour ne pas a�cher les messages

@$(CC) $(CFLAGS) -c $@ $<





Editer son code

Compiler : gcc

Outil de build

Debugguer





Debugguer ?

Dé�nition

partir à la recherche d'erreurs dans le code, de fuite mémoire, etc.

Il existe aussi beaucoup d'outils de debug, comme par exemple :

gdb : The GNU Project Debugger. Richard Stallman, 1988. Standardsous linux, mis à jour régulièrement. Vous permet de :

De démarrer vos programmes, en spéci�ant quoi que ce soit que puissechanger son comportementFaire stopper votre programme quand certaines conditions sontréalisées.Examiner ce qui s'est passé, une fois que votre programme a stoppé.Changer des choses dans votre programme, pour corriger les e�ets d'unbug et en chercher un autre.

ddd : Interface graphique pour gdb.



Debugguer ? (suite et �n)

Valgrind : libre, pour déboguer, e�ectuer du pro�lage de code etmettre en évidence des fuites mémoires.

Utilisation de la mémoire (free, memory links, etc)Exploration de la pileStatistique d'utilisationUtilisation de zone mémoire non allouée ou non initialisée...

kdbg, que vous avez utilisé l'an dernier.


Les includes importants de la programmation système



Editer son code

Compiler : gcc

Outil de build

Debugguer





Les includes de la prog système

La bibliothèque standard C de la norme ISO est minimaliste (24 includesstandards)

fonctions mathématiques,

manipulation de chaînes de caractères,

conversion de types,

entrée/sortie maniant les �chiers et les terminaux

Les fonctions habituellement classiques dans les autres langages (et doncceux de la prog système) et ne sont donc par des standards de la normeISO !



Norme POSIX

Pour remédier à cela, la norme POSIX a été créée.

POSIX

famille de standards IEEE 1003 (début 1988)

POSIX : Portable Operating System Interface, X pour Unix

Interfaces utilisateurs, interfaces logicielle

Librairie POSIX C : donne les headers pour les fonctionnalitésmanquantes dans l'ISO/ANSI

18 �chiers d'includes qui viennent compléter les fonctions systèmes déjào�ertes.



Les includes POSIX

<cpio.h>

Magic numbers for the cpio archive format. (deprecated)<dirent.h>

Allows the opening and listing of directories.<fcntl.h>

File opening, locking and other operations.<grp.h>

User group information and control.<pthread.h>

De�nes an API for creating and manipulating POSIX threads.<pwd.h>

passwd (user information) access and control.<sys/ipc.h>

Inter-process communication (IPC).<sys/msg.h>

POSIX message queues.<sys/sem.h>

POSIX semaphores.



Les includes POSIX - 2

<sys/stat.h>

File information (stat et al.).<sys/time.h>

Time and date functions and structures.<sys/types.h>

Various data types used elsewhere.<sys/utsname.h>

uname and related structures.<sys/wait.h>

Status of terminated child processes (see wait)<tar.h>

Magic numbers for the tar archive format.<termios.h>

Allows terminal I/O interfaces.<unistd.h>

Various essential POSIX functions and constants.<utime.h>

inode access and modi�cation times.


Gestion de �chier Pourquoi ?



Editer son code

Compiler : gcc

Outil de build

Debugguer




Gestion de �chier Pourquoi ?

Système de gestion de �chiers

3 grands types de �chiers :

Texte : (codage ASCII, UTF-8, ISO-8859-1 (latin 1)), utilisé par leséditeurs de texte

Binaire : i.e. code machine, programme exécutable

Spéciaux : imprimante, terminal, mémoire, modem,. . .

Sous Unix, un �chier est un objet typé dont le type permet de dé�nirl'ensemble des opérations applicables. D'un point de vue interne, à chaque�chier correspond une entrée dans une table contenant l'ensemble desattributs (type, propriétaires, droits, . . . ). Une telle entrée est appeléei-node (index node). Un �chier a donc comme identi�cation un coupleconstitué de l'identi�cation de la table dans laquelle est enregistré sescaractéristique (on parle de disque logique), et de l'indice dans cette table.


Gestion de �chier Comment ?

inode

Structure d'un i-node :

L'identi�cation du propriétaire et du groupeLe type de �chier et droits d'accès des di�érents utilisateursLa taille du �chier exprimée en nombre de caractères (pas de sens pourles �chiers spéciaux)Le nombre de liens physiquesLes trois dates signi�catives (lecture, modi�cation du �chier etmodi�cation du n÷ud)L'identi�cation de la ressource associée (pour les �chiers spéciaux)Adresse sur le disque...

La commande stat donne les informations sur un noeud Exemple :

frousse@altamaha:~$ stat exo.c

File: `exo.c'

Size: 331 Blocks: 8 IO Block: 4096 regular file

Device: 900h/2304d Inode: 47579146 Links: 1

Access: (0644/-rw-r�r�) Uid: ( 1010/ frousse) Gid: ( 1002/ sls)

Access: 2008-02-14 09:55:40.000000000 +0100

Modify: 2007-10-30 16:06:42.000000000 +0100

Change: 2007-10-30 16:06:42.000000000 +0100



Information sur les i-nodes en C

On accède en C à toutes ces informations par la structure stat dé�nie dans

<sys/stat.h>

struct stat

dev_t st_dev; /* ID of device containing file */

ino_t st_ino; /* inode number */

mode_t st_mode; /* protection */

nlink_t st_nlink; /* number of hard links */

uid_t st_uid; /* user ID of owner */

gid_t st_gid; /* group ID of owner */

dev_t st_rdev; /* device ID (if special file) */

off_t st_size; /* total size, in bytes */

blksize_t st_blksize; /* blocksize for filesystem I/O */

blkcnt_t st_blocks; /* number of blocks allocated */

time_t st_atime; /* time of last access *

time_t st_mtime; /* time of last modification */

time_t st_ctime; /* time of last status change */

;

On peut changer le contenu de cette structure avec la fonction stat

int stat(const char *ref, struct stat *ptr);



SGF

En fait, il existe plusieurs tables de �chiers . . . chacune correspondantà une arborescence indépendante. La racine de ses arborescences acomme index 2.Les di�érentes arborescences peuvent être reliées entre elles par unmécanisme de montage : il s'agit de gre�er la racine d'unearborescence non encore montée, en un point accessible depuis laracine absolue

La commande SHELL de montage est mount. Par exemple, pourmonter votre clé USB : mount /dev/sda1 /media/CleUSB. On obtientla racine du disque logique avec dmesgLa commande pour démonter est umount : umount /media/CleUSB

Ce mécanisme de montage peut être étendu a�n de permettre l'accèsaux �chiers appartenant à des systèmes distants : le protocole le plusutilisé est NFS (Network File System)L'objectif fondamental est de permettre un accès aux �chiers distantspar l'intermédiaire des mêmes fonctions génériques que celles utiliséespour les �chiers locaux (open, read, write). Problème de sécurité . . .et de cohérence des informationsL.Bobelin (MESCAL) 2011 29 / 31


Les primitives de base : open, close, read, write

Open : permet à un processus de réaliser l'ouverture de �chier, càddemande l'allocation d'une nouvelle entrée dans la table des �chiers ouvertsdu système. Si c'est possible, on charge le i-node correspondant enmémoire. Un descripteur est alloué dans la table des descripteurs duprocessus. La fonction est

int open(const char *ref, int mode_ouverture, ... /* mode_t */);

ref est le nom du �chier mode_ouverture (attention au mode bloquant...)

O_RDONLY, O_WRONLY, O_RDWD, O_CREAT, ...

obtenu par disjonction logique En cas de succès, la valeur retournée estl'indice, dans la table des descripteurs du processus, du descripteur alloué(on l'appelle le descripteur). De plus, la position courante dans le �chier estégale à 0 (début de �chier).Exemple : Pour créer un �chier : fonction creat() ou

open ("fichier_essai", O_WRONLY|O_CREAT|O_TRUNC, 666);

O_WRONLY|O_CREAT|O_TRUNC similaire "w" pour fopen()



Les primitives de base : open, close, read, write

close : ferme le descripteur

int close(int descripteur);

read : lecture de �chier

ssize_t read (int descripteur, void *ptr, size_t nb_octets);

Demande de lecture d'au plus nb_octets caractères via le descripteur. Lescaractères lus sont écrits dans l'espace d'adressage du processus à l'adresseptr.write : ecriture de �chier

ssize_t write (int descripteur, void *ptr, size_t nb_octets);

Demande d'écriture dans le �chier descripteur de nb_octets caractèrestrouvés à l'adresse ptr.


unix - e2i5 - introduction à la programmation système sous...

Documents