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
 263  * Parse a device string and store its information in an
 264  * rte_devargs structure.
 265  *
 266  * A device description is split by layers of abstraction of the device:
 267  * bus, class and driver. Each layer will offer a set of properties that
 268  * can be applied either to configure or recognize a device.
 269  *
 270  * This function will parse those properties and prepare the rte_devargs
 271  * to be given to each layers for processing.
 272  *
 273  * Note: if the "data" field of the devargs points to devstr,
 274  * then no dynamic allocation is performed and the rte_devargs
 275  * can be safely discarded.
 276  *
 277  * Otherwise ``data`` will hold a workable copy of devstr, that will be
 278  * used by layers descriptors within rte_devargs. In this case,
 279  * any rte_devargs should be cleaned-up before being freed.
 280  *
 281  * @param da
 282  *   rte_devargs structure to fill.
 283  *
 284  * @param devstr
 285  *   Device string.
 286  *
 287  * @return
 288  *   0 on success.
 289  *   Negative errno values on error (rte_errno is set).
 290  */
 291 int
 292 rte_devargs_layers_parse(struct rte_devargs *devargs,
 293                          const char *devstr);
 294
 295 /*
 296  * probe a device at local process.
 297  *
 298  * @param devargs
 299  *   Device arguments including bus, class and driver properties.
 300  * @param new_dev
 301  *   new device be probed as output.
 302  * @return
 303  *   0 on success, negative on error.
 304  */
 305 int local_dev_probe(const char *devargs, struct rte_device **new_dev);
 306
 307 /**
 308  * Hotplug remove a given device from a specific bus at local process.
 309  *
 310  * @param dev
 311  *   Data structure of the device to remove.
 312  * @return
 313  *   0 on success, negative on error.
 314  */
 315 int local_dev_remove(struct rte_device *dev);
 316
 317 /**
 318  * Iterate over all buses to find the corresponding bus to handle the sigbus
 319  * error.
 320  * @param failure_addr
 321  *      Pointer of the fault address of the sigbus error.
 322  *
 323  * @return
 324  *       0 success to handle the sigbus.
 325  *      -1 failed to handle the sigbus
 326  *       1 no bus can handler the sigbus
 327  */
 328 int rte_bus_sigbus_handler(const void *failure_addr);
 329
 330 /**
 331  * @internal
 332  * Register the sigbus handler.
 333  *
 334  * @return
 335  *   - On success, zero.
 336  *   - On failure, a negative value.
 337  */
 338 int
 339 dev_sigbus_handler_register(void);
 340
 341 /**
 342  * @internal
 343  * Unregister the sigbus handler.
 344  *
 345  * @return
 346  *   - On success, zero.
 347  *   - On failure, a negative value.
 348  */
 349 int
 350 dev_sigbus_handler_unregister(void);
 351
 352 /**
 353  * Check if the option is registered.
 354  *
 355  * @param option
 356  *  The option to be parsed.
 357  *
 358  * @return
 359  *  0 on success
 360  * @return
 361  *  -1 on fail
 362  */
 363 int
 364 rte_option_parse(const char *opt);
 365
 366 /**
 367  * Iterate through the registered options and execute the associated
 368  * callback if enabled.
 369  */
 370 void
 371 rte_option_init(void);
 372
 373 #endif /* _EAL_PRIVATE_H_ */