| 1 |
# SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) |
| 2 |
# Copyright (c) 2021 Nvidia, Inc. All rights reserved. See COPYING file |
| 3 |
""" |
| 4 |
Test module for pyverbs' mlx5_vfio module. |
| 5 |
""" |
| 6 |
|
| 7 |
from threading import Thread |
| 8 |
import unittest |
| 9 |
import logging |
| 10 |
import struct |
| 11 |
import select |
| 12 |
import errno |
| 13 |
import time |
| 14 |
import math |
| 15 |
import os |
| 16 |
|
| 17 |
from tests.mlx5_base import Mlx5DevxRcResources, Mlx5DevxTrafficBase, PortState, \ |
| 18 |
PortStatus, PORT_STATE_TIMEOUT |
| 19 |
from pyverbs.providers.mlx5.mlx5dv import Mlx5DevxMsiVector, Mlx5DevxEq, Mlx5UAR |
| 20 |
from pyverbs.providers.mlx5.mlx5_vfio import Mlx5VfioAttr, Mlx5VfioContext |
| 21 |
from pyverbs.pyverbs_error import PyverbsRDMAError |
| 22 |
from pyverbs.providers.mlx5.mlx5_enums import _MLX5DV_UAR_ALLOC_TYPE_NC |
| 23 |
from pyverbs.base import PyverbsRDMAErrno |
| 24 |
import pyverbs.mem_alloc as mem |
| 25 |
import pyverbs.dma_util as dma |
| 26 |
|
| 27 |
EVENT_TIMEOUT = 2 # In seconds |
| 28 |
EVENT_REGISTRATION_TIMEOUT = 3 # In seconds |
| 29 |
|
| 30 |
|
| 31 |
class Mlx5VfioResources(Mlx5DevxRcResources): |
| 32 |
def __init__(self, ib_port, pci_name, gid_index=None, ctx=None, activate_port_state=False): |
| 33 |
self.pci_name = pci_name |
| 34 |
self.ctx = ctx |
| 35 |
super().__init__(None, ib_port, gid_index, activate_port_state=activate_port_state) |
| 36 |
|
| 37 |
def create_context(self): |
| 38 |
""" |
| 39 |
Opens an mlx5 VFIO context. |
| 40 |
Since only one context is allowed to be opened on a VFIO, the user must |
| 41 |
pass that context for the remaining resources, which in that case, the |
| 42 |
same context would be used. |
| 43 |
:return: None |
| 44 |
""" |
| 45 |
if self.ctx: |
| 46 |
return |
| 47 |
try: |
| 48 |
vfio_attr = Mlx5VfioAttr(pci_name=self.pci_name) |
| 49 |
vfio_attr.pci_name = self.pci_name |
| 50 |
self.ctx = Mlx5VfioContext(attr=vfio_attr) |
| 51 |
except PyverbsRDMAError as ex: |
| 52 |
if ex.error_code == errno.EOPNOTSUPP: |
| 53 |
raise unittest.SkipTest(f'Mlx5 VFIO is not supported ({ex})') |
| 54 |
raise ex |
| 55 |
|
| 56 |
def query_gid(self): |
| 57 |
""" |
| 58 |
Currently Mlx5VfioResources does not support Eth port type. |
| 59 |
Query GID would just be skipped. |
| 60 |
""" |
| 61 |
pass |
| 62 |
|
| 63 |
|
| 64 |
class Mlx5VfioEqResources(Mlx5VfioResources): |
| 65 |
def __init__(self, ib_port, pci_name, gid_index=None, ctx=None): |
| 66 |
self.cons_index = 0 |
| 67 |
super().__init__(ib_port, pci_name, gid_index, ctx) |
| 68 |
self.logger = logging.getLogger(self.__class__.__name__) |
| 69 |
|
| 70 |
def create_uar(self): |
| 71 |
super().create_uar() |
| 72 |
self.uar['eq'] = Mlx5UAR(self.ctx, _MLX5DV_UAR_ALLOC_TYPE_NC) |
| 73 |
if not self.uar['eq'].page_id: |
| 74 |
raise PyverbsRDMAError('Failed to allocate UAR') |
| 75 |
|
| 76 |
def get_eqe(self, cc): |
| 77 |
from tests.mlx5_prm_structs import SwEqe |
| 78 |
|
| 79 |
ci = self.cons_index + cc |
| 80 |
entry = ci & (self.nent - 1) |
| 81 |
eqe_bytes = mem.read64(self.eq.vaddr + entry * len(SwEqe())) |
| 82 |
eqe_bytes = eqe_bytes.to_bytes(length=8, byteorder='little') |
| 83 |
eqe = SwEqe(eqe_bytes) |
| 84 |
if (eqe.owner & 1) ^ (not(not(ci & self.nent))): |
| 85 |
eqe = None |
| 86 |
elif eqe: |
| 87 |
dma.udma_from_dev_barrier() |
| 88 |
|
| 89 |
return eqe |
| 90 |
|
| 91 |
def update_ci(self, cc, arm=0): |
| 92 |
addr = self.doorbell |
| 93 |
if arm: |
| 94 |
addr += 8 # Adding 2 bytes according to PRM |
| 95 |
self.cons_index += cc |
| 96 |
val = (self.cons_index & 0xffffff) | (self.eqn << 24) |
| 97 |
val_be = struct.unpack("<I", struct.pack(">I", val))[0] |
| 98 |
dma.mmio_write32_as_be(addr, val_be) |
| 99 |
dma.udma_to_dev_barrier() |
| 100 |
|
| 101 |
def init_dveq_buff(self): |
| 102 |
from tests.mlx5_prm_structs import SwEqe |
| 103 |
|
| 104 |
for i in range(self.nent): |
| 105 |
eqe_bytes = mem.read64(self.eq.vaddr + i * len(SwEqe())) |
| 106 |
eqe_bytes = eqe_bytes.to_bytes(length=8, byteorder='little') |
| 107 |
eqe = SwEqe(eqe_bytes) |
| 108 |
eqe.owner = 0x1 |
| 109 |
self.update_ci(0) |
| 110 |
|
| 111 |
def update_cc(self, cc): |
| 112 |
if cc >= self.num_spare_eqe: |
| 113 |
self.update_ci(cc) |
| 114 |
cc = 0 |
| 115 |
return cc |
| 116 |
|
| 117 |
def create_eq(self): |
| 118 |
from tests.mlx5_prm_structs import CreateEqIn, SwEqc, CreateEqOut,\ |
| 119 |
EventType |
| 120 |
|
| 121 |
# Using num_spare_eqe to guarantee that we update |
| 122 |
# the ci before we polled all the entries in the EQ |
| 123 |
self.num_spare_eqe = 0x80 |
| 124 |
self.nent = 0x80 + self.num_spare_eqe |
| 125 |
self.msi_vector = Mlx5DevxMsiVector(self.ctx) |
| 126 |
vector = self.msi_vector.vector |
| 127 |
log_eq_size = math.ceil(math.log2(self.nent)) |
| 128 |
mask = 1 << EventType.PORT_STATE_CHANGE |
| 129 |
cmd_in = CreateEqIn(sw_eqc=SwEqc(uar_page=self.uar['eq'].page_id, |
| 130 |
log_eq_size=log_eq_size, intr=vector), |
| 131 |
event_bitmask_63_0=mask) |
| 132 |
self.eq = Mlx5DevxEq(self.ctx, cmd_in, len(CreateEqOut())) |
| 133 |
self.eqn = CreateEqOut(self.eq.out_view).eqn |
| 134 |
self.doorbell = self.uar['eq'].base_addr + 0x40 |
| 135 |
self.init_dveq_buff() |
| 136 |
self.update_ci(0, 1) |
| 137 |
|
| 138 |
def query_eqn(self): |
| 139 |
pass |
| 140 |
|
| 141 |
def process_async_events(self, fd): |
| 142 |
from tests.mlx5_prm_structs import EventType |
| 143 |
|
| 144 |
cc = 0 |
| 145 |
ret = os.read(fd, 8) |
| 146 |
if not ret: |
| 147 |
raise PyverbsRDMAErrno('Failed to read FD') |
| 148 |
eqe = self.get_eqe(cc) |
| 149 |
while eqe: |
| 150 |
if eqe.event_type == EventType.PORT_STATE_CHANGE: |
| 151 |
self.logger.debug('Caught port state change event') |
| 152 |
return eqe.event_type |
| 153 |
elif eqe.event_type == EventType.CQ_ERROR: |
| 154 |
raise PyverbsRDMAError('Event type Error') |
| 155 |
cc = self.update_cc(cc + 1) |
| 156 |
eqe = self.get_eqe(cc) |
| 157 |
self.update_ci(cc, 1) |
| 158 |
|
| 159 |
|
| 160 |
class Mlx5VfioTrafficTest(Mlx5DevxTrafficBase): |
| 161 |
""" |
| 162 |
Test various functionality of an mlx5-vfio device. |
| 163 |
""" |
| 164 |
def setUp(self): |
| 165 |
""" |
| 166 |
Verifies that the user has passed a PCI device name to work with. |
| 167 |
""" |
| 168 |
self.pci_dev = self.config['pci_dev'] |
| 169 |
if not self.pci_dev: |
| 170 |
raise unittest.SkipTest('PCI device must be passed by the user') |
| 171 |
|
| 172 |
def create_players(self): |
| 173 |
self.server = Mlx5VfioResources(ib_port=self.ib_port, pci_name=self.pci_dev, |
| 174 |
activate_port_state=True) |
| 175 |
self.client = Mlx5VfioResources(ib_port=self.ib_port, pci_name=self.pci_dev, |
| 176 |
ctx=self.server.ctx) |
| 177 |
|
| 178 |
def create_async_players(self): |
| 179 |
self.server = Mlx5VfioEqResources(ib_port=self.ib_port, pci_name=self.pci_dev) |
| 180 |
self.client = Mlx5VfioResources(ib_port=self.ib_port, pci_name=self.pci_dev, |
| 181 |
ctx=self.server.ctx) |
| 182 |
|
| 183 |
def vfio_process_events(self): |
| 184 |
""" |
| 185 |
Processes mlx5 vfio device events. |
| 186 |
This method should run from application thread to maintain the events. |
| 187 |
""" |
| 188 |
# Server and client use the same context |
| 189 |
events_fd = self.server.ctx.get_events_fd() |
| 190 |
with select.epoll() as epoll_events: |
| 191 |
epoll_events.register(events_fd, select.EPOLLIN) |
| 192 |
while self.proc_events: |
| 193 |
for fd, event in epoll_events.poll(timeout=0.1): |
| 194 |
if fd == events_fd: |
| 195 |
if not (event & select.EPOLLIN): |
| 196 |
self.event_ex.append(PyverbsRDMAError(f'Unexpected vfio event: {event}')) |
| 197 |
self.server.ctx.process_events() |
| 198 |
|
| 199 |
def vfio_process_async_events(self): |
| 200 |
""" |
| 201 |
Processes mlx5 vfio device async events. |
| 202 |
This method should run from application thread to maintain the events. |
| 203 |
""" |
| 204 |
from tests.mlx5_prm_structs import EventType |
| 205 |
|
| 206 |
# Server and client use the same context |
| 207 |
events_fd = self.server.msi_vector.fd |
| 208 |
with select.epoll() as epoll_events: |
| 209 |
epoll_events.register(events_fd, select.EPOLLIN) |
| 210 |
self.reg_async_events = True |
| 211 |
while self.proc_events: |
| 212 |
for fd, event in epoll_events.poll(timeout=0.1): |
| 213 |
if fd == events_fd: |
| 214 |
if not (event & select.EPOLLIN): |
| 215 |
self.event_ex.append(PyverbsRDMAError(f'Unexpected vfio event: {event}')) |
| 216 |
if self.server.process_async_events(events_fd) == EventType.PORT_STATE_CHANGE: |
| 217 |
self.caught_event = True |
| 218 |
|
| 219 |
def test_mlx5vfio_rc_qp_send_imm_traffic(self): |
| 220 |
""" |
| 221 |
Opens one mlx5 vfio context, creates two DevX RC QPs on it, and modifies |
| 222 |
them to RTS state. |
| 223 |
Then does SEND_IMM traffic. |
| 224 |
""" |
| 225 |
self.create_players() |
| 226 |
if self.server.is_eth(): |
| 227 |
raise unittest.SkipTest(f'{self.__class__.__name__} is currently supported over IB only') |
| 228 |
self.event_ex = [] |
| 229 |
self.proc_events = True |
| 230 |
proc_events = Thread(target=self.vfio_process_events) |
| 231 |
proc_events.start() |
| 232 |
# Move the DevX QPs to RTS state |
| 233 |
self.pre_run() |
| 234 |
try: |
| 235 |
# Send traffic |
| 236 |
self.send_imm_traffic() |
| 237 |
finally: |
| 238 |
# Stop listening to events |
| 239 |
self.proc_events = False |
| 240 |
proc_events.join() |
| 241 |
if self.event_ex: |
| 242 |
raise PyverbsRDMAError(f'Received unexpected vfio events: {self.event_ex}') |
| 243 |
|
| 244 |
def test_mlx5vfio_async_event(self): |
| 245 |
""" |
| 246 |
Opens one mlx5 vfio context, creates DevX EQ on it. |
| 247 |
Then activates the port and catches the port state change event. |
| 248 |
""" |
| 249 |
self.create_async_players() |
| 250 |
if self.server.is_eth(): |
| 251 |
raise unittest.SkipTest(f'{self.__class__.__name__} is currently supported over IB only') |
| 252 |
self.event_ex = [] |
| 253 |
self.proc_events = True |
| 254 |
self.caught_event = False |
| 255 |
self.reg_async_events = False |
| 256 |
proc_events = Thread(target=self.vfio_process_events) |
| 257 |
proc_async_events = Thread(target=self.vfio_process_async_events) |
| 258 |
proc_events.start() |
| 259 |
proc_async_events.start() |
| 260 |
# Move the DevX QPs to RTS state |
| 261 |
self.pre_run() |
| 262 |
try: |
| 263 |
start_reg_t = time.perf_counter() |
| 264 |
while not self.reg_async_events: |
| 265 |
if time.perf_counter() - start_reg_t >= EVENT_REGISTRATION_TIMEOUT: |
| 266 |
raise PyverbsRDMAError('Could not register async events') |
| 267 |
# Change port state |
| 268 |
self.server.change_port_state_with_registers(PortStatus.MLX5_PORT_UP) |
| 269 |
admin_status, oper_status = self.server.query_port_state_with_registers() |
| 270 |
start_state_t = time.perf_counter() |
| 271 |
while admin_status != PortStatus.MLX5_PORT_UP or oper_status != PortStatus.MLX5_PORT_UP: |
| 272 |
if time.perf_counter() - start_state_t >= PORT_STATE_TIMEOUT: |
| 273 |
raise PyverbsRDMAError('Could not change the port state to UP') |
| 274 |
admin_status, oper_status = self.server.query_port_state_with_registers() |
| 275 |
start_state_t = time.perf_counter() |
| 276 |
while self.server.query_port_state_with_mads(self.ib_port) < PortState.ACTIVE: |
| 277 |
if time.perf_counter() - start_state_t >= PORT_STATE_TIMEOUT: |
| 278 |
raise PyverbsRDMAError('Could not change the port state to ACTIVE') |
| 279 |
time.sleep(1) |
| 280 |
finally: |
| 281 |
# Stop listening to events |
| 282 |
start_event_t = time.perf_counter() |
| 283 |
while not self.caught_event: |
| 284 |
if time.perf_counter() - start_event_t >= EVENT_TIMEOUT: |
| 285 |
raise PyverbsRDMAError('Failed to catch an async event') |
| 286 |
self.proc_events = False |
| 287 |
proc_events.join() |
| 288 |
proc_async_events.join() |
| 289 |
if self.event_ex: |
| 290 |
raise PyverbsRDMAError(f'Received unexpected vfio events: {self.event_ex}') |