Libvirt provides storage management on the physical host through storage pools and volumes.
A storage pool is a quantity of storage set aside by an administrator, often a dedicated storage administrator, for use by virtual machines. Storage pools are divided into storage volumes either by the storage administrator or the system administrator, and the volumes are assigned to VMs as block devices.
For example, the storage administrator responsible for an NFS server creates a share to store virtual machines' data. The system administrator defines a pool on the virtualization host with the details of the share (e.g. nfs.example.com:/path/to/share should be mounted on /vm_data). When the pool is started, libvirt mounts the share on the specified directory, just as if the system administrator logged in and executed 'mount nfs.example.com:/path/to/share /vmdata'. If the pool is configured to autostart, libvirt ensures that the NFS share is mounted on the directory specified when libvirt is started.
Once the pool is started, the files in the NFS share are reported as volumes, and the storage volumes' paths may be queried using the libvirt APIs. The volumes' paths can then be copied into the section of a VM's XML definition describing the source storage for the VM's block devices. In the case of NFS, an application using the libvirt APIs can create and delete volumes in the pool (files in the NFS share) up to the limit of the size of the pool (the storage capacity of the share). Not all pool types support creating and deleting volumes. Stopping the pool (somewhat unfortunately referred to by virsh and the API as "pool-destroy") undoes the start operation, in this case, unmounting the NFS share. The data on the share is not modified by the destroy operation, despite the name. See man virsh for more details.
A second example is an iSCSI pool. A storage administrator provisions an iSCSI target to present a set of LUNs to the host running the VMs. When libvirt is configured to manage that iSCSI target as a pool, libvirt will ensure that the host logs into the iSCSI target and libvirt can then report the available LUNs as storage volumes. The volumes' paths can be queried and used in VM's XML definitions as in the NFS example. In this case, the LUNs are defined on the iSCSI server, and libvirt cannot create and delete volumes.
Storage pools and volumes are not required for the proper operation of VMs. Pools and volumes provide a way for libvirt to ensure that a particular piece of storage will be available for a VM, but some administrators will prefer to manage their own storage and VMs will operate properly without any pools or volumes defined. On systems that do not use pools, system administrators must ensure the availability of the VMs' storage using whatever tools they prefer, for example, adding the NFS share to the host's fstab so that the share is mounted at boot time.
If at this point the value of pools and volumes over traditional system administration tools is unclear, note that one of the features of libvirt is its remote protocol, so it's possible to manage all aspects of a virtual machine's lifecycle as well as the configuration of the resources required by the VM. These operations can be performed on a remote host entirely within the libvirt API. In other words, a management application using libvirt can enable a user to perform all the required tasks for configuring the host for a VM: allocating resources, running the VM, shutting it down and deallocating the resources, without requiring shell access or any other control channel.
Libvirt supports the following storage pool types:
A pool with a type of dir provides the means to manage
files within a directory. The files can be fully allocated raw files,
sparsely allocated raw files, or one of the special disk formats
such as qcow,qcow2,vmdk,
cow, etc as supported by the qemu-img
program. If the directory does not exist at the time the pool is
defined, the build operation can be used to create it.
<pool type="dir">
<name>virtimages</name>
<target>
<path>/var/lib/virt/images</path>
</target>
</pool>
The directory pool does not use the pool format type element.
One of the following options:
raw: a plain filebochs: Bochs disk image formatcloop: compressed loopback disk image formatcow: User Mode Linux disk image formatdmg: Mac disk image formatiso: CDROM disk image formatqcow: QEMU v1 disk image formatqcow2: QEMU v2 disk image formatvmdk: VMWare disk image formatvpc: VirtualPC disk image format
When listing existing volumes all these formats are supported
natively. When creating new volumes, only a subset may be
available. The raw type is guaranteed always
available. The qcow2 type can be created if
either qemu-img or qcow-create tools
are present. The others are dependent on support of the
qemu-img tool.
This is a variant of the directory pool. Instead of creating a directory on an existing mounted filesystem though, it expects a source block device to be named. This block device will be mounted and files managed in the directory of its mount point. It will default to allowing the kernel to automatically discover the filesystem type, though it can be specified manually if required.
<pool type="fs">
<name>virtimages</name>
<source>
<device path="/dev/VolGroup00/VirtImages"/>
</source>
<target>
<path>/var/lib/virt/images</path>
</target>
</pool>
The filesystem pool supports the following formats:
auto - automatically determine formatext2
ext3
ext4
ufs
iso9660
udf
gfs
gfs2
vfat
hfs+
xfs
The valid volume types are the same as for the directory
pool type.
This is a variant of the filesystem pool. Instead of requiring a local block device as the source, it requires the name of a host and path of an exported directory. It will mount this network filesystem and manage files within the directory of its mount point. It will default to using NFS as the protocol.
<pool type="netfs">
<name>virtimages</name>
<source>
<host name="nfs.example.com"/>
<dir path="/var/lib/virt/images"/>
</source>
<target>
<path>/var/lib/virt/images</path>
</target>
</pool>
The network filesystem pool supports the following formats:
auto - automatically determine formatnfs
The valid volume types are the same as for the directory
pool type.
This provides a pool based on an LVM volume group. For a pre-defined LVM volume group, simply providing the group name is sufficient, while to build a new group requires providing a list of source devices to serve as physical volumes. Volumes will be allocated by carving out chunks of storage from the volume group.
<pool type="logical">
<name>HostVG</name>
<source>
<device path="/dev/sda1"/>
<device path="/dev/sdb1"/>
<device path="/dev/sdc1"/>
</source>
<target>
<path>/dev/HostVG</path>
</target>
</pool>
The logical volume pool does not use the pool format type element.
The logical volume pool does not use the volume format type element.
This provides a pool based on a physical disk. Volumes are created by adding partitions to the disk. Disk pools are have constraints on the size and placement of volumes. The 'free extents' information will detail the regions which are available for creating new volumes. A volume cannot span across 2 different free extents.
<pool type="disk">
<name>sda</name>
<source>
<device path='/dev/sda'/>
</source>
<target>
<path>/dev</path>
</target>
</pool>
The disk volume pool accepts the following pool format types, representing the common partition table types:
dos
dvh
gpt
mac
bsd
pc98
sun
The dos or gpt formats are recommended for
best portability - the latter is needed for disks larger than 2TB.
The disk volume pool accepts the following volume format types, representing the common partition entry types:
none
linux
fat16
fat32
linux-swap
linux-lvm
linux-raid
extended
This provides a pool based on an iSCSI target. Volumes must be
pre-allocated on the iSCSI server, and cannot be created via
the libvirt APIs. Since /dev/XXX names may change each time libvirt
logs into the iSCSI target, it is recommended to configure the pool
to use /dev/disk/by-path or /dev/disk/by-id
for the target path. These provide persistent stable naming for LUNs
<pool type="iscsi">
<name>virtimages</name>
<source>
<host name="iscsi.example.com"/>
<device path="demo-target"/>
</source>
<target>
<path>/dev/disk/by-path</path>
</target>
</pool>
The iSCSI volume pool does not use the pool format type element.
The iSCSI volume pool does not use the volume format type element.
This provides a pool based on a SCSI HBA. Volumes are preexisting SCSI
LUNs, and cannot be created via the libvirt APIs. Since /dev/XXX names
aren't generally stable, it is recommended to configure the pool
to use /dev/disk/by-path or /dev/disk/by-id
for the target path. These provide persistent stable naming for LUNs
Since 0.6.2
<pool type="scsi">
<name>virtimages</name>
<source>
<adapter name="host0"/>
</source>
<target>
<path>/dev/disk/by-path</path>
</target>
</pool>
The SCSI volume pool does not use the pool format type element.
The SCSI volume pool does not use the volume format type element.
This provides a pool that contains all the multipath devices on the
host. Volume creating is not supported via the libvirt APIs.
The target element is actually ignored, but one is required to appease
the libvirt XML parser.
Configuring multipathing is not currently supported, this just covers
the case where users want to discover all the available multipath
devices, and assign them to guests.
Since 0.7.1
<pool type="mpath">
<name>virtimages</name>
<target>
<path>/dev/mapper</path>
</target>
</pool>
The Multipath volume pool does not use the pool format type element.
The Multipath volume pool does not use the volume format type element.
This storage driver provides a pool which contains all RBD
images in a RADOS pool. RBD (RADOS Block Device) is part
of the Ceph distributed storage project.
This backend only supports Qemu with RBD support. Kernel RBD
which exposes RBD devices as block devices in /dev is not
supported. RBD images created with this storage backend
can be accessed through kernel RBD if configured manually, but
this backend does not provide mapping for these images.
Images created with this backend can be attached to Qemu guests
when Qemu is build with RBD support (Since Qemu 0.14.0). The
backend supports cephx authentication for communication with the
Ceph cluster. Storing the cephx authentication key is done with
the libvirt secret mechanism. The UUID in the example pool input
refers to the UUID of the stored secret.
Since 0.9.13
<pool type="rbd">
<name>myrbdpool</name>
<source>
<name>rbdpool</name>
<host name='1.2.3.4' port='6789'/>
<host name='my.ceph.monitor' port='6789'/>
<host name='third.ceph.monitor' port='6789'/>
<auth username='admin' type='ceph'>
<secret uuid='2ec115d7-3a88-3ceb-bc12-0ac909a6fd87'/>
</auth>
</source>
</pool>
<volume>
<name>myvol</name>
<key>rbd/myvol</key>
<source>
</source>
<capacity unit='bytes'>53687091200</capacity>
<allocation unit='bytes'>53687091200</allocation>
<target>
<path>rbd:rbd/myvol</path>
<format type='unknown'/>
<permissions>
<mode>00</mode>
<owner>0</owner>
<group>0</group>
</permissions>
</target>
</volume>
RBD images can be attached to Qemu guests when Qemu is built with RBD support. Information about attaching a RBD image to a guest can be found at format domain page.
The RBD pool does not use the pool format type element.
The RBD pool does not use the volume format type element.