1 /******************************************************************************
2 *******************************************************************************
4 ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
5 ** Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
7 ** This copyrighted material is made available to anyone wishing to use,
8 ** modify, copy, or redistribute it subject to the terms and conditions
9 ** of the GNU General Public License v.2.
11 *******************************************************************************
12 ******************************************************************************/
17 * This is the "low-level" comms layer.
19 * It is responsible for sending/receiving messages
20 * from other nodes in the cluster.
22 * Cluster nodes are referred to by their nodeids. nodeids are
23 * simply 32 bit numbers to the locking module - if they need to
24 * be expanded for the cluster infrastructure then that is it's
25 * responsibility. It is this layer's
26 * responsibility to resolve these into IP address or
27 * whatever it needs for inter-node communication.
29 * The comms level is two kernel threads that deal mainly with
30 * the receiving of messages from other nodes and passing them
31 * up to the mid-level comms layer (which understands the
32 * message format) for execution by the locking core, and
33 * a send thread which does all the setting up of connections
34 * to remote nodes and the sending of data. Threads are not allowed
35 * to send their own data because it may cause them to wait in times
36 * of high load. Also, this way, the sending thread can collect together
37 * messages bound for one node and send them in one block.
39 * lowcomms will choose to use wither TCP or SCTP as its transport layer
40 * depending on the configuration variable 'protocol'. This should be set
41 * to 0 (default) for TCP or 1 for SCTP. It shouldbe configured using a
42 * cluster-wide mechanism as it must be the same on all nodes of the cluster
43 * for the DLM to function.
47 #include <asm/ioctls.h>
50 #include <linux/pagemap.h>
51 #include <linux/idr.h>
52 #include <linux/file.h>
53 #include <linux/sctp.h>
54 #include <net/sctp/user.h>
56 #include "dlm_internal.h"
61 #define NEEDED_RMEM (4*1024*1024)
69 static void cbuf_add(struct cbuf *cb, int n)
74 static int cbuf_data(struct cbuf *cb)
76 return ((cb->base + cb->len) & cb->mask);
79 static void cbuf_init(struct cbuf *cb, int size)
81 cb->base = cb->len = 0;
85 static void cbuf_eat(struct cbuf *cb, int n)
92 static bool cbuf_empty(struct cbuf *cb)
98 struct socket *sock; /* NULL if not connected */
99 uint32_t nodeid; /* So we know who we are in the list */
100 struct mutex sock_mutex;
102 #define CF_READ_PENDING 1
103 #define CF_WRITE_PENDING 2
104 #define CF_CONNECT_PENDING 3
105 #define CF_INIT_PENDING 4
106 #define CF_IS_OTHERCON 5
107 struct list_head writequeue; /* List of outgoing writequeue_entries */
108 spinlock_t writequeue_lock;
109 int (*rx_action) (struct connection *); /* What to do when active */
110 void (*connect_action) (struct connection *); /* What to do to connect */
111 struct page *rx_page;
114 #define MAX_CONNECT_RETRIES 3
116 struct connection *othercon;
117 struct work_struct rwork; /* Receive workqueue */
118 struct work_struct swork; /* Send workqueue */
120 #define sock2con(x) ((struct connection *)(x)->sk_user_data)
122 /* An entry waiting to be sent */
123 struct writequeue_entry {
124 struct list_head list;
130 struct connection *con;
133 static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT];
134 static int dlm_local_count;
137 static struct workqueue_struct *recv_workqueue;
138 static struct workqueue_struct *send_workqueue;
140 static DEFINE_IDR(connections_idr);
141 static DECLARE_MUTEX(connections_lock);
142 static int max_nodeid;
143 static struct kmem_cache *con_cache;
145 static void process_recv_sockets(struct work_struct *work);
146 static void process_send_sockets(struct work_struct *work);
149 * If 'allocation' is zero then we don't attempt to create a new
150 * connection structure for this node.
152 static struct connection *__nodeid2con(int nodeid, gfp_t alloc)
154 struct connection *con = NULL;
158 con = idr_find(&connections_idr, nodeid);
162 r = idr_pre_get(&connections_idr, alloc);
166 con = kmem_cache_zalloc(con_cache, alloc);
170 r = idr_get_new_above(&connections_idr, con, nodeid, &n);
172 kmem_cache_free(con_cache, con);
177 idr_remove(&connections_idr, n);
178 kmem_cache_free(con_cache, con);
182 con->nodeid = nodeid;
183 mutex_init(&con->sock_mutex);
184 INIT_LIST_HEAD(&con->writequeue);
185 spin_lock_init(&con->writequeue_lock);
186 INIT_WORK(&con->swork, process_send_sockets);
187 INIT_WORK(&con->rwork, process_recv_sockets);
189 /* Setup action pointers for child sockets */
191 struct connection *zerocon = idr_find(&connections_idr, 0);
193 con->connect_action = zerocon->connect_action;
195 con->rx_action = zerocon->rx_action;
198 if (nodeid > max_nodeid)
204 static struct connection *nodeid2con(int nodeid, gfp_t allocation)
206 struct connection *con;
208 down(&connections_lock);
209 con = __nodeid2con(nodeid, allocation);
210 up(&connections_lock);
215 /* This is a bit drastic, but only called when things go wrong */
216 static struct connection *assoc2con(int assoc_id)
219 struct connection *con;
221 down(&connections_lock);
222 for (i=0; i<=max_nodeid; i++) {
223 con = __nodeid2con(i, 0);
224 if (con && con->sctp_assoc == assoc_id) {
225 up(&connections_lock);
229 up(&connections_lock);
233 static int nodeid_to_addr(int nodeid, struct sockaddr *retaddr)
235 struct sockaddr_storage addr;
238 if (!dlm_local_count)
241 error = dlm_nodeid_to_addr(nodeid, &addr);
245 if (dlm_local_addr[0]->ss_family == AF_INET) {
246 struct sockaddr_in *in4 = (struct sockaddr_in *) &addr;
247 struct sockaddr_in *ret4 = (struct sockaddr_in *) retaddr;
248 ret4->sin_addr.s_addr = in4->sin_addr.s_addr;
250 struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &addr;
251 struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *) retaddr;
252 memcpy(&ret6->sin6_addr, &in6->sin6_addr,
253 sizeof(in6->sin6_addr));
259 /* Data available on socket or listen socket received a connect */
260 static void lowcomms_data_ready(struct sock *sk, int count_unused)
262 struct connection *con = sock2con(sk);
263 if (!test_and_set_bit(CF_READ_PENDING, &con->flags))
264 queue_work(recv_workqueue, &con->rwork);
267 static void lowcomms_write_space(struct sock *sk)
269 struct connection *con = sock2con(sk);
271 if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags))
272 queue_work(send_workqueue, &con->swork);
275 static inline void lowcomms_connect_sock(struct connection *con)
277 if (!test_and_set_bit(CF_CONNECT_PENDING, &con->flags))
278 queue_work(send_workqueue, &con->swork);
281 static void lowcomms_state_change(struct sock *sk)
283 if (sk->sk_state == TCP_ESTABLISHED)
284 lowcomms_write_space(sk);
287 /* Make a socket active */
288 static int add_sock(struct socket *sock, struct connection *con)
292 /* Install a data_ready callback */
293 con->sock->sk->sk_data_ready = lowcomms_data_ready;
294 con->sock->sk->sk_write_space = lowcomms_write_space;
295 con->sock->sk->sk_state_change = lowcomms_state_change;
296 con->sock->sk->sk_user_data = con;
300 /* Add the port number to an IPv6 or 4 sockaddr and return the address
302 static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port,
305 saddr->ss_family = dlm_local_addr[0]->ss_family;
306 if (saddr->ss_family == AF_INET) {
307 struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr;
308 in4_addr->sin_port = cpu_to_be16(port);
309 *addr_len = sizeof(struct sockaddr_in);
310 memset(&in4_addr->sin_zero, 0, sizeof(in4_addr->sin_zero));
312 struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)saddr;
313 in6_addr->sin6_port = cpu_to_be16(port);
314 *addr_len = sizeof(struct sockaddr_in6);
318 /* Close a remote connection and tidy up */
319 static void close_connection(struct connection *con, bool and_other)
321 mutex_lock(&con->sock_mutex);
324 sock_release(con->sock);
327 if (con->othercon && and_other) {
328 /* Will only re-enter once. */
329 close_connection(con->othercon, false);
332 __free_page(con->rx_page);
336 mutex_unlock(&con->sock_mutex);
339 /* We only send shutdown messages to nodes that are not part of the cluster */
340 static void sctp_send_shutdown(sctp_assoc_t associd)
342 static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
343 struct msghdr outmessage;
344 struct cmsghdr *cmsg;
345 struct sctp_sndrcvinfo *sinfo;
347 struct connection *con;
349 con = nodeid2con(0,0);
352 outmessage.msg_name = NULL;
353 outmessage.msg_namelen = 0;
354 outmessage.msg_control = outcmsg;
355 outmessage.msg_controllen = sizeof(outcmsg);
356 outmessage.msg_flags = MSG_EOR;
358 cmsg = CMSG_FIRSTHDR(&outmessage);
359 cmsg->cmsg_level = IPPROTO_SCTP;
360 cmsg->cmsg_type = SCTP_SNDRCV;
361 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
362 outmessage.msg_controllen = cmsg->cmsg_len;
363 sinfo = CMSG_DATA(cmsg);
364 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
366 sinfo->sinfo_flags |= MSG_EOF;
367 sinfo->sinfo_assoc_id = associd;
369 ret = kernel_sendmsg(con->sock, &outmessage, NULL, 0, 0);
372 log_print("send EOF to node failed: %d", ret);
375 /* INIT failed but we don't know which node...
376 restart INIT on all pending nodes */
377 static void sctp_init_failed(void)
380 struct connection *con;
382 down(&connections_lock);
383 for (i=1; i<=max_nodeid; i++) {
384 con = __nodeid2con(i, 0);
388 if (test_and_clear_bit(CF_CONNECT_PENDING, &con->flags)) {
389 if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) {
390 queue_work(send_workqueue, &con->swork);
394 up(&connections_lock);
397 /* Something happened to an association */
398 static void process_sctp_notification(struct connection *con, struct msghdr *msg, char *buf)
400 union sctp_notification *sn = (union sctp_notification *)buf;
402 if (sn->sn_header.sn_type == SCTP_ASSOC_CHANGE) {
403 switch (sn->sn_assoc_change.sac_state) {
408 /* Check that the new node is in the lockspace */
409 struct sctp_prim prim;
413 struct connection *new_con;
415 sctp_peeloff_arg_t parg;
416 int parglen = sizeof(parg);
419 * We get this before any data for an association.
420 * We verify that the node is in the cluster and
421 * then peel off a socket for it.
423 if ((int)sn->sn_assoc_change.sac_assoc_id <= 0) {
424 log_print("COMM_UP for invalid assoc ID %d",
425 (int)sn->sn_assoc_change.sac_assoc_id);
429 memset(&prim, 0, sizeof(struct sctp_prim));
430 prim_len = sizeof(struct sctp_prim);
431 prim.ssp_assoc_id = sn->sn_assoc_change.sac_assoc_id;
433 ret = kernel_getsockopt(con->sock,
439 log_print("getsockopt/sctp_primary_addr on "
440 "new assoc %d failed : %d",
441 (int)sn->sn_assoc_change.sac_assoc_id,
444 /* Retry INIT later */
445 new_con = assoc2con(sn->sn_assoc_change.sac_assoc_id);
447 clear_bit(CF_CONNECT_PENDING, &con->flags);
450 make_sockaddr(&prim.ssp_addr, 0, &addr_len);
451 if (dlm_addr_to_nodeid(&prim.ssp_addr, &nodeid)) {
453 unsigned char *b=(unsigned char *)&prim.ssp_addr;
454 log_print("reject connect from unknown addr");
455 for (i=0; i<sizeof(struct sockaddr_storage);i++)
456 printk("%02x ", b[i]);
458 sctp_send_shutdown(prim.ssp_assoc_id);
462 new_con = nodeid2con(nodeid, GFP_KERNEL);
466 /* Peel off a new sock */
467 parg.associd = sn->sn_assoc_change.sac_assoc_id;
468 ret = kernel_getsockopt(con->sock, IPPROTO_SCTP, SCTP_SOCKOPT_PEELOFF,
469 (void *)&parg, &parglen);
471 log_print("Can't peel off a socket for connection %d to node %d: err=%d\n",
472 parg.associd, nodeid, ret);
474 file = fget(parg.sd);
475 new_con->sock = SOCKET_I(file->f_dentry->d_inode);
476 add_sock(new_con->sock, new_con);
478 put_unused_fd(parg.sd);
480 log_print("got new/restarted association %d nodeid %d",
481 (int)sn->sn_assoc_change.sac_assoc_id, nodeid);
483 /* Send any pending writes */
484 clear_bit(CF_CONNECT_PENDING, &new_con->flags);
485 clear_bit(CF_INIT_PENDING, &con->flags);
486 if (!test_and_set_bit(CF_WRITE_PENDING, &new_con->flags)) {
487 queue_work(send_workqueue, &new_con->swork);
489 if (!test_and_set_bit(CF_READ_PENDING, &new_con->flags))
490 queue_work(recv_workqueue, &new_con->rwork);
495 case SCTP_SHUTDOWN_COMP:
497 con = assoc2con(sn->sn_assoc_change.sac_assoc_id);
504 /* We don't know which INIT failed, so clear the PENDING flags
505 * on them all. if assoc_id is zero then it will then try
508 case SCTP_CANT_STR_ASSOC:
510 log_print("Can't start SCTP association - retrying");
516 log_print("unexpected SCTP assoc change id=%d state=%d",
517 (int)sn->sn_assoc_change.sac_assoc_id,
518 sn->sn_assoc_change.sac_state);
523 /* Data received from remote end */
524 static int receive_from_sock(struct connection *con)
527 struct msghdr msg = {};
531 int call_again_soon = 0;
533 char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
535 mutex_lock(&con->sock_mutex);
537 if (con->sock == NULL) {
542 if (con->rx_page == NULL) {
544 * This doesn't need to be atomic, but I think it should
545 * improve performance if it is.
547 con->rx_page = alloc_page(GFP_ATOMIC);
548 if (con->rx_page == NULL)
550 cbuf_init(&con->cb, PAGE_CACHE_SIZE);
553 /* Only SCTP needs these really */
554 memset(&incmsg, 0, sizeof(incmsg));
555 msg.msg_control = incmsg;
556 msg.msg_controllen = sizeof(incmsg);
559 * iov[0] is the bit of the circular buffer between the current end
560 * point (cb.base + cb.len) and the end of the buffer.
562 iov[0].iov_len = con->cb.base - cbuf_data(&con->cb);
563 iov[0].iov_base = page_address(con->rx_page) + cbuf_data(&con->cb);
568 * iov[1] is the bit of the circular buffer between the start of the
569 * buffer and the start of the currently used section (cb.base)
571 if (cbuf_data(&con->cb) >= con->cb.base) {
572 iov[0].iov_len = PAGE_CACHE_SIZE - cbuf_data(&con->cb);
573 iov[1].iov_len = con->cb.base;
574 iov[1].iov_base = page_address(con->rx_page);
577 len = iov[0].iov_len + iov[1].iov_len;
579 r = ret = kernel_recvmsg(con->sock, &msg, iov, nvec, len,
580 MSG_DONTWAIT | MSG_NOSIGNAL);
584 /* Process SCTP notifications */
585 if (msg.msg_flags & MSG_NOTIFICATION) {
586 msg.msg_control = incmsg;
587 msg.msg_controllen = sizeof(incmsg);
589 process_sctp_notification(con, &msg,
590 page_address(con->rx_page) + con->cb.base);
591 mutex_unlock(&con->sock_mutex);
594 BUG_ON(con->nodeid == 0);
598 cbuf_add(&con->cb, ret);
599 ret = dlm_process_incoming_buffer(con->nodeid,
600 page_address(con->rx_page),
601 con->cb.base, con->cb.len,
603 if (ret == -EBADMSG) {
604 printk(KERN_INFO "dlm: lowcomms: addr=%p, base=%u, len=%u, "
605 "iov_len=%u, iov_base[0]=%p, read=%d\n",
606 page_address(con->rx_page), con->cb.base, con->cb.len,
607 len, iov[0].iov_base, r);
611 cbuf_eat(&con->cb, ret);
613 if (cbuf_empty(&con->cb) && !call_again_soon) {
614 __free_page(con->rx_page);
620 mutex_unlock(&con->sock_mutex);
624 if (!test_and_set_bit(CF_READ_PENDING, &con->flags))
625 queue_work(recv_workqueue, &con->rwork);
626 mutex_unlock(&con->sock_mutex);
630 mutex_unlock(&con->sock_mutex);
631 if (ret != -EAGAIN && !test_bit(CF_IS_OTHERCON, &con->flags)) {
632 close_connection(con, false);
633 /* Reconnect when there is something to send */
635 /* Don't return success if we really got EOF */
642 /* Listening socket is busy, accept a connection */
643 static int tcp_accept_from_sock(struct connection *con)
646 struct sockaddr_storage peeraddr;
647 struct socket *newsock;
650 struct connection *newcon;
651 struct connection *addcon;
653 memset(&peeraddr, 0, sizeof(peeraddr));
654 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM,
655 IPPROTO_TCP, &newsock);
659 mutex_lock_nested(&con->sock_mutex, 0);
662 if (con->sock == NULL)
665 newsock->type = con->sock->type;
666 newsock->ops = con->sock->ops;
668 result = con->sock->ops->accept(con->sock, newsock, O_NONBLOCK);
672 /* Get the connected socket's peer */
673 memset(&peeraddr, 0, sizeof(peeraddr));
674 if (newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr,
676 result = -ECONNABORTED;
680 /* Get the new node's NODEID */
681 make_sockaddr(&peeraddr, 0, &len);
682 if (dlm_addr_to_nodeid(&peeraddr, &nodeid)) {
683 printk("dlm: connect from non cluster node\n");
684 sock_release(newsock);
685 mutex_unlock(&con->sock_mutex);
689 log_print("got connection from %d", nodeid);
691 /* Check to see if we already have a connection to this node. This
692 * could happen if the two nodes initiate a connection at roughly
693 * the same time and the connections cross on the wire.
694 * In this case we store the incoming one in "othercon"
696 newcon = nodeid2con(nodeid, GFP_KERNEL);
701 mutex_lock_nested(&newcon->sock_mutex, 1);
703 struct connection *othercon = newcon->othercon;
706 othercon = kmem_cache_zalloc(con_cache, GFP_KERNEL);
708 printk("dlm: failed to allocate incoming socket\n");
709 mutex_unlock(&newcon->sock_mutex);
713 othercon->nodeid = nodeid;
714 othercon->rx_action = receive_from_sock;
715 mutex_init(&othercon->sock_mutex);
716 INIT_WORK(&othercon->swork, process_send_sockets);
717 INIT_WORK(&othercon->rwork, process_recv_sockets);
718 set_bit(CF_IS_OTHERCON, &othercon->flags);
719 newcon->othercon = othercon;
721 othercon->sock = newsock;
722 newsock->sk->sk_user_data = othercon;
723 add_sock(newsock, othercon);
727 newsock->sk->sk_user_data = newcon;
728 newcon->rx_action = receive_from_sock;
729 add_sock(newsock, newcon);
733 mutex_unlock(&newcon->sock_mutex);
736 * Add it to the active queue in case we got data
737 * beween processing the accept adding the socket
738 * to the read_sockets list
740 if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags))
741 queue_work(recv_workqueue, &addcon->rwork);
742 mutex_unlock(&con->sock_mutex);
747 mutex_unlock(&con->sock_mutex);
748 sock_release(newsock);
750 if (result != -EAGAIN)
751 printk("dlm: error accepting connection from node: %d\n", result);
755 static void free_entry(struct writequeue_entry *e)
757 __free_page(e->page);
761 /* Initiate an SCTP association.
762 This is a special case of send_to_sock() in that we don't yet have a
763 peeled-off socket for this association, so we use the listening socket
764 and add the primary IP address of the remote node.
766 static void sctp_init_assoc(struct connection *con)
768 struct sockaddr_storage rem_addr;
769 char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
770 struct msghdr outmessage;
771 struct cmsghdr *cmsg;
772 struct sctp_sndrcvinfo *sinfo;
773 struct connection *base_con;
774 struct writequeue_entry *e;
780 if (test_and_set_bit(CF_INIT_PENDING, &con->flags))
783 if (con->retries++ > MAX_CONNECT_RETRIES)
786 log_print("Initiating association with node %d", con->nodeid);
788 if (nodeid_to_addr(con->nodeid, (struct sockaddr *)&rem_addr)) {
789 log_print("no address for nodeid %d", con->nodeid);
792 base_con = nodeid2con(0, 0);
793 BUG_ON(base_con == NULL);
795 make_sockaddr(&rem_addr, dlm_config.ci_tcp_port, &addrlen);
797 outmessage.msg_name = &rem_addr;
798 outmessage.msg_namelen = addrlen;
799 outmessage.msg_control = outcmsg;
800 outmessage.msg_controllen = sizeof(outcmsg);
801 outmessage.msg_flags = MSG_EOR;
803 spin_lock(&con->writequeue_lock);
804 e = list_entry(con->writequeue.next, struct writequeue_entry,
807 BUG_ON((struct list_head *) e == &con->writequeue);
811 spin_unlock(&con->writequeue_lock);
814 /* Send the first block off the write queue */
815 iov[0].iov_base = page_address(e->page)+offset;
816 iov[0].iov_len = len;
818 cmsg = CMSG_FIRSTHDR(&outmessage);
819 cmsg->cmsg_level = IPPROTO_SCTP;
820 cmsg->cmsg_type = SCTP_SNDRCV;
821 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
822 sinfo = CMSG_DATA(cmsg);
823 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
824 sinfo->sinfo_ppid = cpu_to_le32(dlm_our_nodeid());
825 outmessage.msg_controllen = cmsg->cmsg_len;
827 ret = kernel_sendmsg(base_con->sock, &outmessage, iov, 1, len);
829 log_print("Send first packet to node %d failed: %d", con->nodeid, ret);
831 /* Try again later */
832 clear_bit(CF_CONNECT_PENDING, &con->flags);
833 clear_bit(CF_INIT_PENDING, &con->flags);
836 spin_lock(&con->writequeue_lock);
840 if (e->len == 0 && e->users == 0) {
845 spin_unlock(&con->writequeue_lock);
849 /* Connect a new socket to its peer */
850 static void tcp_connect_to_sock(struct connection *con)
852 int result = -EHOSTUNREACH;
853 struct sockaddr_storage saddr;
857 if (con->nodeid == 0) {
858 log_print("attempt to connect sock 0 foiled");
862 mutex_lock(&con->sock_mutex);
863 if (con->retries++ > MAX_CONNECT_RETRIES)
866 /* Some odd races can cause double-connects, ignore them */
872 /* Create a socket to communicate with */
873 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM,
878 memset(&saddr, 0, sizeof(saddr));
879 if (dlm_nodeid_to_addr(con->nodeid, &saddr))
882 sock->sk->sk_user_data = con;
883 con->rx_action = receive_from_sock;
884 con->connect_action = tcp_connect_to_sock;
887 make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len);
889 log_print("connecting to %d", con->nodeid);
891 sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len,
893 if (result == -EINPROGRESS)
900 sock_release(con->sock);
904 * Some errors are fatal and this list might need adjusting. For other
905 * errors we try again until the max number of retries is reached.
907 if (result != -EHOSTUNREACH && result != -ENETUNREACH &&
908 result != -ENETDOWN && result != EINVAL
909 && result != -EPROTONOSUPPORT) {
910 lowcomms_connect_sock(con);
914 mutex_unlock(&con->sock_mutex);
918 static struct socket *tcp_create_listen_sock(struct connection *con,
919 struct sockaddr_storage *saddr)
921 struct socket *sock = NULL;
926 if (dlm_local_addr[0]->ss_family == AF_INET)
927 addr_len = sizeof(struct sockaddr_in);
929 addr_len = sizeof(struct sockaddr_in6);
931 /* Create a socket to communicate with */
932 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM, IPPROTO_TCP, &sock);
934 printk("dlm: Can't create listening comms socket\n");
938 result = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
939 (char *)&one, sizeof(one));
942 printk("dlm: Failed to set SO_REUSEADDR on socket: result=%d\n",
945 sock->sk->sk_user_data = con;
946 con->rx_action = tcp_accept_from_sock;
947 con->connect_action = tcp_connect_to_sock;
950 /* Bind to our port */
951 make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len);
952 result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len);
954 printk("dlm: Can't bind to port %d\n", dlm_config.ci_tcp_port);
960 result = kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
961 (char *)&one, sizeof(one));
963 printk("dlm: Set keepalive failed: %d\n", result);
966 result = sock->ops->listen(sock, 5);
968 printk("dlm: Can't listen on port %d\n", dlm_config.ci_tcp_port);
978 /* Get local addresses */
979 static void init_local(void)
981 struct sockaddr_storage sas, *addr;
985 for (i = 0; i < DLM_MAX_ADDR_COUNT - 1; i++) {
986 if (dlm_our_addr(&sas, i))
989 addr = kmalloc(sizeof(*addr), GFP_KERNEL);
992 memcpy(addr, &sas, sizeof(*addr));
993 dlm_local_addr[dlm_local_count++] = addr;
997 /* Bind to an IP address. SCTP allows multiple address so it can do multi-homing */
998 static int add_sctp_bind_addr(struct connection *sctp_con, struct sockaddr_storage *addr, int addr_len, int num)
1003 result = kernel_bind(sctp_con->sock,
1004 (struct sockaddr *) addr,
1007 result = kernel_setsockopt(sctp_con->sock, SOL_SCTP,
1008 SCTP_SOCKOPT_BINDX_ADD,
1009 (char *)addr, addr_len);
1012 log_print("Can't bind to port %d addr number %d",
1013 dlm_config.ci_tcp_port, num);
1018 /* Initialise SCTP socket and bind to all interfaces */
1019 static int sctp_listen_for_all(void)
1021 struct socket *sock = NULL;
1022 struct sockaddr_storage localaddr;
1023 struct sctp_event_subscribe subscribe;
1024 int result = -EINVAL, num = 1, i, addr_len;
1025 struct connection *con = nodeid2con(0, GFP_KERNEL);
1026 int bufsize = NEEDED_RMEM;
1031 log_print("Using SCTP for communications");
1033 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_SEQPACKET,
1034 IPPROTO_SCTP, &sock);
1036 log_print("Can't create comms socket, check SCTP is loaded");
1040 /* Listen for events */
1041 memset(&subscribe, 0, sizeof(subscribe));
1042 subscribe.sctp_data_io_event = 1;
1043 subscribe.sctp_association_event = 1;
1044 subscribe.sctp_send_failure_event = 1;
1045 subscribe.sctp_shutdown_event = 1;
1046 subscribe.sctp_partial_delivery_event = 1;
1048 result = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
1049 (char *)&bufsize, sizeof(bufsize));
1051 log_print("Error increasing buffer space on socket: %d", result);
1053 result = kernel_setsockopt(sock, SOL_SCTP, SCTP_EVENTS,
1054 (char *)&subscribe, sizeof(subscribe));
1056 log_print("Failed to set SCTP_EVENTS on socket: result=%d",
1058 goto create_delsock;
1061 /* Init con struct */
1062 sock->sk->sk_user_data = con;
1064 con->sock->sk->sk_data_ready = lowcomms_data_ready;
1065 con->rx_action = receive_from_sock;
1066 con->connect_action = sctp_init_assoc;
1068 /* Bind to all interfaces. */
1069 for (i = 0; i < dlm_local_count; i++) {
1070 memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr));
1071 make_sockaddr(&localaddr, dlm_config.ci_tcp_port, &addr_len);
1073 result = add_sctp_bind_addr(con, &localaddr, addr_len, num);
1075 goto create_delsock;
1079 result = sock->ops->listen(sock, 5);
1081 log_print("Can't set socket listening");
1082 goto create_delsock;
1094 static int tcp_listen_for_all(void)
1096 struct socket *sock = NULL;
1097 struct connection *con = nodeid2con(0, GFP_KERNEL);
1098 int result = -EINVAL;
1103 /* We don't support multi-homed hosts */
1104 if (dlm_local_addr[1] != NULL) {
1105 log_print("TCP protocol can't handle multi-homed hosts, try SCTP");
1109 log_print("Using TCP for communications");
1111 set_bit(CF_IS_OTHERCON, &con->flags);
1113 sock = tcp_create_listen_sock(con, dlm_local_addr[0]);
1115 add_sock(sock, con);
1119 result = -EADDRINUSE;
1127 static struct writequeue_entry *new_writequeue_entry(struct connection *con,
1130 struct writequeue_entry *entry;
1132 entry = kmalloc(sizeof(struct writequeue_entry), allocation);
1136 entry->page = alloc_page(allocation);
1151 void *dlm_lowcomms_get_buffer(int nodeid, int len,
1152 gfp_t allocation, char **ppc)
1154 struct connection *con;
1155 struct writequeue_entry *e;
1159 con = nodeid2con(nodeid, allocation);
1163 spin_lock(&con->writequeue_lock);
1164 e = list_entry(con->writequeue.prev, struct writequeue_entry, list);
1165 if ((&e->list == &con->writequeue) ||
1166 (PAGE_CACHE_SIZE - e->end < len)) {
1173 spin_unlock(&con->writequeue_lock);
1179 *ppc = page_address(e->page) + offset;
1183 e = new_writequeue_entry(con, allocation);
1185 spin_lock(&con->writequeue_lock);
1189 list_add_tail(&e->list, &con->writequeue);
1190 spin_unlock(&con->writequeue_lock);
1196 void dlm_lowcomms_commit_buffer(void *mh)
1198 struct writequeue_entry *e = (struct writequeue_entry *)mh;
1199 struct connection *con = e->con;
1202 spin_lock(&con->writequeue_lock);
1206 e->len = e->end - e->offset;
1208 spin_unlock(&con->writequeue_lock);
1210 if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) {
1211 queue_work(send_workqueue, &con->swork);
1216 spin_unlock(&con->writequeue_lock);
1220 /* Send a message */
1221 static void send_to_sock(struct connection *con)
1224 ssize_t(*sendpage) (struct socket *, struct page *, int, size_t, int);
1225 const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL;
1226 struct writequeue_entry *e;
1229 mutex_lock(&con->sock_mutex);
1230 if (con->sock == NULL)
1233 sendpage = con->sock->ops->sendpage;
1235 spin_lock(&con->writequeue_lock);
1237 e = list_entry(con->writequeue.next, struct writequeue_entry,
1239 if ((struct list_head *) e == &con->writequeue)
1244 BUG_ON(len == 0 && e->users == 0);
1245 spin_unlock(&con->writequeue_lock);
1250 ret = sendpage(con->sock, e->page, offset, len,
1252 if (ret == -EAGAIN || ret == 0)
1258 /* Don't starve people filling buffers */
1262 spin_lock(&con->writequeue_lock);
1266 if (e->len == 0 && e->users == 0) {
1273 spin_unlock(&con->writequeue_lock);
1275 mutex_unlock(&con->sock_mutex);
1279 mutex_unlock(&con->sock_mutex);
1280 close_connection(con, false);
1281 lowcomms_connect_sock(con);
1285 mutex_unlock(&con->sock_mutex);
1286 if (!test_bit(CF_INIT_PENDING, &con->flags))
1287 lowcomms_connect_sock(con);
1291 static void clean_one_writequeue(struct connection *con)
1293 struct list_head *list;
1294 struct list_head *temp;
1296 spin_lock(&con->writequeue_lock);
1297 list_for_each_safe(list, temp, &con->writequeue) {
1298 struct writequeue_entry *e =
1299 list_entry(list, struct writequeue_entry, list);
1303 spin_unlock(&con->writequeue_lock);
1306 /* Called from recovery when it knows that a node has
1308 int dlm_lowcomms_close(int nodeid)
1310 struct connection *con;
1312 log_print("closing connection to node %d", nodeid);
1313 con = nodeid2con(nodeid, 0);
1315 clean_one_writequeue(con);
1316 close_connection(con, true);
1321 /* Receive workqueue function */
1322 static void process_recv_sockets(struct work_struct *work)
1324 struct connection *con = container_of(work, struct connection, rwork);
1327 clear_bit(CF_READ_PENDING, &con->flags);
1329 err = con->rx_action(con);
1333 /* Send workqueue function */
1334 static void process_send_sockets(struct work_struct *work)
1336 struct connection *con = container_of(work, struct connection, swork);
1338 if (test_and_clear_bit(CF_CONNECT_PENDING, &con->flags)) {
1339 con->connect_action(con);
1341 clear_bit(CF_WRITE_PENDING, &con->flags);
1346 /* Discard all entries on the write queues */
1347 static void clean_writequeues(void)
1351 for (nodeid = 1; nodeid <= max_nodeid; nodeid++) {
1352 struct connection *con = __nodeid2con(nodeid, 0);
1355 clean_one_writequeue(con);
1359 static void work_stop(void)
1361 destroy_workqueue(recv_workqueue);
1362 destroy_workqueue(send_workqueue);
1365 static int work_start(void)
1368 recv_workqueue = create_workqueue("dlm_recv");
1369 error = IS_ERR(recv_workqueue);
1371 log_print("can't start dlm_recv %d", error);
1375 send_workqueue = create_singlethread_workqueue("dlm_send");
1376 error = IS_ERR(send_workqueue);
1378 log_print("can't start dlm_send %d", error);
1379 destroy_workqueue(recv_workqueue);
1386 void dlm_lowcomms_stop(void)
1389 struct connection *con;
1391 /* Set all the flags to prevent any
1394 down(&connections_lock);
1395 for (i = 0; i <= max_nodeid; i++) {
1396 con = __nodeid2con(i, 0);
1400 up(&connections_lock);
1404 down(&connections_lock);
1405 clean_writequeues();
1407 for (i = 0; i <= max_nodeid; i++) {
1408 con = __nodeid2con(i, 0);
1410 close_connection(con, true);
1412 kmem_cache_free(con_cache, con->othercon);
1413 kmem_cache_free(con_cache, con);
1417 up(&connections_lock);
1418 kmem_cache_destroy(con_cache);
1419 idr_init(&connections_idr);
1422 int dlm_lowcomms_start(void)
1424 int error = -EINVAL;
1425 struct connection *con;
1428 if (!dlm_local_count) {
1429 log_print("no local IP address has been set");
1434 con_cache = kmem_cache_create("dlm_conn", sizeof(struct connection),
1435 __alignof__(struct connection), 0,
1440 /* Set some sysctl minima */
1441 if (sysctl_rmem_max < NEEDED_RMEM)
1442 sysctl_rmem_max = NEEDED_RMEM;
1444 /* Start listening */
1445 if (dlm_config.ci_protocol == 0)
1446 error = tcp_listen_for_all();
1448 error = sctp_listen_for_all();
1452 error = work_start();
1459 con = nodeid2con(0,0);
1461 close_connection(con, false);
1462 kmem_cache_free(con_cache, con);
1464 kmem_cache_destroy(con_cache);