Start server commits when holds wait for alloc

Server code that wants to dirty blocks by holding a commit won't be
allowed to until the current allocators for the server transaction have
enough space for the holder.  As an active holder applies the commit the
allocators are refilled and the waiting holders will proceed.

But the current allocators can have no resources as the server starts
up.  There will never be active holders to apply the commit and refill
the allocators.  In this case all the holders will block indefinitely.

The fix is to trigger a server commit when a holder doesn't have room.
It used to be that commits were only triggered when apply callers were
waiting.  We transfer some of that logic into a new 'committing' field
so that we can have commits in flight without apply callers waiting.  We
add it to the server commit tracing.

While we're at it we clean up the logic that tests if a hold can
proceed.  It used to be confusingly split across two functions that both
could sample the current allocator space remaining.  This could lead to
weird cases where the first holder could use the second alloc remaining
call, not the one whose values were tested to see if the holder could
fit.  Now each hold check only samples the allocators once.

And finally we fix a subtle case where the budget exceeded message can
spuriously trigger in the case where dirtying the freed list created a
new empty block after the holder recorded the amount of space in the
freed block.

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

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

@@ -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
@@ -50,211 +40,6 @@ endif
 #
 # Added user_ns argument to posix_acl_valid
 #
-ifneq (,$(shell grep 'posix_acl_valid.*user_namespace' include/linux/posix_acl.h))
+ifneq (,$(shell grep 'posix_acl_valid.*user_ns,' 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

@@ -69,14 +69,12 @@ struct posix_acl *scoutfs_get_acl_locked(struct inode *inode, int type, struct s
 	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)
@@ -98,11 +96,9 @@ struct posix_acl *scoutfs_get_acl_locked(struct inode *inode, int type, struct s
 		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);
 
@@ -116,10 +112,8 @@ struct posix_acl *scoutfs_get_acl(struct inode *inode, int type)
 	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) {
@@ -189,15 +183,13 @@ int scoutfs_set_acl_locked(struct inode *inode, struct posix_acl *acl, int type,
 		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);
+			inode->i_ctime = CURRENT_TIME;
 		}
 	}
 
 out:
-#ifndef KC___POSIX_ACL_CREATE
 	if (!ret)
 		set_cached_acl(inode, type, acl);
-#endif
 
 	kfree(value);
 
@@ -226,17 +218,10 @@ int scoutfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 	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;
 
@@ -255,17 +240,9 @@ int scoutfs_acl_get_xattr(struct dentry *dentry, const char *name, void *value,
 	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;
 
@@ -324,7 +301,7 @@ int scoutfs_init_acl_locked(struct inode *inode, struct inode *dir,
 			if (ret)
 				goto out;
 		}
-		ret = __posix_acl_create(&acl, GFP_NOFS, &inode->i_mode);
+		ret = posix_acl_create(&acl, GFP_NOFS, &inode->i_mode);
 		if (ret < 0)
 			return ret;
 		if (ret > 0)
@@ -368,7 +345,7 @@ int scoutfs_acl_chmod_locked(struct inode *inode, struct iattr *attr,
 	if (IS_ERR_OR_NULL(acl))
 		return PTR_ERR(acl);
 
-	ret = __posix_acl_chmod(&acl, GFP_KERNEL, attr->ia_mode);
+	ret = posix_acl_chmod(&acl, GFP_KERNEL, attr->ia_mode);
 	if (ret)
 		return ret;
 

kmod/src/acl.h

@@ -6,19 +6,10 @@ struct posix_acl *scoutfs_get_acl_locked(struct inode *inode, int type, struct s
 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,

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;
 	}
@@ -971,7 +969,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 +1069,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,18 +1089,24 @@ 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);
 
 	recently = accessed_recently(binf);
 	rhashtable_walk_enter(&binf->ht, &iter);
@@ -1157,7 +1151,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 +1159,12 @@ static unsigned long block_scan_objects(struct shrinker *shrink, struct shrink_c
 
 	rhashtable_walk_stop(&iter);
 	rhashtable_walk_exit(&iter);
-
+out:
 	if (stop)
-		return SHRINK_STOP;
+		return -1;
 	else
-		return freed;
+		return min_t(u64, INT_MAX,
+			     (u64)atomic_read(&binf->total_inserted) * SCOUTFS_BLOCK_LG_PAGES_PER);
 }
 
 struct sm_block_completion {
@@ -1178,11 +1172,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 +1191,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 +1207,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 +1216,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 +1230,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 +1239,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 +1258,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 +1290,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 +1312,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/counters.h

@@ -30,8 +30,6 @@
 	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)		\
@@ -90,8 +88,6 @@
 	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_clear_dirty)			\
 	EXPAND_COUNTER(item_create)				\
 	EXPAND_COUNTER(item_delete)				\
@@ -125,7 +121,6 @@
 	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 +134,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)			\
@@ -238,12 +232,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/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)
@@ -558,7 +558,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);
@@ -704,7 +704,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 +729,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 +754,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 +775,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)
 {
@@ -1081,7 +1057,7 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 		goto out;
 	}
 
-	inode_lock(inode);
+	mutex_lock(&inode->i_mutex);
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
@@ -1142,7 +1118,7 @@ out_extent:
 	up_write(&si->extent_sem);
 out_mutex:
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
+	mutex_unlock(&inode->i_mutex);
 
 out:
 	trace_scoutfs_data_fallocate(sb, ino, mode, offset, len, ret);
@@ -1245,7 +1221,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;
@@ -1466,7 +1442,7 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 		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 +1529,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 +1583,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 +1783,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 +1873,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 +1881,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

@@ -65,9 +65,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.c

@@ -272,7 +272,7 @@ static void set_dentry_fsdata(struct dentry *dentry, struct scoutfs_lock *lock)
 
 static bool test_dentry_fsdata(struct dentry *dentry, u64 refresh)
 {
-	u64 fsd = (unsigned long)READ_ONCE(dentry->d_fsdata);
+	u64 fsd = (unsigned long)ACCESS_ONCE(dentry->d_fsdata);
 
 	return fsd == refresh;
 }
@@ -735,7 +735,7 @@ static int scoutfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 	set_dentry_fsdata(dentry, dir_lock);
 
 	i_size_write(dir, i_size_read(dir) + dentry->d_name.len);
-	dir->i_mtime = dir->i_ctime = current_time(inode);
+	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 	inode->i_mtime = inode->i_atime = inode->i_ctime = dir->i_mtime;
 	si->crtime = inode->i_mtime;
 	inode_inc_iversion(dir);
@@ -859,7 +859,7 @@ retry:
 	set_dentry_fsdata(dentry, dir_lock);
 
 	i_size_write(dir, dir_size);
-	dir->i_mtime = dir->i_ctime = current_time(inode);
+	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 	inode->i_ctime = dir->i_mtime;
 	inc_nlink(inode);
 	inode_inc_iversion(dir);
@@ -900,7 +900,7 @@ static int scoutfs_unlink(struct inode *dir, struct dentry *dentry)
 {
 	struct super_block *sb = dir->i_sb;
 	struct inode *inode = dentry->d_inode;
-	struct kc_timespec ts = current_time(inode);
+	struct timespec ts = current_kernel_time();
 	struct scoutfs_lock *inode_lock = NULL;
 	struct scoutfs_lock *orph_lock = NULL;
 	struct scoutfs_lock *dir_lock = NULL;
@@ -1058,7 +1058,6 @@ static int symlink_item_ops(struct super_block *sb, enum symlink_ops op, u64 ino
 	return ret;
 }
 
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 /*
  * Full a buffer with the null terminated symlink, point nd at it, and
  * return it so put_link can free it once the vfs is done.
@@ -1139,73 +1138,19 @@ static void scoutfs_put_link(struct dentry *dentry, struct nameidata *nd,
 	if (!IS_ERR_OR_NULL(cookie))
 		kfree(cookie);
 }
-#else
-static const char *scoutfs_get_link(struct dentry *dentry, struct inode *inode, struct delayed_call *done)
-{
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_lock *inode_lock = NULL;
-	char *path = NULL;
-	loff_t size;
-	int ret;
 
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ,
-				 SCOUTFS_LKF_REFRESH_INODE, inode, &inode_lock);
-	if (ret)
-		return ERR_PTR(ret);
-
-	size = i_size_read(inode);
-
-	if (size == 0 || size > SCOUTFS_SYMLINK_MAX_SIZE) {
-		scoutfs_corruption(sb, SC_SYMLINK_INODE_SIZE,
-				   corrupt_symlink_inode_size,
-				   "ino %llu size %llu",
-				   scoutfs_ino(inode), (u64)size);
-		ret = -EIO;
-		goto out;
-	}
-
-	/* unlikely, but possible I suppose */
-	if (size > PATH_MAX) {
-		ret = -ENAMETOOLONG;
-		goto out;
-	}
-
-	path = kmalloc(size, GFP_NOFS);
-	if (!path) {
-		ret = -ENOMEM;
-		goto out;
-	}
-
-	ret = symlink_item_ops(sb, SYM_LOOKUP, scoutfs_ino(inode), inode_lock,
-			       path, size);
-
-	if (ret == -ENOENT) {
-		scoutfs_corruption(sb, SC_SYMLINK_MISSING_ITEM,
-				   corrupt_symlink_missing_item,
-				   "ino %llu size %llu", scoutfs_ino(inode),
-				   size);
-		ret = -EIO;
-
-	} else if (ret == 0 && path[size - 1]) {
-		scoutfs_corruption(sb, SC_SYMLINK_NOT_NULL_TERM,
-				   corrupt_symlink_not_null_term,
-				   "ino %llu last %u",
-				   scoutfs_ino(inode), path[size - 1]);
-		ret = -EIO;
-	}
-
-	if (ret != -EIO)
-		set_delayed_call(done, kfree_link, path);
-
-out:
-	if (ret < 0) {
-		kfree(path);
-		path = ERR_PTR(ret);
-	}
-	scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
-	return path;
-}
-#endif
+const struct inode_operations scoutfs_symlink_iops = {
+	.readlink       = generic_readlink,
+	.follow_link    = scoutfs_follow_link,
+	.put_link       = scoutfs_put_link,
+	.getattr	= scoutfs_getattr,
+	.setattr	= scoutfs_setattr,
+	.setxattr	= generic_setxattr,
+	.getxattr	= generic_getxattr,
+	.listxattr	= scoutfs_listxattr,
+	.removexattr	= generic_removexattr,
+	.get_acl	= scoutfs_get_acl,
+};
 
 /*
  * Symlink target paths can be annoyingly large.  We store relatively
@@ -1259,7 +1204,7 @@ static int scoutfs_symlink(struct inode *dir, struct dentry *dentry,
 	set_dentry_fsdata(dentry, dir_lock);
 
 	i_size_write(dir, i_size_read(dir) + dentry->d_name.len);
-	dir->i_mtime = dir->i_ctime = current_time(inode);
+	dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 	inode_inc_iversion(dir);
 
 	inode->i_ctime = dir->i_mtime;
@@ -1613,7 +1558,7 @@ static int scoutfs_rename_common(struct inode *old_dir,
 	struct scoutfs_lock *orph_lock = NULL;
 	struct scoutfs_dirent new_dent;
 	struct scoutfs_dirent old_dent;
-	struct kc_timespec now;
+	struct timespec now;
 	bool ins_new = false;
 	bool del_new = false;
 	bool ins_old = false;
@@ -1779,7 +1724,7 @@ retry:
 		inc_nlink(new_dir);
 	}
 
-	now = current_time(old_inode);
+	now = CURRENT_TIME;
 	old_dir->i_ctime = now;
 	old_dir->i_mtime = now;
 	if (new_dir != old_dir) {
@@ -1866,14 +1811,12 @@ out_unlock:
 	return ret;
 }
 
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 static int scoutfs_rename(struct inode *old_dir,
 			  struct dentry *old_dentry, struct inode *new_dir,
 			  struct dentry *new_dentry)
 {
 	return scoutfs_rename_common(old_dir, old_dentry, new_dir, new_dentry, 0);
 }
-#endif
 
 static int scoutfs_rename2(struct inode *old_dir,
 			  struct dentry *old_dentry, struct inode *new_dir,
@@ -1918,7 +1861,7 @@ static int scoutfs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mod
 	if (ret < 0)
 		goto out; /* XXX returning error but items created */
 
-	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
+	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 	si->crtime = inode->i_mtime;
 	insert_inode_hash(inode);
 	ihold(inode); /* need to update inode modifications in d_tmpfile */
@@ -1943,37 +1886,6 @@ out:
 	return ret;
 }
 
-const struct inode_operations scoutfs_symlink_iops = {
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
-	.readlink       = generic_readlink,
-	.follow_link    = scoutfs_follow_link,
-	.put_link       = scoutfs_put_link,
-#else
-	.get_link	= scoutfs_get_link,
-#endif
-	.getattr	= scoutfs_getattr,
-	.setattr	= scoutfs_setattr,
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
-	.setxattr	= generic_setxattr,
-	.getxattr	= generic_getxattr,
-#endif
-	.listxattr	= scoutfs_listxattr,
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
-	.removexattr	= generic_removexattr,
-#endif
-	.get_acl	= scoutfs_get_acl,
-#ifndef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
-	.tmpfile	= scoutfs_tmpfile,
-	.rename		= scoutfs_rename_common,
-	.symlink	= scoutfs_symlink,
-	.unlink		= scoutfs_unlink,
-	.link		= scoutfs_link,
-	.mkdir		= scoutfs_mkdir,
-	.create		= scoutfs_create,
-	.lookup		= scoutfs_lookup,
-#endif
-};
-
 const struct file_operations scoutfs_dir_fops = {
 	.KC_FOP_READDIR	= scoutfs_readdir,
 #ifdef KC_FMODE_KABI_ITERATE
@@ -1985,12 +1897,9 @@ const struct file_operations scoutfs_dir_fops = {
 };
 
 
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
+
 const struct inode_operations_wrapper scoutfs_dir_iops = {
 	.ops = {
-#else
-const struct inode_operations scoutfs_dir_iops = {
-#endif
 	.lookup		= scoutfs_lookup,
 	.mknod		= scoutfs_mknod,
 	.create		= scoutfs_create,
@@ -1998,25 +1907,17 @@ const struct inode_operations scoutfs_dir_iops = {
 	.link		= scoutfs_link,
 	.unlink		= scoutfs_unlink,
 	.rmdir		= scoutfs_unlink,
+	.rename		= scoutfs_rename,
 	.getattr	= scoutfs_getattr,
 	.setattr	= scoutfs_setattr,
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
-	.rename		= scoutfs_rename,
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
-	.removexattr	= generic_removexattr,
-#endif
 	.listxattr	= scoutfs_listxattr,
+	.removexattr	= generic_removexattr,
 	.get_acl	= scoutfs_get_acl,
 	.symlink	= scoutfs_symlink,
 	.permission	= scoutfs_permission,
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 	},
-#endif
 	.tmpfile	= scoutfs_tmpfile,
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 	.rename2	= scoutfs_rename2,
-#else
-	.rename		= scoutfs_rename2,
-#endif
 };

kmod/src/dir.h

@@ -5,11 +5,7 @@
 #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;

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

@@ -143,12 +143,10 @@ void scoutfs_destroy_inode(struct inode *inode)
 static const struct inode_operations scoutfs_file_iops = {
 	.getattr	= scoutfs_getattr,
 	.setattr	= scoutfs_setattr,
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
-	.removexattr	= generic_removexattr,
-#endif
 	.listxattr	= scoutfs_listxattr,
+	.removexattr	= generic_removexattr,
 	.get_acl	= scoutfs_get_acl,
 	.fiemap		= scoutfs_data_fiemap,
 };
@@ -156,12 +154,10 @@ static const struct inode_operations scoutfs_file_iops = {
 static const struct inode_operations scoutfs_special_iops = {
 	.getattr	= scoutfs_getattr,
 	.setattr	= scoutfs_setattr,
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
-	.removexattr	= generic_removexattr,
-#endif
 	.listxattr	= scoutfs_listxattr,
+	.removexattr	= generic_removexattr,
 	.get_acl	= scoutfs_get_acl,
 };
 
@@ -178,12 +174,8 @@ static void set_inode_ops(struct inode *inode)
 		inode->i_fop = &scoutfs_file_fops;
 		break;
 	case S_IFDIR:
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 		inode->i_op = &scoutfs_dir_iops.ops;
 		inode->i_flags |= S_IOPS_WRAPPER;
-#else
-		inode->i_op = &scoutfs_dir_iops;
-#endif
 		inode->i_fop = &scoutfs_dir_fops;
 		break;
 	case S_IFLNK:
@@ -255,7 +247,7 @@ static void load_inode(struct inode *inode, struct scoutfs_inode *cinode)
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 
 	i_size_write(inode, le64_to_cpu(cinode->size));
-	inode_set_iversion_queried(inode, le64_to_cpu(cinode->version));
+	inode->i_version = le64_to_cpu(cinode->version);
 	set_nlink(inode, le32_to_cpu(cinode->nlink));
 	i_uid_write(inode, le32_to_cpu(cinode->uid));
 	i_gid_write(inode, le32_to_cpu(cinode->gid));
@@ -348,17 +340,10 @@ int scoutfs_inode_refresh(struct inode *inode, struct scoutfs_lock *lock)
 	return ret;
 }
 
-#ifdef KC_LINUX_HAVE_RHEL_IOPS_WRAPPER
 int scoutfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 		    struct kstat *stat)
 {
 	struct inode *inode = dentry->d_inode;
-#else
-int scoutfs_getattr(const struct path *path, struct kstat *stat,
-		    u32 request_mask, unsigned int query_flags)
-{
-	struct inode *inode = d_inode(path->dentry);
-#endif
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_lock *lock = NULL;
 	int ret;
@@ -399,7 +384,7 @@ static int set_inode_size(struct inode *inode, struct scoutfs_lock *lock,
 		scoutfs_inode_inc_data_version(inode);
 
 	truncate_setsize(inode, new_size);
-	inode->i_ctime = inode->i_mtime = current_time(inode);
+	inode->i_ctime = inode->i_mtime = CURRENT_TIME;
 	if (truncate)
 		si->flags |= SCOUTFS_INO_FLAG_TRUNCATE;
 	scoutfs_inode_set_data_seq(inode);
@@ -482,7 +467,8 @@ retry:
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
 	if (ret)
 		return ret;
-	ret = setattr_prepare(dentry, attr);
+
+	ret = inode_change_ok(inode, attr);
 	if (ret)
 		goto out;
 
@@ -510,9 +496,9 @@ retry:
 				scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
 
 				/* XXX callee locks instead? */
-				inode_unlock(inode);
+				mutex_unlock(&inode->i_mutex);
 				ret = scoutfs_data_wait(inode, &dw);
-				inode_lock(inode);
+				mutex_lock(&inode->i_mutex);
 
 				if (ret == 0)
 					goto retry;
@@ -764,7 +750,7 @@ struct inode *scoutfs_iget(struct super_block *sb, u64 ino, int lkf, int igf)
 		/* XXX ensure refresh, instead clear in drop_inode? */
 		si = SCOUTFS_I(inode);
 		atomic64_set(&si->last_refreshed, 0);
-		inode_set_iversion_queried(inode, 0);
+		inode->i_version = 0;
 	}
 
 	ret = scoutfs_inode_refresh(inode, lock);
@@ -812,7 +798,7 @@ static void store_inode(struct scoutfs_inode *cinode, struct inode *inode)
 	scoutfs_inode_get_onoff(inode, &online_blocks, &offline_blocks);
 
 	cinode->size = cpu_to_le64(i_size_read(inode));
-	cinode->version = cpu_to_le64(inode_peek_iversion(inode));
+	cinode->version = cpu_to_le64(inode->i_version);
 	cinode->nlink = cpu_to_le32(inode->i_nlink);
 	cinode->uid = cpu_to_le32(i_uid_read(inode));
 	cinode->gid = cpu_to_le32(i_gid_read(inode));
@@ -1489,7 +1475,7 @@ int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, d
 	inode->i_ino = ino; /* XXX overflow */
 	inode_init_owner(inode, dir, mode);
 	inode_set_bytes(inode, 0);
-	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
+	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
 	inode->i_rdev = rdev;
 	set_inode_ops(inode);
 

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
@@ -123,13 +123,8 @@ 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_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,

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);
@@ -394,7 +393,7 @@ static long scoutfs_ioc_data_wait_err(struct file *file, unsigned long arg)
 		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:
 

kmod/src/item.c

@@ -27,7 +27,6 @@
 #include "trans.h"
 #include "counters.h"
 #include "scoutfs_trace.h"
-#include "util.h"
 
 /*
  * The item cache maintains a consistent view of items that are read
@@ -77,10 +76,8 @@ struct item_cache_info {
 	/* almost always read, barely written */
 	struct super_block *sb;
 	struct item_percpu_pages __percpu *pcpu_pages;
-	KC_DEFINE_SHRINKER(shrinker);
-#ifdef KC_CPU_NOTIFIER
+	struct shrinker shrinker;
 	struct notifier_block notifier;
-#endif
 
 	/* often walked, but per-cpu refs are fast path */
 	rwlock_t rwlock;
@@ -2280,7 +2277,7 @@ int scoutfs_item_write_dirty(struct super_block *sb)
 		ret = -ENOMEM;
 		goto out;
 	}
-	list_add(&page->lru, &pages);
+	list_add(&page->list, &pages);
 
 	first = NULL;
 	prev = &first;
@@ -2293,7 +2290,7 @@ int scoutfs_item_write_dirty(struct super_block *sb)
 				ret = -ENOMEM;
 				goto out;
 			}
-			list_add(&second->lru, &pages);
+			list_add(&second->list, &pages);
 		}
 
 		/* read lock next sorted page, we're only dirty_list user */
@@ -2350,8 +2347,8 @@ int scoutfs_item_write_dirty(struct super_block *sb)
 	/* write all the dirty items into log btree blocks */
 	ret = scoutfs_forest_insert_list(sb, first);
 out:
-	list_for_each_entry_safe(page, second, &pages, lru) {
-		list_del_init(&page->lru);
+	list_for_each_entry_safe(page, second, &pages, list) {
+		list_del_init(&page->list);
 		__free_page(page);
 	}
 
@@ -2533,35 +2530,27 @@ retry:
 	put_pg(sb, right);
 }
 
-static unsigned long item_cache_count_objects(struct shrinker *shrink,
-					      struct shrink_control *sc)
-{
-	struct item_cache_info *cinf = KC_SHRINKER_CONTAINER_OF(shrink, struct item_cache_info);
-	struct super_block *sb = cinf->sb;
-
-	scoutfs_inc_counter(sb, item_cache_count_objects);
-
-	return shrinker_min_t_long((u64)(cinf->lru_pages));
-}
-
 /*
  * Shrink the size the item cache.  We're operating against the fast
  * path lock ordering and we skip pages if we can't acquire locks.  We
  * can run into dirty pages or pages with items that weren't visible to
  * the earliest active reader which must be skipped.
  */
-static unsigned long item_cache_scan_objects(struct shrinker *shrink,
-					     struct shrink_control *sc)
+static int item_lru_shrink(struct shrinker *shrink,
+			   struct shrink_control *sc)
 {
-	struct item_cache_info *cinf = KC_SHRINKER_CONTAINER_OF(shrink, struct item_cache_info);
+	struct item_cache_info *cinf = container_of(shrink,
+						    struct item_cache_info,
+						    shrinker);
 	struct super_block *sb = cinf->sb;
 	struct cached_page *tmp;
 	struct cached_page *pg;
-	unsigned long freed = 0;
 	u64 first_reader_seq;
-	int nr = sc->nr_to_scan;
+	int nr;
 
-	scoutfs_inc_counter(sb, item_cache_scan_objects);
+	if (sc->nr_to_scan == 0)
+		goto out;
+	nr = sc->nr_to_scan;
 
 	/* can't invalidate pages with items that weren't visible to first reader */
 	first_reader_seq = first_active_reader_seq(cinf);
@@ -2593,7 +2582,6 @@ static unsigned long item_cache_scan_objects(struct shrinker *shrink,
 		rbtree_erase(&pg->node, &cinf->pg_root);
 		invalidate_pcpu_page(pg);
 		write_unlock(&pg->rwlock);
-		freed++;
 
 		put_pg(sb, pg);
 
@@ -2603,11 +2591,10 @@ static unsigned long item_cache_scan_objects(struct shrinker *shrink,
 
 	write_unlock(&cinf->rwlock);
 	spin_unlock(&cinf->lru_lock);
-
-	return freed;
+out:
+	return min_t(unsigned long, cinf->lru_pages, INT_MAX);
 }
 
-#ifdef KC_CPU_NOTIFIER
 static int item_cpu_callback(struct notifier_block *nfb,
 			     unsigned long action, void *hcpu)
 {
@@ -2622,7 +2609,6 @@ static int item_cpu_callback(struct notifier_block *nfb,
 
 	return NOTIFY_OK;
 }
-#endif
 
 int scoutfs_item_setup(struct super_block *sb)
 {
@@ -2652,13 +2638,11 @@ int scoutfs_item_setup(struct super_block *sb)
 	for_each_possible_cpu(cpu)
 		init_pcpu_pages(cinf, cpu);
 
-	KC_INIT_SHRINKER_FUNCS(&cinf->shrinker, item_cache_count_objects,
-			       item_cache_scan_objects);
-	KC_REGISTER_SHRINKER(&cinf->shrinker);
-#ifdef KC_CPU_NOTIFIER
+	cinf->shrinker.shrink = item_lru_shrink;
+	cinf->shrinker.seeks = DEFAULT_SEEKS;
+	register_shrinker(&cinf->shrinker);
         cinf->notifier.notifier_call = item_cpu_callback;
         register_hotcpu_notifier(&cinf->notifier);
-#endif
 
 	sbi->item_cache_info = cinf;
 	return 0;
@@ -2678,10 +2662,8 @@ void scoutfs_item_destroy(struct super_block *sb)
 	if (cinf) {
 		BUG_ON(!list_empty(&cinf->active_list));
 
-#ifdef KC_CPU_NOTIFIER
 		unregister_hotcpu_notifier(&cinf->notifier);
-#endif
-		KC_UNREGISTER_SHRINKER(&cinf->shrinker);
+		unregister_shrinker(&cinf->shrinker);
 
 		for_each_possible_cpu(cpu)
 			drop_pcpu_pages(sb, cinf, cpu);

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
@@ -79,198 +52,4 @@ static inline int dir_emit_dots(struct file *file, void *dirent,
 #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,6 +12,7 @@
  */
 #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>
@@ -35,7 +36,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 +77,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;
@@ -1346,7 +1346,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 +1401,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 +1413,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 +1445,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 +1459,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 +1473,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)
@@ -1587,7 +1580,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 +1699,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/net.c

@@ -549,16 +549,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 +707,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 +897,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 +947,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;
 }
@@ -1054,7 +1052,7 @@ static void scoutfs_net_connect_worker(struct work_struct *work)
 
 	trace_scoutfs_net_connect_work_enter(sb, 0, 0);
 
-	ret = kc_sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
+	ret = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
 	if (ret)
 		goto out;
 
@@ -1455,7 +1453,7 @@ 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;
 
@@ -1473,18 +1471,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);

kmod/src/options.c

@@ -169,7 +169,7 @@ static int parse_options(struct super_block *sb, char *options, struct scoutfs_m
 		switch (token) {
 
 		case Opt_acl:
-			sb->s_flags |= SB_POSIXACL;
+			sb->s_flags |= MS_POSIXACL;
 			break;
 
 		case Opt_data_prealloc_blocks:
@@ -203,7 +203,7 @@ static int parse_options(struct super_block *sb, char *options, struct scoutfs_m
 			break;
 
 		case Opt_noacl:
-			sb->s_flags &= ~SB_POSIXACL;
+			sb->s_flags &= ~MS_POSIXACL;
 			break;
 
 		case Opt_orphan_scan_delay_ms:
@@ -327,7 +327,7 @@ 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);
+	const bool is_acl = !!(sb->s_flags & MS_POSIXACL);
 
 	scoutfs_options_read(sb, &opts);
 

kmod/src/quorum.c

@@ -183,7 +183,7 @@ static int create_socket(struct super_block *sb)
 	int addrlen;
 	int ret;
 
-	ret = kc_sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
+	ret = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
 	if (ret) {
 		scoutfs_err(sb, "quorum couldn't create udp socket: %d", ret);
 		goto out;
@@ -243,10 +243,8 @@ static int send_msg_members(struct super_block *sb, int type, u64 term, int only
 	};
 	struct sockaddr_in sin;
 	struct msghdr mh = {
-#ifndef KC_MSGHDR_STRUCT_IOV_ITER
 		.msg_iov = (struct iovec *)&kv,
 		.msg_iovlen = 1,
-#endif
 		.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL,
 		.msg_name = &sin,
 		.msg_namelen = sizeof(sin),
@@ -268,9 +266,6 @@ static int send_msg_members(struct super_block *sb, int type, u64 term, int only
 
 		scoutfs_quorum_slot_sin(&qinf->qconf, i, &sin);
 		now = ktime_get();
-#ifdef KC_MSGHDR_STRUCT_IOV_ITER
-		iov_iter_init(&mh.msg_iter, WRITE, (struct iovec *)&kv, sizeof(qmes), 1);
-#endif
 		ret = kernel_sendmsg(qinf->sock, &mh, &kv, 1, kv.iov_len);
 		if (ret != kv.iov_len)
 			failed++;
@@ -313,10 +308,8 @@ static int recv_msg(struct super_block *sb, struct quorum_host_msg *msg,
 		.iov_len = sizeof(struct scoutfs_quorum_message),
 	};
 	struct msghdr mh = {
-#ifndef KC_MSGHDR_STRUCT_IOV_ITER
 		.msg_iov = (struct iovec *)&kv,
 		.msg_iovlen = 1,
-#endif
 		.msg_flags = MSG_NOSIGNAL,
 	};
 
@@ -338,9 +331,6 @@ static int recv_msg(struct super_block *sb, struct quorum_host_msg *msg,
 			return ret;
 	}
 
-#ifdef KC_MSGHDR_STRUCT_IOV_ITER
-	iov_iter_init(&mh.msg_iter, READ, (struct iovec *)&kv, sizeof(struct scoutfs_quorum_message), 1);
-#endif
 	ret = kernel_recvmsg(qinf->sock, &mh, &kv, 1, kv.iov_len, mh.msg_flags);
 	if (ret < 0)
 		return ret;
@@ -729,13 +719,11 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 	struct sockaddr_in unused;
 	struct quorum_host_msg msg;
 	struct quorum_status qst = {0,};
-	struct hb_recording hbr;
+	struct hb_recording hbr = {{0,},};
 	bool record_hb;
 	int ret;
 	int err;
 
-	memset(&hbr, 0, sizeof(struct hb_recording));
-
 	/* recording votes from slots as native single word bitmap */
 	BUILD_BUG_ON(SCOUTFS_QUORUM_MAX_SLOTS > BITS_PER_LONG);
 
@@ -783,7 +771,8 @@ static void scoutfs_quorum_worker(struct work_struct *work)
 			msg.type = SCOUTFS_QUORUM_MSG_INVALID;
 
 		trace_scoutfs_quorum_loop(sb, qst.role, qst.term, qst.vote_for,
-					  qst.vote_bits, ktime_to_ns(qst.timeout));
+					  qst.vote_bits,
+					  ktime_to_timespec64(qst.timeout));
 
 		/* receiving greater terms resets term, becomes follower */
 		if (msg.type != SCOUTFS_QUORUM_MSG_INVALID &&

kmod/src/scoutfs_trace.h

@@ -1896,8 +1896,9 @@ DEFINE_EVENT(scoutfs_server_client_count_class, scoutfs_server_client_down,
 
 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),
+		 u32 avail_before, u32 freed_before, int committing, int exceeded),
+        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, committing,
+		exceeded),
         TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
 		__field(int, holding)
@@ -1905,6 +1906,7 @@ DECLARE_EVENT_CLASS(scoutfs_server_commit_users_class,
 		__field(int, nr_holders)
 		__field(__u32, avail_before)
 		__field(__u32, freed_before)
+		__field(int, committing)
 		__field(int, exceeded)
         ),
         TP_fast_assign(
@@ -1914,31 +1916,33 @@ DECLARE_EVENT_CLASS(scoutfs_server_commit_users_class,
 		__entry->nr_holders = nr_holders;
 		__entry->avail_before = avail_before;
 		__entry->freed_before = freed_before;
+		__entry->committing = !!committing;
 		__entry->exceeded = !!exceeded;
         ),
-	TP_printk(SCSBF" holding %u applying %u nr %u avail_before %u freed_before %u exceeded %u",
+	TP_printk(SCSBF" holding %u applying %u nr %u avail_before %u freed_before %u committing %u exceeded %u",
 		  SCSB_TRACE_ARGS, __entry->holding, __entry->applying, __entry->nr_holders,
-		  __entry->avail_before, __entry->freed_before, __entry->exceeded)
+		  __entry->avail_before, __entry->freed_before, __entry->committing,
+		  __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)
+		 u32 avail_before, u32 freed_before, int committing, int exceeded),
+        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, committing, 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)
+		 u32 avail_before, u32 freed_before, int committing, int exceeded),
+        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, committing, 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)
+		 u32 avail_before, u32 freed_before, int committing, int exceeded),
+        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, committing, 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)
+		 u32 avail_before, u32 freed_before, int committing, int exceeded),
+        TP_ARGS(sb, holding, applying, nr_holders, avail_before, freed_before, committing, exceeded)
 );
 
 #define slt_symbolic(mode)						\
@@ -2020,9 +2024,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 +2035,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 +2046,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,

kmod/src/server.c

@@ -67,6 +67,7 @@ struct commit_users {
 	unsigned int nr_holders;
 	u32 avail_before;
 	u32 freed_before;
+	bool committing;
 	bool exceeded;
 };
 
@@ -84,7 +85,7 @@ do {												\
 	__typeof__(cusers) _cusers = (cusers);							\
 	trace_scoutfs_server_commit_##which(sb, !list_empty(&_cusers->holding),			\
 		!list_empty(&_cusers->applying), _cusers->nr_holders, _cusers->avail_before,	\
-		_cusers->freed_before, _cusers->exceeded);					\
+		_cusers->freed_before, _cusers->committing, _cusers->exceeded);			\
 } while (0)
 
 struct server_info {
@@ -282,6 +283,14 @@ struct commit_hold {
  * per-holder allocation consumption tracking.   The best we can do is
  * flag all the current holders so that as they release we can see
  * everyone involved in crossing the limit.
+ *
+ * The consumption of space to record freed blocks is tricky.  The
+ * freed_before value was the space available as the holder started.
+ * But that happens before we actually dirty the first block in the
+ * freed list.  If that block is too full then we just allocate a new
+ * empty first block.  In that case the current remaining here can be a
+ * lot more than the initial freed_before.  We account for that and
+ * treat freed_before as the maximum capacity.
  */
 static void check_holder_budget(struct super_block *sb, struct server_info *server,
 				struct commit_users *cusers)
@@ -301,8 +310,13 @@ static void check_holder_budget(struct super_block *sb, struct server_info *serv
 		return;
 
 	scoutfs_alloc_meta_remaining(&server->alloc, &avail_now, &freed_now);
+
 	avail_used = cusers->avail_before - avail_now;
-	freed_used = cusers->freed_before - freed_now;
+	if (freed_now < cusers->freed_before)
+		freed_used = cusers->freed_before - freed_now;
+	else
+		freed_used = SCOUTFS_ALLOC_LIST_MAX_BLOCKS - freed_now;
+
 	budget = cusers->nr_holders * COMMIT_HOLD_ALLOC_BUDGET;
 	if (avail_used <= budget && freed_used <= budget)
 		return;
@@ -325,31 +339,18 @@ static void check_holder_budget(struct super_block *sb, struct server_info *serv
 /*
  * We don't have per-holder consumption.   We allow commit holders as
  * long as the total budget of all the holders doesn't exceed the alloc
- * resources that were available
+ * resources that were available.  If a hold is waiting for budget
+ * availability in the allocators then we try and kick off a commit to
+ * fill and use the next allocators after the current transaction.
  */
-static bool commit_alloc_has_room(struct server_info *server, struct commit_users *cusers,
-				  unsigned int more_holders)
-{
-	u32 avail_before;
-	u32 freed_before;
-	u32 budget;
-
-	if (cusers->nr_holders > 0) {
-		avail_before = cusers->avail_before;
-		freed_before = cusers->freed_before;
-	} else {
-		scoutfs_alloc_meta_remaining(&server->alloc, &avail_before, &freed_before);
-	}
-
-	budget = (cusers->nr_holders + more_holders) * COMMIT_HOLD_ALLOC_BUDGET;
-
-	return avail_before >= budget && freed_before >= budget;
-}
-
 static bool hold_commit(struct super_block *sb, struct server_info *server,
 			struct commit_users *cusers, struct commit_hold *hold)
 {
-	bool held = false;
+	bool has_room;
+	bool held;
+	u32 budget;
+	u32 av;
+	u32 fr;
 
 	spin_lock(&cusers->lock);
 
@@ -357,19 +358,39 @@ static bool hold_commit(struct super_block *sb, struct server_info *server,
 
 	check_holder_budget(sb, server, cusers);
 
+	if (cusers->nr_holders == 0) {
+		scoutfs_alloc_meta_remaining(&server->alloc, &av, &fr);
+	} else {
+		av = cusers->avail_before;
+		fr = cusers->freed_before;
+	}
+
 	/* +2 for our additional hold and then for the final commit work the server does */
-	if (list_empty(&cusers->applying) && commit_alloc_has_room(server, cusers, 2)) {
-		scoutfs_alloc_meta_remaining(&server->alloc, &hold->avail, &hold->freed);
+	budget = (cusers->nr_holders + 2) * COMMIT_HOLD_ALLOC_BUDGET;
+	has_room = av >= budget && fr >= budget;
+	/* checking applying so holders drain once an apply caller starts waiting */
+	held = !cusers->committing && has_room && list_empty(&cusers->applying);
+
+	if (held) {
 		if (cusers->nr_holders == 0) {
-			cusers->avail_before = hold->avail;
-			cusers->freed_before = hold->freed;
+			cusers->avail_before = av;
+			cusers->freed_before = fr;
+			hold->avail = av;
+			hold->freed = fr;
 			cusers->exceeded = false;
+		} else {
+			scoutfs_alloc_meta_remaining(&server->alloc, &hold->avail, &hold->freed);
 		}
+
 		hold->exceeded = false;
 		hold->start = ktime_get();
 		list_add_tail(&hold->entry, &cusers->holding);
+
 		cusers->nr_holders++;
-		held = true;
+
+	} else if (!has_room && cusers->nr_holders == 0 && !cusers->committing) {
+		cusers->committing = true;
+		queue_work(server->wq, &server->commit_work);
 	}
 
 	spin_unlock(&cusers->lock);
@@ -403,7 +424,6 @@ static int server_apply_commit(struct super_block *sb, struct commit_hold *hold,
 	DECLARE_SERVER_INFO(sb, server);
 	struct commit_users *cusers = &server->cusers;
 	struct timespec ts;
-	bool start_commit;
 
 	spin_lock(&cusers->lock);
 
@@ -424,12 +444,14 @@ static int server_apply_commit(struct super_block *sb, struct commit_hold *hold,
 		list_del_init(&hold->entry);
 		hold->ret = err;
 	}
-	cusers->nr_holders--;
-	start_commit = cusers->nr_holders == 0 && !list_empty(&cusers->applying);
-	spin_unlock(&cusers->lock);
 
-	if (start_commit)
+	cusers->nr_holders--;
+	if (cusers->nr_holders == 0 && !cusers->committing && !list_empty(&cusers->applying)) {
+		cusers->committing = true;
 		queue_work(server->wq, &server->commit_work);
+	}
+
+	spin_unlock(&cusers->lock);
 
 	wait_event(cusers->waitq, list_empty_careful(&hold->entry));
 	smp_rmb(); /* entry load before ret */
@@ -438,8 +460,8 @@ static int server_apply_commit(struct super_block *sb, struct commit_hold *hold,
 
 /*
  * Start a commit from the commit work.  We should only have been queued
- * while a holder is waiting to apply after all active holders have
- * finished.
+ * while there are no active holders and someone started the commit.
+ * There may or may not be blocked apply callers waiting for the result.
  */
 static int commit_start(struct super_block *sb, struct commit_users *cusers)
 {
@@ -448,7 +470,7 @@ static int commit_start(struct super_block *sb, struct commit_users *cusers)
 	/* make sure holders held off once commit started */
 	spin_lock(&cusers->lock);
 	TRACE_COMMIT_USERS(sb, cusers, start);
-	if (WARN_ON_ONCE(list_empty(&cusers->applying) || cusers->nr_holders != 0))
+	if (WARN_ON_ONCE(!cusers->committing || cusers->nr_holders != 0))
 		ret = -EINVAL;
 	spin_unlock(&cusers->lock);
 
@@ -471,6 +493,7 @@ static void commit_end(struct super_block *sb, struct commit_users *cusers, int
 	smp_wmb(); /* ret stores before list updates */
 	list_for_each_entry_safe(hold, tmp, &cusers->applying, entry)
 		list_del_init(&hold->entry);
+	cusers->committing = false;
 	spin_unlock(&cusers->lock);
 
 	wake_up(&cusers->waitq);
@@ -543,7 +566,7 @@ static void set_stable_super(struct server_info *server, struct scoutfs_super_bl
  * implement commits with a single pending work func.
  *
  * Processing paths hold the commit while they're making multiple
- * dependent changes.  When they're done and want it persistent they add
+ * dependent changes.  When they're done and want it persistent they
  * queue the commit work.  This work runs, performs the commit, and
  * wakes all the applying waiters with the result.  Readers can run
  * concurrently with these commits.
@@ -4441,7 +4464,7 @@ void scoutfs_server_stop_wait(struct super_block *sb)
 	DECLARE_SERVER_INFO(sb, server);
 
 	stop_server(server);
-	flush_work(&server->work);
+	flush_work_sync(&server->work);
 }
 
 int scoutfs_server_setup(struct super_block *sb)

kmod/src/srch.c

@@ -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>
@@ -179,7 +178,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);
@@ -486,7 +485,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	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_flags |= MS_I_VERSION | MS_POSIXACL;
 	sb->s_time_gran = 1;
 
 	/* btree blocks use long lived bh->b_data refs */
@@ -675,14 +674,14 @@ out:
 		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/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

@@ -773,7 +773,7 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 
 	/* XXX do these want i_mutex or anything? */
 	inode_inc_iversion(inode);
-	inode->i_ctime = current_time(inode);
+	inode->i_ctime = CURRENT_TIME;
 	ret = 0;
 
 out:
@@ -850,7 +850,6 @@ unlock:
 	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
@@ -858,41 +857,22 @@ unlock:
  * 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)
+static const char *full_name_hack(void *handler, const char *name, int len)
 {
 	return name - len;
 }
-#endif
 
-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)
+static int scoutfs_xattr_get_handler(struct dentry *dentry, const char *name,
+				     void *value, size_t size, int handler_flags)
 {
-	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
+	name = full_name_hack(NULL, name, handler_flags);
 	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)
+static int scoutfs_xattr_set_handler(struct dentry *dentry, const char *name,
+				     const void *value, size_t size, int flags, int handler_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
+	name = full_name_hack(NULL, name, handler_flags);
 	return scoutfs_xattr_set(dentry, name, value, size, flags);
 }
 
@@ -925,22 +905,14 @@ static const struct xattr_handler scoutfs_xattr_security_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,

tests/funcs/filter.sh

@@ -85,8 +85,5 @@ t_filter_dmesg()
 	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/golden/basic-posix-consistency

@@ -47,7 +47,7 @@ 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

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/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/xfstests

@@ -241,6 +241,7 @@ generic/312
 generic/314
 generic/316
 generic/317
+generic/318
 generic/324
 generic/326
 generic/327

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

tests/src/handle_fsetxattr.c

@@ -48,7 +48,7 @@ struct our_handle {
 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"
+	       " -e            keep trying on enoent, 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"
@@ -149,7 +149,7 @@ int main(int argc, char **argv)
 
 				fd = open_by_handle_at(mntfd, &handle.handle, O_RDWR);
 				if (fd == -1) {
-					if (!enoent_success_err || ( errno != ENOENT && errno != ESTALE )) {
+					if (!enoent_success_err || errno != ENOENT) {
 						perror("open_by_handle_at");
 						return 1;
 					}

tests/tests/data-prealloc.sh

@@ -95,7 +95,7 @@ print_logical_extents()
 			}
 			print $2, $6, flags
 		}
-	' | sed 's/last,eof/eof/'
+	'
 }
 
 t_save_all_sysfs_mount_options data_prealloc_blocks

tests/tests/inode-deletion.sh

@@ -72,7 +72,7 @@ check_ino_index "$ino" "$dseq" "$T_M0"
 check_ino_index "$ino" "$dseq" "$T_M1"
 exec {FD}>&-  # close
 # we know that revalidating will unhash the remote dentry
-stat "$T_D0/file" 2>&1 | sed 's/cannot statx/cannot stat/' | t_filter_fs
+stat "$T_D0/file" 2>&1 | t_filter_fs
 check_ino_index "$ino" "$dseq" "$T_M0"
 check_ino_index "$ino" "$dseq" "$T_M1"
 

tests/tests/setattr_more.sh

@@ -55,17 +55,10 @@ scoutfs setattr -t 67305985.999999999 -V 1 -s 1 "$FILE" 2>&1 | t_filter_fs
 TZ=GMT stat -c "%z" "$FILE"
 rm "$FILE"
 
-#
-# With e2fsprogs-v1.42.10-10-g29758d2f, the output of filefrag 'flags' changes
-# significantly. First, the _LAST flag is now output. Second, the 'unknown'
-# flag is now printed out as 'unknown_loc'. To compensate for this, we check
-# and replace the "correct" output for new versions here with the expected
-# value.
-#
 echo "== large offline extents are created"
 touch "$FILE"
 scoutfs setattr -V 1 -o -s $((10007 * 4096)) "$FILE" 2>&1 | t_filter_fs
-filefrag -v -b4096 "$FILE" 2>&1 | sed 's/last,unknown_loc,eof$/unknown,eof/' | t_filter_fs
+filefrag -v -b4096 "$FILE" 2>&1 | t_filter_fs
 rm "$FILE"
 
 # had a bug where we were creating extents that were too long

tests/tests/simple-xattr-unit.sh

@@ -27,9 +27,15 @@ test_xattr_lengths() {
 	echo "key len $name_len val len $val_len" >> "$T_TMP.log"
 	setfattr -n $name -v \"$val\" "$FILE"
 
-	getfattr -d --only-values --absolute-names "$FILE" -n "$name" > "$T_TMP.got"
-	echo -n "$val" > "$T_TMP.good"
+	# grep has trouble with enormous args?  so we dump the
+	# name=value to a file and compare with a known good file
+	getfattr -d --absolute-names "$FILE" | grep "$name" > "$T_TMP.got"
 
+	if [ $val_len == 0 ]; then
+		echo "$name" > "$T_TMP.good"
+	else
+		echo "$name=\"$val\"" > "$T_TMP.good"
+	fi
 	cmp "$T_TMP.good" "$T_TMP.got" || \
 		t_fail "cmp failed name len $name_len val len $val_len"
 

tests/tests/xfstests.sh

@@ -75,7 +75,6 @@ generic/215	# mmap missing
 generic/246	# mmap missing
 generic/247	# mmap missing
 generic/248	# mmap missing
-generic/318	# can't support user namespaces until v5.11
 generic/321	# requires selinux enabled for '+' in ls?
 generic/325	# mmap missing
 generic/338	# BUG_ON update inode error handling

utils/scoutfs-utils.spec.in

@@ -61,7 +61,7 @@ install -m 644 -D fenced/scoutfs-fenced.conf.example $RPM_BUILD_ROOT%{_sysconfdi
 %files
 %defattr(644,root,root,755)
 %{_mandir}/man*/scoutfs*.gz
-/%{_unitdir}/scoutfs-fenced.service
+%{_unitdir}/scoutfs-fenced.service
 %{_sysconfdir}/scoutfs
 %defattr(755,root,root,755)
 %{_sbindir}/scoutfs