v1.32 Release

Finish the release notes for the 1.32 release.

Signed-off-by: Auke Kok <auke.kok@versity.com>

ReleaseNotes.md

@@ -1,6 +1,20 @@
 Versity ScoutFS Release Notes
 =============================
 
+---
+v1.32
+\
+*June 2, 2026*
+
+Fix writing POSIX ACLs over NFS mounts that export the scoutfs
+filesystem.
+
+Add support for kernels in the RHEL 9.8 minor release.
+
+Reduce unneeded block allocation when data\_prealloc\_contig\_only was
+set to 0. This will help achieve more efficient data space usage when
+writing small files.
+
 ---
 v1.31
 \

kmod/src/Makefile.kernelcompat

@@ -479,6 +479,16 @@ ifneq (,$(shell grep '^unsigned int stack_trace_save' include/linux/stacktrace.h
 ccflags-y += -DKC_STACK_TRACE_SAVE
 endif
 
+#
+# v3.14-rc1-7-g4e34e719e457
+#
+# .set_acl callback added to struct inode_operations.  Most kernels
+# we target have it, but el7 (3.10 base) does not, so detect.
+#
+ifneq (,$(shell grep 'int ..set_acl..struct' include/linux/fs.h))
+ccflags-y += -DKC_HAS_SET_ACL
+endif
+
 #
 # v6.1-rc1-2-g138060ba92b3
 #
@@ -496,3 +506,12 @@ endif
 ifneq (,$(shell grep 'struct posix_acl.*get_inode_acl' include/linux/fs.h))
 ccflags-y += -DKC_GET_INODE_ACL
 endif
+
+#
+# v6.15-13744-g41cb08555c41
+#
+# from_timer renamed to timer_container_of.
+#
+ifneq (,$(shell grep 'define timer_container_of' include/linux/timer.h))
+ccflags-y += -DKC_TIMER_CONTAINER_OF
+endif

kmod/src/acl.c

@@ -216,7 +216,8 @@ int scoutfs_set_acl(KC_VFS_NS_DEF
 {
 	struct inode *inode = dentry->d_inode;
 #else
-int scoutfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
+int scoutfs_set_acl(KC_VFS_NS_DEF
+		    struct inode *inode, struct posix_acl *acl, int type)
 {
 #endif
 	struct super_block *sb = inode->i_sb;
@@ -309,7 +310,7 @@ int scoutfs_acl_set_xattr(struct dentry *dentry, const char *name, const void *v
 #ifdef KC_SET_ACL_DENTRY
 	ret = scoutfs_set_acl(KC_VFS_INIT_NS dentry, acl, type);
 #else
-	ret = scoutfs_set_acl(dentry->d_inode, acl, type);
+	ret = scoutfs_set_acl(KC_VFS_INIT_NS dentry->d_inode, acl, type);
 #endif
 out:
 	posix_acl_release(acl);

kmod/src/acl.h

@@ -5,7 +5,8 @@
 int scoutfs_set_acl(KC_VFS_NS_DEF
 		    struct dentry *dentry, struct posix_acl *acl, int type);
 #else
-int scoutfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
+int scoutfs_set_acl(KC_VFS_NS_DEF
+		    struct inode *inode, struct posix_acl *acl, int type);
 #endif
 #ifdef KC_GET_INODE_ACL
 struct posix_acl *scoutfs_get_acl(struct inode *inode, int type, bool rcu);

kmod/src/client.c

@@ -479,7 +479,7 @@ static void scoutfs_client_connect_worker(struct work_struct *work)
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 	struct scoutfs_mount_options opts;
 	struct scoutfs_net_greeting greet;
-	struct sockaddr_storage sin;
+	struct sockaddr_in sin;
 	bool am_quorum;
 	int ret;
 

kmod/src/data.c

@@ -422,6 +422,8 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 
 	mutex_lock(&datinf->mutex);
 
+	scoutfs_inode_get_onoff(inode, &online, &offline);
+
 	/* default to single allocation at the written block */
 	start = iblock;
 	count = 1;
@@ -444,7 +446,6 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 		 * the preallocation size to the number of online
 		 * blocks.
 		 */
-		scoutfs_inode_get_onoff(inode, &online, &offline);
 		if (iblock > 1 && iblock == online) {
 			ret = scoutfs_ext_next(sb, &data_ext_ops, &args,
 					       iblock, 1, &found);
@@ -486,6 +487,13 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 		/* trim count by next extent after iblock */
 		if (found.len && found.start > start && found.start < start + count)
 			count = (found.start - start);
+
+		/*
+		 * Ramp the aligned region size up proportionally with
+		 * the file's online block count rather than jumping to
+		 * the full prealloc size.
+		 */
+		count = max_t(u64, 1, min(count, online));
 	}
 
 	/* overall prealloc limit */

kmod/src/dir.c

@@ -2063,7 +2063,7 @@ const struct inode_operations scoutfs_dir_iops = {
 #else
 	.get_acl	= scoutfs_get_acl,
 #endif
-#ifdef KC_SET_ACL_DENTRY
+#ifdef KC_HAS_SET_ACL
 	.set_acl	= scoutfs_set_acl,
 #endif
 	.symlink	= scoutfs_symlink,

kmod/src/fence.c

@@ -25,7 +25,6 @@
 #include "sysfs.h"
 #include "server.h"
 #include "fence.h"
-#include "net.h"
 
 /*
  * Fencing ensures that a given mount can no longer write to the
@@ -80,7 +79,7 @@ struct pending_fence {
 	struct timer_list timer;
 
 	ktime_t start_kt;
-	union scoutfs_inet_addr addr;
+	__be32 ipv4_addr;
 	bool fenced;
 	bool error;
 	int reason;
@@ -172,19 +171,14 @@ static ssize_t error_store(struct kobject *kobj, struct kobj_attribute *attr, co
 }
 SCOUTFS_ATTR_RW(error);
 
-static ssize_t inet_addr_show(struct kobject *kobj,
+static ssize_t ipv4_addr_show(struct kobject *kobj,
 			      struct kobj_attribute *attr, char *buf)
 {
 	DECLARE_FENCE_FROM_KOBJ(fence, kobj);
-	struct sockaddr_storage sin;
 
-	memset(&sin, 0, sizeof(struct sockaddr_storage));
-
-	scoutfs_addr_to_sin(&sin, &fence->addr);
-
-	return snprintf(buf, PAGE_SIZE, "%pISc", SIN_ARG(&sin));
+	return snprintf(buf, PAGE_SIZE, "%pI4", &fence->ipv4_addr);
 }
-SCOUTFS_ATTR_RO(inet_addr);
+SCOUTFS_ATTR_RO(ipv4_addr);
 
 static ssize_t reason_show(struct kobject *kobj, struct kobj_attribute *attr,
 			   char *buf)
@@ -218,7 +212,7 @@ static struct attribute *fence_attrs[] = {
 	SCOUTFS_ATTR_PTR(elapsed_secs),
 	SCOUTFS_ATTR_PTR(fenced),
 	SCOUTFS_ATTR_PTR(error),
-	SCOUTFS_ATTR_PTR(inet_addr),
+	SCOUTFS_ATTR_PTR(ipv4_addr),
 	SCOUTFS_ATTR_PTR(reason),
 	SCOUTFS_ATTR_PTR(rid),
 	NULL,
@@ -228,7 +222,7 @@ static struct attribute *fence_attrs[] = {
 
 static void fence_timeout(struct timer_list *timer)
 {
-	struct pending_fence *fence = from_timer(fence, timer, timer);
+	struct pending_fence *fence = timer_container_of(fence, timer, timer);
 	struct super_block *sb = fence->sb;
 	DECLARE_FENCE_INFO(sb, fi);
 
@@ -238,7 +232,7 @@ static void fence_timeout(struct timer_list *timer)
 	wake_up(&fi->waitq);
 }
 
-int scoutfs_fence_start(struct super_block *sb, u64 rid, union scoutfs_inet_addr *addr, int reason)
+int scoutfs_fence_start(struct super_block *sb, u64 rid, __be32 ipv4_addr, int reason)
 {
 	DECLARE_FENCE_INFO(sb, fi);
 	struct pending_fence *fence;
@@ -254,7 +248,7 @@ int scoutfs_fence_start(struct super_block *sb, u64 rid, union scoutfs_inet_addr
 	scoutfs_sysfs_init_attrs(sb, &fence->ssa);
 
 	fence->start_kt = ktime_get();
-	memcpy(&fence->addr, addr, sizeof(union scoutfs_inet_addr));
+	fence->ipv4_addr = ipv4_addr;
 	fence->fenced = false;
 	fence->error = false;
 	fence->reason = reason;

kmod/src/fence.h

@@ -7,7 +7,7 @@ enum {
 	SCOUTFS_FENCE_QUORUM_BLOCK_LEADER,
 };
 
-int scoutfs_fence_start(struct super_block *sb, u64 rid, union scoutfs_inet_addr *addr, int reason);
+int scoutfs_fence_start(struct super_block *sb, u64 rid, __be32 ipv4_addr, int reason);
 int scoutfs_fence_next(struct super_block *sb, u64 *rid, int *reason, bool *error);
 int scoutfs_fence_reason_pending(struct super_block *sb, int reason);
 int scoutfs_fence_free(struct super_block *sb, u64 rid);

kmod/src/inode.c

@@ -154,7 +154,7 @@ static const struct inode_operations scoutfs_file_iops = {
 #else
 	.get_acl	= scoutfs_get_acl,
 #endif
-#ifdef KC_SET_ACL_DENTRY
+#ifdef KC_HAS_SET_ACL
 	.set_acl	= scoutfs_set_acl,
 #endif
 	.fiemap		= scoutfs_data_fiemap,
@@ -174,7 +174,7 @@ static const struct inode_operations scoutfs_special_iops = {
 #else
 	.get_acl	= scoutfs_get_acl,
 #endif
-#ifdef KC_SET_ACL_DENTRY
+#ifdef KC_HAS_SET_ACL
 	.set_acl	= scoutfs_set_acl,
 #endif
 };

kmod/src/kernelcompat.h

@@ -195,11 +195,9 @@ struct kc_shrinker_wrapper {
 #include <linux/inet.h>
 static inline int kc_kernel_getsockname(struct socket *sock, struct sockaddr *addr)
 {
-	int addrlen = sizeof(struct sockaddr_storage);
+	int addrlen = sizeof(struct sockaddr_in);
 	int ret = kernel_getsockname(sock, addr, &addrlen);
-	if (ret == 0 && (!(
-	    (addrlen == sizeof(struct sockaddr_in)) ||
-	    (addrlen == sizeof(struct sockaddr_in6)))))
+	if (ret == 0 && addrlen != sizeof(struct sockaddr_in))
 		return -EAFNOSUPPORT;
 	else if (ret < 0)
 		return ret;
@@ -208,11 +206,9 @@ static inline int kc_kernel_getsockname(struct socket *sock, struct sockaddr *ad
 }
 static inline int kc_kernel_getpeername(struct socket *sock, struct sockaddr *addr)
 {
-	int addrlen = sizeof(struct sockaddr_storage);
+	int addrlen = sizeof(struct sockaddr_in);
 	int ret = kernel_getpeername(sock, addr, &addrlen);
-	if (ret == 0 && (!(
-	    (addrlen == sizeof(struct sockaddr_in)) ||
-	    (addrlen == sizeof(struct sockaddr_in6)))))
+	if (ret == 0 && addrlen != sizeof(struct sockaddr_in))
 		return -EAFNOSUPPORT;
 	else if (ret < 0)
 		return ret;
@@ -493,4 +489,9 @@ static inline void stack_trace_print(unsigned long *entries, unsigned int nr_ent
 }
 #endif
 
+#ifndef KC_TIMER_CONTAINER_OF
+#define timer_container_of(var, callback_timer, timer_fieldname) \
+	from_timer(var, callback_timer, timer_fieldname)
+#endif
+
 #endif

kmod/src/net.c

@@ -1218,8 +1218,7 @@ static void scoutfs_net_connect_worker(struct work_struct *work)
 
 	trace_scoutfs_net_connect_work_enter(sb, 0, 0);
 
-	ret = kc_sock_create_kern(conn->connect_sin.ss_family,
-				  SOCK_STREAM, IPPROTO_TCP, &sock);
+	ret = kc_sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
 	if (ret)
 		goto out;
 
@@ -1240,9 +1239,7 @@ static void scoutfs_net_connect_worker(struct work_struct *work)
 	trace_scoutfs_conn_connect_start(conn);
 
 	ret = kernel_connect(sock, (struct sockaddr *)&conn->connect_sin,
-			     conn->connect_sin.ss_family == AF_INET ?
-				sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6),
-			     0);
+			     sizeof(struct sockaddr_in), 0);
 	if (ret)
 		goto out;
 
@@ -1284,13 +1281,6 @@ static bool empty_accepted_list(struct scoutfs_net_connection *conn)
 	return empty;
 }
 
-/*
- * sockaddr_storage wraps both _in and _in6, which have _port always
- * __be16 at the same offset, and we only need to test whether it's
- * zero.
- */
-#define sockaddr_port_is_nonzero(sin) ((sin).__data[0] || (sin).__data[1])
-
 /*
  * Safely shut down an active connection.  This can be triggered by
  * errors in workers or by an external call to free the connection.  The
@@ -1314,7 +1304,7 @@ static void scoutfs_net_shutdown_worker(struct work_struct *work)
 	trace_scoutfs_conn_shutdown_start(conn);
 
 	/* connected and accepted conns print a message */
-	if (sockaddr_port_is_nonzero(conn->peername))
+	if (conn->peername.sin_port != 0)
 		scoutfs_info(sb, "%s "SIN_FMT" -> "SIN_FMT,
 			     conn->listening_conn ? "server closing" :
 			                            "client disconnected",
@@ -1444,7 +1434,6 @@ static void scoutfs_net_reconn_free_worker(struct work_struct *work)
 	DEFINE_CONN_FROM_WORK(conn, work, reconn_free_dwork.work);
 	struct super_block *sb = conn->sb;
 	struct scoutfs_net_connection *acc;
-	union scoutfs_inet_addr addr;
 	unsigned long now = jiffies;
 	unsigned long deadline = 0;
 	bool requeue = false;
@@ -1465,9 +1454,8 @@ restart:
 			if (!test_conn_fl(conn, shutting_down)) {
 				scoutfs_info(sb, "client "SIN_FMT" reconnect timed out, fencing",
 					     SIN_ARG(&acc->last_peername));
-				scoutfs_sin_to_addr(&addr, &acc->last_peername);
 				ret = scoutfs_fence_start(sb, acc->rid,
-						&addr,
+						acc->last_peername.sin_addr.s_addr,
 						SCOUTFS_FENCE_CLIENT_RECONNECT);
 				if (ret) {
 					scoutfs_err(sb, "client fence returned err %d, shutting down server",
@@ -1550,9 +1538,9 @@ scoutfs_net_alloc_conn(struct super_block *sb,
 	conn->req_funcs = req_funcs;
 	spin_lock_init(&conn->lock);
 	init_waitqueue_head(&conn->waitq);
-	conn->sockname.ss_family = AF_UNSPEC;
-	conn->peername.ss_family = AF_UNSPEC;
-	conn->last_peername.ss_family = AF_UNSPEC;
+	conn->sockname.sin_family = AF_INET;
+	conn->peername.sin_family = AF_INET;
+	conn->last_peername.sin_family = AF_INET;
 	INIT_LIST_HEAD(&conn->accepted_head);
 	INIT_LIST_HEAD(&conn->accepted_list);
 	conn->next_send_seq = 1;
@@ -1631,7 +1619,7 @@ void scoutfs_net_free_conn(struct super_block *sb,
  */
 int scoutfs_net_bind(struct super_block *sb,
 		     struct scoutfs_net_connection *conn,
-		     struct sockaddr_storage *sin)
+		     struct sockaddr_in *sin)
 {
 	struct socket *sock = NULL;
 	int addrlen;
@@ -1642,7 +1630,7 @@ int scoutfs_net_bind(struct super_block *sb,
 	if (WARN_ON_ONCE(conn->sock))
 		return -EINVAL;
 
-	ret = kc_sock_create_kern(sin->ss_family, SOCK_STREAM, IPPROTO_TCP, &sock);
+	ret = kc_sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
 	if (ret)
 		goto out;
 
@@ -1654,7 +1642,7 @@ int scoutfs_net_bind(struct super_block *sb,
 	if (ret)
 		goto out;
 
-	addrlen = sin->ss_family == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
+	addrlen = sizeof(struct sockaddr_in);
 	ret = kernel_bind(sock, (struct sockaddr *)sin, addrlen);
 	if (ret)
 		goto out;
@@ -1670,7 +1658,7 @@ int scoutfs_net_bind(struct super_block *sb,
 	ret = 0;
 
 	conn->sock = sock;
-	sin = (struct sockaddr_storage *)&conn->sockname;
+	*sin = conn->sockname;
 
 out:
 	if (ret < 0 && sock)
@@ -1705,7 +1693,7 @@ static bool connect_result(struct scoutfs_net_connection *conn, int *error)
 		done = true;
 		*error = 0;
 	} else if (test_conn_fl(conn, shutting_down) ||
-		   conn->connect_sin.ss_family == AF_UNSPEC) {
+		   conn->connect_sin.sin_family == 0) {
 		done = true;
 		*error = -ESHUTDOWN;
 	}
@@ -1726,7 +1714,7 @@ static bool connect_result(struct scoutfs_net_connection *conn, int *error)
  */
 int scoutfs_net_connect(struct super_block *sb,
 			struct scoutfs_net_connection *conn,
-			struct sockaddr_storage *sin, unsigned long timeout_ms)
+			struct sockaddr_in *sin, unsigned long timeout_ms)
 {
 	int ret = 0;
 

kmod/src/net.h

@@ -49,15 +49,15 @@ struct scoutfs_net_connection {
 	unsigned long flags; /* CONN_FL_* bitmask */
 	unsigned long reconn_deadline;
 
-	struct sockaddr_storage connect_sin;
+	struct sockaddr_in connect_sin;
 	unsigned long connect_timeout_ms;
 
 	struct socket *sock;
 	u64 rid;
 	u64 greeting_id;
-	struct sockaddr_storage sockname;
-	struct sockaddr_storage peername;
-	struct sockaddr_storage last_peername;
+	struct sockaddr_in sockname;
+	struct sockaddr_in peername;
+	struct sockaddr_in last_peername;
 
 	struct list_head accepted_head;
 	struct scoutfs_net_connection *listening_conn;
@@ -99,44 +99,27 @@ enum conn_flags {
 	CONN_FL_reconn_freeing = (1UL << 6), /* waiting done, setter frees */
 };
 
-#define SIN_FMT		"%pISpc"
-#define SIN_ARG(sin)	sin
+#define SIN_FMT		"%pIS:%u"
+#define SIN_ARG(sin)	sin, be16_to_cpu((sin)->sin_port)
 
-static inline void scoutfs_addr_to_sin(struct sockaddr_storage *sin,
+static inline void scoutfs_addr_to_sin(struct sockaddr_in *sin,
 				       union scoutfs_inet_addr *addr)
 {
-	if (addr->v4.family == cpu_to_le16(SCOUTFS_AF_IPV4)) {
-		struct sockaddr_in *sin4 = (struct sockaddr_in *)sin;
-		memset(sin, 0, sizeof(struct sockaddr_storage));
-		sin4->sin_family = AF_INET;
-		sin4->sin_addr.s_addr = cpu_to_be32(le32_to_cpu(addr->v4.addr));
-		sin4->sin_port = cpu_to_be16(le16_to_cpu(addr->v4.port));
-	} else if (addr->v6.family == cpu_to_le16(SCOUTFS_AF_IPV6)) {
-		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sin;
-		memset(sin, 0, sizeof(struct sockaddr_storage));
-		sin6->sin6_family = AF_INET6;
-		memcpy(&sin6->sin6_addr.in6_u.u6_addr8, &addr->v6.addr, 16);
-		sin6->sin6_port = cpu_to_be16(le16_to_cpu(addr->v6.port));
-	} else
-		BUG();
+	BUG_ON(addr->v4.family != cpu_to_le16(SCOUTFS_AF_IPV4));
+
+	sin->sin_family = AF_INET;
+	sin->sin_addr.s_addr = cpu_to_be32(le32_to_cpu(addr->v4.addr));
+	sin->sin_port = cpu_to_be16(le16_to_cpu(addr->v4.port));
 }
 
-static inline void scoutfs_sin_to_addr(union scoutfs_inet_addr *addr, struct sockaddr_storage *sin)
+static inline void scoutfs_sin_to_addr(union scoutfs_inet_addr *addr, struct sockaddr_in *sin)
 {
-	if (sin->ss_family == AF_INET) {
-		struct sockaddr_in *sin4 = (struct sockaddr_in *)sin;
-		memset(addr, 0, sizeof(union scoutfs_inet_addr));
-		addr->v4.family = cpu_to_le16(SCOUTFS_AF_IPV4);
-		addr->v4.addr = be32_to_le32(sin4->sin_addr.s_addr);
-		addr->v4.port = be16_to_le16(sin4->sin_port);
-	} else if (sin->ss_family == AF_INET6) {
-		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sin;
-		memset(addr, 0, sizeof(union scoutfs_inet_addr));
-		addr->v6.family = cpu_to_le16(SCOUTFS_AF_IPV6);
-		memcpy(&addr->v6.addr, &sin6->sin6_addr.in6_u.u6_addr8, 16);
-		addr->v6.port = be16_to_le16(sin6->sin6_port);
-	} else
-		BUG();
+	BUG_ON(sin->sin_family != AF_INET);
+
+	memset(addr, 0, sizeof(union scoutfs_inet_addr));
+	addr->v4.family = cpu_to_le16(SCOUTFS_AF_IPV4);
+	addr->v4.addr = be32_to_le32(sin->sin_addr.s_addr);
+	addr->v4.port = be16_to_le16(sin->sin_port);
 }
 
 struct scoutfs_net_connection *
@@ -147,10 +130,10 @@ scoutfs_net_alloc_conn(struct super_block *sb,
 u64 scoutfs_net_client_rid(struct scoutfs_net_connection *conn);
 int scoutfs_net_connect(struct super_block *sb,
 			struct scoutfs_net_connection *conn,
-			struct sockaddr_storage *sin, unsigned long timeout_ms);
+			struct sockaddr_in *sin, unsigned long timeout_ms);
 int scoutfs_net_bind(struct super_block *sb,
 		     struct scoutfs_net_connection *conn,
-		     struct sockaddr_storage *sin);
+		     struct sockaddr_in *sin);
 void scoutfs_net_listen(struct super_block *sb,
 			struct scoutfs_net_connection *conn);
 int scoutfs_net_submit_request(struct super_block *sb,

kmod/src/quorum.c

@@ -145,26 +145,14 @@ struct quorum_info {
 #define DECLARE_QUORUM_INFO_KOBJ(kobj, name) \
 	DECLARE_QUORUM_INFO(SCOUTFS_SYSFS_ATTRS_SB(kobj), name)
 
-static bool quorum_slot_ipv4(struct scoutfs_quorum_config *qconf, int i)
+static bool quorum_slot_present(struct scoutfs_quorum_config *qconf, int i)
 {
 	BUG_ON(i < 0 || i > SCOUTFS_QUORUM_MAX_SLOTS);
 
 	return qconf->slots[i].addr.v4.family == cpu_to_le16(SCOUTFS_AF_IPV4);
 }
 
-static bool quorum_slot_ipv6(struct scoutfs_quorum_config *qconf, int i)
-{
-	BUG_ON(i < 0 || i > SCOUTFS_QUORUM_MAX_SLOTS);
-
-	return qconf->slots[i].addr.v6.family == cpu_to_le16(SCOUTFS_AF_IPV6);
-}
-
-static bool quorum_slot_present(struct scoutfs_quorum_config *qconf, int i)
-{
-	return quorum_slot_ipv4(qconf, i) || quorum_slot_ipv6(qconf, i);
-}
-
-static void quorum_slot_sin(struct scoutfs_quorum_config *qconf, int i, struct sockaddr_storage *sin)
+static void quorum_slot_sin(struct scoutfs_quorum_config *qconf, int i, struct sockaddr_in *sin)
 {
 	BUG_ON(i < 0 || i >= SCOUTFS_QUORUM_MAX_SLOTS);
 
@@ -191,18 +179,11 @@ static int create_socket(struct super_block *sb)
 {
 	DECLARE_QUORUM_INFO(sb, qinf);
 	struct socket *sock = NULL;
-	struct sockaddr_storage sin;
-	struct scoutfs_quorum_slot slot = qinf->qconf.slots[qinf->our_quorum_slot_nr];
+	struct sockaddr_in sin;
 	int addrlen;
 	int ret;
 
-	if (le16_to_cpu(slot.addr.v4.family) == SCOUTFS_AF_IPV4)
-		ret = kc_sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
-	else if (le16_to_cpu(slot.addr.v6.family) == SCOUTFS_AF_IPV6)
-		ret = kc_sock_create_kern(PF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
-	else
-		BUG();
-
+	ret = kc_sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
 	if (ret) {
 		scoutfs_err(sb, "quorum couldn't create udp socket: %d", ret);
 		goto out;
@@ -211,9 +192,9 @@ static int create_socket(struct super_block *sb)
 	/* rather fail and retry than block waiting for free */
 	sock->sk->sk_allocation = GFP_ATOMIC;
 
-	addrlen = (le16_to_cpu(slot.addr.v4.family) == SCOUTFS_AF_IPV4) ?
-		  sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
 	quorum_slot_sin(&qinf->qconf, qinf->our_quorum_slot_nr, &sin);
+
+	addrlen = sizeof(sin);
 	ret = kernel_bind(sock, (struct sockaddr *)&sin, addrlen);
 	if (ret) {
 		scoutfs_err(sb, "quorum failed to bind udp socket to "SIN_FMT": %d",
@@ -260,7 +241,7 @@ static int send_msg_members(struct super_block *sb, int type, u64 term, int only
 		.iov_base = &qmes,
 		.iov_len = sizeof(qmes),
 	};
-	struct sockaddr_storage sin;
+	struct sockaddr_in sin;
 	struct msghdr mh = {
 		.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL,
 		.msg_name = &sin,
@@ -561,11 +542,10 @@ int scoutfs_quorum_fence_leaders(struct super_block *sb, struct scoutfs_quorum_c
 				 u64 term)
 {
 #define NR_OLD 2
-	struct scoutfs_quorum_block_event (*old)[NR_OLD];
+	struct scoutfs_quorum_block_event old[SCOUTFS_QUORUM_MAX_SLOTS][NR_OLD] = {{{0,}}};
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 	struct scoutfs_quorum_block blk;
-	struct sockaddr_storage sin;
-	union scoutfs_inet_addr addr;
+	struct sockaddr_in sin;
 	const __le64 lefsid = cpu_to_le64(sbi->fsid);
 	const u64 rid = sbi->rid;
 	bool fence_started = false;
@@ -578,20 +558,13 @@ int scoutfs_quorum_fence_leaders(struct super_block *sb, struct scoutfs_quorum_c
 
 	BUILD_BUG_ON(SCOUTFS_QUORUM_BLOCKS < SCOUTFS_QUORUM_MAX_SLOTS);
 
-	old = kmalloc(NR_OLD * SCOUTFS_QUORUM_MAX_SLOTS * sizeof(struct scoutfs_quorum_block_event), GFP_KERNEL);
-	if (!old) {
-		ret = -ENOMEM;
-		goto out;
-	}
-	memset(old, 0, NR_OLD * SCOUTFS_QUORUM_MAX_SLOTS * sizeof(struct scoutfs_quorum_block_event));
-
 	for (i = 0; i < SCOUTFS_QUORUM_MAX_SLOTS; i++) {
 		if (!quorum_slot_present(qconf, i))
 			continue;
 
 		ret = read_quorum_block(sb, SCOUTFS_QUORUM_BLKNO + i, &blk, false);
 		if (ret < 0)
-			goto out_free;
+			goto out;
 
 		/* elected leader still running */
 		if (le64_to_cpu(blk.events[SCOUTFS_QUORUM_EVENT_ELECT].term) >
@@ -625,17 +598,14 @@ int scoutfs_quorum_fence_leaders(struct super_block *sb, struct scoutfs_quorum_c
 			scoutfs_info(sb, "fencing previous leader "SCSBF" at term %llu in slot %u with address "SIN_FMT,
 				     SCSB_LEFR_ARGS(lefsid, fence_rid),
 				     le64_to_cpu(old[i][j].term), i, SIN_ARG(&sin));
-			scoutfs_sin_to_addr(&addr, &sin);
-			ret = scoutfs_fence_start(sb, le64_to_cpu(fence_rid), &addr,
+			ret = scoutfs_fence_start(sb, le64_to_cpu(fence_rid), sin.sin_addr.s_addr,
 						  SCOUTFS_FENCE_QUORUM_BLOCK_LEADER);
 			if (ret < 0)
-				goto out_free;
+				goto out;
 			fence_started = true;
 		}
 	}
 
-out_free:
-	kfree(old);
 out:
 	err = scoutfs_fence_wait_fenced(sb, msecs_to_jiffies(SCOUTFS_QUORUM_FENCE_TO_MS));
 	if (ret == 0)
@@ -738,7 +708,7 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 	struct quorum_info *qinf = container_of(work, struct quorum_info, work);
 	struct scoutfs_mount_options opts;
 	struct super_block *sb = qinf->sb;
-	struct sockaddr_storage unused;
+	struct sockaddr_in unused;
 	struct quorum_host_msg msg;
 	struct quorum_status qst = {0,};
 	struct hb_recording hbr;
@@ -1020,7 +990,7 @@ out:
  * leader with the greatest elected term.  If we get it wrong the
  * connection will timeout and the client will try again.
  */
-int scoutfs_quorum_server_sin(struct super_block *sb, struct sockaddr_storage *sin)
+int scoutfs_quorum_server_sin(struct super_block *sb, struct sockaddr_in *sin)
 {
 	struct scoutfs_super_block *super = NULL;
 	struct scoutfs_quorum_block blk;
@@ -1079,7 +1049,7 @@ u8 scoutfs_quorum_votes_needed(struct super_block *sb)
 	return qinf->votes_needed;
 }
 
-void scoutfs_quorum_slot_sin(struct scoutfs_quorum_config *qconf, int i, struct sockaddr_storage *sin)
+void scoutfs_quorum_slot_sin(struct scoutfs_quorum_config *qconf, int i, struct sockaddr_in *sin)
 {
 	return quorum_slot_sin(qconf, i, sin);
 }
@@ -1238,13 +1208,8 @@ static int verify_quorum_slots(struct super_block *sb, struct quorum_info *qinf,
 			       struct scoutfs_quorum_config *qconf)
 {
 	char slots[(SCOUTFS_QUORUM_MAX_SLOTS * 3) + 1];
-	struct sockaddr_storage other;
-	struct sockaddr_storage sin;
-	struct sockaddr_in *sin4;
-	struct sockaddr_in *other4;
-	struct sockaddr_in6 *sin6;
-	struct sockaddr_in6 *other6;
-	__le16 family = cpu_to_le16(SCOUTFS_AF_NONE);
+	struct sockaddr_in other;
+	struct sockaddr_in sin;
 	int found = 0;
 	int ret;
 	int i;
@@ -1255,94 +1220,35 @@ static int verify_quorum_slots(struct super_block *sb, struct quorum_info *qinf,
 		if (!quorum_slot_present(qconf, i))
 			continue;
 
-		if (quorum_slot_ipv4(qconf, i)) {
-			if (family == cpu_to_le16(SCOUTFS_AF_NONE)) {
-				family = cpu_to_le16(SCOUTFS_AF_IPV4);
-			} else if (family != cpu_to_le16(SCOUTFS_AF_IPV4)) {
-				scoutfs_err(sb, "quorum slot #%d is IPv4 but earlier slots are IPv6; mixed IPv4/IPv6 quorum is not supported",
-					    i);
-				return -EINVAL;
-			}
+		scoutfs_quorum_slot_sin(qconf, i, &sin);
 
-			scoutfs_quorum_slot_sin(qconf, i, &sin);
-			sin4 = (struct sockaddr_in *)&sin;
-
-			if (!valid_ipv4_unicast(sin4->sin_addr.s_addr)) {
-				scoutfs_err(sb, "quorum slot #%d has invalid ipv4 unicast address: "SIN_FMT,
-					    i, SIN_ARG(&sin));
-				return -EINVAL;
-			}
-
-			if (!valid_ipv4_port(sin4->sin_port)) {
-				scoutfs_err(sb, "quorum slot #%d has invalid ipv4 port number:"SIN_FMT,
-					    i, SIN_ARG(&sin));
-				return -EINVAL;
-			}
-
-			for (j = i + 1; j < SCOUTFS_QUORUM_MAX_SLOTS; j++) {
-				if (!quorum_slot_ipv4(qconf, j))
-					continue;
-
-				scoutfs_quorum_slot_sin(qconf, j, &other);
-				other4 = (struct sockaddr_in *)&other;
-
-				if (sin4->sin_addr.s_addr == other4->sin_addr.s_addr &&
-				    sin4->sin_port == other4->sin_port) {
-					scoutfs_err(sb, "quorum slots #%u and #%u have the same address: "SIN_FMT,
-						    i, j, SIN_ARG(&sin));
-					return -EINVAL;
-				}
-			}
-
-			found++;
-		} else if (quorum_slot_ipv6(qconf, i)) {
-			if (family == cpu_to_le16(SCOUTFS_AF_NONE)) {
-				family = cpu_to_le16(SCOUTFS_AF_IPV6);
-			} else if (family != cpu_to_le16(SCOUTFS_AF_IPV6)) {
-				scoutfs_err(sb, "quorum slot #%d is IPv6 but earlier slots are IPv4; mixed IPv4/IPv6 quorum is not supported",
-					    i);
-				return -EINVAL;
-			}
-
-			quorum_slot_sin(qconf, i, &sin);
-			sin6 = (struct sockaddr_in6 *)&sin;
-
-			if ((sin6->sin6_addr.in6_u.u6_addr32[0] == 0) && (sin6->sin6_addr.in6_u.u6_addr32[1] == 0) &&
-			    (sin6->sin6_addr.in6_u.u6_addr32[2] == 0) && (sin6->sin6_addr.in6_u.u6_addr32[3] == 0)) {
-				scoutfs_err(sb, "quorum slot #%d has unspecified ipv6 address:"SIN_FMT,
-					    i, SIN_ARG(&sin));
-				return -EINVAL;
-			}
-
-			if (sin6->sin6_addr.in6_u.u6_addr8[0] == 0xff) {
-				scoutfs_err(sb, "quorum slot #%d has multicast ipv6 address:"SIN_FMT,
-					    i, SIN_ARG(&sin));
-				return -EINVAL;
-			}
-
-			if (!valid_ipv4_port(sin6->sin6_port)) {
-				scoutfs_err(sb, "quorum slot #%d has invalid ipv6 port number:"SIN_FMT,
-					    i,  SIN_ARG(&sin));
-				return -EINVAL;
-			}
-
-			for (j = i + 1; j < SCOUTFS_QUORUM_MAX_SLOTS; j++) {
-				if (!quorum_slot_ipv6(qconf, j))
-					continue;
-
-				quorum_slot_sin(qconf, j, &other);
-				other6 = (struct sockaddr_in6 *)&other;
-
-				if ((ipv6_addr_equal(&sin6->sin6_addr, &other6->sin6_addr)) &&
-				    (sin6->sin6_port == other6->sin6_port)) {
-					scoutfs_err(sb, "quorum slots #%u and #%u have the same address: "SIN_FMT,
-						    i, j, SIN_ARG(&sin));
-					return -EINVAL;
-				}
-			}
-
-			found++;
+		if (!valid_ipv4_unicast(sin.sin_addr.s_addr)) {
+			scoutfs_err(sb, "quorum slot #%d has invalid ipv4 unicast address: "SIN_FMT,
+				    i,  SIN_ARG(&sin));
+			return -EINVAL;
 		}
+
+		if (!valid_ipv4_port(sin.sin_port)) {
+			scoutfs_err(sb, "quorum slot #%d has invalid ipv4 port number:"SIN_FMT,
+				    i,  SIN_ARG(&sin));
+			return -EINVAL;
+		}
+
+		for (j = i + 1; j < SCOUTFS_QUORUM_MAX_SLOTS; j++) {
+			if (!quorum_slot_present(qconf, j))
+				continue;
+
+			scoutfs_quorum_slot_sin(qconf, j, &other);
+
+			if (sin.sin_addr.s_addr == other.sin_addr.s_addr &&
+			    sin.sin_port == other.sin_port) {
+				scoutfs_err(sb, "quorum slots #%u and #%u have the same address: "SIN_FMT,
+					    i, j, SIN_ARG(&sin));
+				return -EINVAL;
+			}
+		}
+
+		found++;
 	}
 
 	if (found == 0)  {

kmod/src/quorum.h

@@ -1,11 +1,11 @@
 #ifndef _SCOUTFS_QUORUM_H_
 #define _SCOUTFS_QUORUM_H_
 
-int scoutfs_quorum_server_sin(struct super_block *sb, struct sockaddr_storage *sin);
+int scoutfs_quorum_server_sin(struct super_block *sb, struct sockaddr_in *sin);
 
 u8 scoutfs_quorum_votes_needed(struct super_block *sb);
 void scoutfs_quorum_slot_sin(struct scoutfs_quorum_config *qconf, int i,
-			     struct sockaddr_storage *sin);
+			     struct sockaddr_in *sin);
 
 int scoutfs_quorum_fence_leaders(struct super_block *sb, struct scoutfs_quorum_config *qconf,
 				 u64 term);

kmod/src/recov.c

@@ -134,7 +134,7 @@ static int recov_finished(struct recov_info *recinf)
 
 static void timer_callback(struct timer_list *timer)
 {
-	struct recov_info *recinf = from_timer(recinf, timer, timer);
+	struct recov_info *recinf = timer_container_of(recinf, timer, timer);
 
 	recinf->timeout_fn(recinf->sb);
 }

kmod/src/scoutfs_trace.h

@@ -1355,37 +1355,35 @@ DEFINE_EVENT(scoutfs_lock_class, scoutfs_lock_shrink,
 );
 
 DECLARE_EVENT_CLASS(scoutfs_net_class,
-        TP_PROTO(struct super_block *sb, struct sockaddr_storage *name,
-		 struct sockaddr_storage *peer, struct scoutfs_net_header *nh),
+        TP_PROTO(struct super_block *sb, struct sockaddr_in *name,
+		 struct sockaddr_in *peer, struct scoutfs_net_header *nh),
         TP_ARGS(sb, name, peer, nh),
         TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
-		__field_struct(struct sockaddr_storage, name)
-		__field_struct(struct sockaddr_storage, peer)
+		si4_trace_define(name)
+		si4_trace_define(peer)
 		snh_trace_define(nh)
         ),
         TP_fast_assign(
 		SCSB_TRACE_ASSIGN(sb);
-		memcpy(&__entry->name, name, sizeof(struct sockaddr_storage));
-		memcpy(&__entry->peer, peer, sizeof(struct sockaddr_storage));
+		si4_trace_assign(name, name);
+		si4_trace_assign(peer, peer);
 		snh_trace_assign(nh, nh);
         ),
-        TP_printk(SCSBF" name "SIN_FMT" peer "SIN_FMT" nh "SNH_FMT,
-		  SCSB_TRACE_ARGS,
-		  &__entry->name,
-		  &__entry->peer,
+        TP_printk(SCSBF" name "SI4_FMT" peer "SI4_FMT" nh "SNH_FMT,
+		  SCSB_TRACE_ARGS, si4_trace_args(name), si4_trace_args(peer),
 		  snh_trace_args(nh))
 );
 
 DEFINE_EVENT(scoutfs_net_class, scoutfs_net_send_message,
-        TP_PROTO(struct super_block *sb, struct sockaddr_storage *name,
-		 struct sockaddr_storage *peer, struct scoutfs_net_header *nh),
+        TP_PROTO(struct super_block *sb, struct sockaddr_in *name,
+		 struct sockaddr_in *peer, struct scoutfs_net_header *nh),
         TP_ARGS(sb, name, peer, nh)
 );
 
 DEFINE_EVENT(scoutfs_net_class, scoutfs_net_recv_message,
-        TP_PROTO(struct super_block *sb, struct sockaddr_storage *name,
-		 struct sockaddr_storage *peer, struct scoutfs_net_header *nh),
+        TP_PROTO(struct super_block *sb, struct sockaddr_in *name,
+		 struct sockaddr_in *peer, struct scoutfs_net_header *nh),
         TP_ARGS(sb, name, peer, nh)
 );
 
@@ -1418,8 +1416,8 @@ DECLARE_EVENT_CLASS(scoutfs_net_conn_class,
 		__field(void *, sock)
 		__field(__u64, c_rid)
 		__field(__u64, greeting_id)
-		__field_struct(struct sockaddr_storage, sockname)
-		__field_struct(struct sockaddr_storage, peername)
+		si4_trace_define(sockname)
+		si4_trace_define(peername)
 		__field(unsigned char, e_accepted_head)
 		__field(void *, listening_conn)
 		__field(unsigned char, e_accepted_list)
@@ -1437,8 +1435,8 @@ DECLARE_EVENT_CLASS(scoutfs_net_conn_class,
 		__entry->sock = conn->sock;
 		__entry->c_rid = conn->rid;
 		__entry->greeting_id = conn->greeting_id;
-		memcpy(&__entry->sockname, &conn->sockname, sizeof(struct sockaddr_storage));
-		memcpy(&__entry->peername, &conn->peername, sizeof(struct sockaddr_storage));
+		si4_trace_assign(sockname, &conn->sockname);
+		si4_trace_assign(peername, &conn->peername);
 		__entry->e_accepted_head = !!list_empty(&conn->accepted_head);
 		__entry->listening_conn = conn->listening_conn;
 		__entry->e_accepted_list = !!list_empty(&conn->accepted_list);
@@ -1448,7 +1446,7 @@ DECLARE_EVENT_CLASS(scoutfs_net_conn_class,
 		__entry->e_resend_queue = !!list_empty(&conn->resend_queue);
 		__entry->recv_seq = atomic64_read(&conn->recv_seq);
         ),
-        TP_printk(SCSBF" flags %s rc_dl %lu cto %lu sk %p rid %llu grid %llu sn "SIN_FMT" pn "SIN_FMT" eah %u lc %p eal %u nss %llu nsi %llu esq %u erq %u rs %llu",
+        TP_printk(SCSBF" flags %s rc_dl %lu cto %lu sk %p rid %llu grid %llu sn "SI4_FMT" pn "SI4_FMT" eah %u lc %p eal %u nss %llu nsi %llu esq %u erq %u rs %llu",
 		  SCSB_TRACE_ARGS,
 		  print_conn_flags(__entry->flags),
 		  __entry->reconn_deadline,
@@ -1456,8 +1454,8 @@ DECLARE_EVENT_CLASS(scoutfs_net_conn_class,
 		  __entry->sock,
 		  __entry->c_rid,
 		  __entry->greeting_id,
-		  &__entry->sockname,
-		  &__entry->peername,
+		  si4_trace_args(sockname),
+		  si4_trace_args(peername),
 		  __entry->e_accepted_head,
 		  __entry->listening_conn,
 		  __entry->e_accepted_list,

kmod/src/server.c

@@ -3639,7 +3639,7 @@ static bool invalid_mounted_client_item(struct scoutfs_btree_item_ref *iref)
  * it's acceptable to see -EEXIST.
  */
 static int insert_mounted_client(struct super_block *sb, u64 rid, u64 gr_flags,
-				 struct sockaddr_storage *sin)
+				 struct sockaddr_in *sin)
 {
 	DECLARE_SERVER_INFO(sb, server);
 	struct scoutfs_super_block *super = DIRTY_SUPER_SB(sb);
@@ -4392,7 +4392,7 @@ static void fence_pending_recov_worker(struct work_struct *work)
 			break;
 		}
 
-		ret = scoutfs_fence_start(sb, rid, &addr,
+		ret = scoutfs_fence_start(sb, rid, le32_to_be32(addr.v4.addr),
 					  SCOUTFS_FENCE_CLIENT_RECOVERY);
 		if (ret < 0) {
 			scoutfs_err(sb, "fence returned err %d, shutting down server", ret);
@@ -4543,7 +4543,7 @@ static void scoutfs_server_worker(struct work_struct *work)
 	struct scoutfs_net_connection *conn = NULL;
 	struct scoutfs_mount_options opts;
 	DECLARE_WAIT_QUEUE_HEAD(waitq);
-	struct sockaddr_storage sin;
+	struct sockaddr_in sin;
 	bool alloc_init = false;
 	u64 max_seq;
 	int ret;
@@ -4552,7 +4552,7 @@ static void scoutfs_server_worker(struct work_struct *work)
 
 	scoutfs_options_read(sb, &opts);
 	scoutfs_quorum_slot_sin(&server->qconf, opts.quorum_slot_nr, &sin);
-	scoutfs_info(sb, "server starting at "SIN_FMT, &sin);
+	scoutfs_info(sb, "server starting at "SIN_FMT, SIN_ARG(&sin));
 
 	scoutfs_block_writer_init(sb, &server->wri);
 	server->finalize_sent_seq = 0;

kmod/src/server.h

@@ -1,6 +1,27 @@
 #ifndef _SCOUTFS_SERVER_H_
 #define _SCOUTFS_SERVER_H_
 
+#define SI4_FMT		"%u.%u.%u.%u:%u"
+
+#define si4_trace_define(name)		\
+	__field(__u32, name##_addr)	\
+	__field(__u16, name##_port)
+
+#define si4_trace_assign(name, sin)					\
+do {									\
+	__typeof__(sin) _sin = (sin);					\
+									\
+	__entry->name##_addr = be32_to_cpu(_sin->sin_addr.s_addr);	\
+	__entry->name##_port = be16_to_cpu(_sin->sin_port);		\
+} while(0)
+
+#define si4_trace_args(name)			\
+	(__entry->name##_addr >> 24),		\
+	(__entry->name##_addr >> 16) & 255,	\
+	(__entry->name##_addr >> 8) & 255,	\
+	__entry->name##_addr & 255,		\
+	__entry->name##_port
+
 #define SNH_FMT \
 	"seq %llu recv_seq %llu id %llu data_len %u cmd %u flags 0x%x error %u"
 #define SNH_ARG(nh)							\

tests/funcs/filter.sh

@@ -171,6 +171,13 @@ t_filter_dmesg()
 	# orphan log trees reclaim is handled, not an error
 	re="$re|scoutfs .* reclaiming orphan log trees"
 
+	# nfs can emit a whole range of messages we can ignore
+	re="$re|Installing knfsd .*"
+	re="$re|nfsd: .*"
+	re="$re|NFSD: .*"
+	re="$re|RPC: .*"
+	re="$re|FS-Cache: .*"
+
 	# fencing tests force unmounts and trigger timeouts
 	re="$re|scoutfs .* forcing unmount"
 	re="$re|scoutfs .* reconnect timed out"

tests/golden/basic-inetaddr

@@ -1,7 +0,0 @@
-== mkfs rejects mixed v4/v6 quorum
-rc: 64
-== mkfs all-v4, mount three members, cross-mount signature visible
-== change-quorum-config rejects mixed v4/v6 quorum
-rc: 64
-== switch v4 -> v6, signature survives, cross-mount write again
-== switch v6 -> v4, signatures survive

tests/golden/basic-nfs

@@ -0,0 +1,32 @@
+== write via NFS, read both sides
+== POSIX ACL set via NFS, read both sides
+user::rw-
+user:22222:rw-
+group::r--
+mask::rw-
+other::r--
+
+user::rw-
+user:22222:rw-
+group::r--
+mask::rw-
+other::r--
+
+== POSIX ACL set on scoutfs, read via NFS
+user::rw-
+user:22222:rw-
+group::r--
+group:44444:r--
+mask::rw-
+other::r--
+
+== default ACL inheritance via NFS
+user::rw-
+user:22222:rwx	#effective:rw-
+group::r-x	#effective:r--
+mask::rw-
+other::r--
+
+== NFS read demand-stages a released file
+1
+== cleanup

tests/golden/data-prealloc

@@ -8,10 +8,10 @@
 /mnt/test/test/data-prealloc/file-1: extents: 32
 /mnt/test/test/data-prealloc/file-2: extents: 32
 == any writes to region prealloc get full extents
-/mnt/test/test/data-prealloc/file-1: extents: 4
-/mnt/test/test/data-prealloc/file-2: extents: 4
-/mnt/test/test/data-prealloc/file-1: extents: 4
-/mnt/test/test/data-prealloc/file-2: extents: 4
+/mnt/test/test/data-prealloc/file-1: extents: 8
+/mnt/test/test/data-prealloc/file-2: extents: 8
+/mnt/test/test/data-prealloc/file-1: extents: 8
+/mnt/test/test/data-prealloc/file-2: extents: 8
 == streaming offline writes get full extents either way
 /mnt/test/test/data-prealloc/file-1: extents: 4
 /mnt/test/test/data-prealloc/file-2: extents: 4
@@ -20,8 +20,8 @@
 == goofy preallocation amounts work
 /mnt/test/test/data-prealloc/file-1: extents: 6
 /mnt/test/test/data-prealloc/file-2: extents: 6
-/mnt/test/test/data-prealloc/file-1: extents: 6
-/mnt/test/test/data-prealloc/file-2: extents: 6
+/mnt/test/test/data-prealloc/file-1: extents: 10
+/mnt/test/test/data-prealloc/file-2: extents: 10
 /mnt/test/test/data-prealloc/file-1: extents: 3
 /mnt/test/test/data-prealloc/file-2: extents: 3
 == block writes into region allocs hole

tests/run-tests.sh

@@ -383,7 +383,7 @@ fi
 quo=""
 if [ -n "$T_MKFS" ]; then
 	for i in $(seq -0 $((T_QUORUM - 1))); do
-		quo="$quo -Q $i,::1,$((T_TEST_PORT + i))"
+		quo="$quo -Q $i,127.0.0.1,$((T_TEST_PORT + i))"
 	done
 
 	msg "making new filesystem with $T_QUORUM quorum members"

tests/sequence

@@ -1,9 +1,9 @@
 export-get-name-parent.sh
 basic-block-counts.sh
 basic-bad-mounts.sh
-basic-inetaddr.sh
 basic-posix-acl.sh
 basic-acl-consistency.sh
+basic-nfs.sh
 inode-items-updated.sh
 simple-inode-index.sh
 simple-staging.sh

tests/tests/basic-inetaddr.sh

@@ -1,78 +0,0 @@
-#
-# Test that mixed ipv4/6 fails through mkfs/quorum change and that
-# users can migrate from ipv4 to v6 and back.
-#
-
-t_require_commands dmsetup blockdev cmp
-
-P0=$T_SCRATCH_PORT
-P1=$((T_SCRATCH_PORT + 1))
-P2=$((T_SCRATCH_PORT + 2))
-SIG=$T_TMP.sig
-seq 1 4096 > "$SIG"
-
-trap '
-	umount $T_TMPDIR/m0 $T_TMPDIR/m1 $T_TMPDIR/m2 2>/dev/null
-	dmsetup remove _bia_m0 _bia_m1 _bia_m2 _bia_d0 _bia_d1 _bia_d2 2>/dev/null
-' EXIT
-
-mkdir -p "$T_TMPDIR/m0" "$T_TMPDIR/m1" "$T_TMPDIR/m2"
-for nv in "m0 $T_EX_META_DEV" "m1 $T_EX_META_DEV" "m2 $T_EX_META_DEV" \
-	  "d0 $T_EX_DATA_DEV" "d1 $T_EX_DATA_DEV" "d2 $T_EX_DATA_DEV"; do
-	set -- $nv
-	t_quiet dmsetup create _bia_$1 --table "0 $(blockdev --getsz $2) linear $2 0"
-done
-
-mnt() {
-mount -t scoutfs \
-	-o metadev_path=/dev/mapper/_bia_m$1,quorum_slot_nr=$1 \
-	/dev/mapper/_bia_d$1 "$T_TMPDIR/m$1"
-}
-mount_all() {
-	mnt 0 &
-	mnt 1 &
-	mnt 2 &
-	wait
-}
-umount_all() {
-	umount $T_TMPDIR/m0 &
-	umount $T_TMPDIR/m1 &
-	umount $T_TMPDIR/m2 &
-	wait
-}
-verify() {
-	cmp -s "$SIG" "$T_TMPDIR/m0/sig" &&
-	cmp -s "$SIG" "$T_TMPDIR/m1/sig" &&
-	cmp -s "$SIG" "$T_TMPDIR/m2/sig" || t_fail "$1"
-}
-
-echo "== mkfs rejects mixed v4/v6 quorum"
-t_rc scoutfs mkfs -f -Q 0,127.0.0.1,$P0 -Q 1,::1,$P1 -Q 2,127.0.0.1,$P2 /dev/mapper/_bia_m0 /dev/mapper/_bia_d0
-
-echo "== mkfs all-v4, mount three members, cross-mount signature visible"
-t_quiet scoutfs mkfs -f -Q 0,127.0.0.1,$P0 -Q 1,127.0.0.1,$P1 -Q 2,127.0.0.1,$P2 /dev/mapper/_bia_m0 /dev/mapper/_bia_d0
-mount_all
-cp "$SIG" "$T_TMPDIR/m0/sig"
-verify "v4 initial"
-umount_all
-
-echo "== change-quorum-config rejects mixed v4/v6 quorum"
-t_rc scoutfs change-quorum-config --offline -Q 0,127.0.0.1,$P0 -Q 1,::1,$P1 -Q 2,127.0.0.1,$P2 /dev/mapper/_bia_m0
-
-echo "== switch v4 -> v6, signature survives, cross-mount write again"
-t_quiet scoutfs change-quorum-config --offline -Q 0,::1,$P0 -Q 1,::1,$P1 -Q 2,::1,$P2 /dev/mapper/_bia_m0
-mount_all
-verify "after v4->v6"
-cp "$SIG" "$T_TMPDIR/m1/sig-v6"
-cmp -s "$SIG" "$T_TMPDIR/m0/sig-v6" || t_fail "v6 cross-mount write not visible on m0"
-cmp -s "$SIG" "$T_TMPDIR/m2/sig-v6" || t_fail "v6 cross-mount write not visible on m2"
-umount_all
-
-echo "== switch v6 -> v4, signatures survive"
-t_quiet scoutfs change-quorum-config --offline -Q 0,127.0.0.1,$P0 -Q 1,127.0.0.1,$P1 -Q 2,127.0.0.1,$P2 /dev/mapper/_bia_m0
-mount_all
-verify "after v6->v4"
-cmp -s "$SIG" "$T_TMPDIR/m0/sig-v6" || t_fail "after v6->v4 sig-v6 lost"
-umount_all
-
-t_pass

tests/tests/basic-nfs.sh

@@ -0,0 +1,86 @@
+#
+# Test basic scoutfs-nfs interactions:
+# - read/write
+# - stage/release and data wait
+# - nfs setacl/getacl mapping
+#
+
+t_require_commands scoutfs setfacl getfacl exportfs mount.nfs umount \
+		   stat dd cmp systemctl
+
+systemctl start nfs-server >> "$T_TMPDIR/nfs.log" 2>&1 || \
+	t_skip "nfs-server not available"
+
+# Keep file creation modes deterministic for the ACL golden output.
+umask 022
+
+EXPORT_OPTS="rw,async,no_root_squash,no_subtree_check,fsid=42"
+NFS_MNT="$T_TMP.nfs"
+NFS_DIR="$NFS_MNT/test/basic-nfs"
+
+filter() { sed "s@$T_TMPDIR@T_TMPDIR@g" | t_filter_fs; }
+gf() { getfacl -n --omit-header "$@" 2>/dev/null; }
+
+teardown_nfs()
+{
+	(
+		umount "$NFS_MNT"
+		exportfs -u "127.0.0.1:$T_M0"
+		exportfs -f
+		systemctl stop nfs-server
+		rmdir "$NFS_MNT"
+	) >> "$T_TMPDIR/nfs.log" 2>&1
+}
+trap teardown_nfs EXIT
+
+exportfs -u "127.0.0.1:$T_M0" >> "$T_TMPDIR/nfs.log" 2>&1 || true
+t_quiet mkdir -p "$NFS_MNT"
+exportfs -o "$EXPORT_OPTS" "127.0.0.1:$T_M0" >> "$T_TMPDIR/nfs.log" 2>&1
+mount.nfs -o vers=3,noac,actimeo=0 "127.0.0.1:$T_M0" "$NFS_MNT" >> "$T_TMPDIR/nfs.log" 2>&1
+
+test -d "$NFS_DIR" || t_fail "test dir $NFS_DIR not visible over NFS"
+
+echo "== write via NFS, read both sides"
+dd if=/dev/urandom bs=4096 count=1 of="$T_TMP.data" status=none
+cp "$T_TMP.data" "$NFS_DIR/file"
+cmp "$T_TMP.data" "$T_D0/file"
+cmp "$T_TMP.data" "$NFS_DIR/file"
+
+echo "== POSIX ACL set via NFS, read both sides"
+setfacl -m u:22222:rw "$NFS_DIR/file" 2>&1 | filter
+gf "$NFS_DIR/file"
+gf "$T_D0/file"
+
+echo "== POSIX ACL set on scoutfs, read via NFS"
+setfacl -m g:44444:r "$T_D0/file" 2>&1 | filter
+gf "$NFS_DIR/file"
+
+echo "== default ACL inheritance via NFS"
+mkdir "$NFS_DIR/d"
+setfacl -d -m u:22222:rwx "$NFS_DIR/d" 2>&1 | filter
+touch "$NFS_DIR/d/child"
+gf "$NFS_DIR/d/child"
+
+echo "== NFS read demand-stages a released file"
+dd if=/dev/urandom bs=4096 count=1 of="$T_TMP.big" status=none
+cp "$T_TMP.big" "$T_D0/big"
+sync
+vers=$(scoutfs stat -s data_version "$T_D0/big")
+t_quiet scoutfs release "$T_D0/big" -V "$vers" -o 0 -l 4K
+
+# NFS read against the offline file blocks in scoutfs_read waiting
+# for the data to come back online.
+cat "$NFS_DIR/big" > "$T_TMP.read" &
+read_pid=$!
+sleep 1
+scoutfs data-waiting -B 0 -I 0 -p "$T_D0" | wc -l
+
+t_quiet scoutfs stage "$T_TMP.big" "$T_D0/big" -V "$vers" -o 0 -l 4096
+wait "$read_pid"
+cmp "$T_TMP.big" "$T_TMP.read"
+
+echo "== cleanup"
+rm -f "$T_D0/file" "$T_D0/big"
+rm -rf "$T_D0/d"
+
+t_pass

utils/src/parse.c

@@ -160,16 +160,15 @@ int parse_timespec(char *str, struct timespec *ts)
  * Parse a quorum slot specification string "NR,ADDR,PORT" into its
  * component parts.  We use sscanf to both parse the leading NR and
  * trailing PORT integers, and to pull out the inner ADDR string which
- * is then parsed to make sure that it's a valid unicast ip address.
+ * is then parsed to make sure that it's a valid unicast ipv4 address.
  * We require that all components be specified, and sccanf will check
  * this by the number of matches it returns.
  */
 int parse_quorum_slot(struct scoutfs_quorum_slot *slot, char *arg)
 {
-#define ADDR_CHARS 45 /* (INET6_ADDRSTRLEN - 1) */
-	char addr[INET6_ADDRSTRLEN] = {'\0',};
+#define ADDR_CHARS 45 /* max ipv6 */
+	char addr[ADDR_CHARS + 1] = {'\0',};
 	struct in_addr in;
-	struct in6_addr in6;
 	int port;
 	int parsed;
 	int nr;
@@ -207,25 +206,15 @@ int parse_quorum_slot(struct scoutfs_quorum_slot *slot, char *arg)
 		return -EINVAL;
 	}
 
-	if (inet_pton(AF_INET, addr, &in) == 1) {
-		if (htonl(in.s_addr) == 0 || htonl(in.s_addr) == UINT_MAX) {
-			printf("invalid ipv4 address '%s' in quorum slot '%s'\n",
-			       addr, arg);
-			return -EINVAL;
-		}
-		slot->addr.v4.family = cpu_to_le16(SCOUTFS_AF_IPV4);
-		slot->addr.v4.addr = cpu_to_le32(htonl(in.s_addr));
-		slot->addr.v4.port = cpu_to_le16(port);
-	} else if (inet_pton(AF_INET6, addr, &in6) == 1) {
-		if (IN6_IS_ADDR_UNSPECIFIED(&in6) || IN6_IS_ADDR_MULTICAST(&in6)) {
-			printf("invalid ipv6 address '%s' in quorum slot '%s'\n",
-			       addr, arg);
-			return -EINVAL;
-		}
-		slot->addr.v6.family = cpu_to_le16(SCOUTFS_AF_IPV6);
-		memcpy(slot->addr.v6.addr, &in6, 16);
-		slot->addr.v6.port = cpu_to_le16(port);
+	if (inet_aton(addr, &in) == 0 || htonl(in.s_addr) == 0 ||
+	    htonl(in.s_addr) == UINT_MAX) {
+		printf("invalid ipv4 address '%s' in quorum slot '%s'\n",
+		       addr, arg);
+		return -EINVAL;
 	}
 
+	slot->addr.v4.family = cpu_to_le16(SCOUTFS_AF_IPV4);
+	slot->addr.v4.addr = cpu_to_le32(htonl(in.s_addr));
+	slot->addr.v4.port = cpu_to_le16(port);
 	return nr;
 }

utils/src/print.c

@@ -28,7 +28,6 @@
 #include "srch.h"
 #include "leaf_item_hash.h"
 #include "dev.h"
-#include "quorum.h"
 
 static void print_block_header(struct scoutfs_block_header *hdr, int size)
 {
@@ -401,20 +400,12 @@ static int print_mounted_client_entry(struct scoutfs_key *key, u64 seq, u8 flags
 {
 	struct scoutfs_mounted_client_btree_val *mcv = val;
 	struct in_addr in;
-	char ip6addr[INET6_ADDRSTRLEN];
 
 	memset(&in, 0, sizeof(in));
-	if (mcv->addr.v4.family == cpu_to_le16(SCOUTFS_AF_IPV4)) {
-		in.s_addr = htonl(le32_to_cpu(mcv->addr.v4.addr));
+	in.s_addr = htonl(le32_to_cpu(mcv->addr.v4.addr));
 
-		printf("    rid %016llx ipv4_addr %s flags 0x%x\n",
-		       le64_to_cpu(key->skmc_rid), inet_ntoa(in), mcv->flags);
-	} else if (mcv->addr.v6.family == cpu_to_le16(SCOUTFS_AF_IPV6)) {
-		printf("    rid %016llx ipv6_addr %s flags 0x%x\n",
-		       le64_to_cpu(key->skmc_rid),
-		       inet_ntop(AF_INET, mcv->addr.v6.addr, ip6addr, INET6_ADDRSTRLEN),
-		       mcv->flags);
-	}
+	printf("    rid %016llx ipv4_addr %s flags 0x%x\n",
+	       le64_to_cpu(key->skmc_rid), inet_ntoa(in), mcv->flags);
 
 	return 0;
 }
@@ -900,40 +891,26 @@ static int print_btree_leaf_items(int fd, struct scoutfs_super_block *super,
 static char *alloc_addr_str(union scoutfs_inet_addr *ia)
 {
 	struct in_addr addr;
-	char ip6addr[INET6_ADDRSTRLEN];
 	char *quad;
 	char *str;
 	int len;
 
-	if (le16_to_cpu(ia->v4.family) == SCOUTFS_AF_IPV4) {
-		memset(&addr, 0, sizeof(addr));
-		addr.s_addr = htonl(le32_to_cpu(ia->v4.addr));
-		quad = inet_ntoa(addr);
-		if (quad == NULL)
-			return NULL;
-
-		len = snprintf(NULL, 0, "%s:%u", quad, le16_to_cpu(ia->v4.port));
-		if (len < 1 || len > 22)
-			return NULL;
-
-		len++; /* null */
-		str = malloc(len);
-		if (!str)
-			return NULL;
-
-		snprintf(str, len, "%s:%u", quad, le16_to_cpu(ia->v4.port));
-	} else if (le16_to_cpu(ia->v6.family) == SCOUTFS_AF_IPV6) {
-		if (inet_ntop(AF_INET6, ia->v6.addr, ip6addr, INET6_ADDRSTRLEN) == NULL)
-			return NULL;
-
-		len = strlen(ip6addr) + 9; /* "[]:\0" (4) plus max strlen(u16) (5) */
-		str = malloc(len);
-		if (!str)
-			return NULL;
-
-		snprintf(str, len, "[%s]:%u", ip6addr, le16_to_cpu(ia->v6.port));
-	} else
+	memset(&addr, 0, sizeof(addr));
+	addr.s_addr = htonl(le32_to_cpu(ia->v4.addr));
+	quad = inet_ntoa(addr);
+	if (quad == NULL)
 		return NULL;
+
+	len = snprintf(NULL, 0, "%s:%u", quad, le16_to_cpu(ia->v4.port));
+	if (len < 1 || len > 22)
+		return NULL;
+
+	len++; /* null */
+	str = malloc(len);
+	if (!str)
+		return NULL;
+
+	snprintf(str, len, "%s:%u", quad, le16_to_cpu(ia->v4.port));
 	return str;
 }
 
@@ -1049,7 +1026,7 @@ static void print_super_block(struct scoutfs_super_block *super, u64 blkno)
 	printf("  quorum config version %llu\n",
 		le64_to_cpu(super->qconf.version));
 	for (i = 0; i < array_size(super->qconf.slots); i++) {
-		if (!quorum_slot_present(super, i))
+		if (super->qconf.slots[i].addr.v4.family != cpu_to_le16(SCOUTFS_AF_IPV4))
 			continue;
 
 		addr = alloc_addr_str(&super->qconf.slots[i].addr);

utils/src/quorum.c

@@ -10,8 +10,7 @@
 
 bool quorum_slot_present(struct scoutfs_super_block *super, int i)
 {
-	return ((super->qconf.slots[i].addr.v4.family == cpu_to_le16(SCOUTFS_AF_IPV4)) ||
-		(super->qconf.slots[i].addr.v6.family == cpu_to_le16(SCOUTFS_AF_IPV6)));
+	return super->qconf.slots[i].addr.v4.family == cpu_to_le16(SCOUTFS_AF_IPV4);
 }
 
 bool valid_quorum_slots(struct scoutfs_quorum_slot *slots)
@@ -19,57 +18,35 @@ bool valid_quorum_slots(struct scoutfs_quorum_slot *slots)
 	struct in_addr in;
 	bool valid = true;
 	char *addr;
-	char ip6addr[INET6_ADDRSTRLEN];
-	__le16 family = cpu_to_le16(SCOUTFS_AF_NONE);
 	int i;
 	int j;
 
 	for (i = 0; i < SCOUTFS_QUORUM_MAX_SLOTS; i++) {
-		if (slots[i].addr.v4.family == cpu_to_le16(SCOUTFS_AF_IPV4)) {
-			if (family == cpu_to_le16(SCOUTFS_AF_NONE)) {
-				family = cpu_to_le16(SCOUTFS_AF_IPV4);
-			} else if (family != cpu_to_le16(SCOUTFS_AF_IPV4)) {
-				fprintf(stderr, "quorum slot nr %u is IPv4 but earlier slots are IPv6; mixed IPv4/IPv6 quorum is not supported\n",
-					i);
-				valid = false;
-			}
+		if (slots[i].addr.v4.family == cpu_to_le16(SCOUTFS_AF_NONE))
+			continue;
 
-			for (j = i + 1; j < SCOUTFS_QUORUM_MAX_SLOTS; j++) {
-				if (slots[i].addr.v4.addr == slots[j].addr.v4.addr &&
-				    slots[i].addr.v4.port == slots[j].addr.v4.port) {
-					in.s_addr =
-						htonl(le32_to_cpu(slots[i].addr.v4.addr));
-					addr = inet_ntoa(in);
-					fprintf(stderr, "quorum slot nr %u and %u have the same address %s:%u\n",
-						i, j, addr,
-						le16_to_cpu(slots[i].addr.v4.port));
-					valid = false;
-				}
-			}
-		} else if (slots[i].addr.v6.family == cpu_to_le16(SCOUTFS_AF_IPV6)) {
-			if (family == cpu_to_le16(SCOUTFS_AF_NONE)) {
-				family = cpu_to_le16(SCOUTFS_AF_IPV6);
-			} else if (family != cpu_to_le16(SCOUTFS_AF_IPV6)) {
-				fprintf(stderr, "quorum slot nr %u is IPv6 but earlier slots are IPv4; mixed IPv4/IPv6 quorum is not supported\n",
-					i);
-				valid = false;
-			}
-
-			for (j = i + 1; j < SCOUTFS_QUORUM_MAX_SLOTS; j++) {
-				if ((IN6_ARE_ADDR_EQUAL(slots[i].addr.v6.addr, slots[j].addr.v6.addr)) &&
-				    (slots[i].addr.v6.port == slots[j].addr.v6.port)) {
-					fprintf(stderr, "quorum slot nr %u and %u have the same address [%s]:%u\n",
-						i, j,
-						inet_ntop(AF_INET6, slots[i].addr.v6.addr, ip6addr, INET6_ADDRSTRLEN),
-						le16_to_cpu(slots[i].addr.v6.port));
-					valid = false;
-				}
-			}
-		} else if (slots[i].addr.v6.family != cpu_to_le16(SCOUTFS_AF_NONE)) {
+		if (slots[i].addr.v4.family != cpu_to_le16(SCOUTFS_AF_IPV4)) {
 			fprintf(stderr, "quorum slot nr %u has invalid family %u\n",
 				i, le16_to_cpu(slots[i].addr.v4.family));
 			valid = false;
 		}
+
+		for (j = i + 1; j < SCOUTFS_QUORUM_MAX_SLOTS; j++) {
+			if (slots[i].addr.v4.family != cpu_to_le16(SCOUTFS_AF_IPV4))
+				continue;
+
+			if (slots[i].addr.v4.addr == slots[j].addr.v4.addr &&
+			    slots[i].addr.v4.port == slots[j].addr.v4.port) {
+
+				in.s_addr =
+					htonl(le32_to_cpu(slots[i].addr.v4.addr));
+				addr = inet_ntoa(in);
+				fprintf(stderr, "quorum slot nr %u and %u have the same address %s:%u\n",
+					i, j, addr,
+					le16_to_cpu(slots[i].addr.v4.port));
+				valid = false;
+			}
+		}
 	}
 
 	return valid;
@@ -84,23 +61,19 @@ void print_quorum_slots(struct scoutfs_quorum_slot *slots, int nr, char *indent)
 {
 	struct scoutfs_quorum_slot *sl;
 	struct in_addr in;
-	char ip6addr[INET6_ADDRSTRLEN];
 	bool first = true;
 	int i;
 
 	for (i = 0, sl = slots; i < SCOUTFS_QUORUM_MAX_SLOTS; i++, sl++) {
-		if (sl->addr.v4.family == cpu_to_le16(SCOUTFS_AF_IPV4)) {
-			in.s_addr = htonl(le32_to_cpu(sl->addr.v4.addr));
-			printf("%s%u: %s:%u\n", first ? "" : indent,
-			       i, inet_ntoa(in), le16_to_cpu(sl->addr.v4.port));
 
-			first = false;
-		} else if (sl->addr.v6.family == cpu_to_le16(SCOUTFS_AF_IPV6)) {
-			printf("%s%u: [%s]:%u\n", first ? "" : indent, i,
-				inet_ntop(AF_INET6, sl->addr.v6.addr, ip6addr, INET6_ADDRSTRLEN),
-				le16_to_cpu(sl->addr.v6.port));
-			first = false;
-		}
+		if (sl->addr.v4.family != cpu_to_le16(SCOUTFS_AF_IPV4))
+			continue;
+
+		in.s_addr = htonl(le32_to_cpu(sl->addr.v4.addr));
+		printf("%s%u: %s:%u\n", first ? "" : indent,
+		       i, inet_ntoa(in), le16_to_cpu(sl->addr.v4.port));
+
+		first = false;
 	}
 }