Commit | Line | Data |
---|---|---|
a42d985b BVA |
1 | /* |
2 | * Copyright (c) 2006 - 2009 Mellanox Technology Inc. All rights reserved. | |
3 | * Copyright (C) 2009 - 2010 Bart Van Assche <bvanassche@acm.org>. | |
4 | * | |
5 | * This software is available to you under a choice of one of two | |
6 | * licenses. You may choose to be licensed under the terms of the GNU | |
7 | * General Public License (GPL) Version 2, available from the file | |
8 | * COPYING in the main directory of this source tree, or the | |
9 | * OpenIB.org BSD license below: | |
10 | * | |
11 | * Redistribution and use in source and binary forms, with or | |
12 | * without modification, are permitted provided that the following | |
13 | * conditions are met: | |
14 | * | |
15 | * - Redistributions of source code must retain the above | |
16 | * copyright notice, this list of conditions and the following | |
17 | * disclaimer. | |
18 | * | |
19 | * - Redistributions in binary form must reproduce the above | |
20 | * copyright notice, this list of conditions and the following | |
21 | * disclaimer in the documentation and/or other materials | |
22 | * provided with the distribution. | |
23 | * | |
24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
25 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
26 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
27 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
28 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
29 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
30 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
31 | * SOFTWARE. | |
32 | * | |
33 | */ | |
34 | ||
35 | #ifndef IB_SRPT_H | |
36 | #define IB_SRPT_H | |
37 | ||
a42d985b BVA |
38 | #include <linux/types.h> |
39 | #include <linux/list.h> | |
40 | #include <linux/wait.h> | |
41 | ||
42 | #include <rdma/ib_verbs.h> | |
43 | #include <rdma/ib_sa.h> | |
44 | #include <rdma/ib_cm.h> | |
45 | ||
46 | #include <scsi/srp.h> | |
47 | ||
48 | #include "ib_dm_mad.h" | |
49 | ||
50 | /* | |
51 | * The prefix the ServiceName field must start with in the device management | |
52 | * ServiceEntries attribute pair. See also the SRP specification. | |
53 | */ | |
54 | #define SRP_SERVICE_NAME_PREFIX "SRP.T10:" | |
55 | ||
56 | enum { | |
57 | /* | |
58 | * SRP IOControllerProfile attributes for SRP target ports that have | |
59 | * not been defined in <scsi/srp.h>. Source: section B.7, table B.7 | |
60 | * in the SRP specification. | |
61 | */ | |
62 | SRP_PROTOCOL = 0x0108, | |
63 | SRP_PROTOCOL_VERSION = 0x0001, | |
64 | SRP_IO_SUBCLASS = 0x609e, | |
65 | SRP_SEND_TO_IOC = 0x01, | |
66 | SRP_SEND_FROM_IOC = 0x02, | |
67 | SRP_RDMA_READ_FROM_IOC = 0x08, | |
68 | SRP_RDMA_WRITE_FROM_IOC = 0x20, | |
69 | ||
70 | /* | |
71 | * srp_login_cmd.req_flags bitmasks. See also table 9 in the SRP | |
72 | * specification. | |
73 | */ | |
74 | SRP_MTCH_ACTION = 0x03, /* MULTI-CHANNEL ACTION */ | |
75 | SRP_LOSOLNT = 0x10, /* logout solicited notification */ | |
76 | SRP_CRSOLNT = 0x20, /* credit request solicited notification */ | |
77 | SRP_AESOLNT = 0x40, /* asynchronous event solicited notification */ | |
78 | ||
79 | /* | |
80 | * srp_cmd.sol_nt / srp_tsk_mgmt.sol_not bitmasks. See also tables | |
81 | * 18 and 20 in the SRP specification. | |
82 | */ | |
83 | SRP_SCSOLNT = 0x02, /* SCSOLNT = successful solicited notification */ | |
84 | SRP_UCSOLNT = 0x04, /* UCSOLNT = unsuccessful solicited notification */ | |
85 | ||
86 | /* | |
87 | * srp_rsp.sol_not / srp_t_logout.sol_not bitmasks. See also tables | |
88 | * 16 and 22 in the SRP specification. | |
89 | */ | |
90 | SRP_SOLNT = 0x01, /* SOLNT = solicited notification */ | |
91 | ||
92 | /* See also table 24 in the SRP specification. */ | |
93 | SRP_TSK_MGMT_SUCCESS = 0x00, | |
94 | SRP_TSK_MGMT_FUNC_NOT_SUPP = 0x04, | |
95 | SRP_TSK_MGMT_FAILED = 0x05, | |
96 | ||
97 | /* See also table 21 in the SRP specification. */ | |
98 | SRP_CMD_SIMPLE_Q = 0x0, | |
99 | SRP_CMD_HEAD_OF_Q = 0x1, | |
100 | SRP_CMD_ORDERED_Q = 0x2, | |
101 | SRP_CMD_ACA = 0x4, | |
102 | ||
103 | SRP_LOGIN_RSP_MULTICHAN_NO_CHAN = 0x0, | |
104 | SRP_LOGIN_RSP_MULTICHAN_TERMINATED = 0x1, | |
105 | SRP_LOGIN_RSP_MULTICHAN_MAINTAINED = 0x2, | |
106 | ||
107 | SRPT_DEF_SG_TABLESIZE = 128, | |
108 | SRPT_DEF_SG_PER_WQE = 16, | |
109 | ||
110 | MIN_SRPT_SQ_SIZE = 16, | |
111 | DEF_SRPT_SQ_SIZE = 4096, | |
112 | SRPT_RQ_SIZE = 128, | |
113 | MIN_SRPT_SRQ_SIZE = 4, | |
114 | DEFAULT_SRPT_SRQ_SIZE = 4095, | |
115 | MAX_SRPT_SRQ_SIZE = 65535, | |
116 | MAX_SRPT_RDMA_SIZE = 1U << 24, | |
117 | MAX_SRPT_RSP_SIZE = 1024, | |
118 | ||
119 | MIN_MAX_REQ_SIZE = 996, | |
120 | DEFAULT_MAX_REQ_SIZE | |
121 | = sizeof(struct srp_cmd)/*48*/ | |
122 | + sizeof(struct srp_indirect_buf)/*20*/ | |
123 | + 128 * sizeof(struct srp_direct_buf)/*16*/, | |
124 | ||
125 | MIN_MAX_RSP_SIZE = sizeof(struct srp_rsp)/*36*/ + 4, | |
126 | DEFAULT_MAX_RSP_SIZE = 256, /* leaves 220 bytes for sense data */ | |
127 | ||
128 | DEFAULT_MAX_RDMA_SIZE = 65536, | |
129 | }; | |
130 | ||
131 | enum srpt_opcode { | |
132 | SRPT_RECV, | |
133 | SRPT_SEND, | |
134 | SRPT_RDMA_MID, | |
135 | SRPT_RDMA_ABORT, | |
136 | SRPT_RDMA_READ_LAST, | |
137 | SRPT_RDMA_WRITE_LAST, | |
138 | }; | |
139 | ||
140 | static inline u64 encode_wr_id(u8 opcode, u32 idx) | |
141 | { | |
142 | return ((u64)opcode << 32) | idx; | |
143 | } | |
144 | static inline enum srpt_opcode opcode_from_wr_id(u64 wr_id) | |
145 | { | |
146 | return wr_id >> 32; | |
147 | } | |
148 | static inline u32 idx_from_wr_id(u64 wr_id) | |
149 | { | |
150 | return (u32)wr_id; | |
151 | } | |
152 | ||
153 | struct rdma_iu { | |
154 | u64 raddr; | |
155 | u32 rkey; | |
156 | struct ib_sge *sge; | |
157 | u32 sge_cnt; | |
158 | int mem_id; | |
159 | }; | |
160 | ||
161 | /** | |
162 | * enum srpt_command_state - SCSI command state managed by SRPT. | |
163 | * @SRPT_STATE_NEW: New command arrived and is being processed. | |
164 | * @SRPT_STATE_NEED_DATA: Processing a write or bidir command and waiting | |
165 | * for data arrival. | |
166 | * @SRPT_STATE_DATA_IN: Data for the write or bidir command arrived and is | |
167 | * being processed. | |
168 | * @SRPT_STATE_CMD_RSP_SENT: SRP_RSP for SRP_CMD has been sent. | |
169 | * @SRPT_STATE_MGMT: Processing a SCSI task management command. | |
170 | * @SRPT_STATE_MGMT_RSP_SENT: SRP_RSP for SRP_TSK_MGMT has been sent. | |
171 | * @SRPT_STATE_DONE: Command processing finished successfully, command | |
172 | * processing has been aborted or command processing | |
173 | * failed. | |
174 | */ | |
175 | enum srpt_command_state { | |
176 | SRPT_STATE_NEW = 0, | |
177 | SRPT_STATE_NEED_DATA = 1, | |
178 | SRPT_STATE_DATA_IN = 2, | |
179 | SRPT_STATE_CMD_RSP_SENT = 3, | |
180 | SRPT_STATE_MGMT = 4, | |
181 | SRPT_STATE_MGMT_RSP_SENT = 5, | |
182 | SRPT_STATE_DONE = 6, | |
183 | }; | |
184 | ||
185 | /** | |
186 | * struct srpt_ioctx - Shared SRPT I/O context information. | |
187 | * @buf: Pointer to the buffer. | |
188 | * @dma: DMA address of the buffer. | |
189 | * @index: Index of the I/O context in its ioctx_ring array. | |
190 | */ | |
191 | struct srpt_ioctx { | |
192 | void *buf; | |
193 | dma_addr_t dma; | |
194 | uint32_t index; | |
195 | }; | |
196 | ||
197 | /** | |
198 | * struct srpt_recv_ioctx - SRPT receive I/O context. | |
199 | * @ioctx: See above. | |
200 | * @wait_list: Node for insertion in srpt_rdma_ch.cmd_wait_list. | |
201 | */ | |
202 | struct srpt_recv_ioctx { | |
203 | struct srpt_ioctx ioctx; | |
204 | struct list_head wait_list; | |
205 | }; | |
206 | ||
207 | /** | |
208 | * struct srpt_send_ioctx - SRPT send I/O context. | |
209 | * @ioctx: See above. | |
210 | * @ch: Channel pointer. | |
211 | * @free_list: Node in srpt_rdma_ch.free_list. | |
212 | * @n_rbuf: Number of data buffers in the received SRP command. | |
213 | * @rbufs: Pointer to SRP data buffer array. | |
214 | * @single_rbuf: SRP data buffer if the command has only a single buffer. | |
215 | * @sg: Pointer to sg-list associated with this I/O context. | |
216 | * @sg_cnt: SG-list size. | |
217 | * @mapped_sg_count: ib_dma_map_sg() return value. | |
218 | * @n_rdma_ius: Number of elements in the rdma_ius array. | |
219 | * @rdma_ius: Array with information about the RDMA mapping. | |
220 | * @tag: Tag of the received SRP information unit. | |
221 | * @spinlock: Protects 'state'. | |
222 | * @state: I/O context state. | |
223 | * @rdma_aborted: If initiating a multipart RDMA transfer failed, whether | |
224 | * the already initiated transfers have finished. | |
225 | * @cmd: Target core command data structure. | |
226 | * @sense_data: SCSI sense data. | |
227 | */ | |
228 | struct srpt_send_ioctx { | |
229 | struct srpt_ioctx ioctx; | |
230 | struct srpt_rdma_ch *ch; | |
a42d985b BVA |
231 | struct rdma_iu *rdma_ius; |
232 | struct srp_direct_buf *rbufs; | |
233 | struct srp_direct_buf single_rbuf; | |
234 | struct scatterlist *sg; | |
235 | struct list_head free_list; | |
236 | spinlock_t spinlock; | |
237 | enum srpt_command_state state; | |
238 | bool rdma_aborted; | |
239 | struct se_cmd cmd; | |
240 | struct completion tx_done; | |
241 | u64 tag; | |
242 | int sg_cnt; | |
243 | int mapped_sg_count; | |
244 | u16 n_rdma_ius; | |
245 | u8 n_rdma; | |
246 | u8 n_rbuf; | |
247 | bool queue_status_only; | |
248 | u8 sense_data[SCSI_SENSE_BUFFERSIZE]; | |
249 | }; | |
250 | ||
251 | /** | |
252 | * enum rdma_ch_state - SRP channel state. | |
253 | * @CH_CONNECTING: QP is in RTR state; waiting for RTU. | |
254 | * @CH_LIVE: QP is in RTS state. | |
255 | * @CH_DISCONNECTING: DREQ has been received; waiting for DREP | |
256 | * or DREQ has been send and waiting for DREP | |
257 | * or . | |
258 | * @CH_DRAINING: QP is in ERR state; waiting for last WQE event. | |
259 | * @CH_RELEASING: Last WQE event has been received; releasing resources. | |
260 | */ | |
261 | enum rdma_ch_state { | |
262 | CH_CONNECTING, | |
263 | CH_LIVE, | |
264 | CH_DISCONNECTING, | |
265 | CH_DRAINING, | |
266 | CH_RELEASING | |
267 | }; | |
268 | ||
269 | /** | |
270 | * struct srpt_rdma_ch - RDMA channel. | |
271 | * @wait_queue: Allows the kernel thread to wait for more work. | |
272 | * @thread: Kernel thread that processes the IB queues associated with | |
273 | * the channel. | |
274 | * @cm_id: IB CM ID associated with the channel. | |
275 | * @qp: IB queue pair used for communicating over this channel. | |
276 | * @cq: IB completion queue for this channel. | |
277 | * @rq_size: IB receive queue size. | |
278 | * @rsp_size IB response message size in bytes. | |
279 | * @sq_wr_avail: number of work requests available in the send queue. | |
280 | * @sport: pointer to the information of the HCA port used by this | |
281 | * channel. | |
282 | * @i_port_id: 128-bit initiator port identifier copied from SRP_LOGIN_REQ. | |
283 | * @t_port_id: 128-bit target port identifier copied from SRP_LOGIN_REQ. | |
284 | * @max_ti_iu_len: maximum target-to-initiator information unit length. | |
285 | * @req_lim: request limit: maximum number of requests that may be sent | |
286 | * by the initiator without having received a response. | |
287 | * @req_lim_delta: Number of credits not yet sent back to the initiator. | |
288 | * @spinlock: Protects free_list and state. | |
289 | * @free_list: Head of list with free send I/O contexts. | |
290 | * @state: channel state. See also enum rdma_ch_state. | |
291 | * @ioctx_ring: Send ring. | |
292 | * @wc: IB work completion array for srpt_process_completion(). | |
293 | * @list: Node for insertion in the srpt_device.rch_list list. | |
294 | * @cmd_wait_list: List of SCSI commands that arrived before the RTU event. This | |
295 | * list contains struct srpt_ioctx elements and is protected | |
296 | * against concurrent modification by the cm_id spinlock. | |
297 | * @sess: Session information associated with this SRP channel. | |
298 | * @sess_name: Session name. | |
299 | * @release_work: Allows scheduling of srpt_release_channel(). | |
300 | * @release_done: Enables waiting for srpt_release_channel() completion. | |
301 | */ | |
302 | struct srpt_rdma_ch { | |
303 | wait_queue_head_t wait_queue; | |
304 | struct task_struct *thread; | |
305 | struct ib_cm_id *cm_id; | |
306 | struct ib_qp *qp; | |
307 | struct ib_cq *cq; | |
308 | int rq_size; | |
309 | u32 rsp_size; | |
310 | atomic_t sq_wr_avail; | |
311 | struct srpt_port *sport; | |
312 | u8 i_port_id[16]; | |
313 | u8 t_port_id[16]; | |
314 | int max_ti_iu_len; | |
315 | atomic_t req_lim; | |
316 | atomic_t req_lim_delta; | |
317 | spinlock_t spinlock; | |
318 | struct list_head free_list; | |
319 | enum rdma_ch_state state; | |
320 | struct srpt_send_ioctx **ioctx_ring; | |
321 | struct ib_wc wc[16]; | |
322 | struct list_head list; | |
323 | struct list_head cmd_wait_list; | |
324 | struct se_session *sess; | |
325 | u8 sess_name[36]; | |
326 | struct work_struct release_work; | |
327 | struct completion *release_done; | |
1d19f780 | 328 | bool in_shutdown; |
a42d985b BVA |
329 | }; |
330 | ||
331 | /** | |
332 | * struct srpt_port_attib - Attributes for SRPT port | |
333 | * @srp_max_rdma_size: Maximum size of SRP RDMA transfers for new connections. | |
334 | * @srp_max_rsp_size: Maximum size of SRP response messages in bytes. | |
335 | * @srp_sq_size: Shared receive queue (SRQ) size. | |
336 | */ | |
337 | struct srpt_port_attrib { | |
338 | u32 srp_max_rdma_size; | |
339 | u32 srp_max_rsp_size; | |
340 | u32 srp_sq_size; | |
341 | }; | |
342 | ||
343 | /** | |
344 | * struct srpt_port - Information associated by SRPT with a single IB port. | |
345 | * @sdev: backpointer to the HCA information. | |
346 | * @mad_agent: per-port management datagram processing information. | |
347 | * @enabled: Whether or not this target port is enabled. | |
348 | * @port_guid: ASCII representation of Port GUID | |
349 | * @port: one-based port number. | |
350 | * @sm_lid: cached value of the port's sm_lid. | |
351 | * @lid: cached value of the port's lid. | |
352 | * @gid: cached value of the port's gid. | |
353 | * @port_acl_lock spinlock for port_acl_list: | |
354 | * @work: work structure for refreshing the aforementioned cached values. | |
355 | * @port_tpg_1 Target portal group = 1 data. | |
356 | * @port_wwn: Target core WWN data. | |
357 | * @port_acl_list: Head of the list with all node ACLs for this port. | |
358 | */ | |
359 | struct srpt_port { | |
360 | struct srpt_device *sdev; | |
361 | struct ib_mad_agent *mad_agent; | |
362 | bool enabled; | |
363 | u8 port_guid[64]; | |
364 | u8 port; | |
365 | u16 sm_lid; | |
366 | u16 lid; | |
367 | union ib_gid gid; | |
368 | spinlock_t port_acl_lock; | |
369 | struct work_struct work; | |
370 | struct se_portal_group port_tpg_1; | |
371 | struct se_wwn port_wwn; | |
372 | struct list_head port_acl_list; | |
373 | struct srpt_port_attrib port_attrib; | |
374 | }; | |
375 | ||
376 | /** | |
377 | * struct srpt_device - Information associated by SRPT with a single HCA. | |
378 | * @device: Backpointer to the struct ib_device managed by the IB core. | |
379 | * @pd: IB protection domain. | |
380 | * @mr: L_Key (local key) with write access to all local memory. | |
381 | * @srq: Per-HCA SRQ (shared receive queue). | |
382 | * @cm_id: Connection identifier. | |
383 | * @dev_attr: Attributes of the InfiniBand device as obtained during the | |
384 | * ib_client.add() callback. | |
385 | * @srq_size: SRQ size. | |
386 | * @ioctx_ring: Per-HCA SRQ. | |
387 | * @rch_list: Per-device channel list -- see also srpt_rdma_ch.list. | |
388 | * @ch_releaseQ: Enables waiting for removal from rch_list. | |
389 | * @spinlock: Protects rch_list and tpg. | |
390 | * @port: Information about the ports owned by this HCA. | |
391 | * @event_handler: Per-HCA asynchronous IB event handler. | |
392 | * @list: Node in srpt_dev_list. | |
393 | */ | |
394 | struct srpt_device { | |
395 | struct ib_device *device; | |
396 | struct ib_pd *pd; | |
397 | struct ib_mr *mr; | |
398 | struct ib_srq *srq; | |
399 | struct ib_cm_id *cm_id; | |
400 | struct ib_device_attr dev_attr; | |
401 | int srq_size; | |
402 | struct srpt_recv_ioctx **ioctx_ring; | |
403 | struct list_head rch_list; | |
404 | wait_queue_head_t ch_releaseQ; | |
405 | spinlock_t spinlock; | |
406 | struct srpt_port port[2]; | |
407 | struct ib_event_handler event_handler; | |
408 | struct list_head list; | |
409 | }; | |
410 | ||
411 | /** | |
412 | * struct srpt_node_acl - Per-initiator ACL data (managed via configfs). | |
144bc4c2 | 413 | * @nacl: Target core node ACL information. |
a42d985b BVA |
414 | * @i_port_id: 128-bit SRP initiator port ID. |
415 | * @sport: port information. | |
a42d985b BVA |
416 | * @list: Element of the per-HCA ACL list. |
417 | */ | |
418 | struct srpt_node_acl { | |
144bc4c2 | 419 | struct se_node_acl nacl; |
a42d985b BVA |
420 | u8 i_port_id[16]; |
421 | struct srpt_port *sport; | |
a42d985b BVA |
422 | struct list_head list; |
423 | }; | |
424 | ||
425 | /* | |
426 | * SRP-releated SCSI persistent reservation definitions. | |
427 | * | |
428 | * See also SPC4r28, section 7.6.1 (Protocol specific parameters introduction). | |
429 | * See also SPC4r28, section 7.6.4.5 (TransportID for initiator ports using | |
430 | * SCSI over an RDMA interface). | |
431 | */ | |
432 | ||
433 | enum { | |
434 | SCSI_TRANSPORTID_PROTOCOLID_SRP = 4, | |
435 | }; | |
436 | ||
437 | struct spc_rdma_transport_id { | |
438 | uint8_t protocol_identifier; | |
439 | uint8_t reserved[7]; | |
440 | uint8_t i_port_id[16]; | |
441 | }; | |
442 | ||
443 | #endif /* IB_SRPT_H */ |