Systèmes d'exploitation - Le niveau utilisateur IUT de Villetaneuse Département Informatique - Free
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
IUT de Villetaneuse Département Informatique
1ère année
Systèmes d’exploitation
Le niveau utilisateur
(Volume horaire du cours + travaux dirigés + travaux pratiques : 40 heures)
Pascal Coupey, bureau T209
email : Pascal.Coupey@iutv.univ-paris13.fr2. Préambule
Préambule
L'enseignement du système d'exploitation à l'IUT de Villetaneuse est constitué de 3 parties:
Le niveau utilisateur (40 heures)
Fondements et mise en oeuvre (40 heures)
Administration de systèmes (20 heures)
Cet enseignement doit apporter une bonne connaissance des systèmes d'exploitation
multitâches, multi-utilisateurs tant au niveau de son utilisation qu'au niveau de sa structure interne
et de sa mise en oeuvre. Il doit partir du postulat qu'une machine n'est pratiquement plus jamais
isolée et montrer ainsi les liens avec l'enseignement du réseau.
Le niveau utilisateurObjectifs: Ce module est une introduction aux systèmes d'exploitation. La compétence recherchée consiste à savoir utiliser un système d'exploitation multitâches, multi-utilisateurs. Il doit aussi permettre de comprendre les étapes qui amènent à obtenir un programme en exécution à partir d'un programme en langage source. Remarques: Ce module ne nécessite aucun pré-requis sauf des notions d'algorithmique pour les scripts et de programmation en langage C. Mise en oeuvre: L'enseignement inclut une part importante d'applications par une programmation en langage shell et en C.
Plan du cours
Page de garde
Préambule
L'enseignement du système
Le niveau utilisateur
Présentation des systèmes d'exploitation
Introduction
Structure du SE
Interface utilisateur
Les systèmes d'exploitation à l'IUT
Terminal
Présentation d'Unix
Introduction
Structure d'Unix
Débuter sous Unix
Système de fichiers sous UNIX
Les commandes Unix
Les caractères génériques
Le caractère backquoting "`"
Les caractères de neutralisation
Quelques commandes UNIX
Fichiers
Types et protections
Modifications des protections
Système de fichiers (file system)
Les liens
La redirection des entrées-sorties
Les tubes de communication
Les interpréteurs de commandes
Introduction
Les variables de l'interpréteur
• En Bourne shell
• En C-shell
• Liens avec le C
Les fichiers d'initialisation
Cycle programmeIntroduction
Du source à l'exécutable
Le portage
Les erreurs
Variables en mémoire
Processus
Introduction
Le parallélisme
Utilité
Problèmes
Partage de l'UC
Création d'un processus (sous UNIX)
Distinction père, fils
Changer le code d'un processus
Quelques commandes et fonctions utiles
Programmer en shell
Introduction
Le langage C-shell
suivant3. Présentation des systèmes d'exploitation
Introduction Contexte: Multitâches, multi-utilisateurs Plusieurs programmes s'exécutent "en même temps" (multi-tâches) Plusieurs utilisateurs (multi-utilisateurs) Objectifs: Libérer les utilisateurs Utilisation commode et efficace du matériel Gestion de toutes les ressources de la machine (mémoire, périphériques, ...) Partage équitable des ressources en toute sécurité
Structure du système d'exploitation
Interface utilisateur
Dialoguer avec le système = transmettre des commandes
Interpréteur de commande
peu convivial
puissant
langage de programmation
ex: command.com et fichiers .bat (MsDos)
sh, csh, tcsh, bash, ... + scripts (UNIX)
Appels systèmes ((en langage C) ex: chdir, mkdir, open, ...)
Interface graphique: icônes, menus, fenêtres, ...
convivial
moins efficace
moins puissant
ex: Windows (Microsoft)
Xwindow, Openwin, CDE, ... (UNIX)Les systèmes d'exploitation à l'IUT
Terminal
Un terminal est un dispositif capable d'envoyer des caractères à l'ordinateur et d'afficher les
résultats à l'écran. Un terminal alphanumérique est en mode texte uniquement.
Il faut dissocier terminal et ordinateur
Terminal relié à un ordinateur distant (ex à l'IUT: HPUNIX, VMS).
Les commandes sont exécutées sur l'ordinateur distant.
Terminal relié à un ordinateur local (ex à l'IUT: LINUX, MSDOS).
Les commandes sont exécutées sur l'ordinateur local.
Pour UNIX (LINUX) il est toujours possible d'ouvrir un terminal relié à un ordinateur distant relié
au réseau.4. Présentation d'UNIX
Introduction
UNIX est un système multi-tâches, multiutilisateurs en temps partagé
Succès d'UNIX:
Gratuité
Adoption universitaire
Standard
Portabilité
Historique:
1969: Bell Laboratories (AT&T) (K.Thomson,D.Ritchie)
1973: 1ère version écrite en C (portabilité)
1974: UNIX de Berkeley (BSD) et UNIX AT&T (System 5)
1984: Norme Xwindow (indépendante d'UNIX)
1987: Accord pour convergence de UNIX BSD et UNIX System 5 en Norme POSIX= intersection
1988: Deux consortiums:
OSF: Normalisation d'UNIX : OSF1
UNIX international : UNIX System 5
à l'IUT: LINUX (compatible System 5)Structure d'UNIX
Interface UNIX
Bibliothèques de programmes exécutables: les commandes
Des shells (interpréteurs de commandes)
Langage de commandes (scripts)
Utilitaires
Assembleurs, éditeurs de liens.
Compilateurs (C, PASCAL, ADA, JAVA, ...)
Traitements de texte (LATEX)
Des outils de mise au point de programmes
Des éditeurs de textes (ed, vi)
Un système de messagerie
Un analyseur syntaxique
...Débuter sous UNIX
Connexion:
Login: coupey
Passwd: ******** (avec au moins un chiffre)
$ (prompt UNIX)
Deconnexion:
$logout
Début de session:
Login (répertoire privé = répertoire de travail = /home/...)
Puis
Boucle interpréteur
sous LINUX (bash ou tcsh)Système de fichiers sous UNIX Sous UNIX: Une arborescence : LA racine (/) Sous DOS: Plusieurs arborescences: A: B: C: ... /etc : fichiers de configuration système /home : répertoires utilisateurs /dev : fichiers spéciaux /var : fichiers temporaires pour les files d'attente et les fichiers de mail. /usr : l'ensemble des commandes et des programmes /sbin : exécutables pour l'administration système
Les commandes Unix
nom-de-commande options paramètres
ls -l *.c
Plusieurs commandes sur une ligne séparées par des ";":
ex: ls; date; who
Une commande sur plusieurs lignes en tapant "\" avant le le return:
ex: grep "blablablablablablablablablablablablablablabla" \
essai.txt
Valeur de retour d'une commande: 0 si OK != 0 sinon
ex: rm texte.doc renverra 0 si le fichier texte.doc existe, un code !=0 sinon
Regroupement de commandes (.....):
ex: (date; ls; who) > essai redirige le résultat des commandes date, ls et who dans le
fichier essai
date; ls; who > essai seul le résultat de who est redirigé vers essaiLes caractères génériques
* : 0 ou plusieurs caractères quelconques
ex: ls *.c liste tous les fichiers qui se terminent par .c
? : 1 caractère quelconque
ex: ls tp?.pas liste tous les fichiers de trois caractères commençant par tp et
d'extension .pas
[a,b] ou [ab] : 1 caractère a ou un caractère b
ex: ls [c,l]* liste tous les fichiers et répertoires qui commencent par c ou l
{ab,cd} : la chaîne ab ou la chaîne cd
ex: ls {ab,cd}* liste tous les fichiers et répertoires qui commencent par ab ou cd
[a-zA-Z] : 1 caractère alphabétique minuscule ou majuscule
[1-9A-Z] : 1 caractère numérique ou alphabétique majuscule
ex: ls [a-z][0-9] liste tous les fichiers et répertoires de deux caractères commençant par
une minuscule suivi d'un caractère numériqueLe caractère backquoting "`"
` ` : ce caractère permet d'utiliser le résultat d'une commande comme argument d'une
autre commande
ex:
echo pwd
pwd
echo 'pwd'
pwd
echo `pwd`
/home/pc
echo "pwd"
pwd
echo "ma machine est `hostname` je suis l'utilisateur `whoami`"
grep `whoami` *Les caractères de neutralisation \ : neutralise le caractère spécial qui suit ex: ls pas\*.c liste uniquement le fichier pas*.c s'il existe ' ' : neutralise une chaîne de caractères ex: ls 'pas*?1.c' liste uniquement le fichier pas*?1.c s'il existe " " : idem mais certains métacaractères sont interprétés comme l'évaluation d'une commande ex: echo 'nous sommes le : `date`' nous sommes le : `date` echo "nous sommes le : `date`" nous sommes le : lun 19 nov
Quelques commandes UNIX man: afficher le manuel (ex: man ls) cd: changer de répertoire (ex: cd .., cd /home/users/coupey, cd ~coupey, cd) pwd: afficher le répertoire courant mkdir: créer un répertoire rmdir: supprimer un répertoire ls: lister les répertoires et fichiers (ex: ls -l) more: afficher le contenu d'un fichier page par page cp: copier un fichier (ex: cp essai /home/users/coupey, cp ../essai .) mv: changer le nom d'un fichier ou d'un répertoire (ou déplacer un fichier ou un répertoire) rm: supprime un ou plusieurs fichiers touch: créer un fichier vide (ex: touch essai) grep: recherche d'une chaîne dans un fichier (ex: grep init lisezmoi.txt)
5. Les fichiers
Types et protections
Types de fichier
ordinaire (-)
répertoire (d)
spécial: mode caractère (c)
spécial: mode bloc (b)
tube nommé (p)
lien symbolique (l)
socket (s)
Protections (droits)
3 types d'utilisateurs 3 modes principaux (fichiers et répertoires)
le propriétaire (u) écriture (w)
membres du groupe (g) lecture (r)
les autres utilisateurs du système (o) exécution (x)
Exemple
$ ls -l /etc/passwd
-rw-r--r-- 1 root bin 2055 Jul 28 18:03 /etc/passwdPrécisions sur les droits des répertoires
R autorisation de lister les fichiers du répertoire (ls)
X autorise l'accès au répertoire (cd)
autorise la modification du répertoire c'est à dire création, suppression, changement de nom
W
des fichiers et des répertoires du répertoireModifications des protections Modifications des droits exemple: chmod ug+rx titi exemple: chmod 660 toto (660 = rw-rw----)
Le masque (protection par défaut à la création d'un fichier ou répertoire)
masque = l'inverse des permissions
exemple: par défaut rw- r-- ---
110 100 000
masque 001 011 111
1 3 7
Mais le système tient compte du bit X uniquement pour les répertoires.
masque 0 2 7
Pour un nouveau fichier les droits seront: rw- r-- ---
Pour un nouveau répertoire les droits seront: rwx r-x ---
Changer le masque: commande umask (ex: umask 027)Modifications du propriétaire et du groupe chown nouveau-propriétaire fichier chgrp nouveau-groupe fichier exemples: chgrp bin toto change le groupe de toto en bin chown root titi change le propriétaire de titi en root (attention opération à sens unique)
Système de fichiers (File System sous Unix)
1 file system = 1 table d'inodes
à 1 fichier est associé 1 inode (unique par file system)
exemple: ls -i toto
6330 toto (6330 est le numéro d'inode)
La commande df permet de visualiser tous les file systemLes liens
Un lien = deux noms sur un même fichier
Lien physique (même file system) Lien symbolique (file system différents)
ln fichier-existant nouveau-nom ln -s fichier-existant nouveau-nom
Lien physique donc même inode donc Lien symbolique donc inode différents. Le lien contient le
même file system texte du chemin vers le fichier
exemple: exemple:
$ ls -i $ ls -i /tmp/essai
6630 toto 5540 essai
$ ln toto titi $ ln -s /tmp/essai essai1
$ ls -i $ ls -i
6630 toto 6323 essai1
6630 titi
$ cp titi tutu
$ ls -i
6630 titi
6630 toto
6631 tutuLa redirection des entrées-sorties
entrée standard n°0 par défaut le clavier
sortie standard n°1 par défaut le terminal actif (l'écran ou fenêtre active)
sortie des erreurs n°2 par défaut le terminal actif (l'écran ou fenêtre active)
> Redirection de la sortie standard
>> Redirection de la sortie standard avec concaténation
< Redirection de l'entrée standard
2> ou >& Redirection des messages d'erreurs en shell (2>) et en c-shell (>&)
ls > toto met le résultat de ls dans le fichier toto
users >> toto concatène en fin du fichier toto le résultat de la commande users
cat < f1 > f2 copie f1 dans f2
ls > tutu
more < tutu affiche le contenu des fichiers dont les noms sont dans tutu
mail Dupond < lettre.txt un mail est envoyé à Dupond à partir du contenu du fichiers lettre.txt
ls -l > temp1; grep "rwxr-xr-x" < temp1 > temp2; more temp2 ; rm temp1 temp2 liste, page par page, tous les fichiers du
répertoire courant qui ont comme droits rwxr-xr-x
echo "bonjour" > /dev/pts/2 affiche "bonjour" dans la fenêtre 2 (dans le cas où deux fenêtres de commandes sont
ouvertes)
rm lettre.txt 2> erreur.txt redirige le message d'erreur vers erreur.txt (le fichier lettre.txt n'existe pas)
cat erreur.txt
aucun fichier ou répertoire de ce typeLes tubes de communication
Un tube de communication est un flot de données qui permet de relier la sortie standard d'une
commande à l'entrée standard d'une autre commande sans passer par un fichier temporaire
exemples
ls -l | more affiche page par page le résultat de la commande ls
last | grep coupey | head affiche les dix dernières connexions sur la machine de l'utilisateur
coupey
ls -l | grep "rwxr-xr-x" | more affiche page par page la liste des fichiers qui ont les droits rwxr-
xr-x. Cette commande donne le même résultat que
ls -l > temp1; grep "rwxr-xr-x" < temp1 > temp2; more temp2; rm temp1 temp2
Avantages des tubes
Toutes les commandes liées par le tube s'exécutent en parallèle. Par exemple, dans la
commande ls -l | more la commande more récupère, au fur et à mesure, les lignes produites
par la commande ls alors que dans la commande ls -l > toto; more toto , la commande more
n'affichera toto que lorsque le ls sera terminé.
Il n'y a pas de limite de taille pour le flot de données qui transite dans le tube (car il n'y a pas
de fichier temporaire)6. Les interpréteurs de commandes
Introduction
Un interpréteur de commande (shell) est un programme qui prend en charge l'utilisateur après le
login.
Lors de la connexion d'un utilisateur, il y a exécution d'un programme ( bash ou sh ou csh ou tcsh
ou ksh ou ... en fonction de ce qui est défini dans le fichier /etc/passwd)
Objectif:
Traduire les commandes saisies par l'utilisateur afin que le système puisse les exécuterCatégories de commandes:
Commandes définies par un alias (pas d'exécution de programme associé à la commande)
alias ls='ls -F' en bash
alias rmi rm -i en c-shell
Commandes internes au shell (pas d'exécution de programme associé à la commande)
set, cd, echo, pwd, alias, ...
Commandes externes indépendantes du shell (elles sont dans /usr/bin, /bin , ...) , il y a
exécution d'un programme associé à la commande
cp, rm, ls, ...Les variables de l'interpréteur
Variables globales de l'interpréteur
Variables internes: connues uniquement de l'interpréteur
Variables d'environnement: connues de l'interpréteur et des
commandes lancées à partir de l'interpréteur
exemples:
PATH
PROMPT
HOME
PRINTER
LOGNAME
SHELL
DISPLAYEn Bourne-shell (Bash)
Affectation d'une variable interne
nom-variable=valeur
HOME=/home/xstra
PATH=/bin:/usr/bin:/usr/contrib/bin
x=3
RDV=monagenda
La déclarer comme variable d'environnement
export nom-variable
IMPRIMANTE=laser
export IMPRIMANTE
Lecture
set affiche toutes les variables et leur valeur
env et printenv affichent uniquement les variables d'environnement
Utilisation
$nom-variable
echo $IMPRIMANTE
laser
Suppression
unset nom-variable
unset IMPRIMANTEEn C-shell Affectation d'une variable interne set nom-variable = valeur set home=/home/xstra set path=/bin:/usr/bin:/usr/contrib/bin Affectation d'une variable d'environnement (par convention en majuscules) setenv nom-variable valeur ex: setenv IMPRIMANTE laser Lecture set affiche toutes les variables internes et leur valeur setenv et printenv affichent uniquement les variables d'environnement Utilisation $nom-variable Suppression unset nom-variable ex: unset path unsetenv nom-variable unsetenv * supprime toutes les variables d'environnement
Liens avec le C Par le main: Le paramètre arge est un tableau de chaînes "nom-variable=valeur" int main (int argc, char *argv[], char *arge[]); argc : nombre d'arguments argv : les arguments arge : variables d'environnement Exemple: essai 1 2 trois à l'entrée du programme essai argc = 4 argv = ""essai" "1" "2" "trois"" arge = ""PATH=/bin:/usr/bin:/usr/contrib/bin" "IMPRIMANTE=laser" ..."
Les fichiers d'initialisation
En bourne-shell:
/etc/profile fichier commun à tous les utilisateurs exécuté à la connexion
.bash_profile fichier de l'utilisateur (dans son répertoire d'accueil) exécuté à la connexion
.bashrc fichier de l'utilisateur (dans son répertoire d'accueil) exécuté à chaque bash
.bash_logout exécuté à la sortie de la session
PS1="`hostname`:`whoami`>"
PATH=/bin:/usr/bin:/etc:/usr/contrib/bin:.
LOGNAME=`whoami`
...
En C-shell:
.login exécuté à la connexion (définition des variables d'environnement,
initialisation de la variable TERM)
.cshrc exécuté à chaque exécution d'un c-shell (csh) (définition et initialisation des
variables internes au c-shell, définition des alias)
.logout exécuté à la sortie de la session
exemple d'un .cshrc: exemple d'un .logout
set path=(/bin /usr/bin /etc/usr/local/bin) echo "********** fin de session **********"
set mail=(10 /usr/mail/`whoami`) find $HOME -name core -exec rm{}\;
set prompt='LinuxIUT>'
...
alias del 'rm -i'
alias dir 'ls -l'7. Le cycle programme
Introduction
du code source à l'exécutable
Hiérarchie des langages
langage machine
langage d'assemblage
langages évolués
Traducteurs
code source ====> code cible
Programme-fichiers
avec un fichier principal
(Notion de projet)Du source à l'exécutable
1. Compilation ==> Résultat = programme objet
Pré-compilation (fichier par fichier) (Le résultat est encore en langage source)
Traitement des macros (#define, #include, ...)
Traduction du code source en langage d'assemblage (fichier par fichier)
Références externes (ex: appels de fonctions externes)
Références relogeables
références absolue (ex: mov ax, data (reférence absolue))
références à du code dont la position dans le programme complet est non connu (par exemple un
branchement)
Assemblage (fichier par fichier)
langage d'assemblage ==> langage machine
création des en-têtes
2. Edition des liens (tous les fichiers ensemble) ==> Résultat = Prog. exécutable
Résolution des références externes
Ajout des bibliothèques
Les références absolues non encore résolues
3. Chargement
Déterminer une adresse de chargement en mémoire centrale pour le programme exécutable
Résolution des références absolues
Saut au point d'entréeLe portage
Les erreurs Compilation: erreurs de syntaxe (ex: oubli d'une } ou d'un ;) Edition des liens: problèmes de références externes (ex: oubli d'une bibliothèque) Exécution: problèmes de conception (ex: boucle infinie)
Variables en mémoire
Portée + Durée de vie = classe de variable
En langage C:
Portée
variable dans un bloc: Variable locale au bloc
variable hors de tout bloc: Variable globale à un fichier (static) ou à plusieurs fichiers
(extern ou rien)
Durée de vie
automatique: allouée sur la pile, espace libéré si plus accessible
statique: espace réservé jusqu'à la fin de l'exécution alloué en zone des données
Variable locale: automatique ou statique (si static)
Variable globale: nécessairement statique
Fonctions: statiques et globales
Cas particulier: Allocation dynamique en zone des données (ex: malloc)Exemples
_________________________________________________________________________________________________________________________
/* fichier mymain.c */
extern int tab[ ]; globale à tout le programme, statique, pas d'espace réservé
int i,j=0; variables globales à tout le programme et statiques. Pour i, espace réservé en zone des données non
initialisées et zone des données initialisées pour j.
int code(int c); fonction globale à tout le programme, définie dans un autre fichier
....
_________________________________________________________________________________________________________________________
/* fichier util.c */
int tab[50]; variable globale à tout le programme et statique. 50 entiers en zone des donnés non initialisées
static int aux[29]={11,32,53,...}; variable globale au fichier util.c et statique. 29 entiers en zone des données initialisées
int code (int c) fonction globale à tout le programme et statique
{
static int num; variable locale à code et statique, espace réservé en zone des données jusqu'à la fin de l'exécution.
int temp; variable locale à code et automatique alloué sur la pile
...
}8. Les processus
Introduction
Un processus est une abstraction d'un programme en exécution ou encore
Un processus est un objet indépendant associé à un programme en exécution
exemples:
more toto création d'un processus en avant plan associé à la commande more
emacs titi & création d'un processus en arrière plan associé à l'éditeur emacs
essaitd1 & création d'un processus en arrière plan associé à l'exécutable essaitd1
à un même programme peut être associé plusieurs processus: par exemple le compilateur ou un
programme de réservation de billets SNCF
Chaque processus a son propre compteur ordinal, ses propres registres, ses variables, son
pointeur de pile, ses fichiers ouverts, ...
On trouve les processus sur les systèmes multitâches.
Multitâches = plusieurs tâches (processus) peuvent s'exécuter en "même temps"
exemples: UNIX, OS2, Windows NT, Windows 2000, VMS
Sur un système multitâches toute unité d'exécution est un processus (tout est processus)
exemple: les DAEMONS sont des processus système en attente de requête à traiter (IMP,
MAIL, ...)
Donc les programmes système + programmes utilisateurs en exécution sont un ensemble de
processus qui naissent, vivent leur vie, communiquent et meurent...Le parallélisme
"Indépendance", en "même temps" indiquent un certain parallélisme d'exécution
Deux types de parallélisme:
Le "vrai" parallélisme: deux activités au même instant
Plusieurs UC
Entrées-sorties // UC
Le "pseudo" parallélisme: partage de l'UC entre les processus
Récupérer le temps des entrées-sorties
Temps partagé: allouer l'UC par tranche de temps
Les processus sont des spécialistes indépendants qui coopèrent
éventuellement avec d'autres processus.
Toute la difficulté réside dans la communication des processus, leur
synchronisation et le partage des ressources (UC, disques, mémoire,
etc.)Utilité
Au niveau système
simplification de la conception: ensemble de spécialistes qui interagissent
maintenance: si problème, cf. le spécialiste associé
clarté et visibilité: chaque service (ensemble de processus) est clairement défini avec des
noms clairs et parlants
adaptation: ne pas utiliser une partie du système => ne pas exécuter les spécialistes
associés
performances: grâce au parallélisme. Un processus met à jour des données sur un disque
pendant qu'un autre affiche des données à l'écran et qu'un autre enfin envoie un mail
exemple: 2 programmes
P1 = lecture disque (50) + exécution (100) + impression (100)
P2 = exécution (50) + impression (50) + lecture disque (50) + exécution (100)
tps total = P1 + P2 = 500 si aucun parallélisme
tps total = P1 || P2 = 250 si parallélismeAu niveau utilisateur
Aspects génie logiciel (1 processus = un spécialiste)
maintenance
réutilisabilité
clarté du code
Performances: grâce au parallélisme
Transparence / réseaux: exemple du client-serveur Xwindow
exemple:
trier le fichier f1 sur le disque 1 = 100
trier le fichier f2 sur disque 2 = 100
fusionner f1 et f2 en f3 = 50
Un seul processus plusieurs processus
trier(f1) créerprocessus(trier f1)
trier(f2) créerprocessus(trier f2)
fusionner(f1,f2) attendre fin des tris
fusionner(f1,f2)
temps = 250 temps = 150Problèmes
Communiquer: Des processus qui coopèrent doivent pouvoir communiquer, se synchroniser
Partager les ressources: Des processus partagent l'UC, la mémoire, des fichiers, des variables, ...
exemple:
==> deux primitives de synchronisation de processus: P (pour réserver une ressource) et V (pour
la libérer)
exemple:
P(place); se-garer; pour occuper la place si elle est libre, en attente si place occupée
V(place); pour libérer la place, débloque le premier processus bloquéPartage de l'UC activer: Donner l'UC. C'est l'ordonnanceur qui s'occupe de choisir un processus prêt. désactiver: Le processus a utilisé son crédit d'UC mise en attente: le processus attend un évènement (ex: fin d'entrée-sortie) fin d'attente: l'évènement attendu par le processus est arrivé. ==> 3 états en attente (ou bloqué) prêt (à recevoir l'UC) actif (élu): en exécution
Création d'un processus (sous UNIX)
exécution d'une commande
L'exécution de pratiquement toutes les commandes donne lieu à la création d'un
processus
exemple: cat chapitre1 chapitre2 chapitre3 | grep arbre
==> deux processus qui communiquent à travers un "tube" (pipe).
Dans l'exemple la sortie du cat est l'entrée de grep
grep peut être "en attente" si cat n'a pas produit de lignes ...l'éxécution de tout programme donne lieu à la création d'(au moins) un processus.
le chargement du système donne lieu à la création de plusieurs processus (INIT, MAIL,
IMP ...)
la primitive C fork() permet la création d'un processus clone du père (c'est à dire le processus
associé au programme qui exécute le fork()).
/*programme essai */
main()
{
printf("coucou avant création");
fork();
printf("coucou après creation");
}
$essai
"coucou avant création"
"coucou après création"
"coucou après création"
main () main ()
{fork(); ==> combien de processus? {fork(); ==> combien de processus?
fork();} fork();
fork();}
Chaque processus créé est identifié par un numéro unique: son PIDDistinction père, fils
Grâce à la valeur de retour du fork
Si la valeur de retour est 0 alors c'est le fils
Si la valeur de retour est >0 alors c'est le père (la valeur est le pid du fils)
Si la valeur de retour est 0) {/* c'est le père */}
else {/* c'est le fils (pid ==0) */}
}
La fonction getpid() permet à un fils de connaître son propre PID
La fonction getppid() permet de connaître le PID de son père.
Tous les processus sont organisés sous forme d'un arbre dont INIT est la racine. Chaque
processus a un et un seul père.Changer le code d'un processus
int execlp(const char *path, const char *arg0, ..., const char *argn, char*);
==> Permet de faire exécuter un autre programme à un processus
Attention: Les instructions qui suivent execl ne seront jamais exécutées.
exemple:
main()
{
int pid;
pid = fork();
if (pid < 0) {/* problème */}
else if (pid == 0) { execlp("~/bin/chess","chess",NULL);
printf("coucou");}
printf("coucou je suis le père");
}
==> Le processus fils exécutera le programme exécutable " chess" après l'éxecution de
l'instruction execlp au lieu du programme associé à son père.
==> Le printf("coucou") ne sera pas exécuté.Quelques commandes et fonctions utiles ps: visualiser les processus kill: détruire un processus. exemple: kill 17142 &: lance un processus en arrière plan. exemple:essaitd & ctrl c: détruit le processus qui tourne en avant plan (=kill -9) ctrl z: suspend le processus qui tourne en avant plan jobs: visualiser les travaux (programmes en exécution) qui dépendent d'un shell. fg: fait passer un travail d'arrière plan en avant plan. bg: fait passer un travail d'avant plan en arrière plan. wait: (fonction C) permet à un père d'attendre la terminaison de l'un de ses fils. sleep(T): (fonction C) suspend un processus pendant un temps T.
9. Programmer en shell
Introduction
Le shell est à la fois un interpréteur de commande et un langage de programmation
Un fichier en langage shell est un script (fichier de commandes)
Le langage shell:
instructions
variables
Instructions
Toutes les commandes UNIX
L'invocation de programmes exécutables (ou de scripts) avec passage de paramètres
Assignation de variables
Instructions conditionnelles et itératives
Instructions d'entrée-sortie
Remarques
Le shell est un langage interprété
Il est possible d'invoquer un script dans un shell (ex: csh) à partir d'un autre type de shell (ex:
bash)
La première ligne d'un script doit être le nom du shell qui doit être invoqué (ex: #!/bin/bash)Le langage bash
Avantages du bash
Syntaxe riche
Compatible avec le Bourne shell
Définitions de fonctions
Gestion de l'historique
Utilisation des alias
Utilisation des tableaux
Plus fiable que le csh
Évaluation d'expressions arithmétiques facile
Inconvénient: Une certaine lenteur d'exécution, comme tous les shells
Syntaxe (complémentaire) du bash
Lecture d'une variable
read variable
>read a
bonjour
>echo $a
bonjour
Création d'un alias
salias nom=valeur
>alias rm='rm -i'
>alias cx='chmod u+x'
>cx totoTableaux de variables (listes)
liste=(... ... ... ...)
>arbres=(acacia sapin meloze aulne hêtre chêne)
>echo ${arbres[*]}
acacia sapin meloze aulne hêtre chêne
>echo $arbres[3]
aulne
>echo ${#arbres[*]}
6
Structures de contrôle (1=vrai 0=faux): une expression booléenne de contrôle est sous la
forme [[ exp ]] ou (( exp )) pour les expressions arithmétiques
If expression case valeur in
then label) commandes ;;
commande ...
... [*) commandes ]
[elif expression ; then esac
commande
...] while expression
[else do
commande commande
...] ...
fi done
for nom in liste for expression
do do
commande commande
... ...
done doneLes tests sur les fichiers -x nom l'utilisateur a-t-il le droit en exécution? -r nom l'utilisateur a-t-il le droit en lecture? -w nom l'utilisateur a-t-il le droit en écriture? -e nom existe-il? -O nom l'utilisateur est-il propriétaire? -s nom est-il non vide? -f nom est-il standard? -d nom est ce un répertoire? Passage de paramètre $1 ... $n paramètres $0 le nom du script $* la liste des paramètres ($1 ... $n) $# le nombre de paramètres Opérations arithmétiques (( … )) + - * / ... x=32 y=8 (( z=$x + $y )) echo $x $y $z 32 8 40 echo $(( $x + $y + $z )) 80
Exemples de scripts
script essaipar Script essaifor
#!/bin/bash #!/bin/bash
echo $0 a été appelé avec $# paramètres for x in $*
echo qui sont : $* do
echo $x
done
essaipar a b 1 2
essaipar a été appelé avec 4 paramètres
qui sont : a b 1 2
script essaific script essaiarith
#!/bin/bash #!/bin/bash
if [[ $1 == "" ]] for (( x=0 ; xFIN
Vous pouvez aussi lire
