Cómo identificar y gestionar una tarjeta SD en Linux con comandos

Si trabajas con Linux a diario, tarde o temprano vas a necesitar identificar con precisión una tarjeta SD o cualquier otro dispositivo de almacenamiento: para formatearla, montarla, clonar una Raspberry Pi, hacer copias sector a sector con dd o simplemente para no liarla y borrar el disco duro por error. En sistemas tipo UNIX, esos dispositivos se representan con rutas como /dev/sda, /dev/sdb1, etc., muy lejos de las clásicas unidades C: o D: de Windows.

Además de localizar tu SD, es fundamental conocer bien el hardware y el software de tu sistema GNU/Linux: qué kernel estás usando, qué módulos están cargados, detalles de la memoria RAM, tarjetas PCI/USB, red, etc. Todo esto no solo es útil para diagnosticar problemas, sino también para elegir el software adecuado, pedir ayuda en foros y asegurarte de que un dispositivo es realmente lo que dice el fabricante, sin tener que abrir el ordenador y perder la garantía.

¿Cómo se nombran las tarjetas SD y otros discos en Linux?

En Linux, los discos y particiones se representan mediante archivos especiales en el directorio /dev/. Lo más habitual hoy en día es el esquema /dev/sdX, donde cada letra representa un dispositivo de bloque (discos duros, SSD, USB, tarjetas SD vistas como disco, etc.).

Un disco aparecerá como /dev/sda, /dev/sdb, /dev/sdc… dependiendo del orden en que el kernel los detecte. Sus particiones se numeran a continuación: /dev/sda1, /dev/sda2, etc. Esto significa que una tarjeta SD insertada en un lector USB suele verse como algo tipo /dev/sdb o /dev/sdc, con particiones /dev/sdb1, /dev/sdb2…

En un escenario sencillo, sin más discos que la tarjeta, un disco USB o SD externa podría terminar nombrado como /dev/sda si es el único dispositivo de bloque presente. En routers u otros aparatos embebidos basados en Linux donde solo conectas un disco USB, ese disco generalmente será /dev/sda, con su primera partición en /dev/sda1.

Ten muy presente que estos nombres pueden cambiar según arranques o conectes/quites dispositivos. Por eso muchas herramientas usan identificadores más estables como el UUID de la partición, aunque para operaciones rápidas desde terminal lo normal es trabajar con /dev/sdX.

Comandos básicos para localizar la tarjeta SD en Linux

Para identificar una tarjeta SD concreta sin volverte loco, lo ideal es combinar varios comandos y fijarte en capacidad, tipo de dispositivo y puntos de montaje. Estos son los más prácticos.

Listar todos los discos y particiones con `fdisk`

Un clásico para ver dispositivos de bloque es fdisk -l. Necesita permisos de administrador:

sudo fdisk -l

La salida muestra todos los discos (/dev/sda, /dev/sdb…) con su tamaño total y tabla de particiones. Buscando por capacidad, es bastante fácil localizar cuál de todos coincide con la tarjeta SD (por ejemplo 32 GB, 64 GB, etc.), y también verificar si se trata de tarjetas microSD compatibles. A partir de ahí, ya sabes qué dispositivo apuntar en comandos tipo dd if=/dev/sdX.

Ver dispositivos de almacenamiento conectados

Hay diferentes utilidades que ayudan a listar el hardware de almacenamiento conectado, cada una con su estilo:

lsblk muestra discos y sus particiones en forma de árbol con tamaño y punto de montaje.
lsscsi enseña dispositivos SCSI/SATA (discos duros, SSD, unidades ópticas), útil si tu lector SD se presenta como SCSI. Suele instalarse en Debian/Ubuntu con sudo apt install lsscsi y luego ejecutar lsscsi.
pydf es una versión “vitaminada” de df escrita en Python que muestra uso de espacio en disco con colores. Se instala con sudo apt install pydf y se usa como pydf.
hdparm ofrece multitud de opciones para consultar y ajustar parámetros de discos (hdparm /dev/sdb por ejemplo). Conviene usarlo con cuidado.

Con estas herramientas puedes ver de un vistazo qué dispositivos hay, su tamaño, tipo y si están montados. Combinando esto con la información de fdisk -l difícilmente te equivocarás de tarjeta SD.

Comodines para explorar rápidamente `/dev/sdX`

La shell de Linux permite usar comodines para trabajar sobre varios archivos a la vez, y esto es muy útil también para explorar dispositivos en /dev/. Algunos patrones básicos:

* representa desde ningún carácter hasta cualquier secuencia: ls /dev/sd* listará todos los discos tipo SCSI/SATA/USB (.ej. /dev/sda, /dev/sda1, /dev/sdb, etc.).
? equivale a un solo carácter: ls /dev/sda? mostrará /dev/sda más un carácter, por ejemplo /dev/sda1 a /dev/sda7.
[] define rangos: ls /dev/sda listará de /dev/sda1 a /dev/sda5.
niega un rango: ls /dev/sda listará las particiones de sda cuya parte numérica no está entre 1 y 5, por ejemplo /dev/sda6, /dev/sda7…
{} agrupa patrones separados por comas: ls /dev/{sda*,sdb*} mostrará todo lo que empiece por sda o sdb.
\ sirve para “escapar” caracteres especiales, como el espacio, cuando creas directorios o trabajas con rutas.

Estos comodines son muy prácticos cuando necesitas operar sobre varias particiones o discos a la vez, por ejemplo para listar, copiar o borrar varios dispositivos relacionados con tu tarjeta SD.

Herramientas gráficas para ver discos y tarjetas SD

Si no te apetece tirar solo de terminal, muchas distribuciones incluyen herramientas gráficas que muestran de forma clara los dispositivos de almacenamiento. Dos de las más habituales son:

Discos (GNOME Disks): en entornos GNOME (y derivados como Linux Mint Cinnamon) viene por defecto o se instala fácilmente desde el centro de software. Muestra cada disco, su tamaño, particiones, sistema de archivos, etiqueta y la ruta exacta tipo /dev/sdX. Es ideal para ver rápidamente cuál es tu SD.
Hardinfo: una utilidad gráfica muy completa para ver información de hardware y sistema (CPU, memoria, PCI, USB, discos, temperatura, etc.) y hacer pequeños benchmarks.

Hardinfo suele estar en los repositorios de la mayoría de distribuciones GNU/Linux. Puedes instalarlo desde el gestor de paquetes gráfico (Software, Synaptic, etc.) o con terminal, y lanzarlo desde el menú de aplicaciones o con el comando hardinfo.

En algunas versiones de Ubuntu puede aparecer el error “Failed to load module canberra-gtk-module” al arrancar la aplicación. Se arregla instalando el paquete correspondiente (por ejemplo libcanberra-gtk-module), y listo.

Dentro de Hardinfo la información se organiza en cuatro grandes grupos: Equipo, Dispositivos, Red y Benchmarks. Para localizar una tarjeta SD te interesan sobre todo las secciones de Dispositivos y Almacenamiento, donde verás discos, controladoras y detalles como tamaño y bus.

Comandos para conocer el sistema y los módulos del kernel

Muchas veces identificar una tarjeta SD pasa también por entender cómo la detecta el kernel y qué módulos intervienen. Aquí entran en juego algunos comandos clásicos.

Información básica del sistema y el kernel

Para saber qué sistema tienes entre manos, conviene dominar unos cuantos comandos cortos:

Versión del kernel: uname -r o uname -a para ver versión, arquitectura y más detalles.
Arquitectura del sistema: uname -m te dice si tu máquina es x86_64, armv7l, etc., algo importante cuando trabajas con dispositivos como Raspberry Pi.
Distribución y versión: en muchas distros modernas, lsb_release -a o mirar /etc/os-release da el nombre de la distribución, versión y nombre en clave.
Usuario actual: whoami te muestra con qué usuario estás ejecutando comandos, útil para saber si necesitas sudo.
Nombre del equipo: hostname devuelve el nombre de host del sistema.

Para conocer qué módulos del kernel están cargados en un momento dado se usa lsmod. Es especialmente interesante si estás trasteando con módulos relacionados con almacenamiento, buses o tarjetas (por ejemplo módulos SDHCI, controladores de bus, etc.).

Trabajar con módulos: ejemplo con Bluetooth

Una situación típica de administración es querer probar diferentes parámetros de un módulo del kernel sin reiniciar. Por ejemplo el módulo bluetooth. Lo normal sería descargarlo con:

sudo modprobe -r bluetooth

Sin embargo, a veces obtendrás errores indicando que el módulo no puede descargarse porque está en uso. Esto significa que algún dispositivo o servicio está usando ese módulo, y el kernel no lo suelta. Debes localizar qué lo usa (por ejemplo con lsmod o lsof) y parar el servicio o desconectar el dispositivo antes de intentar recargar el módulo con otros parámetros.

Listar hardware en detalle: CPU, PCI, USB, RAM y más

Además de los discos, a menudo necesitas saber qué hardware exacto tienes para asegurarte de que una tarjeta, gráfica, red o similar es lo que dices haber comprado.

Hardware general: `lshw` y `dmidecode`

El comando lshw lista absolutamente todo el hardware conocido por el sistema: CPU, memoria, buses, dispositivos PCI/USB, discos, etc. La salida es larga, por lo que se suele paginar:

sudo lshw | less

También puedes pedir un resumen más compacto con opciones como sudo lshw -short, que es más manejable cuando solo quieres ver de un vistazo qué dispositivos hay.

Otra herramienta potente es dmidecode, que extrae información de la tabla DMI de la BIOS/UEFI: modelo de placa base, BIOS, memoria, etc.. Como la salida también es extensa, se puede redirigir a un fichero:

sudo dmidecode -q >> hardware.txt

Luego abres hardware.txt con tu editor favorito o un less y revisas lo que te interese.

Dispositivos PCI: localizar una tarjeta gráfica o de red

Para ver qué hay conectado al bus PCI (tarjetas gráficas, de red, controladoras, etc.) se usa lspci. Un ejemplo típico: quieres confirmar que tu flamante tarjeta de vídeo externa es realmente el modelo anunciado, pero no quieres abrir el PC por la garantía. Basta con ejecutar:

lspci

o para más detalle:

lspci -v

y buscar la línea correspondiente a VGA compatible controller o similar, donde verás modelo y fabricante reales tal y como el sistema los detecta. Además, si necesitas información sobre redes, puedes usar recursos para saber qué tarjeta de red tienes y cotejar los datos con lo que muestra el sistema.

Ten en cuenta que en arquitecturas como ARM o en placas tipo Raspberry Pi, el comando lspci a menudo ni siquiera existe o devuelve muy poco, porque muchas de estas máquinas no usan bus PCI tradicional como en x86, sino buses distintos (por ejemplo dispositivos integrados en SoC) que se gestionan de otra forma. Por eso la ausencia de lspci en una Raspberry Pi está más que justificada: simplemente no hay un bus PCI que enumerar.

Dispositivos USB

Si tu tarjeta SD va en un lector USB, resulta muy útil ver qué detecta el sistema en ese bus con lsusb:

lsusb

Ahí aparecerán todos los dispositivos USB conectados, incluyendo lectores de tarjetas, discos externos, hubs… Si además quieres pasar fotos a la tarjeta SD para liberar espacio en otro equipo, combinar esta información con lo que te dan fdisk -l y lsblk te ayudará a identificar perfectamente la SD concreta.

Memoria RAM y dispositivos de memoria

Para echar un vistazo rápido a la memoria principal, el comando free -m te indica cantidad de RAM total, usada, libre y swap en megabytes. Es útil para comprobar si un proceso pesado (como un dd enorme sobre tu SD) está reventando la memoria o si hay espacio de sobra.

Cómo encontrar y entender el punto de montaje de la SD

Mucha gente se frustra cuando intenta encontrar la tarjeta SD desde una aplicación (por ejemplo RetroArch) y no ve una unidad C: o D: como en Windows. En Linux todo cuelga de un único árbol de directorios, y las tarjetas SD o discos USB se montan bajo rutas como /media, /mnt o similares.

Monitorizar copias y clonado de tarjetas SD con `dd` y `pv`

Cuando haces copias sector a sector de tu tarjeta SD, por ejemplo un clon de una Raspberry Pi dañada, es muy habitual usar comandos como:

dd if=/dev/sdb of=/dev/sdc

El problema es que dd no muestra progreso por defecto, así que da la sensación de que se ha colgado, sobre todo en copias de muchos gigas. Tradicionalmente se soluciona lanzando dd en combinación con pv (pipe viewer), que enseña cuánto se ha transferido, velocidad, porcentaje y tiempo estimado.

Pero si ya has lanzado dd y lleva horas copiando, no hace ninguna gracia interrumpirlo solo para ver la barra de progreso. Ahí entra en juego una opción de pv menos conocida: -d permite monitorizar el descriptor de fichero de un proceso en ejecución.

El procedimiento típico sería:

En otra terminal, localizar el PID del proceso dd con ps o similar.
Consultar sus descriptores de fichero en /proc/PID/fd/ con un ls para ver qué descriptor corresponde a la entrada/salida que te interesa (habitualmente 0 es entrada estándar, 1 salida estándar y 2 errores).
Ejecutar pv -d PID indicando el descriptor correspondiente, de forma que pv te muestre el progreso de lectura/escritura del dd que ya está corriendo.

De esta forma puedes ver en tiempo real gigas copiados, tiempo transcurrido, velocidad, porcentaje y ETA sin tener que matar el proceso original, lo cual es perfecto para operaciones largas sobre tarjetas SD grandes.

PCMCIA, tarjetas de memoria y tarjetas SD en sistemas antiguos

En portátiles veteranos y ciertos sistemas embebidos, las tarjetas (incluidas muchas tarjetas de memoria) se gestionan a través de PCMCIA. Aunque hoy está bastante en desuso, sigue siendo relevante en hardware antiguo o industrial donde puedes insertar tarjetas tipo flash o adaptadores SCSI/IDE.

Demonio `cardmgr` y fichero `/var/run/stab`

El demonio cardmgr se encarga de vigilar los sockets PCMCIA, cargar controladores cuando se inserta una tarjeta y ejecutar scripts de configuración de usuario. Registra sus acciones en el log del sistema y señala cambios de estado con pitidos (patrones de tonos que indican si la configuración ha ido bien o mal).

Para cada socket, cardmgr guarda información de dispositivo en /var/run/stab. Un ejemplo de contenido sería:

Socket 0: Adaptec APA-1460 SlimSCSI
0 scsi aha152x_cs 0 sda 8 0
0 scsi aha152x_cs 1 scd0 11 0
Socket 1: Serial or Modem Card
1 serial serial_cs 0 ttyS1 5 65

Cada línea de dispositivo incluye socket, clase de dispositivo, controlador, instancia, nombre de dispositivo y números mayor/menor. Si tu tarjeta SD se ve a través de un adaptador PCMCIA como un disco SCSI, aparecerá ahí como sda, sdb, etc.

Utilidades `cardctl` y `cardinfo`

Para comprobar el estado de un socket PCMCIA y su configuración se usa cardctl. Comandos típicos:

cardctl config: muestra la configuración del socket (voltajes, ventanas de E/S, etc.).
cardctl ident: enseña la información de identificación de la tarjeta insertada.
cardctl suspend y cardctl resume: apagan/reactivan la tarjeta sin descargar módulos.
cardctl reset: intenta resetear y reconfigurar la tarjeta.
cardctl insert y cardctl eject: emulan la inserción o extracción física, incluyendo carga/descarga de controladores y activación/desactivación de dispositivos.

Si estás en un entorno gráfico, cardinfo ofrece una vista gráfica del estado de los sockets PCMCIA y una interfaz para realizar la mayoría de acciones de cardctl. De nuevo, en sistemas antiguos donde la tarjeta SD viaja a través de un adaptador PCMCIA, estas herramientas son claves.

Scripts de configuración y clases de dispositivos

El sistema PCMCIA se basa en clases de dispositivos (red, SCSI, cdrom, disco, serie, memoria, FTL, etc.) que se asocian con scripts en /etc/pcmcia. Por ejemplo:

Red: scripts network y network.opts, que configuran interfaces como eth0, rutas, DNS, etc.
SCSI: script scsi y archivo scsi.opts para discos, cintas y CD-ROM SCSI.
Memoria: scripts memory y memory.opts para tarjetas de memoria simples.
FTL (Flash Translation Layer): ftl_cs y ftl.opts para usar memoria flash como dispositivos de bloques.
ATA/IDE: ide_cs y ide.opts para discos ATA/IDE.

Cada script recibe una “dirección de dispositivo” que identifica esquema, socket, tipo de dispositivo y otros datos útiles (por ejemplo, la MAC en el caso de interfaces de red). A partir de esa dirección, el script decide cómo montar, formatear, configurar IPs o manejar la tarjeta.

Tarjetas de memoria flash, FTL y dispositivos ATA/IDE

En el mundo PCMCIA y similares hay varios tipos de tarjetas de memoria y maneras de presentarlas al sistema, muy relacionadas con cómo se identifican y montan.

Tarjetas de memoria simples y controlador `memory_cs`

El controlador memory_cs se encarga de todas las tarjetas de memoria “simples” y de dar acceso directo al espacio de memoria PCMCIA. Cuando se carga crea tanto dispositivos de carácter como de bloque, que se usan para acceso en bruto o para sistemas de archivos.

Algunas tarjetas antiguas o RAM estática no tienen CIS (Card Information Structure), que es lo que normalmente se usa para identificarlas. En esos casos cardmgr suele asumir que es una tarjeta de memoria básica y carga memory_cs. El tamaño se intenta deducir con heurísticas, pero si falla, puedes especificarlo manualmente al hacer dd o mkfs.

Memoria flash con FTL

Para usar memoria flash como si fuera un disco “normal” se recurre a una capa de traducción llamada FTL (Flash Translation Layer). El proceso típico es:

Formatear la región flash con ftl_format -i /dev/mem0c0c (por ejemplo), operando sobre la interfaz “raw”.
Una vez creado el FTL, tratarla como un dispositivo de bloques y crear el sistema de archivos: mke2fs /dev/ftl0c0, para luego montarla con mount -t ext2 /dev/ftl0c0 /mnt.

Los nombres ftl0c0, ftl0c0p1, etc. codifican número de tarjeta, región y partición. Algunas tarjetas como las Intel Series 100 reservan el primer bloque para información de configuración, y ftl_format ya lo tiene en cuenta para no machacarlo.

También existen tarjetas con formato Microsoft Flash File System (FFS), pero Linux no gestiona actualmente ese formato, así que para usarlas plenamente suele ser necesario reformatearlas.

Discos ATA/IDE a través de PCMCIA

Las unidades ATA/IDE conectadas por PCMCIA se gestionan con ide_cs y el controlador IDE normal del kernel. La dirección de dispositivo que recibe ide.opts incluye esquema, socket, número de serie de la unidad y, opcionalmente, la partición.

Al igual que con SCSI, ide.opts se ejecuta primero para el dispositivo entero y, si se define la variable PARTS, luego para cada partición. Esto permite montar automáticamente ciertas particiones o añadir entradas a /etc/fstab cuando se inserta un disco ATA/IDE o una tarjeta compacta conectada como IDE.

En algunos equipos estas unidades tardan más en inicializarse de lo que la especificación PCMCIA permite. Desde ciertas versiones de los controladores, ide_cs intenta sondear el dispositivo para darle margen de arranque, pero en controladores viejos era necesario jugar con opciones como unreset_delay al cargar el módulo.

Si quieres usar una unidad de CD-ROM ATA/IDE, el kernel debe estar compilado con el soporte correspondiente (CONFIG_BLK_DEV_IDECD), algo que las distribuciones modernas llevan activado por defecto.

Vulnerabilidades de CPU: comprobar Meltdown en Linux

Más allá de discos y tarjetas SD, también te puede interesar ver si tu procesador es vulnerable a fallos conocidos como Meltdown. En 2018 se descubrió esta vulnerabilidad que afectaba a muchos procesadores de distintas arquitecturas, y los kernels recientes incluyen mecanismos para informar del estado.

En Linux, puedes consultar el estado de Meltdown y otras vulnerabilidades de CPU mirando en:

/sys/devices/system/cpu/vulnerabilities/

Dentro encontrarás ficheros como meltdown, spectre_v1, etc. Mostrando el contenido de meltdown con cat verás si el sistema está vulnerable, parcialmente mitigado o completamente protegido, junto con las medidas aplicadas por el kernel.