LLI Wiki — My Digital Knowledge Base

Aide-mémoire Linux : find, du, grep, lsof, signaux et archives

Recettes de ligne de commande Linux : processus zombies et signaux, lsof, copie, suppression et mesure de fichiers avec find et du, grep, tar, zip.

Aide-mémoire de commandes Linux pour l'administration courante : processus et signaux, fichiers ouverts, gestion de fichiers avec find, du, grep, archives et quelques astuces de nettoyage de texte.

Processus et réseau

ps -auxwf                      # arbre des processus, lignes de commande complètes
netstat -tulpn                 # sockets en écoute avec le processus propriétaire
netstat -natu | grep 'ESTABLISHED'
sudo ss -lutn | grep 1521      # qui écoute sur un port donné
lsof -i -nP                    # connexions réseau par processus

Autres outils utiles : mtr (traceroute et ping combinés), drill (requêtes DNS ; remplace dig, déprécié sur certaines distributions), ss, free, du --max-depth=1.

Supprimer la dernière commande de l'historique du shell :

ls ; history -d $(history 1)

Construire des arguments avec xargs :

echo "a b c" | xargs printf -- '-f %s\n'

États des processus et zombies

L'état d'un processus affiché par ps est l'un des suivants :

État Signification
R En cours d'exécution ou prêt (en attente d'un CPU)
S En sommeil, en attente d'un événement (entrée/sortie, ressource)
D Sommeil non interruptible : bloqué dans un appel système, ne réagit pas aux signaux avant son retour
T Arrêté par SIGSTOP ; ne réagit qu'à SIGKILL ou SIGCONT (mécanisme utilisé par fg/bg)
Z Zombie : le processus est terminé mais son entrée dans la table des processus subsiste tant que le parent n'a pas lu son code de sortie (le parent reçoit SIGCHLD)

Un zombie ne peut pas être tué directement : il faut identifier son parent et agir sur lui.

ps aux | egrep "Z|defunct"
ps -o ppid= -p <PID>
kill -SIGKILL <PID_PARENT>

Pour arrêter tous les processus d'un utilisateur, lsof -t -u <utilisateur> liste leurs PID, utilisables avec kill -9.

Signaux courants

Signal Numéro Description
SIGHUP 1 Terminal de contrôle fermé ou fin du processus de contrôle
SIGINT 2 Envoyé par Ctrl-C
SIGQUIT 3 Envoyé par Ctrl-\
SIGFPE 8 Opération arithmétique illégale
SIGKILL 9 Arrêt immédiat, ne peut pas être intercepté
SIGALRM 14 Réveil (alarme)
SIGTERM 15 Demande d'arrêt propre
SIGCONT 18 Reprise après un arrêt ; envoyé par bg et fg
SIGSTOP 19 Arrête le processus, ne peut pas être intercepté
SIGTSTP 20 Arrêt depuis le terminal (Ctrl-Z) ; le programme peut l'ignorer

Les numéros varient selon l'architecture ; voir la liste des signaux.

Fichiers ouverts avec lsof

lsof /var/log/syslog           # qui a ce fichier ouvert
lsof +D /var/log/              # qui a des fichiers ouverts dans ce répertoire

Récupérer un fichier supprimé mais toujours ouvert par un processus (le processus reste actif, le fichier est accessible via /proc) :

less test.txt                  # puis Ctrl-Z pour le passer en arrière-plan
lsof | grep test.txt           # récupérer le PID
cd /proc/<PID>/fd/
ls
cp <fd> /emplacement/sur/test.txt   # copier le descripteur de fichier

Informations système

cat /etc/*release*             # distribution et version

32 ou 64 bits :

uname -a
dpkg --print-architecture
getconf LONG_BIT
arch
file /sbin/init

i386 correspond à 32 bits, amd64 à 64 bits.

Lister les fichiers cachés

ls -d .*
ls -d .b*
ls -d .[!.]*

Construire le motif pour que . et .. ne correspondent pas :

grep -l 'PATH' ~/.[!.]*

Copier et déplacer

Copier tout le répertoire courant vers /target en conservant propriétaire, droits et dates :

tar cf - * | ( cd /target; tar xfp -)

Copie simple de fichiers et de répertoires :

cp -rp source destination
Option Nom long Description
-a --archive Équivalent à -dR --preserve=all
-p Équivalent à --preserve=mode,ownership,timestamps
-r --recursive Copie récursive des répertoires
-l --link Crée des liens physiques au lieu de copier
-s --symbolic-link Crée des liens symboliques au lieu de copier

Copier via le réseau avec tar et ssh :

tar -cf - /some/file | ssh host.name tar -xf - -C /destination
# avec compression
tar -czf - /some/file | ssh host.name tar -xzf - -C /destination

Copier une arborescence en liant les fichiers au lieu de les copier :

cp -as SOURCE/ COPY
cp -as "$(pwd)/SOURCE/" COPY

cp -al /src/dir /dest/dir    # liens physiques vers les fichiers
cp -as /src/dir /dest/dir    # liens symboliques vers les fichiers

cp -rl /src/dir /dest/dir    # liens physiques vers les fichiers
cp -rs /src/dir /dest/dir    # liens symboliques vers les fichiers

Supprimer

Exécutez toujours d'abord la commande avec -print (ou sans -exec) pour vérifier ce qui sera supprimé.

Répertoires de plus de 7 jours (uniquement s'ils sont vides, rmdir refuse sinon) :

find . -mtime +7 -type d -exec rmdir {} \;

Répertoires vides, récursivement :

# vérifier
find . -type d -empty -print
# supprimer
find . -type d -empty -delete

ou

find . -type d -empty
sudo find . -type d -empty -exec rmdir {} \;

Anciens fichiers :

find /opt/backup -type f -mtime +30
find /opt/backup -type f -mtime +30 -exec rm -f {} \;
find /var/log -name "*.log" -type f -mtime +30
find /var/log -name "*.log" -type f -mtime +30 -exec rm -f {} \;

Tout supprimer sauf les fichiers les plus récents (! -newer sélectionne les fichiers qui ne sont pas plus récents que le fichier de référence ; la référence est le plus récent des fichiers à supprimer) :

find magick-* ! -newer <fichier-reference> -exec rm -f {} \; -print
find *.dbf ! -newer reference.dbf -exec stat {} --format "%n %y" \;   # vérifier
find *.dbf ! -newer reference.dbf -exec rm -f {} \; -print

Supprimer des répertoires par nom :

find . -type d -name "bar" -exec rm -rf "{}" \;

Supprimer tous les fichiers d'une extension donnée :

find . -name '*.zip' -print      # vérifier d'abord
find . -name "*.zip" -type f -delete
find . -name "*.bak" -type f -print0 | xargs -0 /bin/rm -f
find . -name "*.bak" -type f -exec rm -f {} \; -print

Mesurer fichiers et tailles

Taille totale des fichiers correspondant à un motif et à un âge :

find . -name "FILEPREFIX*" -type f -mtime +3 -exec du -ch {} + | grep total$

Nombre de fichiers par jour :

find . -type f -printf '%TY-%Tm-%Td\n' | sort | uniq -c

Taille en Go par jour :

find . -type f -printf '%TY-%Tm-%Td %s\n' | awk '
 { a[$1] += $2 }
 END {
   for (i in a) {
     printf "%-15s\t%0.10f \n", i, a[i]/1024/1024/1024 | " sort -nk1"; }
}'

Taille totale des fichiers d'une extension dans une arborescence (discussion d'origine) :

find . -name "*.log.*" -print0 | du -sb --files0-from=- | awk '{ total += $1} END { print total/1024/1024/1024 }'
find . -name "*.o" | xargs du -sch
find . -name "*.jpg" -print0 | xargs -0 du -sch      # -print0 gère les espaces dans les noms
find . -name "*.jpg" -printf '%s\n' | awk '{c+=$1}END{print c}'
find . -name "*.jpg" -exec du -b {} \; | awk '{total+=$1}END{print total}'

shopt -s globstar
du -sch **/*.jpg

Taille totale par extension :

#!/bin/bash
ftypes=$(find . -type f | grep -E ".*\.[a-zA-Z0-9]*$" | sed -e 's/.*\(\.[a-zA-Z0-9]*\)$/\1/' | sort | uniq)
for ft in $ftypes
do
    echo -n "$ft "
    find . -name "*${ft}" -exec ls -l {} \; | awk '{total += $5} END {print total}'
done

Taille pour une seule extension :

find /path -name '*.frq' -exec ls -l {} \; | awk '{ Total += $5 } END { print Total }'
find /var/app -type f -name '*.aud' -exec du -ch {} + | grep total$

Plus gros fichiers et dossiers

sudo du -aBm / 2>/dev/null | sort -nr | head -n 10
sudo du --max-depth=1                     # taille par dossier (Linux)
du | grep -v '/.*/'                       # taille par dossier (AIX)
du | awk -F/ 'NF <= 2'                    # taille par dossier (AIX)
du -hms /home/user/* | sort -nr | head
sudo du -a /dir/ | sort -n -r | head -n 20
sudo find / -type f -printf "%s\t%p\t\n" | sort -n | tail -1
find $HOME -type f -printf '%s %p\n' | sort -nr | head -10

Compter les fichiers par dossier

# fichiers et répertoires (nombre d'inodes) par dossier de premier niveau
du -a 2>/dev/null | cut -d/ -f2 | sort | uniq -c | sort -nr
# fichiers uniquement
find . -type f | cut -d/ -f2 | sort | uniq -c

# fichiers par répertoire
find . -type d -print0 | while read -d '' -r dir; do
    files=("$dir"/*)
    printf "%5d files in directory %s\n" "${#files[@]}" "$dir"
done

# totaux
find / -type d -printf "d\n" -o -type f -printf "f\n" | awk '/f/{f++}/d/{d++}END{printf "%d directories, %d files\n", d, f}'
find / -printf "%y\n" | awk '/f/{f++}/d/{d++}END{printf "%d directories, %d files\n", d, f}'

Archives

tar

# créer
tar -cvzf archive.tar.gz fichier_ou_repertoire ...        # gzip
tar -cvzf - /var/log/* > varlog.tar.gz
tar -cvjf archive.tar.bz2 fichier_ou_repertoire ...       # bzip2
tar -C from/ -cvf test.tar path/sub/

# lister et extraire
tar -tvf archive.tar
tar -xvzf archive.tar.gz
tar -xvjf archive.tar.bz2
tar -C to/ -xvf test.tar

zip

Décompresser toutes les archives d'une arborescence, chacune dans un dossier portant son nom (voir aussi find -exec vs find | xargs) :

find . -name '*.zip' | while read filename; do unzip -o -d "$(dirname "${filename}")/$(basename -s .zip "${filename}")" "$filename" ; done;

En parallèle (remplacer <N> par le nombre de processus parallèles) :

find . -name "*.zip" | xargs -P <N> -I fileName sh -c 'unzip -o -d "$(dirname "fileName")/$(basename -s .zip "fileName")" "fileName"'

Zipper chaque sous-dossier dans sa propre archive, en séquence ou en parallèle (-0 stocke sans compression) :

for i in */; do zip -r "${i%/}.zip" "$i"; done
for i in */; do zip -0 -r "${i%/}.zip" "$i" & done; wait

Recherche

Fichiers par nom, les plus gros en dernier :

find . -name "*.data*" -exec du -m {} \; | sort -n

Taille par extension (référence) :

for ext in `find . -type f | perl -ne 'print $1 if m/\.([^.\/]+)$/' | sort -u`; do
    echo $ext": "`find . -name "*."$ext -print0 | du -ch --files0-from=- | tail -1`
done

Fichiers plus récents ou plus anciens qu'une date :

find /dir/ ! -type f -newerXY 'yyyy-mm-dd'
find . -name 'app.log*' -mtime +2 -exec stat {} --format "%n %y" \;
# fichiers modifiés depuis hier
find /directory -newermt $(date +%Y-%m-%d -d '1 day ago') -type f -print

Chercher une chaîne dans le contenu des fichiers de petite taille (-size -100000 est exprimé en blocs de 512 octets) :

find / -type f -size -100000 -exec grep -il 'PATTERN' {} \; 2> /dev/null

Rechercher dans les fichiers avec grep

grep --include=\*.{c,h} -rnw '/path/to/somewhere/' -e "pattern"
grep --exclude=*.o -rnw '/path/to/somewhere/' -e "pattern"
grep --exclude-dir={dir1,dir2,*.dst} -rnw '/path/to/somewhere/' -e "pattern"
grep -rnw '/path/to/somewhere/' -e 'pattern'

Plusieurs motifs dans un journal :

egrep -w 'warning|error|critical' /var/log/messages
grep 'warning\|error\|critical' /var/log/messages
egrep -wi --color 'warning|error|critical' /var/log/messages

Exclure les lignes listées dans un fichier texte :

grep ORA- alert.log | grep -v "`cat exclude.txt`"

Ne chercher que dans la fin d'un fichier très volumineux (beaucoup plus rapide que de le lire entièrement) :

dd if=file bs=1 skip=14G | grep xxx     # moins d'1 seconde
tail -c 14g file | grep xxx             # moins de 2 secondes

Extraire et compter les adresses IP d'un journal :

grep -E -o "^[^^][0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}" access.log | uniq -c | more

Exemple de sortie : 42 192.0.2.10, 16 192.0.2.11.

Comparer deux listes de fichiers et afficher la date de modification des fichiers présents uniquement dans la première :

comm -1 list_a.lst list_b.lst | xargs -n1 stat --format "%n %y"

Divers

Espace libre depuis la dernière ligne de df, et noms de fichiers depuis ls -la :

df --total | tail -n 1 | awk '{print $4}'
ls -la | awk '{print $9}'

Nettoyage de fichiers texte

# supprimer les retours chariot DOS
sed -i 's/\r$//' filename
# supprimer l'espace avant les deux-points (YAML)
find env/ -type f -exec sed -i -e 's/ :/:/g' {} \;
# supprimer les espaces en fin de ligne
find env/ -type f -exec sed -i -e 's/[[:space:]]*$//' {} \;
# supprimer les lignes vides
find env/ -type f -exec sed -i -e '/^$/d' {} \;

Cibles d'arrêt et de démarrage

Commandes équivalentes (voir cette discussion) :

Cible systemd Commandes équivalentes
systemctl isolate halt.target shutdown -H now, systemctl halt, halt
systemctl isolate reboot.target shutdown -r now, telinit 6, systemctl reboot, reboot
systemctl isolate poweroff.target shutdown -P now, telinit 0, shutdown now, systemctl poweroff, poweroff
systemctl isolate rescue.target telinit 1, systemctl rescue
systemctl isolate multi-user.target telinit 2, telinit 3, telinit 4
systemctl isolate graphical.target telinit 5

Remarques

Mastodon LLIMastodon SocialFosstodon