lib/librte_eal/common/eal_private.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2018 Intel Corporation
   3  */
   4
   5 #ifndef _EAL_PRIVATE_H_
   6 #define _EAL_PRIVATE_H_
   7
   8 #include <stdbool.h>
   9 #include <stdint.h>
  10 #include <stdio.h>
  11
  12 #include <rte_dev.h>
  13
  14 /**
  15  * Initialize the memzone subsystem (private to eal).
  16  *
  17  * @return
  18  *   - 0 on success
  19  *   - Negative on error
  20  */
  21 int rte_eal_memzone_init(void);
  22
  23 /**
  24  * Common log initialization function (private to eal).  Determines
  25  * where log data is written when no call to rte_openlog_stream is
  26  * in effect.
  27  *
  28  * @param default_log
  29  *   The default log stream to be used.
  30  * @return
  31  *   - 0 on success
  32  *   - Negative on error
  33  */
  34 void eal_log_set_default(FILE *default_log);
  35
  36 /**
  37  * Fill configuration with number of physical and logical processors
  38  *
  39  * This function is private to EAL.
  40  *
  41  * Parse /proc/cpuinfo to get the number of physical and logical
  42  * processors on the machine.
  43  *
  44  * @return
  45  *   0 on success, negative on error
  46  */
  47 int rte_eal_cpu_init(void);
  48
  49 /**
  50  * Map memory
  51  *
  52  * This function is private to EAL.
  53  *
  54  * Fill configuration structure with these infos, and return 0 on success.
  55  *
  56  * @return
  57  *   0 on success, negative on error
  58  */
  59 int rte_eal_memory_init(void);
  60
  61 /**
  62  * Configure timers
  63  *
  64  * This function is private to EAL.
  65  *
  66  * Mmap memory areas used by HPET (high precision event timer) that will
  67  * provide our time reference, and configure the TSC frequency also for it
  68  * to be used as a reference.
  69  *
  70  * @return
  71  *   0 on success, negative on error
  72  */
  73 int rte_eal_timer_init(void);
  74
  75 /**
  76  * Init the default log stream
  77  *
  78  * This function is private to EAL.
  79  *
  80  * @return
  81  *   0 on success, negative on error
  82  */
  83 int rte_eal_log_init(const char *id, int facility);
  84
  85 /**
  86  * Save the log regexp for later
  87  */
  88 int rte_log_save_regexp(const char *type, int priority);
  89
  90 /**
  91  * Init tail queues for non-EAL library structures. This is to allow
  92  * the rings, mempools, etc. lists to be shared among multiple processes
  93  *
  94  * This function is private to EAL
  95  *
  96  * @return
  97  *    0 on success, negative on error
  98  */
  99 int rte_eal_tailqs_init(void);
 100
 101 /**
 102  * Init interrupt handling.
 103  *
 104  * This function is private to EAL.
 105  *
 106  * @return
 107  *  0 on success, negative on error
 108  */
 109 int rte_eal_intr_init(void);
 110
 111 /**
 112  * Init alarm mechanism. This is to allow a callback be called after
 113  * specific time.
 114  *
 115  * This function is private to EAL.
 116  *
 117  * @return
 118  *  0 on success, negative on error
 119  */
 120 int rte_eal_alarm_init(void);
 121
 122 /**
 123  * Function is to check if the kernel module(like, vfio, vfio_iommu_type1,
 124  * etc.) loaded.
 125  *
 126  * @param module_name
 127  *      The module's name which need to be checked
 128  *
 129  * @return
 130  *      -1 means some error happens(NULL pointer or open failure)
 131  *      0  means the module not loaded
 132  *      1  means the module loaded
 133  */
 134 int rte_eal_check_module(const char *module_name);
 135
 136 /**
 137  * Get virtual area of specified size from the OS.
 138  *
 139  * This function is private to the EAL.
 140  *
 141  * @param requested_addr
 142  *   Address where to request address space.
 143  * @param size
 144  *   Size of requested area.
 145  * @param page_sz
 146  *   Page size on which to align requested virtual area.
 147  * @param flags
 148  *   EAL_VIRTUAL_AREA_* flags.
 149  * @param mmap_flags
 150  *   Extra flags passed directly to mmap().
 151  *
 152  * @return
 153  *   Virtual area address if successful.
 154  *   NULL if unsuccessful.
 155  */
 156
 157 #define EAL_VIRTUAL_AREA_ADDR_IS_HINT (1 << 0)
 158 /**< don't fail if cannot get exact requested address. */
 159 #define EAL_VIRTUAL_AREA_ALLOW_SHRINK (1 << 1)
 160 /**< try getting smaller sized (decrement by page size) virtual areas if cannot
 161  * get area of requested size.
 162  */
 163 #define EAL_VIRTUAL_AREA_UNMAP (1 << 2)
 164 /**< immediately unmap reserved virtual area. */
 165 void *
 166 eal_get_virtual_area(void *requested_addr, size_t *size,
 167                 size_t page_sz, int flags, int mmap_flags);
 168
 169 /**
 170  * Get cpu core_id.
 171  *
 172  * This function is private to the EAL.
 173  */
 174 unsigned eal_cpu_core_id(unsigned lcore_id);
 175
 176 /**
 177  * Check if cpu is present.
 178  *
 179  * This function is private to the EAL.
 180  */
 181 int eal_cpu_detected(unsigned lcore_id);
 182
 183 /**
 184  * Set TSC frequency from precise value or estimation
 185  *
 186  * This function is private to the EAL.
 187  */
 188 void set_tsc_freq(void);
 189
 190 /**
 191  * Get precise TSC frequency from system
 192  *
 193  * This function is private to the EAL.
 194  */
 195 uint64_t get_tsc_freq(void);
 196
 197 /**
 198  * Get TSC frequency if the architecture supports.
 199  *
 200  * This function is private to the EAL.
 201  *
 202  * @return
 203  *   The number of TSC cycles in one second.
 204  *   Returns zero if the architecture support is not available.
 205  */
 206 uint64_t get_tsc_freq_arch(void);
 207
 208 /**
 209  * Prepare physical memory mapping
 210  * i.e. hugepages on Linux and
 211  *      contigmem on BSD.
 212  *
 213  * This function is private to the EAL.
 214  */
 215 int rte_eal_hugepage_init(void);
 216
 217 /**
 218  * Creates memory mapping in secondary process
 219  * i.e. hugepages on Linux and
 220  *      contigmem on BSD.
 221  *
 222  * This function is private to the EAL.
 223  */
 224 int rte_eal_hugepage_attach(void);
 225
 226 /**
 227  * Find a bus capable of identifying a device.
 228  *
 229  * @param str
 230  *   A device identifier (PCI address, virtual PMD name, ...).
 231  *
 232  * @return
 233  *   A valid bus handle if found.
 234  *   NULL if no bus is able to parse this device.
 235  */
 236 struct rte_bus *rte_bus_find_by_device_name(const char *str);
 237
 238 /**
 239  * Create the unix channel for primary/secondary communication.
 240  *
 241  * @return
 242  *   0 on success;
 243  *   (<0) on failure.
 244  */
 245
 246 int rte_mp_channel_init(void);
 247
 248 /**
 249  * Internal Executes all the user application registered callbacks for
 250  * the specific device. It is for DPDK internal user only. User
 251  * application should not call it directly.
 252  *
 253  * @param device_name
 254  *  The device name.
 255  * @param event
 256  *  the device event type.
 257  */
 258 void dev_callback_process(char *device_name, enum rte_dev_event_type event);
 259
 260 #endif /* _EAL_PRIVATE_H_ */