2016-01-06 20:50:24 +03:00
|
|
|
#ifndef DEF_RDMA_VT_H
|
|
|
|
#define DEF_RDMA_VT_H
|
|
|
|
|
|
|
|
/*
|
IB/{hfi1, rdmavt, qib}: Implement CQ completion vector support
Currently the driver doesn't support completion vectors. These
are used to indicate which sets of CQs should be grouped together
into the same vector. A vector is a CQ processing thread that
runs on a specific CPU.
If an application has several CQs bound to different completion
vectors, and each completion vector runs on different CPUs, then
the completion queue workload is balanced. This helps scale as more
nodes are used.
Implement CQ completion vector support using a global workqueue
where a CQ entry is queued to the CPU corresponding to the CQ's
completion vector. Since the workqueue is global, it's guaranteed
to always be there when queueing CQ entries; Therefore, the RCU
locking for cq->rdi->worker in the hot path is superfluous.
Each completion vector is assigned to a different CPU. The number of
completion vectors available is computed by taking the number of
online, physical CPUs from the local NUMA node and subtracting the
CPUs used for kernel receive queues and the general interrupt.
Special use cases:
* If there are no CPUs left for completion vectors, the same CPU
for the general interrupt is used; Therefore, there would only
be one completion vector available.
* For multi-HFI systems, the number of completion vectors available
for each device is the total number of completion vectors in
the local NUMA node divided by the number of devices in the same
NUMA node. If there's a division remainder, the first device to
get initialized gets an extra completion vector.
Upon a CQ creation, an invalid completion vector could be specified.
Handle it as follows:
* If the completion vector is less than 0, set it to 0.
* Set the completion vector to the result of the passed completion
vector moded with the number of device completion vectors
available.
Reviewed-by: Mike Marciniszyn <mike.marciniszyn@intel.com>
Signed-off-by: Sebastian Sanchez <sebastian.sanchez@intel.com>
Signed-off-by: Dennis Dalessandro <dennis.dalessandro@intel.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2018-05-02 16:43:55 +03:00
|
|
|
* Copyright(c) 2016 - 2018 Intel Corporation.
|
2016-01-06 20:50:24 +03:00
|
|
|
*
|
|
|
|
* This file is provided under a dual BSD/GPLv2 license. When using or
|
|
|
|
* redistributing this file, you may do so under either license.
|
|
|
|
*
|
|
|
|
* GPL LICENSE SUMMARY
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of version 2 of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* BSD LICENSE
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
*
|
|
|
|
* - Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* - Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in
|
|
|
|
* the documentation and/or other materials provided with the
|
|
|
|
* distribution.
|
|
|
|
* - Neither the name of Intel Corporation nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structure that low level drivers will populate in order to register with the
|
|
|
|
* rdmavt layer.
|
|
|
|
*/
|
|
|
|
|
2016-01-06 21:04:13 +03:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/list.h>
|
2016-01-23 00:00:35 +03:00
|
|
|
#include <linux/hash.h>
|
2016-01-06 21:04:31 +03:00
|
|
|
#include <rdma/ib_verbs.h>
|
2017-07-24 17:46:12 +03:00
|
|
|
#include <rdma/ib_mad.h>
|
2016-01-06 21:04:31 +03:00
|
|
|
#include <rdma/rdmavt_mr.h>
|
|
|
|
#include <rdma/rdmavt_qp.h>
|
2016-01-06 21:03:47 +03:00
|
|
|
|
2016-01-06 21:05:12 +03:00
|
|
|
#define RVT_MAX_PKEY_VALUES 16
|
|
|
|
|
2017-07-24 17:46:12 +03:00
|
|
|
#define RVT_MAX_TRAP_LEN 100 /* Limit pending trap list */
|
2017-08-13 18:08:46 +03:00
|
|
|
#define RVT_MAX_TRAP_LISTS 5 /*((IB_NOTICE_TYPE_INFO & 0x0F) + 1)*/
|
2017-07-24 17:46:12 +03:00
|
|
|
#define RVT_TRAP_TIMEOUT 4096 /* 4.096 usec */
|
|
|
|
|
|
|
|
struct trap_list {
|
|
|
|
u32 list_len;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
2016-01-06 21:04:13 +03:00
|
|
|
struct rvt_ibport {
|
|
|
|
struct rvt_qp __rcu *qp[2];
|
|
|
|
struct ib_mad_agent *send_agent; /* agent for SMI (traps) */
|
|
|
|
struct rb_root mcast_tree;
|
|
|
|
spinlock_t lock; /* protect changes in this struct */
|
|
|
|
|
|
|
|
/* non-zero when timer is set */
|
|
|
|
unsigned long mkey_lease_timeout;
|
|
|
|
unsigned long trap_timeout;
|
|
|
|
__be64 gid_prefix; /* in network order */
|
|
|
|
__be64 mkey;
|
|
|
|
u64 tid;
|
|
|
|
u32 port_cap_flags;
|
2017-06-02 03:04:02 +03:00
|
|
|
u16 port_cap3_flags;
|
2016-01-06 21:04:13 +03:00
|
|
|
u32 pma_sample_start;
|
|
|
|
u32 pma_sample_interval;
|
|
|
|
__be16 pma_counter_select[5];
|
|
|
|
u16 pma_tag;
|
|
|
|
u16 mkey_lease_period;
|
2017-08-04 23:54:35 +03:00
|
|
|
u32 sm_lid;
|
2016-01-06 21:04:13 +03:00
|
|
|
u8 sm_sl;
|
|
|
|
u8 mkeyprot;
|
|
|
|
u8 subnet_timeout;
|
|
|
|
u8 vl_high_limit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Driver is expected to keep these up to date. These
|
|
|
|
* counters are informational only and not required to be
|
|
|
|
* completely accurate.
|
|
|
|
*/
|
|
|
|
u64 n_rc_resends;
|
|
|
|
u64 n_seq_naks;
|
|
|
|
u64 n_rdma_seq;
|
|
|
|
u64 n_rnr_naks;
|
|
|
|
u64 n_other_naks;
|
|
|
|
u64 n_loop_pkts;
|
|
|
|
u64 n_pkt_drops;
|
|
|
|
u64 n_vl15_dropped;
|
|
|
|
u64 n_rc_timeouts;
|
|
|
|
u64 n_dmawait;
|
|
|
|
u64 n_unaligned;
|
|
|
|
u64 n_rc_dupreq;
|
|
|
|
u64 n_rc_seqnak;
|
|
|
|
u16 pkey_violations;
|
|
|
|
u16 qkey_violations;
|
|
|
|
u16 mkey_violations;
|
|
|
|
|
|
|
|
/* Hot-path per CPU counters to avoid cacheline trading to update */
|
|
|
|
u64 z_rc_acks;
|
|
|
|
u64 z_rc_qacks;
|
|
|
|
u64 z_rc_delayed_comp;
|
|
|
|
u64 __percpu *rc_acks;
|
|
|
|
u64 __percpu *rc_qacks;
|
|
|
|
u64 __percpu *rc_delayed_comp;
|
|
|
|
|
|
|
|
void *priv; /* driver private data */
|
|
|
|
|
2016-01-06 21:05:12 +03:00
|
|
|
/*
|
|
|
|
* The pkey table is allocated and maintained by the driver. Drivers
|
|
|
|
* need to have access to this before registering with rdmav. However
|
|
|
|
* rdmavt will need access to it so drivers need to proviee this during
|
|
|
|
* the attach port API call.
|
|
|
|
*/
|
|
|
|
u16 *pkey_table;
|
|
|
|
|
2016-01-23 00:04:51 +03:00
|
|
|
struct rvt_ah *sm_ah;
|
2017-07-24 17:46:12 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Keep a list of traps that have not been repressed. They will be
|
|
|
|
* resent based on trap_timer.
|
|
|
|
*/
|
|
|
|
struct trap_list trap_lists[RVT_MAX_TRAP_LISTS];
|
|
|
|
struct timer_list trap_timer;
|
2016-01-06 21:04:13 +03:00
|
|
|
};
|
|
|
|
|
2016-01-23 00:00:15 +03:00
|
|
|
#define RVT_CQN_MAX 16 /* maximum length of cq name */
|
|
|
|
|
2018-09-26 20:44:33 +03:00
|
|
|
#define RVT_SGE_COPY_MEMCPY 0
|
|
|
|
#define RVT_SGE_COPY_CACHELESS 1
|
|
|
|
#define RVT_SGE_COPY_ADAPTIVE 2
|
|
|
|
|
2016-01-06 20:51:48 +03:00
|
|
|
/*
|
|
|
|
* Things that are driver specific, module parameters in hfi1 and qib
|
|
|
|
*/
|
|
|
|
struct rvt_driver_params {
|
2016-01-06 20:52:19 +03:00
|
|
|
struct ib_device_attr props;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Anything driver specific that is not covered by props
|
|
|
|
* For instance special module parameters. Goes here.
|
|
|
|
*/
|
2016-01-06 21:03:31 +03:00
|
|
|
unsigned int lkey_table_size;
|
2016-01-06 21:04:46 +03:00
|
|
|
unsigned int qp_table_size;
|
2018-09-26 20:44:33 +03:00
|
|
|
unsigned int sge_copy_mode;
|
|
|
|
unsigned int wss_threshold;
|
|
|
|
unsigned int wss_clean_period;
|
2016-01-06 21:04:46 +03:00
|
|
|
int qpn_start;
|
|
|
|
int qpn_inc;
|
|
|
|
int qpn_res_start;
|
|
|
|
int qpn_res_end;
|
2016-01-06 21:04:13 +03:00
|
|
|
int nports;
|
2016-01-06 21:05:12 +03:00
|
|
|
int npkeys;
|
2016-01-23 00:00:15 +03:00
|
|
|
int node;
|
2016-01-23 00:00:35 +03:00
|
|
|
int psn_mask;
|
|
|
|
int psn_shift;
|
|
|
|
int psn_modify_mask;
|
2016-02-04 01:15:20 +03:00
|
|
|
u32 core_cap_flags;
|
|
|
|
u32 max_mad_size;
|
2016-05-24 22:50:34 +03:00
|
|
|
u8 qos_shift;
|
|
|
|
u8 max_rdma_atomic;
|
2016-07-25 23:39:39 +03:00
|
|
|
u8 reserved_operations;
|
2016-01-06 20:51:48 +03:00
|
|
|
};
|
|
|
|
|
2016-01-06 21:04:23 +03:00
|
|
|
/* Protection domain */
|
|
|
|
struct rvt_pd {
|
|
|
|
struct ib_pd ibpd;
|
2017-02-08 16:27:31 +03:00
|
|
|
bool user;
|
2016-01-06 21:04:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Address handle */
|
|
|
|
struct rvt_ah {
|
|
|
|
struct ib_ah ibah;
|
2017-04-29 21:41:18 +03:00
|
|
|
struct rdma_ah_attr attr;
|
2016-01-06 21:04:23 +03:00
|
|
|
atomic_t refcount;
|
|
|
|
u8 vl;
|
|
|
|
u8 log_pmtu;
|
|
|
|
};
|
|
|
|
|
2018-09-26 20:44:33 +03:00
|
|
|
/* memory working set size */
|
|
|
|
struct rvt_wss {
|
|
|
|
unsigned long *entries;
|
|
|
|
atomic_t total_count;
|
|
|
|
atomic_t clean_counter;
|
|
|
|
atomic_t clean_entry;
|
|
|
|
|
|
|
|
int threshold;
|
|
|
|
int num_entries;
|
|
|
|
long pages_mask;
|
|
|
|
unsigned int clean_period;
|
|
|
|
};
|
|
|
|
|
2016-01-06 21:02:59 +03:00
|
|
|
struct rvt_dev_info;
|
2016-02-14 23:10:04 +03:00
|
|
|
struct rvt_swqe;
|
2016-01-06 21:02:52 +03:00
|
|
|
struct rvt_driver_provided {
|
|
|
|
/*
|
2016-02-14 23:10:37 +03:00
|
|
|
* Which functions are required depends on which verbs rdmavt is
|
|
|
|
* providing and which verbs the driver is overriding. See
|
|
|
|
* check_support() for details.
|
2016-01-06 21:02:52 +03:00
|
|
|
*/
|
2016-01-06 21:04:23 +03:00
|
|
|
|
2016-10-17 14:19:07 +03:00
|
|
|
/* hot path calldowns in a single cacheline */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give the driver a notice that there is send work to do. It is up to
|
|
|
|
* the driver to generally push the packets out, this just queues the
|
|
|
|
* work with the driver. There are two variants here. The no_lock
|
|
|
|
* version requires the s_lock not to be held. The other assumes the
|
|
|
|
* s_lock is held.
|
|
|
|
*/
|
2018-09-28 17:17:09 +03:00
|
|
|
bool (*schedule_send)(struct rvt_qp *qp);
|
|
|
|
bool (*schedule_send_no_lock)(struct rvt_qp *qp);
|
2016-10-17 14:19:07 +03:00
|
|
|
|
2018-09-10 19:49:27 +03:00
|
|
|
/*
|
2018-09-26 20:26:44 +03:00
|
|
|
* Driver specific work request setup and checking.
|
|
|
|
* This function is allowed to perform any setup, checks, or
|
|
|
|
* adjustments required to the SWQE in order to be usable by
|
|
|
|
* underlying protocols. This includes private data structure
|
|
|
|
* allocations.
|
2018-09-10 19:49:27 +03:00
|
|
|
*/
|
2018-09-26 20:26:44 +03:00
|
|
|
int (*setup_wqe)(struct rvt_qp *qp, struct rvt_swqe *wqe,
|
|
|
|
bool *call_send);
|
2016-10-17 14:19:07 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Sometimes rdmavt needs to kick the driver's send progress. That is
|
|
|
|
* done by this call back.
|
|
|
|
*/
|
|
|
|
void (*do_send)(struct rvt_qp *qp);
|
|
|
|
|
2016-02-14 23:10:37 +03:00
|
|
|
/* Passed to ib core registration. Callback to create syfs files */
|
2016-01-06 21:02:52 +03:00
|
|
|
int (*port_callback)(struct ib_device *, u8, struct kobject *);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns a pointer to the undelying hardware's PCI device. This is
|
|
|
|
* used to display information as to what hardware is being referenced
|
|
|
|
* in an output message
|
|
|
|
*/
|
2016-01-06 21:02:59 +03:00
|
|
|
struct pci_dev * (*get_pci_dev)(struct rvt_dev_info *rdi);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a private queue pair data structure for driver specific
|
2016-06-22 23:29:33 +03:00
|
|
|
* information which is opaque to rdmavt. Errors are returned via
|
|
|
|
* ERR_PTR(err). The driver is free to return NULL or a valid
|
|
|
|
* pointer.
|
2016-02-14 23:10:37 +03:00
|
|
|
*/
|
2017-05-23 14:38:14 +03:00
|
|
|
void * (*qp_priv_alloc)(struct rvt_dev_info *rdi, struct rvt_qp *qp);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
2018-11-28 21:22:31 +03:00
|
|
|
/*
|
|
|
|
* Init a struture allocated with qp_priv_alloc(). This should be
|
|
|
|
* called after all qp fields have been initialized in rdmavt.
|
|
|
|
*/
|
|
|
|
int (*qp_priv_init)(struct rvt_dev_info *rdi, struct rvt_qp *qp,
|
|
|
|
struct ib_qp_init_attr *init_attr);
|
|
|
|
|
2016-02-14 23:10:37 +03:00
|
|
|
/*
|
|
|
|
* Free the driver's private qp structure.
|
|
|
|
*/
|
2016-01-22 23:50:17 +03:00
|
|
|
void (*qp_priv_free)(struct rvt_dev_info *rdi, struct rvt_qp *qp);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Inform the driver the particular qp in quesiton has been reset so
|
|
|
|
* that it can clean up anything it needs to.
|
|
|
|
*/
|
2016-01-22 23:50:17 +03:00
|
|
|
void (*notify_qp_reset)(struct rvt_qp *qp);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a path mtu from the driver based on qp attributes.
|
|
|
|
*/
|
2016-01-23 00:00:35 +03:00
|
|
|
int (*get_pmtu_from_attr)(struct rvt_dev_info *rdi, struct rvt_qp *qp,
|
|
|
|
struct ib_qp_attr *attr);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify driver that it needs to flush any outstanding IO requests that
|
|
|
|
* are waiting on a qp.
|
|
|
|
*/
|
2016-01-23 00:00:35 +03:00
|
|
|
void (*flush_qp_waiters)(struct rvt_qp *qp);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify driver to stop its queue of sending packets. Nothing else
|
|
|
|
* should be posted to the queue pair after this has been called.
|
|
|
|
*/
|
2016-01-23 00:00:35 +03:00
|
|
|
void (*stop_send_queue)(struct rvt_qp *qp);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Have the drivr drain any in progress operations
|
|
|
|
*/
|
2016-01-23 00:00:35 +03:00
|
|
|
void (*quiesce_qp)(struct rvt_qp *qp);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Inform the driver a qp has went to error state.
|
|
|
|
*/
|
2016-01-23 00:00:35 +03:00
|
|
|
void (*notify_error_qp)(struct rvt_qp *qp);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get an MTU for a qp.
|
|
|
|
*/
|
2016-01-23 00:00:35 +03:00
|
|
|
u32 (*mtu_from_qp)(struct rvt_dev_info *rdi, struct rvt_qp *qp,
|
|
|
|
u32 pmtu);
|
2016-02-14 23:10:37 +03:00
|
|
|
/*
|
|
|
|
* Convert an mtu to a path mtu
|
|
|
|
*/
|
2016-01-23 00:00:35 +03:00
|
|
|
int (*mtu_to_path_mtu)(u32 mtu);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the guid of a port in big endian byte order
|
|
|
|
*/
|
2016-02-04 01:15:11 +03:00
|
|
|
int (*get_guid_be)(struct rvt_dev_info *rdi, struct rvt_ibport *rvp,
|
|
|
|
int guid_index, __be64 *guid);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Query driver for the state of the port.
|
|
|
|
*/
|
2016-02-04 01:15:20 +03:00
|
|
|
int (*query_port_state)(struct rvt_dev_info *rdi, u8 port_num,
|
|
|
|
struct ib_port_attr *props);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Tell driver to shutdown a port
|
|
|
|
*/
|
2016-02-04 01:15:20 +03:00
|
|
|
int (*shut_down_port)(struct rvt_dev_info *rdi, u8 port_num);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/* Tell driver to send a trap for changed port capabilities */
|
2016-02-04 01:15:20 +03:00
|
|
|
void (*cap_mask_chg)(struct rvt_dev_info *rdi, u8 port_num);
|
2016-01-06 21:02:52 +03:00
|
|
|
|
2016-02-14 23:10:37 +03:00
|
|
|
/*
|
|
|
|
* The following functions can be safely ignored completely. Any use of
|
|
|
|
* these is checked for NULL before blindly calling. Rdmavt should also
|
|
|
|
* be functional if drivers omit these.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Called to inform the driver that all qps should now be freed. */
|
|
|
|
unsigned (*free_all_qps)(struct rvt_dev_info *rdi);
|
|
|
|
|
|
|
|
/* Driver specific AH validation */
|
2017-04-29 21:41:18 +03:00
|
|
|
int (*check_ah)(struct ib_device *, struct rdma_ah_attr *);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/* Inform the driver a new AH has been created */
|
2017-04-29 21:41:18 +03:00
|
|
|
void (*notify_new_ah)(struct ib_device *, struct rdma_ah_attr *,
|
2016-01-06 21:04:23 +03:00
|
|
|
struct rvt_ah *);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/* Let the driver pick the next queue pair number*/
|
2016-01-22 23:50:17 +03:00
|
|
|
int (*alloc_qpn)(struct rvt_dev_info *rdi, struct rvt_qpn_table *qpt,
|
2017-05-23 14:38:14 +03:00
|
|
|
enum ib_qp_type type, u8 port_num);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/* Determine if its safe or allowed to modify the qp */
|
2016-01-23 00:04:38 +03:00
|
|
|
int (*check_modify_qp)(struct rvt_qp *qp, struct ib_qp_attr *attr,
|
|
|
|
int attr_mask, struct ib_udata *udata);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/* Driver specific QP modification/notification-of */
|
2016-01-23 00:04:38 +03:00
|
|
|
void (*modify_qp)(struct rvt_qp *qp, struct ib_qp_attr *attr,
|
|
|
|
int attr_mask, struct ib_udata *udata);
|
2016-01-23 00:04:51 +03:00
|
|
|
|
2016-02-14 23:10:37 +03:00
|
|
|
/* Notify driver a mad agent has been created */
|
2016-01-23 00:04:51 +03:00
|
|
|
void (*notify_create_mad_agent)(struct rvt_dev_info *rdi, int port_idx);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
|
|
|
/* Notify driver a mad agent has been removed */
|
2016-01-23 00:04:51 +03:00
|
|
|
void (*notify_free_mad_agent)(struct rvt_dev_info *rdi, int port_idx);
|
2016-02-14 23:10:37 +03:00
|
|
|
|
2017-02-08 16:27:13 +03:00
|
|
|
/* Notify driver to restart rc */
|
|
|
|
void (*notify_restart_rc)(struct rvt_qp *qp, u32 psn, int wait);
|
IB/{hfi1, rdmavt, qib}: Implement CQ completion vector support
Currently the driver doesn't support completion vectors. These
are used to indicate which sets of CQs should be grouped together
into the same vector. A vector is a CQ processing thread that
runs on a specific CPU.
If an application has several CQs bound to different completion
vectors, and each completion vector runs on different CPUs, then
the completion queue workload is balanced. This helps scale as more
nodes are used.
Implement CQ completion vector support using a global workqueue
where a CQ entry is queued to the CPU corresponding to the CQ's
completion vector. Since the workqueue is global, it's guaranteed
to always be there when queueing CQ entries; Therefore, the RCU
locking for cq->rdi->worker in the hot path is superfluous.
Each completion vector is assigned to a different CPU. The number of
completion vectors available is computed by taking the number of
online, physical CPUs from the local NUMA node and subtracting the
CPUs used for kernel receive queues and the general interrupt.
Special use cases:
* If there are no CPUs left for completion vectors, the same CPU
for the general interrupt is used; Therefore, there would only
be one completion vector available.
* For multi-HFI systems, the number of completion vectors available
for each device is the total number of completion vectors in
the local NUMA node divided by the number of devices in the same
NUMA node. If there's a division remainder, the first device to
get initialized gets an extra completion vector.
Upon a CQ creation, an invalid completion vector could be specified.
Handle it as follows:
* If the completion vector is less than 0, set it to 0.
* Set the completion vector to the result of the passed completion
vector moded with the number of device completion vectors
available.
Reviewed-by: Mike Marciniszyn <mike.marciniszyn@intel.com>
Signed-off-by: Sebastian Sanchez <sebastian.sanchez@intel.com>
Signed-off-by: Dennis Dalessandro <dennis.dalessandro@intel.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
2018-05-02 16:43:55 +03:00
|
|
|
|
|
|
|
/* Get and return CPU to pin CQ processing thread */
|
|
|
|
int (*comp_vect_cpu_lookup)(struct rvt_dev_info *rdi, int comp_vect);
|
2016-01-06 21:03:59 +03:00
|
|
|
};
|
|
|
|
|
2016-01-06 20:50:24 +03:00
|
|
|
struct rvt_dev_info {
|
2016-01-06 21:03:31 +03:00
|
|
|
struct ib_device ibdev; /* Keep this first. Nothing above here */
|
|
|
|
|
2016-01-06 20:52:19 +03:00
|
|
|
/*
|
|
|
|
* Prior to calling for registration the driver will be responsible for
|
|
|
|
* allocating space for this structure.
|
|
|
|
*
|
|
|
|
* The driver will also be responsible for filling in certain members of
|
2016-01-22 23:50:36 +03:00
|
|
|
* dparms.props. The driver needs to fill in dparms exactly as it would
|
|
|
|
* want values reported to a ULP. This will be returned to the caller
|
|
|
|
* in rdmavt's device. The driver should also therefore refrain from
|
|
|
|
* modifying this directly after registration with rdmavt.
|
2016-01-06 20:52:19 +03:00
|
|
|
*/
|
2016-01-06 20:51:48 +03:00
|
|
|
|
2016-01-06 20:52:19 +03:00
|
|
|
/* Driver specific properties */
|
2016-01-06 20:51:48 +03:00
|
|
|
struct rvt_driver_params dparms;
|
2016-01-06 20:52:19 +03:00
|
|
|
|
2016-07-02 02:02:07 +03:00
|
|
|
/* post send table */
|
|
|
|
const struct rvt_operation_params *post_parms;
|
|
|
|
|
2018-09-26 20:44:42 +03:00
|
|
|
/* opcode translation table */
|
|
|
|
const enum ib_wc_opcode *wc_opcode;
|
|
|
|
|
2016-01-06 21:02:52 +03:00
|
|
|
/* Driver specific helper functions */
|
|
|
|
struct rvt_driver_provided driver_f;
|
2016-01-06 20:50:24 +03:00
|
|
|
|
2016-10-17 14:19:07 +03:00
|
|
|
struct rvt_mregion __rcu *dma_mr;
|
|
|
|
struct rvt_lkey_table lkey_table;
|
|
|
|
|
2016-01-06 20:51:48 +03:00
|
|
|
/* Internal use */
|
|
|
|
int n_pds_allocated;
|
|
|
|
spinlock_t n_pds_lock; /* Protect pd allocated count */
|
2016-01-06 21:03:07 +03:00
|
|
|
|
2016-01-06 21:03:59 +03:00
|
|
|
int n_ahs_allocated;
|
|
|
|
spinlock_t n_ahs_lock; /* Protect ah allocated count */
|
|
|
|
|
2016-02-04 01:14:36 +03:00
|
|
|
u32 n_srqs_allocated;
|
|
|
|
spinlock_t n_srqs_lock; /* Protect srqs allocated count */
|
|
|
|
|
2016-01-06 21:03:07 +03:00
|
|
|
int flags;
|
2016-01-06 21:04:13 +03:00
|
|
|
struct rvt_ibport **ports;
|
2016-01-06 21:04:46 +03:00
|
|
|
|
2016-01-22 23:50:17 +03:00
|
|
|
/* QP */
|
2016-01-06 21:04:46 +03:00
|
|
|
struct rvt_qp_ibdev *qp_dev;
|
2016-01-22 23:50:17 +03:00
|
|
|
u32 n_qps_allocated; /* number of QPs allocated for device */
|
2016-02-10 01:29:49 +03:00
|
|
|
u32 n_rc_qps; /* number of RC QPs allocated for device */
|
|
|
|
u32 busy_jiffies; /* timeout scaling based on RC QP count */
|
|
|
|
spinlock_t n_qps_lock; /* protect qps, rc qps and busy jiffy counts */
|
2016-01-06 21:04:57 +03:00
|
|
|
|
|
|
|
/* memory maps */
|
|
|
|
struct list_head pending_mmaps;
|
|
|
|
spinlock_t mmap_offset_lock; /* protect mmap_offset */
|
|
|
|
u32 mmap_offset;
|
|
|
|
spinlock_t pending_lock; /* protect pending mmap list */
|
2016-01-23 00:00:15 +03:00
|
|
|
|
|
|
|
/* CQ */
|
|
|
|
u32 n_cqs_allocated; /* number of CQs allocated for device */
|
|
|
|
spinlock_t n_cqs_lock; /* protect count of in use cqs */
|
2016-01-23 00:00:55 +03:00
|
|
|
|
|
|
|
/* Multicast */
|
|
|
|
u32 n_mcast_grps_allocated; /* number of mcast groups allocated */
|
|
|
|
spinlock_t n_mcast_grps_lock;
|
|
|
|
|
2018-09-26 20:44:33 +03:00
|
|
|
/* Memory Working Set Size */
|
|
|
|
struct rvt_wss *wss;
|
2016-01-06 20:50:24 +03:00
|
|
|
};
|
|
|
|
|
2017-12-19 06:56:37 +03:00
|
|
|
/**
|
|
|
|
* rvt_set_ibdev_name - Craft an IB device name from client info
|
|
|
|
* @rdi: pointer to the client rvt_dev_info structure
|
|
|
|
* @name: client specific name
|
|
|
|
* @unit: client specific unit number.
|
|
|
|
*/
|
|
|
|
static inline void rvt_set_ibdev_name(struct rvt_dev_info *rdi,
|
|
|
|
const char *fmt, const char *name,
|
|
|
|
const int unit)
|
|
|
|
{
|
2018-09-26 01:58:09 +03:00
|
|
|
/*
|
|
|
|
* FIXME: rvt and its users want to touch the ibdev before
|
|
|
|
* registration and have things like the name work. We don't have the
|
|
|
|
* infrastructure in the core to support this directly today, hack it
|
|
|
|
* to work by setting the name manually here.
|
|
|
|
*/
|
|
|
|
dev_set_name(&rdi->ibdev.dev, fmt, name, unit);
|
|
|
|
strlcpy(rdi->ibdev.name, dev_name(&rdi->ibdev.dev), IB_DEVICE_NAME_MAX);
|
2017-12-19 06:56:37 +03:00
|
|
|
}
|
|
|
|
|
2017-12-19 06:56:44 +03:00
|
|
|
/**
|
|
|
|
* rvt_get_ibdev_name - return the IB name
|
|
|
|
* @rdi: rdmavt device
|
|
|
|
*
|
|
|
|
* Return the registered name of the device.
|
|
|
|
*/
|
|
|
|
static inline const char *rvt_get_ibdev_name(const struct rvt_dev_info *rdi)
|
|
|
|
{
|
2018-09-21 01:42:27 +03:00
|
|
|
return dev_name(&rdi->ibdev.dev);
|
2017-12-19 06:56:44 +03:00
|
|
|
}
|
|
|
|
|
2016-01-06 20:51:48 +03:00
|
|
|
static inline struct rvt_pd *ibpd_to_rvtpd(struct ib_pd *ibpd)
|
|
|
|
{
|
|
|
|
return container_of(ibpd, struct rvt_pd, ibpd);
|
|
|
|
}
|
|
|
|
|
2016-01-06 21:03:59 +03:00
|
|
|
static inline struct rvt_ah *ibah_to_rvtah(struct ib_ah *ibah)
|
|
|
|
{
|
|
|
|
return container_of(ibah, struct rvt_ah, ibah);
|
|
|
|
}
|
|
|
|
|
2016-01-06 20:51:48 +03:00
|
|
|
static inline struct rvt_dev_info *ib_to_rvt(struct ib_device *ibdev)
|
|
|
|
{
|
|
|
|
return container_of(ibdev, struct rvt_dev_info, ibdev);
|
|
|
|
}
|
|
|
|
|
2016-01-06 21:04:06 +03:00
|
|
|
static inline struct rvt_srq *ibsrq_to_rvtsrq(struct ib_srq *ibsrq)
|
|
|
|
{
|
|
|
|
return container_of(ibsrq, struct rvt_srq, ibsrq);
|
|
|
|
}
|
|
|
|
|
2016-01-23 00:00:22 +03:00
|
|
|
static inline struct rvt_qp *ibqp_to_rvtqp(struct ib_qp *ibqp)
|
|
|
|
{
|
|
|
|
return container_of(ibqp, struct rvt_qp, ibqp);
|
|
|
|
}
|
|
|
|
|
2016-01-06 21:05:12 +03:00
|
|
|
static inline unsigned rvt_get_npkeys(struct rvt_dev_info *rdi)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* All ports have same number of pkeys.
|
|
|
|
*/
|
|
|
|
return rdi->dparms.npkeys;
|
|
|
|
}
|
|
|
|
|
2016-05-24 22:50:40 +03:00
|
|
|
/*
|
|
|
|
* Return the max atomic suitable for determining
|
|
|
|
* the size of the ack ring buffer in a QP.
|
|
|
|
*/
|
|
|
|
static inline unsigned int rvt_max_atomic(struct rvt_dev_info *rdi)
|
|
|
|
{
|
|
|
|
return rdi->dparms.max_rdma_atomic + 1;
|
|
|
|
}
|
|
|
|
|
2016-01-06 21:05:12 +03:00
|
|
|
/*
|
|
|
|
* Return the indexed PKEY from the port PKEY table.
|
|
|
|
*/
|
|
|
|
static inline u16 rvt_get_pkey(struct rvt_dev_info *rdi,
|
|
|
|
int port_index,
|
|
|
|
unsigned index)
|
|
|
|
{
|
|
|
|
if (index >= rvt_get_npkeys(rdi))
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return rdi->ports[port_index]->pkey_table[index];
|
|
|
|
}
|
|
|
|
|
2016-01-23 00:00:35 +03:00
|
|
|
/**
|
|
|
|
* rvt_lookup_qpn - return the QP with the given QPN
|
|
|
|
* @ibp: the ibport
|
|
|
|
* @qpn: the QP number to look up
|
|
|
|
*
|
|
|
|
* The caller must hold the rcu_read_lock(), and keep the lock until
|
|
|
|
* the returned qp is no longer in use.
|
|
|
|
*/
|
|
|
|
/* TODO: Remove this and put in rdmavt/qp.h when no longer needed by drivers */
|
|
|
|
static inline struct rvt_qp *rvt_lookup_qpn(struct rvt_dev_info *rdi,
|
|
|
|
struct rvt_ibport *rvp,
|
|
|
|
u32 qpn) __must_hold(RCU)
|
|
|
|
{
|
|
|
|
struct rvt_qp *qp = NULL;
|
|
|
|
|
|
|
|
if (unlikely(qpn <= 1)) {
|
|
|
|
qp = rcu_dereference(rvp->qp[qpn]);
|
|
|
|
} else {
|
|
|
|
u32 n = hash_32(qpn, rdi->qp_dev->qp_table_bits);
|
|
|
|
|
|
|
|
for (qp = rcu_dereference(rdi->qp_dev->qp_table[n]); qp;
|
|
|
|
qp = rcu_dereference(qp->next))
|
|
|
|
if (qp->ibqp.qp_num == qpn)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return qp;
|
|
|
|
}
|
|
|
|
|
2017-02-08 16:27:13 +03:00
|
|
|
/**
|
|
|
|
* rvt_mod_retry_timer - mod a retry timer
|
|
|
|
* @qp - the QP
|
|
|
|
* Modify a potentially already running retry timer
|
|
|
|
*/
|
|
|
|
static inline void rvt_mod_retry_timer(struct rvt_qp *qp)
|
|
|
|
{
|
|
|
|
struct ib_qp *ibqp = &qp->ibqp;
|
|
|
|
struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
|
|
|
|
|
|
|
|
lockdep_assert_held(&qp->s_lock);
|
|
|
|
qp->s_flags |= RVT_S_TIMER;
|
|
|
|
/* 4.096 usec. * (1 << qp->timeout) */
|
|
|
|
mod_timer(&qp->s_timer, jiffies + qp->timeout_jiffies +
|
|
|
|
rdi->busy_jiffies);
|
|
|
|
}
|
|
|
|
|
2016-01-23 00:04:45 +03:00
|
|
|
struct rvt_dev_info *rvt_alloc_device(size_t size, int nports);
|
2016-04-20 16:05:24 +03:00
|
|
|
void rvt_dealloc_device(struct rvt_dev_info *rdi);
|
2018-03-19 16:02:34 +03:00
|
|
|
int rvt_register_device(struct rvt_dev_info *rvd, u32 driver_id);
|
2016-01-06 20:50:24 +03:00
|
|
|
void rvt_unregister_device(struct rvt_dev_info *rvd);
|
2017-04-29 21:41:18 +03:00
|
|
|
int rvt_check_ah(struct ib_device *ibdev, struct rdma_ah_attr *ah_attr);
|
2016-01-06 21:05:12 +03:00
|
|
|
int rvt_init_port(struct rvt_dev_info *rdi, struct rvt_ibport *port,
|
2016-02-04 01:15:02 +03:00
|
|
|
int port_index, u16 *pkey_table);
|
2016-07-25 23:38:19 +03:00
|
|
|
int rvt_fast_reg_mr(struct rvt_qp *qp, struct ib_mr *ibmr, u32 key,
|
|
|
|
int access);
|
|
|
|
int rvt_invalidate_rkey(struct rvt_qp *qp, u32 rkey);
|
2016-01-06 21:03:31 +03:00
|
|
|
int rvt_rkey_ok(struct rvt_qp *qp, struct rvt_sge *sge,
|
|
|
|
u32 len, u64 vaddr, u32 rkey, int acc);
|
|
|
|
int rvt_lkey_ok(struct rvt_lkey_table *rkt, struct rvt_pd *pd,
|
2017-05-12 19:20:31 +03:00
|
|
|
struct rvt_sge *isge, struct rvt_sge *last_sge,
|
|
|
|
struct ib_sge *sge, int acc);
|
2017-04-09 20:15:57 +03:00
|
|
|
struct rvt_mcast *rvt_mcast_find(struct rvt_ibport *ibp, union ib_gid *mgid,
|
|
|
|
u16 lid);
|
2016-01-06 21:04:57 +03:00
|
|
|
|
2016-01-06 20:50:24 +03:00
|
|
|
#endif /* DEF_RDMA_VT_H */
|