2 * Copyright (c) 2006 Oracle. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 #include <linux/module.h>
34 #include <linux/errno.h>
35 #include <linux/kernel.h>
37 #include <linux/poll.h>
43 /* this is just used for stats gathering :/ */
44 static DEFINE_SPINLOCK(rds_sock_lock
);
45 static unsigned long rds_sock_count
;
46 static LIST_HEAD(rds_sock_list
);
47 DECLARE_WAIT_QUEUE_HEAD(rds_poll_waitq
);
50 * This is called as the final descriptor referencing this socket is closed.
51 * We have to unbind the socket so that another socket can be bound to the
52 * address it was using.
54 * We have to be careful about racing with the incoming path. sock_orphan()
55 * sets SOCK_DEAD and we use that as an indicator to the rx path that new
56 * messages shouldn't be queued.
58 static int rds_release(struct socket
*sock
)
60 struct sock
*sk
= sock
->sk
;
67 rs
= rds_sk_to_rs(sk
);
70 /* Note - rds_clear_recv_queue grabs rs_recv_lock, so
71 * that ensures the recv path has completed messing
73 rds_clear_recv_queue(rs
);
74 rds_cong_remove_socket(rs
);
76 rds_send_drop_to(rs
, NULL
);
77 rds_rdma_drop_keys(rs
);
78 rds_notify_queue_get(rs
, NULL
);
80 spin_lock_irqsave(&rds_sock_lock
, flags
);
81 list_del_init(&rs
->rs_item
);
83 spin_unlock_irqrestore(&rds_sock_lock
, flags
);
92 * Careful not to race with rds_release -> sock_orphan which clears sk_sleep.
93 * _bh() isn't OK here, we're called from interrupt handlers. It's probably OK
94 * to wake the waitqueue after sk_sleep is clear as we hold a sock ref, but
95 * this seems more conservative.
96 * NB - normally, one would use sk_callback_lock for this, but we can
97 * get here from interrupts, whereas the network code grabs sk_callback_lock
98 * with _lock_bh only - so relying on sk_callback_lock introduces livelocks.
100 void rds_wake_sk_sleep(struct rds_sock
*rs
)
104 read_lock_irqsave(&rs
->rs_recv_lock
, flags
);
105 __rds_wake_sk_sleep(rds_rs_to_sk(rs
));
106 read_unlock_irqrestore(&rs
->rs_recv_lock
, flags
);
109 static int rds_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
110 int *uaddr_len
, int peer
)
112 struct sockaddr_in
*sin
= (struct sockaddr_in
*)uaddr
;
113 struct rds_sock
*rs
= rds_sk_to_rs(sock
->sk
);
115 memset(sin
->sin_zero
, 0, sizeof(sin
->sin_zero
));
117 /* racey, don't care */
119 if (!rs
->rs_conn_addr
)
122 sin
->sin_port
= rs
->rs_conn_port
;
123 sin
->sin_addr
.s_addr
= rs
->rs_conn_addr
;
125 sin
->sin_port
= rs
->rs_bound_port
;
126 sin
->sin_addr
.s_addr
= rs
->rs_bound_addr
;
129 sin
->sin_family
= AF_INET
;
131 *uaddr_len
= sizeof(*sin
);
136 * RDS' poll is without a doubt the least intuitive part of the interface,
137 * as POLLIN and POLLOUT do not behave entirely as you would expect from
138 * a network protocol.
140 * POLLIN is asserted if
141 * - there is data on the receive queue.
142 * - to signal that a previously congested destination may have become
144 * - A notification has been queued to the socket (this can be a congestion
145 * update, or a RDMA completion).
147 * POLLOUT is asserted if there is room on the send queue. This does not mean
148 * however, that the next sendmsg() call will succeed. If the application tries
149 * to send to a congested destination, the system call may still fail (and
152 static unsigned int rds_poll(struct file
*file
, struct socket
*sock
,
155 struct sock
*sk
= sock
->sk
;
156 struct rds_sock
*rs
= rds_sk_to_rs(sk
);
157 unsigned int mask
= 0;
160 poll_wait(file
, sk
->sk_sleep
, wait
);
162 poll_wait(file
, &rds_poll_waitq
, wait
);
164 read_lock_irqsave(&rs
->rs_recv_lock
, flags
);
165 if (!rs
->rs_cong_monitor
) {
166 /* When a congestion map was updated, we signal POLLIN for
167 * "historical" reasons. Applications can also poll for
169 if (rds_cong_updated_since(&rs
->rs_cong_track
))
170 mask
|= (POLLIN
| POLLRDNORM
| POLLWRBAND
);
172 spin_lock(&rs
->rs_lock
);
173 if (rs
->rs_cong_notify
)
174 mask
|= (POLLIN
| POLLRDNORM
);
175 spin_unlock(&rs
->rs_lock
);
177 if (!list_empty(&rs
->rs_recv_queue
)
178 || !list_empty(&rs
->rs_notify_queue
))
179 mask
|= (POLLIN
| POLLRDNORM
);
180 if (rs
->rs_snd_bytes
< rds_sk_sndbuf(rs
))
181 mask
|= (POLLOUT
| POLLWRNORM
);
182 read_unlock_irqrestore(&rs
->rs_recv_lock
, flags
);
187 static int rds_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
192 static int rds_cancel_sent_to(struct rds_sock
*rs
, char __user
*optval
,
195 struct sockaddr_in sin
;
198 /* racing with another thread binding seems ok here */
199 if (rs
->rs_bound_addr
== 0) {
200 ret
= -ENOTCONN
; /* XXX not a great errno */
204 if (len
< sizeof(struct sockaddr_in
)) {
209 if (copy_from_user(&sin
, optval
, sizeof(sin
))) {
214 rds_send_drop_to(rs
, &sin
);
219 static int rds_set_bool_option(unsigned char *optvar
, char __user
*optval
,
224 if (optlen
< sizeof(int))
226 if (get_user(value
, (int __user
*) optval
))
232 static int rds_cong_monitor(struct rds_sock
*rs
, char __user
*optval
,
237 ret
= rds_set_bool_option(&rs
->rs_cong_monitor
, optval
, optlen
);
239 if (rs
->rs_cong_monitor
) {
240 rds_cong_add_socket(rs
);
242 rds_cong_remove_socket(rs
);
243 rs
->rs_cong_mask
= 0;
244 rs
->rs_cong_notify
= 0;
250 static int rds_setsockopt(struct socket
*sock
, int level
, int optname
,
251 char __user
*optval
, unsigned int optlen
)
253 struct rds_sock
*rs
= rds_sk_to_rs(sock
->sk
);
256 if (level
!= SOL_RDS
) {
262 case RDS_CANCEL_SENT_TO
:
263 ret
= rds_cancel_sent_to(rs
, optval
, optlen
);
266 ret
= rds_get_mr(rs
, optval
, optlen
);
269 ret
= rds_free_mr(rs
, optval
, optlen
);
272 ret
= rds_set_bool_option(&rs
->rs_recverr
, optval
, optlen
);
274 case RDS_CONG_MONITOR
:
275 ret
= rds_cong_monitor(rs
, optval
, optlen
);
284 static int rds_getsockopt(struct socket
*sock
, int level
, int optname
,
285 char __user
*optval
, int __user
*optlen
)
287 struct rds_sock
*rs
= rds_sk_to_rs(sock
->sk
);
288 int ret
= -ENOPROTOOPT
, len
;
290 if (level
!= SOL_RDS
)
293 if (get_user(len
, optlen
)) {
299 case RDS_INFO_FIRST
... RDS_INFO_LAST
:
300 ret
= rds_info_getsockopt(sock
, optname
, optval
,
305 if (len
< sizeof(int))
308 if (put_user(rs
->rs_recverr
, (int __user
*) optval
)
309 || put_user(sizeof(int), optlen
))
323 static int rds_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
324 int addr_len
, int flags
)
326 struct sock
*sk
= sock
->sk
;
327 struct sockaddr_in
*sin
= (struct sockaddr_in
*)uaddr
;
328 struct rds_sock
*rs
= rds_sk_to_rs(sk
);
333 if (addr_len
!= sizeof(struct sockaddr_in
)) {
338 if (sin
->sin_family
!= AF_INET
) {
343 if (sin
->sin_addr
.s_addr
== htonl(INADDR_ANY
)) {
348 rs
->rs_conn_addr
= sin
->sin_addr
.s_addr
;
349 rs
->rs_conn_port
= sin
->sin_port
;
356 static struct proto rds_proto
= {
358 .owner
= THIS_MODULE
,
359 .obj_size
= sizeof(struct rds_sock
),
362 static const struct proto_ops rds_proto_ops
= {
364 .owner
= THIS_MODULE
,
365 .release
= rds_release
,
367 .connect
= rds_connect
,
368 .socketpair
= sock_no_socketpair
,
369 .accept
= sock_no_accept
,
370 .getname
= rds_getname
,
373 .listen
= sock_no_listen
,
374 .shutdown
= sock_no_shutdown
,
375 .setsockopt
= rds_setsockopt
,
376 .getsockopt
= rds_getsockopt
,
377 .sendmsg
= rds_sendmsg
,
378 .recvmsg
= rds_recvmsg
,
379 .mmap
= sock_no_mmap
,
380 .sendpage
= sock_no_sendpage
,
383 static int __rds_create(struct socket
*sock
, struct sock
*sk
, int protocol
)
388 sock_init_data(sock
, sk
);
389 sock
->ops
= &rds_proto_ops
;
390 sk
->sk_protocol
= protocol
;
392 rs
= rds_sk_to_rs(sk
);
393 spin_lock_init(&rs
->rs_lock
);
394 rwlock_init(&rs
->rs_recv_lock
);
395 INIT_LIST_HEAD(&rs
->rs_send_queue
);
396 INIT_LIST_HEAD(&rs
->rs_recv_queue
);
397 INIT_LIST_HEAD(&rs
->rs_notify_queue
);
398 INIT_LIST_HEAD(&rs
->rs_cong_list
);
399 spin_lock_init(&rs
->rs_rdma_lock
);
400 rs
->rs_rdma_keys
= RB_ROOT
;
402 spin_lock_irqsave(&rds_sock_lock
, flags
);
403 list_add_tail(&rs
->rs_item
, &rds_sock_list
);
405 spin_unlock_irqrestore(&rds_sock_lock
, flags
);
410 static int rds_create(struct net
*net
, struct socket
*sock
, int protocol
)
414 if (sock
->type
!= SOCK_SEQPACKET
|| protocol
)
415 return -ESOCKTNOSUPPORT
;
417 sk
= sk_alloc(net
, AF_RDS
, GFP_ATOMIC
, &rds_proto
);
421 return __rds_create(sock
, sk
, protocol
);
424 void rds_sock_addref(struct rds_sock
*rs
)
426 sock_hold(rds_rs_to_sk(rs
));
429 void rds_sock_put(struct rds_sock
*rs
)
431 sock_put(rds_rs_to_sk(rs
));
434 static const struct net_proto_family rds_family_ops
= {
436 .create
= rds_create
,
437 .owner
= THIS_MODULE
,
440 static void rds_sock_inc_info(struct socket
*sock
, unsigned int len
,
441 struct rds_info_iterator
*iter
,
442 struct rds_info_lengths
*lens
)
446 struct rds_incoming
*inc
;
448 unsigned int total
= 0;
450 len
/= sizeof(struct rds_info_message
);
452 spin_lock_irqsave(&rds_sock_lock
, flags
);
454 list_for_each_entry(rs
, &rds_sock_list
, rs_item
) {
455 sk
= rds_rs_to_sk(rs
);
456 read_lock(&rs
->rs_recv_lock
);
458 /* XXX too lazy to maintain counts.. */
459 list_for_each_entry(inc
, &rs
->rs_recv_queue
, i_item
) {
462 rds_inc_info_copy(inc
, iter
, inc
->i_saddr
,
463 rs
->rs_bound_addr
, 1);
466 read_unlock(&rs
->rs_recv_lock
);
469 spin_unlock_irqrestore(&rds_sock_lock
, flags
);
472 lens
->each
= sizeof(struct rds_info_message
);
475 static void rds_sock_info(struct socket
*sock
, unsigned int len
,
476 struct rds_info_iterator
*iter
,
477 struct rds_info_lengths
*lens
)
479 struct rds_info_socket sinfo
;
483 len
/= sizeof(struct rds_info_socket
);
485 spin_lock_irqsave(&rds_sock_lock
, flags
);
487 if (len
< rds_sock_count
)
490 list_for_each_entry(rs
, &rds_sock_list
, rs_item
) {
491 sinfo
.sndbuf
= rds_sk_sndbuf(rs
);
492 sinfo
.rcvbuf
= rds_sk_rcvbuf(rs
);
493 sinfo
.bound_addr
= rs
->rs_bound_addr
;
494 sinfo
.connected_addr
= rs
->rs_conn_addr
;
495 sinfo
.bound_port
= rs
->rs_bound_port
;
496 sinfo
.connected_port
= rs
->rs_conn_port
;
497 sinfo
.inum
= sock_i_ino(rds_rs_to_sk(rs
));
499 rds_info_copy(iter
, &sinfo
, sizeof(sinfo
));
503 lens
->nr
= rds_sock_count
;
504 lens
->each
= sizeof(struct rds_info_socket
);
506 spin_unlock_irqrestore(&rds_sock_lock
, flags
);
509 static void __exit
rds_exit(void)
511 sock_unregister(rds_family_ops
.family
);
512 proto_unregister(&rds_proto
);
519 rds_info_deregister_func(RDS_INFO_SOCKETS
, rds_sock_info
);
520 rds_info_deregister_func(RDS_INFO_RECV_MESSAGES
, rds_sock_inc_info
);
522 module_exit(rds_exit
);
524 static int __init
rds_init(void)
528 ret
= rds_conn_init();
531 ret
= rds_threads_init();
534 ret
= rds_sysctl_init();
537 ret
= rds_stats_init();
540 ret
= proto_register(&rds_proto
, 1);
543 ret
= sock_register(&rds_family_ops
);
547 rds_info_register_func(RDS_INFO_SOCKETS
, rds_sock_info
);
548 rds_info_register_func(RDS_INFO_RECV_MESSAGES
, rds_sock_inc_info
);
553 proto_unregister(&rds_proto
);
567 module_init(rds_init
);
569 #define DRV_VERSION "4.0"
570 #define DRV_RELDATE "Feb 12, 2009"
572 MODULE_AUTHOR("Oracle Corporation <rds-devel@oss.oracle.com>");
573 MODULE_DESCRIPTION("RDS: Reliable Datagram Sockets"
574 " v" DRV_VERSION
" (" DRV_RELDATE
")");
575 MODULE_VERSION(DRV_VERSION
);
576 MODULE_LICENSE("Dual BSD/GPL");
577 MODULE_ALIAS_NETPROTO(PF_RDS
);