????
Your IP : 18.223.132.16
from . import hotplug
from .decorators import *
import tuned.consts as consts
import tuned.logs
import errno
import os
log = tuned.logs.get()
# the plugin manages each IRQ as a "device" and keeps a IrqInfo object for it
class IrqInfo(object):
def __init__(self, irq):
self.irq = irq
self.device = "irq%s" % irq
self.unchangeable = False
self.original_affinity = None
class IrqPlugin(hotplug.Plugin):
r"""
`irq`::
Allows tuning of IRQ affinities, and thus re-implements functionality
already present in the `scheduler` plugin. However, this plugin offers
more flexibility, as it allows tuning of individual interrupts with
different affinities. When using the `irq` plugin, make sure to disable
IRQ processing in the `scheduler` plugin by setting its option
[option]`irq_process=false`.
The plugin handles individual IRQs as `devices`, and multiple plugin
instances can be defined, each addressing different devices/irqs.
The `device` names used by the plugin are `irq<n>`, where `<n>` is the
IRQ number. The special `device` `DEFAULT` controls values written to
`/proc/irq/default_smp_affinity`, which applies to all non-active IRQs.
===
The option [option]`affinity` controls the IRQ affinity to be set. It is
a string in "cpulist" format (such as 1,3-4). If the configured affinity
is empty, then the affinity of the respective IRQs is not touched.
===
The option [option]`mode` is a string which can either be `set` (default)
or `intersect`. In `set` mode the [option]`affinity` is always written
as configured, whereas in `intersect` mode, the new affinity will be
calculated as the intersection of the current and the configured affinity.
If that intersection is empty, the configured affinity will be used.
--
.Example moving all IRQs to CPU0, except irq16, which is directed to CPU2
====
----
[irq_special]
type=irq
devices=irq16
affinity=2
[irq]
affinity=0
----
====
"""
def __init__(self, monitor_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, plugin_instance_factory, global_cfg, variables):
super(IrqPlugin, self).__init__(monitor_repository, storage_factory, hardware_inventory, device_matcher, device_matcher_udev, plugin_instance_factory, global_cfg, variables)
self._irqs = {}
#
# plugin-level methods: devices and plugin options
#
def _init_devices(self):
"""Read /proc/irq to collect devices
"""
self._devices_supported = True
self._free_devices = set()
self._assigned_devices = set()
for i in os.listdir("/proc/irq"):
p = os.path.join("/proc/irq", i)
if os.path.isdir(p) and i.isdigit():
info = IrqInfo(i)
self._irqs[i] = info
self._free_devices.add(info.device)
# add the virtual device for default_smp_affinity
default_info = IrqInfo("DEFAULT")
default_info.device = "DEFAULT"
self._irqs["DEFAULT"] = default_info
self._free_devices.add(default_info.device)
@classmethod
def _get_config_options(cls):
return {
"affinity": "",
"mode": "set",
}
#
# instance-level methods: implement the Instance interface
#
def _instance_init(self, instance):
instance._has_static_tuning = True
instance._has_dynamic_tuning = False
affinity = self._variables.expand(instance.options.get("affinity"))
affinity_list = self._cmd.cpulist_unpack(affinity)
if len(affinity.strip()) == 0:
# empty affinity in profile -> assume it's intentional
log.info("Instance '%s' configured with empty affinity. Deactivating." % instance.name)
instance._active = False
elif len(affinity_list) == 0:
# non-empty affinity string evaluates to empty list -> assume parse error
log.error("Instance '%s' with invalid affinity '%s'. Deactivating." % (instance.name, affinity))
instance._active = False
mode = self._variables.expand(instance.options.get("mode"))
if mode not in ["set", "intersect"]:
log.error("Invalid operating mode '%s' for instance '%s'. Using the default 'set' instead."
% (mode, instance.name))
instance.options["mode"] = "set"
def _instance_cleanup(self, instance):
pass
def _instance_apply_static(self, instance):
log.debug("Applying IRQ affinities (%s)" % instance.name)
super(IrqPlugin, self)._instance_apply_static(instance)
def _instance_unapply_static(self, instance, rollback):
log.debug("Unapplying IRQ affinities (%s)" % instance.name)
super(IrqPlugin, self)._instance_unapply_static(instance, rollback)
def _instance_verify_static(self, instance, ignore_missing, devices):
log.debug("Verifying IRQ affinities (%s)" % instance.name)
return super(IrqPlugin, self)._instance_verify_static(instance, ignore_missing, devices)
#
# "low-level" methods to get/set irq affinities
#
def _get_irq_affinity(self, irq):
"""Get current IRQ affinity from the kernel
Args:
irq (str): IRQ number (as string) or "DEFAULT"
Returns:
affinity (set): set of all CPUs that belong to the IRQ affinity mask,
if reading of the affinity fails, an empty set is returned
"""
try:
filename = "/proc/irq/default_smp_affinity" if irq == "DEFAULT" else "/proc/irq/%s/smp_affinity" % irq
with open(filename, "r") as f:
affinity_hex = f.readline().strip()
return set(self._cmd.hex2cpulist(affinity_hex))
except (OSError, IOError) as e:
log.debug("Failed to read SMP affinity of IRQ %s: %s" % (irq, e))
return set()
def _set_irq_affinity(self, irq, affinity, restoring):
"""Set IRQ affinity in the kernel
Args:
irq (str): IRQ number (as string) or "DEFAULT"
affinity (set): affinity mask as set of CPUs
restoring (bool): are we rolling back a previous change?
Returns:
status (int): 0 on success, -2 if changing the affinity is not
supported, -1 if some other error occurs
"""
try:
affinity_hex = self._cmd.cpulist2hex(list(affinity))
log.debug("Setting SMP affinity of IRQ %s to '%s'" % (irq, affinity_hex))
filename = "/proc/irq/default_smp_affinity" if irq == "DEFAULT" else "/proc/irq/%s/smp_affinity" % irq
with open(filename, "w") as f:
f.write(affinity_hex)
return 0
except (OSError, IOError) as e:
# EIO is returned by
# kernel/irq/proc.c:write_irq_affinity() if changing
# the affinity is not supported
# (at least on kernels 3.10 and 4.18)
if hasattr(e, "errno") and e.errno == errno.EIO and not restoring:
log.debug("Setting SMP affinity of IRQ %s is not supported" % irq)
return -2
else:
log.error("Failed to set SMP affinity of IRQ %s to '%s': %s" % (irq, affinity_hex, e))
return -1
#
# "high-level" methods: apply tuning while saving original affinities
#
def _apply_irq_affinity(self, irqinfo, affinity, mode):
"""Apply IRQ affinity tuning
Args:
irqinfo (IrqInfo): IRQ that should be tuned
affinity (set): desired affinity
"""
original = self._get_irq_affinity(irqinfo.irq)
if mode == "intersect":
# intersection of affinity and original, if that is empty fall back to configured affinity
affinity = affinity & original or affinity
if irqinfo.unchangeable or affinity == original:
return
res = self._set_irq_affinity(irqinfo.irq, affinity, False)
if res == 0:
if irqinfo.original_affinity is None:
irqinfo.original_affinity = original
elif res == -2:
irqinfo.unchangeable = True
def _restore_irq_affinity(self, irqinfo):
"""Restore IRQ affinity
Args:
irqinfo (IrqInfo): IRQ that should be restored
"""
if irqinfo.unchangeable or irqinfo.original_affinity is None:
return
self._set_irq_affinity(irqinfo.irq, irqinfo.original_affinity, True)
irqinfo.original_affinity = None
def _verify_irq_affinity(self, irqinfo, affinity, mode):
"""Verify IRQ affinity tuning
Args:
irqinfo (IrqInfo): IRQ that should be verified
affinity (set): desired affinity
Returns:
status (bool): True if verification successful, False otherwise
"""
if irqinfo.unchangeable:
return True
affinity_description = "IRQ %s affinity" % irqinfo.irq
desired_affinity = affinity
desired_affinity_string = self._cmd.cpulist2string(self._cmd.cpulist_pack(list(desired_affinity)))
current_affinity = self._get_irq_affinity(irqinfo.irq)
current_affinity_string = self._cmd.cpulist2string(self._cmd.cpulist_pack(list(current_affinity)))
if mode == "intersect":
# In intersect mode, we don't use a strict comparison; it's sufficient
# if the current affinity is a subset of the desired one
desired_affinity_string = "subset of " + desired_affinity_string
if ((mode == "intersect" and current_affinity <= desired_affinity) or
(mode == "set" and current_affinity == desired_affinity)):
log.info(consts.STR_VERIFY_PROFILE_VALUE_OK
% (affinity_description, desired_affinity_string))
return True
else:
log.error(consts.STR_VERIFY_PROFILE_VALUE_FAIL
% (affinity_description, current_affinity_string, desired_affinity_string))
return False
#
# command definitions: entry to device-specific tuning
#
@command_custom("mode", per_device=False, priority=-10)
def _mode(self, enabling, value, verify, ignore_missing):
if (enabling or verify) and value is not None:
# Store the operating mode of the current instance in the plugin
# object, from where it is read by the "affinity" command.
# This works because instances are processed sequentially by the engine.
self._mode_val = value
@command_custom("affinity", per_device=True)
def _affinity(self, enabling, value, device, verify, ignore_missing):
irq = "DEFAULT" if device == "DEFAULT" else device[len("irq"):]
if irq not in self._irqs:
log.error("Unknown device: %s" % device)
return None
irqinfo = self._irqs[irq]
if verify:
affinity = set(self._cmd.cpulist_unpack(value))
return self._verify_irq_affinity(irqinfo, affinity, self._mode_val)
if enabling:
affinity = set(self._cmd.cpulist_unpack(value))
return self._apply_irq_affinity(irqinfo, affinity, self._mode_val)
else:
return self._restore_irq_affinity(irqinfo)