feat: Use WMI to implement Volume API to reduce PowerShell overhead

chore: update

fix

remove New-SmbGlobalMapping

fix header

fix

fix vendor

Author: andyzhangx

pkg/azurefile/azurefile.go

@@ -253,6 +253,7 @@ type Driver struct {
 	appendActimeoOption                    bool
 	printVolumeStatsCallLogs               bool
 	enableKataCCMount                      bool
+	useWinCIMAPI                           bool
 	mounter                                *mount.SafeFormatAndMount
 	server                                 *grpc.Server
 	// lock per volume attach (only for vhd disk feature)
@@ -342,6 +343,7 @@ func NewDriver(options *DriverOptions) *Driver {
 	driver.resolver = new(NetResolver)
 	driver.directVolume = new(directVolume)
 	driver.isKataNode = false
+	driver.useWinCIMAPI = options.UseWinCIMAPI
 
 	var err error
 	getter := func(_ context.Context, _ string) (interface{}, error) { return nil, nil }
@@ -416,7 +418,7 @@ func (d *Driver) Run(ctx context.Context) error {
 	}
 	klog.V(2).Infof("cloud: %s, location: %s, rg: %s, VnetName: %s, VnetResourceGroup: %s, SubnetName: %s", d.cloud.Cloud, d.cloud.Location, d.cloud.ResourceGroup, d.cloud.VnetName, d.cloud.VnetResourceGroup, d.cloud.SubnetName)
 
-	d.mounter, err = mounter.NewSafeMounter(d.enableWindowsHostProcess)
+	d.mounter, err = mounter.NewSafeMounter(d.enableWindowsHostProcess, d.useWinCIMAPI)
 	if err != nil {
 		klog.Fatalf("Failed to get safe mounter. Error: %v", err)
 	}

pkg/azurefile/azurefile_options.go

@@ -45,6 +45,7 @@ type DriverOptions struct {
 	AppendNoShareSockOption                bool
 	AppendNoResvPortOption                 bool
 	AppendActimeoOption                    bool
+	UseWinCIMAPI                           bool
 	SkipMatchingTagCacheExpireInMinutes    int
 	VolStatsCacheExpireInMinutes           int
 	PrintVolumeStatsCallLogs               bool
@@ -85,6 +86,7 @@ func (o *DriverOptions) AddFlags() *flag.FlagSet {
 	fs.BoolVar(&o.AppendNoShareSockOption, "append-nosharesock-option", true, "Whether appending nosharesock option to smb mount command")
 	fs.BoolVar(&o.AppendNoResvPortOption, "append-noresvport-option", true, "Whether appending noresvport option to nfs mount command")
 	fs.BoolVar(&o.AppendActimeoOption, "append-actimeo-option", true, "Whether appending actimeo=0 option to nfs mount command")
+	fs.BoolVar(&o.UseWinCIMAPI, "use-win-cim-api", true, "Whether performing azure file operations using CIM API or Powershell command on Windows node")
 	fs.IntVar(&o.SkipMatchingTagCacheExpireInMinutes, "skip-matching-tag-cache-expire-in-minutes", 30, "The cache expire time in minutes for skipMatchingTagCache")
 	fs.IntVar(&o.VolStatsCacheExpireInMinutes, "vol-stats-cache-expire-in-minutes", 10, "The cache expire time in minutes for volume stats cache")
 	fs.BoolVar(&o.PrintVolumeStatsCallLogs, "print-volume-stats-call-logs", false, "Whether to print volume statfs call logs with log level 2")

pkg/azurefile/fake_mounter.go

@@ -74,7 +74,7 @@ func (f *fakeMounter) IsMountPoint(file string) (bool, error) {
 // NewFakeMounter fake mounter
 func NewFakeMounter() (*mount.SafeFormatAndMount, error) {
 	if runtime.GOOS == "windows" {
-		return mounter.NewSafeMounter(true)
+		return mounter.NewSafeMounter(true, true)
 	}
 	return &mount.SafeFormatAndMount{
 		Interface: &fakeMounter{},

pkg/mounter/safe_mounter_host_process_windows.go

@@ -37,10 +37,20 @@ var driverGlobalMountPath = "C:\\var\\lib\\kubelet\\plugins\\kubernetes.io\\csi\
 
 var _ CSIProxyMounter = &winMounter{}
 
-type winMounter struct{}
+type winMounter struct {
+	smbAPI smb.SMBAPI
+}
 
-func NewWinMounter() *winMounter {
-	return &winMounter{}
+func NewWinMounter(useWinCIMAPI bool) *winMounter {
+	var smbAPI smb.SMBAPI
+	if useWinCIMAPI {
+		smbAPI = smb.NewCimSMBAPI()
+	} else {
+		smbAPI = smb.NewPowerShellSMBAPI()
+	}
+	return &winMounter{
+		smbAPI: smbAPI,
+	}
 }
 
 func (mounter *winMounter) SMBMount(source, target, fsType string, mountOptions, sensitiveMountOptions []string) error {
@@ -75,7 +85,7 @@ func (mounter *winMounter) SMBMount(source, target, fsType string, mountOptions,
 		return fmt.Errorf("remote path is empty")
 	}
 
-	isMapped, err := smb.IsSmbMapped(remotePath)
+	isMapped, err := mounter.smbAPI.IsSmbMapped(remotePath)
 	if err != nil {
 		isMapped = false
 	}
@@ -88,7 +98,7 @@ func (mounter *winMounter) SMBMount(source, target, fsType string, mountOptions,
 
 		if !valid {
 			klog.Warningf("RemotePath %s is not valid, removing now", remotePath)
-			if err := smb.RemoveSmbGlobalMapping(remotePath); err != nil {
+			if err := mounter.smbAPI.RemoveSmbGlobalMapping(remotePath); err != nil {
 				klog.Errorf("RemoveSmbGlobalMapping(%s) failed with %v", remotePath, err)
 				return err
 			}
@@ -100,7 +110,7 @@ func (mounter *winMounter) SMBMount(source, target, fsType string, mountOptions,
 		klog.V(2).Infof("Remote %s not mapped. Mapping now!", remotePath)
 		username := mountOptions[0]
 		password := sensitiveMountOptions[0]
-		if err := smb.NewSmbGlobalMapping(remotePath, username, password); err != nil {
+		if err := mounter.smbAPI.NewSmbGlobalMapping(remotePath, username, password); err != nil {
 			klog.Errorf("NewSmbGlobalMapping(%s) failed with %v", remotePath, err)
 			return err
 		}
@@ -136,7 +146,7 @@ func (mounter *winMounter) Unmount(target string) error {
 		klog.V(2).Infof("remote server path: %s, local path: %s", remoteServer, target)
 		if hasDupSMBMount, err := smb.CheckForDuplicateSMBMounts(driverGlobalMountPath, target, remoteServer); err == nil {
 			if !hasDupSMBMount {
-				if err := smb.RemoveSmbGlobalMapping(remoteServer); err != nil {
+				if err := mounter.smbAPI.RemoveSmbGlobalMapping(remoteServer); err != nil {
 					klog.Errorf("RemoveSmbGlobalMapping(%s) failed with %v", target, err)
 				}
 			} else {

pkg/mounter/safe_mounter_unix.go

@@ -24,7 +24,7 @@ import (
 	utilexec "k8s.io/utils/exec"
 )
 
-func NewSafeMounter(_ bool) (*mount.SafeFormatAndMount, error) {
+func NewSafeMounter(_, _ bool) (*mount.SafeFormatAndMount, error) {
 	return &mount.SafeFormatAndMount{
 		Interface: mount.New(""),
 		Exec:      utilexec.New(),

pkg/mounter/safe_mounter_unix_test.go

@@ -23,7 +23,7 @@ import (
 )
 
 func TestNewSafeMounter(t *testing.T) {
-	resp, err := NewSafeMounter(true)
+	resp, err := NewSafeMounter(true, true)
 	assert.NotNil(t, resp)
 	assert.Nil(t, err)
 }

pkg/mounter/safe_mounter_windows.go

@@ -291,11 +291,11 @@ func NewCSIProxyMounter() (*csiProxyMounter, error) {
 	}, nil
 }
 
-func NewSafeMounter(enableWindowsHostProcess bool) (*mount.SafeFormatAndMount, error) {
+func NewSafeMounter(enableWindowsHostProcess, useWinCIMAPI bool) (*mount.SafeFormatAndMount, error) {
 	if enableWindowsHostProcess {
 		klog.V(2).Infof("using windows host process mounter")
 		return &mount.SafeFormatAndMount{
-			Interface: NewWinMounter(),
+			Interface: NewWinMounter(useWinCIMAPI),
 			Exec:      utilexec.New(),
 		}, nil
 	}

pkg/os/cim/smb.go

@@ -0,0 +1,69 @@
+//go:build windows
+// +build windows
+
+/*
+Copyright 2025 The Kubernetes 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 cim
+
+import (
+	"github.com/microsoft/wmi/pkg/base/query"
+	cim "github.com/microsoft/wmi/pkg/wmiinstance"
+)
+
+// Refer to https://learn.microsoft.com/en-us/previous-versions/windows/desktop/smb/msft-smbmapping
+const (
+	SmbMappingStatusOK int32 = iota
+	SmbMappingStatusPaused
+	SmbMappingStatusDisconnected
+	SmbMappingStatusNetworkError
+	SmbMappingStatusConnecting
+	SmbMappingStatusReconnecting
+	SmbMappingStatusUnavailable
+)
+
+// QuerySmbGlobalMappingByRemotePath retrieves the SMB global mapping from its remote path.
+//
+// The equivalent WMI query is:
+//
+//	SELECT [selectors] FROM MSFT_SmbGlobalMapping
+//
+// Refer to https://pkg.go.dev/github.com/microsoft/wmi/server2019/root/microsoft/windows/smb#MSFT_SmbGlobalMapping
+// for the WMI class definition.
+func QuerySmbGlobalMappingByRemotePath(remotePath string) (*cim.WmiInstance, error) {
+	smbQuery := query.NewWmiQuery("MSFT_SmbGlobalMapping", "RemotePath", remotePath)
+	instances, err := QueryInstances(WMINamespaceSmb, smbQuery)
+	if err != nil {
+		return nil, err
+	}
+
+	return instances[0], err
+}
+
+// RemoveSmbGlobalMappingByRemotePath removes a SMB global mapping matching to the remote path.
+//
+// Refer to https://pkg.go.dev/github.com/microsoft/wmi/server2019/root/microsoft/windows/smb#MSFT_SmbGlobalMapping
+// for the WMI class definition.
+func RemoveSmbGlobalMappingByRemotePath(remotePath string) error {
+	smbQuery := query.NewWmiQuery("MSFT_SmbGlobalMapping", "RemotePath", remotePath)
+	instances, err := QueryInstances(WMINamespaceSmb, smbQuery)
+	if err != nil {
+		return err
+	}
+
+	_, err = instances[0].InvokeMethod("Remove", true)
+	return err
+}

pkg/os/cim/wmi.go

@@ -21,19 +21,19 @@ package cim
 
 import (
 	"fmt"
-	"log"
-	"strings"
 
 	"github.com/go-ole/go-ole"
 	"github.com/go-ole/go-ole/oleutil"
 	"github.com/microsoft/wmi/pkg/base/query"
 	"github.com/microsoft/wmi/pkg/errors"
 	cim "github.com/microsoft/wmi/pkg/wmiinstance"
+	"k8s.io/klog/v2"
 )
 
 const (
 	WMINamespaceRoot    = "Root\\CimV2"
 	WMINamespaceStorage = "Root\\Microsoft\\Windows\\Storage"
+	WMINamespaceSmb     = "Root\\Microsoft\\Windows\\Smb"
 )
 
 type InstanceHandler func(instance *cim.WmiInstance) (bool, error)
@@ -108,8 +108,9 @@ func QueryInstances(namespace string, query *query.WmiQuery) ([]*cim.WmiInstance
 }
 
 // TODO: fix the panic in microsoft/wmi library and remove this workaround
+// Refer to https://github.com/microsoft/wmi/issues/167
 func executeClassMethodParam(classInst *cim.WmiInstance, method *cim.WmiMethod, inParam, outParam cim.WmiMethodParamCollection) (result *cim.WmiMethodResult, err error) {
-	log.Printf("[WMI] - Executing Method [%s]\n", method.Name)
+	klog.V(6).Infof("[WMI] - Executing Method [%s]\n", method.Name)
 
 	iDispatchInstance := classInst.GetIDispatch()
 	if iDispatchInstance == nil {
@@ -162,7 +163,6 @@ func executeClassMethodParam(classInst *cim.WmiInstance, method *cim.WmiMethod,
 		defer inparams.Clear()
 
 		for _, inp := range inParam {
-			// 	log.Printf("InParam [%s]=>[%+v]\n", inp.Name, inp.Value)
 			addInParam(inparams, inp.Name, inp.Value)
 		}
 
@@ -184,7 +184,7 @@ func executeClassMethodParam(classInst *cim.WmiInstance, method *cim.WmiMethod,
 	defer returnRaw.Clear()
 	if returnRaw.Value() != nil {
 		result.ReturnValue = returnRaw.Value().(int32)
-		log.Printf("[WMI] - Return [%d] ", result.ReturnValue)
+		klog.V(6).Infof("[WMI] - Return [%d] ", result.ReturnValue)
 	}
 
 	for _, outp := range outParam {
@@ -200,7 +200,6 @@ func executeClassMethodParam(classInst *cim.WmiInstance, method *cim.WmiMethod,
 			err = err1
 			return
 		}
-		// log.Printf("OutParam [%s]=> [%+v]\n", outp.Name, value)
 
 		result.OutMethodParams[outp.Name] = cim.NewWmiMethodParam(outp.Name, value)
 	}
@@ -263,122 +262,3 @@ func IgnoreNotFound(err error) error {
 	}
 	return err
 }
-
-// parseObjectRef extracts the object ID from a WMI object reference string.
-// The result string is in this format
-// {1}\\WIN-8E2EVAQ9QSB\ROOT/Microsoft/Windows/Storage/Providers_v2\WSP_Partition.ObjectId="{b65bb3cd-da86-11ee-854b-806e6f6e6963}:PR:{00000000-0000-0000-0000-100000000000}\\?\scsi#disk&ven_vmware&prod_virtual_disk#4&2c28f6c4&0&000000#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}"
-// from an escape string
-func parseObjectRef(input, objectClass, refName string) (string, error) {
-	tokens := strings.Split(input, fmt.Sprintf("%s.%s=", objectClass, refName))
-	if len(tokens) < 2 {
-		return "", fmt.Errorf("invalid object ID value: %s", input)
-	}
-
-	objectID := tokens[1]
-	objectID = strings.ReplaceAll(objectID, "\\\"", "\"")
-	objectID = strings.ReplaceAll(objectID, "\\\\", "\\")
-	objectID = objectID[1 : len(objectID)-1]
-	return objectID, nil
-}
-
-// ListWMIInstanceMappings queries WMI instances and creates a map using custom indexing functions
-// to extract keys and values from each instance.
-func ListWMIInstanceMappings(namespace, mappingClassName string, selectorList []string, keyIndexer InstanceIndexer, valueIndexer InstanceIndexer) (map[string]string, error) {
-	q := query.NewWmiQueryWithSelectList(mappingClassName, selectorList)
-	mappingInstances, err := QueryInstances(namespace, q)
-	if err != nil {
-		return nil, err
-	}
-
-	result := make(map[string]string)
-	for _, mapping := range mappingInstances {
-		key, err := keyIndexer(mapping)
-		if err != nil {
-			return nil, err
-		}
-
-		value, err := valueIndexer(mapping)
-		if err != nil {
-			return nil, err
-		}
-
-		result[key] = value
-	}
-
-	return result, nil
-}
-
-// FindInstancesByMapping filters instances based on a mapping relationship,
-// matching instances through custom indexing and mapping functions.
-func FindInstancesByMapping(instanceToFind []*cim.WmiInstance, instanceToFindIndex InstanceIndexer, associatedInstances []*cim.WmiInstance, associatedInstanceIndexer InstanceIndexer, instanceMappings map[string]string) ([]*cim.WmiInstance, error) {
-	associatedInstanceObjectIDMapping := map[string]*cim.WmiInstance{}
-	for _, inst := range associatedInstances {
-		key, err := associatedInstanceIndexer(inst)
-		if err != nil {
-			return nil, err
-		}
-
-		associatedInstanceObjectIDMapping[key] = inst
-	}
-
-	var filtered []*cim.WmiInstance
-	for _, inst := range instanceToFind {
-		key, err := instanceToFindIndex(inst)
-		if err != nil {
-			return nil, err
-		}
-
-		valueObjectID, ok := instanceMappings[key]
-		if !ok {
-			continue
-		}
-
-		_, ok = associatedInstanceObjectIDMapping[strings.ToUpper(valueObjectID)]
-		if !ok {
-			continue
-		}
-		filtered = append(filtered, inst)
-	}
-
-	if len(filtered) == 0 {
-		return nil, errors.NotFound
-	}
-
-	return filtered, nil
-}
-
-// mappingObjectRefIndexer indexes an WMI object by the Object ID reference from a specified property.
-func mappingObjectRefIndexer(propertyName, className, refName string) InstanceIndexer {
-	return func(instance *cim.WmiInstance) (string, error) {
-		valueVal, err := instance.GetProperty(propertyName)
-		if err != nil {
-			return "", err
-		}
-
-		refValue, err := parseObjectRef(valueVal.(string), className, refName)
-		return strings.ToUpper(refValue), err
-	}
-}
-
-// stringPropertyIndexer indexes a WMI object from a string property.
-func stringPropertyIndexer(propertyName string) InstanceIndexer {
-	return func(instance *cim.WmiInstance) (string, error) {
-		valueVal, err := instance.GetProperty(propertyName)
-		if err != nil {
-			return "", err
-		}
-
-		return strings.ToUpper(valueVal.(string)), err
-	}
-}
-
-var (
-	// objectIDPropertyIndexer indexes a WMI object from its ObjectId property.
-	objectIDPropertyIndexer = stringPropertyIndexer("ObjectId")
-)
-
-// FindInstancesByObjectIDMapping filters instances based on ObjectId mapping
-// between two sets of WMI instances.
-func FindInstancesByObjectIDMapping(instanceToFind []*cim.WmiInstance, associatedInstances []*cim.WmiInstance, instanceMappings map[string]string) ([]*cim.WmiInstance, error) {
-	return FindInstancesByMapping(instanceToFind, objectIDPropertyIndexer, associatedInstances, objectIDPropertyIndexer, instanceMappings)
-}