Vous recherchez probablement une combinaison de messages provenant de divers fichiers journaux. Essayez :

tail -f /var/log/{messages,kernel,dmesg,syslog}

…pour avoir une assez bonne vue d'ensemble du système. Si vous voulez plus ou moins que cela, cherchez dans quel fichier journal sont placés les messages que vous voulez voir.

Cherchez également à utiliser multitail pour classer et colorer le code et filtrer plusieurs fichiers journaux en même temps.

Edit: Ce n'était pas très pertinent quand j'ai répondu à cette question, mais comme cette page reçoit beaucoup de visites, je pense qu'il vaut la peine de mentionner que des systèmes plus récents fonctionnant sous systemd ont ceci.

dmesg -w

Just make it @#$%ing work

1. You want to print output of dmesg, constantly, immediately
2. Le dmesg imprime le tampon circulaire du noyau (voir man dmesg)
3. La mémoire tampon circulaire du noyau est un fichier proc spécial, /proc/kmsg (voir man proc)
4. Lisez /proc/kmsg directement, c'est-à-dire cat /proc/kmsg.

Maintenant, si vous lisez le manuel proc convivial, il vous avertira sévèrement de ne laisser qu'un seul utilisateur (qui doit être privilégié) lire /proc/kmsg à la fois. Quelle que soit l'implémentation de syslog que vous avez, vous devriez le faire, et il est probable que cela fonctionne avec dmesg. Je ne sais pas, je ne suis pas à la hauteur, je paraphrase juste le manuel. Donc, même si c'est la méthode du “juste faire fonctionner @#$%ing”, considérez d'abord les deux méthodes suivantes.

Page de manuel approuvée : watch + dmesg

Sur une boîte linux que j'utilise avec systemd init*, dmesg.log n'est pas écrit très souvent, peut-être pas du tout ? La meilleure façon que j'ai trouvée pour lire le tampon du journal du noyau en continu est avec watch. Quelque chose comme ceci devrait vous aider à démarrer (ajustez le nombre de lignes qui tiennent dans votre terminal) :

watch 'dmesg | tail -50'

watch + dmesg + daemon + tail -f

Une solution plus complexe pourrait utiliser watch pour écrire la sortie du dmesg dans un fichier, que vous pourriez alors tail -f. Vous voudriez probablement que cela fonctionne comme un démon. Un vrai démon pourrait aussi gzip et faire tourner les logs. Le code de bash suivant n'a pas été testé, ne fonctionne pas, et est uniquement destiné à transmettre une idée. La réponse de Brooks Moses a une version de travail .

watch 'dmesg >> /var/log/dmesg.log | tail -1'

* tangente, car cette question concerne un bureau Apple : lorsque systemd est présent, ne vous embêtez pas avec dmesg ; utilisez journalctl -xf (peut-être avec -n 100 pour montrer aussi les 100 lignes précédentes)

Sous Linux, depuis le noyau 3.5.0 vous pouvez utiliser :

dmesg -w

Aussi sur les systèmes avec systemd vous pouvez utiliser

journalctl -kf

Voici une variante de la réponse de djeikyb qui a été testée, et qui corrige quelques bogues.

watch 'sudo dmesg -c >> /tmp/dmesg.log; tail -n 40 /tmp/dmesg.log'

L'astuce importante est que nous faisons dmesg -c, qui efface le tampon circulaire après qu'il ait été imprimé – ainsi, à chaque fois, nous n'imprimons que ce qui est nouveau depuis la dernière fois.

Il faut être root pour faire ça, donc le sudo. Il y a aussi une correction de bogue ; au lieu d'essayer de transférer la sortie dans un fichier et de l'envoyer à la queue (ce qui ne fonctionne pas), nous lisons simplement à partir du fichier nouvellement écrit.

Nous pourrions faire juste dmesg > /tmp/dmesg.log et écraser tout le fichier à chaque itération, mais cela fait beaucoup d'entrées/sorties et risque aussi de perdre le fichier si l'ordinateur plante au milieu d'une écrasement.

Vous pourriez aussi faire quelque chose de similaire qui ressemble plus à tail -f avec une boucle while qui exécute dmesg -c et sleep 1 pour toujours (voir la réponse de Ben Harris). Cependant, comme cela efface le tampon de messages du noyau pendant qu'il fonctionne, vous pouvez aussi placer les choses dans un fichier journal au cas où vous les voudriez plus tard.

J'ai fait cela avant de voir ce poste :

#!/usr/bin/env perl

use strict;
use warnings;

# "tail -f" for dmesg
# Keeps last printed line. Anything sorting "gt" will be newer

$|=1;

my $y = '';

while(1) {
    for my $k (`dmesg`) {
        if ($k gt $y) {
            print $k;
            $y = $k;
        }
    }
    sleep 1;
}
exit;

Voici quelques idées pour les environnements limités

Des environnements tels que les environnements intégrés ou pré-démarrage, où les commandes de montre, queue, chat, dd et autres ne sont pas disponibles, peuvent nécessiter une gymnastique différente.

C'est ce que font certaines distributions Linux légères :

while dmesg -c >> /tmp/dmesg.log; do sleep 0.1; done & tail -f /tmp/dmesg.log

Il met en arrière-plan la boucle while (avec &) tout en suivant la sortie générée.

Si vous ne pouvez pas écrire dans /tmp :

mount -t tmpfs - /tmp 

# or 
mount -t ramfs - /tmp 

# or use /dev/shm instead of /tmp - which is available in newer environments

Si vous n'avez pas de queue, vous pouvez

cat /tmp/dmesg.log

# or 
dd if=/tmp/dmesg.log 

# or
dd if=/tmp/dmesg.log 2>/dev/null

Ou vous pouvez être dans un environnement busybox qui n'a pas de dmesg lié, alors juste :

busybox dmesg -c

Vous pourriez aussi avoir besoin de

busybox sleep

au lieu de dormir

Si vous n'avez pas de sommeil :

while dmesg -c; do echo >/dev/null; done

Si vous n'avez pas de “dmesg” :

while sleep 0.1; do cat -v /proc/kmsg; done

Cela ne fonctionne que si rien d'autre n'est lu ici. Vous pouvez aussi avoir un /dev/kmsg.

Astuce :

Si vous ne savez pas ce que vous avez, et que vous n'avez pas de “l”, juste :

busybox ls

# or simply:

echo *

Vous pouvez peut-être faire :

tail -f /var/log/messages
```.

J'utilise cet alias dans /root/.bashrc ;

alias dwatch='watch -n 0.1 "dmesg | tail -n $((LINES-6))"'

qui suit le dmesg et ajuste les lignes pour n'importe quel terminal dans lequel il est appelé.

Sous l'actuel Ubuntu (j'utilise Ubuntu 12.04 (Precise Pangolin)),

tail -f /var/log/syslog
6< <( cat /var/log/syslog |grep -F 'kernel: '; sudo cat /proc/kmsg) cat /dev/fd/6

( la commande sudo nécessite le privilège sudo )

Veuillez également en essayer une autre comme celle-ci : 6< <( dmesg ; sudo cat /proc/kmsg) cat /dev/fd/6

J'ai utilisé ce code pour rechercher un événement spécial du noyau et je lui ai transmis un processus de “callback” :

while true ; do dmesg -c ; sleep .1 ; done \
| grep --line-buffered -o $pattern \
| ...

Cela pourrait être utile :

dmesg | tail -f -

conduit la sortie de dmesg à travers la queue en utilisant l'opérateur - comme raccourci vers la sortie standard.