source: src/linux/universal/linux-4.4/drivers/infiniband/ulp/srp/ib_srp.h @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 6 weeks ago

use new squashfs in all kernels

File size: 7.6 KB
Line 
1/*
2 * Copyright (c) 2005 Cisco Systems.  All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses.  You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 *     Redistribution and use in source and binary forms, with or
11 *     without modification, are permitted provided that the following
12 *     conditions are met:
13 *
14 *      - Redistributions of source code must retain the above
15 *        copyright notice, this list of conditions and the following
16 *        disclaimer.
17 *
18 *      - Redistributions in binary form must reproduce the above
19 *        copyright notice, this list of conditions and the following
20 *        disclaimer in the documentation and/or other materials
21 *        provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33#ifndef IB_SRP_H
34#define IB_SRP_H
35
36#include <linux/types.h>
37#include <linux/list.h>
38#include <linux/mutex.h>
39#include <linux/scatterlist.h>
40
41#include <scsi/scsi_host.h>
42#include <scsi/scsi_cmnd.h>
43
44#include <rdma/ib_verbs.h>
45#include <rdma/ib_sa.h>
46#include <rdma/ib_cm.h>
47#include <rdma/ib_fmr_pool.h>
48
49enum {
50        SRP_PATH_REC_TIMEOUT_MS = 1000,
51        SRP_ABORT_TIMEOUT_MS    = 5000,
52
53        SRP_PORT_REDIRECT       = 1,
54        SRP_DLID_REDIRECT       = 2,
55        SRP_STALE_CONN          = 3,
56
57        SRP_DEF_SG_TABLESIZE    = 12,
58
59        SRP_DEFAULT_QUEUE_SIZE  = 1 << 6,
60        SRP_RSP_SQ_SIZE         = 1,
61        SRP_TSK_MGMT_SQ_SIZE    = 1,
62        SRP_DEFAULT_CMD_SQ_SIZE = SRP_DEFAULT_QUEUE_SIZE - SRP_RSP_SQ_SIZE -
63                                  SRP_TSK_MGMT_SQ_SIZE,
64
65        SRP_TAG_NO_REQ          = ~0U,
66        SRP_TAG_TSK_MGMT        = 1U << 31,
67
68        SRP_MAX_PAGES_PER_MR    = 512,
69
70        LOCAL_INV_WR_ID_MASK    = 1,
71        FAST_REG_WR_ID_MASK     = 2,
72
73        SRP_LAST_WR_ID          = 0xfffffffcU,
74};
75
76enum srp_target_state {
77        SRP_TARGET_SCANNING,
78        SRP_TARGET_LIVE,
79        SRP_TARGET_REMOVED,
80};
81
82enum srp_iu_type {
83        SRP_IU_CMD,
84        SRP_IU_TSK_MGMT,
85        SRP_IU_RSP,
86};
87
88/*
89 * @mr_page_mask: HCA memory registration page mask.
90 * @mr_page_size: HCA memory registration page size.
91 * @mr_max_size: Maximum size in bytes of a single FMR / FR registration
92 *   request.
93 */
94struct srp_device {
95        struct list_head        dev_list;
96        struct ib_device       *dev;
97        struct ib_pd           *pd;
98        struct ib_mr           *global_mr;
99        u64                     mr_page_mask;
100        int                     mr_page_size;
101        int                     mr_max_size;
102        int                     max_pages_per_mr;
103        bool                    has_fmr;
104        bool                    has_fr;
105        bool                    use_fmr;
106        bool                    use_fast_reg;
107};
108
109struct srp_host {
110        struct srp_device      *srp_dev;
111        u8                      port;
112        struct device           dev;
113        struct list_head        target_list;
114        spinlock_t              target_lock;
115        struct completion       released;
116        struct list_head        list;
117        struct mutex            add_target_mutex;
118};
119
120struct srp_request {
121        struct scsi_cmnd       *scmnd;
122        struct srp_iu          *cmd;
123        union {
124                struct ib_pool_fmr **fmr_list;
125                struct srp_fr_desc **fr_list;
126        };
127        u64                    *map_page;
128        struct srp_direct_buf  *indirect_desc;
129        dma_addr_t              indirect_dma_addr;
130        short                   nmdesc;
131};
132
133/**
134 * struct srp_rdma_ch
135 * @comp_vector: Completion vector used by this RDMA channel.
136 */
137struct srp_rdma_ch {
138        /* These are RW in the hot path, and commonly used together */
139        struct list_head        free_tx;
140        spinlock_t              lock;
141        s32                     req_lim;
142
143        /* These are read-only in the hot path */
144        struct srp_target_port *target ____cacheline_aligned_in_smp;
145        struct ib_cq           *send_cq;
146        struct ib_cq           *recv_cq;
147        struct ib_qp           *qp;
148        union {
149                struct ib_fmr_pool     *fmr_pool;
150                struct srp_fr_pool     *fr_pool;
151        };
152
153        /* Everything above this point is used in the hot path of
154         * command processing. Try to keep them packed into cachelines.
155         */
156
157        struct completion       done;
158        int                     status;
159
160        struct ib_sa_path_rec   path;
161        struct ib_sa_query     *path_query;
162        int                     path_query_id;
163
164        struct ib_cm_id        *cm_id;
165        struct srp_iu         **tx_ring;
166        struct srp_iu         **rx_ring;
167        struct srp_request     *req_ring;
168        int                     max_ti_iu_len;
169        int                     comp_vector;
170
171        u64                     tsk_mgmt_tag;
172        struct completion       tsk_mgmt_done;
173        u8                      tsk_mgmt_status;
174        bool                    connected;
175};
176
177/**
178 * struct srp_target_port
179 * @comp_vector: Completion vector used by the first RDMA channel created for
180 *   this target port.
181 */
182struct srp_target_port {
183        /* read and written in the hot path */
184        spinlock_t              lock;
185
186        /* read only in the hot path */
187        struct ib_mr            *global_mr;
188        struct srp_rdma_ch      *ch;
189        u32                     ch_count;
190        u32                     lkey;
191        enum srp_target_state   state;
192        unsigned int            max_iu_len;
193        unsigned int            cmd_sg_cnt;
194        unsigned int            indirect_size;
195        bool                    allow_ext_sg;
196
197        /* other member variables */
198        union ib_gid            sgid;
199        __be64                  id_ext;
200        __be64                  ioc_guid;
201        __be64                  service_id;
202        __be64                  initiator_ext;
203        u16                     io_class;
204        struct srp_host        *srp_host;
205        struct Scsi_Host       *scsi_host;
206        struct srp_rport       *rport;
207        char                    target_name[32];
208        unsigned int            scsi_id;
209        unsigned int            sg_tablesize;
210        int                     queue_size;
211        int                     req_ring_size;
212        int                     comp_vector;
213        int                     tl_retry_count;
214
215        union ib_gid            orig_dgid;
216        __be16                  pkey;
217
218        u32                     rq_tmo_jiffies;
219
220        int                     zero_req_lim;
221
222        struct work_struct      tl_err_work;
223        struct work_struct      remove_work;
224
225        struct list_head        list;
226        bool                    qp_in_error;
227};
228
229struct srp_iu {
230        struct list_head        list;
231        u64                     dma;
232        void                   *buf;
233        size_t                  size;
234        enum dma_data_direction direction;
235};
236
237/**
238 * struct srp_fr_desc - fast registration work request arguments
239 * @entry: Entry in srp_fr_pool.free_list.
240 * @mr:    Memory region.
241 * @frpl:  Fast registration page list.
242 */
243struct srp_fr_desc {
244        struct list_head                entry;
245        struct ib_mr                    *mr;
246};
247
248/**
249 * struct srp_fr_pool - pool of fast registration descriptors
250 *
251 * An entry is available for allocation if and only if it occurs in @free_list.
252 *
253 * @size:      Number of descriptors in this pool.
254 * @max_page_list_len: Maximum fast registration work request page list length.
255 * @lock:      Protects free_list.
256 * @free_list: List of free descriptors.
257 * @desc:      Fast registration descriptor pool.
258 */
259struct srp_fr_pool {
260        int                     size;
261        int                     max_page_list_len;
262        spinlock_t              lock;
263        struct list_head        free_list;
264        struct srp_fr_desc      desc[0];
265};
266
267/**
268 * struct srp_map_state - per-request DMA memory mapping state
269 * @desc:           Pointer to the element of the SRP buffer descriptor array
270 *                  that is being filled in.
271 * @pages:          Array with DMA addresses of pages being considered for
272 *                  memory registration.
273 * @base_dma_addr:  DMA address of the first page that has not yet been mapped.
274 * @dma_len:        Number of bytes that will be registered with the next
275 *                  FMR or FR memory registration call.
276 * @total_len:      Total number of bytes in the sg-list being mapped.
277 * @npages:         Number of page addresses in the pages[] array.
278 * @nmdesc:         Number of FMR or FR memory descriptors used for mapping.
279 * @ndesc:          Number of SRP buffer descriptors that have been filled in.
280 */
281struct srp_map_state {
282        union {
283                struct {
284                        struct ib_pool_fmr **next;
285                        struct ib_pool_fmr **end;
286                } fmr;
287                struct {
288                        struct srp_fr_desc **next;
289                        struct srp_fr_desc **end;
290                } fr;
291                struct {
292                        void               **next;
293                        void               **end;
294                } gen;
295        };
296        struct srp_direct_buf  *desc;
297        union {
298                u64                     *pages;
299                struct scatterlist      *sg;
300        };
301        dma_addr_t              base_dma_addr;
302        u32                     dma_len;
303        u32                     total_len;
304        unsigned int            npages;
305        unsigned int            nmdesc;
306        unsigned int            ndesc;
307};
308
309#endif /* IB_SRP_H */
Note: See TracBrowser for help on using the repository browser.