feat(uuid): add partition table uuid support

Author: cospotato

cmd/ndm_daemonset/probe/addhandler.go

@@ -22,6 +22,7 @@ import (
 	apis "github.com/openebs/node-disk-manager/api/v1alpha1"
 	"github.com/openebs/node-disk-manager/blockdevice"
 	"github.com/openebs/node-disk-manager/db/kubernetes"
+	"github.com/openebs/node-disk-manager/pkg/features"
 	"github.com/openebs/node-disk-manager/pkg/partition"
 
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -111,18 +112,29 @@ func (pe *ProbeEvent) addBlockDevice(bd blockdevice.BlockDevice, bdAPIList *apis
 			len(bd.DependentDevices.Holders) > 0 {
 			klog.V(4).Infof("device: %s has holders/partitions. %+v", bd.DevPath, bd.DependentDevices)
 		} else {
-			klog.Infof("starting to create partition on device: %s", bd.DevPath)
 			d := partition.Disk{
 				DevPath:          bd.DevPath,
 				DiskSize:         bd.Capacity.Storage,
 				LogicalBlockSize: uint64(bd.DeviceAttributes.LogicalBlockSize),
 			}
-			if err := d.CreateSinglePartition(); err != nil {
-				klog.Errorf("error creating partition for %s, %v", bd.DevPath, err)
-				return err
+
+			if features.FeatureGates.IsEnabled(features.PartitionTableUUID) {
+				klog.Infof("starting to create partition table on device: %s", bd.DevPath)
+				if err := d.CreatePartitionTable(); err != nil {
+					klog.Errorf("error create partition table for %s, %v", bd.DevPath, err)
+					return err
+				}
+				klog.Infof("created new partition table in %s", bd.DevPath)
+				return ErrNeedRescan
+			} else {
+				klog.Infof("starting to create partition on device: %s", bd.DevPath)
+				if err := d.CreateSinglePartition(); err != nil {
+					klog.Errorf("error creating partition for %s, %v", bd.DevPath, err)
+					return err
+				}
+				klog.Infof("created new partition in %s", bd.DevPath)
+				return nil
 			}
-			klog.Infof("created new partition in %s", bd.DevPath)
-			return nil
 		}
 	} else {
 		bd.UUID = uuid

cmd/ndm_daemonset/probe/eventhandler.go

@@ -17,6 +17,8 @@ limitations under the License.
 package probe
 
 import (
+	"errors"
+
 	"github.com/openebs/node-disk-manager/blockdevice"
 	"github.com/openebs/node-disk-manager/cmd/ndm_daemonset/controller"
 	"github.com/openebs/node-disk-manager/pkg/features"
@@ -38,6 +40,10 @@ const (
 	ChangeEA EventAction = libudevwrapper.UDEV_ACTION_CHANGE
 )
 
+var (
+	ErrNeedRescan = errors.New("need rescan")
+)
+
 // ProbeEvent struct contain a copy of controller it will update disk resources
 type ProbeEvent struct {
 	Controller *controller.Controller
@@ -55,7 +61,7 @@ func (pe *ProbeEvent) addBlockDeviceEvent(msg controller.EventMessage) {
 
 	isGPTBasedUUIDEnabled := features.FeatureGates.IsEnabled(features.GPTBasedUUID)
 
-	isErrorDuringUpdate := false
+	isNeedRescan := false
 	erroredDevices := make([]string, 0)
 
 	// iterate through each block device and perform the add/update operation
@@ -82,9 +88,11 @@ func (pe *ProbeEvent) addBlockDeviceEvent(msg controller.EventMessage) {
 			}
 			err := pe.addBlockDevice(*device, bdAPIList)
 			if err != nil {
-				isErrorDuringUpdate = true
-				erroredDevices = append(erroredDevices, device.DevPath)
-				klog.Error(err)
+				isNeedRescan = true
+				if !errors.Is(err, ErrNeedRescan) {
+					erroredDevices = append(erroredDevices, device.DevPath)
+					klog.Error(err)
+				}
 			}
 		} else {
 			// if GPTBasedUUID is disabled and the device type is partition,
@@ -98,13 +106,13 @@ func (pe *ProbeEvent) addBlockDeviceEvent(msg controller.EventMessage) {
 			existingBlockDeviceResource := pe.Controller.GetExistingBlockDeviceResource(bdAPIList, deviceInfo.UUID)
 			err := pe.Controller.PushBlockDeviceResource(existingBlockDeviceResource, deviceInfo)
 			if err != nil {
-				isErrorDuringUpdate = true
+				isNeedRescan = true
 				klog.Error(err)
 			}
 		}
 	}
 
-	if isErrorDuringUpdate {
+	if isNeedRescan {
 		go Rescan(pe.Controller)
 	}
 }

cmd/ndm_daemonset/probe/uuid.go

@@ -20,6 +20,8 @@ import (
 	"os"
 
 	"github.com/openebs/node-disk-manager/blockdevice"
+	"github.com/openebs/node-disk-manager/pkg/blkid"
+	"github.com/openebs/node-disk-manager/pkg/features"
 	"github.com/openebs/node-disk-manager/pkg/util"
 
 	"k8s.io/klog"
@@ -84,6 +86,28 @@ func generateUUID(bd blockdevice.BlockDevice) (string, bool) {
 		klog.Infof("device(%s) has a filesystem, using filesystem UUID: %s", bd.DevPath, bd.FSInfo.FileSystemUUID)
 		uuidField = bd.FSInfo.FileSystemUUID
 		ok = true
+	case features.FeatureGates.IsEnabled(features.PartitionTableUUID) && len(bd.PartitionInfo.PartitionTableType) > 0:
+		// if the host is CentOS 7, the `libblkid` version on host is `2.23`,
+		// but the `PTUUID` tag was start to provide from `2.24`. This will cause
+		// the udev cache fetched from host udevd will not contain env `ID_PART_TABLE_UUID`.
+		// Fortunately, the `libblkid` version in our base container (ubuntu 16.04)
+		// is `2.27.1`, will provide `PTUUID` tag, so we should fetch `PTUUID` from `blkid`.
+		partUUID := ""
+		if len(bd.PartitionInfo.PartitionTableUUID) == 0 {
+			deviceIdentifier := blkid.DeviceIdentifier{DevPath: bd.DevPath}
+			partUUID = deviceIdentifier.GetPartitionUUID()
+		} else {
+			partUUID = bd.PartitionInfo.PartitionTableUUID
+		}
+
+		if len(partUUID) == 0 {
+			klog.Errorf("device(%s) has a partition table, but can not get partition table uuid", bd.DevPath)
+			break
+		}
+
+		klog.Infof("device(%s) has a partition table, use partition table uuid: %s", bd.DevPath, partUUID)
+		uuidField = partUUID
+		ok = true
 	}
 
 	if ok {

cmd/ndm_daemonset/probe/uuid_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"github.com/openebs/node-disk-manager/blockdevice"
+	"github.com/openebs/node-disk-manager/pkg/features"
 	"github.com/openebs/node-disk-manager/pkg/util"
 	"github.com/stretchr/testify/assert"
 )
@@ -30,15 +31,30 @@ func TestGenerateUUID(t *testing.T) {
 	fakeSerial := "CT500MX500SSD1"
 	fakeFileSystemUUID := "149108ca-f404-4556-a263-04943e6cb0b3"
 	fakePartitionUUID := "065e2357-05"
+	fakePartitionTableUUID := "6f479331-dad4-4ccb-b146-5c359c55399b"
 	fakeLVM_DM_UUID := "LVM-j2xmqvbcVWBQK9Jdttte3CyeVTGgxtVV5VcCi3nxdwihZDxSquMOBaGL5eymBNvk"
 	fakeCRYPT_DM_UUID := "CRYPT-LUKS1-f4608c76343d4b5badaf6651d32f752b-backup"
 	loopDevicePath := "/dev/loop98"
 	hostName, _ := os.Hostname()
+	features.FeatureGates.SetFeatureFlag([]string{
+		"GPTBasedUUID=1",
+		"PartitionTableUUID=1",
+	})
 	tests := map[string]struct {
 		bd       blockdevice.BlockDevice
 		wantUUID string
 		wantOk   bool
 	}{
+		"debiceType-disk with PartitionTableUUID": {
+			bd: blockdevice.BlockDevice{
+				PartitionInfo: blockdevice.PartitionInformation{
+					PartitionTableType: "gpt",
+					PartitionTableUUID: fakePartitionTableUUID,
+				},
+			},
+			wantUUID: blockdevice.BlockDevicePrefix + util.Hash(fakePartitionTableUUID),
+			wantOk:   true,
+		},
 		"deviceType-disk with WWN": {
 			bd: blockdevice.BlockDevice{
 				DeviceAttributes: blockdevice.DeviceAttribute{

deploy/helm/charts/templates/daemonset.yaml

@@ -39,6 +39,9 @@ spec:
 {{- if .Values.featureGates.enabled }}
 {{- if .Values.featureGates.GPTBasedUUID.enabled }}
           - --feature-gates={{ .Values.featureGates.GPTBasedUUID.featureGateFlag }}
+{{- if .Values.featureGates.PartitionTableUUID.enabled }}
+          - --feature-gates={{ .Values.featureGates.PartitionTableUUID.featureGateFlag }}
+{{- end}}
 {{- end}}
 {{- if .Values.featureGates.APIService.enabled }}
           - --feature-gates={{ .Values.featureGates.APIService.featureGateFlag }}

deploy/helm/charts/values.yaml

@@ -122,6 +122,9 @@ featureGates:
   GPTBasedUUID:
     enabled: true
     featureGateFlag: "GPTBasedUUID"
+  PartitionTableUUID:
+    enabled: false
+    featureGateFlag: "PartitionTableUUID"
   APIService:
     enabled: false
     featureGateFlag: "APIService"

pkg/blkid/blkid.go

@@ -30,7 +30,8 @@ import (
 )
 
 const (
-	fsTypeIdentifier = "TYPE"
+	fsTypeIdentifier        = "TYPE"
+	partitionUUIDIdentifier = "PTUUID"
 )
 
 type DeviceIdentifier struct {
@@ -54,3 +55,19 @@ func (di *DeviceIdentifier) GetOnDiskFileSystem() string {
 
 	return C.GoString(fstype)
 }
+
+func (di *DeviceIdentifier) GetPartitionUUID() string {
+	var blkidType *C.char
+	blkidType = C.CString(partitionUUIDIdentifier)
+	defer C.free(unsafe.Pointer(blkidType))
+
+	var device *C.char
+	device = C.CString(di.DevPath)
+	defer C.free(unsafe.Pointer(device))
+
+	var ptuuid *C.char
+	ptuuid = C.blkid_get_tag_value(nil, blkidType, device)
+	defer C.free(unsafe.Pointer(ptuuid))
+
+	return C.GoString(ptuuid)
+}

pkg/features/features.go

@@ -50,6 +50,12 @@ const (
 	// ChangeDetection is used to enable detecting changes to
 	// blockdevice size, filesystem, and mount-points.
 	ChangeDetection Feature = "ChangeDetection"
+
+	// PartitionTableUUID feature flag is used to enable use a
+	// partition table uuid instead of create partition described in
+	// https://github.com/openebs/node-disk-manager/issues/621 .
+	// This feature must enabled with GPTBasedUUID.
+	PartitionTableUUID Feature = "PartitionTableUUID"
 )
 
 // supportedFeatures is the list of supported features. This is used while parsing the
@@ -59,14 +65,16 @@ var supportedFeatures = []Feature{
 	APIService,
 	UseOSDisk,
 	ChangeDetection,
+	PartitionTableUUID,
 }
 
 // defaultFeatureGates is the default features that will be applied to the application
 var defaultFeatureGates = map[Feature]bool{
-	GPTBasedUUID:    true,
-	APIService:      false,
-	UseOSDisk:       false,
-	ChangeDetection: false,
+	GPTBasedUUID:       true,
+	APIService:         false,
+	UseOSDisk:          false,
+	ChangeDetection:    false,
+	PartitionTableUUID: false,
 }
 
 // featureFlag is a map representing the flag and its state

pkg/partition/partition.go

@@ -164,3 +164,40 @@ func (d *Disk) CreateSinglePartition() error {
 	klog.Infof("created a single partition on disk %s", d.DevPath)
 	return nil
 }
+
+// CreatePartitionTable create a GPT header on the disk
+func (d *Disk) CreatePartitionTable() error {
+	fd, err := diskfs.Open(d.DevPath)
+	if err != nil {
+		return fmt.Errorf("error opening disk fd for disk %s: %v", d.DevPath, err)
+	}
+	d.disk = fd
+
+	// check for any existing partition table on the disk
+	if _, err := d.disk.GetPartitionTable(); err == nil {
+		klog.Errorf("aborting partition creation, disk %s already contains a known partition table", d.DevPath)
+		return fmt.Errorf("disk %s contains a partition table, cannot create a new partition table", d.DevPath)
+	}
+
+	// check for any existing filesystem on the disk
+	deviceIdentifier := blkid.DeviceIdentifier{
+		DevPath: d.DevPath,
+	}
+	if fs := deviceIdentifier.GetOnDiskFileSystem(); len(fs) != 0 {
+		klog.Errorf("aborting partition creation, disk %s contains a known filesystem: %s", d.DevPath, fs)
+		return fmt.Errorf("disk %s contains a known filesyste: %s, cannot create a partition table", d.DevPath, fs)
+	}
+
+	err = d.createPartitionTable()
+	if err != nil {
+		klog.Error("partition table initialization failed")
+		return err
+	}
+
+	err = d.disk.Partition(d.table)
+	if err != nil {
+		return fmt.Errorf("unable to create/write partition table. %v", err)
+	}
+	klog.Infof("created partition table on disk %s", d.DevPath)
+	return nil
+}