include/rdma/rdmavt_qp.h

   1 #ifndef DEF_RDMAVT_INCQP_H
   2 #define DEF_RDMAVT_INCQP_H
   3
   4 /*
   5  * Copyright(c) 2016 - 2020 Intel Corporation.
   6  *
   7  * This file is provided under a dual BSD/GPLv2 license.  When using or
   8  * redistributing this file, you may do so under either license.
   9  *
  10  * GPL LICENSE SUMMARY
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of version 2 of the GNU General Public License as
  14  * published by the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * BSD LICENSE
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  *
  27  *  - Redistributions of source code must retain the above copyright
  28  *    notice, this list of conditions and the following disclaimer.
  29  *  - Redistributions in binary form must reproduce the above copyright
  30  *    notice, this list of conditions and the following disclaimer in
  31  *    the documentation and/or other materials provided with the
  32  *    distribution.
  33  *  - Neither the name of Intel Corporation nor the names of its
  34  *    contributors may be used to endorse or promote products derived
  35  *    from this software without specific prior written permission.
  36  *
  37  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  38  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  39  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  40  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  41  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  42  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  43  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  45  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  47  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  *
  49  */
  50
  51 #include <rdma/rdma_vt.h>
  52 #include <rdma/ib_pack.h>
  53 #include <rdma/ib_verbs.h>
  54 #include <rdma/rdmavt_cq.h>
  55 #include <rdma/rvt-abi.h>
  56 /*
  57  * Atomic bit definitions for r_aflags.
  58  */
  59 #define RVT_R_WRID_VALID        0
  60 #define RVT_R_REWIND_SGE        1
  61
  62 /*
  63  * Bit definitions for r_flags.
  64  */
  65 #define RVT_R_REUSE_SGE 0x01
  66 #define RVT_R_RDMAR_SEQ 0x02
  67 #define RVT_R_RSP_NAK   0x04
  68 #define RVT_R_RSP_SEND  0x08
  69 #define RVT_R_COMM_EST  0x10
  70
  71 /*
  72  * If a packet's QP[23:16] bits match this value, then it is
  73  * a PSM packet and the hardware will expect a KDETH header
  74  * following the BTH.
  75  */
  76 #define RVT_KDETH_QP_PREFIX       0x80
  77 #define RVT_KDETH_QP_SUFFIX       0xffff
  78 #define RVT_KDETH_QP_PREFIX_MASK  0x00ff0000
  79 #define RVT_KDETH_QP_PREFIX_SHIFT 16
  80 #define RVT_KDETH_QP_BASE         (u32)(RVT_KDETH_QP_PREFIX << \
  81                                         RVT_KDETH_QP_PREFIX_SHIFT)
  82 #define RVT_KDETH_QP_MAX          (u32)(RVT_KDETH_QP_BASE + RVT_KDETH_QP_SUFFIX)
  83
  84 /*
  85  * If a packet's LNH == BTH and DEST QPN[23:16] in the BTH match this
  86  * prefix value, then it is an AIP packet with a DETH containing the entropy
  87  * value in byte 4 following the BTH.
  88  */
  89 #define RVT_AIP_QP_PREFIX       0x81
  90 #define RVT_AIP_QP_SUFFIX       0xffff
  91 #define RVT_AIP_QP_PREFIX_MASK  0x00ff0000
  92 #define RVT_AIP_QP_PREFIX_SHIFT 16
  93 #define RVT_AIP_QP_BASE         (u32)(RVT_AIP_QP_PREFIX << \
  94                                       RVT_AIP_QP_PREFIX_SHIFT)
  95 #define RVT_AIP_QPN_MAX         BIT(RVT_AIP_QP_PREFIX_SHIFT)
  96 #define RVT_AIP_QP_MAX          (u32)(RVT_AIP_QP_BASE + RVT_AIP_QPN_MAX - 1)
  97
  98 /*
  99  * Bit definitions for s_flags.
 100  *
 101  * RVT_S_SIGNAL_REQ_WR - set if QP send WRs contain completion signaled
 102  * RVT_S_BUSY - send tasklet is processing the QP
 103  * RVT_S_TIMER - the RC retry timer is active
 104  * RVT_S_ACK_PENDING - an ACK is waiting to be sent after RDMA read/atomics
 105  * RVT_S_WAIT_FENCE - waiting for all prior RDMA read or atomic SWQEs
 106  *                         before processing the next SWQE
 107  * RVT_S_WAIT_RDMAR - waiting for a RDMA read or atomic SWQE to complete
 108  *                         before processing the next SWQE
 109  * RVT_S_WAIT_RNR - waiting for RNR timeout
 110  * RVT_S_WAIT_SSN_CREDIT - waiting for RC credits to process next SWQE
 111  * RVT_S_WAIT_DMA - waiting for send DMA queue to drain before generating
 112  *                  next send completion entry not via send DMA
 113  * RVT_S_WAIT_PIO - waiting for a send buffer to be available
 114  * RVT_S_WAIT_TX - waiting for a struct verbs_txreq to be available
 115  * RVT_S_WAIT_DMA_DESC - waiting for DMA descriptors to be available
 116  * RVT_S_WAIT_KMEM - waiting for kernel memory to be available
 117  * RVT_S_WAIT_PSN - waiting for a packet to exit the send DMA queue
 118  * RVT_S_WAIT_ACK - waiting for an ACK packet before sending more requests
 119  * RVT_S_SEND_ONE - send one packet, request ACK, then wait for ACK
 120  * RVT_S_ECN - a BECN was queued to the send engine
 121  * RVT_S_MAX_BIT_MASK - The max bit that can be used by rdmavt
 122  */
 123 #define RVT_S_SIGNAL_REQ_WR     0x0001
 124 #define RVT_S_BUSY              0x0002
 125 #define RVT_S_TIMER             0x0004
 126 #define RVT_S_RESP_PENDING      0x0008
 127 #define RVT_S_ACK_PENDING       0x0010
 128 #define RVT_S_WAIT_FENCE        0x0020
 129 #define RVT_S_WAIT_RDMAR        0x0040
 130 #define RVT_S_WAIT_RNR          0x0080
 131 #define RVT_S_WAIT_SSN_CREDIT   0x0100
 132 #define RVT_S_WAIT_DMA          0x0200
 133 #define RVT_S_WAIT_PIO          0x0400
 134 #define RVT_S_WAIT_TX           0x0800
 135 #define RVT_S_WAIT_DMA_DESC     0x1000
 136 #define RVT_S_WAIT_KMEM         0x2000
 137 #define RVT_S_WAIT_PSN          0x4000
 138 #define RVT_S_WAIT_ACK          0x8000
 139 #define RVT_S_SEND_ONE          0x10000
 140 #define RVT_S_UNLIMITED_CREDIT  0x20000
 141 #define RVT_S_ECN               0x40000
 142 #define RVT_S_MAX_BIT_MASK      0x800000
 143
 144 /*
 145  * Drivers should use s_flags starting with bit 31 down to the bit next to
 146  * RVT_S_MAX_BIT_MASK
 147  */
 148
 149 /*
 150  * Wait flags that would prevent any packet type from being sent.
 151  */
 152 #define RVT_S_ANY_WAIT_IO \
 153         (RVT_S_WAIT_PIO | RVT_S_WAIT_TX | \
 154          RVT_S_WAIT_DMA_DESC | RVT_S_WAIT_KMEM)
 155
 156 /*
 157  * Wait flags that would prevent send work requests from making progress.
 158  */
 159 #define RVT_S_ANY_WAIT_SEND (RVT_S_WAIT_FENCE | RVT_S_WAIT_RDMAR | \
 160         RVT_S_WAIT_RNR | RVT_S_WAIT_SSN_CREDIT | RVT_S_WAIT_DMA | \
 161         RVT_S_WAIT_PSN | RVT_S_WAIT_ACK)
 162
 163 #define RVT_S_ANY_WAIT (RVT_S_ANY_WAIT_IO | RVT_S_ANY_WAIT_SEND)
 164
 165 /* Number of bits to pay attention to in the opcode for checking qp type */
 166 #define RVT_OPCODE_QP_MASK 0xE0
 167
 168 /* Flags for checking QP state (see ib_rvt_state_ops[]) */
 169 #define RVT_POST_SEND_OK                0x01
 170 #define RVT_POST_RECV_OK                0x02
 171 #define RVT_PROCESS_RECV_OK             0x04
 172 #define RVT_PROCESS_SEND_OK             0x08
 173 #define RVT_PROCESS_NEXT_SEND_OK        0x10
 174 #define RVT_FLUSH_SEND                  0x20
 175 #define RVT_FLUSH_RECV                  0x40
 176 #define RVT_PROCESS_OR_FLUSH_SEND \
 177         (RVT_PROCESS_SEND_OK | RVT_FLUSH_SEND)
 178 #define RVT_SEND_OR_FLUSH_OR_RECV_OK \
 179         (RVT_PROCESS_SEND_OK | RVT_FLUSH_SEND | RVT_PROCESS_RECV_OK)
 180
 181 /*
 182  * Internal send flags
 183  */
 184 #define RVT_SEND_RESERVE_USED           IB_SEND_RESERVED_START
 185 #define RVT_SEND_COMPLETION_ONLY        (IB_SEND_RESERVED_START << 1)
 186
 187 /**
 188  * rvt_ud_wr - IB UD work plus AH cache
 189  * @wr: valid IB work request
 190  * @attr: pointer to an allocated AH attribute
 191  *
 192  * Special case the UD WR so we can keep track of the AH attributes.
 193  *
 194  * NOTE: This data structure is stricly ordered wr then attr. I.e the attr
 195  * MUST come after wr.  The ib_ud_wr is sized and copied in rvt_post_one_wr.
 196  * The copy assumes that wr is first.
 197  */
 198 struct rvt_ud_wr {
 199         struct ib_ud_wr wr;
 200         struct rdma_ah_attr *attr;
 201 };
 202
 203 /*
 204  * Send work request queue entry.
 205  * The size of the sg_list is determined when the QP is created and stored
 206  * in qp->s_max_sge.
 207  */
 208 struct rvt_swqe {
 209         union {
 210                 struct ib_send_wr wr;   /* don't use wr.sg_list */
 211                 struct rvt_ud_wr ud_wr;
 212                 struct ib_reg_wr reg_wr;
 213                 struct ib_rdma_wr rdma_wr;
 214                 struct ib_atomic_wr atomic_wr;
 215         };
 216         u32 psn;                /* first packet sequence number */
 217         u32 lpsn;               /* last packet sequence number */
 218         u32 ssn;                /* send sequence number */
 219         u32 length;             /* total length of data in sg_list */
 220         void *priv;             /* driver dependent field */
 221         struct rvt_sge sg_list[];
 222 };
 223
 224 /**
 225  * struct rvt_krwq - kernel struct receive work request
 226  * @p_lock: lock to protect producer of the kernel buffer
 227  * @head: index of next entry to fill
 228  * @c_lock:lock to protect consumer of the kernel buffer
 229  * @tail: index of next entry to pull
 230  * @count: count is aproximate of total receive enteries posted
 231  * @rvt_rwqe: struct of receive work request queue entry
 232  *
 233  * This structure is used to contain the head pointer,
 234  * tail pointer and receive work queue entries for kernel
 235  * mode user.
 236  */
 237 struct rvt_krwq {
 238         spinlock_t p_lock;      /* protect producer */
 239         u32 head;               /* new work requests posted to the head */
 240
 241         /* protect consumer */
 242         spinlock_t c_lock ____cacheline_aligned_in_smp;
 243         u32 tail;               /* receives pull requests from here. */
 244         u32 count;              /* approx count of receive entries posted */
 245         struct rvt_rwqe *curr_wq;
 246         struct rvt_rwqe wq[];
 247 };
 248
 249 /*
 250  * rvt_get_swqe_ah - Return the pointer to the struct rvt_ah
 251  * @swqe: valid Send WQE
 252  *
 253  */
 254 static inline struct rvt_ah *rvt_get_swqe_ah(struct rvt_swqe *swqe)
 255 {
 256         return ibah_to_rvtah(swqe->ud_wr.wr.ah);
 257 }
 258
 259 /**
 260  * rvt_get_swqe_ah_attr - Return the cached ah attribute information
 261  * @swqe: valid Send WQE
 262  *
 263  */
 264 static inline struct rdma_ah_attr *rvt_get_swqe_ah_attr(struct rvt_swqe *swqe)
 265 {
 266         return swqe->ud_wr.attr;
 267 }
 268
 269 /**
 270  * rvt_get_swqe_remote_qpn - Access the remote QPN value
 271  * @swqe: valid Send WQE
 272  *
 273  */
 274 static inline u32 rvt_get_swqe_remote_qpn(struct rvt_swqe *swqe)
 275 {
 276         return swqe->ud_wr.wr.remote_qpn;
 277 }
 278
 279 /**
 280  * rvt_get_swqe_remote_qkey - Acces the remote qkey value
 281  * @swqe: valid Send WQE
 282  *
 283  */
 284 static inline u32 rvt_get_swqe_remote_qkey(struct rvt_swqe *swqe)
 285 {
 286         return swqe->ud_wr.wr.remote_qkey;
 287 }
 288
 289 /**
 290  * rvt_get_swqe_pkey_index - Access the pkey index
 291  * @swqe: valid Send WQE
 292  *
 293  */
 294 static inline u16 rvt_get_swqe_pkey_index(struct rvt_swqe *swqe)
 295 {
 296         return swqe->ud_wr.wr.pkey_index;
 297 }
 298
 299 struct rvt_rq {
 300         struct rvt_rwq *wq;
 301         struct rvt_krwq *kwq;
 302         u32 size;               /* size of RWQE array */
 303         u8 max_sge;
 304         /* protect changes in this struct */
 305         spinlock_t lock ____cacheline_aligned_in_smp;
 306 };
 307
 308 /**
 309  * rvt_get_rq_count - count numbers of request work queue entries
 310  * in circular buffer
 311  * @rq: data structure for request queue entry
 312  * @head: head indices of the circular buffer
 313  * @tail: tail indices of the circular buffer
 314  *
 315  * Return - total number of entries in the Receive Queue
 316  */
 317
 318 static inline u32 rvt_get_rq_count(struct rvt_rq *rq, u32 head, u32 tail)
 319 {
 320         u32 count = head - tail;
 321
 322         if ((s32)count < 0)
 323                 count += rq->size;
 324         return count;
 325 }
 326
 327 /*
 328  * This structure holds the information that the send tasklet needs
 329  * to send a RDMA read response or atomic operation.
 330  */
 331 struct rvt_ack_entry {
 332         struct rvt_sge rdma_sge;
 333         u64 atomic_data;
 334         u32 psn;
 335         u32 lpsn;
 336         u8 opcode;
 337         u8 sent;
 338         void *priv;
 339 };
 340
 341 #define RC_QP_SCALING_INTERVAL  5
 342
 343 #define RVT_OPERATION_PRIV        0x00000001
 344 #define RVT_OPERATION_ATOMIC      0x00000002
 345 #define RVT_OPERATION_ATOMIC_SGE  0x00000004
 346 #define RVT_OPERATION_LOCAL       0x00000008
 347 #define RVT_OPERATION_USE_RESERVE 0x00000010
 348 #define RVT_OPERATION_IGN_RNR_CNT 0x00000020
 349
 350 #define RVT_OPERATION_MAX (IB_WR_RESERVED10 + 1)
 351
 352 /**
 353  * rvt_operation_params - op table entry
 354  * @length - the length to copy into the swqe entry
 355  * @qpt_support - a bit mask indicating QP type support
 356  * @flags - RVT_OPERATION flags (see above)
 357  *
 358  * This supports table driven post send so that
 359  * the driver can have differing an potentially
 360  * different sets of operations.
 361  *
 362  **/
 363
 364 struct rvt_operation_params {
 365         size_t length;
 366         u32 qpt_support;
 367         u32 flags;
 368 };
 369
 370 /*
 371  * Common variables are protected by both r_rq.lock and s_lock in that order
 372  * which only happens in modify_qp() or changing the QP 'state'.
 373  */
 374 struct rvt_qp {
 375         struct ib_qp ibqp;
 376         void *priv; /* Driver private data */
 377         /* read mostly fields above and below */
 378         struct rdma_ah_attr remote_ah_attr;
 379         struct rdma_ah_attr alt_ah_attr;
 380         struct rvt_qp __rcu *next;           /* link list for QPN hash table */
 381         struct rvt_swqe *s_wq;  /* send work queue */
 382         struct rvt_mmap_info *ip;
 383
 384         unsigned long timeout_jiffies;  /* computed from timeout */
 385
 386         int srate_mbps;         /* s_srate (below) converted to Mbit/s */
 387         pid_t pid;              /* pid for user mode QPs */
 388         u32 remote_qpn;
 389         u32 qkey;               /* QKEY for this QP (for UD or RD) */
 390         u32 s_size;             /* send work queue size */
 391
 392         u16 pmtu;               /* decoded from path_mtu */
 393         u8 log_pmtu;            /* shift for pmtu */
 394         u8 state;               /* QP state */
 395         u8 allowed_ops;         /* high order bits of allowed opcodes */
 396         u8 qp_access_flags;
 397         u8 alt_timeout;         /* Alternate path timeout for this QP */
 398         u8 timeout;             /* Timeout for this QP */
 399         u8 s_srate;
 400         u8 s_mig_state;
 401         u8 port_num;
 402         u8 s_pkey_index;        /* PKEY index to use */
 403         u8 s_alt_pkey_index;    /* Alternate path PKEY index to use */
 404         u8 r_max_rd_atomic;     /* max number of RDMA read/atomic to receive */
 405         u8 s_max_rd_atomic;     /* max number of RDMA read/atomic to send */
 406         u8 s_retry_cnt;         /* number of times to retry */
 407         u8 s_rnr_retry_cnt;
 408         u8 r_min_rnr_timer;     /* retry timeout value for RNR NAKs */
 409         u8 s_max_sge;           /* size of s_wq->sg_list */
 410         u8 s_draining;
 411
 412         /* start of read/write fields */
 413         atomic_t refcount ____cacheline_aligned_in_smp;
 414         wait_queue_head_t wait;
 415
 416         struct rvt_ack_entry *s_ack_queue;
 417         struct rvt_sge_state s_rdma_read_sge;
 418
 419         spinlock_t r_lock ____cacheline_aligned_in_smp;      /* used for APM */
 420         u32 r_psn;              /* expected rcv packet sequence number */
 421         unsigned long r_aflags;
 422         u64 r_wr_id;            /* ID for current receive WQE */
 423         u32 r_ack_psn;          /* PSN for next ACK or atomic ACK */
 424         u32 r_len;              /* total length of r_sge */
 425         u32 r_rcv_len;          /* receive data len processed */
 426         u32 r_msn;              /* message sequence number */
 427
 428         u8 r_state;             /* opcode of last packet received */
 429         u8 r_flags;
 430         u8 r_head_ack_queue;    /* index into s_ack_queue[] */
 431         u8 r_adefered;          /* defered ack count */
 432
 433         struct list_head rspwait;       /* link for waiting to respond */
 434
 435         struct rvt_sge_state r_sge;     /* current receive data */
 436         struct rvt_rq r_rq;             /* receive work queue */
 437
 438         /* post send line */
 439         spinlock_t s_hlock ____cacheline_aligned_in_smp;
 440         u32 s_head;             /* new entries added here */
 441         u32 s_next_psn;         /* PSN for next request */
 442         u32 s_avail;            /* number of entries avail */
 443         u32 s_ssn;              /* SSN of tail entry */
 444         atomic_t s_reserved_used; /* reserved entries in use */
 445
 446         spinlock_t s_lock ____cacheline_aligned_in_smp;
 447         u32 s_flags;
 448         struct rvt_sge_state *s_cur_sge;
 449         struct rvt_swqe *s_wqe;
 450         struct rvt_sge_state s_sge;     /* current send request data */
 451         struct rvt_mregion *s_rdma_mr;
 452         u32 s_len;              /* total length of s_sge */
 453         u32 s_rdma_read_len;    /* total length of s_rdma_read_sge */
 454         u32 s_last_psn;         /* last response PSN processed */
 455         u32 s_sending_psn;      /* lowest PSN that is being sent */
 456         u32 s_sending_hpsn;     /* highest PSN that is being sent */
 457         u32 s_psn;              /* current packet sequence number */
 458         u32 s_ack_rdma_psn;     /* PSN for sending RDMA read responses */
 459         u32 s_ack_psn;          /* PSN for acking sends and RDMA writes */
 460         u32 s_tail;             /* next entry to process */
 461         u32 s_cur;              /* current work queue entry */
 462         u32 s_acked;            /* last un-ACK'ed entry */
 463         u32 s_last;             /* last completed entry */
 464         u32 s_lsn;              /* limit sequence number (credit) */
 465         u32 s_ahgpsn;           /* set to the psn in the copy of the header */
 466         u16 s_cur_size;         /* size of send packet in bytes */
 467         u16 s_rdma_ack_cnt;
 468         u8 s_hdrwords;         /* size of s_hdr in 32 bit words */
 469         s8 s_ahgidx;
 470         u8 s_state;             /* opcode of last packet sent */
 471         u8 s_ack_state;         /* opcode of packet to ACK */
 472         u8 s_nak_state;         /* non-zero if NAK is pending */
 473         u8 r_nak_state;         /* non-zero if NAK is pending */
 474         u8 s_retry;             /* requester retry counter */
 475         u8 s_rnr_retry;         /* requester RNR retry counter */
 476         u8 s_num_rd_atomic;     /* number of RDMA read/atomic pending */
 477         u8 s_tail_ack_queue;    /* index into s_ack_queue[] */
 478         u8 s_acked_ack_queue;   /* index into s_ack_queue[] */
 479
 480         struct rvt_sge_state s_ack_rdma_sge;
 481         struct timer_list s_timer;
 482         struct hrtimer s_rnr_timer;
 483
 484         atomic_t local_ops_pending; /* number of fast_reg/local_inv reqs */
 485
 486         /*
 487          * This sge list MUST be last. Do not add anything below here.
 488          */
 489         struct rvt_sge r_sg_list[] /* verified SGEs */
 490                 ____cacheline_aligned_in_smp;
 491 };
 492
 493 struct rvt_srq {
 494         struct ib_srq ibsrq;
 495         struct rvt_rq rq;
 496         struct rvt_mmap_info *ip;
 497         /* send signal when number of RWQEs < limit */
 498         u32 limit;
 499 };
 500
 501 static inline struct rvt_srq *ibsrq_to_rvtsrq(struct ib_srq *ibsrq)
 502 {
 503         return container_of(ibsrq, struct rvt_srq, ibsrq);
 504 }
 505
 506 static inline struct rvt_qp *ibqp_to_rvtqp(struct ib_qp *ibqp)
 507 {
 508         return container_of(ibqp, struct rvt_qp, ibqp);
 509 }
 510
 511 #define RVT_QPN_MAX                 BIT(24)
 512 #define RVT_QPNMAP_ENTRIES          (RVT_QPN_MAX / PAGE_SIZE / BITS_PER_BYTE)
 513 #define RVT_BITS_PER_PAGE           (PAGE_SIZE * BITS_PER_BYTE)
 514 #define RVT_BITS_PER_PAGE_MASK      (RVT_BITS_PER_PAGE - 1)
 515 #define RVT_QPN_MASK                IB_QPN_MASK
 516
 517 /*
 518  * QPN-map pages start out as NULL, they get allocated upon
 519  * first use and are never deallocated. This way,
 520  * large bitmaps are not allocated unless large numbers of QPs are used.
 521  */
 522 struct rvt_qpn_map {
 523         void *page;
 524 };
 525
 526 struct rvt_qpn_table {
 527         spinlock_t lock; /* protect changes to the qp table */
 528         unsigned flags;         /* flags for QP0/1 allocated for each port */
 529         u32 last;               /* last QP number allocated */
 530         u32 nmaps;              /* size of the map table */
 531         u16 limit;
 532         u8  incr;
 533         /* bit map of free QP numbers other than 0/1 */
 534         struct rvt_qpn_map map[RVT_QPNMAP_ENTRIES];
 535 };
 536
 537 struct rvt_qp_ibdev {
 538         u32 qp_table_size;
 539         u32 qp_table_bits;
 540         struct rvt_qp __rcu **qp_table;
 541         spinlock_t qpt_lock; /* qptable lock */
 542         struct rvt_qpn_table qpn_table;
 543 };
 544
 545 /*
 546  * There is one struct rvt_mcast for each multicast GID.
 547  * All attached QPs are then stored as a list of
 548  * struct rvt_mcast_qp.
 549  */
 550 struct rvt_mcast_qp {
 551         struct list_head list;
 552         struct rvt_qp *qp;
 553 };
 554
 555 struct rvt_mcast_addr {
 556         union ib_gid mgid;
 557         u16 lid;
 558 };
 559
 560 struct rvt_mcast {
 561         struct rb_node rb_node;
 562         struct rvt_mcast_addr mcast_addr;
 563         struct list_head qp_list;
 564         wait_queue_head_t wait;
 565         atomic_t refcount;
 566         int n_attached;
 567 };
 568
 569 /*
 570  * Since struct rvt_swqe is not a fixed size, we can't simply index into
 571  * struct rvt_qp.s_wq.  This function does the array index computation.
 572  */
 573 static inline struct rvt_swqe *rvt_get_swqe_ptr(struct rvt_qp *qp,
 574                                                 unsigned n)
 575 {
 576         return (struct rvt_swqe *)((char *)qp->s_wq +
 577                                      (sizeof(struct rvt_swqe) +
 578                                       qp->s_max_sge *
 579                                       sizeof(struct rvt_sge)) * n);
 580 }
 581
 582 /*
 583  * Since struct rvt_rwqe is not a fixed size, we can't simply index into
 584  * struct rvt_rwq.wq.  This function does the array index computation.
 585  */
 586 static inline struct rvt_rwqe *rvt_get_rwqe_ptr(struct rvt_rq *rq, unsigned n)
 587 {
 588         return (struct rvt_rwqe *)
 589                 ((char *)rq->kwq->curr_wq +
 590                  (sizeof(struct rvt_rwqe) +
 591                   rq->max_sge * sizeof(struct ib_sge)) * n);
 592 }
 593
 594 /**
 595  * rvt_is_user_qp - return if this is user mode QP
 596  * @qp - the target QP
 597  */
 598 static inline bool rvt_is_user_qp(struct rvt_qp *qp)
 599 {
 600         return !!qp->pid;
 601 }
 602
 603 /**
 604  * rvt_get_qp - get a QP reference
 605  * @qp - the QP to hold
 606  */
 607 static inline void rvt_get_qp(struct rvt_qp *qp)
 608 {
 609         atomic_inc(&qp->refcount);
 610 }
 611
 612 /**
 613  * rvt_put_qp - release a QP reference
 614  * @qp - the QP to release
 615  */
 616 static inline void rvt_put_qp(struct rvt_qp *qp)
 617 {
 618         if (qp && atomic_dec_and_test(&qp->refcount))
 619                 wake_up(&qp->wait);
 620 }
 621
 622 /**
 623  * rvt_put_swqe - drop mr refs held by swqe
 624  * @wqe - the send wqe
 625  *
 626  * This drops any mr references held by the swqe
 627  */
 628 static inline void rvt_put_swqe(struct rvt_swqe *wqe)
 629 {
 630         int i;
 631
 632         for (i = 0; i < wqe->wr.num_sge; i++) {
 633                 struct rvt_sge *sge = &wqe->sg_list[i];
 634
 635                 rvt_put_mr(sge->mr);
 636         }
 637 }
 638
 639 /**
 640  * rvt_qp_wqe_reserve - reserve operation
 641  * @qp - the rvt qp
 642  * @wqe - the send wqe
 643  *
 644  * This routine used in post send to record
 645  * a wqe relative reserved operation use.
 646  */
 647 static inline void rvt_qp_wqe_reserve(
 648         struct rvt_qp *qp,
 649         struct rvt_swqe *wqe)
 650 {
 651         atomic_inc(&qp->s_reserved_used);
 652 }
 653
 654 /**
 655  * rvt_qp_wqe_unreserve - clean reserved operation
 656  * @qp - the rvt qp
 657  * @flags - send wqe flags
 658  *
 659  * This decrements the reserve use count.
 660  *
 661  * This call MUST precede the change to
 662  * s_last to insure that post send sees a stable
 663  * s_avail.
 664  *
 665  * An smp_mp__after_atomic() is used to insure
 666  * the compiler does not juggle the order of the s_last
 667  * ring index and the decrementing of s_reserved_used.
 668  */
 669 static inline void rvt_qp_wqe_unreserve(struct rvt_qp *qp, int flags)
 670 {
 671         if (unlikely(flags & RVT_SEND_RESERVE_USED)) {
 672                 atomic_dec(&qp->s_reserved_used);
 673                 /* insure no compiler re-order up to s_last change */
 674                 smp_mb__after_atomic();
 675         }
 676 }
 677
 678 extern const enum ib_wc_opcode ib_rvt_wc_opcode[];
 679
 680 /*
 681  * Compare the lower 24 bits of the msn values.
 682  * Returns an integer <, ==, or > than zero.
 683  */
 684 static inline int rvt_cmp_msn(u32 a, u32 b)
 685 {
 686         return (((int)a) - ((int)b)) << 8;
 687 }
 688
 689 __be32 rvt_compute_aeth(struct rvt_qp *qp);
 690
 691 void rvt_get_credit(struct rvt_qp *qp, u32 aeth);
 692
 693 u32 rvt_restart_sge(struct rvt_sge_state *ss, struct rvt_swqe *wqe, u32 len);
 694
 695 /**
 696  * rvt_div_round_up_mtu - round up divide
 697  * @qp - the qp pair
 698  * @len - the length
 699  *
 700  * Perform a shift based mtu round up divide
 701  */
 702 static inline u32 rvt_div_round_up_mtu(struct rvt_qp *qp, u32 len)
 703 {
 704         return (len + qp->pmtu - 1) >> qp->log_pmtu;
 705 }
 706
 707 /**
 708  * @qp - the qp pair
 709  * @len - the length
 710  *
 711  * Perform a shift based mtu divide
 712  */
 713 static inline u32 rvt_div_mtu(struct rvt_qp *qp, u32 len)
 714 {
 715         return len >> qp->log_pmtu;
 716 }
 717
 718 /**
 719  * rvt_timeout_to_jiffies - Convert a ULP timeout input into jiffies
 720  * @timeout - timeout input(0 - 31).
 721  *
 722  * Return a timeout value in jiffies.
 723  */
 724 static inline unsigned long rvt_timeout_to_jiffies(u8 timeout)
 725 {
 726         if (timeout > 31)
 727                 timeout = 31;
 728
 729         return usecs_to_jiffies(1U << timeout) * 4096UL / 1000UL;
 730 }
 731
 732 /**
 733  * rvt_lookup_qpn - return the QP with the given QPN
 734  * @ibp: the ibport
 735  * @qpn: the QP number to look up
 736  *
 737  * The caller must hold the rcu_read_lock(), and keep the lock until
 738  * the returned qp is no longer in use.
 739  */
 740 static inline struct rvt_qp *rvt_lookup_qpn(struct rvt_dev_info *rdi,
 741                                             struct rvt_ibport *rvp,
 742                                             u32 qpn) __must_hold(RCU)
 743 {
 744         struct rvt_qp *qp = NULL;
 745
 746         if (unlikely(qpn <= 1)) {
 747                 qp = rcu_dereference(rvp->qp[qpn]);
 748         } else {
 749                 u32 n = hash_32(qpn, rdi->qp_dev->qp_table_bits);
 750
 751                 for (qp = rcu_dereference(rdi->qp_dev->qp_table[n]); qp;
 752                         qp = rcu_dereference(qp->next))
 753                         if (qp->ibqp.qp_num == qpn)
 754                                 break;
 755         }
 756         return qp;
 757 }
 758
 759 /**
 760  * rvt_mod_retry_timer - mod a retry timer
 761  * @qp - the QP
 762  * @shift - timeout shift to wait for multiple packets
 763  * Modify a potentially already running retry timer
 764  */
 765 static inline void rvt_mod_retry_timer_ext(struct rvt_qp *qp, u8 shift)
 766 {
 767         struct ib_qp *ibqp = &qp->ibqp;
 768         struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
 769
 770         lockdep_assert_held(&qp->s_lock);
 771         qp->s_flags |= RVT_S_TIMER;
 772         /* 4.096 usec. * (1 << qp->timeout) */
 773         mod_timer(&qp->s_timer, jiffies + rdi->busy_jiffies +
 774                   (qp->timeout_jiffies << shift));
 775 }
 776
 777 static inline void rvt_mod_retry_timer(struct rvt_qp *qp)
 778 {
 779         return rvt_mod_retry_timer_ext(qp, 0);
 780 }
 781
 782 /**
 783  * rvt_put_qp_swqe - drop refs held by swqe
 784  * @qp: the send qp
 785  * @wqe: the send wqe
 786  *
 787  * This drops any references held by the swqe
 788  */
 789 static inline void rvt_put_qp_swqe(struct rvt_qp *qp, struct rvt_swqe *wqe)
 790 {
 791         rvt_put_swqe(wqe);
 792         if (qp->allowed_ops == IB_OPCODE_UD)
 793                 rdma_destroy_ah_attr(wqe->ud_wr.attr);
 794 }
 795
 796 /**
 797  * rvt_qp_sqwe_incr - increment ring index
 798  * @qp: the qp
 799  * @val: the starting value
 800  *
 801  * Return: the new value wrapping as appropriate
 802  */
 803 static inline u32
 804 rvt_qp_swqe_incr(struct rvt_qp *qp, u32 val)
 805 {
 806         if (++val >= qp->s_size)
 807                 val = 0;
 808         return val;
 809 }
 810
 811 int rvt_error_qp(struct rvt_qp *qp, enum ib_wc_status err);
 812
 813 /**
 814  * rvt_recv_cq - add a new entry to completion queue
 815  *                      by receive queue
 816  * @qp: receive queue
 817  * @wc: work completion entry to add
 818  * @solicited: true if @entry is solicited
 819  *
 820  * This is wrapper function for rvt_enter_cq function call by
 821  * receive queue. If rvt_cq_enter return false, it means cq is
 822  * full and the qp is put into error state.
 823  */
 824 static inline void rvt_recv_cq(struct rvt_qp *qp, struct ib_wc *wc,
 825                                bool solicited)
 826 {
 827         struct rvt_cq *cq = ibcq_to_rvtcq(qp->ibqp.recv_cq);
 828
 829         if (unlikely(!rvt_cq_enter(cq, wc, solicited)))
 830                 rvt_error_qp(qp, IB_WC_LOC_QP_OP_ERR);
 831 }
 832
 833 /**
 834  * rvt_send_cq - add a new entry to completion queue
 835  *                        by send queue
 836  * @qp: send queue
 837  * @wc: work completion entry to add
 838  * @solicited: true if @entry is solicited
 839  *
 840  * This is wrapper function for rvt_enter_cq function call by
 841  * send queue. If rvt_cq_enter return false, it means cq is
 842  * full and the qp is put into error state.
 843  */
 844 static inline void rvt_send_cq(struct rvt_qp *qp, struct ib_wc *wc,
 845                                bool solicited)
 846 {
 847         struct rvt_cq *cq = ibcq_to_rvtcq(qp->ibqp.send_cq);
 848
 849         if (unlikely(!rvt_cq_enter(cq, wc, solicited)))
 850                 rvt_error_qp(qp, IB_WC_LOC_QP_OP_ERR);
 851 }
 852
 853 /**
 854  * rvt_qp_complete_swqe - insert send completion
 855  * @qp - the qp
 856  * @wqe - the send wqe
 857  * @opcode - wc operation (driver dependent)
 858  * @status - completion status
 859  *
 860  * Update the s_last information, and then insert a send
 861  * completion into the completion
 862  * queue if the qp indicates it should be done.
 863  *
 864  * See IBTA 10.7.3.1 for info on completion
 865  * control.
 866  *
 867  * Return: new last
 868  */
 869 static inline u32
 870 rvt_qp_complete_swqe(struct rvt_qp *qp,
 871                      struct rvt_swqe *wqe,
 872                      enum ib_wc_opcode opcode,
 873                      enum ib_wc_status status)
 874 {
 875         bool need_completion;
 876         u64 wr_id;
 877         u32 byte_len, last;
 878         int flags = wqe->wr.send_flags;
 879
 880         rvt_qp_wqe_unreserve(qp, flags);
 881         rvt_put_qp_swqe(qp, wqe);
 882
 883         need_completion =
 884                 !(flags & RVT_SEND_RESERVE_USED) &&
 885                 (!(qp->s_flags & RVT_S_SIGNAL_REQ_WR) ||
 886                 (flags & IB_SEND_SIGNALED) ||
 887                 status != IB_WC_SUCCESS);
 888         if (need_completion) {
 889                 wr_id = wqe->wr.wr_id;
 890                 byte_len = wqe->length;
 891                 /* above fields required before writing s_last */
 892         }
 893         last = rvt_qp_swqe_incr(qp, qp->s_last);
 894         /* see rvt_qp_is_avail() */
 895         smp_store_release(&qp->s_last, last);
 896         if (need_completion) {
 897                 struct ib_wc w = {
 898                         .wr_id = wr_id,
 899                         .status = status,
 900                         .opcode = opcode,
 901                         .qp = &qp->ibqp,
 902                         .byte_len = byte_len,
 903                 };
 904                 rvt_send_cq(qp, &w, status != IB_WC_SUCCESS);
 905         }
 906         return last;
 907 }
 908
 909 extern const int  ib_rvt_state_ops[];
 910
 911 struct rvt_dev_info;
 912 int rvt_get_rwqe(struct rvt_qp *qp, bool wr_id_only);
 913 void rvt_comm_est(struct rvt_qp *qp);
 914 void rvt_rc_error(struct rvt_qp *qp, enum ib_wc_status err);
 915 unsigned long rvt_rnr_tbl_to_usec(u32 index);
 916 enum hrtimer_restart rvt_rc_rnr_retry(struct hrtimer *t);
 917 void rvt_add_rnr_timer(struct rvt_qp *qp, u32 aeth);
 918 void rvt_del_timers_sync(struct rvt_qp *qp);
 919 void rvt_stop_rc_timers(struct rvt_qp *qp);
 920 void rvt_add_retry_timer_ext(struct rvt_qp *qp, u8 shift);
 921 static inline void rvt_add_retry_timer(struct rvt_qp *qp)
 922 {
 923         rvt_add_retry_timer_ext(qp, 0);
 924 }
 925
 926 void rvt_copy_sge(struct rvt_qp *qp, struct rvt_sge_state *ss,
 927                   void *data, u32 length,
 928                   bool release, bool copy_last);
 929 void rvt_send_complete(struct rvt_qp *qp, struct rvt_swqe *wqe,
 930                        enum ib_wc_status status);
 931 void rvt_ruc_loopback(struct rvt_qp *qp);
 932
 933 /**
 934  * struct rvt_qp_iter - the iterator for QPs
 935  * @qp - the current QP
 936  *
 937  * This structure defines the current iterator
 938  * state for sequenced access to all QPs relative
 939  * to an rvt_dev_info.
 940  */
 941 struct rvt_qp_iter {
 942         struct rvt_qp *qp;
 943         /* private: backpointer */
 944         struct rvt_dev_info *rdi;
 945         /* private: callback routine */
 946         void (*cb)(struct rvt_qp *qp, u64 v);
 947         /* private: for arg to callback routine */
 948         u64 v;
 949         /* private: number of SMI,GSI QPs for device */
 950         int specials;
 951         /* private: current iterator index */
 952         int n;
 953 };
 954
 955 /**
 956  * ib_cq_tail - Return tail index of cq buffer
 957  * @send_cq - The cq for send
 958  *
 959  * This is called in qp_iter_print to get tail
 960  * of cq buffer.
 961  */
 962 static inline u32 ib_cq_tail(struct ib_cq *send_cq)
 963 {
 964         struct rvt_cq *cq = ibcq_to_rvtcq(send_cq);
 965
 966         return ibcq_to_rvtcq(send_cq)->ip ?
 967                RDMA_READ_UAPI_ATOMIC(cq->queue->tail) :
 968                ibcq_to_rvtcq(send_cq)->kqueue->tail;
 969 }
 970
 971 /**
 972  * ib_cq_head - Return head index of cq buffer
 973  * @send_cq - The cq for send
 974  *
 975  * This is called in qp_iter_print to get head
 976  * of cq buffer.
 977  */
 978 static inline u32 ib_cq_head(struct ib_cq *send_cq)
 979 {
 980         struct rvt_cq *cq = ibcq_to_rvtcq(send_cq);
 981
 982         return ibcq_to_rvtcq(send_cq)->ip ?
 983                RDMA_READ_UAPI_ATOMIC(cq->queue->head) :
 984                ibcq_to_rvtcq(send_cq)->kqueue->head;
 985 }
 986
 987 /**
 988  * rvt_free_rq - free memory allocated for rvt_rq struct
 989  * @rvt_rq: request queue data structure
 990  *
 991  * This function should only be called if the rvt_mmap_info()
 992  * has not succeeded.
 993  */
 994 static inline void rvt_free_rq(struct rvt_rq *rq)
 995 {
 996         kvfree(rq->kwq);
 997         rq->kwq = NULL;
 998         vfree(rq->wq);
 999         rq->wq = NULL;
1000 }
1001
1002 /**
1003  * rvt_to_iport - Get the ibport pointer
1004  * @qp: the qp pointer
1005  *
1006  * This function returns the ibport pointer from the qp pointer.
1007  */
1008 static inline struct rvt_ibport *rvt_to_iport(struct rvt_qp *qp)
1009 {
1010         struct rvt_dev_info *rdi = ib_to_rvt(qp->ibqp.device);
1011
1012         return rdi->ports[qp->port_num - 1];
1013 }
1014
1015 /**
1016  * rvt_rc_credit_avail - Check if there are enough RC credits for the request
1017  * @qp: the qp
1018  * @wqe: the request
1019  *
1020  * This function returns false when there are not enough credits for the given
1021  * request and true otherwise.
1022  */
1023 static inline bool rvt_rc_credit_avail(struct rvt_qp *qp, struct rvt_swqe *wqe)
1024 {
1025         lockdep_assert_held(&qp->s_lock);
1026         if (!(qp->s_flags & RVT_S_UNLIMITED_CREDIT) &&
1027             rvt_cmp_msn(wqe->ssn, qp->s_lsn + 1) > 0) {
1028                 struct rvt_ibport *rvp = rvt_to_iport(qp);
1029
1030                 qp->s_flags |= RVT_S_WAIT_SSN_CREDIT;
1031                 rvp->n_rc_crwaits++;
1032                 return false;
1033         }
1034         return true;
1035 }
1036
1037 struct rvt_qp_iter *rvt_qp_iter_init(struct rvt_dev_info *rdi,
1038                                      u64 v,
1039                                      void (*cb)(struct rvt_qp *qp, u64 v));
1040 int rvt_qp_iter_next(struct rvt_qp_iter *iter);
1041 void rvt_qp_iter(struct rvt_dev_info *rdi,
1042                  u64 v,
1043                  void (*cb)(struct rvt_qp *qp, u64 v));
1044 void rvt_qp_mr_clean(struct rvt_qp *qp, u32 lkey);
1045 #endif          /* DEF_RDMAVT_INCQP_H */