2 * IPVS An implementation of the IP virtual server support for the
3 * LINUX operating system. IPVS is now implemented as a module
4 * over the NetFilter framework. IPVS can be used to build a
5 * high-performance and highly available server based on a
8 * Version: $Id: ip_vs_sync.c,v 1.13 2003/06/08 09:31:19 wensong Exp $
10 * Authors: Wensong Zhang <wensong@linuxvirtualserver.org>
12 * ip_vs_sync: sync connection info from master load balancer to backups
16 * Alexandre Cassen : Added master & backup support at a time.
17 * Alexandre Cassen : Added SyncID support for incoming sync
19 * Justin Ossevoort : Fix endian problem on sync message size.
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/inetdevice.h>
25 #include <linux/net.h>
26 #include <linux/completion.h>
27 #include <linux/delay.h>
28 #include <linux/skbuff.h>
30 #include <linux/igmp.h> /* for ip_mc_join_group */
31 #include <linux/udp.h>
35 #include <asm/uaccess.h> /* for get_fs and set_fs */
37 #include <net/ip_vs.h>
39 #define IP_VS_SYNC_GROUP 0xe0000051 /* multicast addr - 224.0.0.81 */
40 #define IP_VS_SYNC_PORT 8848 /* multicast port */
44 * IPVS sync connection entry
46 struct ip_vs_sync_conn
{
49 /* Protocol, addresses and port numbers */
50 __u8 protocol
; /* Which protocol (TCP/UDP) */
54 __be32 caddr
; /* client address */
55 __be32 vaddr
; /* virtual address */
56 __be32 daddr
; /* destination address */
58 /* Flags and state transition */
59 __be16 flags
; /* status flags */
60 __be16 state
; /* state info */
62 /* The sequence options start here */
65 struct ip_vs_sync_conn_options
{
66 struct ip_vs_seq in_seq
; /* incoming seq. struct */
67 struct ip_vs_seq out_seq
; /* outgoing seq. struct */
70 struct ip_vs_sync_thread_data
{
71 struct completion
*startup
;
75 #define SIMPLE_CONN_SIZE (sizeof(struct ip_vs_sync_conn))
76 #define FULL_CONN_SIZE \
77 (sizeof(struct ip_vs_sync_conn) + sizeof(struct ip_vs_sync_conn_options))
81 The master mulitcasts messages to the backup load balancers in the
85 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
86 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
87 | Count Conns | SyncID | Size |
88 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
90 | IPVS Sync Connection (1) |
91 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
95 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
97 | IPVS Sync Connection (n) |
98 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
101 #define SYNC_MESG_HEADER_LEN 4
103 struct ip_vs_sync_mesg
{
108 /* ip_vs_sync_conn entries start here */
111 /* the maximum length of sync (sending/receiving) message */
112 static int sync_send_mesg_maxlen
;
113 static int sync_recv_mesg_maxlen
;
115 struct ip_vs_sync_buff
{
116 struct list_head list
;
117 unsigned long firstuse
;
119 /* pointers for the message data */
120 struct ip_vs_sync_mesg
*mesg
;
126 /* the sync_buff list head and the lock */
127 static LIST_HEAD(ip_vs_sync_queue
);
128 static DEFINE_SPINLOCK(ip_vs_sync_lock
);
130 /* current sync_buff for accepting new conn entries */
131 static struct ip_vs_sync_buff
*curr_sb
= NULL
;
132 static DEFINE_SPINLOCK(curr_sb_lock
);
134 /* ipvs sync daemon state */
135 volatile int ip_vs_sync_state
= IP_VS_STATE_NONE
;
136 volatile int ip_vs_master_syncid
= 0;
137 volatile int ip_vs_backup_syncid
= 0;
139 /* multicast interface name */
140 char ip_vs_master_mcast_ifn
[IP_VS_IFNAME_MAXLEN
];
141 char ip_vs_backup_mcast_ifn
[IP_VS_IFNAME_MAXLEN
];
144 static struct sockaddr_in mcast_addr
;
147 static inline void sb_queue_tail(struct ip_vs_sync_buff
*sb
)
149 spin_lock(&ip_vs_sync_lock
);
150 list_add_tail(&sb
->list
, &ip_vs_sync_queue
);
151 spin_unlock(&ip_vs_sync_lock
);
154 static inline struct ip_vs_sync_buff
* sb_dequeue(void)
156 struct ip_vs_sync_buff
*sb
;
158 spin_lock_bh(&ip_vs_sync_lock
);
159 if (list_empty(&ip_vs_sync_queue
)) {
162 sb
= list_entry(ip_vs_sync_queue
.next
,
163 struct ip_vs_sync_buff
,
167 spin_unlock_bh(&ip_vs_sync_lock
);
172 static inline struct ip_vs_sync_buff
* ip_vs_sync_buff_create(void)
174 struct ip_vs_sync_buff
*sb
;
176 if (!(sb
=kmalloc(sizeof(struct ip_vs_sync_buff
), GFP_ATOMIC
)))
179 if (!(sb
->mesg
=kmalloc(sync_send_mesg_maxlen
, GFP_ATOMIC
))) {
183 sb
->mesg
->nr_conns
= 0;
184 sb
->mesg
->syncid
= ip_vs_master_syncid
;
186 sb
->head
= (unsigned char *)sb
->mesg
+ 4;
187 sb
->end
= (unsigned char *)sb
->mesg
+ sync_send_mesg_maxlen
;
188 sb
->firstuse
= jiffies
;
192 static inline void ip_vs_sync_buff_release(struct ip_vs_sync_buff
*sb
)
199 * Get the current sync buffer if it has been created for more
200 * than the specified time or the specified time is zero.
202 static inline struct ip_vs_sync_buff
*
203 get_curr_sync_buff(unsigned long time
)
205 struct ip_vs_sync_buff
*sb
;
207 spin_lock_bh(&curr_sb_lock
);
208 if (curr_sb
&& (time
== 0 ||
209 time_before(jiffies
- curr_sb
->firstuse
, time
))) {
214 spin_unlock_bh(&curr_sb_lock
);
220 * Add an ip_vs_conn information into the current sync_buff.
221 * Called by ip_vs_in.
223 void ip_vs_sync_conn(struct ip_vs_conn
*cp
)
225 struct ip_vs_sync_mesg
*m
;
226 struct ip_vs_sync_conn
*s
;
229 spin_lock(&curr_sb_lock
);
231 if (!(curr_sb
=ip_vs_sync_buff_create())) {
232 spin_unlock(&curr_sb_lock
);
233 IP_VS_ERR("ip_vs_sync_buff_create failed.\n");
238 len
= (cp
->flags
& IP_VS_CONN_F_SEQ_MASK
) ? FULL_CONN_SIZE
:
241 s
= (struct ip_vs_sync_conn
*)curr_sb
->head
;
244 s
->protocol
= cp
->protocol
;
245 s
->cport
= cp
->cport
;
246 s
->vport
= cp
->vport
;
247 s
->dport
= cp
->dport
;
248 s
->caddr
= cp
->caddr
;
249 s
->vaddr
= cp
->vaddr
;
250 s
->daddr
= cp
->daddr
;
251 s
->flags
= htons(cp
->flags
& ~IP_VS_CONN_F_HASHED
);
252 s
->state
= htons(cp
->state
);
253 if (cp
->flags
& IP_VS_CONN_F_SEQ_MASK
) {
254 struct ip_vs_sync_conn_options
*opt
=
255 (struct ip_vs_sync_conn_options
*)&s
[1];
256 memcpy(opt
, &cp
->in_seq
, sizeof(*opt
));
261 curr_sb
->head
+= len
;
263 /* check if there is a space for next one */
264 if (curr_sb
->head
+FULL_CONN_SIZE
> curr_sb
->end
) {
265 sb_queue_tail(curr_sb
);
268 spin_unlock(&curr_sb_lock
);
270 /* synchronize its controller if it has */
272 ip_vs_sync_conn(cp
->control
);
277 * Process received multicast message and create the corresponding
278 * ip_vs_conn entries.
280 static void ip_vs_process_message(const char *buffer
, const size_t buflen
)
282 struct ip_vs_sync_mesg
*m
= (struct ip_vs_sync_mesg
*)buffer
;
283 struct ip_vs_sync_conn
*s
;
284 struct ip_vs_sync_conn_options
*opt
;
285 struct ip_vs_conn
*cp
;
286 struct ip_vs_protocol
*pp
;
287 struct ip_vs_dest
*dest
;
291 /* Convert size back to host byte order */
292 m
->size
= ntohs(m
->size
);
294 if (buflen
!= m
->size
) {
295 IP_VS_ERR("bogus message\n");
299 /* SyncID sanity check */
300 if (ip_vs_backup_syncid
!= 0 && m
->syncid
!= ip_vs_backup_syncid
) {
301 IP_VS_DBG(7, "Ignoring incoming msg with syncid = %d\n",
306 p
= (char *)buffer
+ sizeof(struct ip_vs_sync_mesg
);
307 for (i
=0; i
<m
->nr_conns
; i
++) {
310 s
= (struct ip_vs_sync_conn
*)p
;
311 flags
= ntohs(s
->flags
) | IP_VS_CONN_F_SYNC
;
312 if (!(flags
& IP_VS_CONN_F_TEMPLATE
))
313 cp
= ip_vs_conn_in_get(s
->protocol
,
317 cp
= ip_vs_ct_in_get(s
->protocol
,
322 * Find the appropriate destination for the connection.
323 * If it is not found the connection will remain unbound
326 dest
= ip_vs_find_dest(s
->daddr
, s
->dport
,
329 cp
= ip_vs_conn_new(s
->protocol
,
335 atomic_dec(&dest
->refcnt
);
337 IP_VS_ERR("ip_vs_conn_new failed\n");
340 cp
->state
= ntohs(s
->state
);
341 } else if (!cp
->dest
) {
342 dest
= ip_vs_try_bind_dest(cp
);
344 /* it is an unbound entry created by
346 cp
->flags
= flags
| IP_VS_CONN_F_HASHED
;
348 atomic_dec(&dest
->refcnt
);
349 } /* Note that we don't touch its state and flags
350 if it is a normal entry. */
352 if (flags
& IP_VS_CONN_F_SEQ_MASK
) {
353 opt
= (struct ip_vs_sync_conn_options
*)&s
[1];
354 memcpy(&cp
->in_seq
, opt
, sizeof(*opt
));
357 p
+= SIMPLE_CONN_SIZE
;
359 atomic_set(&cp
->in_pkts
, sysctl_ip_vs_sync_threshold
[0]);
360 cp
->state
= ntohs(s
->state
);
361 pp
= ip_vs_proto_get(s
->protocol
);
362 cp
->timeout
= pp
->timeout_table
[cp
->state
];
365 if (p
> buffer
+buflen
) {
366 IP_VS_ERR("bogus message\n");
374 * Setup loopback of outgoing multicasts on a sending socket
376 static void set_mcast_loop(struct sock
*sk
, u_char loop
)
378 struct inet_sock
*inet
= inet_sk(sk
);
380 /* setsockopt(sock, SOL_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)); */
382 inet
->mc_loop
= loop
? 1 : 0;
387 * Specify TTL for outgoing multicasts on a sending socket
389 static void set_mcast_ttl(struct sock
*sk
, u_char ttl
)
391 struct inet_sock
*inet
= inet_sk(sk
);
393 /* setsockopt(sock, SOL_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)); */
400 * Specifiy default interface for outgoing multicasts
402 static int set_mcast_if(struct sock
*sk
, char *ifname
)
404 struct net_device
*dev
;
405 struct inet_sock
*inet
= inet_sk(sk
);
407 if ((dev
= __dev_get_by_name(&init_net
, ifname
)) == NULL
)
410 if (sk
->sk_bound_dev_if
&& dev
->ifindex
!= sk
->sk_bound_dev_if
)
414 inet
->mc_index
= dev
->ifindex
;
415 /* inet->mc_addr = 0; */
423 * Set the maximum length of sync message according to the
424 * specified interface's MTU.
426 static int set_sync_mesg_maxlen(int sync_state
)
428 struct net_device
*dev
;
431 if (sync_state
== IP_VS_STATE_MASTER
) {
432 if ((dev
= __dev_get_by_name(&init_net
, ip_vs_master_mcast_ifn
)) == NULL
)
435 num
= (dev
->mtu
- sizeof(struct iphdr
) -
436 sizeof(struct udphdr
) -
437 SYNC_MESG_HEADER_LEN
- 20) / SIMPLE_CONN_SIZE
;
438 sync_send_mesg_maxlen
=
439 SYNC_MESG_HEADER_LEN
+ SIMPLE_CONN_SIZE
* num
;
440 IP_VS_DBG(7, "setting the maximum length of sync sending "
441 "message %d.\n", sync_send_mesg_maxlen
);
442 } else if (sync_state
== IP_VS_STATE_BACKUP
) {
443 if ((dev
= __dev_get_by_name(&init_net
, ip_vs_backup_mcast_ifn
)) == NULL
)
446 sync_recv_mesg_maxlen
= dev
->mtu
-
447 sizeof(struct iphdr
) - sizeof(struct udphdr
);
448 IP_VS_DBG(7, "setting the maximum length of sync receiving "
449 "message %d.\n", sync_recv_mesg_maxlen
);
457 * Join a multicast group.
458 * the group is specified by a class D multicast address 224.0.0.0/8
459 * in the in_addr structure passed in as a parameter.
462 join_mcast_group(struct sock
*sk
, struct in_addr
*addr
, char *ifname
)
464 struct ip_mreqn mreq
;
465 struct net_device
*dev
;
468 memset(&mreq
, 0, sizeof(mreq
));
469 memcpy(&mreq
.imr_multiaddr
, addr
, sizeof(struct in_addr
));
471 if ((dev
= __dev_get_by_name(&init_net
, ifname
)) == NULL
)
473 if (sk
->sk_bound_dev_if
&& dev
->ifindex
!= sk
->sk_bound_dev_if
)
476 mreq
.imr_ifindex
= dev
->ifindex
;
479 ret
= ip_mc_join_group(sk
, &mreq
);
486 static int bind_mcastif_addr(struct socket
*sock
, char *ifname
)
488 struct net_device
*dev
;
490 struct sockaddr_in sin
;
492 if ((dev
= __dev_get_by_name(&init_net
, ifname
)) == NULL
)
495 addr
= inet_select_addr(dev
, 0, RT_SCOPE_UNIVERSE
);
497 IP_VS_ERR("You probably need to specify IP address on "
498 "multicast interface.\n");
500 IP_VS_DBG(7, "binding socket with (%s) %u.%u.%u.%u\n",
501 ifname
, NIPQUAD(addr
));
503 /* Now bind the socket with the address of multicast interface */
504 sin
.sin_family
= AF_INET
;
505 sin
.sin_addr
.s_addr
= addr
;
508 return sock
->ops
->bind(sock
, (struct sockaddr
*)&sin
, sizeof(sin
));
512 * Set up sending multicast socket over UDP
514 static struct socket
* make_send_sock(void)
518 /* First create a socket */
519 if (sock_create_kern(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, &sock
) < 0) {
520 IP_VS_ERR("Error during creation of socket; terminating\n");
524 if (set_mcast_if(sock
->sk
, ip_vs_master_mcast_ifn
) < 0) {
525 IP_VS_ERR("Error setting outbound mcast interface\n");
529 set_mcast_loop(sock
->sk
, 0);
530 set_mcast_ttl(sock
->sk
, 1);
532 if (bind_mcastif_addr(sock
, ip_vs_master_mcast_ifn
) < 0) {
533 IP_VS_ERR("Error binding address of the mcast interface\n");
537 if (sock
->ops
->connect(sock
,
538 (struct sockaddr
*)&mcast_addr
,
539 sizeof(struct sockaddr
), 0) < 0) {
540 IP_VS_ERR("Error connecting to the multicast addr\n");
553 * Set up receiving multicast socket over UDP
555 static struct socket
* make_receive_sock(void)
559 /* First create a socket */
560 if (sock_create_kern(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, &sock
) < 0) {
561 IP_VS_ERR("Error during creation of socket; terminating\n");
565 /* it is equivalent to the REUSEADDR option in user-space */
566 sock
->sk
->sk_reuse
= 1;
568 if (sock
->ops
->bind(sock
,
569 (struct sockaddr
*)&mcast_addr
,
570 sizeof(struct sockaddr
)) < 0) {
571 IP_VS_ERR("Error binding to the multicast addr\n");
575 /* join the multicast group */
576 if (join_mcast_group(sock
->sk
,
577 (struct in_addr
*)&mcast_addr
.sin_addr
,
578 ip_vs_backup_mcast_ifn
) < 0) {
579 IP_VS_ERR("Error joining to the multicast group\n");
592 ip_vs_send_async(struct socket
*sock
, const char *buffer
, const size_t length
)
594 struct msghdr msg
= {.msg_flags
= MSG_DONTWAIT
|MSG_NOSIGNAL
};
599 iov
.iov_base
= (void *)buffer
;
600 iov
.iov_len
= length
;
602 len
= kernel_sendmsg(sock
, &msg
, &iov
, 1, (size_t)(length
));
609 ip_vs_send_sync_msg(struct socket
*sock
, struct ip_vs_sync_mesg
*msg
)
615 /* Put size in network byte order */
616 msg
->size
= htons(msg
->size
);
618 if (ip_vs_send_async(sock
, (char *)msg
, msize
) != msize
)
619 IP_VS_ERR("ip_vs_send_async error\n");
623 ip_vs_receive(struct socket
*sock
, char *buffer
, const size_t buflen
)
625 struct msghdr msg
= {NULL
,};
631 /* Receive a packet */
632 iov
.iov_base
= buffer
;
633 iov
.iov_len
= (size_t)buflen
;
635 len
= kernel_recvmsg(sock
, &msg
, &iov
, 1, buflen
, 0);
645 static DECLARE_WAIT_QUEUE_HEAD(sync_wait
);
646 static pid_t sync_master_pid
= 0;
647 static pid_t sync_backup_pid
= 0;
649 static DECLARE_WAIT_QUEUE_HEAD(stop_sync_wait
);
650 static int stop_master_sync
= 0;
651 static int stop_backup_sync
= 0;
653 static void sync_master_loop(void)
656 struct ip_vs_sync_buff
*sb
;
658 /* create the sending multicast socket */
659 sock
= make_send_sock();
663 IP_VS_INFO("sync thread started: state = MASTER, mcast_ifn = %s, "
665 ip_vs_master_mcast_ifn
, ip_vs_master_syncid
);
668 while ((sb
=sb_dequeue())) {
669 ip_vs_send_sync_msg(sock
, sb
->mesg
);
670 ip_vs_sync_buff_release(sb
);
673 /* check if entries stay in curr_sb for 2 seconds */
674 if ((sb
= get_curr_sync_buff(2*HZ
))) {
675 ip_vs_send_sync_msg(sock
, sb
->mesg
);
676 ip_vs_sync_buff_release(sb
);
679 if (stop_master_sync
)
682 msleep_interruptible(1000);
685 /* clean up the sync_buff queue */
686 while ((sb
=sb_dequeue())) {
687 ip_vs_sync_buff_release(sb
);
690 /* clean up the current sync_buff */
691 if ((sb
= get_curr_sync_buff(0))) {
692 ip_vs_sync_buff_release(sb
);
695 /* release the sending multicast socket */
700 static void sync_backup_loop(void)
706 if (!(buf
= kmalloc(sync_recv_mesg_maxlen
, GFP_ATOMIC
))) {
707 IP_VS_ERR("sync_backup_loop: kmalloc error\n");
711 /* create the receiving multicast socket */
712 sock
= make_receive_sock();
716 IP_VS_INFO("sync thread started: state = BACKUP, mcast_ifn = %s, "
718 ip_vs_backup_mcast_ifn
, ip_vs_backup_syncid
);
721 /* do you have data now? */
722 while (!skb_queue_empty(&(sock
->sk
->sk_receive_queue
))) {
724 ip_vs_receive(sock
, buf
,
725 sync_recv_mesg_maxlen
)) <= 0) {
726 IP_VS_ERR("receiving message error\n");
729 /* disable bottom half, because it accessed the data
730 shared by softirq while getting/creating conns */
732 ip_vs_process_message(buf
, len
);
736 if (stop_backup_sync
)
739 msleep_interruptible(1000);
742 /* release the sending multicast socket */
750 static void set_sync_pid(int sync_state
, pid_t sync_pid
)
752 if (sync_state
== IP_VS_STATE_MASTER
)
753 sync_master_pid
= sync_pid
;
754 else if (sync_state
== IP_VS_STATE_BACKUP
)
755 sync_backup_pid
= sync_pid
;
758 static void set_stop_sync(int sync_state
, int set
)
760 if (sync_state
== IP_VS_STATE_MASTER
)
761 stop_master_sync
= set
;
762 else if (sync_state
== IP_VS_STATE_BACKUP
)
763 stop_backup_sync
= set
;
765 stop_master_sync
= set
;
766 stop_backup_sync
= set
;
770 static int sync_thread(void *startup
)
772 DECLARE_WAITQUEUE(wait
, current
);
776 struct ip_vs_sync_thread_data
*tinfo
= startup
;
778 /* increase the module use count */
779 ip_vs_use_count_inc();
781 if (ip_vs_sync_state
& IP_VS_STATE_MASTER
&& !sync_master_pid
) {
782 state
= IP_VS_STATE_MASTER
;
783 name
= "ipvs_syncmaster";
784 } else if (ip_vs_sync_state
& IP_VS_STATE_BACKUP
&& !sync_backup_pid
) {
785 state
= IP_VS_STATE_BACKUP
;
786 name
= "ipvs_syncbackup";
789 ip_vs_use_count_dec();
798 /* Block all signals */
799 spin_lock_irq(¤t
->sighand
->siglock
);
800 siginitsetinv(¤t
->blocked
, 0);
802 spin_unlock_irq(¤t
->sighand
->siglock
);
804 /* set the maximum length of sync message */
805 set_sync_mesg_maxlen(state
);
807 /* set up multicast address */
808 mcast_addr
.sin_family
= AF_INET
;
809 mcast_addr
.sin_port
= htons(IP_VS_SYNC_PORT
);
810 mcast_addr
.sin_addr
.s_addr
= htonl(IP_VS_SYNC_GROUP
);
812 add_wait_queue(&sync_wait
, &wait
);
814 set_sync_pid(state
, task_pid_nr(current
));
815 complete(tinfo
->startup
);
818 * once we call the completion queue above, we should
819 * null out that reference, since its allocated on the
820 * stack of the creating kernel thread
822 tinfo
->startup
= NULL
;
824 /* processing master/backup loop here */
825 if (state
== IP_VS_STATE_MASTER
)
827 else if (state
== IP_VS_STATE_BACKUP
)
831 remove_wait_queue(&sync_wait
, &wait
);
836 * If we weren't explicitly stopped, then we
837 * exited in error, and should undo our state
839 if ((!stop_master_sync
) && (!stop_backup_sync
))
840 ip_vs_sync_state
-= tinfo
->state
;
842 set_sync_pid(state
, 0);
843 IP_VS_INFO("sync thread stopped!\n");
847 /* decrease the module use count */
848 ip_vs_use_count_dec();
850 set_stop_sync(state
, 0);
851 wake_up(&stop_sync_wait
);
854 * we need to free the structure that was allocated
855 * for us in start_sync_thread
862 static int fork_sync_thread(void *startup
)
866 /* fork the sync thread here, then the parent process of the
867 sync thread is the init process after this thread exits. */
869 if ((pid
= kernel_thread(sync_thread
, startup
, 0)) < 0) {
870 IP_VS_ERR("could not create sync_thread due to %d... "
872 msleep_interruptible(1000);
880 int start_sync_thread(int state
, char *mcast_ifn
, __u8 syncid
)
882 DECLARE_COMPLETION_ONSTACK(startup
);
884 struct ip_vs_sync_thread_data
*tinfo
;
886 if ((state
== IP_VS_STATE_MASTER
&& sync_master_pid
) ||
887 (state
== IP_VS_STATE_BACKUP
&& sync_backup_pid
))
891 * Note that tinfo will be freed in sync_thread on exit
893 tinfo
= kmalloc(sizeof(struct ip_vs_sync_thread_data
), GFP_KERNEL
);
897 IP_VS_DBG(7, "%s: pid %d\n", __FUNCTION__
, task_pid_nr(current
));
898 IP_VS_DBG(7, "Each ip_vs_sync_conn entry need %Zd bytes\n",
899 sizeof(struct ip_vs_sync_conn
));
901 ip_vs_sync_state
|= state
;
902 if (state
== IP_VS_STATE_MASTER
) {
903 strlcpy(ip_vs_master_mcast_ifn
, mcast_ifn
,
904 sizeof(ip_vs_master_mcast_ifn
));
905 ip_vs_master_syncid
= syncid
;
907 strlcpy(ip_vs_backup_mcast_ifn
, mcast_ifn
,
908 sizeof(ip_vs_backup_mcast_ifn
));
909 ip_vs_backup_syncid
= syncid
;
912 tinfo
->state
= state
;
913 tinfo
->startup
= &startup
;
916 if ((pid
= kernel_thread(fork_sync_thread
, tinfo
, 0)) < 0) {
917 IP_VS_ERR("could not create fork_sync_thread due to %d... "
919 msleep_interruptible(1000);
923 wait_for_completion(&startup
);
929 int stop_sync_thread(int state
)
931 DECLARE_WAITQUEUE(wait
, current
);
933 if ((state
== IP_VS_STATE_MASTER
&& !sync_master_pid
) ||
934 (state
== IP_VS_STATE_BACKUP
&& !sync_backup_pid
))
937 IP_VS_DBG(7, "%s: pid %d\n", __FUNCTION__
, task_pid_nr(current
));
938 IP_VS_INFO("stopping sync thread %d ...\n",
939 (state
== IP_VS_STATE_MASTER
) ?
940 sync_master_pid
: sync_backup_pid
);
942 __set_current_state(TASK_UNINTERRUPTIBLE
);
943 add_wait_queue(&stop_sync_wait
, &wait
);
944 set_stop_sync(state
, 1);
945 ip_vs_sync_state
-= state
;
948 __set_current_state(TASK_RUNNING
);
949 remove_wait_queue(&stop_sync_wait
, &wait
);
951 /* Note: no need to reap the sync thread, because its parent
952 process is the init process */
954 if ((state
== IP_VS_STATE_MASTER
&& stop_master_sync
) ||
955 (state
== IP_VS_STATE_BACKUP
&& stop_backup_sync
))