Análisis de dmesg y Logs del Kernel en Linux

dmesg es la herramienta principal para acceder al ring buffer de mensajes del kernel Linux, que registra eventos desde el arranque del sistema hasta la actividad de hardware en tiempo real. Analizar los mensajes del kernel con dmesg es indispensable para diagnosticar problemas de hardware, errores de controladores, fallos de memoria y comportamientos anómalos del sistema. Esta guía cubre el uso avanzado de dmesg, la interpretación de niveles de log, el filtrado de mensajes y la configuración de monitoreo automatizado del kernel.

Requisitos Previos

Linux con acceso a dmesg (cualquier distribución moderna)
Acceso root o pertenencia al grupo adm para ver todos los mensajes
systemd para journalctl (Ubuntu 16.04+, CentOS 7+)

# Verificar acceso a dmesg
dmesg | head -5
# Si falla, añadir al grupo adm
usermod -aG adm $USER
# O como root directamente
sudo dmesg | head -5

Uso Básico de dmesg

# Ver todos los mensajes del kernel (desde el arranque)
dmesg

# Ver los últimos N mensajes
dmesg | tail -50
dmesg -c  # Ver y limpiar el buffer (requiere root)

# Formato legible con timestamps (formato predeterminado en sistemas modernos)
dmesg -T  # Timestamps en formato humano
dmesg --ctime  # Equivalente en versiones antiguas

# Ver en tiempo real (seguir los mensajes nuevos)
dmesg -w
dmesg --follow

# Ver solo desde el último arranque (kernels 3.5+)
dmesg -T | head -20

# Contar total de mensajes en el buffer
dmesg | wc -l

# Ver el tamaño del ring buffer del kernel
dmesg -s 8192  # Ajustar el tamaño del buffer de salida
cat /proc/sys/kernel/dmesg_restrict  # 0=acceso libre, 1=solo root

Niveles de Log y Filtrado

El kernel classifica los mensajes en 8 niveles de severidad:

Nivel	Nombre	Descripción
0	EMERG	Sistema inutilizable
1	ALERT	Requiere acción inmediata
2	CRIT	Condición crítica
3	ERR	Error del kernel
4	WARNING	Advertencia
5	NOTICE	Condición normal pero significativa
6	INFO	Mensaje informativo
7	DEBUG	Mensaje de depuración

# Filtrar por nivel de log
dmesg -l err          # Solo errores
dmesg -l warn         # Solo advertencias
dmesg -l err,warn     # Errores y advertencias
dmesg -l crit,alert,emerg  # Niveles críticos

# Filtrar por subsistema del kernel
dmesg -f kern         # Mensajes del kernel
dmesg -f daemon       # Mensajes de daemons
dmesg -f user         # Mensajes de espacio de usuario

# Combinar nivel y subsistema
dmesg -l err -f kern

# Filtrar con grep (búsqueda de texto)
dmesg | grep -i "error\|fail\|warning"
dmesg | grep -i "usb"     # Eventos USB
dmesg | grep -i "ata\|sata\|nvme"  # Discos
dmesg | grep -i "eth\|eno\|ens\|network"  # Red
dmesg | grep -i "memory\|oom"  # Memoria

# Filtrar por tiempo (mensajes después de N segundos del arranque)
dmesg | awk '$1 > 3600'  # Mensajes después de 1 hora de uptime

Análisis de Mensajes de Arranque

# Ver mensajes del proceso de arranque secuencialmente con timestamps
dmesg -T | head -100

# Información clave del arranque del kernel
dmesg -T | grep -E "Linux version|Command line|BIOS|ACPI|PCI|Memory"

# Ver parámetros con los que arrancó el kernel
dmesg | grep "Command line:"
cat /proc/cmdline

# Ver cuánta memoria detectó el kernel
dmesg | grep -E "Memory:|RAM:|BIOS-e820"

# Ver información de CPUs detectadas
dmesg | grep -E "CPU|processor|GHz|MHz" | head -20

# Ver todos los discos detectados durante el arranque
dmesg | grep -E "sd[a-z]|nvme|ata[0-9]" | head -30

# Análisis completo del arranque con tiempos
cat > /usr/local/bin/boot-analysis.sh << 'EOF'
#!/bin/bash
# Análisis de mensajes de arranque del kernel
echo "=== Análisis de Arranque del Kernel ==="
echo "Versión del kernel: $(uname -r)"
echo "Tiempo de arranque: $(dmesg | tail -1 | awk '{print $1}')s desde inicio del kernel"
echo ""
echo "--- Hardware detectado ---"
dmesg -T | grep -E "CPU|Memory:|nvme|sda|eth0|ens|eno" | head -20
echo ""
echo "--- Errores durante arranque ---"
dmesg -T | grep -E "\[err\]|\[warn\]|error|Error" | head -20
EOF
chmod +x /usr/local/bin/boot-analysis.sh

Diagnóstico de Hardware

Diagnóstico de Discos

# Ver errores de disco (ATA/SATA)
dmesg | grep -E "ata[0-9]|sata|blk_update_request|I/O error" | head -20

# Detectar sectores defectuosos
dmesg | grep -i "sector\|bad block\|read error\|medium error"

# Ver estado de NVMe
dmesg | grep -i "nvme"

# Verificar si hay errores de sistema de archivos
dmesg | grep -E "EXT4-fs|XFS|BTRFS" | grep -i "error\|corrupt"

# Ejemplo de mensaje de error de disco a buscar:
# [sda] tag#30 Add. Sense: Unrecovered read error
# I/O error, dev sda, sector 12345
# end_request: I/O error, dev sda, sector 12345

Diagnóstico de Memoria

# Ver errores de memoria (ECC, bad pages)
dmesg | grep -i "memory\|mce\|edac\|ecc\|dimm"

# Machine Check Exceptions (errores de hardware graves)
dmesg | grep -i "mce\|machine check"

# OOM Killer (proceso matado por falta de memoria)
dmesg | grep -i "oom\|killed process\|out of memory"

# Ver detalles del OOM killer
dmesg | grep -A 20 "Out of memory"
# El OOM killer muestra: el proceso matado, el proceso que causó el OOM,
# y el estado de la memoria en ese momento

Diagnóstico de Red

# Ver detección de interfaces de red
dmesg | grep -E "eth[0-9]|ens[0-9]|eno[0-9]|enp[0-9]"

# Errores de interfaz de red
dmesg | grep -i "link\|duplex\|negotiat\|carrier"

# Detectar caídas de enlace
dmesg | grep -i "link down\|link up"
dmesg -w | grep -i "link"  # Monitorear en tiempo real

# Ver errores del controlador de red
dmesg | grep -iE "e1000|r8169|ixgbe|tg3|bnx2" | grep -i error

Diagnóstico USB

# Ver dispositivos USB conectados y desconectados
dmesg | grep -i usb | tail -30

# Errores de USB
dmesg | grep -i "usb.*error\|urb.*error\|disconnect"

# Ver modelo y velocidad del dispositivo USB
dmesg | grep -E "New USB device found|Product:|Manufacturer:|USB.*speed"

Patrones de Error Comunes

# Script de detección de errores comunes del kernel
cat > /usr/local/bin/dmesg-check.sh << 'EOF'
#!/bin/bash
# Verificación rápida de errores del kernel
echo "=== Verificación de Logs del Kernel ==="
echo "Timestamp: $(date)"

# Función para contar y mostrar errores
check_pattern() {
    local descripcion="$1"
    local patron="$2"
    local count=$(dmesg | grep -ci "$patron")
    if [ $count -gt 0 ]; then
        echo ""
        echo "[ALERTA] $descripcion: $count ocurrencias"
        dmesg | grep -i "$patron" | tail -5
    fi
}

check_pattern "Errores de disco" "I/O error"
check_pattern "Sectores defectuosos" "bad sector\|unrecovered"
check_pattern "Errores de memoria" "mce\|memory error\|edac"
check_pattern "OOM Killer activado" "out of memory\|oom.*kill"
check_pattern "Errores del sistema de archivos" "filesystem error\|ext4.*error\|xfs.*error"
check_pattern "Errores de red" "link down\|carrier"
check_pattern "Errores USB" "usb.*error\|urb.*error"
check_pattern "Errores ACPI" "ACPI.*Error\|ACPI.*Warning"

echo ""
echo "--- Últimos 5 errores del kernel ---"
dmesg -T -l err,crit,alert,emerg | tail -5

echo ""
echo "Verificación completada."
EOF
chmod +x /usr/local/bin/dmesg-check.sh
/usr/local/bin/dmesg-check.sh

Interpretar Mensajes Específicos

# Kernel Oops (el kernel reporta un fallo pero continúa)
# Buscar el trace
dmesg | grep -A 30 "BUG:\|Oops:\|kernel BUG"

# Kernel Panic (el sistema se detiene)
# Ver en logs del arranque anterior
journalctl -k -b -1 | grep -i "panic\|oops" | tail -20

# Soft lockup (CPU bloqueada más de 20s)
dmesg | grep -i "soft lockup\|RCU stall\|hung_task"

# Hard lockup (NMI watchdog)
dmesg | grep -i "hard LOCKUP\|NMI watchdog"

Logs del Kernel con journalctl

En sistemas con systemd, journalctl también puede acceder a los mensajes del kernel:

# Ver solo mensajes del kernel (equivalente a dmesg)
journalctl -k
journalctl --dmesg

# Mensajes del kernel del arranque actual
journalctl -k -b 0

# Mensajes del kernel del arranque anterior
journalctl -k -b -1

# Solo errores del kernel
journalctl -k -p err
journalctl -k -p warning..err  # Advertencias y errores

# Seguir mensajes en tiempo real
journalctl -k -f

# Mensajes del kernel en las últimas 2 horas
journalctl -k --since "2 hours ago"

# Buscar patrón específico en logs del kernel
journalctl -k | grep -i "disk\|ata\|nvme"

# Guardar logs del kernel para análisis posterior
journalctl -k -b 0 > /tmp/kernel-boot.log
journalctl -k --since "24 hours ago" > /tmp/kernel-24h.log

Monitoreo Automatizado

Monitoreo en Tiempo Real con Alertas

# Script de monitoreo continuo de errores del kernel
cat > /usr/local/bin/kernel-monitor.sh << 'EOF'
#!/bin/bash
# Monitoreo continuo de errores del kernel con alertas
LOG="/var/log/kernel-monitor.log"
ALERTAS="/var/log/kernel-alerts.log"
EMAIL="[email protected]"

# Patrones críticos que requieren alerta inmediata
PATRONES_CRITICOS="Out of memory|I/O error|hard LOCKUP|kernel BUG|Oops:|EXT4-fs error|XFS.*corruption"

# Monitorear dmesg en tiempo real
dmesg -w | while read linea; do
    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    
    # Registrar todos los mensajes de warning y error
    if echo "$linea" | grep -qiE "error|warn|fail"; then
        echo "$TIMESTAMP $linea" >> "$LOG"
    fi
    
    # Alertar para patrones críticos
    if echo "$linea" | grep -qiE "$PATRONES_CRITICOS"; then
        echo "$TIMESTAMP [CRITICO] $linea" >> "$ALERTAS"
        logger -t kernel-monitor "ALERTA CRITICA: $linea"
        
        # Enviar alerta por correo
        echo "Alerta del kernel en $(hostname):
Timestamp: $TIMESTAMP
Mensaje: $linea" | mail -s "ALERTA KERNEL: $(hostname)" "$EMAIL" 2>/dev/null
    fi
done
EOF
chmod +x /usr/local/bin/kernel-monitor.sh

# Ejecutar como servicio de systemd
cat > /etc/systemd/system/kernel-monitor.service << 'EOF'
[Unit]
Description=Monitor de errores del kernel
After=multi-user.target

[Service]
Type=simple
ExecStart=/usr/local/bin/kernel-monitor.sh
Restart=always
RestartSec=5s

[Install]
WantedBy=multi-user.target
EOF

systemctl enable --now kernel-monitor.service

Reporte Diario de Kernel

cat > /usr/local/bin/kernel-daily-report.sh << 'EOF'
#!/bin/bash
# Reporte diario de logs del kernel
REPORTE="/var/log/kernel-report-$(date +%Y%m%d).txt"

echo "=== Reporte Diario del Kernel ===" > "$REPORTE"
echo "Sistema: $(hostname)" >> "$REPORTE"
echo "Kernel: $(uname -r)" >> "$REPORTE"
echo "Fecha: $(date)" >> "$REPORTE"

echo -e "\n--- Resumen de Errores (últimas 24h) ---" >> "$REPORTE"
journalctl -k --since "24 hours ago" -p err | wc -l | \
    xargs -I{} echo "Total errores: {}" >> "$REPORTE"
journalctl -k --since "24 hours ago" -p warning | wc -l | \
    xargs -I{} echo "Total advertencias: {}" >> "$REPORTE"

echo -e "\n--- Errores más recientes ---" >> "$REPORTE"
journalctl -k --since "24 hours ago" -p err --no-pager | tail -20 >> "$REPORTE"

echo -e "\n--- Eventos OOM ---" >> "$REPORTE"
journalctl -k --since "24 hours ago" | grep -i "out of memory" >> "$REPORTE" || \
    echo "Sin eventos OOM" >> "$REPORTE"

echo -e "\n--- Errores de disco ---" >> "$REPORTE"
journalctl -k --since "24 hours ago" | grep -i "I/O error" >> "$REPORTE" || \
    echo "Sin errores de disco" >> "$REPORTE"

mail -s "Reporte Kernel: $(hostname) - $(date +%Y-%m-%d)" [email protected] < "$REPORTE"
EOF
chmod +x /usr/local/bin/kernel-daily-report.sh
echo "0 7 * * * root /usr/local/bin/kernel-daily-report.sh" > /etc/cron.d/kernel-report

Solución de Problemas

dmesg no muestra mensajes recientes (buffer lleno):

# El ring buffer tiene un tamaño fijo, mensajes antiguos se descartan
# Ver el tamaño actual del buffer
dmesg --buffer-size  # En bytes
# Para ver el historial completo, usar journalctl
journalctl -k --since boot | wc -l

Error "dmesg: read kernel buffer failed: Operation not permitted":

# Restricciones de seguridad activas
cat /proc/sys/kernel/dmesg_restrict
# Si es 1, solo root puede ver dmesg
# Añadir usuario al grupo adm para acceso
usermod -aG adm nombre_usuario
# O deshabilitar la restricción (no recomendado en producción)
echo 0 > /proc/sys/kernel/dmesg_restrict

No se pueden ver mensajes de arranques anteriores con dmesg:

# dmesg solo muestra el arranque actual
# Para arranques anteriores, usar journalctl
journalctl -k -b -1  # Arranque anterior
journalctl -k -b -2  # Dos arranques atrás
journalctl --list-boots  # Ver todos los arranques disponibles

Los timestamps de dmesg están desfasados:

# dmesg muestra segundos desde el arranque del kernel
dmesg -T   # Convierte a fecha/hora real
# Si el sistema cambió de zona horaria, los timestamps pueden parecer incorrectos
TZ=UTC dmesg -T  # Ver en UTC

Conclusión

dmesg es la ventana más directa al comportamiento interno del kernel Linux, desde la detección de hardware en el arranque hasta errores en tiempo real de discos, memoria y red. Combinar dmesg con journalctl -k para acceder a histórico de arranques y configurar monitoreo automatizado de patrones críticos como errores de I/O, OOM killer y lockups permite detectar y diagnosticar problemas de hardware y sistema antes de que evolucionen en fallos catastróficos. El análisis regular de logs del kernel es una práctica fundamental en la administración proactiva de servidores.

dmesg and Kernel Log Analysis

On this page