Debian Codegraph @

tests/test_mlx5_vfio.py

raw
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}')