Veux faire quelque chose comme

dmesg | tail -f

mais cela ne fonctionne pas: j'utilise Mac OSX 10.6.7, ce qui fait que la queue se fermera au lieu de surveiller la sortie.

Je me demande s'il existe un moyen de le faire, ou une commande équivalente. PS, je ne pense pas qu'une whileboucle sera une idée assez bonne.

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

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

… Pour avoir un bon aperçu du système. Si vous voulez plus ou moins que cela, recherchez dans quel fichier de journal les messages que vous voulez voir sont placés.

Recherchez également dans les multitailfichiers et les codes de couleurs et filtrez plusieurs fichiers journaux à la fois.

Edit: Cela n’était pas très pertinent lorsque j’ai répondu à cette question, mais comme cette page reçoit de nombreux hits, je pense qu’il vaut la peine de mentionner que les systèmes plus récents exécutant systemd ont cela.

dmesg -w

Il suffit de faire @ # $% ing travail

1. Vous voulez imprimer la sortie de dmesg, constamment, immédiatement
2. Dmesg est en train d’imprimer le tampon circulaire du noyau (voir man dmesg)
3. Le tampon circulaire du noyau est un fichier proc spécial, /proc/kmsg(voir man proc)
4. Lire /proc/kmsgdirectement, c'est à dire cat /proc/kmsg.

Maintenant, si vous lisez le manuel convivial de proc, il vous avertira de ne laisser qu'un seul utilisateur (qui doit être privilégié) à la lecture /proc/kmsg. Quelle que soit l'implémentation de syslog que vous avez devrait faire cela, et cela fonctionne vraisemblablement avec dmesg. Je ne sais pas, je suis hors de mon championnat ici, juste pour paraphraser le manuel. Ainsi, bien que ce soit la méthode "il suffit de le faire @ # $% ing", considérons d’abord les méthodes suivantes.

Page de manuel approuvée: watch + dmesg

Sur Arch gnu / linux avec systemd init *, dmesg.log n’est pas écrit très souvent, peut-être même pas du tout? La meilleure façon de lire le tampon de journalisation du noyau que j'ai trouvé est d'utiliser watch. Quelque chose comme ceci devrait vous aider à démarrer (ajustez le nombre de lignes contenues dans votre terminal):

watch 'dmesg | tail -50'

regarder + dmesg + daemon + tail -f

Une solution plus compliquée pourrait utiliser watch pour écrire la sortie de dmesg dans un fichier, que vous pourriez ensuite tail -f. Vous voudrez probablement que cela fonctionne en tant que démon. Un démon approprié serait également gzip et faire pivoter les journaux. Le code bash suivant est non testé, non fonctionnel et uniquement destiné à véhiculer une idée. La réponse de @Brooks Moses a une version de travail .

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

* tangente, car c’est une question osx, mais lorsque systemd est présent, ne vous embêtez pas avec dmesg, utilisez journalctl -xf(peut-être -n 100aussi pour afficher les 100 lignes précédentes)

Pour ceux intéressés par Linux, depuis le noyau noyau 3.5.0:

# dmesg -w

Aussi sur les systèmes avec systemdvous pouvez:

# journalctl -kf

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

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

Le truc important est que nous faisons ce dmesg -cqui efface le tampon de sonnerie après l’impression - ainsi, à chaque fois, nous n’imprimons que les nouveautés depuis la dernière fois. Vous devez être root pour le faire, donc le sudo. Il y a aussi un bugfix; au lieu d'essayer à la fois de vider la sortie dans un fichier et de la canaliser (ce qui ne fonctionne pas), nous lisons simplement à partir du fichier nouvellement écrit.

Nous pourrions faire juste dmesg > /tmp/dmesg.loget écraser le fichier entier à chaque itération, mais cela fait beaucoup d'E / S et risque également de perdre le fichier si l'ordinateur tombe en panne au milieu d'un écrasement.

Vous pouvez également faire quelque chose de similaire qui ressemble plus étroitement tail -fà une boucle while qui s'exécute dmesg -cet sleep 1pour toujours (voir la réponse de Ben Harris). Cependant, étant donné que cela efface réellement la mémoire tampon de messages du noyau pendant son exécution, vous pouvez également diriger des éléments dans un fichier journal au cas où vous les voudriez plus tard.

Cela peut fonctionner pour vous

while true;do sudo dmesg -c;done

N'oubliez pas que l'indicateur '-c' efface le tampon de messages dans stdout. Le 'sudo' est inutile si vous êtes root. Si vous pensez que cela consomme trop de ressources de votre processeur, essayez d’ajouter un «sommeil 1» avant la fin de la boucle.

A fait cela avant de voir ce post:

#!/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;

vous pourriez être capable de faire:

tail -f /var/log/messages

tandis que dmesg -c >> /tmp/dmesg.log; dormez 0,1; done & tail -f /tmp/dmesg.log

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

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

qui suit dmesg et ajuste les lignes pour le terminal appelé.

Sous l’actuel Ubuntu (j’utilise Ubuntu 12.04),

tail -f /var/log/syslog

peut répondre à l'exigence.

J'ai utilisé ce code pour rechercher un événement spécial du noyau et lui ai transmis un processus de "rappel":

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

réponse à une vieille question, mais quelqu'un pourrait trouver cela utile :)

dmesg | queue -f -

achemine la sortie de dmesg par tail en utilisant l'opérateur - comme raccourci vers stdout