Cómo detectar el identificador de tu pendrive en Linux sin errores

Cuando vas a grabar una imagen en una memoria USB en Linux, una de las dudas más habituales es saber con total certeza qué dispositivo es el que corresponde a tu pendrive: ¿es /dev/sda, /dev/sdb, /dev/sdc…?. Un error aquí puede significar sobrescribir el disco duro en lugar de la memoria USB, así que conviene ser meticuloso y disponer de varios métodos fiables para identificarlo sin liarla.

En este artículo vamos a ver, de forma detallada y práctica, cómo detectar el identificador de tu pendrive en Linux sin cometer errores, qué herramientas gráficas y de consola puedes usar, cómo aprovechar el UUID para montarlo siempre igual, cómo actuar si el sistema no lo reconoce o da fallos raros, y hasta cómo comprobar si la memoria es falsa o defectuosa y qué hacer con ella.

¿Por qué es tan importante identificar bien tu pendrive?

En Linux, todos los dispositivos de almacenamiento se representan como ficheros especiales en /dev (por ejemplo, /dev/sda, /dev/sdb1, etc.). Cuando escribes una imagen con dd, Ventoy o cualquier herramienta similar, si te equivocas de dispositivo puedes acabar borrando el disco duro en lugar del pendrive. Por eso es fundamental saber con seguridad cuál es el identificador correcto.

Además, cuando trabajas con varios discos o pendrives, puede ocurrir que el orden cambie: hoy tu memoria es /dev/sdb y mañana sea /dev/sdc. Para evitar disgustos, es muy útil aprender a consultar el sistema, identificar el USB recién conectado y, cuando proceda, usar identificadores más estables como el UUID.

Usar herramientas gráficas: el ejemplo de CPU-G

Si prefieres algo visual, existen aplicaciones como CPU-G que no solo muestran información del sistema, sino que también ayudan a identificar los discos y particiones. En una de sus versiones recientes incorpora una pestaña llamada “Discos” donde puedes ver de un vistazo las unidades de almacenamiento conectadas.

En esa pestaña se listan las distintas particiones montadas, indicando para cada una su nombre de dispositivo (por ejemplo, /dev/sdb1), el punto de montaje (por ejemplo, /media/usuario/USB), la capacidad total y el uso actual. De esta forma puedes reconocer fácilmente qué es cada cosa, sobre todo si enchufas el pendrive y ves qué nuevo dispositivo aparece.

Esta información de un solo vistazo resulta muy cómoda: basta con fijarse en la capacidad aproximada de tu pendrive (8 GB, 16 GB, 64 GB, etc.) y su punto de montaje para saber exactamente qué /dev/sdX1 le corresponde. Es especialmente útil si luego quieres usar esa ruta para grabar una ISO desde la terminal o ajustar la configuración de montaje.

CPU-G, además de este apartado de discos, incluye una sección dedicada a la batería del equipo. Ahí muestra datos como el voltaje real, el voltaje de diseño, la carga actual, la carga de diseño y la corriente, todo en tiempo real. Esto es útil para controlar el estado de salud de la batería y prever cuándo será recomendable cambiarla.

En versiones anteriores la aplicación daba errores en equipos de sobremesa sin batería, precisamente al intentar consultar esos datos. En las versiones nuevas se ha corregido el problema: si el equipo no tiene batería, esa pestaña simplemente no se muestra y el programa funciona con normalidad.

También se corrigieron errores en la pestaña de Sistema, relacionados con la forma de obtener la versión de Xorg en algunos equipos, de manera que ahora la página de información del sistema se muestra correctamente en más configuraciones.

En distribuciones como Ubuntu, CPU-G no suele venir en los repositorios oficiales, pero puedes instalarlo fácilmente desde un PPA ejecutando en un terminal comandos como add-apt-repository, apt update y apt install cpu-g. Una vez instalado, la pestaña de discos se convierte en una forma sencilla de asegurar qué dispositivo es tu pendrive antes de hacer nada delicado.

Comprobar si el sistema reconoce la memoria USB

Antes de entrar en detalles, conviene saber si tu Linux detecta realmente la memoria USB. Hay dos escenarios típicos: el sistema ni siquiera ve el dispositivo, o lo detecta pero no puedes acceder a su contenido o montarlo correctamente.

Una primera comprobación muy útil es usar lsusb, un comando pensado para listar todos los dispositivos USB que el sistema ve en ese momento. Simplemente abre un terminal y ejecuta:

lsusb

La salida mostrará líneas con el bus, el número de dispositivo, el ID de fabricante y producto, y una breve descripción. Por ejemplo, podrías ver algo como:

Bus 003 Device 002: ID 13fe:1d00 Kingston Technology Company Inc. DataTraveler 2.0 1GB Flash Drive

Si tu pendrive aparece listado aquí, significa que el sistema lo reconoce como dispositivo USB, aunque todavía no sepamos qué /dev/sdX le corresponde. Si no aparece en absoluto, el problema suele estar en el hardware (puerto USB, cable, memoria dañada) o en niveles muy bajos del sistema.

El comando lsusb sirve no solo para memorias, sino para ratones, teclados, cámaras, adaptadores de red USB, etc.. Admite varias opciones interesantes: con -v obtienes un listado muy detallado de cada dispositivo, con -t ves la topología en forma de árbol, con -d fabricante:producto filtras por un dispositivo específico, y con -s bus:dispositivo te quedas con una única entrada concreta.

Por ejemplo, para mostrar toda la información de un dispositivo concreto puedes hacer:

lsusb -v | less

O para ver la jerarquía de dispositivos USB:

lsusb -t

Y si necesitas el detalle de un dispositivo concreto representado por un archivo en /dev/bus/usb/, puedes ejecutar:

sudo lsusb -D /dev/bus/usb/001/002

Con estas variantes, lsusb se convierte en una herramienta muy útil de diagnóstico: te permite confirmar que tu pendrive está conectado, ver su fabricante y modelo, y descartar de entrada un problema físico grave (si no aparece, algo serio pasa).

Identificar el dispositivo /dev correcto con comandos de sistema

Confirmado que el pendrive está en el sistema, el siguiente paso es averiguar qué nombre de dispositivo en /dev se le ha asignado. En Linux, las unidades de disco suelen aparecer como /dev/sda, /dev/sdb, /dev/sdc, y sus particiones como /dev/sda1, /dev/sdb1, etc..

Consultar blkid para ver dispositivos y sistemas de ficheros

Una forma muy práctica de ver los dispositivos de almacenamiento detectados y su sistema de archivos es usar el comando blkid. Puedes ejecutarlo con permisos de superusuario para obtener toda la información:

sudo blkid

La salida mostrará líneas similares a:

/dev/sda1: UUID="xxxx-xxxx" TYPE="ext4"
/dev/sdb1: UUID="yyyy-yyyy" TYPE="vfat"

Aquí verás, para cada dispositivo de almacenamiento, su identificador único (UUID) y el tipo de sistema de archivos (ext4, vfat, ntfs, etc.). Esto, además de ayudarte a identificar el pendrive por su sistema de archivos o tamaño aproximado, será clave más adelante para montar siempre el mismo dispositivo mediante su UUID.

Si ya sabes cuál es el dispositivo que te interesa (por ejemplo, sospechas que es /dev/sdb1), puedes acotar la consulta directamente:

sudo blkid /dev/sdb1

Con este comando obtienes de golpe el UUID de la partición, que es un identificador estable aunque cambie la ruta /dev/sdX con la que el sistema la vea. Esto se usa mucho en /etc/fstab para evitar problemas cuando el orden de los discos varía.

Usar vol_id como alternativa (cuando esté disponible)

En algunos sistemas más antiguos o con determinadas herramientas instaladas puedes encontrarte con el comando vol_id, que también sirve para mostrar la información de un dispositivo de almacenamiento. Se emplea de forma similar a blkid:

vol_id /dev/sdb1

Esta herramienta suele mostrar de forma bastante clara la etiqueta, el UUID y el tipo de sistema de archivos. Aunque hoy en día blkid es más habitual y estándar, si tienes vol_id instalado, puedes usar indistintamente uno u otro para obtener el UUID del pendrive.

Montar manualmente el pendrive usando su identificador

Cuando ya sabes qué dispositivo corresponde a tu memoria USB (por ejemplo, /dev/sdb1), puedes montarlo manualmente si por algún motivo el entorno de escritorio no lo hace automáticamente. El procedimiento típico es crear un punto de montaje y luego usar mount:

sudo mkdir -p /media/externaldisk
sudo mount /dev/sdb1 /media/externaldisk

La sintaxis general es sencilla: mount dispositivo ruta_donde_montar. A partir de ese momento, podrás acceder al contenido de la memoria USB en el directorio que has elegido (en el ejemplo, /media/externaldisk o /media/usb si prefieres ese nombre).

Este enfoque es muy útil cuando el entorno gráfico no monta automáticamente la memoria, como ocurre a veces en algunos escritorios o en sistemas minimalistas. Eso sí, si te equivocas de dispositivo al montar, normalmente no romperás nada, pero sí puedes montarte por error otra partición y confundirte con los datos.

Detectar la memoria USB en entornos donde no se monta sola

En algunos escritorios, como ciertas configuraciones de KDE, puede pasar que enchufes una llave USB y no se monte automáticamente, mientras que en otros entornos como GNOME sí funciona sin problemas. En estos casos hay que hacer de “detective” para saber qué dispositivo del sistema representa tu pendrive.

Una estrategia consiste en usar las herramientas del paquete sg3-utils, que permiten trabajar con dispositivos SCSI genéricos. Primero instalarías el paquete (por ejemplo, con apt-get install sg3-utils en sistemas basados en Debian/Ubuntu) y luego usarías comandos como sg_map y sg_scan.

El comando sg_map muestra un mapeo entre dispositivos /dev/sgX (genéricos SCSI) y sus equivalentes tipo disco o CD/DVD, por ejemplo:

/dev/sg0 /dev/sda
/dev/sg1 /dev/scd0
/dev/sg2 /dev/scd1

Si ejecutas sg_map antes de insertar el pendrive y vuelves a ejecutarlo después de enchufarlo, puedes ver qué nueva línea ha aparecido. El dispositivo nuevo (por ejemplo, /dev/sg3 /dev/sdb) será tu memoria USB, y ahí sabrás que el disco asociado es /dev/sdb.

Para obtener más información sobre estos dispositivos, sg_scan -i es muy revelador. Muestra detalles como el modelo, el tipo de dispositivo, etc. Podrás ver algo tal que así:

/dev/sg3: Kingston DataTraveler 2.0 PMAP

Esto te indica claramente que ese /dev/sg3 corresponde al pendrive Kingston que acabas de conectar. Combinando esa información con el resultado de sg_map, confirmarás definitivamente que tu memoria se ve como /dev/sdb en el sistema (y normalmente su partición será /dev/sdb1).

Si además quieres validar lo que ha visto el kernel, puedes ejecutar:

dmesg | tail

Tras enchufar la memoria, las últimas líneas de dmesg suelen mostrar mensajes indicando que se ha detectado un nuevo disco , su tamaño en sectores, el estado de protección contra escritura, y, muy importante, la aparición de particiones como sdb1. Algo parecido a:

sdb: sdb1
sd 3:0:0:0: Attached SCSI removable disk

Con esto ya tienes todo: sabes que tu memoria está vista como /dev/sdb1 y puedes montarla con:

sudo mount /dev/sdb1 /media/usb

Este proceso parece un poco de “investigación forense”, pero en situaciones donde el entorno gráfico falla es extremadamente útil para seguir trabajando con tus dispositivos USB sin depender del automontaje.

Aprovechar el UUID del pendrive para montajes sin errores

Una forma muy robusta de identificar tu memoria USB (y cualquier otro dispositivo de almacenamiento) es usar su UUID, el identificador único universal asociado al sistema de ficheros. A diferencia de /dev/sdb1 o /dev/sdc1, que pueden cambiar según el orden de conexión, el UUID permanece constante mientras no reformatees la unidad.

Esto es especialmente interesante si quieres configurar en /etc/fstab un montaje con determinadas opciones por defecto (por ejemplo, para resolver problemas de idioma y acentos al montar pendrives con sistemas de ficheros como vfat o ntfs). En lugar de indicar el dispositivo por su ruta /dev, puedes usar directamente su UUID.

Como hemos visto antes, puedes obtener el UUID con blkid o con vol_id, por ejemplo:

sudo blkid /dev/sdb1

La salida incluirá algo del estilo:

UUID="1234-ABCD" TYPE="vfat"

Con ese valor, puedes editar /etc/fstab y añadir una línea del estilo:

UUID=1234-ABCD /media/usb vfat defaults,uid=1000,gid=1000,utf8 0 0

Así te aseguras de que ese pendrive concreto se monte siempre con las opciones adecuadas, independientemente de qué /dev/sdX le asigne el sistema en cada arranque. Este enfoque se puede aplicar igualmente a discos duros, cámaras, tarjetas SD, etc., siempre que tengan sistema de ficheros.

Qué hacer cuando la memoria USB da errores o parece falsa

No todos los problemas con pendrives se reducen a identificarlos correctamente. A veces el sistema los detecta, pero no puedes copiar muchos datos, aparecen errores de E/S, el tamaño reportado no cuadra con la realidad, o herramientas como f3probe avisan de que algo huele mal.

En el mundo real es bastante común encontrar memorias USB falsificadas que anuncian, por ejemplo, 64 GB en la carcasa, pero internamente solo tienen 16 GB funcionales. El firmware se encarga de engañar al sistema operativo para que éste crea que la capacidad es mucho mayor de la real, y cuando superas el tamaño físico empiezan los errores, la corrupción de datos o los fallos de escritura.

Herramientas como f3 (Fight Flash Fraud) son ideales para detectar estas situaciones. Una de sus utilidades, f3probe, permite probar la unidad, escribir y leer datos y determinar si la memoria es auténtica o está trucada. Al ejecutarla sobre el dispositivo (por ejemplo, f3probe –destructive /dev/sdb), comprobará el espacio y mostrará un informe.

Si la herramienta detecta que el dispositivo es sospechoso, puede mostrar mensajes del tipo: “Bad news: The device `/dev/sda` is a counterfeit of type limbo”, o indicar directamente que el dispositivo está dañado. La clasificación interna “limbo” suele utilizarse cuando f3probe no puede mapear la memoria de forma fiable por errores graves: en la práctica, significa que la unidad es falsa o irrecuperable para un uso de confianza.

En otros casos, f3probe informa de que el dispositivo tiene menos capacidad útil de la que declara. En sus resultados suele aparecer un campo “usable size” que muestra el tamaño real, tanto en gigabytes como en número de bloques. Si, por ejemplo, una memoria dice ser de 64 GB pero f3 indica que solo dispone de 16 GB utilizables, estás ante un pendrive trucado pero potencialmente reutilizable hasta su tamaño real.

Ante este escenario tienes básicamente dos caminos: reclamar la garantía o intentar adaptar la memoria a su tamaño real. Lo ideal es reclamar, sobre todo si la has comprado recientemente y tienes factura; pero si decides quedarte con ella y aprovechar lo que funcione, f3 incluye la herramienta f3fix para ajustar la unidad.

El proceso pasa por usar el valor de bloques indicado por f3probe y ejecutar algo como:

sudo f3fix --last-sec=<numero_de_bloques> /dev/sda

Con esto se reconfigura la unidad para que el sistema operativo solo vea el espacio realmente utilizable. Una vez terminada la operación, es recomendable desconectar y volver a conectar la memoria y luego formatear la partición resultante. A partir de entonces, el sistema la verá con un tamaño menor, pero al menos será coherente con la realidad y reducirá la posibilidad de pérdida de datos por intentar escribir más allá de lo que realmente existe.

Por supuesto, este tipo de operaciones modifican la estructura del pendrive y borran los datos, así que deben hacerse con pleno conocimiento de causa y siempre sobre el dispositivo correcto para no afectar a otros discos del sistema.

Si en lugar de una memoria falsificada estás ante una unidad realmente defectuosa (por ejemplo, una USB que con apenas uso ya da errores graves y f3probe solo muestra sectores dañados), la mejor opción suele ser no fiarse de ella. Aunque a veces puedas forzarla un poco más, usarla para datos importantes es un riesgo innecesario.

En contextos donde aparecen errores de escritura y lectura, el anillo de mensajes del kernel (accesible con dmesg) es muy útil: verás mensajes sobre errores de E/S, desconexiones repentinas, reintentos, etc. Eso ayuda a distinguir si el problema es de hardware (memoria, puerto, cable) o de sistema de archivos (corrupción lógica que quizás se pueda reparar formateando o pasando fsck).

Con todo este conjunto de herramientas (lsusb, blkid, sg3-utils, dmesg, f3probe, f3fix) puedes no solo detectar con precisión el identificador de tu pendrive en Linux, sino también diagnosticar su estado, verificar si es auténtico y tomar decisiones informadas sobre cómo usarlo o si merece la pena reemplazarlo cuanto antes.

Dominar estos comandos y conceptos te permite trabajar con memorias USB en Linux con mucha más seguridad: sabrás siempre qué dispositivo estás tocando, podrás montarlo de forma manual o automática usando su UUID, tendrás recursos para investigar cuando algo no se monta solo y, si una memoria resulta ser falsa o estar medio muerta, tendrás claro qué herramientas usar para confirmarlo y, si procede, exprimir al menos el espacio realmente utilizable sin sorpresas desagradables. Comparte este tutorial para que más personas aprendan a detectar el identificador de pendrive en Linux sin errores.

from Actualidad Gadget https://ift.tt/6zlpt2r
via IFTTT