cours-système-2011-2012 [mode de...

1

3ème année Licence d’Informatique

Programmation système

Philippe Lahire & G. MenezUniversité de Nice Sophia-Antipolis

Septembre 2011

Ce cours fait de nombreux emprunts à celui de R. Rousseau

Version Septembre 2011 N°2

Organisation du cours

1ère partie : outils de développementG. Menez : 3 premiers cours

2ème partie : prog systèmePlanning :

Cours: 9 séances (1h30)TP: 8 ou 9 séances (3h)

Contrôle continu :TP d à i TP éTP: deux à trois TP notésdeux partiels

Note complémentaire :Le travail : Motivation, Compréhension, Progression,…La tenue : Assiduité, Respect,…

Matériel : PC 3ème étage

2


Acquisition (cours Système de L2)

Notion de processus + API (fork, exec)Système de FichiersSystème de FichiersEntrée-sortie + API (read, write…)Tubes + API (pipe)Signaux + APISockets + API

Langage : • principalement python• complété par du C


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

3


Organisation des enseignements

cours TP

1 Introduction + Entrées-Sorties E/S1 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 IPCy

9

Selon avancement :• Ajout Thread posix + Gestion mémoire virtuelle• Programmation « réseau »


Tentative de bibliographie

1. S. Harbison & G. Steele Jr. C, a reference manual (1st ed. 1984) Prentice Hall, 2nd edition, 1987, 404 p.

2. B. Kernighan & D. Ritchie “The C Programming Language (1st ed. 1978)”,C g g g g g ( ) ,

Prentice Hall, 2nd ed., 1988. Traduction française Masson, 1990.3. A. Tannenbaum “ Systèmes d’exploitation : systèmes centralisés,

systèmes distribués” MacGraw Hill, 1990. Traduction française (2e ed) Dunod, 1999

4. A. Siberschatz & P. Galvin “ Operating Systems Concepts ”, 5e ed, Addison-Wesley, 1998.

5. J. Beauquier & B. Berard “Systèmes d’exploitation : concepts et algorithmes ” MacGraw Hill, 1990.

6. W. Stevens “Advanced Programming in the Unix environment” Addison Wesley 1992 744 p

Conc

epts

ix Wesley, 1992, 744 p.7. M.J. Bach “Conception du système Unix”, Prentice Hall, 1986. Traduction

française Masson, 1991.8. J.M. Rifflet “La programmation sous Unix”, Ediscience intern., 3ème éd.,

1993, 630 p.9. U. Vahalia “Unix Internals : the new Frontiers” Prentice Hall, 199610. A.D. Solomon “Le guide officiel sur l’architecture et le noyau Windows

NT” 2nd ed., Microsoft Press, 1998.11. Site microsoft

Uni

Win

dow

s

4


Documentation en ligne

Sur le langage CEn L2MI (Gilles Menez) : ( )

www-mips.unice.fr/˜menez/L2/L2cours.htmlCours 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/coursCours programmation réseau avec sockets, de Brian "Beej" Hall :

hi d ˜b j id h lwww.ecst.csuchico.edu/˜beej/guide/net/html/.

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 1: Présentation générale

5


Chapitre 1: Présentation générale

Historique des systèmes UNIXVers une normalisation: POSIX

√Vers une normalisation: POSIXUnix propriétaires ou LinuxSurvol de l'architectureNoyau du systèmePrincipales caractéristiquesRappels des notions de base: le ShellRappels des notions de base: le ShellPrincipales commandesInterprétation de commandeNotion de base: La session, le manuel,…Parallèle avec Windows


Vers une normalisation: POSIX

Portable Open System Interface eXchange

Norme IEEE & Description:1003.0: Guide et présentation 1003.1: Bibliothèque de fonctions1003.2: Shell et utilitaires1003.3: Méthode de tests et conformité1003.4: Extension temps réel1003.5: Form. appels systèmes en ADA1003 6: Séc rité1003.6: Sécurité1003.7: Administration système1003.8: Accès commun aux fichiers1003.9: Interface sous Fortran 771003.10: Interface supercalculateurs

Normes: ISO 9945-1 ( P1003.1)

6


Unix propriétaires ou Linux…

Linus Torvald (FIN-91 sur i386)Philosophiep

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ésUn “excellent produit”: stable et code original “libre de droits”

Porté un grand nombre d'architectures : SPARC, INTEL, ALPHA, MAC, …

Quelques projets: ApacheGnomeGNU


De nombreuses distributions Linux

Les différencesNom: 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 versionsqCertifications, …

Mais encore:Debian: de 4500 à 9000 Logiciels,Orienté informaticien,Une dérive vers l'automatisation, …

7


Survol de l'architecture (1)

UTILISATEURInterface Utilisateur

SYSTEME D’EXPLOITATION UNIX

BIBLIOTHEQUE STANDARDfopen, fclose, fread, fwrite,…

PROGRAMMES UTILITAIRES STANDARDShell, éditeur, compilateur, …

Interface Bibliothèques

Interface Appels Systèmes

Interface Utilisateur

MATERIEL: UC, mémoire, disques, terminaux, etc…

SYSTEME D’EXPLOITATION UNIXGestion des processus, de la mémoire, des E/S,…

Autre système en couche : logiciels réseaux suivant norme - OSI


Noyau du système

BibliothèquesProgramme Utilisateur

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

PARTIE MATERIELLE

Cache Buffer

BlocCaractèreContrôleurs de périphériques

Contrôle de la partie matérielle

8


Principales caractéristiques

Langage de haut niveauLe noyau : plus d'1 million de lignes de Cy p g

Expressivité et simplicité de l'interfaceConstruction de programmes: des primitives élémentairesUn système de fichiers « hiérarchique »Un format cohérent de fichier (octet)Accès aux périphériquesccès au pé p é quesMulti-utilisateurs et multitâches …Indépendance avec l'architecture matérielle

54 % du codeMémoire virtuelle (versions actuelles)


Notion d’interprète de commandes

Shell : Interface textuelle vers le système

FonctionnalitésFonctionnalités

Message d'invitation (prompt)

Attend la saisie d'une commande

Commandes internes

Commandes externes (charg. + exec. programmes)

Historique des commandes précédentesHistorique 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

9


Différents shells unix possibles

Bourne shell (historiquement, le 1er)

Toujours utilisé par les scripts internes du systèmeToujours utilisé par les scripts internes du système

C-shell (csh, tcsh)

syntaxe différente

Évolutions du Bourne shell

ksh (Korn shell)

bash (Bourne Again shell): le shell du projet GNU

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


Quelques éléments d’administration

/etc/passwdnom_du_compte : mot_de_passe : numero_utilisateur : numero_de_groupe :

commentaire : répertoire : programme de demarrage

root:x:0:0:root:/root:/bin/bash

bin:x:1:1:bin:/bin:/bin/bash

daemon:x:2:2:daemon:/sbin:/bin/bash

news:x:9:13:News system:/etc/news:/bin/bash

user1:x:500:100:Mr User 1......:/home/user1:/bin/bash

commentaire : répertoire : programme_de_demarrage

/etc/groupnom_de_groupe : champ_special : numero_de_groupe : membre1, membre2

root:x:0:rootbin:x:1:root,bin,daemondaemon:x:2:users:x:100:

10


Caractéres spéciaux du shell

Certains caractères ont une signification spéciale pour le shell

* : 0 ou plusieurs caractères quelconques

Pas en C

p q q

t*o : nom de fichier qui débute par t et finit par o

? : 1 (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, ...

{mot1,mot2} : soit mot1, soit mot2


Notions de base: Le manuel

Principales sections (environ 20 Mo)taille dépendante des paquetages - nyx : (≈20 Mo de “.gz”)man1: Commandes utilisateurs à partir shell (≈1800)man2: Primitives du noyau (≈250)man3: Routines C (≈1400)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 commandesapropos: recherche de mots clés

11


Anatomie d’une page de manuel (1)

Section

Brè ve de scr ip t ion

Syn taxes possibles

Descr ipt ion détaillée de la comman de

Pr om p t d u « PAGE R »

De scr ip t ion d é t a illé e d e sop t ion s (or d r e a lp h a b .)

'q ' : q u it' b ' : r e tou r 1 p .< s p c > : d é fil 1 p .< e n t e r > : d é fil 1 l./xy : r e c h e r c h e r « xy »


Anatomie d’une page de manuel (2)

A i éAutr es pages in téressan tessu r un su jet voisin

N u l n ' e s t p a r fa it . . .

Par fois am bigu ës ou con fu sesVer sion angla ise (défau t ) :unset LANG LC_ALLpu is m an à n ouveau...

12


Principe général d'utilisation/* Fichier Z2.h */

Z1.oR1 (int i)Zlib.a

main (){

}........R1 (23)

/* Fichier Y.c */

#include "Z2.h"

Z2.o

Z3.o

........R1 (int i) {......}.......

PREPROCESSEUR

/* MAN !!!!! */

man r1

}

a.out

Y.o

EDITION DE LIEN

COMPILATION


Exception vs compte-renduPresque toutes fonctions/appels systèmes

Traitement standard des erreurs (1)

entierpointeur…Presque toutes fonctions/appels systèmes

Utilisation de errno :Syntaxe : extern int errno ;n◦ dernière erreur détectée par un appel système

• normale : positive ou nulle, non void ,• anormale : négative ou void

n dernière erreur détectée par un appel systèmepas remise à zéro à chaque appel. intro(2) : liste des différents codes

Méthodologie : test compte-rendu + errno

13


Fonctions associées#include <string.h>


#include string.hchar* strerror (int errnum)retourne message « en clair » associé à errnum

#include <stdio.h>void perror (const char* message)affiche message message associé à errno (stderr)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 »)


Exemple#include <string.h>


g#include <stdio.h>int main (int argc, char* argv[]) {FILE* fichier;if (argc != xxx) {

fprintf(stderr, « nombre paramètres incorrect »);exit(1)

ici > 1

exit(1)}

if ( (fichier = fopen(argv[1], « rw »)) == NULL) {fprintf(stderr,«Erreur %i:%s \n », errno, strerror(errno));exit(2); }

}

14


Traitement des erreurs de W. Stevens (1)

+ return

format message d’erreur avec nb % + nb arguments

+ exit(1)

+ abort

Affiche aussi le message associé à errno

Macros : en majuscule et sans paramètrePas de message passé en paramètre mais :Affichage: Nom du fichier + numéro de ligne


Exemple#include <stevens.h> Pas par défaut dans linux

Traitement des erreurs de W. Stevens (2)

#include <stevens.h>#include <stdio.h>int traiter_fichier (char* f) {FILE* fichier; char tab[30];if ( (fichier = fopen(f, « rw »)) == NULL)

ERR_EXIT;

Pas par défaut dans linux

;…if (fclose(fichier)) != 0)

ERR_RETURN;}

15

Chapitre 2: Entrées - Sorties


Plan de travail

Principes généraux…

Structures internesHiérarchie de descripteursTables pour la gestion des entrées-sorties

Principaux appels systèmesOuverture / fermeture de fichiers: open closeOuverture / fermeture de fichiers: open, closeEntrées-sorties: read, writePositionnement : lseek, fseekDuplication en vue de redirection : dup, dup2

16


Mise au point / Survol

bash gcc emacs

int open (….) { } int read (….) { }

Tables :

FILE* fopen (….) { } Bien sur on se sert aussi du « shell »pour lancer un

programme

…

Système exploitation

Tables :•Fich. Ouvert•Volumes•Blocs•….

Consulte / met à jour« appelle » / exécute

processus


Principes généraux (1)

Sous UNIX: tout est fichierPériphérique réseau mémoire

Exemples : • « hardware » (/dev) • Accès au réseau (sockets)

T b i t t (FIFO)Périphérique, réseau, mémoire...Fichier = une suite d’octetsOrganisation : Hiérarchie de

Système de fichiers (partitions…)répertoiresFichiers « normaux » (en anglais Regular)

• Tubes persistants (FIFO) • Tables du noyau (TDF)

Montage : • local • distant

( g g )Liens entre fichiers (symboliques et physiques)Fichiers virtuels (/proc)Fichiers spéciaux (périphériques,FIFO,…)

17



Méthodes d’accèsSéquentiel (read)q ( )Direct - unité: l’octet – (lseek)

Protectionpropriétaire, groupe d’utilisateurs, les autresPas de journal (log) mais possibilité de verrous

Généralité + simplicitéImplantation de SGBD : bonne aptitudeImplantation de SGBD : bonne aptitudefichiers à trou, accès direct, octets…mécanismes additionnels non intégrés: évolution (gestion des versions), typage des

données, système transactionnel (SGBD),



Deux points de vuesUtilisateur (commandes, applications,…)( , pp , )Programmeur (C et appels systèmes)

Utilisateuréchanges entre un processus et des entités :

disque, machine distante, autre processus, terminal...

Programmeur Fichier au sens large

Echanges avec n’importe quelle entité par des flots d’octets consécutifsAccès direct possible sur des disques locaux ou distants (curseur lecture/écriture)

18



Une suite d’octetsDisque

Curseur

TamponDescripteur de fichier :

Prédéfini (fich Stand )

Mémoire Programme

F.D.

• Prédéfini (fich. Stand.)• A associer (open)

Simple numéro



Association (open…)Dans le programme Appel du programme

( p )nom externe / Desc. Fichier

chemin relatifchemin absolu

Pas de caractère générique

Utilisation (read, write…)chemin relatifchemin absolu

Desc. Fichier: numéro de voieobtenu par associationprédéfini :

0 : voie standard d’entrée1 : voie standard de sortie2 : voie standard d’erreur

On n’utilise jamais directement

Le clavier ou l’écran

19


Un modèle d’E/S adaptable aux langages

Impact:• Performance

Un modèle d’entrée sortie de bas niveauxLangage CJava…

• Utilisation…


Modèle langage C vs Modèle UNIX

Appels systèmes (1)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 ConclusionMode noyau et Préemptiony p

struct FILE vs numéro d'entrée dans la TDFlect./écr. d'enregistrement vs d'octet(2) utilise (1)signatures de (2) indépendantes du système, mais l'implémentation dépend elle, du système ...

qu'en concluez vous ?

20


Qu'est-ce qu'un processus

DéfinitionsInstruction = indécomposable et indivisibleInstruction indécomposable et indivisibleProcesseur = ...Processus = exécution d'un programme

(instructions + données)Approche intuitive

UNIX = système "temps partagé“Plusieurs processus en même tempsUn seul processus actifAttente des autres (dans/hors mémoire)


Tables pour gérer les fichiers

P1 01

Position :État : N° inode :

Tables partagéesPrivé

P2 0

Proc

essu

s 12345

…

Nombre :…

Position :État :Nombre :

Nb. copies :Inode Infos ……

N° inode :Nb. copies :Inode Infos …

…

Tables Descripteurs Fichiers

…

Position :Ét t

Table fichiersEspace utilisateur Table inodes

Proc

essu

s P 0

12345

…

…


État :Nombre :…


21


Modèle UNIX - Synthèse

Trois points de vues Le processus

Rôles :Gestion des voies d’échangep

L’usageLe « fichier »

Deux abstractions (par point de vue)Processus : Usage et nature du fichierUsage : raison de l’utilisation par le processus

et la nature du fichier

gGestion du curseur…Gestion des protections…

« Fichier »: raison de l’utilisation et usage du fichier

Permettre le partageD’un même usage par un/plusieurs processusD’un même fichier par un/plusieurs processusD’une même fichier par un/plusieurs usages


Ouverture/Création d’un fichier: open

Descripteur de fichier

Lors de la création: f(perm,umask)

Mode d’ouverture

Nom fichier

fichier

Mise à jour des tables internes (processus + noyau)Oflags/perm : 9/15 macros dans les fichiers .h

Un petit ensemble de combinaisons validesLes incohérences ne sont pas détectés

22


Ouverture/Création: open (oflags)

O_CREAT: création, si le fichier n’existe pasO EXCL: combiné avec O CREAT, création si le fichier n’existe

Valeurs possibles

_ _ ,pas, erreur sinonO_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 fichierO_APPEND: contenu du fichier non touché + curseur placé en EOFO_SYNC: attend la fin d’écriture sur le média après chaque write (pas de cache)O_NONBLOCK: E/S non bloquantes.



Règles et choix incohérents

O_CREAT si la création est permise ⇒ ¬ O_RDONLY

O_EXCL si le fichier ne doit pas déjà exister ⇒ O_WRONLY +

Choisir l’un des 3 types exclusifs d’action : O_RDONLY, O_WRONLY, O_RDWR

+

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.

23



open (nomFichier, O_RDONLY)

Curseur au début du pour lire

Exemples

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ù


Ouverture/Création: open (perm)Règle

Les permissions associées à un fichier lors de sa créationsont fixées par la conjonction de deux points de vue :

Point de vue :du programmeur, qui propose des permissions logiques

de l’utilisateur, propriétaire des fichiers créés, qui

sont fixées par la conjonction de deux points de vue :

Ex: Compilateur: exécution / Editeur: lecture et écriture…

peut interdire certaines permissions

umask : pas de lecture/écriture pour les autres

Permission appliquée = perm & ~umask

Masque interdictions

24


Ouverture/Création: open (perm)Valeurs possibles

Pour donner des droits

Le propriétaire

Le Groupe propriétairee G oupe p op éta e

Les autres


open (« f », O_WRONLY | O_CREAT, )

Ouverture/Création: open (perm)Exemple

1 1 01 0 0 0 0 0)

0 0 00 1 0 0 1 0022Group = ¬write

umask

1 1 01 0 0 0 0 00 0 10 1 1 0 0 0

|

0 0 00 0 0 1 1 1 |

1 1 11 1 1 1 1 1

1 1 11 0 1 1 0 1&

~

1 1 11 0 1 1 0 1755

pOther = ¬write =

25


Création d'un fichier

Equivalencesopen (path, O WRONLY | O CREAT)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 = 010000 | 001000 (O_RDONLY,...)

Commande(s) associée(s): emacs, gcc, cp, ...Structure(s) interne(s): tables, super-bloc


Création d'un fichier: mécanisme interneEtapes

Localisation inode parent (I.P),Localisation inode parent (I.P),Recherche nom fichier...

Si le nom n’existe pas alors:Verrouillage I.P., liste des inodes libresAllocation inode: inode-mémoire = get (inode-disque) Modification I.P.: Informations fichier

Sinon (le nom existe) :Désallocation blocs: contenu fichierNon-Modification I.P.

Importance des verrous et du mode noyau

26


Processus 1#include <sys/types.h>

Ouverture/Création d'un fichier (1)

y yp#include <sys/stat.h>#include <fcntl.h>int main () { int rfd, wfd, rwfd;

if ((rfd = open("/etc/bashrc",O_RDONLY)) < 0)erreur;

Attention !

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


Ouverture/Création d'un fichier (2)

Processus 2#include <sys/fcntl.h>#include <sys/stat 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épendantsDes tables partagées et privées

Action: ouverture: rfd - ouverture: wfd

27


Ouverture d'un fichier: Vision interne

P1 01


O_RDONLY

1/etc/bashrc

N° inode :Nb. copies :I d I f

123

Attention : partage possible dup/forkP2 0

Proc

essu

s 12345

…

…


O_RDWR

1…


O_WRONLY

1

Inode Infos …


1/.bashrc

…


Proc

essu

s P2 0

12345

…

1

Position :État :Nombre : 1

O_RDONLY


O_WRONLY

1


/.bash_profile

1

…


Fermeture d’un fichier: close

Descripteur de fichier

Mise à jour des tables internes (processus + noyau)

fichier

fd est une entrée dans la TDF :open, fork, voie standard…

Fermeture par le noyau des fichiers à la terminaison d’un processus (exit(?))

28


Fermeture d'un fichier

Processus 2#include <unistd.h> int main ()int main () {

int rfd, wfd;/* Ouverture et utilisation */ ... close (rfd); /* exit: fermeture implicite */ close (wfd); /* exit: fermeture implicite */ }

T bl fi hi /i dTables fichiers/inodesDécrémentations compteursDésallocations élémentsLibération complète si le compteur atteint 0

Commande(s) associée(s): exit, éditeur…Structure(s) interne(s): tables, buffers


Fermeture d'un fichier: Vision interne

P1 01


O_RDONLY

1/etc/bashrc


123

P2 0

Proc

essu

s 12345

…

…


O_RDWR

1…


O_WRONLY

1

Inode Infos …


1/.bashrc

…


Proc

essu

s P2 0

12345

…

1

Position :État :Nombre : 1

O_RDONLYN° inode :Nb. copies :Inode Infos …

/.bash_profile

1

…Position :État :Nombre :

O_WRONLY

1nullnull

29


Lecture d’un fichier: read

Descripteur fichier

Nombre octets lus

Mise à jour des tables internes (noyau)fd é d l TDF l

Lieu de stockage données lues

Nombre octets à lire

fd est une entrée dans la TDF ouverte en lecture :open, fork, voie standard…

Allocation de buffer impérativeNb octets lus ≤ Nb octets à lire (EOF, périphérique,…)Début = position du curseur Après = position + nb oct.lus


Lecture d'un fichier

Processus 1#include <sys/types.h> #include <unistd h>#include <unistd.h> int main () {

int rfd, nb; char tabp[30]; char tabg[1024];/* Ouverture rfd */ ... nb = read (rfd, tabp, 30); nb = read (rfd, tabg, 1024);nb = read (rfd tabp 20);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

30


Lecture d'un fichier: Commentaires

Verrouillage/partageDurée d'un readDurée d un readVerrouillage explicite possible

Schéma lecteur/écrivain possiblePlusieurs descripteurs possibles

Lecture réelleAttention: Lecture bloc par blocBloc dans le "buffer cache" ou sur le disque?Lecture anticipée


Lecture d'un fichier

Processus 1#include <sys/types.h> #include <unistd h> #include <unistd.h> int main () {

int rfd1, rfd2, nb;char tab1[30], tab2[30];/* Ouverture rfd1, rfd2 */ ... nb = read (rfd1, tab1, 30); nb read (rfd2 tab2 30);nb = read (rfd2, tab2, 30);

}Lecture à travers plusieurs entrées – attention

Ici: 2 descripteurs indépendancefork: "2" descripteurs dépendance

31


Lecture d’un fichier (2)


Ecriture dans un fichier: write

Descripteur fichier

Nombre octets écrits

Mise à jour des tables internes (noyau)fd est une entrée dans la TDF ouverte en écriture :

Données à écrire

Nombre octets à écrire

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

32


Ecriture dans un fichier

Processus 1#include <sys/types.h> #include <unistd h> #include <unistd.h> int main () {

int wfd, nb;char tab[30];/* Ouverture wfd */ /* Remplissage de tab */ ... nb = write (wfd tab 30); 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


Ecriture dans un fichier (2)

33


Ecriture d'un fichier: commentaires

Verrouillage/partageDurée d'un writeDurée d un writeVerrouillage explicite possible

Schéma lecteur/écrivain possiblePlusieurs descripteurs possibles

Ecriture réelleAllocation de blocs par nécessité (indirect, données)Ecriture partielle Lecture du blocEcriture différée des blocs: "buffer cache"


Positionnement dans un fichier: lseek

Descripteur fichier

position

Mise à jour des tables internes (noyau)fd est une entrée dans la TDF ouverte en écriture :

Référentiel

déplacementEntier 64 bits

fd est une entrée dans la TDF ouverte en écriture :open, fork, voie standard…

Retour = position par rapport au début du fichierRéférentiel = SEEK_SET, SEEK_CUR, SEEK_END déplacement positif/négatif avant (resp. après) le début (resp. fin)

34


Positionnement : commentaires

Référentiel :SEEK SET : par rapport au débutSEEK_SET : par rapport au débutSEEK_CUR: par rapport au curseurSEEK_END :par rapport à la fin

Comment connaitre la position courante?

O i i è l fiOn peut se positionner après la finToute écriture crée des trousLa lecture de trous rend des octets nuls

Une position négative est souvent une erreur


Positionnement dans un fichier

#include <sys/types.h>#include <unistd.h>int main () { int main () {

int fd, pos;char tab[30];/* Ouverture fd */ ... pos = lseek (fd, 1000, SEEK_CUR); // voir aussi SEEK_SETpos = lseek (fd, -50, SEEK_END);

}read/write ⇒ accès séquentiellseek ⇒ accès directPas d'accès disque

Commande(s) associée(s): éditeur…Structure(s) interne(s): tables des fichiers

35


Duplication d’entrée: dup2

Descripteur fichier à dupliquer

Mise à jour des tables internes (processus et noyau)fd1 é d l TDF

à dupliquer

Descripteur fichier où copier

fd1 est une entrée dans la TDFfd2 est une entrée libre (ou qui sera fermée)le contenu de fd1 est recopié dans fd2 + MAJ de compteurs de référencesdup réalise la copie dans la première entrée libre


Duplication d’entrée: dup

Descripteur fichier à dupliquerà dupliquer

Démarche1. Sauvegarde de fd2 (dup)2. Recopie de fd1 dans fd23. Restauration (dup2 + close)

Idem à dup2La copie se fait dans la 1ère entrée libre flle contenu de fd1 est recopié dans fl + MAJ de compteurs de référencesIl est nécessaire de connaître l’état de la TDF

( p )

36


dup: mécanismes de base (1)P1 0

1


O_RDONLY

1/etc/bashrc


2Pr

oces

sus 1

2345

…

…


O_RDWR

1

Inode Infos …

2



dup: mécanismes de base (2)

Fonctionnement généralD li i d d i d fi hiDuplication du descripteur de fichierTable des fichiers (ouverture): incrémentation des référencesTable des fichiers (fermeture): décrémentation des référencesTable des inodes: pas de modificationD è ê b ffDeux accès au même buffer

Utilisationdup et dup2 (routine)Implémentation du shell: redirections E/S

Liens avec les structures internes: voir open

37


dup: exemple simple

#include <sys/types.h>#include <unistd.h>#i l d f tl h#include <fcntl.h>int main () {

int fd, nfd;char tab1[512], tab2[512];fd = open ("/etc/bashrc", O_RDONLY); /* ex: fd = 3 */ ... fd d (fd) /* fd 6 */nfd = dup (fd); /* ex: nfd = 6 */

read (fd, tab1, 512);read (nfd, tab2, 512);close (fd);read (nfd, tab2, 512);...

}


dup2: exemple simple

#include <sys/types.h>#include <unistd.h>#include <fcntl h>#include <fcntl.h>int main () {

int fd, nfd;char tab1[512], tab2[512];fd = open ("/etc/bashrc", O_RDONLY);/* ex: fd = 3 */

nfd = dup2 (fd, 4); /* nfd = 4 *//* si non libre: "4" est fermé avant *//* si non libre: 4 est fermé avant */

read (fd, tab1, 512);read (nfd, tab2, 512);close (fd);read (nfd, tab2, 512);...

}

38


dup: exemple de la redirection en shell

#include <sys/types.h>#include <unistd.h>#i l d f tl 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 */fd = open (fichier, ...); /* création ... */close (stdout); nfd = dup (fd); /* nfd = stdout */close (fd); exec de la commande}

... } ... }


A propos de fcntl

Descripteur fichier

C d fd

Commande :f l (fd1 F DUPFD 0) d (fd1) i 0 lib

Commande sur fd

Arguments de la commande

fcntl (fd1, F_DUPFD, 0) ⇔ dup (fd1) si 0 est libreF_GETFL : attributs positionnés lors de openF_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

39


A propos de ioctl

Descripteur fichier

C d fd

Commande :

Commande sur fd

Arguments de la commande

Commande :Opérations sur un périphériquePas une commande POSIXGrand nombre de commande qui dépendent du matériel…


Opérations atomiques ou pas ?

Attention :Programmation mono ou multi processusOn peut être interrompu entre deux instructions

cours-système-2011-2012 [mode de...

Documents