def test_create_dm_bad_flow(self):
"""
test ibv_alloc_dm() with an illegal size and comp mask
"""
for ctx, attr, attr_ex in self.devices:
if attr_ex.max_dm_size == 0:
return
dm_len = attr_ex.max_dm_size + 1
dm_attrs = u.get_dm_attrs(dm_len)
try:
d.DM(ctx, dm_attrs)
except PyverbsRDMAError as e:
assert 'Failed to allocate device memory of size' in \
e.args[0]
assert 'Max available size' in e.args[0]
else:
raise PyverbsError(
'Created a DM with size larger than max reported')
dm_attrs.comp_mask = random.randint(1, 100)
try:
d.DM(ctx, dm_attrs)
except PyverbsRDMAError as e:
assert 'Failed to allocate device memory of size' in \
e.args[0]
else:
raise PyverbsError(
'Created a DM with illegal comp mask {c}'. \
format(c=dm_attrs.comp_mask))
def test_dm_write_bad_flow(self):
"""
Test writing to the device memory with bad offset and length
"""
lst = d.get_device_list()
for dev in lst:
with d.Context(name=dev.name.decode()) as ctx:
attr = ctx.query_device_ex()
if attr.max_dm_size == 0:
return
dm_len = random.randrange(u.MIN_DM_SIZE, attr.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
with d.DM(ctx, dm_attrs) as dm:
data_length = random.randrange(4, dm_len, u.DM_ALIGNMENT)
data_offset = random.randrange(0, dm_len - data_length,
u.DM_ALIGNMENT)
data_offset += 1 # offset needs to be a multiple of 4
data = u.get_data(data_length)
try:
dm.copy_to_dm(data_offset, data.encode(), data_length)
except PyverbsRDMAError as e:
assert 'Failed to copy to dm' in e.args[0]
else:
raise PyverbsError(
'Wrote to device memory with a bad offset')
def test_create_dm_bad_flow(self):
"""
test ibv_alloc_dm() with an illegal size and comp mask
"""
lst = d.get_device_list()
for dev in lst:
with d.Context(name=dev.name.decode()) as ctx:
attr = ctx.query_device_ex()
if attr.max_dm_size == 0:
return
dm_len = attr.max_dm_size + 1
dm_attrs = u.get_dm_attrs(dm_len)
try:
dm = d.DM(ctx, dm_attrs)
except PyverbsRDMAError as e:
assert 'Failed to allocate device memory of size' in e.args[
0]
assert 'Max available size' in e.args[0]
else:
raise PyverbsError(
'Created a DM with size larger than max reported')
dm_attrs.comp_mask = random.randint(1, 100)
try:
dm = d.DM(ctx, dm_attrs)
except PyverbsRDMAError as e:
assert 'Failed to allocate device memory of size' in e.args[
0]
else:
raise PyverbsError('Created a DM with illegal comp mask {c}'.\
format(c=dm_attrs.comp_mask))
def test_destroy_dm(self):
"""
test ibv_free_dm()
"""
for ctx, attr, attr_ex in self.devices:
if attr_ex.max_dm_size == 0:
return
dm_len = random.randrange(u.MIN_DM_SIZE, attr_ex.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
dm = d.DM(ctx, dm_attrs)
dm.close()
def test_create_dm(self):
"""
test ibv_alloc_dm()
"""
for ctx, attr, attr_ex in self.devices:
if attr_ex.max_dm_size == 0:
return
dm_len = random.randrange(u.MIN_DM_SIZE, attr_ex.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
with d.DM(ctx, dm_attrs):
pass
def test_destroy_dm(self):
"""
test ibv_free_dm()
"""
lst = d.get_device_list()
for dev in lst:
with d.Context(name=dev.name.decode()) as ctx:
attr = ctx.query_device_ex()
if attr.max_dm_size == 0:
return
dm_len = random.randrange(u.MIN_DM_SIZE, attr.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
dm = d.DM(ctx, dm_attrs)
dm.close()
def test_dm_write(self):
"""
Test writing to the device memory
"""
for ctx, attr, attr_ex in self.devices:
if attr_ex.max_dm_size == 0:
return
dm_len = random.randrange(u.MIN_DM_SIZE, attr_ex.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
with d.DM(ctx, dm_attrs) as dm:
data_length = random.randrange(4, dm_len, u.DM_ALIGNMENT)
data_offset = random.randrange(0, dm_len - data_length,
u.DM_ALIGNMENT)
data = 'a' * data_length
dm.copy_to_dm(data_offset, data.encode(), data_length)
def test_create_dm_mr(self):
"""
Test ibv_reg_dm_mr
"""
for ctx, attr, attr_ex in self.devices:
if attr_ex.max_dm_size == 0:
return
with PD(ctx) as pd:
for i in range(10):
dm_len = random.randrange(u.MIN_DM_SIZE, attr_ex.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
with d.DM(ctx, dm_attrs) as dm:
dm_mr_len = random.randint(1, dm_len)
dm_mr_offset = random.randint(0, (dm_len - dm_mr_len))
DMMR(pd, dm_mr_len, e.IBV_ACCESS_ZERO_BASED, dm=dm,
offset=dm_mr_offset)
def test_dm_write(self):
"""
Test writing to the device memory
"""
lst = d.get_device_list()
for dev in lst:
with d.Context(name=dev.name.decode()) as ctx:
attr = ctx.query_device_ex()
if attr.max_dm_size == 0:
return
dm_len = random.randrange(u.MIN_DM_SIZE, attr.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
with d.DM(ctx, dm_attrs) as dm:
data_length = random.randrange(4, dm_len, u.DM_ALIGNMENT)
data_offset = random.randrange(0, dm_len - data_length,
u.DM_ALIGNMENT)
data = u.get_data(data_length)
dm.copy_to_dm(data_offset, data.encode(), data_length)
def test_create_dm_mr(self):
"""
Test ibv_reg_dm_mr
"""
lst = d.get_device_list()
for dev in lst:
with d.Context(name=dev.name.decode()) as ctx:
attr = ctx.query_device_ex()
if attr.max_dm_size == 0:
return
with PD(ctx) as pd:
dm_len = random.randrange(u.MIN_DM_SIZE, attr.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
with d.DM(ctx, dm_attrs) as dm:
dm_mr_len = random.randint(1, dm_len)
dm_mr_offset = random.randint(0, (dm_len - dm_mr_len))
dm_mr = DMMR(pd,
dm_mr_len,
e.IBV_ACCESS_ZERO_BASED,
dm=dm,
offset=dm_mr_offset)
def test_dm_write_bad_flow(self):
"""
Test writing to the device memory with bad offset and length
"""
for ctx, attr, attr_ex in self.devices:
if attr_ex.max_dm_size == 0:
return
dm_len = random.randrange(u.MIN_DM_SIZE, attr_ex.max_dm_size,
u.DM_ALIGNMENT)
dm_attrs = u.get_dm_attrs(dm_len)
with d.DM(ctx, dm_attrs) as dm:
data_length = random.randrange(4, dm_len, u.DM_ALIGNMENT)
data_offset = random.randrange(0, dm_len - data_length,
u.DM_ALIGNMENT)
data_offset += 1 # offset needs to be a multiple of 4
data = 'a' * data_length
try:
dm.copy_to_dm(data_offset, data.encode(), data_length)
except PyverbsRDMAError as e:
assert 'Failed to copy to dm' in e.args[0]
else:
raise PyverbsError(
'Wrote to device memory with a bad offset')
