[SCM] Samba Shared Repository - branch master updated
Anoop C S
anoopcs at samba.org
Mon Oct 7 17:13:02 UTC 2024
The branch, master has been updated
via d1cb6dca721 ctdb-tcp: Modernise a DEBUG
via 939e5bdfd20 ctdb-tcp: Only attempt to automatically bind to local IPs
via 5af2f09a1f3 ctdb-server: Optimise local IP verification
via 0536d7a98b8 ctdb-common: Reimplement ctdb_sys_have_ip() using new infrastructure
via a489b6699d4 ctdb-common: Make the argument to ctdb_sys_have_ip() const
via a15167aafe8 ctdb-server: Add some local variables
via 33e28deeef9 ctdb-tests: Add test code for ctdb_sys_have_ip()
via cc99d0047d7 ctdb-common: Add functions for local IP address checking
via aab763d659d ctdb-protocol: Add function ctdb_sock_addr_from_sockaddr()
from 3c6ca81aad1 vfs_glusterfs: Retrieve fs capabilities using vfs_get_fs_capabilities
https://git.samba.org/?p=samba.git;a=shortlog;h=master
- Log -----------------------------------------------------------------
commit d1cb6dca721e0082b2b31b4f9be13a02c46235ac
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Thu Oct 3 15:13:30 2024 +1000
ctdb-tcp: Modernise a DEBUG
This is last old-style one in this file.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
Autobuild-User(master): Anoop C S <anoopcs at samba.org>
Autobuild-Date(master): Mon Oct 7 17:12:18 UTC 2024 on atb-devel-224
commit 939e5bdfd20b4029cc90d7d378319b26ed454dcc
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Thu Oct 3 15:07:40 2024 +1000
ctdb-tcp: Only attempt to automatically bind to local IPs
Automatic node address selection in the TCP transport does not work if
net.ipv4.ip_nonlocal_bind=1 because all nodes will be able to bind()
to the first address in the nodes list.
Before getting to the bind() step, add a check to see if an address is
local (i.e. on an interface). If not, it is not considered.
This is defensively coded so that this step is skipped if local
addresses can not be retrieved.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
commit 5af2f09a1f30e7ed5a741d8eeee122d44241ddfc
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Sun Sep 29 14:10:22 2024 +1000
ctdb-server: Optimise local IP verification
It is more efficient calling ctdb_sys_local_ip_check() inside a loop
compared to calling ctdb_sys_have_ip(). There is a chance that this
is premature optimisation... but it sure is easy. Fall back to
checking with bind().
I think these checks really exist because of the weirdness fixed by
commit 4b4e4d8870475d994fe42a7b2c57dc69842d91f6. However, we might as
well do what we can.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
commit 0536d7a98b832fc00d26b09c26bf14fb63dbf5fb
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Sun Sep 29 12:05:31 2024 +1000
ctdb-common: Reimplement ctdb_sys_have_ip() using new infrastructure
It can now be used when net.ipv4.ip_nonlocal_bind=1.
This makes the recovery daemon's local IP verification inefficient.
It can be optimised in a subsequent commit.
Fall back to bind() if unable to fetch IPs.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
commit a489b6699d4f4a49bc431bba6daaf50bd66b56ff
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Fri Oct 4 22:08:46 2024 +1000
ctdb-common: Make the argument to ctdb_sys_have_ip() const
Arguably, this would have made sense back in commit
bf86562144fe4e9541bd993519aca958c2bdb794.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
commit a15167aafe83127efd33d5e5875ffb87746e986a
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Sun Sep 29 14:06:51 2024 +1000
ctdb-server: Add some local variables
Improve readability by not repeating the complex expression now
assigned to addr. ctdb_sys_have_ip() is called in both arms of the
if/else, so call it once when declaring the new variable.
Modernise debug macros while touching lines.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
commit 33e28deeef9cf991637a09a2c9474c88244e578b
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Sun Sep 29 12:04:20 2024 +1000
ctdb-tests: Add test code for ctdb_sys_have_ip()
Do not add any automated test cases because they will always be racy.
This allows manual testing of the function.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
commit cc99d0047d7b39c5af1c7540d3682e8484527a3b
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Sun Sep 29 11:57:58 2024 +1000
ctdb-common: Add functions for local IP address checking
This is a wrapper around getifaddrs(2), which is in libreplace, so
should always be available.
Some users want to set net.ipv4.ip_nonlocal_bind = 1. So, CTDB needs
a way of testing if public IPs are present, without using bind(2).
Doing all of this unconditionally in ctdb_sys_have_ip() will be
inefficient in the recovery daemon's local IP verification if there
are a lot of IP addresses. Split it this way so the interface
information can be retrieved once and used multiple times.
This doesn't appear to need IP canonicalisation for IPv4-mapped IPv6
addresses.
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
commit aab763d659deaaaaa3edcb0245dd1a82fb1f3e00
Author: Martin Schwenke <mschwenke at ddn.com>
Date: Sun Sep 29 11:55:52 2024 +1000
ctdb-protocol: Add function ctdb_sock_addr_from_sockaddr()
Signed-off-by: Martin Schwenke <mschwenke at ddn.com>
Reviewed-by: John Mulligan <jmulligan at redhat.com>
Reviewed-by: Anoop C S <anoopcs at samba.org>
-----------------------------------------------------------------------
Summary of changes:
ctdb/common/system_socket.c | 103 ++++++++++++++++++++++++++++++++++--
ctdb/common/system_socket.h | 11 +++-
ctdb/doc/ctdb.conf.5.xml | 8 +--
ctdb/protocol/protocol_util.c | 19 +++++++
ctdb/protocol/protocol_util.h | 2 +
ctdb/server/ctdb_recoverd.c | 41 +++++++++++---
ctdb/tcp/tcp_connect.c | 34 +++++++++++-
ctdb/tests/src/system_socket_test.c | 23 ++++++++
ctdb/wscript | 18 ++++++-
9 files changed, 240 insertions(+), 19 deletions(-)
Changeset truncated at 500 lines:
diff --git a/ctdb/common/system_socket.c b/ctdb/common/system_socket.c
index 273b9c3400e..b4275b1fc64 100644
--- a/ctdb/common/system_socket.c
+++ b/ctdb/common/system_socket.c
@@ -56,10 +56,13 @@
#define ETHERTYPE_IP6 0x86dd
#endif
+#include <talloc.h>
+
#include "lib/util/debug.h"
#include "lib/util/blocking.h"
#include "protocol/protocol.h"
+#include "protocol/protocol_util.h"
#include "common/logging.h"
#include "common/system_socket.h"
@@ -84,10 +87,80 @@ static uint32_t uint16_checksum(uint8_t *data, size_t n)
return sum;
}
-/*
- * See if the given IP is currently on an interface
- */
-bool ctdb_sys_have_ip(ctdb_sock_addr *_addr)
+struct ctdb_sys_local_ips_context {
+ struct ifaddrs *ifa;
+};
+
+static int ctdb_sys_local_ips_destructor(
+ struct ctdb_sys_local_ips_context *ips_ctx)
+{
+ freeifaddrs(ips_ctx->ifa);
+ ips_ctx->ifa = NULL;
+
+ return 0;
+}
+
+int ctdb_sys_local_ips_init(TALLOC_CTX *ctx,
+ struct ctdb_sys_local_ips_context **ips_ctx)
+{
+ struct ctdb_sys_local_ips_context *t = NULL;
+ int ret = 0;
+
+ t = talloc(ctx, struct ctdb_sys_local_ips_context);
+ if (t == NULL) {
+ return ENOMEM;
+ }
+
+ ret = getifaddrs(&t->ifa);
+ if (ret != 0) {
+ ret = errno;
+ talloc_free(t);
+ return ret;
+ }
+
+ talloc_set_destructor(t, ctdb_sys_local_ips_destructor);
+ *ips_ctx = t;
+
+ return ret;
+}
+
+bool ctdb_sys_local_ip_check(const struct ctdb_sys_local_ips_context *ips_ctx,
+ const ctdb_sock_addr *addr)
+{
+ struct ifaddrs *ifa = NULL;
+ int ret;
+
+ for (ifa = ips_ctx->ifa; ifa != NULL; ifa = ifa->ifa_next) {
+ ctdb_sock_addr sock_addr;
+ bool match;
+
+ if (ifa->ifa_addr == NULL)
+ continue;
+
+ /* Ignore non-IPv4/IPv6 interfaces */
+ switch (ifa->ifa_addr->sa_family) {
+ case AF_INET:
+ case AF_INET6:
+ break;
+ default:
+ continue;
+ }
+
+ ret = ctdb_sock_addr_from_sockaddr(ifa->ifa_addr, &sock_addr);
+ if (ret != 0) {
+ return false;
+ }
+
+ match = ctdb_sock_addr_same_ip(&sock_addr, addr);
+ if (match) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool ctdb_sys_bind_ip_check(const ctdb_sock_addr *_addr)
{
int s;
int ret;
@@ -117,6 +190,28 @@ bool ctdb_sys_have_ip(ctdb_sock_addr *_addr)
return ret == 0;
}
+/*
+ * See if the given IP is currently on an interface
+ */
+bool ctdb_sys_have_ip(const ctdb_sock_addr *addr)
+{
+ struct ctdb_sys_local_ips_context *ips_ctx = NULL;
+ bool have_ip;
+ int ret;
+
+ ret = ctdb_sys_local_ips_init(NULL, &ips_ctx);
+ if (ret != 0) {
+ DBG_DEBUG("Failed to get local addresses, depending on bind\n");
+ have_ip = ctdb_sys_bind_ip_check(addr);
+ return have_ip;
+ }
+
+ have_ip = ctdb_sys_local_ip_check(ips_ctx, addr);
+ talloc_free(ips_ctx);
+
+ return have_ip;
+}
+
/*
* simple TCP checksum - assumes data is multiple of 2 bytes long
*/
diff --git a/ctdb/common/system_socket.h b/ctdb/common/system_socket.h
index 065c53cb2a8..f4d092cce0a 100644
--- a/ctdb/common/system_socket.h
+++ b/ctdb/common/system_socket.h
@@ -20,9 +20,18 @@
#ifndef __CTDB_SYSTEM_SOCKET_H__
#define __CTDB_SYSTEM_SOCKET_H__
+#include <talloc.h>
+
#include "protocol/protocol.h"
-bool ctdb_sys_have_ip(ctdb_sock_addr *addr);
+struct ctdb_sys_local_ips_context;
+
+int ctdb_sys_local_ips_init(TALLOC_CTX *ctx,
+ struct ctdb_sys_local_ips_context **ips_ctx);
+bool ctdb_sys_local_ip_check(const struct ctdb_sys_local_ips_context *ips_ctx,
+ const ctdb_sock_addr *addr);
+bool ctdb_sys_bind_ip_check(const ctdb_sock_addr *addr);
+bool ctdb_sys_have_ip(const ctdb_sock_addr *addr);
int ctdb_sys_send_arp(const ctdb_sock_addr *addr, const char *iface);
diff --git a/ctdb/doc/ctdb.conf.5.xml b/ctdb/doc/ctdb.conf.5.xml
index 615a61e5bfe..7bdbc038f7d 100644
--- a/ctdb/doc/ctdb.conf.5.xml
+++ b/ctdb/doc/ctdb.conf.5.xml
@@ -241,9 +241,11 @@
This option is only required when automatic address
detection can not be used. This can be the case when
running multiple ctdbd daemons/nodes on the same physical
- host (usually for testing), using InfiniBand for the
- private network or on Linux when sysctl
- net.ipv4.ip_nonlocal_bind=1.
+ host (usually for testing) or using InfiniBand for the
+ private network. Another unlikely possibility would be
+ running on a platform with a feature like Linux's
+ net.ipv4.ip_nonlocal_bind=1 enabled and no usable
+ getifaddrs(3) implementation (or replacement) available.
</para>
<para>
Default: CTDB selects the first address from the nodes
diff --git a/ctdb/protocol/protocol_util.c b/ctdb/protocol/protocol_util.c
index 5e48c1513bc..d8f12fa87ba 100644
--- a/ctdb/protocol/protocol_util.c
+++ b/ctdb/protocol/protocol_util.c
@@ -379,6 +379,25 @@ int ctdb_sock_addr_mask_from_string(const char *str,
return ret;
}
+int ctdb_sock_addr_from_sockaddr(struct sockaddr *addr,
+ ctdb_sock_addr *sock_addr)
+{
+ switch (addr->sa_family) {
+ case AF_INET:
+ ZERO_STRUCTP(sock_addr);
+ sock_addr->ip = *(struct sockaddr_in *)addr;
+ break;
+ case AF_INET6:
+ ZERO_STRUCTP(sock_addr);
+ sock_addr->ip6 = *(struct sockaddr_in6 *)addr;
+ break;
+ default:
+ return EINVAL;
+ }
+
+ return 0;
+}
+
unsigned int ctdb_sock_addr_port(ctdb_sock_addr *addr)
{
switch (addr->sa.sa_family) {
diff --git a/ctdb/protocol/protocol_util.h b/ctdb/protocol/protocol_util.h
index 70f35d122a8..31f71e18f81 100644
--- a/ctdb/protocol/protocol_util.h
+++ b/ctdb/protocol/protocol_util.h
@@ -44,6 +44,8 @@ int ctdb_sock_addr_from_string(const char *str,
int ctdb_sock_addr_mask_from_string(const char *str,
ctdb_sock_addr *addr,
unsigned int *mask);
+int ctdb_sock_addr_from_sockaddr(struct sockaddr *addr,
+ ctdb_sock_addr *sock_addr);
unsigned int ctdb_sock_addr_port(ctdb_sock_addr *addr);
void ctdb_sock_addr_set_port(ctdb_sock_addr *addr, unsigned int port);
int ctdb_sock_addr_cmp_ip(const ctdb_sock_addr *addr1,
diff --git a/ctdb/server/ctdb_recoverd.c b/ctdb/server/ctdb_recoverd.c
index 09d5df3e9cb..11644868e46 100644
--- a/ctdb/server/ctdb_recoverd.c
+++ b/ctdb/server/ctdb_recoverd.c
@@ -2285,6 +2285,7 @@ static int verify_local_ip_allocation(struct ctdb_recoverd *rec)
int ret;
bool need_takeover_run = false;
struct ctdb_public_ip_list_old *ips = NULL;
+ struct ctdb_sys_local_ips_context *ips_ctx = NULL;
/* If we are not the leader then do some housekeeping */
if (!this_node_is_leader(rec)) {
@@ -2355,24 +2356,48 @@ static int verify_local_ip_allocation(struct ctdb_recoverd *rec)
return -1;
}
+ ret = ctdb_sys_local_ips_init(mem_ctx, &ips_ctx);
+ if (ret != 0) {
+ /*
+ * What to do? The point here is to allow public
+ * addresses to be checked when
+ * net.ipv4.ip_nonlocal_bind = 1, which is probably
+ * just Linux... though other platforms may have a
+ * similar setting. For non-Linux platforms without a
+ * usable getifaddrs(3) function/replacement, fall
+ * back to bind() below...
+ */
+ DBG_DEBUG("Failed to get local addresses, depending on bind\n");
+ ips_ctx = NULL; /* Just in case */
+ }
+
for (j=0; j<ips->num; j++) {
+ ctdb_sock_addr *addr = &ips->ips[j].addr;
+ bool have_ip;
+
+ if (ips_ctx != NULL) {
+ have_ip = ctdb_sys_local_ip_check(ips_ctx, addr);
+ } else {
+ have_ip = ctdb_sys_bind_ip_check(addr);
+ }
+
if (ips->ips[j].pnn == rec->pnn) {
- if (!ctdb_sys_have_ip(&ips->ips[j].addr)) {
- DEBUG(DEBUG_ERR,
- ("Assigned IP %s not on an interface\n",
- ctdb_addr_to_str(&ips->ips[j].addr)));
+ if (!have_ip) {
+ D_ERR("Assigned IP %s not on an interface\n",
+ ctdb_addr_to_str(addr));
need_takeover_run = true;
}
} else {
- if (ctdb_sys_have_ip(&ips->ips[j].addr)) {
- DEBUG(DEBUG_ERR,
- ("IP %s incorrectly on an interface\n",
- ctdb_addr_to_str(&ips->ips[j].addr)));
+ if (have_ip) {
+ D_ERR("IP %s incorrectly on an interface\n",
+ ctdb_addr_to_str(addr));
need_takeover_run = true;
}
}
}
+ TALLOC_FREE(ips_ctx);
+
done:
if (need_takeover_run) {
struct ctdb_srvid_message rd;
diff --git a/ctdb/tcp/tcp_connect.c b/ctdb/tcp/tcp_connect.c
index 1ad3fa74d55..d69c196dbe4 100644
--- a/ctdb/tcp/tcp_connect.c
+++ b/ctdb/tcp/tcp_connect.c
@@ -32,6 +32,7 @@
#include "ctdb_private.h"
#include "common/system.h"
+#include "common/system_socket.h"
#include "common/common.h"
#include "common/logging.h"
#include "common/path.h"
@@ -490,6 +491,7 @@ static int ctdb_tcp_listen_automatic(struct ctdb_context *ctdb)
unsigned int i;
char *lock_path = NULL;
struct flock lock;
+ struct ctdb_sys_local_ips_context *ips_ctx = NULL;
int ret;
/*
@@ -498,7 +500,8 @@ static int ctdb_tcp_listen_automatic(struct ctdb_context *ctdb)
* process.
*/
if (ctdb->num_nodes == 0) {
- DEBUG(DEBUG_CRIT,("No nodes available to attempt bind to - is the nodes file empty?\n"));
+ D_ERR("No nodes available to attempt bind to - "
+ "is the nodes file empty?\n");
return -1;
}
@@ -534,11 +537,38 @@ static int ctdb_tcp_listen_automatic(struct ctdb_context *ctdb)
}
talloc_free(lock_path);
+ ret = ctdb_sys_local_ips_init(ctdb, &ips_ctx);
+ if (ret != 0) {
+ /*
+ * What to do? The point here is to allow CTDB to
+ * bind to the local IP address from the nodes list if
+ * net.ipv4.ip_nonlocal_bind = 1, which probably just
+ * Linux... though other platforms may have a similar
+ * setting. Let's go ahead and skip checking
+ * addresses this way. That way, a platform with a
+ * replacement implementation of getifaddrs() that
+ * just returns, say, ENOSYS can still proceed and see
+ * if it can bind/listen on each address.
+ */
+ DBG_WARNING(
+ "Failed to get local addresses, depending on bind\n");
+ ips_ctx = NULL; /* Just in case */
+ }
+
for (i=0; i < ctdb->num_nodes; i++) {
if (ctdb->nodes[i]->flags & NODE_FLAGS_DELETED) {
continue;
}
+ if (ips_ctx != NULL) {
+ bool have_ip = ctdb_sys_local_ip_check(
+ ips_ctx, &ctdb->nodes[i]->address);
+
+ if (!have_ip) {
+ continue;
+ }
+ }
+
ret = ctdb_tcp_listen_addr(ctdb,
&ctdb->nodes[i]->address,
false);
@@ -547,6 +577,8 @@ static int ctdb_tcp_listen_automatic(struct ctdb_context *ctdb)
}
}
+ TALLOC_FREE(ips_ctx);
+
if (i == ctdb->num_nodes) {
D_ERR("Unable to bind to any node address - giving up\n");
return -1;
diff --git a/ctdb/tests/src/system_socket_test.c b/ctdb/tests/src/system_socket_test.c
index 436f52a2df8..ff9b066ce4e 100644
--- a/ctdb/tests/src/system_socket_test.c
+++ b/ctdb/tests/src/system_socket_test.c
@@ -222,12 +222,30 @@ static void test_tcp(const char *src_str,
assert(ret == 0);
}
+static void test_haveip(const char *ipaddr_str)
+{
+ ctdb_sock_addr addr;
+ bool have_ip;
+ int ret;
+
+ ret = ctdb_sock_addr_from_string(ipaddr_str, &addr, false);
+ assert(ret == 0);
+
+ have_ip = ctdb_sys_have_ip(&addr);
+ if (have_ip) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+}
+
static void usage(const char *prog)
{
fprintf(stderr, "usage: %s <cmd> [<arg> ...]\n", prog);
fprintf(stderr, " commands:\n");
fprintf(stderr, " types\n");
fprintf(stderr, " arp <ipaddr> <hwaddr> [reply]\n");
+ fprintf(stderr, " haveip <ipaddr>\n");
fprintf(stderr, " tcp <src> <dst> <seq> <ack> <rst>\n");
exit(1);
@@ -258,6 +276,11 @@ int main(int argc, char **argv)
usage(argv[0]);
}
test_tcp(argv[2], argv[3], argv[4], argv[5], argv[6]);
+ } else if (strcmp(argv[1], "haveip") == 0) {
+ if (argc != 3) {
+ usage(argv[0]);
+ }
+ test_haveip(argv[2]);
} else {
usage(argv[0]);
}
diff --git a/ctdb/wscript b/ctdb/wscript
index e89f6548af3..74ad9af2a89 100644
--- a/ctdb/wscript
+++ b/ctdb/wscript
@@ -400,7 +400,13 @@ def build(bld):
source=bld.SUBDIR('tcp',
'tcp_connect.c tcp_init.c tcp_io.c'),
includes='include',
- deps='replace tdb talloc tevent ctdb-protocol-util')
+ deps='''ctdb-protocol-util
+ ctdb-system
+ replace
+ talloc
+ tdb
+ tevent
+ ''')
ib_deps = ''
if bld.env.HAVE_INFINIBAND:
@@ -415,7 +421,15 @@ def build(bld):
bld.SAMBA_SUBSYSTEM('ctdb-system',
source=bld.SUBDIR('common',
'system_socket.c system.c'),
- deps='replace talloc tevent tdb pcap samba-util')
+ deps='''ctdb-protocol
+ ctdb-protocol-util
+ pcap
+ replace
+ samba-util
+ talloc
+ tdb
+ tevent
+ ''')
bld.SAMBA_SUBSYSTEM('ctdb-common',
source=bld.SUBDIR('common',
--
Samba Shared Repository
More information about the samba-cvs
mailing list