Busindre

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
===== Guía rápida y completa de LVM (Logical Volume Manager)=====

**Grupos de volúmenes (VG)**: es la parte superior de la LVM. Es la "caja" en la que tenemos nuestros volúmenes lógicos (LV) y nuestros volúmenes físicos (PV). Se puede ver como una unidad administrativa en la que se engloban nuestros recursos. Hay que hacer notar que mientras un PV no se añada al VG, no podemos comenzar a usarlo.

**Volúmenes físicos (PV)**: Son los discos / particiones con sistema de archivos LVM. Se puede usar cualquier dispositivo de bloques.

**Volúmenes lógicos (LV)**: Es el equivalente a una partición en un sistema tradicional. El LV es visible como un dispositivo estándar de bloques, por lo que puede contener un sistema de archivos (por ejemplo /home).


**Áreas / extensiones físicas (PE)**: Los PV se dividen en bloques de datos conocidos como Áreas Físicas (PE), estas áreas físicas tienen todas el mismo tamaño dentro del Grupo de Volumen (VG) al que pertenecen. 4MB. Cada Área Física tiene un identificador que es único dentro del Volumen Físico (PV) al que pertenece.

**Las Áreas / extensiones Lógicas (LE)**: No es más que una forma de indicar que Áreas Físicas (PE) forman un Volumen Lógico (LV).  Son necesarias porque los identificadores de las Áreas Físicas (PE) sólo son únicos dentro del PV al que pertenecen, pudiendo repetirse en el Volumen Lógico (VG), las Áreas Lógicas (LE) sirven precisamente para solventar este problema, existiendo un mapeado 1:1 entre un Área Lógica (LE) y un Área Física (PE) de un Volumen Físico (PV).

**Lectura recomendada**: [[https://access.redhat.com/documentation/es-ES/Red_Hat_Enterprise_Linux/5/html/Logical_Volume_Manager_Administration/index.html| Red Hat (Logical Volume Manager Administration)]]
==== Crear dos dispositivos de bloque usando loopback ====

Para practicar sin usar discos / memorias físicas crearemos dispositivos de bloque (ficheros loop).

<code bash>
dd if=/dev/zero of=fichero0 bs=1M count=100
dd if=/dev/zero of=fichero1 bs=1M count=100
losetup /dev/loop1 fichero1
losetup /dev/loop0 fichero0
</code>

NOTA: Desactivar completamente un punto de acceso montado mediante ficheros loop. En caso contrario si se quiere reutilizar Linux dirá que ya están en uso y por lo tanto ocupado.
<code bash>umount /dev/loop0
losetup -d /dev/loop0</code>

==== Inicializar los dispositivos ====

Crea un área de descriptor de grupo de volumen (VGDA) al principio de los discos / dispositivos de bloque. Se perderán los datos contenidos en dichos dispositivos.

<code bash>
pvcreate /dev/loop0
pvcreate /dev/loop1
</code>

==== Crear un grupo de volumen====

En LVM, el concepto de grupo de volúmenes (VG) incluye a varios volúmenes lógicos y/o físicos. Podemos crear un VG a partir de los dos dispositivos físicos creados anteriormente.

<code bash>
vgcreate mi_vg /dev/loop0 /dev/loop1
</code>

==== Activando/ Desactivando los VG ====

El comando //vgchange// puede cambiar varios atributos de los VG, su función principal es activarlos y desactivarlos (mediante el parámetro -a). Sólo cuando un VG está activo, se puede acceder a los volumenes lógicos que contiene. Si está desactivado (n) el VG, puede activarlo (y) de la siguiente manera:

<code bash>
vgchange -a y mi_vg
</code>

Si estamos utilizando ficheros de loopback, necesitamos volver a crear los dispositivos de bloque

<code bash>
losetup /dev/loop0 fichero0
losetup /dev/loop1 fichero1
vgchange -a y prueba_vg
</code>


==== Eliminar un VG ====

No debe tener LV en su interior y primero se debe desactivar.

<code bash>
vgchange -a n my_volume_group
vgremove mi_vg
</code>

NOTA: Asegúrate de que el volumen físico no está siendo usado por ningún volumen lógico usando el comando '//pvdisplay//'.  Si el volumen físico está todavía en uso tendrás que migrar los datos a otro volumen físico usando //pvmove//.


==== Eliminar un LV ==== 

No tiene que estar montado para poder ser eliminado.

<code bash>
lvremove /dev/prueba_vg/congelado
</code>

Información sobre los PV y los LV. 

<code bash>
pvdisplay
lvdisplay
</code>

Migrar los datos a otro PV para vaciar de contenido un determinado PV.

<code bash>
# Sintaxis: pvmove [-n volumen_lógico] volumen_físico_origen [volumen_fisico_destino ...]
pvmove -n /dev/prueba_vg/primer_LV /dev/loop1 /dev/loop0
</code>

**volumen_físico_origen**: Indica el Volumen Físico que contiene las Áreas Físicas que se desean migrar.

**volumen_físico_destino**: Designa uno o varios Volúmenes Físicos a los que migrar las Áreas Físicas, si no se indica este último parámetro, entonces pvmove lo pondrá donde considere oportuno.

**volumen_lógico**: Sirve para concretar que sólo deseamos migrar las Áreas Físicas correspondientes a un determinado Volumen Físico, ya que de lo contrario, intentaría mover todos los Volúmenes Lógicos que haya en el Volumen Físico.

Esto se usa para que un dispositivo o partición pueda salir del PV, entonces, los datos se deben reorganizar primero para que quede limpio, en caso contrario se perderían datos.

NOTA: Para saber si se puede o no mover datos, tenemos que mirar con el comando pvdisplay  cada unidad cuantos PE tiene libres y cuantos ocupados. Se recomienda hacer copias de seguridad antes de hacer migraciones.


==== Eliminar un PV de un VG ====

Para eliminar un disco o partición de un grupo de volumenes, es necesario que haya las mismas extensiones físicas (PE) libres en el VG como ocupadas en el PV que se quiere retirar. Si no hay extensiones físicas libres, se debe instalar un nuevo disco / partición e inicializarlo dentro del VG para que puedan pasarse los datos del disco que se desea retirar.

Identificamos el PV que se quiere retirar (sdb1).
<code bash>
pvs -o+pv_used
  PV         VG         Fmt  Attr PSize   PFree Used   
  /dev/sda4  Volgroup00 lvm2 a--  736,02g    0  736,02g
  /dev/sdb1  Volgroup00 lvm2 a--  232,88g    0  232,88g
  
pvdisplay
 pvdisplay 
  --- Physical volume ---
  PV Name               /dev/sda4
  VG Name               Volgroup00
  PV Size               736,02 GiB / not usable 564,00 KiB
  Allocatable           yes (but full)
  PE Size               4,00 MiB
  Total PE              188420
  Free PE               0            <-------------------
  Allocated PE          188420
  PV UUID               yBGKWg-scED-yWi9-sTxo-eRxR-NcjE-8UZebC
   
  --- Physical volume ---
  PV Name               /dev/sdb1
  VG Name               Volgroup00
  PV Size               232,88 GiB / not usable 1,18 MiB
  Allocatable           yes (but full)
  PE Size               4,00 MiB
  Total PE              59618
  Free PE               0            <-------------------
  Allocated PE          59618
  PV UUID               2I1VnJ-x9cN-JVc5-43FK-VO1V-Eneu-v7eIb6
</code>

Como en este caso no hay extensiones disponibles, se agrega un nuevo disco (sdd) y se crea una partición (sdd1) igual o mayor al tamaño del disco que se desea expulsar del VG, por ejemplo por mal funcionamiento. Crear la partición no es algo obligatorio para obtener extensiones lógicas libres, pero para nuestro caso se usará una partición ya que no está en mente utilizar todo el disco duro para el grupo de volúmenes Volgroup00.

<code bash>pvcreate /dev/sdd1
vgextend Volgroup00 /dev/sdd1
  Volume group "Volgroup00" successfully extended
  
  pvdisplay 
  ...   
  --- Physical volume ---
  PV Name               /dev/sdd1
  VG Name               Volgroup00
  PV Size               465,00 GiB / not usable 4,00 MiB
  Allocatable           yes 
  PE Size               4,00 MiB
  Total PE              119039
  Free PE               119039            <-------------------
  Allocated PE          0                 <-------------------
  PV UUID               MZNzzT-eGLJ-aWOr-t5O6-jA8J-jkb9-b3fFLJ
  
pvs -o+pv_used
  PV         VG         Fmt  Attr PSize   PFree   Used   
  /dev/sda4  Volgroup00 lvm2 a--  736,02g      0  736,02g
  /dev/sdb1  Volgroup00 lvm2 a--  232,88g      0  232,88g
  /dev/sdd1  Volgroup00 lvm2 a--  465,00g 465,00g      0 
</code>

Movemos los datos del PV /dev/sdb1 al nuevo y disponible /dev/sdd1.
<code bash>pvmove /dev/sdb1 /dev/sdd1
  /dev/sdb1: Moved: 0,0%
  /dev/sdb1: Moved: 0,5%

pvs -o+pv_used
  PV         VG         Fmt  Attr PSize   PFree   Used   
  /dev/sda4  Volgroup00 lvm2 a--  736,02g      0  736,02g
  /dev/sdb1  Volgroup00 lvm2 a--  232,88g 232,88g      0 
  /dev/sdd1  Volgroup00 lvm2 a--  465,00g 232,11g 232,88g</code>

Eliminamos el PV /dev/sdb1 del grupo de volúmenes Volgroup00.
<code>vgreduce Volgroup00 /dev/sdb1
  Removed "/dev/sdb1" from volume group "Volgroup00"

pvs -o+pv_used
  PV         VG         Fmt  Attr PSize   PFree   Used   
  /dev/sda4  Volgroup00 lvm2 a--  736,02g      0  736,02g
  /dev/sdb1             lvm2 ---  232,88g 232,88g      0 
  /dev/sdd1  Volgroup00 lvm2 a--  465,00g 232,11g 232,88g
</code>

Ya se puede retirar el disco duro sin problemas. Lógicamente, si al apagar el sistema, se intercambian los cables de los discos duros, se puede tener de nuevo el disco que actualmente es /dev/sdd, como /dev/sdb.
==== Añadiendo volúmenes físicos (PV) inicializados a un grupo de volúmenes (VG) ====
<code bash>
vgextend mi_vg /dev/loop2
</code>

==== Crear volumen lógico LV ====

El volumen físico es opcional, pero se puede indicar si queremos, uno o varios.

<code bash>
lvcreate -L 10M -n primer_lv mi_vg /dev/loop1
</code>

==== Crear un LV que use el espacio total de un VG ====

<code bash>
lvcreate -n mylv --extents 100%FREE testvg
</code>

Otra opción es usar //vgdisplay// para buscar el tamaño total de PE y ejecutar lo siguiente.

<code bash>
vgdisplay testvg | grep "Total PE" --> Total PE              10230
lvcreate -l 10230 testvg -n mylv
</code>
==== Utilizar un LV ====

Simplemente hay que darle formato con mkfs u otra aplicación.

<code bash>
mkfs.ext3 /dev/mi_vg/primer_lv
</code>

==== Añadiendo volúmenes físicos a un grupo de volumen existente ====

<code bash>
vgextend my_volume_group /dev/hdc1
</code>

<code>
Error: Couldn't find device with uuid XXXXXX-XXXX-XXXX-XXXX-XXXX-XXXX-XXXXXX.
</code>

<code>
vgextend VolGroup /dev/sdb1
  Couldn't find device with uuid yJ20lV-DQso-EUlv-TNRM-Ud03-Akr6-RPP4HS.
  Cannot change VG VolGroup while PVs are missing.
  Consider vgreduce --removemissing.
</code>

**Solución**: Eliminar el volumen físico "no encontrado" del grupo de volúmenes, para que siga funcionando como anteriormente. Una vez esté como al principio podemos volver a intentar la tarea que fuera.

<code bash>
vgextend VolGroup /dev/sdb1
  Couldn't find device with uuid yJ20lV-DQso-EUlv-TNRM-Ud03-Akr6-RPP4HS.
  Cannot change VG VolGroup while PVs are missing.
  Consider vgreduce --removemissing.

pvscan
  Couldn't find device with uuid yJ20lV-DQso-EUlv-TNRM-Ud03-Akr6-RPP4HS.
  PV /dev/sda2        VG VolGroup        lvm2 [19.51 GiB / 0    free]
  PV unknown device   VG VolGroup        lvm2 [4.66 GiB / 4.66 GiB free]    <--------
  PV /dev/sdb1                           lvm2 [4.66 GiB]
  Total: 3 [28.82 GiB] / in use: 2 [24.16 GiB] / in no VG: 1 [4.66 GiB]

vgreduce --removemissing --verbose VolGroup
    Finding volume group "VolGroup"
  Couldn't find device with uuid yJ20lV-DQso-EUlv-TNRM-Ud03-Akr6-RPP4HS.
    There are 1 physical volumes missing.
    Trying to open VG VolGroup for recovery...
    Couldn't find device with uuid yJ20lV-DQso-EUlv-TNRM-Ud03-Akr6-RPP4HS.
    There are 1 physical volumes missing.
    Archiving volume group "VolGroup" metadata (seqno 4).
    Removing PV with UUID yJ20lV-DQso-EUlv-TNRM-Ud03-Akr6-RPP4HS from VG VolGroup <--------
    Creating volume group backup "/etc/lvm/backup/VolGroup" (seqno 5).
  Wrote out consistent volume group VolGroup

pvscan
  PV /dev/sda2   VG VolGroup        lvm2 [19.51 GiB / 0    free]
  PV /dev/sdb1                      lvm2 [4.66 GiB]
  Total: 2 [24.17 GiB] / in use: 1 [19.51 GiB] / in no VG: 1 [4.66 GiB]
</code>


==== Instantánteas (Snapshots) ====

Comprobar que se tienen los módulos del núcleo cargados.

<code bash>
dmsetup targets
 mirror           v1.12.0
 striped          v1.4.1
 linear           v1.1.0
 error            v1.0.1
modprobe dm-snapshot
dmsetup targets
 snapshot-merge   v1.1.0 <-----------
 snapshot-origin  v1.7.1 <-----------
 snapshot         v1.10.0
 mirror           v1.12.0
 striped          v1.4.1
 linear           v1.1.0
 error            v1.0.1
</code>

<code bash>
lvcreate -L20M -s -n congelado /dev/Volgroup00/lv_root 
  Logical volume "congelado" created.</code>

El concepto de instantánea es similar a los enlaces simbólicos que conocemos, cuando se crea un enlace simbólico a un archivo no se realiza una copia del archivo real, sino sólo una referencia al mismo. Los volúmenes lógicos guardan la información de forma muy similar y se compone de dos partes esenciales: Punteros de metadatos (Información sobre donde están los bloques de datos) y Bloques de datos.

Cuando se crea una instantánea, simplemente se crea una copia de todos los punteros de metadatos de un volumen lógico.
Los metadatos no consumen demasiado espacio, por lo que una instantánea de 5 Mb puede referenciar un volumen de 2GB. El volumen de instantánea sólo aumenta cuando los datos del volumen original a los que referencia crece, cada vez que se elimina o se crea un fichero se crea una copia de este en la instantánea. La recomendación es crear instantáneas con un margen del 5 al 10% del tamaño del volumen lógico original.

Por eso, una vez se crea la instantánea, se debe montar, hacer el backup de la misma, desmontarla y eliminarla. No son un proceso de backup, si no una ayuda para hacer copias de seguridad del disco en caliente en un determinado momento.
==== Fusionar / Restablecer / Restaurar una instantánea (Snapshots) ====

Para montar la instantanea para consultar o hacer un backup.
<code bash>mount /dev/Volgroup00/congelado /mnt/XXXX/
# Listar las instantaneas: lvdisplay</code>

Fusionar / Restablecer / Restaurar una instantánea (Snapshots)
<code bash>
umount /dev/Volgroup00/congelado # En el caso de que esté montada
lvconvert --merge /dev/Volgroup00/congelado
</code>

Si la instantánea  hace referencia al sistema de ficheros raíz, este no se podrá desmontar mientras esté el sistema encendido, por lo que se mostrará un mensaje como el siguiente avisando de que se restablecerá la instantánea después de reiniciar. Este suele ser el mensaje cuando se trata de particiones raíz.
<code>  Logical volume Volgroup00/lv_root contains a filesystem in use.
  Can't merge over open origin volume.
  Merging of snapshot Volgroup00/congelado will occur on next activation of Volgroup00/lv_root.</code>

**Problema al fusionar una snapshot** (No aplicable a particiones raíz).
<code>Can't merge over open origin volume
Can't merge when snapshot is open
Merging of snapshot XXX will start next activation.</code>
**Solución**: La causa suele ser que el snapshot está montada, se debe desmontar (umount) y probar de nuevo.

**Problema al fusionar una snapshot** (No aplicable a particiones raíz).
<code>Can't merge over open origin volume
  Merging of snapshot XXX will start next activation.</code>
**Solución**:
<code bash>
lvchange -an <logical volume path> # Desactivamos
lvchange -ay <logical volume path> # Activamos
# Ahora se debe intentar de nuevo fusionar la instantánea.
</code>

Típico error al querer restaurar una instantánea.

<code>
Volume group "XXXX" has insufficient free space (0 extents): XXX required.
</code>

**Solución**: Generar espacio (PE libres) en ese grupo de volúmenes mediante nuevos dispositivos de almacenamiento o bien, reduciendo los volúmenes. Si hiciera referencia a una instantánea del sistema raíz se tendría que usar un LiveCD, ya que los sistemas de ficheros cuando están montados, dependiendo de cuales, se pueden ampliar sin desmontar, pero no reducirlos.


==== Ejemplo de reducción de volumen con un LiveCD ====

Primero se debe activar el grupo de volúmenes desde el LiveCD.

<code bash>
LiveCD# pvdisplay                                      (Prestamos especial atención al nombre del grupo de volúmenes "VG Name")
LiveCD# lvchange -ay VolGroup                          (Activamos el VG)
LiveCD# e2fsck -f /dev/VolGroup/lv_root                (En el caso de ser un sistema de ficheros EXT3.)
LiveCD# lvresize -r -L -2G /dev/VolGroup/lv_root       (Reducimos 2Gb de su tamaño)
LiveCD# lvreduce -r -L 2G /dev/VolGroup/lv_root        (Reduce el tamaño de /dev/VolGroup/lv_root a 2 Gb, NO es lo mimso que lo anterior.)</code>

Si intentamos ejecutar el comando lvresize en una unidad montada como puede ser "/" pese al aviso, lo más probable es que el sistema no arranque (kernel panic).

<code>
WARNING: Reducing active and open logical volume to 16.76 GiB
  THIS MAY DESTROY YOUR DATA (filesystem etc.)
Do you really want to reduce lv_root? [y/n]:
</code>


==== Extendiendo / Expandiendo un volumen lógico ====

Si se extiende un volumen lógico instalando / utilizando una nueva unidad de almacenamiento, primero debemos particionarla (cfdisk), asignarle un sistema de ficheros LVM y posteriormente incluirla dentro de nuestro grupo de volúmenes. Una vez realizado ese proceso, ya podremos usar ese espacio para cualquiera de los volumenes lógicos mediante la orden "lxextend".

<code bash>
cfdisk /dev/sdb
pvcreate /dev/sdb1
vgextend VolGroup /dev/sdb1
</code>

<code>
lvextend -r -L+500M /dev/prueba_vg/segundo_LV
lvextend -r -l+100%FREE /dev/VolGroup/lv_root
</code>

Hay muchas formas de especificar la cantidad de espacio que se quiere extender (Mb, Gb, PE, %FREE, etc...)

NOTA: Se puede extender el directorio raiz con ext3/ext4 en caliente.

==== Sintaxis lvextend ====

<code>
lvextend -l, --extents [+]LogicalExtentsNumber[%{VG|LV|PVS|FREE|ORIGIN}] 
lvextend -L, --size [+]LogicalVolumeSize[bBsSkKmMgGtTpPeE]
</code>


De no usar la opción "-r" se debe extender el sistema de ficheros posteriormente: resize2fs (ext) / xfs_growfs (xfs) / resize_reiserfs (reiserfs) / ...

resize2fs /dev/prueba_vg/segundo_LV               Ext    (Siempre desmontado, ext4 puede hacerse montado)

resize_reiserfs -f /dev/prueba_vg/segundo_LV      Reiser (Montado / desmonado)

xfs_growfs /media/puntodemontaje                  Xfs    (Debe estar montado y especificar punto de montaje)

mount -o remount,resize /home                     Jfs    (Debe estar montado y especificar punto de montaje)


NOTA: Al usar resize2fs es probable que nos pida antes de redimensionar el sistema, ejecutar un e2fsck -f sobre el LV.

==== Extendiendo / Expandiendo un volumen físico (PV) ====

En LVM cabe la posibilidad de querer aumentar el tamaño de un PV, por ejemplo en los supuestos en los que el disco de una máquina virtual ha sido agrandado o bien porque la partición donde teníamos nuestro sistema LVM ha sido redimensionada. Supongamos un ejemplo donde ///dev/sda4// tiene un tamaño limitado pero en el disco hay espacio libre. Si el sistema utiliza MBR, no se podrían poner más particiones, por lo que la única solución sería redimensionar dicha partición, extender el PV y posteriormente extender también el LV o bien crear otro LV dentro del PV previamente extendido.

NOTA: Como es lógico no se pueden tener dos VG en un mismo PV.

**Redimensionar una partición en GNU/Linux / disco duro virtual**.
Una ver redimensionado, la forma más fácil de adaptarlo al nuevo tamaño es borrar la partición que se desea expandir con cfdisk y crear otra nueva que ocupe el nuevo tamaño, seleccionando las mismas opciones que tenía la anterior (boot, tipo, etc). Si se trata de la partición raíz se debe reiniciar el sistema.

**Extender el PV para que ocupe ese nuevo tamaño adquirido al redimensionar la partición / VDI** (///dev/sda4//).

Muy útil cuando se redimensionan particiones o discos duros virtuales, por ejemplo de VirtualBox.

Espacio ocupado por el grupo de volumen PV en ///dev/sda4//.
<code bash>pvs
  PV         VG         Fmt  Attr PSize   PFree
  /dev/sda4  Volgroup00 lvm2 a--  186,26g    0</code>

Como hemos redimensionado la partición con cfdisk o cualquier otro software, indicamos al PV que ocupe todo el nuevo espacio físico disponible.
<code bash>pvresize /dev/sda4 
  Physical volume "/dev/sda4" changed
  1 physical volume(s) resized / 0 physical volume(s) not resized</code>

Como podemos ver, ahora el PV sí engloba todo el espacio utilizable en ///dev/sda4//.
<code bash>/home/maria pvs
  PV         VG         Fmt  Attr PSize   PFree  
  /dev/sda4  Volgroup00 lvm2 a--  736,02g 549,76g</code>

El siguiente paso sería extender también el LV que queramos ([[guia_rapida_y_completa_de_lvm#extendiendo_expandiendo_un_volumen_logico|leer]]) o bien crear otro LV nuevo, el cual incluso podemos cifrar siguiendo las siguientes instrucciones.

==== Crear un volumen lógico cifrado ====

<code bash>
# Creamos el LV indicanco que use el espacio libre en el grupo de volumen Volgroup00 (Por ejemplo).
lvcreate -n cifrado --extents 100%FREE Volgroup00 
# Comprobamos que se haya creado.
lsblk 

# Ciframos y formateamos: http://www.busindre.com/cifrar_particiones_en_gnu_linux_facil
cryptsetup luksFormat /dev/Volgroup00/cifrado 
cryptsetup luksUUID /dev/Volgroup00/cifrado
cryptsetup luksOpen /dev/Volgroup00/cifrado cifrado
mkfs.xfs /dev/mapper/cifrado </code>

==== Reconocer un disco duro / partición instalado en caliente (hotplugged) ====

NOTA: Esto es independiente de LVM, es decir, se use o no LVM en el disco duro se pueden seguir estos pasos para intentar que el sistema lo reconozca. Se presentan varias opciones a continuación.

<code bash>
##### Usando /sys/class/scsi_host (Util para reconocer nuevos discos / particiones)

# Se listan todos los posibles "scan" para revisar.
 ls /sys/class/scsi_host/
host0  host1  host2  host3  host4  host5

echo "- - -" > /sys/class/scsi_host/host0/scan
echo "- - -" > /sys/class/scsi_host/host1/scan
echo "- - -" > /sys/class/scsi_host/host2/scan
...

##### Comando partprobe (Útil para reconocer particiones cuando no han sido todavía reconocidas por el kernel).
partprobe

##### Comando partx (Útil para reconocer particiones cuando no han sido todavía reconocidas por el kernel).

# Lista las particiones del disco
partx -s /dev/sdb
# Forzar que el kernel kernel reconozca todas las paticiones de /dev/sdb.
partx -v -a /dev/sdb
</code>


Una vez reconocido el disco/partición, si queremos utilizarlo para expandir el espacio de / debemos hacer lo siguiente (Pasos vistos y explicados anteriormente en esta guía).

<code bash>
ls /sys/class/scsi_host
host0 host1 host2

echo "- - -" > /sys/class/scsi_host/host0/scan
echo "- - -" > /sys/class/scsi_host/host1/scan
echo "- - -" > /sys/class/scsi_host/host2/scan
fdisk -l # Debemos ver el nuevo disco duro virtual.

cfdisk /dev/sdb # Creamos la partición (/dev/sdb1)
lvscan # Se comprueba el espacio actual del LV.

pvcreate /dev/sdb1
vgextend VolGroup /dev/sdb1
lvextend -r -l+100%FREE /dev/VolGroup/lv_root
lvscan # Se comprueba el nuevo espacio actual del LV.
</code>

==== Simular retirada / conexión de un disco duro ====

<code bash>echo offline > /sys/block/sda/device/state   # Pone el disco inaccesible.
echo running > /sys/block/sda/device/state   # Vuelve a poner el disco accesible.

# Borrar un disco (Se usa antes de sacarlo del servidor)
# echo 1 > /sys/block/sda/device/delete</code>
==== Reduciendo un volumen lógico ====

Al contrario que al extender no se puede hacer con sistemas de ficheros montados.

Para reducir un volumen lógico se debe antes reducir el tamaño del sistema de ficheros, eso lo podemos hacer de forma manual o bien con la opción "-r" (Utiliza fsdam) para que se encargue lvreduce de reducir el sistema de ficheros (Recomendado)

<code bash>
lvreduce -r -L-5G /dev/myvg/homevol  
</code>

De hacerlo manualmente hay que especificar el nuevo tamaño del sistema de ficheros resultante en Kb (1 bloque -> 1 kbyte), NO el tamaño que se quiere reducir 

<code>
resize2fs /dev/prueba_vg/segundo_LV 68157440
# Si era LV de 70, ahora le sistema de ficheros es de 65, debemos quitarle 5 al LV
lvreduce -L-5G /dev/myvg/homevol 
</code>

**Reiserfs**.
<code bash>lvreduce -r -L-1G /dev/myvg/homevol
resize_reiserfs -s-1G /dev/myvg/homevol
lvreduce -L-1G /dev/myvg/homevol  
</code>

**XFS / JFS**: No se puede reducir actualmente: [[http://xfs.org/index.php/XFS_FAQ#Q%3A_Is_there_a_way_to_make_a_XFS_filesystem_larger_or_smaller.3F|Leer]]

NOTA: De hacerlo manualmente, resize2fs nos avisa si hemos puesto un numero demasiado pequeño indicando el mínimo.

<code>resize2fs: New size smaller than minimum (20477). </code>


==== Mover grupos de volumenes a otros sistemas ====

**Exportar**:

  - Se desmontan las unidades montadas.
  - Se desactiva. (//vgchange -an design//)
  - Exportamos el volumen. (//vgexport design//)
  - Apagamos y sacamos los discos.

**Importar**:

  - Conectamos los discos y escribimos el comando pvscan para encontrar el disco con el VG "//design//"
  - Importamos (indicando el nombre del VG) todo o bien lo que nos interese: vgimport design /dev/sdb1 /dev/sdb2
  - Activamos: vgchange -ay design
  - Montamos como queramos / como estaba antes: mount /dev/design/users /mnt/design/users

==== Dividir un grupo de volumen para crear un nuevo ====

Útil cuando tenemos todos los discos o particiones ocupados por el mismo. Tenemos que tener el PV limpio, podemos usar pvmove para sacar los datos a otos pv. Se debe desmontar antes el sistemas de ficheros y desactivar.

**Supuesto**: Mover sdg2 del vg "caracola" a "design". 

**Opción 1**

<code bash>
vgsplit caracola design /dev/sdg2
</code>

**Opción 2** (//vgsplit nos ahorra el ejecutar estos dos comandos//)

<code bash>
vgreduce dev /dev/sdg2       # Elimina el PV
vgextend design /dev/sdg2    # Lo agraga a otro VG
</code>

==== Montar un disco duro con LVM desde un LiveCD ====

Listamos los volúmenes físicos y grupos de volumenes de los discos duros conectados.
<code bash>pvscan
PV /dev/sda2 VG VolGroup00 lvm2 [74.41 GB / 32.00 MB free]
Total: 1 [74.41 GB] / in use: 1 [74.41 GB] / in no VG: 0 [0 ]</code>
<code bash>vgscan
Reading all physical volumes. This may take a while...
Found volume group "VolGroup00" using metadata type lvm2</code>

Activamos todos los grupos de volumenes disponibles.
<code bash>vgchange -a y
2 logical volume(s) in volume group "VolGroup00" now active</code>

Ejecutamos lvscan para listar todos los volúmenes lógicos existentes para saber cual montar.
<code bash>lvscan
ACTIVE '/dev/VolGroup00/LogVol00' [72.44 GB] inherit
ACTIVE '/dev/VolGroup00/LogVol01' [1.94 GB] inherit</code>

Montamos por ejemplo el volumen lógico LogVol00 en /mnt/volumen0
<code bash>mount /dev/VolGroup00/LogVol00 /mnt/volumen0</code>

==== Comandos útiles que muestran información ====

<code bash>
pvscan (-u muestra el uuid) # Dice los tamaños usados de los discos / particiones del VG
lvs
lvm
pvdisplay
vgdisplay
lvdisplay
lsblk
</code>

==== Identificar el VG y LV al que pertenece un determinado fichero ====
<code>df -T /home/maria/jondo_linux.tar.bz2 |tail -n 1 |awk '{print $1}'
/dev/mapper/Volgroup00-lv_root</code>


==== Conocer el tipo de volumen lógico utilizado (linear / striped) ====

<code>lvs --segments
  LV      VG         Attr       #Str Type   SSize  
  cifrado Volgroup00 -wi-a-----    1 linear 549,76g
  lv_root Volgroup00 -wi-ao----    1 linear 184,00g
  lv_root Volgroup00 -wi-ao----    1 linear 232,88g
  lv_swap Volgroup00 -wc-ao----    1 linear   2,26g</code>

==== Conocer el tamaño de las areas (extents)dentro de un grupo de volúmenes ====

<code>pvdisplay | grep -i "PV Name\|VG Name\|PE Size"
  PV Name               /dev/sda4
  VG Name               Volgroup00
  PE Size               4,00 MiB <-------
  PV Name               /dev/sdb1 
  VG Name               Volgroup00
  PE Size               4,00 MiB <-------</code>

Como sabemos, existen dos sistemas de medidas para representar múltiplos de bits (o bytes). El SI (sistema internacional de unidades) entiende que un kilobyte son 1000 bytes, mientras que en sistema binario se entienden que son 1024. Por ello, a la medida binaria, en este caso, se le llama Kibibyte, para distinguirlos.

Ocurre lo mismo con los MiB (mebibytes) y Gib (gibibytes), que no son exactamente iguales a los MB (megabytes) y GB (gigabytes).
==== Identificar y ubicar las areas lógicas y físicas de los volúmenes lógicos ====

Conocer el número y ubicación física de las áreas (extents) lógicas y físicas de los LVs.
<code>lvdisplay --maps |egrep 'Physical|LV Name|Type'
...
--- Segments ---
  Logical extents 0 to 47103:
    Type		linear
    Physical volume	/dev/sda4
    Physical extents	0 to 47103
   
  Logical extents 47104 to 106721:
    Type		linear
    Physical volume	/dev/sdb1
    Physical extents	0 to 59617</code>
==== Identificar los bloques / áreas que forman un fichero en disco ====

Si el volumen fue definido como linear y no "striping", es muy difícil encontrar ficheros que tengan partes en más de un dispositivo físico.

Obtener la disposición de bloques de un archivo concreto utilizando la utilidad hdparm.
<code>hdparm --fibmap /home/maria/Desktop/World_of_Goo_JC4D2G-1.41_Linux.zip 

/home/maria/Desktop/World_of_Goo_JC4D2G-1.41_Linux.zip:
 filesystem blocksize 4096, begins at LBA 0; assuming 512 byte sectors.
 byte_offset  begin_LBA    end_LBA    sectors
           0  186384384  186400767      16384
     8388608  187678720  187826175     147456
    83886080  187858944  187891711      32768
   100663296  188104704  188186623      81920
   142606336  188203008  188268543      65536
   176160768  188334080  188378919      44840</code>

  * byte_offset: Byte en el que empieza cada parte que conforma el fichero.
  * begin_LBA: En qué bloque comienza una determinada parte.
  * end_LBA: En qué bloque termina la parte del fichero (se debe contabilizar también).
  * sectors: El número de sectores que ocupa dicha parte.

Interpretando y entendiendo correctamente los campos, se puede calcular el tamaño del fichero en bytes de manera simple: "(44840 x 512)+176160768".

Calcular los byte_offset también sería una tarea trivial, "176160768 = 65536 x 512" y ya tenemos los bytes que ocupa esa parte, ahora se debe sumar los bytes que ocupaban las partes anteriores y ya tenemos el byte donde comienza dicha parte "142606336 + (65536 x 512)".

Obtener la disposición de áreas de un archivo concreto utilizando la utilidad hdparm.
<code>debugfs 1.42.13 (17-May-2011)
debugfs:  stat /home/cacas/Desktop/World_of_Goo_JC4D2G-1.41_Linux.zip 
Inode: 270599   Type: regular    Mode:  0600   Flags: 0x80000
Generation: 3352783085    Version: 0x00000000:00000001
User:  1000   Group:  1000   Size: 199116706
File ACL: 0    Directory ACL: 0
Links: 1   Blockcount: 388912
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x55c3c0c0:2b8593ac -- Thu Aug  6 22:17:04 2015
 atime: 0x55c3c08f:e4ee4cf0 -- Thu Aug  6 22:16:15 2015
 mtime: 0x55c3c0c0:2b8593ac -- Thu Aug  6 22:17:04 2015
crtime: 0x55c3c08f:e4ee4cf0 -- Thu Aug  6 22:16:15 2015
Size of extra inode fields: 28
EXTENTS:
(ETB0):1081694, (0-2047):23298048-23300095, (2048-20479):23459840-23478271, (20480-24575):23482368-23486463, (24576-34815):23513088-23523327, (34816-43007):23525376-23533567, (43008-48612):23541760-23547364</code>

<code>/home/maria/Desktop/World_of_Goo_JC4D2G-1.41_Linux.zip:
 filesystem blocksize 4096, begins at LBA 0; assuming 512 byte sectors.
 byte_offset  begin_LBA    end_LBA    sectors
           0  186384384  186400767      16384   ---> 186400767 - 186384384 + 1 = 16384   ----> ((23300095 x 8) +8) - (23298048 x 8) ----> ((2047 - 0) x 8 ) + 8  -------> (8388608 - 0) / 512 
     8388608  187678720  187826175     147456   ---> 187826175 - 187678720 + 1 = 147456  ----> ((23478271 x 8) +8) - (23459840 x 8) ----> ((20479 - 2048) x8 ) + 8  ----> (83886080 - 8388608) / 512
    83886080  187858944  187891711      32768   ---> 187891711 - 187858944 + 1 = 32768   ----> ((23486463 x 8) +8) - (23482368 x 8) ----> ((24575 - 20480) x 8 ) +8 ----> (100663296 - 83886080) / 512
   100663296  188104704  188186623      81920   ---> 188186623 - 188104704 + 1 = 81920   ----> ((23523327 x 8) +8) - (23513088 x 8) ----> ((34815 - 24576) x 8 ) +8 ----> (142606336 - 100663296) / 512
   142606336  188203008  188268543      65536   ---> 188268543 - 188203008 + 1 = 65536   ----> ((23533567 x 8) +8) - (23525376 x 8) ----> ((43007 - 34816) x 8 ) +8 ----> (176160768 - 142606336) / 512
   176160768  188334080  188378919      44840   ---> 188378919 - 188334080 + 1 = 44840   ----> ((23547364 x 8) +8) - (23541760 x 8) ----> ((48612 - 43008) x 8 ) +8
</code>

NOTA: Se debe sumar 1 ya que el sector final debe ser también contabilizado. En el caso de utilizar sectores físicos, se debe sumar 8 por ese mismo motivo. El valor 8 se debe a que "debugfs" utiliza el tamaño de sector físico (4096 bytes) y no el lógico (512 bytes), por tanto 8 es el resultado de dividir 4096 entre 512.

Comentar que es perfectamente posible que las partes que conforman un determinado fichero, ni tienen que ser decuenciales ni tienen por qué estar ordenadas de manera ascendente. Veamos un ejemplo.

<code>hdparm --fibmap /home/cacas/archivo.txt 

/home/mamria/archivo.txt:
 filesystem blocksize 4096, begins at LBA 0; assuming 512 byte sectors.
 byte_offset  begin_LBA    end_LBA    sectors
           0     933888     966655      32768
    16777216     884736     917503      32768 <----------
    33554432     983040    1015807      32768
    50331648    1097728    1163263      65536</code>
==== Ubicar ficheros cuando el volumen lógico ocupa múltiples discos ====
    
Para averiguar en que PV se encuentra un determinado fichero, se puede identificar mediante un hash alguna de sus partes y luego buscar una coincidencia en cada disco físico que ocupado por el volumen.

Lo primero, es identificar qué volumenes físicos están en uso por el volumen lógico. Para el ejemplo, el volumen lógico "lv_root" está repartido entre sda4 y sdb1, por los que deberemos buscar en esos dos VPs.
<code>lvs -o +seg_pe_ranges,vg_extent_size
  LV      VG         Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert PE Ranges              Ext  
  cifrado Volgroup00 -wi-a----- 549,76g                                                     /dev/sda4:47682-188419 4,00m
  lv_root Volgroup00 -wi-ao---- 416,88g                                                     /dev/sda4:0-47103      4,00m
  lv_root Volgroup00 -wi-ao---- 416,88g                                                     /dev/sdb1:0-59617      4,00m
  lv_swap Volgroup00 -wc-ao----   2,26g                                                     /dev/sda4:47104-47681  4,00m

#################

pvdisplay 
  --- Physical volume ---
  PV Name               /dev/sda4
  ...
  Allocated PE          188420 -------> 0-47103 (/ )  47104-4768 (swap)  47682-188419 (cifrado)
  ... 
  --- Physical volume ---
  PV Name               /dev/sdb1
  Total PE              59618 -------> 0-59617 (/ )
  ...</code>


Identificamos la ubicación de las distintas partes del fichero "jondo_linux.tar.bz2"
<code>hdparm --fibmap jondo_linux.tar.bz2
jondo_linux.tar.bz2:
 filesystem blocksize 4096, begins at LBA 0; assuming 512 byte sectors.
 byte_offset  begin_LBA    end_LBA    sectors
           0    8314880    8318975       4096
     2097152   29638656   29642751       4096
     4194304   44793856   44802047       8192
     8388608  694616064  694625847       9784</code>

Obtenemos el hash perteneciente a los primeros 2 MiB del fichero.
<code>dd if=jondo_linux.tar.bz2 bs=512 skip=0 count=4096 | md5sum
4096+0 registros leídos
4096+0 registros escritos
2097152 bytes (2,1 MB, 2,0 MiB) copied, 0,00767018 s, 273 MB/s
6870dcb82fa7aa7077936036f0b03bec  -</code>

Obtenemos el hash perteneciente a los primeros 2 MiB del fichero pero usando el volumen lógico donde se ubica.
<code>dd if=/dev/mapper/Volgroup00-lv_root bs=512 skip=8314880 count=4096 | md5sum
4096+0 registros leídos
4096+0 registros escritos
2097152 bytes (2,1 MB, 2,0 MiB) copied, 0,0261066 s, 80,3 MB/s
6870dcb82fa7aa7077936036f0b03bec  -</code>

Obtenemos el espacio ocupado por los metadatos y otra información de LVM al principio del disco.
<code>pvck -d -v /dev/sda4 
    Scanning /dev/sda4
  Found label on /dev/sda4, sector 1, type=LVM2 001
  Found text metadata area: offset=4096, size=1044480  <----------------------------------
    Found LVM2 metadata record at offset=34304, size=2048, offset2=0 size2=0
    Found LVM2 metadata record at offset=32256, size=2048, offset2=0 size2=0</code>

Este área de información empieza en el ofsset 4096 y ocupa 1044480 bytes. Si se divide 1044480 entre 512, se obtienen 2040 sectores, pero hay que sumarle los otros 8 (4096/512).

Ahora preguntamos por esa parte, en la partición /dev/sda4 incluyendo ese "desplazamiento" de información LVM al principio de disco.
<code>dd if=/dev/sda4 bs=512 skip=$(8314880 + 2048) count=4096 | md5sum
4096+0 registros leídos
4096+0 registros escritos
2097152 bytes (2,1 MB, 2,0 MiB) copied, 0,0220594 s, 95,1 MB/s
6870dcb82fa7aa7077936036f0b03bec  -</code>

Localizado, se encuentra en sda4.

NOTA: Si se utilizan discos de diferente tamaño y se identifican el número de sectores de cada uno de ellos, en algunos casos se identificará rápidamente el disco que contiene el fichero, ya que este puede estar ubicado en un bloque que solo esté presente en uno de los dos discos (que coincidiría con el de mayor tamaño.) Si se tiene el volumen lógico usando mapeado lineal repartido en un disco de 3Gb y otro de 4T, la parte correspondiente a 8314880 nunca podría estar en el disco de 3Gb (6291456 sería el último bloque que podría usarse).

==== Relación entre mapeado de dispositivo (dm-0, dm-1, etc) y los volúmenes lógicos.====

Si se está usando LVM, es común encontrarse en métricas de disco o simplemente en la salida de comandos como iostat, los llamados mapeados de dispositivo (dm-0, dm-1, etc). Con estos comandos se puede averiguar a qué volumen lógico se está refiriendo un mapeo dm-x" en concreto, se muestran dos opciones.

<code bash>
dmsetup ls
luks-20b2aaf7-9353-4732-8f62-ff83bb5e54b7	(254:3)   <--- dm-3
Volgroup00-lv_swap	(254:1)                           <--- dm-1
Volgroup00-lv_root	(254:0)                           <--- dm:0
Volgroup00-cifrado	(254:2)                           <--- dm:2

lvdisplay|awk  '/LV Name/{n=$3} /Block device/{d=$3; sub(".*:","dm-",d); print d,n;}'
dm-0 lv_root
dm-1 lv_swap
dm-2 cifrado</code>
==== Enlaces de interés ====
[[https://www.busindre.com/nociones_sobre_el_tamano_de_bloque_de_disco | Nociones básicas sobre tamaño de bloque]]\\
[[https://access.redhat.com/documentation/es-ES/Red_Hat_Enterprise_Linux/5/html/Logical_Volume_Manager_Administration/index.html| Red Hat (Logical Volume Manager Administration)]]\\
[[http://busindre.com/recuperar_pv_y_lv_tras_cambios_lvm|Recuperación de Volúmenes físicos / lógicos]]\\
[[http://linuxalbacete.org]] (Muy recomendable).\\
[[http://www.vilecha.com/hellguest/lvm2_info.asp]]\\
[[http://www.olafrv.com/wordpress/wp-content/uploads/2013/08/hp_3par_with_debian_v7.txt]]\\
[[https://www.zimbra.com/products/zimbra-collaboration/calendar-collaboration.html]] (Extender directorio raíz sin reiniciar con ext3/ext4)