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))