Merge pull request #1561 from stgraber/main

Discard blocks on LVM resize

Author: hallyn

internal/linux/discard.go

@@ -11,7 +11,9 @@ import (
 // ClearBlock fully resets a block device or disk file using the most efficient mechanism available.
 // For files, it will truncate them down to zero and back to their original size.
 // For blocks, it will attempt a variety of discard options, validating the result with marker files and eventually fallback to full zero-ing.
-func ClearBlock(blockPath string) error {
+//
+// An offset can be specified to only reset a part of a device.
+func ClearBlock(blockPath string, blockOffset int64) error {
 	// Open the block device for checking.
 	fd, err := os.OpenFile(blockPath, os.O_RDWR, 0644)
 	if err != nil {
@@ -39,7 +41,7 @@ func ClearBlock(blockPath string) error {
 
 	if !IsBlockdev(st.Mode()) {
 		// For files, truncate them.
-		err := fd.Truncate(0)
+		err := fd.Truncate(blockOffset)
 		if err != nil {
 			return err
 		}
@@ -55,20 +57,47 @@ func ClearBlock(blockPath string) error {
 	// Blocks are trickier to reset with options varying based on disk features.
 	// We use a set of 3 markers to validate whether it was reset.
 	marker := []byte("INCUS")
-	markerOffsetStart := int64(0)
-	markerOffsetMiddle := size / 2
-	markerOffsetEnd := size - 10
+	markerLength := int64(len(marker))
+	markerOffsetStart := blockOffset
+	markerOffsetMiddle := blockOffset + ((size - blockOffset) / 2)
+	markerOffsetEnd := size - markerLength
+
+	if markerOffsetStart+markerLength > size {
+		// No markers can fit.
+		markerOffsetStart = -1
+		markerOffsetMiddle = -1
+		markerOffsetEnd = -1
+	} else {
+		if markerOffsetMiddle <= markerOffsetStart+markerLength {
+			// Middle marker goes over start marker.
+			markerOffsetMiddle = -1
+		}
+
+		if markerOffsetEnd <= markerOffsetMiddle+markerLength {
+			// End marker goes over middle marker.
+			markerOffsetEnd = -1
+		}
+
+		if markerOffsetEnd <= markerOffsetStart+markerLength {
+			// End marker goes over start marker.
+			markerOffsetEnd = -1
+		}
+	}
 
 	writeMarkers := func(fd *os.File) error {
 		for _, offset := range []int64{markerOffsetStart, markerOffsetMiddle, markerOffsetEnd} {
+			if offset < 0 {
+				continue
+			}
+
 			// Write the marker at the set offset.
 			n, err := fd.WriteAt(marker, offset)
 			if err != nil {
 				return err
 			}
 
-			if n != len(marker) {
-				return fmt.Errorf("Only managed to write %d bytes out of %d of the %d offset marker", n, len(marker), offset)
+			if n != int(markerLength) {
+				return fmt.Errorf("Only managed to write %d bytes out of %d of the %d offset marker", n, markerLength, offset)
 			}
 		}
 
@@ -79,17 +108,21 @@ func ClearBlock(blockPath string) error {
 		found := 0
 
 		for _, offset := range []int64{markerOffsetStart, markerOffsetMiddle, markerOffsetEnd} {
-			fmt.Printf("offset=%d\n", offset)
-			buf := make([]byte, 5)
+			if offset < 0 {
+				found++
+				continue
+			}
+
+			buf := make([]byte, markerLength)
 
 			// Read the marker from the offset.
 			n, err := fd.ReadAt(buf, offset)
 			if err != nil {
 				return found, err
 			}
 
-			if n != len(marker) {
-				return found, fmt.Errorf("Only managed to read %d bytes out of %d of the %d offset marker", n, len(marker), offset)
+			if n != int(markerLength) {
+				return found, fmt.Errorf("Only managed to read %d bytes out of %d of the %d offset marker", n, markerLength, offset)
 			}
 
 			// Check if we found it.
@@ -120,7 +153,7 @@ func ClearBlock(blockPath string) error {
 	_ = fd.Close()
 
 	// Attempt a secure discard run.
-	_, err = subprocess.RunCommand("blkdiscard", "-f", "-s", blockPath)
+	_, err = subprocess.RunCommand("blkdiscard", "-f", "-o", fmt.Sprintf("%d", blockOffset), "-s", blockPath)
 	if err == nil {
 		// Check if the markers are gone.
 		fd, err := os.Open(blockPath)
@@ -145,7 +178,7 @@ func ClearBlock(blockPath string) error {
 	}
 
 	// Attempt a regular discard run.
-	_, err = subprocess.RunCommand("blkdiscard", "-f", blockPath)
+	_, err = subprocess.RunCommand("blkdiscard", "-f", "-o", fmt.Sprintf("%d", blockOffset), blockPath)
 	if err == nil {
 		// Check if the markers are gone.
 		fd, err := os.Open(blockPath)
@@ -170,7 +203,7 @@ func ClearBlock(blockPath string) error {
 	}
 
 	// Attempt device zero-ing.
-	_, err = subprocess.RunCommand("blkdiscard", "-f", "-z", blockPath)
+	_, err = subprocess.RunCommand("blkdiscard", "-f", "-o", fmt.Sprintf("%d", blockOffset), "-z", blockPath)
 	if err == nil {
 		// Check if the markers are gone.
 		fd, err := os.Open(blockPath)
@@ -209,12 +242,17 @@ func ClearBlock(blockPath string) error {
 
 	defer fd.Close()
 
-	n, err := io.CopyN(fd, zero, size)
+	_, err = fd.Seek(blockOffset, 0)
+	if err != nil {
+		return err
+	}
+
+	n, err := io.CopyN(fd, zero, size-blockOffset)
 	if err != nil {
 		return err
 	}
 
-	if n != size {
+	if n != (size - blockOffset) {
 		return fmt.Errorf("Only managed to reset %d bytes out of %d", n, size)
 	}
 

internal/server/storage/drivers/driver_lvm_utils.go

@@ -568,11 +568,31 @@ func (d *lvm) resizeLogicalVolume(lvPath string, sizeBytes int64) error {
 		args = append(args, "--fs=ignore")
 	}
 
+	// If needed, get the original LV size.
+	var oldSizeBytes int64
+	if !d.usesThinpool() {
+		oldSizeBytes, err = d.logicalVolumeSize(lvPath)
+		if err != nil {
+			return err
+		}
+	}
+
 	_, err = subprocess.TryRunCommand("lvresize", args...)
 	if err != nil {
 		return err
 	}
 
+	// On thick pools, discard the blocks in the additional space when the volume is grown.
+	if !d.usesThinpool() {
+		if oldSizeBytes < sizeBytes {
+			// Discard the new blocks.
+			err := linux.ClearBlock(lvPath, sizeBytes)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
 	d.logger.Debug("Logical volume resized", logger.Ctx{"dev": lvPath, "size": fmt.Sprintf("%db", sizeBytes)})
 	return nil
 }

internal/server/storage/drivers/generic_vfs.go

@@ -326,7 +326,7 @@ func genericVFSCreateVolumeFromMigration(d Driver, initVolume func(vol Volume) (
 		}
 
 		// Reset the disk.
-		err := linux.ClearBlock(path)
+		err := linux.ClearBlock(path, 0)
 		if err != nil {
 			return err
 		}
@@ -770,7 +770,7 @@ func genericVFSBackupUnpack(d Driver, sysOS *sys.OS, vol Volume, snapshots []str
 					var allowUnsafeResize bool
 
 					// Reset the disk.
-					err = linux.ClearBlock(targetPath)
+					err = linux.ClearBlock(targetPath, 0)
 					if err != nil {
 						return err
 					}