4 Copyright (C) Ronnie Sahlberg 2007
5 Copyright (C) Andrew Tridgell 2007
6 Copyright (C) Martin Schwenke 2011
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, see <http://www.gnu.org/licenses/>.
23 #include "lib/util/dlinklist.h"
24 #include "system/network.h"
25 #include "system/filesys.h"
26 #include "system/wait.h"
27 #include "../include/ctdb_private.h"
28 #include "../common/rb_tree.h"
31 #define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
33 #define CTDB_ARP_INTERVAL 1
34 #define CTDB_ARP_REPEAT 3
36 /* Flags used in IP allocation algorithms. */
43 struct ctdb_iface
*prev
, *next
;
49 static const char *ctdb_vnn_iface_string(const struct ctdb_vnn
*vnn
)
52 return vnn
->iface
->name
;
58 static int ctdb_add_local_iface(struct ctdb_context
*ctdb
, const char *iface
)
62 /* Verify that we dont have an entry for this ip yet */
63 for (i
=ctdb
->ifaces
;i
;i
=i
->next
) {
64 if (strcmp(i
->name
, iface
) == 0) {
69 /* create a new structure for this interface */
70 i
= talloc_zero(ctdb
, struct ctdb_iface
);
71 CTDB_NO_MEMORY_FATAL(ctdb
, i
);
72 i
->name
= talloc_strdup(i
, iface
);
73 CTDB_NO_MEMORY(ctdb
, i
->name
);
75 * If link_up defaults to true then IPs can be allocated to a
76 * node during the first recovery. However, then an interface
77 * could have its link marked down during the startup event,
78 * causing the IP to move almost immediately. If link_up
79 * defaults to false then, during normal operation, IPs added
80 * to a new interface can't be assigned until a monitor cycle
81 * has occurred and marked the new interfaces up. This makes
82 * IP allocation unpredictable. The following is a neat
83 * compromise: early in startup link_up defaults to false, so
84 * IPs can't be assigned, and after startup IPs can be
85 * assigned immediately.
87 i
->link_up
= (ctdb
->runstate
== CTDB_RUNSTATE_RUNNING
);
89 DLIST_ADD(ctdb
->ifaces
, i
);
94 static bool vnn_has_interface_with_name(struct ctdb_vnn
*vnn
,
99 for (n
= 0; vnn
->ifaces
[n
] != NULL
; n
++) {
100 if (strcmp(name
, vnn
->ifaces
[n
]) == 0) {
108 /* If any interfaces now have no possible IPs then delete them. This
109 * implementation is naive (i.e. simple) rather than clever
110 * (i.e. complex). Given that this is run on delip and that operation
111 * is rare, this doesn't need to be efficient - it needs to be
112 * foolproof. One alternative is reference counting, where the logic
113 * is distributed and can, therefore, be broken in multiple places.
114 * Another alternative is to build a red-black tree of interfaces that
115 * can have addresses (by walking ctdb->vnn and ctdb->single_ip_vnn
116 * once) and then walking ctdb->ifaces once and deleting those not in
117 * the tree. Let's go to one of those if the naive implementation
118 * causes problems... :-)
120 static void ctdb_remove_orphaned_ifaces(struct ctdb_context
*ctdb
,
121 struct ctdb_vnn
*vnn
)
123 struct ctdb_iface
*i
, *next
;
125 /* For each interface, check if there's an IP using it. */
126 for (i
= ctdb
->ifaces
; i
!= NULL
; i
= next
) {
131 /* Only consider interfaces named in the given VNN. */
132 if (!vnn_has_interface_with_name(vnn
, i
->name
)) {
136 /* Is the "single IP" on this interface? */
137 if ((ctdb
->single_ip_vnn
!= NULL
) &&
138 (ctdb
->single_ip_vnn
->ifaces
[0] != NULL
) &&
139 (strcmp(i
->name
, ctdb
->single_ip_vnn
->ifaces
[0]) == 0)) {
140 /* Found, next interface please... */
143 /* Search for a vnn with this interface. */
145 for (tv
=ctdb
->vnn
; tv
; tv
=tv
->next
) {
146 if (vnn_has_interface_with_name(tv
, i
->name
)) {
153 /* None of the VNNs are using this interface. */
154 DLIST_REMOVE(ctdb
->ifaces
, i
);
161 static struct ctdb_iface
*ctdb_find_iface(struct ctdb_context
*ctdb
,
164 struct ctdb_iface
*i
;
166 for (i
=ctdb
->ifaces
;i
;i
=i
->next
) {
167 if (strcmp(i
->name
, iface
) == 0) {
175 static struct ctdb_iface
*ctdb_vnn_best_iface(struct ctdb_context
*ctdb
,
176 struct ctdb_vnn
*vnn
)
179 struct ctdb_iface
*cur
= NULL
;
180 struct ctdb_iface
*best
= NULL
;
182 for (i
=0; vnn
->ifaces
[i
]; i
++) {
184 cur
= ctdb_find_iface(ctdb
, vnn
->ifaces
[i
]);
198 if (cur
->references
< best
->references
) {
207 static int32_t ctdb_vnn_assign_iface(struct ctdb_context
*ctdb
,
208 struct ctdb_vnn
*vnn
)
210 struct ctdb_iface
*best
= NULL
;
213 DEBUG(DEBUG_INFO
, (__location__
" public address '%s' "
214 "still assigned to iface '%s'\n",
215 ctdb_addr_to_str(&vnn
->public_address
),
216 ctdb_vnn_iface_string(vnn
)));
220 best
= ctdb_vnn_best_iface(ctdb
, vnn
);
222 DEBUG(DEBUG_ERR
, (__location__
" public address '%s' "
223 "cannot assign to iface any iface\n",
224 ctdb_addr_to_str(&vnn
->public_address
)));
230 vnn
->pnn
= ctdb
->pnn
;
232 DEBUG(DEBUG_INFO
, (__location__
" public address '%s' "
233 "now assigned to iface '%s' refs[%d]\n",
234 ctdb_addr_to_str(&vnn
->public_address
),
235 ctdb_vnn_iface_string(vnn
),
240 static void ctdb_vnn_unassign_iface(struct ctdb_context
*ctdb
,
241 struct ctdb_vnn
*vnn
)
243 DEBUG(DEBUG_INFO
, (__location__
" public address '%s' "
244 "now unassigned (old iface '%s' refs[%d])\n",
245 ctdb_addr_to_str(&vnn
->public_address
),
246 ctdb_vnn_iface_string(vnn
),
247 vnn
->iface
?vnn
->iface
->references
:0));
249 vnn
->iface
->references
--;
252 if (vnn
->pnn
== ctdb
->pnn
) {
257 static bool ctdb_vnn_available(struct ctdb_context
*ctdb
,
258 struct ctdb_vnn
*vnn
)
262 if (vnn
->delete_pending
) {
266 if (vnn
->iface
&& vnn
->iface
->link_up
) {
270 for (i
=0; vnn
->ifaces
[i
]; i
++) {
271 struct ctdb_iface
*cur
;
273 cur
= ctdb_find_iface(ctdb
, vnn
->ifaces
[i
]);
286 struct ctdb_takeover_arp
{
287 struct ctdb_context
*ctdb
;
290 struct ctdb_tcp_array
*tcparray
;
291 struct ctdb_vnn
*vnn
;
296 lists of tcp endpoints
298 struct ctdb_tcp_list
{
299 struct ctdb_tcp_list
*prev
, *next
;
300 struct ctdb_tcp_connection connection
;
304 list of clients to kill on IP release
306 struct ctdb_client_ip
{
307 struct ctdb_client_ip
*prev
, *next
;
308 struct ctdb_context
*ctdb
;
315 send a gratuitous arp
317 static void ctdb_control_send_arp(struct event_context
*ev
, struct timed_event
*te
,
318 struct timeval t
, void *private_data
)
320 struct ctdb_takeover_arp
*arp
= talloc_get_type(private_data
,
321 struct ctdb_takeover_arp
);
323 struct ctdb_tcp_array
*tcparray
;
324 const char *iface
= ctdb_vnn_iface_string(arp
->vnn
);
326 ret
= ctdb_sys_send_arp(&arp
->addr
, iface
);
328 DEBUG(DEBUG_CRIT
,(__location__
" sending of arp failed on iface '%s' (%s)\n",
329 iface
, strerror(errno
)));
332 tcparray
= arp
->tcparray
;
334 for (i
=0;i
<tcparray
->num
;i
++) {
335 struct ctdb_tcp_connection
*tcon
;
337 tcon
= &tcparray
->connections
[i
];
338 DEBUG(DEBUG_INFO
,("sending tcp tickle ack for %u->%s:%u\n",
339 (unsigned)ntohs(tcon
->dst_addr
.ip
.sin_port
),
340 ctdb_addr_to_str(&tcon
->src_addr
),
341 (unsigned)ntohs(tcon
->src_addr
.ip
.sin_port
)));
342 ret
= ctdb_sys_send_tcp(
347 DEBUG(DEBUG_CRIT
,(__location__
" Failed to send tcp tickle ack for %s\n",
348 ctdb_addr_to_str(&tcon
->src_addr
)));
355 if (arp
->count
== CTDB_ARP_REPEAT
) {
360 event_add_timed(arp
->ctdb
->ev
, arp
->vnn
->takeover_ctx
,
361 timeval_current_ofs(CTDB_ARP_INTERVAL
, 100000),
362 ctdb_control_send_arp
, arp
);
365 static int32_t ctdb_announce_vnn_iface(struct ctdb_context
*ctdb
,
366 struct ctdb_vnn
*vnn
)
368 struct ctdb_takeover_arp
*arp
;
369 struct ctdb_tcp_array
*tcparray
;
371 if (!vnn
->takeover_ctx
) {
372 vnn
->takeover_ctx
= talloc_new(vnn
);
373 if (!vnn
->takeover_ctx
) {
378 arp
= talloc_zero(vnn
->takeover_ctx
, struct ctdb_takeover_arp
);
384 arp
->addr
= vnn
->public_address
;
387 tcparray
= vnn
->tcp_array
;
389 /* add all of the known tcp connections for this IP to the
390 list of tcp connections to send tickle acks for */
391 arp
->tcparray
= talloc_steal(arp
, tcparray
);
393 vnn
->tcp_array
= NULL
;
394 vnn
->tcp_update_needed
= true;
397 event_add_timed(arp
->ctdb
->ev
, vnn
->takeover_ctx
,
398 timeval_zero(), ctdb_control_send_arp
, arp
);
403 struct takeover_callback_state
{
404 struct ctdb_req_control
*c
;
405 ctdb_sock_addr
*addr
;
406 struct ctdb_vnn
*vnn
;
409 struct ctdb_do_takeip_state
{
410 struct ctdb_req_control
*c
;
411 struct ctdb_vnn
*vnn
;
415 called when takeip event finishes
417 static void ctdb_do_takeip_callback(struct ctdb_context
*ctdb
, int status
,
420 struct ctdb_do_takeip_state
*state
=
421 talloc_get_type(private_data
, struct ctdb_do_takeip_state
);
426 struct ctdb_node
*node
= ctdb
->nodes
[ctdb
->pnn
];
428 if (status
== -ETIME
) {
431 DEBUG(DEBUG_ERR
,(__location__
" Failed to takeover IP %s on interface %s\n",
432 ctdb_addr_to_str(&state
->vnn
->public_address
),
433 ctdb_vnn_iface_string(state
->vnn
)));
434 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, status
, NULL
);
436 node
->flags
|= NODE_FLAGS_UNHEALTHY
;
441 if (ctdb
->do_checkpublicip
) {
443 ret
= ctdb_announce_vnn_iface(ctdb
, state
->vnn
);
445 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, -1, NULL
);
452 data
.dptr
= (uint8_t *)ctdb_addr_to_str(&state
->vnn
->public_address
);
453 data
.dsize
= strlen((char *)data
.dptr
) + 1;
454 DEBUG(DEBUG_INFO
,(__location__
" sending TAKE_IP for '%s'\n", data
.dptr
));
456 ctdb_daemon_send_message(ctdb
, ctdb
->pnn
, CTDB_SRVID_TAKE_IP
, data
);
459 /* the control succeeded */
460 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, 0, NULL
);
465 static int ctdb_takeip_destructor(struct ctdb_do_takeip_state
*state
)
467 state
->vnn
->update_in_flight
= false;
472 take over an ip address
474 static int32_t ctdb_do_takeip(struct ctdb_context
*ctdb
,
475 struct ctdb_req_control
*c
,
476 struct ctdb_vnn
*vnn
)
479 struct ctdb_do_takeip_state
*state
;
481 if (vnn
->update_in_flight
) {
482 DEBUG(DEBUG_NOTICE
,("Takeover of IP %s/%u rejected "
483 "update for this IP already in flight\n",
484 ctdb_addr_to_str(&vnn
->public_address
),
485 vnn
->public_netmask_bits
));
489 ret
= ctdb_vnn_assign_iface(ctdb
, vnn
);
491 DEBUG(DEBUG_ERR
,("Takeover of IP %s/%u failed to "
492 "assign a usable interface\n",
493 ctdb_addr_to_str(&vnn
->public_address
),
494 vnn
->public_netmask_bits
));
498 state
= talloc(vnn
, struct ctdb_do_takeip_state
);
499 CTDB_NO_MEMORY(ctdb
, state
);
501 state
->c
= talloc_steal(ctdb
, c
);
504 vnn
->update_in_flight
= true;
505 talloc_set_destructor(state
, ctdb_takeip_destructor
);
507 DEBUG(DEBUG_NOTICE
,("Takeover of IP %s/%u on interface %s\n",
508 ctdb_addr_to_str(&vnn
->public_address
),
509 vnn
->public_netmask_bits
,
510 ctdb_vnn_iface_string(vnn
)));
512 ret
= ctdb_event_script_callback(ctdb
,
514 ctdb_do_takeip_callback
,
518 ctdb_vnn_iface_string(vnn
),
519 ctdb_addr_to_str(&vnn
->public_address
),
520 vnn
->public_netmask_bits
);
523 DEBUG(DEBUG_ERR
,(__location__
" Failed to takeover IP %s on interface %s\n",
524 ctdb_addr_to_str(&vnn
->public_address
),
525 ctdb_vnn_iface_string(vnn
)));
533 struct ctdb_do_updateip_state
{
534 struct ctdb_req_control
*c
;
535 struct ctdb_iface
*old
;
536 struct ctdb_vnn
*vnn
;
540 called when updateip event finishes
542 static void ctdb_do_updateip_callback(struct ctdb_context
*ctdb
, int status
,
545 struct ctdb_do_updateip_state
*state
=
546 talloc_get_type(private_data
, struct ctdb_do_updateip_state
);
550 if (status
== -ETIME
) {
553 DEBUG(DEBUG_ERR
,(__location__
" Failed to move IP %s from interface %s to %s\n",
554 ctdb_addr_to_str(&state
->vnn
->public_address
),
556 ctdb_vnn_iface_string(state
->vnn
)));
559 * All we can do is reset the old interface
560 * and let the next run fix it
562 ctdb_vnn_unassign_iface(ctdb
, state
->vnn
);
563 state
->vnn
->iface
= state
->old
;
564 state
->vnn
->iface
->references
++;
566 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, status
, NULL
);
571 if (ctdb
->do_checkpublicip
) {
573 ret
= ctdb_announce_vnn_iface(ctdb
, state
->vnn
);
575 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, -1, NULL
);
582 /* the control succeeded */
583 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, 0, NULL
);
588 static int ctdb_updateip_destructor(struct ctdb_do_updateip_state
*state
)
590 state
->vnn
->update_in_flight
= false;
595 update (move) an ip address
597 static int32_t ctdb_do_updateip(struct ctdb_context
*ctdb
,
598 struct ctdb_req_control
*c
,
599 struct ctdb_vnn
*vnn
)
602 struct ctdb_do_updateip_state
*state
;
603 struct ctdb_iface
*old
= vnn
->iface
;
604 const char *new_name
;
606 if (vnn
->update_in_flight
) {
607 DEBUG(DEBUG_NOTICE
,("Update of IP %s/%u rejected "
608 "update for this IP already in flight\n",
609 ctdb_addr_to_str(&vnn
->public_address
),
610 vnn
->public_netmask_bits
));
614 ctdb_vnn_unassign_iface(ctdb
, vnn
);
615 ret
= ctdb_vnn_assign_iface(ctdb
, vnn
);
617 DEBUG(DEBUG_ERR
,("update of IP %s/%u failed to "
618 "assin a usable interface (old iface '%s')\n",
619 ctdb_addr_to_str(&vnn
->public_address
),
620 vnn
->public_netmask_bits
,
625 new_name
= ctdb_vnn_iface_string(vnn
);
626 if (old
->name
!= NULL
&& new_name
!= NULL
&& !strcmp(old
->name
, new_name
)) {
627 /* A benign update from one interface onto itself.
628 * no need to run the eventscripts in this case, just return
631 ctdb_request_control_reply(ctdb
, c
, NULL
, 0, NULL
);
635 state
= talloc(vnn
, struct ctdb_do_updateip_state
);
636 CTDB_NO_MEMORY(ctdb
, state
);
638 state
->c
= talloc_steal(ctdb
, c
);
642 vnn
->update_in_flight
= true;
643 talloc_set_destructor(state
, ctdb_updateip_destructor
);
645 DEBUG(DEBUG_NOTICE
,("Update of IP %s/%u from "
646 "interface %s to %s\n",
647 ctdb_addr_to_str(&vnn
->public_address
),
648 vnn
->public_netmask_bits
,
652 ret
= ctdb_event_script_callback(ctdb
,
654 ctdb_do_updateip_callback
,
656 CTDB_EVENT_UPDATE_IP
,
660 ctdb_addr_to_str(&vnn
->public_address
),
661 vnn
->public_netmask_bits
);
663 DEBUG(DEBUG_ERR
,(__location__
" Failed update IP %s from interface %s to %s\n",
664 ctdb_addr_to_str(&vnn
->public_address
),
665 old
->name
, new_name
));
674 Find the vnn of the node that has a public ip address
675 returns -1 if the address is not known as a public address
677 static struct ctdb_vnn
*find_public_ip_vnn(struct ctdb_context
*ctdb
, ctdb_sock_addr
*addr
)
679 struct ctdb_vnn
*vnn
;
681 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
682 if (ctdb_same_ip(&vnn
->public_address
, addr
)) {
691 take over an ip address
693 int32_t ctdb_control_takeover_ip(struct ctdb_context
*ctdb
,
694 struct ctdb_req_control
*c
,
699 struct ctdb_public_ip
*pip
= (struct ctdb_public_ip
*)indata
.dptr
;
700 struct ctdb_vnn
*vnn
;
701 bool have_ip
= false;
702 bool do_updateip
= false;
703 bool do_takeip
= false;
704 struct ctdb_iface
*best_iface
= NULL
;
706 if (pip
->pnn
!= ctdb
->pnn
) {
707 DEBUG(DEBUG_ERR
,(__location__
" takeoverip called for an ip '%s' "
708 "with pnn %d, but we're node %d\n",
709 ctdb_addr_to_str(&pip
->addr
),
710 pip
->pnn
, ctdb
->pnn
));
714 /* update out vnn list */
715 vnn
= find_public_ip_vnn(ctdb
, &pip
->addr
);
717 DEBUG(DEBUG_INFO
,("takeoverip called for an ip '%s' that is not a public address\n",
718 ctdb_addr_to_str(&pip
->addr
)));
722 if (ctdb
->do_checkpublicip
) {
723 have_ip
= ctdb_sys_have_ip(&pip
->addr
);
725 best_iface
= ctdb_vnn_best_iface(ctdb
, vnn
);
726 if (best_iface
== NULL
) {
727 DEBUG(DEBUG_ERR
,("takeoverip of IP %s/%u failed to find"
728 "a usable interface (old %s, have_ip %d)\n",
729 ctdb_addr_to_str(&vnn
->public_address
),
730 vnn
->public_netmask_bits
,
731 ctdb_vnn_iface_string(vnn
),
736 if (vnn
->iface
== NULL
&& vnn
->pnn
== -1 && have_ip
&& best_iface
!= NULL
) {
737 DEBUG(DEBUG_ERR
,("Taking over newly created ip\n"));
742 if (vnn
->iface
== NULL
&& have_ip
) {
743 DEBUG(DEBUG_CRIT
,(__location__
" takeoverip of IP %s is known to the kernel, "
744 "but we have no interface assigned, has someone manually configured it? Ignore for now.\n",
745 ctdb_addr_to_str(&vnn
->public_address
)));
749 if (vnn
->pnn
!= ctdb
->pnn
&& have_ip
&& vnn
->pnn
!= -1) {
750 DEBUG(DEBUG_CRIT
,(__location__
" takeoverip of IP %s is known to the kernel, "
751 "and we have it on iface[%s], but it was assigned to node %d"
752 "and we are node %d, banning ourself\n",
753 ctdb_addr_to_str(&vnn
->public_address
),
754 ctdb_vnn_iface_string(vnn
), vnn
->pnn
, ctdb
->pnn
));
759 if (vnn
->pnn
== -1 && have_ip
) {
760 vnn
->pnn
= ctdb
->pnn
;
761 DEBUG(DEBUG_CRIT
,(__location__
" takeoverip of IP %s is known to the kernel, "
762 "and we already have it on iface[%s], update local daemon\n",
763 ctdb_addr_to_str(&vnn
->public_address
),
764 ctdb_vnn_iface_string(vnn
)));
769 if (vnn
->iface
!= best_iface
) {
770 if (!vnn
->iface
->link_up
) {
772 } else if (vnn
->iface
->references
> (best_iface
->references
+ 1)) {
773 /* only move when the rebalance gains something */
781 ctdb_vnn_unassign_iface(ctdb
, vnn
);
788 ret
= ctdb_do_takeip(ctdb
, c
, vnn
);
792 } else if (do_updateip
) {
793 ret
= ctdb_do_updateip(ctdb
, c
, vnn
);
799 * The interface is up and the kernel known the ip
802 DEBUG(DEBUG_INFO
,("Redundant takeover of IP %s/%u on interface %s (ip already held)\n",
803 ctdb_addr_to_str(&pip
->addr
),
804 vnn
->public_netmask_bits
,
805 ctdb_vnn_iface_string(vnn
)));
809 /* tell ctdb_control.c that we will be replying asynchronously */
816 takeover an ip address old v4 style
818 int32_t ctdb_control_takeover_ipv4(struct ctdb_context
*ctdb
,
819 struct ctdb_req_control
*c
,
825 data
.dsize
= sizeof(struct ctdb_public_ip
);
826 data
.dptr
= (uint8_t *)talloc_zero(c
, struct ctdb_public_ip
);
827 CTDB_NO_MEMORY(ctdb
, data
.dptr
);
829 memcpy(data
.dptr
, indata
.dptr
, indata
.dsize
);
830 return ctdb_control_takeover_ip(ctdb
, c
, data
, async_reply
);
834 kill any clients that are registered with a IP that is being released
836 static void release_kill_clients(struct ctdb_context
*ctdb
, ctdb_sock_addr
*addr
)
838 struct ctdb_client_ip
*ip
;
840 DEBUG(DEBUG_INFO
,("release_kill_clients for ip %s\n",
841 ctdb_addr_to_str(addr
)));
843 for (ip
=ctdb
->client_ip_list
; ip
; ip
=ip
->next
) {
844 ctdb_sock_addr tmp_addr
;
847 DEBUG(DEBUG_INFO
,("checking for client %u with IP %s\n",
849 ctdb_addr_to_str(&ip
->addr
)));
851 if (ctdb_same_ip(&tmp_addr
, addr
)) {
852 struct ctdb_client
*client
= ctdb_reqid_find(ctdb
,
855 DEBUG(DEBUG_INFO
,("matched client %u with IP %s and pid %u\n",
857 ctdb_addr_to_str(&ip
->addr
),
860 if (client
->pid
!= 0) {
861 DEBUG(DEBUG_INFO
,(__location__
" Killing client pid %u for IP %s on client_id %u\n",
862 (unsigned)client
->pid
,
863 ctdb_addr_to_str(addr
),
865 kill(client
->pid
, SIGKILL
);
871 static void do_delete_ip(struct ctdb_context
*ctdb
, struct ctdb_vnn
*vnn
)
873 DLIST_REMOVE(ctdb
->vnn
, vnn
);
874 ctdb_vnn_unassign_iface(ctdb
, vnn
);
875 ctdb_remove_orphaned_ifaces(ctdb
, vnn
);
880 called when releaseip event finishes
882 static void release_ip_callback(struct ctdb_context
*ctdb
, int status
,
885 struct takeover_callback_state
*state
=
886 talloc_get_type(private_data
, struct takeover_callback_state
);
889 if (status
== -ETIME
) {
893 if (ctdb
->do_checkpublicip
&& ctdb_sys_have_ip(state
->addr
)) {
894 DEBUG(DEBUG_ERR
, ("IP %s still hosted during release IP callback, failing\n",
895 ctdb_addr_to_str(state
->addr
)));
896 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, -1, NULL
);
901 /* send a message to all clients of this node telling them
902 that the cluster has been reconfigured and they should
903 release any sockets on this IP */
904 data
.dptr
= (uint8_t *)talloc_strdup(state
, ctdb_addr_to_str(state
->addr
));
905 CTDB_NO_MEMORY_VOID(ctdb
, data
.dptr
);
906 data
.dsize
= strlen((char *)data
.dptr
)+1;
908 DEBUG(DEBUG_INFO
,(__location__
" sending RELEASE_IP for '%s'\n", data
.dptr
));
910 ctdb_daemon_send_message(ctdb
, ctdb
->pnn
, CTDB_SRVID_RELEASE_IP
, data
);
912 /* kill clients that have registered with this IP */
913 release_kill_clients(ctdb
, state
->addr
);
915 ctdb_vnn_unassign_iface(ctdb
, state
->vnn
);
917 /* Process the IP if it has been marked for deletion */
918 if (state
->vnn
->delete_pending
) {
919 do_delete_ip(ctdb
, state
->vnn
);
923 /* the control succeeded */
924 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, 0, NULL
);
928 static int ctdb_releaseip_destructor(struct takeover_callback_state
*state
)
930 if (state
->vnn
!= NULL
) {
931 state
->vnn
->update_in_flight
= false;
937 release an ip address
939 int32_t ctdb_control_release_ip(struct ctdb_context
*ctdb
,
940 struct ctdb_req_control
*c
,
945 struct takeover_callback_state
*state
;
946 struct ctdb_public_ip
*pip
= (struct ctdb_public_ip
*)indata
.dptr
;
947 struct ctdb_vnn
*vnn
;
950 /* update our vnn list */
951 vnn
= find_public_ip_vnn(ctdb
, &pip
->addr
);
953 DEBUG(DEBUG_INFO
,("releaseip called for an ip '%s' that is not a public address\n",
954 ctdb_addr_to_str(&pip
->addr
)));
959 /* stop any previous arps */
960 talloc_free(vnn
->takeover_ctx
);
961 vnn
->takeover_ctx
= NULL
;
963 /* Some ctdb tool commands (e.g. moveip, rebalanceip) send
964 * lazy multicast to drop an IP from any node that isn't the
965 * intended new node. The following causes makes ctdbd ignore
966 * a release for any address it doesn't host.
968 if (ctdb
->do_checkpublicip
) {
969 if (!ctdb_sys_have_ip(&pip
->addr
)) {
970 DEBUG(DEBUG_DEBUG
,("Redundant release of IP %s/%u on interface %s (ip not held)\n",
971 ctdb_addr_to_str(&pip
->addr
),
972 vnn
->public_netmask_bits
,
973 ctdb_vnn_iface_string(vnn
)));
974 ctdb_vnn_unassign_iface(ctdb
, vnn
);
978 if (vnn
->iface
== NULL
) {
979 DEBUG(DEBUG_DEBUG
,("Redundant release of IP %s/%u (ip not held)\n",
980 ctdb_addr_to_str(&pip
->addr
),
981 vnn
->public_netmask_bits
));
986 /* There is a potential race between take_ip and us because we
987 * update the VNN via a callback that run when the
988 * eventscripts have been run. Avoid the race by allowing one
989 * update to be in flight at a time.
991 if (vnn
->update_in_flight
) {
992 DEBUG(DEBUG_NOTICE
,("Release of IP %s/%u rejected "
993 "update for this IP already in flight\n",
994 ctdb_addr_to_str(&vnn
->public_address
),
995 vnn
->public_netmask_bits
));
999 if (ctdb
->do_checkpublicip
) {
1000 iface
= ctdb_sys_find_ifname(&pip
->addr
);
1001 if (iface
== NULL
) {
1002 DEBUG(DEBUG_ERR
, ("Could not find which interface the ip address is hosted on. can not release it\n"));
1005 if (vnn
->iface
== NULL
) {
1006 DEBUG(DEBUG_WARNING
,
1007 ("Public IP %s is hosted on interface %s but we have no VNN\n",
1008 ctdb_addr_to_str(&pip
->addr
),
1010 } else if (strcmp(iface
, ctdb_vnn_iface_string(vnn
)) != 0) {
1011 DEBUG(DEBUG_WARNING
,
1012 ("Public IP %s is hosted on inteterface %s but VNN says %s\n",
1013 ctdb_addr_to_str(&pip
->addr
),
1015 ctdb_vnn_iface_string(vnn
)));
1016 /* Should we fix vnn->iface? If we do, what
1017 * happens to reference counts?
1021 iface
= strdup(ctdb_vnn_iface_string(vnn
));
1024 DEBUG(DEBUG_NOTICE
,("Release of IP %s/%u on interface %s node:%d\n",
1025 ctdb_addr_to_str(&pip
->addr
),
1026 vnn
->public_netmask_bits
,
1030 state
= talloc(ctdb
, struct takeover_callback_state
);
1031 CTDB_NO_MEMORY(ctdb
, state
);
1033 state
->c
= talloc_steal(state
, c
);
1034 state
->addr
= talloc(state
, ctdb_sock_addr
);
1035 CTDB_NO_MEMORY(ctdb
, state
->addr
);
1036 *state
->addr
= pip
->addr
;
1039 vnn
->update_in_flight
= true;
1040 talloc_set_destructor(state
, ctdb_releaseip_destructor
);
1042 ret
= ctdb_event_script_callback(ctdb
,
1043 state
, release_ip_callback
, state
,
1044 CTDB_EVENT_RELEASE_IP
,
1047 ctdb_addr_to_str(&pip
->addr
),
1048 vnn
->public_netmask_bits
);
1051 DEBUG(DEBUG_ERR
,(__location__
" Failed to release IP %s on interface %s\n",
1052 ctdb_addr_to_str(&pip
->addr
),
1053 ctdb_vnn_iface_string(vnn
)));
1058 /* tell the control that we will be reply asynchronously */
1059 *async_reply
= true;
1064 release an ip address old v4 style
1066 int32_t ctdb_control_release_ipv4(struct ctdb_context
*ctdb
,
1067 struct ctdb_req_control
*c
,
1073 data
.dsize
= sizeof(struct ctdb_public_ip
);
1074 data
.dptr
= (uint8_t *)talloc_zero(c
, struct ctdb_public_ip
);
1075 CTDB_NO_MEMORY(ctdb
, data
.dptr
);
1077 memcpy(data
.dptr
, indata
.dptr
, indata
.dsize
);
1078 return ctdb_control_release_ip(ctdb
, c
, data
, async_reply
);
1082 static int ctdb_add_public_address(struct ctdb_context
*ctdb
,
1083 ctdb_sock_addr
*addr
,
1084 unsigned mask
, const char *ifaces
,
1087 struct ctdb_vnn
*vnn
;
1094 tmp
= strdup(ifaces
);
1095 for (iface
= strtok(tmp
, ","); iface
; iface
= strtok(NULL
, ",")) {
1096 if (!ctdb_sys_check_iface_exists(iface
)) {
1097 DEBUG(DEBUG_CRIT
,("Interface %s does not exist. Can not add public-address : %s\n", iface
, ctdb_addr_to_str(addr
)));
1104 /* Verify that we dont have an entry for this ip yet */
1105 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
1106 if (ctdb_same_sockaddr(addr
, &vnn
->public_address
)) {
1107 DEBUG(DEBUG_CRIT
,("Same ip '%s' specified multiple times in the public address list \n",
1108 ctdb_addr_to_str(addr
)));
1113 /* create a new vnn structure for this ip address */
1114 vnn
= talloc_zero(ctdb
, struct ctdb_vnn
);
1115 CTDB_NO_MEMORY_FATAL(ctdb
, vnn
);
1116 vnn
->ifaces
= talloc_array(vnn
, const char *, num
+ 2);
1117 tmp
= talloc_strdup(vnn
, ifaces
);
1118 CTDB_NO_MEMORY_FATAL(ctdb
, tmp
);
1119 for (iface
= strtok(tmp
, ","); iface
; iface
= strtok(NULL
, ",")) {
1120 vnn
->ifaces
= talloc_realloc(vnn
, vnn
->ifaces
, const char *, num
+ 2);
1121 CTDB_NO_MEMORY_FATAL(ctdb
, vnn
->ifaces
);
1122 vnn
->ifaces
[num
] = talloc_strdup(vnn
, iface
);
1123 CTDB_NO_MEMORY_FATAL(ctdb
, vnn
->ifaces
[num
]);
1127 vnn
->ifaces
[num
] = NULL
;
1128 vnn
->public_address
= *addr
;
1129 vnn
->public_netmask_bits
= mask
;
1131 if (check_address
) {
1132 if (ctdb_sys_have_ip(addr
)) {
1133 DEBUG(DEBUG_ERR
,("We are already hosting public address '%s'. setting PNN to ourself:%d\n", ctdb_addr_to_str(addr
), ctdb
->pnn
));
1134 vnn
->pnn
= ctdb
->pnn
;
1138 for (i
=0; vnn
->ifaces
[i
]; i
++) {
1139 ret
= ctdb_add_local_iface(ctdb
, vnn
->ifaces
[i
]);
1141 DEBUG(DEBUG_CRIT
, (__location__
" failed to add iface[%s] "
1142 "for public_address[%s]\n",
1143 vnn
->ifaces
[i
], ctdb_addr_to_str(addr
)));
1149 DLIST_ADD(ctdb
->vnn
, vnn
);
1154 static void ctdb_check_interfaces_event(struct event_context
*ev
, struct timed_event
*te
,
1155 struct timeval t
, void *private_data
)
1157 struct ctdb_context
*ctdb
= talloc_get_type(private_data
,
1158 struct ctdb_context
);
1159 struct ctdb_vnn
*vnn
;
1161 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
1164 for (i
=0; vnn
->ifaces
[i
] != NULL
; i
++) {
1165 if (!ctdb_sys_check_iface_exists(vnn
->ifaces
[i
])) {
1166 DEBUG(DEBUG_CRIT
,("Interface %s does not exist but is used by public ip %s\n",
1168 ctdb_addr_to_str(&vnn
->public_address
)));
1173 event_add_timed(ctdb
->ev
, ctdb
->check_public_ifaces_ctx
,
1174 timeval_current_ofs(30, 0),
1175 ctdb_check_interfaces_event
, ctdb
);
1179 int ctdb_start_monitoring_interfaces(struct ctdb_context
*ctdb
)
1181 if (ctdb
->check_public_ifaces_ctx
!= NULL
) {
1182 talloc_free(ctdb
->check_public_ifaces_ctx
);
1183 ctdb
->check_public_ifaces_ctx
= NULL
;
1186 ctdb
->check_public_ifaces_ctx
= talloc_new(ctdb
);
1187 if (ctdb
->check_public_ifaces_ctx
== NULL
) {
1188 ctdb_fatal(ctdb
, "failed to allocate context for checking interfaces");
1191 event_add_timed(ctdb
->ev
, ctdb
->check_public_ifaces_ctx
,
1192 timeval_current_ofs(30, 0),
1193 ctdb_check_interfaces_event
, ctdb
);
1200 setup the public address lists from a file
1202 int ctdb_set_public_addresses(struct ctdb_context
*ctdb
, bool check_addresses
)
1208 lines
= file_lines_load(ctdb
->public_addresses_file
, &nlines
, ctdb
);
1209 if (lines
== NULL
) {
1210 ctdb_set_error(ctdb
, "Failed to load public address list '%s'\n", ctdb
->public_addresses_file
);
1213 while (nlines
> 0 && strcmp(lines
[nlines
-1], "") == 0) {
1217 for (i
=0;i
<nlines
;i
++) {
1219 ctdb_sock_addr addr
;
1220 const char *addrstr
;
1225 while ((*line
== ' ') || (*line
== '\t')) {
1231 if (strcmp(line
, "") == 0) {
1234 tok
= strtok(line
, " \t");
1236 tok
= strtok(NULL
, " \t");
1238 if (NULL
== ctdb
->default_public_interface
) {
1239 DEBUG(DEBUG_CRIT
,("No default public interface and no interface specified at line %u of public address list\n",
1244 ifaces
= ctdb
->default_public_interface
;
1249 if (!addrstr
|| !parse_ip_mask(addrstr
, ifaces
, &addr
, &mask
)) {
1250 DEBUG(DEBUG_CRIT
,("Badly formed line %u in public address list\n", i
+1));
1254 if (ctdb_add_public_address(ctdb
, &addr
, mask
, ifaces
, check_addresses
)) {
1255 DEBUG(DEBUG_CRIT
,("Failed to add line %u to the public address list\n", i
+1));
1266 int ctdb_set_single_public_ip(struct ctdb_context
*ctdb
,
1270 struct ctdb_vnn
*svnn
;
1271 struct ctdb_iface
*cur
= NULL
;
1275 svnn
= talloc_zero(ctdb
, struct ctdb_vnn
);
1276 CTDB_NO_MEMORY(ctdb
, svnn
);
1278 svnn
->ifaces
= talloc_array(svnn
, const char *, 2);
1279 CTDB_NO_MEMORY(ctdb
, svnn
->ifaces
);
1280 svnn
->ifaces
[0] = talloc_strdup(svnn
->ifaces
, iface
);
1281 CTDB_NO_MEMORY(ctdb
, svnn
->ifaces
[0]);
1282 svnn
->ifaces
[1] = NULL
;
1284 ok
= parse_ip(ip
, iface
, 0, &svnn
->public_address
);
1290 ret
= ctdb_add_local_iface(ctdb
, svnn
->ifaces
[0]);
1292 DEBUG(DEBUG_CRIT
, (__location__
" failed to add iface[%s] "
1293 "for single_ip[%s]\n",
1295 ctdb_addr_to_str(&svnn
->public_address
)));
1300 /* assume the single public ip interface is initially "good" */
1301 cur
= ctdb_find_iface(ctdb
, iface
);
1303 DEBUG(DEBUG_CRIT
,("Can not find public interface %s used by --single-public-ip", iface
));
1306 cur
->link_up
= true;
1308 ret
= ctdb_vnn_assign_iface(ctdb
, svnn
);
1314 ctdb
->single_ip_vnn
= svnn
;
1318 struct ctdb_public_ip_list
{
1319 struct ctdb_public_ip_list
*next
;
1321 ctdb_sock_addr addr
;
1324 /* Given a physical node, return the number of
1325 public addresses that is currently assigned to this node.
1327 static int node_ip_coverage(struct ctdb_context
*ctdb
,
1329 struct ctdb_public_ip_list
*ips
)
1333 for (;ips
;ips
=ips
->next
) {
1334 if (ips
->pnn
== pnn
) {
1342 /* Can the given node host the given IP: is the public IP known to the
1343 * node and is NOIPHOST unset?
1345 static bool can_node_host_ip(struct ctdb_context
*ctdb
, int32_t pnn
,
1346 struct ctdb_ipflags ipflags
,
1347 struct ctdb_public_ip_list
*ip
)
1349 struct ctdb_all_public_ips
*public_ips
;
1352 if (ipflags
.noiphost
) {
1356 public_ips
= ctdb
->nodes
[pnn
]->available_public_ips
;
1358 if (public_ips
== NULL
) {
1362 for (i
=0; i
<public_ips
->num
; i
++) {
1363 if (ctdb_same_ip(&ip
->addr
, &public_ips
->ips
[i
].addr
)) {
1364 /* yes, this node can serve this public ip */
1372 static bool can_node_takeover_ip(struct ctdb_context
*ctdb
, int32_t pnn
,
1373 struct ctdb_ipflags ipflags
,
1374 struct ctdb_public_ip_list
*ip
)
1376 if (ipflags
.noiptakeover
) {
1380 return can_node_host_ip(ctdb
, pnn
, ipflags
, ip
);
1383 /* search the node lists list for a node to takeover this ip.
1384 pick the node that currently are serving the least number of ips
1385 so that the ips get spread out evenly.
1387 static int find_takeover_node(struct ctdb_context
*ctdb
,
1388 struct ctdb_ipflags
*ipflags
,
1389 struct ctdb_public_ip_list
*ip
,
1390 struct ctdb_public_ip_list
*all_ips
)
1392 int pnn
, min
=0, num
;
1395 numnodes
= talloc_array_length(ipflags
);
1397 for (i
=0; i
<numnodes
; i
++) {
1398 /* verify that this node can serve this ip */
1399 if (!can_node_takeover_ip(ctdb
, i
, ipflags
[i
], ip
)) {
1400 /* no it couldnt so skip to the next node */
1404 num
= node_ip_coverage(ctdb
, i
, all_ips
);
1405 /* was this the first node we checked ? */
1417 DEBUG(DEBUG_WARNING
,(__location__
" Could not find node to take over public address '%s'\n",
1418 ctdb_addr_to_str(&ip
->addr
)));
1428 static uint32_t *ip_key(ctdb_sock_addr
*ip
)
1430 static uint32_t key
[IP_KEYLEN
];
1432 bzero(key
, sizeof(key
));
1434 switch (ip
->sa
.sa_family
) {
1436 key
[3] = htonl(ip
->ip
.sin_addr
.s_addr
);
1439 uint32_t *s6_a32
= (uint32_t *)&(ip
->ip6
.sin6_addr
.s6_addr
);
1440 key
[0] = htonl(s6_a32
[0]);
1441 key
[1] = htonl(s6_a32
[1]);
1442 key
[2] = htonl(s6_a32
[2]);
1443 key
[3] = htonl(s6_a32
[3]);
1447 DEBUG(DEBUG_ERR
, (__location__
" ERROR, unknown family passed :%u\n", ip
->sa
.sa_family
));
1454 static void *add_ip_callback(void *parm
, void *data
)
1456 struct ctdb_public_ip_list
*this_ip
= parm
;
1457 struct ctdb_public_ip_list
*prev_ip
= data
;
1459 if (prev_ip
== NULL
) {
1462 if (this_ip
->pnn
== -1) {
1463 this_ip
->pnn
= prev_ip
->pnn
;
1469 static int getips_count_callback(void *param
, void *data
)
1471 struct ctdb_public_ip_list
**ip_list
= (struct ctdb_public_ip_list
**)param
;
1472 struct ctdb_public_ip_list
*new_ip
= (struct ctdb_public_ip_list
*)data
;
1474 new_ip
->next
= *ip_list
;
1479 static struct ctdb_public_ip_list
*
1480 create_merged_ip_list(struct ctdb_context
*ctdb
)
1483 struct ctdb_public_ip_list
*ip_list
;
1484 struct ctdb_all_public_ips
*public_ips
;
1486 if (ctdb
->ip_tree
!= NULL
) {
1487 talloc_free(ctdb
->ip_tree
);
1488 ctdb
->ip_tree
= NULL
;
1490 ctdb
->ip_tree
= trbt_create(ctdb
, 0);
1492 for (i
=0;i
<ctdb
->num_nodes
;i
++) {
1493 public_ips
= ctdb
->nodes
[i
]->known_public_ips
;
1495 if (ctdb
->nodes
[i
]->flags
& NODE_FLAGS_DELETED
) {
1499 /* there were no public ips for this node */
1500 if (public_ips
== NULL
) {
1504 for (j
=0;j
<public_ips
->num
;j
++) {
1505 struct ctdb_public_ip_list
*tmp_ip
;
1507 tmp_ip
= talloc_zero(ctdb
->ip_tree
, struct ctdb_public_ip_list
);
1508 CTDB_NO_MEMORY_NULL(ctdb
, tmp_ip
);
1509 /* Do not use information about IP addresses hosted
1510 * on other nodes, it may not be accurate */
1511 if (public_ips
->ips
[j
].pnn
== ctdb
->nodes
[i
]->pnn
) {
1512 tmp_ip
->pnn
= public_ips
->ips
[j
].pnn
;
1516 tmp_ip
->addr
= public_ips
->ips
[j
].addr
;
1517 tmp_ip
->next
= NULL
;
1519 trbt_insertarray32_callback(ctdb
->ip_tree
,
1520 IP_KEYLEN
, ip_key(&public_ips
->ips
[j
].addr
),
1527 trbt_traversearray32(ctdb
->ip_tree
, IP_KEYLEN
, getips_count_callback
, &ip_list
);
1533 * This is the length of the longtest common prefix between the IPs.
1534 * It is calculated by XOR-ing the 2 IPs together and counting the
1535 * number of leading zeroes. The implementation means that all
1536 * addresses end up being 128 bits long.
1538 * FIXME? Should we consider IPv4 and IPv6 separately given that the
1539 * 12 bytes of 0 prefix padding will hurt the algorithm if there are
1540 * lots of nodes and IP addresses?
1542 static uint32_t ip_distance(ctdb_sock_addr
*ip1
, ctdb_sock_addr
*ip2
)
1544 uint32_t ip1_k
[IP_KEYLEN
];
1549 uint32_t distance
= 0;
1551 memcpy(ip1_k
, ip_key(ip1
), sizeof(ip1_k
));
1553 for (i
=0; i
<IP_KEYLEN
; i
++) {
1554 x
= ip1_k
[i
] ^ t
[i
];
1558 /* Count number of leading zeroes.
1559 * FIXME? This could be optimised...
1561 while ((x
& (1 << 31)) == 0) {
1571 /* Calculate the IP distance for the given IP relative to IPs on the
1572 given node. The ips argument is generally the all_ips variable
1573 used in the main part of the algorithm.
1575 static uint32_t ip_distance_2_sum(ctdb_sock_addr
*ip
,
1576 struct ctdb_public_ip_list
*ips
,
1579 struct ctdb_public_ip_list
*t
;
1584 for (t
=ips
; t
!= NULL
; t
=t
->next
) {
1585 if (t
->pnn
!= pnn
) {
1589 /* Optimisation: We never calculate the distance
1590 * between an address and itself. This allows us to
1591 * calculate the effect of removing an address from a
1592 * node by simply calculating the distance between
1593 * that address and all of the exitsing addresses.
1594 * Moreover, we assume that we're only ever dealing
1595 * with addresses from all_ips so we can identify an
1596 * address via a pointer rather than doing a more
1597 * expensive address comparison. */
1598 if (&(t
->addr
) == ip
) {
1602 d
= ip_distance(ip
, &(t
->addr
));
1603 sum
+= d
* d
; /* Cheaper than pulling in math.h :-) */
1609 /* Return the LCP2 imbalance metric for addresses currently assigned
1612 static uint32_t lcp2_imbalance(struct ctdb_public_ip_list
* all_ips
, int pnn
)
1614 struct ctdb_public_ip_list
*t
;
1616 uint32_t imbalance
= 0;
1618 for (t
=all_ips
; t
!=NULL
; t
=t
->next
) {
1619 if (t
->pnn
!= pnn
) {
1622 /* Pass the rest of the IPs rather than the whole
1625 imbalance
+= ip_distance_2_sum(&(t
->addr
), t
->next
, pnn
);
1631 /* Allocate any unassigned IPs just by looping through the IPs and
1632 * finding the best node for each.
1634 static void basic_allocate_unassigned(struct ctdb_context
*ctdb
,
1635 struct ctdb_ipflags
*ipflags
,
1636 struct ctdb_public_ip_list
*all_ips
)
1638 struct ctdb_public_ip_list
*tmp_ip
;
1640 /* loop over all ip's and find a physical node to cover for
1643 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
1644 if (tmp_ip
->pnn
== -1) {
1645 if (find_takeover_node(ctdb
, ipflags
, tmp_ip
, all_ips
)) {
1646 DEBUG(DEBUG_WARNING
,("Failed to find node to cover ip %s\n",
1647 ctdb_addr_to_str(&tmp_ip
->addr
)));
1653 /* Basic non-deterministic rebalancing algorithm.
1655 static void basic_failback(struct ctdb_context
*ctdb
,
1656 struct ctdb_ipflags
*ipflags
,
1657 struct ctdb_public_ip_list
*all_ips
,
1661 int maxnode
, maxnum
, minnode
, minnum
, num
, retries
;
1662 struct ctdb_public_ip_list
*tmp_ip
;
1664 numnodes
= talloc_array_length(ipflags
);
1671 /* for each ip address, loop over all nodes that can serve
1672 this ip and make sure that the difference between the node
1673 serving the most and the node serving the least ip's are
1676 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
1677 if (tmp_ip
->pnn
== -1) {
1681 /* Get the highest and lowest number of ips's served by any
1682 valid node which can serve this ip.
1686 for (i
=0; i
<numnodes
; i
++) {
1687 /* only check nodes that can actually serve this ip */
1688 if (!can_node_takeover_ip(ctdb
, i
, ipflags
[i
], tmp_ip
)) {
1689 /* no it couldnt so skip to the next node */
1693 num
= node_ip_coverage(ctdb
, i
, all_ips
);
1694 if (maxnode
== -1) {
1703 if (minnode
== -1) {
1713 if (maxnode
== -1) {
1714 DEBUG(DEBUG_WARNING
,(__location__
" Could not find maxnode. May not be able to serve ip '%s'\n",
1715 ctdb_addr_to_str(&tmp_ip
->addr
)));
1720 /* if the spread between the smallest and largest coverage by
1721 a node is >=2 we steal one of the ips from the node with
1722 most coverage to even things out a bit.
1723 try to do this a limited number of times since we dont
1724 want to spend too much time balancing the ip coverage.
1726 if ( (maxnum
> minnum
+1)
1727 && (retries
< (num_ips
+ 5)) ){
1728 struct ctdb_public_ip_list
*tmp
;
1730 /* Reassign one of maxnode's VNNs */
1731 for (tmp
=all_ips
;tmp
;tmp
=tmp
->next
) {
1732 if (tmp
->pnn
== maxnode
) {
1733 (void)find_takeover_node(ctdb
, ipflags
, tmp
, all_ips
);
1742 static void lcp2_init(struct ctdb_context
*tmp_ctx
,
1743 struct ctdb_ipflags
*ipflags
,
1744 struct ctdb_public_ip_list
*all_ips
,
1745 uint32_t *force_rebalance_nodes
,
1746 uint32_t **lcp2_imbalances
,
1747 bool **rebalance_candidates
)
1750 struct ctdb_public_ip_list
*tmp_ip
;
1752 numnodes
= talloc_array_length(ipflags
);
1754 *rebalance_candidates
= talloc_array(tmp_ctx
, bool, numnodes
);
1755 CTDB_NO_MEMORY_FATAL(tmp_ctx
, *rebalance_candidates
);
1756 *lcp2_imbalances
= talloc_array(tmp_ctx
, uint32_t, numnodes
);
1757 CTDB_NO_MEMORY_FATAL(tmp_ctx
, *lcp2_imbalances
);
1759 for (i
=0; i
<numnodes
; i
++) {
1760 (*lcp2_imbalances
)[i
] = lcp2_imbalance(all_ips
, i
);
1761 /* First step: assume all nodes are candidates */
1762 (*rebalance_candidates
)[i
] = true;
1765 /* 2nd step: if a node has IPs assigned then it must have been
1766 * healthy before, so we remove it from consideration. This
1767 * is overkill but is all we have because we don't maintain
1768 * state between takeover runs. An alternative would be to
1769 * keep state and invalidate it every time the recovery master
1772 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
1773 if (tmp_ip
->pnn
!= -1) {
1774 (*rebalance_candidates
)[tmp_ip
->pnn
] = false;
1778 /* 3rd step: if a node is forced to re-balance then
1779 we allow failback onto the node */
1780 if (force_rebalance_nodes
== NULL
) {
1783 for (i
= 0; i
< talloc_array_length(force_rebalance_nodes
); i
++) {
1784 uint32_t pnn
= force_rebalance_nodes
[i
];
1785 if (pnn
>= numnodes
) {
1787 (__location__
"unknown node %u\n", pnn
));
1792 ("Forcing rebalancing of IPs to node %u\n", pnn
));
1793 (*rebalance_candidates
)[pnn
] = true;
1797 /* Allocate any unassigned addresses using the LCP2 algorithm to find
1798 * the IP/node combination that will cost the least.
1800 static void lcp2_allocate_unassigned(struct ctdb_context
*ctdb
,
1801 struct ctdb_ipflags
*ipflags
,
1802 struct ctdb_public_ip_list
*all_ips
,
1803 uint32_t *lcp2_imbalances
)
1805 struct ctdb_public_ip_list
*tmp_ip
;
1806 int dstnode
, numnodes
;
1809 uint32_t mindsum
, dstdsum
, dstimbl
, minimbl
;
1810 struct ctdb_public_ip_list
*minip
;
1812 bool should_loop
= true;
1813 bool have_unassigned
= true;
1815 numnodes
= talloc_array_length(ipflags
);
1817 while (have_unassigned
&& should_loop
) {
1818 should_loop
= false;
1820 DEBUG(DEBUG_DEBUG
,(" ----------------------------------------\n"));
1821 DEBUG(DEBUG_DEBUG
,(" CONSIDERING MOVES (UNASSIGNED)\n"));
1827 /* loop over each unassigned ip. */
1828 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
1829 if (tmp_ip
->pnn
!= -1) {
1833 for (dstnode
=0; dstnode
<numnodes
; dstnode
++) {
1834 /* only check nodes that can actually takeover this ip */
1835 if (!can_node_takeover_ip(ctdb
, dstnode
,
1838 /* no it couldnt so skip to the next node */
1842 dstdsum
= ip_distance_2_sum(&(tmp_ip
->addr
), all_ips
, dstnode
);
1843 dstimbl
= lcp2_imbalances
[dstnode
] + dstdsum
;
1844 DEBUG(DEBUG_DEBUG
,(" %s -> %d [+%d]\n",
1845 ctdb_addr_to_str(&(tmp_ip
->addr
)),
1847 dstimbl
- lcp2_imbalances
[dstnode
]));
1850 if ((minnode
== -1) || (dstdsum
< mindsum
)) {
1860 DEBUG(DEBUG_DEBUG
,(" ----------------------------------------\n"));
1862 /* If we found one then assign it to the given node. */
1863 if (minnode
!= -1) {
1864 minip
->pnn
= minnode
;
1865 lcp2_imbalances
[minnode
] = minimbl
;
1866 DEBUG(DEBUG_INFO
,(" %s -> %d [+%d]\n",
1867 ctdb_addr_to_str(&(minip
->addr
)),
1872 /* There might be a better way but at least this is clear. */
1873 have_unassigned
= false;
1874 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
1875 if (tmp_ip
->pnn
== -1) {
1876 have_unassigned
= true;
1881 /* We know if we have an unassigned addresses so we might as
1884 if (have_unassigned
) {
1885 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
1886 if (tmp_ip
->pnn
== -1) {
1887 DEBUG(DEBUG_WARNING
,("Failed to find node to cover ip %s\n",
1888 ctdb_addr_to_str(&tmp_ip
->addr
)));
1894 /* LCP2 algorithm for rebalancing the cluster. Given a candidate node
1895 * to move IPs from, determines the best IP/destination node
1896 * combination to move from the source node.
1898 static bool lcp2_failback_candidate(struct ctdb_context
*ctdb
,
1899 struct ctdb_ipflags
*ipflags
,
1900 struct ctdb_public_ip_list
*all_ips
,
1902 uint32_t *lcp2_imbalances
,
1903 bool *rebalance_candidates
)
1905 int dstnode
, mindstnode
, numnodes
;
1906 uint32_t srcimbl
, srcdsum
, dstimbl
, dstdsum
;
1907 uint32_t minsrcimbl
, mindstimbl
;
1908 struct ctdb_public_ip_list
*minip
;
1909 struct ctdb_public_ip_list
*tmp_ip
;
1911 /* Find an IP and destination node that best reduces imbalance. */
1918 numnodes
= talloc_array_length(ipflags
);
1920 DEBUG(DEBUG_DEBUG
,(" ----------------------------------------\n"));
1921 DEBUG(DEBUG_DEBUG
,(" CONSIDERING MOVES FROM %d [%d]\n",
1922 srcnode
, lcp2_imbalances
[srcnode
]));
1924 for (tmp_ip
=all_ips
; tmp_ip
; tmp_ip
=tmp_ip
->next
) {
1925 /* Only consider addresses on srcnode. */
1926 if (tmp_ip
->pnn
!= srcnode
) {
1930 /* What is this IP address costing the source node? */
1931 srcdsum
= ip_distance_2_sum(&(tmp_ip
->addr
), all_ips
, srcnode
);
1932 srcimbl
= lcp2_imbalances
[srcnode
] - srcdsum
;
1934 /* Consider this IP address would cost each potential
1935 * destination node. Destination nodes are limited to
1936 * those that are newly healthy, since we don't want
1937 * to do gratuitous failover of IPs just to make minor
1938 * balance improvements.
1940 for (dstnode
=0; dstnode
<numnodes
; dstnode
++) {
1941 if (!rebalance_candidates
[dstnode
]) {
1945 /* only check nodes that can actually takeover this ip */
1946 if (!can_node_takeover_ip(ctdb
, dstnode
,
1947 ipflags
[dstnode
], tmp_ip
)) {
1948 /* no it couldnt so skip to the next node */
1952 dstdsum
= ip_distance_2_sum(&(tmp_ip
->addr
), all_ips
, dstnode
);
1953 dstimbl
= lcp2_imbalances
[dstnode
] + dstdsum
;
1954 DEBUG(DEBUG_DEBUG
,(" %d [%d] -> %s -> %d [+%d]\n",
1956 ctdb_addr_to_str(&(tmp_ip
->addr
)),
1959 if ((dstimbl
< lcp2_imbalances
[srcnode
]) &&
1960 (dstdsum
< srcdsum
) && \
1961 ((mindstnode
== -1) || \
1962 ((srcimbl
+ dstimbl
) < (minsrcimbl
+ mindstimbl
)))) {
1965 minsrcimbl
= srcimbl
;
1966 mindstnode
= dstnode
;
1967 mindstimbl
= dstimbl
;
1971 DEBUG(DEBUG_DEBUG
,(" ----------------------------------------\n"));
1973 if (mindstnode
!= -1) {
1974 /* We found a move that makes things better... */
1975 DEBUG(DEBUG_INFO
,("%d [%d] -> %s -> %d [+%d]\n",
1976 srcnode
, minsrcimbl
- lcp2_imbalances
[srcnode
],
1977 ctdb_addr_to_str(&(minip
->addr
)),
1978 mindstnode
, mindstimbl
- lcp2_imbalances
[mindstnode
]));
1981 lcp2_imbalances
[srcnode
] = minsrcimbl
;
1982 lcp2_imbalances
[mindstnode
] = mindstimbl
;
1983 minip
->pnn
= mindstnode
;
1992 struct lcp2_imbalance_pnn
{
1997 static int lcp2_cmp_imbalance_pnn(const void * a
, const void * b
)
1999 const struct lcp2_imbalance_pnn
* lipa
= (const struct lcp2_imbalance_pnn
*) a
;
2000 const struct lcp2_imbalance_pnn
* lipb
= (const struct lcp2_imbalance_pnn
*) b
;
2002 if (lipa
->imbalance
> lipb
->imbalance
) {
2004 } else if (lipa
->imbalance
== lipb
->imbalance
) {
2011 /* LCP2 algorithm for rebalancing the cluster. This finds the source
2012 * node with the highest LCP2 imbalance, and then determines the best
2013 * IP/destination node combination to move from the source node.
2015 static void lcp2_failback(struct ctdb_context
*ctdb
,
2016 struct ctdb_ipflags
*ipflags
,
2017 struct ctdb_public_ip_list
*all_ips
,
2018 uint32_t *lcp2_imbalances
,
2019 bool *rebalance_candidates
)
2022 struct lcp2_imbalance_pnn
* lips
;
2025 numnodes
= talloc_array_length(ipflags
);
2028 /* Put the imbalances and nodes into an array, sort them and
2029 * iterate through candidates. Usually the 1st one will be
2030 * used, so this doesn't cost much...
2032 DEBUG(DEBUG_DEBUG
,("+++++++++++++++++++++++++++++++++++++++++\n"));
2033 DEBUG(DEBUG_DEBUG
,("Selecting most imbalanced node from:\n"));
2034 lips
= talloc_array(ctdb
, struct lcp2_imbalance_pnn
, numnodes
);
2035 for (i
=0; i
<numnodes
; i
++) {
2036 lips
[i
].imbalance
= lcp2_imbalances
[i
];
2038 DEBUG(DEBUG_DEBUG
,(" %d [%d]\n", i
, lcp2_imbalances
[i
]));
2040 qsort(lips
, numnodes
, sizeof(struct lcp2_imbalance_pnn
),
2041 lcp2_cmp_imbalance_pnn
);
2044 for (i
=0; i
<numnodes
; i
++) {
2045 /* This means that all nodes had 0 or 1 addresses, so
2046 * can't be imbalanced.
2048 if (lips
[i
].imbalance
== 0) {
2052 if (lcp2_failback_candidate(ctdb
,
2057 rebalance_candidates
)) {
2069 static void unassign_unsuitable_ips(struct ctdb_context
*ctdb
,
2070 struct ctdb_ipflags
*ipflags
,
2071 struct ctdb_public_ip_list
*all_ips
)
2073 struct ctdb_public_ip_list
*tmp_ip
;
2075 /* verify that the assigned nodes can serve that public ip
2076 and set it to -1 if not
2078 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
2079 if (tmp_ip
->pnn
== -1) {
2082 if (!can_node_host_ip(ctdb
, tmp_ip
->pnn
,
2083 ipflags
[tmp_ip
->pnn
], tmp_ip
) != 0) {
2084 /* this node can not serve this ip. */
2085 DEBUG(DEBUG_DEBUG
,("Unassign IP: %s from %d\n",
2086 ctdb_addr_to_str(&(tmp_ip
->addr
)),
2093 static void ip_alloc_deterministic_ips(struct ctdb_context
*ctdb
,
2094 struct ctdb_ipflags
*ipflags
,
2095 struct ctdb_public_ip_list
*all_ips
)
2097 struct ctdb_public_ip_list
*tmp_ip
;
2100 numnodes
= talloc_array_length(ipflags
);
2102 DEBUG(DEBUG_NOTICE
,("Deterministic IPs enabled. Resetting all ip allocations\n"));
2103 /* Allocate IPs to nodes in a modulo fashion so that IPs will
2104 * always be allocated the same way for a specific set of
2105 * available/unavailable nodes.
2108 for (i
=0,tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
,i
++) {
2109 tmp_ip
->pnn
= i
% numnodes
;
2112 /* IP failback doesn't make sense with deterministic
2113 * IPs, since the modulo step above implicitly fails
2114 * back IPs to their "home" node.
2116 if (1 == ctdb
->tunable
.no_ip_failback
) {
2117 DEBUG(DEBUG_WARNING
, ("WARNING: 'NoIPFailback' set but ignored - incompatible with 'DeterministicIPs\n"));
2120 unassign_unsuitable_ips(ctdb
, ipflags
, all_ips
);
2122 basic_allocate_unassigned(ctdb
, ipflags
, all_ips
);
2124 /* No failback here! */
2127 static void ip_alloc_nondeterministic_ips(struct ctdb_context
*ctdb
,
2128 struct ctdb_ipflags
*ipflags
,
2129 struct ctdb_public_ip_list
*all_ips
)
2131 /* This should be pushed down into basic_failback. */
2132 struct ctdb_public_ip_list
*tmp_ip
;
2134 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
2138 unassign_unsuitable_ips(ctdb
, ipflags
, all_ips
);
2140 basic_allocate_unassigned(ctdb
, ipflags
, all_ips
);
2142 /* If we don't want IPs to fail back then don't rebalance IPs. */
2143 if (1 == ctdb
->tunable
.no_ip_failback
) {
2147 /* Now, try to make sure the ip adresses are evenly distributed
2150 basic_failback(ctdb
, ipflags
, all_ips
, num_ips
);
2153 static void ip_alloc_lcp2(struct ctdb_context
*ctdb
,
2154 struct ctdb_ipflags
*ipflags
,
2155 struct ctdb_public_ip_list
*all_ips
,
2156 uint32_t *force_rebalance_nodes
)
2158 uint32_t *lcp2_imbalances
;
2159 bool *rebalance_candidates
;
2160 int numnodes
, num_rebalance_candidates
, i
;
2162 TALLOC_CTX
*tmp_ctx
= talloc_new(ctdb
);
2164 unassign_unsuitable_ips(ctdb
, ipflags
, all_ips
);
2166 lcp2_init(tmp_ctx
, ipflags
, all_ips
,force_rebalance_nodes
,
2167 &lcp2_imbalances
, &rebalance_candidates
);
2169 lcp2_allocate_unassigned(ctdb
, ipflags
, all_ips
, lcp2_imbalances
);
2171 /* If we don't want IPs to fail back then don't rebalance IPs. */
2172 if (1 == ctdb
->tunable
.no_ip_failback
) {
2176 /* It is only worth continuing if we have suitable target
2177 * nodes to transfer IPs to. This check is much cheaper than
2180 numnodes
= talloc_array_length(ipflags
);
2181 num_rebalance_candidates
= 0;
2182 for (i
=0; i
<numnodes
; i
++) {
2183 if (rebalance_candidates
[i
]) {
2184 num_rebalance_candidates
++;
2187 if (num_rebalance_candidates
== 0) {
2191 /* Now, try to make sure the ip adresses are evenly distributed
2194 lcp2_failback(ctdb
, ipflags
, all_ips
,
2195 lcp2_imbalances
, rebalance_candidates
);
2198 talloc_free(tmp_ctx
);
2201 static bool all_nodes_are_disabled(struct ctdb_node_map
*nodemap
)
2205 for (i
=0;i
<nodemap
->num
;i
++) {
2206 if (!(nodemap
->nodes
[i
].flags
& (NODE_FLAGS_INACTIVE
|NODE_FLAGS_DISABLED
))) {
2207 /* Found one completely healthy node */
2215 /* The calculation part of the IP allocation algorithm. */
2216 static void ctdb_takeover_run_core(struct ctdb_context
*ctdb
,
2217 struct ctdb_ipflags
*ipflags
,
2218 struct ctdb_public_ip_list
**all_ips_p
,
2219 uint32_t *force_rebalance_nodes
)
2221 /* since nodes only know about those public addresses that
2222 can be served by that particular node, no single node has
2223 a full list of all public addresses that exist in the cluster.
2224 Walk over all node structures and create a merged list of
2225 all public addresses that exist in the cluster.
2227 keep the tree of ips around as ctdb->ip_tree
2229 *all_ips_p
= create_merged_ip_list(ctdb
);
2231 if (1 == ctdb
->tunable
.lcp2_public_ip_assignment
) {
2232 ip_alloc_lcp2(ctdb
, ipflags
, *all_ips_p
, force_rebalance_nodes
);
2233 } else if (1 == ctdb
->tunable
.deterministic_public_ips
) {
2234 ip_alloc_deterministic_ips(ctdb
, ipflags
, *all_ips_p
);
2236 ip_alloc_nondeterministic_ips(ctdb
, ipflags
, *all_ips_p
);
2239 /* at this point ->pnn is the node which will own each IP
2240 or -1 if there is no node that can cover this ip
2246 struct get_tunable_callback_data
{
2247 const char *tunable
;
2252 static void get_tunable_callback(struct ctdb_context
*ctdb
, uint32_t pnn
,
2253 int32_t res
, TDB_DATA outdata
,
2256 struct get_tunable_callback_data
*cd
=
2257 (struct get_tunable_callback_data
*)callback
;
2261 /* Already handled in fail callback */
2265 if (outdata
.dsize
!= sizeof(uint32_t)) {
2266 DEBUG(DEBUG_ERR
,("Wrong size of returned data when reading \"%s\" tunable from node %d. Expected %d bytes but received %d bytes\n",
2267 cd
->tunable
, pnn
, (int)sizeof(uint32_t),
2268 (int)outdata
.dsize
));
2273 size
= talloc_array_length(cd
->out
);
2275 DEBUG(DEBUG_ERR
,("Got %s reply from node %d but nodemap only has %d entries\n",
2276 cd
->tunable
, pnn
, size
));
2281 cd
->out
[pnn
] = *(uint32_t *)outdata
.dptr
;
2284 static void get_tunable_fail_callback(struct ctdb_context
*ctdb
, uint32_t pnn
,
2285 int32_t res
, TDB_DATA outdata
,
2288 struct get_tunable_callback_data
*cd
=
2289 (struct get_tunable_callback_data
*)callback
;
2294 ("Timed out getting tunable \"%s\" from node %d\n",
2300 DEBUG(DEBUG_WARNING
,
2301 ("Tunable \"%s\" not implemented on node %d\n",
2306 ("Unexpected error getting tunable \"%s\" from node %d\n",
2312 static uint32_t *get_tunable_from_nodes(struct ctdb_context
*ctdb
,
2313 TALLOC_CTX
*tmp_ctx
,
2314 struct ctdb_node_map
*nodemap
,
2315 const char *tunable
,
2316 uint32_t default_value
)
2319 struct ctdb_control_get_tunable
*t
;
2322 struct get_tunable_callback_data callback_data
;
2325 tvals
= talloc_array(tmp_ctx
, uint32_t, nodemap
->num
);
2326 CTDB_NO_MEMORY_NULL(ctdb
, tvals
);
2327 for (i
=0; i
<nodemap
->num
; i
++) {
2328 tvals
[i
] = default_value
;
2331 callback_data
.out
= tvals
;
2332 callback_data
.tunable
= tunable
;
2333 callback_data
.fatal
= false;
2335 data
.dsize
= offsetof(struct ctdb_control_get_tunable
, name
) + strlen(tunable
) + 1;
2336 data
.dptr
= talloc_size(tmp_ctx
, data
.dsize
);
2337 t
= (struct ctdb_control_get_tunable
*)data
.dptr
;
2338 t
->length
= strlen(tunable
)+1;
2339 memcpy(t
->name
, tunable
, t
->length
);
2340 nodes
= list_of_connected_nodes(ctdb
, nodemap
, tmp_ctx
, true);
2341 if (ctdb_client_async_control(ctdb
, CTDB_CONTROL_GET_TUNABLE
,
2342 nodes
, 0, TAKEOVER_TIMEOUT(),
2344 get_tunable_callback
,
2345 get_tunable_fail_callback
,
2346 &callback_data
) != 0) {
2347 if (callback_data
.fatal
) {
2353 talloc_free(data
.dptr
);
2358 struct get_runstate_callback_data
{
2359 enum ctdb_runstate
*out
;
2363 static void get_runstate_callback(struct ctdb_context
*ctdb
, uint32_t pnn
,
2364 int32_t res
, TDB_DATA outdata
,
2365 void *callback_data
)
2367 struct get_runstate_callback_data
*cd
=
2368 (struct get_runstate_callback_data
*)callback_data
;
2372 /* Already handled in fail callback */
2376 if (outdata
.dsize
!= sizeof(uint32_t)) {
2377 DEBUG(DEBUG_ERR
,("Wrong size of returned data when getting runstate from node %d. Expected %d bytes but received %d bytes\n",
2378 pnn
, (int)sizeof(uint32_t),
2379 (int)outdata
.dsize
));
2384 size
= talloc_array_length(cd
->out
);
2386 DEBUG(DEBUG_ERR
,("Got reply from node %d but nodemap only has %d entries\n",
2391 cd
->out
[pnn
] = (enum ctdb_runstate
)*(uint32_t *)outdata
.dptr
;
2394 static void get_runstate_fail_callback(struct ctdb_context
*ctdb
, uint32_t pnn
,
2395 int32_t res
, TDB_DATA outdata
,
2398 struct get_runstate_callback_data
*cd
=
2399 (struct get_runstate_callback_data
*)callback
;
2404 ("Timed out getting runstate from node %d\n", pnn
));
2408 DEBUG(DEBUG_WARNING
,
2409 ("Error getting runstate from node %d - assuming runstates not supported\n",
2414 static enum ctdb_runstate
* get_runstate_from_nodes(struct ctdb_context
*ctdb
,
2415 TALLOC_CTX
*tmp_ctx
,
2416 struct ctdb_node_map
*nodemap
,
2417 enum ctdb_runstate default_value
)
2420 enum ctdb_runstate
*rs
;
2421 struct get_runstate_callback_data callback_data
;
2424 rs
= talloc_array(tmp_ctx
, enum ctdb_runstate
, nodemap
->num
);
2425 CTDB_NO_MEMORY_NULL(ctdb
, rs
);
2426 for (i
=0; i
<nodemap
->num
; i
++) {
2427 rs
[i
] = default_value
;
2430 callback_data
.out
= rs
;
2431 callback_data
.fatal
= false;
2433 nodes
= list_of_connected_nodes(ctdb
, nodemap
, tmp_ctx
, true);
2434 if (ctdb_client_async_control(ctdb
, CTDB_CONTROL_GET_RUNSTATE
,
2435 nodes
, 0, TAKEOVER_TIMEOUT(),
2437 get_runstate_callback
,
2438 get_runstate_fail_callback
,
2439 &callback_data
) != 0) {
2440 if (callback_data
.fatal
) {
2450 /* Set internal flags for IP allocation:
2452 * Set NOIPTAKOVER ip flags from per-node NoIPTakeover tunable
2453 * Set NOIPHOST ip flag for each INACTIVE node
2454 * if all nodes are disabled:
2455 * Set NOIPHOST ip flags from per-node NoIPHostOnAllDisabled tunable
2457 * Set NOIPHOST ip flags for disabled nodes
2459 static struct ctdb_ipflags
*
2460 set_ipflags_internal(struct ctdb_context
*ctdb
,
2461 TALLOC_CTX
*tmp_ctx
,
2462 struct ctdb_node_map
*nodemap
,
2463 uint32_t *tval_noiptakeover
,
2464 uint32_t *tval_noiphostonalldisabled
,
2465 enum ctdb_runstate
*runstate
)
2468 struct ctdb_ipflags
*ipflags
;
2470 /* Clear IP flags - implicit due to talloc_zero */
2471 ipflags
= talloc_zero_array(tmp_ctx
, struct ctdb_ipflags
, nodemap
->num
);
2472 CTDB_NO_MEMORY_NULL(ctdb
, ipflags
);
2474 for (i
=0;i
<nodemap
->num
;i
++) {
2475 /* Can not take IPs on node with NoIPTakeover set */
2476 if (tval_noiptakeover
[i
] != 0) {
2477 ipflags
[i
].noiptakeover
= true;
2480 /* Can not host IPs on node not in RUNNING state */
2481 if (runstate
[i
] != CTDB_RUNSTATE_RUNNING
) {
2482 ipflags
[i
].noiphost
= true;
2485 /* Can not host IPs on INACTIVE node */
2486 if (nodemap
->nodes
[i
].flags
& NODE_FLAGS_INACTIVE
) {
2487 ipflags
[i
].noiphost
= true;
2491 if (all_nodes_are_disabled(nodemap
)) {
2492 /* If all nodes are disabled, can not host IPs on node
2493 * with NoIPHostOnAllDisabled set
2495 for (i
=0;i
<nodemap
->num
;i
++) {
2496 if (tval_noiphostonalldisabled
[i
] != 0) {
2497 ipflags
[i
].noiphost
= true;
2501 /* If some nodes are not disabled, then can not host
2502 * IPs on DISABLED node
2504 for (i
=0;i
<nodemap
->num
;i
++) {
2505 if (nodemap
->nodes
[i
].flags
& NODE_FLAGS_DISABLED
) {
2506 ipflags
[i
].noiphost
= true;
2514 static struct ctdb_ipflags
*set_ipflags(struct ctdb_context
*ctdb
,
2515 TALLOC_CTX
*tmp_ctx
,
2516 struct ctdb_node_map
*nodemap
)
2518 uint32_t *tval_noiptakeover
;
2519 uint32_t *tval_noiphostonalldisabled
;
2520 struct ctdb_ipflags
*ipflags
;
2521 enum ctdb_runstate
*runstate
;
2524 tval_noiptakeover
= get_tunable_from_nodes(ctdb
, tmp_ctx
, nodemap
,
2526 if (tval_noiptakeover
== NULL
) {
2530 tval_noiphostonalldisabled
=
2531 get_tunable_from_nodes(ctdb
, tmp_ctx
, nodemap
,
2532 "NoIPHostOnAllDisabled", 0);
2533 if (tval_noiphostonalldisabled
== NULL
) {
2534 /* Caller frees tmp_ctx */
2538 /* Any nodes where CTDB_CONTROL_GET_RUNSTATE is not supported
2539 * will default to CTDB_RUNSTATE_RUNNING. This ensures
2540 * reasonable behaviour on a mixed cluster during upgrade.
2542 runstate
= get_runstate_from_nodes(ctdb
, tmp_ctx
, nodemap
,
2543 CTDB_RUNSTATE_RUNNING
);
2544 if (runstate
== NULL
) {
2545 /* Caller frees tmp_ctx */
2549 ipflags
= set_ipflags_internal(ctdb
, tmp_ctx
, nodemap
,
2551 tval_noiphostonalldisabled
,
2554 talloc_free(tval_noiptakeover
);
2555 talloc_free(tval_noiphostonalldisabled
);
2556 talloc_free(runstate
);
2561 struct iprealloc_callback_data
{
2564 client_async_callback fail_callback
;
2565 void *fail_callback_data
;
2566 struct ctdb_node_map
*nodemap
;
2569 static void iprealloc_fail_callback(struct ctdb_context
*ctdb
, uint32_t pnn
,
2570 int32_t res
, TDB_DATA outdata
,
2574 struct iprealloc_callback_data
*cd
=
2575 (struct iprealloc_callback_data
*)callback
;
2577 numnodes
= talloc_array_length(cd
->retry_nodes
);
2578 if (pnn
> numnodes
) {
2580 ("ipreallocated failure from node %d, "
2581 "but only %d nodes in nodemap\n",
2586 /* Can't run the "ipreallocated" event on a INACTIVE node */
2587 if (cd
->nodemap
->nodes
[pnn
].flags
& NODE_FLAGS_INACTIVE
) {
2588 DEBUG(DEBUG_WARNING
,
2589 ("ipreallocated failed on inactive node %d, ignoring\n",
2596 /* If the control timed out then that's a real error,
2597 * so call the real fail callback
2599 if (cd
->fail_callback
) {
2600 cd
->fail_callback(ctdb
, pnn
, res
, outdata
,
2601 cd
->fail_callback_data
);
2603 DEBUG(DEBUG_WARNING
,
2604 ("iprealloc timed out but no callback registered\n"));
2608 /* If not a timeout then either the ipreallocated
2609 * eventscript (or some setup) failed. This might
2610 * have failed because the IPREALLOCATED control isn't
2611 * implemented - right now there is no way of knowing
2612 * because the error codes are all folded down to -1.
2613 * Consider retrying using EVENTSCRIPT control...
2615 DEBUG(DEBUG_WARNING
,
2616 ("ipreallocated failure from node %d, flagging retry\n",
2618 cd
->retry_nodes
[pnn
] = true;
2623 struct takeover_callback_data
{
2625 client_async_callback fail_callback
;
2626 void *fail_callback_data
;
2627 struct ctdb_node_map
*nodemap
;
2630 static void takeover_run_fail_callback(struct ctdb_context
*ctdb
,
2631 uint32_t node_pnn
, int32_t res
,
2632 TDB_DATA outdata
, void *callback_data
)
2634 struct takeover_callback_data
*cd
=
2635 talloc_get_type_abort(callback_data
,
2636 struct takeover_callback_data
);
2639 for (i
= 0; i
< cd
->nodemap
->num
; i
++) {
2640 if (node_pnn
== cd
->nodemap
->nodes
[i
].pnn
) {
2645 if (i
== cd
->nodemap
->num
) {
2646 DEBUG(DEBUG_ERR
, (__location__
" invalid PNN %u\n", node_pnn
));
2650 if (!cd
->node_failed
[i
]) {
2651 cd
->node_failed
[i
] = true;
2652 cd
->fail_callback(ctdb
, node_pnn
, res
, outdata
,
2653 cd
->fail_callback_data
);
2658 make any IP alias changes for public addresses that are necessary
2660 int ctdb_takeover_run(struct ctdb_context
*ctdb
, struct ctdb_node_map
*nodemap
,
2661 uint32_t *force_rebalance_nodes
,
2662 client_async_callback fail_callback
, void *callback_data
)
2665 struct ctdb_public_ip ip
;
2666 struct ctdb_public_ipv4 ipv4
;
2668 struct ctdb_public_ip_list
*all_ips
, *tmp_ip
;
2670 struct timeval timeout
;
2671 struct client_async_data
*async_data
;
2672 struct ctdb_client_control_state
*state
;
2673 TALLOC_CTX
*tmp_ctx
= talloc_new(ctdb
);
2674 struct ctdb_ipflags
*ipflags
;
2675 struct takeover_callback_data
*takeover_data
;
2676 struct iprealloc_callback_data iprealloc_data
;
2680 * ip failover is completely disabled, just send out the
2681 * ipreallocated event.
2683 if (ctdb
->tunable
.disable_ip_failover
!= 0) {
2687 ipflags
= set_ipflags(ctdb
, tmp_ctx
, nodemap
);
2688 if (ipflags
== NULL
) {
2689 DEBUG(DEBUG_ERR
,("Failed to set IP flags - aborting takeover run\n"));
2690 talloc_free(tmp_ctx
);
2696 /* Do the IP reassignment calculations */
2697 ctdb_takeover_run_core(ctdb
, ipflags
, &all_ips
, force_rebalance_nodes
);
2699 /* Now tell all nodes to release any public IPs should not
2700 * host. This will be a NOOP on nodes that don't currently
2701 * hold the given IP.
2703 takeover_data
= talloc_zero(tmp_ctx
, struct takeover_callback_data
);
2704 CTDB_NO_MEMORY_FATAL(ctdb
, takeover_data
);
2706 takeover_data
->node_failed
= talloc_zero_array(tmp_ctx
,
2707 bool, nodemap
->num
);
2708 CTDB_NO_MEMORY_FATAL(ctdb
, takeover_data
->node_failed
);
2709 takeover_data
->fail_callback
= fail_callback
;
2710 takeover_data
->fail_callback_data
= callback_data
;
2711 takeover_data
->nodemap
= nodemap
;
2713 async_data
= talloc_zero(tmp_ctx
, struct client_async_data
);
2714 CTDB_NO_MEMORY_FATAL(ctdb
, async_data
);
2716 async_data
->fail_callback
= takeover_run_fail_callback
;
2717 async_data
->callback_data
= takeover_data
;
2719 for (i
=0;i
<nodemap
->num
;i
++) {
2720 /* don't talk to unconnected nodes, but do talk to banned nodes */
2721 if (nodemap
->nodes
[i
].flags
& NODE_FLAGS_DISCONNECTED
) {
2725 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
2726 if (tmp_ip
->pnn
== nodemap
->nodes
[i
].pnn
) {
2727 /* This node should be serving this
2728 vnn so dont tell it to release the ip
2732 if (tmp_ip
->addr
.sa
.sa_family
== AF_INET
) {
2733 ipv4
.pnn
= tmp_ip
->pnn
;
2734 ipv4
.sin
= tmp_ip
->addr
.ip
;
2736 timeout
= TAKEOVER_TIMEOUT();
2737 data
.dsize
= sizeof(ipv4
);
2738 data
.dptr
= (uint8_t *)&ipv4
;
2739 state
= ctdb_control_send(ctdb
, nodemap
->nodes
[i
].pnn
,
2740 0, CTDB_CONTROL_RELEASE_IPv4
, 0,
2744 ip
.pnn
= tmp_ip
->pnn
;
2745 ip
.addr
= tmp_ip
->addr
;
2747 timeout
= TAKEOVER_TIMEOUT();
2748 data
.dsize
= sizeof(ip
);
2749 data
.dptr
= (uint8_t *)&ip
;
2750 state
= ctdb_control_send(ctdb
, nodemap
->nodes
[i
].pnn
,
2751 0, CTDB_CONTROL_RELEASE_IP
, 0,
2756 if (state
== NULL
) {
2757 DEBUG(DEBUG_ERR
,(__location__
" Failed to call async control CTDB_CONTROL_RELEASE_IP to node %u\n", nodemap
->nodes
[i
].pnn
));
2758 talloc_free(tmp_ctx
);
2762 ctdb_client_async_add(async_data
, state
);
2765 if (ctdb_client_async_wait(ctdb
, async_data
) != 0) {
2766 DEBUG(DEBUG_ERR
,(__location__
" Async control CTDB_CONTROL_RELEASE_IP failed\n"));
2767 talloc_free(tmp_ctx
);
2770 talloc_free(async_data
);
2773 /* tell all nodes to get their own IPs */
2774 async_data
= talloc_zero(tmp_ctx
, struct client_async_data
);
2775 CTDB_NO_MEMORY_FATAL(ctdb
, async_data
);
2777 async_data
->fail_callback
= fail_callback
;
2778 async_data
->callback_data
= callback_data
;
2780 for (tmp_ip
=all_ips
;tmp_ip
;tmp_ip
=tmp_ip
->next
) {
2781 if (tmp_ip
->pnn
== -1) {
2782 /* this IP won't be taken over */
2786 if (tmp_ip
->addr
.sa
.sa_family
== AF_INET
) {
2787 ipv4
.pnn
= tmp_ip
->pnn
;
2788 ipv4
.sin
= tmp_ip
->addr
.ip
;
2790 timeout
= TAKEOVER_TIMEOUT();
2791 data
.dsize
= sizeof(ipv4
);
2792 data
.dptr
= (uint8_t *)&ipv4
;
2793 state
= ctdb_control_send(ctdb
, tmp_ip
->pnn
,
2794 0, CTDB_CONTROL_TAKEOVER_IPv4
, 0,
2798 ip
.pnn
= tmp_ip
->pnn
;
2799 ip
.addr
= tmp_ip
->addr
;
2801 timeout
= TAKEOVER_TIMEOUT();
2802 data
.dsize
= sizeof(ip
);
2803 data
.dptr
= (uint8_t *)&ip
;
2804 state
= ctdb_control_send(ctdb
, tmp_ip
->pnn
,
2805 0, CTDB_CONTROL_TAKEOVER_IP
, 0,
2809 if (state
== NULL
) {
2810 DEBUG(DEBUG_ERR
,(__location__
" Failed to call async control CTDB_CONTROL_TAKEOVER_IP to node %u\n", tmp_ip
->pnn
));
2811 talloc_free(tmp_ctx
);
2815 ctdb_client_async_add(async_data
, state
);
2817 if (ctdb_client_async_wait(ctdb
, async_data
) != 0) {
2818 DEBUG(DEBUG_ERR
,(__location__
" Async control CTDB_CONTROL_TAKEOVER_IP failed\n"));
2819 talloc_free(tmp_ctx
);
2825 * Tell all nodes to run eventscripts to process the
2826 * "ipreallocated" event. This can do a lot of things,
2827 * including restarting services to reconfigure them if public
2828 * IPs have moved. Once upon a time this event only used to
2831 retry_data
= talloc_zero_array(tmp_ctx
, bool, nodemap
->num
);
2832 CTDB_NO_MEMORY_FATAL(ctdb
, retry_data
);
2833 iprealloc_data
.retry_nodes
= retry_data
;
2834 iprealloc_data
.retry_count
= 0;
2835 iprealloc_data
.fail_callback
= fail_callback
;
2836 iprealloc_data
.fail_callback_data
= callback_data
;
2837 iprealloc_data
.nodemap
= nodemap
;
2839 nodes
= list_of_connected_nodes(ctdb
, nodemap
, tmp_ctx
, true);
2840 ret
= ctdb_client_async_control(ctdb
, CTDB_CONTROL_IPREALLOCATED
,
2841 nodes
, 0, TAKEOVER_TIMEOUT(),
2843 NULL
, iprealloc_fail_callback
,
2846 /* If the control failed then we should retry to any
2847 * nodes flagged by iprealloc_fail_callback using the
2848 * EVENTSCRIPT control. This is a best-effort at
2849 * backward compatiblity when running a mixed cluster
2850 * where some nodes have not yet been upgraded to
2851 * support the IPREALLOCATED control.
2853 DEBUG(DEBUG_WARNING
,
2854 ("Retry ipreallocated to some nodes using eventscript control\n"));
2856 nodes
= talloc_array(tmp_ctx
, uint32_t,
2857 iprealloc_data
.retry_count
);
2858 CTDB_NO_MEMORY_FATAL(ctdb
, nodes
);
2861 for (i
=0; i
<nodemap
->num
; i
++) {
2862 if (iprealloc_data
.retry_nodes
[i
]) {
2868 data
.dptr
= discard_const("ipreallocated");
2869 data
.dsize
= strlen((char *)data
.dptr
) + 1;
2870 ret
= ctdb_client_async_control(ctdb
,
2871 CTDB_CONTROL_RUN_EVENTSCRIPTS
,
2872 nodes
, 0, TAKEOVER_TIMEOUT(),
2874 NULL
, fail_callback
,
2877 DEBUG(DEBUG_ERR
, (__location__
" failed to send control to run eventscripts with \"ipreallocated\"\n"));
2881 talloc_free(tmp_ctx
);
2887 destroy a ctdb_client_ip structure
2889 static int ctdb_client_ip_destructor(struct ctdb_client_ip
*ip
)
2891 DEBUG(DEBUG_DEBUG
,("destroying client tcp for %s:%u (client_id %u)\n",
2892 ctdb_addr_to_str(&ip
->addr
),
2893 ntohs(ip
->addr
.ip
.sin_port
),
2896 DLIST_REMOVE(ip
->ctdb
->client_ip_list
, ip
);
2901 called by a client to inform us of a TCP connection that it is managing
2902 that should tickled with an ACK when IP takeover is done
2903 we handle both the old ipv4 style of packets as well as the new ipv4/6
2906 int32_t ctdb_control_tcp_client(struct ctdb_context
*ctdb
, uint32_t client_id
,
2909 struct ctdb_client
*client
= ctdb_reqid_find(ctdb
, client_id
, struct ctdb_client
);
2910 struct ctdb_control_tcp
*old_addr
= NULL
;
2911 struct ctdb_control_tcp_addr new_addr
;
2912 struct ctdb_control_tcp_addr
*tcp_sock
= NULL
;
2913 struct ctdb_tcp_list
*tcp
;
2914 struct ctdb_tcp_connection t
;
2917 struct ctdb_client_ip
*ip
;
2918 struct ctdb_vnn
*vnn
;
2919 ctdb_sock_addr addr
;
2921 /* If we don't have public IPs, tickles are useless */
2922 if (ctdb
->vnn
== NULL
) {
2926 switch (indata
.dsize
) {
2927 case sizeof(struct ctdb_control_tcp
):
2928 old_addr
= (struct ctdb_control_tcp
*)indata
.dptr
;
2929 ZERO_STRUCT(new_addr
);
2930 tcp_sock
= &new_addr
;
2931 tcp_sock
->src
.ip
= old_addr
->src
;
2932 tcp_sock
->dest
.ip
= old_addr
->dest
;
2934 case sizeof(struct ctdb_control_tcp_addr
):
2935 tcp_sock
= (struct ctdb_control_tcp_addr
*)indata
.dptr
;
2938 DEBUG(DEBUG_ERR
,(__location__
" Invalid data structure passed "
2939 "to ctdb_control_tcp_client. size was %d but "
2940 "only allowed sizes are %lu and %lu\n",
2942 (long unsigned)sizeof(struct ctdb_control_tcp
),
2943 (long unsigned)sizeof(struct ctdb_control_tcp_addr
)));
2947 addr
= tcp_sock
->src
;
2948 ctdb_canonicalize_ip(&addr
, &tcp_sock
->src
);
2949 addr
= tcp_sock
->dest
;
2950 ctdb_canonicalize_ip(&addr
, &tcp_sock
->dest
);
2953 memcpy(&addr
, &tcp_sock
->dest
, sizeof(addr
));
2954 vnn
= find_public_ip_vnn(ctdb
, &addr
);
2956 switch (addr
.sa
.sa_family
) {
2958 if (ntohl(addr
.ip
.sin_addr
.s_addr
) != INADDR_LOOPBACK
) {
2959 DEBUG(DEBUG_ERR
,("Could not add client IP %s. This is not a public address.\n",
2960 ctdb_addr_to_str(&addr
)));
2964 DEBUG(DEBUG_ERR
,("Could not add client IP %s. This is not a public ipv6 address.\n",
2965 ctdb_addr_to_str(&addr
)));
2968 DEBUG(DEBUG_ERR
,(__location__
" Unknown family type %d\n", addr
.sa
.sa_family
));
2974 if (vnn
->pnn
!= ctdb
->pnn
) {
2975 DEBUG(DEBUG_ERR
,("Attempt to register tcp client for IP %s we don't hold - failing (client_id %u pid %u)\n",
2976 ctdb_addr_to_str(&addr
),
2977 client_id
, client
->pid
));
2978 /* failing this call will tell smbd to die */
2982 ip
= talloc(client
, struct ctdb_client_ip
);
2983 CTDB_NO_MEMORY(ctdb
, ip
);
2987 ip
->client_id
= client_id
;
2988 talloc_set_destructor(ip
, ctdb_client_ip_destructor
);
2989 DLIST_ADD(ctdb
->client_ip_list
, ip
);
2991 tcp
= talloc(client
, struct ctdb_tcp_list
);
2992 CTDB_NO_MEMORY(ctdb
, tcp
);
2994 tcp
->connection
.src_addr
= tcp_sock
->src
;
2995 tcp
->connection
.dst_addr
= tcp_sock
->dest
;
2997 DLIST_ADD(client
->tcp_list
, tcp
);
2999 t
.src_addr
= tcp_sock
->src
;
3000 t
.dst_addr
= tcp_sock
->dest
;
3002 data
.dptr
= (uint8_t *)&t
;
3003 data
.dsize
= sizeof(t
);
3005 switch (addr
.sa
.sa_family
) {
3007 DEBUG(DEBUG_INFO
,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
3008 (unsigned)ntohs(tcp_sock
->dest
.ip
.sin_port
),
3009 ctdb_addr_to_str(&tcp_sock
->src
),
3010 (unsigned)ntohs(tcp_sock
->src
.ip
.sin_port
), client_id
, client
->pid
));
3013 DEBUG(DEBUG_INFO
,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
3014 (unsigned)ntohs(tcp_sock
->dest
.ip6
.sin6_port
),
3015 ctdb_addr_to_str(&tcp_sock
->src
),
3016 (unsigned)ntohs(tcp_sock
->src
.ip6
.sin6_port
), client_id
, client
->pid
));
3019 DEBUG(DEBUG_ERR
,(__location__
" Unknown family %d\n", addr
.sa
.sa_family
));
3023 /* tell all nodes about this tcp connection */
3024 ret
= ctdb_daemon_send_control(ctdb
, CTDB_BROADCAST_CONNECTED
, 0,
3025 CTDB_CONTROL_TCP_ADD
,
3026 0, CTDB_CTRL_FLAG_NOREPLY
, data
, NULL
, NULL
);
3028 DEBUG(DEBUG_ERR
,(__location__
" Failed to send CTDB_CONTROL_TCP_ADD\n"));
3036 find a tcp address on a list
3038 static struct ctdb_tcp_connection
*ctdb_tcp_find(struct ctdb_tcp_array
*array
,
3039 struct ctdb_tcp_connection
*tcp
)
3043 if (array
== NULL
) {
3047 for (i
=0;i
<array
->num
;i
++) {
3048 if (ctdb_same_sockaddr(&array
->connections
[i
].src_addr
, &tcp
->src_addr
) &&
3049 ctdb_same_sockaddr(&array
->connections
[i
].dst_addr
, &tcp
->dst_addr
)) {
3050 return &array
->connections
[i
];
3059 called by a daemon to inform us of a TCP connection that one of its
3060 clients managing that should tickled with an ACK when IP takeover is
3063 int32_t ctdb_control_tcp_add(struct ctdb_context
*ctdb
, TDB_DATA indata
, bool tcp_update_needed
)
3065 struct ctdb_tcp_connection
*p
= (struct ctdb_tcp_connection
*)indata
.dptr
;
3066 struct ctdb_tcp_array
*tcparray
;
3067 struct ctdb_tcp_connection tcp
;
3068 struct ctdb_vnn
*vnn
;
3070 /* If we don't have public IPs, tickles are useless */
3071 if (ctdb
->vnn
== NULL
) {
3075 vnn
= find_public_ip_vnn(ctdb
, &p
->dst_addr
);
3077 DEBUG(DEBUG_INFO
,(__location__
" got TCP_ADD control for an address which is not a public address '%s'\n",
3078 ctdb_addr_to_str(&p
->dst_addr
)));
3084 tcparray
= vnn
->tcp_array
;
3086 /* If this is the first tickle */
3087 if (tcparray
== NULL
) {
3088 tcparray
= talloc(vnn
, struct ctdb_tcp_array
);
3089 CTDB_NO_MEMORY(ctdb
, tcparray
);
3090 vnn
->tcp_array
= tcparray
;
3093 tcparray
->connections
= talloc_size(tcparray
, sizeof(struct ctdb_tcp_connection
));
3094 CTDB_NO_MEMORY(ctdb
, tcparray
->connections
);
3096 tcparray
->connections
[tcparray
->num
].src_addr
= p
->src_addr
;
3097 tcparray
->connections
[tcparray
->num
].dst_addr
= p
->dst_addr
;
3100 if (tcp_update_needed
) {
3101 vnn
->tcp_update_needed
= true;
3107 /* Do we already have this tickle ?*/
3108 tcp
.src_addr
= p
->src_addr
;
3109 tcp
.dst_addr
= p
->dst_addr
;
3110 if (ctdb_tcp_find(tcparray
, &tcp
) != NULL
) {
3111 DEBUG(DEBUG_DEBUG
,("Already had tickle info for %s:%u for vnn:%u\n",
3112 ctdb_addr_to_str(&tcp
.dst_addr
),
3113 ntohs(tcp
.dst_addr
.ip
.sin_port
),
3118 /* A new tickle, we must add it to the array */
3119 tcparray
->connections
= talloc_realloc(tcparray
, tcparray
->connections
,
3120 struct ctdb_tcp_connection
,
3122 CTDB_NO_MEMORY(ctdb
, tcparray
->connections
);
3124 tcparray
->connections
[tcparray
->num
].src_addr
= p
->src_addr
;
3125 tcparray
->connections
[tcparray
->num
].dst_addr
= p
->dst_addr
;
3128 DEBUG(DEBUG_INFO
,("Added tickle info for %s:%u from vnn %u\n",
3129 ctdb_addr_to_str(&tcp
.dst_addr
),
3130 ntohs(tcp
.dst_addr
.ip
.sin_port
),
3133 if (tcp_update_needed
) {
3134 vnn
->tcp_update_needed
= true;
3142 called by a daemon to inform us of a TCP connection that one of its
3143 clients managing that should tickled with an ACK when IP takeover is
3146 static void ctdb_remove_tcp_connection(struct ctdb_context
*ctdb
, struct ctdb_tcp_connection
*conn
)
3148 struct ctdb_tcp_connection
*tcpp
;
3149 struct ctdb_vnn
*vnn
= find_public_ip_vnn(ctdb
, &conn
->dst_addr
);
3152 DEBUG(DEBUG_ERR
,(__location__
" unable to find public address %s\n",
3153 ctdb_addr_to_str(&conn
->dst_addr
)));
3157 /* if the array is empty we cant remove it
3158 and we dont need to do anything
3160 if (vnn
->tcp_array
== NULL
) {
3161 DEBUG(DEBUG_INFO
,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
3162 ctdb_addr_to_str(&conn
->dst_addr
),
3163 ntohs(conn
->dst_addr
.ip
.sin_port
)));
3168 /* See if we know this connection
3169 if we dont know this connection then we dont need to do anything
3171 tcpp
= ctdb_tcp_find(vnn
->tcp_array
, conn
);
3173 DEBUG(DEBUG_INFO
,("Trying to remove tickle that doesnt exist %s:%u\n",
3174 ctdb_addr_to_str(&conn
->dst_addr
),
3175 ntohs(conn
->dst_addr
.ip
.sin_port
)));
3180 /* We need to remove this entry from the array.
3181 Instead of allocating a new array and copying data to it
3182 we cheat and just copy the last entry in the existing array
3183 to the entry that is to be removed and just shring the
3186 *tcpp
= vnn
->tcp_array
->connections
[vnn
->tcp_array
->num
- 1];
3187 vnn
->tcp_array
->num
--;
3189 /* If we deleted the last entry we also need to remove the entire array
3191 if (vnn
->tcp_array
->num
== 0) {
3192 talloc_free(vnn
->tcp_array
);
3193 vnn
->tcp_array
= NULL
;
3196 vnn
->tcp_update_needed
= true;
3198 DEBUG(DEBUG_INFO
,("Removed tickle info for %s:%u\n",
3199 ctdb_addr_to_str(&conn
->src_addr
),
3200 ntohs(conn
->src_addr
.ip
.sin_port
)));
3205 called by a daemon to inform us of a TCP connection that one of its
3206 clients used are no longer needed in the tickle database
3208 int32_t ctdb_control_tcp_remove(struct ctdb_context
*ctdb
, TDB_DATA indata
)
3210 struct ctdb_tcp_connection
*conn
= (struct ctdb_tcp_connection
*)indata
.dptr
;
3212 /* If we don't have public IPs, tickles are useless */
3213 if (ctdb
->vnn
== NULL
) {
3217 ctdb_remove_tcp_connection(ctdb
, conn
);
3224 Called when another daemon starts - caises all tickles for all
3225 public addresses we are serving to be sent to the new node on the
3226 next check. This actually causes the next scheduled call to
3227 tdb_update_tcp_tickles() to update all nodes. This is simple and
3228 doesn't require careful error handling.
3230 int32_t ctdb_control_startup(struct ctdb_context
*ctdb
, uint32_t pnn
)
3232 struct ctdb_vnn
*vnn
;
3234 for (vnn
= ctdb
->vnn
; vnn
!= NULL
; vnn
= vnn
->next
) {
3235 vnn
->tcp_update_needed
= true;
3243 called when a client structure goes away - hook to remove
3244 elements from the tcp_list in all daemons
3246 void ctdb_takeover_client_destructor_hook(struct ctdb_client
*client
)
3248 while (client
->tcp_list
) {
3249 struct ctdb_tcp_list
*tcp
= client
->tcp_list
;
3250 DLIST_REMOVE(client
->tcp_list
, tcp
);
3251 ctdb_remove_tcp_connection(client
->ctdb
, &tcp
->connection
);
3257 release all IPs on shutdown
3259 void ctdb_release_all_ips(struct ctdb_context
*ctdb
)
3261 struct ctdb_vnn
*vnn
;
3264 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
3265 if (!ctdb_sys_have_ip(&vnn
->public_address
)) {
3266 ctdb_vnn_unassign_iface(ctdb
, vnn
);
3273 DEBUG(DEBUG_INFO
,("Release of IP %s/%u on interface %s node:-1\n",
3274 ctdb_addr_to_str(&vnn
->public_address
),
3275 vnn
->public_netmask_bits
,
3276 ctdb_vnn_iface_string(vnn
)));
3278 ctdb_event_script_args(ctdb
, CTDB_EVENT_RELEASE_IP
, "%s %s %u",
3279 ctdb_vnn_iface_string(vnn
),
3280 ctdb_addr_to_str(&vnn
->public_address
),
3281 vnn
->public_netmask_bits
);
3282 release_kill_clients(ctdb
, &vnn
->public_address
);
3283 ctdb_vnn_unassign_iface(ctdb
, vnn
);
3287 DEBUG(DEBUG_NOTICE
,(__location__
" Released %d public IPs\n", count
));
3292 get list of public IPs
3294 int32_t ctdb_control_get_public_ips(struct ctdb_context
*ctdb
,
3295 struct ctdb_req_control
*c
, TDB_DATA
*outdata
)
3298 struct ctdb_all_public_ips
*ips
;
3299 struct ctdb_vnn
*vnn
;
3300 bool only_available
= false;
3302 if (c
->flags
& CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE
) {
3303 only_available
= true;
3306 /* count how many public ip structures we have */
3308 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
3312 len
= offsetof(struct ctdb_all_public_ips
, ips
) +
3313 num
*sizeof(struct ctdb_public_ip
);
3314 ips
= talloc_zero_size(outdata
, len
);
3315 CTDB_NO_MEMORY(ctdb
, ips
);
3318 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
3319 if (only_available
&& !ctdb_vnn_available(ctdb
, vnn
)) {
3322 ips
->ips
[i
].pnn
= vnn
->pnn
;
3323 ips
->ips
[i
].addr
= vnn
->public_address
;
3327 len
= offsetof(struct ctdb_all_public_ips
, ips
) +
3328 i
*sizeof(struct ctdb_public_ip
);
3330 outdata
->dsize
= len
;
3331 outdata
->dptr
= (uint8_t *)ips
;
3338 get list of public IPs, old ipv4 style. only returns ipv4 addresses
3340 int32_t ctdb_control_get_public_ipsv4(struct ctdb_context
*ctdb
,
3341 struct ctdb_req_control
*c
, TDB_DATA
*outdata
)
3344 struct ctdb_all_public_ipsv4
*ips
;
3345 struct ctdb_vnn
*vnn
;
3347 /* count how many public ip structures we have */
3349 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
3350 if (vnn
->public_address
.sa
.sa_family
!= AF_INET
) {
3356 len
= offsetof(struct ctdb_all_public_ipsv4
, ips
) +
3357 num
*sizeof(struct ctdb_public_ipv4
);
3358 ips
= talloc_zero_size(outdata
, len
);
3359 CTDB_NO_MEMORY(ctdb
, ips
);
3361 outdata
->dsize
= len
;
3362 outdata
->dptr
= (uint8_t *)ips
;
3366 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
3367 if (vnn
->public_address
.sa
.sa_family
!= AF_INET
) {
3370 ips
->ips
[i
].pnn
= vnn
->pnn
;
3371 ips
->ips
[i
].sin
= vnn
->public_address
.ip
;
3378 int32_t ctdb_control_get_public_ip_info(struct ctdb_context
*ctdb
,
3379 struct ctdb_req_control
*c
,
3384 ctdb_sock_addr
*addr
;
3385 struct ctdb_control_public_ip_info
*info
;
3386 struct ctdb_vnn
*vnn
;
3388 addr
= (ctdb_sock_addr
*)indata
.dptr
;
3390 vnn
= find_public_ip_vnn(ctdb
, addr
);
3392 /* if it is not a public ip it could be our 'single ip' */
3393 if (ctdb
->single_ip_vnn
) {
3394 if (ctdb_same_ip(&ctdb
->single_ip_vnn
->public_address
, addr
)) {
3395 vnn
= ctdb
->single_ip_vnn
;
3400 DEBUG(DEBUG_ERR
,(__location__
" Could not get public ip info, "
3401 "'%s'not a public address\n",
3402 ctdb_addr_to_str(addr
)));
3406 /* count how many public ip structures we have */
3408 for (;vnn
->ifaces
[num
];) {
3412 len
= offsetof(struct ctdb_control_public_ip_info
, ifaces
) +
3413 num
*sizeof(struct ctdb_control_iface_info
);
3414 info
= talloc_zero_size(outdata
, len
);
3415 CTDB_NO_MEMORY(ctdb
, info
);
3417 info
->ip
.addr
= vnn
->public_address
;
3418 info
->ip
.pnn
= vnn
->pnn
;
3419 info
->active_idx
= 0xFFFFFFFF;
3421 for (i
=0; vnn
->ifaces
[i
]; i
++) {
3422 struct ctdb_iface
*cur
;
3424 cur
= ctdb_find_iface(ctdb
, vnn
->ifaces
[i
]);
3426 DEBUG(DEBUG_CRIT
, (__location__
" internal error iface[%s] unknown\n",
3430 if (vnn
->iface
== cur
) {
3431 info
->active_idx
= i
;
3433 strncpy(info
->ifaces
[i
].name
, cur
->name
, sizeof(info
->ifaces
[i
].name
)-1);
3434 info
->ifaces
[i
].link_state
= cur
->link_up
;
3435 info
->ifaces
[i
].references
= cur
->references
;
3438 len
= offsetof(struct ctdb_control_public_ip_info
, ifaces
) +
3439 i
*sizeof(struct ctdb_control_iface_info
);
3441 outdata
->dsize
= len
;
3442 outdata
->dptr
= (uint8_t *)info
;
3447 int32_t ctdb_control_get_ifaces(struct ctdb_context
*ctdb
,
3448 struct ctdb_req_control
*c
,
3452 struct ctdb_control_get_ifaces
*ifaces
;
3453 struct ctdb_iface
*cur
;
3455 /* count how many public ip structures we have */
3457 for (cur
=ctdb
->ifaces
;cur
;cur
=cur
->next
) {
3461 len
= offsetof(struct ctdb_control_get_ifaces
, ifaces
) +
3462 num
*sizeof(struct ctdb_control_iface_info
);
3463 ifaces
= talloc_zero_size(outdata
, len
);
3464 CTDB_NO_MEMORY(ctdb
, ifaces
);
3467 for (cur
=ctdb
->ifaces
;cur
;cur
=cur
->next
) {
3468 strcpy(ifaces
->ifaces
[i
].name
, cur
->name
);
3469 ifaces
->ifaces
[i
].link_state
= cur
->link_up
;
3470 ifaces
->ifaces
[i
].references
= cur
->references
;
3474 len
= offsetof(struct ctdb_control_get_ifaces
, ifaces
) +
3475 i
*sizeof(struct ctdb_control_iface_info
);
3477 outdata
->dsize
= len
;
3478 outdata
->dptr
= (uint8_t *)ifaces
;
3483 int32_t ctdb_control_set_iface_link(struct ctdb_context
*ctdb
,
3484 struct ctdb_req_control
*c
,
3487 struct ctdb_control_iface_info
*info
;
3488 struct ctdb_iface
*iface
;
3489 bool link_up
= false;
3491 info
= (struct ctdb_control_iface_info
*)indata
.dptr
;
3493 if (info
->name
[CTDB_IFACE_SIZE
] != '\0') {
3494 int len
= strnlen(info
->name
, CTDB_IFACE_SIZE
);
3495 DEBUG(DEBUG_ERR
, (__location__
" name[%*.*s] not terminated\n",
3496 len
, len
, info
->name
));
3500 switch (info
->link_state
) {
3508 DEBUG(DEBUG_ERR
, (__location__
" link_state[%u] invalid\n",
3509 (unsigned int)info
->link_state
));
3513 if (info
->references
!= 0) {
3514 DEBUG(DEBUG_ERR
, (__location__
" references[%u] should be 0\n",
3515 (unsigned int)info
->references
));
3519 iface
= ctdb_find_iface(ctdb
, info
->name
);
3520 if (iface
== NULL
) {
3524 if (link_up
== iface
->link_up
) {
3528 DEBUG(iface
->link_up
?DEBUG_ERR
:DEBUG_NOTICE
,
3529 ("iface[%s] has changed it's link status %s => %s\n",
3531 iface
->link_up
?"up":"down",
3532 link_up
?"up":"down"));
3534 iface
->link_up
= link_up
;
3540 structure containing the listening socket and the list of tcp connections
3541 that the ctdb daemon is to kill
3543 struct ctdb_kill_tcp
{
3544 struct ctdb_vnn
*vnn
;
3545 struct ctdb_context
*ctdb
;
3547 struct fd_event
*fde
;
3548 trbt_tree_t
*connections
;
3553 a tcp connection that is to be killed
3555 struct ctdb_killtcp_con
{
3556 ctdb_sock_addr src_addr
;
3557 ctdb_sock_addr dst_addr
;
3559 struct ctdb_kill_tcp
*killtcp
;
3562 /* this function is used to create a key to represent this socketpair
3563 in the killtcp tree.
3564 this key is used to insert and lookup matching socketpairs that are
3565 to be tickled and RST
3567 #define KILLTCP_KEYLEN 10
3568 static uint32_t *killtcp_key(ctdb_sock_addr
*src
, ctdb_sock_addr
*dst
)
3570 static uint32_t key
[KILLTCP_KEYLEN
];
3572 bzero(key
, sizeof(key
));
3574 if (src
->sa
.sa_family
!= dst
->sa
.sa_family
) {
3575 DEBUG(DEBUG_ERR
, (__location__
" ERROR, different families passed :%u vs %u\n", src
->sa
.sa_family
, dst
->sa
.sa_family
));
3579 switch (src
->sa
.sa_family
) {
3581 key
[0] = dst
->ip
.sin_addr
.s_addr
;
3582 key
[1] = src
->ip
.sin_addr
.s_addr
;
3583 key
[2] = dst
->ip
.sin_port
;
3584 key
[3] = src
->ip
.sin_port
;
3587 uint32_t *dst6_addr32
=
3588 (uint32_t *)&(dst
->ip6
.sin6_addr
.s6_addr
);
3589 uint32_t *src6_addr32
=
3590 (uint32_t *)&(src
->ip6
.sin6_addr
.s6_addr
);
3591 key
[0] = dst6_addr32
[3];
3592 key
[1] = src6_addr32
[3];
3593 key
[2] = dst6_addr32
[2];
3594 key
[3] = src6_addr32
[2];
3595 key
[4] = dst6_addr32
[1];
3596 key
[5] = src6_addr32
[1];
3597 key
[6] = dst6_addr32
[0];
3598 key
[7] = src6_addr32
[0];
3599 key
[8] = dst
->ip6
.sin6_port
;
3600 key
[9] = src
->ip6
.sin6_port
;
3604 DEBUG(DEBUG_ERR
, (__location__
" ERROR, unknown family passed :%u\n", src
->sa
.sa_family
));
3612 called when we get a read event on the raw socket
3614 static void capture_tcp_handler(struct event_context
*ev
, struct fd_event
*fde
,
3615 uint16_t flags
, void *private_data
)
3617 struct ctdb_kill_tcp
*killtcp
= talloc_get_type(private_data
, struct ctdb_kill_tcp
);
3618 struct ctdb_killtcp_con
*con
;
3619 ctdb_sock_addr src
, dst
;
3620 uint32_t ack_seq
, seq
;
3622 if (!(flags
& EVENT_FD_READ
)) {
3626 if (ctdb_sys_read_tcp_packet(killtcp
->capture_fd
,
3627 killtcp
->private_data
,
3629 &ack_seq
, &seq
) != 0) {
3630 /* probably a non-tcp ACK packet */
3634 /* check if we have this guy in our list of connections
3637 con
= trbt_lookuparray32(killtcp
->connections
,
3638 KILLTCP_KEYLEN
, killtcp_key(&src
, &dst
));
3640 /* no this was some other packet we can just ignore */
3644 /* This one has been tickled !
3645 now reset him and remove him from the list.
3647 DEBUG(DEBUG_INFO
, ("sending a tcp reset to kill connection :%d -> %s:%d\n",
3648 ntohs(con
->dst_addr
.ip
.sin_port
),
3649 ctdb_addr_to_str(&con
->src_addr
),
3650 ntohs(con
->src_addr
.ip
.sin_port
)));
3652 ctdb_sys_send_tcp(&con
->dst_addr
, &con
->src_addr
, ack_seq
, seq
, 1);
3657 /* when traversing the list of all tcp connections to send tickle acks to
3658 (so that we can capture the ack coming back and kill the connection
3660 this callback is called for each connection we are currently trying to kill
3662 static int tickle_connection_traverse(void *param
, void *data
)
3664 struct ctdb_killtcp_con
*con
= talloc_get_type(data
, struct ctdb_killtcp_con
);
3666 /* have tried too many times, just give up */
3667 if (con
->count
>= 5) {
3668 /* can't delete in traverse: reparent to delete_cons */
3669 talloc_steal(param
, con
);
3673 /* othervise, try tickling it again */
3676 (ctdb_sock_addr
*)&con
->dst_addr
,
3677 (ctdb_sock_addr
*)&con
->src_addr
,
3684 called every second until all sentenced connections have been reset
3686 static void ctdb_tickle_sentenced_connections(struct event_context
*ev
, struct timed_event
*te
,
3687 struct timeval t
, void *private_data
)
3689 struct ctdb_kill_tcp
*killtcp
= talloc_get_type(private_data
, struct ctdb_kill_tcp
);
3690 void *delete_cons
= talloc_new(NULL
);
3692 /* loop over all connections sending tickle ACKs */
3693 trbt_traversearray32(killtcp
->connections
, KILLTCP_KEYLEN
, tickle_connection_traverse
, delete_cons
);
3695 /* now we've finished traverse, it's safe to do deletion. */
3696 talloc_free(delete_cons
);
3698 /* If there are no more connections to kill we can remove the
3699 entire killtcp structure
3701 if ( (killtcp
->connections
== NULL
) ||
3702 (killtcp
->connections
->root
== NULL
) ) {
3703 talloc_free(killtcp
);
3707 /* try tickling them again in a seconds time
3709 event_add_timed(killtcp
->ctdb
->ev
, killtcp
, timeval_current_ofs(1, 0),
3710 ctdb_tickle_sentenced_connections
, killtcp
);
3714 destroy the killtcp structure
3716 static int ctdb_killtcp_destructor(struct ctdb_kill_tcp
*killtcp
)
3718 struct ctdb_vnn
*tmpvnn
;
3720 /* verify that this vnn is still active */
3721 for (tmpvnn
= killtcp
->ctdb
->vnn
; tmpvnn
; tmpvnn
= tmpvnn
->next
) {
3722 if (tmpvnn
== killtcp
->vnn
) {
3727 if (tmpvnn
== NULL
) {
3731 if (killtcp
->vnn
->killtcp
!= killtcp
) {
3735 killtcp
->vnn
->killtcp
= NULL
;
3741 /* nothing fancy here, just unconditionally replace any existing
3742 connection structure with the new one.
3744 dont even free the old one if it did exist, that one is talloc_stolen
3745 by the same node in the tree anyway and will be deleted when the new data
3748 static void *add_killtcp_callback(void *parm
, void *data
)
3754 add a tcp socket to the list of connections we want to RST
3756 static int ctdb_killtcp_add_connection(struct ctdb_context
*ctdb
,
3760 ctdb_sock_addr src
, dst
;
3761 struct ctdb_kill_tcp
*killtcp
;
3762 struct ctdb_killtcp_con
*con
;
3763 struct ctdb_vnn
*vnn
;
3765 ctdb_canonicalize_ip(s
, &src
);
3766 ctdb_canonicalize_ip(d
, &dst
);
3768 vnn
= find_public_ip_vnn(ctdb
, &dst
);
3770 vnn
= find_public_ip_vnn(ctdb
, &src
);
3773 /* if it is not a public ip it could be our 'single ip' */
3774 if (ctdb
->single_ip_vnn
) {
3775 if (ctdb_same_ip(&ctdb
->single_ip_vnn
->public_address
, &dst
)) {
3776 vnn
= ctdb
->single_ip_vnn
;
3781 DEBUG(DEBUG_ERR
,(__location__
" Could not killtcp, not a public address\n"));
3785 killtcp
= vnn
->killtcp
;
3787 /* If this is the first connection to kill we must allocate
3790 if (killtcp
== NULL
) {
3791 killtcp
= talloc_zero(vnn
, struct ctdb_kill_tcp
);
3792 CTDB_NO_MEMORY(ctdb
, killtcp
);
3795 killtcp
->ctdb
= ctdb
;
3796 killtcp
->capture_fd
= -1;
3797 killtcp
->connections
= trbt_create(killtcp
, 0);
3799 vnn
->killtcp
= killtcp
;
3800 talloc_set_destructor(killtcp
, ctdb_killtcp_destructor
);
3805 /* create a structure that describes this connection we want to
3806 RST and store it in killtcp->connections
3808 con
= talloc(killtcp
, struct ctdb_killtcp_con
);
3809 CTDB_NO_MEMORY(ctdb
, con
);
3810 con
->src_addr
= src
;
3811 con
->dst_addr
= dst
;
3813 con
->killtcp
= killtcp
;
3816 trbt_insertarray32_callback(killtcp
->connections
,
3817 KILLTCP_KEYLEN
, killtcp_key(&con
->dst_addr
, &con
->src_addr
),
3818 add_killtcp_callback
, con
);
3821 If we dont have a socket to listen on yet we must create it
3823 if (killtcp
->capture_fd
== -1) {
3824 const char *iface
= ctdb_vnn_iface_string(vnn
);
3825 killtcp
->capture_fd
= ctdb_sys_open_capture_socket(iface
, &killtcp
->private_data
);
3826 if (killtcp
->capture_fd
== -1) {
3827 DEBUG(DEBUG_CRIT
,(__location__
" Failed to open capturing "
3828 "socket on iface '%s' for killtcp (%s)\n",
3829 iface
, strerror(errno
)));
3835 if (killtcp
->fde
== NULL
) {
3836 killtcp
->fde
= event_add_fd(ctdb
->ev
, killtcp
, killtcp
->capture_fd
,
3838 capture_tcp_handler
, killtcp
);
3839 tevent_fd_set_auto_close(killtcp
->fde
);
3841 /* We also need to set up some events to tickle all these connections
3842 until they are all reset
3844 event_add_timed(ctdb
->ev
, killtcp
, timeval_current_ofs(1, 0),
3845 ctdb_tickle_sentenced_connections
, killtcp
);
3848 /* tickle him once now */
3857 talloc_free(vnn
->killtcp
);
3858 vnn
->killtcp
= NULL
;
3863 kill a TCP connection.
3865 int32_t ctdb_control_kill_tcp(struct ctdb_context
*ctdb
, TDB_DATA indata
)
3867 struct ctdb_control_killtcp
*killtcp
= (struct ctdb_control_killtcp
*)indata
.dptr
;
3869 return ctdb_killtcp_add_connection(ctdb
, &killtcp
->src_addr
, &killtcp
->dst_addr
);
3873 called by a daemon to inform us of the entire list of TCP tickles for
3874 a particular public address.
3875 this control should only be sent by the node that is currently serving
3876 that public address.
3878 int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context
*ctdb
, TDB_DATA indata
)
3880 struct ctdb_control_tcp_tickle_list
*list
= (struct ctdb_control_tcp_tickle_list
*)indata
.dptr
;
3881 struct ctdb_tcp_array
*tcparray
;
3882 struct ctdb_vnn
*vnn
;
3884 /* We must at least have tickles.num or else we cant verify the size
3885 of the received data blob
3887 if (indata
.dsize
< offsetof(struct ctdb_control_tcp_tickle_list
,
3888 tickles
.connections
)) {
3889 DEBUG(DEBUG_ERR
,("Bad indata in ctdb_control_set_tcp_tickle_list. Not enough data for the tickle.num field\n"));
3893 /* verify that the size of data matches what we expect */
3894 if (indata
.dsize
< offsetof(struct ctdb_control_tcp_tickle_list
,
3895 tickles
.connections
)
3896 + sizeof(struct ctdb_tcp_connection
)
3897 * list
->tickles
.num
) {
3898 DEBUG(DEBUG_ERR
,("Bad indata in ctdb_control_set_tcp_tickle_list\n"));
3902 vnn
= find_public_ip_vnn(ctdb
, &list
->addr
);
3904 DEBUG(DEBUG_INFO
,(__location__
" Could not set tcp tickle list, '%s' is not a public address\n",
3905 ctdb_addr_to_str(&list
->addr
)));
3910 /* remove any old ticklelist we might have */
3911 talloc_free(vnn
->tcp_array
);
3912 vnn
->tcp_array
= NULL
;
3914 tcparray
= talloc(vnn
, struct ctdb_tcp_array
);
3915 CTDB_NO_MEMORY(ctdb
, tcparray
);
3917 tcparray
->num
= list
->tickles
.num
;
3919 tcparray
->connections
= talloc_array(tcparray
, struct ctdb_tcp_connection
, tcparray
->num
);
3920 CTDB_NO_MEMORY(ctdb
, tcparray
->connections
);
3922 memcpy(tcparray
->connections
, &list
->tickles
.connections
[0],
3923 sizeof(struct ctdb_tcp_connection
)*tcparray
->num
);
3925 /* We now have a new fresh tickle list array for this vnn */
3926 vnn
->tcp_array
= tcparray
;
3932 called to return the full list of tickles for the puclic address associated
3933 with the provided vnn
3935 int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context
*ctdb
, TDB_DATA indata
, TDB_DATA
*outdata
)
3937 ctdb_sock_addr
*addr
= (ctdb_sock_addr
*)indata
.dptr
;
3938 struct ctdb_control_tcp_tickle_list
*list
;
3939 struct ctdb_tcp_array
*tcparray
;
3941 struct ctdb_vnn
*vnn
;
3943 vnn
= find_public_ip_vnn(ctdb
, addr
);
3945 DEBUG(DEBUG_ERR
,(__location__
" Could not get tcp tickle list, '%s' is not a public address\n",
3946 ctdb_addr_to_str(addr
)));
3951 tcparray
= vnn
->tcp_array
;
3953 num
= tcparray
->num
;
3958 outdata
->dsize
= offsetof(struct ctdb_control_tcp_tickle_list
,
3959 tickles
.connections
)
3960 + sizeof(struct ctdb_tcp_connection
) * num
;
3962 outdata
->dptr
= talloc_size(outdata
, outdata
->dsize
);
3963 CTDB_NO_MEMORY(ctdb
, outdata
->dptr
);
3964 list
= (struct ctdb_control_tcp_tickle_list
*)outdata
->dptr
;
3967 list
->tickles
.num
= num
;
3969 memcpy(&list
->tickles
.connections
[0], tcparray
->connections
,
3970 sizeof(struct ctdb_tcp_connection
) * num
);
3978 set the list of all tcp tickles for a public address
3980 static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context
*ctdb
,
3981 ctdb_sock_addr
*addr
,
3982 struct ctdb_tcp_array
*tcparray
)
3986 struct ctdb_control_tcp_tickle_list
*list
;
3989 num
= tcparray
->num
;
3994 data
.dsize
= offsetof(struct ctdb_control_tcp_tickle_list
,
3995 tickles
.connections
) +
3996 sizeof(struct ctdb_tcp_connection
) * num
;
3997 data
.dptr
= talloc_size(ctdb
, data
.dsize
);
3998 CTDB_NO_MEMORY(ctdb
, data
.dptr
);
4000 list
= (struct ctdb_control_tcp_tickle_list
*)data
.dptr
;
4002 list
->tickles
.num
= num
;
4004 memcpy(&list
->tickles
.connections
[0], tcparray
->connections
, sizeof(struct ctdb_tcp_connection
) * num
);
4007 ret
= ctdb_daemon_send_control(ctdb
, CTDB_BROADCAST_ALL
, 0,
4008 CTDB_CONTROL_SET_TCP_TICKLE_LIST
,
4009 0, CTDB_CTRL_FLAG_NOREPLY
, data
, NULL
, NULL
);
4011 DEBUG(DEBUG_ERR
,(__location__
" ctdb_control for set tcp tickles failed\n"));
4015 talloc_free(data
.dptr
);
4022 perform tickle updates if required
4024 static void ctdb_update_tcp_tickles(struct event_context
*ev
,
4025 struct timed_event
*te
,
4026 struct timeval t
, void *private_data
)
4028 struct ctdb_context
*ctdb
= talloc_get_type(private_data
, struct ctdb_context
);
4030 struct ctdb_vnn
*vnn
;
4032 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
4033 /* we only send out updates for public addresses that
4036 if (ctdb
->pnn
!= vnn
->pnn
) {
4039 /* We only send out the updates if we need to */
4040 if (!vnn
->tcp_update_needed
) {
4043 ret
= ctdb_send_set_tcp_tickles_for_ip(ctdb
,
4044 &vnn
->public_address
,
4047 DEBUG(DEBUG_ERR
,("Failed to send the tickle update for public address %s\n",
4048 ctdb_addr_to_str(&vnn
->public_address
)));
4050 vnn
->tcp_update_needed
= false;
4054 event_add_timed(ctdb
->ev
, ctdb
->tickle_update_context
,
4055 timeval_current_ofs(ctdb
->tunable
.tickle_update_interval
, 0),
4056 ctdb_update_tcp_tickles
, ctdb
);
4061 start periodic update of tcp tickles
4063 void ctdb_start_tcp_tickle_update(struct ctdb_context
*ctdb
)
4065 ctdb
->tickle_update_context
= talloc_new(ctdb
);
4067 event_add_timed(ctdb
->ev
, ctdb
->tickle_update_context
,
4068 timeval_current_ofs(ctdb
->tunable
.tickle_update_interval
, 0),
4069 ctdb_update_tcp_tickles
, ctdb
);
4075 struct control_gratious_arp
{
4076 struct ctdb_context
*ctdb
;
4077 ctdb_sock_addr addr
;
4083 send a control_gratuitous arp
4085 static void send_gratious_arp(struct event_context
*ev
, struct timed_event
*te
,
4086 struct timeval t
, void *private_data
)
4089 struct control_gratious_arp
*arp
= talloc_get_type(private_data
,
4090 struct control_gratious_arp
);
4092 ret
= ctdb_sys_send_arp(&arp
->addr
, arp
->iface
);
4094 DEBUG(DEBUG_ERR
,(__location__
" sending of gratious arp on iface '%s' failed (%s)\n",
4095 arp
->iface
, strerror(errno
)));
4100 if (arp
->count
== CTDB_ARP_REPEAT
) {
4105 event_add_timed(arp
->ctdb
->ev
, arp
,
4106 timeval_current_ofs(CTDB_ARP_INTERVAL
, 0),
4107 send_gratious_arp
, arp
);
4114 int32_t ctdb_control_send_gratious_arp(struct ctdb_context
*ctdb
, TDB_DATA indata
)
4116 struct ctdb_control_gratious_arp
*gratious_arp
= (struct ctdb_control_gratious_arp
*)indata
.dptr
;
4117 struct control_gratious_arp
*arp
;
4119 /* verify the size of indata */
4120 if (indata
.dsize
< offsetof(struct ctdb_control_gratious_arp
, iface
)) {
4121 DEBUG(DEBUG_ERR
,(__location__
" Too small indata to hold a ctdb_control_gratious_arp structure. Got %u require %u bytes\n",
4122 (unsigned)indata
.dsize
,
4123 (unsigned)offsetof(struct ctdb_control_gratious_arp
, iface
)));
4127 ( offsetof(struct ctdb_control_gratious_arp
, iface
)
4128 + gratious_arp
->len
) ){
4130 DEBUG(DEBUG_ERR
,(__location__
" Wrong size of indata. Was %u bytes "
4131 "but should be %u bytes\n",
4132 (unsigned)indata
.dsize
,
4133 (unsigned)(offsetof(struct ctdb_control_gratious_arp
, iface
)+gratious_arp
->len
)));
4138 arp
= talloc(ctdb
, struct control_gratious_arp
);
4139 CTDB_NO_MEMORY(ctdb
, arp
);
4142 arp
->addr
= gratious_arp
->addr
;
4143 arp
->iface
= talloc_strdup(arp
, gratious_arp
->iface
);
4144 CTDB_NO_MEMORY(ctdb
, arp
->iface
);
4147 event_add_timed(arp
->ctdb
->ev
, arp
,
4148 timeval_zero(), send_gratious_arp
, arp
);
4153 int32_t ctdb_control_add_public_address(struct ctdb_context
*ctdb
, TDB_DATA indata
)
4155 struct ctdb_control_ip_iface
*pub
= (struct ctdb_control_ip_iface
*)indata
.dptr
;
4158 /* verify the size of indata */
4159 if (indata
.dsize
< offsetof(struct ctdb_control_ip_iface
, iface
)) {
4160 DEBUG(DEBUG_ERR
,(__location__
" Too small indata to hold a ctdb_control_ip_iface structure\n"));
4164 ( offsetof(struct ctdb_control_ip_iface
, iface
)
4167 DEBUG(DEBUG_ERR
,(__location__
" Wrong size of indata. Was %u bytes "
4168 "but should be %u bytes\n",
4169 (unsigned)indata
.dsize
,
4170 (unsigned)(offsetof(struct ctdb_control_ip_iface
, iface
)+pub
->len
)));
4174 DEBUG(DEBUG_NOTICE
,("Add IP %s\n", ctdb_addr_to_str(&pub
->addr
)));
4176 ret
= ctdb_add_public_address(ctdb
, &pub
->addr
, pub
->mask
, &pub
->iface
[0], true);
4179 DEBUG(DEBUG_ERR
,(__location__
" Failed to add public address\n"));
4186 struct delete_ip_callback_state
{
4187 struct ctdb_req_control
*c
;
4191 called when releaseip event finishes for del_public_address
4193 static void delete_ip_callback(struct ctdb_context
*ctdb
,
4194 int32_t status
, TDB_DATA data
,
4195 const char *errormsg
,
4198 struct delete_ip_callback_state
*state
=
4199 talloc_get_type(private_data
, struct delete_ip_callback_state
);
4201 /* If release failed then fail. */
4202 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, status
, errormsg
);
4203 talloc_free(private_data
);
4206 int32_t ctdb_control_del_public_address(struct ctdb_context
*ctdb
,
4207 struct ctdb_req_control
*c
,
4208 TDB_DATA indata
, bool *async_reply
)
4210 struct ctdb_control_ip_iface
*pub
= (struct ctdb_control_ip_iface
*)indata
.dptr
;
4211 struct ctdb_vnn
*vnn
;
4213 /* verify the size of indata */
4214 if (indata
.dsize
< offsetof(struct ctdb_control_ip_iface
, iface
)) {
4215 DEBUG(DEBUG_ERR
,(__location__
" Too small indata to hold a ctdb_control_ip_iface structure\n"));
4219 ( offsetof(struct ctdb_control_ip_iface
, iface
)
4222 DEBUG(DEBUG_ERR
,(__location__
" Wrong size of indata. Was %u bytes "
4223 "but should be %u bytes\n",
4224 (unsigned)indata
.dsize
,
4225 (unsigned)(offsetof(struct ctdb_control_ip_iface
, iface
)+pub
->len
)));
4229 DEBUG(DEBUG_NOTICE
,("Delete IP %s\n", ctdb_addr_to_str(&pub
->addr
)));
4231 /* walk over all public addresses until we find a match */
4232 for (vnn
=ctdb
->vnn
;vnn
;vnn
=vnn
->next
) {
4233 if (ctdb_same_ip(&vnn
->public_address
, &pub
->addr
)) {
4234 if (vnn
->pnn
== ctdb
->pnn
) {
4235 struct delete_ip_callback_state
*state
;
4236 struct ctdb_public_ip
*ip
;
4240 vnn
->delete_pending
= true;
4242 state
= talloc(ctdb
,
4243 struct delete_ip_callback_state
);
4244 CTDB_NO_MEMORY(ctdb
, state
);
4247 ip
= talloc(state
, struct ctdb_public_ip
);
4250 (__location__
" Out of memory\n"));
4255 ip
->addr
= pub
->addr
;
4257 data
.dsize
= sizeof(struct ctdb_public_ip
);
4258 data
.dptr
= (unsigned char *)ip
;
4260 ret
= ctdb_daemon_send_control(ctdb
,
4263 CTDB_CONTROL_RELEASE_IP
,
4270 (__location__
"Unable to send "
4271 "CTDB_CONTROL_RELEASE_IP\n"));
4276 state
->c
= talloc_steal(state
, c
);
4277 *async_reply
= true;
4279 /* This IP is not hosted on the
4280 * current node so just delete it
4282 do_delete_ip(ctdb
, vnn
);
4289 DEBUG(DEBUG_ERR
,("Delete IP of unknown public IP address %s\n",
4290 ctdb_addr_to_str(&pub
->addr
)));
4295 struct ipreallocated_callback_state
{
4296 struct ctdb_req_control
*c
;
4299 static void ctdb_ipreallocated_callback(struct ctdb_context
*ctdb
,
4300 int status
, void *p
)
4302 struct ipreallocated_callback_state
*state
=
4303 talloc_get_type(p
, struct ipreallocated_callback_state
);
4307 (" \"ipreallocated\" event script failed (status %d)\n",
4309 if (status
== -ETIME
) {
4310 ctdb_ban_self(ctdb
);
4314 ctdb_request_control_reply(ctdb
, state
->c
, NULL
, status
, NULL
);
4318 /* A control to run the ipreallocated event */
4319 int32_t ctdb_control_ipreallocated(struct ctdb_context
*ctdb
,
4320 struct ctdb_req_control
*c
,
4324 struct ipreallocated_callback_state
*state
;
4326 state
= talloc(ctdb
, struct ipreallocated_callback_state
);
4327 CTDB_NO_MEMORY(ctdb
, state
);
4329 DEBUG(DEBUG_INFO
,(__location__
" Running \"ipreallocated\" event\n"));
4331 ret
= ctdb_event_script_callback(ctdb
, state
,
4332 ctdb_ipreallocated_callback
, state
,
4333 CTDB_EVENT_IPREALLOCATED
,
4337 DEBUG(DEBUG_ERR
,("Failed to run \"ipreallocated\" event \n"));
4342 /* tell the control that we will be reply asynchronously */
4343 state
->c
= talloc_steal(state
, c
);
4344 *async_reply
= true;
4350 /* This function is called from the recovery daemon to verify that a remote
4351 node has the expected ip allocation.
4352 This is verified against ctdb->ip_tree
4354 int verify_remote_ip_allocation(struct ctdb_context
*ctdb
,
4355 struct ctdb_all_public_ips
*ips
,
4358 struct ctdb_public_ip_list
*tmp_ip
;
4361 if (ctdb
->ip_tree
== NULL
) {
4362 /* dont know the expected allocation yet, assume remote node
4371 for (i
=0; i
<ips
->num
; i
++) {
4372 tmp_ip
= trbt_lookuparray32(ctdb
->ip_tree
, IP_KEYLEN
, ip_key(&ips
->ips
[i
].addr
));
4373 if (tmp_ip
== NULL
) {
4374 DEBUG(DEBUG_ERR
,("Node %u has new or unknown public IP %s\n", pnn
, ctdb_addr_to_str(&ips
->ips
[i
].addr
)));
4378 if (tmp_ip
->pnn
== -1 || ips
->ips
[i
].pnn
== -1) {
4382 if (tmp_ip
->pnn
!= ips
->ips
[i
].pnn
) {
4384 ("Inconsistent IP allocation - node %u thinks %s is held by node %u while it is assigned to node %u\n",
4386 ctdb_addr_to_str(&ips
->ips
[i
].addr
),
4387 ips
->ips
[i
].pnn
, tmp_ip
->pnn
));
4395 int update_ip_assignment_tree(struct ctdb_context
*ctdb
, struct ctdb_public_ip
*ip
)
4397 struct ctdb_public_ip_list
*tmp_ip
;
4399 if (ctdb
->ip_tree
== NULL
) {
4400 DEBUG(DEBUG_ERR
,("No ctdb->ip_tree yet. Failed to update ip assignment\n"));
4404 tmp_ip
= trbt_lookuparray32(ctdb
->ip_tree
, IP_KEYLEN
, ip_key(&ip
->addr
));
4405 if (tmp_ip
== NULL
) {
4406 DEBUG(DEBUG_ERR
,(__location__
" Could not find record for address %s, update ip\n", ctdb_addr_to_str(&ip
->addr
)));
4410 DEBUG(DEBUG_NOTICE
,("Updated ip assignment tree for ip : %s from node %u to node %u\n", ctdb_addr_to_str(&ip
->addr
), tmp_ip
->pnn
, ip
->pnn
));
4411 tmp_ip
->pnn
= ip
->pnn
;
4417 struct ctdb_reloadips_handle
{
4418 struct ctdb_context
*ctdb
;
4419 struct ctdb_req_control
*c
;
4423 struct fd_event
*fde
;
4426 static int ctdb_reloadips_destructor(struct ctdb_reloadips_handle
*h
)
4428 if (h
== h
->ctdb
->reload_ips
) {
4429 h
->ctdb
->reload_ips
= NULL
;
4432 ctdb_request_control_reply(h
->ctdb
, h
->c
, NULL
, h
->status
, NULL
);
4435 ctdb_kill(h
->ctdb
, h
->child
, SIGKILL
);
4439 static void ctdb_reloadips_timeout_event(struct event_context
*ev
,
4440 struct timed_event
*te
,
4441 struct timeval t
, void *private_data
)
4443 struct ctdb_reloadips_handle
*h
= talloc_get_type(private_data
, struct ctdb_reloadips_handle
);
4448 static void ctdb_reloadips_child_handler(struct event_context
*ev
, struct fd_event
*fde
,
4449 uint16_t flags
, void *private_data
)
4451 struct ctdb_reloadips_handle
*h
= talloc_get_type(private_data
, struct ctdb_reloadips_handle
);
4456 ret
= read(h
->fd
[0], &res
, 1);
4457 if (ret
< 1 || res
!= 0) {
4458 DEBUG(DEBUG_ERR
, (__location__
" Reloadips child process returned error\n"));
4466 static int ctdb_reloadips_child(struct ctdb_context
*ctdb
)
4468 TALLOC_CTX
*mem_ctx
= talloc_new(NULL
);
4469 struct ctdb_all_public_ips
*ips
;
4470 struct ctdb_vnn
*vnn
;
4471 struct client_async_data
*async_data
;
4472 struct timeval timeout
;
4474 struct ctdb_client_control_state
*state
;
4478 CTDB_NO_MEMORY(ctdb
, mem_ctx
);
4480 /* Read IPs from local node */
4481 ret
= ctdb_ctrl_get_public_ips(ctdb
, TAKEOVER_TIMEOUT(),
4482 CTDB_CURRENT_NODE
, mem_ctx
, &ips
);
4485 ("Unable to fetch public IPs from local node\n"));
4486 talloc_free(mem_ctx
);
4490 /* Read IPs file - this is safe since this is a child process */
4492 if (ctdb_set_public_addresses(ctdb
, false) != 0) {
4493 DEBUG(DEBUG_ERR
,("Failed to re-read public addresses file\n"));
4494 talloc_free(mem_ctx
);
4498 async_data
= talloc_zero(mem_ctx
, struct client_async_data
);
4499 CTDB_NO_MEMORY(ctdb
, async_data
);
4501 /* Compare IPs between node and file for IPs to be deleted */
4502 for (i
= 0; i
< ips
->num
; i
++) {
4504 for (vnn
= ctdb
->vnn
; vnn
; vnn
= vnn
->next
) {
4505 if (ctdb_same_ip(&vnn
->public_address
,
4506 &ips
->ips
[i
].addr
)) {
4507 /* IP is still in file */
4513 /* Delete IP ips->ips[i] */
4514 struct ctdb_control_ip_iface
*pub
;
4517 ("IP %s no longer configured, deleting it\n",
4518 ctdb_addr_to_str(&ips
->ips
[i
].addr
)));
4520 pub
= talloc_zero(mem_ctx
,
4521 struct ctdb_control_ip_iface
);
4522 CTDB_NO_MEMORY(ctdb
, pub
);
4524 pub
->addr
= ips
->ips
[i
].addr
;
4528 timeout
= TAKEOVER_TIMEOUT();
4530 data
.dsize
= offsetof(struct ctdb_control_ip_iface
,
4532 data
.dptr
= (uint8_t *)pub
;
4534 state
= ctdb_control_send(ctdb
, CTDB_CURRENT_NODE
, 0,
4535 CTDB_CONTROL_DEL_PUBLIC_IP
,
4536 0, data
, async_data
,
4538 if (state
== NULL
) {
4541 " failed sending CTDB_CONTROL_DEL_PUBLIC_IP\n"));
4545 ctdb_client_async_add(async_data
, state
);
4549 /* Compare IPs between node and file for IPs to be added */
4551 for (vnn
= ctdb
->vnn
; vnn
; vnn
= vnn
->next
) {
4552 for (i
= 0; i
< ips
->num
; i
++) {
4553 if (ctdb_same_ip(&vnn
->public_address
,
4554 &ips
->ips
[i
].addr
)) {
4555 /* IP already on node */
4559 if (i
== ips
->num
) {
4560 /* Add IP ips->ips[i] */
4561 struct ctdb_control_ip_iface
*pub
;
4562 const char *ifaces
= NULL
;
4567 ("New IP %s configured, adding it\n",
4568 ctdb_addr_to_str(&vnn
->public_address
)));
4570 uint32_t pnn
= ctdb_get_pnn(ctdb
);
4572 data
.dsize
= sizeof(pnn
);
4573 data
.dptr
= (uint8_t *)&pnn
;
4575 ret
= ctdb_client_send_message(
4577 CTDB_BROADCAST_CONNECTED
,
4578 CTDB_SRVID_REBALANCE_NODE
,
4581 DEBUG(DEBUG_WARNING
,
4582 ("Failed to send message to force node reallocation - IPs may be unbalanced\n"));
4588 ifaces
= vnn
->ifaces
[0];
4590 while (vnn
->ifaces
[iface
] != NULL
) {
4591 ifaces
= talloc_asprintf(vnn
, "%s,%s", ifaces
,
4592 vnn
->ifaces
[iface
]);
4596 len
= strlen(ifaces
) + 1;
4597 pub
= talloc_zero_size(mem_ctx
,
4598 offsetof(struct ctdb_control_ip_iface
, iface
) + len
);
4599 CTDB_NO_MEMORY(ctdb
, pub
);
4601 pub
->addr
= vnn
->public_address
;
4602 pub
->mask
= vnn
->public_netmask_bits
;
4604 memcpy(&pub
->iface
[0], ifaces
, pub
->len
);
4606 timeout
= TAKEOVER_TIMEOUT();
4608 data
.dsize
= offsetof(struct ctdb_control_ip_iface
,
4610 data
.dptr
= (uint8_t *)pub
;
4612 state
= ctdb_control_send(ctdb
, CTDB_CURRENT_NODE
, 0,
4613 CTDB_CONTROL_ADD_PUBLIC_IP
,
4614 0, data
, async_data
,
4616 if (state
== NULL
) {
4619 " failed sending CTDB_CONTROL_ADD_PUBLIC_IP\n"));
4623 ctdb_client_async_add(async_data
, state
);
4627 if (ctdb_client_async_wait(ctdb
, async_data
) != 0) {
4628 DEBUG(DEBUG_ERR
,(__location__
" Add/delete IPs failed\n"));
4632 talloc_free(mem_ctx
);
4636 talloc_free(mem_ctx
);
4640 /* This control is sent to force the node to re-read the public addresses file
4641 and drop any addresses we should nnot longer host, and add new addresses
4642 that we are now able to host
4644 int32_t ctdb_control_reload_public_ips(struct ctdb_context
*ctdb
, struct ctdb_req_control
*c
, bool *async_reply
)
4646 struct ctdb_reloadips_handle
*h
;
4647 pid_t parent
= getpid();
4649 if (ctdb
->reload_ips
!= NULL
) {
4650 talloc_free(ctdb
->reload_ips
);
4651 ctdb
->reload_ips
= NULL
;
4654 h
= talloc(ctdb
, struct ctdb_reloadips_handle
);
4655 CTDB_NO_MEMORY(ctdb
, h
);
4660 if (pipe(h
->fd
) == -1) {
4661 DEBUG(DEBUG_ERR
,("Failed to create pipe for ctdb_freeze_lock\n"));
4666 h
->child
= ctdb_fork(ctdb
);
4667 if (h
->child
== (pid_t
)-1) {
4668 DEBUG(DEBUG_ERR
, ("Failed to fork a child for reloadips\n"));
4676 if (h
->child
== 0) {
4677 signed char res
= 0;
4680 debug_extra
= talloc_asprintf(NULL
, "reloadips:");
4682 ctdb_set_process_name("ctdb_reloadips");
4683 if (switch_from_server_to_client(ctdb
, "reloadips-child") != 0) {
4684 DEBUG(DEBUG_CRIT
,("ERROR: Failed to switch reloadips child into client mode\n"));
4687 res
= ctdb_reloadips_child(ctdb
);
4689 DEBUG(DEBUG_ERR
,("Failed to reload ips on local node\n"));
4693 write(h
->fd
[1], &res
, 1);
4694 /* make sure we die when our parent dies */
4695 while (ctdb_kill(ctdb
, parent
, 0) == 0 || errno
!= ESRCH
) {
4701 h
->c
= talloc_steal(h
, c
);
4704 set_close_on_exec(h
->fd
[0]);
4706 talloc_set_destructor(h
, ctdb_reloadips_destructor
);
4709 h
->fde
= event_add_fd(ctdb
->ev
, h
, h
->fd
[0],
4710 EVENT_FD_READ
, ctdb_reloadips_child_handler
,
4712 tevent_fd_set_auto_close(h
->fde
);
4714 event_add_timed(ctdb
->ev
, h
,
4715 timeval_current_ofs(120, 0),
4716 ctdb_reloadips_timeout_event
, h
);
4718 /* we reply later */
4719 *async_reply
= true;