Support du cours : Systèmes d'exploitation 2 (linux)

Faycel CHAOUA (faycelchaoua@gmail.com)
ISET KELIBIA | ROUTE OUED ELKHATF, CAMPUS UNIVERSITAIRE DE KELIBIA
Janvier 2018
Ministère de l'Enseignement Supérieur et de la Recherche Scientifique
Direction Générale des Études Technologiques
ISET Kélibia
Département Technologies de l’Informatique
Support du cours
SYSTEMES D'EXPLOITATION 2
LMD  L2

Faycel CHAOUA Systèmes d’exploitation 2 i
Conditions d’utilisation de ce support
Ce support de cours est mis à disposition selon les termes de la licence « Creative Commons
Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0
International ».
https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr
Vous êtes autorisé à :
» Partager  copier, distribuer et communiquer le matériel par tous moyens et sous tous
formats.
» Adapter  remixer, transformer et créer à partir du matériel
Selon les conditions suivantes :
» Attribution  Vous devez créditer l'œuvre, intégrer un lien vers la licence et indiquer
si des modifications ont été effectuées à l'œuvre. Vous devez indiquer ces
informations par tous les moyens raisonnables, sans toutefois suggérer que l'offrant
vous soutient ou soutient la façon dont vous avez utilisé son œuvre.
» Pas d’utilisation commerciale  Vous n'êtes pas autorisé à faire un usage commercial
de cette œuvre, tout ou partie du matériel la composant.
» Partage dans les mêmes conditions  Dans le cas où vous effectuez un remix, que
vous transformez, ou créez à partir du matériel composant l'œuvre originale, vous
devez diffuser l'œuvre modifiée dans les même conditions, c'est à dire avec la même
licence avec laquelle l'œuvre originale a été diffusée.

Faycel CHAOUA Systèmes d’exploitation 2 ii
Les objectifs généraux
A l’issue des modules présentés dans ce support, l’apprenant sera capable de :
 Comprendre l’architecture d’un système UNIX.
 Partitionner un disque dur sous un système GNU/Linux.
 Gérer des fichiers et des répertoires.
 Modifier les droits d’accès.
 Gérer les utilisateurs et les groupes.
 Gérer les processus.
 Écrire des scripts Shell.
Plan du cours
Ce support est constitué principalement des chapitres suivants :
 Chapitre 1 : Présentation générale du système Linux.
 Chapitre 2 : Système de fichiers Linux.
 Chapitre 3 : Les commandes GNU/Linux.
 Chapitre 4 : Permissions d'accès aux Fichiers.
 Chapitre 5 : Gestion des utilisateurs et des groupes.
 Chapitre 6 : Système de gestion de processus.
 Chapitre 7 : La programmation Shell.

Faycel CHAOUA Systèmes d’exploitation 2 iii
Table des matières
Chapitre 1. Présentation générale du système Linux............................................................ 1
1.1. Système UNIX................................................................................................................. 2
1.1.1. Le système d’exploitation......................................................................................... 2
1.1.2. Historique.................................................................................................................. 3
1.2. Système GNU / Linux ..................................................................................................... 4
1.2.1. Le projet GNU .......................................................................................................... 4
1.2.2. GNU / Linux : historique et caractéristiques ............................................................ 4
1.2.3. Distribution Linux..................................................................................................... 5
Chapitre 2. Système de fichiers Linux.................................................................................... 6
2.1. Choisir un système de fichiers......................................................................................... 8
2.1.1. Principe ..................................................................................................................... 8
2.1.2. Les filesystems sous Linux ....................................................................................... 9
2.2. Disques durs et partitionnement .................................................................................... 10
2.2.1. Les partitions........................................................................................................... 10
2.2.2. Organisation des partitions sous Linux................................................................... 11
2.2.3. Formatage ............................................................................................................... 12
2.2.4. Contrôle de l'intégrité du système de fichiers et réparation.................................... 12
2.2.5. Montage et démontage d'un système de fichiers..................................................... 13
Chapitre 3. Les commandes GNU/Linux ............................................................................. 15
3.1. Le Shell.......................................................................................................................... 18
3.1.1. Présentation............................................................................................................. 18
3.1.2. Les caractères spéciaux du Shell............................................................................. 18
3.2. Fichiers et répertoires .................................................................................................... 19
3.3. Redirections des entrées-sorties..................................................................................... 20
3.4. Les gestionnaires de paquets ......................................................................................... 21
3.5. Les principales commandes GNU/Linux ...................................................................... 21

Faycel CHAOUA Systèmes d’exploitation 2 iv
3.5.1. Les commandes relatives aux répertoires ............................................................... 21
3.5.2. Les commandes relatives aux fichiers .................................................................... 26
3.5.3. Les commandes d'archivage et de compression...................................................... 39
3.5.4. Commandes d’aide et d’informations..................................................................... 42
Chapitre 4. Permissions d'accès aux Fichiers...................................................................... 44
4.1. Les droits sur les fichiers et les répertoires.................................................................... 45
4.2. Modifier le propriétaire et le groupe sur les fichiers et les répertoires.......................... 47
Chapitre 5. Gestion des utilisateurs et des groupes............................................................. 48
5.1. Les utilisateurs............................................................................................................... 49
5.2. Les groupes.................................................................................................................... 50
5.3. Les fichiers de configuration ......................................................................................... 51
5.3.1. Gestion des utilisateurs ........................................................................................... 51
5.3.2. Gestion des groupes ................................................................................................ 52
5.3.3. Fichiers de configuration par défaut ....................................................................... 52
5.4. Gestion des comptes et des options de création par défaut ........................................... 52
5.4.1. Comment bloquer un compte.................................................................................. 53
5.4.2. Gestion des informations d’expiration du compte.................................................. 53
5.4.3. Destruction d’un compte......................................................................................... 53
Chapitre 6. Système de gestion de processus ....................................................................... 54
6.1. Introduction ................................................................................................................... 55
6.2. La commande « ps »...................................................................................................... 55
6.3. La commande « top » .................................................................................................... 56
6.4. La commande « kill ».................................................................................................... 56
6.5. La commande « nice »................................................................................................... 57
6.6. La commande « renice »................................................................................................ 58
6.7. Les processus et le Shell................................................................................................ 58
6.8. La commande « nohup » ............................................................................................... 59
Chapitre 7. La programmation Shell ................................................................................... 61

Faycel CHAOUA Systèmes d’exploitation 2 v
7.1. Introduction ................................................................................................................... 62
7.2. Le Shell, un interpréteur de commandes ....................................................................... 62
7.3. Utilisation de variables .................................................................................................. 63
7.4. Les scripts Shell............................................................................................................. 64
7.5. Syntaxe .......................................................................................................................... 65
7.5.1. Les tests................................................................................................................... 67
7.5.2. L’instruction « if » .................................................................................................. 68
7.5.3. L’instruction « case ».............................................................................................. 69
7.5.4. L’instruction « for »................................................................................................ 69
7.5.5. L’instruction « while »............................................................................................ 70
7.5.6. Les fonctions........................................................................................................... 71
7.5.7. Expressions arithmétiques « expr » ........................................................................ 71
7.5.8. Expressions arithmétiques « let, (()) ».................................................................... 72
TD (Travaux dirigés) ............................................................................................................. 73
TD N° 1 ................................................................................................................................ 74
TD N° 2 ................................................................................................................................ 76
TD N° 3 ................................................................................................................................ 78
TD N° 4 ................................................................................................................................ 81
TD N° 5 ................................................................................................................................ 83
Correction des TD .................................................................................................................. 85
Correction du TD N° 1 ......................................................................................................... 86
Correction du TD N° 5 ....................................................................................................... 103
Références (Bibliographie / Webographie)........................................................................ 110

Faycel CHAOUA Systèmes d’exploitation 2 1
Chapitre 1. Présentation générale du système Linux
Chapitre 1 : Présentation générale du système Linux
֍ Durée : 1 heure 30 minutes.
֍ Mots clés : Système d’exploitation, UNIX, GNU/Linux, GPL.
֍ Objectifs : À l'issue de ce chapitre, vous serez en mesure de :
» Distinguer l'architecture logique d'un système UNIX.
» Rappeler sommairement l'historique d'UNIX et de GNU/Linux.
» Identifier les quatre libertés de la licence GPL.
Plan du chapitre :
1.1. Système UNIX................................................................................................................. 2
1.1.1. Le système d’exploitation......................................................................................... 2
1.1.2. Historique.................................................................................................................. 3
1.2. Système GNU / Linux ..................................................................................................... 4
1.2.1. Le projet GNU .......................................................................................................... 4
1.2.2. GNU / Linux : historique et caractéristiques ............................................................ 4
1.2.3. Distribution Linux..................................................................................................... 5

1.1. Système UNIX
1.1.1. Le système d’exploitation
Un système d’exploitation est un programme ou un ensemble de programmes assurant la
gestion de l’ordinateur et des périphériques. Il sert d’interface entre le matériel (hardware) et
le logiciel (software). C’est un ensemble de programmes très complexes dont le but est de
rendre plus simples les programmes et l’utilisation de l’ordinateur.
Figure 1-1 : Principe du système d’exploitation
C’est le rôle du système d’exploitation de gérer la mémoire, les accès aux périphériques, les
données sur les disques, les programmes, la sécurité et la collecte des informations.
Figure 1-2 : Architecture logique d’un système UNIX

Le schéma précédent présente une synthèse simplifiée de la structure interne d’un système
d’exploitation Unix. En bas se trouve le matériel, en haut les programmes qu’on fait
fonctionner sur la machine. Entre les deux les divers composants du système assurent son bon
fonctionnement.
1.1.2. Historique
UNIX désigne une famille de systèmes d'exploitation dont le premier a été conçu aux
"laboratoires Bell".
 1969 : Thompson et Ritchie produisent la première édition d'un système primitif qui
ne comporte qu'un assembleur et un chargeur.
 1970 : La primitive « fork » est ajoutée pour permettre la création de processus et des
programmes utilitaires pour la gestion des fichiers sont produits (deuxième édition).
 1971 : Un système de traitement de textes (roff) est produit. Thompson et Ritchie
publient la première documentation du système. C'est la troisième édition.
 1972 : UNIX est amélioré en lui ajoutant la notion de relais (pipe). Il existe à l'époque
environ 20 sites utilisant le système UNIX.
 1973 : UNIX est réécrit en langage C (quatrième édition).
 1974 : La cinquième édition, conçue spécialement pour des fins académiques, est
introduite.
 1975 : La sixième édition d’UNIX est produite et devient la première à être
commercialisée pour une somme modique par "AT&T".
 1977 : Près de 500 sites utilisent UNIX. À partir de ce moment, les versions d’UNIX
vont se multiplier. C'est à cette époque que débute le problème de standard.
 1980 : Il y a environ 100 000 sites UNIX.
 1983 : "AT&T" annonce le System V.
 1984 : Production de la version 2 de System V avec un support complet pour le
système d'exploitation et les utilitaires.
 1986 : "AT&T" annonce la version 3 de System V qui supporte RFS (Remote File
Sharing).
 1987 : Une nouvelle version d’UNIX est annoncée. C'est le System V version 4.0 qui
sera disponible à l'automne 1989. Donc deux versions vont subsister : System V 5.3
de "AT&T" et BSD 4.3 de "Berkeley".

 1989 : Avec la commercialisation du système par "AT&T", les sources n'étaient
offertes qu'à des prix exorbitants. Le projet GNU (GNU's not UNIX) a pour objectif
(entre autres) de remettre UNIX dans le domaine public. Sur une base de volontariat,
les participants au projet GNU produisent du code UNIX disponibles gratuitement.
1.2. Système GNU / Linux
1.2.1. Le projet GNU
Richard Stallman a décidé en 1983 d’écrire un nouveau système d’exploitation entièrement
libre d’accès, d’utilisation, de modification et de redistribution. Basé sur Unix, il l’a nommé
GNU (Gnu’s Not Unix).
Pour défendre le logiciel libre, Stallman a créé la FSF (Free Software Foundation) en 1985
qui diffuse les idées du logiciel libre. Parmi ses premiers travaux figure la rédaction d’une
licence spéciale pour ces logiciels appelée la GPL (General Public License). Un logiciel libre
garantit quatre libertés :
 Liberté 0 : la liberté d’utiliser un logiciel quel que soit l’usage que vous en faites.
 Liberté 1 : la liberté d’étudier le fonctionnement du programme et de l’adapter à votre
besoin.
 Liberté 2 : la liberté de redistribuer des copies afin d’aider votre voisin (au sens large
du terme).
 Liberté 3 : la liberté d’améliorer le programme et de diffuser les améliorations au
public à fin d’en faire bénéficier l’ensemble de la communauté.
Les libertés 1 et 3 nécessitent d’avoir obligatoirement accès au code source du programme.
La liberté 3 définit la notion de communauté autour du logiciel libre.
1.2.2. GNU / Linux : historique et caractéristiques
 1991 : Linus Torvalds a créé le système Linux (Linus' UNIX, l'UNIX de Linus). Il
lance un appel à contribution, et permet donc un libre accès au code source. Cette
version permet de faire tourner quelques applications GNU (logiciels libres)
essentielles comme le compilateur gcc ou le Shell bash. Linus prend la décision de

mettre le code source sous licence GPL : tout le monde peut alors participer au
développement de Linux.
 1991-94 : Linux devient un système UNIX complet compatible avec les autres
systèmes UNIX, offrant toujours plus de services de qualité professionnelle au plus
grand nombre.
 1994-97 : L’apparition des grandes distributions Linux : Red Hat, Debian, Suse et
Slackware. Durant ces années, Linux ne cesse de s’améliorer, avec l’arrivée notable
de la modularité et de la version 2.0. Les projets foisonnent, et déjà l’idée d’améliorer
le système et de l’ouvrir au monde du bureau (desktop) fait son bout de chemin avec le
début du développement de produits comme Gnome ou KDE.
 1998~ : L’explosion de l’utilisation de Linux. Les salons Linux se multiplient et l'on
observe une multiplication des revues spécialisées. Le noyau 2.6 sort le 18 décembre
2003.
 Aujourd’hui et demain : Aujourd’hui Linux est reconnu comme un système
d’exploitation stable, robuste et performant. Il est utilisé dans plus du tiers des
serveurs dans le monde et dans la moitié des serveurs Web. Il a conquis le monde de
l’entreprise, le monde universitaire. Il a surtout su conserver son indépendance,
garantie par la communauté et le nombre de contributeurs, face aux géants de
l’informatique. La prochaine grosse cible de Linux, c’est le poste de travail, et
pourquoi pas, l’usage familial en remplacement de Windows. Il reste encore un peu de
chemin, mais nombreux sont ceux qui ont déjà franchi le pas.
1.2.3. Distribution Linux
Linux est le plus souvent diffusé sous forme d’une distribution, un ensemble de programmes
(noyau, sources des utilitaires, commandes, applications) formant après installation un
système complet. Chacune des distributions a ses avantages et ses inconvénients. Débuter
avec Linux, c’est surtout choisir une distribution qui corresponde avec les usages qu’on attend
du système.
Parmi les distributions les plus utilisées, on trouve RedHat, Debian, Slackware (toutes trois
gratuites) et SuSE, Mandrake (toutes deux payantes).

Chapitre 2. Système de fichiers Linux
Chapitre 2 : Système de fichiers Linux
֍ Durée : 2 heures.
֍ Mots clés : système de fichiers, ext2, ext3, ext4, reiserfs, xfs, vfat, fdisk, mkfs, fsck,
mount, umount, fstab, df, du.
» Distinguer entre les principaux systèmes de fichiers sous Linux.
» Partitionner un disque dur.
Plan du chapitre :
2.1. Choisir un système de fichiers......................................................................................... 8
2.1.1. Principe ..................................................................................................................... 8
2.1.2. Les filesystems sous Linux ....................................................................................... 9
2.1.2.1. ext2..................................................................................................................... 9
2.1.2.2. ext3..................................................................................................................... 9
2.1.2.3. ext4..................................................................................................................... 9
2.1.2.4. reiserfs ................................................................................................................ 9
2.1.2.5. xfs..................................................................................................................... 10
2.1.2.6. vfat.................................................................................................................... 10
2.2. Disques durs et partitionnement .................................................................................... 10
2.2.1. Les partitions........................................................................................................... 10
2.2.2. Organisation des partitions sous Linux................................................................... 11
2.2.3. Formatage ............................................................................................................... 12
2.2.4. Contrôle de l'intégrité du système de fichiers et réparation.................................... 12
2.2.5. Montage et démontage d'un système de fichiers..................................................... 13

Introduction
Un système de fichiers, appelé communément File System ou FS, définit l’organisation des
données sur un support de stockage, donc comment sont gérés et organisés les fichiers par le
système d’exploitation.
Linux est, comme tout Unix, un système d’exploitation entièrement orienté fichier. Tout (ou
presque) est représenté par un fichier, tant les données (fichiers de données de tout type
comme une image ou un programme), que les périphériques (terminaux, souris, clavier, carte
son, etc.) ou encore les moyens de communication (sockets, tubes nommés, etc.). On peut dire
que le système de fichiers est le cœur de tout système Unix.
Figure 2-1 : Exemple d’arborescence Linux
Le système de fichiers de Linux est hiérarchique. Il décrit une arborescence de répertoires et
de sous répertoires, en partant d’un élément de base (/) appelé la racine ou root directory.
Les répertoires de base de l'arborescence standard de fichiers sont les suivants :
 /boot : contient principalement le fichier binaire du noyau ainsi que les ressources
nécessaires à son lancement au démarrage.
 /dev : contient les fichiers des périphériques (devices) de la machine ainsi que des
fichiers spéciaux.
 /home : répertoire où sont stockés par défaut les répertoires home des utilisateurs du
système.

 /etc : répertoire très important où sont stockés tous les fichiers de configuration du
système en général et des différents démons en particulier. Il s’agit du répertoire à
sauvegarder pour pouvoir restaurer la configuration d'une machine.
 /proc : contient les informations nécessaires au noyau. C'est une arborescence
virtuelle généralement en lecture seule sauf /proc/sys.
 /root : répertoire home du super-utilisateur (root).
 /tmp : permet aux applications et aux utilisateurs d'avoir un espace d'échange où ils
peuvent stocker leurs fichiers temporaires. Il est effacé à chaque redémarrage de la
machine (« reboot »).
 /usr : contient les fichiers nécessaires aux applications, la documentation, les
manuels, les fichiers sources ainsi que des librairies généralement statiques et générées
à l'installation des logiciels standards de la distribution.
 /usr/local : arborescence qui sert à installer les logiciels supplémentaires.
 /var : contient les fichiers journaux des différents démons (donc variable) ainsi que
les spools de mail, d'impression, de cron, etc.
 /bin et /sbin : contiennent l'ensemble des binaires indispensables au démarrage de la
machine et les commandes essentielles d’administration.
 /lib et /usr/lib : contiennent les librairies nécessaires aux commandes précédentes.
2.1. Choisir un système de fichiers
2.1.1. Principe
L’action de « formater » un disque, une clé ou tout support de données consiste uniquement à
créer sur un support de mémoire secondaire l’organisation logique permettant d’y placer des
données. Le mot « formatage » n’est quasiment jamais utilisé sous Linux. On parle de
système de fichiers qui est à la fois l’organisation logique des supports au niveau le plus bas
comme au niveau de l’utilisateur.
Si les principes de base sont souvent les mêmes entre les divers systèmes présents sous Linux,
les implémentations et les organisations logiques des données sur le disque varient fortement.
Aussi il n’existe pas un type de système de fichiers, mais plusieurs, au choix de l’utilisateur,
administrateur ou ingénieur.

Le principe de base est d’associer un nom de fichier à son contenu et d’y permettre l’accès :
création, modification, suppression, déplacement, ouverture, lecture, écriture, fermeture.
Suivant ce principe, le système de fichiers doit gérer ce qui en découle : mécanismes de
protection des accès (les permissions, les propriétaires), les accès concurrents, etc.
Un fichier est décrit par des propriétés appelées les métadonnées. Sous Linux, il s’agit de
l’inode. Le contenu (les données) est placé dans d’autres blocs du support de stockage. Le
contenu des métadonnées diffère d’un système de fichiers à un autre.
2.1.2. Les filesystems sous Linux
2.1.2.1. ext2
Le « second extended filesystem » ext2 est considéré comme le système de fichiers
historique de Linux. ext2 est donc le premier système de fichiers développé spécifiquement
pour Linux, d’un niveau de production et aux normes Unix. ext2 n’est pas journalisé.
2.1.2.2. ext3
L’ext3 « third extended filesystem » est le successeur d’ext2 depuis 1999. Il est
journalisé. Surtout, il est entièrement compatible avec ext2. Le journal est une extension
d’ext2. Il est possible d’utiliser un système de fichiers ext3 comme étant ext2, avec les
mêmes commandes, les mêmes manipulations. Il est possible de transformer en quelques
secondes un système ext2 en ext3, et vice versa. C’est l’un des systèmes de fichiers de choix
pour Linux, et le plus utilisé actuellement pour sa souplesse.
2.1.2.3. ext4
L’ext4 « fourth extended filesystem » est une évolution d’ext3. Il présente de
nombreux avantages et optimisations par rapport à l'ancienne version, tout en assurant une
rétro-compatibilité.
2.1.2.4. reiserfs
reiserfs a été le premier système de fichiers intégré à Linux, avant même ext3. Sa force
réside, outre dans son journal, dans l’organisation indexée des entrées des répertoires et la
manipulation des fichiers de petite taille. Ses performances sont exceptionnelles en présence

de milliers de fichiers, de faible à moyen volume. Il est redimensionnable à chaud. Il devient
plus lent sur des gros fichiers.
2.1.2.5. xfs
xfs est le plus ancien des systèmes de fichiers journalisés sous Unix, datant de 1993. Outre
ses capacités de stockages, il a un système de journalisation très performant et des
mécanismes avancés comme la défragmentation en ligne, la capacité d’effectuer des
snapshots, le dimensionnement à chaud, la réservation de bande passante pour les entrées et
sorties, etc.
2.1.2.6. vfat
vfat (Virtual File Allocation Table) est un terme générique regroupant les diverses
versions de FAT supportant les noms de fichiers longs (255 caractères) sous Windows. Ces
systèmes de fichiers sont conservés et continuent d’être utilisés pour des raisons à la fois
historiques et pratiques. La plupart des supports amovibles, disques externes, clefs USB et
lecteurs MP3 utilisent un système de fichiers de ce type.
2.2. Disques durs et partitionnement
À l’installation, un disque dur n’est ni partitionné, ni formaté. Partitionner signifie définir
sur le disque un ou plusieurs espaces, ou partitions, et formater signifie préparer une partition
à recevoir des informations en utilisant un système de fichiers défini.
2.2.1. Les partitions
Une partition est définie par son type, son emplacement de début de partition et enfin soit sa
taille, soit son emplacement de fin de partition. Un partitionnement est réversible (non
physique).
Une seule partition est activée à la fois au niveau du BIOS : cette activation indique où le
BIOS doit aller chercher le noyau du système d’exploitation pour le démarrage.

Il existe trois sortes de partitions :
 Les partitions principales : leur nombre est limité à quatre et elles supportent tous
types de systèmes de fichiers.
 La partition étendue : elle ne peut contenir que des partitions logiques et ne peut pas
recevoir de systèmes de fichiers. Elle ne peut exister que s’il existe une partition
principale.
 Les partitions logiques : elles sont contenues dans une partition étendue. Elles ne
sont pas limitées en nombre et acceptent tous types de systèmes de fichiers.
2.2.2. Organisation des partitions sous Linux
Les descripteurs de disques durs dans le répertoire /dev commencent par hd pour les
périphériques de type IDE ou par sd pour les périphériques de type SCSI. Une lettre
additionnelle est ajoutée au descripteur pour désigner le périphérique.
Il y a généralement deux contrôleurs IDE en standard sur un PC, chaque contrôleur supportant
deux périphériques (disques, lecteur de cédérom/DVD, lecteur ZIP, etc.).
Primaire Secondaire
Maître a c
Esclave b d
Tableau 2-1 : Désignation des périphériques IDE
 Pour le périphérique maître sur le contrôleur primaire : hda.
 Pour le périphérique esclave sur le contrôleur secondaire : hdd.
 Les périphériques SCSI sont désignés en fonction de leur position dans la chaîne SCSI
(sda, sdb, sdc, etc.).
 On utilise la commande fdisk pour configurer une nouvelle partition. Par exemple,
pour le premier disque IDE : fdisk /dev/hda.

2.2.3. Formatage
Les commandes de création des principaux types de système de fichiers supportés par Linux
sont présentées dans le tableau suivant.
Système de fichiers Commande de création
ext2 mke2fs ou mkfs.ext2
ext3 mke2fs -j ou mkfs.ext3
reiserfs mkreiserfs
xfs mkfs.xfs
vfat mkfs.vfat
Tableau 2-2 : Commandes de création de systèmes de fichiers
 L'instruction générale de création d’un système de fichiers est :
 mkfs -t type-de-fichier partition.
 Exemples de formatage de la partition hda1 avec création d'un système de fichiers de
type ext3 (les trois commandes sont équivalentes) :
 mkfs.ext3 /dev/hda1
 mkfs -t ext3 /dev/hda1
 mke2fs -j /dev/hda1 # création du journal spécifique.
 Il est aussi très facile de transformer une partition ext2 en ext3 avec l'instruction
tune2fs pour créer le journal : tune2fs -j /dev/hda1.
2.2.4. Contrôle de l'intégrité du système de fichiers et réparation
 L'instruction générale de vérification du système de fichiers est :
 fsck -t type-de-fichier partition.
 Il existe des commandes équivalentes pour chaque type de système de fichiers, par
exemple fsck.ext3.

 Une vérification de toutes les partitions est faite au démarrage du système par la
commande fsck.
 La commande e2fsck est équivalente à fsck –t ext2.
 L’utilitaire debugfs est utilisé pour examiner et modifier l’état d’un système de
fichiers formaté en ext2.
 L’utilitaire dumpe2fs permet d’afficher les informations d’un système de fichiers
formaté en ext2.
2.2.5. Montage et démontage d'un système de fichiers
Pour pouvoir utiliser un système de fichiers, celui-ci doit être monté sur un point de montage
de l'arborescence Linux : son contenu est alors accessible comme un simple répertoire.
La commande mount accepte deux arguments :
 Le premier est le fichier spécial correspondant à la partition contenant le système de
fichiers.
 Le second est le répertoire sous lequel il sera monté (point de montage).
La commande umount permet le démontage du système de fichiers.
 Exemple : pour monter et démonter une clé USB de type « flashdisk » décrite par le
fichier device sda1, on utilise les commandes suivantes :
 mount /dev/sda1 /mnt/flashdisk
 umount /mnt/flashdisk
Le fichier /etc/fstab est utilisé pour le montage automatique des systèmes de fichiers au
moment du démarrage du système.
Les commandes mount et umount utilisent le fichier fstab. Il est important que les données
de ce fichier soient complètes et exactes.
La commande mount –a monte tous les systèmes de fichiers répertoriés dans le fichier fstab.
Cette commande est généralement exécutée au moment de démarrage du système.

La commande df permet de connaître le taux d'utilisation de toutes les partitions montées du
système. L'option -h (human readable) facilite la lecture en utilisant des unités de taille plus
commodes (Mo, Go, To, etc.).
La commande du (disk usage) est très pratique pour connaître l'espace occupé par une
arborescence. L'option -s permet d'afficher le total pour chaque élément et l'option -k de
l'afficher en kilo-octets : du -ks /usr/local.

Chapitre 3. Les commandes GNU/Linux
Chapitre 3 : Les commandes GNU/Linux
֍ Durée : 3 heures.
֍ Mots clés : Shell, chemin relatif, chemin absolu, redirection, gestionnaire de paquets,
pwd, ls, lsattr, du, cd, mkdir, rmdir, chmod, chattr, touch, file, iconv, tr, cat, more, less,
head, tail, tac, nl, wc, uniq, grep, sort, cut, paste, cp, ln, mv, split, rm, comm, diff, cat,
tee, find, locate, tar, gzip, bzip2, gunzip, bunzip2, unzip, man, which, whereis, whatis,
apropos.
» Définir un interpréteur de commandes.
» Appliquer les commandes de manipulation des fichiers et répertoires.
» Distinguer les commandes d'archivage et de compression.
» Utiliser les commandes d'aide et d'informations.
Plan du chapitre :
3.1. Le Shell.......................................................................................................................... 18
3.1.1. Présentation............................................................................................................. 18
3.1.2. Les caractères spéciaux du Shell............................................................................. 18
3.1.2.1. Nom de fichiers et de répertoires ..................................................................... 18
3.1.2.2. Les autres caractères spéciaux.......................................................................... 19
3.2. Fichiers et répertoires .................................................................................................... 19
3.3. Redirections des entrées-sorties..................................................................................... 20
3.4. Les gestionnaires de paquets ......................................................................................... 21
3.5. Les principales commandes GNU/Linux ...................................................................... 21
3.5.1. Les commandes relatives aux répertoires ............................................................... 21
3.5.1.1. La commande « pwd » ..................................................................................... 22
3.5.1.2. La commande « ls » ......................................................................................... 22

3.5.1.3. La commande « lsattr ».................................................................................... 23
3.5.1.4. La commande « du »........................................................................................ 23
3.5.1.5. La commande « cd » ........................................................................................ 24
3.5.1.6. La commande « mkdir »................................................................................... 24
3.5.1.7. La commande « rmdir » ................................................................................... 24
3.5.1.8. La commande « chmod » ................................................................................. 24
3.5.1.9. La commande « chattr »................................................................................... 25
3.5.2. Les commandes relatives aux fichiers .................................................................... 26
3.5.2.1. La commande « touch » ................................................................................... 27
3.5.2.2. La commande « file »....................................................................................... 27
3.5.2.3. La commande « iconv » ................................................................................... 27
3.5.2.4. La commande « tr ».......................................................................................... 28
3.5.2.5. La commande « cat » ....................................................................................... 28
3.5.2.6. La commande « more ».................................................................................... 29
3.5.2.7. La commande « less »...................................................................................... 29
3.5.2.8. La commande « head »..................................................................................... 29
3.5.2.9. La commande « tail »....................................................................................... 30
3.5.2.10. La commande « tac » ..................................................................................... 30
3.5.2.11. La commande « nl »....................................................................................... 30
3.5.2.12. La commande « wc » ..................................................................................... 30
3.5.2.13. La commande « uniq »................................................................................... 31
3.5.2.14. La commande « grep »................................................................................... 31
3.5.2.15. La commande « sort ».................................................................................... 32
3.5.2.16. La commande « cut » ..................................................................................... 33
3.5.2.17. La commande « paste ».................................................................................. 33
3.5.2.18. La commande « cp » ...................................................................................... 34
3.5.2.19. La commande « ln »....................................................................................... 34
3.5.2.20. La commande « mv »..................................................................................... 34
3.5.2.21. La commande « split » ................................................................................... 35
3.5.2.22. La commande « rm »...................................................................................... 35
3.5.2.23. La commande « comm »................................................................................ 36
3.5.2.24. La commande « diff » .................................................................................... 36
3.5.2.25. La commande « tee » ..................................................................................... 37

3.5.2.26. La commande « find ».................................................................................... 37
3.5.2.27. La commande « locate »................................................................................. 38
3.5.3. Les commandes d'archivage et de compression...................................................... 39
3.5.3.1. La commande « tar »........................................................................................ 39
3.5.3.2. La commande « gzip » ..................................................................................... 40
3.5.3.3. La commande « bzip2 » ................................................................................... 40
3.5.3.4. La commande « gunzip » ................................................................................. 41
3.5.3.5. La commande « bunzip2 » ............................................................................... 41
3.5.3.6. La commande « unzip » ................................................................................... 42
3.5.4. Commandes d’aide et d’informations..................................................................... 42
3.5.4.1. La commande « man » ..................................................................................... 42
3.5.4.2. La commande « which » .................................................................................. 42
3.5.4.3. La commande « whereis »................................................................................ 42
3.5.4.4. La commande « whatis ».................................................................................. 43
3.5.4.5. La commande « apropos » ............................................................................... 43

3.1. Le Shell
3.1.1. Présentation
C'est un programme séparé du noyau qui réalise plusieurs tâches :
 interprète les commandes tapées au clavier par l'utilisateur et exécute les programmes.
 fournit à l'utilisateur un langage de programmation interprété.
 permet de modifier l'environnement de travail.
 réalise les redirections des entrées-sorties.
Il en existe plusieurs versions : le Bourne Shell (sh), le C Shell (csh), le Korn Shell (ksh), le
bash, le tcsh, etc.
Sous GNU/Linux, le Shell généralement utilisé est le bash.
3.1.2. Les caractères spéciaux du Shell
Un certain nombre de caractères ont une signification spéciale.
3.1.2.1. Nom de fichiers et de répertoires
Six caractères servent à générer les noms de fichiers ou de répertoires :
 . qui désigne le répertoire courant.
 .. qui désigne le répertoire père, c'est à dire celui qui se trouve immédiatement au-
dessus du répertoire courant dans la hiérarchie.
 ~ qui désigne le répertoire d'accueil.
 ? remplace un caractère quelconque.
 * remplace une chaîne de caractères quelconque (y compris une chaîne vide).
 [...] remplace les caractères entre crochets, définis par énumération ou par intervalle.
 Exemples :
 [Aa] désigne les caractères A ou a.
 [a-zA-Z] désigne un caractère alphabétique quelconque.

3.1.2.2. Les autres caractères spéciaux
 # introduit un commentaire.
 $ introduit un nom de variable.
 & lance la commande en background.
 ; sépare 2 commandes tapées sur une même ligne.
 !! relance la commande précédente.
 !ch relance la dernière commande commençant par ch.
 !n relance la commande numéro n.
 ^ch1^ch2 remplace la chaîne ch1 par la chaîne ch2 dans la dernière commande.
 Exemple, si la dernière commande est : cat biodn.txt, la commande ^od^do
générera la ligne de commande : cat bidon.txt.
 <, <<, >, >> et | sont des caractères utilisés pour les redirections des entrées-sorties.
 ' délimite une chaîne de caractères contenant des espaces sans substitution de
variables.
 " délimite une chaîne de caractères contenant des espaces avec substitution de
variables.
 annule la signification du caractère spécial suivant.
 ( et ) font exécuter les commandes incluses dans un sous-Shell.
 { et } regroupent les commandes incluses en une liste.
3.2. Fichiers et répertoires
Un nom de fichier (ou de répertoire) peut être constitué de lettres minuscules, majuscules, de
chiffres et de quelques autres caractères comme « . », « _ », « - ».
Le « . » n'a pas la notion d'extension que l'on trouve, par exemple, sous Windows. Un nom de
fichier peut d'ailleurs comporter plusieurs « . ».
Les noms de fichiers Unix sont limités à 255 caractères et les chemins absolus à 1024.
Pour spécifier un nom de fichier, il est possible de donner soit son chemin relatif, soit son
chemin absolu.

Le chemin absolu commence par la racine, notée / et indique le chemin à parcourir depuis
celle-ci jusqu'au répertoire ou fichier désiré.
Par exemple /home/user1/tp/tp1.f est le chemin absolu jusqu'au fichier tp1.f, lui-même
contenu dans le sous-répertoire tp de l'utilisateur user1.
Le chemin relatif commence par un nom de fichier ou de répertoire, ou éventuellement par un
des 3 caractères spéciaux du Shell : « . », « .. » et « ~ ».
Par exemple, le fichier désigné précédemment par son chemin absolu peut également être
désigné par son chemin relatif. En supposant que l'utilisateur user1 se trouve dans son
répertoire d'accueil on peut désigner le fichier par : tp/tp1.f ou ./tp/tp1.f ou
../user1/tp/tp1.f ou ~/tp/tp1.f.
3.3. Redirections des entrées-sorties
Il est possible, sous Unix, de rediriger l'entrée ou la sortie d'une commande :
 < : redirection de l'entrée.
 Exemple : grep abc < essai, la chaîne abc est recherchée dans le fichier
essai.
 > : redirection de la sortie.
 Exemple : ls > liste, le résultat de la commande ls est copié dans le fichier
liste. Si le fichier n'existe pas, il est créé, sinon son contenu est écrasé.
 >> : redirection de la sortie avec concaténation.
 Exemple : ls >> liste2, si le fichier liste2 n'existe pas, il est créé, sinon le
résultat de la commande ls est ajouté à la fin du fichier liste2.
 | : redirection de la sortie d'une commande sur l'entrée de la commande suivante.

 Exemple : ls | grep *.c, la sortie de la commande ls sert d'entrée à la
commande grep. Ici, on cherche tous les fichiers sources C dans le répertoire
courant.
3.4. Les gestionnaires de paquets
Dans les distributions GNU/Linux, un paquet (package) est un fichier d'archives compressé
contenant l'ensemble des fichiers nécessaires au fonctionnement d'une application donnée.
Les paquets contiennent aussi la liste des autres paquets (dépendances) dont l'application a
besoin.
Il existe de nombreuses distributions GNU/Linux. Les plus courantes sont :
 La distribution "Debian" et ses dérivées (Ubuntu, Mint, Linspire, Mepis, etc.) qui
utilisent le format .deb.
 La distribution "RedHat" et ses dérivées (CentOS, Fedora, Mandriva, Scientific Linux,
etc.) ainsi que "openSUSE" qui utilisent le format .rpm.
3.5. Les principales commandes GNU/Linux
Le format d'une commande est généralement de la forme :
commande [-option1] [-option2] [-optionn] [arg1] [arg2] [argn] ...
Les options et arguments forment ce que l'on appelle les paramètres de la commande. Les
arguments présentent généralement un ou plusieurs noms de fichiers ou de répertoires.
GNU/Linux est sensible à la casse, c'est-à-dire qu’il fait la différence entre une majuscule et
une minuscule. Ainsi "essai", "Essai" ou "ESSAI" désignent des fichiers différents.
3.5.1. Les commandes relatives aux répertoires
 Afficher le chemin absolu du répertoire courant : pwd
 Afficher le contenu d'un répertoire : ls
 Afficher les attributs de répertoires : lsattr
 Afficher la taille d'un répertoire : du

 Changer de répertoire : cd
 Créer un répertoire : mkdir
 Supprimer un répertoire : rmdir
 Changer les droits d'accès aux répertoires : chmod
 Changer les attributs de répertoires : chattr
3.5.1.1. La commande « pwd »
La commande pwd affiche le chemin absolu du répertoire courant.
 Syntaxe : pwd
3.5.1.2. La commande « ls »
La commande ls affiche le contenu d'un répertoire ou d'une liste de fichiers.
 Syntaxe : ls [-alrtR] répertoire ou ls [-alrtR] fichiers
 Options principales :
 -a : affiche également les fichiers commençant par un point.
 -l : affiche en format long c'est à dire avec type (répertoire, fichier), droits
d'accès, nombre de liens, nom du propriétaire, nom du groupe, taille en octets,
date de dernière modification, nom.
 -r : inverse l'ordre du tri.
 -t : trie par date de dernière modification.
 -R : récursif.
 Exemples :
 ls -aR ~ : affiche la liste des fichiers et sous-répertoires contenus dans le
répertoire d'accueil de l'utilisateur.
 ls *.c : affiche la liste de tous les fichiers sources C du répertoire courant.

3.5.1.3. La commande « lsattr »
La commande lsattr affiche les attributs de répertoires ou de fichiers dans un filesystem
ext2, ext3 ou ext4.
 Syntaxe : lsattr [-Rad] répertoires ou lsattr fichiers
 -R : liste récursivement les attributs d'un (des) répertoire(s).
 -a : liste tous les fichiers du (des) répertoires y compris les fichiers
commençant par « . ».
 -d : affiche les répertoires comme les fichiers plutôt que d'afficher leur
contenu.
3.5.1.4. La commande « du »
La commande du affiche la taille d'un répertoire.
 Syntaxe : du [-ask] répertoire
 -a : affiche la taille de tous les fichiers.
 -s : affiche le total de chaque répertoire.
 -k : affiche le résultat en kilo-octets (et non en blocs de 512 octets).
 Exemples :
 du -k affiche en kilo-octet la taille des fichiers (ou sous-répertoires) du
répertoire courant.
 du -sk ~/tp affiche en kilo-octet la taille totale du répertoire tp contenu dans
le répertoire d'accueil de l'utilisateur.

3.5.1.5. La commande « cd »
La commande cd change le répertoire courant.
 Syntaxe : cd répertoire
 Exemples :
 cd /home/user1/tp fait passer dans le répertoire tp de l'utilisateur user1.
C'est équivalent à cd ~user1/tp.
 En tapant cd (sans argument), on se retrouve dans le répertoire d'accueil.
3.5.1.6. La commande « mkdir »
La commande mkdir crée un répertoire.
 Syntaxe : mkdir [-p] répertoire
 Option principale : -p crée le(s) répertoire(s) intermédiaire(s).
 Exemple : on veut créer le sous-répertoire tp1 dans le répertoire tp. Si tp existe déjà,
on tape mkdir tp/tp1 sinon mkdir -p tp/tp1 qui crée tp et tp1.
3.5.1.7. La commande « rmdir »
La commande rmdir supprime un répertoire si et seulement s’il est vide. Sinon, il faut utiliser
la commande rm.
 Syntaxe : rmdir répertoire
 Exemple : rmdir tp2 supprime le répertoire tp2 s’il est vide.
3.5.1.8. La commande « chmod »
La commande chmod change les droits d'accès aux répertoires ou aux fichiers. On ne peut
modifier les droits d'accès à un ou plusieurs répertoires ou fichiers que si l'on en est
propriétaire.
 Syntaxe : chmod [-R] [ugoa] [+/-r] [+/-w] [+/-x] répertoire(s) ou :
chmod [ugoa] [+/-r] [+/-w] [+/-x] fichier(s)

 Type d'utilisateur :
 u : propriétaire (user).
 g : groupe du propriétaire (group).
 o : les autres (other).
 a : tous (all).
 Type d'action :
 + signifie qu'on ajoute des droits d'accès.
 - signifie qu'on enlève des droits d'accès.
 Type d'accès :
 r : lecture (read permission).
 w : écriture (write permission).
 x : exécution (execute permission).
 Exemple : chmod -R g+r tp donne les accès en lecture au sous-répertoire tp à tous
les membres du groupe.
3.5.1.9. La commande « chattr »
La commande chattr change les attributs de répertoires ou de fichiers dans un filesystem
ext2, ext3 ou ext4.
 Syntaxe : chattr [-Rvf][mode] répertoires ou : chattr [-Vf][mode] fichiers
 -R : change récursivement les attributs d'un répertoire.
 -V : affichage en mode verbeux.
 -f : supprime la plupart des messages d'erreur.
 Attributs : Le format du mode est [+-=][acdeijstuADST]
 l'opérateur + ajoute l'attribut.
 l'opérateur - retire l'attribut.

 l'opérateur = définit l'attribut.
3.5.2. Les commandes relatives aux fichiers
 Modifier le timestamp de dernier accès et de dernière modification d'un fichier : touch
 Identifier le type d'un fichier : file
 Convertir l'encodage : iconv
 Transposer ou éliminer des caractères : tr
 Afficher le contenu d'un fichier :
 en entier : cat
 page par page : more, less
 le début : head
 la fin : tail
 en ordre inverse : tac
 précédé des numéros de lignes : nl
 Compter les mots et les lignes d'un fichier : wc
 Rechercher les lignes multiples dans un fichier : uniq
 Chercher une chaîne de caractères dans un fichier : grep
 Trier les champs d'un fichier : sort
 Extraire des champs d'un fichier : cut
 Ajouter des champs à un fichier : paste
 Copier un fichier : cp
 Créer un lien sur un fichier : ln
 Déplacer ou changer le nom d'un fichier : mv
 Découper un fichier : split
 Supprimer un fichier : rm
 Comparer 2 fichiers :
 Rechercher les lignes identiques : comm
 Rechercher les lignes différentes : diff
 Concaténer 2 fichiers : cat

 Copier l'entrée standard sur la sortie standard et dans un fichier : tee.
 Rechercher un fichier :
 Rechercher dans un répertoire : find
 Rechercher dans une base de données : locate
3.5.2.1. La commande « touch »
La commande touch modifie le timestamp de dernier accès et de dernière modification d'un
fichier. Si aucun fichier n’est spécifié en argument, un fichier vide est créé avec l'horodatage
courant.
3.5.2.2. La commande « file »
La commande file identifie le type d'un fichier (fichier texte ; fichier archivé, compressé ou
codé ; fichier non imprimable ; fichier image). Si file ne reconnaît pas le type d'un fichier, il
affiche data.
 Syntaxe : file fichier
 Exemple : file Fich1 renvoie ASCII text.
3.5.2.3. La commande « iconv »
La commande iconv convertit l'encodage.
 Syntaxe : iconv -f oldcode -t newcode entree -o sortie
 Exemple : iconv -f latin1 -t utf8 test.iso -o test.unic convertit le fichier
test.iso en test.unic de l'encodage iso-latin en utf-8.

3.5.2.4. La commande « tr »
La commande tr transpose ou élimine des caractères.
 Syntaxe : tr [-cstd] chaine1 chaine2
 -c ou --complement : remplace chaine1 par son complément c'est à dire tous
les caractères n'appartenant pas à chaine1.
 -s ou --squeeze-repeats : remplace chaque répétition de caractères
appartenant à chaine1 par une seule occurrence de ce caractère.
 -d ou --delete car : supprime tous les caractères car présents dans
chaine1.
 Exemples :
 Convertir de minuscules en majuscules (de 3 manières différentes) :
 tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
 tr a-z A-Z
 tr '[:lower:]' '[:upper:]'
 Afficher chaque mot sur une ligne indépendante en convertissant tous les
caractères non alphanumériques en sauts de lignes, puis en regroupant les
lignes blanches successives en un seul saut de ligne : tr -cs '[a-zA-Z0-9]'
'[n*]'.
 Convertir les séquences de sauts de lignes en un seul saut de ligne donc en
supprimant les lignes blanches : tr -s 'n'.
3.5.2.5. La commande « cat »
La commande cat affiche le contenu d'un fichier.
 Syntaxe : cat [-n] fichier
 Option principale : -n numérote les lignes
 Exemples :

 cat -n essai1 : affiche le fichier essai1 à l'écran en numérotant les lignes.
 cat essai1 essai2 : affiche à l'écran le fichier essai1 puis le fichier
essai2.
3.5.2.6. La commande « more »
La commande more affiche le contenu d'un fichier page par page.
 Syntaxe : more [-c] fichier
 Option principale : -c efface la fenêtre avant l'affichage.
 Exemple : more essai.c affiche la première page du fichier essai.c.
 La touche espace permet d’afficher la page suivante.
 La touche [ Enter] permet d’afficher la ligne suivante.
 La touche h permet d’accéder à l'aide en ligne.
 La touche q permet de quitter.
3.5.2.7. La commande « less »
La commande less affiche le contenu d'un fichier page par page. Elle peut être considérée
comme le successeur de more. Elle fait la même chose mais offre davantage de possibilités,
comme le retour en arrière.
 Syntaxe : less [-c] fichier
 Option principale : -c efface la fenêtre avant l'affichage.
3.5.2.8. La commande « head »
La commande head affiche le début d'un fichier.
 Syntaxe : head [-n] fichier
 Option principale : -n affiche les n premières lignes du fichier. Par défaut, n = 10.
 Exemple : head -10 *.c affiche les 10 premières lignes de tous les fichiers sources C
du répertoire courant.

3.5.2.9. La commande « tail »
La commande tail affiche la fin d'un fichier.
 Syntaxe : tail [-n] fichier
 Option principale : -n affiche les n dernières lignes du fichier. Par défaut, n = 10.
 Exemple : tail -50 essai affiche les 50 dernières lignes du fichier essai.
3.5.2.10. La commande « tac »
La commande tac affiche le contenu d'un fichier en ordre inverse, c'est à dire en commençant
par la fin.
 Syntaxe : tac fichier
 Exemple : tac essai.txt : affiche le fichier essai.txt en ordre inverse, c'est à dire
en commençant par la fin.
3.5.2.11. La commande « nl »
La commande nl affiche les lignes d'un fichier précédées de leur numéro.
 Syntaxe : nl [-ba] fichier
 Options principales : -ba numérote aussi les lignes blanches (ou vides).
 Exemple : nl -ba essai.c affiche toutes les lignes du fichier essai.c précédées de
leur numéro.
3.5.2.12. La commande « wc »
La commande wc compte le nombre de lignes, de mots ou de caractères d'un fichier.
 Syntaxe : wc [-clw] fichier
 -c : renvoie le nombre de caractères (octets).
 -l : renvoie le nombre de lignes.
 -w : renvoie le nombre de mots.

 Exemple : wc -l essai.c renvoie le nombre de lignes du fichier essai.c.
3.5.2.13. La commande « uniq »
La commande uniq recherche les lignes consécutives identiques dans un fichier.
 Syntaxe : uniq [-udc] fichier
 -u : affiche les lignes consécutives identiques une seule fois.
 -d : n'affiche que les lignes consécutives identiques.
 -c : chaque ligne est précédée de son nombre d'occurrences.
3.5.2.14. La commande « grep »
La commande grep recherche une (ou plusieurs) expression(s) dans un fichier.
 Syntaxe : grep [-cilnrvE] expression fichier
 -c : affiche le nombre de lignes contenant l'expression.
 -i : contrairement à la plupart des commandes, l'option -i ne signifie pas
interactif mais ignore-case, c'est à dire que grep ne fera pas de différence
entre minuscules et majuscules.
 -l : n'affiche que le nom des fichiers contenant l'expression.
 -n : affiche les numéros des lignes contenant l'expression.
 -r : recherche récursivement dans les sous-répertoires du répertoire courant.
 -v : inverse la recherche, c'est à dire affiche les lignes ne contenant pas
l'expression.
 -w : recherche exactement l'expression et non les mots contenant l'expression.
 -E ou --extended-regexp : expression régulière étendue qui permet de
rechercher plusieurs expressions en même temps.
 -A n : affiche n lignes supplémentaires après les lignes qui concordent.
 -B n : affiche n lignes supplémentaires avant lignes qui concordent.

 Exemples :
 grep -i -c 'integer' * : affiche le nombre de fois où les expressions
integer, Integer ou INTEGER sont rencontrées dans chaque fichier du
 grep -Eir "fortran|Python" /codes : cherche les chaînes fortran ou
Python, sans tenir compte de la casse, dans le répertoire /codes et ses sous-
répertoires.
3.5.2.15. La commande « sort »
La commande sort trie les champs d'un fichier.
 Syntaxe : sort [-fnru] [-t car] [+i] [-j] [-o sortie] fichier
 -f : ne tient pas compte des minuscules et majuscules.
 -n : trie numérique et non alphabétique.
 -r : inverse l'ordre de tri.
 -u : n'affiche qu'une fois les lignes multiples.
 -t car : indique le caractère séparateur de champs (par défaut, c'est l'espace).
 -o sortie : écrit le résultat dans le fichier sortie.
 +i : on trie à partir du i-ième champ. i=0, 1, ….
 -j : on trie jusqu'au j-ième champ.
 Exemples :
 sort +1 liste trie le fichier liste (liste de prénoms et noms, e.g. Robert
BIDOCHON) par ordre alphabétique des noms.
 sort -n -t : +1 -2 adresses : trie le fichier adresses (liste de prénoms,
numéros de téléphone et villes, e.g. robert:0380234567:Dijon) par numéros de
téléphones.

3.5.2.16. La commande « cut »
La commande cut extrait des champs d'un fichier.
 Syntaxe : cut [-cf] [-d car] [+i] [-j] fichier
 -c : extrait suivant le nombre de caractères.
 -f : extrait suivant le nombre de champs.
 -d car : indique le caractère séparateur de champs (par défaut, c'est la
tabulation).
 +i : on trie à partir du i-ième champ. i=1, 2, ….
 -j : on trie jusqu'au j-ième champ.
 Exemples :
 cut -c10 adresses : extrait les 10 premiers caractères de chaque ligne.
 cut -d : -f2 adresses : extrait le deuxième champ.
3.5.2.17. La commande « paste »
La commande paste ajoute des champs à un fichier.
 Syntaxe : paste [-s] [-d car] fichier1 fichier2
 -s : les lignes sont remplacées par des colonnes.
 -d car : indique le caractère séparateur de champs (par défaut, c'est la
tabulation).

3.5.2.18. La commande « cp »
La commande cp copie de fichier. Pour copier plusieurs fichiers d'un seul coup, il faut utiliser
les caractères spéciaux du Shell.
 Syntaxe : cp [-ipr] source cible
 Option principale : -p le fichier cible conserve les permissions et la date de dernière
modification du fichier source (au lieu de la date courante).
 Exemples :
 cp tp1/* tp2 : copie tous les fichiers du répertoire tp1 dans le répertoire tp2.
 cp -ir tp1 tp2 : copie le répertoire tp1 dans le répertoire tp2 en demandant
confirmation à chaque fichier.
3.5.2.19. La commande « ln »
La commande ln crée un lien sur un fichier.
 Syntaxe : ln [-s] source cible
 Option principale : -s crée un lien symbolique. Créer un lien revient à définir un alias
à un fichier qui existe déjà. Un lien ne peut se faire qu'entre fichiers d'un même
filesystem. Sinon il faut utiliser l'option -s. De manière générale, il est recommandé
d'utiliser systématiquement l'option -s.
 Exemple : ln -s Mon_Fichier Mon_lien.
3.5.2.20. La commande « mv »
La commande mv déplace ou change le nom d'un fichier.
 Syntaxe : mv [-fi] source cible. Si cible est un nom de fichier, source est
renommé en cible. Si cible est un nom de répertoire, source est déplacé dans le
répertoire cible.
 Option principale : -f force la commande.

 Exemples :
 mv essai1 essai2 renomme le fichier essai1 en essai2.
 mv tp11.c tp/tp1 : déplace le fichier tp11.c dans le répertoire tp/tp1.
3.5.2.21. La commande « split »
La commande split découpe un fichier.
 Syntaxe : split [-n] fichier [nom]
 -n : découpe fichier en fichiers de n lignes (par défaut, 1000 lignes).
 nom : par défaut les fichiers créés sont nommés xaa, xab, xac, ... jusqu'à xzz.
Avec cette option, on remplace x par nom : on obtient donc les fichiers nomaa,
nomab, etc.
 Exemple : split -100 essai.c petit découpe le fichier essai.c en fichiers de
100 lignes nommés petitaa, petitab, etc.
3.5.2.22. La commande « rm »
La commande rm supprime un fichier ou un répertoire.
 Syntaxe : rm [-if] fichier ou rm [-if] -r répertoire
 -i : le système demande confirmation avant la suppression définitive.
 -f : force la commande.
 Exemples :
 rm essai2 : suppression du fichier essai2.
 rm -r tp : suppression du répertoire tp.

3.5.2.23. La commande « comm »
La commande comm recherche les lignes identiques à 2 fichiers.
 Syntaxe : comm [-123] fichier1 fichier2. Elle sépare les lignes en 3 groupes :
1. Les lignes présentes seulement dans le premier fichier.
2. Les lignes présentes seulement dans le deuxième fichier.
3. Les lignes présentes seulement dans les 2 fichiers.
 Options :
 -1 : n'affiche pas les lignes du premier groupe.
 -2 : n'affiche pas les lignes du deuxième groupe.
 -3 : n'affiche pas les lignes du troisième groupe.
3.5.2.24. La commande « diff »
La commande diff recherche les lignes différentes à 2 fichiers.
 Syntaxe : diff fichier1 fichier2
 -b : ignore les espaces.
 -i : contrairement à la plupart des commandes, l'option -i ne signifie pas
interactif mais ignore-case, c'est à dire que diff ne fera pas de différence
entre minuscules et majuscules.
 -w : ignore les espaces et les tabulations.
 --side-by-side : affiche le contenu des 2 fichiers côte à côte et non pas l'un
au dessous de l'autre.

3.5.2.25. La commande « tee »
La commande tee copie l'entrée standard sur la sortie standard, et dans tous les fichiers
fournis en argument.
Si un fichier n'existe pas, il est créé. Si le fichier existe déjà, il est écrasé, à moins que l'option
-a soit précisée.
 Syntaxe : tee [-ai][--append][--ignore-interrupts][--help][fichier...]
 -a, --append : Ajouter l'entrée standard aux fichiers indiqués plutôt que de les
écraser.
 --help : Afficher un message d'aide sur la sortie standard et se terminer
normalement.
 -i, --ignore-interrupts : Ignorer les signaux d'interruption.
3.5.2.26. La commande « find »
La commande find recherche un (ou plusieurs) fichier(s) dans un répertoire. Cette commande
est automatiquement récursive.
 Syntaxe : find chemin critères
 -print affiche le résultat de la recherche.
 -name recherche sur le nom du fichier.
 -type recherche sur le type (d : répertoire, c : caractère, f : fichier).
 -size n : recherche sur la taille du fichier.
 -amin n : le fichier a été accédé il y a n minutes.
 -atime n : le fichier a été accédé il y a n fois 24 heures.
 -cmin n : le statut du fichier a changé il y a n minutes.
 -ctime n : le statut du fichier a changé il y a n fois 24 heures.

Pour les options -size, -amin, -atime, -cmin, et -ctime, on peut préciser :
 n : exactement n.
 -n : inférieur à n.
 +n : supérieur à n.
Ces options peuvent être combinées aux moyens des opérateurs logiques :
 -o : OU logique
 -a : ET logique
 ! : NON logique
 Exemples :
 find . -name tp1 -print : cherche le fichier ou le répertoire tp1 dans le
 find tp -name '*.c' -print : cherche tous les fichiers sources C dans le
répertoire tp.
 find tp -type d -print : cherche tous les sous-répertoires contenus dans le
répertoire tp.
 find . -size +1954 -print : cherche tous fichiers dont la taille est
supérieure à 1954 blocs (environ 1 Mo) dans le répertoire courant.
 find tp ( -name '*.c' -o -name '*.f' ) : cherche tous les fichiers
sources C ou FORTRAN dans le répertoire tp.
 find . ( -name '*.py' -a -amin -1000 ) : cherche tous les fichiers
Python accédés depuis moins de 1000 minutes.
3.5.2.27. La commande « locate »
La commande locate liste des fichiers d’une base de données correspondant à un motif. On
peut mettre à jour manuellement la base de données en utilisant la commande updatedb.
 Syntaxe : locate fichier
 -i effectue une recherche non sensible à la casse.

 -n X limite le nombre de résultats affichés au nombre X choisi,
 -r X ou --regexp=X recherche des fichiers dans la base de données en
utilisant une expression rationnelle X.
 Exemple : locate -i -n 12 toto | grep bin : affichera les douze premiers
résultats pour la requête non sensible à la casse de la chaîne toto en se limitant à ceux
dans lesquels la chaîne bin apparaît aussi, par exemple : /usr/bin/ToTo,
/mnt/bintoto ou encore /home/totoro/bin.
3.5.3. Les commandes d'archivage et de compression
 Archivage des données :
 tar
 Compression des données :
 gzip
 bzip2
 Décompression des données :
 gunzip
 bunzip2
 unzip pour les fichiers MS-DOS.
3.5.3.1. La commande « tar »
La commande tar archive des données.
 Syntaxe : tar [crtx][v]f cible source
 Type d'action :
 c : création d'une archive.
 r : ajout de fichier(s) ou de répertoire(s) à la fin d'une archive.
 t : liste du contenu d'une archive.
 x : extraction d'une archive.

 v : la commande affiche au fur et à mesure tout ce qu'elle fait.
 f : précise le nom du fichier cible.
 Exemples :
 tar cf tp.tar tp : le répertoire tp est archivé en tp.tar.
 tar rf tp.tar tp2 : ajoute le répertoire tp2 à la fin de l'archive tp.tar.
 tar tvf tp.tar : liste le contenu de l'archive tp.tar.
 tar xf tp.tar : extrait l'archive tp.tar, c'est à dire recrée le répertoire tp.
3.5.3.2. La commande « gzip »
La commande gzip compresse des données.
 Syntaxe : gzip [-h][-rtv] source
 -h : affiche la liste des options de gzip.
 -r : récursif. Dans ce cas source est un répertoire.
 -t : teste l'intégrité d'un fichier compressé.
 -v : la commande affiche au fur et à mesure tout ce qu'elle fait.
 -1 : compresse plus vite. Le résultat est plus gros.
 -9 : compresse mieux mais plus lentement.
 Exemple : gzip tp.tar compresse le fichier tp.tar en tp.tar.gz.
3.5.3.3. La commande « bzip2 »
La commande bzip2 compresse des données.
 Syntaxe : bzip2 [-h][-tv] source
 -h : affiche la liste des options de bzip2.
 -t : teste l'intégrité d'un fichier compressé.

 -1 : compresse plus vite. Le résultat est plus gros.
 -9 : compresse mieux mais plus lentement.
 Exemple : bzip2 tp.tar compresse le fichier tp.tar en tp.tar.bz2.
3.5.3.4. La commande « gunzip »
La commande gunzip décompresse des données.
 Syntaxe : gunzip [-h][-tv][-S suf] source.gz
 -h : affiche la liste des options de gunzip.
 -t : teste l'intégrité du fichier compressé.
 -S suf : autorise le suffixe .suf au lieu de .gz.
 Exemple : gunzip tp.tar.gz décompresse le fichier tp.tar.gz en tp.tar. La
commande gzip –d donne le même résultat.
3.5.3.5. La commande « bunzip2 »
La commande bunzip2 décompresse des données.
 Syntaxe : bunzip2 [-h][-tv] source.bz2
 -h : affiche la liste des options de bunzip2.
 -t : teste l'intégrité du fichier compressé.
 Exemple : bunzip2 tp.tar.bz2 décompresse le fichier tp.tar.bz2 en tp.tar. La
commande bzip2 –d donne le même résultat.

3.5.3.6. La commande « unzip »
La commande unzip décompresse des fichiers MS-DOS.
 Syntaxe : unzip [-h] source.zip ou unzip [-h] source.ZIP
 Option principale : -h affiche la liste des options de unzip.
 Exemple : unzip UTILS.ZIP décompresse le fichier UTILS.ZIP.
3.5.4. Commandes d’aide et d’informations
3.5.4.1. La commande « man »
La commande man affiche les pages de manuel expliquant les différentes commandes, leurs
fonctionnements et leurs options.
 Syntaxe : man commande
 Exemple : man ls
3.5.4.2. La commande « which »
La commande which permet de trouver l'emplacement d'une commande en effectuant sa
recherche par rapport au contenu de la variable PATH, et retourne le chemin du premier fichier
correspondant.
 Syntaxe : which commande
 Exemple : which ls
3.5.4.3. La commande « whereis »
La commande whereis fonctionne de façon similaire à which, peut aussi chercher dans les
pages de manuel (man) et les codes sources.
 Syntaxe : whereis commande
 Exemple : whereis ls

3.5.4.4. La commande « whatis »
La commande whatis cherche des commandes dans l'intégralité des systèmes de fichiers
comme which mais utilise une base de données qui contient une courte description ainsi que
des mots clés.
La base de données est créée en utilisant la commande makewhatis.
 Syntaxe : whatis commande
 Exemple : whatis who
3.5.4.5. La commande « apropos »
La commande apropos utilise la même base de données que whatis, mais donne plus
d'informations.
 Syntaxe : apropos commande
 Exemple : apropos who

Chapitre 4. Permissions d'accès aux Fichiers
Chapitre 4 : Permissions d'accès aux Fichiers
֍ Mots clés : chmod, umask, SUID, SGID, Sticky Bit, chown, chgrp.
» Modifier les droits d'accès sur les fichiers et les répertoires.
» Examiner les droits spéciaux.
» Modifier le propriétaire et le groupe sur les fichiers et les répertoires.
Plan du chapitre :
4.1. Les droits sur les fichiers et les répertoires.................................................................... 45
4.2. Modifier le propriétaire et le groupe sur les fichiers et les répertoires.......................... 47

Chapitre 4. Permissions d’accès aux fichiers
4.1. Les droits sur les fichiers et les répertoires
Linux permet de spécifier les droits dont disposent les utilisateurs sur un fichier ou un
répertoire par la commande chmod.
On distingue trois catégories d'utilisateurs :
 u : le propriétaire (user).
 g : le groupe.
 o : les autres (others).
Ainsi que trois types de droits :
 r : lecture (read).
 w : écriture (write).
 x : exécution.
 - : aucun droit.
Exemples :
 pour donner le droit de lire le fichier liste.txt au propriétaire du fichier :
chmod u+r liste.txt
 pour autoriser une personne du groupe propriétaire du fichier à modifier le fichier :
chmod g+w liste.txt
 pour autoriser les autres utilisateurs à exécuter le fichier commande.sh :
chmod o+x commande.sh
Les droits d'accès peuvent aussi s'exprimer en notation octale. Les correspondances sont
indiquées dans le tableau 4-1 suivant.
On peut utiliser la notation octale pour les droits avec la commande chmod, cela permet de
positionner plusieurs types de droits en une seule commande.

Exemples :
 attribuer les droits rw------- à tous les fichiers : chmod 600 *
 attribuer les droits rw-r--r-- à tous les fichiers : chmod 644 *
 attribuer les droits rwxr-x--- à tous les fichiers : chmod 750 *
Droit Notion octale Droit Notion octale
--- 0 r-- 4
--x 1 r-x 5
-w- 2 rw- 6
-wx 3 rwx 7
Tableau 4-1 : Expression des droits sur les fichiers en notation octale
Lorsqu’on crée un nouveau fichier, ce dernier possède certains droits par défaut. La
commande umask permet de changer ces droits par défaut. Les droits sont indiqués de façon
"inverse" en notation octale pour les droits de type r et w seulement.
 Pour créer des fichiers en mode rw-r--r-- : umask 022
 Pour créer des fichiers en mode ------- : umask 666
Les droits spéciaux
Il existe trois droits spéciaux, SUID, SGID et Sticky Bit. Ils peuvent être positionnés par la
commande chmod (premier groupe de droits exprimés en octal) :
 SUID (Set User ID) : Ce droit s'applique aux fichiers exécutables, il permet d'allouer
temporairement à un utilisateur les droits du propriétaire du fichier. Par exemple, la
commande /usr/bin/passwd permet d’acquérir les droits de root pour modifier le
fichier /etc/shadow.
Le bit SUID est positionné par l’option s de la commande chmod, ou bien en
positionnant à 1 le premier bit du groupe des droits spéciaux (d’où la valeur 4 de
l’exemple suivant) :
 chmod 4755 /bin/cat
 chmod u+s /bin/grep

 SGID (Set Group Id) : ce droit fonctionne de la même façon que le droit SUID en ce
qui concerne les exécutables mais en donnant à l’utilisateur les droits du groupe
auquel appartient le propriétaire de l'exécutable.
Le SGID peut aussi être attribué à un répertoire : dans ce cas tout fichier créé dans un
répertoire portant le SGID aura comme groupe propriétaire le groupe du répertoire.
Ce bit est positionné par l'option s de la commande chmod, ou bien en positionnant à 1
le deuxième bit du groupe des droits spéciaux (d’où la valeur 2 de l’exemple suivant) :
 chmod 2755 /home/lpi102
 chmod g+s /home/lpi102
 Sticky Bit : si le Sticky Bit est positionné sur un répertoire, seul le propriétaire
d'un fichier contenu dans ce répertoire pourra le renommer ou le supprimer, mais tous
les utilisateurs pourront y avoir accès. Le Sticky Bit est par exemple toujours
positionné sur les répertoires /tmp ou /var/mail/.
Ce bit est positionné par l'option t de la commande chmod, ou bien en positionnant à 1
le troisième bit du groupe des droits spéciaux (d’où la valeur 1 de l’exemple suivant) :
 chmod 1666 /home/lpi/partagé
 chmod o+t /home/lpi/partagé
Historiquement, le Sticky Bit positionné sur un fichier indiquait au système de le
maintenir en mémoire à la suite d’un premier chargement pour des questions
d’efficacité.
4.2. Modifier le propriétaire et le groupe sur les fichiers et les répertoires
La commande chown permet de spécifier le propriétaire d’un fichier ou d’un répertoire :
chown le_propriétaire /home/lpi/monfichier
Linux permet de spécifier le groupe d’un fichier ou d’un répertoire par la commande chgrp :
chgrp le_groupe /home/lpi/monfichier

Chapitre 5. Gestion des utilisateurs et des groupes
Chapitre 5 : Gestion des utilisateurs et des groupes
֍ Mots clés : useradd, usermod, userdel, id, newgrp, groups, groupadd, groupmod,
groupdel, passwd, gpasswd, /etc/passwd, /etc/shadow, /etc/group, /etc/login.defs,
chage.
» Gérer les comptes utilisateurs et les groupes.
» Interpréter les fichiers de configuration des utilisateurs et des groupes.
Plan du chapitre :
5.1. Les utilisateurs............................................................................................................... 49
5.2. Les groupes.................................................................................................................... 50
5.3. Les fichiers de configuration ......................................................................................... 51
5.3.1. Gestion des utilisateurs ........................................................................................... 51
5.3.2. Gestion des groupes ................................................................................................ 52
5.3.3. Fichiers de configuration par défaut ....................................................................... 52
5.4. Gestion des comptes et des options de création par défaut ........................................... 52
5.4.1. Comment bloquer un compte.................................................................................. 53
5.4.2. Gestion des informations d’expiration du compte.................................................. 53
5.4.3. Destruction d’un compte......................................................................................... 53

5.1. Les utilisateurs
Pour la création d’un utilisateur, on utilise la commande /usr/sbin/useradd ou son alias
/usr/sbin/adduser qui est un lien symbolique vers la commande précédente pour des
raisons de compatibilité historique.
 Syntaxe : /usr/sbin/useradd [options] nom-utilisateur
 Quelques options utiles :
 -c : commentaire.
 -g : groupe.
 -s : Shell.
Pour ajouter un utilisateur « user1 » dans le groupe « chefs » avec le Shell « tcsh » :
/usr/sbin/useradd -c 'User 1 le chef' -g 'chefs' -s '/bin/tcsh' user1
Les options par défaut se trouvent dans le fichier /etc/default/useradd, ou bien sont
listées par l’option -D de la commande useradd.
Chaque utilisateur possède un identifiant ou UID (user identifier), numéro généré
automatiquement et compris entre 500 et 60 000. Un autre intervalle de valeurs peut si
nécessaire être imposé. Il doit dans ce cas être spécifié dans le fichier /etc/login.defs.
Pour activer le compte, l’administrateur doit définir un mot de passe pour le compte par la
commande /usr/bin/passwd :
 Syntaxe : /usr/bin/passwd nom-utilisateur
 Exemple : /usr/bin/passwd user1
Cette commande permet également à l’utilisateur de changer lui-même son mot de passe.

5.2. Les groupes
Un utilisateur appartient toujours au moins à un groupe dit groupe primaire (primary group).
Si le groupe n’est pas spécifié au moment de la création du compte deux stratégies générales
sont employées pour assigner un groupe par défaut :
 Le groupe par défaut est le même pour tous. Il s’appelle par exemple « users » ;
 La distribution Red Hat a introduit la notion de groupe privé par utilisateur ou UPG
(User Private Group). Le nom du groupe est identique à celui du login.
Selon la stratégie employée, le masque par défaut (umask) de création est initialisé à 022 dans
le premier cas (classique) et à 002 dans le deuxième cas (UPG).
Si un utilisateur crée un fichier, celui-ci appartiendra par défaut au groupe primaire de
l’utilisateur. Un utilisateur peut appartenir à d’autres groupes, ce sont les groupes secondaires.
La commande id permet de connaître la liste des groupes auxquels l’utilisateur appartient.
Dans l’exemple qui suit, l’utilisateur « moi » appartient au groupe primaire « normal » et aux
groupes secondaires « compta » et « chefs ».
La commande newgrp permet de changer temporairement de groupe primaire, à condition que
le nouveau groupe soit un groupe secondaire de l’utilisateur ou que l’utilisateur en connaisse
le mot de passe. Par exemple : newgrp chefs. La commande id donne alors :
La commande groups permet elle aussi d’afficher les groupes auxquels appartient un
utilisateur.

Pour ajouter un groupe, on utilise la commande groupadd : groupadd forcats. Pour
supprimer un groupe, on utilise la commande groupdel : groupdel forcats. Ces
commandes mettent à jour le fichier /etc/group. Pour gérer les utilisateurs d’un groupe, on
utilise la commande gpasswd. Les options sont les suivantes :
 -a : ajout d’un utilisateur.
 -d : retrait d’un utilisateur.
 -A : affectation d’un administrateur au groupe.
Par exemple : gpasswd -a nicolas forcats.
5.3. Les fichiers de configuration
5.3.1. Gestion des utilisateurs
Le fichier /etc/passwd contient les informations sur les utilisateurs, structurées en 7
champs :
 Login.
 Mot de passe ou « x » s’il existe un fichier /etc/shadow.
 UID.
 GID.
 Description de l’utilisateur.
 Répertoire par défaut de l’utilisateur.
 Shell.
Les 7 champs sont présentés sur une ligne et séparés par le caractère « : ».
Une ligne extraite d’un fichier /etc/passwd avec utilisation d’un fichier /etc/shadow :

5.3.2. Gestion des groupes
Le fichier /etc/group contient les informations sur les groupes, structurées en 4 champs :
 Nom du groupe.
 Mot de passe du groupe ou « x » s’il existe un fichier /etc/gshadow.
 GID.
 Liste des utilisateurs du groupe.
Les 4 champs sont présentés sur une ligne et séparés par le caractère « : ».
5.3.3. Fichiers de configuration par défaut
Le fichier /etc/login.defs contient les informations par défaut sur la validité des comptes
et des mots de passe des utilisateurs. Ces informations sont stockées dans le fichier
/etc/shadow lors de la création du compte.
5.4. Gestion des comptes et des options de création par défaut
Les options de configuration d’un compte peuvent être modifiées par la commande usermod :
 -l : nouveau nom d’utilisateur.
 -c : commentaire.
 -g : groupe (il doit exister au préalable).
 -s : Shell.
 -d : chemin du répertoire home.
 -u : identifiant utilisateur (UID).
 -p : mot de passe à entrer en format md5.
 -e : informations d’expiration du compte.
Les options de configuration d’un groupe peuvent être modifiées par la commande groupmod:
 -n : nouveau nom du groupe.
 -g : identifiant du groupe (GID).

5.4.1. Comment bloquer un compte
Un moyen simple est de faire précéder le mot de passe par un « ! » dans les fichiers de
configuration. Lors de l’utilisation d'un fichier /etc/shadow, on peut remplacer également le
« x » dans le fichier /etc/passwd par un « * ».
Une autre méthode consiste à utiliser les commandes passwd et usermod :
 passwd –l
 usermod –L
Pour débloquer le compte en utilisant les mêmes commandes :
 passwd –u
 usermod –U
On peut aussi détruire le mot de passe : passwd –d. Enfin, on peut affecter à un utilisateur le
Shell par défaut /bin/false, ce qui l’empêche de se connecter.
5.4.2. Gestion des informations d’expiration du compte
Pour modifier les informations par défaut (/etc/login.defs) et les informations
d’expiration, on utilise la commande /usr/bin/chage :
5.4.3. Destruction d’un compte
On utilise la commande /usr/sbin/userdel. L’option -r (--remove-home) permet de
détruire également le contenu du répertoire home : userdel -r user1.

Chapitre 6. Système de gestion de processus
Chapitre 6 : Système de gestion de processus
֍ Mots clés : PID, init, systemd, ps, top, pstree, kill, killall, nice, renice, job, nohup.
» Lister les processus en cours d’exécution.
» Arrêter un ou plusieurs processus.
» Modifier la priorité d’un processus.
» Lancer un processus en tâche de fond.
Plan du chapitre :
6.1. Introduction ................................................................................................................... 55
6.2. La commande « ps »...................................................................................................... 55
6.3. La commande « top » .................................................................................................... 56
6.4. La commande « kill ».................................................................................................... 56
6.5. La commande « nice »................................................................................................... 57
6.6. La commande « renice »................................................................................................ 58
6.7. Les processus et le Shell................................................................................................ 58
6.8. La commande « nohup » ............................................................................................... 59

6.1. Introduction
Ce qui est désigné comme processus est une instance de programme s’exécutant à un instant
donné ainsi que son contexte (ou environnement). Ce dernier terme désigne l’ensemble des
ressources utilisées par le programme pour pouvoir se dérouler, comme par exemple la
mémoire, les fichiers ouverts, les droits associés, la priorité, etc.
Les processus sont identifiés par un numéro unique dans le système à un moment donné, le
PID. C'est à l’aide de ce nombre que l’on peut désigner une instance de programme et
interagir avec.
Les processus sont également caractérisés par un propriétaire. Il s’agit de l’utilisateur qui en a
demandé l’exécution. En général, seul ce propriétaire pourra entreprendre des actions sur le
processus.
Les processus sont créés par « clonage ». Le premier processus créé est le processus init
(systemd) qui est l’ancêtre de tous les autres.
La commande pstree affiche les processus sous forme d’arborescence. On peut donc
visualiser qui est le processus parent d’un autre. L’option –p affiche le PID de chaque
processus et l’option –u affiche le nom de l’utilisateur ayant lancé le processus.
6.2. La commande « ps »
La commande ps permet de lister les processus en cours d’exécution.
 Syntaxe : ps [-Aefl]
 -A : affiche tous les processus.
 -e : affiche tous les processus.
 -f : affiche toutes les informations.
 -l : affiche en format long.
 Exemple : ps -Af | head -5 affiche les informations relatives aux 4 premiers
processus.

UID PID PPID C STIME TTY TIME CMD
root 0 0 0 nov 08 ? 0:00 sched
root 1 0 0 nov 08 ? 0:03 /etc/init -
root 2 0 0 nov 08 ? 0:01 pageout
root 3 0 0 nov 08 ? 10:00 fsflush
Les 8 champs correspondent à :
 UID : propriétaire du processus.
 PID : numéro du processus.
 PPID : numéro du processus-père.
 C : obsolète.
 STIME : heure de début du processus.
 TTY : pseudo-terminal contrôlant le processus.
 TIME : durée d'exécution du processus.
 CMD : nom de la commande.
Dans la pratique, nous n'avons besoin que des champs UID, PID et éventuellement
TIME.
6.3. La commande « top »
La commande top 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, durée d’exécution d’un processus depuis son démarrage).
 Syntaxe : top [-d delay][-n iterations][-p pid}[-u user]
 Option principale : -d permet de spécifier des délais de rafraîchissement (en
secondes).
6.4. La commande « kill »
La commande kill permet de supprimer un processus.
 Syntaxe : kill –signal pid
 Option principale : -signal est le numéro du signal envoyé au processus :
 -1 : simule une déconnexion.
 -15 : ordonne au processus de se terminer normalement.

 -9 : ordonne au processus de se terminer inconditionnellement comme dans le
cas des processus qui bouclent.
 Exemple : On récupère le numéro du processus par la commande ps dans le champ
PID. La commande ps –Af | grep user1 renvoie la liste de tous les processus
lancés par l'utilisateur user1.
 user1 1724 1722 0 Nov 28 ? 0:00 –csh
 user1 1749 1747 1 Nov 28 ? 0:00 –csh
 user1 1759 1724 8 Nov 28 ? 46:16 essai.
Le processus 1759 correspondant au programme essai qui semble boucler (il tourne
depuis plus de 46 h). Pour le supprimer, on tape : kill -9 1759.
Si l’on ne connaît pas le PID du processus auquel on veut envoyer un signal, on peut le
désigner par son nom en utilisant la commande killall.
 Syntaxe : killall signal nom_du_processus
6.5. La commande « nice »
La priorité d’un processus peut être connue en examinant la colonne PRI du résultat des
commandes ps –l ou top. Plus la priorité est grande, plus de temps CPU est offert au
processus.
Le noyau gère la priorité moyennant une file d’attente de processus. Un utilisateur autorisé
peut modifier la priorité des processus à travers une valeur de gentillesse ou valeur nice
(colonne NI du résultat des commandes ps –l ou top).
La valeur nice varie de -20 à +19, plus elle est élevée, moins le processus est prioritaire.
La commande nice permet de modifier la priorité d'un processus au démarrage du processus.
 Syntaxe : nice [-n Valeur] [Commande [Arguments ...]]
 Option principale : -n indique la valeur de nice. L’utilisateur standard ne peut utiliser
qu’une valeur nice positive, seul le super-utilisateur (root) peut utiliser des valeurs
négatives.

 Exemple : nice -n 19 mon_programme. Cette commande lance mon_programme avec
la priorité la moins basse possible.
6.6. La commande « renice »
La commande renice permet de modifier la priorité d’un ou plusieurs processus en cours
d’exécution.
 Syntaxe : renice [-n] nouvelle_valeur_nice [[-p] pid ] [-g] prgg ] [-u]
utilisateur]
 Options :
 -n : la nouvelle priorité.
 -p : des identifiants de processus.
 -g : des identifiants de groupes de processus. Utiliser renice sur un groupe de
processus implique que tous les processus de ce groupe auront leur priorité
modifiée.
 -u : des noms d’utilisateurs. Lorsqu’un utilisateur est spécifié, tous les
processus appartenant à celui-ci auront leur priorité modifiée.
 Exemples :
 La commande ps -l | grep mon_processus permet d’obtenir le PID de
mon_processus.
 La commande renice -n 10 -p PID_de_mon_processus permet de modifier
la valeur de nice.
6.7. Les processus et le Shell
Si on lance un programme depuis un terminal, l’interpréteur de commande (Shell) ne rend la
main que quand le programme ainsi lancé est terminé. Il est possible d’interrompre ce
programme et de reprendre la main en utilisant la combinaison de touches <Ctrl>-<Z>.
Ajouter le signe « & » à la fin de la ligne de commande permet de lancer le programme en
arrière-plan – on parle aussi de tâche de fond – et de reprendre tout de suite la main : on

revient directement au prompt du Shell. Cette possibilité est surtout utile lorsqu’on travaille
en mode « console », ou à distance, et qu’on ne dispose que d’une seule fenêtre ouverte.
Dans l’exemple ci-dessous, le processus lancé en tâche de fond depuis le Shell est l’éditeur
emacs. La première valeur, entre crochets, est le numéro de job. La seconde valeur est le PID
de emacs.
emacs&
[1] 7522
Si plusieurs Shells sont utilisés simultanément – par exemple avec plusieurs fenêtres de
console – chacun aura ses propres processus fils et ne pourra agir sur ceux des autres Shells.
Le numéro de job identifie un processus de façon univoque par rapport au Shell à partir
duquel il a été lancé, mais plusieurs processus lancés à partir de Shells différents peuvent
avoir le même numéro de job.
On peut alors utiliser la commande jobs qui affichera la liste des processus s’exécutant en
arrière-plan.
On peut faire passer un processus en avant-plan (foreground) par la commande fg et le
remettre en arrière-plan (background) par la commande bg.
6.8. La commande « nohup »
La commande nohup permet de lancer un processus qui pourra rester actif aussi longtemps
que nécessaire, et ceci même après la déconnexion de l’utilisateur l’ayant initié.
Par défaut, quand un utilisateur se déconnecte, le Shell est quitté et un signal SIGHUP (signal
1) est envoyé aux processus enfants de ce Shell. L’action associée à ce signal est l’arrêt de ces
processus.
nohup ignore le signal SIGHUP (d’où son nom) puis exécute le programme indiqué en ligne de
commande, de sorte que celui-ci ignorera le signal SIGHUP.
Dans l’exemple qui suit, le script « mon_calcul_long » est lancé avec la commande nohup
pour que, si l’utilisateur se déconnecte avant que son exécution soit terminée, elle ne soit pas

interrompue. Notons qu’en plus d’utiliser la commande nohup pour ignorer le signal SGHUP,
on tape « & » en fin de ligne de commande pour que le script s’exécute en tâche de fond.
nohup mon_calcul_long &

Chapitre 7. La programmation Shell
Chapitre 7 : La programmation Shell
֍ Durée : 2 heures 30 minutes.
֍ Mots clés : /etc/shells, bash, variable, export, env, set, unset, script Shell, if, case, for,
while, function, expr, let, (()).
» Reconnaître les fichiers de configuration du Shell bash.
» Ecrire un script Shell.
» Utiliser les instructions if, case, for et while dans un script Shell.
» Utiliser les fonctions dans un script Shell.
» Employer les expressions arithmétiques dans un script Shell.
Plan du chapitre :
7.1. Introduction ................................................................................................................... 62
7.2. Le Shell, un interpréteur de commandes ....................................................................... 62
7.3. Utilisation de variables .................................................................................................. 63
7.4. Les scripts Shell............................................................................................................. 64
7.5. Syntaxe .......................................................................................................................... 65
7.5.1. Les tests................................................................................................................... 67
7.5.2. L’instruction « if » .................................................................................................. 68
7.5.3. L’instruction « case ».............................................................................................. 69
7.5.4. L’instruction « for »................................................................................................ 69
7.5.5. L’instruction « while »............................................................................................ 70
7.5.6. Les fonctions........................................................................................................... 71
7.5.7. Expressions arithmétiques « expr » ........................................................................ 71
7.5.8. Expressions arithmétiques « let, (()) ».................................................................... 72

Chapitre 7. La programmation shell
7.1. Introduction
Le Shell est un interpréteur de commandes. C'est un programme spécial qui joue le rôle
d'intermédiaire en interprétant les commandes passées par l'utilisateur.
7.2. Le Shell, un interpréteur de commandes
Il existe plusieurs types de Shells, les plus connus depuis Unix ayant une version améliorée
sous Linux. Le fichier /etc/shells contient une liste de tous les Shells disponibles :
/bin/ash, /bin/bash, /bin/bash1, /bin/csh, /bin/false, /bin/passwd, /bin/sh,
/bin/tcsh, /usr/bin/csh, /usr/bin/ksh, /usr/bin/tcsh, /usr/bin/zsh.
Les plus connus sont bash (version améliorée du Shell Bourne sous Unix), ksh (version
améliorée du Shell Korn sous Unix) et tcsh (version améliorée du Shell C sous Unix). La
commande help affiche la liste des commandes internes du Shell. Par défaut, c'est le Shell
Bash qui est installé avec Linux. C'est aussi le plus puissant et le plus utilisé.
L'initialisation du Shell bash, à son ouverture, se fait à l'aide de plusieurs scripts, qui
représentent autant de possibilités de le personnaliser. Dans l'ordre, les fichiers suivants sont
lus et exécutés :
1. le fichier /etc/profile, s'il existe.
2. le fichier $HOME/.bash_profile, s'il existe
3. sinon le fichier $HOME/.bash_login, s'il existe.
4. sinon le fichier $HOME/.profile, s'il existe, et si le fichier $HOME/.bash_profile
n'existe pas. Dans ce cas, le fichier .bashrc n'est pas pris en considération, même s'il
existe.
5. le fichier système /etc/bashrc.
6. le fichier de ressources .bashrc, s'il existe.
7. Dans le cas où bash est invoqué en tant que Shell, il n'exécute que les fichiers
/etc/profile et $HOME/.profile s'ils existent.
8. Pour personnaliser le Shell, il faut donc modifier les fichiers $HOME/.bash_profile
et/ou $HOME/.bashrc.

7.3. Utilisation de variables
Les interpréteurs de commande Linux distinguent deux types de variables : les variables
simples et les variables d'environnement. Les variables d'environnement ont la particularité
d'être connues de toutes les commandes lancées depuis l'interpréteur de commande courant.
L’affectation de variables se fait comme suit : variable="valeur". Avec bash, il ne doit pas
y avoir d’espace avant et après le signe « = ». L’accès au contenu s’effectue en ajoutant le
caractère $ au début du nom de la variable ou par l'expression ${nom-de-la-variable} :
Nous venons de définir une variable simple. Pour la transformer en variable d’environnement,
on utilise la commande export :
La commande env seule, sans option ni argument, permet d'afficher toutes les variables
d'environnement définies :
 SHELL : indique quel type de Shell est en cours d'utilisation.
 PATH : une liste des répertoires qui contiennent des exécutables qu’on souhaite pouvoir
lancer sans indiquer leur répertoire. Si un programme se trouve dans un de ces
dossiers, on pourra l'invoquer quel que soit le dossier où on se trouve.
 EDITOR : l'éditeur de texte par défaut qui s'ouvre lorsque cela est nécessaire.
 HOME : la position du dossier home.
 PWD : le dossier dans lequel on se trouve.
 OLDPWD : le dossier dans lequel on se trouve auparavant.
La commande set affiche la liste complète des variables définies (variables simples ou
variables d'environnement).
La commande unset permet de détruire une variable.

Voici certaines variables spéciales de bash :
 $$ : le numéro de processus (PID) de l’interpréteur de commande.
 $! : le numéro de processus (PID) de la dernière commande lancée en tâche de fond
(c'est-à-dire avec l’opérateur « & »).
 $? : la valeur retournée par la dernière commande.
 $ : la liste des options avec lesquelles l’interpréteur de commande a été appelé.
Dans le cadre d’une commande lancée à partir d'un fichier script :
 $# : désigne le nombre de paramètres accompagnant l’appel du script.
 $@ et $* : désignent l’ensemble des paramètres.
 $1, ..., $9, ${10}, ${11}, ... : désignent la valeur de chaque paramètre.
 $0 : désigne le nom (le chemin) du script.
Plusieurs variables sont définies au démarrage de l’interpréteur de commandes. La définition
de ces variables peut se trouver dans les fichiers lus par l’interpréteur au démarrage comme le
fichier /etc/profile pour tous les utilisateurs du système ou dans les fichiers personnels de
l'utilisateur ~/.profile, ~/.bash_profile, etc.
7.4. Les scripts Shell
Les scripts Shell sont des fichiers exécutables permettant de lancer successivement plusieurs
commandes. Pour créer un script Shell, il faut éditer un ficher, y entrer les commandes et le
rendre exécutable par une commande du type :
chmod 755 premier.sh ou chmod +x premier.sh.
Comme premier fichier, on peut faire, par exemple le fichier "premier.sh" :
#!/bin/sh
# Un premier script Shell.
echo -n "Aujoud'hui, le "
date

et l'appeler par la commande : ./premier.sh.
7.5. Syntaxe
Le script Shell suivant montre entre autres comment lire les arguments passés par l'utilisateur
à la suite du script, sélectionner les arguments à traiter, redéfinir les arguments si il n'y en a
pas qui ont été passés par l'utilisateur, afficher une variable dont le contenu a été définit par le
script, lire une entrée clavier et l'affecter à une variable, utiliser les différentes variables
spécialement définies par le Shell, qui contiennent des informations sur les programmes ou
sur les utilisateurs.
#!/bin/sh
# Exemples de programmation du Shell.
echo "Exemples de programmation du Shell ..."
echo "Utilisation : simple.sh <fichier> <argument>"
#--------------------#
# lire les arguments #
#--------------------#
echo "nom du script : $0"
echo "argument 1 : $1"
echo "tous les arguments : $*"
echo "tous les arguments sous forme séparée : $@"
echo "Il y a en tout $# arguments"
#-------------------------#
# Redéfinir les arguments #
#-------------------------#
a=1
b=2
c=3
d=4
e=5

set a b c d e
echo "Et maintenant, après le passage de set..."
echo "Tous les arguments : $* ($# arguments)"
shift
echo
echo "Et maintenant, après le passage de shift ..."
echo "$2 devient $1, $3 devient $2 ..."
set a b c d e
echo
echo "On refait un petit coût de set"
shift 3
echo
echo "Et maintenant, après le passage de shift 3 ..."
echo "$4 devient $1, $5 devient $2 ..."
#--------------#
# echo et read #
#--------------#
echo -n "Entrer deux chaînes de caractères : "
read moi toi
echo "Vous avez saisi : moi=$moi toi=$toi"
echo "Longueur du contenu de "moi" : ${#moi}"
# nb: pas d'espace !
moi=10

echo $moi
echo "dernière commande exécutée par le Shell : $?"
echo "no. de processus du Shell : $$"
echo "PID de la dernière commande exécutée en tâche de fond : $!"
echo "Fin du programme !"
exit 0 # Valeur de retour du script (contenu dans la variable '$?'
# à la fin de l'exécution du script).
7.5.1. Les tests
Deux syntaxes :
test expression ou bien [ expression ]
 Le résultat est récupérable par la variable $?.
 Il faut respecter un espace avant et après les crochets.
Tests sur les chaînes
Condition Signification
-z chaîne vrai si la chaîne est vide
-n chaîne vrai si la chaîne est non vide
chaîne1 = chaîne2 vrai si les deux chaînes sont égales
chaîne1 != chaîne2 Vrai si les deux chaînes sont différentes
Tests sur les nombres
num1 eq num2 Egalité
num1 ne num2 Inégalité
num1 lt num2 inférieur ( < )
num1 le num2 inférieur ou égal ( < =)
num1 gt num2 supérieur ( > )
num1 ge num2 supérieur ou égal ( > =)

Tests sur les fichiers
-e filename vrai si filename existe
-d filename vrai si filename est un répertoire
-f filename vrai si filename est un fichier ordinaire
-L filename vrai si filename est un lien symbolique
-r filename vrai si filename est lisible (r)
-w filename vrai si filename est modifiable (w)
-x filename vrai si filename est exécutable (x)
file1 -nt file2 vrai si file1 plus récent que file2
file1 -ot file2 vrai si file1 plus ancien que file2
7.5.2. L’instruction « if »
 Syntaxe
if suite_de_commandes1
then
suite_de_commandes2
[ elif suite_de_commandes ; then suite_de_commandes ] ...
[ else suite_de_commandes ]
fi
 Exemple
#!/bin/bash
if [ $1 = "Salah" ]
then echo "Salut Salah !"
else
echo "Je ne te connais pas !"
fi

7.5.3. L’instruction « case »
Permet de vérifier le contenu d’une variable.
 Syntaxe
case Valeur in
Modele1) Commandes ;;
Modele2) Commandes ;;
*) action_defaut ;;
esac
7.5.4. L’instruction « for »
 Syntaxe (première forme)
for var
do
suite_de_commandes
done
 Syntaxe (deuxième forme)
for var in liste_mots
do
suites_de_commandes
done
 Exemple 1
#!/bin/bash
for i in `seq 1 10`;
do
echo $i
done

 Exemple 2
#!/bin/bash
for variable in 'valeur1' 'valeur2' 'valeur3'
do
echo "La variable vaut $variable"
done
7.5.5. L’instruction « while »
L'instruction while permet de tester les arguments passés au programme, et de les traiter.
Cette instruction trouvera donc tout naturellement sa place au début d'un script Shell digne de
ce nom.
 Syntaxe
while suite_cmd1
do
suite_cmd2
done
 Exemple
#!/bin/bash
while
echo "tapez quelque chose : "
read mot
[ $mot != "fin" ];
do
echo "vous avez tapé $mot"
echo "tapez "fin" pour finir";
done

7.5.6. Les fonctions
 Syntaxe
function nom_fct
{
suite_de_commandes
}
 Exemple
$ function f0
> {
> echo Bonjour tout le monde !
> }
$
 Appel de la fonction f0
$ f0
Bonjour tout le monde !
7.5.7. Expressions arithmétiques « expr »
 Opérateurs arithmétiques
$ expr 2 + 3
$ expr 2 – 3
$ expr 2 + 3 * 4
$ expr ( 2 + 3 ) * 4
 Opérateurs logiques
$ expr 2 = 2 # retourne 1
$ echo $? # retourne 0
$ expr 3 > 6 # retourne 0
$ echo $? # retourne 1
$ expr 1 & 0 # retourne 0
$ expr 1 | 0 # retourne 1

7.5.8. Expressions arithmétiques « let, (()) »
La syntaxe est moins contraignante. Il n’est pas nécessaire de mettre les espaces entre chaque
élément, ni de préfixer avec un antislash certains opérateurs. La manipulation de variables est
simplifiée. Il existe un plus grand nombre d'opérateurs pour le calcul arithmétique.
 Opérateurs arithmétiques
$ let var=2+3
$ echo $var # retourne 5
$ ((var=2**3))
$ echo $var # retourne 8
$ echo $((2*3)) # retourne 6
$ echo $((2*(4+(10/2))-1)) # retourne 17
$ echo $((7%3)) # retourne 1
$ a=1+2
$ echo $(($a)) # retourne 3
$ echo $((a)) # retourne 3
 Opérateurs Logiques, incrémentation
$ ((x=3))
$ while ((x>0))
> do
> echo $x
> ((x--))
> done

TD (Travaux dirigés)
TD
(Travaux
dirigés)

Faycel CHAOUA Systèmes d’exploitation 2 – TD1 74
Exercice 1
1. Créer les fichiers suivants : annee1, Annee2, annee4, annee45, annee41, annee510,
annee_solaire, annee_tropique.
2. Créer le répertoire "Year".
3. Déplacer les fichiers précédemment créés dans le répertoire "Year".
4. Lister tous les fichiers
a) se terminant par le caractère 5.
b) commençant par la chaîne annee4.
c) commençant par la chaîne annee4 et de 7 lettres.
d) commençant par la chaîne annee avec aucun chiffre numérique.
e) contenant la chaîne rop.
f) commençant par la lettre a ou la lettre A.
5. Copier les fichiers dont l'avant dernier caractère est le caractère 4 ou le caractère 1 dans le
répertoire /tmp.
Exercice 2
1. Dans le répertoire courant, créer en une commande les fichiers suivants : 3bananes,
3poires, 45pommes, aride, banane, paname, panorama, Paris, parti, parties,
pomme, programmer.
2. Créer le répertoire "Dictionnaire" dans le répertoire courant.
3. Déplacer les fichiers précédemment créés dans le répertoire "Dictionnaire".
4. À partir du répertoire "Dictionnaire" lister tous les fichiers
a) se terminant par la lettre e.
b) commençant par la chaîne pa.
Institut Supérieur des Études Technologiques de Kélibia
Département de Technologies de l'Informatique
Matière : Systèmes d’exploitation 2
Niveau : LMD ‒ L2
Enseignant : Faycel CHAOUA
Durée : 1 heure 30 min
TD N° 1

c) contenant la chaîne ar.
d) commençant par un chiffre et ayant ensuite exactement quatre lettres minuscules.
e) commençant par un chiffre et contenant au moins trois lettres minuscules consécutives
dont la troisième lettre de ce groupe est une voyelle.
f) commençant par un chiffre et contenant au moins trois lettres minuscules consécutives
dont la troisième lettre de ce groupe n’est pas une voyelle.
g) contenant la chaîne ar, celle-ci n’étant pas suivie d’une lettre i.
h) commençant par la lettre p ou la lettre P.
i) commençant par la lettre p ou la lettre P, ou finissant par la lettre s.
j) ne commençant ni par la lettre p, ni par la lettre P.
k) ne se terminant ni par la lettre e, ni par la lettre s.
l) dont l’avant dernier caractère est la lettre m ou le dernier est la lettre e.
m) dont le troisième caractère est une voyelle.
n) ne se terminant pas par la chaîne me.
o) ne se terminant pas par la chaîne mes.
p) ne se terminant ni par la chaîne mes, ni par la chaîne me.

Exercice 1 (Redirection des entrées/sorties)
1. Redirection de la sortie standard : le symbole >
a) Exécuter la commande ls. Taper ensuite ls > sorties, puis relister le contenu du
répertoire courant. Un nouveau fichier appelé sorties a été créé. Lire son contenu.
b) Exécuter maintenant la commande ls -l > sorties. Consulter à nouveau le contenu
de sorties.
c) Concaténer le résultat de la commande ls >> sorties à la fin du fichier sorties.
2. Redirection de l’entrée standard : le symbole <
a) Comparer les résultats de wc < sorties et wc sorties. Expliquer la différence.
b) Ajouter le résultat de wc < sorties dans le fichier sortie.
3. Redirection d’erreur standard : les symboles 2>
a) Exécuter la commande wc tutu. Comme le fichier "tutu" n’existe pas, wc renvoie une
erreur.
b) Exécuter maintenant wc tutu > sortie. Regarder le contenu de sortie.
c) Faire en sorte que le message d’erreur soit écrit dans un fichier nommé erreur.
Exercice 2 (grep)
1. Créer un répertoire "essai-grep" dans le répertoire d’accueil (home directory).
2. Dans ce répertoire, créer les fichiers suivants : tomate, poire, pomme, cerise, Fraise,
fraise, courgette, POMME3, afraise.
3. Lister les fichiers (sortie de la commande ls redirigée vers grep) avec les critères suivants
a) Critère 1 : le nom doit être la chaîne Fraise ou la chaîne fraise.
Niveau : LMD ‒ L2
TD N° 2

b) Critère 2 : le nom se termine par la chaîne se.
c) Critère 3 : le nom contient la chaîne ai.
d) Critère 4 : le nom contient un chiffre numérique.
e) Critère 5 : le nom contient la chaîne mm ou la chaîne MM.
4. Copier le fichier /etc/passwd dans le home directory. Afficher la ligne commençant par
le nom d’utilisateur user1.
5. Dans le nouveau fichier passwd, afficher les lignes commençant par des noms d’utilisateurs
ne contenant pas de chiffre.
6. Dans le même fichier passwd, afficher les lignes commençant par des noms d’utilisateurs de
3 ou 4 caractères.
Exercice 3 (les filtres)
1. Copier le fichier /etc/passwd dans le répertoire d’accueil (home directory). Éditer
uniquement les champs contenant le login et le home directory.
2. Trier le fichier passwd sur le nom.
3. En une seule commande, extraire les noms d’utilisateurs et les UID, puis trier suivant les UID
et rediriger le tout vers un fichier file1.
4. Dans le fichier de résultat file1 remplacer les ":" par des " " (espace).
5. Afficher les cinq premières lignes de file1.
6. Afficher les cinq dernières lignes de file1.
Exercice 4 (find)
1. Chercher dans toute l'arborescence les fichiers qui répondent aux critères suivants. Rediriger
les erreurs vers le fichier poubelle /dev/null.
f) les fichiers dont le nom se termine par la chaîne .c.
g) les fichiers commençant par la lettre X ou la lettre x.
h) les fichiers dont les noms ne contiennent pas de chiffre.
2. Chercher dans /usr les fichiers dont la taille dépasse 1Mo et dont les droits sont fixés à 755
(rwx r-x r-x).
3. Combien de fichiers y-a-t il dans toute l'arborescence appartenant à user1 et ayant les droits
fixés à 666 (rw- rw- rw-).
4. Trouver tous les fichiers core dans l'arborescence et les supprimer.

Exercice 1
1. Expliquer la signification de chacune des options de la commande suivante :
useradd -u 600 -g 100 -c "Un Utilisateur" -d /home/u1 -s /bin/sh u1
a) -u 600
b) -g 100
c) -c "Un Utilisateur"
d) -d /home/u1
e) -s /bin/sh u1
2. Une ligne dans le fichier /etc/shadow est composée de neuf champs séparés par le
caractère « : ».
a) Que signifie le caractère « ! » ?
b) Que signifie la valeur « 99999 » ?
c) Que signifie la valeur « 7 » ?
3. En exécutant la commande chage –l user1, on a obtenu le résultat suivant.
a) Après combien de jours user1 recevra un avertissement sur la validité de son compte ?
b) Après combien de jours user1 doit contacter l’administrateur pour activer son compte ?
c) Est-ce que user1 peut changer son mot de passe quand il le souhaite ?
Niveau : LMD ‒ L2
TD N° 3

Exercice 2
1. Dans le répertoire courant, créer un répertoire "essai_droit", par défaut ce répertoire est à 755
(rwxr-xr-x). Quelles sont les commandes (en notation symbolique et en base 8) pour lui
donner les droits suivants (on suppose qu'après chaque commande on remet le répertoire à
755) ?
Propriétaire Groupe Les autres
r w x r w x r W x
Commande 1 Oui Oui Oui Oui Non Oui Non Non Oui
Commande 2 Oui Non Oui Non Oui Non Non Non Oui
Commande 3 Non Oui Non Non Non Oui Oui Non Non
Commande 4 Non Non Oui Oui Non Oui Non Non Non
2. Créer un fichier "droit" dans le répertoire "essai_droit", par défaut ce fichier est à 644 (rw-
r--r--). En partant du répertoire courant, pour chacune des commandes précédentes, essayer
d'accéder au répertoire "essai_droit" (commande cd), de faire un ls dans "essai_droit" et de
modifier le fichier avec un éditeur quelconque (vi par exemple). Expliquer les résultats
obtenus.
3. Taper la commande umask, de manière à ce que les fichiers lors de leur création aient par
défaut les droits 640 (rw-r-----), et les répertoires 750 (rwxr-x---).
Exercice 3
Déterminer les permissions d’un utilisateur sur un fichier en étudiant les informations fournies par la
commande ls, et assimiler les possibilités offertes par ces droits.
On suppose qu’un utilisateur tape la commande suivante :
1. Qui est le propriétaire du répertoire de travail ?
2. Quelles sont les permissions de l’utilisateur truc appartenant aux groupes machin et bidule
sur fic ?
3. Quelles sont les permissions de l’utilisateur bidule appartenant aux groupes machin et truc
sur fic ?

sur rep ?
5. Que peut-on dire des utilisateurs qui peuvent supprimer fic ?
6. Est-il possible que rep ait pu être créé tel quel dans le répertoire de travail ?
Quels sont les droits effectifs de l’utilisateur machin appartenant aussi au groupe machin sur rep
?

Exercice 1
Donner la signification des différentes lignes du crontab suivant.
Crontab Signification
47 * * * * commande …………………………………………………………………………
0 0 * * 1 commande …………………………………………………………………………
0 4 1 * * commande …………………………………………………………………………
0 4 * 12 * commande …………………………………………………………………………
0 * 4 12 * commande …………………………………………………………………………
* * * * * commande …………………………………………………………………………
Exercice 2
Compléter le crontab suivant avec les valeurs correspondantes aux significations données.
…………………………………… commande À 5 h 30 du matin du 1er au 15 de chaque mois.
…………………………………… commande À minuit le lundi, le mercredi et le jeudi.
…………………………………… commande Toutes les 2 heures (00 h 00, 02 h 00, 04 h 00…)
…………………………………… commande Toutes les 10 minutes du lundi au vendredi.
Niveau : LMD ‒ L2
TD N° 4

Exercice 3
Créer un script qui demande à l'utilisateur de saisir une note et qui affiche un message en fonction de
cette note (Appréciation de note) :
 "Très Bien" si la note est entre 16 et 20 ;
 "Bien" lorsqu'elle est entre 14 et 16 ;
 "Assez Bien" si la note est entre 12 et 14 ;
 "Moyen" si la note est entre 10 et 12 ;
 "Insuffisant" si la note est inférieur à 10.
Exercice 4
Reprendre l’exercice précédent (Appréciation de note) et faire en sorte que le programme se répète
tant que l'utilisateur n'a pas saisi la lettre 'q' (pour quitter).
Le script doit calculer le nombre de notes saisies et en faire la moyenne tout à la fin.
Exercice 5
Créer un script, se basant sur la boucle for, qui prend un nombre en saisie et l'élève à sa propre
puissance.
Exemple d'exécution :
./NomDuScript.sh
Saisir une valeur :
2
2^2 = 4
Exercice 6
Reprendre l’exercice 3 (Appréciation de note). La note devra être donnée en paramètre ou bien saisie
en cas d'absences d'arguments. La comparaison de la note devra être faite dans une fonction
appreciation()

Exercice 1
Créer un script qui propose le menu suivant :
1 - Vérifier l'existence d'un utilisateur
2 - Connaître l'UID d'un utilisateur
q – Quitter
L'utilisateur devra être saisi, à l'aide d'une fonction. Son existence devra être vérifiée à l'aide d'une
autre fonction.
Exercice 2
Créer un script dans lequel deux nombres opérandes et un signe opérateur (+-*/) devront être donnés
en paramètres, ou saisis. Le script doit réaliser l'opération souhaitée.
Exemple :
./calculette.sh 7 + 4
Le résultat est : 11
Le calcul devra être fait à l'aide d'une fonction calcul().
Exercice 3
Créer un script qui permet de calculer et d'afficher la factorielle d'un nombre donné en paramètre (ou
saisi en cas d'absence de paramètres).
Exercice 4
Créer un script qui doit calculer le nombre de fichiers standard, de sous-répertoires, et d'exécutables
d'un répertoire quelconque qui sera donné en paramètre (ou saisis en cas d'absence du paramètre).
Niveau : LMD ‒ L2
TD N° 5

Exercice 5
Créer un script qui devra enregistrer à l'aide d'un tableau, un nombre d'entiers donné en paramètre (ou
en saisie) puis trier ceux-ci dans l'ordre croissant dans ce même tableau (sans passer par un autre) et
enfin afficher le contenu du tableau (ordonné) sur la sortie standard.
Exercice 6
Créer un script qui renvoie la même sortie que la commande ls mais dans l'ordre décroissant
(autrement dit : le script devra lister le contenu d'un répertoire dans l'ordre décroissant). Il ne faut pas
utiliser ni la commande ls, ni la commande sort.
Exercice 7
Créer un script qui prend en paramètre ou en saisie le nom d'un fichier contenant le nom des élèves et
leurs trois notes. Le script devra afficher les noms des élèves, puis calculer et afficher la moyenne de
chaque élève.
Voici comment se présente le fichier :
Durand 12 9 14
Lucas 8 11 4
Martin 9 12 1

TD (Travaux dirigés)
Correction
des TD

Faycel CHAOUA Systèmes d’exploitation 2 – Correction du TD1 86
Exercice 1
1. Créer les fichiers suivants : annee1, Annee2, annee4, annee45, annee41, annee510,
annee_solaire, annee_tropique.
 touch annee1 Annee2 annee4 annee45 annee41 annee510 annee_solaire
annee_tropique
2. Créer le répertoire "Year".
 mkdir Year
3. Déplacer les fichiers précédemment créés dans le répertoire "Year".
 mv [aA]nnee* Year
4. Lister tous les fichiers
a) se terminant par le caractère 5.
 ls Year/*5
 find Year -name '*5'
b) commençant par la chaîne annee4.
 ls Year/annee4*
 find Year –name 'annee4*'
c) commençant par la chaîne annee4 et de 7 lettres.
 ls Year/annee4?
 find Year –name 'annee4?'
Niveau : LMD ‒ L2
Correction du TD N° 1

d) commençant par la chaîne annee avec aucun chiffre numérique.
 ls Year/annee[!0-9]*
 find Year –name 'annee[!0-9]*'
e) contenant la chaîne rop.
 ls Year/*rop*
 find Year –name '*rop*'
f) commençant par la lettre a ou la lettre A.
 ls Year/[aA]*
 find Year –name '[aA]*'
5. Copier les fichiers dont l'avant dernier caractère est le caractère 4 ou le caractère 1 dans le
répertoire /tmp.
 cp Year/*[41]? /tmp
Exercice 2
1. Dans le répertoire courant, créer en une commande les fichiers suivants : 3bananes,
3poires, 45pommes, aride, banane, paname, panorama, Paris, parti, parties,
pomme, programmer.
 touch 3bananes 3poires 45pommes aride banane paname panorama Paris
parti parties pomme programmer
2. Créer le répertoire "Dictionnaire" dans le répertoire courant.
 mkdir Dictionnaire
3. Déplacer les fichiers précédemment créés dans le répertoire "Dictionnaire".
 mv 3bananes 3poires 45pommes aride banane paname panorama Paris
parti parties pomme programmer Dictionnaire

4. À partir du répertoire "Dictionnaire" lister tous les fichiers
a) se terminant par la lettre e.
 ls *e
 find . –name '*e'
b) commençant par la chaîne pa.
 ls pa*
 find . –name 'pa*'
c) contenant la chaîne ar.
 ls *ar*
 find . –name '*ar*'
d) commençant par un chiffre et ayant ensuite exactement quatre lettres minuscules.
 ls [0-9][a-z][a-z][a-z][a-z]*
 find . –name '[0-9][a-z][a-z][a-z][a-z]*'
e) commençant par un chiffre et contenant au moins trois lettres minuscules consécutives
dont la troisième lettre de ce groupe est une voyelle.
 ls [0-9]*[a-z][a-z][aeiouy]*
 find . –name '[0-9]*[a-z][a-z][aeiouy]*'
f) commençant par un chiffre et contenant au moins trois lettres minuscules consécutives
dont la troisième lettre de ce groupe n’est pas une voyelle.
 ls [0-9]*[a-z][a-z][b-df-hj-np-tv-xz]*
 find . –name '[0-9]*[a-z][a-z][b-df-hj-np-tv-xz]*'
g) contenant la chaîne ar, celle-ci n’étant pas suivie d’une lettre i.
 ls *ar[!i]*
 find . –name '*ar[!i]*'
h) commençant par la lettre p ou la lettre P.
 ls [pP]*

 find . –name '[pP]*'
i) commençant par la lettre p ou la lettre P, ou finissant par la lettre s.
 find . –name '[pP]*' –o –name '*s'
j) ne commençant ni par la lettre p, ni par la lettre P.
 ls [!pP]*
 find . ! –name 'p*' –a ! –name 'P*'
 find . ! ( –name 'p*' –o –name 'P*' )
k) ne se terminant ni par la lettre e, ni par la lettre s.
 ls *[!es]
 find . ! –name '*e' –a ! –name '*s'
 find . ! ( –name '*e' –o –name '*s' )
l) dont l’avant dernier caractère est la lettre m ou le dernier est la lettre e.
 find . –name '*m?' –o –name '*e'
m) dont le troisième caractère est une voyelle.
 ls ??[aeiouy]*
 find . –name '??[aeiouy]*'
n) ne se terminant pas par la chaîne me.
 ls !(*me)
 find . ! –name '*me'
o) ne se terminant pas par la chaîne mes.
 ls !(*mes)
 find . ! –name '*mes'
p) ne se terminant ni par la chaîne mes, ni par la chaîne me.
 find . ! ( –name '*me' –o –name '*mes' )
 find . ! –name '*me' –a ! –name '*mes'

Exercice 1 (Redirection des entrées/sorties)
1. Redirection de la sortie standard : le symbole >
a) Exécuter la commande ls. Taper ensuite ls > sorties, puis relister le contenu du
répertoire courant. Un nouveau fichier appelé sorties a été créé. Lire son contenu.
 ls
 ls > sorties
 ls
 cat sorties
b) Exécuter maintenant la commande ls -l > sorties. Consulter à nouveau le contenu
de sorties.
 ls -l > sorties
 cat sorties
c) Concaténer le résultat de la commande ls >> sorties à la fin du fichier sorties.
 ls >> sorties
2. Redirection de l’entrée standard : le symbole <
a) Comparer les résultats de wc < sorties et wc sorties. Expliquer la différence.
 C’est le même résultat.
b) Ajouter le résultat de wc < sorties dans le fichier sortie.
 wc < sorties > sortie
Niveau : LMD ‒ L2

3. Redirection d’erreur standard : les symboles 2>
a) Exécuter la commande wc tutu. Comme le fichier "tutu" n’existe pas, wc renvoie une
erreur.
b) Exécuter maintenant wc tutu > sortie. Regarder le contenu de sortie.
 cat sortie
 le contenu de "sortie" est écrasé.
c) Faire en sorte que le message d’erreur soit écrit dans un fichier nommé erreur.
 wc tutu 2> erreur
Exercice 2 (grep)
1. Créer un répertoire "essai-grep" dans le répertoire d’accueil (home directory).
 mkdir ~/essai-grep
2. Dans ce répertoire, créer les fichiers suivants : tomate, poire, pomme, cerise, Fraise,
fraise, courgette, POMME3, afraise.
 cd ~/essai-grep
 touch tomate poire pomme cerise Fraise fraise courgette POMME3
afraise
3. Lister les fichiers (sortie de la commande ls redirigée vers grep) avec les critères suivants
a) Critère 1 : le nom doit être la chaîne Fraise ou la chaîne fraise.
 ls | grep "^[fF]raise$"
b) Critère 2 : le nom se termine par la chaîne se.
 ls | grep "se$"
c) Critère 3 : le nom contient la chaîne ai.
 ls | grep "ai"
d) Critère 4 : le nom contient un chiffre numérique.

 ls | grep "[0-9]"
e) Critère 5 : le nom contient la chaîne mm ou la chaîne MM.
 ls | grep "[mM]{2}"
4. Copier le fichier /etc/passwd dans le home directory. Afficher la ligne commençant par
le nom d’utilisateur user1.
 cd
 cp /etc/passwd ~
 cat passwd | grep "^user1"
5. Dans le nouveau fichier passwd, afficher les lignes commençant par des noms d’utilisateurs
ne contenant pas de chiffre.
 cat passwd | grep "^[^0-9][^0-9]*:" ou
 cat passwd | grep "^[a-z][a-z]*:"
6. Dans le même fichier passwd, afficher les lignes commençant par des noms d’utilisateurs de
3 ou 4 caractères.
 cat passwd | grep "^.{3,4}:"
Exercice 3 (les filtres)
1. Copier le fichier /etc/passwd dans le répertoire d’accueil (home directory). Éditer
uniquement les champs contenant le login et le home directory.
 cd
 cp /etc/passwd ~
 cut -d: -f1,6 passwd
2. Trier le fichier passwd sur le nom.
 sort -t: +0 -1 passwd
3. En une seule commande, extraire les noms d’utilisateurs et les UID, puis trier suivant les UID
et rediriger le tout vers un fichier file1.
 cut -d: -f1,3 passwd | sort -t: -n +1 -2 > file1

4. Dans le fichier de résultat file1 remplacer les ":" par des " " (espace).
 cat file1 | tr ":" " " > file1
5. Afficher les cinq premières lignes de file1.
 head -5 file1
6. Afficher les cinq dernières lignes de file1.
 tail -5 file1
Exercice 4 (find)
1. Chercher dans toute l'arborescence les fichiers qui répondent aux critères suivants. Rediriger
les erreurs vers le fichier poubelle /dev/null.
a) les fichiers dont le nom se termine par la chaîne .c.
 find / -name "*.c" -print 2> /dev/null
b) les fichiers commençant par la lettre X ou la lettre x.
 find / -name "[Xx]*" -print 2> /dev/null
c) les fichiers dont les noms ne contiennent pas de chiffre.
 find / -name "[!0-9]" -print 2> /dev/null
2. Chercher dans /usr les fichiers dont la taille dépasse 1Mo (2000 blocs de 500Ko) et dont les
droits sont fixés à 755 (rwx r-x r-x).
 find /usr ( -size +2000 -a -perm 755 ) -print 2> /dev/null
3. Combien de fichiers y-a-t il dans toute l'arborescence appartenant à user1 et ayant les droits
fixés à 666 (rw- rw- rw-).
 find / ( -user user1 -a -perm 666 –print ) | wc -l
4. Trouver tous les fichiers core dans l'arborescence et les supprimer.
 find / -name "core" -print -delete

Exercice 1
1. Expliquer la signification de chacune des options de la commande suivante :
useradd -u 600 -g 100 -c "Un Utilisateur" -d /home/u1 -s /bin/sh u1
a) -u 600  UID de l’utilisateur.
b) -g 100  GUD de l’utilisateur.
c) -c "Un Utilisateur"  Commentaire sur l’utilisateur.
d) -d /home/u1  Chemin vers le répertoire personnel de l’utilisateur.
e) -s /bin/sh u1  Interpréteur de commandes initial de l’utilisateur.
2. Une ligne dans le fichier /etc/shadow est composée de neuf champs séparés par le
caractère « : ».
a) Que signifie le caractère « ! » ?  Le compte root est désactivé. Il n’a pas de mot de
passe. Au démarrage du système, il n’est pas possible de se connecter avec root.
b) Que signifie la valeur « 99999 » ?  Indique que l'utilisateur peut garder son mot de
passe inchangé pendant une longue durée.
c) Que signifie la valeur « 7 » ?  Pour une semaine entière.
3. En exécutant la commande chage –l user1, on a obtenu le résultat suivant.
Niveau : LMD ‒ L2

a) Après combien de jours user1 recevra un avertissement sur la validité de son compte ?
 Il peut garder son mot de passe sans le changer (pas d’avertissement).
b) Après combien de jours user1 doit contacter l’administrateur pour activer son compte ?
 Il n’a pas besoin de contacter l’administrateur. Son mot de passe n’expire jamais.
c) Est-ce que user1 peut changer son mot de passe quand il le souhaite ?  Oui.
Exercice 2
1. Dans le répertoire courant, créer un répertoire "essai_droit", par défaut ce répertoire est à 755
(rwxr-xr-x). Quelles sont les commandes (en notation symbolique et en base 8) pour lui
donner les droits suivants (on suppose qu'après chaque commande on remet le répertoire à
755) ?
mkdir essai_droit
Propriétaire Groupe Les autres
r w x r W X R w x
Commande 1 Oui Oui Oui Oui Non Oui Non Non Oui
Commande 2 Oui Non Oui Non Oui Non Non Non Oui
Commande 3 Non Oui Non Non Non Oui Oui Non Non
Commande 4 Non Non Oui Oui Non Oui Non Non Non
[En notation symbolique]
Commande 1 : chmod o-r essai_droit
Commande 2 : chmod u-w,g-rx,g+w,o-r essai_droit
Commande 3 : chmod u-rx,g-r,o-x essai_droit
Commande 4 : chmod u-rw,o-rx essai_droit
[En notation octale]
Commande 1 : chmod 751 essai_droit

2. Créer un fichier "droit" dans le répertoire "essai_droit", par défaut ce fichier est à 644 (rw-
r--r--). En partant du répertoire courant, pour chacune des commandes précédentes, essayer
d'accéder au répertoire "essai_droit" (commande cd), de faire un ls dans "essai_droit" et de
modifier le fichier avec un éditeur quelconque (vi par exemple). Expliquer les résultats
obtenus.
Commande 1 : on peut accéder au répertoire (droit d'accès x). On peut
faire ls (droit en lecture sur le répertoire r), et modifier le
fichier (droit en écriture sur le répertoire w et sur le fichier w).
Commande 2 : on peut accéder au répertoire (droit d'accès x). On peut
faire ls (droit en lecture sur le répertoire r), et modifier le
fichier (le droit en écriture sur le répertoire n'est pas pris en
compte dès lors qu’on a le droit en écriture sur le fichier).
Commande 3 : on ne peut pas accéder au répertoire (pas de droit
d'accès x).
Commande 4 : on peut accéder au répertoire (droit d'accès x). On ne
peut pas faire ls (pas de droit de lecture). On peut éditer et
modifier le fichier (droit en écriture sur le répertoire et sur le
fichier).
3. Taper la commande umask, de manière à ce que les fichiers lors de leur création aient par
défaut les droits 640 (rw-r-----), et les répertoires 750 (rwxr-x---).
Pour un fichier
masque maximum pour un fichier 666 rw-rw-rw-
à retirer 026 ----w-rw-
droit par défaut 640 rw-r-----
Pour un répertoire
masque maximum pour un répertoire 777 rwxrwxrwx
à retirer 027 ----w-rwx
droit par défaut 640 rwxr-x---
Soit la commande : umask 027
(Pour un fichier, retirer 026 ou 027 est équivalent)

Exercice 3
Déterminer les permissions d’un utilisateur sur un fichier en étudiant les informations fournies par ls,
et assimiler les possibilités offertes par ces droits.
On suppose qu’un utilisateur tape la commande suivante :
1. Qui est le propriétaire du répertoire de travail ?
 La première ligne affichée par ls indique que truc est le
propriétaire de "." (répertoire de travail).
2. Quelles sont les permissions de l’utilisateur truc appartenant aux groupes machin et bidule
sur fic ?
 truc est le propriétaire de fic. Il possède donc les droits r-x.
sur fic ?
 bidule est membre du groupe machin (groupe de fic). Il possède
donc les droits rw-.
sur rep ?
 bidule n’est ni le propriétaire de fic, ni membre de son groupe.
Il a donc les droits -wx.
5. Que peut-on dire des utilisateurs qui peuvent supprimer fic ?
 Pour supprimer fic, il faut au minimum les droits d’écriture et
d’exécution sur le répertoire de travail. Ceux qui les possèdent
sont truc et les utilisateurs qui ne sont pas membre du groupe
bidule.

6. Est-il possible que rep ait pu être créé tel quel dans le répertoire de travail ?
 Non, s’il n’y a pas eu intervention de root, rep n’a pu être créé
qu’avec des permissions différentes du répertoire de travail (ou
alors par déplacement mais ce n’est pas une création). En effet,
le propriétaire (et créateur) de rep est machin. Puisque le groupe
de rep est bidule et que seul machin (ou root) peut le changer, on
en déduit que machin est membre du groupe bidule. Or, pour créer
un fichier il faut les droits wx sur le répertoire mais machin a
les droits du groupe, soit uniquement r.
7. Quels sont les droits effectifs de l’utilisateur machin appartenant aussi au groupe machin sur
rep ?
 Aucun droit ! En effet, en tant que membre du groupe bidule,
machin n’a pas les droits d’exécution sur le répertoire de travail
et ne peut donc pas accéder à rep !

Exercice 1
Donner la signification des différentes lignes du crontab suivant.
47 * * * * commande Toutes les heures à 47 minutes exactement (à 00:47, 01:47, etc.).
0 0 * * 1 commande Tous les lundis à minuit (00:00).
0 4 1 * * commande Tous les premiers du mois à 4 h du matin (04:00).
0 4 * 12 * commande Tous les jours du mois de décembre à 4 h du matin.
0 * 4 12 * commande Toutes les heures les 4 décembre.
* * * * * commande Toutes les minutes.
Exercice 2
Compléter le crontab suivant avec les valeurs correspondantes aux significations données.
30 5 1-15 * * commande À 5 h 30 du matin du 1er au 15 de chaque mois.
0 0 * * 1,3,4 commande À minuit le lundi, le mercredi et le jeudi.
0 */2 * * * commande Toutes les 2 heures (00 h 00, 02 h 00, 04 h 00…)
*/10 * * * 1-5 commande Toutes les 10 minutes du lundi au vendredi.
Niveau : LMD ‒ L2

Exercice 3
Créer un script qui demande à l'utilisateur de saisir une note et qui affiche un message en fonction de
cette note (Appréciation de note) :
 "Très Bien" si la note est entre 16 et 20 ;
 "Bien" lorsqu'elle est entre 14 et 16 ;
 "Assez Bien" si la note est entre 12 et 14 ;
 "Moyen" si la note est entre 10 et 12 ;
 "Insuffisant" si la note est inférieur à 10.
Exercice 4
Reprendre l’exercice précédent (Appréciation de note) et faire en sorte que le programme se répète
tant que l'utilisateur n'a pas saisi la lettre 'q' (pour quitter).
Le script doit calculer le nombre de notes saisies et en faire la moyenne tout à la fin.

Exercice 5
Créer un script, se basant sur la boucle for, qui prend un nombre en saisie et l'élève à sa propre
puissance.
Exemple d'exécution :
./NomDuScript.sh
Saisir une valeur :
2
2^2 = 4

Exercice 6
Reprendre l’exercice 3 (Appréciation de note). La note devra être donnée en paramètre ou bien saisie
en cas d'absences d'arguments. La comparaison de la note devra être faite dans une fonction
appreciation()

Exercice 1
Créer un script qui propose le menu suivant :
1 - Vérifier l'existence d'un utilisateur
2 - Connaître l'UID d'un utilisateur
q – Quitter
L'utilisateur devra être saisi, à l'aide d'une fonction. Son existence devra être vérifiée à l'aide d'une
autre fonction.
Niveau : LMD ‒ L2

Exercice 2
Créer un script dans lequel deux nombres opérandes et un signe opérateur (+-*/) devront être donnés
en paramètres, ou saisis. Le script doit réaliser l'opération souhaitée.
Exemple :
./calculette.sh 7 + 4
Le résultat est : 11
Le calcul devra être fait à l'aide d'une fonction calcul().

Exercice 3
Créer un script qui permet de calculer et d'afficher la factorielle d'un nombre donné en paramètre (ou
saisi en cas d'absence de paramètres).

Exercice 4
Créer un script qui doit calculer le nombre de fichiers standard, de sous-répertoires, et d'exécutables
d'un répertoire quelconque qui sera donné en paramètre (ou saisis en cas d'absence du paramètre).
Exercice 5
Créer un script qui devra enregistrer à l'aide d'un tableau, un nombre d'entiers donné en paramètre (ou
en saisie) puis trier ceux-ci dans l'ordre croissant dans ce même tableau (sans passer par un autre) et
enfin afficher le contenu du tableau (ordonné) sur la sortie standard.

Exercice 6
Créer un script qui renvoie la même sortie que la commande ls mais dans l'ordre décroissant
(autrement dit : le script devra lister le contenu d'un répertoire dans l'ordre décroissant). Il ne faut pas
utiliser ni la commande ls, ni la commande sort.

Exercice 7
Créer un script qui prend en paramètre ou en saisie le nom d'un fichier contenant le nom des élèves et
leurs trois notes. Le script devra afficher les noms des élèves, puis calculer et afficher la moyenne de
chaque élève.
Voici comment se présente le fichier :
Durand 12 9 14
Lucas 8 11 4
Martin 9 12 1

Références (Bibliographie / Webographie)
[1] Z. Bouziri, N. H. Andriambelo, B. Andrei, et N. Larrousse, Préparation à l’examen 101
pour la certification de l’Institut professionnel de Linux, niveau junior (LPIC-1), 2e
éd. Paris:
Agence universitaire de la francophonie, 2010.
[2] Z. Bouziri, N. H. Andriambelo, B. Andrei, et N. Larrousse, Préparation à l’examen 102
pour la certification de l’Institut professionnel de Linux, niveau junior (LPIC-1), 2e
éd. Paris:
Agence universitaire de la francophonie, 2010.
[3] N. Drakos et R. Moore, « Historique de UNIX », 11-janv-2006. [En ligne]. Disponible sur:
http://www-etud.iro.umontreal.ca/~semunix/documentIRO/html/node43.html. [Consulté le:
22-déc-2017].
[4] P. Gentil, « Documentation UNIX », 15-déc-2017. [En ligne]. Disponible sur:
https://perso.univ-rennes1.fr/pascal.gentil/unix/index.html#fichiers. [Consulté le: 22-déc-
2017].
[5] P. Gentil, « Documentation Unix : Les commandes d’archivage et de (dé)compression »,
27-févr-2014. [En ligne]. Disponible sur: https://perso.univ-
rennes1.fr/pascal.gentil/unix/archives.html. [Consulté le: 22-déc-2017].
[6] P. Gentil, « Documentation Unix : les commandes relatives aux fichiers », 05-déc-2013.
[En ligne]. Disponible sur: https://perso.univ-rennes1.fr/pascal.gentil/unix/fichiers.html.
[Consulté le: 22-déc-2017].
[7] P. Gentil, « Documentation Unix : les commandes relatives aux répertoires », 06-avr-
2016. [En ligne]. Disponible sur: https://perso.univ-rennes1.fr/pascal.gentil/unix/rep.html.
[8] P. Gentil, « Documentation Unix : Les gestionnaires de paquets », 15-déc-2017. [En
ligne]. Disponible sur: https://perso.univ-rennes1.fr/pascal.gentil/unix/gestionnaires.html.
[9] M. Decore, « Gestion des processus », 03-nov-1999. [En ligne]. Disponible sur:
http://www.linux-france.org/article/memo/node13.html. [Consulté le: 22-déc-2017].
[10] « Fonctionnalités avancées du Shell ». [En ligne]. Disponible sur: http://debian-
facile.org/doc:programmation:shell:avancee. [Consulté le: 22-déc-2017].

[11] O. Hoarau, « Cours et exercices UNIX », 27-janv-2017. [En ligne]. Disponible sur:
http://www.funix.org/fr/unix/. [Consulté le: 22-déc-2017].
[12] C. Pain-Barre, « Cours Système », 27-sept-2013. [En ligne]. Disponible sur:
http://infodoc.iut.univ-aix.fr/~cpb/index.php?page=systeme. [Consulté le: 22-déc-2017].
[13] I. Neumann, « Exercices shell scripts », Developpez.com. [En ligne]. Disponible sur:
http://ineumann.developpez.com/tutoriels/linux/exercices-shell/. [Consulté le: 22-déc-2017].
[14] « Introduction à Linux ». [En ligne]. Disponible sur:
http://www.daudel.com/mmia/linux1.pdf. [Consulté le: 22-déc-2017].
[15] C. Pivoteau, « Introduction au système ». [En ligne]. Disponible sur: http://igm.univ-
mlv.fr/~pivoteau/LINUX/. [Consulté le: 22-déc-2017].

Support du cours : Systèmes d'exploitation 2 (linux)

Contenu connexe

Tendances (20)

Similaire à Support du cours : Systèmes d'exploitation 2 (linux) (20)

Dernier (20)

Support du cours : Systèmes d'exploitation 2 (linux)