feat(uuid): add partition table uuid support

cospotato · cospotato · commit 039bc907e60f · 2021-11-18T16:36:23.000+08:00
Signed-off-by: cospotato &lt;i@0x233.cn&gt;
diff --git a/cmd/ndm_daemonset/probe/addhandler.go b/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
diff --git a/cmd/ndm_daemonset/probe/blkidprobe.go b/cmd/ndm_daemonset/probe/blkidprobe.go
@@ -0,0 +1,70 @@
+/*
+Copyright 2020 The OpenEBS Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package probe
+
+import (
+	"github.com/openebs/node-disk-manager/blockdevice"
+	"github.com/openebs/node-disk-manager/cmd/ndm_daemonset/controller"
+	"github.com/openebs/node-disk-manager/pkg/blkid"
+	"k8s.io/klog"
+)
+
+const (
+	blkidProbePriority = 4
+)
+
+var (
+	blkidProbeState = defaultEnabled
+)
+
+type blkidProbe struct {
+}
+
+var blkidProbeRegister = func() {
+	// Get a controller object
+	ctrl := <-controller.ControllerBroadcastChannel
+	if ctrl == nil {
+		klog.Error("unable to configure custom tag probe")
+		return
+	}
+	probe := &blkidProbe{}
+
+	newRegisterProbe := &registerProbe{
+		priority:   blkidProbePriority,
+		name:       "blkid probe",
+		state:      blkidProbeState,
+		pi:         probe,
+		controller: ctrl,
+	}
+
+	newRegisterProbe.register()
+}
+
+func (bp *blkidProbe) Start() {}
+
+func (bp *blkidProbe) FillBlockDeviceDetails(bd *blockdevice.BlockDevice) {
+	di := &blkid.DeviceIdentifier{DevPath: bd.DevPath}
+
+	bd.FSInfo.FileSystem = di.GetOnDiskFileSystem()
+
+	// 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`.
+	bd.PartitionInfo.PartitionTableUUID = di.GetPartitionUUID()
+}
diff --git a/cmd/ndm_daemonset/probe/eventhandler.go b/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)
 	}
 }
diff --git a/cmd/ndm_daemonset/probe/probe.go b/cmd/ndm_daemonset/probe/probe.go
@@ -35,6 +35,7 @@ var RegisteredProbes = []func(){
 	sysfsProbeRegister,
 	usedbyProbeRegister,
 	customTagProbeRegister,
+	blkidProbeRegister,
 }
 
 type registerProbe struct {
diff --git a/cmd/ndm_daemonset/probe/uuid.go b/cmd/ndm_daemonset/probe/uuid.go
@@ -20,6 +20,7 @@ import (
 	"os"
 
 	"github.com/openebs/node-disk-manager/blockdevice"
+	"github.com/openebs/node-disk-manager/pkg/features"
 	"github.com/openebs/node-disk-manager/pkg/util"
 
 	"k8s.io/klog"
@@ -84,6 +85,15 @@ 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 len(bd.PartitionInfo.PartitionTableUUID) == 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, bd.PartitionInfo.PartitionTableUUID)
+		uuidField = bd.PartitionInfo.PartitionTableUUID
+		ok = true
 	}
 
 	if ok {
diff --git a/cmd/ndm_daemonset/probe/uuid_test.go b/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{
diff --git a/deploy/ndm-operator.yaml b/deploy/ndm-operator.yaml
@@ -518,6 +518,9 @@ spec:
         args:
         - -v=4
         - --feature-gates="GPTBasedUUID"
+        # Use partition table UUID instead of create single partition to get
+        # partition UUID. Require `GPTBasedUUID` to be enabled with.
+        # - --feature-gates="PartitionTableUUID"
         - --feature-gates="APIService"
         # Detect changes to device size, filesystem and mount-points without restart.
         #- --feature-gates="ChangeDetection"
diff --git a/deploy/yamls/node-disk-manager.yaml b/deploy/yamls/node-disk-manager.yaml
@@ -33,6 +33,9 @@ spec:
         args:
         - -v=4
         - --feature-gates="GPTBasedUUID"
+        # Use partition table UUID instead of create single partition to get
+        # partition UUID. Require `GPTBasedUUID` to be enabled with.
+        # - --feature-gates="PartitionTableUUID"
         - --feature-gates="APIService"
         # Detect changes to device size, filesystem and mount-points without restart.
         #- --feature-gates="ChangeDetection"
diff --git a/pkg/blkid/blkid.go b/pkg/blkid/blkid.go
@@ -1,3 +1,6 @@
+//go:build (linux && ignore) || cgo
+// +build linux,ignore cgo
+
 /*
 Copyright 2020 The OpenEBS Authors
 
@@ -14,8 +17,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// +build linux, cgo
-
 package blkid
 
 /*
@@ -30,8 +31,9 @@ import (
 )
 
 const (
-	fsTypeIdentifier = "TYPE"
-	labelIdentifier  = "LABEL"
+	fsTypeIdentifier        = "TYPE"
+	labelIdentifier         = "LABEL"
+	partitionUUIDIdentifier = "PTUUID"
 )
 
 type DeviceIdentifier struct {
@@ -50,6 +52,12 @@ func (di *DeviceIdentifier) GetOnDiskLabel() string {
 	return di.GetTagValue(labelIdentifier)
 }
 
+// GetPartitionUUID returns the partition UUID present on the disk by reading from the disk
+// using libblkid
+func (di *DeviceIdentifier) GetPartitionUUID() string {
+	return di.GetTagValue(partitionUUIDIdentifier)
+}
+
 func (di *DeviceIdentifier) GetTagValue(tag string) string {
 	var blkidType *C.char
 	blkidType = C.CString(tag)
diff --git a/pkg/features/features.go b/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,17 +65,23 @@ 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,
 }
 
-var featureDependencies = map[Feature][]Feature{}
+var featureDependencies = map[Feature][]Feature{
+	PartitionTableUUID: {
+		GPTBasedUUID,
+	},
+}
 
 // featureFlag is a map representing the flag and its state
 type featureFlag map[Feature]bool
diff --git a/pkg/partition/partition.go b/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
+}

Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ var RegisteredProbes = []func(){`
`35`	`35`	`sysfsProbeRegister,`
`36`	`36`	`usedbyProbeRegister,`
`37`	`37`	`customTagProbeRegister,`
	`38`	`+ blkidProbeRegister,`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`type registerProbe struct {`