/* * Return a pointer to a correctly filled memzone descriptor. If the * allocation cannot be done, return NULL. */ const struct rte_memzone * rte_memzone_reserve(const char *name, size_t len, int socket_id, unsigned flags) { return rte_memzone_reserve_aligned(name, len, socket_id, flags, RTE_CACHE_LINE_SIZE); }
static int rte_event_eth_rx_adapter_init(void) { const char *name = "rte_event_eth_rx_adapter_array"; const struct rte_memzone *mz; unsigned int sz; sz = sizeof(*event_eth_rx_adapter) * RTE_EVENT_ETH_RX_ADAPTER_MAX_INSTANCE; sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE); mz = rte_memzone_lookup(name); if (mz == NULL) { mz = rte_memzone_reserve_aligned(name, sz, rte_socket_id(), 0, RTE_CACHE_LINE_SIZE); if (mz == NULL) { RTE_EDEV_LOG_ERR("failed to reserve memzone err = %" PRId32, rte_errno); return -rte_errno; } } event_eth_rx_adapter = mz->addr; return 0; }
static const struct rte_memzone * queue_dma_zone_reserve(const char *queue_name, uint32_t queue_size, int socket_id) { const struct rte_memzone *mz; unsigned memzone_flags = 0; const struct rte_memseg *ms; PMD_INIT_FUNC_TRACE(); mz = rte_memzone_lookup(queue_name); if (mz != 0) { if (((size_t)queue_size <= mz->len) && ((socket_id == SOCKET_ID_ANY) || (socket_id == mz->socket_id))) { PMD_DRV_LOG(DEBUG, "re-use memzone already " "allocated for %s", queue_name); return mz; } PMD_DRV_LOG(ERR, "Incompatible memzone already " "allocated %s, size %u, socket %d. " "Requested size %u, socket %u", queue_name, (uint32_t)mz->len, mz->socket_id, queue_size, socket_id); return NULL; } PMD_DRV_LOG(DEBUG, "Allocate memzone for %s, size %u on socket %u", queue_name, queue_size, socket_id); ms = rte_eal_get_physmem_layout(); switch (ms[0].hugepage_sz) { case(RTE_PGSIZE_2M): memzone_flags = RTE_MEMZONE_2MB; break; case(RTE_PGSIZE_1G): memzone_flags = RTE_MEMZONE_1GB; break; case(RTE_PGSIZE_16M): memzone_flags = RTE_MEMZONE_16MB; break; case(RTE_PGSIZE_16G): memzone_flags = RTE_MEMZONE_16GB; break; default: memzone_flags = RTE_MEMZONE_SIZE_HINT_ONLY; } #ifdef RTE_LIBRTE_XEN_DOM0 return rte_memzone_reserve_bounded(queue_name, queue_size, socket_id, 0, RTE_CACHE_LINE_SIZE, RTE_PGSIZE_2M); #else return rte_memzone_reserve_aligned(queue_name, queue_size, socket_id, memzone_flags, queue_size); #endif }
void * alloc_hugepages(size_t size) { struct rte_memzone *memzone = rte_memzone_reserve_aligned( "hugepages", size, SOCKET_ID_ANY, RTE_MEMZONE_SIZE_HINT_ONLY, 64); assert(memzone); return memzone->addr; /* return rte_malloc(NULL, size, 64); */ }
static const struct rte_memzone * ring_dma_zone_reserve(struct rte_eth_dev *dev, const char *ring_name, uint16_t queue_id, uint32_t ring_size, int socket_id) { char z_name[RTE_MEMZONE_NAMESIZE]; const struct rte_memzone *mz; snprintf(z_name, sizeof(z_name), "%s_%s_%d_%d", dev->driver->pci_drv.name, ring_name, dev->data->port_id, queue_id); mz = rte_memzone_lookup(z_name); if (mz) return mz; return rte_memzone_reserve_aligned(z_name, ring_size, socket_id, 0, BNX2X_PAGE_SIZE); }
static const struct rte_memzone * gpa_zone_reserve(struct rte_eth_dev *dev, uint32_t size, const char *post_string, int socket_id, uint16_t align) { char z_name[RTE_MEMZONE_NAMESIZE]; const struct rte_memzone *mz; rte_snprintf(z_name, sizeof(z_name), "%s_%d_%s", dev->driver->pci_drv.name, dev->data->port_id, post_string); mz = rte_memzone_lookup(z_name); if (mz) return mz; return rte_memzone_reserve_aligned(z_name, size, socket_id, 0, align); }
static int test_memzone_invalid_alignment(void) { const struct rte_memzone * mz; mz = rte_memzone_lookup("invalid_alignment"); if (mz != NULL) { printf("Zone with invalid alignment has been reserved\n"); return -1; } mz = rte_memzone_reserve_aligned("invalid_alignment", 100, SOCKET_ID_ANY, 0, 100); if (mz != NULL) { printf("Zone with invalid alignment has been reserved\n"); return -1; } return 0; }
static void * enic_alloc_consistent(__rte_unused void *priv, size_t size, dma_addr_t *dma_handle, u8 *name) { void *vaddr; const struct rte_memzone *rz; *dma_handle = 0; rz = rte_memzone_reserve_aligned((const char *)name, size, 0, 0, ENIC_ALIGN); if (!rz) { pr_err("%s : Failed to allocate memory requested for %s", __func__, name); return NULL; } vaddr = rz->addr; *dma_handle = (dma_addr_t)rz->phys_addr; return vaddr; }
int otx_cpt_get_resource(void *dev, uint8_t group, struct cpt_instance **instance) { int ret = -ENOENT, len, qlen, i; int chunk_len, chunks, chunk_size; struct cpt_vf *cptvf = (struct cpt_vf *)dev; struct cpt_instance *cpt_instance; struct command_chunk *chunk_head = NULL, *chunk_prev = NULL; struct command_chunk *chunk = NULL; uint8_t *mem; const struct rte_memzone *rz; uint64_t dma_addr = 0, alloc_len, used_len; uint64_t *next_ptr; uint64_t pg_sz = sysconf(_SC_PAGESIZE); CPT_LOG_DP_DEBUG("Initializing cpt resource %s", cptvf->dev_name); cpt_instance = &cptvf->instance; memset(&cptvf->cqueue, 0, sizeof(cptvf->cqueue)); memset(&cptvf->pqueue, 0, sizeof(cptvf->pqueue)); /* Chunks are of fixed size buffers */ chunks = DEFAULT_CMD_QCHUNKS; chunk_len = DEFAULT_CMD_QCHUNK_SIZE; qlen = chunks * chunk_len; /* Chunk size includes 8 bytes of next chunk ptr */ chunk_size = chunk_len * CPT_INST_SIZE + CPT_NEXT_CHUNK_PTR_SIZE; /* For command chunk structures */ len = chunks * RTE_ALIGN(sizeof(struct command_chunk), 8); /* For pending queue */ len += qlen * RTE_ALIGN(sizeof(struct rid), 8); /* So that instruction queues start as pg size aligned */ len = RTE_ALIGN(len, pg_sz); /* For Instruction queues */ len += chunks * RTE_ALIGN(chunk_size, 128); /* Wastage after instruction queues */ len = RTE_ALIGN(len, pg_sz); rz = rte_memzone_reserve_aligned(cptvf->dev_name, len, cptvf->node, RTE_MEMZONE_SIZE_HINT_ONLY | RTE_MEMZONE_256MB, RTE_CACHE_LINE_SIZE); if (!rz) { ret = rte_errno; goto cleanup; } mem = rz->addr; dma_addr = rz->phys_addr; alloc_len = len; memset(mem, 0, len); cpt_instance->rsvd = (uintptr_t)rz; /* Pending queue setup */ cptvf->pqueue.rid_queue = (struct rid *)mem; cptvf->pqueue.enq_tail = 0; cptvf->pqueue.deq_head = 0; cptvf->pqueue.pending_count = 0; mem += qlen * RTE_ALIGN(sizeof(struct rid), 8); len -= qlen * RTE_ALIGN(sizeof(struct rid), 8); dma_addr += qlen * RTE_ALIGN(sizeof(struct rid), 8); /* Alignment wastage */ used_len = alloc_len - len; mem += RTE_ALIGN(used_len, pg_sz) - used_len; len -= RTE_ALIGN(used_len, pg_sz) - used_len; dma_addr += RTE_ALIGN(used_len, pg_sz) - used_len; /* Init instruction queues */ chunk_head = &cptvf->cqueue.chead[0]; i = qlen; chunk_prev = NULL; for (i = 0; i < DEFAULT_CMD_QCHUNKS; i++) { int csize; chunk = &cptvf->cqueue.chead[i]; chunk->head = mem; chunk->dma_addr = dma_addr; csize = RTE_ALIGN(chunk_size, 128); mem += csize; dma_addr += csize; len -= csize; if (chunk_prev) { next_ptr = (uint64_t *)(chunk_prev->head + chunk_size - 8); *next_ptr = (uint64_t)chunk->dma_addr; } chunk_prev = chunk; } /* Circular loop */ next_ptr = (uint64_t *)(chunk_prev->head + chunk_size - 8); *next_ptr = (uint64_t)chunk_head->dma_addr; assert(!len); /* This is used for CPT(0)_PF_Q(0..15)_CTL.size config */ cptvf->qsize = chunk_size / 8; cptvf->cqueue.qhead = chunk_head->head; cptvf->cqueue.idx = 0; cptvf->cqueue.cchunk = 0; if (cpt_vq_init(cptvf, group)) { CPT_LOG_ERR("Failed to initialize CPT VQ of device %s", cptvf->dev_name); ret = -EBUSY; goto cleanup; } *instance = cpt_instance; CPT_LOG_DP_DEBUG("Crypto device (%s) initialized", cptvf->dev_name); return 0; cleanup: rte_memzone_free(rz); *instance = NULL; return ret; }
void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring) { memset(ring->descs, 0, ring->size); } int vnic_dev_alloc_desc_ring(__attribute__((unused)) struct vnic_dev *vdev, struct vnic_dev_ring *ring, unsigned int desc_count, unsigned int desc_size, unsigned int socket_id, char *z_name) { const struct rte_memzone *rz; vnic_dev_desc_ring_size(ring, desc_count, desc_size); rz = rte_memzone_reserve_aligned(z_name, ring->size_unaligned, socket_id, 0, ENIC_ALIGN); if (!rz) { pr_err("Failed to allocate ring (size=%d), aborting\n", (int)ring->size); return -ENOMEM; } ring->descs_unaligned = rz->addr; if (!ring->descs_unaligned) { pr_err("Failed to map allocated ring (size=%d), aborting\n", (int)ring->size); return -ENOMEM; } ring->base_addr_unaligned = (dma_addr_t)rz->phys_addr;
static int test_memzone_reserve_remainder(void) { const struct rte_memzone *mz1, *mz2; const struct rte_memseg *ms, *min_ms = NULL; size_t min_len; const struct rte_config *config; int i, align; min_len = 0; align = RTE_CACHE_LINE_SIZE; config = rte_eal_get_configuration(); /* find minimum free contiguous length */ for (i = 0; i < RTE_MAX_MEMSEG; i++) { ms = &config->mem_config->free_memseg[i]; if (ms->addr == NULL) break; if (ms->len == 0) continue; if (min_len == 0 || ms->len < min_len) { min_len = ms->len; min_ms = ms; /* find maximum alignment this segment is able to hold */ align = RTE_CACHE_LINE_SIZE; while ((ms->addr_64 & (align-1)) == 0) { align <<= 1; } } } if (min_ms == NULL) { printf("Minimal sized segment not found!\n"); return -1; } /* try reserving min_len bytes with alignment - this should not affect our * memseg, the memory will be taken from a different one. */ mz1 = rte_memzone_reserve_aligned("reserve_remainder_1", min_len, SOCKET_ID_ANY, 0, align); if (mz1 == NULL) { printf("Failed to reserve %zu bytes aligned on %i bytes\n", min_len, align); return -1; } if (min_ms->len != min_len) { printf("Memseg memory should not have been reserved!\n"); return -1; } /* try reserving min_len bytes with less alignment - this should fill up * the segment. */ mz2 = rte_memzone_reserve("reserve_remainder_2", min_len, SOCKET_ID_ANY, 0); if (mz2 == NULL) { printf("Failed to reserve %zu bytes\n", min_len); return -1; } if (min_ms->len != 0) { printf("Memseg memory should have been reserved!\n"); return -1; } return 0; }
/* this test is a bit tricky, and thus warrants explanation. * * first, we find two smallest memsegs to conduct our experiments on. * * then, we bring them within alignment from each other: if second segment is * twice+ as big as the first, reserve memory from that segment; if second * segment is comparable in length to the first, then cut the first segment * down until it becomes less than half of second segment, and then cut down * the second segment to be within alignment of the first. * * then, we have to pass the following test: if segments are within alignment * of each other (that is, the difference is less than 256 bytes, which is what * our alignment will be), segment with smallest offset should be picked. * * we know that min_ms will be our smallest segment, so we need to make sure * that we adjust the alignments so that the bigger segment has smallest * alignment (in our case, smallest segment will have 64-byte alignment, while * bigger segment will have 128-byte alignment). */ static int test_memzone_reserve_memory_with_smallest_offset(void) { const struct rte_memseg *ms, *min_ms, *prev_min_ms; size_t len, min_len, prev_min_len; const struct rte_config *config; int i, align; config = rte_eal_get_configuration(); min_ms = NULL; /*< smallest segment */ prev_min_ms = NULL; /*< second smallest segment */ align = RTE_CACHE_LINE_SIZE * 4; /* find two smallest segments */ for (i = 0; i < RTE_MAX_MEMSEG; i++) { ms = &config->mem_config->free_memseg[i]; if (ms->addr == NULL) break; if (ms->len == 0) continue; if (min_ms == NULL) min_ms = ms; else if (min_ms->len > ms->len) { /* set last smallest to second last */ prev_min_ms = min_ms; /* set new smallest */ min_ms = ms; } else if ((prev_min_ms == NULL) || (prev_min_ms->len > ms->len)) { prev_min_ms = ms; } } if (min_ms == NULL || prev_min_ms == NULL) { printf("Smallest segments not found!\n"); return -1; } prev_min_len = prev_min_ms->len; min_len = min_ms->len; /* if smallest segment is bigger than half of bigger segment */ if (prev_min_ms->len - min_ms->len <= min_ms->len) { len = (min_ms->len * 2) - prev_min_ms->len; /* make sure final length is *not* aligned */ while (((min_ms->addr_64 + len) & (align-1)) == 0) len += RTE_CACHE_LINE_SIZE; if (rte_memzone_reserve("dummy_mz1", len, SOCKET_ID_ANY, 0) == NULL) { printf("Cannot reserve memory!\n"); return -1; } /* check if we got memory from correct segment */ if (min_ms->len != min_len - len) { printf("Reserved memory from wrong segment!\n"); return -1; } } /* if we don't need to touch smallest segment but it's aligned */ else if ((min_ms->addr_64 & (align-1)) == 0) { if (rte_memzone_reserve("align_mz1", RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY, 0) == NULL) { printf("Cannot reserve memory!\n"); return -1; } if (min_ms->len != min_len - RTE_CACHE_LINE_SIZE) { printf("Reserved memory from wrong segment!\n"); return -1; } } /* if smallest segment is less than half of bigger segment */ if (prev_min_ms->len - min_ms->len > min_ms->len) { len = prev_min_ms->len - min_ms->len - align; /* make sure final length is aligned */ while (((prev_min_ms->addr_64 + len) & (align-1)) != 0) len += RTE_CACHE_LINE_SIZE; if (rte_memzone_reserve("dummy_mz2", len, SOCKET_ID_ANY, 0) == NULL) { printf("Cannot reserve memory!\n"); return -1; } /* check if we got memory from correct segment */ if (prev_min_ms->len != prev_min_len - len) { printf("Reserved memory from wrong segment!\n"); return -1; } } len = RTE_CACHE_LINE_SIZE; prev_min_len = prev_min_ms->len; min_len = min_ms->len; if (min_len >= prev_min_len || prev_min_len - min_len > (unsigned) align) { printf("Segments are of wrong lengths!\n"); return -1; } /* try reserving from a bigger segment */ if (rte_memzone_reserve_aligned("smallest_offset", len, SOCKET_ID_ANY, 0, align) == NULL) { printf("Cannot reserve memory!\n"); return -1; } /* check if we got memory from correct segment */ if (min_ms->len != min_len && prev_min_ms->len != (prev_min_len - len)) { printf("Reserved memory from segment with smaller offset!\n"); return -1; } return 0; }
static int test_memzone_aligned(void) { const struct rte_memzone *memzone_aligned_32; const struct rte_memzone *memzone_aligned_128; const struct rte_memzone *memzone_aligned_256; const struct rte_memzone *memzone_aligned_512; const struct rte_memzone *memzone_aligned_1024; /* memzone that should automatically be adjusted to align on 64 bytes */ memzone_aligned_32 = rte_memzone_reserve_aligned("aligned_32", 100, SOCKET_ID_ANY, 0, 32); /* memzone that is supposed to be aligned on a 128 byte boundary */ memzone_aligned_128 = rte_memzone_reserve_aligned("aligned_128", 100, SOCKET_ID_ANY, 0, 128); /* memzone that is supposed to be aligned on a 256 byte boundary */ memzone_aligned_256 = rte_memzone_reserve_aligned("aligned_256", 100, SOCKET_ID_ANY, 0, 256); /* memzone that is supposed to be aligned on a 512 byte boundary */ memzone_aligned_512 = rte_memzone_reserve_aligned("aligned_512", 100, SOCKET_ID_ANY, 0, 512); /* memzone that is supposed to be aligned on a 1024 byte boundary */ memzone_aligned_1024 = rte_memzone_reserve_aligned("aligned_1024", 100, SOCKET_ID_ANY, 0, 1024); printf("check alignments and lengths\n"); if (memzone_aligned_32 == NULL) { printf("Unable to reserve 64-byte aligned memzone!\n"); return -1; } if ((memzone_aligned_32->phys_addr & RTE_CACHE_LINE_MASK) != 0) return -1; if (((uintptr_t) memzone_aligned_32->addr & RTE_CACHE_LINE_MASK) != 0) return -1; if ((memzone_aligned_32->len & RTE_CACHE_LINE_MASK) != 0) return -1; if (memzone_aligned_128 == NULL) { printf("Unable to reserve 128-byte aligned memzone!\n"); return -1; } if ((memzone_aligned_128->phys_addr & 127) != 0) return -1; if (((uintptr_t) memzone_aligned_128->addr & 127) != 0) return -1; if ((memzone_aligned_128->len & RTE_CACHE_LINE_MASK) != 0) return -1; if (memzone_aligned_256 == NULL) { printf("Unable to reserve 256-byte aligned memzone!\n"); return -1; } if ((memzone_aligned_256->phys_addr & 255) != 0) return -1; if (((uintptr_t) memzone_aligned_256->addr & 255) != 0) return -1; if ((memzone_aligned_256->len & RTE_CACHE_LINE_MASK) != 0) return -1; if (memzone_aligned_512 == NULL) { printf("Unable to reserve 512-byte aligned memzone!\n"); return -1; } if ((memzone_aligned_512->phys_addr & 511) != 0) return -1; if (((uintptr_t) memzone_aligned_512->addr & 511) != 0) return -1; if ((memzone_aligned_512->len & RTE_CACHE_LINE_MASK) != 0) return -1; if (memzone_aligned_1024 == NULL) { printf("Unable to reserve 1024-byte aligned memzone!\n"); return -1; } if ((memzone_aligned_1024->phys_addr & 1023) != 0) return -1; if (((uintptr_t) memzone_aligned_1024->addr & 1023) != 0) return -1; if ((memzone_aligned_1024->len & RTE_CACHE_LINE_MASK) != 0) return -1; /* check that zones don't overlap */ printf("check overlapping\n"); if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len, memzone_aligned_128->phys_addr, memzone_aligned_128->len)) return -1; if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len, memzone_aligned_256->phys_addr, memzone_aligned_256->len)) return -1; if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len, memzone_aligned_512->phys_addr, memzone_aligned_512->len)) return -1; if (is_memory_overlap(memzone_aligned_32->phys_addr, memzone_aligned_32->len, memzone_aligned_1024->phys_addr, memzone_aligned_1024->len)) return -1; if (is_memory_overlap(memzone_aligned_128->phys_addr, memzone_aligned_128->len, memzone_aligned_256->phys_addr, memzone_aligned_256->len)) return -1; if (is_memory_overlap(memzone_aligned_128->phys_addr, memzone_aligned_128->len, memzone_aligned_512->phys_addr, memzone_aligned_512->len)) return -1; if (is_memory_overlap(memzone_aligned_128->phys_addr, memzone_aligned_128->len, memzone_aligned_1024->phys_addr, memzone_aligned_1024->len)) return -1; if (is_memory_overlap(memzone_aligned_256->phys_addr, memzone_aligned_256->len, memzone_aligned_512->phys_addr, memzone_aligned_512->len)) return -1; if (is_memory_overlap(memzone_aligned_256->phys_addr, memzone_aligned_256->len, memzone_aligned_1024->phys_addr, memzone_aligned_1024->len)) return -1; if (is_memory_overlap(memzone_aligned_512->phys_addr, memzone_aligned_512->len, memzone_aligned_1024->phys_addr, memzone_aligned_1024->len)) return -1; return 0; }
static int test_memzone_reserve_max_aligned(void) { const struct rte_memzone *mz; const struct rte_config *config; const struct rte_memseg *ms; int memseg_idx = 0; int memzone_idx = 0; uintptr_t addr_offset; size_t len = 0; void* last_addr; size_t maxlen = 0; /* random alignment */ rte_srand((unsigned)rte_rdtsc()); const unsigned align = 1 << ((rte_rand() % 8) + 5); /* from 128 up to 4k alignment */ /* get pointer to global configuration */ config = rte_eal_get_configuration(); ms = rte_eal_get_physmem_layout(); addr_offset = 0; for (memseg_idx = 0; memseg_idx < RTE_MAX_MEMSEG; memseg_idx++){ /* ignore smaller memsegs as they can only get smaller */ if (ms[memseg_idx].len < maxlen) continue; /* align everything */ last_addr = RTE_PTR_ALIGN_CEIL(ms[memseg_idx].addr, RTE_CACHE_LINE_SIZE); len = ms[memseg_idx].len - RTE_PTR_DIFF(last_addr, ms[memseg_idx].addr); len &= ~((size_t) RTE_CACHE_LINE_MASK); /* cycle through all memzones */ for (memzone_idx = 0; memzone_idx < RTE_MAX_MEMZONE; memzone_idx++) { /* stop when reaching last allocated memzone */ if (config->mem_config->memzone[memzone_idx].addr == NULL) break; /* check if the memzone is in our memseg and subtract length */ if ((config->mem_config->memzone[memzone_idx].addr >= ms[memseg_idx].addr) && (config->mem_config->memzone[memzone_idx].addr < (RTE_PTR_ADD(ms[memseg_idx].addr, ms[memseg_idx].len)))) { /* since the zones can now be aligned and occasionally skip * some space, we should calculate the length based on * reported length and start addresses difference. */ len -= (uintptr_t) RTE_PTR_SUB( config->mem_config->memzone[memzone_idx].addr, (uintptr_t) last_addr); len -= config->mem_config->memzone[memzone_idx].len; last_addr = RTE_PTR_ADD(config->mem_config->memzone[memzone_idx].addr, (size_t) config->mem_config->memzone[memzone_idx].len); } } /* make sure we get the alignment offset */ if (len > maxlen) { addr_offset = RTE_PTR_ALIGN_CEIL((uintptr_t) last_addr, align) - (uintptr_t) last_addr; maxlen = len; } } if (maxlen == 0 || maxlen == addr_offset) { printf("There is no space left for biggest %u-aligned memzone!\n", align); return 0; } maxlen -= addr_offset; mz = rte_memzone_reserve_aligned("max_zone_aligned", 0, SOCKET_ID_ANY, 0, align); if (mz == NULL){ printf("Failed to reserve a big chunk of memory\n"); rte_dump_physmem_layout(stdout); rte_memzone_dump(stdout); return -1; } if (mz->len != maxlen) { printf("Memzone reserve with 0 size and alignment %u did not return" " bigest block\n", align); printf("Expected size = %zu, actual size = %zu\n", maxlen, mz->len); rte_dump_physmem_layout(stdout); rte_memzone_dump(stdout); return -1; } return 0; }
/* * Allocates a completion ring with vmem and stats optionally also allocating * a TX and/or RX ring. Passing NULL as tx_ring_info and/or rx_ring_info * to not allocate them. * * Order in the allocation is: * stats - Always non-zero length * cp vmem - Always zero-length, supported for the bnxt_ring abstraction * tx vmem - Only non-zero length if tx_ring_info is not NULL * rx vmem - Only non-zero length if rx_ring_info is not NULL * cp bd ring - Always non-zero length * tx bd ring - Only non-zero length if tx_ring_info is not NULL * rx bd ring - Only non-zero length if rx_ring_info is not NULL */ int bnxt_alloc_rings(struct bnxt *bp, uint16_t qidx, struct bnxt_tx_ring_info *tx_ring_info, struct bnxt_rx_ring_info *rx_ring_info, struct bnxt_cp_ring_info *cp_ring_info, const char *suffix) { struct bnxt_ring *cp_ring = cp_ring_info->cp_ring_struct; struct bnxt_ring *tx_ring; struct bnxt_ring *rx_ring; struct rte_pci_device *pdev = bp->pdev; const struct rte_memzone *mz = NULL; char mz_name[RTE_MEMZONE_NAMESIZE]; rte_iova_t mz_phys_addr; int sz; int stats_len = (tx_ring_info || rx_ring_info) ? RTE_CACHE_LINE_ROUNDUP(sizeof(struct ctx_hw_stats64)) : 0; int cp_vmem_start = stats_len; int cp_vmem_len = RTE_CACHE_LINE_ROUNDUP(cp_ring->vmem_size); int tx_vmem_start = cp_vmem_start + cp_vmem_len; int tx_vmem_len = tx_ring_info ? RTE_CACHE_LINE_ROUNDUP(tx_ring_info-> tx_ring_struct->vmem_size) : 0; int rx_vmem_start = tx_vmem_start + tx_vmem_len; int rx_vmem_len = rx_ring_info ? RTE_CACHE_LINE_ROUNDUP(rx_ring_info-> rx_ring_struct->vmem_size) : 0; int ag_vmem_start = 0; int ag_vmem_len = 0; int cp_ring_start = 0; ag_vmem_start = rx_vmem_start + rx_vmem_len; ag_vmem_len = rx_ring_info ? RTE_CACHE_LINE_ROUNDUP( rx_ring_info->ag_ring_struct->vmem_size) : 0; cp_ring_start = ag_vmem_start + ag_vmem_len; int cp_ring_len = RTE_CACHE_LINE_ROUNDUP(cp_ring->ring_size * sizeof(struct cmpl_base)); int tx_ring_start = cp_ring_start + cp_ring_len; int tx_ring_len = tx_ring_info ? RTE_CACHE_LINE_ROUNDUP(tx_ring_info->tx_ring_struct->ring_size * sizeof(struct tx_bd_long)) : 0; int rx_ring_start = tx_ring_start + tx_ring_len; int rx_ring_len = rx_ring_info ? RTE_CACHE_LINE_ROUNDUP(rx_ring_info->rx_ring_struct->ring_size * sizeof(struct rx_prod_pkt_bd)) : 0; int ag_ring_start = rx_ring_start + rx_ring_len; int ag_ring_len = rx_ring_len * AGG_RING_SIZE_FACTOR; int ag_bitmap_start = ag_ring_start + ag_ring_len; int ag_bitmap_len = rx_ring_info ? RTE_CACHE_LINE_ROUNDUP(rte_bitmap_get_memory_footprint( rx_ring_info->rx_ring_struct->ring_size * AGG_RING_SIZE_FACTOR)) : 0; int tpa_info_start = ag_bitmap_start + ag_bitmap_len; int tpa_info_len = rx_ring_info ? RTE_CACHE_LINE_ROUNDUP(BNXT_TPA_MAX * sizeof(struct bnxt_tpa_info)) : 0; int total_alloc_len = tpa_info_start; if (bp->eth_dev->data->dev_conf.rxmode.enable_lro) total_alloc_len += tpa_info_len; snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "bnxt_%04x:%02x:%02x:%02x-%04x_%s", pdev->addr.domain, pdev->addr.bus, pdev->addr.devid, pdev->addr.function, qidx, suffix); mz_name[RTE_MEMZONE_NAMESIZE - 1] = 0; mz = rte_memzone_lookup(mz_name); if (!mz) { mz = rte_memzone_reserve_aligned(mz_name, total_alloc_len, SOCKET_ID_ANY, RTE_MEMZONE_2MB | RTE_MEMZONE_SIZE_HINT_ONLY, getpagesize()); if (mz == NULL) return -ENOMEM; } memset(mz->addr, 0, mz->len); mz_phys_addr = mz->iova; if ((unsigned long)mz->addr == mz_phys_addr) { RTE_LOG(WARNING, PMD, "Memzone physical address same as virtual.\n"); RTE_LOG(WARNING, PMD, "Using rte_mem_virt2iova()\n"); for (sz = 0; sz < total_alloc_len; sz += getpagesize()) rte_mem_lock_page(((char *)mz->addr) + sz); mz_phys_addr = rte_mem_virt2iova(mz->addr); if (mz_phys_addr == 0) { RTE_LOG(ERR, PMD, "unable to map ring address to physical memory\n"); return -ENOMEM; } } if (tx_ring_info) { tx_ring = tx_ring_info->tx_ring_struct; tx_ring->bd = ((char *)mz->addr + tx_ring_start); tx_ring_info->tx_desc_ring = (struct tx_bd_long *)tx_ring->bd; tx_ring->bd_dma = mz_phys_addr + tx_ring_start; tx_ring_info->tx_desc_mapping = tx_ring->bd_dma; tx_ring->mem_zone = (const void *)mz; if (!tx_ring->bd) return -ENOMEM; if (tx_ring->vmem_size) { tx_ring->vmem = (void **)((char *)mz->addr + tx_vmem_start); tx_ring_info->tx_buf_ring = (struct bnxt_sw_tx_bd *)tx_ring->vmem; } } if (rx_ring_info) { rx_ring = rx_ring_info->rx_ring_struct; rx_ring->bd = ((char *)mz->addr + rx_ring_start); rx_ring_info->rx_desc_ring = (struct rx_prod_pkt_bd *)rx_ring->bd; rx_ring->bd_dma = mz_phys_addr + rx_ring_start; rx_ring_info->rx_desc_mapping = rx_ring->bd_dma; rx_ring->mem_zone = (const void *)mz; if (!rx_ring->bd) return -ENOMEM; if (rx_ring->vmem_size) { rx_ring->vmem = (void **)((char *)mz->addr + rx_vmem_start); rx_ring_info->rx_buf_ring = (struct bnxt_sw_rx_bd *)rx_ring->vmem; } rx_ring = rx_ring_info->ag_ring_struct; rx_ring->bd = ((char *)mz->addr + ag_ring_start); rx_ring_info->ag_desc_ring = (struct rx_prod_pkt_bd *)rx_ring->bd; rx_ring->bd_dma = mz->iova + ag_ring_start; rx_ring_info->ag_desc_mapping = rx_ring->bd_dma; rx_ring->mem_zone = (const void *)mz; if (!rx_ring->bd) return -ENOMEM; if (rx_ring->vmem_size) { rx_ring->vmem = (void **)((char *)mz->addr + ag_vmem_start); rx_ring_info->ag_buf_ring = (struct bnxt_sw_rx_bd *)rx_ring->vmem; } rx_ring_info->ag_bitmap = rte_bitmap_init(rx_ring_info->rx_ring_struct->ring_size * AGG_RING_SIZE_FACTOR, (uint8_t *)mz->addr + ag_bitmap_start, ag_bitmap_len); /* TPA info */ if (bp->eth_dev->data->dev_conf.rxmode.enable_lro) rx_ring_info->tpa_info = ((struct bnxt_tpa_info *)((char *)mz->addr + tpa_info_start)); } cp_ring->bd = ((char *)mz->addr + cp_ring_start); cp_ring->bd_dma = mz_phys_addr + cp_ring_start; cp_ring_info->cp_desc_ring = cp_ring->bd; cp_ring_info->cp_desc_mapping = cp_ring->bd_dma; cp_ring->mem_zone = (const void *)mz; if (!cp_ring->bd) return -ENOMEM; if (cp_ring->vmem_size) *cp_ring->vmem = ((char *)mz->addr + stats_len); if (stats_len) { cp_ring_info->hw_stats = mz->addr; cp_ring_info->hw_stats_map = mz_phys_addr; } cp_ring_info->hw_stats_ctx_id = HWRM_NA_SIGNATURE; return 0; }