Probabilmente stai cercando una combinazione di messaggi da vari file di log. Provate:

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

…per avere una panoramica abbastanza buona del sistema. Se vuoi più o meno di questo, cerca in quale file di log i messaggi che vuoi vedere vengono inseriti.

Guarda anche come usare multitail per archiviare e colorare e filtrare più file di log in una volta sola.

Modifica: Questo non era molto rilevante quando ho risposto, ma dato che questa pagina riceve molte visite, ho pensato che valesse la pena menzionare che i sistemi più recenti con systemd hanno questo.

dmesg -w

Just make it @#$%% work

1. Vuoi stampare l'output di dmesg, costantemente, immediatamente
2. Dmesg sta stampando il ring buffer del kernel (vedi man dmesg)
3. Il ring buffer del kernel è un file proc speciale, /proc/kmsg (vedi man proc)
4. Leggi direttamente /proc/kmsg, cioè cat /proc/kmsg.

Ora, se leggete l'amichevole manuale di proc, vi avvertirà severamente di lasciare che solo un utente (che deve essere privilegiato) legga /proc/kmsg alla volta. Qualsiasi implementazione syslog abbiate dovrebbe fare questo, e presumibilmente funziona con dmesg. Non so, sono fuori dalla mia portata qui, sto solo parafrasando il manuale. Quindi, mentre questo è il modo “fallo solo funzionare @#$%%”, considerate prima i prossimi due metodi.

Pagina uomo approvata: watch + dmesg

Su una scatola linux che uso 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 log del kernel è con watch. Qualcosa come questo dovrebbe farvi iniziare (aggiustate per quante linee ci stanno nel vostro terminale):

watch 'dmesg | tail -50'

watch + dmesg + daemon + tail -f

Una soluzione più contorta potrebbe usare watch per scrivere l'output di dmesg su file, che potreste poi tail -f. Probabilmente vorrete che questo venga eseguito come demone. Un demone adeguato dovrebbe anche gzippare e ruotare i log. Il seguente codice bash non è testato, non funziona, ed è inteso solo a trasmettere un'idea. La risposta di @Brooks Moses ha una versione funzionante .

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

* tangente, perché questa è una domanda su un sistema operativo desktop apple: quando c'è systemd, non preoccupatevi di dmesg; usate journalctl -xf (forse con -n 100 per mostrare anche le 100 linee precedenti)

Su Linux, dal kernel 3.5.0 si può usare:

dmesg -w

Anche sui sistemi con systemd potete usare:

journalctl -kf

Ecco una variante sulla risposta di djeikyb che è 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 stiamo facendo dmesg -c, che cancella il ring buffer dopo aver stampato – così, ogni volta stiamo stampando solo ciò che è nuovo dall'ultima volta.

Dovrai essere root per farlo, quindi lo sudo. C'è anche un bugfix; invece di provare sia a scaricare l'output in un file che a pipearlo in tail (che non funziona), stiamo solo leggendo dal file appena scritto.

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

Si potrebbe anche fare qualcosa di simile che è più simile a tail -f con un ciclo while che esegue dmesg -c e sleep 1 per sempre (vedere la risposta di Ben Harris). Tuttavia, dal momento che questo sta effettivamente cancellando il buffer dei messaggi del kernel mentre è in esecuzione, si potrebbe anche voler convogliare le cose in un file di registro nel caso in cui le si voglia in seguito.

L'ho fatto 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;

Ecco alcune idee per ambienti limitati

Ambienti come quelli embedded o pre-boot, dove watch, tail, cat, dd e altri comandi potrebbero non essere disponibili, potrebbero richiedere una ginnastica diversa.

Questo è ciò che fanno alcune distribuzioni Linux leggere:

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

Sfondo il ciclo while (con &) mentre si pedina l'output generato.

Se non puoi scrivere su /tmp:

mount -t tmpfs - /tmp 

# or 
mount -t ramfs - /tmp 

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

Se non avete tail, potete

cat /tmp/dmesg.log

# or 
dd if=/tmp/dmesg.log 

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

Oppure potreste essere in un ambiente busybox che non ha dmesg collegato, allora solo:

busybox dmesg -c

Potresti anche aver bisogno di

busybox sleep

invece di sleep

Se non hai sleep:

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

Se non hai “dmesg”:

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

Questo funziona solo se nient'altro sta leggendo da qui. Potresti anche avere un /dev/kmsg.

Bonus tip:

Se non sapete cosa avete, e non avete “ls”, semplicemente:

busybox ls

# or simply:

echo *

Potreste fare:

tail -f /var/log/messages

Io 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 qualsiasi terminale in cui è chiamato.

Sotto l'attuale Ubuntu (sto usando 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

( il comando sudo ha bisogno dei privilegi sudo)

Per favore provate anche un altro come: 6< <( dmesg; sudo cat /proc/kmsg) cat /dev/fd/6

Ho usato questo codice per cercare un evento speciale del kernel e l'ho collegato a un processo di “callback”:

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

Questo potrebbe essere utile:

dmesg | tail -f -

fa passare l'output di dmesg attraverso tail usando l'operatore - come scorciatoia per lo standard output.