Vuoi fare qualcosa del genere

dmesg | tail -f

ma non funziona: uso Mac OSX 10.6.7, facendo uscire la coda, invece di monitorare l'output.

Mi chiedo se c'è un modo per farlo o un comando equivalente. PS, non penso che un whileloop sia una buona idea.

Probabilmente stai cercando una combinazione di messaggi da vari file di registro. Provare:

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

... per avere una visione abbastanza buona del sistema. Se vuoi più o meno di quello, cerca in quale file di registro vengono inseriti i messaggi che vuoi vedere.

Cerca anche di utilizzare il multitailfile e il codice colore e di filtrare più file di registro contemporaneamente.

Modifica: questo non è stato molto rilevante quando ho risposto a questa domanda, ma poiché questa pagina ottiene molti successi, ho pensato che valesse la pena ricordare che i sistemi più recenti che eseguono systemd hanno questo.

dmesg -w

Fallo funzionare @ # $% ing

1. Volete stampare l'output di dmesg, costantemente, immediatamente
2. Dmesg sta stampando il buffer dell'anello del kernel (vedi man dmesg)
3. Il buffer dell'anello del kernel è un file proc speciale, /proc/kmsg(vedi man proc)
4. Leggi /proc/kmsgdirettamente, ad es cat /proc/kmsg.

Ora, se leggi il simpatico manuale proc, ti avvertirà severamente di far leggere /proc/kmsgun solo utente (che deve essere privilegiato) alla volta. Qualunque sia l'implementazione di syslog che dovresti fare, e presumibilmente funziona dmesg. Non so, sono fuori dalla mia portata qui, sto solo parafrasando il manuale. Quindi, mentre questo è il modo "basta farlo @ # $% ing lavoro", considera prima i metodi della coppia successiva.

Pagina man approvata: watch + dmesg

Su Arch gnu / linux con systemd init *, dmesg.log non viene scritto molto spesso, forse per niente? Il modo migliore che ho trovato per leggere continuamente il buffer di registro del kernel è con watch. Qualcosa del genere dovrebbe iniziare (regolare per quante linee si adattano al tuo terminale):

watch 'dmesg | tail -50'

guarda + dmesg + daemon + tail -f

Una soluzione più complessa potrebbe utilizzare watch per scrivere l'output di dmesg su file, che è quindi possibile tail -f. Probabilmente vorresti che funzionasse come un demone. Un demone corretto inoltre gzip e ruoterebbe i log. Il seguente codice bash non è testato, non funziona e ha solo lo scopo di trasmettere un'idea. @Brooks La risposta di Mosè ha una versione funzionante .

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

* tangente, perché questa è una domanda osx, ma quando systemd è in giro, non preoccuparti dmesg, usa journalctl -xf(forse w / -n 100per mostrare anche le 100 linee precedenti)

Per coloro che sono interessati a Linux, dal kernel kernel 3.5.0:

# dmesg -w

Anche sui sistemi con systemdte puoi:

# journalctl -kf

Ecco una variante della risposta di djeikyb che è stata effettivamente testata e risolve un paio di bug.

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

Il trucco importante è che lo stiamo facendo dmesg -c, che cancella il buffer dell'anello dopo la stampa, quindi ogni volta stampiamo solo le novità dall'ultima volta. Dovrai essere root per farlo, quindi il sudo. C'è anche un bugfix; invece di provare a scaricare l'output su un file e a reindirizzarlo (che non funziona), stiamo solo leggendo dal file appena scritto.

Potremmo fare solo dmesg > /tmp/dmesg.loge sovrascrivere l'intero file ogni iterazione, ma questo è un sacco di I / O e rischia anche di perdere il file se il computer si arresta in modo anomalo nel mezzo di una sovrascrittura.

Potresti anche fare qualcosa di simile che è più simile tail -fa un ciclo while che viene eseguito dmesg -cper sleep 1sempre (vedi la risposta di Ben Harris). Tuttavia, poiché questo sta effettivamente cancellando il buffer dei messaggi del kernel mentre è in esecuzione, potresti anche voler convogliare le cose in un file di registro nel caso in cui le desideri in un secondo momento.

Questo potrebbe funzionare per te

while true;do sudo dmesg -c;done

Tieni presente che il flag '-c' cancella il buffer dei messaggi in stdout. Il "sudo" non è necessario se si è root. Se ritieni che questo stia consumando troppo della tua risorsa CPU, prova ad aggiungere un "sleep 1" prima che il ciclo sia terminato.

Ho fatto questo prima di vedere questo 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;

potresti essere in grado di fare:

tail -f /var/log/messages

mentre dmesg -c >> /tmp/dmesg.log; dormire 0.1; done & tail -f /tmp/dmesg.log

Uso questo alias in /root/.bashrc;

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

che segue dmesg e regola le linee per qualunque terminale venga chiamato.

Sotto l'attuale Ubuntu (sto usando Ubuntu 12.04),

tail -f /var/log/syslog

può soddisfare il requisito.

Ho usato questo codice per cercare un evento del kernel speciale e ho inviato un processo di "callback":

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

risposta a una vecchia domanda, ma qualcuno potrebbe trovarla utile :)

dmesg | tail -f -

convoglia l'output di dmesg attraverso tail usando l'operatore - come scorciatoia per stdout