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  * Create memseg lists
  51  *
  52  * This function is private to EAL.
  53  *
  54  * Preallocate virtual memory.
  55  *
  56  * @return
  57  *   0 on success, negative on error
  58  */
  59 int rte_eal_memseg_init(void);
  60
  61 /**
  62  * Map memory
  63  *
  64  * This function is private to EAL.
  65  *
  66  * Fill configuration structure with these infos, and return 0 on success.
  67  *
  68  * @return
  69  *   0 on success, negative on error
  70  */
  71 int rte_eal_memory_init(void);
  72
  73 /**
  74  * Configure timers
  75  *
  76  * This function is private to EAL.
  77  *
  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.
  81  *
  82  * @return
  83  *   0 on success, negative on error
  84  */
  85 int rte_eal_timer_init(void);
  86
  87 /**
  88  * Init the default log stream
  89  *
  90  * This function is private to EAL.
  91  *
  92  * @return
  93  *   0 on success, negative on error
  94  */
  95 int rte_eal_log_init(const char *id, int facility);
  96
  97 /**
  98  * Save the log regexp for later
  99  */
 100 int rte_log_save_regexp(const char *type, int priority);
 101 int rte_log_save_pattern(const char *pattern, int priority);
 102
 103 /**
 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
 106  *
 107  * This function is private to EAL
 108  *
 109  * @return
 110  *    0 on success, negative on error
 111  */
 112 int rte_eal_tailqs_init(void);
 113
 114 /**
 115  * Init interrupt handling.
 116  *
 117  * This function is private to EAL.
 118  *
 119  * @return
 120  *  0 on success, negative on error
 121  */
 122 int rte_eal_intr_init(void);
 123
 124 /**
 125  * Init alarm mechanism. This is to allow a callback be called after
 126  * specific time.
 127  *
 128  * This function is private to EAL.
 129  *
 130  * @return
 131  *  0 on success, negative on error
 132  */
 133 int rte_eal_alarm_init(void);
 134
 135 /**
 136  * Function is to check if the kernel module(like, vfio, vfio_iommu_type1,
 137  * etc.) loaded.
 138  *
 139  * @param module_name
 140  *      The module's name which need to be checked
 141  *
 142  * @return
 143  *      -1 means some error happens(NULL pointer or open failure)
 144  *      0  means the module not loaded
 145  *      1  means the module loaded
 146  */
 147 int rte_eal_check_module(const char *module_name);
 148
 149 /**
 150  * Get virtual area of specified size from the OS.
 151  *
 152  * This function is private to the EAL.
 153  *
 154  * @param requested_addr
 155  *   Address where to request address space.
 156  * @param size
 157  *   Size of requested area.
 158  * @param page_sz
 159  *   Page size on which to align requested virtual area.
 160  * @param flags
 161  *   EAL_VIRTUAL_AREA_* flags.
 162  * @param mmap_flags
 163  *   Extra flags passed directly to mmap().
 164  *
 165  * @return
 166  *   Virtual area address if successful.
 167  *   NULL if unsuccessful.
 168  */
 169
 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.
 175  */
 176 #define EAL_VIRTUAL_AREA_UNMAP (1 << 2)
 177 /**< immediately unmap reserved virtual area. */
 178 void *
 179 eal_get_virtual_area(void *requested_addr, size_t *size,
 180                 size_t page_sz, int flags, int mmap_flags);
 181
 182 /**
 183  * Get cpu core_id.
 184  *
 185  * This function is private to the EAL.
 186  */
 187 unsigned eal_cpu_core_id(unsigned lcore_id);
 188
 189 /**
 190  * Check if cpu is present.
 191  *
 192  * This function is private to the EAL.
 193  */
 194 int eal_cpu_detected(unsigned lcore_id);
 195
 196 /**
 197  * Set TSC frequency from precise value or estimation
 198  *
 199  * This function is private to the EAL.
 200  */
 201 void set_tsc_freq(void);
 202
 203 /**
 204  * Get precise TSC frequency from system
 205  *
 206  * This function is private to the EAL.
 207  */
 208 uint64_t get_tsc_freq(void);
 209
 210 /**
 211  * Get TSC frequency if the architecture supports.
 212  *
 213  * This function is private to the EAL.
 214  *
 215  * @return
 216  *   The number of TSC cycles in one second.
 217  *   Returns zero if the architecture support is not available.
 218  */
 219 uint64_t get_tsc_freq_arch(void);
 220
 221 /**
 222  * Prepare physical memory mapping
 223  * i.e. hugepages on Linux and
 224  *      contigmem on BSD.
 225  *
 226  * This function is private to the EAL.
 227  */
 228 int rte_eal_hugepage_init(void);
 229
 230 /**
 231  * Creates memory mapping in secondary process
 232  * i.e. hugepages on Linux and
 233  *      contigmem on BSD.
 234  *
 235  * This function is private to the EAL.
 236  */
 237 int rte_eal_hugepage_attach(void);
 238
 239 /**
 240  * Find a bus capable of identifying a device.
 241  *
 242  * @param str
 243  *   A device identifier (PCI address, virtual PMD name, ...).
 244  *
 245  * @return
 246  *   A valid bus handle if found.
 247  *   NULL if no bus is able to parse this device.
 248  */
 249 struct rte_bus *rte_bus_find_by_device_name(const char *str);
 250
 251 /**
 252  * Create the unix channel for primary/secondary communication.
 253  *
 254  * @return
 255  *   0 on success;
 256  *   (<0) on failure.
 257  */
 258
 259 int rte_mp_channel_init(void);
 260
 261 /**
 262  * Internal Executes all the user application registered callbacks for
 263  * the specific device. It is for DPDK internal user only. User
 264  * application should not call it directly.
 265  *
 266  * @param device_name
 267  *  The device name.
 268  * @param event
 269  *  the device event type.
 270  */
 271 void dev_callback_process(char *device_name, enum rte_dev_event_type event);
 272
 273 /**
 274  * @internal
 275  * Parse a device string and store its information in an
 276  * rte_devargs structure.
 277  *
 278  * A device description is split by layers of abstraction of the device:
 279  * bus, class and driver. Each layer will offer a set of properties that
 280  * can be applied either to configure or recognize a device.
 281  *
 282  * This function will parse those properties and prepare the rte_devargs
 283  * to be given to each layers for processing.
 284  *
 285  * Note: if the "data" field of the devargs points to devstr,
 286  * then no dynamic allocation is performed and the rte_devargs
 287  * can be safely discarded.
 288  *
 289  * Otherwise ``data`` will hold a workable copy of devstr, that will be
 290  * used by layers descriptors within rte_devargs. In this case,
 291  * any rte_devargs should be cleaned-up before being freed.
 292  *
 293  * @param da
 294  *   rte_devargs structure to fill.
 295  *
 296  * @param devstr
 297  *   Device string.
 298  *
 299  * @return
 300  *   0 on success.
 301  *   Negative errno values on error (rte_errno is set).
 302  */
 303 int
 304 rte_devargs_layers_parse(struct rte_devargs *devargs,
 305                          const char *devstr);
 306
 307 #endif /* _EAL_PRIVATE_H_ */