TABLE DES MATIERES

Chapitre 1: Généralités sur les systèmes d’exploitation..................5

1. Introduction........................................................................................5
2. Évolution des systèmes d'exploitation...............................................5
2.1. Première génération (1945-1955)..............................................5
2.2. Deuxième génération (1955-1965)............................................6
2.3. Troisième génération (1965-1980).............................................7
3. Les roles du système d’exploitation...................................................8
3.1. Gestion du processeur...............................................................8
3.2. Gestion de la mémoire vive........................................................8
3.3. Gestion des entrées/sorties.......................................................8
3.4. Gestion des droits......................................................................8
3.5. Gestion des fichiers....................................................................8
3.6. Gestion des informations...........................................................8
4. Les types de systemes d’eploitation..................................................9
4.1. Systèmes multitâches................................................................9
4.2. Systèmes multi-processeurs......................................................9
4.3. Systèmes embarqués................................................................9
4.4. Systèmes temps réel................................................................10
5. Composition du systeme d’exploitation...........................................10
5.1. Exemples de systèmes d'exploitation......................................11
6. Structure interne d'un système d'exploitation..................................11
6.1. Structure en couches...............................................................11
6.2. Structure monolithique.............................................................12
6.3. Micro-kernel.............................................................................13
6.4. Le modèle client/serveur..........................................................13
6.5. Machines virtuelles...................................................................14
Chapitre 2: Gestion des processus..................................................15
1. Introduction......................................................................................15

1
 2. Notion de processus........................................................................15
2.1. Définition d’un procesus :.........................................................15
2.2. contexte d’un processus..........................................................15
3. État d’un processus.........................................................................16
3.1. Cycle d’exécution d’un processus............................................16
3.2. Bloc de contrôle d’un processus (PCB)....................................17
4. Ordonnancement des processus.....................................................17
4.1. Le Dispatcheur.........................................................................17
4.2. L’Ordonnanceur.......................................................................18
4.3. Algorithmes d’ordonnancement...............................................18
4.4. Ordonnancement FCFS (first come first Served).....................19
4.5. Ordonnancement SJF (Shortest Job First)...............................20
4.6. Ordonnancement RR (round robin)..........................................20
4.7. Ordonnancement basé sur les priorités...................................21
Chapitre 3: Système de gestion de fichiers.....................................23
1. Introduction......................................................................................23
2. Rôle d’un système de gestion de fichiers........................................23
3. La structure d’un système de fichiers..............................................23
4. Anatomie d’un disque dur................................................................24
5. Formatage et Partitionnement.........................................................25
5.1. Partitionnement........................................................................25
5.2. Formatage................................................................................26
6. Le concept de fichier.......................................................................26
7. La notion de répertoire....................................................................26
8. Methodes d’allocation......................................................................27
8.1. Allocation contiguë...................................................................27
8.2. Allocation chaînée....................................................................28
9. Gestion de l’espace libre :...............................................................30
9.1. Vecteur binaire.........................................................................30

2
 9.2. Liste chaînée............................................................................30
9.3. Liste chaînée avec groupement...............................................30
9.4. Liste avec comptage................................................................31
Chapitre 4: Etude du système d’exploitation MS-DOS...................32
1. Introduction......................................................................................32
2. Structure du DOS............................................................................32
2.1. Noyau.......................................................................................32
2.2. Interprétateur de commande....................................................32
3. Concepts fondamentaux..................................................................32
3.1. Unités et périphériques............................................................32
3.2. Fichiers.....................................................................................33
3.3. 2.3.3. Répertoires.....................................................................33
3.4. Chemin d‘accès........................................................................34
4. Commandes MS-DOS.....................................................................34
4.1. Syntaxe générale d'une commande MS-DOS.........................34
4.2. Obtenir de l'aide sur une commande MS-DOS........................35
5. 4. Commandes de base..................................................................35
5.1. Commandes sur les répertoires...............................................35
5.1.1. Lister le contenu d'un répertoire : dir..................................35
5.1.2. Se déplacer dans les répertoires : cd ou chdir...................35
5.1.3. Créer un répertoire : md ou mkdir.......................................35
5.1.4. Supprimer un répertoire : rd ou rmdir.................................35
5.1.5. Visualisation de l'arborescence : tree.................................36
5.1.6. Commandes sur les fichiers...............................................36
5.1.7. Afficher le contenu d'un fichier : Type.................................36
5.1.8. Copier un fichier : copy.......................................................36
5.1.9. Supprimer un fichier : delete...............................................36
5.1.10. Renommer un fichier : ren...............................................36
5.2. Commandes sur disque...........................................................36

3
 5.2.1. Formatage du disque : format.............................................36
5.2.2. Dupliquer des disques diskcopy.........................................36
5.3. 4.3. Commandes avancées.....................................................36
5.3.1. Copier une arborescence Xcopy........................................36
5.3.2. Supprimer une arborescence : deltree...............................36

4
Chapitre 1: Généralités sur les systèmes d’exploitation
1. Introduction
Un système d'exploitation est un programme qui doit permettre aux utilisateurs
d'utiliser les fonctionnalités d'un ordinateur. Mais il doit aussi aider le programmeur à
développer des logiciels de la façon la plus efficace possible. Un système
d'exploitation est mis en route dès qu'on met en marche l'ordinateur. Dans les
grosses machines, il est toujours en exécution. Le système constitue donc une
interface entre l'utilisateur et la machine physique.
Le système d'exploitation gère et contrôle les composants de l'ordinateur. Il fournit
une base appelée machine virtuelle, sur laquelle seront construits les programmes
d'application et les utilitaires au moyen des services ou appels système. Le but d'un
système d'exploitation consiste donc à développer des applications sans se soucier
des détails de fonctionnement et de gestion du matériel. Ainsi, par exemple, on peut
effectuer la lecture d'un fichier par un simple appel système : read(fd, buf, 255); et
peu importe que le fichier en question se trouve dans un disque magnétique, un DVD
ou un disque en RAM.
2. Évolution des systèmes d'exploitation
L'apparition et l'évolution des systèmes d’exploitation est lié à l'évolution des
ordinateurs.
2.1. Première génération (1945-1955)
Dans les années 40, les premiers « ordinateur » apparaissent, les programmes et les
données sont codés directement en binaire sur des tableaux d'interrupteurs, puis
plus tard (1950) sur des cartes perforées (la présence ou l'absence de trous
correspondent à 0 ou 1), ils sont chargés en mémoire, exécutés et mis au point à
partir d'un pupitre de commande. C'est la même équipe qui conçoit, construit,
programme, administre et maintient la machine.
L'arrivée de l'assembleur facilite l'écriture des programmes, mais l'utilisation des
machines est toujours la même. L'ordinateur ne traite qu'un programme à la fois. Il
faut pour chaque travail (job), en amont insérer les cartes dans un lecteur de cartes,
en aval imprimer les résultats, ce sont des opérations très lentes par rapport au
travail du CPU. Par la suite, c'est un opérateur qui se charge de l'exploitation de la
machine mais le principe reste le même.

5
2.2. Deuxième génération (1955-1965)
Avec l'apparition du transistor (1955 environ), les ordinateurs sont beaucoup plus
fiables, mais coûtent très cher (seules de grandes entreprises privées ou publiques
en possèdent). Ce sont maintenant des équipes différentes qui conçoivent,
construisent, programment, administrent et maintiennent la machine.
Pour chaque travail (job) à réaliser, le programmeur transmet son paquet de cartes
perforées (programmes en assembleur ou en FORTRAN) à l’opérateur qui les
soumet
au compilateur puis à l'ordinateur. Une fois l'exécution terminée, l'opérateur récupère
le résultat sur l'imprimante. Comme les ordinateurs sont très coûteux, on cherche à
réduire les temps d'attente en automatisant les opérations manuelles.
Les gros ordinateurs disposent alors de trois dérouleurs de bande : un pour le
système
d'exploitation, un pour le programme et ses données, un pour les données en sortie.
En annexe, il existe des machines pour transcrire les cartes perforées (apportés par
les programmeurs) sur bandes et des machines pour imprimer les données en sortie
(contenues sur la bande) sur papier. On parle d'impression off-line (l'imprimante n'est
pas directement connectée à l'ordinateur).
Mais le calculateur principal ne fonctionne pas tout le temps : beaucoup de temps
sont encore perdus lors des déplacements des opérateurs qui sont chargés
d'alimenter les machines en cartes, papier, bandes.
On procède au traitement par lots (batch) : plusieurs travaux sont transcrits sur une
même bande d'entrée. Le calculateur principal lit le 1 er job, puis lorsque celui-ci est
terminé, lit le 2nd, etc... jusqu'à la fin de la bande. Un interprète de commande permet
le chargement du programme et des données puis l'exécution du programme, le
moniteur est le programme charger du séquencement des travaux des utilisateurs et
de la continuité des opérations. Le moniteur des années 60 est le précurseur du
système d'exploitation.

Figure 1-1: Traitement par lots

6
2.3. Troisième génération (1965-1980)
Au milieu des années 60, l'apparition des circuits intégrés permet une grande
avancée sur la performance et le coût des ordinateurs. Des familles de machines
partageant le même langage machine, le même système d'exploitation se mettent en
place.
Les travaux sont entièrement traités par l'ordinateur sans passer par des machines
annexes, les jobs sont stockés sur des fichiers disques. Comme l'accès sur un
disque est aléatoire (dans le sens de non-séquentiel) le moniteur peut choisir l'ordre
des travaux.
Dans le moniteur, le planificateur (scheduler) assure cette tâche. Mais les moniteurs
batch exécutent toujours un seul job à la fois, à tout instant un seul programme se
trouve en mémoire et peut seul exploiter le CPU.
On arrive à la multiprogrammation. La mémoire est partagée entre différents
programmes en attente d'une donnée en entrée par exemple peut être suspendu
temporairement au profit d'une tâche. Le but étant d'exploiter au maximum le CPU.
On appelle cette technique le spoule (de SPOOL : Simultaneous Peripheral
Operation On Line). Dans le système d'exploitation, l'allocateur (dispatcher) s'occupe
de la gestion instantanée du CPU en tenant compte de la planification établie par le
scheduler. Il a fallut mettre en place des systèmes de contrôle des accès mémoires,
de protection des données.
On voit apparaître également le temps-partagé (time-sharing) pour des ordinateur
multiutilisateurs (un ordinateur central connecté à plusieurs terminaux).
4) Quatrième génération (1980-Maintenant)
Depuis les années 80, on assiste au développement des ordinateurs personnels, à
l'amélioration constante du taux d'intégration des circuits (LSI : Large Scale
Integration,
VLSI, Very LSI), à la baisse des coûts et au développement des réseaux de
communications, au développement des réseaux locaux, à l'explosion d'internet.
Les interfaces Homme/Machine sont toujours améliorées.

7
3. Les roles du système d’exploitation
Les rôles du système d'exploitation sont divers
3.1. Gestion du processeur
Le système d'exploitation est chargé de gérer l'allocation du processeur entre les
différents programmes grâce à un algorithme d'ordonnancement. Le type
d'ordonnanceur est totalement dépendant du système d'exploitation, en fonction de
l'objectif visé.
3.2. Gestion de la mémoire vive
Le système d'exploitation est chargé de gérer l'espace mémoire alloué à chaque
application et, le cas échéant, à chaque usager. En cas d'insuffisance de mémoire
physique, le système d'exploitation peut créer une zone mémoire sur le disque dur,
appelée «mémoire virtuelle». La mémoire virtuelle permet de faire fonctionner des
applications nécessitant plus de mémoire qu'il n'y a de mémoire vive disponible sur le
système. En contrepartie cette mémoire est beaucoup plus lente.
3.3. Gestion des entrées/sorties
Le système d'exploitation permet d'unifier et de contrôler l'accès des programmes
aux ressources matérielles par l'intermédiaire des pilotes (appelés également
gestionnaires de périphériques ou gestionnaires d'entrée/sortie).
Gestion de l'exécution des applications
Le système d'exploitation est chargé de la bonne exécution des applications en leur
affectant les ressources nécessaires à leur bon fonctionnement. Il permet à ce titre
de «tuer» une application ne répondant plus correctement.
3.4. Gestion des droits
Le système d'exploitation est chargé de la sécurité liée à l'exécution des programmes
en garantissant que les ressources ne sont utilisées que par les programmes et
utilisateurs possédant les droits adéquats.
3.5. Gestion des fichiers
Le système d'exploitation gère la lecture et l'écriture dans le système de fichiers et
les droits d'accès aux fichiers par les utilisateurs et les applications.
3.6. Gestion des informations
Le système d'exploitation fournit un certain nombre d'indicateurs permettant de
diagnostiquer le bon fonctionnement de la machine.

8
4. Les types de systemes d’eploitation
4.1. Systèmes multitâches
Un système d'exploitation est dit «multi-tâche» (en anglais multithreaded) lorsque
plusieurs «tâches» (également appelées processus) peuvent être exécutées
simultanément.
Les applications sont composées en séquence d'instructions que l'on appelle
«processus légers» (en anglais «threads»). Ces threads seront tour à tour actifs, en
attente, suspendus ou détruits, suivant la priorité qui leur est associée ou bien
exécutés séquentiellement.
Un système est dit préemptif lorsqu'il possède un ordonnanceur (aussi appelé
planificateur), qui répartit, selon des critères de priorité, le temps machine entre les
différents processus qui en font la demande.
Le système est dit à temps partagé lorsqu'un quota de temps est alloué à chaque
processus par l'ordonnanceur. C'est notamment le cas des systèmes multi-
utilisateurs qui permettent à plusieurs utilisateurs d'utiliser simultanément sur une
même machine des applications différentes ou bien similaires : le système est alors
dit «système transactionnel». Pour ce faire, le système alloue à chaque utilisateur
une tranche de temps.
4.2. Systèmes multi-processeurs
Le multiprocessing est une technique consistant à faire fonctionner plusieurs
processeurs en parallèle afin d'obtenir une puissance de calcul plus importante que
celle obtenue avec un processeur haut de gamme ou bien afin d'augmenter la
disponibilité du système (en cas de panne d'un processeur).
On appelle SMP (Symmetric Multiprocessing ou Symmetric Multiprocessor) une
architecture dans laquelle tous les processeurs accèdent à un espace mémoire
partagé.
Un système multiprocesseur doit donc être capable de gérer le partage de la
mémoire entre plusieurs processeurs mais également de distribuer la charge de
travail.
4.3. Systèmes embarqués
Les systèmes embarqués sont des systèmes d'exploitation prévus pour fonctionner
sur des machines de petite taille, telles que des PDA (personal digital assistants ou
en français assistants numériques personnels) ou des appareils électroniques

9
autonomes (sondes spatiales, robot, ordinateur de bord de véhicule, etc.), possédant
une autonomie réduite. Ainsi, une caractéristique essentielle des systèmes
embarqués est leur gestion avancée de l'énergie et leur capacité à fonctionner avec
des ressources limitées.
Les principaux systèmes embarqués «grand public» pour assistants numériques
personnels sont :
 PalmOS
 Windows CE / Windows Mobile / Window Smartphone
4.4. Systèmes temps réel
Les systèmes temps réel (real time systems), essentiellement utilisés dans
l'industrie, sont des systèmes dont l'objectif est de fonctionner dans un
environnement contraint temporellement.
Un système temps réel doit ainsi fonctionner de manière fiable selon des contraintes
temporelles spécifiques, c'est-à-dire qu'il doit être capable de délivrer un traitement
correct des informations reçues à des intervalles de temps bien définis (réguliers ou
non).
Voici quelques exemples de systèmes d'exploitation temps réel :
 OS-9 ;
 RTLinux (RealTime Linux) ;
 QNX ;
 VxWorks.
5. Composition du systeme d’exploitation
Le système d’exploitation est composé d’un ensemble de logiciels permettant de
gérer les interactions avec le matériel. Parmi cet ensemble de logiciels on distingue
généralement les éléments suivants :
 Le noyau (en anglais kernel) représentant les fonctions fondamentales du
système d’exploitation telles que la gestion de la mémoire, des processus, des
fichiers, des entrées-sorties principales, et des fonctionnalités de
communication.
 L’interpréteur de commande (en anglais shell, traduisez «coquille» par
opposition au noyau) permettant la communication avec le système
d’exploitation par l’intermédiaire d’un langage de commandes, afin de
permettre à l’utilisateur de piloter les périphériques en ignorant tout des

10
 caractéristiques du matériel qu’il utilise, de la gestion des adresses physiques,
etc.
 Le système de fichiers (en anglais «file system», noté FS), permettant
d’enregistrer les fichiers dans une arborescence.
5.1. Exemples de systèmes d'exploitation
On distingue plusieurs types de systèmes d'exploitation, selon qu'ils sont capables
de gérer simultanément des informations d'une longueur de 16 bits, 32 bits, 64 bits
ou plus.

6. Structure interne d'un système d'exploitation

6.1. Structure en couches
Le système d'exploitation est structuré en couches. Chaque couche utilise les
fonctions des couches inférieures. La principale difficulté est la définition des
différentes couches. Par exemple, on peut l'organiser en cinq couches, comme
montré sur la figure:
 Au plus bas niveau on trouve le noyau, l'interface entre le matériel et le
logiciel. Il se charge, en utilisant les fonctions fournies par le matériel, de gérer
la UCT, les interruptions et les processus (la communication et la
synchronisation). Il doit entièrement résider en mémoire.
 Au second niveau, on trouve le gestionnaire de la mémoire qui se charge du
partage de la mémoire entre les processus en attente d'exécution.
 Au troisième niveau, on a le module de gestion des entrées/sorties qui se
charge de gérer tous les périphériques (clavier, écran, disques, imprimantes,
etc.).

11
  Au quatrième niveau, on trouve le gestionnaire de fichiers qui se charge de la
gestion de l'espace du disque, de la manipulation des fichiers tout en assurant
l'intégrité des données, la protection des fichiers, etc.
 Au cinquième niveau, on a le module d'allocation de ressources qui se charge
d'assurer une bonne utilisation des ressources ; de comptabiliser et de fournir
des statistiques sur l'exploitation des ressources principales ; de créer de
nouveaux processus et leur attribuer un niveau de priorité : de permettre à
chaque processus existant dans le système d'obtenir les ressources
nécessaires dans des limites de temps raisonnables ; d'exclure mutuellement
les processus qui demandent une ressource non partageable et d'éviter les
situations de blocage.

Figure 1-2: Structure en couches

6.2. Structure monolithique

Les systèmes d'exploitation sous une structure monolithique sont un ensemble de
procédures de —presque— le même niveau : une procédure principale qui appelle la
procédure de service requise, des procédures de service qui exécutent les appels
système et un ensemble de procédures utilitaires qui assistent les procédures de
service, par exemple la recherche de données des programmes utilisateur. Unix et
Linux sont des exemples de systèmes monolithiques.

Figure 1-3: Structure monolithique

12
6.3. Micro-kernel
Une architecture plus moderne que celle monolitique est l'architecture micro-kernel
(voir la figure …) utilisée en Minix et NT. L'attribut principal qui distingue les micro-
kernels des kernels monolitiques est l'implantation de leurs architectures respectives
en mode superviseur (kernel mode) et en mode usager (user mode). L'architecture
monolitique met en oeuvre tous les services du Système d'exploitation (controleurs
de dispositifs, mémoire virtuelle, système de fichiers, réseaux, etc) dans le domaine
du mode superviseur de l'UCT.
Par contre, l'architecture micro-kernel fait une division entre les services du Système
d'exploitation, en les divisant en « haut-niveau » implantés dans le domaine de
l'utilisateur et « bas-niveau » implantés dans l'espace du mode superviseur.

Figure 1-4: L'architecture Micro-kernel

6.4. Le modèle client/serveur

Dans le modèle client/serveur Le système d'exploitation est composé d'un noyau et
d'un ensemble de serveurs. Le noyau gère la communication entre les clients et les
serveurs. Les clients sont les demandeurs de services. Par exemple, pour demander
un service, comme la lecture d'un bloc d'un fichier, un processus utilisateur (aussi
appelé processus client) envoie une requête à un processus serveur qui effectue le
travail et renvoie une réponse. Les serveurs s'exécutent en mode utilisateur. Ils ne
peuvent donc pas accéder directement au matériel. Par conséquent, une erreur ou
un bogue dans le serveur de fichiers, par exemple, n'affectera pas, en général,
l'ensemble de la machine. Les dégâts se limitent au serveur.

13
6.5. Machines virtuelles
Le cœur du système se charge de la multiprogrammation en fournissant à la couche
au dessus plusieurs machines virtuelles. Des systèmes d'exploitation différents
peuvent tourner au dessus d'une machine virtuelle.
Exemples de machines virtuelles :
 IBM VM : offre à chaque usager sa propre machine virtuelle monotâche. Les
machines virtuelles étaient planifiées avec du temps partagé.
 Java : les programmes compilés en Java tournent sur une machine virtuelle
(JVM).
 VMWare7: sur PC, exécute en même temps des sessions Windows, Linux,
OS/2, etc.

14
Chapitre 2: Gestion des processus
1. Introduction
Dans un système multitâche, la ressource la plus importante d’une machine est le
processeur. Cette ressource est allouée à un et un processus sélectionné parmi un
ensemble des processus éligibles. Par conséquent, il convient à bien gérer ce
dernier afin de le rendre plus productif. En effet, un système d’exploitation dispose
d’un module qui s’occupe de l’allocation du processeur en l’occurrence le
Dispatcheur. Ce module est exécuté chaque fois qu’un processus se termine ou se
bloque dans le but de réquisitionner le processeur pour un autre processus. En plus
de ce Dispatcheur, un système d’exploitation dispose d’un autre module permettant
ainsi la mise en ordre des processus qui demandent le processeur.
2. Notion de processus
2.1. Définition d’un procesus :
Un processus représente l’exécution d’un programme comportant des instructions et
des données. C’est une entité dynamique crée à un instant donné et qui disparaît, en
général, au bout d’un temps fini. Chaque exécution d’un même programme donne
lieu à un nouveau processus.
2.2. contexte d’un processus
Le contexte d’un processus (ou vecteur d’état) est l’ensemble des informations
nécessaires pour que le processus puisse reprendre son exécution après une
interruption. (Il termine l’exécution du programme et non pas commencer dés le
début). Il comprend donc :
 Le mot d’état et les registres généraux (le compteur ordinal, etc.)
 Un espace de travail (segments, procédures, données statiques et
dynamiques, pile d’exécution,…)
 Un ensemble d’attributs attachés au processus et spécifiant diverses
propriétés (nom, priorité, droits,…) ou encore des informations de gestion
(état, lien de chaînage,…)
On peut classer ces informations en deux classes :
 Des informations utilisées explicitement par le processus (variables,
procédures,…)
 Des informations utilisées par le système pour gérer l’attribution des
ressources

15
3. État d’un processus
Pour qu’un processus puisse s’exécuter, il a besoin de procédures et de données, de
mémoire destinée à les contenir, de l’unité centrale, éventuellement de fichiers et de
périphériques. Nous appelons toutes ces entités des ressources.
Comme les ressources du système sont en nombre limité, il n’est pas possible
d’attribuer à chaque processus, dès sa création toutes les ressources dont il aura
besoin. On peut aboutir à la situation ou un processus n’est pas en possession des
ressources indisponibles à l’exécution de l’instruction suivante. On dit que le
processus est dans l’état bloqué. Par opposition, un processus qui dispose de toutes
les ressources dont il a besoin pour évoluer est dit à l’état actif (ou élu ou en
exécution).
Un processus est à l’état éligible (ou prêt) s’il est en attente de l’unité centrale
uniquement.

Figure 2-5: Diagramme d’états d’un processus

Etant une entité nécessaire à l’exécution d’un processus, une ressource peut être
matérielle (unité centrale, mémoire centrale, périphériques,…) ou logicielle (variable
partagée, fichier,…)
Remarque :
A chaque type de ressource est associé dans le système une procédure d’allocation
et à chaque ressource correspond un descripteur. Le descripteur minimal se réduit à
un bit représentant l’état libre ou alloué de la ressource.
3.1. Cycle d’exécution d’un processus
L’exécution d’un processus peut être vue comme une séquence de phases. Chaque
phase comprend deux cycles : un cycle d’exécution (ou calcul) réalisé par le
processeur et un cycle d’entrée sortie assuré par le canal. La dernière phase de tout
processus doit comprendre obligatoirement un seul cycle dans lequel sera exécuté la
requête informant le système d’exploitation sur la terminaison du processus. Cet

16
appel permet au système de restituer les ressources utilisées par le processus qui
vient de terminer.

Figure 2-6:Cycle d’exécution d’un processus

3.2. Bloc de contrôle d’un processus (PCB)

Lorsqu’un processus est temporairement suspendu, il faut qu’il puisse retrouver l’état
où il se trouvait au moment de suspension, il faut que toutes les informations dont il a
besoin soient sauvegardées pendant sa mise en attente.
Notons que le contexte d’un processus dépend du système, mais dans tous les cas
c’est un bloc de contrôle de processus (BCP) qui contient toute information
nécessaire à la reprise d’un processus interrompu : Etat du processus (prêt,
suspendu, ..), quantité de mémoire, temps CPU (utilisé, restant), priorité, etc.
Les BCP sont rangés dans une table (table des processus) qui se trouve dans
l’espace mémoire du système.

Figure 2-7:Bloc de contrôle de processus (PCB)

4. Ordonnancement des processus

Chaque fois, que le processeur devient inactif, le système d’exploitation doit
sélectionner un processus de la file d’attente des processus prêts, et lui passe le
contrôle. D’une manière plus concrète, cette tâche est prise en charge par deux
routines système en l’occurrence le Dispatcheur et le Scheduleur
(Ordonnanceur).

17
4.1. Le Dispatcheur
Il s’occupe de l’allocation du processeur à un processus sélectionné par
l’Ordonnanceur du
processeur. Une fois allouer, le processeur doit réaliser les tâches suivantes :
 Commutation de contexte : sauvegarder le contexte du processus qui doit
relâcher le processeur et charger le contexte de celui qui aura le prochain
cycle processeur
 Commutation du mode d’exécution : basculer du mode Maître (mode
d’exécution du dispatcheur) en mode utilisateur (mode d’exécution du
processeur utilisateur)
 Branchement : se brancher au bon emplacement dans le processus
utilisateur pour le faire démarrer.
4.2. L’Ordonnanceur
Certains systèmes d’exploitation utilisent une technique d’ordonnancement à deux
niveaux qui intègre deux types d’Ordonnanceurs :
Ordonnanceur du processeur : c’est un Ordonnanceur court terme opère sur une
ensemble du processus présents en mémoire. Il s’occupe de la sélection du
processus qui aura le prochain cycle processeur, à partir de la file d’attente des
processus prêts.
Ordonnanceur de travail : ou Ordonnanceur long terme, utilisé en cas
d’insuffisance de mémoire, son rôle est de sélectionné le sous ensemble de
processus stockés sur un disque et qui vont être chargés en mémoire. En suite, il
retire périodiquement de la mémoire les processus qui sont restés assez longtemps
et les remplace par des processus qui sont sur le disque depuis trop de temps.
Nous distinguons plusieurs algorithmes d’ordonnancement, les plus répandus sont :
 Ordonnancement Premier Arrivé Premier Servi
 Ordonnancement du plus court d’abord
 Ordonnancement circulaire : Tourniquet
 Ordonnancement circulaire à plusieurs niveaux
 Ordonnancement avec priorité
4.3. Algorithmes d’ordonnancement
L'ordonnancement est la partie du système d'exploitation qui détermine dans quel
ordre les processus prêts à s'exécuter (présents dans la file des prêts) seront élus.
Ses objectifs sont :
18
  Assurer le plein usage du CPU (agir en sorte qu’il soit le moins souvent
possible inactifs);
 Réduire le temps d'attente des utilisateurs.
 Assurer l'équité entre les utilisateurs.
Un algorithme d’ordonnancement permet d’optimiser une des grandeurs temporelles
suivantes :
 Le temps de réponse moyen décrit la moyenne des dates de fin d’exécution :
n
TRM=∑ TRi /n , avec TRi=date fin – date arrivée.
i=1

 Le temps d’attente moyen est la moyenne des délais d’attente pour

commencer une exécution :
n
ATM=∑ TAi /n , avec TAi=TRi – temps d’exécution.
i=1

Les algorithmes d’ordonnancement se distinguent les uns des autres du fait que
certains autorisent la réquisition de l’unité centrale alors que d’autres l’interdisent. La
réquisition est la possibilité de retirer à n’importe quel instant le processeur à un
processus même si ce dernier est en cours d’exécution.
Remarque :
Pour représenter schématiquement l’évolution dans le temps des processus, on
recourt habituellement à des diagrammes de Gantt.
4.4. Ordonnancement FCFS (first come first Served)
Dans cet algorithme, connu sous le nom FIFO (First In, First Out), les processus sont
rangés dans la file d’attente des processus prêts selon leur ordre d’arriver. Les règles
régissant cet ordonnancement sont :
1. Quand un processus est prêt à s’exécuter, il est mis en queue de la file
d’attente des processus prêts.
2. Quand le processeur devient libre, il est alloué au processus se trouvant en
tête de file d’attente des processus prêts.
3. Le processus élu relâche le processeur s’il se termine ou s’il demande une
entrée sortie

Figure 2-8: Ordonnancement FIFO

19
20
Caractéristiques de l’Ordonnanceur
 Ordonnanceur sans réquisition
 Ordonnanceur non adapté à un système temps partagé car dans un système
pareil, chaque utilisateur obtienne le processeur à des intervalles réguliers.
4.5. Ordonnancement SJF (Shortest Job First)
SJF choisit de façon prioritaire les processus ayant le plus court temps d’exécution
sans réellement tenir compte de leur date d’arrivée.
Dans cet algorithme les différents processus sont rangés dans la file d'attente des
processus prêts selon un ordre croissant de leur temps d'exécution (cycle de calcul).
Les règles régissant cet ordonnancement sont :
1. Quand un processus est prêt à s’exécuter, il est inséré dans la file d’attente
des processus prêts à sa position approprie.
2. Quand le processeur devient libre, il est assigné au processus se trouvant en
tête de la file d’attente des processus prêts (ce processus possède le plus
petit cycle processeur.). Si deux processus ont la même longueur de cycle, on
applique dans ce cas l’algorithme FCFS.
3. Si le système ne met pas en oeuvre la réquisition, le processus élu relâche le
processeur s’il se termine ou s’il demande une entrée sortie. Dans le cas
contraire, le processus élu perd le processeur également. Quand un
processus ayant un cycle d’exécution inférieur au temps processeur restant
du processus élu, vient d’entrer dans la file d’attente des prêts. Le processus
élu dans ce cas sera mis dans la file d’attente des éligibles, et le processeur
est alloué au processus qui vient d’entrer.

Figure 2-9: Ordonnancement SJF

Caractéristiques de l’Ordonnanceur
 Cet Ordonnanceur peut être avec ou sans réquisition
 Implémentation difficile, car il n’existe aucune manière pour connaître le cycle
suivant du processeur.

21
4.6. Ordonnancement RR (round robin)
Dans cet algorithme les processus sont rangés dans une file d'attente des éligibles,
le
processeur est alloué successivement aux différents processus pour une tranche de
temps fixe Q appelé Quantum.
Cet Ordonnancement est régit par les règles suivantes :
1. Un processus qui rentre dans l’état éligible est mis en queue de la file
d'attente des prêts.
2. Si un processus élu se termine ou se bloque avant de consommer son
quantum de temps, le processeur est immédiatement alloué au prochain
processus se trouvant en tête de la file d'attente des prêts.
3. Si le processus élu continue de s'exécuter au bout de son quantum, dans ce
cas le processus sera interrompu et mis en queue de la file d'attente des prêts
et le processeur est réquisitionné pour être réalloué au prochain processus en
tête de cette même file d’attente.
Caractéristiques de l’Ordonnanceur
 Avec réquisition
 Adapté aux systèmes temps partagé.
 La stratégie du tourniquet garantit que tous processus est servis au bout d’un
temps fini. Son avantage est d’éviter la famine. On dit qu'un processus est en
famine lorsqu'il est prêt à être exécuté et se voit refuser l'accès à une
ressource (ici le processeur) pendant un temps indéterminé
 L’efficacité de cet ordonnanceur dépend principalement de la valeur du
quantum Q:
o Le choix d'un Q assez petit augmente le nombre de commutation.
o Le choix d'un Q assez grand augmente le temps de réponse du
système
4.7. Ordonnancement basé sur les priorités
Dans cet algorithme, les processus sont rangés dans la file d’attente des processus
prêt par ordre décroissant de priorité. L’ordonnancement dans ce cas est régit par les
règles suivantes :
1. Quand un processus est admis par le système, il est inséré dans la file
d’attente des processus prêts à sa position approprie (dépend de la valeur de
priorité).
22
 2. Quand le processeur devient libre, il est alloué au processus se trouvant en
tête de file d’attente des processus prêts (le plus prioritaire).
3. Un processus élu relâche le processeur s’il se termine ou se bloque (E/S ou
autre).
Remarque :
Si le système met en oeuvre la réquisition, quand un processus de priorité
supérieure à celle du processus élu entre dans l’état prêt ; le processus élu sera mis
dans la file d’attente des éligibles à la position approprie, et le processeur est alloué
au processus qui vient d’entrer.
Caractéristiques de l’Ordonnanceur
Les principales caractéristiques sont :
 Peut être avec ou sans réquisition
 Un processus de priorité basse risque de ne pas être servi (problème de
famine) d’où la nécessité d’ajuster périodiquement les priorités des processus
prêts. L’ajustement consiste à incrémenter graduellement la priorité des
processus de la file d’attente des éligibles (par exemple à chaque 15 mn on
incrémente d’une unité la priorité des processus prêts).

23
Chapitre 3: Système de gestion de fichiers
1. Introduction
Le système de gestion de fichiers (SGF) est le composant d’un système
d’exploitation
responsable de la gestion (stockage, lecture, écriture, etc.) des données des
utilisateurs sous forme de fichier enregistré sur les supports de stockage de manière
permanente (généralement sur le disque dur).
2. Rôle d’un système de gestion de fichiers
Le système de gestion de fichiers assure les fonctionnalités suivantes :
 Le stockage des données des utilisateurs sous forme de fichiers sur les
supports de stockage (disque dur, etc.).
 La mise en oeuvre d’un certain nombre de manipulations telles que la
structuration de l’ensemble des données, l’insertion d’éléments, etc.
 La gestion de l'espace libre
 La gestion des accès simultanés aux données
3. La structure d’un système de fichiers
Un fichier est une unité de stockage logique mise à la disposition des utilisateurs
pour l'enregistrement de leurs données. Le SGF établit de façon transparente aux
utilisateurs la correspondance entre le fichier et les bits enregistrés dans le support
de stockage.
Dans un fichier on peut écrire des images, du texte, des instructions d'un
programme, etc. Ces données sont structurées logiquement sous forme de fichier et
physiquement sous forme de bits.
Afin de différencier les fichiers, chacun possède un ensemble d'attributs comme le
nom, l'extension, la date de création, la dernière date de modification, la taille.
Un répertoire est une unité logique qui permet de stocker plusieurs fichiers. Il ne
contient pas directement des données, il contient des fichiers et ce sont les fichiers
qui contiennent des données.
Les répertoires sont, eux aussi, des fichiers, constitués des noms et des références
de tous les fichiers qu’ils contiennent. Cette structure permet alors de construire
l’arborescence du système. Pour désigner un fichier quelconque, il suffit de spécifier
l’enchaînement des répertoires nécessaires à son accès, à partir de la racine. Dans

24
le système Unix, les répertoires de cet enchaînement sont séparés par une oblique :
« / ». Dans le système DOS, par une contre-oblique : « \ ».
Dans le système Unix, chaque répertoire contient aussi sa propre référence, ainsi
que celle du répertoire immédiatement supérieur. « . » désigne le répertoire courant,
et « .. », le répertoire supérieur. L’inclusion de ces deux références permet de
désigner un fichier quelconque, relativement au répertoire courant.
Les systèmes d’exploitation modernes adoptent une structure hiérarchique des
fichiers. Chaque fichier appartient à un groupe d’autres fichiers et chaque groupe
appartient lui-même à un groupe d’ordre supérieur. On appelle ces groupes, des
répertoires ou des dossiers, suivant les terminologies.
Le schéma de la structure générale d’un système de fichiers prend l’aspect d’un
arbre, formé au départ d’un répertoire « racine » recouvrant des périphériques et
notamment un ou plusieurs disques. Dans chacun des répertoires on pourra trouver
d’autres répertoires ainsi que des fichiers de données ordinaires.
4. Anatomie d’un disque dur
Un disque dur possède la forme suivante:

Figure 3-10: Structure d’un disque dur

Un disque dur est constitué des composants suivants:

Les plateaux : un plateau est le support destiné à accueillir les données. Les
plateaux ont une forme circulaire et ils sont empilés les unes au-dessus des autres.
Le diamètre d'un plateau indique la taille d'un disque (3 pouces et demi ou 5 pouces
et ¼) généralement le nombre des plateaux n'excède pas une dizaine.

25
Les têtes de lecture-écriture : sur chaque plateau, on peut écrire les données sur
les deux faces. Il faut ainsi associer une tête à chaque face. Les têtes sont reliées à
un bras qui permet de les déplacer simultanément. Le bras se déplace de
l'extérieur vers le centre et vice-versa. Chaque tête est collée à la face du plateau
lorsque le disque est au repos. Quand la machine est mise sous tension, le disque
entreprend un mouvement de rotation permanent et il se crée une dépression sous
chaque tête l'obligeant à s'éloigner du plateau de qqs millimètres.
Un moteur rotatif : il permet de faire tourner les plateaux à une vitesse de 7200
tr/min et même plus.
Des positionneurs de tête : ils permettent de positionner la tête de lecture/écriture à
l'emplacement voulu. Chaque face du plateau est constituée d'un ensemble de pistes
La surface de chaque plateau est divisée en pistes concentriques numérotées à
partir de 0 en commençant à partir de la piste la plus à l'extérieur. Chaque piste est
divisée en secteurs.
5. Formatage et Partitionnement
5.1. Partitionnement
Le partitionnement consiste à « cloisonner » le disque. Il permet la cohabitation de
plusieurs systèmes d’exploitation sur le même disque (il permet d’isoler certaines
parties du système). L’information sur le partitionnement d’un disque est stockée
dans son premier secteur (secteur zéro), le MBR (Master Boot Record).
Deux types de partitionnement :
 Primaire : On peut créer jusqu’à 4 partitions primaires sur un même disque.
 Etendue est un moyen de diviser une partition primaire en sous-partitions (une
ou plusieurs partitions logiques qui se comportent comme les partitions
primaires, mais sont créées différemment (pas de secteurs de démarrage))
Dans un même disque, on peut avoir un ensemble de partitions (multi-partition),
contenant chacune un système de fichier (par exemple DOS et UNIX)

Figure 3-11:Multipartition d’un disque

26
5.2. Formatage
Avant qu’un système de fichiers puisse créer et gérer des fichiers sur une unité de
stockage, son unité doit être formatée selon les spécificités du système de fichiers.
Le formatage inspecte les secteurs, efface les données et crée le répertoire racine
du système de fichiers. Il crée également un superbloc pour stocker les informations
nécessaires à assurer l’intégrité du système de fichiers.

Figure 3-12:Organisation du système de fichier

Un superbloc contient notamment : L’identifiant du système de fichiers (C:, D : ..), Le

nombre de blocs dans le système de fichiers, La liste des blocs libres, l’emplacement
du répertoire racine, la date et l’heure de la dernière modification du système de
fichiers, une information indiquant s’il faut tester l’intégrité du système de fichiers.
6. Le concept de fichier
Un fichier est l’unité de stockage logique mise à la disposition des utilisateurs pour
l’enregistrement de leurs données : c’est l’unité d’allocation. Le SE établi la
correspondance entre le fichier et le système binaire utilisé lors du stockage de
manière transparente pour les utilisateurs. Dans un fichier on peut écrire du texte,
des images, des calculs, des programmes, etc.
Les fichiers sont généralement créés par les utilisateurs. Toutefois certains fichiers
sont générés par les systèmes ou certains outils tels que les compilateurs.
Afin de différencier les fichiers entre eux, chaque fichier a un ensemble d’attributs qui
le décrivent. Parmi ceux-ci on retrouve : le nom, l’extension, la date et l’heur de sa
création ou de sa dernière modification, la taille, la protection. Certains de ces
attributs sont indiqués par l’utilisateur, d’autres sont complétés par le système
d’exploitation.
7. La notion de répertoire
Un répertoire est une entité crée pour l’organisation des fichiers. En effet on peut
enregistrer des milliers, voir des millions de fichiers sur un disque dur et il devient
alors impossible de s’y retrouver. Avec la multitude de fichiers créés, le système
27
d’exploitation a besoin d’une organisation afin de structurer ces fichiers et de pouvoir
y accéder rapidement. Cette organisation est réalisée au moyen de répertoires
également appelés catalogues ou directory.
Un répertoire est lui-même un fichier puisqu’il est stocké sur le disque et est destiné
à contenir des fichiers.
Du point de vue SGF, un répertoire est un fichier qui dispose d’une structure
logique : il est considéré comme un tableau qui contient une entrée par fichier.
L’entrée du répertoire permet d’associer au nom du fichier (nom externe au SGF) les
informations stockées en interne par le SGF. Chaque entrée peut contenir des
informations sur le fichier (attributs du fichier) ou faire référence à (pointer sur) des
structures qui contiennent ces informations.
8. Methodes d’allocation
L’accès direct aux disques permet une grande souplesse dans l’implémentation des
fichiers. Le problème principal consiste à savoir comment allouer de l’espace à ces
fichiers.
On distingue trois manières d’organiser les blocs d’un fichier : contiguë, chaînée et
indexée.
8.1. Allocation contiguë
La méthode de l’allocation contiguë demande que chaque fichier occupe un
ensemble de blocs contigus sur le disque. Les adresses disques définissent un ordre
linéaire sur le disque.
L’allocation contiguë d’un fichier est définie par l’adresse disque et la longueur , en
unités blocs, du premier bloc. Si le fichier est d’une longueur de n blocs et démarre à
l’emplacement b, il occupe donc les blocs b, b+1, b+2, …, b+n-1. L’entrée du
répertoire pour chaque fichier indique l’adresse du bloc de début et la longueur de la
zone allouée au fichier.

28
 Figure 3-13: Allocation contiguë

Avantage : Déplacement minimal du bras du disque.

Inconvénient : Fragmentation.
8.2. Allocation chaînée
L’allocation chaînée résout les problèmes de l’allocation contiguë. Avec l’allocation
chaînée, chaque fichier est une liste chaînée de blocs de disques. Les blocs de
disque peuvent être dispersés n’importe où sur le disque. Le répertoire contient un
pointeur sur le premier et le dernier bloc du fichier.
Exemple : Le fichier abc occupe cinq (05) blocs : b9, b16, b1, b10, b25.

Figure 3-14: Allocation chaînée

Avantage : réduire la fragmentation.

Inconvénient : Le mouvement du bras du disque peut être important.
d’allocation de fichiers (File Allocation Table : FAT) qui a été utilisée dans les
systèmes d’exploitation DOS et OS2. Celle-ci possède une entrée pour chaque bloc
disque et elle est indexée par numéro de bloc. On utilise la FAT comme s’il s’agissait
d’une liste chaînée. L’entrée du répertoire contient le numéro de bloc du premier bloc
du fichier. L’entrée de la table indexée par ce numéro de bloc possède donc le
numéro de bloc suivant dans le fichier. Cette chaîne continue jusqu’au dernier bloc,
possédant une valeur spéciale de fin de fichier comme l’entrée de la table.
29
Figure 3-15: Table d’allocation de fichiers

30
Allocation indexée
L’allocation chaînée résout les problèmes de fragmentation, cependant elle ne peut
pas supporter l’accès direct de façon efficace, car les pointeurs vers les blocs ainsi
que les blocs eux-mêmes sont dispersés dans tout le disque et ils doivent être
récupérés dans l’ordre. L’allocation indexée résout ce problème en rangeant tous les
pointeurs dans un seul emplacement : le bloc d’index.
Chaque fichier possède son propre bloc index, qui est un tableau d’adresse de blocs
disque. La ième entrée dans le bloc index pointe sur le ième bloc du fichier. Le
répertoire contient l’adresse du bloc index. Pour lire le ième bloc, on utilise le
pointeur de la ième entrée du bloc index afin de trouver et de lire le bloc désiré. Ce
schéma est semblable à celui de la pagination.

Figure 3-16: Allocation indexée de l’espace disque.

Quand on crée le fichier, tous les pointeurs du bloc index sont fixés à nul. Quand le
ième bloc est écrit pour la première fois, on obtient un bloc du gestionnaire de
l’espace libre et son adresse est placée dans la ième entrée du bloc index.
Inconvénient : L’espace occupé par le bloc d’index.
Chaque fichier doit posséder un bloc d’index dont il est souhaitable qu’il soit le plus
petit possible. Cependant s’il est trop petit, il ne pourra pas ranger des pointeurs en
nombre suffisant pour un grand fichier et il faudrait un mécanisme pour traiter ce
détail.
Pour cela plusieurs solutions ont été proposées, dont :
 Schéma chaîné : Pour des fichiers importants, on peut chaîner les blocs
d’index entre eux.
 Index multiniveaux : Cette solution consiste à utiliser un bloc d’index séparé
pointant sur des blocs d’index.

31
9. Gestion de l’espace libre :
Comme il n’existe qu’une quantité limitée d’espace disque, il est nécessaire de
réutiliser l’espace des fichiers détruits pour les nouveaux fichiers. Pour cela, le
système doit maintenir une liste d’espace libre. Cette liste mémorise tous les blocs
libres du disque.
Pour créer un fichier, on recherche dans la liste d’espace libre la quantité requise
d’espace et on alloue cet espace au nouveau fichier. Cet espace est ensuite
supprimé de la liste. Quand un fichier est détruit, son espace disque est ajouté à la
liste d’espace libre. Mais comment implémenter la liste d’espace libre ?. Plusieurs
méthodes existent dont : le vecteur binaire et la liste chaînée.
9.1. Vecteur binaire
On implémente souvent la liste d’espace libre comme un tableau binaire. Chaque
bloc est représenté par un bit. Si le bloc est libre, le bit est à 1, s’il est alloué le bit est
à 0. Par exemple, si dans un disque les blocs 2, 3, 5, 8 et 9 sont libres, et les autres
alloués, le vecteur représentant l’espace libre est alors :

Avantage : Il est relativement facile de trouver le premier bloc libre ou les n blocs
libres consécutifs.
Inconvénient : la gestion du vecteur.
9.2. Liste chaînée
Il existe une autre approche pour représenter l’espace libre. Elle consiste à chaîner
les blocs disques libres, en maintenant un pointeur sur le premier bloc libre dans un
emplacement spécial du disque et en le mettant en mémoire cache. Exemple :

Avantage : La liste ne représente que les blocs libres.

Inconvénient : Parcours de la liste.
9.3. Liste chaînée avec groupement
Il existe une autre variante de la méthode de la liste chaînée : on stocke les adresses
des n blocs libres dans le premier bloc libre. Les n-1 premiers blocs sont réellement
libres. Le dernier blocs contient les adresses de n autres blocs libres et ainsi de
suite. L’importance de cette implémentation, c’est que l’on peut rapidement trouver

32
les adresses d’un grands nombres de blocs libres, à la différence de la méthode
chaînée standard.

9.4. Liste avec comptage

La méthode de représentation d’espace libre avec comptage, profite du fait qu’il
existe souvent plusieurs blocs libres contigus dispersés dans le disque. Alors, plutôt
que de maintenir une liste de n adresses libres, on mémorise l’adresse du premier
bloc libre et le nombre x de blocs contigus libres qui suivent le premier bloc. Chaque
entrée dans la liste d’espace libre consiste donc en une adresse disque et un
compteur.

33
Chapitre 4: Etude du système d’exploitation MS-DOS
1. Introduction
MS-DOS (Microsoft Disk Operating System) est un S.E. ancien (version 1.25 en
1981), mono tâche, mono utilisateur, dépourvu d‘une interface graphique. Pourquoi
le conserver ? Pourquoi l‘étudier ?
 Pour son langage de commande qui est très utilisé
 Pour installer une machine : démarrer avec une disquette de boot et préparer
la machine à recevoir le futur SE (par exemple partitionner et formater les
partitions)
 Pour dépanner une machine, lorsque l‘interface graphique ne démarre pas
 Pour créer des scripts de commandes ou fichier batch
 Pour automatiser des traitements
 Il sert de complément au SE muni d‘une interface graphique.
2. Structure du DOS
Le DOS est constitué de deux parties :
2.1. Noyau
Il fournit des services tels que gestion de fichiers, gestion de la mémoire...
Il réside dans deux fichiers cachés sur le disque :
 IO.SYS: lien entre le BIOS et le noyau (routines d'accès aux périphériques)
 MSDOS.SYS : primitives du DOS (routines d'accès aux lecteurs de
disquettes, fichiers, répertoires)
2.2. Interprétateur de commande
Il est stocké dans le fichier Command.com, analyse les ordres tapés par l'utilisateur
et les transmet au système.
Les commandes les plus courantes sont traitées directement par COMMAND.COM
(commandes internes ou résidentes) ; les autres sont chargées à la demande et
résident dans des fichiers (commandes externes).
3. Concepts fondamentaux
3.1. Unités et périphériques
Une unité est un élément physique permettant le stockage permanent des
informations. Le standard de nommage de ces unités est :
 A : 1er lecteur de disquette
 B : 2e lecteur de disquettes (sur les anciens systèmes)
34
  C : 1er disque dur (ou première partition du premier disque)
 D : 2e disque dur ou lecteur graveur CD-DVD ou 2e partition
3.2. Fichiers
Un fichier est un ensemble d'informations plus ou moins structurées stockées sur un
périphérique de masse (disquette, disque dur…). Il contient des données ou des
programmes, son nom est composé de :
 d'un nom proprement dit
 d'une extension facultative (3 caractères maximum) précédée d'un point.
L'extension est habituellement utilisée pour donner des informations sur la nature du
fichier. Quatre extensions sont imposées par le système :
 .COM fichier de commandes exécutable
 .EXE fichier exécutable
 .BAT fichier de commande (batch) (il s'agit d'un fichier texte)
 .SYS fichier système
Un fichier est doté de quatre attributs :
 a: Archive : il est utilisé pour les commandes de sauvegarde (backup)
 r: (read only) lecture seule (remarque : lorsque les fichiers sont copiés à partir
d'un Cd-rom, l'attribut de lecture seule est positionné sur chaque fichier)
 s: attribut système : utilisé pour les fichiers systèmes
 h: (hidden) fichier caché
3.3. 2.3.3. Répertoires
Un répertoire est un regroupement de fichiers et de sous répertoires. Il permet de
ranger dans un même emplacement des fichiers de même nature ou couvrant le
même sujet.
Le répertoire principal (ou répertoire racine) est l'unité complète. Il est représenté par
le nom de l'unité, suivi du symbole \. Ainsi C:\ représente le répertoire principal de
l'unité C.
Le répertoire courant est le répertoire avec lequel où l’on travaille à un moment
donné.
Exemple : C:\TP\AS\
Tout répertoire est doté de deux répertoires particuliers :
 . : Répertoire courant ;
 .. : Répertoire père (celui dans lequel est contenu le répertoire courant) ;

35
3.4. Chemin d‘accès
C’est la description complète des répertoires permettant d‘y accéder depuis l‘endroit
où on se trouve. Les noms de répertoires sont séparés par « \ »
Exemples :
 C:\images\index\liste.txt : chemin absolu, commence la description depuis la
racine ;
 .index\liste.txt : chemin relatif, commence la description depuis le répertoire
courant (ici, image par exemple)
 ..\index\liste.txt : idem, par contre le ".." indique que l'on passe par le
répertoire père (ici, on est dans labs, et on souhaite accéder au fichier dans le
répertoire image)

Figure 4-17:Chemin absolu

4. Commandes MS-DOS
Une commande Dos est une commande exécutée dans un mode appelé ligne de
commande. Cette commande pour être exécutée doit être présente dans
l'environnement de travail (sur une disquette de boot, toutes les commandes ne sont
pas présentes).
4.1. Syntaxe générale d'une commande MS-DOS
Nom commande [paramètre(s)] [option(s)]
Les trois éléments de la commande sont séparés par un ou plusieurs espaces. [ ],
certains paramètres étant optionnels. Les options s'expriment également sous forme
de lettre précédée par le signe /
Exemples :
 dir
 dir *.jpg
 dir *.jpg /w

36
4.2. Obtenir de l'aide sur une commande MS-DOS
Il suffit de rajouter à la commande les caractères /? ou d'utiliser la commande help.
La commande help saisie directement donne la liste des commandes.
Exemples:
 Help
 dir / ?
 help dir
5. 4. Commandes de base
5.1. Commandes sur les répertoires
5.1.1. Lister le contenu d'un répertoire : dir
 dir *.doc : affiche la liste des fichiers .doc du répertoire courant
 dir /p : affiche la liste des fichiers du répertoire courant page par page
 dir a:\info\01 /w : liste des fichiers du répertoire \info\01 de l'unité a: sur cinq
colonnes
 dir *.* /s : liste les fichiers contenus dans ce répertoire et dans tous ses sous-
répertoires.
5.1.2. Se déplacer dans les répertoires : cd ou chdir
 cd a:\info\01
 cd .. permet de remonter dans le répertoire parent.
 cd \ permet de remonter au répertoire racine.
5.1.3. Créer un répertoire : md ou mkdir
 md travail : créer le répertoire travail dans le répertoire courant.
 mkdir a:\info\Travail : créer le répertoire travail dans le répertoire info de l'unité
a:
 md \travail\exemple : créer le répertoire et le sous répertoire dans le répertoire
courant.
5.1.4. Supprimer un répertoire : rd ou rmdir
 rd travail : supprime le répertoire travail du répertoire courant.
 rmdir a:\info\Travail supprime le répertoire travail sur l'unité a:
Remarque :
Pour être supprimé, le répertoire ne doit contenir aucun fichier ni aucun sous-
répertoire. Ceci n'est plus vrai avec le versions récentes Windows : /S permet de
supprimer tous les fichiers et répertoires.
37
5.1.5. Visualisation de l'arborescence : tree
 tree c:\travail : affiche l'arborescence de c:\travail
5.1.6. Commandes sur les fichiers
5.1.7. Afficher le contenu d'un fichier : Type
 Type clients.txt : affiche à l'écran le contenu du fichier clients.txt
Remarque
Le fichier à afficher doit contenir uniquement des caractères imprimables (affichable).
5.1.8. Copier un fichier : copy
 copy lettre.doc a: copie le fichier lettre.doc sur la disquette a:
 copy c:\doc\*.txt c:\txt : copie les fichiers .txt du répertoire c:\doc dans le
répertoire c:\txt
5.1.9. Supprimer un fichier : delete
 del toto.txt: efface le fichier toto.txt du répertoire courant
 del *.* : efface tous les fichiers du répertoire courant
 del *.* /p : un message de confirmation est affichée pour chaque fichier
5.1.10.Renommer un fichier : ren
 ren toto.doc titi.doc : renomme le fichier toto.doc en titi.doc
5.2. Commandes sur disque
Certaines commandes ne peuvent pas être utilisées dans une fenêtre Dos. De plus,
certaines de ces commandes sont destructrices, donc, à manipuler avec précaution.
5.2.1. Formatage du disque : format
 format a:
 format a: /s :
5.2.2. Dupliquer des disques diskcopy
 diskcopy a: b: copie la disquette de l'unité a sur la disquette de l'unité b
5.3. 4.3. Commandes avancées
5.3.1. Copier une arborescence Xcopy
 XCopy c:\travail a: /e : Copie le répertoire travail et ses sous répertoires, y
compris les répertoires vides.
5.3.2. Supprimer une arborescence : deltree
 Deltree a:\travail : Supprime tous les fichiers et répertoires à partir du
répertoire Travail.

38