Re: [PATCH i-g-t 06/10] tools/vmtb: Refactor driver interfaces

["Bernatowicz, Marcin" <marcin.bernatowicz@linux.intel.com>]

On 2/24/2026 8:50 AM, Adam Miszczak wrote:
> Introduce new common driver interface - base class for all DRM drivers.
> DriverInterface exposes basic functions like bind, unbind or reset
> and is extended by specialized classes representing PF and VF drivers.
> Both PF and VF driver classes implement methods to read/write sysfs/debugfs:
> a host uses standard Python's pathlib for filesystem operations,
> guest access it over QEMU Guest-Agent commands.
> Additionally, PfDriverInterface publishes functions to enable
> and provision VFs, configure scheduling etc.
> Concrete implementation of PF driver is provided by Xe driver class.
>
> Additional adjustments for xe provisioning:
> - scheduling configured via sysfs SRIOV admin tree:
>    /sys/bus/pci/drivers/xe/[BDF]/sriov_admin
> - support bulk settings (PF and all VFs) for EQ, PT and scheduling priority
> - align with a new 'sched_priority' file format:
>    low/normal/high strings instead of integers
> - remove 'sched_if_idle' attribute support - enable strict scheduling
>    via 'normal' scheduling priority
> - support new debugfs 'restore_auto_provisioning' attribute
>    to reenable auto-provisioning mode.
> - set LMEM and GGTT quotas exclusively on a root tile
> - in auto resources provisioning mode, setting scheduling parameters
>    should follow VFs enabling
>    (otherwise xe KMD sets custom provisioning mode for resources as well)
> - Device.reset_provisioning() clears (zeroes) provisioning attributes
>    and restores auto-provisioning
>
> Signed-off-by: Adam Miszczak <adam.miszczak@linux.intel.com>
> ---
>   tools/vmtb/bench/drivers/driver_interface.py | 179 +++++++++++++---
>   tools/vmtb/bench/drivers/xe.py               | 207 ++++++++-----------
>   tools/vmtb/bench/machines/physical/device.py |  96 +++++----
>   tools/vmtb/vmm_flows/conftest.py             |  14 +-
>   4 files changed, 301 insertions(+), 195 deletions(-)
>
> diff --git a/tools/vmtb/bench/drivers/driver_interface.py b/tools/vmtb/bench/drivers/driver_interface.py
> index 3026fece7..0b0bd5abb 100644
> --- a/tools/vmtb/bench/drivers/driver_interface.py
> +++ b/tools/vmtb/bench/drivers/driver_interface.py
> @@ -3,13 +3,21 @@
>   
>   import abc
>   import enum
> +import logging
>   import typing
> +from pathlib import Path
>   
> +from bench import exceptions
> +from bench.machines.machine_interface import MachineInterface
> +from bench.helpers.log import LogDecorators
>   
> -class SchedulingPriority(enum.Enum):
> -    LOW = 0
> -    NORMAL = 1
> -    HIGH = 2
> +logger = logging.getLogger('DriverInterface')
> +
> +
> +class SchedulingPriority(str, enum.Enum):
> +    LOW = 'low'
> +    NORMAL = 'normal'
> +    HIGH = 'high'
>   
>   
>   class VfControl(str, enum.Enum):
> @@ -23,20 +31,85 @@ class VfControl(str, enum.Enum):
>   
>   
>   class DriverInterface(abc.ABC):
> +    """Base class for DRM drivers (Physical and Virtual).
> +    Provide common operations for all drivers like bind/unbind, reset etc.
> +    """
> +    def __init__(self, bdf: str) -> None:
> +        self.pci_bdf = bdf
> +        self.sysfs_device_path = Path('/sys/bus/pci/devices') / self.pci_bdf
> +        self.sysfs_driver_path = Path('/sys/bus/pci/drivers') / self.get_name()
> +        self.debugfs_path = Path('/sys/kernel/debug/dri') / self.pci_bdf
> +
> +    @abc.abstractmethod
> +    def get_name(self) -> str:
> +        raise NotImplementedError
> +
> +    @abc.abstractmethod
> +    def write_sysfs(self, path: Path, value: str) -> None:
> +        raise NotImplementedError
>   
> -    @staticmethod
>       @abc.abstractmethod
> -    def get_name() -> str:
> +    def read_sysfs(self, path: Path) -> str:
>           raise NotImplementedError
>   
>       @abc.abstractmethod
> -    def bind(self, bdf: str) -> None:
> +    def write_debugfs(self, file: str, value: str) -> None:
>           raise NotImplementedError
>   
>       @abc.abstractmethod
> -    def unbind(self, bdf: str) -> None:
> +    def read_debugfs(self, file: str) -> str:
>           raise NotImplementedError
>   
> +    @LogDecorators.parse_kmsg
> +    def bind(self) -> None:
> +        self.write_sysfs((self.sysfs_driver_path / 'bind'), self.pci_bdf)
> +
> +    @LogDecorators.parse_kmsg
> +    def unbind(self) -> None:
> +        self.write_sysfs((self.sysfs_driver_path / 'unbind'), self.pci_bdf)
> +
> +    @LogDecorators.parse_kmsg
> +    def flr(self) -> None:
> +        self.write_sysfs((self.sysfs_device_path / 'reset'), '1')
> +
> +
> +class PfDriverInterface(DriverInterface, abc.ABC):
> +    """Base class for PF drivers, extends common DriverInterface base class.
> +    Provide operations specific for PF drivers like read/write sysfs on Host,
> +    set number of VFs to enable, set/get provisioning related attributes etc.
> +    """
> +    @LogDecorators.parse_kmsg
> +    def __write_fs(self, path: Path, value: str) -> None:
> +        try:
> +            path.write_text(value)
> +            logger.debug("Write: %s -> %s", value, path)
> +        except Exception as exc:
> +            logger.error("Unable to write %s -> %s", value, path)
> +            raise exceptions.HostError(f'Could not write to {path}. Error: {exc}') from exc
> +
> +    @LogDecorators.parse_kmsg
> +    def __read_fs(self, path: Path) -> str:
> +        try:
> +            ret = path.read_text()
> +        except Exception as exc:
> +            logger.error("Unable to read %s", path)
> +            raise exceptions.HostError(f'Could not read from {path}. Error: {exc}') from exc
> +
> +        logger.debug("Read: %s -> %s", path, ret.strip())
> +        return ret
> +
> +    def write_sysfs(self, path: Path, value: str) -> None:
> +        self.__write_fs(path, value)
> +
> +    def read_sysfs(self, path: Path) -> str:
> +        return str(self.__read_fs(path))
> +
> +    def write_debugfs(self, file: str, value: str) -> None:
> +        self.__write_fs(self.debugfs_path / file, value)
> +
> +    def read_debugfs(self, file: str) -> str:
> +        return str(self.__read_fs(self.debugfs_path / file))
> +
>       @abc.abstractmethod
>       def get_totalvfs(self) -> int:
>           raise NotImplementedError
> @@ -70,17 +143,14 @@ class DriverInterface(abc.ABC):
>           raise NotImplementedError
>   
>       @abc.abstractmethod
> -    def get_auto_provisioning(self) -> bool:
> -        raise NotImplementedError
> -
> -    @abc.abstractmethod
> -    def set_auto_provisioning(self, val: bool) -> None:
> +    def restore_auto_provisioning(self) -> None:
>           raise NotImplementedError
>   
>       @abc.abstractmethod
>       def cancel_work(self) -> None:
>           raise NotImplementedError
>   
> +    # PF provisioning
>       @abc.abstractmethod
>       def get_pf_ggtt_spare(self, gt_num: int) -> int:
>           raise NotImplementedError
> @@ -113,14 +183,6 @@ class DriverInterface(abc.ABC):
>       def set_pf_doorbells_spare(self, gt_num: int, val: int) -> None:
>           raise NotImplementedError
>   
> -    @abc.abstractmethod
> -    def get_pf_sched_priority(self, gt_num: int) -> SchedulingPriority:
> -        raise NotImplementedError
> -
> -    @abc.abstractmethod
> -    def set_pf_sched_priority(self, gt_num: int, val: SchedulingPriority) -> None:
> -        raise NotImplementedError
> -
>       @abc.abstractmethod
>       def get_pf_policy_reset_engine(self, gt_num: int) -> int:
>           raise NotImplementedError
> @@ -137,14 +199,7 @@ class DriverInterface(abc.ABC):
>       def set_pf_policy_sample_period_ms(self, gt_num: int, val: int) -> None:
>           raise NotImplementedError
>   
> -    @abc.abstractmethod
> -    def get_pf_policy_sched_if_idle(self, gt_num: int) -> int:
> -        raise NotImplementedError
> -
> -    @abc.abstractmethod
> -    def set_pf_policy_sched_if_idle(self, gt_num: int, val: int) -> None:
> -        raise NotImplementedError
> -
> +    # VF provisioning
>       @abc.abstractmethod
>       def get_ggtt_quota(self, vf_num: int, gt_num: int) -> int:
>           raise NotImplementedError
> @@ -177,20 +232,53 @@ class DriverInterface(abc.ABC):
>       def set_doorbells_quota(self, vf_num: int, gt_num: int, val: int) -> None:
>           raise NotImplementedError
>   
> +    # Scheduling provisioning
> +    @abc.abstractmethod
> +    def get_exec_quantum_ms(self, fn_num: int) -> int:
> +        "Get execution quantum (ms) for PF/VF (EQ/exec_quantum_ms)."
> +        raise NotImplementedError
> +
> +    @abc.abstractmethod
> +    def set_exec_quantum_ms(self, fn_num: int, val: int) -> None:
> +        "Set execution quantum (ms) for PF/VF (EQ/exec_quantum_ms)."
> +        raise NotImplementedError
> +
> +    @abc.abstractmethod
> +    def set_bulk_exec_quantum_ms(self, val: int) -> None:
> +        "Set execution quantum (ms) for PF and all VFs (EQ/exec_quantum_ms)."
> +        raise NotImplementedError
> +
> +    @abc.abstractmethod
> +    def get_preempt_timeout_us(self, fn_num: int) -> int:
> +        "Get preemption timeout (us) for PF/VF (PT/preempt_timeout_us)."
> +        raise NotImplementedError
> +
> +    @abc.abstractmethod
> +    def set_preempt_timeout_us(self, fn_num: int, val: int) -> None:
> +        "Set preemption timeout (us) for PF/VF (PT/preempt_timeout_us)."
> +        raise NotImplementedError
> +
>       @abc.abstractmethod
> -    def get_exec_quantum_ms(self, vf_num: int, gt_num: int) -> int:
> +    def set_bulk_preempt_timeout_us(self, val: int) -> None:
> +        "Set preemption timeout (us) for PF and all VFs (PT/preempt_timeout_us)."
>           raise NotImplementedError
>   
>       @abc.abstractmethod
> -    def set_exec_quantum_ms(self, vf_num: int, gt_num: int, val: int) -> None:
> +    def get_sched_priority(self, fn_num: int) -> SchedulingPriority:
> +        "Get scheduling priority (sched_priority) of PF/VF: low, normal or high."
>           raise NotImplementedError
>   
>       @abc.abstractmethod
> -    def get_preempt_timeout_us(self, vf_num: int, gt_num: int) -> int:
> +    def set_pf_sched_priority(self, val: SchedulingPriority) -> None:
> +        "Set scheduling priority (sched_priority) for PF only."
> +        # Independent sched_prio setting is available only for PF
>           raise NotImplementedError
>   
>       @abc.abstractmethod
> -    def set_preempt_timeout_us(self, vf_num: int, gt_num: int, val: int) -> None:
> +    def set_bulk_sched_priority(self, val: SchedulingPriority) -> None:
> +        "Set scheduling priority (sched_priority) for PF and all VFs."
> +        # Set sched_prio for PF and all VFs.
> +        # Setting sched_priority for a single VF independently is not supported currently.
>           raise NotImplementedError
>   
>       @abc.abstractmethod
> @@ -200,3 +288,28 @@ class DriverInterface(abc.ABC):
>       @abc.abstractmethod
>       def get_ggtt_available(self, gt_num: int) -> typing.Tuple[int, int]:
>           raise NotImplementedError
> +
> +
> +class VfDriver(DriverInterface):
> +    """Base class for VF drivers, extends common DriverInterface base class.
> +    Provide operations specific for VF drivers like read/write sysfs on Guest/VM.
> +    """
> +    def __init__(self, bdf: str, vm: MachineInterface) -> None:
> +        # VirtualMachine instance is required for VM filesystem access via QEMU Guest-Agent
> +        self.vm: MachineInterface = vm
> +        super().__init__(bdf)
> +
> +    def get_name(self) -> str:
> +        return self.vm.get_drm_driver_name()
> +
> +    def write_sysfs(self, path: Path, value: str) -> None:
> +        self.vm.write_file_content(str(path), value)
> +
> +    def read_sysfs(self, path: Path) -> str:
> +        return self.vm.read_file_content(str(path))
> +
> +    def write_debugfs(self, file: str, value: str) -> None:
> +        self.vm.write_file_content(str(self.debugfs_path / file), value)
> +
> +    def read_debugfs(self, file: str) -> str:
> +        return self.vm.read_file_content(str(self.debugfs_path / file))
> diff --git a/tools/vmtb/bench/drivers/xe.py b/tools/vmtb/bench/drivers/xe.py
> index c2b9643bb..26e4e0a08 100644
> --- a/tools/vmtb/bench/drivers/xe.py
> +++ b/tools/vmtb/bench/drivers/xe.py
> @@ -2,85 +2,42 @@
>   # Copyright © 2024-2026 Intel Corporation
>   
>   import logging
> +import re
>   import typing
>   from pathlib import Path
>   
> -from bench import exceptions
> -from bench.drivers.driver_interface import (DriverInterface,
> +from bench.drivers.driver_interface import (PfDriverInterface,
>                                               SchedulingPriority, VfControl)
> -from bench.helpers.log import LogDecorators
>   
>   logger = logging.getLogger('XeDriver')
>   
>   
> -class XeDriver(DriverInterface):
> -    def __init__(self, card_index: int) -> None:
> -        self.sysfs_card_path = Path(f'/sys/class/drm/card{card_index}')
> -        self.debugfs_path = Path(f'/sys/kernel/debug/dri/{card_index}')
> -
> -    @staticmethod
> -    def get_name() -> str:
> +class XeDriver(PfDriverInterface):
> +    """Xe driver abstraction class, implements PfDriverInterface.
> +    Provide xe specific sysfs/debugfs access and other operations on Host.
> +    """
> +    def get_name(self) -> str:
>           return 'xe'
>   
> -    @LogDecorators.parse_kmsg
> -    def __write_fs(self, base_path: Path, name: str, value: str) -> None:
> -        path = base_path / name
> -        try:
> -            path.write_text(value)
> -            logger.debug("Write: %s -> %s", value, path)
> -        except Exception as exc:
> -            logger.error("Unable to write %s -> %s", value, path)
> -            raise exceptions.HostError(f'Could not write to {path}. Error: {exc}') from exc
> -
> -    @LogDecorators.parse_kmsg
> -    def __read_fs(self,  base_path: Path, name: str) -> str:
> -        path = base_path / name
> -        try:
> -            ret = path.read_text()
> -        except Exception as exc:
> -            logger.error("Unable to read %s", path)
> -            raise exceptions.HostError(f'Could not read from {path}. Error: {exc}') from exc
> -
> -        logger.debug("Read: %s -> %s", path, ret.strip())
> -        return ret
> -
> -    def __write_sysfs(self, name: str, value: str) -> None:
> -        self.__write_fs(self.sysfs_card_path / 'device', name, value)
> -
> -    def __read_sysfs(self, name: str) -> str:
> -        return str(self.__read_fs(self.sysfs_card_path / 'device', name))
> -
> -    def __write_debugfs(self, name: str, value: str) -> None:
> -        self.__write_fs(self.debugfs_path, name, value)
> -
> -    def __read_debugfs(self, name: str) -> str:
> -        return str(self.__read_fs(self.debugfs_path, name))
> -
> -    def bind(self, bdf: str) -> None:
> -        self.__write_sysfs('driver/bind', bdf)
> -
> -    def unbind(self, bdf: str) -> None:
> -        self.__write_sysfs('driver/unbind', bdf)
> -
>       def get_totalvfs(self) -> int:
> -        return int(self.__read_sysfs('sriov_totalvfs'))
> +        return int(self.read_sysfs(self.sysfs_device_path / 'sriov_totalvfs'))
>   
>       def get_numvfs(self) -> int:
> -        return int(self.__read_sysfs('sriov_numvfs'))
> +        return int(self.read_sysfs(self.sysfs_device_path / 'sriov_numvfs'))
>   
>       def set_numvfs(self, val: int) -> None:
> -        self.__write_sysfs('sriov_numvfs', str(val))
> +        self.write_sysfs(self.sysfs_device_path / 'sriov_numvfs', str(val))
>   
>       def get_drivers_autoprobe(self) -> int:
> -        return int(self.__read_sysfs('sriov_drivers_autoprobe'))
> +        return int(self.read_sysfs(self.sysfs_device_path / 'sriov_drivers_autoprobe'))
>   
>       def set_drivers_autoprobe(self, val: int) -> None:
> -        self.__write_sysfs('sriov_drivers_autoprobe', str(val))
> +        self.write_sysfs(self.sysfs_device_path / 'sriov_drivers_autoprobe', str(val))
>   
>       def get_num_gts(self) -> int:
>           gt_num = 0
>           # Fixme: tile0 only at the moment, add support for multiple tiles if needed
> -        path = self.sysfs_card_path / 'device' / 'tile0' / 'gt'
> +        path = self.sysfs_device_path / 'tile0' / 'gt'
>   
>           if path.exists():
>               gt_num = 1
> @@ -101,12 +58,9 @@ class XeDriver(DriverInterface):
>           path = self.debugfs_path / f'gt{gt_num}' / 'pf' / 'ggtt_spare'
>           return not path.exists()
>   
> -    def get_auto_provisioning(self) -> bool:
> -        raise exceptions.NotAvailableError('auto_provisioning attribute not available')
> -
> -    def set_auto_provisioning(self, val: bool) -> None:
> -        # No-op - xe driver doesn't publish this attribute
> -        pass
> +    def restore_auto_provisioning(self) -> None:
> +        path = self.debugfs_path / 'sriov' / 'restore_auto_provisioning'
> +        self.write_debugfs(str(path), str(1))
>   
>       def cancel_work(self) -> None:
>           # Function to cancel all remaing work on GPU (for test cleanup).
> @@ -114,84 +68,77 @@ class XeDriver(DriverInterface):
>           pass
>   
>       # Create debugfs path to given parameter (without a base part):
> -    # gt@gt_num/[pf|vf@vf_num]/@attr
> -    # @vf_num: VF number (1-based) or 0 for PF
> +    # gt@gt_num/[pf|vf@fn_num]/@attr
> +    # @fn_num: VF number (1-based) or 0 for PF
>       # @gt_num: GT instance number
>       # @subdir: subdirectory for attribute or empty string if not exists
>       # @attr: iov parameter name
>       # Returns: iov debugfs path to @attr
> -    def __helper_create_debugfs_path(self, vf_num: int, gt_num: int, subdir: str, attr: str) -> str:
> -        vf_gt_part = f'gt{gt_num}/pf' if vf_num == 0 else f'gt{gt_num}/vf{vf_num}'
> -        return f'{vf_gt_part}/{subdir}/{attr}'
> +    def __helper_create_debugfs_path(self, fn_num: int, gt_num: int, subdir: str, attr: str) -> str:
> +        gt_fn_part = f'gt{gt_num}/pf' if fn_num == 0 else f'gt{gt_num}/vf{fn_num}'
> +        return f'{gt_fn_part}/{subdir}/{attr}'
> +
> +    # Create sysfs sriov_admin path to given scheduling parameter (without a base part):
> +    # sriov_admin/[pf|vf@fn_num]/profile/@attr
> +    # @fn_num: VF number (1-based) or 0 for PF
> +    # @attr: iov parameter name
> +    # Returns: iov sysfs path to @attr
> +    def __helper_create_sriov_admin_path(self, fn_num: int, attr: str) -> str:
> +        fn_part = 'pf' if fn_num == 0 else f'vf{fn_num}'
> +        return f'sriov_admin/{fn_part}/profile/{attr}'
>   
>       # PF spare resources
>       # Debugfs location: [SRIOV debugfs base path]/gtM/pf/xxx_spare
>       def get_pf_ggtt_spare(self, gt_num: int) -> int:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'ggtt_spare')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_pf_ggtt_spare(self, gt_num: int, val: int) -> None:
>           path = self.__helper_create_debugfs_path(0, gt_num, '',  'ggtt_spare')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
>   
>       def get_pf_lmem_spare(self, gt_num: int) -> int:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'lmem_spare')
> -        return int(self.__read_debugfs(path)) if self.has_lmem() else 0
> +        return int(self.read_debugfs(path)) if self.has_lmem() else 0
>   
>       def set_pf_lmem_spare(self, gt_num: int, val: int) -> None:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'lmem_spare')
>           if self.has_lmem():
> -            self.__write_debugfs(path, str(val))
> +            self.write_debugfs(path, str(val))
>   
>       def get_pf_contexts_spare(self, gt_num: int) -> int:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'contexts_spare')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_pf_contexts_spare(self, gt_num: int, val: int) -> None:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'contexts_spare')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
>   
>       def get_pf_doorbells_spare(self, gt_num: int) -> int:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'doorbells_spare')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_pf_doorbells_spare(self, gt_num: int, val: int) -> None:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'doorbells_spare')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
>   
>       # PF specific provisioning parameters
>       # Debugfs location: [SRIOV debugfs base path]/gtM/pf
> -    def get_pf_sched_priority(self, gt_num: int) -> SchedulingPriority:
> -        logger.warning("PF sched_priority param not available")
> -        return SchedulingPriority.LOW
> -
> -    def set_pf_sched_priority(self, gt_num: int, val: SchedulingPriority) -> None:
> -        logger.warning("PF sched_priority param not available")
> -
>       def get_pf_policy_reset_engine(self, gt_num: int) -> int:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'reset_engine')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_pf_policy_reset_engine(self, gt_num: int, val: int) -> None:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'reset_engine')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
>   
>       def get_pf_policy_sample_period_ms(self, gt_num: int) -> int:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'sample_period_ms')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_pf_policy_sample_period_ms(self, gt_num: int, val: int) -> None:
>           path = self.__helper_create_debugfs_path(0, gt_num, '', 'sample_period_ms')
> -        self.__write_debugfs(path, str(val))
> -
> -    def get_pf_policy_sched_if_idle(self, gt_num: int) -> int:
> -        path = self.__helper_create_debugfs_path(0, gt_num, '', 'sched_if_idle')
> -        return int(self.__read_debugfs(path))
> -
> -    def set_pf_policy_sched_if_idle(self, gt_num: int, val: int) -> None:
> -        # In order to set strict scheduling policy, PF scheduling priority needs to be default
> -        path = self.__helper_create_debugfs_path(0, gt_num, '', 'sched_if_idle')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
>   
>       # VF and PF provisioning parameters
>       # Debugfs location: [SRIOV debugfs base path]/gtM/[pf|vfN]
> @@ -202,7 +149,7 @@ class XeDriver(DriverInterface):
>               return 0
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'ggtt_quota')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_ggtt_quota(self, vf_num: int, gt_num: int, val: int) -> None:
>           if vf_num == 0:
> @@ -210,7 +157,7 @@ class XeDriver(DriverInterface):
>               return
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'ggtt_quota')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
>   
>       def get_lmem_quota(self, vf_num: int, gt_num: int) -> int:
>           if vf_num == 0:
> @@ -218,7 +165,7 @@ class XeDriver(DriverInterface):
>               return 0
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'lmem_quota')
> -        return int(self.__read_debugfs(path)) if self.has_lmem() else 0
> +        return int(self.read_debugfs(path)) if self.has_lmem() else 0
>   
>       def set_lmem_quota(self, vf_num: int, gt_num: int, val: int) -> None:
>           if vf_num == 0:
> @@ -227,7 +174,7 @@ class XeDriver(DriverInterface):
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'lmem_quota')
>           if self.has_lmem():
> -            self.__write_debugfs(path, str(val))
> +            self.write_debugfs(path, str(val))
>   
>       def get_contexts_quota(self, vf_num: int, gt_num: int) -> int:
>           if vf_num == 0:
> @@ -235,7 +182,7 @@ class XeDriver(DriverInterface):
>               return 0
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'contexts_quota')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_contexts_quota(self, vf_num: int, gt_num: int, val: int) -> None:
>           if vf_num == 0:
> @@ -243,7 +190,7 @@ class XeDriver(DriverInterface):
>               return
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'contexts_quota')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
>   
>       def get_doorbells_quota(self, vf_num: int, gt_num: int) -> int:
>           if vf_num == 0:
> @@ -251,7 +198,7 @@ class XeDriver(DriverInterface):
>               return 0
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'doorbells_quota')
> -        return int(self.__read_debugfs(path))
> +        return int(self.read_debugfs(path))
>   
>       def set_doorbells_quota(self, vf_num: int, gt_num: int, val: int) -> None:
>           if vf_num == 0:
> @@ -259,23 +206,51 @@ class XeDriver(DriverInterface):
>               return
>   
>           path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'doorbells_quota')
> -        self.__write_debugfs(path, str(val))
> +        self.write_debugfs(path, str(val))
> +
> +    # VF and PF scheduling parameters
> +    # Sysfs location: [SRIOV sysfs base path]/sriov_admin/[pf|vfN]/profile
> +    # @fn_num: VF number (1-based) or 0 for PF
> +    def get_exec_quantum_ms(self, fn_num: int) -> int:
> +        sriov_admin_path = self.__helper_create_sriov_admin_path(fn_num, 'exec_quantum_ms')
> +        return int(self.read_sysfs(self.sysfs_device_path / sriov_admin_path))
> +
> +    def set_exec_quantum_ms(self, fn_num: int, val: int) -> None:
> +        sriov_admin_path = self.__helper_create_sriov_admin_path(fn_num, 'exec_quantum_ms')
> +        self.write_sysfs(self.sysfs_device_path / sriov_admin_path, str(val))
> +
> +    def set_bulk_exec_quantum_ms(self, val: int) -> None:
> +        self.write_sysfs(self.sysfs_device_path / 'sriov_admin/.bulk_profile/exec_quantum_ms', str(val))
> +
> +    def get_preempt_timeout_us(self, fn_num: int) -> int:
> +        sriov_admin_path = self.__helper_create_sriov_admin_path(fn_num, 'preempt_timeout_us')
> +        return int(self.read_sysfs(self.sysfs_device_path / sriov_admin_path))
> +
> +    def set_preempt_timeout_us(self, fn_num: int, val: int) -> None:
> +        sriov_admin_path = self.__helper_create_sriov_admin_path(fn_num, 'preempt_timeout_us')
> +        self.write_sysfs(self.sysfs_device_path / sriov_admin_path, str(val))
> +
> +    def set_bulk_preempt_timeout_us(self, val: int) -> None:
> +        self.write_sysfs(self.sysfs_device_path / 'sriov_admin/.bulk_profile/preempt_timeout_us', str(val))
> +
> +    def get_sched_priority(self, fn_num: int) -> SchedulingPriority:
> +        sriov_admin_path = self.__helper_create_sriov_admin_path(fn_num, 'sched_priority')
> +        ret = self.read_sysfs(self.sysfs_device_path / sriov_admin_path).rstrip()
>   
> -    def get_exec_quantum_ms(self, vf_num: int, gt_num: int) -> int:
> -        path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'exec_quantum_ms')
> -        return int(self.__read_debugfs(path))
> +        match = re.search(r'\[(low|normal|high)\]', ret)
> +        if match:
> +            return SchedulingPriority(match.group(1))
>   
> -    def set_exec_quantum_ms(self, vf_num: int, gt_num: int, val: int) -> None:
> -        path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'exec_quantum_ms')
> -        self.__write_debugfs(path, str(val))
> +        logger.error("Unexpected sched_priority value (must be low/normal/high)")
> +        raise ValueError('Unexpected sched_priority value (must be low/normal/high)')
>   
> -    def get_preempt_timeout_us(self, vf_num: int, gt_num: int) -> int:
> -        path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'preempt_timeout_us')
> -        return int(self.__read_debugfs(path))
> +    def set_pf_sched_priority(self, val: SchedulingPriority) -> None:
> +        # Independent sched_prio setting is available for PF only
> +        sriov_admin_path = self.__helper_create_sriov_admin_path(0, 'sched_priority')
> +        self.write_sysfs(self.sysfs_device_path / sriov_admin_path, val)
>   
> -    def set_preempt_timeout_us(self, vf_num: int, gt_num: int, val: int) -> None:
> -        path = self.__helper_create_debugfs_path(vf_num, gt_num, '', 'preempt_timeout_us')
> -        self.__write_debugfs(path, str(val))
> +    def set_bulk_sched_priority(self, val: SchedulingPriority) -> None:
> +        self.write_sysfs(self.sysfs_device_path / 'sriov_admin/.bulk_profile/sched_priority', val)
>   
>       # Control state of the running VF (WO)
>       # Debugfs location: [SRIOV debugfs base path]/gtM/vfN/control
> @@ -285,7 +260,7 @@ class XeDriver(DriverInterface):
>       # For debug purposes only.
>       def set_vf_control(self, vf_num: int, val: VfControl) -> None:
>           path = self.__helper_create_debugfs_path(vf_num, 0, '', 'control')
> -        self.__write_debugfs(path, val)
> +        self.write_debugfs(path, val)
>   
>       # Read [attribute]_available value from debugfs:
>       # /sys/kernel/debug/dri/[card_index]/gt@gt_num/pf/@attr_available
> diff --git a/tools/vmtb/bench/machines/physical/device.py b/tools/vmtb/bench/machines/physical/device.py
> index 250466733..f1f24c65c 100644
> --- a/tools/vmtb/bench/machines/physical/device.py
> +++ b/tools/vmtb/bench/machines/physical/device.py
> @@ -11,7 +11,7 @@ from bench import exceptions
>   from bench.configurators import pci
>   from bench.configurators.vgpu_profile import (VgpuProfile, VgpuResourcesConfig,
>                                                 VgpuSchedulerConfig)
> -from bench.drivers.driver_interface import DriverInterface, SchedulingPriority
> +from bench.drivers.driver_interface import PfDriverInterface, SchedulingPriority
>   from bench.helpers.log import LogDecorators
>   from bench.machines.device_interface import DeviceInterface
>   
> @@ -46,12 +46,12 @@ class Device(DeviceInterface):
>       def __init__(self, bdf: str, driver: str) -> None:
>           self.pci_info = self.PciInfo(bdf)
>           self.gpu_model = pci.get_gpu_model(self.pci_info.devid)
> -        self.driver: DriverInterface = self.instantiate_driver(driver, self.pci_info.minor_number)
> +        self.driver: PfDriverInterface = self.instantiate_driver(self.pci_info.bdf, driver)
>   
>       def __str__(self) -> str:
>           return f'Dev-{self.pci_info.bdf}'
>   
> -    def instantiate_driver(self, driver_name: str, card_index: int) -> Any:
> +    def instantiate_driver(self, bdf: str, driver_name: str) -> Any:
>           module_name = f'bench.drivers.{driver_name}'
>           class_name = f'{driver_name.capitalize()}Driver'
>   
> @@ -62,7 +62,7 @@ class Device(DeviceInterface):
>               logging.error("Driver module/class is not available: %s", exc)
>               raise exceptions.VmtbConfigError(f'Requested driver module {driver_name} is not available!')
>   
> -        return driver_class(card_index)
> +        return driver_class(bdf)
>   
>       def set_drivers_autoprobe(self, val: bool) -> None:
>           self.driver.set_drivers_autoprobe(int(val))
> @@ -164,26 +164,27 @@ class Device(DeviceInterface):
>           If 'set_resources' parameter is True - apply the full vGPU profile (hard resources and scheduling).
>           Otherwise, set only scheduling profile (e.g. in case of auto resources provisioning).
>           """
> -        main_gt_nums = [gt_num for gt_num in range(self.get_num_gts()) if not self.is_gt_media_type(gt_num)]
> -
> +        all_gt_nums = list(range(self.get_num_gts()))
> +        main_gt_nums = [gt_num for gt_num in all_gt_nums if not self.is_gt_media_type(gt_num)]
>           logger.info("[%s] Provision %sxVFs on main GT%s", self.pci_info.bdf, num_vfs, main_gt_nums)
>   
> -        for gt_num in main_gt_nums:
> +        for gt_num in all_gt_nums:
>               if set_resources:
>                   self.set_resources(0, gt_num, profile.resources)
> -            self.set_scheduling(0, gt_num, profile.scheduler)
>               self.driver.set_pf_policy_reset_engine(gt_num, int(profile.security.reset_after_vf_switch))
>   
> +        self.set_scheduling(0, profile.scheduler)
> +
>           for vf_num in range(1, num_vfs + 1):
> -            gt_nums = main_gt_nums
>               if len(main_gt_nums) > 1 and num_vfs > 1:
>                   # Multi-tile device Mode 2|3 - odd VFs on GT0, even on GT1
> -                gt_nums = [main_gt_nums[0] if vf_num % 2 else main_gt_nums[1]]
> +                all_gt_nums = [main_gt_nums[0] if vf_num % 2 else main_gt_nums[1]]
>   
> -            for gt_num in gt_nums:
> +            for gt_num in all_gt_nums:
>                   if set_resources:
>                       self.set_resources(vf_num, gt_num, profile.resources)
> -                self.set_scheduling(vf_num, gt_num, profile.scheduler)
> +
> +            self.set_scheduling(vf_num, profile.scheduler)
>   
>       def provision(self, profile: VgpuProfile) -> None:
>           """Provision PF and VF(s) based on requested vGPU profile."""
> @@ -194,44 +195,47 @@ class Device(DeviceInterface):
>           self.__set_provisioning(num_vfs, profile, set_resources=False)
>   
>       # fn_num = 0 for PF, 1..n for VF
> -    def set_scheduling(self, fn_num: int, gt_num: int, scheduling_config: VgpuSchedulerConfig) -> None:
> -        """Write sysfs/debugfs PF/VF scheduling attributes."""
> +    def set_scheduling(self, fn_num: int, scheduling_config: VgpuSchedulerConfig) -> None:
> +        """Write sysfs PF/VF scheduling attributes."""
>           logger.debug("[%s] Set scheduling for PCI Function %s", self.pci_info.bdf, fn_num)
> +
>           if fn_num == 0:
> -            self.driver.set_pf_policy_sched_if_idle(gt_num, int(scheduling_config.scheduleIfIdle))
> -            self.driver.set_exec_quantum_ms(0, gt_num, scheduling_config.pfExecutionQuanta)
> -            self.driver.set_preempt_timeout_us(0, gt_num, scheduling_config.pfPreemptionTimeout)
> +            eq, pt = scheduling_config.pfExecutionQuanta, scheduling_config.pfPreemptionTimeout
>           else:
> -            self.driver.set_exec_quantum_ms(fn_num, gt_num, scheduling_config.vfExecutionQuanta)
> -            self.driver.set_preempt_timeout_us(fn_num, gt_num, scheduling_config.vfPreemptionTimeout)
> +            eq, pt = scheduling_config.vfExecutionQuanta, scheduling_config.vfPreemptionTimeout
> +
> +        self.driver.set_exec_quantum_ms(fn_num, eq)
> +        self.driver.set_preempt_timeout_us(fn_num, pt)
> +
> +        if scheduling_config.scheduleIfIdle:
> +            self.driver.set_bulk_sched_priority(SchedulingPriority.NORMAL)
>   
>       def set_resources(self, fn_num: int, gt_num: int, resources_config: VgpuResourcesConfig) -> None:
> -        """Write sysfs/debugfs PF/VF resources attributes."""
> +        """Write debugfs PF/VF resources attributes."""
>           logger.debug("[%s] Set resources for PCI Function %s", self.pci_info.bdf, fn_num)
>           if fn_num == 0:
> -            self.driver.set_pf_ggtt_spare(gt_num, resources_config.pfGgtt)
> -            self.driver.set_pf_lmem_spare(gt_num, resources_config.pfLmem)
> +            if not self.is_gt_media_type(gt_num):
> +                self.driver.set_pf_ggtt_spare(gt_num, resources_config.pfGgtt)
> +                self.driver.set_pf_lmem_spare(gt_num, resources_config.pfLmem)
>               self.driver.set_pf_contexts_spare(gt_num, resources_config.pfContexts)
>               self.driver.set_pf_doorbells_spare(gt_num, resources_config.pfDoorbells)
>           else:
> -            self.driver.set_ggtt_quota(fn_num, gt_num, resources_config.vfGgtt)
> -            self.driver.set_lmem_quota(fn_num, gt_num, resources_config.vfLmem)
> +            if not self.is_gt_media_type(gt_num):
> +                self.driver.set_ggtt_quota(fn_num, gt_num, resources_config.vfGgtt)
> +                self.driver.set_lmem_quota(fn_num, gt_num, resources_config.vfLmem)
>               self.driver.set_contexts_quota(fn_num, gt_num, resources_config.vfContexts)
>               self.driver.set_doorbells_quota(fn_num, gt_num, resources_config.vfDoorbells)
>   
> -    def reset_provisioning(self, num_vfs: int) -> None:
> -        """Clear provisioning config for a requested number of VFs.
> -        Function calls the sysfs control interface to clear VF provisioning settings
> -        and restores the auto provisioning mode.
> -        """
> -        logger.info("[%s] Reset %s VFs provisioning configuration", self.pci_info.bdf, num_vfs)
> +    def clear_provisioning_attributes(self, num_vfs: int) -> None:
> +        """Clear provisioning attributes for a requested number of VFs."""
> +        # Provisioning config are likely wiped out by (xe) debugfs/restore_auto_provisioning,
> +        # but explicit clear shouldn't harm.
> +        self.driver.set_bulk_sched_priority(SchedulingPriority.LOW)
> +        self.driver.set_bulk_exec_quantum_ms(0)
> +        self.driver.set_bulk_preempt_timeout_us(0)
> +
>           for gt_num in range(self.get_num_gts()):
> -            if self.get_scheduling_priority(gt_num) != SchedulingPriority.LOW:
> -                self.set_scheduling_priority(gt_num, SchedulingPriority.LOW)
> -            self.driver.set_pf_policy_sched_if_idle(gt_num, 0)
>               self.driver.set_pf_policy_reset_engine(gt_num, 0)
> -            self.driver.set_exec_quantum_ms(0, gt_num, 0)
> -            self.driver.set_preempt_timeout_us(0, gt_num, 0)
>               self.driver.set_doorbells_quota(0, gt_num, 0)
>               # PF contexts cannot be set from sysfs
>   
> @@ -242,14 +246,24 @@ class Device(DeviceInterface):
>                       self.driver.set_ggtt_quota(vf_num, gt_num, 0)
>                       self.driver.set_lmem_quota(vf_num, gt_num, 0)
>   
> +    def reset_provisioning(self, num_vfs: int) -> None:
> +        """Clear provisioning config for a given number of VFs and restore auto provisioning mode."""
> +        logger.info("[%s] Reset %sxVF provisioning configuration", self.pci_info.bdf, num_vfs)
> +        self.clear_provisioning_attributes(num_vfs)
> +        self.driver.restore_auto_provisioning()
> +
>       def cancel_work(self) -> None:
>           """Drop and reset remaining GPU execution at exit."""
>           self.driver.cancel_work()
>   
> -    def get_scheduling_priority(self, gt_num: int) -> SchedulingPriority:
> -        return self.driver.get_pf_sched_priority(gt_num)
> +    def get_scheduling_priority(self, fn_num: int) -> SchedulingPriority:
> +        """Get scheduling priority for a given VF or PF."""
> +        return self.driver.get_sched_priority(fn_num)
> +
> +    def set_scheduling_priority(self, val: SchedulingPriority) -> None:
> +        """Set scheduling priority for PF and all VFs. Normal priority enables strict scheduling."""
> +        self.driver.set_bulk_sched_priority(val)
>   
> -    def set_scheduling_priority(self, gt_num: int, val: SchedulingPriority) -> None:
> -        # In order to set scheduling priority, strict scheduling policy needs to be default
> -        # self.drm_driver.set_pf_policy_sched_if_idle(gt_num, 0)
> -        self.driver.set_pf_sched_priority(gt_num, val)
> +    def set_pf_scheduling_priority(self, val: SchedulingPriority) -> None:
> +        """Set scheduling priority for PF only. High prioritizes PF execution over VFs."""
> +        self.driver.set_pf_sched_priority(val)
> diff --git a/tools/vmtb/vmm_flows/conftest.py b/tools/vmtb/vmm_flows/conftest.py
> index 12726416f..a2a6b6680 100644
> --- a/tools/vmtb/vmm_flows/conftest.py
> +++ b/tools/vmtb/vmm_flows/conftest.py
> @@ -253,14 +253,18 @@ def fixture_setup_vms(get_vmtb_config, get_cmdline_config, get_host, request):
>               ts.vgpu_profile.resources.vfLmem = org_vgpu_profile_vfLmem
>   
>       else:
> -        device.driver.set_auto_provisioning(True)
> -        if ts.testing_config.scheduling_mode is not VfSchedulingMode.INFINITE:
> -            # Auto provisioning with concrete scheduling (i.e. different than HW default: infinite)
> -            ts.vgpu_profile.print_scheduler_config()
> -            device.provision_scheduling(num_vfs, ts.vgpu_profile)
> +        device.driver.restore_auto_provisioning()
>   
>       assert device.create_vf(num_vfs) == num_vfs
>   
> +    if (ts.testing_config.provisioning_mode is VfProvisioningMode.AUTO and
> +        ts.testing_config.scheduling_mode is not VfSchedulingMode.INFINITE):
> +        # Auto resources provisioning with concrete scheduling (i.e. different than HW default: infinite).
> +        # Scheduler params override must be done after enabling VFs
> +        # to allow hard resources auto provisioning by KMD.
> +        ts.vgpu_profile.print_scheduler_config()
> +        device.provision_scheduling(num_vfs, ts.vgpu_profile)
> +
LGTM,
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>       if tc.auto_poweron_vm:
>           bdf_list = [device.get_vf_bdf(vf) for vf in range(1, num_vms + 1)]
>           for vm, bdf in zip(ts.get_vm, bdf_list):