rte_memory.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation
 */

#ifndef _RTE_MEMORY_H_
#define _RTE_MEMORY_H_

#include <stdint.h>
#include <stddef.h>
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#include <rte_common.h>
#include <rte_compat.h>
#include <rte_config.h>

/* forward declaration for pointers */
struct rte_memseg_list;

__extension__
enum rte_page_sizes {
        RTE_PGSIZE_4K    = 1ULL << 12,
        RTE_PGSIZE_64K   = 1ULL << 16,
        RTE_PGSIZE_256K  = 1ULL << 18,
        RTE_PGSIZE_2M    = 1ULL << 21,
        RTE_PGSIZE_16M   = 1ULL << 24,
        RTE_PGSIZE_256M  = 1ULL << 28,
        RTE_PGSIZE_512M  = 1ULL << 29,
        RTE_PGSIZE_1G    = 1ULL << 30,
        RTE_PGSIZE_4G    = 1ULL << 32,
        RTE_PGSIZE_16G   = 1ULL << 34,
};

#define SOCKET_ID_ANY -1                    
#define RTE_CACHE_LINE_MASK (RTE_CACHE_LINE_SIZE-1) 
#define RTE_CACHE_LINE_ROUNDUP(size) \
        (RTE_CACHE_LINE_SIZE * ((size + RTE_CACHE_LINE_SIZE - 1) / RTE_CACHE_LINE_SIZE))

#if RTE_CACHE_LINE_SIZE == 64
#define RTE_CACHE_LINE_SIZE_LOG2 6
#elif RTE_CACHE_LINE_SIZE == 128
#define RTE_CACHE_LINE_SIZE_LOG2 7
#else
#error "Unsupported cache line size"
#endif

#define RTE_CACHE_LINE_MIN_SIZE 64      
#define __rte_cache_aligned __rte_aligned(RTE_CACHE_LINE_SIZE)

#define __rte_cache_min_aligned __rte_aligned(RTE_CACHE_LINE_MIN_SIZE)

typedef uint64_t phys_addr_t; 
#define RTE_BAD_PHYS_ADDR ((phys_addr_t)-1)

typedef uint64_t rte_iova_t;
#define RTE_BAD_IOVA ((rte_iova_t)-1)

#define RTE_MEMSEG_FLAG_DO_NOT_FREE (1 << 0)

struct rte_memseg {
        RTE_STD_C11
        union {
                phys_addr_t phys_addr;  
                rte_iova_t iova;        
        };
        RTE_STD_C11
        union {
                void *addr;         
                uint64_t addr_64;   
        };
        size_t len;               
        uint64_t hugepage_sz;       
        int32_t socket_id;          
        uint32_t nchannel;          
        uint32_t nrank;             
        uint32_t flags;             
} __rte_packed;

int rte_mem_lock_page(const void *virt);

phys_addr_t rte_mem_virt2phy(const void *virt);

rte_iova_t rte_mem_virt2iova(const void *virt);

__rte_experimental void *
rte_mem_iova2virt(rte_iova_t iova);

__rte_experimental struct rte_memseg *
rte_mem_virt2memseg(const void *virt, const struct rte_memseg_list *msl);

__rte_experimental struct rte_memseg_list *
rte_mem_virt2memseg_list(const void *virt);

typedef int (*rte_memseg_walk_t)(const struct rte_memseg_list *msl,
                const struct rte_memseg *ms, void *arg);

typedef int (*rte_memseg_contig_walk_t)(const struct rte_memseg_list *msl,
                const struct rte_memseg *ms, size_t len, void *arg);

typedef int (*rte_memseg_list_walk_t)(const struct rte_memseg_list *msl,
                void *arg);

int __rte_experimental
rte_memseg_walk(rte_memseg_walk_t func, void *arg);

int __rte_experimental
rte_memseg_contig_walk(rte_memseg_contig_walk_t func, void *arg);

int __rte_experimental
rte_memseg_list_walk(rte_memseg_list_walk_t func, void *arg);

int __rte_experimental
rte_memseg_walk_thread_unsafe(rte_memseg_walk_t func, void *arg);

int __rte_experimental
rte_memseg_contig_walk_thread_unsafe(rte_memseg_contig_walk_t func, void *arg);

int __rte_experimental
rte_memseg_list_walk_thread_unsafe(rte_memseg_list_walk_t func, void *arg);

int __rte_experimental
rte_memseg_get_fd(const struct rte_memseg *ms);

int __rte_experimental
rte_memseg_get_fd_thread_unsafe(const struct rte_memseg *ms);

int __rte_experimental
rte_memseg_get_fd_offset(const struct rte_memseg *ms, size_t *offset);

int __rte_experimental
rte_memseg_get_fd_offset_thread_unsafe(const struct rte_memseg *ms,
                size_t *offset);

int __rte_experimental
rte_extmem_register(void *va_addr, size_t len, rte_iova_t iova_addrs[],
                unsigned int n_pages, size_t page_sz);

int __rte_experimental
rte_extmem_unregister(void *va_addr, size_t len);

int __rte_experimental
rte_extmem_attach(void *va_addr, size_t len);

int __rte_experimental
rte_extmem_detach(void *va_addr, size_t len);

void rte_dump_physmem_layout(FILE *f);

uint64_t rte_eal_get_physmem_size(void);

unsigned rte_memory_get_nchannel(void);

unsigned rte_memory_get_nrank(void);

int __rte_experimental rte_mem_check_dma_mask(uint8_t maskbits);

int __rte_experimental rte_mem_check_dma_mask_thread_unsafe(uint8_t maskbits);

void __rte_experimental rte_mem_set_dma_mask(uint8_t maskbits);

int rte_eal_using_phys_addrs(void);


enum rte_mem_event {
        RTE_MEM_EVENT_ALLOC = 0, 
        RTE_MEM_EVENT_FREE,      
};
#define RTE_MEM_EVENT_CALLBACK_NAME_LEN 64

typedef void (*rte_mem_event_callback_t)(enum rte_mem_event event_type,
                const void *addr, size_t len, void *arg);

int __rte_experimental
rte_mem_event_callback_register(const char *name, rte_mem_event_callback_t clb,
                void *arg);

int __rte_experimental
rte_mem_event_callback_unregister(const char *name, void *arg);


#define RTE_MEM_ALLOC_VALIDATOR_NAME_LEN 64

typedef int (*rte_mem_alloc_validator_t)(int socket_id,
                size_t cur_limit, size_t new_len);

int __rte_experimental
rte_mem_alloc_validator_register(const char *name,
                rte_mem_alloc_validator_t clb, int socket_id, size_t limit);

int __rte_experimental
rte_mem_alloc_validator_unregister(const char *name, int socket_id);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_MEMORY_H_ */