1 /* $FreeBSD$ */
2 /*-
3 * Copyright (c) 2015, Mellanox Technologies, Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #ifndef ICL_ISER_H
28 #define ICL_ISER_H
29
30 /*
31 * iSCSI Common Layer for RDMA.
32 */
33
34 #include <sys/cdefs.h>
35 #include <sys/param.h>
36 #include <sys/capsicum.h>
37 #include <sys/condvar.h>
38 #include <sys/conf.h>
39 #include <sys/file.h>
40 #include <sys/kernel.h>
41 #include <sys/kthread.h>
42 #include <sys/lock.h>
43 #include <sys/mbuf.h>
44 #include <sys/mutex.h>
45 #include <sys/module.h>
46 #include <sys/protosw.h>
47 #include <sys/socket.h>
48 #include <sys/socketvar.h>
49 #include <sys/sysctl.h>
50 #include <sys/systm.h>
51 #include <sys/sx.h>
52 #include <sys/uio.h>
53 #include <sys/taskqueue.h>
54 #include <sys/bio.h>
55 #include <vm/uma.h>
56 #include <netinet/in.h>
57 #include <netinet/tcp.h>
58 #include <dev/iscsi/icl.h>
59 #include <dev/iscsi/iscsi_proto.h>
60 #include <icl_conn_if.h>
61 #include <cam/cam.h>
62 #include <cam/cam_ccb.h>
63 #include <rdma/ib_verbs.h>
64 #include <rdma/ib_fmr_pool.h>
65 #include <rdma/rdma_cm.h>
66
67
68 #define ISER_DBG(X, ...) \
69 do { \
70 if (unlikely(iser_debug > 2)) \
71 printf("DEBUG: %s: " X "\n", \
72 __func__, ## __VA_ARGS__); \
73 } while (0)
74
75 #define ISER_INFO(X, ...) \
76 do { \
77 if (unlikely(iser_debug > 1)) \
78 printf("INFO: %s: " X "\n", \
79 __func__, ## __VA_ARGS__); \
80 } while (0)
81
82 #define ISER_WARN(X, ...) \
83 do { \
84 if (unlikely(iser_debug > 0)) { \
85 printf("WARNING: %s: " X "\n", \
86 __func__, ## __VA_ARGS__); \
87 } \
88 } while (0)
89
90 #define ISER_ERR(X, ...) \
91 printf("ERROR: %s: " X "\n", __func__, ## __VA_ARGS__)
92
93 #define ISER_VER 0x10
94 #define ISER_WSV 0x08
95 #define ISER_RSV 0x04
96
97 #define ISER_FASTREG_LI_WRID 0xffffffffffffffffULL
98 #define ISER_BEACON_WRID 0xfffffffffffffffeULL
99
100 #define SHIFT_4K 12
101 #define SIZE_4K (1ULL << SHIFT_4K)
102 #define MASK_4K (~(SIZE_4K-1))
103
104 /* support up to 512KB in one RDMA */
105 #define ISCSI_ISER_SG_TABLESIZE (0x80000 >> SHIFT_4K)
106 #define ISER_DEF_XMIT_CMDS_MAX 256
107
108 /* the max RX (recv) WR supported by the iSER QP is defined by *
109 * max_recv_wr = commands_max + recv_beacon */
110 #define ISER_QP_MAX_RECV_DTOS (ISER_DEF_XMIT_CMDS_MAX + 1)
111 #define ISER_MIN_POSTED_RX (ISER_DEF_XMIT_CMDS_MAX >> 2)
112
113 /* QP settings */
114 /* Maximal bounds on received asynchronous PDUs */
115 #define ISER_MAX_RX_MISC_PDUS 4 /* NOOP_IN(2) , ASYNC_EVENT(2) */
116 #define ISER_MAX_TX_MISC_PDUS 6 /* NOOP_OUT(2), TEXT(1), SCSI_TMFUNC(2), LOGOUT(1) */
117
118 /* the max TX (send) WR supported by the iSER QP is defined by *
119 * max_send_wr = T * (1 + D) + C ; D is how many inflight dataouts we expect *
120 * to have at max for SCSI command. The tx posting & completion handling code *
121 * supports -EAGAIN scheme where tx is suspended till the QP has room for more *
122 * send WR. D=8 comes from 64K/8K */
123
124 #define ISER_INFLIGHT_DATAOUTS 8
125
126 /* the send_beacon increase the max_send_wr by 1 */
127 #define ISER_QP_MAX_REQ_DTOS (ISER_DEF_XMIT_CMDS_MAX * \
128 (1 + ISER_INFLIGHT_DATAOUTS) + \
129 ISER_MAX_TX_MISC_PDUS + \
130 ISER_MAX_RX_MISC_PDUS + 1)
131
132 #define ISER_GET_MAX_XMIT_CMDS(send_wr) ((send_wr \
133 - ISER_MAX_TX_MISC_PDUS \
134 - ISER_MAX_RX_MISC_PDUS - 1) / \
135 (1 + ISER_INFLIGHT_DATAOUTS))
136
137 #define ISER_WC_BATCH_COUNT 16
138 #define ISER_SIGNAL_CMD_COUNT 32
139
140 /* Maximal QP's recommended per CQ. In case we use more QP's per CQ we might *
141 * encounter a CQ overrun state. */
142 #define ISCSI_ISER_MAX_CONN 8
143 #define ISER_MAX_RX_LEN (ISER_QP_MAX_RECV_DTOS * ISCSI_ISER_MAX_CONN)
144 #define ISER_MAX_TX_LEN (ISER_QP_MAX_REQ_DTOS * ISCSI_ISER_MAX_CONN)
145 #define ISER_MAX_CQ_LEN (ISER_MAX_RX_LEN + ISER_MAX_TX_LEN + \
146 ISCSI_ISER_MAX_CONN)
147
148 #define ISER_ZBVA_NOT_SUPPORTED 0x80
149 #define ISER_SEND_W_INV_NOT_SUPPORTED 0x40
150
151 #define ISCSI_DEF_MAX_RECV_SEG_LEN 8192
152 #define ISCSI_OPCODE_MASK 0x3f
153
154 #define icl_to_iser_conn(ic) \
155 container_of(ic, struct iser_conn, icl_conn)
156 #define icl_to_iser_pdu(ip) \
157 container_of(ip, struct icl_iser_pdu, icl_pdu)
158
159 /**
160 * struct iser_hdr - iSER header
161 *
162 * @flags: flags support (zbva, remote_inv)
163 * @rsvd: reserved
164 * @write_stag: write rkey
165 * @write_va: write virtual address
166 * @reaf_stag: read rkey
167 * @read_va: read virtual address
168 */
169 struct iser_hdr {
170 u8 flags;
171 u8 rsvd[3];
172 __be32 write_stag;
173 __be64 write_va;
174 __be32 read_stag;
175 __be64 read_va;
176 } __attribute__((packed));
177
178 struct iser_cm_hdr {
179 u8 flags;
180 u8 rsvd[3];
181 } __packed;
182
183 /* Constant PDU lengths calculations */
184 #define ISER_HEADERS_LEN (sizeof(struct iser_hdr) + ISCSI_BHS_SIZE)
185
186 #define ISER_RECV_DATA_SEG_LEN 128
187 #define ISER_RX_PAYLOAD_SIZE (ISER_HEADERS_LEN + ISER_RECV_DATA_SEG_LEN)
188
189 #define ISER_RX_LOGIN_SIZE (ISER_HEADERS_LEN + ISCSI_DEF_MAX_RECV_SEG_LEN)
190
191 enum iser_conn_state {
192 ISER_CONN_INIT, /* descriptor allocd, no conn */
193 ISER_CONN_PENDING, /* in the process of being established */
194 ISER_CONN_UP, /* up and running */
195 ISER_CONN_TERMINATING, /* in the process of being terminated */
196 ISER_CONN_DOWN, /* shut down */
197 ISER_CONN_STATES_NUM
198 };
199
200 enum iser_task_status {
201 ISER_TASK_STATUS_INIT = 0,
202 ISER_TASK_STATUS_STARTED,
203 ISER_TASK_STATUS_COMPLETED
204 };
205
206 enum iser_data_dir {
207 ISER_DIR_IN = 0, /* to initiator */
208 ISER_DIR_OUT, /* from initiator */
209 ISER_DIRS_NUM
210 };
211
212 /**
213 * struct iser_mem_reg - iSER memory registration info
214 *
215 * @sge: memory region sg element
216 * @rkey: memory region remote key
217 * @mem_h: pointer to registration context (FMR/Fastreg)
218 */
219 struct iser_mem_reg {
220 struct ib_sge sge;
221 u32 rkey;
222 void *mem_h;
223 };
224
225 enum iser_desc_type {
226 ISCSI_TX_CONTROL ,
227 ISCSI_TX_SCSI_COMMAND,
228 ISCSI_TX_DATAOUT
229 };
230
231 /**
232 * struct iser_data_buf - iSER data buffer
233 *
234 * @sg: pointer to the sg list
235 * @size: num entries of this sg
236 * @data_len: total beffer byte len
237 * @dma_nents: returned by dma_map_sg
238 * @copy_buf: allocated copy buf for SGs unaligned
239 * for rdma which are copied
240 * @orig_sg: pointer to the original sg list (in case
241 * we used a copy)
242 * @sg_single: SG-ified clone of a non SG SC or
243 * unaligned SG
244 */
245 struct iser_data_buf {
246 struct scatterlist sgl[ISCSI_ISER_SG_TABLESIZE];
247 void *sg;
248 int size;
249 unsigned long data_len;
250 unsigned int dma_nents;
251 char *copy_buf;
252 struct scatterlist *orig_sg;
253 struct scatterlist sg_single;
254 };
255
256 /* fwd declarations */
257 struct iser_conn;
258 struct ib_conn;
259 struct iser_device;
260
261 /**
262 * struct iser_tx_desc - iSER TX descriptor (for send wr_id)
263 *
264 * @iser_header: iser header
265 * @iscsi_header: iscsi header (bhs)
266 * @type: command/control/dataout
267 * @dma_addr: header buffer dma_address
268 * @tx_sg: sg[0] points to iser/iscsi headers
269 * sg[1] optionally points to either of immediate data
270 * unsolicited data-out or control
271 * @num_sge: number sges used on this TX task
272 * @mapped: indicates if the descriptor is dma mapped
273 */
274 struct iser_tx_desc {
275 struct iser_hdr iser_header;
276 struct iscsi_bhs iscsi_header __attribute__((packed));
277 enum iser_desc_type type;
278 u64 dma_addr;
279 struct ib_sge tx_sg[2];
280 int num_sge;
281 bool mapped;
282 };
283
284 #define ISER_RX_PAD_SIZE (256 - (ISER_RX_PAYLOAD_SIZE + \
285 sizeof(u64) + sizeof(struct ib_sge)))
286 /**
287 * struct iser_rx_desc - iSER RX descriptor (for recv wr_id)
288 *
289 * @iser_header: iser header
290 * @iscsi_header: iscsi header
291 * @data: received data segment
292 * @dma_addr: receive buffer dma address
293 * @rx_sg: ib_sge of receive buffer
294 * @pad: for sense data TODO: Modify to maximum sense length supported
295 */
296 struct iser_rx_desc {
297 struct iser_hdr iser_header;
298 struct iscsi_bhs iscsi_header;
299 char data[ISER_RECV_DATA_SEG_LEN];
300 u64 dma_addr;
301 struct ib_sge rx_sg;
302 char pad[ISER_RX_PAD_SIZE];
303 } __attribute__((packed));
304
305 struct icl_iser_pdu {
306 struct icl_pdu icl_pdu;
307 struct iser_tx_desc desc;
308 struct iser_conn *iser_conn;
309 enum iser_task_status status;
310 struct ccb_scsiio *csio;
311 int command_sent;
312 int dir[ISER_DIRS_NUM];
313 struct iser_mem_reg rdma_reg[ISER_DIRS_NUM];
314 struct iser_data_buf data[ISER_DIRS_NUM];
315 };
316
317 /**
318 * struct iser_comp - iSER completion context
319 *
320 * @device: pointer to device handle
321 * @cq: completion queue
322 * @wcs: work completion array
323 * @tq: taskqueue handle
324 * @task: task to run task_fn
325 * @active_qps: Number of active QPs attached
326 * to completion context
327 */
328 struct iser_comp {
329 struct iser_device *device;
330 struct ib_cq *cq;
331 struct ib_wc wcs[ISER_WC_BATCH_COUNT];
332 struct taskqueue *tq;
333 struct task task;
334 int active_qps;
335 };
336
337 /**
338 * struct iser_device - iSER device handle
339 *
340 * @ib_device: RDMA device
341 * @pd: Protection Domain for this device
342 * @dev_attr: Device attributes container
343 * @mr: Global DMA memory region
344 * @event_handler: IB events handle routine
345 * @ig_list: entry in devices list
346 * @refcount: Reference counter, dominated by open iser connections
347 * @comps_used: Number of completion contexts used, Min between online
348 * cpus and device max completion vectors
349 * @comps: Dinamically allocated array of completion handlers
350 */
351 struct iser_device {
352 struct ib_device *ib_device;
353 struct ib_pd *pd;
354 struct ib_device_attr dev_attr;
355 struct ib_mr *mr;
356 struct ib_event_handler event_handler;
357 struct list_head ig_list;
358 int refcount;
359 int comps_used;
360 struct iser_comp *comps;
361 };
362
363 /**
364 * struct iser_reg_resources - Fast registration recources
365 *
366 * @mr: memory region
367 * @mr_valid: is mr valid indicator
368 */
369 struct iser_reg_resources {
370 struct ib_mr *mr;
371 u8 mr_valid:1;
372 };
373
374 /**
375 * struct fast_reg_descriptor - Fast registration descriptor
376 *
377 * @list: entry in connection fastreg pool
378 * @rsc: data buffer registration resources
379 */
380 struct fast_reg_descriptor {
381 struct list_head list;
382 struct iser_reg_resources rsc;
383 };
384
385
386 /**
387 * struct iser_beacon - beacon to signal all flush errors were drained
388 *
389 * @send: send wr
390 * @recv: recv wr
391 * @flush_lock: protects flush_cv
392 * @flush_cv: condition variable for beacon flush
393 */
394 struct iser_beacon {
395 union {
396 struct ib_send_wr send;
397 struct ib_recv_wr recv;
398 };
399 struct mtx flush_lock;
400 struct cv flush_cv;
401 };
402
403 /**
404 * struct ib_conn - Infiniband related objects
405 *
406 * @cma_id: rdma_cm connection maneger handle
407 * @qp: Connection Queue-pair
408 * @device: reference to iser device
409 * @comp: iser completion context
410 */
411 struct ib_conn {
412 struct rdma_cm_id *cma_id;
413 struct ib_qp *qp;
414 int post_recv_buf_count;
415 u8 sig_count;
416 struct ib_recv_wr rx_wr[ISER_MIN_POSTED_RX];
417 struct iser_device *device;
418 struct iser_comp *comp;
419 struct iser_beacon beacon;
420 struct mtx lock;
421 union {
422 struct {
423 struct ib_fmr_pool *pool;
424 struct iser_page_vec *page_vec;
425 } fmr;
426 struct {
427 struct list_head pool;
428 int pool_size;
429 } fastreg;
430 };
431 };
432
433 struct iser_conn {
434 struct icl_conn icl_conn;
435 struct ib_conn ib_conn;
436 struct cv up_cv;
437 struct list_head conn_list;
438 struct sx state_mutex;
439 enum iser_conn_state state;
440 int qp_max_recv_dtos;
441 int min_posted_rx;
442 u16 max_cmds;
443 char *login_buf;
444 char *login_req_buf, *login_resp_buf;
445 u64 login_req_dma, login_resp_dma;
446 unsigned int rx_desc_head;
447 struct iser_rx_desc *rx_descs;
448 u32 num_rx_descs;
449 bool handoff_done;
450 };
451
452 /**
453 * struct iser_global: iSER global context
454 *
455 * @device_list_mutex: protects device_list
456 * @device_list: iser devices global list
457 * @connlist_mutex: protects connlist
458 * @connlist: iser connections global list
459 * @desc_cache: kmem cache for tx dataout
460 * @close_conns_mutex: serializes conns closure
461 */
462 struct iser_global {
463 struct sx device_list_mutex;
464 struct list_head device_list;
465 struct mtx connlist_mutex;
466 struct list_head connlist;
467 struct sx close_conns_mutex;
468 };
469
470 extern struct iser_global ig;
471 extern int iser_debug;
472
473 void
474 iser_create_send_desc(struct iser_conn *, struct iser_tx_desc *);
475
476 int
477 iser_post_recvl(struct iser_conn *);
478
479 int
480 iser_post_recvm(struct iser_conn *, int);
481
482 int
483 iser_alloc_login_buf(struct iser_conn *iser_conn);
484
485 void
486 iser_free_login_buf(struct iser_conn *iser_conn);
487
488 int
489 iser_post_send(struct ib_conn *, struct iser_tx_desc *, bool);
490
491 void
492 iser_snd_completion(struct iser_tx_desc *, struct ib_conn *);
493
494 void
495 iser_rcv_completion(struct iser_rx_desc *, unsigned long,
496 struct ib_conn *);
497
498 void
499 iser_pdu_free(struct icl_conn *, struct icl_pdu *);
500
501 struct icl_pdu *
502 iser_new_pdu(struct icl_conn *ic, int flags);
503
504 int
505 iser_alloc_rx_descriptors(struct iser_conn *, int);
506
507 void
508 iser_free_rx_descriptors(struct iser_conn *);
509
510 int
511 iser_initialize_headers(struct icl_iser_pdu *, struct iser_conn *);
512
513 int
514 iser_send_control(struct iser_conn *, struct icl_iser_pdu *);
515
516 int
517 iser_send_command(struct iser_conn *, struct icl_iser_pdu *);
518
519 int
520 iser_reg_rdma_mem(struct icl_iser_pdu *, enum iser_data_dir);
521
522 void
523 iser_unreg_rdma_mem(struct icl_iser_pdu *, enum iser_data_dir);
524
525 int
526 iser_create_fastreg_pool(struct ib_conn *, unsigned);
527
528 void
529 iser_free_fastreg_pool(struct ib_conn *);
530
531 int
532 iser_dma_map_task_data(struct icl_iser_pdu *,
533 struct iser_data_buf *, enum iser_data_dir,
534 enum dma_data_direction);
535
536 int
537 iser_conn_terminate(struct iser_conn *);
538
539 void
540 iser_free_ib_conn_res(struct iser_conn *, bool);
541
542 void
543 iser_dma_unmap_task_data(struct icl_iser_pdu *, struct iser_data_buf *,
544 enum dma_data_direction);
545
546 int
547 iser_cma_handler(struct rdma_cm_id *, struct rdma_cm_event *);
548
549 #endif /* !ICL_ISER_H */
Cache object: 24dd437730e5427c87a100bd586d1fbe
|