Ajout TP1 et TP2

TP1/TP1.sh

+#1a
+tree ~/.config
+#1b
+tree -d ~/.config
+#1c
+touch ~/.config/.hidden_file
+tree -a ~/.config	#on voit bien le fichier `hidden_file`
+rm ~/.config/.hidden_file
+#1d
+ln -s ~/Téléchargements ~/.config/dwnlds
+touch ~/Téléchargements/test
+tree -l ~/.config	#on voit bien le contenu de `~/Téléchargements` (dont le fichier `test`) dans `~/.config/dwnlds`
+ln -s ~/.config/ ~/.config/recursive
+tree -l ~/.config	#`tree` détecte la récursion et s'arrête
+rm ~/Téléchargement/test
+rm ~/.config/dwlnds
+#1.e
+tree -t ~/.config	
+
+#2
+mkdir -p os/{archives,cm,evaluation,tp} os/cm/{0,1,2} os/tp/{0,1}
+touch os/cm/{0,1,2}/résumé os/tp/{0,1}/{correction,sujet}
+tree os	#pour vérifier
+
+#3a
+ln -rs os/tp/1 os/evaluation/tp-noté-1	#options `r` pour "relatif" et `s` pour symbolique
+#3b
+ln os/evaluation/notes os/tp/1/	#pas besoin de spécifier un nom
+#3c
+rm os/evaluation/notes
+cat os/tp/1/notes	#le fichier est toujours présent ici
+#3d
+rmdir os/evaluation	#éviter `rm -r` qui peut avoir des conséquences graves, en cas d'erreur
+	#rm -d os/evaluation	#aussi possible
+#3e
+rm -vr os/tp	#cette fois, il a été spécifié que le contenu devait être supprimé (l'option `-v` est facultative)
+
+#4a:	pour éviter d'afficher la sortie d'erreur, qui contient des erreurs dues aux permissions
+#4b:	il sert à limiter le nombre de résultat (potentiellement très grand), à 16 sorties
+#4c:	on peut changer l'option `-name` par `-iname`. On peut faire d'autre choses avec des _regexp_.
+
+#5
+chmod -R 755 os
+chmod +X ~	# à répéter sur tout le chemin du `~` vers le répertoire `os`
+ls ~voisin/…/os #où voisin doit être remplacé par le login du voisin et … par le chemin adéquat (chez le voisin)
+
+#6a
+ls -ld /tmp
+#6b
+chmod +t os
+ls -ld os	#pour vérifier
+touch ~voisin/…/os/$USER	#on écrit un fichier qui s'appelle `$USER` (notre login)
+ls -l os	#pour regarder les fichiers que les voisins on créés chez nous
+rm os/voisin	#devrait échouer
+
+#7
+#which donne l'adresse absolue de l'exécutable correspondant au nom d'une commande. Si plusieurs exécutable ont ce nom et se trouvent dans les répertoires de la variable d'environnement PATH, il prend le premier trouvé.
+which bash
+
+#8
+man bash	#utiliser `/` pour rechercher dans le manuel
+echo '#!'$(which bash)	#préferer `$(…)` à l'ancienne substitution de commande avec backquote
+#9
+echo '#!'$(which bash) > header.sh 
+#10
+echo "echo '"'#!'"'"'$(which bash)' >> header.sh	#le jeu de guillemets est important, à cause du '!'. Ne pas oublier le double chevron `>>`.
+chmod +x header.sh
+./header.sh	#affiche bien la ligne d'entête
+
+#11a
+find /usr -iname '*t*' -type f -executable -print 2>/dev/null | head -3	#`-print` est facultatif
+#10b
+	#find /proc -name '[0-9]*' -type d -print 2>/dev/null | head -3	#n'est pas correct, car * signifie ici “n'importe quel caractère”, et non la répétition d'autant de chiffres que l'on veut).
+find /proc -regex '.*/[0-9]*' -type d -print 2>/dev/null | head -3	#regex permet de faire une vraie expression régulière, sur tout le chemin (d'où le préfixe `.*/`).
+	#ou bien (par double négation, avec -name)
+find /proc ! -name '*[^0-9]*' -type d -print 2>/dev/null | head -3
+#11c
+find /dev -regex '.*/[^/-]*' -type l -print 2>/dev/null | head -3	#on interdit '/' pour ne considérer que le nom
+#11d
+find /var -type s -print 2>/dev/null | head -3
+#11e
+find /dev -type b -print 2>/dev/null | head -3
+#11f
+find /dev -type b -print 2>/dev/null | head -3
+#11g
+find /usr -links +2 -type f -print 2>/dev/null | head -3	#le '+' permet de dire "au moins"
+	#il faut maintenant récupérer leur inœud (via `ls -l`, `stat`…). On peut faire comme cela:
+ls -i $(find /usr -links +2 -type f -print 2>/dev/null | head -3)
+	#puis on recherche les inœuds de chacun (ici, 7613765)
+find / -inum 7613765 -print 2>/dev/null
+	#…
+
+#12
+find /usr/bin -type f -executable -size +16M -print
+find /usr/bin -type f -executable -size +16M -exec du '{}' \;	#l'option `-h` de `du` permet de rendre la taille plus lisible
+
+#13
+stat /dev/sda2
+stat /proc
+stat ~
+stat /dev/null
+stat /dev/stderr

TP2/TP2.sh

+
+#Q1 
+man bash, puis /^REDIRECTION pour trouver la section.
+    #Q1a
+        lecture: <
+        écriture: > ou >> (ajout)
+        les deux à la fois: <>
+    #Q1b
+        <~/.bashrc: redirige l’entrée standard sur le fichier ~/.bashrc ouvert en lecture — descripteur de fichier (fd) 0
+        3<>/tmp/toto: ouvre le fichier /tmp/toto en lecture et écriture, et lui attribue le descripteur de fichier (fd) 3
+        >>/tmp/toto.log: redirige la sortie standard (fd 1) sur le fichier /tmp/toto.log, ouvert en écriture incrémental (ajout à la fin)
+    #Q1c
+        2>&1: redirige l’erreur standard (fd 2) sur la sortie standard (fd 1). Les deux flus sont mélangés.
+        3>&-: ferme le descripteur de fichier 3.
+        3>&1 1>&2 2>&3 3>&-: intervertit les descripteurs de fichier 1 (sortie standard) et 2 (erreur standard) — comme vu en cours.
+
+#Q2 
+Il affiche "sortie de $USER" sur la sortie standard, "erreur de $USER" sur l’erreur standard, et écrit "écriture de $USER" (le nom de l’utilisateur courant) en ajout, à la fin de /tmp/fichier. Puis, il lit le contenu de /tmp/fichier (sur lequel est redirigé l’entrée standard), et en affiche le contenu sur l’erreur standard. On peut s’attendre à voir "écriture de $USER" apparaître, mais également d’autres messages "écriture de […]", puisque tous les étudiants travaillant sur le même serveur écrivent leur nom dans le même fichier /tmp/fichier.
+
+#Q3
+
+#!/bin/bash
+echo "sortie de $USER" >&1
+echo "erreur de $USER" >&2
+echo "écriture de $USER" >>/tmp/fichier
+cat </tmp/fichier >&2
+
+et ensuite chmod 750 manyfd.sh puis ./manyfd.sh
+Q4 ./manyfd.sh | grep "$USER" où grep permet de filtrer un flux en ne gardant que les lignes (par défaut, i.e., sans option) contenant une certaine expression. Ici "$USER".
+Q5 ./manyfd.sh 3>&2 2>&1 1>&3- | grep "$USER" ou, mieux, on rétablit les flux comme prévus après grep: { ./manyfd.sh 3>&2 2>&1 1>&3- | grep "$USER"; } 3>&2 2>&1 1>&3
+Q6 éventuellement, exécuter touch /tmp/{toto,tata} puis chmod 660 /tmp/{toto,tata}
+    Q6a ls -l --time-style=+ /proc/self/fd/ </tmp/toto
+    Q6b ls -l --time-style=+ /proc/self/fd/ 0<>/tmp/toto
+    Q6c ls -l --time-style=+ /proc/self/fd/ 2>/tmp/toto
+    Q6d ls -l --time-style=+ /proc/self/fd/ </tmp/toto 2>/tmp/toto 3<>/tmp/toto 4</tmp/tata 5>&2
+
+Appels système
+
+Q7 strace ./manyfd.sh
+Q8 Avec man strace, on trouve l’option -o qui prend en argument un fichier, ou un tube vers une commande (c.f. plus bas). strace -o /tmp/manyfd_$USER.trace ./manyfd.sh Pour n’avoir que la sortie de strace, sans la sortie de manyfd.sh, on peut faire (non-demandé): { strace -o"|cat >&3" ./manyfd.sh 3>&1 &>/dev/null ; } 3>&1
+Q9 man strace puis /-e et n plusieurs fois pour chercher l’occurrence suivante (ou Shift-n pour la précédente)
+    Q9a strace -e trace=%process Oui, un clone est créé.
+    Q9b strace -e trace=%file
+    Q9c strace -e trace=open # Processus
+Q10
+    Q10a echo \( et $BASHPID affiche deux fois le même pid.
+    Q10b (echo \) et $BASHPID) affiche cette fois deux pid différents.
+    Q10c { echo \( et $BASHPID; } affiche deux fois le même pid.
+    Q10d { echo \) et $BASHPID; } & affiche deux pid différents.
+
+Q11
+
+#!/bin/bash
+while read -p "> " line
+do
+    (eval \$line) &
+    wait
+done
+echo
+
+Q12
+
+#!/bin/bash
+echo "my pid \$BASHPID, my parent pid \$PPID, my shell level \$SHLVL, my bash root instance pid \$\$"
+sleep \${1:-0}
+
+Q13 ./pid_sleep.sh 1024 &
+    Q13a cat /proc/$!/stat en troisième position, on voit S pour Sleeping
+    Q13b cat /proc/$!/status, on voit la ligne correspondant à uid id -u, nous donne notre uid, qui est le même que celui observé
+    Q13c ls -l /proc/$!/fd/{0,1,2}
+Q14 ps -p $! ps -o pid,ppid,state,comm -p $!
+Q15 kill $!
+
+#Q16 
+Le script évalue le premier argument. Avant cela, il s’appelle récursivement dans un sous-shell en arrière plan, selon un second argument entier (par défaut 0) qui décroit jusqu’à 0 à chaque appelle. Par exemple, ./the_script.sh "./pid_sleep.sh 3" 4 lancera 5 fois la commande ./pid_sleep.sh 3, dont 4 fois dans des sous-shells en arrière plan.