1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3 * Copyright (c) 2025 Stefan Metzmacher
4 */
5
6 #ifndef __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__
7 #define __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__
8
9 #include <rdma/rw.h>
10
11 enum smbdirect_socket_status {
12 SMBDIRECT_SOCKET_CREATED,
13 SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED,
14 SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING,
15 SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED,
16 SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED,
17 SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING,
18 SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED,
19 SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED,
20 SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING,
21 SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED,
22 SMBDIRECT_SOCKET_NEGOTIATE_NEEDED,
23 SMBDIRECT_SOCKET_NEGOTIATE_RUNNING,
24 SMBDIRECT_SOCKET_NEGOTIATE_FAILED,
25 SMBDIRECT_SOCKET_CONNECTED,
26 SMBDIRECT_SOCKET_ERROR,
27 SMBDIRECT_SOCKET_DISCONNECTING,
28 SMBDIRECT_SOCKET_DISCONNECTED,
29 SMBDIRECT_SOCKET_DESTROYED
30 };
31
32 static __always_inline
smbdirect_socket_status_string(enum smbdirect_socket_status status)33 const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
34 {
35 switch (status) {
36 case SMBDIRECT_SOCKET_CREATED:
37 return "CREATED";
38 case SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED:
39 return "RESOLVE_ADDR_NEEDED";
40 case SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING:
41 return "RESOLVE_ADDR_RUNNING";
42 case SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED:
43 return "RESOLVE_ADDR_FAILED";
44 case SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED:
45 return "RESOLVE_ROUTE_NEEDED";
46 case SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING:
47 return "RESOLVE_ROUTE_RUNNING";
48 case SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED:
49 return "RESOLVE_ROUTE_FAILED";
50 case SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED:
51 return "RDMA_CONNECT_NEEDED";
52 case SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING:
53 return "RDMA_CONNECT_RUNNING";
54 case SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED:
55 return "RDMA_CONNECT_FAILED";
56 case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
57 return "NEGOTIATE_NEEDED";
58 case SMBDIRECT_SOCKET_NEGOTIATE_RUNNING:
59 return "NEGOTIATE_RUNNING";
60 case SMBDIRECT_SOCKET_NEGOTIATE_FAILED:
61 return "NEGOTIATE_FAILED";
62 case SMBDIRECT_SOCKET_CONNECTED:
63 return "CONNECTED";
64 case SMBDIRECT_SOCKET_ERROR:
65 return "ERROR";
66 case SMBDIRECT_SOCKET_DISCONNECTING:
67 return "DISCONNECTING";
68 case SMBDIRECT_SOCKET_DISCONNECTED:
69 return "DISCONNECTED";
70 case SMBDIRECT_SOCKET_DESTROYED:
71 return "DESTROYED";
72 }
73
74 return "<unknown>";
75 }
76
77 /*
78 * This can be used with %1pe to print errors as strings or '0'
79 * And it avoids warnings like: warn: passing zero to 'ERR_PTR'
80 * from smatch -p=kernel --pedantic
81 */
82 static __always_inline
SMBDIRECT_DEBUG_ERR_PTR(long error)83 const void * __must_check SMBDIRECT_DEBUG_ERR_PTR(long error)
84 {
85 if (error == 0)
86 return NULL;
87 return ERR_PTR(error);
88 }
89
90 enum smbdirect_keepalive_status {
91 SMBDIRECT_KEEPALIVE_NONE,
92 SMBDIRECT_KEEPALIVE_PENDING,
93 SMBDIRECT_KEEPALIVE_SENT
94 };
95
96 struct smbdirect_socket {
97 enum smbdirect_socket_status status;
98 wait_queue_head_t status_wait;
99 int first_error;
100
101 /*
102 * This points to the workqueue to
103 * be used for this socket.
104 * It can be per socket (on the client)
105 * or point to a global workqueue (on the server)
106 */
107 struct workqueue_struct *workqueue;
108
109 struct work_struct disconnect_work;
110
111 /* RDMA related */
112 struct {
113 struct rdma_cm_id *cm_id;
114 /*
115 * This is for iWarp MPA v1
116 */
117 bool legacy_iwarp;
118 } rdma;
119
120 /* IB verbs related */
121 struct {
122 struct ib_pd *pd;
123 struct ib_cq *send_cq;
124 struct ib_cq *recv_cq;
125
126 /*
127 * shortcuts for rdma.cm_id->{qp,device};
128 */
129 struct ib_qp *qp;
130 struct ib_device *dev;
131 } ib;
132
133 struct smbdirect_socket_parameters parameters;
134
135 /*
136 * The state for connect/negotiation
137 */
138 struct {
139 spinlock_t lock;
140 struct work_struct work;
141 } connect;
142
143 /*
144 * The state for keepalive and timeout handling
145 */
146 struct {
147 enum smbdirect_keepalive_status keepalive;
148 struct work_struct immediate_work;
149 struct delayed_work timer_work;
150 } idle;
151
152 /*
153 * The state for posted send buffers
154 */
155 struct {
156 /*
157 * Memory pools for preallocating
158 * smbdirect_send_io buffers
159 */
160 struct {
161 struct kmem_cache *cache;
162 mempool_t *pool;
163 } mem;
164
165 /*
166 * This is a coordination for smbdirect_send_batch.
167 *
168 * There's only one possible credit, which means
169 * only one instance is running at a time.
170 */
171 struct {
172 atomic_t count;
173 wait_queue_head_t wait_queue;
174 } bcredits;
175
176 /*
177 * The local credit state for ib_post_send()
178 */
179 struct {
180 atomic_t count;
181 wait_queue_head_t wait_queue;
182 } lcredits;
183
184 /*
185 * The remote credit state for the send side
186 */
187 struct {
188 atomic_t count;
189 wait_queue_head_t wait_queue;
190 } credits;
191
192 /*
193 * The state about posted/pending sends
194 */
195 struct {
196 atomic_t count;
197 /*
198 * woken when count is decremented
199 */
200 wait_queue_head_t dec_wait_queue;
201 /*
202 * woken when count reached zero
203 */
204 wait_queue_head_t zero_wait_queue;
205 } pending;
206 } send_io;
207
208 /*
209 * The state for posted receive buffers
210 */
211 struct {
212 /*
213 * The type of PDU we are expecting
214 */
215 enum {
216 SMBDIRECT_EXPECT_NEGOTIATE_REQ = 1,
217 SMBDIRECT_EXPECT_NEGOTIATE_REP = 2,
218 SMBDIRECT_EXPECT_DATA_TRANSFER = 3,
219 } expected;
220
221 /*
222 * Memory pools for preallocating
223 * smbdirect_recv_io buffers
224 */
225 struct {
226 struct kmem_cache *cache;
227 mempool_t *pool;
228 } mem;
229
230 /*
231 * The list of free smbdirect_recv_io
232 * structures
233 */
234 struct {
235 struct list_head list;
236 spinlock_t lock;
237 } free;
238
239 /*
240 * The state for posted recv_io messages
241 * and the refill work struct.
242 */
243 struct {
244 atomic_t count;
245 struct work_struct refill_work;
246 } posted;
247
248 /*
249 * The credit state for the recv side
250 */
251 struct {
252 u16 target;
253 atomic_t available;
254 atomic_t count;
255 } credits;
256
257 /*
258 * The list of arrived non-empty smbdirect_recv_io
259 * structures
260 *
261 * This represents the reassembly queue.
262 */
263 struct {
264 struct list_head list;
265 spinlock_t lock;
266 wait_queue_head_t wait_queue;
267 /* total data length of reassembly queue */
268 int data_length;
269 int queue_length;
270 /* the offset to first buffer in reassembly queue */
271 int first_entry_offset;
272 /*
273 * Indicate if we have received a full packet on the
274 * connection This is used to identify the first SMBD
275 * packet of a assembled payload (SMB packet) in
276 * reassembly queue so we can return a RFC1002 length to
277 * upper layer to indicate the length of the SMB packet
278 * received
279 */
280 bool full_packet_received;
281 } reassembly;
282 } recv_io;
283
284 /*
285 * The state for Memory registrations on the client
286 */
287 struct {
288 enum ib_mr_type type;
289
290 /*
291 * The list of free smbdirect_mr_io
292 * structures
293 */
294 struct {
295 struct list_head list;
296 spinlock_t lock;
297 } all;
298
299 /*
300 * The number of available MRs ready for memory registration
301 */
302 struct {
303 atomic_t count;
304 wait_queue_head_t wait_queue;
305 } ready;
306
307 /*
308 * The number of used MRs
309 */
310 struct {
311 atomic_t count;
312 } used;
313
314 struct work_struct recovery_work;
315
316 /* Used by transport to wait until all MRs are returned */
317 struct {
318 wait_queue_head_t wait_queue;
319 } cleanup;
320 } mr_io;
321
322 /*
323 * The state for RDMA read/write requests on the server
324 */
325 struct {
326 /*
327 * The credit state for the send side
328 */
329 struct {
330 /*
331 * The maximum number of rw credits
332 */
333 size_t max;
334 /*
335 * The number of pages per credit
336 */
337 size_t num_pages;
338 atomic_t count;
339 wait_queue_head_t wait_queue;
340 } credits;
341 } rw_io;
342
343 /*
344 * For debug purposes
345 */
346 struct {
347 u64 get_receive_buffer;
348 u64 put_receive_buffer;
349 u64 enqueue_reassembly_queue;
350 u64 dequeue_reassembly_queue;
351 u64 send_empty;
352 } statistics;
353
354 struct {
355 #define SMBDIRECT_LOG_ERR 0x0
356 #define SMBDIRECT_LOG_INFO 0x1
357
358 #define SMBDIRECT_LOG_OUTGOING 0x1
359 #define SMBDIRECT_LOG_INCOMING 0x2
360 #define SMBDIRECT_LOG_READ 0x4
361 #define SMBDIRECT_LOG_WRITE 0x8
362 #define SMBDIRECT_LOG_RDMA_SEND 0x10
363 #define SMBDIRECT_LOG_RDMA_RECV 0x20
364 #define SMBDIRECT_LOG_KEEP_ALIVE 0x40
365 #define SMBDIRECT_LOG_RDMA_EVENT 0x80
366 #define SMBDIRECT_LOG_RDMA_MR 0x100
367 #define SMBDIRECT_LOG_RDMA_RW 0x200
368 #define SMBDIRECT_LOG_NEGOTIATE 0x400
369 void *private_ptr;
370 bool (*needed)(struct smbdirect_socket *sc,
371 void *private_ptr,
372 unsigned int lvl,
373 unsigned int cls);
374 void (*vaprintf)(struct smbdirect_socket *sc,
375 const char *func,
376 unsigned int line,
377 void *private_ptr,
378 unsigned int lvl,
379 unsigned int cls,
380 struct va_format *vaf);
381 } logging;
382 };
383
__smbdirect_socket_disabled_work(struct work_struct * work)384 static void __smbdirect_socket_disabled_work(struct work_struct *work)
385 {
386 /*
387 * Should never be called as disable_[delayed_]work_sync() was used.
388 */
389 WARN_ON_ONCE(1);
390 }
391
__smbdirect_log_needed(struct smbdirect_socket * sc,void * private_ptr,unsigned int lvl,unsigned int cls)392 static bool __smbdirect_log_needed(struct smbdirect_socket *sc,
393 void *private_ptr,
394 unsigned int lvl,
395 unsigned int cls)
396 {
397 /*
398 * Should never be called, the caller should
399 * set it's own functions.
400 */
401 WARN_ON_ONCE(1);
402 return false;
403 }
404
__smbdirect_log_vaprintf(struct smbdirect_socket * sc,const char * func,unsigned int line,void * private_ptr,unsigned int lvl,unsigned int cls,struct va_format * vaf)405 static void __smbdirect_log_vaprintf(struct smbdirect_socket *sc,
406 const char *func,
407 unsigned int line,
408 void *private_ptr,
409 unsigned int lvl,
410 unsigned int cls,
411 struct va_format *vaf)
412 {
413 /*
414 * Should never be called, the caller should
415 * set it's own functions.
416 */
417 WARN_ON_ONCE(1);
418 }
419
420 __printf(6, 7)
421 static void __smbdirect_log_printf(struct smbdirect_socket *sc,
422 const char *func,
423 unsigned int line,
424 unsigned int lvl,
425 unsigned int cls,
426 const char *fmt,
427 ...);
428 __maybe_unused
__smbdirect_log_printf(struct smbdirect_socket * sc,const char * func,unsigned int line,unsigned int lvl,unsigned int cls,const char * fmt,...)429 static void __smbdirect_log_printf(struct smbdirect_socket *sc,
430 const char *func,
431 unsigned int line,
432 unsigned int lvl,
433 unsigned int cls,
434 const char *fmt,
435 ...)
436 {
437 struct va_format vaf;
438 va_list args;
439
440 va_start(args, fmt);
441
442 vaf.fmt = fmt;
443 vaf.va = &args;
444
445 sc->logging.vaprintf(sc,
446 func,
447 line,
448 sc->logging.private_ptr,
449 lvl,
450 cls,
451 &vaf);
452 va_end(args);
453 }
454
455 #define ___smbdirect_log_generic(sc, func, line, lvl, cls, fmt, args...) do { \
456 if (sc->logging.needed(sc, sc->logging.private_ptr, lvl, cls)) { \
457 __smbdirect_log_printf(sc, func, line, lvl, cls, fmt, ##args); \
458 } \
459 } while (0)
460 #define __smbdirect_log_generic(sc, lvl, cls, fmt, args...) \
461 ___smbdirect_log_generic(sc, __func__, __LINE__, lvl, cls, fmt, ##args)
462
463 #define smbdirect_log_outgoing(sc, lvl, fmt, args...) \
464 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_OUTGOING, fmt, ##args)
465 #define smbdirect_log_incoming(sc, lvl, fmt, args...) \
466 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_INCOMING, fmt, ##args)
467 #define smbdirect_log_read(sc, lvl, fmt, args...) \
468 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_READ, fmt, ##args)
469 #define smbdirect_log_write(sc, lvl, fmt, args...) \
470 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_WRITE, fmt, ##args)
471 #define smbdirect_log_rdma_send(sc, lvl, fmt, args...) \
472 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_RDMA_SEND, fmt, ##args)
473 #define smbdirect_log_rdma_recv(sc, lvl, fmt, args...) \
474 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_RDMA_RECV, fmt, ##args)
475 #define smbdirect_log_keep_alive(sc, lvl, fmt, args...) \
476 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_KEEP_ALIVE, fmt, ##args)
477 #define smbdirect_log_rdma_event(sc, lvl, fmt, args...) \
478 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_RDMA_EVENT, fmt, ##args)
479 #define smbdirect_log_rdma_mr(sc, lvl, fmt, args...) \
480 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_RDMA_MR, fmt, ##args)
481 #define smbdirect_log_rdma_rw(sc, lvl, fmt, args...) \
482 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_RDMA_RW, fmt, ##args)
483 #define smbdirect_log_negotiate(sc, lvl, fmt, args...) \
484 __smbdirect_log_generic(sc, lvl, SMBDIRECT_LOG_NEGOTIATE, fmt, ##args)
485
smbdirect_socket_init(struct smbdirect_socket * sc)486 static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
487 {
488 /*
489 * This also sets status = SMBDIRECT_SOCKET_CREATED
490 */
491 BUILD_BUG_ON(SMBDIRECT_SOCKET_CREATED != 0);
492 memset(sc, 0, sizeof(*sc));
493
494 init_waitqueue_head(&sc->status_wait);
495
496 INIT_WORK(&sc->disconnect_work, __smbdirect_socket_disabled_work);
497 disable_work_sync(&sc->disconnect_work);
498
499 spin_lock_init(&sc->connect.lock);
500 INIT_WORK(&sc->connect.work, __smbdirect_socket_disabled_work);
501 disable_work_sync(&sc->connect.work);
502
503 INIT_WORK(&sc->idle.immediate_work, __smbdirect_socket_disabled_work);
504 disable_work_sync(&sc->idle.immediate_work);
505 INIT_DELAYED_WORK(&sc->idle.timer_work, __smbdirect_socket_disabled_work);
506 disable_delayed_work_sync(&sc->idle.timer_work);
507
508 atomic_set(&sc->send_io.bcredits.count, 0);
509 init_waitqueue_head(&sc->send_io.bcredits.wait_queue);
510
511 atomic_set(&sc->send_io.lcredits.count, 0);
512 init_waitqueue_head(&sc->send_io.lcredits.wait_queue);
513
514 atomic_set(&sc->send_io.credits.count, 0);
515 init_waitqueue_head(&sc->send_io.credits.wait_queue);
516
517 atomic_set(&sc->send_io.pending.count, 0);
518 init_waitqueue_head(&sc->send_io.pending.dec_wait_queue);
519 init_waitqueue_head(&sc->send_io.pending.zero_wait_queue);
520
521 INIT_LIST_HEAD(&sc->recv_io.free.list);
522 spin_lock_init(&sc->recv_io.free.lock);
523
524 atomic_set(&sc->recv_io.posted.count, 0);
525 INIT_WORK(&sc->recv_io.posted.refill_work, __smbdirect_socket_disabled_work);
526 disable_work_sync(&sc->recv_io.posted.refill_work);
527
528 atomic_set(&sc->recv_io.credits.available, 0);
529 atomic_set(&sc->recv_io.credits.count, 0);
530
531 INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
532 spin_lock_init(&sc->recv_io.reassembly.lock);
533 init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
534
535 atomic_set(&sc->rw_io.credits.count, 0);
536 init_waitqueue_head(&sc->rw_io.credits.wait_queue);
537
538 spin_lock_init(&sc->mr_io.all.lock);
539 INIT_LIST_HEAD(&sc->mr_io.all.list);
540 atomic_set(&sc->mr_io.ready.count, 0);
541 init_waitqueue_head(&sc->mr_io.ready.wait_queue);
542 atomic_set(&sc->mr_io.used.count, 0);
543 INIT_WORK(&sc->mr_io.recovery_work, __smbdirect_socket_disabled_work);
544 disable_work_sync(&sc->mr_io.recovery_work);
545 init_waitqueue_head(&sc->mr_io.cleanup.wait_queue);
546
547 sc->logging.private_ptr = NULL;
548 sc->logging.needed = __smbdirect_log_needed;
549 sc->logging.vaprintf = __smbdirect_log_vaprintf;
550 }
551
552 #define __SMBDIRECT_CHECK_STATUS_FAILED(__sc, __expected_status, __error_cmd, __unexpected_cmd) ({ \
553 bool __failed = false; \
554 if (unlikely((__sc)->first_error)) { \
555 __failed = true; \
556 __error_cmd \
557 } else if (unlikely((__sc)->status != (__expected_status))) { \
558 __failed = true; \
559 __unexpected_cmd \
560 } \
561 __failed; \
562 })
563
564 #define __SMBDIRECT_CHECK_STATUS_WARN(__sc, __expected_status, __unexpected_cmd) \
565 __SMBDIRECT_CHECK_STATUS_FAILED(__sc, __expected_status, \
566 { \
567 const struct sockaddr_storage *__src = NULL; \
568 const struct sockaddr_storage *__dst = NULL; \
569 if ((__sc)->rdma.cm_id) { \
570 __src = &(__sc)->rdma.cm_id->route.addr.src_addr; \
571 __dst = &(__sc)->rdma.cm_id->route.addr.dst_addr; \
572 } \
573 smbdirect_log_rdma_event(sc, SMBDIRECT_LOG_INFO, \
574 "expected[%s] != %s first_error=%1pe local=%pISpsfc remote=%pISpsfc\n", \
575 smbdirect_socket_status_string(__expected_status), \
576 smbdirect_socket_status_string((__sc)->status), \
577 SMBDIRECT_DEBUG_ERR_PTR((__sc)->first_error), \
578 __src, __dst); \
579 }, \
580 { \
581 const struct sockaddr_storage *__src = NULL; \
582 const struct sockaddr_storage *__dst = NULL; \
583 if ((__sc)->rdma.cm_id) { \
584 __src = &(__sc)->rdma.cm_id->route.addr.src_addr; \
585 __dst = &(__sc)->rdma.cm_id->route.addr.dst_addr; \
586 } \
587 smbdirect_log_rdma_event(sc, SMBDIRECT_LOG_ERR, \
588 "expected[%s] != %s first_error=%1pe local=%pISpsfc remote=%pISpsfc\n", \
589 smbdirect_socket_status_string(__expected_status), \
590 smbdirect_socket_status_string((__sc)->status), \
591 SMBDIRECT_DEBUG_ERR_PTR((__sc)->first_error), \
592 __src, __dst); \
593 WARN_ONCE(1, \
594 "expected[%s] != %s first_error=%1pe local=%pISpsfc remote=%pISpsfc\n", \
595 smbdirect_socket_status_string(__expected_status), \
596 smbdirect_socket_status_string((__sc)->status), \
597 SMBDIRECT_DEBUG_ERR_PTR((__sc)->first_error), \
598 __src, __dst); \
599 __unexpected_cmd \
600 })
601
602 #define SMBDIRECT_CHECK_STATUS_WARN(__sc, __expected_status) \
603 __SMBDIRECT_CHECK_STATUS_WARN(__sc, __expected_status, /* nothing */)
604
605 #define SMBDIRECT_CHECK_STATUS_DISCONNECT(__sc, __expected_status) \
606 __SMBDIRECT_CHECK_STATUS_WARN(__sc, __expected_status, \
607 __SMBDIRECT_SOCKET_DISCONNECT(__sc);)
608
609 struct smbdirect_send_io {
610 struct smbdirect_socket *socket;
611 struct ib_cqe cqe;
612
613 /*
614 * The SGE entries for this work request
615 *
616 * The first points to the packet header
617 */
618 #define SMBDIRECT_SEND_IO_MAX_SGE 6
619 size_t num_sge;
620 struct ib_sge sge[SMBDIRECT_SEND_IO_MAX_SGE];
621
622 /*
623 * Link to the list of sibling smbdirect_send_io
624 * messages.
625 */
626 struct list_head sibling_list;
627 struct ib_send_wr wr;
628
629 /* SMBD packet header follows this structure */
630 u8 packet[];
631 };
632
633 struct smbdirect_send_batch {
634 /*
635 * List of smbdirect_send_io messages
636 */
637 struct list_head msg_list;
638 /*
639 * Number of list entries
640 */
641 size_t wr_cnt;
642
643 /*
644 * Possible remote key invalidation state
645 */
646 bool need_invalidate_rkey;
647 u32 remote_key;
648
649 int credit;
650 };
651
652 struct smbdirect_recv_io {
653 struct smbdirect_socket *socket;
654 struct ib_cqe cqe;
655
656 /*
657 * For now we only use a single SGE
658 * as we have just one large buffer
659 * per posted recv.
660 */
661 #define SMBDIRECT_RECV_IO_MAX_SGE 1
662 struct ib_sge sge;
663
664 /* Link to free or reassembly list */
665 struct list_head list;
666
667 /* Indicate if this is the 1st packet of a payload */
668 bool first_segment;
669
670 /* SMBD packet header and payload follows this structure */
671 u8 packet[];
672 };
673
674 enum smbdirect_mr_state {
675 SMBDIRECT_MR_READY,
676 SMBDIRECT_MR_REGISTERED,
677 SMBDIRECT_MR_INVALIDATED,
678 SMBDIRECT_MR_ERROR,
679 SMBDIRECT_MR_DISABLED
680 };
681
682 struct smbdirect_mr_io {
683 struct smbdirect_socket *socket;
684 struct ib_cqe cqe;
685
686 /*
687 * We can have up to two references:
688 * 1. by the connection
689 * 2. by the registration
690 */
691 struct kref kref;
692 struct mutex mutex;
693
694 struct list_head list;
695
696 enum smbdirect_mr_state state;
697 struct ib_mr *mr;
698 struct sg_table sgt;
699 enum dma_data_direction dir;
700 union {
701 struct ib_reg_wr wr;
702 struct ib_send_wr inv_wr;
703 };
704
705 bool need_invalidate;
706 struct completion invalidate_done;
707 };
708
709 struct smbdirect_rw_io {
710 struct smbdirect_socket *socket;
711 struct ib_cqe cqe;
712
713 struct list_head list;
714
715 int error;
716 struct completion *completion;
717
718 struct rdma_rw_ctx rdma_ctx;
719 struct sg_table sgt;
720 struct scatterlist sg_list[];
721 };
722
723 #endif /* __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__ */
724