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
;
290 /* Convert size back to host byte order */
291 m
->size
= ntohs(m
->size
);
293 if (buflen
!= m
->size
) {
294 IP_VS_ERR("bogus message\n");
298 /* SyncID sanity check */
299 if (ip_vs_backup_syncid
!= 0 && m
->syncid
!= ip_vs_backup_syncid
) {
300 IP_VS_DBG(7, "Ignoring incoming msg with syncid = %d\n",
305 p
= (char *)buffer
+ sizeof(struct ip_vs_sync_mesg
);
306 for (i
=0; i
<m
->nr_conns
; i
++) {
309 s
= (struct ip_vs_sync_conn
*)p
;
310 flags
= ntohs(s
->flags
);
311 if (!(flags
& IP_VS_CONN_F_TEMPLATE
))
312 cp
= ip_vs_conn_in_get(s
->protocol
,
316 cp
= ip_vs_ct_in_get(s
->protocol
,
320 cp
= ip_vs_conn_new(s
->protocol
,
326 IP_VS_ERR("ip_vs_conn_new failed\n");
329 cp
->state
= ntohs(s
->state
);
330 } else if (!cp
->dest
) {
331 /* it is an entry created by the synchronization */
332 cp
->state
= ntohs(s
->state
);
333 cp
->flags
= flags
| IP_VS_CONN_F_HASHED
;
334 } /* Note that we don't touch its state and flags
335 if it is a normal entry. */
337 if (flags
& IP_VS_CONN_F_SEQ_MASK
) {
338 opt
= (struct ip_vs_sync_conn_options
*)&s
[1];
339 memcpy(&cp
->in_seq
, opt
, sizeof(*opt
));
342 p
+= SIMPLE_CONN_SIZE
;
344 atomic_set(&cp
->in_pkts
, sysctl_ip_vs_sync_threshold
[0]);
345 pp
= ip_vs_proto_get(s
->protocol
);
346 cp
->timeout
= pp
->timeout_table
[cp
->state
];
349 if (p
> buffer
+buflen
) {
350 IP_VS_ERR("bogus message\n");
358 * Setup loopback of outgoing multicasts on a sending socket
360 static void set_mcast_loop(struct sock
*sk
, u_char loop
)
362 struct inet_sock
*inet
= inet_sk(sk
);
364 /* setsockopt(sock, SOL_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)); */
366 inet
->mc_loop
= loop
? 1 : 0;
371 * Specify TTL for outgoing multicasts on a sending socket
373 static void set_mcast_ttl(struct sock
*sk
, u_char ttl
)
375 struct inet_sock
*inet
= inet_sk(sk
);
377 /* setsockopt(sock, SOL_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)); */
384 * Specifiy default interface for outgoing multicasts
386 static int set_mcast_if(struct sock
*sk
, char *ifname
)
388 struct net_device
*dev
;
389 struct inet_sock
*inet
= inet_sk(sk
);
391 if ((dev
= __dev_get_by_name(&init_net
, ifname
)) == NULL
)
394 if (sk
->sk_bound_dev_if
&& dev
->ifindex
!= sk
->sk_bound_dev_if
)
398 inet
->mc_index
= dev
->ifindex
;
399 /* inet->mc_addr = 0; */
407 * Set the maximum length of sync message according to the
408 * specified interface's MTU.
410 static int set_sync_mesg_maxlen(int sync_state
)
412 struct net_device
*dev
;
415 if (sync_state
== IP_VS_STATE_MASTER
) {
416 if ((dev
= __dev_get_by_name(&init_net
, ip_vs_master_mcast_ifn
)) == NULL
)
419 num
= (dev
->mtu
- sizeof(struct iphdr
) -
420 sizeof(struct udphdr
) -
421 SYNC_MESG_HEADER_LEN
- 20) / SIMPLE_CONN_SIZE
;
422 sync_send_mesg_maxlen
=
423 SYNC_MESG_HEADER_LEN
+ SIMPLE_CONN_SIZE
* num
;
424 IP_VS_DBG(7, "setting the maximum length of sync sending "
425 "message %d.\n", sync_send_mesg_maxlen
);
426 } else if (sync_state
== IP_VS_STATE_BACKUP
) {
427 if ((dev
= __dev_get_by_name(&init_net
, ip_vs_backup_mcast_ifn
)) == NULL
)
430 sync_recv_mesg_maxlen
= dev
->mtu
-
431 sizeof(struct iphdr
) - sizeof(struct udphdr
);
432 IP_VS_DBG(7, "setting the maximum length of sync receiving "
433 "message %d.\n", sync_recv_mesg_maxlen
);
441 * Join a multicast group.
442 * the group is specified by a class D multicast address 224.0.0.0/8
443 * in the in_addr structure passed in as a parameter.
446 join_mcast_group(struct sock
*sk
, struct in_addr
*addr
, char *ifname
)
448 struct ip_mreqn mreq
;
449 struct net_device
*dev
;
452 memset(&mreq
, 0, sizeof(mreq
));
453 memcpy(&mreq
.imr_multiaddr
, addr
, sizeof(struct in_addr
));
455 if ((dev
= __dev_get_by_name(&init_net
, ifname
)) == NULL
)
457 if (sk
->sk_bound_dev_if
&& dev
->ifindex
!= sk
->sk_bound_dev_if
)
460 mreq
.imr_ifindex
= dev
->ifindex
;
463 ret
= ip_mc_join_group(sk
, &mreq
);
470 static int bind_mcastif_addr(struct socket
*sock
, char *ifname
)
472 struct net_device
*dev
;
474 struct sockaddr_in sin
;
476 if ((dev
= __dev_get_by_name(&init_net
, ifname
)) == NULL
)
479 addr
= inet_select_addr(dev
, 0, RT_SCOPE_UNIVERSE
);
481 IP_VS_ERR("You probably need to specify IP address on "
482 "multicast interface.\n");
484 IP_VS_DBG(7, "binding socket with (%s) %u.%u.%u.%u\n",
485 ifname
, NIPQUAD(addr
));
487 /* Now bind the socket with the address of multicast interface */
488 sin
.sin_family
= AF_INET
;
489 sin
.sin_addr
.s_addr
= addr
;
492 return sock
->ops
->bind(sock
, (struct sockaddr
*)&sin
, sizeof(sin
));
496 * Set up sending multicast socket over UDP
498 static struct socket
* make_send_sock(void)
502 /* First create a socket */
503 if (sock_create_kern(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, &sock
) < 0) {
504 IP_VS_ERR("Error during creation of socket; terminating\n");
508 if (set_mcast_if(sock
->sk
, ip_vs_master_mcast_ifn
) < 0) {
509 IP_VS_ERR("Error setting outbound mcast interface\n");
513 set_mcast_loop(sock
->sk
, 0);
514 set_mcast_ttl(sock
->sk
, 1);
516 if (bind_mcastif_addr(sock
, ip_vs_master_mcast_ifn
) < 0) {
517 IP_VS_ERR("Error binding address of the mcast interface\n");
521 if (sock
->ops
->connect(sock
,
522 (struct sockaddr
*)&mcast_addr
,
523 sizeof(struct sockaddr
), 0) < 0) {
524 IP_VS_ERR("Error connecting to the multicast addr\n");
537 * Set up receiving multicast socket over UDP
539 static struct socket
* make_receive_sock(void)
543 /* First create a socket */
544 if (sock_create_kern(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, &sock
) < 0) {
545 IP_VS_ERR("Error during creation of socket; terminating\n");
549 /* it is equivalent to the REUSEADDR option in user-space */
550 sock
->sk
->sk_reuse
= 1;
552 if (sock
->ops
->bind(sock
,
553 (struct sockaddr
*)&mcast_addr
,
554 sizeof(struct sockaddr
)) < 0) {
555 IP_VS_ERR("Error binding to the multicast addr\n");
559 /* join the multicast group */
560 if (join_mcast_group(sock
->sk
,
561 (struct in_addr
*)&mcast_addr
.sin_addr
,
562 ip_vs_backup_mcast_ifn
) < 0) {
563 IP_VS_ERR("Error joining to the multicast group\n");
576 ip_vs_send_async(struct socket
*sock
, const char *buffer
, const size_t length
)
578 struct msghdr msg
= {.msg_flags
= MSG_DONTWAIT
|MSG_NOSIGNAL
};
583 iov
.iov_base
= (void *)buffer
;
584 iov
.iov_len
= length
;
586 len
= kernel_sendmsg(sock
, &msg
, &iov
, 1, (size_t)(length
));
593 ip_vs_send_sync_msg(struct socket
*sock
, struct ip_vs_sync_mesg
*msg
)
599 /* Put size in network byte order */
600 msg
->size
= htons(msg
->size
);
602 if (ip_vs_send_async(sock
, (char *)msg
, msize
) != msize
)
603 IP_VS_ERR("ip_vs_send_async error\n");
607 ip_vs_receive(struct socket
*sock
, char *buffer
, const size_t buflen
)
609 struct msghdr msg
= {NULL
,};
615 /* Receive a packet */
616 iov
.iov_base
= buffer
;
617 iov
.iov_len
= (size_t)buflen
;
619 len
= kernel_recvmsg(sock
, &msg
, &iov
, 1, buflen
, 0);
629 static DECLARE_WAIT_QUEUE_HEAD(sync_wait
);
630 static pid_t sync_master_pid
= 0;
631 static pid_t sync_backup_pid
= 0;
633 static DECLARE_WAIT_QUEUE_HEAD(stop_sync_wait
);
634 static int stop_master_sync
= 0;
635 static int stop_backup_sync
= 0;
637 static void sync_master_loop(void)
640 struct ip_vs_sync_buff
*sb
;
642 /* create the sending multicast socket */
643 sock
= make_send_sock();
647 IP_VS_INFO("sync thread started: state = MASTER, mcast_ifn = %s, "
649 ip_vs_master_mcast_ifn
, ip_vs_master_syncid
);
652 while ((sb
=sb_dequeue())) {
653 ip_vs_send_sync_msg(sock
, sb
->mesg
);
654 ip_vs_sync_buff_release(sb
);
657 /* check if entries stay in curr_sb for 2 seconds */
658 if ((sb
= get_curr_sync_buff(2*HZ
))) {
659 ip_vs_send_sync_msg(sock
, sb
->mesg
);
660 ip_vs_sync_buff_release(sb
);
663 if (stop_master_sync
)
666 msleep_interruptible(1000);
669 /* clean up the sync_buff queue */
670 while ((sb
=sb_dequeue())) {
671 ip_vs_sync_buff_release(sb
);
674 /* clean up the current sync_buff */
675 if ((sb
= get_curr_sync_buff(0))) {
676 ip_vs_sync_buff_release(sb
);
679 /* release the sending multicast socket */
684 static void sync_backup_loop(void)
690 if (!(buf
= kmalloc(sync_recv_mesg_maxlen
, GFP_ATOMIC
))) {
691 IP_VS_ERR("sync_backup_loop: kmalloc error\n");
695 /* create the receiving multicast socket */
696 sock
= make_receive_sock();
700 IP_VS_INFO("sync thread started: state = BACKUP, mcast_ifn = %s, "
702 ip_vs_backup_mcast_ifn
, ip_vs_backup_syncid
);
705 /* do you have data now? */
706 while (!skb_queue_empty(&(sock
->sk
->sk_receive_queue
))) {
708 ip_vs_receive(sock
, buf
,
709 sync_recv_mesg_maxlen
)) <= 0) {
710 IP_VS_ERR("receiving message error\n");
713 /* disable bottom half, because it accessed the data
714 shared by softirq while getting/creating conns */
716 ip_vs_process_message(buf
, len
);
720 if (stop_backup_sync
)
723 msleep_interruptible(1000);
726 /* release the sending multicast socket */
734 static void set_sync_pid(int sync_state
, pid_t sync_pid
)
736 if (sync_state
== IP_VS_STATE_MASTER
)
737 sync_master_pid
= sync_pid
;
738 else if (sync_state
== IP_VS_STATE_BACKUP
)
739 sync_backup_pid
= sync_pid
;
742 static void set_stop_sync(int sync_state
, int set
)
744 if (sync_state
== IP_VS_STATE_MASTER
)
745 stop_master_sync
= set
;
746 else if (sync_state
== IP_VS_STATE_BACKUP
)
747 stop_backup_sync
= set
;
749 stop_master_sync
= set
;
750 stop_backup_sync
= set
;
754 static int sync_thread(void *startup
)
756 DECLARE_WAITQUEUE(wait
, current
);
760 struct ip_vs_sync_thread_data
*tinfo
= startup
;
762 /* increase the module use count */
763 ip_vs_use_count_inc();
765 if (ip_vs_sync_state
& IP_VS_STATE_MASTER
&& !sync_master_pid
) {
766 state
= IP_VS_STATE_MASTER
;
767 name
= "ipvs_syncmaster";
768 } else if (ip_vs_sync_state
& IP_VS_STATE_BACKUP
&& !sync_backup_pid
) {
769 state
= IP_VS_STATE_BACKUP
;
770 name
= "ipvs_syncbackup";
773 ip_vs_use_count_dec();
782 /* Block all signals */
783 spin_lock_irq(¤t
->sighand
->siglock
);
784 siginitsetinv(¤t
->blocked
, 0);
786 spin_unlock_irq(¤t
->sighand
->siglock
);
788 /* set the maximum length of sync message */
789 set_sync_mesg_maxlen(state
);
791 /* set up multicast address */
792 mcast_addr
.sin_family
= AF_INET
;
793 mcast_addr
.sin_port
= htons(IP_VS_SYNC_PORT
);
794 mcast_addr
.sin_addr
.s_addr
= htonl(IP_VS_SYNC_GROUP
);
796 add_wait_queue(&sync_wait
, &wait
);
798 set_sync_pid(state
, task_pid_nr(current
));
799 complete(tinfo
->startup
);
802 * once we call the completion queue above, we should
803 * null out that reference, since its allocated on the
804 * stack of the creating kernel thread
806 tinfo
->startup
= NULL
;
808 /* processing master/backup loop here */
809 if (state
== IP_VS_STATE_MASTER
)
811 else if (state
== IP_VS_STATE_BACKUP
)
815 remove_wait_queue(&sync_wait
, &wait
);
820 * If we weren't explicitly stopped, then we
821 * exited in error, and should undo our state
823 if ((!stop_master_sync
) && (!stop_backup_sync
))
824 ip_vs_sync_state
-= tinfo
->state
;
826 set_sync_pid(state
, 0);
827 IP_VS_INFO("sync thread stopped!\n");
831 /* decrease the module use count */
832 ip_vs_use_count_dec();
834 set_stop_sync(state
, 0);
835 wake_up(&stop_sync_wait
);
838 * we need to free the structure that was allocated
839 * for us in start_sync_thread
846 static int fork_sync_thread(void *startup
)
850 /* fork the sync thread here, then the parent process of the
851 sync thread is the init process after this thread exits. */
853 if ((pid
= kernel_thread(sync_thread
, startup
, 0)) < 0) {
854 IP_VS_ERR("could not create sync_thread due to %d... "
856 msleep_interruptible(1000);
864 int start_sync_thread(int state
, char *mcast_ifn
, __u8 syncid
)
866 DECLARE_COMPLETION_ONSTACK(startup
);
868 struct ip_vs_sync_thread_data
*tinfo
;
870 if ((state
== IP_VS_STATE_MASTER
&& sync_master_pid
) ||
871 (state
== IP_VS_STATE_BACKUP
&& sync_backup_pid
))
875 * Note that tinfo will be freed in sync_thread on exit
877 tinfo
= kmalloc(sizeof(struct ip_vs_sync_thread_data
), GFP_KERNEL
);
881 IP_VS_DBG(7, "%s: pid %d\n", __FUNCTION__
, task_pid_nr(current
));
882 IP_VS_DBG(7, "Each ip_vs_sync_conn entry need %Zd bytes\n",
883 sizeof(struct ip_vs_sync_conn
));
885 ip_vs_sync_state
|= state
;
886 if (state
== IP_VS_STATE_MASTER
) {
887 strlcpy(ip_vs_master_mcast_ifn
, mcast_ifn
,
888 sizeof(ip_vs_master_mcast_ifn
));
889 ip_vs_master_syncid
= syncid
;
891 strlcpy(ip_vs_backup_mcast_ifn
, mcast_ifn
,
892 sizeof(ip_vs_backup_mcast_ifn
));
893 ip_vs_backup_syncid
= syncid
;
896 tinfo
->state
= state
;
897 tinfo
->startup
= &startup
;
900 if ((pid
= kernel_thread(fork_sync_thread
, tinfo
, 0)) < 0) {
901 IP_VS_ERR("could not create fork_sync_thread due to %d... "
903 msleep_interruptible(1000);
907 wait_for_completion(&startup
);
913 int stop_sync_thread(int state
)
915 DECLARE_WAITQUEUE(wait
, current
);
917 if ((state
== IP_VS_STATE_MASTER
&& !sync_master_pid
) ||
918 (state
== IP_VS_STATE_BACKUP
&& !sync_backup_pid
))
921 IP_VS_DBG(7, "%s: pid %d\n", __FUNCTION__
, task_pid_nr(current
));
922 IP_VS_INFO("stopping sync thread %d ...\n",
923 (state
== IP_VS_STATE_MASTER
) ?
924 sync_master_pid
: sync_backup_pid
);
926 __set_current_state(TASK_UNINTERRUPTIBLE
);
927 add_wait_queue(&stop_sync_wait
, &wait
);
928 set_stop_sync(state
, 1);
929 ip_vs_sync_state
-= state
;
932 __set_current_state(TASK_RUNNING
);
933 remove_wait_queue(&stop_sync_wait
, &wait
);
935 /* Note: no need to reap the sync thread, because its parent
936 process is the init process */
938 if ((state
== IP_VS_STATE_MASTER
&& stop_master_sync
) ||
939 (state
== IP_VS_STATE_BACKUP
&& stop_backup_sync
))