Use cwskip for the item cache

The use of pages in the item cache got us pretty far but it
fundmanetally couldn't escape the contention around the global or
per-page read locks.  Some loads became bottlenecked in contention
in the item cache.   Worse, we were seeing inconsistency in the
per-cpu cached mappings of key ranges to pages.

All the users of items in the cache are transitioned from searching for
items in locked pages to searching for items in the cwskip list.  It's
fundamentally built around a seqlock-like begin/retry pattern so most of
the item work gets wrapped around search and retry helpers.

Without pages we no longer have a global list of dirty pages.   Instead
we have per-cpu lists of dirty items that are later sorted and handed to
the btree insertion iterator.   We take the opportunity to clean up that
interface now that it's very easy for us to iterate through the stable
list of dirty items.

Rather than a global lru of pages we have an algorithm for maintaining
items in rough groups of ages.  Shrinking randomly walks the cwskip list
looking for regions of sufficiently old items rather than walking a
precise global lru list of pages.

Signed-off-by: Zach Brown <zab@versity.com>

ReleaseNotes.md

@@ -2,269 +2,9 @@ Versity ScoutFS Release Notes
 =============================
 
 ---
-v1.15
+v1.x
 \
-*Jul 17, 2023*
-
-Process log btree merge splicing in multiple commits.  This prevents a
-rare case where pending log merge completions contain more work than can
-be done in a single server commit, causing the server to trigger an
-assert shortly after starting.
-
-Fix spurious EINVAL from data writes when data\_prealloc\_contig\_only was
-set to 0.
-
----
-v1.14
-\
-*Jun 29, 2023*
-
-Add get\_referring\_entries ioctl for getting directory entries that
-refer to an inode.
-
-Fix excessive CPU use in the move\_blocks interface when moving a large
-number of extents.
-
-Reduce fragmented data allocation when contig\_only prealloc is not in
-use by more consistently allocating multi-block extents within each
-aligned prealloc region.
-
-Avoid rare deadlock in metadata block cache recalim under both heavy
-load and memory pressure.
-
-Fix crash when using quorum\_heartbeat\_timeout\_ms mount option.
-
----
-v1.13
-\
-*May 19, 2023*
-
-Add the quorum\_heartbeat\_timeout\_ms mount option to set the quorum
-heartbeat timeout.
-
-Change some task prioritization and allocation behavior of the quorum
-agent to help reduce delays in sending and receiving heartbeat messages.
-
----
-v1.12
-\
-*Apr 17, 2023*
-
-Add the prepare-empty-data-device scoutfs command.  A data device can be
-unused when no files have data blocks, perhaps because they're archived
-and offline.  In this case the data device can be swapped out for
-another device without changes to the metadata device.
-
-Fix an oversight which limited inode timestamps to second granularity
-for some operations.  All operations now record timestamps with full
-nanosecond precision.
-
-Fix spurious ENOENT failures when renaming from other directories into
-the root directory.
-
----
-v1.11
-\
-*Feb 2, 2023*
-
-Fixed a free extent processing error that could prevent mount from
-proceeding when free data extents were sufficiently fragmented.  It now
-properly handle very fragmented free extent maps.
-
-Fixed a statfs server processing race that could return spurious errors
-and shut down the server.  With the race closed statfs processing is
-reliable.
-
-Fixed a rare livelock in the move\_blocks ioctl.  With the right
-relationship between ioctl arguments and eventual file extent items the
-core loop in the move\_blocks ioctl could get stuck looping on an extent
-item and never return.  The loop exit conditions were fixed and the loop
-will always advance through all extents.
-
-Changed the 'print' scoutfs commands to flush the block cache for the
-devices.  It was inconvenient to expect cache flushing to be a separate
-step to ensure consistency with remote node writes.
-
----
-v1.10
-\
-*Dec 7, 2022*
-
-Fixed a potential directory entry cache management deadlock that could
-occur when many nodes performed heavy metadata write loads across shared
-directories and their child subdirectories.  The deadlock could halt
-invalidation progress on a node which could then stop use of locks that
-needed invalidation on that node which would result in almost all tasks
-hanging on those locks that would never make progress. 
-
-Fixed a circumstance where metadata change sequence index item
-modification could leave behind old stale metadata sequence items.  The
-duplication case required concurrent metadata updates across mounts with
-particular open transaction patterns so the duplicate items are rare.
-They resulted in a small amount of additional load when walking change
-indexes but had no effect on correctness.
-
-Fixed a rare case where sparse file extension might not write partial
-blocks of zeros which was found in testing.  This required using
-truncate to extend files past file sizes that end in partial blocks
-along with the right transaction commit and memory reclaim patterns.
-This never affected regular non-sparse files nor files prepopulated with
-fallocate.
-
----
-v1.9
-\
-*Oct 29, 2022*
-
-Fix VFS cached directory entry consistency verification that could cause
-spurious "no such file or directory" (ENOENT) errors from rename over
-NFS under certain conditions.  The problem was only every with the
-consistency of in-memory cached dentry objects, persistent data was
-correct and eventual eviction of the bad cached objects would stop
-generating the errors.
-
----
-v1.8
-\
-*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.
-
----
-v1.2
-\
-*Mar 14, 2022*
-
-* **Fix deadlock between fallocate() and read() system calls**
-\
-  Fixed a lock inversion that could cause two tasks to deadlock if they
-  performed fallocate() and read() on a file at the same time.   The
-  deadlock was uninterruptible so the machine needed to be rebooted.  This
-  was relatively rare as fallocate() is usually used to prepare files
-  before they're used.
-
-* **Fix instability from heavy file deletion workloads**
-\
-  Fixed rare circumstances under which background file deletion cleanup
-  tasks could try to delete a file while it is being deleted by another
-  task.  Heavy load across multiple nodes, either many files being deleted
-  or large files being deleted, increased the chances of this happening.
-  Heavy staging could cause this problem because staging can create many
-  internal temporary files that need to be deleted.
-
----
-v1.1
-\
-*Feb 4, 2022*
+*TBD*
 
 
 * **Add scoutfs(1) change-quorum-config command**
@@ -274,15 +14,6 @@ v1.1
   unmounted.   This can be used to change the mounts that will
   participate in quorum and the IP addresses they use.
 
-* **Fix Rare Risk of Item Cache Corruption**
-\
-  Code review found a rare potential source of item cache corruption.
-  If this happened it would look as though deleted parts of the filesystem
-  returned, but only at the time they were deleted.  Old deleted items are
-  not affected.  This problem only affected the item cache, never
-  persistent storage.  Unmounting and remounting would drop the bad item
-  cache and resync it with the correct persistent data.
-
 ---
 v1.0
 \

kmod/Makefile

@@ -31,12 +31,12 @@ TARFILE = scoutfs-kmod-$(RPM_VERSION).tar
 all: module
 
 module:
-	$(MAKE) $(SCOUTFS_ARGS)
-	$(SP) $(MAKE) C=2 CF="-D__CHECK_ENDIAN__" $(SCOUTFS_ARGS)
+	make $(SCOUTFS_ARGS)
+	$(SP) make C=2 CF="-D__CHECK_ENDIAN__" $(SCOUTFS_ARGS)
 
 
 modules_install:
-	$(MAKE) $(SCOUTFS_ARGS) modules_install
+	make $(SCOUTFS_ARGS) modules_install
 
 
 %.spec: %.spec.in .FORCE
@@ -50,4 +50,4 @@ dist: scoutfs-kmod.spec
 	@ tar rf $(TARFILE) --transform="s@\(.*\)@scoutfs-kmod-$(RPM_VERSION)/\1@" scoutfs-kmod.spec
 
 clean:
-	$(MAKE) $(SCOUTFS_ARGS) clean
+	make $(SCOUTFS_ARGS) clean

kmod/scoutfs-kmod.spec.in

@@ -3,28 +3,16 @@
 %define kmod_git_hash @@GITHASH@@
 %define pkg_date %(date +%%Y%%m%%d)
 
-# Disable the building of the debug package(s).
-%define debug_package %{nil}
-
 # take kernel version or default to uname -r
 %{!?kversion: %global kversion %(uname -r)}
 %global kernel_version %{kversion}
 
-%if 0%{?el7}
 %global kernel_source() /usr/src/kernels/%{kernel_version}.$(arch)
-%endif
-%if 0%{?el8}
-%global kernel_source() /usr/src/kernels/%{kernel_version}
-%endif
+%global kernel_release() %{kversion}
 
 %{!?_release: %global _release 0.%{pkg_date}git%{kmod_git_hash}}
 
-%if 0%{?el7}
 Name:           %{kmod_name}
-%endif
-%if 0%{?el8}
-Name:           kmod-%{kmod_name}
-%endif
 Summary:        %{kmod_name} kernel module
 Version:        %{kmod_version}
 Release:        %{_release}%{?dist}
@@ -32,30 +20,24 @@ License:        GPLv2
 Group:          System/Kernel
 URL:            http://scoutfs.org/
 
-%if 0%{?el7}
 BuildRequires:  %{kernel_module_package_buildreqs}
-%endif
-%if 0%{?el8}
-BuildRequires:  elfutils-libelf-devel
-%endif
-BuildRequires:  kernel-devel-uname-r = %{kernel_version}
 BuildRequires:  git
+BuildRequires:  kernel-devel-uname-r = %{kernel_version}
 BuildRequires:  module-init-tools
 
 ExclusiveArch:  x86_64
 
 Source:		%{kmod_name}-kmod-%{kmod_version}.tar
 
-%if 0%{?el7}
 # Build only for standard kernel variant(s); for debug packages, append "debug"
 # after "default" (separated by space)
 %kernel_module_package default
-%endif
 
-%global install_mod_dir extra/%{kmod_name}
-%if 0%{?el8}
-%global flavors_to_build x86_64
-%endif
+# Disable the building of the debug package(s).
+%define debug_package %{nil}
+
+%global install_mod_dir extra/%{name}
+
 
 %description
 %{kmod_name} - kernel module
@@ -84,7 +66,7 @@ export INSTALL_MOD_DIR=%{install_mod_dir}
 mkdir -p %{install_mod_dir}
 for flavor in %{flavors_to_build}; do
 	export KSRC=%{kernel_source $flavor}
-	export KVERSION=%{kversion}
+	export KVERSION=%{kernel_release $KSRC}
 	install -d $INSTALL_MOD_PATH/lib/modules/$KVERSION/%{install_mod_dir}
 	cp $PWD/obj/$flavor/src/scoutfs.ko $INSTALL_MOD_PATH/lib/modules/$KVERSION/%{install_mod_dir}/
 done
@@ -92,14 +74,6 @@ done
 # mark modules executable so that strip-to-file can strip them
 find %{buildroot} -type f -name \*.ko -exec %{__chmod} u+x \{\} \;
 
-%if 0%{?el8}
-%files
-/lib/modules
-
-%post
-weak-modules --add-kernel --no-initramfs
-depmod -a
-%endif
 
 %clean
 rm -rf %{buildroot}

kmod/src/Makefile

@@ -8,12 +8,12 @@ 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			\
 	btree.o			\
 	client.o		\
+	cwskip.o		\
 	counters.o		\
 	data.o			\
 	dir.o			\
@@ -25,7 +25,6 @@ scoutfs-y +=			\
 	inode.o			\
 	ioctl.o			\
 	item.o			\
-	kernelcompat.o		\
 	lock.o			\
 	lock_server.o		\
 	msg.o			\

kmod/src/Makefile.kernelcompat

@@ -26,16 +26,6 @@ ifneq (,$(shell grep 'dir_emit_dots' include/linux/fs.h))
 ccflags-y += -DKC_DIR_EMIT_DOTS
 endif
 
-#
-# v3.18-rc2-19-gb5ae6b15bd73
-# 
-# Folds d_materialise_unique into d_splice_alias. Note reversal
-# of arguments (Also note Documentation/filesystems/porting.rst)
-#
-ifneq (,$(shell grep 'd_materialise_unique' include/linux/dcache.h))
-ccflags-y += -DKC_D_MATERIALISE_UNIQUE=1
-endif
-
 #
 # RHEL extended the fop struct so to use it we have to set
 # a flag to indicate that the struct is large enough and
@@ -44,217 +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_namespace' include/linux/posix_acl.h))
-ccflags-y += -DKC_POSIX_ACL_VALID_USER_NS
-endif
-
-#
-# v5.3-12296-g6d2052d188d9
-#
-# The RBCOMPUTE function is now passed an extra flag, and should return a bool
-# to indicate whether the propagated callback should stop or not.
-#
-ifneq (,$(shell grep 'static inline bool RBNAME.*_compute_max' include/linux/rbtree_augmented.h))
-ccflags-y += -DKC_RB_TREE_AUGMENTED_COMPUTE_MAX
-endif
-
-#
-# v3.13-25-g37bc15392a23
-#
-# Renames posix_acl_create to __posix_acl_create and provide some
-# new interfaces for creating ACLs
-#
-ifneq (,$(shell grep '__posix_acl_create' include/linux/posix_acl.h))
-ccflags-y += -DKC___POSIX_ACL_CREATE
-endif
-
-#
-# v4.8-rc1-29-g31051c85b5e2
-#
-# inode_change_ok() removed - replace with setattr_prepare()
-#
-ifneq (,$(shell grep 'extern int setattr_prepare' include/linux/fs.h))
-ccflags-y += -DKC_SETATTR_PREPARE
-endif
-
-#
-# v4.15-rc3-4-gae5e165d855d
-#
-# linux/iversion.h needs to manually be included for code that
-# manipulates this field.
-#
-ifneq (,$(shell grep -s 'define _LINUX_IVERSION_H' include/linux/iversion.h))
-ccflags-y += -DKC_NEED_LINUX_IVERSION_H=1
-endif
-
-# v4.11-12447-g104b4e5139fe
-#
-# Renamed __percpu_counter_add to percpu_counter_add_batch to clarify
-# that the __ wasn't less safe, just took an extra parameter.
-#
-ifneq (,$(shell grep 'percpu_counter_add_batch' include/linux/percpu_counter.h))
-ccflags-y += -DKC_PERCPU_COUNTER_ADD_BATCH
-endif
-
-#
-# v4.11-4550-g7dea19f9ee63
-#
-# Introduced memalloc_nofs_{save,restore} preferred instead of _noio_.
-#
-ifneq (,$(shell grep 'memalloc_nofs_save' include/linux/sched/mm.h))
-ccflags-y += -DKC_MEMALLOC_NOFS_SAVE
-endif
-
-#
-# v4.7-12414-g1eff9d322a44
-#
-# Renamed bi_rw to bi_opf to force old code to catch up.  We use it as a
-# single switch between old and new bio structures.
-#
-ifneq (,$(shell grep 'bi_opf' include/linux/blk_types.h))
-ccflags-y += -DKC_BIO_BI_OPF
-endif
-
-#
-# v4.12-rc2-201-g4e4cbee93d56
-#
-# Moves to bi_status BLK_STS_ API instead of having a mix of error
-# end_io args or bi_error.
-#
-ifneq (,$(shell grep 'bi_status' include/linux/blk_types.h))
-ccflags-y += -DKC_BIO_BI_STATUS
-endif
-
-#
-# v3.11-8765-ga0b02131c5fc
-#
-# Remove the old ->shrink() API, ->{scan,count}_objects is preferred.
-#
-ifneq (,$(shell grep '(*shrink)' include/linux/shrinker.h))
-ccflags-y += -DKC_SHRINKER_SHRINK
-endif
-
-#
-# v3.19-4777-g6bec00352861
-#
-# backing_dev_info is removed from address_space. Instead we need to use
-# inode_to_bdi() inline from <backing-dev.h>.
-#
-ifneq (,$(shell grep 'struct backing_dev_info.*backing_dev_info' include/linux/fs.h))
-ccflags-y += -DKC_LINUX_BACKING_DEV_INFO=1
-endif
-
-#
-# v4.3-9290-ge409de992e3e
-#
-# xattr handlers are now passed a struct that contains `flags`
-#
-ifneq (,$(shell grep 'int...get..const struct xattr_handler.*struct dentry.*dentry,' include/linux/xattr.h))
-ccflags-y += -DKC_XATTR_STRUCT_XATTR_HANDLER=1
-endif
-
-#
-# v4.16-rc1-1-g9b2c45d479d0
-#
-# kernel_getsockname() and kernel_getpeername dropped addrlen arg
-#
-ifneq (,$(shell grep 'kernel_getsockname.*,$$' include/linux/net.h))
-ccflags-y += -DKC_KERNEL_GETSOCKNAME_ADDRLEN=1
-endif
-
-#
-# v4.1-rc1-410-geeb1bd5c40ed
-#
-# Adds a struct net parameter to sock_create_kern
-#
-ifneq (,$(shell grep 'sock_create_kern.*struct net' include/linux/net.h))
-ccflags-y += -DKC_SOCK_CREATE_KERN_NET=1
-endif
-
-#
-# v3.18-rc6-1619-gc0371da6047a
-#
-# iov_iter is now part of struct msghdr
-#
-ifneq (,$(shell grep 'struct iov_iter.*msg_iter' include/linux/socket.h))
-ccflags-y += -DKC_MSGHDR_STRUCT_IOV_ITER=1
-endif
-
-#
-# v4.17-rc6-7-g95582b008388
-#
-# Kernel has current_time(inode) to uniformly retreive timespec in the right unit
-#
-ifneq (,$(shell grep 'extern struct timespec64 current_time' include/linux/fs.h))
-ccflags-y += -DKC_CURRENT_TIME_INODE=1
-endif
-
-#
-# v4.9-12228-g530e9b76ae8f
-#
-# register_cpu_notifier and family were all removed and to be
-# replaced with cpuhp_* API calls.
-#
-ifneq (,$(shell grep 'define register_hotcpu_notifier' include/linux/cpu.h))
-ccflags-y += -DKC_CPU_NOTIFIER
-endif
-
-#
-# v3.14-rc8-130-gccad2365668f
-#
-# generic_file_buffered_write is removed, backport it
-#
-ifneq (,$(shell grep 'extern ssize_t generic_file_buffered_write' include/linux/fs.h))
-ccflags-y += -DKC_GENERIC_FILE_BUFFERED_WRITE=1
-endif
-
-#
-# v5.7-438-g8151b4c8bee4
-#
-# struct address_space_operations switches away from .readpages to .readahead
-#
-# RHEL has backported this feature all the way to RHEL8, as part of RHEL_KABI,
-# which means we need to detect this very precisely
-#
-ifneq (,$(shell grep 'readahead.*struct readahead_control' include/linux/fs.h))
-ccflags-y += -DKC_FILE_AOPS_READAHEAD
-endif
-
-#
-# v4.0-rc7-1743-g8436318205b9
-#
-# .aio_read and .aio_write no longer exist. All reads and writes now use the
-# .read_iter and .write_iter methods, or must implement .read and .write (which
-# we don't).
-#
-ifneq (,$(shell grep 'ssize_t.*aio_read' include/linux/fs.h))
-ccflags-y += -DKC_LINUX_HAVE_FOP_AIO_READ=1
-endif
-
-#
-# rhel7 has a custom inode_operations_wrapper struct that is discarded
-# entirely in favor of upstream structure since rhel8.
-#
-ifneq (,$(shell grep 'void.*follow_link.*struct dentry' include/linux/fs.h))
-ccflags-y += -DKC_LINUX_HAVE_RHEL_IOPS_WRAPPER=1
-endif
-
-ifneq (,$(shell grep 'size_t.*ki_left;' include/linux/aio.h))
-ccflags-y += -DKC_LINUX_AIO_KI_LEFT=1
-endif
-
-#
-# v4.4-rc4-4-g98e9cb5711c6
-#
-# Introduces a new xattr_handler .name member that can be used to match the
-# entire field, instead of just a prefix. For these kernels, we must use
-# the new .name field instead.
-ifneq (,$(shell grep 'static inline const char .xattr_prefix' include/linux/xattr.h))
-ccflags-y += -DKC_XATTR_HANDLER_NAME=1
-endif

kmod/src/acl.c

@@ -1,378 +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;
-
-#ifndef KC___POSIX_ACL_CREATE
-	if (!IS_POSIXACL(inode))
-		return NULL;
-
-	acl = get_cached_acl(inode, type);
-	if (acl != ACL_NOT_CACHED)
-		return acl;
-#endif
-
-	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);
-	}
-
-#ifndef KC___POSIX_ACL_CREATE
-	/* can set null negative cache */
-	if (!IS_ERR(acl))
-		set_cached_acl(inode, type, acl);
-#endif
-
-	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;
-
-#ifndef KC___POSIX_ACL_CREATE
-	if (!IS_POSIXACL(inode))
-		return NULL;
-#endif
-
-	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(inode);
-		}
-	}
-
-out:
-#ifndef KC___POSIX_ACL_CREATE
-	if (!ret)
-		set_cached_acl(inode, type, acl);
-#endif
-
-	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;
-}
-#ifdef KC_XATTR_STRUCT_XATTR_HANDLER
-int scoutfs_acl_get_xattr(const struct xattr_handler *handler, struct dentry *dentry,
-			  struct inode *inode, const char *name, void *value,
-			  size_t size)
-{
-	int type = handler->flags;
-#else
-int scoutfs_acl_get_xattr(struct dentry *dentry, const char *name, void *value, size_t size,
-			  int type)
-{
-#endif
-	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;
-}
-
-#ifdef KC_XATTR_STRUCT_XATTR_HANDLER
-int scoutfs_acl_set_xattr(const struct xattr_handler *handler, struct dentry *dentry,
-			  struct inode *inode, const char *name, const void *value,
-			  size_t size, int flags)
-{
-	int type = handler->flags;
-#else
-int scoutfs_acl_set_xattr(struct dentry *dentry, const char *name, const void *value, size_t size,
-			  int flags, int type)
-{
-#endif
-	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,27 +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);
-#ifdef KC_XATTR_STRUCT_XATTR_HANDLER
-int scoutfs_acl_get_xattr(const struct xattr_handler *, struct dentry *dentry,
-			  struct inode *inode, const char *name, void *value,
-			  size_t size);
-int scoutfs_acl_set_xattr(const struct xattr_handler *, struct dentry *dentry,
-			  struct inode *inode, const char *name, const void *value,
-			  size_t size, int flags);
-#else
-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);
-#endif
-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,24 +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;
-		}
-
-		/* return partial if the server alloc can't dirty any more */
-		if (scoutfs_alloc_meta_low(sb, alloc, 50 + extent_mod_blocks(src->root.height) +
-						      extent_mod_blocks(dst->root.height))) {
-			if (WARN_ON_ONCE(!moved))
-				ret = -ENOSPC;
-			else
-				ret = 0;
-			break;
-		}
-
 		/* searching set start/len, finish initializing alloced extent */
 		ext.map = found.map ? ext.start - found.start + found.map : 0;
 		ext.flags = found.flags;
@@ -1110,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
@@ -1118,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) {
@@ -1354,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)
 {
@@ -1582,10 +1514,12 @@ out:
  * call the caller's callback.  This assumes that the super it's reading
  * could be stale and will retry if it encounters stale blocks.
  */
-int scoutfs_alloc_foreach(struct super_block *sb, scoutfs_alloc_foreach_cb_t cb, void *arg)
+int scoutfs_alloc_foreach(struct super_block *sb,
+			  scoutfs_alloc_foreach_cb_t cb, void *arg)
 {
 	struct scoutfs_super_block *super = NULL;
-	DECLARE_SAVED_REFS(saved);
+	struct scoutfs_block_ref stale_refs[2] = {{0,}};
+	struct scoutfs_block_ref refs[2] = {{0,}};
 	int ret;
 
 	super = kmalloc(sizeof(struct scoutfs_super_block), GFP_NOFS);
@@ -1594,18 +1528,26 @@ int scoutfs_alloc_foreach(struct super_block *sb, scoutfs_alloc_foreach_cb_t cb,
 		goto out;
 	}
 
-	do {
-		ret = scoutfs_read_super(sb, super);
-		if (ret < 0)
-			goto out;
+retry:
+	ret = scoutfs_read_super(sb, super);
+	if (ret < 0)
+		goto out;
 
-		ret = scoutfs_alloc_foreach_super(sb, super, cb, arg);
-
-		ret = scoutfs_block_check_stale(sb, ret, &saved, &super->logs_root.ref,
-						&super->srch_root.ref);
-	} while (ret == -ESTALE);
+	refs[0] = super->logs_root.ref;
+	refs[1] = super->srch_root.ref;
 
+	ret = scoutfs_alloc_foreach_super(sb, super, cb, arg);
 out:
+	if (ret == -ESTALE) {
+		if (memcmp(&stale_refs, &refs, sizeof(refs)) == 0) {
+			ret = -EIO;
+		} else {
+			BUILD_BUG_ON(sizeof(stale_refs) != sizeof(refs));
+			memcpy(stale_refs, refs, sizeof(stale_refs));
+			goto retry;
+		}
+	}
+
 	kfree(super);
 	return ret;
 }

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/block.c

@@ -21,7 +21,6 @@
 #include <linux/blkdev.h>
 #include <linux/rhashtable.h>
 #include <linux/random.h>
-#include <linux/sched/mm.h>
 
 #include "format.h"
 #include "super.h"
@@ -31,7 +30,6 @@
 #include "scoutfs_trace.h"
 #include "alloc.h"
 #include "triggers.h"
-#include "util.h"
 
 /*
  * The scoutfs block cache manages metadata blocks that can be larger
@@ -59,7 +57,7 @@ struct block_info {
 	atomic64_t access_counter;
 	struct rhashtable ht;
 	wait_queue_head_t waitq;
-	KC_DEFINE_SHRINKER(shrinker);
+	struct shrinker shrinker;
 	struct work_struct free_work;
 	struct llist_head free_llist;
 };
@@ -130,7 +128,7 @@ static __le32 block_calc_crc(struct scoutfs_block_header *hdr, u32 size)
 static struct block_private *block_alloc(struct super_block *sb, u64 blkno)
 {
 	struct block_private *bp;
-	unsigned int nofs_flags;
+	unsigned int noio_flags;
 
 	/*
 	 * If we had multiple blocks per page we'd need to be a little
@@ -158,9 +156,9 @@ static struct block_private *block_alloc(struct super_block *sb, u64 blkno)
 		 * spurious reclaim-on dependencies and warnings.
 		 */
 		lockdep_off();
-		nofs_flags = memalloc_nofs_save();
+		noio_flags = memalloc_noio_save();
 		bp->virt = __vmalloc(SCOUTFS_BLOCK_LG_SIZE, GFP_NOFS | __GFP_HIGHMEM, PAGE_KERNEL);
-		memalloc_nofs_restore(nofs_flags);
+		memalloc_noio_restore(noio_flags);
 		lockdep_on();
 
 		if (!bp->virt) {
@@ -438,10 +436,11 @@ static void block_remove_all(struct super_block *sb)
  * possible.  Final freeing, verifying checksums, and unlinking errored
  * blocks are all done by future users of the blocks.
  */
-static void block_end_io(struct super_block *sb, unsigned int opf,
+static void block_end_io(struct super_block *sb, int rw,
 			 struct block_private *bp, int err)
 {
 	DECLARE_BLOCK_INFO(sb, binf);
+	bool is_read = !(rw & WRITE);
 
 	if (err) {
 		scoutfs_inc_counter(sb, block_cache_end_io_error);
@@ -451,7 +450,7 @@ static void block_end_io(struct super_block *sb, unsigned int opf,
 	if (!atomic_dec_and_test(&bp->io_count))
 		return;
 
-	if (!op_is_write(opf) && !test_bit(BLOCK_BIT_ERROR, &bp->bits))
+	if (is_read && !test_bit(BLOCK_BIT_ERROR, &bp->bits))
 		set_bit(BLOCK_BIT_UPTODATE, &bp->bits);
 
 	clear_bit(BLOCK_BIT_IO_BUSY, &bp->bits);
@@ -464,13 +463,13 @@ static void block_end_io(struct super_block *sb, unsigned int opf,
 		wake_up(&binf->waitq);
 }
 
-static void KC_DECLARE_BIO_END_IO(block_bio_end_io, struct bio *bio)
+static void block_bio_end_io(struct bio *bio, int err)
 {
 	struct block_private *bp = bio->bi_private;
 	struct super_block *sb = bp->sb;
 
 	TRACE_BLOCK(end_io, bp);
-	block_end_io(sb, kc_bio_get_opf(bio), bp, kc_bio_get_errno(bio));
+	block_end_io(sb, bio->bi_rw, bp, err);
 	bio_put(bio);
 }
 
@@ -478,7 +477,7 @@ static void KC_DECLARE_BIO_END_IO(block_bio_end_io, struct bio *bio)
  * Kick off IO for a single block.
  */
 static int block_submit_bio(struct super_block *sb, struct block_private *bp,
-			    unsigned int opf)
+			    int rw)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 	struct bio *bio = NULL;
@@ -511,9 +510,8 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp,
 				break;
 			}
 
-			kc_bio_set_opf(bio, opf);
-			kc_bio_set_sector(bio, sector + (off >> 9));
-			bio_set_dev(bio, sbi->meta_bdev);
+			bio->bi_sector = sector + (off >> 9);
+			bio->bi_bdev = sbi->meta_bdev;
 			bio->bi_end_io = block_bio_end_io;
 			bio->bi_private = bp;
 
@@ -530,18 +528,18 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp,
 			BUG();
 
 		if (!bio_add_page(bio, page, PAGE_SIZE, 0)) {
-			kc_submit_bio(bio);
+			submit_bio(rw, bio);
 			bio = NULL;
 		}
 	}
 
 	if (bio)
-		kc_submit_bio(bio);
+		submit_bio(rw, bio);
 
 	blk_finish_plug(&plug);
 
 	/* let racing end_io know we're done */
-	block_end_io(sb, opf, bp, ret);
+	block_end_io(sb, rw, bp, ret);
 
 	return ret;
 }
@@ -642,7 +640,7 @@ static struct block_private *block_read(struct super_block *sb, u64 blkno)
 
 	if (!test_bit(BLOCK_BIT_UPTODATE, &bp->bits) &&
 	     test_and_clear_bit(BLOCK_BIT_NEW, &bp->bits)) {
-		ret = block_submit_bio(sb, bp, REQ_OP_READ);
+		ret = block_submit_bio(sb, bp, READ);
 		if (ret < 0)
 			goto out;
 	}
@@ -679,7 +677,7 @@ out:
 int scoutfs_block_read_ref(struct super_block *sb, struct scoutfs_block_ref *ref, u32 magic,
 			   struct scoutfs_block **bl_ret)
 {
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
+	struct scoutfs_super_block *super = &SCOUTFS_SB(sb)->super;
 	struct scoutfs_block_header *hdr;
 	struct block_private *bp = NULL;
 	bool retried = false;
@@ -703,7 +701,7 @@ retry:
 		set_bit(BLOCK_BIT_CRC_VALID, &bp->bits);
 	}
 
-	if (hdr->magic != cpu_to_le32(magic) || hdr->fsid != cpu_to_le64(sbi->fsid) ||
+	if (hdr->magic != cpu_to_le32(magic) || hdr->fsid != super->hdr.fsid ||
 	    hdr->seq != ref->seq || hdr->blkno != ref->blkno) {
 		ret = -ESTALE;
 		goto out;
@@ -730,36 +728,6 @@ out:
 	return ret;
 }
 
-static bool stale_refs_match(struct scoutfs_block_ref *caller, struct scoutfs_block_ref *saved)
-{
-	return !caller || (caller->blkno == saved->blkno && caller->seq == saved->seq);
-}
-
-/*
- * Check if a read of a reference that gave ESTALE should be retried or
- * should generate a hard error.  If this is the second time we got
- * ESTALE from the same refs then we return EIO and the caller should
- * stop.  As long as we keep seeing different refs we'll return ESTALE
- * and the caller can keep trying.
- */
-int scoutfs_block_check_stale(struct super_block *sb, int ret,
-			      struct scoutfs_block_saved_refs *saved,
-			      struct scoutfs_block_ref *a, struct scoutfs_block_ref *b)
-{
-	if (ret == -ESTALE) {
-		if (stale_refs_match(a, &saved->refs[0]) && stale_refs_match(b, &saved->refs[1])){
-			ret = -EIO;
-		} else {
-			if (a)
-				saved->refs[0] = *a;
-			if (b)
-				saved->refs[1] = *b;
-		}
-	}
-
-	return ret;
-}
-
 void scoutfs_block_put(struct super_block *sb, struct scoutfs_block *bl)
 {
 	if (!IS_ERR_OR_NULL(bl))
@@ -829,7 +797,7 @@ int scoutfs_block_dirty_ref(struct super_block *sb, struct scoutfs_alloc *alloc,
 			    u32 magic, struct scoutfs_block **bl_ret,
 			    u64 dirty_blkno, u64 *ref_blkno)
 {
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
+	struct scoutfs_super_block *super = &SCOUTFS_SB(sb)->super;
 	struct scoutfs_block *cow_bl = NULL;
 	struct scoutfs_block *bl = NULL;
 	struct block_private *exist_bp = NULL;
@@ -897,7 +865,7 @@ int scoutfs_block_dirty_ref(struct super_block *sb, struct scoutfs_alloc *alloc,
 
 	hdr = bl->data;
 	hdr->magic = cpu_to_le32(magic);
-	hdr->fsid = cpu_to_le64(sbi->fsid);
+	hdr->fsid = super->hdr.fsid;
 	hdr->blkno = cpu_to_le64(bl->blkno);
 	prandom_bytes(&hdr->seq, sizeof(hdr->seq));
 
@@ -971,7 +939,7 @@ int scoutfs_block_writer_write(struct super_block *sb,
 		/* retry previous write errors */
 		clear_bit(BLOCK_BIT_ERROR, &bp->bits);
 
-		ret = block_submit_bio(sb, bp, REQ_OP_WRITE);
+		ret = block_submit_bio(sb, bp, WRITE);
 		if (ret < 0)
 			break;
 	}
@@ -1071,16 +1039,6 @@ u64 scoutfs_block_writer_dirty_bytes(struct super_block *sb,
 	return wri->nr_dirty_blocks * SCOUTFS_BLOCK_LG_SIZE;
 }
 
-static unsigned long block_count_objects(struct shrinker *shrink, struct shrink_control *sc)
-{
-	struct block_info *binf = KC_SHRINKER_CONTAINER_OF(shrink, struct block_info);
-	struct super_block *sb = binf->sb;
-
-	scoutfs_inc_counter(sb, block_cache_count_objects);
-
-	return shrinker_min_t_long((u64)atomic_read(&binf->total_inserted));
-}
-
 /*
  * Remove a number of cached blocks that haven't been used recently.
  *
@@ -1101,19 +1059,25 @@ static unsigned long block_count_objects(struct shrinker *shrink, struct shrink_
  * atomically remove blocks when the only references are ours and the
  * hash table.
  */
-static unsigned long block_scan_objects(struct shrinker *shrink, struct shrink_control *sc)
+static int block_shrink(struct shrinker *shrink, struct shrink_control *sc)
 {
-	struct block_info *binf = KC_SHRINKER_CONTAINER_OF(shrink, struct block_info);
+	struct block_info *binf = container_of(shrink, struct block_info,
+					       shrinker);
 	struct super_block *sb = binf->sb;
 	struct rhashtable_iter iter;
 	struct block_private *bp;
-	bool stop = false;
-	unsigned long freed = 0;
-	unsigned long nr = sc->nr_to_scan;
+	unsigned long nr;
 	u64 recently;
 
-	scoutfs_inc_counter(sb, block_cache_scan_objects);
+	nr = sc->nr_to_scan;
+	if (nr == 0)
+		goto out;
 
+	scoutfs_inc_counter(sb, block_cache_shrink);
+
+	nr = DIV_ROUND_UP(nr, SCOUTFS_BLOCK_LG_PAGES_PER);
+
+restart:
 	recently = accessed_recently(binf);
 	rhashtable_walk_enter(&binf->ht, &iter);
 	rhashtable_walk_start(&iter);
@@ -1135,15 +1099,12 @@ static unsigned long block_scan_objects(struct shrinker *shrink, struct shrink_c
 		if (bp == NULL)
 			break;
 		if (bp == ERR_PTR(-EAGAIN)) {
-			/*
-			 * We can be called from reclaim in the allocation
-			 * to resize the hash table itself.  We have to
-			 * return so that the caller can proceed and
-			 * enable hash table iteration again.
-			 */
-			scoutfs_inc_counter(sb, block_cache_shrink_stop);
-			stop = true;
-			break;
+			/* hard exit to wait for rcu rebalance to finish */
+			rhashtable_walk_stop(&iter);
+			rhashtable_walk_exit(&iter);
+			scoutfs_inc_counter(sb, block_cache_shrink_restart);
+			synchronize_rcu();
+			goto restart;
 		}
 
 		scoutfs_inc_counter(sb, block_cache_shrink_next);
@@ -1157,7 +1118,6 @@ static unsigned long block_scan_objects(struct shrinker *shrink, struct shrink_c
 			if (block_remove_solo(sb, bp)) {
 				scoutfs_inc_counter(sb, block_cache_shrink_remove);
 				TRACE_BLOCK(shrink, bp);
-				freed++;
 				nr--;
 			}
 			block_put(sb, bp);
@@ -1166,11 +1126,9 @@ static unsigned long block_scan_objects(struct shrinker *shrink, struct shrink_c
 
 	rhashtable_walk_stop(&iter);
 	rhashtable_walk_exit(&iter);
-
-	if (stop)
-		return SHRINK_STOP;
-	else
-		return freed;
+out:
+	return min_t(u64, (u64)atomic_read(&binf->total_inserted) * SCOUTFS_BLOCK_LG_PAGES_PER,
+		     INT_MAX);
 }
 
 struct sm_block_completion {
@@ -1178,11 +1136,11 @@ struct sm_block_completion {
 	int err;
 };
 
-static void KC_DECLARE_BIO_END_IO(sm_block_bio_end_io, struct bio *bio)
+static void sm_block_bio_end_io(struct bio *bio, int err)
 {
 	struct sm_block_completion *sbc = bio->bi_private;
 
-	sbc->err = kc_bio_get_errno(bio);
+	sbc->err = err;
 	complete(&sbc->comp);
 	bio_put(bio);
 }
@@ -1197,8 +1155,9 @@ static void KC_DECLARE_BIO_END_IO(sm_block_bio_end_io, struct bio *bio)
  * only layer that sees the full block buffer so we pass the calculated
  * crc to the caller for them to check in their context.
  */
-static int sm_block_io(struct super_block *sb, struct block_device *bdev, unsigned int opf,
-		       u64 blkno, struct scoutfs_block_header *hdr, size_t len, __le32 *blk_crc)
+static int sm_block_io(struct super_block *sb, struct block_device *bdev, int rw, u64 blkno,
+		       struct scoutfs_block_header *hdr, size_t len,
+		       __le32 *blk_crc)
 {
 	struct scoutfs_block_header *pg_hdr;
 	struct sm_block_completion sbc;
@@ -1212,7 +1171,7 @@ static int sm_block_io(struct super_block *sb, struct block_device *bdev, unsign
 		return -EIO;
 
 	if (WARN_ON_ONCE(len > SCOUTFS_BLOCK_SM_SIZE) ||
-	    WARN_ON_ONCE(!op_is_write(opf) && !blk_crc))
+	    WARN_ON_ONCE(!(rw & WRITE) && !blk_crc))
 		return -EINVAL;
 
 	page = alloc_page(GFP_NOFS);
@@ -1221,7 +1180,7 @@ static int sm_block_io(struct super_block *sb, struct block_device *bdev, unsign
 
 	pg_hdr = page_address(page);
 
-	if (op_is_write(opf)) {
+	if (rw & WRITE) {
 		memcpy(pg_hdr, hdr, len);
 		if (len < SCOUTFS_BLOCK_SM_SIZE)
 			memset((char *)pg_hdr + len, 0,
@@ -1235,9 +1194,8 @@ static int sm_block_io(struct super_block *sb, struct block_device *bdev, unsign
 		goto out;
 	}
 
-	kc_bio_set_opf(bio, opf | REQ_SYNC);
-	kc_bio_set_sector(bio, blkno << (SCOUTFS_BLOCK_SM_SHIFT - 9));
-	bio_set_dev(bio, bdev);
+	bio->bi_sector = blkno << (SCOUTFS_BLOCK_SM_SHIFT - 9);
+	bio->bi_bdev = bdev;
 	bio->bi_end_io = sm_block_bio_end_io;
 	bio->bi_private = &sbc;
 	bio_add_page(bio, page, SCOUTFS_BLOCK_SM_SIZE, 0);
@@ -1245,12 +1203,12 @@ static int sm_block_io(struct super_block *sb, struct block_device *bdev, unsign
 	init_completion(&sbc.comp);
 	sbc.err = 0;
 
-	kc_submit_bio(bio);
+	submit_bio((rw & WRITE) ? WRITE_SYNC : READ_SYNC, bio);
 
 	wait_for_completion(&sbc.comp);
 	ret = sbc.err;
 
-	if (ret == 0 && !op_is_write(opf)) {
+	if (ret == 0 && !(rw & WRITE)) {
 		memcpy(hdr, pg_hdr, len);
 		*blk_crc = block_calc_crc(pg_hdr, SCOUTFS_BLOCK_SM_SIZE);
 	}
@@ -1264,14 +1222,14 @@ int scoutfs_block_read_sm(struct super_block *sb,
 			  struct scoutfs_block_header *hdr, size_t len,
 			  __le32 *blk_crc)
 {
-	return sm_block_io(sb, bdev, REQ_OP_READ, blkno, hdr, len, blk_crc);
+	return sm_block_io(sb, bdev, READ, blkno, hdr, len, blk_crc);
 }
 
 int scoutfs_block_write_sm(struct super_block *sb,
 			   struct block_device *bdev, u64 blkno,
 			   struct scoutfs_block_header *hdr, size_t len)
 {
-	return sm_block_io(sb, bdev, REQ_OP_WRITE, blkno, hdr, len, NULL);
+	return sm_block_io(sb, bdev, WRITE, blkno, hdr, len, NULL);
 }
 
 int scoutfs_block_setup(struct super_block *sb)
@@ -1296,9 +1254,9 @@ int scoutfs_block_setup(struct super_block *sb)
 	atomic_set(&binf->total_inserted, 0);
 	atomic64_set(&binf->access_counter, 0);
 	init_waitqueue_head(&binf->waitq);
-	KC_INIT_SHRINKER_FUNCS(&binf->shrinker, block_count_objects,
-			       block_scan_objects);
-	KC_REGISTER_SHRINKER(&binf->shrinker);
+	binf->shrinker.shrink = block_shrink;
+	binf->shrinker.seeks = DEFAULT_SEEKS;
+	register_shrinker(&binf->shrinker);
 	INIT_WORK(&binf->free_work, block_free_work);
 	init_llist_head(&binf->free_llist);
 
@@ -1318,7 +1276,7 @@ void scoutfs_block_destroy(struct super_block *sb)
 	struct block_info *binf = SCOUTFS_SB(sb)->block_info;
 
 	if (binf) {
-		KC_UNREGISTER_SHRINKER(&binf->shrinker);
+		unregister_shrinker(&binf->shrinker);
 		block_remove_all(sb);
 		flush_work(&binf->free_work);
 		rhashtable_destroy(&binf->ht);

kmod/src/block.h

@@ -13,17 +13,6 @@ struct scoutfs_block {
 	void *priv;
 };
 
-struct scoutfs_block_saved_refs {
-	struct scoutfs_block_ref refs[2];
-};
-
-#define DECLARE_SAVED_REFS(name) \
-	struct scoutfs_block_saved_refs name = {{{0,}}}
-
-int scoutfs_block_check_stale(struct super_block *sb, int ret,
-			      struct scoutfs_block_saved_refs *saved,
-			      struct scoutfs_block_ref *a, struct scoutfs_block_ref *b);
-
 int scoutfs_block_read_ref(struct super_block *sb, struct scoutfs_block_ref *ref, u32 magic,
 			   struct scoutfs_block **bl_ret);
 void scoutfs_block_put(struct super_block *sb, struct scoutfs_block *bl);

kmod/src/btree.c

@@ -1875,12 +1875,11 @@ out:
  * set in btree items.  They're only used for fs items written through
  * the item cache and forest of log btrees.
  */
-int scoutfs_btree_insert_list(struct super_block *sb,
-			      struct scoutfs_alloc *alloc,
-			      struct scoutfs_block_writer *wri,
-			      struct scoutfs_btree_root *root,
-			      struct scoutfs_btree_item_list *lst)
+int scoutfs_btree_insert_list(struct super_block *sb, struct scoutfs_alloc *alloc,
+			      struct scoutfs_block_writer *wri, struct scoutfs_btree_root *root,
+			      scoutfs_btree_item_iter_cb iter_cb, void *pos, void *arg)
 {
+	struct scoutfs_btree_item_desc desc;
 	struct scoutfs_btree_item *item;
 	struct btree_walk_key_range kr;
 	struct scoutfs_btree_block *bt;
@@ -1889,44 +1888,46 @@ int scoutfs_btree_insert_list(struct super_block *sb,
 	int cmp;
 	int ret = 0;
 
-	while (lst) {
+	pos = iter_cb(sb, &desc, pos, arg);
+
+	while (pos) {
 		ret = btree_walk(sb, alloc, wri, root, BTW_DIRTY | BTW_INSERT,
-				 &lst->key, lst->val_len, &bl, &kr, NULL);
+				 desc.key, desc.val_len, &bl, &kr, NULL);
 		if (ret < 0)
 			goto out;
 		bt = bl->data;
 
 		do {
-			item = leaf_item_hash_search(sb, bt, &lst->key);
+			item = leaf_item_hash_search(sb, bt, desc.key);
 			if (item) {
 				/* try to merge delta values, _NULL not deleted; merge will */
-				ret = scoutfs_forest_combine_deltas(&lst->key,
+				ret = scoutfs_forest_combine_deltas(desc.key,
 								    item_val(bt, item),
 								    item_val_len(item),
-								    lst->val, lst->val_len);
+								    desc.val, desc.val_len);
 				if (ret < 0) {
 					scoutfs_block_put(sb, bl);
 					goto out;
 				}
 
-				item->seq = cpu_to_le64(lst->seq);
-				item->flags = lst->flags;
+				item->seq = cpu_to_le64(desc.seq);
+				item->flags = desc.flags;
 
 				if (ret == 0)
-					update_item_value(bt, item, lst->val, lst->val_len);
+					update_item_value(bt, item, desc.val, desc.val_len);
 				else
 					ret = 0;
 			} else {
 				scoutfs_avl_search(&bt->item_root,
-						   cmp_key_item, &lst->key,
+						   cmp_key_item, desc.key,
 						   &cmp, &par, NULL, NULL);
-				create_item(bt, &lst->key, lst->seq, lst->flags, lst->val,
-					    lst->val_len, par, cmp);
+				create_item(bt, desc.key, desc.seq, desc.flags, desc.val,
+					    desc.val_len, par, cmp);
 			}
 
-			lst = lst->next;
-		} while (lst && scoutfs_key_compare(&lst->key, &kr.end) <= 0 &&
-			 mid_free_item_room(bt, lst->val_len));
+			pos = iter_cb(sb, &desc, pos, arg);
+		} while (pos && scoutfs_key_compare(desc.key, &kr.end) <= 0 &&
+			 mid_free_item_room(bt, desc.val_len));
 
 		scoutfs_block_put(sb, bl);
 	}
@@ -2449,7 +2450,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 +2460,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 +2539,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 +2554,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 +2569,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

@@ -18,11 +18,24 @@ struct scoutfs_btree_item_ref {
 #define SCOUTFS_BTREE_ITEM_REF(name) \
 	struct scoutfs_btree_item_ref name = {NULL,}
 
-/* caller gives an item to the callback */
+/* btree gives an item to caller */
 typedef int (*scoutfs_btree_item_cb)(struct super_block *sb,
 				     struct scoutfs_key *key, u64 seq, u8 flags,
 				     void *val, int val_len, void *arg);
 
+struct scoutfs_btree_item_desc {
+	struct scoutfs_key *key;
+	void *val;
+	u64 seq;
+	u8 flags;
+	unsigned val_len;
+};
+
+/* btree iterates through items from caller */
+typedef void *(*scoutfs_btree_item_iter_cb)(struct super_block *sb,
+					    struct scoutfs_btree_item_desc *desc,
+					    void *pos, void *arg);
+
 /* simple singly-linked list of items */
 struct scoutfs_btree_item_list {
 	struct scoutfs_btree_item_list *next;
@@ -78,11 +91,9 @@ int scoutfs_btree_read_items(struct super_block *sb,
 			     struct scoutfs_key *start,
 			     struct scoutfs_key *end,
 			     scoutfs_btree_item_cb cb, void *arg);
-int scoutfs_btree_insert_list(struct super_block *sb,
-			      struct scoutfs_alloc *alloc,
-			      struct scoutfs_block_writer *wri,
-			      struct scoutfs_btree_root *root,
-			      struct scoutfs_btree_item_list *lst);
+int scoutfs_btree_insert_list(struct super_block *sb, struct scoutfs_alloc *alloc,
+			      struct scoutfs_block_writer *wri, struct scoutfs_btree_root *root,
+			      scoutfs_btree_item_iter_cb iter_cb, void *pos, void *arg);
 
 int scoutfs_btree_parent_range(struct super_block *sb,
 			       struct scoutfs_btree_root *root,
@@ -125,7 +136,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/client.c

@@ -356,6 +356,7 @@ static int client_greeting(struct super_block *sb,
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 	struct client_info *client = sbi->client_info;
+	struct scoutfs_super_block *super = &SCOUTFS_SB(sb)->super;
 	struct scoutfs_net_greeting *gr = resp;
 	bool new_server;
 	int ret;
@@ -370,9 +371,9 @@ static int client_greeting(struct super_block *sb,
 		goto out;
 	}
 
-	if (gr->fsid != cpu_to_le64(sbi->fsid)) {
+	if (gr->fsid != super->hdr.fsid) {
 		scoutfs_warn(sb, "server greeting response fsid 0x%llx did not match client fsid 0x%llx",
-			     le64_to_cpu(gr->fsid), sbi->fsid);
+			     le64_to_cpu(gr->fsid), le64_to_cpu(super->hdr.fsid));
 		ret = -EINVAL;
 		goto out;
 	}
@@ -475,15 +476,13 @@ static void scoutfs_client_connect_worker(struct work_struct *work)
 						  connect_dwork.work);
 	struct super_block *sb = client->sb;
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
-	struct scoutfs_mount_options opts;
+	struct scoutfs_super_block *super = &sbi->super;
+	struct mount_options *opts = &sbi->opts;
+	const bool am_quorum = opts->quorum_slot_nr >= 0;
 	struct scoutfs_net_greeting greet;
 	struct sockaddr_in sin;
-	bool am_quorum;
 	int ret;
 
-	scoutfs_options_read(sb, &opts);
-	am_quorum = opts.quorum_slot_nr >= 0;
-
 	/* can unmount once server farewell handling removes our item */
 	if (client->sending_farewell &&
 	    lookup_mounted_client_item(sb, sbi->rid) == 0) {
@@ -506,7 +505,7 @@ static void scoutfs_client_connect_worker(struct work_struct *work)
 		goto out;
 
 	/* send a greeting to verify endpoints of each connection */
-	greet.fsid = cpu_to_le64(sbi->fsid);
+	greet.fsid = super->hdr.fsid;
 	greet.fmt_vers = cpu_to_le64(sbi->fmt_vers);
 	greet.server_term = cpu_to_le64(client->server_term);
 	greet.rid = cpu_to_le64(sbi->rid);

kmod/src/counters.h

@@ -30,13 +30,11 @@
 	EXPAND_COUNTER(block_cache_free)			\
 	EXPAND_COUNTER(block_cache_free_work)			\
 	EXPAND_COUNTER(block_cache_remove_stale)		\
-	EXPAND_COUNTER(block_cache_count_objects)		\
-	EXPAND_COUNTER(block_cache_scan_objects)		\
 	EXPAND_COUNTER(block_cache_shrink)			\
 	EXPAND_COUNTER(block_cache_shrink_next)			\
 	EXPAND_COUNTER(block_cache_shrink_recent)		\
 	EXPAND_COUNTER(block_cache_shrink_remove)		\
-	EXPAND_COUNTER(block_cache_shrink_stop)			\
+	EXPAND_COUNTER(block_cache_shrink_restart)		\
 	EXPAND_COUNTER(btree_compact_values)			\
 	EXPAND_COUNTER(btree_compact_values_enomem)		\
 	EXPAND_COUNTER(btree_delete)				\
@@ -77,6 +75,8 @@
 	EXPAND_COUNTER(data_write_begin_enobufs_retry)		\
 	EXPAND_COUNTER(dentry_revalidate_error)			\
 	EXPAND_COUNTER(dentry_revalidate_invalid)		\
+	EXPAND_COUNTER(dentry_revalidate_locked)		\
+	EXPAND_COUNTER(dentry_revalidate_orphan)		\
 	EXPAND_COUNTER(dentry_revalidate_rcu)			\
 	EXPAND_COUNTER(dentry_revalidate_root)			\
 	EXPAND_COUNTER(dentry_revalidate_valid)			\
@@ -90,42 +90,30 @@
 	EXPAND_COUNTER(forest_read_items)			\
 	EXPAND_COUNTER(forest_roots_next_hint)			\
 	EXPAND_COUNTER(forest_set_bloom_bits)			\
-	EXPAND_COUNTER(item_cache_count_objects)		\
-	EXPAND_COUNTER(item_cache_scan_objects)			\
+	EXPAND_COUNTER(item_alloc_bytes)			\
 	EXPAND_COUNTER(item_clear_dirty)			\
 	EXPAND_COUNTER(item_create)				\
 	EXPAND_COUNTER(item_delete)				\
 	EXPAND_COUNTER(item_delta)				\
 	EXPAND_COUNTER(item_delta_written)			\
 	EXPAND_COUNTER(item_dirty)				\
+	EXPAND_COUNTER(item_free_bytes)				\
 	EXPAND_COUNTER(item_invalidate)				\
-	EXPAND_COUNTER(item_invalidate_page)			\
+	EXPAND_COUNTER(item_invalidate_item)			\
 	EXPAND_COUNTER(item_lookup)				\
 	EXPAND_COUNTER(item_mark_dirty)				\
 	EXPAND_COUNTER(item_next)				\
-	EXPAND_COUNTER(item_page_accessed)			\
-	EXPAND_COUNTER(item_page_alloc)				\
-	EXPAND_COUNTER(item_page_clear_dirty)			\
-	EXPAND_COUNTER(item_page_compact)			\
-	EXPAND_COUNTER(item_page_free)				\
-	EXPAND_COUNTER(item_page_lru_add)			\
-	EXPAND_COUNTER(item_page_lru_remove)			\
-	EXPAND_COUNTER(item_page_mark_dirty)			\
-	EXPAND_COUNTER(item_page_rbtree_walk)			\
-	EXPAND_COUNTER(item_page_split)				\
-	EXPAND_COUNTER(item_pcpu_add_replaced)			\
-	EXPAND_COUNTER(item_pcpu_page_hit)			\
-	EXPAND_COUNTER(item_pcpu_page_miss)			\
-	EXPAND_COUNTER(item_pcpu_page_miss_keys)		\
-	EXPAND_COUNTER(item_read_pages_split)			\
-	EXPAND_COUNTER(item_shrink_page)			\
-	EXPAND_COUNTER(item_shrink_page_dirty)			\
-	EXPAND_COUNTER(item_shrink_page_reader)			\
-	EXPAND_COUNTER(item_shrink_page_trylock)		\
+	EXPAND_COUNTER(item_shrink)				\
+	EXPAND_COUNTER(item_shrink_all)				\
+	EXPAND_COUNTER(item_shrink_exhausted)			\
+	EXPAND_COUNTER(item_shrink_read_search)			\
+	EXPAND_COUNTER(item_shrink_removed)			\
+	EXPAND_COUNTER(item_shrink_searched)			\
+	EXPAND_COUNTER(item_shrink_skipped)			\
+	EXPAND_COUNTER(item_shrink_write_search)		\
 	EXPAND_COUNTER(item_update)				\
 	EXPAND_COUNTER(item_write_dirty)			\
 	EXPAND_COUNTER(lock_alloc)				\
-	EXPAND_COUNTER(lock_count_objects)			\
 	EXPAND_COUNTER(lock_free)				\
 	EXPAND_COUNTER(lock_grant_request)			\
 	EXPAND_COUNTER(lock_grant_response)			\
@@ -139,7 +127,6 @@
 	EXPAND_COUNTER(lock_lock_error)				\
 	EXPAND_COUNTER(lock_nonblock_eagain)			\
 	EXPAND_COUNTER(lock_recover_request)			\
-	EXPAND_COUNTER(lock_scan_objects)			\
 	EXPAND_COUNTER(lock_shrink_attempted)			\
 	EXPAND_COUNTER(lock_shrink_aborted)			\
 	EXPAND_COUNTER(lock_shrink_work)			\
@@ -156,12 +143,11 @@
 	EXPAND_COUNTER(net_recv_messages)			\
 	EXPAND_COUNTER(net_unknown_request)			\
 	EXPAND_COUNTER(orphan_scan)				\
-	EXPAND_COUNTER(orphan_scan_attempts)			\
 	EXPAND_COUNTER(orphan_scan_cached)			\
 	EXPAND_COUNTER(orphan_scan_error)			\
 	EXPAND_COUNTER(orphan_scan_item)			\
 	EXPAND_COUNTER(orphan_scan_omap_set)			\
-	EXPAND_COUNTER(quorum_candidate_server_stopping)	\
+	EXPAND_COUNTER(orphan_scan_read)			\
 	EXPAND_COUNTER(quorum_elected)				\
 	EXPAND_COUNTER(quorum_fence_error)			\
 	EXPAND_COUNTER(quorum_fence_leader)			\
@@ -172,7 +158,6 @@
 	EXPAND_COUNTER(quorum_recv_resignation)			\
 	EXPAND_COUNTER(quorum_recv_vote)			\
 	EXPAND_COUNTER(quorum_send_heartbeat)			\
-	EXPAND_COUNTER(quorum_send_heartbeat_dropped)		\
 	EXPAND_COUNTER(quorum_send_resignation)			\
 	EXPAND_COUNTER(quorum_send_request)			\
 	EXPAND_COUNTER(quorum_send_vote)			\
@@ -194,6 +179,8 @@
 	EXPAND_COUNTER(srch_search_retry_empty)			\
 	EXPAND_COUNTER(srch_search_sorted)			\
 	EXPAND_COUNTER(srch_search_sorted_block)		\
+	EXPAND_COUNTER(srch_search_stale_eio)			\
+	EXPAND_COUNTER(srch_search_stale_retry)			\
 	EXPAND_COUNTER(srch_search_xattrs)			\
 	EXPAND_COUNTER(srch_read_stale)				\
 	EXPAND_COUNTER(statfs)					\
@@ -238,12 +225,12 @@ struct scoutfs_counters {
 #define SCOUTFS_PCPU_COUNTER_BATCH (1 << 30)
 
 #define scoutfs_inc_counter(sb, which)					\
-	percpu_counter_add_batch(&SCOUTFS_SB(sb)->counters->which, 1,	\
-				 SCOUTFS_PCPU_COUNTER_BATCH)
+	__percpu_counter_add(&SCOUTFS_SB(sb)->counters->which, 1,	\
+			     SCOUTFS_PCPU_COUNTER_BATCH)
 
 #define scoutfs_add_counter(sb, which, cnt)				\
-	percpu_counter_add_batch(&SCOUTFS_SB(sb)->counters->which, cnt,	\
-				 SCOUTFS_PCPU_COUNTER_BATCH)
+	__percpu_counter_add(&SCOUTFS_SB(sb)->counters->which, cnt,	\
+			     SCOUTFS_PCPU_COUNTER_BATCH)
 
 void __init scoutfs_init_counters(void);
 int scoutfs_setup_counters(struct super_block *sb);

kmod/src/cwskip.c

@@ -0,0 +1,584 @@
+/*
+ * 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.
+ */
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/rcupdate.h>
+#include <linux/random.h>
+
+#include "cwskip.h"
+
+/*
+ * This skip list is built to allow concurrent modification and limit
+ * contention to the region of the list around the modification.  All
+ * node references are protected by RCU.   Each node has a write_seq
+ * that works like a seqlock, the big differences are that we nest them
+ * and use trylock to acquire them.
+ *
+ * Readers sample the write_seqs of nodes containing links as they
+ * traverse them, verifying that the node hasn't been modified before
+ * traversing to the node referenced by the link.
+ *
+ * Writers remember the seqs of all the nodes they traversed to end up
+ * at their final node.   They try to acquire the lock of all the nodes
+ * needed to modify the list at a given height.   Their trylocks will
+ * fail if any of the nodes have changed since their traversal.
+ *
+ * The interface is built around references to adjacent pairs of nodes
+ * and their sequence numbers.   This lets readers and writers traverse
+ * through their local region of the list until they hit contention and
+ * must start over with a full search.
+ *
+ * The caller is responsible for allocating and freeing nodes.   The
+ * interface is built around caller's objects which each have embedded
+ * nodes.
+ */
+
+/*
+ * node_off is the positive offset of the cwskip node within the
+ * container structs stored in the list.  The node_off is subtracted
+ * from node pointers to give the caller a pointer to their stored
+ * container struct.
+ */
+void scoutfs_cwskip_init_root(struct scoutfs_cwskip_root *root, scoutfs_cwskip_cmp_t cmp_fn,
+			      unsigned long node_off)
+{
+	memset(root, 0, sizeof(&root));
+	root->cmp_fn = cmp_fn;
+	root->node_off = node_off;
+}
+
+/* This is completely racey and should be used accordingly. */
+bool scoutfs_cwskip_empty(struct scoutfs_cwskip_root *root)
+{
+	int i;
+
+	for (i = 0; i < SCOUTFS_CWSKIP_MAX_HEIGHT; i++) {
+		if (root->node.links[i] != NULL)
+			return false;
+	}
+
+	return true;
+}
+
+/*
+ * Return a random height between 1 and max height, inclusive.  Using
+ * ffs means that each greater height relies on all lower height bits
+ * being clear and we get the height distribution we want: 1 = 1/2,
+ * 2 = 1/4, 3 = 1/8, etc.
+ */
+int scoutfs_cwskip_rand_height(void)
+{
+	return ffs(prandom_u32() | (1 << (SCOUTFS_CWSKIP_MAX_HEIGHT - 1)));
+}
+
+static void *node_container(struct scoutfs_cwskip_root *root, struct scoutfs_cwskip_node *node)
+{
+	return node ? (void *)((unsigned long)node - root->node_off) : NULL;
+}
+
+/*
+ * Set the caller's containers for the given nodes.   There isn't a
+ * previous container when the previous node is the root's static
+ * full-height node.
+ */
+static void set_containers(struct scoutfs_cwskip_root *root, struct scoutfs_cwskip_node *prev,
+			   struct scoutfs_cwskip_node *node, void **prev_cont, void **node_cont)
+{
+	if (prev_cont)
+		*prev_cont = (prev != &root->node) ? node_container(root, prev) : NULL;
+	if (node_cont)
+		*node_cont = node_container(root, node);
+}
+
+static struct scoutfs_cwskip_node *node_read_begin(struct scoutfs_cwskip_node *node,
+						   unsigned int *seq)
+{
+	if (node) {
+		*seq = READ_ONCE(node->write_seq) & ~1U;
+		smp_rmb();
+	} else {
+		*seq = 1;  /* caller shouldn't use if we return null, being careful */
+	}
+
+	return node;
+}
+
+static bool node_read_retry(struct scoutfs_cwskip_node *node, unsigned int seq)
+{
+	if (node) {
+	       smp_rmb();
+	       return READ_ONCE(node->write_seq) != seq;
+	}
+
+	return false;
+}
+
+/*
+ * write_seq is only an int to reduce the size of nodes and full-height
+ * seq arrays, it could be a long if archs have trouble with int
+ * cmpxchg.
+ */
+static bool __node_trylock(struct scoutfs_cwskip_node *node, unsigned int seq)
+{
+	if (seq & 1)
+		return false;
+
+	return cmpxchg(&node->write_seq, seq, seq + 1) == seq;
+}
+
+static bool node_trylock(struct scoutfs_cwskip_node *node, unsigned int seq)
+{
+	bool locked = __node_trylock(node, seq);
+	if (locked)
+		smp_wmb();
+	return locked;
+}
+
+static void __node_unlock(struct scoutfs_cwskip_node *node)
+{
+	node->write_seq++;
+}
+
+static void node_unlock(struct scoutfs_cwskip_node *node)
+{
+	__node_unlock(node);
+	smp_wmb();
+}
+
+/* return -1/1 to go left/right, never 0 */
+static int random_cmp(void *K, void *C)
+{
+	return (int)(prandom_u32() & 2) - 1;
+}
+
+static void cwskip_search(struct scoutfs_cwskip_root *root, void *key, int *node_cmp,
+			  struct scoutfs_cwskip_reader *rd, struct scoutfs_cwskip_writer *wr,
+			  unsigned int *prev_seqs)
+{
+	struct scoutfs_cwskip_node *prev;
+	struct scoutfs_cwskip_node *node;
+	scoutfs_cwskip_cmp_t cmp_fn;
+	unsigned int prev_seq;
+	unsigned int node_seq;
+	int level;
+	int cmp;
+
+	if (key == NULL)
+		cmp_fn = random_cmp;
+
+restart:
+	prev = node_read_begin(&root->node, &prev_seq);
+	node = NULL;
+	node_seq = 1;
+	cmp = -1;
+
+	level = SCOUTFS_CWSKIP_MAX_HEIGHT - 1;
+	while (prev && level >= 0) {
+		node = node_read_begin(prev->links[level], &node_seq);
+		if (!node) {
+			cmp = -1;
+			level--;
+			continue;
+		}
+
+		cmp = cmp_fn(key, node_container(root, node));
+		if (cmp > 0) {
+			if (node_read_retry(prev, prev_seq))
+				goto restart;
+			prev = node;
+			prev_seq = node_seq;
+			node = NULL;
+			continue;
+		}
+
+		if (wr) {
+			wr->prevs[level] = prev;
+			prev_seqs[level] = prev_seq;
+		}
+
+		level--;
+	}
+
+	rd->prev = prev;
+	rd->prev_seq = prev_seq;
+	rd->node = node;
+	rd->node_seq = node_seq;
+	*node_cmp = cmp;
+}
+
+static void init_reader(struct scoutfs_cwskip_reader *rd, struct scoutfs_cwskip_root *root)
+{
+	memset(rd, 0, sizeof(struct scoutfs_cwskip_reader));
+	rd->root = root;
+}
+
+/*
+ * Find and returns nodes that surround the search key.
+ *
+ * Either prev or null can be null if there are no nodes before or after
+ * the search key.  *node_cmp is set to the final comparison of the key
+ * and the returned node's container key, it will be 0 if an exact match
+ * is found.
+ *
+ * This starts an RCU read critical section and is fully concurrent with
+ * both other readers and writers.   The nodes won't be freed until
+ * after the section so its always safe to reference them but their
+ * contents might be nonsense if they're modified during the read.
+ * Nothing learned from the list during the read section should have an
+ * effect until after _read_valid has said it was OK.
+ *
+ * _read_valid can be called after referencing the nodes to see if they
+ * were stable during the read.  _read_next can be used to iterate
+ * forward through the list without repeating the search.   The caller
+ * must always call a matching _read_end once they're done.
+ */
+void scoutfs_cwskip_read_begin(struct scoutfs_cwskip_root *root, void *key, void **prev_cont,
+			       void **node_cont, int *node_cmp, struct scoutfs_cwskip_reader *rd)
+	__acquires(RCU) /* :/ */
+{
+	init_reader(rd, root);
+
+	rcu_read_lock();
+	cwskip_search(root, key, node_cmp, rd, NULL, NULL);
+	set_containers(root, rd->prev, rd->node, prev_cont, node_cont);
+}
+
+/*
+ * Returns true of the nodes referenced by the reader haven't been
+ * modified and any references of them were consistent.  Thsi does not
+ * end the reader critical section and can be called multiple times.
+ */
+bool scoutfs_cwskip_read_valid(struct scoutfs_cwskip_reader *rd)
+{
+	return !(node_read_retry(rd->prev, rd->prev_seq) &&
+		 node_read_retry(rd->node, rd->node_seq));
+}
+
+/*
+ * Advance from the current prev/node to the next pair of nodes in the
+ * list.  prev_cont is set to what node_cont was before the call.
+ * node_cont is set to the next node after the current node_cont.
+ *
+ * This returns true if it found a next node and that its load of the
+ * next pointer from node was valid and stable.  Returning false means
+ * that the caller should retry.  There could be more items in the list.
+ */
+bool scoutfs_cwskip_read_next(struct scoutfs_cwskip_reader *rd, void **prev_cont, void **node_cont)
+{
+	struct scoutfs_cwskip_node *next;
+	unsigned int next_seq;
+	bool valid_next;
+
+	next = rd->node ? node_read_begin(rd->node->links[0], &next_seq) : NULL;
+	valid_next = scoutfs_cwskip_read_valid(rd) && next;
+	if (valid_next) {
+		rd->prev = rd->node;
+		rd->prev_seq = rd->node_seq;
+		rd->node = next;
+		rd->node_seq = next_seq;
+
+		set_containers(rd->root, rd->prev, rd->node, prev_cont, node_cont);
+	}
+
+	return valid_next;
+}
+
+/*
+ * End the critical section started with _read_begin.
+ */
+void scoutfs_cwskip_read_end(struct scoutfs_cwskip_reader *rd)
+	__releases(RCU) /* :/ */
+{
+	rcu_read_unlock();
+}
+
+/*
+ * Higher locks are more likely to cause contention so we unlock them
+ * first.
+ */
+static void writer_unlock(struct scoutfs_cwskip_writer *wr)
+{
+	int i;
+
+	for (i = wr->locked_height - 1; i >= 0; i--) {
+		if (i == 0 || (wr->prevs[i - 1] != wr->prevs[i]))
+			__node_unlock(wr->prevs[i]);
+	}
+
+	if (wr->node_locked)
+		__node_unlock(wr->node);
+
+	smp_wmb();
+
+	wr->locked_height = 0;
+	wr->node_locked = false;
+}
+
+/*
+ * A search traversal has saved all the previous nodes at each level.
+ *
+ * We try to acquire the write_seq locks for all the prevs up to height
+ * from the seqs that we read during the search.   The search was
+ * protected by read sections so the prevs represent a consistent
+ * version of the list at some point in the past.  If nodes have been
+ * locked since we read them we won't be able to acquire the locks.
+ * Nodes aren't re-inserted after removal so we shouldn't see nodes in
+ * multiple places (which would deadlock).
+ *
+ * The same node can be in multiple prev slots.  We're careful to only
+ * try locking the lowest duplicate slot.
+ *
+ * We lock from the highest level down.   This only matters when there's
+ * contention.   The higher nodes are more likely to see contention so
+ * we want trylock to fail early to avoid useless locking churn on lower
+ * nodes.
+ */
+static bool writer_trylock(struct scoutfs_cwskip_writer *wr, unsigned int *prev_seqs, int height)
+{
+	int i;
+
+	if (WARN_ON_ONCE(wr->locked_height != 0) ||
+	    WARN_ON_ONCE(height < 1 || height > ARRAY_SIZE(wr->prevs)))
+		return false;
+
+	for (i = height - 1; i >= 0; i--) {
+		if ((i == 0 || wr->prevs[i - 1] != wr->prevs[i]) &&
+		    !__node_trylock(wr->prevs[i], prev_seqs[i]))
+			break;
+		wr->locked_height++;
+	}
+
+	if (i < height) {
+		writer_unlock(wr);
+		return false;
+	}
+
+	/* paranoid debugging verification */
+	for (i = 0; i < wr->locked_height; i++) {
+		BUG_ON(wr->prevs[i]->height <= i);
+		BUG_ON(wr->node && i < wr->node->height && wr->prevs[i]->links[i] != wr->node);
+	}
+
+	smp_mb();
+	return true;
+}
+
+static void init_writer(struct scoutfs_cwskip_writer *wr, struct scoutfs_cwskip_root *root)
+{
+	memset(wr, 0, sizeof(struct scoutfs_cwskip_writer));
+	wr->root = root;
+}
+
+/*
+ * Search for and return references to the two nodes that surround the
+ * search key, with the nodes locked.
+ *
+ * Either node can be null if there are no nodes before or after the
+ * search key.  We still hold a lock on the static root node if the
+ * search key falls before the first node in the list.
+ *
+ * If lock_height is 0 then the caller is saying that they just want to
+ * lock the surrounding nodes and not modify their position in the list.
+ * We only lock those two nodes.  Any greater lock_height represents a
+ * height that we need to lock so the caller can insert an allocated
+ * node with that height.
+ *
+ * The caller can use the writer context to iterate through locked nodes
+ * via the lowest level list that contains all nodes.  If they hit a
+ * node that's higher than the locked height in the writer then they
+ * have to unlock and restart because we don't have the previous node
+ * for that height.  We set a min level that we lock to reduce the
+ * possibility of hitting higher nodes and retrying.
+ */
+#define MIN_LOCKED_HEIGHT 4
+void scoutfs_cwskip_write_begin(struct scoutfs_cwskip_root *root, void *key, int lock_height,
+				void **prev_cont, void **node_cont, int *node_cmp,
+				struct scoutfs_cwskip_writer *wr)
+	__acquires(RCU) /* :/ */
+{
+	unsigned int prev_seqs[SCOUTFS_CWSKIP_MAX_HEIGHT];
+	struct scoutfs_cwskip_reader rd;
+	int node_height;
+	int use_height;
+	bool locked;
+
+	BUG_ON(WARN_ON_ONCE(lock_height < 0 || lock_height > SCOUTFS_CWSKIP_MAX_HEIGHT));
+
+	do {
+		init_reader(&rd, root);
+		init_writer(wr, root);
+
+		rcu_read_lock();
+		cwskip_search(root, key, node_cmp, &rd, wr, NULL);
+
+		wr->node = rd.node;
+		if (wr->node) {
+			/* _trylock of prevs will issue barrier on success */
+			if (!__node_trylock(wr->node, rd.node_seq)) {
+				locked = false;
+				continue;
+			}
+			wr->node_locked = true;
+			node_height = wr->node->height;
+		} else {
+			node_height = 0;
+		}
+
+		if (lock_height > 0)
+			use_height = max3(MIN_LOCKED_HEIGHT, node_height, lock_height);
+		else
+			use_height = 1;
+
+		locked = writer_trylock(wr, prev_seqs, use_height);
+		if (!locked)
+			rcu_read_unlock();
+	} while (!locked);
+
+	set_containers(root, wr->prevs[0], wr->node, prev_cont, node_cont);
+}
+
+/*
+ * Insert a new node between the writer's two locked nodes.  The
+ * inserting node is locked and replaces the existing node in the writer
+ * which is unlocked.
+ *
+ * The next node may not exist.   The previous nodes will always exist
+ * though they may be the static root node.
+ *
+ * The inserting node is visible to readers the moment we store the
+ * first link to it in previous nodes.  We first lock it with a write
+ * barrier so that any readers will retry if they visit it before all
+ * its links are updated and its unlocked.
+ *
+ * We don't unlock prevs that are higher than the inserting node.  This
+ * lets the caller continue iterating through nodes that are higher than
+ * insertion but still under the locked height.
+ */
+void scoutfs_cwskip_write_insert(struct scoutfs_cwskip_writer *wr,
+				 struct scoutfs_cwskip_node *ins)
+{
+	struct scoutfs_cwskip_node *node = wr->node;
+	int i;
+
+	BUG_ON(ins->height > wr->locked_height);
+	node_trylock(ins, ins->write_seq);
+
+	for (i = 0; i < ins->height; i++) {
+		ins->links[i] = wr->prevs[i]->links[i];
+		wr->prevs[i]->links[i] = ins;
+	}
+
+	if (node)
+		node_unlock(node);
+	wr->node = ins;
+}
+
+/*
+ * Remove the node in the writer from the list.  The writers node
+ * pointer is not advanced because we don't want this to be able to fail
+ * if trylock on the next node fails.  The caller can call _write_next
+ * on this writer and it will try and iterate from prevs[0].
+ *
+ * The caller's removal argument must be the node pointer in the writer.
+ * This is redundant but meant to communicate to the caller that they're
+ * responsible for the node after removing it (presumably queueing it
+ * for freeing before _write_end leaves rcu).
+ *
+ * Readers can be traversing our node as we modify its pointers and can
+ * read a temporarily inconsistent state.  We have the node locked so
+ * the reader will immediately retry once the check the seqs after
+ * hitting our node that's being removed.
+ */
+void scoutfs_cwskip_write_remove(struct scoutfs_cwskip_writer *wr,
+				 struct scoutfs_cwskip_node *node)
+{
+	int i;
+
+	BUG_ON(node != wr->node);
+	BUG_ON(node->height > wr->locked_height);
+
+	for (i = 0; i < node->height; i++) {
+		wr->prevs[i]->links[i] = node->links[i];
+		node->links[i] = NULL;
+	}
+
+	node_unlock(node);
+	wr->node = NULL;
+}
+
+/*
+ * Advance through the list by setting prevs to node and node to the
+ * next node in the list after locking it.  Returns true only if there
+ * was a next node that we were able to lock.   Returning false can mean
+ * that we weren't able to lock the next node and the caller should
+ * retry a full search.
+ *
+ * This may be called after _write_remove clears node so we try to
+ * iterate from prev if there is no node.
+ *
+ * If lock_height is greater than zero then the caller needs at least
+ * that lock_height to insert a node of that height.   If locked_height
+ * doesn't cover it then we return false so the caller can retry
+ * _write_begin with the needed height.
+ *
+ * Like insertion, we don't unlock prevs higher than the height of the
+ * next node.   They're not strictly needed to modify the next node but
+ * we want to keep them locked so the caller can continue to iterate
+ * through nodes up to the locked height.
+ */
+bool scoutfs_cwskip_write_next(struct scoutfs_cwskip_writer *wr, int lock_height,
+			       void **prev_cont, void **node_cont)
+{
+	struct scoutfs_cwskip_node *next;
+	int i;
+
+	if (WARN_ON_ONCE(lock_height < 0 || lock_height > SCOUTFS_CWSKIP_MAX_HEIGHT))
+		return false;
+
+	if (wr->node)
+		next = rcu_dereference(wr->node->links[0]);
+	else
+		next = rcu_dereference(wr->prevs[0]->links[0]);
+
+	if (!next ||
+	    (lock_height > wr->locked_height) ||
+	    (lock_height > 0 && next->height > wr->locked_height) ||
+	    !__node_trylock(next, next->write_seq))
+		return false;
+
+	if (!wr->node) {
+		/* set next as missing node */
+		wr->node = next;
+		wr->node_locked = true;
+
+	} else {
+		/* existing node becomes prevs for its height */
+		__node_unlock(wr->prevs[0]);
+		for (i = 0; i < wr->node->height; i++)
+			wr->prevs[0] = wr->node;
+		wr->node = next;
+	}
+
+	smp_wmb(); /* next locked and prev unlocked */
+
+	set_containers(wr->root, wr->prevs[0], wr->node, prev_cont, node_cont);
+
+	return true;
+}
+
+void scoutfs_cwskip_write_end(struct scoutfs_cwskip_writer *wr)
+	__releases(RCU) /* :/ */
+{
+	writer_unlock(wr);
+	rcu_read_unlock();
+}

kmod/src/cwskip.h

@@ -0,0 +1,68 @@
+#ifndef _SCOUTFS_CWSKIP_H_
+#define _SCOUTFS_CWSKIP_H_
+
+/* A billion seems like a lot. */
+#define SCOUTFS_CWSKIP_MAX_HEIGHT 30
+
+struct scoutfs_cwskip_node {
+	int height;
+	unsigned int write_seq;
+	struct scoutfs_cwskip_node *links[];
+};
+
+#define SCOUTFS_CWSKIP_FULL_NODE_BYTES \
+	offsetof(struct scoutfs_cwskip_node, links[SCOUTFS_CWSKIP_MAX_HEIGHT + 1])
+
+typedef int (*scoutfs_cwskip_cmp_t)(void *K, void *C);
+
+struct scoutfs_cwskip_root {
+	scoutfs_cwskip_cmp_t cmp_fn;
+	unsigned long node_off;
+	union {
+		struct scoutfs_cwskip_node node;
+		__u8 __full_root_node[SCOUTFS_CWSKIP_FULL_NODE_BYTES];
+	};
+};
+
+struct scoutfs_cwskip_reader {
+	struct scoutfs_cwskip_root *root;
+	struct scoutfs_cwskip_node *prev;
+	struct scoutfs_cwskip_node *node;
+	unsigned int prev_seq;
+	unsigned int node_seq;
+};
+
+/*
+ * The full height prevs array makes these pretty enormous :/.
+ */
+struct scoutfs_cwskip_writer {
+	struct scoutfs_cwskip_root *root;
+	bool node_locked;
+	int locked_height;
+	struct scoutfs_cwskip_node *node;
+	struct scoutfs_cwskip_node *prevs[SCOUTFS_CWSKIP_MAX_HEIGHT];
+};
+
+void scoutfs_cwskip_init_root(struct scoutfs_cwskip_root *root, scoutfs_cwskip_cmp_t cmp_fn,
+			      unsigned long node_off);
+bool scoutfs_cwskip_empty(struct scoutfs_cwskip_root *root);
+int scoutfs_cwskip_rand_height(void);
+
+void scoutfs_cwskip_read_begin(struct scoutfs_cwskip_root *root, void *key, void **prev_cont,
+			       void **node_cont, int *node_cmp, struct scoutfs_cwskip_reader *rd);
+bool scoutfs_cwskip_read_valid(struct scoutfs_cwskip_reader *rd);
+bool scoutfs_cwskip_read_next(struct scoutfs_cwskip_reader *rd, void **prev_cont, void **node_cont);
+void scoutfs_cwskip_read_end(struct scoutfs_cwskip_reader *rd);
+
+void scoutfs_cwskip_write_begin(struct scoutfs_cwskip_root *root, void *key, int lock_height,
+				void **prev_cont, void **node_cont, int *node_cmp,
+				struct scoutfs_cwskip_writer *wr);
+void scoutfs_cwskip_write_insert(struct scoutfs_cwskip_writer *wr,
+				 struct scoutfs_cwskip_node *ins);
+void scoutfs_cwskip_write_remove(struct scoutfs_cwskip_writer *wr,
+				 struct scoutfs_cwskip_node *node);
+bool scoutfs_cwskip_write_next(struct scoutfs_cwskip_writer *wr, int lock_height,
+			       void **prev_cont, void **node_cont);
+void scoutfs_cwskip_write_end(struct scoutfs_cwskip_writer *wr);
+
+#endif

kmod/src/data.c

@@ -307,7 +307,7 @@ int scoutfs_data_truncate_items(struct super_block *sb, struct inode *inode,
 	LIST_HEAD(ind_locks);
 	s64 ret = 0;
 
-	WARN_ON_ONCE(inode && !inode_is_locked(inode));
+	WARN_ON_ONCE(inode && !mutex_is_locked(&inode->i_mutex));
 
 	/* clamp last to the last possible block? */
 	if (last > SCOUTFS_BLOCK_SM_MAX)
@@ -366,27 +366,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 +394,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,118 +413,66 @@ 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 within aligned regions tries to
-		 * allocate an extent to fill the hole in the region
-		 * that contains iblock.  We'd have to add a bit of plumbing
-		 * to find previous extents so we only search for a next
-		 * extent from the front of the region and from iblock.
-		 */
-		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;
-
-		/* trim count if there's an extent in the region before iblock */
-		if (found.len && found.start < iblock) {
-			count -= iblock - start;
-			start = iblock;
-			/* see if there's also an extent after iblock */
-			ret = scoutfs_ext_next(sb, &data_ext_ops, &args, iblock, 1, &found);
-			if (ret < 0 && ret != -ENOENT)
-				goto out;
-		}
-
-		/* trim count by next extent after iblock */
-		if (found.len && found.start > start && found.start < start + count)
-			count = (found.start - start);
+		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 */
@@ -558,7 +501,7 @@ static int scoutfs_get_block(struct inode *inode, sector_t iblock,
 	u64 offset;
 	int ret;
 
-	WARN_ON_ONCE(create && !inode_is_locked(inode));
+	WARN_ON_ONCE(create && !mutex_is_locked(&inode->i_mutex));
 
 	/* make sure caller holds a cluster lock */
 	lock = scoutfs_per_task_get(&si->pt_data_lock);
@@ -643,8 +586,8 @@ static int scoutfs_get_block_read(struct inode *inode, sector_t iblock,
 	return ret;
 }
 
-int scoutfs_get_block_write(struct inode *inode, sector_t iblock, struct buffer_head *bh,
-			    int create)
+static 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;
@@ -704,7 +647,7 @@ static int scoutfs_readpage(struct file *file, struct page *page)
 
 	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, inode_lock)) {
 		ret = scoutfs_data_wait_check(inode, page_offset(page),
-					      PAGE_SIZE, SEF_OFFLINE,
+					      PAGE_CACHE_SIZE, SEF_OFFLINE,
 					      SCOUTFS_IOC_DWO_READ, &dw,
 					      inode_lock);
 		if (ret != 0) {
@@ -729,7 +672,6 @@ static int scoutfs_readpage(struct file *file, struct page *page)
 	return ret;
 }
 
-#ifndef KC_FILE_AOPS_READAHEAD
 /*
  * This is used for opportunistic read-ahead which can throw the pages
  * away if it needs to.  If the caller didn't deal with offline extents
@@ -755,14 +697,14 @@ static int scoutfs_readpages(struct file *file, struct address_space *mapping,
 
 	list_for_each_entry_safe(page, tmp, pages, lru) {
 		ret = scoutfs_data_wait_check(inode, page_offset(page),
-					      PAGE_SIZE, SEF_OFFLINE,
+					      PAGE_CACHE_SIZE, SEF_OFFLINE,
 					      SCOUTFS_IOC_DWO_READ, NULL,
 					      inode_lock);
 		if (ret < 0)
 			goto out;
 		if (ret > 0) {
 			list_del(&page->lru);
-			put_page(page);
+			page_cache_release(page);
 			if (--nr_pages == 0) {
 				ret = 0;
 				goto out;
@@ -776,29 +718,6 @@ out:
 	BUG_ON(!list_empty(pages));
 	return ret;
 }
-#else
-static void scoutfs_readahead(struct readahead_control *rac)
-{
-	struct inode *inode = rac->file->f_inode;
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *inode_lock = NULL;
-	int ret;
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ,
-				 SCOUTFS_LKF_REFRESH_INODE, inode, &inode_lock);
-	if (ret)
-		return;
-
-	ret = scoutfs_data_wait_check(inode, readahead_pos(rac),
-				      readahead_length(rac), SEF_OFFLINE,
-				      SCOUTFS_IOC_DWO_READ, NULL,
-				      inode_lock);
-	if (ret == 0)
-		mpage_readahead(rac, scoutfs_get_block_read);
-
-	scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
-}
-#endif
 
 static int scoutfs_writepage(struct page *page, struct writeback_control *wbc)
 {
@@ -1064,6 +983,9 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 	u64 last;
 	s64 ret;
 
+	mutex_lock(&inode->i_mutex);
+	down_write(&si->extent_sem);
+
 	/* XXX support more flags */
         if (mode & ~(FALLOC_FL_KEEP_SIZE)) {
 		ret = -EOPNOTSUPP;
@@ -1081,22 +1003,18 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 		goto out;
 	}
 
-	inode_lock(inode);
-
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
 	if (ret)
-		goto out_mutex;
+		goto out;
 
 	inode_dio_wait(inode);
 
-	down_write(&si->extent_sem);
-
 	if (!(mode & FALLOC_FL_KEEP_SIZE) &&
 	    (offset + len > i_size_read(inode))) {
                 ret = inode_newsize_ok(inode, offset + len);
                 if (ret)
-                        goto out_extent;
+                        goto out;
         }
 
 	iblock = offset >> SCOUTFS_BLOCK_SM_SHIFT;
@@ -1106,7 +1024,7 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 
 		ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, false, true);
 		if (ret)
-			goto out_extent;
+			goto out;
 
 		ret = fallocate_extents(sb, inode, iblock, last, lock);
 
@@ -1132,19 +1050,17 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 		}
 
 		if (ret <= 0)
-			goto out_extent;
+			goto out;
 
 		iblock += ret;
 		ret = 0;
 	}
 
-out_extent:
-	up_write(&si->extent_sem);
-out_mutex:
-	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
-
 out:
+	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
+	up_write(&si->extent_sem);
+	mutex_unlock(&inode->i_mutex);
+
 	trace_scoutfs_data_fallocate(sb, ino, mode, offset, len, ret);
 	return ret;
 }
@@ -1228,9 +1144,9 @@ static void truncate_inode_pages_extent(struct inode *inode, u64 start, u64 len)
  * explained above the move_blocks ioctl argument structure definition.
  *
  * The caller has processed the ioctl args and performed the most basic
- * argument sanity and inode checks, but we perform more detailed inode
- * checks once we have the inode lock and refreshed inodes.  Our job is
- * to safely lock the two files and move the extents.
+ * inode checks, but we perform more detailed inode checks once we have
+ * the inode lock and refreshed inodes.  Our job is to safely lock the
+ * two files and move the extents.
  */
 #define MOVE_DATA_EXTENTS_PER_HOLD 16
 int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
@@ -1245,7 +1161,7 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 	struct data_ext_args from_args;
 	struct data_ext_args to_args;
 	struct scoutfs_extent ext;
-	struct kc_timespec cur_time;
+	struct timespec cur_time;
 	LIST_HEAD(locks);
 	bool done = false;
 	loff_t from_size;
@@ -1289,16 +1205,6 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 	from_iblock = from_off >> SCOUTFS_BLOCK_SM_SHIFT;
 	count = (byte_len + SCOUTFS_BLOCK_SM_MASK) >> SCOUTFS_BLOCK_SM_SHIFT;
 	to_iblock = to_off >> SCOUTFS_BLOCK_SM_SHIFT;
-	from_start = from_iblock;
-
-	/* only move extent blocks inside i_size, careful not to wrap */
-	from_size = i_size_read(from);
-	if (from_off >= from_size) {
-		ret = 0;
-		goto out;
-	}
-	if (from_off + byte_len > from_size)
-		count = ((from_size - from_off) + SCOUTFS_BLOCK_SM_MASK) >> SCOUTFS_BLOCK_SM_SHIFT;
 
 	if (S_ISDIR(from->i_mode) || S_ISDIR(to->i_mode)) {
 		ret = -EISDIR;
@@ -1366,7 +1272,7 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 
 			/* find the next extent to move */
 			ret = scoutfs_ext_next(sb, &data_ext_ops, &from_args,
-					       from_start, 1, &ext);
+					       from_iblock, 1, &ext);
 			if (ret < 0) {
 				if (ret == -ENOENT) {
 					done = true;
@@ -1375,8 +1281,9 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 				break;
 			}
 
-			/* done if next extent starts after moving region */
-			if (ext.start >= from_iblock + count) {
+			/* only move extents within count and i_size */
+			if (ext.start >= from_iblock + count ||
+			    ext.start >= i_size_read(from)) {
 				done = true;
 				ret = 0;
 				break;
@@ -1384,14 +1291,12 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 
 			from_start = max(ext.start, from_iblock);
 			map = ext.map + (from_start - ext.start);
-			len = min(from_iblock + count, ext.start + ext.len) - from_start;
-			to_start = to_iblock + (from_start - from_iblock);
+			len = min3(from_iblock + count,
+				   round_up((u64)i_size_read(from),
+					    SCOUTFS_BLOCK_SM_SIZE),
+				   ext.start + ext.len) - from_start;
 
-			/* we'd get stuck, shouldn't happen */
-			if (WARN_ON_ONCE(len == 0)) {
-				ret = -EIO;
-				goto out;
-			}
+			to_start = to_iblock + (from_start - from_iblock);
 
 			if (is_stage) {
 				ret = scoutfs_ext_next(sb, &data_ext_ops, &to_args,
@@ -1454,19 +1359,13 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 							i_size_read(from);
 				i_size_write(to, to_size);
 			}
-
-			/* find next after moved extent, avoiding wrapping */
-			if (from_start + len < from_start)
-				from_start = from_iblock + count + 1;
-			else
-				from_start += len;
 		}
 
 
 		up_write(&from_si->extent_sem);
 		up_write(&to_si->extent_sem);
 
-		cur_time = current_time(from);
+		cur_time = CURRENT_TIME;
 		if (!is_stage) {
 			to->i_ctime = to->i_mtime = cur_time;
 			inode_inc_iversion(to);
@@ -1553,7 +1452,7 @@ int scoutfs_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 	if (ret)
 		goto out;
 
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 	down_read(&si->extent_sem);
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ, 0, inode, &lock);
@@ -1607,7 +1506,7 @@ int scoutfs_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 unlock:
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
 	up_read(&si->extent_sem);
-	inode_unlock(inode);
+	mutex_unlock(&inode->i_mutex);
 
 out:
 	if (ret == 1)
@@ -1807,37 +1706,6 @@ int scoutfs_data_wait_check_iov(struct inode *inode, const struct iovec *iov,
 	return ret;
 }
 
-int scoutfs_data_wait_check_iter(struct inode *inode, loff_t pos, struct iov_iter *iter,
-				 u8 sef, u8 op, struct scoutfs_data_wait *dw,
-				 struct scoutfs_lock *lock)
-{
-	size_t count = iov_iter_count(iter);
-	size_t off = iter->iov_offset;
-	const struct iovec *iov;
-	size_t len;
-	int ret = 0;
-
-	for (iov = iter->iov; count > 0; iov++) {
-		len = iov->iov_len - off;
-		if (len == 0)
-			continue;
-
-		/* aren't we waiting on too much data here ? */
-		ret = scoutfs_data_wait_check(inode, pos, len,
-					      sef, op, dw, lock);
-
-		if (ret != 0)
-			break;
-
-
-		pos += len;
-		count -= len;
-		off = 0;
-	}
-
-	return ret;
-}
-
 int scoutfs_data_wait(struct inode *inode, struct scoutfs_data_wait *dw)
 {
 	DECLARE_DATA_WAIT_ROOT(inode->i_sb, rt);
@@ -1928,11 +1796,7 @@ int scoutfs_data_waiting(struct super_block *sb, u64 ino, u64 iblock,
 
 const struct address_space_operations scoutfs_file_aops = {
 	.readpage		= scoutfs_readpage,
-#ifndef KC_FILE_AOPS_READAHEAD
 	.readpages		= scoutfs_readpages,
-#else
-	.readahead		= scoutfs_readahead,
-#endif
 	.writepage		= scoutfs_writepage,
 	.writepages		= scoutfs_writepages,
 	.write_begin		= scoutfs_write_begin,
@@ -1940,15 +1804,10 @@ const struct address_space_operations scoutfs_file_aops = {
 };
 
 const struct file_operations scoutfs_file_fops = {
-#ifdef KC_LINUX_HAVE_FOP_AIO_READ
 	.read		= do_sync_read,
 	.write		= do_sync_write,
 	.aio_read	= scoutfs_file_aio_read,
 	.aio_write	= scoutfs_file_aio_write,
-#else
-	.read_iter	= scoutfs_file_read_iter,
-	.write_iter	= scoutfs_file_write_iter,
-#endif
 	.unlocked_ioctl	= scoutfs_ioctl,
 	.fsync		= scoutfs_file_fsync,
 	.llseek		= scoutfs_file_llseek,

kmod/src/data.h

@@ -43,9 +43,6 @@ extern const struct file_operations scoutfs_file_fops;
 struct scoutfs_alloc;
 struct scoutfs_block_writer;
 
-int scoutfs_get_block_write(struct inode *inode, sector_t iblock, struct buffer_head *bh,
-			    int create);
-
 int scoutfs_data_truncate_items(struct super_block *sb, struct inode *inode,
 				u64 ino, u64 iblock, u64 last, bool offline,
 				struct scoutfs_lock *lock);
@@ -65,9 +62,6 @@ int scoutfs_data_wait_check_iov(struct inode *inode, const struct iovec *iov,
 				unsigned long nr_segs, loff_t pos, u8 sef,
 				u8 op, struct scoutfs_data_wait *ow,
 				struct scoutfs_lock *lock);
-int scoutfs_data_wait_check_iter(struct inode *inode, loff_t pos, struct iov_iter *iter,
-				 u8 sef, u8 op, struct scoutfs_data_wait *ow,
-				 struct scoutfs_lock *lock);
 bool scoutfs_data_wait_found(struct scoutfs_data_wait *ow);
 int scoutfs_data_wait(struct inode *inode,
 			      struct scoutfs_data_wait *ow);

kmod/src/dir.h

@@ -5,22 +5,14 @@
 #include "lock.h"
 
 extern const struct file_operations scoutfs_dir_fops;
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 extern const struct inode_operations_wrapper scoutfs_dir_iops;
-#else
-extern const struct inode_operations scoutfs_dir_iops;
-#endif
 extern const struct inode_operations scoutfs_symlink_iops;
 
-extern const struct dentry_operations scoutfs_dentry_ops;
-
 struct scoutfs_link_backref_entry {
 	struct list_head head;
 	u64 dir_ino;
 	u64 dir_pos;
 	u16 name_len;
-	u8 d_type;
-	bool last;
 	struct scoutfs_dirent dent;
 	/* the full name is allocated and stored in dent.name[] */
 };
@@ -30,10 +22,14 @@ int scoutfs_dir_get_backref_path(struct super_block *sb, u64 ino, u64 dir_ino,
 void scoutfs_dir_free_backref_path(struct super_block *sb,
 				   struct list_head *list);
 
-int scoutfs_dir_add_next_linkrefs(struct super_block *sb, u64 ino, u64 dir_ino, u64 dir_pos,
-				  int count, struct list_head *list);
+int scoutfs_dir_add_next_linkref(struct super_block *sb, u64 ino,
+				 u64 dir_ino, u64 dir_pos,
+				 struct list_head *list);
 
 int scoutfs_symlink_drop(struct super_block *sb, u64 ino,
 			 struct scoutfs_lock *lock, u64 i_size);
 
+int scoutfs_dir_init(void);
+void scoutfs_dir_exit(void);
+
 #endif

kmod/src/export.c

@@ -81,7 +81,7 @@ static struct dentry *scoutfs_fh_to_dentry(struct super_block *sb,
 	trace_scoutfs_fh_to_dentry(sb, fh_type, sfid);
 
 	if (scoutfs_valid_fileid(fh_type))
-		inode = scoutfs_iget(sb, le64_to_cpu(sfid->ino), 0, SCOUTFS_IGF_LINKED);
+		inode = scoutfs_iget(sb, le64_to_cpu(sfid->ino), 0);
 
 	return d_obtain_alias(inode);
 }
@@ -100,7 +100,7 @@ static struct dentry *scoutfs_fh_to_parent(struct super_block *sb,
 
 	if (scoutfs_valid_fileid(fh_type) &&
 	    fh_type == FILEID_SCOUTFS_WITH_PARENT)
-		inode = scoutfs_iget(sb, le64_to_cpu(sfid->parent_ino), 0, SCOUTFS_IGF_LINKED);
+		inode = scoutfs_iget(sb, le64_to_cpu(sfid->parent_ino), 0);
 
 	return d_obtain_alias(inode);
 }
@@ -114,8 +114,8 @@ static struct dentry *scoutfs_get_parent(struct dentry *child)
 	int ret;
 	u64 ino;
 
-	ret = scoutfs_dir_add_next_linkrefs(sb, scoutfs_ino(inode), 0, 0, 1, &list);
-	if (ret < 0)
+	ret = scoutfs_dir_add_next_linkref(sb, scoutfs_ino(inode), 0, 0, &list);
+	if (ret)
 		return ERR_PTR(ret);
 
 	ent = list_first_entry(&list, struct scoutfs_link_backref_entry, head);
@@ -123,7 +123,7 @@ static struct dentry *scoutfs_get_parent(struct dentry *child)
 	scoutfs_dir_free_backref_path(sb, &list);
 	trace_scoutfs_get_parent(sb, inode, ino);
 
-	inode = scoutfs_iget(sb, ino, 0, SCOUTFS_IGF_LINKED);
+	inode = scoutfs_iget(sb, ino, 0);
 
 	return d_obtain_alias(inode);
 }
@@ -138,9 +138,9 @@ static int scoutfs_get_name(struct dentry *parent, char *name,
 	LIST_HEAD(list);
 	int ret;
 
-	ret = scoutfs_dir_add_next_linkrefs(sb, scoutfs_ino(inode), dir_ino,
-					    0, 1, &list);
-	if (ret < 0)
+	ret = scoutfs_dir_add_next_linkref(sb, scoutfs_ino(inode), dir_ino,
+					   0, &list);
+	if (ret)
 		return ret;
 
 	ret = -ENOENT;

kmod/src/fence.c

@@ -395,13 +395,12 @@ int scoutfs_fence_wait_fenced(struct super_block *sb, long timeout_jiffies)
 int scoutfs_fence_setup(struct super_block *sb)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
-	struct scoutfs_mount_options opts;
+	struct mount_options *opts = &sbi->opts;
 	struct fence_info *fi;
 	int ret;
 
 	/* can only fence if we can be elected by quorum */
-	scoutfs_options_read(sb, &opts);
-	if (opts.quorum_slot_nr == -1) {
+	if (opts->quorum_slot_nr == -1) {
 		ret = 0;
 		goto out;
 	}

kmod/src/file.c

@@ -29,7 +29,6 @@
 #include "per_task.h"
 #include "omap.h"
 
-#ifdef KC_LINUX_HAVE_FOP_AIO_READ
 /*
  * Start a high level file read.  We check for offline extents in the
  * read region here so that we only check the extents once.  We use the
@@ -43,27 +42,27 @@ ssize_t scoutfs_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
 	struct inode *inode = file_inode(file);
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *scoutfs_inode_lock = NULL;
+	struct scoutfs_lock *inode_lock = NULL;
 	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	DECLARE_DATA_WAIT(dw);
 	int ret;
 
 retry:
 	/* protect checked extents from release */
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 	atomic_inc(&inode->i_dio_count);
-	inode_unlock(inode);
+	mutex_unlock(&inode->i_mutex);
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ,
-				 SCOUTFS_LKF_REFRESH_INODE, inode, &scoutfs_inode_lock);
+				 SCOUTFS_LKF_REFRESH_INODE, inode, &inode_lock);
 	if (ret)
 		goto out;
 
-	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, scoutfs_inode_lock)) {
+	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, inode_lock)) {
 		ret = scoutfs_data_wait_check_iov(inode, iov, nr_segs, pos,
 						  SEF_OFFLINE,
 						  SCOUTFS_IOC_DWO_READ,
-						  &dw, scoutfs_inode_lock);
+						  &dw, inode_lock);
 		if (ret != 0)
 			goto out;
 	} else {
@@ -75,7 +74,7 @@ retry:
 out:
 	inode_dio_done(inode);
 	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
-	scoutfs_unlock(sb, scoutfs_inode_lock, SCOUTFS_LOCK_READ);
+	scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
 
 	if (scoutfs_data_wait_found(&dw)) {
 		ret = scoutfs_data_wait(inode, &dw);
@@ -93,7 +92,7 @@ ssize_t scoutfs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 	struct inode *inode = file_inode(file);
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *scoutfs_inode_lock = NULL;
+	struct scoutfs_lock *inode_lock = NULL;
 	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	DECLARE_DATA_WAIT(dw);
 	int ret;
@@ -102,22 +101,22 @@ ssize_t scoutfs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 		return 0;
 
 retry:
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
-				 SCOUTFS_LKF_REFRESH_INODE, inode, &scoutfs_inode_lock);
+				 SCOUTFS_LKF_REFRESH_INODE, inode, &inode_lock);
 	if (ret)
 		goto out;
 
-	ret = scoutfs_complete_truncate(inode, scoutfs_inode_lock);
+	ret = scoutfs_complete_truncate(inode, inode_lock);
 	if (ret)
 		goto out;
 
-	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, scoutfs_inode_lock)) {
+	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, inode_lock)) {
 		/* data_version is per inode, whole file must be online */
 		ret = scoutfs_data_wait_check(inode, 0, i_size_read(inode),
 					      SEF_OFFLINE,
 					      SCOUTFS_IOC_DWO_WRITE,
-					      &dw, scoutfs_inode_lock);
+					      &dw, inode_lock);
 		if (ret != 0)
 			goto out;
 	}
@@ -128,8 +127,8 @@ retry:
 
 out:
 	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
-	scoutfs_unlock(sb, scoutfs_inode_lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
+	scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_WRITE);
+	mutex_unlock(&inode->i_mutex);
 
 	if (scoutfs_data_wait_found(&dw)) {
 		ret = scoutfs_data_wait(inode, &dw);
@@ -147,113 +146,6 @@ out:
 
 	return ret;
 }
-#else
-ssize_t scoutfs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
-{
-	struct file *file = iocb->ki_filp;
-	struct inode *inode = file_inode(file);
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *scoutfs_inode_lock = NULL;
-	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
-	DECLARE_DATA_WAIT(dw);
-	int ret;
-
-retry:
-	/* protect checked extents from release */
-	inode_lock(inode);
-	atomic_inc(&inode->i_dio_count);
-	inode_unlock(inode);
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ,
-				 SCOUTFS_LKF_REFRESH_INODE, inode, &scoutfs_inode_lock);
-	if (ret)
-		goto out;
-
-	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, scoutfs_inode_lock)) {
-		ret = scoutfs_data_wait_check_iter(inode, iocb->ki_pos, to,
-						   SEF_OFFLINE,
-						   SCOUTFS_IOC_DWO_READ,
-						   &dw, scoutfs_inode_lock);
-		if (ret != 0)
-			goto out;
-	} else {
-		WARN_ON_ONCE(true);
-	}
-
-	ret = generic_file_read_iter(iocb, to);
-
-out:
-	inode_dio_end(inode);
-	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
-	scoutfs_unlock(sb, scoutfs_inode_lock, SCOUTFS_LOCK_READ);
-
-	if (scoutfs_data_wait_found(&dw)) {
-		ret = scoutfs_data_wait(inode, &dw);
-		if (ret == 0)
-			goto retry;
-	}
-	return ret;
-}
-
-ssize_t scoutfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
-{
-	struct file *file = iocb->ki_filp;
-	struct inode *inode = file_inode(file);
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *scoutfs_inode_lock = NULL;
-	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
-	DECLARE_DATA_WAIT(dw);
-	int ret;
-	int written;
-
-retry:
-	inode_lock(inode);
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
-				 SCOUTFS_LKF_REFRESH_INODE, inode, &scoutfs_inode_lock);
-	if (ret)
-		goto out;
-
-	ret = generic_write_checks(iocb, from);
-	if (ret <= 0)
-		goto out;
-
-	ret = scoutfs_complete_truncate(inode, scoutfs_inode_lock);
-	if (ret)
-		goto out;
-
-	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, scoutfs_inode_lock)) {
-		/* data_version is per inode, whole file must be online */
-		ret = scoutfs_data_wait_check_iter(inode, iocb->ki_pos, from,
-						   SEF_OFFLINE,
-						   SCOUTFS_IOC_DWO_WRITE,
-						   &dw, scoutfs_inode_lock);
-		if (ret != 0)
-			goto out;
-	}
-
-	/* XXX: remove SUID bit */
-
-	written = __generic_file_write_iter(iocb, from);
-
-out:
-	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
-	scoutfs_unlock(sb, scoutfs_inode_lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
-
-	if (scoutfs_data_wait_found(&dw)) {
-		ret = scoutfs_data_wait(inode, &dw);
-		if (ret == 0)
-			goto retry;
-	}
-
-	if (ret > 0 || ret == -EIOCBQUEUED)
-		ret = generic_write_sync(iocb, written);
-
-	return written ? written : ret;
-}
-#endif
 
 int scoutfs_permission(struct inode *inode, int mask)
 {

kmod/src/file.h

@@ -1,15 +1,10 @@
 #ifndef _SCOUTFS_FILE_H_
 #define _SCOUTFS_FILE_H_
 
-#ifdef KC_LINUX_HAVE_FOP_AIO_READ
 ssize_t scoutfs_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
 			      unsigned long nr_segs, loff_t pos);
 ssize_t scoutfs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 			       unsigned long nr_segs, loff_t pos);
-#else
-ssize_t scoutfs_file_read_iter(struct kiocb *, struct iov_iter *);
-ssize_t scoutfs_file_write_iter(struct kiocb *, struct iov_iter *);
-#endif
 int scoutfs_permission(struct inode *inode, int mask);
 loff_t scoutfs_file_llseek(struct file *file, loff_t offset, int whence);
 

kmod/src/forest.c

@@ -78,6 +78,11 @@ struct forest_refs {
 	struct scoutfs_block_ref logs_ref;
 };
 
+/* initialize some refs that initially aren't equal */
+#define DECLARE_STALE_TRACKING_SUPER_REFS(a, b)		\
+	struct forest_refs a = {{cpu_to_le64(0),}};	\
+	struct forest_refs b = {{cpu_to_le64(1),}}
+
 struct forest_bloom_nrs {
 	unsigned int nrs[SCOUTFS_FOREST_BLOOM_NRS];
 };
@@ -131,11 +136,11 @@ static struct scoutfs_block *read_bloom_ref(struct super_block *sb, struct scout
 int scoutfs_forest_next_hint(struct super_block *sb, struct scoutfs_key *key,
 			     struct scoutfs_key *next)
 {
+	DECLARE_STALE_TRACKING_SUPER_REFS(prev_refs, refs);
 	struct scoutfs_net_roots roots;
 	struct scoutfs_btree_root item_root;
 	struct scoutfs_log_trees *lt;
 	SCOUTFS_BTREE_ITEM_REF(iref);
-	DECLARE_SAVED_REFS(saved);
 	struct scoutfs_key found;
 	struct scoutfs_key ltk;
 	bool checked_fs;
@@ -150,6 +155,8 @@ retry:
 		goto out;
 
 	trace_scoutfs_forest_using_roots(sb, &roots.fs_root, &roots.logs_root);
+	refs.fs_ref = roots.fs_root.ref;
+	refs.logs_ref = roots.logs_root.ref;
 
 	scoutfs_key_init_log_trees(&ltk, 0, 0);
 	checked_fs = false;
@@ -205,10 +212,14 @@ retry:
 		}
 	}
 
-	ret = scoutfs_block_check_stale(sb, ret, &saved, &roots.fs_root.ref, &roots.logs_root.ref);
-	if (ret == -ESTALE)
+	if (ret == -ESTALE) {
+		if (memcmp(&prev_refs, &refs, sizeof(refs)) == 0)
+			return -EIO;
+		prev_refs = refs;
 		goto retry;
+	}
 out:
+
 	return ret;
 }
 
@@ -483,13 +494,13 @@ out:
 	return ret;
 }
 
-int scoutfs_forest_insert_list(struct super_block *sb,
-			       struct scoutfs_btree_item_list *lst)
+int scoutfs_forest_insert_list(struct super_block *sb, scoutfs_btree_item_iter_cb cb,
+			       void *pos, void *arg)
 {
 	DECLARE_FOREST_INFO(sb, finf);
 
 	return scoutfs_btree_insert_list(sb, finf->alloc, finf->wri,
-					 &finf->our_log.item_root, lst);
+					 &finf->our_log.item_root, cb, pos, arg);
 }
 
 /*
@@ -530,8 +541,9 @@ void scoutfs_forest_dec_inode_count(struct super_block *sb)
 
 /*
  * Return the total inode count from the super block and all the
- * log_btrees it references.  ESTALE from read blocks is returned to the
- * caller who is expected to retry or return hard errors.
+ * log_btrees it references.   This assumes it's working with a block
+ * reference hierarchy that should be fully consistent.   If we see
+ * ESTALE we've hit persistent corruption.
  */
 int scoutfs_forest_inode_count(struct super_block *sb, struct scoutfs_super_block *super,
 			       u64 *inode_count)
@@ -560,6 +572,8 @@ int scoutfs_forest_inode_count(struct super_block *sb, struct scoutfs_super_bloc
 		if (ret < 0) {
 			if (ret == -ENOENT)
 				ret = 0;
+			else if (ret == -ESTALE)
+				ret = -EIO;
 			break;
 		}
 	}

kmod/src/forest.h

@@ -29,8 +29,8 @@ void scoutfs_forest_set_max_seq(struct super_block *sb, u64 max_seq);
 int scoutfs_forest_get_max_seq(struct super_block *sb,
 			       struct scoutfs_super_block *super,
 			       u64 *seq);
-int scoutfs_forest_insert_list(struct super_block *sb,
-			       struct scoutfs_btree_item_list *lst);
+int scoutfs_forest_insert_list(struct super_block *sb, scoutfs_btree_item_iter_cb cb,
+			       void *pos, void *arg);
 int scoutfs_forest_srch_add(struct super_block *sb, u64 hash, u64 ino, u64 id);
 
 void scoutfs_forest_inc_inode_count(struct super_block *sb);

kmod/src/format.h

@@ -683,19 +683,16 @@ struct scoutfs_xattr_totl_val {
 #define SCOUTFS_QUORUM_ELECT_VAR_MS	100
 
 /*
- * Once a leader is elected they send heartbeat messages to all quorum
- * members at regular intervals to force members to wait the much longer
- * heartbeat timeout.  Once the heartbeat timeout expires without
- * receiving a heartbeat message a member will start an election.
+ * Once a leader is elected they send out heartbeats at regular
+ * intervals to force members to wait the much longer heartbeat timeout.
+ * Once heartbeat timeout expires without receiving a heartbeat they'll
+ * switch over the performing elections.
  *
  * These determine how long it could take members to notice that a
- * leader has gone silent and start to elect a new leader.  The
- * heartbeat timeout can be changed at run time by options.
+ * leader has gone silent and start to elect a new leader.
  */
 #define SCOUTFS_QUORUM_HB_IVAL_MS	100
-#define SCOUTFS_QUORUM_MIN_HB_TIMEO_MS	(2 * MSEC_PER_SEC)
-#define SCOUTFS_QUORUM_DEF_HB_TIMEO_MS	(10 * MSEC_PER_SEC)
-#define SCOUTFS_QUORUM_MAX_HB_TIMEO_MS	(60 * MSEC_PER_SEC)
+#define SCOUTFS_QUORUM_HB_TIMEO_MS	(5 * MSEC_PER_SEC)
 
 /*
  * A newly elected leader will give fencing some time before giving up and

kmod/src/inode.h

@@ -22,7 +22,7 @@ struct scoutfs_inode_info {
 	u64 online_blocks;
 	u64 offline_blocks;
 	u32 flags;
-	struct kc_timespec crtime;
+	struct timespec crtime;
 
 	/*
 	 * Protects per-inode extent items, most particularly readers
@@ -56,16 +56,14 @@ struct scoutfs_inode_info {
 
 	struct scoutfs_lock_coverage ino_lock_cov;
 
-	struct list_head iput_head;
-	unsigned long iput_count;
-	unsigned long iput_flags;
+	/* drop if i_count hits 0, allows drop while invalidate holds coverage */
+	bool drop_invalidated;
+	struct llist_node iput_llnode;
+	atomic_t iput_count;
 
 	struct inode inode;
 };
 
-/* try to prune dcache aliases with queued iput */
-#define SI_IPUT_FLAG_PRUNE	(1 << 0)
-
 static inline struct scoutfs_inode_info *SCOUTFS_I(struct inode *inode)
 {
 	return container_of(inode, struct scoutfs_inode_info, inode);
@@ -80,15 +78,11 @@ struct inode *scoutfs_alloc_inode(struct super_block *sb);
 void scoutfs_destroy_inode(struct inode *inode);
 int scoutfs_drop_inode(struct inode *inode);
 void scoutfs_evict_inode(struct inode *inode);
-void scoutfs_inode_queue_iput(struct inode *inode, unsigned long flags);
+void scoutfs_inode_queue_iput(struct inode *inode);
 
-#define SCOUTFS_IGF_LINKED (1 << 0) /* enoent if nlink == 0 */
-struct inode *scoutfs_iget(struct super_block *sb, u64 ino, int lkf, int igf);
-struct inode *scoutfs_ilookup_nowait(struct super_block *sb, u64 ino);
-struct inode *scoutfs_ilookup_nowait_nonewfree(struct super_block *sb, u64 ino);
+struct inode *scoutfs_iget(struct super_block *sb, u64 ino, int lkf);
+struct inode *scoutfs_ilookup(struct super_block *sb, u64 ino);
 
-
-void scoutfs_inode_init_key(struct scoutfs_key *key, u64 ino);
 void scoutfs_inode_init_index_key(struct scoutfs_key *key, u8 type, u64 major,
 				  u32 minor, u64 ino);
 int scoutfs_inode_index_start(struct super_block *sb, u64 *seq);
@@ -108,8 +102,9 @@ void scoutfs_update_inode_item(struct inode *inode, struct scoutfs_lock *lock,
 			       struct list_head *ind_locks);
 
 int scoutfs_alloc_ino(struct super_block *sb, bool is_dir, u64 *ino_ret);
-int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, dev_t rdev,
-		      u64 ino, struct scoutfs_lock *lock, struct inode **inode_ret);
+struct inode *scoutfs_new_inode(struct super_block *sb, struct inode *dir,
+				umode_t mode, dev_t rdev, u64 ino,
+				struct scoutfs_lock *lock);
 
 void scoutfs_inode_set_meta_seq(struct inode *inode);
 void scoutfs_inode_set_data_seq(struct inode *inode);
@@ -122,21 +117,14 @@ u64 scoutfs_inode_data_version(struct inode *inode);
 void scoutfs_inode_get_onoff(struct inode *inode, s64 *on, s64 *off);
 int scoutfs_complete_truncate(struct inode *inode, struct scoutfs_lock *lock);
 
-int scoutfs_inode_refresh(struct inode *inode, struct scoutfs_lock *lock);
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
+int scoutfs_inode_refresh(struct inode *inode, struct scoutfs_lock *lock,
+			  int flags);
 int scoutfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 		    struct kstat *stat);
-#else
-int scoutfs_getattr(const struct path *path, struct kstat *stat,
-		    u32 request_mask, unsigned int query_flags);
-#endif
 int scoutfs_setattr(struct dentry *dentry, struct iattr *attr);
 
-int scoutfs_inode_orphan_create(struct super_block *sb, u64 ino, struct scoutfs_lock *lock,
-				struct scoutfs_lock *primary);
-int scoutfs_inode_orphan_delete(struct super_block *sb, u64 ino, struct scoutfs_lock *lock,
-				struct scoutfs_lock *primary);
-void scoutfs_inode_schedule_orphan_dwork(struct super_block *sb);
+int scoutfs_inode_orphan_create(struct super_block *sb, u64 ino, struct scoutfs_lock *lock);
+int scoutfs_inode_orphan_delete(struct super_block *sb, u64 ino, struct scoutfs_lock *lock);
 
 void scoutfs_inode_queue_writeback(struct inode *inode);
 int scoutfs_inode_walk_writeback(struct super_block *sb, bool write);

kmod/src/ioctl.c

@@ -22,7 +22,6 @@
 #include <linux/sched.h>
 #include <linux/aio.h>
 #include <linux/list_sort.h>
-#include <linux/backing-dev.h>
 
 #include "format.h"
 #include "key.h"
@@ -303,7 +302,7 @@ static long scoutfs_ioc_release(struct file *file, unsigned long arg)
 	if (ret)
 		return ret;
 
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
@@ -352,7 +351,7 @@ static long scoutfs_ioc_release(struct file *file, unsigned long arg)
 
 out:
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
+	mutex_unlock(&inode->i_mutex);
 	mnt_drop_write_file(file);
 
 	trace_scoutfs_ioc_release_ret(sb, scoutfs_ino(inode), ret);
@@ -388,13 +387,13 @@ static long scoutfs_ioc_data_wait_err(struct file *file, unsigned long arg)
 	if (sblock > eblock)
 		return -EINVAL;
 
-	inode = scoutfs_ilookup_nowait_nonewfree(sb, args.ino);
+	inode = scoutfs_ilookup(sb, args.ino);
 	if (!inode) {
 		ret = -ESTALE;
 		goto out;
 	}
 
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ,
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
@@ -412,7 +411,7 @@ static long scoutfs_ioc_data_wait_err(struct file *file, unsigned long arg)
 
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
 unlock:
-	inode_unlock(inode);
+	mutex_unlock(&inode->i_mutex);
 	iput(inode);
 out:
 	return ret;
@@ -449,6 +448,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg)
 {
 	struct inode *inode = file_inode(file);
 	struct super_block *sb = inode->i_sb;
+	struct address_space *mapping = inode->i_mapping;
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	struct scoutfs_ioctl_stage args;
@@ -480,10 +480,8 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg)
 	/* the iocb is really only used for the file pointer :P */
 	init_sync_kiocb(&kiocb, file);
 	kiocb.ki_pos = args.offset;
-#ifdef KC_LINUX_AIO_KI_LEFT
 	kiocb.ki_left = args.length;
 	kiocb.ki_nbytes = args.length;
-#endif
 	iov.iov_base = (void __user *)(unsigned long)args.buf_ptr;
 	iov.iov_len = args.length;
 
@@ -491,7 +489,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg)
 	if (ret)
 		return ret;
 
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
@@ -518,7 +516,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg)
 	}
 
 	si->staging = true;
-	current->backing_dev_info = inode_to_bdi(inode);
+	current->backing_dev_info = mapping->backing_dev_info;
 
 	pos = args.offset;
 	written = 0;
@@ -535,7 +533,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg)
 out:
 	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
+	mutex_unlock(&inode->i_mutex);
 	mnt_drop_write_file(file);
 
 	trace_scoutfs_ioc_stage_ret(sb, scoutfs_ino(inode), ret);
@@ -654,7 +652,7 @@ static long scoutfs_ioc_setattr_more(struct file *file, unsigned long arg)
 	if (ret)
 		goto out;
 
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
@@ -698,7 +696,7 @@ static long scoutfs_ioc_setattr_more(struct file *file, unsigned long arg)
 unlock:
 	scoutfs_inode_index_unlock(sb, &ind_locks);
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
+	mutex_unlock(&inode->i_mutex);
 	mnt_drop_write_file(file);
 out:
 
@@ -1322,188 +1320,6 @@ out:
 	return ret ?: count;
 }
 
-static long scoutfs_ioc_get_allocated_inos(struct file *file, unsigned long arg)
-{
-	struct super_block *sb = file_inode(file)->i_sb;
-	struct scoutfs_ioctl_get_allocated_inos __user *ugai = (void __user *)arg;
-	struct scoutfs_ioctl_get_allocated_inos gai;
-	struct scoutfs_lock *lock = NULL;
-	struct scoutfs_key key;
-	struct scoutfs_key end;
-	u64 __user *uinos;
-	u64 bytes;
-	u64 ino;
-	int nr;
-	int ret;
-
-	if (!(file->f_mode & FMODE_READ)) {
-		ret = -EBADF;
-		goto out;
-	}
-
-	if (!capable(CAP_SYS_ADMIN)) {
-		ret = -EPERM;
-		goto out;
-	}
-
-	if (copy_from_user(&gai, ugai, sizeof(gai))) {
-		ret = -EFAULT;
-		goto out;
-	}
-
-	if ((gai.inos_ptr & (sizeof(__u64) - 1)) || (gai.inos_bytes < sizeof(__u64))) {
-		ret = -EINVAL;
-		goto out;
-	}
-
-	scoutfs_inode_init_key(&key, gai.start_ino);
-	scoutfs_inode_init_key(&end, gai.start_ino | SCOUTFS_LOCK_INODE_GROUP_MASK);
-	uinos = (void __user *)gai.inos_ptr;
-	bytes = gai.inos_bytes;
-	nr = 0;
-
-	ret = scoutfs_lock_ino(sb, SCOUTFS_LOCK_READ, 0, gai.start_ino, &lock);
-	if (ret < 0)
-		goto out;
-
-	while (bytes >= sizeof(*uinos)) {
-
-		ret = scoutfs_item_next(sb, &key, &end, NULL, 0, lock);
-		if (ret < 0) {
-			if (ret == -ENOENT)
-				ret = 0;
-			break;
-		}
-
-		if (key.sk_zone != SCOUTFS_FS_ZONE) {
-			ret = 0;
-			break;
-		}
-
-		/* all fs items are owned by allocated inodes, and _first is always ino */
-		ino = le64_to_cpu(key._sk_first);
-		if (put_user(ino, uinos)) {
-			ret = -EFAULT;
-			break;
-		}
-
-		uinos++;
-		bytes -= sizeof(*uinos);
-		if (++nr == INT_MAX)
-			break;
-
-		scoutfs_inode_init_key(&key, ino + 1);
-	}
-
-	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
-out:
-	return ret ?: nr;
-}
-
-/*
- * Copy entries that point to an inode to the user's buffer.  We copy to
- * userspace from copies of the entries that are acquired under a lock
- * so that we don't fault while holding cluster locks.  It also gives us
- * a chance to limit the amount of work under each lock hold.
- */
-static long scoutfs_ioc_get_referring_entries(struct file *file, unsigned long arg)
-{
-	struct super_block *sb = file_inode(file)->i_sb;
-	struct scoutfs_ioctl_get_referring_entries gre;
-	struct scoutfs_link_backref_entry *bref = NULL;
-	struct scoutfs_link_backref_entry *bref_tmp;
-	struct scoutfs_ioctl_dirent __user *uent;
-	struct scoutfs_ioctl_dirent ent;
-	LIST_HEAD(list);
-	u64 copied;
-	int name_len;
-	int bytes;
-	long nr;
-	int ret;
-
-	if (!capable(CAP_DAC_READ_SEARCH))
-		return -EPERM;
-
-	if (copy_from_user(&gre, (void __user *)arg, sizeof(gre)))
-		return -EFAULT;
-
-	uent = (void __user *)(unsigned long)gre.entries_ptr;
-	copied = 0;
-	nr = 0;
-
-	/* use entry as cursor between calls */
-	ent.dir_ino = gre.dir_ino;
-	ent.dir_pos = gre.dir_pos;
-
-	for (;;) {
-		ret = scoutfs_dir_add_next_linkrefs(sb, gre.ino, ent.dir_ino, ent.dir_pos, 1024,
-						    &list);
-		if (ret < 0) {
-			if (ret == -ENOENT)
-				ret = 0;
-			goto out;
-		}
-
-		/* _add_next adds each entry to the head, _reverse for key order */
-		list_for_each_entry_safe_reverse(bref, bref_tmp, &list, head) {
-			list_del_init(&bref->head);
-
-			name_len = bref->name_len;
-			bytes = ALIGN(offsetof(struct scoutfs_ioctl_dirent, name[name_len + 1]),
-				      16);
-			if (copied + bytes > gre.entries_bytes) {
-				ret = -EINVAL;
-				goto out;
-			}
-
-			ent.dir_ino = bref->dir_ino;
-			ent.dir_pos = bref->dir_pos;
-			ent.ino = gre.ino;
-			ent.entry_bytes = bytes;
-			ent.flags = bref->last ? SCOUTFS_IOCTL_DIRENT_FLAG_LAST : 0;
-			ent.d_type = bref->d_type;
-			ent.name_len = name_len;
-
-			if (copy_to_user(uent, &ent, sizeof(struct scoutfs_ioctl_dirent)) ||
-			    copy_to_user(&uent->name[0], bref->dent.name, name_len) ||
-			    put_user('\0', &uent->name[name_len])) {
-				ret = -EFAULT;
-				goto out;
-			}
-
-			kfree(bref);
-			bref = NULL;
-
-			uent = (void __user *)uent + bytes;
-			copied += bytes;
-			nr++;
-
-			if (nr == LONG_MAX || (ent.flags & SCOUTFS_IOCTL_DIRENT_FLAG_LAST)) {
-				ret = 0;
-				goto out;
-			}
-		}
-
-		/* advance cursor pos from last copied entry */
-		if (++ent.dir_pos == 0) {
-			if (++ent.dir_ino == 0) {
-				ret = 0;
-				goto out;
-			}
-		}
-	}
-
-	ret = 0;
-out:
-	kfree(bref);
-	list_for_each_entry_safe(bref, bref_tmp, &list, head) {
-		list_del_init(&bref->head);
-		kfree(bref);
-	}
-
-	return nr ?: ret;
-}
-
 long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	switch (cmd) {
@@ -1537,10 +1353,6 @@ long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 		return scoutfs_ioc_resize_devices(file, arg);
 	case SCOUTFS_IOC_READ_XATTR_TOTALS:
 		return scoutfs_ioc_read_xattr_totals(file, arg);
-	case SCOUTFS_IOC_GET_ALLOCATED_INOS:
-		return scoutfs_ioc_get_allocated_inos(file, arg);
-	case SCOUTFS_IOC_GET_REFERRING_ENTRIES:
-		return scoutfs_ioc_get_referring_entries(file, arg);
 	}
 
 	return -ENOTTY;

kmod/src/ioctl.h

@@ -520,157 +520,4 @@ struct scoutfs_ioctl_xattr_total {
 #define SCOUTFS_IOC_READ_XATTR_TOTALS \
 	_IOW(SCOUTFS_IOCTL_MAGIC, 15, struct scoutfs_ioctl_read_xattr_totals)
 
-/*
- * This fills the caller's inos array with inode numbers that are in use
- * after the start ino, within an internal inode group.
- *
- * This only makes a promise about the state of the inode numbers within
- * the first and last numbers returned by one call.  At one time, all of
- * those inodes were still allocated.   They could have changed before
- * the call returned.   And any numbers outside of the first and last
- * (or single) are undefined.
- *
- * This doesn't iterate over all allocated inodes, it only probes a
- * single group that the start inode is within.   This interface was
- * first introduced to support tests that needed to find out about a
- * specific inode, while having some other similarly niche uses.   It is
- * unsuitable for a consistent iteration over all the inode numbers in
- * use.
- *
- * This test of inode items doesn't serialize with the inode lifetime
- * mechanism.   It only tells you the numbers of inodes that were once
- * active in the system and haven't yet been fully deleted.  The inode
- * numbers returned could have been in the process of being deleted and
- * were already unreachable even before the call started.
- *
- * @start_ino: the first inode number that could be returned
- * @inos_ptr: pointer to an aligned array of 64bit inode numbers
- * @inos_bytes: the number of bytes available in the inos_ptr array
- *
- * Returns errors or the count of inode numbers returned, quite possibly
- * including 0.
- */
-struct scoutfs_ioctl_get_allocated_inos {
-	__u64 start_ino;
-	__u64 inos_ptr;
-	__u64 inos_bytes;
-};
-
-#define SCOUTFS_IOC_GET_ALLOCATED_INOS \
-	_IOW(SCOUTFS_IOCTL_MAGIC, 16, struct scoutfs_ioctl_get_allocated_inos)
-
-/*
- * Get directory entries that refer to a specific inode.
- *
- * @ino: The target ino that we're finding referring entries to.
- * Constant across all the calls that make up an iteration over all the
- * inode's entries.
- *
- * @dir_ino: The inode number of a directory containing the entry to our
- * inode to search from.  If this parent directory contains no more
- * entries to our inode then we'll search through other parent directory
- * inodes in inode order.
- *
- * @dir_pos: The position in the dir_ino parent directory of the entry
- * to our inode to search from.  If there is no entry at this position
- * then we'll search through other entry positions in increasing order.
- * If we exhaust the parent directory then we'll search through
- * additional parent directories in inode order.
- *
- * @entries_ptr: A pointer to the buffer where found entries will be
- * stored.  The pointer must be aligned to 16 bytes.
- *
- * @entries_bytes: The size of the buffer that will contain entries.
- *
- * To start iterating set the desired target ino, dir_ino to 0, dir_pos
- * to 0, and set result_ptr and _bytes to a sufficiently large buffer.
- * Each entry struct that's stored in the buffer adds some overhead so a
- * large multiple of the largest possible name is a reasonable choice.
- * (A few multiples of PATH_MAX perhaps.)
- *
- * Each call returns the total number of entries that were stored in the
- * entries buffer.  Zero is returned when the search was successful and
- * no referring entries were found.  The entries can be iterated over by
- * advancing each starting struct offset by the total number of bytes in
- * each entry.  If the _LAST flag is set on an entry then there were no
- * more entries referring to the inode at the time of the call and
- * iteration can be stopped.
- *
- * To resume iteration set the next call's starting dir_ino and dir_pos
- * to one past the last entry seen.  Increment the last entry's dir_pos,
- * and if it wrapped to 0, increment its dir_ino.
- *
- * This does not check that the caller has permission to read the
- * entries found in each containing directory.  It requires
- * CAP_DAC_READ_SEARCH which bypasses path traversal permissions
- * checking.
- *
- * Entries returned by a single call can reflect any combination of
- * racing creation and removal of entries.  Each entry existed at the
- * time it was read though it may have changed in the time it took to
- * return from the call.  The set of entries returned may no longer
- * reflect the current set of entries and may not have existed at the
- * same time.
- *
- * This has no knowledge of the life cycle of the inode.  It can return
- * 0 when there are no referring entries because either the target inode
- * doesn't exist, it is in the process of being deleted, or because it
- * is still open while being unlinked.
- *
- * On success this returns the number of entries filled in the buffer.
- * A return of 0 indicates that no entries referred to the inode.
- *
- * EINVAL is returned when there is a problem with the buffer.  Either
- * it was not aligned or it was not large enough for the first entry.
- *
- * Many other errnos indicate hard failure to find the next entry.
- */
-struct scoutfs_ioctl_get_referring_entries {
-	__u64 ino;
-	__u64 dir_ino;
-	__u64 dir_pos;
-	__u64 entries_ptr;
-	__u64 entries_bytes;
-};
-
-/*
- * @dir_ino: The inode of the directory containing the entry.
- *
- * @dir_pos: The readdir f_pos position of the entry within the
- * directory.
- *
- * @ino: The inode number of the target of the entry.
- *
- * @flags: Flags associated with this entry.
- *
- * @d_type: Inode type as specified with DT_ enum values in readdir(3).
- *
- * @entry_bytes: The total bytes taken by the entry in memory, including
- * the name and any alignment padding.  The start of a following entry
- * will be found after this number of bytes.
- *
- * @name_len: The number of bytes in the name not including the trailing
- * null, ala strlen(3).
- *
- * @name: The null terminated name of the referring entry.  In the
- * struct definition this array is sized to naturally align the struct.
- * That number of padded bytes are not necessarily found in the buffer
- * returned by _get_referring_entries;
- */
-struct scoutfs_ioctl_dirent {
-	__u64 dir_ino;
-	__u64 dir_pos;
-	__u64 ino;
-	__u16 entry_bytes;
-	__u8  flags;
-	__u8  d_type;
-	__u8  name_len;
-	__u8  name[3];
-};
-
-#define SCOUTFS_IOCTL_DIRENT_FLAG_LAST (1 << 0)
-
-#define SCOUTFS_IOC_GET_REFERRING_ENTRIES \
-	_IOW(SCOUTFS_IOCTL_MAGIC, 17, struct scoutfs_ioctl_get_referring_entries)
-
 #endif

kmod/src/item.h

@@ -15,17 +15,18 @@ int scoutfs_item_create(struct super_block *sb, struct scoutfs_key *key,
 			void *val, int val_len, struct scoutfs_lock *lock);
 int scoutfs_item_create_force(struct super_block *sb, struct scoutfs_key *key,
 			      void *val, int val_len,
-			      struct scoutfs_lock *lock, struct scoutfs_lock *primary);
+			      struct scoutfs_lock *lock);
 int scoutfs_item_update(struct super_block *sb, struct scoutfs_key *key,
 			void *val, int val_len, struct scoutfs_lock *lock);
 int scoutfs_item_delta(struct super_block *sb, struct scoutfs_key *key,
 		       void *val, int val_len, struct scoutfs_lock *lock);
 int scoutfs_item_delete(struct super_block *sb, struct scoutfs_key *key,
 			  struct scoutfs_lock *lock);
-int scoutfs_item_delete_force(struct super_block *sb, struct scoutfs_key *key,
-			      struct scoutfs_lock *lock, struct scoutfs_lock *primary);
+int scoutfs_item_delete_force(struct super_block *sb,
+				struct scoutfs_key *key,
+				struct scoutfs_lock *lock);
 
-u64 scoutfs_item_dirty_pages(struct super_block *sb);
+u64 scoutfs_item_dirty_bytes(struct super_block *sb);
 int scoutfs_item_write_dirty(struct super_block *sb);
 int scoutfs_item_write_done(struct super_block *sb);
 bool scoutfs_item_range_cached(struct super_block *sb,

kmod/src/kernelcompat.c

@@ -1,84 +0,0 @@
-
-#include <linux/uio.h>
-
-#include "kernelcompat.h"
-
-#ifdef KC_SHRINKER_SHRINK
-#include <linux/shrinker.h>
-/*
- * If a target doesn't have that .{count,scan}_objects() interface then
- * we have a .shrink() helper that performs the shrink work in terms of
- * count/scan.
- */
-int kc_shrink_wrapper_fn(struct shrinker *shrink, struct shrink_control *sc)
-{
-	struct kc_shrinker_wrapper *wrapper = container_of(shrink, struct kc_shrinker_wrapper, shrink);
-	unsigned long nr;
-	unsigned long rc;
-
-	if (sc->nr_to_scan != 0) {
-		rc = wrapper->scan_objects(shrink, sc);
-		/* translate magic values to the equivalent for older kernels */
-		if (rc == SHRINK_STOP)
-			return -1;
-		else if (rc == SHRINK_EMPTY)
-			return 0;
-	}
-
-	nr = wrapper->count_objects(shrink, sc);
-
-	return min_t(unsigned long, nr, INT_MAX);
-}
-#endif
-
-#ifndef KC_CURRENT_TIME_INODE
-struct timespec64 kc_current_time(struct inode *inode)
-{
-	struct timespec64 now;
-	unsigned gran;
-
-	getnstimeofday64(&now);
-
-	if (unlikely(!inode->i_sb)) {
-		WARN(1, "current_time() called with uninitialized super_block in the inode");
-		return now;
-	}
-
-	gran = inode->i_sb->s_time_gran;
-
-	/* Avoid division in the common cases 1 ns and 1 s. */
-	if (gran == 1) {
-		/* nothing */
-	} else if (gran == NSEC_PER_SEC) {
-		now.tv_nsec = 0;
-	} else if (gran > 1 && gran < NSEC_PER_SEC) {
-		now.tv_nsec -= now.tv_nsec % gran;
-	} else {
-		WARN(1, "illegal file time granularity: %u", gran);
-	}
-
-	return now;
-}
-#endif
-
-#ifndef KC_GENERIC_FILE_BUFFERED_WRITE
-ssize_t
-kc_generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
-			       unsigned long nr_segs, loff_t pos, loff_t *ppos,
-			       size_t count, ssize_t written)
-{
-	struct file *file = iocb->ki_filp;
-	ssize_t status;
-	struct iov_iter i;
-
-	iov_iter_init(&i, WRITE, iov, nr_segs, count);
-	status = generic_perform_write(file, &i, pos);
-
-	if (likely(status >= 0)) {
-		written += status;
-		*ppos = pos + status;
-	}
-
-	return written ? written : status;
-}
-#endif

kmod/src/kernelcompat.h

@@ -1,35 +1,8 @@
 #ifndef _SCOUTFS_KERNELCOMPAT_H_
 #define _SCOUTFS_KERNELCOMPAT_H_
 
-#include <linux/kernel.h>
-#include <linux/fs.h>
-
-/*
- * v4.15-rc3-4-gae5e165d855d
- *
- * new API for handling inode->i_version. This forces us to
- * include this API where we need. We include it here for
- * convenience instead of where it's needed.
- */
-#ifdef KC_NEED_LINUX_IVERSION_H
-#include <linux/iversion.h>
-#else
-/*
- * Kernels before above version will need to fall back to
- * manipulating inode->i_version as previous with degraded
- * methods.
- */
-#define inode_set_iversion_queried(inode, val)	\
-do {						\
-	(inode)->i_version = val;		\
-} while (0)
-#define inode_peek_iversion(inode)		\
-({						\
-	(inode)->i_version;			\
-})
-#endif
-
 #ifndef KC_ITERATE_DIR_CONTEXT
+#include <linux/fs.h>
 typedef filldir_t kc_readdir_ctx_t;
 #define KC_DECLARE_READDIR(name, file, dirent, ctx) name(file, dirent, ctx)
 #define KC_FOP_READDIR readdir
@@ -73,204 +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
-
-/*
- * v3.6-rc1-24-gdbf2576e37da
- *
- * All workqueues are now non-reentrant, and the bit flag is removed
- * shortly after its uses were removed.
- */
-#ifndef WQ_NON_REENTRANT
-#define WQ_NON_REENTRANT 0
-#endif
-
-/*
- * v3.18-rc2-19-gb5ae6b15bd73
- *
- * Folds d_materialise_unique into d_splice_alias. Note reversal
- * of arguments (Also note Documentation/filesystems/porting.rst)
- */
-#ifndef KC_D_MATERIALISE_UNIQUE
-#define d_materialise_unique(dentry, inode) d_splice_alias(inode, dentry)
-#endif
-
-/*
- * v4.8-rc1-29-g31051c85b5e2
- *
- * fall back to inode_change_ok() if setattr_prepare() isn't available
- */
-#ifndef KC_SETATTR_PREPARE
-#define setattr_prepare(dentry, attr) inode_change_ok(d_inode(dentry), attr)
-#endif
-
-#ifndef KC___POSIX_ACL_CREATE
-#define __posix_acl_create posix_acl_create
-#define __posix_acl_chmod posix_acl_chmod
-#endif
-
-#ifndef KC_PERCPU_COUNTER_ADD_BATCH
-#define percpu_counter_add_batch __percpu_counter_add
-#endif
-
-#ifndef KC_MEMALLOC_NOFS_SAVE
-#define memalloc_nofs_save memalloc_noio_save
-#define memalloc_nofs_restore memalloc_noio_restore
-#endif
-
-#ifdef KC_BIO_BI_OPF
-#define kc_bio_get_opf(bio)		\
-({					\
-	(bio)->bi_opf;			\
-})
-#define kc_bio_set_opf(bio, opf)	\
-do {					\
-	(bio)->bi_opf = opf;		\
-} while (0)
-#define kc_bio_set_sector(bio, sect)	\
-do {					\
-	(bio)->bi_iter.bi_sector = sect;\
-} while (0)
-#define kc_submit_bio(bio) submit_bio(bio)
-#else
-#define kc_bio_get_opf(bio)		\
-({					\
-	(bio)->bi_rw;			\
-})
-#define kc_bio_set_opf(bio, opf)	\
-do {					\
-	(bio)->bi_rw = opf;		\
-} while (0)
-#define kc_bio_set_sector(bio, sect)	\
-do {					\
-	(bio)->bi_sector = sect;	\
-} while (0)
-#define kc_submit_bio(bio)		\
-do {					\
-	submit_bio((bio)->bi_rw, bio);	\
-} while (0)
-#define bio_set_dev(bio, bdev)		\
-do {					\
-	(bio)->bi_bdev = (bdev);	\
-} while (0)
-#endif
-
-#ifdef KC_BIO_BI_STATUS
-#define KC_DECLARE_BIO_END_IO(name, bio)	name(bio)
-#define kc_bio_get_errno(bio)			({ blk_status_to_errno((bio)->bi_status); })
-#else
-#define KC_DECLARE_BIO_END_IO(name, bio)	name(bio, int _error_arg)
-#define kc_bio_get_errno(bio)			({ (int)((void)(bio), _error_arg); })
-#endif
-
-/*
- * v4.13-rc1-6-ge462ec50cb5f
- *
- * MS_* (mount) flags from <linux/mount.h> should not be used in the kernel
- * anymore from 4.x onwards. Instead, we need to use the SB_* (superblock) flags
- */
-#ifndef SB_POSIXACL
-#define SB_POSIXACL MS_POSIXACL
-#define SB_I_VERSION MS_I_VERSION
-#endif
-
-#ifndef KC_CURRENT_TIME_INODE
-struct timespec64 kc_current_time(struct inode *inode);
-#define current_time kc_current_time
-#define kc_timespec timespec
-#else
-#define kc_timespec timespec64
-#endif
-
-#ifndef KC_SHRINKER_SHRINK
-
-#define KC_DEFINE_SHRINKER(name) struct shrinker name
-#define KC_INIT_SHRINKER_FUNCS(name, countfn, scanfn) do {	\
-	__typeof__(name) _shrink = (name);			\
-	_shrink->count_objects = (countfn);			\
-	_shrink->scan_objects = (scanfn);			\
-	_shrink->seeks = DEFAULT_SEEKS;			\
-} while (0)
-
-#define KC_SHRINKER_CONTAINER_OF(ptr, type) container_of(ptr, type, shrinker)
-#define KC_REGISTER_SHRINKER(ptr) (register_shrinker(ptr))
-#define KC_UNREGISTER_SHRINKER(ptr) (unregister_shrinker(ptr))
-#define KC_SHRINKER_FN(ptr) (ptr)
-#else
-
-#include <linux/shrinker.h>
-#ifndef SHRINK_STOP
-#define SHRINK_STOP (~0UL)
-#define SHRINK_EMPTY (~0UL - 1)
-#endif
-
-int kc_shrink_wrapper_fn(struct shrinker *shrink, struct shrink_control *sc);
-struct kc_shrinker_wrapper {
-	unsigned long (*count_objects)(struct shrinker *, struct shrink_control *sc);
-	unsigned long (*scan_objects)(struct shrinker *, struct shrink_control *sc);
-	struct shrinker shrink;
-};
-
-#define KC_DEFINE_SHRINKER(name) struct kc_shrinker_wrapper name;
-#define KC_INIT_SHRINKER_FUNCS(name, countfn, scanfn) do {	\
-	struct kc_shrinker_wrapper *_wrap = (name);		\
-	_wrap->count_objects = (countfn);			\
-	_wrap->scan_objects = (scanfn);				\
-	_wrap->shrink.shrink = kc_shrink_wrapper_fn;		\
-	_wrap->shrink.seeks = DEFAULT_SEEKS;			\
-} while (0)
-#define KC_SHRINKER_CONTAINER_OF(ptr, type) container_of(container_of(ptr, struct kc_shrinker_wrapper, shrink), type, shrinker)
-#define KC_REGISTER_SHRINKER(ptr) (register_shrinker(ptr.shrink))
-#define KC_UNREGISTER_SHRINKER(ptr) (unregister_shrinker(ptr.shrink))
-#define KC_SHRINKER_FN(ptr) (ptr.shrink)
-
-#endif /* KC_SHRINKER_SHRINK */
-
-#ifdef KC_KERNEL_GETSOCKNAME_ADDRLEN
-#include <linux/net.h>
-#include <linux/inet.h>
-static inline int kc_kernel_getsockname(struct socket *sock, struct sockaddr *addr)
-{
-	int addrlen = sizeof(struct sockaddr_in);
-	int ret = kernel_getsockname(sock, addr, &addrlen);
-	if (ret == 0 && addrlen != sizeof(struct sockaddr_in))
-		return -EAFNOSUPPORT;
-	else if (ret < 0)
-		return ret;
-
-	return sizeof(struct sockaddr_in);
-}
-static inline int kc_kernel_getpeername(struct socket *sock, struct sockaddr *addr)
-{
-	int addrlen = sizeof(struct sockaddr_in);
-	int ret = kernel_getpeername(sock, addr, &addrlen);
-	if (ret == 0 && addrlen != sizeof(struct sockaddr_in))
-		return -EAFNOSUPPORT;
-	else if (ret < 0)
-		return ret;
-
-	return sizeof(struct sockaddr_in);
-}
-#else
-#define kc_kernel_getsockname(sock, addr) kernel_getsockname(sock, addr)
-#define kc_kernel_getpeername(sock, addr) kernel_getpeername(sock, addr)
-#endif
-
-#ifdef KC_SOCK_CREATE_KERN_NET
-#define kc_sock_create_kern(family, type, proto, res) sock_create_kern(&init_net, family, type, proto, res)
-#else
-#define kc_sock_create_kern sock_create_kern
-#endif
-
-#ifndef KC_GENERIC_FILE_BUFFERED_WRITE
-ssize_t kc_generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
-               unsigned long nr_segs, loff_t pos, loff_t *ppos,
-               size_t count, ssize_t written);
-#define generic_file_buffered_write kc_generic_file_buffered_write
-#endif
-
 #endif

kmod/src/lock.c

@@ -12,12 +12,12 @@
  */
 #include <linux/kernel.h>
 #include <linux/fs.h>
+#include <linux/preempt_mask.h> /* a rhel shed.h needed preempt_offset? */
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/sort.h>
 #include <linux/ctype.h>
-#include <linux/posix_acl.h>
 
 #include "super.h"
 #include "lock.h"
@@ -35,7 +35,6 @@
 #include "xattr.h"
 #include "item.h"
 #include "omap.h"
-#include "util.h"
 
 /*
  * scoutfs uses a lock service to manage item cache consistency between
@@ -77,7 +76,7 @@ struct lock_info {
 	bool unmounting;
 	struct rb_root lock_tree;
 	struct rb_root lock_range_tree;
-	KC_DEFINE_SHRINKER(shrinker);
+	struct shrinker shrinker;
 	struct list_head lru_list;
 	unsigned long long lru_nr;
 	struct workqueue_struct *workq;
@@ -130,17 +129,20 @@ static bool lock_modes_match(int granted, int requested)
  * allows deletions to be performed by unlink without having to wait for
  * remote cached inodes to be dropped.
  *
- * We kick the d_prune and iput off to async work because they can end
- * up in final iput and inode eviction item deletion which would
- * deadlock.   d_prune->dput can end up in iput on parents in different
- * locks entirely.
+ * If the cached inode was already deferring final inode deletion then
+ * we can't perform that inline in invalidation.  The locking alone
+ * deadlock, and it might also take multiple transactions to fully
+ * delete an inode with significant metadata.  We only perform the iput
+ * inline if we know that possible eviction can't perform the final
+ * deletion, otherwise we kick it off to async work.
  */
 static void invalidate_inode(struct super_block *sb, u64 ino)
 {
+	DECLARE_LOCK_INFO(sb, linfo);
 	struct scoutfs_inode_info *si;
 	struct inode *inode;
 
-	inode = scoutfs_ilookup_nowait_nonewfree(sb, ino);
+	inode = scoutfs_ilookup(sb, ino);
 	if (inode) {
 		si = SCOUTFS_I(inode);
 
@@ -150,9 +152,17 @@ static void invalidate_inode(struct super_block *sb, u64 ino)
 			scoutfs_data_wait_changed(inode);
 		}
 
-		forget_all_cached_acls(inode);
+		/* can't touch during unmount, dcache destroys w/o locks */
+		if (!linfo->unmounting)
+			d_prune_aliases(inode);
 
-		scoutfs_inode_queue_iput(inode, SI_IPUT_FLAG_PRUNE);
+		si->drop_invalidated = true;
+		if (scoutfs_lock_is_covered(sb, &si->ino_lock_cov) && inode->i_nlink > 0) {
+			iput(inode);
+		} else {
+			/* defer iput to work context so we don't evict inodes from invalidation */
+			scoutfs_inode_queue_iput(inode);
+		}
 	}
 }
 
@@ -188,6 +198,16 @@ static int lock_invalidate(struct super_block *sb, struct scoutfs_lock *lock,
 	/* have to invalidate if we're not in the only usable case */
 	if (!(prev == SCOUTFS_LOCK_WRITE && mode == SCOUTFS_LOCK_READ)) {
 retry:
+		/* invalidate inodes before removing coverage */
+		if (lock->start.sk_zone == SCOUTFS_FS_ZONE) {
+			ino = le64_to_cpu(lock->start.ski_ino);
+			last = le64_to_cpu(lock->end.ski_ino);
+			while (ino <= last) {
+				invalidate_inode(sb, ino);
+				ino++;
+			}
+		}
+
 		/* remove cov items to tell users that their cache is stale */
 		spin_lock(&lock->cov_list_lock);
 		list_for_each_entry_safe(cov, tmp, &lock->cov_list, head) {
@@ -203,16 +223,6 @@ retry:
 		}
 		spin_unlock(&lock->cov_list_lock);
 
-		/* invalidate inodes after removing coverage so drop/evict aren't covered */
-		if (lock->start.sk_zone == SCOUTFS_FS_ZONE) {
-			ino = le64_to_cpu(lock->start.ski_ino);
-			last = le64_to_cpu(lock->end.ski_ino);
-			while (ino <= last) {
-				invalidate_inode(sb, ino);
-				ino++;
-			}
-		}
-
 		scoutfs_item_invalidate(sb, &lock->start, &lock->end);
 	}
 
@@ -245,7 +255,7 @@ static void lock_free(struct lock_info *linfo, struct scoutfs_lock *lock)
 	BUG_ON(!list_empty(&lock->shrink_head));
 	BUG_ON(!list_empty(&lock->cov_list));
 
-	kfree(lock->inode_deletion_data);
+	scoutfs_omap_free_lock_data(lock->omap_data);
 	kfree(lock);
 }
 
@@ -279,9 +289,9 @@ 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);
+	spin_lock_init(&lock->omap_spinlock);
 
 	trace_scoutfs_lock_alloc(sb, lock);
 
@@ -657,9 +667,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)
 {
@@ -684,8 +692,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 */
@@ -728,8 +735,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);
@@ -820,7 +825,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;
@@ -841,15 +845,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)
@@ -1051,7 +1050,7 @@ int scoutfs_lock_inode(struct super_block *sb, enum scoutfs_lock_mode mode, int
 		goto out;
 
 	if (flags & SCOUTFS_LKF_REFRESH_INODE) {
-		ret = scoutfs_inode_refresh(inode, *lock);
+		ret = scoutfs_inode_refresh(inode, *lock, flags);
 		if (ret < 0) {
 			scoutfs_unlock(sb, *lock, mode);
 			*lock = NULL;
@@ -1346,7 +1345,7 @@ void scoutfs_lock_del_coverage(struct super_block *sb,
 bool scoutfs_lock_protected(struct scoutfs_lock *lock, struct scoutfs_key *key,
 			    enum scoutfs_lock_mode mode)
 {
-	signed char lock_mode = READ_ONCE(lock->mode);
+	signed char lock_mode = ACCESS_ONCE(lock->mode);
 
 	return lock_modes_match(lock_mode, mode) &&
 	       scoutfs_key_compare_ranges(key, key,
@@ -1401,17 +1400,6 @@ static void lock_shrink_worker(struct work_struct *work)
 	}
 }
 
-static unsigned long lock_count_objects(struct shrinker *shrink,
-					struct shrink_control *sc)
-{
-	struct lock_info *linfo = KC_SHRINKER_CONTAINER_OF(shrink, struct lock_info);
-	struct super_block *sb = linfo->sb;
-
-	scoutfs_inc_counter(sb, lock_count_objects);
-
-	return shrinker_min_t_long((u64)(linfo->lru_nr));
-}
-
 /*
  * Start the shrinking process for locks on the lru.  If a lock is on
  * the lru then it can't have any active users.  We don't want to block
@@ -1424,18 +1412,21 @@ static unsigned long lock_count_objects(struct shrinker *shrink,
  * mode which will prevent the lock from being freed when the null
  * response arrives.
  */
-static unsigned long lock_scan_objects(struct shrinker *shrink,
-				       struct shrink_control *sc)
+static int scoutfs_lock_shrink(struct shrinker *shrink,
+			       struct shrink_control *sc)
 {
-	struct lock_info *linfo = KC_SHRINKER_CONTAINER_OF(shrink, struct lock_info);
+	struct lock_info *linfo = container_of(shrink, struct lock_info,
+					       shrinker);
 	struct super_block *sb = linfo->sb;
 	struct scoutfs_lock *lock;
 	struct scoutfs_lock *tmp;
-	unsigned long freed = 0;
-	unsigned long nr = sc->nr_to_scan;
+	unsigned long nr;
 	bool added = false;
+	int ret;
 
-	scoutfs_inc_counter(sb, lock_scan_objects);
+	nr = sc->nr_to_scan;
+	if (nr == 0)
+		goto out;
 
 	spin_lock(&linfo->lock);
 
@@ -1453,7 +1444,6 @@ restart:
 		lock->request_pending = 1;
 		list_add_tail(&lock->shrink_head, &linfo->shrink_list);
 		added = true;
-		freed++;
 
 		scoutfs_inc_counter(sb, lock_shrink_attempted);
 		trace_scoutfs_lock_shrink(sb, lock);
@@ -1468,8 +1458,10 @@ restart:
 	if (added)
 		queue_work(linfo->workq, &linfo->shrink_work);
 
-	trace_scoutfs_lock_shrink_exit(sb, sc->nr_to_scan, freed);
-	return freed;
+out:
+	ret = min_t(unsigned long, linfo->lru_nr, INT_MAX);
+	trace_scoutfs_lock_shrink_exit(sb, sc->nr_to_scan, ret);
+	return ret;
 }
 
 void scoutfs_free_unused_locks(struct super_block *sb)
@@ -1480,7 +1472,7 @@ void scoutfs_free_unused_locks(struct super_block *sb)
 		.nr_to_scan = INT_MAX,
 	};
 
-	lock_scan_objects(KC_SHRINKER_FN(&linfo->shrinker), &sc);
+	linfo->shrinker.shrink(&linfo->shrinker, &sc);
 }
 
 static void lock_tseq_show(struct seq_file *m, struct scoutfs_tseq_entry *ent)
@@ -1522,38 +1514,6 @@ void scoutfs_lock_flush_invalidate(struct super_block *sb)
 		flush_work(&linfo->inv_work);
 }
 
-static u64 get_held_lock_refresh_gen(struct super_block *sb, struct scoutfs_key *start)
-{
-	DECLARE_LOCK_INFO(sb, linfo);
-	struct scoutfs_lock *lock;
-	u64 refresh_gen = 0;
-
-	/* this can be called from all manner of places */
-	if (!linfo)
-		return 0;
-
-	spin_lock(&linfo->lock);
-	lock = lock_lookup(sb, start, NULL);
-	if (lock) {
-		if (lock_mode_can_read(lock->mode))
-			refresh_gen = lock->refresh_gen;
-	}
-	spin_unlock(&linfo->lock);
-
-	return refresh_gen;
-}
-
-u64 scoutfs_lock_ino_refresh_gen(struct super_block *sb, u64 ino)
-{
-	struct scoutfs_key start;
-
-	scoutfs_key_set_zeros(&start);
-	start.sk_zone = SCOUTFS_FS_ZONE;
-	start.ski_ino = cpu_to_le64(ino & ~(u64)SCOUTFS_LOCK_INODE_GROUP_MASK);
-
-	return get_held_lock_refresh_gen(sb, &start);
-}
-
 /*
  * The caller is going to be shutting down transactions and the client.
  * We need to make sure that locking won't call either after we return.
@@ -1587,7 +1547,7 @@ void scoutfs_lock_shutdown(struct super_block *sb)
 	trace_scoutfs_lock_shutdown(sb, linfo);
 
 	/* stop the shrinker from queueing work */
-	KC_UNREGISTER_SHRINKER(&linfo->shrinker);
+	unregister_shrinker(&linfo->shrinker);
 	flush_work(&linfo->shrink_work);
 
 	/* cause current and future lock calls to return errors */
@@ -1706,9 +1666,9 @@ int scoutfs_lock_setup(struct super_block *sb)
 	spin_lock_init(&linfo->lock);
 	linfo->lock_tree = RB_ROOT;
 	linfo->lock_range_tree = RB_ROOT;
-	KC_INIT_SHRINKER_FUNCS(&linfo->shrinker, lock_count_objects,
-			       lock_scan_objects);
-	KC_REGISTER_SHRINKER(&linfo->shrinker);
+	linfo->shrinker.shrink = scoutfs_lock_shrink;
+	linfo->shrinker.seeks = DEFAULT_SEEKS;
+	register_shrinker(&linfo->shrinker);
 	INIT_LIST_HEAD(&linfo->lru_list);
 	INIT_WORK(&linfo->inv_work, lock_invalidate_worker);
 	INIT_LIST_HEAD(&linfo->inv_list);

kmod/src/lock.h

@@ -11,7 +11,7 @@
 
 #define SCOUTFS_LOCK_NR_MODES		SCOUTFS_LOCK_INVALID
 
-struct inode_deletion_lock_data;
+struct scoutfs_omap_lock;
 
 /*
  * A few fields (start, end, refresh_gen, write_seq, granted_mode)
@@ -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];
 
@@ -48,8 +47,9 @@ struct scoutfs_lock {
 	/* the forest tracks which log tree last saw bloom bit updates */
 	atomic64_t forest_bloom_nr;
 
-	/* inode deletion tracks some state per lock */
-	struct inode_deletion_lock_data *inode_deletion_data;
+	/* open ino mapping has a valid map for a held write lock */
+	spinlock_t omap_spinlock;
+	struct scoutfs_omap_lock_data *omap_data;
 };
 
 struct scoutfs_lock_coverage {
@@ -100,8 +100,6 @@ void scoutfs_lock_del_coverage(struct super_block *sb,
 bool scoutfs_lock_protected(struct scoutfs_lock *lock, struct scoutfs_key *key,
 			    enum scoutfs_lock_mode mode);
 
-u64 scoutfs_lock_ino_refresh_gen(struct super_block *sb, u64 ino);
-
 void scoutfs_free_unused_locks(struct super_block *sb);
 
 int scoutfs_lock_setup(struct super_block *sb);

kmod/src/lock_server.c

@@ -153,30 +153,30 @@ enum {
  */
 static void add_client_entry(struct server_lock_node *snode,
 			     struct list_head *list,
-			     struct client_lock_entry *c_ent)
+			     struct client_lock_entry *clent)
 {
 	WARN_ON_ONCE(!mutex_is_locked(&snode->mutex));
 
-	if (list_empty(&c_ent->head))
-		list_add_tail(&c_ent->head, list);
+	if (list_empty(&clent->head))
+		list_add_tail(&clent->head, list);
 	else
-		list_move_tail(&c_ent->head, list);
+		list_move_tail(&clent->head, list);
 
-	c_ent->on_list = list == &snode->granted ? OL_GRANTED :
+	clent->on_list = list == &snode->granted ? OL_GRANTED :
 			 list == &snode->requested ? OL_REQUESTED :
 			 OL_INVALIDATED;
 }
 
 static void free_client_entry(struct lock_server_info *inf,
 			      struct server_lock_node *snode,
-			      struct client_lock_entry *c_ent)
+			      struct client_lock_entry *clent)
 {
 	WARN_ON_ONCE(!mutex_is_locked(&snode->mutex));
 
-	if (!list_empty(&c_ent->head))
-		list_del_init(&c_ent->head);
-	scoutfs_tseq_del(&inf->tseq_tree, &c_ent->tseq_entry);
-	kfree(c_ent);
+	if (!list_empty(&clent->head))
+		list_del_init(&clent->head);
+	scoutfs_tseq_del(&inf->tseq_tree, &clent->tseq_entry);
+	kfree(clent);
 }
 
 static bool invalid_mode(u8 mode)
@@ -339,13 +339,13 @@ static struct client_lock_entry *find_entry(struct server_lock_node *snode,
 					    struct list_head *list,
 					    u64 rid)
 {
-	struct client_lock_entry *c_ent;
+	struct client_lock_entry *clent;
 
 	WARN_ON_ONCE(!mutex_is_locked(&snode->mutex));
 
-	list_for_each_entry(c_ent, list, head) {
-		if (c_ent->rid == rid)
-			return c_ent;
+	list_for_each_entry(clent, list, head) {
+		if (clent->rid == rid)
+			return clent;
 	}
 
 	return NULL;
@@ -364,7 +364,7 @@ int scoutfs_lock_server_request(struct super_block *sb, u64 rid,
 				u64 net_id, struct scoutfs_net_lock *nl)
 {
 	DECLARE_LOCK_SERVER_INFO(sb, inf);
-	struct client_lock_entry *c_ent;
+	struct client_lock_entry *clent;
 	struct server_lock_node *snode;
 	int ret;
 
@@ -376,29 +376,29 @@ int scoutfs_lock_server_request(struct super_block *sb, u64 rid,
 		goto out;
 	}
 
-	c_ent = kzalloc(sizeof(struct client_lock_entry), GFP_NOFS);
-	if (!c_ent) {
+	clent = kzalloc(sizeof(struct client_lock_entry), GFP_NOFS);
+	if (!clent) {
 		ret = -ENOMEM;
 		goto out;
 	}
 
-	INIT_LIST_HEAD(&c_ent->head);
-	c_ent->rid = rid;
-	c_ent->net_id = net_id;
-	c_ent->mode = nl->new_mode;
+	INIT_LIST_HEAD(&clent->head);
+	clent->rid = rid;
+	clent->net_id = net_id;
+	clent->mode = nl->new_mode;
 
 	snode = alloc_server_lock(inf, &nl->key);
 	if (snode == NULL) {
-		kfree(c_ent);
+		kfree(clent);
 		ret = -ENOMEM;
 		goto out;
 	}
 
 	snode->stats[SLT_REQUEST]++;
 
-	c_ent->snode = snode;
-	add_client_entry(snode, &snode->requested, c_ent);
-	scoutfs_tseq_add(&inf->tseq_tree, &c_ent->tseq_entry);
+	clent->snode = snode;
+	add_client_entry(snode, &snode->requested, clent);
+	scoutfs_tseq_add(&inf->tseq_tree, &clent->tseq_entry);
 
 	ret = process_waiting_requests(sb, snode);
 out:
@@ -417,7 +417,7 @@ int scoutfs_lock_server_response(struct super_block *sb, u64 rid,
 				 struct scoutfs_net_lock *nl)
 {
 	DECLARE_LOCK_SERVER_INFO(sb, inf);
-	struct client_lock_entry *c_ent;
+	struct client_lock_entry *clent;
 	struct server_lock_node *snode;
 	int ret;
 
@@ -438,18 +438,18 @@ int scoutfs_lock_server_response(struct super_block *sb, u64 rid,
 
 	snode->stats[SLT_RESPONSE]++;
 
-	c_ent = find_entry(snode, &snode->invalidated, rid);
-	if (!c_ent) {
+	clent = find_entry(snode, &snode->invalidated, rid);
+	if (!clent) {
 		put_server_lock(inf, snode);
 		ret = -EINVAL;
 		goto out;
 	}
 
 	if (nl->new_mode == SCOUTFS_LOCK_NULL) {
-		free_client_entry(inf, snode, c_ent);
+		free_client_entry(inf, snode, clent);
 	} else {
-		c_ent->mode = nl->new_mode;
-		add_client_entry(snode, &snode->granted, c_ent);
+		clent->mode = nl->new_mode;
+		add_client_entry(snode, &snode->granted, clent);
 	}
 
 	ret = process_waiting_requests(sb, snode);
@@ -632,7 +632,7 @@ int scoutfs_lock_server_recover_response(struct super_block *sb, u64 rid,
 {
 	DECLARE_LOCK_SERVER_INFO(sb, inf);
 	struct client_lock_entry *existing;
-	struct client_lock_entry *c_ent;
+	struct client_lock_entry *clent;
 	struct server_lock_node *snode;
 	struct scoutfs_key key;
 	int ret = 0;
@@ -652,35 +652,35 @@ int scoutfs_lock_server_recover_response(struct super_block *sb, u64 rid,
 	}
 
 	for (i = 0; i < le16_to_cpu(nlr->nr); i++) {
-		c_ent = kzalloc(sizeof(struct client_lock_entry), GFP_NOFS);
-		if (!c_ent) {
+		clent = kzalloc(sizeof(struct client_lock_entry), GFP_NOFS);
+		if (!clent) {
 			ret = -ENOMEM;
 			goto out;
 		}
 
-		INIT_LIST_HEAD(&c_ent->head);
-		c_ent->rid = rid;
-		c_ent->net_id = 0;
-		c_ent->mode = nlr->locks[i].new_mode;
+		INIT_LIST_HEAD(&clent->head);
+		clent->rid = rid;
+		clent->net_id = 0;
+		clent->mode = nlr->locks[i].new_mode;
 
 		snode = alloc_server_lock(inf, &nlr->locks[i].key);
 		if (snode == NULL) {
-			kfree(c_ent);
+			kfree(clent);
 			ret = -ENOMEM;
 			goto out;
 		}
 
 		existing = find_entry(snode, &snode->granted, rid);
 		if (existing) {
-			kfree(c_ent);
+			kfree(clent);
 			put_server_lock(inf, snode);
 			ret = -EEXIST;
 			goto out;
 		}
 
-		c_ent->snode = snode;
-		add_client_entry(snode, &snode->granted, c_ent);
-		scoutfs_tseq_add(&inf->tseq_tree, &c_ent->tseq_entry);
+		clent->snode = snode;
+		add_client_entry(snode, &snode->granted, clent);
+		scoutfs_tseq_add(&inf->tseq_tree, &clent->tseq_entry);
 
 		put_server_lock(inf, snode);
 
@@ -707,7 +707,7 @@ out:
 int scoutfs_lock_server_farewell(struct super_block *sb, u64 rid)
 {
 	DECLARE_LOCK_SERVER_INFO(sb, inf);
-	struct client_lock_entry *c_ent;
+	struct client_lock_entry *clent;
 	struct client_lock_entry *tmp;
 	struct server_lock_node *snode;
 	struct scoutfs_key key;
@@ -724,9 +724,9 @@ int scoutfs_lock_server_farewell(struct super_block *sb, u64 rid)
 			    (list == &snode->requested) ? &snode->invalidated :
 			    NULL) {
 
-			list_for_each_entry_safe(c_ent, tmp, list, head) {
-				if (c_ent->rid == rid) {
-					free_client_entry(inf, snode, c_ent);
+			list_for_each_entry_safe(clent, tmp, list, head) {
+				if (clent->rid == rid) {
+					free_client_entry(inf, snode, clent);
 					freed = true;
 				}
 			}
@@ -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;
@@ -787,15 +787,15 @@ static char *lock_on_list_string(u8 on_list)
 static void lock_server_tseq_show(struct seq_file *m,
 				  struct scoutfs_tseq_entry *ent)
 {
-	struct client_lock_entry *c_ent = container_of(ent,
+	struct client_lock_entry *clent = container_of(ent,
 						       struct client_lock_entry,
 						       tseq_entry);
-	struct server_lock_node *snode = c_ent->snode;
+	struct server_lock_node *snode = clent->snode;
 
 	seq_printf(m, SK_FMT" %s %s rid %016llx net_id %llu\n",
-		   SK_ARG(&snode->key), lock_mode_string(c_ent->mode),
-		   lock_on_list_string(c_ent->on_list), c_ent->rid,
-		   c_ent->net_id);
+		   SK_ARG(&snode->key), lock_mode_string(clent->mode),
+		   lock_on_list_string(clent->on_list), clent->rid,
+		   clent->net_id);
 }
 
 static void stats_tseq_show(struct seq_file *m, struct scoutfs_tseq_entry *ent)
@@ -857,7 +857,7 @@ void scoutfs_lock_server_destroy(struct super_block *sb)
 	DECLARE_LOCK_SERVER_INFO(sb, inf);
 	struct server_lock_node *snode;
 	struct server_lock_node *stmp;
-	struct client_lock_entry *c_ent;
+	struct client_lock_entry *clent;
 	struct client_lock_entry *ctmp;
 	LIST_HEAD(list);
 
@@ -873,8 +873,8 @@ void scoutfs_lock_server_destroy(struct super_block *sb)
 			list_splice_init(&snode->invalidated, &list);
 
 			mutex_lock(&snode->mutex);
-			list_for_each_entry_safe(c_ent, ctmp, &list, head) {
-				free_client_entry(inf, snode, c_ent);
+			list_for_each_entry_safe(clent, ctmp, &list, head) {
+				free_client_entry(inf, snode, clent);
 			}
 			mutex_unlock(&snode->mutex);
 

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;
 		}
 	}
@@ -549,16 +548,12 @@ static int recvmsg_full(struct socket *sock, void *buf, unsigned len)
 
 	while (len) {
 		memset(&msg, 0, sizeof(msg));
+		msg.msg_iov = (struct iovec *)&kv;
+		msg.msg_iovlen = 1;
 		msg.msg_flags = MSG_NOSIGNAL;
 		kv.iov_base = buf;
 		kv.iov_len = len;
 
-#ifndef KC_MSGHDR_STRUCT_IOV_ITER
-		msg.msg_iov = (struct iovec *)&kv;
-		msg.msg_iovlen = 1;
-#else
-		iov_iter_init(&msg.msg_iter, READ, (struct iovec *)&kv, len, 1);
-#endif
 		ret = kernel_recvmsg(sock, &msg, &kv, 1, len, msg.msg_flags);
 		if (ret <= 0)
 			return -ECONNABORTED;
@@ -711,16 +706,12 @@ static int sendmsg_full(struct socket *sock, void *buf, unsigned len)
 
 	while (len) {
 		memset(&msg, 0, sizeof(msg));
+		msg.msg_iov = (struct iovec *)&kv;
+		msg.msg_iovlen = 1;
 		msg.msg_flags = MSG_NOSIGNAL;
 		kv.iov_base = buf;
 		kv.iov_len = len;
 
-#ifndef KC_MSGHDR_STRUCT_IOV_ITER
-		msg.msg_iov = (struct iovec *)&kv;
-		msg.msg_iovlen = 1;
-#else
-		iov_iter_init(&msg.msg_iter, WRITE, (struct iovec *)&kv, len, 1);
-#endif
 		ret = kernel_sendmsg(sock, &msg, &kv, 1, len);
 		if (ret <= 0)
 			return -ECONNABORTED;
@@ -905,6 +896,7 @@ static int sock_opts_and_names(struct scoutfs_net_connection *conn,
 			       struct socket *sock)
 {
 	struct timeval tv;
+	int addrlen;
 	int optval;
 	int ret;
 
@@ -954,18 +946,23 @@ static int sock_opts_and_names(struct scoutfs_net_connection *conn,
 	if (ret)
 		goto out;
 
-	ret = kc_kernel_getsockname(sock, (struct sockaddr *)&conn->sockname);
-	if (ret < 0)
+	addrlen = sizeof(struct sockaddr_in);
+	ret = kernel_getsockname(sock, (struct sockaddr *)&conn->sockname,
+				 &addrlen);
+	if (ret == 0 && addrlen != sizeof(struct sockaddr_in))
+		ret = -EAFNOSUPPORT;
+	if (ret)
 		goto out;
 
-	ret = kc_kernel_getpeername(sock, (struct sockaddr *)&conn->peername);
-	if (ret < 0)
+	addrlen = sizeof(struct sockaddr_in);
+	ret = kernel_getpeername(sock, (struct sockaddr *)&conn->peername,
+				 &addrlen);
+	if (ret == 0 && addrlen != sizeof(struct sockaddr_in))
+		ret = -EAFNOSUPPORT;
+	if (ret)
 		goto out;
 
-	ret = 0;
-
 	conn->last_peername = conn->peername;
-
 out:
 	return ret;
 }
@@ -994,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,
@@ -1054,12 +1049,10 @@ static void scoutfs_net_connect_worker(struct work_struct *work)
 
 	trace_scoutfs_net_connect_work_enter(sb, 0, 0);
 
-	ret = kc_sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
+	ret = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
 	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;
@@ -1299,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);
@@ -1348,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",
@@ -1455,12 +1446,10 @@ int scoutfs_net_bind(struct super_block *sb,
 	if (WARN_ON_ONCE(conn->sock))
 		return -EINVAL;
 
-	ret = kc_sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
+	ret = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
 	if (ret)
 		goto out;
 
-	sock->sk->sk_allocation = GFP_NOFS;
-
 	optval = 1;
 	ret = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
 				(char *)&optval, sizeof(optval));
@@ -1473,18 +1462,20 @@ int scoutfs_net_bind(struct super_block *sb,
 		goto out;
 
 	ret = kernel_listen(sock, 255);
-	if (ret < 0)
+	if (ret)
 		goto out;
 
-	ret = kc_kernel_getsockname(sock, (struct sockaddr *)&conn->sockname);
-	if (ret < 0)
+	addrlen = sizeof(struct sockaddr_in);
+	ret = kernel_getsockname(sock, (struct sockaddr *)&conn->sockname,
+				 &addrlen);
+	if (ret == 0 && addrlen != sizeof(struct sockaddr_in))
+		ret = -EAFNOSUPPORT;
+	if (ret)
 		goto out;
 
-	ret = 0;
-
 	conn->sock = sock;
 	*sin = conn->sockname;
-
+	ret = 0;
 out:
 	if (ret < 0 && sock)
 		sock_release(sock);
@@ -1781,6 +1772,23 @@ int scoutfs_net_response_node(struct super_block *sb,
 			   NULL, NULL, NULL);
 }
 
+/*
+ * The response function that was submitted with the request is not
+ * called if the request is canceled here.
+ */
+void scoutfs_net_cancel_request(struct super_block *sb,
+				struct scoutfs_net_connection *conn,
+				u8 cmd, u64 id)
+{
+	struct message_send *msend;
+
+	spin_lock(&conn->lock);
+	msend = find_request(conn, cmd, id);
+	if (msend)
+		complete_send(conn, msend);
+	spin_unlock(&conn->lock);
+}
+
 struct sync_request_completion {
 	struct completion comp;
 	void *resp;

kmod/src/net.h

@@ -134,6 +134,9 @@ int scoutfs_net_submit_request_node(struct super_block *sb,
 				    u64 rid, u8 cmd, void *arg, u16 arg_len,
 				    scoutfs_net_response_t resp_func,
 				    void *resp_data, u64 *id_ret);
+void scoutfs_net_cancel_request(struct super_block *sb,
+				struct scoutfs_net_connection *conn,
+				u8 cmd, u64 id);
 int scoutfs_net_sync_request(struct super_block *sb,
 			     struct scoutfs_net_connection *conn,
 			     u8 cmd, void *arg, unsigned arg_len,

kmod/src/omap.c

@@ -30,22 +30,27 @@
 /*
  * As a client removes an inode from its cache with an nlink of 0 it
  * needs to decide if it is the last client using the inode and should
- * fully delete all the inode's items.  It needs to know if other mounts
- * still have the inode in use.
+ * fully delete all its items.  It needs to know if other mounts still
+ * have the inode in use.
  *
- * We need a way to communicate between mounts that an inode is in use.
+ * We need a way to communicate between mounts that an inode is open.
  * We don't want to pay the synchronous per-file locking round trip
  * costs associated with per-inode open locks that you'd typically see
- * in systems to solve this problem.  The first prototypes of this
- * tracked open file handles so this was coined the open map, though it
- * now tracks cached inodes.
+ * in systems to solve this problem.
  *
- * Clients maintain bitmaps that cover groups of inodes.  As inodes
- * enter the cache their bit is set and as the inode is evicted the bit
- * is cleared.  As deletion is attempted, either by scanning orphans or
- * evicting an inode with an nlink of 0, messages are sent around the
- * cluster to get the current bitmaps for that inode's group from all
- * active mounts.  If the inode's bit is clear then it can be deleted.
+ * Instead clients maintain open bitmaps that cover groups of inodes.
+ * As inodes enter the cache their bit is set, and as the inode is
+ * evicted the bit is cleared.  As an inode is evicted messages are sent
+ * around the cluster to get the current bitmaps for that inode's group
+ * from all active mounts.  If the inode's bit is clear then it can be
+ * deleted.
+ *
+ * We associate the open bitmaps with our cluster locking of inode
+ * groups to cache these open bitmaps.  As long as we have the lock then
+ * nlink can't be changed on any remote mounts.  Specifically, it can't
+ * increase from 0 so any clear bits can gain references on remote
+ * mounts.  As long as we have the lock, all clear bits in the group for
+ * inodes with 0 nlink can be deleted.
  *
  * This layer maintains a list of client rids to send messages to.  The
  * server calls us as clients enter and leave the cluster.    We can't
@@ -80,12 +85,14 @@ struct omap_info {
 	struct omap_info *name = SCOUTFS_SB(sb)->omap_info
 
 /*
- * The presence of an inode in the inode sets its bit in the lock
- * group's bitmap.
+ * The presence of an inode in the inode cache increases the count of
+ * its inode number's position within its lock group.  These structs
+ * track the counts for all the inodes in a lock group and maintain a
+ * bitmap whose bits are set for each non-zero count.
  *
  * We don't want to add additional global synchronization of inode cache
  * maintenance so these are tracked in an rcu hash table.  Once their
- * total reaches zero they're removed from the hash and queued for
+ * total count reaches zero they're removed from the hash and queued for
  * freeing and readers should ignore them.
  */
 struct omap_group {
@@ -95,6 +102,7 @@ struct omap_group {
 	u64 nr;
 	spinlock_t lock;
 	unsigned int total;
+	unsigned int *counts;
 	__le64 bits[SCOUTFS_OPEN_INO_MAP_LE64S];
 };
 
@@ -103,7 +111,8 @@ do {											\
 	__typeof__(group) _grp = (group);						\
 	__typeof__(bit_nr) _nr = (bit_nr);						\
 											\
-	trace_scoutfs_omap_group_##which(sb, _grp, _grp->nr, _grp->total, _nr);		\
+	trace_scoutfs_omap_group_##which(sb, _grp, _grp->nr, _grp->total, _nr,		\
+				        _nr < 0 ? -1 : _grp->counts[_nr]);		\
 } while (0)
 
 /*
@@ -125,6 +134,18 @@ struct omap_request {
 	struct scoutfs_open_ino_map map;
 };
 
+/*
+ * In each inode group cluster lock we store data to track the open ino
+ * map which tracks all the inodes that the cluster lock covers.  When
+ * the seq shows that the map is stale we send a request to update it.
+ */
+struct scoutfs_omap_lock_data {
+	u64 seq;
+	bool req_in_flight;
+	wait_queue_head_t waitq;
+	struct scoutfs_open_ino_map map;
+};
+
 static inline void init_rid_list(struct omap_rid_list *list)
 {
 	INIT_LIST_HEAD(&list->head);
@@ -157,15 +178,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;
@@ -220,7 +232,7 @@ static void free_rids(struct omap_rid_list *list)
 	}
 }
 
-void scoutfs_omap_calc_group_nrs(u64 ino, u64 *group_nr, int *bit_nr)
+static void calc_group_nrs(u64 ino, u64 *group_nr, int *bit_nr)
 {
 	*group_nr = ino >> SCOUTFS_OPEN_INO_MAP_SHIFT;
 	*bit_nr = ino & SCOUTFS_OPEN_INO_MAP_MASK;
@@ -230,13 +242,21 @@ static struct omap_group *alloc_group(struct super_block *sb, u64 group_nr)
 {
 	struct omap_group *group;
 
+	BUILD_BUG_ON((sizeof(group->counts[0]) * SCOUTFS_OPEN_INO_MAP_BITS) > PAGE_SIZE);
+
 	group = kzalloc(sizeof(struct omap_group), GFP_NOFS);
 	if (group) {
 		group->sb = sb;
 		group->nr = group_nr;
 		spin_lock_init(&group->lock);
 
-		trace_group(sb, alloc, group, -1);
+		group->counts = (void *)get_zeroed_page(GFP_NOFS);
+		if (!group->counts) {
+			kfree(group);
+			group = NULL;
+		} else {
+			trace_group(sb, alloc, group, -1);
+		}
 	}
 
 	return group;
@@ -245,6 +265,7 @@ static struct omap_group *alloc_group(struct super_block *sb, u64 group_nr)
 static void free_group(struct super_block *sb, struct omap_group *group)
 {
 	trace_group(sb, free, group, -1);
+	free_page((unsigned long)group->counts);
 	kfree(group);
 }
 
@@ -262,16 +283,13 @@ static const struct rhashtable_params group_ht_params = {
 };
 
 /*
- * Track an cached inode in its group.  Our set can be racing with a
- * final clear that removes the group from the hash, sets total to
+ * Track an cached inode in its group.  Our increment can be racing with
+ * a final decrement that removes the group from the hash, sets total to
  * UINT_MAX, and calls rcu free.  We can retry until the dead group is
  * no longer visible in the hash table and we can insert a new allocated
  * group.
- *
- * The caller must ensure that the bit is clear, -EEXIST will be
- * returned otherwise.
  */
-int scoutfs_omap_set(struct super_block *sb, u64 ino)
+int scoutfs_omap_inc(struct super_block *sb, u64 ino)
 {
 	DECLARE_OMAP_INFO(sb, ominf);
 	struct omap_group *group;
@@ -280,7 +298,7 @@ int scoutfs_omap_set(struct super_block *sb, u64 ino)
 	bool found;
 	int ret = 0;
 
-	scoutfs_omap_calc_group_nrs(ino, &group_nr, &bit_nr);
+	calc_group_nrs(ino, &group_nr, &bit_nr);
 
 retry:
 	found = false;
@@ -290,10 +308,10 @@ retry:
 		spin_lock(&group->lock);
 		if (group->total < UINT_MAX) {
 			found = true;
-			if (WARN_ON_ONCE(test_and_set_bit_le(bit_nr, group->bits)))
-				ret = -EEXIST;
-			else
+			if (group->counts[bit_nr]++ == 0) {
+				set_bit_le(bit_nr, group->bits);
 				group->total++;
+			}
 		}
 		trace_group(sb, inc, group, bit_nr);
 		spin_unlock(&group->lock);
@@ -324,50 +342,29 @@ retry:
 	return ret;
 }
 
-bool scoutfs_omap_test(struct super_block *sb, u64 ino)
-{
-	DECLARE_OMAP_INFO(sb, ominf);
-	struct omap_group *group;
-	bool ret = false;
-	u64 group_nr;
-	int bit_nr;
-
-	scoutfs_omap_calc_group_nrs(ino, &group_nr, &bit_nr);
-
-	rcu_read_lock();
-	group = rhashtable_lookup(&ominf->group_ht, &group_nr, group_ht_params);
-	if (group) {
-		spin_lock(&group->lock);
-		ret = !!test_bit_le(bit_nr, group->bits);
-		spin_unlock(&group->lock);
-	}
-	rcu_read_unlock();
-
-	return ret;
-}
-
 /*
- * Clear a previously set ino bit.  Trying to clear a bit that's already
- * clear implies imbalanced set/clear or bugs freeing groups.  We only
- * free groups here as the last clear drops the group's total to 0.
+ * Decrement a previously incremented ino count.  Not finding a count
+ * implies imbalanced inc/dec or bugs freeing groups.  We only free
+ * groups here as the last dec drops the group's total count to 0.
  */
-void scoutfs_omap_clear(struct super_block *sb, u64 ino)
+void scoutfs_omap_dec(struct super_block *sb, u64 ino)
 {
 	DECLARE_OMAP_INFO(sb, ominf);
 	struct omap_group *group;
 	u64 group_nr;
 	int bit_nr;
 
-	scoutfs_omap_calc_group_nrs(ino, &group_nr, &bit_nr);
+	calc_group_nrs(ino, &group_nr, &bit_nr);
 
 	rcu_read_lock();
 	group = rhashtable_lookup(&ominf->group_ht, &group_nr, group_ht_params);
 	if (group) {
 		spin_lock(&group->lock);
-		WARN_ON_ONCE(!test_bit_le(bit_nr, group->bits));
+		WARN_ON_ONCE(group->counts[bit_nr] == 0);
 		WARN_ON_ONCE(group->total == 0);
 		WARN_ON_ONCE(group->total == UINT_MAX);
-		if (test_and_clear_bit_le(bit_nr, group->bits)) {
+		if (--group->counts[bit_nr] == 0) {
+			clear_bit_le(bit_nr, group->bits);
 			if (--group->total == 0) {
 				group->total = UINT_MAX;
 				rhashtable_remove_fast(&ominf->group_ht, &group->ht_head,
@@ -667,7 +664,8 @@ int scoutfs_omap_server_handle_request(struct super_block *sb, u64 rid, u64 id,
 
 /*
  * The client is receiving a request from the server for its map for the
- * given group.  Look up the group and copy the bits to the map.
+ * given group.  Look up the group and copy the bits to the map for
+ * non-zero open counts.
  *
  * The mount originating the request for this bitmap has the inode group
  * write locked.  We can't be adding links to any inodes in the group
@@ -813,13 +811,182 @@ 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();
 }
 
+static bool omap_req_in_flight(struct scoutfs_lock *lock, struct scoutfs_omap_lock_data *ldata)
+{
+	bool in_flight;
+
+	spin_lock(&lock->omap_spinlock);
+	in_flight = ldata->req_in_flight;
+	spin_unlock(&lock->omap_spinlock);
+
+	return in_flight;
+}
+
+/*
+ * Make sure the map covered by the cluster lock is current.  The caller
+ * holds the cluster lock so once we store lock_data on the cluster lock
+ * it won't be freed and the write_seq in the cluster lock won't change.
+ *
+ * The omap_spinlock protects the omap_data in the cluster lock.  We
+ * have to drop it if we have to block to allocate lock_data, send a
+ * request for a new map, or wait for a request in flight to finish.
+ */
+static int get_current_lock_data(struct super_block *sb, struct scoutfs_lock *lock,
+				 struct scoutfs_omap_lock_data **ldata_ret, u64 group_nr)
+{
+	struct scoutfs_omap_lock_data *ldata;
+	bool send_req;
+	int ret = 0;
+
+	spin_lock(&lock->omap_spinlock);
+
+	ldata = lock->omap_data;
+	if (ldata == NULL) {
+		spin_unlock(&lock->omap_spinlock);
+		ldata = kzalloc(sizeof(struct scoutfs_omap_lock_data), GFP_NOFS);
+		spin_lock(&lock->omap_spinlock);
+
+		if (!ldata) {
+			ret = -ENOMEM;
+			goto out;
+		}
+
+		if (lock->omap_data == NULL) {
+			ldata->seq = lock->write_seq - 1; /* ensure refresh */
+			init_waitqueue_head(&ldata->waitq);
+
+			lock->omap_data = ldata;
+		} else {
+			kfree(ldata);
+			ldata = lock->omap_data;
+		}
+	}
+
+	while (ldata->seq != lock->write_seq) {
+		/* only one waiter sends a request at a time */
+		if (!ldata->req_in_flight) {
+			ldata->req_in_flight = true;
+			send_req = true;
+		} else {
+			send_req = false;
+		}
+
+		spin_unlock(&lock->omap_spinlock);
+		if (send_req)
+			ret = scoutfs_client_open_ino_map(sb, group_nr, &ldata->map);
+		else
+			wait_event(ldata->waitq, !omap_req_in_flight(lock, ldata));
+		spin_lock(&lock->omap_spinlock);
+
+		/* only sender can return error, other waiters retry */
+		if (send_req) {
+			ldata->req_in_flight = false;
+			if (ret == 0)
+				ldata->seq = lock->write_seq;
+			wake_up(&ldata->waitq);
+			if (ret < 0)
+				goto out;
+		}
+	}
+
+out:
+	spin_unlock(&lock->omap_spinlock);
+
+	if (ret == 0)
+		*ldata_ret = ldata;
+	else
+		*ldata_ret = NULL;
+
+	return ret;
+}
+
+/*
+ * Return 1 and give the caller their locks when they should delete the
+ * inode items.  It's safe to delete the inode items when it is no
+ * longer reachable and nothing is referencing it.
+ *
+ * The inode is unreachable when nlink hits zero.  Cluster locks protect
+ * modification and testing of nlink.  We use the ino_lock_cov covrage
+ * to short circuit the common case of having a locked inode that hasn't
+ * been deleted.  If it isn't locked, we have to acquire the lock to
+ * refresh the inode to see its current nlink. 
+ *
+ * Then we use an open inode bitmap that covers all the inodes in the
+ * lock group to determine if the inode is present in any other mount's
+ * caches.  We refresh it by asking the server for all clients' maps and
+ * then store it in the lock.  As long as we hold the lock nothing can
+ * increase nlink from zero and let people get a reference to the inode.
+ */
+int scoutfs_omap_should_delete(struct super_block *sb, struct inode *inode,
+			       struct scoutfs_lock **lock_ret, struct scoutfs_lock **orph_lock_ret)
+{
+	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
+	struct scoutfs_lock *orph_lock = NULL;
+	struct scoutfs_lock *lock = NULL;
+	const u64 ino = scoutfs_ino(inode);
+	struct scoutfs_omap_lock_data *ldata;
+	u64 group_nr;
+	int bit_nr;
+	int ret;
+	int err;
+
+	/* lock group and omap constants are defined independently */
+	BUILD_BUG_ON(SCOUTFS_OPEN_INO_MAP_BITS != SCOUTFS_LOCK_INODE_GROUP_NR);
+
+	if (scoutfs_lock_is_covered(sb, &si->ino_lock_cov) && inode->i_nlink > 0) {
+		ret = 0;
+		goto out;
+	}
+
+	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE, SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
+	if (ret < 0)
+		goto out;
+
+	if (inode->i_nlink > 0) {
+		ret = 0;
+		goto out;
+	}
+
+	calc_group_nrs(ino, &group_nr, &bit_nr);
+
+	/* only one request to refresh the map at a time */
+	ret = get_current_lock_data(sb, lock, &ldata, group_nr);
+	if (ret < 0)
+		goto out;
+
+	/* can delete caller's zero nlink inode if it's not cached in other mounts */
+	ret = !test_bit_le(bit_nr, ldata->map.bits);
+out:
+	trace_scoutfs_omap_should_delete(sb, ino, inode->i_nlink, ret);
+
+	if (ret > 0) {
+		err = scoutfs_lock_orphan(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, ino, &orph_lock);
+		if (err < 0)
+			ret = err;
+	}
+
+	if (ret <= 0) {
+		scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
+		lock = NULL;
+	}
+
+	*lock_ret = lock;
+	*orph_lock_ret = orph_lock;
+	return ret;
+}
+
+void scoutfs_omap_free_lock_data(struct scoutfs_omap_lock_data *ldata)
+{
+	if (ldata) {
+		WARN_ON_ONCE(ldata->req_in_flight);
+		WARN_ON_ONCE(waitqueue_active(&ldata->waitq));
+		kfree(ldata);
+	}
+}
+
 int scoutfs_omap_setup(struct super_block *sb)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
@@ -877,10 +1044,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/omap.h

@@ -1,12 +1,13 @@
 #ifndef _SCOUTFS_OMAP_H_
 #define _SCOUTFS_OMAP_H_
 
-int scoutfs_omap_set(struct super_block *sb, u64 ino);
-bool scoutfs_omap_test(struct super_block *sb, u64 ino);
-void scoutfs_omap_clear(struct super_block *sb, u64 ino);
+int scoutfs_omap_inc(struct super_block *sb, u64 ino);
+void scoutfs_omap_dec(struct super_block *sb, u64 ino);
+int scoutfs_omap_should_delete(struct super_block *sb, struct inode *inode,
+			       struct scoutfs_lock **lock_ret, struct scoutfs_lock **orph_lock_ret);
+void scoutfs_omap_free_lock_data(struct scoutfs_omap_lock_data *ldata);
 int scoutfs_omap_client_handle_request(struct super_block *sb, u64 id,
 				       struct scoutfs_open_ino_map_args *args);
-void scoutfs_omap_calc_group_nrs(u64 ino, u64 *group_nr, int *bit_nr);
 
 int scoutfs_omap_add_rid(struct super_block *sb, u64 rid);
 int scoutfs_omap_remove_rid(struct super_block *sb, u64 rid);

kmod/src/options.c

@@ -26,41 +26,22 @@
 #include "msg.h"
 #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_heartbeat_timeout_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_heartbeat_timeout_ms, "quorum_heartbeat_timeout_ms=%s"},
 	{Opt_quorum_slot_nr, "quorum_slot_nr=%s"},
+	{Opt_metadev_path, "metadev_path=%s"},
 	{Opt_err, NULL}
 };
 
-struct options_info {
-	seqlock_t seqlock;
-	struct scoutfs_mount_options opts;
-	struct scoutfs_sysfs_attrs sysfs_attrs;
+struct options_sb_info {
+	struct dentry *debugfs_dir;
 };
 
-#define DECLARE_OPTIONS_INFO(sb, name) \
-	struct options_info *name = SCOUTFS_SB(sb)->options_info
+u32 scoutfs_option_u32(struct super_block *sb, int token)
+{
+	WARN_ON_ONCE(1);
+	return 0;
+}
 
 static int parse_bdev_path(struct super_block *sb, substring_t *substr,
 			      char **bdev_path_ret)
@@ -108,157 +89,58 @@ out:
 	return ret;
 }
 
-static void free_options(struct scoutfs_mount_options *opts)
-{
-	kfree(opts->metadev_path);
-}
-
-#define MIN_ORPHAN_SCAN_DELAY_MS	100UL
-#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->orphan_scan_delay_ms = -1;
-	opts->quorum_heartbeat_timeout_ms = SCOUTFS_QUORUM_DEF_HB_TIMEO_MS;
-	opts->quorum_slot_nr = -1;
-}
-
-static int verify_quorum_heartbeat_timeout_ms(struct super_block *sb, int ret, u64 val)
-{
-	if (ret < 0) {
-		scoutfs_err(sb, "failed to parse quorum_heartbeat_timeout_ms value");
-		return -EINVAL;
-	}
-	if (val < SCOUTFS_QUORUM_MIN_HB_TIMEO_MS || val > SCOUTFS_QUORUM_MAX_HB_TIMEO_MS) {
-		scoutfs_err(sb, "invalid quorum_heartbeat_timeout_ms value %llu, must be between %lu and %lu",
-			    val, SCOUTFS_QUORUM_MIN_HB_TIMEO_MS, SCOUTFS_QUORUM_MAX_HB_TIMEO_MS);
-		return -EINVAL;
-	}
-
-	return 0;
-}
-
-/*
- * Parse the option string into our options struct.   This can allocate
- * memory in the struct.  The caller is responsible for always calling
- * free_options() when the struct is destroyed, including when we return
- * an error.
- */
-static int parse_options(struct super_block *sb, char *options, struct scoutfs_mount_options *opts)
+int scoutfs_parse_options(struct super_block *sb, char *options,
+			  struct mount_options *parsed)
 {
 	substring_t args[MAX_OPT_ARGS];
-	u64 nr64;
 	int nr;
 	int token;
 	char *p;
 	int ret;
 
+	/* Set defaults */
+	memset(parsed, 0, sizeof(*parsed));
+	parsed->quorum_slot_nr = -1;
+
 	while ((p = strsep(&options, ",")) != NULL) {
 		if (!*p)
 			continue;
 
 		token = match_token(p, tokens, args);
 		switch (token) {
-
-		case Opt_acl:
-			sb->s_flags |= SB_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 &= ~SB_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.");
-				return -EINVAL;
-			}
-
-			ret = match_int(args, &nr);
-			if (ret < 0 ||
-			    nr < MIN_ORPHAN_SCAN_DELAY_MS || nr > MAX_ORPHAN_SCAN_DELAY_MS) {
-				scoutfs_err(sb, "invalid orphan_scan_delay_ms option, must be between %lu and %lu",
-					    MIN_ORPHAN_SCAN_DELAY_MS, MAX_ORPHAN_SCAN_DELAY_MS);
-				if (ret == 0)
-					ret = -EINVAL;
-				return ret;
-			}
-			opts->orphan_scan_delay_ms = nr;
-			break;
-
-		case Opt_quorum_heartbeat_timeout_ms:
-			ret = match_u64(args, &nr64);
-			ret = verify_quorum_heartbeat_timeout_ms(sb, ret, nr64);
-			if (ret < 0)
-				return ret;
-			opts->quorum_heartbeat_timeout_ms = nr64;
-			break;
-
 		case Opt_quorum_slot_nr:
-			if (opts->quorum_slot_nr != -1) {
+
+			if (parsed->quorum_slot_nr != -1) {
 				scoutfs_err(sb, "multiple quorum_slot_nr options provided, only provide one.");
 				return -EINVAL;
 			}
 
 			ret = match_int(args, &nr);
-			if (ret < 0 || nr < 0 || nr >= SCOUTFS_QUORUM_MAX_SLOTS) {
+			if (ret < 0 || nr < 0 ||
+			    nr >= SCOUTFS_QUORUM_MAX_SLOTS) {
 				scoutfs_err(sb, "invalid quorum_slot_nr option, must be between 0 and %u",
 					    SCOUTFS_QUORUM_MAX_SLOTS - 1);
 				if (ret == 0)
 					ret = -EINVAL;
 				return ret;
 			}
-			opts->quorum_slot_nr = nr;
+			parsed->quorum_slot_nr = nr;
 			break;
+		case Opt_metadev_path:
 
+			ret = parse_bdev_path(sb, &args[0],
+						 &parsed->metadev_path);
+			if (ret < 0)
+				return ret;
+			break;
 		default:
-			scoutfs_err(sb, "Unknown or malformed option, \"%s\"", p);
-			return -EINVAL;
+			scoutfs_err(sb, "Unknown or malformed option, \"%s\"",
+				    p);
+			break;
 		}
 	}
 
-	if (opts->orphan_scan_delay_ms == -1)
-		opts->orphan_scan_delay_ms = DEFAULT_ORPHAN_SCAN_DELAY_MS;
-
-	if (!opts->metadev_path) {
+	if (!parsed->metadev_path) {
 		scoutfs_err(sb, "Required mount option \"metadev_path\" not found");
 		return -EINVAL;
 	}
@@ -266,305 +148,40 @@ static int parse_options(struct super_block *sb, char *options, struct scoutfs_m
 	return 0;
 }
 
-void scoutfs_options_read(struct super_block *sb, struct scoutfs_mount_options *opts)
-{
-	DECLARE_OPTIONS_INFO(sb, optinf);
-	unsigned int seq;
-
-	if (WARN_ON_ONCE(optinf == NULL)) {
-		/* trying to use options before early setup or after destroy */
-		init_default_options(opts);
-		return;
-	}
-
-	do {
-		seq = read_seqbegin(&optinf->seqlock);
-		memcpy(opts, &optinf->opts, sizeof(struct scoutfs_mount_options));
-	} while (read_seqretry(&optinf->seqlock, seq));
-}
-
-/*
- * Early setup that parses and stores the options so that the rest of
- * setup can use them.   Full options setup that relies on other
- * components will be done later.
- */
-int scoutfs_options_early_setup(struct super_block *sb, char *options)
+int scoutfs_options_setup(struct super_block *sb)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
-	struct scoutfs_mount_options opts;
-	struct options_info *optinf;
+	struct options_sb_info *osi;
 	int ret;
 
-	init_default_options(&opts);
+	osi = kzalloc(sizeof(struct options_sb_info), GFP_KERNEL);
+	if (!osi)
+		return -ENOMEM;
 
-	ret = parse_options(sb, options, &opts);
-	if (ret < 0)
-		goto out;
+	sbi->options = osi;
 
-	optinf = kzalloc(sizeof(struct options_info), GFP_KERNEL);
-	if (!optinf) {
+	osi->debugfs_dir = debugfs_create_dir("options", sbi->debug_root);
+	if (!osi->debugfs_dir) {
 		ret = -ENOMEM;
 		goto out;
 	}
 
-	seqlock_init(&optinf->seqlock);
-	scoutfs_sysfs_init_attrs(sb, &optinf->sysfs_attrs);
-
-	write_seqlock(&optinf->seqlock);
-	optinf->opts = opts;
-	write_sequnlock(&optinf->seqlock);
-
-	sbi->options_info = optinf;
 	ret = 0;
 out:
-	if (ret < 0)
-		free_options(&opts);
-
-	return ret;
-}
-
-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 & SB_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);
-
-	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);
-	struct scoutfs_mount_options opts;
-
-	scoutfs_options_read(sb, &opts);
-
-	return snprintf(buf, PAGE_SIZE, "%s", opts.metadev_path);
-}
-SCOUTFS_ATTR_RO(metadev_path);
-
-static ssize_t orphan_scan_delay_ms_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.orphan_scan_delay_ms);
-}
-static ssize_t orphan_scan_delay_ms_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 < MIN_ORPHAN_SCAN_DELAY_MS || val > MAX_ORPHAN_SCAN_DELAY_MS) {
-		scoutfs_err(sb, "invalid orphan_scan_delay_ms value written to options sysfs file, must be between %lu and %lu",
-			    MIN_ORPHAN_SCAN_DELAY_MS, MAX_ORPHAN_SCAN_DELAY_MS);
-		return -EINVAL;
-	}
-
-	write_seqlock(&optinf->seqlock);
-	optinf->opts.orphan_scan_delay_ms = val;
-	write_sequnlock(&optinf->seqlock);
-
-	scoutfs_inode_schedule_orphan_dwork(sb);
-
-	return count;
-}
-SCOUTFS_ATTR_RW(orphan_scan_delay_ms);
-
-static ssize_t quorum_heartbeat_timeout_ms_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.quorum_heartbeat_timeout_ms);
-}
-static ssize_t quorum_heartbeat_timeout_ms_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);
-	ret = verify_quorum_heartbeat_timeout_ms(sb, ret, val);
-	if (ret == 0) {
-		write_seqlock(&optinf->seqlock);
-		optinf->opts.quorum_heartbeat_timeout_ms = val;
-		write_sequnlock(&optinf->seqlock);
-		ret = count;
-	}
-
-	return ret;
-}
-SCOUTFS_ATTR_RW(quorum_heartbeat_timeout_ms);
-
-static ssize_t quorum_slot_nr_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, "%d\n", opts.quorum_slot_nr);
-}
-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_heartbeat_timeout_ms),
-	SCOUTFS_ATTR_PTR(quorum_slot_nr),
-	NULL,
-};
-
-int scoutfs_options_setup(struct super_block *sb)
-{
-	DECLARE_OPTIONS_INFO(sb, optinf);
-	int ret;
-
-	ret = scoutfs_sysfs_create_attrs(sb, &optinf->sysfs_attrs, options_attrs, "mount_options");
-	if (ret < 0)
+	if (ret)
 		scoutfs_options_destroy(sb);
 	return ret;
 }
 
-/*
- * We remove the sysfs files early in unmount so that they can't try to call other subsystems
- * as they're being destroyed.
- */
-void scoutfs_options_stop(struct super_block *sb)
-{
-	DECLARE_OPTIONS_INFO(sb, optinf);
-
-	if (optinf)
-		scoutfs_sysfs_destroy_attrs(sb, &optinf->sysfs_attrs);
-}
-
 void scoutfs_options_destroy(struct super_block *sb)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
-	DECLARE_OPTIONS_INFO(sb, optinf);
+	struct options_sb_info *osi = sbi->options;
 
-	scoutfs_options_stop(sb);
-
-	if (optinf) {
-		free_options(&optinf->opts);
-		kfree(optinf);
-		sbi->options_info = NULL;
+	if (osi) {
+		if (osi->debugfs_dir)
+			debugfs_remove_recursive(osi->debugfs_dir);
+		kfree(osi);
+		sbi->options = NULL;
 	}
 }

kmod/src/options.h

@@ -5,21 +5,23 @@
 #include <linux/in.h>
 #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;
-	u64 quorum_heartbeat_timeout_ms;
+enum scoutfs_mount_options {
+	Opt_quorum_slot_nr,
+	Opt_metadev_path,
+	Opt_err,
 };
 
-void scoutfs_options_read(struct super_block *sb, struct scoutfs_mount_options *opts);
-int scoutfs_options_show(struct seq_file *seq, struct dentry *root);
+struct mount_options {
+	int quorum_slot_nr;
+	char *metadev_path;
+};
 
-int scoutfs_options_early_setup(struct super_block *sb, char *options);
+int scoutfs_parse_options(struct super_block *sb, char *options,
+			  struct mount_options *parsed);
 int scoutfs_options_setup(struct super_block *sb);
-void scoutfs_options_stop(struct super_block *sb);
 void scoutfs_options_destroy(struct super_block *sb);
 
+u32 scoutfs_option_u32(struct super_block *sb, int token);
+#define scoutfs_option_bool scoutfs_option_u32
+
 #endif	/* _SCOUTFS_OPTIONS_H_ */

kmod/src/quorum.h

@@ -2,13 +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_quorum_config *qconf, int i,
+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, struct scoutfs_quorum_config *qconf,
-				 u64 term);
+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/recov.c

@@ -262,7 +262,7 @@ void scoutfs_recov_shutdown(struct super_block *sb)
 	recinf->timeout_fn = NULL;
 	spin_unlock(&recinf->lock);
 
-	list_for_each_entry_safe(pend, tmp, &list, head) {
+	list_for_each_entry_safe(pend, tmp, &recinf->pending, head) {
 		list_del(&pend->head);
 		kfree(pend);
 	}

kmod/src/scoutfs_trace.h

@@ -403,24 +403,24 @@ TRACE_EVENT(scoutfs_sync_fs,
 );
 
 TRACE_EVENT(scoutfs_trans_write_func,
-	TP_PROTO(struct super_block *sb, u64 dirty_block_bytes, u64 dirty_item_pages),
+	TP_PROTO(struct super_block *sb, u64 dirty_block_bytes, u64 dirty_item_bytes),
 
-	TP_ARGS(sb, dirty_block_bytes, dirty_item_pages),
+	TP_ARGS(sb, dirty_block_bytes, dirty_item_bytes),
 
 	TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
 		__field(__u64, dirty_block_bytes)
-		__field(__u64, dirty_item_pages)
+		__field(__u64, dirty_item_bytes)
 	),
 
 	TP_fast_assign(
 		SCSB_TRACE_ASSIGN(sb);
 		__entry->dirty_block_bytes = dirty_block_bytes;
-		__entry->dirty_item_pages = dirty_item_pages;
+		__entry->dirty_item_bytes = dirty_item_bytes;
 	),
 
-	TP_printk(SCSBF" dirty_block_bytes %llu dirty_item_pages %llu",
-		  SCSB_TRACE_ARGS, __entry->dirty_block_bytes, __entry->dirty_item_pages)
+	TP_printk(SCSBF" dirty_block_bytes %llu dirty_item_bytes %llu",
+		  SCSB_TRACE_ARGS, __entry->dirty_block_bytes, __entry->dirty_item_bytes)
 );
 
 DECLARE_EVENT_CLASS(scoutfs_trans_hold_release_class,
@@ -691,16 +691,16 @@ TRACE_EVENT(scoutfs_evict_inode,
 
 TRACE_EVENT(scoutfs_drop_inode,
 	TP_PROTO(struct super_block *sb, __u64 ino, unsigned int nlink,
-		 unsigned int unhashed, bool lock_covered),
+		 unsigned int unhashed, bool drop_invalidated),
 
-	TP_ARGS(sb, ino, nlink, unhashed, lock_covered),
+	TP_ARGS(sb, ino, nlink, unhashed, drop_invalidated),
 
 	TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
 		__field(__u64, ino)
 		__field(unsigned int, nlink)
 		__field(unsigned int, unhashed)
-		__field(unsigned int, lock_covered)
+		__field(unsigned int, drop_invalidated)
 	),
 
 	TP_fast_assign(
@@ -708,12 +708,12 @@ TRACE_EVENT(scoutfs_drop_inode,
 		__entry->ino = ino;
 		__entry->nlink = nlink;
 		__entry->unhashed = unhashed;
-		__entry->lock_covered = !!lock_covered;
+		__entry->drop_invalidated = !!drop_invalidated;
 	),
 
-	TP_printk(SCSBF" ino %llu nlink %u unhashed %d lock_covered %u", SCSB_TRACE_ARGS,
+	TP_printk(SCSBF" ino %llu nlink %u unhashed %d drop_invalidated %u", SCSB_TRACE_ARGS,
 		  __entry->ino, __entry->nlink, __entry->unhashed,
-		  __entry->lock_covered)
+		  __entry->drop_invalidated)
 );
 
 TRACE_EVENT(scoutfs_inode_walk_writeback,
@@ -817,17 +817,22 @@ TRACE_EVENT(scoutfs_advance_dirty_super,
 	TP_printk(SCSBF" super seq now %llu", SCSB_TRACE_ARGS, __entry->seq)
 );
 
-TRACE_EVENT(scoutfs_dir_add_next_linkref_found,
+TRACE_EVENT(scoutfs_dir_add_next_linkref,
 	TP_PROTO(struct super_block *sb, __u64 ino, __u64 dir_ino,
-		 __u64 dir_pos, unsigned int name_len),
+		 __u64 dir_pos, int ret, __u64 found_dir_ino,
+		 __u64 found_dir_pos, unsigned int name_len),
 
-	TP_ARGS(sb, ino, dir_ino, dir_pos, name_len),
+	TP_ARGS(sb, ino, dir_ino, dir_pos, ret, found_dir_pos, found_dir_ino,
+		name_len),
 
 	TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
 		__field(__u64, ino)
 		__field(__u64, dir_ino)
 		__field(__u64, dir_pos)
+		__field(int, ret)
+		__field(__u64, found_dir_ino)
+		__field(__u64, found_dir_pos)
 		__field(unsigned int, name_len)
 	),
 
@@ -836,43 +841,16 @@ TRACE_EVENT(scoutfs_dir_add_next_linkref_found,
 		__entry->ino = ino;
 		__entry->dir_ino = dir_ino;
 		__entry->dir_pos = dir_pos;
+		__entry->ret = ret;
+		__entry->found_dir_ino = dir_ino;
+		__entry->found_dir_pos = dir_pos;
 		__entry->name_len = name_len;
 	),
 
-	TP_printk(SCSBF" ino %llu dir_ino %llu dir_pos %llu name_len %u",
-		  SCSB_TRACE_ARGS, __entry->ino, __entry->dir_ino,
-		  __entry->dir_pos, __entry->name_len)
-);
-
-TRACE_EVENT(scoutfs_dir_add_next_linkrefs,
-	TP_PROTO(struct super_block *sb, __u64 ino, __u64 dir_ino,
-		 __u64 dir_pos, int count, int nr, int ret),
-
-	TP_ARGS(sb, ino, dir_ino, dir_pos, count, nr, ret),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(__u64, ino)
-		__field(__u64, dir_ino)
-		__field(__u64, dir_pos)
-		__field(int, count)
-		__field(int, nr)
-		__field(int, ret)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->ino = ino;
-		__entry->dir_ino = dir_ino;
-		__entry->dir_pos = dir_pos;
-		__entry->count = count;
-		__entry->nr = nr;
-		__entry->ret = ret;
-	),
-
-	TP_printk(SCSBF" ino %llu dir_ino %llu dir_pos %llu count %d nr %d ret %d",
-		  SCSB_TRACE_ARGS, __entry->ino, __entry->dir_ino,
-		  __entry->dir_pos, __entry->count, __entry->nr, __entry->ret)
+	TP_printk(SCSBF" ino %llu dir_ino %llu dir_pos %llu ret %d found_dir_ino %llu found_dir_pos %llu name_len %u",
+		  SCSB_TRACE_ARGS, __entry->ino, __entry->dir_pos,
+		  __entry->dir_ino, __entry->ret, __entry->found_dir_pos,
+		  __entry->found_dir_ino, __entry->name_len)
 );
 
 TRACE_EVENT(scoutfs_write_begin,
@@ -1439,71 +1417,42 @@ TRACE_EVENT(scoutfs_rename,
 );
 
 TRACE_EVENT(scoutfs_d_revalidate,
-	TP_PROTO(struct super_block *sb, struct dentry *dentry, int flags, u64 dir_ino, int ret),
+	TP_PROTO(struct super_block *sb,
+		 struct dentry *dentry, int flags, struct dentry *parent,
+		 bool is_covered, int ret),
 
-	TP_ARGS(sb, dentry, flags, dir_ino, ret),
+	TP_ARGS(sb, dentry, flags, parent, is_covered, ret),
 
 	TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
-		__field(void *, dentry)
 		__string(name, dentry->d_name.name)
 		__field(__u64, ino)
-		__field(__u64, dir_ino)
+		__field(__u64, parent_ino)
 		__field(int, flags)
 		__field(int, is_root)
+		__field(int, is_covered)
 		__field(int, ret)
 	),
 
 	TP_fast_assign(
 		SCSB_TRACE_ASSIGN(sb);
-		__entry->dentry = dentry;
 		__assign_str(name, dentry->d_name.name)
-		__entry->ino = dentry->d_inode ? scoutfs_ino(dentry->d_inode) : 0;
-		__entry->dir_ino = dir_ino;
+		__entry->ino = dentry->d_inode ?
+			       scoutfs_ino(dentry->d_inode) : 0;
+		__entry->parent_ino = parent->d_inode ?
+			       scoutfs_ino(parent->d_inode) : 0;
 		__entry->flags = flags;
 		__entry->is_root = IS_ROOT(dentry);
+		__entry->is_covered = is_covered;
 		__entry->ret = ret;
 	),
 
-	TP_printk(SCSBF" dentry %p name %s ino %llu dir_ino %llu flags 0x%x s_root %u ret %d",
-		  SCSB_TRACE_ARGS, __entry->dentry, __get_str(name), __entry->ino, __entry->dir_ino,
-		  __entry->flags, __entry->is_root, __entry->ret)
-);
-
-TRACE_EVENT(scoutfs_validate_dentry,
-	TP_PROTO(struct super_block *sb, struct dentry *dentry, u64 dir_ino, u64 dentry_ino,
-		 u64 dent_ino, u64 refresh_gen, int ret),
-
-	TP_ARGS(sb, dentry, dir_ino, dentry_ino, dent_ino, refresh_gen, ret),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(void *, dentry)
-		__field(__u64, dir_ino)
-		__string(name, dentry->d_name.name)
-		__field(__u64, dentry_ino)
-		__field(__u64, dent_ino)
-		__field(__u64, fsdata_gen)
-		__field(__u64, refresh_gen)
-		__field(int, ret)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->dentry = dentry;
-		__entry->dir_ino = dir_ino;
-		__assign_str(name, dentry->d_name.name)
-		__entry->dentry_ino = dentry_ino;
-		__entry->dent_ino = dent_ino;
-		__entry->fsdata_gen = (unsigned long long)dentry->d_fsdata;
-		__entry->refresh_gen = refresh_gen;
-		__entry->ret = ret;
-	),
-
-	TP_printk(SCSBF" dentry %p dir %llu name %s dentry_ino %llu dent_ino %llu fsdata_gen %llu refresh_gen %llu ret %d",
-		  SCSB_TRACE_ARGS, __entry->dentry, __entry->dir_ino, __get_str(name),
-		  __entry->dentry_ino, __entry->dent_ino, __entry->fsdata_gen,
-		  __entry->refresh_gen, __entry->ret)
+	TP_printk(SCSBF" name %s ino %llu parent_ino %llu flags 0x%x s_root %u is_covered %u ret %d",
+		  SCSB_TRACE_ARGS, __get_str(name), __entry->ino,
+		  __entry->parent_ino, __entry->flags,
+		  __entry->is_root,
+		  __entry->is_covered,
+		  __entry->ret)
 );
 
 DECLARE_EVENT_CLASS(scoutfs_super_lifecycle_class,
@@ -1894,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" },	\
@@ -2020,9 +1922,9 @@ DEFINE_EVENT(scoutfs_quorum_message_class, scoutfs_quorum_recv_message,
 
 TRACE_EVENT(scoutfs_quorum_loop,
 	TP_PROTO(struct super_block *sb, int role, u64 term, int vote_for,
-		 unsigned long vote_bits, unsigned long long nsecs),
+		 unsigned long vote_bits, struct timespec64 timeout),
 
-	TP_ARGS(sb, role, term, vote_for, vote_bits, nsecs),
+	TP_ARGS(sb, role, term, vote_for, vote_bits, timeout),
 
 	TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
@@ -2031,7 +1933,8 @@ TRACE_EVENT(scoutfs_quorum_loop,
 		__field(int, vote_for)
 		__field(unsigned long, vote_bits)
 		__field(unsigned long, vote_count)
-		__field(unsigned long long, nsecs)
+		__field(unsigned long long, timeout_sec)
+		__field(int, timeout_nsec)
 	),
 
 	TP_fast_assign(
@@ -2041,13 +1944,14 @@ TRACE_EVENT(scoutfs_quorum_loop,
 		__entry->vote_for = vote_for;
 		__entry->vote_bits = vote_bits;
 		__entry->vote_count = hweight_long(vote_bits);
-		__entry->nsecs = nsecs;
+		__entry->timeout_sec = timeout.tv_sec;
+		__entry->timeout_nsec = timeout.tv_nsec;
 	),
 
-	TP_printk(SCSBF" term %llu role %d vote_for %d vote_bits 0x%lx vote_count %lu timeout %llu",
+	TP_printk(SCSBF" term %llu role %d vote_for %d vote_bits 0x%lx vote_count %lu timeout %llu.%u",
 		  SCSB_TRACE_ARGS, __entry->term, __entry->role,
 		  __entry->vote_for, __entry->vote_bits, __entry->vote_count,
-		  __entry->nsecs)
+		  __entry->timeout_sec, __entry->timeout_nsec)
 );
 
 TRACE_EVENT(scoutfs_trans_seq_last,
@@ -2716,9 +2620,9 @@ TRACE_EVENT(scoutfs_item_invalidate_page,
 
 DECLARE_EVENT_CLASS(scoutfs_omap_group_class,
 	TP_PROTO(struct super_block *sb, void *grp, u64 group_nr, unsigned int group_total,
-		 int bit_nr),
+		 int bit_nr, int bit_count),
 
-	TP_ARGS(sb, grp, group_nr, group_total, bit_nr),
+	TP_ARGS(sb, grp, group_nr, group_total, bit_nr, bit_count),
 
 	TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
@@ -2726,6 +2630,7 @@ DECLARE_EVENT_CLASS(scoutfs_omap_group_class,
 		__field(__u64, group_nr)
 		__field(unsigned int, group_total)
 		__field(int, bit_nr)
+		__field(int, bit_count)
 	),
 
 	TP_fast_assign(
@@ -2734,42 +2639,43 @@ DECLARE_EVENT_CLASS(scoutfs_omap_group_class,
 		__entry->group_nr = group_nr;
 		__entry->group_total = group_total;
 		__entry->bit_nr = bit_nr;
+		__entry->bit_count = bit_count;
 	),
 
-	TP_printk(SCSBF" grp %p group_nr %llu group_total %u bit_nr %d",
+	TP_printk(SCSBF" grp %p group_nr %llu group_total %u bit_nr %d bit_count %d",
 		  SCSB_TRACE_ARGS, __entry->grp, __entry->group_nr, __entry->group_total,
-		  __entry->bit_nr)
+		  __entry->bit_nr, __entry->bit_count)
 );
 
 DEFINE_EVENT(scoutfs_omap_group_class, scoutfs_omap_group_alloc,
 	TP_PROTO(struct super_block *sb, void *grp, u64 group_nr, unsigned int group_total,
-		 int bit_nr),
-	TP_ARGS(sb, grp, group_nr, group_total, bit_nr)
+		 int bit_nr, int bit_count),
+	TP_ARGS(sb, grp, group_nr, group_total, bit_nr, bit_count)
 );
 DEFINE_EVENT(scoutfs_omap_group_class, scoutfs_omap_group_free,
 	TP_PROTO(struct super_block *sb, void *grp, u64 group_nr, unsigned int group_total,
-		 int bit_nr),
-	TP_ARGS(sb, grp, group_nr, group_total, bit_nr)
+		 int bit_nr, int bit_count),
+	TP_ARGS(sb, grp, group_nr, group_total, bit_nr, bit_count)
 );
 DEFINE_EVENT(scoutfs_omap_group_class, scoutfs_omap_group_inc,
 	TP_PROTO(struct super_block *sb, void *grp, u64 group_nr, unsigned int group_total,
-		 int bit_nr),
-	TP_ARGS(sb, grp, group_nr, group_total, bit_nr)
+		 int bit_nr, int bit_count),
+	TP_ARGS(sb, grp, group_nr, group_total, bit_nr, bit_count)
 );
 DEFINE_EVENT(scoutfs_omap_group_class, scoutfs_omap_group_dec,
 	TP_PROTO(struct super_block *sb, void *grp, u64 group_nr, unsigned int group_total,
-		 int bit_nr),
-	TP_ARGS(sb, grp, group_nr, group_total, bit_nr)
+		 int bit_nr, int bit_count),
+	TP_ARGS(sb, grp, group_nr, group_total, bit_nr, bit_count)
 );
 DEFINE_EVENT(scoutfs_omap_group_class, scoutfs_omap_group_request,
 	TP_PROTO(struct super_block *sb, void *grp, u64 group_nr, unsigned int group_total,
-		 int bit_nr),
-	TP_ARGS(sb, grp, group_nr, group_total, bit_nr)
+		 int bit_nr, int bit_count),
+	TP_ARGS(sb, grp, group_nr, group_total, bit_nr, bit_count)
 );
 DEFINE_EVENT(scoutfs_omap_group_class, scoutfs_omap_group_destroy,
 	TP_PROTO(struct super_block *sb, void *grp, u64 group_nr, unsigned int group_total,
-		 int bit_nr),
-	TP_ARGS(sb, grp, group_nr, group_total, bit_nr)
+		 int bit_nr, int bit_count),
+	TP_ARGS(sb, grp, group_nr, group_total, bit_nr, bit_count)
 );
 
 TRACE_EVENT(scoutfs_omap_should_delete,

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, struct scoutfs_quorum_config *qconf, 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/srch.c

@@ -861,6 +861,7 @@ int scoutfs_srch_search_xattrs(struct super_block *sb,
 			       struct scoutfs_srch_rb_root *sroot,
 			       u64 hash, u64 ino, u64 last_ino, bool *done)
 {
+	struct scoutfs_net_roots prev_roots;
 	struct scoutfs_net_roots roots;
 	struct scoutfs_srch_entry start;
 	struct scoutfs_srch_entry end;
@@ -868,7 +869,6 @@ int scoutfs_srch_search_xattrs(struct super_block *sb,
 	struct scoutfs_log_trees lt;
 	struct scoutfs_srch_file sfl;
 	SCOUTFS_BTREE_ITEM_REF(iref);
-	DECLARE_SAVED_REFS(saved);
 	struct scoutfs_key key;
 	unsigned long limit = SRCH_LIMIT;
 	int ret;
@@ -877,6 +877,7 @@ int scoutfs_srch_search_xattrs(struct super_block *sb,
 
 	*done = false;
 	srch_init_rb_root(sroot);
+	memset(&prev_roots, 0, sizeof(prev_roots));
 
 	start.hash = cpu_to_le64(hash);
 	start.ino = cpu_to_le64(ino);
@@ -891,6 +892,7 @@ retry:
 	ret = scoutfs_client_get_roots(sb, &roots);
 	if (ret)
 		goto out;
+	memset(&roots.fs_root, 0, sizeof(roots.fs_root));
 
 	end = final;
 
@@ -966,10 +968,16 @@ retry:
 	*done = sre_cmp(&end, &final) == 0;
 	ret = 0;
 out:
-	ret = scoutfs_block_check_stale(sb, ret, &saved, &roots.srch_root.ref,
-					&roots.logs_root.ref);
-	if (ret == -ESTALE)
-		goto retry;
+	if (ret == -ESTALE) {
+		if (memcmp(&prev_roots, &roots, sizeof(roots)) == 0) {
+			scoutfs_inc_counter(sb, srch_search_stale_eio);
+			ret = -EIO;
+		} else {
+			scoutfs_inc_counter(sb, srch_search_stale_retry);
+			prev_roots = roots;
+			goto retry;
+		}
+	}
 
 	return ret;
 }
@@ -995,14 +1003,6 @@ int scoutfs_srch_rotate_log(struct super_block *sb,
 		      le64_to_cpu(sfl->ref.blkno), 0);
 	ret = scoutfs_btree_insert(sb, alloc, wri, root, &key,
 				   sfl, sizeof(*sfl));
-	/*
-	 * While it's fine to replay moving the client's logging srch
-	 * file to the core btree item, server commits should keep it
-	 * from happening.  So we'll warn if we see it happen.  This can
-	 * be removed eventually.
-	 */
-	if (WARN_ON_ONCE(ret == -EEXIST))
-		ret = 0;
 	if (ret == 0) {
 		memset(sfl, 0, sizeof(*sfl));
 		scoutfs_inc_counter(sb, srch_rotate_log);
@@ -1747,7 +1747,7 @@ static int compact_logs(struct super_block *sb,
 				goto out;
 			}
 			page->private = 0;
-			list_add_tail(&page->lru, &pages);
+			list_add_tail(&page->list, &pages);
 			nr_pages++;
 			scoutfs_inc_counter(sb, srch_compact_log_page);
 		}
@@ -1800,7 +1800,7 @@ static int compact_logs(struct super_block *sb,
 
 	/* sort page entries and reset private for _next */
 	i = 0;
-	list_for_each_entry(page, &pages, lru) {
+	list_for_each_entry(page, &pages, list) {
 		args[i++] = page;
 
 		if (atomic_read(&srinf->shutdown)) {
@@ -1821,7 +1821,7 @@ static int compact_logs(struct super_block *sb,
 		goto out;
 
 	/* make sure we finished all the pages */
-	list_for_each_entry(page, &pages, lru) {
+	list_for_each_entry(page, &pages, list) {
 		sre = page_priv_sre(page);
 		if (page->private < SRES_PER_PAGE && sre->ino != 0) {
 			ret = -ENOSPC;
@@ -1834,8 +1834,8 @@ static int compact_logs(struct super_block *sb,
 out:
 	scoutfs_block_put(sb, bl);
 	vfree(args);
-	list_for_each_entry_safe(page, tmp, &pages, lru) {
-		list_del(&page->lru);
+	list_for_each_entry_safe(page, tmp, &pages, list) {
+		list_del(&page->list);
 		__free_page(page);
 	}
 

kmod/src/super.c

@@ -13,7 +13,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/fs.h>
-#include <linux/blkdev.h>
 #include <linux/slab.h>
 #include <linux/pagemap.h>
 #include <linux/magic.h>
@@ -48,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;
@@ -134,6 +132,44 @@ out:
 	return ret;
 }
 
+static int scoutfs_show_options(struct seq_file *seq, struct dentry *root)
+{
+	struct super_block *sb = root->d_sb;
+	struct mount_options *opts = &SCOUTFS_SB(sb)->opts;
+
+	if (opts->quorum_slot_nr >= 0)
+		seq_printf(seq, ",quorum_slot_nr=%d", opts->quorum_slot_nr);
+	seq_printf(seq, ",metadev_path=%s", opts->metadev_path);
+
+	return 0;
+}
+
+static ssize_t metadev_path_show(struct kobject *kobj,
+				 struct kobj_attribute *attr, char *buf)
+{
+	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
+	struct mount_options *opts = &SCOUTFS_SB(sb)->opts;
+
+	return snprintf(buf, PAGE_SIZE, "%s", opts->metadev_path);
+}
+SCOUTFS_ATTR_RO(metadev_path);
+
+static ssize_t quorum_server_nr_show(struct kobject *kobj,
+			      struct kobj_attribute *attr, char *buf)
+{
+	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
+	struct mount_options *opts = &SCOUTFS_SB(sb)->opts;
+
+	return snprintf(buf, PAGE_SIZE, "%d\n", opts->quorum_slot_nr);
+}
+SCOUTFS_ATTR_RO(quorum_server_nr);
+
+static struct attribute *mount_options_attrs[] = {
+	SCOUTFS_ATTR_PTR(metadev_path),
+	SCOUTFS_ATTR_PTR(quorum_server_nr),
+	NULL,
+};
+
 static int scoutfs_sync_fs(struct super_block *sb, int wait)
 {
 	trace_scoutfs_sync_fs(sb, wait);
@@ -179,7 +215,7 @@ static void scoutfs_put_super(struct super_block *sb)
 	/*
 	 * Wait for invalidation and iput to finish with any lingering
 	 * inode references that escaped the evict_inodes in
-	 * generic_shutdown_super.  SB_ACTIVE is clear so final iput
+	 * generic_shutdown_super.  MS_ACTIVE is clear so final iput
 	 * will always evict.
 	 */
 	scoutfs_lock_flush_invalidate(sb);
@@ -210,11 +246,13 @@ static void scoutfs_put_super(struct super_block *sb)
 	scoutfs_destroy_triggers(sb);
 	scoutfs_fence_destroy(sb);
 	scoutfs_options_destroy(sb);
+	scoutfs_sysfs_destroy_attrs(sb, &sbi->mopts_ssa);
 	debugfs_remove(sbi->debug_root);
 	scoutfs_destroy_counters(sb);
 	scoutfs_destroy_sysfs(sb);
 	scoutfs_metadev_close(sb);
 
+	kfree(sbi->opts.metadev_path);
 	kfree(sbi);
 
 	sb->s_fs_info = NULL;
@@ -244,7 +282,7 @@ static const struct super_operations scoutfs_super_ops = {
 	.destroy_inode = scoutfs_destroy_inode,
 	.sync_fs = scoutfs_sync_fs,
 	.statfs = scoutfs_statfs,
-	.show_options = scoutfs_options_show,
+	.show_options = scoutfs_show_options,
 	.put_super = scoutfs_put_super,
 	.umount_begin = scoutfs_umount_begin,
 };
@@ -462,8 +500,9 @@ static int scoutfs_read_supers(struct super_block *sb)
 		goto out;
 	}
 
-	sbi->fsid = le64_to_cpu(meta_super->hdr.fsid);
+
 	sbi->fmt_vers = le64_to_cpu(meta_super->fmt_vers);
+	sbi->super = *meta_super;
 out:
 	kfree(meta_super);
 	kfree(data_super);
@@ -472,9 +511,9 @@ out:
 
 static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 {
-	struct scoutfs_mount_options opts;
-	struct block_device *meta_bdev;
 	struct scoutfs_sb_info *sbi;
+	struct mount_options opts;
+	struct block_device *meta_bdev;
 	struct inode *inode;
 	int ret;
 
@@ -483,11 +522,8 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	sb->s_magic = SCOUTFS_SUPER_MAGIC;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	sb->s_op = &scoutfs_super_ops;
-	sb->s_d_op = &scoutfs_dentry_ops;
 	sb->s_export_op = &scoutfs_export_ops;
-	sb->s_xattr = scoutfs_xattr_handlers;
-	sb->s_flags |= SB_I_VERSION | SB_POSIXACL;
-	sb->s_time_gran = 1;
+	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);
@@ -500,17 +536,18 @@ 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);
 	sbi->data_wait_root.root = RB_ROOT;
+	scoutfs_sysfs_init_attrs(sb, &sbi->mopts_ssa);
 
-	/* parse options early for use during setup */
-	ret = scoutfs_options_early_setup(sb, data);
-	if (ret < 0)
+	ret = scoutfs_parse_options(sb, data, &opts);
+	if (ret)
 		goto out;
-	scoutfs_options_read(sb, &opts);
+
+	sbi->opts = opts;
 
 	ret = sb_set_blocksize(sb, SCOUTFS_BLOCK_SM_SIZE);
 	if (ret != SCOUTFS_BLOCK_SM_SIZE) {
@@ -519,7 +556,9 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 		goto out;
 	}
 
-	meta_bdev = blkdev_get_by_path(opts.metadev_path, SCOUTFS_META_BDEV_MODE, sb);
+	meta_bdev =
+		blkdev_get_by_path(sbi->opts.metadev_path,
+				   SCOUTFS_META_BDEV_MODE, sb);
 	if (IS_ERR(meta_bdev)) {
 		scoutfs_err(sb, "could not open metadev: error %ld",
 			    PTR_ERR(meta_bdev));
@@ -539,6 +578,8 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	      scoutfs_setup_sysfs(sb) ?:
 	      scoutfs_setup_counters(sb) ?:
 	      scoutfs_options_setup(sb) ?:
+	      scoutfs_sysfs_create_attrs(sb, &sbi->mopts_ssa,
+				mount_options_attrs, "mount_options") ?:
 	      scoutfs_setup_triggers(sb) ?:
 	      scoutfs_fence_setup(sb) ?:
 	      scoutfs_block_setup(sb) ?:
@@ -560,7 +601,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 		goto out;
 
 	/* this interruptible iget lets hung mount be aborted with ctl-c */
-	inode = scoutfs_iget(sb, SCOUTFS_ROOT_INO, SCOUTFS_LKF_INTERRUPTIBLE, 0);
+	inode = scoutfs_iget(sb, SCOUTFS_ROOT_INO, SCOUTFS_LKF_INTERRUPTIBLE);
 	if (IS_ERR(inode)) {
 		ret = PTR_ERR(inode);
 		if (ret == -ERESTARTSYS)
@@ -611,7 +652,6 @@ static void scoutfs_kill_sb(struct super_block *sb)
 	}
 
 	if (SCOUTFS_HAS_SBI(sb)) {
-		scoutfs_options_stop(sb);
 		scoutfs_inode_orphan_stop(sb);
 		scoutfs_lock_unmount_begin(sb);
 	}
@@ -632,6 +672,7 @@ MODULE_ALIAS_FS("scoutfs");
 static void teardown_module(void)
 {
 	debugfs_remove(scoutfs_debugfs_root);
+	scoutfs_dir_exit();
 	scoutfs_inode_exit();
 	scoutfs_sysfs_exit();
 }
@@ -669,20 +710,21 @@ static int __init scoutfs_module_init(void)
 		goto out;
 	}
 	ret = scoutfs_inode_init() ?:
+	      scoutfs_dir_init() ?:
 	      register_filesystem(&scoutfs_fs_type);
 out:
 	if (ret)
 		teardown_module();
 	return ret;
 }
-module_init(scoutfs_module_init);
+module_init(scoutfs_module_init)
 
 static void __exit scoutfs_module_exit(void)
 {
 	unregister_filesystem(&scoutfs_fs_type);
 	teardown_module();
 }
-module_exit(scoutfs_module_exit);
+module_exit(scoutfs_module_exit)
 
 MODULE_AUTHOR("Zach Brown <zab@versity.com>");
 MODULE_LICENSE("GPL");

kmod/src/super.h

@@ -35,15 +35,15 @@ struct scoutfs_sb_info {
 	struct super_block *sb;
 
 	/* assigned once at the start of each mount, read-only */
-	u64 fsid;
 	u64 rid;
 	u64 fmt_vers;
 
+	struct scoutfs_super_block super;
+
 	struct block_device *meta_bdev;
 
 	spinlock_t next_ino_lock;
 
-	struct options_info *options_info;
 	struct data_info *data_info;
 	struct inode_sb_info *inode_sb_info;
 	struct btree_info *btree_info;
@@ -74,6 +74,10 @@ struct scoutfs_sb_info {
 	struct scoutfs_counters *counters;
 	struct scoutfs_triggers *triggers;
 
+	struct mount_options opts;
+	struct options_sb_info *options;
+	struct scoutfs_sysfs_attrs mopts_ssa;
+
 	struct dentry *debug_root;
 
 	bool forced_unmount;
@@ -134,14 +138,14 @@ static inline bool scoutfs_unmounting(struct super_block *sb)
 	(int)(le64_to_cpu(fsid) >> SCSB_SHIFT),				    \
 	(int)(le64_to_cpu(rid) >> SCSB_SHIFT)
 #define SCSB_ARGS(sb)							    \
-	(int)(SCOUTFS_SB(sb)->fsid >> SCSB_SHIFT),			    \
+	(int)(le64_to_cpu(SCOUTFS_SB(sb)->super.hdr.fsid) >> SCSB_SHIFT),   \
 	(int)(SCOUTFS_SB(sb)->rid >> SCSB_SHIFT)
 #define SCSB_TRACE_FIELDS	\
 	__field(__u64, fsid)	\
 	__field(__u64, rid)
 #define SCSB_TRACE_ASSIGN(sb)						\
 	__entry->fsid = SCOUTFS_HAS_SBI(sb) ?				\
-		        SCOUTFS_SB(sb)->fsid : 0;			\
+			le64_to_cpu(SCOUTFS_SB(sb)->super.hdr.fsid) : 0;\
 	__entry->rid = SCOUTFS_HAS_SBI(sb) ?				\
 		       SCOUTFS_SB(sb)->rid : 0;
 #define SCSB_TRACE_ARGS				\

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)
 {
@@ -60,9 +51,10 @@ static ssize_t fsid_show(struct kobject *kobj, struct attribute *attr,
 			 char *buf)
 {
 	struct super_block *sb = KOBJ_TO_SB(kobj, sb_id_kobj);
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
+	struct scoutfs_super_block *super = &SCOUTFS_SB(sb)->super;
 
-	return snprintf(buf, PAGE_SIZE, "%016llx\n", sbi->fsid);
+	return snprintf(buf, PAGE_SIZE, "%016llx\n",
+			le64_to_cpu(super->hdr.fsid));
 }
 ATTR_FUNCS_RO(fsid);
 
@@ -109,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,
@@ -267,7 +258,7 @@ int __init scoutfs_sysfs_init(void)
 	return 0;
 }
 
-void scoutfs_sysfs_exit(void)
+void __exit scoutfs_sysfs_exit(void)
 {
 	if (scoutfs_kset)
 		kset_unregister(scoutfs_kset);

kmod/src/sysfs.h

@@ -53,6 +53,6 @@ int scoutfs_setup_sysfs(struct super_block *sb);
 void scoutfs_destroy_sysfs(struct super_block *sb);
 
 int __init scoutfs_sysfs_init(void);
-void scoutfs_sysfs_exit(void);
+void __exit scoutfs_sysfs_exit(void);
 
 #endif

kmod/src/trans.c

@@ -207,7 +207,7 @@ void scoutfs_trans_write_func(struct work_struct *work)
 	}
 
 	trace_scoutfs_trans_write_func(sb, scoutfs_block_writer_dirty_bytes(sb, &tri->wri),
-				       scoutfs_item_dirty_pages(sb));
+				       scoutfs_item_dirty_bytes(sb));
 
 	if (tri->deadline_expired)
 		scoutfs_inc_counter(sb, trans_commit_timer);
@@ -422,16 +422,18 @@ static void release_holders(struct super_block *sb)
  */
 static bool commit_before_hold(struct super_block *sb, struct trans_info *tri)
 {
+	u64 dirty_blocks = (scoutfs_item_dirty_bytes(sb) >> SCOUTFS_BLOCK_LG_SHIFT) + 1;
+
 	/*
-	 * In theory each dirty item page could be straddling two full
-	 * blocks, requiring 4 allocations for each item cache page.
-	 * That's much too conservative, typically many dirty item cache
-	 * pages that are near each other all land in one block.  This
+	 * In theory each dirty item could be added to a full block that
+	 * has to split, requiring 2 meta block allocs for each dirty
+	 * item.  That's much too conservative, typically many dirty
+	 * items that are near each other all land in one block.  This
 	 * rough estimate is still so far beyond what typically happens
 	 * that it accounts for having to dirty parent blocks and
 	 * whatever dirtying is done during the transaction hold.
 	 */
-	if (scoutfs_alloc_meta_low(sb, &tri->alloc, scoutfs_item_dirty_pages(sb) * 2)) {
+	if (scoutfs_alloc_meta_low(sb, &tri->alloc, dirty_blocks * 4)) {
 		scoutfs_inc_counter(sb, trans_commit_dirty_meta_full);
 		return true;
 	}
@@ -640,7 +642,6 @@ void scoutfs_shutdown_trans(struct super_block *sb)
 			tri->write_workq = NULL;
 		}
 
-		scoutfs_alloc_prepare_commit(sb, &tri->alloc, &tri->wri);
 		scoutfs_block_writer_forget_all(sb, &tri->wri);
 
 		kfree(tri);

kmod/src/tseq.c

@@ -46,23 +46,6 @@ static struct scoutfs_tseq_entry *tseq_rb_next(struct scoutfs_tseq_entry *ent)
 	return rb_entry(node, struct scoutfs_tseq_entry, node);
 }
 
-#ifdef KC_RB_TREE_AUGMENTED_COMPUTE_MAX
-static bool tseq_compute_total(struct scoutfs_tseq_entry *ent, bool exit)
-{
-	loff_t total = 1 + tseq_node_total(ent->node.rb_left) +
-		       tseq_node_total(ent->node.rb_right);
-
-	if (exit && ent->total == total)
-		return true;
-
-	ent->total = total;
-	return false;
-}
-
-RB_DECLARE_CALLBACKS(static, tseq_rb_callbacks, struct scoutfs_tseq_entry,
-		     node, total, tseq_compute_total);
-#else
-
 static loff_t tseq_compute_total(struct scoutfs_tseq_entry *ent)
 {
 	return 1 + tseq_node_total(ent->node.rb_left) +
@@ -70,8 +53,7 @@ static loff_t tseq_compute_total(struct scoutfs_tseq_entry *ent)
 }
 
 RB_DECLARE_CALLBACKS(static, tseq_rb_callbacks, struct scoutfs_tseq_entry,
-		     node, loff_t, total, tseq_compute_total);
-#endif
+		     node, loff_t, total, tseq_compute_total)
 
 void scoutfs_tseq_tree_init(struct scoutfs_tseq_tree *tree,
 			    scoutfs_tseq_show_t show)

kmod/src/util.h

@@ -17,15 +17,4 @@ static inline void down_write_two(struct rw_semaphore *a,
 	down_write_nested(b, SINGLE_DEPTH_NESTING);
 }
 
-/*
- * When returning shrinker counts from scan_objects, we should steer
- * clear of the magic SHRINK_STOP and SHRINK_EMPTY values, which are near
- * ~0UL values. Hence, we cap count to ~0L, which is arbitarily high
- * enough to avoid it.
- */
-static inline unsigned long shrinker_min_t_long(unsigned long count)
-{
-	return min_t(u64, count, LONG_MAX);
-}
-
 #endif

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(inode);
-	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,126 +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;
 }
 
-#ifndef KC_XATTR_STRUCT_XATTR_HANDLER
-/*
- * 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(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;
-}
-#endif
+	if (size == 0)
+		value = ""; /* set empty value */
 
-static int scoutfs_xattr_get_handler
-#ifdef KC_XATTR_STRUCT_XATTR_HANDLER
-		(const struct xattr_handler *handler, struct dentry *dentry,
-		 struct inode *inode, const char *name, void *value,
-		 size_t size)
-{
-	name = xattr_full_name(handler, name);
-#else
-		(struct dentry *dentry, const char *name,
-		 void *value, size_t size, int handler_flags)
-{
-	name = full_name_hack(name, handler_flags);
-#endif
-	return scoutfs_xattr_get(dentry, name, value, size);
-}
-
-static int scoutfs_xattr_set_handler
-#ifdef KC_XATTR_STRUCT_XATTR_HANDLER
-		(const struct xattr_handler *handler, struct dentry *dentry,
-		 struct inode *inode, const char *name, const void *value,
-		 size_t size, int flags)
-{
-	name = xattr_full_name(handler, name);
-#else
-		(struct dentry *dentry, const char *name,
-		 const void *value, size_t size, int flags, int handler_flags)
-{
-	name = full_name_hack(name, handler_flags);
-#endif
 	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 = {
-#ifdef KC_XATTR_HANDLER_NAME
-	.name   = XATTR_NAME_POSIX_ACL_ACCESS,
-#else
-	.prefix = XATTR_NAME_POSIX_ACL_ACCESS,
-#endif
-	.flags  = ACL_TYPE_ACCESS,
-	.get    = scoutfs_acl_get_xattr,
-	.set    = scoutfs_acl_set_xattr,
-};
-
-static const struct xattr_handler scoutfs_xattr_acl_default_handler = {
-#ifdef KC_XATTR_HANDLER_NAME
-	.name   = XATTR_NAME_POSIX_ACL_DEFAULT,
-#else
-	.prefix = XATTR_NAME_POSIX_ACL_DEFAULT,
-#endif
-	.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,
@@ -966,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;
@@ -979,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;
@@ -993,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/.gitignore

@@ -3,9 +3,7 @@ src/createmany
 src/dumb_renameat2
 src/dumb_setxattr
 src/handle_cat
-src/handle_fsetxattr
 src/bulk_create_paths
 src/find_xattrs
 src/stage_tmpfile
 src/create_xattr_loop
-src/o_tmpfile_umask

tests/Makefile

@@ -6,13 +6,10 @@ BIN := src/createmany			\
 	src/dumb_renameat2		\
 	src/dumb_setxattr		\
 	src/handle_cat			\
-	src/handle_fsetxattr		\
 	src/bulk_create_paths		\
 	src/stage_tmpfile		\
 	src/find_xattrs			\
-	src/create_xattr_loop		\
-	src/fragmented_data_extents	\
-	src/o_tmpfile_umask
+	src/create_xattr_loop
 
 DEPS := $(wildcard src/*.d)
 

tests/fenced-local-force-unmount.sh

@@ -1,43 +0,0 @@
-#!/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
-}
-
-rid="$SCOUTFS_FENCED_REQ_RID"
-
-for fs in /sys/fs/scoutfs/*; do
-	[ ! -d "$fs" ] && continue
-
-	fs_rid="$(cat $fs/rid)" || \
-		echo_fail "failed to get rid in $fs"
-	if [ "$fs_rid" != "$rid" ]; then
-		continue
-	fi
-
-	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
-		umount -f "$mnt" || \
-			echo_fail "umout -f $mnt failed"
-	done
-done
-
-exit 0

tests/funcs/exec.sh

@@ -39,18 +39,6 @@ t_quiet()
 		t_fail "quiet command failed"
 }
 
-#
-# Quietly run a command during a test.  The output is logged but only
-# the return code is printed, presumably because the output contains
-# a lot of invocation specific text that is difficult to filter.
-#
-t_rc()
-{
-	echo "# $*" >> "$T_TMP.rc.log"
-	"$@" >> "$T_TMP.rc.log" 2>&1
-	echo "rc: $?"
-}
-
 #
 # redirect test output back to the output of the invoking script intead
 # of the compared output.

tests/funcs/filter.sh

@@ -18,7 +18,6 @@ t_filter_dmesg()
 
 	# the kernel can just be noisy
 	re=" used greatest stack depth: "
-	re="$re|sched: RT throttling activated"
 
 	# mkfs/mount checks partition tables
 	re="$re|unknown partition table"
@@ -57,12 +56,8 @@ t_filter_dmesg()
 	re="$re|scoutfs .*: all clients recovered"
 	re="$re|scoutfs .* error: client rid.*lock recovery timed out"
 
-	# we test bad devices and options
+	# some tests mount w/o options
 	re="$re|scoutfs .* error: Required mount option \"metadev_path\" not found"
-	re="$re|scoutfs .* error: meta_super META flag not set"
-	re="$re|scoutfs .* error: could not open metadev:.*"
-	re="$re|scoutfs .* error: Unknown or malformed option,.*"
-	re="$re|scoutfs .* error: invalid quorum_heartbeat_timeout_ms value"
 
 	# in debugging kernels we can slow things down a bit
 	re="$re|hrtimer: interrupt took .*"
@@ -83,10 +78,6 @@ t_filter_dmesg()
 	re="$re|scoutfs .* error .* freeing merged btree blocks.*.final commit del.upd freeing item"
 	re="$re|scoutfs .* error .*reading quorum block.*to update event.*"
 	re="$re|scoutfs .* error.*server failed to bind to.*"
-	re="$re|scoutfs .* critical transaction commit failure.*"
-
-	# change-devices causes loop device resizing
-	re="$re|loop[0-9].* detected capacity change from.*"
 
 	egrep -v "($re)" 
 }

tests/funcs/fs.sh

@@ -75,29 +75,6 @@ t_fs_nrs()
 	seq 0 $((T_NR_MOUNTS - 1))
 }
 
-#
-# output the fs nrs of quorum nodes, we "know" that
-# the quorum nrs are the first consequtive nrs
-#
-t_quorum_nrs()
-{
-	seq 0 $((T_QUORUM - 1))
-}
-
-#
-# outputs "1" if the fs number has "1" in its quorum/is_leader file.
-# All other cases output 0, including the fs nr being a client which
-# won't have a quorum/ dir.
-#
-t_fs_is_leader()
-{
-	if [ "$(cat $(t_sysfs_path $i)/quorum/is_leader 2>/dev/null)" == "1" ]; then
-		echo "1"
-	else
-		echo "0"
-	fi
-}
-
 #
 # Output the mount nr of the current server.  This takes no steps to
 # ensure that the server doesn't shut down and have some other mount
@@ -106,7 +83,7 @@ t_fs_is_leader()
 t_server_nr()
 {
 	for i in $(t_fs_nrs); do
-		if [ "$(t_fs_is_leader $i)" == "1" ]; then
+		if [ "$(cat $(t_sysfs_path $i)/quorum/is_leader)" == "1" ]; then
 			echo $i
 			return
 		fi
@@ -124,7 +101,7 @@ t_server_nr()
 t_first_client_nr()
 {
 	for i in $(t_fs_nrs); do
-		if [ "$(t_fs_is_leader $i)" == "0" ]; then
+		if [ "$(cat $(t_sysfs_path $i)/quorum/is_leader)" == "0" ]; then
 			echo $i
 			return
 		fi
@@ -153,27 +130,7 @@ t_mount()
 	test "$nr" -lt "$T_NR_MOUNTS" || \
 		t_fail "fs nr $nr invalid"
 
-	eval t_quiet mount -t scoutfs \$T_O$nr\$opt \$T_DB$nr \$T_M$nr
-}
-
-#
-# Mount with an optional mount option string.  If the string is empty
-# then the saved mount options are used.  If the string has contents
-# then it is appended to the end of the saved options with a separating
-# comma.
-#
-# Unlike t_mount this won't inherently fail in t_quiet, errors are
-# returned so bad options can be tested.
-#
-t_mount_opt()
-{
-	local nr="$1"
-	local opt="${2:+,$2}"
-
-	test "$nr" -lt "$T_NR_MOUNTS" || \
-		t_fail "fs nr $nr invalid"
-
-	eval mount -t scoutfs \$T_O$nr\$opt \$T_DB$nr \$T_M$nr
+	eval t_quiet mount -t scoutfs \$T_O$nr \$T_DB$nr \$T_M$nr
 }
 
 t_umount()
@@ -405,57 +362,3 @@ t_wait_for_leader() {
 		done
 	done
 }
-
-t_get_sysfs_mount_option() {
-	local nr="$1"
-	local name="$2"
-	local opt="$(t_sysfs_path $nr)/mount_options/$name"
-
-	cat "$opt"
-}
-
-t_set_sysfs_mount_option() {
-	local nr="$1"
-	local name="$2"
-	local val="$3"
-	local opt="$(t_sysfs_path $nr)/mount_options/$name"
-
-	echo "$val" > "$opt" 2>/dev/null
-}
-
-t_set_all_sysfs_mount_options() {
-	local name="$1"
-	local val="$2"
-	local i
-
-	for i in $(t_fs_nrs); do
-		t_set_sysfs_mount_option $i $name $val
-	done
-}
-
-declare -A _saved_opts
-t_save_all_sysfs_mount_options() {
-	local name="$1"
-	local ind
-	local opt
-	local i
-
-	for i in $(t_fs_nrs); do
-		opt="$(t_sysfs_path $i)/mount_options/$name"
-		ind="${name}_${i}"
-
-		_saved_opts[$ind]="$(cat $opt)"
-	done
-}
-
-t_restore_all_sysfs_mount_options() {
-	local name="$1"
-	local ind
-	local i
-
-	for i in $(t_fs_nrs); do
-		ind="${name}_${i}"
-
-		t_set_sysfs_mount_option $i $name "${_saved_opts[$ind]}"
-	done
-}

tests/golden/basic-bad-mounts

@@ -1,6 +0,0 @@
-== prepare devices, mount point, and logs
-== bad devices, bad options
-== swapped devices
-== both meta devices
-== both data devices
-== good volume, bad option and good options

tests/golden/basic-posix-consistency

@@ -47,9 +47,8 @@ four
 --- dir within dir
 --- overwrite file
 --- can't overwrite non-empty dir
-mv: cannot move '/mnt/test/test/basic-posix-consistency/dir/c/clobber' to '/mnt/test/test/basic-posix-consistency/dir/a/dir': Directory not empty
+mv: cannot move ‘/mnt/test/test/basic-posix-consistency/dir/c/clobber’ to ‘/mnt/test/test/basic-posix-consistency/dir/a/dir’: Directory not empty
 --- can overwrite empty dir
---- can rename into root
 == path resoluion
 == inode indexes match after syncing existing
 == inode indexes match after copying and syncing

tests/golden/basic-truncate

@@ -1,6 +0,0 @@
-== truncate writes zeroed partial end of file block
-0000000 0a79 0a79 0a79 0a79 0a79 0a79 0a79 0a79
-*
-0006144 0000 0000 0000 0000 0000 0000 0000 0000
-*
-0012288

tests/golden/change-devices

@@ -1,27 +0,0 @@
-== make tmp sparse data dev files
-== make scratch fs
-== small new data device fails
-rc: 1
-== check sees data device errors
-rc: 1
-rc: 0
-== preparing while mounted fails
-rc: 1
-== preparing without recovery fails
-rc: 1
-== check sees metadata errors
-rc: 1
-rc: 1
-== preparing with file data fails
-rc: 1
-== preparing after emptied
-rc: 0
-== checks pass
-rc: 0
-rc: 0
-== using prepared
-== preparing larger and resizing
-rc: 0
-equal_prepared
-large_prepared
-resized larger test rc: 0

tests/golden/client-unmount-recovery

@@ -1 +0,0 @@
-== 60s of unmounting non-quorum clients during recovery

tests/golden/data-prealloc

@@ -1,330 +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
-== block writes into region allocs hole
-wrote blk 24
-wrote blk 32
-wrote blk 40
-wrote blk 55
-wrote blk 63
-wrote blk 71
-wrote blk 72
-wrote blk 79
-wrote blk 80
-wrote blk 87
-wrote blk 88
-wrote blk 95
-before:
-24.. 1: 
-32.. 1: 
-40.. 1: 
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 0 at pos 0
-wrote blk 0
-0.. 1: 
-1.. 7: unwritten
-24.. 1: 
-32.. 1: 
-40.. 1: 
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 0 at pos 1
-wrote blk 15
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-24.. 1: 
-32.. 1: 
-40.. 1: 
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 0 at pos 2
-wrote blk 19
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-32.. 1: 
-40.. 1: 
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 1 at pos 0
-wrote blk 25
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-40.. 1: 
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 1 at pos 1
-wrote blk 39
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 1 at pos 2
-wrote blk 44
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-44.. 1: 
-45.. 3: unwritten
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 2 at pos 0
-wrote blk 48
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-44.. 1: 
-45.. 3: unwritten
-48.. 1: 
-49.. 6: unwritten
-55.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 2 at pos 1
-wrote blk 62
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-44.. 1: 
-45.. 3: unwritten
-48.. 1: 
-49.. 6: unwritten
-55.. 1: 
-56.. 6: unwritten
-62.. 1: 
-63.. 1: 
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 2 at pos 2
-wrote blk 67
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-44.. 1: 
-45.. 3: unwritten
-48.. 1: 
-49.. 6: unwritten
-55.. 1: 
-56.. 6: unwritten
-62.. 1: 
-63.. 1: 
-64.. 3: unwritten
-67.. 1: 
-68.. 3: unwritten
-71.. 2: 
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 3 at pos 0
-wrote blk 73
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-44.. 1: 
-45.. 3: unwritten
-48.. 1: 
-49.. 6: unwritten
-55.. 1: 
-56.. 6: unwritten
-62.. 1: 
-63.. 1: 
-64.. 3: unwritten
-67.. 1: 
-68.. 3: unwritten
-71.. 2: 
-73.. 1: 
-74.. 5: unwritten
-79.. 2: 
-87.. 2: 
-95.. 1: eof
-writing into existing 3 at pos 1
-wrote blk 86
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-44.. 1: 
-45.. 3: unwritten
-48.. 1: 
-49.. 6: unwritten
-55.. 1: 
-56.. 6: unwritten
-62.. 1: 
-63.. 1: 
-64.. 3: unwritten
-67.. 1: 
-68.. 3: unwritten
-71.. 2: 
-73.. 1: 
-74.. 5: unwritten
-79.. 2: 
-86.. 1: 
-87.. 2: 
-95.. 1: eof
-writing into existing 3 at pos 2
-wrote blk 92
-0.. 1: 
-1.. 14: unwritten
-15.. 1: 
-16.. 3: unwritten
-19.. 1: 
-20.. 4: unwritten
-24.. 1: 
-25.. 1: 
-26.. 6: unwritten
-32.. 1: 
-39.. 1: 
-40.. 1: 
-44.. 1: 
-45.. 3: unwritten
-48.. 1: 
-49.. 6: unwritten
-55.. 1: 
-56.. 6: unwritten
-62.. 1: 
-63.. 1: 
-64.. 3: unwritten
-67.. 1: 
-68.. 3: unwritten
-71.. 2: 
-73.. 1: 
-74.. 5: unwritten
-79.. 2: 
-86.. 1: 
-87.. 2: 
-92.. 1: 
-93.. 2: unwritten
-95.. 1: eof

tests/golden/fallocate

@@ -1,3 +0,0 @@
-== creating reasonably large per-mount files
-== 10s of racing cold reads and fallocate nop
-== cleaning up files

tests/golden/get-referring-entries

@@ -1,18 +0,0 @@
-== root inode returns nothing
-== crazy large unused inode does nothing
-== basic entry
-file
-== rename
-renamed
-== hard link
-file
-link
-== removal
-== different dirs
-== file types
-type b name block
-type c name char
-type d name dir
-type f name file
-type l name symlink
-== all name lengths work

tests/golden/inode-deletion

@@ -17,7 +17,7 @@ ino not found in dseq index
 mount 0 contents after mount 1 rm: contents
 ino found in dseq index
 ino found in dseq index
-stat: cannot stat '/mnt/test/test/inode-deletion/file': No such file or directory
+stat: cannot stat ‘/mnt/test/test/inode-deletion/file’: No such file or directory
 ino not found in dseq index
 ino not found in dseq index
 == lots of deletions use one open map

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/offline-extent-waiting

@@ -20,10 +20,10 @@ offline waiting should now have two known entries:
 data_wait_err found 2 waiters.
 offline waiting should now have 0 known entries:
 0
-dd: error reading '/mnt/test/test/offline-extent-waiting/dir/file': Input/output error
+dd: error reading ‘/mnt/test/test/offline-extent-waiting/dir/file’: Input/output error
 0+0 records in
 0+0 records out
-dd: error reading '/mnt/test/test/offline-extent-waiting/dir/file': Input/output error
+dd: error reading ‘/mnt/test/test/offline-extent-waiting/dir/file’: Input/output error
 0+0 records in
 0+0 records out
 offline waiting should be empty again:

tests/golden/orphan-inodes

@@ -2,4 +2,3 @@
 == unlinked and opened inodes still exist
 == orphan from failed evict deletion is picked up
 == orphaned inos in all mounts all deleted
-== 30s of racing evict deletion, orphan scanning, and open by handle

tests/golden/quorum-heartbeat-timeout

@@ -1,5 +0,0 @@
-== bad timeout values fail
-== bad mount option fails
-== mount option
-== sysfs
-== reset all options

tests/golden/simple-inode-index

@@ -7,4 +7,3 @@ found second
 == changing metadata must increase meta seq
 == changing contents must increase data seq
 == make sure dirtying doesn't livelock walk
-== concurrent update attempts maintain single entries

tests/golden/stage-tmpfile

@@ -1,11 +1,3 @@
-== non-acl O_TMPFILE creation honors umask
-umask 022
-fstat after open(0777): 0100755
-stat after linkat: 0100755
-umask 077
-fstat after open(0777): 0100700
-stat after linkat: 0100700
-== stage from tmpfile
 total file size 33669120
 00000000  41 41 41 41 41 41 41 41  41 41 41 41 41 41 41 41  |AAAAAAAAAAAAAAAA|
 *

tests/golden/xfstests

@@ -40,7 +40,6 @@ generic/092
 generic/098
 generic/101
 generic/104
-generic/105
 generic/106
 generic/107
 generic/117
@@ -52,7 +51,6 @@ generic/184
 generic/221
 generic/228
 generic/236
-generic/237
 generic/245
 generic/249
 generic/257
@@ -65,7 +63,6 @@ generic/308
 generic/309
 generic/313
 generic/315
-generic/319
 generic/322
 generic/335
 generic/336
@@ -75,7 +72,6 @@ generic/342
 generic/343
 generic/348
 generic/360
-generic/375
 generic/376
 generic/377
 Not
@@ -241,6 +237,7 @@ generic/312
 generic/314
 generic/316
 generic/317
+generic/318
 generic/324
 generic/326
 generic/327
@@ -285,4 +282,4 @@ shared/004
 shared/032
 shared/051
 shared/289
-Passed all 79 tests
+Passed all 75 tests

tests/run-tests.sh

@@ -1,8 +1,5 @@
 #!/usr/bin/bash
 
-# Force system tools to use ASCII quotes
-export LC_ALL=C
-
 #
 # XXX
 #  - could have helper functions for waiting for pids
@@ -61,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
@@ -72,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
@@ -141,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"
 		;;
@@ -171,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"
@@ -243,9 +227,8 @@ test "$T_QUORUM" -le "$T_NR_MOUNTS" || \
 	 die "-q quorum mmembers must not be greater than -n mounts"
 
 # top level paths
-T_TESTS=$(realpath "$(dirname $0)")
-T_KMOD=$(realpath "$T_TESTS/../kmod")
-T_UTILS=$(realpath "$T_TESTS/../utils")
+T_KMOD=$(realpath "$(dirname $0)/../kmod")
+T_UTILS=$(realpath "$T_KMOD/../utils")
 
 test -d "$T_KMOD" || die "kmod/ repo dir $T_KMOD not directory"
 test -d "$T_UTILS" || die "utils/ repo dir $T_UTILS not directory"
@@ -361,13 +344,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
@@ -397,21 +373,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=$T_UTILS/fenced/local-force-unmount
+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
@@ -419,7 +393,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()
@@ -430,7 +404,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"
 
@@ -454,7 +428,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" &
@@ -629,9 +602,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

@@ -1,18 +1,12 @@
 export-get-name-parent.sh
 basic-block-counts.sh
-basic-bad-mounts.sh
 inode-items-updated.sh
 simple-inode-index.sh
 simple-staging.sh
 simple-release-extents.sh
-get-referring-entries.sh
-fallocate.sh
-basic-truncate.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
@@ -21,14 +15,13 @@ 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
 createmany-rename-large-dir.sh
 stage-release-race-alloc.sh
 stage-multi-part.sh
-o_tmpfile.sh
+stage-tmpfile.sh
 basic-posix-consistency.sh
 dirent-consistency.sh
 mkdir-rename-rmdir.sh
@@ -37,12 +30,9 @@ cross-mount-data-free.sh
 persistent-item-vers.sh
 setup-error-teardown.sh
 resize-devices.sh
-change-devices.sh
 fence-and-reclaim.sh
-quorum-heartbeat-timeout.sh
 orphan-inodes.sh
 mount-unmount-race.sh
-client-unmount-recovery.sh
 createmany-parallel-mounts.sh
 archive-light-cycle.sh
 block-stale-reads.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/src/handle_fsetxattr.c

@@ -1,189 +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.
- */
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <errno.h>
-#include <string.h>
-#include <endian.h>
-#include <time.h>
-#include <linux/types.h>
-#include <sys/xattr.h>
-
-#define FILEID_SCOUTFS			0x81
-#define FILEID_SCOUTFS_WITH_PARENT	0x82
-
-struct our_handle {
-	struct file_handle handle;
-	/*
-	 * scoutfs file handle can be ino or ino/parent. The
-	 * handle_type field of struct file_handle denotes which
-	 * version is in use. We only use the ino variant here.
-	 */
-	__le64 scoutfs_ino;
-};
-
-#define DEFAULT_NAME "user.handle_fsetxattr"
-#define DEFAULT_VALUE "value"
-
-static void exit_usage(void)
-{
-	printf(" -h/-?         output this usage message and exit\n"
-	       " -e            keep trying on enoent and estale, consider success an error\n"
-	       " -i <num>      64bit inode number for handle open, can be multiple\n"
-	       " -m <string>   scoutfs mount path string for ioctl fd\n"
-	       " -n <string>   optional xattr name string, defaults to \""DEFAULT_NAME"\"\n"
-	       " -s <num>      loop for num seconds, defaults to 0 for one iteration"
-	       " -v <string>   optional xattr value string, defaults to \""DEFAULT_VALUE"\"\n");
-	exit(1);
-}
-
-int main(int argc, char **argv)
-{
-	struct our_handle handle;
-	struct timespec ts;
-	bool enoent_success_err = false;
-	uint64_t seconds = 0;
-	char *value = NULL;
-	char *name = NULL;
-	char *mnt = NULL;
-	int nr_inos = 0;
-	uint64_t *inos;
-	uint64_t i;
-	int *fds;
-	int mntfd;
-	int fd;
-	int ret;
-	char c;
-	int j;
-
-	/* can't have more inos than args */
-	inos = calloc(argc, sizeof(inos[0]));
-	fds = calloc(argc, sizeof(fds[0]));
-	if (!inos || !fds) {
-		perror("calloc");
-		exit(1);
-	}
-	for (i = 0; i < argc; i++)
-		fds[i] = -1;
-
-	while ((c = getopt(argc, argv, "+ei:m:n:s:v:")) != -1) {
-		switch (c) {
-			case 'e':
-				enoent_success_err = true;
-				break;
-			case 'i':
-				inos[nr_inos] = strtoll(optarg, NULL, 0);
-				nr_inos++;
-				break;
-			case 'm':
-				mnt = strdup(optarg);
-				break;
-			case 'n':
-				name = strdup(optarg);
-				break;
-			case 's':
-				seconds = strtoll(optarg, NULL, 0);
-				break;
-			case 'v':
-				value = strdup(optarg);
-				break;
-			case '?':
-				printf("unknown argument: %c\n", optind);
-			case 'h':
-				exit_usage();
-		}
-	}
-
-	if (nr_inos == 0) {
-		printf("specify non-zero inode number with -i\n");
-		exit(1);
-	}
-
-	if (!mnt) {
-		printf("specify scoutfs mount path for ioctl with -p\n");
-		exit(1);
-	}
-
-	if (name == NULL)
-		name = DEFAULT_NAME;
-	if (value == NULL)
-		value = DEFAULT_VALUE;
-
-	mntfd = open(mnt, O_RDONLY);
-	if (mntfd == -1) {
-		perror("opening mountpoint");
-		return 1;
-	}
-
-	clock_gettime(CLOCK_REALTIME, &ts);
-	seconds += ts.tv_sec;
-
-	for (i = 0; ; i++) {
-		for (j = 0; j < nr_inos; j++) {
-			fd = fds[j];
-
-			if (fd < 0) {
-				handle.handle.handle_bytes = sizeof(struct our_handle);
-				handle.handle.handle_type = FILEID_SCOUTFS;
-				handle.scoutfs_ino = htole64(inos[j]);
-
-				fd = open_by_handle_at(mntfd, &handle.handle, O_RDWR);
-				if (fd == -1) {
-					if (!enoent_success_err || ( errno != ENOENT && errno != ESTALE )) {
-						perror("open_by_handle_at");
-						return 1;
-					}
-					continue;
-				}
-				fds[j] = fd;
-			}
-
-			ret = fsetxattr(fd, name, value, strlen(value), 0);
-			if (ret < 0) {
-				perror("fsetxattr");
-				return 1;
-			}
-		}
-
-		if ((i % 10) == 0) {
-			clock_gettime(CLOCK_REALTIME, &ts);
-			if (ts.tv_sec >= seconds)
-				break;
-		}
-	}
-
-	if (enoent_success_err) {
-		bool able = false;
-		for (i = 0; i < nr_inos; i++) {
-			if (fds[i] >= 0) {
-				printf("was able to open ino %"PRIu64"\n", inos[i]);
-				able = true;
-			}
-		}
-		if (able)
-			exit(1);
-	}
-
-	/* not bothering to close or free */
-	return 0;
-}

tests/src/o_tmpfile_umask.c

@@ -1,97 +0,0 @@
-/*
- * Show the modes of files as we create them with O_TMPFILE and link
- * them into the namespace.
- *
- * 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.
- */
-
-#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 <sys/stat.h>
-#include <assert.h>
-#include <limits.h>
-
-static void linkat_tmpfile_modes(char *dir, char *lpath, mode_t mode)
-{
-	char proc_self[PATH_MAX];
-	struct stat st;
-	int ret;
-	int fd;
-
-	umask(mode);
-	printf("umask 0%o\n", mode);
-
-	fd = open(dir, O_RDWR | O_TMPFILE, 0777);
-	if (fd < 0) {
-		perror("open(O_TMPFILE)");
-		exit(1);
-	}
-
-	ret = fstat(fd, &st);
-	if (ret < 0) {
-		perror("fstat");
-		exit(1);
-	}
-
-	printf("fstat after open(0777): 0%o\n", st.st_mode);
-
-	snprintf(proc_self, sizeof(proc_self), "/proc/self/fd/%d", fd);
-
-	ret = linkat(AT_FDCWD, proc_self, AT_FDCWD, lpath, AT_SYMLINK_FOLLOW);
-	if (ret < 0) {
-		perror("linkat");
-		exit(1);
-	}
-
-	close(fd);
-
-	ret = stat(lpath, &st);
-	if (ret < 0) {
-		perror("fstat");
-		exit(1);
-	}
-
-	printf("stat after linkat: 0%o\n", st.st_mode);
-
-	ret = unlink(lpath);
-	if (ret < 0) {
-		perror("unlink");
-		exit(1);
-	}
-}
-
-int main(int argc, char **argv)
-{
-	char *lpath;
-	char *dir;
-
-	if (argc < 3) {
-		printf("%s <open_dir> <linkat_path>\n", argv[0]);
-		return 1;
-	}
-
-	dir = argv[1];
-	lpath = argv[2];
-
-	linkat_tmpfile_modes(dir, lpath, 022);
-	linkat_tmpfile_modes(dir, lpath, 077);
-
-	return 0;
-}

tests/tests/basic-bad-mounts.sh

@@ -1,36 +0,0 @@
-
-mount_fail()
-{
-	local mnt=${!#}
-
-	echo "mounting $@" >> $T_TMP.mount.out
-	mount -t scoutfs "$@" >> $T_TMP.mount.out 2>&1
-	if [ $? == 0 ]; then
-		umount "$mnt" || t_fail "couldn't unmount"
-		t_fail "bad mount succeeded"
-	fi
-}
-
-echo "== prepare devices, mount point, and logs"
-SCR="$T_TMPDIR/mnt.scratch"
-mkdir -p "$SCR"
-> $T_TMP.mount.out
-scoutfs mkfs -f -Q 0,127.0.0.1,53000 "$T_EX_META_DEV" "$T_EX_DATA_DEV" > $T_TMP.mkfs.out 2>&1 \
-	|| t_fail "mkfs failed"
-
-echo "== bad devices, bad options"
-mount_fail -o _bad /dev/null /dev/null "$SCR"
-
-echo "== swapped devices"
-mount_fail -o metadev_path=$T_EX_DATA_DEV,quorum_slot_nr=0 "$T_EX_META_DEV" "$SCR"
-
-echo "== both meta devices"
-mount_fail -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$T_EX_META_DEV" "$SCR"
-
-echo "== both data devices"
-mount_fail -o metadev_path=$T_EX_DATA_DEV,quorum_slot_nr=0 "$T_EX_DATA_DEV" "$SCR"
-
-echo "== good volume, bad option and good options"
-mount_fail -o _bad,metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$T_EX_DATA_DEV" "$SCR" 
-
-t_pass

tests/tests/basic-posix-consistency.sh

@@ -149,10 +149,6 @@ find "$T_D0/dir" -ls 2>&1 | t_filter_fs > "$T_TMP.0"
 find "$T_D1/dir" -ls 2>&1 | t_filter_fs > "$T_TMP.1"
 diff -u "$T_TMP.0" "$T_TMP.1"
 rm -rf "$T_D0/dir"
-echo "--- can rename into root"
-touch "$T_D0/rename-into-root"
-mv "$T_D0/rename-into-root" "$T_M0/"
-rm -f "$T_M0/rename-into-root"
 
 echo "== path resoluion"
 touch "$T_D0/file"

tests/tests/basic-truncate.sh

@@ -1,21 +0,0 @@
-#
-# Test basic correctness of truncate.
-#
-
-t_require_commands yes dd od truncate
-
-FILE="$T_D0/file"
-
-#
-# We forgot to write a dirty block that zeroed the tail of a partial
-# final block as we truncated past it.
-#
-echo "== truncate writes zeroed partial end of file block"
-yes | dd of="$FILE" bs=8K count=1 status=none
-sync
-truncate -s 6K "$FILE"
-truncate -s 12K "$FILE"
-echo 3 > /proc/sys/vm/drop_caches
-od -Ad -x "$FILE"
-
-t_pass

tests/tests/change-devices.sh

@@ -1,76 +0,0 @@
-#
-# test changing devices
-#
-
-echo "== make tmp sparse data dev files"
-sz=$(blockdev --getsize64 "$T_EX_DATA_DEV")
-large_sz=$((sz * 2))
-touch "$T_TMP."{small,equal,large}
-truncate -s 1MB "$T_TMP.small"
-truncate -s $sz "$T_TMP.equal"
-truncate -s $large_sz "$T_TMP.large"
-
-echo "== make scratch fs"
-t_quiet scoutfs mkfs -f -Q 0,127.0.0.1,53000 "$T_EX_META_DEV" "$T_EX_DATA_DEV"
-SCR="$T_TMPDIR/mnt.scratch"
-mkdir -p "$SCR"
-
-echo "== small new data device fails"
-t_rc scoutfs prepare-empty-data-device "$T_EX_META_DEV" "$T_TMP.small"
-
-echo "== check sees data device errors"
-t_rc scoutfs prepare-empty-data-device --check "$T_EX_META_DEV" "$T_TMP.small"
-t_rc scoutfs prepare-empty-data-device --check "$T_EX_META_DEV"
-
-echo "== preparing while mounted fails"
-mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$T_EX_DATA_DEV" "$SCR"
-t_rc scoutfs prepare-empty-data-device "$T_EX_META_DEV" "$T_TMP.equal"
-umount "$SCR"
-
-echo "== preparing without recovery fails"
-mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$T_EX_DATA_DEV" "$SCR"
-umount -f "$SCR"
-t_rc scoutfs prepare-empty-data-device "$T_EX_META_DEV" "$T_TMP.equal"
-
-echo "== check sees metadata errors"
-t_rc scoutfs prepare-empty-data-device --check "$T_EX_META_DEV"
-t_rc scoutfs prepare-empty-data-device --check "$T_EX_META_DEV" "$T_TMP.equal"
-
-echo "== preparing with file data fails"
-mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$T_EX_DATA_DEV" "$SCR"
-echo hi > "$SCR"/file
-umount "$SCR"
-scoutfs print "$T_EX_META_DEV" > "$T_TMP.print"
-t_rc scoutfs prepare-empty-data-device "$T_EX_META_DEV" "$T_TMP.equal"
-
-echo "== preparing after emptied"
-mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$T_EX_DATA_DEV" "$SCR"
-rm -f "$SCR"/file
-umount "$SCR"
-t_rc scoutfs prepare-empty-data-device "$T_EX_META_DEV" "$T_TMP.equal"
-
-echo "== checks pass"
-t_rc scoutfs prepare-empty-data-device --check "$T_EX_META_DEV"
-t_rc scoutfs prepare-empty-data-device --check "$T_EX_META_DEV" "$T_TMP.equal"
-
-echo "== using prepared"
-scr_loop=$(losetup --find --show "$T_TMP.equal")
-mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$scr_loop" "$SCR"
-touch "$SCR"/equal_prepared
-equal_tot=$(scoutfs statfs -s total_data_blocks -p "$SCR")
-umount "$SCR"
-losetup -d "$scr_loop"
-
-echo "== preparing larger and resizing"
-t_rc scoutfs prepare-empty-data-device "$T_EX_META_DEV" "$T_TMP.large"
-scr_loop=$(losetup --find --show "$T_TMP.large")
-mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 "$scr_loop" "$SCR"
-touch "$SCR"/large_prepared
-ls "$SCR"
-scoutfs resize-devices -p "$SCR" -d $large_sz
-large_tot=$(scoutfs statfs -s total_data_blocks -p "$SCR")
-test "$large_tot" -gt "$equal_tot" ; echo "resized larger test rc: $?"
-umount "$SCR"
-losetup -d "$scr_loop"
-
-t_pass

tests/tests/client-unmount-recovery.sh

@@ -1,61 +0,0 @@
-#
-# Unmount Server and unmount a client as it's replaying to a remaining server
-#
-
-majority_nr=$(t_majority_count)
-quorum_nr=$T_QUORUM
-
-test "$quorum_nr" == "$majority_nr" && \
-        t_skip "all quorum members make up majority, need more mounts to unmount"
-
-test "$T_NR_MOUNTS" -lt "$T_QUORUM" && \
-        t_skip "Need enough non-quorum clients to unmount"
-
-for i in $(t_fs_nrs); do
-        mounted[$i]=1
-done
-
-LENGTH=60
-echo "== ${LENGTH}s of unmounting non-quorum clients during recovery"
-END=$((SECONDS + LENGTH))
-while [ "$SECONDS" -lt "$END" ]; do
-        sv=$(t_server_nr)
-        rid=$(t_mount_rid $sv)
-        echo "sv $sv rid $rid" >> "$T_TMP.log"
-        sync
-        t_umount $sv &
-
-        for i in $(t_fs_nrs); do
-                if [ "$i" -ge "$quorum_nr" ]; then
-                        t_umount $i &
-                        echo "umount $i pid $pid quo $quorum_nr" \
-                                >> $T_TMP.log
-                        mounted[$i]=0
-                fi
-        done
-
-        wait
-
-        t_mount $sv &
-        for i in $(t_fs_nrs); do
-                if [ "${mounted[$i]}" == 0 ]; then
-                        t_mount $i &
-                fi
-        done
-
-        wait
-
-        declare RID_LIST=$(cat /sys/fs/scoutfs/*/rid | sort -u)
-        read -a rid_arr <<< $RID_LIST
-
-        declare LOCK_LIST=$(cut -d' ' -f 5 /sys/kernel/debug/scoutfs/*/server_locks | sort -u)
-        read -a lock_arr <<< $LOCK_LIST
-
-        for i in "${lock_arr[@]}"; do
-                if [[ ! " ${rid_arr[*]} " =~ " $i " ]]; then
-                        t_fail "RID($i): exists when not mounted"
-                fi
-        done
-done
-
-t_pass

tests/tests/data-prealloc.sh

@@ -1,231 +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_block()
-{
-	local file="$1"
-	local blk="$2"
-
-	dd if=/dev/zero of="$file" bs=4096 seek=$blk count=1 conv=notrunc status=none
-	echo "wrote blk $blk"
-}
-
-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
-}
-
-#
-# print the logical start, len, and flags if they're there.
-#
-print_logical_extents()
-{
-	local file="$1"
-
-	filefrag -v -b4096 "$file" 2>&1 | t_filter_fs | awk '
-		($1 ~ /[0-9]+:/) {
-			if ($NF !~  /[0-9]+:/) {
-				flags=$NF
-			} else {
-				flags=""
-			}
-			print $2, $6, flags
-		}
-	' | sed 's/last,eof/eof/'
-}
-
-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
-
-#
-# prepare aligned regions of 8 blocks that we'll write into.
-# We'll right into the first, last, and middle block of each
-# region which was prepared with no existing extents, one at
-# the start, and one at the end.
-#
-# Let's keep this last because it creates a ton of output to read
-# through.  The correct output is tied to preallocation strategy so it
-# has to be verified each time we change preallocation.
-#
-echo "== block writes into region allocs hole" 
-t_set_sysfs_mount_option 0 data_prealloc_blocks 8
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 1
-touch "$prefix"
-truncate -s 0 "$prefix"
-
-# write initial blocks in regions
-base=0
-for sides in 0 1 2 3; do
-	for i in 0 1 2; do
-                case "$sides" in
-			# none
-			0) ;;
-			# left
-			1) write_block $prefix $((base + 0)) ;;
-			# right
-			2) write_block $prefix $((base + 7)) ;;
-			# both
-			3) write_block $prefix $((base + 0)) 
-			   write_block $prefix $((base + 7)) ;;
-		esac
-		((base+=8))
-	done
-done
-
-echo before:
-print_logical_extents "$prefix"
-
-# now write into the first, middle, and last empty block of each
-t_set_sysfs_mount_option 0 data_prealloc_contig_only 0
-base=0
-for sides in 0 1 2 3; do
-	for i in 0 1 2; do
-		echo "writing into existing $sides at pos $i"
-		case "$sides" in
-			# none
-			0) left=$base; right=$((base + 7));;
-			# left
-			1) left=$((base + 1)); right=$((base + 7));;
-			# right
-			2) left=$((base)); right=$((base + 6));;
-			# both
-			3) left=$((base + 1)); right=$((base + 6));;
-		esac
-		case "$i" in
-			# start
-			0) write_block $prefix $left ;;
-			# end
-			1) write_block $prefix $right ;;
-			# mid (both has 6 blocks internally)
-			2) write_block $prefix $((left + 3)) ;;
-		esac
-		print_logical_extents "$prefix"
-		((base+=8))
-	done
-done
-
-t_pass

tests/tests/enospc.sh

@@ -59,7 +59,7 @@ echo "== make small meta fs"
 # meta device just big enough for reserves and the metadata we'll fill
 scoutfs mkfs -A -f -Q 0,127.0.0.1,53000 -m 10G "$T_EX_META_DEV" "$T_EX_DATA_DEV" > $T_TMP.mkfs.out 2>&1 || \
 	t_fail "mkfs failed"
-SCR="$T_TMPDIR/mnt.scratch"
+SCR="/mnt/scoutfs.enospc"
 mkdir -p "$SCR"
 mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 \
 	"$T_EX_DATA_DEV" "$SCR"

tests/tests/fallocate.sh

@@ -1,38 +0,0 @@
-
-t_require_commands fallocate cat
-
-echo "== creating reasonably large per-mount files"
-for n in $(t_fs_nrs); do
-	eval path="\$T_D${n}/file-$n"
-
-	LC_ALL=C fallocate -l 128MiB  "$path" || \
-		t_fail "initial creating fallocate failed"
-done
-
-#
-# we had lock inversions between read and fallocate, dropping
-# the cache each time forces waiting for IO during the calls
-# with the inverted locks held so we have a better chance
-# of the deadlock happening.
-#
-DURATION=10
-echo "== ${DURATION}s of racing cold reads and fallocate nop"
-END=$((SECONDS + DURATION))
-while [ $SECONDS -le $END ]; do
-
-	echo 3 > /proc/sys/vm/drop_caches
-
-	for n in $(t_fs_nrs); do
-		eval path="\$T_D${n}/file-$n"
-		
-		LC_ALL=C fallocate -o 0 -l 4KiB  "$path" &
-		cat "$path" > /dev/null &
-	done
-
-	wait || t_fail "fallocate or cat failed"
-done
-
-echo "== cleaning up files"
-rm -f "$T_D0"/file-*
-
-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/get-referring-entries.sh

@@ -1,99 +0,0 @@
-
-#
-# Test _GET_REFERRING_ENTRIES ioctl via the get-referring-entries cli
-# command
-#
-
-# consistently print only entry names
-filter_names() {
-	exec cut -d ' ' -f 8- | sort
-}
-
-# print entries with type characters to match find.  not happy with hard
-# coding, but abi won't change much.
-filter_types() {
-	exec cut -d ' ' -f 5- | \
-	sed \
-		-e 's/type 1 /type p /' \
-		-e 's/type 2 /type c /' \
-		-e 's/type 4 /type d /' \
-		-e 's/type 6 /type b /' \
-		-e 's/type 8 /type f /' \
-		-e 's/type 10 /type l /' \
-		-e 's/type 12 /type s /' \
-		| \
-	sort
-}
-
-n_chars() {
-	local n="$1"
-	printf 'A%.0s' $(eval echo {1..\$n})
-}
-
-GRE="scoutfs get-referring-entries -p $T_M0"
-
-echo "== root inode returns nothing"
-$GRE 1
-
-echo "== crazy large unused inode does nothing"
-$GRE 4611686018427387904 # 1 << 62
-
-echo "== basic entry"
-touch $T_D0/file
-ino=$(stat -c '%i' $T_D0/file)
-$GRE $ino | filter_names
-
-echo "== rename"
-mv $T_D0/file $T_D0/renamed
-$GRE $ino | filter_names
-
-echo "== hard link"
-mv $T_D0/renamed $T_D0/file
-ln $T_D0/file $T_D0/link
-$GRE $ino | filter_names
-
-echo "== removal"
-rm $T_D0/file $T_D0/link
-$GRE $ino
-
-echo "== different dirs"
-touch $T_D0/file
-ino=$(stat -c '%i' $T_D0/file)
-for i in $(seq 1 10); do
-	mkdir $T_D0/dir-$i
-	ln $T_D0/file $T_D0/dir-$i/file-$i
-done
-diff -u <(find $T_D0 -type f -printf '%f\n' | sort) <($GRE $ino | filter_names)
-rm $T_D0/file
-
-echo "== file types"
-mkdir $T_D0/dir
-touch $T_D0/dir/file
-mkdir $T_D0/dir/dir
-ln -s $T_D0/dir/file $T_D0/dir/symlink
-mknod $T_D0/dir/char c 1 3 # null
-mknod $T_D0/dir/block b 7 0 # loop0
-for name in $(ls -UA $T_D0/dir | sort); do
-	ino=$(stat -c '%i' $T_D0/dir/$name)
-	$GRE $ino | filter_types
-done
-rm -rf $T_D0/dir
-
-echo "== all name lengths work"
-mkdir $T_D0/dir
-touch $T_D0/dir/file
-ino=$(stat -c '%i' $T_D0/dir/file)
-name=""
-> $T_TMP.unsorted
-for i in $(seq 1 255); do
-	name+="a"
-	echo "$name" >> $T_TMP.unsorted
-	ln $T_D0/dir/file $T_D0/dir/$name
-done
-sort $T_TMP.unsorted > $T_TMP.sorted
-rm $T_D0/dir/file
-$GRE $ino | filter_names > $T_TMP.gre
-diff -u $T_TMP.sorted $T_TMP.gre
-rm -rf $T_D0/dir
-
-t_pass