dlb2: introduce DLB 2.0 device driver
Subsystems (3)
v3 cover dlb2: introduce DLB 2.0 device driver
This commit introduces a new misc device driver for the Intel(r) Dynamic Load Balancer 2.0 (Intel(r) DLB 2.0). The Intel DLB 2.0 is a PCIe device that provides load-balanced, prioritized scheduling of core-to-core communication.
The Intel DLB 2.0 consists of queues and arbiters that connect producer cores and consumer cores. The device implements load-balanced queueing features including:
- Lock-free multi-producer/multi-consumer operation.
- Multiple priority levels for varying traffic types.
- 'Direct' traffic (i.e. multi-producer/single-consumer)
- Simple unordered load-balanced distribution.
- Atomic lock free load balancing across multiple consumers.
- Queue element reordering feature allowing ordered load-balanced distribution.
Intel DLB 2.0 can be used in an event-driven programming model, such as DPDK's Event Device Library[2]. Such frameworks are commonly used in packet processing pipelines that benefit from the framework's multi-core scalability, dynamic load-balancing, and variety of packet distribution and synchronization schemes.
These distribution schemes include "parallel" (packets are load-balanced across multiple cores and processed in parallel), "ordered" (similar to "parallel" but packets are reordered into ingress order by the device), and "atomic" (packet flows are scheduled to a single core at a time such that locks are not required to access per-flow data, and dynamically migrated to ensure load-balance).
The fundamental unit of communication through the device is a queue entry (QE), which consists of 8B of data and 8B of metadata (destination queue, priority, etc.). The data field can be any type that fits within 8B.
A core's interface to the device, a "port," consists of a memory-mappable region through which the core enqueues a queue entry, and an in-memory queue (the "consumer queue") to which the device schedules QEs. Each QE is enqueued to a device-managed queue, and from there scheduled to a port. Software specifies the "linking" of queues and ports; i.e. which ports the device is allowed to schedule to for a given queue. The device uses a credit scheme to prevent overflow of the on-device queue storage.
Applications can interface directly with the device by mapping the port's memory and MMIO regions into the application's address space for enqueue and dequeue operations, but call into the kernel driver for configuration operations. An application can also be polling- or interrupt-driven; Intel DLB 2.0 supports both modes of operation.
Device resources -- i.e. ports, queues, and credits -- are contained within a scheduling domain. Scheduling domains are isolated from one another; a port can only enqueue to and dequeue from queues within its scheduling domain. A scheduling domain's resources are configured through a scheduling domain file, which is acquired through an ioctl.
Intel DLB 2.0 supports SR-IOV and Scalable IOV, and allows for a flexible division of its resources among the PF and its virtual devices. The virtual devices are incapable of configuring the device directly; they use a hardware mailbox to proxy configuration requests to the PF driver. This driver supports both PF and virtual devices, as there is significant code re-use between the two, with device-specific behavior handled through a callback interface. Virtualization support will be added in a later patch set.
The dlb driver uses ioctls as its primary interface (it makes use of sysfs as well, to a lesser extent). The dlb device file supports a different ioctl interface than the scheduling domain file; the dlb device file is used for device-wide operations (including scheduling domain creation), and the scheduling domain file supports operations on the scheduling domain's resources (primarily resource configuration).
[1] https://builders.intel.com/docs/networkbuilders/SKU-343247-001US-queue-management-and-load-balancing-on-intel-architecture.pdf
[2] https://doc.dpdk.org/guides/prog_guide/eventdev.html
v3:
- Remove DLB2_PCI_REG_READ/WRITE macros
v2:
- Change driver license to GPLv2 only
- Expand Kconfig help text and remove unnecessary (R)s
- Remove unnecessary prints
- Add a new entry in ioctl-number.rst
- Convert the ioctl handler into a switch statement
- Correct some instances of IOWR that should have been IOR
- Align macro blocks
- Don't break ioctl ABI when introducing new commands
- Remove indirect pointers from ioctl data structures
- Remove the get-sched-domain-fd ioctl command
Gage Eads (19):
dlb2: add skeleton for DLB 2.0 driver
dlb2: initialize PF device
dlb2: add resource and device initialization
dlb2: add device ioctl layer and first three ioctls
dlb2: add sched domain config and reset support
dlb2: add runtime power-management support
dlb2: add queue create and queue-depth-get ioctls
dlb2: add ioctl to configure ports, query poll mode
dlb2: add port mmap support
dlb2: add start domain ioctl
dlb2: add queue map and unmap ioctls
dlb2: add port enable/disable ioctls
dlb2: add CQ interrupt support
dlb2: add domain alert support
dlb2: add sequence-number management ioctls
dlb2: add cos bandwidth get/set ioctls
dlb2: add device FLR support
dlb2: add basic PF sysfs interfaces
dlb2: add ingress error handling
Documentation/ABI/testing/sysfs-driver-dlb2 | 202 + Documentation/misc-devices/dlb2.rst | 310 + Documentation/misc-devices/index.rst | 1 + Documentation/userspace-api/ioctl/ioctl-number.rst | 1 + MAINTAINERS | 7 + drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + drivers/misc/dlb2/Kconfig | 17 + drivers/misc/dlb2/Makefile | 13 + drivers/misc/dlb2/dlb2_bitmap.h | 286 + drivers/misc/dlb2/dlb2_file.c | 133 + drivers/misc/dlb2/dlb2_file.h | 19 + drivers/misc/dlb2/dlb2_hw_types.h | 353 + drivers/misc/dlb2/dlb2_intr.c | 137 + drivers/misc/dlb2/dlb2_intr.h | 30 + drivers/misc/dlb2/dlb2_ioctl.c | 892 +++ drivers/misc/dlb2/dlb2_ioctl.h | 14 + drivers/misc/dlb2/dlb2_main.c | 1091 +++ drivers/misc/dlb2/dlb2_main.h | 285 + drivers/misc/dlb2/dlb2_pf_ops.c | 1286 ++++ drivers/misc/dlb2/dlb2_regs.h | 3702 ++++++++++ drivers/misc/dlb2/dlb2_resource.c | 7117 ++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 924 +++ include/linux/pci_ids.h | 2 + include/uapi/linux/dlb2_user.h | 1045 +++ 25 files changed, 17869 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-driver-dlb2 create mode 100644 Documentation/misc-devices/dlb2.rst create mode 100644 drivers/misc/dlb2/Kconfig create mode 100644 drivers/misc/dlb2/Makefile create mode 100644 drivers/misc/dlb2/dlb2_bitmap.h create mode 100644 drivers/misc/dlb2/dlb2_file.c create mode 100644 drivers/misc/dlb2/dlb2_file.h create mode 100644 drivers/misc/dlb2/dlb2_hw_types.h create mode 100644 drivers/misc/dlb2/dlb2_intr.c create mode 100644 drivers/misc/dlb2/dlb2_intr.h create mode 100644 drivers/misc/dlb2/dlb2_ioctl.c create mode 100644 drivers/misc/dlb2/dlb2_ioctl.h create mode 100644 drivers/misc/dlb2/dlb2_main.c create mode 100644 drivers/misc/dlb2/dlb2_main.h create mode 100644 drivers/misc/dlb2/dlb2_pf_ops.c create mode 100644 drivers/misc/dlb2/dlb2_regs.h create mode 100644 drivers/misc/dlb2/dlb2_resource.c create mode 100644 drivers/misc/dlb2/dlb2_resource.h create mode 100644 include/uapi/linux/dlb2_user.h
base-commit: dd5597245d35cfbb0890b8a868028aa1d2018701
Signature · 1 line
2.13.6
PATCH v3 1/19 dlb2: add skeleton for DLB 2.0 driver
This initial commit contains basic driver functionality (load, unload, probe, and remove callbacks) file_operations stubs, and device documentation as well.
--- Documentation/misc-devices/dlb2.rst | 310 +++++++++++++++++++++++++++++++++++ Documentation/misc-devices/index.rst | 1 + MAINTAINERS | 7 + drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + drivers/misc/dlb2/Kconfig | 17 ++ drivers/misc/dlb2/Makefile | 8 + drivers/misc/dlb2/dlb2_hw_types.h | 29 ++++ drivers/misc/dlb2/dlb2_main.c | 208 +++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.h | 37 +++++ include/linux/pci_ids.h | 2 + 11 files changed, 621 insertions(+) create mode 100644 Documentation/misc-devices/dlb2.rst create mode 100644 drivers/misc/dlb2/Kconfig create mode 100644 drivers/misc/dlb2/Makefile create mode 100644 drivers/misc/dlb2/dlb2_hw_types.h create mode 100644 drivers/misc/dlb2/dlb2_main.c create mode 100644 drivers/misc/dlb2/dlb2_main.h
Documentation/misc-devices/dlb2.rst new file +310 -0
@@ -0,0 +1,310 @@ +.. SPDX-License-Identifier: GPL-2.0-only + +=========================================== +Intel(R) Dynamic Load Balancer 2.0 Overview +=========================================== + +:Author: Gage Eads + +Contents +======== + +- Introduction +- Scheduling +- Queue Entry +- Port +- Queue +- Credits +- Scheduling Domain +- Interrupts +- Power Management +- Virtualization +- User Interface +- Reset + +Introduction +============ + +The Intel(r) Dynamic Load Balancer 2.0 (Intel(r) DLB 2.0) is a PCIe device that +provides load-balanced, prioritized scheduling of core-to-core communication. + +The Intel DLB 2.0 device consists of queues and arbiters that connect producer +cores and consumer cores. The device implements load-balanced queueing features +including: +- Lock-free multi-producer/multi-consumer operation. +- Multiple priority levels for varying traffic types. +- 'Direct' traffic (i.e. multi-producer/single-consumer) +- Simple unordered load-balanced distribution. +- Atomic lock free load balancing across multiple consumers. +- Queue element reordering feature allowing ordered load-balanced distribution. + +Intel DLB 2.0 can be used in an event-driven programming model, such as DPDK's +Event Device Library[2]. Such frameworks are commonly used in packet processing +pipelines that benefit from the framework's multi-core scalability, dynamic +load-balancing, and variety of packet distribution and synchronization schemes. + +Scheduling Types +================ + +Intel DLB 2.0 supports four types of scheduling of 'events' (using DPDK +terminology), where an event can represent any type of data (e.g. a network +packet). The first, ``directed``, is multi-producer/single-consumer style +core-to-core communication. The remaining three are +multi-producer/multi-consumer, and support load-balancing across the consumers. + +- ``Unordered``: events are load-balanced across consumers without any ordering + guarantees. + +- ``Ordered``: events are load-balanced across consumers, and when the consumer + re-injects each event into the device it is re-ordered into the + original order. This scheduling type allows software to + parallelize ordered event processing without the synchronization + cost of re-ordering packets. + +- ``Atomic``: events are load-balanced across consumers, with the guarantee that + events from a particular 'flow' are only scheduled to a single + consumer at a time (but can migrate over time). This allows, for + example, packet processing applications to parallelize while + avoiding locks on per-flow data and maintaining ordering within a + flow. + +Intel DLB 2.0 provides hierarchical priority scheduling, with eight priority +levels within each. Each consumer selects up to eight queues to receive events +from, and assigns a priority to each of these 'connected' queues. To schedule +an event to a consumer, the device selects the highest priority non-empty queue +of the (up to) eight connected queues. Within that queue, the device selects +the highest priority event available (selecting a lower priority event for +starvation avoidance 1% of the time, by default). + +The device also supports four load-balanced scheduler classes of service. Each +class of service receives a (user-configurable) guaranteed percentage of the +scheduler bandwidth, and any unreserved bandwidth is divided evenly among the +four classes. + +Queue Entry +=========== + +Each event is contained in a queue entry (QE), the fundamental unit of +communication through the device, which consists of 8B of data and 8B of +metadata, as depicted below. + +QE structure format +:: + data :64 + opaque :16 + qid :8 + sched :2 + priority :3 + msg_type :3 + lock_id :16 + rsvd :8 + cmd :8 + +The ``data`` field can be any type that fits within 8B (pointer, integer, +etc.); DLB 2.0 merely copies this field from producer to consumer. The +``opaque`` and ``msg_type`` fields behave the same way. + +``qid`` is set by the producer to specify to which DLB 2.0 queue it wishes to +enqueue this QE. The ID spaces for load-balanced and directed queues are both +zero-based; the ``sched`` field is used to distinguish whether the queue is +load-balanced or directed. + +``sched`` controls the scheduling type: atomic, unordered, ordered, or +directed. The first three scheduling types are only valid for load-balanced +queues, and the directed scheduling type is only valid for directed queues. + +``priority`` is the priority with which this QE should be scheduled. + +``lock_id``, used only by atomic scheduling, identifies the atomic flow to +which the QE belongs. When sending a directed event, ``lock_id`` is simply +copied like the ``data``, ``opaque``, and ``msg_type`` fields. + +``cmd`` specifies the operation, such as: +- Enqueue a new QE +- Forward a QE that was dequeued +- Complete/terminate a QE that was dequeued +- Return one or more consumer queue tokens. +- Arm the port's consumer queue interrupt. + +Port +==== + +A core's interface to the DLB 2.0 is called a "port," and consists of an MMIO +region through which the core enqueues a queue entry, and an in-memory queue +(the "consumer queue") to which the device schedules QEs. A core enqueues a QE +to a device queue, then the device schedules the event to a port. Software +specifies the connection of queues and ports; i.e. for each queue, to which +ports the device is allowed to schedule its events. The device uses a credit +scheme to prevent overflow of the on-device queue storage. + +Applications interface directly with the device by mapping the port's memory +and MMIO regions into the application's address space for enqueue and dequeue +operations, but call into the kernel driver for configuration operations. An +application can also be polling- or interrupt-driven; DLB 2.0 supports both +modes of operation. + +Queue +===== + +The device contains 32 load-balanced (i.e. capable of atomic, ordered, and +unordered scheduling) queues and 64 directed queues. Each queue comprises 8 +internal queues, one per priority level. The internal queue that an event is +enqueued to is selected by the event's priority field. + +A load-balanced queue is capable of scheduling its events to any combination of +load-balanced ports, whereas each directed queue has one-to-one mapping with a +directed port. There is no restriction on port or queue types when a port +enqueues an event to a queue; that is, a load-balanced port can enqueue to a +directed queue and vice versa. + +Credits +======= + +The Intel DLB 2.0 uses a credit scheme to prevent overflow of the on-device +queue storage, with separate credits for load-balanced and directed queues. A +port spends one credit when it enqueues a QE, and one credit is replenished +when a QE is scheduled to a consumer queue. Each scheduling domain has one pool +of load-balanced credits and one pool of directed credits; software is +responsible for managing the allocation and replenishment of these credits among +the scheduling domain's ports. + +Scheduling Domain +================= + +Device resources -- including ports, queues, and credits -- are contained +within a scheduling domain. Scheduling domains are isolated from one another; a +port can only enqueue to and dequeue from queues within its scheduling domain. + +The scheduling domain creation ioctl returns a domain file descriptor, through +which the domain's resources are configured. For a multi-process scenario, the +owner of this descriptor must share it with the other processes (e.g. inherited +through fork() or shared over a unix domain socket). + +Consumer Queue Interrupts +========================= + +Each port has its own interrupt which fires, if armed, when the consumer queue +depth becomes non-zero. Software arms an interrupt by enqueueing a special +'interrupt arm' command to the device through the port's MMIO window. + +Power Management +================ + +The kernel driver keeps the device in D3Hot when not in use. The driver +transitions the device to D0 when the first device file is opened or a virtual +function is created, and keeps it there until there are no open device files, +memory mappings, or virtual functions. + +Virtualization +============== + +The DLB 2.0 supports both SR-IOV and Scalable IOV, and can flexibly divide its +resources among the physical function (PF) and its virtual devices. Virtual +devices do not configure the device directly; they use a hardware mailbox to +proxy configuration requests to the PF driver. Mailbox communication is +initiated by the virtual device with a registration message that establishes +the mailbox interface version. + +SR-IOV +------ + +Each SR-IOV virtual function (VF) has 32 interrupts, 1 for PF->VF mailbox +messages and the remainder for CQ interrupts. If a VF user (e.g. a guest OS) +needs more CQ interrupts, they have to use more than one VF. + +To support this case, the driver introduces the notion of primary and auxiliary +VFs. A VF is either considered primary or auxiliary: +- Primary: the VF is used as a regular DLB 2.0 device. The primary VF has 0+ + auxiliary VFs supporting it. +- Auxiliary: the VF doesn't have any resources of its own, and serves only to + provide the primary VF with MSI vectors for its CQ interrupts. + +Each VF has an aux_vf_ids file in its sysfs directory, which is a R/W file that +controls the primary VF’s auxiliaries. When a VF is made auxiliary to another, +its resources are relinquished to the PF device. + +When the VF driver registers its device with the PF driver, the PF driver tells +the VF driver whether its device is auxiliary or primary, and if so then the ID +of its primary VF. If it is auxiliary, the VF device will “claim” up to 31 of +the primary VF’s CQs, such that they use the auxiliary VF’s MSI vectors. + +When a primary VF has one or more auxiliary VFs, the entire VF group must be +assigned to the same virtual machine. The PF driver will not allow the primary +VF to configure its resources until all its auxiliary VFs have been registered +by the guest OS’s driver. + +Scalable IOV +------------ + +Scalable IOV is a virtualization solution that, compared to SR-IOV, enables +highly-scalable, high-performance, and fine-grained sharing of I/O devices +across isolated domains. + +In Scalable IOV, the smallest granularity of sharing a device is the Assignable Device +Interface (ADI). Similar to SR-IOV’s Virtual Function, Scalable IOV defines the +Virtual Device (VDEV) as the abstraction at which a Scalable IOV device is exposed to +guest software, and a VDEV contains one or more ADIs. + +Kernel software is responsible for composing and managing VDEV instances in +Scalable IOV. The device-specific software components are the Host (PF) Driver, +the Guest (VDEV) Driver, and the Virtual Device Composition Module (VDCM). The +VDCM is responsible for managing the software-based virtualization of (slow) +control path operations, like the mailbox between Host and Guest drivers. + +For DLB 2.0, the ADI is the scheduling domain, which consists of load-balanced +and directed queues, ports, and other resources. Each port, whether +load-balanced or directed, consists of: +- A producer port: a 4-KB separated MMIO window +- A consumer queue: a memory-based ring to which the device writes queue entries +- One CQ interrupt message + +DLB 2.0 supports up to 16 VDEVs per PF. + +For Scalable IOV guest-host communication, DLB 2.0 uses a software-based +mailbox. This mailbox interface matches the SR-IOV hardware mailbox (i.e. PF2VF +and VF2PF MMIO regions) except that it is backed by shared memory (allocated +and managed by the VDCM). Similarly, the VF2PF interrupt trigger register +instead causes a VM exit into the VDCM driver, and the PF2VF interrupt is +replaced by a virtual interrupt injected into the guest through the VDCM. + +User Interface +============== + +The dlb2 driver uses ioctls as its primary interface. It provides two types of +files: the dlb2 device file and the scheduling domain file. + +The two types support different ioctl interfaces; the dlb2 device file is used +for device-wide operations (including scheduling domain creation), and the +scheduling domain device file supports operations on the scheduling domain's +resources such as port and queue configuration. + +The driver also exports an mmap interface through port files, which are +acquired through scheduling domain ioctls. This mmap interface is used to map +a port's memory and MMIO window into the process's address space. + +Reset +===== + +The dlb2 driver supports reset at two levels: scheduling domain and device-wide +(i.e. FLR). + +Scheduling domain reset occurs when an application stops using its domain. +Specifically, when no more file references or memory mappings exist. At this +time, the driver resets all the domain's resources (flushes its queues and +ports) and puts them in their respective available-resource lists for later +use. + +An FLR can occur while the device is in use by user-space software, so the +driver uses its reset_prepare callback to ensure that no applications continue +to use the device while the FLR executes. First, the driver blocks user-space +from executing ioctls or opening a device file, and evicts any threads blocked +on a CQ interrupt. The driver then notifies applications and virtual functions +that an FLR is pending, and waits for them to clean up with a timeout (default +of 5 seconds). If the timeout expires and the device is still in use by an +application, the driver zaps its MMIO mappings. Virtual functions, whether in +use or not, are reset as part of a PF FLR. + +While PF FLR is a hardware procedure, VF FLR is a software procedure. When a +VF FLR is triggered, this causes an interrupt to be delivered to the PF driver, +which performs the actual reset. This consists of performing the scheduling +domain reset operation for each of the VF's scheduling domains.
Documentation/misc-devices/index.rst +1 -0
@@ -17,6 +17,7 @@ fit into other categories. ad525x_dpot apds990x bh1770glc + dlb2 eeprom c2port ibmvmc
MAINTAINERS +7 -0
@@ -8716,6 +8716,13 @@ L: [email protected] S: Supported F: arch/x86/include/asm/intel-family.h +INTEL DYNAMIC LOAD BALANCER 2.0 DRIVER +M: Gage Eads <[email protected]> +S: Maintained +F: Documentation/ABI/testing/sysfs-driver-dlb2 +F: drivers/misc/dlb* +F: include/uapi/linux/dlb2_user.h + INTEL DRM DRIVERS (excluding Poulsbo, Moorestown and derivative chipsets) M: Jani Nikula <[email protected]> M: Joonas Lahtinen <[email protected]>
drivers/misc/Kconfig +1 -0
@@ -472,4 +472,5 @@ source "drivers/misc/ocxl/Kconfig" source "drivers/misc/cardreader/Kconfig" source "drivers/misc/habanalabs/Kconfig" source "drivers/misc/uacce/Kconfig" +source "drivers/misc/dlb2/Kconfig" endmenu
drivers/misc/Makefile +1 -0
@@ -57,3 +57,4 @@ obj-$(CONFIG_PVPANIC) += pvpanic.o obj-$(CONFIG_HABANA_AI) += habanalabs/ obj-$(CONFIG_UACCE) += uacce/ obj-$(CONFIG_XILINX_SDFEC) += xilinx_sdfec.o +obj-$(CONFIG_INTEL_DLB2) += dlb2/
drivers/misc/dlb2/Kconfig new file +17 -0
@@ -0,0 +1,17 @@ +# SPDX-License-Identifier: GPL-2.0-only + +config INTEL_DLB2 + tristate "Intel Dynamic Load Balancer 2.0 Driver" + depends on 64BIT && PCI && X86 + help + This driver supports the Intel Dynamic Load Balancer 2.0 (DLB 2.0), a + PCIe device (PCI ID 8086:2710) that provides load-balanced, + prioritized scheduling of core-to-core communication. + + The user-space interface is described in + include/uapi/linux/dlb2_user.h + + To compile this driver as a module, choose M here. The module + will be called dlb2. + + If unsure, select N.
drivers/misc/dlb2/Makefile new file +8 -0
@@ -0,0 +1,8 @@ +# +# Makefile for the Intel(R) Dynamic Load Balancer 2.0 (dlb2.ko) driver +# + +obj-$(CONFIG_INTEL_DLB2) := dlb2.o + +dlb2-objs := \ + dlb2_main.o \
drivers/misc/dlb2/dlb2_hw_types.h new file +29 -0
@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-2.0-only +* Copyright(c) 2016-2020 Intel Corporation +*/ + +#ifndef __DLB2_HW_TYPES_H +#define __DLB2_HW_TYPES_H + +#define DLB2_MAX_NUM_VDEVS 16 +#define DLB2_MAX_NUM_DOMAINS 32 +#define DLB2_MAX_NUM_LDB_QUEUES 32/* LDB == load-balanced */ +#define DLB2_MAX_NUM_DIR_QUEUES 64/* DIR == directed */ +#define DLB2_MAX_NUM_LDB_PORTS 64 +#define DLB2_MAX_NUM_DIR_PORTS DLB2_MAX_NUM_DIR_QUEUES +#define DLB2_MAX_NUM_LDB_CREDITS 8192 +#define DLB2_MAX_NUM_DIR_CREDITS 2048 +#define DLB2_MAX_NUM_HIST_LIST_ENTRIES 2048 +#define DLB2_MAX_NUM_AQED_ENTRIES 2048 +#define DLB2_MAX_NUM_QIDS_PER_LDB_CQ 8 +#define DLB2_MAX_NUM_SEQUENCE_NUMBER_GROUPS 2 +#define DLB2_MAX_NUM_SEQUENCE_NUMBER_MODES 5 +#define DLB2_QID_PRIORITIES 8 +#define DLB2_NUM_ARB_WEIGHTS 8 +#define DLB2_MAX_WEIGHT 255 +#define DLB2_NUM_COS_DOMAINS 4 +#define DLB2_MAX_CQ_COMP_CHECK_LOOPS 409600 +#define DLB2_MAX_QID_EMPTY_CHECK_LOOPS (32 * 64 * 1024 * (800 / 30)) +#define DLB2_HZ 800000000 + +#endif /* __DLB2_HW_TYPES_H */
drivers/misc/dlb2/dlb2_main.c new file +208 -0
208 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h new file +37 -0
@@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0-only +* Copyright(c) 2017-2020 Intel Corporation +*/ + +#ifndef __DLB2_MAIN_H +#define __DLB2_MAIN_H + +#include <linux/cdev.h> +#include <linux/device.h> +#include <linux/ktime.h> +#include <linux/list.h> +#include <linux/mutex.h> +#include <linux/pci.h> +#include <linux/types.h> + +#include "dlb2_hw_types.h" + +static const char dlb2_driver_name[] =KBUILD_MODNAME ; + +/* +* The dlb2 driver uses a different minor number for each device file, of which +* there are: +* - 33 per device (PF or VF/VDEV): 1 for the device, 32 for scheduling domains +* - Up to 17 devices per PF: 1 PF and up to 16 VFs/VDEVs +* - Up to 16 PFs per system +*/ +#define DLB2_MAX_NUM_PFS 16 +#define DLB2_NUM_FUNCS_PER_DEVICE (1 + DLB2_MAX_NUM_VDEVS) +#define DLB2_MAX_NUM_DEVICES (DLB2_MAX_NUM_PFS * DLB2_NUM_FUNCS_PER_DEVICE) + +struct dlb2_dev { +struct pci_dev *pdev; +struct list_head list; +int id; +}; + +#endif /* __DLB2_MAIN_H */
include/linux/pci_ids.h +2 -0
@@ -2813,6 +2813,8 @@#define PCI_DEVICE_ID_INTEL_ESB2_14 0x2698#define PCI_DEVICE_ID_INTEL_ESB2_17 0x269b#define PCI_DEVICE_ID_INTEL_ESB2_18 0x269e +#define PCI_DEVICE_ID_INTEL_DLB2_PF 0x2710 +#define PCI_DEVICE_ID_INTEL_DLB2_VF 0x2711#define PCI_DEVICE_ID_INTEL_ICH7_0 0x27b8#define PCI_DEVICE_ID_INTEL_ICH7_1 0x27b9#define PCI_DEVICE_ID_INTEL_ICH7_30 0x27b0
Signature · 1 line
2.13.6
Greg KH
maintainerRe: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driver
include/linux/pci_ids.h line 2820
Quoted 11 lines · Gage Eads
include/linux/pci_ids.h +2
-0@@ -2813,6 +2813,8 @@#define PCI_DEVICE_ID_INTEL_ESB2_14 0x2698#define PCI_DEVICE_ID_INTEL_ESB2_17 0x269b#define PCI_DEVICE_ID_INTEL_ESB2_18 0x269e +#define PCI_DEVICE_ID_INTEL_DLB2_PF 0x2710 +#define PCI_DEVICE_ID_INTEL_DLB2_VF 0x2711#define PCI_DEVICE_ID_INTEL_ICH7_0 0x27b8#define PCI_DEVICE_ID_INTEL_ICH7_1 0x27b9#define PCI_DEVICE_ID_INTEL_ICH7_30 0x27b0
Doesn't the top of this file say to not add new ids?
Why are you adding these? Can't they just stick in the driver you use them in? And they aren't referenced in this patch either, so even if you did need them, they shouldn't be here :(
greg k-h
Greg KH
maintainerRe: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driver
In reply to Gage EadsQuoted 10 lines · Gage Eads
drivers/misc/dlb2/dlb2_main.c new file +7
-0@@ -0,0 +1,208 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright(c) 2018-2020 Intel Corporation */ + +#include <linux/aer.h> +#include <linux/cdev.h> +#include <linux/delay.h> +#include <linux/fs.h>
drivers/misc/dlb2/dlb2_main.c line 17
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+#include <linux/init.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/uaccess.h> + +#include "dlb2_main.h" + +static const char +dlb2_driver_copyright[] ="Copyright(c) 2018-2020 Intel Corporation" ;
Why have this in a string and then:
drivers/misc/dlb2/dlb2_main.c line 20
Quoted 2 lines
drivers/misc/dlb2/dlb2_main.c new file +2
-0+MODULE_LICENSE ("GPL v2" ); +MODULE_AUTHOR ("Copyright(c) 2018-2020 Intel Corporation" );
Not use it?
It's probably not needed at all, right?
Don't you get a build warning about this when applying and building this patch?
thanks,
greg k-h
A message that is not in the archive (sent off-list or not yet received): SN6PR11MB2574DA2AA215E9566BA4F410F6270@SN6PR11MB2574.namprd11.prod.outlook.com
Greg KH
maintainerRe: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driver
Quoted 44 lines · Gage
Quoted 44 lines
-----Original Message-----
From: Greg KH <[email protected]>
Sent: Monday, September 7, 2020 8:02 AM
To: Eads, Gage <[email protected]>
Cc: [email protected]; [email protected]; Karlsson, Magnus <[email protected]>; Topel, Bjorn <[email protected]>
Subject: Re: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driverQuoted 10 lines · Gage Eads
drivers/misc/dlb2/dlb2_main.c new file +7
-0@@ -0,0 +1,208 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright(c) 2018-2020 Intel Corporation */ + +#include <linux/aer.h> +#include <linux/cdev.h> +#include <linux/delay.h> +#include <linux/fs.h> drivers/misc/dlb2/dlb2_main.c line 17
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+#include <linux/init.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/uaccess.h> + +#include "dlb2_main.h" + +static const char +dlb2_driver_copyright[] ="Copyright(c) 2018-2020 Intel Corporation" ;Why have this in a string and then:
drivers/misc/dlb2/dlb2_main.c line 20
Quoted 2 lines
drivers/misc/dlb2/dlb2_main.c new file +2
-0+MODULE_LICENSE ("GPL v2" ); +MODULE_AUTHOR ("Copyright(c) 2018-2020 Intel Corporation" );Not use it?
It's probably not needed at all, right?
Don't you get a build warning about this when applying and building this patch?
Quoted 8 lines
Quoted 3 lines
thanks,
greg k-h
dlb2_driver_copyrightwas used in apr_info()in the v1 patchset that was removed at Arnd's recommendation, and I forgot to remove the string. Will fix. The unused warning variable was likely missed in the deluge of warnings from included kernel headers.
You should not have any build warnings. If you do, then something is really wrong, the kernel builds cleanly today.
thanks,
greg k-h
RE: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driver
Quoted 64 lines
-----Original Message-----
From: Greg KH <[email protected]>
Sent: Thursday, September 10, 2020 11:32 AM
To: Eads, Gage <[email protected]>
Cc: [email protected]; [email protected]; Karlsson, Magnus <[email protected]>; Topel, Bjorn <[email protected]>
Subject: Re: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driverQuoted 44 lines · Gage
Quoted 44 lines
-----Original Message-----
From: Greg KH <[email protected]>
Sent: Monday, September 7, 2020 8:02 AM
To: Eads, Gage <[email protected]>
Cc: [email protected]; [email protected]; Karlsson, Magnus <[email protected]>; Topel, Bjorn <[email protected]>
Subject: Re: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driverQuoted 10 lines · Gage Eads
drivers/misc/dlb2/dlb2_main.c new file +7
-0@@ -0,0 +1,208 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright(c) 2018-2020 Intel Corporation */ + +#include <linux/aer.h> +#include <linux/cdev.h> +#include <linux/delay.h> +#include <linux/fs.h> drivers/misc/dlb2/dlb2_main.c line 17
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+#include <linux/init.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/uaccess.h> + +#include "dlb2_main.h" + +static const char +dlb2_driver_copyright[] ="Copyright(c) 2018-2020 Intel Corporation" ;Why have this in a string and then:
drivers/misc/dlb2/dlb2_main.c line 20
Quoted 2 lines
drivers/misc/dlb2/dlb2_main.c new file +2
-0+MODULE_LICENSE ("GPL v2" ); +MODULE_AUTHOR ("Copyright(c) 2018-2020 Intel Corporation" );Not use it?
It's probably not needed at all, right?
Don't you get a build warning about this when applying and building this patch?
Quoted 6 lines
Quoted 3 lines
thanks,
greg k-h
dlb2_driver_copyrightwas used in apr_info()in the v1 patchset that was removed at Arnd's recommendation, and I forgot to remove the string.Will fix.
Quoted 1 line
The unused warning variable was likely missed in the deluge of warnings
from
Quoted 8 lines
Quoted 1 line
included kernel headers.
You should not have any build warnings. If you do, then something is really wrong, the kernel builds cleanly today.
thanks,
greg k-h
Sorry, I worded that ambiguously. The driver builds without any warnings with my GCC (7.3.1) by default. The deluge from kernel headers only occurs after adding EXTRA_CFLAGS=-W. There shouldn't be any dlb2 warnings with -W enabled, but I'll double check.
Thanks,
Gage
Greg KH
maintainerRe: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driver
Quoted 69 lines · Gage
Quoted 69 lines
-----Original Message-----
From: Greg KH <[email protected]>
Sent: Thursday, September 10, 2020 11:32 AM
To: Eads, Gage <[email protected]>
Cc: [email protected]; [email protected]; Karlsson, Magnus <[email protected]>; Topel, Bjorn <[email protected]>
Subject: Re: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driverQuoted 44 lines · Gage
Quoted 44 lines
-----Original Message-----
From: Greg KH <[email protected]>
Sent: Monday, September 7, 2020 8:02 AM
To: Eads, Gage <[email protected]>
Cc: [email protected]; [email protected]; Karlsson, Magnus <[email protected]>; Topel, Bjorn <[email protected]>
Subject: Re: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driverQuoted 10 lines · Gage Eads
drivers/misc/dlb2/dlb2_main.c new file +7
-0@@ -0,0 +1,208 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright(c) 2018-2020 Intel Corporation */ + +#include <linux/aer.h> +#include <linux/cdev.h> +#include <linux/delay.h> +#include <linux/fs.h> drivers/misc/dlb2/dlb2_main.c line 17
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+#include <linux/init.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/uaccess.h> + +#include "dlb2_main.h" + +static const char +dlb2_driver_copyright[] ="Copyright(c) 2018-2020 Intel Corporation" ;Why have this in a string and then:
drivers/misc/dlb2/dlb2_main.c line 20
Quoted 2 lines
drivers/misc/dlb2/dlb2_main.c new file +2
-0+MODULE_LICENSE ("GPL v2" ); +MODULE_AUTHOR ("Copyright(c) 2018-2020 Intel Corporation" );Not use it?
It's probably not needed at all, right?
Don't you get a build warning about this when applying and building this patch?
Quoted 6 lines
Quoted 3 lines
thanks,
greg k-h
dlb2_driver_copyrightwas used in apr_info()in the v1 patchset that was removed at Arnd's recommendation, and I forgot to remove the string.Will fix.
Quoted 1 line
The unused warning variable was likely missed in the deluge of warnings
from
Quoted 1 line
included kernel headers.
You should not have any build warnings. If you do, then something is really wrong, the kernel builds cleanly today.
Quoted 8 lines
Quoted 3 lines
thanks,
greg k-h
Sorry, I worded that ambiguously. The driver builds without any warnings with my GCC (7.3.1) by default. The deluge from kernel headers only occurs after adding EXTRA_CFLAGS=-W. There shouldn't be any dlb2 warnings with -W enabled, but I'll double check.
You do know about "W=1", right?
Greg KH
maintainerRe: [PATCH v3 01/19] dlb2: add skeleton for DLB 2.0 driver
In reply to Gage EadsQuoted 53 lines · Gage Eads
drivers/misc/dlb2/dlb2_hw_types.h new file +29
-0@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-2.0-only +* Copyright(c) 2016-2020 Intel Corporation +*/ + +#ifndef __DLB2_HW_TYPES_H +#define __DLB2_HW_TYPES_H + +#define DLB2_MAX_NUM_VDEVS 16 +#define DLB2_MAX_NUM_DOMAINS 32 +#define DLB2_MAX_NUM_LDB_QUEUES 32/* LDB == load-balanced */ +#define DLB2_MAX_NUM_DIR_QUEUES 64/* DIR == directed */ +#define DLB2_MAX_NUM_LDB_PORTS 64 +#define DLB2_MAX_NUM_DIR_PORTS DLB2_MAX_NUM_DIR_QUEUES +#define DLB2_MAX_NUM_LDB_CREDITS 8192 +#define DLB2_MAX_NUM_DIR_CREDITS 2048 +#define DLB2_MAX_NUM_HIST_LIST_ENTRIES 2048 +#define DLB2_MAX_NUM_AQED_ENTRIES 2048 +#define DLB2_MAX_NUM_QIDS_PER_LDB_CQ 8 +#define DLB2_MAX_NUM_SEQUENCE_NUMBER_GROUPS 2 +#define DLB2_MAX_NUM_SEQUENCE_NUMBER_MODES 5 +#define DLB2_QID_PRIORITIES 8 +#define DLB2_NUM_ARB_WEIGHTS 8 +#define DLB2_MAX_WEIGHT 255 +#define DLB2_NUM_COS_DOMAINS 4 +#define DLB2_MAX_CQ_COMP_CHECK_LOOPS 409600 +#define DLB2_MAX_QID_EMPTY_CHECK_LOOPS (32 * 64 * 1024 * (800 / 30)) +#define DLB2_HZ 800000000 + +#endif /* __DLB2_HW_TYPES_H */ drivers/misc/dlb2/dlb2_main.c new file +15
-0@@ -0,0 +1,208 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright(c) 2018-2020 Intel Corporation */ + +#include <linux/aer.h> +#include <linux/cdev.h> +#include <linux/delay.h> +#include <linux/fs.h> +#include <linux/init.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/uaccess.h> + +#include "dlb2_main.h" +
drivers/misc/dlb2/dlb2_main.c line 25
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+static const char +dlb2_driver_copyright[] ="Copyright(c) 2018-2020 Intel Corporation" ; + +MODULE_LICENSE ("GPL v2" ); +MODULE_AUTHOR ("Copyright(c) 2018-2020 Intel Corporation" ); +MODULE_DESCRIPTION ("Intel(R) Dynamic Load Balancer 2.0 Driver" ); + +/* The driver lock protects data structures that used by multiple devices. */ +static DEFINE_MUTEX (dlb2_driver_lock); +static struct list_head dlb2_dev_list =LIST_HEAD_INIT (dlb2_dev_list);
A static list of your devices? Why? Who is going to need to ever walk the list, shouldn't you be able to just access it from the device node directly?
drivers/misc/dlb2/dlb2_main.c line 28
Quoted 3 lines
drivers/misc/dlb2/dlb2_main.c new file +3
-0+ +static struct class *dlb2_class; +static dev_t dlb2_dev_number_base;
"number_base"?
drivers/misc/dlb2/dlb2_main.c line 32
Quoted 4 lines
drivers/misc/dlb2/dlb2_main.c new file +4
-0+ +/*****************************/ +/****** Devfs callbacks ******/ +/*****************************/
I said this before, but it seems to have been ignored, so I'm guessing my other comments were also ignored...
Anyway, there has not been anything called "Devfs" for 15+ years now, where did you port this code from that had a horrid, out-of-date comment block like that?
drivers/misc/dlb2/dlb2_main.c line 42
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+ +static int dlb2_open (struct inode *i,struct file *f) +{ +return 0 ; +} + +static int dlb2_close (struct inode *i,struct file *f) +{ +return 0 ; +}
If open/close do not do anything, then do not include them as a callback please.
drivers/misc/dlb2/dlb2_main.c line 54
Quoted 12 lines
drivers/misc/dlb2/dlb2_main.c new file +12
-0+ +static const struct file_operations dlb2_fops = { + .owner =THIS_MODULE , + .open = dlb2_open, + .release = dlb2_close, +}; + +/**********************************/ +/****** PCI driver callbacks ******/ +/**********************************/ + +static DEFINE_IDA (dlb2_ids);
This is not a PCI driver callback :)
Bad comments are worse than no comments at all.
drivers/misc/dlb2/dlb2_main.c line 63
Quoted 9 lines
drivers/misc/dlb2/dlb2_main.c new file +9
-0+ +static int dlb2_alloc_id (void ) +{ +return ida_alloc_max (&dlb2_ids,DLB2_MAX_NUM_DEVICES -1 ,GFP_KERNEL ); +} + +static void dlb2_free_id (int id) +{ +ida_free (&dlb2_ids, id);
Why have wrapper functions for simple one line calls, especially when you only call these once? They aren't needed, right?
Quoted 5 lines
drivers/misc/dlb2/dlb2_main.c new file +5
-0+} + +static int dlb2_probe (struct pci_dev *pdev, +const struct pci_device_id *pdev_id) +{
drivers/misc/dlb2/dlb2_main.c line 78
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+struct dlb2_dev *dlb2_dev; +int ret; + + dlb2_dev =devm_kzalloc (&pdev->dev,sizeof (*dlb2_dev),GFP_KERNEL ); +if (!dlb2_dev) +return -ENOMEM ; + +pci_set_drvdata (pdev, dlb2_dev); + + dlb2_dev->pdev = pdev;
No reference counting? Brave...
Quoted 18 lines
drivers/misc/dlb2/dlb2_main.c new file +18
-0+ + dlb2_dev->id =dlb2_alloc_id (); +if (dlb2_dev->id <0 ) { +dev_err (&pdev->dev,"probe: device ID allocation failed\n" ); + + ret = dlb2_dev->id; + goto alloc_id_fail; + } + + ret =pci_enable_device (pdev); +if (ret !=0 ) { +dev_err (&pdev->dev,"pci_enable_device() returned %d\n" , ret); + + goto pci_enable_device_fail; + } + + ret =pci_request_regions (pdev, dlb2_driver_name); +if (ret !=0 ) {
drivers/misc/dlb2/dlb2_main.c line 106
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+dev_err (&pdev->dev, +"pci_request_regions(): returned %d\n" , ret); + + goto pci_request_regions_fail; + } + +pci_set_master (pdev); + +if (pci_enable_pcie_error_reporting (pdev)) +dev_info (&pdev->dev,"[%s()] Failed to enable AER\n" , __func__);
dev_err()? And if this fails, why not really error out?
drivers/misc/dlb2/dlb2_main.c line 109
Quoted 3 lines
drivers/misc/dlb2/dlb2_main.c new file +3
-0+ +mutex_lock (&dlb2_driver_lock); +list_add (&dlb2_dev->list, &dlb2_dev_list);
What is this list for?
Quoted 27 lines
drivers/misc/dlb2/dlb2_main.c new file +27
-0+mutex_unlock (&dlb2_driver_lock); + +return 0 ; + +pci_request_regions_fail: +pci_disable_device (pdev); +pci_enable_device_fail: +dlb2_free_id (dlb2_dev->id); +alloc_id_fail: +devm_kfree (&pdev->dev, dlb2_dev); +return ret; +} + +static void dlb2_remove (struct pci_dev *pdev) +{ +struct dlb2_dev *dlb2_dev; + +/* Undo all the dlb2_probe() operations */ + dlb2_dev =pci_get_drvdata (pdev); + +mutex_lock (&dlb2_driver_lock); +list_del (&dlb2_dev->list); +mutex_unlock (&dlb2_driver_lock); + +pci_disable_pcie_error_reporting (pdev); + +pci_release_regions (pdev);
drivers/misc/dlb2/dlb2_main.c line 146
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+ +pci_disable_device (pdev); + +dlb2_free_id (dlb2_dev->id); + +devm_kfree (&pdev->dev, dlb2_dev); +} + +static struct pci_device_id dlb2_id_table[] = { + {PCI_DEVICE_DATA (INTEL ,DLB2_PF ,NULL ) },
If you don't have a data pointer, PCI_DEVICE() works, right?
drivers/misc/dlb2/dlb2_main.c line 152
Quoted 6 lines
drivers/misc/dlb2/dlb2_main.c new file +6
-0+ { 0 } +}; +MODULE_DEVICE_TABLE (pci, dlb2_id_table); + +static struct pci_driver dlb2_pci_driver = { + .name = (char *)dlb2_driver_name,
Hm, we should const that name in the structure, right?
Quoted 13 lines
drivers/misc/dlb2/dlb2_main.c new file +13
-0+ .id_table = dlb2_id_table, + .probe = dlb2_probe, + .remove = dlb2_remove, +}; + +static int __init dlb2_init_module (void ) +{ +int err; + + dlb2_class =class_create (THIS_MODULE , dlb2_driver_name); + +if (IS_ERR (dlb2_class)) { + pr_err("%s: class_create() returned %ld\n",
drivers/misc/dlb2/dlb2_main.c line 175
Quoted 10 lines
drivers/misc/dlb2/dlb2_main.c new file +10
-0+ dlb2_driver_name, PTR_ERR(dlb2_class)); + +return PTR_ERR (dlb2_class); + } + +/* Allocate one minor number per domain */ + err =alloc_chrdev_region (&dlb2_dev_number_base, +0 , +DLB2_MAX_NUM_DEVICES , + dlb2_driver_name);
Shouldn't you allocate your device ids when you have a device show up in the system? Why try to "pre-allocate" them all here? That feels really wasteful.
Same for allocating your class, why not just do that once your first PCI device shows up?
drivers/misc/dlb2/dlb2_main.c line 188
Quoted 13 lines
drivers/misc/dlb2/dlb2_main.c new file +13
-0+ +if (err <0 ) { +pr_err ("%s: alloc_chrdev_region() returned %d\n" , + dlb2_driver_name, err); + +return err; + } + + err =pci_register_driver (&dlb2_pci_driver); +if (err <0 ) { +pr_err ("%s: pci_register_driver() returned %d\n" , + dlb2_driver_name, err); +return err;
Nice, you just leaked device ids, and your class is stuck around for forever...
{sigh}
Why am I finding such Linux device-driver-101 errors here?
Please go back and follow the Intel-documented procedures and find someone who has experience with pci and misc drivers and get their review before sending this whole thing out again. To lean on maintainers without that experience makes the documented policy that you should be following pretty worthless :(
greg "your company still owes me a lot of liquor" k-h
PATCH v3 2/19 dlb2: initialize PF device
In reply to Gage EadsThe driver detects the device type (PF/VF) at probe time, and assigns the corresponding 'ops' callbacks from that. These callbacks include mapping and unmapping the PCI BAR space, creating/destroying the device, and adding/deleting a char device.
--- drivers/misc/dlb2/Makefile | 5 +- drivers/misc/dlb2/dlb2_hw_types.h | 28 +++++++++ drivers/misc/dlb2/dlb2_main.c | 49 ++++++++++++++- drivers/misc/dlb2/dlb2_main.h | 30 +++++++++ drivers/misc/dlb2/dlb2_pf_ops.c | 126 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 235 insertions(+), 3 deletions(-) create mode 100644 drivers/misc/dlb2/dlb2_pf_ops.c
drivers/misc/dlb2/Makefile +3 -2
@@ -4,5 +4,6 @@ obj-$(CONFIG_INTEL_DLB2) := dlb2.o -dlb2-objs := \ - dlb2_main.o \ +dlb2-objs := \ + dlb2_main.o \ + dlb2_pf_ops.o \
drivers/misc/dlb2/dlb2_hw_types.h +28 -0
@@ -5,6 +5,25 @@#ifndef __DLB2_HW_TYPES_H#define __DLB2_HW_TYPES_H +#include <linux/io.h> + +#define DLB2_PCI_REG_READ (addr) ioread32(addr) +#define DLB2_PCI_REG_WRITE (reg, value) iowrite32(value, reg) + +/* Read/write register 'reg' in the CSR BAR space */ +#define DLB2_CSR_REG_ADDR (a, reg) ((a)->csr_kva + (reg)) +#define DLB2_CSR_RD (hw, reg) \ + DLB2_PCI_REG_READ(DLB2_CSR_REG_ADDR((hw), (reg))) +#define DLB2_CSR_WR (hw, reg, value) \ + DLB2_PCI_REG_WRITE(DLB2_CSR_REG_ADDR((hw), (reg)), (value)) + +/* Read/write register 'reg' in the func BAR space */ +#define DLB2_FUNC_REG_ADDR (a, reg) ((a)->func_kva + (reg)) +#define DLB2_FUNC_RD (hw, reg) \ + DLB2_PCI_REG_READ(DLB2_FUNC_REG_ADDR((hw), (reg))) +#define DLB2_FUNC_WR (hw, reg, value) \ + DLB2_PCI_REG_WRITE(DLB2_FUNC_REG_ADDR((hw), (reg)), (value)) +#define DLB2_MAX_NUM_VDEVS 16#define DLB2_MAX_NUM_DOMAINS 32#define DLB2_MAX_NUM_LDB_QUEUES 32/* LDB == load-balanced */
@@ -26,4 +45,13 @@#define DLB2_MAX_QID_EMPTY_CHECK_LOOPS (32 * 64 * 1024 * (800 / 30))#define DLB2_HZ 800000000 +struct dlb2_hw { +/* BAR 0 address */ +void __iomem *csr_kva; +unsigned long csr_phys_addr; +/* BAR 2 address */ +void __iomem *func_kva; +unsigned long func_phys_addr; +}; +#endif /* __DLB2_HW_TYPES_H */
drivers/misc/dlb2/dlb2_main.c +48 -1
85 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h +30 -0
@@ -28,10 +28,40 @@ static const char dlb2_driver_name[] = KBUILD_MODNAME;#define DLB2_NUM_FUNCS_PER_DEVICE (1 + DLB2_MAX_NUM_VDEVS)#define DLB2_MAX_NUM_DEVICES (DLB2_MAX_NUM_PFS * DLB2_NUM_FUNCS_PER_DEVICE) +enum dlb2_device_type { +DLB2_PF , +DLB2_VF , +}; + +struct dlb2_dev ; + +struct dlb2_device_ops { +int (*map_pci_bar_space)(struct dlb2_dev *dev,struct pci_dev *pdev); +void (*unmap_pci_bar_space)(struct dlb2_dev *dev, +struct pci_dev *pdev); +int (*device_create)(struct dlb2_dev *dlb2_dev, +struct pci_dev *pdev, +struct class *dlb2_class); +void (*device_destroy)(struct dlb2_dev *dlb2_dev, +struct class *dlb2_class); +int (*cdev_add)(struct dlb2_dev *dlb2_dev, +dev_t base, +const struct file_operations *fops); +void (*cdev_del)(struct dlb2_dev *dlb2_dev); +}; + +extern struct dlb2_device_ops dlb2_pf_ops; +struct dlb2_dev {struct pci_dev *pdev; +struct dlb2_hw hw; +struct cdev cdev; +struct dlb2_device_ops *ops;struct list_head list; +struct device *dlb2_device; +enum dlb2_device_type type;int id; +dev_t dev_number; };#endif /* __DLB2_MAIN_H */
drivers/misc/dlb2/dlb2_pf_ops.c new file +126 -0
126 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 3/19 dlb2: add resource and device initialization
In reply to Gage EadsThis commit adds the hardware resource data structures and functions for their initialization/teardown and for device power-on. In subsequent commits, dlb2_resource.c will be expanded to hold the dlb2 resource-management and configuration logic (using the data structures defined in dlb2_hw_types.h).
This commit also introduces dlb2_bitmap_* functions, a thin convenience layer wrapping the Linux bitmap interfaces, used by the bitmaps in the dlb2 hardware types.
--- drivers/misc/dlb2/Makefile | 7 +- drivers/misc/dlb2/dlb2_bitmap.h | 121 +++++++++++++++++++++++ drivers/misc/dlb2/dlb2_hw_types.h | 173 +++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.c | 51 ++++++++++ drivers/misc/dlb2/dlb2_main.h | 11 +++ drivers/misc/dlb2/dlb2_pf_ops.c | 68 +++++++++++++ drivers/misc/dlb2/dlb2_regs.h | 83 ++++++++++++++++ drivers/misc/dlb2/dlb2_resource.c | 197 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 46 +++++++++ 9 files changed, 754 insertions(+), 3 deletions(-) create mode 100644 drivers/misc/dlb2/dlb2_bitmap.h create mode 100644 drivers/misc/dlb2/dlb2_regs.h create mode 100644 drivers/misc/dlb2/dlb2_resource.c create mode 100644 drivers/misc/dlb2/dlb2_resource.h
drivers/misc/dlb2/Makefile +4 -3
@@ -4,6 +4,7 @@ obj-$(CONFIG_INTEL_DLB2) := dlb2.o -dlb2-objs := \ - dlb2_main.o \ - dlb2_pf_ops.o \ +dlb2-objs := \ + dlb2_main.o \ + dlb2_pf_ops.o \ + dlb2_resource.o \
drivers/misc/dlb2/dlb2_bitmap.h new file +121 -0
121 lines not on this page · raw message
drivers/misc/dlb2/dlb2_hw_types.h +173 -0
191 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.c +51 -0
81 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h +11 -0
@@ -39,6 +39,8 @@ struct dlb2_device_ops {int (*map_pci_bar_space)(struct dlb2_dev *dev,struct pci_dev *pdev);void (*unmap_pci_bar_space)(struct dlb2_dev *dev,struct pci_dev *pdev); +int (*init_driver_state)(struct dlb2_dev *dev); +void (*free_driver_state)(struct dlb2_dev *dev);int (*device_create)(struct dlb2_dev *dlb2_dev,struct pci_dev *pdev,struct class *dlb2_class);
@@ -48,6 +50,10 @@ struct dlb2_device_ops {dev_t base, const struct file_operations *fops);void (*cdev_del)(struct dlb2_dev *dlb2_dev); +void (*enable_pm)(struct dlb2_dev *dev); +int (*wait_for_device_ready)(struct dlb2_dev *dev, +struct pci_dev *pdev); +void (*init_hardware)(struct dlb2_dev *dev); };extern struct dlb2_device_ops dlb2_pf_ops;
@@ -59,6 +65,11 @@ struct dlb2_dev {struct dlb2_device_ops *ops;struct list_head list;struct device *dlb2_device; +/* +* The resource mutex serializes access to driver data structures and +* hardware registers. +*/ +struct mutex resource_mutex;enum dlb2_device_type type;int id;dev_t dev_number;
drivers/misc/dlb2/dlb2_pf_ops.c +68 -0
95 lines not on this page · raw message
drivers/misc/dlb2/dlb2_regs.h new file +83 -0
83 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.c new file +197 -0
197 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h new file +46 -0
46 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 4/19 dlb2: add device ioctl layer and first three ioctls
In reply to Gage EadsThis commit introduces the dlb2 device ioctl layer, and the first three
ioctls: query device version, query available resources, and create a scheduling domain. This commit also introduces the user-space interface file dlb2_user.h.
The device version query is designed to allow each DLB device version/type to have its own unique ioctl API through the /dev/dlb%d node. Each such API would share in common the device version command as its first command, and all subsequent commands can be unique to the particular device.
The PF hardware operation for scheduling domain creation will be added in a subsequent commit.
--- Documentation/userspace-api/ioctl/ioctl-number.rst | 1 + drivers/misc/dlb2/Makefile | 1 + drivers/misc/dlb2/dlb2_bitmap.h | 63 ++++++++ drivers/misc/dlb2/dlb2_ioctl.c | 86 +++++++++++ drivers/misc/dlb2/dlb2_ioctl.h | 12 ++ drivers/misc/dlb2/dlb2_main.c | 6 + drivers/misc/dlb2/dlb2_main.h | 7 + drivers/misc/dlb2/dlb2_pf_ops.c | 21 +++ drivers/misc/dlb2/dlb2_resource.c | 46 ++++++ drivers/misc/dlb2/dlb2_resource.h | 22 +++ include/uapi/linux/dlb2_user.h | 163 +++++++++++++++++++++ 11 files changed, 428 insertions(+) create mode 100644 drivers/misc/dlb2/dlb2_ioctl.c create mode 100644 drivers/misc/dlb2/dlb2_ioctl.h create mode 100644 include/uapi/linux/dlb2_user.h
Documentation/userspace-api/ioctl/ioctl-number.rst +1 -0
@@ -241,6 +241,7 @@ Code Seq# Include File Comments 'h' 00-7F conflict! Charon filesystem <mailto:[email protected]> 'h' 00-1F linux/hpet.h conflict! +'h' 00-1F uapi/linux/dlb2_user.h conflict! 'h' 80-8F fs/hfsplus/ioctl.c 'i' 00-3F linux/i2o-dev.h conflict! 'i' 0B-1F linux/ipmi.h conflict!
drivers/misc/dlb2/Makefile +1 -0
@@ -6,5 +6,6 @@ obj-$(CONFIG_INTEL_DLB2) := dlb2.o dlb2-objs := \ dlb2_main.o \ + dlb2_ioctl.o \ dlb2_pf_ops.o \ dlb2_resource.o \
drivers/misc/dlb2/dlb2_bitmap.h +63 -0
67 lines not on this page · raw message
drivers/misc/dlb2/dlb2_ioctl.c new file +86 -0
86 lines not on this page · raw message
drivers/misc/dlb2/dlb2_ioctl.h new file +12 -0
@@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-only +* Copyright(c) 2017-2020 Intel Corporation +*/ + +#ifndef __DLB2_IOCTL_H +#define __DLB2_IOCTL_H + +#include "dlb2_main.h" + +long dlb2_ioctl (struct file *f,unsigned int cmd,unsigned long arg); + +#endif /* __DLB2_IOCTL_H */
drivers/misc/dlb2/dlb2_main.c +6 -0
@@ -11,12 +11,16 @@#include <linux/pci.h> #include <linux/uaccess.h> +#include "dlb2_ioctl.h" #include "dlb2_main.h" #include "dlb2_resource.h" static const char dlb2_driver_copyright[] ="Copyright(c) 2018-2020 Intel Corporation" ; +#define TO_STR2 (s) #s +#define TO_STR (s) TO_STR2(s) +MODULE_LICENSE ("GPL v2" );MODULE_AUTHOR ("Copyright(c) 2018-2020 Intel Corporation" );MODULE_DESCRIPTION ("Intel(R) Dynamic Load Balancer 2.0 Driver" );
@@ -63,6 +67,8 @@ static const struct file_operations dlb2_fops = { .owner = THIS_MODULE, .open = dlb2_open, .release = dlb2_close, + .unlocked_ioctl = dlb2_ioctl, + .compat_ioctl = compat_ptr_ioctl, };/**********************************/
drivers/misc/dlb2/dlb2_main.h +7 -0
@@ -13,6 +13,8 @@#include <linux/pci.h> #include <linux/types.h> +#include <uapi/linux/dlb2_user.h> +#include "dlb2_hw_types.h" static const char dlb2_driver_name[] =KBUILD_MODNAME ;
@@ -53,6 +55,11 @@ struct dlb2_device_ops {void (*enable_pm)(struct dlb2_dev *dev);int (*wait_for_device_ready)(struct dlb2_dev *dev,struct pci_dev *pdev); +int (*create_sched_domain)(struct dlb2_hw *hw, +struct dlb2_create_sched_domain_args *args, +struct dlb2_cmd_response *resp); +int (*get_num_resources)(struct dlb2_hw *hw, +struct dlb2_get_num_resources_args *args);void (*init_hardware)(struct dlb2_dev *dev); };
drivers/misc/dlb2/dlb2_pf_ops.c +21 -0
@@ -175,6 +175,25 @@ dlb2_pf_init_hardware(struct dlb2_dev *dlb2_dev) { } +/*****************************/ +/****** IOCTL callbacks ******/ +/*****************************/ + +static int +dlb2_pf_create_sched_domain (struct dlb2_hw *hw, +struct dlb2_create_sched_domain_args *args, +struct dlb2_cmd_response *resp) +{ +return 0 ; +} + +static int +dlb2_pf_get_num_resources (struct dlb2_hw *hw, +struct dlb2_get_num_resources_args *args) +{ +return dlb2_hw_get_num_resources (hw, args, false,0 ); +} +/********************************/ /****** DLB2 PF Device Ops ******/ /********************************/
@@ -190,5 +209,7 @@ struct dlb2_device_ops dlb2_pf_ops = { .cdev_del = dlb2_pf_cdev_del, .enable_pm = dlb2_pf_enable_pm, .wait_for_device_ready = dlb2_pf_wait_for_device_ready, + .create_sched_domain = dlb2_pf_create_sched_domain, + .get_num_resources = dlb2_pf_get_num_resources, .init_hardware = dlb2_pf_init_hardware, };
drivers/misc/dlb2/dlb2_resource.c +46 -0
52 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +22 -0
@@ -35,6 +35,28 @@ int dlb2_resource_init(struct dlb2_hw *hw);void dlb2_resource_free (struct dlb2_hw *hw);/** +* dlb2_hw_get_num_resources() - query the PCI function's available resources +* @hw: dlb2_hw handle for a particular device. +* @arg: pointer to resource counts. +* @vdev_request: indicates whether this request came from a vdev. +* @vdev_id: If vdev_request is true, this contains the vdev's ID. +* +* This function returns the number of available resources for the PF or for a +* VF. +* +* A vdev can be either an SR-IOV virtual function or a Scalable IOV virtual +* device. +* +* Return: +* Returns 0 upon success, -EINVAL if vdev_request is true and vdev_id is +* invalid. +*/ +int dlb2_hw_get_num_resources (struct dlb2_hw *hw, +struct dlb2_get_num_resources_args *arg, +bool vdev_request, +unsigned int vdev_id); + +/** * dlb2_clr_pmcsr_disable() - power on bulk of DLB 2.0 logic * @hw: dlb2_hw handle for a particular device. *
include/uapi/linux/dlb2_user.h new file +163 -0
163 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 5/19 dlb2: add sched domain config and reset support
In reply to Gage EadsWhen a user requests to create a scheduling domain, the requested resources are validated then reserved for the scheduling domain. This takes place in dlb2_resource.c. Finally, the ioctl handler allocates an anonymous file descriptor for the domain.
Once created, user-space can use its file descriptor for the scheduling domain to configure the domain's resources (to be added in a subsequent commit). User-space can also get additional file descriptors (for multiprocess usage).
The driver maintains a reference count for each scheduling domain, incrementing it each time user-space requests a file descriptor and decrementing it in the file's release callback.
When the reference count transitions from 1->0 the driver automatically resets the scheduling domain's resources and makes them available for use by future applications. This ensures that applications that crash without explicitly cleaning up do not orphan device resources.
Broadly speaking, the scheduling domain reset logic progressively disables resources and flushes/drains them. The driver uses iosubmit_cmds512() to flush load-balanced and directed ports. At the end of the domain reset function, it resets hardware (register) state and software state.
--- drivers/misc/dlb2/dlb2_bitmap.h | 102 ++ drivers/misc/dlb2/dlb2_hw_types.h | 92 + drivers/misc/dlb2/dlb2_ioctl.c | 42 +- drivers/misc/dlb2/dlb2_main.c | 73 + drivers/misc/dlb2/dlb2_main.h | 25 + drivers/misc/dlb2/dlb2_pf_ops.c | 9 +- drivers/misc/dlb2/dlb2_regs.h | 3619 +++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.c | 3132 ++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 74 + include/uapi/linux/dlb2_user.h | 86 + 10 files changed, 7252 insertions(+), 2 deletions(-)
drivers/misc/dlb2/dlb2_bitmap.h +102 -0
@@ -119,6 +119,108 @@ static inline int dlb2_bitmap_zero(struct dlb2_bitmap *bitmap) }/** +* dlb2_bitmap_set_range() - set a range of bitmap entries +* @bitmap: pointer to dlb2_bitmap structure. +* @bit: starting bit index. +* @len: length of the range. +* +* Return: +* Returns 0 upon success, < 0 otherwise. +* +* Errors: +* EINVAL - bitmap is NULL or is uninitialized, or the range exceeds the bitmap +* length. +*/ +static inline int dlb2_bitmap_set_range (struct dlb2_bitmap *bitmap, +unsigned int bit, +unsigned int len) +{ +if (!bitmap || !bitmap->map) +return -EINVAL ; + +if (bitmap->len <= bit) +return -EINVAL ; + +bitmap_set (bitmap->map, bit, len); + +return 0 ; +} + +/** +* dlb2_bitmap_clear_range() - clear a range of bitmap entries +* @bitmap: pointer to dlb2_bitmap structure. +* @bit: starting bit index. +* @len: length of the range. +* +* Return: +* Returns 0 upon success, < 0 otherwise. +* +* Errors: +* EINVAL - bitmap is NULL or is uninitialized, or the range exceeds the bitmap +* length. +*/ +static inline int dlb2_bitmap_clear_range (struct dlb2_bitmap *bitmap, +unsigned int bit, +unsigned int len) +{ +if (!bitmap || !bitmap->map) +return -EINVAL ; + +if (bitmap->len <= bit) +return -EINVAL ; + +bitmap_clear (bitmap->map, bit, len); + +return 0 ; +} + +/** +* dlb2_bitmap_find_set_bit_range() - find an range of set bits +* @bitmap: pointer to dlb2_bitmap structure. +* @len: length of the range. +* +* This function looks for a range of set bits of length @len. +* +* Return: +* Returns the base bit index upon success, < 0 otherwise. +* +* Errors: +* ENOENT - unable to find a length *len* range of set bits. +* EINVAL - bitmap is NULL or is uninitialized, or len is invalid. +*/ +static inline int dlb2_bitmap_find_set_bit_range (struct dlb2_bitmap *bitmap, +unsigned int len) +{ +struct dlb2_bitmap *complement_mask =NULL ; +int ret; + +if (!bitmap || !bitmap->map || len ==0 ) +return -EINVAL ; + +if (bitmap->len < len) +return -ENOENT ; + + ret =dlb2_bitmap_alloc (&complement_mask, bitmap->len); +if (ret) +return ret; + +dlb2_bitmap_zero (complement_mask); + +bitmap_complement (complement_mask->map, bitmap->map, bitmap->len); + + ret =bitmap_find_next_zero_area (complement_mask->map, + complement_mask->len, +0 , + len, +0 ); + +dlb2_bitmap_free (complement_mask); + +/* No set bit range of length len? */ +return (ret >= (int )bitmap->len) ? -ENOENT : ret; +} + +/** * dlb2_bitmap_count() - returns the number of set bits * @bitmap: pointer to dlb2_bitmap structure. *
drivers/misc/dlb2/dlb2_hw_types.h +92 -0
116 lines not on this page · raw message
drivers/misc/dlb2/dlb2_ioctl.c +41 -1
62 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.c +73 -0
85 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h +25 -0
@@ -60,10 +60,18 @@ struct dlb2_device_ops { struct dlb2_cmd_response *resp);int (*get_num_resources)(struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args); +int (*reset_domain)(struct dlb2_hw *hw,u32 domain_id);void (*init_hardware)(struct dlb2_dev *dev); };extern struct dlb2_device_ops dlb2_pf_ops; +extern const struct file_operations dlb2_domain_fops; + +struct dlb2_domain { +struct dlb2_dev *dlb2_dev; +struct kref refcnt; +u8 id; +};struct dlb2_dev {struct pci_dev *pdev;
@@ -72,6 +80,7 @@ struct dlb2_dev {struct dlb2_device_ops *ops;struct list_head list;struct device *dlb2_device; +struct dlb2_domain *sched_domains[DLB2_MAX_NUM_DOMAINS ];/* * The resource mutex serializes access to driver data structures and * hardware registers.
@@ -80,6 +89,22 @@ struct dlb2_dev {enum dlb2_device_type type;int id;dev_t dev_number; + u8 domain_reset_failed; }; +int dlb2_init_domain (struct dlb2_dev *dlb2_dev,u32 domain_id); +void dlb2_free_domain (struct kref *kref); + +#define DLB2_HW_ERR (dlb2, ...) do { \ + struct dlb2_dev *dev; \ + dev = container_of(dlb2, struct dlb2_dev, hw); \ + dev_err(dev->dlb2_device, __VA_ARGS__); \ +} while (0) + +#define DLB2_HW_DBG (dlb2, ...) do { \ + struct dlb2_dev *dev; \ + dev = container_of(dlb2, struct dlb2_dev, hw); \ + dev_dbg(dev->dlb2_device, __VA_ARGS__); \ +} while (0) +#endif /* __DLB2_MAIN_H */
drivers/misc/dlb2/dlb2_pf_ops.c +8 -1
@@ -184,7 +184,7 @@ dlb2_pf_create_sched_domain(struct dlb2_hw *hw,struct dlb2_create_sched_domain_args *args, struct dlb2_cmd_response *resp) { -return 0 ; + return dlb2_hw_create_sched_domain(hw, args, resp, false, 0); } static int
@@ -194,6 +194,12 @@ dlb2_pf_get_num_resources(struct dlb2_hw *hw,return dlb2_hw_get_num_resources (hw, args, false,0 ); } +static int +dlb2_pf_reset_domain (struct dlb2_hw *hw,u32 id) +{ +return dlb2_reset_domain (hw, id, false,0 ); +} +/********************************/ /****** DLB2 PF Device Ops ******/ /********************************/
@@ -211,5 +217,6 @@ struct dlb2_device_ops dlb2_pf_ops = { .wait_for_device_ready = dlb2_pf_wait_for_device_ready, .create_sched_domain = dlb2_pf_create_sched_domain, .get_num_resources = dlb2_pf_get_num_resources, + .reset_domain = dlb2_pf_reset_domain, .init_hardware = dlb2_pf_init_hardware, };
drivers/misc/dlb2/dlb2_regs.h +3619 -0
2,556 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.c +3132 -0
3,132 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +74 -0
74 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +86 -0
86 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.13.6
Part of the diff is not shown here. View the raw message.
PATCH v3 6/19 dlb2: add runtime power-management support
In reply to Gage EadsThe driver's power-management policy is to put the device in D0 when in use (when there are any open device files or memory mappings, or there are any virtual devices), and leave it in D3Hot otherwise. This includes resume/suspend callbacks; when the device resumes, the driver resets the hardware to a known good state.
--- drivers/misc/dlb2/dlb2_main.c | 72 +++++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.h | 2 ++ drivers/misc/dlb2/dlb2_pf_ops.c | 30 +++++++++++++++++ 3 files changed, 104 insertions(+)
drivers/misc/dlb2/dlb2_main.c +72 -0
@@ -61,11 +61,19 @@ static int dlb2_open(struct inode *i, struct file *f) f->private_data = dev; + dev->ops->inc_pm_refcnt (dev->pdev, true); +return 0 ; }static int dlb2_close (struct inode *i,struct file *f) { +struct dlb2_dev *dev; + + dev = container_of(f->f_inode->i_cdev, struct dlb2_dev, cdev); + + dev->ops->dec_pm_refcnt (dev->pdev); +return 0 ; }
@@ -94,6 +102,8 @@ int dlb2_init_domain(struct dlb2_dev *dlb2_dev, u32 domain_id) dlb2_dev->sched_domains[domain_id] = domain; + dlb2_dev->ops->inc_pm_refcnt (dlb2_dev->pdev, true); +return 0 ; }
@@ -134,6 +144,8 @@ static int dlb2_domain_close(struct inode *i, struct file *f)kref_put (&domain->refcnt, dlb2_free_domain); + dev->ops->dec_pm_refcnt (dev->pdev); +mutex_unlock (&dev->resource_mutex);return ret;
@@ -262,6 +274,15 @@ static int dlb2_probe(struct pci_dev *pdev,list_add (&dlb2_dev->list, &dlb2_dev_list);mutex_unlock (&dlb2_driver_lock); +/* +* The driver puts the device to sleep (D3hot) while there are no +* scheduling domains to service. The usage counter of a PCI device at +* probe time is 2, so decrement it twice here. (The PCI layer has +* already called pm_runtime_enable().) +*/ + dlb2_dev->ops->dec_pm_refcnt (pdev); + dlb2_dev->ops->dec_pm_refcnt (pdev); +return 0 ; init_driver_state_fail:
@@ -298,6 +319,10 @@ static void dlb2_remove(struct pci_dev *pdev)list_del (&dlb2_dev->list);mutex_unlock (&dlb2_driver_lock); +/* Undo the PM operations in dlb2_probe(). */ + dlb2_dev->ops->inc_pm_refcnt (pdev, false); + dlb2_dev->ops->inc_pm_refcnt (pdev, false); + dlb2_dev->ops->free_driver_state (dlb2_dev);dlb2_resource_free (&dlb2_dev->hw);
@@ -319,17 +344,64 @@ static void dlb2_remove(struct pci_dev *pdev)devm_kfree (&pdev->dev, dlb2_dev); } +#ifdef CONFIG_PM +static void dlb2_reset_hardware_state (struct dlb2_dev *dev) +{ +dlb2_reset_device (dev->pdev); + +/* Reinitialize any other hardware state */ + dev->ops->init_hardware (dev); +} + +static int dlb2_runtime_suspend (struct device *dev) +{ +/* Return and let the PCI subsystem put the device in D3hot. */ + +return 0 ; +} + +static int dlb2_runtime_resume (struct device *dev) +{ + struct pci_dev *pdev = container_of(dev, struct pci_dev, dev); +struct dlb2_dev *dlb2_dev =pci_get_drvdata (pdev); +int ret; + +/* +* The PCI subsystem put the device in D0, but the device may not have +* completed powering up. Wait until the device is ready before +* proceeding. +*/ + ret = dlb2_dev->ops->wait_for_device_ready (dlb2_dev, pdev); +if (ret) +return ret; + +/* Now reinitialize the device state. */ +dlb2_reset_hardware_state (dlb2_dev); + +return 0 ; +} +#endif +static struct pci_device_id dlb2_id_table[] = { {PCI_DEVICE_DATA (INTEL ,DLB2_PF ,DLB2_PF ) }, {0 } };MODULE_DEVICE_TABLE (pci, dlb2_id_table); +#ifdef CONFIG_PM +static const struct dev_pm_ops dlb2_pm_ops = { +SET_RUNTIME_PM_OPS (dlb2_runtime_suspend, dlb2_runtime_resume,NULL ) +}; +#endif +static struct pci_driver dlb2_pci_driver = { .name = (char *)dlb2_driver_name, .id_table = dlb2_id_table, .probe = dlb2_probe, .remove = dlb2_remove, +#ifdef CONFIG_PM + .driver.pm = &dlb2_pm_ops, +#endif };static int __init dlb2_init_module (void )
drivers/misc/dlb2/dlb2_main.h +2 -0
@@ -41,6 +41,8 @@ struct dlb2_device_ops {int (*map_pci_bar_space)(struct dlb2_dev *dev,struct pci_dev *pdev);void (*unmap_pci_bar_space)(struct dlb2_dev *dev,struct pci_dev *pdev); +void (*inc_pm_refcnt)(struct pci_dev *pdev,bool resume); +void (*dec_pm_refcnt)(struct pci_dev *pdev);int (*init_driver_state)(struct dlb2_dev *dev);void (*free_driver_state)(struct dlb2_dev *dev); int (*device_create)(struct dlb2_dev *dlb2_dev,
drivers/misc/dlb2/dlb2_pf_ops.c +30 -0
@@ -2,11 +2,39 @@/* Copyright(c) 2017-2020 Intel Corporation */ #include <linux/delay.h> +#include <linux/pm_runtime.h> #include "dlb2_main.h" #include "dlb2_regs.h" #include "dlb2_resource.h" +/***********************************/ +/****** Runtime PM management ******/ +/***********************************/ + +static void +dlb2_pf_pm_inc_refcnt (struct pci_dev *pdev,bool resume) +{ +if (resume) +/* +* Increment the device's usage count and immediately wake it +* if it was suspended. +*/ +pm_runtime_get_sync (&pdev->dev); +else +pm_runtime_get_noresume (&pdev->dev); +} + +static void +dlb2_pf_pm_dec_refcnt (struct pci_dev *pdev) +{ +/* +* Decrement the device's usage count and suspend it if the +* count reaches zero. +*/ +pm_runtime_put_sync_suspend (&pdev->dev); +} +/********************************/ /****** PCI BAR management ******/ /********************************/
@@ -207,6 +235,8 @@ dlb2_pf_reset_domain(struct dlb2_hw *hw, u32 id)struct dlb2_device_ops dlb2_pf_ops = { .map_pci_bar_space = dlb2_pf_map_pci_bar_space, .unmap_pci_bar_space = dlb2_pf_unmap_pci_bar_space, + .inc_pm_refcnt = dlb2_pf_pm_inc_refcnt, + .dec_pm_refcnt = dlb2_pf_pm_dec_refcnt, .init_driver_state = dlb2_pf_init_driver_state, .free_driver_state = dlb2_pf_free_driver_state, .device_create = dlb2_pf_device_create,
Signature · 1 line
2.13.6
PATCH v3 7/19 dlb2: add queue create and queue-depth-get ioctls
In reply to Gage EadsWhen a CPU enqueues a queue entry (QE) to DLB 2.0, the QE entry is sent to a DLB 2.0 queue. These queues hold queue entries (QEs) that have not yet been scheduled to a destination port. The queue's depth is the number of QEs residing in a queue.
Each queue supports multiple priority levels, and while a directed queue has a 1:1 mapping with a directed port, load-balanced queues can be configured with a set of load-balanced ports that software desires the queue's QEs to be scheduled to.
--- drivers/misc/dlb2/dlb2_ioctl.c | 61 ++++ drivers/misc/dlb2/dlb2_ioctl.h | 2 + drivers/misc/dlb2/dlb2_main.c | 2 + drivers/misc/dlb2/dlb2_main.h | 16 + drivers/misc/dlb2/dlb2_pf_ops.c | 40 +++ drivers/misc/dlb2/dlb2_resource.c | 732 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 125 +++++++ include/uapi/linux/dlb2_user.h | 138 +++++++ 8 files changed, 1116 insertions(+)
drivers/misc/dlb2/dlb2_ioctl.c +61 -0
@@ -9,6 +9,67 @@#include "dlb2_ioctl.h" #include "dlb2_main.h" +/* +* The DLB domain ioctl callback template minimizes replication of boilerplate +* code to copy arguments, acquire and release the resource lock, and execute +* the command. The arguments and response structure name should have the +* format dlb2_<lower_name>_args. +*/ +#define DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE (lower_name) \ +static int dlb2_domain_ioctl_##lower_name(struct dlb2_dev *dev, \ + struct dlb2_domain *domain, \ + unsigned long user_arg) \ +{ \ + struct dlb2_cmd_response response = {0}; \ + struct dlb2_##lower_name##_args arg; \ + int ret; \ + \ + if (copy_from_user(&arg, (void __user *)user_arg, sizeof(arg))) \ + return -EFAULT; \ + \ + mutex_lock(&dev->resource_mutex); \ + \ + ret = dev->ops->lower_name(&dev->hw, \ + domain->id, \ + &arg, \ + &response); \ + \ + mutex_unlock(&dev->resource_mutex); \ + \ + BUILD_BUG_ON(offsetof(typeof(arg), response) != 0); \ + \ + if (copy_to_user((void __user *)user_arg, \ + &response, \ + sizeof(response))) \ + return -EFAULT; \ + \ + return ret; \ +} + +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE (create_ldb_queue) +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE (create_dir_queue ) +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE (get_ldb_queue_depth) +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE (get_dir_queue_depth) + +long dlb2_domain_ioctl(struct file *f, unsigned int cmd, unsigned long arg) +{ +struct dlb2_domain *dom = f->private_data; +struct dlb2_dev *dev = dom->dlb2_dev; + +switch (cmd) { +case DLB2_IOC_CREATE_LDB_QUEUE : +return dlb2_domain_ioctl_create_ldb_queue (dev, dom, arg); +case DLB2_IOC_CREATE_DIR_QUEUE : +return dlb2_domain_ioctl_create_dir_queue (dev, dom, arg); +case DLB2_IOC_GET_LDB_QUEUE_DEPTH : +return dlb2_domain_ioctl_get_ldb_queue_depth (dev, dom, arg); +case DLB2_IOC_GET_DIR_QUEUE_DEPTH : +return dlb2_domain_ioctl_get_dir_queue_depth (dev, dom, arg); +default : +return -ENOTTY ; + } +} +/* [7:0]: device revision, [15:8]: device version */ #define DLB2_SET_DEVICE_VERSION (ver, rev) (((ver) << 8) | (rev))
drivers/misc/dlb2/dlb2_ioctl.h +2 -0
@@ -9,4 +9,6 @@long dlb2_ioctl (struct file *f,unsigned int cmd,unsigned long arg); +long dlb2_domain_ioctl (struct file *f,unsigned int cmd,unsigned long arg); +#endif /* __DLB2_IOCTL_H */
drivers/misc/dlb2/dlb2_main.c +2 -0
@@ -154,6 +154,8 @@ static int dlb2_domain_close(struct inode *i, struct file *f)const struct file_operations dlb2_domain_fops = { .owner =THIS_MODULE , .release = dlb2_domain_close, + .unlocked_ioctl = dlb2_domain_ioctl, + .compat_ioctl = compat_ptr_ioctl, };/**********************************/
drivers/misc/dlb2/dlb2_main.h +16 -0
@@ -60,9 +60,25 @@ struct dlb2_device_ops {int (*create_sched_domain)(struct dlb2_hw *hw,struct dlb2_create_sched_domain_args *args,struct dlb2_cmd_response *resp); +int (*create_ldb_queue)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_create_ldb_queue_args *args, +struct dlb2_cmd_response *resp); +int (*create_dir_queue)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_create_dir_queue_args *args, +struct dlb2_cmd_response *resp);int (*get_num_resources)(struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args);int (*reset_domain)(struct dlb2_hw *hw,u32 domain_id); +int (*get_ldb_queue_depth)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_get_ldb_queue_depth_args *args, +struct dlb2_cmd_response *resp); +int (*get_dir_queue_depth)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_get_dir_queue_depth_args *args, +struct dlb2_cmd_response *resp);void (*init_hardware)(struct dlb2_dev *dev); };
drivers/misc/dlb2/dlb2_pf_ops.c +40 -0
@@ -216,6 +216,24 @@ dlb2_pf_create_sched_domain(struct dlb2_hw *hw, }static int +dlb2_pf_create_ldb_queue (struct dlb2_hw *hw, +u32 id, +struct dlb2_create_ldb_queue_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_create_ldb_queue (hw, id, args, resp, false,0 ); +} + +static int +dlb2_pf_create_dir_queue (struct dlb2_hw *hw, +u32 id, +struct dlb2_create_dir_queue_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_create_dir_queue (hw, id, args, resp, false,0 ); +} + +static int dlb2_pf_get_num_resources (struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args) {
@@ -228,6 +246,24 @@ dlb2_pf_reset_domain(struct dlb2_hw *hw, u32 id)return dlb2_reset_domain (hw, id, false,0 ); } +static int +dlb2_pf_get_ldb_queue_depth (struct dlb2_hw *hw, +u32 id, +struct dlb2_get_ldb_queue_depth_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_get_ldb_queue_depth (hw, id, args, resp, false,0 ); +} + +static int +dlb2_pf_get_dir_queue_depth (struct dlb2_hw *hw, +u32 id, +struct dlb2_get_dir_queue_depth_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_get_dir_queue_depth (hw, id, args, resp, false,0 ); +} +/********************************/ /****** DLB2 PF Device Ops ******/ /********************************/
@@ -246,7 +282,11 @@ struct dlb2_device_ops dlb2_pf_ops = { .enable_pm = dlb2_pf_enable_pm, .wait_for_device_ready = dlb2_pf_wait_for_device_ready, .create_sched_domain = dlb2_pf_create_sched_domain, + .create_ldb_queue = dlb2_pf_create_ldb_queue, + .create_dir_queue = dlb2_pf_create_dir_queue, .get_num_resources = dlb2_pf_get_num_resources, .reset_domain = dlb2_pf_reset_domain, + .get_ldb_queue_depth = dlb2_pf_get_ldb_queue_depth, + .get_dir_queue_depth = dlb2_pf_get_dir_queue_depth, .init_hardware = dlb2_pf_init_hardware, };
drivers/misc/dlb2/dlb2_resource.c +732 -0
774 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +125 -0
137 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +138 -0
149 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 8/19 dlb2: add ioctl to configure ports, query poll mode
In reply to Gage EadsThe port is a core's interface to the DLB, and it consists of an MMIO page (the "producer port" (PP)) through which the core enqueues a queue entry and an in-memory queue (the "consumer queue" (CQ)) to which the device schedules QEs. The driver allocates DMA memory for each port's CQ, and frees this memory during domain reset or driver removal. A subsequent commit will add the mmap interface for an application to directly access the PP and CQ regions.
The device supports two formats ("standard" and "sparse") for CQ entries, dubbed the "poll mode". This (device-wide) mode is selected by the driver; to determine the mode at run time, the driver provides an ioctl for user-space software to query which mode the driver has configured. In this way, the policy of which mode to use is decoupled from user-space software.
--- drivers/misc/dlb2/dlb2_hw_types.h | 1 + drivers/misc/dlb2/dlb2_ioctl.c | 150 +++++++ drivers/misc/dlb2/dlb2_main.c | 70 +++ drivers/misc/dlb2/dlb2_main.h | 23 + drivers/misc/dlb2/dlb2_pf_ops.c | 46 ++ drivers/misc/dlb2/dlb2_resource.c | 922 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 89 ++++ include/uapi/linux/dlb2_user.h | 99 ++++ 8 files changed, 1400 insertions(+)
drivers/misc/dlb2/dlb2_hw_types.h +1 -0
@@ -317,6 +317,7 @@ struct dlb2_hw {/* Virtualization */ int virt_mode; + unsigned int pasid[DLB2_MAX_NUM_VDEVS]; };#endif /* __DLB2_HW_TYPES_H */
drivers/misc/dlb2/dlb2_ioctl.c +150 -0
174 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.c +70 -0
87 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h +23 -0
@@ -68,6 +68,16 @@ struct dlb2_device_ops {u32 domain_id, struct dlb2_create_dir_queue_args *args, struct dlb2_cmd_response *resp); +int (*create_ldb_port)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_create_ldb_port_args *args, +uintptr_t cq_dma_base, +struct dlb2_cmd_response *resp); +int (*create_dir_port)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_create_dir_port_args *args, +uintptr_t cq_dma_base, +struct dlb2_cmd_response *resp);int (*get_num_resources)(struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args);int (*reset_domain)(struct dlb2_hw *hw,u32 domain_id);
@@ -80,11 +90,22 @@ struct dlb2_device_ops {struct dlb2_get_dir_queue_depth_args *args, struct dlb2_cmd_response *resp);void (*init_hardware)(struct dlb2_dev *dev); +int (*query_cq_poll_mode)(struct dlb2_dev *dev, +struct dlb2_cmd_response *user_resp); };extern struct dlb2_device_ops dlb2_pf_ops;extern const struct file_operations dlb2_domain_fops; +struct dlb2_port { +void *cq_base; +dma_addr_t cq_dma_base; +struct dlb2_domain *domain; +int id; +u8 is_ldb; +u8 valid; +}; +struct dlb2_domain {struct dlb2_dev *dlb2_dev;struct kref refcnt;
@@ -99,6 +120,8 @@ struct dlb2_dev {struct list_head list;struct device *dlb2_device;struct dlb2_domain *sched_domains[DLB2_MAX_NUM_DOMAINS ]; +struct dlb2_port ldb_port[DLB2_MAX_NUM_LDB_PORTS ]; +struct dlb2_port dir_port[DLB2_MAX_NUM_DIR_PORTS ];/* * The resource mutex serializes access to driver data structures and * hardware registers.
drivers/misc/dlb2/dlb2_pf_ops.c +46 -0
76 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.c +922 -0
943 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +89 -0
99 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +99 -0
136 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 9/19 dlb2: add port mmap support
In reply to Gage EadsOnce a port is created, the application can mmap the corresponding DMA memory and MMIO into user-space. This allows user-space applications to do (performance-sensitive) enqueue and dequeue independent of the kernel driver.
The mmap callback is only available through special port files: a producer port (PP) file and a consumer queue (CQ) file. User-space gets an fd for these files by calling a new ioctl, DLB2_DOMAIN_CMD_GET_{LDB, DIR}_PORT_{PP, CQ}_FD, and passing in a port ID. If the ioctl succeeds, the returned fd can be used to mmap that port's PP/CQ.
Device reset requires first unmapping all user-space mappings, to prevent applications from interfering with the reset operation. To this end, the driver uses a single inode -- allocated when the first PP/CQ file is created, and freed when the last such file is closed -- and attaches all port files to this common inode, as done elsewhere in Linux (e.g. cxl, dax).
Allocating this inode requires creating a pseudo-filesystem. The driver initializes this FS when the inode is allocated, and frees the FS after the inode is freed.
The driver doesn't use anon_inode_getfd() for these port mmap files because the anon inode layer uses a single inode that is shared with other kernel components -- calling unmap_mapping_range() on that shared inode would likely break the kernel.
--- drivers/misc/dlb2/Makefile | 1 + drivers/misc/dlb2/dlb2_file.c | 133 ++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_file.h | 19 +++++ drivers/misc/dlb2/dlb2_ioctl.c | 154 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.c | 100 +++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.h | 13 ++++ drivers/misc/dlb2/dlb2_pf_ops.c | 22 ++++++ drivers/misc/dlb2/dlb2_resource.c | 99 ++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 50 +++++++++++++ include/uapi/linux/dlb2_user.h | 59 +++++++++++++++ 10 files changed, 650 insertions(+) create mode 100644 drivers/misc/dlb2/dlb2_file.c create mode 100644 drivers/misc/dlb2/dlb2_file.h
drivers/misc/dlb2/Makefile +1 -0
@@ -6,6 +6,7 @@ obj-$(CONFIG_INTEL_DLB2) := dlb2.o dlb2-objs := \ dlb2_main.o \ + dlb2_file.o \ dlb2_ioctl.o \ dlb2_pf_ops.o \ dlb2_resource.o \
drivers/misc/dlb2/dlb2_file.c new file +133 -0
133 lines not on this page · raw message
drivers/misc/dlb2/dlb2_file.h new file +19 -0
@@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0-only +* Copyright(c) 2020 Intel Corporation +*/ + +#ifndef __DLB2_FILE_H +#define __DLB2_FILE_H + +#include <linux/file.h> + +#include "dlb2_main.h" + +void dlb2_release_fs (struct dlb2_dev *dev); + +struct file *dlb2_getfile (struct dlb2_dev *dev, +int flags, +const struct file_operations *fops, +const char *name); + +#endif /* __DLB2_FILE_H */
drivers/misc/dlb2/dlb2_ioctl.c +154 -0
172 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.c +100 -0
112 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h +13 -0
@@ -81,6 +81,12 @@ struct dlb2_device_ops {int (*get_num_resources)(struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args);int (*reset_domain)(struct dlb2_hw *hw,u32 domain_id); +int (*ldb_port_owned_by_domain)(struct dlb2_hw *hw, +u32 domain_id, +u32 port_id); +int (*dir_port_owned_by_domain)(struct dlb2_hw *hw, +u32 domain_id, +u32 port_id); int (*get_ldb_queue_depth)(struct dlb2_hw *hw, u32 domain_id, struct dlb2_get_ldb_queue_depth_args *args,
@@ -96,6 +102,8 @@ struct dlb2_device_ops {extern struct dlb2_device_ops dlb2_pf_ops;extern const struct file_operations dlb2_domain_fops; +extern const struct file_operations dlb2_pp_fops; +extern const struct file_operations dlb2_cq_fops;struct dlb2_port {void *cq_base;
@@ -123,6 +131,11 @@ struct dlb2_dev {struct dlb2_port ldb_port[DLB2_MAX_NUM_LDB_PORTS ];struct dlb2_port dir_port[DLB2_MAX_NUM_DIR_PORTS ];/* +* Anonymous inode used to share an address_space for all domain +* device file mappings. +*/ +struct inode *inode; +/* * The resource mutex serializes access to driver data structures and * hardware registers. */
drivers/misc/dlb2/dlb2_pf_ops.c +22 -0
@@ -307,6 +307,26 @@ dlb2_pf_query_cq_poll_mode(struct dlb2_dev *dlb2_dev,return 0 ; } +/**************************************/ +/****** Resource query callbacks ******/ +/**************************************/ + +static int +dlb2_pf_ldb_port_owned_by_domain (struct dlb2_hw *hw, +u32 domain_id, +u32 port_id) +{ +return dlb2_ldb_port_owned_by_domain (hw, domain_id, port_id, false,0 ); +} + +static int +dlb2_pf_dir_port_owned_by_domain (struct dlb2_hw *hw, +u32 domain_id, +u32 port_id) +{ +return dlb2_dir_port_owned_by_domain (hw, domain_id, port_id, false,0 ); +} +/********************************/ /****** DLB2 PF Device Ops ******/ /********************************/
@@ -331,6 +351,8 @@ struct dlb2_device_ops dlb2_pf_ops = { .create_dir_port = dlb2_pf_create_dir_port, .get_num_resources = dlb2_pf_get_num_resources, .reset_domain = dlb2_pf_reset_domain, + .ldb_port_owned_by_domain = dlb2_pf_ldb_port_owned_by_domain, + .dir_port_owned_by_domain = dlb2_pf_dir_port_owned_by_domain, .get_ldb_queue_depth = dlb2_pf_get_ldb_queue_depth, .get_dir_queue_depth = dlb2_pf_get_dir_queue_depth, .init_hardware = dlb2_pf_init_hardware,
drivers/misc/dlb2/dlb2_resource.c +99 -0
117 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +50 -0
56 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +59 -0
82 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 10/19 dlb2: add start domain ioctl
In reply to Gage EadsOnce a scheduling domain and its resources have been configured, the start domain ioctl is called to enable its ports to begin enqueueing to the device. Once started, the domain's resources cannot be configured again until after the domain is reset.
--- drivers/misc/dlb2/dlb2_ioctl.c | 3 + drivers/misc/dlb2/dlb2_main.h | 4 ++ drivers/misc/dlb2/dlb2_pf_ops.c | 10 ++++ drivers/misc/dlb2/dlb2_resource.c | 120 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 30 ++++++++++ include/uapi/linux/dlb2_user.h | 22 +++++++ 6 files changed, 189 insertions(+)
drivers/misc/dlb2/dlb2_ioctl.c +3 -0
@@ -51,6 +51,7 @@ DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(create_ldb_queue) DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(create_dir_queue) DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(get_ldb_queue_depth) DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(get_dir_queue_depth) +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(start_domain) /* * Port creation ioctls don't use the callback template macro because they have
@@ -343,6 +344,8 @@ long dlb2_domain_ioctl(struct file *f, unsigned int cmd, unsigned long arg)return dlb2_domain_ioctl_get_dir_port_pp_fd (dev, dom, arg);case DLB2_IOC_GET_DIR_PORT_CQ_FD :return dlb2_domain_ioctl_get_dir_port_cq_fd (dev, dom, arg); +case DLB2_IOC_START_DOMAIN : +return dlb2_domain_ioctl_start_domain (dev, dom, arg);default :return -ENOTTY ; }
drivers/misc/dlb2/dlb2_main.h +4 -0
@@ -78,6 +78,10 @@ struct dlb2_device_ops {struct dlb2_create_dir_port_args *args, uintptr_t cq_dma_base, struct dlb2_cmd_response *resp); +int (*start_domain)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_start_domain_args *args, +struct dlb2_cmd_response *resp);int (*get_num_resources)(struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args);int (*reset_domain)(struct dlb2_hw *hw,u32 domain_id);
drivers/misc/dlb2/dlb2_pf_ops.c +10 -0
@@ -263,6 +263,15 @@ dlb2_pf_create_dir_port(struct dlb2_hw *hw, }static int +dlb2_pf_start_domain (struct dlb2_hw *hw, +u32 id, +struct dlb2_start_domain_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_start_domain (hw, id, args, resp, false,0 ); +} + +static int dlb2_pf_get_num_resources (struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args) {
@@ -349,6 +358,7 @@ struct dlb2_device_ops dlb2_pf_ops = { .create_dir_queue = dlb2_pf_create_dir_queue, .create_ldb_port = dlb2_pf_create_ldb_port, .create_dir_port = dlb2_pf_create_dir_port, + .start_domain = dlb2_pf_start_domain, .get_num_resources = dlb2_pf_get_num_resources, .reset_domain = dlb2_pf_reset_domain, .ldb_port_owned_by_domain = dlb2_pf_ldb_port_owned_by_domain,
drivers/misc/dlb2/dlb2_resource.c +120 -0
132 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +30 -0
@@ -209,6 +209,36 @@ int dlb2_hw_create_ldb_port(struct dlb2_hw *hw, unsigned int vdev_id);/** +* dlb2_hw_start_domain() - start a scheduling domain +* @hw: dlb2_hw handle for a particular device. +* @domain_id: domain ID. +* @args: start domain arguments. +* @resp: response structure. +* @vdev_request: indicates whether this request came from a vdev. +* @vdev_id: If vdev_request is true, this contains the vdev's ID. +* +* This function starts a scheduling domain, which allows applications to send +* traffic through it. Once a domain is started, its resources can no longer be +* configured (besides QID remapping and port enable/disable). +* +* A vdev can be either an SR-IOV virtual function or a Scalable IOV virtual +* device. +* +* Return: +* Returns 0 upon success, < 0 otherwise. If an error occurs, resp->status is +* assigned a detailed error code from enum dlb2_error. +* +* Errors: +* EINVAL - the domain is not configured, or the domain is already started. +*/ +int dlb2_hw_start_domain (struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_start_domain_args *args, +struct dlb2_cmd_response *resp, +bool vdev_request, +unsigned int vdev_id); + +/** * dlb2_reset_domain() - reset a scheduling domain * @hw: dlb2_hw handle for a particular device. * @domain_id: domain ID.
include/uapi/linux/dlb2_user.h +22 -0
@@ -456,6 +456,23 @@ struct dlb2_get_port_fd_args {__u32 padding0; }; +/* +* DLB2_DOMAIN_CMD_START_DOMAIN: Mark the end of the domain configuration. This +* must be called before passing QEs into the device, and no configuration +* ioctls can be issued once the domain has started. Sending QEs into the +* device before calling this ioctl will result in undefined behavior. +* Input parameters: +* - (None) +* +* Output parameters: +* - response.status: Detailed error code. In certain cases, such as if the +* ioctl request arg is invalid, the driver won't set status. +*/ +struct dlb2_start_domain_args { +/* Output parameters */ +struct dlb2_cmd_response response; +}; +enum dlb2_domain_user_interface_commands {DLB2_DOMAIN_CMD_CREATE_LDB_QUEUE ,DLB2_DOMAIN_CMD_CREATE_DIR_QUEUE ,
@@ -467,6 +484,7 @@ enum dlb2_domain_user_interface_commands {DLB2_DOMAIN_CMD_GET_LDB_PORT_CQ_FD ,DLB2_DOMAIN_CMD_GET_DIR_PORT_PP_FD ,DLB2_DOMAIN_CMD_GET_DIR_PORT_CQ_FD , +DLB2_DOMAIN_CMD_START_DOMAIN ,/* NUM_DLB2_DOMAIN_CMD must be last */ NUM_DLB2_DOMAIN_CMD,
@@ -541,5 +559,9 @@ enum dlb2_domain_user_interface_commands {_IOWR (DLB2_IOC_MAGIC , \DLB2_DOMAIN_CMD_GET_DIR_PORT_CQ_FD , \ struct dlb2_get_port_fd_args) +#define DLB2_IOC_START_DOMAIN \ + _IOR(DLB2_IOC_MAGIC, \ + DLB2_DOMAIN_CMD_START_DOMAIN, \ + struct dlb2_start_domain_args)#endif /* __DLB2_USER_H */
Signature · 1 line
2.13.6
PATCH v3 11/19 dlb2: add queue map and unmap ioctls
In reply to Gage EadsLoad-balanced queues can be "mapped" to any number of load-balanced ports. Once mapped, the port becomes a candidate to which the device can schedule queue entries from the queue. If a port is unmapped from a queue, it is no longer a candidate for scheduling from that queue.
The process for map and unmap is different depending on whether or not the domain is started, because the process requires updating hardware structures that are dynamically modified by the device when it's in use. If the domain is not started, its ports and queues are guaranteed not to be in active use.
If the domain is started, the map process must (temporarily) disable the queue and wait for it to quiesce. Similarly, the unmap process must (temporarily) disable the port and wait for it to quiesce. 'Quiesce' here means the user processes any in-flight QEs.
It's possible that the thread that requires the map/unmap is the same one which is responsible for doing the processing that would quiesce the queue/port, thus the driver may have to complete the operation asynchronously. To that end, the driver uses a workqueue that periodically checks whether any outstanding operations can be completed. This workqueue function is only scheduled when there is at least one outstanding map/unmap operation.
To support this asynchronous operation while also providing a reasonably usable user-interface, the driver maintains two views of the queue map state:
- The hardware view: the actual queue map state in the device
- The user/software view: the queue map state as though the operations were synchronous.
While a map/unmap operation is inflight, these two views are out-of-sync. When the user requests a new map/unmap operation, the driver verifies the request against the software view, so the errors are synchronous from the user’s perspective, then adds the request to the queue of in-progress operations. When possible -- for example if the user requests to map a queue and then immediately requests to unmap it -- the driver will coalesce or cancel outstanding operations.
This commit also adds a pending-port-unmaps ioctl, that user-space can call to query how many pending/outstanding unmap operations exist for a given port.
--- drivers/misc/dlb2/dlb2_ioctl.c | 9 + drivers/misc/dlb2/dlb2_main.h | 14 + drivers/misc/dlb2/dlb2_pf_ops.c | 30 ++ drivers/misc/dlb2/dlb2_resource.c | 789 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 111 ++++++ include/uapi/linux/dlb2_user.h | 79 ++++ 6 files changed, 1032 insertions(+)
drivers/misc/dlb2/dlb2_ioctl.c +9 -0
@@ -52,6 +52,9 @@ DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(create_dir_queue) DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(get_ldb_queue_depth) DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(get_dir_queue_depth) DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(start_domain) +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(map_qid) +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(unmap_qid) +DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(pending_port_unmaps)/* * Port creation ioctls don't use the callback template macro because they have
@@ -346,6 +349,12 @@ long dlb2_domain_ioctl(struct file *f, unsigned int cmd, unsigned long arg)return dlb2_domain_ioctl_get_dir_port_cq_fd (dev, dom, arg);case DLB2_IOC_START_DOMAIN :return dlb2_domain_ioctl_start_domain (dev, dom, arg); +case DLB2_IOC_MAP_QID : +return dlb2_domain_ioctl_map_qid (dev, dom, arg); +case DLB2_IOC_UNMAP_QID : +return dlb2_domain_ioctl_unmap_qid (dev, dom, arg); +case DLB2_IOC_PENDING_PORT_UNMAPS : +return dlb2_domain_ioctl_pending_port_unmaps (dev, dom, arg);default :return -ENOTTY ; }
drivers/misc/dlb2/dlb2_main.h +14 -0
@@ -82,6 +82,18 @@ struct dlb2_device_ops {u32 domain_id, struct dlb2_start_domain_args *args, struct dlb2_cmd_response *resp); +int (*map_qid)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_map_qid_args *args, +struct dlb2_cmd_response *resp); +int (*unmap_qid)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_unmap_qid_args *args, +struct dlb2_cmd_response *resp); +int (*pending_port_unmaps)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_pending_port_unmaps_args *args, +struct dlb2_cmd_response *resp);int (*get_num_resources)(struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args);int (*reset_domain)(struct dlb2_hw *hw,u32 domain_id);
@@ -144,10 +156,12 @@ struct dlb2_dev {* hardware registers. */ struct mutex resource_mutex; +struct work_struct work;enum dlb2_device_type type;int id;dev_t dev_number;u8 domain_reset_failed; +u8 worker_launched; };int dlb2_init_domain (struct dlb2_dev *dlb2_dev,u32 domain_id);
drivers/misc/dlb2/dlb2_pf_ops.c +30 -0
@@ -272,6 +272,33 @@ dlb2_pf_start_domain(struct dlb2_hw *hw, }static int +dlb2_pf_map_qid (struct dlb2_hw *hw, +u32 id, +struct dlb2_map_qid_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_map_qid (hw, id, args, resp, false,0 ); +} + +static int +dlb2_pf_unmap_qid (struct dlb2_hw *hw, +u32 id, +struct dlb2_unmap_qid_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_unmap_qid (hw, id, args, resp, false,0 ); +} + +static int +dlb2_pf_pending_port_unmaps (struct dlb2_hw *hw, +u32 id, +struct dlb2_pending_port_unmaps_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_pending_port_unmaps (hw, id, args, resp, false,0 ); +} + +static int dlb2_pf_get_num_resources (struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args) {
@@ -359,6 +386,9 @@ struct dlb2_device_ops dlb2_pf_ops = { .create_ldb_port = dlb2_pf_create_ldb_port, .create_dir_port = dlb2_pf_create_dir_port, .start_domain = dlb2_pf_start_domain, + .map_qid = dlb2_pf_map_qid, + .unmap_qid = dlb2_pf_unmap_qid, + .pending_port_unmaps = dlb2_pf_pending_port_unmaps, .get_num_resources = dlb2_pf_get_num_resources, .reset_domain = dlb2_pf_reset_domain, .ldb_port_owned_by_domain = dlb2_pf_ldb_port_owned_by_domain,
drivers/misc/dlb2/dlb2_resource.c +789 -0
855 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +111 -0
123 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +79 -0
96 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 12/19 dlb2: add port enable/disable ioctls
In reply to Gage EadsThe ioctls can be used to dynamically enable or disable scheduling to a port. (By default, ports start with their scheduling enabled.) Doing so allows software to, for example, quickly add/remove cores to/from a worker pool.
--- drivers/misc/dlb2/dlb2_ioctl.c | 112 +++++++++++ drivers/misc/dlb2/dlb2_main.h | 16 ++ drivers/misc/dlb2/dlb2_pf_ops.c | 40 ++++ drivers/misc/dlb2/dlb2_resource.c | 382 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 120 ++++++++++++ include/uapi/linux/dlb2_user.h | 92 +++++++++ 6 files changed, 762 insertions(+)
drivers/misc/dlb2/dlb2_ioctl.c +112 -0
@@ -57,6 +57,110 @@ DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE(unmap_qid)DLB2_DOMAIN_IOCTL_CALLBACK_TEMPLATE (pending_port_unmaps)/* +* Port enable/disable ioctls don't use the callback template macro because +* they have additional CQ interrupt management logic. +*/ +static int dlb2_domain_ioctl_enable_ldb_port(struct dlb2_dev *dev, +struct dlb2_domain *domain, +unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_enable_ldb_port_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->enable_ldb_port (&dev->hw, domain->id, &arg, &response); + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} + +static int dlb2_domain_ioctl_enable_dir_port (struct dlb2_dev *dev, +struct dlb2_domain *domain, +unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_enable_dir_port_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->enable_dir_port (&dev->hw, domain->id, &arg, &response); + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} + +static int dlb2_domain_ioctl_disable_ldb_port (struct dlb2_dev *dev, +struct dlb2_domain *domain, +unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_disable_ldb_port_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->disable_ldb_port (&dev->hw, domain->id, &arg, &response); + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} + +static int dlb2_domain_ioctl_disable_dir_port (struct dlb2_dev *dev, +struct dlb2_domain *domain, +unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_disable_dir_port_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->disable_dir_port (&dev->hw, domain->id, &arg, &response); + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} + +/* * Port creation ioctls don't use the callback template macro because they have * a number of OS-dependent memory operations. */
@@ -355,6 +459,14 @@ long dlb2_domain_ioctl(struct file *f, unsigned int cmd, unsigned long arg)return dlb2_domain_ioctl_unmap_qid (dev, dom, arg);case DLB2_IOC_PENDING_PORT_UNMAPS :return dlb2_domain_ioctl_pending_port_unmaps (dev, dom, arg); +case DLB2_IOC_ENABLE_LDB_PORT : +return dlb2_domain_ioctl_enable_ldb_port (dev, dom, arg); +case DLB2_IOC_ENABLE_DIR_PORT : +return dlb2_domain_ioctl_enable_dir_port (dev, dom, arg); +case DLB2_IOC_DISABLE_LDB_PORT : +return dlb2_domain_ioctl_disable_ldb_port (dev, dom, arg); +case DLB2_IOC_DISABLE_DIR_PORT : +return dlb2_domain_ioctl_disable_dir_port (dev, dom, arg);default :return -ENOTTY ; }
drivers/misc/dlb2/dlb2_main.h +16 -0
@@ -94,6 +94,22 @@ struct dlb2_device_ops {u32 domain_id, struct dlb2_pending_port_unmaps_args *args, struct dlb2_cmd_response *resp); +int (*enable_ldb_port)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_enable_ldb_port_args *args, +struct dlb2_cmd_response *resp); +int (*disable_ldb_port)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_disable_ldb_port_args *args, +struct dlb2_cmd_response *resp); +int (*enable_dir_port)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_enable_dir_port_args *args, +struct dlb2_cmd_response *resp); +int (*disable_dir_port)(struct dlb2_hw *hw, +u32 domain_id, +struct dlb2_disable_dir_port_args *args, +struct dlb2_cmd_response *resp);int (*get_num_resources)(struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args);int (*reset_domain)(struct dlb2_hw *hw,u32 domain_id);
drivers/misc/dlb2/dlb2_pf_ops.c +40 -0
@@ -299,6 +299,42 @@ dlb2_pf_pending_port_unmaps(struct dlb2_hw *hw, }static int +dlb2_pf_enable_ldb_port (struct dlb2_hw *hw, +u32 id, +struct dlb2_enable_ldb_port_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_enable_ldb_port (hw, id, args, resp, false,0 ); +} + +static int +dlb2_pf_disable_ldb_port (struct dlb2_hw *hw, +u32 id, +struct dlb2_disable_ldb_port_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_disable_ldb_port (hw, id, args, resp, false,0 ); +} + +static int +dlb2_pf_enable_dir_port (struct dlb2_hw *hw, +u32 id, +struct dlb2_enable_dir_port_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_enable_dir_port (hw, id, args, resp, false,0 ); +} + +static int +dlb2_pf_disable_dir_port (struct dlb2_hw *hw, +u32 id, +struct dlb2_disable_dir_port_args *args, +struct dlb2_cmd_response *resp) +{ +return dlb2_hw_disable_dir_port (hw, id, args, resp, false,0 ); +} + +static int dlb2_pf_get_num_resources (struct dlb2_hw *hw,struct dlb2_get_num_resources_args *args) {
@@ -389,6 +425,10 @@ struct dlb2_device_ops dlb2_pf_ops = { .map_qid = dlb2_pf_map_qid, .unmap_qid = dlb2_pf_unmap_qid, .pending_port_unmaps = dlb2_pf_pending_port_unmaps, + .enable_ldb_port = dlb2_pf_enable_ldb_port, + .enable_dir_port = dlb2_pf_enable_dir_port, + .disable_ldb_port = dlb2_pf_disable_ldb_port, + .disable_dir_port = dlb2_pf_disable_dir_port, .get_num_resources = dlb2_pf_get_num_resources, .reset_domain = dlb2_pf_reset_domain, .ldb_port_owned_by_domain = dlb2_pf_ldb_port_owned_by_domain,
drivers/misc/dlb2/dlb2_resource.c +382 -0
394 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +120 -0
126 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +92 -0
109 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 13/19 dlb2: add CQ interrupt support
In reply to Gage EadsDLB 2.0 supports interrupt-driven applications with per-CQ interrupts. A CQ interrupt is armed by user-space software by enqueueing a special command to the device through the port's MMIO window, and the interrupt fires when the armed CQ becomes non-empty.
All CQ interrupts use a single MSI-X interrupt vector, and the ISR reads bitmap registers to determine which CQ(s)'s interrupt fired. For each of these CQs, the driver wakes up a wait-queue -- on which user-space threads may be blocking waiting for the interrupt. User-space software calls a block-on-CQ-interrupt ioctl in order to block on the wait queue.
A CQ's interrupt is enabled when its port is configured, and interrupts are enabled/disabled when a port is enabled/disabled. If a port is disabled and a thread is blocked on the wait queue, the thread is woken and returned to user-space.
--- drivers/misc/dlb2/Makefile | 1 + drivers/misc/dlb2/dlb2_hw_types.h | 13 ++ drivers/misc/dlb2/dlb2_intr.c | 130 ++++++++++++++++ drivers/misc/dlb2/dlb2_intr.h | 29 ++++ drivers/misc/dlb2/dlb2_ioctl.c | 70 +++++++++ drivers/misc/dlb2/dlb2_main.c | 20 ++- drivers/misc/dlb2/dlb2_main.h | 43 ++++++ drivers/misc/dlb2/dlb2_pf_ops.c | 211 ++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.c | 306 ++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 128 ++++++++++++++++ include/uapi/linux/dlb2_user.h | 37 +++++ 11 files changed, 987 insertions(+), 1 deletion(-) create mode 100644 drivers/misc/dlb2/dlb2_intr.c create mode 100644 drivers/misc/dlb2/dlb2_intr.h
drivers/misc/dlb2/Makefile +1 -0
@@ -6,6 +6,7 @@ obj-$(CONFIG_INTEL_DLB2) := dlb2.o dlb2-objs := \ dlb2_main.o \ + dlb2_intr.o \ dlb2_file.o \ dlb2_ioctl.o \ dlb2_pf_ops.o \
drivers/misc/dlb2/dlb2_hw_types.h +13 -0
@@ -48,6 +48,19 @@#define DLB2_MAX_QID_EMPTY_CHECK_LOOPS (32 * 64 * 1024 * (800 / 30))#define DLB2_HZ 800000000 +/* Interrupt related macros */ +#define DLB2_PF_NUM_NON_CQ_INTERRUPT_VECTORS 1 +#define DLB2_PF_NUM_CQ_INTERRUPT_VECTORS 64 +#define DLB2_PF_TOTAL_NUM_INTERRUPT_VECTORS \ + (DLB2_PF_NUM_NON_CQ_INTERRUPT_VECTORS + \ + DLB2_PF_NUM_CQ_INTERRUPT_VECTORS) +#define DLB2_PF_NUM_COMPRESSED_MODE_VECTORS \ + (DLB2_PF_NUM_NON_CQ_INTERRUPT_VECTORS + 1) +#define DLB2_PF_NUM_PACKED_MODE_VECTORS \ + DLB2_PF_TOTAL_NUM_INTERRUPT_VECTORS +#define DLB2_PF_COMPRESSED_MODE_CQ_VECTOR_ID \ + DLB2_PF_NUM_NON_CQ_INTERRUPT_VECTORS +/* * Hardware-defined base addresses. Those prefixed 'DLB2_DRV' are only used by * the PF driver.
drivers/misc/dlb2/dlb2_intr.c new file +130 -0
130 lines not on this page · raw message
drivers/misc/dlb2/dlb2_intr.h new file +29 -0
@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-2.0-only +* Copyright(c) 2017-2020 Intel Corporation +*/ + +#ifndef __DLB2_INTR_H +#define __DLB2_INTR_H + +#include <linux/pci.h> + +#include "dlb2_main.h" + +int dlb2_block_on_cq_interrupt (struct dlb2_dev *dev, +struct dlb2_domain *domain, +int port_id, +bool is_ldb, +u64 cq_va, +u8 cq_gen, +bool arm); + +enum dlb2_wake_reason { +WAKE_CQ_INTR , +WAKE_PORT_DISABLED , +}; + +void dlb2_wake_thread (struct dlb2_dev *dev, +struct dlb2_cq_intr *intr, +enum dlb2_wake_reason reason); + +#endif /* __DLB2_INTR_H */
drivers/misc/dlb2/dlb2_ioctl.c +70 -0
124 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.c +19 -1
@@ -174,13 +174,20 @@ static void dlb2_release_device_memory(struct dlb2_dev *dev)static int __dlb2_free_domain (struct dlb2_dev *dev,struct dlb2_domain *domain) { -int ret =0 ; +int i, ret =0 ; ret = dev->ops->reset_domain (&dev->hw, domain->id);/* Unpin and free all memory pages associated with the domain */ dlb2_release_domain_memory (dev, domain->id); +for (i =0 ; i <DLB2_MAX_NUM_LDB_PORTS ; i++) +if (dev->intr.ldb_cq_intr[i].domain_id == domain->id) + dev->intr.ldb_cq_intr[i].configured = false; +for (i =0 ; i <DLB2_MAX_NUM_DIR_PORTS ; i++) +if (dev->intr.dir_cq_intr[i].domain_id == domain->id) + dev->intr.dir_cq_intr[i].configured = false; +if (ret) { dev->domain_reset_failed = true; dev_err(dev->dlb2_device,
@@ -430,6 +437,10 @@ static int dlb2_probe(struct pci_dev *pdev,if (ret) goto dlb2_reset_fail; + ret = dlb2_dev->ops->init_interrupts (dlb2_dev, pdev); +if (ret) + goto init_interrupts_fail; + ret =dlb2_resource_init (&dlb2_dev->hw);if (ret) goto resource_init_fail;
@@ -458,6 +469,8 @@ static int dlb2_probe(struct pci_dev *pdev, init_driver_state_fail:dlb2_resource_free (&dlb2_dev->hw); resource_init_fail: + dlb2_dev->ops->free_interrupts (dlb2_dev, pdev); +init_interrupts_fail: dlb2_reset_fail: wait_for_device_ready_fail: dma_set_mask_fail:
@@ -497,6 +510,8 @@ static void dlb2_remove(struct pci_dev *pdev)dlb2_resource_free (&dlb2_dev->hw); + dlb2_dev->ops->free_interrupts (dlb2_dev, pdev); +dlb2_release_device_memory (dlb2_dev); dlb2_dev->ops->device_destroy (dlb2_dev, dlb2_class);
@@ -521,6 +536,9 @@ static void dlb2_reset_hardware_state(struct dlb2_dev *dev) {dlb2_reset_device (dev->pdev); +/* Reinitialize interrupt configuration */ + dev->ops->reinit_interrupts (dev); +/* Reinitialize any other hardware state */ dev->ops->init_hardware (dev); }
drivers/misc/dlb2/dlb2_main.h +43 -0
61 lines not on this page · raw message
drivers/misc/dlb2/dlb2_pf_ops.c +211 -0
229 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.c +306 -0
324 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +128 -0
134 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +37 -0
@@ -609,6 +609,38 @@ struct dlb2_disable_dir_port_args {__u32 padding0; }; +/* +* DLB2_DOMAIN_CMD_BLOCK_ON_CQ_INTERRUPT: Block on a CQ interrupt until a QE +* arrives for the specified port. If a QE is already present, the ioctl +* will immediately return. +* +* Note: Only one thread can block on a CQ's interrupt at a time. Doing +* otherwise can result in hung threads. +* +* Input parameters: +* - port_id: Port ID. +* - is_ldb: True if the port is load-balanced, false otherwise. +* - arm: Tell the driver to arm the interrupt. +* - cq_gen: Current CQ generation bit. +* - padding0: Reserved for future use. +* - cq_va: VA of the CQ entry where the next QE will be placed. +* +* Output parameters: +* - response.status: Detailed error code. In certain cases, such as if the +* ioctl request arg is invalid, the driver won't set status. +*/ +struct dlb2_block_on_cq_interrupt_args { +/* Output parameters */ +struct dlb2_cmd_response response; +/* Input parameters */ +__u32 port_id; +__u8 is_ldb; +__u8 arm; +__u8 cq_gen; +__u8 padding0; +__u64 cq_va; +}; +enum dlb2_domain_user_interface_commands {DLB2_DOMAIN_CMD_CREATE_LDB_QUEUE ,DLB2_DOMAIN_CMD_CREATE_DIR_QUEUE ,
@@ -628,6 +660,7 @@ enum dlb2_domain_user_interface_commands {DLB2_DOMAIN_CMD_ENABLE_DIR_PORT ,DLB2_DOMAIN_CMD_DISABLE_LDB_PORT ,DLB2_DOMAIN_CMD_DISABLE_DIR_PORT , +DLB2_DOMAIN_CMD_BLOCK_ON_CQ_INTERRUPT ,/* NUM_DLB2_DOMAIN_CMD must be last */ NUM_DLB2_DOMAIN_CMD,
@@ -734,5 +767,9 @@ enum dlb2_domain_user_interface_commands {_IOWR (DLB2_IOC_MAGIC , \DLB2_DOMAIN_CMD_DISABLE_DIR_PORT , \ struct dlb2_disable_dir_port_args) +#define DLB2_IOC_BLOCK_ON_CQ_INTERRUPT \ + _IOWR(DLB2_IOC_MAGIC, \ + DLB2_DOMAIN_CMD_BLOCK_ON_CQ_INTERRUPT, \ + struct dlb2_block_on_cq_interrupt_args)#endif /* __DLB2_USER_H */
Signature · 1 line
2.13.6
PATCH v3 14/19 dlb2: add domain alert support
In reply to Gage EadsDomain alerts are a mechanism for the driver to asynchronously notify user-space applications of device reset or hardware alarms (both to be added in later commits). This mechanism also allows the application to enqueue an alert to its domain, as a form of (limited) IPC in a multi-process scenario.
An application can read its domain alerts through the domain device file's read callback. Applications are expected to spawn a thread that performs a blocking read, and rarely (if ever) wakes and returns to user-space.
--- drivers/misc/dlb2/dlb2_ioctl.c | 17 ++++++ drivers/misc/dlb2/dlb2_main.c | 130 +++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.h | 16 +++++ include/uapi/linux/dlb2_user.h | 134 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 297 insertions(+)
drivers/misc/dlb2/dlb2_ioctl.c +17 -0
@@ -493,6 +493,21 @@ static int dlb2_domain_ioctl_get_dir_port_cq_fd(struct dlb2_dev *dev, "dlb2_dir_cq:", &dlb2_cq_fops, false); } +static int dlb2_domain_ioctl_enqueue_domain_alert (struct dlb2_dev *dev, +struct dlb2_domain *domain, +unsigned long user_arg) +{ +struct dlb2_enqueue_domain_alert_args arg; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +return dlb2_write_domain_alert (dev, + domain, +DLB2_DOMAIN_ALERT_USER , + arg.aux_alert_data); +} +long dlb2_domain_ioctl (struct file *f,unsigned int cmd,unsigned long arg) {struct dlb2_domain *dom = f->private_data;
@@ -537,6 +552,8 @@ long dlb2_domain_ioctl(struct file *f, unsigned int cmd, unsigned long arg)return dlb2_domain_ioctl_disable_dir_port (dev, dom, arg);case DLB2_IOC_BLOCK_ON_CQ_INTERRUPT :return dlb2_domain_ioctl_block_on_cq_interrupt (dev, dom, arg); +case DLB2_IOC_ENQUEUE_DOMAIN_ALERT : +return dlb2_domain_ioctl_enqueue_domain_alert (dev, dom, arg);default :return -ENOTTY ; }
drivers/misc/dlb2/dlb2_main.c +130 -0
145 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h +16 -0
@@ -11,6 +11,7 @@#include <linux/list.h> #include <linux/mutex.h> #include <linux/pci.h> +#include <linux/spinlock.h> #include <linux/types.h> #include <uapi/linux/dlb2_user.h>
@@ -161,9 +162,20 @@ struct dlb2_port {u8 valid; }; +#define DLB2_DOMAIN_ALERT_RING_SIZE 256 +struct dlb2_domain {struct dlb2_dev *dlb2_dev; +struct dlb2_domain_alert alerts[DLB2_DOMAIN_ALERT_RING_SIZE ]; +wait_queue_head_t wq_head; +/* +* The alert lock protects access to the alert ring and its read and +* write indexes. +*/ +spinlock_t alert_lock;struct kref refcnt; +u8 alert_rd_idx; +u8 alert_wr_idx;u8 id; };
@@ -225,6 +237,10 @@ struct dlb2_dev {int dlb2_init_domain (struct dlb2_dev *dlb2_dev,u32 domain_id);void dlb2_free_domain (struct kref *kref); +int dlb2_write_domain_alert (struct dlb2_dev *dev, +struct dlb2_domain *domain, +u64 alert_id, +u64 aux_alert_data);#define DLB2_HW_ERR (dlb2, ...) do { \ struct dlb2_dev *dev; \
include/uapi/linux/dlb2_user.h +134 -0
157 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 15/19 dlb2: add sequence-number management ioctls
In reply to Gage EadsIn order for a load-balanced DLB 2.0 queue to support ordered scheduling, it must be configured with an allocation of sequence numbers (SNs) -- a hardware resource used to re-order QEs.
The device evenly partitions its SNs across two groups. A queue is allocated SNs by taking a 'slot' in one of these two groups, and the number of slots is variable. A group can support as many as 16 slots (64 SNs per slot) and as few as 1 slot (1024 SNs per slot).
This commit adds ioctls to get and set a sequence number group's slot configuration, as well as query the group's slot occupancy.
--- drivers/misc/dlb2/dlb2_ioctl.c | 86 +++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.h | 3 ++ drivers/misc/dlb2/dlb2_pf_ops.c | 21 ++++++++++ drivers/misc/dlb2/dlb2_resource.c | 67 ++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 47 +++++++++++++++++++++ include/uapi/linux/dlb2_user.h | 84 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 308 insertions(+)
drivers/misc/dlb2/dlb2_ioctl.c +86 -0
@@ -681,6 +681,86 @@ static int dlb2_ioctl_query_cq_poll_mode(struct dlb2_dev *dev,return ret; } +static int dlb2_ioctl_set_sn_allocation (struct dlb2_dev *dev, +unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_set_sn_allocation_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->set_sn_allocation (&dev->hw, arg.group, arg.num); + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} + +static int dlb2_ioctl_get_sn_allocation (struct dlb2_dev *dev, +unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_get_sn_allocation_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->get_sn_allocation (&dev->hw, arg.group); + + response.id = ret; + + ret = (ret >0 ) ?0 : ret; + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} + +static int dlb2_ioctl_get_sn_occupancy (struct dlb2_dev *dev, +unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_get_sn_occupancy_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->get_sn_occupancy (&dev->hw, arg.group); + + response.id = ret; + + ret = (ret >0 ) ?0 : ret; + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} +long dlb2_ioctl (struct file *f,unsigned int cmd,unsigned long arg) {struct dlb2_dev *dev;
@@ -696,6 +776,12 @@ long dlb2_ioctl(struct file *f, unsigned int cmd, unsigned long arg)return dlb2_ioctl_get_num_resources (dev, arg);case DLB2_IOC_QUERY_CQ_POLL_MODE :return dlb2_ioctl_query_cq_poll_mode (dev, arg); +case DLB2_IOC_SET_SN_ALLOCATION : +return dlb2_ioctl_set_sn_allocation (dev, arg); +case DLB2_IOC_GET_SN_ALLOCATION : +return dlb2_ioctl_get_sn_allocation (dev, arg); +case DLB2_IOC_GET_SN_OCCUPANCY : +return dlb2_ioctl_get_sn_occupancy (dev, arg);default :return -ENOTTY ; }
drivers/misc/dlb2/dlb2_main.h +3 -0
@@ -135,6 +135,9 @@ struct dlb2_device_ops {int (*dir_port_owned_by_domain)(struct dlb2_hw *hw,u32 domain_id,u32 port_id); +int (*get_sn_allocation)(struct dlb2_hw *hw,u32 group_id); +int (*set_sn_allocation)(struct dlb2_hw *hw,u32 group_id,u32 num); +int (*get_sn_occupancy)(struct dlb2_hw *hw,u32 group_id); int (*get_ldb_queue_depth)(struct dlb2_hw *hw, u32 domain_id, struct dlb2_get_ldb_queue_depth_args *args,
drivers/misc/dlb2/dlb2_pf_ops.c +21 -0
@@ -604,6 +604,24 @@ dlb2_pf_dir_port_owned_by_domain(struct dlb2_hw *hw,return dlb2_dir_port_owned_by_domain (hw, domain_id, port_id, false,0 ); } +static int +dlb2_pf_get_sn_allocation (struct dlb2_hw *hw,u32 group_id) +{ +return dlb2_get_group_sequence_numbers (hw, group_id); +} + +static int +dlb2_pf_set_sn_allocation (struct dlb2_hw *hw,u32 group_id,u32 num) +{ +return dlb2_set_group_sequence_numbers (hw, group_id, num); +} + +static int +dlb2_pf_get_sn_occupancy (struct dlb2_hw *hw,u32 group_id) +{ +return dlb2_get_group_sequence_number_occupancy (hw, group_id); +} +/********************************/ /****** DLB2 PF Device Ops ******/ /********************************/
@@ -644,6 +662,9 @@ struct dlb2_device_ops dlb2_pf_ops = { .reset_domain = dlb2_pf_reset_domain, .ldb_port_owned_by_domain = dlb2_pf_ldb_port_owned_by_domain, .dir_port_owned_by_domain = dlb2_pf_dir_port_owned_by_domain, + .get_sn_allocation = dlb2_pf_get_sn_allocation, + .set_sn_allocation = dlb2_pf_set_sn_allocation, + .get_sn_occupancy = dlb2_pf_get_sn_occupancy, .get_ldb_queue_depth = dlb2_pf_get_ldb_queue_depth, .get_dir_queue_depth = dlb2_pf_get_dir_queue_depth, .init_hardware = dlb2_pf_init_hardware,
drivers/misc/dlb2/dlb2_resource.c +67 -0
73 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +47 -0
53 lines not on this page · raw message
include/uapi/linux/dlb2_user.h +84 -0
101 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 16/19 dlb2: add cos bandwidth get/set ioctls
In reply to Gage EadsThe DLB 2.0 supports four load-balanced port classes of service (CoS). Each CoS receives a guaranteed percentage of the load-balanced scheduler's bandwidth, and any unreserved bandwidth is divided among the four CoS.
These two ioctls allow applications to query CoS allocations and adjust them as needed. These allocations are controlled by the PF driver; virtual devices, when support for them is added, will not be able to adjust them.
--- drivers/misc/dlb2/dlb2_ioctl.c | 54 +++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_main.h | 2 ++ drivers/misc/dlb2/dlb2_pf_ops.c | 14 ++++++++++ drivers/misc/dlb2/dlb2_resource.c | 59 +++++++++++++++++++++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.h | 28 +++++++++++++++++++ include/uapi/linux/dlb2_user.h | 52 ++++++++++++++++++++++++++++++++++ 6 files changed, 209 insertions(+)
drivers/misc/dlb2/dlb2_ioctl.c +54 -0
@@ -761,6 +761,56 @@ static int dlb2_ioctl_get_sn_occupancy(struct dlb2_dev *dev,return ret; } +static int dlb2_ioctl_set_cos_bw (struct dlb2_dev *dev,unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_set_cos_bw_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->set_cos_bw (&dev->hw, arg.cos_id, arg.bandwidth); + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} + +static int dlb2_ioctl_get_cos_bw (struct dlb2_dev *dev,unsigned long user_arg) +{ +struct dlb2_cmd_response response = {0 }; +struct dlb2_get_cos_bw_args arg; +int ret; + +if (copy_from_user (&arg, (void __user *)user_arg,sizeof (arg))) +return -EFAULT ; + +mutex_lock (&dev->resource_mutex); + + ret = dev->ops->get_cos_bw (&dev->hw, arg.cos_id); + + response.id = ret; + + ret = (ret >0 ) ?0 : ret; + +mutex_unlock (&dev->resource_mutex); + +BUILD_BUG_ON (offsetof(typeof (arg ), response) !=0 ); + +if (copy_to_user ((void __user *)user_arg, &response,sizeof (response))) +return -EFAULT ; + +return ret; +} +long dlb2_ioctl (struct file *f,unsigned int cmd,unsigned long arg) {struct dlb2_dev *dev;
@@ -782,6 +832,10 @@ long dlb2_ioctl(struct file *f, unsigned int cmd, unsigned long arg)return dlb2_ioctl_get_sn_allocation (dev, arg);case DLB2_IOC_GET_SN_OCCUPANCY :return dlb2_ioctl_get_sn_occupancy (dev, arg); +case DLB2_IOC_SET_COS_BW : +return dlb2_ioctl_set_cos_bw (dev, arg); +case DLB2_IOC_GET_COS_BW : +return dlb2_ioctl_get_cos_bw (dev, arg);default :return -ENOTTY ; }
drivers/misc/dlb2/dlb2_main.h +2 -0
@@ -146,6 +146,8 @@ struct dlb2_device_ops {u32 domain_id, struct dlb2_get_dir_queue_depth_args *args, struct dlb2_cmd_response *resp); +int (*set_cos_bw)(struct dlb2_hw *hw,u32 cos_id,u8 bandwidth); +int (*get_cos_bw)(struct dlb2_hw *hw,u32 cos_id);void (*init_hardware)(struct dlb2_dev *dev);int (*query_cq_poll_mode)(struct dlb2_dev *dev,struct dlb2_cmd_response *user_resp);
drivers/misc/dlb2/dlb2_pf_ops.c +14 -0
@@ -617,6 +617,18 @@ dlb2_pf_set_sn_allocation(struct dlb2_hw *hw, u32 group_id, u32 num) }static int +dlb2_pf_set_cos_bw (struct dlb2_hw *hw,u32 cos_id,u8 bandwidth) +{ +return dlb2_hw_set_cos_bandwidth (hw, cos_id, bandwidth); +} + +static int +dlb2_pf_get_cos_bw (struct dlb2_hw *hw,u32 cos_id) +{ +return dlb2_hw_get_cos_bandwidth (hw, cos_id); +} + +static int dlb2_pf_get_sn_occupancy (struct dlb2_hw *hw,u32 group_id) {return dlb2_get_group_sequence_number_occupancy (hw, group_id);
@@ -667,6 +679,8 @@ struct dlb2_device_ops dlb2_pf_ops = { .get_sn_occupancy = dlb2_pf_get_sn_occupancy, .get_ldb_queue_depth = dlb2_pf_get_ldb_queue_depth, .get_dir_queue_depth = dlb2_pf_get_dir_queue_depth, + .set_cos_bw = dlb2_pf_set_cos_bw, + .get_cos_bw = dlb2_pf_get_cos_bw, .init_hardware = dlb2_pf_init_hardware, .query_cq_poll_mode = dlb2_pf_query_cq_poll_mode, };
drivers/misc/dlb2/dlb2_resource.c +59 -0
65 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +28 -0
@@ -823,6 +823,34 @@ int dlb2_hw_pending_port_unmaps(struct dlb2_hw *hw, unsigned int vf_id);/** +* dlb2_hw_get_cos_bandwidth() - returns the percent of bandwidth allocated +* to a port class-of-service. +* @hw: dlb2_hw handle for a particular device. +* @cos_id: class-of-service ID. +* +* Return: +* Returns -EINVAL if cos_id is invalid, else the class' bandwidth allocation. +*/ +int dlb2_hw_get_cos_bandwidth (struct dlb2_hw *hw,u32 cos_id); + +/** +* dlb2_hw_set_cos_bandwidth() - set a bandwidth allocation percentage for a +* port class-of-service. +* @hw: dlb2_hw handle for a particular device. +* @cos_id: class-of-service ID. +* @bandwidth: class-of-service bandwidth. +* +* Return: +* Returns 0 upon success, < 0 otherwise. +* +* Errors: +* EINVAL - Invalid cos ID, bandwidth is greater than 100, or bandwidth would +* cause the total bandwidth across all classes of service to exceed +* 100%. +*/ +int dlb2_hw_set_cos_bandwidth (struct dlb2_hw *hw,u32 cos_id,u8 bandwidth); + +/** * dlb2_hw_enable_sparse_ldb_cq_mode() - enable sparse mode for load-balanced * ports. * @hw: dlb2_hw handle for a particular device.
include/uapi/linux/dlb2_user.h +52 -0
70 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 17/19 dlb2: add device FLR support
In reply to Gage EadsA device FLR can be triggered while applications are actively using the device, which poses two problems:
- If applications continue to enqueue to the hardware they will cause hardware errors, because the FLR will have reset the scheduling domains, ports, and queues.
- When the applications end, they must not trigger the driver's domain reset logic, which would fail because the device's registers will have been reset by the FLR.
The driver needs to stop applications from using the device before the FLR begins, and detect when these applications exit (so they don't trigger the domain reset that occurs when their last file reference (or memory mapping) closes). The driver must also disallow applications from configuring the device while the reset is in progress.
To avoid these problems, the driver handles unexpected resets as follows:
1. Set the reset_active flag. This flag blocks new device files from being opened and is used as a wakeup condition in the driver's wait queues.
2. If this is a PF FLR and there are active VFs, send them a pre-reset notification, so they can stop any VF applications. (Added in a later commit.)
3. Disable all device files (set the per-file valid flag to false, which prevents the file from being used after FLR completes) and wake any threads blocked on a wait queue.
4. If the device is not in use -- i.e. no open device files or memory mappings, and no VFs in use (PF FLR only) -- the FLR can begin.
5. Else, the driver waits (up to a user-specified timeout, default 5s) for software to stop using the driver and the device. If the timeout elapses, the driver zaps any remaining MMIO mappings so the extant applications can no longer use the device.
6. Do not unlock the resource mutex at the end of the reset prepare function, to prevent device access during the reset.
The reset timeout is exposed as a module parameter.
After the FLR:
1. Clear the per-domain pointers (the memory is freed elsewhere).
2. Release any remaining allocated port or CQ memory, now that it's guaranteed the device is unconfigured and won't write to memory.
3. Reset software and hardware state.
4. Notify VFs that the FLR is complete. (Added in a later commit.)
5. Set reset_active to false.
6. Unlock the resource mutex.
--- Documentation/ABI/testing/sysfs-driver-dlb2 | 22 ++ drivers/misc/dlb2/dlb2_intr.c | 13 +- drivers/misc/dlb2/dlb2_intr.h | 1 + drivers/misc/dlb2/dlb2_ioctl.c | 54 ++++- drivers/misc/dlb2/dlb2_main.c | 315 +++++++++++++++++++++++++++- drivers/misc/dlb2/dlb2_main.h | 4 + drivers/misc/dlb2/dlb2_resource.c | 17 ++ drivers/misc/dlb2/dlb2_resource.h | 9 + 8 files changed, 424 insertions(+), 11 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-driver-dlb2
Documentation/ABI/testing/sysfs-driver-dlb2 new file +22 -0
@@ -0,0 +1,22 @@ +What: /sys/bus/pci/drivers/dlb2/module/parameters/reset_timeout_s +Date: June 22, 2020 +KernelVersion: 5.9 +Contact: [email protected] +Description: Interface for setting the driver's reset timeout. + When a device reset (FLR) is issued, the driver waits for + user-space to stop using the device before allowing the FLR to + proceed, with a timeout. The device is considered in use if + there are any open domain device file descriptors or memory + mapped producer ports. (For PF device resets, this includes all + VF-owned domains and producer ports.) + + The amount of time the driver waits for userspace to stop using + the device is controlled by the module parameter + reset_timeout_s, which is in units of seconds and defaults to + 5. If reset_timeout_s seconds elapse and any user is still + using the device, the driver zaps those processes' memory + mappings and marks their device file descriptors as invalid. + This is necessary because user processes that do not relinquish + their device mappings can interfere with processes that use the + device after the reset completes. To ensure that user processes + have enough time to clean up, reset_timeout_s can be increased.
drivers/misc/dlb2/dlb2_intr.c +10 -3
@@ -30,7 +30,10 @@ static inline bool wake_condition(struct dlb2_cq_intr *intr,struct dlb2_dev *dev, struct dlb2_domain *domain) { - return (READ_ONCE(intr->wake) || READ_ONCE(intr->disabled)); + return (READ_ONCE(intr->wake) || + READ_ONCE(dev->reset_active) || + !READ_ONCE(domain->valid) || + READ_ONCE(intr->disabled)); } struct dlb2_dequeue_qe {
@@ -114,8 +117,12 @@ int dlb2_block_on_cq_interrupt(struct dlb2_dev *dev, ret =wait_event_interruptible (intr->wq_head,wake_condition (intr, dev, dom)); -if (ret ==0 &&READ_ONCE (intr->disabled)) - ret = -EACCES ; +if (ret ==0 ) { +if (READ_ONCE (dev->reset_active) || !READ_ONCE (dom->valid)) + ret = -EINTR ; +else if (READ_ONCE (intr->disabled)) + ret = -EACCES ; + }WRITE_ONCE (intr->wake, false);
drivers/misc/dlb2/dlb2_intr.h +1 -0
@@ -20,6 +20,7 @@ int dlb2_block_on_cq_interrupt(struct dlb2_dev *dev,enum dlb2_wake_reason {WAKE_CQ_INTR ,WAKE_PORT_DISABLED , +WAKE_DEV_RESET }; void dlb2_wake_thread(struct dlb2_dev *dev,
drivers/misc/dlb2/dlb2_ioctl.c +52 -2
120 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.c +309 -6
414 lines not on this page · raw message
drivers/misc/dlb2/dlb2_main.h +4 -0
@@ -31,6 +31,8 @@ static const char dlb2_driver_name[] = KBUILD_MODNAME;#define DLB2_NUM_FUNCS_PER_DEVICE (1 + DLB2_MAX_NUM_VDEVS)#define DLB2_MAX_NUM_DEVICES (DLB2_MAX_NUM_PFS * DLB2_NUM_FUNCS_PER_DEVICE) +#define DLB2_DEFAULT_RESET_TIMEOUT_S 5 +enum dlb2_device_type {DLB2_PF ,DLB2_VF ,
@@ -182,6 +184,7 @@ struct dlb2_domain {u8 alert_rd_idx;u8 alert_wr_idx;u8 id; +u8 valid; };struct dlb2_cq_intr {
@@ -237,6 +240,7 @@ struct dlb2_dev {int id;dev_t dev_number;u8 domain_reset_failed; +u8 reset_active;u8 worker_launched; };
drivers/misc/dlb2/dlb2_resource.c +17 -0
@@ -24,6 +24,9 @@#define DLB2_DOM_LIST_FOR_SAFE (head, ptr, ptr_tmp) \ list_for_each_entry_safe(ptr, ptr_tmp, &(head), domain_list) +#define DLB2_FUNC_LIST_FOR_SAFE (head, ptr, ptr_tmp) \ + list_for_each_entry_safe(ptr, ptr_tmp, &(head), func_list) +/* * The PF driver cannot assume that a register write will affect subsequent HCW * writes. To ensure a write completes, the driver must read back a CSR. This
@@ -5327,6 +5330,20 @@ static int dlb2_domain_reset_software_state(struct dlb2_hw *hw,return 0 ; } +void dlb2_resource_reset (struct dlb2_hw *hw) +{ + struct dlb2_hw_domain *domain, *next __attribute__((unused)); +int i; + +for (i =0 ; i <DLB2_MAX_NUM_VDEVS ; i++) { + DLB2_FUNC_LIST_FOR_SAFE(hw->vdev[i].used_domains, domain, next) +dlb2_domain_reset_software_state (hw, domain); + } + + DLB2_FUNC_LIST_FOR_SAFE(hw->pf.used_domains, domain, next) +dlb2_domain_reset_software_state (hw, domain); +} +static u32 dlb2_dir_queue_depth (struct dlb2_hw *hw,struct dlb2_dir_pq_pair *queue) {
drivers/misc/dlb2/dlb2_resource.h +9 -0
@@ -37,6 +37,15 @@ int dlb2_resource_init(struct dlb2_hw *hw);void dlb2_resource_free (struct dlb2_hw *hw);/** +* dlb2_resource_reset() - reset in-use resources to their initial state +* @hw: dlb2_hw handle for a particular device. +* +* This function resets in-use resources, and makes them available for use. +* All resources go back to their owning function, whether a PF or a VF. +*/ +void dlb2_resource_reset (struct dlb2_hw *hw); + +/** * dlb2_hw_create_sched_domain() - create a scheduling domain * @hw: dlb2_hw handle for a particular device. * @args: scheduling domain creation arguments.
Signature · 1 line
2.13.6
PATCH v3 18/19 dlb2: add basic PF sysfs interfaces
In reply to Gage EadsThese interfaces include files for reading the total and available device resources, getting and setting sequence number group allocations, and reading the device ID.
--- Documentation/ABI/testing/sysfs-driver-dlb2 | 165 +++++++++++ drivers/misc/dlb2/dlb2_main.c | 11 + drivers/misc/dlb2/dlb2_main.h | 3 + drivers/misc/dlb2/dlb2_pf_ops.c | 423 ++++++++++++++++++++++++++++ 4 files changed, 602 insertions(+)
Documentation/ABI/testing/sysfs-driver-dlb2 +165 -0
@@ -20,3 +20,168 @@ Description: Interface for setting the driver's reset timeout. their device mappings can interfere with processes that use the device after the reset completes. To ensure that user processes have enough time to clean up, reset_timeout_s can be increased. + +What: /sys/bus/pci/devices/.../sequence_numbers/group<N>_sns_per_queue +Date: June 22, 2020 +KernelVersion: 5.9 +Contact: [email protected] +Description: Interface for configuring dlb2 load-balanced sequence numbers. + + The DLB 2.0 has a fixed number of sequence numbers used for + ordered scheduling. They are divided among two sequence number + groups. A group can be configured to contain one queue with + 1,024 sequence numbers, or two queues with 512 sequence numbers + each, and so on, down to 16 queues with 64 sequence numbers + each. + + When a load-balanced queue is configured with non-zero sequence + numbers, the driver finds a group configured for the same + number of sequence numbers and an available slot. If no such + groups are found, the queue cannot be configured. + + Once the first ordered queue is configured, the sequence number + configurations are locked. The driver returns an error on writes + to locked sequence number configurations. When all ordered + queues are unconfigured, the sequence number configurations can + be changed again. + + This file is only accessible for physical function DLB 2.0 + devices. + +What: /sys/bus/pci/devices/.../total_resources/num_atomic_inflights +What: /sys/bus/pci/devices/.../total_resources/num_dir_credits +What: /sys/bus/pci/devices/.../total_resources/num_dir_ports +What: /sys/bus/pci/devices/.../total_resources/num_hist_list_entries +What: /sys/bus/pci/devices/.../total_resources/num_ldb_credits +What: /sys/bus/pci/devices/.../total_resources/num_ldb_ports +What: /sys/bus/pci/devices/.../total_resources/num_cos0_ldb_ports +What: /sys/bus/pci/devices/.../total_resources/num_cos1_ldb_ports +What: /sys/bus/pci/devices/.../total_resources/num_cos2_ldb_ports +What: /sys/bus/pci/devices/.../total_resources/num_cos3_ldb_ports +What: /sys/bus/pci/devices/.../total_resources/num_ldb_queues +What: /sys/bus/pci/devices/.../total_resources/num_sched_domains +Date: June 22, 2020 +KernelVersion: 5.9 +Contact: [email protected] +Description: + The total_resources subdirectory contains read-only files that + indicate the total number of resources in the device. + + num_atomic_inflights: Total number of atomic inflights in the + device. Atomic inflights refers to the + on-device storage used by the atomic + scheduler. + + num_dir_credits: Total number of directed credits in the + device. + + num_dir_ports: Total number of directed ports (and + queues) in the device. + + num_hist_list_entries: Total number of history list entries in + the device. + + num_ldb_credits: Total number of load-balanced credits in + the device. + + num_ldb_ports: Total number of load-balanced ports in + the device. + + num_cos<M>_ldb_ports: Total number of load-balanced ports + belonging to class-of-service M in the + device. + + num_ldb_queues: Total number of load-balanced queues in + the device. + + num_sched_domains: Total number of scheduling domains in the + device. + +What: /sys/bus/pci/devices/.../avail_resources/num_atomic_inflights +What: /sys/bus/pci/devices/.../avail_resources/num_dir_credits +What: /sys/bus/pci/devices/.../avail_resources/num_dir_ports +What: /sys/bus/pci/devices/.../avail_resources/num_hist_list_entries +What: /sys/bus/pci/devices/.../avail_resources/num_ldb_credits +What: /sys/bus/pci/devices/.../avail_resources/num_ldb_ports +What: /sys/bus/pci/devices/.../avail_resources/num_cos0_ldb_ports +What: /sys/bus/pci/devices/.../avail_resources/num_cos1_ldb_ports +What: /sys/bus/pci/devices/.../avail_resources/num_cos2_ldb_ports +What: /sys/bus/pci/devices/.../avail_resources/num_cos3_ldb_ports +What: /sys/bus/pci/devices/.../avail_resources/num_ldb_queues +What: /sys/bus/pci/devices/.../avail_resources/num_sched_domains +What: /sys/bus/pci/devices/.../avail_resources/max_ctg_hl_entries +Date: June 22, 2020 +KernelVersion: 5.9 +Contact: [email protected] +Description: + The avail_resources subdirectory contains read-only files that + indicate the available number of resources in the device. + "Available" here means resources that are not currently in use + by an application or, in the case of a physical function + device, assigned to a virtual function. + + num_atomic_inflights: Available number of atomic inflights in + the device. + + num_dir_ports: Available number of directed ports (and + queues) in the device. + + num_hist_list_entries: Available number of history list entries + in the device. + + num_ldb_credits: Available number of load-balanced credits + in the device. + + num_ldb_ports: Available number of load-balanced ports + in the device. + + num_cos<M>_ldb_ports: Available number of load-balanced ports + belonging to class-of-service M in the + device. + + num_ldb_queues: Available number of load-balanced queues + in the device. + + num_sched_domains: Available number of scheduling domains in + the device. + + max_ctg_hl_entries: Maximum contiguous history list entries + available in the device. + + Each scheduling domain is created with + an allocation of history list entries, + and each domain's allocation of entries + must be contiguous. + +What: /sys/bus/pci/devices/.../cos_bw/cos<N>_bw_percent +Date: June 22, 2020 +KernelVersion: 5.9 +Contact: [email protected] +Description: Interface for configuring dlb2 class-of-service bandwidths. + + The DLB 2.0 supports four load-balanced port classes of service + (CoS). Each CoS receives a guaranteed percentage of the + load-balanced scheduler's bandwidth, and any unreserved + bandwidth is divided among the four CoS. + + By default, each CoS is guaranteed 25% of the bandwidth. Writing + these files allows the user to change the CoS, subject to the + constraint that the total reserved bandwidth of all CoS cannot + exceed 100%. + + Bandwidth reservations can be modified during run-time. + + These files are only accessible for physical function DLB 2.0 + devices. + +What: /sys/bus/pci/devices/.../dev_id +Date: June 22, 2020 +KernelVersion: 5.9 +Contact: [email protected] +Description: Device ID used in /dev, i.e. /dev/dlb<device ID> + + Each DLB 2.0 PF and VF device is granted a unique ID by the + kernel driver, and this ID is used to construct the device's + /dev directory: /dev/dlb<device ID>. This sysfs file can be read + to determine a device's ID, which allows the user to map a + device file to a PCI BDF.
drivers/misc/dlb2/dlb2_main.c +11 -0
@@ -603,6 +603,10 @@ static int dlb2_probe(struct pci_dev *pdev,if (ret) goto dma_set_mask_fail; + ret = dlb2_dev->ops->sysfs_create (dlb2_dev); +if (ret) + goto sysfs_create_fail; +/* * PM enable must be done before any other MMIO accesses, and this * setting is persistent across device reset.
@@ -653,6 +657,8 @@ static int dlb2_probe(struct pci_dev *pdev, init_interrupts_fail: dlb2_reset_fail: wait_for_device_ready_fail: + dlb2_dev->ops->sysfs_destroy (dlb2_dev); +sysfs_create_fail: dma_set_mask_fail: dlb2_dev->ops->device_destroy (dlb2_dev, dlb2_class); device_add_fail:
@@ -694,6 +700,8 @@ static void dlb2_remove(struct pci_dev *pdev)dlb2_release_device_memory (dlb2_dev); + dlb2_dev->ops->sysfs_destroy (dlb2_dev); + dlb2_dev->ops->device_destroy (dlb2_dev, dlb2_class); dlb2_dev->ops->cdev_del (dlb2_dev);
@@ -719,6 +727,9 @@ static void dlb2_reset_hardware_state(struct dlb2_dev *dev, bool issue_flr)/* Reinitialize interrupt configuration */ dev->ops->reinit_interrupts (dev); +/* Reset configuration done through the sysfs */ + dev->ops->sysfs_reapply (dev); +/* Reinitialize any other hardware state */ dev->ops->init_hardware (dev); }
drivers/misc/dlb2/dlb2_main.h +3 -0
@@ -57,6 +57,9 @@ struct dlb2_device_ops {dev_t base, const struct file_operations *fops);void (*cdev_del)(struct dlb2_dev *dlb2_dev); +int (*sysfs_create)(struct dlb2_dev *dlb2_dev); +void (*sysfs_destroy)(struct dlb2_dev *dlb2_dev); +void (*sysfs_reapply)(struct dlb2_dev *dev);int (*init_interrupts)(struct dlb2_dev *dev,struct pci_dev *pdev); int (*enable_ldb_cq_interrupts)(struct dlb2_dev *dev, int domain_id,
drivers/misc/dlb2/dlb2_pf_ops.c +423 -0
435 lines not on this page · raw message
Signature · 1 line
2.13.6
PATCH v3 19/19 dlb2: add ingress error handling
In reply to Gage EadsWhen DLB 2.0 detects that an application enqueued an illegal QE, it fires an ingress error interrupt. The driver processes these errors and notifies user-space through a domain alert.
A malicious application or virtual machine could attempt a denial-of-service attack by enqueueing illegal QEs at a high rate and tying up the PF driver, so the driver tracks the rate of ingress error alarms per second. If they exceed a threshold of 1000/second, the driver simply disables the interrupt. The interrupt is re-enabled when the device is reset, the driver is reloaded, or by a user through a sysfs interface.
--- Documentation/ABI/testing/sysfs-driver-dlb2 | 15 ++ drivers/misc/dlb2/dlb2_hw_types.h | 17 ++ drivers/misc/dlb2/dlb2_main.h | 16 ++ drivers/misc/dlb2/dlb2_pf_ops.c | 177 ++++++++++++++++++++ drivers/misc/dlb2/dlb2_resource.c | 251 +++++++++++++++++++++++++++- drivers/misc/dlb2/dlb2_resource.h | 45 +++++ 6 files changed, 520 insertions(+), 1 deletion(-)
Documentation/ABI/testing/sysfs-driver-dlb2 +15 -0
@@ -185,3 +185,18 @@ Description: Device ID used in /dev, i.e. /dev/dlb<device ID> /dev directory: /dev/dlb<device ID>. This sysfs file can be read to determine a device's ID, which allows the user to map a device file to a PCI BDF. + +What: /sys/bus/pci/devices/.../ingress_err_en +Date: June 22, 2020 +KernelVersion: 5.9 +Contact: [email protected] +Description: Interface for re-enabling ingress error interrupts + + If the PF driver detects an overload of ingress error + interrupts, it will -- to prevent a possible denial-of-service + attack -- disable them. + + If the ingress error interrupt is disabled, they will be + re-enabled when the device is reset or the driver is reloaded. + This interface can be used to re-enable the interrupt as well, + and can be read to determine whether the interrupt is enabled.
drivers/misc/dlb2/dlb2_hw_types.h +17 -0
@@ -61,6 +61,23 @@#define DLB2_PF_COMPRESSED_MODE_CQ_VECTOR_ID \ DLB2_PF_NUM_NON_CQ_INTERRUPT_VECTORS +/* DLB non-CQ interrupts (alarm, mailbox, WDT) */ +#define DLB2_INT_NON_CQ 0 + +#define DLB2_ALARM_HW_SOURCE_SYS 0 +#define DLB2_ALARM_HW_SOURCE_DLB 1 + +#define DLB2_ALARM_HW_UNIT_CHP 4 + +#define DLB2_ALARM_SYS_AID_ILLEGAL_QID 3 +#define DLB2_ALARM_SYS_AID_DISABLED_QID 4 +#define DLB2_ALARM_SYS_AID_ILLEGAL_HCW 5 +#define DLB2_ALARM_HW_CHP_AID_ILLEGAL_ENQ 1 +#define DLB2_ALARM_HW_CHP_AID_EXCESS_TOKEN_POPS 2 + +#define DLB2_VF_NUM_NON_CQ_INTERRUPT_VECTORS 1 +#define DLB2_VF_NUM_CQ_INTERRUPT_VECTORS 31 +/* * Hardware-defined base addresses. Those prefixed 'DLB2_DRV' are only used by * the PF driver.
drivers/misc/dlb2/dlb2_main.h +16 -0
@@ -217,6 +217,21 @@ struct dlb2_intr {int mode; }; +/* +* ISR overload is defined as more than DLB2_ISR_OVERLOAD_THRESH interrupts +* (of a particular type) occurring in a 1s period. If overload is detected, +* the driver blocks that interrupt (exact mechanism depending on the +* interrupt) from overloading the PF driver. +*/ +#define DLB2_ISR_OVERLOAD_THRESH 1000 +#define DLB2_ISR_OVERLOAD_PERIOD_S 1 + +struct dlb2_alarm { +ktime_t ts; +unsigned int enabled; +u32 count; +}; +struct dlb2_dev {struct pci_dev *pdev;struct dlb2_hw hw;
@@ -239,6 +254,7 @@ struct dlb2_dev {*/ struct mutex resource_mutex;struct work_struct work; +struct dlb2_alarm ingress_err;enum dlb2_device_type type;int id;dev_t dev_number;
drivers/misc/dlb2/dlb2_pf_ops.c +177 -0
225 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.c +250 -1
263 lines not on this page · raw message
drivers/misc/dlb2/dlb2_resource.h +45 -0
63 lines not on this page · raw message
Signature · 1 line
2.13.6