1#ifndef _RDS_RDS_H
2#define _RDS_RDS_H
3
4#include <net/sock.h>
5#include <linux/scatterlist.h>
6#include <linux/highmem.h>
7#include <rdma/rdma_cm.h>
8#include <linux/mutex.h>
9#include <linux/rds.h>
10
11#include "info.h"
12
13
14
15
16#define RDS_PROTOCOL_3_0 0x0300
17#define RDS_PROTOCOL_3_1 0x0301
18#define RDS_PROTOCOL_VERSION RDS_PROTOCOL_3_1
19#define RDS_PROTOCOL_MAJOR(v) ((v) >> 8)
20#define RDS_PROTOCOL_MINOR(v) ((v) & 255)
21#define RDS_PROTOCOL(maj, min) (((maj) << 8) | min)
22
23
24
25
26
27
28
29#define RDS_PORT 18634
30
31#ifdef ATOMIC64_INIT
32#define KERNEL_HAS_ATOMIC64
33#endif
34
35#ifdef DEBUG
36#define rdsdebug(fmt, args...) pr_debug("%s(): " fmt, __func__ , ##args)
37#else
38
39static inline __printf(1, 2)
40void rdsdebug(char *fmt, ...)
41{
42}
43#endif
44
45
46#define ceil(x, y) \
47 ({ unsigned long __x = (x), __y = (y); (__x + __y - 1) / __y; })
48
49#define RDS_FRAG_SHIFT 12
50#define RDS_FRAG_SIZE ((unsigned int)(1 << RDS_FRAG_SHIFT))
51
52#define RDS_CONG_MAP_BYTES (65536 / 8)
53#define RDS_CONG_MAP_PAGES (PAGE_ALIGN(RDS_CONG_MAP_BYTES) / PAGE_SIZE)
54#define RDS_CONG_MAP_PAGE_BITS (PAGE_SIZE * 8)
55
56struct rds_cong_map {
57 struct rb_node m_rb_node;
58 __be32 m_addr;
59 wait_queue_head_t m_waitq;
60 struct list_head m_conn_list;
61 unsigned long m_page_addrs[RDS_CONG_MAP_PAGES];
62};
63
64
65
66
67
68
69
70
71enum {
72 RDS_CONN_DOWN = 0,
73 RDS_CONN_CONNECTING,
74 RDS_CONN_DISCONNECTING,
75 RDS_CONN_UP,
76 RDS_CONN_ERROR,
77};
78
79
80#define RDS_LL_SEND_FULL 0
81#define RDS_RECONNECT_PENDING 1
82#define RDS_IN_XMIT 2
83
84struct rds_connection {
85 struct hlist_node c_hash_node;
86 __be32 c_laddr;
87 __be32 c_faddr;
88 unsigned int c_loopback:1;
89 struct rds_connection *c_passive;
90
91 struct rds_cong_map *c_lcong;
92 struct rds_cong_map *c_fcong;
93
94 struct rds_message *c_xmit_rm;
95 unsigned long c_xmit_sg;
96 unsigned int c_xmit_hdr_off;
97 unsigned int c_xmit_data_off;
98 unsigned int c_xmit_atomic_sent;
99 unsigned int c_xmit_rdma_sent;
100 unsigned int c_xmit_data_sent;
101
102 spinlock_t c_lock;
103 u64 c_next_tx_seq;
104 struct list_head c_send_queue;
105 struct list_head c_retrans;
106
107 u64 c_next_rx_seq;
108
109 struct rds_transport *c_trans;
110 void *c_transport_data;
111
112 atomic_t c_state;
113 unsigned long c_send_gen;
114 unsigned long c_flags;
115 unsigned long c_reconnect_jiffies;
116 struct delayed_work c_send_w;
117 struct delayed_work c_recv_w;
118 struct delayed_work c_conn_w;
119 struct work_struct c_down_w;
120 struct mutex c_cm_lock;
121 wait_queue_head_t c_waitq;
122
123 struct list_head c_map_item;
124 unsigned long c_map_queued;
125
126 unsigned int c_unacked_packets;
127 unsigned int c_unacked_bytes;
128
129
130 unsigned int c_version;
131};
132
133#define RDS_FLAG_CONG_BITMAP 0x01
134#define RDS_FLAG_ACK_REQUIRED 0x02
135#define RDS_FLAG_RETRANSMITTED 0x04
136#define RDS_MAX_ADV_CREDIT 255
137
138
139
140
141#define RDS_HEADER_EXT_SPACE 16
142
143struct rds_header {
144 __be64 h_sequence;
145 __be64 h_ack;
146 __be32 h_len;
147 __be16 h_sport;
148 __be16 h_dport;
149 u8 h_flags;
150 u8 h_credit;
151 u8 h_padding[4];
152 __sum16 h_csum;
153
154 u8 h_exthdr[RDS_HEADER_EXT_SPACE];
155};
156
157
158
159
160#define RDS_EXTHDR_NONE 0
161
162
163
164
165
166
167
168
169
170
171
172#define RDS_EXTHDR_VERSION 1
173struct rds_ext_header_version {
174 __be32 h_version;
175};
176
177
178
179
180
181#define RDS_EXTHDR_RDMA 2
182struct rds_ext_header_rdma {
183 __be32 h_rdma_rkey;
184};
185
186
187
188
189
190
191#define RDS_EXTHDR_RDMA_DEST 3
192struct rds_ext_header_rdma_dest {
193 __be32 h_rdma_rkey;
194 __be32 h_rdma_offset;
195};
196
197#define __RDS_EXTHDR_MAX 16
198
199struct rds_incoming {
200 atomic_t i_refcount;
201 struct list_head i_item;
202 struct rds_connection *i_conn;
203 struct rds_header i_hdr;
204 unsigned long i_rx_jiffies;
205 __be32 i_saddr;
206
207 rds_rdma_cookie_t i_rdma_cookie;
208};
209
210struct rds_mr {
211 struct rb_node r_rb_node;
212 atomic_t r_refcount;
213 u32 r_key;
214
215
216 unsigned int r_use_once:1;
217 unsigned int r_invalidate:1;
218 unsigned int r_write:1;
219
220
221
222
223
224 unsigned long r_state;
225 struct rds_sock *r_sock;
226 struct rds_transport *r_trans;
227 void *r_trans_private;
228};
229
230
231#define RDS_MR_DEAD 0
232
233static inline rds_rdma_cookie_t rds_rdma_make_cookie(u32 r_key, u32 offset)
234{
235 return r_key | (((u64) offset) << 32);
236}
237
238static inline u32 rds_rdma_cookie_key(rds_rdma_cookie_t cookie)
239{
240 return cookie;
241}
242
243static inline u32 rds_rdma_cookie_offset(rds_rdma_cookie_t cookie)
244{
245 return cookie >> 32;
246}
247
248
249#define RDS_ATOMIC_TYPE_CSWP 0
250#define RDS_ATOMIC_TYPE_FADD 1
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281#define RDS_MSG_ON_SOCK 1
282#define RDS_MSG_ON_CONN 2
283#define RDS_MSG_HAS_ACK_SEQ 3
284#define RDS_MSG_ACK_REQUIRED 4
285#define RDS_MSG_RETRANSMITTED 5
286#define RDS_MSG_MAPPED 6
287#define RDS_MSG_PAGEVEC 7
288
289struct rds_message {
290 atomic_t m_refcount;
291 struct list_head m_sock_item;
292 struct list_head m_conn_item;
293 struct rds_incoming m_inc;
294 u64 m_ack_seq;
295 __be32 m_daddr;
296 unsigned long m_flags;
297
298
299
300
301
302
303 spinlock_t m_rs_lock;
304 wait_queue_head_t m_flush_wait;
305
306 struct rds_sock *m_rs;
307
308
309 rds_rdma_cookie_t m_rdma_cookie;
310
311 unsigned int m_used_sgs;
312 unsigned int m_total_sgs;
313
314 void *m_final_op;
315
316 struct {
317 struct rm_atomic_op {
318 int op_type;
319 union {
320 struct {
321 uint64_t compare;
322 uint64_t swap;
323 uint64_t compare_mask;
324 uint64_t swap_mask;
325 } op_m_cswp;
326 struct {
327 uint64_t add;
328 uint64_t nocarry_mask;
329 } op_m_fadd;
330 };
331
332 u32 op_rkey;
333 u64 op_remote_addr;
334 unsigned int op_notify:1;
335 unsigned int op_recverr:1;
336 unsigned int op_mapped:1;
337 unsigned int op_silent:1;
338 unsigned int op_active:1;
339 struct scatterlist *op_sg;
340 struct rds_notifier *op_notifier;
341
342 struct rds_mr *op_rdma_mr;
343 } atomic;
344 struct rm_rdma_op {
345 u32 op_rkey;
346 u64 op_remote_addr;
347 unsigned int op_write:1;
348 unsigned int op_fence:1;
349 unsigned int op_notify:1;
350 unsigned int op_recverr:1;
351 unsigned int op_mapped:1;
352 unsigned int op_silent:1;
353 unsigned int op_active:1;
354 unsigned int op_bytes;
355 unsigned int op_nents;
356 unsigned int op_count;
357 struct scatterlist *op_sg;
358 struct rds_notifier *op_notifier;
359
360 struct rds_mr *op_rdma_mr;
361 } rdma;
362 struct rm_data_op {
363 unsigned int op_active:1;
364 unsigned int op_nents;
365 unsigned int op_count;
366 struct scatterlist *op_sg;
367 } data;
368 };
369};
370
371
372
373
374
375
376
377
378struct rds_notifier {
379 struct list_head n_list;
380 uint64_t n_user_token;
381 int n_status;
382};
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411#define RDS_TRANS_IB 0
412#define RDS_TRANS_IWARP 1
413#define RDS_TRANS_TCP 2
414#define RDS_TRANS_COUNT 3
415
416struct rds_transport {
417 char t_name[TRANSNAMSIZ];
418 struct list_head t_item;
419 struct module *t_owner;
420 unsigned int t_prefer_loopback:1;
421 unsigned int t_type;
422
423 int (*laddr_check)(__be32 addr);
424 int (*conn_alloc)(struct rds_connection *conn, gfp_t gfp);
425 void (*conn_free)(void *data);
426 int (*conn_connect)(struct rds_connection *conn);
427 void (*conn_shutdown)(struct rds_connection *conn);
428 void (*xmit_prepare)(struct rds_connection *conn);
429 void (*xmit_complete)(struct rds_connection *conn);
430 int (*xmit)(struct rds_connection *conn, struct rds_message *rm,
431 unsigned int hdr_off, unsigned int sg, unsigned int off);
432 int (*xmit_rdma)(struct rds_connection *conn, struct rm_rdma_op *op);
433 int (*xmit_atomic)(struct rds_connection *conn, struct rm_atomic_op *op);
434 int (*recv)(struct rds_connection *conn);
435 int (*inc_copy_to_user)(struct rds_incoming *inc, struct iov_iter *to);
436 void (*inc_free)(struct rds_incoming *inc);
437
438 int (*cm_handle_connect)(struct rdma_cm_id *cm_id,
439 struct rdma_cm_event *event);
440 int (*cm_initiate_connect)(struct rdma_cm_id *cm_id);
441 void (*cm_connect_complete)(struct rds_connection *conn,
442 struct rdma_cm_event *event);
443
444 unsigned int (*stats_info_copy)(struct rds_info_iterator *iter,
445 unsigned int avail);
446 void (*exit)(void);
447 void *(*get_mr)(struct scatterlist *sg, unsigned long nr_sg,
448 struct rds_sock *rs, u32 *key_ret);
449 void (*sync_mr)(void *trans_private, int direction);
450 void (*free_mr)(void *trans_private, int invalidate);
451 void (*flush_mrs)(void);
452};
453
454struct rds_sock {
455 struct sock rs_sk;
456
457 u64 rs_user_addr;
458 u64 rs_user_bytes;
459
460
461
462
463
464 struct hlist_node rs_bound_node;
465 __be32 rs_bound_addr;
466 __be32 rs_conn_addr;
467 __be16 rs_bound_port;
468 __be16 rs_conn_port;
469 struct rds_transport *rs_transport;
470
471
472
473
474
475 struct rds_connection *rs_conn;
476
477
478 int rs_congested;
479
480 int rs_seen_congestion;
481
482
483 spinlock_t rs_lock;
484 struct list_head rs_send_queue;
485 u32 rs_snd_bytes;
486 int rs_rcv_bytes;
487 struct list_head rs_notify_queue;
488
489
490
491
492
493
494 uint64_t rs_cong_mask;
495 uint64_t rs_cong_notify;
496 struct list_head rs_cong_list;
497 unsigned long rs_cong_track;
498
499
500
501
502
503 rwlock_t rs_recv_lock;
504 struct list_head rs_recv_queue;
505
506
507 struct list_head rs_item;
508
509
510 spinlock_t rs_rdma_lock;
511 struct rb_root rs_rdma_keys;
512
513
514 unsigned char rs_recverr,
515 rs_cong_monitor;
516};
517
518static inline struct rds_sock *rds_sk_to_rs(const struct sock *sk)
519{
520 return container_of(sk, struct rds_sock, rs_sk);
521}
522static inline struct sock *rds_rs_to_sk(struct rds_sock *rs)
523{
524 return &rs->rs_sk;
525}
526
527
528
529
530
531
532static inline int rds_sk_sndbuf(struct rds_sock *rs)
533{
534 return rds_rs_to_sk(rs)->sk_sndbuf / 2;
535}
536static inline int rds_sk_rcvbuf(struct rds_sock *rs)
537{
538 return rds_rs_to_sk(rs)->sk_rcvbuf / 2;
539}
540
541struct rds_statistics {
542 uint64_t s_conn_reset;
543 uint64_t s_recv_drop_bad_checksum;
544 uint64_t s_recv_drop_old_seq;
545 uint64_t s_recv_drop_no_sock;
546 uint64_t s_recv_drop_dead_sock;
547 uint64_t s_recv_deliver_raced;
548 uint64_t s_recv_delivered;
549 uint64_t s_recv_queued;
550 uint64_t s_recv_immediate_retry;
551 uint64_t s_recv_delayed_retry;
552 uint64_t s_recv_ack_required;
553 uint64_t s_recv_rdma_bytes;
554 uint64_t s_recv_ping;
555 uint64_t s_send_queue_empty;
556 uint64_t s_send_queue_full;
557 uint64_t s_send_lock_contention;
558 uint64_t s_send_lock_queue_raced;
559 uint64_t s_send_immediate_retry;
560 uint64_t s_send_delayed_retry;
561 uint64_t s_send_drop_acked;
562 uint64_t s_send_ack_required;
563 uint64_t s_send_queued;
564 uint64_t s_send_rdma;
565 uint64_t s_send_rdma_bytes;
566 uint64_t s_send_pong;
567 uint64_t s_page_remainder_hit;
568 uint64_t s_page_remainder_miss;
569 uint64_t s_copy_to_user;
570 uint64_t s_copy_from_user;
571 uint64_t s_cong_update_queued;
572 uint64_t s_cong_update_received;
573 uint64_t s_cong_send_error;
574 uint64_t s_cong_send_blocked;
575};
576
577
578char *rds_str_array(char **array, size_t elements, size_t index);
579void rds_sock_addref(struct rds_sock *rs);
580void rds_sock_put(struct rds_sock *rs);
581void rds_wake_sk_sleep(struct rds_sock *rs);
582static inline void __rds_wake_sk_sleep(struct sock *sk)
583{
584 wait_queue_head_t *waitq = sk_sleep(sk);
585
586 if (!sock_flag(sk, SOCK_DEAD) && waitq)
587 wake_up(waitq);
588}
589extern wait_queue_head_t rds_poll_waitq;
590
591
592
593int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len);
594void rds_remove_bound(struct rds_sock *rs);
595struct rds_sock *rds_find_bound(__be32 addr, __be16 port);
596
597
598int rds_cong_get_maps(struct rds_connection *conn);
599void rds_cong_add_conn(struct rds_connection *conn);
600void rds_cong_remove_conn(struct rds_connection *conn);
601void rds_cong_set_bit(struct rds_cong_map *map, __be16 port);
602void rds_cong_clear_bit(struct rds_cong_map *map, __be16 port);
603int rds_cong_wait(struct rds_cong_map *map, __be16 port, int nonblock, struct rds_sock *rs);
604void rds_cong_queue_updates(struct rds_cong_map *map);
605void rds_cong_map_updated(struct rds_cong_map *map, uint64_t);
606int rds_cong_updated_since(unsigned long *recent);
607void rds_cong_add_socket(struct rds_sock *);
608void rds_cong_remove_socket(struct rds_sock *);
609void rds_cong_exit(void);
610struct rds_message *rds_cong_update_alloc(struct rds_connection *conn);
611
612
613int rds_conn_init(void);
614void rds_conn_exit(void);
615struct rds_connection *rds_conn_create(__be32 laddr, __be32 faddr,
616 struct rds_transport *trans, gfp_t gfp);
617struct rds_connection *rds_conn_create_outgoing(__be32 laddr, __be32 faddr,
618 struct rds_transport *trans, gfp_t gfp);
619void rds_conn_shutdown(struct rds_connection *conn);
620void rds_conn_destroy(struct rds_connection *conn);
621void rds_conn_drop(struct rds_connection *conn);
622void rds_conn_connect_if_down(struct rds_connection *conn);
623void rds_for_each_conn_info(struct socket *sock, unsigned int len,
624 struct rds_info_iterator *iter,
625 struct rds_info_lengths *lens,
626 int (*visitor)(struct rds_connection *, void *),
627 size_t item_len);
628__printf(2, 3)
629void __rds_conn_error(struct rds_connection *conn, const char *, ...);
630#define rds_conn_error(conn, fmt...) \
631 __rds_conn_error(conn, KERN_WARNING "RDS: " fmt)
632
633static inline int
634rds_conn_transition(struct rds_connection *conn, int old, int new)
635{
636 return atomic_cmpxchg(&conn->c_state, old, new) == old;
637}
638
639static inline int
640rds_conn_state(struct rds_connection *conn)
641{
642 return atomic_read(&conn->c_state);
643}
644
645static inline int
646rds_conn_up(struct rds_connection *conn)
647{
648 return atomic_read(&conn->c_state) == RDS_CONN_UP;
649}
650
651static inline int
652rds_conn_connecting(struct rds_connection *conn)
653{
654 return atomic_read(&conn->c_state) == RDS_CONN_CONNECTING;
655}
656
657
658struct rds_message *rds_message_alloc(unsigned int nents, gfp_t gfp);
659struct scatterlist *rds_message_alloc_sgs(struct rds_message *rm, int nents);
660int rds_message_copy_from_user(struct rds_message *rm, struct iov_iter *from);
661struct rds_message *rds_message_map_pages(unsigned long *page_addrs, unsigned int total_len);
662void rds_message_populate_header(struct rds_header *hdr, __be16 sport,
663 __be16 dport, u64 seq);
664int rds_message_add_extension(struct rds_header *hdr,
665 unsigned int type, const void *data, unsigned int len);
666int rds_message_next_extension(struct rds_header *hdr,
667 unsigned int *pos, void *buf, unsigned int *buflen);
668int rds_message_add_rdma_dest_extension(struct rds_header *hdr, u32 r_key, u32 offset);
669int rds_message_inc_copy_to_user(struct rds_incoming *inc, struct iov_iter *to);
670void rds_message_inc_free(struct rds_incoming *inc);
671void rds_message_addref(struct rds_message *rm);
672void rds_message_put(struct rds_message *rm);
673void rds_message_wait(struct rds_message *rm);
674void rds_message_unmapped(struct rds_message *rm);
675
676static inline void rds_message_make_checksum(struct rds_header *hdr)
677{
678 hdr->h_csum = 0;
679 hdr->h_csum = ip_fast_csum((void *) hdr, sizeof(*hdr) >> 2);
680}
681
682static inline int rds_message_verify_checksum(const struct rds_header *hdr)
683{
684 return !hdr->h_csum || ip_fast_csum((void *) hdr, sizeof(*hdr) >> 2) == 0;
685}
686
687
688
689int rds_page_remainder_alloc(struct scatterlist *scat, unsigned long bytes,
690 gfp_t gfp);
691int rds_page_copy_user(struct page *page, unsigned long offset,
692 void __user *ptr, unsigned long bytes,
693 int to_user);
694#define rds_page_copy_to_user(page, offset, ptr, bytes) \
695 rds_page_copy_user(page, offset, ptr, bytes, 1)
696#define rds_page_copy_from_user(page, offset, ptr, bytes) \
697 rds_page_copy_user(page, offset, ptr, bytes, 0)
698void rds_page_exit(void);
699
700
701void rds_inc_init(struct rds_incoming *inc, struct rds_connection *conn,
702 __be32 saddr);
703void rds_inc_put(struct rds_incoming *inc);
704void rds_recv_incoming(struct rds_connection *conn, __be32 saddr, __be32 daddr,
705 struct rds_incoming *inc, gfp_t gfp);
706int rds_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
707 int msg_flags);
708void rds_clear_recv_queue(struct rds_sock *rs);
709int rds_notify_queue_get(struct rds_sock *rs, struct msghdr *msg);
710void rds_inc_info_copy(struct rds_incoming *inc,
711 struct rds_info_iterator *iter,
712 __be32 saddr, __be32 daddr, int flip);
713
714
715int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len);
716void rds_send_reset(struct rds_connection *conn);
717int rds_send_xmit(struct rds_connection *conn);
718struct sockaddr_in;
719void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest);
720typedef int (*is_acked_func)(struct rds_message *rm, uint64_t ack);
721void rds_send_drop_acked(struct rds_connection *conn, u64 ack,
722 is_acked_func is_acked);
723int rds_send_pong(struct rds_connection *conn, __be16 dport);
724struct rds_message *rds_send_get_message(struct rds_connection *,
725 struct rm_rdma_op *);
726
727
728void rds_rdma_unuse(struct rds_sock *rs, u32 r_key, int force);
729int rds_get_mr(struct rds_sock *rs, char __user *optval, int optlen);
730int rds_get_mr_for_dest(struct rds_sock *rs, char __user *optval, int optlen);
731int rds_free_mr(struct rds_sock *rs, char __user *optval, int optlen);
732void rds_rdma_drop_keys(struct rds_sock *rs);
733int rds_rdma_extra_size(struct rds_rdma_args *args);
734int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
735 struct cmsghdr *cmsg);
736int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
737 struct cmsghdr *cmsg);
738int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
739 struct cmsghdr *cmsg);
740int rds_cmsg_rdma_map(struct rds_sock *rs, struct rds_message *rm,
741 struct cmsghdr *cmsg);
742void rds_rdma_free_op(struct rm_rdma_op *ro);
743void rds_atomic_free_op(struct rm_atomic_op *ao);
744void rds_rdma_send_complete(struct rds_message *rm, int wc_status);
745void rds_atomic_send_complete(struct rds_message *rm, int wc_status);
746int rds_cmsg_atomic(struct rds_sock *rs, struct rds_message *rm,
747 struct cmsghdr *cmsg);
748
749void __rds_put_mr_final(struct rds_mr *mr);
750static inline void rds_mr_put(struct rds_mr *mr)
751{
752 if (atomic_dec_and_test(&mr->r_refcount))
753 __rds_put_mr_final(mr);
754}
755
756
757DECLARE_PER_CPU_SHARED_ALIGNED(struct rds_statistics, rds_stats);
758#define rds_stats_inc_which(which, member) do { \
759 per_cpu(which, get_cpu()).member++; \
760 put_cpu(); \
761} while (0)
762#define rds_stats_inc(member) rds_stats_inc_which(rds_stats, member)
763#define rds_stats_add_which(which, member, count) do { \
764 per_cpu(which, get_cpu()).member += count; \
765 put_cpu(); \
766} while (0)
767#define rds_stats_add(member, count) rds_stats_add_which(rds_stats, member, count)
768int rds_stats_init(void);
769void rds_stats_exit(void);
770void rds_stats_info_copy(struct rds_info_iterator *iter,
771 uint64_t *values, const char *const *names,
772 size_t nr);
773
774
775int rds_sysctl_init(void);
776void rds_sysctl_exit(void);
777extern unsigned long rds_sysctl_sndbuf_min;
778extern unsigned long rds_sysctl_sndbuf_default;
779extern unsigned long rds_sysctl_sndbuf_max;
780extern unsigned long rds_sysctl_reconnect_min_jiffies;
781extern unsigned long rds_sysctl_reconnect_max_jiffies;
782extern unsigned int rds_sysctl_max_unacked_packets;
783extern unsigned int rds_sysctl_max_unacked_bytes;
784extern unsigned int rds_sysctl_ping_enable;
785extern unsigned long rds_sysctl_trace_flags;
786extern unsigned int rds_sysctl_trace_level;
787
788
789int rds_threads_init(void);
790void rds_threads_exit(void);
791extern struct workqueue_struct *rds_wq;
792void rds_queue_reconnect(struct rds_connection *conn);
793void rds_connect_worker(struct work_struct *);
794void rds_shutdown_worker(struct work_struct *);
795void rds_send_worker(struct work_struct *);
796void rds_recv_worker(struct work_struct *);
797void rds_connect_complete(struct rds_connection *conn);
798
799
800int rds_trans_register(struct rds_transport *trans);
801void rds_trans_unregister(struct rds_transport *trans);
802struct rds_transport *rds_trans_get_preferred(__be32 addr);
803void rds_trans_put(struct rds_transport *trans);
804unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter,
805 unsigned int avail);
806int rds_trans_init(void);
807void rds_trans_exit(void);
808
809#endif
810