def Read(self):
if (GlobalOptions.dryrun):
data = bytes(self.size)
self.data = RdmaDcqcnProfile(data)
return
self.data = RdmaDcqcnProfile(model_wrap.read_mem(self.addr, self.size))
logger.info("Read RdmaDcqcnProfile @ 0x%x size: %d: " % (self.addr, self.size))
logger.ShowScapyObject(self.data)
def ReadAtomicResData(self):
if (GlobalOptions.dryrun):
atomic_res_data = bytes(64)
self.atomic_res_data = RdmaAtomicResState(atomic_res_data)
return
self.atomic_res_data = RdmaAtomicResState(
model_wrap.read_mem(self.rdma_atomic_res_addr, 64))
logger.ShowScapyObject(self.atomic_res_data)
return
def Read(self):
if (GlobalOptions.dryrun):
data = bytes(self.size)
self.data = RdmaKeyTableEntry(data)
return
self.data = RdmaKeyTableEntry(model_wrap.read_mem(
self.addr, self.size))
logger.info("Read KeyTableEntry @ 0x%x size: %d: " %
(self.addr, self.size))
logger.ShowScapyObject(self.data)
def ReadDcqcnCb(self):
if (GlobalOptions.dryrun):
return
self.dcqcn_data = RdmaDCQCNstate(
model_wrap.read_mem(self.header_temp_addr + AH_ENTRY_T_SIZE_BYTES,
DCQCN_CB_T_SIZE_BYTES))
logger.ShowScapyObject(self.dcqcn_data)
logger.info("Read DCQCN Qstate @0x%x size: %d" %
(self.header_temp_addr + AH_ENTRY_T_SIZE_BYTES,
DCQCN_CB_T_SIZE_BYTES))
return
def Read(self):
"""
Reads a Descriptor from "self.address"
:return:
"""
self.phy_address = resmgr.HostMemoryAllocator.v2p(self.address)
mem_handle = objects.MemHandle(self.address, self.phy_address)
desc = NvmeCqDescriptor(resmgr.HostMemoryAllocator.read(
mem_handle, 64))
logger.ShowScapyObject(desc)
def ReadRomeSenderCb(self):
if (GlobalOptions.dryrun):
return
self.rome_sender_data = RdmaROME_SENDERstate(
model_wrap.read_mem(self.header_temp_addr + AH_ENTRY_T_SIZE_BYTES,
ROME_CB_T_SIZE_BYTES))
logger.ShowScapyObject(self.rome_sender_data)
logger.info("Read ROME_SENDER Qstate @0x%x size: %d" %
(self.header_temp_addr + AH_ENTRY_T_SIZE_BYTES,
ROME_CB_T_SIZE_BYTES))
return
def HwxtstxcbRead(self, debug=True):
cb_size = len(NvmeHwXtsTxcb())
if (GlobalOptions.dryrun):
return NvmeHwXtsTxcb(bytes(cb_size))
if debug is True:
logger.info("Read Hwxtstxcb @0x%x size: %d" %
(self.tx_hwxtscb_addr, cb_size))
cb = NvmeHwXtsTxcb(model_wrap.read_mem(self.tx_hwxtscb_addr, cb_size))
logger.ShowScapyObject(cb)
return cb
def NscbRead(self, debug=True):
nscb_size = len(NvmeNscb())
if (GlobalOptions.dryrun):
return NvmeNscb(bytes(nscb_size))
if debug is True:
logger.info("Read Nscb @0x%x size: %d" %
(self.nscb_addr, nscb_size))
nscb = NvmeNscb(model_wrap.read_mem(self.nscb_addr, nscb_size))
logger.ShowScapyObject(nscb)
return nscb
def Read(self, debug=True):
if (GlobalOptions.dryrun):
data = bytes(self.size)
self.data = qt_params[self.queue_type]['state'](data)
return
self.data = qt_params[self.queue_type]['state'](model_wrap.read_mem(
self.addr, self.size))
if debug is True:
logger.info("Read Qstate @0x%x Type: %s size: %d" %
(self.addr, self.queue_type, self.size))
logger.ShowScapyObject(self.data)
return copy.deepcopy(self.data)
def ProcessHALResponse(self, req_spec, resp_spec):
self.eq.SetRingParams('EQ', 0, True, False, self.eq_slab.mem_handle,
self.eq_slab.address, self.num_eq_wqes,
self.eqwqe_size)
logger.info("EQ: %s LIF: %d eqcb_addr: 0x%x eqe_base_addr: 0x%x" \
" eqe_base_addr_phy: 0x%x" %\
(self.GID(), self.lif.hw_lif_id,
self.eq.GetQstateAddr(), self.eqe_base_addr, self.eqe_base_addr_phy))
self.intr_tbl_addr = resp_spec.eq_intr_tbl_addr
logger.info("EQ: intr_tbl_addr from HAL: 0x%x" % self.intr_tbl_addr)
logger.info("HAL Response successful for EQ creation")
logger.ShowScapyObject(self.eq.qstate.data)
def NvmesessprodrxcbRead(self, debug=True):
cb_size = len(Nvmesessprodrxcb())
if (GlobalOptions.dryrun):
return Nvmesessprodrxcb(bytes(cb_size))
if debug is True:
logger.info("Read sessprodrxcb @0x%x size: %d" %
(self.rxsessprodcb_addr, cb_size))
cb = Nvmesessprodrxcb(
model_wrap.read_mem(self.rxsessprodcb_addr, cb_size))
logger.ShowScapyObject(cb)
return cb
def PrepareHALRequestSpec(self, req_spec):
req_spec.lif_handle = 0 # HW LIF ID is not known in DOL. Assume it is filled in by hal::LifCreate.
req_spec.type_num = self.queue_type.type
req_spec.qid = self.id
qt_params_entry = qt_params[self.queue_type.GID()]
qstate = qt_params_entry["state"]()
qstate.host = qt_params_entry["hrings"]
qstate.total = qt_params_entry["trings"]
logger.ShowScapyObject(qstate)
req_spec.queue_state = bytes(qstate)
if qt_params_entry["has_label"]:
req_spec.label.handle = "p4plus"
req_spec.label.prog_name = qt_params_entry["prog"]
req_spec.label.label = qt_params_entry["label"]
def CmdIdRead(self, index, debug=True):
entry_size = len(NvmeCmdContextRingEntry())
if (GlobalOptions.dryrun):
return NvmeCmdContextRingEntry(bytes(entry_size))
addr = self.cmd_context_ring_base + (index * entry_size)
if debug is True:
logger.info("Read CmdContextRingEntry @0x%x index: %d size: %d" %
(addr, index, entry_size))
entry = NvmeCmdContextRingEntry(model_wrap.read_mem(addr, entry_size))
logger.ShowScapyObject(entry)
return entry.cid
def ReadRomeReceiverCb(self):
if (GlobalOptions.dryrun):
rome_receiver_data = bytes(ROME_CB_T_SIZE_BYTES)
self.rome_receiver_data = RdmaROME_RECEIVERstate(
rome_receiver_data)
return
self.rome_receiver_data = RdmaROME_RECEIVERstate(
model_wrap.read_mem(
self.header_temp_addr + AH_ENTRY_T_SIZE_BYTES +
DCQCN_CB_T_SIZE_BYTES, ROME_CB_T_SIZE_BYTES))
logger.ShowScapyObject(self.rome_receiver_data)
logger.info("Read ROME_RECEIVER Qstate @0x%x size: %d" %
(self.header_temp_addr + AH_ENTRY_T_SIZE_BYTES +
DCQCN_CB_T_SIZE_BYTES, ROME_CB_T_SIZE_BYTES))
return
def Read(self):
"""
Reads a Descriptor from "self.address"
:return:
"""
if self.mem_handle:
self.phy_address = resmgr.HostMemoryAllocator.v2p(self.address)
mem_handle = objects.MemHandle(self.address, self.phy_address)
desc = NvmeTcprqDescriptor(
resmgr.HostMemoryAllocator.read(mem_handle, 64))
else:
hbm_addr = self.address
desc = NvmeTcprqDescriptor(model_wrap.read_mem(hbm_addr, 64))
logger.ShowScapyObject(desc)
def Write(self):
"""
Creates a Descriptor at "self.address"
:return:
"""
desc = NvmeCqDescriptor(sqhd=self.spec.fields.sqhd,
sqid=self.spec.fields.sqid,
p=self.spec.fields.p,
sc=self.spec.fields.sc,
sct=self.spec.fields.sct)
self.desc = desc
logger.ShowScapyObject(desc)
logger.info("desc_size = %d" % (len(desc)))
resmgr.HostMemoryAllocator.write(self.mem_handle, bytes(desc))
def Write(self):
"""
Creates a Descriptor at "self.address"
:return:
"""
desc = NvmeTcprqDescriptor()
self.desc = desc
logger.ShowScapyObject(desc)
logger.info("desc_size = %d" % (len(desc)))
if self.mem_handle:
resmgr.HostMemoryAllocator.write(self.mem_handle, bytes(desc))
else:
model_wrap.write_mem_pcie(self.address, bytes(desc), len(desc))
#TBD: Do we need it ?
self.Read()
def Init(self, spec):
#self.LockAttributes()
super().Init(spec)
if (GlobalOptions.dryrun): return
self.buffer_type = spec.buffer_type if hasattr(spec,
'buffer_type') else 0
if self.buffer_type == 1:
sq_buffer = RdmaQuerySqBuffer(
rnr_timer=spec.fields.rnr_timer,
retry_timeout=spec.fields.retry_timeout,
access_perms_flags=0,
access_perms_rsvd=0,
qkey_dest_qpn=spec.fields.qkey_dest_qpn,
rate_limit_kbps=0,
pkey_id=0,
rq_psn=spec.fields.rq_psn)
rq_buffer = RdmaQueryRqBuffer(state=spec.fields.state,
pmtu=spec.fields.pmtu,
retry_cnt=spec.fields.retry_cnt,
rnr_retry=spec.fields.rnr_retry,
rrq_depth=spec.fields.rrq_depth,
rsq_depth=spec.fields.rsq_depth,
sq_psn=spec.fields.sq_psn,
ah_id_len=spec.fields.ah_id_len)
hdr_buffer = spec.fields.hdr_data
buffer = sq_buffer / rq_buffer / hdr_buffer
self.data = bytes(buffer)
self.size = len(buffer)
logger.info("Creating Rdma Query Buffer size: %d " % (self.size))
logger.ShowScapyObject(sq_buffer)
logger.ShowScapyObject(rq_buffer)
logger.ShowScapyObject(hdr_buffer)
elif self.buffer_type == 2:
hdr_buffer = spec.fields.hdr_data
self.data = bytes(hdr_buffer)
self.size = len(hdr_buffer)
logger.info("Creating Rdma Query AH Buffer size: %d " %
(self.size))
logger.ShowScapyObject(hdr_buffer)
else:
if hasattr(spec.fields, 'segments'):
for segment in spec.fields.segments:
skip_bytes = segment.skip if hasattr(segment,
'skip') else 0
offset = segment.offset if hasattr(segment,
'offset') else 0
self.size += (segment.size - skip_bytes) if hasattr(
segment, 'size') else 0
self.data += segment.data[offset:len(segment.data) -
skip_bytes] if (
hasattr(segment, 'data')
and segment.data) else []
#handle segment.offset
#self.size = spec.fields.size if hasattr(spec.fields, 'size') else 0
#self.data = spec.fields.data if hasattr(spec.fields, 'data') else []
# Offset of the data
self.slab_id = spec.fields.slab
self.offset = spec.fields.offset if hasattr(spec.fields,
'offset') else 0
self.address = spec.fields.slab.address if spec.fields.slab else 0
self.address += self.offset
if self.address:
self.mem_handle = objects.MemHandle(
self.address, resmgr.HostMemoryAllocator.v2p(self.address))
self.phy_address = resmgr.HostMemoryAllocator.v2p(self.address)
logger.info(
"Creating Rdma Buffer @0x%x = phy_address: 0x%x size: %d offset: %d "
% (self.address, self.phy_address, self.size, self.offset))
def ShowScapyPacket(rawbytes):
spktobj = Parse(rawbytes)
spkt = spktobj.spkt
logger.info("------------------- SCAPY PACKET ---------------------")
logger.ShowScapyObject(spkt, build=False)
return
def Write(self):
"""
Creates a Descriptor at "self.address"
:return:
"""
opc = self.spec.fields.opc
if opc in (NVME_OPC_FLUSH, NVME_OPC_WRITE, NVME_OPC_READ,
NVME_OPC_WRITE_UNC, NVME_OPC_WRITE_ZEROES):
#requires data to be specified
if hasattr(self.spec.fields, 'data'):
data_buffer = self.spec.fields.data
else:
logger.error(
"Error!! nvme buffer needs to be specified for the descriptor"
)
return
self.prp1 = data_buffer.phy_pages[0]
num_pages = data_buffer.num_pages
if num_pages == 2:
self.prp2 = data_buffer.phy_pages[1]
#prepare PRP list page
elif num_pages > 2:
if hasattr(self.spec.fields, "prp2_offset"):
prp2_offset = self.spec.fields.prp2_offset
assert prp2_offset < data_buffer.page_size - 8
else:
prp2_offset = 0
prp2_entries = (data_buffer.page_size - prp2_offset) / 8
prp2_begin = 1
prp2_end = (int)(min(prp2_entries, num_pages - 1))
logger.info(
"PRP2 begin: %d, PRP2 end: %d, PRP2 offset: %d, prp2_entries: %d"
% (prp2_begin, prp2_end, prp2_offset, prp2_entries))
prp3_required = 0
#prp3 required
if prp2_end < num_pages - 1:
prp3_required = 1
prp2_end -= 1
prp3_begin = (int)(prp2_end + 1)
prp3_entries = num_pages - prp2_end - 1
prp3_end = (int)(num_pages - 1)
assert prp3_end > prp3_begin
prp3_offset = 0
logger.info(
"PRP3 begin: %d, PRP3 end: %d, PRP3 offset: %d, prp3_entries: %d"
% (prp3_begin, prp3_end, prp3_offset, prp3_entries))
prp3_slab = self.nvme_session.lif.GetNextSlab()
logger.info(
"Slab with address 0x%x allocated for PRP3 list" %
(prp3_slab.address))
self.prp3 = resmgr.HostMemoryAllocator.v2p(
prp3_slab.address)
data = []
for i in range(prp3_begin, prp3_end + 1):
data += data_buffer.phy_pages[i].to_bytes(8, 'little')
print("%s" % (data))
mem_handle = objects.MemHandle(
prp3_slab.address + prp3_offset,
resmgr.HostMemoryAllocator.v2p(prp3_slab.address +
prp3_offset))
resmgr.HostMemoryAllocator.write(mem_handle, bytes(data))
prp2_slab = self.nvme_session.lif.GetNextSlab()
logger.info("Slab with address 0x%x allocated for PRP2 list" %
(prp2_slab.address))
self.prp2 = resmgr.HostMemoryAllocator.v2p(prp2_slab.address +
prp2_offset)
data = []
for i in range(prp2_begin, prp2_end + 1):
data += data_buffer.phy_pages[i].to_bytes(8, 'little')
print("%s" % (data))
if prp3_required:
data += resmgr.HostMemoryAllocator.v2p(
prp3_slab.address).to_bytes(8, "little")
print("%s" % (data))
mem_handle = objects.MemHandle(
prp2_slab.address + prp2_offset,
resmgr.HostMemoryAllocator.v2p(prp2_slab.address +
prp2_offset))
resmgr.HostMemoryAllocator.write(mem_handle, bytes(data))
desc = NvmeSqDescriptorBase(opc=self.spec.fields.opc,
cid=self.spec.fields.cid,
nsid=self.spec.fields.nsid,
prp1=self.prp1,
prp2=self.prp2)
logger.ShowScapyObject(desc)
self.desc = desc
if hasattr(self.spec.fields, 'write'):
slba = self.spec.fields.write.slba if hasattr(
self.spec.fields.write, 'slba') else 0
nlb = self.spec.fields.write.nlb if hasattr(
self.spec.fields.write, 'nlb') else 0
write = NvmeSqDescriptorWrite(slba=slba, nlb=nlb)
self.desc = self.desc / write
logger.ShowScapyObject(write)
logger.info("desc_size = %d" % (len(self.desc)))
resmgr.HostMemoryAllocator.write(self.mem_handle, bytes(self.desc))
