Systèmes d’Exploitation 1 - freealilou.free.frfreealilou.free.fr/CV_MCF_fichiers/Mes_Cours/Diapos-Cours-SE-1.pdf · – Comprendre les fonctionnalités d'un système d'exploitation

Systèmes d’Exploitation 1Systèmes d’Exploitation 1

Ali LarabCUFR d’Albi2008-2009

Présentation du module « S.EPrésentation du module « S.E--1 » 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.

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

– 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.

BibliographieBibliographie

• 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 SEContenu SE--11

• Introduction aux systèmes d’exploitation– Définition, - Fonctions, – Historique (Evolution), - Exemples, – Classification

• Gestion des supports de stockage (disques magnétiques


• 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. 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.3 Fonctions d'un SEI.4 Exemples de SEI.5 Classification des SE

II Historique des SEII.2 Générations d'ordinateur

Introduction aux SE 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...


– 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'exploitationsystème d'exploitation ».

Définition d'un SEDé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.


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 SEPositionnement du SE


Positionnement du SEPositionnement du SEPériphériques physiquesPé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...


Positionnement du SEPositionnement du SEMicroMicro--architecturearchitecture : Correspond 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.


plusieurs) registre.

Positionnement du SEPositionnement du SELangage machineLangage machine : Correspond au programme (en assembleur) 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'exploitationSystè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èmesReste 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 d'interruptions d'horloge (fait partie du SE).



ApplicationsApplications : 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 SEFonctions d'un SE (1/5)(1/5)

FonctionsFonctions d’und’un SESE ::

1. Extension de la machine,�� Machine virtuelle ou machine étendue ,

2. Gestion des ressources .



11.. ExtensionExtension dede lala machinemachine (Machine(Machine virtuelle)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).


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 ».


22.. GestionGestion desdes ressourcesressources ((11//33))– 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


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


22.. GestionGestion desdes ressourcesressources ((22//33))

---->> partagepartage dede ressourcesressources::– 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.


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).


22.. GestionGestion desdes ressourcesressources ((33//33))

Les ressources à gérer :Les ressources à gérer :– Les processus,– Les fichiers,– Les entrées/sorties,


– Les entrées/sorties,– La mémoire.

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

Exemples de SE (1/4) Exemples de SE (1/4) Liste nonListe non--exhaustive… !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-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 : 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-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– DEC : TOPS-10, TOPS-20 et ITS

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

[Source: Wikipedia]


• 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...


• MS-DOS...

RedHat Fedora FreeBSD Suse OpenSUSE Knoppix

Kaella Minix NetBSD OpenBSD OpenDarwin Mandriva

Debian Ubuntu Gentoo Slackware Sentinix ReiserFS

Classification des SEClassification des SE

•• Critères de classificationCritères de classification :1. Libre et gratuit / Propriétaire et payant2. Services rendus3. Architecture de fonctionnement4. Architecture matérielle supportée


4. Architecture matérielle supportée5. Évolution6. Contraintes de temps réel7. …

Critères de classification (1/6)Critères de classification (1/6)

Libre et gratuit / Propriétaire et payantLibre 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 ...


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: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.


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 :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.


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: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.


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É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


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).


ContraintesContraintes dede tempstemps réelréel ::

Certains automatismes (particulièrement industriels) nécessitent desréponses en temps réel. Toutes les réponses qu'il recevra au delà dutemps 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) Historique des SE (1/6)

II.2 Générations d'ordinateurII.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


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

• 5ème génération (1990 - Aujourd'hui et +) : Les ordinateurs personnels portables et de poche.


11èreère génération (1945 génération (1945 -- 1955)1955) : Les tubes à vide et les cartes enfichables: 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.


22èmeème génération (1955 génération (1955 -- 1965)1965) : Les transistors et le traitement par lots: 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).


33èmeème génération (1965 génération (1965 -- 1980)1980) : : Les circuits intégrés et la multiprogrammationLes 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


• 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.


44èmeème génération (1980 génération (1980 -- 1990) : Les ordinateurs personne ls1990) : 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.


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.


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

• 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


• 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)Système UNIX (historique)

HistoriqueHistorique :

1) 1969 - 1979 : Les premiers pas universitaires2) 1979 - 1984 : Les premiers pas commerciaux3) 1984 - 1993 : La standardisation


3) 1984 - 1993 : La standardisation4) 1991 - 2000 : Linux, le renouveau d'UNIX


HistoriqueHistorique :1) 1969 1) 1969 -- 1979 : Les premiers pas universitaires1979 : 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,


• 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.


HistoriqueHistorique :2) 1979 2) 1979 -- 1984 : Les premiers pas commerciaux1984 : 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.


– 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.


HistoriqueHistorique :3) 1984 3) 1984 -- 1993 : La standardisation1993 : 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.


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 ...).


HistoriqueHistorique :4) 1991 4) 1991 -- 2000 : 2000 : LinuxLinux , le renouveau d'UNIX, 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


• 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 UNIXQualités du système UNIX1. 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.


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 noyauCaractéristiques générales du noyau

1. Multi-tâche / multi-utilisateur2. Système de fichiers arborescent3. Entrée/Sorties compatible fichiers, périphériques et processus4. Réduction du noyau système


5. Interface au noyau


Caractéristiques générales du noyauCaractéristiques générales du noyau1. Multi1. Multi--tâche / multitâche / multi--utilisateurutilisateur• 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


• 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 ».


Caractéristiques générales du noyauCaractéristiques générales du noyau2. Système de fichiers arborescent2. 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érique s et processus3. Entrée/Sorties compatible fichiers, périphérique s et processus• Les périphériques sont manipulés comme des fichiers ordinaires.


• 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.


Caractéristiques générales du noyauCaractéristiques générales du noyau4. Réduction du noyau système4. 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 ...).


de l'interprète de commande (sh, csh, ksh, tcsh ...).

5. Interface au noyau5. 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.


Caractéristiques générales du noyauCaractéristiques générales du noyau


Langage de commande Langage de commande et et

expressions régulièresexpressions régulières


expressions régulièresexpressions régulières

AA-- Langage de commande Langage de commande


Langage de commandesLangage de commandes

Points à aborder1. Les commandes internes et externes2. Les variables3. Les procédures4. Les structures de contrôle5. Les opérateurs


5. Les opérateurs6. Les commandes « test », « expr » et « find »7. Les fonctions.

Langage de commandesLangage de commandesLangage de commandesLangage de commandes (1/2)

DéfinitionDé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.


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 commandesLangage de commandesLangage de commandesLangage 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 ).


– « 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 )

AA--1) Langage de commandes1) Langage de commandesCommandes internes et commandes Commandes internes et commandes

externesexternes


externesexternes

Langage de commandesLangage de commandes1) Commandes internes1) 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)


• Ex. : cd, trap , umask, wait …

echo, pwd, test …(juste pour rapidité sinon elles auraient pu être externes)

typetype nom-commande � pour voir si la commande est interne ou externe

Ex. type cdcd is a Shell builtin

Langage de commandesLangage de commandes2) Commandes externes2) 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


sous−processus. Cette commande ne peut donc pas modifier l’environnement du processus.

Ex. type cpcp is /usr/bin/cp

Langage de commandesLangage de commandesExécution d’une Exécution d’une commande commande interneinterne

Exécution d’une Exécution d’une commande commande

externeexterne

cd /tmp cp fich1 fich2


Langage de commandesLangage de commandesExécution d’une commandes Exécution d’une commandes (internes ou externes)(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

AA--2) Langage de commandes2) Langage de commandesLes variablesLes variables


Les variablesLes variables

Langage de commandesLangage de commandesLes variablesLes variables

Définition de variableDé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


• 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)



• 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


variable

$ echo $$variable

valeur

$.



• 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


$ echo rienrien$ echo $$rien$ echo A$rienAA$ echo A ${${ rien }} AAA$


Réévaluation de variable !!!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


$ echo $BA$ B=$A$ echo $B1$ A=2$ echo $B1$


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 *


$ ls −x $t *fic1 fic2 fic3 fichier$

On a aussi:$ l=ls$ $l −x $t ?fic1 fic2 fic3


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


la date est : Wed May 18 15:56:30 MET 1994$ lognamec1$ grep ‘ logname ‘ /etc/passwdc1:x:106:104:Eleve 1:/usr/c1:/bin/ksh$ dateWed May 18 15:57:30 MET 1994$ ‘ date ‘ksh: Wed command not found$


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 $varfun:x:208:55:Guy Thienot:/tech/u2/fun:/bin/ksh


Liste des variables• Commande setset � 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


• 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 )

• …


Destruction d’une variable

• Pour détruire des variables utiliser la commande :unset var var1 ...



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


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 027PATH=/bin:/usr/bin:$HOME/bin:.export PATHV2=$HOME/projet/src/version2export V2


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 (exportexport ) une variable pour pouvoir

la transmettre aux fils.


$ a=1$ bash$ echo $a$ exit$ export aexport a$on fait hériter les fils de la valeur de a$ bash$ echo $a1$La variable a bien été transmise

$ bash$ echo $a1$cet héritage est fait à tous les fils puis on

remonte$ exit$


L’Affectation interactive L’Affectation interactive ((commande interne commande interne readread ))• 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$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.


Exemple:Exemple:

$ read a10$ echo $a10

$ read b c dvoici trois mots$ echo $d $c $b

$ read d e fBonjour$ echo $dBonjour$ echo $e$ echo $f


$ echo $d $c $bmots trois voici

$ read a b cet voici quatre mots$ echo $aet$ echo $bvoici$ echo $cquatre mots

$ IFS= u$IFS$ read g hcou cou$ echo $gco$ echo $hco

Remarque:IFS=u$IFS -> concaténation du contenu de IFS

avec le u. Elle va donc contenir « u + blanc »IFS=u � réinitialisation de IFS

AA--3) Langage de commandes3) Langage de commandesProcéduresProcédures


ProcéduresProcédures

Langage de commandesLangage de commandesProcéduresProcédures

DéfinitionDé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 :


Exemple :$ cat fichier_procedure_1

# ceci est une procédure

date

who

tty

$


Exécution d’une procédureExé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


3. Lancer la procédure après avoir rendu exécutable le fichier la contenant.


Exécution d’une procédureExé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_1wed Jul 6 11:07:45 MET 1994


wed Jul 6 11:07:45 MET 1994philip term/c0 Jul 6 10:30fun term/c5 Jul 6 09:06c1 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).



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 :

$ bashbash fichier_procedure_1


$ bashbash fichier_procedure_1wed Jul 6 11:07:45 MET 1994philip term/c0 Jul 6 10:30fun term/c5 Jul 6 09:06c1 term/c4 Jul 6 09:14/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é.



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+rxchmod u+rx fichier_procedure_1$ fichier_procedure_1wed Jul 6 11:07:45 MET 1994


wed Jul 6 11:07:45 MET 1994philip term/c0 Jul 6 10:30fun term/c5 Jul 6 09:06c1 term/c4 Jul 6 09:14/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.


Paramètres positionnelsParamètres positionnels (1/2)

Paramètres positionnels = arguments d’appel de la procédureEx . $ fichier_procedure1 arg1 arg2 arg3

$ Moyenne 10 12 1 4

Le nom de ces paramètres sont $0, $1…$9Ex. Dans l’exemple précédent, Moyenne=$0, 10=$1, 12=$2, 1=$3 et 4=$4


4=$4

Ex.$ cat p2

echo $0 $1 $2 $3

$ p2 a b c

p2 a b c


Paramètres positionnelsParamètres positionnels (2/2)

S’il y a plus de 9 paramètres, il faut soit utiliser la commande ShiftShiftsoit mettre les paramètres entre accolades { …}

EX.

$ cat proc2echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9

$ proc2 a b c d e f g h i j k l m


echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9shiftecho $0 $1 $2 $3 $4 $5 $6 $7 $8 $9shift 2 ça fait 3 avec le 1er shift

echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9shift 3 ça fait 6 avec le 1er et 2ème shift

echo $0 $1 $2 $3 $4 $5 $6 $7 $8 $9$ echo $ { 11} ${ 12}

i j k l m

proc2 a b c d e f g h iproc2 b c d e f g h i jproc2 d e f g h i j k lproc2 g h i j k l mk l$


Variables automatiquesVariables automatiques (1/3)

• Exécution d’une procédure � initialisation des paramètres positionnels et des variables automatiquesvariables 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

_ ( underscore )le dernier mot de la dernière ! le numéro du dernier processus


_ ( underscore )le dernier mot de la dernière commande exécutée

! le numéro du dernier processus lancé en arrière−plan

#le nombre de variables de position définies

PPID le numéro du processus père

*la liste des variables de position vu comme une seule variable

PWD la référence absolue du répertoire de travail

@ la liste des variables de position RANDOM un nombre aléatoire

?le code de retour du dernier processus terminé

SECONDS le nombre de secondes écoulées depuis le lancement du processus Shell

$ le numéro du processus courant



• 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 $!


$ kill $!



$ cat p3datesleep 2ps −fecho "0=$0 1=$1 2=$2 3=$3 4=$4 5=$5" ²

echo "#=$# *=$* !=$! $=$$"$ ls −l p3−rw−r−−r−− 1 jmr ens 115 Nov 16

$$ chmod u+x p3$ ls −l p3−rwxr−−r−− 1 jmr ens 115 Nov 16

10:07 p3$ p3 abc xyz 123Mon May 20 11:46:32 MET DST

1995PID TTY STAT TIME COMMAND


−rw−r−−r−− 1 jmr ens 115 Nov 16 10:07 p3

$ .. p3 abc xyz 123Mon May 20 11:45:20 MET DST 1995PID TTY STAT TIME COMMAND56 v01 S 0:01 −bash112 v01 S 0:00 \_ ps −f0=−bash 1=abc 2=xyz 3=123 4= 5=#=3 *=abc xyz 123 !=95 $= 56

$0=bash car c’est le Shell (.p3) qui exécute les lignes de p3 !!!

PID TTY STAT TIME COMMAND56 v01 S 0:01 −bash112 v01 S 0:00 \_ −bash115 v01 R 0:00 \_ ps −f0=./p3 1=abc 2=xyz 3=123 4= 5=#=3 *=abc xyz 123 !=95 $= 112

$0=./p3, car p3 est devenu maintenant exécutable !!!


Commande Commande setset• La commande set permet de donner une valeur aux

paramètres positionnels, et de mettre à jour les variables automatiques ’$#’, ’$*’, ’$@’.

$ setset 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.


Statut d’une procédureStatut 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 dernière commande exécutéecommande exécutée .


$ cat p4whoecho statut de who : $?date −zecho statut de date −z : $?$ ls −l p4−rwxr−x−−x 1 c1 cours 94 Jul ... p4

$ p4c1 term/c4 Jul 19 07:41manu term/b1 Jul 18 15:22fun term/b3 Jul 19 09:10statut de who : 0date: illegal option −− zstatut de date −z : 1$ echo $?1$


Commande Commande ExitExit• 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.


• Ex.$ cat proc5ls −l p4exit 2exit 2Who

$ proc5−rwxr−x−−x 1 c1 cours 94 Jul ... P4

$ echo $?2$

AA--4) Langage de commandes4) Langage de commandesStructures de contrôleStructures de contrôle


Structures de contrôleStructures de contrôle

Langage de commandesLangage de commandesStructures de contrôleStructures de contrôle

Structures de contrôleBut: 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 »,


– 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 « La structure « forfor » » for nom [ in liste ... ]do

commandesdone

• � 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


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.


La structure « La structure « forfor »»Ce qu’on peut faire avec « for…do…done »• for var in liste_exhaustive• for var in $VARIABLEVARIABLE• for var in $** ou for var• for var in ‘‘commande ‘‘


• for var in ‘‘commande ‘‘• for var in métacaractères


La structure « La structure « forfor »»for var in liste_exhaustive

Ex1.

$cat pgm_Feu1$ for i in 3 2 1 Feu> do echo $i


> do echo $i> done

$pgm_Feu1321Feu

$


La structure « La structure « forfor »»for var in liste_exhaustive (suite)

Ex2.for i in 1 2 3do cp fich " $i$i " /tmpchmod 666 /tmp/fich " $i$i "done


�� Copie les fichiers fich1 , fich2 et fich3 dans le répertoire /tmp , et change leurs protections.

done


La structure « La structure « forfor »»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 do

commande done

for i in $$ **do

commandedone

est équivalent à :


Structures de contrôleLa structure « La structure « forfor »»

for var in $**(ou for var ) (2/4)

• Ex. for var in $variable

$ cat pgm_listargfor argargdo

echo argument: $arg$argdone

$ chmod a+rx pgm_listarg


for var in $variable$ pgm_listarg camion proton véloargument: camionargument: protonargument: vélo

$ pgm_listarg f * $HOMEargument: fic1argument: fic2argument: /usr/c1$


La structure « La structure « forfor »»for var in $**(ou for var ) (3/4)

• Ex2. for var in $variable

� Il est possible de passer une liste

$ VAR="3 2 1 Feu"

$ cat pgm_Feu2$ for i in $VAR> do> echo $i> done


� Il est possible de passer une liste dont les éléments seront variables.

> done

$ pgm_Feu2321Feu$


La structure « La structure « forfor »»for var in $**(ou for var ) (4/4)

• Ex3. Imbrication

$cat pgm_cons_voyel$ for consonne in b c d f g> do> for voyelle in a e i o u> do > echo "$consonne$voyelle \c "> done

• La séquence \\cc de la


> done> echo " "> done

$ pgm_cons_voyelbabebibobucacecicocudadedidodufafefifofugagegigogu$

• La séquence \\cc de la commande echo permet de ne pas faire de saut de ligne.

• La commande echo " "" "permet de sauter une ligne.


La structure « La structure « forfor »»for var in `̀commande `̀

Ex.

$cat pgm_fic> for fic in ‘‘ ls ‘‘> do> echo $fic present> done

$ pgm_fic

•Il est possible d’initialiser la liste à l’aide du résultat d’une commande en mettant la commande entre `…`.


$ pgm_ficfic presentfic1 presentfic2 presentrep present$

mettant la commande entre `…`.

•La variable fic sera initialisée successivement à chacun des mots du résultat de la commande ls.

•Cette commande ne sera exécutée qu’une seule fois au premier passage.


La structure « La structure « forfor »»for var in …métacaractères

• �� On peut aussi initialiser la liste dans la substitu tion des noms de fichiers via les métacaractères.


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

…


La structure « La structure « ifif »,»,• Syntaxe

if commandes1then commandes2[ else commandes3]

FiExplication:


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.


La structure « La structure « ifif »,»,Ex.

$ cat exist_userif grep "$1" /etc/passwd > /dev/nullthen echo "L’utilisateur $1 a un compte"else echo "L’utilisateur $1 n’existe pas"Fi


Fi

$ chmod u+x exist_user

$ exist_user c1L’utilisateur c1 a un compte$


La structure « La structure « ifif »,»,• Il est possible d’enchaîner en cascade des conditionnelles de ce type :

if commandes1then commandes2else ifelse if commandes3

if commandes1then commandes2elifelif commandes3

��

Que l’on


else ifelse if commandes3then commande4else ifelse if commande5

......fi

fifi

elifelif commandes3then commandes4elifelif commandes5.....

fi

Que l’on peut

écrire sous la forme

abrégée en : ��


La structure « La structure « ifif »,»,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.


La structure « La structure « ifif »,»,Ex. :

$ cat existficif test −d $1then echo "$1 est un repertoire"elif test −w $1then echo "$1 autorise l’ajout"elif test −r $1then 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 ...


La structure « case »,Syntaxe :

casecase chaîne inmotif 1) commande1 ;;;;motif 2) commande2 ;;;;...motif n) commanden ;;;;

esacesac

• Les différents motif sont des expressions reconnues par le mécanisme


• Les différents motif i 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îneréponde au motif i . Il exécute alors la commandei (et elle seule).

• Il est courant d’utiliser * comme dernier motif (cas par défaut) d’un aiguillage.


La structure « case »,Ex1.

$ cat engtofrcasecase $1 ininone) X=un;;two ) X=deux;;three ) X=trois;;* ) X=$1;;EsacEsac


EsacEsacecho $X

$ chmod u+x engtofr

$ engtofr oneun$


La structure « case »,Ex2.

$ cat choixecho –e "voulez vous continuer \c"read reponsecasecase "$reponse" inin[nN] || no || NO)) exit 0 ;;;;esacesac# suite du traitementdate


date$


Les structures « while » et « until »,Syntaxe de « Syntaxe de « whilewhile »» :

while commandes1do commandes2done

• Dans le cas du while , tant que le statut de commandes1est vrai, commandes2 est exécutée.


est vrai, commandes2 est exécutée.

• Rq : commandes1 peut être formée d’un ensemble de commandes enchaînées par des pipes (|).


Les structures « while » et « until »,

Ex. $ cat deconnectewhile who || grep "$1" > /dev/nulldosleep 180echo ",\c"doneecho " \ n$1 n’est plus connecté"

$ chmod u+x deconnecte$ deconnecte c1,,,c1 n’est plus connecte$


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.

echo " \ n$1 n’est plus connecté"


Les structures « while » et « until »,Syntaxe de « until »:

until commandes1

do

commandes2

done


• � On réexécute commandes2 jusqu’à ce que comandes1devienne vraie.


Les structures « while » et « until »,Syntaxe de « until »:Ex.

$ cat userlogeruntil who | grep "$1" > /dev/nulldo

echo −e ",\c"sleep 300

Explications: Tant que l’utilisateur passé en argument ne se trouve pas dans la liste des utilisateurs (who | grep

), on affiche une virgule


sleep 300doneecho "\n$1 est arrivé"

$ chmod u+x userloger$ userloger c1,,,c1 est arrivé$

$1), on affiche une virgule (l’option "−e" permet de prendre en compte le "\c " qui ne fait pas de saut de ligne) et on fait une pause (sleep 300 ). Dès que l’utilisateur se connecte, on sort 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 n ième niveau (1 par défaut) de boucle for ou while .


Les débranchements, (2/2)

Ex.

$ cat fichexistwhile ::doecho −e "nom de fichier: \n"read fic

$ lsfichexistfichA

$ fichexist


read ficif test −f "$fic"then

breakbreakelse

echo $fic fichier inconnufidone# le break branche ici# la suite du traitementecho "fin de traitement"

$ fichexistnom de fichier : foofoo fichier inconnunom de fichier : barbebarbe fichier inconnunom de fichier : fichAfin de traitement$

AA--5) 5) Langage de commandesLangage de commandesLes opérateursLes opérateurs


Les opérateursLes opérateurs

Langage de commandesLangage de commandesLes opérateursLes opérateurs

L’opérateur « L’opérateur « ET logiqueET logique »»Syntaxe : cmd1 &&&& cmd2

• On exécute cmd2 uniquement si cmd1 se termine correctement $ pwd

/usr/c1$ mkdir tmp


$ mkdir tmp$ test -d $HOME/tmp &&&& cd $HOME/tmp$ pwd/usr/c1/tmp

$ cd$ rmdir tmp$ test -d $HOME/tmp &&&& cd $HOME/tmp$ pwd/usr/c1$

Explications de l’ex.:Si le répertoire tmp existe dans le répertoire courant, alors aller dans ce répertoire.

Langage de commandesLangage de commandesLes opérateursLes opérateurs

L’opérateur « L’opérateur « OU logiqueOU logique »»Syntaxe : cmd1 |||| cmd2

• On exécute cmd2 uniquement si cmd1 ne se termine pascorrectement (statut ≠ 0).

$ pwd/usr/c1


/usr/c1$ mkdir tmp$ test -d $HOME/tmp |||| echo $HOME/tmp inexistant

$ rmdir tmp$ test -d $HOME/tmp |||| echo $HOME/tmp inexistant

/usr/c1/tmp inexistant$

Explications de l’ex.:S'il n'existe pas de répertoire tmp dans le répertoire courant, alors afficher un message.

AA--6) Langage de commandes6) Langage de commandesLa commande La commande testtest


La commande La commande testtest

Langage de commandesLangage de commandesLa commande La commande testtest

La commande La commande testtestSyntaxe:

testtest expression

Ou mettre l’expression entre crochets:

[[ expression ]]

test expression


• La commande test évalue expression et retourne le résultat de cette évaluation.

• Quand test est appelée sans argument elle retourne faux .


Test sur des fichiers et répertoires :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.


Test sur des chaînes :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 .


Test sur des nombres :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.


Test sur des nombres :Test sur des nombres : (2/2)

Ex.$ cat testarg

if testtest "$#" -eq "0"

then


then

echo "usage: $0 arg1 arg2" >&2

exit 1

fi

$

AA--7) Langage de commandes7) Langage de commandesLa commande La commande exprexpr


La commande La commande exprexpr

Langage de commandesLangage de commandesLa commande La commande exprexpr

SyntaxeSyntaxe :exprexpr 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


Attention : Certains opérateurs utilisés par la commande exprsont 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 \*


Qlq utilisations 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 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


Qlq utilisations 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 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


Ex.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


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

AA--8) Langage de commandes8) Langage de commandesLes fonctions Les fonctions


Les fonctions Les fonctions

Langage de commandesLangage de commandesFonctionsFonctions

Fonctions


BB-- Expressions régulièresExpressions régulières


Lgge de commandes et E. Rég.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


• 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.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.


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èresExpressions régulières

Exemple: La commande Exemple: La commande egrepegrep

�� RRecherche dans les fichiers textesecherche dans les fichiers textes

• egrep ‘^(From|Subject) : ‘ mailbox

� pour réaliser la table des matière d’une 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èresLes métacaractères1- Début et fin de ligne : ^̂ et $$

^̂ chatchat reconnaît ‘chat’ placé en début de ligne.

chatchat $$ reconnaît ‘chat’ placé en fin de ligne


chatchat $$ reconnaît ‘chat’ placé en fin de ligne

^̂ chatchat $$ reconnaît une ligne qui ne contient que le mot ‘chat’

^$^$ reconnaît une ligne vide


Les métacaractèresLes métacaractères2- 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


[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


Les métacaractèresLes métacaractères3- 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. ‘^…’).


[^…]) 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).


Les métacaractèresLes métacaractères4- 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 !)


Les métacaractèresLes métacaractères5- 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]sl(i|y)s Équivalent à l[iy]s.


– Attention à ne pas confondre l’expression ^From|Date|Subject : avec ^(From|Date|Subect) : Il désigne n’importe quel caractère.

l(i|y)s Équivalent à l[iy]s. Les parenthèses sont des métacaractères.

Première|1ère (Premi|1)ère


Les métacaractèresLes métacaractères6- 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


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 .


Les métacaractèresLes métacaractères7- 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 +(.*) +{While +$.*$ +{

début d’une boucle while en C qui s’écrit :while (…) {.Attention: Dans cet exemple il y a un blanc avant le +


Les métacaractèresLes métacaractères8- 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 {


Les métacaractèresLes métacaractères9- 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


Les métacaractèresLes métacaractères10- 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


Les métacaractèresLes métacaractères11-Transformer certains caractères en métacaractère s : \• 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


\ 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

Expressions régulièresExpressions régulièresLes métacaractèresLes métacaractères12-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)

Expressions régulièresExpressions régulièresLes métacaractèresLes métacaractères13-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 


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.

Expressions régulièresExpressions régulièresLes métacaractères :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


• 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.

Expressions régulièresExpressions régulièresLes métacaractères :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 | ;


• 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.

Expressions régulièresExpressions régulièresLes Les métacaractèresmétacaractèresQuelques exemples avec la commande grep (grep affiche les lignes correspondant à un motif): • nombre de lignes en commentaire (commençant par !) dans un code Fortran :

grepgrep "^!" "^!" prog.fprog.f | | wcwc --l l (wc –l affiche le nmbr de sauts de lignes)

• recherche de STOP avec le numéro de la ligne dans tous les sources :

grepgrep --n n --i stop *.f* 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 : lsls | | grepgrep --vEvE "("(imageimage||sonson)" )"


lsls | | grepgrep --vEvE "("(imageimage||sonson)" )" (-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

grepgrep --E "(E "(imageimage||sonson)" *)" *• liste des fichiers contenant JPP dans une arborescence

findfind . . --namename "*" "*" --execexec grepgrep JPP {} JPP {} \\; ; bizarre donne le contenu du fichier et non pas son nom

Langage de commandes et ERLangage de commandes et ERDifférence de signification entre expression réguli ères et Shell

Caractères spéciaux

Signification pour les E.R(Pour grep,find,awk ou vi en partie)

Signification pour le Shell

$ fin de ligne idem

^ début de ligne idem

[] un des caractères du crochet idem

- de x à y dans [x-y] idem


- de x à y dans [x-y] idem

. Caractère quelconque .

? L’expression régulière précédente est optionnelle

Un caractère quelconque

* Répétition >=0 Chaîne quelconque

+ Répétition >0 (pas dans vi) +

| ou (pas dans vi) Pipe

() Groupement des expressions (pas dans vi)Groupement des commandes

FINFINFINFINFINFINFINFIN


FINFINFINFINFINFINFINFIN

Documents

Systèmes d’Exploitation 1 - freealilou.free.frfreealilou.free.fr/CV_MCF_fichiers/Mes_Cours/Diapos-Cours-SE-1.pdf · – Comprendre les fonctionnalités d'un système d'exploitation