Programmation système

3 ème année Licence d Informatique Programmation système Philippe Lahire & G. Menez Université de Nice Sophia-Antipolis Septembre 20 Ce cours fait de nombreux emprunts à celui de R. Rousseau Version Septembre 20 N 2 Organisation du cours ère partie : outils de développement G. Menez : 3 premiers cours 2 ème partie : prog système Planning : Cours: 9 séances (h30) TP: 8 ou 9 séances (3h) Contrôle continu : TP: deux à trois TP notés deux partiels Note complémentaire : Le travail : Motivation, Compréhension, Progression, La tenue : Assiduité, Respect, Matériel : PC 3 ème étage

Version Septembre 20 N 3 Acquisition (cours Système de L2) Notion de processus + API (fork, exec) Système de Fichiers Entrée-sortie + API (read, write ) Tubes + API (pipe) Signaux + API Sockets + API Langage : principalement python complété par du C Version Septembre 20 N 4 Démarche proposée Evaluation: compréhension des concepts acquis Approfondissement des concepts vues Reprise détaillée des concepts + complément Apprentissage de nouveaux concepts TPs plus approfondis en C Adaptation de la rapidité en fonction de la compréhension 2

Version Septembre 20 N 5 Organisation des enseignements cours Introduction + Entrées-Sorties E/S 2 Entrées-Sorties + Syst. Fichiers Syst. Fichier 3 Syst. Fichiers Syst. Fichier 4 Processus Process. 5 Processus Process. 6 Tubes Tubes 7 Signaux Signaux 8 IPC-Système V IPC 9 TP Selon avancement : Ajout Thread posix + Gestion mémoire virtuelle Programmation «réseau» Version Septembre 20 N 7 Tentative de bibliographie C Windows Uni ix Concepts. S. Harbison & G. Steele Jr. C, a reference manual (st ed. 984) Prentice Hall, 2nd edition, 987, 404 p. 2. B. Kernighan & D. Ritchie The C Programming g Language g (st ed. 978),, Prentice Hall, 2nd ed., 988. Traduction française Masson, 990. 3. A. Tannenbaum Systèmes d exploitation : systèmes centralisés, systèmes distribués MacGraw Hill, 990. Traduction française (2e ed) Dunod, 999 4. A. Siberschatz & P. Galvin Operating Systems Concepts, 5e ed, Addison-Wesley, 998. 5. J. Beauquier & B. Berard Systèmes d exploitation : concepts et algorithmes MacGraw Hill, 990. 6. W. Stevens Advanced Programming in the Unix environment Addison Wesley, 992, 744 p. 7. M.J. Bach Conception du système Unix, Prentice Hall, 986. Traduction française Masson, 99. 8. J.M. Rifflet La programmation sous Unix, Ediscience intern., 3ème éd., 993, 630 p. 9. U. Vahalia Unix Internals : the new Frontiers Prentice Hall, 996 0. A.D. Solomon Le guide officiel sur l architecture et le noyau Windows NT 2nd ed., Microsoft Press, 998.. Site microsoft 3

Version Septembre 20 N 8 Documentation en ligne Sur le langage C En L2MI (Gilles Menez) : www-mips.unice.fr/ menez/l2/l2cours.html Cours vidéo sur le langage C de l Université de Paris VI : www.infop6.jussieu.fr/cederoms/videoc2000/ Sur la programmation réseau : Cours réseau du CNRS : www.urec.fr/cours Cours programmation réseau avec sockets, de Brian "Beej" Hall : www.ecst.csuchico.edu/ beej/guide/net/html/. id h A propos de l UE «Programmation système et réseau» : Site web officiel de cet enseignement : http://deptinfo.unice.fr/~lahire/enseignement/sysl3 Chapitre : Présentation générale 4

Version Septembre 20 N 0 Chapitre : Présentation générale Historique des systèmes UNIX Vers une normalisation: POSIX Unix propriétaires ou Linux Survol de l'architecture Noyau du système Principales caractéristiques Rappels des notions de base: le Shell Principales commandes Interprétation de commande Notion de base: La session, le manuel, Parallèle avec Windows Version Septembre 20 N 3 Vers une normalisation: POSIX Portable Open System Interface exchange Norme IEEE & Description: 003.0: Guide et présentation 003.: Bibliothèque de fonctions 003.2: Shell et utilitaires 003.3: Méthode de tests et conformité 003.4: Extension temps réel 003.5: Form. appels systèmes en ADA 003.6: Sécurité 003.7: Administration système 003.8: Accès commun aux fichiers 003.9: Interface sous Fortran 77 003.0: Interface supercalculateurs Normes: ISO 9945- ( P003.) 5

Version Septembre 20 N 4 Unix propriétaires ou Linux Linus Torvald (FIN-9 sur i386) Philosophie Un noyau et des outils de base Indépendant de tout constructeur Libre et Basé sur des contributions bénévoles (GPL) Organisation en projets ambitieux (FSF, SourceForge) Un grand nombre d'utilisateurs motivés Un excellent produit : stable et code original libre de droits Porté un grand nombre d'architectures : SPARC, INTEL, ALPHA, MAC, Quelques projets: Apache Gnome GNU Version Septembre 20 N 5 De nombreuses distributions Linux Les différences Nom: Debian, Redhat, Suse, Mandrake, Prix (commerciale ou pas), Nombre de logiciels, Versions des logiciels, Pilotes supportés, Organisation des fichiers de configuration, Procédures d'installation, Sérieux de la gestion (site web, mise à jour, etc.), Fréquence des versions Certifications, Mais encore: Debian: de 4500 à 9000 Logiciels, Orienté informaticien, Une dérive vers l'automatisation, 6

Version Septembre 20 N 6 Survol de l'architecture () UTILISATEUR Interface Utilisateur PROGRAMMES UTILITAIRES STANDARD Shell, éditeur, compilateur, Interface Bibliothèques BIBLIOTHEQUE STANDARD fopen, fclose, fread, fwrite, Interface Appels Systèmes SYSTEME D EXPLOITATION UNIX Gestion des processus, de la mémoire, des E/S, MATERIEL: UC, mémoire, disques, terminaux, etc Autre système en couche : logiciels réseaux suivant norme - OSI Version Septembre 20 N 9 Noyau du système Programme Utilisateur Bibliothèques Interface des appels systèmes Sous-systèmes de contrôle de fichiers Sous-systèmes de contrôle des processus Communication interprocessus Ordonnanceur Gestion mémoire Cache Buffer Caractère Bloc Contrôleurs de périphériques Contrôle de la partie matérielle PARTIE MATERIELLE 7

Version Septembre 20 N 2 Principales caractéristiques Langage de haut niveau Le noyau : plus d' million de lignes de C Expressivité et simplicité de l'interface Construction de programmes: des primitives élémentaires Un système de fichiers «hiérarchique» Un format cohérent de fichier (octet) Accès aux périphériquesp é Multi-utilisateurs et multitâches Indépendance avec l'architecture matérielle 54 % du code Mémoire virtuelle (versions actuelles) Version Septembre 20 N 23 Notion d interprète de commandes Shell : Interface textuelle vers le système Fonctionnalités Message d'invitation (prompt) Attend la saisie d'une commande Commandes internes Commandes externes (charg. + exec. programmes) Historique des commandes précédentes Redirections et tubes Structures de contrôles (boucles, tests, fonctions,...) Mécanisme d'alias, variables d'environnement Gestion de processus 8

Version Septembre 20 N 24 Différents shells unix possibles Bourne shell (historiquement, le er) Toujours utilisé par les scripts internes du système C-shell (csh, tcsh) syntaxe différente Évolutions du Bourne shell ksh (Korn shell) Où indiquer le shell par défaut? bash (Bourne Again shell): le shell du projet GNU zsh: Évolution prétendument "ultime" du bourne shell Améliorations : historique, complétion,... Possibilité de (demander à) changer le shell par défaut lancé automatiquement au début de session Version Septembre 20 N 25 Quelques éléments d administration /etc/passwd nom_du_compte : mot_de_passe : numero_utilisateur : numero_de_groupe : commentaire : répertoire : programme_de_demarrage demarrage root:x:0:0:root:/root:/bin/bash bin:x:::bin:/bin:/bin/bash daemon:x:2:2:daemon:/sbin:/bin/bash news:x:9:3:news system:/etc/news:/bin/bash user:x:500:00:mr User...:/home/user:/bin/bash /etc/group nom_de_groupe : champ_special : numero_de_groupe : membre, membre2 root:x:0:root bin:x::root,bin,daemon daemon:x:2: users:x:00: 9

Version Septembre 20 N 30 Caractéres spéciaux du shell Pas en C Certains caractères ont une signification spéciale pour le shell * : 0 ou plusieurs caractères quelconquesq t*o : nom de fichier qui débute par t et finit par o? : (et un seul) caractère quelconque t?t? : désigne toto ou titi ou ttta,... \ : enlève la signification spéciale du caractère qui suit t\*to : désigne t*to Certaines constructions ont une signification spéciale [a-z] : un caractère entre a et z (a ou b ou c... ou z) [aefgij] : un caractère (et un seul) parmi a,e,f,g,i,j t[oau]t[oau] : toto, ou totu, ou tata, ou tato,... {mot,mot2} : soit mot, soit mot2 Version Septembre 20 N 36 Notions de base: Le manuel Principales sections (environ 20 Mo) taille dépendante des paquetages - nyx : ( 20 Mo de.gz ) man: Commandes utilisateurs à partir shell ( 800) man2: Primitives du noyau ( 250) man3: Routines C ( 400) man4: Fichiers spéciaux: les pilotes des périphériques (disque dur, clavier/écran, graveur, lecteur de dvd, zip, mémoires usb...) ( 90) man5: Formats de fichiers et protocoles ( 200) man7: Format des systèmes de fichiers, jeux de caractères, macros, nroff... ( 80) man8: Commandes d administration à partir shell ( 450) man9: routines du noyau non standards ( 90) Attention : Un ordre d'évaluation Base whatis: recherche de commandes apropos: recherche de mots clés 0

Version Septembre 20 N 37 Anatomie d une page de manuel () Section Brève description Syntaxes possibles Description détaillée de la commande Description détaillée des options (ordre alphab.) Prompt du «PAGER» 'q' : quit 'b' : retour p. < spc> : défil p. < enter> : défil l. /xy : rechercher «xy» Version Septembre 20 N 38 Anatomie d une page de manuel (2) Autres pages intéressantes sur un sujet voisin Nul n'est parfait... Parfois ambiguës ou confuses Version anglaise (défaut) : unset LANG LC_ALL puis man à nouveau...

Version Septembre 20 N 40 Principe général d'utilisation /* Fichier Z2.h */ R (int i) Z.o Zlib.a man r PREPROCESSEUR /* Fichier Y.c */ #include "Z2.h" main () { /* MAN!!!!! */ R (23)... } Z2.o... R (int i) {...}... Z3.o COMPILATION Y.o a.out EDITION DE LIEN Version Septembre 20 N 4 Traitement standard des erreurs () Exception vs compte-rendu Presque toutes fonctions/appels systèmes entier pointeur normale : positive ou nulle, non void, anormale : négative ou void Utilisation de errno : Syntaxe : extern int errno ; n dernière erreur détectée par un appel système pas remise à zéro à chaque appel. intro(2) : liste des différents codes Méthodologie : test compte-rendu + errno 2

Version Septembre 20 N 42 Traitement standard des erreurs (2) Fonctions associées #include <string.h> char* strerror (int errnum) retourne message «en clair» associé à errnum #include <stdio.h> void perror (const char* message) affiche «message» + message associé à errno (stderr) Méthodologie : utiliser en s appuyant sur «man» (Errors / Erreurs) ou traitement ad hoc (ex: gestion paramètres de «main») Version Septembre 20 N 43 Traitement standard des erreurs (3) Exemple #include <string.h> #include <stdio.h> int main (int argc, char* argv[]) { FILE* fichier; if (argc!= xxx) { ici > fprintf(stderr, «nombre paramètres incorrect»); exit() } if ( (fichier = fopen(argv[], «rw»)) == NULL) { fprintf(stderr,«erreur %i:%s \n», errno, strerror(errno)); exit(2); } } 3

Version Septembre 20 N 44 Traitement des erreurs de W. Stevens () + return + exit() + abort format message d erreur avec nb %+ nb arguments Affiche aussi le message associé à errno Macros : en majuscule et sans paramètre Pas de message passé en paramètre mais : Affichage: Nom du fichier + numéro de ligne Version Septembre 20 N 45 Traitement des erreurs de W. Stevens (2) Exemple #include <stevens.h> Pas par défaut dans linux #include <stdio.h> int traiter_fichier (char* f) { FILE* fichier; char tab[30]; if ( (fichier = fopen(f, «rw»)) == NULL) ERR_EXIT; if (fclose(fichier))!= 0) ERR_RETURN; } 4

Chapitre 2: Entrées - Sorties Version Septembre 20 N 47 Plan de travail Principes généraux Structures internes Hiérarchie de descripteurs Tables pour la gestion des entrées-sorties Principaux appels systèmes Ouverture / fermeture de fichiers: open, close Entrées-sorties: read, write Positionnement : lseek, fseek Duplication en vue de redirection : dup, dup2 5

Version Septembre 20 N 48 Mise au point / Survol bash gcc emacs FILE* fopen (.) { } int open (.) { } int read (.) { } Consulte / met à jour «appelle» / exécute Système exploitation Bien sur on se sert aussi du «shell» pour lancer un programme Tables : Fich. Ouvert Volumes Blocs. processus Version Septembre 20 N 49 Principes généraux () Sous UNIX: tout est fichier Périphérique, réseau, mémoire... Fichier = une suite d octets Organisation : Hiérarchie de Système de fichiers (partitions ) répertoires Exemples : «hardware» (/dev) Accès au réseau (sockets) Tb Tubes persistants it t (FIFO) Tables du noyau(tdf) Fichiers «normaux» (en anglais Regular) ) Liens entre fichiers (symboliques et physiques) Fichiers virtuels (/proc) Fichiers spéciaux (périphériques,fifo, ) Montage : local distant 6

Version Septembre 20 N 50 Principes généraux (2) Méthodes d accès Séquentiel (read) Direct - unité: l octet (lseek) Protection propriétaire, groupe d utilisateurs, les autres Pas de journal (log) mais possibilité de verrous Généralité + simplicité Implantation de SGBD : bonne aptitude fichiers à trou, accès direct, octets mécanismes additionnels non intégrés: évolution (gestion des versions), typage des données, système transactionnel (SGBD), Version Septembre 20 N 5 Principes généraux (3) Deux points de vues Utilisateur (commandes, applications, ) Programmeur (C et appels systèmes) Utilisateur échanges entre un processus et des entités : disque, machine distante, autre processus, terminal... Fichier au sens large Programmeur Echanges avec n importe quelle entité par des flots d octets consécutifs Accès direct possible sur des disques locaux ou distants (curseur lecture/écriture) 7

Version Septembre 20 N 52 Principes généraux (4) Disque Une suite d octets Tampon Mémoire F.D. Curseur Programme Descripteur de fichier : Prédéfini (fich. Stand.) A associer (open) Simple numéro Version Septembre 20 N 53 Principes généraux (5) Dans le programme Association (open ) p nom externe / Desc. Fichier chemin relatif chemin absolu Pas de caractère générique Utilisation (read, write ) Desc. Fichier: numéro de voie obtenu par association prédéfini : 0 : voie standard d entrée : voie standard de sortie 2 : voie standard d erreur Appel du programme chemin relatif chemin absolu On n utilise jamais directement Le clavier ou l écran 8

Version Septembre 20 N 54 Un modèle d E/S adaptable aux langages Impact: Performance Utilisation Un modèle d entrée sortie de bas niveaux Langage C Java Version Septembre 20 N 55 Modèle langage C vs Modèle UNIX Appels systèmes () open, lseek, write, stat... Mécanismes de base Streams et routines C (2) isastream, fopen, fseek, fread, fwrite, fgets, feof,... Notion de stream Remarques et Conclusion Mode noyau et Préemption struct FILE vs numéro d'entrée dans la TDF lect./écr. d'enregistrement vs d'octet (2) utilise () signatures de (2) indépendantes du système, mais l'implémentation dépend elle, du système... qu'en concluez vous? 9

Version Septembre 20 N 56 Qu'est-ce qu'un processus Définitions Instruction = indécomposable et indivisible Processeur =... Processus = exécution d'un programme (instructions + données) Approche intuitive UNIX = système "temps partagé Plusieurs processus en même temps Un seul processus actif Attente des autres (dans/hors mémoire) Version Septembre 20 N 57 Tables pour gérer les fichiers Privé Tables partagées P 0 2 3 4 5 Tables Descripteurs Fichiers Processus Processus P2 0 2 3 4 5 Position : État : N inode : Nombre : Nb. copies : Inode Infos Position : État : Nombre : Position : État t : Nombre : Position : État : Nombre : N inode : Nb. copies : Inode Infos N inode : Nb. copies : Inode Infos Espace utilisateur Table fichiers Table inodes 20

Version Septembre 20 N 58 Modèle UNIX - Synthèse Trois points de vues Le processus L usage Le «fichier» Rôles : Gestion des voies d échange Gestion du curseur Gestion des protections Deux abstractions (par point de vue) Processus : Usage et nature du fichier Usage : raison de l utilisation par le processus et la nature du fichier «Fichier»: raison de l utilisation et usage du fichier Permettre le partage D un même usage par un/plusieurs processus D un même fichier par un/plusieurs processus D une même fichier par un/plusieurs usages Version Septembre 20 N 59 Ouverture/Création d un fichier: open Descripteur de fichier Nom fichier Mode d ouverture Lors de la création: f(perm,umask) Mise à jour des tables internes (processus + noyau) Oflags/perm : 9/5 macros dans les fichiers.h Un petit ensemble de combinaisons valides Les incohérences ne sont pas détectés 2

Version Septembre 20 N 60 Ouverture/Création: open (oflags) Valeurs possibles O_CREAT: création, si le fichier n existe pas O_ EXCL: combiné avec O_ CREAT, création si le fichier n existe pas, erreur sinon O_RDONLY: ouverture en lecture seule. O_WRONLY: ouverture en écriture seule (création ou ajout) O_RDWR: ouverture en lecture et écriture (mise à jour n importe où) O_ TRUNC: libération du contenu du fichier, s il existe + curseur placé en début de fichier O_APPEND: contenu du fichier non touché + curseur placé en EOF O_SYNC: attend la fin d écriture sur le média après chaque write (pas de cache) O_NONBLOCK: E/S non bloquantes. Version Septembre 20 N 6 Ouverture/Création: open (oflags) Règles et choix incohérents Choisir l un des 3 types exclusifs d action : O_RDONLY, O_WRONLY, O_RDWR + O_CREAT si la création est permise O_RDONLY O_EXCL si le fichier ne doit pas déjà exister O_WRONLY + O_CREAT O_TRUNC ou O_APPEND pour placer le curseur au début (resp. à la fin) du fichier (doit donc déjà exister O_EXCL) O_SYNC si les écritures doivent être immédiates O_RDONLY. 22

Version Septembre 20 N 62 Ouverture/Création: open (oflags) Exemples open (nomfichier, O_RDONLY) Curseur au début du pour lire open (nomfichier, O_WRONLY O_CREAT O_TRUNC, ) [Création + effacement] si nécessaire + curseur au début pour écrire open (nomfichier, O_WRONLY O_APPEND, ) Curseur en fin pour écrire open (nomfichier, O_WRONLY O_CREAT O_APPEND, ) Création si nécessaire + curseur en fin pour écrire open (nomfichier, O_WRONLY O_CREAT O_EXCL, ) Création si n existe pas (erreur sinon) + curseur au début pour écrire open (nomfichier, O_RDWR) Doit exister + curseur au début pour lire ou écrire n importe où Version Septembre 20 N 63 Ouverture/Création: open (perm) Règle Les permissions associées à un fichier lors de sa création sont fixées par la conjonction de deux points de vue : Point de vue : du programmeur, qui propose des permissions logiques Ex: Compilateur: exécution / Editeur: lecture et écriture de l utilisateur, propriétaire des fichiers créés, qui peut interdire certaines permissions umask : pas de lecture/écriture pour les autres Masque interdictions Permission appliquée = perm &~umask 23

Version Septembre 20 N 64 Ouverture/Création: open (perm) Valeurs possibles Pour donner des droits Le propriétaire Le egoupepop Groupe propriétaire Les autres Version Septembre 20 N 65 Ouverture/Création: open (perm) Exemple 022 open («f», O_WRONLY O_CREAT, ) umask 0 0 0 0 0 0 0 Group = write ~ Other = write = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 & 755 0 0 24

Version Septembre 20 N 66 Création d'un fichier Equivalences open (path, O_WRONLY O_CREAT) creat (path, mode) mknod : Fichier spéciaux (FIFO,...) Deux Phases: création et ouverture Voir Communication inter-processus Paramètres oflag = 00000 00000 (O_RDONLY,...) Commande(s) associée(s): emacs, gcc, cp,... Structure(s) interne(s): tables, super-bloc Version Septembre 20 N 67 Création d'un fichier: mécanisme interne Etapes Localisation inode parent (I.P), Recherche nom fichier... Si le nom n existe pas alors: Verrouillage I.P., liste des inodes libres Allocation inode: inode-mémoire = get (inode-disque) Modification I.P.: Informations fichier Sinon (le nom existe) : Désallocation blocs: contenu fichier Non-Modification I.P. Importance des verrous et du mode noyau 25

Version Septembre 20 N 68 Ouverture/Création d'un fichier () Processus #include <sys/types.h> yp #include <sys/stat.h> #include <fcntl.h> int main () { int rfd, wfd, rwfd; Attention! if ((rfd = open("/etc/bashrc",o_rdonly)) < 0) erreur; if ((rwfd = open("/etc/bashrc", O_RDWR)) < 0) erreur; if ((wfd = open("/.bashrc",o_wronly O_CREAT)) < 0) erreur; } Action: ouverture: rfd, rwfd - création/ouverture: wfd Version Septembre 20 N 69 Ouverture/Création d'un fichier (2) Processus 2 #include <sys/fcntl.h> #include <sys/stat.h> #include <sys/types.h> int main () { int rfd, wfd; if ((wfd = open("/etc/bashrc",o_wronly)) < 0) erreur; if ((rfd = open("/.bash_profile",o_rdonly)) < 0) erreur; } Deux processus indépendants Des tables partagées et privées Action: ouverture: rfd -ouverture: wfd 26

Version Septembre 20 N 70 Ouverture d'un fichier: Vision interne Attention : partage possible dup/fork P Processus Processus P2 0 2 3 4 5 0 2 3 4 5 Espace utilisateur Position : État : Nombre : Position : État : Nombre : Position : État : Nombre : Position : État : Nombre : Position : État : Nombre : O_RDONLY O_RDWR O_WRONLY Table fichiers O_WRONLY O_RDONLY /etc/bashrc N inode : Nb. copies : Inode Infos /.bashrc N inode : Nb. copies : Inode Infos /.bash_profile N inode : Nb. copies : Inode Infos Table inodes 2 3 Version Septembre 20 N 7 Fermeture d un fichier: close Descripteur de fichier Mise à jour des tables internes (processus + noyau) fd est une entrée dans la TDF : open, fork, voie standard Fermeture par le noyau des fichiers à la terminaison d un processus (exit(?)) 27

Version Septembre 20 N 72 Fermeture d'un fichier Processus 2 #include <unistd.h> int main () { int rfd, wfd; /* Ouverture et utilisation */... close (rfd); /* exit: fermeture implicite */ close (wfd); /* exit: fermeture implicite */ } Tables fichiers/inodes Décrémentations compteurs Désallocations éléments Libération complète si le compteur atteint 0 Commande(s) associée(s): exit, éditeur Structure(s) interne(s): tables, buffers Version Septembre 20 N 73 Fermeture d'un fichier: Vision interne P Processus Processus P2 0 2 3 4 5 0 2 3 null 4 null 5 Espace utilisateur Position : État : Nombre : Position : État : Nombre : Position : État : Nombre : Position : État : Nombre : Position : État : Nombre : O_RDONLY O_RDWR O_WRONLY Table fichiers O_WRONLY O_RDONLY /etc/bashrc N inode : Nb. copies : Inode Infos /.bashrc N inode : Nb. copies : Inode Infos /.bash_profile N inode : Nb. copies : Inode Infos Table inodes 2 3 28

Version Septembre 20 N 74 Lecture d un fichier: read Nombre octets lus Descripteur fichier Nombre octets à lire Lieu de stockage données lues Mise à jour des tables internes (noyau) fd est une entrée dans la TDF ouverte en lecture : open, fork, voie standard Allocation de buffer impérative Nb octets lus Nb octets à lire (EOF, périphérique, ) Début = position du curseur Après = position + nb oct.lus Version Septembre 20 N 75 Lecture d'un fichier Processus #include <sys/types.h> #include <unistd.h> int main () { int rfd, nb; char tabp[30]; char tabg[024]; /* Ouverture rfd */... nb = read (rfd, tabp, 30); nb = read (rfd, tabg, 024); nb = read (rfd, tabp, 20); } Lecture à travers une même entrée Commande(s) associée(s): cat, more, emacs,... Structure(s) interne(s): tables, blocs, buffers 29

Version Septembre 20 N 76 Lecture d'un fichier: Commentaires Verrouillage/partage Durée d'un read Verrouillage explicite possible Schéma lecteur/écrivain possible Plusieurs descripteurs possibles Lecture réelle Attention: Lecture bloc par bloc Bloc dans le "buffer cache" ou sur le disque? Lecture anticipée Version Septembre 20 N 77 Lecture d'un fichier Processus #include <sys/types.h> #include <unistd.h> int main () { int rfd, rfd2, nb; char tab[30], tab2[30]; /* Ouverture rfd, rfd2 */... nb = read (rfd, tab, 30); nb = read (rfd2, tab2, 30); } Lecture à travers plusieurs entrées attention Ici: 2 descripteurs indépendance fork: "2" descripteurs dépendance 30

Version Septembre 20 N 78 Lecture d un fichier (2) Version Septembre 20 N 79 Ecriture dans un fichier: write Nombre octets écrits Descripteur fichier Nombre octets à écrire Données à écrire Mise à jour des tables internes (noyau) fd est une entrée dans la TDF ouverte en écriture : open, fork, voie standard Nb octets écrits Nb octets à écrire EOF, périphérique (imprimante, réseau ), signal, média/quota plein Début = position du curseur Après = position + nb octets écrits 3

Version Septembre 20 N 80 Ecriture dans un fichier Processus #include <sys/types.h> #include <unistd.h> int main () { int wfd, nb; char tab[30]; /* Ouverture wfd */ /* Remplissage de tab */... nb = write (wfd, tab, 30); /* Remplissage à partir de tab */... nb = write (wfd, tab, 30); } Commande(s) associée(s): cat, emacs, Structure(s) interne(s): Tables, blocs, buffer Version Septembre 20 N 8 Ecriture dans un fichier (2) 32

Version Septembre 20 N 82 Ecriture d'un fichier: commentaires Verrouillage/partage Durée d'un write Verrouillage explicite possible Schéma lecteur/écrivain possible Plusieurs descripteurs possibles Ecriture réelle Allocation de blocs par nécessité (indirect, données) Ecriture partielle Lecture du bloc Ecriture différée des blocs: "buffer cache" Version Septembre 20 N 83 Positionnement dans un fichier: lseek position Descripteur fichier Entier 64 bits déplacement Référentiel Mise à jour des tables internes (noyau) fd est une entrée dans la TDF ouverte en écriture : open, fork, voie standard Retour = position par rapport au début du fichier Référentiel = SEEK_SET, SEEK_CUR, SEEK_END déplacement positif/négatif avant (resp. après) le début (resp. fin) 33

Version Septembre 20 N 84 Positionnement : commentaires Référentiel : SEEK_SET SET : par rapport au début SEEK_CUR: par rapport au curseur SEEK_END :par rapport à la fin Comment connaitre la position courante? On peut se positionner i après la fin Toute écriture crée des trous La lecture de trous rend des octets nuls Une position négative est souvent une erreur Version Septembre 20 N 85 Positionnement dans un fichier #include <sys/types.h> #include <unistd.h> int main () { int fd, pos; char tab[30]; /* Ouverture fd */... pos = lseek (fd, 000, SEEK_CUR); // voir aussi SEEK_SET pos = lseek (fd, -50, SEEK_END); } read/write accès séquentiel lseek accès direct Pas d'accès disque Commande(s) associée(s): éditeur Structure(s) interne(s): tables des fichiers 34

Version Septembre 20 N 86 Duplication d entrée: dup2 Descripteur fichier à dupliquer Descripteur fichier où copier Mise à jour des tables internes (processus et noyau) fd est une entrée dans la TDF fd2 est une entrée libre (ou qui sera fermée) le contenu de fd est recopié dans fd2 + MAJ de compteurs de références dup réalise la copie dans la première entrée libre Version Septembre 20 N 87 Duplication d entrée: dup Descripteur fichier à dupliquer Démarche. Sauvegarde de fd2 (dup) 2. Recopie de fd dans fd2 3. Restauration (dup2 + close) Idem à dup2 La copie se fait dans la ère entrée libre fl le contenu de fd est recopié dans fl + MAJ de compteurs de références Il est nécessaire de connaître l état de la TDF 35

Version Septembre 20 N 88 dup: mécanismes de base () P Processus 0 2 3 4 5 Position : État : Nombre : Position : État : Nombre : O_RDONLY O_RDWR 2 /etc/bashrc N inode : Nb. copies : Inode Infos 2 Espace utilisateur Table fichiers Table inodes Version Septembre 20 N 89 dup: mécanismes de base (2) Fonctionnement général Duplication i du descripteur de fichier Table des fichiers (ouverture): incrémentation des références Table des fichiers (fermeture): décrémentation des références Table des inodes: pas de modification Deux accès au même buffer Utilisation dup et dup2 (routine) Implémentation du shell: redirections E/S Liens avec les structures internes: voir open 36

Version Septembre 20 N 90 dup: exemple simple #include <sys/types.h> #include <unistd.h> #include <fcntl.h> int main () { int fd, nfd; char tab[52], tab2[52]; fd = open ("/etc/bashrc", O_RDONLY); /* ex: fd = 3 */... nfd = dup (fd); /* ex: nfd = 6 */ read (fd, tab, 52); read (nfd, tab2, 52); close (fd); read (nfd, tab2, 52);... } Version Septembre 20 N 9 dup2: exemple simple #include <sys/types.h> #include <unistd.h> #include <fcntl.h> int main () { int fd, nfd; char tab[52], tab2[52]; fd = open ("/etc/bashrc", O_RDONLY); /* ex: fd = 3 */ nfd = dup2 (fd, 4); /* nfd = 4 */ /* si non libre: "4" est fermé avant */ read (fd, tab, 52); read (nfd, tab2, 52); close (fd); read (nfd, tab2, 52);... } 37

Version Septembre 20 N 92 dup: exemple de la redirection en shell #include <sys/types.h> #include <unistd.h> #include <fcntl.h> int main () { int pid, fd, nfd;... if ( (pid = fork ()) < 0) erreur; if (pid == 0) { /* Traitement fils */ if (/* redirection */) { fd = open (fichier,...); /* création... */ close (stdout); nfd = dup (fd); /* nfd = stdout */ close (fd); exec de la commande}... }... } Version Septembre 20 N 93 A propos de fcntl Descripteur fichier Commande sur fd Arguments de la commande Commande : fcntl (fd, F_DUPFD, 0) dup (fd) si 0 est libre F_GETFL : attributs positionnés lors de open F_SETFL : nouveaux attributs - dans arg. Seuls O_APPEND, O_NONBLOCK et O_ASYNC Gestion de verrous, Signaux (interruptions IO), PID processus concerné... relatifs au fichier 38

Version Septembre 20 N 94 A propos de ioctl Descripteur fichier Commande sur fd Arguments de la commande Commande : Opérations sur un périphérique Pas une commande POSIX Grand nombre de commande qui dépendent du matériel Version Septembre 20 N 95 Opérations atomiques ou pas? Attention : Programmation mono ou multi processus On peut être interrompu entre deux instructions 39