Epreuve de S.Expl. & Mise en Œuvre UNIX

Questions de cours

Question 1 - Avantage d'une machine virtuelle

Réponse correcte : D. rendre transparent le support d'exécution

Une machine virtuelle abstrait le matériel sous-jacent. L'avantage principal (parmi les choix proposés) est de fournir un environnement d'exécution standardisé, masquant les spécificités du matériel physique à l'utilisateur et aux applications. Les autres choix sont faux : une VM consomme généralement plus de mémoire (C) et introduit une légère surcharge qui la rend souvent un peu moins rapide qu'une exécution native (A).

Question 2 - Définition d'un processus

Réponse correcte : B. processus : une abstraction d'un programme en exécution

C'est une distinction fondamentale en systèmes d'exploitation. Un programme (réponse A ou C) est une entité passive (un fichier sur un disque). Un processus est une entité active : c'est le programme chargé en mémoire centrale, en cours d'exécution, possédant son propre contexte (compteur ordinal, registres, pile d'exécution).

Question 3 - Signification des deux points (..)

Réponse correcte : B. le répertoire père du répertoire courant

Sous UNIX, chaque répertoire contient automatiquement deux entrées spéciales :

• . (un point) qui désigne le répertoire courant lui-même.
• .. (deux points) qui désigne le répertoire parent (celui situé juste au-dessus dans l'arborescence).

Question 4 - Codage des droits d'un fichier

Réponse correcte : B. 9 bits

Les droits d'un fichier UNIX classique (hors listes de contrôle d'accès étendues) se répartissent en 3 catégories d'utilisateurs : le propriétaire (User), le groupe (Group) et les autres (Others). Pour chaque catégorie, on définit 3 droits : Lecture (r), Écriture (w) et Exécution (x). 3 catégories × 3 droits = 9 bits (ex: rwxr-xr--).

Question 5 - Système à temps partagé

Réponse correcte : C. à temps partagé : d'avoir l'illusion de programmes s'exécutant en même temps

Dans un système à temps partagé avec un processeur monocœur, le processeur ne traite qu'une seule instruction à la fois. Cependant, le système d'exploitation alloue un très court "quantum de temps" à chaque processus tour à tour. Cette commutation de contexte est si rapide qu'elle donne à l'utilisateur l'illusion d'une exécution simultanée.

Exercice 1 - Arborescence et Permissions

Question 1.1 - Répertoire de connexion

Réponse : /home/linuxuser

Lors de la connexion, UNIX vous place par défaut dans le répertoire personnel (home directory) attribué à votre compte. Pour un utilisateur nommé linuxuser, le chemin absolu standard est /home/linuxuser.

Question 1.2 - Commande du répertoire courant

Réponse : echo $HOME ou pwd

La variable d'environnement $HOME contient le chemin de votre répertoire de connexion. La commande pwd (print working directory) affichera également ce chemin si vous venez tout juste d'ouvrir votre session et que vous n'avez pas encore changé de répertoire.

Question 1.3 - Création de l'arborescence

L'énoncé demande de créer une arborescence spécifique. Voici la séquence de commandes.

cd ~
mkdir "Mes Cours"
cd "Mes Cours"
mkdir CoursUnix
mkdir CoursUML
touch CoursUnix/noteschap1
touch CoursUML/remarques
cd ~
mkdir Exercices
mkdir Exercices/ExUnix
cd Exercices/ExUnix
touch TD1
cd ~

Note pédagogique : L'utilisation des guillemets " (ou de l'échappement \ ) est obligatoire pour "Mes Cours" afin que le shell comprenne qu'il s'agit d'un seul nom de dossier contenant un espace, et non de deux dossiers distincts "Mes" et "Cours". L'arborescence corrigée du professeur indique "CourUML" puis "CoursUML", c'est une faute de frappe dans le corrigé original. Restez cohérent et utilisez CoursUML.

Question 1.4 - Création d'un lien symbolique

Réponse : ln -s /home/linuxuser/Exercices/ExUnix/TD1 /home/linuxuser/raccourciTD1

La commande ln avec l'option -s (symbolic) crée un lien symbolique (un raccourci). La syntaxe est ln -s cible nom_du_lien. L'utilisation de chemins absolus permet d'éviter que le lien ne soit brisé si on le déplace.

Question 1.5 - Copie de fichier

Réponse : cp $HOME/"Mes Cours"/CoursUnix/noteschap1 $HOME/Exercices/ExUnix/noteschap1

La commande cp copie le fichier. Le respect des chemins exige d'utiliser le chemin depuis le point de départ jusqu'à la destination voulue.

Question 1.6 - Affichage des permissions

Réponse : ls -lR /home/linuxuser

L'option -l (long) affiche les détails dont les permissions. L'option -R (récursif) permet de parcourir non seulement le répertoire, mais aussi tout le contenu de ses sous-répertoires, couvrant ainsi toute l'arborescence créée.

Question 1.7 - Permissions par défaut

Réponse : umask

Tapée sans arguments, la commande umask affiche le masque actuel qui soustrait des droits aux permissions de base lors de la création d'un fichier (qui a les permissions de base de 666, soit rw-rw-rw-).

Question 1.8 - Modification du masque par défaut

Réponse : umask 026

L'utilisateur veut les permissions rw-r----- (propriétaire: lecture/écriture, groupe: lecture, autres: rien).

• En octal, cela donne 640.
• Les permissions maximales pour un fichier régulier sont 666.
• Le masque se calcule par soustraction : 666 - 640 = 026.
• La commande est donc umask 026.

Question 1.9 - Modification des droits d'un fichier

Réponse : chmod 777 /home/linuxuser/Exercices/ExUnix/TD1 (ou chmod a+rwx ...)

L'autorisation totale signifie octroyer les droits de lecture (4), écriture (2) et exécution (1) à tout le monde. 4+2+1 = 7. Répété pour les 3 catégories, on obtient 777.

Exercice 2 - Redirections et Tubes

Question 2.1 - Redirection d'entrée/sortie standard

Sous UNIX, chaque processus communique via trois flux standards :

1. L'entrée standard (stdin - descripteur 0) : Par défaut, le clavier.
2. La sortie standard (stdout - descripteur 1) : Par défaut, l'écran.
3. La sortie d'erreur standard (stderr - descripteur 2) : Par défaut, l'écran.

Une redirection permet de dévier ces flux vers un fichier.

• Rediriger la sortie standard (>) : Écrit le résultat d'une commande dans un fichier (écrase le contenu s'il existe). Exemple : ls > fichiers.txt
• Ajouter à la sortie standard (>>) : Ajoute le résultat à la fin d'un fichier existant. Exemple : echo "fin" >> fichiers.txt
• Rediriger l'erreur standard (2>) : Dévie uniquement les messages d'erreur. Exemple : ls /dossier_inexistant 2> erreurs.log
• Rediriger l'entrée standard (<) : Fournit le contenu d'un fichier comme entrée à une commande. Exemple : wc -l < fichiers.txt

Question 2.2 - Utilisation des tubes (pipes)

Un tube (symbolisé par |) connecte directement la sortie standard d'une commande à l'entrée standard de la commande suivante, sans avoir besoin d'écrire sur le disque dur.

Exemple d'utilisation : Afficher la liste des fichiers, puis trier le résultat par ordre alphabétique inversé : ls | sort -r

Équivalent avec des redirections : Pour reproduire le comportement d'un tube, il faut créer un fichier temporaire :

ls > fichier_temporaire
sort -r < fichier_temporaire
rm fichier_temporaire

Exercice 3 - Analyse de script shell (Factorielle)

Voici le code commenté tel que demandé. Le but de ce script est de calculer la factorielle (notée "!") du nombre passé en premier argument de la ligne de commande.

if
test  $#  -ne  1
# Si le nombre d'arguments ($#) est différent de (-ne) 1
then   echo nombre de paramètres incorrect

  elif
test  $1  -lt  0
# Si le 1er paramètre ($1) est strictement inférieur à (-lt) 0
then  echo argument non correct

  elif
test  $1  -eq  0   -o   $1  -eq  1
# Si le 1er paramètre est égal à (-eq) 0 OU (-o) égal à 1
then   echo le résultat trouvé est = 1

  else
res=1
for  i  in  `seq  2  1  $1`
# Pour i allant de 2 jusqu'à la valeur de l'argument $1 (avec un pas de 1)
do
res=`expr $i \* $res`
# Affecter à 'res' le résultat de la multiplication de 'i' par la valeur actuelle de 'res'.
# Le caractère '*' doit être échappé avec '\' pour ne pas être interprété comme un joker de fichier.
done
echo le résultat trouvé est = $res
fi

# Ce script est censé calculer la factorielle d'un entier passé en paramètre d'appel.
# Puisque : 
# 0! = 1, 1! = 1 (géré par la deuxième condition elif).
# Et pour n > 1, n! = 1 * 2 * 3 * ... * n (géré par la boucle for).

Exercice 4 - Écriture de script shell (Analyse de fichiers)

Attention au corrigé source : Le corrigé fourni dans l'examen original calcule le nombre de caractères/octets du fichier (via wc -c) pour calculer une "Taille totale". Cependant, l'énoncé de l'examen exige explicitement l'affichage et l'addition du "nombre de ses lignes" (donc wc -l). Vous trouverez ci-dessous le script correct résolvant rigoureusement l'énoncé.

#!/bin/bash

# Vérification du nombre d'arguments
if test $# -lt 1
then
    echo "Usage : $0 fichier1 [fichier2 ...]"
    exit 1
fi

total_lignes=0

# Boucle sur l'ensemble des arguments passés au script
for fichier in "$@"
do
    echo "----------------------------------------"
    
    # 1. Vérifie si le fichier existe et est un fichier ordinaire
    if ! test -f "$fichier"
    then
        echo "Erreur : '$fichier' n'est pas un fichier ordinaire ou n'existe pas."
        continue
    fi
    
    # 2. Vérifie si le fichier est lisible
    if ! test -r "$fichier"
    then
        echo "Erreur : '$fichier' n'est pas accessible en lecture."
        continue
    fi
    
    # 3. Vérifie si le fichier est non vide
    if ! test -s "$fichier"
    then
        echo "Erreur : '$fichier' est un fichier vide."
        continue
    fi
    
    # 4. Vérifie si le fichier est de type ASCII text
    # file -b n'affiche que le type. On cherche si le retour contient "text"
    est_texte=$(file "$fichier" | grep -c "text")
    if test $est_texte -eq 0
    then
        echo "Erreur : '$fichier' n'est pas un fichier ASCII Text."
        continue
    fi
    
    # Si toutes les caractéristiques sont respectées :
    
    # Calcul du nombre de lignes du fichier courant
    # awk '{print $1}' sert à isoler juste le nombre renvoyé par wc
    nb_lignes=$(wc -l < "$fichier")
    
    echo "Fichier : $fichier"
    echo "Nombre de lignes : $nb_lignes"
    echo "--- Début du fichier ---"
    head -n 5 "$fichier"
    echo "..."
    tail -n 5 "$fichier"
    echo "--- Fin du fichier ---"
    
    # Ajout au compteur global
    total_lignes=$(expr $total_lignes + $nb_lignes)
done

echo "========================================"
echo "Nombre total de lignes trouvé pour les fichiers valides : $total_lignes"
echo "========================================"

Méthode

Face à ce type d'épreuve associant QCM, connaissances de l'arborescence UNIX, et scripts Shell :

1. Les QCM et l'arborescence : Apprenez rigoureusement les options des commandes UNIX fondamentales (ls, chmod, cp, ln). La commande umask est souvent mal comprise : rappelez-vous qu'elle est soustraite des droits complets (666 pour les fichiers, 777 pour les répertoires). Pour les chemins, soyez attentifs à l'instruction demandée ("donnez le chemin absolu") ; partir d'un / ou de ~ change tout.
2. La logique des conditions (Test) : Dans l'exercice 3, repérez bien les opérateurs historiques de la commande test : -eq (equal), -ne (not equal), -lt (less than). Les traductions de l'anglais vous évitent de deviner.
3. Le Scripting (Exercice 4) :
   • Commencez par la sécurité : Vérifiez toujours le nombre d'arguments ($#) avant de tenter des actions.
   • Lisez et respectez l'énoncé, pas l'intuition : L'énoncé demande de compter des lignes, il faut utiliser wc -l. Le fait que le correcteur d'origine ait utilisé la taille octet (wc -c) illustre qu'il est facile de dévier. Répondez point par point aux contraintes (fichier régulier, lisible, texte, non vide).
   • Séparez contrôle et traitement : Utilisez continue après chaque erreur dans la boucle pour passer à l'argument suivant. Cela limite l'imbrication infinie de blocs if / then / else qui rendent un code illisible et augmente le risque d'erreur de syntaxe.