Make the block overhead configurable

This patch will allow the user to configure the block overhead.
Currently it defaults to 0. The overhead is required when migrating to
encrypted Ceph RBD (block). The pod may see less space on the disk and
therefore the migration will fail when it tries to allocate the last
sectors. See more about encrypted Ceph RBD in:
https://docs.ceph.com/en/quincy/rbd/rbd-encryption/

The value needs to be set in the ForkliftController spec under the
value: `controller_block_overhead`. The addition will be the fixed
number provided to the size of the disk.

Signed-off-by: Liran Rotenberg <lrotenbe@redhat.com>

Author: liranr23

operator/config/manager/manager.yaml

@@ -66,6 +66,8 @@ spec:
           value: ${CDI_EXPORT_TOKEN_TTL}
         - name: FILESYSTEM_OVERHEAD
           value: ${FILESYSTEM_OVERHEAD}
+        - name: BLOCK_OVERHEAD
+          value: ${BLOCK_OVERHEAD}
         - name: POPULATOR_CONTROLLER_IMAGE
           value: ${POPULATOR_CONTROLLER_IMAGE}
         - name: OVIRT_POPULATOR_IMAGE

operator/roles/forkliftcontroller/defaults/main.yml

@@ -35,6 +35,7 @@ controller_vsphere_incremental_backup: true
 controller_ovirt_warm_migration: true
 controller_max_vm_inflight: 20
 controller_filesystem_overhead: 10
+controller_block_overhead: 0
 profiler_volume_path: "/var/cache/profiler"
 
 inventory_volume_path: "/var/cache/inventory"

operator/roles/forkliftcontroller/templates/controller/deployment-controller.yml.j2

@@ -80,6 +80,10 @@ spec:
         - name: FILESYSTEM_OVERHEAD
           value: "{{ controller_filesystem_overhead }}"
 {% endif %}
+{% if controller_block_overhead is number %}
+        - name: BLOCK_OVERHEAD
+          value: "{{ controller_block_overhead }}"
+{% endif %}
 {% if controller_vsphere_incremental_backup|bool %}
         - name: FEATURE_VSPHERE_INCREMENTAL_BACKUP
           value: "true"

pkg/controller/plan/adapter/openstack/builder.go

@@ -1098,10 +1098,7 @@ func (r *Builder) persistentVolumeClaimWithSourceRef(image model.Image, storageC
 		err = liberr.Wrap(err)
 		return
 	}
-
-	if *volumeMode == core.PersistentVolumeFilesystem {
-		virtualSize = utils.CalculateSpaceWithOverhead(virtualSize)
-	}
+	virtualSize = utils.CalculateSpaceWithOverhead(virtualSize, volumeMode)
 
 	// The image might be a VM Snapshot Image and has no volume associated to it
 	if originalVolumeDiskId, ok := image.Properties["forklift_original_volume_id"]; ok {

pkg/controller/plan/adapter/ovirt/builder.go

@@ -793,24 +793,19 @@ func (r *Builder) getDefaultVolumeAndAccessMode(storageClassName string) ([]core
 // Build a PersistentVolumeClaim with DataSourceRef for VolumePopulator
 func (r *Builder) persistentVolumeClaimWithSourceRef(diskAttachment model.XDiskAttachment, storageClassName string, populatorName string,
 	annotations map[string]string) (pvc *core.PersistentVolumeClaim, err error) {
-
-	// We add 10% overhead because of the fsOverhead in CDI, around 5% to ext4 and 5% for root partition.
-	// This value is configurable using `FILESYSTEM_OVERHEAD`
 	diskSize := diskAttachment.Disk.ProvisionedSize
-
 	var accessModes []core.PersistentVolumeAccessMode
 	var volumeMode *core.PersistentVolumeMode
 	accessModes, volumeMode, err = r.getDefaultVolumeAndAccessMode(storageClassName)
 	if err != nil {
 		err = liberr.Wrap(err)
 		return
 	}
-
-	// Accounting for fsOverhead is only required for `volumeMode: Filesystem`, as we may not have enough space
-	// after creating a filesystem on an underlying block device
-	if *volumeMode == core.PersistentVolumeFilesystem {
-		diskSize = utils.CalculateSpaceWithOverhead(diskSize)
-	}
+	// We add 10% overhead because of the fsOverhead in CDI, around 5% to ext4 and 5% for root partition.
+	// This value is configurable using `FILESYSTEM_OVERHEAD`
+	// Encrypted Ceph RBD makes the pod see less space, this possible overhead needs to be taken into account.
+	// For Block the value is configurable using `BLOCK_OVERHEAD`
+	diskSize = utils.CalculateSpaceWithOverhead(diskSize, volumeMode)
 
 	annotations[AnnImportDiskId] = diskAttachment.ID
 

pkg/controller/plan/util/utils.go

@@ -4,6 +4,7 @@ import (
 	"math"
 
 	"github.com/konveyor/forklift-controller/pkg/settings"
+	core "k8s.io/api/core/v1"
 )
 
 // Disk alignment size used to align FS overhead,
@@ -20,8 +21,13 @@ func roundUp(requestedSpace, multiple int64) int64 {
 	return int64(partitions) * multiple
 }
 
-func CalculateSpaceWithOverhead(requestedSpace int64) int64 {
+func CalculateSpaceWithOverhead(requestedSpace int64, volumeMode *core.PersistentVolumeMode) int64 {
 	alignedSize := roundUp(requestedSpace, DefaultAlignBlockSize)
-	spaceWithOverhead := int64(math.Ceil(float64(alignedSize) / (1 - float64(settings.Settings.FileSystemOverhead)/100)))
+	var spaceWithOverhead int64
+	if *volumeMode == core.PersistentVolumeFilesystem {
+		spaceWithOverhead = int64(math.Ceil(float64(alignedSize) / (1 - float64(settings.Settings.FileSystemOverhead)/100)))
+	} else {
+		spaceWithOverhead = alignedSize + int64(settings.Settings.BlockOverhead)
+	}
 	return spaceWithOverhead
 }

pkg/settings/migration.go

@@ -20,6 +20,7 @@ const (
 	SnapshotStatusCheckRate = "SNAPSHOT_STATUS_CHECK_RATE"
 	CDIExportTokenTTL       = "CDI_EXPORT_TOKEN_TTL"
 	FileSystemOverhead      = "FILESYSTEM_OVERHEAD"
+	BlockOverhead           = "BLOCK_OVERHEAD"
 )
 
 // Migration settings
@@ -45,6 +46,8 @@ type Migration struct {
 	CDIExportTokenTTL int
 	// FileSystem overhead in percantage
 	FileSystemOverhead int
+	// Block fixed overhead size
+	BlockOverhead int
 }
 
 // Load settings.
@@ -85,6 +88,9 @@ func (r *Migration) Load() (err error) {
 	if r.FileSystemOverhead, err = getNonNegativeEnvLimit(FileSystemOverhead, 10); err != nil {
 		return liberr.Wrap(err)
 	}
+	if r.BlockOverhead, err = getNonNegativeEnvLimit(BlockOverhead, 0); err != nil {
+		return liberr.Wrap(err)
+	}
 
 	return
 }