NVMeTCP Offload ULP and QEDN Device Driver
Subsystems (4)
v4 cover NVMeTCP Offload ULP and QEDN Device Driver
With the goal of enabling a generic infrastructure that allows NVMe/TCP offload devices like NICs to seamlessly plug into the NVMe-oF stack, this patch series introduces the nvme-tcp-offload ULP host layer, which will be a new transport type called "tcp-offload" and will serve as an abstraction layer to work with vendor specific nvme-tcp offload drivers.
NVMeTCP offload is a full offload of the NVMeTCP protocol, this includes both the TCP level and the NVMeTCP level.
The nvme-tcp-offload transport can co-exist with the existing tcp and other transports. The tcp offload was designed so that stack changes are kept to a bare minimum: only registering new transports.
All other APIs, ops etc. are identical to the regular tcp transport. Representing the TCP offload as a new transport allows clear and manageable differentiation between the connections which should use the offload path and those that are not offloaded (even on the same device).
The nvme-tcp-offload layers and API compared to nvme-tcp and nvme-rdma:
* NVMe layer: *
[ nvme/nvme-fabrics/blk-mq ]
|
(nvme API and blk-mq API)
|
| * Vendor agnostic transport layer: *
[ nvme-rdma ] [ nvme-tcp ] [ nvme-tcp-offload ]
| | |
(Verbs)
| | |
| (Socket)
| | |
| | (nvme-tcp-offload API)
| | |
| | |
* Vendor Specific Driver: *
| | |
[ qedr ]
| | [ qede ]
|
[ qedn ]
Performance:
============
With this implementation on top of the Marvell qedn driver (using the Marvell FastLinQ NIC), we were able to demonstrate the following CPU utilization improvement:
On AMD EPYC 7402, 2.80GHz, 28 cores:
- For 16K queued read IOs, 16jobs, 4qd (50Gbps line rate):
Improved the CPU utilization from 15.1% with NVMeTCP SW to 4.7% with NVMeTCP offload.
On Intel(R) Xeon(R) Gold 5122 CPU, 3.60GHz, 16 cores:
- For 512K queued read IOs, 16jobs, 4qd (25Gbps line rate):
Improved the CPU utilization from 16.3% with NVMeTCP SW to 1.1% with NVMeTCP offload.
In addition, we were able to demonstrate the following latency improvement:
- For 200K read IOPS (16 jobs, 16 qd, with fio rate limiter):
Improved the average latency from 105 usec with NVMeTCP SW to 39 usec with NVMeTCP offload.
Improved the 99.99 tail latency from 570 usec with NVMeTCP SW to 91 usec with NVMeTCP offload.
The end-to-end offload latency was measured from fio while running against back end of null device.
Upstream plan:
==============
Following this RFC, the series will be sent in a modular way so that changes in each part will not impact the previous part.
- Part 1 (Patches 1-7):
The qed infrastructure, will be sent to '[email protected]'.
- Part 2 (Patch 8-15):
The nvme-tcp-offload patches, will be sent to
'[email protected]'.
- Part 3 (Packet 16-27):
The qedn patches, will be sent to '[email protected]'.
Queue Initialization Design:
============================
The nvme-tcp-offload ULP module shall register with the existing nvmf_transport_ops (.name = "tcp_offload"), nvme_ctrl_ops and blk_mq_ops. The nvme-tcp-offload vendor driver shall register to nvme-tcp-offload ULP with the following ops:
- claim_dev() - in order to resolve the route to the target according to the paired net_dev.
- create_queue() - in order to create offloaded nvme-tcp queue.
The nvme-tcp-offload ULP module shall manage all the controller level functionalities, call claim_dev and based on the return values shall call the relevant module create_queue in order to create the admin queue and the IO queues.
IO-path Design:
===============
The nvme-tcp-offload shall work at the IO-level - the nvme-tcp-offload ULP module shall pass the request (the IO) to the nvme-tcp-offload vendor driver and later, the nvme-tcp-offload vendor driver returns the request completion (the IO completion).
No additional handling is needed in between; this design will reduce the CPU utilization as we will describe below.
The nvme-tcp-offload vendor driver shall register to nvme-tcp-offload ULP with the following IO-path ops:
- init_req()
- send_req() - in order to pass the request to the handling of the offload driver that shall pass it to the vendor specific device.
- poll_queue()
Once the IO completes, the nvme-tcp-offload vendor driver shall call command.done() that will invoke the nvme-tcp-offload ULP layer to complete the request.
TCP events:
===========
The Marvell FastLinQ NIC HW engine handle all the TCP re-transmissions and OOO events.
Teardown and errors:
====================
In case of NVMeTCP queue error the nvme-tcp-offload vendor driver shall call the nvme_tcp_ofld_report_queue_err.
The nvme-tcp-offload vendor driver shall register to nvme-tcp-offload ULP with the following teardown ops:
- drain_queue()
- destroy_queue()
The Marvell FastLinQ NIC HW engine:
====================================
The Marvell NIC HW engine is capable of offloading the entire TCP/IP stack and managing up to 64K connections per PF, already implemented and upstream use cases for this include iWARP (by the Marvell qedr driver) and iSCSI (by the Marvell qedi driver).
In addition, the Marvell NIC HW engine offloads the NVMeTCP queue layer and is able to manage the IO level also in case of TCP re-transmissions and OOO events.
The HW engine enables direct data placement (including the data digest CRC calculation and validation) and direct data transmission (including data digest CRC calculation).
The Marvell qedn driver:
========================
The new driver will be added under "drivers/nvme/hw" and will be enabled by the Kconfig "Marvell NVM Express over Fabrics TCP offload". As part of the qedn init, the driver will register as a pci device driver and will work with the Marvell fastlinQ NIC.
As part of the probe, the driver will register to the nvme_tcp_offload (ULP) and to the qed module (qed_nvmetcp_ops) - similar to other "qed_*_ops" which are used by the qede, qedr, qedf and qedi device drivers.
QEDN Future work:
=================
- Support extended HW resources.
- Digest support.
- Devlink support for device configuration and TCP offload configurations.
- Statistics
Long term future work:
======================
- The nvme-tcp-offload ULP target abstraction layer.
- The Marvell nvme-tcp-offload "qednt" target driver.
Changes since RFC v1:
=====================
- Fix nvme_tcp_ofld_ops return values.
- Remove NVMF_TRTYPE_TCP_OFFLOAD.
- Add nvme_tcp_ofld_poll() implementation.
- Fix nvme_tcp_ofld_queue_rq() to check map_sg() and send_req() return values.
Changes since RFC v2:
=====================
- Add qedn - Marvell's NVMeTCP HW offload vendor driver init and probe (patches 8-11).
- Fixes in controller and queue level (patches 3-6).
Changes since RFC v3:
=====================
- Add the full implementation of the nvme-tcp-offload layer including the new ops: setup_ctrl(), release_ctrl(), commit_rqs() and new flows (ASYNC and timeout).
- Add nvme-tcp-offload device maximums: max_hw_sectors, max_segments.
- Add nvme-tcp-offload layer design and optimization changes.
- Add the qedn full implementation for the conn level, IO path and error handling.
- Add qed support for the new AHP HW.
Arie Gershberg (3):
nvme-fabrics: Move NVMF_ALLOWED_OPTS and NVMF_REQUIRED_OPTS
definitions
nvme-tcp-offload: Add controller level implementation
nvme-tcp-offload: Add controller level error recovery implementation
Dean Balandin (3):
nvme-tcp-offload: Add device scan implementation
nvme-tcp-offload: Add queue level implementation
nvme-tcp-offload: Add IO level implementation
Nikolay Assa (2):
qed: Add IP services APIs support
qedn: Add qedn_claim_dev API support
Omkar Kulkarni (1):
qed: Add qed-NVMeTCP personality
Prabhakar Kushwaha (6):
qed: Add support of HW filter block
qedn: Add connection-level slowpath functionality
qedn: Add support of configuring HW filter block
qedn: Add support of Task and SGL
qedn: Add support of NVME ICReq & ICResp
qedn: Add support of ASYNC
Shai Malin (12):
qed: Add NVMeTCP Offload PF Level FW and HW HSI
qed: Add NVMeTCP Offload Connection Level FW and HW HSI
qed: Add NVMeTCP Offload IO Level FW and HW HSI
qed: Add NVMeTCP Offload IO Level FW Initializations
nvme-tcp-offload: Add nvme-tcp-offload - NVMeTCP HW offload ULP
nvme-tcp-offload: Add Timeout and ASYNC Support
qedn: Add qedn - Marvell's NVMeTCP HW offload vendor driver
qedn: Add qedn probe
qedn: Add IRQ and fast-path resources initializations
qedn: Add IO level nvme_req and fw_cq workqueues
qedn: Add IO level fastpath functionality
qedn: Add Connection and IO level recovery flows
MAINTAINERS | 10 + drivers/net/ethernet/qlogic/Kconfig | 3 + drivers/net/ethernet/qlogic/qed/Makefile | 5 + drivers/net/ethernet/qlogic/qed/qed.h | 16 + drivers/net/ethernet/qlogic/qed/qed_cxt.c | 32 + drivers/net/ethernet/qlogic/qed/qed_cxt.h | 1 + drivers/net/ethernet/qlogic/qed/qed_dev.c | 151 +- drivers/net/ethernet/qlogic/qed/qed_hsi.h | 4 +- drivers/net/ethernet/qlogic/qed/qed_ll2.c | 31 +- drivers/net/ethernet/qlogic/qed/qed_mcp.c | 3 + drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c | 3 +- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 868 +++++++++++ drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h | 114 ++ .../qlogic/qed/qed_nvmetcp_fw_funcs.c | 372 +++++ .../qlogic/qed/qed_nvmetcp_fw_funcs.h | 43 + .../qlogic/qed/qed_nvmetcp_ip_services.c | 239 +++ drivers/net/ethernet/qlogic/qed/qed_ooo.c | 5 +- drivers/net/ethernet/qlogic/qed/qed_sp.h | 5 + .../net/ethernet/qlogic/qed/qed_sp_commands.c | 1 + drivers/nvme/Kconfig | 1 + drivers/nvme/Makefile | 1 + drivers/nvme/host/Kconfig | 16 + drivers/nvme/host/Makefile | 3 + drivers/nvme/host/fabrics.c | 7 - drivers/nvme/host/fabrics.h | 7 + drivers/nvme/host/tcp-offload.c | 1330 +++++++++++++++++ drivers/nvme/host/tcp-offload.h | 209 +++ drivers/nvme/hw/Kconfig | 9 + drivers/nvme/hw/Makefile | 3 + drivers/nvme/hw/qedn/Makefile | 4 + drivers/nvme/hw/qedn/qedn.h | 435 ++++++ drivers/nvme/hw/qedn/qedn_conn.c | 999 +++++++++++++ drivers/nvme/hw/qedn/qedn_main.c | 1153 ++++++++++++++ drivers/nvme/hw/qedn/qedn_task.c | 977 ++++++++++++ include/linux/qed/common_hsi.h | 1 + include/linux/qed/nvmetcp_common.h | 616 ++++++++ include/linux/qed/qed_if.h | 22 + include/linux/qed/qed_nvmetcp_if.h | 244 +++ .../linux/qed/qed_nvmetcp_ip_services_if.h | 29 + 39 files changed, 7947 insertions(+), 25 deletions(-) create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_ip_services.c create mode 100644 drivers/nvme/host/tcp-offload.c create mode 100644 drivers/nvme/host/tcp-offload.h create mode 100644 drivers/nvme/hw/Kconfig create mode 100644 drivers/nvme/hw/Makefile create mode 100644 drivers/nvme/hw/qedn/Makefile create mode 100644 drivers/nvme/hw/qedn/qedn.h create mode 100644 drivers/nvme/hw/qedn/qedn_conn.c create mode 100644 drivers/nvme/hw/qedn/qedn_main.c create mode 100644 drivers/nvme/hw/qedn/qedn_task.c create mode 100644 include/linux/qed/nvmetcp_common.h create mode 100644 include/linux/qed/qed_nvmetcp_if.h create mode 100644 include/linux/qed/qed_nvmetcp_ip_services_if.h
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
RFC PATCH v4 1/27 qed: Add NVMeTCP Offload PF Level FW and HW HSI
This patch introduces the NVMeTCP device and PF level HSI and HSI functionality in order to initialize and interact with the HW device.
This patch is based on the qede, qedr, qedi, qedf drivers HSI.
--- drivers/net/ethernet/qlogic/Kconfig | 3 + drivers/net/ethernet/qlogic/qed/Makefile | 2 + drivers/net/ethernet/qlogic/qed/qed.h | 3 + drivers/net/ethernet/qlogic/qed/qed_hsi.h | 1 + drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 282 ++++++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h | 51 ++++ drivers/net/ethernet/qlogic/qed/qed_sp.h | 2 + include/linux/qed/common_hsi.h | 1 + include/linux/qed/nvmetcp_common.h | 54 ++++ include/linux/qed/qed_if.h | 22 ++ include/linux/qed/qed_nvmetcp_if.h | 72 +++++ 11 files changed, 493 insertions(+) create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h create mode 100644 include/linux/qed/nvmetcp_common.h create mode 100644 include/linux/qed/qed_nvmetcp_if.h
drivers/net/ethernet/qlogic/Kconfig +3 -0
@@ -110,6 +110,9 @@ config QED_RDMA config QED_ISCSI bool +config QED_NVMETCP + bool + config QED_FCOE bool
drivers/net/ethernet/qlogic/qed/Makefile +2 -0
@@ -28,6 +28,8 @@ qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o qed-$(CONFIG_QED_LL2) += qed_ll2.o qed-$(CONFIG_QED_OOO) += qed_ooo.o +qed-$(CONFIG_QED_NVMETCP) += qed_nvmetcp.o + qed-$(CONFIG_QED_RDMA) += \ qed_iwarp.o \ qed_rdma.o \
drivers/net/ethernet/qlogic/qed/qed.h +3 -0
@@ -240,6 +240,7 @@ enum QED_FEATURE {QED_VF ,QED_RDMA_CNQ ,QED_ISCSI_CQ , +QED_NVMETCP_CQ =QED_ISCSI_CQ ,QED_FCOE_CQ ,QED_VF_L2_QUE , QED_MAX_FEATURES,
@@ -592,6 +593,7 @@ struct qed_hwfn {struct qed_ooo_info *p_ooo_info;struct qed_rdma_info *p_rdma_info;struct qed_iscsi_info *p_iscsi_info; +struct qed_nvmetcp_info *p_nvmetcp_info;struct qed_fcoe_info *p_fcoe_info;struct qed_pf_params pf_params;
@@ -828,6 +830,7 @@ struct qed_dev {struct qed_eth_cb_ops *eth;struct qed_fcoe_cb_ops *fcoe;struct qed_iscsi_cb_ops *iscsi; +struct qed_nvmetcp_cb_ops *nvmetcp; } protocol_ops;void *ops_cookie;
drivers/net/ethernet/qlogic/qed/qed_hsi.h +1 -0
@@ -20,6 +20,7 @@#include <linux/qed/fcoe_common.h> #include <linux/qed/eth_common.h> #include <linux/qed/iscsi_common.h> +#include <linux/qed/nvmetcp_common.h> #include <linux/qed/iwarp_common.h> #include <linux/qed/rdma_common.h> #include <linux/qed/roce_common.h>
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c new file +282 -0
282 lines not on this page · raw message
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h new file +51 -0
51 lines not on this page · raw message
drivers/net/ethernet/qlogic/qed/qed_sp.h +2 -0
@@ -100,6 +100,8 @@ union ramrod_data {struct iscsi_spe_conn_mac_update iscsi_conn_mac_update;struct iscsi_spe_conn_termination iscsi_conn_terminate; +struct nvmetcp_init_ramrod_params nvmetcp_init; +struct vf_start_ramrod_data vf_start;struct vf_stop_ramrod_data vf_stop; };
include/linux/qed/common_hsi.h +1 -0
@@ -703,6 +703,7 @@ enum mf_mode {/* Per-protocol connection types */ enum protocol_type {PROTOCOLID_ISCSI , +PROTOCOLID_NVMETCP =PROTOCOLID_ISCSI ,PROTOCOLID_FCOE ,PROTOCOLID_ROCE ,PROTOCOLID_CORE ,
include/linux/qed/nvmetcp_common.h new file +54 -0
54 lines not on this page · raw message
include/linux/qed/qed_if.h +22 -0
@@ -542,6 +542,26 @@ struct qed_iscsi_pf_params {u8 bdq_pbl_num_entries[3 ]; }; +struct qed_nvmetcp_pf_params { +u64 glbl_q_params_addr; +u16 cq_num_entries; + +u16 num_cons; +u16 num_tasks; + +u8 num_sq_pages_in_ring; +u8 num_r2tq_pages_in_ring; +u8 num_uhq_pages_in_ring; + +u8 num_queues; +u8 gl_rq_pi; +u8 gl_cmd_pi; +u8 debug_mode; +u8 ll2_ooo_queue_id; + +u16 min_rto; +}; +struct qed_rdma_pf_params {/* Supplied to QED during resource allocation (may affect the ILT and * the doorbell BAR).
@@ -560,6 +580,7 @@ struct qed_pf_params {struct qed_eth_pf_params eth_pf_params;struct qed_fcoe_pf_params fcoe_pf_params;struct qed_iscsi_pf_params iscsi_pf_params; +struct qed_nvmetcp_pf_params nvmetcp_pf_params;struct qed_rdma_pf_params rdma_pf_params; };
@@ -662,6 +683,7 @@ enum qed_sb_type {enum qed_protocol {QED_PROTOCOL_ETH ,QED_PROTOCOL_ISCSI , +QED_PROTOCOL_NVMETCP =QED_PROTOCOL_ISCSI ,QED_PROTOCOL_FCOE , };
include/linux/qed/qed_nvmetcp_if.h new file +72 -0
72 lines not on this page · raw message
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 01/27] qed: Add NVMeTCP Offload PF Level FW and HW HSI
Quoted 460 lines · Shai Malin
This patch introduces the NVMeTCP device and PF level HSI and HSI functionality in order to initialize and interact with the HW device.
This patch is based on the qede, qedr, qedi, qedf drivers HSI.
Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/Kconfig | 3 + drivers/net/ethernet/qlogic/qed/Makefile | 2 + drivers/net/ethernet/qlogic/qed/qed.h | 3 + drivers/net/ethernet/qlogic/qed/qed_hsi.h | 1 + drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 282 ++++++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h | 51 ++++ drivers/net/ethernet/qlogic/qed/qed_sp.h | 2 + include/linux/qed/common_hsi.h | 1 + include/linux/qed/nvmetcp_common.h | 54 ++++ include/linux/qed/qed_if.h | 22 ++ include/linux/qed/qed_nvmetcp_if.h | 72 +++++ 11 files changed, 493 insertions(+)create mode 100644
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.ccreate mode 100644drivers/net/ethernet/qlogic/qed/qed_nvmetcp.hcreate mode 100644include/linux/qed/nvmetcp_common.hcreate mode 100644include/linux/qed/qed_nvmetcp_if.hdrivers/net/ethernet/qlogic/Kconfig +3
-0@@ -110,6 +110,9 @@ config QED_RDMA config QED_ISCSI bool +config QED_NVMETCP + bool + config QED_FCOE booldrivers/net/ethernet/qlogic/qed/Makefile +2
-0@@ -28,6 +28,8 @@ qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o qed-$(CONFIG_QED_LL2) += qed_ll2.o qed-$(CONFIG_QED_OOO) += qed_ooo.o +qed-$(CONFIG_QED_NVMETCP) += qed_nvmetcp.o + qed-$(CONFIG_QED_RDMA) += \ qed_iwarp.o \ qed_rdma.o \drivers/net/ethernet/qlogic/qed/qed.h +3
-0@@ -240,6 +240,7 @@ enum QED_FEATURE {QED_VF ,QED_RDMA_CNQ ,QED_ISCSI_CQ , +QED_NVMETCP_CQ =QED_ISCSI_CQ ,QED_FCOE_CQ ,QED_VF_L2_QUE , QED_MAX_FEATURES,@@ -592,6 +593,7 @@ struct qed_hwfn {struct qed_ooo_info *p_ooo_info;struct qed_rdma_info *p_rdma_info;struct qed_iscsi_info *p_iscsi_info; +struct qed_nvmetcp_info *p_nvmetcp_info;struct qed_fcoe_info *p_fcoe_info;struct qed_pf_params pf_params;@@ -828,6 +830,7 @@ struct qed_dev {struct qed_eth_cb_ops *eth;struct qed_fcoe_cb_ops *fcoe;struct qed_iscsi_cb_ops *iscsi; +struct qed_nvmetcp_cb_ops *nvmetcp; } protocol_ops;void *ops_cookie;drivers/net/ethernet/qlogic/qed/qed_hsi.h +1
-0@@ -20,6 +20,7 @@#include <linux/qed/fcoe_common.h> #include <linux/qed/eth_common.h> #include <linux/qed/iscsi_common.h> +#include <linux/qed/nvmetcp_common.h> #include <linux/qed/iwarp_common.h> #include <linux/qed/rdma_common.h> #include <linux/qed/roce_common.h> drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c new file +282
-0@@ -0,0 +1,282 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) +/* Copyright 2021 Marvell. All rights reserved. */ + +#include <linux/types.h> +#include <asm/byteorder.h> +#include <asm/param.h> +#include <linux/delay.h> +#include <linux/dma-mapping.h> +#include <linux/etherdevice.h> +#include <linux/kernel.h> +#include <linux/log2.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/stddef.h> +#include <linux/string.h> +#include <linux/errno.h> +#include <linux/list.h> +#include <linux/qed/qed_nvmetcp_if.h> +#include "qed.h" +#include "qed_cxt.h" +#include "qed_dev_api.h" +#include "qed_hsi.h" +#include "qed_hw.h" +#include "qed_int.h" +#include "qed_nvmetcp.h" +#include "qed_ll2.h" +#include "qed_mcp.h" +#include "qed_sp.h" +#include "qed_reg_addr.h" + +static int qed_nvmetcp_async_event (struct qed_hwfn *p_hwfn,u8 fw_event_code, +u16 echo,union event_ring_data *data, +u8 fw_return_code) +{ +if (p_hwfn->p_nvmetcp_info->event_cb) { +struct qed_nvmetcp_info *p_nvmetcp = p_hwfn->p_nvmetcp_info; + +return p_nvmetcp->event_cb (p_nvmetcp->event_context, + fw_event_code, data); + }else { +DP_NOTICE (p_hwfn,"nvmetcp async completion is not set\n" ); + +return -EINVAL ; + } +} + +static int qed_sp_nvmetcp_func_start (struct qed_hwfn *p_hwfn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr, +void *event_context, +nvmetcp_event_cb_t async_event_cb) +{ +struct nvmetcp_init_ramrod_params *p_ramrod =NULL ; +struct qed_nvmetcp_pf_params *p_params =NULL ; +struct scsi_init_func_queues *p_queue =NULL ; +struct nvmetcp_spe_func_init *p_init =NULL ; +struct qed_sp_init_data init_data = {}; +struct qed_spq_entry *p_ent =NULL ; +int rc =0 ; +u16 val; +u8 i; + +/* Get SPQ entry */ + init_data.cid =qed_spq_get_cid (p_hwfn); + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_INIT_FUNC , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_init; + p_init = &p_ramrod->nvmetcp_init_spe; + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + p_queue = &p_init->q_params; + + p_init->num_sq_pages_in_ring = p_params->num_sq_pages_in_ring; + p_init->num_r2tq_pages_in_ring = p_params->num_r2tq_pages_in_ring; + p_init->num_uhq_pages_in_ring = p_params->num_uhq_pages_in_ring; + p_init->ll2_rx_queue_id =RESC_START (p_hwfn,QED_LL2_RAM_QUEUE ) + + p_params->ll2_ooo_queue_id; + +SET_FIELD (p_init->flags,NVMETCP_SPE_FUNC_INIT_NVMETCP_MODE ,1 ); + + p_init->func_params.log_page_size =ilog2 (PAGE_SIZE ); + p_init->func_params.num_tasks =cpu_to_le16 (p_params->num_tasks); + p_init->debug_flags = p_params->debug_mode; + +DMA_REGPAIR_LE (p_queue->glbl_q_params_addr, + p_params->glbl_q_params_addr); + + p_queue->cq_num_entries =cpu_to_le16 (QED_NVMETCP_FW_CQ_SIZE ); + p_queue->num_queues = p_params->num_queues; + val =RESC_START (p_hwfn,QED_CMDQS_CQS ); + p_queue->queue_relative_offset =cpu_to_le16 ((u16 )val); + p_queue->cq_sb_pi = p_params->gl_rq_pi; + +for (i =0 ; i < p_params->num_queues; i++) { + val =qed_get_igu_sb_id (p_hwfn, i); + p_queue->cq_cmdq_sb_num_arr[i] =cpu_to_le16 (val); + } + +SET_FIELD (p_queue->q_validity, +SCSI_INIT_FUNC_QUEUES_CMD_VALID ,0 ); + p_queue->cmdq_num_entries =0 ; + p_queue->bdq_resource_id = (u8 )RESC_START (p_hwfn,QED_BDQ ); + +/* p_ramrod->tcp_init.min_rto = cpu_to_le16(p_params->min_rto); */ + p_ramrod->tcp_init.two_msl_timer =cpu_to_le32 (QED_TCP_TWO_MSL_TIMER ); + p_ramrod->tcp_init.tx_sws_timer =cpu_to_le16 (QED_TCP_SWS_TIMER ); + p_init->half_way_close_timeout =cpu_to_le16 (QED_TCP_HALF_WAY_CLOSE_TIMEOUT ); + p_ramrod->tcp_init.max_fin_rt =QED_TCP_MAX_FIN_RT ; + +SET_FIELD (p_ramrod->nvmetcp_init_spe.params, +NVMETCP_SPE_FUNC_INIT_MAX_SYN_RT ,QED_TCP_MAX_FIN_RT ); + + p_hwfn->p_nvmetcp_info->event_context = event_context; + p_hwfn->p_nvmetcp_info->event_cb = async_event_cb; + +qed_spq_register_async_cb (p_hwfn,PROTOCOLID_NVMETCP , + qed_nvmetcp_async_event); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_func_stop (struct qed_hwfn *p_hwfn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid =qed_spq_get_cid (p_hwfn); + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_DESTROY_FUNC , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + rc =qed_spq_post (p_hwfn, p_ent,NULL ); + +qed_spq_unregister_async_cb (p_hwfn,PROTOCOLID_NVMETCP ); + +return rc; +} + +static int qed_fill_nvmetcp_dev_info (struct qed_dev *cdev, +struct qed_dev_nvmetcp_info *info) +{ +struct qed_hwfn *hwfn =QED_AFFIN_HWFN (cdev); +int rc; + +memset (info,0 ,sizeof (*info)); + rc =qed_fill_dev_info (cdev, &info->common); + + info->port_id =MFW_PORT (hwfn); + info->num_cqs =FEAT_NUM (hwfn,QED_NVMETCP_CQ ); + +return rc; +} + +static void qed_register_nvmetcp_ops (struct qed_dev *cdev, +struct qed_nvmetcp_cb_ops *ops, +void *cookie) +{ + cdev->protocol_ops.nvmetcp = ops; + cdev->ops_cookie = cookie; +} + +static int qed_nvmetcp_stop (struct qed_dev *cdev) +{ +int rc; + +if (!(cdev->flags &QED_FLAG_STORAGE_STARTED )) { +DP_NOTICE (cdev,"nvmetcp already stopped\n" ); + +return 0 ; + } + +if (!hash_empty (cdev->connections)) { +DP_NOTICE (cdev, +"Can't stop nvmetcp - not all connections were returned\n" ); + +return -EINVAL ; + } + +/* Stop the nvmetcp */ + rc =qed_sp_nvmetcp_func_stop (QED_AFFIN_HWFN (cdev),QED_SPQ_MODE_EBLOCK , +NULL ); + cdev->flags &= ~QED_FLAG_STORAGE_STARTED ; + +return rc; +} + +static int qed_nvmetcp_start (struct qed_dev *cdev, +struct qed_nvmetcp_tid *tasks, +void *event_context, +nvmetcp_event_cb_t async_event_cb) +{ +struct qed_tid_mem *tid_info; +int rc; + +if (cdev->flags &QED_FLAG_STORAGE_STARTED ) { +DP_NOTICE (cdev,"nvmetcp already started;\n" ); + +return 0 ; + } + + rc =qed_sp_nvmetcp_func_start (QED_AFFIN_HWFN (cdev), +QED_SPQ_MODE_EBLOCK ,NULL , + event_context, async_event_cb); +if (rc) { +DP_NOTICE (cdev,"Failed to start nvmetcp\n" ); + +return rc; + } + + cdev->flags |=QED_FLAG_STORAGE_STARTED ; +hash_init (cdev->connections); + +if (!tasks) +return 0 ; + + tid_info =kzalloc (sizeof (*tid_info),GFP_KERNEL ); + +if (!tid_info) { +qed_nvmetcp_stop (cdev); + +return -ENOMEM ; + } + + rc =qed_cxt_get_tid_mem_info (QED_AFFIN_HWFN (cdev), tid_info); +if (rc) { +DP_NOTICE (cdev,"Failed to gather task information\n" ); +qed_nvmetcp_stop (cdev); +kfree (tid_info); + +return rc; + } + +/* Fill task information */ + tasks->size = tid_info->tid_size; + tasks->num_tids_per_block = tid_info->num_tids_per_block; +memcpy (tasks->blocks, tid_info->blocks, +MAX_TID_BLOCKS_NVMETCP *sizeof (u8 *)); + +kfree (tid_info); + +return 0 ; +} + +static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { + .common = &qed_common_ops_pass, + .ll2 = &qed_ll2_ops_pass, + .fill_dev_info = &qed_fill_nvmetcp_dev_info, + .register_ops = &qed_register_nvmetcp_ops, + .start = &qed_nvmetcp_start, + .stop = &qed_nvmetcp_stop, + +/* Placeholder - Connection level ops */ +}; + +const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void ) +{ +return &qed_nvmetcp_ops_pass; +} +EXPORT_SYMBOL (qed_get_nvmetcp_ops); + +void qed_put_nvmetcp_ops (void ) +{ +} +EXPORT_SYMBOL (qed_put_nvmetcp_ops);drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h new file +51
-0@@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef _QED_NVMETCP_H +#define _QED_NVMETCP_H + +#include <linux/types.h> +#include <linux/list.h> +#include <linux/slab.h> +#include <linux/spinlock.h> +#include <linux/qed/tcp_common.h> +#include <linux/qed/qed_nvmetcp_if.h> +#include <linux/qed/qed_chain.h> +#include "qed.h" +#include "qed_hsi.h" +#include "qed_mcp.h" +#include "qed_sp.h" + +#define QED_NVMETCP_FW_CQ_SIZE (4 * 1024) + +/* tcp parameters */ +#define QED_TCP_TWO_MSL_TIMER 4000 +#define QED_TCP_HALF_WAY_CLOSE_TIMEOUT 10 +#define QED_TCP_MAX_FIN_RT 2 +#define QED_TCP_SWS_TIMER 5000 + +struct qed_nvmetcp_info { +spinlock_t lock;/* Connection resources. */ +struct list_head free_list; +u16 max_num_outstanding_tasks; +void *event_context; +nvmetcp_event_cb_t event_cb; +}; + +#if IS_ENABLED (CONFIG_QED_NVMETCP ) +int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn); +void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn); +void qed_nvmetcp_free (struct qed_hwfn *p_hwfn); + +#else /* IS_ENABLED(CONFIG_QED_NVMETCP) */ +static inline int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn) +{ +return -EINVAL ; +} + +static inline void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn) {} +static inline void qed_nvmetcp_free (struct qed_hwfn *p_hwfn) {} + +#endif /* IS_ENABLED(CONFIG_QED_NVMETCP) */ + +#endif drivers/net/ethernet/qlogic/qed/qed_sp.h +2
-0@@ -100,6 +100,8 @@ union ramrod_data {struct iscsi_spe_conn_mac_update iscsi_conn_mac_update;struct iscsi_spe_conn_termination iscsi_conn_terminate; +struct nvmetcp_init_ramrod_params nvmetcp_init; +struct vf_start_ramrod_data vf_start;struct vf_stop_ramrod_data vf_stop; };include/linux/qed/common_hsi.h +0
-0
include/linux/qed/common_hsi.h enum mf_mode { · line 709
Quoted 7 lines
include/linux/qed/common_hsi.h +1
-0@@ -703,6 +703,7 @@ enum mf_mode {/* Per-protocol connection types */ enum protocol_type {PROTOCOLID_ISCSI , +PROTOCOLID_NVMETCP =PROTOCOLID_ISCSI ,PROTOCOLID_FCOE ,PROTOCOLID_ROCE ,PROTOCOLID_CORE ,
Why not a separate Protocol ID?
Don't you expect iSCSI and NVMe-TCP to be run at the same time?
Quoted 176 lines
include/linux/qed/nvmetcp_common.h new file +54
-0@@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef __NVMETCP_COMMON__ +#define __NVMETCP_COMMON__ + +#include "tcp_common.h" + +/* NVMeTCP firmware function init parameters */ +struct nvmetcp_spe_func_init { +__le16 half_way_close_timeout; +u8 num_sq_pages_in_ring; +u8 num_r2tq_pages_in_ring; +u8 num_uhq_pages_in_ring; +u8 ll2_rx_queue_id; +u8 flags; +#define NVMETCP_SPE_FUNC_INIT_COUNTERS_EN_MASK 0x1 +#define NVMETCP_SPE_FUNC_INIT_COUNTERS_EN_SHIFT 0 +#define NVMETCP_SPE_FUNC_INIT_NVMETCP_MODE_MASK 0x1 +#define NVMETCP_SPE_FUNC_INIT_NVMETCP_MODE_SHIFT 1 +#define NVMETCP_SPE_FUNC_INIT_RESERVED0_MASK 0x3F +#define NVMETCP_SPE_FUNC_INIT_RESERVED0_SHIFT 2 +u8 debug_flags; +__le16 reserved1; +u8 params; +#define NVMETCP_SPE_FUNC_INIT_MAX_SYN_RT_MASK 0xF +#define NVMETCP_SPE_FUNC_INIT_MAX_SYN_RT_SHIFT 0 +#define NVMETCP_SPE_FUNC_INIT_RESERVED1_MASK 0xF +#define NVMETCP_SPE_FUNC_INIT_RESERVED1_SHIFT 4 +u8 reserved2[5 ]; +struct scsi_init_func_params func_params; +struct scsi_init_func_queues q_params; +}; + +/* NVMeTCP init params passed by driver to FW in NVMeTCP init ramrod. */ +struct nvmetcp_init_ramrod_params { +struct nvmetcp_spe_func_init nvmetcp_init_spe; +struct tcp_init_params tcp_init; +}; + +/* NVMeTCP Ramrod Command IDs */ +enum nvmetcp_ramrod_cmd_id { +NVMETCP_RAMROD_CMD_ID_UNUSED =0 , +NVMETCP_RAMROD_CMD_ID_INIT_FUNC =1 , +NVMETCP_RAMROD_CMD_ID_DESTROY_FUNC =2 , +MAX_NVMETCP_RAMROD_CMD_ID +}; + +struct nvmetcp_glbl_queue_entry { +struct regpair cq_pbl_addr; +struct regpair reserved; +}; + +#endif /* __NVMETCP_COMMON__ */ include/linux/qed/qed_if.h +22
-0@@ -542,6 +542,26 @@ struct qed_iscsi_pf_params {u8 bdq_pbl_num_entries[3 ]; }; +struct qed_nvmetcp_pf_params { +u64 glbl_q_params_addr; +u16 cq_num_entries; + +u16 num_cons; +u16 num_tasks; + +u8 num_sq_pages_in_ring; +u8 num_r2tq_pages_in_ring; +u8 num_uhq_pages_in_ring; + +u8 num_queues; +u8 gl_rq_pi; +u8 gl_cmd_pi; +u8 debug_mode; +u8 ll2_ooo_queue_id; + +u16 min_rto; +}; +struct qed_rdma_pf_params {/* Supplied to QED during resource allocation (may affect the ILT and * the doorbell BAR). @@ -560,6 +580,7 @@ struct qed_pf_params {struct qed_eth_pf_params eth_pf_params;struct qed_fcoe_pf_params fcoe_pf_params;struct qed_iscsi_pf_params iscsi_pf_params; +struct qed_nvmetcp_pf_params nvmetcp_pf_params;struct qed_rdma_pf_params rdma_pf_params; };@@ -662,6 +683,7 @@ enum qed_sb_type {enum qed_protocol {QED_PROTOCOL_ETH ,QED_PROTOCOL_ISCSI , +QED_PROTOCOL_NVMETCP =QED_PROTOCOL_ISCSI ,QED_PROTOCOL_FCOE , };include/linux/qed/qed_nvmetcp_if.h new file +62
-0@@ -0,0 +1,72 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef _QED_NVMETCP_IF_H +#define _QED_NVMETCP_IF_H +#include <linux/types.h> +#include <linux/qed/qed_if.h> + +#define QED_NVMETCP_MAX_IO_SIZE 0x800000 + +typedef int (*nvmetcp_event_cb_t) (void *context, + u8 fw_event_code, void *fw_handle); + +struct qed_dev_nvmetcp_info { + struct qed_dev_info common; + + u8 port_id; /* Physical port */ + u8 num_cqs; +}; + +#define MAX_TID_BLOCKS_NVMETCP (512) +struct qed_nvmetcp_tid { + u32 size; /* In bytes per task */ + u32 num_tids_per_block; + u8 *blocks[MAX_TID_BLOCKS_NVMETCP]; +}; + +struct qed_nvmetcp_cb_ops { + struct qed_common_cb_ops common; +}; + +/** + * struct qed_nvmetcp_ops - qed NVMeTCP operations. + * @common: common operations pointer + * @ll2: light L2 operations pointer + * @fill_dev_info: fills NVMeTCP specific information + * @param cdev + * @param info + * @return 0 on success, otherwise error value. + * @register_ops: register nvmetcp operations + * @param cdev + * @param ops - specified using qed_nvmetcp_cb_ops + * @param cookie - driver private + * @start: nvmetcp in FW + * @param cdev + * @param tasks - qed will fill information about tasks + * return 0 on success, otherwise error value. + * @stop: nvmetcp in FW + * @param cdev + * return 0 on success, otherwise error value. + */ +struct qed_nvmetcp_ops { + const struct qed_common_ops *common; + + const struct qed_ll2_ops *ll2; + + int (*fill_dev_info)(struct qed_dev *cdev, + struct qed_dev_nvmetcp_info *info); + + void (*register_ops)(struct qed_dev *cdev, + struct qed_nvmetcp_cb_ops *ops, void *cookie); +
include/linux/qed/qed_nvmetcp_if.h line 72
Quoted 10 lines
include/linux/qed/qed_nvmetcp_if.h new file +10
-0+int (*start)(struct qed_dev *cdev, +struct qed_nvmetcp_tid *tasks, +void *event_context,nvmetcp_event_cb_t async_event_cb); + + int (*stop)(struct qed_dev *cdev); +}; + +const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void ); +void qed_put_nvmetcp_ops (void ); +#endif
As mentioned, please rearrange the patchset to have the NVMe-TCP patches first, then the driver specific bits.
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 01/27] qed: Add NVMeTCP Offload PF Level FW and HW HSI
Quoted 463 lines · Hannes Reinecke
Quoted 462 lines · Shai Malin
This patch introduces the NVMeTCP device and PF level HSI and HSI functionality in order to initialize and interact with the HW device.
This patch is based on the qede, qedr, qedi, qedf drivers HSI.
Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/Kconfig | 3 + drivers/net/ethernet/qlogic/qed/Makefile | 2 + drivers/net/ethernet/qlogic/qed/qed.h | 3 + drivers/net/ethernet/qlogic/qed/qed_hsi.h | 1 + drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 282 ++++++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h | 51 ++++ drivers/net/ethernet/qlogic/qed/qed_sp.h | 2 + include/linux/qed/common_hsi.h | 1 + include/linux/qed/nvmetcp_common.h | 54 ++++ include/linux/qed/qed_if.h | 22 ++ include/linux/qed/qed_nvmetcp_if.h | 72 +++++ 11 files changed, 493 insertions(+)create mode 100644
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.ccreate mode 100644drivers/net/ethernet/qlogic/qed/qed_nvmetcp.hcreate mode 100644include/linux/qed/nvmetcp_common.hcreate mode 100644include/linux/qed/qed_nvmetcp_if.hdrivers/net/ethernet/qlogic/Kconfig +3
-0@@ -110,6 +110,9 @@ config QED_RDMA config QED_ISCSI bool +config QED_NVMETCP + bool + config QED_FCOE booldrivers/net/ethernet/qlogic/qed/Makefile +2
-0@@ -28,6 +28,8 @@ qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o qed-$(CONFIG_QED_LL2) += qed_ll2.o qed-$(CONFIG_QED_OOO) += qed_ooo.o +qed-$(CONFIG_QED_NVMETCP) += qed_nvmetcp.o + qed-$(CONFIG_QED_RDMA) += \ qed_iwarp.o \ qed_rdma.o \drivers/net/ethernet/qlogic/qed/qed.h +3
-0@@ -240,6 +240,7 @@ enum QED_FEATURE {QED_VF ,QED_RDMA_CNQ ,QED_ISCSI_CQ , +QED_NVMETCP_CQ =QED_ISCSI_CQ ,QED_FCOE_CQ ,QED_VF_L2_QUE , QED_MAX_FEATURES,@@ -592,6 +593,7 @@ struct qed_hwfn {struct qed_ooo_info *p_ooo_info;struct qed_rdma_info *p_rdma_info;struct qed_iscsi_info *p_iscsi_info; +struct qed_nvmetcp_info *p_nvmetcp_info;struct qed_fcoe_info *p_fcoe_info;struct qed_pf_params pf_params;@@ -828,6 +830,7 @@ struct qed_dev {struct qed_eth_cb_ops *eth;struct qed_fcoe_cb_ops *fcoe;struct qed_iscsi_cb_ops *iscsi; +struct qed_nvmetcp_cb_ops *nvmetcp; } protocol_ops;void *ops_cookie;drivers/net/ethernet/qlogic/qed/qed_hsi.h +1
-0@@ -20,6 +20,7 @@#include <linux/qed/fcoe_common.h> #include <linux/qed/eth_common.h> #include <linux/qed/iscsi_common.h> +#include <linux/qed/nvmetcp_common.h> #include <linux/qed/iwarp_common.h> #include <linux/qed/rdma_common.h> #include <linux/qed/roce_common.h> drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c new file +282
-0@@ -0,0 +1,282 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) +/* Copyright 2021 Marvell. All rights reserved. */ + +#include <linux/types.h> +#include <asm/byteorder.h> +#include <asm/param.h> +#include <linux/delay.h> +#include <linux/dma-mapping.h> +#include <linux/etherdevice.h> +#include <linux/kernel.h> +#include <linux/log2.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/stddef.h> +#include <linux/string.h> +#include <linux/errno.h> +#include <linux/list.h> +#include <linux/qed/qed_nvmetcp_if.h> +#include "qed.h" +#include "qed_cxt.h" +#include "qed_dev_api.h" +#include "qed_hsi.h" +#include "qed_hw.h" +#include "qed_int.h" +#include "qed_nvmetcp.h" +#include "qed_ll2.h" +#include "qed_mcp.h" +#include "qed_sp.h" +#include "qed_reg_addr.h" + +static int qed_nvmetcp_async_event (struct qed_hwfn *p_hwfn,u8 fw_event_code, +u16 echo,union event_ring_data *data, +u8 fw_return_code) +{ +if (p_hwfn->p_nvmetcp_info->event_cb) { +struct qed_nvmetcp_info *p_nvmetcp = p_hwfn->p_nvmetcp_info; + +return p_nvmetcp->event_cb (p_nvmetcp->event_context, + fw_event_code, data); + }else { +DP_NOTICE (p_hwfn,"nvmetcp async completion is not set\n" ); + +return -EINVAL ; + } +} + +static int qed_sp_nvmetcp_func_start (struct qed_hwfn *p_hwfn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr, +void *event_context, +nvmetcp_event_cb_t async_event_cb) +{ +struct nvmetcp_init_ramrod_params *p_ramrod =NULL ; +struct qed_nvmetcp_pf_params *p_params =NULL ; +struct scsi_init_func_queues *p_queue =NULL ; +struct nvmetcp_spe_func_init *p_init =NULL ; +struct qed_sp_init_data init_data = {}; +struct qed_spq_entry *p_ent =NULL ; +int rc =0 ; +u16 val; +u8 i; + +/* Get SPQ entry */ + init_data.cid =qed_spq_get_cid (p_hwfn); + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_INIT_FUNC , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_init; + p_init = &p_ramrod->nvmetcp_init_spe; + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + p_queue = &p_init->q_params; + + p_init->num_sq_pages_in_ring = p_params->num_sq_pages_in_ring; + p_init->num_r2tq_pages_in_ring = p_params->num_r2tq_pages_in_ring; + p_init->num_uhq_pages_in_ring = p_params->num_uhq_pages_in_ring; + p_init->ll2_rx_queue_id =RESC_START (p_hwfn,QED_LL2_RAM_QUEUE ) + + p_params->ll2_ooo_queue_id; + +SET_FIELD (p_init->flags,NVMETCP_SPE_FUNC_INIT_NVMETCP_MODE ,1 ); + + p_init->func_params.log_page_size =ilog2 (PAGE_SIZE ); + p_init->func_params.num_tasks =cpu_to_le16 (p_params->num_tasks); + p_init->debug_flags = p_params->debug_mode; + +DMA_REGPAIR_LE (p_queue->glbl_q_params_addr, + p_params->glbl_q_params_addr); + + p_queue->cq_num_entries =cpu_to_le16 (QED_NVMETCP_FW_CQ_SIZE ); + p_queue->num_queues = p_params->num_queues; + val =RESC_START (p_hwfn,QED_CMDQS_CQS ); + p_queue->queue_relative_offset =cpu_to_le16 ((u16 )val); + p_queue->cq_sb_pi = p_params->gl_rq_pi; + +for (i =0 ; i < p_params->num_queues; i++) { + val =qed_get_igu_sb_id (p_hwfn, i); + p_queue->cq_cmdq_sb_num_arr[i] =cpu_to_le16 (val); + } + +SET_FIELD (p_queue->q_validity, +SCSI_INIT_FUNC_QUEUES_CMD_VALID ,0 ); + p_queue->cmdq_num_entries =0 ; + p_queue->bdq_resource_id = (u8 )RESC_START (p_hwfn,QED_BDQ ); + +/* p_ramrod->tcp_init.min_rto = cpu_to_le16(p_params->min_rto); */ + p_ramrod->tcp_init.two_msl_timer =cpu_to_le32 (QED_TCP_TWO_MSL_TIMER ); + p_ramrod->tcp_init.tx_sws_timer =cpu_to_le16 (QED_TCP_SWS_TIMER ); + p_init->half_way_close_timeout =cpu_to_le16 (QED_TCP_HALF_WAY_CLOSE_TIMEOUT ); + p_ramrod->tcp_init.max_fin_rt =QED_TCP_MAX_FIN_RT ; + +SET_FIELD (p_ramrod->nvmetcp_init_spe.params, +NVMETCP_SPE_FUNC_INIT_MAX_SYN_RT ,QED_TCP_MAX_FIN_RT ); + + p_hwfn->p_nvmetcp_info->event_context = event_context; + p_hwfn->p_nvmetcp_info->event_cb = async_event_cb; + +qed_spq_register_async_cb (p_hwfn,PROTOCOLID_NVMETCP , + qed_nvmetcp_async_event); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_func_stop (struct qed_hwfn *p_hwfn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid =qed_spq_get_cid (p_hwfn); + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_DESTROY_FUNC , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + rc =qed_spq_post (p_hwfn, p_ent,NULL ); + +qed_spq_unregister_async_cb (p_hwfn,PROTOCOLID_NVMETCP ); + +return rc; +} + +static int qed_fill_nvmetcp_dev_info (struct qed_dev *cdev, +struct qed_dev_nvmetcp_info *info) +{ +struct qed_hwfn *hwfn =QED_AFFIN_HWFN (cdev); +int rc; + +memset (info,0 ,sizeof (*info)); + rc =qed_fill_dev_info (cdev, &info->common); + + info->port_id =MFW_PORT (hwfn); + info->num_cqs =FEAT_NUM (hwfn,QED_NVMETCP_CQ ); + +return rc; +} + +static void qed_register_nvmetcp_ops (struct qed_dev *cdev, +struct qed_nvmetcp_cb_ops *ops, +void *cookie) +{ + cdev->protocol_ops.nvmetcp = ops; + cdev->ops_cookie = cookie; +} + +static int qed_nvmetcp_stop (struct qed_dev *cdev) +{ +int rc; + +if (!(cdev->flags &QED_FLAG_STORAGE_STARTED )) { +DP_NOTICE (cdev,"nvmetcp already stopped\n" ); + +return 0 ; + } + +if (!hash_empty (cdev->connections)) { +DP_NOTICE (cdev, +"Can't stop nvmetcp - not all connections were returned\n" ); + +return -EINVAL ; + } + +/* Stop the nvmetcp */ + rc =qed_sp_nvmetcp_func_stop (QED_AFFIN_HWFN (cdev),QED_SPQ_MODE_EBLOCK , +NULL ); + cdev->flags &= ~QED_FLAG_STORAGE_STARTED ; + +return rc; +} + +static int qed_nvmetcp_start (struct qed_dev *cdev, +struct qed_nvmetcp_tid *tasks, +void *event_context, +nvmetcp_event_cb_t async_event_cb) +{ +struct qed_tid_mem *tid_info; +int rc; + +if (cdev->flags &QED_FLAG_STORAGE_STARTED ) { +DP_NOTICE (cdev,"nvmetcp already started;\n" ); + +return 0 ; + } + + rc =qed_sp_nvmetcp_func_start (QED_AFFIN_HWFN (cdev), +QED_SPQ_MODE_EBLOCK ,NULL , + event_context, async_event_cb); +if (rc) { +DP_NOTICE (cdev,"Failed to start nvmetcp\n" ); + +return rc; + } + + cdev->flags |=QED_FLAG_STORAGE_STARTED ; +hash_init (cdev->connections); + +if (!tasks) +return 0 ; + + tid_info =kzalloc (sizeof (*tid_info),GFP_KERNEL ); + +if (!tid_info) { +qed_nvmetcp_stop (cdev); + +return -ENOMEM ; + } + + rc =qed_cxt_get_tid_mem_info (QED_AFFIN_HWFN (cdev), tid_info); +if (rc) { +DP_NOTICE (cdev,"Failed to gather task information\n" ); +qed_nvmetcp_stop (cdev); +kfree (tid_info); + +return rc; + } + +/* Fill task information */ + tasks->size = tid_info->tid_size; + tasks->num_tids_per_block = tid_info->num_tids_per_block; +memcpy (tasks->blocks, tid_info->blocks, +MAX_TID_BLOCKS_NVMETCP *sizeof (u8 *)); + +kfree (tid_info); + +return 0 ; +} + +static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { + .common = &qed_common_ops_pass, + .ll2 = &qed_ll2_ops_pass, + .fill_dev_info = &qed_fill_nvmetcp_dev_info, + .register_ops = &qed_register_nvmetcp_ops, + .start = &qed_nvmetcp_start, + .stop = &qed_nvmetcp_stop, + +/* Placeholder - Connection level ops */ +}; + +const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void ) +{ +return &qed_nvmetcp_ops_pass; +} +EXPORT_SYMBOL (qed_get_nvmetcp_ops); + +void qed_put_nvmetcp_ops (void ) +{ +} +EXPORT_SYMBOL (qed_put_nvmetcp_ops);drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h new file +51
-0@@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef _QED_NVMETCP_H +#define _QED_NVMETCP_H + +#include <linux/types.h> +#include <linux/list.h> +#include <linux/slab.h> +#include <linux/spinlock.h> +#include <linux/qed/tcp_common.h> +#include <linux/qed/qed_nvmetcp_if.h> +#include <linux/qed/qed_chain.h> +#include "qed.h" +#include "qed_hsi.h" +#include "qed_mcp.h" +#include "qed_sp.h" + +#define QED_NVMETCP_FW_CQ_SIZE (4 * 1024) + +/* tcp parameters */ +#define QED_TCP_TWO_MSL_TIMER 4000 +#define QED_TCP_HALF_WAY_CLOSE_TIMEOUT 10 +#define QED_TCP_MAX_FIN_RT 2 +#define QED_TCP_SWS_TIMER 5000 + +struct qed_nvmetcp_info { +spinlock_t lock;/* Connection resources. */ +struct list_head free_list; +u16 max_num_outstanding_tasks; +void *event_context; +nvmetcp_event_cb_t event_cb; +}; + +#if IS_ENABLED (CONFIG_QED_NVMETCP ) +int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn); +void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn); +void qed_nvmetcp_free (struct qed_hwfn *p_hwfn); + +#else /* IS_ENABLED(CONFIG_QED_NVMETCP) */ +static inline int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn) +{ +return -EINVAL ; +} + +static inline void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn) {} +static inline void qed_nvmetcp_free (struct qed_hwfn *p_hwfn) {} + +#endif /* IS_ENABLED(CONFIG_QED_NVMETCP) */ + +#endif drivers/net/ethernet/qlogic/qed/qed_sp.h +2
-0@@ -100,6 +100,8 @@ union ramrod_data {struct iscsi_spe_conn_mac_update iscsi_conn_mac_update;struct iscsi_spe_conn_termination iscsi_conn_terminate; +struct nvmetcp_init_ramrod_params nvmetcp_init; +struct vf_start_ramrod_data vf_start;struct vf_stop_ramrod_data vf_stop; };include/linux/qed/common_hsi.h +0
-0@@ -703,6 +703,7 @@ enum mf_mode {/* Per-protocol connection types */ enum protocol_type {
Quoted 8 lines
include/linux/qed/common_hsi.h enum mf_mode { · line 709
Quoted 5 lines
include/linux/qed/common_hsi.h +1
-0PROTOCOLID_ISCSI , +PROTOCOLID_NVMETCP =PROTOCOLID_ISCSI ,PROTOCOLID_FCOE ,PROTOCOLID_ROCE , PROTOCOLID_CORE,Why not a separate Protocol ID?
Don't you expect iSCSI and NVMe-TCP to be run at the same time?
PROTOCOLID determines the FW resource layout, which is the same for iSCSI and NVMeTCP.
I will change PROTOCOLID_NVMETCP and PROTOCOLID_ISCSI to PROTOCOLID_TCP_ULP.
iSCSI and NVMeTCP can run concurrently on the device, but not on the same PF. Both iSCSI and NVMeTCP PFs will use PROTOCOLID_TCP_ULP
Quoted 181 lines
Quoted 181 lines
include/linux/qed/nvmetcp_common.h new file +54
-0@@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef __NVMETCP_COMMON__ +#define __NVMETCP_COMMON__ + +#include "tcp_common.h" + +/* NVMeTCP firmware function init parameters */ +struct nvmetcp_spe_func_init { +__le16 half_way_close_timeout; +u8 num_sq_pages_in_ring; +u8 num_r2tq_pages_in_ring; +u8 num_uhq_pages_in_ring; +u8 ll2_rx_queue_id; +u8 flags; +#define NVMETCP_SPE_FUNC_INIT_COUNTERS_EN_MASK 0x1 +#define NVMETCP_SPE_FUNC_INIT_COUNTERS_EN_SHIFT 0 +#define NVMETCP_SPE_FUNC_INIT_NVMETCP_MODE_MASK 0x1 +#define NVMETCP_SPE_FUNC_INIT_NVMETCP_MODE_SHIFT 1 +#define NVMETCP_SPE_FUNC_INIT_RESERVED0_MASK 0x3F +#define NVMETCP_SPE_FUNC_INIT_RESERVED0_SHIFT 2 +u8 debug_flags; +__le16 reserved1; +u8 params; +#define NVMETCP_SPE_FUNC_INIT_MAX_SYN_RT_MASK 0xF +#define NVMETCP_SPE_FUNC_INIT_MAX_SYN_RT_SHIFT 0 +#define NVMETCP_SPE_FUNC_INIT_RESERVED1_MASK 0xF +#define NVMETCP_SPE_FUNC_INIT_RESERVED1_SHIFT 4 +u8 reserved2[5 ]; +struct scsi_init_func_params func_params; +struct scsi_init_func_queues q_params; +}; + +/* NVMeTCP init params passed by driver to FW in NVMeTCP init ramrod. */ +struct nvmetcp_init_ramrod_params { +struct nvmetcp_spe_func_init nvmetcp_init_spe; +struct tcp_init_params tcp_init; +}; + +/* NVMeTCP Ramrod Command IDs */ +enum nvmetcp_ramrod_cmd_id { +NVMETCP_RAMROD_CMD_ID_UNUSED =0 , +NVMETCP_RAMROD_CMD_ID_INIT_FUNC =1 , +NVMETCP_RAMROD_CMD_ID_DESTROY_FUNC =2 , +MAX_NVMETCP_RAMROD_CMD_ID +}; + +struct nvmetcp_glbl_queue_entry { +struct regpair cq_pbl_addr; +struct regpair reserved; +}; + +#endif /* __NVMETCP_COMMON__ */ include/linux/qed/qed_if.h +22
-0@@ -542,6 +542,26 @@ struct qed_iscsi_pf_params {u8 bdq_pbl_num_entries[3 ]; }; +struct qed_nvmetcp_pf_params { +u64 glbl_q_params_addr; +u16 cq_num_entries; + +u16 num_cons; +u16 num_tasks; + +u8 num_sq_pages_in_ring; +u8 num_r2tq_pages_in_ring; +u8 num_uhq_pages_in_ring; + +u8 num_queues; +u8 gl_rq_pi; +u8 gl_cmd_pi; +u8 debug_mode; +u8 ll2_ooo_queue_id; + +u16 min_rto; +}; +struct qed_rdma_pf_params {/* Supplied to QED during resource allocation (may affect the ILT and * the doorbell BAR). @@ -560,6 +580,7 @@ struct qed_pf_params {struct qed_eth_pf_params eth_pf_params;struct qed_fcoe_pf_params fcoe_pf_params;struct qed_iscsi_pf_params iscsi_pf_params; +struct qed_nvmetcp_pf_params nvmetcp_pf_params;struct qed_rdma_pf_params rdma_pf_params; };@@ -662,6 +683,7 @@ enum qed_sb_type {enum qed_protocol {QED_PROTOCOL_ETH ,QED_PROTOCOL_ISCSI , +QED_PROTOCOL_NVMETCP =QED_PROTOCOL_ISCSI ,QED_PROTOCOL_FCOE , };include/linux/qed/qed_nvmetcp_if.h new file +67
-0@@ -0,0 +1,72 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef _QED_NVMETCP_IF_H +#define _QED_NVMETCP_IF_H +#include <linux/types.h> +#include <linux/qed/qed_if.h> + +#define QED_NVMETCP_MAX_IO_SIZE 0x800000 + +typedef int (*nvmetcp_event_cb_t) (void *context, + u8 fw_event_code, void *fw_handle); + +struct qed_dev_nvmetcp_info { + struct qed_dev_info common; + + u8 port_id; /* Physical port */ + u8 num_cqs; +}; + +#define MAX_TID_BLOCKS_NVMETCP (512) +struct qed_nvmetcp_tid { + u32 size; /* In bytes per task */ + u32 num_tids_per_block; + u8 *blocks[MAX_TID_BLOCKS_NVMETCP]; +}; + +struct qed_nvmetcp_cb_ops { + struct qed_common_cb_ops common; +}; + +/** + * struct qed_nvmetcp_ops - qed NVMeTCP operations. + * @common: common operations pointer + * @ll2: light L2 operations pointer + * @fill_dev_info: fills NVMeTCP specific information + * @param cdev + * @param info + * @return 0 on success, otherwise error value. + * @register_ops: register nvmetcp operations + * @param cdev + * @param ops - specified using qed_nvmetcp_cb_ops + * @param cookie - driver private + * @start: nvmetcp in FW + * @param cdev + * @param tasks - qed will fill information about tasks + * return 0 on success, otherwise error value. + * @stop: nvmetcp in FW + * @param cdev + * return 0 on success, otherwise error value. + */ +struct qed_nvmetcp_ops { + const struct qed_common_ops *common; + + const struct qed_ll2_ops *ll2; + + int (*fill_dev_info)(struct qed_dev *cdev, + struct qed_dev_nvmetcp_info *info); + + void (*register_ops)(struct qed_dev *cdev, + struct qed_nvmetcp_cb_ops *ops, void *cookie); + + int (*start)(struct qed_dev *cdev, + struct qed_nvmetcp_tid *tasks, + void *event_context, nvmetcp_event_cb_t async_event_cb); + + int (*stop)(struct qed_dev *cdev);
Quoted 8 lines
include/linux/qed/qed_nvmetcp_if.h line 72
Quoted 6 lines
include/linux/qed/qed_nvmetcp_if.h new file +5
-0+}; + +const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void ); +void qed_put_nvmetcp_ops (void ); +#endif As mentioned, please rearrange the patchset to have the NVMe-TCP patches first, then the driver specific bits.
Sure.
Quoted 9 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 2/27 qed: Add NVMeTCP Offload Connection Level FW and HW HSI
In reply to Shai MalinThis patch introduces the NVMeTCP HSI and HSI functionality in order to initialize and interact with the HW device as part of the connection level HSI.
This includes:
- Connection offload: offload a TCP connection to the FW.
- Connection update: update the ICReq-ICResp params
- Connection clear SQ: outstanding IOs FW flush.
- Connection termination: terminate the TCP connection and flush the FW.
--- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 580 +++++++++++++++++- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h | 63 ++ drivers/net/ethernet/qlogic/qed/qed_sp.h | 3 + include/linux/qed/nvmetcp_common.h | 143 +++++ include/linux/qed/qed_nvmetcp_if.h | 94 +++ 5 files changed, 881 insertions(+), 2 deletions(-)
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +578 -2
@@ -259,6 +259,578 @@ static int qed_nvmetcp_start(struct qed_dev *cdev,return 0 ; } +static struct qed_hash_nvmetcp_con *qed_nvmetcp_get_hash (struct qed_dev *cdev, +u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con =NULL ; + +if (!(cdev->flags &QED_FLAG_STORAGE_STARTED )) +return NULL ; + +hash_for_each_possible (cdev->connections, hash_con, node, handle) { +if (hash_con->con->icid == handle) +break ; + } + +if (!hash_con || hash_con->con->icid != handle) +return NULL ; + +return hash_con; +} + +static int qed_sp_nvmetcp_conn_offload (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_spe_conn_offload *p_ramrod =NULL ; +struct tcp_offload_params_opt2 *p_tcp2 =NULL ; +struct qed_sp_init_data init_data = {0 }; +struct qed_spq_entry *p_ent =NULL ; +dma_addr_t r2tq_pbl_addr; +dma_addr_t xhq_pbl_addr; +dma_addr_t uhq_pbl_addr; +u16 physical_q; +int rc =0 ; +u32 dval; +u8 i; + +/* Get SPQ entry */ + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_OFFLOAD_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_offload; + +/* Transmission PQ is the first of the PF */ + physical_q =qed_get_cm_pq_idx (p_hwfn,PQ_FLAGS_OFLD ); + p_conn->physical_q0 =cpu_to_le16 (physical_q); + p_ramrod->nvmetcp.physical_q0 =cpu_to_le16 (physical_q); + +/* nvmetcp Pure-ACK PQ */ + physical_q =qed_get_cm_pq_idx (p_hwfn,PQ_FLAGS_ACK ); + p_conn->physical_q1 =cpu_to_le16 (physical_q); + p_ramrod->nvmetcp.physical_q1 =cpu_to_le16 (physical_q); + + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + +DMA_REGPAIR_LE (p_ramrod->nvmetcp.sq_pbl_addr, p_conn->sq_pbl_addr); + + r2tq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->r2tq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.r2tq_pbl_addr, r2tq_pbl_addr); + + xhq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->xhq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.xhq_pbl_addr, xhq_pbl_addr); + + uhq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->uhq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.uhq_pbl_addr, uhq_pbl_addr); + + p_ramrod->nvmetcp.flags = p_conn->offl_flags; + p_ramrod->nvmetcp.default_cq = p_conn->default_cq; + p_ramrod->nvmetcp.initial_ack =0 ; + +DMA_REGPAIR_LE (p_ramrod->nvmetcp.nvmetcp.cccid_itid_table_addr, + p_conn->nvmetcp_cccid_itid_table_addr); + p_ramrod->nvmetcp.nvmetcp.cccid_max_range = +cpu_to_le16 (p_conn->nvmetcp_cccid_max_range); + + p_tcp2 = &p_ramrod->tcp; + +qed_set_fw_mac_addr (&p_tcp2->remote_mac_addr_hi, + &p_tcp2->remote_mac_addr_mid, + &p_tcp2->remote_mac_addr_lo, p_conn->remote_mac); +qed_set_fw_mac_addr (&p_tcp2->local_mac_addr_hi, + &p_tcp2->local_mac_addr_mid, + &p_tcp2->local_mac_addr_lo, p_conn->local_mac); + + p_tcp2->vlan_id =cpu_to_le16 (p_conn->vlan_id); + p_tcp2->flags =cpu_to_le16 (p_conn->tcp_flags); + + p_tcp2->ip_version = p_conn->ip_version; +for (i =0 ; i <4 ; i++) { + dval = p_conn->remote_ip[i]; + p_tcp2->remote_ip[i] =cpu_to_le32 (dval); + dval = p_conn->local_ip[i]; + p_tcp2->local_ip[i] =cpu_to_le32 (dval); + } + + p_tcp2->flow_label =cpu_to_le32 (p_conn->flow_label); + p_tcp2->ttl = p_conn->ttl; + p_tcp2->tos_or_tc = p_conn->tos_or_tc; + p_tcp2->remote_port =cpu_to_le16 (p_conn->remote_port); + p_tcp2->local_port =cpu_to_le16 (p_conn->local_port); + p_tcp2->mss =cpu_to_le16 (p_conn->mss); + p_tcp2->rcv_wnd_scale = p_conn->rcv_wnd_scale; + p_tcp2->connect_mode = p_conn->connect_mode; + p_tcp2->cwnd =cpu_to_le32 (p_conn->cwnd); + p_tcp2->ka_max_probe_cnt = p_conn->ka_max_probe_cnt; + p_tcp2->ka_timeout =cpu_to_le32 (p_conn->ka_timeout); + p_tcp2->max_rt_time =cpu_to_le32 (p_conn->max_rt_time); + p_tcp2->ka_interval =cpu_to_le32 (p_conn->ka_interval); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_update (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_conn_update_ramrod_params *p_ramrod =NULL ; +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; +u32 dval; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_UPDATE_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_update; + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + p_ramrod->flags = p_conn->update_flag; + p_ramrod->max_seq_size =cpu_to_le32 (p_conn->max_seq_size); + dval = p_conn->max_recv_pdu_length; + p_ramrod->max_recv_pdu_length =cpu_to_le32 (dval); + dval = p_conn->max_send_pdu_length; + p_ramrod->max_send_pdu_length =cpu_to_le32 (dval); + dval = p_conn->first_seq_length; + p_ramrod->first_seq_length =cpu_to_le32 (dval); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_terminate (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_spe_conn_termination *p_ramrod =NULL ; +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_TERMINATION_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_terminate; + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + p_ramrod->abortive = p_conn->abortive_dsconnect; + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_clear_sq (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_CLEAR_SQ , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static void __iomem *qed_nvmetcp_get_db_addr (struct qed_hwfn *p_hwfn,u32 cid) +{ +return (u8 __iomem *)p_hwfn->doorbells + +qed_db_addr (cid,DQ_DEMS_LEGACY ); +} + +static int qed_nvmetcp_allocate_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn **p_out_conn) +{ +struct qed_chain_init_params params = { + .mode =QED_CHAIN_MODE_PBL , + .intended_use =QED_CHAIN_USE_TO_CONSUME_PRODUCE , + .cnt_type =QED_CHAIN_CNT_TYPE_U16 , + }; +struct qed_nvmetcp_pf_params *p_params =NULL ; +struct qed_nvmetcp_conn *p_conn =NULL ; +int rc =0 ; + +/* Try finding a free connection that can be used */ +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +if (!list_empty (&p_hwfn->p_nvmetcp_info->free_list)) + p_conn =list_first_entry (&p_hwfn->p_nvmetcp_info->free_list, + struct qed_nvmetcp_conn, list_entry); +if (p_conn) { +list_del (&p_conn->list_entry); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + *p_out_conn = p_conn; + +return 0 ; + } +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +/* Need to allocate a new connection */ + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + + p_conn =kzalloc (sizeof (*p_conn),GFP_KERNEL ); +if (!p_conn) +return -ENOMEM ; + + params.num_elems = p_params->num_r2tq_pages_in_ring * +QED_CHAIN_PAGE_SIZE /sizeof (struct nvmetcp_wqe ); + params.elem_size =sizeof (struct nvmetcp_wqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->r2tq, ¶ms); +if (rc) + goto nomem_r2tq; + + params.num_elems = p_params->num_uhq_pages_in_ring * +QED_CHAIN_PAGE_SIZE /sizeof (struct iscsi_uhqe ); + params.elem_size =sizeof (struct iscsi_uhqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->uhq, ¶ms); +if (rc) + goto nomem_uhq; + + params.elem_size =sizeof (struct iscsi_xhqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->xhq, ¶ms); +if (rc) + goto nomem; + + p_conn->free_on_delete = true; + *p_out_conn = p_conn; + +return 0 ; + +nomem: +qed_chain_free (p_hwfn->cdev, &p_conn->uhq); +nomem_uhq: +qed_chain_free (p_hwfn->cdev, &p_conn->r2tq); +nomem_r2tq: +kfree (p_conn); + +return -ENOMEM ; +} + +static int qed_nvmetcp_acquire_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn **p_out_conn) +{ +struct qed_nvmetcp_conn *p_conn =NULL ; +int rc =0 ; +u32 icid; + +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); + rc =qed_cxt_acquire_cid (p_hwfn,PROTOCOLID_NVMETCP , &icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +if (rc) +return rc; + + rc =qed_nvmetcp_allocate_connection (p_hwfn, &p_conn); +if (rc) { +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +qed_cxt_release_cid (p_hwfn, icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +return rc; + } + + p_conn->icid = icid; + p_conn->conn_id = (u16 )icid; + p_conn->fw_cid = (p_hwfn->hw_info.opaque_fid <<16 ) | icid; + *p_out_conn = p_conn; + +return rc; +} + +static void qed_nvmetcp_release_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn) +{ +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +list_add_tail (&p_conn->list_entry, &p_hwfn->p_nvmetcp_info->free_list); +qed_cxt_release_cid (p_hwfn, p_conn->icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); +} + +static void qed_nvmetcp_free_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn) +{ +qed_chain_free (p_hwfn->cdev, &p_conn->xhq); +qed_chain_free (p_hwfn->cdev, &p_conn->uhq); +qed_chain_free (p_hwfn->cdev, &p_conn->r2tq); + +kfree (p_conn); +} + +int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn) +{ +struct qed_nvmetcp_info *p_nvmetcp_info; + + p_nvmetcp_info =kzalloc (sizeof (*p_nvmetcp_info),GFP_KERNEL ); +if (!p_nvmetcp_info) +return -ENOMEM ; + +INIT_LIST_HEAD (&p_nvmetcp_info->free_list); + + p_hwfn->p_nvmetcp_info = p_nvmetcp_info; + +return 0 ; +} + +void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn) +{ +spin_lock_init (&p_hwfn->p_nvmetcp_info->lock); +} + +void qed_nvmetcp_free (struct qed_hwfn *p_hwfn) +{ +struct qed_nvmetcp_conn *p_conn =NULL ; + +if (!p_hwfn->p_nvmetcp_info) +return ; + +while (!list_empty (&p_hwfn->p_nvmetcp_info->free_list)) { + p_conn =list_first_entry (&p_hwfn->p_nvmetcp_info->free_list, + struct qed_nvmetcp_conn, list_entry); +if (p_conn) { +list_del (&p_conn->list_entry); +qed_nvmetcp_free_connection (p_hwfn, p_conn); + } + } + +kfree (p_hwfn->p_nvmetcp_info); + p_hwfn->p_nvmetcp_info =NULL ; +} + +static int qed_nvmetcp_acquire_conn (struct qed_dev *cdev, +u32 *handle, +u32 *fw_cid,void __iomem **p_doorbell) +{ +struct qed_hash_nvmetcp_con *hash_con; +int rc; + +/* Allocate a hashed connection */ + hash_con =kzalloc (sizeof (*hash_con),GFP_ATOMIC ); +if (!hash_con) +return -ENOMEM ; + +/* Acquire the connection */ + rc =qed_nvmetcp_acquire_connection (QED_AFFIN_HWFN (cdev), + &hash_con->con); +if (rc) { +DP_NOTICE (cdev,"Failed to acquire Connection\n" ); +kfree (hash_con); + +return rc; + } + +/* Added the connection to hash table */ + *handle = hash_con->con->icid; + *fw_cid = hash_con->con->fw_cid; +hash_add (cdev->connections, &hash_con->node, *handle); + +if (p_doorbell) + *p_doorbell =qed_nvmetcp_get_db_addr (QED_AFFIN_HWFN (cdev), + *handle); + +return 0 ; +} + +static int qed_nvmetcp_release_conn (struct qed_dev *cdev,u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +hlist_del (&hash_con->node); +qed_nvmetcp_release_connection (QED_AFFIN_HWFN (cdev), hash_con->con); +kfree (hash_con); + +return 0 ; +} + +static int qed_nvmetcp_offload_conn (struct qed_dev *cdev,u32 handle, +struct qed_nvmetcp_params_offload *conn_info) +{ +struct qed_hash_nvmetcp_con *hash_con; +struct qed_nvmetcp_conn *con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +/* Update the connection with information from the params */ + con = hash_con->con; + +/* FW initializations */ + con->layer_code =NVMETCP_SLOW_PATH_LAYER_CODE ; + con->sq_pbl_addr = conn_info->sq_pbl_addr; + con->nvmetcp_cccid_max_range = conn_info->nvmetcp_cccid_max_range; + con->nvmetcp_cccid_itid_table_addr = conn_info->nvmetcp_cccid_itid_table_addr; + con->default_cq = conn_info->default_cq; + +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_TARGET_MODE ,0 ); +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_NVMETCP_MODE ,1 ); +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B ,1 ); + +/* Networking and TCP stack initializations */ +ether_addr_copy (con->local_mac, conn_info->src.mac); +ether_addr_copy (con->remote_mac, conn_info->dst.mac); +memcpy (con->local_ip, conn_info->src.ip,sizeof (con->local_ip)); +memcpy (con->remote_ip, conn_info->dst.ip,sizeof (con->remote_ip)); + con->local_port = conn_info->src.port; + con->remote_port = conn_info->dst.port; + con->vlan_id = conn_info->vlan_id; + +if (conn_info->timestamp_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_TS_EN ,1 ); + +if (conn_info->delayed_ack_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_DA_EN ,1 ); + +if (conn_info->tcp_keep_alive_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_KA_EN ,1 ); + +if (conn_info->ecn_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_ECN_EN ,1 ); + + con->ip_version = conn_info->ip_version; + con->flow_label =QED_TCP_FLOW_LABEL ; + con->ka_max_probe_cnt = conn_info->ka_max_probe_cnt; + con->ka_timeout = conn_info->ka_timeout; + con->ka_interval = conn_info->ka_interval; + con->max_rt_time = conn_info->max_rt_time; + con->ttl = conn_info->ttl; + con->tos_or_tc = conn_info->tos_or_tc; + con->mss = conn_info->mss; + con->cwnd = conn_info->cwnd; + con->rcv_wnd_scale = conn_info->rcv_wnd_scale; + con->connect_mode =0 ;/* TCP_CONNECT_ACTIVE */ + +return qed_sp_nvmetcp_conn_offload (QED_AFFIN_HWFN (cdev), con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_update_conn (struct qed_dev *cdev, +u32 handle, +struct qed_nvmetcp_params_update *conn_info) +{ +struct qed_hash_nvmetcp_con *hash_con; +struct qed_nvmetcp_conn *con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +/* Update the connection with information from the params */ + con = hash_con->con; + +SET_FIELD (con->update_flag, +ISCSI_CONN_UPDATE_RAMROD_PARAMS_INITIAL_R2T ,0 ); +SET_FIELD (con->update_flag, +ISCSI_CONN_UPDATE_RAMROD_PARAMS_IMMEDIATE_DATA ,1 ); + +if (conn_info->hdr_digest_en) +SET_FIELD (con->update_flag,ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN ,1 ); + +if (conn_info->data_digest_en) +SET_FIELD (con->update_flag,ISCSI_CONN_UPDATE_RAMROD_PARAMS_DD_EN ,1 ); + +/* Placeholder - initialize pfv, cpda, hpda */ + + con->max_seq_size = conn_info->max_io_size; + con->max_recv_pdu_length = conn_info->max_recv_pdu_length; + con->max_send_pdu_length = conn_info->max_send_pdu_length; + con->first_seq_length = conn_info->max_io_size; + +return qed_sp_nvmetcp_conn_update (QED_AFFIN_HWFN (cdev), con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_clear_conn_sq (struct qed_dev *cdev,u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +return qed_sp_nvmetcp_conn_clear_sq (QED_AFFIN_HWFN (cdev), hash_con->con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_destroy_conn (struct qed_dev *cdev, +u32 handle,u8 abrt_conn) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + + hash_con->con->abortive_dsconnect = abrt_conn; + +return qed_sp_nvmetcp_conn_terminate (QED_AFFIN_HWFN (cdev), hash_con->con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} +static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .common = &qed_common_ops_pass, .ll2 = &qed_ll2_ops_pass,
@@ -266,8 +838,12 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .register_ops = &qed_register_nvmetcp_ops, .start = &qed_nvmetcp_start, .stop = &qed_nvmetcp_stop, - -/* Placeholder - Connection level ops */ + .acquire_conn = &qed_nvmetcp_acquire_conn, + .release_conn = &qed_nvmetcp_release_conn, + .offload_conn = &qed_nvmetcp_offload_conn, + .update_conn = &qed_nvmetcp_update_conn, + .destroy_conn = &qed_nvmetcp_destroy_conn, + .clear_sq = &qed_nvmetcp_clear_conn_sq, };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void )
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h +63 -0
75 lines not on this page · raw message
drivers/net/ethernet/qlogic/qed/qed_sp.h +3 -0
@@ -101,6 +101,9 @@ union ramrod_data {struct iscsi_spe_conn_termination iscsi_conn_terminate;struct nvmetcp_init_ramrod_params nvmetcp_init; +struct nvmetcp_spe_conn_offload nvmetcp_conn_offload; +struct nvmetcp_conn_update_ramrod_params nvmetcp_conn_update; +struct nvmetcp_spe_conn_termination nvmetcp_conn_terminate;struct vf_start_ramrod_data vf_start;struct vf_stop_ramrod_data vf_stop;
include/linux/qed/nvmetcp_common.h +143 -0
159 lines not on this page · raw message
include/linux/qed/qed_nvmetcp_if.h +94 -0
112 lines not on this page · raw message
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 02/27] qed: Add NVMeTCP Offload Connection Level FW and HW HSI
Quoted 124 lines · Shai Malin
This patch introduces the NVMeTCP HSI and HSI functionality in order to initialize and interact with the HW device as part of the connection level HSI.
This includes:
- Connection offload: offload a TCP connection to the FW.
- Connection update: update the ICReq-ICResp params
- Connection clear SQ: outstanding IOs FW flush.
- Connection termination: terminate the TCP connection and flush the FW.Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 580 +++++++++++++++++- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h | 63 ++ drivers/net/ethernet/qlogic/qed/qed_sp.h | 3 + include/linux/qed/nvmetcp_common.h | 143 +++++ include/linux/qed/qed_nvmetcp_if.h | 94 +++ 5 files changed, 881 insertions(+), 2 deletions(-)drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +92
-0@@ -259,6 +259,578 @@ static int qed_nvmetcp_start(struct qed_dev *cdev,return 0 ; } +static struct qed_hash_nvmetcp_con *qed_nvmetcp_get_hash (struct qed_dev *cdev, +u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con =NULL ; + +if (!(cdev->flags &QED_FLAG_STORAGE_STARTED )) +return NULL ; + +hash_for_each_possible (cdev->connections, hash_con, node, handle) { +if (hash_con->con->icid == handle) +break ; + } + +if (!hash_con || hash_con->con->icid != handle) +return NULL ; + +return hash_con; +} + +static int qed_sp_nvmetcp_conn_offload (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_spe_conn_offload *p_ramrod =NULL ; +struct tcp_offload_params_opt2 *p_tcp2 =NULL ; +struct qed_sp_init_data init_data = {0 }; +struct qed_spq_entry *p_ent =NULL ; +dma_addr_t r2tq_pbl_addr; +dma_addr_t xhq_pbl_addr; +dma_addr_t uhq_pbl_addr; +u16 physical_q; +int rc =0 ; +u32 dval; +u8 i; + +/* Get SPQ entry */ + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_OFFLOAD_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_offload; + +/* Transmission PQ is the first of the PF */ + physical_q =qed_get_cm_pq_idx (p_hwfn,PQ_FLAGS_OFLD ); + p_conn->physical_q0 =cpu_to_le16 (physical_q); + p_ramrod->nvmetcp.physical_q0 =cpu_to_le16 (physical_q); + +/* nvmetcp Pure-ACK PQ */ + physical_q =qed_get_cm_pq_idx (p_hwfn,PQ_FLAGS_ACK ); + p_conn->physical_q1 =cpu_to_le16 (physical_q); + p_ramrod->nvmetcp.physical_q1 =cpu_to_le16 (physical_q); + + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + +DMA_REGPAIR_LE (p_ramrod->nvmetcp.sq_pbl_addr, p_conn->sq_pbl_addr); + + r2tq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->r2tq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.r2tq_pbl_addr, r2tq_pbl_addr); + + xhq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->xhq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.xhq_pbl_addr, xhq_pbl_addr); + + uhq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->uhq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.uhq_pbl_addr, uhq_pbl_addr); + + p_ramrod->nvmetcp.flags = p_conn->offl_flags; + p_ramrod->nvmetcp.default_cq = p_conn->default_cq; + p_ramrod->nvmetcp.initial_ack =0 ; + +DMA_REGPAIR_LE (p_ramrod->nvmetcp.nvmetcp.cccid_itid_table_addr, + p_conn->nvmetcp_cccid_itid_table_addr); + p_ramrod->nvmetcp.nvmetcp.cccid_max_range = +cpu_to_le16 (p_conn->nvmetcp_cccid_max_range); + + p_tcp2 = &p_ramrod->tcp; + +qed_set_fw_mac_addr (&p_tcp2->remote_mac_addr_hi, + &p_tcp2->remote_mac_addr_mid, + &p_tcp2->remote_mac_addr_lo, p_conn->remote_mac); +qed_set_fw_mac_addr (&p_tcp2->local_mac_addr_hi, + &p_tcp2->local_mac_addr_mid, + &p_tcp2->local_mac_addr_lo, p_conn->local_mac); + + p_tcp2->vlan_id =cpu_to_le16 (p_conn->vlan_id);
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c static int qed_nvmetcp_start(struct qed_dev *cdev, · line 363
Quoted 10 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +10
-0+ p_tcp2->flags =cpu_to_le16 (p_conn->tcp_flags); + + p_tcp2->ip_version = p_conn->ip_version; +for (i =0 ; i <4 ; i++) { + dval = p_conn->remote_ip[i]; + p_tcp2->remote_ip[i] =cpu_to_le32 (dval); + dval = p_conn->local_ip[i]; + p_tcp2->local_ip[i] =cpu_to_le32 (dval); + } +
What is this?
Some convoluted way of assigning the IP address in little endian? Pointless if it's IPv4, as then each bit is just one byte. And if it's for IPv6, what do you do for IPv4?
And isn't there a helper for it?
Quoted 859 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +476
-2+ p_tcp2->flow_label =cpu_to_le32 (p_conn->flow_label); + p_tcp2->ttl = p_conn->ttl; + p_tcp2->tos_or_tc = p_conn->tos_or_tc; + p_tcp2->remote_port =cpu_to_le16 (p_conn->remote_port); + p_tcp2->local_port =cpu_to_le16 (p_conn->local_port); + p_tcp2->mss =cpu_to_le16 (p_conn->mss); + p_tcp2->rcv_wnd_scale = p_conn->rcv_wnd_scale; + p_tcp2->connect_mode = p_conn->connect_mode; + p_tcp2->cwnd =cpu_to_le32 (p_conn->cwnd); + p_tcp2->ka_max_probe_cnt = p_conn->ka_max_probe_cnt; + p_tcp2->ka_timeout =cpu_to_le32 (p_conn->ka_timeout); + p_tcp2->max_rt_time =cpu_to_le32 (p_conn->max_rt_time); + p_tcp2->ka_interval =cpu_to_le32 (p_conn->ka_interval); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_update (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_conn_update_ramrod_params *p_ramrod =NULL ; +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; +u32 dval; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_UPDATE_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_update; + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + p_ramrod->flags = p_conn->update_flag; + p_ramrod->max_seq_size =cpu_to_le32 (p_conn->max_seq_size); + dval = p_conn->max_recv_pdu_length; + p_ramrod->max_recv_pdu_length =cpu_to_le32 (dval); + dval = p_conn->max_send_pdu_length; + p_ramrod->max_send_pdu_length =cpu_to_le32 (dval); + dval = p_conn->first_seq_length; + p_ramrod->first_seq_length =cpu_to_le32 (dval); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_terminate (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_spe_conn_termination *p_ramrod =NULL ; +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_TERMINATION_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_terminate; + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + p_ramrod->abortive = p_conn->abortive_dsconnect; + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_clear_sq (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_CLEAR_SQ , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static void __iomem *qed_nvmetcp_get_db_addr (struct qed_hwfn *p_hwfn,u32 cid) +{ +return (u8 __iomem *)p_hwfn->doorbells + +qed_db_addr (cid,DQ_DEMS_LEGACY ); +} + +static int qed_nvmetcp_allocate_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn **p_out_conn) +{ +struct qed_chain_init_params params = { + .mode =QED_CHAIN_MODE_PBL , + .intended_use =QED_CHAIN_USE_TO_CONSUME_PRODUCE , + .cnt_type =QED_CHAIN_CNT_TYPE_U16 , + }; +struct qed_nvmetcp_pf_params *p_params =NULL ; +struct qed_nvmetcp_conn *p_conn =NULL ; +int rc =0 ; + +/* Try finding a free connection that can be used */ +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +if (!list_empty (&p_hwfn->p_nvmetcp_info->free_list)) + p_conn =list_first_entry (&p_hwfn->p_nvmetcp_info->free_list, + struct qed_nvmetcp_conn, list_entry); +if (p_conn) { +list_del (&p_conn->list_entry); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + *p_out_conn = p_conn; + +return 0 ; + } +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +/* Need to allocate a new connection */ + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + + p_conn =kzalloc (sizeof (*p_conn),GFP_KERNEL ); +if (!p_conn) +return -ENOMEM ; + + params.num_elems = p_params->num_r2tq_pages_in_ring * +QED_CHAIN_PAGE_SIZE /sizeof (struct nvmetcp_wqe ); + params.elem_size =sizeof (struct nvmetcp_wqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->r2tq, ¶ms); +if (rc) + goto nomem_r2tq; + + params.num_elems = p_params->num_uhq_pages_in_ring * +QED_CHAIN_PAGE_SIZE /sizeof (struct iscsi_uhqe ); + params.elem_size =sizeof (struct iscsi_uhqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->uhq, ¶ms); +if (rc) + goto nomem_uhq; + + params.elem_size =sizeof (struct iscsi_xhqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->xhq, ¶ms); +if (rc) + goto nomem; + + p_conn->free_on_delete = true; + *p_out_conn = p_conn; + +return 0 ; + +nomem: +qed_chain_free (p_hwfn->cdev, &p_conn->uhq); +nomem_uhq: +qed_chain_free (p_hwfn->cdev, &p_conn->r2tq); +nomem_r2tq: +kfree (p_conn); + +return -ENOMEM ; +} + +static int qed_nvmetcp_acquire_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn **p_out_conn) +{ +struct qed_nvmetcp_conn *p_conn =NULL ; +int rc =0 ; +u32 icid; + +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); + rc =qed_cxt_acquire_cid (p_hwfn,PROTOCOLID_NVMETCP , &icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +if (rc) +return rc; + + rc =qed_nvmetcp_allocate_connection (p_hwfn, &p_conn); +if (rc) { +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +qed_cxt_release_cid (p_hwfn, icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +return rc; + } + + p_conn->icid = icid; + p_conn->conn_id = (u16 )icid; + p_conn->fw_cid = (p_hwfn->hw_info.opaque_fid <<16 ) | icid; + *p_out_conn = p_conn; + +return rc; +} + +static void qed_nvmetcp_release_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn) +{ +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +list_add_tail (&p_conn->list_entry, &p_hwfn->p_nvmetcp_info->free_list); +qed_cxt_release_cid (p_hwfn, p_conn->icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); +} + +static void qed_nvmetcp_free_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn) +{ +qed_chain_free (p_hwfn->cdev, &p_conn->xhq); +qed_chain_free (p_hwfn->cdev, &p_conn->uhq); +qed_chain_free (p_hwfn->cdev, &p_conn->r2tq); + +kfree (p_conn); +} + +int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn) +{ +struct qed_nvmetcp_info *p_nvmetcp_info; + + p_nvmetcp_info =kzalloc (sizeof (*p_nvmetcp_info),GFP_KERNEL ); +if (!p_nvmetcp_info) +return -ENOMEM ; + +INIT_LIST_HEAD (&p_nvmetcp_info->free_list); + + p_hwfn->p_nvmetcp_info = p_nvmetcp_info; + +return 0 ; +} + +void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn) +{ +spin_lock_init (&p_hwfn->p_nvmetcp_info->lock); +} + +void qed_nvmetcp_free (struct qed_hwfn *p_hwfn) +{ +struct qed_nvmetcp_conn *p_conn =NULL ; + +if (!p_hwfn->p_nvmetcp_info) +return ; + +while (!list_empty (&p_hwfn->p_nvmetcp_info->free_list)) { + p_conn =list_first_entry (&p_hwfn->p_nvmetcp_info->free_list, + struct qed_nvmetcp_conn, list_entry); +if (p_conn) { +list_del (&p_conn->list_entry); +qed_nvmetcp_free_connection (p_hwfn, p_conn); + } + } + +kfree (p_hwfn->p_nvmetcp_info); + p_hwfn->p_nvmetcp_info =NULL ; +} + +static int qed_nvmetcp_acquire_conn (struct qed_dev *cdev, +u32 *handle, +u32 *fw_cid,void __iomem **p_doorbell) +{ +struct qed_hash_nvmetcp_con *hash_con; +int rc; + +/* Allocate a hashed connection */ + hash_con =kzalloc (sizeof (*hash_con),GFP_ATOMIC ); +if (!hash_con) +return -ENOMEM ; + +/* Acquire the connection */ + rc =qed_nvmetcp_acquire_connection (QED_AFFIN_HWFN (cdev), + &hash_con->con); +if (rc) { +DP_NOTICE (cdev,"Failed to acquire Connection\n" ); +kfree (hash_con); + +return rc; + } + +/* Added the connection to hash table */ + *handle = hash_con->con->icid; + *fw_cid = hash_con->con->fw_cid; +hash_add (cdev->connections, &hash_con->node, *handle); + +if (p_doorbell) + *p_doorbell =qed_nvmetcp_get_db_addr (QED_AFFIN_HWFN (cdev), + *handle); + +return 0 ; +} + +static int qed_nvmetcp_release_conn (struct qed_dev *cdev,u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +hlist_del (&hash_con->node); +qed_nvmetcp_release_connection (QED_AFFIN_HWFN (cdev), hash_con->con); +kfree (hash_con); + +return 0 ; +} + +static int qed_nvmetcp_offload_conn (struct qed_dev *cdev,u32 handle, +struct qed_nvmetcp_params_offload *conn_info) +{ +struct qed_hash_nvmetcp_con *hash_con; +struct qed_nvmetcp_conn *con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +/* Update the connection with information from the params */ + con = hash_con->con; + +/* FW initializations */ + con->layer_code =NVMETCP_SLOW_PATH_LAYER_CODE ; + con->sq_pbl_addr = conn_info->sq_pbl_addr; + con->nvmetcp_cccid_max_range = conn_info->nvmetcp_cccid_max_range; + con->nvmetcp_cccid_itid_table_addr = conn_info->nvmetcp_cccid_itid_table_addr; + con->default_cq = conn_info->default_cq; + +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_TARGET_MODE ,0 ); +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_NVMETCP_MODE ,1 ); +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B ,1 ); + +/* Networking and TCP stack initializations */ +ether_addr_copy (con->local_mac, conn_info->src.mac); +ether_addr_copy (con->remote_mac, conn_info->dst.mac); +memcpy (con->local_ip, conn_info->src.ip,sizeof (con->local_ip)); +memcpy (con->remote_ip, conn_info->dst.ip,sizeof (con->remote_ip)); + con->local_port = conn_info->src.port; + con->remote_port = conn_info->dst.port; + con->vlan_id = conn_info->vlan_id; + +if (conn_info->timestamp_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_TS_EN ,1 ); + +if (conn_info->delayed_ack_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_DA_EN ,1 ); + +if (conn_info->tcp_keep_alive_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_KA_EN ,1 ); + +if (conn_info->ecn_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_ECN_EN ,1 ); + + con->ip_version = conn_info->ip_version; + con->flow_label =QED_TCP_FLOW_LABEL ; + con->ka_max_probe_cnt = conn_info->ka_max_probe_cnt; + con->ka_timeout = conn_info->ka_timeout; + con->ka_interval = conn_info->ka_interval; + con->max_rt_time = conn_info->max_rt_time; + con->ttl = conn_info->ttl; + con->tos_or_tc = conn_info->tos_or_tc; + con->mss = conn_info->mss; + con->cwnd = conn_info->cwnd; + con->rcv_wnd_scale = conn_info->rcv_wnd_scale; + con->connect_mode =0 ;/* TCP_CONNECT_ACTIVE */ + +return qed_sp_nvmetcp_conn_offload (QED_AFFIN_HWFN (cdev), con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_update_conn (struct qed_dev *cdev, +u32 handle, +struct qed_nvmetcp_params_update *conn_info) +{ +struct qed_hash_nvmetcp_con *hash_con; +struct qed_nvmetcp_conn *con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +/* Update the connection with information from the params */ + con = hash_con->con; + +SET_FIELD (con->update_flag, +ISCSI_CONN_UPDATE_RAMROD_PARAMS_INITIAL_R2T ,0 ); +SET_FIELD (con->update_flag, +ISCSI_CONN_UPDATE_RAMROD_PARAMS_IMMEDIATE_DATA ,1 ); + +if (conn_info->hdr_digest_en) +SET_FIELD (con->update_flag,ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN ,1 ); + +if (conn_info->data_digest_en) +SET_FIELD (con->update_flag,ISCSI_CONN_UPDATE_RAMROD_PARAMS_DD_EN ,1 ); + +/* Placeholder - initialize pfv, cpda, hpda */ + + con->max_seq_size = conn_info->max_io_size; + con->max_recv_pdu_length = conn_info->max_recv_pdu_length; + con->max_send_pdu_length = conn_info->max_send_pdu_length; + con->first_seq_length = conn_info->max_io_size; + +return qed_sp_nvmetcp_conn_update (QED_AFFIN_HWFN (cdev), con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_clear_conn_sq (struct qed_dev *cdev,u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +return qed_sp_nvmetcp_conn_clear_sq (QED_AFFIN_HWFN (cdev), hash_con->con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_destroy_conn (struct qed_dev *cdev, +u32 handle,u8 abrt_conn) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + + hash_con->con->abortive_dsconnect = abrt_conn; + +return qed_sp_nvmetcp_conn_terminate (QED_AFFIN_HWFN (cdev), hash_con->con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} +static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .common = &qed_common_ops_pass, .ll2 = &qed_ll2_ops_pass,@@ -266,8 +838,12 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .register_ops = &qed_register_nvmetcp_ops, .start = &qed_nvmetcp_start, .stop = &qed_nvmetcp_stop, - -/* Placeholder - Connection level ops */ + .acquire_conn = &qed_nvmetcp_acquire_conn, + .release_conn = &qed_nvmetcp_release_conn, + .offload_conn = &qed_nvmetcp_offload_conn, + .update_conn = &qed_nvmetcp_update_conn, + .destroy_conn = &qed_nvmetcp_destroy_conn, + .clear_sq = &qed_nvmetcp_clear_conn_sq, };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void )drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h +63
-0@@ -19,6 +19,7 @@#define QED_NVMETCP_FW_CQ_SIZE (4 * 1024)/* tcp parameters */ +#define QED_TCP_FLOW_LABEL 0#define QED_TCP_TWO_MSL_TIMER 4000#define QED_TCP_HALF_WAY_CLOSE_TIMEOUT 10#define QED_TCP_MAX_FIN_RT 2@@ -32,6 +33,68 @@ struct qed_nvmetcp_info {nvmetcp_event_cb_t event_cb; }; +struct qed_hash_nvmetcp_con { +struct hlist_node node; +struct qed_nvmetcp_conn *con; +}; + +struct qed_nvmetcp_conn { +struct list_head list_entry; +bool free_on_delete; + +u16 conn_id; +u32 icid; +u32 fw_cid; + +u8 layer_code; +u8 offl_flags; +u8 connect_mode; + +dma_addr_t sq_pbl_addr; +struct qed_chain r2tq; +struct qed_chain xhq; +struct qed_chain uhq; + +u8 local_mac[6 ]; +u8 remote_mac[6 ]; +u8 ip_version; +u8 ka_max_probe_cnt; + +u16 vlan_id; +u16 tcp_flags; +u32 remote_ip[4 ]; +u32 local_ip[4 ]; + +u32 flow_label; +u32 ka_timeout; +u32 ka_interval; +u32 max_rt_time; + +u8 ttl; +u8 tos_or_tc; +u16 remote_port; +u16 local_port; +u16 mss; +u8 rcv_wnd_scale; +u32 rcv_wnd; +u32 cwnd; + +u8 update_flag; +u8 default_cq; +u8 abortive_dsconnect; + +u32 max_seq_size; +u32 max_recv_pdu_length; +u32 max_send_pdu_length; +u32 first_seq_length; + +u16 physical_q0; +u16 physical_q1; + +u16 nvmetcp_cccid_max_range; +dma_addr_t nvmetcp_cccid_itid_table_addr; +}; +#if IS_ENABLED (CONFIG_QED_NVMETCP )int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn);void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn);drivers/net/ethernet/qlogic/qed/qed_sp.h +3
-0@@ -101,6 +101,9 @@ union ramrod_data {struct iscsi_spe_conn_termination iscsi_conn_terminate;struct nvmetcp_init_ramrod_params nvmetcp_init; +struct nvmetcp_spe_conn_offload nvmetcp_conn_offload; +struct nvmetcp_conn_update_ramrod_params nvmetcp_conn_update; +struct nvmetcp_spe_conn_termination nvmetcp_conn_terminate;struct vf_start_ramrod_data vf_start;struct vf_stop_ramrod_data vf_stop;include/linux/qed/nvmetcp_common.h +143
-0@@ -6,6 +6,8 @@#include "tcp_common.h" +#define NVMETCP_SLOW_PATH_LAYER_CODE (6) +/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {__le16 half_way_close_timeout;@@ -43,6 +45,10 @@ enum nvmetcp_ramrod_cmd_id {NVMETCP_RAMROD_CMD_ID_UNUSED =0 ,NVMETCP_RAMROD_CMD_ID_INIT_FUNC =1 ,NVMETCP_RAMROD_CMD_ID_DESTROY_FUNC =2 , +NVMETCP_RAMROD_CMD_ID_OFFLOAD_CONN =3 , +NVMETCP_RAMROD_CMD_ID_UPDATE_CONN =4 , +NVMETCP_RAMROD_CMD_ID_TERMINATION_CONN =5 , +NVMETCP_RAMROD_CMD_ID_CLEAR_SQ =6 , MAX_NVMETCP_RAMROD_CMD_ID };@@ -51,4 +57,141 @@ struct nvmetcp_glbl_queue_entry {struct regpair reserved; }; +/* NVMeTCP conn level EQEs */ +enum nvmetcp_eqe_opcode { +NVMETCP_EVENT_TYPE_INIT_FUNC =0 ,/* Response after init Ramrod */ +NVMETCP_EVENT_TYPE_DESTROY_FUNC ,/* Response after destroy Ramrod */ +NVMETCP_EVENT_TYPE_OFFLOAD_CONN ,/* Response after option 2 offload Ramrod */ +NVMETCP_EVENT_TYPE_UPDATE_CONN ,/* Response after update Ramrod */ +NVMETCP_EVENT_TYPE_CLEAR_SQ ,/* Response after clear sq Ramrod */ +NVMETCP_EVENT_TYPE_TERMINATE_CONN ,/* Response after termination Ramrod */ +NVMETCP_EVENT_TYPE_RESERVED0 , +NVMETCP_EVENT_TYPE_RESERVED1 , +NVMETCP_EVENT_TYPE_ASYN_CONNECT_COMPLETE ,/* Connect completed (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_TERMINATE_DONE ,/* Termination completed (A-syn EQE) */ +NVMETCP_EVENT_TYPE_START_OF_ERROR_TYPES =10 ,/* Separate EQs from err EQs */ +NVMETCP_EVENT_TYPE_ASYN_ABORT_RCVD ,/* TCP RST packet receive (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_CLOSE_RCVD ,/* TCP FIN packet receive (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_SYN_RCVD ,/* TCP SYN+ACK packet receive (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_MAX_RT_TIME ,/* TCP max retransmit time (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_MAX_RT_CNT ,/* TCP max retransmit count (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_MAX_KA_PROBES_CNT ,/* TCP ka probes count (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_FIN_WAIT2 ,/* TCP fin wait 2 (A-syn EQE) */ +NVMETCP_EVENT_TYPE_NVMETCP_CONN_ERROR ,/* NVMeTCP error response (A-syn EQE) */ +NVMETCP_EVENT_TYPE_TCP_CONN_ERROR ,/* NVMeTCP error - tcp error (A-syn EQE) */ +MAX_NVMETCP_EQE_OPCODE +}; + +struct nvmetcp_conn_offload_section { +struct regpair cccid_itid_table_addr;/* CCCID to iTID table address */ +__le16 cccid_max_range;/* CCCID max value - used for validation */ +__le16 reserved[3 ]; +}; + +/* NVMe TCP connection offload params passed by driver to FW in NVMeTCP offload ramrod */ +struct nvmetcp_conn_offload_params { +struct regpair sq_pbl_addr; +struct regpair r2tq_pbl_addr; +struct regpair xhq_pbl_addr; +struct regpair uhq_pbl_addr; +__le16 physical_q0; +__le16 physical_q1; +u8 flags; +#define NVMETCP_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_SHIFT 0 +#define NVMETCP_CONN_OFFLOAD_PARAMS_TARGET_MODE_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_TARGET_MODE_SHIFT 1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_SHIFT 2 +#define NVMETCP_CONN_OFFLOAD_PARAMS_NVMETCP_MODE_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_NVMETCP_MODE_SHIFT 3 +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESERVED1_MASK 0xF +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESERVED1_SHIFT 4 +u8 default_cq; +__le16 reserved0; +__le32 reserved1; +__le32 initial_ack; + +struct nvmetcp_conn_offload_section nvmetcp;/* NVMe/TCP section */ +}; + +/* NVMe TCP and TCP connection offload params passed by driver to FW in NVMeTCP offload ramrod. */ +struct nvmetcp_spe_conn_offload { +__le16 reserved; +__le16 conn_id; +__le32 fw_cid; +struct nvmetcp_conn_offload_params nvmetcp; +struct tcp_offload_params_opt2 tcp; +}; + +/* NVMeTCP connection update params passed by driver to FW in NVMETCP update ramrod. */ +struct nvmetcp_conn_update_ramrod_params { +__le16 reserved0; +__le16 conn_id; +__le32 reserved1; +u8 flags; +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_HD_EN_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_HD_EN_SHIFT 0 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_DD_EN_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_DD_EN_SHIFT 1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED0_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED0_SHIFT 2 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED1_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED1_DATA_SHIFT 3 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED2_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED2_SHIFT 4 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED3_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED3_SHIFT 5 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED4_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED4_SHIFT 6 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED5_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED5_SHIFT 7 +u8 reserved3[3 ]; +__le32 max_seq_size; +__le32 max_send_pdu_length; +__le32 max_recv_pdu_length; +__le32 first_seq_length; +__le32 reserved4[5 ]; +}; + +/* NVMeTCP connection termination request */ +struct nvmetcp_spe_conn_termination { +__le16 reserved0; +__le16 conn_id; +__le32 reserved1; +u8 abortive; +u8 reserved2[7 ]; +struct regpair reserved3; +struct regpair reserved4; +}; + +struct nvmetcp_dif_flags { +u8 flags; +}; + +enum nvmetcp_wqe_type { +NVMETCP_WQE_TYPE_NORMAL , +NVMETCP_WQE_TYPE_TASK_CLEANUP , +NVMETCP_WQE_TYPE_MIDDLE_PATH , +NVMETCP_WQE_TYPE_IC , +MAX_NVMETCP_WQE_TYPE +}; + +struct nvmetcp_wqe { +__le16 task_id; +u8 flags; +#define NVMETCP_WQE_WQE_TYPE_MASK 0x7/* [use nvmetcp_wqe_type] */ +#define NVMETCP_WQE_WQE_TYPE_SHIFT 0 +#define NVMETCP_WQE_NUM_SGES_MASK 0xF +#define NVMETCP_WQE_NUM_SGES_SHIFT 3 +#define NVMETCP_WQE_RESPONSE_MASK 0x1 +#define NVMETCP_WQE_RESPONSE_SHIFT 7 +struct nvmetcp_dif_flags prot_flags; +__le32 contlen_cdbsize; +#define NVMETCP_WQE_CONT_LEN_MASK 0xFFFFFF +#define NVMETCP_WQE_CONT_LEN_SHIFT 0 +#define NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD_MASK 0xFF +#define NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD_SHIFT 24 +}; +#endif /* __NVMETCP_COMMON__ */ include/linux/qed/qed_nvmetcp_if.h +87
-0@@ -25,6 +25,50 @@ struct qed_nvmetcp_tid {u8 *blocks[MAX_TID_BLOCKS_NVMETCP ]; }; +struct qed_nvmetcp_id_params { +u8 mac[ETH_ALEN ]; +u32 ip[4 ]; +u16 port; +}; + +struct qed_nvmetcp_params_offload { +/* FW initializations */ +dma_addr_t sq_pbl_addr; +dma_addr_t nvmetcp_cccid_itid_table_addr; +u16 nvmetcp_cccid_max_range; +u8 default_cq; + +/* Networking and TCP stack initializations */ +struct qed_nvmetcp_id_params src; +struct qed_nvmetcp_id_params dst; +u32 ka_timeout; +u32 ka_interval; +u32 max_rt_time; +u32 cwnd; +u16 mss; +u16 vlan_id; +bool timestamp_en; +bool delayed_ack_en; +bool tcp_keep_alive_en; +bool ecn_en; +u8 ip_version; +u8 ka_max_probe_cnt; +u8 ttl; +u8 tos_or_tc; +u8 rcv_wnd_scale; +}; + +struct qed_nvmetcp_params_update { +u32 max_io_size; +u32 max_recv_pdu_length; +u32 max_send_pdu_length; + +/* Placeholder: pfv, cpda, hpda */ + +bool hdr_digest_en; +bool data_digest_en; +}; +struct qed_nvmetcp_cb_ops {struct qed_common_cb_ops common; };@@ -48,6 +92,38 @@ struct qed_nvmetcp_cb_ops {* @stop: nvmetcp in FW * @param cdev * return 0 on success, otherwise error value. +* @acquire_conn: acquire a new nvmetcp connection +* @param cdev +* @param handle - qed will fill handle that should be +* used henceforth as identifier of the +* connection. +* @param p_doorbell - qed will fill the address of the +* doorbell. +* @return 0 on sucesss, otherwise error value. +* @release_conn: release a previously acquired nvmetcp connection +* @param cdev +* @param handle - the connection handle. +* @return 0 on success, otherwise error value. +* @offload_conn: configures an offloaded connection +* @param cdev +* @param handle - the connection handle. +* @param conn_info - the configuration to use for the +* offload. +* @return 0 on success, otherwise error value. +* @update_conn: updates an offloaded connection +* @param cdev +* @param handle - the connection handle. +* @param conn_info - the configuration to use for the +* offload. +* @return 0 on success, otherwise error value. +* @destroy_conn: stops an offloaded connection +* @param cdev +* @param handle - the connection handle. +* @return 0 on success, otherwise error value. +* @clear_sq: clear all task in sq +* @param cdev +* @param handle - the connection handle. +* @return 0 on success, otherwise error value. */ struct qed_nvmetcp_ops {const struct qed_common_ops *common;@@ -65,6 +141,24 @@ struct qed_nvmetcp_ops { void *event_context, nvmetcp_event_cb_t async_event_cb);int (*stop)(struct qed_dev *cdev); + +int (*acquire_conn)(struct qed_dev *cdev, +u32 *handle, +u32 *fw_cid,void __iomem **p_doorbell); + +int (*release_conn)(struct qed_dev *cdev,u32 handle); + +int (*offload_conn)(struct qed_dev *cdev, +u32 handle, +struct qed_nvmetcp_params_offload *conn_info); +
include/linux/qed/qed_nvmetcp_if.h struct qed_nvmetcp_ops { · line 164
Quoted 10 lines
include/linux/qed/qed_nvmetcp_if.h +7
-0+int (*update_conn)(struct qed_dev *cdev, +u32 handle, +struct qed_nvmetcp_params_update *conn_info); + +int (*destroy_conn)(struct qed_dev *cdev,u32 handle,u8 abrt_conn); + +int (*clear_sq)(struct qed_dev *cdev,u32 handle); };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void );
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 02/27] qed: Add NVMeTCP Offload Connection Level FW and HW HSI
Quoted 133 lines · Hannes Reinecke
Quoted 132 lines · Shai Malin
This patch introduces the NVMeTCP HSI and HSI functionality in order to initialize and interact with the HW device as part of the connection level HSI.
This includes:
- Connection offload: offload a TCP connection to the FW.
- Connection update: update the ICReq-ICResp params
- Connection clear SQ: outstanding IOs FW flush.
- Connection termination: terminate the TCP connection and flush the FW.Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 580 +++++++++++++++++- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h | 63 ++ drivers/net/ethernet/qlogic/qed/qed_sp.h | 3 + include/linux/qed/nvmetcp_common.h | 143 +++++ include/linux/qed/qed_nvmetcp_if.h | 94 +++ 5 files changed, 881 insertions(+), 2 deletions(-)drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +100
-0@@ -259,6 +259,578 @@ static int qed_nvmetcp_start(struct qed_dev *cdev,return 0 ; } +static struct qed_hash_nvmetcp_con *qed_nvmetcp_get_hash (struct qed_dev *cdev, +u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con =NULL ; + +if (!(cdev->flags &QED_FLAG_STORAGE_STARTED )) +return NULL ; + +hash_for_each_possible (cdev->connections, hash_con, node, handle) { +if (hash_con->con->icid == handle) +break ; + } + +if (!hash_con || hash_con->con->icid != handle) +return NULL ; + +return hash_con; +} + +static int qed_sp_nvmetcp_conn_offload (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_spe_conn_offload *p_ramrod =NULL ; +struct tcp_offload_params_opt2 *p_tcp2 =NULL ; +struct qed_sp_init_data init_data = {0 }; +struct qed_spq_entry *p_ent =NULL ; +dma_addr_t r2tq_pbl_addr; +dma_addr_t xhq_pbl_addr; +dma_addr_t uhq_pbl_addr; +u16 physical_q; +int rc =0 ; +u32 dval; +u8 i; + +/* Get SPQ entry */ + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_OFFLOAD_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_offload; + +/* Transmission PQ is the first of the PF */ + physical_q =qed_get_cm_pq_idx (p_hwfn,PQ_FLAGS_OFLD ); + p_conn->physical_q0 =cpu_to_le16 (physical_q); + p_ramrod->nvmetcp.physical_q0 =cpu_to_le16 (physical_q); + +/* nvmetcp Pure-ACK PQ */ + physical_q =qed_get_cm_pq_idx (p_hwfn,PQ_FLAGS_ACK ); + p_conn->physical_q1 =cpu_to_le16 (physical_q); + p_ramrod->nvmetcp.physical_q1 =cpu_to_le16 (physical_q); + + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + +DMA_REGPAIR_LE (p_ramrod->nvmetcp.sq_pbl_addr, p_conn->sq_pbl_addr); + + r2tq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->r2tq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.r2tq_pbl_addr, r2tq_pbl_addr); + + xhq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->xhq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.xhq_pbl_addr, xhq_pbl_addr); + + uhq_pbl_addr =qed_chain_get_pbl_phys (&p_conn->uhq); +DMA_REGPAIR_LE (p_ramrod->nvmetcp.uhq_pbl_addr, uhq_pbl_addr); + + p_ramrod->nvmetcp.flags = p_conn->offl_flags; + p_ramrod->nvmetcp.default_cq = p_conn->default_cq; + p_ramrod->nvmetcp.initial_ack =0 ; + +DMA_REGPAIR_LE (p_ramrod->nvmetcp.nvmetcp.cccid_itid_table_addr, + p_conn->nvmetcp_cccid_itid_table_addr); + p_ramrod->nvmetcp.nvmetcp.cccid_max_range = +cpu_to_le16 (p_conn->nvmetcp_cccid_max_range); + + p_tcp2 = &p_ramrod->tcp; + +qed_set_fw_mac_addr (&p_tcp2->remote_mac_addr_hi, + &p_tcp2->remote_mac_addr_mid, + &p_tcp2->remote_mac_addr_lo, p_conn->remote_mac); +qed_set_fw_mac_addr (&p_tcp2->local_mac_addr_hi, + &p_tcp2->local_mac_addr_mid, + &p_tcp2->local_mac_addr_lo, p_conn->local_mac); + + p_tcp2->vlan_id =cpu_to_le16 (p_conn->vlan_id); + p_tcp2->flags =cpu_to_le16 (p_conn->tcp_flags); + + p_tcp2->ip_version = p_conn->ip_version; +for (i =0 ; i <4 ; i++) { + dval = p_conn->remote_ip[i]; + p_tcp2->remote_ip[i] =cpu_to_le32 (dval); + dval = p_conn->local_ip[i]; + p_tcp2->local_ip[i] =cpu_to_le32 (dval);
Quoted 8 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c static int qed_nvmetcp_start(struct qed_dev *cdev, · line 363
Quoted 2 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +2
-0+ } +What is this?
Some convoluted way of assigning the IP address in little endian? Pointless if it's IPv4, as then each bit is just one byte. And if it's for IPv6, what do you do for IPv4?
And isn't there a helper for it?
Endianity here is only for BE machines.
I haven't found a relevant helper function,
Will re-write to have cleaner implementation separately for ipv4 and ipv6.
Quoted 878 lines
Quoted 860 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +476
-2+ p_tcp2->flow_label =cpu_to_le32 (p_conn->flow_label); + p_tcp2->ttl = p_conn->ttl; + p_tcp2->tos_or_tc = p_conn->tos_or_tc; + p_tcp2->remote_port =cpu_to_le16 (p_conn->remote_port); + p_tcp2->local_port =cpu_to_le16 (p_conn->local_port); + p_tcp2->mss =cpu_to_le16 (p_conn->mss); + p_tcp2->rcv_wnd_scale = p_conn->rcv_wnd_scale; + p_tcp2->connect_mode = p_conn->connect_mode; + p_tcp2->cwnd =cpu_to_le32 (p_conn->cwnd); + p_tcp2->ka_max_probe_cnt = p_conn->ka_max_probe_cnt; + p_tcp2->ka_timeout =cpu_to_le32 (p_conn->ka_timeout); + p_tcp2->max_rt_time =cpu_to_le32 (p_conn->max_rt_time); + p_tcp2->ka_interval =cpu_to_le32 (p_conn->ka_interval); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_update (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_conn_update_ramrod_params *p_ramrod =NULL ; +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; +u32 dval; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_UPDATE_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_update; + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + p_ramrod->flags = p_conn->update_flag; + p_ramrod->max_seq_size =cpu_to_le32 (p_conn->max_seq_size); + dval = p_conn->max_recv_pdu_length; + p_ramrod->max_recv_pdu_length =cpu_to_le32 (dval); + dval = p_conn->max_send_pdu_length; + p_ramrod->max_send_pdu_length =cpu_to_le32 (dval); + dval = p_conn->first_seq_length; + p_ramrod->first_seq_length =cpu_to_le32 (dval); + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_terminate (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct nvmetcp_spe_conn_termination *p_ramrod =NULL ; +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_TERMINATION_CONN , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + + p_ramrod = &p_ent->ramrod.nvmetcp_conn_terminate; + p_ramrod->conn_id =cpu_to_le16 (p_conn->conn_id); + p_ramrod->abortive = p_conn->abortive_dsconnect; + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static int qed_sp_nvmetcp_conn_clear_sq (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn, +enum spq_mode comp_mode, +struct qed_spq_comp_cb *p_comp_addr) +{ +struct qed_spq_entry *p_ent =NULL ; +struct qed_sp_init_data init_data; +int rc = -EINVAL ; + +/* Get SPQ entry */ +memset (&init_data,0 ,sizeof (init_data)); + init_data.cid = p_conn->icid; + init_data.opaque_fid = p_hwfn->hw_info.opaque_fid; + init_data.comp_mode = comp_mode; + init_data.p_comp_data = p_comp_addr; + + rc =qed_sp_init_request (p_hwfn, &p_ent, +NVMETCP_RAMROD_CMD_ID_CLEAR_SQ , +PROTOCOLID_NVMETCP , &init_data); +if (rc) +return rc; + +return qed_spq_post (p_hwfn, p_ent,NULL ); +} + +static void __iomem *qed_nvmetcp_get_db_addr (struct qed_hwfn *p_hwfn,u32 cid) +{ +return (u8 __iomem *)p_hwfn->doorbells + +qed_db_addr (cid,DQ_DEMS_LEGACY ); +} + +static int qed_nvmetcp_allocate_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn **p_out_conn) +{ +struct qed_chain_init_params params = { + .mode =QED_CHAIN_MODE_PBL , + .intended_use =QED_CHAIN_USE_TO_CONSUME_PRODUCE , + .cnt_type =QED_CHAIN_CNT_TYPE_U16 , + }; +struct qed_nvmetcp_pf_params *p_params =NULL ; +struct qed_nvmetcp_conn *p_conn =NULL ; +int rc =0 ; + +/* Try finding a free connection that can be used */ +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +if (!list_empty (&p_hwfn->p_nvmetcp_info->free_list)) + p_conn =list_first_entry (&p_hwfn->p_nvmetcp_info->free_list, + struct qed_nvmetcp_conn, list_entry); +if (p_conn) { +list_del (&p_conn->list_entry); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + *p_out_conn = p_conn; + +return 0 ; + } +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +/* Need to allocate a new connection */ + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + + p_conn =kzalloc (sizeof (*p_conn),GFP_KERNEL ); +if (!p_conn) +return -ENOMEM ; + + params.num_elems = p_params->num_r2tq_pages_in_ring * +QED_CHAIN_PAGE_SIZE /sizeof (struct nvmetcp_wqe ); + params.elem_size =sizeof (struct nvmetcp_wqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->r2tq, ¶ms); +if (rc) + goto nomem_r2tq; + + params.num_elems = p_params->num_uhq_pages_in_ring * +QED_CHAIN_PAGE_SIZE /sizeof (struct iscsi_uhqe ); + params.elem_size =sizeof (struct iscsi_uhqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->uhq, ¶ms); +if (rc) + goto nomem_uhq; + + params.elem_size =sizeof (struct iscsi_xhqe ); + + rc =qed_chain_alloc (p_hwfn->cdev, &p_conn->xhq, ¶ms); +if (rc) + goto nomem; + + p_conn->free_on_delete = true; + *p_out_conn = p_conn; + +return 0 ; + +nomem: +qed_chain_free (p_hwfn->cdev, &p_conn->uhq); +nomem_uhq: +qed_chain_free (p_hwfn->cdev, &p_conn->r2tq); +nomem_r2tq: +kfree (p_conn); + +return -ENOMEM ; +} + +static int qed_nvmetcp_acquire_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn **p_out_conn) +{ +struct qed_nvmetcp_conn *p_conn =NULL ; +int rc =0 ; +u32 icid; + +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); + rc =qed_cxt_acquire_cid (p_hwfn,PROTOCOLID_NVMETCP , &icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +if (rc) +return rc; + + rc =qed_nvmetcp_allocate_connection (p_hwfn, &p_conn); +if (rc) { +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +qed_cxt_release_cid (p_hwfn, icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); + +return rc; + } + + p_conn->icid = icid; + p_conn->conn_id = (u16 )icid; + p_conn->fw_cid = (p_hwfn->hw_info.opaque_fid <<16 ) | icid; + *p_out_conn = p_conn; + +return rc; +} + +static void qed_nvmetcp_release_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn) +{ +spin_lock_bh (&p_hwfn->p_nvmetcp_info->lock); +list_add_tail (&p_conn->list_entry, &p_hwfn->p_nvmetcp_info->free_list); +qed_cxt_release_cid (p_hwfn, p_conn->icid); +spin_unlock_bh (&p_hwfn->p_nvmetcp_info->lock); +} + +static void qed_nvmetcp_free_connection (struct qed_hwfn *p_hwfn, +struct qed_nvmetcp_conn *p_conn) +{ +qed_chain_free (p_hwfn->cdev, &p_conn->xhq); +qed_chain_free (p_hwfn->cdev, &p_conn->uhq); +qed_chain_free (p_hwfn->cdev, &p_conn->r2tq); + +kfree (p_conn); +} + +int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn) +{ +struct qed_nvmetcp_info *p_nvmetcp_info; + + p_nvmetcp_info =kzalloc (sizeof (*p_nvmetcp_info),GFP_KERNEL ); +if (!p_nvmetcp_info) +return -ENOMEM ; + +INIT_LIST_HEAD (&p_nvmetcp_info->free_list); + + p_hwfn->p_nvmetcp_info = p_nvmetcp_info; + +return 0 ; +} + +void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn) +{ +spin_lock_init (&p_hwfn->p_nvmetcp_info->lock); +} + +void qed_nvmetcp_free (struct qed_hwfn *p_hwfn) +{ +struct qed_nvmetcp_conn *p_conn =NULL ; + +if (!p_hwfn->p_nvmetcp_info) +return ; + +while (!list_empty (&p_hwfn->p_nvmetcp_info->free_list)) { + p_conn =list_first_entry (&p_hwfn->p_nvmetcp_info->free_list, + struct qed_nvmetcp_conn, list_entry); +if (p_conn) { +list_del (&p_conn->list_entry); +qed_nvmetcp_free_connection (p_hwfn, p_conn); + } + } + +kfree (p_hwfn->p_nvmetcp_info); + p_hwfn->p_nvmetcp_info =NULL ; +} + +static int qed_nvmetcp_acquire_conn (struct qed_dev *cdev, +u32 *handle, +u32 *fw_cid,void __iomem **p_doorbell) +{ +struct qed_hash_nvmetcp_con *hash_con; +int rc; + +/* Allocate a hashed connection */ + hash_con =kzalloc (sizeof (*hash_con),GFP_ATOMIC ); +if (!hash_con) +return -ENOMEM ; + +/* Acquire the connection */ + rc =qed_nvmetcp_acquire_connection (QED_AFFIN_HWFN (cdev), + &hash_con->con); +if (rc) { +DP_NOTICE (cdev,"Failed to acquire Connection\n" ); +kfree (hash_con); + +return rc; + } + +/* Added the connection to hash table */ + *handle = hash_con->con->icid; + *fw_cid = hash_con->con->fw_cid; +hash_add (cdev->connections, &hash_con->node, *handle); + +if (p_doorbell) + *p_doorbell =qed_nvmetcp_get_db_addr (QED_AFFIN_HWFN (cdev), + *handle); + +return 0 ; +} + +static int qed_nvmetcp_release_conn (struct qed_dev *cdev,u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +hlist_del (&hash_con->node); +qed_nvmetcp_release_connection (QED_AFFIN_HWFN (cdev), hash_con->con); +kfree (hash_con); + +return 0 ; +} + +static int qed_nvmetcp_offload_conn (struct qed_dev *cdev,u32 handle, +struct qed_nvmetcp_params_offload *conn_info) +{ +struct qed_hash_nvmetcp_con *hash_con; +struct qed_nvmetcp_conn *con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +/* Update the connection with information from the params */ + con = hash_con->con; + +/* FW initializations */ + con->layer_code =NVMETCP_SLOW_PATH_LAYER_CODE ; + con->sq_pbl_addr = conn_info->sq_pbl_addr; + con->nvmetcp_cccid_max_range = conn_info->nvmetcp_cccid_max_range; + con->nvmetcp_cccid_itid_table_addr = conn_info->nvmetcp_cccid_itid_table_addr; + con->default_cq = conn_info->default_cq; + +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_TARGET_MODE ,0 ); +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_NVMETCP_MODE ,1 ); +SET_FIELD (con->offl_flags,NVMETCP_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B ,1 ); + +/* Networking and TCP stack initializations */ +ether_addr_copy (con->local_mac, conn_info->src.mac); +ether_addr_copy (con->remote_mac, conn_info->dst.mac); +memcpy (con->local_ip, conn_info->src.ip,sizeof (con->local_ip)); +memcpy (con->remote_ip, conn_info->dst.ip,sizeof (con->remote_ip)); + con->local_port = conn_info->src.port; + con->remote_port = conn_info->dst.port; + con->vlan_id = conn_info->vlan_id; + +if (conn_info->timestamp_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_TS_EN ,1 ); + +if (conn_info->delayed_ack_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_DA_EN ,1 ); + +if (conn_info->tcp_keep_alive_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_KA_EN ,1 ); + +if (conn_info->ecn_en) +SET_FIELD (con->tcp_flags,TCP_OFFLOAD_PARAMS_OPT2_ECN_EN ,1 ); + + con->ip_version = conn_info->ip_version; + con->flow_label =QED_TCP_FLOW_LABEL ; + con->ka_max_probe_cnt = conn_info->ka_max_probe_cnt; + con->ka_timeout = conn_info->ka_timeout; + con->ka_interval = conn_info->ka_interval; + con->max_rt_time = conn_info->max_rt_time; + con->ttl = conn_info->ttl; + con->tos_or_tc = conn_info->tos_or_tc; + con->mss = conn_info->mss; + con->cwnd = conn_info->cwnd; + con->rcv_wnd_scale = conn_info->rcv_wnd_scale; + con->connect_mode =0 ;/* TCP_CONNECT_ACTIVE */ + +return qed_sp_nvmetcp_conn_offload (QED_AFFIN_HWFN (cdev), con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_update_conn (struct qed_dev *cdev, +u32 handle, +struct qed_nvmetcp_params_update *conn_info) +{ +struct qed_hash_nvmetcp_con *hash_con; +struct qed_nvmetcp_conn *con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +/* Update the connection with information from the params */ + con = hash_con->con; + +SET_FIELD (con->update_flag, +ISCSI_CONN_UPDATE_RAMROD_PARAMS_INITIAL_R2T ,0 ); +SET_FIELD (con->update_flag, +ISCSI_CONN_UPDATE_RAMROD_PARAMS_IMMEDIATE_DATA ,1 ); + +if (conn_info->hdr_digest_en) +SET_FIELD (con->update_flag,ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN ,1 ); + +if (conn_info->data_digest_en) +SET_FIELD (con->update_flag,ISCSI_CONN_UPDATE_RAMROD_PARAMS_DD_EN ,1 ); + +/* Placeholder - initialize pfv, cpda, hpda */ + + con->max_seq_size = conn_info->max_io_size; + con->max_recv_pdu_length = conn_info->max_recv_pdu_length; + con->max_send_pdu_length = conn_info->max_send_pdu_length; + con->first_seq_length = conn_info->max_io_size; + +return qed_sp_nvmetcp_conn_update (QED_AFFIN_HWFN (cdev), con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_clear_conn_sq (struct qed_dev *cdev,u32 handle) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + +return qed_sp_nvmetcp_conn_clear_sq (QED_AFFIN_HWFN (cdev), hash_con->con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} + +static int qed_nvmetcp_destroy_conn (struct qed_dev *cdev, +u32 handle,u8 abrt_conn) +{ +struct qed_hash_nvmetcp_con *hash_con; + + hash_con =qed_nvmetcp_get_hash (cdev, handle); +if (!hash_con) { +DP_NOTICE (cdev,"Failed to find connection for handle %d\n" , + handle); + +return -EINVAL ; + } + + hash_con->con->abortive_dsconnect = abrt_conn; + +return qed_sp_nvmetcp_conn_terminate (QED_AFFIN_HWFN (cdev), hash_con->con, +QED_SPQ_MODE_EBLOCK ,NULL ); +} +static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .common = &qed_common_ops_pass, .ll2 = &qed_ll2_ops_pass,@@ -266,8 +838,12 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .register_ops = &qed_register_nvmetcp_ops, .start = &qed_nvmetcp_start, .stop = &qed_nvmetcp_stop, - -/* Placeholder - Connection level ops */ + .acquire_conn = &qed_nvmetcp_acquire_conn, + .release_conn = &qed_nvmetcp_release_conn, + .offload_conn = &qed_nvmetcp_offload_conn, + .update_conn = &qed_nvmetcp_update_conn, + .destroy_conn = &qed_nvmetcp_destroy_conn, + .clear_sq = &qed_nvmetcp_clear_conn_sq, };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void )drivers/net/ethernet/qlogic/qed/qed_nvmetcp.h +63
-0@@ -19,6 +19,7 @@#define QED_NVMETCP_FW_CQ_SIZE (4 * 1024)/* tcp parameters */ +#define QED_TCP_FLOW_LABEL 0#define QED_TCP_TWO_MSL_TIMER 4000#define QED_TCP_HALF_WAY_CLOSE_TIMEOUT 10#define QED_TCP_MAX_FIN_RT 2@@ -32,6 +33,68 @@ struct qed_nvmetcp_info {nvmetcp_event_cb_t event_cb; }; +struct qed_hash_nvmetcp_con { +struct hlist_node node; +struct qed_nvmetcp_conn *con; +}; + +struct qed_nvmetcp_conn { +struct list_head list_entry; +bool free_on_delete; + +u16 conn_id; +u32 icid; +u32 fw_cid; + +u8 layer_code; +u8 offl_flags; +u8 connect_mode; + +dma_addr_t sq_pbl_addr; +struct qed_chain r2tq; +struct qed_chain xhq; +struct qed_chain uhq; + +u8 local_mac[6 ]; +u8 remote_mac[6 ]; +u8 ip_version; +u8 ka_max_probe_cnt; + +u16 vlan_id; +u16 tcp_flags; +u32 remote_ip[4 ]; +u32 local_ip[4 ]; + +u32 flow_label; +u32 ka_timeout; +u32 ka_interval; +u32 max_rt_time; + +u8 ttl; +u8 tos_or_tc; +u16 remote_port; +u16 local_port; +u16 mss; +u8 rcv_wnd_scale; +u32 rcv_wnd; +u32 cwnd; + +u8 update_flag; +u8 default_cq; +u8 abortive_dsconnect; + +u32 max_seq_size; +u32 max_recv_pdu_length; +u32 max_send_pdu_length; +u32 first_seq_length; + +u16 physical_q0; +u16 physical_q1; + +u16 nvmetcp_cccid_max_range; +dma_addr_t nvmetcp_cccid_itid_table_addr; +}; +#if IS_ENABLED (CONFIG_QED_NVMETCP )int qed_nvmetcp_alloc (struct qed_hwfn *p_hwfn);void qed_nvmetcp_setup (struct qed_hwfn *p_hwfn);drivers/net/ethernet/qlogic/qed/qed_sp.h +3
-0@@ -101,6 +101,9 @@ union ramrod_data {struct iscsi_spe_conn_termination iscsi_conn_terminate;struct nvmetcp_init_ramrod_params nvmetcp_init; +struct nvmetcp_spe_conn_offload nvmetcp_conn_offload; +struct nvmetcp_conn_update_ramrod_params nvmetcp_conn_update; +struct nvmetcp_spe_conn_termination nvmetcp_conn_terminate;struct vf_start_ramrod_data vf_start;struct vf_stop_ramrod_data vf_stop;include/linux/qed/nvmetcp_common.h +143
-0@@ -6,6 +6,8 @@#include "tcp_common.h" +#define NVMETCP_SLOW_PATH_LAYER_CODE (6) +/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {__le16 half_way_close_timeout;@@ -43,6 +45,10 @@ enum nvmetcp_ramrod_cmd_id {NVMETCP_RAMROD_CMD_ID_UNUSED =0 ,NVMETCP_RAMROD_CMD_ID_INIT_FUNC =1 ,NVMETCP_RAMROD_CMD_ID_DESTROY_FUNC =2 , +NVMETCP_RAMROD_CMD_ID_OFFLOAD_CONN =3 , +NVMETCP_RAMROD_CMD_ID_UPDATE_CONN =4 , +NVMETCP_RAMROD_CMD_ID_TERMINATION_CONN =5 , +NVMETCP_RAMROD_CMD_ID_CLEAR_SQ =6 , MAX_NVMETCP_RAMROD_CMD_ID };@@ -51,4 +57,141 @@ struct nvmetcp_glbl_queue_entry {struct regpair reserved; }; +/* NVMeTCP conn level EQEs */ +enum nvmetcp_eqe_opcode { +NVMETCP_EVENT_TYPE_INIT_FUNC =0 ,/* Response after init Ramrod */ +NVMETCP_EVENT_TYPE_DESTROY_FUNC ,/* Response after destroy Ramrod */ +NVMETCP_EVENT_TYPE_OFFLOAD_CONN ,/* Response after option 2 offload Ramrod */ +NVMETCP_EVENT_TYPE_UPDATE_CONN ,/* Response after update Ramrod */ +NVMETCP_EVENT_TYPE_CLEAR_SQ ,/* Response after clear sq Ramrod */ +NVMETCP_EVENT_TYPE_TERMINATE_CONN ,/* Response after termination Ramrod */ +NVMETCP_EVENT_TYPE_RESERVED0 , +NVMETCP_EVENT_TYPE_RESERVED1 , +NVMETCP_EVENT_TYPE_ASYN_CONNECT_COMPLETE ,/* Connect completed (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_TERMINATE_DONE ,/* Termination completed (A-syn EQE) */ +NVMETCP_EVENT_TYPE_START_OF_ERROR_TYPES =10 ,/* Separate EQs from err EQs */ +NVMETCP_EVENT_TYPE_ASYN_ABORT_RCVD ,/* TCP RST packet receive (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_CLOSE_RCVD ,/* TCP FIN packet receive (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_SYN_RCVD ,/* TCP SYN+ACK packet receive (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_MAX_RT_TIME ,/* TCP max retransmit time (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_MAX_RT_CNT ,/* TCP max retransmit count (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_MAX_KA_PROBES_CNT ,/* TCP ka probes count (A-syn EQE) */ +NVMETCP_EVENT_TYPE_ASYN_FIN_WAIT2 ,/* TCP fin wait 2 (A-syn EQE) */ +NVMETCP_EVENT_TYPE_NVMETCP_CONN_ERROR ,/* NVMeTCP error response (A-syn EQE) */ +NVMETCP_EVENT_TYPE_TCP_CONN_ERROR ,/* NVMeTCP error - tcp error (A-syn EQE) */ +MAX_NVMETCP_EQE_OPCODE +}; + +struct nvmetcp_conn_offload_section { +struct regpair cccid_itid_table_addr;/* CCCID to iTID table address */ +__le16 cccid_max_range;/* CCCID max value - used for validation */ +__le16 reserved[3 ]; +}; + +/* NVMe TCP connection offload params passed by driver to FW in NVMeTCP offload ramrod */ +struct nvmetcp_conn_offload_params { +struct regpair sq_pbl_addr; +struct regpair r2tq_pbl_addr; +struct regpair xhq_pbl_addr; +struct regpair uhq_pbl_addr; +__le16 physical_q0; +__le16 physical_q1; +u8 flags; +#define NVMETCP_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_SHIFT 0 +#define NVMETCP_CONN_OFFLOAD_PARAMS_TARGET_MODE_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_TARGET_MODE_SHIFT 1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_SHIFT 2 +#define NVMETCP_CONN_OFFLOAD_PARAMS_NVMETCP_MODE_MASK 0x1 +#define NVMETCP_CONN_OFFLOAD_PARAMS_NVMETCP_MODE_SHIFT 3 +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESERVED1_MASK 0xF +#define NVMETCP_CONN_OFFLOAD_PARAMS_RESERVED1_SHIFT 4 +u8 default_cq; +__le16 reserved0; +__le32 reserved1; +__le32 initial_ack; + +struct nvmetcp_conn_offload_section nvmetcp;/* NVMe/TCP section */ +}; + +/* NVMe TCP and TCP connection offload params passed by driver to FW in NVMeTCP offload ramrod. */ +struct nvmetcp_spe_conn_offload { +__le16 reserved; +__le16 conn_id; +__le32 fw_cid; +struct nvmetcp_conn_offload_params nvmetcp; +struct tcp_offload_params_opt2 tcp; +}; + +/* NVMeTCP connection update params passed by driver to FW in NVMETCP update ramrod. */ +struct nvmetcp_conn_update_ramrod_params { +__le16 reserved0; +__le16 conn_id; +__le32 reserved1; +u8 flags; +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_HD_EN_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_HD_EN_SHIFT 0 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_DD_EN_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_DD_EN_SHIFT 1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED0_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED0_SHIFT 2 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED1_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED1_DATA_SHIFT 3 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED2_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED2_SHIFT 4 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED3_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED3_SHIFT 5 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED4_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED4_SHIFT 6 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED5_MASK 0x1 +#define NVMETCP_CONN_UPDATE_RAMROD_PARAMS_RESERVED5_SHIFT 7 +u8 reserved3[3 ]; +__le32 max_seq_size; +__le32 max_send_pdu_length; +__le32 max_recv_pdu_length; +__le32 first_seq_length; +__le32 reserved4[5 ]; +}; + +/* NVMeTCP connection termination request */ +struct nvmetcp_spe_conn_termination { +__le16 reserved0; +__le16 conn_id; +__le32 reserved1; +u8 abortive; +u8 reserved2[7 ]; +struct regpair reserved3; +struct regpair reserved4; +}; + +struct nvmetcp_dif_flags { +u8 flags; +}; + +enum nvmetcp_wqe_type { +NVMETCP_WQE_TYPE_NORMAL , +NVMETCP_WQE_TYPE_TASK_CLEANUP , +NVMETCP_WQE_TYPE_MIDDLE_PATH , +NVMETCP_WQE_TYPE_IC , +MAX_NVMETCP_WQE_TYPE +}; + +struct nvmetcp_wqe { +__le16 task_id; +u8 flags; +#define NVMETCP_WQE_WQE_TYPE_MASK 0x7/* [use nvmetcp_wqe_type] */ +#define NVMETCP_WQE_WQE_TYPE_SHIFT 0 +#define NVMETCP_WQE_NUM_SGES_MASK 0xF +#define NVMETCP_WQE_NUM_SGES_SHIFT 3 +#define NVMETCP_WQE_RESPONSE_MASK 0x1 +#define NVMETCP_WQE_RESPONSE_SHIFT 7 +struct nvmetcp_dif_flags prot_flags; +__le32 contlen_cdbsize; +#define NVMETCP_WQE_CONT_LEN_MASK 0xFFFFFF +#define NVMETCP_WQE_CONT_LEN_SHIFT 0 +#define NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD_MASK 0xFF +#define NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD_SHIFT 24 +}; +#endif /* __NVMETCP_COMMON__ */ include/linux/qed/qed_nvmetcp_if.h +87
-0@@ -25,6 +25,50 @@ struct qed_nvmetcp_tid {u8 *blocks[MAX_TID_BLOCKS_NVMETCP ]; }; +struct qed_nvmetcp_id_params { +u8 mac[ETH_ALEN ]; +u32 ip[4 ]; +u16 port; +}; + +struct qed_nvmetcp_params_offload { +/* FW initializations */ +dma_addr_t sq_pbl_addr; +dma_addr_t nvmetcp_cccid_itid_table_addr; +u16 nvmetcp_cccid_max_range; +u8 default_cq; + +/* Networking and TCP stack initializations */ +struct qed_nvmetcp_id_params src; +struct qed_nvmetcp_id_params dst; +u32 ka_timeout; +u32 ka_interval; +u32 max_rt_time; +u32 cwnd; +u16 mss; +u16 vlan_id; +bool timestamp_en; +bool delayed_ack_en; +bool tcp_keep_alive_en; +bool ecn_en; +u8 ip_version; +u8 ka_max_probe_cnt; +u8 ttl; +u8 tos_or_tc; +u8 rcv_wnd_scale; +}; + +struct qed_nvmetcp_params_update { +u32 max_io_size; +u32 max_recv_pdu_length; +u32 max_send_pdu_length; + +/* Placeholder: pfv, cpda, hpda */ + +bool hdr_digest_en; +bool data_digest_en; +}; +struct qed_nvmetcp_cb_ops {struct qed_common_cb_ops common; };@@ -48,6 +92,38 @@ struct qed_nvmetcp_cb_ops {* @stop: nvmetcp in FW * @param cdev * return 0 on success, otherwise error value. +* @acquire_conn: acquire a new nvmetcp connection +* @param cdev +* @param handle - qed will fill handle that should be +* used henceforth as identifier of the +* connection. +* @param p_doorbell - qed will fill the address of the +* doorbell. +* @return 0 on sucesss, otherwise error value. +* @release_conn: release a previously acquired nvmetcp connection +* @param cdev +* @param handle - the connection handle. +* @return 0 on success, otherwise error value. +* @offload_conn: configures an offloaded connection +* @param cdev +* @param handle - the connection handle. +* @param conn_info - the configuration to use for the +* offload. +* @return 0 on success, otherwise error value. +* @update_conn: updates an offloaded connection +* @param cdev +* @param handle - the connection handle. +* @param conn_info - the configuration to use for the +* offload. +* @return 0 on success, otherwise error value. +* @destroy_conn: stops an offloaded connection +* @param cdev +* @param handle - the connection handle. +* @return 0 on success, otherwise error value. +* @clear_sq: clear all task in sq +* @param cdev +* @param handle - the connection handle. +* @return 0 on success, otherwise error value. */ struct qed_nvmetcp_ops {const struct qed_common_ops *common;@@ -65,6 +141,24 @@ struct qed_nvmetcp_ops { void *event_context, nvmetcp_event_cb_t async_event_cb);int (*stop)(struct qed_dev *cdev); + +int (*acquire_conn)(struct qed_dev *cdev, +u32 *handle, +u32 *fw_cid,void __iomem **p_doorbell); + +int (*release_conn)(struct qed_dev *cdev,u32 handle); + +int (*offload_conn)(struct qed_dev *cdev, +u32 handle, +struct qed_nvmetcp_params_offload *conn_info); +include/linux/qed/qed_nvmetcp_if.h struct qed_nvmetcp_ops { · line 164
Quoted 10 lines
include/linux/qed/qed_nvmetcp_if.h +7
-0+int (*update_conn)(struct qed_dev *cdev, +u32 handle, +struct qed_nvmetcp_params_update *conn_info); + +int (*destroy_conn)(struct qed_dev *cdev,u32 handle,u8 abrt_conn); + +int (*clear_sq)(struct qed_dev *cdev,u32 handle); };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void );Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 3/27 qed: Add qed-NVMeTCP personality
In reply to Shai MalinFrom: Omkar Kulkarni <[email protected]>
This patch adds qed NVMeTCP personality in order to support the NVMeTCP qed functionalities and manage the HW device shared resources. The same design is used with Eth (qede), RDMA(qedr), iSCSI (qedi) and FCoE (qedf).
--- drivers/net/ethernet/qlogic/qed/qed.h | 3 ++ drivers/net/ethernet/qlogic/qed/qed_cxt.c | 32 ++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_cxt.h | 1 + drivers/net/ethernet/qlogic/qed/qed_dev.c | 44 ++++++++++++++++--- drivers/net/ethernet/qlogic/qed/qed_hsi.h | 3 +- drivers/net/ethernet/qlogic/qed/qed_ll2.c | 31 ++++++++----- drivers/net/ethernet/qlogic/qed/qed_mcp.c | 3 ++ drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c | 3 +- drivers/net/ethernet/qlogic/qed/qed_ooo.c | 5 ++- .../net/ethernet/qlogic/qed/qed_sp_commands.c | 1 + 10 files changed, 108 insertions(+), 18 deletions(-)
drivers/net/ethernet/qlogic/qed/qed.h +3 -0
@@ -200,6 +200,7 @@ enum qed_pci_personality {QED_PCI_ETH ,QED_PCI_FCOE ,QED_PCI_ISCSI , +QED_PCI_NVMETCP ,QED_PCI_ETH_ROCE ,QED_PCI_ETH_IWARP , QED_PCI_ETH_RDMA,
@@ -285,6 +286,8 @@ struct qed_hw_info { ((dev)->hw_info.personality == QED_PCI_FCOE)#define QED_IS_ISCSI_PERSONALITY (dev) \ ((dev)->hw_info.personality == QED_PCI_ISCSI) +#define QED_IS_NVMETCP_PERSONALITY (dev) \ + ((dev)->hw_info.personality == QED_PCI_NVMETCP)/* Resource Allocation scheme results */ u32 resc_start[QED_MAX_RESC ];
drivers/net/ethernet/qlogic/qed/qed_cxt.c +32 -0
@@ -2106,6 +2106,30 @@ int qed_cxt_set_pf_params(struct qed_hwfn *p_hwfn, u32 rdma_tasks) }break ; } +case QED_PCI_NVMETCP : + { +struct qed_nvmetcp_pf_params *p_params; + + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + +if (p_params->num_cons && p_params->num_tasks) { +qed_cxt_set_proto_cid_count (p_hwfn, +PROTOCOLID_NVMETCP , + p_params->num_cons, +0 ); + +qed_cxt_set_proto_tid_count (p_hwfn, +PROTOCOLID_NVMETCP , +QED_CTX_NVMETCP_TID_SEG , +0 , + p_params->num_tasks, + true); + }else { +DP_INFO (p_hwfn->cdev, +"NvmeTCP personality used without setting params!\n" ); + } +break ; + }default :return -EINVAL ; }
@@ -2132,6 +2156,10 @@ int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, proto =PROTOCOLID_ISCSI ; seg =QED_CXT_ISCSI_TID_SEG ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; + seg =QED_CTX_NVMETCP_TID_SEG ; +break ;default :return -EINVAL ; }
@@ -2458,6 +2486,10 @@ int qed_cxt_get_task_ctx(struct qed_hwfn *p_hwfn, proto =PROTOCOLID_ISCSI ; seg =QED_CXT_ISCSI_TID_SEG ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; + seg =QED_CTX_NVMETCP_TID_SEG ; +break ;default :return -EINVAL ; }
drivers/net/ethernet/qlogic/qed/qed_cxt.h +1 -0
@@ -51,6 +51,7 @@ int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, struct qed_tid_mem *p_info);#define QED_CXT_ISCSI_TID_SEG PROTOCOLID_ISCSI +#define QED_CTX_NVMETCP_TID_SEG PROTOCOLID_NVMETCP#define QED_CXT_ROCE_TID_SEG PROTOCOLID_ROCE#define QED_CXT_FCOE_TID_SEG PROTOCOLID_FCOEenum qed_cxt_elem_type {
drivers/net/ethernet/qlogic/qed/qed_dev.c +39 -5
116 lines not on this page · raw message
drivers/net/ethernet/qlogic/qed/qed_hsi.h +2 -1
@@ -12148,7 +12148,8 @@ struct public_func {#define FUNC_MF_CFG_PROTOCOL_ISCSI 0x00000010#define FUNC_MF_CFG_PROTOCOL_FCOE 0x00000020#define FUNC_MF_CFG_PROTOCOL_ROCE 0x00000030 -#define FUNC_MF_CFG_PROTOCOL_MAX 0x00000030 +#define FUNC_MF_CFG_PROTOCOL_NVMETCP 0x00000040 +#define FUNC_MF_CFG_PROTOCOL_MAX 0x00000040#define FUNC_MF_CFG_MIN_BW_MASK 0x0000ff00#define FUNC_MF_CFG_MIN_BW_SHIFT 8
drivers/net/ethernet/qlogic/qed/qed_ll2.c +21 -10
@@ -960,7 +960,8 @@ static int qed_sp_ll2_rx_queue_start(struct qed_hwfn *p_hwfn,if (test_bit (QED_MF_LL2_NON_UNICAST , &p_hwfn->cdev->mf_bits) && p_ramrod->main_func_queue && conn_type !=QED_LL2_TYPE_ROCE && - conn_type !=QED_LL2_TYPE_IWARP ) { + conn_type !=QED_LL2_TYPE_IWARP && + (!QED_IS_NVMETCP_PERSONALITY (p_hwfn))) { p_ramrod->mf_si_bcast_accept_all =1 ; p_ramrod->mf_si_mcast_accept_all =1 ; }else {
@@ -1049,6 +1050,8 @@ static int qed_sp_ll2_tx_queue_start(struct qed_hwfn *p_hwfn,case QED_LL2_TYPE_OOO :if (p_hwfn->hw_info.personality ==QED_PCI_ISCSI ) p_ramrod->conn_type =PROTOCOLID_ISCSI ; +else if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) + p_ramrod->conn_type =PROTOCOLID_NVMETCP ;else p_ramrod->conn_type =PROTOCOLID_IWARP ;break ;
@@ -1634,7 +1637,8 @@ int qed_ll2_establish_connection(void *cxt, u8 connection_handle)if (rc) goto out; -if (!QED_IS_RDMA_PERSONALITY (p_hwfn)) +if (!QED_IS_RDMA_PERSONALITY (p_hwfn) && + !QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_wr (p_hwfn, p_ptt,PRS_REG_USE_LIGHT_L2 ,1 );qed_ll2_establish_connection_ooo (p_hwfn, p_ll2_conn);
@@ -2376,7 +2380,8 @@ static int qed_ll2_start_ooo(struct qed_hwfn *p_hwfn,static bool qed_ll2_is_storage_eng1 (struct qed_dev *cdev) {return (QED_IS_FCOE_PERSONALITY (QED_LEADING_HWFN (cdev)) || -QED_IS_ISCSI_PERSONALITY (QED_LEADING_HWFN (cdev))) && +QED_IS_ISCSI_PERSONALITY (QED_LEADING_HWFN (cdev)) || +QED_IS_NVMETCP_PERSONALITY (QED_LEADING_HWFN (cdev))) && (QED_AFFIN_HWFN (cdev) !=QED_LEADING_HWFN (cdev)); }
@@ -2402,11 +2407,13 @@ static int qed_ll2_stop(struct qed_dev *cdev)if (cdev->ll2->handle ==QED_LL2_UNUSED_HANDLE )return 0 ; +if (!QED_IS_NVMETCP_PERSONALITY (p_hwfn)) +qed_llh_remove_mac_filter (cdev,0 , cdev->ll2_mac_address);qed_llh_remove_mac_filter (cdev,0 , cdev->ll2_mac_address);eth_zero_addr (cdev->ll2_mac_address); -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_ll2_stop_ooo (p_hwfn);/* In CMT mode, LL2 is always started on engine 0 for a storage PF */
@@ -2442,6 +2449,7 @@ static int __qed_ll2_start(struct qed_hwfn *p_hwfn, conn_type =QED_LL2_TYPE_FCOE ;break ;case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : conn_type =QED_LL2_TYPE_ISCSI ;break ;case QED_PCI_ETH_ROCE :
@@ -2567,7 +2575,7 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params) } } -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) { +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn)) {DP_VERBOSE (cdev,QED_MSG_STORAGE ,"Starting OOO LL2 queue\n" ); rc =qed_ll2_start_ooo (p_hwfn, params);if (rc) {
@@ -2576,10 +2584,13 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params) } } - rc =qed_llh_add_mac_filter (cdev,0 , params->ll2_mac_address); -if (rc) { -DP_NOTICE (cdev,"Failed to add an LLH filter\n" ); - goto err3; +if (!QED_IS_NVMETCP_PERSONALITY (p_hwfn)) { + rc =qed_llh_add_mac_filter (cdev,0 , params->ll2_mac_address); +if (rc) { +DP_NOTICE (cdev,"Failed to add an LLH filter\n" ); + goto err3; + } + }ether_addr_copy (cdev->ll2_mac_address, params->ll2_mac_address);
@@ -2587,7 +2598,7 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params)return 0 ; err3: -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_ll2_stop_ooo (p_hwfn); err2:if (b_is_storage_eng1)
drivers/net/ethernet/qlogic/qed/qed_mcp.c +3 -0
@@ -2446,6 +2446,9 @@ qed_mcp_get_shmem_proto(struct qed_hwfn *p_hwfn,case FUNC_MF_CFG_PROTOCOL_ISCSI : *p_proto =QED_PCI_ISCSI ;break ; +case FUNC_MF_CFG_PROTOCOL_NVMETCP : + *p_proto =QED_PCI_NVMETCP ; +break ;case FUNC_MF_CFG_PROTOCOL_FCOE : *p_proto =QED_PCI_FCOE ;break ;
drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c +2 -1
@@ -1306,7 +1306,8 @@ int qed_mfw_process_tlv_req(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) }if ((tlv_group &QED_MFW_TLV_ISCSI ) && - p_hwfn->hw_info.personality !=QED_PCI_ISCSI ) { + p_hwfn->hw_info.personality !=QED_PCI_ISCSI && + p_hwfn->hw_info.personality !=QED_PCI_NVMETCP ) {DP_VERBOSE (p_hwfn,QED_MSG_SP ,"Skipping iSCSI TLVs for non-iSCSI function\n" ); tlv_group &= ~QED_MFW_TLV_ISCSI ;
drivers/net/ethernet/qlogic/qed/qed_ooo.c +4 -1
@@ -16,7 +16,7 @@#include "qed_ll2.h" #include "qed_ooo.h" #include "qed_cxt.h" - +#include "qed_nvmetcp.h" static struct qed_ooo_archipelago *qed_ooo_seek_archipelago (struct qed_hwfn *p_hwfn, struct qed_ooo_info
@@ -85,6 +85,9 @@ int qed_ooo_alloc(struct qed_hwfn *p_hwfn)case QED_PCI_ISCSI : proto =PROTOCOLID_ISCSI ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; +break ;case QED_PCI_ETH_RDMA :case QED_PCI_ETH_IWARP : proto =PROTOCOLID_IWARP ;
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c +1 -0
@@ -385,6 +385,7 @@ int qed_sp_pf_start(struct qed_hwfn *p_hwfn, p_ramrod->personality =PERSONALITY_FCOE ;break ;case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : p_ramrod->personality =PERSONALITY_ISCSI ;break ;case QED_PCI_ETH_ROCE :
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 03/27] qed: Add qed-NVMeTCP personality
Quoted 39 lines · Shai Malin
From: Omkar Kulkarni <[email protected]>
This patch adds qed NVMeTCP personality in order to support the NVMeTCP qed functionalities and manage the HW device shared resources. The same design is used with Eth (qede), RDMA(qedr), iSCSI (qedi) and FCoE (qedf).
Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/qed/qed.h | 3 ++ drivers/net/ethernet/qlogic/qed/qed_cxt.c | 32 ++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_cxt.h | 1 + drivers/net/ethernet/qlogic/qed/qed_dev.c | 44 ++++++++++++++++--- drivers/net/ethernet/qlogic/qed/qed_hsi.h | 3 +- drivers/net/ethernet/qlogic/qed/qed_ll2.c | 31 ++++++++----- drivers/net/ethernet/qlogic/qed/qed_mcp.c | 3 ++ drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c | 3 +- drivers/net/ethernet/qlogic/qed/qed_ooo.c | 5 ++- .../net/ethernet/qlogic/qed/qed_sp_commands.c | 1 + 10 files changed, 108 insertions(+), 18 deletions(-)drivers/net/ethernet/qlogic/qed/qed.h +1
-0@@ -200,6 +200,7 @@ enum qed_pci_personality {QED_PCI_ETH ,QED_PCI_FCOE ,QED_PCI_ISCSI , +QED_PCI_NVMETCP ,QED_PCI_ETH_ROCE ,QED_PCI_ETH_IWARP , QED_PCI_ETH_RDMA,
drivers/net/ethernet/qlogic/qed/qed.h struct qed_hw_info { · line 291
Quoted 6 lines
drivers/net/ethernet/qlogic/qed/qed.h +2
-0@@ -285,6 +286,8 @@ struct qed_hw_info { ((dev)->hw_info.personality == QED_PCI_FCOE)#define QED_IS_ISCSI_PERSONALITY (dev) \ ((dev)->hw_info.personality == QED_PCI_ISCSI) +#define QED_IS_NVMETCP_PERSONALITY (dev) \ + ((dev)->hw_info.personality == QED_PCI_NVMETCP)
So you have a distinct PCI personality for NVMe-oF, but not for the protocol? Strange. Why don't you have a distinct NVMe-oF protocol ID?
Quoted 376 lines
drivers/net/ethernet/qlogic/qed/qed.h +0
-0/* Resource Allocation scheme results */ u32 resc_start[QED_MAX_RESC ];drivers/net/ethernet/qlogic/qed/qed_cxt.c +32
-0@@ -2106,6 +2106,30 @@ int qed_cxt_set_pf_params(struct qed_hwfn *p_hwfn, u32 rdma_tasks) }break ; } +case QED_PCI_NVMETCP : + { +struct qed_nvmetcp_pf_params *p_params; + + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + +if (p_params->num_cons && p_params->num_tasks) { +qed_cxt_set_proto_cid_count (p_hwfn, +PROTOCOLID_NVMETCP , + p_params->num_cons, +0 ); + +qed_cxt_set_proto_tid_count (p_hwfn, +PROTOCOLID_NVMETCP , +QED_CTX_NVMETCP_TID_SEG , +0 , + p_params->num_tasks, + true); + }else { +DP_INFO (p_hwfn->cdev, +"NvmeTCP personality used without setting params!\n" ); + } +break ; + }default :return -EINVAL ; }@@ -2132,6 +2156,10 @@ int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, proto =PROTOCOLID_ISCSI ; seg =QED_CXT_ISCSI_TID_SEG ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; + seg =QED_CTX_NVMETCP_TID_SEG ; +break ;default :return -EINVAL ; }@@ -2458,6 +2486,10 @@ int qed_cxt_get_task_ctx(struct qed_hwfn *p_hwfn, proto =PROTOCOLID_ISCSI ; seg =QED_CXT_ISCSI_TID_SEG ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; + seg =QED_CTX_NVMETCP_TID_SEG ; +break ;default :return -EINVAL ; }drivers/net/ethernet/qlogic/qed/qed_cxt.h +1
-0@@ -51,6 +51,7 @@ int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, struct qed_tid_mem *p_info);#define QED_CXT_ISCSI_TID_SEG PROTOCOLID_ISCSI +#define QED_CTX_NVMETCP_TID_SEG PROTOCOLID_NVMETCP#define QED_CXT_ROCE_TID_SEG PROTOCOLID_ROCE#define QED_CXT_FCOE_TID_SEG PROTOCOLID_FCOEenum qed_cxt_elem_type {drivers/net/ethernet/qlogic/qed/qed_dev.c +39
-5@@ -37,6 +37,7 @@#include "qed_sriov.h" #include "qed_vf.h" #include "qed_rdma.h" +#include "qed_nvmetcp.h" static DEFINE_SPINLOCK (qm_lock);@@ -667,7 +668,8 @@ qed_llh_set_engine_affin(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) }/* Storage PF is bound to a single engine while L2 PF uses both */ -if (QED_IS_FCOE_PERSONALITY (p_hwfn) ||QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_FCOE_PERSONALITY (p_hwfn) ||QED_IS_ISCSI_PERSONALITY (p_hwfn) || +QED_IS_NVMETCP_PERSONALITY (p_hwfn)) eng = cdev->fir_affin ?QED_ENG1 :QED_ENG0 ;else /* L2_PERSONALITY */ eng =QED_BOTH_ENG ;@@ -1164,6 +1166,9 @@ void qed_llh_remove_mac_filter(struct qed_dev *cdev,if (!test_bit (QED_MF_LLH_MAC_CLSS , &cdev->mf_bits)) goto out; +if (QED_IS_NVMETCP_PERSONALITY (p_hwfn)) +return ; +ether_addr_copy (filter.mac.addr, mac_addr); rc =qed_llh_shadow_remove_filter (cdev, ppfid, &filter, &filter_idx, &ref_cnt);@@ -1381,6 +1386,11 @@ void qed_resc_free(struct qed_dev *cdev)qed_ooo_free (p_hwfn); } +if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { +qed_nvmetcp_free (p_hwfn); +qed_ooo_free (p_hwfn); + } +if (QED_IS_RDMA_PERSONALITY (p_hwfn) && rdma_info) {qed_spq_unregister_async_cb (p_hwfn, rdma_info->proto);qed_rdma_info_free (p_hwfn);@@ -1423,6 +1433,7 @@ static u32 qed_get_pq_flags(struct qed_hwfn *p_hwfn) flags |=PQ_FLAGS_OFLD ;break ;case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : flags |=PQ_FLAGS_ACK |PQ_FLAGS_OOO |PQ_FLAGS_OFLD ;break ;case QED_PCI_ETH_ROCE :@@ -2269,6 +2280,12 @@ int qed_resc_alloc(struct qed_dev *cdev)PROTOCOLID_ISCSI , NULL); n_eqes +=2 * num_cons; + }else if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { + num_cons = +qed_cxt_get_proto_cid_count (p_hwfn, +PROTOCOLID_NVMETCP , +NULL ); + n_eqes +=2 * num_cons; }if (n_eqes >0xFFFF ) {@@ -2313,6 +2330,15 @@ int qed_resc_alloc(struct qed_dev *cdev) goto alloc_err; } +if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { + rc =qed_nvmetcp_alloc (p_hwfn); +if (rc) + goto alloc_err; + rc =qed_ooo_alloc (p_hwfn); +if (rc) + goto alloc_err; + } +if (QED_IS_RDMA_PERSONALITY (p_hwfn)) { rc =qed_rdma_info_alloc (p_hwfn);if (rc)@@ -2393,6 +2419,11 @@ void qed_resc_setup(struct qed_dev *cdev)qed_iscsi_setup (p_hwfn);qed_ooo_setup (p_hwfn); } + +if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { +qed_nvmetcp_setup (p_hwfn); +qed_ooo_setup (p_hwfn); + } } }@@ -2854,7 +2885,8 @@ static int qed_hw_init_pf(struct qed_hwfn *p_hwfn,/* Protocol Configuration */ STORE_RT_REG (p_hwfn,PRS_REG_SEARCH_TCP_RT_OFFSET , - (p_hwfn->hw_info.personality ==QED_PCI_ISCSI ) ?1 :0 ); + ((p_hwfn->hw_info.personality ==QED_PCI_ISCSI ) || + (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP )) ?1 :0 );STORE_RT_REG (p_hwfn,PRS_REG_SEARCH_FCOE_RT_OFFSET , (p_hwfn->hw_info.personality ==QED_PCI_FCOE ) ?1 :0 );STORE_RT_REG (p_hwfn,PRS_REG_SEARCH_ROCE_RT_OFFSET ,0 );@@ -3531,7 +3563,7 @@ static void qed_hw_set_feat(struct qed_hwfn *p_hwfn)RESC_NUM (p_hwfn, QED_CMDQS_CQS)); -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn)) feat_num[QED_ISCSI_CQ ] =min_t (u32, sb_cnt.cnt,RESC_NUM (p_hwfn,QED_CMDQS_CQS ));@@ -3734,7 +3766,8 @@ int qed_hw_get_dflt_resc(struct qed_hwfn *p_hwfn,break ;case QED_BDQ :if (p_hwfn->hw_info.personality !=QED_PCI_ISCSI && - p_hwfn->hw_info.personality !=QED_PCI_FCOE ) + p_hwfn->hw_info.personality !=QED_PCI_FCOE && + p_hwfn->hw_info.personality !=QED_PCI_NVMETCP ) *p_resc_num =0 ;else *p_resc_num =1 ;@@ -3755,7 +3788,8 @@ int qed_hw_get_dflt_resc(struct qed_hwfn *p_hwfn, *p_resc_start =0 ; else if (p_hwfn->cdev->num_ports_in_engine == 4) *p_resc_start = p_hwfn->port_id; - else if (p_hwfn->hw_info.personality == QED_PCI_ISCSI) + else if (p_hwfn->hw_info.personality == QED_PCI_ISCSI || + p_hwfn->hw_info.personality == QED_PCI_NVMETCP) *p_resc_start = p_hwfn->port_id; else if (p_hwfn->hw_info.personality == QED_PCI_FCOE) *p_resc_start = p_hwfn->port_id + 2;drivers/net/ethernet/qlogic/qed/qed_hsi.h +2
-1@@ -12148,7 +12148,8 @@ struct public_func {#define FUNC_MF_CFG_PROTOCOL_ISCSI 0x00000010#define FUNC_MF_CFG_PROTOCOL_FCOE 0x00000020#define FUNC_MF_CFG_PROTOCOL_ROCE 0x00000030 -#define FUNC_MF_CFG_PROTOCOL_MAX 0x00000030 +#define FUNC_MF_CFG_PROTOCOL_NVMETCP 0x00000040 +#define FUNC_MF_CFG_PROTOCOL_MAX 0x00000040#define FUNC_MF_CFG_MIN_BW_MASK 0x0000ff00#define FUNC_MF_CFG_MIN_BW_SHIFT 8drivers/net/ethernet/qlogic/qed/qed_ll2.c +21
-10@@ -960,7 +960,8 @@ static int qed_sp_ll2_rx_queue_start(struct qed_hwfn *p_hwfn,if (test_bit (QED_MF_LL2_NON_UNICAST , &p_hwfn->cdev->mf_bits) && p_ramrod->main_func_queue && conn_type !=QED_LL2_TYPE_ROCE && - conn_type !=QED_LL2_TYPE_IWARP ) { + conn_type !=QED_LL2_TYPE_IWARP && + (!QED_IS_NVMETCP_PERSONALITY (p_hwfn))) { p_ramrod->mf_si_bcast_accept_all =1 ; p_ramrod->mf_si_mcast_accept_all =1 ; }else {@@ -1049,6 +1050,8 @@ static int qed_sp_ll2_tx_queue_start(struct qed_hwfn *p_hwfn,case QED_LL2_TYPE_OOO :if (p_hwfn->hw_info.personality ==QED_PCI_ISCSI ) p_ramrod->conn_type =PROTOCOLID_ISCSI ; +else if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) + p_ramrod->conn_type =PROTOCOLID_NVMETCP ;else p_ramrod->conn_type =PROTOCOLID_IWARP ;break ;@@ -1634,7 +1637,8 @@ int qed_ll2_establish_connection(void *cxt, u8 connection_handle)if (rc) goto out; -if (!QED_IS_RDMA_PERSONALITY (p_hwfn)) +if (!QED_IS_RDMA_PERSONALITY (p_hwfn) && + !QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_wr (p_hwfn, p_ptt,PRS_REG_USE_LIGHT_L2 ,1 );qed_ll2_establish_connection_ooo (p_hwfn, p_ll2_conn);@@ -2376,7 +2380,8 @@ static int qed_ll2_start_ooo(struct qed_hwfn *p_hwfn,static bool qed_ll2_is_storage_eng1 (struct qed_dev *cdev) {return (QED_IS_FCOE_PERSONALITY (QED_LEADING_HWFN (cdev)) || -QED_IS_ISCSI_PERSONALITY (QED_LEADING_HWFN (cdev))) && +QED_IS_ISCSI_PERSONALITY (QED_LEADING_HWFN (cdev)) || +QED_IS_NVMETCP_PERSONALITY (QED_LEADING_HWFN (cdev))) && (QED_AFFIN_HWFN (cdev) !=QED_LEADING_HWFN (cdev)); }@@ -2402,11 +2407,13 @@ static int qed_ll2_stop(struct qed_dev *cdev)if (cdev->ll2->handle ==QED_LL2_UNUSED_HANDLE )return 0 ; +if (!QED_IS_NVMETCP_PERSONALITY (p_hwfn)) +qed_llh_remove_mac_filter (cdev,0 , cdev->ll2_mac_address);qed_llh_remove_mac_filter (cdev,0 , cdev->ll2_mac_address);eth_zero_addr (cdev->ll2_mac_address); -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_ll2_stop_ooo (p_hwfn);/* In CMT mode, LL2 is always started on engine 0 for a storage PF */ @@ -2442,6 +2449,7 @@ static int __qed_ll2_start(struct qed_hwfn *p_hwfn, conn_type =QED_LL2_TYPE_FCOE ;break ;case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : conn_type =QED_LL2_TYPE_ISCSI ;break ;case QED_PCI_ETH_ROCE :@@ -2567,7 +2575,7 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params) } } -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) { +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn)) {DP_VERBOSE (cdev,QED_MSG_STORAGE ,"Starting OOO LL2 queue\n" ); rc =qed_ll2_start_ooo (p_hwfn, params);if (rc) {@@ -2576,10 +2584,13 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params) } } - rc =qed_llh_add_mac_filter (cdev,0 , params->ll2_mac_address); -if (rc) { -DP_NOTICE (cdev,"Failed to add an LLH filter\n" ); - goto err3; +if (!QED_IS_NVMETCP_PERSONALITY (p_hwfn)) { + rc =qed_llh_add_mac_filter (cdev,0 , params->ll2_mac_address); +if (rc) { +DP_NOTICE (cdev,"Failed to add an LLH filter\n" ); + goto err3; + } + }ether_addr_copy (cdev->ll2_mac_address, params->ll2_mac_address);@@ -2587,7 +2598,7 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params)return 0 ; err3: -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_ll2_stop_ooo (p_hwfn); err2:if (b_is_storage_eng1)drivers/net/ethernet/qlogic/qed/qed_mcp.c +3
-0@@ -2446,6 +2446,9 @@ qed_mcp_get_shmem_proto(struct qed_hwfn *p_hwfn,case FUNC_MF_CFG_PROTOCOL_ISCSI : *p_proto =QED_PCI_ISCSI ;break ; +case FUNC_MF_CFG_PROTOCOL_NVMETCP : + *p_proto =QED_PCI_NVMETCP ; +break ;case FUNC_MF_CFG_PROTOCOL_FCOE : *p_proto =QED_PCI_FCOE ;break ;drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c +2
-1@@ -1306,7 +1306,8 @@ int qed_mfw_process_tlv_req(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) }if ((tlv_group &QED_MFW_TLV_ISCSI ) && - p_hwfn->hw_info.personality !=QED_PCI_ISCSI ) { + p_hwfn->hw_info.personality !=QED_PCI_ISCSI && + p_hwfn->hw_info.personality !=QED_PCI_NVMETCP ) {DP_VERBOSE (p_hwfn,QED_MSG_SP ,"Skipping iSCSI TLVs for non-iSCSI function\n" ); tlv_group &= ~QED_MFW_TLV_ISCSI ;drivers/net/ethernet/qlogic/qed/qed_ooo.c +4
-1@@ -16,7 +16,7 @@#include "qed_ll2.h" #include "qed_ooo.h" #include "qed_cxt.h" - +#include "qed_nvmetcp.h" static struct qed_ooo_archipelago *qed_ooo_seek_archipelago (struct qed_hwfn *p_hwfn, struct qed_ooo_info@@ -85,6 +85,9 @@ int qed_ooo_alloc(struct qed_hwfn *p_hwfn)case QED_PCI_ISCSI : proto =PROTOCOLID_ISCSI ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; +break ;case QED_PCI_ETH_RDMA :case QED_PCI_ETH_IWARP : proto =PROTOCOLID_IWARP ;drivers/net/ethernet/qlogic/qed/qed_sp_commands.c +0
-0
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c int qed_sp_pf_start(struct qed_hwfn *p_hwfn, · line 391
Quoted 7 lines
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c +1
-0@@ -385,6 +385,7 @@ int qed_sp_pf_start(struct qed_hwfn *p_hwfn, p_ramrod->personality =PERSONALITY_FCOE ;break ;case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : p_ramrod->personality =PERSONALITY_ISCSI ;break ;case QED_PCI_ETH_ROCE :
As indicated, I do find this mix of 'nvmetcp is nearly iscsi' a bit strange. I would have preferred to have distinct types for nvmetcp.
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 03/27] qed: Add qed-NVMeTCP personality
Quoted 427 lines · Hannes Reinecke
Quoted 39 lines · Shai Malin
From: Omkar Kulkarni <[email protected]>
This patch adds qed NVMeTCP personality in order to support the NVMeTCP qed functionalities and manage the HW device shared resources. The same design is used with Eth (qede), RDMA(qedr), iSCSI (qedi) and FCoE (qedf).
Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/qed/qed.h | 3 ++ drivers/net/ethernet/qlogic/qed/qed_cxt.c | 32 ++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_cxt.h | 1 + drivers/net/ethernet/qlogic/qed/qed_dev.c | 44 ++++++++++++++++--- drivers/net/ethernet/qlogic/qed/qed_hsi.h | 3 +- drivers/net/ethernet/qlogic/qed/qed_ll2.c | 31 ++++++++----- drivers/net/ethernet/qlogic/qed/qed_mcp.c | 3 ++ drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c | 3 +- drivers/net/ethernet/qlogic/qed/qed_ooo.c | 5 ++- .../net/ethernet/qlogic/qed/qed_sp_commands.c | 1 + 10 files changed, 108 insertions(+), 18 deletions(-)drivers/net/ethernet/qlogic/qed/qed.h +1
-0@@ -200,6 +200,7 @@ enum qed_pci_personality {QED_PCI_ETH ,QED_PCI_FCOE ,QED_PCI_ISCSI , +QED_PCI_NVMETCP ,QED_PCI_ETH_ROCE ,QED_PCI_ETH_IWARP , QED_PCI_ETH_RDMA,drivers/net/ethernet/qlogic/qed/qed.h struct qed_hw_info { · line 291
Quoted 6 lines
drivers/net/ethernet/qlogic/qed/qed.h +2
-0@@ -285,6 +286,8 @@ struct qed_hw_info { ((dev)->hw_info.personality == QED_PCI_FCOE)#define QED_IS_ISCSI_PERSONALITY (dev) \ ((dev)->hw_info.personality == QED_PCI_ISCSI) +#define QED_IS_NVMETCP_PERSONALITY (dev) \ + ((dev)->hw_info.personality == QED_PCI_NVMETCP)So you have a distinct PCI personality for NVMe-oF, but not for the protocol? Strange.
Why don't you have a distinct NVMe-oF protocol ID?Quoted 377 lines
drivers/net/ethernet/qlogic/qed/qed.h +0
-0/* Resource Allocation scheme results */ u32 resc_start[QED_MAX_RESC ];drivers/net/ethernet/qlogic/qed/qed_cxt.c +32
-0@@ -2106,6 +2106,30 @@ int qed_cxt_set_pf_params(struct qed_hwfn *p_hwfn, u32 rdma_tasks) }break ; } +case QED_PCI_NVMETCP : + { +struct qed_nvmetcp_pf_params *p_params; + + p_params = &p_hwfn->pf_params.nvmetcp_pf_params; + +if (p_params->num_cons && p_params->num_tasks) { +qed_cxt_set_proto_cid_count (p_hwfn, +PROTOCOLID_NVMETCP , + p_params->num_cons, +0 ); + +qed_cxt_set_proto_tid_count (p_hwfn, +PROTOCOLID_NVMETCP , +QED_CTX_NVMETCP_TID_SEG , +0 , + p_params->num_tasks, + true); + }else { +DP_INFO (p_hwfn->cdev, +"NvmeTCP personality used without setting params!\n" ); + } +break ; + }default :return -EINVAL ; }@@ -2132,6 +2156,10 @@ int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, proto =PROTOCOLID_ISCSI ; seg =QED_CXT_ISCSI_TID_SEG ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; + seg =QED_CTX_NVMETCP_TID_SEG ; +break ;default :return -EINVAL ; }@@ -2458,6 +2486,10 @@ int qed_cxt_get_task_ctx(struct qed_hwfn *p_hwfn, proto =PROTOCOLID_ISCSI ; seg =QED_CXT_ISCSI_TID_SEG ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; + seg =QED_CTX_NVMETCP_TID_SEG ; +break ;default :return -EINVAL ; }drivers/net/ethernet/qlogic/qed/qed_cxt.h +1
-0@@ -51,6 +51,7 @@ int qed_cxt_get_tid_mem_info(struct qed_hwfn *p_hwfn, struct qed_tid_mem *p_info);#define QED_CXT_ISCSI_TID_SEG PROTOCOLID_ISCSI +#define QED_CTX_NVMETCP_TID_SEG PROTOCOLID_NVMETCP#define QED_CXT_ROCE_TID_SEG PROTOCOLID_ROCE#define QED_CXT_FCOE_TID_SEG PROTOCOLID_FCOEenum qed_cxt_elem_type {drivers/net/ethernet/qlogic/qed/qed_dev.c +39
-5@@ -37,6 +37,7 @@#include "qed_sriov.h" #include "qed_vf.h" #include "qed_rdma.h" +#include "qed_nvmetcp.h" static DEFINE_SPINLOCK (qm_lock);@@ -667,7 +668,8 @@ qed_llh_set_engine_affin(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) }/* Storage PF is bound to a single engine while L2 PF uses both */ -if (QED_IS_FCOE_PERSONALITY (p_hwfn) ||QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_FCOE_PERSONALITY (p_hwfn) ||QED_IS_ISCSI_PERSONALITY (p_hwfn) || +QED_IS_NVMETCP_PERSONALITY (p_hwfn)) eng = cdev->fir_affin ?QED_ENG1 :QED_ENG0 ;else /* L2_PERSONALITY */ eng =QED_BOTH_ENG ;@@ -1164,6 +1166,9 @@ void qed_llh_remove_mac_filter(struct qed_dev *cdev,if (!test_bit (QED_MF_LLH_MAC_CLSS , &cdev->mf_bits)) goto out; +if (QED_IS_NVMETCP_PERSONALITY (p_hwfn)) +return ; +ether_addr_copy (filter.mac.addr, mac_addr); rc =qed_llh_shadow_remove_filter (cdev, ppfid, &filter, &filter_idx, &ref_cnt);@@ -1381,6 +1386,11 @@ void qed_resc_free(struct qed_dev *cdev)qed_ooo_free (p_hwfn); } +if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { +qed_nvmetcp_free (p_hwfn); +qed_ooo_free (p_hwfn); + } +if (QED_IS_RDMA_PERSONALITY (p_hwfn) && rdma_info) {qed_spq_unregister_async_cb (p_hwfn, rdma_info->proto);qed_rdma_info_free (p_hwfn);@@ -1423,6 +1433,7 @@ static u32 qed_get_pq_flags(struct qed_hwfn *p_hwfn) flags |=PQ_FLAGS_OFLD ;break ;case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : flags |=PQ_FLAGS_ACK |PQ_FLAGS_OOO |PQ_FLAGS_OFLD ;break ;case QED_PCI_ETH_ROCE :@@ -2269,6 +2280,12 @@ int qed_resc_alloc(struct qed_dev *cdev)PROTOCOLID_ISCSI , NULL); n_eqes +=2 * num_cons; + }else if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { + num_cons = +qed_cxt_get_proto_cid_count (p_hwfn, +PROTOCOLID_NVMETCP , +NULL ); + n_eqes +=2 * num_cons; }if (n_eqes >0xFFFF ) {@@ -2313,6 +2330,15 @@ int qed_resc_alloc(struct qed_dev *cdev) goto alloc_err; } +if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { + rc =qed_nvmetcp_alloc (p_hwfn); +if (rc) + goto alloc_err; + rc =qed_ooo_alloc (p_hwfn); +if (rc) + goto alloc_err; + } +if (QED_IS_RDMA_PERSONALITY (p_hwfn)) { rc =qed_rdma_info_alloc (p_hwfn);if (rc)@@ -2393,6 +2419,11 @@ void qed_resc_setup(struct qed_dev *cdev)qed_iscsi_setup (p_hwfn);qed_ooo_setup (p_hwfn); } + +if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) { +qed_nvmetcp_setup (p_hwfn); +qed_ooo_setup (p_hwfn); + } } }@@ -2854,7 +2885,8 @@ static int qed_hw_init_pf(struct qed_hwfn *p_hwfn,/* Protocol Configuration */ STORE_RT_REG (p_hwfn,PRS_REG_SEARCH_TCP_RT_OFFSET , - (p_hwfn->hw_info.personality ==QED_PCI_ISCSI ) ?1 :0 ); + ((p_hwfn->hw_info.personality ==QED_PCI_ISCSI ) || + (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP )) ?1 :0 );STORE_RT_REG (p_hwfn,PRS_REG_SEARCH_FCOE_RT_OFFSET , (p_hwfn->hw_info.personality ==QED_PCI_FCOE ) ?1 :0 );STORE_RT_REG (p_hwfn,PRS_REG_SEARCH_ROCE_RT_OFFSET ,0 );@@ -3531,7 +3563,7 @@ static void qed_hw_set_feat(struct qed_hwfn *p_hwfn)RESC_NUM (p_hwfn, QED_CMDQS_CQS)); -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn)) feat_num[QED_ISCSI_CQ ] =min_t (u32, sb_cnt.cnt,RESC_NUM (p_hwfn,QED_CMDQS_CQS ));@@ -3734,7 +3766,8 @@ int qed_hw_get_dflt_resc(struct qed_hwfn *p_hwfn,break ;case QED_BDQ :if (p_hwfn->hw_info.personality !=QED_PCI_ISCSI && - p_hwfn->hw_info.personality !=QED_PCI_FCOE ) + p_hwfn->hw_info.personality !=QED_PCI_FCOE && + p_hwfn->hw_info.personality !=QED_PCI_NVMETCP ) *p_resc_num =0 ;else *p_resc_num =1 ;@@ -3755,7 +3788,8 @@ int qed_hw_get_dflt_resc(struct qed_hwfn *p_hwfn, *p_resc_start =0 ; else if (p_hwfn->cdev->num_ports_in_engine == 4) *p_resc_start = p_hwfn->port_id; - else if (p_hwfn->hw_info.personality == QED_PCI_ISCSI) + else if (p_hwfn->hw_info.personality == QED_PCI_ISCSI || + p_hwfn->hw_info.personality == QED_PCI_NVMETCP) *p_resc_start = p_hwfn->port_id; else if (p_hwfn->hw_info.personality == QED_PCI_FCOE) *p_resc_start = p_hwfn->port_id + 2;drivers/net/ethernet/qlogic/qed/qed_hsi.h +2
-1@@ -12148,7 +12148,8 @@ struct public_func {#define FUNC_MF_CFG_PROTOCOL_ISCSI 0x00000010#define FUNC_MF_CFG_PROTOCOL_FCOE 0x00000020#define FUNC_MF_CFG_PROTOCOL_ROCE 0x00000030 -#define FUNC_MF_CFG_PROTOCOL_MAX 0x00000030 +#define FUNC_MF_CFG_PROTOCOL_NVMETCP 0x00000040 +#define FUNC_MF_CFG_PROTOCOL_MAX 0x00000040#define FUNC_MF_CFG_MIN_BW_MASK 0x0000ff00#define FUNC_MF_CFG_MIN_BW_SHIFT 8drivers/net/ethernet/qlogic/qed/qed_ll2.c +21
-10@@ -960,7 +960,8 @@ static int qed_sp_ll2_rx_queue_start(struct qed_hwfn *p_hwfn,if (test_bit (QED_MF_LL2_NON_UNICAST , &p_hwfn->cdev->mf_bits) && p_ramrod->main_func_queue && conn_type !=QED_LL2_TYPE_ROCE && - conn_type !=QED_LL2_TYPE_IWARP ) { + conn_type !=QED_LL2_TYPE_IWARP && + (!QED_IS_NVMETCP_PERSONALITY (p_hwfn))) { p_ramrod->mf_si_bcast_accept_all =1 ; p_ramrod->mf_si_mcast_accept_all =1 ; }else {@@ -1049,6 +1050,8 @@ static int qed_sp_ll2_tx_queue_start(struct qed_hwfn *p_hwfn,case QED_LL2_TYPE_OOO :if (p_hwfn->hw_info.personality ==QED_PCI_ISCSI ) p_ramrod->conn_type =PROTOCOLID_ISCSI ; +else if (p_hwfn->hw_info.personality ==QED_PCI_NVMETCP ) + p_ramrod->conn_type =PROTOCOLID_NVMETCP ;else p_ramrod->conn_type =PROTOCOLID_IWARP ;break ;@@ -1634,7 +1637,8 @@ int qed_ll2_establish_connection(void *cxt, u8 connection_handle)if (rc) goto out; -if (!QED_IS_RDMA_PERSONALITY (p_hwfn)) +if (!QED_IS_RDMA_PERSONALITY (p_hwfn) && + !QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_wr (p_hwfn, p_ptt,PRS_REG_USE_LIGHT_L2 ,1 );qed_ll2_establish_connection_ooo (p_hwfn, p_ll2_conn);@@ -2376,7 +2380,8 @@ static int qed_ll2_start_ooo(struct qed_hwfn *p_hwfn,static bool qed_ll2_is_storage_eng1 (struct qed_dev *cdev) {return (QED_IS_FCOE_PERSONALITY (QED_LEADING_HWFN (cdev)) || -QED_IS_ISCSI_PERSONALITY (QED_LEADING_HWFN (cdev))) && +QED_IS_ISCSI_PERSONALITY (QED_LEADING_HWFN (cdev)) || +QED_IS_NVMETCP_PERSONALITY (QED_LEADING_HWFN (cdev))) && (QED_AFFIN_HWFN (cdev) !=QED_LEADING_HWFN (cdev)); }@@ -2402,11 +2407,13 @@ static int qed_ll2_stop(struct qed_dev *cdev)if (cdev->ll2->handle ==QED_LL2_UNUSED_HANDLE )return 0 ; +if (!QED_IS_NVMETCP_PERSONALITY (p_hwfn)) +qed_llh_remove_mac_filter (cdev,0 , cdev->ll2_mac_address);qed_llh_remove_mac_filter (cdev,0 , cdev->ll2_mac_address);eth_zero_addr (cdev->ll2_mac_address); -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_ll2_stop_ooo (p_hwfn);/* In CMT mode, LL2 is always started on engine 0 for a storage PF */ @@ -2442,6 +2449,7 @@ static int __qed_ll2_start(struct qed_hwfn *p_hwfn, conn_type =QED_LL2_TYPE_FCOE ;break ;case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : conn_type =QED_LL2_TYPE_ISCSI ;break ;case QED_PCI_ETH_ROCE :@@ -2567,7 +2575,7 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params) } } -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) { +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn)) {DP_VERBOSE (cdev,QED_MSG_STORAGE ,"Starting OOO LL2 queue\n" ); rc =qed_ll2_start_ooo (p_hwfn, params);if (rc) {@@ -2576,10 +2584,13 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params) } } - rc =qed_llh_add_mac_filter (cdev,0 , params->ll2_mac_address); -if (rc) { -DP_NOTICE (cdev,"Failed to add an LLH filter\n" ); - goto err3; +if (!QED_IS_NVMETCP_PERSONALITY (p_hwfn)) { + rc =qed_llh_add_mac_filter (cdev,0 , params->ll2_mac_address); +if (rc) { +DP_NOTICE (cdev,"Failed to add an LLH filter\n" ); + goto err3; + } + }ether_addr_copy (cdev->ll2_mac_address, params->ll2_mac_address);@@ -2587,7 +2598,7 @@ static int qed_ll2_start(struct qed_dev *cdev, struct qed_ll2_params *params)return 0 ; err3: -if (QED_IS_ISCSI_PERSONALITY (p_hwfn)) +if (QED_IS_ISCSI_PERSONALITY (p_hwfn) ||QED_IS_NVMETCP_PERSONALITY (p_hwfn))qed_ll2_stop_ooo (p_hwfn); err2:if (b_is_storage_eng1)drivers/net/ethernet/qlogic/qed/qed_mcp.c +3
-0@@ -2446,6 +2446,9 @@ qed_mcp_get_shmem_proto(struct qed_hwfn *p_hwfn,case FUNC_MF_CFG_PROTOCOL_ISCSI : *p_proto =QED_PCI_ISCSI ;break ; +case FUNC_MF_CFG_PROTOCOL_NVMETCP : + *p_proto =QED_PCI_NVMETCP ; +break ;case FUNC_MF_CFG_PROTOCOL_FCOE : *p_proto =QED_PCI_FCOE ;break ;drivers/net/ethernet/qlogic/qed/qed_mng_tlv.c +2
-1@@ -1306,7 +1306,8 @@ int qed_mfw_process_tlv_req(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) }if ((tlv_group &QED_MFW_TLV_ISCSI ) && - p_hwfn->hw_info.personality !=QED_PCI_ISCSI ) { + p_hwfn->hw_info.personality !=QED_PCI_ISCSI && + p_hwfn->hw_info.personality !=QED_PCI_NVMETCP ) {DP_VERBOSE (p_hwfn,QED_MSG_SP ,"Skipping iSCSI TLVs for non-iSCSI function\n" ); tlv_group &= ~QED_MFW_TLV_ISCSI ;drivers/net/ethernet/qlogic/qed/qed_ooo.c +4
-1@@ -16,7 +16,7 @@#include "qed_ll2.h" #include "qed_ooo.h" #include "qed_cxt.h" - +#include "qed_nvmetcp.h" static struct qed_ooo_archipelago *qed_ooo_seek_archipelago (struct qed_hwfn *p_hwfn, struct qed_ooo_info@@ -85,6 +85,9 @@ int qed_ooo_alloc(struct qed_hwfn *p_hwfn)case QED_PCI_ISCSI : proto =PROTOCOLID_ISCSI ;break ; +case QED_PCI_NVMETCP : + proto =PROTOCOLID_NVMETCP ; +break ;case QED_PCI_ETH_RDMA :case QED_PCI_ETH_IWARP : proto =PROTOCOLID_IWARP ;drivers/net/ethernet/qlogic/qed/qed_sp_commands.c +0
-0@@ -385,6 +385,7 @@ int qed_sp_pf_start(struct qed_hwfn *p_hwfn, p_ramrod->personality =PERSONALITY_FCOE ;break ;
Quoted 9 lines
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c int qed_sp_pf_start(struct qed_hwfn *p_hwfn, · line 391
Quoted 6 lines
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c +1
-0case QED_PCI_ISCSI : +case QED_PCI_NVMETCP : p_ramrod->personality =PERSONALITY_ISCSI ;break ;case QED_PCI_ETH_ROCE :As indicated, I do find this mix of 'nvmetcp is nearly iscsi' a bit strange. I would have preferred to have distinct types for nvmetcp.
PERSONALITY_ determines the FW resource layout, which is the same for iSCSI and NVMeTCP. I will change PERSONALITY_ISCSI to PERSONALITY_TCP_ULP.
Quoted 8 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 4/27 qed: Add support of HW filter block
In reply to Shai MalinFrom: Prabhakar Kushwaha <[email protected]>
This patch introduces the functionality of HW filter block. It adds and removes filters based on source and target TCP port.
It also add functionality to clear all filters at once.
--- drivers/net/ethernet/qlogic/qed/qed.h | 10 ++ drivers/net/ethernet/qlogic/qed/qed_dev.c | 107 ++++++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 5 + include/linux/qed/qed_nvmetcp_if.h | 24 ++++ 4 files changed, 146 insertions(+)
drivers/net/ethernet/qlogic/qed/qed.h +10 -0
@@ -49,6 +49,8 @@ extern const struct qed_common_ops qed_common_ops_pass;#define QED_MIN_WIDS (4)#define QED_PF_DEMS_SIZE (4) +#define QED_LLH_DONT_CARE 0 +/* cau states */ enum qed_coalescing_mode {QED_COAL_MODE_DISABLE ,
@@ -1005,4 +1007,12 @@ int qed_mfw_fill_tlv_data(struct qed_hwfn *hwfn,void qed_hw_info_set_offload_tc (struct qed_hw_info *p_info,u8 tc);void qed_periodic_db_rec_start (struct qed_hwfn *p_hwfn); + +int qed_llh_add_src_tcp_port_filter (struct qed_dev *cdev,u16 src_port); +int qed_llh_add_dst_tcp_port_filter (struct qed_dev *cdev,u16 dest_port); + +void qed_llh_remove_src_tcp_port_filter (struct qed_dev *cdev,u16 src_port); +void qed_llh_remove_dst_tcp_port_filter (struct qed_dev *cdev,u16 src_port); + +void qed_llh_clear_all_filters (struct qed_dev *cdev);#endif /* _QED_H */
drivers/net/ethernet/qlogic/qed/qed_dev.c +107 -0
110 lines not on this page · raw message
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +5 -0
@@ -844,6 +844,11 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .update_conn = &qed_nvmetcp_update_conn, .destroy_conn = &qed_nvmetcp_destroy_conn, .clear_sq = &qed_nvmetcp_clear_conn_sq, + .add_src_tcp_port_filter = &qed_llh_add_src_tcp_port_filter, + .remove_src_tcp_port_filter = &qed_llh_remove_src_tcp_port_filter, + .add_dst_tcp_port_filter = &qed_llh_add_dst_tcp_port_filter, + .remove_dst_tcp_port_filter = &qed_llh_remove_dst_tcp_port_filter, + .clear_all_filters = &qed_llh_clear_all_filters };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void )
include/linux/qed/qed_nvmetcp_if.h +24 -0
@@ -124,6 +124,20 @@ struct qed_nvmetcp_cb_ops {* @param cdev * @param handle - the connection handle. * @return 0 on success, otherwise error value. +* @add_src_tcp_port_filter: Add source tcp port filter +* @param cdev +* @param src_port +* @remove_src_tcp_port_filter: Remove source tcp port filter +* @param cdev +* @param src_port +* @add_dst_tcp_port_filter: Add destination tcp port filter +* @param cdev +* @param dest_port +* @remove_dst_tcp_port_filter: Remove destination tcp port filter +* @param cdev +* @param dest_port +* @clear_all_filters: Clear all filters. +* @param cdev */ struct qed_nvmetcp_ops {const struct qed_common_ops *common;
@@ -159,6 +173,16 @@ struct qed_nvmetcp_ops {int (*destroy_conn)(struct qed_dev *cdev,u32 handle,u8 abrt_conn);int (*clear_sq)(struct qed_dev *cdev,u32 handle); + +int (*add_src_tcp_port_filter)(struct qed_dev *cdev,u16 src_port); + +void (*remove_src_tcp_port_filter)(struct qed_dev *cdev,u16 src_port); + +int (*add_dst_tcp_port_filter)(struct qed_dev *cdev,u16 dest_port); + +void (*remove_dst_tcp_port_filter)(struct qed_dev *cdev,u16 dest_port); + +void (*clear_all_filters)(struct qed_dev *cdev); };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void );
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
kernel test robot
build botRe: [RFC PATCH v4 04/27] qed: Add support of HW filter block
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]
Hi Shai,
[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on ipvs/master]
[also build test WARNING on hch-configfs/for-next linus/master v5.12 next-20210429] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 base: https://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git master config: riscv-allyesconfig (attached as .config) compiler: riscv64-linux-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/caa1600cbe7295b770621c5990833e2e4571ce1b
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 git checkout caa1600cbe7295b770621c5990833e2e4571ce1b
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross W=1 ARCH=riscv
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
>> drivers/net/ethernet/qlogic/qed/qed_dev.c:5381:5: warning: no previous prototype for 'qed_abs_ppfid' [-Wmissing-prototypes]
5381 | int qed_abs_ppfid(struct qed_dev *cdev, u8 rel_ppfid, u8 *p_abs_ppfid)
| ^~~~~~~~~~~~~
>> drivers/net/ethernet/qlogic/qed/qed_dev.c:5398:6: warning: no previous prototype for 'qed_llh_clear_ppfid_filters' [-Wmissing-prototypes] 5398 | void qed_llh_clear_ppfid_filters(struct qed_dev *cdev, u8 ppfid)
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
vim +/qed_abs_ppfid +5381 drivers/net/ethernet/qlogic/qed/qed_dev.c
5380
> 5381 int qed_abs_ppfid(struct qed_dev *cdev, u8 rel_ppfid, u8 *p_abs_ppfid)
5382 {
5383 struct qed_llh_info *p_llh_info = cdev->p_llh_info;
5384
5385 if (rel_ppfid >= p_llh_info->num_ppfid) {
5386 DP_NOTICE(cdev,
5387 "rel_ppfid %d is not valid, available indices are 0..%hhu\n",
5388 rel_ppfid, p_llh_info->num_ppfid - 1);
5389
5390 return -EINVAL;
5391 }
5392
5393 *p_abs_ppfid = p_llh_info->ppfid_array[rel_ppfid];
5394
5395 return 0;
5396 }
5397
> 5398 void qed_llh_clear_ppfid_filters(struct qed_dev *cdev, u8 ppfid) 5399 {
5400 struct qed_hwfn *p_hwfn = QED_LEADING_HWFN(cdev);
5401 struct qed_ptt *p_ptt = qed_ptt_acquire(p_hwfn);
5402 u8 filter_idx, abs_ppfid;
5403 int rc = 0;
5404
5405 if (!p_ptt)
5406 return;
5407
5408 if (!test_bit(QED_MF_LLH_PROTO_CLSS, &cdev->mf_bits) &&
5409 !test_bit(QED_MF_LLH_MAC_CLSS, &cdev->mf_bits))
5410 goto out;
5411
5412 rc = qed_abs_ppfid(cdev, ppfid, &abs_ppfid);
5413 if (rc)
5414 goto out;
5415
5416 rc = qed_llh_shadow_remove_all_filters(cdev, ppfid);
5417 if (rc)
5418 goto out;
5419
5420 for (filter_idx = 0; filter_idx < NIG_REG_LLH_FUNC_FILTER_EN_SIZE;
5421 filter_idx++) {
5422 rc = qed_llh_remove_filter(p_hwfn, p_ptt,
5423 abs_ppfid, filter_idx);
5424 if (rc)
5425 goto out;
5426 }
5427 out:
5428 qed_ptt_release(p_hwfn, p_ptt);
5429 }
5430
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
Re: [RFC PATCH v4 04/27] qed: Add support of HW filter block
In reply to Shai MalinQuoted 13 lines · Shai Malin
From: Prabhakar Kushwaha <[email protected]>
This patch introduces the functionality of HW filter block. It adds and removes filters based on source and target TCP port.
It also add functionality to clear all filters at once.
Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>
Quoted 7 lines
--- drivers/net/ethernet/qlogic/qed/qed.h | 10 ++ drivers/net/ethernet/qlogic/qed/qed_dev.c | 107 ++++++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 5 + include/linux/qed/qed_nvmetcp_if.h | 24 ++++ 4 files changed, 146 insertions(+)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 04/27] qed: Add support of HW filter block
Quoted 21 lines · Hannes Reinecke
Quoted 13 lines · Shai Malin
From: Prabhakar Kushwaha <[email protected]>
This patch introduces the functionality of HW filter block. It adds and removes filters based on source and target TCP port.
It also add functionality to clear all filters at once.
Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Quoted 7 lines
--- drivers/net/ethernet/qlogic/qed/qed.h | 10 ++ drivers/net/ethernet/qlogic/qed/qed_dev.c | 107 ++++++++++++++++++ drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 5 + include/linux/qed/qed_nvmetcp_if.h | 24 ++++ 4 files changed, 146 insertions(+)
Quoted 1 line
Reviewed-by Hannes Reinecke <[email protected]>
Thanks.
Quoted 9 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 5/27 qed: Add NVMeTCP Offload IO Level FW and HW HSI
In reply to Shai MalinThis patch introduces the NVMeTCP Offload FW and HW HSI in order to initialize the IO level configuration into a per IO HW resource ("task") as part of the IO path flow.
--- include/linux/qed/nvmetcp_common.h | 418 ++++++++++++++++++++++++++++- include/linux/qed/qed_nvmetcp_if.h | 37 +++ 2 files changed, 454 insertions(+), 1 deletion(-)
include/linux/qed/nvmetcp_common.h +417 -1
@@ -7,6 +7,7 @@#include "tcp_common.h" #define NVMETCP_SLOW_PATH_LAYER_CODE (6) +#define NVMETCP_WQE_NUM_SGES_SLOWIO (0xf)/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {
@@ -194,4 +195,419 @@ struct nvmetcp_wqe {#define NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD_SHIFT 24 }; -#endif /* __NVMETCP_COMMON__ */ +struct nvmetcp_host_cccid_itid_entry { +__le16 itid; +}; + +struct nvmetcp_connect_done_results { +__le16 icid; +__le16 conn_id; +struct tcp_ulp_connect_done_params params; +}; + +struct nvmetcp_eqe_data { +__le16 icid; +__le16 conn_id; +__le16 reserved; +u8 error_code; +u8 error_pdu_opcode_reserved; +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_MASK 0x3F +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_SHIFT 0 +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_VALID_MASK 0x1 +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_VALID_SHIFT 6 +#define NVMETCP_EQE_DATA_RESERVED0_MASK 0x1 +#define NVMETCP_EQE_DATA_RESERVED0_SHIFT 7 +}; + +enum nvmetcp_task_type { +NVMETCP_TASK_TYPE_HOST_WRITE , +NVMETCP_TASK_TYPE_HOST_READ , +NVMETCP_TASK_TYPE_INIT_CONN_REQUEST , +NVMETCP_TASK_TYPE_RESERVED0 , +NVMETCP_TASK_TYPE_CLEANUP , +NVMETCP_TASK_TYPE_HOST_READ_NO_CQE , +MAX_NVMETCP_TASK_TYPE +}; + +struct nvmetcp_db_data { +u8 params; +#define NVMETCP_DB_DATA_DEST_MASK 0x3/* destination of doorbell (use enum db_dest) */ +#define NVMETCP_DB_DATA_DEST_SHIFT 0 +#define NVMETCP_DB_DATA_AGG_CMD_MASK 0x3/* aggregative command to CM (use enum db_agg_cmd_sel) */ +#define NVMETCP_DB_DATA_AGG_CMD_SHIFT 2 +#define NVMETCP_DB_DATA_BYPASS_EN_MASK 0x1/* enable QM bypass */ +#define NVMETCP_DB_DATA_BYPASS_EN_SHIFT 4 +#define NVMETCP_DB_DATA_RESERVED_MASK 0x1 +#define NVMETCP_DB_DATA_RESERVED_SHIFT 5 +#define NVMETCP_DB_DATA_AGG_VAL_SEL_MASK 0x3/* aggregative value selection */ +#define NVMETCP_DB_DATA_AGG_VAL_SEL_SHIFT 6 +u8 agg_flags;/* bit for every DQ counter flags in CM context that DQ can increment */ +__le16 sq_prod; +}; + +struct nvmetcp_fw_cqe_error_bitmap { +u8 cqe_error_status_bits; +#define CQE_ERROR_BITMAP_DIF_ERR_BITS_MASK 0x7 +#define CQE_ERROR_BITMAP_DIF_ERR_BITS_SHIFT 0 +#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_MASK 0x1 +#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_SHIFT 3 +#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_MASK 0x1 +#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_SHIFT 4 +}; + +struct nvmetcp_nvmf_cqe { +__le32 reserved[4 ]; +}; + +struct nvmetcp_fw_cqe_data { +struct nvmetcp_nvmf_cqe nvme_cqe; +struct regpair task_opaque; +__le32 reserved[6 ]; +}; + +struct nvmetcp_fw_cqe { +__le16 conn_id; +u8 cqe_type; +struct nvmetcp_fw_cqe_error_bitmap error_bitmap; +__le16 itid; +u8 task_type; +u8 fw_dbg_field; +u8 caused_conn_err; +u8 reserved0[3 ]; +__le32 reserved1; +struct nvmetcp_nvmf_cqe nvme_cqe; +struct regpair task_opaque; +__le32 reserved[6 ]; +}; + +enum nvmetcp_fw_cqes_type { +NVMETCP_FW_CQE_TYPE_NORMAL =1 , +NVMETCP_FW_CQE_TYPE_RESERVED0 , +NVMETCP_FW_CQE_TYPE_RESERVED1 , +NVMETCP_FW_CQE_TYPE_CLEANUP , +NVMETCP_FW_CQE_TYPE_DUMMY , +MAX_NVMETCP_FW_CQES_TYPE +}; + +struct ystorm_nvmetcp_task_state { +struct scsi_cached_sges data_desc; +struct scsi_sgl_params sgl_params; +__le32 resrved0; +__le32 buffer_offset; +__le16 cccid; +struct nvmetcp_dif_flags dif_flags; +u8 flags; +#define YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP_SHIFT 0 +#define YSTORM_NVMETCP_TASK_STATE_SLOW_IO_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SLOW_IO_SHIFT 1 +#define YSTORM_NVMETCP_TASK_STATE_SET_DIF_OFFSET_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SET_DIF_OFFSET_SHIFT 2 +#define YSTORM_NVMETCP_TASK_STATE_SEND_W_RSP_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SEND_W_RSP_SHIFT 3 +}; + +struct ystorm_nvmetcp_task_rxmit_opt { +__le32 reserved[4 ]; +}; + +struct nvmetcp_task_hdr { +__le32 reg[18 ]; +}; + +struct nvmetcp_task_hdr_aligned { +struct nvmetcp_task_hdr task_hdr; +__le32 reserved[2 ];/* HSI_COMMENT: Align to QREG */ +}; + +struct e5_tdif_task_context { +__le32 reserved[16 ]; +}; + +struct e5_rdif_task_context { +__le32 reserved[12 ]; +}; + +struct ystorm_nvmetcp_task_st_ctx { +struct ystorm_nvmetcp_task_state state; +struct ystorm_nvmetcp_task_rxmit_opt rxmit_opt; +struct nvmetcp_task_hdr_aligned pdu_hdr; +}; + +struct mstorm_nvmetcp_task_st_ctx { +struct scsi_cached_sges data_desc; +struct scsi_sgl_params sgl_params; +__le32 rem_task_size; +__le32 data_buffer_offset; +u8 task_type; +struct nvmetcp_dif_flags dif_flags; +__le16 dif_task_icid; +struct regpair reserved0; +__le32 expected_itt; +__le32 reserved1; +}; + +struct nvmetcp_reg1 { +__le32 reg1_map; +#define NVMETCP_REG1_NUM_SGES_MASK 0xF +#define NVMETCP_REG1_NUM_SGES_SHIFT 0 +#define NVMETCP_REG1_RESERVED1_MASK 0xFFFFFFF +#define NVMETCP_REG1_RESERVED1_SHIFT 4 +}; + +struct ustorm_nvmetcp_task_st_ctx { +__le32 rem_rcv_len; +__le32 exp_data_transfer_len; +__le32 exp_data_sn; +struct regpair reserved0; +struct nvmetcp_reg1 reg1; +u8 flags2; +#define USTORM_NVMETCP_TASK_ST_CTX_AHS_EXIST_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_AHS_EXIST_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_RESERVED1_MASK 0x7F +#define USTORM_NVMETCP_TASK_ST_CTX_RESERVED1_SHIFT 1 +struct nvmetcp_dif_flags dif_flags; +__le16 reserved3; +__le16 tqe_opaque[2 ]; +__le32 reserved5; +__le32 nvme_tcp_opaque_lo; +__le32 nvme_tcp_opaque_hi; +u8 task_type; +u8 error_flags; +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_DIGEST_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_DIGEST_ERROR_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_TRUNCATED_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_TRUNCATED_ERROR_SHIFT 1 +#define USTORM_NVMETCP_TASK_ST_CTX_UNDER_RUN_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_UNDER_RUN_ERROR_SHIFT 2 +#define USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP_SHIFT 3 +u8 flags; +#define USTORM_NVMETCP_TASK_ST_CTX_CQE_WRITE_MASK 0x3 +#define USTORM_NVMETCP_TASK_ST_CTX_CQE_WRITE_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP_SHIFT 2 +#define USTORM_NVMETCP_TASK_ST_CTX_Q0_R2TQE_WRITE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_Q0_R2TQE_WRITE_SHIFT 3 +#define USTORM_NVMETCP_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_SHIFT 4 +#define USTORM_NVMETCP_TASK_ST_CTX_HQ_SCANNED_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_HQ_SCANNED_DONE_SHIFT 5 +#define USTORM_NVMETCP_TASK_ST_CTX_R2T2RECV_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_R2T2RECV_DONE_SHIFT 6 +u8 cq_rss_number; +}; + +struct e5_ystorm_nvmetcp_task_ag_ctx { +u8 reserved/* cdu_validation */ ; +u8 byte1/* state_and_core_id */ ; +__le16 word0/* icid */ ; +u8 flags0; +u8 flags1; +u8 flags2; +u8 flags3; +__le32 TTT; +u8 byte2; +u8 byte3; +u8 byte4; +u8 e4_reserved7; +}; + +struct e5_mstorm_nvmetcp_task_ag_ctx { +u8 cdu_validation; +u8 byte1; +__le16 task_cid; +u8 flags0; +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_MASK 0xF +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_SHIFT 0 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_SHIFT 4 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_SHIFT 5 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_VALID_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_VALID_SHIFT 6 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_FLAG_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_FLAG_SHIFT 7 +u8 flags1; +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_SHIFT 0 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1_SHIFT 2 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF2_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF2_SHIFT 4 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_EN_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_EN_SHIFT 6 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1EN_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1EN_SHIFT 7 +u8 flags2; +u8 flags3; +__le32 reg0; +u8 byte2; +u8 byte3; +u8 byte4; +u8 e4_reserved7; +}; + +struct e5_ustorm_nvmetcp_task_ag_ctx { +u8 reserved; +u8 state_and_core_id; +__le16 icid; +u8 flags0; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_MASK 0xF +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_SHIFT 5 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_SHIFT 6 +u8 flags1; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RESERVED1_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RESERVED1_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_SHIFT 6 +u8 flags2; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_EN_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DISABLE_DATA_ACKED_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DISABLE_DATA_ACKED_SHIFT 1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_EN_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3EN_SHIFT 3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_SHIFT 5 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RULE1EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RULE1EN_SHIFT 6 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_SHIFT 7 +u8 flags3; +u8 flags4; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED5_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED5_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED6_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED6_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED7_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED7_SHIFT 3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_TYPE_MASK 0xF +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_TYPE_SHIFT 4 +u8 byte2; +u8 byte3; +u8 e4_reserved8; +__le32 dif_err_intervals; +__le32 dif_error_1st_interval; +__le32 rcv_cont_len; +__le32 exp_cont_len; +__le32 total_data_acked; +__le32 exp_data_acked; +__le16 word1; +__le16 next_tid; +__le32 hdr_residual_count; +__le32 exp_r2t_sn; +}; + +struct e5_nvmetcp_task_context { +struct ystorm_nvmetcp_task_st_ctx ystorm_st_context; +struct e5_ystorm_nvmetcp_task_ag_ctx ystorm_ag_context; +struct regpair ystorm_ag_padding[2 ]; +struct e5_tdif_task_context tdif_context; +struct e5_mstorm_nvmetcp_task_ag_ctx mstorm_ag_context; +struct regpair mstorm_ag_padding[2 ]; +struct e5_ustorm_nvmetcp_task_ag_ctx ustorm_ag_context; +struct regpair ustorm_ag_padding[2 ]; +struct mstorm_nvmetcp_task_st_ctx mstorm_st_context; +struct regpair mstorm_st_padding[2 ]; +struct ustorm_nvmetcp_task_st_ctx ustorm_st_context; +struct regpair ustorm_st_padding[2 ]; +struct e5_rdif_task_context rdif_context; +}; + +/* NVMe TCP common header in network order */ +struct nvmetcp_common_hdr { +u8 pdo; +u8 hlen; +u8 flags; +#define NVMETCP_COMMON_HDR_HDGSTF_MASK 0x1 +#define NVMETCP_COMMON_HDR_HDGSTF_SHIFT 0 +#define NVMETCP_COMMON_HDR_DDGSTF_MASK 0x1 +#define NVMETCP_COMMON_HDR_DDGSTF_SHIFT 1 +#define NVMETCP_COMMON_HDR_LAST_PDU_MASK 0x1 +#define NVMETCP_COMMON_HDR_LAST_PDU_SHIFT 2 +#define NVMETCP_COMMON_HDR_SUCCESS_MASK 0x1 +#define NVMETCP_COMMON_HDR_SUCCESS_SHIFT 3 +#define NVMETCP_COMMON_HDR_RESERVED_MASK 0xF +#define NVMETCP_COMMON_HDR_RESERVED_SHIFT 4 +u8 pdu_type; +__le32 plen_swapped; +}; + +/* We don't need the entire 128 Bytes of the ICReq, hence passing only 16 +* Bytes to the FW in network order. +*/ +struct nvmetcp_icreq_hdr_psh { +__le16 pfv; +u8 hpda; +u8 digest; +#define NVMETCP_ICREQ_HDR_PSH_16B_HDGST_EN_MASK 0x1 +#define NVMETCP_ICREQ_HDR_PSH_16B_HDGST_EN_SHIFT 0 +#define NVMETCP_ICREQ_HDR_PSH_16B_DDGST_EN_MASK 0x1 +#define NVMETCP_ICREQ_HDR_PSH_16B_DDGST_EN_SHIFT 1 +#define NVMETCP_ICREQ_HDR_PSH_16B_RESERVED1_MASK 0x3F +#define NVMETCP_ICREQ_HDR_PSH_16B_RESERVED1_SHIFT 2 +__le32 maxr2t; +u8 reserved[8 ]; +}; + +struct nvmetcp_cmd_capsule_hdr_psh { +__le32 raw_swapped[16 ]; +}; + +struct nvmetcp_cmd_capsule_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_cmd_capsule_hdr_psh pshdr; +}; + +struct nvmetcp_data_hdr { +__le32 data[6 ]; +}; + +struct nvmetcp_h2c_hdr_psh { +__le16 ttag_swapped; +__le16 command_id_swapped; +__le32 data_offset_swapped; +__le32 data_length_swapped; +__le32 reserved1; +}; + +struct nvmetcp_h2c_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_h2c_hdr_psh pshdr; +}; + +/* We don't need the entire 128 Bytes of the ICResp, hence passing only 16 +* Bytes to the FW in network order. +*/ +struct nvmetcp_icresp_hdr_psh { +u8 digest; +#define NVMETCP_ICRESP_HDR_PSH_16B_HDGST_EN_MASK 0x1 +#define NVMETCP_ICRESP_HDR_PSH_16B_HDGST_EN_SHIFT 0 +#define NVMETCP_ICRESP_HDR_PSH_16B_DDGST_EN_MASK 0x1 +#define NVMETCP_ICRESP_HDR_PSH_16B_DDGST_EN_SHIFT 1 +u8 cpda; +__le16 pfv_swapped; +__le32 maxdata_swapped; +__le16 reserved2[4 ]; +}; + +struct nvmetcp_init_conn_req_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_icreq_hdr_psh pshdr; +}; + +#endif /* __NVMETCP_COMMON__*/
include/linux/qed/qed_nvmetcp_if.h +37 -0
@@ -5,6 +5,8 @@#define _QED_NVMETCP_IF_H#include <linux/types.h> #include <linux/qed/qed_if.h> +#include <linux/qed/storage_common.h> +#include <linux/qed/nvmetcp_common.h> #define QED_NVMETCP_MAX_IO_SIZE 0x800000
@@ -73,6 +75,41 @@ struct qed_nvmetcp_cb_ops {struct qed_common_cb_ops common; }; +struct nvmetcp_sge { +struct regpair sge_addr;/* SGE address */ +__le32 sge_len;/* SGE length */ +__le32 reserved; +}; + +/* IO path HSI function SGL params */ +struct storage_sgl_task_params { +struct nvmetcp_sge *sgl; +struct regpair sgl_phys_addr; +u32 total_buffer_size; +u16 num_sges; +bool small_mid_sge; +}; + +/* IO path HSI function FW task context params */ +struct nvmetcp_task_params { +void *context;/* Output parameter - set/filled by the HSI function */ +struct nvmetcp_wqe *sqe; +u32 tx_io_size;/* in bytes (Without DIF, if exists) */ +u32 rx_io_size;/* in bytes (Without DIF, if exists) */ +u16 conn_icid; +u16 itid; +struct regpair opq;/* qedn_task_ctx address */ +u16 host_cccid; +u8 cq_rss_number; +bool send_write_incapsule; +}; + +/* IO path HSI function FW conn level input params */ + +struct nvmetcp_conn_params { +u32 max_burst_length; +}; +/** * struct qed_nvmetcp_ops - qed NVMeTCP operations. * @common: common operations pointer
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 05/27] qed: Add NVMeTCP Offload IO Level FW and HW HSI
Quoted 81 lines · Shai Malin
This patch introduces the NVMeTCP Offload FW and HW HSI in order to initialize the IO level configuration into a per IO HW resource ("task") as part of the IO path flow.
Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- include/linux/qed/nvmetcp_common.h | 418 ++++++++++++++++++++++++++++- include/linux/qed/qed_nvmetcp_if.h | 37 +++ 2 files changed, 454 insertions(+), 1 deletion(-)include/linux/qed/nvmetcp_common.h +50
-1@@ -7,6 +7,7 @@#include "tcp_common.h" #define NVMETCP_SLOW_PATH_LAYER_CODE (6) +#define NVMETCP_WQE_NUM_SGES_SLOWIO (0xf)/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {@@ -194,4 +195,419 @@ struct nvmetcp_wqe {#define NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD_SHIFT 24 }; -#endif /* __NVMETCP_COMMON__ */ +struct nvmetcp_host_cccid_itid_entry { +__le16 itid; +}; + +struct nvmetcp_connect_done_results { +__le16 icid; +__le16 conn_id; +struct tcp_ulp_connect_done_params params; +}; + +struct nvmetcp_eqe_data { +__le16 icid; +__le16 conn_id; +__le16 reserved; +u8 error_code; +u8 error_pdu_opcode_reserved; +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_MASK 0x3F +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_SHIFT 0 +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_VALID_MASK 0x1 +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_VALID_SHIFT 6 +#define NVMETCP_EQE_DATA_RESERVED0_MASK 0x1 +#define NVMETCP_EQE_DATA_RESERVED0_SHIFT 7 +}; + +enum nvmetcp_task_type { +NVMETCP_TASK_TYPE_HOST_WRITE , +NVMETCP_TASK_TYPE_HOST_READ , +NVMETCP_TASK_TYPE_INIT_CONN_REQUEST , +NVMETCP_TASK_TYPE_RESERVED0 , +NVMETCP_TASK_TYPE_CLEANUP , +NVMETCP_TASK_TYPE_HOST_READ_NO_CQE , +MAX_NVMETCP_TASK_TYPE +}; + +struct nvmetcp_db_data { +u8 params; +#define NVMETCP_DB_DATA_DEST_MASK 0x3/* destination of doorbell (use enum db_dest) */ +#define NVMETCP_DB_DATA_DEST_SHIFT 0 +#define NVMETCP_DB_DATA_AGG_CMD_MASK 0x3/* aggregative command to CM (use enum db_agg_cmd_sel) */ +#define NVMETCP_DB_DATA_AGG_CMD_SHIFT 2 +#define NVMETCP_DB_DATA_BYPASS_EN_MASK 0x1/* enable QM bypass */ +#define NVMETCP_DB_DATA_BYPASS_EN_SHIFT 4 +#define NVMETCP_DB_DATA_RESERVED_MASK 0x1 +#define NVMETCP_DB_DATA_RESERVED_SHIFT 5 +#define NVMETCP_DB_DATA_AGG_VAL_SEL_MASK 0x3/* aggregative value selection */ +#define NVMETCP_DB_DATA_AGG_VAL_SEL_SHIFT 6 +u8 agg_flags;/* bit for every DQ counter flags in CM context that DQ can increment */ +__le16 sq_prod; +};
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 256
Quoted 10 lines
include/linux/qed/nvmetcp_common.h +10
-0+ +struct nvmetcp_fw_cqe_error_bitmap { +u8 cqe_error_status_bits; +#define CQE_ERROR_BITMAP_DIF_ERR_BITS_MASK 0x7 +#define CQE_ERROR_BITMAP_DIF_ERR_BITS_SHIFT 0 +#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_MASK 0x1 +#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_SHIFT 3 +#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_MASK 0x1 +#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_SHIFT 4 +};
Why exactly do you need a struct here?
For just one 8 bit value?
Quoted 90 lines
include/linux/qed/nvmetcp_common.h +90
-0+ > +struct nvmetcp_nvmf_cqe { +__le32 reserved[4 ]; +}; + +struct nvmetcp_fw_cqe_data { +struct nvmetcp_nvmf_cqe nvme_cqe; +struct regpair task_opaque; +__le32 reserved[6 ]; +}; + +struct nvmetcp_fw_cqe { +__le16 conn_id; +u8 cqe_type; +struct nvmetcp_fw_cqe_error_bitmap error_bitmap; +__le16 itid; +u8 task_type; +u8 fw_dbg_field; +u8 caused_conn_err; +u8 reserved0[3 ]; +__le32 reserved1; +struct nvmetcp_nvmf_cqe nvme_cqe; +struct regpair task_opaque; +__le32 reserved[6 ]; +}; + +enum nvmetcp_fw_cqes_type { +NVMETCP_FW_CQE_TYPE_NORMAL =1 , +NVMETCP_FW_CQE_TYPE_RESERVED0 , +NVMETCP_FW_CQE_TYPE_RESERVED1 , +NVMETCP_FW_CQE_TYPE_CLEANUP , +NVMETCP_FW_CQE_TYPE_DUMMY , +MAX_NVMETCP_FW_CQES_TYPE +}; + +struct ystorm_nvmetcp_task_state { +struct scsi_cached_sges data_desc; +struct scsi_sgl_params sgl_params; +__le32 resrved0; +__le32 buffer_offset; +__le16 cccid; +struct nvmetcp_dif_flags dif_flags; +u8 flags; +#define YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP_SHIFT 0 +#define YSTORM_NVMETCP_TASK_STATE_SLOW_IO_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SLOW_IO_SHIFT 1 +#define YSTORM_NVMETCP_TASK_STATE_SET_DIF_OFFSET_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SET_DIF_OFFSET_SHIFT 2 +#define YSTORM_NVMETCP_TASK_STATE_SEND_W_RSP_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SEND_W_RSP_SHIFT 3 +}; + +struct ystorm_nvmetcp_task_rxmit_opt { +__le32 reserved[4 ]; +}; + +struct nvmetcp_task_hdr { +__le32 reg[18 ]; +}; + +struct nvmetcp_task_hdr_aligned { +struct nvmetcp_task_hdr task_hdr; +__le32 reserved[2 ];/* HSI_COMMENT: Align to QREG */ +}; + +struct e5_tdif_task_context { +__le32 reserved[16 ]; +}; + +struct e5_rdif_task_context { +__le32 reserved[12 ]; +}; + +struct ystorm_nvmetcp_task_st_ctx { +struct ystorm_nvmetcp_task_state state; +struct ystorm_nvmetcp_task_rxmit_opt rxmit_opt; +struct nvmetcp_task_hdr_aligned pdu_hdr; +}; + +struct mstorm_nvmetcp_task_st_ctx { +struct scsi_cached_sges data_desc; +struct scsi_sgl_params sgl_params; +__le32 rem_task_size; +__le32 data_buffer_offset; +u8 task_type; +struct nvmetcp_dif_flags dif_flags; +__le16 dif_task_icid; +struct regpair reserved0; +__le32 expected_itt; +__le32 reserved1;
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 357
Quoted 10 lines
include/linux/qed/nvmetcp_common.h +10
-0+}; + +struct nvmetcp_reg1 { +__le32 reg1_map; +#define NVMETCP_REG1_NUM_SGES_MASK 0xF +#define NVMETCP_REG1_NUM_SGES_SHIFT 0 +#define NVMETCP_REG1_RESERVED1_MASK 0xFFFFFFF +#define NVMETCP_REG1_RESERVED1_SHIFT 4 +}; +
Similar here; it is 32 bits, true, but still just a single value.
Quoted 182 lines
include/linux/qed/nvmetcp_common.h +182
-0+struct ustorm_nvmetcp_task_st_ctx { +__le32 rem_rcv_len; +__le32 exp_data_transfer_len; +__le32 exp_data_sn; +struct regpair reserved0; +struct nvmetcp_reg1 reg1; +u8 flags2; +#define USTORM_NVMETCP_TASK_ST_CTX_AHS_EXIST_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_AHS_EXIST_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_RESERVED1_MASK 0x7F +#define USTORM_NVMETCP_TASK_ST_CTX_RESERVED1_SHIFT 1 +struct nvmetcp_dif_flags dif_flags; +__le16 reserved3; +__le16 tqe_opaque[2 ]; +__le32 reserved5; +__le32 nvme_tcp_opaque_lo; +__le32 nvme_tcp_opaque_hi; +u8 task_type; +u8 error_flags; +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_DIGEST_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_DIGEST_ERROR_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_TRUNCATED_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_TRUNCATED_ERROR_SHIFT 1 +#define USTORM_NVMETCP_TASK_ST_CTX_UNDER_RUN_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_UNDER_RUN_ERROR_SHIFT 2 +#define USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP_SHIFT 3 +u8 flags; +#define USTORM_NVMETCP_TASK_ST_CTX_CQE_WRITE_MASK 0x3 +#define USTORM_NVMETCP_TASK_ST_CTX_CQE_WRITE_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP_SHIFT 2 +#define USTORM_NVMETCP_TASK_ST_CTX_Q0_R2TQE_WRITE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_Q0_R2TQE_WRITE_SHIFT 3 +#define USTORM_NVMETCP_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_SHIFT 4 +#define USTORM_NVMETCP_TASK_ST_CTX_HQ_SCANNED_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_HQ_SCANNED_DONE_SHIFT 5 +#define USTORM_NVMETCP_TASK_ST_CTX_R2T2RECV_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_R2T2RECV_DONE_SHIFT 6 +u8 cq_rss_number; +}; + +struct e5_ystorm_nvmetcp_task_ag_ctx { +u8 reserved/* cdu_validation */ ; +u8 byte1/* state_and_core_id */ ; +__le16 word0/* icid */ ; +u8 flags0; +u8 flags1; +u8 flags2; +u8 flags3; +__le32 TTT; +u8 byte2; +u8 byte3; +u8 byte4; +u8 e4_reserved7; +}; + +struct e5_mstorm_nvmetcp_task_ag_ctx { +u8 cdu_validation; +u8 byte1; +__le16 task_cid; +u8 flags0; +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_MASK 0xF +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_SHIFT 0 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_SHIFT 4 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_SHIFT 5 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_VALID_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_VALID_SHIFT 6 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_FLAG_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_FLAG_SHIFT 7 +u8 flags1; +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_SHIFT 0 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1_SHIFT 2 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF2_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF2_SHIFT 4 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_EN_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_EN_SHIFT 6 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1EN_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1EN_SHIFT 7 +u8 flags2; +u8 flags3; +__le32 reg0; +u8 byte2; +u8 byte3; +u8 byte4; +u8 e4_reserved7; +}; + +struct e5_ustorm_nvmetcp_task_ag_ctx { +u8 reserved; +u8 state_and_core_id; +__le16 icid; +u8 flags0; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_MASK 0xF +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_SHIFT 5 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_SHIFT 6 +u8 flags1; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RESERVED1_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RESERVED1_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_SHIFT 6 +u8 flags2; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_EN_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DISABLE_DATA_ACKED_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DISABLE_DATA_ACKED_SHIFT 1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_EN_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3EN_SHIFT 3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_SHIFT 5 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RULE1EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RULE1EN_SHIFT 6 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_SHIFT 7 +u8 flags3; +u8 flags4; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED5_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED5_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED6_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED6_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED7_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED7_SHIFT 3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_TYPE_MASK 0xF +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_TYPE_SHIFT 4 +u8 byte2; +u8 byte3; +u8 e4_reserved8; +__le32 dif_err_intervals; +__le32 dif_error_1st_interval; +__le32 rcv_cont_len; +__le32 exp_cont_len; +__le32 total_data_acked; +__le32 exp_data_acked; +__le16 word1; +__le16 next_tid; +__le32 hdr_residual_count; +__le32 exp_r2t_sn; +}; + +struct e5_nvmetcp_task_context { +struct ystorm_nvmetcp_task_st_ctx ystorm_st_context; +struct e5_ystorm_nvmetcp_task_ag_ctx ystorm_ag_context; +struct regpair ystorm_ag_padding[2 ]; +struct e5_tdif_task_context tdif_context; +struct e5_mstorm_nvmetcp_task_ag_ctx mstorm_ag_context; +struct regpair mstorm_ag_padding[2 ]; +struct e5_ustorm_nvmetcp_task_ag_ctx ustorm_ag_context; +struct regpair ustorm_ag_padding[2 ]; +struct mstorm_nvmetcp_task_st_ctx mstorm_st_context; +struct regpair mstorm_st_padding[2 ]; +struct ustorm_nvmetcp_task_st_ctx ustorm_st_context; +struct regpair ustorm_st_padding[2 ]; +struct e5_rdif_task_context rdif_context; +}; + +/* NVMe TCP common header in network order */ +struct nvmetcp_common_hdr { +u8 pdo; +u8 hlen; +u8 flags; +#define NVMETCP_COMMON_HDR_HDGSTF_MASK 0x1 +#define NVMETCP_COMMON_HDR_HDGSTF_SHIFT 0 +#define NVMETCP_COMMON_HDR_DDGSTF_MASK 0x1 +#define NVMETCP_COMMON_HDR_DDGSTF_SHIFT 1
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 549
Quoted 10 lines
include/linux/qed/nvmetcp_common.h +10
-0+#define NVMETCP_COMMON_HDR_LAST_PDU_MASK 0x1 +#define NVMETCP_COMMON_HDR_LAST_PDU_SHIFT 2 +#define NVMETCP_COMMON_HDR_SUCCESS_MASK 0x1 +#define NVMETCP_COMMON_HDR_SUCCESS_SHIFT 3 +#define NVMETCP_COMMON_HDR_RESERVED_MASK 0xF +#define NVMETCP_COMMON_HDR_RESERVED_SHIFT 4 +u8 pdu_type; +__le32 plen_swapped; +}; +
Why do you need to define this?
Wouldn't it be easier to use the standard 'struct nvme_tcp_hdr' and swap the bytes before sending it off?
(Or modify the firmware to do the byte-swapping itself ...)
Quoted 7 lines
include/linux/qed/nvmetcp_common.h +7
-0+/* We don't need the entire 128 Bytes of the ICReq, hence passing only 16 +* Bytes to the FW in network order. +*/ +struct nvmetcp_icreq_hdr_psh { +__le16 pfv; +u8 hpda; +u8 digest;
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 566
Quoted 10 lines
include/linux/qed/nvmetcp_common.h +10
-0+#define NVMETCP_ICREQ_HDR_PSH_16B_HDGST_EN_MASK 0x1 +#define NVMETCP_ICREQ_HDR_PSH_16B_HDGST_EN_SHIFT 0 +#define NVMETCP_ICREQ_HDR_PSH_16B_DDGST_EN_MASK 0x1 +#define NVMETCP_ICREQ_HDR_PSH_16B_DDGST_EN_SHIFT 1 +#define NVMETCP_ICREQ_HDR_PSH_16B_RESERVED1_MASK 0x3F +#define NVMETCP_ICREQ_HDR_PSH_16B_RESERVED1_SHIFT 2 +__le32 maxr2t; +u8 reserved[8 ]; +}; +
One of these short-cuts which will come back to haunt you eventually; I would consider updating the firmware to process the entire icreq.
Quoted 31 lines
include/linux/qed/nvmetcp_common.h +31
-0+struct nvmetcp_cmd_capsule_hdr_psh { +__le32 raw_swapped[16 ]; +}; + +struct nvmetcp_cmd_capsule_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_cmd_capsule_hdr_psh pshdr; +}; + +struct nvmetcp_data_hdr { +__le32 data[6 ]; +}; + +struct nvmetcp_h2c_hdr_psh { +__le16 ttag_swapped; +__le16 command_id_swapped; +__le32 data_offset_swapped; +__le32 data_length_swapped; +__le32 reserved1; +}; + +struct nvmetcp_h2c_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_h2c_hdr_psh pshdr; +}; + +/* We don't need the entire 128 Bytes of the ICResp, hence passing only 16 +* Bytes to the FW in network order. +*/ +struct nvmetcp_icresp_hdr_psh { +u8 digest;
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 607
Quoted 10 lines
include/linux/qed/nvmetcp_common.h +10
-0+#define NVMETCP_ICRESP_HDR_PSH_16B_HDGST_EN_MASK 0x1 +#define NVMETCP_ICRESP_HDR_PSH_16B_HDGST_EN_SHIFT 0 +#define NVMETCP_ICRESP_HDR_PSH_16B_DDGST_EN_MASK 0x1 +#define NVMETCP_ICRESP_HDR_PSH_16B_DDGST_EN_SHIFT 1 +u8 cpda; +__le16 pfv_swapped; +__le32 maxdata_swapped; +__le16 reserved2[4 ]; +}; +
Same here.
Quoted 52 lines
include/linux/qed/nvmetcp_common.h +6
-0+struct nvmetcp_init_conn_req_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_icreq_hdr_psh pshdr; +}; + +#endif /* __NVMETCP_COMMON__*/ include/linux/qed/qed_nvmetcp_if.h +30
-0@@ -5,6 +5,8 @@#define _QED_NVMETCP_IF_H#include <linux/types.h> #include <linux/qed/qed_if.h> +#include <linux/qed/storage_common.h> +#include <linux/qed/nvmetcp_common.h> #define QED_NVMETCP_MAX_IO_SIZE 0x800000@@ -73,6 +75,41 @@ struct qed_nvmetcp_cb_ops {struct qed_common_cb_ops common; }; +struct nvmetcp_sge { +struct regpair sge_addr;/* SGE address */ +__le32 sge_len;/* SGE length */ +__le32 reserved; +}; + +/* IO path HSI function SGL params */ +struct storage_sgl_task_params { +struct nvmetcp_sge *sgl; +struct regpair sgl_phys_addr; +u32 total_buffer_size; +u16 num_sges; +bool small_mid_sge; +}; + +/* IO path HSI function FW task context params */ +struct nvmetcp_task_params { +void *context;/* Output parameter - set/filled by the HSI function */ +struct nvmetcp_wqe *sqe; +u32 tx_io_size;/* in bytes (Without DIF, if exists) */ +u32 rx_io_size;/* in bytes (Without DIF, if exists) */ +u16 conn_icid; +u16 itid; +struct regpair opq;/* qedn_task_ctx address */ +u16 host_cccid; +u8 cq_rss_number; +bool send_write_incapsule; +};
include/linux/qed/qed_nvmetcp_if.h struct qed_nvmetcp_cb_ops { · line 115
Quoted 10 lines
include/linux/qed/qed_nvmetcp_if.h +7
-0+ +/* IO path HSI function FW conn level input params */ + +struct nvmetcp_conn_params { +u32 max_burst_length; +}; +/** * struct qed_nvmetcp_ops - qed NVMeTCP operations. * @common: common operations pointer
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 05/27] qed: Add NVMeTCP Offload IO Level FW and HW HSI
Quoted 87 lines · Hannes Reinecke
Quoted 86 lines · Shai Malin
This patch introduces the NVMeTCP Offload FW and HW HSI in order to initialize the IO level configuration into a per IO HW resource ("task") as part of the IO path flow.
Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- include/linux/qed/nvmetcp_common.h | 418 ++++++++++++++++++++++++++++- include/linux/qed/qed_nvmetcp_if.h | 37 +++ 2 files changed, 454 insertions(+), 1 deletion(-)include/linux/qed/nvmetcp_common.h +55
-1@@ -7,6 +7,7 @@#include "tcp_common.h" #define NVMETCP_SLOW_PATH_LAYER_CODE (6) +#define NVMETCP_WQE_NUM_SGES_SLOWIO (0xf)/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {@@ -194,4 +195,419 @@ struct nvmetcp_wqe {#define NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD_SHIFT 24 }; -#endif /* __NVMETCP_COMMON__ */ +struct nvmetcp_host_cccid_itid_entry { +__le16 itid; +}; + +struct nvmetcp_connect_done_results { +__le16 icid; +__le16 conn_id; +struct tcp_ulp_connect_done_params params; +}; + +struct nvmetcp_eqe_data { +__le16 icid; +__le16 conn_id; +__le16 reserved; +u8 error_code; +u8 error_pdu_opcode_reserved; +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_MASK 0x3F +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_SHIFT 0 +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_VALID_MASK 0x1 +#define NVMETCP_EQE_DATA_ERROR_PDU_OPCODE_VALID_SHIFT 6 +#define NVMETCP_EQE_DATA_RESERVED0_MASK 0x1 +#define NVMETCP_EQE_DATA_RESERVED0_SHIFT 7 +}; + +enum nvmetcp_task_type { +NVMETCP_TASK_TYPE_HOST_WRITE , +NVMETCP_TASK_TYPE_HOST_READ , +NVMETCP_TASK_TYPE_INIT_CONN_REQUEST , +NVMETCP_TASK_TYPE_RESERVED0 , +NVMETCP_TASK_TYPE_CLEANUP , +NVMETCP_TASK_TYPE_HOST_READ_NO_CQE , +MAX_NVMETCP_TASK_TYPE +}; + +struct nvmetcp_db_data { +u8 params; +#define NVMETCP_DB_DATA_DEST_MASK 0x3/* destination of doorbell (use enum db_dest) */ +#define NVMETCP_DB_DATA_DEST_SHIFT 0 +#define NVMETCP_DB_DATA_AGG_CMD_MASK 0x3/* aggregative command to CM (use enum db_agg_cmd_sel) */ +#define NVMETCP_DB_DATA_AGG_CMD_SHIFT 2 +#define NVMETCP_DB_DATA_BYPASS_EN_MASK 0x1/* enable QM bypass */ +#define NVMETCP_DB_DATA_BYPASS_EN_SHIFT 4 +#define NVMETCP_DB_DATA_RESERVED_MASK 0x1 +#define NVMETCP_DB_DATA_RESERVED_SHIFT 5 +#define NVMETCP_DB_DATA_AGG_VAL_SEL_MASK 0x3/* aggregative value selection */ +#define NVMETCP_DB_DATA_AGG_VAL_SEL_SHIFT 6 +u8 agg_flags;/* bit for every DQ counter flags in CM context that DQ can increment */ +__le16 sq_prod; +}; + +struct nvmetcp_fw_cqe_error_bitmap { +u8 cqe_error_status_bits; +#define CQE_ERROR_BITMAP_DIF_ERR_BITS_MASK 0x7 +#define CQE_ERROR_BITMAP_DIF_ERR_BITS_SHIFT 0
Quoted 9 lines
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 256
Quoted 5 lines
include/linux/qed/nvmetcp_common.h +5
-0+#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_MASK 0x1 +#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_SHIFT 3 +#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_MASK 0x1 +#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_SHIFT 4 +};Why exactly do you need a struct here?
For just one 8 bit value?
Will be fixed in v5.
Quoted 94 lines
Quoted 94 lines
include/linux/qed/nvmetcp_common.h +94
-0+ > +struct nvmetcp_nvmf_cqe { +__le32 reserved[4 ]; +}; + +struct nvmetcp_fw_cqe_data { +struct nvmetcp_nvmf_cqe nvme_cqe; +struct regpair task_opaque; +__le32 reserved[6 ]; +}; + +struct nvmetcp_fw_cqe { +__le16 conn_id; +u8 cqe_type; +struct nvmetcp_fw_cqe_error_bitmap error_bitmap; +__le16 itid; +u8 task_type; +u8 fw_dbg_field; +u8 caused_conn_err; +u8 reserved0[3 ]; +__le32 reserved1; +struct nvmetcp_nvmf_cqe nvme_cqe; +struct regpair task_opaque; +__le32 reserved[6 ]; +}; + +enum nvmetcp_fw_cqes_type { +NVMETCP_FW_CQE_TYPE_NORMAL =1 , +NVMETCP_FW_CQE_TYPE_RESERVED0 , +NVMETCP_FW_CQE_TYPE_RESERVED1 , +NVMETCP_FW_CQE_TYPE_CLEANUP , +NVMETCP_FW_CQE_TYPE_DUMMY , +MAX_NVMETCP_FW_CQES_TYPE +}; + +struct ystorm_nvmetcp_task_state { +struct scsi_cached_sges data_desc; +struct scsi_sgl_params sgl_params; +__le32 resrved0; +__le32 buffer_offset; +__le16 cccid; +struct nvmetcp_dif_flags dif_flags; +u8 flags; +#define YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP_SHIFT 0 +#define YSTORM_NVMETCP_TASK_STATE_SLOW_IO_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SLOW_IO_SHIFT 1 +#define YSTORM_NVMETCP_TASK_STATE_SET_DIF_OFFSET_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SET_DIF_OFFSET_SHIFT 2 +#define YSTORM_NVMETCP_TASK_STATE_SEND_W_RSP_MASK 0x1 +#define YSTORM_NVMETCP_TASK_STATE_SEND_W_RSP_SHIFT 3 +}; + +struct ystorm_nvmetcp_task_rxmit_opt { +__le32 reserved[4 ]; +}; + +struct nvmetcp_task_hdr { +__le32 reg[18 ]; +}; + +struct nvmetcp_task_hdr_aligned { +struct nvmetcp_task_hdr task_hdr; +__le32 reserved[2 ];/* HSI_COMMENT: Align to QREG */ +}; + +struct e5_tdif_task_context { +__le32 reserved[16 ]; +}; + +struct e5_rdif_task_context { +__le32 reserved[12 ]; +}; + +struct ystorm_nvmetcp_task_st_ctx { +struct ystorm_nvmetcp_task_state state; +struct ystorm_nvmetcp_task_rxmit_opt rxmit_opt; +struct nvmetcp_task_hdr_aligned pdu_hdr; +}; + +struct mstorm_nvmetcp_task_st_ctx { +struct scsi_cached_sges data_desc; +struct scsi_sgl_params sgl_params; +__le32 rem_task_size; +__le32 data_buffer_offset; +u8 task_type; +struct nvmetcp_dif_flags dif_flags; +__le16 dif_task_icid; +struct regpair reserved0; +__le32 expected_itt; +__le32 reserved1; +}; + +struct nvmetcp_reg1 { +__le32 reg1_map;
Quoted 8 lines
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 357
Quoted 6 lines
include/linux/qed/nvmetcp_common.h +6
-0+#define NVMETCP_REG1_NUM_SGES_MASK 0xF +#define NVMETCP_REG1_NUM_SGES_SHIFT 0 +#define NVMETCP_REG1_RESERVED1_MASK 0xFFFFFFF +#define NVMETCP_REG1_RESERVED1_SHIFT 4 +}; +Similar here; it is 32 bits, true, but still just a single value.
Will be fixed in v5.
Quoted 188 lines
Quoted 188 lines
include/linux/qed/nvmetcp_common.h +187
-0+struct ustorm_nvmetcp_task_st_ctx { +__le32 rem_rcv_len; +__le32 exp_data_transfer_len; +__le32 exp_data_sn; +struct regpair reserved0; +struct nvmetcp_reg1 reg1; +u8 flags2; +#define USTORM_NVMETCP_TASK_ST_CTX_AHS_EXIST_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_AHS_EXIST_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_RESERVED1_MASK 0x7F +#define USTORM_NVMETCP_TASK_ST_CTX_RESERVED1_SHIFT 1 +struct nvmetcp_dif_flags dif_flags; +__le16 reserved3; +__le16 tqe_opaque[2 ]; +__le32 reserved5; +__le32 nvme_tcp_opaque_lo; +__le32 nvme_tcp_opaque_hi; +u8 task_type; +u8 error_flags; +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_DIGEST_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_DIGEST_ERROR_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_TRUNCATED_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_DATA_TRUNCATED_ERROR_SHIFT 1 +#define USTORM_NVMETCP_TASK_ST_CTX_UNDER_RUN_ERROR_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_UNDER_RUN_ERROR_SHIFT 2 +#define USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP_SHIFT 3 +u8 flags; +#define USTORM_NVMETCP_TASK_ST_CTX_CQE_WRITE_MASK 0x3 +#define USTORM_NVMETCP_TASK_ST_CTX_CQE_WRITE_SHIFT 0 +#define USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP_SHIFT 2 +#define USTORM_NVMETCP_TASK_ST_CTX_Q0_R2TQE_WRITE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_Q0_R2TQE_WRITE_SHIFT 3 +#define USTORM_NVMETCP_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_SHIFT 4 +#define USTORM_NVMETCP_TASK_ST_CTX_HQ_SCANNED_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_HQ_SCANNED_DONE_SHIFT 5 +#define USTORM_NVMETCP_TASK_ST_CTX_R2T2RECV_DONE_MASK 0x1 +#define USTORM_NVMETCP_TASK_ST_CTX_R2T2RECV_DONE_SHIFT 6 +u8 cq_rss_number; +}; + +struct e5_ystorm_nvmetcp_task_ag_ctx { +u8 reserved/* cdu_validation */ ; +u8 byte1/* state_and_core_id */ ; +__le16 word0/* icid */ ; +u8 flags0; +u8 flags1; +u8 flags2; +u8 flags3; +__le32 TTT; +u8 byte2; +u8 byte3; +u8 byte4; +u8 e4_reserved7; +}; + +struct e5_mstorm_nvmetcp_task_ag_ctx { +u8 cdu_validation; +u8 byte1; +__le16 task_cid; +u8 flags0; +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_MASK 0xF +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_SHIFT 0 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_SHIFT 4 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_SHIFT 5 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_VALID_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_VALID_SHIFT 6 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_FLAG_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_FLAG_SHIFT 7 +u8 flags1; +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_SHIFT 0 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1_SHIFT 2 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF2_MASK 0x3 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF2_SHIFT 4 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_EN_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_TASK_CLEANUP_CF_EN_SHIFT 6 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1EN_MASK 0x1 +#define E5_MSTORM_NVMETCP_TASK_AG_CTX_CF1EN_SHIFT 7 +u8 flags2; +u8 flags3; +__le32 reg0; +u8 byte2; +u8 byte3; +u8 byte4; +u8 e4_reserved7; +}; + +struct e5_ustorm_nvmetcp_task_ag_ctx { +u8 reserved; +u8 state_and_core_id; +__le16 icid; +u8 flags0; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_MASK 0xF +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONNECTION_TYPE_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_EXIST_IN_QM0_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CONN_CLEAR_SQ_FLAG_SHIFT 5 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_SHIFT 6 +u8 flags1; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RESERVED1_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RESERVED1_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_SHIFT 6 +u8 flags2; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_HQ_SCANNED_CF_EN_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DISABLE_DATA_ACKED_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DISABLE_DATA_ACKED_SHIFT 1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV_EN_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CF3EN_SHIFT 3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN_SHIFT 4 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_SHIFT 5 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RULE1EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_RULE1EN_SHIFT 6 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_SHIFT 7 +u8 flags3; +u8 flags4; +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED5_MASK 0x3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED5_SHIFT 0 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED6_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED6_SHIFT 2 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED7_MASK 0x1 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_E4_RESERVED7_SHIFT 3 +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_TYPE_MASK 0xF +#define E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_TYPE_SHIFT 4 +u8 byte2; +u8 byte3; +u8 e4_reserved8; +__le32 dif_err_intervals; +__le32 dif_error_1st_interval; +__le32 rcv_cont_len; +__le32 exp_cont_len; +__le32 total_data_acked; +__le32 exp_data_acked; +__le16 word1; +__le16 next_tid; +__le32 hdr_residual_count; +__le32 exp_r2t_sn; +}; + +struct e5_nvmetcp_task_context { +struct ystorm_nvmetcp_task_st_ctx ystorm_st_context; +struct e5_ystorm_nvmetcp_task_ag_ctx ystorm_ag_context; +struct regpair ystorm_ag_padding[2 ]; +struct e5_tdif_task_context tdif_context; +struct e5_mstorm_nvmetcp_task_ag_ctx mstorm_ag_context; +struct regpair mstorm_ag_padding[2 ]; +struct e5_ustorm_nvmetcp_task_ag_ctx ustorm_ag_context; +struct regpair ustorm_ag_padding[2 ]; +struct mstorm_nvmetcp_task_st_ctx mstorm_st_context; +struct regpair mstorm_st_padding[2 ]; +struct ustorm_nvmetcp_task_st_ctx ustorm_st_context; +struct regpair ustorm_st_padding[2 ]; +struct e5_rdif_task_context rdif_context; +}; + +/* NVMe TCP common header in network order */ +struct nvmetcp_common_hdr { +u8 pdo; +u8 hlen; +u8 flags; +#define NVMETCP_COMMON_HDR_HDGSTF_MASK 0x1 +#define NVMETCP_COMMON_HDR_HDGSTF_SHIFT 0 +#define NVMETCP_COMMON_HDR_DDGSTF_MASK 0x1 +#define NVMETCP_COMMON_HDR_DDGSTF_SHIFT 1 +#define NVMETCP_COMMON_HDR_LAST_PDU_MASK 0x1 +#define NVMETCP_COMMON_HDR_LAST_PDU_SHIFT 2 +#define NVMETCP_COMMON_HDR_SUCCESS_MASK 0x1 +#define NVMETCP_COMMON_HDR_SUCCESS_SHIFT 3 +#define NVMETCP_COMMON_HDR_RESERVED_MASK 0xF
Quoted 8 lines
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 549
Quoted 5 lines
include/linux/qed/nvmetcp_common.h +5
-0+#define NVMETCP_COMMON_HDR_RESERVED_SHIFT 4 +u8 pdu_type; +__le32 plen_swapped; +}; +Why do you need to define this?
Wouldn't it be easier to use the standard 'structnvme_tcp_hdr' and swap the bytes before sending it off?
We will change it and use the standard 'struct nvme_tcp_hdr'.
Quoted 15 lines
(Or modify the firmware to do the byte-swapping itself ...)
Quoted 12 lines
include/linux/qed/nvmetcp_common.h +12
-0+/* We don't need the entire 128 Bytes of the ICReq, hence passing only 16 +* Bytes to the FW in network order. +*/ +struct nvmetcp_icreq_hdr_psh { +__le16 pfv; +u8 hpda; +u8 digest; +#define NVMETCP_ICREQ_HDR_PSH_16B_HDGST_EN_MASK 0x1 +#define NVMETCP_ICREQ_HDR_PSH_16B_HDGST_EN_SHIFT 0 +#define NVMETCP_ICREQ_HDR_PSH_16B_DDGST_EN_MASK 0x1 +#define NVMETCP_ICREQ_HDR_PSH_16B_DDGST_EN_SHIFT 1 +#define NVMETCP_ICREQ_HDR_PSH_16B_RESERVED1_MASK 0x3F
Quoted 8 lines
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 566
Quoted 5 lines
include/linux/qed/nvmetcp_common.h +5
-0+#define NVMETCP_ICREQ_HDR_PSH_16B_RESERVED1_SHIFT 2 +__le32 maxr2t; +u8 reserved[8 ]; +}; +One of these short-cuts which will come back to haunt you eventually; I would consider updating the firmware to process the entire icreq.
We will change it and use the standard 'struct nvme_tcp_icreq_pdu'.
Quoted 36 lines
Quoted 36 lines
include/linux/qed/nvmetcp_common.h +35
-0+struct nvmetcp_cmd_capsule_hdr_psh { +__le32 raw_swapped[16 ]; +}; + +struct nvmetcp_cmd_capsule_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_cmd_capsule_hdr_psh pshdr; +}; + +struct nvmetcp_data_hdr { +__le32 data[6 ]; +}; + +struct nvmetcp_h2c_hdr_psh { +__le16 ttag_swapped; +__le16 command_id_swapped; +__le32 data_offset_swapped; +__le32 data_length_swapped; +__le32 reserved1; +}; + +struct nvmetcp_h2c_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_h2c_hdr_psh pshdr; +}; + +/* We don't need the entire 128 Bytes of the ICResp, hence passing only 16 +* Bytes to the FW in network order. +*/ +struct nvmetcp_icresp_hdr_psh { +u8 digest; +#define NVMETCP_ICRESP_HDR_PSH_16B_HDGST_EN_MASK 0x1 +#define NVMETCP_ICRESP_HDR_PSH_16B_HDGST_EN_SHIFT 0 +#define NVMETCP_ICRESP_HDR_PSH_16B_DDGST_EN_MASK 0x1 +#define NVMETCP_ICRESP_HDR_PSH_16B_DDGST_EN_SHIFT 1
Quoted 8 lines
include/linux/qed/nvmetcp_common.h struct nvmetcp_wqe { · line 607
Quoted 6 lines
include/linux/qed/nvmetcp_common.h +6
-0+u8 cpda; +__le16 pfv_swapped; +__le32 maxdata_swapped; +__le16 reserved2[4 ]; +}; +Same here.
We will change it.
Quoted 70 lines
Quoted 52 lines
include/linux/qed/nvmetcp_common.h +6
-0+struct nvmetcp_init_conn_req_hdr { +struct nvmetcp_common_hdr chdr; +struct nvmetcp_icreq_hdr_psh pshdr; +}; + +#endif /* __NVMETCP_COMMON__*/ include/linux/qed/qed_nvmetcp_if.h +30
-0@@ -5,6 +5,8 @@#define _QED_NVMETCP_IF_H#include <linux/types.h> #include <linux/qed/qed_if.h> +#include <linux/qed/storage_common.h> +#include <linux/qed/nvmetcp_common.h> #define QED_NVMETCP_MAX_IO_SIZE 0x800000@@ -73,6 +75,41 @@ struct qed_nvmetcp_cb_ops {struct qed_common_cb_ops common; }; +struct nvmetcp_sge { +struct regpair sge_addr;/* SGE address */ +__le32 sge_len;/* SGE length */ +__le32 reserved; +}; + +/* IO path HSI function SGL params */ +struct storage_sgl_task_params { +struct nvmetcp_sge *sgl; +struct regpair sgl_phys_addr; +u32 total_buffer_size; +u16 num_sges; +bool small_mid_sge; +}; + +/* IO path HSI function FW task context params */ +struct nvmetcp_task_params { +void *context;/* Output parameter - set/filled by the HSI function */ +struct nvmetcp_wqe *sqe; +u32 tx_io_size;/* in bytes (Without DIF, if exists) */ +u32 rx_io_size;/* in bytes (Without DIF, if exists) */ +u16 conn_icid; +u16 itid; +struct regpair opq;/* qedn_task_ctx address */ +u16 host_cccid; +u8 cq_rss_number; +bool send_write_incapsule; +};include/linux/qed/qed_nvmetcp_if.h struct qed_nvmetcp_cb_ops { · line 115
Quoted 10 lines
include/linux/qed/qed_nvmetcp_if.h +7
-0+ +/* IO path HSI function FW conn level input params */ + +struct nvmetcp_conn_params { +u32 max_burst_length; +}; +/** * struct qed_nvmetcp_ops - qed NVMeTCP operations. * @common: common operations pointer Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 6/27 qed: Add NVMeTCP Offload IO Level FW Initializations
In reply to Shai MalinThis patch introduces the NVMeTCP FW initializations which is used to initialize the IO level configuration into a per IO HW resource ("task") as part of the IO path flow.
This includes:
- Write IO FW initialization
- Read IO FW initialization.
- IC-Req and IC-Resp FW exchange.
- FW Cleanup flow (Flush IO).
--- drivers/net/ethernet/qlogic/qed/Makefile | 5 +- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 7 +- .../qlogic/qed/qed_nvmetcp_fw_funcs.c | 372 ++++++++++++++++++ .../qlogic/qed/qed_nvmetcp_fw_funcs.h | 43 ++ include/linux/qed/nvmetcp_common.h | 3 + include/linux/qed/qed_nvmetcp_if.h | 17 + 6 files changed, 445 insertions(+), 2 deletions(-) create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h
drivers/net/ethernet/qlogic/qed/Makefile +4 -1
@@ -28,7 +28,10 @@ qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o qed-$(CONFIG_QED_LL2) += qed_ll2.o qed-$(CONFIG_QED_OOO) += qed_ooo.o -qed-$(CONFIG_QED_NVMETCP) += qed_nvmetcp.o +qed-$(CONFIG_QED_NVMETCP) += \ + qed_nvmetcp.o \ + qed_nvmetcp_fw_funcs.o \ + qed_nvmetcp_ip_services.o qed-$(CONFIG_QED_RDMA) += \ qed_iwarp.o \
drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +6 -1
@@ -27,6 +27,7 @@#include "qed_mcp.h" #include "qed_sp.h" #include "qed_reg_addr.h" +#include "qed_nvmetcp_fw_funcs.h" static int qed_nvmetcp_async_event(struct qed_hwfn *p_hwfn, u8 fw_event_code, u16 echo, union event_ring_data *data,
@@ -848,7 +849,11 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .remove_src_tcp_port_filter = &qed_llh_remove_src_tcp_port_filter, .add_dst_tcp_port_filter = &qed_llh_add_dst_tcp_port_filter, .remove_dst_tcp_port_filter = &qed_llh_remove_dst_tcp_port_filter, - .clear_all_filters = &qed_llh_clear_all_filters + .clear_all_filters = &qed_llh_clear_all_filters, + .init_read_io = &init_nvmetcp_host_read_task, + .init_write_io = &init_nvmetcp_host_write_task, + .init_icreq_exchange = &init_nvmetcp_init_conn_req_task, + .init_task_cleanup = &init_cleanup_task_nvmetcp };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void )
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c new file +372 -0
372 lines not on this page · raw message
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h new file +43 -0
43 lines not on this page · raw message
include/linux/qed/nvmetcp_common.h +3 -0
@@ -9,6 +9,9 @@#define NVMETCP_SLOW_PATH_LAYER_CODE (6)#define NVMETCP_WQE_NUM_SGES_SLOWIO (0xf) +#define QED_NVMETCP_CMD_HDR_SIZE 72 +#define QED_NVMETCP_CMN_HDR_SIZE 24 +/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {__le16 half_way_close_timeout;
include/linux/qed/qed_nvmetcp_if.h +17 -0
@@ -220,6 +220,23 @@ struct qed_nvmetcp_ops {void (*remove_dst_tcp_port_filter)(struct qed_dev *cdev,u16 dest_port);void (*clear_all_filters)(struct qed_dev *cdev); + +void (*init_read_io)(struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void (*init_write_io)(struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void (*init_icreq_exchange)(struct nvmetcp_task_params *task_params, +struct nvmetcp_init_conn_req_hdr *init_conn_req_pdu_hdr, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params); + +void (*init_task_cleanup)(struct nvmetcp_task_params *task_params); };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void );
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 06/27] qed: Add NVMeTCP Offload IO Level FW Initializations
Quoted 228 lines · Shai Malin
This patch introduces the NVMeTCP FW initializations which is used to initialize the IO level configuration into a per IO HW resource ("task") as part of the IO path flow.
This includes:
- Write IO FW initialization
- Read IO FW initialization.
- IC-Req and IC-Resp FW exchange.
- FW Cleanup flow (Flush IO).Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/qed/Makefile | 5 +- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 7 +- .../qlogic/qed/qed_nvmetcp_fw_funcs.c | 372 ++++++++++++++++++ .../qlogic/qed/qed_nvmetcp_fw_funcs.h | 43 ++ include/linux/qed/nvmetcp_common.h | 3 + include/linux/qed/qed_nvmetcp_if.h | 17 + 6 files changed, 445 insertions(+), 2 deletions(-)create mode 100644
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.ccreate mode 100644drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.hdrivers/net/ethernet/qlogic/qed/Makefile +4
-1@@ -28,7 +28,10 @@ qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o qed-$(CONFIG_QED_LL2) += qed_ll2.o qed-$(CONFIG_QED_OOO) += qed_ooo.o -qed-$(CONFIG_QED_NVMETCP) += qed_nvmetcp.o +qed-$(CONFIG_QED_NVMETCP) += \ + qed_nvmetcp.o \ + qed_nvmetcp_fw_funcs.o \ + qed_nvmetcp_ip_services.o qed-$(CONFIG_QED_RDMA) += \ qed_iwarp.o \drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +6
-1@@ -27,6 +27,7 @@#include "qed_mcp.h" #include "qed_sp.h" #include "qed_reg_addr.h" +#include "qed_nvmetcp_fw_funcs.h" static int qed_nvmetcp_async_event(struct qed_hwfn *p_hwfn, u8 fw_event_code, u16 echo, union event_ring_data *data,@@ -848,7 +849,11 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .remove_src_tcp_port_filter = &qed_llh_remove_src_tcp_port_filter, .add_dst_tcp_port_filter = &qed_llh_add_dst_tcp_port_filter, .remove_dst_tcp_port_filter = &qed_llh_remove_dst_tcp_port_filter, - .clear_all_filters = &qed_llh_clear_all_filters + .clear_all_filters = &qed_llh_clear_all_filters, + .init_read_io = &init_nvmetcp_host_read_task, + .init_write_io = &init_nvmetcp_host_write_task, + .init_icreq_exchange = &init_nvmetcp_init_conn_req_task, + .init_task_cleanup = &init_cleanup_task_nvmetcp };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void )drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c new file +154
-0@@ -0,0 +1,372 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) +/* Copyright 2021 Marvell. All rights reserved. */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/mm.h> +#include <linux/types.h> +#include <asm/byteorder.h> +#include <linux/qed/common_hsi.h> +#include <linux/qed/storage_common.h> +#include <linux/qed/nvmetcp_common.h> +#include <linux/qed/qed_nvmetcp_if.h> +#include "qed_nvmetcp_fw_funcs.h" + +#define NVMETCP_NUM_SGES_IN_CACHE 0x4 + +bool nvmetcp_is_slow_sgl (u16 num_sges,bool small_mid_sge) +{ +return (num_sges >SCSI_NUM_SGES_SLOW_SGL_THR && small_mid_sge); +} + +void init_scsi_sgl_context (struct scsi_sgl_params *ctx_sgl_params, +struct scsi_cached_sges *ctx_data_desc, +struct storage_sgl_task_params *sgl_params) +{ +u8 num_sges_to_init = (u8)(sgl_params->num_sges >NVMETCP_NUM_SGES_IN_CACHE ? +NVMETCP_NUM_SGES_IN_CACHE : sgl_params->num_sges); +u8 sge_index; + +/* sgl params */ + ctx_sgl_params->sgl_addr.lo =cpu_to_le32 (sgl_params->sgl_phys_addr.lo); + ctx_sgl_params->sgl_addr.hi =cpu_to_le32 (sgl_params->sgl_phys_addr.hi); + ctx_sgl_params->sgl_total_length =cpu_to_le32 (sgl_params->total_buffer_size); + ctx_sgl_params->sgl_num_sges =cpu_to_le16 (sgl_params->num_sges); + +for (sge_index =0 ; sge_index < num_sges_to_init; sge_index++) { + ctx_data_desc->sge[sge_index].sge_addr.lo = +cpu_to_le32 (sgl_params->sgl[sge_index].sge_addr.lo); + ctx_data_desc->sge[sge_index].sge_addr.hi = +cpu_to_le32 (sgl_params->sgl[sge_index].sge_addr.hi); + ctx_data_desc->sge[sge_index].sge_len = +cpu_to_le32 (sgl_params->sgl[sge_index].sge_len); + } +} + +static inline u32 calc_rw_task_size (struct nvmetcp_task_params *task_params, +enum nvmetcp_task_type task_type) +{ +u32 io_size; + +if (task_type ==NVMETCP_TASK_TYPE_HOST_WRITE ) + io_size = task_params->tx_io_size; +else + io_size = task_params->rx_io_size; + +if (unlikely (!io_size)) +return 0 ; + +return io_size; +} + +static inline void init_sqe (struct nvmetcp_task_params *task_params, +struct storage_sgl_task_params *sgl_task_params, +enum nvmetcp_task_type task_type) +{ +if (!task_params->sqe) +return ; + +memset (task_params->sqe,0 ,sizeof (*task_params->sqe)); + task_params->sqe->task_id =cpu_to_le16 (task_params->itid); + +switch (task_type) { +case NVMETCP_TASK_TYPE_HOST_WRITE : { +u32 buf_size =0 ; +u32 num_sges =0 ; + +SET_FIELD (task_params->sqe->contlen_cdbsize, +NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD ,1 ); +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_NORMAL ); +if (task_params->tx_io_size) { +if (task_params->send_write_incapsule) + buf_size =calc_rw_task_size (task_params, task_type); + +if (nvmetcp_is_slow_sgl (sgl_task_params->num_sges, + sgl_task_params->small_mid_sge)) + num_sges =NVMETCP_WQE_NUM_SGES_SLOWIO ; +else + num_sges =min ((u16 )sgl_task_params->num_sges, + (u16 )SCSI_NUM_SGES_SLOW_SGL_THR ); + } +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_NUM_SGES , num_sges); +SET_FIELD (task_params->sqe->contlen_cdbsize,NVMETCP_WQE_CONT_LEN , buf_size); + }break ; + +case NVMETCP_TASK_TYPE_HOST_READ : { +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_NORMAL ); +SET_FIELD (task_params->sqe->contlen_cdbsize, +NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD ,1 ); + }break ; + +case NVMETCP_TASK_TYPE_INIT_CONN_REQUEST : { +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_MIDDLE_PATH ); + +if (task_params->tx_io_size) { +SET_FIELD (task_params->sqe->contlen_cdbsize,NVMETCP_WQE_CONT_LEN , + task_params->tx_io_size); +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_NUM_SGES , +min ((u16 )sgl_task_params->num_sges, + (u16 )SCSI_NUM_SGES_SLOW_SGL_THR )); + } + }break ; + +case NVMETCP_TASK_TYPE_CLEANUP : +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_TASK_CLEANUP ); + +default : +break ; + } +} + +/* The following function initializes of NVMeTCP task params */ +static inline void +init_nvmetcp_task_params (struct e5_nvmetcp_task_context *context, +struct nvmetcp_task_params *task_params, +enum nvmetcp_task_type task_type) +{ + context->ystorm_st_context.state.cccid = task_params->host_cccid; +SET_FIELD (context->ustorm_st_context.error_flags,USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP ,1 ); + context->ustorm_st_context.nvme_tcp_opaque_lo =cpu_to_le32 (task_params->opq.lo); + context->ustorm_st_context.nvme_tcp_opaque_hi =cpu_to_le32 (task_params->opq.hi); +} + +/* The following function initializes default values to all tasks */ +static inline void +init_default_nvmetcp_task (struct nvmetcp_task_params *task_params,void *pdu_header, +enum nvmetcp_task_type task_type) +{ +struct e5_nvmetcp_task_context *context = task_params->context; +const u8 val_byte = context->mstorm_ag_context.cdu_validation; +u8 dw_index; + +memset (context,0 ,sizeof (*context)); + +init_nvmetcp_task_params (context, task_params, + (enum nvmetcp_task_type )task_type); + + if (task_type == NVMETCP_TASK_TYPE_HOST_WRITE ||
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c line 164
Quoted 10 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c new file +10
-0+ task_type == NVMETCP_TASK_TYPE_HOST_READ) { + for (dw_index = 0; dw_index < QED_NVMETCP_CMD_HDR_SIZE / 4; dw_index++) + context->ystorm_st_context.pdu_hdr.task_hdr.reg[dw_index] = + cpu_to_le32(((u32 *)pdu_header)[dw_index]); + } else { +for (dw_index =0 ; dw_index <QED_NVMETCP_CMN_HDR_SIZE /4 ; dw_index++) + context->ystorm_st_context.pdu_hdr.task_hdr.reg[dw_index] = +cpu_to_le32 (((u32 *)pdu_header)[dw_index]); + } +
And this is what I meant. You are twiddling with the bytes already, so why bother with a separate struct at all?
Quoted 290 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c new file +208
-0+/* M-Storm Context: */ + context->mstorm_ag_context.cdu_validation = val_byte; + context->mstorm_st_context.task_type = (u8)(task_type); + context->mstorm_ag_context.task_cid =cpu_to_le16 (task_params->conn_icid); + +/* Ustorm Context: */ +SET_FIELD (context->ustorm_ag_context.flags1,E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV ,1 ); + context->ustorm_st_context.task_type = (u8)(task_type); + context->ustorm_st_context.cq_rss_number = task_params->cq_rss_number; + context->ustorm_ag_context.icid =cpu_to_le16 (task_params->conn_icid); +} + +/* The following function initializes the U-Storm Task Contexts */ +static inline void +init_ustorm_task_contexts (struct ustorm_nvmetcp_task_st_ctx *ustorm_st_context, +struct e5_ustorm_nvmetcp_task_ag_ctx *ustorm_ag_context, +u32 remaining_recv_len, +u32 expected_data_transfer_len,u8 num_sges, +bool tx_dif_conn_err_en) +{ +/* Remaining data to be received in bytes. Used in validations*/ + ustorm_st_context->rem_rcv_len =cpu_to_le32 (remaining_recv_len); + ustorm_ag_context->exp_data_acked =cpu_to_le32 (expected_data_transfer_len); + ustorm_st_context->exp_data_transfer_len =cpu_to_le32 (expected_data_transfer_len); +SET_FIELD (ustorm_st_context->reg1.reg1_map,NVMETCP_REG1_NUM_SGES , num_sges); +SET_FIELD (ustorm_ag_context->flags2,E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN , + tx_dif_conn_err_en ?1 :0 ); +} + +/* The following function initializes Local Completion Contexts: */ +static inline void +set_local_completion_context (struct e5_nvmetcp_task_context *context) +{ +SET_FIELD (context->ystorm_st_context.state.flags, +YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP ,1 ); +SET_FIELD (context->ustorm_st_context.flags, +USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP ,1 ); +} + +/* Common Fastpath task init function: */ +static inline void +init_rw_nvmetcp_task (struct nvmetcp_task_params *task_params, +enum nvmetcp_task_type task_type, +struct nvmetcp_conn_params *conn_params,void *pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +struct e5_nvmetcp_task_context *context = task_params->context; +u32 task_size =calc_rw_task_size (task_params, task_type); +u32 exp_data_transfer_len = conn_params->max_burst_length; +bool slow_io = false; +u8 num_sges =0 ; + +init_default_nvmetcp_task (task_params, pdu_header, task_type); + +/* Tx/Rx: */ +if (task_params->tx_io_size) { +/* if data to transmit: */ +init_scsi_sgl_context (&context->ystorm_st_context.state.sgl_params, + &context->ystorm_st_context.state.data_desc, + sgl_task_params); + slow_io =nvmetcp_is_slow_sgl (sgl_task_params->num_sges, + sgl_task_params->small_mid_sge); + num_sges = + (u8)(!slow_io ?min ((u32 )sgl_task_params->num_sges, + (u32 )SCSI_NUM_SGES_SLOW_SGL_THR ) : +NVMETCP_WQE_NUM_SGES_SLOWIO ); +if (slow_io) { +SET_FIELD (context->ystorm_st_context.state.flags, +YSTORM_NVMETCP_TASK_STATE_SLOW_IO ,1 ); + } + }else if (task_params->rx_io_size) { +/* if data to receive: */ +init_scsi_sgl_context (&context->mstorm_st_context.sgl_params, + &context->mstorm_st_context.data_desc, + sgl_task_params); + num_sges = + (u8)(!nvmetcp_is_slow_sgl (sgl_task_params->num_sges, + sgl_task_params->small_mid_sge) ? +min ((u32 )sgl_task_params->num_sges, + (u32 )SCSI_NUM_SGES_SLOW_SGL_THR ) : +NVMETCP_WQE_NUM_SGES_SLOWIO ); + context->mstorm_st_context.rem_task_size =cpu_to_le32 (task_size); + } + +/* Ustorm context: */ +if (exp_data_transfer_len > task_size) +/* The size of the transmitted task*/ + exp_data_transfer_len = task_size; +init_ustorm_task_contexts (&context->ustorm_st_context, + &context->ustorm_ag_context, +/* Remaining Receive length is the Task Size */ + task_size, +/* The size of the transmitted task */ + exp_data_transfer_len, +/* num_sges */ + num_sges, + false); + +/* Set exp_data_acked */ +if (task_type ==NVMETCP_TASK_TYPE_HOST_WRITE ) { +if (task_params->send_write_incapsule) + context->ustorm_ag_context.exp_data_acked = task_size; +else + context->ustorm_ag_context.exp_data_acked =0 ; + }else if (task_type ==NVMETCP_TASK_TYPE_HOST_READ ) { + context->ustorm_ag_context.exp_data_acked =0 ; + } + + context->ustorm_ag_context.exp_cont_len =0 ; + +init_sqe (task_params, sgl_task_params, task_type); +} + +static void +init_common_initiator_read_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_rw_nvmetcp_task (task_params,NVMETCP_TASK_TYPE_HOST_READ , + conn_params, cmd_pdu_header, sgl_task_params); +} + +void init_nvmetcp_host_read_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_common_initiator_read_task (task_params, conn_params, + (void *)cmd_pdu_header, sgl_task_params); +} + +static void +init_common_initiator_write_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_rw_nvmetcp_task (task_params,NVMETCP_TASK_TYPE_HOST_WRITE , + conn_params, cmd_pdu_header, sgl_task_params); +} + +void init_nvmetcp_host_write_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_common_initiator_write_task (task_params, conn_params, + (void *)cmd_pdu_header, + sgl_task_params); +} + +static void +init_common_login_request_task (struct nvmetcp_task_params *task_params, +void *login_req_pdu_header, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params) +{ +struct e5_nvmetcp_task_context *context = task_params->context; + +init_default_nvmetcp_task (task_params, (void *)login_req_pdu_header, +NVMETCP_TASK_TYPE_INIT_CONN_REQUEST ); + +/* Ustorm Context: */ +init_ustorm_task_contexts (&context->ustorm_st_context, + &context->ustorm_ag_context, + +/* Remaining Receive length is the Task Size */ + task_params->rx_io_size ? + rx_sgl_task_params->total_buffer_size :0 , + +/* The size of the transmitted task */ + task_params->tx_io_size ? + tx_sgl_task_params->total_buffer_size :0 , +0 ,/* num_sges */ +0 );/* tx_dif_conn_err_en */ + +/* SGL context: */ +if (task_params->tx_io_size) +init_scsi_sgl_context (&context->ystorm_st_context.state.sgl_params, + &context->ystorm_st_context.state.data_desc, + tx_sgl_task_params); +if (task_params->rx_io_size) +init_scsi_sgl_context (&context->mstorm_st_context.sgl_params, + &context->mstorm_st_context.data_desc, + rx_sgl_task_params); + + context->mstorm_st_context.rem_task_size = +cpu_to_le32 (task_params->rx_io_size ? + rx_sgl_task_params->total_buffer_size :0 ); + +init_sqe (task_params, tx_sgl_task_params,NVMETCP_TASK_TYPE_INIT_CONN_REQUEST ); +} + +/* The following function initializes Login task in Host mode: */ +void init_nvmetcp_init_conn_req_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_init_conn_req_hdr *init_conn_req_pdu_hdr, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params) +{ +init_common_login_request_task (task_params, init_conn_req_pdu_hdr, + tx_sgl_task_params, rx_sgl_task_params); +} + +void init_cleanup_task_nvmetcp (struct nvmetcp_task_params *task_params) +{ +init_sqe (task_params,NULL ,NVMETCP_TASK_TYPE_CLEANUP ); +}drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h new file +43
-0@@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef _QED_NVMETCP_FW_FUNCS_H +#define _QED_NVMETCP_FW_FUNCS_H + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/mm.h> +#include <linux/types.h> +#include <asm/byteorder.h> +#include <linux/qed/common_hsi.h> +#include <linux/qed/storage_common.h> +#include <linux/qed/nvmetcp_common.h> +#include <linux/qed/qed_nvmetcp_if.h> + +#if IS_ENABLED (CONFIG_QED_NVMETCP ) + +void init_nvmetcp_host_read_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void init_nvmetcp_host_write_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void init_nvmetcp_init_conn_req_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_init_conn_req_hdr *init_conn_req_pdu_hdr, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params); + +void init_cleanup_task_nvmetcp (struct nvmetcp_task_params *task_params); + +#else /* IS_ENABLED(CONFIG_QED_NVMETCP) */ + +#endif /* IS_ENABLED(CONFIG_QED_NVMETCP) */ + +#endif /* _QED_NVMETCP_FW_FUNCS_H */ include/linux/qed/nvmetcp_common.h +3
-0@@ -9,6 +9,9 @@#define NVMETCP_SLOW_PATH_LAYER_CODE (6)#define NVMETCP_WQE_NUM_SGES_SLOWIO (0xf) +#define QED_NVMETCP_CMD_HDR_SIZE 72 +#define QED_NVMETCP_CMN_HDR_SIZE 24 +/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {__le16 half_way_close_timeout;include/linux/qed/qed_nvmetcp_if.h +10
-0@@ -220,6 +220,23 @@ struct qed_nvmetcp_ops {void (*remove_dst_tcp_port_filter)(struct qed_dev *cdev,u16 dest_port);void (*clear_all_filters)(struct qed_dev *cdev); + +void (*init_read_io)(struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void (*init_write_io)(struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params);
include/linux/qed/qed_nvmetcp_if.h struct qed_nvmetcp_ops { · line 242
Quoted 10 lines
include/linux/qed/qed_nvmetcp_if.h +7
-0+ +void (*init_icreq_exchange)(struct nvmetcp_task_params *task_params, +struct nvmetcp_init_conn_req_hdr *init_conn_req_pdu_hdr, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params); + +void (*init_task_cleanup)(struct nvmetcp_task_params *task_params); };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void );
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 06/27] qed: Add NVMeTCP Offload IO Level FW Initializations
Quoted 234 lines · Hannes Reinecke
Quoted 233 lines · Shai Malin
This patch introduces the NVMeTCP FW initializations which is used to initialize the IO level configuration into a per IO HW resource ("task") as part of the IO path flow.
This includes:
- Write IO FW initialization
- Read IO FW initialization.
- IC-Req and IC-Resp FW exchange.
- FW Cleanup flow (Flush IO).Acked-by Igor Russkikh <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Shai Malin <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>--- drivers/net/ethernet/qlogic/qed/Makefile | 5 +- drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 7 +- .../qlogic/qed/qed_nvmetcp_fw_funcs.c | 372 ++++++++++++++++++ .../qlogic/qed/qed_nvmetcp_fw_funcs.h | 43 ++ include/linux/qed/nvmetcp_common.h | 3 + include/linux/qed/qed_nvmetcp_if.h | 17 + 6 files changed, 445 insertions(+), 2 deletions(-)create mode 100644
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.ccreate mode 100644drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.hdrivers/net/ethernet/qlogic/qed/Makefile +4
-1@@ -28,7 +28,10 @@ qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o qed-$(CONFIG_QED_LL2) += qed_ll2.o qed-$(CONFIG_QED_OOO) += qed_ooo.o -qed-$(CONFIG_QED_NVMETCP) += qed_nvmetcp.o +qed-$(CONFIG_QED_NVMETCP) += \ + qed_nvmetcp.o \ + qed_nvmetcp_fw_funcs.o \ + qed_nvmetcp_ip_services.o qed-$(CONFIG_QED_RDMA) += \ qed_iwarp.o \drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c +6
-1@@ -27,6 +27,7 @@#include "qed_mcp.h" #include "qed_sp.h" #include "qed_reg_addr.h" +#include "qed_nvmetcp_fw_funcs.h" static int qed_nvmetcp_async_event(struct qed_hwfn *p_hwfn, u8 fw_event_code, u16 echo, union event_ring_data *data,@@ -848,7 +849,11 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_ops_pass = { .remove_src_tcp_port_filter = &qed_llh_remove_src_tcp_port_filter, .add_dst_tcp_port_filter = &qed_llh_add_dst_tcp_port_filter, .remove_dst_tcp_port_filter = &qed_llh_remove_dst_tcp_port_filter, - .clear_all_filters = &qed_llh_clear_all_filters + .clear_all_filters = &qed_llh_clear_all_filters, + .init_read_io = &init_nvmetcp_host_read_task, + .init_write_io = &init_nvmetcp_host_write_task, + .init_icreq_exchange = &init_nvmetcp_init_conn_req_task, + .init_task_cleanup = &init_cleanup_task_nvmetcp };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void )drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c new file +159
-0@@ -0,0 +1,372 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) +/* Copyright 2021 Marvell. All rights reserved. */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/mm.h> +#include <linux/types.h> +#include <asm/byteorder.h> +#include <linux/qed/common_hsi.h> +#include <linux/qed/storage_common.h> +#include <linux/qed/nvmetcp_common.h> +#include <linux/qed/qed_nvmetcp_if.h> +#include "qed_nvmetcp_fw_funcs.h" + +#define NVMETCP_NUM_SGES_IN_CACHE 0x4 + +bool nvmetcp_is_slow_sgl (u16 num_sges,bool small_mid_sge) +{ +return (num_sges >SCSI_NUM_SGES_SLOW_SGL_THR && small_mid_sge); +} + +void init_scsi_sgl_context (struct scsi_sgl_params *ctx_sgl_params, +struct scsi_cached_sges *ctx_data_desc, +struct storage_sgl_task_params *sgl_params) +{ +u8 num_sges_to_init = (u8)(sgl_params->num_sges >NVMETCP_NUM_SGES_IN_CACHE ? +NVMETCP_NUM_SGES_IN_CACHE : sgl_params->num_sges); +u8 sge_index; + +/* sgl params */ + ctx_sgl_params->sgl_addr.lo =cpu_to_le32 (sgl_params->sgl_phys_addr.lo); + ctx_sgl_params->sgl_addr.hi =cpu_to_le32 (sgl_params->sgl_phys_addr.hi); + ctx_sgl_params->sgl_total_length =cpu_to_le32 (sgl_params->total_buffer_size); + ctx_sgl_params->sgl_num_sges =cpu_to_le16 (sgl_params->num_sges); + +for (sge_index =0 ; sge_index < num_sges_to_init; sge_index++) { + ctx_data_desc->sge[sge_index].sge_addr.lo = +cpu_to_le32 (sgl_params->sgl[sge_index].sge_addr.lo); + ctx_data_desc->sge[sge_index].sge_addr.hi = +cpu_to_le32 (sgl_params->sgl[sge_index].sge_addr.hi); + ctx_data_desc->sge[sge_index].sge_len = +cpu_to_le32 (sgl_params->sgl[sge_index].sge_len); + } +} + +static inline u32 calc_rw_task_size (struct nvmetcp_task_params *task_params, +enum nvmetcp_task_type task_type) +{ +u32 io_size; + +if (task_type ==NVMETCP_TASK_TYPE_HOST_WRITE ) + io_size = task_params->tx_io_size; +else + io_size = task_params->rx_io_size; + +if (unlikely (!io_size)) +return 0 ; + +return io_size; +} + +static inline void init_sqe (struct nvmetcp_task_params *task_params, +struct storage_sgl_task_params *sgl_task_params, +enum nvmetcp_task_type task_type) +{ +if (!task_params->sqe) +return ; + +memset (task_params->sqe,0 ,sizeof (*task_params->sqe)); + task_params->sqe->task_id =cpu_to_le16 (task_params->itid); + +switch (task_type) { +case NVMETCP_TASK_TYPE_HOST_WRITE : { +u32 buf_size =0 ; +u32 num_sges =0 ; + +SET_FIELD (task_params->sqe->contlen_cdbsize, +NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD ,1 ); +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_NORMAL ); +if (task_params->tx_io_size) { +if (task_params->send_write_incapsule) + buf_size =calc_rw_task_size (task_params, task_type); + +if (nvmetcp_is_slow_sgl (sgl_task_params->num_sges, + sgl_task_params->small_mid_sge)) + num_sges =NVMETCP_WQE_NUM_SGES_SLOWIO ; +else + num_sges =min ((u16 )sgl_task_params->num_sges, + (u16 )SCSI_NUM_SGES_SLOW_SGL_THR ); + } +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_NUM_SGES , num_sges); +SET_FIELD (task_params->sqe->contlen_cdbsize,NVMETCP_WQE_CONT_LEN , buf_size); + }break ; + +case NVMETCP_TASK_TYPE_HOST_READ : { +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_NORMAL ); +SET_FIELD (task_params->sqe->contlen_cdbsize, +NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD ,1 ); + }break ; + +case NVMETCP_TASK_TYPE_INIT_CONN_REQUEST : { +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_MIDDLE_PATH ); + +if (task_params->tx_io_size) { +SET_FIELD (task_params->sqe->contlen_cdbsize,NVMETCP_WQE_CONT_LEN , + task_params->tx_io_size); +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_NUM_SGES , +min ((u16 )sgl_task_params->num_sges, + (u16 )SCSI_NUM_SGES_SLOW_SGL_THR )); + } + }break ; + +case NVMETCP_TASK_TYPE_CLEANUP : +SET_FIELD (task_params->sqe->flags,NVMETCP_WQE_WQE_TYPE , +NVMETCP_WQE_TYPE_TASK_CLEANUP ); + +default : +break ; + } +} + +/* The following function initializes of NVMeTCP task params */ +static inline void +init_nvmetcp_task_params (struct e5_nvmetcp_task_context *context, +struct nvmetcp_task_params *task_params, +enum nvmetcp_task_type task_type) +{ + context->ystorm_st_context.state.cccid = task_params->host_cccid; +SET_FIELD (context->ustorm_st_context.error_flags,USTORM_NVMETCP_TASK_ST_CTX_NVME_TCP ,1 ); + context->ustorm_st_context.nvme_tcp_opaque_lo =cpu_to_le32 (task_params->opq.lo); + context->ustorm_st_context.nvme_tcp_opaque_hi =cpu_to_le32 (task_params->opq.hi); +} + +/* The following function initializes default values to all tasks */ +static inline void +init_default_nvmetcp_task (struct nvmetcp_task_params *task_params,void *pdu_header, +enum nvmetcp_task_type task_type) +{ +struct e5_nvmetcp_task_context *context = task_params->context; +const u8 val_byte = context->mstorm_ag_context.cdu_validation; +u8 dw_index; + +memset (context,0 ,sizeof (*context)); + +init_nvmetcp_task_params (context, task_params, + (enum nvmetcp_task_type )task_type); + +if (task_type ==NVMETCP_TASK_TYPE_HOST_WRITE || + task_type ==NVMETCP_TASK_TYPE_HOST_READ ) { +for (dw_index =0 ; dw_index <QED_NVMETCP_CMD_HDR_SIZE /4 ; dw_index++) + context->ystorm_st_context.pdu_hdr.task_hdr.reg[dw_index] = +cpu_to_le32 (((u32 *)pdu_header)[dw_index]); + }else {
Quoted 8 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c line 164
Quoted 5 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c new file +5
-0+for (dw_index =0 ; dw_index <QED_NVMETCP_CMN_HDR_SIZE /4 ; dw_index++) + context->ystorm_st_context.pdu_hdr.task_hdr.reg[dw_index] = +cpu_to_le32 (((u32 *)pdu_header)[dw_index]); + } +And this is what I meant. You are twiddling with the bytes already, so why bother with a separate struct at all?
We agree, will be fixed in V5.
Quoted 309 lines
Quoted 291 lines
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c new file +208
-0+/* M-Storm Context: */ + context->mstorm_ag_context.cdu_validation = val_byte; + context->mstorm_st_context.task_type = (u8)(task_type); + context->mstorm_ag_context.task_cid =cpu_to_le16 (task_params->conn_icid); + +/* Ustorm Context: */ +SET_FIELD (context->ustorm_ag_context.flags1,E5_USTORM_NVMETCP_TASK_AG_CTX_R2T2RECV ,1 ); + context->ustorm_st_context.task_type = (u8)(task_type); + context->ustorm_st_context.cq_rss_number = task_params->cq_rss_number; + context->ustorm_ag_context.icid =cpu_to_le16 (task_params->conn_icid); +} + +/* The following function initializes the U-Storm Task Contexts */ +static inline void +init_ustorm_task_contexts (struct ustorm_nvmetcp_task_st_ctx *ustorm_st_context, +struct e5_ustorm_nvmetcp_task_ag_ctx *ustorm_ag_context, +u32 remaining_recv_len, +u32 expected_data_transfer_len,u8 num_sges, +bool tx_dif_conn_err_en) +{ +/* Remaining data to be received in bytes. Used in validations*/ + ustorm_st_context->rem_rcv_len =cpu_to_le32 (remaining_recv_len); + ustorm_ag_context->exp_data_acked =cpu_to_le32 (expected_data_transfer_len); + ustorm_st_context->exp_data_transfer_len =cpu_to_le32 (expected_data_transfer_len); +SET_FIELD (ustorm_st_context->reg1.reg1_map,NVMETCP_REG1_NUM_SGES , num_sges); +SET_FIELD (ustorm_ag_context->flags2,E5_USTORM_NVMETCP_TASK_AG_CTX_DIF_ERROR_CF_EN , + tx_dif_conn_err_en ?1 :0 ); +} + +/* The following function initializes Local Completion Contexts: */ +static inline void +set_local_completion_context (struct e5_nvmetcp_task_context *context) +{ +SET_FIELD (context->ystorm_st_context.state.flags, +YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP ,1 ); +SET_FIELD (context->ustorm_st_context.flags, +USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP ,1 ); +} + +/* Common Fastpath task init function: */ +static inline void +init_rw_nvmetcp_task (struct nvmetcp_task_params *task_params, +enum nvmetcp_task_type task_type, +struct nvmetcp_conn_params *conn_params,void *pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +struct e5_nvmetcp_task_context *context = task_params->context; +u32 task_size =calc_rw_task_size (task_params, task_type); +u32 exp_data_transfer_len = conn_params->max_burst_length; +bool slow_io = false; +u8 num_sges =0 ; + +init_default_nvmetcp_task (task_params, pdu_header, task_type); + +/* Tx/Rx: */ +if (task_params->tx_io_size) { +/* if data to transmit: */ +init_scsi_sgl_context (&context->ystorm_st_context.state.sgl_params, + &context->ystorm_st_context.state.data_desc, + sgl_task_params); + slow_io =nvmetcp_is_slow_sgl (sgl_task_params->num_sges, + sgl_task_params->small_mid_sge); + num_sges = + (u8)(!slow_io ?min ((u32 )sgl_task_params->num_sges, + (u32 )SCSI_NUM_SGES_SLOW_SGL_THR ) : +NVMETCP_WQE_NUM_SGES_SLOWIO ); +if (slow_io) { +SET_FIELD (context->ystorm_st_context.state.flags, +YSTORM_NVMETCP_TASK_STATE_SLOW_IO ,1 ); + } + }else if (task_params->rx_io_size) { +/* if data to receive: */ +init_scsi_sgl_context (&context->mstorm_st_context.sgl_params, + &context->mstorm_st_context.data_desc, + sgl_task_params); + num_sges = + (u8)(!nvmetcp_is_slow_sgl (sgl_task_params->num_sges, + sgl_task_params->small_mid_sge) ? +min ((u32 )sgl_task_params->num_sges, + (u32 )SCSI_NUM_SGES_SLOW_SGL_THR ) : +NVMETCP_WQE_NUM_SGES_SLOWIO ); + context->mstorm_st_context.rem_task_size =cpu_to_le32 (task_size); + } + +/* Ustorm context: */ +if (exp_data_transfer_len > task_size) +/* The size of the transmitted task*/ + exp_data_transfer_len = task_size; +init_ustorm_task_contexts (&context->ustorm_st_context, + &context->ustorm_ag_context, +/* Remaining Receive length is the Task Size */ + task_size, +/* The size of the transmitted task */ + exp_data_transfer_len, +/* num_sges */ + num_sges, + false); + +/* Set exp_data_acked */ +if (task_type ==NVMETCP_TASK_TYPE_HOST_WRITE ) { +if (task_params->send_write_incapsule) + context->ustorm_ag_context.exp_data_acked = task_size; +else + context->ustorm_ag_context.exp_data_acked =0 ; + }else if (task_type ==NVMETCP_TASK_TYPE_HOST_READ ) { + context->ustorm_ag_context.exp_data_acked =0 ; + } + + context->ustorm_ag_context.exp_cont_len =0 ; + +init_sqe (task_params, sgl_task_params, task_type); +} + +static void +init_common_initiator_read_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_rw_nvmetcp_task (task_params,NVMETCP_TASK_TYPE_HOST_READ , + conn_params, cmd_pdu_header, sgl_task_params); +} + +void init_nvmetcp_host_read_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_common_initiator_read_task (task_params, conn_params, + (void *)cmd_pdu_header, sgl_task_params); +} + +static void +init_common_initiator_write_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_rw_nvmetcp_task (task_params,NVMETCP_TASK_TYPE_HOST_WRITE , + conn_params, cmd_pdu_header, sgl_task_params); +} + +void init_nvmetcp_host_write_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params) +{ +init_common_initiator_write_task (task_params, conn_params, + (void *)cmd_pdu_header, + sgl_task_params); +} + +static void +init_common_login_request_task (struct nvmetcp_task_params *task_params, +void *login_req_pdu_header, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params) +{ +struct e5_nvmetcp_task_context *context = task_params->context; + +init_default_nvmetcp_task (task_params, (void *)login_req_pdu_header, +NVMETCP_TASK_TYPE_INIT_CONN_REQUEST ); + +/* Ustorm Context: */ +init_ustorm_task_contexts (&context->ustorm_st_context, + &context->ustorm_ag_context, + +/* Remaining Receive length is the Task Size */ + task_params->rx_io_size ? + rx_sgl_task_params->total_buffer_size :0 , + +/* The size of the transmitted task */ + task_params->tx_io_size ? + tx_sgl_task_params->total_buffer_size :0 , +0 ,/* num_sges */ +0 );/* tx_dif_conn_err_en */ + +/* SGL context: */ +if (task_params->tx_io_size) +init_scsi_sgl_context (&context->ystorm_st_context.state.sgl_params, + &context->ystorm_st_context.state.data_desc, + tx_sgl_task_params); +if (task_params->rx_io_size) +init_scsi_sgl_context (&context->mstorm_st_context.sgl_params, + &context->mstorm_st_context.data_desc, + rx_sgl_task_params); + + context->mstorm_st_context.rem_task_size = +cpu_to_le32 (task_params->rx_io_size ? + rx_sgl_task_params->total_buffer_size :0 ); + +init_sqe (task_params, tx_sgl_task_params,NVMETCP_TASK_TYPE_INIT_CONN_REQUEST ); +} + +/* The following function initializes Login task in Host mode: */ +void init_nvmetcp_init_conn_req_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_init_conn_req_hdr *init_conn_req_pdu_hdr, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params) +{ +init_common_login_request_task (task_params, init_conn_req_pdu_hdr, + tx_sgl_task_params, rx_sgl_task_params); +} + +void init_cleanup_task_nvmetcp (struct nvmetcp_task_params *task_params) +{ +init_sqe (task_params,NULL ,NVMETCP_TASK_TYPE_CLEANUP ); +}drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h new file +43
-0@@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* Copyright 2021 Marvell. All rights reserved. */ + +#ifndef _QED_NVMETCP_FW_FUNCS_H +#define _QED_NVMETCP_FW_FUNCS_H + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/mm.h> +#include <linux/types.h> +#include <asm/byteorder.h> +#include <linux/qed/common_hsi.h> +#include <linux/qed/storage_common.h> +#include <linux/qed/nvmetcp_common.h> +#include <linux/qed/qed_nvmetcp_if.h> + +#if IS_ENABLED (CONFIG_QED_NVMETCP ) + +void init_nvmetcp_host_read_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void init_nvmetcp_host_write_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void init_nvmetcp_init_conn_req_task (struct nvmetcp_task_params *task_params, +struct nvmetcp_init_conn_req_hdr *init_conn_req_pdu_hdr, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params); + +void init_cleanup_task_nvmetcp (struct nvmetcp_task_params *task_params); + +#else /* IS_ENABLED(CONFIG_QED_NVMETCP) */ + +#endif /* IS_ENABLED(CONFIG_QED_NVMETCP) */ + +#endif /* _QED_NVMETCP_FW_FUNCS_H */ include/linux/qed/nvmetcp_common.h +3
-0@@ -9,6 +9,9 @@#define NVMETCP_SLOW_PATH_LAYER_CODE (6)#define NVMETCP_WQE_NUM_SGES_SLOWIO (0xf) +#define QED_NVMETCP_CMD_HDR_SIZE 72 +#define QED_NVMETCP_CMN_HDR_SIZE 24 +/* NVMeTCP firmware function init parameters */ struct nvmetcp_spe_func_init {__le16 half_way_close_timeout;include/linux/qed/qed_nvmetcp_if.h +10
-0@@ -220,6 +220,23 @@ struct qed_nvmetcp_ops {void (*remove_dst_tcp_port_filter)(struct qed_dev *cdev,u16 dest_port);void (*clear_all_filters)(struct qed_dev *cdev); + +void (*init_read_io)(struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params); + +void (*init_write_io)(struct nvmetcp_task_params *task_params, +struct nvmetcp_conn_params *conn_params, +struct nvmetcp_cmd_capsule_hdr *cmd_pdu_header, +struct storage_sgl_task_params *sgl_task_params);include/linux/qed/qed_nvmetcp_if.h struct qed_nvmetcp_ops { · line 242
Quoted 10 lines
include/linux/qed/qed_nvmetcp_if.h +7
-0+ +void (*init_icreq_exchange)(struct nvmetcp_task_params *task_params, +struct nvmetcp_init_conn_req_hdr *init_conn_req_pdu_hdr, +struct storage_sgl_task_params *tx_sgl_task_params, +struct storage_sgl_task_params *rx_sgl_task_params); + +void (*init_task_cleanup)(struct nvmetcp_task_params *task_params); };const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops (void );Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 7/27 qed: Add IP services APIs support
In reply to Shai MalinFrom: Nikolay Assa <[email protected]>
This patch introduces APIs which the NVMeTCP Offload device (qedn) will use through the paired net-device (qede).
It includes APIs for:
- ipv4/ipv6 routing
- get VLAN from net-device
- TCP ports reservation
--- .../qlogic/qed/qed_nvmetcp_ip_services.c | 239 ++++++++++++++++++ .../linux/qed/qed_nvmetcp_ip_services_if.h | 29 +++ 2 files changed, 268 insertions(+) create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_ip_services.c create mode 100644 include/linux/qed/qed_nvmetcp_ip_services_if.h
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_ip_services.c new file +239 -0
@@ -0,0 +1,239 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) +/* +* Copyright 2021 Marvell. All rights reserved. +*/ + +#include <linux/types.h> +#include <asm/byteorder.h> +#include <asm/param.h> +#include <linux/delay.h> +#include <linux/pci.h> +#include <linux/dma-mapping.h> +#include <linux/etherdevice.h> +#include <linux/kernel.h> +#include <linux/stddef.h> +#include <linux/errno.h> + +#include <net/tcp.h> + +#include <linux/qed/qed_nvmetcp_ip_services_if.h> + +#define QED_IP_RESOL_TIMEOUT 4 + +int qed_route_ipv4 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev) +{ +struct neighbour *neigh =NULL ; +__be32 *loc_ip, *rem_ip; +struct rtable *rt; +int rc = -ENXIO ; +int retry; + + loc_ip = &((struct sockaddr_in *)local_addr)->sin_addr.s_addr; + rem_ip = &((struct sockaddr_in *)remote_addr)->sin_addr.s_addr; + *ndev =NULL ; + rt =ip_route_output (&init_net, *rem_ip, *loc_ip,0 /*tos*/ ,0 /*oif*/ ); +if (IS_ERR (rt)) { +pr_err ("lookup route failed\n" ); + rc =PTR_ERR (rt); + goto return_err; + } + + neigh =dst_neigh_lookup (&rt->dst, rem_ip); +if (!neigh) { + rc = -ENOMEM ; +ip_rt_put (rt); + goto return_err; + } + + *ndev = rt->dst.dev; +ip_rt_put (rt); + +/* If not resolved, kick-off state machine towards resolution */ +if (!(neigh->nud_state &NUD_VALID )) +neigh_event_send (neigh,NULL ); + +/* query neighbor until resolved or timeout */ + retry =QED_IP_RESOL_TIMEOUT ; +while (!(neigh->nud_state &NUD_VALID ) && retry >0 ) { +msleep (1000 ); + retry--; + } + +if (neigh->nud_state &NUD_VALID ) { +/* copy resolved MAC address */ +neigh_ha_snapshot (hardware_address->sa_data, neigh, *ndev); + + hardware_address->sa_family = (*ndev)->type; + rc =0 ; + } + +neigh_release (neigh); +if (!(*loc_ip)) { + *loc_ip =inet_select_addr (*ndev, *rem_ip,RT_SCOPE_UNIVERSE ); + local_addr->ss_family =AF_INET ; + } + +return_err: + +return rc; +} +EXPORT_SYMBOL (qed_route_ipv4); + +int qed_route_ipv6 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev) +{ +struct neighbour *neigh =NULL ; +struct dst_entry *dst; +struct flowi6 fl6; +int rc = -ENXIO ; +int retry; + +memset (&fl6,0 ,sizeof (fl6)); + fl6.saddr = ((struct sockaddr_in6 *)local_addr)->sin6_addr; + fl6.daddr = ((struct sockaddr_in6 *)remote_addr)->sin6_addr; + + dst =ip6_route_output (&init_net,NULL , &fl6); +if (!dst || dst->error) { +if (dst) { +dst_release (dst); +pr_err ("lookup route failed %d\n" , dst->error); + } + + goto out; + } + + neigh =dst_neigh_lookup (dst, &fl6.daddr); +if (neigh) { + *ndev =ip6_dst_idev (dst)->dev; + +/* If not resolved, kick-off state machine towards resolution */ +if (!(neigh->nud_state &NUD_VALID )) +neigh_event_send (neigh,NULL ); + +/* query neighbor until resolved or timeout */ + retry =QED_IP_RESOL_TIMEOUT ; +while (!(neigh->nud_state &NUD_VALID ) && retry >0 ) { +msleep (1000 ); + retry--; + } + +if (neigh->nud_state &NUD_VALID ) { +neigh_ha_snapshot ((u8 *)hardware_address->sa_data, neigh, *ndev); + + hardware_address->sa_family = (*ndev)->type; + rc =0 ; + } + +neigh_release (neigh); + +if (ipv6_addr_any (&fl6.saddr)) { +if (ipv6_dev_get_saddr (dev_net (*ndev), *ndev, + &fl6.daddr,0 , &fl6.saddr)) { +pr_err ("Unable to find source IP address\n" ); + goto out; + } + + local_addr->ss_family =AF_INET6 ; + ((struct sockaddr_in6 *)local_addr)->sin6_addr = + fl6.saddr; + } + } + +dst_release (dst); + +out: + +return rc; +} +EXPORT_SYMBOL (qed_route_ipv6); + +void qed_vlan_get_ndev (struct net_device **ndev,u16 *vlan_id) +{ +if (is_vlan_dev (*ndev)) { + *vlan_id =vlan_dev_vlan_id (*ndev); + *ndev =vlan_dev_real_dev (*ndev); + } +} +EXPORT_SYMBOL (qed_vlan_get_ndev); + +struct pci_dev *qed_validate_ndev (struct net_device *ndev) +{ +struct pci_dev *pdev =NULL ; +struct net_device *upper; + +for_each_pci_dev (pdev) { +if (pdev && pdev->driver && + !strcmp (pdev->driver->name,"qede" )) { + upper =pci_get_drvdata (pdev); +if (upper->ifindex == ndev->ifindex) +return pdev; + } + } + +return NULL ; +} +EXPORT_SYMBOL (qed_validate_ndev); + +__be16 qed_get_in_port (struct sockaddr_storage *sa) +{ +return sa->ss_family ==AF_INET + ? ((struct sockaddr_in *)sa)->sin_port + : ((struct sockaddr_in6 *)sa)->sin6_port; +} +EXPORT_SYMBOL (qed_get_in_port); + +int qed_fetch_tcp_port (struct sockaddr_storage local_ip_addr, +struct socket **sock,u16 *port) +{ +struct sockaddr_storage sa; +int rc =0 ; + + rc =sock_create (local_ip_addr.ss_family,SOCK_STREAM ,IPPROTO_TCP , sock); +if (rc) { +pr_warn ("failed to create socket: %d\n" , rc); + goto err; + } + + (*sock)->sk->sk_allocation =GFP_KERNEL ; +sk_set_memalloc ((*sock)->sk); + + rc =kernel_bind (*sock, (struct sockaddr *)&local_ip_addr, +sizeof (local_ip_addr)); + +if (rc) { +pr_warn ("failed to bind socket: %d\n" , rc); + goto err_sock; + } + + rc =kernel_getsockname (*sock, (struct sockaddr *)&sa); +if (rc <0 ) { +pr_warn ("getsockname() failed: %d\n" , rc); + goto err_sock; + } + + *port =ntohs (qed_get_in_port (&sa)); + +return 0 ; + +err_sock: +sock_release (*sock); + sock =NULL ; +err: + +return rc; +} +EXPORT_SYMBOL (qed_fetch_tcp_port); + +void qed_return_tcp_port (struct socket *sock) +{ +if (sock && sock->sk) { +tcp_set_state (sock->sk,TCP_CLOSE ); +sock_release (sock); + } +} +EXPORT_SYMBOL (qed_return_tcp_port);
include/linux/qed/qed_nvmetcp_ip_services_if.h new file +29 -0
@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* +* Copyright 2021 Marvell. All rights reserved. +*/ + +#ifndef _QED_IP_SERVICES_IF_H +#define _QED_IP_SERVICES_IF_H + +#include <linux/types.h> +#include <net/route.h> +#include <net/ip6_route.h> +#include <linux/inetdevice.h> + +int qed_route_ipv4 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev); +int qed_route_ipv6 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev); +void qed_vlan_get_ndev (struct net_device **ndev,u16 *vlan_id); +struct pci_dev *qed_validate_ndev (struct net_device *ndev); +void qed_return_tcp_port (struct socket *sock); +int qed_fetch_tcp_port (struct sockaddr_storage local_ip_addr, +struct socket **sock,u16 *port); +__be16 qed_get_in_port (struct sockaddr_storage *sa); + +#endif /* _QED_IP_SERVICES_IF_H */
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 07/27] qed: Add IP services APIs support
Quoted 294 lines · Shai Malin
From: Nikolay Assa <[email protected]>
This patch introduces APIs which the NVMeTCP Offload device (qedn) will use through the paired net-device (qede).
It includes APIs for:
- ipv4/ipv6 routing
- get VLAN from net-device
- TCP ports reservationAcked-by Igor Russkikh <[email protected]>Signed-off-by Nikolay Assa <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- .../qlogic/qed/qed_nvmetcp_ip_services.c | 239 ++++++++++++++++++ .../linux/qed/qed_nvmetcp_ip_services_if.h | 29 +++ 2 files changed, 268 insertions(+)create mode 100644
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_ip_services.ccreate mode 100644include/linux/qed/qed_nvmetcp_ip_services_if.hdrivers/net/ethernet/qlogic/qed/qed_nvmetcp_ip_services.c new file +239
-0@@ -0,0 +1,239 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) +/* +* Copyright 2021 Marvell. All rights reserved. +*/ + +#include <linux/types.h> +#include <asm/byteorder.h> +#include <asm/param.h> +#include <linux/delay.h> +#include <linux/pci.h> +#include <linux/dma-mapping.h> +#include <linux/etherdevice.h> +#include <linux/kernel.h> +#include <linux/stddef.h> +#include <linux/errno.h> + +#include <net/tcp.h> + +#include <linux/qed/qed_nvmetcp_ip_services_if.h> + +#define QED_IP_RESOL_TIMEOUT 4 + +int qed_route_ipv4 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev) +{ +struct neighbour *neigh =NULL ; +__be32 *loc_ip, *rem_ip; +struct rtable *rt; +int rc = -ENXIO ; +int retry; + + loc_ip = &((struct sockaddr_in *)local_addr)->sin_addr.s_addr; + rem_ip = &((struct sockaddr_in *)remote_addr)->sin_addr.s_addr; + *ndev =NULL ; + rt =ip_route_output (&init_net, *rem_ip, *loc_ip,0 /*tos*/ ,0 /*oif*/ ); +if (IS_ERR (rt)) { +pr_err ("lookup route failed\n" ); + rc =PTR_ERR (rt); + goto return_err; + } + + neigh =dst_neigh_lookup (&rt->dst, rem_ip); +if (!neigh) { + rc = -ENOMEM ; +ip_rt_put (rt); + goto return_err; + } + + *ndev = rt->dst.dev; +ip_rt_put (rt); + +/* If not resolved, kick-off state machine towards resolution */ +if (!(neigh->nud_state &NUD_VALID )) +neigh_event_send (neigh,NULL ); + +/* query neighbor until resolved or timeout */ + retry =QED_IP_RESOL_TIMEOUT ; +while (!(neigh->nud_state &NUD_VALID ) && retry >0 ) { +msleep (1000 ); + retry--; + } + +if (neigh->nud_state &NUD_VALID ) { +/* copy resolved MAC address */ +neigh_ha_snapshot (hardware_address->sa_data, neigh, *ndev); + + hardware_address->sa_family = (*ndev)->type; + rc =0 ; + } + +neigh_release (neigh); +if (!(*loc_ip)) { + *loc_ip =inet_select_addr (*ndev, *rem_ip,RT_SCOPE_UNIVERSE ); + local_addr->ss_family =AF_INET ; + } + +return_err: + +return rc; +} +EXPORT_SYMBOL (qed_route_ipv4); + +int qed_route_ipv6 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev) +{ +struct neighbour *neigh =NULL ; +struct dst_entry *dst; +struct flowi6 fl6; +int rc = -ENXIO ; +int retry; + +memset (&fl6,0 ,sizeof (fl6)); + fl6.saddr = ((struct sockaddr_in6 *)local_addr)->sin6_addr; + fl6.daddr = ((struct sockaddr_in6 *)remote_addr)->sin6_addr; + + dst =ip6_route_output (&init_net,NULL , &fl6); +if (!dst || dst->error) { +if (dst) { +dst_release (dst); +pr_err ("lookup route failed %d\n" , dst->error); + } + + goto out; + } + + neigh =dst_neigh_lookup (dst, &fl6.daddr); +if (neigh) { + *ndev =ip6_dst_idev (dst)->dev; + +/* If not resolved, kick-off state machine towards resolution */ +if (!(neigh->nud_state &NUD_VALID )) +neigh_event_send (neigh,NULL ); + +/* query neighbor until resolved or timeout */ + retry =QED_IP_RESOL_TIMEOUT ; +while (!(neigh->nud_state &NUD_VALID ) && retry >0 ) { +msleep (1000 ); + retry--; + } + +if (neigh->nud_state &NUD_VALID ) { +neigh_ha_snapshot ((u8 *)hardware_address->sa_data, neigh, *ndev); + + hardware_address->sa_family = (*ndev)->type; + rc =0 ; + } + +neigh_release (neigh); + +if (ipv6_addr_any (&fl6.saddr)) { +if (ipv6_dev_get_saddr (dev_net (*ndev), *ndev, + &fl6.daddr,0 , &fl6.saddr)) { +pr_err ("Unable to find source IP address\n" ); + goto out; + } + + local_addr->ss_family =AF_INET6 ; + ((struct sockaddr_in6 *)local_addr)->sin6_addr = + fl6.saddr; + } + } + +dst_release (dst); + +out: + +return rc; +} +EXPORT_SYMBOL (qed_route_ipv6); + +void qed_vlan_get_ndev (struct net_device **ndev,u16 *vlan_id) +{ +if (is_vlan_dev (*ndev)) { + *vlan_id =vlan_dev_vlan_id (*ndev); + *ndev =vlan_dev_real_dev (*ndev); + } +} +EXPORT_SYMBOL (qed_vlan_get_ndev); + +struct pci_dev *qed_validate_ndev (struct net_device *ndev) +{ +struct pci_dev *pdev =NULL ; +struct net_device *upper; + +for_each_pci_dev (pdev) { +if (pdev && pdev->driver && + !strcmp (pdev->driver->name,"qede" )) { + upper =pci_get_drvdata (pdev); +if (upper->ifindex == ndev->ifindex) +return pdev; + } + } + +return NULL ; +} +EXPORT_SYMBOL (qed_validate_ndev); + +__be16 qed_get_in_port (struct sockaddr_storage *sa) +{ +return sa->ss_family ==AF_INET + ? ((struct sockaddr_in *)sa)->sin_port + : ((struct sockaddr_in6 *)sa)->sin6_port; +} +EXPORT_SYMBOL (qed_get_in_port); + +int qed_fetch_tcp_port (struct sockaddr_storage local_ip_addr, +struct socket **sock,u16 *port) +{ +struct sockaddr_storage sa; +int rc =0 ; + + rc =sock_create (local_ip_addr.ss_family,SOCK_STREAM ,IPPROTO_TCP , sock); +if (rc) { +pr_warn ("failed to create socket: %d\n" , rc); + goto err; + } + + (*sock)->sk->sk_allocation =GFP_KERNEL ; +sk_set_memalloc ((*sock)->sk); + + rc =kernel_bind (*sock, (struct sockaddr *)&local_ip_addr, +sizeof (local_ip_addr)); + +if (rc) { +pr_warn ("failed to bind socket: %d\n" , rc); + goto err_sock; + } + + rc =kernel_getsockname (*sock, (struct sockaddr *)&sa); +if (rc <0 ) { +pr_warn ("getsockname() failed: %d\n" , rc); + goto err_sock; + } + + *port =ntohs (qed_get_in_port (&sa)); + +return 0 ; + +err_sock: +sock_release (*sock); + sock =NULL ; +err: + +return rc; +} +EXPORT_SYMBOL (qed_fetch_tcp_port); + +void qed_return_tcp_port (struct socket *sock) +{ +if (sock && sock->sk) { +tcp_set_state (sock->sk,TCP_CLOSE ); +sock_release (sock); + } +} +EXPORT_SYMBOL (qed_return_tcp_port);include/linux/qed/qed_nvmetcp_ip_services_if.h new file +19
-0@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* +* Copyright 2021 Marvell. All rights reserved. +*/ + +#ifndef _QED_IP_SERVICES_IF_H +#define _QED_IP_SERVICES_IF_H + +#include <linux/types.h> +#include <net/route.h> +#include <net/ip6_route.h> +#include <linux/inetdevice.h> + +int qed_route_ipv4 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev); +int qed_route_ipv6(struct sockaddr_storage *local_addr, + struct sockaddr_storage *remote_addr,
include/linux/qed/qed_nvmetcp_ip_services_if.h line 29
Quoted 10 lines
include/linux/qed/qed_nvmetcp_ip_services_if.h new file +10
-0+struct sockaddr *hardware_address, + struct net_device **ndev); +void qed_vlan_get_ndev (struct net_device **ndev,u16 *vlan_id); +struct pci_dev *qed_validate_ndev (struct net_device *ndev); +void qed_return_tcp_port (struct socket *sock); +int qed_fetch_tcp_port (struct sockaddr_storage local_ip_addr, +struct socket **sock,u16 *port); +__be16 qed_get_in_port (struct sockaddr_storage *sa); + +#endif /* _QED_IP_SERVICES_IF_H */
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 07/27] qed: Add IP services APIs support
Quoted 298 lines · Hannes Reinecke
Quoted 297 lines · Shai Malin
From: Nikolay Assa <[email protected]>
This patch introduces APIs which the NVMeTCP Offload device (qedn) will use through the paired net-device (qede).
It includes APIs for:
- ipv4/ipv6 routing
- get VLAN from net-device
- TCP ports reservationAcked-by Igor Russkikh <[email protected]>Signed-off-by Nikolay Assa <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- .../qlogic/qed/qed_nvmetcp_ip_services.c | 239 ++++++++++++++++++ .../linux/qed/qed_nvmetcp_ip_services_if.h | 29 +++ 2 files changed, 268 insertions(+)create mode 100644
drivers/net/ethernet/qlogic/qed/qed_nvmetcp_ip_services.ccreate mode 100644include/linux/qed/qed_nvmetcp_ip_services_if.hdrivers/net/ethernet/qlogic/qed/qed_nvmetcp_ip_services.c new file +239
-0@@ -0,0 +1,239 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) +/* +* Copyright 2021 Marvell. All rights reserved. +*/ + +#include <linux/types.h> +#include <asm/byteorder.h> +#include <asm/param.h> +#include <linux/delay.h> +#include <linux/pci.h> +#include <linux/dma-mapping.h> +#include <linux/etherdevice.h> +#include <linux/kernel.h> +#include <linux/stddef.h> +#include <linux/errno.h> + +#include <net/tcp.h> + +#include <linux/qed/qed_nvmetcp_ip_services_if.h> + +#define QED_IP_RESOL_TIMEOUT 4 + +int qed_route_ipv4 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev) +{ +struct neighbour *neigh =NULL ; +__be32 *loc_ip, *rem_ip; +struct rtable *rt; +int rc = -ENXIO ; +int retry; + + loc_ip = &((struct sockaddr_in *)local_addr)->sin_addr.s_addr; + rem_ip = &((struct sockaddr_in *)remote_addr)->sin_addr.s_addr; + *ndev =NULL ; + rt =ip_route_output (&init_net, *rem_ip, *loc_ip,0 /*tos*/ ,0 /*oif*/ ); +if (IS_ERR (rt)) { +pr_err ("lookup route failed\n" ); + rc =PTR_ERR (rt); + goto return_err; + } + + neigh =dst_neigh_lookup (&rt->dst, rem_ip); +if (!neigh) { + rc = -ENOMEM ; +ip_rt_put (rt); + goto return_err; + } + + *ndev = rt->dst.dev; +ip_rt_put (rt); + +/* If not resolved, kick-off state machine towards resolution */ +if (!(neigh->nud_state &NUD_VALID )) +neigh_event_send (neigh,NULL ); + +/* query neighbor until resolved or timeout */ + retry =QED_IP_RESOL_TIMEOUT ; +while (!(neigh->nud_state &NUD_VALID ) && retry >0 ) { +msleep (1000 ); + retry--; + } + +if (neigh->nud_state &NUD_VALID ) { +/* copy resolved MAC address */ +neigh_ha_snapshot (hardware_address->sa_data, neigh, *ndev); + + hardware_address->sa_family = (*ndev)->type; + rc =0 ; + } + +neigh_release (neigh); +if (!(*loc_ip)) { + *loc_ip =inet_select_addr (*ndev, *rem_ip,RT_SCOPE_UNIVERSE ); + local_addr->ss_family =AF_INET ; + } + +return_err: + +return rc; +} +EXPORT_SYMBOL (qed_route_ipv4); + +int qed_route_ipv6 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev) +{ +struct neighbour *neigh =NULL ; +struct dst_entry *dst; +struct flowi6 fl6; +int rc = -ENXIO ; +int retry; + +memset (&fl6,0 ,sizeof (fl6)); + fl6.saddr = ((struct sockaddr_in6 *)local_addr)->sin6_addr; + fl6.daddr = ((struct sockaddr_in6 *)remote_addr)->sin6_addr; + + dst =ip6_route_output (&init_net,NULL , &fl6); +if (!dst || dst->error) { +if (dst) { +dst_release (dst); +pr_err ("lookup route failed %d\n" , dst->error); + } + + goto out; + } + + neigh =dst_neigh_lookup (dst, &fl6.daddr); +if (neigh) { + *ndev =ip6_dst_idev (dst)->dev; + +/* If not resolved, kick-off state machine towards resolution */ +if (!(neigh->nud_state &NUD_VALID )) +neigh_event_send (neigh,NULL ); + +/* query neighbor until resolved or timeout */ + retry =QED_IP_RESOL_TIMEOUT ; +while (!(neigh->nud_state &NUD_VALID ) && retry >0 ) { +msleep (1000 ); + retry--; + } + +if (neigh->nud_state &NUD_VALID ) { +neigh_ha_snapshot ((u8 *)hardware_address->sa_data, neigh, *ndev); + + hardware_address->sa_family = (*ndev)->type; + rc =0 ; + } + +neigh_release (neigh); + +if (ipv6_addr_any (&fl6.saddr)) { +if (ipv6_dev_get_saddr (dev_net (*ndev), *ndev, + &fl6.daddr,0 , &fl6.saddr)) { +pr_err ("Unable to find source IP address\n" ); + goto out; + } + + local_addr->ss_family =AF_INET6 ; + ((struct sockaddr_in6 *)local_addr)->sin6_addr = + fl6.saddr; + } + } + +dst_release (dst); + +out: + +return rc; +} +EXPORT_SYMBOL (qed_route_ipv6); + +void qed_vlan_get_ndev (struct net_device **ndev,u16 *vlan_id) +{ +if (is_vlan_dev (*ndev)) { + *vlan_id =vlan_dev_vlan_id (*ndev); + *ndev =vlan_dev_real_dev (*ndev); + } +} +EXPORT_SYMBOL (qed_vlan_get_ndev); + +struct pci_dev *qed_validate_ndev (struct net_device *ndev) +{ +struct pci_dev *pdev =NULL ; +struct net_device *upper; + +for_each_pci_dev (pdev) { +if (pdev && pdev->driver && + !strcmp (pdev->driver->name,"qede" )) { + upper =pci_get_drvdata (pdev); +if (upper->ifindex == ndev->ifindex) +return pdev; + } + } + +return NULL ; +} +EXPORT_SYMBOL (qed_validate_ndev); + +__be16 qed_get_in_port (struct sockaddr_storage *sa) +{ +return sa->ss_family ==AF_INET + ? ((struct sockaddr_in *)sa)->sin_port + : ((struct sockaddr_in6 *)sa)->sin6_port; +} +EXPORT_SYMBOL (qed_get_in_port); + +int qed_fetch_tcp_port (struct sockaddr_storage local_ip_addr, +struct socket **sock,u16 *port) +{ +struct sockaddr_storage sa; +int rc =0 ; + + rc =sock_create (local_ip_addr.ss_family,SOCK_STREAM ,IPPROTO_TCP , sock); +if (rc) { +pr_warn ("failed to create socket: %d\n" , rc); + goto err; + } + + (*sock)->sk->sk_allocation =GFP_KERNEL ; +sk_set_memalloc ((*sock)->sk); + + rc =kernel_bind (*sock, (struct sockaddr *)&local_ip_addr, +sizeof (local_ip_addr)); + +if (rc) { +pr_warn ("failed to bind socket: %d\n" , rc); + goto err_sock; + } + + rc =kernel_getsockname (*sock, (struct sockaddr *)&sa); +if (rc <0 ) { +pr_warn ("getsockname() failed: %d\n" , rc); + goto err_sock; + } + + *port =ntohs (qed_get_in_port (&sa)); + +return 0 ; + +err_sock: +sock_release (*sock); + sock =NULL ; +err: + +return rc; +} +EXPORT_SYMBOL (qed_fetch_tcp_port); + +void qed_return_tcp_port (struct socket *sock) +{ +if (sock && sock->sk) { +tcp_set_state (sock->sk,TCP_CLOSE ); +sock_release (sock); + } +} +EXPORT_SYMBOL (qed_return_tcp_port);include/linux/qed/qed_nvmetcp_ip_services_if.h new file +23
-0@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ +/* +* Copyright 2021 Marvell. All rights reserved. +*/ + +#ifndef _QED_IP_SERVICES_IF_H +#define _QED_IP_SERVICES_IF_H + +#include <linux/types.h> +#include <net/route.h> +#include <net/ip6_route.h> +#include <linux/inetdevice.h> + +int qed_route_ipv4 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev); +int qed_route_ipv6 (struct sockaddr_storage *local_addr, +struct sockaddr_storage *remote_addr, +struct sockaddr *hardware_address, +struct net_device **ndev); +void qed_vlan_get_ndev (struct net_device **ndev,u16 *vlan_id); +struct pci_dev *qed_validate_ndev (struct net_device *ndev);
Quoted 9 lines
include/linux/qed/qed_nvmetcp_ip_services_if.h line 29
Quoted 7 lines
include/linux/qed/qed_nvmetcp_ip_services_if.h new file +6
-0+void qed_return_tcp_port (struct socket *sock); +int qed_fetch_tcp_port (struct sockaddr_storage local_ip_addr, +struct socket **sock,u16 *port); +__be16 qed_get_in_port (struct sockaddr_storage *sa); + +#endif /* _QED_IP_SERVICES_IF_H */ Reviewed-by Hannes Reinecke <[email protected]>
Thanks.
Quoted 8 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 8/27 nvme-tcp-offload: Add nvme-tcp-offload - NVMeTCP HW offload ULP
In reply to Shai MalinThis patch will present the structure for the NVMeTCP offload common layer driver. This module is added under "drivers/nvme/host/" and future offload drivers which will register to it will be placed under "drivers/nvme/hw".
This new driver will be enabled by the Kconfig "NVM Express over Fabrics TCP offload commmon layer".
In order to support the new transport type, for host mode, no change is needed.
Each new vendor-specific offload driver will register to this ULP during its probe function, by filling out the nvme_tcp_ofld_dev->ops and nvme_tcp_ofld_dev->private_data and calling nvme_tcp_ofld_register_dev with the initialized struct.
The internal implementation:
- tcp-offload.h:
Includes all common structs and ops to be used and shared by offload drivers.
- tcp-offload.c:
Includes the init function which registers as a NVMf transport just like any other transport.
--- drivers/nvme/host/Kconfig | 16 +++ drivers/nvme/host/Makefile | 3 + drivers/nvme/host/tcp-offload.c | 126 +++++++++++++++++++ drivers/nvme/host/tcp-offload.h | 206 ++++++++++++++++++++++++++++++++ 4 files changed, 351 insertions(+) create mode 100644 drivers/nvme/host/tcp-offload.c create mode 100644 drivers/nvme/host/tcp-offload.h
drivers/nvme/host/Kconfig +16 -0
@@ -84,3 +84,19 @@ config NVME_TCP from https://github.com/linux-nvme/nvme-cli. If unsure, say N. + +config NVME_TCP_OFFLOAD + tristate "NVM Express over Fabrics TCP offload common layer" + default m + depends on INET + depends on BLK_DEV_NVME + select NVME_FABRICS + help + This provides support for the NVMe over Fabrics protocol using + the TCP offload transport. This allows you to use remote block devices + exported using the NVMe protocol set. + + To configure a NVMe over Fabrics controller use the nvme-cli tool + from https://github.com/linux-nvme/nvme-cli. + + If unsure, say N.
drivers/nvme/host/Makefile +3 -0
@@ -8,6 +8,7 @@ obj-$(CONFIG_NVME_FABRICS) += nvme-fabrics.o obj-$(CONFIG_NVME_RDMA) += nvme-rdma.o obj-$(CONFIG_NVME_FC) += nvme-fc.o obj-$(CONFIG_NVME_TCP) += nvme-tcp.o +obj-$(CONFIG_NVME_TCP_OFFLOAD) += nvme-tcp-offload.o nvme-core-y := core.o nvme-core-$(CONFIG_TRACING) += trace.o
@@ -26,3 +27,5 @@ nvme-rdma-y += rdma.o nvme-fc-y += fc.o nvme-tcp-y += tcp.o + +nvme-tcp-offload-y += tcp-offload.o
drivers/nvme/host/tcp-offload.c new file +126 -0
126 lines not on this page · raw message
drivers/nvme/host/tcp-offload.h new file +206 -0
206 lines not on this page · raw message
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
kernel test robot
build botRe: [RFC PATCH v4 08/27] nvme-tcp-offload: Add nvme-tcp-offload - NVMeTCP HW offload ULP
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]
Hi Shai,
[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on ipvs/master]
[also build test WARNING on linus/master v5.12 next-20210429] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 base: https://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git master config: x86_64-randconfig-s021-20210429 (attached as .config) compiler: gcc-9 (Debian 9.3.0-22) 9.3.0 reproduce: # apt-get install sparse # sparse version: v0.6.3-341-g8af24329-dirty # https://github.com/0day-ci/linux/commit/0db296abc14fe7b09c722148eaa14d03169f4d4a git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 git checkout 0db296abc14fe7b09c722148eaa14d03169f4d4a # save the attached .config to linux build tree make W=1 C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' W=1 ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
sparse warnings: (new ones prefixed by >>)
>> drivers/nvme/host/tcp-offload.c:76:5: sparse: sparse: symbol 'nvme_tcp_ofld_report_queue_err' was not declared. Should it be static? >> drivers/nvme/host/tcp-offload.c:94:6: sparse: sparse: symbol 'nvme_tcp_ofld_req_done' was not declared. Should it be static?
Please review and possibly fold the followup patch.
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
kernel test robot
build bot[RFC PATCH] nvme-tcp-offload: nvme_tcp_ofld_report_queue_err() can be static
In reply to Shai Malindrivers/nvme/host/tcp-offload.c:76:5: warning: symbol 'nvme_tcp_ofld_report_queue_err' was not declared. Should it be static? drivers/nvme/host/tcp-offload.c:94:6: warning: symbol…
drivers/nvme/host/tcp-offload.c:76:5: warning: symbol 'nvme_tcp_ofld_report_queue_err' was not declared. Should it be static? drivers/nvme/host/tcp-offload.c:94:6: warning: symbol 'nvme_tcp_ofld_req_done' was not declared. Should it be static?
--- tcp-offload.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/nvme/host/tcp-offload.c +4 -4
@@ -73,7 +73,7 @@ EXPORT_SYMBOL_GPL(nvme_tcp_ofld_unregister_dev);* API function that allows the vendor specific offload driver to reports errors * to the common offload layer, to invoke error recovery. */ -int nvme_tcp_ofld_report_queue_err (struct nvme_tcp_ofld_queue *queue) +static int nvme_tcp_ofld_report_queue_err (struct nvme_tcp_ofld_queue *queue) {/* Placeholder - invoke error recovery flow */
@@ -91,9 +91,9 @@ int nvme_tcp_ofld_report_queue_err(struct nvme_tcp_ofld_queue *queue)* API function that allows the vendor specific offload driver to report request * completions to the common offload layer. */ -void nvme_tcp_ofld_req_done (struct nvme_tcp_ofld_req *req, -union nvme_result *result, -__le16 status) +static void nvme_tcp_ofld_req_done (struct nvme_tcp_ofld_req *req, +union nvme_result *result, +__le16 status) {/* Placeholder - complete request with/without error */ }
Re: [RFC PATCH v4 08/27] nvme-tcp-offload: Add nvme-tcp-offload - NVMeTCP HW offload ULP
In reply to Shai MalinQuoted 30 lines · Shai Malin
This patch will present the structure for the NVMeTCP offload common layer driver. This module is added under "
drivers/nvme/host/" and future offload drivers which will register to it will be placed under "drivers/nvme/hw".
This new driver will be enabled by theKconfig"NVM Express over Fabrics TCP offload commmon layer".
In order to support the new transport type, for host mode, no change is needed.Each new vendor-specific offload driver will register to this ULP during its probe function, by filling out the
nvme_tcp_ofld_dev->opsandnvme_tcp_ofld_dev->private_dataand callingnvme_tcp_ofld_register_devwith the initialized struct.The internal implementation:
-tcp-offload.h:
Includes all common structs and ops to be used and shared by offload drivers.-
tcp-offload.c:
Includes the init function which registers as a NVMf transport just like any other transport.Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>
Quoted 9 lines
--- drivers/nvme/host/Kconfig | 16 +++ drivers/nvme/host/Makefile | 3 + drivers/nvme/host/tcp-offload.c | 126 +++++++++++++++++++ drivers/nvme/host/tcp-offload.h | 206 ++++++++++++++++++++++++++++++++ 4 files changed, 351 insertions(+)create mode 100644
drivers/nvme/host/tcp-offload.ccreate mode 100644drivers/nvme/host/tcp-offload.h
It will be tricky to select the correct transport eg when traversing the discovery log page; the discovery log page only knows about 'tcp' (not 'tcp_offload'), so the offload won't be picked up. But that can we worked on / fixed later on, as it's arguably a policy decision.
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 08/27] nvme-tcp-offload: Add nvme-tcp-offload - NVMeTCP HW offload ULP
Quoted 40 lines · Hannes Reinecke
Quoted 30 lines · Shai Malin
This patch will present the structure for the NVMeTCP offload common layer driver. This module is added under "
drivers/nvme/host/" and future offload drivers which will register to it will be placed under "drivers/nvme/hw".
This new driver will be enabled by theKconfig"NVM Express over Fabrics TCP offload commmon layer".
In order to support the new transport type, for host mode, no change is needed.Each new vendor-specific offload driver will register to this ULP during its probe function, by filling out the
nvme_tcp_ofld_dev->opsandnvme_tcp_ofld_dev->private_dataand callingnvme_tcp_ofld_register_devwith the initialized struct.The internal implementation:
-tcp-offload.h:
Includes all common structs and ops to be used and shared by offload drivers.-
tcp-offload.c:
Includes the init function which registers as a NVMf transport just like any other transport.Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>Quoted 9 lines
--- drivers/nvme/host/Kconfig | 16 +++ drivers/nvme/host/Makefile | 3 + drivers/nvme/host/tcp-offload.c | 126 +++++++++++++++++++ drivers/nvme/host/tcp-offload.h | 206 ++++++++++++++++++++++++++++++++ 4 files changed, 351 insertions(+)create mode 100644
drivers/nvme/host/tcp-offload.ccreate mode 100644drivers/nvme/host/tcp-offload.h
Quoted 5 lines
It will be tricky to select the correct transport eg when traversing the discovery log page; the discovery log page only knows about 'tcp' (not '
tcp_offload'), so the offload won't be picked up.
But that can we worked on / fixed later on, as it's arguably a policy decision.
I agree that we should improve the policy decision and allow additional capabilities and it may be discussed as a new NVMe TPAR.
Quoted 2 lines
Reviewed-by Hannes Reinecke <[email protected]>
Thanks.
Quoted 9 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 9/27 nvme-fabrics: Move NVMF_ALLOWED_OPTS and NVMF_REQUIRED_OPTS definitions
In reply to Shai MalinFrom: Arie Gershberg <[email protected]>
Move NVMF_ALLOWED_OPTS and NVMF_REQUIRED_OPTS definitions to header file, so it can be used by transport modules.
--- drivers/nvme/host/fabrics.c | 7 ------- drivers/nvme/host/fabrics.h | 7 +++++++ 2 files changed, 7 insertions(+), 7 deletions(-)
drivers/nvme/host/fabrics.c +0 -7
@@ -1001,13 +1001,6 @@ void nvmf_free_options(struct nvmf_ctrl_options *opts) }EXPORT_SYMBOL_GPL (nvmf_free_options); -#define NVMF_REQUIRED_OPTS (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN) -#define NVMF_ALLOWED_OPTS (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \ - NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \ - NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\ - NVMF_OPT_DISABLE_SQFLOW |\ - NVMF_OPT_FAIL_FAST_TMO) -static struct nvme_ctrl *nvmf_create_ctrl (struct device *dev,const char *buf) {
drivers/nvme/host/fabrics.h +7 -0
@@ -68,6 +68,13 @@ enum { NVMF_OPT_FAIL_FAST_TMO = 1 << 20, }; +#define NVMF_REQUIRED_OPTS (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN) +#define NVMF_ALLOWED_OPTS (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \ + NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \ + NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\ + NVMF_OPT_DISABLE_SQFLOW |\ + NVMF_OPT_FAIL_FAST_TMO) +/** * struct nvmf_ctrl_options - Used to hold the options specified * with the parsing opts enum.
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 09/27] nvme-fabrics: Move NVMF_ALLOWED_OPTS and NVMF_REQUIRED_OPTS definitions
Quoted 44 lines · Shai Malin
From: Arie Gershberg <[email protected]>
Move
NVMF_ALLOWED_OPTSandNVMF_REQUIRED_OPTSdefinitions to header file, so it can be used by transport modules.Acked-by Igor Russkikh <[email protected]>Signed-off-by Arie Gershberg <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/fabrics.c | 7 ------- drivers/nvme/host/fabrics.h | 7 +++++++ 2 files changed, 7 insertions(+), 7 deletions(-)drivers/nvme/host/fabrics.c +0
-7@@ -1001,13 +1001,6 @@ void nvmf_free_options(struct nvmf_ctrl_options *opts) }EXPORT_SYMBOL_GPL (nvmf_free_options); -#define NVMF_REQUIRED_OPTS (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN) -#define NVMF_ALLOWED_OPTS (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \ - NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \ - NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\ - NVMF_OPT_DISABLE_SQFLOW |\ - NVMF_OPT_FAIL_FAST_TMO) -static struct nvme_ctrl *nvmf_create_ctrl (struct device *dev,const char *buf) {drivers/nvme/host/fabrics.h +0
-0@@ -68,6 +68,13 @@ enum { NVMF_OPT_FAIL_FAST_TMO = 1 << 20, };
drivers/nvme/host/fabrics.h enum { · line 80
Quoted 10 lines
drivers/nvme/host/fabrics.h +7
-0+#define NVMF_REQUIRED_OPTS (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN) +#define NVMF_ALLOWED_OPTS (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \ + NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \ + NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\ + NVMF_OPT_DISABLE_SQFLOW |\ + NVMF_OPT_FAIL_FAST_TMO) +/** * struct nvmf_ctrl_options - Used to hold the options specified * with the parsing opts enum.
Why do you need them? None of the other transport drivers use them, why you?
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 09/27] nvme-fabrics: Move NVMF_ALLOWED_OPTS and NVMF_REQUIRED_OPTS definitions
Quoted 44 lines · Hannes Reinecke
Quoted 43 lines · Shai Malin
From: Arie Gershberg <[email protected]>
Move
NVMF_ALLOWED_OPTSandNVMF_REQUIRED_OPTSdefinitions to header file, so it can be used by transport modules.Acked-by Igor Russkikh <[email protected]>Signed-off-by Arie Gershberg <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/fabrics.c | 7 ------- drivers/nvme/host/fabrics.h | 7 +++++++ 2 files changed, 7 insertions(+), 7 deletions(-)drivers/nvme/host/fabrics.c +0
-7@@ -1001,13 +1001,6 @@ void nvmf_free_options(struct nvmf_ctrl_options *opts) }EXPORT_SYMBOL_GPL (nvmf_free_options); -#define NVMF_REQUIRED_OPTS (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN) -#define NVMF_ALLOWED_OPTS (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \ - NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \ - NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\ - NVMF_OPT_DISABLE_SQFLOW |\ - NVMF_OPT_FAIL_FAST_TMO) -static struct nvme_ctrl *nvmf_create_ctrl (struct device *dev,const char *buf) {drivers/nvme/host/fabrics.h +0
-0@@ -68,6 +68,13 @@ enum { NVMF_OPT_FAIL_FAST_TMO = 1 << 20, };
Quoted 14 lines
drivers/nvme/host/fabrics.h enum { · line 80
Quoted 11 lines
drivers/nvme/host/fabrics.h +7
-0+#define NVMF_REQUIRED_OPTS (NVMF_OPT_TRANSPORT | NVMF_OPT_NQN) +#define NVMF_ALLOWED_OPTS (NVMF_OPT_QUEUE_SIZE | NVMF_OPT_NR_IO_QUEUES | \ + NVMF_OPT_KATO | NVMF_OPT_HOSTNQN | \ + NVMF_OPT_HOST_ID | NVMF_OPT_DUP_CONNECT |\ + NVMF_OPT_DISABLE_SQFLOW |\ + NVMF_OPT_FAIL_FAST_TMO) +/** * struct nvmf_ctrl_options - Used to hold the options specified * with the parsing opts enum. Why do you need them? None of the other transport drivers use them, why you?
Different HW devices that are offloading the NVMeTCP might have different limitations of the allowed options.
For example, a device that does not support all the queue types. With tcp and rdma, only the nvme-tcp and nvme-rdma layers handle those attributes and the HW devices do not create any limitations for the allowed options.
An alternative design could be to add separate fields in nvme_tcp_ofld_ops such as max_hw_sectors and max_segments that we already have in this series.
Which would you prefer?
Quoted 8 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 10/27 nvme-tcp-offload: Add device scan implementation
In reply to Shai MalinFrom: Dean Balandin <[email protected]>
As part of create_ctrl(), it scans the registered devices and calls the claim_dev op on each of them, to find the first devices that matches the connection params. Once the correct devices is found (claim_dev returns true), we raise the refcnt of that device and return that device as the device to be used for ctrl currently being created.
--- drivers/nvme/host/tcp-offload.c | 94 +++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+)
drivers/nvme/host/tcp-offload.c +94 -0
@@ -13,6 +13,11 @@static LIST_HEAD (nvme_tcp_ofld_devices);static DECLARE_RWSEM (nvme_tcp_ofld_devices_rwsem); +static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl (struct nvme_ctrl *nctrl) +{ + return container_of(nctrl, struct nvme_tcp_ofld_ctrl, nctrl); +} +/** * nvme_tcp_ofld_register_dev() - NVMeTCP Offload Library registration * function.
@@ -98,6 +103,94 @@ void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,/* Placeholder - complete request with/without error */ } +struct nvme_tcp_ofld_dev * +nvme_tcp_ofld_lookup_dev (struct nvme_tcp_ofld_ctrl *ctrl) +{ +struct nvme_tcp_ofld_dev *dev; + +down_read (&nvme_tcp_ofld_devices_rwsem); +list_for_each_entry (dev, &nvme_tcp_ofld_devices, entry) { +if (dev->ops->claim_dev (dev, &ctrl->conn_params)) { +/* Increase driver refcnt */ +if (!try_module_get (dev->ops->module)) { +pr_err ("try_module_get failed\n" ); + dev =NULL ; + } + + goto out; + } + } + + dev =NULL ; +out: +up_read (&nvme_tcp_ofld_devices_rwsem); + +return dev; +} + +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) +{ +/* Placeholder - validates inputs and creates admin and IO queues */ + +return 0 ; +} + +static struct nvme_ctrl * +nvme_tcp_ofld_create_ctrl (struct device *ndev,struct nvmf_ctrl_options *opts) +{ +struct nvme_tcp_ofld_ctrl *ctrl; +struct nvme_tcp_ofld_dev *dev; +struct nvme_ctrl *nctrl; +int rc =0 ; + + ctrl =kzalloc (sizeof (*ctrl),GFP_KERNEL ); +if (!ctrl) +return ERR_PTR (-ENOMEM ); + + nctrl = &ctrl->nctrl; + +/* Init nvme_tcp_ofld_ctrl and nvme_ctrl params based on received opts */ + +/* Find device that can reach the dest addr */ + dev =nvme_tcp_ofld_lookup_dev (ctrl); +if (!dev) { +pr_info ("no device found for addr %s:%s.\n" , + opts->traddr, opts->trsvcid); + rc = -EINVAL ; + goto out_free_ctrl; + } + + ctrl->dev = dev; + +if (ctrl->dev->ops->max_hw_sectors) + nctrl->max_hw_sectors = ctrl->dev->ops->max_hw_sectors; +if (ctrl->dev->ops->max_segments) + nctrl->max_segments = ctrl->dev->ops->max_segments; + +/* Init queues */ + +/* Call nvme_init_ctrl */ + + rc = ctrl->dev->ops->setup_ctrl (ctrl, true); +if (rc) + goto out_module_put; + + rc =nvme_tcp_ofld_setup_ctrl (nctrl, true); +if (rc) + goto out_uninit_ctrl; + +return nctrl; + +out_uninit_ctrl: + ctrl->dev->ops->release_ctrl (ctrl); +out_module_put: +module_put (dev->ops->module); +out_free_ctrl: +kfree (ctrl); + +return ERR_PTR (rc); +} +static struct nvmf_transport_ops nvme_tcp_ofld_transport = { .name ="tcp_offload" , .module =THIS_MODULE ,
@@ -107,6 +200,7 @@ static struct nvmf_transport_ops nvme_tcp_ofld_transport = {NVMF_OPT_RECONNECT_DELAY |NVMF_OPT_HDR_DIGEST |NVMF_OPT_DATA_DIGEST |NVMF_OPT_NR_POLL_QUEUES | NVMF_OPT_TOS, + .create_ctrl = nvme_tcp_ofld_create_ctrl, };static int __init nvme_tcp_ofld_init_module (void )
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
kernel test robot
build botRe: [RFC PATCH v4 10/27] nvme-tcp-offload: Add device scan implementation
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]
Hi Shai,
[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on ipvs/master]
[also build test WARNING on linus/master v5.12 next-20210429] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 base: https://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git master config: x86_64-randconfig-s021-20210429 (attached as .config) compiler: gcc-9 (Debian 9.3.0-22) 9.3.0 reproduce: # apt-get install sparse # sparse version: v0.6.3-341-g8af24329-dirty # https://github.com/0day-ci/linux/commit/08328760bdbc2f5a78d7a4cf9bdc058d5120abb4 git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 git checkout 08328760bdbc2f5a78d7a4cf9bdc058d5120abb4 # save the attached .config to linux build tree make W=1 C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' W=1 ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
sparse warnings: (new ones prefixed by >>)
drivers/nvme/host/tcp-offload.c:81:5: sparse: sparse: symbol 'nvme_tcp_ofld_report_queue_err' was not declared. Should it be static? drivers/nvme/host/tcp-offload.c:99:6: sparse: sparse: symbol 'nvme_tcp_ofld_req_done' was not declared. Should it be static?
>> drivers/nvme/host/tcp-offload.c:106:26: sparse: sparse: symbol 'nvme_tcp_ofld_lookup_dev' was not declared. Should it be static?
Please review and possibly fold the followup patch.
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
kernel test robot
build bot[RFC PATCH] nvme-tcp-offload: nvme_tcp_ofld_lookup_dev can be static
In reply to Shai Malindrivers/nvme/host/tcp-offload.c:106:26: warning: symbol 'nvme_tcp_ofld_lookup_dev' was not declared. Should it be static?
drivers/nvme/host/tcp-offload.c:106:26: warning: symbol 'nvme_tcp_ofld_lookup_dev' was not declared. Should it be static?
--- tcp-offload.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/nvme/host/tcp-offload.c +1 -1
@@ -103,7 +103,7 @@ void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,/* Placeholder - complete request with/without error */ } -struct nvme_tcp_ofld_dev * +static struct nvme_tcp_ofld_dev *nvme_tcp_ofld_lookup_dev (struct nvme_tcp_ofld_ctrl *ctrl) {struct nvme_tcp_ofld_dev *dev;
kernel test robot
build botRe: [RFC PATCH v4 10/27] nvme-tcp-offload: Add device scan implementation
In reply to Shai Malin[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]
Hi Shai,
[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on ipvs/master]
[also build test WARNING on hch-configfs/for-next linus/master v5.12 next-20210429] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 base: https://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git master config: x86_64-randconfig-a011-20210429 (attached as .config) compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 9131a078901b00e68248a27a4f8c4b11bb1db1ae)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# https://github.com/0day-ci/linux/commit/08328760bdbc2f5a78d7a4cf9bdc058d5120abb4
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 git checkout 08328760bdbc2f5a78d7a4cf9bdc058d5120abb4
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
drivers/nvme/host/tcp-offload.c:81:5: warning: no previous prototype for function 'nvme_tcp_ofld_report_queue_err' [-Wmissing-prototypes] int nvme_tcp_ofld_report_queue_err(struct nvme_tcp_ofld_queue *queue)
^
drivers/nvme/host/tcp-offload.c:81:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
int nvme_tcp_ofld_report_queue_err(struct nvme_tcp_ofld_queue *queue)
^
static
drivers/nvme/host/tcp-offload.c:99:6: warning: no previous prototype for function 'nvme_tcp_ofld_req_done' [-Wmissing-prototypes]
void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,
^
drivers/nvme/host/tcp-offload.c:99:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,
^
static
>> drivers/nvme/host/tcp-offload.c:107:1: warning: no previous prototype for function 'nvme_tcp_ofld_lookup_dev' [-Wmissing-prototypes]
nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)
^
drivers/nvme/host/tcp-offload.c:106:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
struct nvme_tcp_ofld_dev *
^
static
drivers/nvme/host/tcp-offload.c:16:42: warning: unused function 'to_tcp_ofld_ctrl' [-Wunused-function]
static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl(struct nvme_ctrl *nctrl)
^4 warnings generated.
vim +/nvme_tcp_ofld_lookup_dev +107 drivers/nvme/host/tcp-offload.c
105
106 struct nvme_tcp_ofld_dev *
> 107 nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)
108 {
109 struct nvme_tcp_ofld_dev *dev;
110
111 down_read(&nvme_tcp_ofld_devices_rwsem);
112 list_for_each_entry(dev, &nvme_tcp_ofld_devices, entry) {
113 if (dev->ops->claim_dev(dev, &ctrl->conn_params)) {
114 /* Increase driver refcnt */
115 if (!try_module_get(dev->ops->module)) {
116 pr_err("try_module_get failed\n");
117 dev = NULL;
118 }
119
120 goto out;
121 }
122 }
123
124 dev = NULL;
125 out:
126 up_read(&nvme_tcp_ofld_devices_rwsem);
127
128 return dev;
129 }
130
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
kernel test robot
build botRe: [RFC PATCH v4 10/27] nvme-tcp-offload: Add device scan implementation
In reply to Shai Malin[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]
Hi Shai,
[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on ipvs/master]
[also build test WARNING on hch-configfs/for-next linus/master v5.12 next-20210429] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 base: https://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git master config: alpha-randconfig-r014-20210429 (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/08328760bdbc2f5a78d7a4cf9bdc058d5120abb4
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 git checkout 08328760bdbc2f5a78d7a4cf9bdc058d5120abb4
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross W=1 ARCH=alpha
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
drivers/nvme/host/tcp-offload.c:81:5: warning: no previous prototype for 'nvme_tcp_ofld_report_queue_err' [-Wmissing-prototypes]
81 | int nvme_tcp_ofld_report_queue_err(struct nvme_tcp_ofld_queue *queue)
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/nvme/host/tcp-offload.c:99:6: warning: no previous prototype for 'nvme_tcp_ofld_req_done' [-Wmissing-prototypes]
99 | void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,
| ^~~~~~~~~~~~~~~~~~~~~~
>> drivers/nvme/host/tcp-offload.c:107:1: warning: no previous prototype for 'nvme_tcp_ofld_lookup_dev' [-Wmissing-prototypes]
107 | nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)
| ^~~~~~~~~~~~~~~~~~~~~~~~
vim +/nvme_tcp_ofld_lookup_dev +107 drivers/nvme/host/tcp-offload.c
105
106 struct nvme_tcp_ofld_dev *
> 107 nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)
108 {
109 struct nvme_tcp_ofld_dev *dev;
110
111 down_read(&nvme_tcp_ofld_devices_rwsem);
112 list_for_each_entry(dev, &nvme_tcp_ofld_devices, entry) {
113 if (dev->ops->claim_dev(dev, &ctrl->conn_params)) {
114 /* Increase driver refcnt */
115 if (!try_module_get(dev->ops->module)) {
116 pr_err("try_module_get failed\n");
117 dev = NULL;
118 }
119
120 goto out;
121 }
122 }
123
124 dev = NULL;
125 out:
126 up_read(&nvme_tcp_ofld_devices_rwsem);
127
128 return dev;
129 }
130
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [RFC PATCH v4 10/27] nvme-tcp-offload: Add device scan implementation
In reply to Shai MalinQuoted 132 lines · Shai Malin
From: Dean Balandin <[email protected]>
As part of
create_ctrl(), it scans the registered devices and calls theclaim_devop on each of them, to find the first devices that matches the connection params. Once the correct devices is found (claim_devreturns true), we raise the refcnt of that device and return that device as the device to be used for ctrl currently being created.Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/tcp-offload.c | 94 +++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+)drivers/nvme/host/tcp-offload.c +93
-0@@ -13,6 +13,11 @@static LIST_HEAD (nvme_tcp_ofld_devices);static DECLARE_RWSEM (nvme_tcp_ofld_devices_rwsem); +static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl (struct nvme_ctrl *nctrl) +{ + return container_of(nctrl, struct nvme_tcp_ofld_ctrl, nctrl); +} +/** * nvme_tcp_ofld_register_dev() - NVMeTCP Offload Library registration * function. @@ -98,6 +103,94 @@ void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,/* Placeholder - complete request with/without error */ } +struct nvme_tcp_ofld_dev * +nvme_tcp_ofld_lookup_dev (struct nvme_tcp_ofld_ctrl *ctrl) +{ +struct nvme_tcp_ofld_dev *dev; + +down_read (&nvme_tcp_ofld_devices_rwsem); +list_for_each_entry (dev, &nvme_tcp_ofld_devices, entry) { +if (dev->ops->claim_dev (dev, &ctrl->conn_params)) { +/* Increase driver refcnt */ +if (!try_module_get (dev->ops->module)) { +pr_err ("try_module_get failed\n" ); + dev =NULL ; + } + + goto out; + } + } + + dev =NULL ; +out: +up_read (&nvme_tcp_ofld_devices_rwsem); + +return dev; +} + +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) +{ +/* Placeholder - validates inputs and creates admin and IO queues */ + +return 0 ; +} + +static struct nvme_ctrl * +nvme_tcp_ofld_create_ctrl (struct device *ndev,struct nvmf_ctrl_options *opts) +{ +struct nvme_tcp_ofld_ctrl *ctrl; +struct nvme_tcp_ofld_dev *dev; +struct nvme_ctrl *nctrl; +int rc =0 ; + + ctrl =kzalloc (sizeof (*ctrl),GFP_KERNEL ); +if (!ctrl) +return ERR_PTR (-ENOMEM ); + + nctrl = &ctrl->nctrl; + +/* Init nvme_tcp_ofld_ctrl and nvme_ctrl params based on received opts */ + +/* Find device that can reach the dest addr */ + dev =nvme_tcp_ofld_lookup_dev (ctrl); +if (!dev) { +pr_info ("no device found for addr %s:%s.\n" , + opts->traddr, opts->trsvcid); + rc = -EINVAL ; + goto out_free_ctrl; + } + + ctrl->dev = dev; + +if (ctrl->dev->ops->max_hw_sectors) + nctrl->max_hw_sectors = ctrl->dev->ops->max_hw_sectors; +if (ctrl->dev->ops->max_segments) + nctrl->max_segments = ctrl->dev->ops->max_segments; + +/* Init queues */ + +/* Call nvme_init_ctrl */ + + rc = ctrl->dev->ops->setup_ctrl (ctrl, true); +if (rc) + goto out_module_put; + + rc =nvme_tcp_ofld_setup_ctrl (nctrl, true); +if (rc) + goto out_uninit_ctrl; + +return nctrl; + +out_uninit_ctrl: + ctrl->dev->ops->release_ctrl (ctrl); +out_module_put: +module_put (dev->ops->module); +out_free_ctrl: +kfree (ctrl); + +return ERR_PTR (rc); +} +static struct nvmf_transport_ops nvme_tcp_ofld_transport = { .name ="tcp_offload" , .module =THIS_MODULE ,
drivers/nvme/host/tcp-offload.c static struct nvmf_transport_ops nvme_tcp_ofld_transport = { · line 206
Quoted 7 lines
drivers/nvme/host/tcp-offload.c +1
-0@@ -107,6 +200,7 @@ static struct nvmf_transport_ops nvme_tcp_ofld_transport = {NVMF_OPT_RECONNECT_DELAY |NVMF_OPT_HDR_DIGEST |NVMF_OPT_DATA_DIGEST |NVMF_OPT_NR_POLL_QUEUES | NVMF_OPT_TOS, + .create_ctrl = nvme_tcp_ofld_create_ctrl, };static int __init nvme_tcp_ofld_init_module (void )
I wonder if we shouldn't take the approach from Martin Belanger, and introduce a new option 'host_iface' to select the interface to use.
That is, _if_ the nvme-tcp offload driver would present itself as a network interface; one might argue that it would put too much restriction on the implementations.
But if it does not present itself as a network interface, how do we address it? And if it does, wouldn't we be better off to specify the interface directly, and not try to imply the interface from the IP address?
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 10/27] nvme-tcp-offload: Add device scan implementation
Quoted 138 lines · Hannes Reinecke
Quoted 137 lines · Shai Malin
From: Dean Balandin <[email protected]>
As part of
create_ctrl(), it scans the registered devices and calls theclaim_devop on each of them, to find the first devices that matches the connection params. Once the correct devices is found (claim_devreturns true), we raise the refcnt of that device and return that device as the device to be used for ctrl currently being created.Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/tcp-offload.c | 94 +++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+)drivers/nvme/host/tcp-offload.c +94
-0@@ -13,6 +13,11 @@static LIST_HEAD (nvme_tcp_ofld_devices);static DECLARE_RWSEM (nvme_tcp_ofld_devices_rwsem); +static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl (struct nvme_ctrl *nctrl) +{ + return container_of(nctrl, struct nvme_tcp_ofld_ctrl, nctrl); +} +/** * nvme_tcp_ofld_register_dev() - NVMeTCP Offload Library registration * function. @@ -98,6 +103,94 @@ void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,/* Placeholder - complete request with/without error */ } +struct nvme_tcp_ofld_dev * +nvme_tcp_ofld_lookup_dev (struct nvme_tcp_ofld_ctrl *ctrl) +{ +struct nvme_tcp_ofld_dev *dev; + +down_read (&nvme_tcp_ofld_devices_rwsem); +list_for_each_entry (dev, &nvme_tcp_ofld_devices, entry) { +if (dev->ops->claim_dev (dev, &ctrl->conn_params)) { +/* Increase driver refcnt */ +if (!try_module_get (dev->ops->module)) { +pr_err ("try_module_get failed\n" ); + dev =NULL ; + } + + goto out; + } + } + + dev =NULL ; +out: +up_read (&nvme_tcp_ofld_devices_rwsem); + +return dev; +} + +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) +{ +/* Placeholder - validates inputs and creates admin and IO queues */ + +return 0 ; +} + +static struct nvme_ctrl * +nvme_tcp_ofld_create_ctrl (struct device *ndev,struct nvmf_ctrl_options *opts) +{ +struct nvme_tcp_ofld_ctrl *ctrl; +struct nvme_tcp_ofld_dev *dev; +struct nvme_ctrl *nctrl; +int rc =0 ; + + ctrl =kzalloc (sizeof (*ctrl),GFP_KERNEL ); +if (!ctrl) +return ERR_PTR (-ENOMEM ); + + nctrl = &ctrl->nctrl; + +/* Init nvme_tcp_ofld_ctrl and nvme_ctrl params based on received opts */ + +/* Find device that can reach the dest addr */ + dev =nvme_tcp_ofld_lookup_dev (ctrl); +if (!dev) { +pr_info ("no device found for addr %s:%s.\n" , + opts->traddr, opts->trsvcid); + rc = -EINVAL ; + goto out_free_ctrl; + } + + ctrl->dev = dev; + +if (ctrl->dev->ops->max_hw_sectors) + nctrl->max_hw_sectors = ctrl->dev->ops->max_hw_sectors; +if (ctrl->dev->ops->max_segments) + nctrl->max_segments = ctrl->dev->ops->max_segments; + +/* Init queues */ + +/* Call nvme_init_ctrl */ + + rc = ctrl->dev->ops->setup_ctrl (ctrl, true); +if (rc) + goto out_module_put; + + rc =nvme_tcp_ofld_setup_ctrl (nctrl, true); +if (rc) + goto out_uninit_ctrl; + +return nctrl; + +out_uninit_ctrl: + ctrl->dev->ops->release_ctrl (ctrl); +out_module_put: +module_put (dev->ops->module); +out_free_ctrl: +kfree (ctrl); + +return ERR_PTR (rc); +} +static struct nvmf_transport_ops nvme_tcp_ofld_transport = { .name ="tcp_offload" , .module =THIS_MODULE ,@@ -107,6 +200,7 @@ static struct nvmf_transport_ops nvme_tcp_ofld_transport = {NVMF_OPT_RECONNECT_DELAY |NVMF_OPT_HDR_DIGEST |NVMF_OPT_DATA_DIGEST |NVMF_OPT_NR_POLL_QUEUES | NVMF_OPT_TOS, + .create_ctrl = nvme_tcp_ofld_create_ctrl, };
Quoted 7 lines
drivers/nvme/host/tcp-offload.c static struct nvmf_transport_ops nvme_tcp_ofld_transport = { · line 206
Quoted 2 lines
drivers/nvme/host/tcp-offload.c +0
-0static int __init nvme_tcp_ofld_init_module (void )I wonder if we shouldn't take the approach from Martin Belanger, and introduce a new option '
host_iface' to select the interface to use. That is, _if_ the nvme-tcp offload driver would present itself as a network interface; one might argue that it would put too much restriction on the implementations.
We should add the new option 'host_iface' also to nvme-tcp-offload and each vendor-specific driver shall register with this to nvme_tcp_ofld_ops.
Quoted 3 lines
But if it does not present itself as a network interface, how do we address it? And if it does, wouldn't we be better off to specify the interface directly, and not try to imply the interface from the IP address?
Specifically for the Marvell qedn driver, we are pairing between the net-device (qede) and the offload-device (qedn) on each port.
The usage for the user is:
Assign IP to the net-device (from any existing linux tool):
ip addr add 100.100.0.101/24 dev p1p1
This IP will be used by both net-device (qede) and offload-device (qedn). In order to connect from "sw" nvme-tcp through the net-device (qede):
nvme connect -t tcp -s 4420 -a 100.100.0.100 -n testnqn
In order to connect from "offload" nvme-tcp through the offload-device (qedn):
nvme connect -t tcp_offload -s 4420 -a 100.100.0.100 -n testnqn
A suggestion (by Hannes Reinecke), as a future enhancement, and in order to simplify the usage, we suggest modifying nvme-cli with a new flag that will determine if "-t tcp" should be the regular nvme-tcp (which will be the default) or nvme-tcp-offload.
For exmaple:
nvme connect -t tcp -s 4420 -a 100.100.0.100 -n testnqn -[new flag]
Quoted 9 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
_______________________________________________
Linux-nvme mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-nvme
RFC PATCH v4 11/27 nvme-tcp-offload: Add controller level implementation
In reply to Shai MalinFrom: Arie Gershberg <[email protected]>
In this patch we implement controller level functionality including:
- create_ctrl.
- delete_ctrl.
- free_ctrl.
The implementation is similar to other nvme fabrics modules, the main difference being that the nvme-tcp-offload ULP calls the vendor specific claim_dev() op with the given TCP/IP parameters to determine which device will be used for this controller.
Once found, the vendor specific device and controller will be paired and kept in a controller list managed by the ULP.
--- drivers/nvme/host/tcp-offload.c | 467 +++++++++++++++++++++++++++++++- 1 file changed, 459 insertions(+), 8 deletions(-)
drivers/nvme/host/tcp-offload.c +459 -8
@@ -12,6 +12,10 @@static LIST_HEAD (nvme_tcp_ofld_devices);static DECLARE_RWSEM (nvme_tcp_ofld_devices_rwsem); +static LIST_HEAD (nvme_tcp_ofld_ctrl_list); +static DECLARE_RWSEM (nvme_tcp_ofld_ctrl_rwsem); +static struct blk_mq_ops nvme_tcp_ofld_admin_mq_ops; +static struct blk_mq_ops nvme_tcp_ofld_mq_ops;static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl (struct nvme_ctrl *nctrl) {
@@ -128,28 +132,430 @@ nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)return dev; } +static struct blk_mq_tag_set * +nvme_tcp_ofld_alloc_tagset (struct nvme_ctrl *nctrl,bool admin) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct blk_mq_tag_set *set; +int rc; + +if (admin) { + set = &ctrl->admin_tag_set; +memset (set,0 ,sizeof (*set)); + set->ops = &nvme_tcp_ofld_admin_mq_ops; + set->queue_depth =NVME_AQ_MQ_TAG_DEPTH ; + set->reserved_tags =NVMF_RESERVED_TAGS ; + set->numa_node = nctrl->numa_node; + set->flags =BLK_MQ_F_BLOCKING ; + set->cmd_size =sizeof (struct nvme_tcp_ofld_req ); + set->driver_data = ctrl; + set->nr_hw_queues =1 ; + set->timeout =NVME_ADMIN_TIMEOUT ; + }else { + set = &ctrl->tag_set; +memset (set,0 ,sizeof (*set)); + set->ops = &nvme_tcp_ofld_mq_ops; + set->queue_depth = nctrl->sqsize +1 ; + set->reserved_tags =NVMF_RESERVED_TAGS ; + set->numa_node = nctrl->numa_node; + set->flags =BLK_MQ_F_SHOULD_MERGE |BLK_MQ_F_BLOCKING ; + set->cmd_size =sizeof (struct nvme_tcp_ofld_req ); + set->driver_data = ctrl; + set->nr_hw_queues = nctrl->queue_count -1 ; + set->timeout =NVME_IO_TIMEOUT ; + set->nr_maps = nctrl->opts->nr_poll_queues ?HCTX_MAX_TYPES :2 ; + } + + rc =blk_mq_alloc_tag_set (set); +if (rc) +return ERR_PTR (rc); + +return set; +} + +static int nvme_tcp_ofld_configure_admin_queue (struct nvme_ctrl *nctrl, +bool new) +{ +int rc; + +/* Placeholder - alloc_admin_queue */ +if (new) { + nctrl->admin_tagset = +nvme_tcp_ofld_alloc_tagset (nctrl, true); +if (IS_ERR (nctrl->admin_tagset)) { + rc =PTR_ERR (nctrl->admin_tagset); + nctrl->admin_tagset =NULL ; + goto out_free_queue; + } + + nctrl->fabrics_q =blk_mq_init_queue (nctrl->admin_tagset); +if (IS_ERR (nctrl->fabrics_q)) { + rc =PTR_ERR (nctrl->fabrics_q); + nctrl->fabrics_q =NULL ; + goto out_free_tagset; + } + + nctrl->admin_q =blk_mq_init_queue (nctrl->admin_tagset); +if (IS_ERR (nctrl->admin_q)) { + rc =PTR_ERR (nctrl->admin_q); + nctrl->admin_q =NULL ; + goto out_cleanup_fabrics_q; + } + } + +/* Placeholder - nvme_tcp_ofld_start_queue */ + + rc =nvme_enable_ctrl (nctrl); +if (rc) + goto out_stop_queue; + +blk_mq_unquiesce_queue (nctrl->admin_q); + + rc =nvme_init_identify (nctrl); +if (rc) + goto out_quiesce_queue; + +return 0 ; + +out_quiesce_queue: +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); + +out_stop_queue: +/* Placeholder - stop offload queue */ +nvme_cancel_admin_tagset (nctrl); + +out_cleanup_fabrics_q: +if (new) +blk_cleanup_queue (nctrl->fabrics_q); +out_free_tagset: +if (new) +blk_mq_free_tag_set (nctrl->admin_tagset); +out_free_queue: +/* Placeholder - free admin queue */ + +return rc; +} + +static int +nvme_tcp_ofld_configure_io_queues (struct nvme_ctrl *nctrl,bool new) +{ +int rc; + +/* Placeholder - alloc_io_queues */ + +if (new) { + nctrl->tagset =nvme_tcp_ofld_alloc_tagset (nctrl, false); +if (IS_ERR (nctrl->tagset)) { + rc =PTR_ERR (nctrl->tagset); + nctrl->tagset =NULL ; + goto out_free_io_queues; + } + + nctrl->connect_q =blk_mq_init_queue (nctrl->tagset); +if (IS_ERR (nctrl->connect_q)) { + rc =PTR_ERR (nctrl->connect_q); + nctrl->connect_q =NULL ; + goto out_free_tag_set; + } + } + +/* Placeholder - start_io_queues */ + +if (!new) { +nvme_start_queues (nctrl); +if (!nvme_wait_freeze_timeout (nctrl,NVME_IO_TIMEOUT )) { +/* +* If we timed out waiting for freeze we are likely to +* be stuck. Fail the controller initialization just +* to be safe. +*/ + rc = -ENODEV ; + goto out_wait_freeze_timed_out; + } +blk_mq_update_nr_hw_queues (nctrl->tagset, nctrl->queue_count -1 ); +nvme_unfreeze (nctrl); + } + +return 0 ; + +out_wait_freeze_timed_out: +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); + +/* Placeholder - Stop IO queues */ + +if (new) +blk_cleanup_queue (nctrl->connect_q); +out_free_tag_set: +if (new) +blk_mq_free_tag_set (nctrl->tagset); +out_free_io_queues: +/* Placeholder - free_io_queues */ + +return rc; +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) { -/* Placeholder - validates inputs and creates admin and IO queues */ +struct nvmf_ctrl_options *opts = nctrl->opts; +int rc; + + rc =nvme_tcp_ofld_configure_admin_queue (nctrl, new); +if (rc) +return rc; + +if (nctrl->icdoff) { +dev_err (nctrl->device,"icdoff is not supported!\n" ); + rc = -EINVAL ; + goto destroy_admin; + } + +if (opts->queue_size > nctrl->sqsize +1 ) +dev_warn (nctrl->device, +"queue_size %zu > ctrl sqsize %u, clamping down\n" , + opts->queue_size, nctrl->sqsize +1 ); + +if (nctrl->sqsize +1 > nctrl->maxcmd) { +dev_warn (nctrl->device, +"sqsize %u > ctrl maxcmd %u, clamping down\n" , + nctrl->sqsize +1 , nctrl->maxcmd); + nctrl->sqsize = nctrl->maxcmd -1 ; + } + +if (nctrl->queue_count >1 ) { + rc =nvme_tcp_ofld_configure_io_queues (nctrl, new); +if (rc) + goto destroy_admin; + } + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_LIVE )) { +/* +* state change failure is ok if we started ctrl delete, +* unless we're during creation of a new controller to +* avoid races with teardown flow. +*/ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); +WARN_ON_ONCE (new); + rc = -EINVAL ; + goto destroy_io; + } + +nvme_start_ctrl (nctrl); + +return 0 ; + +destroy_io: +/* Placeholder - stop and destroy io queues*/ +destroy_admin: +/* Placeholder - stop and destroy admin queue*/ + +return rc; +} + +static int +nvme_tcp_ofld_check_dev_opts (struct nvmf_ctrl_options *opts, +struct nvme_tcp_ofld_ops *ofld_ops) +{ +unsigned int nvme_tcp_ofld_opt_mask =NVMF_ALLOWED_OPTS | + ofld_ops->allowed_opts | ofld_ops->required_opts; +if (opts->mask & ~nvme_tcp_ofld_opt_mask) { +pr_warn ("One or more of the nvmf options isn't supported by %s.\n" , + ofld_ops->name); + +return -EINVAL ; + } + +return 0 ; +} + +static void nvme_tcp_ofld_free_ctrl (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_dev *dev = ctrl->dev; + +if (list_empty (&ctrl->list)) + goto free_ctrl; + +down_write (&nvme_tcp_ofld_ctrl_rwsem); + ctrl->dev->ops->release_ctrl (ctrl); +list_del (&ctrl->list); +up_write (&nvme_tcp_ofld_ctrl_rwsem); + +nvmf_free_options (nctrl->opts); +free_ctrl: +module_put (dev->ops->module); +kfree (ctrl->queues); +kfree (ctrl); +} + +static void nvme_tcp_ofld_submit_async_event (struct nvme_ctrl *arg) +{ +/* Placeholder - submit_async_event */ +} + +static void +nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *ctrl,bool remove) +{ +/* Placeholder - teardown_admin_queue */ +} + +static void +nvme_tcp_ofld_teardown_io_queues (struct nvme_ctrl *nctrl,bool remove) +{ +/* Placeholder - teardown_io_queues */ +} + +static void +nvme_tcp_ofld_teardown_ctrl (struct nvme_ctrl *nctrl,bool shutdown) +{ +/* Placeholder - err_work and connect_work */ +nvme_tcp_ofld_teardown_io_queues (nctrl, shutdown); +blk_mq_quiesce_queue (nctrl->admin_q); +if (shutdown) +nvme_shutdown_ctrl (nctrl); +else +nvme_disable_ctrl (nctrl); +nvme_tcp_ofld_teardown_admin_queue (nctrl, shutdown); +} + +static void nvme_tcp_ofld_delete_ctrl (struct nvme_ctrl *nctrl) +{ +nvme_tcp_ofld_teardown_ctrl (nctrl, true); +} + +static int +nvme_tcp_ofld_init_request (struct blk_mq_tag_set *set, +struct request *rq, +unsigned int hctx_idx, +unsigned int numa_node) +{ +struct nvme_tcp_ofld_req *req =blk_mq_rq_to_pdu (rq); +struct nvme_tcp_ofld_ctrl *ctrl = set->driver_data; + +/* Placeholder - init request */ + + req->done = nvme_tcp_ofld_req_done; + ctrl->dev->ops->init_req (req);return 0 ; } +static blk_status_t +nvme_tcp_ofld_queue_rq (struct blk_mq_hw_ctx *hctx, +const struct blk_mq_queue_data *bd) +{ +/* Call nvme_setup_cmd(...) */ + +/* Call ops->send_req(...) */ + +return BLK_STS_OK ; +} + +static struct blk_mq_ops nvme_tcp_ofld_mq_ops = { + .queue_rq = nvme_tcp_ofld_queue_rq, + .init_request = nvme_tcp_ofld_init_request, +/* +* All additional ops will be also implemented and registered similar to +* tcp.c +*/ +}; + +static struct blk_mq_ops nvme_tcp_ofld_admin_mq_ops = { + .queue_rq = nvme_tcp_ofld_queue_rq, + .init_request = nvme_tcp_ofld_init_request, +/* +* All additional ops will be also implemented and registered similar to +* tcp.c +*/ +}; + +static const struct nvme_ctrl_ops nvme_tcp_ofld_ctrl_ops = { + .name ="tcp_offload" , + .module =THIS_MODULE , + .flags =NVME_F_FABRICS , + .reg_read32 = nvmf_reg_read32, + .reg_read64 = nvmf_reg_read64, + .reg_write32 = nvmf_reg_write32, + .free_ctrl = nvme_tcp_ofld_free_ctrl, + .submit_async_event = nvme_tcp_ofld_submit_async_event, + .delete_ctrl = nvme_tcp_ofld_delete_ctrl, + .get_address = nvmf_get_address, +}; + +static bool +nvme_tcp_ofld_existing_controller (struct nvmf_ctrl_options *opts) +{ +struct nvme_tcp_ofld_ctrl *ctrl; +bool found = false; + +down_read (&nvme_tcp_ofld_ctrl_rwsem); +list_for_each_entry (ctrl, &nvme_tcp_ofld_ctrl_list, list) { + found =nvmf_ip_options_match (&ctrl->nctrl, opts); +if (found) +break ; + } +up_read (&nvme_tcp_ofld_ctrl_rwsem); + +return found; +} +static struct nvme_ctrl *nvme_tcp_ofld_create_ctrl (struct device *ndev,struct nvmf_ctrl_options *opts) { +struct nvme_tcp_ofld_queue *queue;struct nvme_tcp_ofld_ctrl *ctrl;struct nvme_tcp_ofld_dev *dev;struct nvme_ctrl *nctrl; -int rc =0 ; +int i, rc =0 ; ctrl =kzalloc (sizeof (*ctrl),GFP_KERNEL );if (!ctrl)return ERR_PTR (-ENOMEM ); +INIT_LIST_HEAD (&ctrl->list); nctrl = &ctrl->nctrl; + nctrl->opts = opts; + nctrl->queue_count = opts->nr_io_queues + opts->nr_write_queues + + opts->nr_poll_queues +1 ; + nctrl->sqsize = opts->queue_size -1 ; + nctrl->kato = opts->kato; +if (!(opts->mask &NVMF_OPT_TRSVCID )) { + opts->trsvcid = +kstrdup (__stringify (NVME_TCP_DISC_PORT ),GFP_KERNEL ); +if (!opts->trsvcid) { + rc = -ENOMEM ; + goto out_free_ctrl; + } + opts->mask |=NVMF_OPT_TRSVCID ; + } -/* Init nvme_tcp_ofld_ctrl and nvme_ctrl params based on received opts */ + rc =inet_pton_with_scope (&init_net,AF_UNSPEC , opts->traddr, + opts->trsvcid, + &ctrl->conn_params.remote_ip_addr); +if (rc) { +pr_err ("malformed address passed: %s:%s\n" , + opts->traddr, opts->trsvcid); + goto out_free_ctrl; + } + +if (opts->mask &NVMF_OPT_HOST_TRADDR ) { + rc =inet_pton_with_scope (&init_net,AF_UNSPEC , + opts->host_traddr,NULL , + &ctrl->conn_params.local_ip_addr); +if (rc) { +pr_err ("malformed src address passed: %s\n" , + opts->host_traddr); + goto out_free_ctrl; + } + } + +if (!opts->duplicate_connect && +nvme_tcp_ofld_existing_controller (opts)) { + rc = -EALREADY ; + goto out_free_ctrl; + }/* Find device that can reach the dest addr */ dev =nvme_tcp_ofld_lookup_dev (ctrl);
@@ -160,6 +566,10 @@ nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts) goto out_free_ctrl; } + rc =nvme_tcp_ofld_check_dev_opts (opts, dev->ops); +if (rc) + goto out_module_put; + ctrl->dev = dev;if (ctrl->dev->ops->max_hw_sectors)
@@ -167,22 +577,55 @@ nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts)if (ctrl->dev->ops->max_segments) nctrl->max_segments = ctrl->dev->ops->max_segments; -/* Init queues */ + ctrl->queues =kcalloc (nctrl->queue_count, +sizeof (struct nvme_tcp_ofld_queue ), +GFP_KERNEL ); +if (!ctrl->queues) { + rc = -ENOMEM ; + goto out_module_put; + } -/* Call nvme_init_ctrl */ +for (i =0 ; i < nctrl->queue_count; ++i) { + queue = &ctrl->queues[i]; + queue->ctrl = ctrl; + queue->dev = dev; + queue->report_err = nvme_tcp_ofld_report_queue_err; + } + + rc =nvme_init_ctrl (nctrl, ndev, &nvme_tcp_ofld_ctrl_ops,0 ); +if (rc) + goto out_free_queues; + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +WARN_ON_ONCE (1 ); + rc = -EINTR ; + goto out_uninit_ctrl; + } rc = ctrl->dev->ops->setup_ctrl (ctrl, true);if (rc) - goto out_module_put; + goto out_uninit_ctrl; rc =nvme_tcp_ofld_setup_ctrl (nctrl, true);if (rc) - goto out_uninit_ctrl; + goto out_release_ctrl; + +dev_info (nctrl->device,"new ctrl: NQN \"%s\", addr %pISp\n" , + opts->subsysnqn, &ctrl->conn_params.remote_ip_addr); + +down_write (&nvme_tcp_ofld_ctrl_rwsem); +list_add_tail (&ctrl->list, &nvme_tcp_ofld_ctrl_list); +up_write (&nvme_tcp_ofld_ctrl_rwsem);return nctrl; -out_uninit_ctrl: +out_release_ctrl: ctrl->dev->ops->release_ctrl (ctrl); +out_uninit_ctrl: +nvme_uninit_ctrl (nctrl); +nvme_put_ctrl (nctrl); +out_free_queues: +kfree (ctrl->queues); out_module_put:module_put (dev->ops->module); out_free_ctrl:
@@ -212,7 +655,15 @@ static int __init nvme_tcp_ofld_init_module(void) static void __exit nvme_tcp_ofld_cleanup_module(void) { +struct nvme_tcp_ofld_ctrl *ctrl; +nvmf_unregister_transport (&nvme_tcp_ofld_transport); + +down_write (&nvme_tcp_ofld_ctrl_rwsem); +list_for_each_entry (ctrl, &nvme_tcp_ofld_ctrl_list, list) +nvme_delete_ctrl (&ctrl->nctrl); +up_write (&nvme_tcp_ofld_ctrl_rwsem); +flush_workqueue (nvme_delete_wq); }module_init (nvme_tcp_ofld_init_module);
Signature · 7 lines
2.22.0 _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
Re: [RFC PATCH v4 11/27] nvme-tcp-offload: Add controller level implementation
Quoted 273 lines · Shai Malin
From: Arie Gershberg <[email protected]>
In this patch we implement controller level functionality including:
-create_ctrl.
-delete_ctrl.
-free_ctrl.The implementation is similar to other nvme fabrics modules, the main difference being that the nvme-tcp-offload ULP calls the vendor specific
claim_dev()op with the given TCP/IP parameters to determine which device will be used for this controller.
Once found, the vendor specific device and controller will be paired and kept in a controller list managed by the ULP.Acked-by Igor Russkikh <[email protected]>Signed-off-by Arie Gershberg <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/tcp-offload.c | 467 +++++++++++++++++++++++++++++++- 1 file changed, 459 insertions(+), 8 deletions(-)drivers/nvme/host/tcp-offload.c +230
-1@@ -12,6 +12,10 @@static LIST_HEAD (nvme_tcp_ofld_devices);static DECLARE_RWSEM (nvme_tcp_ofld_devices_rwsem); +static LIST_HEAD (nvme_tcp_ofld_ctrl_list); +static DECLARE_RWSEM (nvme_tcp_ofld_ctrl_rwsem); +static struct blk_mq_ops nvme_tcp_ofld_admin_mq_ops; +static struct blk_mq_ops nvme_tcp_ofld_mq_ops;static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl (struct nvme_ctrl *nctrl) {@@ -128,28 +132,430 @@ nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)return dev; } +static struct blk_mq_tag_set * +nvme_tcp_ofld_alloc_tagset (struct nvme_ctrl *nctrl,bool admin) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct blk_mq_tag_set *set; +int rc; + +if (admin) { + set = &ctrl->admin_tag_set; +memset (set,0 ,sizeof (*set)); + set->ops = &nvme_tcp_ofld_admin_mq_ops; + set->queue_depth =NVME_AQ_MQ_TAG_DEPTH ; + set->reserved_tags =NVMF_RESERVED_TAGS ; + set->numa_node = nctrl->numa_node; + set->flags =BLK_MQ_F_BLOCKING ; + set->cmd_size =sizeof (struct nvme_tcp_ofld_req ); + set->driver_data = ctrl; + set->nr_hw_queues =1 ; + set->timeout =NVME_ADMIN_TIMEOUT ; + }else { + set = &ctrl->tag_set; +memset (set,0 ,sizeof (*set)); + set->ops = &nvme_tcp_ofld_mq_ops; + set->queue_depth = nctrl->sqsize +1 ; + set->reserved_tags =NVMF_RESERVED_TAGS ; + set->numa_node = nctrl->numa_node; + set->flags =BLK_MQ_F_SHOULD_MERGE |BLK_MQ_F_BLOCKING ; + set->cmd_size =sizeof (struct nvme_tcp_ofld_req ); + set->driver_data = ctrl; + set->nr_hw_queues = nctrl->queue_count -1 ; + set->timeout =NVME_IO_TIMEOUT ; + set->nr_maps = nctrl->opts->nr_poll_queues ?HCTX_MAX_TYPES :2 ; + } + + rc =blk_mq_alloc_tag_set (set); +if (rc) +return ERR_PTR (rc); + +return set; +} + +static int nvme_tcp_ofld_configure_admin_queue (struct nvme_ctrl *nctrl, +bool new) +{ +int rc; + +/* Placeholder - alloc_admin_queue */ +if (new) { + nctrl->admin_tagset = +nvme_tcp_ofld_alloc_tagset (nctrl, true); +if (IS_ERR (nctrl->admin_tagset)) { + rc =PTR_ERR (nctrl->admin_tagset); + nctrl->admin_tagset =NULL ; + goto out_free_queue; + } + + nctrl->fabrics_q =blk_mq_init_queue (nctrl->admin_tagset); +if (IS_ERR (nctrl->fabrics_q)) { + rc =PTR_ERR (nctrl->fabrics_q); + nctrl->fabrics_q =NULL ; + goto out_free_tagset; + } + + nctrl->admin_q =blk_mq_init_queue (nctrl->admin_tagset); +if (IS_ERR (nctrl->admin_q)) { + rc =PTR_ERR (nctrl->admin_q); + nctrl->admin_q =NULL ; + goto out_cleanup_fabrics_q; + } + } + +/* Placeholder - nvme_tcp_ofld_start_queue */ + + rc =nvme_enable_ctrl (nctrl); +if (rc) + goto out_stop_queue; + +blk_mq_unquiesce_queue (nctrl->admin_q); + + rc =nvme_init_identify (nctrl); +if (rc) + goto out_quiesce_queue; + +return 0 ; + +out_quiesce_queue: +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); + +out_stop_queue: +/* Placeholder - stop offload queue */ +nvme_cancel_admin_tagset (nctrl); + +out_cleanup_fabrics_q: +if (new) +blk_cleanup_queue (nctrl->fabrics_q); +out_free_tagset: +if (new) +blk_mq_free_tag_set (nctrl->admin_tagset); +out_free_queue: +/* Placeholder - free admin queue */ + +return rc; +} + +static int +nvme_tcp_ofld_configure_io_queues (struct nvme_ctrl *nctrl,bool new) +{ +int rc; + +/* Placeholder - alloc_io_queues */ + +if (new) { + nctrl->tagset =nvme_tcp_ofld_alloc_tagset (nctrl, false); +if (IS_ERR (nctrl->tagset)) { + rc =PTR_ERR (nctrl->tagset); + nctrl->tagset =NULL ; + goto out_free_io_queues; + } + + nctrl->connect_q =blk_mq_init_queue (nctrl->tagset); +if (IS_ERR (nctrl->connect_q)) { + rc =PTR_ERR (nctrl->connect_q); + nctrl->connect_q =NULL ; + goto out_free_tag_set; + } + } + +/* Placeholder - start_io_queues */ + +if (!new) { +nvme_start_queues (nctrl); +if (!nvme_wait_freeze_timeout (nctrl,NVME_IO_TIMEOUT )) { +/* +* If we timed out waiting for freeze we are likely to +* be stuck. Fail the controller initialization just +* to be safe. +*/ + rc = -ENODEV ; + goto out_wait_freeze_timed_out; + } +blk_mq_update_nr_hw_queues (nctrl->tagset, nctrl->queue_count -1 ); +nvme_unfreeze (nctrl); + } + +return 0 ; + +out_wait_freeze_timed_out: +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); + +/* Placeholder - Stop IO queues */ + +if (new) +blk_cleanup_queue (nctrl->connect_q); +out_free_tag_set: +if (new) +blk_mq_free_tag_set (nctrl->tagset); +out_free_io_queues: +/* Placeholder - free_io_queues */ + +return rc; +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) { -/* Placeholder - validates inputs and creates admin and IO queues */ +struct nvmf_ctrl_options *opts = nctrl->opts; +int rc; + + rc =nvme_tcp_ofld_configure_admin_queue (nctrl, new); +if (rc) +return rc; + +if (nctrl->icdoff) { +dev_err (nctrl->device,"icdoff is not supported!\n" ); + rc = -EINVAL ; + goto destroy_admin; + } + +if (opts->queue_size > nctrl->sqsize +1 ) +dev_warn (nctrl->device, +"queue_size %zu > ctrl sqsize %u, clamping down\n" , + opts->queue_size, nctrl->sqsize +1 ); + +if (nctrl->sqsize +1 > nctrl->maxcmd) { +dev_warn (nctrl->device, +"sqsize %u > ctrl maxcmd %u, clamping down\n" , + nctrl->sqsize +1 , nctrl->maxcmd); + nctrl->sqsize = nctrl->maxcmd -1 ; + } + +if (nctrl->queue_count >1 ) { + rc =nvme_tcp_ofld_configure_io_queues (nctrl, new); +if (rc) + goto destroy_admin; + } + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_LIVE )) { +/* +* state change failure is ok if we started ctrl delete, +* unless we're during creation of a new controller to +* avoid races with teardown flow. +*/ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); +WARN_ON_ONCE (new); + rc = -EINVAL ; + goto destroy_io; + } + +nvme_start_ctrl (nctrl); + +return 0 ; + +destroy_io: +/* Placeholder - stop and destroy io queues*/ +destroy_admin: +/* Placeholder - stop and destroy admin queue*/ + +return rc; +} + +static int +nvme_tcp_ofld_check_dev_opts (struct nvmf_ctrl_options *opts, +struct nvme_tcp_ofld_ops *ofld_ops) +{ +unsigned int nvme_tcp_ofld_opt_mask =NVMF_ALLOWED_OPTS | + ofld_ops->allowed_opts | ofld_ops->required_opts;
drivers/nvme/host/tcp-offload.c nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl) · line 372
Quoted 10 lines
drivers/nvme/host/tcp-offload.c +10
-0+if (opts->mask & ~nvme_tcp_ofld_opt_mask) { +pr_warn ("One or more of the nvmf options isn't supported by %s.\n" , + ofld_ops->name); + +return -EINVAL ; + } + +return 0 ; +} +
I'd rather specify the options directly; that's how all the other transports do it.
Quoted 181 lines
drivers/nvme/host/tcp-offload.c +162
-2+static void nvme_tcp_ofld_free_ctrl (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_dev *dev = ctrl->dev; + +if (list_empty (&ctrl->list)) + goto free_ctrl; + +down_write (&nvme_tcp_ofld_ctrl_rwsem); + ctrl->dev->ops->release_ctrl (ctrl); +list_del (&ctrl->list); +up_write (&nvme_tcp_ofld_ctrl_rwsem); + +nvmf_free_options (nctrl->opts); +free_ctrl: +module_put (dev->ops->module); +kfree (ctrl->queues); +kfree (ctrl); +} + +static void nvme_tcp_ofld_submit_async_event (struct nvme_ctrl *arg) +{ +/* Placeholder - submit_async_event */ +} + +static void +nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *ctrl,bool remove) +{ +/* Placeholder - teardown_admin_queue */ +} + +static void +nvme_tcp_ofld_teardown_io_queues (struct nvme_ctrl *nctrl,bool remove) +{ +/* Placeholder - teardown_io_queues */ +} + +static void +nvme_tcp_ofld_teardown_ctrl (struct nvme_ctrl *nctrl,bool shutdown) +{ +/* Placeholder - err_work and connect_work */ +nvme_tcp_ofld_teardown_io_queues (nctrl, shutdown); +blk_mq_quiesce_queue (nctrl->admin_q); +if (shutdown) +nvme_shutdown_ctrl (nctrl); +else +nvme_disable_ctrl (nctrl); +nvme_tcp_ofld_teardown_admin_queue (nctrl, shutdown); +} + +static void nvme_tcp_ofld_delete_ctrl (struct nvme_ctrl *nctrl) +{ +nvme_tcp_ofld_teardown_ctrl (nctrl, true); +} + +static int +nvme_tcp_ofld_init_request (struct blk_mq_tag_set *set, +struct request *rq, +unsigned int hctx_idx, +unsigned int numa_node) +{ +struct nvme_tcp_ofld_req *req =blk_mq_rq_to_pdu (rq); +struct nvme_tcp_ofld_ctrl *ctrl = set->driver_data; + +/* Placeholder - init request */ + + req->done = nvme_tcp_ofld_req_done; + ctrl->dev->ops->init_req (req);return 0 ; } +static blk_status_t +nvme_tcp_ofld_queue_rq (struct blk_mq_hw_ctx *hctx, +const struct blk_mq_queue_data *bd) +{ +/* Call nvme_setup_cmd(...) */ + +/* Call ops->send_req(...) */ + +return BLK_STS_OK ; +} + +static struct blk_mq_ops nvme_tcp_ofld_mq_ops = { + .queue_rq = nvme_tcp_ofld_queue_rq, + .init_request = nvme_tcp_ofld_init_request, +/* +* All additional ops will be also implemented and registered similar to +* tcp.c +*/ +}; + +static struct blk_mq_ops nvme_tcp_ofld_admin_mq_ops = { + .queue_rq = nvme_tcp_ofld_queue_rq, + .init_request = nvme_tcp_ofld_init_request, +/* +* All additional ops will be also implemented and registered similar to +* tcp.c +*/ +}; + +static const struct nvme_ctrl_ops nvme_tcp_ofld_ctrl_ops = { + .name ="tcp_offload" , + .module =THIS_MODULE , + .flags =NVME_F_FABRICS , + .reg_read32 = nvmf_reg_read32, + .reg_read64 = nvmf_reg_read64, + .reg_write32 = nvmf_reg_write32, + .free_ctrl = nvme_tcp_ofld_free_ctrl, + .submit_async_event = nvme_tcp_ofld_submit_async_event, + .delete_ctrl = nvme_tcp_ofld_delete_ctrl, + .get_address = nvmf_get_address, +}; + +static bool +nvme_tcp_ofld_existing_controller (struct nvmf_ctrl_options *opts) +{ +struct nvme_tcp_ofld_ctrl *ctrl; +bool found = false; + +down_read (&nvme_tcp_ofld_ctrl_rwsem); +list_for_each_entry (ctrl, &nvme_tcp_ofld_ctrl_list, list) { + found =nvmf_ip_options_match (&ctrl->nctrl, opts); +if (found) +break ; + } +up_read (&nvme_tcp_ofld_ctrl_rwsem); + +return found; +} +static struct nvme_ctrl *nvme_tcp_ofld_create_ctrl (struct device *ndev,struct nvmf_ctrl_options *opts) { +struct nvme_tcp_ofld_queue *queue;struct nvme_tcp_ofld_ctrl *ctrl;struct nvme_tcp_ofld_dev *dev;struct nvme_ctrl *nctrl; -int rc =0 ; +int i, rc =0 ; ctrl =kzalloc (sizeof (*ctrl),GFP_KERNEL );if (!ctrl)return ERR_PTR (-ENOMEM ); +INIT_LIST_HEAD (&ctrl->list); nctrl = &ctrl->nctrl; + nctrl->opts = opts; + nctrl->queue_count = opts->nr_io_queues + opts->nr_write_queues + + opts->nr_poll_queues +1 ; + nctrl->sqsize = opts->queue_size -1 ; + nctrl->kato = opts->kato; +if (!(opts->mask &NVMF_OPT_TRSVCID )) { + opts->trsvcid = +kstrdup (__stringify (NVME_TCP_DISC_PORT ),GFP_KERNEL ); +if (!opts->trsvcid) { + rc = -ENOMEM ; + goto out_free_ctrl; + } + opts->mask |=NVMF_OPT_TRSVCID ; + } -/* Init nvme_tcp_ofld_ctrl and nvme_ctrl params based on received opts */ + rc =inet_pton_with_scope (&init_net,AF_UNSPEC , opts->traddr, + opts->trsvcid, + &ctrl->conn_params.remote_ip_addr); +if (rc) { +pr_err ("malformed address passed: %s:%s\n" , + opts->traddr, opts->trsvcid); + goto out_free_ctrl; + } + +if (opts->mask &NVMF_OPT_HOST_TRADDR ) { + rc =inet_pton_with_scope (&init_net,AF_UNSPEC , + opts->host_traddr,NULL , + &ctrl->conn_params.local_ip_addr); +if (rc) { +pr_err ("malformed src address passed: %s\n" , + opts->host_traddr); + goto out_free_ctrl; + }
drivers/nvme/host/tcp-offload.c nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl) · line 561
Quoted 10 lines
drivers/nvme/host/tcp-offload.c +7
-0+ } + +if (!opts->duplicate_connect && +nvme_tcp_ofld_existing_controller (opts)) { + rc = -EALREADY ; + goto out_free_ctrl; + }/* Find device that can reach the dest addr */ dev =nvme_tcp_ofld_lookup_dev (ctrl);
As mentioned in my previous comment: This is not necessarily unique.
There is no guarantee that a specific host ip/target ip combination will devolve onto a single interface; in fact, given that this is an offload card which might handle only specific protocols I fully expect to have several interfaces through which the target ip address can be reached.
One could implement some sort of prioritisation such that offload engines should be preferred, but in the end it's a policy decision and not something we should impose from the driver side.
I'd rather be able to specify an interface directly, and tie specific
host ip/target ip connections (ie host_traddr/traddr combinations) to that interface. That way we don't impose restrictions on the admin, and remove ambiguity when creating the controller from userspace.
Quoted 22 lines
drivers/nvme/host/tcp-offload.c +10
-1@@ -160,6 +566,10 @@ nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts) goto out_free_ctrl; } + rc =nvme_tcp_ofld_check_dev_opts (opts, dev->ops); +if (rc) + goto out_module_put; + ctrl->dev = dev;if (ctrl->dev->ops->max_hw_sectors)@@ -167,22 +577,55 @@ nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts)if (ctrl->dev->ops->max_segments) nctrl->max_segments = ctrl->dev->ops->max_segments; -/* Init queues */ + ctrl->queues =kcalloc (nctrl->queue_count, +sizeof (struct nvme_tcp_ofld_queue ), +GFP_KERNEL ); +if (!ctrl->queues) { + rc = -ENOMEM ; + goto out_module_put;
drivers/nvme/host/tcp-offload.c nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts) · line 594
Quoted 10 lines
drivers/nvme/host/tcp-offload.c +8
-1+ } -/* Call nvme_init_ctrl */ +for (i =0 ; i < nctrl->queue_count; ++i) { + queue = &ctrl->queues[i]; + queue->ctrl = ctrl; + queue->dev = dev; + queue->report_err = nvme_tcp_ofld_report_queue_err; + } +
What does this 'report_err' callback do?
Maybe it's easier to understand when it's introduced alongside with the code handling it.
Quoted 47 lines
drivers/nvme/host/tcp-offload.c +26
-3+ rc =nvme_init_ctrl (nctrl, ndev, &nvme_tcp_ofld_ctrl_ops,0 ); +if (rc) + goto out_free_queues; + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +WARN_ON_ONCE (1 ); + rc = -EINTR ; + goto out_uninit_ctrl; + } rc = ctrl->dev->ops->setup_ctrl (ctrl, true);if (rc) - goto out_module_put; + goto out_uninit_ctrl; rc =nvme_tcp_ofld_setup_ctrl (nctrl, true);if (rc) - goto out_uninit_ctrl; + goto out_release_ctrl; + +dev_info (nctrl->device,"new ctrl: NQN \"%s\", addr %pISp\n" , + opts->subsysnqn, &ctrl->conn_params.remote_ip_addr); + +down_write (&nvme_tcp_ofld_ctrl_rwsem); +list_add_tail (&ctrl->list, &nvme_tcp_ofld_ctrl_list); +up_write (&nvme_tcp_ofld_ctrl_rwsem);return nctrl; -out_uninit_ctrl: +out_release_ctrl: ctrl->dev->ops->release_ctrl (ctrl); +out_uninit_ctrl: +nvme_uninit_ctrl (nctrl); +nvme_put_ctrl (nctrl); +out_free_queues: +kfree (ctrl->queues); out_module_put:module_put (dev->ops->module); out_free_ctrl:@@ -212,7 +655,15 @@ static int __init nvme_tcp_ofld_init_module(void) static void __exit nvme_tcp_ofld_cleanup_module(void) { +struct nvme_tcp_ofld_ctrl *ctrl; +
drivers/nvme/host/tcp-offload.c static int __init nvme_tcp_ofld_init_module(void) · line 669
Quoted 10 lines
drivers/nvme/host/tcp-offload.c +6
-0nvmf_unregister_transport (&nvme_tcp_ofld_transport); + +down_write (&nvme_tcp_ofld_ctrl_rwsem); +list_for_each_entry (ctrl, &nvme_tcp_ofld_ctrl_list, list) +nvme_delete_ctrl (&ctrl->nctrl); +up_write (&nvme_tcp_ofld_ctrl_rwsem); +flush_workqueue (nvme_delete_wq); }module_init (nvme_tcp_ofld_init_module);
Cheers,
Hannes
Signature · 9 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer _______________________________________________ Linux-nvme mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-nvme
RFC PATCH v4 12/27 nvme-tcp-offload: Add controller level error recovery implementation
In reply to Shai MalinFrom: Arie Gershberg <[email protected]>
In this patch, we implement controller level error handling and recovery. Upon an error discovered by the ULP or reset controller initiated by the nvme-core (using reset_ctrl workqueue), the ULP will initiate a controller recovery which includes teardown and re-connect of all queues.
--- drivers/nvme/host/tcp-offload.c | 138 +++++++++++++++++++++++++++++++- drivers/nvme/host/tcp-offload.h | 1 + 2 files changed, 137 insertions(+), 2 deletions(-)
drivers/nvme/host/tcp-offload.c +136 -2
@@ -74,6 +74,23 @@ void nvme_tcp_ofld_unregister_dev(struct nvme_tcp_ofld_dev *dev) }EXPORT_SYMBOL_GPL (nvme_tcp_ofld_unregister_dev); +/** +* nvme_tcp_ofld_error_recovery() - NVMeTCP Offload Library error recovery. +* function. +* @nctrl: NVMe controller instance to change to resetting. +* +* API function that change the controller state to resseting. +* Part of the overall controller reset sequence. +*/ +void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl) +{ +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_RESETTING )) +return ; + +queue_work (nvme_reset_wq, &to_tcp_ofld_ctrl (nctrl)->err_work); +} +EXPORT_SYMBOL_GPL (nvme_tcp_ofld_error_recovery); +/** * nvme_tcp_ofld_report_queue_err() - NVMeTCP Offload report error event * callback function. Pointed to by nvme_tcp_ofld_queue->report_err.
@@ -84,7 +101,8 @@ EXPORT_SYMBOL_GPL(nvme_tcp_ofld_unregister_dev);*/ int nvme_tcp_ofld_report_queue_err (struct nvme_tcp_ofld_queue *queue) { -/* Placeholder - invoke error recovery flow */ +pr_err ("nvme-tcp-offload queue error\n" ); +nvme_tcp_ofld_error_recovery (&queue->ctrl->nctrl);return 0 ; }
@@ -296,6 +314,28 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new)return rc; } +static void nvme_tcp_ofld_reconnect_or_remove (struct nvme_ctrl *nctrl) +{ +/* If we are resetting/deleting then do nothing */ +if (nctrl->state !=NVME_CTRL_CONNECTING ) { +WARN_ON_ONCE (nctrl->state ==NVME_CTRL_NEW || + nctrl->state ==NVME_CTRL_LIVE ); + +return ; + } + +if (nvmf_should_reconnect (nctrl)) { +dev_info (nctrl->device,"Reconnecting in %d seconds...\n" , + nctrl->opts->reconnect_delay); +queue_delayed_work (nvme_wq, + &to_tcp_ofld_ctrl (nctrl)->connect_work, + nctrl->opts->reconnect_delay *HZ ); + }else { +dev_info (nctrl->device,"Removing controller...\n" ); +nvme_delete_ctrl (nctrl); + } +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) {struct nvmf_ctrl_options *opts = nctrl->opts;
@@ -407,10 +447,68 @@ nvme_tcp_ofld_teardown_io_queues(struct nvme_ctrl *nctrl, bool remove)/* Placeholder - teardown_io_queues */ } +static void nvme_tcp_ofld_reconnect_ctrl_work (struct work_struct *work) +{ +struct nvme_tcp_ofld_ctrl *ctrl = +container_of (to_delayed_work (work), + struct nvme_tcp_ofld_ctrl, + connect_work); +struct nvme_ctrl *nctrl = &ctrl->nctrl; + + ++nctrl->nr_reconnects; + +if (ctrl->dev->ops->setup_ctrl (ctrl, false)) + goto requeue; + +if (nvme_tcp_ofld_setup_ctrl (nctrl, false)) + goto release_and_requeue; + +dev_info (nctrl->device,"Successfully reconnected (%d attempt)\n" , + nctrl->nr_reconnects); + + nctrl->nr_reconnects =0 ; + +return ; + +release_and_requeue: + ctrl->dev->ops->release_ctrl (ctrl); +requeue: +dev_info (nctrl->device,"Failed reconnect attempt %d\n" , + nctrl->nr_reconnects); +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} + +static void nvme_tcp_ofld_error_recovery_work (struct work_struct *work) +{ +struct nvme_tcp_ofld_ctrl *ctrl = + container_of(work, struct nvme_tcp_ofld_ctrl, err_work); +struct nvme_ctrl *nctrl = &ctrl->nctrl; + +nvme_stop_keep_alive (nctrl); +nvme_tcp_ofld_teardown_io_queues (nctrl, false); +/* unquiesce to fail fast pending requests */ +nvme_start_queues (nctrl); +nvme_tcp_ofld_teardown_admin_queue (nctrl, false); +blk_mq_unquiesce_queue (nctrl->admin_q); + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +/* state change failure is ok if we started nctrl delete */ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); + +return ; + } + +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} +static void nvme_tcp_ofld_teardown_ctrl (struct nvme_ctrl *nctrl,bool shutdown) { -/* Placeholder - err_work and connect_work */ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); + +cancel_work_sync (&ctrl->err_work); +cancel_delayed_work_sync (&ctrl->connect_work);nvme_tcp_ofld_teardown_io_queues (nctrl, shutdown);blk_mq_quiesce_queue (nctrl->admin_q);if (shutdown)
@@ -425,6 +523,38 @@ static void nvme_tcp_ofld_delete_ctrl(struct nvme_ctrl *nctrl)nvme_tcp_ofld_teardown_ctrl (nctrl, true); } +static void nvme_tcp_ofld_reset_ctrl_work (struct work_struct *work) +{ +struct nvme_ctrl *nctrl = + container_of(work, struct nvme_ctrl, reset_work); +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); + +nvme_stop_ctrl (nctrl); +nvme_tcp_ofld_teardown_ctrl (nctrl, false); + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +/* state change failure is ok if we started ctrl delete */ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); + +return ; + } + +if (ctrl->dev->ops->setup_ctrl (ctrl, false)) + goto out_fail; + +if (nvme_tcp_ofld_setup_ctrl (nctrl, false)) + goto release_ctrl; + +return ; + +release_ctrl: + ctrl->dev->ops->release_ctrl (ctrl); +out_fail: + ++nctrl->nr_reconnects; +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} + static int nvme_tcp_ofld_init_request(struct blk_mq_tag_set *set, struct request *rq,
@@ -521,6 +651,10 @@ nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts) opts->nr_poll_queues +1 ; nctrl->sqsize = opts->queue_size -1 ; nctrl->kato = opts->kato; +INIT_DELAYED_WORK (&ctrl->connect_work, + nvme_tcp_ofld_reconnect_ctrl_work); +INIT_WORK (&ctrl->err_work, nvme_tcp_ofld_error_recovery_work); +INIT_WORK (&nctrl->reset_work, nvme_tcp_ofld_reset_ctrl_work);if (!(opts->mask &NVMF_OPT_TRSVCID )) { opts->trsvcid =kstrdup (__stringify (NVME_TCP_DISC_PORT ),GFP_KERNEL );
drivers/nvme/host/tcp-offload.h +1 -0
@@ -204,3 +204,4 @@ struct nvme_tcp_ofld_ops {/* Exported functions for lower vendor specific offload drivers */ int nvme_tcp_ofld_register_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_unregister_dev (struct nvme_tcp_ofld_dev *dev); +void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl);
Signature · 1 line
2.22.0
Re: [RFC PATCH v4 12/27] nvme-tcp-offload: Add controller level error recovery implementation
Quoted 212 lines · Shai Malin
From: Arie Gershberg <[email protected]>
In this patch, we implement controller level error handling and recovery. Upon an error discovered by the ULP or reset controller initiated by the nvme-core (using
reset_ctrlworkqueue), the ULP will initiate a controller recovery which includes teardown and re-connect of all queues.Acked-by Igor Russkikh <[email protected]>Signed-off-by Arie Gershberg <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/tcp-offload.c | 138 +++++++++++++++++++++++++++++++- drivers/nvme/host/tcp-offload.h | 1 + 2 files changed, 137 insertions(+), 2 deletions(-)drivers/nvme/host/tcp-offload.c +136
-2@@ -74,6 +74,23 @@ void nvme_tcp_ofld_unregister_dev(struct nvme_tcp_ofld_dev *dev) }EXPORT_SYMBOL_GPL (nvme_tcp_ofld_unregister_dev); +/** +* nvme_tcp_ofld_error_recovery() - NVMeTCP Offload Library error recovery. +* function. +* @nctrl: NVMe controller instance to change to resetting. +* +* API function that change the controller state to resseting. +* Part of the overall controller reset sequence. +*/ +void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl) +{ +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_RESETTING )) +return ; + +queue_work (nvme_reset_wq, &to_tcp_ofld_ctrl (nctrl)->err_work); +} +EXPORT_SYMBOL_GPL (nvme_tcp_ofld_error_recovery); +/** * nvme_tcp_ofld_report_queue_err() - NVMeTCP Offload report error event * callback function. Pointed to by nvme_tcp_ofld_queue->report_err. @@ -84,7 +101,8 @@ EXPORT_SYMBOL_GPL(nvme_tcp_ofld_unregister_dev);*/ int nvme_tcp_ofld_report_queue_err (struct nvme_tcp_ofld_queue *queue) { -/* Placeholder - invoke error recovery flow */ +pr_err ("nvme-tcp-offload queue error\n" ); +nvme_tcp_ofld_error_recovery (&queue->ctrl->nctrl);return 0 ; }@@ -296,6 +314,28 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new)return rc; } +static void nvme_tcp_ofld_reconnect_or_remove (struct nvme_ctrl *nctrl) +{ +/* If we are resetting/deleting then do nothing */ +if (nctrl->state !=NVME_CTRL_CONNECTING ) { +WARN_ON_ONCE (nctrl->state ==NVME_CTRL_NEW || + nctrl->state ==NVME_CTRL_LIVE ); + +return ; + } + +if (nvmf_should_reconnect (nctrl)) { +dev_info (nctrl->device,"Reconnecting in %d seconds...\n" , + nctrl->opts->reconnect_delay); +queue_delayed_work (nvme_wq, + &to_tcp_ofld_ctrl (nctrl)->connect_work, + nctrl->opts->reconnect_delay *HZ ); + }else { +dev_info (nctrl->device,"Removing controller...\n" ); +nvme_delete_ctrl (nctrl); + } +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) {struct nvmf_ctrl_options *opts = nctrl->opts;@@ -407,10 +447,68 @@ nvme_tcp_ofld_teardown_io_queues(struct nvme_ctrl *nctrl, bool remove)/* Placeholder - teardown_io_queues */ } +static void nvme_tcp_ofld_reconnect_ctrl_work (struct work_struct *work) +{ +struct nvme_tcp_ofld_ctrl *ctrl = +container_of (to_delayed_work (work), + struct nvme_tcp_ofld_ctrl, + connect_work); +struct nvme_ctrl *nctrl = &ctrl->nctrl; + + ++nctrl->nr_reconnects; + +if (ctrl->dev->ops->setup_ctrl (ctrl, false)) + goto requeue; + +if (nvme_tcp_ofld_setup_ctrl (nctrl, false)) + goto release_and_requeue; + +dev_info (nctrl->device,"Successfully reconnected (%d attempt)\n" , + nctrl->nr_reconnects); + + nctrl->nr_reconnects =0 ; + +return ; + +release_and_requeue: + ctrl->dev->ops->release_ctrl (ctrl); +requeue: +dev_info (nctrl->device,"Failed reconnect attempt %d\n" , + nctrl->nr_reconnects); +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} + +static void nvme_tcp_ofld_error_recovery_work (struct work_struct *work) +{ +struct nvme_tcp_ofld_ctrl *ctrl = + container_of(work, struct nvme_tcp_ofld_ctrl, err_work); +struct nvme_ctrl *nctrl = &ctrl->nctrl; + +nvme_stop_keep_alive (nctrl); +nvme_tcp_ofld_teardown_io_queues (nctrl, false); +/* unquiesce to fail fast pending requests */ +nvme_start_queues (nctrl); +nvme_tcp_ofld_teardown_admin_queue (nctrl, false); +blk_mq_unquiesce_queue (nctrl->admin_q); + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +/* state change failure is ok if we started nctrl delete */ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); + +return ; + } + +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} +static void nvme_tcp_ofld_teardown_ctrl (struct nvme_ctrl *nctrl,bool shutdown) { -/* Placeholder - err_work and connect_work */ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); + +cancel_work_sync (&ctrl->err_work); +cancel_delayed_work_sync (&ctrl->connect_work);nvme_tcp_ofld_teardown_io_queues (nctrl, shutdown);blk_mq_quiesce_queue (nctrl->admin_q);if (shutdown)@@ -425,6 +523,38 @@ static void nvme_tcp_ofld_delete_ctrl(struct nvme_ctrl *nctrl)nvme_tcp_ofld_teardown_ctrl (nctrl, true); } +static void nvme_tcp_ofld_reset_ctrl_work (struct work_struct *work) +{ +struct nvme_ctrl *nctrl = + container_of(work, struct nvme_ctrl, reset_work); +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); + +nvme_stop_ctrl (nctrl); +nvme_tcp_ofld_teardown_ctrl (nctrl, false); + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +/* state change failure is ok if we started ctrl delete */ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); + +return ; + } + +if (ctrl->dev->ops->setup_ctrl (ctrl, false)) + goto out_fail; + +if (nvme_tcp_ofld_setup_ctrl (nctrl, false)) + goto release_ctrl; + +return ; + +release_ctrl: + ctrl->dev->ops->release_ctrl (ctrl); +out_fail: + ++nctrl->nr_reconnects; +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} + static int nvme_tcp_ofld_init_request(struct blk_mq_tag_set *set, struct request *rq,@@ -521,6 +651,10 @@ nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts) opts->nr_poll_queues +1 ; nctrl->sqsize = opts->queue_size -1 ; nctrl->kato = opts->kato; +INIT_DELAYED_WORK (&ctrl->connect_work, + nvme_tcp_ofld_reconnect_ctrl_work); +INIT_WORK (&ctrl->err_work, nvme_tcp_ofld_error_recovery_work); +INIT_WORK (&nctrl->reset_work, nvme_tcp_ofld_reset_ctrl_work);if (!(opts->mask &NVMF_OPT_TRSVCID )) { opts->trsvcid =kstrdup (__stringify (NVME_TCP_DISC_PORT ),GFP_KERNEL );drivers/nvme/host/tcp-offload.h +0
-0
drivers/nvme/host/tcp-offload.h struct nvme_tcp_ofld_ops { · line 207
Quoted 4 lines
drivers/nvme/host/tcp-offload.h +1
-0@@ -204,3 +204,4 @@ struct nvme_tcp_ofld_ops {/* Exported functions for lower vendor specific offload drivers */ int nvme_tcp_ofld_register_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_unregister_dev (struct nvme_tcp_ofld_dev *dev); +void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl);
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 12/27] nvme-tcp-offload: Add controller level error recovery implementation
Quoted 210 lines · Hannes Reinecke
Quoted 209 lines · Shai Malin
From: Arie Gershberg <[email protected]>
In this patch, we implement controller level error handling and recovery. Upon an error discovered by the ULP or reset controller initiated by the nvme-core (using
reset_ctrlworkqueue), the ULP will initiate a controller recovery which includes teardown and re-connect of all queues.Acked-by Igor Russkikh <[email protected]>Signed-off-by Arie Gershberg <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/tcp-offload.c | 138 +++++++++++++++++++++++++++++++- drivers/nvme/host/tcp-offload.h | 1 + 2 files changed, 137 insertions(+), 2 deletions(-)drivers/nvme/host/tcp-offload.c +136
-2@@ -74,6 +74,23 @@ void nvme_tcp_ofld_unregister_dev(struct nvme_tcp_ofld_dev *dev) }EXPORT_SYMBOL_GPL (nvme_tcp_ofld_unregister_dev); +/** +* nvme_tcp_ofld_error_recovery() - NVMeTCP Offload Library error recovery. +* function. +* @nctrl: NVMe controller instance to change to resetting. +* +* API function that change the controller state to resseting. +* Part of the overall controller reset sequence. +*/ +void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl) +{ +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_RESETTING )) +return ; + +queue_work (nvme_reset_wq, &to_tcp_ofld_ctrl (nctrl)->err_work); +} +EXPORT_SYMBOL_GPL (nvme_tcp_ofld_error_recovery); +/** * nvme_tcp_ofld_report_queue_err() - NVMeTCP Offload report error event * callback function. Pointed to by nvme_tcp_ofld_queue->report_err. @@ -84,7 +101,8 @@ EXPORT_SYMBOL_GPL(nvme_tcp_ofld_unregister_dev);*/ int nvme_tcp_ofld_report_queue_err (struct nvme_tcp_ofld_queue *queue) { -/* Placeholder - invoke error recovery flow */ +pr_err ("nvme-tcp-offload queue error\n" ); +nvme_tcp_ofld_error_recovery (&queue->ctrl->nctrl);return 0 ; }@@ -296,6 +314,28 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new)return rc; } +static void nvme_tcp_ofld_reconnect_or_remove (struct nvme_ctrl *nctrl) +{ +/* If we are resetting/deleting then do nothing */ +if (nctrl->state !=NVME_CTRL_CONNECTING ) { +WARN_ON_ONCE (nctrl->state ==NVME_CTRL_NEW || + nctrl->state ==NVME_CTRL_LIVE ); + +return ; + } + +if (nvmf_should_reconnect (nctrl)) { +dev_info (nctrl->device,"Reconnecting in %d seconds...\n" , + nctrl->opts->reconnect_delay); +queue_delayed_work (nvme_wq, + &to_tcp_ofld_ctrl (nctrl)->connect_work, + nctrl->opts->reconnect_delay *HZ ); + }else { +dev_info (nctrl->device,"Removing controller...\n" ); +nvme_delete_ctrl (nctrl); + } +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) {struct nvmf_ctrl_options *opts = nctrl->opts;@@ -407,10 +447,68 @@ nvme_tcp_ofld_teardown_io_queues(struct nvme_ctrl *nctrl, bool remove)/* Placeholder - teardown_io_queues */ } +static void nvme_tcp_ofld_reconnect_ctrl_work (struct work_struct *work) +{ +struct nvme_tcp_ofld_ctrl *ctrl = +container_of (to_delayed_work (work), + struct nvme_tcp_ofld_ctrl, + connect_work); +struct nvme_ctrl *nctrl = &ctrl->nctrl; + + ++nctrl->nr_reconnects; + +if (ctrl->dev->ops->setup_ctrl (ctrl, false)) + goto requeue; + +if (nvme_tcp_ofld_setup_ctrl (nctrl, false)) + goto release_and_requeue; + +dev_info (nctrl->device,"Successfully reconnected (%d attempt)\n" , + nctrl->nr_reconnects); + + nctrl->nr_reconnects =0 ; + +return ; + +release_and_requeue: + ctrl->dev->ops->release_ctrl (ctrl); +requeue: +dev_info (nctrl->device,"Failed reconnect attempt %d\n" , + nctrl->nr_reconnects); +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} + +static void nvme_tcp_ofld_error_recovery_work (struct work_struct *work) +{ +struct nvme_tcp_ofld_ctrl *ctrl = + container_of(work, struct nvme_tcp_ofld_ctrl, err_work); +struct nvme_ctrl *nctrl = &ctrl->nctrl; + +nvme_stop_keep_alive (nctrl); +nvme_tcp_ofld_teardown_io_queues (nctrl, false); +/* unquiesce to fail fast pending requests */ +nvme_start_queues (nctrl); +nvme_tcp_ofld_teardown_admin_queue (nctrl, false); +blk_mq_unquiesce_queue (nctrl->admin_q); + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +/* state change failure is ok if we started nctrl delete */ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); + +return ; + } + +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} +static void nvme_tcp_ofld_teardown_ctrl (struct nvme_ctrl *nctrl,bool shutdown) { -/* Placeholder - err_work and connect_work */ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); + +cancel_work_sync (&ctrl->err_work); +cancel_delayed_work_sync (&ctrl->connect_work);nvme_tcp_ofld_teardown_io_queues (nctrl, shutdown);blk_mq_quiesce_queue (nctrl->admin_q);if (shutdown)@@ -425,6 +523,38 @@ static void nvme_tcp_ofld_delete_ctrl(struct nvme_ctrl *nctrl)nvme_tcp_ofld_teardown_ctrl (nctrl, true); } +static void nvme_tcp_ofld_reset_ctrl_work (struct work_struct *work) +{ +struct nvme_ctrl *nctrl = + container_of(work, struct nvme_ctrl, reset_work); +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); + +nvme_stop_ctrl (nctrl); +nvme_tcp_ofld_teardown_ctrl (nctrl, false); + +if (!nvme_change_ctrl_state (nctrl,NVME_CTRL_CONNECTING )) { +/* state change failure is ok if we started ctrl delete */ +WARN_ON_ONCE (nctrl->state !=NVME_CTRL_DELETING && + nctrl->state !=NVME_CTRL_DELETING_NOIO ); + +return ; + } + +if (ctrl->dev->ops->setup_ctrl (ctrl, false)) + goto out_fail; + +if (nvme_tcp_ofld_setup_ctrl (nctrl, false)) + goto release_ctrl; + +return ; + +release_ctrl: + ctrl->dev->ops->release_ctrl (ctrl); +out_fail: + ++nctrl->nr_reconnects; +nvme_tcp_ofld_reconnect_or_remove (nctrl); +} + static int nvme_tcp_ofld_init_request(struct blk_mq_tag_set *set, struct request *rq,@@ -521,6 +651,10 @@ nvme_tcp_ofld_create_ctrl(struct device *ndev, struct nvmf_ctrl_options *opts) opts->nr_poll_queues +1 ; nctrl->sqsize = opts->queue_size -1 ; nctrl->kato = opts->kato; +INIT_DELAYED_WORK (&ctrl->connect_work, + nvme_tcp_ofld_reconnect_ctrl_work); +INIT_WORK (&ctrl->err_work, nvme_tcp_ofld_error_recovery_work); +INIT_WORK (&nctrl->reset_work, nvme_tcp_ofld_reset_ctrl_work);if (!(opts->mask &NVMF_OPT_TRSVCID )) { opts->trsvcid =kstrdup (__stringify (NVME_TCP_DISC_PORT ),GFP_KERNEL );drivers/nvme/host/tcp-offload.h +0
-1--- a/drivers/nvme/host/tcp-offload.h
Quoted 8 lines
drivers/nvme/host/tcp-offload.h struct nvme_tcp_ofld_ops { · line 207
Quoted 7 lines
+++
b/drivers/nvme/host/tcp-offload.hdrivers/nvme/host/tcp-offload.h +1
-0@@ -204,3 +204,4 @@ struct nvme_tcp_ofld_ops {/* Exported functions for lower vendor specific offload drivers */ int nvme_tcp_ofld_register_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_unregister_dev (struct nvme_tcp_ofld_dev *dev); +void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl);Reviewed-by Hannes Reinecke <[email protected]>
Thanks.
Quoted 9 lines
Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 13/27 nvme-tcp-offload: Add queue level implementation
In reply to Shai MalinFrom: Dean Balandin <[email protected]>
In this patch we implement queue level functionality.
The implementation is similar to the nvme-tcp module, the main difference being that we call the vendor specific create_queue op which creates the TCP connection, and NVMeTPC connection including icreq+icresp negotiation.
Once create_queue returns successfully, we can move on to the fabrics connect.
--- drivers/nvme/host/tcp-offload.c | 415 ++++++++++++++++++++++++++++++-- drivers/nvme/host/tcp-offload.h | 2 +- 2 files changed, 390 insertions(+), 27 deletions(-)
drivers/nvme/host/tcp-offload.c +389 -26
@@ -22,6 +22,11 @@ static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl(struct nvme_ctrl *nctr return container_of(nctrl, struct nvme_tcp_ofld_ctrl, nctrl); } +static inline int nvme_tcp_ofld_qid (struct nvme_tcp_ofld_queue *queue) +{ +return queue - queue->ctrl->queues; +} +/** * nvme_tcp_ofld_register_dev() - NVMeTCP Offload Library registration * function.
@@ -191,12 +196,94 @@ nvme_tcp_ofld_alloc_tagset(struct nvme_ctrl *nctrl, bool admin)return set; } +static void __nvme_tcp_ofld_stop_queue (struct nvme_tcp_ofld_queue *queue) +{ + queue->dev->ops->drain_queue (queue); + queue->dev->ops->destroy_queue (queue); +} + +static void nvme_tcp_ofld_stop_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; + +if (!test_and_clear_bit (NVME_TCP_OFLD_Q_LIVE , &queue->flags)) +return ; + +__nvme_tcp_ofld_stop_queue (queue); +} + +static void nvme_tcp_ofld_stop_io_queues (struct nvme_ctrl *ctrl) +{ +int i; + +for (i =1 ; i < ctrl->queue_count; i++) +nvme_tcp_ofld_stop_queue (ctrl, i); +} + +static void nvme_tcp_ofld_free_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; + +if (!test_and_clear_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags)) +return ; + + queue = &ctrl->queues[qid]; + queue->ctrl =NULL ; + queue->dev =NULL ; + queue->report_err =NULL ; +} + +static void nvme_tcp_ofld_destroy_admin_queue (struct nvme_ctrl *nctrl,bool remove) +{ +nvme_tcp_ofld_stop_queue (nctrl,0 ); +if (remove) { +blk_cleanup_queue (nctrl->admin_q); +blk_cleanup_queue (nctrl->fabrics_q); +blk_mq_free_tag_set (nctrl->admin_tagset); + } +} + +static int nvme_tcp_ofld_start_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; +int rc; + + queue = &ctrl->queues[qid]; +if (qid) { + queue->cmnd_capsule_len = nctrl->ioccsz *16 ; + rc =nvmf_connect_io_queue (nctrl, qid, false); + }else { + queue->cmnd_capsule_len =sizeof (struct nvme_command ) +NVME_TCP_ADMIN_CCSZ ; + rc =nvmf_connect_admin_queue (nctrl); + } + +if (!rc) { +set_bit (NVME_TCP_OFLD_Q_LIVE , &queue->flags); + }else { +if (test_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags)) +__nvme_tcp_ofld_stop_queue (queue); +dev_err (nctrl->device, +"failed to connect queue: %d ret=%d\n" , qid, rc); + } + +return rc; +} +static int nvme_tcp_ofld_configure_admin_queue (struct nvme_ctrl *nctrl,bool new) { +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[0 ];int rc; -/* Placeholder - alloc_admin_queue */ + rc = ctrl->dev->ops->create_queue (queue,0 ,NVME_AQ_DEPTH ); +if (rc) +return rc; + +set_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags);if (new) { nctrl->admin_tagset =nvme_tcp_ofld_alloc_tagset (nctrl, true);
@@ -221,7 +308,9 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, } } -/* Placeholder - nvme_tcp_ofld_start_queue */ + rc =nvme_tcp_ofld_start_queue (nctrl,0 ); +if (rc) + goto out_cleanup_queue; rc =nvme_enable_ctrl (nctrl);if (rc)
@@ -238,11 +327,12 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, out_quiesce_queue:blk_mq_quiesce_queue (nctrl->admin_q);blk_sync_queue (nctrl->admin_q); - out_stop_queue: -/* Placeholder - stop offload queue */ +nvme_tcp_ofld_stop_queue (nctrl,0 );nvme_cancel_admin_tagset (nctrl); - +out_cleanup_queue: +if (new) +blk_cleanup_queue (nctrl->admin_q); out_cleanup_fabrics_q:if (new)blk_cleanup_queue (nctrl->fabrics_q);
@@ -250,7 +340,127 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl,if (new)blk_mq_free_tag_set (nctrl->admin_tagset); out_free_queue: -/* Placeholder - free admin queue */ +nvme_tcp_ofld_free_queue (nctrl,0 ); + +return rc; +} + +static unsigned int nvme_tcp_ofld_nr_io_queues (struct nvme_ctrl *nctrl) +{ +unsigned int nr_io_queues; + + nr_io_queues =min (nctrl->opts->nr_io_queues,num_online_cpus ()); + nr_io_queues +=min (nctrl->opts->nr_write_queues,num_online_cpus ()); + nr_io_queues +=min (nctrl->opts->nr_poll_queues,num_online_cpus ()); + +return nr_io_queues; +} + +static void +nvme_tcp_ofld_set_io_queues (struct nvme_ctrl *nctrl,unsigned int nr_io_queues) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvmf_ctrl_options *opts = nctrl->opts; + +if (opts->nr_write_queues && opts->nr_io_queues < nr_io_queues) { +/* +* separate read/write queues +* hand out dedicated default queues only after we have +* sufficient read queues. +*/ + ctrl->io_queues[HCTX_TYPE_READ ] = opts->nr_io_queues; + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_READ ]; + ctrl->io_queues[HCTX_TYPE_DEFAULT ] = +min (opts->nr_write_queues, nr_io_queues); + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + }else { +/* +* shared read/write queues +* either no write queues were requested, or we don't have +* sufficient queue count to have dedicated default queues. +*/ + ctrl->io_queues[HCTX_TYPE_DEFAULT ] = +min (opts->nr_io_queues, nr_io_queues); + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + } + +if (opts->nr_poll_queues && nr_io_queues) { +/* map dedicated poll queues only if we have queues left */ + ctrl->io_queues[HCTX_TYPE_POLL ] = +min (opts->nr_poll_queues, nr_io_queues); + } +} + +static void +nvme_tcp_ofld_terminate_io_queues (struct nvme_ctrl *nctrl,int start_from) +{ +int i; + +/* admin-q will be ignored because of the loop condition */ +for (i = start_from; i >=1 ; i--) +nvme_tcp_ofld_stop_queue (nctrl, i); +} + +static int nvme_tcp_ofld_create_io_queues (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +int i, rc; + +for (i =1 ; i < nctrl->queue_count; i++) { + rc = ctrl->dev->ops->create_queue (&ctrl->queues[i], + i, nctrl->sqsize +1 ); +if (rc) + goto out_free_queues; + +set_bit (NVME_TCP_OFLD_Q_ALLOCATED , &ctrl->queues[i].flags); + } + +return 0 ; + +out_free_queues: +nvme_tcp_ofld_terminate_io_queues (nctrl, --i); + +return rc; +} + +static int nvme_tcp_ofld_alloc_io_queues (struct nvme_ctrl *nctrl) +{ +unsigned int nr_io_queues; +int rc; + + nr_io_queues =nvme_tcp_ofld_nr_io_queues (nctrl); + rc =nvme_set_queue_count (nctrl, &nr_io_queues); +if (rc) +return rc; + + nctrl->queue_count = nr_io_queues +1 ; +if (nctrl->queue_count <2 ) { +dev_err (nctrl->device, +"unable to set any I/O queues\n" ); + +return -ENOMEM ; + } + +dev_info (nctrl->device,"creating %d I/O queues.\n" , nr_io_queues); +nvme_tcp_ofld_set_io_queues (nctrl, nr_io_queues); + +return nvme_tcp_ofld_create_io_queues (nctrl); +} + +static int nvme_tcp_ofld_start_io_queues (struct nvme_ctrl *nctrl) +{ +int i, rc =0 ; + +for (i =1 ; i < nctrl->queue_count; i++) { + rc =nvme_tcp_ofld_start_queue (nctrl, i); +if (rc) + goto terminate_queues; + } + +return 0 ; + +terminate_queues: +nvme_tcp_ofld_terminate_io_queues (nctrl, --i);return rc; }
@@ -258,9 +468,10 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl,static int nvme_tcp_ofld_configure_io_queues (struct nvme_ctrl *nctrl,bool new) { -int rc; +int rc =nvme_tcp_ofld_alloc_io_queues (nctrl); -/* Placeholder - alloc_io_queues */ +if (rc) +return rc;if (new) { nctrl->tagset =nvme_tcp_ofld_alloc_tagset (nctrl, false);
@@ -278,7 +489,9 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new) } } -/* Placeholder - start_io_queues */ + rc =nvme_tcp_ofld_start_io_queues (nctrl); +if (rc) + goto out_cleanup_connect_q;if (!new) {nvme_start_queues (nctrl);
@@ -300,16 +513,16 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new) out_wait_freeze_timed_out:nvme_stop_queues (nctrl);nvme_sync_io_queues (nctrl); - -/* Placeholder - Stop IO queues */ - +nvme_tcp_ofld_stop_io_queues (nctrl); +out_cleanup_connect_q: +nvme_cancel_tagset (nctrl);if (new)blk_cleanup_queue (nctrl->connect_q); out_free_tag_set:if (new)blk_mq_free_tag_set (nctrl->tagset); out_free_io_queues: -/* Placeholder - free_io_queues */ +nvme_tcp_ofld_terminate_io_queues (nctrl, nctrl->queue_count);return rc; }
@@ -336,6 +549,26 @@ static void nvme_tcp_ofld_reconnect_or_remove(struct nvme_ctrl *nctrl) } } +static int +nvme_tcp_ofld_init_admin_hctx (struct blk_mq_hw_ctx *hctx,void *data, +unsigned int hctx_idx) +{ +struct nvme_tcp_ofld_ctrl *ctrl = data; + + hctx->driver_data = &ctrl->queues[0 ]; + +return 0 ; +} + +static void nvme_tcp_ofld_destroy_io_queues (struct nvme_ctrl *nctrl,bool remove) +{ +nvme_tcp_ofld_stop_io_queues (nctrl); +if (remove) { +blk_cleanup_queue (nctrl->connect_q); +blk_mq_free_tag_set (nctrl->tagset); + } +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) {struct nvmf_ctrl_options *opts = nctrl->opts;
@@ -387,9 +620,19 @@ static int nvme_tcp_ofld_setup_ctrl(struct nvme_ctrl *nctrl, bool new)return 0 ; destroy_io: -/* Placeholder - stop and destroy io queues*/ +if (nctrl->queue_count >1 ) { +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); +nvme_tcp_ofld_stop_io_queues (nctrl); +nvme_cancel_tagset (nctrl); +nvme_tcp_ofld_destroy_io_queues (nctrl, new); + } destroy_admin: -/* Placeholder - stop and destroy admin queue*/ +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); +nvme_tcp_ofld_stop_queue (nctrl,0 ); +nvme_cancel_admin_tagset (nctrl); +nvme_tcp_ofld_destroy_admin_queue (nctrl, new);return rc; }
@@ -410,6 +653,18 @@ nvme_tcp_ofld_check_dev_opts(struct nvmf_ctrl_options *opts,return 0 ; } +static void nvme_tcp_ofld_free_ctrl_queues (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +int i; + +for (i =0 ; i < nctrl->queue_count; ++i) +nvme_tcp_ofld_free_queue (nctrl, i); + +kfree (ctrl->queues); + ctrl->queues =NULL ; +} +static void nvme_tcp_ofld_free_ctrl (struct nvme_ctrl *nctrl) {struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl);
@@ -419,6 +674,7 @@ static void nvme_tcp_ofld_free_ctrl(struct nvme_ctrl *nctrl) goto free_ctrl;down_write (&nvme_tcp_ofld_ctrl_rwsem); +nvme_tcp_ofld_free_ctrl_queues (nctrl); ctrl->dev->ops->release_ctrl (ctrl);list_del (&ctrl->list);up_write (&nvme_tcp_ofld_ctrl_rwsem);
@@ -436,15 +692,37 @@ static void nvme_tcp_ofld_submit_async_event(struct nvme_ctrl *arg) }static void -nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *ctrl,bool remove) +nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *nctrl,bool remove) { -/* Placeholder - teardown_admin_queue */ +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); + +nvme_tcp_ofld_stop_queue (nctrl,0 ); +nvme_cancel_admin_tagset (nctrl); + +if (remove) +blk_mq_unquiesce_queue (nctrl->admin_q); + +nvme_tcp_ofld_destroy_admin_queue (nctrl, remove); }static void nvme_tcp_ofld_teardown_io_queues (struct nvme_ctrl *nctrl,bool remove) { -/* Placeholder - teardown_io_queues */ +if (nctrl->queue_count <=1 ) +return ; + +blk_mq_quiesce_queue (nctrl->admin_q); +nvme_start_freeze (nctrl); +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); +nvme_tcp_ofld_stop_io_queues (nctrl); +nvme_cancel_tagset (nctrl); + +if (remove) +nvme_start_queues (nctrl); + +nvme_tcp_ofld_destroy_io_queues (nctrl, remove); }static void nvme_tcp_ofld_reconnect_ctrl_work (struct work_struct *work)
@@ -572,6 +850,17 @@ nvme_tcp_ofld_init_request(struct blk_mq_tag_set *set,return 0 ; } +inline size_t nvme_tcp_ofld_inline_data_size (struct nvme_tcp_ofld_queue *queue) +{ +return queue->cmnd_capsule_len -sizeof (struct nvme_command ); +} +EXPORT_SYMBOL_GPL (nvme_tcp_ofld_inline_data_size); + +static void nvme_tcp_ofld_commit_rqs (struct blk_mq_hw_ctx *hctx) +{ +/* Call ops->commit_rqs */ +} +static blk_status_t nvme_tcp_ofld_queue_rq (struct blk_mq_hw_ctx *hctx,const struct blk_mq_queue_data *bd)
@@ -583,22 +872,96 @@ nvme_tcp_ofld_queue_rq(struct blk_mq_hw_ctx *hctx,return BLK_STS_OK ; } +static void +nvme_tcp_ofld_exit_request (struct blk_mq_tag_set *set, +struct request *rq,unsigned int hctx_idx) +{ +/* +* Nothing is allocated in nvme_tcp_ofld_init_request, +* hence empty. +*/ +} + +static int +nvme_tcp_ofld_init_hctx (struct blk_mq_hw_ctx *hctx,void *data, +unsigned int hctx_idx) +{ +struct nvme_tcp_ofld_ctrl *ctrl = data; + + hctx->driver_data = &ctrl->queues[hctx_idx +1 ]; + +return 0 ; +} + +static int nvme_tcp_ofld_map_queues (struct blk_mq_tag_set *set) +{ +struct nvme_tcp_ofld_ctrl *ctrl = set->driver_data; +struct nvmf_ctrl_options *opts = ctrl->nctrl.opts; + +if (opts->nr_write_queues && ctrl->io_queues[HCTX_TYPE_READ ]) { +/* separate read/write queues */ + set->map[HCTX_TYPE_DEFAULT ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_DEFAULT ].queue_offset =0 ; + set->map[HCTX_TYPE_READ ].nr_queues = + ctrl->io_queues[HCTX_TYPE_READ ]; + set->map[HCTX_TYPE_READ ].queue_offset = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + }else { +/* shared read/write queues */ + set->map[HCTX_TYPE_DEFAULT ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_DEFAULT ].queue_offset =0 ; + set->map[HCTX_TYPE_READ ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_READ ].queue_offset =0 ; + } +blk_mq_map_queues (&set->map[HCTX_TYPE_DEFAULT ]); +blk_mq_map_queues (&set->map[HCTX_TYPE_READ ]); + +if (opts->nr_poll_queues && ctrl->io_queues[HCTX_TYPE_POLL ]) { +/* map dedicated poll queues only if we have queues left */ + set->map[HCTX_TYPE_POLL ].nr_queues = + ctrl->io_queues[HCTX_TYPE_POLL ]; + set->map[HCTX_TYPE_POLL ].queue_offset = + ctrl->io_queues[HCTX_TYPE_DEFAULT ] + + ctrl->io_queues[HCTX_TYPE_READ ]; +blk_mq_map_queues (&set->map[HCTX_TYPE_POLL ]); + } + +dev_info (ctrl->nctrl.device, +"mapped %d/%d/%d default/read/poll queues.\n" , + ctrl->io_queues[HCTX_TYPE_DEFAULT ], + ctrl->io_queues[HCTX_TYPE_READ ], + ctrl->io_queues[HCTX_TYPE_POLL ]); + +return 0 ; +} + +static int nvme_tcp_ofld_poll (struct blk_mq_hw_ctx *hctx) +{ +/* Placeholder - Implement polling mechanism */ + +return 0 ; +} +static struct blk_mq_ops nvme_tcp_ofld_mq_ops = { .queue_rq = nvme_tcp_ofld_queue_rq, + .commit_rqs = nvme_tcp_ofld_commit_rqs, + .complete = nvme_complete_rq, .init_request = nvme_tcp_ofld_init_request, -/* -* All additional ops will be also implemented and registered similar to -* tcp.c -*/ + .exit_request = nvme_tcp_ofld_exit_request, + .init_hctx = nvme_tcp_ofld_init_hctx, + .map_queues = nvme_tcp_ofld_map_queues, + .poll = nvme_tcp_ofld_poll, };static struct blk_mq_ops nvme_tcp_ofld_admin_mq_ops = { .queue_rq = nvme_tcp_ofld_queue_rq, + .complete = nvme_complete_rq, .init_request = nvme_tcp_ofld_init_request, -/* -* All additional ops will be also implemented and registered similar to -* tcp.c -*/ + .exit_request = nvme_tcp_ofld_exit_request, + .init_hctx = nvme_tcp_ofld_init_admin_hctx, };static const struct nvme_ctrl_ops nvme_tcp_ofld_ctrl_ops = {
drivers/nvme/host/tcp-offload.h +1 -1
@@ -105,7 +105,6 @@ struct nvme_tcp_ofld_ctrl {* Each entry in the array indicates the number of queues of * corresponding type. */ -u32 queue_type_mapping[HCTX_MAX_TYPES ];u32 io_queues[HCTX_MAX_TYPES ];/* Connectivity params */
@@ -205,3 +204,4 @@ struct nvme_tcp_ofld_ops {int nvme_tcp_ofld_register_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_unregister_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl); +inline size_t nvme_tcp_ofld_inline_data_size (struct nvme_tcp_ofld_queue *queue);
Signature · 1 line
2.22.0
Re: [RFC PATCH v4 13/27] nvme-tcp-offload: Add queue level implementation
Quoted 172 lines · Shai Malin
From: Dean Balandin <[email protected]>
In this patch we implement queue level functionality.
The implementation is similar to the nvme-tcp module, the main difference being that we call the vendor specificcreate_queueop which creates the TCP connection, and NVMeTPC connection including icreq+icresp negotiation.
Oncecreate_queuereturns successfully, we can move on to the fabrics connect.Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/tcp-offload.c | 415 ++++++++++++++++++++++++++++++-- drivers/nvme/host/tcp-offload.h | 2 +- 2 files changed, 390 insertions(+), 27 deletions(-)drivers/nvme/host/tcp-offload.c +101
-6@@ -22,6 +22,11 @@ static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl(struct nvme_ctrl *nctr return container_of(nctrl, struct nvme_tcp_ofld_ctrl, nctrl); } +static inline int nvme_tcp_ofld_qid (struct nvme_tcp_ofld_queue *queue) +{ +return queue - queue->ctrl->queues; +} +/** * nvme_tcp_ofld_register_dev() - NVMeTCP Offload Library registration * function. @@ -191,12 +196,94 @@ nvme_tcp_ofld_alloc_tagset(struct nvme_ctrl *nctrl, bool admin)return set; } +static void __nvme_tcp_ofld_stop_queue (struct nvme_tcp_ofld_queue *queue) +{ + queue->dev->ops->drain_queue (queue); + queue->dev->ops->destroy_queue (queue); +} + +static void nvme_tcp_ofld_stop_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; + +if (!test_and_clear_bit (NVME_TCP_OFLD_Q_LIVE , &queue->flags)) +return ; + +__nvme_tcp_ofld_stop_queue (queue); +} + +static void nvme_tcp_ofld_stop_io_queues (struct nvme_ctrl *ctrl) +{ +int i; + +for (i =1 ; i < ctrl->queue_count; i++) +nvme_tcp_ofld_stop_queue (ctrl, i); +} + +static void nvme_tcp_ofld_free_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; + +if (!test_and_clear_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags)) +return ; + + queue = &ctrl->queues[qid]; + queue->ctrl =NULL ; + queue->dev =NULL ; + queue->report_err =NULL ; +} + +static void nvme_tcp_ofld_destroy_admin_queue (struct nvme_ctrl *nctrl,bool remove) +{ +nvme_tcp_ofld_stop_queue (nctrl,0 ); +if (remove) { +blk_cleanup_queue (nctrl->admin_q); +blk_cleanup_queue (nctrl->fabrics_q); +blk_mq_free_tag_set (nctrl->admin_tagset); + } +} + +static int nvme_tcp_ofld_start_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; +int rc; + + queue = &ctrl->queues[qid]; +if (qid) { + queue->cmnd_capsule_len = nctrl->ioccsz *16 ; + rc =nvmf_connect_io_queue (nctrl, qid, false); + }else { + queue->cmnd_capsule_len =sizeof (struct nvme_command ) +NVME_TCP_ADMIN_CCSZ ; + rc =nvmf_connect_admin_queue (nctrl); + } + +if (!rc) { +set_bit (NVME_TCP_OFLD_Q_LIVE , &queue->flags); + }else { +if (test_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags)) +__nvme_tcp_ofld_stop_queue (queue); +dev_err (nctrl->device, +"failed to connect queue: %d ret=%d\n" , qid, rc); + } + +return rc; +} +static int nvme_tcp_ofld_configure_admin_queue (struct nvme_ctrl *nctrl,bool new) { +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[0 ];int rc; -/* Placeholder - alloc_admin_queue */ + rc = ctrl->dev->ops->create_queue (queue,0 ,NVME_AQ_DEPTH ); +if (rc) +return rc; + +set_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags);if (new) { nctrl->admin_tagset =nvme_tcp_ofld_alloc_tagset (nctrl, true);@@ -221,7 +308,9 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, } } -/* Placeholder - nvme_tcp_ofld_start_queue */ + rc =nvme_tcp_ofld_start_queue (nctrl,0 ); +if (rc) + goto out_cleanup_queue; rc =nvme_enable_ctrl (nctrl);if (rc)@@ -238,11 +327,12 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, out_quiesce_queue:blk_mq_quiesce_queue (nctrl->admin_q);blk_sync_queue (nctrl->admin_q); - out_stop_queue: -/* Placeholder - stop offload queue */ +nvme_tcp_ofld_stop_queue (nctrl,0 );nvme_cancel_admin_tagset (nctrl); - +out_cleanup_queue: +if (new) +blk_cleanup_queue (nctrl->admin_q); out_cleanup_fabrics_q:if (new)blk_cleanup_queue (nctrl->fabrics_q);@@ -250,7 +340,127 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl,if (new)blk_mq_free_tag_set (nctrl->admin_tagset); out_free_queue: -/* Placeholder - free admin queue */ +nvme_tcp_ofld_free_queue (nctrl,0 ); + +return rc; +} + +static unsigned int nvme_tcp_ofld_nr_io_queues (struct nvme_ctrl *nctrl)
drivers/nvme/host/tcp-offload.c static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, · line 358
Quoted 10 lines
drivers/nvme/host/tcp-offload.c +10
-0+{ +unsigned int nr_io_queues; + + nr_io_queues =min (nctrl->opts->nr_io_queues,num_online_cpus ()); + nr_io_queues +=min (nctrl->opts->nr_write_queues,num_online_cpus ()); + nr_io_queues +=min (nctrl->opts->nr_poll_queues,num_online_cpus ()); + +return nr_io_queues; +} +
Really? Isn't this hardware-dependent?
I would have expected the hardware to impose some limitations here (# of MSIx interrupts or something). Hmm?
Quoted 25 lines
drivers/nvme/host/tcp-offload.c +25
-0+static void +nvme_tcp_ofld_set_io_queues (struct nvme_ctrl *nctrl,unsigned int nr_io_queues) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvmf_ctrl_options *opts = nctrl->opts; + +if (opts->nr_write_queues && opts->nr_io_queues < nr_io_queues) { +/* +* separate read/write queues +* hand out dedicated default queues only after we have +* sufficient read queues. +*/ + ctrl->io_queues[HCTX_TYPE_READ ] = opts->nr_io_queues; + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_READ ]; + ctrl->io_queues[HCTX_TYPE_DEFAULT ] = +min (opts->nr_write_queues, nr_io_queues); + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + }else { +/* +* shared read/write queues +* either no write queues were requested, or we don't have +* sufficient queue count to have dedicated default queues. +*/ + ctrl->io_queues[HCTX_TYPE_DEFAULT ] = +min (opts->nr_io_queues, nr_io_queues);
drivers/nvme/host/tcp-offload.c static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, · line 393
Quoted 10 lines
drivers/nvme/host/tcp-offload.c +10
-0+ nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + } + +if (opts->nr_poll_queues && nr_io_queues) { +/* map dedicated poll queues only if we have queues left */ + ctrl->io_queues[HCTX_TYPE_POLL ] = +min (opts->nr_poll_queues, nr_io_queues); + } +} +
Same here.
Poll queues only ever make sense of the hardware can serve specific queue pairs without interrupts. Which again relates to the number of interrupts, and the affinity of those. Or isn't this a concern with your card?
drivers/nvme/host/tcp-offload.c static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, · line 403
Quoted 10 lines
drivers/nvme/host/tcp-offload.c +10
-0+static void +nvme_tcp_ofld_terminate_io_queues (struct nvme_ctrl *nctrl,int start_from) +{ +int i; + +/* admin-q will be ignored because of the loop condition */ +for (i = start_from; i >=1 ; i--) +nvme_tcp_ofld_stop_queue (nctrl, i); +} +
Loop condition? Care to elaborate?
Quoted 362 lines
drivers/nvme/host/tcp-offload.c +233
-20+static int nvme_tcp_ofld_create_io_queues (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +int i, rc; + +for (i =1 ; i < nctrl->queue_count; i++) { + rc = ctrl->dev->ops->create_queue (&ctrl->queues[i], + i, nctrl->sqsize +1 ); +if (rc) + goto out_free_queues; + +set_bit (NVME_TCP_OFLD_Q_ALLOCATED , &ctrl->queues[i].flags); + } + +return 0 ; + +out_free_queues: +nvme_tcp_ofld_terminate_io_queues (nctrl, --i); + +return rc; +} + +static int nvme_tcp_ofld_alloc_io_queues (struct nvme_ctrl *nctrl) +{ +unsigned int nr_io_queues; +int rc; + + nr_io_queues =nvme_tcp_ofld_nr_io_queues (nctrl); + rc =nvme_set_queue_count (nctrl, &nr_io_queues); +if (rc) +return rc; + + nctrl->queue_count = nr_io_queues +1 ; +if (nctrl->queue_count <2 ) { +dev_err (nctrl->device, +"unable to set any I/O queues\n" ); + +return -ENOMEM ; + } + +dev_info (nctrl->device,"creating %d I/O queues.\n" , nr_io_queues); +nvme_tcp_ofld_set_io_queues (nctrl, nr_io_queues); + +return nvme_tcp_ofld_create_io_queues (nctrl); +} + +static int nvme_tcp_ofld_start_io_queues (struct nvme_ctrl *nctrl) +{ +int i, rc =0 ; + +for (i =1 ; i < nctrl->queue_count; i++) { + rc =nvme_tcp_ofld_start_queue (nctrl, i); +if (rc) + goto terminate_queues; + } + +return 0 ; + +terminate_queues: +nvme_tcp_ofld_terminate_io_queues (nctrl, --i);return rc; }@@ -258,9 +468,10 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl,static int nvme_tcp_ofld_configure_io_queues (struct nvme_ctrl *nctrl,bool new) { -int rc; +int rc =nvme_tcp_ofld_alloc_io_queues (nctrl); -/* Placeholder - alloc_io_queues */ +if (rc) +return rc;if (new) { nctrl->tagset =nvme_tcp_ofld_alloc_tagset (nctrl, false);@@ -278,7 +489,9 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new) } } -/* Placeholder - start_io_queues */ + rc =nvme_tcp_ofld_start_io_queues (nctrl); +if (rc) + goto out_cleanup_connect_q;if (!new) {nvme_start_queues (nctrl);@@ -300,16 +513,16 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new) out_wait_freeze_timed_out:nvme_stop_queues (nctrl);nvme_sync_io_queues (nctrl); - -/* Placeholder - Stop IO queues */ - +nvme_tcp_ofld_stop_io_queues (nctrl); +out_cleanup_connect_q: +nvme_cancel_tagset (nctrl);if (new)blk_cleanup_queue (nctrl->connect_q); out_free_tag_set:if (new)blk_mq_free_tag_set (nctrl->tagset); out_free_io_queues: -/* Placeholder - free_io_queues */ +nvme_tcp_ofld_terminate_io_queues (nctrl, nctrl->queue_count);return rc; }@@ -336,6 +549,26 @@ static void nvme_tcp_ofld_reconnect_or_remove(struct nvme_ctrl *nctrl) } } +static int +nvme_tcp_ofld_init_admin_hctx (struct blk_mq_hw_ctx *hctx,void *data, +unsigned int hctx_idx) +{ +struct nvme_tcp_ofld_ctrl *ctrl = data; + + hctx->driver_data = &ctrl->queues[0 ]; + +return 0 ; +} + +static void nvme_tcp_ofld_destroy_io_queues (struct nvme_ctrl *nctrl,bool remove) +{ +nvme_tcp_ofld_stop_io_queues (nctrl); +if (remove) { +blk_cleanup_queue (nctrl->connect_q); +blk_mq_free_tag_set (nctrl->tagset); + } +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) {struct nvmf_ctrl_options *opts = nctrl->opts;@@ -387,9 +620,19 @@ static int nvme_tcp_ofld_setup_ctrl(struct nvme_ctrl *nctrl, bool new)return 0 ; destroy_io: -/* Placeholder - stop and destroy io queues*/ +if (nctrl->queue_count >1 ) { +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); +nvme_tcp_ofld_stop_io_queues (nctrl); +nvme_cancel_tagset (nctrl); +nvme_tcp_ofld_destroy_io_queues (nctrl, new); + } destroy_admin: -/* Placeholder - stop and destroy admin queue*/ +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); +nvme_tcp_ofld_stop_queue (nctrl,0 ); +nvme_cancel_admin_tagset (nctrl); +nvme_tcp_ofld_destroy_admin_queue (nctrl, new);return rc; }@@ -410,6 +653,18 @@ nvme_tcp_ofld_check_dev_opts(struct nvmf_ctrl_options *opts,return 0 ; } +static void nvme_tcp_ofld_free_ctrl_queues (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +int i; + +for (i =0 ; i < nctrl->queue_count; ++i) +nvme_tcp_ofld_free_queue (nctrl, i); + +kfree (ctrl->queues); + ctrl->queues =NULL ; +} +static void nvme_tcp_ofld_free_ctrl (struct nvme_ctrl *nctrl) {struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl);@@ -419,6 +674,7 @@ static void nvme_tcp_ofld_free_ctrl(struct nvme_ctrl *nctrl) goto free_ctrl;down_write (&nvme_tcp_ofld_ctrl_rwsem); +nvme_tcp_ofld_free_ctrl_queues (nctrl); ctrl->dev->ops->release_ctrl (ctrl);list_del (&ctrl->list);up_write (&nvme_tcp_ofld_ctrl_rwsem);@@ -436,15 +692,37 @@ static void nvme_tcp_ofld_submit_async_event(struct nvme_ctrl *arg) }static void -nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *ctrl,bool remove) +nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *nctrl,bool remove) { -/* Placeholder - teardown_admin_queue */ +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); + +nvme_tcp_ofld_stop_queue (nctrl,0 ); +nvme_cancel_admin_tagset (nctrl); + +if (remove) +blk_mq_unquiesce_queue (nctrl->admin_q); + +nvme_tcp_ofld_destroy_admin_queue (nctrl, remove); }static void nvme_tcp_ofld_teardown_io_queues (struct nvme_ctrl *nctrl,bool remove) { -/* Placeholder - teardown_io_queues */ +if (nctrl->queue_count <=1 ) +return ; + +blk_mq_quiesce_queue (nctrl->admin_q); +nvme_start_freeze (nctrl); +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); +nvme_tcp_ofld_stop_io_queues (nctrl); +nvme_cancel_tagset (nctrl); + +if (remove) +nvme_start_queues (nctrl); + +nvme_tcp_ofld_destroy_io_queues (nctrl, remove); }static void nvme_tcp_ofld_reconnect_ctrl_work (struct work_struct *work)@@ -572,6 +850,17 @@ nvme_tcp_ofld_init_request(struct blk_mq_tag_set *set,return 0 ; } +inline size_t nvme_tcp_ofld_inline_data_size (struct nvme_tcp_ofld_queue *queue) +{ +return queue->cmnd_capsule_len -sizeof (struct nvme_command ); +} +EXPORT_SYMBOL_GPL (nvme_tcp_ofld_inline_data_size); + +static void nvme_tcp_ofld_commit_rqs (struct blk_mq_hw_ctx *hctx) +{ +/* Call ops->commit_rqs */ +} +static blk_status_t nvme_tcp_ofld_queue_rq (struct blk_mq_hw_ctx *hctx,const struct blk_mq_queue_data *bd)@@ -583,22 +872,96 @@ nvme_tcp_ofld_queue_rq(struct blk_mq_hw_ctx *hctx,return BLK_STS_OK ; } +static void +nvme_tcp_ofld_exit_request (struct blk_mq_tag_set *set, +struct request *rq,unsigned int hctx_idx) +{ +/* +* Nothing is allocated in nvme_tcp_ofld_init_request, +* hence empty. +*/ +} + +static int +nvme_tcp_ofld_init_hctx (struct blk_mq_hw_ctx *hctx,void *data, +unsigned int hctx_idx) +{ +struct nvme_tcp_ofld_ctrl *ctrl = data; + + hctx->driver_data = &ctrl->queues[hctx_idx +1 ]; + +return 0 ; +} + +static int nvme_tcp_ofld_map_queues (struct blk_mq_tag_set *set) +{ +struct nvme_tcp_ofld_ctrl *ctrl = set->driver_data; +struct nvmf_ctrl_options *opts = ctrl->nctrl.opts; + +if (opts->nr_write_queues && ctrl->io_queues[HCTX_TYPE_READ ]) { +/* separate read/write queues */ + set->map[HCTX_TYPE_DEFAULT ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_DEFAULT ].queue_offset =0 ; + set->map[HCTX_TYPE_READ ].nr_queues = + ctrl->io_queues[HCTX_TYPE_READ ]; + set->map[HCTX_TYPE_READ ].queue_offset = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + }else { +/* shared read/write queues */ + set->map[HCTX_TYPE_DEFAULT ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_DEFAULT ].queue_offset =0 ; + set->map[HCTX_TYPE_READ ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_READ ].queue_offset =0 ; + } +blk_mq_map_queues (&set->map[HCTX_TYPE_DEFAULT ]); +blk_mq_map_queues (&set->map[HCTX_TYPE_READ ]); + +if (opts->nr_poll_queues && ctrl->io_queues[HCTX_TYPE_POLL ]) { +/* map dedicated poll queues only if we have queues left */ + set->map[HCTX_TYPE_POLL ].nr_queues = + ctrl->io_queues[HCTX_TYPE_POLL ]; + set->map[HCTX_TYPE_POLL ].queue_offset = + ctrl->io_queues[HCTX_TYPE_DEFAULT ] + + ctrl->io_queues[HCTX_TYPE_READ ]; +blk_mq_map_queues (&set->map[HCTX_TYPE_POLL ]); + } + +dev_info (ctrl->nctrl.device, +"mapped %d/%d/%d default/read/poll queues.\n" , + ctrl->io_queues[HCTX_TYPE_DEFAULT ], + ctrl->io_queues[HCTX_TYPE_READ ], + ctrl->io_queues[HCTX_TYPE_POLL ]); + +return 0 ; +} + +static int nvme_tcp_ofld_poll (struct blk_mq_hw_ctx *hctx) +{ +/* Placeholder - Implement polling mechanism */ + +return 0 ; +} +static struct blk_mq_ops nvme_tcp_ofld_mq_ops = { .queue_rq = nvme_tcp_ofld_queue_rq, + .commit_rqs = nvme_tcp_ofld_commit_rqs, + .complete = nvme_complete_rq, .init_request = nvme_tcp_ofld_init_request, -/* -* All additional ops will be also implemented and registered similar to -* tcp.c -*/ + .exit_request = nvme_tcp_ofld_exit_request, + .init_hctx = nvme_tcp_ofld_init_hctx, + .map_queues = nvme_tcp_ofld_map_queues, + .poll = nvme_tcp_ofld_poll, };static struct blk_mq_ops nvme_tcp_ofld_admin_mq_ops = { .queue_rq = nvme_tcp_ofld_queue_rq, + .complete = nvme_complete_rq, .init_request = nvme_tcp_ofld_init_request, -/* -* All additional ops will be also implemented and registered similar to -* tcp.c -*/ + .exit_request = nvme_tcp_ofld_exit_request, + .init_hctx = nvme_tcp_ofld_init_admin_hctx, };static const struct nvme_ctrl_ops nvme_tcp_ofld_ctrl_ops = {drivers/nvme/host/tcp-offload.h +0
-1@@ -105,7 +105,6 @@ struct nvme_tcp_ofld_ctrl {* Each entry in the array indicates the number of queues of * corresponding type. */ -u32 queue_type_mapping[HCTX_MAX_TYPES ];u32 io_queues[HCTX_MAX_TYPES ];/* Connectivity params */
drivers/nvme/host/tcp-offload.h struct nvme_tcp_ofld_ops { · line 207
Quoted 4 lines
drivers/nvme/host/tcp-offload.h +1
-0@@ -205,3 +204,4 @@ struct nvme_tcp_ofld_ops {int nvme_tcp_ofld_register_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_unregister_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl); +inline size_t nvme_tcp_ofld_inline_data_size (struct nvme_tcp_ofld_queue *queue);
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
Re: [RFC PATCH v4 13/27] nvme-tcp-offload: Add queue level implementation
Quoted 179 lines · Hannes Reinecke
Quoted 178 lines · Shai Malin
From: Dean Balandin <[email protected]>
In this patch we implement queue level functionality.
The implementation is similar to the nvme-tcp module, the main difference being that we call the vendor specificcreate_queueop which creates the TCP connection, and NVMeTPC connection including icreq+icresp negotiation.
Oncecreate_queuereturns successfully, we can move on to the fabrics connect.Acked-by Igor Russkikh <[email protected]>Signed-off-by Dean Balandin <[email protected]>Signed-off-by Prabhakar Kushwaha <[email protected]>Signed-off-by Omkar Kulkarni <[email protected]>Signed-off-by Michal Kalderon <[email protected]>Signed-off-by Ariel Elior <[email protected]>Signed-off-by Shai Malin <[email protected]>--- drivers/nvme/host/tcp-offload.c | 415 ++++++++++++++++++++++++++++++-- drivers/nvme/host/tcp-offload.h | 2 +- 2 files changed, 390 insertions(+), 27 deletions(-)drivers/nvme/host/tcp-offload.c +107
-6@@ -22,6 +22,11 @@ static inline struct nvme_tcp_ofld_ctrl *to_tcp_ofld_ctrl(struct nvme_ctrl *nctr return container_of(nctrl, struct nvme_tcp_ofld_ctrl, nctrl); } +static inline int nvme_tcp_ofld_qid (struct nvme_tcp_ofld_queue *queue) +{ +return queue - queue->ctrl->queues; +} +/** * nvme_tcp_ofld_register_dev() - NVMeTCP Offload Library registration * function. @@ -191,12 +196,94 @@ nvme_tcp_ofld_alloc_tagset(struct nvme_ctrl *nctrl, bool admin)return set; } +static void __nvme_tcp_ofld_stop_queue (struct nvme_tcp_ofld_queue *queue) +{ + queue->dev->ops->drain_queue (queue); + queue->dev->ops->destroy_queue (queue); +} + +static void nvme_tcp_ofld_stop_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; + +if (!test_and_clear_bit (NVME_TCP_OFLD_Q_LIVE , &queue->flags)) +return ; + +__nvme_tcp_ofld_stop_queue (queue); +} + +static void nvme_tcp_ofld_stop_io_queues (struct nvme_ctrl *ctrl) +{ +int i; + +for (i =1 ; i < ctrl->queue_count; i++) +nvme_tcp_ofld_stop_queue (ctrl, i); +} + +static void nvme_tcp_ofld_free_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; + +if (!test_and_clear_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags)) +return ; + + queue = &ctrl->queues[qid]; + queue->ctrl =NULL ; + queue->dev =NULL ; + queue->report_err =NULL ; +} + +static void nvme_tcp_ofld_destroy_admin_queue (struct nvme_ctrl *nctrl,bool remove) +{ +nvme_tcp_ofld_stop_queue (nctrl,0 ); +if (remove) { +blk_cleanup_queue (nctrl->admin_q); +blk_cleanup_queue (nctrl->fabrics_q); +blk_mq_free_tag_set (nctrl->admin_tagset); + } +} + +static int nvme_tcp_ofld_start_queue (struct nvme_ctrl *nctrl,int qid) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[qid]; +int rc; + + queue = &ctrl->queues[qid]; +if (qid) { + queue->cmnd_capsule_len = nctrl->ioccsz *16 ; + rc =nvmf_connect_io_queue (nctrl, qid, false); + }else { + queue->cmnd_capsule_len =sizeof (struct nvme_command ) +NVME_TCP_ADMIN_CCSZ ; + rc =nvmf_connect_admin_queue (nctrl); + } + +if (!rc) { +set_bit (NVME_TCP_OFLD_Q_LIVE , &queue->flags); + }else { +if (test_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags)) +__nvme_tcp_ofld_stop_queue (queue); +dev_err (nctrl->device, +"failed to connect queue: %d ret=%d\n" , qid, rc); + } + +return rc; +} +static int nvme_tcp_ofld_configure_admin_queue (struct nvme_ctrl *nctrl,bool new) { +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvme_tcp_ofld_queue *queue = &ctrl->queues[0 ];int rc; -/* Placeholder - alloc_admin_queue */ + rc = ctrl->dev->ops->create_queue (queue,0 ,NVME_AQ_DEPTH ); +if (rc) +return rc; + +set_bit (NVME_TCP_OFLD_Q_ALLOCATED , &queue->flags);if (new) { nctrl->admin_tagset =nvme_tcp_ofld_alloc_tagset (nctrl, true);@@ -221,7 +308,9 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, } } -/* Placeholder - nvme_tcp_ofld_start_queue */ + rc =nvme_tcp_ofld_start_queue (nctrl,0 ); +if (rc) + goto out_cleanup_queue; rc =nvme_enable_ctrl (nctrl);if (rc)@@ -238,11 +327,12 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, out_quiesce_queue:blk_mq_quiesce_queue (nctrl->admin_q);blk_sync_queue (nctrl->admin_q); - out_stop_queue: -/* Placeholder - stop offload queue */ +nvme_tcp_ofld_stop_queue (nctrl,0 );nvme_cancel_admin_tagset (nctrl); - +out_cleanup_queue: +if (new) +blk_cleanup_queue (nctrl->admin_q); out_cleanup_fabrics_q:if (new)blk_cleanup_queue (nctrl->fabrics_q);@@ -250,7 +340,127 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl,if (new)blk_mq_free_tag_set (nctrl->admin_tagset); out_free_queue: -/* Placeholder - free admin queue */ +nvme_tcp_ofld_free_queue (nctrl,0 ); + +return rc; +} + +static unsigned int nvme_tcp_ofld_nr_io_queues (struct nvme_ctrl *nctrl) +{ +unsigned int nr_io_queues; + + nr_io_queues =min (nctrl->opts->nr_io_queues,num_online_cpus ()); + nr_io_queues +=min (nctrl->opts->nr_write_queues,num_online_cpus ()); + nr_io_queues +=min (nctrl->opts->nr_poll_queues,num_online_cpus ());
Quoted 8 lines
drivers/nvme/host/tcp-offload.c static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, · line 358
Quoted 4 lines
drivers/nvme/host/tcp-offload.c +4
-0+ +return nr_io_queues; +} +Really? Isn't this hardware-dependent?
I would have expected the hardware to impose some limitations here (# of MSIx interrupts or something). Hmm?
Right! We will be added to nvme_tcp_ofld_ops.
Quoted 34 lines
Quoted 34 lines
drivers/nvme/host/tcp-offload.c +33
-0+static void +nvme_tcp_ofld_set_io_queues (struct nvme_ctrl *nctrl,unsigned int nr_io_queues) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +struct nvmf_ctrl_options *opts = nctrl->opts; + +if (opts->nr_write_queues && opts->nr_io_queues < nr_io_queues) { +/* +* separate read/write queues +* hand out dedicated default queues only after we have +* sufficient read queues. +*/ + ctrl->io_queues[HCTX_TYPE_READ ] = opts->nr_io_queues; + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_READ ]; + ctrl->io_queues[HCTX_TYPE_DEFAULT ] = +min (opts->nr_write_queues, nr_io_queues); + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + }else { +/* +* shared read/write queues +* either no write queues were requested, or we don't have +* sufficient queue count to have dedicated default queues. +*/ + ctrl->io_queues[HCTX_TYPE_DEFAULT ] = +min (opts->nr_io_queues, nr_io_queues); + nr_io_queues -= ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + } + +if (opts->nr_poll_queues && nr_io_queues) { +/* map dedicated poll queues only if we have queues left */ + ctrl->io_queues[HCTX_TYPE_POLL ] = +min (opts->nr_poll_queues, nr_io_queues); + }
Quoted 8 lines
drivers/nvme/host/tcp-offload.c static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, · line 393
Quoted 2 lines
drivers/nvme/host/tcp-offload.c +2
-0+} +Same here.
Poll queues only ever make sense of the hardware can serve specific queue pairs without interrupts. Which again relates to the number of interrupts, and the affinity of those.
Or isn't this a concern with your card?
Right! We will be added to nvme_tcp_ofld_ops.
Our NVMeTCP offload HW supports 256 interrupt lines across the offload devices, meaning 64-256 per offload device, (depends on the number of ports).
Quoted 13 lines
drivers/nvme/host/tcp-offload.c static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl, · line 403
Quoted 11 lines
drivers/nvme/host/tcp-offload.c +10
-0+static void +nvme_tcp_ofld_terminate_io_queues (struct nvme_ctrl *nctrl,int start_from) +{ +int i; + +/* admin-q will be ignored because of the loop condition */ +for (i = start_from; i >=1 ; i--) +nvme_tcp_ofld_stop_queue (nctrl, i); +} +Loop condition? Care to elaborate?
Similar code (with the same loop condition) exists in the other transports, e.g. __nvme_tcp_alloc_io_queues(), which calls nvme_tcp_free_queues(). Will rephrase comment to: "Loop condition will stop before index 0 which is the admin queue."
Quoted 375 lines
Quoted 363 lines
drivers/nvme/host/tcp-offload.c +233
-20+static int nvme_tcp_ofld_create_io_queues (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +int i, rc; + +for (i =1 ; i < nctrl->queue_count; i++) { + rc = ctrl->dev->ops->create_queue (&ctrl->queues[i], + i, nctrl->sqsize +1 ); +if (rc) + goto out_free_queues; + +set_bit (NVME_TCP_OFLD_Q_ALLOCATED , &ctrl->queues[i].flags); + } + +return 0 ; + +out_free_queues: +nvme_tcp_ofld_terminate_io_queues (nctrl, --i); + +return rc; +} + +static int nvme_tcp_ofld_alloc_io_queues (struct nvme_ctrl *nctrl) +{ +unsigned int nr_io_queues; +int rc; + + nr_io_queues =nvme_tcp_ofld_nr_io_queues (nctrl); + rc =nvme_set_queue_count (nctrl, &nr_io_queues); +if (rc) +return rc; + + nctrl->queue_count = nr_io_queues +1 ; +if (nctrl->queue_count <2 ) { +dev_err (nctrl->device, +"unable to set any I/O queues\n" ); + +return -ENOMEM ; + } + +dev_info (nctrl->device,"creating %d I/O queues.\n" , nr_io_queues); +nvme_tcp_ofld_set_io_queues (nctrl, nr_io_queues); + +return nvme_tcp_ofld_create_io_queues (nctrl); +} + +static int nvme_tcp_ofld_start_io_queues (struct nvme_ctrl *nctrl) +{ +int i, rc =0 ; + +for (i =1 ; i < nctrl->queue_count; i++) { + rc =nvme_tcp_ofld_start_queue (nctrl, i); +if (rc) + goto terminate_queues; + } + +return 0 ; + +terminate_queues: +nvme_tcp_ofld_terminate_io_queues (nctrl, --i);return rc; }@@ -258,9 +468,10 @@ static int nvme_tcp_ofld_configure_admin_queue(struct nvme_ctrl *nctrl,static int nvme_tcp_ofld_configure_io_queues (struct nvme_ctrl *nctrl,bool new) { -int rc; +int rc =nvme_tcp_ofld_alloc_io_queues (nctrl); -/* Placeholder - alloc_io_queues */ +if (rc) +return rc;if (new) { nctrl->tagset =nvme_tcp_ofld_alloc_tagset (nctrl, false);@@ -278,7 +489,9 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new) } } -/* Placeholder - start_io_queues */ + rc =nvme_tcp_ofld_start_io_queues (nctrl); +if (rc) + goto out_cleanup_connect_q;if (!new) {nvme_start_queues (nctrl);@@ -300,16 +513,16 @@ nvme_tcp_ofld_configure_io_queues(struct nvme_ctrl *nctrl, bool new) out_wait_freeze_timed_out:nvme_stop_queues (nctrl);nvme_sync_io_queues (nctrl); - -/* Placeholder - Stop IO queues */ - +nvme_tcp_ofld_stop_io_queues (nctrl); +out_cleanup_connect_q: +nvme_cancel_tagset (nctrl);if (new)blk_cleanup_queue (nctrl->connect_q); out_free_tag_set:if (new)blk_mq_free_tag_set (nctrl->tagset); out_free_io_queues: -/* Placeholder - free_io_queues */ +nvme_tcp_ofld_terminate_io_queues (nctrl, nctrl->queue_count);return rc; }@@ -336,6 +549,26 @@ static void nvme_tcp_ofld_reconnect_or_remove(struct nvme_ctrl *nctrl) } } +static int +nvme_tcp_ofld_init_admin_hctx (struct blk_mq_hw_ctx *hctx,void *data, +unsigned int hctx_idx) +{ +struct nvme_tcp_ofld_ctrl *ctrl = data; + + hctx->driver_data = &ctrl->queues[0 ]; + +return 0 ; +} + +static void nvme_tcp_ofld_destroy_io_queues (struct nvme_ctrl *nctrl,bool remove) +{ +nvme_tcp_ofld_stop_io_queues (nctrl); +if (remove) { +blk_cleanup_queue (nctrl->connect_q); +blk_mq_free_tag_set (nctrl->tagset); + } +} +static int nvme_tcp_ofld_setup_ctrl (struct nvme_ctrl *nctrl,bool new) {struct nvmf_ctrl_options *opts = nctrl->opts;@@ -387,9 +620,19 @@ static int nvme_tcp_ofld_setup_ctrl(struct nvme_ctrl *nctrl, bool new)return 0 ; destroy_io: -/* Placeholder - stop and destroy io queues*/ +if (nctrl->queue_count >1 ) { +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); +nvme_tcp_ofld_stop_io_queues (nctrl); +nvme_cancel_tagset (nctrl); +nvme_tcp_ofld_destroy_io_queues (nctrl, new); + } destroy_admin: -/* Placeholder - stop and destroy admin queue*/ +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); +nvme_tcp_ofld_stop_queue (nctrl,0 ); +nvme_cancel_admin_tagset (nctrl); +nvme_tcp_ofld_destroy_admin_queue (nctrl, new);return rc; }@@ -410,6 +653,18 @@ nvme_tcp_ofld_check_dev_opts(struct nvmf_ctrl_options *opts,return 0 ; } +static void nvme_tcp_ofld_free_ctrl_queues (struct nvme_ctrl *nctrl) +{ +struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl); +int i; + +for (i =0 ; i < nctrl->queue_count; ++i) +nvme_tcp_ofld_free_queue (nctrl, i); + +kfree (ctrl->queues); + ctrl->queues =NULL ; +} +static void nvme_tcp_ofld_free_ctrl (struct nvme_ctrl *nctrl) {struct nvme_tcp_ofld_ctrl *ctrl =to_tcp_ofld_ctrl (nctrl);@@ -419,6 +674,7 @@ static void nvme_tcp_ofld_free_ctrl(struct nvme_ctrl *nctrl) goto free_ctrl;down_write (&nvme_tcp_ofld_ctrl_rwsem); +nvme_tcp_ofld_free_ctrl_queues (nctrl); ctrl->dev->ops->release_ctrl (ctrl);list_del (&ctrl->list);up_write (&nvme_tcp_ofld_ctrl_rwsem);@@ -436,15 +692,37 @@ static void nvme_tcp_ofld_submit_async_event(struct nvme_ctrl *arg) }static void -nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *ctrl,bool remove) +nvme_tcp_ofld_teardown_admin_queue (struct nvme_ctrl *nctrl,bool remove) { -/* Placeholder - teardown_admin_queue */ +blk_mq_quiesce_queue (nctrl->admin_q); +blk_sync_queue (nctrl->admin_q); + +nvme_tcp_ofld_stop_queue (nctrl,0 ); +nvme_cancel_admin_tagset (nctrl); + +if (remove) +blk_mq_unquiesce_queue (nctrl->admin_q); + +nvme_tcp_ofld_destroy_admin_queue (nctrl, remove); }static void nvme_tcp_ofld_teardown_io_queues (struct nvme_ctrl *nctrl,bool remove) { -/* Placeholder - teardown_io_queues */ +if (nctrl->queue_count <=1 ) +return ; + +blk_mq_quiesce_queue (nctrl->admin_q); +nvme_start_freeze (nctrl); +nvme_stop_queues (nctrl); +nvme_sync_io_queues (nctrl); +nvme_tcp_ofld_stop_io_queues (nctrl); +nvme_cancel_tagset (nctrl); + +if (remove) +nvme_start_queues (nctrl); + +nvme_tcp_ofld_destroy_io_queues (nctrl, remove); }static void nvme_tcp_ofld_reconnect_ctrl_work (struct work_struct *work)@@ -572,6 +850,17 @@ nvme_tcp_ofld_init_request(struct blk_mq_tag_set *set,return 0 ; } +inline size_t nvme_tcp_ofld_inline_data_size (struct nvme_tcp_ofld_queue *queue) +{ +return queue->cmnd_capsule_len -sizeof (struct nvme_command ); +} +EXPORT_SYMBOL_GPL (nvme_tcp_ofld_inline_data_size); + +static void nvme_tcp_ofld_commit_rqs (struct blk_mq_hw_ctx *hctx) +{ +/* Call ops->commit_rqs */ +} +static blk_status_t nvme_tcp_ofld_queue_rq (struct blk_mq_hw_ctx *hctx,const struct blk_mq_queue_data *bd)@@ -583,22 +872,96 @@ nvme_tcp_ofld_queue_rq(struct blk_mq_hw_ctx *hctx,return BLK_STS_OK ; } +static void +nvme_tcp_ofld_exit_request (struct blk_mq_tag_set *set, +struct request *rq,unsigned int hctx_idx) +{ +/* +* Nothing is allocated in nvme_tcp_ofld_init_request, +* hence empty. +*/ +} + +static int +nvme_tcp_ofld_init_hctx (struct blk_mq_hw_ctx *hctx,void *data, +unsigned int hctx_idx) +{ +struct nvme_tcp_ofld_ctrl *ctrl = data; + + hctx->driver_data = &ctrl->queues[hctx_idx +1 ]; + +return 0 ; +} + +static int nvme_tcp_ofld_map_queues (struct blk_mq_tag_set *set) +{ +struct nvme_tcp_ofld_ctrl *ctrl = set->driver_data; +struct nvmf_ctrl_options *opts = ctrl->nctrl.opts; + +if (opts->nr_write_queues && ctrl->io_queues[HCTX_TYPE_READ ]) { +/* separate read/write queues */ + set->map[HCTX_TYPE_DEFAULT ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_DEFAULT ].queue_offset =0 ; + set->map[HCTX_TYPE_READ ].nr_queues = + ctrl->io_queues[HCTX_TYPE_READ ]; + set->map[HCTX_TYPE_READ ].queue_offset = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + }else { +/* shared read/write queues */ + set->map[HCTX_TYPE_DEFAULT ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_DEFAULT ].queue_offset =0 ; + set->map[HCTX_TYPE_READ ].nr_queues = + ctrl->io_queues[HCTX_TYPE_DEFAULT ]; + set->map[HCTX_TYPE_READ ].queue_offset =0 ; + } +blk_mq_map_queues (&set->map[HCTX_TYPE_DEFAULT ]); +blk_mq_map_queues (&set->map[HCTX_TYPE_READ ]); + +if (opts->nr_poll_queues && ctrl->io_queues[HCTX_TYPE_POLL ]) { +/* map dedicated poll queues only if we have queues left */ + set->map[HCTX_TYPE_POLL ].nr_queues = + ctrl->io_queues[HCTX_TYPE_POLL ]; + set->map[HCTX_TYPE_POLL ].queue_offset = + ctrl->io_queues[HCTX_TYPE_DEFAULT ] + + ctrl->io_queues[HCTX_TYPE_READ ]; +blk_mq_map_queues (&set->map[HCTX_TYPE_POLL ]); + } + +dev_info (ctrl->nctrl.device, +"mapped %d/%d/%d default/read/poll queues.\n" , + ctrl->io_queues[HCTX_TYPE_DEFAULT ], + ctrl->io_queues[HCTX_TYPE_READ ], + ctrl->io_queues[HCTX_TYPE_POLL ]); + +return 0 ; +} + +static int nvme_tcp_ofld_poll (struct blk_mq_hw_ctx *hctx) +{ +/* Placeholder - Implement polling mechanism */ + +return 0 ; +} +static struct blk_mq_ops nvme_tcp_ofld_mq_ops = { .queue_rq = nvme_tcp_ofld_queue_rq, + .commit_rqs = nvme_tcp_ofld_commit_rqs, + .complete = nvme_complete_rq, .init_request = nvme_tcp_ofld_init_request, -/* -* All additional ops will be also implemented and registered similar to -* tcp.c -*/ + .exit_request = nvme_tcp_ofld_exit_request, + .init_hctx = nvme_tcp_ofld_init_hctx, + .map_queues = nvme_tcp_ofld_map_queues, + .poll = nvme_tcp_ofld_poll, };static struct blk_mq_ops nvme_tcp_ofld_admin_mq_ops = { .queue_rq = nvme_tcp_ofld_queue_rq, + .complete = nvme_complete_rq, .init_request = nvme_tcp_ofld_init_request, -/* -* All additional ops will be also implemented and registered similar to -* tcp.c -*/ + .exit_request = nvme_tcp_ofld_exit_request, + .init_hctx = nvme_tcp_ofld_init_admin_hctx, };static const struct nvme_ctrl_ops nvme_tcp_ofld_ctrl_ops = {drivers/nvme/host/tcp-offload.h +0
-1@@ -105,7 +105,6 @@ struct nvme_tcp_ofld_ctrl {* Each entry in the array indicates the number of queues of * corresponding type. */ -u32 queue_type_mapping[HCTX_MAX_TYPES ];u32 io_queues[HCTX_MAX_TYPES ];/* Connectivity params */ drivers/nvme/host/tcp-offload.h struct nvme_tcp_ofld_ops { · line 207
Quoted 4 lines
drivers/nvme/host/tcp-offload.h +1
-0@@ -205,3 +204,4 @@ struct nvme_tcp_ofld_ops {int nvme_tcp_ofld_register_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_unregister_dev (struct nvme_tcp_ofld_dev *dev);void nvme_tcp_ofld_error_recovery (struct nvme_ctrl *nctrl); +inline size_t nvme_tcp_ofld_inline_data_size (struct nvme_tcp_ofld_queue *queue);Cheers,
Hannes
--
Dr. Hannes Reinecke Kernel Storage Architect
[email protected] +49 911 74053 688
SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Felix Imendörffer
RFC PATCH v4 14/27 nvme-tcp-offload: Add IO level implementation
In reply to Shai MalinFrom: Dean Balandin <[email protected]>
In this patch, we present the IO level functionality.
The nvme-tcp-offload shall work on the IO-level, meaning the nvme-tcp-offload ULP module shall pass the request to the nvme-tcp-offload vendor driver and shall expect for the request compilation.
No additional handling is needed in between, this design will reduce the CPU utilization as we will describe below.
The nvme-tcp-offload vendor driver shall register to nvme-tcp-offload ULP with the following IO-path ops:
- init_req
- send_req - in order to pass the request to the handling of the offload driver that shall pass it to the vendor specific device
- poll_queue
The vendor driver will manage the context from which the request will be executed and the request aggregations.
Once the IO completed, the nvme-tcp-offload vendor driver shall call command.done() that shall invoke the nvme-tcp-offload ULP layer for completing the request.
This patch also contains initial definition of nvme_tcp_ofld_queue_rq().
--- drivers/nvme/host/tcp-offload.c | 95 ++++++++++++++++++++++++++++++--- 1 file changed, 87 insertions(+), 8 deletions(-)
drivers/nvme/host/tcp-offload.c +87 -8
@@ -127,7 +127,10 @@ void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req, union nvme_result *result, __le16 status) { -/* Placeholder - complete request with/without error */ +struct request *rq =blk_mq_rq_from_pdu (req); + +if (!nvme_try_complete_req (rq,cpu_to_le16 (status <<1 ), *result)) +nvme_complete_rq (rq); } struct nvme_tcp_ofld_dev *
@@ -686,6 +689,34 @@ static void nvme_tcp_ofld_free_ctrl(struct nvme_ctrl *nctrl)kfree (ctrl); } +static void nvme_tcp_ofld_set_sg_null (struct nvme_command *c) +{ +struct nvme_sgl_desc *sg = &c->common.dptr.sgl; + + sg->addr =0 ; + sg->length =0 ; + sg->type = (NVME_TRANSPORT_SGL_DATA_DESC <<4 ) |NVME_SGL_FMT_TRANSPORT_A ; +} + +inline void nvme_tcp_ofld_set_sg_inline (struct nvme_tcp_ofld_queue *queue, +struct nvme_command *c,u32 data_len) +{ +struct nvme_sgl_desc *sg = &c->common.dptr.sgl; + + sg->addr =cpu_to_le64 (queue->ctrl->nctrl.icdoff); + sg->length =cpu_to_le32 (data_len); + sg->type = (NVME_SGL_FMT_DATA_DESC <<4 ) |NVME_SGL_FMT_OFFSET ; +} + +void nvme_tcp_ofld_map_data (struct nvme_command *c,u32 data_len) +{ +struct nvme_sgl_desc *sg = &c->common.dptr.sgl; + + sg->addr =0 ; + sg->length =cpu_to_le32 (data_len); + sg->type = (NVME_TRANSPORT_SGL_DATA_DESC <<4 ) |NVME_SGL_FMT_TRANSPORT_A ; +} +static void nvme_tcp_ofld_submit_async_event (struct nvme_ctrl *arg) {/* Placeholder - submit_async_event */
@@ -841,9 +872,11 @@ nvme_tcp_ofld_init_request(struct blk_mq_tag_set *set, {struct nvme_tcp_ofld_req *req =blk_mq_rq_to_pdu (rq);struct nvme_tcp_ofld_ctrl *ctrl = set->driver_data; +int qid; -/* Placeholder - init request */ - + qid = (set == &ctrl->tag_set) ? hctx_idx +1 :0 ; + req->queue = &ctrl->queues[qid]; +nvme_req (rq)->ctrl = &ctrl->nctrl; req->done = nvme_tcp_ofld_req_done; ctrl->dev->ops->init_req (req);
@@ -858,16 +891,60 @@ EXPORT_SYMBOL_GPL(nvme_tcp_ofld_inline_data_size);static void nvme_tcp_ofld_commit_rqs (struct blk_mq_hw_ctx *hctx) { -/* Call ops->commit_rqs */ +struct nvme_tcp_ofld_queue *queue = hctx->driver_data; +struct nvme_tcp_ofld_dev *dev = queue->dev; +struct nvme_tcp_ofld_ops *ops = dev->ops; + + ops->commit_rqs (queue); }static blk_status_t nvme_tcp_ofld_queue_rq (struct blk_mq_hw_ctx *hctx,const struct blk_mq_queue_data *bd) { -/* Call nvme_setup_cmd(...) */ +struct nvme_tcp_ofld_req *req =blk_mq_rq_to_pdu (bd->rq); +struct nvme_tcp_ofld_queue *queue = hctx->driver_data; +struct nvme_tcp_ofld_ctrl *ctrl = queue->ctrl; +struct nvme_ns *ns = hctx->queue->queuedata; +struct nvme_tcp_ofld_dev *dev = queue->dev; +struct nvme_tcp_ofld_ops *ops = dev->ops; +struct nvme_command *nvme_cmd; +struct request *rq; +bool queue_ready; +u32 data_len; +int rc; + + queue_ready =test_bit (NVME_TCP_OFLD_Q_LIVE , &queue->flags); + + req->rq = bd->rq; + req->async = false; + rq = req->rq; + +if (!nvmf_check_ready (&ctrl->nctrl, req->rq, queue_ready)) +return nvmf_fail_nonready_command (&ctrl->nctrl, req->rq); + + rc =nvme_setup_cmd (ns, req->rq, &req->nvme_cmd); +if (unlikely (rc)) +return rc; -/* Call ops->send_req(...) */ +blk_mq_start_request (req->rq); + req->last = bd->last; + + nvme_cmd = &req->nvme_cmd; + nvme_cmd->common.flags |=NVME_CMD_SGL_METABUF ; + + data_len =blk_rq_nr_phys_segments (rq) ?blk_rq_payload_bytes (rq) :0 ; +if (!data_len) +nvme_tcp_ofld_set_sg_null (&req->nvme_cmd); +else if ((rq_data_dir (rq) ==WRITE ) && + data_len <=nvme_tcp_ofld_inline_data_size (queue)) +nvme_tcp_ofld_set_sg_inline (queue, nvme_cmd, data_len); +else +nvme_tcp_ofld_map_data (nvme_cmd, data_len); + + rc = ops->send_req (req); +if (unlikely (rc)) +return rc;return BLK_STS_OK ; }
@@ -940,9 +1017,11 @@ static int nvme_tcp_ofld_map_queues(struct blk_mq_tag_set *set)static int nvme_tcp_ofld_poll (struct blk_mq_hw_ctx *hctx) { -/* Placeholder - Implement polling mechanism */ +struct nvme_tcp_ofld_queue *queue = hctx->driver_data; +struct nvme_tcp_ofld_dev *dev = queue->dev; +struct nvme_tcp_ofld_ops *ops = dev->ops; -return 0 ; +return ops->poll_queue (queue); }static struct blk_mq_ops nvme_tcp_ofld_mq_ops = {
Signature · 1 line
2.22.0
kernel test robot
build botRe: [RFC PATCH v4 14/27] nvme-tcp-offload: Add IO level implementation
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]
Hi Shai,
[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on ipvs/master]
[also build test WARNING on hch-configfs/for-next linus/master v5.12 next-20210429] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 base: https://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git master config: x86_64-randconfig-a011-20210429 (attached as .config) compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 9131a078901b00e68248a27a4f8c4b11bb1db1ae)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# https://github.com/0day-ci/linux/commit/8f96123c694f82006e0946973a21196ec384d008
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 git checkout 8f96123c694f82006e0946973a21196ec384d008
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
drivers/nvme/host/tcp-offload.c:107:5: warning: no previous prototype for function 'nvme_tcp_ofld_report_queue_err' [-Wmissing-prototypes] int nvme_tcp_ofld_report_queue_err(struct nvme_tcp_ofld_queue *queue)
^
drivers/nvme/host/tcp-offload.c:107:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
int nvme_tcp_ofld_report_queue_err(struct nvme_tcp_ofld_queue *queue)
^
static
drivers/nvme/host/tcp-offload.c:126:6: warning: no previous prototype for function 'nvme_tcp_ofld_req_done' [-Wmissing-prototypes]
void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,
^
drivers/nvme/host/tcp-offload.c:126:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,
^
static
drivers/nvme/host/tcp-offload.c:137:1: warning: no previous prototype for function 'nvme_tcp_ofld_lookup_dev' [-Wmissing-prototypes]
nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)
^
drivers/nvme/host/tcp-offload.c:136:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
struct nvme_tcp_ofld_dev *
^
static
>> drivers/nvme/host/tcp-offload.c:711:6: warning: no previous prototype for function 'nvme_tcp_ofld_map_data' [-Wmissing-prototypes]
void nvme_tcp_ofld_map_data(struct nvme_command *c, u32 data_len)
^
drivers/nvme/host/tcp-offload.c:711:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
void nvme_tcp_ofld_map_data(struct nvme_command *c, u32 data_len)
^
static
drivers/nvme/host/tcp-offload.c:25:19: warning: unused function 'nvme_tcp_ofld_qid' [-Wunused-function]
static inline int nvme_tcp_ofld_qid(struct nvme_tcp_ofld_queue *queue)
^5 warnings generated.
vim +/nvme_tcp_ofld_map_data +711 drivers/nvme/host/tcp-offload.c
710
> 711 void nvme_tcp_ofld_map_data(struct nvme_command *c, u32 data_len)
712 {
713 struct nvme_sgl_desc *sg = &c->common.dptr.sgl;
714
715 sg->addr = 0;
716 sg->length = cpu_to_le32(data_len);
717 sg->type = (NVME_TRANSPORT_SGL_DATA_DESC << 4) | NVME_SGL_FMT_TRANSPORT_A;
718 }
719
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
kernel test robot
build botRe: [RFC PATCH v4 14/27] nvme-tcp-offload: Add IO level implementation
In reply to Shai Malin[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch]
Hi Shai,
[FYI, it's a private test report for your RFC patch.]
[auto build test WARNING on ipvs/master]
[also build test WARNING on hch-configfs/for-next linus/master v5.12 next-20210430] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 base: https://git.kernel.org/pub/scm/linux/kernel/git/horms/ipvs.git master config: alpha-randconfig-r014-20210429 (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/8f96123c694f82006e0946973a21196ec384d008
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Shai-Malin/NVMeTCP-Offload-ULP-and-QEDN-Device-Driver/20210430-032713 git checkout 8f96123c694f82006e0946973a21196ec384d008
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross W=1 ARCH=alpha
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
drivers/nvme/host/tcp-offload.c:107:5: warning: no previous prototype for 'nvme_tcp_ofld_report_queue_err' [-Wmissing-prototypes]
107 | int nvme_tcp_ofld_report_queue_err(struct nvme_tcp_ofld_queue *queue)
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/nvme/host/tcp-offload.c:126:6: warning: no previous prototype for 'nvme_tcp_ofld_req_done' [-Wmissing-prototypes]
126 | void nvme_tcp_ofld_req_done(struct nvme_tcp_ofld_req *req,
| ^~~~~~~~~~~~~~~~~~~~~~
drivers/nvme/host/tcp-offload.c:137:1: warning: no previous prototype for 'nvme_tcp_ofld_lookup_dev' [-Wmissing-prototypes]
137 | nvme_tcp_ofld_lookup_dev(struct nvme_tcp_ofld_ctrl *ctrl)
| ^~~~~~~~~~~~~~~~~~~~~~~~
>> drivers/nvme/host/tcp-offload.c:711:6: warning: no previous prototype for 'nvme_tcp_ofld_map_data' [-Wmissing-prototypes]
711 | void nvme_tcp_ofld_map_data(struct nvme_command *c, u32 data_len)
| ^~~~~~~~~~~~~~~~~~~~~~
vim +/nvme_tcp_ofld_map_data +711 drivers/nvme/host/tcp-offload.c
710
> 711 void nvme_tcp_ofld_map_data(struct nvme_command *c, u32 data_len)
712 {
713 struct nvme_sgl_desc *sg = &c->common.dptr.sgl;
714
715 sg->addr = 0;
716 sg->length = cpu_to_le32(data_len);
717 sg->type = (NVME_TRANSPORT_SGL_DATA_DESC << 4) | NVME_SGL_FMT_TRANSPORT_A;
718 }
719
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]