def __init__(self, devid, cpunum, proc):
"""The class constructor. The arguments are the same as in '_WultDeviceBase.__init__()'."""
super().__init__(devid, cpunum, proc)
self._pci_info = None
self._devpath = None
self._captured = None
path = Path(f"/sys/bus/pci/devices/{self._devid}")
if not FSHelpers.exists(path, proc=proc):
raise ErrorNotFound(f"cannot find device '{self._devid}'{self._proc.hostmsg}:\n"
f"path {path} does not exist")
self._devpath = FSHelpers.abspath(path, proc=self._proc)
self._pci_info = LsPCI.LsPCI(proc).get_info(Path(self._devpath).name)
if self.supported_devices and self._pci_info['devid'] not in self.supported_devices:
supported = ["%s - %s" % (key, val) for key, val in self.supported_devices.items()]
supported = "\n * ".join(supported)
raise ErrorNotSupported(f"PCI device '{self._pci_info['pciaddr']}' (PCI ID "
f"{self._pci_info['devid']}) is not supported by wult driver "
f"{self.drvname}.\nHere is the list of supported PCI IDs:\n* "
f"{supported}")
self.info["name"] = "Intel I210"
self.info["devid"] = self._pci_info["pciaddr"]
if self.supported_devices:
self.info["descr"] = self.supported_devices[self._pci_info['devid']]
else:
self.info["name"] = self._pci_info["name"]
self.info["descr"] = self.info['name'].capitalize()
self.info["descr"] += f". PCI address {self._pci_info['pciaddr']}, Vendor ID " \
f"{self._pci_info['vendorid']}, Device ID {self._pci_info['devid']}."
def _get_driver(self):
"""
Find out whether the PCI device is bound to any driver. If it is not, returns the
'(None, None)' tuple. Otherwise returns a tuple of:
* driver name
* driver sysfs path
"""
drvpath = Path(f"{self._devpath}/driver")
if not FSHelpers.exists(drvpath, proc=self._proc):
return (None, None)
drvpath = FSHelpers.abspath(drvpath, proc=self._proc)
drvname = Path(drvpath).name
return (drvname, drvpath)
def _get_hw_addr(self):
"""
Return the hardware address for the NIC corresponding to the network interface. Typically
the hardware address is a PCI address, such as '0000:04:00.0'.
"""
# The "device" symlink leads to the sysfs subdirectory corresponding to the underlying NIC.
path = self._sysfsbase / "device"
if not FSHelpers.exists(path, proc=self._proc):
raise ErrorNotFound(
f"cannot find network interface '{self.ifname}':\n"
f"path '{path}' does not exist{self._proc.hostmsg}'")
# The name of the subdirectory is the hardware address.
path = FSHelpers.abspath(path, proc=self._proc)
return path.name
def _get_ifinfos(proc):
"""
For every network interfaces backed by a real device on the system defined by 'proc', yield the
following tuples:
* interface name
* device HW address
"""
for ifname, path, typ in FSHelpers.lsdir(_SYSFSBASE, proc=proc):
if typ != "@":
# We expect a symlink.
continue
devpath = None
with contextlib.suppress(Error):
devpath = FSHelpers.abspath(path / "device", proc=proc)
if not devpath:
continue
yield ifname, devpath.name
def _deploy_prepare(args, toolname, minkver):
"""
Validate command-line arguments of the "deploy" command and prepare for builing the helpers and
drivers. The arguments are as follows.
o args - the command line arguments.
o toolname - name of the tool being deployed (e.g., 'ndl').
o minkver - the minimum required version number.
"""
args.tmpdir = None
args.kver = None
if not args.ihost:
args.ihost = "localhost"
if not args.bhost:
args.bhost = args.ihost
if args.ihost != args.bhost and not args.bhost == "localhost":
raise Error("build host (--build-host) must be the local host or the same as deploy host "
"(--host)")
if args.ihost == "localhost" and args.bhost == "localhost":
for attr in ("username", "privkey", "timeout"):
if getattr(args, attr) is not None:
_LOG.warning("ignoring the '--%s' option as it not useful for a local host", attr)
if not args.timeout:
args.timeout = 8
else:
args.timeout = Trivial.str_to_num(args.timeout)
if not args.username:
args.username = "******"
if args.privkey and not args.privkey.is_dir():
raise Error(f"path '{args.privkey}' does not exist or it is not a directory")
if hasattr(args, "drvsrc"):
if not args.drvsrc:
args.drvsrc = FSHelpers.search_for_app_data("wult", _DRV_SRC_SUBPATH/f"{toolname}",
pathdescr=f"{toolname} drivers sources")
if not args.drvsrc.is_dir():
raise Error(f"path '{args.drvsrc}' does not exist or it is not a directory")
if hasattr(args, "helpersrc"):
if not args.helpersrc:
args.helpersrc = FSHelpers.search_for_app_data("wult",
_HELPERS_SRC_SUBPATH/f"{toolname}",
pathdescr=f"{toolname} helper sources")
if not args.helpersrc.is_dir():
raise Error(f"path '{args.helpersrc}' does not exist or it is not a directory")
with contextlib.closing(get_proc(args, args.bhost)) as proc:
if not FSHelpers.which("make", default=None, proc=proc):
raise Error(f"please, install the 'make' tool{proc.hostmsg}")
if not args.ksrc:
args.kver = KernelVersion.get_kver(proc=proc)
if not args.ksrc:
args.ksrc = Path(f"/lib/modules/{args.kver}/build")
else:
args.ksrc = FSHelpers.abspath(args.ksrc, proc=proc)
if not FSHelpers.isdir(args.ksrc, proc=proc):
raise Error(f"kernel sources directory '{args.ksrc}' does not exist{proc.hostmsg}")
if not args.kver:
args.kver = KernelVersion.get_kver_ktree(args.ksrc, proc=proc)
_LOG.info("Kernel sources path: %s", args.ksrc)
_LOG.info("Kernel version: %s", args.kver)
if KernelVersion.kver_lt(args.kver, minkver):
raise Error(f"version of the kernel{proc.hostmsg} is {args.kver}, and it is not new "
f"enough.\nPlease, use kernel version {minkver} or newer.")
args.tmpdir = FSHelpers.mktemp(prefix=f"{toolname}-", proc=proc)
if hasattr(args, "drvsrc"):
_LOG.debug("copying the drivers to %s:\n '%s' -> '%s'",
proc.hostname, args.drvsrc, args.tmpdir)
proc.rsync(f"{args.drvsrc}/", args.tmpdir / "drivers", remotesrc=False, remotedst=True)
args.drvsrc = args.tmpdir / "drivers"
_LOG.info("Drivers will be compiled on host '%s'", proc.hostname)
if hasattr(args, "helpersrc"):
_LOG.debug("copying the helpers to %s:\n '%s' -> '%s'",
proc.hostname, args.helpersrc, args.tmpdir)
proc.rsync(f"{args.helpersrc}/", args.tmpdir / "helpers", remotesrc=False,
remotedst=True)
args.helpersrc = args.tmpdir / "helpers"
_LOG.info("Helpers will be compiled on host '%s'", proc.hostname)
with contextlib.closing(get_proc(args, args.ihost)) as proc:
if not args.kmodpath:
args.kmodpath = Path(f"/lib/modules/{args.kver}")
if not FSHelpers.isdir(args.kmodpath, proc=proc):
raise Error(f"kernel modules directory '{args.kmodpath}' does not exist{proc.hostmsg}")
_LOG.info("Drivers will be deployed to '%s'%s", args.kmodpath, proc.hostmsg)
_LOG.info("Kernel modules path%s: %s", proc.hostmsg, args.kmodpath)
if hasattr(args, "helpersrc"):
if not args.helpers_path:
args.helpers_path = get_helpers_deploy_path(proc, toolname)
_LOG.info("Helpers will be deployed to '%s'%s", args.helpers_path, proc.hostmsg)