Programmation avancée sous Unix : Partie 1

SOMMAIRE

Connaissances de base et commandes..................................................................... - 3 -

I- Généralités sur Unix......................................................................................- 3 -
1- Système d’exploitation............................................................................... - 3 -
2- Historique ................................................................................................. - 3 -
3- Standards et versions d’unix....................................................................... - 3 -
4- Architecture d’unix.................................................................................... - 4 -
a- Noyau Unix......................................................................................................... - 4 -
b- Shell .................................................................................................................... - 5 -
c- Les processus....................................................................................................... - 5 -
d- Gestion de la mémoire ........................................................................................ - 6 -
II- Systèmes de fichiers sous Unix ......................................................................- 7 -
1- Arborescence ............................................................................................ - 7 -
2- Noms des fichiers ...................................................................................... - 7 -
3- Chemin d’un fichier................................................................................... - 7 -
a- Répertoire parent................................................................................................. - 8 -
b- Répertoire courant............................................................................................... - 8 -
c- Chemin absolu .................................................................................................... - 8 -
d- Chemin relatif...................................................................................................... - 8 -
4- Types de fichiers........................................................................................ - 8 -
5- Commandes sur le système de fichiers ....................................................... - 8 -
a- Commande pwd.................................................................................................. - 8 -
b- Commande cd..................................................................................................... - 8 -
c- Création et suppression de fichiers et répertoires................................................. - 8 -
d- Copie de fichiers et répertoires............................................................................ - 9 -
e- La commande ls .................................................................................................. - 9 -
6- Modification droits d'accès avec chmod ...................................................- 11 -
a- Commande chmod............................................................................................ - 11 -
b- Représentation symbolique ............................................................................... - 11 -
c- Représentation octale ........................................................................................ - 11 -
d- Commande umask............................................................................................. - 12 -
III- Manipulation des fichiers ............................................................................- 13 -
1- Affichage du contenu d’un fichier .............................................................- 13 -
a- Commande cat .................................................................................................. - 13 -
b- Commandes more et less................................................................................... - 13 -
c- Commandes head.............................................................................................. - 13 -
d- Commande tail .................................................................................................. - 13 -
e- Commande nl.................................................................................................... - 14 -
f- Commande wc .................................................................................................. - 14 -
2- Manipulation de fichiers avec grep ...........................................................- 14 -
3- Recherche de fichiers dans l'arborescence ................................................- 14 -
a- Utilisation de la commande find ....................................................................... - 14 -
b- Utilisation de la commande locate .................................................................... - 15 -
IV- Commandes d’observation du système ........................................................- 15 -
1- Date et heure ...........................................................................................- 15 -
2- Nom de l’ordinateur .................................................................................- 15 -

-1-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

3- Nom du système d’exploitation ................................................................- 15 -

4- Information sur les utilisateurs ..................................................................- 15 -
a- Les commandes who et whoami ....................................................................... - 15 -
b- La commande finger.......................................................................................... - 15 -
5- Espace disque occupé : du........................................................................- 15 -
6- Place libre d’un système de fichiers : df ....................................................- 16 -
V- Commande pour la gestion des processus....................................................- 17 -
1- Caractéristiques d’un processus ................................................................- 17 -
2- Commandes .............................................................................................- 18 -
a- La commande top.............................................................................................. - 18 -
b- La commande ps ............................................................................................... - 18 -
c- La commande pstree ......................................................................................... - 19 -
d- La commande kill .............................................................................................. - 19 -

-2-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

CONNAISSANCES DE BASE ET COMMANDES

I- GENERALITES SUR UNIX

1- Système d’exploitation
Unix est un système d’exploitation.
Un système d’exploitation est un logiciel qui fournit un environnement d’exécution
pour les programmes qui vont s’exécuter sur l’ordinateur. Il doit gérer en particulier les
ressources que vont se partager les programmes. Il a, entre autres, la charge des
fonctions suivantes, essentielles pour la bonne marche d’un ordinateur :
• gestion du processeur
• gestion de la mémoire centrale
• gestion du système de fichiers
• gestion des périphériques

Un ordinateur ne peut fonctionner sans système d’exploitation. Un ordinateur donné

peut fonctionner avec plusieurs systèmes d’exploitation ; par exemple, certains PC
permettent à l’utilisateur de travailler sous Unix ou sous Windows.
UNIX est un système d’exploitation moderne, complet et efficace, disponible sur la
plupart des ordinateurs vendus, du PC au super calculateur Cray. C’est pourtant un
système ancien, puisque son histoire remonte à la fin des années 60. Son architecture
ouverte et sa grande diffusion dans les centres de recherches et les universités lui ont
permis d’évoluer en intégrant de nombreuses améliorations.
Aujourd’hui, UNIX est très utilisé en informatique scientifique, et pour les serveurs
réseaux : la grande majorité des serveurs sur Internet fonctionnent sous UNIX. Par
contre, sa relative complexité d’utilisation l’écarte des applications grand public.

2- Historique
1969 : Ken Thompson écrit Unix en assembleur dans les laboratoires de Bell (AT&T)
1973 : Dennis Ritchie et Ken Thompson réécrivent Unix en langage C (seulement 10%
en assembleur)
1974 : Unix est distribué aux universités américaines
1975 : Première version d’unix commercialisée (licence pour le code source ; version 6)
1977 : Unix BSD (Berkeley Software Development) 1.0 de l’université de Berkeley au
Etats-Unis
1979 : Unix Version 7. Commercialisation d’une licence binaire (moins onéreuse que la
licence pour le code source)
1984 : Unix Système V
1991 : Unix OSF/1

3- Standards et versions d’unix

Depuis la fin des années 70, il existe deux grandes familles d’UNIX. D’une part une
version développée essentiellement par l’université de Berkeley (Californie), et nommée

-3-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

UNIX BSD, d’autre part l’UNIX Système V commercialisé par ATT. De nombreuses
autres versions ont vu le jour, qui sont le plus souvent une adaptation de BSD ou
Système V par un fabriquant particulier :
• AIX IBM, Bull (stations de travail, mainframes) ;
• HP/UX Hewlett-Packard (stations) ;
• SCO Unix SCO (PC) ;
• OSF/1 DEC ;
• Solaris Sun MicroSystems (stations Sun et PC) ;
• GNU/Linux Logiciel libre (et gratuit).
Ces différentes versions possèdent quelques incompatibilités. Pour y remédier, une
norme a été proposée par l’IEEE, le système POSIX. La plupart des versions modernes
d’UNIX sont des sur-ensembles de POSIX ; un programme écrit en respectant POSIX
sera donc portable sur toutes ces versions.
Les premières versions d’UNIX ne permettaient que le travail sur des terminaux
alphanumériques (il n’en existait pas d’autres à l’époque). Un grand pas en avant a été
fait avec le développement au MIT du système X Windows (X11).
Ce système permet le multifenêtrage sur écran graphique et le développement
d’interfaces utilisateurs sophistiquées et “conviviales” (inspirées du Macintosh).
De nombreux environnements graphiques sont maintenant disponibles : Motif,
OpenLook (Sun), KDE, Gnome, etc.
Linux est une version libre d’UNIX (le code source du système est disponible
gratuitement et redistribuable) qui connait actuellement un grand succès, tant chez les
utilisateurs particulier (en tant qu’alternative à Windows) que sur pour les serveurs
Internet/Intranet. Linux est diffusé par différentes sociétés ou organisations, sous formes
de distributions qui utilisent le même noyau (ou presque) et organisent de diverses
façons le système (packages, mises à jour, etc). Les distributions les plus répandues sont
Red Hat, Suse, Caldera, Debian, Slackware et Mandrake (à l’origine issue de Red Hat) et
s’adressent chacune à différents types d’utilisateurs

4- Architecture d’unix
Unix est un système d’exploitation
• d’usage général
• multi-utilisateurs
• multi-tâches
• interactif
• orienté temps partagé
• portable
• dont les systèmes de fichiers sont hiérarchisés en arbre
• qui offre une compatibilité totale des entrées/sorties (pour Unix, les
périphérique sont des fichiers)
• pour lequel il est très facile d’ajouter de nouvelles commandes sans modifier le
noyau (grâce à la grande puissance des langages des shells)
a- Noyau Unix
Le noyau est le programme qui assure la gestion de la mémoire, le partage du
processeur entre les différentes tâches à exécuter et les entrées/sorties de bas niveau. Il
est lancé au démarrage du système (le boot) et s’exécute jusqu’à son arrêt. C’est un
programme relativement petit, qui est chargé en mémoire principale.

-4-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

Le rôle principal du noyau est d’assurer une bonne répartition des ressources de
l’ordinateur (mémoire, processeur(s), espace disque, imprimante(s), accès réseaux) sans
intervention des utilisateurs. Il s’exécute en mode superviseur, c’est à dire qu’il a accès à
toutes les fonctionnalités de la machine : accès à toute la mémoire, et à tous les disques
connectés, manipulations des interruptions, etc.
Tous les autres programmes qui s’exécutent sur la machine fonctionnent en mode
utilisateur : il leur est interdit d’accéder directement au matériel et d’utiliser certaines
instructions. Chaque programme utilisateur n’a ainsi accès qu’à une certaine partie de la
mémoire principale, et il lui est impossible de lire ou écrire les zones mémoires
attribuées aux autres programmes.
Lorsque l’un de ces programmes désire accéder à une ressource gérée par le noyau, par
exemple pour effectuer une opération d’entrée/sortie, il exécute un appel système. Le
noyau exécute alors la fonction correspondante, après avoir vérifié que le programme
appelant est autorisé à la réaliser.
b- Shell
Le shell est l’interpr_teur de commandes. Quand un utilisateur tape des commandes
Unix, ces commandes sont lues par le shell qui effectue éventuellement des traitements
avant de lancer l’exécution de la commande. Le shell est une couche logicielle bien
séparée du noyau. Il existe plusieurs shells UNIX : C-Shell (csh ou tcsh), Bourne Shell
(sh ou bash), Korn shell (ksh), .... L’interprétation des commandes simples est semblable
pour tous ; par contre l’utilisation pour écrire des scripts diffère beaucoup (définition des
variables, structures de contrôle, etc).
Les variantes tcsh et bash apportent un plus grand confort d’utilisation en mode
interactif (historique, terminaison automatique des commandes, etc) ; tcsh est
compatible avec csh, et bash avec sh.
Le point commun à tous les shells est l’emploi d’une syntaxe concise mais obscure et
difficilement mémorisable, rendant leur apprentissage difficile (mais leur usage assez
divertissant à la longue !). Il est difficile d’administrer finement un système UNIX sans
posséder quelques bases sur sh et csh, car de nombreux scripts de configuration sont
écrits dans ces langages. La tendance actuelle est de généraliser l’emploi d’interfaces
graphiques, qui restent toutefois moins souples et puissantes que les scripts.
c- Les processus
UNIX est un système multi-tâches, ce qui signifie que plusieurs programmes peuvent
s’exécuter en même temps sur la même machine. Comme on ne dispose en général que
d’un processeur, à un instant donné un seul programme peut s’exécuter. Le noyau va
donc découper le temps en tranches (quelques millièmes de secondes) et attribuer
chaque tranche à un programme. On parle de système en temps partagé. Du point de
vue des programmes, tout se passe comme si l’on avait une exécution réellement en
parallèle. L’utilisateur voit s’exécuter ses programmes en même temps, mais d’autant
plus lentement qu’ils sont nombreux.
On appelle processus un programme en cours d’exécution. A un instant donné, un
processus peut être dans l’un des états suivants :
• actif : le processus s’exécute sur un processeur (il n’y a donc qu’un seul
processus actif en même temps sur une machine mono-processeur) ;
• prêt : le processus peut devenir actif dès que le processeur lui sera attribué par le
système ;

-5-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

• bloqué : le processus a besoin d’une ressource pour continuer (attente

d’entrée/sortie par exemple). Le blocage ne peut avoir lieu qu’à la suite d’un
appel système. Un processus bloqué ne consomme pas de temps processeur ; il
peut y en avoir beaucoup sans pénaliser les performances du système.
Remarque : le passage de l’état actif à l’état prêt (interruption) est déclenché par le
noyau lorsque la tranche de temps allouée au processus s’est écoulée. Concrètement, le
noyau programme dans ce but une interruption matérielle. Ceci implique que toute
section d’un programme utilisateur peut se voir interrompue n’importe où ; les
processus n’ont bien sûr pas accès aux instructions de masquage d’interruptions.
Toute opération critique (ininterruptible) devra donc être réalisée dans le noyau, un
processus y accédant via un appel système.

d- Gestion de la mémoire
Le système UNIX fonctionne en mémoire virtuelle paginée. Ceci permet de faire
fonctionner des processus demandant une quantité d’espace mémoire supérieure à la
mémoire physique installée.
Lorsqu’un processus demande l’allocation d’une page de mémoire et qu’il n’y en a pas
de disponible en mémoire centrale, le noyau traite un défaut de page. Il choisit une
page (qui n’a pas été utilisé depuis longtemps) et l’écrit sur une partition spéciale du
disque dur. La place libérée est alors attribuée au processus demandeur.
Ce mécanisme demande la réservation d’une (ou plusieurs) partition spéciale sur l’un
des disques durs, nommée partition de swap. La mémoire disponible pour les processus
est donnée par la somme de la taille de mémoire physique (RAM) et des partitions de
swap. Bien entendu, les performances du système se dégradent lorsque la fréquence des
défauts de page augmente ; dans ce cas, il faut augmenter la mémoire physique.

-6-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

II- SYSTEMES DE FICHIERS SOUS UNIX

1- Arborescence
Les fichiers d’unix sont enregistrés dans un ensemble structuré hiérarchiquement en
arbre, appelé système de fichiers. Un système de fichiers est composé d’une racine et de
nœuds qui sont des fichiers répertoires ; ces fichiers contiennent des références, d’autres
fichiers, et des fichiers ordinaires qui contiennent des données et des programmes.
L’arborescence totale ressemble à l’arborescence de la figure suivante :

2- Noms des fichiers

Sous Unix (et contrairement au Dos), tous les caractères alphanumériques plus la
ponctuation sont des caractères valides. De plus il n'existe pas de notion d'extension de
fichier. Cela fait du caractère. (point) un caractère comme un autre qui peut apparaître
plus d'une fois dans un nom de fichier. Par contre l'espace est considéré comme un
séparateur à proscrire dans le nommage des fichiers. Le système Unix n'accepte pas les
caractères accentués et distingue les minuscules des majuscules.
Exemples :
• MonFichier.c et monfichier.c ne représentent pas les mêmes fichiers
• x.y...z. est un nom de fichier valide sous Unix
• tp6-01/2010.c est valide
• _AA_ l'est aussi

3- Chemin d’un fichier

Un fichier est localisable sans ambigüité (de façon exacte et unique) par son chemin. Ce
dernier représente la succession des répertoires à parcourir pour accéder au fichier
(navigation dans l'arbre). Les répertoires sont séparés par un slash noté / dans l'écriture
du chemin (attention, c'est le même symbole qui représente la racine).

-7-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

a- Répertoire parent
Le répertoire parent est celui hiérarchiquement immédiatement supérieure à celui
courant. Il est noté « deux points » ..
b- Répertoire courant
On appelle répertoire courant celui dans lequel on se trouve à un instant donné durant
la navigation dans le système de fichiers. Il est noté point .
c- Chemin absolu
Le chemin absolu désigne la succession des répertoires à parcourir depuis la racine pour
accéder au fichier spécifié.
Exemple : /home/guest/fich1.C pour accéder au fichier fich1.c du système de fichier ou
qu'on se trouve dans le système (représenté dans le schéma plus-haut).
d- Chemin relatif
Le chemin relatif désigne la succession des répertoires à parcourir depuis le répertoire
courant pour accéder au fichier spécifié.
Exemple : ../fich1.c pour accéder au fichier fich1.c lorsqu'on se trouve dans le
répertoire guest. La présence du répertoire parent dans ce chemin relatif permet de
remonter dans l'arbre.

4- Types de fichiers
Nous appelons fichier tout point dans l’arborescence des fichiers. Tous ne
correspondent donc pas à des fichiers de données ordinaires. On distingue 4 types de
fichiers :
– les fichiers ordinaires, qui contiennent des données. UNIX ne fait aucune
différence entre les fichiers de texte et les fichiers binaires. Dans un fichier texte,
les lignes consécutives sont séparées par un seul caractère ’\n’.
– les répertoires, qui contiennent une liste de références à d’autres fichiers UNIX;
– les fichiers spéciaux, associés par exemple à des pilotes de périphériques ;
– les tubes et sockets, utilisés pour la communication entre processus ;
– les liens symboliques (fichiers “pointant” sur un autre fichier).

5- Commandes sur le système de fichiers

a- Commande pwd
La commande pwd retourne le répertoire courant.
b- Commande cd
La commande cd permet de se déplacer dans l'arborescence du système de fichier.
Utilisée sans argument, elle renvoie vers le répertoire home de l'utilisateur qui
l'exécute, tout comme cd ~. Utilisée avec un nom de répertoire, elle renvoie vers le
répertoire en question. cd - renvoie vers le répertoire précédent.
A noter que cd .. renvoie vers le répertoire parent.
c- Création et suppression de fichiers et répertoires

Création de fichiers
La commande touch <fichier> permet de créer un fichier vide. Il est également
possible de créer un fichier par l'intermédiaire de la commande cat ou avec un éditeur
de texte du type vim.

Suppression de fichiers

-8-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

La suppression d'un fichier se fait par la commande rm <fichier>. La commande rm -r

<repertoire> permet de supprimer récursivement le contenu d'un répertoire.
Différentes options utiles de cette commande rm sont :
-r : suppression récursive ;
-f : force la suppression ;
-i : demande confirmation pour chaque fichier ;
-v : affiche le déroulement de la suppression.

Création et suppression de répertoires
La création d'un répertoire se fait par l'intermédiaire de la commande mkdir
<repertoire>, et la suppression par rmdir <repertoire>. Il faut cependant que le
répertoire soit vide. Dans le cas contraire, la commande rm -r <repertoire> est donc
plus appropriée.
d- Copie de fichiers et répertoires

Copie
La commande cp <fichier source> <fichier destination> permet de copier le fichier
<fichier source> vers <fichier destination>. Il est également possible de copier un ou
plusieurs fichiers vers un répertoire donné, en utilisant
cp <fichier1> ... <fichierN> <repertoire>
Pour copier un répertoire, il faut utiliser l'option -r (récursivité) de la commande cp :
cp -r <repertoirer source> <repertoire destination>

Renommage
La commande mv <source> <destination> permet de renommer aussi bien un
fichier qu'un répertoire.
e- La commande ls

Utilisation
Utilisée dans options, la commande ls permet de lister le contenu du répertoire courant,
hormis les fichiers et répertoires cachés (ceux débutant par un .). Pour lister le contenu
d'un répertoire donné, son utilisation est ls <repertoire>.
Cette commande dispose de diverses options, dont les plus utilisées sont :
-a : affiche également les fichiers cachés ;
-l : affiche des informations supplémentaires sur les fichiers ;
-i : affiche les numéros d'i-node (utile pour vérifier les liens) ;
-s : affiche la taille en Ko de chaque fichier.
Il est également possible d'utiliser la commande ls sur un fichier et non pas sur un
répertoire.

Commande ls -l
Comme indiqué ci-dessus, l'option -l permet d'afficher des informations supplémentaires
sur les fichiers. Voici un exemple de sortie de la commande ls -l.
Chaque ligne s'interprète de la façon suivante :
• 1er caractère : indique le type du fichier (répertoire, fichier simple…) ;
• 9 caractères suivants : droits du fichier;
• 2nd champ : nombre de liens sur le fichier ;
• 3ème champ : propriétaire du fichier ;
• 4ème champ : groupe du fichier ;
• 5ème champ : taille en octets ;
• 6ème et 7émé champs : date de dernière modification ;

-9-

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

• 8ème champ : nom du fichier.

Droits d'accès
Concernant les droits sur les fichiers (1er champ, 2nd au 10ème caractère), ceux-ci sont
répartis de la façon suivante :
• Les 3 premiers caractères correspondent aux droits du propriétaire ;
• les 3 suivants aux droits du groupe ;
• les 3 suivants aux droits du reste des utilisateurs du système ;
• r correspond à un accès en lecture ;
• w correspond à un accès en écriture ;
• x correspond à un accès en exécution.

A un fichier on affecte les droits correspondants à trois catégories d'utilisateurs : les

droits du propriétaire du fichier, les permissions du groupe d'utilisateurs auquel
appartient le propriétaire et celles concédées à tous les autres.
Propriétaire
Le propriétaire d'un fichier est la personne qui le crée. Il est désigné par la
lettre u (owner).
Le UID désigne par un identificateur numérique unique le propriétaire d'un
fichier.
Groupe
Un groupe d'utilisateur est un ensemble d'utilisateurs privilégiés ayant en général
des permissions moindre que le propriétaire d'un fichier mais plus grandes que la
catégorie qui suit. Cette catégorie est désignée par la lettre g (group).
Le GID désigne par un identificateur numérique unique le groupe auquel
appartient le propriétaire d'un fichier.
Autres
Cette catégorie regroupe tous les utilisateurs qui ne sont ni le propriétaire d'un
fichier ni faisant partir du même groupe que le propriétaire. On les désignent par
la lettre a (other).

Le schéma ci-contre montre qu'un ensemble de

propriétaires forme un groupe, qu'un ensemble de groupes
forme la catégorie "autres" (qui sont tous ceux qui
prétendent à accéder aux données).

A chaque catégorie d'utilisateur on associe un triplet de droits :

lecture, écriture et exécution. Au total 9 droits (3*3) sont
affectés à chaque fichier.

Les droits d'accès d'un fichier sont au nombre de trois:

- 10 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

Lecture
L'accès en lecture autorise la lecture du fichier, c'est-à-dire qu'il est possible
d'éditer ce fichier avec une application quelconque pour en voir le contenu. Cet
accès est désigné par la lettre r (read).
Alloué à un répertoire, ce droit permet de lister les fichiers qu'il contient.
Ecriture
L'accès en écriture permet de modifier un fichier et de le supprimer. Il est
désigné par la lettre w (write).
Alloué à un répertoire, il autorise la modification et la suppression des fichiers
qu'il contient quelques soient les droits d'accès des fichiers de ce répertoire
(mêmes s'ils ne possèdent pas eux-même le droit en écriture). Donc attention!
Exécution
L'accès en exécution permet à un fichier exécutable d'être lancé et à un
répertoire d'être ouvert. Il est désigné par la lettre x (execute).
Pour qu'un programme puisse être exécuté, il est indispensable que le droit en
exécution sur ce fichier soit autorisé pour l'utilisateur qui souhaite le lancer.
Quant à un répertoire, il est tout aussi indispensable que son droit en exécution
soit autorisé pour qu'on puisse accéder aux fichiers qu'il contient.
Ce droit en exécution est sans effet lorsqu'il est affecté à un fichier qui n'est pas
un exécutable.

6- Modification droits d'accès avec chmod

a- Commande chmod
Sous Unix, et donc sous GNU/Linux, chaque fichier ou répertoire possède donc un
système de droits, comme définis ci dessus (rwx).
La commande chmod permet de modifier les droits d'accès d'un ou plusieurs fichiers
passés en argument. Elle peut s'utiliser de deux façons.
b- Représentation symbolique
La première consiste à utiliser la représentation symbolique des droits d'accès. Celle-ci
est définie en 3 parties, les différents droits étant séparés par des ,.
• Les droits d'accès à modifier : propriétaire (u pour user), groupe (g), ou reste des
utilisateurs du système (o pour other) ;
• Le type de modifications à apporter : affectation (=), ajout (+) ou suppression (-);
• Les modifications à apporter : lecture (r), écriture (w) ou exécution (x).
Ainsi, pour autoriser l'accès en lecture/écriture pour le propriétaire et en lecture pour le
groupe et le reste du système à un fichier fichier1.txt, la commande chmod s'utilise de
la façon suivante :
mlthioune@met_ubuntu:~$ chmod u+rx,go+r fichier1.txt
mlthioune@met_ubuntu:~$ ls -l fichier1.txt
-rwxr--r-- 1 mlthioune admin 1121 2009-09-22 13:01 fichier1.txt
c- Représentation octale
La seconde façon d'utiliser chmod est d'utiliser la représentation octale des droits
d'accès. Pour chacun des droits à modifier, on affecte les valeurs suivantes :
• 4 correspond à r ;
• 2 correspond à w ;
• 1 correspond à x.

- 11 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

Pour chaque droit, on ajoute à convenance ces 3 chiffres pour former le chiffre
correspondant à la modification souhaitée (ex : 7 pour rwx). Enfin on combine ces 3
chiffres pour former un nombre à 3 chiffres qui correspond aux nouveaux droits du
fichier.
Si l'on reprend l'exemple suivant, pour autoriser l'accès en lecture/écriture pour le
propriétaire et en lecture pour le groupe et le reste du système à un fichier fichier1.txt, la
commande chmod s'utilise de la façon suivante avec la représentation octale des droits :
mlthioune@met_ubuntu:~$ chmod 544 fichier1.txt
mlthioune@met_ubuntu:~$ ls -l fichier1.txt
-r-xr--r-- 1 mlthioune admin 1121 2009-09-22 13:01 fichier1.txt

d- Commande umask
Afin de définir les droits d'accès à appliquer par défaut, on peut utiliser la commande
umask. Celle-ci se base sur la représentation octale vu précédemment.
Il s'agit de définir un masque qui sera retranché au masque maximal lors de la création
de fichiers ou de répertoires.
Pour les fichiers, le masque maximal est de 666. Ainsi, pour que tous les fichiers crées
le soient avec les droits définis en octal par le code 644 (soit rw-r--r--), il faut appliquer le
masque 022 : umask 022.
En ce qui concerne les répertoires, le masque maximal est de 777.

- 12 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

III-MANIPULATION DES FICHIERS

1- Affichage du contenu d’un fichier
Les commandes ci-dessous sont à utiliser dans le cas de fichiers ascii. Dans le cas de
fichiers binaires, la sortie sera illisible et la plupart du temps, votre terminal sera par la
suite inutilisable.
a- Commande cat
La commande cat permet d'afficher le contenu d'un fichier en une seule fois :
cat <fichier>.
Options :
- v (Verbose) permet de convertir les caractères spéciaux des fichiers binaires en
caractères affichables
- n (Number) numérote les lignes
- b (number nonBlank) ne numérote que les lignes non vides
- E (show Ends) affiche le symbôle $ (dollard) à la fin de chaque ligne
- s (Squeeze blank) n'affiche au plus une ligne vide
- T (show Tab) affiche les caractères tabulations comme ^I
- A (show All) équivalent à –vET
- e équivalent à –vE
- t équivalent à -vT.
A l'origine, cat permet de concaténer des fichiers et d'en renvoyer le résultat sur la sortie
standard : cat fichier_1 fichier_2 fichier_3
Exemple : cat lettre.txt rapport.txt conclusion.txt
L'exemple précédent affiche à l'écran le contenu des
fichiers lettre.txt, rapport.txt et conclusion.txt.
b- Commandes more et less
Les commandes more et less permettent d'afficher page par page des fichiers
volumineux sur la sortie stantard.
Pour passer à la page suivante : les touches fléchées. Pour effectuer un défilement
vertical : touche ENTREE. Pour quitter : touche q.

c- Commandes head
La commande head permet d'afficher le début du fichier passé en argument. Par défaut,
les 10 premières lignes sont affichées. head <fichier>
Les options utiles de head sont les suivantes :
-nX : affiche les X premières lignes du fichier ;
-cX : affiche les X premiers caractères du fichier.
d- Commande tail
A l'inverse de la commande head, la commande tail affiche la fin du fichier passé en
argument. Par défaut, les 10 premières lignes sont affichées. tail <fichier>
Les options utiles de tail sont les suivantes :
-nX : affiche les X dernières lignes du fichier ;
-cX : affiche les X derniers caractères du fichier.
-f : affiche les dernières lignes en continu, i.e. au fur et à mesure de l'évolution
du fichier (utile pour observer des fichiers de log).

- 13 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

e- Commande nl
La commande nl permet l'affichage du contenu d'un fichier et en numérote les lignes.
nl <fichier>
En voici les options :
- bt numérote les lignes non-vides (par défaut)
- ba numérote toutes les lignes
- bpXXX numérote seulement les lignes qui contiennent la chaîne de caractères XXX
- sX supprime le décalage du à la numérotation et utilise le séparateur X
- s'XXX' supprime le décalage du à la numérotation et utilise la chaîne 'XXX'
f- Commande wc
La commande wc permet de compter le nombre de caractères, de mots et de lignes d'un
fichier. wc <fichier> Ses options sont :
- l (Lignes) compte le nombre de lignes
- w (Words) compte le nombre de mots
- c (Chars) compte le nombre de caractères
- L (Length max ligne) affiche la longueur de la ligne la plus longue

2- Manipulation de fichiers avec grep

La commande grep <expression> <fichiers> a pour but de rechercher et d'afficher
les lignes contenant la chaine de caractères expression parmi les fichiers de la liste
fichiers passée en arguments. Par exemple : grep foo *.c affichera toutes les lignes
contentant la chaine foo des fichiers d'extension .c.
Différentes options utiles de grep sont :
-i : Rend la recherche case-insensitive ;
-l : Affiche le nom du fichier trouvé ;
-v : Affiche les lignes ne contenant pas l'expression recherchée ;
-n : Affiche les numéros de lignes correspondantes.

3- Recherche de fichiers dans l'arborescence

a- Utilisation de la commande find
Comme son nom l'indique, find a pour but de rechercher des fichiers dans
l'arborescence. Elle s'utilise en spécifiant différentes options, permettant une recherche
classique par nom, mais aussi par exemple par type ou date de modification.
Sa syntaxe est la suivante : find <chemin> <expression>.
Parmi les expressions possibles, citons :
-name <expression> : pour recherche les fichiers dont le nom correspond à
l'expression en argument ;
-mindepth et -maxdepth : pour restreindre la profondeur de recherche dans
l'arborescence ;
-follow : pour suivre les liens symboliques ;
-atime n et amin n : pour rechercher les fichiers accédés il y a n jours ou n
minutes ;
-ctime n et cmin n : pour rechercher les fichiers modifiés il y a n jours ou n
minutes ;
-exec <expression> : exécute expression sur l'ensemble des résultats de la
recherche.

- 14 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

b- Utilisation de la commande locate

La commande locate va quand à elle rechercher tous les fichiers donc le nom
correspond à l'expression passée en argument. Cette recherche ne se fait pas par rapport
au système de fichiers, mais dans une base de données répertoriant l'ensemble des
fichiers du système. Cette base de donnée est crée et mise à jour par le root par le biais
de la commande updatedb.

IV-COMMANDES D’OBSERVATION DU SYSTEME

1- Date et heure
La commande date affiche la date et l’heure. Des formats d’affichage sont disponibles en
options.

2- Nom de l’ordinateur
La commande hostname affiche le nom de l’ordinateur sur lequel la commande
s’exécute.

3- Nom du système d’exploitation

uname –a affiche des informations sur le système d’exploitation

4- Information sur les utilisateurs

a- Les commandes who et whoami
La commande who affiche le nom de login, le nom du terminal et l’heure du login pour
chaque utilisateur actuellement en ligne.
Si un utilisateur s’est connecté par l’intermédiaire du réseau (et pas directement sur la
machine qui exécute la commande who), le nom de la machine d’où il vient est indiqué
entre parenthèses à la fin de la ligne.
who am I affiche les informations sur l’utilisateur qui s’est connecté pour démarrer la
session en cours
whoami affiche le nom de login de l’utilisateur qui a lancé la commande.
b- La commande finger
finger [<@machines>] affiche les informations de la commande who et des détails sur
les utilisateurs actuellement connectés sur les machines (machine locale par défaut).
finger <utilisateur> [<@machines>] affiche les informations sur les utilisateurs
spéciés, même s’il ne sont pas connectés. finger donne plus d’informations sur les
utilisateurs que lorsque l’on n’indique pas d’utilisateurs en particulier.

5- Espace disque occupé : du

Place occupée par la branche d’un répertoire
La commande du [<fichier>] affiche le nombre de blocs occupés par les fichiers
indiqués (répertoire en cours par défaut)
Si un des fichiers est un répertoire, c’est le nombre de blocs occupés par toute
l’arborescence placée sous le répertoire qui est affichée.
-s affiche seulement le nombre total de blocs
-a affiche la taille de tous les fichiers et répertoires
Exemple

- 15 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

du -s /home/methi

6- Place libre d’un système de fichiers : df

df [<fichier>] [<fichier>] affiche le nombre de blocs disponibles pour le système de
fichiers spécifié.
Le système de fichiers peut être spécifié par le nom du périphérique (/dev/….) ou par un
fichier quelconque du système monté.
df (sans argument) affiche les renseignements sur tous les systèmes montés
Exemple :
df .
affiche les renseignements sur le système de fichiers sur lequel se
trouve le répertoire courant.
Nom du terminal utilisé : tty
La commande tty affiche le nom du terminal associé à l’entrée standard du processus
courant. Le code retour est 0 si l’entrée standard est un terminal et 1 sinon.

- 16 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

V- COMMANDE POUR LA GESTION DES PROCESSUS

1- Présentation des processus
Sous Unix, toute tâche qui est en cours d'exécution est représentée par un processus.
Un processus est une entité comportant à la fois des données et du code. On peut
considérer un processus comme une unité élémentaire en ce qui concerne l'activité sur
le système.
On peut imaginer un processus comme un programme en cours d'exécution. Cette
représentation est très imparfaite car une application peut non seulement utiliser
plusieurs processus concurrents, mais un unique processus peut également lancer
l'exécution d'un nouveau programme, en remplaçant entièrement le code et les
données du programme précédent.
Un instant donné, un processus peut, comme nous le verrons plus loin, se trouver dans
divers états. Le noyau du système d'exploitation est chargé de réguler l'exécution des
processus afin de garantir à l'utilisateur un comportement multitâche performant. Le
noyau fournit un mécanisme de régulation des tâches qu'on nomme « ordonnancement»
(en anglais scheduling). Cela assure la répartition équitable de l'accès au
microprocesseur par les divers processus concurrents.
Sur une machine uni-processeur, il n'y a qu'un seul processus qui s'exécute
effectivement à un instant donné. Le noyau assure une commutation régulière entre tous
les processus présents sur le système pour garantir un fonctionnement multitâche. Sur
une machine multiprocesseur, le principe est le même. A la différence que plusieurs
processus — mais rarement tous — peuvent s'exécuter réellement en parallèle.
On peut examiner la liste des processus présents sur le système à l'aide de la commande
ps, et plus particulièrement avec ses options ax, qui nous permettent de voir les
processus endormis, et ceux qui appartiennent aux autres utilisateurs. On voit alors,
même sur un système apparemment au repos, une bonne trentaine de processus plus ou
moins actifs :
$ ps -ax

2- Caractéristiques d’un processus

À partir d'un terminal, un processus peut être lancé de deux façons différentes :
• au premier plan (fg). Pour cela, il suffit de taper le nom du programme dans un
terminal.
• en arrière-plan (bg) (on dit aussi en tâche de fond). Il faut alors taper le nom du
programme suivi du symbole &.
Lorsqu'un processus s'exécute au premier plan, le terminal devient inactif puisqu'il est
occupé par ce processus. Au contraire, si le processus est lancé en arrière-plan, le
terminal reste disponible (le prompt s'affiche de nouveau). Cette seconde solution
permet de lancer plusieurs processus à partir du même terminal.

On peut à un moment donné avoir plusieurs processus en cours, à un temps donné. Le

système doit être capable de les identifier. Pour cela il attribue à chacun d'entre eux, un
numéro appelé PID (Process Identification).
Un processus peut lui même créer un autre processus, il devient donc un processus
parent ou père, et le nouveau processus, un processus enfant ou fils. Ce dernier est

- 17 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

identifié par son PID, et le processus père par son numéro de processus
appelé PPID (Parent Process Identification).
Tous les processus sont ainsi identifiés par leur PID, mais aussi par le PPID du processus
qui l’a créé, car tous les processus ont été créés par un autre processus. Le seul qui ne
suit pas cette règle est le premier processus lancé sur le système le processus init qui n'a
pas de père et qui a pour PID 1.

3- Commandes
a- La commande top
La commande top vous permet d'afficher des informations en continu sur l'activité du
système. Elle permet surtout de suivre les ressources que les processus utilisent (quantité
de RAM, pourcentage de CPU, la durée de ce processus depuis son démarrage).
Vous pourrez utiliser l'option -d pour spécifier des délais de rafraîchissement (en
secondes).
En cours d'utilisation de top, il est possible de stopper un processus de manière
interactive en tapant k. top demande ensuite lequel signal il doit envoyer : 15
(SIGTERM) est le signal par défaut qui met fin à un processus, 9 (SIGKILL) est plus brutal.
Pour quitter top, appuyer simplement sur la touche "q".
b- La commande ps
La commande ps permet de connaître les processus actifs à un moment donné. Elle
affiche les détails de ces processus :

- Le "PID" est l'identificateur d'un processus, c'est un nombre. Chaque processus

est identifié dans le système par un nombre unique.
- Le "TTY" indique à quel port de terminal est associé le processus.
- "STAT" indique l'état dans lequel se trouve le processus. (S comme "sleep"), (R
comme "run").
- Le "TIME" indique depuis combien de temps le processus utilise les ressources
du microprocesseur.
- Le "COMMAND" précise, comme son nom l'indique, la commande dont l'état
est décrit par PID, TTY, STAT et TIME.

Une simple commande "ps" n'indique pas tous les processus du système. Le simple fait
de lancer ps indique juste les processus associés à un terminal et qui dépendent de
l'utilisateur courant.
En fait, il est tout a fait probable que d'autres processus non liés à un terminal aient été
lancés par l’utilisateur courant.
Pour avoir ces processus, on ajoute à ps l’option –x.
L'option ax permet de connaître tous les processus de tous les utilisateurs de la
machine. Si en plus on désire connaître les utilisateurs associés à chaque processus, il
vous suffit d'utiliser l'option aux. On verra alors plusieurs colonnes s'ajouter dont
"USER" qui indique à quel utilisateur appartient le processus.
"%CPU" indique en pourcentage les ressources du microprocesseur utilisées par le
processus.
"%MEM" montre en pourcentage les ressources en mémoire vive utilisées par le
processus.
"RSS" donne réellement la mémoire utilisée en kilobytes par le processus.

- 18 -

mlTHIOUNE
 Programmation avancée sous Unix : Partie 1

"START" indique l'heure à laquelle le processus a été lancé.

c- La commande pstree
Cette commande permet d'afficher les processus sous forme d'arborescence et donc de
voir leurs dépendances.
d- La commande kill
La commande kill transmet des signaux à des processus (via leur PID) travaillant en
arrière-plan. Le plus connu (et sûrement le plus utilisé) de ces signaux est le signal 9
appelé KILL. Il arrête le processus.
Un utilisateur ne peut arrêter que les processus qui lui appartient (qu'il a lancés).

- 19 -

mlTHIOUNE