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

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 checksum

Archive Extraction 

New Password

Retype New Password

Network Configuration

Would you like to configure
IPv6..? 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!.

Actualizar zpool en FreeBSD 13.0 UEFI partition

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

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

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

Particionar instalar Arch Linux UEFI 2017 KDE

Arrancar el instalador en modo UEFI

Comprobar que está conectado a la red
# ping -c 2 www.freebsd.org

Instalar fuente terminus-font y activar durante la instalación

# pacman -S terminus-font
# pacman -Ql terminus-font
# setfont ter-v32n

Q = Consulta a la basde de datos de paquetes
l = listar todos los archivos pertenecientes a un paquete

Listar discos (dispositivos de bloque)

# lsblk

parted - linea de comando

# parted /dev/sda      # abrir parted y seleccionar el disco
# mklabel gpt          # configrurar disco GPT

Particionar disco

# mkpart ESP 1MiB 513MiB          # crear /boot 512MB /dev/sda1
# set 1 boot on                   # marcar /boot como partición de arranque
# mkpart linux-swap 513MiB 2.5GiB # crear swap 2.5GB (8GB RAM)
# mkpart ext4 2.5GiB 50GiB        # partición raiz /
# mkpart ext4 50GiB 100%          # resto espacio libre /home

salir parted

Crear los sistemas de ficheros

    mkfs.vfat /dev/sda1 # EF00
    mkfs.ext4 /dev/sda2 # 8300
    mkfs.ext4 /dev/sda4 # 8300

Activar partición swap

    mkswap /dev/sda3 # 8200
    swapon /dev/sda3

Montar particiones

    mount /dev/sda2 /mnt
    mkdir -p /mnt/boot
    mount /dev/sda1 /mnt/boot
    mkdir -p /mnt/home
    mount /dev/sda4 /mnt/home

Elegir lista de mirror

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

Install los paquetes básicos arch linux

# pacstrap -i /mnt base base-devel

Configurar fstab

# genfstab -U -p /mnt >> /mnt/etc/fstab

Entorno chroot

# arch-chroot /mnt

Configurar lenguaje y ubicación

nano /etc/locale.gen # descomentar

es_ES.UTF-8 UTF-8  
es_ES ISO-8859-1  
es_ES@euro ISO-8859-15
# locale-gen
# export LANG=es_ES.UTF8-8 > /etc/locale.conf
# export LC_TIME=es_ES.UTF-8 >> /etc/locale.conf

Zona horaria

# ln -s /usr/share/zoneinfo/Europe/Madrid > /etc/localtime

# hwclock --systohc --utc

# pacman -Sy

Nombre de host

# echo archlinux > /etc/hostname

Contraseña de root y crear un nuevo usuario

# passwd

# pacman -S sudo bash-completion

# useradd -m -s /bin/bash -g users -G wheel,storage,power carles

# passwd carles

Permitir a los usuarios del grupo wheel tareas administrativas con sudo

# visudo
Descomentar la linea %wheel% ALL=(ALL)

Consola en español

# echo KEYMAP=es >> /etc/vconsole.conf 
# echo FONT >> /etc/vconsole.conf
# echo FONT_MAP= >> /etc/vconsole.conf

# mkinitcpio -p linux

Instalar y Configurar bootloader

# bootctl --path=/boot install

Opciones por defecto bootloader

# nano /boot/loader/loader.conf

default arch
timeout 0 # segundos de espera Elegir kernel/OS
editor  0 # segundos de espera para editar parametros del kernel

Buscar PARTUUID de la partición raiz y crear una entrada en bootloader

# blkid -s PARTUUID -o value /dev/sda2 >> /boot/loader/entries/arch.conf

64f369f2-608a-4f5c-bb4c-27d7146ef482

Edite ese archivo

# nano /boot/loader/entries/arch.conf

title   Arch LInux
linux   /vmlinuz-linux
initrd  /initramfs-linux.img
options root=PARTUUID=64f369f2-608a-4f5c-bb4c-27d7146ef482 rw

Recrear Initramfs

# mkinitcpio -p linux

Actualizar el bootloader

# bootctl update

Salir del entorno chroot

# exit

Desmontar particiones

# umount -R /mnt

# reboot

Continuar con la instalación

username root
passwd

# ip addr

# systemctl enable dhcpcd

# systemctl start dhcpcd

# ping -c 2 www.freebsd.org

# pacman -S xorg

# pacman -S xterm xorg-xclock xorg-twm xorg-xinit xorg-server-utils

# pacman -S plasma kdebase

# pacman -S ttf-freefont ttf-linux-libertine-g artwiz-fonts

# pacman -S ttf-ubuntu-font-family cantarell-fonts freetype2

# pacman -S ttf-droid ttf-linux-libertine ttf-liberation

# pacman -S ttf-fira-mono ttf-fira-sans ttf-gentium fontsproto

# pacman -S ttf-dejavu noto-fonts font-bitstream-speedo

# systemctl enable sddm

# reboot

Intercambiar teclado es y us con la combinación de teclas alt-shift

# nano /etc/X11/xorg.conf.d/10-keyboard.conf

Section "InputClass"
        Identifier "system-keyboard"
        MatchIsKeyboard "on"
        Option "XkbLayout"  "es,us"
        Option "XkbModel"   "pc104"
        Option "XkbVariant" "deadtilde,"
        Option "XkbOptions" "grp:alt_shift_toggle"
EndSection

# pacman -S libreoffice libreoffice-es

# pacman -S kdegraphics-okular firefox firefox-i18n-es-es

# pacman -S vlc gimp k3b kaffeine dia spectacle

VPN - PIA

Tunel VPN - Private Internet Access

Instalar openvpn

# pacman -S openvpn

Crear el directorio

# mkdir -p /etc/private-internet-access
# cd /etc/private-internet-access

Descargar el archivo openvpn.zip

# wget https://www.privateinternetaccess.com/openvpn/openvpn.zip
# unzip openvpn.zip

Copiar los archivos necesarios

# cd /etc/openvpn/
# cp /etc/private-internet-access/ca.rsa.2048.crt . # no olvide el punto final
# cp /etc/private-internet-access/crl.rsa.2048.pem .

El archivo que contiene el nombre de usuario y contraseña de PIA

# touch password.conf
# vi password.conf
username
password

# chown root:root /etc/openvpn/password.conf
# chmod 600 /etc/openvpn/password.conf

El archivo de configuración PIA

# cp /etc/private-internet-access/France.ovpn /etc/openvpn/pia_vpn.con
# nano /etc/openvpn/pia_vpn.conf

client
dev tun
proto udp4
remote france.privateinternetaccess.com 1198
resolv-retry infinite
nobind
persist-key
persist-tun
cipher aes-128-cbc
auth sha1
tls-client
remote-cert-tls server
auth-user-pass
comp-lzo
verb 1
reneg-sec 0
crl-verify /etc/openvpn/crl.rsa.2048.pem
ca /etc/openvpn/ca.rsa.2048.crt
disable-occ
auth-user-pass /etc/openvpn/password.conf
auth-nocache

Llegados a este punto vamos a comprobar openvpn

# openvpn --config /etc/openvpn/pia_vpn.conf

Crear un script de conexión:

# cd /home/carles
# vim openvpn-pia.sh
###################################
#!/bin/bash
openvpn --config /etc/openvpn/pia_vpn.conf > /dev/null 2>&1 &
###################################

Establecer permisos de ejecución

# chmod +x openvpn-pia.sh

Ejecutar el script
# ./openvpn-pia.sh

# ip addr

Como conectarse usando NetworkManager:

Haga clic derecho en el icono de NetworkManager en la bandeja del sistema
y clic en Configurar conexiones de red
luego haz clic en Agregar (Add)
elige la opción Importar VPN ...
vaya a /etc/openvpn/pia_vpn.conf (nuestro archivo de configuración)
ahora haga clic en Abrir
puerta de enlace (gateway), solo el nombre de dominio debe estar en esta casilla.
para el nombre de usuario, escriba su nombre de usuario p7654321
para la contraseña, escriba la contraseña que acompaña a su nombre de usuario V5thzg8X4C
luego haga clic en Avanzado
establecer puerto de la puerta de enlace y configurarelo en 1198
haga clic en la pestaña Seguridad
establecer el cifrado: a AES-128-CBC
establecer la autenticación HMAC: a SHA-1
haga clic en Aceptar y clic en Aceptar nuevamente.

Actualizar todo el sistema
# pacman -Su

Portátil con dos discos duros ssd, (Intel sata3 60GB y Samsumg EVO sata3 120GB) y dos S.O. instalados, FreeBSD 11 y Arch LInux 2017. Desde la BIOS elijo con cual arrancar. El segundo disdo duro (instalado con un adaptador CADDY) en el lugar reservado a la unidad óptica (DVD).

Listar discos (dispositivos de bloque)

# lsblk

NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:16   0 111,8G  0 disk 
├─sda1   8:17   0   512M  0 part /boot
├─sda2   8:18   0  49,5G  0 part /
├─sda3   8:19   0   2,5G  0 part [SWAP]
└─sda4   8:20   0  59,3G  0 part /home
sdb      8:0    0  55,9G  0 disk 
├─sdb1   8:1    0   512K  0 part 
├─sdb2   8:2    0    53G  0 part 
└─sdb3   8:3    0   2,8G  0 part 

# pacman -S parted
# parted /dev/sda

Model: ATA Samsung SSD 840 (scsi)
Disk /dev/sda: 120GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags: 

Numero  Inicio  Fin     Tamaño  Sistema de ficheros  Nombre  Banderas
 1      1049kB  538MB   537MB   fat32                        arranque, esp
 2      538MB   53,7GB  53,1GB  ext4
 3      53,7GB  56,4GB  2684MB  linux-swap(v1)
 4      56,4GB  120GB   63,7GB  ext4

Ayuda parted

 (parted) m                                                                
  align-check TYPE N                        check partition N for TYPE(min|opt) alignment
  help [COMMAND]                           print general help, or help on COMMAND
  mklabel,mktable LABEL-TYPE               create a new disklabel (partition table)
  mkpart TIPO-PART [TIPO-SF] INICIO FIN     crea una partición
  name NUMBER NAME                         name partition NUMBER as NAME
  print [devices|free|list,all|NUMBER]     display the partition table, available devices, free
    space, all found partitions, or a particular partition
  quit                                     exit program
  rescue START END                         rescue a lost partition near START and END
  resizepart NUMBER END                    resize partition NUMBER
  rm NUMBER                                delete partition NUMBER
  select DEVICE                            choose the device to edit
  disk_set FLAG STATE                      change the FLAG on selected device
  disk_toggle [FLAG]                       toggle the state of FLAG on selected device
  set NUMBER FLAG STATE                    change the FLAG on partition NUMBER
  toggle [NUMBER [FLAG]]                   toggle the state of FLAG on partition NUMBER
  unit UNIT                                set the default unit to UNIT
  version                                  display the version number and copyright information
        of GNU Parted

FreeBSD es genial!.

Instalar Arch Linux 64 bits UEFI KDE Plasma

Instalar Arch Linux x86_64 UEFI KDE Plasma en una máquina virtual.

Nota: En una instalación en disco, la partición raíz no debería ser menor de 50 Gb. Por lo demás el proceso es el mismo.  Con el tamaño actual de los discos esto no es un problema.

Cargar teclado español

# loadkeys es

Listar los dispositivos de bloque del sistema, discos duros, cd-rom, unidades flash, etc.

# lsblk

Particionado con cfdisk

Creamos una primera partición de 20G que será nuestra partición de sitema (root). de tipo linux filesystems.

# cfdisk /dev/sda
   gpt
new 20G  /dev/sda1
type linux filesystems

new 512M /dev/sda2
type Efi Systems

new 4G /dev/sda3
type linux-swap 

new 29G /dev/sda4
type linux filesystems

write quit

# lsblk

Vamos a crear los Sistema de Ficheros y montar particiones

# mkfs.ext4 /dev/sda1

# mount /dev/sda1 /mnt

# mkfs.vfat /dev/sda2

# mkdir -p /mnt/boot/efi

# mount /dev/sda2 /mnt/boot/efi

# mkswap /dev/sda3

# swapon /dev/sda3

# mkfs.ext4 /dev/sda4

# mkdir /mnt/home

# mount /dev/sda4 /mnt/home

# pacstrap /mnt base base-devel grub efibootmgr

# genfstab -U -p /mnt >> /mnt/etc/fstab

# cat /mnt/etc/fstab

Entrar al entorno de instalación

# arch-chroot /mnt /bin/bash

# nano /etc/locale.gen
 es_ES.UTF-8 UTF-8
 es_ES ISO-8859-1

# locale-gen

# echo LANG=es_ES.UTF8-8 > /etc/locale.conf

# echo KEYMAP=es > /etc/vconsole.conf

# ln -sf /usr/share/zoneinfo/Europe/Madrid > /etc/localtime

# echo archlinux > /etc/hostname

# mkinitcpio -p linux

# passwd root

Usuario no priveligiado

# useradd -m -g users -G wheel -s /bin/bash carles

# passwd carles

# grub-mkconfig -o /boot/grub/grub.cfg

# grub-install /dev/sda

# umount /mnt -R

# exit

# exit

# reboot

# ip addr

# systemctl enable dhcpcd

# systemctl start dhcpcd

# ping -c 2 www.freebsd.org

# pacman -S xorg

# pacman -S xterm xorg-xclock xorg-twm xorg-xinit xorg-server-utils

# pacman -S plasma kdebase

# pacman -S ttf-freefont ttf-linux-libertine-g artwiz-fonts

# pacman -S ttf-ubuntu-font-family cantarell-fonts freetype2

# pacman -S ttf-droid ttf-linux-libertine ttf-liberation

# pacman -S ttf-fira-mono ttf-fira-sans ttf-gentium fontsproto

# pacman -S ttf-dejavu noto-fonts font-bitstream-speedo

# systemctl enable sddm

# reboot

Intercambiar teclado es y us con la combinación de teclas alt-shift

$ cat /etc/X11/xorg.conf.d/10-keyboard.conf

Section "InputClass"
        Identifier "system-keyboard"
        MatchIsKeyboard "on"
        Option "XkbLayout"  "es,us"
        Option "XkbModel"   "pc104"
        Option "XkbVariant" "deadtilde,"
        Option "XkbOptions" "grp:alt_shift_toggle"
EndSection

# pacman -S libreoffice libreoffice-es

# pacman -S kdegraphics-okular firefox firefox-i18n-es-es

# pacman -S vlc gimp k3b kaffeine gparted spectacle


Unix es genial!.

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

Alinear particiones linux

Particiones alineadas

Después de ejecutar fdisk -l aparece un mensaje similar a este:

Disk /dev/sda: 640.1 GB, 640135028736 bytes
255 heads, 63 sectors/track, 77825 cylinders, total 1250263728 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 byes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x0000e1f0

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *          63       96388       48163+  83  Linux
Partition 1 does not start on physical sector boundary.
/dev/sda2           96389      594404      249007+  82  Linux Swap
Partition 2 does not start on physical sector boundary.
/dev/sda3          594405    40596254    20000925   83  Linux
Partition 3 does not start on physical sector boundary.
/dev/sda4        40596255  1250263727   604833736+  83  Linux
Partition 4 does not start on physical sector boundary
....

Todos los sectores donde empiezan las particiones deben ser múltiplo de 8. Caso contrario, está mal alieada la partición o particiones.

Fdisk en versiones anteriores de modo predeterminado gestiona los tamaños de las particiones sin alinear al tamaño del sector. Herramientas modernas de particionado utilizan libparted > 2.1 que de forma automática realizan alineamiento compatible 1Mb.

Las nuevas unidades de sectores 4096 bytes

Logical block size: 512 bytes
Physical block size: 4096 bytes

Alinear particiones pasa por reparticionar el disco duro y este proceso es posible realizarlo en Linux sin perder un solo dato. Utilizando un disco externo de 120Gb montado en /media/recuperacion copiar todos los datos de la partición de datos:

# cp -R /media/datos/* /media/recuperacion/

Características:
Disco duro 500 GB 9 particiones distribuidas de la manera siguiente. Las particiones sda8 de datos y sda9 tmp se crearán despues de recuperar el sistema:

$ ls -l /dev/disk/by-label

lrwxrwxrwx 1 root root 10 jul 31 10:12 datos -> ../../sda8
lrwxrwxrwx 1 root root 10 jul 31 10:12 gentoob -> ../../sda1
lrwxrwxrwx 1 root root 10 jul 31 08:10 gentooh -> ../../sda7
lrwxrwxrwx 1 root root 10 jul 31 08:10 gentoor -> ../../sda3
lrwxrwxrwx 1 root root 10 jul 31 08:10 gentoot -> ../../sda9
lrwxrwxrwx 1 root root 10 jul 31 10:12 ubuntuh -> ../../sda6
lrwxrwxrwx 1 root root 10 jul 31 10:12 ubuntur -> ../../sda2

Desde la instalación de gentoo se crean y montan los directorios ubuntur y ubuntuh:
# mkdir /media/ubuntur
# mkdir /media/ubuntuh
# mount -v -t ext3 /dev/sda2 /media/ubuntur
# mount -v -t ext3 /dev/sda6 /media/ubuntuh
# mkdir /media/recuperacion/ubuntu

Entrar en los directorios y realizar los backups:
# cd /media/ubuntur
# tar czvf /media/recuperacion/ubuntu/ubuntu-raiz.tar.gz *
# cd ..
# cd /media/ubuntuh
# tar czvf /media/recuperacion/ubuntu/ubuntu-home.tar.gz *
# cd ..

Al finalizar los backups desmontar las particiones
# umount /media/ubuntuh
# umount /media/ubuntur

Reiniciar y desde la instalación ubuntu realizar los mismos pasos:
Crear directorios y montarlos:
# mkdir /media/gentoob
# mkdir /media/gentoor
# mkdir /media/gentooh
# mount /dev/sda1 /media/gentoob
# mount /dev/sda3 /media/gentoor
# mount /dev/sda7 /media/gentooh
# mkdir /media/recuperacion/gentoo

Realizar los backup
# cd /media/gentoob
# tar czvf /media/recuperacion/gentoo/gentoo-boot.tar.gz *
# cd ..
# cd /media/gentoor
# tar czvf /media/recuperacion/gentoo/gentoo-raiz.tar.gz *
# cd ..
# cd /media/gentooh
# tar czvf /media/recuperacion/gentoo/gentoo-home.tar.gz *

Desmontar particiones
# umount /media/gentoob /media/gentoor /media/gentooh

Realizado el backup de las particiones abrir gparted y copiar el tamaño aproximado de las particiones:

sda1 ext2 97 Mb
sda2 ext3 25 GB
sda3 ext3 25 GB
sda4 extended 415 Gb
sda5 swap 2 GB
sda6 ext3 20 Gb
sda7 ext3 20 Gb
sda8 ext3 200 Gb
sda9 reiserfs 8 Gb
sin asignar 165 Gb

Reiniciar con un livecd, en este caso el livedvd gentoo linux 13.0
Después de la carga del sistema utilizando fdisk particionar el disco. La versión incluida en el mencionado livedvd inicia por defecto desde 2048 bytes. Versiones anteriores empiezan desde 63 bytes en cuyo caso no se acepta el valor por defecto y se sustituye por 64 bytes.

Crear, formatear particiones, hacer sda1 arrancable. Primero eliminar todas las particiones.
# fdisk /dev/sda

Crear las particiones utilizando fdisk

Crear los sistemas de ficheros

Crear e inicializar swap.

# mkswap /dev/sda5

# swapon /dev/sda5

Conmutar el indicador de iniciable.

Abrir un terminal y pasarse a root:
# sudo su

Restaurar particiones:
formatear partición, crear directorios y montarlos
# mkfs.ext2 /dev/sda1
# mkdir /media/{gentoob,gentoor,gentooh,ubuntur,ubuntuh}
# mount -t ext2 /dev/sda1 /media/gentoob
# cd /media/gentoob
# tar xzvf /media/recuperacion/gentoo/gentoo-boot.tar.gz
# mkfs.ext3 /dev/sda2
# mount /dev/sda2 /media/ubuntur
# cd /media/ubuntur
# tar xzvf /media/recuperacion/ubuntu/ubuntu-raiz.tar.gz
# mkfs.ext3 /dev/sda3
# mount /dev/sda3 /media/gentoor
# cd /media/gentoor
# tar xzvf /media/recuperacion/gentoo/gentoo-raiz.tar.gz
# cd ..
# mkfs.ext3 /dev/sda6
# mount /dev/sda6 /media/ubuntuh
# cd /media/ubuntuh
# tar xzvf /media/recuperacion/ubuntu/ubuntu-home.tar.gz
# cd ..
# mkfs.ext3 /dev/sda7
# mount /dev/sda7 /media/gentooh
# cd /media/gentooh
# tar xzvf /media/recuperacion/gentoo/gentoo-home.tar.gz
# cd ..

Desmontar particiones:
# umount /media/gentoob /media/gentooh /media/gentoor

Reinstalar grub y cambiar los uuid para ubuntu en los archivos /boot/grub/menu.lst y /etc/fstab.

# mount -v -t ext2 /dev/sda1 /media/gentoor/boot
# mount -v -t ext3 /dev/sda7 /media/gentoor/home

Montar el sistema de ficheros /proc para permitir a la instalación utilizar la información proporcionada por el kernel incluso dentro del chroot y montar de forma transparente el sistema de ficheros /dev.

# mount -t proc none /media/gentoor/proc
# mount -o bind /dev /media/gentoor/dev

Entrar en el nuevo entorno de instalación chrooting:
# chroot /media/gentoor /bin/bash
# env-update
>>> Regenerating /etc/ld.so.cache...
# source /etc/profile
# export PS1="(chroot) $PS1"

Actualizar /etc/mtab que contiene la información relativa a todos los ficheros montados:
# grep -v rootfs /proc/mounts > /etc/mtab

Instalar grub:
# grub-install --no-floppy /dev/sda

Salir del chroot y reiniciar
# exit
# umount /media/gentoor/boot /media/gentoor/home
# umount /media/gentoor/proc /media/gentoor/dev
# umount /media/gentoor
# reboot

Crear el sistema de ficheros reiserfs para la partición tmp se puede realizar una vez iniciado el sistema. En Gentoo con la utilidad reiserfsprogs. Comentar esta linea en /etc/fstab y descomentarla despues de crear el sistema de fichero:

# /dev/sda9 /tmp reiserfs notail,noatime,nodev,nosuid,noexec 0 0

Creo el sistema de ficheros reiserfs para particion tmp:
# emerge reiserfsprogs
# mkreiserfs -f --l "gentoot" /dev/sda9

Utilizar gparted para crear la particion de datos. Crear directorio /media/datos y agregar entrada al archivo /etc/fstab
# vi /etc/fstab
/dev/sda8 /media/datos ext3  users,defaults,nodev,nosuid 0 2

# mount -a

Disposit. Inicio    Comienzo      Fin      Bloques  Id  Sistema
/dev/sda1   *        2048      200703       99328   83  Linux
/dev/sda2          200704    52629503    26214400   83  Linux
/dev/sda3        52629504   105058303    26214400   83  Linux
/dev/sda4       105058304   976773167   435857432    5  Extendida
/dev/sda5       105060352   109254655     2097152   83  Linux
/dev/sda6       109256704   151199743    20971520   83  Linux
/dev/sda7       151201792   193144831    20971520   83  Linux
/dev/sda8       193146880   617873407   212363264   83  Linux
/dev/sda9       617875456   634652671     8388608   83  Linux

Linux es genial!.