2019-11-20 17:23:38 +00:00
|
|
|
DPDK_20.0 {
|
2015-02-02 17:40:20 +00:00
|
|
|
global:
|
|
|
|
|
|
|
|
|
|
__rte_panic;
|
|
|
|
|
eal_parse_sysfs_value;
|
|
|
|
|
eal_timer_source;
|
|
|
|
|
per_lcore__lcore_id;
|
|
|
|
|
per_lcore__rte_errno;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_bus_dump;
|
|
|
|
|
rte_bus_find;
|
|
|
|
|
rte_bus_find_by_device;
|
|
|
|
|
rte_bus_find_by_name;
|
|
|
|
|
rte_bus_get_iommu_class;
|
|
|
|
|
rte_bus_probe;
|
|
|
|
|
rte_bus_register;
|
|
|
|
|
rte_bus_scan;
|
|
|
|
|
rte_bus_unregister;
|
2015-07-15 16:32:20 +00:00
|
|
|
rte_calloc;
|
|
|
|
|
rte_calloc_socket;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_cpu_get_flag_enabled;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_cpu_get_flag_name;
|
|
|
|
|
rte_cpu_is_supported;
|
|
|
|
|
rte_ctrl_thread_create;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_cycles_vmware_tsc_map;
|
|
|
|
|
rte_delay_us;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_delay_us_block;
|
|
|
|
|
rte_delay_us_callback_register;
|
|
|
|
|
rte_dev_is_probed;
|
|
|
|
|
rte_dev_probe;
|
|
|
|
|
rte_dev_remove;
|
|
|
|
|
rte_devargs_add;
|
|
|
|
|
rte_devargs_dump;
|
|
|
|
|
rte_devargs_insert;
|
|
|
|
|
rte_devargs_next;
|
|
|
|
|
rte_devargs_parse;
|
|
|
|
|
rte_devargs_parsef;
|
|
|
|
|
rte_devargs_remove;
|
|
|
|
|
rte_devargs_type_count;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_dump_physmem_layout;
|
|
|
|
|
rte_dump_registers;
|
|
|
|
|
rte_dump_stack;
|
|
|
|
|
rte_dump_tailq;
|
|
|
|
|
rte_eal_alarm_cancel;
|
|
|
|
|
rte_eal_alarm_set;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_eal_cleanup;
|
|
|
|
|
rte_eal_create_uio_dev;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_eal_get_lcore_state;
|
|
|
|
|
rte_eal_get_physmem_size;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_eal_get_runtime_dir;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_eal_has_hugepages;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_eal_has_pci;
|
|
|
|
|
rte_eal_hotplug_add;
|
|
|
|
|
rte_eal_hotplug_remove;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_eal_hpet_init;
|
|
|
|
|
rte_eal_init;
|
2015-02-12 15:40:54 +00:00
|
|
|
rte_eal_iopl_init;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_eal_iova_mode;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_eal_lcore_role;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_eal_mbuf_user_pool_ops;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_eal_mp_remote_launch;
|
|
|
|
|
rte_eal_mp_wait_lcore;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_eal_primary_proc_alive;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_eal_process_type;
|
|
|
|
|
rte_eal_remote_launch;
|
|
|
|
|
rte_eal_tailq_lookup;
|
2015-03-04 21:50:07 +00:00
|
|
|
rte_eal_tailq_register;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_eal_using_phys_addrs;
|
|
|
|
|
rte_eal_vfio_intr_mode;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_eal_wait_lcore;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_epoll_ctl;
|
|
|
|
|
rte_epoll_wait;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_exit;
|
2015-07-15 16:32:20 +00:00
|
|
|
rte_free;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_get_hpet_cycles;
|
|
|
|
|
rte_get_hpet_hz;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_get_master_lcore;
|
|
|
|
|
rte_get_next_lcore;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_get_tsc_hz;
|
|
|
|
|
rte_hexdump;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_hypervisor_get;
|
|
|
|
|
rte_hypervisor_get_name;
|
|
|
|
|
rte_intr_allow_others;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_intr_callback_register;
|
|
|
|
|
rte_intr_callback_unregister;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_intr_cap_multiple;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_intr_disable;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_intr_dp_is_en;
|
|
|
|
|
rte_intr_efd_disable;
|
|
|
|
|
rte_intr_efd_enable;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_intr_enable;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_intr_free_epoll_fd;
|
|
|
|
|
rte_intr_rx_ctl;
|
|
|
|
|
rte_intr_tls_epfd;
|
|
|
|
|
rte_keepalive_create;
|
|
|
|
|
rte_keepalive_dispatch_pings;
|
|
|
|
|
rte_keepalive_mark_alive;
|
|
|
|
|
rte_keepalive_mark_sleep;
|
|
|
|
|
rte_keepalive_register_core;
|
|
|
|
|
rte_keepalive_register_relay_callback;
|
|
|
|
|
rte_lcore_count;
|
|
|
|
|
rte_lcore_has_role;
|
|
|
|
|
rte_lcore_index;
|
|
|
|
|
rte_lcore_is_enabled;
|
|
|
|
|
rte_lcore_to_socket_id;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_log;
|
|
|
|
|
rte_log_cur_msg_loglevel;
|
|
|
|
|
rte_log_cur_msg_logtype;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_log_dump;
|
|
|
|
|
rte_log_get_global_level;
|
|
|
|
|
rte_log_get_level;
|
|
|
|
|
rte_log_register;
|
|
|
|
|
rte_log_set_global_level;
|
|
|
|
|
rte_log_set_level;
|
|
|
|
|
rte_log_set_level_pattern;
|
|
|
|
|
rte_log_set_level_regexp;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_logs;
|
2015-07-15 16:32:20 +00:00
|
|
|
rte_malloc;
|
|
|
|
|
rte_malloc_dump_stats;
|
|
|
|
|
rte_malloc_get_socket_stats;
|
|
|
|
|
rte_malloc_set_limit;
|
|
|
|
|
rte_malloc_socket;
|
|
|
|
|
rte_malloc_validate;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_malloc_virt2iova;
|
|
|
|
|
rte_mcfg_mem_read_lock;
|
|
|
|
|
rte_mcfg_mem_read_unlock;
|
|
|
|
|
rte_mcfg_mem_write_lock;
|
|
|
|
|
rte_mcfg_mem_write_unlock;
|
|
|
|
|
rte_mcfg_mempool_read_lock;
|
|
|
|
|
rte_mcfg_mempool_read_unlock;
|
|
|
|
|
rte_mcfg_mempool_write_lock;
|
|
|
|
|
rte_mcfg_mempool_write_unlock;
|
|
|
|
|
rte_mcfg_tailq_read_lock;
|
|
|
|
|
rte_mcfg_tailq_read_unlock;
|
|
|
|
|
rte_mcfg_tailq_write_lock;
|
|
|
|
|
rte_mcfg_tailq_write_unlock;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_mem_lock_page;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_mem_virt2iova;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_mem_virt2phy;
|
|
|
|
|
rte_memdump;
|
|
|
|
|
rte_memory_get_nchannel;
|
|
|
|
|
rte_memory_get_nrank;
|
|
|
|
|
rte_memzone_dump;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_memzone_free;
|
2015-02-02 17:40:20 +00:00
|
|
|
rte_memzone_lookup;
|
|
|
|
|
rte_memzone_reserve;
|
|
|
|
|
rte_memzone_reserve_aligned;
|
|
|
|
|
rte_memzone_reserve_bounded;
|
|
|
|
|
rte_memzone_walk;
|
|
|
|
|
rte_openlog_stream;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_rand;
|
2015-07-15 16:32:20 +00:00
|
|
|
rte_realloc;
|
2018-01-26 05:04:49 +00:00
|
|
|
rte_reciprocal_value;
|
2018-01-26 05:04:50 +00:00
|
|
|
rte_reciprocal_value_u64;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_rtm_supported;
|
2018-04-05 13:15:46 +00:00
|
|
|
rte_service_attr_get;
|
|
|
|
|
rte_service_attr_reset_all;
|
|
|
|
|
rte_service_component_register;
|
|
|
|
|
rte_service_component_runstate_set;
|
|
|
|
|
rte_service_component_unregister;
|
|
|
|
|
rte_service_dump;
|
|
|
|
|
rte_service_finalize;
|
|
|
|
|
rte_service_get_by_id;
|
|
|
|
|
rte_service_get_by_name;
|
|
|
|
|
rte_service_get_count;
|
|
|
|
|
rte_service_get_name;
|
|
|
|
|
rte_service_lcore_add;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_service_lcore_attr_get;
|
|
|
|
|
rte_service_lcore_attr_reset_all;
|
2018-04-05 13:15:46 +00:00
|
|
|
rte_service_lcore_count;
|
|
|
|
|
rte_service_lcore_count_services;
|
|
|
|
|
rte_service_lcore_del;
|
|
|
|
|
rte_service_lcore_list;
|
|
|
|
|
rte_service_lcore_reset_all;
|
|
|
|
|
rte_service_lcore_start;
|
|
|
|
|
rte_service_lcore_stop;
|
|
|
|
|
rte_service_map_lcore_get;
|
|
|
|
|
rte_service_map_lcore_set;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_service_may_be_active;
|
2018-04-05 13:15:46 +00:00
|
|
|
rte_service_probe_capability;
|
|
|
|
|
rte_service_run_iter_on_app_lcore;
|
|
|
|
|
rte_service_runstate_get;
|
|
|
|
|
rte_service_runstate_set;
|
|
|
|
|
rte_service_set_runstate_mapped_check;
|
|
|
|
|
rte_service_set_stats_enable;
|
|
|
|
|
rte_service_start_with_defaults;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_set_application_usage_hook;
|
|
|
|
|
rte_socket_count;
|
|
|
|
|
rte_socket_id;
|
|
|
|
|
rte_socket_id_by_idx;
|
|
|
|
|
rte_srand;
|
|
|
|
|
rte_strerror;
|
|
|
|
|
rte_strscpy;
|
|
|
|
|
rte_strsplit;
|
|
|
|
|
rte_sys_gettid;
|
|
|
|
|
rte_thread_get_affinity;
|
|
|
|
|
rte_thread_set_affinity;
|
|
|
|
|
rte_thread_setname;
|
2018-07-13 17:06:41 +00:00
|
|
|
rte_uuid_compare;
|
|
|
|
|
rte_uuid_is_null;
|
|
|
|
|
rte_uuid_parse;
|
|
|
|
|
rte_uuid_unparse;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_vfio_clear_group;
|
2018-06-08 09:40:11 +00:00
|
|
|
rte_vfio_container_create;
|
|
|
|
|
rte_vfio_container_destroy;
|
|
|
|
|
rte_vfio_container_dma_map;
|
|
|
|
|
rte_vfio_container_dma_unmap;
|
|
|
|
|
rte_vfio_container_group_bind;
|
|
|
|
|
rte_vfio_container_group_unbind;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_vfio_enable;
|
2018-06-08 09:40:11 +00:00
|
|
|
rte_vfio_get_container_fd;
|
|
|
|
|
rte_vfio_get_group_fd;
|
|
|
|
|
rte_vfio_get_group_num;
|
2019-11-20 17:23:38 +00:00
|
|
|
rte_vfio_is_enabled;
|
|
|
|
|
rte_vfio_noiommu_is_enabled;
|
|
|
|
|
rte_vfio_release_device;
|
|
|
|
|
rte_vfio_setup_device;
|
|
|
|
|
rte_vlog;
|
|
|
|
|
rte_zmalloc;
|
|
|
|
|
rte_zmalloc_socket;
|
2018-07-13 17:06:41 +00:00
|
|
|
|
2019-11-20 17:23:38 +00:00
|
|
|
local: *;
|
|
|
|
|
};
|
2019-10-25 13:56:08 +00:00
|
|
|
|
2020-07-06 20:52:26 +00:00
|
|
|
DPDK_21 {
|
|
|
|
|
global:
|
|
|
|
|
|
|
|
|
|
per_lcore__thread_id;
|
|
|
|
|
|
|
|
|
|
} DPDK_20.0;
|
|
|
|
|
|
2017-06-30 18:19:41 +00:00
|
|
|
EXPERIMENTAL {
|
|
|
|
|
global:
|
|
|
|
|
|
2019-07-27 07:21:33 +00:00
|
|
|
# added in 18.02
|
|
|
|
|
rte_mp_action_register;
|
|
|
|
|
rte_mp_action_unregister;
|
|
|
|
|
rte_mp_reply;
|
|
|
|
|
rte_mp_sendmsg;
|
|
|
|
|
|
|
|
|
|
# added in 18.05
|
2018-04-13 08:30:38 +00:00
|
|
|
rte_dev_event_callback_register;
|
|
|
|
|
rte_dev_event_callback_unregister;
|
|
|
|
|
rte_dev_event_monitor_start;
|
|
|
|
|
rte_dev_event_monitor_stop;
|
eal: add shared indexed file-backed array
rte_fbarray is a simple indexed array stored in shared memory
via mapping files into memory. Rationale for its existence is the
following: since we are going to map memory page-by-page, there
could be quite a lot of memory segments to keep track of (for
smaller page sizes, page count can easily reach thousands). We
can't really make page lists truly dynamic and infinitely expandable,
because that involves reallocating memory (which is a big no-no in
multiprocess). What we can do instead is have a maximum capacity as
something really, really large, and decide at allocation time how
big the array is going to be. We map the entire file into memory,
which makes it possible to use fbarray as shared memory, provided
the structure itself is allocated in shared memory. Per-fbarray
locking is also used to avoid index data races (but not contents
data races - that is up to user application to synchronize).
In addition, in understanding that we will frequently need to scan
this array for free space and iterating over array linearly can
become slow, rte_fbarray provides facilities to index array's
usage. The following use cases are covered:
- find next free/used slot (useful either for adding new elements
to fbarray, or walking the list)
- find starting index for next N free/used slots (useful for when
we want to allocate chunk of VA-contiguous memory composed of
several pages)
- find how many contiguous free/used slots there are, starting
from specified index (useful for when we want to figure out
how many pages we have until next hole in allocated memory, to
speed up some bulk operations where we would otherwise have to
walk the array and add pages one by one)
This is accomplished by storing a usage mask in-memory, right
after the data section of the array, and using some bit-level
magic to figure out the info we need.
Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Tested-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Tested-by: Hemant Agrawal <hemant.agrawal@nxp.com>
Tested-by: Gowrishankar Muthukrishnan <gowrishankar.m@linux.vnet.ibm.com>
2018-04-11 12:30:23 +00:00
|
|
|
rte_fbarray_attach;
|
|
|
|
|
rte_fbarray_destroy;
|
|
|
|
|
rte_fbarray_detach;
|
|
|
|
|
rte_fbarray_dump_metadata;
|
2019-07-27 07:21:33 +00:00
|
|
|
rte_fbarray_find_contig_free;
|
|
|
|
|
rte_fbarray_find_contig_used;
|
eal: add shared indexed file-backed array
rte_fbarray is a simple indexed array stored in shared memory
via mapping files into memory. Rationale for its existence is the
following: since we are going to map memory page-by-page, there
could be quite a lot of memory segments to keep track of (for
smaller page sizes, page count can easily reach thousands). We
can't really make page lists truly dynamic and infinitely expandable,
because that involves reallocating memory (which is a big no-no in
multiprocess). What we can do instead is have a maximum capacity as
something really, really large, and decide at allocation time how
big the array is going to be. We map the entire file into memory,
which makes it possible to use fbarray as shared memory, provided
the structure itself is allocated in shared memory. Per-fbarray
locking is also used to avoid index data races (but not contents
data races - that is up to user application to synchronize).
In addition, in understanding that we will frequently need to scan
this array for free space and iterating over array linearly can
become slow, rte_fbarray provides facilities to index array's
usage. The following use cases are covered:
- find next free/used slot (useful either for adding new elements
to fbarray, or walking the list)
- find starting index for next N free/used slots (useful for when
we want to allocate chunk of VA-contiguous memory composed of
several pages)
- find how many contiguous free/used slots there are, starting
from specified index (useful for when we want to figure out
how many pages we have until next hole in allocated memory, to
speed up some bulk operations where we would otherwise have to
walk the array and add pages one by one)
This is accomplished by storing a usage mask in-memory, right
after the data section of the array, and using some bit-level
magic to figure out the info we need.
Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Tested-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Tested-by: Hemant Agrawal <hemant.agrawal@nxp.com>
Tested-by: Gowrishankar Muthukrishnan <gowrishankar.m@linux.vnet.ibm.com>
2018-04-11 12:30:23 +00:00
|
|
|
rte_fbarray_find_idx;
|
|
|
|
|
rte_fbarray_find_next_free;
|
|
|
|
|
rte_fbarray_find_next_n_free;
|
|
|
|
|
rte_fbarray_find_next_n_used;
|
2019-07-27 07:21:33 +00:00
|
|
|
rte_fbarray_find_next_used;
|
eal: add shared indexed file-backed array
rte_fbarray is a simple indexed array stored in shared memory
via mapping files into memory. Rationale for its existence is the
following: since we are going to map memory page-by-page, there
could be quite a lot of memory segments to keep track of (for
smaller page sizes, page count can easily reach thousands). We
can't really make page lists truly dynamic and infinitely expandable,
because that involves reallocating memory (which is a big no-no in
multiprocess). What we can do instead is have a maximum capacity as
something really, really large, and decide at allocation time how
big the array is going to be. We map the entire file into memory,
which makes it possible to use fbarray as shared memory, provided
the structure itself is allocated in shared memory. Per-fbarray
locking is also used to avoid index data races (but not contents
data races - that is up to user application to synchronize).
In addition, in understanding that we will frequently need to scan
this array for free space and iterating over array linearly can
become slow, rte_fbarray provides facilities to index array's
usage. The following use cases are covered:
- find next free/used slot (useful either for adding new elements
to fbarray, or walking the list)
- find starting index for next N free/used slots (useful for when
we want to allocate chunk of VA-contiguous memory composed of
several pages)
- find how many contiguous free/used slots there are, starting
from specified index (useful for when we want to figure out
how many pages we have until next hole in allocated memory, to
speed up some bulk operations where we would otherwise have to
walk the array and add pages one by one)
This is accomplished by storing a usage mask in-memory, right
after the data section of the array, and using some bit-level
magic to figure out the info we need.
Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Tested-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Tested-by: Hemant Agrawal <hemant.agrawal@nxp.com>
Tested-by: Gowrishankar Muthukrishnan <gowrishankar.m@linux.vnet.ibm.com>
2018-04-11 12:30:23 +00:00
|
|
|
rte_fbarray_get;
|
|
|
|
|
rte_fbarray_init;
|
|
|
|
|
rte_fbarray_is_used;
|
|
|
|
|
rte_fbarray_set_free;
|
|
|
|
|
rte_fbarray_set_used;
|
2018-03-21 11:28:16 +00:00
|
|
|
rte_log_register_type_and_pick_level;
|
2018-04-11 12:29:39 +00:00
|
|
|
rte_malloc_dump_heaps;
|
2018-04-11 12:30:43 +00:00
|
|
|
rte_mem_alloc_validator_register;
|
|
|
|
|
rte_mem_alloc_validator_unregister;
|
2018-11-01 19:53:25 +00:00
|
|
|
rte_mem_check_dma_mask;
|
2018-04-11 12:30:37 +00:00
|
|
|
rte_mem_event_callback_register;
|
|
|
|
|
rte_mem_event_callback_unregister;
|
2018-04-11 12:30:11 +00:00
|
|
|
rte_mem_iova2virt;
|
2018-04-11 12:30:15 +00:00
|
|
|
rte_mem_virt2memseg;
|
mem: replace memseg with memseg lists
Before, we were aggregating multiple pages into one memseg, so the
number of memsegs was small. Now, each page gets its own memseg,
so the list of memsegs is huge. To accommodate the new memseg list
size and to keep the under-the-hood workings sane, the memseg list
is now not just a single list, but multiple lists. To be precise,
each hugepage size available on the system gets one or more memseg
lists, per socket.
In order to support dynamic memory allocation, we reserve all
memory in advance (unless we're in 32-bit legacy mode, in which
case we do not preallocate memory). As in, we do an anonymous
mmap() of the entire maximum size of memory per hugepage size, per
socket (which is limited to either RTE_MAX_MEMSEG_PER_TYPE pages or
RTE_MAX_MEM_MB_PER_TYPE megabytes worth of memory, whichever is the
smaller one), split over multiple lists (which are limited to
either RTE_MAX_MEMSEG_PER_LIST memsegs or RTE_MAX_MEM_MB_PER_LIST
megabytes per list, whichever is the smaller one). There is also
a global limit of CONFIG_RTE_MAX_MEM_MB megabytes, which is mainly
used for 32-bit targets to limit amounts of preallocated memory,
but can be used to place an upper limit on total amount of VA
memory that can be allocated by DPDK application.
So, for each hugepage size, we get (by default) up to 128G worth
of memory, per socket, split into chunks of up to 32G in size.
The address space is claimed at the start, in eal_common_memory.c.
The actual page allocation code is in eal_memalloc.c (Linux-only),
and largely consists of copied EAL memory init code.
Pages in the list are also indexed by address. That is, in order
to figure out where the page belongs, one can simply look at base
address for a memseg list. Similarly, figuring out IOVA address
of a memzone is a matter of finding the right memseg list, getting
offset and dividing by page size to get the appropriate memseg.
This commit also removes rte_eal_dump_physmem_layout() call,
according to deprecation notice [1], and removes that deprecation
notice as well.
On 32-bit targets due to limited VA space, DPDK will no longer
spread memory to different sockets like before. Instead, it will
(by default) allocate all of the memory on socket where master
lcore is. To override this behavior, --socket-mem must be used.
The rest of the changes are really ripple effects from the memseg
change - heap changes, compile fixes, and rewrites to support
fbarray-backed memseg lists. Due to earlier switch to _walk()
functions, most of the changes are simple fixes, however some
of the _walk() calls were switched to memseg list walk, where
it made sense to do so.
Additionally, we are also switching locks from flock() to fcntl().
Down the line, we will be introducing single-file segments option,
and we cannot use flock() locks to lock parts of the file. Therefore,
we will use fcntl() locks for legacy mem as well, in case someone is
unfortunate enough to accidentally start legacy mem primary process
alongside an already working non-legacy mem-based primary process.
[1] http://dpdk.org/dev/patchwork/patch/34002/
Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Tested-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Tested-by: Hemant Agrawal <hemant.agrawal@nxp.com>
Tested-by: Gowrishankar Muthukrishnan <gowrishankar.m@linux.vnet.ibm.com>
2018-04-11 12:30:24 +00:00
|
|
|
rte_mem_virt2memseg_list;
|
2018-04-11 12:30:09 +00:00
|
|
|
rte_memseg_contig_walk;
|
2019-07-27 07:21:33 +00:00
|
|
|
rte_memseg_list_walk;
|
|
|
|
|
rte_memseg_walk;
|
|
|
|
|
rte_mp_request_async;
|
|
|
|
|
rte_mp_request_sync;
|
|
|
|
|
|
|
|
|
|
# added in 18.08
|
|
|
|
|
rte_class_find;
|
|
|
|
|
rte_class_find_by_name;
|
|
|
|
|
rte_class_register;
|
|
|
|
|
rte_class_unregister;
|
|
|
|
|
rte_dev_iterator_init;
|
|
|
|
|
rte_dev_iterator_next;
|
|
|
|
|
rte_fbarray_find_prev_free;
|
|
|
|
|
rte_fbarray_find_prev_n_free;
|
|
|
|
|
rte_fbarray_find_prev_n_used;
|
|
|
|
|
rte_fbarray_find_prev_used;
|
|
|
|
|
rte_fbarray_find_rev_contig_free;
|
|
|
|
|
rte_fbarray_find_rev_contig_used;
|
2018-06-12 09:46:14 +00:00
|
|
|
rte_memseg_contig_walk_thread_unsafe;
|
2019-07-27 07:21:33 +00:00
|
|
|
rte_memseg_list_walk_thread_unsafe;
|
|
|
|
|
rte_memseg_walk_thread_unsafe;
|
|
|
|
|
|
|
|
|
|
# added in 18.11
|
|
|
|
|
rte_delay_us_sleep;
|
|
|
|
|
rte_dev_event_callback_process;
|
|
|
|
|
rte_dev_hotplug_handle_disable;
|
|
|
|
|
rte_dev_hotplug_handle_enable;
|
|
|
|
|
rte_malloc_heap_create;
|
|
|
|
|
rte_malloc_heap_destroy;
|
|
|
|
|
rte_malloc_heap_get_socket;
|
|
|
|
|
rte_malloc_heap_memory_add;
|
|
|
|
|
rte_malloc_heap_memory_attach;
|
|
|
|
|
rte_malloc_heap_memory_detach;
|
|
|
|
|
rte_malloc_heap_memory_remove;
|
|
|
|
|
rte_malloc_heap_socket_is_external;
|
|
|
|
|
rte_mem_check_dma_mask_thread_unsafe;
|
|
|
|
|
rte_mem_set_dma_mask;
|
2018-09-04 15:15:48 +00:00
|
|
|
rte_memseg_get_fd;
|
2018-09-04 15:15:49 +00:00
|
|
|
rte_memseg_get_fd_offset;
|
|
|
|
|
rte_memseg_get_fd_offset_thread_unsafe;
|
2019-07-27 07:21:33 +00:00
|
|
|
rte_memseg_get_fd_thread_unsafe;
|
|
|
|
|
|
|
|
|
|
# added in 19.02
|
|
|
|
|
rte_extmem_attach;
|
|
|
|
|
rte_extmem_detach;
|
|
|
|
|
rte_extmem_register;
|
|
|
|
|
rte_extmem_unregister;
|
|
|
|
|
|
|
|
|
|
# added in 19.05
|
|
|
|
|
rte_dev_dma_map;
|
|
|
|
|
rte_dev_dma_unmap;
|
|
|
|
|
rte_fbarray_find_biggest_free;
|
|
|
|
|
rte_fbarray_find_biggest_used;
|
|
|
|
|
rte_fbarray_find_rev_biggest_free;
|
|
|
|
|
rte_fbarray_find_rev_biggest_used;
|
|
|
|
|
rte_intr_callback_unregister_pending;
|
2019-03-01 08:46:16 +00:00
|
|
|
rte_realloc_socket;
|
2019-05-31 15:36:59 +00:00
|
|
|
|
|
|
|
|
# added in 19.08
|
2019-07-23 08:04:18 +00:00
|
|
|
rte_intr_ack;
|
2019-05-31 15:36:59 +00:00
|
|
|
rte_lcore_cpuset;
|
|
|
|
|
rte_lcore_to_cpu_id;
|
2019-07-05 17:22:44 +00:00
|
|
|
rte_mcfg_timer_lock;
|
|
|
|
|
rte_mcfg_timer_unlock;
|
2019-07-27 07:21:33 +00:00
|
|
|
rte_rand_max;
|
2019-10-25 13:56:06 +00:00
|
|
|
|
|
|
|
|
# added in 19.11
|
|
|
|
|
rte_log_get_stream;
|
2019-11-04 11:03:00 +00:00
|
|
|
rte_mcfg_get_single_file_segments;
|
2020-01-14 09:04:52 +00:00
|
|
|
|
|
|
|
|
# added in 20.02
|
|
|
|
|
rte_thread_is_intr;
|
2020-03-13 14:51:59 +00:00
|
|
|
|
|
|
|
|
# added in 20.05
|
2020-04-22 19:03:34 +00:00
|
|
|
__rte_eal_trace_alarm_cancel;
|
|
|
|
|
__rte_eal_trace_alarm_set;
|
2020-04-22 19:03:33 +00:00
|
|
|
__rte_eal_trace_generic_double;
|
|
|
|
|
__rte_eal_trace_generic_float;
|
|
|
|
|
__rte_eal_trace_generic_func;
|
|
|
|
|
__rte_eal_trace_generic_i16;
|
|
|
|
|
__rte_eal_trace_generic_i32;
|
|
|
|
|
__rte_eal_trace_generic_i64;
|
|
|
|
|
__rte_eal_trace_generic_i8;
|
|
|
|
|
__rte_eal_trace_generic_int;
|
|
|
|
|
__rte_eal_trace_generic_long;
|
|
|
|
|
__rte_eal_trace_generic_ptr;
|
|
|
|
|
__rte_eal_trace_generic_str;
|
|
|
|
|
__rte_eal_trace_generic_u16;
|
|
|
|
|
__rte_eal_trace_generic_u32;
|
|
|
|
|
__rte_eal_trace_generic_u64;
|
|
|
|
|
__rte_eal_trace_generic_u8;
|
|
|
|
|
__rte_eal_trace_generic_void;
|
2020-04-22 19:03:38 +00:00
|
|
|
__rte_eal_trace_intr_callback_register;
|
|
|
|
|
__rte_eal_trace_intr_callback_unregister;
|
|
|
|
|
__rte_eal_trace_intr_enable;
|
|
|
|
|
__rte_eal_trace_intr_disable;
|
2020-04-22 19:03:35 +00:00
|
|
|
__rte_eal_trace_mem_free;
|
|
|
|
|
__rte_eal_trace_mem_malloc;
|
|
|
|
|
__rte_eal_trace_mem_realloc;
|
|
|
|
|
__rte_eal_trace_mem_zmalloc;
|
2020-04-22 19:03:36 +00:00
|
|
|
__rte_eal_trace_memzone_free;
|
|
|
|
|
__rte_eal_trace_memzone_lookup;
|
|
|
|
|
__rte_eal_trace_memzone_reserve;
|
2020-04-22 19:03:37 +00:00
|
|
|
__rte_eal_trace_thread_lcore_ready;
|
|
|
|
|
__rte_eal_trace_thread_remote_launch;
|
2020-04-22 19:03:26 +00:00
|
|
|
__rte_trace_mem_per_thread_alloc;
|
2020-04-22 19:03:29 +00:00
|
|
|
__rte_trace_point_emit_field;
|
2020-04-22 19:03:20 +00:00
|
|
|
__rte_trace_point_register;
|
2020-04-22 19:03:26 +00:00
|
|
|
per_lcore_trace_mem;
|
2020-04-22 19:03:20 +00:00
|
|
|
per_lcore_trace_point_sz;
|
2020-03-13 14:51:59 +00:00
|
|
|
rte_log_can_log;
|
2020-04-22 19:03:18 +00:00
|
|
|
rte_thread_getname;
|
2020-04-22 19:03:27 +00:00
|
|
|
rte_trace_dump;
|
2020-04-22 19:03:21 +00:00
|
|
|
rte_trace_is_enabled;
|
2020-04-22 19:03:27 +00:00
|
|
|
rte_trace_metadata_dump;
|
2020-04-22 19:03:21 +00:00
|
|
|
rte_trace_mode_get;
|
|
|
|
|
rte_trace_mode_set;
|
|
|
|
|
rte_trace_pattern;
|
|
|
|
|
rte_trace_point_disable;
|
|
|
|
|
rte_trace_point_enable;
|
|
|
|
|
rte_trace_point_is_enabled;
|
|
|
|
|
rte_trace_point_lookup;
|
|
|
|
|
rte_trace_regexp;
|
2020-04-22 19:03:28 +00:00
|
|
|
rte_trace_save;
|
2020-07-03 14:57:18 +00:00
|
|
|
|
|
|
|
|
# added in 20.08
|
|
|
|
|
rte_eal_vfio_get_vf_token;
|
2020-07-06 20:52:31 +00:00
|
|
|
rte_lcore_callback_register;
|
|
|
|
|
rte_lcore_callback_unregister;
|
2020-07-06 20:52:32 +00:00
|
|
|
rte_lcore_dump;
|
|
|
|
|
rte_lcore_iterate;
|
2020-07-06 20:52:30 +00:00
|
|
|
rte_thread_register;
|
|
|
|
|
rte_thread_unregister;
|
2018-04-27 15:17:55 +00:00
|
|
|
};
|
2020-06-15 00:43:45 +00:00
|
|
|
|
|
|
|
|
INTERNAL {
|
|
|
|
|
global:
|
|
|
|
|
|
|
|
|
|
rte_mem_lock;
|
|
|
|
|
rte_mem_map;
|
|
|
|
|
rte_mem_page_size;
|
|
|
|
|
rte_mem_unmap;
|
|
|
|
|
};
|
