4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 #ifndef _RTE_MEMZONE_H_
35 #define _RTE_MEMZONE_H_
41 * The goal of the memzone allocator is to reserve contiguous
42 * portions of physical memory. These zones are identified by a name.
44 * The memzone descriptors are shared by all partitions and are
45 * located in a known place of physical memory. This zone is accessed
46 * using rte_eal_get_configuration(). The lookup (by name) of a
47 * memory zone can be done in any partition and returns the same
50 * A reserved memory zone cannot be unreserved. The reservation shall
51 * be done at initialization time only.
55 #include <rte_memory.h>
56 #include <rte_common.h>
62 #define RTE_MEMZONE_2MB 0x00000001 /**< Use 2MB pages. */
63 #define RTE_MEMZONE_1GB 0x00000002 /**< Use 1GB pages. */
64 #define RTE_MEMZONE_16MB 0x00000100 /**< Use 16MB pages. */
65 #define RTE_MEMZONE_16GB 0x00000200 /**< Use 16GB pages. */
66 #define RTE_MEMZONE_256KB 0x00010000 /**< Use 256KB pages. */
67 #define RTE_MEMZONE_256MB 0x00020000 /**< Use 256MB pages. */
68 #define RTE_MEMZONE_512MB 0x00040000 /**< Use 512MB pages. */
69 #define RTE_MEMZONE_4GB 0x00080000 /**< Use 4GB pages. */
70 #define RTE_MEMZONE_SIZE_HINT_ONLY 0x00000004 /**< Use available page size */
73 * A structure describing a memzone, which is a contiguous portion of
74 * physical memory identified by a name.
78 #define RTE_MEMZONE_NAMESIZE 32 /**< Maximum length of memory zone name.*/
79 char name[RTE_MEMZONE_NAMESIZE]; /**< Name of the memory zone. */
83 phys_addr_t phys_addr; /**< deprecated - Start physical address. */
84 rte_iova_t iova; /**< Start IO address. */
88 void *addr; /**< Start virtual address. */
89 uint64_t addr_64; /**< Makes sure addr is always 64-bits */
91 size_t len; /**< Length of the memzone. */
93 uint64_t hugepage_sz; /**< The page size of underlying memory */
95 int32_t socket_id; /**< NUMA socket ID. */
97 uint32_t flags; /**< Characteristics of this memzone. */
98 uint32_t memseg_id; /**< Memseg it belongs. */
99 } __attribute__((__packed__));
102 * Reserve a portion of physical memory.
104 * This function reserves some memory and returns a pointer to a
105 * correctly filled memzone descriptor. If the allocation cannot be
109 * The name of the memzone. If it already exists, the function will
110 * fail and return NULL.
112 * The size of the memory to be reserved. If it
113 * is 0, the biggest contiguous zone will be reserved.
115 * The socket identifier in the case of
116 * NUMA. The value can be SOCKET_ID_ANY if there is no NUMA
117 * constraint for the reserved zone.
119 * The flags parameter is used to request memzones to be
120 * taken from specifically sized hugepages.
121 * - RTE_MEMZONE_2MB - Reserved from 2MB pages
122 * - RTE_MEMZONE_1GB - Reserved from 1GB pages
123 * - RTE_MEMZONE_16MB - Reserved from 16MB pages
124 * - RTE_MEMZONE_16GB - Reserved from 16GB pages
125 * - RTE_MEMZONE_256KB - Reserved from 256KB pages
126 * - RTE_MEMZONE_256MB - Reserved from 256MB pages
127 * - RTE_MEMZONE_512MB - Reserved from 512MB pages
128 * - RTE_MEMZONE_4GB - Reserved from 4GB pages
129 * - RTE_MEMZONE_SIZE_HINT_ONLY - Allow alternative page size to be used if
130 * the requested page size is unavailable.
131 * If this flag is not set, the function
132 * will return error on an unavailable size
135 * A pointer to a correctly-filled read-only memzone descriptor, or NULL
137 * On error case, rte_errno will be set appropriately:
138 * - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
139 * - E_RTE_SECONDARY - function was called from a secondary process instance
140 * - ENOSPC - the maximum number of memzones has already been allocated
141 * - EEXIST - a memzone with the same name already exists
142 * - ENOMEM - no appropriate memory area found in which to create memzone
143 * - EINVAL - invalid parameters
145 const struct rte_memzone *rte_memzone_reserve(const char *name,
146 size_t len, int socket_id,
150 * Reserve a portion of physical memory with alignment on a specified
153 * This function reserves some memory with alignment on a specified
154 * boundary, and returns a pointer to a correctly filled memzone
155 * descriptor. If the allocation cannot be done or if the alignment
156 * is not a power of 2, returns NULL.
159 * The name of the memzone. If it already exists, the function will
160 * fail and return NULL.
162 * The size of the memory to be reserved. If it
163 * is 0, the biggest contiguous zone will be reserved.
165 * The socket identifier in the case of
166 * NUMA. The value can be SOCKET_ID_ANY if there is no NUMA
167 * constraint for the reserved zone.
169 * The flags parameter is used to request memzones to be
170 * taken from specifically sized hugepages.
171 * - RTE_MEMZONE_2MB - Reserved from 2MB pages
172 * - RTE_MEMZONE_1GB - Reserved from 1GB pages
173 * - RTE_MEMZONE_16MB - Reserved from 16MB pages
174 * - RTE_MEMZONE_16GB - Reserved from 16GB pages
175 * - RTE_MEMZONE_256KB - Reserved from 256KB pages
176 * - RTE_MEMZONE_256MB - Reserved from 256MB pages
177 * - RTE_MEMZONE_512MB - Reserved from 512MB pages
178 * - RTE_MEMZONE_4GB - Reserved from 4GB pages
179 * - RTE_MEMZONE_SIZE_HINT_ONLY - Allow alternative page size to be used if
180 * the requested page size is unavailable.
181 * If this flag is not set, the function
182 * will return error on an unavailable size
185 * Alignment for resulting memzone. Must be a power of 2.
187 * A pointer to a correctly-filled read-only memzone descriptor, or NULL
189 * On error case, rte_errno will be set appropriately:
190 * - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
191 * - E_RTE_SECONDARY - function was called from a secondary process instance
192 * - ENOSPC - the maximum number of memzones has already been allocated
193 * - EEXIST - a memzone with the same name already exists
194 * - ENOMEM - no appropriate memory area found in which to create memzone
195 * - EINVAL - invalid parameters
197 const struct rte_memzone *rte_memzone_reserve_aligned(const char *name,
198 size_t len, int socket_id,
199 unsigned flags, unsigned align);
202 * Reserve a portion of physical memory with specified alignment and
205 * This function reserves some memory with specified alignment and
206 * boundary, and returns a pointer to a correctly filled memzone
207 * descriptor. If the allocation cannot be done or if the alignment
208 * or boundary are not a power of 2, returns NULL.
209 * Memory buffer is reserved in a way, that it wouldn't cross specified
210 * boundary. That implies that requested length should be less or equal
214 * The name of the memzone. If it already exists, the function will
215 * fail and return NULL.
217 * The size of the memory to be reserved. If it
218 * is 0, the biggest contiguous zone will be reserved.
220 * The socket identifier in the case of
221 * NUMA. The value can be SOCKET_ID_ANY if there is no NUMA
222 * constraint for the reserved zone.
224 * The flags parameter is used to request memzones to be
225 * taken from specifically sized hugepages.
226 * - RTE_MEMZONE_2MB - Reserved from 2MB pages
227 * - RTE_MEMZONE_1GB - Reserved from 1GB pages
228 * - RTE_MEMZONE_16MB - Reserved from 16MB pages
229 * - RTE_MEMZONE_16GB - Reserved from 16GB pages
230 * - RTE_MEMZONE_256KB - Reserved from 256KB pages
231 * - RTE_MEMZONE_256MB - Reserved from 256MB pages
232 * - RTE_MEMZONE_512MB - Reserved from 512MB pages
233 * - RTE_MEMZONE_4GB - Reserved from 4GB pages
234 * - RTE_MEMZONE_SIZE_HINT_ONLY - Allow alternative page size to be used if
235 * the requested page size is unavailable.
236 * If this flag is not set, the function
237 * will return error on an unavailable size
240 * Alignment for resulting memzone. Must be a power of 2.
242 * Boundary for resulting memzone. Must be a power of 2 or zero.
243 * Zero value implies no boundary condition.
245 * A pointer to a correctly-filled read-only memzone descriptor, or NULL
247 * On error case, rte_errno will be set appropriately:
248 * - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
249 * - E_RTE_SECONDARY - function was called from a secondary process instance
250 * - ENOSPC - the maximum number of memzones has already been allocated
251 * - EEXIST - a memzone with the same name already exists
252 * - ENOMEM - no appropriate memory area found in which to create memzone
253 * - EINVAL - invalid parameters
255 const struct rte_memzone *rte_memzone_reserve_bounded(const char *name,
256 size_t len, int socket_id,
257 unsigned flags, unsigned align, unsigned bound);
263 * A pointer to the memzone
265 * -EINVAL - invalid parameter.
268 int rte_memzone_free(const struct rte_memzone *mz);
271 * Lookup for a memzone.
273 * Get a pointer to a descriptor of an already reserved memory
274 * zone identified by the name given as an argument.
277 * The name of the memzone.
279 * A pointer to a read-only memzone descriptor.
281 const struct rte_memzone *rte_memzone_lookup(const char *name);
284 * Dump all reserved memzones to a file.
287 * A pointer to a file for output
289 void rte_memzone_dump(FILE *f);
292 * Walk list of all memzones
297 * Argument passed to iterator
299 void rte_memzone_walk(void (*func)(const struct rte_memzone *, void *arg),
306 #endif /* _RTE_MEMZONE_H_ */