env_dpdk: add copies of 22.07 pci-related header files (1eb35ac7) · Commits · Public Repositories / spdk

lib/env_dpdk/22.07/rte_bus.h

0 → 100644

+405 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: BSD-3-Clause
		* Copyright 2016 NXP
		*/

		#ifndef _RTE_BUS_H_
		#define _RTE_BUS_H_

		/**
		* @file
		*
		* DPDK device bus interface
		*
		* This file exposes API and interfaces for bus abstraction
		* over the devices and drivers in EAL.
		*/

		#ifdef __cplusplus
		extern "C" {
		#endif

		#include <stdio.h>

		#include <rte_log.h>
		#include <rte_dev.h>

		/** Double linked list of buses */
		RTE_TAILQ_HEAD(rte_bus_list, rte_bus);


		/**
		* IOVA mapping mode.
		*
		* IOVA mapping mode is iommu programming mode of a device.
		* That device (for example: IOMMU backed DMA device) based
		* on rte_iova_mode will generate physical or virtual address.
		*
		*/
		enum rte_iova_mode {
		RTE_IOVA_DC = 0, /* Don't care mode */
		RTE_IOVA_PA = (1 << 0), /* DMA using physical address */
		RTE_IOVA_VA = (1 << 1) /* DMA using virtual address */
		};

		/**
		* Bus specific scan for devices attached on the bus.
		* For each bus object, the scan would be responsible for finding devices and
		* adding them to its private device list.
		*
		* A bus should mandatorily implement this method.
		*
		* @return
		* 0 for successful scan
		* <0 for unsuccessful scan with error value
		*/
		typedef int (*rte_bus_scan_t)(void);

		/**
		* Implementation specific probe function which is responsible for linking
		* devices on that bus with applicable drivers.
		*
		* This is called while iterating over each registered bus.
		*
		* @return
		* 0 for successful probe
		* !0 for any error while probing
		*/
		typedef int (*rte_bus_probe_t)(void);

		/**
		* Device iterator to find a device on a bus.
		*
		* This function returns an rte_device if one of those held by the bus
		* matches the data passed as parameter.
		*
		* If the comparison function returns zero this function should stop iterating
		* over any more devices. To continue a search the device of a previous search
		* can be passed via the start parameter.
		*
		* @param cmp
		* Comparison function.
		*
		* @param data
		* Data to compare each device against.
		*
		* @param start
		* starting point for the iteration
		*
		* @return
		* The first device matching the data, NULL if none exists.
		*/
		typedef struct rte_device *
		(rte_bus_find_device_t)(const struct rte_device start, rte_dev_cmp_t cmp,
		const void *data);

		/**
		* Implementation specific probe function which is responsible for linking
		* devices on that bus with applicable drivers.
		*
		* @param dev
		* Device pointer that was returned by a previous call to find_device.
		*
		* @return
		* 0 on success.
		* !0 on error.
		*/
		typedef int (rte_bus_plug_t)(struct rte_device dev);

		/**
		* Implementation specific remove function which is responsible for unlinking
		* devices on that bus from assigned driver.
		*
		* @param dev
		* Device pointer that was returned by a previous call to find_device.
		*
		* @return
		* 0 on success.
		* !0 on error.
		*/
		typedef int (rte_bus_unplug_t)(struct rte_device dev);

		/**
		* Bus specific parsing function.
		* Validates the syntax used in the textual representation of a device,
		* If the syntax is valid and ``addr`` is not NULL, writes the bus-specific
		* device representation to ``addr``.
		*
		* @param[in] name
		* device textual description
		*
		* @param[out] addr
		* device information location address, into which parsed info
		* should be written. If NULL, nothing should be written, which
		* is not an error.
		*
		* @return
		* 0 if parsing was successful.
		* !0 for any error.
		*/
		typedef int (rte_bus_parse_t)(const char name, void *addr);

		/**
		* Parse bus part of the device arguments.
		*
		* The field name of the struct rte_devargs will be set.
		*
		* @param da
		* Pointer to the devargs to parse.
		*
		* @return
		* 0 on successful parsing, otherwise rte_errno is set.
		* -EINVAL: on parsing error.
		* -ENODEV: if no key matching a device argument is specified.
		* -E2BIG: device name is too long.
		*/
		typedef int (rte_bus_devargs_parse_t)(struct rte_devargs da);

		/**
		* Device level DMA map function.
		* After a successful call, the memory segment will be mapped to the
		* given device.
		*
		* @param dev
		* Device pointer.
		* @param addr
		* Virtual address to map.
		* @param iova
		* IOVA address to map.
		* @param len
		* Length of the memory segment being mapped.
		*
		* @return
		* 0 if mapping was successful.
		* Negative value and rte_errno is set otherwise.
		*/
		typedef int (rte_dev_dma_map_t)(struct rte_device dev, void *addr,
		uint64_t iova, size_t len);

		/**
		* Device level DMA unmap function.
		* After a successful call, the memory segment will no longer be
		* accessible by the given device.
		*
		* @param dev
		* Device pointer.
		* @param addr
		* Virtual address to unmap.
		* @param iova
		* IOVA address to unmap.
		* @param len
		* Length of the memory segment being mapped.
		*
		* @return
		* 0 if un-mapping was successful.
		* Negative value and rte_errno is set otherwise.
		*/
		typedef int (rte_dev_dma_unmap_t)(struct rte_device dev, void *addr,
		uint64_t iova, size_t len);

		/**
		* Implement a specific hot-unplug handler, which is responsible for
		* handle the failure when device be hot-unplugged. When the event of
		* hot-unplug be detected, it could call this function to handle
		* the hot-unplug failure and avoid app crash.
		* @param dev
		* Pointer of the device structure.
		*
		* @return
		* 0 on success.
		* !0 on error.
		*/
		typedef int (rte_bus_hot_unplug_handler_t)(struct rte_device dev);

		/**
		* Implement a specific sigbus handler, which is responsible for handling
		* the sigbus error which is either original memory error, or specific memory
		* error that caused of device be hot-unplugged. When sigbus error be captured,
		* it could call this function to handle sigbus error.
		* @param failure_addr
		* Pointer of the fault address of the sigbus error.
		*
		* @return
		* 0 for success handle the sigbus for hot-unplug.
		* 1 for not process it, because it is a generic sigbus error.
		* -1 for failed to handle the sigbus for hot-unplug.
		*/
		typedef int (rte_bus_sigbus_handler_t)(const void failure_addr);

		/**
		* Bus scan policies
		*/
		enum rte_bus_scan_mode {
		RTE_BUS_SCAN_UNDEFINED,
		RTE_BUS_SCAN_ALLOWLIST,
		RTE_BUS_SCAN_BLOCKLIST,
		};

		/**
		* A structure used to configure bus operations.
		*/
		struct rte_bus_conf {
		enum rte_bus_scan_mode scan_mode; /*< Scan policy. /
		};


		/**
		* Get common iommu class of the all the devices on the bus. The bus may
		* check that those devices are attached to iommu driver.
		* If no devices are attached to the bus. The bus may return with don't care
		* (_DC) value.
		* Otherwise, The bus will return appropriate _pa or _va iova mode.
		*
		* @return
		* enum rte_iova_mode value.
		*/
		typedef enum rte_iova_mode (*rte_bus_get_iommu_class_t)(void);


		/**
		* A structure describing a generic bus.
		*/
		struct rte_bus {
		RTE_TAILQ_ENTRY(rte_bus) next; /*< Next bus object in linked list /
		const char name; /< Name of the bus /
		rte_bus_scan_t scan; /*< Scan for devices attached to bus /
		rte_bus_probe_t probe; /*< Probe devices on bus /
		rte_bus_find_device_t find_device; /*< Find a device on the bus /
		rte_bus_plug_t plug; /*< Probe single device for drivers /
		rte_bus_unplug_t unplug; /*< Remove single device from driver /
		rte_bus_parse_t parse; /*< Parse a device name /
		rte_bus_devargs_parse_t devargs_parse; /*< Parse bus devargs /
		rte_dev_dma_map_t dma_map; /*< DMA map for device in the bus /
		rte_dev_dma_unmap_t dma_unmap; /*< DMA unmap for device in the bus /
		struct rte_bus_conf conf; /*< Bus configuration /
		rte_bus_get_iommu_class_t get_iommu_class; /*< Get iommu class /
		rte_dev_iterate_t dev_iterate; /*< Device iterator. /
		rte_bus_hot_unplug_handler_t hot_unplug_handler;
		/*< handle hot-unplug failure on the bus /
		rte_bus_sigbus_handler_t sigbus_handler;
		/*< handle sigbus error on the bus /

		};

		/**
		* Register a Bus handler.
		*
		* @param bus
		* A pointer to a rte_bus structure describing the bus
		* to be registered.
		*/
		void rte_bus_register(struct rte_bus *bus);

		/**
		* Unregister a Bus handler.
		*
		* @param bus
		* A pointer to a rte_bus structure describing the bus
		* to be unregistered.
		*/
		void rte_bus_unregister(struct rte_bus *bus);

		/**
		* Scan all the buses.
		*
		* @return
		* 0 in case of success in scanning all buses
		* !0 in case of failure to scan
		*/
		int rte_bus_scan(void);

		/**
		* For each device on the buses, perform a driver 'match' and call the
		* driver-specific probe for device initialization.
		*
		* @return
		* 0 for successful match/probe
		* !0 otherwise
		*/
		int rte_bus_probe(void);

		/**
		* Dump information of all the buses registered with EAL.
		*
		* @param f
		* A valid and open output stream handle
		*/
		void rte_bus_dump(FILE *f);

		/**
		* Bus comparison function.
		*
		* @param bus
		* Bus under test.
		*
		* @param data
		* Data to compare against.
		*
		* @return
		* 0 if the bus matches the data.
		* !0 if the bus does not match.
		* <0 if ordering is possible and the bus is lower than the data.
		* >0 if ordering is possible and the bus is greater than the data.
		*/
		typedef int (rte_bus_cmp_t)(const struct rte_bus bus, const void *data);

		/**
		* Bus iterator to find a particular bus.
		*
		* This function compares each registered bus to find one that matches
		* the data passed as parameter.
		*
		* If the comparison function returns zero this function will stop iterating
		* over any more buses. To continue a search the bus of a previous search can
		* be passed via the start parameter.
		*
		* @param start
		* Starting point for the iteration.
		*
		* @param cmp
		* Comparison function.
		*
		* @param data
		* Data to pass to comparison function.
		*
		* @return
		* A pointer to a rte_bus structure or NULL in case no bus matches
		*/
		struct rte_bus rte_bus_find(const struct rte_bus start, rte_bus_cmp_t cmp,
		const void *data);

		/**
		* Find the registered bus for a particular device.
		*/
		struct rte_bus rte_bus_find_by_device(const struct rte_device dev);

		/**
		* Find the registered bus for a given name.
		*/
		struct rte_bus rte_bus_find_by_name(const char busname);


		/**
		* Get the common iommu class of devices bound on to buses available in the
		* system. RTE_IOVA_DC means that no preference has been expressed.
		*
		* @return
		* enum rte_iova_mode value.
		*/
		enum rte_iova_mode rte_bus_get_iommu_class(void);

		/**
		* Helper for Bus registration.
		* The constructor has higher priority than PMD constructors.
		*/
		#define RTE_REGISTER_BUS(nm, bus) \
		RTE_INIT_PRIO(businitfn_ ##nm, BUS) \
		{\
		(bus).name = RTE_STR(nm);\
		rte_bus_register(&bus); \
		}

		#ifdef __cplusplus
		}
		#endif

		#endif /* _RTE_BUS_H */

lib/env_dpdk/22.07/rte_bus_pci.h

0 → 100644

+398 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: BSD-3-Clause
		* Copyright(c) 2010-2015 Intel Corporation.
		* Copyright 2013-2014 6WIND S.A.
		*/

		#ifndef _RTE_BUS_PCI_H_
		#define _RTE_BUS_PCI_H_

		/**
		* @file
		* PCI device & driver interface
		*/

		#ifdef __cplusplus
		extern "C" {
		#endif

		#include <stdio.h>
		#include <stdlib.h>
		#include <limits.h>
		#include <errno.h>
		#include <stdint.h>
		#include <inttypes.h>

		#include <rte_debug.h>
		#include <rte_interrupts.h>
		#include <rte_dev.h>
		#include <rte_bus.h>
		#include <rte_pci.h>

		/** Pathname of PCI devices directory. */
		const char *rte_pci_get_sysfs_path(void);

		/* Forward declarations */
		struct rte_pci_device;
		struct rte_pci_driver;

		/** List of PCI devices */
		RTE_TAILQ_HEAD(rte_pci_device_list, rte_pci_device);
		/** List of PCI drivers */
		RTE_TAILQ_HEAD(rte_pci_driver_list, rte_pci_driver);

		/* PCI Bus iterators */
		#define FOREACH_DEVICE_ON_PCIBUS(p) \
		RTE_TAILQ_FOREACH(p, &(rte_pci_bus.device_list), next)

		#define FOREACH_DRIVER_ON_PCIBUS(p) \
		RTE_TAILQ_FOREACH(p, &(rte_pci_bus.driver_list), next)

		struct rte_devargs;

		enum rte_pci_kernel_driver {
		RTE_PCI_KDRV_UNKNOWN = 0, /* may be misc UIO or bifurcated driver */
		RTE_PCI_KDRV_IGB_UIO, /* igb_uio for Linux */
		RTE_PCI_KDRV_VFIO, /* VFIO for Linux */
		RTE_PCI_KDRV_UIO_GENERIC, /* uio_pci_generic for Linux */
		RTE_PCI_KDRV_NIC_UIO, /* nic_uio for FreeBSD */
		RTE_PCI_KDRV_NONE, /* no attached driver */
		RTE_PCI_KDRV_NET_UIO, /* NetUIO for Windows */
		};

		/**
		* A structure describing a PCI device.
		*/
		struct rte_pci_device {
		RTE_TAILQ_ENTRY(rte_pci_device) next; /*< Next probed PCI device. /
		struct rte_device device; /*< Inherit core device /
		struct rte_pci_addr addr; /*< PCI location. /
		struct rte_pci_id id; /*< PCI ID. /
		struct rte_mem_resource mem_resource[PCI_MAX_RESOURCE];
		/*< PCI Memory Resource /
		struct rte_intr_handle intr_handle; /< Interrupt handle /
		struct rte_pci_driver driver; /< PCI driver used in probing /
		uint16_t max_vfs; /*< sriov enable if not zero /
		enum rte_pci_kernel_driver kdrv; /*< Kernel driver passthrough /
		char name[PCI_PRI_STR_SIZE+1]; /*< PCI location (ASCII) /
		struct rte_intr_handle *vfio_req_intr_handle;
		/*< Handler of VFIO request interrupt /
		};

		/**
		* @internal
		* Helper macro for drivers that need to convert to struct rte_pci_device.
		*/
		#define RTE_DEV_TO_PCI(ptr) container_of(ptr, struct rte_pci_device, device)

		#define RTE_DEV_TO_PCI_CONST(ptr) \
		container_of(ptr, const struct rte_pci_device, device)

		#define RTE_ETH_DEV_TO_PCI(eth_dev) RTE_DEV_TO_PCI((eth_dev)->device)

		#ifdef __cplusplus
		/** C++ macro used to help building up tables of device IDs */
		#define RTE_PCI_DEVICE(vend, dev) \
		RTE_CLASS_ANY_ID, \
		(vend), \
		(dev), \
		RTE_PCI_ANY_ID, \
		RTE_PCI_ANY_ID
		#else
		/** Macro used to help building up tables of device IDs */
		#define RTE_PCI_DEVICE(vend, dev) \
		.class_id = RTE_CLASS_ANY_ID, \
		.vendor_id = (vend), \
		.device_id = (dev), \
		.subsystem_vendor_id = RTE_PCI_ANY_ID, \
		.subsystem_device_id = RTE_PCI_ANY_ID
		#endif

		/**
		* Initialisation function for the driver called during PCI probing.
		*/
		typedef int (rte_pci_probe_t)(struct rte_pci_driver , struct rte_pci_device );

		/**
		* Uninitialisation function for the driver called during hotplugging.
		*/
		typedef int (rte_pci_remove_t)(struct rte_pci_device *);

		/**
		* Driver-specific DMA mapping. After a successful call the device
		* will be able to read/write from/to this segment.
		*
		* @param dev
		* Pointer to the PCI device.
		* @param addr
		* Starting virtual address of memory to be mapped.
		* @param iova
		* Starting IOVA address of memory to be mapped.
		* @param len
		* Length of memory segment being mapped.
		* @return
		* - 0 On success.
		* - Negative value and rte_errno is set otherwise.
		*/
		typedef int (pci_dma_map_t)(struct rte_pci_device dev, void addr,
		uint64_t iova, size_t len);

		/**
		* Driver-specific DMA un-mapping. After a successful call the device
		* will not be able to read/write from/to this segment.
		*
		* @param dev
		* Pointer to the PCI device.
		* @param addr
		* Starting virtual address of memory to be unmapped.
		* @param iova
		* Starting IOVA address of memory to be unmapped.
		* @param len
		* Length of memory segment being unmapped.
		* @return
		* - 0 On success.
		* - Negative value and rte_errno is set otherwise.
		*/
		typedef int (pci_dma_unmap_t)(struct rte_pci_device dev, void addr,
		uint64_t iova, size_t len);

		/**
		* A structure describing a PCI driver.
		*/
		struct rte_pci_driver {
		RTE_TAILQ_ENTRY(rte_pci_driver) next; /*< Next in list. /
		struct rte_driver driver; /*< Inherit core driver. /
		struct rte_pci_bus bus; /< PCI bus reference. /
		rte_pci_probe_t probe; /< Device probe function. /
		rte_pci_remove_t remove; /< Device remove function. /
		pci_dma_map_t dma_map; /< device dma map function. /
		pci_dma_unmap_t dma_unmap; /< device dma unmap function. /
		const struct rte_pci_id id_table; /< ID table, NULL terminated. /
		uint32_t drv_flags; /*< Flags RTE_PCI_DRV_. */
		};

		/**
		* Structure describing the PCI bus
		*/
		struct rte_pci_bus {
		struct rte_bus bus; /*< Inherit the generic class /
		struct rte_pci_device_list device_list; /*< List of PCI devices /
		struct rte_pci_driver_list driver_list; /*< List of PCI drivers /
		};

		/** Device needs PCI BAR mapping (done with either IGB_UIO or VFIO) */
		#define RTE_PCI_DRV_NEED_MAPPING 0x0001
		/** Device needs PCI BAR mapping with enabled write combining (wc) */
		#define RTE_PCI_DRV_WC_ACTIVATE 0x0002
		/** Device already probed can be probed again to check for new ports. */
		#define RTE_PCI_DRV_PROBE_AGAIN 0x0004
		/** Device driver supports link state interrupt */
		#define RTE_PCI_DRV_INTR_LSC 0x0008
		/** Device driver supports device removal interrupt */
		#define RTE_PCI_DRV_INTR_RMV 0x0010
		/** Device driver needs to keep mapped resources if unsupported dev detected */
		#define RTE_PCI_DRV_KEEP_MAPPED_RES 0x0020
		/** Device driver needs IOVA as VA and cannot work with IOVA as PA */
		#define RTE_PCI_DRV_NEED_IOVA_AS_VA 0x0040

		/**
		* Map the PCI device resources in user space virtual memory address
		*
		* Note that driver should not call this function when flag
		* RTE_PCI_DRV_NEED_MAPPING is set, as EAL will do that for
		* you when it's on.
		*
		* @param dev
		* A pointer to a rte_pci_device structure describing the device
		* to use
		*
		* @return
		* 0 on success, negative on error and positive if no driver
		* is found for the device.
		*/
		int rte_pci_map_device(struct rte_pci_device *dev);

		/**
		* Unmap this device
		*
		* @param dev
		* A pointer to a rte_pci_device structure describing the device
		* to use
		*/
		void rte_pci_unmap_device(struct rte_pci_device *dev);

		/**
		* Dump the content of the PCI bus.
		*
		* @param f
		* A pointer to a file for output
		*/
		void rte_pci_dump(FILE *f);

		/**
		* Find device's extended PCI capability.
		*
		* @param dev
		* A pointer to rte_pci_device structure.
		*
		* @param cap
		* Extended capability to be found, which can be any from
		* RTE_PCI_EXT_CAP_ID_*, defined in librte_pci.
		*
		* @return
		* > 0: The offset of the next matching extended capability structure
		* within the device's PCI configuration space.
		* < 0: An error in PCI config space read.
		* = 0: Device does not support it.
		*/
		__rte_experimental
		off_t rte_pci_find_ext_capability(struct rte_pci_device *dev, uint32_t cap);

		/**
		* Enables/Disables Bus Master for device's PCI command register.
		*
		* @param dev
		* A pointer to rte_pci_device structure.
		* @param enable
		* Enable or disable Bus Master.
		*
		* @return
		* 0 on success, -1 on error in PCI config space read/write.
		*/
		__rte_experimental
		int rte_pci_set_bus_master(struct rte_pci_device *dev, bool enable);

		/**
		* Register a PCI driver.
		*
		* @param driver
		* A pointer to a rte_pci_driver structure describing the driver
		* to be registered.
		*/
		void rte_pci_register(struct rte_pci_driver *driver);

		/** Helper for PCI device registration from driver (eth, crypto) instance */
		#define RTE_PMD_REGISTER_PCI(nm, pci_drv) \
		RTE_INIT(pciinitfn_ ##nm) \
		{\
		(pci_drv).driver.name = RTE_STR(nm);\
		rte_pci_register(&pci_drv); \
		} \
		RTE_PMD_EXPORT_NAME(nm, __COUNTER__)

		/**
		* Unregister a PCI driver.
		*
		* @param driver
		* A pointer to a rte_pci_driver structure describing the driver
		* to be unregistered.
		*/
		void rte_pci_unregister(struct rte_pci_driver *driver);

		/**
		* Read PCI config space.
		*
		* @param device
		* A pointer to a rte_pci_device structure describing the device
		* to use
		* @param buf
		* A data buffer where the bytes should be read into
		* @param len
		* The length of the data buffer.
		* @param offset
		* The offset into PCI config space
		* @return
		* Number of bytes read on success, negative on error.
		*/
		int rte_pci_read_config(const struct rte_pci_device *device,
		void *buf, size_t len, off_t offset);

		/**
		* Write PCI config space.
		*
		* @param device
		* A pointer to a rte_pci_device structure describing the device
		* to use
		* @param buf
		* A data buffer containing the bytes should be written
		* @param len
		* The length of the data buffer.
		* @param offset
		* The offset into PCI config space
		*/
		int rte_pci_write_config(const struct rte_pci_device *device,
		const void *buf, size_t len, off_t offset);

		/**
		* A structure used to access io resources for a pci device.
		* rte_pci_ioport is arch, os, driver specific, and should not be used outside
		* of pci ioport api.
		*/
		struct rte_pci_ioport {
		struct rte_pci_device *dev;
		uint64_t base;
		uint64_t len; /* only filled for memory mapped ports */
		};

		/**
		* Initialize a rte_pci_ioport object for a pci device io resource.
		*
		* This object is then used to gain access to those io resources (see below).
		*
		* @param dev
		* A pointer to a rte_pci_device structure describing the device
		* to use.
		* @param bar
		* Index of the io pci resource we want to access.
		* @param p
		* The rte_pci_ioport object to be initialized.
		* @return
		* 0 on success, negative on error.
		*/
		int rte_pci_ioport_map(struct rte_pci_device *dev, int bar,
		struct rte_pci_ioport *p);

		/**
		* Release any resources used in a rte_pci_ioport object.
		*
		* @param p
		* The rte_pci_ioport object to be uninitialized.
		* @return
		* 0 on success, negative on error.
		*/
		int rte_pci_ioport_unmap(struct rte_pci_ioport *p);

		/**
		* Read from a io pci resource.
		*
		* @param p
		* The rte_pci_ioport object from which we want to read.
		* @param data
		* A data buffer where the bytes should be read into
		* @param len
		* The length of the data buffer.
		* @param offset
		* The offset into the pci io resource.
		*/
		void rte_pci_ioport_read(struct rte_pci_ioport *p,
		void *data, size_t len, off_t offset);

		/**
		* Write to a io pci resource.
		*
		* @param p
		* The rte_pci_ioport object to which we want to write.
		* @param data
		* A data buffer where the bytes should be read into
		* @param len
		* The length of the data buffer.
		* @param offset
		* The offset into the pci io resource.
		*/
		void rte_pci_ioport_write(struct rte_pci_ioport *p,
		const void *data, size_t len, off_t offset);

		#ifdef __cplusplus
		}
		#endif

		#endif /* _RTE_BUS_PCI_H_ */

lib/env_dpdk/22.07/rte_dev.h

0 → 100644

+499 −0

File added.

Preview size limit exceeded, changes collapsed.

lib/env_dpdk/pci_dpdk_2207.c

+3 −1

Original line number	Diff line number	Diff line
		@@ -6,7 +6,9 @@
		#include <rte_config.h>
		#include <rte_version.h>
		#include "pci_dpdk.h"
		#include <rte_bus_pci.h>
		#include "22.07/rte_dev.h"
		#include "22.07/rte_bus.h"
		#include "22.07/rte_bus_pci.h"
		#include "spdk/assert.h"

		SPDK_STATIC_ASSERT(offsetof(struct spdk_pci_driver, driver_buf) == 0, "driver_buf must be first");

scripts/check_format.sh

+5 −2

Original line number	Diff line number	Diff line
		@@ -126,7 +126,8 @@ function check_c_style() {
		else
		rm -f astyle.log
		touch astyle.log
		git ls-files '*.[ch]' \
		# Exclude DPDK header files copied into our tree
		git ls-files '.[ch]' ':!:/env_dpdk//.h' \
		\| xargs -P$(nproc) -n10 astyle --break-return-type --attach-return-type-decl \
		--options=.astylerc >> astyle.log
		git ls-files '.cpp' '.cc' '.cxx' '.hh' '*.hpp' \
		@@ -268,7 +269,9 @@ function check_posix_includes() {
		local rc=0

		echo -n "Checking for POSIX includes..."
		git grep -I -i -f scripts/posix.txt -- './' ':!include/spdk/stdinc.h' ':!include/linux/' ':!scripts/posix.txt' ':!.patch' ':!configure' > scripts/posix.log \|\| true
		git grep -I -i -f scripts/posix.txt -- './*' ':!include/spdk/stdinc.h' \
		':!include/linux/*' ':!scripts/posix.txt' ':!lib/env_dpdk//*.h' \
		':!*.patch' ':!configure' > scripts/posix.log \|\| true
		if [ -s scripts/posix.log ]; then
		echo "POSIX includes detected. Please include spdk/stdinc.h instead."
		cat scripts/posix.log

Admin message