Diapos Cours SE 1

Systèmes d’Exploitation 1
Ali Larab
CUFR d’Albi
2008-2009
Présentation du module « S.E-
S.E-1 »
Objectif:
– Comprendre les fonctionnalités d'un système d'exploitation et les utiliser au moyen
d’un langage de commande.
Volume horaire: 30h (12h cours + 8h TD + 10h TP).
Contenu:
– Introduction aux systèmes d’exploitation
– Gestion des supports de stockage
– Langage de commande.
Thèmes de TP :
– Commandes principales de Linux et primitives de gestion de fichiers (+ script).
Evaluation:
– Contrôle de connaissances sur table + Evaluation TP.
Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 2

Bibliographie
• Andrew Tanenbaum, Systèmes d'exploitation, Pearson Education

(2ème édition), France, ISBN: 2-7440-7002-5.
• J. Archer Harris, Systèmes d'exploitation, Edisciences, 2002,

ISBN:2100065130.
• Valérie Martinez, Windows 2000 Professionnel – Notions de base,

Edition Dunod, 2001, ISBN:2100046284.
• Jerry Peek, Grace Todino, John Strang, Introduction à Unix, Edition

O'Reilly, 2002, ISBN: 978-2841772094.
• ...

Contenu SE-
SE-1
• Introduction aux systèmes d’exploitation
– Définition, - Fonctions,
– Historique (Evolution), - Exemples,
– Classification
• Gestion des supports de stockage (disques magnétiques

(disques durs), disque optiques (CD-ROM)…)
• Langage de commande. (application sous les SE Windows et

les SE basés sur le noyau Linux) : principales commandes
et primitives de gestion de fichiers.
• PS: Une partie de ce cours est extraite de celui de Bourdonn.

Cours 1 : Introduction aux S.E.
PLAN
I. Introduction aux systèmes d'exploitation (SE)

I.1 Pourquoi ?
I.2 Définition d'un système d'exploitation
I.3 Fonctions d'un SE
I.4 Exemples de SE
I.5 Classification des SE
II Historique des SE
II.2 Générations d'ordinateur

Introduction aux SE
I.1 Pourquoi un SE ?
• Un système informatique est constitué :
– d'un ou plusieurs processeurs,
– d'une mémoire principale et mémoires secondaires (disques durs, clé USB,
mémoire flash...),
– d'un clavier, d'un écran, d'une interface réseau,
– d’une imprimante, d’une carte TV...
Ce système est donc très complexe: Écrire un programme qui prend en
compte et utilise tous ces composants est une tâche très difficile.
Astuce: trouver un moyen qui va gérer tout ce matériel et offrir une
interface simplifiée à ce programme pour qu'il manipule ce matériel
facilement et d'une manière optimale.
« logiciels systèmes ». Le plus important de ces logiciels est le
« système d'exploitation ».

Définition d'un SE
Un « système d'exploitation » (SE ou OS pour Operating System) est le

programme fondamental des programmes systèmes.
Son rôle est de gérer tous les périphériques et de fournir aux

programmes utilisateur une interface simplifiée avec le
matériel.
Il contrôle donc toutes les ressources de l'ordinateur et fournit

la base sur laquelle seront construits les programmes
d'application.

Positionnement du SE

Périphériques physiques : fait
partie de la couche « matériel ».
Elle intéresse plus les ingénieurs
électroniciens, car elle est
composée des périphériques,
circuits intégrés, câbles,
alimentations, tubes cathodiques...

Micro--architecture : Correspond
Micro
aux programmes de contrôle de
périphériques (interprète).
Les périphériques sont regroupés
en unités fonctionnelles.
Extraire des registres, à chaque
cycle d'horloge, un ou deux
opérandes et on fait une opération
(adition, ET logique...) sur eux, puis
on stocke le résultat dans un (ou
plusieurs) registre.

Langage machine : Correspond
au programme (en assembleur) Positionnement du SE
qui permet d'effectuer des
instructions élémentaires (ADD,
MOVE, JUMP...) pour déplacer
des données dans la mémoire,
faire des calculs (opérations
arithmétiques) ou des
comparaisons entre les valeurs
des registres.

Système d'exploitation : C'est

une couche logicielle (un
ensemble de programmes ou de
commandes) qui cache
partiellement le matériel et fournit
au développeur un jeu
d'instructions plus pratique, qui
englobe souvent plusieurs
instructions du langage machine.
Reste des logiciels systèmes :

La différence entre ces logiciels et
le système d'exploitation est que
le système d'exploitation
fonctionne en mode noyau
(mode superutilisateur) alors
que les autres fonctionnent en
mode utilisateur. On peut par
exemple changer de compilateur,
mais pas de gestionnaire
Ali Larab, Univ-JFC, d'interruptions
08-09 d'horloge (fait d'Exploitation,
Systèmes partie du partie 1 13
SE).
Applications : On y trouve tous les

programmes (achetés ou conçus) qui
répondent aux besoins particuliers des
utilisateurs,
tels que le traitement de texte, les tableurs,
la gestion des bases de donnée ou les
navigateurs Web.

Fonctions d'un SE (1/5)
Fonctions d’un SE :
1. Extension de la machine,
Machine virtuelle ou machine étendue,
2. Gestion des ressources.

1. Extension de la machine (Machine virtuelle)
Fournir à l'utilisateur l'équivalent d'une machine virtuelle plus simple à
programmer que la machine réelle.
Masquer les éléments fastidieux liés au matériel (gestion des interruptions,
des horloges, de la mémoire, des périphériques (déplacement du bras de lecture d'un
disque dur)).
– Ex. Ecrire sur le disque dur: il faut manipuler environ 20 commandes (lecture/écriture de données,
adresse du bloc à lire, nombre de secteurs par piste, déplacement du bras, formatage des pistes,
remise à zéro et recalibrage du périphérique).
• La commande READ nécessite ≅ 13 paramètres compactés dans 9 octets, et
retourne 23 champs de statuts et d'erreurs, compactés dans 7 octets,
Le SE: Créer une interface de programmation plus abstraite qui lui permet de
manipuler les périphériques d'une manière plus simple.
– Ex. Présenter le disque dur comme un fichier qu'il faut ouvrir, manipuler
(lecture/écriture), puis fermer.
• L'interface de programmation offerte par le SE = ensemble de services
que les programmeurs peuvent solliciter par le billet d'instructions
spéciales appelées « appels systèmes ».
2. Gestion des ressources (1/3)
– Un ordinateur est composé d'un ensemble de ressources.
– Plusieurs programmes peuvent s'exécuter sur cet ordinateur. Ces
programmes nécessitent de la mémoire, des accès disque et des accès
ou utilisation des ressources.
• Le rôle du SE dans ce cas est de gérer de manière équitable,

optimale et sans conflit l'allocation des processeurs, de la mémoire et
des périphériques d'E/S aux différents programmes concurrents qui
les sollicitent.
Ex.
- Impression simultanée,
- Accès aux fichiers,
- Autorisation/interdiction d’accès à certaines ressources.
Partage de ressources

--
-->> partage de ressources
ressources::
– Dans le temps : Gérer l'accès dans le temps à l'imprimante, à un fichier ou
à la CPU.
Le choix du programme qui va bénéficier de la ressource est la tâche du SE.
– Dans l'espace : Au lieu d'attendre son tour, certaines ressources
permettent d'être partagées.
• On peut par exemple partager la mémoire principale entre les processus ou
programmes actifs qui s'exécutent à un instant t.
Remarque:
Le rôle du SE est de trouver le juste milieu entre le partage de la ressource dans le
temps et dans l'espace.
Ex1. Ne pas allouer toute la mémoire à un seule programme qui n'a besoin que de
quelques kilo octets et de laisser les autres attendre l'utilisation de la CPU.
Ex2. Ne pas partager la mémoire entre tous les programmes à un instant t (la mémoire
n'est pas suffisante).

Les ressources à gérer :

– Les processus,
– Les fichiers,
– Les entrées/sorties,
– La mémoire.
Points à détailler dans le module SE-2.

Exemples de SE (1/4)
Liste non-
non-exhaustive… !
• OS/2 d’IBM ;
• OS/400 présent sur les moyens systèmes IBM (AS/400 - ISéries) ;
• Mac OS : le premier système d’exploitation des ordinateurs Apple Macintosh, qui a succédé
aux systèmes Lisa et Apple II, et a été suivi de Mac OS X puis d'iPhone OS ;
• VMS et OpenVMS (Compaq, ex-Digital) ;
• Geekeo : Open source et spécialisé dans la virtualisation ;
• la famille des DOS, dont :
– PC-DOS (version fournie par IBM avec les premiers x86), MS-DOS, DR-DOS, FreeDOS,
PTS-DOS...
• Windows 9x, le système d’exploitation fenêtré de Microsoft basé sur le MSDOS ;
• Windows NT ;
• ReactOS, Un système d'exploitation libre compatible win32.
• BeOS et ses successeurs libres et propriétaires : Haïku.
• AtheOS et son fork Syllable dont l'arborescence du système de fichier est très proche d'UNIX.
Liste non-
non-exhaustive… !
Liste non-exhaustive de systèmes d’exploitation : (2/3)
• Dérivés d’UNIX (sous différentes déclinaisons : BSD, System V, etc.) dont :

– GNU/Linux : un système d’exploitation libre s’appuyant sur le noyau Linux et les outils
GNU.
• Distributions : Debian, Mandriva, Ubuntu, Gentoo, Red Hat, Fedora, SuSE,
Slackware, EduLinux…
– la famille BSD : un effort réussi pour rendre sa liberté au système de Berkeley
comprenant :
• NetBSD, OpenBSD et son dérivé OliveBSD, FreeBSD et ses dérivés, PicoBSD,
DragonFly BSD et PC-BSD; Darwin (sur lequel est construit Mac OS X, semi-
propriétaire), OpenSolaris de Sun.
– les UNIX propriétaires :
• AIX (IBM, SystemV), A/UX (Apple, SystemV), BOS (Bull Operating System), Irix
(Silicon Graphics, SystemV), HP-UX (Hewlett Packard, SystemV), LynxOS
(LynuxWorks), NeXTSTEP (NeXT, BSD), Sinix (Siemens), Solaris(Sun, SystemV),
SunOS (Sun, BSD), Tru64 (Compaq).
Liste non-
non-exhaustive… !
Liste non-exhaustive de systèmes d’exploitation : (3/3)
• Les systèmes d’exploitation grands systèmes (mainframes) :

– Multics (père d’UNIX) et héritier de CTSS
– IBM : MVS, VM, DOS/VSE, TPF
– Bull : GCOS
– Siemens : BS2000
– DEC : TOPS-10, TOPS-20 et ITS
• Symbian OS est un système d’exploitation pour Smartphones
[Source: Wikipedia]
Liste non-
non-exhaustive… !
• Windows (95, 98, 2000, NT, XP...),

• UNIX,
• Famille GNU/Linux: des SE basés sur le noyau Linux et entouré des
bibliothèques et logiciels GNU. On y trouve Redhat (Redhat, Fedora), Debian
(Debian, Ubuntu), gentoo, mandrake, SUSE....
• BSD,
• MacOS,
• MS-DOS...
RedHat Fedora FreeBSD Suse OpenSUSE Knoppix
Kaella Minix NetBSD OpenBSD OpenDarwin Mandriva
Debian Ubuntu Gentoo Slackware Sentinix ReiserFS

Classification des SE
• Critères de classification:
classification
1. Libre et gratuit / Propriétaire et payant
2. Services rendus
3. Architecture de fonctionnement
4. Architecture matérielle supportée
5. Évolution
6. Contraintes de temps réel
7. …

Critères de classification (1/6)
Libre et gratuit / Propriétaire et payant
• Libres et gratuits:
– Libre on peut avoir le code source.
– Gratuit on peut l’avoir gratuitement.
Ex. Les distributions GNU/Linux (Debian - Fedora – Gentoo, Mandrake – Slackware-
SUSE), NetBSD - payants FreeBSD – OpenBSD ...
• Propriétaires et payants :
– Il faut payer pour pouvoir les utiliser. Ces SE sont généralement non libres
(on ne peut pas avoir accès à leur code source).
Ex. MacOS, OS/2, QNX, Solaris, UNIX, Windows (95, 98, NT, 2000, XP), DOS...

Services rendus:
a) Mono-tâche : Le SE ne peut exécuter qu'une seule tâche à la fois.
Exemple : DOS
b) Multi-tâche : Le SE peut exécuter plusieurs tâches ou processus
simultanément. (effectuer, par exemple, une compilation et consulter le fichier
source du programme correspondant).
Ex. UNIX, OS/2 d'IBM, Windows.
-------------
a) Mono-utilisateur : Il ne peut y avoir qu'un seul utilisateur qui utilise le
système à un instant donné.
a) Ex. DOS, Windows.
b) Multi-utilisateurs : Le système peut gérer plusieurs utilisateurs au
même temps. Le SE partage l'accès aux ressources entre ces
utilisateurs.
Ex. UNIX, VMS (vax)...

Architecture de fonctionnement :
• Système centralisé : L'ensemble du système est entièrement présent
sur la machine considérée. Les autres machines reliées à celle-ci sont
vues comme des entités étrangères disposant elles aussi d'un
système centralisé.
Le SE ne gère que les ressources de la machine sur laquelle il est
installé.
Exemple: UNIX, Windows.
• Système réparti (distribué) : Les différentes abstractions du SE sont
réparties sur plusieurs machines, mais apparaît aux utilisateurs
comme une seule machine virtuelle.
L'utilisateur n'a pas à se soucier de la localisation des ressources; Il
n'a pas à connaître le nom de la machine qui exécute le programme
qu'il va lancer.
Les 2 principaux avantages d'un tel système est l'exécution
parallèle de tâche ainsi que la résistance aux pannes.
Architecture matérielle supportée:
• Monoprocesseur : La machine a 1 seul processeur Pseudo-
parallélisme (illusion d'un parallélisme dans l'exécution des tâches (processus),
car il y a une rapide commutation entre les différents processus qui s'exécutent sur
la machine).
• Multiprocesseur : La machine possède plusieurs processeurs. Chacun
s'occupe d'une tâche. Plusieurs architectures sont possibles:
– SIMD (Single Instruction Multiple Data) : Tous les processeurs exécutent les
mêmes instructions, mais sur des données différentes.
– MIMD (Multiple Instructions Multiple Data) : Chaque processeur est complètement
indépendant des autres et exécute des instructions sur des données
différentes.
– Pipeline : Les différentes unités d'exécution sont mises en chaîne et font
chacune partie du traitement à effectuer
– Architectures fortement couplées : architectures à mémoire commune,
– Architectures faiblement couplées : chaque processeur possède sa propre
mémoire locale (ex. réseau de stations).
– Architectures mixtes : différents niveaux de mémoire (commune et privée).
Évolution :
• Système fermé : Le système n'accepte pas des ajouts (ou ayant une
extensibilité réduite).
Pour lui ajouter d'autres fonctionnalités, il faut remettre en cause sa
conception et refaire une archive (système complet).
Exemple : UNIX, Windows, DOS...
• Système ouvert : Le système accepte des ajouts de fonctionnalités et
des abstractions sans avoir à repenser le système ou même sans avoir
à l'arrêter (extensible à chaud).
Pour cela le système doit être basé sur une conception modulaire
(modèle client-serveur).

Contraintes de temps réel :
Certains automatismes (particulièrement industriels) nécessitent des

réponses en temps réel. Toutes les réponses qu'il recevra au delà du
temps requis (quelques millisecondes) ne sont plus valables.
Le SE qui doit gérer cet automatisme doit alors répondre dans les
délais.
On parle dans ce cas d'un système à temps réel.
Les contraintes de temps sont de deux types:

- Contraintes strictes (ou dures)
- Contraintes relatives (ou molles).
Ex. Linux-RT.

Historique des SE (1/6)
II.2 Générations d'ordinateur
• 1ère génération (1945 - 1955) : Les tubes à vide et les cartes enfichables
• 2ème génération (1955 - 1965) : Les transistors et le traitement par lots
• 3ème génération (1965 - 1980) : Les circuits intégrés et la multiprogrammation
• 4ème génération (1980 - 1990) : Les ordinateurs personnels
• 5ème génération (1990 - Aujourd'hui et +) : Les ordinateurs personnels
portables et de poche.

1ère génération (1945 - 1955) : Les tubes à vide et les cartes enfichables
• Il n'existait pas de système

d'exploitation.
• Les utilisateurs travaillaient

chacun leur tour sur
l'ordinateur qui remplissait
une salle entière.
• Ils étaient d'une très grande

lenteur et d'une très grande
fragilité.
• Années 50 apparition des
cartes perforées.

2ème génération (1955 - 1965) : Les transistors et le traitement par lots

• Le passage aux transistors rendait les ordinateurs (mainframe) plus fiables.
• Ils pouvaient être vendus à des utilisateurs (grandes compagnies, université ou
administrations).
• Mais devant les coûts d'équipement élevés on réduisit les temps grâce au
traitement par lots.
• Les utilisations principales étaient le calcul scientifique et l'ingénierie

(équations différentielles).
• Apparition des langages FORTRAN et assembleur.
• Apparition des systèmes d'exploitation (SE) : FMS (Fortran Monitor System)
et IBSYS (IBM 7094).

3ème génération (1965 - 1980) : Les circuits intégrés et la multiprogrammation
• Amélioration des coûts et des performances (circuits intégrés).
• Une famille d'ordinateurs (Mini-ordinateurs) compatibles entre eux avec une
seule architecture et un même jeu d'instructions (des ordi dédiés au calculs
scientifiques et commerciaux).
• Apparition du spoule (spool, Simultaneous Peripheral Operation On Line) pour le transfert
des travaux des cartes vers le disque (ex. chargement du disque des travaux à imprimer).
• Apparition de la multiprogrammation (partitionnement de la mémoire pour des
tâches différentes).
Mais, un SE énorme et très complexe pour satisfaire tous les besoins.
• Apparition du partage de temps, une variante de la multiprogrammation
naissance du système MULTICS (MULTiplexed Information and Computing Service)
pour un ordinateur central.
• Apparition des mini-ordinateurs (DEC PDP-1 en 1961, 4K mots de 18 bits, pour un
prix de 120 000 $).
• Apparition d’UNICS puis d’UNIX (UNICS en C) UNIX est porté sur toutes sortes
de machine.
4ème génération (1980 - 1990) : Les ordinateurs personnels

• Ils sont dû au développement des circuits LSI (Large Scale Integration)
contenant des centaines de transistors au cm².
• Ils (Micro-ordinateurs) ont la même architecture que les mini-ordinateurs
mais leur prix est beaucoup moins élevé.
• Il existe deux systèmes d'exploitation principaux : MS-DOS (Microsoft Inc.)
et UNIX.
• MS-DOS intègre petit à petit des concepts riches d'UNIX et de
MULTICS.
• Dans le milieu des années 80, on voit l'apparition de réseaux
d'ordinateurs individuels qui fonctionnent sous des systèmes
d'exploitation en réseau ou des systèmes d'exploitation distribués.

5ème génération (1990 - ?) : Les ordinateurs personnels portables et de

poche
• Apparition des PIC (Personal Intelligent Communicator de chez Sony) et des PDA
(Personal Digital Assistant), grâce à l'intégration des composants et l'arrivée des
systèmes d'exploitation de type « micro-noyau ».
• Ils sont utiles pour les « nomades » et les systèmes de gestion des
informations (recherche, navigation, communication).
• Ils utilisent la reconnaissance de caractère (OCR) et les modes de
communication synchrone et asynchrone (mode messagerie).
• Très bon marché, ils sont capables de se connecter à des ordinateurs
distants et performants.
• Les systèmes d'exploitation de type « micro-noyau » sont modulaires (un
module par fonction) ; ils peuvent être réalisés avec plus ou moins de modules
et donc adaptables à des très petites machines (PDA et PIC).

Système UNIX (historique)
Historique:
Historique
1) 1969 - 1979 : Les premiers pas universitaires

2) 1979 - 1984 : Les premiers pas commerciaux
3) 1984 - 1993 : La standardisation
4) 1991 - 2000 : Linux, le renouveau d'UNIX

Historique:
Historique
1) 1969 - 1979 : Les premiers pas universitaires
• Eté 1969 : Ken Thompson, aux BELL Laboratories, écrit la version expérimentale
d'UNIX (UNICS) : système de fichiers exploité dans un environnement mono-
utilisateur, multi-tâche, le tout étant écrit en assembleur.
• 1ère justification officielle : traitement de texte pour secrétariat.
• Puis : étude des principes de programmation, de réseaux et de langages.
• En 1972, Dennis Ritchie implémente le langage C, à partir du langage interprété B,
écrit par Ken Thompson.
• Eté 1973 : réécriture du noyau et des utilitaires d'UNIX en C.
• En 1974 distribution d'UNIX aux Universités (Berkeley et Columbia notamment). Il se
compose alors :
• d'un système de fichiers modulaire et simple,
• d'une interface unifiée vers les périphériques par l'intermédiaire du système de fichiers,
• du multi-tâche
• et d'un interprète de commandes flexible et interchangeable.

Historique:
Historique
2) 1979 - 1984 : Les premiers pas commerciaux
– En 1979, avec la version 7, UNIX se développe commercialement :
Par des sociétés privées comme Microport (1985), Xenix-Microsoft (1980)
... qui achetèrent les sources et le droit de diffuser des binaires.
– Des UNIX like apparaissent ; le noyau est entièrement récrit.
– L'université de Berkeley fait un portage sur VAX (UNIX 32V).
– AT&T vend la version 7 sur les ordinateurs de la gamme PDP 11.

Historique:
Historique
3) 1984 - 1993 : La standardisation
• En 1984 le Système V.2 est adopté comme standard.
• En 1984 X/Open est chargée d'organiser la portabilité d'UNIX.
• En 1985 AT&T publie SVID (System V Interface Definition) qui définit l'interface
d'application du Système V.2 et non pas son implémentation.
• En 1986, le Système V.3 apporte les Streams, les librairies partagées et RFS
(Remote File Sharing).
• En 1993, X/Open lance le COSE (Common Open Software Environment). Il s'agit
d'accords entre constructeurs pour le développement d'applications dans un
environnement commun. L'authentification d'UNIX appartient désormais à un
consortium de constructeurs (USL, HP, IBM, SUN ...).

Historique:
Historique
4) 1991 - 2000 : Linux
Linux,, le renouveau d'UNIX
• LINUX est une implantation libre des spécifications POSIX avec des
extensions System V (AT&T) et BSD (Berkeley).
• En 1991, Linus B. Torvalds (Helsinki) utilise MINIX (A. Tannenbaum)
• Août 1991 : 1ère version de LINUX 0.01. C'est une réécriture de MINIX, avec
des ajouts de nouvelles fonctionnalités et la diffusion des sources sur Internet
--> une version instable
• Mars 1994 : 1ère version stable
• Aujourd'hui : Les versions 2.0 ... respectent la norme POSIX (code source
portable) et le code source est gratuit.

Qualités du système UNIX
1. Code source facile à lire et à modifier ; disponible commercialement.
2. Interface utilisateur simple ; moins conviviale que… mais très puissante.
3. Le système est construit sur un petit nombre de primitives de base ; de
nombreuses combinaisons possibles entre programmes.
4. Les fichiers ne sont pas structurés au niveau des données, ce qui
favorise une utilisation simple.
5. Toutes les interfaces avec les périphériques sont unifiées (système de
fichier).
6. Le programmeur n'a jamais à se soucier de l'architecture de la machine
sur laquelle il travaille.
7. C'est un système disponible sur de nombreuses machines, allant du
supercalculateur au microordinateur (PC).
8. Les utilitaires et programmes proposés en standard sont très
nombreux.
Caractéristiques générales du noyau
1. Multi-tâche / multi-utilisateur
2. Système de fichiers arborescent
3. Entrée/Sorties compatible fichiers, périphériques et processus
4. Réduction du noyau système
5. Interface au noyau

1. Multi-
Multi-tâche / multi-
multi-utilisateur
• Plusieurs utilisateurs peuvent travailler en même temps ; chaque
utilisateur peut effectuer une ou plusieurs tâches en même temps.
• Une tâche ou un processus = programme s'exécutant dans un
environnement spécifique.
• Les tâches sont protégées ; certaines peuvent communiquer, c.à.d
échanger ou partager des données, se synchroniser dans leur
exécution ou le partage de ressources. Certaines tâches peuvent être
« temps réel ».

2. Système de fichiers arborescent
• Arborescence unique de fichiers, même avec plusieurs périphériques
(disques) de stockage.
3. Entrée/Sorties compatible fichiers, périphériques et processus

• Les périphériques sont manipulés comme des fichiers ordinaires.
• Les canaux de communication entre les processus (pipe) s'utilisent
avec les mêmes appels systèmes que ceux destinés à la
manipulation des fichiers.

4. Réduction du noyau système
• UNIX comprend un noyau (kernel) et des utilitaires. Irremplaçable par
l'utilisateur, le noyau gère les processus, les ressources (mémoires,
périphériques ...) et les fichiers.
• Tout autre traitement doit être pris en charge par des utilitaires ; Cas
de l'interprète de commande (sh, csh, ksh, tcsh ...).
5. Interface au noyau
• L'interface entre le noyau UNIX et les périphériques est assurée par
les gestionnaires de périphériques (devices driver).
• L'interface entre le noyau UNIX et les programmes utilisateurs est
assurée par un ensemble d'appels systèmes.


Langage de commande
et
expressions régulières

A- Langage de commande

Langage de commandes
Points à aborder
1. Les commandes internes et externes
2. Les variables
3. Les procédures
4. Les structures de contrôle
5. Les opérateurs
6. Les commandes « test », « expr » et « find »
7. Les fonctions.

Langage de commandes (1/2)
Définition
• Une commande est un texte (une ou plusieurs chaine de caractère) qui
a une syntaxe particulière.
• Un langage de commandes est un langage qui permet une
communication entre un utilisateur et le système (noyau)
notion de Shell.
• Il permet ainsi de lancer l’exécution d’autres programmes et de
définir l’environnement d’exécution de ces programmes et les
liaisons de ces programmes avec les objets externes qu’ils
manipulent.
Ex. Sous UNIX: commande ls , cp, date, echo…
Sous DOS: commande dir, copy, date, echo, print…
Remarque: Il est parfois nécessaire d’identifier l’utilisateur qui lance la
commande, afin de contrôler les opérations effectuées.
Langage de commandes (2/2)
Les différents types de SHELL
• 2 principales familles
– « Bourne Shell » : la syntaxe des commandes est proche de
celle des premiers UNIX ( /bin/sh ).
– « C Shell » : la syntaxe est proche du « C » ( /bin/csh ).
• D’autres variations:
– « Bourne Again Shell » ou bash correspond au Bourne Shell
augmenté de la plupart des fonctionnalités avancées du C
Shell (/bin/bash ).
Un script Bourne Shell (sh) est correctement interprété avec
un Bourne Again Shell (Bash), car sh ∈ bash
– « Tcsh » C’est une extension du C Shell d’origine ( /bin/tcsh )
A-1) Langage de commandes
Commandes internes et commandes
externes

1) Commandes internes
• C’ est une commande intégrée au Shell (mot réservé du
langage Shell).
• Pour la traiter, le Shell effectue lui−même un traitement
spécifique, sans créer de sous−processus.
• Ex. : cd, trap, umask, wait… (obligatoirement internes)
echo, pwd, test… (juste pour rapidité sinon elles auraient pu être
externes)
type nom-commande pour voir si la commande est interne
ou externe
Ex.
type cd
cd is a Shell builtin

2) Commandes externes
• C’est un fichier exécutable.
• Le Shell recherche ce fichier exécutable dans chacun des
répertoires spécifiés par la variable PATH.
• Pour traiter une commande, le Shell crée un
sous−processus. Cette commande ne peut donc pas
modifier l’environnement du processus.
Ex.
type cp
cp is /usr/bin/cp

Exécution d’une Exécution d’une
commande commande
interne externe
cd /tmp cp fich1 fich2

Exécution d’une commandes (internes ou externes)
• Lire le texte de la commande
• L’interpréter
• Si (la commande est INTERNE) Alors
•L’exécuter au sein du Shell courant
• Sinon (ie commande EXTERNE)
•La chercher sur le disque
• Si (le fichier est un BINAIRE) Alors
•Lancer un processus qui va exécuter le BINAIRE
• Sinon
•Lancer un processus interpréteur qui va lire et
exécuter le texte de la COMMANDE

Les variables

Les variables
Définition de variable (1/3)
• Nom de la variable: une chaîne de caractères ne
contenant pas de caractères spéciaux.
– L’usage des majuscule est plutôt réservé pour les
variables systèmes
• L’affectation « = » : Le Shell associe du texte au nom de la
variable, sans présumer de sa signification.
• Ex.
i=2, i=02, i=0002, i=deux
Pas de signification Les instructions ci-dessus sont toutes
différentes)

Les variables
• Pour accéder au contenu d’une variable, on utilise le
caractère ’$’ devant le nom de la variable. C’est le Shell
qui fait la substitution.
$ variable=valeur
$ echo variable
variable
$ echo $variable
valeur
$.

Les variables
• Une variable non définie a une valeur nulle.
– Cela permet d’utiliser une variable alors qu’on ne l’a jamais
affectée.
• Pour bien limiter le nom de la variable de son contenu, on
l’encadre entre accolades ({}).
$ echo rien
rien
$ echo $rien
$ echo A$rienA
A
$ echo A${
${rien}
}A
AA
$

Les variables
Réévaluation de variable !!!
• Il n’est pas possible de réévaluer les variables utilisateurs.
le Shell ne change la valeur d’une variable QUE lors de
l’affectation.
$ A=1
$ B=A
$ echo $B
A
$ B=$A
$ echo $B
1
$ A=2
$ echo $B
1
$

Les variables
Interprétation des métacaractères
• Les métacaractères du Shell sont substitués parmi les noms de
fichiers du répertoire courant.
• Leur interprétation est faite après celle des variables.
$ ls −x f*
f1 f2 fic1 fic2 fic3 fichier
$ t=fic
$ ls −x $t*
fic1 fic2 fic3 fichier
$
On a aussi:
$ l=ls
$ $l −x $t?
fic1 fic2 fic3

Les variables
Substitution de commande (1/2)
• Il est possible de faire exécuter une commande et d’en
récupérer le résultat dans une variable.
• Cela se fait en encadrant une commande par des quottes
inverses ‘…‘ (AltGr + 7).
$ echo la date est : ‘date‘
la date est : Wed May 18 15:56:30 MET 1994
$ logname
c1
$ grep ‘logname‘ /etc/passwd
c1:x:106:104:Eleve 1:/usr/c1:/bin/ksh
$ date
Wed May 18 15:57:30 MET 1994
$ ‘date‘
ksh: Wed command not found
$

Les variables
Substitution de commande (2/2)
• La commande à exécuter entre ‘…‘ ‘:
– ne doit pas faire de lecture au clavier (ex: ni vi, ni pg)
– s’exécute dans un Sous−Shell, donc peut être
composée de plusieurs commandes séparées par des
’;;’ voire même s’exécuter dans un autre répertoire.
$ var=‘
‘cd /etc ; grep fun passwd‘
‘
$ echo $var
fun:x:208:55:Guy Thienot:/tech/u2/fun:/bin/ksh

Les variables
Liste des variables
• Commande set Pour visualiser toutes les variables que le
Shell connaît.
• Les variables dont le nom est en MAJUSCULE sont les
variables d’environnement du Shell
Ex.
• PATH: liste de répertoires séparés par le caractère ‘:’ pour rechercher
les commandes (/bin :/usr/bin :/usr/local/bin :/usr/bin/X11 :.)
• SHELL: référence absolue du processus Shell (/bin/bash)
• USER: nom de login de l’utilisateur courant (ali)
• HOME : répertoire de travail à l’ouverture d’une session (/home/ali)
• …

Les variables
Destruction d’une variable
• Pour détruire des variables utiliser la commande :

unset var var1 ...

Les variables
Sauvegarde des valeurs des variables
• Pour une sauvegarde permanente du contenu d’une variable, il
faut placer ses initialisations dans un fichier lu au démarrage du
Shell ; en général le fichier $HOME/.profile (ou le fichier dont le
nom est contenu dans la variable $ENV)
• Lorsque le Shell démarre, il lit et exécute chaque ligne du
fichier .profile, sans créer de sous−processus. Ce fichier permet
donc d’initialiser l’environnement du processus. On y trouve
typiquement des commandes telles que :
umask 027
PATH=/bin:/usr/bin:$HOME/bin:.
export PATH
V2=$HOME/projet/src/version2
export V2

Les variables
La portée des variables
• n’est vue que dans le Shell dans lequel elle a été définie.
ne sera pas connue des processus fils.
• Le Shell doit exporter (export
export) une variable pour pouvoir
la transmettre aux fils.
$ a=1 $ bash
$ bash $ echo $a
$ echo $a 1
$ exit $
$ export a cet héritage est fait à tous les fils puis on
$ remonte
on fait hériter les fils de la valeur de a $ exit
$ bash $
$ echo $a
1
$
La variable a bien été transmise

Les variables
L’Affectation interactive (commande interne read read))
• read assigne une valeur à une variable, à partir d’une
lecture sur l’entrée standard (clavier)
• Après un read la machine se met en attente du clavier et
affecte les valeurs entrées (séparées par les valeurs citées dans $IFS)
aux noms de variables qui lui sont passés en arguments.
Remarques:
– Si plus de valeurs sont entrées qu’il n’y a d’arguments, alors la
dernière variable vaudra tous les derniers mots restant.
– S’il y a moins de valeurs entrées que de variables, celles non
affectées sont mises à vide.

Les variables
Exemple:
$ read a
10 $ read d e f
$ echo $a Bonjour
10 $ echo $d
Bonjour
$ read b c d $ echo $e
voici trois mots $ echo $f
$ echo $d $c $b
mots trois voici $ IFS=u$IFS
$ read g h
$ read a b c cou cou
et voici quatre mots $ echo $g
$ echo $a co
et $ echo $h
$ echo $b co
voici
$ echo $c Remarque:
quatre mots IFS=u$IFS -> concaténation du contenu de IFS
avec le u. Elle va donc contenir « u + blanc »
IFS=u réinitialisation de IFS

Procédures

Procédures
Définition
Définition:
Une procédure est un fichier contenant une suite de
lignes exécutables par l’interpréteur de commandes
Shell
(Shell script, fichier de commandes Shell).
Exemple :
$ cat fichier_procedure_1
# ceci est une procédure
date
who
tty
$

Procédures
Exécution d’une procédure : (1/4)
Soit :
1. Utiliser la commande interne ’..’,
2. Lancer un Shell + rediriger son entrée standard sur le
fichier contenant la procédure,
3. Lancer la procédure après avoir rendu exécutable le
fichier la contenant.

Procédures
Exécution d’une procédure (2/4)
1) Utiliser la commande interne ’..’ qui permet de lire et
d’exécuter les commandes se trouvant dans le fichier
procédure, sans créer de sous-processus.
Exemple :
$ . fichier_procedure_1
wed Jul 6 11:07:45 MET 1994
philip term/c0 Jul 6 10:30
fun term/c5 Jul 6 09:06
c1 term/c4 Jul 6 09:14
/dev/term/c4
$
• Dans ce cas, aucun processus n’est créé pour lire et lancer ces commandes,
(mais de toutes façons trois processus sont créés par ce script).

Procédures
2) Lancer le programme Shell en redirigeant son entrée
standard sur le fichier contenant la procédure. Ainsi le Shell
lit les commandes sur ce fichier au lieu de les lire sur le
terminal.
Exemple :
$ bash fichier_procedure_1
wed Jul 6 11:07:45 MET 1994
/dev/term/c4
$
• Dans ce cas, un sous−processus est créé. Le père est mis en attente et ne sera
réveillé que lorsque le sous−processus sera terminé.

Procédures
3) Modifier les droits du fichier script, pour le rendre
exécutable pour l’utilisateur, puis lancer la procédure
comme s’il s’agissait d’une commande standard.
Exemple :
$ chmod u+rx fichier_procedure_1
$ fichier_procedure_1
wed Jul 6 11:07:45 MET 1994
/dev/term/c4
$
• Le fichier devient une commande externe (pas de code machine, mais des
lignes de texte). Le système crée un processus, qui exécute le programme
Shell, et les commandes sont lues depuis ce fichier.

Procédures
Paramètres positionnels (1/2)
Paramètres positionnels = arguments d’appel de la procédure
Ex . $ fichier_procedure1 arg1 arg2 arg3
$ Moyenne 10 12 1 4
Le nom de ces paramètres sont $0, $1…$9
Ex. Dans l’exemple précédent, Moyenne=$0, 10=$1, 12=$2, 1=$3 et
4=$4
Ex.
$ cat p2
echo $0 $1 $2 $3
$ p2 a b c
p2 a b c

Procédures
Paramètres positionnels (2/2)
S’il y a plus de 9 paramètres, il faut soit utiliser la commande Shift
soit mettre les paramètres entre accolades {…}
EX.
$ cat proc2 $ proc2 a b c d e f g h

echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9 i j k l m
shift
echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9 proc2 a b c d e f g h i
proc2 b c d e f g h i j
shift 2  ça fait 3 avec le 1er shift
proc2 d e f g h i j k l
echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9 proc2 g h i j k l m
shift 3  ça fait 6 avec le 1er et 2ème shift k l
echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $
$ echo ${11} ${12}

Procédures
Variables automatiques (1/3)
• Exécution d’une procédure initialisation des paramètres
positionnels et des variables automatiques (ou var prédéfinies).
• Les var automatiques peuvent être consultées, mais pas
modifiées.
Nom de la variable Valeur de la variable Nom de la variable Valeur de la variable
le dernier mot de la dernière ! le numéro du dernier processus
_ ( underscore )
commande exécutée lancé en arrière−plan
le nombre de variables de position PPID le numéro du processus père
#
définies
la liste des variables de position vu PWD la référence absolue du
*
comme une seule variable répertoire de travail
@ la liste des variables de position RANDOM un nombre aléatoire
le code de retour du dernier SECONDS le nombre de secondes
? processus terminé écoulées depuis le lancement
du processus Shell
$ le numéro du processus courant

Procédures
• Après avoir lancé une commande en mode asynchrone, $!
contiendra une valeur. Elle la conservera même si la
commande associée s’est terminée.
– Ex. Utiliser la commande suivante pour terminer le dernier
processus lancé en mode asynchrone, sans faire appel à ps:
$ kill $!

Procédures
$ cat p3 $
date $ chmod u+x p3
sleep 2 $ ls −l p3
ps −f −rwxr−−r−− 1 jmr ens 115 Nov 16
echo "0=$0 1=$1 2=$2 3=$3 4=$4 10:07 p3
5=$5"² $ p3 abc xyz 123
echo "#=$# *=$* !=$! $=$$" Mon May 20 11:46:32 MET DST
$ ls −l p3 1995
−rw−r−−r−− 1 jmr ens 115 Nov 16 PID TTY STAT TIME COMMAND
10:07 p3 56 v01 S 0:01 −bash
$ . p3 abc xyz 123 112 v01 S 0:00 \_ −bash
Mon May 20 11:45:20 MET DST 1995 115 v01 R 0:00 \_ ps −f
PID TTY STAT TIME COMMAND 0=./p3 1=abc 2=xyz 3=123 4= 5=
56 v01 S 0:01 −bash #=3 *=abc xyz 123 !=95 $=112
112 v01 S 0:00 \_ ps −f
0=−bash 1=abc 2=xyz 3=123 4= 5=
#=3 *=abc xyz 123 !=95 $=56 $0=./p3, car p3 est devenu maintenant
exécutable !!!
$0=bash car c’est le Shell (.p3) qui exécute les
lignes de p3 !!!

Procédures
Commande set
• La commande set permet de donner une valeur aux
paramètres positionnels, et de mettre à jour les variables
automatiques ’$#’, ’$*’, ’$@’.
$ set abc xyz 123
$ echo $1 $2 $3 $#
abc xyz 123 3
$
• La commande set sans argument liste les variables
connues du Shell courant (cf. dernier cours).
• La commande env sans argument liste les variables
exportées du Shell courant.

Procédures
Statut d’une procédure
• Chaque commande d’une procédure est exécutée en
séquence. Si l’une de ces commandes échoue, la
procédure continue.
• Le statut de la procédure est celui de la dernière
commande exécutée.
exécutée
$ cat p4 $ p4
who c1 term/c4 Jul 19 07:41
echo statut de who : $? manu term/b1 Jul 18 15:22
date −z fun term/b3 Jul 19 09:10
echo statut de date −z : $? statut de who : 0
$ ls −l p4 date: illegal option −− z
−rwxr−x−−x 1 c1 cours 94 Jul ... statut de date −z : 1
p4 $ echo $?
1
$
Procédures
Commande Exit
• C’est une commande interne permettant de terminer la
procédure sans exécuter les lignes qui suivent.
• Elle est suivie par l’argument qui fournit le statut de retour
de la procédure.
• Ex.
$ cat proc5
ls −l p4
exit 2
Who
$ proc5
−rwxr−x−−x 1 c1 cours 94 Jul ... P4
$ echo $?
2
$

Structures de contrôle

But: permettre de transformer une simple procédure en un
programme qui pourra comparer, tester ...
Exemples (à voir):
– La structure « for »
– La structure « if »,
– La structure « case »,
– Les structures « while » et « until »,
– Les débranchements,
– Les « Sous-Shell »,
– Les Blocs.
Remarques:
1. Afin d’optimiser le système, ces commandes sont déclarées internes.
2. Chacun des interprètes de commandes offre ses propres structures de
contrôle.
La structure « for »
for nom [ in liste ... ]
do
commandes
done
• exécuter les commandes autant de fois qu’il y a d’éléments
dans la liste, et remplacer les variables des commandes par les
éléments de la liste.
• Nom : est le nom d’une variable, qui prendra successivement la
valeur de chaque mot de la liste exhaustive fournie après in.
• L’exécution se termine lorsqu’il n’y a plus d’élément dans la
liste.

Ce qu’on peut faire avec « for…do…done »
• for var in liste_exhaustive
• for var in $VARIABLE
VARIABLE
• for var in $** ou for var
• for var in ‘commande‘‘
• for var in métacaractères

for var in liste_exhaustive
Ex1.
$cat pgm_Feu1
$ for i in 3 2 1 Feu
> do echo $i
> done
$pgm_Feu1
3
2
1
Feu

for var in liste_exhaustive (suite)
Ex2.
for i in 1 2 3
do cp fich "$i
$i" /tmp
chmod 666 /tmp/fich "$i
$i"
done
Copie les fichiers fich1, fich2 et fich3 dans le répertoire

/tmp, et change leurs protections.

for var in $** (ou for var) (1/4)
• Récupérer la liste d’arguments d’une procédure comme
différents mots de la boucle.
for i for i in $*
do do
commande est équivalent à : commande
done done

La structure « for » $ cat pgm_listarg
for arg
for var in $** do
(ou for var) (2/4) echo argument: $arg
done
• Ex.
$ chmod a+rx pgm_listarg
for var in $variable
$ pgm_listarg camion proton vélo
argument: camion
argument: proton
argument: vélo
$ pgm_listarg f* $HOME
argument: fic1
argument: fic2
argument: /usr/c1
$
for var in $**
$ VAR="3 2 1 Feu"
(ou for var) (3/4)
• Ex2. $ cat pgm_Feu2
$ for i in $VAR
for var in $variable > do
> echo $i
Il est possible de passer une liste > done
dont les éléments seront variables.
$ pgm_Feu2
3
2
1
Feu
$

for var in $** $cat pgm_cons_voyel
(ou for var) (4/4) $ for consonne in b c d f g
> do
• Ex3. Imbrication > for voyelle in a e i o u
> do
> echo "$consonne$voyelle\c"
> done
• La séquence \c de la > echo " "
commande echo permet > done
de ne pas faire de saut
de ligne. $ pgm_cons_voyel
• La commande echo " " babebibobu
permet de sauter une cacecicocu
ligne. dadedidodu
fafefifofu
gagegigogu
$
for var in `commande`` $cat pgm_fic
> for fic in ‘ls‘
‘
Ex. > do
> echo $fic present
> done
•Il est possible d’initialiser la liste à
l’aide du résultat d’une commande en $ pgm_fic
mettant la commande entre `…`. fic present
fic1 present
•La variable fic sera initialisée fic2 present
successivement à chacun des mots du rep present
résultat de la commande ls. $
•Cette commande ne sera exécutée
qu’une seule fois au premier passage.

for var in …métacaractères
• On peut aussi initialiser la liste dans la substitution

des noms de fichiers via les métacaractères.
Ex.
…

La structure « if »,
• Syntaxe
if commandes1
then commandes2
[else commandes3]
Fi
Explication:
– La commande1 est évaluée.
– Si elle est vraie (code de retour nulle), commande2 est évaluée à
son tour (et commande3 ne le sera pas)
– Si elle est fausse (code de retour non nulle), commande3 est
évaluée (commande2 ne l’étant pas).
Rq: La partie else de cette instruction est optionnelle.

Ex.
$ cat exist_user
if grep "$1" /etc/passwd > /dev/null
then echo "L’utilisateur $1 a un compte"
else echo "L’utilisateur $1 n’existe pas"
Fi
$ chmod u+x exist_user
$ exist_user c1
L’utilisateur c1 a un compte
$

• Il est possible d’enchaîner en cascade des conditionnelles de ce type :
if commandes1 if commandes1
then commandes2 then commandes2
else if commandes3 Que l’on elif commandes3
then commande4 peut then commandes4
else if commande5 elif commandes5
...... écrire .....
fi sous la fi
fi forme
fi
abrégée
en :


Qlq abréviations :
• commande1 && commande2

est équivalent à :
if commande1 ; then commande2 ; fi
• commande1 || commande2
Cette commande provoque l’exécution de commande2 uniquement si
commande1 est fausse.

Ex. :
$ cat existfic
if test −d $1
then echo "$1 est un repertoire"
elif test −w $1
then echo "$1 autorise l’ajout"
elif test −r $1
then echo "$1 est lisible"
else echo "$1 autre ..."
fi
$
• Le premier argument de la procédure sera testé
successivement pour connaître au moins une de ses
permissions.

La structure « case »,
• Elle permet de sélectionner des actions suivant la valeur
de certains mots.
• La structure case ne peut que comparer des chaînes de
caractères.
• Elle peut être remplacée par une structure de la forme
if else if else ...

Syntaxe :
case chaîne in
motif1) commande1 ;;
motif2) commande2 ;;
...
motifn) commanden ;;
esac
• Les différents motifi sont des expressions reconnues par le mécanisme
d’expansion des noms de fichiers.
• De plus, le caractère "|", lorsqu’il est utilisé dans un motif, permet de faire
l’union des deux expressions entre lesquelles il est placé.
• L’interpréteur recherche le plus petit entier i inférieur à n tel que chaîne
réponde au motifi. Il exécute alors la commandei (et elle seule).
• Il est courant d’utiliser * comme dernier motif (cas par défaut) d’un
aiguillage.

Ex1.
$ cat engtofr
case $1 in
one)X=un;;
two)X=deux;;
three) X=trois;;
*) X=$1;;
Esac
echo $X
$ chmod u+x engtofr
$ engtofr one
un
$

Ex2.
$ cat choix
echo –e "voulez vous continuer \c"
read reponse
case "$reponse" in
[nN] | no | NO)
) exit 0;;
;;
esac
# suite du traitement
date
$

Les structures « while » et « until »,
Syntaxe de « while » :
while commandes1
do commandes2
done
• Dans le cas du while, tant que le statut de commandes1

est vrai, commandes2 est exécutée.
• Rq : commandes1 peut être formée d’un ensemble de

commandes enchaînées par des pipes (|).

Ex.
$ cat deconnecte $ chmod u+x deconnecte
while who | grep "$1" > /dev/null $ deconnecte c1
do ,,,
sleep 180 c1 n’est plus connecte
echo ",\c" $
done
echo "\n$1 n’est plus connecté"
Explications:
• Tant que l’utilisateur passé en argument (ici c1) est dans la liste de la commande who
(donc est connecté), on boucle après avoir attendu 180 secondes et affiché une virgule.
• Puis on signale qu’il n’est plus connecté. Les commandes testées dans le while sont
exécutées, donc leur affichage se fait à l’écran (sortie standard), afin d’éviter de recevoir
l’affichage parasite (seul le statut nous intéresse), on redirige la sortie standard de la
dernière commande dans le pseudo−périphérique /dev/null.

Syntaxe de « until »:
until commandes1
do
commandes2
done
• On réexécute commandes2 jusqu’à ce que comandes1

devienne vraie.

Syntaxe de « until »:
Ex.
Explications: Tant que $ cat userloger
l’utilisateur passé en argument until who | grep "$1" > /dev/null
ne se trouve pas dans la liste do
echo −e ",\c"
des utilisateurs (who | grep sleep 300
$1), on affiche une virgule done
(l’option "−e" permet de prendre en echo "\n$1 est arrivé"
compte le "\c" qui ne fait pas de
saut de ligne) et on fait une $ chmod u+x userloger
pause (sleep 300). Dès que $ userloger c1
,,,
l’utilisateur se connecte, on sort c1 est arrivé
de la boucle et on affiche le $
message "utilisateur est
arrivé".

Les débranchements, (1/2)
• break : sortir prématurément d’une boucle sans effectuer
tous les tours prévus,
• Cela permet de pouvoir sortir d’une boucle infinie, ou que
la sortie soit déclenchée par un événement autre que le
test de boucle.
• continue : permet au contraire de faire un tour de boucle

supplémentaire.
• break n permet de sortir du nième niveau (1 par défaut) de

boucle for ou while.

Les débranchements, (2/2)
Ex.
$ cat fichexist $ ls
while : fichexist
do fichA
echo −e "nom de fichier: \n"
read fic $ fichexist
if test −f "$fic" nom de fichier : foo
then foo fichier inconnu
break nom de fichier : barbe
else barbe fichier inconnu
echo $fic fichier inconnu nom de fichier : fichA
fi fin de traitement
done $
# le break branche ici
# la suite du traitement
echo "fin de traitement"

Les opérateurs

Les opérateurs
L’opérateur « ET logique »
Syntaxe : cmd1 && cmd2
• On exécute cmd2 uniquement si cmd1 se termine
correctement $ pwd
/usr/c1
$ mkdir tmp
Explications de l’ex.: $ test -d $HOME/tmp && cd $HOME/tmp
Si le répertoire tmp $ pwd
existe dans le /usr/c1/tmp
répertoire courant,
$ cd
alors aller dans ce
$ rmdir tmp
répertoire. $ test -d $HOME/tmp && cd $HOME/tmp
$ pwd
/usr/c1
$

Les opérateurs
L’opérateur « OU logique »
Syntaxe : cmd1 || cmd2
• On exécute cmd2 uniquement si cmd1 ne se termine pas
correctement (statut ≠ 0).
$ pwd
/usr/c1
Explications de l’ex.: $ mkdir tmp
S'il n'existe pas de $ test -d $HOME/tmp || echo $HOME/tmp
répertoire tmp dans le inexistant
répertoire courant,
$ rmdir tmp
alors afficher un $ test -d $HOME/tmp || echo $HOME/tmp
message. inexistant
/usr/c1/tmp inexistant
$

La commande test

La commande test
La commande test
Syntaxe:
test expression
Ou mettre l’expression entre crochets:
[ expression ]
• La commande test évalue expression et retourne le

résultat de cette évaluation.
• Quand test est appelée sans argument elle retourne faux.

La commande test
Test sur des fichiers et répertoires :
test -w fichier vrai si fichier existe et est autorisé en écriture.

test -r fichier vrai si fichier existe et est autorisé en lecture.
test -x fichier vrai si fichier existe et est exécutable.
test -d fichier vrai si fichier existe et est un répertoire.
test -f fichier vrai si fichier existe et n'est pas un répertoire.
test -s fichier vrai si fichier existe et a une taille non nulle.
test -t descripteur vrai si descripteur est associé à un terminal.

La commande test
Test sur des chaînes :
test -z s1 vrai si la chaîne s1 est vide (a une longueur de 0 caractère).

test -n s1 vrai si la chaîne s1 est non vide.
test s1 = s2 vrai si les chaînes s1 et s2 sont identiques.
test s1 != s2 vrai si les chaînes s1 et s2 sont différentes.
test s1 vrai si la chaîne s1 n'est pas la chaîne nulle.

La commande test
Test sur des nombres : (1/2)
test n1 -eq n2 vrai si l'entier n1 est égal à l'entier n2.

test n1 -ne n2 vrai si l'entier n1 est différent de l'entier n2.
test n1 -gt n2 vrai si l'entier n1 est supérieur à l'entier n2.
test n1 -lt n2 vrai si l'entier n1 est inférieur à l'entier n2.
test n1 -ge n2 vrai si l'entier n1 est supérieur ou égal à l'entier n2.
test n1 -le n2 vrai si l'entier n1 est inférieur ou égal à l'entier n2.

La commande test
Test sur des nombres : (2/2)
Ex.
$ cat testarg
if test "$#" -eq "0"
then
echo "usage: $0 arg1 arg2" >&2
exit 1
fi
$

La commande expr

La commande expr
Syntaxe
Syntaxe:
expr arg …
Explication: L'expression formée par les arguments, est
évaluée, et expr retourne le résultat de cette évaluation.
Attention : Certains opérateurs utilisés par la commande expr

sont significatifs pour le Shell. Ils devront donc être
protégés, en utilisant soit '…' , soit " …" soit \...
Ainsi par exemple :
• pour | utiliser : '|' ou encore "|" ou encore \|
• pour >= utiliser : '>=' ou encore ">=" ou encore \>=
• pour * utiliser : '*' ou encore "*" ou encore \*

La commande expr
Qlq utilisations : (1/2)
Plusieurs arguments peuvent être combinés à l'aide des
opérateurs suivants (expr arg1 op arg2) :
e1 | e2 si e1 est égale à 0 retourne e2 sinon retourne e1
e1 & e2 si ni e1 ni e2 ne sont égales à 0 retourne e1
e1 < e2 retourne 1 si e1 est plus petit que e2 sinon 0
e1 <= e2 retourne 1 si e1 est plus petit ou égal à e2 sinon 0
e1 = e2 retourne 1 si e1 est égal à e2 sinon 0
e1 != e2 retourne 1 si e1 est différent de e2 sinon 0
e1 > e2 retourne 1 si e1 est supérieur à e2 sinon 0
e1 >= e2 retourne 1 si e1 est supérieur ou égale à e2 sinon 0

La commande expr
Qlq utilisations : (2/2)
Remarque: Si les deux expressions sont numériques, la
comparaison sera numérique, sinon elle sera
lexicographique.
e1 + e2 retourne le résultat de l'addition

e1 - e2 retourne le résultat de la soustraction
e1 * e2 retourne le résultat de la multiplication
e1 / e2 retourne le résultat de la division
e1 % e2 retourne le résultat du modulo

La commande expr
Ex.
a=3
b=$(expr $a + 5)
• La variable "b" va récupérer le résultat du calcul effectué

entre parenthèses, c'est-à-dire "8". La variable "a" est
inchangée.

Les fonctions

Fonctions
Fonctions

B- Expressions régulières

Lgge de commandes et E. Rég.
Introduction aux E-R (1/2)

• Les E.R. sont des chaînes de caractères permettant de
définir des règles sophistiquées de recherche et de
remplacement de motifs.
• Elles constituent un outil puissant de manipulation de
données et de textes.
• Ex. de problèmes résolus facilement avec les ER :
– Trouvez tous les doublons d’un texte
– Réaliser une table des matières de tous ses emails
– Changer automatiquement un code dans un programme ou dans un
document HTML
• Les expressions Shell sont limitées, car bornées à un problème simple,
le repérage de noms de fichier.

Lgge de commandes et E. Rég.
Introduction aux E-R (2/2)

• Les expressions régulières sont acceptées par tous les
Shells.
– grep par exemple accepte des expressions régulières.
Ex.
grep *chaine, grep ^chaine, grep *toto*, grep chaine$
On peut voir les expressions régulières comme des filtres,

des masques agissant sur des chaînes de caractères.

Expressions régulières
Exemple: La commande egrep
Recherche dans les fichiers textes
• egrep ‘^(From|Subject) : ‘ mailbox

pour réaliser la table des matière d’une mailbox
• egrep ‘chat’ fich_1
cherche les caractères chat dans le fichier fich_1
• Elle trouve et affiche les lignes contenant ‘chat’ mais aussi
‘rachat’…

Les métacaractères
1- Début et fin de ligne : ^ et $
^chat reconnaît ‘chat’ placé en début de ligne.
chat$
chat$ reconnaît ‘chat’ placé en fin de ligne
^chat
chat$
$ reconnaît une ligne qui ne contient que le mot ‘chat’
^$ reconnaît une ligne vide

2- Les classes de caractères : [ … ]
• permet de chercher tous les caractères énumérés dans la classe de
caractère.
l[iy]s ‘lys’ ou ‘lis’
[sS]inge singe ou Singe
H[123456] reconnaît les tags H1, H2, H3, … du HTML
H[1-
-6] Équivalent à H[123456] (effet du métacaractère –)
H[0-9a-z_ !. ?] H suivi d’un chiffre, d’une lettre, d’un caractère qlcq,
d’un underscore (_), mais pas d’un point (effet du métacaractère !).
[-a-b] cherche soit un tiret, soit un a, soit un b.

Un tiret en début de liste est considéré en tant que
tel et non pas comme métacaractère

3- Les classes complémentées : [^ … ]
• Si on place un ^ devant la classe on cherche alors tous les
caractères qui ne font pas partie de la classe
• Attention: Ne pas confondre le rôle de ^ en tête de classe (ie.
[^…]) et en tête d’expression (ie. ‘^…’).
egrep ‘q[^u]’ fich1 cherche dans le fichier fich1 toutes les lignes
avec des mots qui comptent un q non suivi d’un
u (comme coq ou iraq).

4- Le .
(le point)
• Il désigne n’importe quel caractère.
04.07.05 reconnaître les dates écrites 04/07/05, 04-07-05 ou

04.07.05.
Mais attention reconnaît aussi 04207805 (N°de tél !)

5- Les alternatives : | (un OU logique).
• Il permet de combiner plusieurs expressions en une seule qui reconnaît
au choix l’une des deux expressions.
lis|lys Équivalent à l[iy]s

l(i|y)s Équivalent à l[iy]s.
Les parenthèses sont des métacaractères.
Première|1ère (Premi|1)ère
– Attention à ne pas confondre l’expression ^From|Date|Subject : avec

^(From|Date|Subect) : Il désigne n’importe quel caractère.

6- Les éléments optionnels : ?
• Si on fait suivre un élément par un ?, cela rend l’élément optionnel.
colou?r Correspond à color mais aussi à colour (les

orthographes anglaises et américaines du mot
couleur).
man(teau)? Désigne les expressions soit man, soit manteau.

7- La répétition : * et +
• + signifie une ou plus répétition de l’élément précédent.
• * signifie zéro ou plus répétition de l’élément précédent.
• On appelle le ? , le + et l’* des quantificateurs, car ils définissent le
nombre de fois ou un élément peut apparaître.
<H[1-6] *> Désigne toutes les balises H en html mais en

autorisant un nombre d’espace quelconque avant le >
While +(.*) +{ début d’une boucle while en C qui s’écrit :

While +$.*$ +{
while (…) {.
Attention: Dans cet exemple il y a un blanc avant le +

8- Intervalles définis de reconnaissance
• A la place des quantificateurs on peut aussi utiliser la notation {min, max}
qui indique le nombre de fois minimum et maximum ou l’élément doit
apparaître.
{0,1} Correspond à: ?
{1, } Correspond à: +
{0,} Correspond à: *
While +(.*) +{ While {1,}(.{0,}) {1,}{
à ne pas utiliser car risque de créer une confusion entre le métacaractère { et
le caractère {

9- Parenthèses et références arrières (…)
• On peut dans une expression faire référence à quelque chose qu’on a
déjà reconnu au début du motif. Ce quelque chose doit être entouré par
des parenthèses. On y fait alors référence par la notation \n où n est un
entier qui désigne la paire de parenthèses qui a reconnu le motif.
(le) \1 Correspond à ‘le le’.

(le) (la) \1 \2 Correspond à ‘le la le la’
(le la) \1 Correspond à (le) (la) \1 \2 de l’exemple
précédent

10- Rendre normaux les métacaractères: \
• Pour chercher des métacaractères dans un texte on le précède du
caractère \.
www\.univ-jfc\.fr Correspond à : www.univ-jfc.fr

11-Transformer certains caractères en métacaractères : \
• Certains caractères prennent une signification spéciale quand on le
précède du caractère \.
\n Correspond à : retour à la ligne

\t Correspond à : tabulation
\d Correspond à : chiffre (identique à [0-9])
\D Correspond à : non-chiffre
\w Correspond à : caractère constituant de mot (souvent identique à [a-zA-Z0-9]
\W Correspond à : complément de caractère constituant de mot (cf.ci-dessus).
\s Correspond à : espacement vide (souvent identique à [ \t\n], tabulation ou retour chariot)
\S Correspond à : non espacement

12-Les classes de caractères spéciales
• Les classes spéciales qui dépendent de la localisation :
[ :alnum :] caractères alphabétiques et numériques
[ :alpha :] caractères alphabétiques
[ :blank :] espacement
[ :cntrl :] caractères de contrôle
[ :digit :] chiffres
[ :graph :] non blancs (pas d’espaces, de caractères de contrôles, etc)
[ :lower :] caractères alphabétiques en lettres minuscules.
[ :upper :] majuscules
[ :print :] comme graph mais avec l’espacement
[ :punct :] signes de ponctuation
[ :xdigit :] chiffres admis dans un nombre heaxdécimal (càd 0-9a-fA-F)
13-Le comportement avide ou paresseux.
Soit la chaîne suivante : gras normal gras 
On veut reconnaître le texte à l’intérieur de la première balise 
Si on utilise .* cela ne marche pas car on reconnaît tout le texte
entre le premier et le dernier 
Perl propose d’ajouter le symbole ? aux quantificateurs pour les rendre
paresseux, c-à-d. les forcer à reconnaître la chaîne la plus courte.
On écrira donc en perl .* ?
Mais cette possibilité n’est présente que dans perl.

Les métacaractères : Quelques remarques (1/2)
• [[:alnum:]] correspond à [0-9A-Za-z], sauf que :

– [0-9A-Za-z] à dépend des paramètres régionaux C et du codage de
caractères ASCII,
– [[:alnum:]] est plus portable.
• La plupart des méta-caractères perdent leur signification spéciale au sein
des listes.
– Pour inclure un caractère ], mettez-le en premier dans la liste.
– Pour inclure un caractère ^, placez-le n'importe où sauf au début de la
liste.
– Pour inclure un -, placez-le en dernier.

Les métacaractères : Quelques remarques (1/2)
• Deux expressions rationnelles peuvent être juxtaposées l'expression

résultante correspondra à toute chaîne formée par la juxtaposition de deux
sous-chaînes correspondant respectivement aux deux expressions.
• Deux expressions rationnelles peuvent être reliées par l'opérateur infixe | ;

l'expression résultante correspondra à toute chaîne concordant avec l'une
ou l'autre des deux expressions.

Quelques exemples avec la commande grep (grep affiche les lignes correspondant à un motif):
• nombre de lignes en commentaire (commençant par !) dans un code Fortran :
grep "^!" prog.f | wc -l (wc –l affiche le nmbr de sauts de lignes)
• recherche de STOP avec le numéro de la ligne dans tous les sources :
grep -n -i stop *.f* (-n: Ajouter numéro de la ligne. -i: ignore différence maj/min)
• liste de tous les fichiers qui n'ont pas "image" ou "son" dans leur nom :
ls | grep -vE "(
"(image
image||son
son)"
)" (-v: Inverser sélectionner les lignes ne correspondant
pas au motif. –E: Interpréter le MOTIF comme une expression rationnelle étendue)
• liste des lignes contenant "image" ou "son" dans tous les fichiers du répertoire
courant
grep -E "(
"(image
image||son
son)"
)" *
• liste des fichiers contenant JPP dans une arborescence
find . -name "*" -exec grep JPP {} \;  bizarre donne le contenu du fichier et non pas son nom

Langage de commandes et ER
Différence de signification entre expression régulières et Shell
Caractères Signification pour les E.R Signification pour le
spéciaux (Pour grep,find,awk ou vi en partie) Shell
$ fin de ligne idem
^ début de ligne idem
[] un des caractères du crochet idem
- de x à y dans [x-y] idem
. Caractère quelconque .
L’expression régulière précédente est Un caractère
?
optionnelle quelconque
* Répétition >=0 Chaîne quelconque
+ Répétition >0 (pas dans vi) +
| ou (pas dans vi) Pipe
Groupement des
() Groupement des expressions (pas dans vi)
commandes
FIN

Diapos Cours SE 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Diapos Cours SE 1

Transféré par

Droits d'auteur :

Formats disponibles

Systèmes d’Exploitation 1

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 2

• Andrew Tanenbaum, Systèmes d'exploitation, Pearson Education

• J. Archer Harris, Systèmes d'exploitation, Edisciences, 2002,

• Valérie Martinez, Windows 2000 Professionnel – Notions de base,

• Jerry Peek, Grace Todino, John Strang, Introduction à Unix, Edition

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 3

• Gestion des supports de stockage (disques magnétiques

• Langage de commande. (application sous les SE Windows et

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 4

I. Introduction aux systèmes d'exploitation (SE)

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 5

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 6

Un « système d'exploitation » (SE ou OS pour Operating System) est le

Son rôle est de gérer tous les périphériques et de fournir aux

Il contrôle donc toutes les ressources de l'ordinateur et fournit

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 7

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 8

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 9

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 10

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 11

Système d'exploitation : C'est

Reste des logiciels systèmes :

Applications : On y trouve tous les

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 14

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 15

• Le rôle du SE dans ce cas est de gérer de manière équitable,

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 17

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 18

Les ressources à gérer :

Points à détailler dans le module SE-2.

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 19

Liste non-exhaustive de systèmes d’exploitation : (2/3)

• Dérivés d’UNIX (sous différentes déclinaisons : BSD, System V, etc.) dont :

Liste non-exhaustive de systèmes d’exploitation : (3/3)

• Les systèmes d’exploitation grands systèmes (mainframes) :

• Symbian OS est un système d’exploitation pour Smartphones

• Windows (95, 98, 2000, NT, XP...),

Kaella Minix NetBSD OpenBSD OpenDarwin Mandriva

Debian Ubuntu Gentoo Slackware Sentinix ReiserFS

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 23

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 33

Libre et gratuit / Propriétaire et payant

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 34

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 35

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 38

Contraintes de temps réel :

Certains automatismes (particulièrement industriels) nécessitent des

Les contraintes de temps sont de deux types:

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 39

II.2 Générations d'ordinateur

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 40

• Il n'existait pas de système

• Les utilisateurs travaillaient

• Ils étaient d'une très grande

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 41

2ème génération (1955 - 1965) : Les transistors et le traitement par lots

• Les utilisations principales étaient le calcul scientifique et l'ingénierie

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 42

4ème génération (1980 - 1990) : Les ordinateurs personnels

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 44

5ème génération (1990 - ?) : Les ordinateurs personnels portables et de

Ali Larab, Univ-JFC, 08-09 Systèmes d'Exploitation, partie 1 45