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 void __attribute__ ((format (printf, 1, 2)))
40rdsdebug(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_LONGS (RDS_CONG_MAP_BYTES / sizeof(unsigned long))
54#define RDS_CONG_MAP_PAGES (PAGE_ALIGN(RDS_CONG_MAP_BYTES) / PAGE_SIZE)
55#define RDS_CONG_MAP_PAGE_BITS (PAGE_SIZE * 8)
56
57struct rds_cong_map {
58 struct rb_node m_rb_node;
59 __be32 m_addr;
60 wait_queue_head_t m_waitq;
61 struct list_head m_conn_list;
62 unsigned long m_page_addrs[RDS_CONG_MAP_PAGES];
63};
64
65
66
67
68
69
70
71
72enum {
73 RDS_CONN_DOWN = 0,
74 RDS_CONN_CONNECTING,
75 RDS_CONN_DISCONNECTING,
76 RDS_CONN_UP,
77 RDS_CONN_ERROR,
78};
79
80
81#define RDS_LL_SEND_FULL 0
82#define RDS_RECONNECT_PENDING 1
83#define RDS_IN_XMIT 2
84
85struct rds_connection {
86 struct hlist_node c_hash_node;
87 __be32 c_laddr;
88 __be32 c_faddr;
89 unsigned int c_loopback:1;
90 struct rds_connection *c_passive;
91
92 struct rds_cong_map *c_lcong;
93 struct rds_cong_map *c_fcong;
94
95 struct rds_message *c_xmit_rm;
96 unsigned long c_xmit_sg;
97 unsigned int c_xmit_hdr_off;
98 unsigned int c_xmit_data_off;
99 unsigned int c_xmit_atomic_sent;
100 unsigned int c_xmit_rdma_sent;
101 unsigned int c_xmit_data_sent;
102
103 spinlock_t c_lock;
104 u64 c_next_tx_seq;
105 struct list_head c_send_queue;
106 struct list_head c_retrans;
107
108 u64 c_next_rx_seq;
109
110 struct rds_transport *c_trans;
111 void *c_transport_data;
112
113 atomic_t c_state;
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 iovec *iov,
436 size_t size);
437 void (*inc_free)(struct rds_incoming *inc);
438
439 int (*cm_handle_connect)(struct rdma_cm_id *cm_id,
440 struct rdma_cm_event *event);
441 int (*cm_initiate_connect)(struct rdma_cm_id *cm_id);
442 void (*cm_connect_complete)(struct rds_connection *conn,
443 struct rdma_cm_event *event);
444
445 unsigned int (*stats_info_copy)(struct rds_info_iterator *iter,
446 unsigned int avail);
447 void (*exit)(void);
448 void *(*get_mr)(struct scatterlist *sg, unsigned long nr_sg,
449 struct rds_sock *rs, u32 *key_ret);
450 void (*sync_mr)(void *trans_private, int direction);
451 void (*free_mr)(void *trans_private, int invalidate);
452 void (*flush_mrs)(void);
453};
454
455struct rds_sock {
456 struct sock rs_sk;
457
458 u64 rs_user_addr;
459 u64 rs_user_bytes;
460
461
462
463
464
465 struct hlist_node rs_bound_node;
466 __be32 rs_bound_addr;
467 __be32 rs_conn_addr;
468 __be16 rs_bound_port;
469 __be16 rs_conn_port;
470 struct rds_transport *rs_transport;
471
472
473
474
475
476 struct rds_connection *rs_conn;
477
478
479 int rs_congested;
480
481 int rs_seen_congestion;
482
483
484 spinlock_t rs_lock;
485 struct list_head rs_send_queue;
486 u32 rs_snd_bytes;
487 int rs_rcv_bytes;
488 struct list_head rs_notify_queue;
489
490
491
492
493
494
495 uint64_t rs_cong_mask;
496 uint64_t rs_cong_notify;
497 struct list_head rs_cong_list;
498 unsigned long rs_cong_track;
499
500
501
502
503
504 rwlock_t rs_recv_lock;
505 struct list_head rs_recv_queue;
506
507
508 struct list_head rs_item;
509
510
511 spinlock_t rs_rdma_lock;
512 struct rb_root rs_rdma_keys;
513
514
515 unsigned char rs_recverr,
516 rs_cong_monitor;
517};
518
519static inline struct rds_sock *rds_sk_to_rs(const struct sock *sk)
520{
521 return container_of(sk, struct rds_sock, rs_sk);
522}
523static inline struct sock *rds_rs_to_sk(struct rds_sock *rs)
524{
525 return &rs->rs_sk;
526}
527
528
529
530
531
532
533static inline int rds_sk_sndbuf(struct rds_sock *rs)
534{
535 return rds_rs_to_sk(rs)->sk_sndbuf / 2;
536}
537static inline int rds_sk_rcvbuf(struct rds_sock *rs)
538{
539 return rds_rs_to_sk(rs)->sk_rcvbuf / 2;
540}
541
542struct rds_statistics {
543 uint64_t s_conn_reset;
544 uint64_t s_recv_drop_bad_checksum;
545 uint64_t s_recv_drop_old_seq;
546 uint64_t s_recv_drop_no_sock;
547 uint64_t s_recv_drop_dead_sock;
548 uint64_t s_recv_deliver_raced;
549 uint64_t s_recv_delivered;
550 uint64_t s_recv_queued;
551 uint64_t s_recv_immediate_retry;
552 uint64_t s_recv_delayed_retry;
553 uint64_t s_recv_ack_required;
554 uint64_t s_recv_rdma_bytes;
555 uint64_t s_recv_ping;
556 uint64_t s_send_queue_empty;
557 uint64_t s_send_queue_full;
558 uint64_t s_send_lock_contention;
559 uint64_t s_send_lock_queue_raced;
560 uint64_t s_send_immediate_retry;
561 uint64_t s_send_delayed_retry;
562 uint64_t s_send_drop_acked;
563 uint64_t s_send_ack_required;
564 uint64_t s_send_queued;
565 uint64_t s_send_rdma;
566 uint64_t s_send_rdma_bytes;
567 uint64_t s_send_pong;
568 uint64_t s_page_remainder_hit;
569 uint64_t s_page_remainder_miss;
570 uint64_t s_copy_to_user;
571 uint64_t s_copy_from_user;
572 uint64_t s_cong_update_queued;
573 uint64_t s_cong_update_received;
574 uint64_t s_cong_send_error;
575 uint64_t s_cong_send_blocked;
576};
577
578
579char *rds_str_array(char **array, size_t elements, size_t index);
580void rds_sock_addref(struct rds_sock *rs);
581void rds_sock_put(struct rds_sock *rs);
582void rds_wake_sk_sleep(struct rds_sock *rs);
583static inline void __rds_wake_sk_sleep(struct sock *sk)
584{
585 wait_queue_head_t *waitq = sk_sleep(sk);
586
587 if (!sock_flag(sk, SOCK_DEAD) && waitq)
588 wake_up(waitq);
589}
590extern wait_queue_head_t rds_poll_waitq;
591
592
593
594int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len);
595void rds_remove_bound(struct rds_sock *rs);
596struct rds_sock *rds_find_bound(__be32 addr, __be16 port);
597
598
599int rds_cong_get_maps(struct rds_connection *conn);
600void rds_cong_add_conn(struct rds_connection *conn);
601void rds_cong_remove_conn(struct rds_connection *conn);
602void rds_cong_set_bit(struct rds_cong_map *map, __be16 port);
603void rds_cong_clear_bit(struct rds_cong_map *map, __be16 port);
604int rds_cong_wait(struct rds_cong_map *map, __be16 port, int nonblock, struct rds_sock *rs);
605void rds_cong_queue_updates(struct rds_cong_map *map);
606void rds_cong_map_updated(struct rds_cong_map *map, uint64_t);
607int rds_cong_updated_since(unsigned long *recent);
608void rds_cong_add_socket(struct rds_sock *);
609void rds_cong_remove_socket(struct rds_sock *);
610void rds_cong_exit(void);
611struct rds_message *rds_cong_update_alloc(struct rds_connection *conn);
612
613
614int rds_conn_init(void);
615void rds_conn_exit(void);
616struct rds_connection *rds_conn_create(__be32 laddr, __be32 faddr,
617 struct rds_transport *trans, gfp_t gfp);
618struct rds_connection *rds_conn_create_outgoing(__be32 laddr, __be32 faddr,
619 struct rds_transport *trans, gfp_t gfp);
620void rds_conn_shutdown(struct rds_connection *conn);
621void rds_conn_destroy(struct rds_connection *conn);
622void rds_conn_drop(struct rds_connection *conn);
623void rds_conn_connect_if_down(struct rds_connection *conn);
624void rds_for_each_conn_info(struct socket *sock, unsigned int len,
625 struct rds_info_iterator *iter,
626 struct rds_info_lengths *lens,
627 int (*visitor)(struct rds_connection *, void *),
628 size_t item_len);
629void __rds_conn_error(struct rds_connection *conn, const char *, ...)
630 __attribute__ ((format (printf, 2, 3)));
631#define rds_conn_error(conn, fmt...) \
632 __rds_conn_error(conn, KERN_WARNING "RDS: " fmt)
633
634static inline int
635rds_conn_transition(struct rds_connection *conn, int old, int new)
636{
637 return atomic_cmpxchg(&conn->c_state, old, new) == old;
638}
639
640static inline int
641rds_conn_state(struct rds_connection *conn)
642{
643 return atomic_read(&conn->c_state);
644}
645
646static inline int
647rds_conn_up(struct rds_connection *conn)
648{
649 return atomic_read(&conn->c_state) == RDS_CONN_UP;
650}
651
652static inline int
653rds_conn_connecting(struct rds_connection *conn)
654{
655 return atomic_read(&conn->c_state) == RDS_CONN_CONNECTING;
656}
657
658
659struct rds_message *rds_message_alloc(unsigned int nents, gfp_t gfp);
660struct scatterlist *rds_message_alloc_sgs(struct rds_message *rm, int nents);
661int rds_message_copy_from_user(struct rds_message *rm, struct iovec *first_iov,
662 size_t total_len);
663struct rds_message *rds_message_map_pages(unsigned long *page_addrs, unsigned int total_len);
664void rds_message_populate_header(struct rds_header *hdr, __be16 sport,
665 __be16 dport, u64 seq);
666int rds_message_add_extension(struct rds_header *hdr,
667 unsigned int type, const void *data, unsigned int len);
668int rds_message_next_extension(struct rds_header *hdr,
669 unsigned int *pos, void *buf, unsigned int *buflen);
670int rds_message_add_rdma_dest_extension(struct rds_header *hdr, u32 r_key, u32 offset);
671int rds_message_inc_copy_to_user(struct rds_incoming *inc,
672 struct iovec *first_iov, size_t size);
673void rds_message_inc_free(struct rds_incoming *inc);
674void rds_message_addref(struct rds_message *rm);
675void rds_message_put(struct rds_message *rm);
676void rds_message_wait(struct rds_message *rm);
677void rds_message_unmapped(struct rds_message *rm);
678
679static inline void rds_message_make_checksum(struct rds_header *hdr)
680{
681 hdr->h_csum = 0;
682 hdr->h_csum = ip_fast_csum((void *) hdr, sizeof(*hdr) >> 2);
683}
684
685static inline int rds_message_verify_checksum(const struct rds_header *hdr)
686{
687 return !hdr->h_csum || ip_fast_csum((void *) hdr, sizeof(*hdr) >> 2) == 0;
688}
689
690
691
692int rds_page_remainder_alloc(struct scatterlist *scat, unsigned long bytes,
693 gfp_t gfp);
694int rds_page_copy_user(struct page *page, unsigned long offset,
695 void __user *ptr, unsigned long bytes,
696 int to_user);
697#define rds_page_copy_to_user(page, offset, ptr, bytes) \
698 rds_page_copy_user(page, offset, ptr, bytes, 1)
699#define rds_page_copy_from_user(page, offset, ptr, bytes) \
700 rds_page_copy_user(page, offset, ptr, bytes, 0)
701void rds_page_exit(void);
702
703
704void rds_inc_init(struct rds_incoming *inc, struct rds_connection *conn,
705 __be32 saddr);
706void rds_inc_put(struct rds_incoming *inc);
707void rds_recv_incoming(struct rds_connection *conn, __be32 saddr, __be32 daddr,
708 struct rds_incoming *inc, gfp_t gfp, enum km_type km);
709int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
710 size_t size, int msg_flags);
711void rds_clear_recv_queue(struct rds_sock *rs);
712int rds_notify_queue_get(struct rds_sock *rs, struct msghdr *msg);
713void rds_inc_info_copy(struct rds_incoming *inc,
714 struct rds_info_iterator *iter,
715 __be32 saddr, __be32 daddr, int flip);
716
717
718int rds_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
719 size_t payload_len);
720void rds_send_reset(struct rds_connection *conn);
721int rds_send_xmit(struct rds_connection *conn);
722struct sockaddr_in;
723void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest);
724typedef int (*is_acked_func)(struct rds_message *rm, uint64_t ack);
725void rds_send_drop_acked(struct rds_connection *conn, u64 ack,
726 is_acked_func is_acked);
727int rds_send_pong(struct rds_connection *conn, __be16 dport);
728struct rds_message *rds_send_get_message(struct rds_connection *,
729 struct rm_rdma_op *);
730
731
732void rds_rdma_unuse(struct rds_sock *rs, u32 r_key, int force);
733int rds_get_mr(struct rds_sock *rs, char __user *optval, int optlen);
734int rds_get_mr_for_dest(struct rds_sock *rs, char __user *optval, int optlen);
735int rds_free_mr(struct rds_sock *rs, char __user *optval, int optlen);
736void rds_rdma_drop_keys(struct rds_sock *rs);
737int rds_rdma_extra_size(struct rds_rdma_args *args);
738int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
739 struct cmsghdr *cmsg);
740int rds_cmsg_rdma_dest(struct rds_sock *rs, struct rds_message *rm,
741 struct cmsghdr *cmsg);
742int rds_cmsg_rdma_args(struct rds_sock *rs, struct rds_message *rm,
743 struct cmsghdr *cmsg);
744int rds_cmsg_rdma_map(struct rds_sock *rs, struct rds_message *rm,
745 struct cmsghdr *cmsg);
746void rds_rdma_free_op(struct rm_rdma_op *ro);
747void rds_atomic_free_op(struct rm_atomic_op *ao);
748void rds_rdma_send_complete(struct rds_message *rm, int wc_status);
749void rds_atomic_send_complete(struct rds_message *rm, int wc_status);
750int rds_cmsg_atomic(struct rds_sock *rs, struct rds_message *rm,
751 struct cmsghdr *cmsg);
752
753extern void __rds_put_mr_final(struct rds_mr *mr);
754static inline void rds_mr_put(struct rds_mr *mr)
755{
756 if (atomic_dec_and_test(&mr->r_refcount))
757 __rds_put_mr_final(mr);
758}
759
760
761DECLARE_PER_CPU_SHARED_ALIGNED(struct rds_statistics, rds_stats);
762#define rds_stats_inc_which(which, member) do { \
763 per_cpu(which, get_cpu()).member++; \
764 put_cpu(); \
765} while (0)
766#define rds_stats_inc(member) rds_stats_inc_which(rds_stats, member)
767#define rds_stats_add_which(which, member, count) do { \
768 per_cpu(which, get_cpu()).member += count; \
769 put_cpu(); \
770} while (0)
771#define rds_stats_add(member, count) rds_stats_add_which(rds_stats, member, count)
772int rds_stats_init(void);
773void rds_stats_exit(void);
774void rds_stats_info_copy(struct rds_info_iterator *iter,
775 uint64_t *values, const char *const *names,
776 size_t nr);
777
778
779int rds_sysctl_init(void);
780void rds_sysctl_exit(void);
781extern unsigned long rds_sysctl_sndbuf_min;
782extern unsigned long rds_sysctl_sndbuf_default;
783extern unsigned long rds_sysctl_sndbuf_max;
784extern unsigned long rds_sysctl_reconnect_min_jiffies;
785extern unsigned long rds_sysctl_reconnect_max_jiffies;
786extern unsigned int rds_sysctl_max_unacked_packets;
787extern unsigned int rds_sysctl_max_unacked_bytes;
788extern unsigned int rds_sysctl_ping_enable;
789extern unsigned long rds_sysctl_trace_flags;
790extern unsigned int rds_sysctl_trace_level;
791
792
793int rds_threads_init(void);
794void rds_threads_exit(void);
795extern struct workqueue_struct *rds_wq;
796void rds_queue_reconnect(struct rds_connection *conn);
797void rds_connect_worker(struct work_struct *);
798void rds_shutdown_worker(struct work_struct *);
799void rds_send_worker(struct work_struct *);
800void rds_recv_worker(struct work_struct *);
801void rds_connect_complete(struct rds_connection *conn);
802
803
804int rds_trans_register(struct rds_transport *trans);
805void rds_trans_unregister(struct rds_transport *trans);
806struct rds_transport *rds_trans_get_preferred(__be32 addr);
807void rds_trans_put(struct rds_transport *trans);
808unsigned int rds_trans_stats_info_copy(struct rds_info_iterator *iter,
809 unsigned int avail);
810int rds_trans_init(void);
811void rds_trans_exit(void);
812
813#endif
814