| 1 |
import unittest |
| 2 |
import random |
| 3 |
import errno |
| 4 |
|
| 5 |
from pyverbs.wq import WQInitAttr, WQAttr, WQ, RwqIndTableInitAttr, RwqIndTable, RxHashConf |
| 6 |
from tests.utils import requires_cap_net_raw, PacketConsts, requires_eth |
| 7 |
from tests.base import RDMATestCase, PyverbsRDMAError, MLNX_VENDOR_ID, \ |
| 8 |
CX3_MLNX_PART_ID, CX3Pro_MLNX_PART_ID |
| 9 |
from pyverbs.qp import QPInitAttrEx, QPEx |
| 10 |
from tests.test_flow import FlowRes |
| 11 |
from pyverbs.flow import Flow |
| 12 |
from pyverbs.cq import CQ |
| 13 |
from pyverbs.libibverbs_enums import ibv_qp_init_attr_mask, ibv_qp_type, ibv_wq_attr_mask, ibv_wq_state, \ |
| 14 |
ibv_wq_type, ibv_rx_hash_function_flags, ibv_rx_hash_fields |
| 15 |
import tests.utils as u |
| 16 |
|
| 17 |
|
| 18 |
WRS_PER_ROUND = 512 |
| 19 |
CQS_NUM = 2 |
| 20 |
TOEPLITZ_KEY_LEN = 40 |
| 21 |
HASH_KEY = [0x2c, 0xc6, 0x81, 0xd1, 0x5b, 0xdb, 0xf4, 0xf7, |
| 22 |
0xfc, 0xa2, 0x83, 0x19, 0xdb, 0x1a, 0x3e, 0x94, |
| 23 |
0x6b, 0x9e, 0x38, 0xd9, 0x2c, 0x9c, 0x03, 0xd1, |
| 24 |
0xad, 0x99, 0x44, 0xa7, 0xd9, 0x56, 0x3d, 0x59, |
| 25 |
0x06, 0x3c, 0x25, 0xf3, 0xfc, 0x1f, 0xdc, 0x2a] |
| 26 |
|
| 27 |
|
| 28 |
def requires_indirection_table_support(func): |
| 29 |
def wrapper(instance): |
| 30 |
dev_attrs = instance.ctx.query_device() |
| 31 |
vendor_id = dev_attrs.vendor_id |
| 32 |
vendor_pid = dev_attrs.vendor_part_id |
| 33 |
if vendor_id == MLNX_VENDOR_ID and vendor_pid in [CX3_MLNX_PART_ID, |
| 34 |
CX3Pro_MLNX_PART_ID]: |
| 35 |
raise unittest.SkipTest('WQN must be aligned with the Indirection Table size in CX3') |
| 36 |
return func(instance) |
| 37 |
return wrapper |
| 38 |
|
| 39 |
|
| 40 |
class RssRes(FlowRes): |
| 41 |
def __init__(self, dev_name, ib_port, gid_index, log_ind_tbl_size=3): |
| 42 |
""" |
| 43 |
Initialize rss resources based on Flow resources that include RSS Raw QP. |
| 44 |
:param dev_name: Device name to be used |
| 45 |
:param ib_port: IB port of the device to use |
| 46 |
:param gid_index: Which GID index to use |
| 47 |
""" |
| 48 |
self.log_ind_tbl_size = log_ind_tbl_size |
| 49 |
self.wqs = [] |
| 50 |
self.cqs = [] |
| 51 |
self.ind_table = None |
| 52 |
super().__init__(dev_name=dev_name, ib_port=ib_port, |
| 53 |
gid_index=gid_index) |
| 54 |
|
| 55 |
def create_cq(self): |
| 56 |
self.cqs = [CQ(self.ctx, WRS_PER_ROUND) for _ in range(CQS_NUM)] |
| 57 |
|
| 58 |
@requires_cap_net_raw() |
| 59 |
@requires_eth() |
| 60 |
def create_qps(self): |
| 61 |
""" |
| 62 |
Initializes self.qps with RSS QPs. |
| 63 |
:return: None |
| 64 |
""" |
| 65 |
qp_init_attr = self.create_qp_init_attr() |
| 66 |
for _ in range(self.qp_count): |
| 67 |
try: |
| 68 |
qp = QPEx(self.ctx, qp_init_attr) |
| 69 |
self.qps.append(qp) |
| 70 |
self.qps_num.append(qp.qp_num) |
| 71 |
self.psns.append(random.getrandbits(24)) |
| 72 |
except PyverbsRDMAError as ex: |
| 73 |
if ex.error_code == errno.EOPNOTSUPP: |
| 74 |
raise unittest.SkipTest(f'Create QPEx type {qp_init_attr.qp_type} is not ' |
| 75 |
'supported') |
| 76 |
raise ex |
| 77 |
|
| 78 |
def create_qp_init_attr(self): |
| 79 |
self.create_ind_table() |
| 80 |
mask = ibv_qp_init_attr_mask.IBV_QP_INIT_ATTR_CREATE_FLAGS | ibv_qp_init_attr_mask.IBV_QP_INIT_ATTR_PD | \ |
| 81 |
ibv_qp_init_attr_mask.IBV_QP_INIT_ATTR_RX_HASH | ibv_qp_init_attr_mask.IBV_QP_INIT_ATTR_IND_TABLE |
| 82 |
return QPInitAttrEx(qp_type=ibv_qp_type.IBV_QPT_RAW_PACKET, comp_mask=mask, pd=self.pd, |
| 83 |
hash_conf=self.hash_conf, ind_table=self.ind_tbl) |
| 84 |
|
| 85 |
@requires_indirection_table_support |
| 86 |
def create_ind_table(self): |
| 87 |
self.ind_tbl = RwqIndTable(self.ctx, self.initiate_table_attr()) |
| 88 |
self.hash_conf = self.init_rx_hash_config() |
| 89 |
|
| 90 |
def initiate_table_attr(self): |
| 91 |
self.create_wqs() |
| 92 |
return RwqIndTableInitAttr(self.log_ind_tbl_size, self.wqs) |
| 93 |
|
| 94 |
def create_wqs(self): |
| 95 |
wqias = [self.initiate_wq_attr(cq) for cq in self.cqs] |
| 96 |
for i in range(1 << self.log_ind_tbl_size): |
| 97 |
wq = WQ(self.ctx, wqias[i % CQS_NUM]) |
| 98 |
wq.modify(WQAttr(attr_mask=ibv_wq_attr_mask.IBV_WQ_ATTR_STATE, wq_state=ibv_wq_state.IBV_WQS_RDY)) |
| 99 |
self.wqs.append(wq) |
| 100 |
return self.wqs |
| 101 |
|
| 102 |
def initiate_wq_attr(self, cq): |
| 103 |
return WQInitAttr(wq_context=None, wq_pd=self.pd, wq_cq=cq, wq_type=ibv_wq_type.IBV_WQT_RQ, |
| 104 |
max_wr=WRS_PER_ROUND, max_sge=self.ctx.query_device().max_sge, |
| 105 |
comp_mask=0, create_flags=0) |
| 106 |
|
| 107 |
def init_rx_hash_config(self): |
| 108 |
return RxHashConf(rx_hash_function=ibv_rx_hash_function_flags.IBV_RX_HASH_FUNC_TOEPLITZ, |
| 109 |
rx_hash_key_len=len(HASH_KEY), |
| 110 |
rx_hash_key=HASH_KEY, |
| 111 |
rx_hash_fields_mask=ibv_rx_hash_fields.IBV_RX_HASH_DST_IPV4 | ibv_rx_hash_fields.IBV_RX_HASH_SRC_IPV4) |
| 112 |
|
| 113 |
def _create_flow(self, flow_attr): |
| 114 |
return [Flow(qp, flow_attr) for qp in self.qps] |
| 115 |
|
| 116 |
|
| 117 |
class RSSTrafficTest(RDMATestCase): |
| 118 |
""" |
| 119 |
Test various functionalities of the RSS QPs. |
| 120 |
""" |
| 121 |
def setUp(self): |
| 122 |
super().setUp() |
| 123 |
self.iters = 1 |
| 124 |
self.server = None |
| 125 |
self.client = None |
| 126 |
|
| 127 |
def create_players(self): |
| 128 |
""" |
| 129 |
Init RSS tests resources. |
| 130 |
RSS-QP can recive traffic only, so client will be based on Flow tests resources. |
| 131 |
""" |
| 132 |
self.client = FlowRes(**self.dev_info) |
| 133 |
self.server = RssRes(**self.dev_info) |
| 134 |
|
| 135 |
def flow_traffic(self, specs, l3=PacketConsts.IP_V4, |
| 136 |
l4=PacketConsts.UDP_PROTO): |
| 137 |
""" |
| 138 |
Execute raw ethernet traffic with given specs flow. |
| 139 |
:param specs: List of flow specs to match on the QP |
| 140 |
:param l3: Packet layer 3 type: 4 for IPv4 or 6 for IPv6 |
| 141 |
:param l4: Packet layer 4 type: 'tcp' or 'udp' |
| 142 |
:return: None |
| 143 |
""" |
| 144 |
self.flows = self.server.create_flow(specs) |
| 145 |
u.raw_rss_traffic(self.client, self.server, self.iters, l3, l4, |
| 146 |
num_packets=32) |
| 147 |
|
| 148 |
def test_rss_traffic(self): |
| 149 |
self.create_players() |
| 150 |
self.flow_traffic([self.server.create_eth_spec()]) |