1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2018 Intel Corporation
5 #ifndef _EAL_PRIVATE_H_
6 #define _EAL_PRIVATE_H_
15 * Initialize the memzone subsystem (private to eal).
21 int rte_eal_memzone_init(void);
24 * Common log initialization function (private to eal). Determines
25 * where log data is written when no call to rte_openlog_stream is
29 * The default log stream to be used.
34 void eal_log_set_default(FILE *default_log);
37 * Fill configuration with number of physical and logical processors
39 * This function is private to EAL.
41 * Parse /proc/cpuinfo to get the number of physical and logical
42 * processors on the machine.
45 * 0 on success, negative on error
47 int rte_eal_cpu_init(void);
52 * This function is private to EAL.
54 * Preallocate virtual memory.
57 * 0 on success, negative on error
59 int rte_eal_memseg_init(void);
64 * This function is private to EAL.
66 * Fill configuration structure with these infos, and return 0 on success.
69 * 0 on success, negative on error
71 int rte_eal_memory_init(void);
76 * This function is private to EAL.
78 * Mmap memory areas used by HPET (high precision event timer) that will
79 * provide our time reference, and configure the TSC frequency also for it
80 * to be used as a reference.
83 * 0 on success, negative on error
85 int rte_eal_timer_init(void);
88 * Init the default log stream
90 * This function is private to EAL.
93 * 0 on success, negative on error
95 int rte_eal_log_init(const char *id, int facility);
98 * Save the log regexp for later
100 int rte_log_save_regexp(const char *type, int priority);
101 int rte_log_save_pattern(const char *pattern, int priority);
104 * Init tail queues for non-EAL library structures. This is to allow
105 * the rings, mempools, etc. lists to be shared among multiple processes
107 * This function is private to EAL
110 * 0 on success, negative on error
112 int rte_eal_tailqs_init(void);
115 * Init interrupt handling.
117 * This function is private to EAL.
120 * 0 on success, negative on error
122 int rte_eal_intr_init(void);
125 * Init alarm mechanism. This is to allow a callback be called after
128 * This function is private to EAL.
131 * 0 on success, negative on error
133 int rte_eal_alarm_init(void);
136 * Function is to check if the kernel module(like, vfio, vfio_iommu_type1,
140 * The module's name which need to be checked
143 * -1 means some error happens(NULL pointer or open failure)
144 * 0 means the module not loaded
145 * 1 means the module loaded
147 int rte_eal_check_module(const char *module_name);
150 * Get virtual area of specified size from the OS.
152 * This function is private to the EAL.
154 * @param requested_addr
155 * Address where to request address space.
157 * Size of requested area.
159 * Page size on which to align requested virtual area.
161 * EAL_VIRTUAL_AREA_* flags.
163 * Extra flags passed directly to mmap().
166 * Virtual area address if successful.
167 * NULL if unsuccessful.
170 #define EAL_VIRTUAL_AREA_ADDR_IS_HINT (1 << 0)
171 /**< don't fail if cannot get exact requested address. */
172 #define EAL_VIRTUAL_AREA_ALLOW_SHRINK (1 << 1)
173 /**< try getting smaller sized (decrement by page size) virtual areas if cannot
174 * get area of requested size.
176 #define EAL_VIRTUAL_AREA_UNMAP (1 << 2)
177 /**< immediately unmap reserved virtual area. */
179 eal_get_virtual_area(void *requested_addr, size_t *size,
180 size_t page_sz, int flags, int mmap_flags);
185 * This function is private to the EAL.
187 unsigned eal_cpu_core_id(unsigned lcore_id);
190 * Check if cpu is present.
192 * This function is private to the EAL.
194 int eal_cpu_detected(unsigned lcore_id);
197 * Set TSC frequency from precise value or estimation
199 * This function is private to the EAL.
201 void set_tsc_freq(void);
204 * Get precise TSC frequency from system
206 * This function is private to the EAL.
208 uint64_t get_tsc_freq(void);
211 * Get TSC frequency if the architecture supports.
213 * This function is private to the EAL.
216 * The number of TSC cycles in one second.
217 * Returns zero if the architecture support is not available.
219 uint64_t get_tsc_freq_arch(void);
222 * Prepare physical memory mapping
223 * i.e. hugepages on Linux and
226 * This function is private to the EAL.
228 int rte_eal_hugepage_init(void);
231 * Creates memory mapping in secondary process
232 * i.e. hugepages on Linux and
235 * This function is private to the EAL.
237 int rte_eal_hugepage_attach(void);
240 * Find a bus capable of identifying a device.
243 * A device identifier (PCI address, virtual PMD name, ...).
246 * A valid bus handle if found.
247 * NULL if no bus is able to parse this device.
249 struct rte_bus *rte_bus_find_by_device_name(const char *str);
252 * Create the unix channel for primary/secondary communication.
258 int rte_mp_channel_init(void);
261 * Primary/secondary communication cleanup.
263 void rte_mp_channel_cleanup(void);
267 * Parse a device string and store its information in an
268 * rte_devargs structure.
270 * A device description is split by layers of abstraction of the device:
271 * bus, class and driver. Each layer will offer a set of properties that
272 * can be applied either to configure or recognize a device.
274 * This function will parse those properties and prepare the rte_devargs
275 * to be given to each layers for processing.
277 * Note: if the "data" field of the devargs points to devstr,
278 * then no dynamic allocation is performed and the rte_devargs
279 * can be safely discarded.
281 * Otherwise ``data`` will hold a workable copy of devstr, that will be
282 * used by layers descriptors within rte_devargs. In this case,
283 * any rte_devargs should be cleaned-up before being freed.
286 * rte_devargs structure to fill.
293 * Negative errno values on error (rte_errno is set).
296 rte_devargs_layers_parse(struct rte_devargs *devargs,
300 * probe a device at local process.
303 * Device arguments including bus, class and driver properties.
305 * new device be probed as output.
307 * 0 on success, negative on error.
309 int local_dev_probe(const char *devargs, struct rte_device **new_dev);
312 * Hotplug remove a given device from a specific bus at local process.
315 * Data structure of the device to remove.
317 * 0 on success, negative on error.
319 int local_dev_remove(struct rte_device *dev);
322 * Iterate over all buses to find the corresponding bus to handle the sigbus
324 * @param failure_addr
325 * Pointer of the fault address of the sigbus error.
328 * 0 success to handle the sigbus.
329 * -1 failed to handle the sigbus
330 * 1 no bus can handler the sigbus
332 int rte_bus_sigbus_handler(const void *failure_addr);
336 * Register the sigbus handler.
339 * - On success, zero.
340 * - On failure, a negative value.
343 dev_sigbus_handler_register(void);
347 * Unregister the sigbus handler.
350 * - On success, zero.
351 * - On failure, a negative value.
354 dev_sigbus_handler_unregister(void);
357 * Check if the option is registered.
360 * The option to be parsed.
368 rte_option_parse(const char *opt);
371 * Iterate through the registered options and execute the associated
372 * callback if enabled.
375 rte_option_init(void);
378 * Iterate through the registered options and show the associated
382 rte_option_usage(void);
384 #endif /* _EAL_PRIVATE_H_ */