Linux-RDMA Archive on lore.kernel.org
 help / color / Atom feed
From: Parav Pandit <parav@mellanox.com>
To: Jeff Kirsher <jeffrey.t.kirsher@intel.com>,
	"davem@davemloft.net" <davem@davemloft.net>,
	"gregkh@linuxfoundation.org" <gregkh@linuxfoundation.org>
Cc: Mustafa Ismail <mustafa.ismail@intel.com>,
	"netdev@vger.kernel.org" <netdev@vger.kernel.org>,
	"linux-rdma@vger.kernel.org" <linux-rdma@vger.kernel.org>,
	"nhorman@redhat.com" <nhorman@redhat.com>,
	"sassmann@redhat.com" <sassmann@redhat.com>,
	"jgg@ziepe.ca" <jgg@ziepe.ca>,
	Shiraz Saleem <shiraz.saleem@intel.com>
Subject: Re: [RFC PATCH v4 10/25] RDMA/irdma: Add driver framework definitions
Date: Fri, 14 Feb 2020 22:13:25 +0000
Message-ID: <6f01d517-3196-1183-112e-8151b821bd72@mellanox.com> (raw)
In-Reply-To: <20200212191424.1715577-11-jeffrey.t.kirsher@intel.com>

On 2/12/2020 1:14 PM, Jeff Kirsher wrote:
> From: Mustafa Ismail <mustafa.ismail@intel.com>
> 
> Register irdma as a platform driver capable of supporting platform
> devices from multi-generation RDMA capable Intel HW. Establish the
> interface with all supported netdev peer devices and initialize HW.
> 
> Signed-off-by: Mustafa Ismail <mustafa.ismail@intel.com>
> Signed-off-by: Shiraz Saleem <shiraz.saleem@intel.com>
> Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
> ---
>  drivers/infiniband/hw/irdma/i40iw_if.c | 228 ++++++++++
>  drivers/infiniband/hw/irdma/irdma_if.c | 424 ++++++++++++++++++
>  drivers/infiniband/hw/irdma/main.c     | 572 ++++++++++++++++++++++++
>  drivers/infiniband/hw/irdma/main.h     | 595 +++++++++++++++++++++++++
>  4 files changed, 1819 insertions(+)
>  create mode 100644 drivers/infiniband/hw/irdma/i40iw_if.c
>  create mode 100644 drivers/infiniband/hw/irdma/irdma_if.c
>  create mode 100644 drivers/infiniband/hw/irdma/main.c
>  create mode 100644 drivers/infiniband/hw/irdma/main.h
> 
> diff --git a/drivers/infiniband/hw/irdma/i40iw_if.c b/drivers/infiniband/hw/irdma/i40iw_if.c
> new file mode 100644
> index 000000000000..5e69b16a2658
> --- /dev/null
> +++ b/drivers/infiniband/hw/irdma/i40iw_if.c
> @@ -0,0 +1,228 @@
> +// SPDX-License-Identifier: GPL-2.0 or Linux-OpenIB
> +/* Copyright (c) 2015 - 2019 Intel Corporation */
> +#include <linux/module.h>
> +#include <linux/moduleparam.h>
> +#include <linux/netdevice.h>
> +#include <linux/etherdevice.h>
> +#include <linux/net/intel/i40e_client.h>
> +#include <net/addrconf.h>
> +#include "main.h"
> +#include "i40iw_hw.h"
> +
> +/**
> + * i40iw_request_reset - Request a reset
> + * @rf: RDMA PCI function
> + *
> + */
> +static void i40iw_request_reset(struct irdma_pci_f *rf)
> +{
> +	struct i40e_info *ldev = rf->ldev.if_ldev;
> +
> +	ldev->ops->request_reset(ldev, rf->ldev.if_client, 1);
> +}
> +
> +/**
> + * i40iw_open - client interface operation open for iwarp/uda device
> + * @ldev: LAN device information
> + * @client: iwarp client information, provided during registration
> + *
> + * Called by the LAN driver during the processing of client
> + * register Create device resources, set up queues, pble and hmc
> + * objects and register the device with the ib verbs interface
> + * Return 0 if successful, otherwise return error
> + */
> +static int i40iw_open(struct i40e_info *ldev, struct i40e_client *client)
> +{
> +	struct irdma_device *iwdev = NULL;
> +	struct irdma_handler *hdl = NULL;
> +	struct irdma_priv_ldev *pldev;
> +	struct irdma_sc_dev *dev;
> +	struct irdma_pci_f *rf;
> +	struct irdma_l2params l2params = {};
> +	int err = -EIO;
> +	int i;
> +	u16 qset;
> +	u16 last_qset = IRDMA_NO_QSET;
> +
> +	hdl = irdma_find_handler(ldev->pcidev);
> +	if (hdl)
> +		return 0;
> +
> +	hdl = kzalloc(sizeof(*hdl), GFP_KERNEL);
> +	if (!hdl)
> +		return -ENOMEM;
> +
> +	rf = &hdl->rf;
> +	rf->hdl = hdl;
> +	dev = &rf->sc_dev;
> +	dev->back_dev = rf;
> +	rf->rdma_ver = IRDMA_GEN_1;
> +	hdl->vdev = ldev->vdev;
> +	irdma_init_rf_config_params(rf);
> +	rf->gen_ops.init_hw = i40iw_init_hw;
> +	rf->gen_ops.request_reset = i40iw_request_reset;
> +	rf->hw.hw_addr = ldev->hw_addr;
> +	rf->pdev = ldev->pcidev;
> +	rf->netdev = ldev->netdev;
> +	dev->pci_rev = rf->pdev->revision;
> +
> +	pldev = &rf->ldev;
> +	hdl->ldev = pldev;
> +	pldev->if_client = client;
> +	pldev->if_ldev = ldev;
> +	pldev->fn_num = ldev->fid;
> +	pldev->ftype = ldev->ftype;
> +	pldev->pf_vsi_num = 0;
> +	pldev->msix_count = ldev->msix_count;
> +	pldev->msix_entries = ldev->msix_entries;
> +
> +	if (irdma_ctrl_init_hw(rf)) {
> +		err = -EIO;
> +		goto err_ctrl_init;
> +	}
> +
> +	iwdev = ib_alloc_device(irdma_device, ibdev);
> +	if (!iwdev) {
> +		err = -ENOMEM;
> +		goto err_ib_alloc;
> +	}
> +
> +	iwdev->rf = rf;
> +	iwdev->hdl = hdl;
> +	iwdev->ldev = &rf->ldev;
> +	iwdev->init_state = INITIAL_STATE;
> +	iwdev->rcv_wnd = IRDMA_CM_DEFAULT_RCV_WND_SCALED;
> +	iwdev->rcv_wscale = IRDMA_CM_DEFAULT_RCV_WND_SCALE;
> +	iwdev->netdev = ldev->netdev;
> +	iwdev->create_ilq = true;
> +	iwdev->vsi_num = 0;
> +
> +	l2params.mtu =
> +		(ldev->params.mtu) ? ldev->params.mtu : IRDMA_DEFAULT_MTU;
> +	for (i = 0; i < I40E_CLIENT_MAX_USER_PRIORITY; i++) {
> +		qset = ldev->params.qos.prio_qos[i].qs_handle;
> +		l2params.up2tc[i] = ldev->params.qos.prio_qos[i].tc;
> +		l2params.qs_handle_list[i] = qset;
> +		if (last_qset == IRDMA_NO_QSET)
> +			last_qset = qset;
> +		else if ((qset != last_qset) && (qset != IRDMA_NO_QSET))
> +			iwdev->dcb = true;
> +	}
> +
> +	if (irdma_rt_init_hw(rf, iwdev, &l2params)) {
> +		err = -EIO;
> +		goto err_rt_init;
> +	}
> +
> +	err = irdma_ib_register_device(iwdev);
> +	if (err)
> +		goto err_ibreg;
> +
> +	irdma_add_handler(hdl);
> +	dev_dbg(rfdev_to_dev(dev), "INIT: Gen1 VSI open success ldev=%p\n",
> +		ldev);
> +
> +	return 0;
> +
> +err_ibreg:
> +	irdma_rt_deinit_hw(iwdev);
> +err_rt_init:
> +	ib_dealloc_device(&iwdev->ibdev);
> +err_ib_alloc:
> +	irdma_ctrl_deinit_hw(rf);
> +err_ctrl_init:
> +	kfree(hdl);
> +
> +	return err;
> +}
> +
> +/**
> + * i40iw_l2param_change - handle mss change
> + * @ldev: lan device information
> + * @client: client for parameter change
> + * @params: new parameters from L2
> + */
> +static void i40iw_l2param_change(struct i40e_info *ldev,
> +				 struct i40e_client *client,
> +				 struct i40e_params *params)
> +{
> +	struct irdma_l2params l2params = {};
> +	struct irdma_device *iwdev;
> +
> +	iwdev = irdma_get_device(ldev->netdev);
> +	if (!iwdev)
> +		return;
> +
> +	if (iwdev->vsi.mtu != params->mtu) {
> +		l2params.mtu_changed = true;
> +		l2params.mtu = params->mtu;
> +	}
> +	irdma_change_l2params(&iwdev->vsi, &l2params);
> +	irdma_put_device(iwdev);
> +}
> +
> +/**
> + * i40iw_close - client interface operation close for iwarp/uda device
> + * @ldev: lan device information
> + * @client: client to close
> + * @reset: flag to indicate close on reset
> + *
> + * Called by the lan driver during the processing of client unregister
> + * Destroy and clean up the driver resources
> + */
> +static void i40iw_close(struct i40e_info *ldev, struct i40e_client *client,
> +			bool reset)
> +{
> +	struct irdma_handler *hdl;
> +	struct irdma_pci_f *rf;
> +	struct irdma_device *iwdev;
> +
> +	hdl = irdma_find_handler(ldev->pcidev);
> +	if (!hdl)
> +		return;
> +
> +	rf = &hdl->rf;
> +	iwdev = list_first_entry_or_null(&rf->vsi_dev_list, struct irdma_device,
> +					 list);
> +	if (reset)
> +		iwdev->reset = true;
> +
> +	irdma_ib_unregister_device(iwdev);
> +	irdma_deinit_rf(rf);
> +	pr_debug("INIT: Gen1 VSI close complete ldev=%p\n", ldev);
> +}
> +
> +/* client interface functions */
> +static const struct i40e_client_ops i40e_ops = {
> +	.open = i40iw_open,
> +	.close = i40iw_close,
> +	.l2_param_change = i40iw_l2param_change
> +};
> +
> +static struct i40e_client i40iw_client = {
> +	.name = "irdma",
> +	.ops = &i40e_ops,
> +	.type = I40E_CLIENT_IWARP,
> +};
> +
> +int i40iw_probe(struct virtbus_device *vdev)
> +{
> +	struct i40e_virtbus_device *i40e_vdev =
> +			container_of(vdev, struct i40e_virtbus_device, vdev);
> +	struct i40e_info *ldev = i40e_vdev->ldev;
> +
> +	ldev->client = &i40iw_client;
> +
> +	return ldev->ops->client_device_register(ldev);
> +}
> +
> +int i40iw_remove(struct virtbus_device *vdev)
> +{
> +	struct i40e_virtbus_device *i40e_vdev =
> +			container_of(vdev, struct i40e_virtbus_device, vdev);
> +	struct i40e_info *ldev = i40e_vdev->ldev;
> +
> +	ldev->ops->client_device_unregister(ldev);
> +
> +	return 0;
> +}
> diff --git a/drivers/infiniband/hw/irdma/irdma_if.c b/drivers/infiniband/hw/irdma/irdma_if.c
> new file mode 100644
> index 000000000000..b538801ca0b9
> --- /dev/null
> +++ b/drivers/infiniband/hw/irdma/irdma_if.c
> @@ -0,0 +1,424 @@
> +// SPDX-License-Identifier: GPL-2.0 or Linux-OpenIB
> +/* Copyright (c) 2019 Intel Corporation */
> +#include <linux/module.h>
> +#include <linux/moduleparam.h>
> +#include <linux/net/intel/iidc.h>
> +#include "main.h"
> +#include "ws.h"
> +#include "icrdma_hw.h"
> +
> +/**
> + * irdma_lan_register_qset - Register qset with LAN driver
> + * @vsi: vsi structure
> + * @tc_node: Traffic class node
> + */
> +static enum irdma_status_code irdma_lan_register_qset(struct irdma_sc_vsi *vsi,
> +						      struct irdma_ws_node *tc_node)
> +{
> +	struct irdma_device *iwdev = vsi->back_vsi;
> +	struct iidc_peer_dev *ldev = iwdev->ldev->if_ldev;
> +	struct iidc_res rdma_qset_res = {};
> +	int ret;
> +
> +	rdma_qset_res.cnt_req = 1;
> +	rdma_qset_res.res_type = IIDC_RDMA_QSETS_TXSCHED;
> +	rdma_qset_res.res[0].res.qsets.qs_handle = tc_node->qs_handle;
> +	rdma_qset_res.res[0].res.qsets.tc = tc_node->traffic_class;
> +	rdma_qset_res.res[0].res.qsets.vsi_id = vsi->vsi_idx;
> +	ret = ldev->ops->alloc_res(ldev, &rdma_qset_res, 0);
> +	if (ret) {
> +		dev_dbg(rfdev_to_dev(vsi->dev),
> +			"WS: LAN alloc_res for rdma qset failed.\n");
> +		return IRDMA_ERR_NO_MEMORY;
> +	}
> +
> +	tc_node->l2_sched_node_id = rdma_qset_res.res[0].res.qsets.teid;
> +	vsi->qos[tc_node->user_pri].l2_sched_node_id =
> +		rdma_qset_res.res[0].res.qsets.teid;
> +
> +	return 0;
> +}
> +
> +/**
> + * irdma_lan_unregister_qset - Unregister qset with LAN driver
> + * @vsi: vsi structure
> + * @tc_node: Traffic class node
> + */
> +static void irdma_lan_unregister_qset(struct irdma_sc_vsi *vsi,
> +				      struct irdma_ws_node *tc_node)
> +{
> +	struct irdma_device *iwdev = vsi->back_vsi;
> +	struct iidc_peer_dev *ldev = iwdev->ldev->if_ldev;
> +	struct iidc_res rdma_qset_res = {};
> +
> +	rdma_qset_res.res_allocated = 1;
> +	rdma_qset_res.res_type = IIDC_RDMA_QSETS_TXSCHED;
> +	rdma_qset_res.res[0].res.qsets.vsi_id = vsi->vsi_idx;
> +	rdma_qset_res.res[0].res.qsets.teid = tc_node->l2_sched_node_id;
> +	rdma_qset_res.res[0].res.qsets.qs_handle = tc_node->qs_handle;
> +
> +	if (ldev->ops->free_res(ldev, &rdma_qset_res))
> +		dev_dbg(rfdev_to_dev(vsi->dev),
> +			"WS: LAN free_res for rdma qset failed.\n");
> +}
> +
> +/**
> + * irdma_prep_tc_change - Prepare for TC changes
> + * @ldev: Peer device structure
> + */
> +static void irdma_prep_tc_change(struct iidc_peer_dev *ldev)
> +{
> +	struct irdma_device *iwdev;
> +
> +	iwdev = irdma_get_device(ldev->netdev);
> +	if (!iwdev)
> +		return;
> +
> +	if (iwdev->vsi.tc_change_pending)
> +		goto done;
> +
> +	iwdev->vsi.tc_change_pending = true;
> +	irdma_sc_suspend_resume_qps(&iwdev->vsi, IRDMA_OP_SUSPEND);
> +
> +	/* Wait for all qp's to suspend */
> +	wait_event_timeout(iwdev->suspend_wq,
> +			   !atomic_read(&iwdev->vsi.qp_suspend_reqs),
> +			   IRDMA_EVENT_TIMEOUT);
> +	irdma_ws_reset(&iwdev->vsi);
> +done:
> +	irdma_put_device(iwdev);
> +}
> +
> +static void irdma_log_invalid_mtu(u16 mtu, struct irdma_sc_dev *dev)
> +{
> +	if (mtu < IRDMA_MIN_MTU_IPV4)
> +		dev_warn(rfdev_to_dev(dev),
> +			 "MTU setting [%d] too low for RDMA traffic. Minimum MTU is 576 for IPv4\n",
> +			 mtu);
> +	else if (mtu < IRDMA_MIN_MTU_IPV6)
> +		dev_warn(rfdev_to_dev(dev),
> +			 "MTU setting [%d] too low for RDMA traffic. Minimum MTU is 1280 for IPv6\\n",
> +			 mtu);
> +}
> +
> +/**
> + * irdma_event_handler - Called by LAN driver to notify events
> + * @ldev: Peer device structure
> + * @event: event from LAN driver
> + */
> +static void irdma_event_handler(struct iidc_peer_dev *ldev,
> +				struct iidc_event *event)
> +{
> +	struct irdma_l2params l2params = {};
> +	struct irdma_device *iwdev;
> +	int i;
> +
> +	iwdev = irdma_get_device(ldev->netdev);
> +	if (!iwdev)
> +		return;
> +
> +	if (*event->type & BIT(IIDC_EVENT_LINK_CHANGE)) {
> +		dev_dbg(rfdev_to_dev(&iwdev->rf->sc_dev),
> +			"CLNT: LINK_CHANGE event\n");
> +	} else if (*event->type & BIT(IIDC_EVENT_MTU_CHANGE)) {
> +		dev_dbg(rfdev_to_dev(&iwdev->rf->sc_dev),
> +			"CLNT: new MTU = %d\n", event->info.mtu);
> +		if (iwdev->vsi.mtu != event->info.mtu) {
> +			l2params.mtu = event->info.mtu;
> +			l2params.mtu_changed = true;
> +			irdma_log_invalid_mtu(l2params.mtu, &iwdev->rf->sc_dev);
> +			irdma_change_l2params(&iwdev->vsi, &l2params);
> +		}
> +	} else if (*event->type & BIT(IIDC_EVENT_TC_CHANGE)) {
> +		if (!iwdev->vsi.tc_change_pending)
> +			goto done;
> +
> +		l2params.tc_changed = true;
> +		dev_dbg(rfdev_to_dev(&iwdev->rf->sc_dev), "CLNT: TC Change\n");
> +		iwdev->dcb = event->info.port_qos.num_tc > 1 ? true : false;
> +
> +		for (i = 0; i < IIDC_MAX_USER_PRIORITY; ++i)
> +			l2params.up2tc[i] = event->info.port_qos.up2tc[i];
> +		irdma_change_l2params(&iwdev->vsi, &l2params);
> +	} else if (*event->type & BIT(IIDC_EVENT_API_CHANGE)) {
> +		dev_dbg(rfdev_to_dev(&iwdev->rf->sc_dev),
> +			"CLNT: API_CHANGE\n");
> +	}
> +
> +done:
> +	irdma_put_device(iwdev);
> +}
> +
> +/**
> + * irdma_open - client interface operation open for RDMA device
> + * @ldev: LAN device information
> + *
> + * Called by the LAN driver during the processing of client
> + * register.
> + */
> +static int irdma_open(struct iidc_peer_dev *ldev)
> +{
> +	struct irdma_handler *hdl;
> +	struct irdma_device *iwdev;
> +	struct irdma_sc_dev *dev;
> +	struct iidc_event events = {};
> +	struct irdma_pci_f *rf;
> +	struct irdma_priv_ldev *pldev;
> +	struct irdma_l2params l2params = {};
> +	int i, ret;
> +
> +	hdl = irdma_find_handler(ldev->pdev);
> +	if (!hdl)
> +		return -ENODEV;
> +
> +	rf = &hdl->rf;
> +	if (rf->init_state != CEQ0_CREATED)
> +		return -EINVAL;
> +
> +	iwdev = ib_alloc_device(irdma_device, ibdev);
> +	if (!iwdev)
> +		return -ENOMEM;
> +
> +	pldev = &rf->ldev;
> +	pldev->pf_vsi_num = ldev->pf_vsi_num;
> +	dev = &hdl->rf.sc_dev;
> +
> +	iwdev->hdl = hdl;
> +	iwdev->rf = rf;
> +	iwdev->ldev = &rf->ldev;
> +	iwdev->push_mode = 0;
> +	iwdev->rcv_wnd = IRDMA_CM_DEFAULT_RCV_WND_SCALED;
> +	iwdev->rcv_wscale = IRDMA_CM_DEFAULT_RCV_WND_SCALE;
> +	iwdev->netdev = ldev->netdev;
> +	iwdev->create_ilq = true;
> +	if (rf->protocol_used == IRDMA_ROCE_PROTOCOL_ONLY) {
> +		iwdev->roce_mode = true;
> +		iwdev->create_ilq = false;
> +	}
> +	l2params.mtu = ldev->netdev->mtu;
> +	l2params.num_tc = ldev->initial_qos_info.num_tc;
> +	l2params.num_apps = ldev->initial_qos_info.num_apps;
> +	l2params.vsi_prio_type = ldev->initial_qos_info.vsi_priority_type;
> +	l2params.vsi_rel_bw = ldev->initial_qos_info.vsi_relative_bw;
> +	for (i = 0; i < l2params.num_tc; i++) {
> +		l2params.tc_info[i].egress_virt_up =
> +			ldev->initial_qos_info.tc_info[i].egress_virt_up;
> +		l2params.tc_info[i].ingress_virt_up =
> +			ldev->initial_qos_info.tc_info[i].ingress_virt_up;
> +		l2params.tc_info[i].prio_type =
> +			ldev->initial_qos_info.tc_info[i].prio_type;
> +		l2params.tc_info[i].rel_bw =
> +			ldev->initial_qos_info.tc_info[i].rel_bw;
> +		l2params.tc_info[i].tc_ctx =
> +			ldev->initial_qos_info.tc_info[i].tc_ctx;
> +	}
> +	for (i = 0; i < IIDC_MAX_USER_PRIORITY; i++)
> +		l2params.up2tc[i] = ldev->initial_qos_info.up2tc[i];
> +
> +	iwdev->vsi_num = ldev->pf_vsi_num;
> +	ldev->ops->update_vsi_filter(ldev, IIDC_RDMA_FILTER_BOTH, true);
> +
> +	if (irdma_rt_init_hw(rf, iwdev, &l2params)) {
> +		ib_dealloc_device(&iwdev->ibdev);
> +		return -EIO;
> +	}
> +
> +	ret = irdma_ib_register_device(iwdev);
> +	if (ret) {
> +		irdma_rt_deinit_hw(iwdev);
> +		ib_dealloc_device(&iwdev->ibdev);
> +		return ret;
> +	}
> +
> +	events.reporter = ldev;
> +	set_bit(IIDC_EVENT_LINK_CHANGE, events.type);
> +	set_bit(IIDC_EVENT_MTU_CHANGE, events.type);
> +	set_bit(IIDC_EVENT_TC_CHANGE, events.type);
> +	set_bit(IIDC_EVENT_API_CHANGE, events.type);
> +
> +	ldev->ops->reg_for_notification(ldev, &events);
> +	dev_dbg(rfdev_to_dev(dev),
> +		"INIT: Gen2 VSI[%d] open success ldev=%p\n", ldev->pf_vsi_num,
> +		ldev);
> +
> +	return 0;
> +}
> +
> +/**
> + * irdma_close - client interface operation close for iwarp/uda device
> + * @ldev: LAN device information
> + * @reason: reason for closing
> + *
> + * Called by the LAN driver during the processing of client
> + * unregister Destroy and clean up the driver resources
> + */
> +static void irdma_close(struct iidc_peer_dev *ldev,
> +			enum iidc_close_reason reason)
> +{
> +	struct irdma_handler *hdl;
> +	struct irdma_device *iwdev;
> +	struct irdma_pci_f *rf;
> +
> +	hdl = irdma_find_handler(ldev->pdev);
> +	if (!hdl)
> +		return;
> +
> +	rf = &hdl->rf;
> +	iwdev = list_first_entry_or_null(&rf->vsi_dev_list, struct irdma_device,
> +					 list);
> +	if (!iwdev)
> +		return;
> +
> +	if (reason == IIDC_REASON_GLOBR_REQ || reason == IIDC_REASON_CORER_REQ ||
> +	    reason == IIDC_REASON_PFR_REQ || rf->reset) {
> +		iwdev->reset = true;
> +		rf->reset = true;
> +	}
> +
> +	irdma_ib_unregister_device(iwdev);
> +	ldev->ops->update_vsi_filter(ldev, IIDC_RDMA_FILTER_BOTH, false);
> +	if (rf->reset)
> +		schedule_delayed_work(&rf->rst_work, rf->rst_to * HZ);
> +
> +	pr_debug("INIT: Gen2 VSI[%d] close complete ldev=%p\n",
> +		 ldev->pf_vsi_num, ldev);
> +}
> +
> +/**
> + * irdma_remove - GEN_2 device remove()
> + * @vdev: virtbus device
> + *
> + * Called on module unload.
> + */
> +int irdma_remove(struct virtbus_device *vdev)
> +{
> +	struct iidc_virtbus_object *vo =
> +			container_of(vdev, struct iidc_virtbus_object, vdev);
> +	struct iidc_peer_dev *ldev = vo->peer_dev;
> +	struct irdma_handler *hdl;
> +
> +	hdl = irdma_find_handler(ldev->pdev);
> +	if (!hdl)
> +		return 0;
> +
> +	cancel_delayed_work_sync(&hdl->rf.rst_work);
> +	ldev->ops->peer_unregister(ldev);
> +
> +	irdma_deinit_rf(&hdl->rf);
> +	pr_debug("INIT: Gen2 device remove success ldev=%p\n", ldev);
> +
> +	return 0;
> +}
> +
> +static const struct iidc_peer_ops irdma_peer_ops = {
> +	.close = irdma_close,
> +	.event_handler = irdma_event_handler,
> +	.open = irdma_open,
> +	.prep_tc_change = irdma_prep_tc_change,
> +};
> +
> +static struct iidc_peer_drv irdma_peer_drv = {
> +	.driver_id = IIDC_PEER_RDMA_DRIVER,
> +	.name = KBUILD_MODNAME,
> +};
> +
> +/**
> + * icrdma_request_reset - Request a reset
> + * @rf: RDMA PCI function
> + */
> +static void icrdma_request_reset(struct irdma_pci_f *rf)
> +{
> +	struct iidc_peer_dev *ldev = rf->ldev.if_ldev;
> +
> +	dev_warn(rfdev_to_dev(&rf->sc_dev), "Requesting a a reset\n");
> +	ldev->ops->request_reset(ldev, IIDC_PEER_PFR);
> +}
> +
> +/**
> + * irdma_probe - GEN_2 device probe()
> + * @vdev: virtbus device
> + *
> + * Create device resources, set up queues, pble and hmc objects.
> + * Return 0 if successful, otherwise return error
> + */
> +int irdma_probe(struct virtbus_device *vdev)
> +{
> +	struct iidc_virtbus_object *vo =
> +			container_of(vdev, struct iidc_virtbus_object, vdev);
> +	struct iidc_peer_dev *ldev = vo->peer_dev;
> +	struct irdma_handler *hdl;
> +	struct irdma_pci_f *rf;
> +	struct irdma_sc_dev *dev;
> +	struct irdma_priv_ldev *pldev;
> +	int err;
> +
> +	hdl = irdma_find_handler(ldev->pdev);
> +	if (hdl)
> +		return -EBUSY;
> +
> +	hdl = kzalloc(sizeof(*hdl), GFP_KERNEL);
> +	if (!hdl)
> +		return -ENOMEM;
> +
> +	rf = &hdl->rf;
> +	pldev = &rf->ldev;
> +	hdl->ldev = pldev;
> +	hdl->vdev = vdev;
> +	rf->hdl = hdl;
> +	dev = &rf->sc_dev;
> +	dev->back_dev = rf;
> +	rf->gen_ops.init_hw = icrdma_init_hw;
> +	rf->gen_ops.request_reset = icrdma_request_reset;
> +	rf->gen_ops.register_qset = irdma_lan_register_qset;
> +	rf->gen_ops.unregister_qset = irdma_lan_unregister_qset;
> +	pldev->if_ldev = ldev;
> +	rf->rdma_ver = IRDMA_GEN_2;
> +	irdma_init_rf_config_params(rf);
> +	INIT_DELAYED_WORK(&rf->rst_work, irdma_reset_task);
> +	dev->pci_rev = ldev->pdev->revision;
> +	rf->default_vsi.vsi_idx = ldev->pf_vsi_num;
> +	/* save information from ldev to priv_ldev*/
> +	pldev->fn_num = PCI_FUNC(ldev->pdev->devfn);
> +	rf->hw.hw_addr = ldev->hw_addr;
> +	rf->pdev = ldev->pdev;
> +	rf->netdev = ldev->netdev;
> +	pldev->ftype = ldev->ftype;
> +	pldev->msix_count = ldev->msix_count;
> +	pldev->msix_entries = ldev->msix_entries;
> +	irdma_add_handler(hdl);
> +	if (irdma_ctrl_init_hw(rf)) {
> +		err = -EIO;
> +		goto err_ctrl_init;
> +	}
> +	ldev->peer_ops = &irdma_peer_ops;
> +	ldev->peer_drv = &irdma_peer_drv;
> +	err = ldev->ops->peer_register(ldev);
> +	if (err)
> +		goto err_peer_reg;
> +
> +	dev_dbg(rfdev_to_dev(dev),
> +		"INIT: Gen2 device probe success ldev=%p\n", ldev);
> +
> +	return 0;
> +
> +err_peer_reg:
> +	irdma_ctrl_deinit_hw(rf);
> +err_ctrl_init:
> +	irdma_del_handler(rf->hdl);
> +	kfree(rf->hdl);
> +
> +	return err;
> +}
> +
> +/*
> + * irdma_lan_vsi_ready - check to see if lan reset done
> + * @vdev: virtbus device
> + */
> +bool irdma_lan_vsi_ready(struct virtbus_device *vdev)
> +{
> +	struct iidc_virtbus_object *vo =
> +			container_of(vdev, struct iidc_virtbus_object, vdev);
> +	struct iidc_peer_dev *ldev = vo->peer_dev;
> +
> +	return ldev->ops->is_vsi_ready(ldev) ? true : false;
> +}
> diff --git a/drivers/infiniband/hw/irdma/main.c b/drivers/infiniband/hw/irdma/main.c
> new file mode 100644
> index 000000000000..aa7f2b2f496b
> --- /dev/null
> +++ b/drivers/infiniband/hw/irdma/main.c
> @@ -0,0 +1,572 @@
> +// SPDX-License-Identifier: GPL-2.0 or Linux-OpenIB
> +/* Copyright (c) 2015 - 2019 Intel Corporation */
> +#include "main.h"
> +
> +bool irdma_upload_context;
> +
> +MODULE_ALIAS("i40iw");
> +MODULE_AUTHOR("Intel Corporation, <e1000-rdma@lists.sourceforge.net>");
> +MODULE_DESCRIPTION("Intel(R) Ethernet Protocol Driver for RDMA");
> +MODULE_LICENSE("Dual BSD/GPL");
> +
> +LIST_HEAD(irdma_handlers);
> +DEFINE_SPINLOCK(irdma_handler_lock);
> +
> +static struct notifier_block irdma_inetaddr_notifier = {
> +	.notifier_call = irdma_inetaddr_event
> +};
> +
> +static struct notifier_block irdma_inetaddr6_notifier = {
> +	.notifier_call = irdma_inet6addr_event
> +};
> +
> +static struct notifier_block irdma_net_notifier = {
> +	.notifier_call = irdma_net_event
> +};
> +
> +static struct notifier_block irdma_netdevice_notifier = {
> +	.notifier_call = irdma_netdevice_event
> +};
> +
> +/**
> + * set_protocol_used - set protocol_used against HW generation and roce_ena flag
> + * @rf: RDMA PCI function
> + * @roce_ena: RoCE enabled flag
> + */
> +static void set_protocol_used(struct irdma_pci_f *rf, bool roce_ena)
> +{
> +	switch (rf->rdma_ver) {
> +	case IRDMA_GEN_2:
> +		rf->protocol_used = roce_ena ? IRDMA_ROCE_PROTOCOL_ONLY :
> +					       IRDMA_IWARP_PROTOCOL_ONLY;
> +		break;
> +	case IRDMA_GEN_1:
> +		rf->protocol_used = IRDMA_IWARP_PROTOCOL_ONLY;
> +		break;
> +	}
> +}
> +
> +void irdma_init_rf_config_params(struct irdma_pci_f *rf)
> +{
> +	struct irdma_dl_priv *dl_priv;
> +
> +	rf->rsrc_profile = IRDMA_HMC_PROFILE_DEFAULT;
> +	dl_priv = dev_get_drvdata(&rf->hdl->vdev->dev);
> +	rf->limits_sel = dl_priv->limits_sel;
> +	set_protocol_used(rf, dl_priv->roce_ena);
> +	rf->rst_to = IRDMA_RST_TIMEOUT_HZ;
> +}
> +
> +/*
> + * irdma_deinit_rf - Clean up resources allocated for RF
> + * @rf: RDMA PCI function
> + */
> +void irdma_deinit_rf(struct irdma_pci_f *rf)
> +{
> +	irdma_ctrl_deinit_hw(rf);
> +	irdma_del_handler(rf->hdl);
> +	kfree(rf->hdl);
> +}
> +
> +/**
> + * irdma_find_ice_handler - find a handler given a client info
> + * @pdev: pointer to pci dev info
> + */
> +struct irdma_handler *irdma_find_handler(struct pci_dev *pdev)
> +{
> +	struct irdma_handler *hdl;
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&irdma_handler_lock, flags);
> +	list_for_each_entry (hdl, &irdma_handlers, list) {
> +		if (hdl->rf.pdev->devfn == pdev->devfn &&
> +		    hdl->rf.pdev->bus->number == pdev->bus->number) {
> +			spin_unlock_irqrestore(&irdma_handler_lock, flags);
> +			return hdl;
> +		}
> +	}
> +	spin_unlock_irqrestore(&irdma_handler_lock, flags);
> +
> +	return NULL;
> +}
> +
> +/**
> + * irdma_add_handler - add a handler to the list
> + * @hdl: handler to be added to the handler list
> + */
> +void irdma_add_handler(struct irdma_handler *hdl)
> +{
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&irdma_handler_lock, flags);
> +	list_add(&hdl->list, &irdma_handlers);
> +	spin_unlock_irqrestore(&irdma_handler_lock, flags);
> +}
> +
> +/**
> + * irdma_del_handler - delete a handler from the list
> + * @hdl: handler to be deleted from the handler list
> + */
> +void irdma_del_handler(struct irdma_handler *hdl)
> +{
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&irdma_handler_lock, flags);
> +	list_del(&hdl->list);
> +	spin_unlock_irqrestore(&irdma_handler_lock, flags);
> +}
> +
> +/**
> + * irdma_register_notifiers - register tcp ip notifiers
> + */
> +void irdma_register_notifiers(void)
> +{
> +	register_inetaddr_notifier(&irdma_inetaddr_notifier);
> +	register_inet6addr_notifier(&irdma_inetaddr6_notifier);
> +	register_netevent_notifier(&irdma_net_notifier);
> +	register_netdevice_notifier(&irdma_netdevice_notifier);
> +}
> +
> +void irdma_unregister_notifiers(void)
> +{
> +	unregister_netevent_notifier(&irdma_net_notifier);
> +	unregister_inetaddr_notifier(&irdma_inetaddr_notifier);
> +	unregister_inet6addr_notifier(&irdma_inetaddr6_notifier);
> +	unregister_netdevice_notifier(&irdma_netdevice_notifier);
> +}
> +
> +/**
> + * irdma_add_ipv6_addr - add ipv6 address to the hw arp table
> + * @iwdev: irdma device
> + */
> +static void irdma_add_ipv6_addr(struct irdma_device *iwdev)
> +{
> +	struct net_device *ip_dev;
> +	struct inet6_dev *idev;
> +	struct inet6_ifaddr *ifp, *tmp;
> +	u32 local_ipaddr6[4];
> +
> +	rcu_read_lock();
> +	for_each_netdev_rcu (&init_net, ip_dev) {
> +		if (((rdma_vlan_dev_vlan_id(ip_dev) < 0xFFFF &&
> +		      rdma_vlan_dev_real_dev(ip_dev) == iwdev->netdev) ||
> +		      ip_dev == iwdev->netdev) && ip_dev->flags & IFF_UP) {
> +			idev = __in6_dev_get(ip_dev);
> +			if (!idev) {
> +				dev_err(rfdev_to_dev(&iwdev->rf->sc_dev),
> +					"ipv6 inet device not found\n");
> +				break;
> +			}
> +			list_for_each_entry_safe (ifp, tmp, &idev->addr_list,
> +						  if_list) {
> +				dev_dbg(rfdev_to_dev(&iwdev->rf->sc_dev),
> +					"INIT: IP=%pI6, vlan_id=%d, MAC=%pM\n",
> +					&ifp->addr,
> +					rdma_vlan_dev_vlan_id(ip_dev),
> +					ip_dev->dev_addr);
> +
> +				irdma_copy_ip_ntohl(local_ipaddr6,
> +						    ifp->addr.in6_u.u6_addr32);
> +				irdma_manage_arp_cache(iwdev->rf,
> +						       ip_dev->dev_addr,
> +						       local_ipaddr6, false,
> +						       IRDMA_ARP_ADD);
> +			}
> +		}
> +	}
> +	rcu_read_unlock();
> +}
> +
> +/**
> + * irdma_add_ipv4_addr - add ipv4 address to the hw arp table
> + * @iwdev: irdma device
> + */
> +static void irdma_add_ipv4_addr(struct irdma_device *iwdev)
> +{
> +	struct net_device *dev;
> +	struct in_device *idev;
> +	u32 ip_addr;
> +
> +	rcu_read_lock();
> +	for_each_netdev_rcu (&init_net, dev) {
> +		if (((rdma_vlan_dev_vlan_id(dev) < 0xFFFF &&
> +		      rdma_vlan_dev_real_dev(dev) == iwdev->netdev) ||
> +		      dev == iwdev->netdev) && dev->flags & IFF_UP) {
> +			const struct in_ifaddr *ifa;
> +
> +			idev = __in_dev_get_rcu(dev);
> +			if (!idev)
> +				continue;
> +			in_dev_for_each_ifa_rcu(ifa, idev) {
> +				dev_dbg(rfdev_to_dev(&iwdev->rf->sc_dev),
> +					"CM: IP=%pI4, vlan_id=%d, MAC=%pM\n",
> +					&ifa->ifa_address,
> +					rdma_vlan_dev_vlan_id(dev),
> +					dev->dev_addr);
> +
> +				ip_addr = ntohl(ifa->ifa_address);
> +				irdma_manage_arp_cache(iwdev->rf, dev->dev_addr,
> +						       &ip_addr, true,
> +						       IRDMA_ARP_ADD);
> +			}
> +		}
> +	}
> +	rcu_read_unlock();
> +}
> +
> +/**
> + * irdma_add_ip - add ip addresses
> + * @iwdev: irdma device
> + *
> + * Add ipv4/ipv6 addresses to the arp cache
> + */
> +void irdma_add_ip(struct irdma_device *iwdev)
> +{
> +	irdma_add_ipv4_addr(iwdev);
> +	irdma_add_ipv6_addr(iwdev);
> +}
> +
> +static int irdma_devlink_rsrc_limits_validate(struct devlink *dl, u32 id,
> +					      union devlink_param_value val,
> +					      struct netlink_ext_ack *extack)
> +{
> +	u8 value = val.vu8;
> +
> +	if (value > 5) {
> +		NL_SET_ERR_MSG_MOD(extack, "resource limits selector range is (0-5)");
> +		return -ERANGE;
> +	}
> +
> +	return 0;
> +}
> +
> +static int irdma_devlink_enable_roce_validate(struct devlink *dl, u32 id,
> +					      union devlink_param_value val,
> +					      struct netlink_ext_ack *extack)
> +{
> +	struct irdma_dl_priv *priv = devlink_priv(dl);
> +	const struct virtbus_dev_id *vid = priv->vdev->matched_element;
> +	u8 gen_ver = vid->driver_data;
> +	bool value = val.vbool;
> +
> +	if (value && gen_ver == IRDMA_GEN_1) {
> +		NL_SET_ERR_MSG_MOD(extack, "RoCE not supported on device");
> +		return -EOPNOTSUPP;
> +	}
> +
> +	return 0;
> +}
> +
> +static int irdma_devlink_upload_ctx_get(struct devlink *devlink, u32 id,
> +					struct devlink_param_gset_ctx *ctx)
> +{
> +	ctx->val.vbool = irdma_upload_context;
> +	return 0;
> +}
> +
> +static int irdma_devlink_upload_ctx_set(struct devlink *devlink, u32 id,
> +					struct devlink_param_gset_ctx *ctx)
> +{
> +	irdma_upload_context = ctx->val.vbool;
> +	return 0;
> +}
> +
> +enum irdma_dl_param_id {
> +	IRDMA_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
> +	IRDMA_DEVLINK_PARAM_ID_LIMITS_SELECTOR,
> +	IRDMA_DEVLINK_PARAM_ID_UPLOAD_CONTEXT,
> +};
> +
> +static const struct devlink_param irdma_devlink_params[] = {
> +	/* Common */
> +	DEVLINK_PARAM_DRIVER(IRDMA_DEVLINK_PARAM_ID_LIMITS_SELECTOR,
> +			     "resource_limits_selector", DEVLINK_PARAM_TYPE_U8,
> +			      BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
> +			      NULL, NULL, irdma_devlink_rsrc_limits_validate),
> +	DEVLINK_PARAM_DRIVER(IRDMA_DEVLINK_PARAM_ID_UPLOAD_CONTEXT,
> +			     "upload_context", DEVLINK_PARAM_TYPE_BOOL,
> +			     BIT(DEVLINK_PARAM_CMODE_RUNTIME),
> +			     irdma_devlink_upload_ctx_get,
> +			     irdma_devlink_upload_ctx_set, NULL),
> +	DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
> +			      NULL, NULL, irdma_devlink_enable_roce_validate)
> +};
> +
> +static int irdma_devlink_reload_down(struct devlink *devlink, bool netns_change,
> +				     struct netlink_ext_ack *extack)
> +{
> +	struct irdma_dl_priv *priv = devlink_priv(devlink);
> +	const struct virtbus_dev_id *id = priv->vdev->matched_element;
> +	u8 gen_ver = id->driver_data;
> +
> +	switch (gen_ver) {
> +	case IRDMA_GEN_2:
> +		irdma_remove(priv->vdev);
> +		break;
> +	case IRDMA_GEN_1:
> +		i40iw_remove(priv->vdev);
> +		break;
> +	default:
> +		return -ENODEV;
> +	}
> +
> +	return 0;
> +}
> +
> +static int irdma_devlink_reload_up(struct devlink *devlink,
> +				   struct netlink_ext_ack *extack)
> +{
> +	struct irdma_dl_priv *priv = devlink_priv(devlink);
> +	union devlink_param_value saved_value;
> +	const struct virtbus_dev_id *id = priv->vdev->matched_element;

Like irdma_probe(), struct iidc_virtbus_object *vo is accesible for the
given priv.
Please use struct iidc_virtbus_object for any sharing between two drivers.
matched_element modification inside the virtbus match() function and
accessing pointer to some driver data between two driver through this
matched_element is not appropriate.

  reply index

Thread overview: 52+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-02-12 19:13 [RFC PATCH v4 00/25] Intel Wired LAN/RDMA Driver Updates 2020-02-11 Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 01/25] virtual-bus: Implementation of Virtual Bus Jeff Kirsher
2020-02-14 17:02   ` Greg KH
2020-02-14 20:34     ` Jason Gunthorpe
2020-02-14 20:43       ` Greg KH
2020-02-15  0:01         ` Jason Gunthorpe
2020-02-15  0:53           ` Greg KH
2020-02-14 20:45       ` Greg KH
2020-02-20 18:55         ` Ertman, David M
2020-02-20 19:27           ` Jason Gunthorpe
2020-02-14 21:22   ` Parav Pandit
2020-02-15  0:08   ` Jason Gunthorpe
2020-02-12 19:14 ` [RFC PATCH v4 02/25] ice: Create and register virtual bus for RDMA Jeff Kirsher
2020-02-14 20:39   ` Jason Gunthorpe
2020-02-20 18:48     ` Ertman, David M
2020-02-20 20:58       ` Jason Gunthorpe
2020-02-12 19:14 ` [RFC PATCH v4 03/25] ice: Complete RDMA peer registration Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 04/25] ice: Support resource allocation requests Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 05/25] ice: Enable event notifications Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 06/25] ice: Allow reset operations Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 07/25] ice: Pass through communications to VF Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 08/25] i40e: Move client header location Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 09/25] i40e: Register a virtbus device to provide RDMA Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 10/25] RDMA/irdma: Add driver framework definitions Jeff Kirsher
2020-02-14 22:13   ` Parav Pandit [this message]
2020-02-18 20:42     ` Saleem, Shiraz
2020-02-20 22:24       ` Parav Pandit
2020-02-20 23:06         ` Jason Gunthorpe
2020-02-21 17:01         ` Saleem, Shiraz
2020-02-21 17:23           ` Parav Pandit
2020-02-21 18:04             ` Jason Gunthorpe
2020-02-12 19:14 ` [RFC PATCH v4 11/25] RDMA/irdma: Implement device initialization definitions Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 12/25] RDMA/irdma: Implement HW Admin Queue OPs Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 13/25] RDMA/irdma: Add HMC backing store setup functions Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 14/25] RDMA/irdma: Add privileged UDA queue implementation Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 15/25] RDMA/irdma: Add QoS definitions Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 16/25] RDMA/irdma: Add connection manager Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 17/25] RDMA/irdma: Add PBLE resource manager Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 18/25] RDMA/irdma: Implement device supported verb APIs Jeff Kirsher
2020-02-14 14:54   ` Jason Gunthorpe
2020-02-14 15:49     ` Andrew Boyer
2020-02-14 16:45       ` Jason Gunthorpe
2020-02-18 20:43     ` Saleem, Shiraz
2020-02-12 19:14 ` [RFC PATCH v4 19/25] RDMA/irdma: Add RoCEv2 UD OP support Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 20/25] RDMA/irdma: Add user/kernel shared libraries Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 21/25] RDMA/irdma: Add miscellaneous utility definitions Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 22/25] RDMA/irdma: Add dynamic tracing for CM Jeff Kirsher
2020-02-14 14:53   ` Jason Gunthorpe
2020-02-18 20:43     ` Saleem, Shiraz
2020-02-12 19:14 ` [RFC PATCH v4 23/25] RDMA/irdma: Add ABI definitions Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 24/25] RDMA: Add irdma Kconfig/Makefile and remove i40iw Jeff Kirsher
2020-02-12 19:14 ` [RFC PATCH v4 25/25] RDMA/irdma: Update MAINTAINERS file Jeff Kirsher

Reply instructions:

You may reply publically to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=6f01d517-3196-1183-112e-8151b821bd72@mellanox.com \
    --to=parav@mellanox.com \
    --cc=davem@davemloft.net \
    --cc=gregkh@linuxfoundation.org \
    --cc=jeffrey.t.kirsher@intel.com \
    --cc=jgg@ziepe.ca \
    --cc=linux-rdma@vger.kernel.org \
    --cc=mustafa.ismail@intel.com \
    --cc=netdev@vger.kernel.org \
    --cc=nhorman@redhat.com \
    --cc=sassmann@redhat.com \
    --cc=shiraz.saleem@intel.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

Linux-RDMA Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/linux-rdma/0 linux-rdma/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 linux-rdma linux-rdma/ https://lore.kernel.org/linux-rdma \
		linux-rdma@vger.kernel.org
	public-inbox-index linux-rdma

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.linux-rdma


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git