 |
VOOZH | about |
|
VOOZH | about |
Unix (ou UNIX) est un système d'exploitation multi-tâche et multi utilisateur créé à partir de 1969 dans un laboratoire de recherche d'AT&T (American Telephone & Telegraph). Il s'agissait de concevoir un système d'exploitation plus simple que MULTICS sur lequel ils avaient travaillé.
Dans les années 60, le Massachusetts Institute of Technology, l'entreprise General Electric et les laboratoires Bell d’AT&T ont travaillé ensemble à la réalisation d'un système d’exploitation ayant pour nom MULTICS. Mais ce système d'exploitation très novateur se révèle trop compliqué à concevoir et son étude est abandonnée.
Toutefois Ken Thompson qui travaille à AT&T a l'idée de créer un système d'exploitation plus simple qui reprendra certaines idées de MULTICS. Dennis Ritchie puis plus tard Brian Kernighan s'associent à ce projet.
Le nom du nouveau système d'exploitation UNICS est choisi par Brian Kernighan. C'est un jeu de mots. MULTICS étant l'abréviation de Multiplexed Information and Computing Service, leur nouveau système d'exploitation plus simple ne sera pas multiplexé 👁 Image
mais seulement uniplexé.
Par la suite, UNICS sera écrit UNIX.
Au début, UNIX est écrit en assembleur. Le problème est que ce langage est très lié au matériel sur lequel le logiciel est exécuté. Or, les concepteurs d'UNIX veulent créer un système d'exploitation utilisable sur un grand nombre de modèles d'ordinateurs. Ils essaient plusieurs langages de programmation parmi lequel le BCPL qu'ils adaptent pour créer le langage B, et à partir de là Dennis Ritchie crée le langage C qui est encore employé de nos jours.
UNIX est alors réécrit entièrement en langage C en 1972.
À partir de 1975, UNIX est vendu avec son code source aux universités américaines dans un but éducatif. Bill Joy, l'un des étudiants de l'université de Berkeley crée alors la version d'UNIX appelée BSD (Berkeley Software Distribution) qui sera utilisée à partir de 1982 sur les ordinateurs de marque Sun.
En 1978, UNIX est adapté à un modèle d'ordinateur 32 bits, le Interdata 8/32.
En 1983, une décision de justice met fin à l'interdiction pour AT&T de vendre autre-chose que du matériel de télécommunications. AT&T réalise alors UNIX System V et le vend aux entreprises. Cependant, la licence d'utilisation de AT&T coûte cher et la licence BSD est plus abordable.
En 1985, la version BSD inclue le protocole TCP/IP pour les communications en réseau. UNIX System V ne le fera que plus tard.
Entre 1989 et 1994, les morceaux de programme venant d'AT&T dans le code source de la version BSD sont réécrits. BSD peut vendre sa version d'UNIX sans rien devoir à AT&T. Mais d'autres versions d'UNIX gratuites sont aussi créées à partir de la version BSD.
À partir de 1983, Richard Stallman travaille à la réalisation d'un UNIX libre. C'est le projet GNU. Les programmes utilitaires d'UNIX sont réécrits. Par contre, il y a des difficultés pour faire fonctionner ces logiciels sur un PC à cause de particularités de fonctionnement des microprocesseurs Intel.
À partir de 1987. Minix est développé et diffusé à des fins éducatives par Andrew Tanenbaum. Il est destiné à du matériel d'informatique embarquée. Cependant, en se basant sur Minix, en 1990 Linus Torvalds écrit un noyau 👁 Image
adapté aux PC qui sera appelé Linux.
Le noyau Linux combiné avec les logiciels GNU constituent un système d'exploitation complet dérivé d'UNIX.
D'autres systèmes d'exploitation comme MacOS sont aussi dérivés d'UNIX.
Unix a été créé à une époque où les ordinateurs étaient volumineux et coûtaient cher. Pour communiquer avec l'ordinateur, on utilisait un télétype, c'est à dire un appareil composé d'un clavier et d'une imprimante. Plus tard, l'imprimante sera remplacée par un écran.
Par rapport au prix des ordinateur, les télétypes n'étaient pas trop chers. Du coup, on pouvait en brancher plusieurs sur l'ordinateur afin que plusieurs personnes puissent utiliser l'ordinateur en même temps.
Pour cette raison, sur Unix, on définit des utilisateurs et des groupes d'utilisateurs. Il existe un fichier qui a pour nom qui définit tous les utilisateurs connus du système d'exploitation à raison d'un utilisateur par ligne.
Chaque ligne de contient plusieurs informations séparées les unes des autres par le caractère : Ce sont
Il existe aussi un fichier similaire pour les groupe d'utilisateurs appelé
Toutefois, pour que plusieurs utilisateurs puissent utiliser l'ordinateur en même temps, il faut que le système d'exploitation s'occupe de tous ces utilisateurs. Unix est donc aussi un système d'exploitation multi-tâche. Il fonctionne en temps partagé. Chaque seconde, Unix travaille un peu pour chacun des utilisateurs qui ont donné à l'ordinateur quelque-chose à faire. Ainsi. même si sur une période de temps très courte, l'ordinateur ne s'occupe que d'un utilisateur, le passage d'un utilisateur à l'autre est suffisamment rapide pour qu'un utilisateur qui n'a pas demandé grand chose n'ait pas besoin d'attendre le résultat.
Sur Unix chaque fichier appartient à un utilisateur (en général, celui qui l'a créé) et à un groupe d'utilisateurs (en général le groupe dont fait partie l'utilisateur qui a créé le fichier). L'uid du propriétaire du fichier et le gid du groupe auquel il appartient sont enregistrés avec le fichier.
À chacun des fichiers sont associés 3 droits d'accès symbolisés par des lettres correspondant à des mots anglais :
Le droit r autorise à lire le contenu du fichier.
Le droit w autorise à modifier le contenu du fichier.
Certains fichier contiennent des scripts ou des programmes exécutables. Mais pour qu'un fichier puisse être exécuté, il faut que le droit x soit indiqué.
Mais tous les utilisateurs n'ont en général pas les mêmes droits sur un fichier particulier. Les droits rwx sont définis séparément pour :
Cela fait en tout 9 droits d'accès à définir pour chaque fichier. C'est le propriétaire du fichier qui fixe ces droits.
Un fichier avec les droits rw-r----- peut être :
Un fichier avec les droits rwxr-x--x peut être :
Les répertoires (équivalents aux dossiers sous Windows) sont des fichier dont le rôle est de contenir d'autres fichiers (et éventuellement des sous-répertoires). Mais la signification des droits d'accès pour les répertoires est légèrement différente de celle des fichiers classiques :
Parmi les utilisateurs d'un système d'exploitation UNIX, il y en a un privilégié : celui dont l'uid vaut 0. Traditionnellement cet utilisateur s'appelle root. On le qualifie de super utilisateur.
Le super utilisateur a le droit :
Les fichiers du système d'exploitation et les répertoires qui les contiennent appartiennent au super utilisateur et ont en général les droits rwxr-x-r-x :
Ainsi, les fichiers du système d'exploitation sont protégé des mauvaises manipulations des utilisateurs (et des virus). Par contre, le super utilisateur doit faire attention à ce qu'il fait.
Pour UNIX, les éléments de l'ordinateur (clavier, imprimante de télétype qui sera remplacée par un écran, disque dur, partition de disque dur, mémoire ...) sont aussi des fichiers. Ils sont stockés dans le répertoire .
Par exemple est le premier télétype. Comme plusieurs télétypes peuvent être connectés à l'ordinateur, les fichiers sont numérotés.
Pour lire ce que l'utilisateur du premier télétype tape sur son clavier, l'ordinateur lit les caractères qui apparaissent dans le fichier .
De son coté, pour faire imprimer du texte par le premier télétype ou afficher ce texte à l'écran, l'ordinateur écrit ce texte dans le fichier .
Les disques durs sous UNIX s'appellent (suivi dune lettre). Par exemple, le premier disque dur est 2. Et comme un disque dur peut être partitionné 👁 Image
, la première partition du premier disque dur s'appelle .
Les logiciels d'UNIX (qui sont écrits en langage C) et contentent de lire le clavier, envoyer des caractères à la télétype ou à l'écran, lire des fichiers du disque dur ou écrire dans ces fichiers grâce à des fonctions du langage C. Ces logiciels n'ont pas besoin de s'occuper d'agir eux-mêmes sur les circuits électronique de l'ordinateur pour récupérer un caractère tapé au clavier, en envoyer un à l'écran ou lire ou écrire dans tel fichier d'un disque dur.
L'accès aux éléments matériels de l'ordinateur est réalisé par une série de programmes qui constituent le noyau.
Pour chaque type de fichier présent dans , le noyau contient une fonction pour envoyer les caractères qui ont été écrits dans le fichier /dev au bon élément matériel pour que ces caractères soient affichés à l'écran ou écrits sur le disque dur.
Il dispose aussi de fonctions permettant de récupérer des caractères sur un périphérique (clavier, disque dur...) et de les écrire dans le fichier associé à ce périphérique afin que le logiciel applicatif puisse à son tour les lire.
Ainsi, si on veut faire fonctionner un logiciel applicatif sur un autre type d'ordinateur, avec des composants électroniques différents, c'est seulement le noyau du système d'exploitation qui devra être adapté au matériel.
UNIX existait bien avant les clés USB contrairement à Linux qui est plus récent mais qui fonctionne selon le même principe. À l'origine aussi, Linux ne permettait d'écrire des fichiers que sur un disque dur. Lorsque les clés USB sont apparues, il a suffit de rajouter dans le noyau les fonctions pour les lire et y écrire dessus. Par contre, les logiciels applicatifs n'ont pas besoin de s'occuper du type d'élément matériel sur lequel sont les fichiers.
Les commandes UNIX sont surtout des programmes écrits en langage C. Il utilisent 3 types d'entrées-sorties qu'on appelle les entrées-sorties standard.
Les programmes C font la distinction entre les messages normaux, lorsque le programme fonctionne bien (sortie standard) et les messages d'erreur (sortie erreur) lorsqu'il y a un problème, par exemple un fichier manquant ou inaccessible à cause de ses droits d'accès.
Toutefois, sous UNIX, rien n'interdit d'utiliser des fichiers en entrée et/ou en sortie à la place du clavier et de l'écran. La redirection des entrées-sorties le permet.
Les symboles < et > permette d'indiquer les noms des fichiers qu'on veut utiliser en entrée ou en sortie.
| Symboles | Redirection effectuée | Si ce fichier de sortie existait déjà |
|---|---|---|
| < | utilise le fichier qui suit le < à la place du clavier comme entrée standard | |
| > | écrit la sortie standard dans le fichier qui suit le > | ancien contenu du fichier supprimé |
| >> | écrit la sortie standard dans le fichier qui suit le >> | sortie standard rajoutée à l'ancien contenu du fichier |
| 2> | écrit la sortie erreur dans le fichier qui suit le 2> | ancien contenu du fichier supprimé |
| 2>> | écrit la sortie erreur dans le fichier qui suit le 2>> | sortie erreur rajoutée à l'ancien contenu du fichier |
| 2>&1 | envoie la sortie erreur sur la sortie standard | |
| 1>&2 | envoie la sortie standard sur la sortie erreur (pas vraiment utile) | |
| `commande` | le résultat d'exécution de la commande devient un paramètre d'une autre commande |
Remarque : Les 3 premières redirections, ainsi que le tube mentionné au chapitre suivant existaient aussi sous MS-DOS qui est un système d'exploitation plus récent qu'UNIX.
Il existe un autre symbole de redirection qui est le | et qui permet d'enchaîner l'exécution de plusieurs commandes. Lorsqu'on a :
commande1 | commande2
La commande commande1 est exécutée en premier, mais au lieu d'envoyer sa sorte standard à l'écran, elle l'envoie comme entrée standard à commande2. Et donc, le résultat de l'exécution de commande1 sert de données en entrée pour commande2.
On peut enchaîner plus de deux commandes en utilisant plusieurs |
Unix permet aussi de garder en mémoire des informations dans des variables.
Il y a au moins 2 variable pre-définies :
Exemples
PATH=/bin:/usr/bin:/usr/local/bin:/user/bernard/bin:.
Avec cette valeur de PATH, les commandes exécutables seront cherchées dans :
Si la commande est disponible à plusieurs endroits, c'est la première version trouvée qui est exécutée> Si elle n'est trouvé à aucun de ces endroits, il y aura un message d'erreur.
Au départ, PS1 contient $ pour un utilisateur normal et # pour le super utilisateur root. La commande echo permet d'afficher du texte et pour accéder au contenu d'une variable en met un $ avant son nom.
Voici un exemple d'exécution. Pour plus de lisibilité, ce qui est en bleu est affiché par l'ordinateur et ce qui est en noir est tapé par l'utilisateur.
$ $ PS1="Tape une commande : " Tape une commande : echo Maintenant mon prompt est : $PS1 Maintenant mon prompt est : Tape une commande : Tape une commande : PS1="$ " $
En dehors des variables pré-définies, l'utilisateur peut déclarer d'autres variables pour mémoriser ce qu'il veut.
Unix comporte plus d'une centaines d'outils. La plupart font peu de choses. C'est en combinant ces outils qu'on peut réaliser des traitements quelquefois très complexes.
| outil | Action effectuée |
|---|---|
| echo | Affiche le texte précisé en paramètre |
| cat | Affiche ce qui est envoyé sur l'entrée standard ou le contenu du fichier passé en paramètre |
| cp | Permet de copier un fichier ailleurs ou sous un autre nom |
| mv | Permet de déplacer un fichier ou de changer son nom |
| ln | Permet de cloner un fichier (le même fichier existera sous plusieurs noms ou à plusieurs endroits) |
| ls | Permet de lister les fichier présents |
| rm | Permet de détruire un fichier |
| rmdir | Permet de détruire un répertoire s'il est vide |
| mkdir | Permet de créer un répertoire |
| cd | Permet de changer de répertoire |
| pwd | Indique dans quel répertoire on est |
| find | Permet de chercher des fichier en fonction de leur nom, leur taille, leur propiétaire ou groupe, les droits d'accès... |
| cpio | Permet de copier une liste de fichiers fournis par la commande find |
| fgrep | Affiche les ligne de l'entrée standard ou des fichiers qui comportent (ou ne comportent pas) la chaîne da caractères indiquée |
| grep, egrep | Même principe que fgrep mais la chaine de caractères cherchée peut contenir des parties variables |
| sed | Permet de remplacer certaines données du fichier par autre-chose |
| head | Affiche les premières lignes d'un fichier (ou de l'entrée standard) |
| tail | Affiche les dernières lignes d'un fichier (ou de l'entrée standard) |
| pg ou more | Affiche un morceau des données (ce qui correspond à une page d'écran) et attend que l'utilisateur demande la suite en tapant au clavier |
| cut | Affiche seulement la partie indiquée des lignes d'un fichier (ou de l'entrée standard) |
| paste | Affiche à la suite sur la même ligne le contenu de chaque ligne de plusieurs fichiers |
| wc | Compte les lignes, les mots et les caractères d'une liste de fichiers ou de ce qui arrive sur l'entrée standard |
| tee | Envoie ce qui arrive sur l'entrée standard à la fois sur la sortie standard et dans un fichier |
| diff | Compare 2 fichiers et affiche les différences |
| sdiff | Comme diff mais toutes les lignes des 2 fichiers sont affichées avec l'utilisation des symboles | < et > pour indiquer les lignes différentes et les lignes en plus dans l'un des deux fichiers |
| diff3 | Compare 3 fichiers et affiche les différences |
| vi | éditeur de textes, permet de modifier des fichiers |
| touch | Permet de changer la date de dernière modification d'un fichier, le crée vide s'il n'existe pas encore |
| chmod | Permet de changer les droits d'accès à un fichier ou un répertoire |
| chown | Permet de changer le propriétaire d'un fichier ou d'un répertoire (pour root seulement) |
| chgrp | Permet de changer le groupe d'un fichier ou d'un répertoire |
| du | Indique l'espace disque utilisé par tous les fichiers d'un répertoire |
| df | Indique la taille des différentes partitions du disque dur et leur taux d'utilisation |
| ps | Liste les processus (programmes exécutable) que l'ordinateur exécute en ce moment |
| who | donne la liste des utilisateurs connectés à l'ordinateur |
| L'ancêtre du courrier électronique : permet d'envoyer un message à un utilisateur | |
| sleep | Attend un certain nombre de secondes |
| expr | Fait des calculs simples (additions ou soustractions de nombres entiers) |
| bc | Calculatrice 4 opérations + puissances qui peut travailler avec beaucoup de chiffres |
| man | Décrit le fonctionnement d'un outil ou d'une fonction du langage C |
| lp | Envoie quelque-chose à l'imprimante |
| sh | Interpréteur de commandes |
Mais il y a beaucoup d'autres outils.
Pour exécuter une commande il faut taper :
Les outils qui ont besoin de données en entrée les récupèrent soit sur l'entrée standard, soit en lisant le fichier dont le nom aura été passé en paramètre.
Par défaut, les données produites par l'outil sont envoyées sur la sortie standard (écran) et s'il y a lieu sur la sortie erreur. Mais peut utiliser les redirections et les tubes pour conserver ces données ou les faire traiter par un autre outil.
Les scripts shells existent depuis la version & d'Unix (1977). Ils permettent d'exécuter de manière automatique plusieurs commandes Unix enregistrées dans un fichier. C'est plus simple que d'avoir à taper toutes ces commandes à la main les unes après les autres.
Les scripts shells permettent de tester des conditions et de réaliser des boucles 👁 Image
.
On va créer le fichier salutation avec le contenu suivant :
echo "Salut inconnu, comment tu t'appelle ?" read prenom echo Bonjour $prenom !
Il faut rendre ce fichier exécutable par la commande :
chmod +x salutation
On va maintenant l'essayer.
$ salutation Salut inconnu, comment tu t'appelle ? Bernard Bonjour Bernard ! $
Le texte en noir est affiché par l'ordinateur. Ce qui est en bleu est tapé au clavier par l'utilisateur.
Cet exemple a permit aussi de voir l'utilisation d'une variable d'environnement.
On va maintenant voir un exemple qui traite une condition et utilise une boucle pour le décompte du temps restant.
Les lignes commençant par un # sont des commentaires. Elles donnent des explications à celui qui lit le script shell.
Ce script shell s'appelle
echo "La fusée est elle prête ?" read reponse # on ne garde que le premier caractère de la reponse et on le met en minuscules reponse=`echo $reponse | cut -c1 | tr "[A-Z]" "[a-z]"` # deux cas # si la reponse ne commence pas par la lettre n if [ "$reponse" != "n" ] then # on va faire le compte à rebours final et le lancement # compteur de secondes restantes secondes=10 # boucle du compte à rebours while [ $secondes -gt 0 ] do echo $secondes # attendre une seconde sleep 1 # mettre à jour le nombre de secondes restantes secondes=`expr $secondes - 1` done echo "Décollage !" # Expression de Buzz l'éclair dans les dessins animés Toy Story echo "Vers l'infini ... et au delà !" # sinon else echo "Lancement reporté." fi
Première exécution du script
$ lancement La fusée est elle prête ? Noooon Lancement reporté. $
Deuxième exécution du script
$ lancement La fusée est elle prête ? Bien sur ! 10 9 8 7 6 5 4 3 2 1 Décollage ! Vers l'infini ... et au delà ! $
Portail de l'informatique — Tous les articles sur son histoire, les logiciels, Internet…
|
Portail des techniques — Tous les articles liés à l'information et aux matériaux...
|
