Páginas

Buscar este blog

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

sábado, 3 de octubre de 2026

Realizar copia de seguridad del cliente solaris en disco USB

ZFS FreeBSD Copia de seguridad del servidor tormenta
Backup Manual y Recuperación

FreeBSD14.5

1. Identificar discos

geom disk list
camcontrol devlist
gpart show

En solaris, el disco USB suele aparecer como da0 o da1. Verificar con geom disk list cuál es el correcto (etiqueta ZFSBACKUP).

2. Comprobaciones previas (antes de destruir nada)

¿Tiene particiones?

gpart show da0

¿Tiene restos de ZFS?

zpool import | grep -B2 -A5 da0

¿Está montado en algún sitio?

mount | grep da0

3. Plan resumido

ComandoQué hace
gpart destroy -F da0Borra particiones
zpool labelclear -f /dev/da0Borra restos ZFS
gpart create -s gpt da0Tabla GPT nueva
gpart add -t freebsd-zfs -l ZFSBACKUP da0Partición ZFS
zpool create -o ashift=12 ... zbackup /dev/gpt/ZFSBACKUPPool zbackup
zfs create -o mountpoint=none zbackup/recovery/solarisDataset destino
zfs snapshot -r zroot@snap-$(date +%Y%m%d)Snapshot del sistema
zfs send -Rwcv ... | zfs receive -Fsuv ...Envío local (en tmux)
zpool export zbackupCerrar limpiamente

4. Preparar el disco

gpart destroy -F da0
# → da0 destroyed

Borrar cualquier resto de ZFS (aunque no haya, por asegurar)

zpool labelclear -f /dev/da0 2>/dev/null

Crear tabla GPT nueva

gpart create -s gpt da0
# → da0 created

Crear partición ZFS ocupando todo el disco

gpart add -t freebsd-zfs -l ZFSBACKUP da0
# → da0p1 added

Verificar

gpart show da0
# →       40  3907029088  da0  GPT  (2T)
# →       40  3907029088    1  freebsd-zfs  (2T)

5. Crear el pool zbackup

Los discos modernos suelen tener sectores de 4K, pero muchos discos USB reportan 512B. Es crítico crear el pool con ashift=12 (4096 bytes) para evitar problemas de rendimiento.

Ver ashift que ZFS detectaría por defecto

diskinfo -v da0 | grep -i "sector size"

Si dice 512, hay que forzar ashift=12 al crear el pool.

zpool create -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O relatime=on \
             -O mountpoint=none \
             zbackup /dev/gpt/ZFSBACKUP

Banderas

  • ashift=12 → sectores 4K (crítico para rendimiento en discos modernos).
  • compression=lz4 → compresión ligera y rápida.
  • atime=off → no actualizar tiempo de acceso (más rápido).
  • xattr=sa → atributos extendidos en el inodo.
  • relatime=on → atime solo cuando sea útil.
  • mountpoint=none → no montar automáticamente.

Verificar

zpool status zbackup
zpool list zbackup
zfs list

Crear dataset destino

zfs create -o mountpoint=none zbackup/recovery
zfs create -o mountpoint=none zbackup/recovery/solaris
zfs list -r zbackup

Salida esperada:

zbackup                     XXXG   XXXG    96K  none
zbackup/recovery            XXXG   XXXG    96K  none
zbackup/recovery/solaris    XXXG   XXXG    96K  none

Pool zbackup creado correctamente:

DatoValor
Poolzbackup
Tamaño~2 TB
Dataset destinozbackup/recovery/solaris (listo)
zroot a respaldar~220 G

6. Crear snapshot del sistema

zfs snapshot -r zroot@snap-$(date +%Y%m%d)

Verificar

zfs list -t snapshot -r zroot | grep snap-$(date +%Y%m%d) | wc -l

El resultado depende del número de datasets del sistema. En solaris actual: ~30.

Nota para el futuro: si un script creó el snapshot en un solo dataset sin usar -r, o si otro proceso lo creó antes para otro propósito, puede haber conflictos. Cuando se monte el cron para backups automáticos, usar date +%Y%m%d-%H%M%S para evitar colisiones si se ejecuta dos veces el mismo día.
zfs snapshot -r zroot@snap-$(date +%Y%m%d-%H%M%S)

7. Lanzar el envío en tmux

Entrar en tmux

tmux new -s backup_usb

Comando de envío (dentro de tmux)

zfs send -Rwcv zroot@snap-$(date +%Y%m%d) \
  | zfs receive -Fsuv -x mountpoint zbackup/recovery/solaris

Banderas explicadas

FlagSignificado
-RRecursivo: envía zroot y todos sus hijos
-wRaw: envía los bloques cifrados tal cual (necesario si hay datasets cifrados)
-cCompresión nativa ZFS (lz4)
-vVerbose: muestra progreso por dataset
-FFuerza rollback en destino si hay divergencias
-sGuarda token de resume en /var/tmp/ (permite reanudar si se corta)
-uNo monta los datasets recibidos
-x mountpointNo replica los mountpoints del origen
Importante sobre -w: aunque solaris no tiene datasets cifrados actualmente, el -w es inofensivo si no hay cifrado. Mantener el mismo script/comando que en tormenta para consistencia y por si en el futuro se añade cifrado.

8. Salir de tmux sin matar el proceso

Ctrl+b  d

9. Monitorizar (en otra terminal)

Ver datasets llegando en tiempo real

watch -n 10 'zfs list -r zbackup/recovery/solaris | head -30'

Ver velocidad de escritura al USB

zpool iostat zbackup 5

Ver espacio consumido

watch -n 30 'zfs list zbackup'

10. Verificar tras el envío

Volver a la sesión tmux

tmux attach -t backup_usb

Si ya terminó, se verá el real Xm Ys del comando. Entonces:

Contar snapshots origen vs destino

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zbackup/recovery/solaris | wc -l

Deben coincidir.

Verificar datasets replicados

zfs list -r zbackup/recovery/solaris | head -30

Espacio usado

zfs list zbackup
zpool list zbackup

11. Si algo falla durante el envío

¿Sigue algún proceso zfs vivo?

ps aux | grep -E "zfs (send|receive)" | grep -v grep

Si aparece algo, sigue corriendo. Esperar y dejarlo terminar.

¿En qué estado está el destino?

zfs list zbackup
zfs list -r zbackup/recovery/solaris | head -20

Se verá si quedó un dataset a medias (zbackup/recovery/solaris con datos parciales).

¿Hay un token de resume guardado?

ls -la /var/tmp/ | grep -i zfs
ls -la / | grep -i zfs
El token de resume solo existe si se usó -s en el zfs receive. Si no se usó, no hay reanudación posible: hay que empezar de cero.

¿El proceso murió? Limpiar el destino parcial

zfs destroy -r zbackup/recovery/solaris
zfs create -o mountpoint=none zbackup/recovery/solaris
zfs list -r zbackup/recovery

Relanzar con -s para permitir resume

tmux new -s backup_usb

Dentro de tmux:

zfs send -Rwcv zroot@snap-20261002 \
  | zfs receive -Fsuv -x mountpoint zbackup/recovery/solaris
El flag -s en zfs receive guarda un token de reanudación en /var/tmp/. Si se vuelve a cortar, se podrá reanudar con:
zfs send -t $(ls /var/tmp/zfs_*.resume 2>/dev/null | head -1)

Salir de tmux con Ctrl+b d antes de cerrar SSH. No cerrar la sesión SSH hasta que tmux esté desconectado.

12. Exportar el pool y desconectar el USB

Verificar que no hay nada escribiendo

zpool status zbackup
lsof | grep zbackup 2>/dev/null

Exportar limpiamente

zpool export zbackup

Y por último

sync

Ya se puede retirar el cable USB.

13. Tiempo estimado

Velocidad USB~220 GB
80 MB/s~45 min
120 MB/s~30 min
200 MB/s~18 min
400 MB/s~9 min

Con el chip ASMT USB 3.0 + disco SATA: ~15-30 min si es SSD, ~40-60 min si es HDD.

Recordatorio: para poder cerrar la sesión SSH sin que se corte el envío, primero entrar en tmux con tmux new -s backup_usb, lanzar el envío, y salir con Ctrl+b d.
Recomendación adicional: poner una etiqueta al disco físico con rotulador o adhesivo:
  • Backup Solaris
  • snap-20261002
  • zbackup pool

14. Restaurar archivos de configuración

No requiere reiniciar. Solo copia los archivos desde el snapshot.

Paso 1: Montar el snapshot

mkdir -p /mnt/snap
mount -t zfs zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026 /mnt/snap

Paso 2: Comparar qué cambió

diff /etc/pf.conf       /mnt/snap/etc/pf.conf
diff /etc/rc.conf       /mnt/snap/etc/rc.conf
diff /etc/sysctl.conf   /mnt/snap/etc/sysctl.conf
diff /boot/loader.conf  /mnt/snap/boot/loader.conf

Paso 3: Backup de los actuales

cp /etc/pf.conf       /etc/pf.conf.broken-$(date +%Y%m%d)
cp /etc/rc.conf       /etc/rc.conf.broken-$(date +%Y%m%d)
cp /etc/sysctl.conf   /etc/sysctl.conf.broken-$(date +%Y%m%d)
cp /boot/loader.conf  /boot/loader.conf.broken-$(date +%Y%m%d)

Paso 4: Restaurar desde el snapshot

cp /mnt/snap/etc/pf.conf       /etc/pf.conf
cp /mnt/snap/etc/rc.conf       /etc/rc.conf
cp /mnt/snap/etc/sysctl.conf   /etc/sysctl.conf
cp /mnt/snap/boot/loader.conf  /boot/loader.conf

Paso 5: Desmontar y probar

umount /mnt/snap
rmdir /mnt/snap

# Recargar pf (sin reiniciar)
pfctl -f /etc/pf.conf

# Ver rutas
netstat -rn

# Probar red
ping -c 3 192.168.88.1
ping -c 3 8.8.8.8
ping -c 3 google.com

Paso 6: Si funciona, reiniciar para aplicar loader.conf y sysctl.conf

shutdown -r now

15. Rollback completo

Requiere arrancar en modo monousuario. No se puede hacer con el dataset montado.

Paso 1: Crear snapshot de seguridad del estado actual

Antes de tocar nada, para poder volver si algo falla:

zfs snapshot -r zroot@before-rollback-$(date +%Y%m%d-%H%M)

Paso 2: Reiniciar en modo monousuario

shutdown -r now

En el menú de arranque de FreeBSD, pulsar 2 (Boot Single User).

Paso 3: Preparar el sistema

zfs set readonly=off zroot
zfs mount -a

Paso 4: Rollback

Esto destruye los snapshots posteriores a este (incluido el de before-rollback).
zfs rollback -R zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026

Paso 5: Salir del modo monousuario y reiniciar

exit

O directamente:

reboot

Qué se pierde con el rollback

ElementoEstado
pf.confVuelve al estado del snapshot
loader.confVuelve al estado del snapshot
sysctl.confVuelve al estado del snapshot
/etc/rc.confEstado del snapshot
Archivos en /home/carlosNO se pierden (dataset separado)
Archivos en /varNO se pierden (dataset separado, si no se hace rollback ahí)
Solo afecta a zroot/ROOT/default (el sistema base). Los datos personales en zroot/home/carlos no se tocan.

16. Uso del script automatizado

Solaris tiene instalado el script /root/bin/zfs-backup.sh que automatiza todo el proceso.

Ejecución manual (modelo B: USB guardado fuera)

# 1. Conectar el USB ZFSBACKUP a solaris
# 2. Ejecutar:
sh /root/bin/zfs-backup.sh

# 3. Ver el resultado
tail -20 /var/log/zfs-backup.log

# 4. Cuando termine, el script exporta el pool automáticamente
# 5. Desconectar el USB y guardarlo en lugar seguro

Qué hace el script automáticamente

  • Detecta que está en solaris y usa zbackup/zbackup/recovery/solaris/ZFSBACKUP.
  • Importa el pool zbackup si no está importado.
  • Crea el snapshot zroot@snap-YYYYMMDD (dataset por dataset, sin fallos atómicos).
  • Detecta la última snapshot en destino y envía solo el incremental.
  • Aplica retención: 7 snapshots en origen, 30 en destino.
  • Exporta el pool al terminar (para poder desconectar el USB).
  • Registra todo en /var/log/zfs-backup.log.

Frecuencia recomendada

Semanal (domingo por la tarde). Total: 5-15 minutos por backup.

17. Errores comunes a evitar

  • Usar zfs send -Rcv sin -w → falla si hay datasets cifrados.
  • Olvidar -s en zfs receive → no hay reanudación posible si se corta.
  • Cerrar la sesión SSH sin tmux → el envío muere al desconectar.
  • No guardar la clave de cifrado fuera del backup → backup inútil si se pierde.
  • Usar zfs destroy sin -n primero → riesgo de borrar snapshots con dependencias.
  • Ejecutar el script de retención sin verificar → puede borrar snapshots indiscriminadamente.
  • Importar el mismo pool en dos máquinas simultáneamente → corrompe metadatos.
  • Desconectar el USB sin zpool export → riesgo de corrupción.

18. Checklist final

  • [ ] Disco USB identificado y preparado
  • [ ] Pool zbackup creado con ashift=12
  • [ ] Dataset zbackup/recovery/solaris creado
  • [ ] Snapshot del sistema creado (zfs snapshot -r)
  • [ ] Envío lanzado dentro de tmux
  • [ ] Proceso monitorizado hasta el final
  • [ ] Verificado: snapshots origen vs destino coinciden
  • [ ] Pool exportado limpiamente (zpool export zbackup)
  • [ ] USB desconectado y guardado en lugar seguro
  • [ ] Clave de cifrado guardada en al menos 2 sitios distintos (si aplica)

19. Dónde guardar el USB

UbicaciónProtección
❌ Junto a la máquinaNinguna (robo/incendio afecta a ambos)
⚠️ Otra habitación de la casaProtección baja
✅ Otra planta / garaje / trasteroProtección media
✅✅ Casa de un familiar / amigoProtección alta
✅✅✅ Caja de seguridad del bancoProtección máxima

Recomendación: caja fuerte pequeña en casa + copia secundaria en casa de un familiar.

20. Verificaciones periódicas (cada 3-6 meses)

# 1. Conectar el USB ZFSBACKUP a solaris
# 2. Importar el pool
zpool import zbackup

# 3. Verificar el pool
zpool status zbackup

# 4. Contar snapshots en destino
zfs list -t snapshot -r zbackup/recovery/solaris | grep 'snap-2026' | wc -l

# 5. Ver las más recientes
zfs list -t snapshot -r zbackup/recovery/solaris | grep 'snap-2026' | sort | tail -5

# 6. Exportar
zpool export zbackup

Si todo está en orden, los datos son recuperables.

FreeBSD es genial!.

viernes, 2 de octubre de 2026

Realizar copia de seguridad del servidor tormenta en disco USB

ZFS FreeBSD Copia de seguridad del cliente solaris
Backup Manual y Recuperación

FreeBSD 14.5

1. Identificar discos

geom disk list
camcontrol devlist
gpart show

2. Comprobaciones previas (antes de destruir nada)

¿Tiene particiones?

gpart show da1

¿Tiene restos de ZFS?

zpool import | grep -B2 -A5 da1

¿Está montado en algún sitio?

mount | grep da1

3. Plan resumido

ComandoQué hace
gpart destroy -F da1Borra particiones
zpool labelclear -f /dev/da1Borra restos ZFS
gpart create -s gpt da1Tabla GPT nueva
gpart add -t freebsd-zfs -l backup1tb da1Partición ZFS
zpool create -o ashift=12 ... zbk /dev/gpt/backup1tbPool zbk
zfs create -o mountpoint=none zbk/tormentaDataset destino
zfs snapshot -r zroot@snap-$(date +%Y%m%d)Snapshot del sistema
zfs send -Rwcv ... | zfs receive -Fsuv ...Envío local (en tmux)
zpool export zbkCerrar limpiamente

4. Preparar el disco

gpart destroy -F da1
# → da1 destroyed

Borrar cualquier resto de ZFS (aunque no haya, por asegurar)

zpool labelclear -f /dev/da1 2>/dev/null

Crear tabla GPT nueva

gpart create -s gpt da1
# → da1 created

Crear partición ZFS ocupando todo el disco

gpart add -t freebsd-zfs -l backup1tb da1
# → da1p1 added

Verificar

gpart show da1
# →       40  1953525088  da1  GPT  (932G)
# →       40  1953525088    1  freebsd-zfs  (932G)

5. Crear el pool zbk

Los discos modernos suelen tener sectores de 4K, pero muchos discos USB reportan 512B. Es crítico crear el pool con ashift=12 (4096 bytes) para evitar problemas de rendimiento.

Ver ashift que ZFS detectaría por defecto

diskinfo -v da1 | grep -i "sector size"

Si dice 512, hay que forzar ashift=12 al crear el pool.

zpool create -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O relatime=on \
             -O mountpoint=none \
             zbk /dev/gpt/backup1tb

Banderas

  • ashift=12 → sectores 4K (crítico para rendimiento en discos modernos).
  • compression=lz4 → compresión ligera y rápida.
  • atime=off → no actualizar tiempo de acceso (más rápido).
  • xattr=sa → atributos extendidos en el inodo.
  • relatime=on → atime solo cuando sea útil.
  • mountpoint=none → no montar automáticamente.

Verificar

zpool status zbk
zpool list zbk
zfs list

Crear dataset destino

zfs create -o mountpoint=none zbk/tormenta
zfs list -r zbk

Salida esperada:

zbk           XXXG   XXXG    96K  none
zbk/tormenta   96K   XXXG    96K  none

Pool zbk creado correctamente:

DatoValor
Poolzbk
Tamaño928 G
Disponible899 G
Dataset destinozbk/tormenta (listo)
zroot a respaldar312 G

6. Crear snapshot del sistema

zfs snapshot -r zroot@snap-$(date +%Y%m%d)

Verificar

zfs list -t snapshot -r zroot | grep snap-$(date +%Y%m%d) | wc -l

El resultado depende del número de datasets del sistema. En tormenta actual: ~48.

Nota para el futuro: si un script creó el snapshot en un solo dataset sin usar -r, o si otro proceso lo creó antes para otro propósito, puede haber conflictos. Cuando se monte el cron para backups automáticos, usar date +%Y%m%d-%H%M%S para evitar colisiones si se ejecuta dos veces el mismo día.
zfs snapshot -r zroot@snap-$(date +%Y%m%d-%H%M%S)

7. Lanzar el envío en tmux

Entrar en tmux

tmux new -s backup_usb

Comando de envío (dentro de tmux)

zfs send -Rwcv zroot@snap-$(date +%Y%m%d) \
  | zfs receive -Fsuv -x mountpoint zbk/tormenta

Banderas explicadas

FlagSignificado
-RRecursivo: envía zroot y todos sus hijos
-wRaw: envía los bloques cifrados tal cual (necesario si hay datasets cifrados como zroot/nfsv4/secifrado)
-cCompresión nativa ZFS (lz4)
-vVerbose: muestra progreso por dataset
-FFuerza rollback en destino si hay divergencias
-sGuarda token de resume en /var/tmp/ (permite reanudar si se corta)
-uNo monta los datasets recibidos
-x mountpointNo replica los mountpoints del origen
Importante sobre -w: el dataset zroot/nfsv4/secifrado está cifrado con ZFS native encryption. Con zfs send -Rcv (sin -w) el envío falla. Siempre usar -Rwcv.

8. Cifrado: consideraciones

El flag -w envía el dataset cifrado tal cual (raw). Ventaja: funciona, conserva el cifrado, es rápido. Inconveniente: en destino el dataset también estará cifrado y necesitarás la clave para montarlo.

¿Qué se necesita para recuperarlo?

La passphrase o keyfile utilizada para cifrar zroot/nfsv4/secifrado. Sin ella, el backup es inútil.

GUARDAR LA PASSPHRASE/KEYFILE
Si se pierde la clave, se pierden los datos y el backup. Guardarla en:
  • Un gestor de contraseñas (Bitwarden, KeePass, etc.)
  • Un archivo en un USB que no sea el mismo del backup
  • Papel impreso en un lugar seguro

Comprobar qué método de cifrado se utilizó

zfs get encryption,keyformat,keylocation zroot/nfsv4/secifrado

# NAME                       PROPERTY     VALUE                        SOURCE
# zroot/nfsv4/secifrado      encryption   aes-256-gcm                  -
# zroot/nfsv4/secifrado      keyformat    raw                          -
# zroot/nfsv4/secifrado      keylocation  file:///etc/zfs/secifrado.key

Si dice keyformat=passphrase, se necesita esa passphrase.
Si dice keyformat=raw con keylocation=file:///..., es necesario ese archivo.

Ver el contenido (para copiarlo en un gestor de contraseñas)

Convertir a base64 para poder copiarlo como texto:

base64 /etc/zfs/secifrado.key

9. Salir de tmux sin matar el proceso

Ctrl+b  d

10. Monitorizar (en otra terminal)

Ver datasets llegando en tiempo real

watch -n 10 'zfs list -r zbk/tormenta | head -30'

Ver velocidad de escritura al USB

zpool iostat zbk 5

Ver espacio consumido

watch -n 30 'zfs list zbk'

11. Verificar tras el envío

Volver a la sesión tmux

tmux attach -t backup_usb

Si ya terminó, se verá el real Xm Ys del comando. Entonces:

Contar snapshots origen vs destino

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zbk/tormenta | wc -l

Deben coincidir (probablemente ~300+).

Verificar datasets replicados

zfs list -r zbk/tormenta | head -30

Espacio usado

zfs list zbk
zpool list zbk

12. Si algo falla durante el envío

¿Sigue algún proceso zfs vivo?

ps aux | grep -E "zfs (send|receive)" | grep -v grep

Si aparece algo, sigue corriendo. Esperar y dejarlo terminar.

¿En qué estado está el destino?

zfs list zbk
zfs list -r zbk/tormenta | head -20

Se verá si quedó un dataset a medias (zbk/tormenta con datos parciales).

¿Hay un token de resume guardado?

ls -la /var/tmp/ | grep -i zfs
ls -la / | grep -i zfs
El token de resume solo existe si se usó -s en el zfs receive. Si no se usó, no hay reanudación posible: hay que empezar de cero.

¿El proceso murió? Limpiar el destino parcial

zfs destroy -r zbk/tormenta
zfs create -o mountpoint=none zbk/tormenta
zfs list -r zbk

Relanzar con -s para permitir resume

tmux new -s backup_usb

Dentro de tmux:

zfs send -Rwcv zroot@snap-20260930 \
  | zfs receive -Fsuv -x mountpoint zbk/tormenta
El flag -s en zfs receive guarda un token de reanudación en /var/tmp/. Si se vuelve a cortar, se podrá reanudar con:
zfs send -t $(ls /var/tmp/zfs_*.resume 2>/dev/null | head -1)

Salir de tmux con Ctrl+b d antes de cerrar SSH. No cerrar la sesión SSH hasta que tmux esté desconectado.

13. Exportar el pool y desconectar el USB

Verificar que no hay nada escribiendo

zpool status zbk
lsof | grep zbk 2>/dev/null

Exportar limpiamente

zpool export zbk

Y por último

sync

Ya se puede retirar el cable USB.

14. Tiempo estimado

Velocidad USB312 GB
80 MB/s~1.1 h
120 MB/s~43 min
200 MB/s~26 min
400 MB/s~13 min

Con el chip ASMT USB 3.0 + disco SATA: ~20–45 min si es SSD, ~50–80 min si es HDD.

Recordatorio: para poder cerrar la sesión SSH sin que se corte el envío, primero entrar en tmux con tmux new -s backup_usb, lanzar el envío, y salir con Ctrl+b d.
Recomendación adicional: poner una etiqueta al disco físico con rotulador o adhesivo:
  • Backup Tormenta
  • snap-20260930
  • zbk pool

15. Restaurar archivos de configuración

No requiere reiniciar. Solo copia los archivos desde el snapshot.

Paso 1: Montar el snapshot

mkdir -p /mnt/snap
mount -t zfs zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026 /mnt/snap

Paso 2: Comparar qué cambió

diff /etc/pf.conf       /mnt/snap/etc/pf.conf
diff /etc/rc.conf       /mnt/snap/etc/rc.conf
diff /etc/sysctl.conf   /mnt/snap/etc/sysctl.conf
diff /boot/loader.conf  /mnt/snap/boot/loader.conf

Paso 3: Backup de los actuales

cp /etc/pf.conf       /etc/pf.conf.broken-$(date +%Y%m%d)
cp /etc/rc.conf       /etc/rc.conf.broken-$(date +%Y%m%d)
cp /etc/sysctl.conf   /etc/sysctl.conf.broken-$(date +%Y%m%d)
cp /boot/loader.conf  /boot/loader.conf.broken-$(date +%Y%m%d)

Paso 4: Restaurar desde el snapshot

cp /mnt/snap/etc/pf.conf       /etc/pf.conf
cp /mnt/snap/etc/rc.conf       /etc/rc.conf
cp /mnt/snap/etc/sysctl.conf   /etc/sysctl.conf
cp /mnt/snap/boot/loader.conf  /boot/loader.conf

Paso 5: Desmontar y probar

umount /mnt/snap
rmdir /mnt/snap

# Recargar pf (sin reiniciar)
pfctl -f /etc/pf.conf

# Ver rutas
netstat -rn

# Probar red
ping -c 3 192.168.88.1
ping -c 3 8.8.8.8
ping -c 3 google.com

Paso 6: Si funciona, reiniciar para aplicar loader.conf y sysctl.conf

shutdown -r now

16. Rollback completo

Requiere arrancar en modo monousuario. No se puede hacer con el dataset montado.

Paso 1: Crear snapshot de seguridad del estado actual

Antes de tocar nada, para poder volver si algo falla:

zfs snapshot -r zroot@before-rollback-$(date +%Y%m%d-%H%M)

Paso 2: Reiniciar en modo monousuario

shutdown -r now

En el menú de arranque de FreeBSD, pulsar 2 (Boot Single User).

Paso 3: Preparar el sistema

zfs set readonly=off zroot
zfs mount -a

Paso 4: Rollback

Esto destruye los snapshots posteriores a este (incluido el de before-rollback).
zfs rollback -R zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026

Paso 5: Salir del modo monousuario y reiniciar

exit

O directamente:

reboot

Qué se pierde con el rollback

ElementoEstado
pf.confext_if="wlan0" (vuelve atrás)
loader.confSin hw.em.eee_setting=1
sysctl.confSin dev.em.0.eee_control=0
/etc/rc.confEstado del snapshot
Archivos en /home/carlosNO se pierden (dataset separado)
Archivos en /varNO se pierden (dataset separado, si no se hace rollback ahí)
Solo afecta a zroot/ROOT/default (el sistema base). Los datos personales en zroot/home/carlos no se tocan.

17. Errores comunes a evitar

  • Usar zfs send -Rcv sin -w → falla si hay datasets cifrados.
  • Olvidar -s en zfs receive → no hay reanudación posible si se corta.
  • Cerrar la sesión SSH sin tmux → el envío muere al desconectar.
  • No guardar la clave de cifrado fuera del backup → backup inútil si se pierde.
  • Usar zfs destroy sin -n primero → riesgo de borrar snapshots con dependencias.
  • Ejecutar el script de retención sin verificar → puede borrar snapshots indiscriminadamente.

18. Checklist final

  • [ ] Disco USB identificado y preparado
  • [ ] Pool zbk creado con ashift=12
  • [ ] Dataset zbk/tormenta creado
  • [ ] Snapshot del sistema creado (zfs snapshot -r)
  • [ ] Envío lanzado dentro de tmux
  • [ ] Proceso monitorizado hasta el final
  • [ ] Verificado: snapshots origen vs destino coinciden
  • [ ] Pool exportado limpiamente (zpool export zbk)
  • [ ] USB desconectado y guardado en lugar seguro
  • [ ] Clave de cifrado guardada en al menos 2 sitios distintos
FreeBSD es genial!.

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, 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!.

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!.

jueves, 28 de octubre de 2021

Crear particiones e instalar FreeBSD 13.0 zfs UEFI

A diferencia del valor predeterminado de bsdinstall para ZFS, no establece puntos de montaje explícitos para conjuntos de datos, sino que se basa en la herencia.

Este conjunto de instrucciones configura partición freebsd-boot, una particion ESP para la instalacion UEFI, intercambio cifrado con GELI y un grupo raíz.  

Iniciar el instalador de FreeBSD

Elegir shell para el particionado manual

Limpiar disco - Esta es una operación destructiva

# gpart destroy -F ada0
ada0 destroyed

Configurar nueva tabla de partición GPT.

Antes de poder crear particiones de disco, se debe marcar el disco con el tipo de esquema de partición que utilizará, gpart create con la marca -s y el esquema, como gpt o mbr. Aquí, el disco usa el esquema GPT

# gpart create -s gpt ada0
ada0 created

Añadir particiones con etiquetas (label -l) para acceder a ellas por su nombre.

Crear partición boot para arranque Legacy (aunque no será utilizada). No puede ser mayor de 545k.

 # gpart add -t freebsd-boot -s 512k -l boot0 ada0
ada0p1 added

UEFI ESP arranque UEFI.

# gpart add -t efi -s 200M -l efi0 ada0 
ada0p2 added

ESP debe ser vfat/fat32:

# newfs_msdos -F 32 -c 1 /dev/ada0p2
/dev/gpt/efi0: 2003 sectors in 2003 FAT12 clusters (512 bytes/cluster)
BytesPerSec=512 SecPerClust=1 ResSectors=1 FATs=2 RootDirEnts=512 Sectors=2048 \
Media=0xf0 FATsecs=6 SecPerTrack=63 Heads=255 HiddenSecs=0

Partición swap

# gpart add -t freebsd-swap -l swap0 -a 1m -s 2048m ada0

Resto del disco

# gpart add -t freebsd-zfs -l zroot0 -a 1m ada0

Crear el root pool

.
# zpool create -R /mnt -o cachefile=/tmp/zpool.cache -O mountpoint=/ \
    -O atime=off -O canmount=off -O compression=on \
    zroot gpt/zroot0
# zfs create -o canmount=off -o mountpoint=none zroot/ROOT
# zfs create -o mountpoint=/ zroot/ROOT/default

Definir el conjunto de datos de arranque predeterminado para este zpool

# zpool set bootfs=zroot/ROOT/default zroot

Crear el resto de los sistemas de archivos

# zfs create -o canmount=off zroot/usr
# zfs create zroot/usr/home
# zfs create zroot/usr/local
# zfs create zroot/usr/obj
# zfs create zroot/usr/src
# zfs create zroot/usr/ports
# zfs create -o canmount=off zroot/var
# zfs create zroot/var/jail
# zfs create zroot/var/log
# zfs create zroot/var/tmp
# zfs create zroot/tmp
# zfs set setuid=off zroot/tmp
# zfs set setuid=off zroot/var
# zfs set exec=off zroot/var
# zfs set setuid=off zroot/usr/src 
# zfs set exec=off zroot/usr/src
# zfs set setuid=off zroot/usr/ports
# zfs set exec=on zroot/var/tmp

Copiar el caché de zpool

# mkdir -p /mnt/boot/zfs
# cp /tmp/zpool.cache /mnt/boot/zfs

No olvide elegir la opción shell para terminar la configuración al final de la instalación.

# exit

Elegir

 Install  

Keymap Selection

Set Hostname

Distribution Select 

Partitioning

En este punto elegir la opción:open a shell and partition by hand

# exit

Fetching Distribution Comprobing checksumArchive Extraction 

New Password

Retype New Password

Network Configuration

Would you like to configureIPv6..? No

Resolver Configuration

Select local or UTC (Greenwich Mean Time) clock

System Configuration 

System Hardening

Add User Accounts (Yes)

Final Configuration 

Exit (Apply configuration and exit installer) OK

Manual Configuration Yes

Elegir Yes para seguir con la configuración

# cat >> /boot/loader.conf<<EOF
zfs_load="YES"

zpool_cache_load="YES"
zpool_cache_name="/boot/zfs/zpool.cache"
zpool_cache_type="/boot/zfs/zpool.cache"

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

# cat >> /etc/rc.conf<<EOF
zfs_enable="YES"
zfsd_enable="YES"
EOF

# cat >> /etc/fstab<<EOF
/dev/gpt/efi0 /boot/efi0 msdosfs rw,late 0 0
/dev/swap.eli none swap sw 0 0
EOF
# mount -t devfs devfs /dev
# rm /dev/null

Crear punto de montaje y montar ESP

# mkdir /boot/efi0 
# mount -t msdosfs /dev/gpt/efi0 /boot/efi0 

UEFI con nomenclatura de reserva:

mkdir -p /boot/efi0/efi/boot
cp /boot/loader.efi /boot/efi0/efi/boot/bootx64.efi

Llegados a este punto debería estar listo.

# exit
# Reboot
# zfs create zroot/usr/home/carlos

Enlace simbólico y permisos.

# ln -s /usr/home /home
# chmod 1777 /var/tmp
# chmod 1777 /tmp

Usar git para obtener el código fuente de FreeBSD 13.0

(Si necesita construir módulos del kernel)

# pkg install git
# git clone -b releng/13.0 https://git.freebsd.org/src.git /usr/src

Clonar colección de puertos con git

# git clone https://git.freebsd.org/ports.git /usr/ports

Crear Directorios de usuario

# pkg install xdg-user-dirs
$ xdg-user-dirs-update
# cat /etc/fstab
/dev/gpt/efi0 /boot/efi0 msdosfs rw,late 2 2
/dev/swap.eli none swap sw 0 0

# cat /boot/loader.conf
security.bsd.allow_destructive_dtrace=0
cryptodev_load="YES"
zfs_load="YES"
zpool_cache_load="YES"
zpool_cache_name="/boot/zfs/zpool.cache"
zpool_cache_type="/boot/zfs/zpool.cache"

vfs.root.mountfrom="zfs:zroot/ROOT/default"
# cat /etc/rc.conf
clear_tmp_enable="YES"
syslogd_flags="-ss"
sendmail_enable="NONE"
hostname="bsdzfs"
ifconfig_ue0="DHCP"
sshd_enable="YES"
ntpd_enable="YES"
# Set dumpdev to "AUTO" to enable crash dumps, "NO" to disable
dumpdev="NO"
zfs_enable="YES"
zfsd_enable="YES"
# gpart show
=>       40  976773088  ada0  GPT  (466G)
         40       1088     1  freebsd-boot  (544K)
       1128       2048     2  efi  (1.0M)
       3176        920        - free -  (460K)
       4096    4194304     3  freebsd-swap  (2.0G)
    4198400  972574720     4  freebsd-zfs  (464G)
  976773120          8        - free -  (4.0K)
# zfs list
NAME                        USED  AVAIL     REFER  MOUNTPOINT
zroot                      1.83G   444G       96K  /
zroot/ROOT                 1011M   444G       96K  none
zroot/ROOT/default         1011M   444G     1011M  /
zroot/tmp                   104K   444G      104K  /tmp
zroot/usr                   863M   444G       96K  /usr
zroot/usr/home               96K   444G       96K  /usr/home
zroot/usr/local             191M   444G      191M  /usr/local
zroot/usr/obj                96K   444G       96K  /usr/obj
zroot/usr/ports             192K   444G       96K  /usr/ports
zroot/usr/ports/distfiles    96K   444G       96K  /usr/ports/distfiles
zroot/usr/src               672M   444G      672M  /usr/src
zroot/var                   432K   444G       96K  /var
zroot/var/jail               96K   444G       96K  /var/jail
zroot/var/log               144K   444G      144K  /var/log
zroot/var/tmp                96K   444G       96K  /var/tmp

https://wiki.freebsd.org/MasonLoringBliss/ZFSandGELIbyHAND

FreeBSD es genial!.

domingo, 24 de octubre de 2021

Actualizar zpool en FreeBSD 13.0 UEFI partition

Modos de arranque FreeBSD BIOS y UEFI

FreeBSD soporta ambos modos de arranque, pero con diferencias importantes en cómo gestiona cada uno:BIOS (modo legacy)

Gestor de arranque: Usa el bootloader tradicional de FreeBSD (boot0/boot1/boot2) o GRUB si se prefiere.

Tabla de particiones: Requiere MBR (Master Boot Record) o, alternativamente, GPT con un protective MBR y un pequeño BIOS boot partition .

Limitaciones: arranque desde discos de hasta ~2 TiB, máximo 4 particiones primarias (o extendidas).

Proceso: el BIOS lee el sector 0 del disco, carga el boot loader de FreeBSD, que luego carga el kernel ( /boot/kernel/kernel ).

UEFI

Gestor de arranque: FreeBSD instala su propio ejecutable EFI ( boot1.efi ) en la EFI System Partition (ESP), típicamente en EFI/freebsd/ .

Tabla de particiones: Requiere GPT (GUID Partition Table). Es el esquema recomendado para instalaciones modernas.

Ventajas: soporte para discos mayores a 2 TiB, arranque más rápido, Secure Boot (con limitaciones), y mejor integración con firmware moderno.

Proceso: el firmware UEFI ejecuta directamente boot1.efi , que carga el kernel sin necesidad de los intermediarios del modo BIOS.

Después de actualizar el pool el código de inicio del disco duro también se debe actualizar, de manera que se pueda iniciar el sistema sin problemas.

El instalador de FreeBSD 13.0 con zfs elige una partición de arranque BIOS tradicional freebsd-boot y una partición UEFI efi.

gpart show
          40  1953525088  ada0  GPT  (932G)
          40      532480    1   efi  (260M)
      532520        1024    2   freebsd-boot  (512K)
      533544         984        - free -  (492K)
      534528     4194304    3   freebsd-swap  (2.0G)
     4728832  1948794880    4   freebsd-zfs  (929G)
  1953523712        1416        - free -  (708K)
 zpool upgrade -a
This system supports ZFS pool feature flags.

Enabled the following features on 'zroot': allocation_classes

If you boot from pool 'zroot', don't forget to update boot code. Assuming you use GPT partitioning and da0 is your boot disk the following command will do it:

 gpart bootcode -b /boot/pmbr -p /boot/gptzfsboot -i 2 da0

Si el arranque de su sistema es UEFI al ejecutar el código anterior y hacer un reboot el sistema no se iniciará.

Para actualizar una partición EFI:

 mount -t msdosfs /dev/ada0p1 /mnt
 mv /mnt/boot/efi0/efi/boot/bootx64.efi /mnt/efi/boot/bootx64.efi-old
 cp /boot/loader.efi /mnt/boot/efi0/efi/boot/bootx64.efi
 umount /mnt
 reboot
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, 10 de junio de 2019

Instalar Arch Linux UEFI

Instalar Arch Linux 2019 modo UEFI (Unified Extensible Firmware Interface) y tabla de particiones GPT necesaria para arrancar en modo UEFI desde la BIOS.



Descargar Arch Linux y grabar la instantánea de Arch Linux en una unidad USB (unidad flash). Arrancar el sistema desde el dispositivo USB cambiando el orden de arranque desde la BIOS o utilizando la tecla F12 o F9 (dependiendo de su sistema).

Al finalizar el proceso de arranque lo primero es comprobar la conexión a Internet:
root@archiso ~ # ping -c3 www.freebsd.org

Si en lugar de conexión por cable nos conectarnos mediante wifi Arch Linux pone a su disposición la herramienta wifi-menu.
root@archiso ~ # wifi-menu

Comprobamos con fdisk -l los discos del sistema disponible y las particiones creadas.

El particionado del disco /dev/sda (SSD) puede realizarse con diferentes herramientas en este caso se utiliza cfdisk.

root@archiso ~ # cfdisk /dev/sda
En el cuadro de diálogo (Select label type) se selecciona el tipo gpt.
Luego se crea una nueva partición de 512M (Partition size) partición 1 del tipo EFI system.
A continuación una segunda partición de 30G del tipo ext4
Por último una cuarta partición con el resto del espacio libre del disco tipo ext4. Se desplaza hasta Write y sale con Quit. Tendremos este esquema de particionado:

root@archiso ~ # fdisk -l
Disposit.  Comienzo     Final Sectores Tamaño Tipo
/dev/sda1      2048   1050623  1048576   512M Sistema EFI
/dev/sda2   1050624  63965183 62914560    30G Sistema de ficheros de Linux
/dev/sda3  63965184 117231374 53266191  25,4G Sistema de ficheros de Linux

Crear los sistemas de ficheros
root@archiso ~ # mkfs.fat -F32 /dev/sda1
root@archiso ~ # mkfs.ext4 /dev/sda2
root@archiso ~ # mkfs.ext4 /dev/sda3

Montar las particiones

root@archiso ~ # mount /dev/sda2 /mnt
root@archiso ~ # mkdir /mnt/home
root@archiso ~ # mount /dev/sda3 /mnt/home
root@archiso ~ # 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 /home

Elegir lista de mirror

# pacman -Sy
# pacman -S reflector
# reflector --verbose -l 5 --sort rate --save /etc/pacman.d/mirrorlist

sda1 es nuestra partición UEFI, se usará más tarde. El comando pacstrap con la opción -i (ver la información) instala los paquetes base base-devel dentro de /mnt

root@archiso ~ # pacstrap -i /mnt base base-devel

El comando genfstab con las opciónes U (use UUIDs) y p (Excluye pseudofs montados)

root@archiso ~ # genfstab -U -p /mnt >> /mnt/etc/fstab

Se necesita chroot a mnt para entrar en el nuevo sistema instalado

root@archiso ~ # arch-chroot /mnt /bin/bash

Establecer la locale

root@archiso ~ # nano /etc/locale.gen descomentar la siguiente línea.
es_ES.UTF-8 UTF-8

Generar la locale
root@archiso ~ # locale-gen

Enlace a hora locale dentro de su zone

root@archiso ~ # ln -sf /usr/share/zoneinfo/Europe/Madrid /etc/localtime

Enlace a hora locale dentro de su time zone
root@archiso ~ # hwclock --systohc --utc

root@archiso ~ # echo archlinux > /etc/hostname

root@archiso ~ # nano /etc/hosts
127.0.0.1 localhost.localdomain archlinux.unix.bcn archlinux

Instalar networkmanager
root@archiso ~ # pacman -S networkmanager

Activar la conexión a Internet cableada
(wired) durante el arranque del sistema.
root@archiso ~ # systemctl enable NetworkManager

Establecer la contraseña de root
root@archiso ~ # passwd

Archivo /etc/pacman.conf descomentar:

 [multilib]
Include = /etc/pacman.d/mirrorlist

El siguiente paso donde se instala el group bootloader
es el más relevante  en el proceso de instalaciónn de UEFI:

1.- Instalar los paquetes necesarios

root@archiso ~ # pacman -S grub efibootmgr

2.- Crear el directorio efi y montar la partición efi sda1 a este directorio

root@archiso ~ # mkdir /boot/efi
root@archiso ~ # mount /dev/sda1 /boot/efi

Comprobar el punto de montaje con lsblk
root@archiso ~ # lsblk

3.- Iniciar la instalación de grub-install

root@archiso ~ # grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi

4.- Se necesita generar el archivo de configuración para el grub bootloader instalado.
root@archiso ~ # grub-mkconfig -o /boot/grub/grub.cfg

5.- Configuraión adicional.

root@archiso ~ # mkdir -p /boot/efi/EFI/BOOT
root@archiso ~ # cp /boot/efi/EFI/GRUB/grubx64.efi /boot/efi/EFI/BOOT/BOOTX64.EFI

BOOTX64.EFI es el bootloader reconocido por efi en caso de fallo durante el arranque del sistema.

6.- Crear script de inicio para efi /boot/efi/startup.nsh

root@archiso ~ # nano /boot/efi/startup.nsh
bcf boot add 1 fs0:\EFI\GRUB\grubx64.efi "Grub bootloader"
exit

Identificar los gráficos del sistema# lspci | grep VGA

Entorno gráfico
# pacman -S xorg-server xorg-xinit
# pacman -S xf86-video-intel
# pacman -S mesa mesa-demos

Para una computadora portátil o netbook necesita los controladores para el soporte de entrada del panel táctil
# pacman -S xf86-input-synaptics

Crear usuario
# useradd -m -g users -G audio,storage,optical,video,wheel -s /bin/bash carles

Montar las USB, Micro SD
# pacman -S gvfs

Montar iphone
# pacman -S gvfs-afc

Montar dispositivo android
# pacman -S gvfs-mtp

Crea las carpetas por defecto del usuario automáticamente
# pacman -S xdg-user-dirs

Instalar deepin
# pacman -S deepin-extra

Editar el archivo /etc/lightdm/lightdm.conf
# nano /etc/lightdm/lightdm.conf

Buscar la siguiente linea (Ctrl + W)
#greeter-session=example-gtk-gnome

Descomente y cambie como se muestra abajo
greeter-session=lightdm-deepin-greeter

Luego habilite el administrador de inicio de sesión de lightdm para que se inicie en el arranque.
# systemctl enable lightdm.service -f

El archivo .xinitrc se crea en el directorio del usuario sin privilegios
$ nano /home/carles/.xinitrc
exec startdde

Cambiar los permisos del archivo
# chown carles:users /home/carles/.xinitrc

Salir del entorno chroot
# exit

# exit

Desmontar las particiones
# umount /mnt/home
# umount /mnt/boot/efi
# umount /mnt

Reiniciar el sistema
#reboot

Instalar ifplugd. Un demonio que activa - desactiva las interfaces de red al insertar - quitar el cable.
# pacman -S ifplugd

Si hay algún problema como parpadeo o pantalla en blanco después de instalar Deepin, instalar lightdm-deepin-greeter usando el siguiente comando

# pacman -S lightdm-deepin-greeter

Y reinstalar deepin:

# pacman -Syu deepin

# reboot


Se prescinde de la partición Swap
Un portátil con 8 GB de memoria RAM y un diso duro SSD Intel de 60 GB. Los datos se guardan en el servidor de archivos de la LAN por lo que no se necesita mayor capacidad de almacenamiento.



OpenBSD es genial!.