Páginas

Mostrando entradas con la etiqueta disco. Mostrar todas las entradas
Mostrando entradas con la etiqueta disco. Mostrar todas las entradas

martes, 10 de marzo de 2026

Formatear y montar dispositivo USB exFAT en FreeBSD 14.3

Fuente:

https://docs.freebsd.org/en/books/handbook/filesystems/

En FreeBSD 14.3, el sistema no tiene soporte nativo para exFAT en el kernel. Para el montaje de un disco USB exFAT (/dev/da0 o /dev/da0p1 /dev/da0s1), se necesita utilizar FUSE y el puerto fusefs-exfat.

Instalar los paquetes necesarios

pkg install fusefs-libs fusefs-exfat

pkg info | grep -i exfat
exfat-utils-1.4.0_1    Utilities to create, check, label and dump exFAT filesystem
fusefs-exfat-1.4.0_1   Full-featured exFAT FS implementation as a FUSE module

Cargar el módulo FUSE

kldload fusefs

Para cargar siempre al inicio

sysrc kld_list+="fusefs"

Identificar correctamente el dispositivo

dmesg
da0 at umass-sim0 bus 0 scbus1 target 0 lun 0
da0: <ASMT USB 3.0 TOSATA 0> Fixed Direct Access SPC-4 SCSI device
da0: Serial Number 0000000000A3
da0: 400.000MB/s transfers
da0: 38166MB (78165360 512 byte sectors)
da0: quirks=0x2

Particionar /dev/da0 desde FreeBSD 14.3

Desmontar si está montado (por seguridad)

umount /dev/da0p1 2>/dev/null || true 

Formatear dispositivo /dev/da0

Borrar todo y crear tabla GPT (destructivo)

sudo gpart destroy -F da0
da0 destroyed

gpart create -s gpt da0 
da0 created

Agregar una partición que ocupe todo el disco con el tipo ms-basic-data que Windows/macOS reconocen como exFAT

gpart add -t ms-basic-data -l "MiSSD" da0
da0p1 added

Formatear la partición (da0p1)

mkexfatfs /dev/da0p1
mkexfatfs 1.4.0
Creating... done.
Flushing... done.
File system created successfully.

Crear punto de montaje y montar la particion

mkdir /mnt/usb
mount.exfat /dev/da0p1 /mnt/usb
FUSE exfat 1.4.0 (libfuse2)

Mostrar espacio libre en disco

df -h /mnt/usb 
Filesystem    Size   Used   Avail Capacity  Mounted on
/dev/da0p1     37G   1.6M     37G     0%    /mnt/usb

Listar las particiones

gpart show da0
=>      40  78165280  da0  GPT  (37G)
        40  78165280    1  ms-basic-data  (37G)

El dispositivo real suele ser

/dev/da0p1 (GPT con letra p)
/dev/da0s1 (MBR/slice con letra s)

Es importante desmontar antes de desconectar

umount /mnt/usb
FreeBSD es genial!.

jueves, 26 de febrero de 2026

mount FreeBSD Cifrado ZFS desde liveCD y encontrar partición root

Fuente:

https://klarasystems.com/articles/manipulating-a-pool-from-the-rescue-system/
 mkdir /tmp/mountado
 geli attach /dev/nda0p4
 zpool import -f -R /tmp/montado zroot
 zfs list zroot
 NAME                            USED  AVAIL  REFER  MOUNTPOINT
zroot                            223G   211G    96K  /zroot
zroot/ROOT                      82.9G   211G    96K  none
zroot/ROOT/14.3-RELEASE-p8         8K   211G  21.1G  /
zroot/ROOT/default              82.9G   211G  21.3G  /
zroot/cache                     3.04G   211G    96K  /zroot/cache
zroot/cache/ccache              3.04G   211G  3.04G  /var/cache/ccache
zroot/home                      75.3G   211G    96K  /home
zroot/home/carlos               75.3G   211G  67.4G  /home/carlos
zroot/reserved                  50.0G   261G    96K  /zroot/reserved
zroot/tmp                        320K   211G   180K  /tmp
zroot/usr                       9.89G   211G    96K  /usr
zroot/usr/ports                 6.99G   211G  2.91G  /usr/ports
zroot/usr/src                   2.90G   211G  2.63G  /usr/src
zroot/var                       1.61G   211G    96K  /var
zroot/var/audit                   96K   211G    96K  /var/audit
zroot/var/crash                 1.60G   211G  1.60G  /var/crash
zroot/var/log                   3.11M   211G  2.00M  /var/log
zroot/var/mail                   356K   211G   260K

Propiedad canmount de zroot/ROOT/default

zfs get mountpoint,canmount,mounted zroot/ROOT/default
NAME                PROPERTY    VALUE       SOURCE
zroot/ROOT/default  mountpoint  /           local
zroot/ROOT/default  canmount    noauto      local
zroot/ROOT/default  mounted     yes         -

¿Qué hace canmount=noauto?

La propiedad canmount en ZFS controla si un dataset puede ser montado. Tiene tres valores posibles:

on - El dataset se monta automáticamente cuando es necesario (por ejemplo, al importar el pool o al ejecutar zfs mount -a).

off - El dataset no puede ser montado en absoluto.

noauto - El dataset no se monta automáticamente por operaciones generales del sistema (como zfs mount -a o la importación del pool), pero puede ser montado manualmente con zfs mount. Es un estado intermedio que lo hace "disponible pero no automático".

Montar zroot/ROOT/default con el comando mount

 zfs mount zroot/ROOT/default

Despues de finalizar los cambios exportar el zpool

zpool export zroot

Reiniciar y arrancar desde el disco duro NVMe (nda0)

 shutdown -r now
FreeBSD es genial!.

jueves, 19 de febrero de 2026

Migración de SSD a disco de mayor capacidad en FreeBSD 14.3 send receive vía USB

Estado actual del sistema

zpool status
zpool list 
zpool list -t all

Identificar discos

geom disk list
camcomtrol devlist

Anotar el disco actual (ada0) y el nuevo disco USB (da0)


Limpiar el disco nuevo completamente

gpart destroy -F da0
dd -if=/dev/zero of=/dev/da0 bs=1M count=100

Crear tabla de particiones GPT

gpart create -s gpt da0

Partición de arranque EFI (si el sistema usa UEFI)

gpart add -t efi -s 260M -l efiboot-new da0

Partición de arranque BIOS/GPT (para compatibilidad legacy)

gpart add -t freebsd-boot -s 512k -l gptboot-new da0

Partición swap

gpart add -t freebsd-swap -s 8G -a 1M -l swap0 da0

Particion ZFS (el resto del disco)

gpart add -t freebsd-zfs -a 1M -l zroot-new da0

Para sistemas UEFI


Montar partición EFI del disco nuevo

newfs_msdos -F 32 -c 1 /dev/da0p1
mount -t msdosfs /dev/da0p1 /mnt

Copiar EFI loader desde el actual disco

mkdir -p /mnt/EFI/BOOT
cp -r /boot/efi/EFI/BOOT /mnt/EFI/

umount /mnt

Crear pool temporal en el nuevo disco

Crear pool temporal con nombre diferente para evitar conflictos
zpool create -o altroot=/mnt \
             -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O acltype=posix \
             -m none \
             zroot-new /dev/da0p3

Verificar

zpool status zroot-new

Listar todos los datasets a migrar

zfs list -H -o name -t filesystem,volume

Tomar snapshot recursivo de todo el pool (Shell zsh)

sudo zfs snapshot -r zroot@migracion

Verificar snapshot creado

zfs list -t snapshot -o name | grep "$migracion" 
zroot@migracion
zroot/ROOT@migracion
zroot/ROOT/14.3-RELEASE-filebrowser-tailscale-serve-certs-https@migracion
zroot/ROOT/14.3-RELEASE_2026-02-14_193200@migracion
zroot/ROOT/default@2026-02-14-19:32:00-0
zroot/ROOT/default@2026-02-17-17:48:09-0
zroot/ROOT/default@migracion
zroot/home@migracion
zroot/home/carlos@migracion
zroot/tmp@migracion
zroot/usr@migracion
zroot/usr/ports@migracion
zroot/usr/src@migracion
zroot/var@migracion
zroot/var/audit@migracion
zroot/var/crash@migracion
zroot/var/log@migracion
zroot/var/mail@migracion
zroot/var/tmp@migracion

Enviar snapshot raíz primero

zfs send -Lec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Enviar recursivamente todos los datasets hijos

zfs send -RLec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Banderas (flags)

-R Recursivo (todos los datasets hijos)
-L Incluye large blocks
-e Embed data (bloques pequeños inline)
-c Comprime el stream
-F En receive: fuerza rollback si es necesario
-u No monta los datasets al recibirlos
-v Verbose

Comprobar la replicación


Comparar conjuntos de datos entre pools

zfs list -r zroot
zfs list -r zroot-new

Verificar propiedades

zfs get all zroot
zfs get all zroot-new

Cantidad de instantáneas

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zroot-new | wc -l

Configurar bootfs en el nuevo pool

zpool set bootfs=zroot-new/ROOT/default zroot-new

Verificar

zpool get bootfs zroot-new

Ajustar cachefile y otros parámetros del pool

zpool set cachefile=/boot/zfs/zpool.cache zroot-new

Ver propiedades del pool original para replicarlas

zpool get all zroot

Montar el dataset raíz del nuevo disco

zfs set mountpoint=/mnt zroot-new/ROOT/default
zfs mount zroot-new/ROOT/default

Verificar /boot/loader.conf

cat /mnt/boot/loader.conf

Debe contener algo como:

zfs_load="YES"
vfs.root.mountfrom="zfs:zroot/ROOT/default"

Si el nombre del pool cambió, actualizar:

sed -i '' 's/zroot-new/zroot/g' /mnt/boot/loader.conf

También verificar /etc/fstab (en ZFS puro suele estar sin referencias a ada0)

cat /mnt/etc/fstab

Cambiar el disco y primer arranque


Apagar el sistema

shutdown -p now

Desconectar el disco viejo Conectar el nuevo disco en el slot interno (ya no como USB) Comprobar en BIOS/UEFI que el nuevo disco sea el primero en el orden de arranque Arrancar

Verificación después del arranque


Comprobar salud del pool

zpool status
zpool list

Verificar que todos los datasets montaron

zfs list -t filesystem

Verificar espacio disponible (debe reflejar el disco nuevo mayor)

df -h

Verificar que el sistema arrancó desde el disco correcto

geom disk list
camcontrol devlist

Limpiar snapshots de migración

zfs destroy -r zroot@migracion

Problemas y posibles soluciones después del primer arranque


Renombrar zpool zroot-new a zroot

zpool import -f zroot-new zroot

Error

zpool export zroot-new Cannot unmount /

Es el error clásico: el dataset raíz (/) está montado desde zroot-new, así que ZFS no puede desmontarlo en caliente

Solución Desde loader prompt o LiveCD


Desde el LiveCD

zpool import -f zroot-new zroot
zpool set bootfs=zroot/ROOT/default zroot
zpool export zroot

zpool import -f zroot-new zroot
   zpool set bootfs=zroot/ROOT/default zroot
   zpool export zroot hecho.

Reiniciar

shutdown -r now

FreeBSD al arrancar y no encontrar zroot buscará pools disponibles. Si el disco nuevo ya está interno, lo encontrará como zroot-new y podrás importarlo con el nombre correcto.

Después de reiniciar sin el LiveCD el sistema arranca desde el nuevo disco duro.

Estos dos errores son normales y esperables en este proceso.

1. swapon: /dev/da0p3: No such file or directory, 
2. Import of zpool cache /etc/zfs/zpool.cache failed

El archivo /etc/fstab del sistema nuevo todavía referencia el dispositivo del disco USB (da0) que ya no existe. Ahora el disco está interno, probablemente como ada0 o nvme0ns1.

Montar el sistema de ficheros rw

mount -u -o rw /

Averiguar cómo se llama el disco ahora geom disk list o camcontrol devlist.

geom disk list                                    
Geom name: ada0
Providers:
1. Name: ada0
   Mediasize: 250059350016 (233G)
   Sectorsize: 512
   Mode: r3w3e7
   descr: WDC WDS250G2B0A-00SM50
   lunid: 5001b448b8a2a91f
   ident: 192686806761
   rotationrate: 0
   fwsectors: 63
   fwheads: 16

Cambiar la línea de swap, por ejemplo

/dev/da0p3  none   swap  sw   0   0
 por
/dev/ada0p3  none   swap  sw   0   0

Mejor aún, usar la etiqueta (label) GPT que es independiente del nombre del dispositivo

gpart show -l ada0
=>       40  488397088  ada0  GPT  (233G)
         40     532480     1  efiboot0  (260M)
     532520       1024     2  gptboot0  (512K)
     533544        984        - free -  (492K)
     534528   16777216     3  swap0  (8.0G)
   17311744  471085056     4  zroot-new  (225G)
  488396800        328        - free -  (164K)
ls /dev/gpt/
efiboot0 gptboot0 swap0

En el archivo /etc/fstab usar la etiqueta en lugar del dispositivo

...
/dev/gpt/swap0	  none	  swap	  sw	 0	0
...

Error 2

Import of zpool cache /etc/zfs/zpool.cache failed

El zpool.cache fue generado cuando el pool se llamaba zroot-new y estaba en da0. Ahora el pool se llama zroot y el dispositivo cambió. El caché está obsoleto.

Sencillamente borrarlo, ZFS lo regenera automáticamente

rm /etc/zfs/zpool.cache

Antes de reiniciar para verificar el nombre correcto del dispositivo

swapinfo -h
Device              Size     Used    Avail Capacity
/dev/gpt/swap0      8.0G       0B     8.0G     0%

Si el sistema arrancó pero con errores no críticos Ambos errores no impiden el funcionamiento del sistema. El swap simplemente no está activo hasta que corrijas el fstab, y el zpool.cache se regenera solo. Si llegaste al prompt de login, la migración fue exitosa.

Reiniciar

shutdown -r now

Error 3.

Can't open /dev/gpt/efiboot0

Ese error indica que el bootloader está buscando la partición EFI por su label GPT (efiboot0) pero no la encuentra, probablemente porque el label en el disco nuevo es diferente o no se asignó correctamente

ls /dev/gpt
efiboot0 gptboot0 swap0

Montar el sistema de ficheros rw

mount -u -o rw /

Solución. Renombrar el label al esperado

...
/dev/gpt/efiboot0    /boot/efi	  msdosfs    rw	   2	2
...

Corregir el label

gpart modify -i 1 -l efiboot0 ada0

Si la partición EFI estaba vacía, reinstalar loader

newfs_msdos -F 32 -c 1 /dev/ada0p1
mount -t msdosfs /dev/ada0p1 /mnt
mkdir -p /mnt/EFI/BOOT
cp /boot/loader.efi /mnt/EFI/BOOT/BOOTX64.EFI

umount /mnt

 

FreeBSD es genial!.

martes, 23 de septiembre de 2025

Supervisar Disco con smartmontools en FreeBSD 14.2

Configurar smartmontools en FreeBSD 14.2 para supervisar el estado de discos SSD y/o nvme y enviar correos mediante DMA usando los servidores de Gmail


Instalar smartmontools

 pkg install smartmontools

Habilitar el servicio smartd para que inicie al arrancar el sistema

 sysrc smartd_enable="YES"

Iniciar servicio

 service smartd start

Identificar el disco SSD

Primero listar los discos disponibles

 smartctl --scan

/dev/da0 -d sat # /dev/da0 [SAT], ATA device
/dev/nvme0 -d nvme # /dev/nvme0, NVMe device

Configurar smartd para monitorear el SSD

Editar el archivo de configuración

 cp /usr/local/etc/smartd.conf.sample /usr/local/etc/smartd.conf

Agregar esta línea para monitorear el SSD y enviar alertas por correo electrónico

 /dev/da0 -d sat -H -l error -l selftest -f -m tucorreo@protonmail.com
Explicación
 -H Comprueba el estado general SMART
 -l error Revisa el log de errores
 -l selftest Revisa el log de autopruebas
 -f Revisa fallos futuros
 -m Dirección de correo para notificaciones

Comprobar que el disco habla con el disco /dev/da0

# smartctl -d sat -a /dev/da0
smartctl 7.5 2025-04-30 r5714 [FreeBSD 14.3-RELEASE-p2 amd64] (local build)
Copyright (C) 2002-25, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     Toshiba 2.5" HDD MQ04UBD...
Device Model:     TOSHIBA MQ04UBD200
Serial Number:    Y0JKT0QOT
LU WWN Device Id: 0 000000 000000000
Firmware Version: JT001U
User Capacity:    2,000,398,934,016 bytes [2.00 TB]
Sector Sizes:     512 bytes logical, 4096 bytes physical
Rotation Rate:    5400 rpm
Form Factor:      2.5 inches
Zoned Device:     Device managed zones
Device is:        In smartctl database 7.5/5706
ATA Version is:   ACS-3 T13/2161-D revision 5
SATA Version is:  SATA 3.3, 3.0 Gb/s (current: 3.0 Gb/s)
Local Time is:    Tue Sep 23 15:03:29 2025 CEST
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
...

Configurar DMA para enviar correos por Gmail


https://gnulinuxcodigo.blogspot.com/2024/12/freebsd-dma-dragonfly-mail-agent.html

FreeBSD 14.2 usa DMA como agente de correo por defecto.

Probando el envío de correos

echo "Prueba de correo desde FreeBSD" | mail -s "Prueba" tucorreo@protonmail.com

o, otra forma para lograr el mismo resultado

 cat >> mensaje.txt<<EOF
Esto es una prueba de correo desde usando el agente DMA.
EOF

 mail -v -s prueba tucorreo@protonmail.com < mensaje.txt

Verificar el log de DMA

 tail -f /var/log/maillog
...
Sep 19 08:59:00 tormenta dma[dd67.2b6bad248050][86005]: trying remote delivery to smtp.gmail.com [74.125.133.109] pref 0
Sep 19 08:59:00 tormenta dma[dd67.2b6bad248050][86005]: using SMTP authentication for user tucorreo@gmail.com
Sep 19 08:59:01 tormenta dma[dd67.2b6bad248050][86005]:  delivery successful

Para que smartmontools vigile un disco NVMe

Averiguar el nodo del NVMe

 nvmecontrol devlist
 nvme0: CT500P2SSD8
    nvme0ns1 (476940MB)

 ls -l /dev/nvme*
crw-------  1 root wheel 0x33 Sep 20 15:41 /dev/nvme0
crw-------  1 root wheel 0x40 Sep 20 15:41 /dev/nvme0ns1

Comprobar que smartctl habla con el NVMe

 smartctl -d nvme /dev/nvme0ns1 -i

smartctl 7.5 2025-04-30 r5714 [FreeBSD 14.2-RELEASE-p1 amd64] (local build)
Copyright (C) 2002-25, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Number:                       CT500P2SSD8
Serial Number:                      2216E629B1D4
Firmware Version:                   P2CR048
PCI Vendor/Subsystem ID:            0xc0a9
IEEE OUI Identifier:                0x00a075
Total NVM Capacity:                 500,107,862,016 [500 GB]
Unallocated NVM Capacity:           0
Controller ID:                      1
NVMe Version:                       1.3
Number of Namespaces:               1
Namespace 1 Size/Capacity:          500,107,862,016 [500 GB]
Namespace 1 Formatted LBA Size:     512
Namespace 1 IEEE EUI-64:            00a075 61b0000125
Local Time is:                      Fri Sep 19 09:36:00 2025 CEST

Mostrará modelo, serial, versión NVMe, etc.

Crear una entrada específica para el NVMe en /usr/local/etc/smartd.conf

 /dev/nvme0ns1 -d nvme -H -l error -l selftest -f -m tucorreo@protonmail.com -M test

Explicación

 -d nvme - le dice a smartd que use el backend NVMe
 -H - atributo "Health"
 -l error - log de errores
 -l selftest - log de autopruebas 
 -f - predicción de fallos
 -m - destinatario
 -M test - envía un correo de bienvenida al arrancar smartd (útil para verificar).

Contenido del fichero /usr/local/etc/smartd.conf

 sed -e '/^[ ]*#/d' -e '/^$/d' /usr/local/etc/smartd.conf
 
/dev/da0 -d sat -H -l error -l selftest -f -m tucorreo@protonmail.com
/dev/nvme0ns1 -d nvme -H -l error -l selftest -f -m tucorreo@protonmail.com

service smartd restart

En /var/log/daemon.log se verá

 tail -f /var/log/daemon.log 
...
Sep 19 09:55:34 tormenta smartd[87644]: Device: /dev/nvme0, opened
Sep 19 09:55:34 tormenta smartd[87644]: Device: /dev/nvme0, CT500P3SSD8, S/N:2240E6733488, FW:P9CR30A
Sep 19 09:55:34 tormenta smartd[87644]: Device: /dev/nvme0, is SMART capable. Adding to "monitor" list.
Sep 19 09:55:34 tormenta smartd[87644]: Monitoring 1 ATA/SATA, 0 SCSI/SAS and 1 NVMe devices

Arrancar o reiniciar el demonio

 service smartd restart

En /var/log/daemon.log se verá la línea "Device:/dev/nvme0ns1,opened" y si se incluye -M test, un correo inmediato.

Crear el helper de notificación

En FreeBSD el paquete smartmontools no instala helper de notificación; hay que crearlo.

Crear el script que smartd invoca y asegurarse de que llame a /usr/bin/mail smartd siempre ejecuta el script con sh, por lo que la shell personal (csh) no afecta en absoluto.

cat > /usr/local/sbin/smartdnotify-mailout <<'EOF'
#!/bin/sh
# SMARTD_ADDRESS direccion destino
# SMARTD_SUBJECT asunto
# SMARTD_MESSAGE cuerpo del mensaje
exec /usr/bin/mail -s "$SMARTD_SUBJECT" "$SMARTD_ADDRESS" <<EOF_MAIL
$SMARTD_MESSAGE
EOF_MAIL
EOF

Contenido del archivo /usr/local/sbin/smartdnotify-mailout

#!/bin/sh
# SMARTD_ADDRESS direccion destino
# SMARTD_SUBJECT asunto
# SMARTD_MESSAGE cuerpo del mensaje
exec /usr/bin/mail -s "$SMARTD_SUBJECT" "$SMARTD_ADDRESS" <<EOF
$SMARTD_MESSAGE
EOF

Hay que darle permisos de ejecución

chmod 755 /usr/local/sbin/smartdnotify-mailout

Verificar que smartd lo va a usar

grep ^mailout /usr/local/etc/smartd.conf

Si tuviera una línea como

MAILER /usr/local/libexec/smartdnotify

comentarla o borrarla para que smartd use el helper estándar.

Simular las variables que smartd exporta (shell csh)

setenv SMARTD_ADDRESS "tucorreo@protonmail.com"
setenv SMARTD_SUBJECT "SMART alerta"
setenv SMARTD_MESSAGE "Problema en disco detectado"

En csh las variables anteriores sólo existen en esa shell; Cuando smartd arranca como servicio, no las ve.

La solución es asegurarse de que smartd exporte esas variables él mismo

Forzar un correo de prueba

service smartd restart

si smartd ya está corriendo

pkill -USR1 smartd

Verificar la entrega

tail -f /var/log/maillog
...
Sep 21 16:14:42 tormenta dma[8210.32674c848000][49835]: trying remote delivery to smtp.gmail.com [64.233.184.109] pref 0
Sep 21 16:14:43 tormenta dma[f8210.32674c848000][49835]: using SMTP authentication for user tucorreo@gmail.com
Sep 21 16:14:43 tormenta dma[f820e.57c02fa48000][49825]: <tucorreo@protonmail.com> delivery successful
Sep 21 16:14:44 tormenta dma[f8210.32674c848000][49835]: <tucorreo@protonmail.com> delivery successful

El mensaje "SMART daemon startup" llegará a la bandeja de entrada

Comprobaciones

smartd invoca realmente el helper?

Verlo en tiempo real

service smartd stop
smartd -d -c /usr/local/etc/smartd.conf

En otra terminal forzar el envío

pkill -USR1 smartd

En la primera terminal debe aparecer

Executing "/usr/local/sbin/smartdnotify-mailout"

Si no aparece el problema es parseo de smartd.conf (espacio, salto de línea, falta -M test, etc.)

Borrar las variables del shell (no hacen falta), csh

unsetenv SMARTD_SUBJECT SMARTD_MESSAGE SMARTD_ADDRESS

No se necesita setenv en ningún fichero. Reiniciar smartd con service smartd restart y el demonio exportará las variables antes de llamar al helper.

Ahora ya se puede quitar -M test de ambas líneas cuando ya no se desee recibir el correo de bienvenida cada vez que reinicie smartd

-M test sólo fuerza el envío de un aviso al arrancar el demonio. No afecta a las alertas reales; esas se mandan siempre cuando ocurran.

A partir de ahora no se recibirá el mail "SMART daemon startup". Sí recibirás cualquier alerta real cuando smartd la detecte.

Verificar el estado actual y forzar una alerta en cualquier momento sin reiniciar el servicio.

Lectura rápida en caliente (sin detener smartd)

 smartctl -d nvme -A /dev/nvme0ns1
 smartctl -d nvme -H /dev/nvme0ns1
 smartctl -d nvme -l /dev/nvme0
 smartctl -d sat -A /dev/da0
 smartctl -d sat -H  /dev/da0
 smartctl -d sat -l error /dev/da0

Forzar un evento para comprobar que las alertas siguen funcionando

 kill -USR1 $(pgrep smartd) # sh
 kill -USR1 `pgrep smartd` # csh

Ver que está vigilando smartd en este momento

 tail -f /var/log/daemon.log | grep smartd

Cada 30 minutos, que es el valor por defecto, vuelve a comprobar y registrará cualquier cambio.

Mensajes recibidos en mi correo (uno por cada disco)


Primer mensaje

This message was generated by the smartd daemon running on:

   host name:  tormenta
   DNS domain: [Empty]

The following warning/error was logged by the smartd daemon:

TEST EMAIL from smartd for device: /dev/da0 [SAT]

Device info:
TOSHIBA MQ04UBD200, S/N:Y0JKT0QOT, WWN:0-000000-000000000, FW:JT001U, 2.00 TB

For details see host's SYSLOG.

Segundo mensaje

This message was generated by the smartd daemon running on:

   host name:  tormenta
   DNS domain: [Empty]

The following warning/error was logged by the smartd daemon:

TEST EMAIL from smartd for device: /dev/nvme0ns1

Device info:
CT500P3SSD8, S/N:2240E6733488, FW:P9CR30A, NSID:1

For details see host's SYSLOG.
FreeBSD es genial!.

viernes, 4 de julio de 2025

Borrar Disco FreeBSD 14.2

Borrar disco

Arranque el dispositivo objetivo desde el medio de instalación. En el menú de arranque de FreeBSD, presione s para seleccionar el modo de usuario único de arranque.

Use geom para identificar discos

 geom disk list
Geom name: nda0
Providers:
1. Name: nda0
...

Use dd para sobrescribir todo el disco con ceros:

 dd if=/dev/zero of=/dev/nda0 bs=4M conv=fsync oflag=direct status=progress

Esta operación tomará un poco de tiempo. En mi nvme 500G, por ejemplo, tardó aproximadamente 14 minutos en borrar completamente el disco. Sea paciente.

Instalación

Después de que termine la operación de borrado, ingrese el comando reboot para volver al Menú de Arranque. Presione <Enter> para iniciar el instalador.

 reboot
En la pantalla de bienvenida, elija Install.
FreeBSD es genial!.

martes, 25 de marzo de 2025

Crear Particiones en Disco Duro USB Sistema de Archivos ZFS con gpart en FreeBSD 14

# Identificar el disco USB

Primero, verifica el nombre del disco USB conectado:

 gpart show

O también:

 camcontrol devlist

El disco USB generalmente aparecerá como daX (por ejemplo: da0).


# Eliminar particiones existentes (si es necesario)

Si el disco ya tiene particiones, puedes limpiarlo con:

 gpart destroy -F /dev/daX

(Reemplaza daX con tu dispositivo, como da0).


# Crear tabla de particiones (GPT)

Crea una tabla de particiones GPT en el disco:

 gpart create -s GPT /dev/daX

# Crear partición para ZFS

Crea una partición que ocupe todo el disco (o el espacio deseado):

 gpart add -t freebsd-zfs -a 1M -l ZFSBACKUP /dev/daX

-t freebsd-zfs: Tipo de partición para ZFS.
-a 1M: Alineación a 1 MiB (mejor rendimiento en discos modernos).
-l ZFSBACKUP`: Etiqueta de la partición (opcional pero útil para identificación).

# Verificar la partición creada

 gpart show /dev/daX

Deberías ver algo como:

=>   40  625142368  da0  GPT  (298G)
     40  625142368    1  freebsd-zfs  (298G)  [ZFSBACKUP]

# Crear el pool ZFS en la partición

Ahora crea un pool ZFS en la partición (no en el disco completo, `/dev/daX`, sino en la partición, /dev/daXp1 o /dev/gpt/ZFSBACKUP si usaste etiqueta):

 zpool create -f zbackup /dev/gpt/ZFSBACKUP

- zbackup: Nombre del pool (cámbialo si lo prefieres).
- f Fuerza la creación si hay restos de particiones anteriores.

# Configurar propiedades del pool (opcional)

Para mejorar la compatibilidad y rendimiento:

 zfs set mountpoint=none zbackup
 zpool set autoexpand=on zbackup
 zpool set listsnapshots=on zbackup

# Habilitar compresión (recomendado)

 zfs set compression=lz4 zbackup

# Verificar el pool ZFS

 zpool status

zfs list

# Enviar instantáneas (snapshots) al disco USB

Desde el sistema origen (donde está el ZFS con los datos), usa zfs send y zfs receive:


# En el sistema origen:

zfs snapshot pool/dataset@backup1
zfs send pool/dataset@backup1 | zfs receive zbackup/dataset

Si el disco está conectado a otro sistema, usa ssh:

 zfs send pool/dataset@backup1 | ssh user@host "zfs receive zbackup/dataset"

# Notas importantes:

USB y ZFS: ZFS en discos USB puede ser lento y no es ideal para uso intensivo. Se recomienda usar discos con conexión SATA o NVMe si es posible.
- Montaje automático: Si deseas que el pool se monte al conectar el disco, agrega zfs_enable="YES" en /etc/rc.conf.
- Exportar el pool: Antes de desconectar el disco, ejecuta:

 zpool export zbackup

Esto asegura que el pool se cierre correctamente y se liberen todos los recursos asociados. Luego, el disco puede ser desconectado de forma segura.

¡Listo! Ahora tienes un disco USB con ZFS listo para recibir snapshots de FreeBSD.

 

FreeBSD es genial!.

domingo, 4 de diciembre de 2022

NFS Sistema de Archivos en Red FreeBSD ZFS

NFS Sistema de Archivos en Red FreeBSD
Montaje de Sistema de Archivos NFS Usando Autofs
Replicar, Recuperar Pool Root ZFS FreeBSD

NFS FreeBSD ZFS utilizando /etc/fstab

NFS Network File System es un protocolo de nivel de aplicación, según el modelo OSI, que permite compartir, en una red local, directorios y particiones entre sistemas tipo Unix como si se tratara de locales. NFS está incluido por defecto en los sistemas operativos UNIX.

La utilidad nfsd se ejecuta en un equipo servidor para atender las peticiones NFS de los equipos de las máquinas cliente. Para que una máquina funcione como servidor, debe ejecutarse al menos un nfsd.

Configurar el servidor NFS

Acceder al servidor a través de SSH con clave pública


% ssh carlos@tormenta
% su
Password:
root@tormenta:/home/carlos #

Active el soporte del servidor NFS con las siguientes opciones de rc.conf. Aunque no todas opciones son estrictamente necesarias para todos los entornos, activarlas todas garantiza el mayor rango de compatibilidad con NFS y un rendimiento adecuado.


sysrc nfs_server_enable="YES"
sysrc rpcbind_enable="YES"
sysrc mountd_enable="YES"
sysrc rpc_lockd_enable="YES"
sysrc rpc_statd_enable="YES"

Archivo /etc/rc.conf


...
nfs_server_enable="YES"
rpcbind_enable="YES"
mountd_enable="YES"
rpc_statd_enable="YES"
rpc_lockd_enable="YES"
...

Reiniciar el sistema.

El demonio rpcbind mapea las llamadas a procedimientos remotos (RPC) en direcciones de red locales. Cada cliente NFS pregunta al demonio rpcbind del servidor dónde puede encontrar un demonio mountd al que conectarse.

El demonio mountd escucha los puertos de alta numeración para las peticiones de montaje de los clientes. Al activar el servidor NFS también se inicia nfsd, que se encarga de la solicitud de archivos. NFS asegura el bloqueo de archivos con rpc.lockd, y rpc.statd monitoriza los clientes NFS para que el servidor NFS pueda liberar recursos cuando el host desaparezca.

Una vez que el NFS esté funcionando, la salida de sockstat mostrará rpc.lockd, rpc.statd, nfsd, mountd, y rpcbind escuchando.

El servidor NFS debería auto negociar las conexiones de forma transparente. También puede ajustar su servidor NFS nfsd para que se adapte mejor a sus clientes y esto se hace con nfsd al inicio, con la opción (/etc/rc.conf) opción nfs_server_flags.

Comprobar que los servicios están activos


# service -e | grep rpcbind
/etc/rc.d/rpcbind
# service -e | grep mountd
/etc/rc.d/mountd
# service -e | grep lockd
/etc/rc.d/lockd
# service -e | grep statd
/etc/rc.d/statd

NFS puede funcionar sobre TCP o UDP que es el protocolo de transporte tradicional de NFS.

Cuando un servidor tiene varias direcciones IP es una buena práctica indicar al servidor NFS que utilice sólo una dirección con -h y la IP del servidor.

Que NFS utilice los protocolos de transporte UDP y TCP y se enlace a la dirección IP 192.168.88.160


nfs_server_flags="nfsd -u -t -h 192.168.88.160"

Configurar NFS Exports

Determinar que puede compartir o exportar el servidor.

FreeBSD le permite configurar las exportaciones a través de:

1. Fichero /etc/exports

2. Un servidor basado en ZFS, a través de la propiedad sharenfs de cada conjunto de datos. El servidor creará el archivo de exportaciones ZFS /etc/zfs/exports en base a estas propiedades. Ambos tienen el mismo formato pero no es buena práctica usar ambos métodos al mismo tiempo. Si utiliza el método ZFS nunca edite /etc/zfs/exports manualmente.

Independientemente del método elegido /etc/exports debe existir

Crear /etc/exports


# touch /etc/exports

NFS a través de /etc/exports

Configurar una exportación

Cada entrada del exports tiene hasta tres partes la primera obligatoria


1. Directorios o particiones a exportar
2. Opciones sobre esa exportación
3. Clientes que pueden conectarse

Dispositivo de disco y clientes sólo pueden tener una línea en el archivo de exportación. De modo que si, p.e., /var/log y /var/mail están en la misma partición, para exportar a un cliente en particular, ambos dos deben aparecer en la misma línea. No puede exportar /var/log y /var/mail a un cliente con permisos diferentes.

Tampoco tiene que exportar todo el dispositivo de disco; puede exportar un directorio dentro de una partición. Si las particiones /var y /var/mail están separadas, la exportación de /var no exporta automáticamnet /var/mail

Esta línea en /etc/exports exporta el directorio /home/mycloud a todos los hosts, no tiene opciones ni restricciones de host


/usr/home/mycloud

Una vez editado el archivo /etc/exports:


# service mountd reload

En NFSv2 y NFSv3 los usuarios son identificados por UID, por ejemplo, en mi portátil el usuario carlos tiene el UID 1001. En el servidor NFS carlos también tiene el UID 1001. Los mismos privilegios en el servidor y en el portátil.

En una red pequeña se puede sincronizar /etc/master.passwd en sus sistemas o asignar el mismo UID.

Si desea que todas las peticiones desde root en un cliente se ejecuten como el usuario nfsroot (uid=10000) en el servidor. Utilizando cuidadosamente los grupos, puede permitir que este usuario tenga un acceso limitado a los archivos.

La opción maproot se usa para asignar root a otro usuario. Por ejemplo, asignar el UID 0 (root) en el cliente, al UID 10000 en el servidor


/usr/home/mycloud   -maproot=10000

Exportando múltiples directorios

Todos los directorios en la misma línea de /etc/exports separados por espacio


/var/log /usr/src/ /usr/obj -maproot=carlos

Los clientes pueden montar cualquiera de estos directorios y las peticiones de root se asignan al usuario carlos

Restricción de clientes

Sólo los clientes listados prodrán acceder a la exportación NFS.


/var/log /usr/src/ /usr/obj -maproot=carlos 192.168.88.100 192.168.88.51

Permitir que cualquier cliente con una dirección IP que empiece en 192.168.88 acceda a los recursos compartidos del servidor NFS.


/var/log /usr/src/ /usr/obj -maproot=carlos -network 192.168.88 -mask 255.255.255.0

El cliente NFS de la dirección IP 192.168.88.101 puede montar la totalidad de /usr y puede hacerlo como root


/var/log /usr/src/ /usr/obj -maproot=carlos 192.168.88.100
/usr -maproot=0 192.168.88.101

NFS a través de ZFS

sharenfs es la propiedad utilizada para activar, desactivar y configurar exportaciones NFS. Se establece en on para compartir globalmente un conjunto de datos y todos sus decendientes.

Este conjunto de datos o cualquiera de sus hijos puede ser montado por cualquier persona, sin restricciones y sin opciones, a menos que tenga control de acceso, como un cortafuegos. Crear un conjunto de datos con la propiedad canmount=off; esta propiedad controla si un conjunto de datos puede ser montado o no. Es lo que querrás hacer si no quieres romper los entornos de arranque (Boot Environments).


# zfs create -o canmount=off zroot/usr/backup
# zfs get mounted zroot/usr/backup
NAME              PROPERTY  VALUE    SOURCE
zroot/usr/backup  mounted   no       -

Ahora puede crear un conjunto de datos separados.


# zfs create zroot/usr/backup/nfsshare
# chown carlos:carlos zroot/usr/backup/nfsshare

Crear el dataset poolrecovery que será utilizado, posteriormente, para duplicar 
un sistema completo FreeBSD ZFS
# zfs create zroot/usr/backup/poolrecovery

Empezar a compartir sharenfs=on


# zfs set sharenfs=on zroot/usr/backup/nfsshare
# zfs set sharenfs=on zroot/usr/backup/poolrecovery

Para dejar de compartir el conjunto de datos, se establece sharenfs en off


# zfs set sharenfs=off zroot/dellhome

Establecer un usuario maproot y restringir los clientes a la red local


# zfs set sharenfs="-maproot=0 192.168.88.51" zroot/usr/backup/poolrecovery
# zfs set sharenfs="-network 192.168.88.0/24 -maproot=carlos" zroot/usr/backup/nfsshare

El uso de ZFS es menos flexible para la gestión de exportaciones NFS porque todos los hosts permitidos obtienen las mismas opciones.

ZFS crea automáticamnet el Fichero /etc/exports


cat /etc/zfs/exports
# !!! DO NOT EDIT THIS FILE MANUALLY !!!

/usr/backup/nfsshare    -network 192.168.88.0/24 -maproot=carlos
/usr/backup/poolrecovery     -maproot=0 192.168.88.51

Mapeos de host a IP
...
192.168.88.160          solaris
192.168.88.51           tormenta
...

habilitar el cliente NFS


Mapeos de host a IP
...
192.168.88.51           tormenta
192.168.88.160          solaris
...

Agregar al archivo /etc/rc.conf


sysrc nfs_client_enable=YES
Listar todas las exportaciones NFS disponibles para un cliente

$ showmount -e tormenta
Exports list on tormenta:
/usr/backup/poolrecovery           192.168.88.51
/usr/backup/nfsshare               192.168.88.0

Montar directorios o sistemas de ficheros exportados por el servidor NFS.


# mkdir /mnt/nfs
# mount tormenta:/nfsshare /mnt/nfs

Opciones de montaje

Para acceder a un servidor NFS utilizando sólo UDP con la opción de montaje udp (-u).

Si el servidor NFS desaparece, los programas en el cliente que intenten acceder al sistema de archivos NFS se cuelgan. Por tanto, su montaje NFS tiene que ser interrumpible con la opción intr; podrá interrumpir los procesos colgados con ctrl-C.

Utilizar un montaje suave (soft) FreeBSD notificará a los programas que el fichero ya no está disponible.

Montar Directorios con las opciones soft,intr,rw


# umount /mnt/nfs
# mount -o soft,intr,rw tormenta:/zroot/nfsshare /mnt/nfs
# mount
...
tormenta:/usr/backup/poolrecovery on /mnt/nfs (nfs)
...

Podria anadir esto a /etc/fstab para el mountaje automático


tormenta:/usr/backup/poolrecovery	/mnt/nfs   nfs  rw,soft,intr   0  0

Que versión de NFS estamos utilizando


# nfsstat -m
solaris:/rpool/nfssolaris on /media/nfs
nfsv3,tcp,resvport,nconnect=1,soft,intr,cto,lockd,sec=sys,acdirmin=3,acdirmax=60,\
acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,wsize=65536,\
readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,retrans=2

https://gnulinuxcodigo.blogspot.com/2022/12/montaje-de-sistemas-de-archivos-nfs.html


FreeBSD es genial!

martes, 19 de octubre de 2021

ZFS Local Replication en FreeBSD

Disco ZFS Local Send Receive Snapshots en FreeBSD La replicación de ZFS consta de dos partes: zfs send que serializa una instantánea o una serie de instantáneas en un flujo de datos mezclado, y zfs receive, que convierte ese flujo en un sistema de archivos ZFS. La replicación basada en instantáneas significa que puede hacer una replicación incremental, enviando sólo los bloques que han cambiado; los mismos datos nunca se envían dos veces. El conjunto de datos ZFS transmitido es totalmente coherente, a diferencia del volcado o rsyncing de un sistema de archivos en vivo. Crear un punto de montaje # mkdir /mnt/zbackupsConectar la unidad usb # lsblk


 DEVICE         MAJ:MIN SIZE TYPE                          LABEL MOUNT
ada0             0:96  112G GPT                               - -
  ada0p1         0:97  260M efi                          gpt/efiboot0 /boot/efi
  ada0p2         0:98  512K freebsd-boot                 gpt/gptboot0 -
  free         -:-   492K -                                       - -
  ada0p3         0:99  2.0G freebsd-swap                    gpt/swap0 SWAP
  ada0p3.eli     0:93  2.0G freebsd-swap                           - SWAP
  ada0p4         0:100 110G freebsd-zfs                      gpt/zfs0 zfs
  free         -:-   452K -                                       - -
da0              1:164 932G GPT                               - -
  da0p1          1:166 932G freebsd-zfs                             - zfs

# geom disk list


Geom name: ada0
Providers:
1. Name: ada0
   Mediasize: 120034123776 (112G)
   Sectorsize: 512
   Stripesize: 4096
   Stripeoffset: 0
   Mode: r3w3e6
   descr: Samsung SSD 850 EVO 120GB
   lunid: 5002538d4010a7f6
   ident: S21UNXAG517311N
   rotationrate: 0
   fwsectors: 63
   fwheads: 16

Geom name: da0
Providers:
1. Name: da0
   Mediasize: 1000204886016 (932G)
   Sectorsize: 512
   Stripesize: 4096
   Stripeoffset: 0
   Mode: r0w0e0
   descr: HGST HTS 541010A9E680
   lunname: HGST HTS541010A9E680    160324JD1042ZF1J
   lunid: 3016032414104216
   ident: 160324A41042A61A4543
   rotationrate: unknown
   fwsectors: 63
   fwheads: 255

Particionar el disco externo. Esta es una operación destructiva e irreversible


# gpart destroy -F da0 
  # gpart create -s gpt da0
  da0 created 
  # gpart add -t freebsd-zfs -s 900G -l zbackups da0
  da0p1 added 
  # gpart show da0
=>        40  1953525088  da0  GPT  (932G)
          40  1887436800    1  freebsd-zfs  (900G)
  1887436840    66088288       - free -  (32G)

gpart show -p da0
=>        40  1953525088    da0  GPT  (932G)
          40  1887436800  da0p1  freebsd-zfs  (900G)
  1887436840    66088288         - free -  (32G)

# zpool create zbackups da0p1

Establecer el punto de montaje


# zfs set mountpoint=/mnt/zbackups zbackups

Crear conjunto de datos (dataset) en la unidad zbackups - los puntos de montaje se crean automáticamente.


# zfs create zbackups/carlos
# zfs create zbackups/vm
# zfs create zbackups/vm/alpine
# zfs create zbackups/vm/arch
# zfs create zbackups/vm/freebsd
# zfs list

NAME                           USED  AVAIL     REFER  MOUNTPOINT
zbackups                      1.02M   868G       96K  /mnt/zbackups
zbackups/carlos                104K   868G      104K  /mnt/zbackups/carlos
zbackups/vm                    384K   868G       96K  /mnt/zbackups/vm
zbackups/vm/alpine              96K   868G       96K  /mnt/zbackups/vm/alpine
zbackups/vm/arch                96K   868G       96K  /mnt/zbackups/vm/arch
zbackups/vm/freebsd             96K   868G       96K  /mnt/zbackups/vm/freebsd
...

Listar snapshot

# zfs list -t snapshot

Enviar el conjunto de datos del directorio personal a la unidad externa zbackups.

Primero crear la instantánea para después enviar


(snap_`date +%d%m%y%H%M`)
zfs snapshot zroot/usr/home@/carlos@snap_`date +%d%m%y%H%M`
# zfs snapshot zroot/usr/home/carlos@snap_1910211203

Enviar el conjunto de datos a zbackups/carlos


# zfs send -v zroot/usr/home/carlos@snap_1910211203 | zfs receive -F \ 
zbackups/carlos

# zfs snapshot zroot/vm@snap_1910211203

# zfs send -v zroot/vm@snap_1910211203 | zfs receive -F zbackups/vm

# zfs snapshot zroot/vm/alpine@snap_1910211203

# zfs send -v zroot/vm/alpine@snap_1910211203 | zfs receive -F \ 
zbackups/vm/alpine

# zfs snapshot zroot/vm/arch@snap_1910211203

# zfs send -v zroot/vm/arch@snap_1910211203 | zfs receive -F zbackups/vm/arch

# zfs snapshot zroot/vm/freebsd-12-2@snap_1910211203
# zfs snapshot zroot/vm/freebsd-12-2/disk1@snap_1910211203

# zfs send -Rv zroot/vm/freebsd-12-2@snap_1910211203 | zfs receive \
-F zbackups/vm/freebsd

snapshot del pool completo zroot


# zfs snapshot -r zroot@snap1_021121

Crear dataset zbackups


# zfs create zbackups/snap1full

Enviar recursivamente las snpashots


# zfs send -vR zroot@snap_021121 | zfs receive zbackups/snap1full

Los conjuntos de datos de las instantáneas recibidas deben estar impecables para que los zfs reciban aceptar actualizaciones incrementales o diferenciales. La bandera -F le dice a zfs Receive que revierte cualquier cambio que impida aceptar esto instantánea.


# zfs send -vR zroot@snap_021121 | zfs receive -F zbackups/snap1full 
# grc zfs list -t all -r zbackups

Instantáneas incrementales

Crear las instantánea(s)


# zfs snapshot zroot/usr/home/carlos@snap_20102112020

Enviar instantáneas incrementales.


# zfs send -i zroot/usr/home/carlos@snap_1910211203 \ 
zroot/usr/home/carlos@snap_20102112020 | zfs receive \ 
-F zbackups/carlos

% smartctl -a /dev/ada0


smartctl 7.2 2020-12-30 r5155 [FreeBSD 13.0-RELEASE-p4 amd64] (local build)
Copyright (C) 2002-20, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     Samsung based SSDs
Device Model:     Samsung SSD 850 EVO 120GB
Serial Number:    S21UNXAG517311N
LU WWN Device Id: 5 002538 d4010a7f6
Firmware Version: EMT01B6Q
User Capacity:    120.034.123.776 bytes [120 GB]
Sector Size:      512 bytes logical/physical
Rotation Rate:    Solid State Device
TRIM Command:     Available
Device is:        In smartctl database [for details use: -P show]
ATA Version is:   ACS-2, ATA8-ACS T13/1699-D revision 4c
SATA Version is:  SATA 3.1, 6.0 Gb/s (current: 6.0 Gb/s)
Local Time is:    Wed Oct 20 00:00:26 2021 CEST
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
...

% smartctl -a /dev/da0
martctl 7.2 2020-12-30 r5155 [FreeBSD 13.0-RELEASE-p4 amd64] (local build)
Copyright (C) 2002-20, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     HGST Travelstar 5K1000
Device Model:     HGST HTS541010A9E680
Serial Number:    160324JD1042ZF1J45DS
LU WWN Device Id: 5 000cca 887d56d1c
Firmware Version: JA0OA5M0
User Capacity:    1.000.204.886.016 bytes [1,00 TB]
Sector Sizes:     512 bytes logical, 4096 bytes physical
Rotation Rate:    5400 rpm
Form Factor:      2.5 inches
Device is:        In smartctl database [for details use: -P show]
ATA Version is:   ATA8-ACS T13/1699-D revision 6
SATA Version is:  SATA 2.6, 3.0 Gb/s (current: 3.0 Gb/s)
Local Time is:    Wed Oct 20 00:02:24 2021 CEST
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

=== START OF READ SMART DATA SECTION ===
SMART Status not supported: Incomplete response, ATA output registers missing
SMART overall-health self-assessment test result: PASSED
...

FreeBSD es genial!.

lunes, 24 de junio de 2019

Copiar restaurar particiones Linux


Instalar Arch Linux UEFI

Iniciar el sistema desde un usb live Sytem Rescue con soporte UEFI


lsblk lista información a cerca de todos los dispositivos de bloques disponibles


# lsblk

root@sysresccd /root % lsblk 

NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT

sda      8:0    0  55.9G  0 disk 

├─sda1   8:1    0   512M  0 part 

├─sda2   8:2    0    30G  0 part 

└─sda3   8:3    0  25.4G  0 part 

sdb      8:16   0 465.8G  0 disk 

└─sdb1   8:17   0 211.5G  0 part 

sdc      8:32   1   1.9G  0 disk 

└─sdc1   8:33   1   1.9G  0 part /livemnt/boot

loop0    7:0    0 317.1M  1 loop /livemnt/squashfs

lsblk con la opción -f devuelve información sobre sistemas de archivos

# lsblk -f

NAME FSTYPE LABEL UUID FSAVAIL FSUSE% MOUNTPOINT

sda                                                                   

├─sda1 vfat    CC3A-1EDB 

├─sda2  ext4    38b21575-cd76-4ff5-9733-654c1d50f30f   21,4G    22% /

└─sda3  ext4    e9774ab0-2d95-4820-8c1e-d76563970c86     21G    11% /home

sdb                                                                   

└─sdb1  vfat  SYSRCD-4_5_ 6843-DF82    /livemnt/boot

sdc                                                                

└─sdc1  ext4 ArchlinuxHP   d007c890-2620-44fc-aaeb-5e40f68fa40

loop0  squashfs                                               /livemnt/squashfs 

https://docs.freebsd.org/es/books/handbook/disks/#backup-basics

“No hacer nada” no es un programa, pero es la estrategia de respaldo más extendida. No tiene coste. No hay un calendario de respaldos a seguir. Simplemente hay que decir que no. Si algo le sucediera a sus datos sonría y acostúmbrese a su nueva situación.


Copia de seguridad con tar

Se crea el punto de montaje y se monta en modo rw (lectura y escritura) el disco duro externo donde se guardarán las copias de seguridad en formato tar.gz

root@sysresccd /root % mkdir /mnt/backuprestore
root@sysresccd /root % mount -t ext4 -o rw /dev/sdc1 /mnt/backuprestore

Se crean los puntos de montaje uno para cada partición con nombres que sirvan de referencia.

# mkdir /mnt/archlinuxboot
# mkdir /mnt/archlinuxraiz
# mkdir /mnt/archlinuxhome

Mantar en modo ro (sólo lectura) las particiones del sistema a respaldar

root@sysresccd /mnt % mount -o ro -t vfat /dev/sda1 /mnt/archlinuxboot
root@sysresccd /mnt % mount -o ro -t ext4 /dev/sda2 /mnt/archlinuxraiz
root@sysresccd /mnt % mount -o ro -t ext4 /dev/sda3 /mnt/archlinuxhome

Opciones y argumentos del comando tar
c crea la copia usando tar
v activa el modo verbose para mostrar información por pantalla
z comprime los datos utilizando el formato gzip
p preserva los permisos de los ficheros (predeterminado para root)
f manda la salida a un fichero en lugar de a la salida estandar
--exclude excluye ficheros y directorios de la copia

Se crea y exporta la variable temporal fecha
root@sysresccd /mnt % FECHA=$(date +%d%m%Y)
root@sysresccd /mnt % export FECHA
root@sysresccd /mnt % env | grep FECHA
FECHA=24062019
root@sysresccd /mnt % echo $FECHA
24062019

Una vez hecho esto se cambia al punto de montaje de la partición raiz (sda2) para realizar la copia.
root@sysresccd /mnt % cd /mnt/archlinuxraiz
root@sysresccd /mnt/archlinuxraiz % tar czvf /mnt/backuprestore/Archlinux/archlinuxsda2/archilinuxsda2-$FECHA.tar.gz *

Entrando en el punto de montaje de la partición boot (sda1) para la copia en formato tar.gz utilizando tar
root@sysresccd /mnt % cd /mnt/archlinuxboot
root@sysresccd /mnt/archlinuxboot % tar czvf /mnt/backuprestore/Archlinux/archlinuxsda1/archilinuxsda1-$FECHA.tar.gz *

Por último lo mismo para home (sda3)

root@sysresccd /mnt % cd /mnt/archlinuxhome
root@sysresccd /mnt/archlinuxraiz % tar czvf /mnt/backuprestore/Archlinux/archlinuxsda3/archilinuxsda3-$FECHA.tar.gz --exclude=lost+found *

Restaurar particiones

Iniciar un live usb System Rescue con soporte UEFI

Crear el punto de montaje y montar en modo ro (sólo lectura) la partición que contiene el o los archivos comprimidos a restaurar

# mkdir /mnt/backuprestore
# mount -t ext4 -o ro /dev/sdb1 /mnt/backuprestore

Restaurar la partición raiz

Formatear la partición a restaurar (se perderan todos los datos)
# mkfs.ext4 /dev/sda2

Crear el punto de montaje y montar en modo rw (lectura y escritura) la partición a restaurar

# mkdir /mnt/archraiz
# mount -t ext4 -o rw /dev/sda2 /mnt/archraiz

Entrar en la partición sda2
# cd /mnt/archraiz

Extraer el archivo (no olvide el punto final)
# tar xvzf /mnt/backuprestore/Archlinux/archlinuxsda2/archilinuxsda2-24062019.tar.gz .

Restaurar partición boot (sda1)

Formatear la partición a restaurar (se perderan todos los datos)
# mkfs.vfat /dev/sda1

Crear el punto de montaje y montar en modo rw (lectura y escritura) la partición a restaurar
# mkdir /mnt/archboot
# mount -t vfat -o rw /dev/sda1 /mnt/archboot

Entrar en la partición sda1
# cd /mnt/archboot

Extraer el archivo

# tar xvzf /mnt/backuprestore/Archlinux/archlinuxsda1/archilinuxsda1-24062019.tar.gz .

Restaurar partición home

Formatear la partición a restaurar (se perderan todos los datos)
# mkfs.ext4 /dev/sda3

Crear el punto de montaje y montar en modo rw (lectura y escritura) la partición a restaurar
# mkdir /mnt/archhome
# mount -t ext4 -o rw /dev/sda3 /mnt/archhome

Entrando en la partición sda3

# cd /mnt/archraiz

Extraer el archivo
# tar xvzf /mnt/backuprestore/Archlinux/archlinuxsda3/archilinuxsda3-24062019.tar.gz . 

Finalmente desmontar las particiones

# cd
# umount /mnt/archraiz
# umount /mnt/archboot
# umount /mnt/archhome
# umount /mnt/backuprestore

O desmontar recursivamente.
La relación entre los puntos de montaje está determinada por /proc/self/mountinfo. El sistema de archivos debe ser especificado por la ruta del punto de montaje. Un recursivo desmontado por el nombre del dispositivo o UUID es incompatible.

# umount -R /mnt/*

Reiniciar el sistema
# reboot

OpenBSD es genial!.

martes, 22 de mayo de 2018

Disco de rescate Centos

Rescartar sistema Centos

Introduzca el disco de instalación para iniciar. Cuando aparezca la pantalla de bienvenida seleccione la entrada "Rescue installed system" con la tecla de dirección. Pulse Enter y continuar. Verá que la opción de arranque es simplemente rescue. Pulse Enter.

Lo primero es configurar el idioma spanish y Enter. Para el teclado Español/España, seleccione es luego la tecla TAB hasta que resalte Aceptar y a continuación Enter.

Método de rescate ¿Qué tipo de dispositivo contiene la imagen de rescate? seleccione CD/DVD

Si repondió Si en la pantalla ¿Desea arrancar las tarjetas de red del sistema? se le solicitará que elija la tarjeta o tarjetas que desea utilizar para establecer una conexión de red. Puede establecer la conexión de red por medio de DHCP o ip estática. Al finalizar pulse TAB y Aceptar

Rescatar

Las opciones son

Continuar. Intentará encontrar una instalación de Linux en el disco duro e intentará montar las particiones correspondiente debajo del directorio /mnt/sysimage. Se podrá acceder en modo lectura y escritura al sistema de archivos para realizar los cambios pertinentes.

Modo lectura. El sistema de archivos se montará en modo de sólo lectura.

Omitir. No se montaŕa el sistema de archivos del disco, ideal para realizar reparaciones del sistema de archivos de las particiones utilizando fsck.

Avanzado. Esta opción permite hacer uso de dispositivos especiales de almacenamiento.

Tan pronto como sea detectada la instalación en el disco duro, las particiones de la instalación existente quedarán montadas debajo del directorio /mnt/sysimage. Pulse Enter.

La pantalla que aparecerá presenta tres opciones.

Start shell. Inicia el intérprete de comandos, tendrá acceso a un conjunto básico de herramientas de diagnóstico y reparación.
Run diagnostic. Esta opción ejecuta FirstAidKit, una herramienta de reparación y verificación automática de algunos problemas comunes.
Reboot. Reinicia el sistema.

Seleccione Start shell y verifique que todas las particiones de la instalación han sido montadas utilizando el comando df -h

# df -h

Teclee exit para regresar a la anterior pantalla.

El comando 

# chroot /mnt/sysimage

Cambia al sistema operativo en el disco duro, desde el sistema operativo del disco de rescate.

Puede cambiar la clave de acceso del usuario root ejecutando passwd sin argumentos

# passwd

Es posible reinstalar manualmente el gestor de arranque del sistema ejecutando

# grub-install /dev/sda

Teclee exit para regresar al sistema operativo del entorno de rescate

# exit

Puede seleccionar ejecutar fakd (FirstAidKit), herramienta de diagnóstico y reparación automática de, el gestor de arranque, imagen del disco RAM para el inicio del sistema (initrd), arreglos de discos por software y reinstalación del algunos paquetes básicos.

Teclee exit para regresar a la anterior pantalla y reboot para reiniciar el sistema sin olvidar extraer el disco de rescate.


Centos es genial!.

sábado, 24 de septiembre de 2016

Cifrar particion con cryptsetup luks

Sistema Operativo Arch Linux

# lsmod|grep dm_crypt
dm_crypt               28672  1
dm_mod                102400  2 dm_crypt

Si no aparece el módulo lo cargamos con:
# modprobe dm_crypt


Ya creada la partición /dev/sda5, procedemos a formatear usando el sistema de archivos LUKS (Linux Unified Key Setup)

# cryptsetup luksFormat /dev/sda5

El UUID del nuevo sistema de ficheros encryptado.

# cryptsetup luksUUID /dev/sda5
2005190e-81e8-4292-a84e-e84a06d6d70a

El siguiente paso es mapear el sistema de ficheros contra encrypted-fs e introducir la contraseña que necesitaremos recordar.

# cryptsetup luksOpen /dev/sda5 encrypted-fs
Enter passphrase for /dev/sda5

Tendrá que darle formato y montar:

# mkfs.ext4 /dev/mapper/encrypted-fs
mke2fs 1.43.3 (04-Sep-2016)
Creating filesystem with 10521856 4k blocks and 2632672 inodes
Filesystem UUID: 8da03053-b6bd-4add-b944-713fa2942806
Superblock backups stored on blocks: 
        32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 
        4096000, 7962624

Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (65536 blocks): done
Writing superblocks and filesystem accounting information: done 



Esta es la salida de fdisk

# fdisk -l
Disk /dev/sda: 465.8 GiB, 500107862016 bytes, 976773168 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disklabel type: gpt
Disk identifier: 9E0ED2FC-0BC1-4542-9688-DF733F20A984

Device         Start       End   Sectors  Size Type
/dev/sda1       2048 104859647 104857600   50G Linux filesystem
/dev/sda2  104859648 105908223   1048576  512M EFI System
/dev/sda3  105908224 114296831   8388608    4G Linux swap
/dev/sda4  114296832 533727231 419430400  200G Linux filesystem
/dev/sda5  533727232 617906175  84178944 40.1G Linux filesystem



Disk /dev/mapper/encrypted-fs: 40.1 GiB, 43097522176 bytes, 84174848 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes


La salida del comando siguiente nos sirve para averiguar el UUID y utilizarlo en fstab:

# tune2fs -l /dev/mapper/encrypted-fs | grep UUID

Filesystem UUID:          8da03053-b6bd-4add-b944-713fa2942806


# mkdir /encrypted-fs

Lo añadimos al archivo /etc/fstab con la opción noauto para iniciar y montar manualmente.

# /dev/sda5                                                                                                   
UUID=8da03053-b6bd-4add-b944-713fa2942806   /encrypted-fs  ext4  noauto,defaults  0 0


# cat /etc/fstab


Si quiere montar el sistema de archivos cifrado al iniciar el sistema, tiene que agregar al archivo /etc/crypttab la línea, le pedirá la contraseña al arranque del sistema.

encrypted-fs  /dev/mapper/encrypted-fs  none

Antes de desconectar el dispositivo vamos a copiar los datos que queremos mantener cifrados:

# cp -r /home/carles/gentoo /encrypted-fs/

Desmontamos el dispositivo antes de desconectarlo
# umount /encrypted-fs/

Ya podemods desconectar el dispositivo ejecutando cryptsetup, con la opción luksClose y el nombre del dispositivo.

# cryptsetup luksClose /dev/mapper/encrypted-fs

Bien, reiniciar el sistema.

Al reiniciar el sistema tendremos que cargar el módulo con lsmod, y abrirlo con cryptsetup y la opción luksOpen /dev/sda5 encrypted-fs. Nos pedirá la frase o contraseña introducida para el cifrado de la partición.

# cryptsetup luksOpen /dev/sda5 encrypted-fs
Enter passphrase for /dev/sda5:

Aún no podremos acceder al dispositivo, tenemos que montarlo:

# ls /encrypted-fs/gentoo
ls: cannot access '/encrypted-fs/gentoo': No such file or directory

# mount /encrypted-fs

# ls /encrypted-fs
gentoo  lost+found

Unix es genial!.

martes, 7 de julio de 2015

Particiones gpart FreeBSD bsdtar

FreeBSD y gpart para reparticionar la particion de 364GB destinada a datos y crear dos particiones, la primera dedicada a guardar un archivo tar.gz del sistema root y la segunda de datos.

Como crear una imagen del sistema raiz completo archivo.tar.gz con bsdtar
Como restaurar el sistema raiz con bsdtar.

Enumerar las particiónes del disco para ver la configuracion actual:
# gpart show ada0


El esquema de partición actual.

/dev/ada0p1 freebsd-boot - 512G
/dev/ada0p2 freebsd-ufs - 98G
/dev/ada0p3 freebsd-swap - 4G
/dev/ada0p4 freebsd-ufs - 364G

/dev/ada0p4 es la partición a modificar.

Lo primero es hacer copia de seguridad de todos los datos al servidor con rsync.

$ rsync -avz --stats /mnt/datos/* root@192.168.1.254:/volume1/NetBackup/datos-HD-500-dell/
...
Number of files: 33,909 (reg: 24,404, dir: 9,505)
Number of created files: 33,848 (reg: 24,360, dir: 9,488)
Number of regular files transferred: 24,360
Total file size: 94,221,107,499 bytes
Total transferred file size: 94,055,122,224 bytes
Literal data: 94,055,122,224 bytes
Matched data: 0 bytes
File list size: 1,260,226
File list generation time: 0.003 seconds
File list transfer time: 0.000 seconds
Total bytes sent: 91,464,319,664
Total bytes received: 577,095

sent 91,464,319,664 bytes  received 577,095 bytes  4,876,437.33 bytes/sec
total size is 94,221,107,499  speedup is 1.03

Eliminar la partición de datos (364G):
# gpart delete -i 4 ada0

Tengo 364G libres

Crear una partición de 100G:
# gpart add -s 100G -t freebsd-ufs ada0
ada0p4 added


La siguiente partición ocupa el resto de espacio libre:
# gpart add -t freebsd-ufs ada0
ada0p5 added

/dev/ada0p5 (264G) es la partición de datos.
/dev/ada0p4 (100G) la partición donde se guardarán las imagenes de copia de seguridad del sistema raiz (tar.gz).

Por ultimo crear los sistemas de ficheros:
# newfs -U /dev/ada0p4


# newfs -U /dev/ada0p5


Poner etiquetas (label):

$ glabel label systemtar /dev/ada0p4
$ glabel label datos /dev/ada0p5

# ls /dev/label/
datos  systemtar

Montar la partición de datos:

# mkdir /mnt/datos

Cambiar los permisos del directorio /mnt/datos a un usuario sin privilegios
# chown carles /mnt/datos

# mount -t -o rw /dev/ada0p5 /mnt/datos
# chown carles /mnt/datos

 Copiar los datos con rsync desde el servidor al directorio local:
$ rsync -avz --stats root@192.168.1.254:/volume1/NetBackup/datos-HD-500-dell/ /mnt/datos/

Number of files: 33,910 (reg: 24,404, dir: 9,506)
Number of created files: 2,637 (reg: 2,560, dir: 77)
Number of regular files transferred: 2,560
Total file size: 94,221,107,499 bytes
Total transferred file size: 7,147,728,070 bytes
Literal data: 7,147,728,070 bytes
Matched data: 0 bytes
File list size: 365,294
File list generation time: 0.014 seconds
File list transfer time: 0.000 seconds
Total bytes sent: 58,503
Total bytes received: 7,151,528,689
...

Copia de seguridad con bsdtar del sistema raiz:

Iniciar el sistema en modo single user:

Pulsar la barra espaciadora para detener la cuenta atrás y luego la tecla 2 (single user)

Presionar Intro para la shell por defecto y teclee la contraseña de root si la ha implementado en su servidor.

Copia de seguridad del sistema:

En el símbolo del sistema teclear:

# fsck -p
# mount -u /
# swapon -a
# adjkerntz -i

Crear el directorio donde se guarda el archivo tar.gz
# mkdir /mnt/sysbsdtar

Montar la particion  (100G), a la que volcaremos la copia bsdtar del
sistema raiz freebsd, para recuperarlo en caso de querer volver a un estado
anterior:

# mount -t ufs -o rw /dev/ada0p4 /mnt/sysbsdtar

Cambiar al directorio raiz (particion a respaldar):
# cd /

Realizar la copia de respaldo:
# bsdtar cvfz /mnt/sysbsdtar/ada0p2-7-7-2015.tar.gz --exclude=home *

Despues de finalizar la copia desmontamos la particion:
# umount /mnt/sysbsdtar
# reboot


Restaurar la copia del sistema:

Iniciar en modo single user

Presionar Intro para la shell por defecto.

En el símbolo del sistema teclear:

# fsck -p
# mount -u /
# swapon -a
# adjkerntz -i

Formatear el sistema de ficheros a restaurar (Perdera todos los datos)
# newfs -U /dev/ada0p2

Crear el directorio
# mkdir /mnt/raiz
# mkdir /mnt/copia

Montar particiones
# mount -t ufs -o rw /dev/ada0p2 /mnt/raiz
# mount -t ufs -o ro /dev/ada0p4 /mnt/copia

# cd /mnt/raiz

Restaurar particion raiz
# bsdtar xvzf /mnt/copia/ada0p2-7-7-2015.tar.gz .

# cd /
Desmontar particion:
# umount /mnt/copia
# reboot

Unix es genial!.