aboutsummaryrefslogtreecommitdiffstats
path: root/fs/dlm/lowcomms.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/dlm/lowcomms.c')
-rw-r--r--fs/dlm/lowcomms.c1468
1 files changed, 1468 insertions, 0 deletions
diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c
new file mode 100644
index 000000000000..76399b7819b4
--- /dev/null
+++ b/fs/dlm/lowcomms.c
@@ -0,0 +1,1468 @@
1/******************************************************************************
2*******************************************************************************
3**
4** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
5** Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
6**
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.
10**
11*******************************************************************************
12******************************************************************************/
13
14/*
15 * lowcomms.c
16 *
17 * This is the "low-level" comms layer.
18 *
19 * It is responsible for sending/receiving messages
20 * from other nodes in the cluster.
21 *
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.
28 *
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.
38 *
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.
44 *
45 */
46
47#include <asm/ioctls.h>
48#include <net/sock.h>
49#include <net/tcp.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>
55
56#include "dlm_internal.h"
57#include "lowcomms.h"
58#include "midcomms.h"
59#include "config.h"
60
61#define NEEDED_RMEM (4*1024*1024)
62
63struct cbuf {
64 unsigned int base;
65 unsigned int len;
66 unsigned int mask;
67};
68
69static void cbuf_add(struct cbuf *cb, int n)
70{
71 cb->len += n;
72}
73
74static int cbuf_data(struct cbuf *cb)
75{
76 return ((cb->base + cb->len) & cb->mask);
77}
78
79static void cbuf_init(struct cbuf *cb, int size)
80{
81 cb->base = cb->len = 0;
82 cb->mask = size-1;
83}
84
85static void cbuf_eat(struct cbuf *cb, int n)
86{
87 cb->len -= n;
88 cb->base += n;
89 cb->base &= cb->mask;
90}
91
92static bool cbuf_empty(struct cbuf *cb)
93{
94 return cb->len == 0;
95}
96
97struct connection {
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;
101 unsigned long flags;
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;
112 struct cbuf cb;
113 int retries;
114#define MAX_CONNECT_RETRIES 3
115 int sctp_assoc;
116 struct connection *othercon;
117 struct work_struct rwork; /* Receive workqueue */
118 struct work_struct swork; /* Send workqueue */
119};
120#define sock2con(x) ((struct connection *)(x)->sk_user_data)
121
122/* An entry waiting to be sent */
123struct writequeue_entry {
124 struct list_head list;
125 struct page *page;
126 int offset;
127 int len;
128 int end;
129 int users;
130 struct connection *con;
131};
132
133static struct sockaddr_storage *dlm_local_addr[DLM_MAX_ADDR_COUNT];
134static int dlm_local_count;
135
136/* Work queues */
137static struct workqueue_struct *recv_workqueue;
138static struct workqueue_struct *send_workqueue;
139
140static DEFINE_IDR(connections_idr);
141static DECLARE_MUTEX(connections_lock);
142static int max_nodeid;
143static struct kmem_cache *con_cache;
144
145static void process_recv_sockets(struct work_struct *work);
146static void process_send_sockets(struct work_struct *work);
147
148/*
149 * If 'allocation' is zero then we don't attempt to create a new
150 * connection structure for this node.
151 */
152static struct connection *__nodeid2con(int nodeid, gfp_t alloc)
153{
154 struct connection *con = NULL;
155 int r;
156 int n;
157
158 con = idr_find(&connections_idr, nodeid);
159 if (con || !alloc)
160 return con;
161
162 r = idr_pre_get(&connections_idr, alloc);
163 if (!r)
164 return NULL;
165
166 con = kmem_cache_zalloc(con_cache, alloc);
167 if (!con)
168 return NULL;
169
170 r = idr_get_new_above(&connections_idr, con, nodeid, &n);
171 if (r) {
172 kmem_cache_free(con_cache, con);
173 return NULL;
174 }
175
176 if (n != nodeid) {
177 idr_remove(&connections_idr, n);
178 kmem_cache_free(con_cache, con);
179 return NULL;
180 }
181
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);
188
189 /* Setup action pointers for child sockets */
190 if (con->nodeid) {
191 struct connection *zerocon = idr_find(&connections_idr, 0);
192
193 con->connect_action = zerocon->connect_action;
194 if (!con->rx_action)
195 con->rx_action = zerocon->rx_action;
196 }
197
198 if (nodeid > max_nodeid)
199 max_nodeid = nodeid;
200
201 return con;
202}
203
204static struct connection *nodeid2con(int nodeid, gfp_t allocation)
205{
206 struct connection *con;
207
208 down(&connections_lock);
209 con = __nodeid2con(nodeid, allocation);
210 up(&connections_lock);
211
212 return con;
213}
214
215/* This is a bit drastic, but only called when things go wrong */
216static struct connection *assoc2con(int assoc_id)
217{
218 int i;
219 struct connection *con;
220
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);
226 return con;
227 }
228 }
229 up(&connections_lock);
230 return NULL;
231}
232
233static int nodeid_to_addr(int nodeid, struct sockaddr *retaddr)
234{
235 struct sockaddr_storage addr;
236 int error;
237
238 if (!dlm_local_count)
239 return -1;
240
241 error = dlm_nodeid_to_addr(nodeid, &addr);
242 if (error)
243 return error;
244
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;
249 } else {
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));
254 }
255
256 return 0;
257}
258
259/* Data available on socket or listen socket received a connect */
260static void lowcomms_data_ready(struct sock *sk, int count_unused)
261{
262 struct connection *con = sock2con(sk);
263 if (!test_and_set_bit(CF_READ_PENDING, &con->flags))
264 queue_work(recv_workqueue, &con->rwork);
265}
266
267static void lowcomms_write_space(struct sock *sk)
268{
269 struct connection *con = sock2con(sk);
270
271 if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags))
272 queue_work(send_workqueue, &con->swork);
273}
274
275static inline void lowcomms_connect_sock(struct connection *con)
276{
277 if (!test_and_set_bit(CF_CONNECT_PENDING, &con->flags))
278 queue_work(send_workqueue, &con->swork);
279}
280
281static void lowcomms_state_change(struct sock *sk)
282{
283 if (sk->sk_state == TCP_ESTABLISHED)
284 lowcomms_write_space(sk);
285}
286
287/* Make a socket active */
288static int add_sock(struct socket *sock, struct connection *con)
289{
290 con->sock = sock;
291
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;
297 return 0;
298}
299
300/* Add the port number to an IPv6 or 4 sockaddr and return the address
301 length */
302static void make_sockaddr(struct sockaddr_storage *saddr, uint16_t port,
303 int *addr_len)
304{
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));
311 } else {
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);
315 }
316}
317
318/* Close a remote connection and tidy up */
319static void close_connection(struct connection *con, bool and_other)
320{
321 mutex_lock(&con->sock_mutex);
322
323 if (con->sock) {
324 sock_release(con->sock);
325 con->sock = NULL;
326 }
327 if (con->othercon && and_other) {
328 /* Will only re-enter once. */
329 close_connection(con->othercon, false);
330 }
331 if (con->rx_page) {
332 __free_page(con->rx_page);
333 con->rx_page = NULL;
334 }
335 con->retries = 0;
336 mutex_unlock(&con->sock_mutex);
337}
338
339/* We only send shutdown messages to nodes that are not part of the cluster */
340static void sctp_send_shutdown(sctp_assoc_t associd)
341{
342 static char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
343 struct msghdr outmessage;
344 struct cmsghdr *cmsg;
345 struct sctp_sndrcvinfo *sinfo;
346 int ret;
347 struct connection *con;
348
349 con = nodeid2con(0,0);
350 BUG_ON(con == NULL);
351
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;
357
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));
365
366 sinfo->sinfo_flags |= MSG_EOF;
367 sinfo->sinfo_assoc_id = associd;
368
369 ret = kernel_sendmsg(con->sock, &outmessage, NULL, 0, 0);
370
371 if (ret != 0)
372 log_print("send EOF to node failed: %d", ret);
373}
374
375/* INIT failed but we don't know which node...
376 restart INIT on all pending nodes */
377static void sctp_init_failed(void)
378{
379 int i;
380 struct connection *con;
381
382 down(&connections_lock);
383 for (i=1; i<=max_nodeid; i++) {
384 con = __nodeid2con(i, 0);
385 if (!con)
386 continue;
387 con->sctp_assoc = 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);
391 }
392 }
393 }
394 up(&connections_lock);
395}
396
397/* Something happened to an association */
398static void process_sctp_notification(struct connection *con, struct msghdr *msg, char *buf)
399{
400 union sctp_notification *sn = (union sctp_notification *)buf;
401
402 if (sn->sn_header.sn_type == SCTP_ASSOC_CHANGE) {
403 switch (sn->sn_assoc_change.sac_state) {
404
405 case SCTP_COMM_UP:
406 case SCTP_RESTART:
407 {
408 /* Check that the new node is in the lockspace */
409 struct sctp_prim prim;
410 int nodeid;
411 int prim_len, ret;
412 int addr_len;
413 struct connection *new_con;
414 struct file *file;
415 sctp_peeloff_arg_t parg;
416 int parglen = sizeof(parg);
417
418 /*
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.
422 */
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);
426 sctp_init_failed();
427 return;
428 }
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;
432
433 ret = kernel_getsockopt(con->sock,
434 IPPROTO_SCTP,
435 SCTP_PRIMARY_ADDR,
436 (char*)&prim,
437 &prim_len);
438 if (ret < 0) {
439 log_print("getsockopt/sctp_primary_addr on "
440 "new assoc %d failed : %d",
441 (int)sn->sn_assoc_change.sac_assoc_id,
442 ret);
443
444 /* Retry INIT later */
445 new_con = assoc2con(sn->sn_assoc_change.sac_assoc_id);
446 if (new_con)
447 clear_bit(CF_CONNECT_PENDING, &con->flags);
448 return;
449 }
450 make_sockaddr(&prim.ssp_addr, 0, &addr_len);
451 if (dlm_addr_to_nodeid(&prim.ssp_addr, &nodeid)) {
452 int i;
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]);
457 printk("\n");
458 sctp_send_shutdown(prim.ssp_assoc_id);
459 return;
460 }
461
462 new_con = nodeid2con(nodeid, GFP_KERNEL);
463 if (!new_con)
464 return;
465
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);
470 if (ret < 0) {
471 log_print("Can't peel off a socket for connection %d to node %d: err=%d\n",
472 parg.associd, nodeid, ret);
473 return;
474 }
475
476 file = fget(parg.sd);
477 new_con->sock = SOCKET_I(file->f_dentry->d_inode);
478 add_sock(new_con->sock, new_con);
479 fput(file);
480 put_unused_fd(parg.sd);
481
482 log_print("got new/restarted association %d nodeid %d",
483 (int)sn->sn_assoc_change.sac_assoc_id, nodeid);
484
485 /* Send any pending writes */
486 clear_bit(CF_CONNECT_PENDING, &new_con->flags);
487 clear_bit(CF_INIT_PENDING, &con->flags);
488 if (!test_and_set_bit(CF_WRITE_PENDING, &new_con->flags)) {
489 queue_work(send_workqueue, &new_con->swork);
490 }
491 if (!test_and_set_bit(CF_READ_PENDING, &new_con->flags))
492 queue_work(recv_workqueue, &new_con->rwork);
493 }
494 break;
495
496 case SCTP_COMM_LOST:
497 case SCTP_SHUTDOWN_COMP:
498 {
499 con = assoc2con(sn->sn_assoc_change.sac_assoc_id);
500 if (con) {
501 con->sctp_assoc = 0;
502 }
503 }
504 break;
505
506 /* We don't know which INIT failed, so clear the PENDING flags
507 * on them all. if assoc_id is zero then it will then try
508 * again */
509
510 case SCTP_CANT_STR_ASSOC:
511 {
512 log_print("Can't start SCTP association - retrying");
513 sctp_init_failed();
514 }
515 break;
516
517 default:
518 log_print("unexpected SCTP assoc change id=%d state=%d",
519 (int)sn->sn_assoc_change.sac_assoc_id,
520 sn->sn_assoc_change.sac_state);
521 }
522 }
523}
524
525/* Data received from remote end */
526static int receive_from_sock(struct connection *con)
527{
528 int ret = 0;
529 struct msghdr msg = {};
530 struct kvec iov[2];
531 unsigned len;
532 int r;
533 int call_again_soon = 0;
534 int nvec;
535 char incmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
536
537 mutex_lock(&con->sock_mutex);
538
539 if (con->sock == NULL) {
540 ret = -EAGAIN;
541 goto out_close;
542 }
543
544 if (con->rx_page == NULL) {
545 /*
546 * This doesn't need to be atomic, but I think it should
547 * improve performance if it is.
548 */
549 con->rx_page = alloc_page(GFP_ATOMIC);
550 if (con->rx_page == NULL)
551 goto out_resched;
552 cbuf_init(&con->cb, PAGE_CACHE_SIZE);
553 }
554
555 /* Only SCTP needs these really */
556 memset(&incmsg, 0, sizeof(incmsg));
557 msg.msg_control = incmsg;
558 msg.msg_controllen = sizeof(incmsg);
559
560 /*
561 * iov[0] is the bit of the circular buffer between the current end
562 * point (cb.base + cb.len) and the end of the buffer.
563 */
564 iov[0].iov_len = con->cb.base - cbuf_data(&con->cb);
565 iov[0].iov_base = page_address(con->rx_page) + cbuf_data(&con->cb);
566 iov[1].iov_len = 0;
567 nvec = 1;
568
569 /*
570 * iov[1] is the bit of the circular buffer between the start of the
571 * buffer and the start of the currently used section (cb.base)
572 */
573 if (cbuf_data(&con->cb) >= con->cb.base) {
574 iov[0].iov_len = PAGE_CACHE_SIZE - cbuf_data(&con->cb);
575 iov[1].iov_len = con->cb.base;
576 iov[1].iov_base = page_address(con->rx_page);
577 nvec = 2;
578 }
579 len = iov[0].iov_len + iov[1].iov_len;
580
581 r = ret = kernel_recvmsg(con->sock, &msg, iov, nvec, len,
582 MSG_DONTWAIT | MSG_NOSIGNAL);
583 if (ret <= 0)
584 goto out_close;
585
586 /* Process SCTP notifications */
587 if (msg.msg_flags & MSG_NOTIFICATION) {
588 BUG_ON(con->nodeid != 0);
589 msg.msg_control = incmsg;
590 msg.msg_controllen = sizeof(incmsg);
591
592 process_sctp_notification(con, &msg,
593 page_address(con->rx_page) + con->cb.base);
594 mutex_unlock(&con->sock_mutex);
595 return 0;
596 }
597 BUG_ON(con->nodeid == 0);
598
599 if (ret == len)
600 call_again_soon = 1;
601 cbuf_add(&con->cb, ret);
602 ret = dlm_process_incoming_buffer(con->nodeid,
603 page_address(con->rx_page),
604 con->cb.base, con->cb.len,
605 PAGE_CACHE_SIZE);
606 if (ret == -EBADMSG) {
607 printk(KERN_INFO "dlm: lowcomms: addr=%p, base=%u, len=%u, "
608 "iov_len=%u, iov_base[0]=%p, read=%d\n",
609 page_address(con->rx_page), con->cb.base, con->cb.len,
610 len, iov[0].iov_base, r);
611 }
612 if (ret < 0)
613 goto out_close;
614 cbuf_eat(&con->cb, ret);
615
616 if (cbuf_empty(&con->cb) && !call_again_soon) {
617 __free_page(con->rx_page);
618 con->rx_page = NULL;
619 }
620
621 if (call_again_soon)
622 goto out_resched;
623 mutex_unlock(&con->sock_mutex);
624 return 0;
625
626out_resched:
627 if (!test_and_set_bit(CF_READ_PENDING, &con->flags))
628 queue_work(recv_workqueue, &con->rwork);
629 mutex_unlock(&con->sock_mutex);
630 return -EAGAIN;
631
632out_close:
633 mutex_unlock(&con->sock_mutex);
634 if (ret != -EAGAIN && !test_bit(CF_IS_OTHERCON, &con->flags)) {
635 close_connection(con, false);
636 /* Reconnect when there is something to send */
637 }
638 /* Don't return success if we really got EOF */
639 if (ret == 0)
640 ret = -EAGAIN;
641
642 return ret;
643}
644
645/* Listening socket is busy, accept a connection */
646static int tcp_accept_from_sock(struct connection *con)
647{
648 int result;
649 struct sockaddr_storage peeraddr;
650 struct socket *newsock;
651 int len;
652 int nodeid;
653 struct connection *newcon;
654 struct connection *addcon;
655
656 memset(&peeraddr, 0, sizeof(peeraddr));
657 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM,
658 IPPROTO_TCP, &newsock);
659 if (result < 0)
660 return -ENOMEM;
661
662 mutex_lock_nested(&con->sock_mutex, 0);
663
664 result = -ENOTCONN;
665 if (con->sock == NULL)
666 goto accept_err;
667
668 newsock->type = con->sock->type;
669 newsock->ops = con->sock->ops;
670
671 result = con->sock->ops->accept(con->sock, newsock, O_NONBLOCK);
672 if (result < 0)
673 goto accept_err;
674
675 /* Get the connected socket's peer */
676 memset(&peeraddr, 0, sizeof(peeraddr));
677 if (newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr,
678 &len, 2)) {
679 result = -ECONNABORTED;
680 goto accept_err;
681 }
682
683 /* Get the new node's NODEID */
684 make_sockaddr(&peeraddr, 0, &len);
685 if (dlm_addr_to_nodeid(&peeraddr, &nodeid)) {
686 printk("dlm: connect from non cluster node\n");
687 sock_release(newsock);
688 mutex_unlock(&con->sock_mutex);
689 return -1;
690 }
691
692 log_print("got connection from %d", nodeid);
693
694 /* Check to see if we already have a connection to this node. This
695 * could happen if the two nodes initiate a connection at roughly
696 * the same time and the connections cross on the wire.
697 * In this case we store the incoming one in "othercon"
698 */
699 newcon = nodeid2con(nodeid, GFP_KERNEL);
700 if (!newcon) {
701 result = -ENOMEM;
702 goto accept_err;
703 }
704 mutex_lock_nested(&newcon->sock_mutex, 1);
705 if (newcon->sock) {
706 struct connection *othercon = newcon->othercon;
707
708 if (!othercon) {
709 othercon = kmem_cache_zalloc(con_cache, GFP_KERNEL);
710 if (!othercon) {
711 printk("dlm: failed to allocate incoming socket\n");
712 mutex_unlock(&newcon->sock_mutex);
713 result = -ENOMEM;
714 goto accept_err;
715 }
716 othercon->nodeid = nodeid;
717 othercon->rx_action = receive_from_sock;
718 mutex_init(&othercon->sock_mutex);
719 INIT_WORK(&othercon->swork, process_send_sockets);
720 INIT_WORK(&othercon->rwork, process_recv_sockets);
721 set_bit(CF_IS_OTHERCON, &othercon->flags);
722 newcon->othercon = othercon;
723 }
724 othercon->sock = newsock;
725 newsock->sk->sk_user_data = othercon;
726 add_sock(newsock, othercon);
727 addcon = othercon;
728 }
729 else {
730 newsock->sk->sk_user_data = newcon;
731 newcon->rx_action = receive_from_sock;
732 add_sock(newsock, newcon);
733 addcon = newcon;
734 }
735
736 mutex_unlock(&newcon->sock_mutex);
737
738 /*
739 * Add it to the active queue in case we got data
740 * beween processing the accept adding the socket
741 * to the read_sockets list
742 */
743 if (!test_and_set_bit(CF_READ_PENDING, &addcon->flags))
744 queue_work(recv_workqueue, &addcon->rwork);
745 mutex_unlock(&con->sock_mutex);
746
747 return 0;
748
749accept_err:
750 mutex_unlock(&con->sock_mutex);
751 sock_release(newsock);
752
753 if (result != -EAGAIN)
754 printk("dlm: error accepting connection from node: %d\n", result);
755 return result;
756}
757
758static void free_entry(struct writequeue_entry *e)
759{
760 __free_page(e->page);
761 kfree(e);
762}
763
764/* Initiate an SCTP association.
765 This is a special case of send_to_sock() in that we don't yet have a
766 peeled-off socket for this association, so we use the listening socket
767 and add the primary IP address of the remote node.
768 */
769static void sctp_init_assoc(struct connection *con)
770{
771 struct sockaddr_storage rem_addr;
772 char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
773 struct msghdr outmessage;
774 struct cmsghdr *cmsg;
775 struct sctp_sndrcvinfo *sinfo;
776 struct connection *base_con;
777 struct writequeue_entry *e;
778 int len, offset;
779 int ret;
780 int addrlen;
781 struct kvec iov[1];
782
783 if (test_and_set_bit(CF_INIT_PENDING, &con->flags))
784 return;
785
786 if (con->retries++ > MAX_CONNECT_RETRIES)
787 return;
788
789 log_print("Initiating association with node %d", con->nodeid);
790
791 if (nodeid_to_addr(con->nodeid, (struct sockaddr *)&rem_addr)) {
792 log_print("no address for nodeid %d", con->nodeid);
793 return;
794 }
795 base_con = nodeid2con(0, 0);
796 BUG_ON(base_con == NULL);
797
798 make_sockaddr(&rem_addr, dlm_config.ci_tcp_port, &addrlen);
799
800 outmessage.msg_name = &rem_addr;
801 outmessage.msg_namelen = addrlen;
802 outmessage.msg_control = outcmsg;
803 outmessage.msg_controllen = sizeof(outcmsg);
804 outmessage.msg_flags = MSG_EOR;
805
806 spin_lock(&con->writequeue_lock);
807 e = list_entry(con->writequeue.next, struct writequeue_entry,
808 list);
809
810 BUG_ON((struct list_head *) e == &con->writequeue);
811
812 len = e->len;
813 offset = e->offset;
814 spin_unlock(&con->writequeue_lock);
815 kmap(e->page);
816
817 /* Send the first block off the write queue */
818 iov[0].iov_base = page_address(e->page)+offset;
819 iov[0].iov_len = len;
820
821 cmsg = CMSG_FIRSTHDR(&outmessage);
822 cmsg->cmsg_level = IPPROTO_SCTP;
823 cmsg->cmsg_type = SCTP_SNDRCV;
824 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
825 sinfo = CMSG_DATA(cmsg);
826 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
827 sinfo->sinfo_ppid = cpu_to_le32(dlm_our_nodeid());
828 outmessage.msg_controllen = cmsg->cmsg_len;
829
830 ret = kernel_sendmsg(base_con->sock, &outmessage, iov, 1, len);
831 if (ret < 0) {
832 log_print("Send first packet to node %d failed: %d", con->nodeid, ret);
833
834 /* Try again later */
835 clear_bit(CF_CONNECT_PENDING, &con->flags);
836 clear_bit(CF_INIT_PENDING, &con->flags);
837 }
838 else {
839 spin_lock(&con->writequeue_lock);
840 e->offset += ret;
841 e->len -= ret;
842
843 if (e->len == 0 && e->users == 0) {
844 list_del(&e->list);
845 kunmap(e->page);
846 free_entry(e);
847 }
848 spin_unlock(&con->writequeue_lock);
849 }
850}
851
852/* Connect a new socket to its peer */
853static void tcp_connect_to_sock(struct connection *con)
854{
855 int result = -EHOSTUNREACH;
856 struct sockaddr_storage saddr;
857 int addr_len;
858 struct socket *sock;
859
860 if (con->nodeid == 0) {
861 log_print("attempt to connect sock 0 foiled");
862 return;
863 }
864
865 mutex_lock(&con->sock_mutex);
866 if (con->retries++ > MAX_CONNECT_RETRIES)
867 goto out;
868
869 /* Some odd races can cause double-connects, ignore them */
870 if (con->sock) {
871 result = 0;
872 goto out;
873 }
874
875 /* Create a socket to communicate with */
876 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM,
877 IPPROTO_TCP, &sock);
878 if (result < 0)
879 goto out_err;
880
881 memset(&saddr, 0, sizeof(saddr));
882 if (dlm_nodeid_to_addr(con->nodeid, &saddr))
883 goto out_err;
884
885 sock->sk->sk_user_data = con;
886 con->rx_action = receive_from_sock;
887 con->connect_action = tcp_connect_to_sock;
888 add_sock(sock, con);
889
890 make_sockaddr(&saddr, dlm_config.ci_tcp_port, &addr_len);
891
892 log_print("connecting to %d", con->nodeid);
893 result =
894 sock->ops->connect(sock, (struct sockaddr *)&saddr, addr_len,
895 O_NONBLOCK);
896 if (result == -EINPROGRESS)
897 result = 0;
898 if (result == 0)
899 goto out;
900
901out_err:
902 if (con->sock) {
903 sock_release(con->sock);
904 con->sock = NULL;
905 }
906 /*
907 * Some errors are fatal and this list might need adjusting. For other
908 * errors we try again until the max number of retries is reached.
909 */
910 if (result != -EHOSTUNREACH && result != -ENETUNREACH &&
911 result != -ENETDOWN && result != EINVAL
912 && result != -EPROTONOSUPPORT) {
913 lowcomms_connect_sock(con);
914 result = 0;
915 }
916out:
917 mutex_unlock(&con->sock_mutex);
918 return;
919}
920
921static struct socket *tcp_create_listen_sock(struct connection *con,
922 struct sockaddr_storage *saddr)
923{
924 struct socket *sock = NULL;
925 int result = 0;
926 int one = 1;
927 int addr_len;
928
929 if (dlm_local_addr[0]->ss_family == AF_INET)
930 addr_len = sizeof(struct sockaddr_in);
931 else
932 addr_len = sizeof(struct sockaddr_in6);
933
934 /* Create a socket to communicate with */
935 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_STREAM, IPPROTO_TCP, &sock);
936 if (result < 0) {
937 printk("dlm: Can't create listening comms socket\n");
938 goto create_out;
939 }
940
941 result = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
942 (char *)&one, sizeof(one));
943
944 if (result < 0) {
945 printk("dlm: Failed to set SO_REUSEADDR on socket: result=%d\n",
946 result);
947 }
948 sock->sk->sk_user_data = con;
949 con->rx_action = tcp_accept_from_sock;
950 con->connect_action = tcp_connect_to_sock;
951 con->sock = sock;
952
953 /* Bind to our port */
954 make_sockaddr(saddr, dlm_config.ci_tcp_port, &addr_len);
955 result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len);
956 if (result < 0) {
957 printk("dlm: Can't bind to port %d\n", dlm_config.ci_tcp_port);
958 sock_release(sock);
959 sock = NULL;
960 con->sock = NULL;
961 goto create_out;
962 }
963 result = kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
964 (char *)&one, sizeof(one));
965 if (result < 0) {
966 printk("dlm: Set keepalive failed: %d\n", result);
967 }
968
969 result = sock->ops->listen(sock, 5);
970 if (result < 0) {
971 printk("dlm: Can't listen on port %d\n", dlm_config.ci_tcp_port);
972 sock_release(sock);
973 sock = NULL;
974 goto create_out;
975 }
976
977create_out:
978 return sock;
979}
980
981/* Get local addresses */
982static void init_local(void)
983{
984 struct sockaddr_storage sas, *addr;
985 int i;
986
987 for (i = 0; i < DLM_MAX_ADDR_COUNT - 1; i++) {
988 if (dlm_our_addr(&sas, i))
989 break;
990
991 addr = kmalloc(sizeof(*addr), GFP_KERNEL);
992 if (!addr)
993 break;
994 memcpy(addr, &sas, sizeof(*addr));
995 dlm_local_addr[dlm_local_count++] = addr;
996 }
997}
998
999/* Bind to an IP address. SCTP allows multiple address so it can do multi-homing */
1000static int add_sctp_bind_addr(struct connection *sctp_con, struct sockaddr_storage *addr, int addr_len, int num)
1001{
1002 int result = 0;
1003
1004 if (num == 1)
1005 result = kernel_bind(sctp_con->sock,
1006 (struct sockaddr *) addr,
1007 addr_len);
1008 else
1009 result = kernel_setsockopt(sctp_con->sock, SOL_SCTP,
1010 SCTP_SOCKOPT_BINDX_ADD,
1011 (char *)addr, addr_len);
1012
1013 if (result < 0)
1014 log_print("Can't bind to port %d addr number %d",
1015 dlm_config.ci_tcp_port, num);
1016
1017 return result;
1018}
1019
1020/* Initialise SCTP socket and bind to all interfaces */
1021static int sctp_listen_for_all(void)
1022{
1023 struct socket *sock = NULL;
1024 struct sockaddr_storage localaddr;
1025 struct sctp_event_subscribe subscribe;
1026 int result = -EINVAL, num = 1, i, addr_len;
1027 struct connection *con = nodeid2con(0, GFP_KERNEL);
1028 int bufsize = NEEDED_RMEM;
1029
1030 if (!con)
1031 return -ENOMEM;
1032
1033 log_print("Using SCTP for communications");
1034
1035 result = sock_create_kern(dlm_local_addr[0]->ss_family, SOCK_SEQPACKET,
1036 IPPROTO_SCTP, &sock);
1037 if (result < 0) {
1038 log_print("Can't create comms socket, check SCTP is loaded");
1039 goto out;
1040 }
1041
1042 /* Listen for events */
1043 memset(&subscribe, 0, sizeof(subscribe));
1044 subscribe.sctp_data_io_event = 1;
1045 subscribe.sctp_association_event = 1;
1046 subscribe.sctp_send_failure_event = 1;
1047 subscribe.sctp_shutdown_event = 1;
1048 subscribe.sctp_partial_delivery_event = 1;
1049
1050 result = kernel_setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
1051 (char *)&bufsize, sizeof(bufsize));
1052 if (result)
1053 log_print("Error increasing buffer space on socket: %d", result);
1054
1055 result = kernel_setsockopt(sock, SOL_SCTP, SCTP_EVENTS,
1056 (char *)&subscribe, sizeof(subscribe));
1057 if (result < 0) {
1058 log_print("Failed to set SCTP_EVENTS on socket: result=%d",
1059 result);
1060 goto create_delsock;
1061 }
1062
1063 /* Init con struct */
1064 sock->sk->sk_user_data = con;
1065 con->sock = sock;
1066 con->sock->sk->sk_data_ready = lowcomms_data_ready;
1067 con->rx_action = receive_from_sock;
1068 con->connect_action = sctp_init_assoc;
1069
1070 /* Bind to all interfaces. */
1071 for (i = 0; i < dlm_local_count; i++) {
1072 memcpy(&localaddr, dlm_local_addr[i], sizeof(localaddr));
1073 make_sockaddr(&localaddr, dlm_config.ci_tcp_port, &addr_len);
1074
1075 result = add_sctp_bind_addr(con, &localaddr, addr_len, num);
1076 if (result)
1077 goto create_delsock;
1078 ++num;
1079 }
1080
1081 result = sock->ops->listen(sock, 5);
1082 if (result < 0) {
1083 log_print("Can't set socket listening");
1084 goto create_delsock;
1085 }
1086
1087 return 0;
1088
1089create_delsock:
1090 sock_release(sock);
1091 con->sock = NULL;
1092out:
1093 return result;
1094}
1095
1096static int tcp_listen_for_all(void)
1097{
1098 struct socket *sock = NULL;
1099 struct connection *con = nodeid2con(0, GFP_KERNEL);
1100 int result = -EINVAL;
1101
1102 if (!con)
1103 return -ENOMEM;
1104
1105 /* We don't support multi-homed hosts */
1106 if (dlm_local_addr[1] != NULL) {
1107 log_print("TCP protocol can't handle multi-homed hosts, try SCTP");
1108 return -EINVAL;
1109 }
1110
1111 log_print("Using TCP for communications");
1112
1113 set_bit(CF_IS_OTHERCON, &con->flags);
1114
1115 sock = tcp_create_listen_sock(con, dlm_local_addr[0]);
1116 if (sock) {
1117 add_sock(sock, con);
1118 result = 0;
1119 }
1120 else {
1121 result = -EADDRINUSE;
1122 }
1123
1124 return result;
1125}
1126
1127
1128
1129static struct writequeue_entry *new_writequeue_entry(struct connection *con,
1130 gfp_t allocation)
1131{
1132 struct writequeue_entry *entry;
1133
1134 entry = kmalloc(sizeof(struct writequeue_entry), allocation);
1135 if (!entry)
1136 return NULL;
1137
1138 entry->page = alloc_page(allocation);
1139 if (!entry->page) {
1140 kfree(entry);
1141 return NULL;
1142 }
1143
1144 entry->offset = 0;
1145 entry->len = 0;
1146 entry->end = 0;
1147 entry->users = 0;
1148 entry->con = con;
1149
1150 return entry;
1151}
1152
1153void *dlm_lowcomms_get_buffer(int nodeid, int len,
1154 gfp_t allocation, char **ppc)
1155{
1156 struct connection *con;
1157 struct writequeue_entry *e;
1158 int offset = 0;
1159 int users = 0;
1160
1161 con = nodeid2con(nodeid, allocation);
1162 if (!con)
1163 return NULL;
1164
1165 spin_lock(&con->writequeue_lock);
1166 e = list_entry(con->writequeue.prev, struct writequeue_entry, list);
1167 if ((&e->list == &con->writequeue) ||
1168 (PAGE_CACHE_SIZE - e->end < len)) {
1169 e = NULL;
1170 } else {
1171 offset = e->end;
1172 e->end += len;
1173 users = e->users++;
1174 }
1175 spin_unlock(&con->writequeue_lock);
1176
1177 if (e) {
1178 got_one:
1179 if (users == 0)
1180 kmap(e->page);
1181 *ppc = page_address(e->page) + offset;
1182 return e;
1183 }
1184
1185 e = new_writequeue_entry(con, allocation);
1186 if (e) {
1187 spin_lock(&con->writequeue_lock);
1188 offset = e->end;
1189 e->end += len;
1190 users = e->users++;
1191 list_add_tail(&e->list, &con->writequeue);
1192 spin_unlock(&con->writequeue_lock);
1193 goto got_one;
1194 }
1195 return NULL;
1196}
1197
1198void dlm_lowcomms_commit_buffer(void *mh)
1199{
1200 struct writequeue_entry *e = (struct writequeue_entry *)mh;
1201 struct connection *con = e->con;
1202 int users;
1203
1204 spin_lock(&con->writequeue_lock);
1205 users = --e->users;
1206 if (users)
1207 goto out;
1208 e->len = e->end - e->offset;
1209 kunmap(e->page);
1210 spin_unlock(&con->writequeue_lock);
1211
1212 if (!test_and_set_bit(CF_WRITE_PENDING, &con->flags)) {
1213 queue_work(send_workqueue, &con->swork);
1214 }
1215 return;
1216
1217out:
1218 spin_unlock(&con->writequeue_lock);
1219 return;
1220}
1221
1222/* Send a message */
1223static void send_to_sock(struct connection *con)
1224{
1225 int ret = 0;
1226 ssize_t(*sendpage) (struct socket *, struct page *, int, size_t, int);
1227 const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL;
1228 struct writequeue_entry *e;
1229 int len, offset;
1230
1231 mutex_lock(&con->sock_mutex);
1232 if (con->sock == NULL)
1233 goto out_connect;
1234
1235 sendpage = con->sock->ops->sendpage;
1236
1237 spin_lock(&con->writequeue_lock);
1238 for (;;) {
1239 e = list_entry(con->writequeue.next, struct writequeue_entry,
1240 list);
1241 if ((struct list_head *) e == &con->writequeue)
1242 break;
1243
1244 len = e->len;
1245 offset = e->offset;
1246 BUG_ON(len == 0 && e->users == 0);
1247 spin_unlock(&con->writequeue_lock);
1248 kmap(e->page);
1249
1250 ret = 0;
1251 if (len) {
1252 ret = sendpage(con->sock, e->page, offset, len,
1253 msg_flags);
1254 if (ret == -EAGAIN || ret == 0)
1255 goto out;
1256 if (ret <= 0)
1257 goto send_error;
1258 }
1259 else {
1260 /* Don't starve people filling buffers */
1261 cond_resched();
1262 }
1263
1264 spin_lock(&con->writequeue_lock);
1265 e->offset += ret;
1266 e->len -= ret;
1267
1268 if (e->len == 0 && e->users == 0) {
1269 list_del(&e->list);
1270 kunmap(e->page);
1271 free_entry(e);
1272 continue;
1273 }
1274 }
1275 spin_unlock(&con->writequeue_lock);
1276out:
1277 mutex_unlock(&con->sock_mutex);
1278 return;
1279
1280send_error:
1281 mutex_unlock(&con->sock_mutex);
1282 close_connection(con, false);
1283 lowcomms_connect_sock(con);
1284 return;
1285
1286out_connect:
1287 mutex_unlock(&con->sock_mutex);
1288 if (!test_bit(CF_INIT_PENDING, &con->flags))
1289 lowcomms_connect_sock(con);
1290 return;
1291}
1292
1293static void clean_one_writequeue(struct connection *con)
1294{
1295 struct list_head *list;
1296 struct list_head *temp;
1297
1298 spin_lock(&con->writequeue_lock);
1299 list_for_each_safe(list, temp, &con->writequeue) {
1300 struct writequeue_entry *e =
1301 list_entry(list, struct writequeue_entry, list);
1302 list_del(&e->list);
1303 free_entry(e);
1304 }
1305 spin_unlock(&con->writequeue_lock);
1306}
1307
1308/* Called from recovery when it knows that a node has
1309 left the cluster */
1310int dlm_lowcomms_close(int nodeid)
1311{
1312 struct connection *con;
1313
1314 log_print("closing connection to node %d", nodeid);
1315 con = nodeid2con(nodeid, 0);
1316 if (con) {
1317 clean_one_writequeue(con);
1318 close_connection(con, true);
1319 }
1320 return 0;
1321}
1322
1323/* Receive workqueue function */
1324static void process_recv_sockets(struct work_struct *work)
1325{
1326 struct connection *con = container_of(work, struct connection, rwork);
1327 int err;
1328
1329 clear_bit(CF_READ_PENDING, &con->flags);
1330 do {
1331 err = con->rx_action(con);
1332 } while (!err);
1333}
1334
1335/* Send workqueue function */
1336static void process_send_sockets(struct work_struct *work)
1337{
1338 struct connection *con = container_of(work, struct connection, swork);
1339
1340 if (test_and_clear_bit(CF_CONNECT_PENDING, &con->flags)) {
1341 con->connect_action(con);
1342 }
1343 clear_bit(CF_WRITE_PENDING, &con->flags);
1344 send_to_sock(con);
1345}
1346
1347
1348/* Discard all entries on the write queues */
1349static void clean_writequeues(void)
1350{
1351 int nodeid;
1352
1353 for (nodeid = 1; nodeid < max_nodeid; nodeid++) {
1354 struct connection *con = nodeid2con(nodeid, 0);
1355
1356 if (con)
1357 clean_one_writequeue(con);
1358 }
1359}
1360
1361static void work_stop(void)
1362{
1363 destroy_workqueue(recv_workqueue);
1364 destroy_workqueue(send_workqueue);
1365}
1366
1367static int work_start(void)
1368{
1369 int error;
1370 recv_workqueue = create_workqueue("dlm_recv");
1371 error = IS_ERR(recv_workqueue);
1372 if (error) {
1373 log_print("can't start dlm_recv %d", error);
1374 return error;
1375 }
1376
1377 send_workqueue = create_singlethread_workqueue("dlm_send");
1378 error = IS_ERR(send_workqueue);
1379 if (error) {
1380 log_print("can't start dlm_send %d", error);
1381 destroy_workqueue(recv_workqueue);
1382 return error;
1383 }
1384
1385 return 0;
1386}
1387
1388void dlm_lowcomms_stop(void)
1389{
1390 int i;
1391 struct connection *con;
1392
1393 /* Set all the flags to prevent any
1394 socket activity.
1395 */
1396 down(&connections_lock);
1397 for (i = 0; i < max_nodeid; i++) {
1398 con = __nodeid2con(i, 0);
1399 if (con)
1400 con->flags |= 0xFF;
1401 }
1402 up(&connections_lock);
1403
1404 work_stop();
1405
1406 down(&connections_lock);
1407 clean_writequeues();
1408
1409 for (i = 0; i < max_nodeid; i++) {
1410 con = nodeid2con(i, 0);
1411 if (con) {
1412 close_connection(con, true);
1413 if (con->othercon)
1414 kmem_cache_free(con_cache, con->othercon);
1415 kmem_cache_free(con_cache, con);
1416 }
1417 }
1418 up(&connections_lock);
1419 kmem_cache_destroy(con_cache);
1420}
1421
1422int dlm_lowcomms_start(void)
1423{
1424 int error = -EINVAL;
1425 struct connection *con;
1426
1427 init_local();
1428 if (!dlm_local_count) {
1429 log_print("no local IP address has been set");
1430 goto out;
1431 }
1432
1433 error = -ENOMEM;
1434 con_cache = kmem_cache_create("dlm_conn", sizeof(struct connection),
1435 __alignof__(struct connection), 0,
1436 NULL, NULL);
1437 if (!con_cache)
1438 goto out;
1439
1440 /* Set some sysctl minima */
1441 if (sysctl_rmem_max < NEEDED_RMEM)
1442 sysctl_rmem_max = NEEDED_RMEM;
1443
1444 /* Start listening */
1445 if (dlm_config.ci_protocol == 0)
1446 error = tcp_listen_for_all();
1447 else
1448 error = sctp_listen_for_all();
1449 if (error)
1450 goto fail_unlisten;
1451
1452 error = work_start();
1453 if (error)
1454 goto fail_unlisten;
1455
1456 return 0;
1457
1458fail_unlisten:
1459 con = nodeid2con(0,0);
1460 if (con) {
1461 close_connection(con, false);
1462 kmem_cache_free(con_cache, con);
1463 }
1464 kmem_cache_destroy(con_cache);
1465
1466out:
1467 return error;
1468}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-19 13:51:11 -0500