Enable and Disable correct unit tests for O_DIRECT

Signed-off-by: Bryant G. Duffy-Ly <bduffyly@versity.com>

ReleaseNotes.md

@@ -2,120 +2,9 @@ Versity ScoutFS Release Notes
 =============================
 
 ---
-v1.8
+v1.3-rc
 \
-*Oct 18, 2022*
-
-Add support for Linux POSIX Access Control Lists, as described in
-acl(5).  Mount options are added to enable ("acl") and disable ("noacl")
-support.  The default is to support ACLs.  ACLs are stored in the
-existing extended attribute scheme so adding support is does not require
-a format change.
-
-Add options to control data extent preallocation.  The default behavior
-does not change.  The options can relax the limits on preallocation
-which will then trigger under more write patterns and increase the risk
-of preallocated space which is never used.  The options are described in
-scoutfs(5).
-
----
-v1.7
-\
-*Aug 26, 2022*
-
-* **Fixed possible persistent errors moving freed data extents**
-\
-  Fixed a case where the server could hit persistent errors trying to
-  move a client's freed extents in one commit.  The client had to free
-  a large number of extents that occupied distant positions in the
-  global free extent btree.  Very large fragmented files could cause
-  this.  The server now moves the freed extents in multiple commits and
-  can always ensure forward progress.
-
-* **Fixed possible persistent errors from freed duplicate extents**
-\
-  Background orphan deletion wasn't properly synchronizing with
-  foreground tasks deleting very large files.  If a deletion took long
-  enough then background deletion could also attempt to delete inode items
-  while the deletion was making progress.  This could create duplicate
-  deletions of data extent items which causes the server to abort when
-  it later discovers the duplicate extents as it merges free lists.
-
----
-v1.6
-\
-*Jul 7, 2022*
-
-* **Fix memory leaks in rare corner cases**
-\
-  Analysis tools found a few corner cases that leaked small structures,
-  generally around error handling or startup and shutdown.
-
-* **Add --skip-likely-huge scoutfs print command option**
-\
-  Add an option to scoutfs print to reduce the size of the output
-  so that it can be used to see system-wide metadata without being
-  overwhelmed by file-level details.
-
----
-v1.5
-\
-*Jun 21, 2022*
-
-* **Fix persistent error during server startup**
-\
-  Fixed a case where the server would always hit a consistent error on
-  seartup, preventing the system from mounting.  This required a rare
-  but valid state across the clients.
-
-* **Fix a client hang that would lead to fencing**
-\
-  The client module's use of in-kernel networking was missing annotation
-  that could lead to communication hanging.  The server would fence the
-  client when it stopped communicating.  This could be identified by the
-  server fencing a client after it disconnected with no attempt by the
-  client to reconnect.
-
----
-v1.4
-\
-*May 6, 2022*
-
-* **Fix possible client crash during server failover**
-\
-  Fixed a narrow window during server failover and lock recovery that
-  could cause a client mount to believe that it had an inconsistent item
-  cache and panic.  This required very specific lock state and messaging
-  patterns between multiple mounts and multiple servers which made it
-  unlikely to occur in the field.
-
----
-v1.3
-\
-*Apr 7, 2022*
-
-* **Fix rare server instability under heavy load**
-\
-  Fixed a case of server instability under heavy load due to concurrent
-  work fully exhausting metadata block allocation pools reserved for a
-  single server transaction.  This would cause brief interruption as the
-  server shutdown and the next server started up and made progress as
-  pending work was retried.
-
-* **Fix slow fencing preventing server startup**
-\
-  If a server had to process many fence requests with a slow fencing
-  mechanism it could be interrupted before it finished.  The server
-  now makes sure heartbeat messages are sent while it is making progress
-  on fencing requests so that other quorum members don't interrupt the
-  process.
-
-* **Performance improvement in getxattr and setxattr**
-\
-  Kernel allocation patterns in the getxattr and setxattr
-  implementations were causing significant contention between CPUs.  Their
-  allocation strategy was changed so that concurrent tasks can call these
-  xattr methods without degrading performance.
+*TBD*
 
 ---
 v1.2

kmod/src/Makefile

@@ -8,7 +8,6 @@ CFLAGS_scoutfs_trace.o = -I$(src) # define_trace.h double include
 -include $(src)/Makefile.kernelcompat
  
 scoutfs-y +=			\
-	acl.o			\
 	avl.o			\
 	alloc.o			\
 	block.o			\

kmod/src/Makefile.kernelcompat

@@ -34,12 +34,3 @@ endif
 ifneq (,$(shell grep 'FMODE_KABI_ITERATE' include/linux/fs.h))
 ccflags-y += -DKC_FMODE_KABI_ITERATE
 endif
-
-#
-# v4.7-rc2-23-g0d4d717f2583
-#
-# Added user_ns argument to posix_acl_valid
-#
-ifneq (,$(shell grep 'posix_acl_valid.*user_ns,' include/linux/posix_acl.h))
-ccflags-y += -DKC_POSIX_ACL_VALID_USER_NS
-endif

kmod/src/acl.c

@@ -1,355 +0,0 @@
-/*
- * Copyright (C) 2022 Versity Software, Inc.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-#include <linux/kernel.h>
-#include <linux/fs.h>
-#include <linux/slab.h>
-#include <linux/xattr.h>
-#include <linux/posix_acl.h>
-#include <linux/posix_acl_xattr.h>
-
-#include "format.h"
-#include "super.h"
-#include "scoutfs_trace.h"
-#include "xattr.h"
-#include "acl.h"
-#include "inode.h"
-#include "trans.h"
-
-/*
- * POSIX draft ACLs are stored as full xattr items with the entries
- * encoded as the kernel's posix_acl_xattr_{header,entry} value structs.
- *
- * They're accessed and modified via user facing synthetic xattrs, iops
- * calls from the kernel, during inode mode changes, and during inode
- * creation.
- *
- * ACL access devolves into xattr access which is relatively expensive
- * so we maintain the cached native form in the vfs inode.  We drop the
- * cache in lock invalidation which means that cached acl access must
- * always be performed under cluster locking.
- */
-
-static int acl_xattr_name_len(int type, char **name, size_t *name_len)
-{
-	int ret = 0;
-
-	switch (type) {
-	case ACL_TYPE_ACCESS:
-		*name = XATTR_NAME_POSIX_ACL_ACCESS;
-		if (name_len)
-			*name_len = sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1;
-		break;
-	case ACL_TYPE_DEFAULT:
-		*name = XATTR_NAME_POSIX_ACL_DEFAULT;
-		if (name_len)
-			*name_len = sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1;
-		break;
-	default:
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-struct posix_acl *scoutfs_get_acl_locked(struct inode *inode, int type, struct scoutfs_lock *lock)
-{
-	struct posix_acl *acl;
-	char *value = NULL;
-	char *name;
-	int ret;
-
-	if (!IS_POSIXACL(inode))
-		return NULL;
-
-	acl = get_cached_acl(inode, type);
-	if (acl != ACL_NOT_CACHED)
-		return acl;
-
-	ret = acl_xattr_name_len(type, &name, NULL);
-	if (ret < 0)
-		return ERR_PTR(ret);
-
-	ret = scoutfs_xattr_get_locked(inode, name, NULL, 0, lock);
-	if (ret > 0) {
-		value = kzalloc(ret, GFP_NOFS);
-		if (!value)
-			ret = -ENOMEM;
-		else
-			ret = scoutfs_xattr_get_locked(inode, name, value, ret, lock);
-	}
-	if (ret > 0) {
-		acl = posix_acl_from_xattr(&init_user_ns, value, ret);
-	} else if (ret == -ENODATA || ret == 0) {
-		acl = NULL;
-	} else {
-		acl = ERR_PTR(ret);
-	}
-
-	/* can set null negative cache */
-	if (!IS_ERR(acl))
-		set_cached_acl(inode, type, acl);
-
-	kfree(value);
-
-	return acl;
-}
-
-struct posix_acl *scoutfs_get_acl(struct inode *inode, int type)
-{
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *lock = NULL;
-	struct posix_acl *acl;
-	int ret;
-
-	if (!IS_POSIXACL(inode))
-		return NULL;
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ, 0, inode, &lock);
-	if (ret < 0) {
-		acl = ERR_PTR(ret);
-	} else {
-		acl = scoutfs_get_acl_locked(inode, type, lock);
-		scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
-	}
-
-	return acl;
-}
-
-/*
- * The caller has acquired the locks and dirtied the inode, they'll
- * update the inode item if we return 0.
- */
-int scoutfs_set_acl_locked(struct inode *inode, struct posix_acl *acl, int type,
-			   struct scoutfs_lock *lock, struct list_head *ind_locks)
-{
-	static const struct scoutfs_xattr_prefix_tags tgs = {0,}; /* never scoutfs. prefix */
-	bool set_mode = false;
-	char *value = NULL;
-	umode_t new_mode;
-	size_t name_len;
-	char *name;
-	int size = 0;
-	int ret;
-
-	ret = acl_xattr_name_len(type, &name, &name_len);
-	if (ret < 0)
-		return ret;
-
-	switch (type) {
-	case ACL_TYPE_ACCESS:
-		if (acl) {
-			ret = posix_acl_update_mode(inode, &new_mode, &acl);
-			if (ret < 0)
-				goto out;
-			set_mode = true;
-		}
-		break;
-	case ACL_TYPE_DEFAULT:
-		if (!S_ISDIR(inode->i_mode)) {
-			ret = acl ? -EINVAL : 0;
-			goto out;
-		}
-		break;
-	}
-
-	if (acl) {
-		size = posix_acl_xattr_size(acl->a_count);
-		value = kmalloc(size, GFP_NOFS);
-		if (!value) {
-			ret = -ENOMEM;
-			goto out;
-		}
-
-		ret = posix_acl_to_xattr(&init_user_ns, acl, value, size);
-		if (ret < 0)
-			goto out;
-	}
-
-	ret = scoutfs_xattr_set_locked(inode, name, name_len, value, size, 0, &tgs,
-				       lock, NULL, ind_locks);
-	if (ret == 0 && set_mode) {
-		inode->i_mode = new_mode;
-		if (!value) {
-			/* can be setting an acl that only affects mode, didn't need xattr */
-			inode_inc_iversion(inode);
-			inode->i_ctime = CURRENT_TIME;
-		}
-	}
-
-out:
-	if (!ret)
-		set_cached_acl(inode, type, acl);
-
-	kfree(value);
-
-	return ret;
-}
-
-int scoutfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
-{
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *lock = NULL;
-	LIST_HEAD(ind_locks);
-	int ret;
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE, SCOUTFS_LKF_REFRESH_INODE, inode, &lock) ?:
-	      scoutfs_inode_index_lock_hold(inode, &ind_locks, false, true);
-	if (ret == 0) {
-		ret = scoutfs_dirty_inode_item(inode, lock) ?:
-		      scoutfs_set_acl_locked(inode, acl, type, lock, &ind_locks);
-		if (ret == 0)
-			scoutfs_update_inode_item(inode, lock, &ind_locks);
-
-		scoutfs_release_trans(sb);
-		scoutfs_inode_index_unlock(sb, &ind_locks);
-	}
-
-	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
-	return ret;
-}
-
-int scoutfs_acl_get_xattr(struct dentry *dentry, const char *name, void *value, size_t size,
-			  int type)
-{
-	struct posix_acl *acl;
-	int ret = 0;
-
-	if (!IS_POSIXACL(dentry->d_inode))
-		return -EOPNOTSUPP;
-
-	acl = scoutfs_get_acl(dentry->d_inode, type);
-	if (IS_ERR(acl))
-		return PTR_ERR(acl);
-	if (acl == NULL)
-		return -ENODATA;
-
-	ret = posix_acl_to_xattr(&init_user_ns, acl, value, size);
-	posix_acl_release(acl);
-
-	return ret;
-}
-
-int scoutfs_acl_set_xattr(struct dentry *dentry, const char *name, const void *value, size_t size,
-			  int flags, int type)
-{
-	struct posix_acl *acl = NULL;
-	int ret;
-
-	if (!inode_owner_or_capable(dentry->d_inode))
-		return -EPERM;
-
-	if (!IS_POSIXACL(dentry->d_inode))
-		return -EOPNOTSUPP;
-
-	if (value) {
-		acl = posix_acl_from_xattr(&init_user_ns, value, size);
-		if (IS_ERR(acl))
-			return PTR_ERR(acl);
-
-		if (acl) {
-			ret = kc_posix_acl_valid(&init_user_ns, acl);
-			if (ret)
-				goto out;
-		}
-	}
-
-	ret = scoutfs_set_acl(dentry->d_inode, acl, type);
-out:
-	posix_acl_release(acl);
-
-	return ret;
-}
-
-/*
- * Apply the parent's default acl to new inodes access acl and inherit
- * it as the default for new directories.  The caller holds locks and a
- * transaction.
- */
-int scoutfs_init_acl_locked(struct inode *inode, struct inode *dir,
-			    struct scoutfs_lock *lock, struct scoutfs_lock *dir_lock,
-			    struct list_head *ind_locks)
-{
-	struct posix_acl *acl = NULL;
-	int ret = 0;
-
-	if (!S_ISLNK(inode->i_mode)) {
-		if (IS_POSIXACL(dir)) {
-			acl = scoutfs_get_acl_locked(dir, ACL_TYPE_DEFAULT, dir_lock);
-			if (IS_ERR(acl))
-				return PTR_ERR(acl);
-		}
-
-		if (!acl)
-			inode->i_mode &= ~current_umask();
-	}
-
-	if (IS_POSIXACL(dir) && acl) {
-		if (S_ISDIR(inode->i_mode)) {
-			ret = scoutfs_set_acl_locked(inode, acl, ACL_TYPE_DEFAULT,
-						     lock, ind_locks);
-			if (ret)
-				goto out;
-		}
-		ret = posix_acl_create(&acl, GFP_NOFS, &inode->i_mode);
-		if (ret < 0)
-			return ret;
-		if (ret > 0)
-			ret = scoutfs_set_acl_locked(inode, acl, ACL_TYPE_ACCESS,
-						     lock, ind_locks);
-	} else {
-		cache_no_acl(inode);
-	}
-out:
-	posix_acl_release(acl);
-	return ret;
-}
-
-/*
- * Update the access ACL based on a newly set mode.  If we return an
- * error then the xattr wasn't changed.
- *
- * Annoyingly, setattr_copy has logic that transforms the final set mode
- * that we want to use to update the acl.   But we don't want to modify
- * the other inode fields while discovering the resulting mode.  We're
- * relying on acl_chmod not caring about the transformation (currently
- * just clears sgid).  It would be better if we could get the resulting
- * mode to give to acl_chmod without modifying the other inode fields.
- *
- * The caller has the inode mutex, a cluster lock, transaction, and will
- * update the inode item if we return success.
- */
-int scoutfs_acl_chmod_locked(struct inode *inode, struct iattr *attr,
-			     struct scoutfs_lock *lock, struct list_head *ind_locks)
-{
-	struct posix_acl *acl;
-	int ret = 0;
-
-	if (!IS_POSIXACL(inode) || !(attr->ia_valid & ATTR_MODE))
-		return 0;
-
-	if (S_ISLNK(inode->i_mode))
-		return -EOPNOTSUPP;
-
-	acl = scoutfs_get_acl_locked(inode, ACL_TYPE_ACCESS, lock);
-	if (IS_ERR_OR_NULL(acl))
-		return PTR_ERR(acl);
-
-	ret = posix_acl_chmod(&acl, GFP_KERNEL, attr->ia_mode);
-	if (ret)
-		return ret;
-
-	ret = scoutfs_set_acl_locked(inode, acl, ACL_TYPE_ACCESS, lock, ind_locks);
-	posix_acl_release(acl);
-	return ret;
-}

kmod/src/acl.h

@@ -1,18 +0,0 @@
-#ifndef _SCOUTFS_ACL_H_
-#define _SCOUTFS_ACL_H_
-
-struct posix_acl *scoutfs_get_acl(struct inode *inode, int type);
-struct posix_acl *scoutfs_get_acl_locked(struct inode *inode, int type, struct scoutfs_lock *lock);
-int scoutfs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
-int scoutfs_set_acl_locked(struct inode *inode, struct posix_acl *acl, int type,
-			   struct scoutfs_lock *lock, struct list_head *ind_locks);
-int scoutfs_acl_get_xattr(struct dentry *dentry, const char *name, void *value, size_t size,
-			  int type);
-int scoutfs_acl_set_xattr(struct dentry *dentry, const char *name, const void *value, size_t size,
-			  int flags, int type);
-int scoutfs_acl_chmod_locked(struct inode *inode, struct iattr *attr,
-			     struct scoutfs_lock *lock, struct list_head *ind_locks);
-int scoutfs_init_acl_locked(struct inode *inode, struct inode *dir,
-			    struct scoutfs_lock *lock, struct scoutfs_lock *dir_lock,
-			    struct list_head *ind_locks);
-#endif

kmod/src/alloc.c

@@ -84,21 +84,6 @@ static u64 smallest_order_length(u64 len)
 	return 1ULL << (free_extent_order(len) * 3);
 }
 
-/*
- * An extent modification dirties three distinct leaves of an allocator
- * btree as it adds and removes the blkno and size sorted items for the
- * old and new lengths of the extent.  Dirtying the paths to these
- * leaves can grow the tree and grow/shrink neighbours at each level.
- * We over-estimate the number of blocks allocated and freed (the paths
- * share a root, growth doesn't free) to err on the simpler and safer
- * side.  The overhead is minimal given the relatively large list blocks
- * and relatively short allocator trees.
- */
-static u32 extent_mod_blocks(u32 height)
-{
-	return ((1 + height) * 2) * 3;
-}
-
 /*
  * Free extents don't have flags and are stored in two indexes sorted by
  * block location and by length order, largest first.  The location key
@@ -892,13 +877,6 @@ static int find_zone_extent(struct super_block *sb, struct scoutfs_alloc_root *r
  * -ENOENT is returned if we run out of extents in the source tree
  * before moving the total.
  *
- * If meta_budget is non-zero then -EINPROGRESS can be returned if the
- * the caller's budget is consumed in the allocator during this call
- * (though not necessarily by us, we don't have per-thread tracking of
- * allocator consumption :/).  The call can still have made progress and
- * caller is expected commit the dirty trees and examining the resulting
- * modified trees to see if they need to continue moving extents.
- *
  * The caller can specify that extents in the source tree should first
  * be found based on their zone bitmaps.  We'll first try to find
  * extents in the exclusive zones, then vacant zones, and then we'll
@@ -913,7 +891,7 @@ int scoutfs_alloc_move(struct super_block *sb, struct scoutfs_alloc *alloc,
 		       struct scoutfs_block_writer *wri,
 		       struct scoutfs_alloc_root *dst,
 		       struct scoutfs_alloc_root *src, u64 total,
-		       __le64 *exclusive, __le64 *vacant, u64 zone_blocks, u64 meta_budget)
+		       __le64 *exclusive, __le64 *vacant, u64 zone_blocks)
 {
 	struct alloc_ext_args args = {
 		.alloc = alloc,
@@ -921,8 +899,6 @@ int scoutfs_alloc_move(struct super_block *sb, struct scoutfs_alloc *alloc,
 	};
 	struct scoutfs_extent found;
 	struct scoutfs_extent ext;
-	u32 avail_start = 0;
-	u32 freed_start = 0;
 	u64 moved = 0;
 	u64 count;
 	int ret = 0;
@@ -933,9 +909,6 @@ int scoutfs_alloc_move(struct super_block *sb, struct scoutfs_alloc *alloc,
 		vacant = NULL;
 	}
 
-	if (meta_budget != 0)
-		scoutfs_alloc_meta_remaining(alloc, &avail_start, &freed_start);
-
 	while (moved < total) {
 		count = total - moved;
 
@@ -968,14 +941,6 @@ int scoutfs_alloc_move(struct super_block *sb, struct scoutfs_alloc *alloc,
 		if (ret < 0)
 			break;
 
-		if (meta_budget != 0 &&
-		    scoutfs_alloc_meta_low_since(alloc, avail_start, freed_start, meta_budget,
-						 extent_mod_blocks(src->root.height) +
-						 extent_mod_blocks(dst->root.height))) {
-			ret = -EINPROGRESS;
-			break;
-		}
-
 		/* searching set start/len, finish initializing alloced extent */
 		ext.map = found.map ? ext.start - found.start + found.map : 0;
 		ext.flags = found.flags;
@@ -1100,6 +1065,15 @@ out:
  * than completely exhausting the avail list or overflowing the freed
  * list.
  *
+ * An extent modification dirties three distinct leaves of an allocator
+ * btree as it adds and removes the blkno and size sorted items for the
+ * old and new lengths of the extent.  Dirtying the paths to these
+ * leaves can grow the tree and grow/shrink neighbours at each level.
+ * We over-estimate the number of blocks allocated and freed (the paths
+ * share a root, growth doesn't free) to err on the simpler and safer
+ * side.  The overhead is minimal given the relatively large list blocks
+ * and relatively short allocator trees.
+ *
  * The caller tells us how many extents they're about to modify and how
  * many other additional blocks they may cow manually.  And finally, the
  * caller could be the first to dirty the avail and freed blocks in the
@@ -1108,7 +1082,7 @@ out:
 static bool list_has_blocks(struct super_block *sb, struct scoutfs_alloc *alloc,
 			    struct scoutfs_alloc_root *root, u32 extents, u32 addl_blocks)
 {
-	u32 tree_blocks = extent_mod_blocks(root->root.height) * extents;
+	u32 tree_blocks = (((1 + root->root.height) * 2) * 3) * extents;
 	u32 most = 1 + tree_blocks + addl_blocks;
 
 	if (le32_to_cpu(alloc->avail.first_nr) < most) {
@@ -1344,38 +1318,6 @@ bool scoutfs_alloc_meta_low(struct super_block *sb,
 	return lo;
 }
 
-void scoutfs_alloc_meta_remaining(struct scoutfs_alloc *alloc, u32 *avail_total, u32 *freed_space)
-{
-	unsigned int seq;
-
-	do {
-		seq = read_seqbegin(&alloc->seqlock);
-		*avail_total = le32_to_cpu(alloc->avail.first_nr);
-		*freed_space = list_block_space(alloc->freed.first_nr);
-	} while (read_seqretry(&alloc->seqlock, seq));
-}
-
-/*
- * Returns true if the caller's consumption of nr from either avail or
- * freed would end up exceeding their budget relative to the starting
- * remaining snapshot they took.
- */
-bool scoutfs_alloc_meta_low_since(struct scoutfs_alloc *alloc, u32 avail_start, u32 freed_start,
-				  u32 budget, u32 nr)
-{
-	u32 avail_use;
-	u32 freed_use;
-	u32 avail;
-	u32 freed;
-
-	scoutfs_alloc_meta_remaining(alloc, &avail, &freed);
-
-	avail_use = avail_start - avail;
-	freed_use = freed_start - freed;
-
-	return ((avail_use + nr) > budget) || ((freed_use + nr) > budget);
-}
-
 bool scoutfs_alloc_test_flag(struct super_block *sb,
 			    struct scoutfs_alloc *alloc, u32 flag)
 {

kmod/src/alloc.h

@@ -19,11 +19,14 @@
 	(128ULL * 1024 * 1024 >> SCOUTFS_BLOCK_SM_SHIFT)
 
 /*
- * The default size that we'll try to preallocate.  This is trying to
- * hit the limit of large efficient device writes while minimizing
- * wasted preallocation that is never used.
+ * The largest aligned region that we'll try to allocate at the end of
+ * the file as it's extended.  This is also limited to the current file
+ * size so we can only waste at most twice the total file size when
+ * files are less than this.  We try to keep this around the point of
+ * diminishing returns in streaming performance of common data devices
+ * to limit waste.
  */
-#define SCOUTFS_DATA_PREALLOC_DEFAULT_BLOCKS \
+#define SCOUTFS_DATA_EXTEND_PREALLOC_LIMIT \
 	(8ULL * 1024 * 1024 >> SCOUTFS_BLOCK_SM_SHIFT)
 
 /*
@@ -128,7 +131,7 @@ int scoutfs_alloc_move(struct super_block *sb, struct scoutfs_alloc *alloc,
 		       struct scoutfs_block_writer *wri,
 		       struct scoutfs_alloc_root *dst,
 		       struct scoutfs_alloc_root *src, u64 total,
-		       __le64 *exclusive, __le64 *vacant, u64 zone_blocks, u64 meta_budget);
+		       __le64 *exclusive, __le64 *vacant, u64 zone_blocks);
 int scoutfs_alloc_insert(struct super_block *sb, struct scoutfs_alloc *alloc,
 			 struct scoutfs_block_writer *wri, struct scoutfs_alloc_root *root,
 			 u64 start, u64 len);
@@ -155,9 +158,6 @@ int scoutfs_alloc_splice_list(struct super_block *sb,
 
 bool scoutfs_alloc_meta_low(struct super_block *sb,
 			    struct scoutfs_alloc *alloc, u32 nr);
-void scoutfs_alloc_meta_remaining(struct scoutfs_alloc *alloc, u32 *avail_total, u32 *freed_space);
-bool scoutfs_alloc_meta_low_since(struct scoutfs_alloc *alloc, u32 avail_start, u32 freed_start,
-				  u32 budget, u32 nr);
 bool scoutfs_alloc_test_flag(struct super_block *sb,
 			    struct scoutfs_alloc *alloc, u32 flag);
 

kmod/src/btree.c

@@ -2449,7 +2449,7 @@ int scoutfs_btree_free_blocks(struct super_block *sb,
 			      struct scoutfs_alloc *alloc,
 			      struct scoutfs_block_writer *wri,
 			      struct scoutfs_key *key,
-			      struct scoutfs_btree_root *root, int free_budget)
+			      struct scoutfs_btree_root *root, int alloc_low)
 {
 	u64 blknos[SCOUTFS_BTREE_MAX_HEIGHT];
 	struct scoutfs_block *bl = NULL;
@@ -2459,15 +2459,11 @@ int scoutfs_btree_free_blocks(struct super_block *sb,
 	struct scoutfs_avl_node *node;
 	struct scoutfs_avl_node *next;
 	struct scoutfs_key par_next;
-	int nr_freed = 0;
 	int nr_par;
 	int level;
 	int ret;
 	int i;
 
-	if (WARN_ON_ONCE(free_budget <= 0))
-		return -EINVAL;
-
 	if (WARN_ON_ONCE(root->height > ARRAY_SIZE(blknos)))
 		return -EIO; /* XXX corruption */
 
@@ -2542,7 +2538,8 @@ int scoutfs_btree_free_blocks(struct super_block *sb,
 		while (node) {
 
 			/* make sure we can always free parents after leaves */
-			if ((nr_freed + 1 + nr_par) > free_budget) {
+			if (scoutfs_alloc_meta_low(sb, alloc,
+						   alloc_low + nr_par + 1)) {
 				ret = 0;
 				goto out;
 			}
@@ -2556,7 +2553,6 @@ int scoutfs_btree_free_blocks(struct super_block *sb,
 						le64_to_cpu(ref.blkno));
 			if (ret < 0)
 				goto out;
-			nr_freed++;
 
 			node = scoutfs_avl_next(&bt->item_root, node);
 			if (node) {
@@ -2572,7 +2568,6 @@ int scoutfs_btree_free_blocks(struct super_block *sb,
 							       blknos[i]);
 			ret = scoutfs_free_meta(sb, alloc, wri, blknos[i]);
 			BUG_ON(ret); /* checked meta low, freed should fit */
-			nr_freed++;
 		}
 
 		/* restart walk past the subtree we just freed */

kmod/src/btree.h

@@ -125,7 +125,7 @@ int scoutfs_btree_free_blocks(struct super_block *sb,
 			      struct scoutfs_alloc *alloc,
 			      struct scoutfs_block_writer *wri,
 			      struct scoutfs_key *key,
-			      struct scoutfs_btree_root *root, int free_budget);
+			      struct scoutfs_btree_root *root, int alloc_low);
 
 void scoutfs_btree_put_iref(struct scoutfs_btree_item_ref *iref);
 

kmod/src/counters.h

@@ -157,7 +157,6 @@
 	EXPAND_COUNTER(orphan_scan_error)			\
 	EXPAND_COUNTER(orphan_scan_item)			\
 	EXPAND_COUNTER(orphan_scan_omap_set)			\
-	EXPAND_COUNTER(quorum_candidate_server_stopping)	\
 	EXPAND_COUNTER(quorum_elected)				\
 	EXPAND_COUNTER(quorum_fence_error)			\
 	EXPAND_COUNTER(quorum_fence_leader)			\

kmod/src/data.c

@@ -21,6 +21,7 @@
 #include <linux/log2.h>
 #include <linux/falloc.h>
 #include <linux/writeback.h>
+#include <linux/aio.h>
 
 #include "format.h"
 #include "super.h"
@@ -366,27 +367,27 @@ static inline u64 ext_last(struct scoutfs_extent *ext)
 
 /*
  * The caller is writing to a logical iblock that doesn't have an
- * allocated extent.  The caller has searched for an extent containing
- * iblock.  If it already existed then it must be unallocated and
- * offline.
+ * allocated extent.
  *
- * We implement two preallocation strategies.  Typically we only
- * preallocate for simple streaming writes and limit preallocation while
- * the file is small.   The largest efficient allocation size is
- * typically large enough that it would be unreasonable to allocate that
- * much for all small files.
+ * We always allocate an extent starting at the logical iblock.  The
+ * caller has searched for an extent containing iblock.  If it already
+ * existed then it must be unallocated and offline.
  *
- * Optionally, we can simply preallocate large empty aligned regions.
- * This can waste a lot of space for small or sparse files but is
- * reasonable when a file population is known to be large and dense but
- * known to be written with non-streaming write patterns.
+ * Preallocation is used if we're strictly contiguously extending
+ * writes.  That is, if the logical block offset equals the number of
+ * online blocks.  We try to preallocate the number of blocks existing
+ * so that small files don't waste inordinate amounts of space and large
+ * files will eventually see large extents.  This only works for
+ * contiguous single stream writes or stages of files from the first
+ * block.  It doesn't work for concurrent stages, releasing behind
+ * staging, sparse files, multi-node writes, etc.  fallocate() is always
+ * a better tool to use.
  */
 static int alloc_block(struct super_block *sb, struct inode *inode,
 		       struct scoutfs_extent *ext, u64 iblock,
 		       struct scoutfs_lock *lock)
 {
 	DECLARE_DATA_INFO(sb, datinf);
-	struct scoutfs_mount_options opts;
 	const u64 ino = scoutfs_ino(inode);
 	struct data_ext_args args = {
 		.ino = ino,
@@ -394,22 +395,17 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 		.lock = lock,
 	};
 	struct scoutfs_extent found;
-	struct scoutfs_extent pre = {0,};
-	bool undo_pre = false;
+	struct scoutfs_extent pre;
 	u64 blkno = 0;
 	u64 online;
 	u64 offline;
 	u8 flags;
-	u64 start;
 	u64 count;
-	u64 rem;
 	int ret;
 	int err;
 
 	trace_scoutfs_data_alloc_block_enter(sb, ino, iblock, ext);
 
-	scoutfs_options_read(sb, &opts);
-
 	/* can only allocate over existing unallocated offline extent */
 	if (WARN_ON_ONCE(ext->len &&
 			 !(iblock >= ext->start && iblock <= ext_last(ext) &&
@@ -418,106 +414,67 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 
 	mutex_lock(&datinf->mutex);
 
-	/* default to single allocation at the written block */
-	start = iblock;
-	count = 1;
-	/* copy existing flags for preallocated regions */
-	flags = ext->len ? ext->flags : 0;
+	scoutfs_inode_get_onoff(inode, &online, &offline);
 
 	if (ext->len) {
-		/*
-		 * Assume that offline writers are going to be writing
-		 * all the offline extents and try to preallocate the
-		 * rest of the unwritten extent.
-		 */
+		/* limit preallocation to remaining existing (offline) extent */
 		count = ext->len - (iblock - ext->start);
-
-	} else if (opts.data_prealloc_contig_only) {
-		/*
-		 * Only preallocate when a quick test of the online
-		 * block counts looks like we're a simple streaming
-		 * write.  Try to write until the next extent but limit
-		 * 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);
-			if (ret < 0 && ret != -ENOENT)
-				goto out;
-			if (found.len && found.start > iblock)
-				count = found.start - iblock;
-			else
-				count = opts.data_prealloc_blocks;
-
-			count = min(iblock, count);
-		}
-
+		flags = ext->flags;
 	} else {
-		/*
-		 * Preallocation of aligned regions only preallocates if
-		 * the aligned region contains no extents at all.  This
-		 * could be fooled by offline sparse extents but we
-		 * don't want to iterate over all offline extents in the
-		 * aligned region.
-		 */
-		div64_u64_rem(iblock, opts.data_prealloc_blocks, &rem);
-		start = iblock - rem;
-		count = opts.data_prealloc_blocks;
-		ret = scoutfs_ext_next(sb, &data_ext_ops, &args, start, 1, &found);
+		/* otherwise alloc to next extent */
+		ret = scoutfs_ext_next(sb, &data_ext_ops, &args,
+				       iblock, 1, &found);
 		if (ret < 0 && ret != -ENOENT)
 			goto out;
-		if (found.len && found.start < start + count)
-			count = 1;
+		if (found.len && found.start > iblock)
+			count = found.start - iblock;
+		else
+			count = SCOUTFS_DATA_EXTEND_PREALLOC_LIMIT;
+		flags = 0;
 	}
 
 	/* overall prealloc limit */
-	count = min_t(u64, count, opts.data_prealloc_blocks);
+	count = min_t(u64, count, SCOUTFS_DATA_EXTEND_PREALLOC_LIMIT);
+
+	/* only strictly contiguous extending writes will try to preallocate */
+	if (iblock > 1 && iblock == online)
+		count = min(iblock, count);
+	else
+		count = 1;
 
 	ret = scoutfs_alloc_data(sb, datinf->alloc, datinf->wri,
 				 &datinf->dalloc, count, &blkno, &count);
 	if (ret < 0)
 		goto out;
 
-	/*
-	 * An aligned prealloc attempt that gets a smaller extent can
-	 * fail to cover iblock, make sure that it does.  This is a
-	 * pathological case so we don't try to move the window past
-	 * iblock.  Just enough to cover it, which we know is safe.
-	 */
-	if (start + count <= iblock)
-		start += (iblock - (start + count) + 1);
+	ret = scoutfs_ext_set(sb, &data_ext_ops, &args, iblock, 1, blkno, 0);
+	if (ret < 0)
+		goto out;
 
 	if (count > 1) {
-		pre.start = start;
-		pre.len = count;
-		pre.map = blkno;
+		pre.start = iblock + 1;
+		pre.len = count - 1;
+		pre.map = blkno + 1;
 		pre.flags = flags | SEF_UNWRITTEN;
 		ret = scoutfs_ext_set(sb, &data_ext_ops, &args, pre.start,
 				      pre.len, pre.map, pre.flags);
-		if (ret < 0)
+		if (ret < 0) {
+			err = scoutfs_ext_set(sb, &data_ext_ops, &args, iblock,
+					      1, 0, flags);
+			BUG_ON(err); /* couldn't restore original */
 			goto out;
-		undo_pre = true;
+		}
 	}
 
-	ret = scoutfs_ext_set(sb, &data_ext_ops, &args, iblock, 1, blkno + (iblock - start), 0);
-	if (ret < 0)
-		goto out;
-
 	/* tell the caller we have a single block, could check next? */
 	ext->start = iblock;
 	ext->len = 1;
-	ext->map = blkno + (iblock - start);
+	ext->map = blkno;
 	ext->flags = 0;
 	ret = 0;
+
 out:
 	if (ret < 0 && blkno > 0) {
-		if (undo_pre) {
-			err = scoutfs_ext_set(sb, &data_ext_ops, &args,
-					      pre.start, pre.len, 0, flags);
-			BUG_ON(err); /* leaked preallocated extent */
-		}
 		err = scoutfs_free_data(sb, datinf->alloc, datinf->wri,
 				        &datinf->data_freed, blkno, count);
 		BUG_ON(err); /* leaked free blocks */
@@ -533,8 +490,68 @@ out:
 	return ret;
 }
 
+static int alloc_block_dio(struct super_block *sb, struct inode *inode,
+			   struct scoutfs_extent *ext, struct buffer_head *bh,
+			   u64 iblock, struct scoutfs_lock *lock)
+{
+	DECLARE_DATA_INFO(sb, datinf);
+	const u64 ino = scoutfs_ino(inode);
+	struct data_ext_args args = {
+		.ino = ino,
+		.inode = inode,
+		.lock = lock,
+	};
+	u64 blkno = 0;
+	u64 blocks = 0;
+	u64 count = 0;
+	u64 last;
+	u8 ext_fl = 0;
+	int ret = 0;
+	bool first = true;
+	int err;
+
+	last = (bh->b_size - 1) >> SCOUTFS_BLOCK_SM_SHIFT;
+
+	while(blocks < last) {
+		if (ext->len >= last && first)
+			count = min_t(u64, last, SCOUTFS_FALLOCATE_ALLOC_LIMIT);
+		else
+			count = min_t(u64, last - blocks, SCOUTFS_FALLOCATE_ALLOC_LIMIT);
+
+		mutex_lock(&datinf->mutex);
+		ret = scoutfs_alloc_data(sb, datinf->alloc, datinf->wri,
+					 &datinf->dalloc, count, &blkno, &count);
+		if (ret == 0) {
+			ret = scoutfs_ext_set(sb, &data_ext_ops, &args, iblock,
+					      count, blkno,
+					      ext_fl | SEF_UNWRITTEN);
+			if (ret < 0) {
+				err = scoutfs_free_data(sb, datinf->alloc,
+							datinf->wri,
+							&datinf->data_freed,
+							blkno, count);
+				BUG_ON(err); /* inconsistent */
+			}
+		}
+
+		mutex_unlock(&datinf->mutex);
+
+		if (ret < 0)
+			break;
+
+		blocks += count;
+		first = false;
+		ret = scoutfs_ext_next(sb, &data_ext_ops, &args,
+				       iblock, 1, ext);
+		if (ret < 0)
+			break;
+	}
+
+	return ret;
+}
+
 static int scoutfs_get_block(struct inode *inode, sector_t iblock,
-			     struct buffer_head *bh, int create)
+			     struct buffer_head *bh, int create, bool dio_flag)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	const u64 ino = scoutfs_ino(inode);
@@ -575,7 +592,7 @@ static int scoutfs_get_block(struct inode *inode, sector_t iblock,
 	}
 
 	/* convert unwritten to written, could be staging */
-	if (create && ext.map && (ext.flags & SEF_UNWRITTEN)) {
+	if (create && ext.map && !dio_flag && (ext.flags & SEF_UNWRITTEN)) {
 		un.start = iblock;
 		un.len = 1;
 		un.map = ext.map + (iblock - ext.start);
@@ -587,11 +604,26 @@ static int scoutfs_get_block(struct inode *inode, sector_t iblock,
 			set_buffer_new(bh);
 		}
 		goto out;
+	} else if (create && ext.map && dio_flag) {
+		un.start = iblock;
+		un.len = 1;
+		un.map = ext.map + (iblock - ext.start);
+		un.flags = ext.flags;
+		ret = scoutfs_ext_set(sb, &data_ext_ops, &args,
+				      un.start, un.len, un.map, un.flags);
+		if (ret == 0) {
+			ext = un;
+			set_buffer_new(bh);
+		}
+		goto out;
 	}
 
 	/* allocate and map blocks containing our logical block */
 	if (create && !ext.map) {
-		ret = alloc_block(sb, inode, &ext, iblock, lock);
+		if (dio_flag)
+			ret = alloc_block_dio(sb, inode, &ext, bh, iblock, lock);
+		else
+			ret = alloc_block(sb, inode, &ext, iblock, lock);
 		if (ret == 0)
 			set_buffer_new(bh);
 	} else {
@@ -625,25 +657,75 @@ static int scoutfs_get_block_read(struct inode *inode, sector_t iblock,
 	int ret;
 
 	down_read(&si->extent_sem);
-	ret = scoutfs_get_block(inode, iblock, bh, create);
+	ret = scoutfs_get_block(inode, iblock, bh, create, false);
 	up_read(&si->extent_sem);
 
 	return ret;
 }
 
-static int scoutfs_get_block_write(struct inode *inode, sector_t iblock,
-				   struct buffer_head *bh, int create)
+int scoutfs_get_block_write(struct inode *inode, sector_t iblock,
+			    struct buffer_head *bh, int create)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	int ret;
 
 	down_write(&si->extent_sem);
-	ret = scoutfs_get_block(inode, iblock, bh, create);
+	ret = scoutfs_get_block(inode, iblock, bh, create, false);
 	up_write(&si->extent_sem);
 
 	return ret;
 }
 
+
+static int scoutfs_get_block_write_dio(struct inode *inode, sector_t iblock,
+				       struct buffer_head *bh, int create)
+{
+	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
+	struct super_block *sb = inode->i_sb;
+	struct scoutfs_lock *lock = NULL;
+	LIST_HEAD(ind_locks);
+	int ret;
+
+	lock = scoutfs_per_task_get(&si->pt_data_lock);
+	if (WARN_ON_ONCE(!lock)) {
+		return -EINVAL;
+	}
+
+	if (inode)
+		ret = scoutfs_inode_index_lock_hold(inode, &ind_locks,
+						    true, false);
+	else
+		ret = scoutfs_hold_trans(sb, false);
+	if (ret)
+		goto out;
+
+	if (inode)
+		ret = scoutfs_dirty_inode_item(inode, lock);
+
+	if (ret < 0)
+		goto out_unlock;
+
+	down_write(&si->extent_sem);
+	ret = scoutfs_get_block(inode, iblock, bh, create, true);
+	up_write(&si->extent_sem);
+
+	if (inode) {
+		scoutfs_inode_set_data_seq(inode);
+		scoutfs_inode_inc_data_version(inode);
+		inode_inc_iversion(inode);
+
+		if (ret > 0)
+			i_size_write(inode, ret);
+		scoutfs_update_inode_item(inode, lock, &ind_locks);
+	}
+
+out_unlock:
+	scoutfs_release_trans(sb);
+	scoutfs_inode_index_unlock(sb, &ind_locks);
+out:
+	return ret;
+}
+
 /*
  * This is almost never used.  We can't block on a cluster lock while
  * holding the page lock because lock invalidation gets the page lock
@@ -906,6 +988,154 @@ static int scoutfs_write_end(struct file *file, struct address_space *mapping,
 	return ret;
 }
 
+static s64 convert_unwritten_items(struct super_block *sb, struct inode *inode,
+			           u64 ino, u64 iblock, u64 last,
+			           struct scoutfs_lock *lock)
+{
+	struct data_ext_args args = {
+		.ino = ino,
+		.inode = inode,
+		.lock = lock,
+	};
+	struct scoutfs_extent ext;
+	struct scoutfs_extent un;
+	u64 offset;
+	s64 ret;
+	int i;
+
+	ret = 0;
+
+	for (i = 0; iblock <= last; i++) {
+		if (i == EXTENTS_PER_HOLD) {
+			ret = iblock;
+			break;
+		}
+
+		ret = scoutfs_ext_next(sb, &data_ext_ops, &args,
+				       iblock, 1, &ext);
+		if (ret < 0) {
+			if (ret == -ENOENT)
+				ret = 0;
+			break;
+		}
+
+		/* done if we went past the region */
+		if (ext.start > last) {
+			ret = 0;
+			break;
+		}
+
+		/* nothing to do when already marked written */
+		if (!(ext.flags & SEF_UNWRITTEN)) {
+			iblock = ext.start + ext.len;
+			continue;
+		}
+
+		iblock = max(ext.start, iblock);
+		offset = iblock - ext.start;
+
+		un.start = iblock;
+		un.map = ext.map ? ext.map + offset : 0;
+		un.len = min(ext.len - offset, last - iblock + 1);
+		un.flags = ext.flags & ~(SEF_OFFLINE|SEF_UNWRITTEN);
+
+		ret = scoutfs_ext_set(sb, &data_ext_ops, &args,
+				      un.start, un.len, un.map, un.flags);
+		if (ret < 0)
+			break;
+
+		iblock += un.len;
+	}
+
+	return ret;
+}
+
+static ssize_t
+convert_unwritten_extent(struct inode *inode, loff_t offset, ssize_t count)
+{
+	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
+	struct super_block *sb = inode->i_sb;
+	const u64 ino = scoutfs_ino(inode);
+	struct scoutfs_lock *lock = NULL;
+	LIST_HEAD(ind_locks);
+	u64 iblock;
+	u64 last;
+	ssize_t ret = 0;
+
+	lock = scoutfs_per_task_get(&si->pt_data_lock);
+	if (WARN_ON_ONCE(!lock)) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	iblock = offset >> SCOUTFS_BLOCK_SM_SHIFT;
+	last = (offset + count - 1) >> SCOUTFS_BLOCK_SM_SHIFT;
+	while(iblock <= last) {
+		if (inode)
+			ret = scoutfs_inode_index_lock_hold(inode, &ind_locks,
+							    true, false);
+		else
+			ret = scoutfs_hold_trans(sb, false);
+		if (ret)
+			break; 
+
+		if (inode)
+			ret = scoutfs_dirty_inode_item(inode, lock);
+		else
+			ret = 0;
+
+		if (ret == 0) {
+			down_write(&si->extent_sem);
+			ret = convert_unwritten_items(sb, inode, ino, iblock,
+						      last, lock);
+			up_write(&si->extent_sem);
+		}
+
+		if (ret < 0)
+			goto out;
+
+		if (inode) {
+			scoutfs_inode_set_data_seq(inode);
+			scoutfs_inode_inc_data_version(inode);
+			inode_inc_iversion(inode);
+
+			if (ret > 0)
+				i_size_write(inode, ret);
+			scoutfs_update_inode_item(inode, lock, &ind_locks);
+		}
+		scoutfs_release_trans(sb);
+		if (inode)
+			scoutfs_inode_index_unlock(sb, &ind_locks);
+
+		if (ret <= 0)
+			break;
+
+		iblock = ret;
+	}
+
+out:
+	return ret;
+}
+
+static ssize_t
+scoutfs_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
+		  loff_t offset, unsigned long nr_segs)
+{
+	struct file *file = iocb->ki_filp;
+	struct address_space *mapping = file->f_mapping;
+	struct inode *inode = mapping->host;
+	ssize_t ret;
+
+	ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
+				 scoutfs_get_block_write_dio);
+	if (ret > 0 && (rw & WRITE))
+	{
+		ret = convert_unwritten_extent(inode, offset, ret);
+	}
+
+	return ret;
+}
+
 /*
  * Try to allocate unwritten extents for any unallocated regions of the
  * logical block extent from the caller.  The caller manages locks and
@@ -1518,13 +1748,14 @@ int scoutfs_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 	iblock = start >> SCOUTFS_BLOCK_SM_SHIFT;
 	last = (start + len - 1) >> SCOUTFS_BLOCK_SM_SHIFT;
 
-	while (iblock <= last) {
+	while (true) {
 		ret = scoutfs_ext_next(sb, &data_ext_ops, &args,
 				       iblock, 1, &ext);
 		if (ret < 0) {
-			if (ret == -ENOENT)
+			if (ret == -ENOENT) {
 				ret = 0;
-			last_flags = FIEMAP_EXTENT_LAST;
+				last_flags = FIEMAP_EXTENT_LAST;
+			}
 			break;
 		}
 
@@ -1849,6 +2080,7 @@ const struct address_space_operations scoutfs_file_aops = {
 	.writepages		= scoutfs_writepages,
 	.write_begin		= scoutfs_write_begin,
 	.write_end		= scoutfs_write_end,
+	.direct_IO		= scoutfs_direct_IO,
 };
 
 const struct file_operations scoutfs_file_fops = {

kmod/src/data.h

@@ -49,6 +49,8 @@ int scoutfs_data_truncate_items(struct super_block *sb, struct inode *inode,
 int scoutfs_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 			u64 start, u64 len);
 long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len);
+int scoutfs_get_block_write(struct inode *inode, sector_t iblock,
+			    struct buffer_head *bh, int create);
 int scoutfs_data_init_offline_extent(struct inode *inode, u64 size,
 				     struct scoutfs_lock *lock);
 int scoutfs_data_move_blocks(struct inode *from, u64 from_off,

kmod/src/dir.c

@@ -32,7 +32,6 @@
 #include "hash.h"
 #include "omap.h"
 #include "forest.h"
-#include "acl.h"
 #include "counters.h"
 #include "scoutfs_trace.h"
 
@@ -766,8 +765,7 @@ retry:
 	if (ret)
 		goto out_unlock;
 
-	ret = scoutfs_new_inode(sb, dir, mode, rdev, ino, *inode_lock, &inode) ?:
-	      scoutfs_init_acl_locked(inode, dir, *inode_lock, *dir_lock, ind_locks);
+	ret = scoutfs_new_inode(sb, dir, mode, rdev, ino, *inode_lock, &inode);
 	if (ret < 0)
 		goto out;
 
@@ -1244,11 +1242,10 @@ const struct inode_operations scoutfs_symlink_iops = {
 	.put_link       = scoutfs_put_link,
 	.getattr	= scoutfs_getattr,
 	.setattr	= scoutfs_setattr,
-	.setxattr	= generic_setxattr,
-	.getxattr	= generic_getxattr,
+	.setxattr	= scoutfs_setxattr,
+	.getxattr	= scoutfs_getxattr,
 	.listxattr	= scoutfs_listxattr,
-	.removexattr	= generic_removexattr,
-	.get_acl	= scoutfs_get_acl,
+	.removexattr	= scoutfs_removexattr,
 };
 
 /*
@@ -1981,11 +1978,10 @@ const struct inode_operations_wrapper scoutfs_dir_iops = {
 	.rename		= scoutfs_rename,
 	.getattr	= scoutfs_getattr,
 	.setattr	= scoutfs_setattr,
-	.setxattr	= generic_setxattr,
-	.getxattr	= generic_getxattr,
+	.setxattr	= scoutfs_setxattr,
+	.getxattr	= scoutfs_getxattr,
 	.listxattr	= scoutfs_listxattr,
-	.removexattr	= generic_removexattr,
-	.get_acl	= scoutfs_get_acl,
+	.removexattr	= scoutfs_removexattr,
 	.symlink	= scoutfs_symlink,
 	.permission	= scoutfs_permission,
 	},

kmod/src/file.c

@@ -47,6 +47,9 @@ ssize_t scoutfs_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
 	DECLARE_DATA_WAIT(dw);
 	int ret;
 
+	if (!is_sync_kiocb(iocb))
+		return -EINVAL;
+
 retry:
 	/* protect checked extents from release */
 	mutex_lock(&inode->i_mutex);
@@ -97,6 +100,9 @@ ssize_t scoutfs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 	DECLARE_DATA_WAIT(dw);
 	int ret;
 
+	if (!is_sync_kiocb(iocb))
+		return -EINVAL;
+
 	if (iocb->ki_left == 0) /* Does this even happen? */
 		return 0;
 

kmod/src/inode.c

@@ -19,6 +19,7 @@
 #include <linux/pagemap.h>
 #include <linux/sched.h>
 #include <linux/list_sort.h>
+#include <linux/buffer_head.h>
 
 #include "format.h"
 #include "super.h"
@@ -36,7 +37,6 @@
 #include "omap.h"
 #include "forest.h"
 #include "btree.h"
-#include "acl.h"
 
 /*
  * XXX
@@ -137,22 +137,20 @@ void scoutfs_destroy_inode(struct inode *inode)
 static const struct inode_operations scoutfs_file_iops = {
 	.getattr	= scoutfs_getattr,
 	.setattr	= scoutfs_setattr,
-	.setxattr	= generic_setxattr,
-	.getxattr	= generic_getxattr,
+	.setxattr	= scoutfs_setxattr,
+	.getxattr	= scoutfs_getxattr,
 	.listxattr	= scoutfs_listxattr,
-	.removexattr	= generic_removexattr,
-	.get_acl	= scoutfs_get_acl,
+	.removexattr	= scoutfs_removexattr,
 	.fiemap		= scoutfs_data_fiemap,
 };
 
 static const struct inode_operations scoutfs_special_iops = {
 	.getattr	= scoutfs_getattr,
 	.setattr	= scoutfs_setattr,
-	.setxattr	= generic_setxattr,
-	.getxattr	= generic_getxattr,
+	.setxattr	= scoutfs_setxattr,
+	.getxattr	= scoutfs_getxattr,
 	.listxattr	= scoutfs_listxattr,
-	.removexattr	= generic_removexattr,
-	.get_acl	= scoutfs_get_acl,
+	.removexattr	= scoutfs_removexattr,
 };
 
 /*
@@ -357,15 +355,22 @@ static int set_inode_size(struct inode *inode, struct scoutfs_lock *lock,
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
+	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	LIST_HEAD(ind_locks);
 	int ret;
 
 	if (!S_ISREG(inode->i_mode))
 		return 0;
 
+	scoutfs_per_task_add(&si->pt_data_lock, &pt_ent, lock);
+	ret = block_truncate_page(inode->i_mapping, new_size, scoutfs_get_block_write);
+	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
+	if (ret)
+		goto out;
+
 	ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, true, false);
 	if (ret)
-		return ret;
+		goto out;
 
 	if (new_size != i_size_read(inode))
 		scoutfs_inode_inc_data_version(inode);
@@ -381,6 +386,7 @@ static int set_inode_size(struct inode *inode, struct scoutfs_lock *lock,
 	scoutfs_release_trans(sb);
 	scoutfs_inode_index_unlock(sb, &ind_locks);
 
+out:
 	return ret;
 }
 
@@ -510,15 +516,10 @@ retry:
 	if (ret)
 		goto out;
 
-	ret = scoutfs_acl_chmod_locked(inode, attr, lock, &ind_locks);
-	if (ret < 0)
-		goto release;
-
 	setattr_copy(inode, attr);
 	inode_inc_iversion(inode);
 	scoutfs_update_inode_item(inode, lock, &ind_locks);
 
-release:
 	scoutfs_release_trans(sb);
 	scoutfs_inode_index_unlock(sb, &ind_locks);
 out:
@@ -1693,7 +1694,6 @@ static int try_delete_inode_items(struct super_block *sb, u64 ino)
 	struct scoutfs_lock *lock = NULL;
 	struct scoutfs_inode sinode;
 	struct scoutfs_key key;
-	bool clear_trying = false;
 	u64 group_nr;
 	int bit_nr;
 	int ret;
@@ -1713,7 +1713,6 @@ static int try_delete_inode_items(struct super_block *sb, u64 ino)
 		ret = 0;
 		goto out;
 	}
-	clear_trying = true;
 
 	/* can't delete if it's cached in local or remote mounts */
 	if (scoutfs_omap_test(sb, ino) || test_bit_le(bit_nr, ldata->map.bits)) {
@@ -1740,7 +1739,7 @@ static int try_delete_inode_items(struct super_block *sb, u64 ino)
 
 	ret = delete_inode_items(sb, ino, &sinode, lock, orph_lock);
 out:
-	if (clear_trying)
+	if (ldata)
 		clear_bit(bit_nr, ldata->trying);
 
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);

kmod/src/kernelcompat.h

@@ -46,10 +46,4 @@ static inline int dir_emit_dots(struct file *file, void *dirent,
 }
 #endif
 
-#ifdef KC_POSIX_ACL_VALID_USER_NS
-#define kc_posix_acl_valid(user_ns, acl) posix_acl_valid(user_ns, acl)
-#else
-#define kc_posix_acl_valid(user_ns, acl) posix_acl_valid(acl)
-#endif
-
 #endif

kmod/src/lock.c

@@ -18,7 +18,6 @@
 #include <linux/mm.h>
 #include <linux/sort.h>
 #include <linux/ctype.h>
-#include <linux/posix_acl.h>
 
 #include "super.h"
 #include "lock.h"
@@ -157,8 +156,6 @@ static void invalidate_inode(struct super_block *sb, u64 ino)
 		if (!linfo->unmounting)
 			d_prune_aliases(inode);
 
-		forget_all_cached_acls(inode);
-
 		si->drop_invalidated = true;
 		if (scoutfs_lock_is_covered(sb, &si->ino_lock_cov) && inode->i_nlink > 0) {
 			iput(inode);
@@ -292,7 +289,6 @@ static struct scoutfs_lock *lock_alloc(struct super_block *sb,
 	lock->sb = sb;
 	init_waitqueue_head(&lock->waitq);
 	lock->mode = SCOUTFS_LOCK_NULL;
-	lock->invalidating_mode = SCOUTFS_LOCK_NULL;
 
 	atomic64_set(&lock->forest_bloom_nr, 0);
 
@@ -670,9 +666,7 @@ struct inv_req {
  *
  * Before we start invalidating the lock we set the lock to the new
  * mode, preventing further incompatible users of the old mode from
- * using the lock while we're invalidating.  We record the previously
- * granted mode so that we can send lock recover responses with the old
- * granted mode during invalidation.
+ * using the lock while we're invalidating.
  */
 static void lock_invalidate_worker(struct work_struct *work)
 {
@@ -697,8 +691,7 @@ static void lock_invalidate_worker(struct work_struct *work)
 		if (!lock_counts_match(nl->new_mode, lock->users))
 			continue;
 
-		/* set the new mode, no incompatible users during inval, recov needs old */
-		lock->invalidating_mode = lock->mode;
+		/* set the new mode, no incompatible users during inval */
 		lock->mode = nl->new_mode;
 
 		/* move everyone that's ready to our private list */
@@ -741,8 +734,6 @@ static void lock_invalidate_worker(struct work_struct *work)
 		list_del(&ireq->head);
 		kfree(ireq);
 
-		lock->invalidating_mode = SCOUTFS_LOCK_NULL;
-
 		if (list_empty(&lock->inv_list)) {
 			/* finish if another request didn't arrive */
 			list_del_init(&lock->inv_head);
@@ -833,7 +824,6 @@ int scoutfs_lock_recover_request(struct super_block *sb, u64 net_id,
 {
 	DECLARE_LOCK_INFO(sb, linfo);
 	struct scoutfs_net_lock_recover *nlr;
-	enum scoutfs_lock_mode mode;
 	struct scoutfs_lock *lock;
 	struct scoutfs_lock *next;
 	struct rb_node *node;
@@ -854,15 +844,10 @@ int scoutfs_lock_recover_request(struct super_block *sb, u64 net_id,
 
 	for (i = 0; lock && i < SCOUTFS_NET_LOCK_MAX_RECOVER_NR; i++) {
 
-		if (lock->invalidating_mode != SCOUTFS_LOCK_NULL)
-			mode = lock->invalidating_mode;
-		else
-			mode = lock->mode;
-
 		nlr->locks[i].key = lock->start;
 		nlr->locks[i].write_seq = cpu_to_le64(lock->write_seq);
-		nlr->locks[i].old_mode = mode;
-		nlr->locks[i].new_mode = mode;
+		nlr->locks[i].old_mode = lock->mode;
+		nlr->locks[i].new_mode = lock->mode;
 
 		node = rb_next(&lock->node);
 		if (node)

kmod/src/lock.h

@@ -39,7 +39,6 @@ struct scoutfs_lock {
 	struct list_head cov_list;
 
 	enum scoutfs_lock_mode mode;
-	enum scoutfs_lock_mode invalidating_mode;
 	unsigned int waiters[SCOUTFS_LOCK_NR_MODES];
 	unsigned int users[SCOUTFS_LOCK_NR_MODES];
 

kmod/src/lock_server.c

@@ -749,7 +749,7 @@ out:
 	if (ret < 0) {
 		scoutfs_err(sb, "lock server err %d during client rid %016llx farewell, shutting down",
 			    ret, rid);
-		scoutfs_server_stop(sb);
+		scoutfs_server_abort(sb);
 	}
 
 	return ret;

kmod/src/net.c

@@ -355,7 +355,6 @@ static int submit_send(struct super_block *sb,
 		}
 		if (rid != 0) {
 			spin_unlock(&conn->lock);
-			kfree(msend);
 			return -ENOTCONN;
 		}
 	}
@@ -992,8 +991,6 @@ static void scoutfs_net_listen_worker(struct work_struct *work)
 		if (ret < 0)
 			break;
 
-		acc_sock->sk->sk_allocation = GFP_NOFS;
-
 		/* inherit accepted request funcs from listening conn */
 		acc_conn = scoutfs_net_alloc_conn(sb, conn->notify_up,
 						  conn->notify_down,
@@ -1056,8 +1053,6 @@ static void scoutfs_net_connect_worker(struct work_struct *work)
 	if (ret)
 		goto out;
 
-	sock->sk->sk_allocation = GFP_NOFS;
-
 	/* caller specified connect timeout */
 	tv.tv_sec = conn->connect_timeout_ms / MSEC_PER_SEC;
 	tv.tv_usec = (conn->connect_timeout_ms % MSEC_PER_SEC) * USEC_PER_MSEC;
@@ -1297,7 +1292,7 @@ restart:
 				if (ret) {
 					scoutfs_err(sb, "client fence returned err %d, shutting down server",
 						    ret);
-					scoutfs_server_stop(sb);
+					scoutfs_server_abort(sb);
 				}
 			}
 			destroy_conn(acc);
@@ -1346,12 +1341,10 @@ scoutfs_net_alloc_conn(struct super_block *sb,
 	if (!conn)
 		return NULL;
 
-	if (info_size) {
-		conn->info = kzalloc(info_size, GFP_NOFS);
-		if (!conn->info) {
-			kfree(conn);
-			return NULL;
-		}
+	conn->info = kzalloc(info_size, GFP_NOFS);
+	if (!conn->info) {
+		kfree(conn);
+		return NULL;
 	}
 
 	conn->workq = alloc_workqueue("scoutfs_net_%s",
@@ -1457,8 +1450,6 @@ int scoutfs_net_bind(struct super_block *sb,
 	if (ret)
 		goto out;
 
-	sock->sk->sk_allocation = GFP_NOFS;
-
 	optval = 1;
 	ret = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
 				(char *)&optval, sizeof(optval));

kmod/src/omap.c

@@ -157,15 +157,6 @@ static int free_rid(struct omap_rid_list *list, struct omap_rid_entry *entry)
 	return nr;
 }
 
-static void free_rid_list(struct omap_rid_list *list)
-{
-	struct omap_rid_entry *entry;
-	struct omap_rid_entry *tmp;
-
-	list_for_each_entry_safe(entry, tmp, &list->head, head)
-		free_rid(list, entry);
-}
-
 static int copy_rids(struct omap_rid_list *to, struct omap_rid_list *from, spinlock_t *from_lock)
 {
 	struct omap_rid_entry *entry;
@@ -813,10 +804,6 @@ void scoutfs_omap_server_shutdown(struct super_block *sb)
 	llist_for_each_entry_safe(req, tmp, requests, llnode)
 		kfree(req);
 
-	spin_lock(&ominf->lock);
-	free_rid_list(&ominf->rids);
-	spin_unlock(&ominf->lock);
-
 	synchronize_rcu();
 }
 
@@ -877,10 +864,6 @@ void scoutfs_omap_destroy(struct super_block *sb)
 		rhashtable_walk_stop(&iter);
 		rhashtable_walk_exit(&iter);
 
-		spin_lock(&ominf->lock);
-		free_rid_list(&ominf->rids);
-		spin_unlock(&ominf->lock);
-
 		rhashtable_destroy(&ominf->group_ht);
 		rhashtable_destroy(&ominf->req_ht);
 		kfree(ominf);

kmod/src/options.c

@@ -27,25 +27,16 @@
 #include "options.h"
 #include "super.h"
 #include "inode.h"
-#include "alloc.h"
 
 enum {
-	Opt_acl,
-	Opt_data_prealloc_blocks,
-	Opt_data_prealloc_contig_only,
 	Opt_metadev_path,
-	Opt_noacl,
 	Opt_orphan_scan_delay_ms,
 	Opt_quorum_slot_nr,
 	Opt_err,
 };
 
 static const match_table_t tokens = {
-	{Opt_acl, "acl"},
-	{Opt_data_prealloc_blocks, "data_prealloc_blocks=%s"},
-	{Opt_data_prealloc_contig_only, "data_prealloc_contig_only=%s"},
 	{Opt_metadev_path, "metadev_path=%s"},
-	{Opt_noacl, "noacl"},
 	{Opt_orphan_scan_delay_ms, "orphan_scan_delay_ms=%s"},
 	{Opt_quorum_slot_nr, "quorum_slot_nr=%s"},
 	{Opt_err, NULL}
@@ -115,17 +106,11 @@ static void free_options(struct scoutfs_mount_options *opts)
 #define DEFAULT_ORPHAN_SCAN_DELAY_MS	(10 * MSEC_PER_SEC)
 #define MAX_ORPHAN_SCAN_DELAY_MS	(60 * MSEC_PER_SEC)
 
-#define MIN_DATA_PREALLOC_BLOCKS	1ULL
-#define MAX_DATA_PREALLOC_BLOCKS	((unsigned long long)SCOUTFS_BLOCK_SM_MAX)
-
 static void init_default_options(struct scoutfs_mount_options *opts)
 {
 	memset(opts, 0, sizeof(*opts));
-
-	opts->data_prealloc_blocks = SCOUTFS_DATA_PREALLOC_DEFAULT_BLOCKS;
-	opts->data_prealloc_contig_only = 1;
 	opts->quorum_slot_nr = -1;
-	opts->orphan_scan_delay_ms = -1;
+	opts->orphan_scan_delay_ms = DEFAULT_ORPHAN_SCAN_DELAY_MS;
 }
 
 /*
@@ -137,7 +122,6 @@ static void init_default_options(struct scoutfs_mount_options *opts)
 static int parse_options(struct super_block *sb, char *options, struct scoutfs_mount_options *opts)
 {
 	substring_t args[MAX_OPT_ARGS];
-	u64 nr64;
 	int nr;
 	int token;
 	char *p;
@@ -150,44 +134,12 @@ static int parse_options(struct super_block *sb, char *options, struct scoutfs_m
 		token = match_token(p, tokens, args);
 		switch (token) {
 
-		case Opt_acl:
-			sb->s_flags |= MS_POSIXACL;
-			break;
-
-		case Opt_data_prealloc_blocks:
-			ret = match_u64(args, &nr64);
-			if (ret < 0 ||
-			    nr64 < MIN_DATA_PREALLOC_BLOCKS || nr64 > MAX_DATA_PREALLOC_BLOCKS) {
-				scoutfs_err(sb, "invalid data_prealloc_blocks option, must be between %llu and %llu",
-					    MIN_DATA_PREALLOC_BLOCKS, MAX_DATA_PREALLOC_BLOCKS);
-				if (ret == 0)
-					ret = -EINVAL;
-				return ret;
-			}
-			opts->data_prealloc_blocks = nr64;
-			break;
-
-		case Opt_data_prealloc_contig_only:
-			ret = match_int(args, &nr);
-			if (ret < 0 || nr < 0 || nr > 1) {
-				scoutfs_err(sb, "invalid data_prealloc_contig_only option, bool must only be 0 or 1");
-				if (ret == 0)
-					ret = -EINVAL;
-				return ret;
-			}
-			opts->data_prealloc_contig_only = nr;
-			break;
-
 		case Opt_metadev_path:
 			ret = parse_bdev_path(sb, &args[0], &opts->metadev_path);
 			if (ret < 0)
 				return ret;
 			break;
 
-		case Opt_noacl:
-			sb->s_flags &= ~MS_POSIXACL;
-			break;
-
 		case Opt_orphan_scan_delay_ms:
 			if (opts->orphan_scan_delay_ms != -1) {
 				scoutfs_err(sb, "multiple orphan_scan_delay_ms options provided, only provide one.");
@@ -229,9 +181,6 @@ static int parse_options(struct super_block *sb, char *options, struct scoutfs_m
 		}
 	}
 
-	if (opts->orphan_scan_delay_ms == -1)
-		opts->orphan_scan_delay_ms = DEFAULT_ORPHAN_SCAN_DELAY_MS;
-
 	if (!opts->metadev_path) {
 		scoutfs_err(sb, "Required mount option \"metadev_path\" not found");
 		return -EINVAL;
@@ -301,17 +250,10 @@ int scoutfs_options_show(struct seq_file *seq, struct dentry *root)
 {
 	struct super_block *sb = root->d_sb;
 	struct scoutfs_mount_options opts;
-	const bool is_acl = !!(sb->s_flags & MS_POSIXACL);
 
 	scoutfs_options_read(sb, &opts);
 
-	if (is_acl)
-		seq_puts(seq, ",acl");
-	seq_printf(seq, ",data_prealloc_blocks=%llu", opts.data_prealloc_blocks);
-	seq_printf(seq, ",data_prealloc_contig_only=%u", opts.data_prealloc_contig_only);
 	seq_printf(seq, ",metadev_path=%s", opts.metadev_path);
-	if (!is_acl)
-		seq_puts(seq, ",noacl");
 	seq_printf(seq, ",orphan_scan_delay_ms=%u", opts.orphan_scan_delay_ms);
 	if (opts.quorum_slot_nr >= 0)
 		seq_printf(seq, ",quorum_slot_nr=%d", opts.quorum_slot_nr);
@@ -319,83 +261,6 @@ int scoutfs_options_show(struct seq_file *seq, struct dentry *root)
 	return 0;
 }
 
-static ssize_t data_prealloc_blocks_show(struct kobject *kobj, struct kobj_attribute *attr,
-					 char *buf)
-{
-	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
-	struct scoutfs_mount_options opts;
-
-	scoutfs_options_read(sb, &opts);
-
-	return snprintf(buf, PAGE_SIZE, "%llu", opts.data_prealloc_blocks);
-}
-static ssize_t data_prealloc_blocks_store(struct kobject *kobj, struct kobj_attribute *attr,
-					  const char *buf, size_t count)
-{
-	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
-	DECLARE_OPTIONS_INFO(sb, optinf);
-	char nullterm[30]; /* more than enough for octal -U64_MAX */
-	u64 val;
-	int len;
-	int ret;
-
-	len = min(count, sizeof(nullterm) - 1);
-	memcpy(nullterm, buf, len);
-	nullterm[len] = '\0';
-
-	ret = kstrtoll(nullterm, 0, &val);
-	if (ret < 0 || val < MIN_DATA_PREALLOC_BLOCKS || val > MAX_DATA_PREALLOC_BLOCKS) {
-		scoutfs_err(sb, "invalid data_prealloc_blocks option, must be between %llu and %llu",
-			    MIN_DATA_PREALLOC_BLOCKS, MAX_DATA_PREALLOC_BLOCKS);
-		return -EINVAL;
-	}
-
-	write_seqlock(&optinf->seqlock);
-	optinf->opts.data_prealloc_blocks = val;
-	write_sequnlock(&optinf->seqlock);
-
-	return count;
-}
-SCOUTFS_ATTR_RW(data_prealloc_blocks);
-
-static ssize_t data_prealloc_contig_only_show(struct kobject *kobj, struct kobj_attribute *attr,
-					 char *buf)
-{
-	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
-	struct scoutfs_mount_options opts;
-
-	scoutfs_options_read(sb, &opts);
-
-	return snprintf(buf, PAGE_SIZE, "%u", opts.data_prealloc_contig_only);
-}
-static ssize_t data_prealloc_contig_only_store(struct kobject *kobj, struct kobj_attribute *attr,
-					  const char *buf, size_t count)
-{
-	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
-	DECLARE_OPTIONS_INFO(sb, optinf);
-	char nullterm[20]; /* more than enough for octal -U32_MAX */
-	long val;
-	int len;
-	int ret;
-
-	len = min(count, sizeof(nullterm) - 1);
-	memcpy(nullterm, buf, len);
-	nullterm[len] = '\0';
-
-	ret = kstrtol(nullterm, 0, &val);
-	if (ret < 0 || val < 0 || val > 1) {
-		scoutfs_err(sb, "invalid data_prealloc_contig_only option, bool must be 0 or 1");
-		return -EINVAL;
-	}
-
-	write_seqlock(&optinf->seqlock);
-	optinf->opts.data_prealloc_contig_only = val;
-	write_sequnlock(&optinf->seqlock);
-
-	return count;
-}
-SCOUTFS_ATTR_RW(data_prealloc_contig_only);
-
 static ssize_t metadev_path_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 {
 	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
@@ -460,8 +325,6 @@ static ssize_t quorum_slot_nr_show(struct kobject *kobj, struct kobj_attribute *
 SCOUTFS_ATTR_RO(quorum_slot_nr);
 
 static struct attribute *options_attrs[] = {
-	SCOUTFS_ATTR_PTR(data_prealloc_blocks),
-	SCOUTFS_ATTR_PTR(data_prealloc_contig_only),
 	SCOUTFS_ATTR_PTR(metadev_path),
 	SCOUTFS_ATTR_PTR(orphan_scan_delay_ms),
 	SCOUTFS_ATTR_PTR(quorum_slot_nr),

kmod/src/options.h

@@ -6,8 +6,6 @@
 #include "format.h"
 
 struct scoutfs_mount_options {
-	u64 data_prealloc_blocks;
-	bool data_prealloc_contig_only;
 	char *metadev_path;
 	unsigned int orphan_scan_delay_ms;
 	int quorum_slot_nr;

kmod/src/quorum.c

@@ -105,8 +105,6 @@ enum quorum_role { FOLLOWER, CANDIDATE, LEADER };
 struct quorum_status {
 	enum quorum_role role;
 	u64 term;
-	u64 server_start_term;
-	int server_event;
 	int vote_for;
 	unsigned long vote_bits;
 	ktime_t timeout;
@@ -119,6 +117,7 @@ struct quorum_info {
 	bool shutdown;
 
 	int our_quorum_slot_nr;
+	unsigned long flags;
 	int votes_needed;
 
 	spinlock_t show_lock;
@@ -129,6 +128,8 @@ struct quorum_info {
 	struct scoutfs_sysfs_attrs ssa;
 };
 
+#define QINF_FLAG_SERVER 0
+
 #define DECLARE_QUORUM_INFO(sb, name) \
 	struct quorum_info *name = SCOUTFS_SB(sb)->quorum_info
 #define DECLARE_QUORUM_INFO_KOBJ(kobj, name) \
@@ -493,6 +494,16 @@ static int update_quorum_block(struct super_block *sb, int event, u64 term, bool
 	return ret;
 }
 
+/*
+ * The calling server has fenced previous leaders and reclaimed their
+ * resources.  We can now update our fence event with a greater term to
+ * stop future leaders from doing the same.
+ */
+int scoutfs_quorum_fence_complete(struct super_block *sb, u64 term)
+{
+	return update_quorum_block(sb, SCOUTFS_QUORUM_EVENT_FENCE, term, true);
+}
+
 /*
  * The calling server has been elected and has started running but can't
  * yet assume that it has exclusive access to the metadata device.  We
@@ -582,9 +593,15 @@ int scoutfs_quorum_fence_leaders(struct super_block *sb, u64 term)
 	}
 
 out:
-	err = scoutfs_fence_wait_fenced(sb, msecs_to_jiffies(SCOUTFS_QUORUM_FENCE_TO_MS));
-	if (ret == 0)
-		ret = err;
+	if (fence_started) {
+		err = scoutfs_fence_wait_fenced(sb, msecs_to_jiffies(SCOUTFS_QUORUM_FENCE_TO_MS));
+		if (ret == 0)
+			ret = err;
+	} else {
+		err = scoutfs_quorum_fence_complete(sb, term);
+		if (ret == 0)
+			ret = err;
+	}
 
 	if (ret < 0)
 		scoutfs_inc_counter(sb, quorum_fence_error);
@@ -610,8 +627,9 @@ static void update_show_status(struct quorum_info *qinf, struct quorum_status *q
 /*
  * The quorum work always runs in the background of quorum member
  * mounts.  It's responsible for starting and stopping the server if
- * it's elected leader.  While it's leader it sends heartbeats to
- * suppress other quorum work from standing for election.
+ * it's elected leader, and the server can call back into it to let it
+ * know that it has shut itself down (perhaps due to error) so that the
+ * work should stop sending heartbeats.
  */
 static void scoutfs_quorum_worker(struct work_struct *work)
 {
@@ -619,7 +637,7 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 	struct super_block *sb = qinf->sb;
 	struct sockaddr_in unused;
 	struct quorum_host_msg msg;
-	struct quorum_status qst = {0,};
+	struct quorum_status qst;
 	int ret;
 	int err;
 
@@ -628,7 +646,9 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 
 	/* start out as a follower */
 	qst.role = FOLLOWER;
+	qst.term = 0;
 	qst.vote_for = -1;
+	qst.vote_bits = 0;
 
 	/* read our starting term from greatest in all events in all slots */
 	read_greatest_term(sb, &qst.term);
@@ -664,6 +684,20 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 		    msg.term < qst.term)
 			msg.type = SCOUTFS_QUORUM_MSG_INVALID;
 
+		/* if the server has shutdown we become follower */
+		if (!test_bit(QINF_FLAG_SERVER, &qinf->flags) &&
+		    qst.role == LEADER) {
+			qst.role = FOLLOWER;
+			qst.vote_for = -1;
+			qst.vote_bits = 0;
+			qst.timeout = election_timeout();
+			scoutfs_inc_counter(sb, quorum_server_shutdown);
+
+			send_msg_others(sb, SCOUTFS_QUORUM_MSG_RESIGNATION,
+					qst.term);
+			scoutfs_inc_counter(sb, quorum_send_resignation);
+		}
+
 		trace_scoutfs_quorum_loop(sb, qst.role, qst.term, qst.vote_for,
 					  qst.vote_bits,
 					  ktime_to_timespec64(qst.timeout));
@@ -674,6 +708,8 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 			if (qst.role == LEADER) {
 				scoutfs_warn(sb, "saw msg type %u from %u for term %llu while leader in term %llu, shutting down server.",
 					     msg.type, msg.from, msg.term, qst.term);
+				update_show_status(qinf, &qst);
+				scoutfs_server_stop(sb);
 			}
 			qst.role = FOLLOWER;
 			qst.term = msg.term;
@@ -695,13 +731,6 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 		/* followers and candidates start new election on timeout */
 		if (qst.role != LEADER &&
 		    ktime_after(ktime_get(), qst.timeout)) {
-			/* .. but only if their server has stopped */
-			if (!scoutfs_server_is_down(sb)) {
-				qst.timeout = election_timeout();
-				scoutfs_inc_counter(sb, quorum_candidate_server_stopping);
-				continue;
-			}
-
 			qst.role = CANDIDATE;
 			qst.term++;
 			qst.vote_for = -1;
@@ -750,62 +779,24 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 			if (ret < 0)
 				goto out;
 
-			qst.server_start_term = qst.term;
-			qst.server_event = SCOUTFS_QUORUM_EVENT_ELECT;
-			scoutfs_server_start(sb, qst.term);
-		}
-
-		/*
-		 * This leader's server is up, having finished fencing
-		 * previous leaders.  We update the fence event with the
-		 * current term to let future leaders know that previous
-		 * servers have been fenced.
-		 */
-		if (qst.role == LEADER && qst.server_event != SCOUTFS_QUORUM_EVENT_FENCE &&
-		    scoutfs_server_is_up(sb)) {
-			ret = update_quorum_block(sb, SCOUTFS_QUORUM_EVENT_FENCE, qst.term, true);
-			if (ret < 0)
-				goto out;
-			qst.server_event = SCOUTFS_QUORUM_EVENT_FENCE;
-		}
-
-		/*
-		 * Stop a running server if we're no longer leader in
-		 * its term.
-		 */
-		if (!(qst.role == LEADER && qst.term == qst.server_start_term) &&
-		    scoutfs_server_is_running(sb)) {
+			/* make very sure server is fully shut down */
 			scoutfs_server_stop(sb);
-		}
+			/* set server bit before server shutdown could clear */
+			set_bit(QINF_FLAG_SERVER, &qinf->flags);
 
-		/*
-		 * A previously running server has stopped.  The quorum
-		 * protocol might have shut it down by changing roles or
-		 * it might have stopped on its own, perhaps on errors.
-		 * If we're still a leader then we become a follower and
-		 * send resignations to encourage the next election.
-		 * Always update the _STOP event to stop connections and
-		 * fencing.
-		 */
-		if (qst.server_start_term > 0 && scoutfs_server_is_down(sb)) {
-			if (qst.role == LEADER) {
-				qst.role = FOLLOWER;
-				qst.vote_for = -1;
-				qst.vote_bits = 0;
-				qst.timeout = election_timeout();
-				scoutfs_inc_counter(sb, quorum_server_shutdown);
-
-				send_msg_others(sb, SCOUTFS_QUORUM_MSG_RESIGNATION,
-						qst.server_start_term);
-				scoutfs_inc_counter(sb, quorum_send_resignation);
+			ret = scoutfs_server_start(sb, qst.term);
+			if (ret < 0) {
+				clear_bit(QINF_FLAG_SERVER, &qinf->flags);
+				/* store our increased term */
+				err = update_quorum_block(sb, SCOUTFS_QUORUM_EVENT_STOP, qst.term,
+							  true);
+				if (err < 0) {
+					ret = err;
+					goto out;
+				}
+				ret = 0;
+				continue;
 			}
-
-			ret = update_quorum_block(sb, SCOUTFS_QUORUM_EVENT_STOP,
-						  qst.server_start_term, true);
-			if (ret < 0)
-				goto out;
-
-			qst.server_start_term = 0;
 		}
 
 		/* leaders regularly send heartbeats to delay elections */
@@ -845,16 +836,11 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 	update_show_status(qinf, &qst);
 
 	/* always try to stop a running server as we stop */
-	if (scoutfs_server_is_running(sb)) {
-		scoutfs_server_stop_wait(sb);
-		send_msg_others(sb, SCOUTFS_QUORUM_MSG_RESIGNATION, qst.term);
-
-		if (qst.server_start_term > 0) {
-			err = update_quorum_block(sb, SCOUTFS_QUORUM_EVENT_STOP,
-						  qst.server_start_term, true);
-			if (err < 0 && ret == 0)
-				ret = err;
-		}
+	if (test_bit(QINF_FLAG_SERVER, &qinf->flags)) {
+		scoutfs_server_stop(sb);
+		scoutfs_fence_stop(sb);
+		send_msg_others(sb, SCOUTFS_QUORUM_MSG_RESIGNATION,
+				qst.term);
 	}
 
 	/* record that this slot no longer has an active quorum */
@@ -866,6 +852,21 @@ out:
 	}
 }
 
+/*
+ * The calling server has shutdown and is no longer using shared
+ * resources.  Clear the bit so that we stop sending heartbeats and
+ * allow the next server to be elected.  Update the stop event so that
+ * it won't be considered available by clients or fenced by the next
+ * leader.
+ */
+void scoutfs_quorum_server_shutdown(struct super_block *sb, u64 term)
+{
+	DECLARE_QUORUM_INFO(sb, qinf);
+
+	clear_bit(QINF_FLAG_SERVER, &qinf->flags);
+	update_quorum_block(sb, SCOUTFS_QUORUM_EVENT_STOP, term, true);
+}
+
 /*
  * Clients read quorum blocks looking for the leader with a server whose
  * address it can try and connect to.
@@ -987,8 +988,6 @@ static ssize_t status_show(struct kobject *kobj, struct kobj_attribute *attr,
 		     qinf->our_quorum_slot_nr);
 	snprintf_ret(buf, size, &ret, "term %llu\n",
 		     qst.term);
-	snprintf_ret(buf, size, &ret, "server_start_term %llu\n", qst.server_start_term);
-	snprintf_ret(buf, size, &ret, "server_event %d\n", qst.server_event);
 	snprintf_ret(buf, size, &ret, "role %d (%s)\n",
 		     qst.role, role_str(qst.role));
 	snprintf_ret(buf, size, &ret, "vote_for %d\n",

kmod/src/quorum.h

@@ -2,12 +2,14 @@
 #define _SCOUTFS_QUORUM_H_
 
 int scoutfs_quorum_server_sin(struct super_block *sb, struct sockaddr_in *sin);
+void scoutfs_quorum_server_shutdown(struct super_block *sb, u64 term);
 
 u8 scoutfs_quorum_votes_needed(struct super_block *sb);
 void scoutfs_quorum_slot_sin(struct scoutfs_super_block *super, int i,
 			     struct sockaddr_in *sin);
 
 int scoutfs_quorum_fence_leaders(struct super_block *sb, u64 term);
+int scoutfs_quorum_fence_complete(struct super_block *sb, u64 term);
 
 int scoutfs_quorum_setup(struct super_block *sb);
 void scoutfs_quorum_shutdown(struct super_block *sb);

kmod/src/scoutfs_trace.h

@@ -1843,53 +1843,6 @@ DEFINE_EVENT(scoutfs_server_client_count_class, scoutfs_server_client_down,
 	TP_ARGS(sb, rid, nr_clients)
 );
 
-DECLARE_EVENT_CLASS(scoutfs_server_commit_users_class,
-        TP_PROTO(struct super_block *sb, int holding, int applying, int nr_holders,
-		 u32 avail_before, u32 freed_before, int exceeded),
-        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, exceeded),
-        TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(int, holding)
-		__field(int, applying)
-		__field(int, nr_holders)
-		__field(__u32, avail_before)
-		__field(__u32, freed_before)
-		__field(int, exceeded)
-        ),
-        TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->holding = !!holding;
-		__entry->applying = !!applying;
-		__entry->nr_holders = nr_holders;
-		__entry->avail_before = avail_before;
-		__entry->freed_before = freed_before;
-		__entry->exceeded = !!exceeded;
-        ),
-	TP_printk(SCSBF" holding %u applying %u nr %u avail_before %u freed_before %u exceeded %u",
-		  SCSB_TRACE_ARGS, __entry->holding, __entry->applying, __entry->nr_holders,
-		  __entry->avail_before, __entry->freed_before, __entry->exceeded)
-);
-DEFINE_EVENT(scoutfs_server_commit_users_class, scoutfs_server_commit_hold,
-        TP_PROTO(struct super_block *sb, int holding, int applying, int nr_holders,
-		 u32 avail_before, u32 freed_before, int exceeded),
-        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, exceeded)
-);
-DEFINE_EVENT(scoutfs_server_commit_users_class, scoutfs_server_commit_apply,
-        TP_PROTO(struct super_block *sb, int holding, int applying, int nr_holders,
-		 u32 avail_before, u32 freed_before, int exceeded),
-        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, exceeded)
-);
-DEFINE_EVENT(scoutfs_server_commit_users_class, scoutfs_server_commit_start,
-        TP_PROTO(struct super_block *sb, int holding, int applying, int nr_holders,
-		 u32 avail_before, u32 freed_before, int exceeded),
-        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, exceeded)
-);
-DEFINE_EVENT(scoutfs_server_commit_users_class, scoutfs_server_commit_end,
-        TP_PROTO(struct super_block *sb, int holding, int applying, int nr_holders,
-		 u32 avail_before, u32 freed_before, int exceeded),
-        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, exceeded)
-);
-
 #define slt_symbolic(mode)						\
 	__print_symbolic(mode,					\
 		{ SLT_CLIENT,		"client" },	\

kmod/src/server.h

@@ -64,6 +64,8 @@ int scoutfs_server_lock_response(struct super_block *sb, u64 rid, u64 id,
 				 struct scoutfs_net_lock *nl);
 int scoutfs_server_lock_recover_request(struct super_block *sb, u64 rid,
 					struct scoutfs_key *key);
+void scoutfs_server_hold_commit(struct super_block *sb);
+int scoutfs_server_apply_commit(struct super_block *sb, int err);
 void scoutfs_server_recov_finish(struct super_block *sb, u64 rid, int which);
 
 int scoutfs_server_send_omap_request(struct super_block *sb, u64 rid,
@@ -75,12 +77,9 @@ u64 scoutfs_server_seq(struct super_block *sb);
 u64 scoutfs_server_next_seq(struct super_block *sb);
 void scoutfs_server_set_seq_if_greater(struct super_block *sb, u64 seq);
 
-void scoutfs_server_start(struct super_block *sb, u64 term);
+int scoutfs_server_start(struct super_block *sb, u64 term);
+void scoutfs_server_abort(struct super_block *sb);
 void scoutfs_server_stop(struct super_block *sb);
-void scoutfs_server_stop_wait(struct super_block *sb);
-bool scoutfs_server_is_running(struct super_block *sb);
-bool scoutfs_server_is_up(struct super_block *sb);
-bool scoutfs_server_is_down(struct super_block *sb);
 
 int scoutfs_server_setup(struct super_block *sb);
 void scoutfs_server_destroy(struct super_block *sb);

kmod/src/super.c

@@ -47,7 +47,6 @@
 #include "omap.h"
 #include "volopt.h"
 #include "fence.h"
-#include "xattr.h"
 #include "scoutfs_trace.h"
 
 static struct dentry *scoutfs_debugfs_root;
@@ -484,8 +483,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_op = &scoutfs_super_ops;
 	sb->s_export_op = &scoutfs_export_ops;
-	sb->s_xattr = scoutfs_xattr_handlers;
-	sb->s_flags |= MS_I_VERSION | MS_POSIXACL;
+	sb->s_flags |= MS_I_VERSION;
 
 	/* btree blocks use long lived bh->b_data refs */
 	mapping_set_gfp_mask(sb->s_bdev->bd_inode->i_mapping, GFP_NOFS);
@@ -498,7 +496,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 
 	ret = assign_random_id(sbi);
 	if (ret < 0)
-		goto out;
+		return ret;
 
 	spin_lock_init(&sbi->next_ino_lock);
 	spin_lock_init(&sbi->data_wait_root.lock);
@@ -507,7 +505,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	/* parse options early for use during setup */
 	ret = scoutfs_options_early_setup(sb, data);
 	if (ret < 0)
-		goto out;
+		return ret;
 	scoutfs_options_read(sb, &opts);
 
 	ret = sb_set_blocksize(sb, SCOUTFS_BLOCK_SM_SIZE);

kmod/src/sysfs.c

@@ -37,15 +37,6 @@ struct attr_funcs {
 #define ATTR_FUNCS_RO(_name) \
 	static struct attr_funcs _name##_attr_funcs = __ATTR_RO(_name)
 
-static ssize_t data_device_maj_min_show(struct kobject *kobj, struct attribute *attr, char *buf)
-{
-	struct super_block *sb = KOBJ_TO_SB(kobj, sb_id_kobj);
-
-	return snprintf(buf, PAGE_SIZE, "%u:%u\n",
-			MAJOR(sb->s_bdev->bd_dev), MINOR(sb->s_bdev->bd_dev));
-}
-ATTR_FUNCS_RO(data_device_maj_min);
-
 static ssize_t format_version_show(struct kobject *kobj, struct attribute *attr,
 			 char *buf)
 {
@@ -110,7 +101,6 @@ static ssize_t attr_funcs_show(struct kobject *kobj, struct attribute *attr,
 
 
 static struct attribute *sb_id_attrs[] = {
-	&data_device_maj_min_attr_funcs.attr,
 	&format_version_attr_funcs.attr,
 	&fsid_attr_funcs.attr,
 	&rid_attr_funcs.attr,

kmod/src/xattr.c

@@ -15,7 +15,6 @@
 #include <linux/dcache.h>
 #include <linux/xattr.h>
 #include <linux/crc32c.h>
-#include <linux/posix_acl.h>
 
 #include "format.h"
 #include "inode.h"
@@ -27,7 +26,6 @@
 #include "xattr.h"
 #include "lock.h"
 #include "hash.h"
-#include "acl.h"
 #include "scoutfs_trace.h"
 
 /*
@@ -59,6 +57,12 @@ static u32 xattr_names_equal(const char *a_name, unsigned int a_len,
 	return a_len == b_len && memcmp(a_name, b_name, a_len) == 0;
 }
 
+static unsigned int xattr_full_bytes(struct scoutfs_xattr *xat)
+{
+	return offsetof(struct scoutfs_xattr,
+		        name[xat->name_len + le16_to_cpu(xat->val_len)]);
+}
+
 static unsigned int xattr_nr_parts(struct scoutfs_xattr *xat)
 {
 	return SCOUTFS_XATTR_NR_PARTS(xat->name_len,
@@ -81,6 +85,16 @@ static void init_xattr_key(struct scoutfs_key *key, u64 ino, u32 name_hash,
 #define SCOUTFS_XATTR_PREFIX		"scoutfs."
 #define SCOUTFS_XATTR_PREFIX_LEN	(sizeof(SCOUTFS_XATTR_PREFIX) - 1)
 
+static int unknown_prefix(const char *name)
+{
+	return strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
+	       strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) &&
+	       strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) &&
+	       strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)&&
+	       strncmp(name, SCOUTFS_XATTR_PREFIX, SCOUTFS_XATTR_PREFIX_LEN);
+}
+
+
 #define HIDE_TAG	"hide."
 #define SRCH_TAG	"srch."
 #define TOTL_TAG	"totl."
@@ -123,29 +137,12 @@ int scoutfs_xattr_parse_tags(const char *name, unsigned int name_len,
 }
 
 /*
- * xattrs are stored in multiple items.   The first item is a
- * concatenation of an initial header, the name, and then as much of the
- * value as fits in the remainder of the first item.  This return the
- * size of the first item that'd store an xattr with the given name
- * length and value payload size.
- */
-static int first_item_bytes(int name_len, size_t size)
-{
-	if (WARN_ON_ONCE(name_len <= 0) ||
-	    WARN_ON_ONCE(name_len > SCOUTFS_XATTR_MAX_NAME_LEN))
-		return 0;
-
-	return min_t(int, sizeof(struct scoutfs_xattr) + name_len + size,
-			  SCOUTFS_XATTR_MAX_PART_SIZE);
-}
-
-/*
- * Find the next xattr, set the caller's key, and copy as much of the
- * first item into the callers buffer as we can.  Returns the number of
- * bytes copied which can include the header, name, and start of the
- * value from the first item.  The caller is responsible for comparing
- * their lengths, the header, and the returned length before safely
- * using the buffer.
+ * Find the next xattr and copy the key, xattr header, and as much of
+ * the name and value into the callers buffer as we can.  Returns the
+ * number of bytes copied which include the header, name, and value and
+ * can be limited by the xattr length or the callers buffer.  The caller
+ * is responsible for comparing their lengths, the header, and the
+ * returned length before safely using the xattr.
  *
  * If a name is provided then we'll iterate over items with a matching
  * name_hash until we find a matching name.  If we don't find a matching
@@ -157,17 +154,20 @@ static int first_item_bytes(int name_len, size_t size)
  * Returns -ENOENT if it didn't find a next item.
  */
 static int get_next_xattr(struct inode *inode, struct scoutfs_key *key,
-			  struct scoutfs_xattr *xat, unsigned int xat_bytes,
+			  struct scoutfs_xattr *xat, unsigned int bytes,
 			  const char *name, unsigned int name_len,
 			  u64 name_hash, u64 id, struct scoutfs_lock *lock)
 {
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_key last;
+	u8 last_part;
+	int total;
+	u8 part;
 	int ret;
 
 	/* need to be able to see the name we're looking for */
-	if (WARN_ON_ONCE(name_len > 0 &&
-			 xat_bytes < offsetof(struct scoutfs_xattr, name[name_len])))
+	if (WARN_ON_ONCE(name_len > 0 && bytes < offsetof(struct scoutfs_xattr,
+							  name[name_len])))
 		return -EINVAL;
 
 	if (name_len)
@@ -176,15 +176,26 @@ static int get_next_xattr(struct inode *inode, struct scoutfs_key *key,
 	init_xattr_key(key, scoutfs_ino(inode), name_hash, id);
 	init_xattr_key(&last, scoutfs_ino(inode), U32_MAX, U64_MAX);
 
+	last_part = 0;
+	part = 0;
+	total = 0;
+
 	for (;;) {
-		ret = scoutfs_item_next(sb, key, &last, xat, xat_bytes, lock);
-		if (ret < 0)
+		key->skx_part = part;
+		ret = scoutfs_item_next(sb, key, &last,
+					(void *)xat + total, bytes - total,
+					lock);
+		if (ret < 0) {
+			/* XXX corruption, ran out of parts */
+			if (ret == -ENOENT && part > 0)
+				ret = -EIO;
 			break;
+		}
 
 		trace_scoutfs_xattr_get_next_key(sb, key);
 
 		/* XXX corruption */
-		if (key->skx_part != 0) {
+		if (key->skx_part != part) {
 			ret = -EIO;
 			break;
 		}
@@ -194,7 +205,8 @@ static int get_next_xattr(struct inode *inode, struct scoutfs_key *key,
 		 * the first part and if the next xattr name fits in our
 		 * buffer then the item must have included it.
 		 */
-		if ((ret < sizeof(struct scoutfs_xattr) ||
+		if (part == 0 &&
+		    (ret < sizeof(struct scoutfs_xattr) ||
 		     (xat->name_len <= name_len &&
 		      ret < offsetof(struct scoutfs_xattr,
 				     name[xat->name_len])) ||
@@ -204,7 +216,7 @@ static int get_next_xattr(struct inode *inode, struct scoutfs_key *key,
 			break;
 		}
 
-		if (name_len > 0) {
+		if (part == 0 && name_len) {
 			/* ran out of names that could match */
 			if (le64_to_cpu(key->skx_name_hash) != name_hash) {
 				ret = -ENOENT;
@@ -212,126 +224,64 @@ static int get_next_xattr(struct inode *inode, struct scoutfs_key *key,
 			}
 
 			/* keep looking for our name */
-			if (!xattr_names_equal(name, name_len, xat->name, xat->name_len)) {
+			if (!xattr_names_equal(name, name_len,
+					       xat->name, xat->name_len)) {
+				part = 0;
 				le64_add_cpu(&key->skx_id, 1);
 				continue;
 			}
+
+			/* use the matching name we found */
+			last_part = xattr_nr_parts(xat) - 1;
 		}
 
-		/* found next name */
-		break;
+		total += ret;
+		if (total == bytes || part == last_part) {
+			/* copied as much as we could */
+			ret = total;
+			break;
+		}
+		part++;
 	}
 
 	return ret;
 }
 
-/*
- * The caller has already read and verified the xattr's first item.
- * Copy the value from the tail of the first item and from any future
- * items into the destination buffer.
- */
-static int copy_xattr_value(struct super_block *sb, struct scoutfs_key *xat_key,
-			    struct scoutfs_xattr *xat, int xat_bytes,
-			    char *buffer, size_t size,
-			    struct scoutfs_lock *lock)
-{
-	struct scoutfs_key key;
-	size_t copied = 0;
-	int val_tail;
-	int bytes;
-	int ret;
-	int i;
-
-	/* must have first item up to value */
-	if (WARN_ON_ONCE(xat_bytes < sizeof(struct scoutfs_xattr)) ||
-	    WARN_ON_ONCE(xat_bytes < offsetof(struct scoutfs_xattr, name[xat->name_len])))
-		return -EINVAL;
-
-	/* only ever copy up to the full value */
-	size = min_t(size_t, size, le16_to_cpu(xat->val_len));
-
-	/* must have full first item if caller needs value from second item */
-	val_tail = SCOUTFS_XATTR_MAX_PART_SIZE -
-		   offsetof(struct scoutfs_xattr, name[xat->name_len]);
-	if (WARN_ON_ONCE(size > val_tail && xat_bytes != SCOUTFS_XATTR_MAX_PART_SIZE))
-		return -EINVAL;
-
-	/* copy from tail of first item */
-	bytes = min_t(unsigned int, size, val_tail);
-	if (bytes > 0) {
-		memcpy(buffer, &xat->name[xat->name_len], bytes);
-		copied += bytes;
-	}
-
-	key = *xat_key;
-	for (i = 1; copied < size; i++) {
-		key.skx_part = i;
-		bytes = min_t(unsigned int, size - copied, SCOUTFS_XATTR_MAX_PART_SIZE);
-
-		ret = scoutfs_item_lookup(sb, &key, buffer + copied, bytes, lock);
-		if (ret >= 0 && ret != bytes)
-			ret = -EIO;
-		if (ret < 0)
-			return ret;
-
-		copied += ret;
-	}
-
-	return copied;
-}
-
-/*
- * The caller is working with items that are either in the allocated
- * first compound item or further items that are offsets into a value
- * buffer.  Give them a pointer and length of the start of the item.
- */
-static void xattr_item_part_buffer(void **buf, int *len, int part,
-				   struct scoutfs_xattr *xat, unsigned int xat_bytes,
-				   const char *value, size_t size)
-{
-	int off;
-
-	if (part == 0) {
-		*buf = xat;
-		*len = xat_bytes;
-	} else {
-		off = (part * SCOUTFS_XATTR_MAX_PART_SIZE) -
-		      offsetof(struct scoutfs_xattr, name[xat->name_len]);
-		BUG_ON(off >= size); /* calls limited by number of parts */
-		*buf = (void *)value + off;
-		*len = min_t(size_t, size - off, SCOUTFS_XATTR_MAX_PART_SIZE);
-	}
-}
-
 /*
  * Create all the items associated with the given xattr.  If this
  * returns an error it will have already cleaned up any items it created
  * before seeing the error.
  */
-static int create_xattr_items(struct inode *inode, u64 id, struct scoutfs_xattr *xat,
-			      int xat_bytes, const char *value, size_t size, u8 new_parts,
+static int create_xattr_items(struct inode *inode, u64 id,
+			      struct scoutfs_xattr *xat, unsigned int bytes,
 			      struct scoutfs_lock *lock)
 {
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_key key;
-	int ret = 0;
-	void *buf;
-	int len;
-	int i;
+	unsigned int part_bytes;
+	unsigned int total;
+	int ret;
 
 	init_xattr_key(&key, scoutfs_ino(inode),
 		       xattr_name_hash(xat->name, xat->name_len), id);
 
-	for (i = 0; i < new_parts; i++) {
-		key.skx_part = i;
-		xattr_item_part_buffer(&buf, &len, i, xat, xat_bytes, value, size);
+	total = 0;
+	ret = 0;
+	while (total < bytes) {
+		part_bytes = min_t(unsigned int, bytes - total,
+				   SCOUTFS_XATTR_MAX_PART_SIZE);
 
-		ret = scoutfs_item_create(sb, &key, buf, len, lock);
-		if (ret < 0) {
+		ret = scoutfs_item_create(sb, &key,
+					  (void *)xat + total, part_bytes,
+					  lock);
+		if (ret) {
 			while (key.skx_part-- > 0)
 				scoutfs_item_delete(sb, &key, lock);
 			break;
 		}
+
+		total += part_bytes;
+		key.skx_part++;
 	}
 
 	return ret;
@@ -379,20 +329,20 @@ out:
  * deleted items.
  */
 static int change_xattr_items(struct inode *inode, u64 id,
-			      struct scoutfs_xattr *xat, int xat_bytes,
-			      const char *value, size_t size,
-			      u8 new_parts, u8 old_parts, struct scoutfs_lock *lock)
+			      struct scoutfs_xattr *new_xat,
+			      unsigned int new_bytes, u8 new_parts,
+			      u8 old_parts, struct scoutfs_lock *lock)
 {
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_key key;
 	int last_created = -1;
-	void *buf;
-	int len;
+	int bytes;
+	int off;
 	int i;
 	int ret;
 
 	init_xattr_key(&key, scoutfs_ino(inode),
-		       xattr_name_hash(xat->name, xat->name_len), id);
+		       xattr_name_hash(new_xat->name, new_xat->name_len), id);
 
 	/* dirty existing old items */
 	for (i = 0; i < old_parts; i++) {
@@ -404,10 +354,13 @@ static int change_xattr_items(struct inode *inode, u64 id,
 
 	/* create any new items past the old */
 	for (i = old_parts; i < new_parts; i++) {
-		key.skx_part = i;
-		xattr_item_part_buffer(&buf, &len, i, xat, xat_bytes, value, size);
+		off = i * SCOUTFS_XATTR_MAX_PART_SIZE;
+		bytes = min_t(unsigned int, new_bytes - off,
+			      SCOUTFS_XATTR_MAX_PART_SIZE);
 
-		ret = scoutfs_item_create(sb, &key, buf, len, lock);
+		key.skx_part = i;
+		ret = scoutfs_item_create(sb, &key, (void *)new_xat + off,
+					  bytes, lock);
 		if (ret)
 			goto out;
 
@@ -416,10 +369,13 @@ static int change_xattr_items(struct inode *inode, u64 id,
 
 	/* update dirtied overlapping existing items, last partial first */
 	for (i = min(old_parts, new_parts) - 1; i >= 0; i--) {
-		key.skx_part = i;
-		xattr_item_part_buffer(&buf, &len, i, xat, xat_bytes, value, size);
+		off = i * SCOUTFS_XATTR_MAX_PART_SIZE;
+		bytes = min_t(unsigned int, new_bytes - off,
+			      SCOUTFS_XATTR_MAX_PART_SIZE);
 
-		ret = scoutfs_item_update(sb, &key, buf, len, lock);
+		key.skx_part = i;
+		ret = scoutfs_item_update(sb, &key, (void *)new_xat + off,
+					  bytes, lock);
 		/* only last partial can fail, then we unwind created */
 		if (ret < 0)
 			goto out;
@@ -447,69 +403,72 @@ out:
  * Copy the value for the given xattr name into the caller's buffer, if it
  * fits.  Return the bytes copied or -ERANGE if it doesn't fit.
  */
-int scoutfs_xattr_get_locked(struct inode *inode, const char *name, void *buffer, size_t size,
-			     struct scoutfs_lock *lck)
+ssize_t scoutfs_getxattr(struct dentry *dentry, const char *name, void *buffer,
+			 size_t size)
 {
+	struct inode *inode = dentry->d_inode;
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_xattr *xat = NULL;
+	struct scoutfs_lock *lck = NULL;
 	struct scoutfs_key key;
-	unsigned int xat_bytes;
+	unsigned int bytes;
 	size_t name_len;
 	int ret;
 
+	if (unknown_prefix(name))
+		return -EOPNOTSUPP;
+
 	name_len = strlen(name);
 	if (name_len > SCOUTFS_XATTR_MAX_NAME_LEN)
 		return -ENODATA;
 
-	xat_bytes = first_item_bytes(name_len, size);
-	xat = kmalloc(xat_bytes, GFP_NOFS);
+	/* only need enough for caller's name and value sizes */
+	bytes = sizeof(struct scoutfs_xattr) + name_len + size;
+	xat = __vmalloc(bytes, GFP_NOFS, PAGE_KERNEL);
 	if (!xat)
 		return -ENOMEM;
 
+	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ, 0, inode, &lck);
+	if (ret)
+		goto out;
+
 	down_read(&si->xattr_rwsem);
 
-	ret = get_next_xattr(inode, &key, xat, xat_bytes, name, name_len, 0, 0, lck);
+	ret = get_next_xattr(inode, &key, xat, bytes,
+			     name, name_len, 0, 0, lck);
+
+	up_read(&si->xattr_rwsem);
+	scoutfs_unlock(sb, lck, SCOUTFS_LOCK_READ);
 
 	if (ret < 0) {
 		if (ret == -ENOENT)
 			ret = -ENODATA;
-		goto unlock;
+		goto out;
 	}
 
 	/* the caller just wants to know the size */
 	if (size == 0) {
 		ret = le16_to_cpu(xat->val_len);
-		goto unlock;
+		goto out;
 	}
 
 	/* the caller's buffer wasn't big enough */
 	if (size < le16_to_cpu(xat->val_len)) {
 		ret = -ERANGE;
-		goto unlock;
+		goto out;
 	}
 
-	ret = copy_xattr_value(sb, &key, xat, xat_bytes, buffer, size, lck);
-unlock:
-	up_read(&si->xattr_rwsem);
-
-	kfree(xat);
-	return ret;
-}
-
-static int scoutfs_xattr_get(struct dentry *dentry, const char *name, void *buffer, size_t size)
-{
-	struct inode *inode = dentry->d_inode;
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *lock = NULL;
-	int ret;
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ, 0, inode, &lock);
-	if (ret == 0) {
-		ret = scoutfs_xattr_get_locked(inode, name, buffer, size, lock);
-		scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
+	/* XXX corruption, the items didn't match the header */
+	if (ret < xattr_full_bytes(xat)) {
+		ret = -EIO;
+		goto out;
 	}
 
+	ret = le16_to_cpu(xat->val_len);
+	memcpy(buffer, &xat->name[xat->name_len], ret);
+out:
+	vfree(xat);
 	return ret;
 }
 
@@ -617,32 +576,29 @@ int scoutfs_xattr_combine_totl(void *dst, int dst_len, void *src, int src_len)
  * cause creation to fail if the xattr already exists (_CREATE) or
  * doesn't already exist (_REPLACE).  xattrs can have a zero length
  * value.
- *
- * The caller has acquired cluster locks, holds a transaction, and has
- * dirtied the inode item so that they can update it after we modify it.
- * The caller has to know the tags to acquire cluster locks before
- * holding the transaction so they pass in the parsed tags, or all 0s for
- * non scoutfs. prefixes.
  */
-int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_len,
-			     const void *value, size_t size, int flags,
-			     const struct scoutfs_xattr_prefix_tags *tgs,
-			     struct scoutfs_lock *lck, struct scoutfs_lock *totl_lock,
-			     struct list_head *ind_locks)
+static int scoutfs_xattr_set(struct dentry *dentry, const char *name,
+			     const void *value, size_t size, int flags)
 {
+	struct inode *inode = dentry->d_inode;
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
 	const u64 ino = scoutfs_ino(inode);
 	struct scoutfs_xattr_totl_val tval = {0,};
+	struct scoutfs_xattr_prefix_tags tgs;
 	struct scoutfs_xattr *xat = NULL;
+	struct scoutfs_lock *lck = NULL;
+	struct scoutfs_lock *totl_lock = NULL;
+	size_t name_len = strlen(name);
 	struct scoutfs_key totl_key;
 	struct scoutfs_key key;
 	bool undo_srch = false;
 	bool undo_totl = false;
+	LIST_HEAD(ind_locks);
 	u8 found_parts;
-	unsigned int xat_bytes_totl;
-	unsigned int xat_bytes;
+	unsigned int bytes;
 	unsigned int val_len;
+	u64 ind_seq;
 	u64 total;
 	u64 hash = 0;
 	u64 id = 0;
@@ -651,9 +607,6 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 
 	trace_scoutfs_xattr_set(sb, name_len, value, size, flags);
 
-	if (WARN_ON_ONCE(tgs->totl && !totl_lock))
-		return -EINVAL;
-
 	/* mirror the syscall's errors for large names and values */
 	if (name_len > SCOUTFS_XATTR_MAX_NAME_LEN)
 		return -ERANGE;
@@ -664,61 +617,73 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	    (flags & ~(XATTR_CREATE | XATTR_REPLACE)))
 		return -EINVAL;
 
-	if ((tgs->hide | tgs->srch | tgs->totl) && !capable(CAP_SYS_ADMIN))
+	if (unknown_prefix(name))
+		return -EOPNOTSUPP;
+
+	if (scoutfs_xattr_parse_tags(name, name_len, &tgs) != 0)
+		return -EINVAL;
+
+	if ((tgs.hide | tgs.srch | tgs.totl) && !capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
-	if (tgs->totl && ((ret = parse_totl_key(&totl_key, name, name_len)) != 0))
+	if (tgs.totl && ((ret = parse_totl_key(&totl_key, name, name_len)) != 0))
 		return ret;
 
-	/* allocate enough to always read an existing xattr's totl */
-	xat_bytes_totl = first_item_bytes(name_len,
-					  max_t(size_t, size, SCOUTFS_XATTR_MAX_TOTL_U64));
-	/* but store partial first item that only includes the new xattr's value */
-	xat_bytes = first_item_bytes(name_len, size);
-	xat = kmalloc(xat_bytes_totl, GFP_NOFS);
-	if (!xat)
-		return -ENOMEM;
+	bytes = sizeof(struct scoutfs_xattr) + name_len + size;
+	/* alloc enough to read old totl value */
+	xat = __vmalloc(bytes + SCOUTFS_XATTR_MAX_TOTL_U64, GFP_NOFS, PAGE_KERNEL);
+	if (!xat) {
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
+				 SCOUTFS_LKF_REFRESH_INODE, inode, &lck);
+	if (ret)
+		goto out;
 
 	down_write(&si->xattr_rwsem);
 
 	/* find an existing xattr to delete, including possible totl value */
-	ret = get_next_xattr(inode, &key, xat, xat_bytes_totl, name, name_len, 0, 0, lck);
+	ret = get_next_xattr(inode, &key, xat,
+			     sizeof(struct scoutfs_xattr) + name_len + SCOUTFS_XATTR_MAX_TOTL_U64,
+			     name, name_len, 0, 0, lck);
 	if (ret < 0 && ret != -ENOENT)
-		goto out;
+		goto unlock;
 
 	/* check existence constraint flags */
 	if (ret == -ENOENT && (flags & XATTR_REPLACE)) {
 		ret = -ENODATA;
-		goto out;
+		goto unlock;
 	} else if (ret >= 0 && (flags & XATTR_CREATE)) {
 		ret = -EEXIST;
-		goto out;
+		goto unlock;
 	}
 
 	/* not an error to delete something that doesn't exist */
 	if (ret == -ENOENT && !value) {
 		ret = 0;
-		goto out;
+		goto unlock;
 	}
 
 	/* s64 count delta if we create or delete */
-	if (tgs->totl)
+	if (tgs.totl)
 		tval.count = cpu_to_le64((u64)!!(value) - (u64)!!(ret != -ENOENT));
 
 	/* found fields in key will also be used */
 	found_parts = ret >= 0 ? xattr_nr_parts(xat) : 0;
 
-	if (found_parts && tgs->totl) {
+	if (found_parts && tgs.totl) {
 		/* parse old totl value before we clobber xat buf */
 		val_len = ret - offsetof(struct scoutfs_xattr, name[xat->name_len]);
 		ret = parse_totl_u64(&xat->name[xat->name_len], val_len, &total);
 		if (ret < 0)
-			goto out;
+			goto unlock;
 
 		le64_add_cpu(&tval.total, -total);
 	}
 
-	/* prepare the xattr header, name, and start of value in first item */
+	/* prepare our xattr */
 	if (value) {
 		if (found_parts)
 			id = le64_to_cpu(key.skx_id);
@@ -728,94 +693,17 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 		xat->val_len = cpu_to_le16(size);
 		memset(xat->__pad, 0, sizeof(xat->__pad));
 		memcpy(xat->name, name, name_len);
-		memcpy(&xat->name[name_len], value,
-		       min(size, SCOUTFS_XATTR_MAX_PART_SIZE -
-			         offsetof(struct scoutfs_xattr, name[name_len])));
+		memcpy(&xat->name[xat->name_len], value, size);
 
-		if (tgs->totl) {
+		if (tgs.totl) {
 			ret = parse_totl_u64(value, size, &total);
 			if (ret < 0)
-				goto out;
+				goto unlock;
 		}
 
 		le64_add_cpu(&tval.total, total);
 	}
 
-	if (tgs->srch && !(found_parts && value)) {
-		if (found_parts)
-			id = le64_to_cpu(key.skx_id);
-		hash = scoutfs_hash64(name, name_len);
-		ret = scoutfs_forest_srch_add(sb, hash, ino, id);
-		if (ret < 0)
-			goto out;
-		undo_srch = true;
-	}
-
-	if (tgs->totl) {
-		ret = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
-		if (ret < 0)
-			goto out;
-		undo_totl = true;
-	}
-
-	if (found_parts && value)
-		ret = change_xattr_items(inode, id, xat, xat_bytes, value, size,
-					 xattr_nr_parts(xat), found_parts, lck);
-	else if (found_parts)
-		ret = delete_xattr_items(inode, le64_to_cpu(key.skx_name_hash),
-					 le64_to_cpu(key.skx_id), found_parts,
-					 lck);
-	else
-		ret = create_xattr_items(inode, id, xat, xat_bytes, value, size,
-					 xattr_nr_parts(xat), lck);
-	if (ret < 0)
-		goto out;
-
-	/* XXX do these want i_mutex or anything? */
-	inode_inc_iversion(inode);
-	inode->i_ctime = CURRENT_TIME;
-	ret = 0;
-
-out:
-	if (ret < 0 && undo_srch) {
-		err = scoutfs_forest_srch_add(sb, hash, ino, id);
-		BUG_ON(err);
-	}
-	if (ret < 0 && undo_totl) {
-		/* _delta() on dirty items shouldn't fail */
-		tval.total = cpu_to_le64(-le64_to_cpu(tval.total));
-		tval.count = cpu_to_le64(-le64_to_cpu(tval.count));
-		err = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
-		BUG_ON(err);
-	}
-
-	up_write(&si->xattr_rwsem);
-	kfree(xat);
-
-	return ret;
-}
-
-static int scoutfs_xattr_set(struct dentry *dentry, const char *name, const void *value,
-			     size_t size, int flags)
-{
-	struct inode *inode = dentry->d_inode;
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_xattr_prefix_tags tgs;
-	struct scoutfs_lock *totl_lock = NULL;
-	struct scoutfs_lock *lck = NULL;
-	size_t name_len = strlen(name);
-	LIST_HEAD(ind_locks);
-	u64 ind_seq;
-	int ret;
-
-	if (scoutfs_xattr_parse_tags(name, name_len, &tgs) != 0)
-		return -EINVAL;
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
-				 SCOUTFS_LKF_REFRESH_INODE, inode, &lck);
-	if (ret)
-		goto unlock;
-
 	if (tgs.totl) {
 		ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &totl_lock);
 		if (ret)
@@ -835,98 +723,79 @@ retry:
 	if (ret < 0)
 		goto release;
 
-	ret = scoutfs_xattr_set_locked(dentry->d_inode, name, name_len, value, size, flags, &tgs,
-				       lck, totl_lock, &ind_locks);
-	if (ret == 0)
-		scoutfs_update_inode_item(inode, lck, &ind_locks);
+	if (tgs.srch && !(found_parts && value)) {
+		if (found_parts)
+			id = le64_to_cpu(key.skx_id);
+		hash = scoutfs_hash64(name, name_len);
+		ret = scoutfs_forest_srch_add(sb, hash, ino, id);
+		if (ret < 0)
+			goto release;
+		undo_srch = true;
+	}
+
+	if (tgs.totl) {
+		ret = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
+		if (ret < 0)
+			goto release;
+		undo_totl = true;
+	}
+
+	if (found_parts && value)
+		ret = change_xattr_items(inode, id, xat, bytes,
+					 xattr_nr_parts(xat), found_parts, lck);
+	else if (found_parts)
+		ret = delete_xattr_items(inode, le64_to_cpu(key.skx_name_hash),
+					 le64_to_cpu(key.skx_id), found_parts,
+					 lck);
+	else
+		ret = create_xattr_items(inode, id, xat, bytes, lck);
+	if (ret < 0)
+		goto release;
+
+	/* XXX do these want i_mutex or anything? */
+	inode_inc_iversion(inode);
+	inode->i_ctime = CURRENT_TIME;
+	scoutfs_update_inode_item(inode, lck, &ind_locks);
+	ret = 0;
 
 release:
+	if (ret < 0 && undo_srch) {
+		err = scoutfs_forest_srch_add(sb, hash, ino, id);
+		BUG_ON(err);
+	}
+	if (ret < 0 && undo_totl) {
+		/* _delta() on dirty items shouldn't fail */
+		tval.total = cpu_to_le64(-le64_to_cpu(tval.total));
+		tval.count = cpu_to_le64(-le64_to_cpu(tval.count));
+		err = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
+		BUG_ON(err);
+	}
+
 	scoutfs_release_trans(sb);
 	scoutfs_inode_index_unlock(sb, &ind_locks);
 unlock:
+	up_write(&si->xattr_rwsem);
 	scoutfs_unlock(sb, lck, SCOUTFS_LOCK_WRITE);
 	scoutfs_unlock(sb, totl_lock, SCOUTFS_LOCK_WRITE_ONLY);
+out:
+	vfree(xat);
 
 	return ret;
 }
 
-/*
- * Future kernels have this amazing hack to rewind the name to get the
- * skipped prefix.  We're back in the stone ages without the handler
- * arg, so we Just Know that this is possible.  This will become a
- * compat hook to either call the kernel's xattr_full_name(handler), or
- * our hack to use the flags as the prefix length.
- */
-static const char *full_name_hack(void *handler, const char *name, int len)
+int scoutfs_setxattr(struct dentry *dentry, const char *name,
+		     const void *value, size_t size, int flags)
 {
-	return name - len;
-}
+	if (size == 0)
+		value = ""; /* set empty value */
 
-static int scoutfs_xattr_get_handler(struct dentry *dentry, const char *name,
-				     void *value, size_t size, int handler_flags)
-{
-	name = full_name_hack(NULL, name, handler_flags);
-	return scoutfs_xattr_get(dentry, name, value, size);
-}
-
-static int scoutfs_xattr_set_handler(struct dentry *dentry, const char *name,
-				     const void *value, size_t size, int flags, int handler_flags)
-{
-	name = full_name_hack(NULL, name, handler_flags);
 	return scoutfs_xattr_set(dentry, name, value, size, flags);
 }
 
-static const struct xattr_handler scoutfs_xattr_user_handler = {
-	.prefix = XATTR_USER_PREFIX,
-	.flags = XATTR_USER_PREFIX_LEN,
-	.get = scoutfs_xattr_get_handler,
-	.set = scoutfs_xattr_set_handler,
-};
-
-static const struct xattr_handler scoutfs_xattr_scoutfs_handler = {
-	.prefix = SCOUTFS_XATTR_PREFIX,
-	.flags = SCOUTFS_XATTR_PREFIX_LEN,
-	.get = scoutfs_xattr_get_handler,
-	.set = scoutfs_xattr_set_handler,
-};
-
-static const struct xattr_handler scoutfs_xattr_trusted_handler = {
-	.prefix = XATTR_TRUSTED_PREFIX,
-	.flags = XATTR_TRUSTED_PREFIX_LEN,
-	.get = scoutfs_xattr_get_handler,
-	.set = scoutfs_xattr_set_handler,
-};
-
-static const struct xattr_handler scoutfs_xattr_security_handler = {
-	.prefix = XATTR_SECURITY_PREFIX,
-	.flags = XATTR_SECURITY_PREFIX_LEN,
-	.get = scoutfs_xattr_get_handler,
-	.set = scoutfs_xattr_set_handler,
-};
-
-static const struct xattr_handler scoutfs_xattr_acl_access_handler = {
-	.prefix = XATTR_NAME_POSIX_ACL_ACCESS,
-	.flags  = ACL_TYPE_ACCESS,
-	.get    = scoutfs_acl_get_xattr,
-	.set    = scoutfs_acl_set_xattr,
-};
-
-static const struct xattr_handler scoutfs_xattr_acl_default_handler = {
-	.prefix = XATTR_NAME_POSIX_ACL_DEFAULT,
-	.flags  = ACL_TYPE_DEFAULT,
-	.get    = scoutfs_acl_get_xattr,
-	.set    = scoutfs_acl_set_xattr,
-};
-
-const struct xattr_handler *scoutfs_xattr_handlers[] = {
-	&scoutfs_xattr_user_handler,
-	&scoutfs_xattr_scoutfs_handler,
-	&scoutfs_xattr_trusted_handler,
-	&scoutfs_xattr_security_handler,
-	&scoutfs_xattr_acl_access_handler,
-	&scoutfs_xattr_acl_default_handler,
-	NULL
-};
+int scoutfs_removexattr(struct dentry *dentry, const char *name)
+{
+	return scoutfs_xattr_set(dentry, name, NULL, 0, XATTR_REPLACE);
+}
 
 ssize_t scoutfs_list_xattrs(struct inode *inode, char *buffer,
 			    size_t size, __u32 *hash_pos, __u64 *id_pos,
@@ -938,7 +807,7 @@ ssize_t scoutfs_list_xattrs(struct inode *inode, char *buffer,
 	struct scoutfs_xattr *xat = NULL;
 	struct scoutfs_lock *lck = NULL;
 	struct scoutfs_key key;
-	unsigned int xat_bytes;
+	unsigned int bytes;
 	ssize_t total = 0;
 	u32 name_hash = 0;
 	bool is_hidden;
@@ -951,8 +820,8 @@ ssize_t scoutfs_list_xattrs(struct inode *inode, char *buffer,
 		id = *id_pos;
 
 	/* need a buffer large enough for all possible names */
-	xat_bytes = first_item_bytes(SCOUTFS_XATTR_MAX_NAME_LEN, 0);
-	xat = kmalloc(xat_bytes, GFP_NOFS);
+	bytes = sizeof(struct scoutfs_xattr) + SCOUTFS_XATTR_MAX_NAME_LEN;
+	xat = kmalloc(bytes, GFP_NOFS);
 	if (!xat) {
 		ret = -ENOMEM;
 		goto out;
@@ -965,7 +834,8 @@ ssize_t scoutfs_list_xattrs(struct inode *inode, char *buffer,
 	down_read(&si->xattr_rwsem);
 
 	for (;;) {
-		ret = get_next_xattr(inode, &key, xat, xat_bytes, NULL, 0, name_hash, id, lck);
+		ret = get_next_xattr(inode, &key, xat, bytes,
+				     NULL, 0, name_hash, id, lck);
 		if (ret < 0) {
 			if (ret == -ENOENT)
 				ret = total;

kmod/src/xattr.h

@@ -1,29 +1,25 @@
 #ifndef _SCOUTFS_XATTR_H_
 #define _SCOUTFS_XATTR_H_
 
+ssize_t scoutfs_getxattr(struct dentry *dentry, const char *name, void *buffer,
+			 size_t size);
+int scoutfs_setxattr(struct dentry *dentry, const char *name,
+		     const void *value, size_t size, int flags);
+int scoutfs_removexattr(struct dentry *dentry, const char *name);
+ssize_t scoutfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
+ssize_t scoutfs_list_xattrs(struct inode *inode, char *buffer,
+			    size_t size, __u32 *hash_pos, __u64 *id_pos,
+			    bool e_range, bool show_hidden);
+
+int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
+		       struct scoutfs_lock *lock);
+
 struct scoutfs_xattr_prefix_tags {
 	unsigned long hide:1,
 		      srch:1,
 		      totl:1;
 };
 
-extern const struct xattr_handler *scoutfs_xattr_handlers[];
-
-int scoutfs_xattr_get_locked(struct inode *inode, const char *name, void *buffer, size_t size,
-			     struct scoutfs_lock *lck);
-int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_len,
-			     const void *value, size_t size, int flags,
-			     const struct scoutfs_xattr_prefix_tags *tgs,
-			     struct scoutfs_lock *lck, struct scoutfs_lock *totl_lock,
-			     struct list_head *ind_locks);
-
-ssize_t scoutfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
-ssize_t scoutfs_list_xattrs(struct inode *inode, char *buffer,
-			    size_t size, __u32 *hash_pos, __u64 *id_pos,
-			    bool e_range, bool show_hidden);
-int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
-		       struct scoutfs_lock *lock);
-
 int scoutfs_xattr_parse_tags(const char *name, unsigned int name_len,
 			     struct scoutfs_xattr_prefix_tags *tgs);
 

tests/Makefile

@@ -10,8 +10,7 @@ BIN := src/createmany			\
 	src/bulk_create_paths		\
 	src/stage_tmpfile		\
 	src/find_xattrs			\
-	src/create_xattr_loop		\
-	src/fragmented_data_extents
+	src/create_xattr_loop
 
 DEPS := $(wildcard src/*.d)
 

tests/fenced-local-force-unmount.sh

@@ -1,18 +1,5 @@
 #!/usr/bin/bash
 
-#
-# This fencing script is used for testing clusters of multiple mounts on
-# a single host.  It finds mounts to fence by looking for their rids and
-# only knows how to "fence" by using forced unmount.
-#
-
-echo "$0 running rid '$SCOUTFS_FENCED_REQ_RID' ip '$SCOUTFS_FENCED_REQ_IP' args '$@'"
-
-log() {
-	echo "$@" > /dev/stderr
-	exit 1
-}
-
 echo_fail() {
 	echo "$@" > /dev/stderr
 	exit 1
@@ -20,24 +7,29 @@ echo_fail() {
 
 rid="$SCOUTFS_FENCED_REQ_RID"
 
-for fs in /sys/fs/scoutfs/*; do
-	[ ! -d "$fs" ] && continue
+#
+# Look for a local mount with the rid to fence.  Typically we'll at
+# least find the mount with the server that requested the fence that
+# we're processing.   But it's possible that mounts are unmounted
+# before, or while, we're running.
+#
+mnts=$(findmnt -l -n -t scoutfs -o TARGET) || \
+	echo_fail "findmnt -t scoutfs failed" > /dev/stderr
 
-	fs_rid="$(cat $fs/rid)" || \
-		echo_fail "failed to get rid in $fs"
-	if [ "$fs_rid" != "$rid" ]; then
-		continue
-	fi
+for mnt in $mnts; do
+	mnt_rid=$(scoutfs statfs -p "$mnt" -s rid) || \
+		echo_fail "scoutfs statfs $mnt failed"
 
-	nr="$(cat $fs/data_device_maj_min)" || \
-		echo_fail "failed to get data device major:minor in $fs"
-
-	mnts=$(findmnt -l -n -t scoutfs -o TARGET -S $nr) || \
-		echo_fail "findmnt -t scoutfs -S $nr failed"
-	for mnt in $mnts; do
+	if [ "$mnt_rid" == "$rid" ]; then
 		umount -f "$mnt" || \
-			echo_fail "umout -f $mnt failed"
-	done
+			echo_fail "umout -f $mnt"
+
+		exit 0
+	fi
 done
 
+#
+# If the mount doesn't exist on this host then it can't access the
+# devices by definition and can be considered fenced.
+#
 exit 0

tests/funcs/fs.sh

@@ -405,7 +405,7 @@ t_save_all_sysfs_mount_options() {
 
 	for i in $(t_fs_nrs); do
 		opt="$(t_sysfs_path $i)/mount_options/$name"
-		ind="${name}_${i}"
+		ind="$name_$i"
 
 		_saved_opts[$ind]="$(cat $opt)"
 	done
@@ -417,7 +417,7 @@ t_restore_all_sysfs_mount_options() {
 	local i
 
 	for i in $(t_fs_nrs); do
-		ind="${name}_${i}"
+		ind="$name_$i"
 
 		t_set_sysfs_mount_option $i $name "${_saved_opts[$ind]}"
 	done

tests/golden/data-prealloc

@@ -1,26 +0,0 @@
-== initial writes smaller than prealloc grow to prealloc size
-/mnt/test/test/data-prealloc/file-1: 7 extents found
-/mnt/test/test/data-prealloc/file-2: 7 extents found
-== larger files get full prealloc extents
-/mnt/test/test/data-prealloc/file-1: 9 extents found
-/mnt/test/test/data-prealloc/file-2: 9 extents found
-== non-streaming writes with contig have per-block extents
-/mnt/test/test/data-prealloc/file-1: 32 extents found
-/mnt/test/test/data-prealloc/file-2: 32 extents found
-== any writes to region prealloc get full extents
-/mnt/test/test/data-prealloc/file-1: 4 extents found
-/mnt/test/test/data-prealloc/file-2: 4 extents found
-/mnt/test/test/data-prealloc/file-1: 4 extents found
-/mnt/test/test/data-prealloc/file-2: 4 extents found
-== streaming offline writes get full extents either way
-/mnt/test/test/data-prealloc/file-1: 4 extents found
-/mnt/test/test/data-prealloc/file-2: 4 extents found
-/mnt/test/test/data-prealloc/file-1: 4 extents found
-/mnt/test/test/data-prealloc/file-2: 4 extents found
-== goofy preallocation amounts work
-/mnt/test/test/data-prealloc/file-1: 5 extents found
-/mnt/test/test/data-prealloc/file-2: 5 extents found
-/mnt/test/test/data-prealloc/file-1: 5 extents found
-/mnt/test/test/data-prealloc/file-2: 5 extents found
-/mnt/test/test/data-prealloc/file-1: 3 extents found
-/mnt/test/test/data-prealloc/file-2: 3 extents found

tests/golden/large-fragmented-free

@@ -1,3 +0,0 @@
-== creating fragmented extents
-== unlink file with moved extents to free extents per block
-== cleanup

tests/golden/lock-recover-invalidate

@@ -1,3 +0,0 @@
-== starting background invalidating read/write load
-== 60s of lock recovery during invalidating load
-== stopping background load

tests/golden/xfstests

@@ -40,19 +40,22 @@ generic/092
 generic/098
 generic/101
 generic/104
-generic/105
 generic/106
 generic/107
 generic/117
 generic/124
 generic/129
+generic/130
 generic/131
+generic/135
 generic/169
 generic/184
+generic/211
+generic/212
+generic/214
 generic/221
 generic/228
 generic/236
-generic/237
 generic/245
 generic/249
 generic/257
@@ -65,7 +68,6 @@ generic/308
 generic/309
 generic/313
 generic/315
-generic/319
 generic/322
 generic/335
 generic/336
@@ -75,7 +77,6 @@ generic/342
 generic/343
 generic/348
 generic/360
-generic/375
 generic/376
 generic/377
 Not
@@ -104,13 +105,9 @@ generic/078
 generic/079
 generic/081
 generic/082
-generic/091
-generic/094
 generic/096
 generic/110
 generic/111
-generic/113
-generic/114
 generic/115
 generic/116
 generic/118
@@ -119,9 +116,7 @@ generic/121
 generic/122
 generic/123
 generic/128
-generic/130
 generic/134
-generic/135
 generic/136
 generic/138
 generic/139
@@ -169,7 +164,6 @@ generic/194
 generic/195
 generic/196
 generic/197
-generic/198
 generic/199
 generic/200
 generic/201
@@ -177,11 +171,6 @@ generic/202
 generic/203
 generic/205
 generic/206
-generic/207
-generic/210
-generic/211
-generic/212
-generic/214
 generic/216
 generic/217
 generic/218
@@ -189,13 +178,11 @@ generic/219
 generic/220
 generic/222
 generic/223
-generic/225
 generic/227
 generic/229
 generic/230
 generic/235
 generic/238
-generic/240
 generic/244
 generic/250
 generic/252
@@ -207,7 +194,6 @@ generic/259
 generic/260
 generic/261
 generic/262
-generic/263
 generic/264
 generic/265
 generic/266
@@ -286,4 +272,4 @@ shared/004
 shared/032
 shared/051
 shared/289
-Passed all 79 tests
+Passed all 80 tests

tests/run-tests.sh

@@ -58,7 +58,6 @@ $(basename $0) options:
     -m        | Run mkfs on the device before mounting and running
               | tests.  Implies unmounting existing mounts first.
     -n <nr>   | The number of devices and mounts to test.
-    -o <opts> | Add option string to all mounts during all tests.
     -P        | Enable trace_printk.
     -p        | Exit script after preparing mounts only, don't run tests.
     -q <nr>   | The first <nr> mounts will be quorum members.  Must be
@@ -69,7 +68,6 @@ $(basename $0) options:
     -s        | Skip git repo checkouts.
     -t        | Enabled trace events that match the given glob argument.
               | Multiple options enable multiple globbed events.
-    -T <nr>   | Multiply the original trace buffer size by nr during the run.
     -X        | xfstests git repo. Used by tests/xfstests.sh.
     -x        | xfstests git branch to checkout and track.
     -y        | xfstests ./check additional args
@@ -138,12 +136,6 @@ while true; do
 		T_NR_MOUNTS="$2"
 		shift
 		;;
-	-o)
-		test -n "$2" || die "-o must have option string argument"
-		# always appending to existing options
-		T_MNT_OPTIONS+=",$2"
-		shift
-		;;
 	-P)
 		T_TRACE_PRINTK="1"
 		;;
@@ -168,11 +160,6 @@ while true; do
 		T_TRACE_GLOB+=("$2")
 		shift
 		;;
-	-T)
-		test -n "$2" || die "-T must have trace buffer size multiplier argument"
-		T_TRACE_MULT="$2"
-		shift
-		;;
 	-X)
 		test -n "$2" || die "-X requires xfstests git repo dir argument"
 		T_XFSTESTS_REPO="$2"
@@ -358,13 +345,6 @@ if [ -n "$T_INSMOD" ]; then
 	cmd insmod "$T_KMOD/src/scoutfs.ko"
 fi
 
-if [ -n "$T_TRACE_MULT" ]; then
-	orig_trace_size=$(cat /sys/kernel/debug/tracing/buffer_size_kb)
-	mult_trace_size=$((orig_trace_size * T_TRACE_MULT))
-	msg "increasing trace buffer size from $orig_trace_size KiB to $mult_trace_size KiB"
-	echo $mult_trace_size > /sys/kernel/debug/tracing/buffer_size_kb
-fi
-
 nr_globs=${#T_TRACE_GLOB[@]}
 if [ $nr_globs -gt 0 ]; then
 	echo 0 > /sys/kernel/debug/tracing/events/scoutfs/enable
@@ -394,21 +374,19 @@ fi
 # always describe tracing in the logs
 cmd cat /sys/kernel/debug/tracing/set_event
 cmd grep .  /sys/kernel/debug/tracing/options/trace_printk \
-	    /sys/kernel/debug/tracing/buffer_size_kb \
 	    /proc/sys/kernel/ftrace_dump_on_oops
 
 #
 # Build a fenced config that runs scripts out of the repository rather
 # than the default system directory
 #
-conf="$T_RESULTS/scoutfs-fenced.conf"
+conf="$T_RESULTS/scoutfs-fencd.conf"
 cat > $conf << EOF
 SCOUTFS_FENCED_DELAY=1
 SCOUTFS_FENCED_RUN=$T_TESTS/fenced-local-force-unmount.sh
-SCOUTFS_FENCED_RUN_ARGS="ignored run args"
+SCOUTFS_FENCED_RUN_ARGS=""
 EOF
 export SCOUTFS_FENCED_CONFIG_FILE="$conf"
-T_FENCED_LOG="$T_RESULTS/fenced.log"
 
 #
 # Run the agent in the background, log its output, an kill it if we
@@ -416,7 +394,7 @@ T_FENCED_LOG="$T_RESULTS/fenced.log"
 #
 fenced_log()
 {
-	echo "[$(timestamp)] $*" >> "$T_FENCED_LOG"
+	echo "[$(timestamp)] $*" >> "$T_RESULTS/fenced.stdout.log"
 }
 fenced_pid=""
 kill_fenced()
@@ -427,7 +405,7 @@ kill_fenced()
 	fi
 }
 trap kill_fenced EXIT
-$T_UTILS/fenced/scoutfs-fenced > "$T_FENCED_LOG" 2>&1 &
+$T_UTILS/fenced/scoutfs-fenced > "$T_RESULTS/fenced.stdout.log" 2> "$T_RESULTS/fenced.stderr.log" &
 fenced_pid=$!
 fenced_log "started fenced pid $fenced_pid in the background"
 
@@ -451,7 +429,6 @@ for i in $(seq 0 $((T_NR_MOUNTS - 1))); do
 	if [ "$i" -lt "$T_QUORUM" ]; then
 		opts="$opts,quorum_slot_nr=$i"
 	fi
-	opts="${opts}${T_MNT_OPTIONS}"
 
 	msg "mounting $meta_dev|$data_dev on $dir"
 	cmd mount -t scoutfs $opts "$data_dev" "$dir" &
@@ -626,9 +603,6 @@ if [ -n "$T_TRACE_GLOB" -o -n "$T_TRACE_PRINTK" ]; then
 	echo 0 > /sys/kernel/debug/tracing/events/scoutfs/enable
 	echo 0 > /sys/kernel/debug/tracing/options/trace_printk
 	cat /sys/kernel/debug/tracing/trace > "$T_RESULTS/traces"
-	if [ -n "$orig_trace_size" ]; then
-		echo $orig_trace_size > /sys/kernel/debug/tracing/buffer_size_kb
-	fi
 fi
 
 if [ "$skipped" == 0 -a "$failed" == 0 ]; then

tests/sequence

@@ -6,11 +6,9 @@ simple-inode-index.sh
 simple-staging.sh
 simple-release-extents.sh
 fallocate.sh
-data-prealloc.sh
 setattr_more.sh
 offline-extent-waiting.sh
 move-blocks.sh
-large-fragmented-free.sh
 enospc.sh
 srch-basic-functionality.sh
 simple-xattr-unit.sh
@@ -19,7 +17,6 @@ lock-refleak.sh
 lock-shrink-consistency.sh
 lock-pr-cw-conflict.sh
 lock-revoke-getcwd.sh
-lock-recover-invalidate.sh
 export-lookup-evict-race.sh
 createmany-parallel.sh
 createmany-large-names.sh

tests/src/fragmented_data_extents.c

@@ -1,113 +0,0 @@
-/*
- * Copyright (C) 2021 Versity Software, Inc.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-
-/*
- * This creates fragmented data extents.
- *
- * A file is created that has alternating free and allocated extents.
- * This also results in the global allocator having the matching
- * fragmented free extent pattern.  While that file is being created,
- * occasionally an allocated extent is moved to another file.   This
- * results in a file that has fragmented extents at a given stride that
- * can be deleted to create free data extents with a given stride.
- *
- * We don't have hole punching so to do this quickly we use a goofy
- * combination of fallocate, truncate, and our move_blocks ioctl.
- */
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <linux/types.h>
-#include <assert.h>
-
-#include "ioctl.h"
-
-#define BLOCK_SIZE 4096
-
-int main(int argc, char **argv)
-{
-	struct scoutfs_ioctl_move_blocks mb = {0,};
-	unsigned long long freed_extents;
-	unsigned long long move_stride;
-	unsigned long long i;
-	int alloc_fd;
-	int trunc_fd;
-	off_t off;
-	int ret;
-
-	if (argc != 5) {
-		printf("%s <freed_extents> <move_stride> <alloc_file> <trunc_file>\n", argv[0]);
-		return 1;
-	}
-
-	freed_extents = strtoull(argv[1], NULL, 0);
-	move_stride = strtoull(argv[2], NULL, 0);
-
-	alloc_fd = open(argv[3], O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
-	if (alloc_fd == -1) {
-		fprintf(stderr, "error opening %s: %d (%s)\n", argv[3], errno, strerror(errno));
-		exit(1);
-	}
-
-	trunc_fd = open(argv[4], O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
-	if (trunc_fd == -1) {
-		fprintf(stderr, "error opening %s: %d (%s)\n", argv[4], errno, strerror(errno));
-		exit(1);
-	}
-
-	for (i = 0, off = 0; i < freed_extents; i++, off += BLOCK_SIZE * 2) {
-
-		ret = fallocate(alloc_fd, 0, off, BLOCK_SIZE * 2);
-		if (ret < 0) {
-			fprintf(stderr, "fallocate at off %llu error: %d (%s)\n",
-				(unsigned long long)off, errno, strerror(errno));
-			exit(1);
-		}
-
-		ret = ftruncate(alloc_fd, off + BLOCK_SIZE);
-		if (ret < 0) {
-			fprintf(stderr, "truncate to off %llu error: %d (%s)\n",
-				(unsigned long long)off + BLOCK_SIZE, errno, strerror(errno));
-			exit(1);
-		}
-
-		if ((i % move_stride) == 0) {
-			mb.from_fd = alloc_fd;
-			mb.from_off = off;
-			mb.len = BLOCK_SIZE;
-			mb.to_off = i * BLOCK_SIZE;
-
-			ret = ioctl(trunc_fd, SCOUTFS_IOC_MOVE_BLOCKS, &mb);
-			if (ret < 0) {
-				fprintf(stderr, "move from off %llu error: %d (%s)\n",
-					(unsigned long long)off,
-					errno, strerror(errno));
-			}
-		}
-	}
-
-	if (alloc_fd > -1)
-		close(alloc_fd);
-	if (trunc_fd > -1)
-		close(trunc_fd);
-
-	return 0;
-}

tests/tests/data-prealloc.sh

@@ -1,136 +0,0 @@
-#
-# test that the data prealloc options behave as expected.  We write to
-# two files a block at a time so that a single file doesn't naturally
-# merge adjacent consecutive allocations.  (we don't have multiple
-# allocation cursors)
-#
-t_require_commands scoutfs stat filefrag dd touch truncate
-
-write_forwards()
-{
-	local prefix="$1"
-	local nr="$2"
-	local blk
-
-	touch "$prefix"-{1,2}
-	truncate -s 0 "$prefix"-{1,2}
-
-	for blk in $(seq 0 1 $((nr - 1))); do
-		dd if=/dev/zero of="$prefix"-1 bs=4096 seek=$blk count=1 conv=notrunc status=none
-		dd if=/dev/zero of="$prefix"-2 bs=4096 seek=$blk count=1 conv=notrunc status=none
-	done
-}
-
-write_backwards()
-{
-	local prefix="$1"
-	local nr="$2"
-	local blk
-
-	touch "$prefix"-{1,2}
-	truncate -s 0 "$prefix"-{1,2}
-
-	for blk in $(seq $((nr - 1)) -1 0); do
-		dd if=/dev/zero of="$prefix"-1 bs=4096 seek=$blk count=1 conv=notrunc status=none
-		dd if=/dev/zero of="$prefix"-2 bs=4096 seek=$blk count=1 conv=notrunc status=none
-	done
-}
-
-release_files() {
-	local prefix="$1"
-	local size=$(($2 * 4096))
-	local vers
-	local f
-
-	for f in "$prefix"*; do
-		size=$(stat -c "%s" "$f")
-		vers=$(scoutfs stat -s data_version "$f")
-		scoutfs release "$f" -V "$vers" -o 0 -l $size
-	done
-}
-
-stage_files() {
-	local prefix="$1"
-	local nr="$2"
-	local vers
-	local f
-
-	for blk in $(seq 0 1 $((nr - 1))); do
-		for f in "$prefix"*; do
-			vers=$(scoutfs stat -s data_version "$f")
-			scoutfs stage /dev/zero "$f" -V "$vers" -o $((blk * 4096)) -l 4096
-		done
-	done
-}
-
-print_extents_found()
-{
-	local prefix="$1"
-
-	filefrag "$prefix"* 2>&1 | grep "extent.*found" | t_filter_fs
-}
-
-t_save_all_sysfs_mount_options data_prealloc_blocks
-t_save_all_sysfs_mount_options data_prealloc_contig_only
-restore_options()
-{
-	t_restore_all_sysfs_mount_options data_prealloc_blocks
-	t_restore_all_sysfs_mount_options data_prealloc_contig_only
-}
-trap restore_options EXIT
-
-prefix="$T_D0/file"
-
-echo "== initial writes smaller than prealloc grow to prealloc size"
-t_set_sysfs_mount_option 0 data_prealloc_blocks 32
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 1
-write_forwards $prefix 64
-print_extents_found $prefix
-
-echo "== larger files get full prealloc extents"
-t_set_sysfs_mount_option 0 data_prealloc_blocks 32
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 1
-write_forwards $prefix 128
-print_extents_found $prefix
-
-echo "== non-streaming writes with contig have per-block extents"
-t_set_sysfs_mount_option 0 data_prealloc_blocks 32
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 1
-write_backwards $prefix 32
-print_extents_found $prefix
-
-echo "== any writes to region prealloc get full extents"
-t_set_sysfs_mount_option 0 data_prealloc_blocks 16
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 0
-write_forwards $prefix 64
-print_extents_found $prefix
-write_backwards $prefix 64
-print_extents_found $prefix
-
-echo "== streaming offline writes get full extents either way"
-t_set_sysfs_mount_option 0 data_prealloc_blocks 16
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 1
-write_forwards $prefix 64
-release_files $prefix 64
-stage_files $prefix 64
-print_extents_found $prefix
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 0
-release_files $prefix 64
-stage_files $prefix 64
-print_extents_found $prefix
-
-echo "== goofy preallocation amounts work"
-t_set_sysfs_mount_option 0 data_prealloc_blocks 7
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 1
-write_forwards $prefix 14
-print_extents_found $prefix
-t_set_sysfs_mount_option 0 data_prealloc_blocks 13
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 0
-write_forwards $prefix 53
-print_extents_found $prefix
-t_set_sysfs_mount_option 0 data_prealloc_blocks 1
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 0
-write_forwards $prefix 3
-print_extents_found $prefix
-
-t_pass

tests/tests/fence-and-reclaim.sh

@@ -45,18 +45,6 @@ check_read_write()
 	fi
 }
 
-# verify that fenced ran our testing fence script
-verify_fenced_run()
-{
-	local rids="$@"
-	local rid
-
-	for rid in $rids; do
-		grep -q ".* running rid '$rid'.* args 'ignored run args'" "$T_FENCED_LOG" || \
-			t_fail "fenced didn't execute RUN script for rid $rid"
-	done
-}
-
 echo "== make sure all mounts can see each other"
 check_read_write
 
@@ -74,14 +62,12 @@ done
 while t_rid_is_fencing $rid; do
 	sleep .5
 done
-verify_fenced_run $rid
 t_mount $cl
 check_read_write
 
 echo "== force unmount all non-server, connection timeout, fence nop, mount"
 sv=$(t_server_nr)
 pattern="nonsense"
-rids=""
 sync
 for cl in $(t_fs_nrs); do
 	if [ $cl == $sv ]; then
@@ -89,7 +75,6 @@ for cl in $(t_fs_nrs); do
 	fi
 
 	rid=$(t_mount_rid $cl)
-	rids="$rids $rid"
 	pattern="$pattern|$rid"
 	echo "cl $cl sv $sv rid $rid" >> "$T_TMP.log"
 
@@ -104,7 +89,6 @@ done
 while test -d $(echo /sys/fs/scoutfs/*/fence/* | cut -d " " -f 1); do
 	sleep .5
 done
-verify_fenced_run $rids
 # remount all the clients
 for cl in $(t_fs_nrs); do
 	if [ $cl == $sv ]; then
@@ -125,17 +109,11 @@ t_wait_for_leader
 while t_rid_is_fencing $rid; do
 	sleep .5
 done
-verify_fenced_run $rid
 t_mount $sv
 check_read_write
 
 echo "== force unmount everything, new server fences all previous"
 sync
-rids=""
-# get rids before forced unmount breaks scoutfs statfs
-for nr in $(t_fs_nrs); do
-	rids="$rids $(t_mount_rid $nr)"
-done
 for nr in $(t_fs_nrs); do
 	t_force_umount $nr
 done
@@ -144,7 +122,6 @@ t_mount_all
 while test -d $(echo /sys/fs/scoutfs/*/fence/* | cut -d " " -f 1); do
 	sleep .5
 done
-verify_fenced_run $rids
 check_read_write
 
 t_pass

tests/tests/large-fragmented-free.sh

@@ -1,22 +0,0 @@
-#
-# Make sure the server can handle a transaction with a data_freed whose
-# blocks all hit different btree blocks in the main free list.  It
-# probably has to be merged in multiple commits.
-#
-
-t_require_commands fragmented_data_extents
-
-EXTENTS_PER_BTREE_BLOCK=600
-EXTENTS_PER_LIST_BLOCK=8192
-FREED_EXTENTS=$((EXTENTS_PER_BTREE_BLOCK * EXTENTS_PER_LIST_BLOCK))
-
-echo "== creating fragmented extents"
-fragmented_data_extents $FREED_EXTENTS $EXTENTS_PER_BTREE_BLOCK "$T_D0/alloc" "$T_D0/move"
-
-echo "== unlink file with moved extents to free extents per block"
-rm -f "$T_D0/move"
-
-echo "== cleanup"
-rm -f "$T_D0/alloc"
-
-t_pass

tests/tests/lock-recover-invalidate.sh

@@ -1,43 +0,0 @@
-#
-# trigger server failover and lock recovery during heavy invalidating
-# load on multiple mounts
-#
-
-majority_nr=$(t_majority_count)
-quorum_nr=$T_QUORUM
-
-test "$quorum_nr" == "$majority_nr" && \
-        t_skip "need remaining majority when leader unmounted"
-
-test "$T_NR_MOUNTS" -lt "$((quorum_nr + 2))" && \
-        t_skip "need at least 2 non-quorum load mounts"
-
-echo "== starting background invalidating read/write load"
-touch "$T_D0/file"
-load_pids=""
-for i in $(t_fs_nrs); do
-	if [ "$i" -ge "$quorum_nr" ]; then
-		eval path="\$T_D${i}/file"
-
-		(while true; do touch $path > /dev/null 2>&1; done) &
-		load_pids="$load_pids $!"
-		(while true; do stat $path > /dev/null 2>&1; done) &
-		load_pids="$load_pids $!"
-	fi
-done
-
-# had it reproduce in ~40s on wimpy debug kernel guests
-LENGTH=60
-echo "== ${LENGTH}s of lock recovery during invalidating load"
-END=$((SECONDS + LENGTH))
-while [ "$SECONDS" -lt "$END" ]; do
-        sv=$(t_server_nr)
-        t_umount $sv
-        t_mount $sv
-	# new server had to process greeting for mount to finish
-done
-
-echo "== stopping background load"
-kill $load_pids
-
-t_pass

tests/tests/simple-xattr-unit.sh

@@ -36,8 +36,7 @@ test_xattr_lengths() {
 	else
 		echo "$name=\"$val\"" > "$T_TMP.good"
 	fi
-	cmp "$T_TMP.good" "$T_TMP.got" || \
-		t_fail "cmp failed name len $name_len val len $val_len"
+	cmp "$T_TMP.good" "$T_TMP.got" || exit 1
 
 	setfattr -x $name "$FILE"
 }

tests/tests/xfstests.sh

@@ -64,22 +64,36 @@ generic/029	# mmap missing
 generic/030	# mmap missing
 generic/075	# file content mismatch failures (fds, etc)
 generic/080	# mmap missing
+generic/091	# skip fsx tests
+generic/094	# odirect streaming pre-alloc treated as failure in xfstests
 generic/103	# enospc causes trans commit failures
+generic/105	# needs trigage: something about acls
 generic/108	# mount fails on failing device?
 generic/112	# file content mismatch failures (fds, etc)
+generic/113	# block aio dio runs
+generic/114	# block aio dio runs
 generic/120	# (can't exec 'cause no mmap)
 generic/126	# (can't exec 'cause no mmap)
 generic/141	# mmap missing
+generic/198	# block aio dio runs
+generic/207	# block aio dio runs
+generic/210	# block aio dio runs
 generic/213	# enospc causes trans commit failures
 generic/215	# mmap missing
+generic/225	# odirect streaming pre-alloc treated as failure in xfstests
+generic/237	# wrong error return from failing setfacl?
+generic/240	# block aio dio runs
 generic/246	# mmap missing
 generic/247	# mmap missing
 generic/248	# mmap missing
+generic/263	# do not support allocate mode FALLOC_FL_PUNCH_HOLE, FALLOC_FL_KEEP_SIZE, FALLOC_FL_ZERO_RANGE...
+generic/319	# utils output change?  update branch?
 generic/321	# requires selinux enabled for '+' in ls?
 generic/325	# mmap missing
 generic/338	# BUG_ON update inode error handling
 generic/346	# mmap missing
 generic/347	# _dmthin_mount doesn't work?
+generic/375	# utils output change?  update branch?
 EOF
 
 t_restore_output

utils/fenced/scoutfs-fenced

@@ -55,21 +55,9 @@ test -x "$SCOUTFS_FENCED_RUN" || \
 	error_exit "SCOUTFS_FENCED_RUN '$SCOUTFS_FENCED_RUN' isn't executable"
 
 #
-# Main loop watching for fence request across all filesystems.   The
-# server can shut down without waiting for pending fence requests to
-# finish.  All of the interaction with the fence directory and files can
-# fail at any moment.  We will generate log messages when the dir or
-# files disappear.
+# main loop watching for fence request across all filesystems 
 #
 
-# generate failure messages to stderr while still echoing 0 for the caller
-careful_cat()
-{
-	local path="$@"
-
-	cat "$@" || echo 0
-}
-
 while sleep $SCOUTFS_FENCED_DELAY; do
 	for fence in /sys/fs/scoutfs/*/fence/*; do
 		# catches unmatched regex when no dirs
@@ -78,8 +66,7 @@ while sleep $SCOUTFS_FENCED_DELAY; do
 		fi
 
 		# skip requests that have been handled
-		if [ "$(careful_cat $fence/fenced)" == 1 -o \
-		     "$(careful_cat $fence/error)" == 1 ]; then
+		if [ $(cat "$fence/fenced") == 1 -o $(cat "$fence/error") == 1 ]; then
 			continue
 		fi
 
@@ -94,10 +81,10 @@ while sleep $SCOUTFS_FENCED_DELAY; do
 		export SCOUTFS_FENCED_REQ_RID="$rid"
 		export SCOUTFS_FENCED_REQ_IP="$ip"
 
-		$SCOUTFS_FENCED_RUN $SCOUTFS_FENCED_RUN_ARGS
+		$run $SCOUTFS_FENCED_RUN_ARGS
 		rc=$?
 		if [ "$rc" != 0 ]; then
-			log_message "server $srv fencing rid $rid saw error status $rc"
+			log_message "server $srv fencing rid $rid saw error status $rc from $run"
 			echo 1 > "$fence/error"
 			continue
 		fi

utils/man/scoutfs.5

@@ -15,61 +15,12 @@ general mount options described in the
 .BR mount (8)
 manual page.
 .TP
-.B acl
-The acl mount option enables support for POSIX Access Control Lists
-as detailed in
-.BR acl (5) .
-Support for POSIX ACLs is the default.
-.TP
-.B data_prealloc_blocks=<blocks>
-Set the size of preallocation regions of data files, in 4KiB blocks.
-Writes to these regions that contain no extents will attempt to
-preallocate the size of the full region.  This can waste a lot of space
-with small files, files with sparse regions, and files whose final
-length isn't a multiple of the preallocation size.  The following
-data_prealloc_contig_only option, which is the default, restricts this
-behaviour to waste less space.
-.sp
-All the preallocation options can be changed in an active mount by
-writing to their respective files in the options directory in the
-mount's sysfs directory.
-.sp
-It is worth noting that it is always more efficient in every way to use 
-.BR fallocate (2)
-to precisely allocate large extents for the resulting size of the file.
-Always attempt to enable it in software that supports it.
-.TP
-.B data_prealloc_contig_only=<0|1>
-This option, currently the default, limits file data preallocation in
-two ways.  First, it will only preallocate when extending a fully
-allocated file.  Second, it will limit the size of preallocation to the
-existing length of the file.  These limits reduce the amount of
-preallocation wasted per file at the cost of multiple initial extents in
-all files.  It only supports simple streaming writes, any other write
-pattern will not be recognized and could result in many fragmented
-extent allocations.
-.sp
-This option can be disabled to encourage large allocated extents
-regardless of write patterns.  This can be helpful if files are written
-with initial sparse regions (perhaps by multiple threads writing to
-different regions) and wasted space isn't an issue (perhaps because the
-file population contains few small files).
-.TP
 .B metadev_path=<device>
 The metadev_path option specifies the path to the block device that
 contains the filesystem's metadata.
 .sp
 This option is required.
 .TP
-.B noacl
-The noacl mount option disables the default support for POSIX Access
-Control Lists.  Any existing system.posix_acl_default and
-system.posix_acl_access extended attributes remain in inodes.   They
-will appear in listings from
-.BR listxattr (5)
-but specific retrieval or reomval operations will fail.  They will be
-used for enforcement again if ACL support is later enabled.
-.TP
 .B orphan_scan_delay_ms=<number>
 This option sets the average expected delay, in milliseconds, between
 each mount's scan of the global orphaned inode list.  Jitter is added to

utils/man/scoutfs.8

@@ -597,7 +597,7 @@ format.
 .PD
 
 .TP
-.BI "print {-S|--skip-likely-huge} META-DEVICE"
+.BI "print META-DEVICE"
 .sp
 Prints out all of the metadata in the file system.  This makes no effort
 to ensure that the structures are consistent as they're traversed and
@@ -607,20 +607,6 @@ output.
 .PD 0
 .TP
 .sp
-.B "-S, --skip-likely-huge"
-Skip printing structures that are likely to be very large.  The
-structures that are skipped tend to be global and whose size tends to be
-related to the size of the volume.   Examples of skipped structures include
-the global fs items, srch files, and metadata and data
-allocators.  Similar structures that are not skipped are related to the
-number of mounts and are maintained at a relatively reasonable size.
-These include per-mount log trees, srch files, allocators, and the
-metadata allocators used by server commits.
-.sp
-Skipping the larger structures limits the print output to a relatively
-constant size rather than being a large multiple of the used metadata
-space of the volume making the output much more useful for inspection.
-.TP
 .B "META-DEVICE"
 The path to the metadata device for the filesystem whose metadata will be
 printed.  Since this command reads via the host's buffer cache, it may not

utils/src/print.c

@@ -8,7 +8,6 @@
 #include <errno.h>
 #include <string.h>
 #include <stdarg.h>
-#include <stdbool.h>
 #include <ctype.h>
 #include <uuid/uuid.h>
 #include <sys/socket.h>
@@ -990,10 +989,9 @@ static void print_super_block(struct scoutfs_super_block *super, u64 blkno)
 
 struct print_args {
 	char *meta_device;
-	bool skip_likely_huge;
 };
 
-static int print_volume(int fd, struct print_args *args)
+static int print_volume(int fd)
 {
 	struct scoutfs_super_block *super = NULL;
 	struct print_recursion_args pa;
@@ -1043,26 +1041,23 @@ static int print_volume(int fd, struct print_args *args)
 			ret = err;
 	}
 
-	if (!args->skip_likely_huge) {
-		for (i = 0; i < array_size(super->meta_alloc); i++) {
-			snprintf(str, sizeof(str), "meta_alloc[%u]", i);
-			err = print_btree(fd, super, str, &super->meta_alloc[i].root,
-					  print_alloc_item, NULL);
-			if (err && !ret)
-				ret = err;
-		}
-
-		err = print_btree(fd, super, "data_alloc", &super->data_alloc.root,
+	for (i = 0; i < array_size(super->meta_alloc); i++) {
+		snprintf(str, sizeof(str), "meta_alloc[%u]", i);
+		err = print_btree(fd, super, str, &super->meta_alloc[i].root,
 				  print_alloc_item, NULL);
 		if (err && !ret)
 			ret = err;
 	}
 
+	err = print_btree(fd, super, "data_alloc", &super->data_alloc.root,
+			  print_alloc_item, NULL);
+	if (err && !ret)
+		ret = err;
+
 	err = print_btree(fd, super, "srch_root", &super->srch_root,
 			  print_srch_root_item, NULL);
 	if (err && !ret)
 		ret = err;
-
 	err = print_btree(fd, super, "logs_root", &super->logs_root,
 			  print_log_trees_item, NULL);
 	if (err && !ret)
@@ -1070,23 +1065,19 @@ static int print_volume(int fd, struct print_args *args)
 
 	pa.super = super;
 	pa.fd = fd;
-	if (!args->skip_likely_huge) {
-		err = print_btree_leaf_items(fd, super, &super->srch_root.ref,
-					     print_srch_root_files, &pa);
-		if (err && !ret)
-			ret = err;
-	}
+	err = print_btree_leaf_items(fd, super, &super->srch_root.ref,
+				     print_srch_root_files, &pa);
+	if (err && !ret)
+		ret = err;
 	err = print_btree_leaf_items(fd, super, &super->logs_root.ref,
 				     print_log_trees_roots, &pa);
 	if (err && !ret)
 		ret = err;
 
-	if (!args->skip_likely_huge) {
-		err = print_btree(fd, super, "fs_root", &super->fs_root,
-				  print_fs_item, NULL);
-		if (err && !ret)
-			ret = err;
-	}
+	err = print_btree(fd, super, "fs_root", &super->fs_root,
+			  print_fs_item, NULL);
+	if (err && !ret)
+		ret = err;
 
 out:
 	free(super);
@@ -1107,7 +1098,7 @@ static int do_print(struct print_args *args)
 		return ret;
 	}
 
-	ret = print_volume(fd, args);
+	ret = print_volume(fd);
 	close(fd);
 	return ret;
 };
@@ -1117,9 +1108,6 @@ static int parse_opt(int key, char *arg, struct argp_state *state)
 	struct print_args *args = state->input;
 
 	switch (key) {
-	case 'S':
-		args->skip_likely_huge = true;
-		break;
 	case ARGP_KEY_ARG:
 		if (!args->meta_device)
 			args->meta_device = strdup_or_error(state, arg);
@@ -1137,13 +1125,8 @@ static int parse_opt(int key, char *arg, struct argp_state *state)
 	return 0;
 }
 
-static struct argp_option options[] = {
-	{ "skip-likely-huge", 'S', NULL, 0, "Skip large structures to minimize output size"},
-	{ NULL }
-};
-
 static struct argp argp = {
-	options,
+	NULL,
 	parse_opt,
 	"META-DEV",
 	"Print metadata structures"