Add nr_log_trees debugfs counter

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

ReleaseNotes.md

@@ -1,50 +1,6 @@
 Versity ScoutFS Release Notes
 =============================
 
----
-v1.21
-\
-*Jul 1, 2024*
-
-This release adds features that rely on incompatible changes to
-structure the file system.  The process of advancing the format version
-to enable these features is described in scoutfs(5).
-
-Added the ".indx." extended attribute tag which can be used to determine
-the sorting of files in a global index.
-
-Added ScoutFS quotas which let rules define file size and count limits
-in terms of ".totl." extended attribute totals.
-
-Added the project ID file attribute which is inherited from parent
-directories on creation.  ScoutFS quota rules can reference project IDs.
-
-Add a retention attribute for files which prevents modification once
-enabled.
-
----
-v1.20
-\
-*Apr 22, 2024*
-
-Minor changes to packaging to better support "weak" module linking of
-the kernel module, and to including git hashes in the built package.  No
-changes in runtime behaviour.
-
----
-v1.19
-\
-*Jan 30, 2024*
-
-Added the log\_merge\_wait\_timeout\_ms mount option to set the timeout
-for creating log merge operations.  The previous timeout, now the
-default, was too short for some systems and was resulting in consistent
-timeouts which created an excessive number of log trees waiting to be
-merged.
-
-Improved performance of many in-mount server operations when there are a
-large number of log trees waiting to be merged.
-
 ---
 v1.18
 \

kmod/Makefile

@@ -12,22 +12,17 @@ else
 SP = @:
 endif
 
-SCOUTFS_GIT_DESCRIBE ?= \
+SCOUTFS_GIT_DESCRIBE := \
 	$(shell git describe --all --abbrev=6 --long 2>/dev/null || \
 		echo no-git)
 
-ESCAPED_GIT_DESCRIBE := \
-	$(shell echo $(SCOUTFS_GIT_DESCRIBE) |sed -e 's/\//\\\//g')
-
-RPM_GITHASH ?= $(shell git rev-parse --short HEAD)
-
 SCOUTFS_ARGS := SCOUTFS_GIT_DESCRIBE=$(SCOUTFS_GIT_DESCRIBE) \
-		RPM_GITHASH=$(RPM_GITHASH) \
 		CONFIG_SCOUTFS_FS=m -C $(SK_KSRC) M=$(CURDIR)/src \
 		EXTRA_CFLAGS="-Werror"
 
 # - We use the git describe from tags to set up the RPM versioning
 RPM_VERSION := $(shell git describe --long --tags | awk -F '-' '{gsub(/^v/,""); print $$1}')
+RPM_GITHASH := $(shell git rev-parse --short HEAD)
 TARFILE = scoutfs-kmod-$(RPM_VERSION).tar
 
 
@@ -46,8 +41,7 @@ modules_install:
 
 %.spec: %.spec.in .FORCE
 	sed -e 's/@@VERSION@@/$(RPM_VERSION)/g' \
-	    -e 's/@@GITHASH@@/$(RPM_GITHASH)/g' \
-	    -e 's/@@GITDESCRIBE@@/$(ESCAPED_GIT_DESCRIBE)/g' < $< > $@+
+	    -e 's/@@GITHASH@@/$(RPM_GITHASH)/g' < $< > $@+
 	mv $@+ $@
 
 

kmod/scoutfs-kmod.spec.in

@@ -1,7 +1,6 @@
 %define kmod_name scoutfs
 %define kmod_version @@VERSION@@
 %define kmod_git_hash @@GITHASH@@
-%define kmod_git_describe @@GITDESCRIBE@@
 %define pkg_date %(date +%%Y%%m%%d)
 
 # Disable the building of the debug package(s).
@@ -76,7 +75,7 @@ echo "Building for kernel: %{kernel_version} flavors: '%{flavors_to_build}'"
 for flavor in %flavors_to_build; do
     rm -rf obj/$flavor
     cp -r source obj/$flavor
-    make RPM_GITHASH=%{kmod_git_hash} SCOUTFS_GIT_DESCRIBE=%{kmod_git_describe} SK_KSRC=%{kernel_source $flavor} -C obj/$flavor module
+    make SK_KSRC=%{kernel_source $flavor} -C obj/$flavor module
 done
 
 %install
@@ -98,21 +97,10 @@ find %{buildroot} -type f -name \*.ko -exec %{__chmod} u+x \{\} \;
 /lib/modules
 
 %post
-echo /lib/modules/%{kversion}/%{install_mod_dir}/scoutfs.ko | weak-modules --add-modules --no-initramfs
+weak-modules --add-kernel --no-initramfs
 depmod -a
 %endif
 
 %clean
 rm -rf %{buildroot}
 
-%preun
-# stash our modules for postun cleanup
-SCOUTFS_RPM_NAME=$(rpm -q %{name} | grep "%{version}-%{release}")
-rpm -ql $SCOUTFS_RPM_NAME | grep '\.ko$' > /var/run/%{name}-modules-%{version}-%{release} || true
-
-%postun
-if [ -x /sbin/weak-modules ]; then
-    cat /var/run/%{name}-modules-%{version}-%{release} | /sbin/weak-modules --remove-modules --no-initramfs
-fi
-
-rm /var/run/%{name}-modules-%{version}-%{release} || true

kmod/src/Makefile

@@ -9,7 +9,6 @@ CFLAGS_scoutfs_trace.o = -I$(src) # define_trace.h double include
  
 scoutfs-y +=			\
 	acl.o			\
-	attr_x.o		\
 	avl.o			\
 	alloc.o			\
 	block.o			\
@@ -35,7 +34,6 @@ scoutfs-y +=			\
 	options.o		\
 	per_task.o		\
 	quorum.o		\
-	quota.o			\
 	recov.o			\
 	scoutfs_trace.o		\
 	server.o		\
@@ -44,12 +42,10 @@ scoutfs-y +=			\
 	srch.o			\
 	super.o			\
 	sysfs.o			\
-	totl.o			\
 	trans.o			\
 	triggers.o		\
 	tseq.o			\
 	volopt.o		\
-	wkic.o			\
 	xattr.o
 
 #

kmod/src/attr_x.c

@@ -1,252 +0,0 @@
-/*
- * Copyright (C) 2024 Versity Software, Inc.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-#include <linux/kernel.h>
-#include <linux/fs.h>
-
-#include "format.h"
-#include "super.h"
-#include "inode.h"
-#include "ioctl.h"
-#include "lock.h"
-#include "trans.h"
-#include "attr_x.h"
-
-static int validate_attr_x_input(struct super_block *sb, struct scoutfs_ioctl_inode_attr_x *iax)
-{
-	int ret;
-
-	if ((iax->x_mask & SCOUTFS_IOC_IAX__UNKNOWN) ||
-	    (iax->x_flags & SCOUTFS_IOC_IAX_F__UNKNOWN))
-		return -EINVAL;
-
-	if ((iax->x_mask & SCOUTFS_IOC_IAX_RETENTION) &&
-	    (ret = scoutfs_fmt_vers_unsupported(sb, SCOUTFS_FORMAT_VERSION_FEAT_RETENTION)))
-		    return ret;
-
-	if ((iax->x_mask & SCOUTFS_IOC_IAX_PROJECT_ID) &&
-	    (ret = scoutfs_fmt_vers_unsupported(sb, SCOUTFS_FORMAT_VERSION_FEAT_PROJECT_ID)))
-		    return ret;
-
-	return 0;
-}
-
-/*
- * If the mask indicates interest in the given attr then set the field
- * to the caller's value and return the new size if it didn't already
- * include the attr field.
- */
-#define fill_attr(size, iax, bit, field, val)							\
-({												\
-	__typeof__(iax) _iax = (iax);								\
-	__typeof__(size) _size = (size);							\
-												\
-	if (_iax->x_mask & (bit)) {								\
-		_iax->field = (val);								\
-		_size = max(_size, offsetof(struct scoutfs_ioctl_inode_attr_x, field) +		\
-				   sizeof_field(struct scoutfs_ioctl_inode_attr_x, field));	\
-	}											\
-												\
-	_size;											\
-})
-
-/*
- * Returns -errno on error, or >= number of bytes filled by the
- * response.  0 can be returned if no attributes are requested in the
- * input x_mask.
- */
-int scoutfs_get_attr_x(struct inode *inode, struct scoutfs_ioctl_inode_attr_x *iax)
-{
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	struct scoutfs_lock *lock = NULL;
-	size_t size = 0;
-	u64 offline;
-	u64 online;
-	u64 bits;
-	int ret;
-
-	if (iax->x_mask == 0) {
-		ret = 0;
-		goto out;
-	}
-
-	ret = validate_attr_x_input(sb, iax);
-	if (ret < 0)
-		goto out;
-
-	inode_lock(inode);
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ, SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
-	if (ret)
-		goto unlock;
-
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_META_SEQ,
-			 meta_seq, scoutfs_inode_meta_seq(inode));
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_DATA_SEQ,
-			 data_seq, scoutfs_inode_data_seq(inode));
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_DATA_VERSION,
-			 data_version, scoutfs_inode_data_version(inode));
-	if (iax->x_mask & (SCOUTFS_IOC_IAX_ONLINE_BLOCKS | SCOUTFS_IOC_IAX_OFFLINE_BLOCKS)) {
-		scoutfs_inode_get_onoff(inode, &online, &offline);
-		size = fill_attr(size, iax, SCOUTFS_IOC_IAX_ONLINE_BLOCKS,
-				 online_blocks, online);
-		size = fill_attr(size, iax, SCOUTFS_IOC_IAX_OFFLINE_BLOCKS,
-				 offline_blocks, offline);
-	}
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_CTIME, ctime_sec, inode->i_ctime.tv_sec);
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_CTIME, ctime_nsec, inode->i_ctime.tv_nsec);
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_CRTIME, crtime_sec, si->crtime.tv_sec);
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_CRTIME, crtime_nsec, si->crtime.tv_nsec);
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_SIZE, size, i_size_read(inode));
-	if (iax->x_mask & SCOUTFS_IOC_IAX__BITS) {
-		bits = 0;
-		if ((iax->x_mask & SCOUTFS_IOC_IAX_RETENTION) &&
-		    (scoutfs_inode_get_flags(inode) & SCOUTFS_INO_FLAG_RETENTION))
-			bits |= SCOUTFS_IOC_IAX_B_RETENTION;
-		size = fill_attr(size, iax, SCOUTFS_IOC_IAX__BITS, bits, bits);
-	}
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_PROJECT_ID,
-			 project_id, scoutfs_inode_get_proj(inode));
-
-	ret = size;
-unlock:
-	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
-	inode_unlock(inode);
-out:
-	return ret;
-}
-
-static bool valid_attr_changes(struct inode *inode, struct scoutfs_ioctl_inode_attr_x *iax)
-{
-	/* provided data_version must be non-zero */
-	if ((iax->x_mask & SCOUTFS_IOC_IAX_DATA_VERSION) && (iax->data_version == 0))
-		return false;
-
-	/* can only set size or data version in new regular files */
-	if (((iax->x_mask & SCOUTFS_IOC_IAX_SIZE) ||
-	     (iax->x_mask & SCOUTFS_IOC_IAX_DATA_VERSION)) &&
-	    (!S_ISREG(inode->i_mode) || scoutfs_inode_data_version(inode) != 0))
-		return false;
-
-	/* must provide non-zero data_version with non-zero size */
-	if (((iax->x_mask & SCOUTFS_IOC_IAX_SIZE) && (iax->size > 0)) &&
-	    (!(iax->x_mask & SCOUTFS_IOC_IAX_DATA_VERSION) || (iax->data_version == 0)))
-		return false;
-
-	/* must provide non-zero size when setting offline extents to that size */
-	if ((iax->x_flags & SCOUTFS_IOC_IAX_F_SIZE_OFFLINE) &&
-	    (!(iax->x_mask & SCOUTFS_IOC_IAX_SIZE) || (iax->size == 0)))
-		return false;
-
-	/* the retention bit only applies to regular files */
-	if ((iax->x_mask & SCOUTFS_IOC_IAX_RETENTION) && !S_ISREG(inode->i_mode))
-		return false;
-
-	return true;
-}
-
-int scoutfs_set_attr_x(struct inode *inode, struct scoutfs_ioctl_inode_attr_x *iax)
-{
-	struct super_block *sb = inode->i_sb;
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	struct scoutfs_lock *lock = NULL;
-	LIST_HEAD(ind_locks);
-	bool set_data_seq;
-	int ret;
-
-	/* initially all setting is root only, could loosen with finer grained checks */
-	if (!capable(CAP_SYS_ADMIN)) {
-		ret = -EPERM;
-		goto out;
-	}
-
-	if (iax->x_mask == 0) {
-		ret = 0;
-		goto out;
-	}
-
-	ret = validate_attr_x_input(sb, iax);
-	if (ret < 0)
-		goto out;
-
-	inode_lock(inode);
-
-	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE, SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
-	if (ret)
-		goto unlock;
-
-	/* check for errors before making any changes */
-	if (!valid_attr_changes(inode, iax)) {
-		ret = -EINVAL;
-		goto unlock;
-	}
-
-	/* retention prevents modification unless also clearing retention */
-	ret = scoutfs_inode_check_retention(inode);
-	if (ret < 0 && !((iax->x_mask & SCOUTFS_IOC_IAX_RETENTION) &&
-			 !(iax->bits & SCOUTFS_IOC_IAX_B_RETENTION)))
-		goto unlock;
-
-	/* setting only so we don't see 0 data seq with nonzero data_version */
-	if ((iax->x_mask & SCOUTFS_IOC_IAX_DATA_VERSION) && (iax->data_version > 0))
-		set_data_seq = true;
-	else
-		set_data_seq = false;
-
-	ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, set_data_seq, true);
-	if (ret)
-		goto unlock;
-
-	ret = scoutfs_dirty_inode_item(inode, lock);
-	if (ret < 0)
-		goto release;
-
-	/* creating offline extent first, it might fail */
-	if (iax->x_flags & SCOUTFS_IOC_IAX_F_SIZE_OFFLINE) {
-		ret = scoutfs_data_init_offline_extent(inode, iax->size, lock);
-		if (ret)
-			goto release;
-	}
-
-	/* make all changes once they're all checked and will succeed */
-	if (iax->x_mask & SCOUTFS_IOC_IAX_DATA_VERSION)
-		scoutfs_inode_set_data_version(inode, iax->data_version);
-	if (iax->x_mask & SCOUTFS_IOC_IAX_SIZE)
-		i_size_write(inode, iax->size);
-	if (iax->x_mask & SCOUTFS_IOC_IAX_CTIME) {
-		inode->i_ctime.tv_sec = iax->ctime_sec;
-		inode->i_ctime.tv_nsec = iax->ctime_nsec;
-	}
-	if (iax->x_mask & SCOUTFS_IOC_IAX_CRTIME) {
-		si->crtime.tv_sec = iax->crtime_sec;
-		si->crtime.tv_nsec = iax->crtime_nsec;
-	}
-	if (iax->x_mask & SCOUTFS_IOC_IAX_RETENTION) {
-		scoutfs_inode_set_flags(inode, ~SCOUTFS_INO_FLAG_RETENTION,
-					(iax->bits & SCOUTFS_IOC_IAX_B_RETENTION) ?
-					SCOUTFS_INO_FLAG_RETENTION : 0);
-	}
-	if (iax->x_mask & SCOUTFS_IOC_IAX_PROJECT_ID)
-		scoutfs_inode_set_proj(inode, iax->project_id);
-
-	scoutfs_update_inode_item(inode, lock, &ind_locks);
-	ret = 0;
-release:
-	scoutfs_release_trans(sb);
-unlock:
-	scoutfs_inode_index_unlock(sb, &ind_locks);
-	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
-	inode_unlock(inode);
-out:
-	return ret;
-}

kmod/src/attr_x.h

@@ -1,11 +0,0 @@
-#ifndef _SCOUTFS_ATTR_X_H_
-#define _SCOUTFS_ATTR_X_H_
-
-#include <linux/kernel.h>
-#include <linux/fs.h>
-#include "ioctl.h"
-
-int scoutfs_get_attr_x(struct inode *inode, struct scoutfs_ioctl_inode_attr_x *iax);
-int scoutfs_set_attr_x(struct inode *inode, struct scoutfs_ioctl_inode_attr_x *iax);
-
-#endif

kmod/src/block.c

@@ -683,7 +683,6 @@ int scoutfs_block_read_ref(struct super_block *sb, struct scoutfs_block_ref *ref
 	struct scoutfs_block_header *hdr;
 	struct block_private *bp = NULL;
 	bool retried = false;
-	__le32 crc = 0;
 	int ret;
 
 retry:
@@ -696,9 +695,7 @@ retry:
 
 	/* corrupted writes might be a sign of a stale reference */
 	if (!test_bit(BLOCK_BIT_CRC_VALID, &bp->bits)) {
-		crc = block_calc_crc(hdr, SCOUTFS_BLOCK_LG_SIZE);
-		if (hdr->crc != crc) {
-			trace_scoutfs_block_stale(sb, ref, hdr, magic, le32_to_cpu(crc));
+		if (hdr->crc != block_calc_crc(hdr, SCOUTFS_BLOCK_LG_SIZE)) {
 			ret = -ESTALE;
 			goto out;
 		}
@@ -708,7 +705,6 @@ retry:
 
 	if (hdr->magic != cpu_to_le32(magic) || hdr->fsid != cpu_to_le64(sbi->fsid) ||
 	    hdr->seq != ref->seq || hdr->blkno != ref->blkno) {
-		trace_scoutfs_block_stale(sb, ref, hdr, magic, 0);
 		ret = -ESTALE;
 		goto out;
 	}

kmod/src/btree.c

@@ -2029,253 +2029,187 @@ int scoutfs_btree_rebalance(struct super_block *sb,
 			  key, SCOUTFS_BTREE_MAX_VAL_LEN, NULL, NULL, NULL);
 }
 
-struct merged_range {
-	struct scoutfs_key start;
-	struct scoutfs_key end;
-	struct rb_root root;
-	int size;
-};
-
-struct merged_item {
+struct merge_pos {
 	struct rb_node node;
-	struct scoutfs_key key;
+	struct scoutfs_btree_root *root;
+	struct scoutfs_block *bl;
+	struct scoutfs_btree_block *bt;
+	struct scoutfs_avl_node *avl;
+	struct scoutfs_key *key;
 	u64 seq;
 	u8 flags;
 	unsigned int val_len;
-	u8 val[0];
+	u8 *val;
 };
 
-static inline struct merged_item *mitem_container(struct rb_node *node)
+static struct merge_pos *first_mpos(struct rb_root *root)
 {
-	return node ? container_of(node, struct merged_item, node) : NULL;
-}
-
-static inline struct merged_item *first_mitem(struct rb_root *root)
-{
-	return mitem_container(rb_first(root));
-}
-
-static inline struct merged_item *last_mitem(struct rb_root *root)
-{
-	return mitem_container(rb_last(root));
-}
-
-static inline struct merged_item *next_mitem(struct merged_item *mitem)
-{
-	return mitem_container(mitem ? rb_next(&mitem->node) : NULL);
-}
-
-static inline struct merged_item *prev_mitem(struct merged_item *mitem)
-{
-	return mitem_container(mitem ? rb_prev(&mitem->node) : NULL);
-}
-
-static struct merged_item *find_mitem(struct rb_root *root, struct scoutfs_key *key,
-				      struct rb_node **parent_ret, struct rb_node ***link_ret)
-{
-	struct rb_node **node = &root->rb_node;
-	struct rb_node *parent = NULL;
-	struct merged_item *mitem;
-	int cmp;
-
-	while (*node) {
-		parent = *node;
-		mitem = container_of(*node, struct merged_item, node);
-
-		cmp = scoutfs_key_compare(key, &mitem->key);
-
-		if (cmp < 0) {
-			node = &(*node)->rb_left;
-		} else if (cmp > 0) {
-			node = &(*node)->rb_right;
-		} else {
-			*parent_ret = NULL;
-			*link_ret = NULL;
-			return mitem;
-		}
-	}
-
-	*parent_ret = parent;
-	*link_ret = node;
+	struct rb_node *node = rb_first(root);
+	if (node)
+		 return container_of(node, struct merge_pos, node);
 	return NULL;
 }
 
-static void insert_mitem(struct merged_range *rng, struct merged_item *mitem,
-			 struct rb_node *parent, struct rb_node **link)
+static struct merge_pos *next_mpos(struct merge_pos *mpos)
 {
-	rb_link_node(&mitem->node, parent, link);
-	rb_insert_color(&mitem->node, &rng->root);
-	rng->size += item_len_bytes(mitem->val_len);
+	struct rb_node *node;
+
+	if (mpos && (node = rb_next(&mpos->node)))
+		return container_of(node, struct merge_pos, node);
+	else
+		return NULL;
 }
 
-static void replace_mitem(struct merged_range *rng, struct merged_item *victim,
-				struct merged_item *new)
+static void free_mpos(struct super_block *sb, struct merge_pos *mpos)
 {
-	rb_replace_node(&victim->node, &new->node, &rng->root);
-	RB_CLEAR_NODE(&victim->node);
-	rng->size -= item_len_bytes(victim->val_len);
-	rng->size += item_len_bytes(new->val_len);
+	scoutfs_block_put(sb, mpos->bl);
+	kfree(mpos);
 }
 
-static void free_mitem(struct merged_range *rng, struct merged_item *mitem)
+static void insert_mpos(struct rb_root *pos_root, struct merge_pos *ins)
 {
-	if (IS_ERR_OR_NULL(mitem))
-		return;
+	struct rb_node **node = &pos_root->rb_node;
+	struct rb_node *parent = NULL;
+	struct merge_pos *mpos;
+	int cmp;
 
-	if (!RB_EMPTY_NODE(&mitem->node)) {
-		rng->size -= item_len_bytes(mitem->val_len);
-		rb_erase(&mitem->node, &rng->root);
+	parent = NULL;
+	while (*node) {
+		parent = *node;
+		mpos = container_of(*node, struct merge_pos, node);
+
+		/* sort merge items by key then newest to oldest */
+		cmp = scoutfs_key_compare(ins->key, mpos->key) ?:
+		      -scoutfs_cmp(ins->seq, mpos->seq);
+
+		if (cmp < 0)
+			node = &(*node)->rb_left;
+		else
+			node = &(*node)->rb_right;
 	}
 
-	kfree(mitem);
-}
-
-static void trim_range_size(struct merged_range *rng, int merge_window)
-{
-	struct merged_item *mitem;
-	struct merged_item *tmp;
-
-	mitem = last_mitem(&rng->root);
-	while (mitem && rng->size > merge_window) {
-
-		rng->end = mitem->key;
-		scoutfs_key_dec(&rng->end);
-
-		tmp = mitem;
-		mitem = prev_mitem(mitem);
-		free_mitem(rng, tmp);
-	}
-}
-
-static void trim_range_end(struct merged_range *rng)
-{
-	struct merged_item *mitem;
-	struct merged_item *tmp;
-
-	mitem = last_mitem(&rng->root);
-	while (mitem && scoutfs_key_compare(&mitem->key, &rng->end) > 0) {
-		tmp = mitem;
-		mitem = prev_mitem(mitem);
-		free_mitem(rng, tmp);
-	}
+	rb_link_node(&ins->node, parent, node);
+	rb_insert_color(&ins->node, pos_root);
 }
 
 /*
- * Record and combine logged items from log roots for merging with the
- * writable destination root.  The caller is responsible for trimming
- * the range if it gets too large or if the key range shrinks.
+ * Find the next item in the merge_pos root in the caller's range and
+ * insert it into the rbtree sorted by key and version so that merging
+ * can find the next newest item at the front of the rbtree.  We free
+ * the mpos on error or if there are no more items in the range.
  */
-static int merge_read_item(struct super_block *sb, struct scoutfs_key *key, u64 seq, u8 flags,
-			   void *val, int val_len, void *arg)
+static int reset_mpos(struct super_block *sb, struct rb_root *pos_root, struct merge_pos *mpos,
+		      struct scoutfs_key *start, struct scoutfs_key *end)
 {
-	struct merged_range *rng = arg;
-	struct merged_item *mitem;
-	struct merged_item *found;
-	struct rb_node *parent;
-	struct rb_node **link;
-	int ret;
+	struct scoutfs_btree_item *item;
+	struct scoutfs_avl_node *next;
+	struct btree_walk_key_range kr;
+	struct scoutfs_key walk_key;
+	int ret = 0;
 
-	found = find_mitem(&rng->root, key, &parent, &link);
-	if (found) {
-		ret = scoutfs_forest_combine_deltas(key, found->val, found->val_len, val, val_len);
-		if (ret < 0)
-			goto out;
-		if (ret > 0) {
-			if (ret == SCOUTFS_DELTA_COMBINED) {
-				scoutfs_inc_counter(sb, btree_merge_delta_combined);
-			} else if (ret == SCOUTFS_DELTA_COMBINED_NULL) {
-				scoutfs_inc_counter(sb, btree_merge_delta_null);
-				free_mitem(rng, found);
-			}
-			ret = 0;
-			goto out;
-		}
-
-		if (found->seq >= seq) {
-			ret = 0;
-			goto out;
-		}
+	/* always erase before freeing or inserting */
+	if (!RB_EMPTY_NODE(&mpos->node)) {
+		rb_erase(&mpos->node, pos_root);
+		RB_CLEAR_NODE(&mpos->node);
 	}
 
-	mitem = kmalloc(offsetof(struct merged_item, val[val_len]), GFP_NOFS);
-	if (!mitem) {
-		ret = -ENOMEM;
+	/*
+	 * advance to next item via the avl tree.   The caller's pos is
+	 * only ever incremented past the last key so we can use next to
+	 * iterate rather than using search to skip past multiple items.
+	 */
+	if (mpos->avl)
+		mpos->avl = scoutfs_avl_next(&mpos->bt->item_root, mpos->avl);
+
+	/* find the next leaf with the key if we run out of items */
+	walk_key = *start;
+	while (!mpos->avl && !scoutfs_key_is_zeros(&walk_key)) {
+		scoutfs_block_put(sb, mpos->bl);
+		mpos->bl = NULL;
+		ret = btree_walk(sb, NULL, NULL, mpos->root, BTW_NEXT, &walk_key,
+				 0, &mpos->bl, &kr, NULL);
+		if (ret < 0) {
+			if (ret == -ENOENT)
+				ret = 0;
+			free_mpos(sb, mpos);
+			goto out;
+		}
+		mpos->bt = mpos->bl->data;
+
+		mpos->avl = scoutfs_avl_search(&mpos->bt->item_root, cmp_key_item,
+					       start, NULL, NULL, &next, NULL) ?: next;
+		if (mpos->avl == NULL)
+			walk_key = kr.iter_next;
+	}
+
+	/* see if we're out of items within the range */
+	item = node_item(mpos->avl);
+	if (!item || scoutfs_key_compare(item_key(item), end) > 0) {
+		free_mpos(sb, mpos);
+		ret = 0;
 		goto out;
 	}
 
-	mitem->key = *key;
-	mitem->seq = seq;
-	mitem->flags = flags;
-	mitem->val_len = val_len;
-	if (val_len)
-		memcpy(mitem->val, val, val_len);
-
-	if (found) {
-		replace_mitem(rng, found, mitem);
-		free_mitem(rng, found);
-	} else {
-		insert_mitem(rng, mitem, parent, link);
-	}
+	/* insert the next item within range at its version */
+	mpos->key = item_key(item);
+	mpos->seq = le64_to_cpu(item->seq);
+	mpos->flags = item->flags;
+	mpos->val_len = item_val_len(item);
+	mpos->val = item_val(mpos->bt, item);
 
+	insert_mpos(pos_root, mpos);
 	ret = 0;
 out:
 	return ret;
 }
 
 /*
- * Read a range of merged items.  The caller has set the key bounds of
- * the range.  We read a merge window's worth of items from blocks in
- * each input btree.
+ * The caller has reset all the merge positions for all the input log
+ * btree roots and wants the next logged item it should try and merge
+ * with the items in the fs_root.
  *
- * The caller can only use the smallest range that overlaps with all the
- * blocks that we read.  We start reading from the range's start key so
- * it will always be present and we don't need to adjust it.  The final
- * block we read from each input might not cover the range's end so it
- * needs to be adjusted.
- *
- * The end range can also shrink if we have to drop items because the
- * items exceeded the merge window size.
+ * We look ahead in the logged item stream to see if we should merge any
+ * older logged delta items into one result for the caller.  We also
+ * take this opportunity to skip and reset the mpos for any older
+ * versions of the first item.
  */
-static int read_merged_range(struct super_block *sb, struct merged_range *rng,
-			     struct list_head *inputs, int merge_window)
+static int next_resolved_mpos(struct super_block *sb, struct rb_root *pos_root,
+			      struct scoutfs_key *end, struct merge_pos **mpos_ret)
 {
-	struct scoutfs_btree_root_head *rhead;
-	struct scoutfs_key start;
-	struct scoutfs_key end;
+	struct merge_pos *mpos;
+	struct merge_pos *next;
 	struct scoutfs_key key;
 	int ret = 0;
-	int i;
 
-	list_for_each_entry(rhead, inputs, head) {
-		key = rng->start;
+	while ((mpos = first_mpos(pos_root)) && (next = next_mpos(mpos)) &&
+	       !scoutfs_key_compare(mpos->key, next->key)) {
 
-		for (i = 0; i < merge_window; i += SCOUTFS_BLOCK_LG_SIZE) {
-			start = key;
-			end = rng->end;
-			ret = scoutfs_btree_read_items(sb, &rhead->root, &key, &start, &end,
-						       merge_read_item, rng);
+		ret = scoutfs_forest_combine_deltas(mpos->key, mpos->val, mpos->val_len,
+						    next->val, next->val_len);
+		if (ret < 0)
+			break;
+
+		/* reset advances to the next item */
+		key = *mpos->key;
+		scoutfs_key_inc(&key);
+
+		/* always skip next combined or older version */
+		ret = reset_mpos(sb, pos_root, next, &key, end);
+		if (ret < 0)
+			break;
+
+		if (ret == SCOUTFS_DELTA_COMBINED) {
+			scoutfs_inc_counter(sb, btree_merge_delta_combined);
+		} else if (ret == SCOUTFS_DELTA_COMBINED_NULL) {
+			scoutfs_inc_counter(sb, btree_merge_delta_null);
+			/* if merging resulted in no info, skip current */
+			ret = reset_mpos(sb, pos_root, mpos, &key, end);
 			if (ret < 0)
-				goto out;
-
-			if (scoutfs_key_compare(&end, &rng->end) >= 0)
 				break;
-
-			key = end;
-			scoutfs_key_inc(&key);
 		}
-
-		if (scoutfs_key_compare(&end, &rng->end) < 0) {
-			rng->end = end;
-			trim_range_end(rng);
-		}
-
-		if (rng->size > merge_window)
-			trim_range_size(rng, merge_window);
 	}
 
-	trace_scoutfs_btree_merge_read_range(sb, &rng->start, &rng->end, rng->size);
-	ret = 0;
-out:
+	*mpos_ret = mpos;
 	return ret;
 }
 
@@ -2292,13 +2226,6 @@ out:
  * to allocators running low or needing to join/split the parent.
  * *next_ret is set to the next key which hasn't been merged so that the
  * caller can retry with a new allocator and subtree.
- *
- * The number of input roots can be immense.  The merge_window specifies
- * the size of the set of merged items that we'll maintain as we iterate
- * over all the input roots.  Once we've merged items into the window
- * from all the input roots the merged input items are then merged to
- * the writable destination root.  It may take multiple passes of
- * windows of merged items to cover the input key range.
  */
 int scoutfs_btree_merge(struct super_block *sb,
 			struct scoutfs_alloc *alloc,
@@ -2308,16 +2235,18 @@ int scoutfs_btree_merge(struct super_block *sb,
 			struct scoutfs_key *next_ret,
 			struct scoutfs_btree_root *root,
 			struct list_head *inputs,
-			bool subtree, int dirty_limit, int alloc_low, int merge_window)
+			bool subtree, int dirty_limit, int alloc_low)
 {
+	struct scoutfs_btree_root_head *rhead;
+	struct rb_root pos_root = RB_ROOT;
 	struct scoutfs_btree_item *item;
 	struct scoutfs_btree_block *bt;
 	struct scoutfs_block *bl = NULL;
 	struct btree_walk_key_range kr;
 	struct scoutfs_avl_node *par;
-	struct merged_item *mitem;
-	struct merged_item *tmp;
-	struct merged_range rng;
+	struct scoutfs_key next;
+	struct merge_pos *mpos;
+	struct merge_pos *tmp;
 	int walk_val_len;
 	int walk_flags;
 	bool is_del;
@@ -2328,59 +2257,49 @@ int scoutfs_btree_merge(struct super_block *sb,
 	trace_scoutfs_btree_merge(sb, root, start, end);
 	scoutfs_inc_counter(sb, btree_merge);
 
+	list_for_each_entry(rhead, inputs, head) {
+		mpos = kzalloc(sizeof(*mpos), GFP_NOFS);
+		if (!mpos) {
+			ret = -ENOMEM;
+			goto out;
+		}
+
+		RB_CLEAR_NODE(&mpos->node);
+		mpos->root = &rhead->root;
+
+		ret = reset_mpos(sb, &pos_root, mpos, start, end);
+		if (ret < 0)
+			goto out;
+	}
+
 	walk_flags = BTW_DIRTY;
 	if (subtree)
 		walk_flags |= BTW_SUBTREE;
 	walk_val_len = 0;
 
-	rng.start = *start;
-	rng.end = *end;
-	rng.root = RB_ROOT;
-	rng.size = 0;
-
-	ret = read_merged_range(sb, &rng, inputs, merge_window);
-	if (ret < 0)
-		goto out;
-
-	for (;;) {
-		/* read next window as it empties (and it is possible to read an empty range) */
-		mitem = first_mitem(&rng.root);
-		if (!mitem) {
-			/* done if the read range hit the end */
-			if (scoutfs_key_compare(&rng.end, end) >= 0)
-				break;
-
-			/* read next batch of merged items */
-			rng.start = rng.end;
-			scoutfs_key_inc(&rng.start);
-			rng.end = *end;
-			ret = read_merged_range(sb, &rng, inputs, merge_window);
-			if (ret < 0)
-				break;
-			continue;
-		}
+	while ((ret = next_resolved_mpos(sb, &pos_root, end, &mpos)) == 0 && mpos) {
 
 		if (scoutfs_block_writer_dirty_bytes(sb, wri) >= dirty_limit) {
 			scoutfs_inc_counter(sb, btree_merge_dirty_limit);
 			ret = -ERANGE;
-			*next_ret = mitem->key;
+			*next_ret = *mpos->key;
 			goto out;
 		}
 
 		if (scoutfs_alloc_meta_low(sb, alloc, alloc_low)) {
 			scoutfs_inc_counter(sb, btree_merge_alloc_low);
 			ret = -ERANGE;
-			*next_ret = mitem->key;
+			*next_ret = *mpos->key;
 			goto out;
 		}
 
 		scoutfs_block_put(sb, bl);
 		bl = NULL;
 		ret = btree_walk(sb, alloc, wri, root, walk_flags,
-			         &mitem->key, walk_val_len, &bl, &kr, NULL);
+			         mpos->key, walk_val_len, &bl, &kr, NULL);
 		if (ret < 0) {
 			if (ret == -ERANGE)
-				*next_ret = mitem->key;
+				*next_ret = *mpos->key;
 			goto out;
 		}
 		bt = bl->data;
@@ -2392,21 +2311,22 @@ int scoutfs_btree_merge(struct super_block *sb,
 			continue;
 		}
 
-		while (mitem) {
+		while ((ret = next_resolved_mpos(sb, &pos_root, end, &mpos)) == 0 && mpos) {
+
 			/* walk to new leaf if we exceed parent ref key */
-			if (scoutfs_key_compare(&mitem->key, &kr.end) > 0)
+			if (scoutfs_key_compare(mpos->key, &kr.end) > 0)
 				break;
 
 			/* see if there's an existing item */
-			item = leaf_item_hash_search(sb, bt, &mitem->key);
-			is_del = !!(mitem->flags & SCOUTFS_ITEM_FLAG_DELETION);
+			item = leaf_item_hash_search(sb, bt, mpos->key);
+			is_del = !!(mpos->flags & SCOUTFS_ITEM_FLAG_DELETION);
 
 			/* see if we're merging delta items */
 			if (item && !is_del)
-				delta = scoutfs_forest_combine_deltas(&mitem->key,
+				delta = scoutfs_forest_combine_deltas(mpos->key,
 								      item_val(bt, item),
 								      item_val_len(item),
-								      mitem->val, mitem->val_len);
+								      mpos->val, mpos->val_len);
 			else
 				delta = 0;
 			if (delta < 0) {
@@ -2418,38 +2338,40 @@ int scoutfs_btree_merge(struct super_block *sb,
 				scoutfs_inc_counter(sb, btree_merge_delta_null);
 			}
 
-			trace_scoutfs_btree_merge_items(sb, &mitem->key, mitem->val_len,
+			trace_scoutfs_btree_merge_items(sb, mpos->root,
+					mpos->key, mpos->val_len,
 					item ? root : NULL,
 					item ? item_key(item) : NULL,
 					item ? item_val_len(item) : 0, is_del);
 
 			/* rewalk and split if ins/update needs room */
-			if (!is_del && !delta && !mid_free_item_room(bt, mitem->val_len)) {
+			if (!is_del && !delta && !mid_free_item_room(bt, mpos->val_len)) {
 				walk_flags |= BTW_INSERT;
-				walk_val_len = mitem->val_len;
+				walk_val_len = mpos->val_len;
 				break;
 			}
 
 			/* insert missing non-deletion merge items */
 			if (!item && !is_del) {
-				scoutfs_avl_search(&bt->item_root, cmp_key_item, &mitem->key,
+				scoutfs_avl_search(&bt->item_root,
+						   cmp_key_item, mpos->key,
 						   &cmp, &par, NULL, NULL);
-				create_item(bt, &mitem->key, mitem->seq, mitem->flags,
-					    mitem->val, mitem->val_len, par, cmp);
+				create_item(bt, mpos->key, mpos->seq, mpos->flags,
+					    mpos->val, mpos->val_len, par, cmp);
 				scoutfs_inc_counter(sb, btree_merge_insert);
 			}
 
 			/* update existing items */
 			if (item && !is_del && !delta) {
-				item->seq = cpu_to_le64(mitem->seq);
-				item->flags = mitem->flags;
-				update_item_value(bt, item, mitem->val, mitem->val_len);
+				item->seq = cpu_to_le64(mpos->seq);
+				item->flags = mpos->flags;
+				update_item_value(bt, item, mpos->val, mpos->val_len);
 				scoutfs_inc_counter(sb, btree_merge_update);
 			}
 
 			/* update combined delta item seq */
 			if (delta == SCOUTFS_DELTA_COMBINED) {
-				item->seq = cpu_to_le64(mitem->seq);
+				item->seq = cpu_to_le64(mpos->seq);
 			}
 
 			/*
@@ -2481,18 +2403,21 @@ int scoutfs_btree_merge(struct super_block *sb,
 			walk_flags &= ~(BTW_INSERT | BTW_DELETE);
 			walk_val_len = 0;
 
-			/* finished with this merged item */
-			tmp = mitem;
-			mitem = next_mitem(mitem);
-			free_mitem(&rng, tmp);
+			/* finished with this key, skip any older items */
+			next = *mpos->key;
+			scoutfs_key_inc(&next);
+			ret = reset_mpos(sb, &pos_root, mpos, &next, end);
+			if (ret < 0)
+				goto out;
 		}
 	}
 
 	ret = 0;
 out:
 	scoutfs_block_put(sb, bl);
-	rbtree_postorder_for_each_entry_safe(mitem, tmp, &rng.root, node)
-		free_mitem(&rng, mitem);
+	rbtree_postorder_for_each_entry_safe(mpos, tmp, &pos_root, node) {
+		free_mpos(sb, mpos);
+	}
 
 	return ret;
 }

kmod/src/btree.h

@@ -119,7 +119,7 @@ int scoutfs_btree_merge(struct super_block *sb,
 			struct scoutfs_key *next_ret,
 			struct scoutfs_btree_root *root,
 			struct list_head *input_list,
-			bool subtree, int dirty_limit, int alloc_low, int merge_window);
+			bool subtree, int dirty_limit, int alloc_low);
 
 int scoutfs_btree_free_blocks(struct super_block *sb,
 			      struct scoutfs_alloc *alloc,

kmod/src/counters.h

@@ -145,7 +145,6 @@
 	EXPAND_COUNTER(lock_shrink_work)			\
 	EXPAND_COUNTER(lock_unlock)				\
 	EXPAND_COUNTER(lock_wait)				\
-	EXPAND_COUNTER(log_merge_wait_timeout)			\
 	EXPAND_COUNTER(net_dropped_response)			\
 	EXPAND_COUNTER(net_send_bytes)				\
 	EXPAND_COUNTER(net_send_error)				\
@@ -199,7 +198,10 @@
 	EXPAND_COUNTER(srch_read_stale)				\
 	EXPAND_COUNTER(statfs)					\
 	EXPAND_COUNTER(totl_read_copied)			\
+	EXPAND_COUNTER(totl_read_finalized)			\
+	EXPAND_COUNTER(totl_read_fs)				\
 	EXPAND_COUNTER(totl_read_item)				\
+	EXPAND_COUNTER(totl_read_logged)			\
 	EXPAND_COUNTER(trans_commit_data_alloc_low)		\
 	EXPAND_COUNTER(trans_commit_dirty_meta_full)		\
 	EXPAND_COUNTER(trans_commit_fsync)			\

kmod/src/data.c

@@ -586,12 +586,6 @@ static int scoutfs_get_block(struct inode *inode, sector_t iblock,
 		goto out;
 	}
 
-	if (create && !si->staging) {
-		ret = scoutfs_inode_check_retention(inode);
-		if (ret < 0)
-			goto out;
-	}
-
 	/* convert unwritten to written, could be staging */
 	if (create && ext.map && (ext.flags & SEF_UNWRITTEN)) {
 		un.start = iblock;
@@ -1110,10 +1104,6 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 
 	while(iblock <= last) {
 
-		ret = scoutfs_quota_check_data(sb, inode);
-		if (ret)
-			goto out_extent;
-
 		ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, false, true);
 		if (ret)
 			goto out_extent;
@@ -1165,9 +1155,9 @@ out:
  * on regular files with no data extents.  It's used to restore a file
  * with an offline extent which can then trigger staging.
  *
- * The caller must take care of cluster locking, transactions, inode
- * updates, and index updates (so that they can atomically make this
- * change along with other metadata changes).
+ * The caller has taken care of locking the inode.  We're updating the
+ * inode offline count as we create the offline extent so we take care
+ * of the index locking, updating, and transaction.
  */
 int scoutfs_data_init_offline_extent(struct inode *inode, u64 size,
 				     struct scoutfs_lock *lock)
@@ -1181,6 +1171,7 @@ int scoutfs_data_init_offline_extent(struct inode *inode, u64 size,
 		.lock = lock,
 	};
 	const u64 count = DIV_ROUND_UP(size, SCOUTFS_BLOCK_SM_SIZE);
+	LIST_HEAD(ind_locks);
 	u64 on;
 	u64 off;
 	int ret;
@@ -1193,10 +1184,28 @@ int scoutfs_data_init_offline_extent(struct inode *inode, u64 size,
 		goto out;
 	}
 
+	/* we're updating meta_seq with offline block count */
+	ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, false, true);
+	if (ret < 0)
+		goto out;
+
+	ret = scoutfs_dirty_inode_item(inode, lock);
+	if (ret < 0)
+		goto unlock;
+
 	down_write(&si->extent_sem);
 	ret = scoutfs_ext_insert(sb, &data_ext_ops, &args,
 				 0, count, 0, SEF_OFFLINE);
 	up_write(&si->extent_sem);
+	if (ret < 0)
+		goto unlock;
+
+	scoutfs_update_inode_item(inode, lock, &ind_locks);
+
+unlock:
+	scoutfs_release_trans(sb);
+	scoutfs_inode_index_unlock(sb, &ind_locks);
+	ret = 0;
 out:
 	return ret;
 }
@@ -1264,9 +1273,6 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 	if (ret)
 		goto out;
 
-	if (!is_stage && (ret = scoutfs_inode_check_retention(to)))
-		goto out;
-
 	if ((from_off & SCOUTFS_BLOCK_SM_MASK) ||
 	    (to_off & SCOUTFS_BLOCK_SM_MASK) ||
 	    ((byte_len & SCOUTFS_BLOCK_SM_MASK) &&
@@ -1801,6 +1807,37 @@ 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);

kmod/src/data.h

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

@@ -34,7 +34,6 @@
 #include "forest.h"
 #include "acl.h"
 #include "counters.h"
-#include "quota.h"
 #include "scoutfs_trace.h"
 
 /*
@@ -652,10 +651,6 @@ static struct inode *lock_hold_create(struct inode *dir, struct dentry *dentry,
 	if (ret)
 		goto out_unlock;
 
-	ret = scoutfs_quota_check_inode(sb, dir);
-	if (ret)
-		goto out_unlock;
-
 	if (orph_lock) {
 		ret = scoutfs_lock_orphan(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, ino, orph_lock);
 		if (ret < 0)
@@ -677,8 +672,6 @@ retry:
 	if (ret < 0)
 		goto out;
 
-	scoutfs_inode_set_proj(inode, scoutfs_inode_get_proj(dir));
-
 	ret = scoutfs_dirty_inode_item(dir, *dir_lock);
 out:
 	if (ret)
@@ -933,16 +926,12 @@ static int scoutfs_unlink(struct inode *dir, struct dentry *dentry)
 		goto unlock;
 	}
 
-	ret = scoutfs_inode_check_retention(inode);
-	if (ret < 0)
-		goto unlock;
-
 	hash = dirent_name_hash(dentry->d_name.name, dentry->d_name.len);
 
 	ret = lookup_dirent(sb, scoutfs_ino(dir), dentry->d_name.name, dentry->d_name.len, hash,
 			    &dent, dir_lock);
 	if (ret < 0)
-		goto unlock;
+		goto out;
 
 	if (should_orphan(inode)) {
 		ret = scoutfs_lock_orphan(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, scoutfs_ino(inode),
@@ -1643,10 +1632,6 @@ static int scoutfs_rename_common(struct inode *old_dir,
 		goto out_unlock;
 	}
 
-	if ((old_inode && (ret = scoutfs_inode_check_retention(old_inode))) ||
-	    (new_inode && (ret = scoutfs_inode_check_retention(new_inode))))
-		goto out_unlock;
-
 	if (should_orphan(new_inode)) {
 		ret = scoutfs_lock_orphan(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, scoutfs_ino(new_inode),
 					  &orph_lock);

kmod/src/file.c

@@ -28,7 +28,6 @@
 #include "inode.h"
 #include "per_task.h"
 #include "omap.h"
-#include "quota.h"
 
 #ifdef KC_LINUX_HAVE_FOP_AIO_READ
 /*
@@ -109,10 +108,6 @@ retry:
 	if (ret)
 		goto out;
 
-	ret = scoutfs_inode_check_retention(inode);
-	if (ret < 0)
-		goto out;
-
 	ret = scoutfs_complete_truncate(inode, scoutfs_inode_lock);
 	if (ret)
 		goto out;
@@ -127,10 +122,6 @@ retry:
 			goto out;
 	}
 
-	ret = scoutfs_quota_check_data(sb, inode);
-	if (ret)
-		goto out;
-
 	/* XXX: remove SUID bit */
 
 	ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
@@ -180,8 +171,10 @@ retry:
 		goto out;
 
 	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, scoutfs_inode_lock)) {
-		ret = scoutfs_data_wait_check(inode, iocb->ki_pos, iov_iter_count(to), SEF_OFFLINE,
-					      SCOUTFS_IOC_DWO_READ, &dw, 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 {
@@ -212,7 +205,8 @@ ssize_t scoutfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 	struct scoutfs_lock *scoutfs_inode_lock = NULL;
 	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	DECLARE_DATA_WAIT(dw);
-	ssize_t ret;
+	int ret;
+	int written;
 
 retry:
 	inode_lock(inode);
@@ -225,29 +219,23 @@ retry:
 	if (ret <= 0)
 		goto out;
 
-	ret = scoutfs_inode_check_retention(inode);
-	if (ret < 0)
-		goto out;
-
 	ret = scoutfs_complete_truncate(inode, scoutfs_inode_lock);
 	if (ret)
 		goto out;
 
-	ret = scoutfs_quota_check_data(sb, inode);
-	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(inode, 0, i_size_read(inode), SEF_OFFLINE,
-					      SCOUTFS_IOC_DWO_WRITE, &dw, scoutfs_inode_lock);
+		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 */
 
-	ret = __generic_file_write_iter(iocb, from);
+	written = __generic_file_write_iter(iocb, from);
 
 out:
 	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
@@ -260,10 +248,10 @@ out:
 			goto retry;
 	}
 
-	if (ret > 0)
-		ret = generic_write_sync(iocb, ret);
+	if (ret > 0 || ret == -EIOCBQUEUED)
+		ret = generic_write_sync(iocb, written);
 
-	return ret;
+	return written ? written : ret;
 }
 #endif
 

kmod/src/forest.c

@@ -68,6 +68,8 @@ struct forest_info {
 	struct delayed_work log_merge_dwork;
 
 	atomic64_t inode_count_delta;
+
+	struct dentry *dent;
 };
 
 #define DECLARE_FOREST_INFO(sb, name) \
@@ -238,16 +240,19 @@ static int forest_read_items(struct super_block *sb, struct scoutfs_key *key, u6
  * We return -ESTALE if we hit stale blocks to give the caller a chance
  * to reset their state and retry with a newer version of the btrees.
  */
-int scoutfs_forest_read_items_roots(struct super_block *sb, struct scoutfs_net_roots *roots,
-				    struct scoutfs_key *key, struct scoutfs_key *bloom_key,
-				    struct scoutfs_key *start, struct scoutfs_key *end,
-				    scoutfs_forest_item_cb cb, void *arg)
+int scoutfs_forest_read_items(struct super_block *sb,
+			      struct scoutfs_key *key,
+			      struct scoutfs_key *bloom_key,
+			      struct scoutfs_key *start,
+			      struct scoutfs_key *end,
+			      scoutfs_forest_item_cb cb, void *arg)
 {
 	struct forest_read_items_data rid = {
 		.cb = cb,
 		.cb_arg = arg,
 	};
 	struct scoutfs_log_trees lt;
+	struct scoutfs_net_roots roots;
 	struct scoutfs_bloom_block *bb;
 	struct forest_bloom_nrs bloom;
 	SCOUTFS_BTREE_ITEM_REF(iref);
@@ -261,14 +266,18 @@ int scoutfs_forest_read_items_roots(struct super_block *sb, struct scoutfs_net_r
 	scoutfs_inc_counter(sb, forest_read_items);
 	calc_bloom_nrs(&bloom, bloom_key);
 
-	trace_scoutfs_forest_using_roots(sb, &roots->fs_root, &roots->logs_root);
+	ret = scoutfs_client_get_roots(sb, &roots);
+	if (ret)
+		goto out;
+
+	trace_scoutfs_forest_using_roots(sb, &roots.fs_root, &roots.logs_root);
 
 	*start = orig_start;
 	*end = orig_end;
 
 	/* start with fs root items */
 	rid.fic |= FIC_FS_ROOT;
-	ret = scoutfs_btree_read_items(sb, &roots->fs_root, key, start, end,
+	ret = scoutfs_btree_read_items(sb, &roots.fs_root, key, start, end,
 				       forest_read_items, &rid);
 	if (ret < 0)
 		goto out;
@@ -276,7 +285,7 @@ int scoutfs_forest_read_items_roots(struct super_block *sb, struct scoutfs_net_r
 
 	scoutfs_key_init_log_trees(&ltk, 0, 0);
 	for (;; scoutfs_key_inc(&ltk)) {
-		ret = scoutfs_btree_next(sb, &roots->logs_root, &ltk, &iref);
+		ret = scoutfs_btree_next(sb, &roots.logs_root, &ltk, &iref);
 		if (ret == 0) {
 			if (iref.val_len == sizeof(lt)) {
 				ltk = *iref.key;
@@ -333,23 +342,6 @@ out:
 	return ret;
 }
 
-int scoutfs_forest_read_items(struct super_block *sb,
-			      struct scoutfs_key *key,
-			      struct scoutfs_key *bloom_key,
-			      struct scoutfs_key *start,
-			      struct scoutfs_key *end,
-			      scoutfs_forest_item_cb cb, void *arg)
-{
-	struct scoutfs_net_roots roots;
-	int ret;
-
-	ret = scoutfs_client_get_roots(sb, &roots);
-	if (ret == 0)
-		ret = scoutfs_forest_read_items_roots(sb, &roots, key, bloom_key, start, end,
-						      cb, arg);
-	return ret;
-}
-
 /*
  * If the items are deltas then combine the src with the destination
  * value and store the result in the destination.
@@ -731,8 +723,7 @@ static void scoutfs_forest_log_merge_worker(struct work_struct *work)
 	ret = scoutfs_btree_merge(sb, &alloc, &wri, &req.start, &req.end,
 				  &next, &comp.root, &inputs,
 				  !!(req.flags & cpu_to_le64(SCOUTFS_LOG_MERGE_REQUEST_SUBTREE)),
-				  SCOUTFS_LOG_MERGE_DIRTY_BYTE_LIMIT, 10,
-				  (2 * 1024 * 1024));
+				  SCOUTFS_LOG_MERGE_DIRTY_BYTE_LIMIT, 10);
 	if (ret == -ERANGE) {
 		comp.remain = next;
 		le64_add_cpu(&comp.flags, SCOUTFS_LOG_MERGE_COMP_REMAIN);
@@ -761,6 +752,60 @@ resched:
 	queue_delayed_work(finf->workq, &finf->log_merge_dwork, delay);
 }
 
+static int count_log_trees(struct super_block *sb, struct scoutfs_key *key, u64 seq,
+			   u8 flags, void *val, int val_len, void *arg)
+{
+	u64 *count = arg;
+
+	(*count)++;
+	return 0;
+}
+
+static int debugfs_nr_log_trees_get(void *data, u64 *val)
+{
+	struct super_block *sb = data;
+	struct scoutfs_super_block *super = NULL;
+	struct scoutfs_key start;
+	struct scoutfs_key end;
+	struct scoutfs_key key;
+	u64 count;
+	int ret;
+
+	super = kmalloc(sizeof(struct scoutfs_super_block), GFP_NOFS);
+	if (!super) {
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	ret = scoutfs_read_super(sb, super);
+	if (ret < 0)
+		goto out;
+
+	scoutfs_key_init_log_trees(&key, 0, 0);
+	count = 0;
+	for (;;) {
+		scoutfs_key_set_zeros(&start);
+		scoutfs_key_set_ones(&end);
+		ret = scoutfs_btree_read_items(sb, &super->logs_root, &key, &start, &end,
+					       count_log_trees, &count);
+		if (ret == -ENOENT || scoutfs_key_is_ones(&end))
+			break;
+		if (ret < 0)
+			goto out;
+
+		key = end;
+		scoutfs_key_inc(&key);
+	}
+
+	*val = count;
+	ret = 0;
+out:
+	kfree(super);
+	return ret ? -EIO : 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_nr_log_trees, debugfs_nr_log_trees_get, NULL, "%llu\n");
+
 int scoutfs_forest_setup(struct super_block *sb)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
@@ -781,6 +826,13 @@ int scoutfs_forest_setup(struct super_block *sb)
 			  scoutfs_forest_log_merge_worker);
 	sbi->forest_info = finf;
 
+	finf->dent = debugfs_create_file("nr_log_trees", S_IFREG|S_IRUSR, sbi->debug_root, sb,
+					 &fops_nr_log_trees);
+	if (IS_ERR(finf->dent)) {
+		ret = PTR_ERR(finf->dent);
+		goto out;
+	}
+
 	finf->workq = alloc_workqueue("scoutfs_log_merge", WQ_NON_REENTRANT |
 				      WQ_UNBOUND | WQ_HIGHPRI, 0);
 	if (!finf->workq) {
@@ -810,6 +862,8 @@ void scoutfs_forest_stop(struct super_block *sb)
 
 	if (finf && finf->workq) {
 		cancel_delayed_work_sync(&finf->log_merge_dwork);
+		if (!IS_ERR_OR_NULL(finf->dent))
+			debugfs_remove(finf->dent);
 		destroy_workqueue(finf->workq);
 	}
 }

kmod/src/forest.h

@@ -4,7 +4,6 @@
 struct scoutfs_alloc;
 struct scoutfs_block_writer;
 struct scoutfs_block;
-struct scoutfs_lock;
 
 #include "btree.h"
 
@@ -24,10 +23,6 @@ int scoutfs_forest_read_items(struct super_block *sb,
 			      struct scoutfs_key *start,
 			      struct scoutfs_key *end,
 			      scoutfs_forest_item_cb cb, void *arg);
-int scoutfs_forest_read_items_roots(struct super_block *sb, struct scoutfs_net_roots *roots,
-				    struct scoutfs_key *key, struct scoutfs_key *bloom_key,
-				    struct scoutfs_key *start, struct scoutfs_key *end,
-				    scoutfs_forest_item_cb cb, void *arg);
 int scoutfs_forest_set_bloom_bits(struct super_block *sb,
 				  struct scoutfs_lock *lock);
 void scoutfs_forest_set_max_seq(struct super_block *sb, u64 max_seq);

kmod/src/format.h

@@ -8,14 +8,9 @@
  */
 #define SCOUTFS_FORMAT_VERSION_MIN		1
 #define SCOUTFS_FORMAT_VERSION_MIN_STR	__stringify(SCOUTFS_FORMAT_VERSION_MIN)
-#define SCOUTFS_FORMAT_VERSION_MAX		2
+#define SCOUTFS_FORMAT_VERSION_MAX		1
 #define SCOUTFS_FORMAT_VERSION_MAX_STR	__stringify(SCOUTFS_FORMAT_VERSION_MAX)
 
-#define SCOUTFS_FORMAT_VERSION_FEAT_RETENTION	2
-#define SCOUTFS_FORMAT_VERSION_FEAT_PROJECT_ID	2
-#define SCOUTFS_FORMAT_VERSION_FEAT_QUOTA	2
-#define SCOUTFS_FORMAT_VERSION_FEAT_INDX_TAG	2
-
 /* statfs(2) f_type */
 #define SCOUTFS_SUPER_MAGIC	0x554f4353		/* "SCOU" */
 
@@ -180,10 +175,6 @@ struct scoutfs_key {
 #define sko_rid		_sk_first
 #define sko_ino		_sk_second
 
-/* quota rules */
-#define skqr_hash	_sk_second
-#define skqr_coll_nr	_sk_third
-
 /* xattr totl */
 #define skxt_a		_sk_first
 #define skxt_b		_sk_second
@@ -594,9 +585,7 @@ struct scoutfs_log_merge_freeing {
  */
 #define SCOUTFS_INODE_INDEX_ZONE		4
 #define SCOUTFS_ORPHAN_ZONE			8
-#define SCOUTFS_QUOTA_ZONE			10
 #define SCOUTFS_XATTR_TOTL_ZONE			12
-#define SCOUTFS_XATTR_INDX_ZONE			14
 #define SCOUTFS_FS_ZONE				16
 #define SCOUTFS_LOCK_ZONE			20
 /* Items only stored in server btrees */
@@ -619,9 +608,6 @@ struct scoutfs_log_merge_freeing {
 /* orphan zone, redundant type used for clarity */
 #define SCOUTFS_ORPHAN_TYPE			4
 
-/* quota zone */
-#define SCOUTFS_QUOTA_RULE_TYPE			4
-
 /* fs zone */
 #define SCOUTFS_INODE_TYPE			4
 #define SCOUTFS_XATTR_TYPE			8
@@ -675,34 +661,6 @@ struct scoutfs_xattr_totl_val {
 	__le64 count;
 };
 
-#define SQ_RF_TOTL_COUNT	(1 << 0)
-#define SQ_RF__UNKNOWN	(~((1 << 1) - 1))
-
-#define SQ_NS_LITERAL		0
-#define SQ_NS_PROJ		1
-#define SQ_NS_UID		2
-#define SQ_NS_GID		3
-#define SQ_NS__NR		4
-#define SQ_NS__NR_SELECT	(SQ_NS__NR - 1) /* !literal */
-
-#define SQ_NF_SELECT	(1 << 0)
-#define SQ_NF__UNKNOWN	(~((1 << 1) - 1))
-
-#define SQ_OP_INODE	0
-#define SQ_OP_DATA	1
-#define SQ_OP__NR	2
-
-struct scoutfs_quota_rule_val {
-	__le64 name_val[3];
-	__le64 limit;
-	__u8 prio;
-	__u8 op;
-	__u8 rule_flags;
-	__u8 name_source[3];
-	__u8 name_flags[3];
-	__u8 _pad[7];
-};
-
 /* XXX does this exist upstream somewhere? */
 #define member_sizeof(TYPE, MEMBER) (sizeof(((TYPE *)0)->MEMBER))
 
@@ -901,38 +859,9 @@ struct scoutfs_inode {
 	struct scoutfs_timespec ctime;
 	struct scoutfs_timespec mtime;
 	struct scoutfs_timespec crtime;
-	__le64 proj;
 };
 
-#define SCOUTFS_INODE_FMT_V1_BYTES offsetof(struct scoutfs_inode, proj)
-
-/*
- * There are so few versions that we don't mind doing this work inline
- * so that both utils and kernel can share these.  Mounting has already
- * checked that the format version is within the supported min and max,
- * so these functions only deal with size variance within that band.
- */
-/* Returns the native written inode size for the given format version, 0 for bad version */
-static inline int scoutfs_inode_vers_bytes(__u64 fmt_vers)
-{
-	if (fmt_vers == 1)
-		return SCOUTFS_INODE_FMT_V1_BYTES;
-	else
-		return sizeof(struct scoutfs_inode);
-}
-/*
- * Returns true if bytes is a valid inode size to read from the given
- * version.  The given version must be greater than the version that
- * introduced the size.
- */
-static inline int scoutfs_inode_valid_vers_bytes(__u64 fmt_vers, int bytes)
-{
-	return (bytes == sizeof(struct scoutfs_inode) && fmt_vers == SCOUTFS_FORMAT_VERSION_MAX) ||
-	       (bytes == SCOUTFS_INODE_FMT_V1_BYTES);
-}
-
-#define SCOUTFS_INO_FLAG_TRUNCATE	0x1
-#define SCOUTFS_INO_FLAG_RETENTION	0x2
+#define SCOUTFS_INO_FLAG_TRUNCATE 0x1
 
 #define SCOUTFS_ROOT_INO 1
 

kmod/src/inode.c

@@ -91,7 +91,7 @@ static void scoutfs_inode_ctor(void *obj)
 
 	init_rwsem(&si->extent_sem);
 	mutex_init(&si->item_mutex);
-	seqlock_init(&si->seqlock);
+	seqcount_init(&si->seqcount);
 	si->staging = false;
 	scoutfs_per_task_init(&si->pt_data_lock);
 	atomic64_set(&si->data_waitq.changed, 0);
@@ -250,7 +250,7 @@ static void set_item_info(struct scoutfs_inode_info *si,
 	set_item_major(si, SCOUTFS_INODE_INDEX_DATA_SEQ_TYPE, sinode->data_seq);
 }
 
-static void load_inode(struct inode *inode, struct scoutfs_inode *cinode, int inode_bytes)
+static void load_inode(struct inode *inode, struct scoutfs_inode *cinode)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 
@@ -278,7 +278,6 @@ static void load_inode(struct inode *inode, struct scoutfs_inode *cinode, int in
 	si->flags = le32_to_cpu(cinode->flags);
 	si->crtime.tv_sec = le64_to_cpu(cinode->crtime.sec);
 	si->crtime.tv_nsec = le32_to_cpu(cinode->crtime.nsec);
-	si->proj = le64_to_cpu(cinode->proj);
 
 	/*
 	 * i_blocks is initialized from online and offline and is then
@@ -299,24 +298,6 @@ void scoutfs_inode_init_key(struct scoutfs_key *key, u64 ino)
 	};
 }
 
-/*
- * Read an inode item into the caller's buffer and return the size that
- * we read.   Returns errors if the inode size is unsupported or doesn't
- * make sense for the format version.
- */
-static int lookup_inode_item(struct super_block *sb, struct scoutfs_key *key,
-			     struct scoutfs_inode *sinode, struct scoutfs_lock *lock)
-{
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
-	int ret;
-
-	ret = scoutfs_item_lookup_smaller_zero(sb, key, sinode, sizeof(struct scoutfs_inode), lock);
-	if (ret >= 0 && !scoutfs_inode_valid_vers_bytes(sbi->fmt_vers, ret))
-		return -EIO;
-
-	return ret;
-}
-
 /*
  * Refresh the vfs inode fields if the lock indicates that the current
  * contents could be stale.
@@ -352,12 +333,12 @@ int scoutfs_inode_refresh(struct inode *inode, struct scoutfs_lock *lock)
 
 	mutex_lock(&si->item_mutex);
 	if (atomic64_read(&si->last_refreshed) < refresh_gen) {
-		ret = lookup_inode_item(sb, &key, &sinode, lock);
-		if (ret > 0) {
-			load_inode(inode, &sinode, ret);
+		ret = scoutfs_item_lookup_exact(sb, &key, &sinode,
+						sizeof(sinode), lock);
+		if (ret == 0) {
+			load_inode(inode, &sinode);
 			atomic64_set(&si->last_refreshed, refresh_gen);
 			scoutfs_lock_add_coverage(sb, lock, &si->ino_lock_cov);
-			ret = 0;
 		}
 	} else {
 		ret = 0;
@@ -505,10 +486,6 @@ retry:
 	if (ret)
 		goto out;
 
-	ret = scoutfs_inode_check_retention(inode);
-	if (ret < 0)
-		goto out;
-
 	attr_size = (attr->ia_valid & ATTR_SIZE) ? attr->ia_size :
 		i_size_read(inode);
 
@@ -589,9 +566,11 @@ static void set_trans_seq(struct inode *inode, u64 *seq)
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 
 	if (*seq != sbi->trans_seq) {
-		write_seqlock(&si->seqlock);
+		preempt_disable();
+		write_seqcount_begin(&si->seqcount);
 		*seq = sbi->trans_seq;
-		write_sequnlock(&si->seqlock);
+		write_seqcount_end(&si->seqcount);
+		preempt_enable();
 	}
 }
 
@@ -613,18 +592,22 @@ void scoutfs_inode_inc_data_version(struct inode *inode)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 
-	write_seqlock(&si->seqlock);
+	preempt_disable();
+	write_seqcount_begin(&si->seqcount);
 	si->data_version++;
-	write_sequnlock(&si->seqlock);
+	write_seqcount_end(&si->seqcount);
+	preempt_enable();
 }
 
 void scoutfs_inode_set_data_version(struct inode *inode, u64 data_version)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 
-	write_seqlock(&si->seqlock);
+	preempt_disable();
+	write_seqcount_begin(&si->seqcount);
 	si->data_version = data_version;
-	write_sequnlock(&si->seqlock);
+	write_seqcount_end(&si->seqcount);
+	preempt_enable();
 }
 
 void scoutfs_inode_add_onoff(struct inode *inode, s64 on, s64 off)
@@ -633,7 +616,8 @@ void scoutfs_inode_add_onoff(struct inode *inode, s64 on, s64 off)
 
 	if (inode && (on || off)) {
 		si = SCOUTFS_I(inode);
-		write_seqlock(&si->seqlock);
+		preempt_disable();
+		write_seqcount_begin(&si->seqcount);
 
 		/* inode and extents out of sync, bad callers */
 		if (((s64)si->online_blocks + on < 0) ||
@@ -654,7 +638,8 @@ void scoutfs_inode_add_onoff(struct inode *inode, s64 on, s64 off)
 						    si->online_blocks,
 						    si->offline_blocks);
 
-		write_sequnlock(&si->seqlock);
+		write_seqcount_end(&si->seqcount);
+		preempt_enable();
 	}
 
 	/* any time offline extents decreased we try and wake waiters */
@@ -662,16 +647,16 @@ void scoutfs_inode_add_onoff(struct inode *inode, s64 on, s64 off)
 		scoutfs_data_wait_changed(inode);
 }
 
-static u64 read_seqlock_u64(struct inode *inode, u64 *val)
+static u64 read_seqcount_u64(struct inode *inode, u64 *val)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	unsigned seq;
+	unsigned int seq;
 	u64 v;
 
 	do {
-		seq = read_seqbegin(&si->seqlock);
+		seq = read_seqcount_begin(&si->seqcount);
 		v = *val;
-	} while (read_seqretry(&si->seqlock, seq));
+	} while (read_seqcount_retry(&si->seqcount, seq));
 
 	return v;
 }
@@ -680,82 +665,33 @@ u64 scoutfs_inode_meta_seq(struct inode *inode)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 
-	return read_seqlock_u64(inode, &si->meta_seq);
+	return read_seqcount_u64(inode, &si->meta_seq);
 }
 
 u64 scoutfs_inode_data_seq(struct inode *inode)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 
-	return read_seqlock_u64(inode, &si->data_seq);
+	return read_seqcount_u64(inode, &si->data_seq);
 }
 
 u64 scoutfs_inode_data_version(struct inode *inode)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 
-	return read_seqlock_u64(inode, &si->data_version);
+	return read_seqcount_u64(inode, &si->data_version);
 }
 
 void scoutfs_inode_get_onoff(struct inode *inode, s64 *on, s64 *off)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	unsigned seq;
+	unsigned int seq;
 
 	do {
-		seq = read_seqbegin(&si->seqlock);
+		seq = read_seqcount_begin(&si->seqcount);
 		*on = SCOUTFS_I(inode)->online_blocks;
 		*off = SCOUTFS_I(inode)->offline_blocks;
-	} while (read_seqretry(&si->seqlock, seq));
-}
-
-/*
- * Get our private scoutfs inode flags, not the vfs i_flags.
- */
-u32 scoutfs_inode_get_flags(struct inode *inode)
-{
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	unsigned seq;
-	u32 flags;
-
-	do {
-		seq = read_seqbegin(&si->seqlock);
-		flags = si->flags;
-	} while (read_seqretry(&si->seqlock, seq));
-
-	return flags;
-}
-
-void scoutfs_inode_set_flags(struct inode *inode, u32 and, u32 or)
-{
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-
-	write_seqlock(&si->seqlock);
-	si->flags = (si->flags & and) | or;
-	write_sequnlock(&si->seqlock);
-}
-
-u64 scoutfs_inode_get_proj(struct inode *inode)
-{
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-	unsigned seq;
-	u64 proj;
-
-	do {
-		seq = read_seqbegin(&si->seqlock);
-		proj = si->proj;
-	} while (read_seqretry(&si->seqlock, seq));
-
-	return proj;
-}
-
-void scoutfs_inode_set_proj(struct inode *inode, u64 proj)
-{
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
-
-	write_seqlock(&si->seqlock);
-	si->proj = proj;
-	write_sequnlock(&si->seqlock);
+	} while (read_seqcount_retry(&si->seqcount, seq));
 }
 
 static int scoutfs_iget_test(struct inode *inode, void *arg)
@@ -867,7 +803,7 @@ out:
 	return inode;
 }
 
-static void store_inode(struct scoutfs_inode *cinode, struct inode *inode, int inode_bytes)
+static void store_inode(struct scoutfs_inode *cinode, struct inode *inode)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	u64 online_blocks;
@@ -903,7 +839,6 @@ static void store_inode(struct scoutfs_inode *cinode, struct inode *inode, int i
 	cinode->crtime.sec = cpu_to_le64(si->crtime.tv_sec);
 	cinode->crtime.nsec = cpu_to_le32(si->crtime.tv_nsec);
 	memset(cinode->crtime.__pad, 0, sizeof(cinode->crtime.__pad));
-	cinode->proj = cpu_to_le64(si->proj);
 }
 
 /*
@@ -927,18 +862,15 @@ static void store_inode(struct scoutfs_inode *cinode, struct inode *inode, int i
 int scoutfs_dirty_inode_item(struct inode *inode, struct scoutfs_lock *lock)
 {
 	struct super_block *sb = inode->i_sb;
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 	struct scoutfs_inode sinode;
 	struct scoutfs_key key;
-	int inode_bytes;
 	int ret;
 
-	inode_bytes = scoutfs_inode_vers_bytes(sbi->fmt_vers);
-	store_inode(&sinode, inode, inode_bytes);
+	store_inode(&sinode, inode);
 
 	scoutfs_inode_init_key(&key, scoutfs_ino(inode));
 
-	ret = scoutfs_item_update(sb, &key, &sinode, inode_bytes, lock);
+	ret = scoutfs_item_update(sb, &key, &sinode, sizeof(sinode), lock);
 	if (!ret)
 		trace_scoutfs_dirty_inode(inode);
 	return ret;
@@ -1140,11 +1072,9 @@ void scoutfs_update_inode_item(struct inode *inode, struct scoutfs_lock *lock,
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 	const u64 ino = scoutfs_ino(inode);
-	struct scoutfs_inode sinode;
 	struct scoutfs_key key;
-	int inode_bytes;
+	struct scoutfs_inode sinode;
 	int ret;
 	int err;
 
@@ -1153,17 +1083,15 @@ void scoutfs_update_inode_item(struct inode *inode, struct scoutfs_lock *lock,
 	/* set the meta version once per trans for any inode updates */
 	scoutfs_inode_set_meta_seq(inode);
 
-	inode_bytes = scoutfs_inode_vers_bytes(sbi->fmt_vers);
-
 	/* only race with other inode field stores once */
-	store_inode(&sinode, inode, inode_bytes);
+	store_inode(&sinode, inode);
 
 	ret = update_indices(sb, si, ino, inode->i_mode, &sinode, lock_list, lock);
 	BUG_ON(ret);
 
 	scoutfs_inode_init_key(&key, ino);
 
-	err = scoutfs_item_update(sb, &key, &sinode, inode_bytes, lock);
+	err = scoutfs_item_update(sb, &key, &sinode, sizeof(sinode), lock);
 	if (err) {
 		scoutfs_err(sb, "inode %llu update err %d", ino, err);
 		BUG_ON(err);
@@ -1531,12 +1459,10 @@ out:
 int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, dev_t rdev,
 		      u64 ino, struct scoutfs_lock *lock, struct inode **inode_ret)
 {
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
 	struct scoutfs_inode_info *si;
-	struct scoutfs_inode sinode;
 	struct scoutfs_key key;
+	struct scoutfs_inode sinode;
 	struct inode *inode;
-	int inode_bytes;
 	int ret;
 
 	inode = new_inode(sb);
@@ -1552,7 +1478,6 @@ int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, d
 	si->offline_blocks = 0;
 	si->next_readdir_pos = SCOUTFS_DIRENT_FIRST_POS;
 	si->next_xattr_id = 0;
-	si->proj = 0;
 	si->have_item = false;
 	atomic64_set(&si->last_refreshed, lock->refresh_gen);
 	scoutfs_lock_add_coverage(sb, lock, &si->ino_lock_cov);
@@ -1568,16 +1493,14 @@ int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, d
 	inode->i_rdev = rdev;
 	set_inode_ops(inode);
 
-	inode_bytes = scoutfs_inode_vers_bytes(sbi->fmt_vers);
-
-	store_inode(&sinode, inode, inode_bytes);
+	store_inode(&sinode, inode);
 	scoutfs_inode_init_key(&key, scoutfs_ino(inode));
 
 	ret = scoutfs_omap_set(sb, ino);
 	if (ret < 0)
 		goto out;
 
-	ret = scoutfs_item_create(sb, &key, &sinode, inode_bytes, lock);
+	ret = scoutfs_item_create(sb, &key, &sinode, sizeof(sinode), lock);
 	if (ret < 0)
 		scoutfs_omap_clear(sb, ino);
 out:
@@ -1831,7 +1754,7 @@ static int try_delete_inode_items(struct super_block *sb, u64 ino)
 	}
 
 	scoutfs_inode_init_key(&key, ino);
-	ret = lookup_inode_item(sb, &key, &sinode, lock);
+	ret = scoutfs_item_lookup_exact(sb, &key, &sinode, sizeof(sinode), lock);
 	if (ret < 0) {
 		if (ret == -ENOENT)
 			ret = 0;
@@ -2220,17 +2143,6 @@ out:
 	return ret;
 }
 
-/*
- * Return an error if the inode has the retention flag set and can not
- * be modified.  This mimics the errno returned by the vfs whan an
- * inode's immutable flag is set.  The flag won't be set on older format
- * versions so we don't check the mounted format version here.
- */
-int scoutfs_inode_check_retention(struct inode *inode)
-{
-	return (scoutfs_inode_get_flags(inode) & SCOUTFS_INO_FLAG_RETENTION) ? -EPERM : 0;
-}
-
 int scoutfs_inode_setup(struct super_block *sb)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);

kmod/src/inode.h

@@ -21,7 +21,6 @@ struct scoutfs_inode_info {
 	u64 data_version;
 	u64 online_blocks;
 	u64 offline_blocks;
-	u64 proj;
 	u32 flags;
 	struct kc_timespec crtime;
 
@@ -48,7 +47,7 @@ struct scoutfs_inode_info {
 	atomic64_t last_refreshed;
 
 	/* initialized once for slab object */
-	seqlock_t seqlock;
+	seqcount_t seqcount;
 	bool staging;			/* holder of i_mutex is staging */
 	struct scoutfs_per_task pt_data_lock;
 	struct scoutfs_data_waitq data_waitq;
@@ -121,15 +120,8 @@ u64 scoutfs_inode_meta_seq(struct inode *inode);
 u64 scoutfs_inode_data_seq(struct inode *inode);
 u64 scoutfs_inode_data_version(struct inode *inode);
 void scoutfs_inode_get_onoff(struct inode *inode, s64 *on, s64 *off);
-u32 scoutfs_inode_get_flags(struct inode *inode);
-void scoutfs_inode_set_flags(struct inode *inode, u32 and, u32 or);
-u64 scoutfs_inode_get_proj(struct inode *inode);
-void scoutfs_inode_set_proj(struct inode *inode, u64 proj);
-
 int scoutfs_complete_truncate(struct inode *inode, struct scoutfs_lock *lock);
 
-int scoutfs_inode_check_retention(struct inode *inode);
-
 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,

kmod/src/ioctl.c

@@ -42,10 +42,6 @@
 #include "alloc.h"
 #include "server.h"
 #include "counters.h"
-#include "attr_x.h"
-#include "totl.h"
-#include "wkic.h"
-#include "quota.h"
 #include "scoutfs_trace.h"
 
 /*
@@ -549,41 +545,20 @@ out:
 static long scoutfs_ioc_stat_more(struct file *file, unsigned long arg)
 {
 	struct inode *inode = file_inode(file);
-	struct scoutfs_ioctl_inode_attr_x *iax = NULL;
-	struct scoutfs_ioctl_stat_more *stm = NULL;
-	int ret;
+	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
+	struct scoutfs_ioctl_stat_more stm;
 
-	iax = kmalloc(sizeof(struct scoutfs_ioctl_inode_attr_x), GFP_KERNEL);
-	stm = kmalloc(sizeof(struct scoutfs_ioctl_stat_more), GFP_KERNEL);
-	if (!iax || !stm) {
-		ret = -ENOMEM;
-		goto out;
-	}
+	stm.meta_seq = scoutfs_inode_meta_seq(inode);
+	stm.data_seq = scoutfs_inode_data_seq(inode);
+	stm.data_version = scoutfs_inode_data_version(inode);
+	scoutfs_inode_get_onoff(inode, &stm.online_blocks, &stm.offline_blocks);
+	stm.crtime_sec = si->crtime.tv_sec;
+	stm.crtime_nsec = si->crtime.tv_nsec;
 
-	iax->x_mask = SCOUTFS_IOC_IAX_META_SEQ | SCOUTFS_IOC_IAX_DATA_SEQ |
-		      SCOUTFS_IOC_IAX_DATA_VERSION | SCOUTFS_IOC_IAX_ONLINE_BLOCKS |
-		      SCOUTFS_IOC_IAX_OFFLINE_BLOCKS | SCOUTFS_IOC_IAX_CRTIME;
-	iax->x_flags = 0;
-	ret = scoutfs_get_attr_x(inode, iax);
-	if (ret < 0)
-		goto out;
+	if (copy_to_user((void __user *)arg, &stm, sizeof(stm)))
+		return -EFAULT;
 
-	stm->meta_seq = iax->meta_seq;
-	stm->data_seq = iax->data_seq;
-	stm->data_version = iax->data_version;
-	stm->online_blocks = iax->online_blocks;
-	stm->offline_blocks = iax->offline_blocks;
-	stm->crtime_sec = iax->crtime_sec;
-	stm->crtime_nsec = iax->crtime_nsec;
-
-	if (copy_to_user((void __user *)arg, stm, sizeof(struct scoutfs_ioctl_stat_more)))
-		ret = -EFAULT;
-	else
-		ret = 0;
-out:
-	kfree(iax);
-	kfree(stm);
-	return ret;
+	return 0;
 }
 
 static bool inc_wrapped(u64 *ino, u64 *iblock)
@@ -640,19 +615,24 @@ static long scoutfs_ioc_data_waiting(struct file *file, unsigned long arg)
  * This is used when restoring files, it lets the caller set all the
  * inode attributes which are otherwise unreachable.  Changing the file
  * size can only be done for regular files with a data_version of 0.
- *
- * We unconditionally fill the iax attributes from the sm set and let
- * set_attr_x check them.
  */
 static long scoutfs_ioc_setattr_more(struct file *file, unsigned long arg)
 {
-	struct inode *inode = file_inode(file);
+	struct inode *inode = file->f_inode;
+	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
+	struct super_block *sb = inode->i_sb;
 	struct scoutfs_ioctl_setattr_more __user *usm = (void __user *)arg;
-	struct scoutfs_ioctl_inode_attr_x *iax = NULL;
 	struct scoutfs_ioctl_setattr_more sm;
+	struct scoutfs_lock *lock = NULL;
 	LIST_HEAD(ind_locks);
+	bool set_data_seq;
 	int ret;
 
+	if (!capable(CAP_SYS_ADMIN)) {
+		ret = -EPERM;
+		goto out;
+	}
+
 	if (!(file->f_mode & FMODE_WRITE)) {
 		ret = -EBADF;
 		goto out;
@@ -663,38 +643,65 @@ static long scoutfs_ioc_setattr_more(struct file *file, unsigned long arg)
 		goto out;
 	}
 
-	if (sm.flags & SCOUTFS_IOC_SETATTR_MORE_UNKNOWN) {
+	if ((sm.i_size > 0 && sm.data_version == 0) ||
+	    ((sm.flags & SCOUTFS_IOC_SETATTR_MORE_OFFLINE) && !sm.i_size) ||
+	    (sm.flags & SCOUTFS_IOC_SETATTR_MORE_UNKNOWN)) {
 		ret = -EINVAL;
 		goto out;
 	}
 
-	iax = kzalloc(sizeof(struct scoutfs_ioctl_inode_attr_x), GFP_KERNEL);
-	if (!iax) {
-		ret = -ENOMEM;
+	ret = mnt_want_write_file(file);
+	if (ret)
 		goto out;
+
+	inode_lock(inode);
+
+	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
+				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
+	if (ret)
+		goto unlock;
+
+	/* can only change size/dv on untouched regular files */
+	if ((sm.i_size != 0 || sm.data_version != 0) &&
+	    ((!S_ISREG(inode->i_mode) ||
+	      scoutfs_inode_data_version(inode) != 0))) {
+		ret = -EINVAL;
+		goto unlock;
 	}
 
-	iax->x_mask = SCOUTFS_IOC_IAX_DATA_VERSION | SCOUTFS_IOC_IAX_CTIME |
-		      SCOUTFS_IOC_IAX_CRTIME | SCOUTFS_IOC_IAX_SIZE;
-	iax->data_version = sm.data_version;
-	iax->ctime_sec = sm.ctime_sec;
-	iax->ctime_nsec = sm.ctime_nsec;
-	iax->crtime_sec = sm.crtime_sec;
-	iax->crtime_nsec = sm.crtime_nsec;
-	iax->size = sm.i_size;
+	/* create offline extents in potentially many transactions */
+	if (sm.flags & SCOUTFS_IOC_SETATTR_MORE_OFFLINE) {
+		ret = scoutfs_data_init_offline_extent(inode, sm.i_size, lock);
+		if (ret)
+			goto unlock;
+	}
 
-	if (sm.flags & SCOUTFS_IOC_SETATTR_MORE_OFFLINE)
-		iax->x_flags |= SCOUTFS_IOC_IAX_F_SIZE_OFFLINE;
+	/* setting only so we don't see 0 data seq with nonzero data_version */
+	set_data_seq = sm.data_version != 0 ? true : false;
+	ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, set_data_seq, false);
+	if (ret)
+		goto unlock;
 
-	ret = mnt_want_write_file(file);
-	if (ret < 0)
-		goto out;
+	if (sm.data_version)
+		scoutfs_inode_set_data_version(inode, sm.data_version);
+	if (sm.i_size)
+		i_size_write(inode, sm.i_size);
+	inode->i_ctime.tv_sec = sm.ctime_sec;
+	inode->i_ctime.tv_nsec = sm.ctime_nsec;
+	si->crtime.tv_sec = sm.crtime_sec;
+	si->crtime.tv_nsec = sm.crtime_nsec;
 
-	ret = scoutfs_set_attr_x(inode, iax);
+	scoutfs_update_inode_item(inode, lock, &ind_locks);
+	ret = 0;
 
+	scoutfs_release_trans(sb);
+unlock:
+	scoutfs_inode_index_unlock(sb, &ind_locks);
+	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
+	inode_unlock(inode);
 	mnt_drop_write_file(file);
 out:
-	kfree(iax);
+
 	return ret;
 }
 
@@ -1028,32 +1035,124 @@ out:
 	return ret;
 }
 
-struct read_xattr_total_iter_cb_args {
-	struct scoutfs_ioctl_xattr_total *xt;
-	unsigned int copied;
-	unsigned int total;
+struct xattr_total_entry {
+	struct rb_node node;
+	struct scoutfs_ioctl_xattr_total xt;
+	u64 fs_seq;
+	u64 fs_total;
+	u64 fs_count;
+	u64 fin_seq;
+	u64 fin_total;
+	s64 fin_count;
+	u64 log_seq;
+	u64 log_total;
+	s64 log_count;
 };
 
-/*
- * This is called under an RCU read lock so it can't copy to userspace.
- */
-static int read_xattr_total_iter_cb(struct scoutfs_key *key, void *val, unsigned int val_len,
-				    void *cb_arg)
+static int cmp_xt_entry_name(const struct xattr_total_entry *a,
+			     const struct xattr_total_entry *b)
+
+{
+	return scoutfs_cmp_u64s(a->xt.name[0], b->xt.name[0]) ?:
+	       scoutfs_cmp_u64s(a->xt.name[1], b->xt.name[1]) ?:
+	       scoutfs_cmp_u64s(a->xt.name[2], b->xt.name[2]);
+}
+
+/*
+ * Record the contribution of the three classes of logged items we can
+ * see: the item in the fs_root, items from finalized log btrees, and
+ * items from active log btrees.  Once we have the full set the caller
+ * can decide which of the items contribute to the total it sends to the
+ * user.
+ */
+static int read_xattr_total_item(struct super_block *sb, struct scoutfs_key *key,
+				 u64 seq, u8 flags, void *val, int val_len, int fic, void *arg)
 {
-	struct read_xattr_total_iter_cb_args *cba = cb_arg;
 	struct scoutfs_xattr_totl_val *tval = val;
-	struct scoutfs_ioctl_xattr_total *xt = &cba->xt[cba->copied];
+	struct xattr_total_entry *ent;
+	struct xattr_total_entry rd;
+	struct rb_root *root = arg;
+	struct rb_node *parent;
+	struct rb_node **node;
+	int cmp;
 
-	xt->name[0] = le64_to_cpu(key->skxt_a);
-	xt->name[1] = le64_to_cpu(key->skxt_b);
-	xt->name[2] = le64_to_cpu(key->skxt_c);
-	xt->total = le64_to_cpu(tval->total);
-	xt->count = le64_to_cpu(tval->count);
+	rd.xt.name[0] = le64_to_cpu(key->skxt_a);
+	rd.xt.name[1] = le64_to_cpu(key->skxt_b);
+	rd.xt.name[2] = le64_to_cpu(key->skxt_c);
 
-	if (++cba->copied < cba->total)
-		return -EAGAIN;
-	else
-		return 0;
+	/* find entry matching name */
+	node = &root->rb_node;
+	parent = NULL;
+	cmp = -1;
+	while (*node) {
+		parent = *node;
+		ent = container_of(*node, struct xattr_total_entry, node);
+
+		/* sort merge items by key then newest to oldest */
+		cmp = cmp_xt_entry_name(&rd, ent);
+		if (cmp < 0)
+			node = &(*node)->rb_left;
+		else if (cmp > 0)
+			node = &(*node)->rb_right;
+		else
+			break;
+	}
+
+	/* allocate and insert new node if we need to */
+	if (cmp != 0) {
+		ent = kzalloc(sizeof(*ent), GFP_KERNEL);
+		if (!ent)
+			return -ENOMEM;
+
+		memcpy(&ent->xt.name, &rd.xt.name, sizeof(ent->xt.name));
+
+		rb_link_node(&ent->node, parent, node);
+		rb_insert_color(&ent->node, root);
+	}
+
+	if (fic & FIC_FS_ROOT) {
+		ent->fs_seq = seq;
+		ent->fs_total = le64_to_cpu(tval->total);
+		ent->fs_count = le64_to_cpu(tval->count);
+	} else if (fic & FIC_FINALIZED) {
+		ent->fin_seq = seq;
+		ent->fin_total += le64_to_cpu(tval->total);
+		ent->fin_count += le64_to_cpu(tval->count);
+	} else {
+		ent->log_seq = seq;
+		ent->log_total += le64_to_cpu(tval->total);
+		ent->log_count += le64_to_cpu(tval->count);
+	}
+
+	scoutfs_inc_counter(sb, totl_read_item);
+
+	return 0;
+}
+
+/* these are always _safe, node stores next */
+#define for_each_xt_ent(ent, node, root)					\
+	for (node = rb_first(root);						\
+	     node && (ent = rb_entry(node, struct xattr_total_entry, node),	\
+		      node = rb_next(node), 1); )
+
+#define for_each_xt_ent_reverse(ent, node, root)				\
+	for (node = rb_last(root);						\
+	     node && (ent = rb_entry(node, struct xattr_total_entry, node),	\
+		      node = rb_prev(node), 1); )
+
+static void free_xt_ent(struct rb_root *root, struct xattr_total_entry *ent)
+{
+	rb_erase(&ent->node, root);
+	kfree(ent);
+}
+
+static void free_all_xt_ents(struct rb_root *root)
+{
+	struct xattr_total_entry *ent;
+	struct rb_node *node;
+
+	for_each_xt_ent(ent, node, root)
+		free_xt_ent(root, ent);
 }
 
 /*
@@ -1063,6 +1162,30 @@ static int read_xattr_total_iter_cb(struct scoutfs_key *key, void *val, unsigned
  * have been committed.  It doesn't use locking to force commits and
  * block writers so it can be a little bit out of date with respect to
  * dirty xattrs in memory across the system.
+ *
+ * Our reader has to be careful because the log btree merging code can
+ * write partial results to the fs_root.  This means that a reader can
+ * see both cases where new finalized logs should be applied to the old
+ * fs items and where old finalized logs have already been applied to
+ * the partially merged fs items.  Currently active logged items are
+ * always applied on top of all cases.
+ *
+ * These cases are differentiated with a combination of sequence numbers
+ * in items, the count of contributing xattrs, and a flag
+ * differentiating finalized and active logged items.  This lets us
+ * recognize all cases, including when finalized logs were merged and
+ * deleted the fs item.
+ *
+ * We're allocating a tracking struct for each totl name we see while
+ * traversing the item btrees.  The forest reader is providing the items
+ * it finds in leaf blocks that contain the search key.  In the worst
+ * case all of these blocks are full and none of the items overlap.  At
+ * most, figure order a thousand names per mount.  But in practice many
+ * of these factors fall away: leaf blocks aren't fill, leaf items
+ * overlap, there aren't finalized log btrees, and not all mounts are
+ * actively changing totals.   We're much more likely to only read a
+ * leaf block's worth of totals that have been long since merged into
+ * the fs_root.
  */
 static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 {
@@ -1070,13 +1193,14 @@ static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 	struct scoutfs_ioctl_read_xattr_totals __user *urxt = (void __user *)arg;
 	struct scoutfs_ioctl_read_xattr_totals rxt;
 	struct scoutfs_ioctl_xattr_total __user *uxt;
-	struct read_xattr_total_iter_cb_args cba = {NULL, };
-	struct scoutfs_key range_start;
-	struct scoutfs_key range_end;
+	struct xattr_total_entry *ent;
 	struct scoutfs_key key;
-	unsigned int copied = 0;
-	unsigned int total;
-	unsigned int ready;
+	struct scoutfs_key bloom_key;
+	struct scoutfs_key start;
+	struct scoutfs_key end;
+	struct rb_root root = RB_ROOT;
+	struct rb_node *node;
+	int count = 0;
 	int ret;
 
 	if (!(file->f_mode & FMODE_READ)) {
@@ -1089,13 +1213,6 @@ static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 		goto out;
 	}
 
-	cba.xt = (void *)__get_free_page(GFP_KERNEL);
-	if (!cba.xt) {
-		ret = -ENOMEM;
-		goto out;
-	}
-	cba.total = PAGE_SIZE / sizeof(struct scoutfs_ioctl_xattr_total);
-
 	if (copy_from_user(&rxt, urxt, sizeof(rxt))) {
 		ret = -EFAULT;
 		goto out;
@@ -1108,40 +1225,101 @@ static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 		goto out;
 	}
 
-	total = div_u64(min_t(u64, rxt.totals_bytes, INT_MAX),
-			sizeof(struct scoutfs_ioctl_xattr_total));
+	scoutfs_key_set_zeros(&bloom_key);
+	bloom_key.sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
+	scoutfs_xattr_init_totl_key(&start, rxt.pos_name);
 
-	scoutfs_totl_set_range(&range_start, &range_end);
-	scoutfs_xattr_init_totl_key(&key, rxt.pos_name);
+	while (rxt.totals_bytes >= sizeof(struct scoutfs_ioctl_xattr_total)) {
 
-	while (copied < total) {
-		cba.copied = 0;
-		ret = scoutfs_wkic_iterate(sb, &key, &range_end, &range_start, &range_end,
-					   read_xattr_total_iter_cb, &cba);
-		if (ret < 0)
-			goto out;
-
-		if (cba.copied == 0)
+		scoutfs_key_set_ones(&end);
+		end.sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
+		if (scoutfs_key_compare(&start, &end) > 0)
 			break;
 
-		ready = min(total - copied, cba.copied);
-
-		if (copy_to_user(&uxt[copied], cba.xt, ready * sizeof(cba.xt[0]))) {
-			ret = -EFAULT;
+		key = start;
+		ret = scoutfs_forest_read_items(sb, &key, &bloom_key, &start, &end,
+						read_xattr_total_item, &root);
+		if (ret < 0) {
+			if (ret == -ESTALE) {
+				free_all_xt_ents(&root);
+				continue;
+			}
 			goto out;
 		}
 
-		scoutfs_xattr_init_totl_key(&key, cba.xt[ready - 1].name);
-		scoutfs_key_inc(&key);
-		copied += ready;
+		if (RB_EMPTY_ROOT(&root))
+			break;
+
+		/* trim totals that fall outside of the consistent range */
+		for_each_xt_ent(ent, node, &root) {
+			scoutfs_xattr_init_totl_key(&key, ent->xt.name);
+			if (scoutfs_key_compare(&key, &start) < 0) {
+				free_xt_ent(&root, ent);
+			} else {
+				break;
+			}
+		}
+		for_each_xt_ent_reverse(ent, node, &root) {
+			scoutfs_xattr_init_totl_key(&key, ent->xt.name);
+			if (scoutfs_key_compare(&key, &end) > 0) {
+				free_xt_ent(&root, ent);
+			} else {
+				break;
+			}
+		}
+
+		/* copy resulting unique non-zero totals to userspace */
+		for_each_xt_ent(ent, node, &root) {
+			if (rxt.totals_bytes < sizeof(ent->xt))
+				break;
+
+			/* start with the fs item if we have it */
+			if (ent->fs_seq != 0) {
+				ent->xt.total = ent->fs_total;
+				ent->xt.count = ent->fs_count;
+				scoutfs_inc_counter(sb, totl_read_fs);
+			}
+
+			/* apply finalized logs if they're newer or creating */
+			if (((ent->fs_seq != 0) && (ent->fin_seq > ent->fs_seq)) ||
+			    ((ent->fs_seq == 0) && (ent->fin_count > 0))) {
+				ent->xt.total += ent->fin_total;
+				ent->xt.count += ent->fin_count;
+				scoutfs_inc_counter(sb, totl_read_finalized);
+			}
+
+			/* always apply active logs which must be newer than fs and finalized */
+			if (ent->log_seq > 0) {
+				ent->xt.total += ent->log_total;
+				ent->xt.count += ent->log_count;
+				scoutfs_inc_counter(sb, totl_read_logged);
+			}
+
+			if (ent->xt.total != 0 || ent->xt.count != 0) {
+				if (copy_to_user(uxt, &ent->xt, sizeof(ent->xt))) {
+					ret = -EFAULT;
+					goto out;
+				}
+
+				uxt++;
+				rxt.totals_bytes -= sizeof(ent->xt);
+				count++;
+				scoutfs_inc_counter(sb, totl_read_copied);
+			}
+
+			free_xt_ent(&root, ent);
+		}
+
+		/* continue after the last possible key read */
+		start = end;
+		scoutfs_key_inc(&start);
 	}
 
 	ret = 0;
 out:
-	if (cba.xt)
-		free_page((long)cba.xt);
+	free_all_xt_ents(&root);
 
-	return ret ?: copied;
+	return ret ?: count;
 }
 
 static long scoutfs_ioc_get_allocated_inos(struct file *file, unsigned long arg)
@@ -1326,265 +1504,6 @@ out:
 	return nr ?: ret;
 }
 
-static long scoutfs_ioc_get_attr_x(struct file *file, unsigned long arg)
-{
-	struct inode *inode = file_inode(file);
-	struct scoutfs_ioctl_inode_attr_x __user *uiax = (void __user *)arg;
-	struct scoutfs_ioctl_inode_attr_x *iax = NULL;
-	int ret;
-
-	iax = kmalloc(sizeof(struct scoutfs_ioctl_inode_attr_x), GFP_KERNEL);
-	if (!iax) {
-		ret = -ENOMEM;
-		goto out;
-	}
-
-	ret = get_user(iax->x_mask, &uiax->x_mask) ?:
-	      get_user(iax->x_flags, &uiax->x_flags);
-	if (ret < 0)
-		goto out;
-
-	ret = scoutfs_get_attr_x(inode, iax);
-	if (ret < 0)
-		goto out;
-
-	/* only copy results after dropping cluster locks (could fault) */
-	if (ret > 0 && copy_to_user(uiax, iax, ret) != 0)
-		ret = -EFAULT;
-	else
-		ret = 0;
-out:
-	kfree(iax);
-	return ret;
-}
-
-static long scoutfs_ioc_set_attr_x(struct file *file, unsigned long arg)
-{
-	struct inode *inode = file_inode(file);
-	struct scoutfs_ioctl_inode_attr_x __user *uiax = (void __user *)arg;
-	struct scoutfs_ioctl_inode_attr_x *iax = NULL;
-	int ret;
-
-	iax = kmalloc(sizeof(struct scoutfs_ioctl_inode_attr_x), GFP_KERNEL);
-	if (!iax) {
-		ret = -ENOMEM;
-		goto out;
-	}
-
-	if (copy_from_user(iax, uiax, sizeof(struct scoutfs_ioctl_inode_attr_x))) {
-		ret = -EFAULT;
-		goto out;
-	}
-
-	ret = mnt_want_write_file(file);
-	if (ret < 0)
-		goto out;
-
-	ret = scoutfs_set_attr_x(inode, iax);
-
-	mnt_drop_write_file(file);
-out:
-	kfree(iax);
-	return ret;
-}
-
-static long scoutfs_ioc_get_quota_rules(struct file *file, unsigned long arg)
-{
-	struct super_block *sb = file_inode(file)->i_sb;
-	struct scoutfs_ioctl_get_quota_rules __user *ugqr = (void __user *)arg;
-	struct scoutfs_ioctl_get_quota_rules gqr;
-	struct scoutfs_ioctl_quota_rule __user *uirules;
-	struct scoutfs_ioctl_quota_rule *irules;
-	struct page *page = NULL;
-	int copied = 0;
-	int nr;
-	int ret;
-
-	if (!capable(CAP_SYS_ADMIN))
-		return -EPERM;
-
-	if (copy_from_user(&gqr, ugqr, sizeof(gqr)))
-		return -EFAULT;
-
-	if (gqr.rules_nr == 0)
-		return 0;
-
-	uirules = (void __user *)gqr.rules_ptr;
-	/* limit rules copied per call */
-	gqr.rules_nr = min_t(u64, gqr.rules_nr, INT_MAX);
-
-	page = alloc_page(GFP_KERNEL | __GFP_ZERO);
-	if (!page) {
-		ret = -ENOMEM;
-		goto out;
-	}
-	irules = page_address(page);
-
-	while (copied < gqr.rules_nr) {
-		nr = min_t(u64, gqr.rules_nr - copied,
-				PAGE_SIZE / sizeof(struct scoutfs_ioctl_quota_rule));
-		ret = scoutfs_quota_get_rules(sb, gqr.iterator, page_address(page), nr);
-		if (ret <= 0)
-			goto out;
-
-		if (copy_to_user(&uirules[copied], irules, ret * sizeof(irules[0]))) {
-			ret = -EFAULT;
-			goto out;
-		}
-
-		copied += ret;
-	}
-
-	ret = 0;
-out:
-	if (page)
-		__free_page(page);
-
-	if (ret == 0 && copy_to_user(ugqr->iterator, gqr.iterator, sizeof(gqr.iterator)))
-		ret = -EFAULT;
-
-	return ret ?: copied;
-}
-
-static long scoutfs_ioc_mod_quota_rule(struct file *file, unsigned long arg, bool is_add)
-{
-	struct super_block *sb = file_inode(file)->i_sb;
-	struct scoutfs_ioctl_quota_rule __user *uirule = (void __user *)arg;
-	struct scoutfs_ioctl_quota_rule irule;
-
-	if (!capable(CAP_SYS_ADMIN))
-		return -EPERM;
-
-	if (copy_from_user(&irule, uirule, sizeof(irule)))
-		return -EFAULT;
-
-	return scoutfs_quota_mod_rule(sb, is_add, &irule);
-}
-
-struct read_index_buf {
-	int nr;
-	int size;
-	struct scoutfs_ioctl_xattr_index_entry ents[0];
-};
-
-#define READ_INDEX_BUF_MAX_ENTS \
-	((PAGE_SIZE - sizeof(struct read_index_buf)) / \
-		sizeof(struct scoutfs_ioctl_xattr_index_entry))
-
-/*
- * This doesn't filter out duplicates, the caller filters them out to
- * catch duplicates between iteration calls.
- */
-static int read_index_cb(struct scoutfs_key *key, void *val, unsigned int val_len, void *cb_arg)
-{
-	struct read_index_buf *rib = cb_arg;
-	struct scoutfs_ioctl_xattr_index_entry *ent = &rib->ents[rib->nr];
-	u64 xid;
-
-	if (val_len != 0)
-		return -EIO;
-
-	/* discard the xid, they're not exposed to ioctl callers */
-	scoutfs_xattr_get_indx_key(key, &ent->major, &ent->minor, &ent->ino, &xid);
-
-	if (++rib->nr == rib->size)
-		return rib->nr;
-
-	return -EAGAIN;
-}
-
-static long scoutfs_ioc_read_xattr_index(struct file *file, unsigned long arg)
-{
-	struct super_block *sb = file_inode(file)->i_sb;
-	struct scoutfs_ioctl_read_xattr_index __user *urxi = (void __user *)arg;
-	struct scoutfs_ioctl_xattr_index_entry __user *uents;
-	struct scoutfs_ioctl_xattr_index_entry *ent;
-	struct scoutfs_ioctl_xattr_index_entry prev;
-	struct scoutfs_ioctl_read_xattr_index rxi;
-	struct read_index_buf *rib;
-	struct page *page = NULL;
-	struct scoutfs_key first;
-	struct scoutfs_key last;
-	struct scoutfs_key start;
-	struct scoutfs_key end;
-	int copied = 0;
-	int ret;
-	int i;
-
-	if (!capable(CAP_SYS_ADMIN)) {
-		ret = -EPERM;
-		goto out;
-	}
-
-	if (copy_from_user(&rxi, urxi, sizeof(rxi))) {
-		ret = -EFAULT;
-		goto out;
-	}
-	uents = (void __user *)rxi.entries_ptr;
-	rxi.entries_nr = min_t(u64, rxi.entries_nr, INT_MAX);
-
-	page = alloc_page(GFP_KERNEL);
-	if (!page) {
-		ret = -ENOMEM;
-		goto out;
-	}
-	rib = page_address(page);
-
-	scoutfs_xattr_init_indx_key(&first, rxi.first.major, rxi.first.minor, rxi.first.ino, 0);
-	scoutfs_xattr_init_indx_key(&last, rxi.last.major, rxi.last.minor, rxi.last.ino, U64_MAX);
-	scoutfs_xattr_indx_get_range(&start, &end);
-
-	if (scoutfs_key_compare(&first, &last) > 0) {
-		ret = -EINVAL;
-		goto out;
-	}
-
-	/* 0 ino doesn't exist, can't ever match entry to return */
-	memset(&prev, 0, sizeof(prev));
-
-	while (copied < rxi.entries_nr) {
-		rib->nr = 0;
-		rib->size = min_t(u64, rxi.entries_nr - copied, READ_INDEX_BUF_MAX_ENTS);
-		ret = scoutfs_wkic_iterate(sb, &first, &last, &start, &end,
-					   read_index_cb, rib);
-		if (ret < 0)
-			goto out;
-		if (rib->nr == 0)
-			break;
-
-		/*
-		 * Copy entries to userspace, skipping duplicate entries
-		 * that can result from multiple xattrs indexing an
-		 * inode at the same position and which can span
-		 * multiple cache iterations.  (Comparing in order of
-		 * most likely to change to fail fast.)
-		 */
-		for (i = 0, ent = rib->ents; i < rib->nr; i++, ent++) {
-			if (ent->ino == prev.ino && ent->minor == prev.minor &&
-			    ent->major == prev.major)
-				continue;
-
-			if (copy_to_user(&uents[copied], ent, sizeof(*ent))) {
-				ret = -EFAULT;
-				goto out;
-			}
-
-			prev = *ent;
-			copied++;
-		}
-
-		scoutfs_xattr_init_indx_key(&first, prev.major, prev.minor, prev.ino, U64_MAX);
-		scoutfs_key_inc(&first);
-	}
-
-	ret = copied;
-out:
-	if (page)
-		__free_page(page);
-
-	return ret;
-}
-
 long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	switch (cmd) {
@@ -1622,18 +1541,6 @@ long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 		return scoutfs_ioc_get_allocated_inos(file, arg);
 	case SCOUTFS_IOC_GET_REFERRING_ENTRIES:
 		return scoutfs_ioc_get_referring_entries(file, arg);
-	case SCOUTFS_IOC_GET_ATTR_X:
-		return scoutfs_ioc_get_attr_x(file, arg);
-	case SCOUTFS_IOC_SET_ATTR_X:
-		return scoutfs_ioc_set_attr_x(file, arg);
-	case SCOUTFS_IOC_GET_QUOTA_RULES:
-		return scoutfs_ioc_get_quota_rules(file, arg);
-	case SCOUTFS_IOC_ADD_QUOTA_RULE:
-		return scoutfs_ioc_mod_quota_rule(file, arg, true);
-	case SCOUTFS_IOC_DEL_QUOTA_RULE:
-		return scoutfs_ioc_mod_quota_rule(file, arg, false);
-	case SCOUTFS_IOC_READ_XATTR_INDEX:
-		return scoutfs_ioc_read_xattr_index(file, arg);
 	}
 
 	return -ENOTTY;

kmod/src/ioctl.h

@@ -673,174 +673,4 @@ struct scoutfs_ioctl_dirent {
 #define SCOUTFS_IOC_GET_REFERRING_ENTRIES \
 	_IOW(SCOUTFS_IOCTL_MAGIC, 17, struct scoutfs_ioctl_get_referring_entries)
 
-struct scoutfs_ioctl_inode_attr_x {
-	__u64 x_mask;
-	__u64 x_flags;
-	__u64 meta_seq;
-	__u64 data_seq;
-	__u64 data_version;
-	__u64 online_blocks;
-	__u64 offline_blocks;
-	__u64 ctime_sec;
-	__u32 ctime_nsec;
-	__u32 crtime_nsec;
-	__u64 crtime_sec;
-	__u64 size;
-	__u64 bits;
-	__u64 project_id;
-};
-
-/*
- * Behavioral flags set in the x_flags field.  These flags don't
- * necessarily correspond to specific attributes, but instead change the
- * behaviour of a _get_ or _set_ operation.
- *
- * @SCOUTFS_IOC_IAX_F_SIZE_OFFLINE: When setting i_size, also create
- * extents which are marked offline for the region of the file from
- * offset 0 to the new set size.  This can only be set when setting the
- * size and has no effect if setting the size fails.
- */
-#define SCOUTFS_IOC_IAX_F_SIZE_OFFLINE	(1ULL << 0)
-#define SCOUTFS_IOC_IAX_F__UNKNOWN	(U64_MAX << 1)
-
-/*
- * Single-bit values stored in the @bits field.  These indicate whether
- * the bit is set, or not.  The main _IAX_ bits set in the mask indicate
- * whether this value bit is populated by _get or stored by _set. 
- */
-#define SCOUTFS_IOC_IAX_B_RETENTION	(1ULL << 0)
-
-/*
- * x_mask bits which indicate which attributes of the inode to populate
- * on return for _get or to set on the inode for _set.  Each mask bit
- * corresponds to the matching named field in the attr_x struct passed
- * to the _get_ and _set_ calls.
- *
- * Each field can have different permissions or other attribute
- * requirements which can cause calls to fail.  If _set_ fails then no
- * other attribute changes will have been made by the same call.
- *
- * @SCOUTFS_IOC_IAX_RETENTION: Mark a file for retention.  When marked,
- * no modification can be made to the file other than changing extended
- * attributes outside the "user." prefix and clearing the retention
- * mark.  This can only be set on regular files and requires root (the
- * CAP_SYS_ADMIN capability).  Other attributes can be set with a
- * set_attr_x call on a retention inode as long as that call also
- * successfully clears the retention mark.
- */
-#define SCOUTFS_IOC_IAX_META_SEQ	(1ULL << 0)
-#define SCOUTFS_IOC_IAX_DATA_SEQ	(1ULL << 1)
-#define SCOUTFS_IOC_IAX_DATA_VERSION	(1ULL << 2)
-#define SCOUTFS_IOC_IAX_ONLINE_BLOCKS	(1ULL << 3)
-#define SCOUTFS_IOC_IAX_OFFLINE_BLOCKS	(1ULL << 4)
-#define SCOUTFS_IOC_IAX_CTIME		(1ULL << 5)
-#define SCOUTFS_IOC_IAX_CRTIME		(1ULL << 6)
-#define SCOUTFS_IOC_IAX_SIZE		(1ULL << 7)
-#define SCOUTFS_IOC_IAX_RETENTION	(1ULL << 8)
-#define SCOUTFS_IOC_IAX_PROJECT_ID	(1ULL << 9)
-
-/* single bit attributes that are packed in the bits field as _B_ */
-#define SCOUTFS_IOC_IAX__BITS		(SCOUTFS_IOC_IAX_RETENTION)
-/* inverse of all the bits we understand */
-#define SCOUTFS_IOC_IAX__UNKNOWN	(U64_MAX << 10)
-
-#define SCOUTFS_IOC_GET_ATTR_X \
-	_IOW(SCOUTFS_IOCTL_MAGIC, 18, struct scoutfs_ioctl_inode_attr_x)
-
-#define SCOUTFS_IOC_SET_ATTR_X \
-	_IOW(SCOUTFS_IOCTL_MAGIC, 19, struct scoutfs_ioctl_inode_attr_x)
-
-/*
- * (These fields are documented in the order that they're displayed by
- * the scoutfs cli utility which matches the sort order of the rules.)
- *
- * @prio: The priority of the rule.  Rules are sorted by their fields
- * with prio at the highest magnitude.  When multiple rules match the
- * rule with the highest sort order is enforced.  The priority field
- * lets rules override the default field sort order.
- *
- * @name_val[3]: The three 64bit values that make up the name of the
- * totl xattr whose total will be checked against the rule's limit to
- * see if the quota rule has been exceeded.  The behavior of the values
- * can be changed by their corresponding name_source and name_flags.
- *
- * @name_source[3]: The SQ_NS_ enums that control where the value comes
- * from.  _LITERAL uses the value from name_val.  Inode attribute
- * sources (_PROJ, _UID, _GID) are taken from the inode of the operation
- * that is being checked against the rule.
- *
- * @name_flags[3]: The SQ_NF_ enums that alter the name values.  _SELECT
- * makes the rule only match if the inode attribute of the operation
- * matches the attribute value stored in name_val.  This lets rules
- * match a specific value of an attribute rather than mapping all
- * attribute values of to totl names.
- *
- * @op: The SQ_OP_ enums which specify the operation that can't exceed
- * the rule's limit.  _INODE checks inode creation and the inode
- * attributes are taken from the inode that would be created.  _DATA
- * checks file data block allocation and the inode fields come from the
- * inode that is allocating the blocks.
- *
- * @limit: The 64bit value that is checked against the totl value
- * described by the rule.  If the totl value is greater than or equal to
- * this value of the matching rule then the operation will return
- * -EDQUOT.
- *
- * @rule_flags: SQ_RF_TOTL_COUNT indicates that the rule's limit should
- * be checked against the number of xattrs contributing to a totl value
- * instead of the sum of the xattrs.
- */
-struct scoutfs_ioctl_quota_rule {
-	__u64 name_val[3];
-	__u64 limit;
-	__u8 prio;
-	__u8 op;
-	__u8 rule_flags;
-	__u8 name_source[3];
-	__u8 name_flags[3];
-	__u8 _pad[7];
-};
-
-struct scoutfs_ioctl_get_quota_rules {
-	__u64 iterator[2];
-	__u64 rules_ptr;
-	__u64 rules_nr;
-};
-
-/*
- * Rules are uniquely identified by their non-padded fields.  Addition will fail
- * with -EEXIST if the specified rule already exists and deletion must find a rule
- * with all matching fields to delete.
- */
-#define SCOUTFS_IOC_GET_QUOTA_RULES \
-	_IOR(SCOUTFS_IOCTL_MAGIC, 20, struct scoutfs_ioctl_get_quota_rules)
-#define SCOUTFS_IOC_ADD_QUOTA_RULE \
-	_IOW(SCOUTFS_IOCTL_MAGIC, 21, struct scoutfs_ioctl_quota_rule)
-#define SCOUTFS_IOC_DEL_QUOTA_RULE \
-	_IOW(SCOUTFS_IOCTL_MAGIC, 22, struct scoutfs_ioctl_quota_rule)
-
-/*
- * Inodes can be indexed in a global key space at a position determined
- * by a .indx. tagged xattr.  The xattr name specifies the two index
- * position values, with major having the more significant comparison
- * order.
- */
-struct scoutfs_ioctl_xattr_index_entry {
-	__u64 minor;
-	__u64 ino;
-	__u8 major;
-	__u8 _pad[7];
-};
-
-struct scoutfs_ioctl_read_xattr_index {
-	__u64 flags;
-	struct scoutfs_ioctl_xattr_index_entry first;
-	struct scoutfs_ioctl_xattr_index_entry last;
-	__u64 entries_ptr;
-	__u64 entries_nr;
-};
-
-#define SCOUTFS_IOC_READ_XATTR_INDEX \
-	_IOR(SCOUTFS_IOCTL_MAGIC, 23, struct scoutfs_ioctl_read_xattr_index)
-
 #endif

kmod/src/item.c

@@ -24,7 +24,6 @@
 #include "item.h"
 #include "forest.h"
 #include "block.h"
-#include "msg.h"
 #include "trans.h"
 #include "counters.h"
 #include "scoutfs_trace.h"
@@ -1671,24 +1670,13 @@ out:
 	return ret;
 }
 
-static int lock_safe(struct super_block *sb, struct scoutfs_lock *lock, struct scoutfs_key *key,
+static int lock_safe(struct scoutfs_lock *lock, struct scoutfs_key *key,
 		     int mode)
 {
-	bool prot = scoutfs_lock_protected(lock, key, mode);
-
-	if (!prot) {
-		static bool once = false;
-		if (!once) {
-			scoutfs_err(sb, "lock (start "SK_FMT" end "SK_FMT" mode 0x%x) does not protect operation (key "SK_FMT" mode 0x%x)",
-				    SK_ARG(&lock->start), SK_ARG(&lock->end), lock->mode,
-				    SK_ARG(key), mode);
-			dump_stack();
-			once = true;
-		}
+	if (WARN_ON_ONCE(!scoutfs_lock_protected(lock, key, mode)))
 		return -EINVAL;
-	}
-
-	return 0;
+	else
+		return 0;
 }
 
 static int optional_lock_mode_match(struct scoutfs_lock *lock, int mode)
@@ -1720,8 +1708,8 @@ static int copy_val(void *dst, int dst_len, void *src, int src_len)
  * The amount of bytes copied is returned which can be 0 or truncated if
  * the caller's buffer isn't big enough.
  */
-static int item_lookup(struct super_block *sb, struct scoutfs_key *key,
-		       void *val, int val_len, int len_limit, struct scoutfs_lock *lock)
+int scoutfs_item_lookup(struct super_block *sb, struct scoutfs_key *key,
+			void *val, int val_len, struct scoutfs_lock *lock)
 {
 	DECLARE_ITEM_CACHE_INFO(sb, cinf);
 	struct cached_item *item;
@@ -1730,7 +1718,7 @@ static int item_lookup(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_lookup);
 
-	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_READ)))
+	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_READ)))
 		goto out;
 
 	ret = get_cached_page(sb, cinf, lock, key, false, false, 0, &pg);
@@ -1741,8 +1729,6 @@ static int item_lookup(struct super_block *sb, struct scoutfs_key *key,
 	item = item_rbtree_walk(&pg->item_root, key, NULL, NULL, NULL);
 	if (!item || item->deletion)
 		ret = -ENOENT;
-	else if (len_limit > 0 && item->val_len > len_limit)
-		ret = -EIO;
 	else
 		ret = copy_val(val, val_len, item->val, item->val_len);
 
@@ -1751,38 +1737,13 @@ out:
 	return ret;
 }
 
-int scoutfs_item_lookup(struct super_block *sb, struct scoutfs_key *key,
-			void *val, int val_len, struct scoutfs_lock *lock)
-{
-	return item_lookup(sb, key, val, val_len, 0, lock);
-}
-
-/*
- * Copy an item's value into the caller's buffer.  If the item's value
- * is larger than the caller's buffer then -EIO is returned.  If the
- * item is smaller then the bytes from the end of the copied value to
- * the end of the buffer are zeroed.  The number of value bytes copied
- * is returned, and 0 can be returned for an item with no value.
- */
-int scoutfs_item_lookup_smaller_zero(struct super_block *sb, struct scoutfs_key *key,
-				     void *val, int val_len, struct scoutfs_lock *lock)
-{
-	int ret;
-
-	ret = item_lookup(sb, key, val, val_len, val_len, lock);
-	if (ret >= 0 && ret < val_len)
-		memset(val + ret, 0, val_len - ret);
-
-	return ret;
-}
-
 int scoutfs_item_lookup_exact(struct super_block *sb, struct scoutfs_key *key,
 			      void *val, int val_len,
 			      struct scoutfs_lock *lock)
 {
 	int ret;
 
-	ret = item_lookup(sb, key, val, val_len, 0, lock);
+	ret = scoutfs_item_lookup(sb, key, val, val_len, lock);
 	if (ret == val_len)
 		ret = 0;
 	else if (ret >= 0)
@@ -1832,7 +1793,7 @@ int scoutfs_item_next(struct super_block *sb, struct scoutfs_key *key,
 		goto out;
 	}
 
-	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_READ)))
+	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_READ)))
 		goto out;
 
 	pos = *key;
@@ -1913,7 +1874,7 @@ int scoutfs_item_dirty(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_dirty);
 
-	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_WRITE)))
+	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_WRITE)))
 		goto out;
 
 	ret = scoutfs_forest_set_bloom_bits(sb, lock);
@@ -1959,7 +1920,7 @@ static int item_create(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_create);
 
-	if ((ret = lock_safe(sb, lock, key, mode)) ||
+	if ((ret = lock_safe(lock, key, mode)) ||
 	    (ret = optional_lock_mode_match(primary, SCOUTFS_LOCK_WRITE)))
 		goto out;
 
@@ -2002,7 +1963,7 @@ int scoutfs_item_create(struct super_block *sb, struct scoutfs_key *key,
 			void *val, int val_len, struct scoutfs_lock *lock)
 {
 	return item_create(sb, key, val, val_len, lock, NULL,
-			   SCOUTFS_LOCK_WRITE, false);
+			   SCOUTFS_LOCK_READ, false);
 }
 
 int scoutfs_item_create_force(struct super_block *sb, struct scoutfs_key *key,
@@ -2033,7 +1994,7 @@ int scoutfs_item_update(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_update);
 
-	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_WRITE)))
+	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_WRITE)))
 		goto out;
 
 	ret = scoutfs_forest_set_bloom_bits(sb, lock);
@@ -2101,7 +2062,7 @@ int scoutfs_item_delta(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_delta);
 
-	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_WRITE_ONLY)))
+	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_WRITE_ONLY)))
 		goto out;
 
 	ret = scoutfs_forest_set_bloom_bits(sb, lock);
@@ -2174,7 +2135,7 @@ static int item_delete(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_delete);
 
-	if ((ret = lock_safe(sb, lock, key, mode)) ||
+	if ((ret = lock_safe(lock, key, mode)) ||
 	    (ret = optional_lock_mode_match(primary, SCOUTFS_LOCK_WRITE)))
 		goto out;
 

kmod/src/item.h

@@ -3,8 +3,6 @@
 
 int scoutfs_item_lookup(struct super_block *sb, struct scoutfs_key *key,
 			void *val, int val_len, struct scoutfs_lock *lock);
-int scoutfs_item_lookup_smaller_zero(struct super_block *sb, struct scoutfs_key *key,
-				     void *val, int val_len, struct scoutfs_lock *lock);
 int scoutfs_item_lookup_exact(struct super_block *sb, struct scoutfs_key *key,
 			      void *val, int val_len,
 			      struct scoutfs_lock *lock);

kmod/src/lock.c

@@ -36,8 +36,6 @@
 #include "item.h"
 #include "omap.h"
 #include "util.h"
-#include "totl.h"
-#include "quota.h"
 
 /*
  * scoutfs uses a lock service to manage item cache consistency between
@@ -187,9 +185,6 @@ static int lock_invalidate(struct super_block *sb, struct scoutfs_lock *lock,
 			return ret;
 	}
 
-	if (lock->start.sk_zone == SCOUTFS_QUOTA_ZONE && !lock_mode_can_read(mode))
-		scoutfs_quota_invalidate(sb);
-
 	/* have to invalidate if we're not in the only usable case */
 	if (!(prev == SCOUTFS_LOCK_WRITE && mode == SCOUTFS_LOCK_READ)) {
 retry:
@@ -1249,29 +1244,10 @@ int scoutfs_lock_xattr_totl(struct super_block *sb, enum scoutfs_lock_mode mode,
 	struct scoutfs_key start;
 	struct scoutfs_key end;
 
-	scoutfs_totl_set_range(&start, &end);
-
-	return lock_key_range(sb, mode, flags, &start, &end, lock);
-}
-
-int scoutfs_lock_xattr_indx(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
-			    struct scoutfs_lock **lock)
-{
-	struct scoutfs_key start;
-	struct scoutfs_key end;
-
-	scoutfs_xattr_indx_get_range(&start, &end);
-
-	return lock_key_range(sb, mode, flags, &start, &end, lock);
-}
-
-int scoutfs_lock_quota(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
-		       struct scoutfs_lock **lock)
-{
-	struct scoutfs_key start;
-	struct scoutfs_key end;
-
-	scoutfs_quota_get_lock_range(&start, &end);
+	scoutfs_key_set_zeros(&start);
+	start.sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
+	scoutfs_key_set_ones(&end);
+	end.sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
 
 	return lock_key_range(sb, mode, flags, &start, &end, lock);
 }

kmod/src/lock.h

@@ -86,10 +86,6 @@ int scoutfs_lock_orphan(struct super_block *sb, enum scoutfs_lock_mode mode, int
 		        u64 ino, struct scoutfs_lock **lock);
 int scoutfs_lock_xattr_totl(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
 			    struct scoutfs_lock **lock);
-int scoutfs_lock_xattr_indx(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
-			    struct scoutfs_lock **lock);
-int scoutfs_lock_quota(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
-		       struct scoutfs_lock **lock);
 void scoutfs_unlock(struct super_block *sb, struct scoutfs_lock *lock,
 		    enum scoutfs_lock_mode mode);
 

kmod/src/options.c

@@ -33,7 +33,6 @@ enum {
 	Opt_acl,
 	Opt_data_prealloc_blocks,
 	Opt_data_prealloc_contig_only,
-	Opt_log_merge_wait_timeout_ms,
 	Opt_metadev_path,
 	Opt_noacl,
 	Opt_orphan_scan_delay_ms,
@@ -46,7 +45,6 @@ static const match_table_t tokens = {
 	{Opt_acl, "acl"},
 	{Opt_data_prealloc_blocks, "data_prealloc_blocks=%s"},
 	{Opt_data_prealloc_contig_only, "data_prealloc_contig_only=%s"},
-	{Opt_log_merge_wait_timeout_ms, "log_merge_wait_timeout_ms=%s"},
 	{Opt_metadev_path, "metadev_path=%s"},
 	{Opt_noacl, "noacl"},
 	{Opt_orphan_scan_delay_ms, "orphan_scan_delay_ms=%s"},
@@ -115,10 +113,6 @@ static void free_options(struct scoutfs_mount_options *opts)
 	kfree(opts->metadev_path);
 }
 
-#define MIN_LOG_MERGE_WAIT_TIMEOUT_MS		100UL
-#define DEFAULT_LOG_MERGE_WAIT_TIMEOUT_MS	500
-#define MAX_LOG_MERGE_WAIT_TIMEOUT_MS		(60 * MSEC_PER_SEC)
-
 #define MIN_ORPHAN_SCAN_DELAY_MS	100UL
 #define DEFAULT_ORPHAN_SCAN_DELAY_MS	(10 * MSEC_PER_SEC)
 #define MAX_ORPHAN_SCAN_DELAY_MS	(60 * MSEC_PER_SEC)
@@ -132,27 +126,11 @@ static void init_default_options(struct scoutfs_mount_options *opts)
 
 	opts->data_prealloc_blocks = SCOUTFS_DATA_PREALLOC_DEFAULT_BLOCKS;
 	opts->data_prealloc_contig_only = 1;
-	opts->log_merge_wait_timeout_ms = DEFAULT_LOG_MERGE_WAIT_TIMEOUT_MS;
 	opts->orphan_scan_delay_ms = -1;
 	opts->quorum_heartbeat_timeout_ms = SCOUTFS_QUORUM_DEF_HB_TIMEO_MS;
 	opts->quorum_slot_nr = -1;
 }
 
-static int verify_log_merge_wait_timeout_ms(struct super_block *sb, int ret, int val)
-{
-	if (ret < 0) {
-		scoutfs_err(sb, "failed to parse log_merge_wait_timeout_ms value");
-		return -EINVAL;
-	}
-	if (val < MIN_LOG_MERGE_WAIT_TIMEOUT_MS || val > MAX_LOG_MERGE_WAIT_TIMEOUT_MS) {
-		scoutfs_err(sb, "invalid log_merge_wait_timeout_ms value %d, must be between %lu and %lu",
-			    val, MIN_LOG_MERGE_WAIT_TIMEOUT_MS, MAX_LOG_MERGE_WAIT_TIMEOUT_MS);
-		return -EINVAL;
-	}
-
-	return 0;
-}
-
 static int verify_quorum_heartbeat_timeout_ms(struct super_block *sb, int ret, u64 val)
 {
 	if (ret < 0) {
@@ -218,14 +196,6 @@ static int parse_options(struct super_block *sb, char *options, struct scoutfs_m
 			opts->data_prealloc_contig_only = nr;
 			break;
 
-		case Opt_log_merge_wait_timeout_ms:
-			ret = match_int(args, &nr);
-			ret = verify_log_merge_wait_timeout_ms(sb, ret, nr);
-			if (ret < 0)
-				return ret;
-			opts->log_merge_wait_timeout_ms = nr;
-			break;
-
 		case Opt_metadev_path:
 			ret = parse_bdev_path(sb, &args[0], &opts->metadev_path);
 			if (ret < 0)
@@ -452,43 +422,6 @@ static ssize_t data_prealloc_contig_only_store(struct kobject *kobj, struct kobj
 }
 SCOUTFS_ATTR_RW(data_prealloc_contig_only);
 
-static ssize_t log_merge_wait_timeout_ms_show(struct kobject *kobj, struct kobj_attribute *attr,
-						char *buf)
-{
-	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
-	struct scoutfs_mount_options opts;
-
-	scoutfs_options_read(sb, &opts);
-
-	return snprintf(buf, PAGE_SIZE, "%u", opts.log_merge_wait_timeout_ms);
-}
-static ssize_t log_merge_wait_timeout_ms_store(struct kobject *kobj, struct kobj_attribute *attr,
-						 const char *buf, size_t count)
-{
-	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
-	DECLARE_OPTIONS_INFO(sb, optinf);
-	char nullterm[30]; /* more than enough for octal -U64_MAX */
-	int val;
-	int len;
-	int ret;
-
-	len = min(count, sizeof(nullterm) - 1);
-	memcpy(nullterm, buf, len);
-	nullterm[len] = '\0';
-
-	ret = kstrtoint(nullterm, 0, &val);
-	ret = verify_log_merge_wait_timeout_ms(sb, ret, val);
-	if (ret == 0) {
-		write_seqlock(&optinf->seqlock);
-		optinf->opts.log_merge_wait_timeout_ms = val;
-		write_sequnlock(&optinf->seqlock);
-		ret = count;
-	}
-
-	return ret;
-}
-SCOUTFS_ATTR_RW(log_merge_wait_timeout_ms);
-
 static ssize_t metadev_path_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
 {
 	struct super_block *sb = SCOUTFS_SYSFS_ATTRS_SB(kobj);
@@ -592,7 +525,6 @@ SCOUTFS_ATTR_RO(quorum_slot_nr);
 static struct attribute *options_attrs[] = {
 	SCOUTFS_ATTR_PTR(data_prealloc_blocks),
 	SCOUTFS_ATTR_PTR(data_prealloc_contig_only),
-	SCOUTFS_ATTR_PTR(log_merge_wait_timeout_ms),
 	SCOUTFS_ATTR_PTR(metadev_path),
 	SCOUTFS_ATTR_PTR(orphan_scan_delay_ms),
 	SCOUTFS_ATTR_PTR(quorum_heartbeat_timeout_ms),

kmod/src/options.h

@@ -8,7 +8,6 @@
 struct scoutfs_mount_options {
 	u64 data_prealloc_blocks;
 	bool data_prealloc_contig_only;
-	unsigned int log_merge_wait_timeout_ms;
 	char *metadev_path;
 	unsigned int orphan_scan_delay_ms;
 	int quorum_slot_nr;

kmod/src/quota.h

@@ -1,48 +0,0 @@
-#ifndef _SCOUTFS_QUOTA_H_
-#define _SCOUTFS_QUOTA_H_
-
-#include "ioctl.h"
-
-/*
- * Each rule's name can be in the ruleset's rbtree associated with the
- * source attr that it selects.  This lets checks only test rules that
- * the inputs could match.  The 'i' field indicates which name is in the
- * tree so we can find the containing rule.
- *
- * This is mostly private to quota.c but we expose it for tracing.
- */
-struct squota_rule {
-	u64 limit;
-	u8 prio;
-	u8 op;
-	u8 rule_flags;
-	struct squota_rule_name {
-		struct rb_node node;
-		u64 val;
-		u8 source;
-		u8 flags;
-		u8 i;
-	} names[3];
-};
-
-/* private to quota.c, only here for tracing */
-struct squota_input {
-	u64 attrs[SQ_NS__NR_SELECT];
-	u8 op;
-};
-
-int scoutfs_quota_check_inode(struct super_block *sb, struct inode *dir);
-int scoutfs_quota_check_data(struct super_block *sb, struct inode *inode);
-
-int scoutfs_quota_get_rules(struct super_block *sb, u64 *iterator,
-			    struct scoutfs_ioctl_quota_rule *irules, int nr);
-int scoutfs_quota_mod_rule(struct super_block *sb, bool is_add,
-			   struct scoutfs_ioctl_quota_rule *irule);
-
-void scoutfs_quota_get_lock_range(struct scoutfs_key *start, struct scoutfs_key *end);
-void scoutfs_quota_invalidate(struct super_block *sb);
-
-int scoutfs_quota_setup(struct super_block *sb);
-void scoutfs_quota_destroy(struct super_block *sb);
-
-#endif

kmod/src/scoutfs_trace.h

@@ -37,10 +37,6 @@
 #include "net.h"
 #include "data.h"
 #include "ext.h"
-#include "quota.h"
-
-#include "trace/quota.h"
-#include "trace/wkic.h"
 
 struct lock_info;
 
@@ -1751,41 +1747,21 @@ TRACE_EVENT(scoutfs_btree_merge,
 		  sk_trace_args(end))
 );
 
-TRACE_EVENT(scoutfs_btree_merge_read_range,
-	TP_PROTO(struct super_block *sb, struct scoutfs_key *start, struct scoutfs_key *end,
-		 int size),
-
-	TP_ARGS(sb, start, end, size),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		sk_trace_define(start)
-		sk_trace_define(end)
-		__field(int, size)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		sk_trace_assign(start, start);
-		sk_trace_assign(end, end);
-		__entry->size = size;
-	),
-
-	TP_printk(SCSBF" start "SK_FMT" end "SK_FMT" size %d",
-		  SCSB_TRACE_ARGS, sk_trace_args(start), sk_trace_args(end), __entry->size)
-);
-
 TRACE_EVENT(scoutfs_btree_merge_items,
 	TP_PROTO(struct super_block *sb,
+		 struct scoutfs_btree_root *m_root,
 		 struct scoutfs_key *m_key, int m_val_len,
 		 struct scoutfs_btree_root *f_root,
 		 struct scoutfs_key *f_key, int f_val_len,
 		 int is_del),
 
-	TP_ARGS(sb, m_key, m_val_len, f_root, f_key, f_val_len, is_del),
+	TP_ARGS(sb, m_root, m_key, m_val_len, f_root, f_key, f_val_len, is_del),
 
 	TP_STRUCT__entry(
 		SCSB_TRACE_FIELDS
+		__field(__u64, m_root_blkno)
+		__field(__u64, m_root_seq)
+		__field(__u8, m_root_height)
 		sk_trace_define(m_key)
 		__field(int, m_val_len)
 		__field(__u64, f_root_blkno)
@@ -1798,6 +1774,10 @@ TRACE_EVENT(scoutfs_btree_merge_items,
 
 	TP_fast_assign(
 		SCSB_TRACE_ASSIGN(sb);
+		__entry->m_root_blkno = m_root ?
+					le64_to_cpu(m_root->ref.blkno) : 0;
+		__entry->m_root_seq = m_root ? le64_to_cpu(m_root->ref.seq) : 0;
+		__entry->m_root_height = m_root ? m_root->height : 0;
 		sk_trace_assign(m_key, m_key);
 		__entry->m_val_len = m_val_len;
 		__entry->f_root_blkno = f_root ?
@@ -1809,9 +1789,11 @@ TRACE_EVENT(scoutfs_btree_merge_items,
 		__entry->is_del = !!is_del;
 	),
 
-	TP_printk(SCSBF" merge item key "SK_FMT" val_len %d, fs item root blkno %llu seq %llu height %u key "SK_FMT" val_len %d, is_del %d",
-		  SCSB_TRACE_ARGS, sk_trace_args(m_key), __entry->m_val_len,
-		  __entry->f_root_blkno, __entry->f_root_seq, __entry->f_root_height,
+	TP_printk(SCSBF" merge item root blkno %llu seq %llu height %u key "SK_FMT" val_len %d, fs item root blkno %llu seq %llu height %u key "SK_FMT" val_len %d, is_del %d",
+		  SCSB_TRACE_ARGS, __entry->m_root_blkno, __entry->m_root_seq,
+		  __entry->m_root_height, sk_trace_args(m_key),
+		  __entry->m_val_len, __entry->f_root_blkno,
+		  __entry->f_root_seq, __entry->f_root_height,
 		  sk_trace_args(f_key), __entry->f_val_len, __entry->is_del)
 );
 
@@ -2094,71 +2076,6 @@ TRACE_EVENT(scoutfs_trans_seq_last,
 		  SCSB_TRACE_ARGS, __entry->s_rid, __entry->trans_seq)
 );
 
-TRACE_EVENT(scoutfs_server_finalize_items,
-	TP_PROTO(struct super_block *sb, u64 rid, u64 item_rid, u64 item_nr, u64 item_flags,
-		 u64 item_get_trans_seq),
-
-	TP_ARGS(sb, rid, item_rid, item_nr, item_flags, item_get_trans_seq),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(__u64, c_rid)
-		__field(__u64, item_rid)
-		__field(__u64, item_nr)
-		__field(__u64, item_flags)
-		__field(__u64, item_get_trans_seq)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->c_rid = rid;
-		__entry->item_rid = item_rid;
-		__entry->item_nr = item_nr;
-		__entry->item_flags = item_flags;
-		__entry->item_get_trans_seq = item_get_trans_seq;
-	),
-
-	TP_printk(SCSBF" rid %016llx item_rid %016llx item_nr %llu item_flags 0x%llx item_get_trans_seq %llu",
-		  SCSB_TRACE_ARGS, __entry->c_rid, __entry->item_rid, __entry->item_nr,
-		  __entry->item_flags, __entry->item_get_trans_seq)
-);
-
-TRACE_EVENT(scoutfs_server_finalize_decision,
-	TP_PROTO(struct super_block *sb, u64 rid, bool saw_finalized, bool others_active,
-		 bool ours_visible, bool finalize_ours, unsigned int delay_ms,
-		 u64 finalize_sent_seq),
-
-	TP_ARGS(sb, rid, saw_finalized, others_active, ours_visible, finalize_ours, delay_ms,
-		finalize_sent_seq),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(__u64, c_rid)
-		__field(bool, saw_finalized)
-		__field(bool, others_active)
-		__field(bool, ours_visible)
-		__field(bool, finalize_ours)
-		__field(unsigned int, delay_ms)
-		__field(__u64, finalize_sent_seq)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->c_rid = rid;
-		__entry->saw_finalized = saw_finalized;
-		__entry->others_active = others_active;
-		__entry->ours_visible = ours_visible;
-		__entry->finalize_ours = finalize_ours;
-		__entry->delay_ms = delay_ms;
-		__entry->finalize_sent_seq = finalize_sent_seq;
-	),
-
-	TP_printk(SCSBF" rid %016llx saw_finalized %u others_active %u ours_visible %u finalize_ours %u delay_ms %u finalize_sent_seq %llu",
-		  SCSB_TRACE_ARGS, __entry->c_rid, __entry->saw_finalized, __entry->others_active,
-		  __entry->ours_visible, __entry->finalize_ours, __entry->delay_ms,
-		  __entry->finalize_sent_seq)
-);
-
 TRACE_EVENT(scoutfs_get_log_merge_status,
 	TP_PROTO(struct super_block *sb, u64 rid, struct scoutfs_key *next_range_key,
 		 u64 nr_requests, u64 nr_complete, u64 seq),
@@ -2399,44 +2316,6 @@ TRACE_EVENT(scoutfs_block_dirty_ref,
 		  __entry->block_blkno, __entry->block_seq)
 );
 
-TRACE_EVENT(scoutfs_block_stale,
-	TP_PROTO(struct super_block *sb, struct scoutfs_block_ref *ref,
-		 struct scoutfs_block_header *hdr, u32 magic, u32 crc),
-
-	TP_ARGS(sb, ref, hdr, magic, crc),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(__u64, ref_blkno)
-		__field(__u64, ref_seq)
-		__field(__u32, hdr_crc)
-		__field(__u32, hdr_magic)
-		__field(__u64, hdr_fsid)
-		__field(__u64, hdr_seq)
-		__field(__u64, hdr_blkno)
-		__field(__u32, magic)
-		__field(__u32, crc)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->ref_blkno = le64_to_cpu(ref->blkno);
-		__entry->ref_seq = le64_to_cpu(ref->seq);
-		__entry->hdr_crc = le32_to_cpu(hdr->crc);
-		__entry->hdr_magic = le32_to_cpu(hdr->magic);
-		__entry->hdr_fsid = le64_to_cpu(hdr->fsid);
-		__entry->hdr_seq = le64_to_cpu(hdr->seq);
-		__entry->hdr_blkno = le64_to_cpu(hdr->blkno);
-		__entry->magic = magic;
-		__entry->crc = crc;
-	),
-
-	TP_printk(SCSBF" ref_blkno %llu ref_seq %016llx hdr_crc %08x hdr_magic %08x hdr_fsid %016llx hdr_seq %016llx hdr_blkno %llu magic %08x crc %08x",
-		  SCSB_TRACE_ARGS, __entry->ref_blkno, __entry->ref_seq, __entry->hdr_crc,
-		  __entry->hdr_magic, __entry->hdr_fsid, __entry->hdr_seq, __entry->hdr_blkno,
-		  __entry->magic, __entry->crc)
-);
-
 DECLARE_EVENT_CLASS(scoutfs_block_class,
 	TP_PROTO(struct super_block *sb, void *bp, u64 blkno, int refcount, int io_count,
 		 unsigned long bits, __u64 accessed),

kmod/src/server.c

@@ -148,8 +148,6 @@ struct server_info {
 	struct scoutfs_quorum_config qconf;
 	/* a running server maintains a private dirty super */
 	struct scoutfs_super_block dirty_super;
-
-	u64 finalize_sent_seq;
 };
 
 #define DECLARE_SERVER_INFO(sb, name) \
@@ -415,27 +413,6 @@ static void server_hold_commit(struct super_block *sb, struct commit_hold *hold)
 	wait_event(cusers->waitq, hold_commit(sb, server, cusers, hold));
 }
 
-/*
- * Return the higher of the avail or freed used by the active commit
- * since this holder joined the commit.  This is *not* the amount used
- * by the holder, we don't track per-holder alloc use.
- */
-static u32 server_hold_alloc_used_since(struct super_block *sb, struct commit_hold *hold)
-{
-	DECLARE_SERVER_INFO(sb, server);
-	u32 avail_used;
-	u32 freed_used;
-	u32 avail_now;
-	u32 freed_now;
-
-	scoutfs_alloc_meta_remaining(&server->alloc, &avail_now, &freed_now);
-
-	avail_used = hold->avail - avail_now;
-	freed_used = hold->freed - freed_now;
-
-	return max(avail_used, freed_used);
-}
-
 /*
  * This is called while holding the commit and returns once the commit
  * is successfully written.  Many holders can all wait for all holders
@@ -961,24 +938,22 @@ static int find_log_trees_item(struct super_block *sb,
 }
 
 /*
- * Find the log_trees item with the greatest nr for each rid.  Fills the
- * caller's log_trees and sets the key before the returned log_trees for
- * the next iteration.  Returns 0 when done, > 0 for each item, and
- * -errno on fatal errors.
+ * Find the next log_trees item from the key.  Fills the caller's log_trees and sets
+ * the key past the returned log_trees for iteration.  Returns 0 when done, > 0 for each
+ * item, and -errno on fatal errors.
  */
-static int for_each_rid_last_lt(struct super_block *sb, struct scoutfs_btree_root *root,
-				struct scoutfs_key *key, struct scoutfs_log_trees *lt)
+static int for_each_lt(struct super_block *sb, struct scoutfs_btree_root *root,
+		       struct scoutfs_key *key, struct scoutfs_log_trees *lt)
 {
 	SCOUTFS_BTREE_ITEM_REF(iref);
 	int ret;
 
-	ret = scoutfs_btree_prev(sb, root, key, &iref);
+	ret = scoutfs_btree_next(sb, root, key, &iref);
 	if (ret == 0) {
 		if (iref.val_len == sizeof(struct scoutfs_log_trees)) {
 			memcpy(lt, iref.val, iref.val_len);
 			*key = *iref.key;
-			key->sklt_nr = 0;
-			scoutfs_key_dec(key);
+			scoutfs_key_inc(key);
 			ret = 1;
 		} else {
 			ret = -EIO;
@@ -1073,13 +1048,21 @@ static int next_log_merge_item(struct super_block *sb,
  * abandoned log btree finalized.  If it takes too long each client has
  * a change to make forward progress before being asked to commit again.
  *
+ * We're waiting on heavy state that is protected by mutexes and
+ * transaction machinery.  It's tricky to recreate that state for
+ * lightweight condition tests that don't change task state.  Instead of
+ * trying to get that right, particularly as we unwind after success or
+ * after timeouts, waiters use an unsatisfying poll.   Short enough to
+ * not add terrible latency, given how heavy and infrequent this already
+ * is, and long enough to not melt the cpu.  This could be tuned if it
+ * becomes a problem.
+ *
  * This can end up finalizing a new empty log btree if a new mount
  * happens to arrive at just the right time.  That's fine, merging will
  * ignore and tear down the empty input.
  */
-#define FINALIZE_POLL_MIN_DELAY_MS	5U
-#define FINALIZE_POLL_MAX_DELAY_MS	100U
-#define FINALIZE_POLL_DELAY_GROWTH_PCT	150U
+#define FINALIZE_POLL_MS	(11)
+#define FINALIZE_TIMEOUT_MS	(MSEC_PER_SEC / 2)
 static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_log_trees *lt,
 					u64 rid, struct commit_hold *hold)
 {
@@ -1087,10 +1070,8 @@ static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_l
 	struct scoutfs_super_block *super = DIRTY_SUPER_SB(sb);
 	struct scoutfs_log_merge_status stat;
 	struct scoutfs_log_merge_range rng;
-	struct scoutfs_mount_options opts;
 	struct scoutfs_log_trees each_lt;
 	struct scoutfs_log_trees fin;
-	unsigned int delay_ms;
 	unsigned long timeo;
 	bool saw_finalized;
 	bool others_active;
@@ -1098,14 +1079,10 @@ static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_l
 	bool ours_visible;
 	struct scoutfs_key key;
 	char *err_str = NULL;
-	ktime_t start;
 	int ret;
 	int err;
 
-	scoutfs_options_read(sb, &opts);
-	timeo = jiffies + msecs_to_jiffies(opts.log_merge_wait_timeout_ms);
-	delay_ms = FINALIZE_POLL_MIN_DELAY_MS;
-	start = ktime_get_raw();
+	timeo = jiffies + msecs_to_jiffies(FINALIZE_TIMEOUT_MS);
 
 	for (;;) {
 		/* nothing to do if there's already a merge in flight */
@@ -1122,13 +1099,8 @@ static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_l
 		saw_finalized = false;
 		others_active = false;
 		ours_visible = false;
-		scoutfs_key_init_log_trees(&key, U64_MAX, U64_MAX);
-		while ((ret = for_each_rid_last_lt(sb, &super->logs_root, &key, &each_lt)) > 0) {
-
-			trace_scoutfs_server_finalize_items(sb, rid, le64_to_cpu(each_lt.rid),
-							    le64_to_cpu(each_lt.nr),
-							    le64_to_cpu(each_lt.flags),
-							    le64_to_cpu(each_lt.get_trans_seq));
+		scoutfs_key_init_log_trees(&key, 0, 0);
+		while ((ret = for_each_lt(sb, &super->logs_root, &key, &each_lt)) > 0) {
 
 			if ((le64_to_cpu(each_lt.flags) & SCOUTFS_LOG_TREES_FINALIZED))
 				saw_finalized = true;
@@ -1153,10 +1125,6 @@ static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_l
 		finalize_ours = (lt->item_root.height > 2) ||
 				(le32_to_cpu(lt->meta_avail.flags) & SCOUTFS_ALLOC_FLAG_LOW);
 
-		trace_scoutfs_server_finalize_decision(sb, rid, saw_finalized, others_active,
-						       ours_visible, finalize_ours, delay_ms,
-						       server->finalize_sent_seq);
-
 		/* done if we're not finalizing and there's no finalized */
 		if (!finalize_ours && !saw_finalized) {
 			ret = 0;
@@ -1164,13 +1132,12 @@ static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_l
 		}
 
 		/* send sync requests soon to give time to commit */
-		scoutfs_key_init_log_trees(&key, U64_MAX, U64_MAX);
+		scoutfs_key_init_log_trees(&key, 0, 0);
 		while (others_active &&
-		       (ret = for_each_rid_last_lt(sb, &super->logs_root, &key, &each_lt)) > 0) {
+		       (ret = for_each_lt(sb, &super->logs_root, &key, &each_lt)) > 0) {
 
 			if ((le64_to_cpu(each_lt.flags) & SCOUTFS_LOG_TREES_FINALIZED) ||
-			    (le64_to_cpu(each_lt.rid) == rid) ||
-			    (le64_to_cpu(each_lt.get_trans_seq) <= server->finalize_sent_seq))
+			    (le64_to_cpu(each_lt.rid) == rid))
 				continue;
 
 			ret = scoutfs_net_submit_request_node(sb, server->conn,
@@ -1190,8 +1157,6 @@ static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_l
 			break;
 		}
 
-		server->finalize_sent_seq = scoutfs_server_seq(sb);
-
 		/* Finalize ours if it's visible to others */
 		if (ours_visible) {
 			fin = *lt;
@@ -1229,16 +1194,13 @@ static int finalize_and_start_log_merge(struct super_block *sb, struct scoutfs_l
 			if (ret < 0)
 				err_str = "applying commit before waiting for finalized";
 
-			msleep(delay_ms);
-			delay_ms = min(delay_ms * FINALIZE_POLL_DELAY_GROWTH_PCT / 100,
-				       FINALIZE_POLL_MAX_DELAY_MS);
+			msleep(FINALIZE_POLL_MS);
 
 			server_hold_commit(sb, hold);
 			mutex_lock(&server->logs_mutex);
 
 			/* done if we timed out */
-			if (time_after(jiffies, timeo)) {
-				scoutfs_inc_counter(sb, log_merge_wait_timeout);
+			if (1 || time_after(jiffies, timeo)) {
 				ret = 0;
 				break;
 			}
@@ -1821,29 +1783,43 @@ out:
  * Give the caller the last seq before outstanding client commits.  All
  * seqs up to and including this are stable, new client transactions can
  * only have greater seqs.
- *
- * For each rid, only its greatest log trees nr can be an open commit.
- * We look at the last log_trees item for each client rid and record its
- * trans seq if it hasn't been committed.
  */
 static int get_stable_trans_seq(struct super_block *sb, u64 *last_seq_ret)
 {
 	struct scoutfs_super_block *super = DIRTY_SUPER_SB(sb);
 	DECLARE_SERVER_INFO(sb, server);
-	struct scoutfs_log_trees lt;
+	SCOUTFS_BTREE_ITEM_REF(iref);
+	struct scoutfs_log_trees *lt;
 	struct scoutfs_key key;
 	u64 last_seq = 0;
 	int ret;
 
 	last_seq = scoutfs_server_seq(sb) - 1;
+	scoutfs_key_init_log_trees(&key, 0, 0);
 
 	mutex_lock(&server->logs_mutex);
 
-	scoutfs_key_init_log_trees(&key, U64_MAX, U64_MAX);
-	while ((ret = for_each_rid_last_lt(sb, &super->logs_root, &key, &lt)) > 0) {
-		if ((le64_to_cpu(lt.get_trans_seq) > le64_to_cpu(lt.commit_trans_seq)) &&
-		     le64_to_cpu(lt.get_trans_seq) <= last_seq) {
-			last_seq = le64_to_cpu(lt.get_trans_seq) - 1;
+	for (;; scoutfs_key_inc(&key)) {
+		ret = scoutfs_btree_next(sb, &super->logs_root, &key, &iref);
+		if (ret == 0) {
+			if (iref.val_len == sizeof(*lt)) {
+				lt = iref.val;
+				if ((le64_to_cpu(lt->get_trans_seq) >
+				     le64_to_cpu(lt->commit_trans_seq)) &&
+				     le64_to_cpu(lt->get_trans_seq) <= last_seq) {
+					last_seq = le64_to_cpu(lt->get_trans_seq) - 1;
+				}
+				key = *iref.key;
+			} else {
+				ret = -EIO;
+			}
+			scoutfs_btree_put_iref(&iref);
+		}
+		if (ret < 0) {
+			if (ret == -ENOENT) {
+				ret = 0;
+				break;
+			}
 		}
 	}
 
@@ -2495,11 +2471,9 @@ static void server_log_merge_free_work(struct work_struct *work)
 
 	while (!server_is_stopping(server)) {
 
-		if (!commit) {
-			server_hold_commit(sb, &hold);
-			mutex_lock(&server->logs_mutex);
-			commit = true;
-		}
+		server_hold_commit(sb, &hold);
+		mutex_lock(&server->logs_mutex);
+		commit = true;
 
 		ret = next_log_merge_item(sb, &super->log_merge,
 					  SCOUTFS_LOG_MERGE_FREEING_ZONE,
@@ -2546,14 +2520,12 @@ static void server_log_merge_free_work(struct work_struct *work)
 		/* freed blocks are in allocator, we *have* to update fr */
 		BUG_ON(ret < 0);
 
-		if (server_hold_alloc_used_since(sb, &hold) >= COMMIT_HOLD_ALLOC_BUDGET / 2) {
-			mutex_unlock(&server->logs_mutex);
-			ret = server_apply_commit(sb, &hold, ret);
-			commit = false;
-			if (ret < 0) {
-				err_str = "looping commit del/upd freeing item";
-				break;
-			}
+		mutex_unlock(&server->logs_mutex);
+		ret = server_apply_commit(sb, &hold, ret);
+		commit = false;
+		if (ret < 0) {
+			err_str = "looping commit del/upd freeing item";
+			break;
 		}
 	}
 
@@ -4326,7 +4298,6 @@ static void scoutfs_server_worker(struct work_struct *work)
 	scoutfs_info(sb, "server starting at "SIN_FMT, SIN_ARG(&sin));
 
 	scoutfs_block_writer_init(sb, &server->wri);
-	server->finalize_sent_seq = 0;
 
 	/* first make sure no other servers are still running */
 	ret = scoutfs_quorum_fence_leaders(sb, &server->qconf, server->term);

kmod/src/super.c

@@ -49,8 +49,6 @@
 #include "volopt.h"
 #include "fence.h"
 #include "xattr.h"
-#include "wkic.h"
-#include "quota.h"
 #include "scoutfs_trace.h"
 
 static struct dentry *scoutfs_debugfs_root;
@@ -196,9 +194,7 @@ static void scoutfs_put_super(struct super_block *sb)
 	scoutfs_shutdown_trans(sb);
 	scoutfs_volopt_destroy(sb);
 	scoutfs_client_destroy(sb);
-	scoutfs_quota_destroy(sb);
 	scoutfs_inode_destroy(sb);
-	scoutfs_wkic_destroy(sb);
 	scoutfs_item_destroy(sb);
 	scoutfs_forest_destroy(sb);
 	scoutfs_data_destroy(sb);
@@ -548,9 +544,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	      scoutfs_block_setup(sb) ?:
 	      scoutfs_forest_setup(sb) ?:
 	      scoutfs_item_setup(sb) ?:
-	      scoutfs_wkic_setup(sb) ?:
 	      scoutfs_inode_setup(sb) ?:
-	      scoutfs_quota_setup(sb) ?:
 	      scoutfs_data_setup(sb) ?:
 	      scoutfs_setup_trans(sb) ?:
 	      scoutfs_omap_setup(sb) ?:

kmod/src/super.h

@@ -30,8 +30,6 @@ struct recov_info;
 struct omap_info;
 struct volopt_info;
 struct fence_info;
-struct wkic_info;
-struct squota_info;
 
 struct scoutfs_sb_info {
 	struct super_block *sb;
@@ -57,8 +55,6 @@ struct scoutfs_sb_info {
 	struct omap_info *omap_info;
 	struct volopt_info *volopt_info;
 	struct item_cache_info *item_cache_info;
-	struct wkic_info *wkic_info;
-	struct squota_info *squota_info;
 	struct fence_info *fence_info;
 
 	/* tracks tasks waiting for data extents */
@@ -160,17 +156,4 @@ int scoutfs_write_super(struct super_block *sb,
 /* to keep this out of the ioctl.h public interface definition */
 long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 
-/*
- * Returns 0 when supported, non-zero -errno when unsupported.
- */
-static inline int scoutfs_fmt_vers_unsupported(struct super_block *sb, u64 vers)
-{
-	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
-
-	if (sbi && (sbi->fmt_vers < vers))
-		return -EOPNOTSUPP;
-	else
-		return 0;
-}
-
 #endif

kmod/src/totl.c

@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2023 Versity Software, Inc.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-#include <linux/kernel.h>
-#include <linux/string.h>
-
-#include "format.h"
-#include "forest.h"
-#include "totl.h"
-
-void scoutfs_totl_set_range(struct scoutfs_key *start, struct scoutfs_key *end)
-{
-	scoutfs_key_set_zeros(start);
-	start->sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
-	scoutfs_key_set_ones(end);
-	end->sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
-}
-
-void scoutfs_totl_merge_init(struct scoutfs_totl_merging *merg)
-{
-	memset(merg, 0, sizeof(struct scoutfs_totl_merging));
-}
-
-void scoutfs_totl_merge_contribute(struct scoutfs_totl_merging *merg,
-				   u64 seq, u8 flags, void *val, int val_len, int fic)
-{
-	struct scoutfs_xattr_totl_val *tval = val;
-
-	if (fic & FIC_FS_ROOT) {
-		merg->fs_seq = seq;
-		merg->fs_total = le64_to_cpu(tval->total);
-		merg->fs_count = le64_to_cpu(tval->count);
-	} else if (fic & FIC_FINALIZED) {
-		merg->fin_seq = seq;
-		merg->fin_total += le64_to_cpu(tval->total);
-		merg->fin_count += le64_to_cpu(tval->count);
-	} else {
-		merg->log_seq = seq;
-		merg->log_total += le64_to_cpu(tval->total);
-		merg->log_count += le64_to_cpu(tval->count);
-	}
-}
-
-/*
- * .totl. item merging has to be careful because the log btree merging
- * code can write partial results to the fs_root.  This means that a
- * reader can see both cases where new finalized logs should be applied
- * to the old fs items and where old finalized logs have already been
- * applied to the partially merged fs items.  Currently active logged
- * items are always applied on top of all cases.
- *
- * These cases are differentiated with a combination of sequence numbers
- * in items, the count of contributing xattrs, and a flag
- * differentiating finalized and active logged items.  This lets us
- * recognize all cases, including when finalized logs were merged and
- * deleted the fs item.
- */
-void scoutfs_totl_merge_resolve(struct scoutfs_totl_merging *merg, __u64 *total, __u64 *count)
-{
-	*total = 0;
-	*count = 0;
-
-	/* start with the fs item if we have it */
-	if (merg->fs_seq != 0) {
-		*total = merg->fs_total;
-		*count = merg->fs_count;
-	}
-
-	/* apply finalized logs if they're newer or creating */
-	if (((merg->fs_seq != 0) && (merg->fin_seq > merg->fs_seq)) ||
-	    ((merg->fs_seq == 0) && (merg->fin_count > 0))) {
-		*total += merg->fin_total;
-		*count += merg->fin_count;
-	}
-
-	/* always apply active logs which must be newer than fs and finalized */
-	if (merg->log_seq > 0) {
-		*total += merg->log_total;
-		*count += merg->log_count;
-	}
-}

kmod/src/totl.h

@@ -1,24 +0,0 @@
-#ifndef _SCOUTFS_TOTL_H_
-#define _SCOUTFS_TOTL_H_
-
-#include "key.h"
-
-struct scoutfs_totl_merging {
-	u64 fs_seq;
-	u64 fs_total;
-	u64 fs_count;
-	u64 fin_seq;
-	u64 fin_total;
-	s64 fin_count;
-	u64 log_seq;
-	u64 log_total;
-	s64 log_count;
-};
-
-void scoutfs_totl_set_range(struct scoutfs_key *start, struct scoutfs_key *end);
-void scoutfs_totl_merge_init(struct scoutfs_totl_merging *merg);
-void scoutfs_totl_merge_contribute(struct scoutfs_totl_merging *merg,
-				   u64 seq, u8 flags, void *val, int val_len, int fic);
-void scoutfs_totl_merge_resolve(struct scoutfs_totl_merging *merg, __u64 *total, __u64 *count);
-
-#endif

kmod/src/trace/quota.h

@@ -1,143 +0,0 @@
-
-/*
- * Tracing squota_input
- */
-#define SQI_FMT "[%u %llu %llu %llu]"
-
-#define SQI_ARGS(i)						\
-	(i)->op, (i)->attrs[0], (i)->attrs[1], (i)->attrs[2]
-
-#define SQI_FIELDS(pref)					\
-	__array(__u64, pref##_attrs, SQ_NS__NR_SELECT)		\
-	__field(__u8, pref##_op)
-
-#define SQI_ASSIGN(pref, i)					\
-	__entry->pref##_attrs[0] = (i)->attrs[0];		\
-	__entry->pref##_attrs[1] = (i)->attrs[1];		\
-	__entry->pref##_attrs[2] = (i)->attrs[2];		\
-	__entry->pref##_op = (i)->op;
-
-#define SQI_ENTRY_ARGS(pref)					\
-	__entry->pref##_op, __entry->pref##_attrs[0],		\
-	__entry->pref##_attrs[1], __entry->pref##_attrs[2]
-
-/*
- * Tracing squota_rule
- */
-#define SQR_FMT "[%u %llu,%u,%x %llu,%u,%x %llu,%u,%x %u %llu]"
-
-#define SQR_ARGS(r)							\
-	(r)->prio,							\
-	(r)->name_val[0], (r)->name_source[0], (r)->name_flags[0],	\
-	(r)->name_val[1], (r)->name_source[1], (r)->name_flags[1],	\
-	(r)->name_val[2], (r)->name_source[2], (r)->name_flags[2],	\
-	(r)->op, (r)->limit						\
-
-#define SQR_FIELDS(pref)			\
-	__array(__u64, pref##_name_val, 3)	\
-	__field(__u64, pref##_limit)		\
-	__array(__u8, pref##_name_source, 3)	\
-	__array(__u8, pref##_name_flags, 3)	\
-	__field(__u8, pref##_prio)		\
-	__field(__u8, pref##_op)
-
-#define SQR_ASSIGN(pref, r)					\
-	__entry->pref##_name_val[0] = (r)->names[0].val;	\
-	__entry->pref##_name_val[1] = (r)->names[1].val;	\
-	__entry->pref##_name_val[2] = (r)->names[2].val;	\
-	__entry->pref##_limit = (r)->limit;			\
-	__entry->pref##_name_source[0] = (r)->names[0].source;	\
-	__entry->pref##_name_source[1] = (r)->names[1].source;	\
-	__entry->pref##_name_source[2] = (r)->names[2].source;	\
-	__entry->pref##_name_flags[0] = (r)->names[0].flags;	\
-	__entry->pref##_name_flags[1] = (r)->names[1].flags;	\
-	__entry->pref##_name_flags[2] = (r)->names[2].flags;	\
-	__entry->pref##_prio = (r)->prio;			\
-	__entry->pref##_op = (r)->op;
-
-#define SQR_ENTRY_ARGS(pref)						\
-	__entry->pref##_prio, __entry->pref##_name_val[0],		\
-	__entry->pref##_name_source[0], __entry->pref##_name_flags[0],	\
-	__entry->pref##_name_val[1], __entry->pref##_name_source[1],	\
-	__entry->pref##_name_flags[1], __entry->pref##_name_val[2],	\
-	__entry->pref##_name_source[2], __entry->pref##_name_flags[2],	\
-	__entry->pref##_op, __entry->pref##_limit
-
-TRACE_EVENT(scoutfs_quota_check,
-	TP_PROTO(struct super_block *sb, long rs_ptr, struct squota_input *inp, int ret),
-
-	TP_ARGS(sb, rs_ptr, inp, ret),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(long, rs_ptr)
-		SQI_FIELDS(i)
-		__field(int, ret)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->rs_ptr = rs_ptr;
-		SQI_ASSIGN(i, inp);
-		__entry->ret = ret;
-	),
-
-	TP_printk(SCSBF" rs_ptr %ld ret %d inp "SQI_FMT,
-		  SCSB_TRACE_ARGS, __entry->rs_ptr, __entry->ret, SQI_ENTRY_ARGS(i))
-);
-
-DECLARE_EVENT_CLASS(scoutfs_quota_rule_op_class,
-	TP_PROTO(struct super_block *sb, struct squota_rule *rule, int ret),
-
-	TP_ARGS(sb, rule, ret),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		SQR_FIELDS(r)
-		__field(int, ret)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		SQR_ASSIGN(r, rule);
-		__entry->ret = ret;
-	),
-
-	TP_printk(SCSBF" "SQR_FMT" ret %d",
-		  SCSB_TRACE_ARGS, SQR_ENTRY_ARGS(r), __entry->ret)
-);
-DEFINE_EVENT(scoutfs_quota_rule_op_class, scoutfs_quota_add_rule,
-	TP_PROTO(struct super_block *sb, struct squota_rule *rule, int ret),
-	TP_ARGS(sb, rule, ret)
-);
-DEFINE_EVENT(scoutfs_quota_rule_op_class, scoutfs_quota_del_rule,
-	TP_PROTO(struct super_block *sb, struct squota_rule *rule, int ret),
-	TP_ARGS(sb, rule, ret)
-);
-
-TRACE_EVENT(scoutfs_quota_totl_check,
-	TP_PROTO(struct super_block *sb, struct squota_input *inp, struct scoutfs_key *key,
-		 u64 limit, int ret),
-
-	TP_ARGS(sb, inp, key, limit, ret),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		SQI_FIELDS(i)
-		sk_trace_define(k)
-		__field(__u64, limit)
-		__field(int, ret)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		SQI_ASSIGN(i, inp);
-		sk_trace_assign(k, key);
-		__entry->limit = limit;
-		__entry->ret = ret;
-	),
-
-	TP_printk(SCSBF" inp "SQI_FMT" key "SK_FMT" limit %llu ret %d",
-		  SCSB_TRACE_ARGS, SQI_ENTRY_ARGS(i), sk_trace_args(k), __entry->limit,
-		  __entry->ret)
-);

kmod/src/trace/wkic.h

@@ -1,112 +0,0 @@
-
-DECLARE_EVENT_CLASS(scoutfs_wkic_wpage_class,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		__field(void *, ptr)
-		__field(int, which)
-		__field(bool, n0l)
-		__field(bool, n1l)
-		sk_trace_define(start)
-		sk_trace_define(end)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		__entry->ptr = ptr;
-		__entry->which = which;
-		__entry->n0l = n0l;
-		__entry->n1l = n1l;
-		sk_trace_assign(start, start);
-		sk_trace_assign(end, end);
-		__entry->which = which;
-	),
-
-	TP_printk(SCSBF" ptr %p wh %d nl %u,%u start "SK_FMT " end "SK_FMT, SCSB_TRACE_ARGS,
-			__entry->ptr, __entry->which, __entry->n0l, __entry->n1l,
-			sk_trace_args(start), sk_trace_args(end))
-);
-
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_alloced,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_freeing,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_found,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_trimmed,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_erased,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_inserting,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_inserted,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_shrinking,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_dropping,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_replaying,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-DEFINE_EVENT(scoutfs_wkic_wpage_class, scoutfs_wkic_wpage_filled,
-	TP_PROTO(struct super_block *sb, void *ptr, int which, bool n0l, bool n1l,
-		 struct scoutfs_key *start, struct scoutfs_key *end),
-	TP_ARGS(sb, ptr, which, n0l, n1l, start, end)
-);
-
-TRACE_EVENT(scoutfs_wkic_read_items,
-	TP_PROTO(struct super_block *sb, struct scoutfs_key *key, struct scoutfs_key *start,
-		 struct scoutfs_key *end),
-
-	TP_ARGS(sb, key, start, end),
-
-	TP_STRUCT__entry(
-		SCSB_TRACE_FIELDS
-		sk_trace_define(key)
-		sk_trace_define(start)
-		sk_trace_define(end)
-	),
-
-	TP_fast_assign(
-		SCSB_TRACE_ASSIGN(sb);
-		sk_trace_assign(key, start);
-		sk_trace_assign(start, start);
-		sk_trace_assign(end, end);
-	),
-
-	TP_printk(SCSBF" key "SK_FMT" start "SK_FMT " end "SK_FMT, SCSB_TRACE_ARGS,
-			sk_trace_args(key), sk_trace_args(start), sk_trace_args(end))
-);

kmod/src/wkic.h

@@ -1,19 +0,0 @@
-#ifndef _SCOUTFS_WKIC_H_
-#define _SCOUTFS_WKIC_H_
-
-#include "format.h"
-
-typedef int (*wkic_iter_cb_t)(struct scoutfs_key *key, void *val, unsigned int val_len,
-			      void *cb_arg);
-
-int scoutfs_wkic_iterate(struct super_block *sb, struct scoutfs_key *key, struct scoutfs_key *last,
-			 struct scoutfs_key *range_start, struct scoutfs_key *range_end,
-			 wkic_iter_cb_t cb, void *cb_arg);
-int scoutfs_wkic_iterate_stable(struct super_block *sb, struct scoutfs_key *key,
-				struct scoutfs_key *last, struct scoutfs_key *range_start,
-				struct scoutfs_key *range_end, wkic_iter_cb_t cb, void *cb_arg);
-
-int scoutfs_wkic_setup(struct super_block *sb);
-void scoutfs_wkic_destroy(struct super_block *sb);
-
-#endif

kmod/src/xattr.c

@@ -81,20 +81,7 @@ static void init_xattr_key(struct scoutfs_key *key, u64 ino, u32 name_hash,
 #define SCOUTFS_XATTR_PREFIX		"scoutfs."
 #define SCOUTFS_XATTR_PREFIX_LEN	(sizeof(SCOUTFS_XATTR_PREFIX) - 1)
 
-/*
- * We could have hidden the logic that needs this in a user-prefix
- * specific .set handler, but I wanted to make sure that we always
- * applied that logic from any call chains to _xattr_set.  The
- * additional strcmp isn't so expensive given all the rest of the work
- * we're doing in here.
- */
-static inline bool is_user(const char *name)
-{
-	return !strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
-}
-
 #define HIDE_TAG	"hide."
-#define INDX_TAG	"indx."
 #define SRCH_TAG	"srch."
 #define TOTL_TAG	"totl."
 #define TAG_LEN		(sizeof(HIDE_TAG) - 1)
@@ -116,9 +103,6 @@ int scoutfs_xattr_parse_tags(const char *name, unsigned int name_len,
 		if (!strncmp(name, HIDE_TAG, TAG_LEN)) {
 			if (++tgs->hide == 0)
 				return -EINVAL;
-		} else if (!strncmp(name, INDX_TAG, TAG_LEN)) {
-			if (++tgs->indx == 0)
-				return -EINVAL;
 		} else if (!strncmp(name, SRCH_TAG, TAG_LEN)) {
 			if (++tgs->srch == 0)
 				return -EINVAL;
@@ -556,57 +540,47 @@ static int parse_totl_u64(const char *s, int len, u64 *res)
 }
 
 /*
- * non-destructive relatively quick parse of final dotted u64s in an
- * xattr name.  If the required number of values are found then we
- * return the number of bytes in the name that are not the final dotted
- * u64s with their dots.  -EINVAL is returned if we didn't find the
- * required number of values.
+ * non-destructive relatively quick parse of the last 3 dotted u64s that
+ * make up the name of the xattr total.  -EINVAL is returned if there
+ * are anything but 3 valid u64 encodings between single dots at the end
+ * of the name.
  */
-static int parse_dotted_u64s(u64 *u64s, int nr, const char *name, int name_len)
+static int parse_totl_key(struct scoutfs_key *key, const char *name, int name_len)
 {
+	u64 tot_name[3];
 	int end = name_len;
+	int nr = 0;
 	int len;
 	int ret;
 	int i;
-	int u;
 
 	/* parse name elements in reserve order from end of xattr name string */
-	for (u = nr - 1, i = name_len - 1; u >= 0 && i >= 0; i--) {
+	for (i = name_len - 1; i >= 0 && nr < ARRAY_SIZE(tot_name); i--) {
 		if (name[i] != '.')
 			continue;
 
 		len = end - (i + 1);
-		ret = parse_totl_u64(&name[i + 1], len, &u64s[u]);
+		ret = parse_totl_u64(&name[i + 1], len, &tot_name[nr]);
 		if (ret < 0)
 			goto out;
 
 		end = i;
-		u--;
+		nr++;
 	}
 
-	if (u == -1)
-		ret = end;
-	else
+	if (nr == ARRAY_SIZE(tot_name)) {
+		/* swap to account for parsing in reverse */
+		swap(tot_name[0], tot_name[2]);
+		scoutfs_xattr_init_totl_key(key, tot_name);
+		ret = 0;
+	} else {
 		ret = -EINVAL;
+	}
 
 out:
 	return ret;
 }
 
-static int parse_totl_key(struct scoutfs_key *key, const char *name, int name_len)
-{
-	u64 u64s[3];
-	int ret;
-
-	ret = parse_dotted_u64s(u64s, ARRAY_SIZE(u64s), name, name_len);
-	if (ret >= 0) {
-		scoutfs_xattr_init_totl_key(key, u64s);
-		ret = 0;
-	}
-
-	return ret;
-}
-
 static int apply_totl_delta(struct super_block *sb, struct scoutfs_key *key,
 			    struct scoutfs_xattr_totl_val *tval, struct scoutfs_lock *lock)
 {
@@ -633,72 +607,6 @@ int scoutfs_xattr_combine_totl(void *dst, int dst_len, void *src, int src_len)
 	return SCOUTFS_DELTA_COMBINED;
 }
 
-void scoutfs_xattr_indx_get_range(struct scoutfs_key *start, struct scoutfs_key *end)
-{
-	scoutfs_key_set_zeros(start);
-	start->sk_zone = SCOUTFS_XATTR_INDX_ZONE;
-	scoutfs_key_set_ones(end);
-	end->sk_zone = SCOUTFS_XATTR_INDX_ZONE;
-}
-
-/*
- * .indx. keys are a bit funny because we're iterating over index keys
- * by major:minor:inode:xattr_id.  That doesn't map nicely to the
- * comparison precedence of the key fields.  We have to mess around a
- * little bit to get the major into the most significant key bits and
- * the low bits of xattr id into the least significant key bits.
- */
-void scoutfs_xattr_init_indx_key(struct scoutfs_key *key, u8 major, u64 minor, u64 ino, u64 xid)
-{
-	scoutfs_key_set_zeros(key);
-	key->sk_zone = SCOUTFS_XATTR_INDX_ZONE;
-
-	key->_sk_first = cpu_to_le64(((u64)major << 56) | (minor >> 8));
-	key->_sk_second = cpu_to_le64((minor << 56) | (ino >> 8));
-	key->_sk_third = cpu_to_le64((ino << 56) | (xid >> 8));
-	key->_sk_fourth = xid & 0xff;
-}
-
-void scoutfs_xattr_get_indx_key(struct scoutfs_key *key, u8 *major, u64 *minor, u64 *ino, u64 *xid)
-{
-	*major = le64_to_cpu(key->_sk_first) >> 56;
-	*minor = (le64_to_cpu(key->_sk_first) << 8) | (le64_to_cpu(key->_sk_second) >> 56);
-	*ino = (le64_to_cpu(key->_sk_second) << 8) | (le64_to_cpu(key->_sk_third) >> 56);
-	*xid = (le64_to_cpu(key->_sk_third) << 8) | key->_sk_fourth;
-}
-
-void scoutfs_xattr_set_indx_key_xid(struct scoutfs_key *key, u64 xid)
-{
-	u8 major;
-	u64 minor;
-	u64 ino;
-	u64 dummy;
-
-	scoutfs_xattr_get_indx_key(key, &major, &minor, &ino, &dummy);
-	scoutfs_xattr_init_indx_key(key, major, minor, ino, xid);
-}
-
-/*
- * This initial parsing of the name doesn't yet have access to an xattr
- * id to put in the key.  That's added later as the existing xattr is
- * found or a new xattr's id is allocated.
- */
-static int parse_indx_key(struct scoutfs_key *key, const char *name, int name_len, u64 ino)
-{
-	u64 u64s[2];
-	int ret;
-
-	ret = parse_dotted_u64s(u64s, ARRAY_SIZE(u64s), name, name_len);
-	if (ret < 0)
-		return ret;
-
-	if (u64s[0] > U8_MAX)
-		return -EINVAL;
-
-	scoutfs_xattr_init_indx_key(key, u64s[0], u64s[1], ino, 0);
-	return 0;
-}
-
 /*
  * The confusing swiss army knife of creating, modifying, and deleting
  * xattrs.
@@ -719,7 +627,7 @@ static int parse_indx_key(struct scoutfs_key *key, const char *name, int name_le
 int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_len,
 			     const void *value, size_t size, int flags,
 			     const struct scoutfs_xattr_prefix_tags *tgs,
-			     struct scoutfs_lock *lck, struct scoutfs_lock *tag_lock,
+			     struct scoutfs_lock *lck, struct scoutfs_lock *totl_lock,
 			     struct list_head *ind_locks)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
@@ -727,11 +635,10 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	const u64 ino = scoutfs_ino(inode);
 	struct scoutfs_xattr_totl_val tval = {0,};
 	struct scoutfs_xattr *xat = NULL;
-	struct scoutfs_key tag_key;
+	struct scoutfs_key totl_key;
 	struct scoutfs_key key;
 	bool undo_srch = false;
 	bool undo_totl = false;
-	bool undo_indx = false;
 	u8 found_parts;
 	unsigned int xat_bytes_totl;
 	unsigned int xat_bytes;
@@ -744,8 +651,7 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 
 	trace_scoutfs_xattr_set(sb, name_len, value, size, flags);
 
-	if (WARN_ON_ONCE(tgs->totl && tgs->indx) ||
-	    WARN_ON_ONCE((tgs->totl | tgs->indx) && !tag_lock))
+	if (WARN_ON_ONCE(tgs->totl && !totl_lock))
 		return -EINVAL;
 
 	/* mirror the syscall's errors for large names and values */
@@ -758,22 +664,10 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	    (flags & ~(XATTR_CREATE | XATTR_REPLACE)))
 		return -EINVAL;
 
-	if ((tgs->hide | tgs->indx | tgs->srch | tgs->totl) && !capable(CAP_SYS_ADMIN))
+	if ((tgs->hide | tgs->srch | tgs->totl) && !capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
-	if (tgs->totl && ((ret = parse_totl_key(&tag_key, name, name_len)) != 0))
-		return ret;
-
-	if (tgs->indx &&
-	    (ret = scoutfs_fmt_vers_unsupported(sb, SCOUTFS_FORMAT_VERSION_FEAT_INDX_TAG)))
-		return ret;
-
-	if (tgs->indx && ((ret = parse_indx_key(&tag_key, name, name_len, ino)) != 0))
-		return ret;
-
-	/* retention blocks user. xattr modification, all else allowed */
-	ret = scoutfs_inode_check_retention(inode);
-	if (ret < 0 && is_user(name))
+	if (tgs->totl && ((ret = parse_totl_key(&totl_key, name, name_len)) != 0))
 		return ret;
 
 	/* allocate enough to always read an existing xattr's totl */
@@ -814,12 +708,6 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	/* found fields in key will also be used */
 	found_parts = ret >= 0 ? xattr_nr_parts(xat) : 0;
 
-	/* use existing xattr's id or allocate new when creating */
-	if (found_parts)
-		id = le64_to_cpu(key.skx_id);
-	else if (value)
-		id = si->next_xattr_id++;
-
 	if (found_parts && tgs->totl) {
 		/* parse old totl value before we clobber xat buf */
 		val_len = ret - offsetof(struct scoutfs_xattr, name[xat->name_len]);
@@ -830,25 +718,12 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 		le64_add_cpu(&tval.total, -total);
 	}
 
-	/*
-	 * indx xattrs don't have a value.  After returning an error for
-	 * non-zero val length or short circuiting modifying with the
-	 * same 0 length, all we're left with is creating or deleting
-	 * the xattr.
-	 */
-	if (tgs->indx) {
-		if (size != 0) {
-			ret = -EINVAL;
-			goto out;
-		}
-		if (found_parts && value) {
-			ret = 0;
-			goto out;
-		}
-	}
-
 	/* prepare the xattr header, name, and start of value in first item */
 	if (value) {
+		if (found_parts)
+			id = le64_to_cpu(key.skx_id);
+		else
+			id = si->next_xattr_id++;
 		xat->name_len = name_len;
 		xat->val_len = cpu_to_le16(size);
 		memset(xat->__pad, 0, sizeof(xat->__pad));
@@ -866,18 +741,9 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 		le64_add_cpu(&tval.total, total);
 	}
 
-	if (tgs->indx) {
-		scoutfs_xattr_set_indx_key_xid(&tag_key, id);
-		if (value)
-			ret = scoutfs_item_create_force(sb, &tag_key, NULL, 0, tag_lock, NULL);
-		else
-			ret = scoutfs_item_delete_force(sb, &tag_key, tag_lock, NULL);
-		if (ret < 0)
-			goto out;
-		undo_indx = true;
-	}
-
 	if (tgs->srch && !(found_parts && value)) {
+		if (found_parts)
+			id = le64_to_cpu(key.skx_id);
 		hash = scoutfs_hash64(name, name_len);
 		ret = scoutfs_forest_srch_add(sb, hash, ino, id);
 		if (ret < 0)
@@ -886,7 +752,7 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	}
 
 	if (tgs->totl) {
-		ret = apply_totl_delta(sb, &tag_key, &tval, tag_lock);
+		ret = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
 		if (ret < 0)
 			goto out;
 		undo_totl = true;
@@ -911,13 +777,6 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	ret = 0;
 
 out:
-	if (ret < 0 && undo_indx) {
-		if (value)
-			err = scoutfs_item_delete_force(sb, &tag_key, tag_lock, NULL);
-		else
-			err = scoutfs_item_create_force(sb, &tag_key, NULL, 0, tag_lock, NULL);
-		BUG_ON(err); /* inconsistent */
-	}
 	if (ret < 0 && undo_srch) {
 		err = scoutfs_forest_srch_add(sb, hash, ino, id);
 		BUG_ON(err);
@@ -926,7 +785,7 @@ out:
 		/* _delta() on dirty items shouldn't fail */
 		tval.total = cpu_to_le64(-le64_to_cpu(tval.total));
 		tval.count = cpu_to_le64(-le64_to_cpu(tval.count));
-		err = apply_totl_delta(sb, &tag_key, &tval, tag_lock);
+		err = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
 		BUG_ON(err);
 	}
 
@@ -942,7 +801,7 @@ static int scoutfs_xattr_set(struct dentry *dentry, const char *name, const void
 	struct inode *inode = dentry->d_inode;
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_xattr_prefix_tags tgs;
-	struct scoutfs_lock *tag_lock = NULL;
+	struct scoutfs_lock *totl_lock = NULL;
 	struct scoutfs_lock *lck = NULL;
 	size_t name_len = strlen(name);
 	LIST_HEAD(ind_locks);
@@ -957,11 +816,8 @@ static int scoutfs_xattr_set(struct dentry *dentry, const char *name, const void
 	if (ret)
 		goto unlock;
 
-	if (tgs.totl || tgs.indx) {
-		if (tgs.totl)
-			ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &tag_lock);
-		else
-			ret = scoutfs_lock_xattr_indx(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &tag_lock);
+	if (tgs.totl) {
+		ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &totl_lock);
 		if (ret)
 			goto unlock;
 	}
@@ -980,7 +836,7 @@ retry:
 		goto release;
 
 	ret = scoutfs_xattr_set_locked(dentry->d_inode, name, name_len, value, size, flags, &tgs,
-				       lck, tag_lock, &ind_locks);
+				       lck, totl_lock, &ind_locks);
 	if (ret == 0)
 		scoutfs_update_inode_item(inode, lck, &ind_locks);
 
@@ -989,7 +845,7 @@ release:
 	scoutfs_inode_index_unlock(sb, &ind_locks);
 unlock:
 	scoutfs_unlock(sb, lck, SCOUTFS_LOCK_WRITE);
-	scoutfs_unlock(sb, tag_lock, SCOUTFS_LOCK_WRITE_ONLY);
+	scoutfs_unlock(sb, totl_lock, SCOUTFS_LOCK_WRITE_ONLY);
 
 	return ret;
 }
@@ -1199,15 +1055,14 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 {
 	struct scoutfs_xattr_prefix_tags tgs;
 	struct scoutfs_xattr *xat = NULL;
-	struct scoutfs_lock *tag_lock = NULL;
+	struct scoutfs_lock *totl_lock = NULL;
 	struct scoutfs_xattr_totl_val tval;
-	struct scoutfs_key tag_key;
+	struct scoutfs_key totl_key;
 	struct scoutfs_key last;
 	struct scoutfs_key key;
 	bool release = false;
 	unsigned int bytes;
 	unsigned int val_len;
-	u8 locked_zone = 0;
 	void *value;
 	u64 total;
 	u64 hash;
@@ -1253,32 +1108,16 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 				goto out;
 			}
 
-			ret = parse_totl_key(&tag_key, xat->name, xat->name_len) ?:
+			ret = parse_totl_key(&totl_key, xat->name, xat->name_len) ?:
 			      parse_totl_u64(value, val_len, &total);
 			if (ret < 0)
 				break;
 		}
 
-		if (tgs.indx) {
-			ret = parse_indx_key(&tag_key, xat->name, xat->name_len, ino);
-			if (ret < 0)
-				goto out;
-		}
-
-		if ((tgs.totl || tgs.indx) && locked_zone != tag_key.sk_zone) {
-			if (tag_lock) {
-				scoutfs_unlock(sb, tag_lock, SCOUTFS_LOCK_WRITE_ONLY);
-				tag_lock = NULL;
-			}
-			if (tgs.totl)
-				ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0,
-							      &tag_lock);
-			else
-				ret = scoutfs_lock_xattr_indx(sb, SCOUTFS_LOCK_WRITE_ONLY, 0,
-							      &tag_lock);
+		if (tgs.totl && totl_lock == NULL) {
+			ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &totl_lock);
 			if (ret < 0)
 				break;
-			locked_zone = tag_key.sk_zone;
 		}
 
 		ret = scoutfs_hold_trans(sb, false);
@@ -1301,13 +1140,7 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 		if (tgs.totl) {
 			tval.total = cpu_to_le64(-total);
 			tval.count = cpu_to_le64(-1LL);
-			ret = apply_totl_delta(sb, &tag_key, &tval, tag_lock);
-			if (ret < 0)
-				break;
-		}
-
-		if (tgs.indx) {
-			ret = scoutfs_item_delete_force(sb, &tag_key, tag_lock, NULL);
+			ret = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
 			if (ret < 0)
 				break;
 		}
@@ -1320,7 +1153,7 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 
 	if (release)
 		scoutfs_release_trans(sb);
-	scoutfs_unlock(sb, tag_lock, SCOUTFS_LOCK_WRITE_ONLY);
+	scoutfs_unlock(sb, totl_lock, SCOUTFS_LOCK_WRITE_ONLY);
 	kfree(xat);
 out:
 	return ret;

kmod/src/xattr.h

@@ -3,7 +3,6 @@
 
 struct scoutfs_xattr_prefix_tags {
 	unsigned long hide:1,
-		      indx:1,
 		      srch:1,
 		      totl:1;
 };
@@ -31,9 +30,4 @@ int scoutfs_xattr_parse_tags(const char *name, unsigned int name_len,
 void scoutfs_xattr_init_totl_key(struct scoutfs_key *key, u64 *name);
 int scoutfs_xattr_combine_totl(void *dst, int dst_len, void *src, int src_len);
 
-void scoutfs_xattr_indx_get_range(struct scoutfs_key *start, struct scoutfs_key *end);
-void scoutfs_xattr_init_indx_key(struct scoutfs_key *key, u8 major, u64 minor, u64 ino, u64 xid);
-void scoutfs_xattr_get_indx_key(struct scoutfs_key *key, u8 *major, u64 *minor, u64 *ino, u64 *xid);
-void scoutfs_xattr_set_indx_key_xid(struct scoutfs_key *key, u64 xid);
-
 #endif

tests/.gitignore

@@ -9,4 +9,3 @@ src/find_xattrs
 src/stage_tmpfile
 src/create_xattr_loop
 src/o_tmpfile_umask
-src/o_tmpfile_linkat

tests/Makefile

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

tests/README.md

@@ -113,7 +113,6 @@ used during the test.
 | T\_EX\_META\_DEV | scratch meta bdev    | -f              | /dev/vdd          |
 | T\_EX\_DATA\_DEV | scratch meta bdev    | -e              | /dev/vdc          |
 | T\_M[0-9]        | mount paths          | mounted per run | /mnt/test.[0-9]/  |
-| T\_MODULE        | built kernel module  | created per run | ../kmod/src/..ko  |
 | T\_NR\_MOUNTS    | number of mounts     | -n              | 3                 |
 | T\_O[0-9]        | mount options        | created per run | -o server\_addr=  |
 | T\_QUORUM        | quorum count         | -q              | 2                 |

tests/funcs/filter.sh

@@ -147,10 +147,6 @@ t_filter_dmesg()
 	# ignore systemd-journal rotating
 	re="$re|systemd-journald.*"
 
-	# format vers back/compat tries bad mounts
-	re="$re|scoutfs .* error.*outside of supported version.*"
-	re="$re|scoutfs .* error.*could not get .*super.*"
-
 	egrep -v "($re)" | \
 		ignore_harmless_unwind_kasan_stack_oob
 }

tests/funcs/fs.sh

@@ -29,12 +29,13 @@ t_mount_rid()
 }
 
 #
-# Output the "f.$fsid.r.$rid" identifier string for the given path
-# in a mounted scoutfs volume.
+# Output the "f.$fsid.r.$rid" identifier string for the given mount
+# number, 0 is used by default if none is specified. 
 #
-t_ident_from_mnt()
+t_ident()
 {
-	local mnt="$1"
+	local nr="${1:-0}"
+	local mnt="$(eval echo \$T_M$nr)"
 	local fsid
 	local rid
 
@@ -44,38 +45,6 @@ t_ident_from_mnt()
 	echo "f.${fsid:0:6}.r.${rid:0:6}"
 }
 
-#
-# Output the "f.$fsid.r.$rid" identifier string for the given mount
-# number, 0 is used by default if none is specified.
-#
-t_ident()
-{
-	local nr="${1:-0}"
-	local mnt="$(eval echo \$T_M$nr)"
-
-	t_ident_from_mnt "$mnt"
-}
-
-#
-# Output the sysfs path for a path in a mounted fs.
-#
-t_sysfs_path_from_ident()
-{
-	local ident="$1"
-
-	echo "/sys/fs/scoutfs/$ident"
-}
-
-#
-# Output the sysfs path for a path in a mounted fs.
-#
-t_sysfs_path_from_mnt()
-{
-	local mnt="$1"
-
-	t_sysfs_path_from_ident $(t_ident_from_mnt $mnt)
-}
-
 #
 # Output the mount's sysfs path, defaulting to mount 0 if none is
 # specified.
@@ -84,7 +53,7 @@ t_sysfs_path()
 {
 	local nr="$1"
 
-	t_sysfs_path_from_ident $(t_ident $nr)
+	echo "/sys/fs/scoutfs/$(t_ident $nr)"
 }
 
 #

tests/golden/format-version-forward-back

@@ -1,4 +0,0 @@
-== ensuring utils and module for old versions
-== unmounting test fs and removing test module
-== testing combinations of old and new format versions
-== restoring test module and mount

tests/golden/projects

@@ -1,24 +0,0 @@
-== default new files don't have project
-0
-== set new project on files and dirs
-8675309
-8675309
-== non-root can see id
-8675309
-== can use IDs around long width limits
-2147483647
-2147483648
-4294967295
-9223372036854775807
-9223372036854775808
-18446744073709551615
-== created files and dirs inherit project id
-8675309
-8675309
-== inheritance continues
-8675309
-== clearing project id stops inheritance
-0
-0
-== o_tmpfile creations inherit dir
-8675309

tests/golden/quota

@@ -1,40 +0,0 @@
-== prepare dir with write perm for test ids
-== test assumes starting with no rules, empty list
-== add rule
-  7 13,L,- 15,L,- 17,L,- I 33 -
-== list is empty again after delete
-== can change limits without deleting
-  1 1,L,- 1,L,- 1,L,- I 100 -
-  1 1,L,- 1,L,- 1,L,- I 101 -
-  1 1,L,- 1,L,- 1,L,- I 99 -
-== wipe and restore rules in bulk
-  7 15,L,- 0,L,- 0,L,- I 33 -
-  7 14,L,- 0,L,- 0,L,- I 33 -
-  7 13,L,- 0,L,- 0,L,- I 33 -
-  7 12,L,- 0,L,- 0,L,- I 33 -
-  7 11,L,- 0,L,- 0,L,- I 33 -
-  7 10,L,- 0,L,- 0,L,- I 33 -
-  7 15,L,- 0,L,- 0,L,- I 33 -
-  7 14,L,- 0,L,- 0,L,- I 33 -
-  7 13,L,- 0,L,- 0,L,- I 33 -
-  7 12,L,- 0,L,- 0,L,- I 33 -
-  7 11,L,- 0,L,- 0,L,- I 33 -
-  7 10,L,- 0,L,- 0,L,- I 33 -
-== default rule prevents file creation
-touch: cannot touch '/mnt/test/test/quota/dir/file': Disk quota exceeded
-== decreasing totl allows file creation again
-== attr selecting rules prevent creation
-touch: cannot touch '/mnt/test/test/quota/dir/file': Disk quota exceeded
-touch: cannot touch '/mnt/test/test/quota/dir/file': Disk quota exceeded
-== multi attr selecting doesn't prevent partial
-touch: cannot touch '/mnt/test/test/quota/dir/file': Disk quota exceeded
-== op differentiates
-== higher priority rule applies
-touch: cannot touch '/mnt/test/test/quota/dir/file': Disk quota exceeded
-== data rules with total and count prevent write and fallocate
-dd: error writing '/mnt/test/test/quota/dir/file': Disk quota exceeded
-fallocate: fallocate failed: Disk quota exceeded
-dd: error writing '/mnt/test/test/quota/dir/file': Disk quota exceeded
-fallocate: fallocate failed: Disk quota exceeded
-== added rules work after bulk restore
-touch: cannot touch '/mnt/test/test/quota/dir/file': Disk quota exceeded

tests/golden/retention-basic

@@ -1,28 +0,0 @@
-== setting retention on dir fails
-attr_x ioctl failed on '/mnt/test/test/retention-basic': Invalid argument (22)
-scoutfs: set-attr-x failed: Invalid argument (22)
-== set retention
-== get-attr-x shows retention
-1
-== unpriv can't clear retention
-attr_x ioctl failed on '/mnt/test/test/retention-basic/file-1': Operation not permitted (1)
-scoutfs: set-attr-x failed: Operation not permitted (1)
-== can set hidden scoutfs xattr in retention
-== setting user. xattr fails in retention
-setfattr: /mnt/test/test/retention-basic/file-1: Operation not permitted
-== file deletion fails in retention
-rm: cannot remove '/mnt/test/test/retention-basic/file-1': Operation not permitted
-== file rename fails in retention
-mv: cannot move '/mnt/test/test/retention-basic/file-1' to '/mnt/test/test/retention-basic/file-2': Operation not permitted
-== file write fails in retention
-date: write error: Operation not permitted
-== file truncate fails in retention
-truncate: failed to truncate '/mnt/test/test/retention-basic/file-1' at 0 bytes: Operation not permitted
-== setattr fails in retention
-touch: setting times of '/mnt/test/test/retention-basic/file-1': Operation not permitted
-== clear retention
-== file write
-== file rename
-== setattr
-== xattr deletion
-== cleanup

tests/run-tests.sh

@@ -73,7 +73,6 @@ $(basename $0) options:
     -t        | Enabled trace events that match the given glob argument.
               | Multiple options enable multiple globbed events.
     -T <nr>   | Multiply the original trace buffer size by nr during the run.
-    -V <nr>   | Set mkfs device format version.
     -X        | xfstests git repo. Used by tests/xfstests.sh.
     -x        | xfstests git branch to checkout and track.
     -y        | xfstests ./check additional args
@@ -177,11 +176,6 @@ while true; do
 		T_TRACE_MULT="$2"
 		shift
 		;;
-	-V)
-		test -n "$2" || die "-V must have a format version argument"
-		T_MKFS_FORMAT_VERSION="-V $2"
-		shift
-		;;
 	-X)
 		test -n "$2" || die "-X requires xfstests git repo dir argument"
 		T_XFSTESTS_REPO="$2"
@@ -350,7 +344,7 @@ if [ -n "$T_MKFS" ]; then
 	done
 
 	msg "making new filesystem with $T_QUORUM quorum members"
-	cmd scoutfs mkfs -f $quo $T_DATA_ALLOC_ZONE_BLOCKS $T_MKFS_FORMAT_VERSION \
+	cmd scoutfs mkfs -f $quo $T_DATA_ALLOC_ZONE_BLOCKS \
 		"$T_META_DEVICE" "$T_DATA_DEVICE"
 fi
 
@@ -358,8 +352,7 @@ if [ -n "$T_INSMOD" ]; then
 	msg "removing and reinserting scoutfs module"
 	test -e /sys/module/scoutfs && cmd rmmod scoutfs
 	cmd modprobe libcrc32c
-	T_MODULE="$T_KMOD/src/scoutfs.ko"
-	cmd insmod "$T_MODULE"
+	cmd insmod "$T_KMOD/src/scoutfs.ko"
 fi
 
 if [ -n "$T_TRACE_MULT" ]; then

tests/sequence

@@ -12,16 +12,12 @@ data-prealloc.sh
 setattr_more.sh
 offline-extent-waiting.sh
 move-blocks.sh
-projects.sh
 large-fragmented-free.sh
-format-version-forward-back.sh
 enospc.sh
 srch-safe-merge-pos.sh
 srch-basic-functionality.sh
 simple-xattr-unit.sh
-retention-basic.sh
 totl-xattr-tag.sh
-quota.sh
 lock-refleak.sh
 lock-shrink-consistency.sh
 lock-pr-cw-conflict.sh

tests/src/o_tmpfile_linkat.c

@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2023 Versity Software, Inc.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <assert.h>
-#include <limits.h>
-
-static void linkat_tmpfile(char *dir, char *lpath)
-{
-	char proc_self[PATH_MAX];
-	int ret;
-	int fd;
-
-	fd = open(dir, O_RDWR | O_TMPFILE, 0777);
-	if (fd < 0) {
-		perror("open(O_TMPFILE)");
-		exit(1);
-	}
-
-	snprintf(proc_self, sizeof(proc_self), "/proc/self/fd/%d", fd);
-
-	ret = linkat(AT_FDCWD, proc_self, AT_FDCWD, lpath, AT_SYMLINK_FOLLOW);
-	if (ret < 0) {
-		perror("linkat");
-		exit(1);
-	}
-
-	close(fd);
-}
-
-/*
- * Use O_TMPFILE and linkat to create a new visible file, used to test
- * the O_TMPFILE creation path by inspecting the created file.
- */
-int main(int argc, char **argv)
-{
-	char *lpath;
-	char *dir;
-
-	if (argc < 3) {
-		printf("%s <open_dir> <linkat_path>\n", argv[0]);
-		return 1;
-	}
-
-	dir = argv[1];
-	lpath = argv[2];
-
-	linkat_tmpfile(dir, lpath);
-
-	return 0;
-}

tests/tests/format-version-forward-back.sh

@@ -1,179 +0,0 @@
-#
-# Test our basic ability to work with different format versions.
-#
-# The current code being tested has a range of supported format
-# versions.   For each of the older supported format versions we have a
-# git hash of the commit before the next greater version was introduced.
-# We build versions of the scoutfs utility and kernel module for the
-# last commit in tree that had a lesser supported version as its max
-# supported version.   We use those binaries to test forward and back
-# compat as new and old code works with a persistent volume with a given
-# format version.
-#
-
-mount_has_format_version()
-{
-	local mnt="$1"
-	local vers="$2"
-	local sysfs_fmt_vers="$(t_sysfs_path_from_mnt $SCR)/format_version"
-
-	test "$(cat $sysfs_fmt_vers)" == "$vers"
-}
-
-SCR="/mnt/scoutfs.scratch"
-
-MIN=$(modinfo $T_MODULE | awk '($1 == "scoutfs_format_version_min:"){print $2}')
-MAX=$(modinfo $T_MODULE | awk '($1 == "scoutfs_format_version_max:"){print $2}')
-
-echo "min: $MIN max: $MAX" > "$T_TMP.log"
-
-test "$MIN" -gt 0 -a "$MAX" -gt 0 -a "$MIN" -le "$MAX" || \
-	t_fail "parsed bad versions, min: $MIN max: $MAX"
-
-test "$MIN" == "$MAX" && \
-	t_skip "only one supported format version: $MIN"
-
-# prepare dir and wipe any weird old partial state
-builds="$T_RESULTS/format_version_builds"
-mkdir -p "$builds"
-
-echo "== ensuring utils and module for old versions"
-declare -A commits
-commits[1]=c3c4b080
-for vers in $(seq $MIN $((MAX - 1))); do
-	dir="$builds/$vers"
-	platform=$(uname -rp)
-	buildmark="$dir/buildmark"
-	commit="${commits[$vers]}"
-
-	test -n "$commit" || \
-		t_fail "no commit for vers $vers"
-
-	# have our files for this version
-	test "$(cat $buildmark 2>&1)" == "$platform" && \
-		continue
-
-	# build as one big sequence of commands that can return failure
-	(
-		set -o pipefail
-
-		rm -rf $dir							&&
-		mkdir -p $dir/building						&&
-		cd "$T_TESTS/.."						&&
-		git archive --format=tar "$commit" | tar -C "$dir/building" -xf - &&
-		cd -								&&
-		find $dir							&&
-		make -C "$dir/building"						&&
-		mv $dir/building/utils/src/scoutfs $dir				&&
-		mv $dir/building/kmod/src/scoutfs.ko $dir			&&
-		rm -rf $dir/building						&&
-		echo "$platform" > $buildmark					&&
-		find $dir							&&
-		cat $buildmark
-	) >> "$T_TMP.log" 2>&1 || t_fail "version $vers build failed"
-done
-
-echo "== unmounting test fs and removing test module"
-t_quiet t_umount_all
-t_quiet rmmod scoutfs
-
-echo "== testing combinations of old and new format versions"
-mkdir -p "$SCR"
-for vers in $(seq $MIN $((MAX - 1))); do
-	old_scoutfs="$builds/$vers/scoutfs"
-	old_module="$builds/$vers/scoutfs.ko"
-
-	echo "mkfs $vers" >> "$T_TMP.log"
-	t_quiet $old_scoutfs mkfs -f -Q 0,127.0.0.1,53000 "$T_EX_META_DEV" "$T_EX_DATA_DEV" \
-		|| t_fail "mkfs $vers failed"
-
-	echo "mount $vers with $vers" >> "$T_TMP.log"
-	t_quiet insmod $old_module
-	t_quiet mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 \
-		"$T_EX_DATA_DEV" "$SCR"
-	t_quiet mount_has_format_version "$SCR" "$vers"
-
-	echo "creating files in $vers" >> "$T_TMP.log"
-	t_quiet touch "$SCR/file-"{1,2,3}
-	stat "$SCR"/file-* > "$T_TMP.stat" || \
-		t_fail "stat in $vers failed"
-
-	echo "remounting $vers fs with $MAX" >> "$T_TMP.log"
-	t_quiet umount "$SCR"
-	rmmod scoutfs
-	insmod "$T_MODULE"
-	t_quiet mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 \
-		"$T_EX_DATA_DEV" "$SCR"
-	t_quiet mount_has_format_version "$SCR" "$vers"
-
-	echo "verifying stat in $vers with $MAX" >> "$T_TMP.log"
-	diff -u "$T_TMP.stat" <(stat "$SCR"/file-*)
-
-	echo "keep/update/del existing, create new in $vers" >> "$T_TMP.log"
-	t_quiet touch "$SCR/file-2"
-	t_quiet rm -f "$SCR/file-3"
-	t_quiet touch "$SCR/file-4"
-	stat "$SCR"/file-* > "$T_TMP.stat" || \
-		t_fail "stat in $vers failed"
-
-	echo "remounting $vers fs with $vers" >> "$T_TMP.log"
-	t_quiet umount "$SCR"
-	rmmod scoutfs
-	insmod "$old_module"
-	t_quiet mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 \
-		"$T_EX_DATA_DEV" "$SCR"
-	t_quiet mount_has_format_version "$SCR" "$vers"
-
-	echo "verifying stat in $vers with $vers" >> "$T_TMP.log"
-	diff -u "$T_TMP.stat" <(stat "$SCR"/file-*)
-
-	echo "changing format vers to $MAX" >> "$T_TMP.log"
-	t_quiet umount "$SCR"
-	rmmod scoutfs
-	t_quiet scoutfs change-format-version -F -V $MAX $T_EX_META_DEV "$T_EX_DATA_DEV"
-
-	echo "mount fs $MAX with old $vers should fail" >> "$T_TMP.log"
-	insmod "$old_module"
-	mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 \
-		"$T_EX_DATA_DEV" "$SCR" >> "$T_TMP.log" 2>&1
-	if [ "$?" == "0" ]; then
-		umount "$SCR"
-		t_fail "old code ver $vers able to mount new ver $MAX"
-	fi
-
-	echo "remounting $MAX fs with $MAX" >> "$T_TMP.log"
-	rmmod scoutfs
-	insmod "$T_MODULE"
-	t_quiet mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 \
-		"$T_EX_DATA_DEV" "$SCR"
-	t_quiet mount_has_format_version "$SCR" "$MAX"
-
-	echo "verifying stat in $MAX with $MAX" >> "$T_TMP.log"
-	diff -u "$T_TMP.stat" <(stat "$SCR"/file-*)
-
-	echo "keep/update/del existing, create new in $MAX" >> "$T_TMP.log"
-	t_quiet touch "$SCR/file-2"
-	t_quiet rm -f "$SCR/file-4"
-	t_quiet touch "$SCR/file-5"
-	stat "$SCR"/file-* > "$T_TMP.stat" || \
-		t_fail "stat in $MAX failed"
-
-	echo "remounting $MAX fs with $MAX again" >> "$T_TMP.log"
-	t_quiet umount "$SCR"
-	t_quiet mount -t scoutfs -o metadev_path=$T_EX_META_DEV,quorum_slot_nr=0 \
-		"$T_EX_DATA_DEV" "$SCR"
-	t_quiet mount_has_format_version "$SCR" "$MAX"
-
-	echo "verifying stat in $MAX with $MAX again" >> "$T_TMP.log"
-	diff -u "$T_TMP.stat" <(stat "$SCR"/file-*)
-
-	echo "done with old vers $vers" >> "$T_TMP.log"
-	t_quiet umount "$SCR"
-	rmmod scoutfs
-done
-
-echo "== restoring test module and mount"
-insmod "$T_MODULE"
-t_mount_all
-
-t_pass

tests/tests/projects.sh

@@ -1,52 +0,0 @@
-
-# notable id to recognize in output
-ID=8675309
-
-echo "== default new files don't have project"
-touch "$T_D0/file"
-scoutfs get-attr-x -p "$T_D0/file"
-
-echo "== set new project on files and dirs"
-mkdir "$T_D0/dir"
-scoutfs set-attr-x -p $ID "$T_D0/file"
-scoutfs set-attr-x -p $ID "$T_D0/dir"
-scoutfs get-attr-x -p "$T_D0/file"
-scoutfs get-attr-x -p "$T_D0/dir"
-
-echo "== non-root can see id"
-chmod 644 "$T_D0/file"
-setpriv --ruid=12345 --euid=12345 scoutfs get-attr-x -p "$T_D0/file"
-
-echo "== can use IDs around long width limits"
-touch "$T_D0/ids"
-for id in         0x7FFFFFFF         0x80000000         0xFFFFFFFF \
-          0x7FFFFFFFFFFFFFFF 0x8000000000000000 0xFFFFFFFFFFFFFFFF; do
-	scoutfs set-attr-x -p $id "$T_D0/ids"
-	scoutfs get-attr-x -p "$T_D0/ids"
-done
-
-echo "== created files and dirs inherit project id"
-touch "$T_D0/dir/file"
-mkdir "$T_D0/dir/sub"
-scoutfs get-attr-x -p "$T_D0/dir/file"
-scoutfs get-attr-x -p "$T_D0/dir/sub"
-
-echo "== inheritance continues"
-mkdir "$T_D0/dir/sub/more"
-scoutfs get-attr-x -p "$T_D0/dir/sub/more"
-
-# .. just inherits 0 :) 
-echo "== clearing project id stops inheritance"
-scoutfs set-attr-x -p 0 "$T_D0/dir"
-touch "$T_D0/dir/another-file"
-mkdir "$T_D0/dir/another-sub"
-scoutfs get-attr-x -p "$T_D0/dir/another-file"
-scoutfs get-attr-x -p "$T_D0/dir/another-sub"
-
-echo "== o_tmpfile creations inherit dir"
-scoutfs set-attr-x -p $ID "$T_D0/dir"
-o_tmpfile_linkat "$T_D0/dir" "$T_D0/dir/tmpfile"
-scoutfs get-attr-x -p "$T_D0/dir/tmpfile"
-
-
-t_pass

tests/tests/quota.sh

@@ -1,150 +0,0 @@
-
-TEST_UID=22222
-TEST_GID=44444
-
-# sys_setreuid() set fs[uid] to e[ug]id
-SET_UID="--ruid=$TEST_UID --euid=$TEST_UID"
-SET_GID="--rgid=$TEST_GID --egid=$TEST_GID --clear-groups"
-
-FILE="$T_D0/dir/file"
-
-sync_and_drop()
-{
-	sync
-	echo 1 > $(t_debugfs_path)/drop_weak_item_cache
-	echo 1 > $(t_debugfs_path)/drop_quota_check_cache
-}
-
-reset_all()
-{
-	rm -f "$FILE"
-	scoutfs quota-wipe -p "$T_M0"
-	getfattr --absolute-names -d -m - "$T_D0" | \
-		grep "^scoutfs.totl." | \
-		cut -d '=' -f 1 | \
-		xargs -n 1 -I'{}'  setfattr -x '{}' "$T_D0"
-}
-
-echo "== prepare dir with write perm for test ids"
-mkdir "$T_D0/dir"
-chown --quiet $TEST_UID "$T_D0/dir"
-chgrp --quiet $TEST_GID "$T_D0/dir"
-
-echo "== test assumes starting with no rules, empty list"
-scoutfs quota-list -p "$T_M0"
-
-echo "== add rule"
-scoutfs quota-add -p "$T_M0" -r "7 13,L,- 15,L,- 17,L,- I 33 -"
-scoutfs quota-list -p "$T_M0"
-
-echo "== list is empty again after delete"
-scoutfs quota-del -p "$T_M0" -r "7 13,L,- 15,L,- 17,L,- I 33 -"
-scoutfs quota-list -p "$T_M0"
-
-echo "== can change limits without deleting"
-scoutfs quota-add -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 100 -"
-scoutfs quota-list -p "$T_M0"
-scoutfs quota-add -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 101 -"
-scoutfs quota-del -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 100 -"
-scoutfs quota-list -p "$T_M0"
-scoutfs quota-add -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 99 -"
-scoutfs quota-del -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 101 -"
-scoutfs quota-list -p "$T_M0"
-scoutfs quota-del -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 99 -"
-reset_all
-
-echo "== wipe and restore rules in bulk"
-for a in $(seq 10 15); do
-	scoutfs quota-add -p "$T_M0" -r "7 $a,L,- 0,L,- 0,L,- I 33 -"
-done
-scoutfs quota-list -p "$T_M0"
-scoutfs quota-list -p "$T_M0" > "$T_TMP.list"
-scoutfs quota-wipe -p "$T_M0"
-scoutfs quota-list -p "$T_M0"
-scoutfs quota-restore -p "$T_M0" < "$T_TMP.list"
-scoutfs quota-list -p "$T_M0"
-reset_all
-
-echo "== default rule prevents file creation"
-scoutfs quota-add -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 1 -"
-setfattr -n scoutfs.totl.test.1.1.1 -v 2 "$T_D0"
-sync_and_drop
-setpriv $SET_UID touch "$FILE" 2>&1 | t_filter_fs
-
-echo "== decreasing totl allows file creation again"
-setfattr -x scoutfs.totl.test.1.1.1 "$T_D0"
-sync_and_drop
-setpriv $SET_UID touch "$FILE"
-reset_all
-
-echo "== attr selecting rules prevent creation"
-scoutfs quota-add -p "$T_M0" -r "1 $TEST_UID,U,S 1,L,- 1,L,- I 1 -"
-scoutfs quota-add -p "$T_M0" -r "1 $TEST_GID,G,S 1,L,- 1,L,- I 1 -"
-setfattr -n scoutfs.totl.test.$TEST_UID.1.1 -v 2 "$T_D0"
-setfattr -n scoutfs.totl.test.$TEST_GID.1.1 -v 2 "$T_D0"
-sync_and_drop
-setpriv $SET_UID touch "$FILE" 2>&1 | t_filter_fs
-setpriv $SET_GID touch "$FILE" 2>&1 | t_filter_fs
-reset_all
-
-echo "== multi attr selecting doesn't prevent partial"
-scoutfs quota-add -p "$T_M0" -r "1 $TEST_UID,U,S $TEST_GID,G,S 1,L,- I 1 -"
-setfattr -n scoutfs.totl.test.$TEST_UID.$TEST_GID.1 -v 2 "$T_D0"
-sync_and_drop
-setpriv $SET_UID touch "$FILE"
-rm -f "$FILE"
-setpriv $SET_GID touch "$FILE"
-rm -f "$FILE"
-setpriv $SET_UID $SET_GID touch "$FILE" 2>&1 | t_filter_fs
-reset_all
-
-echo "== op differentiates"
-# inode ops succeed in presence of data rule
-scoutfs quota-add -p "$T_M0" -r "1 $TEST_UID,U,S 1,L,- 1,L,- D 1 -"
-setfattr -n scoutfs.totl.test.$TEST_UID.1.1 -v 2 "$T_D0"
-sync_and_drop
-setpriv $SET_UID touch "$FILE" 2>&1 | t_filter_fs
-reset_all
-# data ops succeed in presence of inode rule
-touch "$FILE"
-chown --quiet $TEST_UID "$FILE"
-scoutfs quota-add -p "$T_M0" -r "1 $TEST_UID,U,S 1,L,- 1,L,- I 1 -"
-setfattr -n scoutfs.totl.test.$TEST_UID.1.1 -v 2 "$T_D0"
-sync_and_drop
-setpriv $SET_UID fallocate -l 4096 "$FILE" 2>&1 | t_filter_fs
-reset_all
-
-echo "== higher priority rule applies"
-scoutfs quota-add -p "$T_M0" -r "1 $TEST_UID,U,S 1,L,- 1,L,- I 1000 -"
-scoutfs quota-add -p "$T_M0" -r "2 $TEST_UID,U,S 1,L,- 1,L,- I 1 -"
-setfattr -n scoutfs.totl.test.$TEST_UID.1.1 -v 2 "$T_D0"
-sync_and_drop
-setpriv $SET_UID touch "$FILE" 2>&1 | t_filter_fs
-reset_all
-
-echo "== data rules with total and count prevent write and fallocate" 
-touch "$FILE"
-scoutfs quota-add -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- D 1 -"
-setfattr -n scoutfs.totl.test.1.1.1 -v 2 "$T_D0"
-sync_and_drop
-dd if=/dev/zero of="$FILE" bs=4096 count=1 conv=notrunc status=none 2>&1 | t_filter_fs
-fallocate -l 4096 "$FILE" 2>&1 | t_filter_fs
-scoutfs quota-del -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- D 1 -"
-scoutfs quota-add -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- D 0 C"
-sync_and_drop
-dd if=/dev/zero of="$FILE" bs=4096 count=1 conv=notrunc status=none 2>&1 | t_filter_fs
-fallocate -l 4096 "$FILE" 2>&1 | t_filter_fs
-reset_all
-
-echo "== added rules work after bulk restore"
-seq -f "  1 %.0f,U,S 1,L,- 1,L,- I 1 -" 9000050000 -1 9000000000 > "$T_TMP.lots"
-scoutfs quota-restore -p "$T_M0" < "$T_TMP.lots"
-scoutfs quota-list -p "$T_M0" > "$T_TMP.list"
-diff -u "$T_TMP.lots" "$T_TMP.list"
-scoutfs quota-add -p "$T_M0" -r "1 $TEST_UID,U,S 1,L,- 1,L,- I 1 -"
-setfattr -n scoutfs.totl.test.$TEST_UID.1.1 -v 2 "$T_D0"
-sync_and_drop
-setpriv $SET_UID touch "$FILE" 2>&1 | t_filter_fs
-reset_all
-
-t_pass

tests/tests/retention-basic.sh

@@ -1,57 +0,0 @@
-t_require_commands scoutfs touch rm setfattr
-
-touch "$T_D0/file-1"
-
-echo "== setting retention on dir fails"
-scoutfs set-attr-x -t 1 "$T_D0" 2>&1 | t_filter_fs
-
-echo "== set retention"
-scoutfs set-attr-x -t 1 "$T_D0/file-1"
-
-echo "== get-attr-x shows retention"
-scoutfs get-attr-x -t "$T_D0/file-1"
-
-echo "== unpriv can't clear retention"
-setpriv --ruid=12345 --euid=12345 scoutfs set-attr-x -t 0 "$T_D0/file-1" 2>&1 | t_filter_fs
-
-echo "== can set hidden scoutfs xattr in retention"
-setfattr -n scoutfs.hide.srch.retention_test -v val "$T_D0/file-1"
-
-echo "== setting user. xattr fails in retention"
-setfattr -n user.retention_test -v val "$T_D0/file-1" 2>&1 | t_filter_fs
-
-echo "== file deletion fails in retention"
-rm -f "$T_D0/file-1" 2>&1 | t_filter_fs
-
-echo "== file rename fails in retention"
-mv $T_D0/file-1 $T_D0/file-2 2>&1 | t_filter_fs
-
-echo "== file write fails in retention"
-date >> $T_D0/file-1
-
-echo "== file truncate fails in retention"
-truncate -s 0 $T_D0/file-1 2>&1 | t_filter_fs
-
-echo "== setattr fails in retention"
-touch $T_D0/file-1 2>&1 | t_filter_fs
-
-echo "== clear retention"
-scoutfs set-attr-x -t 0 "$T_D0/file-1"
-
-echo "== file write"
-date >> $T_D0/file-1
-
-echo "== file rename"
-mv $T_D0/file-1 $T_D0/file-2
-mv $T_D0/file-2 $T_D0/file-1
-
-echo "== setattr"
-touch $T_D0/file-1 2>&1 | t_filter_fs
-
-echo "== xattr deletion"
-setfattr -x scoutfs.hide.srch.retention_test "$T_D0/file-1"
-
-echo "== cleanup"
-rm -f "$T_D0/file-1"
-
-t_pass

tests/tests/totl-xattr-tag.sh

@@ -3,7 +3,6 @@ t_require_commands touch rm setfattr scoutfs find_xattrs
 read_xattr_totals()
 {
 	sync
-	echo 1 > $(t_debugfs_path)/drop_weak_item_cache
 	scoutfs read-xattr-totals -p "$T_M0"
 }
 
@@ -113,6 +112,7 @@ for phase in create update remove; do
 				echo "$k.0.0 = ${totals[$k]}, ${counts[$k]}"
 			  done ) | grep -v "= 0, 0$" | sort -n >> $T_TMP.check_arr
 
+			sync
 			read_xattr_totals | sort -n >> $T_TMP.check_read
 
 			diff -u $T_TMP.check_arr $T_TMP.check_read || \

utils/man/scoutfs.5

@@ -55,19 +55,6 @@ with initial sparse regions (perhaps by multiple threads writing to
 different regions) and wasted space isn't an issue (perhaps because the
 file population contains few small files).
 .TP
-.B log_merge_wait_timeout_ms=<number>
-This option sets the amount of time, in milliseconds, that log merge
-creation can wait before timing out.  This setting is per-mount, only
-changes the behavior of that mount, and only affects the server when it
-is running in that mount.
-.sp
-This determines how long it may take for mounts to synchronize
-committing their log trees to create a log merge operation.  Setting it
-too high can create long latencies in the event that a mount takes a
-long time to commit their log.  Setting it too low can result in the
-creation of excessive numbers of log trees that are never merged.  The
-default is 500 and it can not be less than 100 nor greater than 60000.
-.TP
 .B metadev_path=<device>
 The metadev_path option specifies the path to the block device that
 contains the filesystem's metadata.
@@ -270,21 +257,6 @@ metadata that is bound to a specific volume and should not be
 transferred with the file by tools that read extended attributes, like
 .BR tar(1) .
 .TP
-.B .indx.
-Attributes with the .indx. tag dd the inode containing the attribute to
-a filesystem-wide index.  The name of the extended attribute must end
-with strings representing two values separated by dots.  The first value
-is an unsigned 8bit value and the second is an unsigned 64bit value.
-These attributes can only be modified with root privileges and the
-attributes can not have a value.
-.sp
-The inodes in the index are stored in increasing sort order of the
-values, with the first u8 value being most significant.  Inodes can be
-at many positions as tracked by many extended attributes, and their
-position follows the creation, renaming, or deletion of the attributes.
-The index can be read with the read-xattr-index command which uses the
-underlying READ_XATTR_INDEX ioctl.
-.TP
 .B .srch.
 Attributes with the .srch. tag are indexed so that they can be
 found by the
@@ -310,36 +282,6 @@ with the
 ioctl.
 .RE
 
-.SH FILE RETENTION MODE
-A file can be set to retention mode by setting the
-.IB RETENTION
-attribute with the
-.IB SET_ATTR_X
-ioctl.  This flag can only be set on regular files and requires root
-permission (the
-.IB CAP_SYS_ADMIN
-capability).
-.sp
-Once in retention mode all modifications of the file will fail.  The
-only exceptions are that system extended attributes (all those without
-the "user." prefix) may be modified.  The retention bit may be cleared
-with sufficient priveledges to remove the retention restrictions on
-other modifications.
-.RE
-
-.SH PROJECT IDs
-All inodes have a project ID attribute that can be set via the
-SET_ATTR_X ioctl and displayed with the GET_ATTR_X ioctl.  Project IDs
-are an unsigned 64bit value and the value of 0 is reserved to indicate
-that no project ID is assigned.   If a project ID is set on a directory
-then all inodes created with it as the initial parent inheret that ID,
-for all file types.  This includes files initially unlinked from the
-namespace when created with O_TMPFILE.  Project IDs are only
-automatically inherited from the parent dir on initial creation.
-They're not changed as directory entry linkes to the inode are created
-or renamed.
-.RE
-
 .SH FORMAT VERSION
 The format version defines the layout and use of structures stored on
 devices and passed over the network.  The version is incremented for
@@ -418,19 +360,6 @@ The version that a mount is using is shown in the
 file in the mount's sysfs directory, typically
 .I /sys/fs/scoutfs/f.FSID.r.RID/
 .RE
-.sp
-The defined format versions are:
-.RS
-.TP
-.sp
-.B 1
-Initial format version.
-.TP
-.B 2
-Added retention mode by setting the retention attribute.  Added the
-project ID inode attribute.  Added quota rules and enforcement.  Added
-the .indx. extended attribute tag.
-.RE
 
 .SH CORRUPTION DETECTION
 A

utils/man/scoutfs.8

@@ -209,16 +209,6 @@ A path within a ScoutFS filesystem.
 .RE
 .PD
 
-.TP
-.BI "get-attr-x FILE"
-.sp
-Display ScoutFS-specific attributes from a file.  If no options are
-given than all the attributes that the command supports will be
-displayed.  If attributes are specified with options then only those
-attributes are displayed.  If only one attribute is specified then it
-will not have a label prefix in the display output.  The --help option
-will list the attributes that the command supports.  The file system may
-support a different set of attributes.
 .TP
 .BI "get-referring-entries [-p|--path PATH] INO"
 .sp
@@ -516,15 +506,6 @@ A path within a ScoutFS filesystem.
 .RE
 .PD
 
-.TP
-.BI "set-attr-x FILE"
-.sp
-Set ScoutFS-specific attributes on a file.  Only the attributes that are
-spcified by options will be set.  The --help option will list the
-attributes that the command understands.  The file system may support a
-different set of attributes.
-.PD
-
 .TP
 .BI "setattr FILE [-d, --data-version=VERSION [-s, --size=SIZE [-o, --offline]]] [-t, --ctime=TIMESPEC]"
 .sp

utils/src/attr_x.c

@@ -1,304 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <assert.h>
-#include <argp.h>
-#include <stdbool.h>
-
-#include "sparse.h"
-#include "util.h"
-#include "format.h"
-#include "ioctl.h"
-#include "parse.h"
-#include "cmd.h"
-
-struct attr_x_args {
-	bool set;
-	char *filename;
-	struct scoutfs_ioctl_inode_attr_x iax;
-};
-
-#define pr(iax, name, label, fmt, args...)			\
-do {								\
-	if ((iax->x_mask & SCOUTFS_IOC_IAX_##name)) {		\
-		if (__builtin_popcount(iax->x_mask) > 1)	\
-			printf(label ": " fmt "\n", ##args);	\
-		else						\
-			printf(fmt "\n", ##args);		\
-	}							\
-} while (0)
-
-#define prb(iax, name, label) \
-	pr(iax, name, label, "%u", !!((iax)->bits & SCOUTFS_IOC_IAX_B_##name))
-
-static int do_attr_x(struct attr_x_args *args)
-{
-	struct scoutfs_ioctl_inode_attr_x *iax = &args->iax;
-	int fd = -1;
-	int ret;
-	int op;
-
-	if (args->set) {
-		/* nothing to do if not setting */
-		if (iax->x_mask == 0)
-			return 0;
-		op = SCOUTFS_IOC_SET_ATTR_X;
-	} else {
-		/* get all known if none specified */
-		if (iax->x_mask == 0)
-			iax->x_mask = ~SCOUTFS_IOC_IAX__UNKNOWN;
-		op = SCOUTFS_IOC_GET_ATTR_X;
-	}
-
-	fd = open(args->filename, O_RDONLY);
-	if (fd < 0) {
-		ret = -errno;
-		fprintf(stderr, "failed to open '%s': %s (%d)\n",
-			args->filename, strerror(errno), errno);
-		goto out;
-	}
-
-	ret = ioctl(fd, op, iax);
-	if (ret < 0) {
-		ret = -errno;
-		fprintf(stderr, "attr_x ioctl failed on '%s': "
-			"%s (%d)\n", args->filename, strerror(errno), errno);
-		goto out;
-	}
-
-	if (!args->set) {
-		pr(iax, META_SEQ, "meta_seq", "%llu", iax->meta_seq);
-		pr(iax, DATA_SEQ, "data_seq", "%llu", iax->data_seq);
-		pr(iax, DATA_VERSION, "data_version", "%llu", iax->data_version);
-		pr(iax, ONLINE_BLOCKS, "online_blocks", "%llu", iax->online_blocks);
-		pr(iax, OFFLINE_BLOCKS, "offline_blocks", "%llu", iax->offline_blocks);
-		pr(iax, CTIME, "ctime", "%llu.%u", iax->ctime_sec, iax->ctime_nsec);
-		pr(iax, CRTIME, "crtime", "%llu.%u", iax->crtime_sec, iax->crtime_nsec);
-		pr(iax, SIZE, "size", "%llu", iax->size);
-		prb(iax, RETENTION, "retention");
-		pr(iax, PROJECT_ID, "project_id", "%llu", iax->project_id);
-	}
-
-	ret = 0;
-out:
-	if (fd >= 0)
-		close(fd);
-	return ret;
-}
-
-/*
- * This is called for both get and set.  The get calls won't have
- * arguments and are only setting the mask.  The set calls parse the
- * value to set.  We could have defaults by making set option arguments
- * optional, like setting the current time for timestamps, but that
- * hasn't been needed.
- *
- * Option value parsing places no constraints on the attributes or
- * values themselves once parsed.  This lets us use the set command to
- * test the kernel's testing for invalid attribute combinations and
- * values.
- */
-static int parse_opt(int key, char *arg, struct argp_state *state)
-{
-	struct attr_x_args *args = state->input;
-	struct timespec ts;
-	int ret;
-	u64 x;
-
-	switch (key) {
-	case 'm':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_META_SEQ;
-		if (arg) {
-			ret = parse_u64(arg, &args->iax.meta_seq);
-			if (ret)
-				return ret;
-		}
-		break;
-	case 'd':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_DATA_SEQ;
-		if (arg) {
-			ret = parse_u64(arg, &args->iax.data_seq);
-			if (ret)
-				return ret;
-		}
-		break;
-	case 'v':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_DATA_VERSION;
-		if (arg) {
-			ret = parse_u64(arg, &args->iax.data_version);
-			if (ret)
-				return ret;
-			if (args->iax.data_version == 0)
-				argp_error(state, "data version must not be 0");
-		}
-		break;
-	case 'n':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_ONLINE_BLOCKS;
-		if (arg) {
-			ret = parse_u64(arg, &args->iax.online_blocks);
-			if (ret)
-				return ret;
-		}
-		break;
-	case 'f':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_OFFLINE_BLOCKS;
-		if (arg) {
-			ret = parse_u64(arg, &args->iax.offline_blocks);
-			if (ret)
-				return ret;
-		}
-		break;
-	case 'c':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_CTIME;
-		if (arg) {
-			ret = parse_timespec(arg, &ts);
-			if (ret)
-				return ret;
-			args->iax.ctime_sec = ts.tv_sec;
-			args->iax.ctime_nsec = ts.tv_nsec;
-		}
-		break;
-	case 'r':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_CRTIME;
-		if (arg) {
-			ret = parse_timespec(arg, &ts);
-			if (ret)
-				return ret;
-			args->iax.crtime_sec = ts.tv_sec;
-			args->iax.crtime_nsec = ts.tv_nsec;
-		}
-		break;
-	case 's':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_SIZE;
-		if (arg) {
-			ret = parse_u64(arg, &args->iax.size);
-			if (ret)
-				return ret;
-		}
-		break;
-	case 't':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_RETENTION;
-		if (arg) {
-			ret = parse_u64(arg, &x);
-			if (ret)
-				return ret;
-			if (x)
-				args->iax.bits |= SCOUTFS_IOC_IAX_B_RETENTION;
-		}
-		break;
-	case 'p':
-		args->iax.x_mask |= SCOUTFS_IOC_IAX_PROJECT_ID;
-		if (arg) {
-			ret = parse_u64(arg, &args->iax.project_id);
-			if (ret)
-				return ret;
-		}
-		break;
-	case ARGP_KEY_ARG:
-		if (!args->filename)
-			args->filename = strdup_or_error(state, arg);
-		else
-			argp_error(state, "more than one argument given");
-		break;
-	case ARGP_KEY_FINI:
-		if (!args->filename)
-			argp_error(state, "no filename given");
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-/*
- * The get options are derived from these by copying the struct and
- * modifying fields.
- */
-static struct argp_option set_options[] = {
-	{ "meta_seq", 'm', "SEQ", 0, "Inode Metadata change index sequence number"},
-	{ "data_seq", 'd', "SEQ", 0, "File Data change index sequence number"},
-	{ "data_version", 'v', "VERSION", 0, "File Data contents version"},
-	{ "online_blocks", 'n', "COUNT", 0, "Online data block count"},
-	{ "offline_blocks", 'f', "COUNT", 0, "Offline data block count"},
-	{ "ctime", 'c', "SECS.NSECS", 0, "Inode change time (posix ctime)"},
-	{ "crtime", 'r', "SECS.NSECS", 0, "ScoutFS creation time"},
-	{ "size", 's', "SIZE", 0, "Inode i_size field"},
-	{ "retention", 't', "0|1", 0, "Retention flag"},
-	{ "project_id", 'p', "PROJECT_ID", 0, "Project ID"},
-	{ NULL }
-};
-
-static struct argp get_argp = {
-	NULL, /* dynamically built */
-	parse_opt,
-	"FILE",
-	"get extensible file attributes"
-};
-
-static int get_attr_x_cmd(int argc, char **argv)
-{
-	struct attr_x_args args = {0,};
-	int ret;
-
-	ret = argp_parse(&get_argp, argc, argv, 0, NULL, &args);
-	if (ret)
-		return ret;
-
-	return do_attr_x(&args);
-}
-
-/*
- * The set options match the get arguments but don't take argument
- * values to set.
- */
-static void build_get_options(void)
-{
-	struct argp_option **opts = (struct argp_option **)&get_argp.options;
-	int i;
-
-	*opts = calloc(array_size(set_options), sizeof(set_options[0]));
-	assert(*opts);
-
-	memcpy(*opts, set_options, array_size(set_options) * sizeof(set_options[0]));
-
-	for (i = 0; i < array_size(set_options) - 1; i++)
-		(*opts)[i].arg = NULL;
-}
-
-static void __attribute__((constructor)) get_ctor(void)
-{
-	build_get_options();
-
-	cmd_register_argp("get-attr-x", &get_argp, GROUP_AGENT, get_attr_x_cmd);
-}
-
-static struct argp set_argp = {
-	set_options,
-	parse_opt,
-	"FILE",
-	"Set extensible file attributes"
-};
-
-static int set_attr_x_cmd(int argc, char **argv)
-{
-	struct attr_x_args args = {.set = true,};
-	int ret;
-
-	ret = argp_parse(&set_argp, argc, argv, 0, NULL, &args);
-	if (ret)
-		return ret;
-
-	return do_attr_x(&args);
-}
-
-static void __attribute__((constructor)) set_ctor(void)
-{
-	cmd_register_argp("set-attr-x", &set_argp, GROUP_AGENT, set_attr_x_cmd);
-}

utils/src/change_format_version.c

@@ -119,16 +119,6 @@ static int do_change_fmt_vers(struct change_fmt_vers_args *args)
 		goto out;
 	}
 
-	if (le64_to_cpu(meta_super->fmt_vers) > args->fmt_vers ||
-	    le64_to_cpu(data_super->fmt_vers) > args->fmt_vers) {
-		ret = -EPERM;
-		printf("Downgrade of Meta Format Version: %llu and Data Format Version: %llu to Format Version: %llu is not allowed\n",
-		       le64_to_cpu(meta_super->fmt_vers),
-		       le64_to_cpu(data_super->fmt_vers),
-		       args->fmt_vers);
-		goto out;
-	}
-
 	if (le64_to_cpu(meta_super->fmt_vers) != args->fmt_vers) {
 		meta_super->fmt_vers = cpu_to_le64(args->fmt_vers);
 

utils/src/key.h

@@ -141,13 +141,4 @@ static inline void scoutfs_key_dec(struct scoutfs_key *key)
 	key->sk_zone--;
 }
 
-static inline void scoutfs_xattr_get_indx_key(struct scoutfs_key *key, u8 *major, u64 *minor,
-					      u64 *ino, u64 *xid)
-{
-	*major = le64_to_cpu(key->_sk_first) >> 56;
-	*minor = (le64_to_cpu(key->_sk_first) << 8) | (le64_to_cpu(key->_sk_second) >> 56);
-	*ino = (le64_to_cpu(key->_sk_second) << 8) | (le64_to_cpu(key->_sk_third) >> 56);
-	*xid = (le64_to_cpu(key->_sk_third) << 8) | key->_sk_fourth;
-}
-
 #endif

utils/src/mkfs.c

@@ -274,9 +274,7 @@ static int do_mkfs(struct mkfs_args *args)
 	inode.ctime.nsec = inode.atime.nsec;
 	inode.mtime.sec = inode.atime.sec;
 	inode.mtime.nsec = inode.atime.nsec;
-	inode.crtime.sec = inode.atime.sec;
-	inode.crtime.nsec = inode.atime.nsec;
-	btree_append_item(bt, &key, &inode, scoutfs_inode_vers_bytes(args->fmt_vers));
+	btree_append_item(bt, &key, &inode, sizeof(inode));
 
 	ret = write_block(meta_fd, SCOUTFS_BLOCK_MAGIC_BTREE, fsid, 1, blkno,
 			  SCOUTFS_BLOCK_LG_SHIFT, &bt->hdr);

utils/src/print.c

@@ -49,7 +49,7 @@ static void print_inode(struct scoutfs_key *key, void *val, int val_len)
 {
 	struct scoutfs_inode *inode = val;
 
-	printf("    inode: ino %llu size %llu version %llu proj %llu nlink %u\n"
+	printf("    inode: ino %llu size %llu version %llu nlink %u\n"
 	       "      uid %u gid %u mode 0%o rdev 0x%x flags 0x%x\n"
 	       "      next_readdir_pos %llu meta_seq %llu data_seq %llu data_version %llu\n"
 	       "      atime %llu.%08u ctime %llu.%08u\n"
@@ -57,7 +57,6 @@ static void print_inode(struct scoutfs_key *key, void *val, int val_len)
 	       le64_to_cpu(key->ski_ino),
 	       le64_to_cpu(inode->size),
 	       le64_to_cpu(inode->version),
-	       le64_to_cpu(inode->proj),
 	       le32_to_cpu(inode->nlink), le32_to_cpu(inode->uid),
 	       le32_to_cpu(inode->gid), le32_to_cpu(inode->mode),
 	       le32_to_cpu(inode->rdev),
@@ -80,24 +79,6 @@ static void print_orphan(struct scoutfs_key *key, void *val, int val_len)
 }
 
 
-#define SQR_FMT "[%u %llu,%u,%x %llu,%u,%x %llu,%u,%x %u %llu %x]"
-
-#define SQR_ARGS(r)								\
-	(r)->prio,								\
-	le64_to_cpu((r)->name_val[0]), (r)->name_source[0], (r)->name_flags[0],	\
-	le64_to_cpu((r)->name_val[1]), (r)->name_source[1], (r)->name_flags[1],	\
-	le64_to_cpu((r)->name_val[2]), (r)->name_source[2], (r)->name_flags[2],	\
-	(r)->op, le64_to_cpu((r)->limit), (r)->rule_flags
-
-static void print_quota(struct scoutfs_key *key, void *val, int val_len)
-{
-	struct scoutfs_quota_rule_val *rv = val;
-
-	printf("    quota rule: hash 0x%016llx coll_nr %llu\n"
-	       "      "SQR_FMT"\n",
-	       le64_to_cpu(key->skqr_hash), le64_to_cpu(key->skqr_coll_nr), SQR_ARGS(rv));
-}
-
 static void print_xattr_totl(struct scoutfs_key *key, void *val, int val_len)
 {
 	struct scoutfs_xattr_totl_val *tval = val;
@@ -108,17 +89,6 @@ static void print_xattr_totl(struct scoutfs_key *key, void *val, int val_len)
 	       le64_to_cpu(tval->count));
 }
 
-static void print_xattr_indx(struct scoutfs_key *key, void *val, int val_len)
-{
-	u64 minor;
-	u64 ino;
-	u64 xid;
-	u8 major;
-
-	scoutfs_xattr_get_indx_key(key, &major, &minor, &ino, &xid);
-	printf("    xattr indx: major %u minor %llu ino %llu xid %llu", major, minor, ino, xid);
-}
-
 static u8 *global_printable_name(u8 *name, int name_len)
 {
 	static u8 name_buf[SCOUTFS_NAME_LEN + 1];
@@ -207,15 +177,9 @@ static print_func_t find_printer(u8 zone, u8 type)
 			return print_orphan;
 	}
 
-	if (zone == SCOUTFS_QUOTA_ZONE)
-		return print_quota;
-
 	if (zone == SCOUTFS_XATTR_TOTL_ZONE)
 		return print_xattr_totl;
 
-	if (zone == SCOUTFS_XATTR_INDX_ZONE)
-		return print_xattr_indx;
-
 	if (zone == SCOUTFS_FS_ZONE) {
 		switch(type) {
 			case SCOUTFS_INODE_TYPE: return print_inode;

utils/src/quota.c

@@ -1,547 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <argp.h>
-
-#include "sparse.h"
-#include "parse.h"
-#include "util.h"
-#include "format.h"
-#include "ioctl.h"
-#include "cmd.h"
-#include "util.h"
-#include "key.h"
-
-static char opc[] = {
-	[SQ_OP_DATA] = 'D',
-	[SQ_OP_INODE] = 'I',
-};
-
-static char nsc[] = {
-	[SQ_NS_LITERAL] = 'L',
-	[SQ_NS_PROJ] = 'P',
-	[SQ_NS_UID] = 'U',
-	[SQ_NS_GID] = 'G',
-};
-
-static void printf_rule(struct scoutfs_ioctl_quota_rule *irule)
-{
-	int i;
-
-	/* priority: [0-9]+ */
-	printf("%3u ", irule->prio);
-
-	/* totl name: ([0-9]+,[LPUG-]+,[S-]+){3} */
-	for (i = 0; i < array_size(irule->name_val); i++) {
-
-		printf("%llu,%c,%c ",
-		       irule->name_val[i],
-		       nsc[irule->name_source[i]],
-		       (irule->name_flags[i] & SQ_NF_SELECT) ? 'S' : '-');
-	}
-
-	/* op: [ID], limit: [0-9]+, flags [C-] */
-	printf("%c %llu %c\n",
-	       opc[irule->op], irule->limit, (irule->rule_flags & SQ_RF_TOTL_COUNT) ? 'C' : '-');
-}
-
-static int parse_rule(struct scoutfs_ioctl_quota_rule *irule, char *str)
-{
-	char ns[3];
-	char nf[3];
-	char rf;
-	char op;
-	int ret;
-	int i;
-	int j;
-
-	memset(irule, 0, sizeof(struct scoutfs_ioctl_quota_rule));
-
-	ret = sscanf(str, " %hhu %llu,%c,%c %llu,%c,%c %llu,%c,%c %c %llu %c",
-		     &irule->prio, &irule->name_val[0], &ns[0], &nf[0], &irule->name_val[1],
-		     &ns[1], &nf[1], &irule->name_val[2], &ns[2], &nf[2], &op, &irule->limit,
-		     &rf);
-	if (ret != 13) {
-		printf("invalid rule, missing fields: %s\n", str);
-		ret = -EINVAL;
-		goto out;
-	}
-
-	for (i = 0; i < array_size(irule->name_val); i++) {
-		irule->name_source[i] = SQ_NS__NR;
-
-		for (j = 0; j < array_size(nsc); j++) {
-			if (ns[i] == nsc[j]) {
-				irule->name_source[i] = j;
-				break;
-			}
-		}
-
-		if (irule->name_source[i] == SQ_NS__NR) {
-			printf("invalid name source '%c' in name #%u in rule:\n\t%s\n",
-			       ns[i], i + 1, str);
-			ret = -EINVAL;
-			goto out;
-		}
-
-		irule->name_flags[i] = nf[i] == '-' ? 0 :
-				       nf[i] == 'S' ? SQ_NF_SELECT :
-				       SQ_NF__UNKNOWN;
-		if (irule->name_flags[i] == SQ_NF__UNKNOWN) {
-			printf("invalid name flags '%c' in name #%u in rule:\n\t%s\n",
-			       nf[i], i + 1, str);
-			ret = -EINVAL;
-			goto out;
-		}
-	}
-
-	irule->op = SQ_NS__NR;
-	for (i = 0; i < array_size(opc); i++) {
-		if (op == opc[i]) {
-			irule->op = i;
-			break;
-		}
-	}
-
-	if (irule->op == SQ_NS__NR) {
-		printf("invalid op '%c' in rule:\n\t%s\n", op, str);
-		ret = -EINVAL;
-		goto out;
-	}
-
-	irule->rule_flags = rf == '-' ? 0 : rf == 'C' ? SQ_RF_TOTL_COUNT : SQ_RF__UNKNOWN;
-	if (irule->rule_flags == SQ_RF__UNKNOWN) {
-		printf("invalid rule flags '%c' in rule:\n\t%s\n", rf, str);
-		ret = -EINVAL;
-		goto out;
-	}
-
-	ret = 0;
-out:
-	return ret;
-}
-
-/* ---------------------------------------------- */
-
-struct mod_args {
-	char *path;
-	char *rule_str;
-	bool is_add;
-};
-
-static int do_mod(struct mod_args *args)
-{
-	struct scoutfs_ioctl_quota_rule irule;
-	unsigned int cmd;
-	int fd = -1;
-	int ret;
-
-	memset(&irule, 0, sizeof(irule));
-
-	ret = parse_rule(&irule, args->rule_str);
-	if (ret < 0)
-		goto out;
-
-	fd = get_path(args->path, O_RDONLY);
-	if (fd < 0)
-		return fd;
-
-	cmd = args->is_add ? SCOUTFS_IOC_ADD_QUOTA_RULE : SCOUTFS_IOC_DEL_QUOTA_RULE;
-	ret = ioctl(fd, cmd, &irule);
-	if (ret < 0) {
-		ret = -errno;
-		fprintf(stderr, "MOD_QUOTA_RULE ioctl failed: %s (%d)\n",
-			strerror(errno), errno);
-		goto out;
-	}
-
-	ret = 0;
-out:
-	if (fd >= 0)
-		close(fd);
-
-	return ret;
-}
-
-static int parse_mod_opt(int key, char *arg, struct argp_state *state)
-{
-	struct mod_args *args = state->input;
-
-	switch (key) {
-	case 'p':
-		args->path = strdup_or_error(state, arg);
-		break;
-	case 'r':
-		args->rule_str = strdup_or_error(state, arg);
-		break;
-	case ARGP_KEY_FINI:
-		if (!args->path)
-			argp_error(state, "must provide file path");
-		if (!args->rule_str)
-			argp_error(state, "must provide rule string");
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-static struct argp_option add_options[] = {
-	{ "path", 'p', "PATH", 0, "Path to ScoutFS filesystem"},
-	{ "rule", 'r', "RULE_STRING", 0, "Rule string"},
-	{ NULL }
-};
-
-static struct argp add_argp = {
-	add_options,
-	parse_mod_opt,
-	"",
-	"Add quota rule"
-};
-
-static int add_cmd(int argc, char **argv)
-{
-	struct mod_args args = { .is_add = true, };
-	int ret;
-
-	ret = argp_parse(&add_argp, argc, argv, 0, NULL, &args);
-	if (ret)
-		return ret;
-
-	return do_mod(&args);
-}
-
-static void __attribute__((constructor)) add_ctor(void)
-{
-	cmd_register_argp("quota-add", &add_argp, GROUP_CORE, add_cmd);
-}
-
-static struct argp_option del_options[] = {
-	{ "path", 'p', "PATH", 0, "Path to ScoutFS filesystem"},
-	{ "rule", 'r', "RULE_STRING", 0, "Rule string"},
-	{ NULL }
-};
-
-static struct argp del_argp = {
-	del_options,
-	parse_mod_opt,
-	"",
-	"Delete quota rule"
-};
-
-static int del_cmd(int argc, char **argv)
-{
-	struct mod_args args = { .is_add = false };
-	int ret;
-
-	ret = argp_parse(&del_argp, argc, argv, 0, NULL, &args);
-	if (ret)
-		return ret;
-
-	return do_mod(&args);
-}
-
-static void __attribute__((constructor)) del_ctor(void)
-{
-	cmd_register_argp("quota-del", &del_argp, GROUP_CORE, del_cmd);
-}
-
-/* ---------------------------------------------- */
-
-struct bulk_args {
-	char *path;
-	bool unsorted;
-};
-
-typedef int (*bulk_in_fn)(int fd, struct scoutfs_ioctl_quota_rule *irules, size_t nr,
-		          void *in_args);
-typedef int (*bulk_out_fn)(int fd, struct scoutfs_ioctl_quota_rule *irule, void *out_args);
-
-static int cmp_irules(const struct scoutfs_ioctl_quota_rule *a,
-		      const struct scoutfs_ioctl_quota_rule *b)
-{
-	return scoutfs_cmp(a->prio, b->prio) ?:
-	       scoutfs_cmp(a->name_val[0], b->name_val[0]) ?:
-	       scoutfs_cmp(a->name_source[0], b->name_source[0]) ?:
-	       scoutfs_cmp(a->name_flags[0], b->name_flags[0]) ?:
-	       scoutfs_cmp(a->name_val[1], b->name_val[1]) ?:
-	       scoutfs_cmp(a->name_source[1], b->name_source[1]) ?:
-	       scoutfs_cmp(a->name_flags[1], b->name_flags[1]) ?:
-	       scoutfs_cmp(a->name_val[2], b->name_val[2]) ?:
-	       scoutfs_cmp(a->name_source[2], b->name_source[2]) ?:
-	       scoutfs_cmp(a->name_flags[2], b->name_flags[2]) ?:
-	       scoutfs_cmp(a->op, b->op) ?:
-	       scoutfs_cmp(a->limit, b->limit) ?:
-	       scoutfs_cmp(a->rule_flags, b->rule_flags);
-}
-
-static int compar_irules(const void *a, const void *b)
-{
-	return -cmp_irules(a, b);
-}
-
-static int do_bulk(struct bulk_args *args, bulk_in_fn in_fn, void *in_args,
-		   bulk_out_fn out_fn, void *out_args)
-{
-	struct scoutfs_ioctl_quota_rule *irules = NULL;
-	size_t alloced = 0;
-	size_t nr = 0;
-	size_t batch;
-	size_t i;
-	int fd = -1;
-	int ret;
-
-	fd = get_path(args->path, O_RDONLY);
-	if (fd < 0)
-		return fd;
-
-	for (;;) {
-		if (nr == alloced) {
-			alloced += 1024;
-			irules = realloc(irules, alloced * sizeof(irules[0]));
-			if (!irules) {
-				ret = -errno;
-				fprintf(stderr, "memory allocation failed: %s (%d)\n",
-					strerror(errno), errno);
-				goto out;
-			}
-		}
-
-		ret = in_fn(fd, &irules[nr], alloced - nr, in_args);
-		if (ret == 0)
-			break;
-		if (ret < 0)
-			goto out;
-
-		batch = ret;
-
-		if (args->unsorted) {
-			for (i = 0; i < batch; i++) {
-				ret = out_fn(fd, &irules[nr + i], out_args);
-				if (ret < 0)
-					goto out;
-			}
-		} else {
-			nr += batch;
-		}
-	}
-
-	if (!args->unsorted) {
-		qsort(irules, nr, sizeof(irules[0]), compar_irules);
-
-		for (i = 0; i < nr; i++) {
-			ret = out_fn(fd, &irules[i], out_args);
-			if (ret < 0)
-				goto out;
-		}
-	}
-
-	ret = 0;
-out:
-	if (fd >= 0)
-		close(fd);
-	if (irules)
-		free(irules);
-
-	return ret;
-}
-
-/* ---------------------------------------------- */
-
-/* maintain iterator in gqr between calls */
-static int get_ioctl_in_fn(int fd, struct scoutfs_ioctl_quota_rule *irules, size_t nr,
-			   void *in_args)
-{
-	struct scoutfs_ioctl_get_quota_rules *gqr = in_args;
-	int ret;
-
-	gqr->rules_ptr = (intptr_t)irules;
-	gqr->rules_nr = nr;
-
-	ret = ioctl(fd, SCOUTFS_IOC_GET_QUOTA_RULES, gqr);
-	if (ret < 0) {
-		ret = -errno;
-		fprintf(stderr, "GET_QUOTA_RULES ioctl failed: %s (%d)\n",
-			strerror(errno), errno);
-	}
-
-	return ret;
-}
-
-static int parse_stdin_in_fn(int fd, struct scoutfs_ioctl_quota_rule *irules, size_t nr,
-			     void *in_args)
-{
-	char *line = NULL;
-	size_t size;
-	int ret;
-
-	ret = getline(&line, &size, stdin);
-	if (ret < 0) {
-		if (errno == ENOENT)
-			return 0;
-
-		ret = -errno;
-		fprintf(stderr, "error reading rules: %s (%d)\n",
-			strerror(errno), errno);
-		return ret;
-	}
-
-	ret = parse_rule(&irules[0], line);
-	if (ret == 0)
-		ret = 1;
-
-	free(line);
-
-	return ret;
-}
-
-struct mod_ioctl_args {
-	unsigned int cmd;
-	char *which;
-};
-
-static int mod_ioctl_out_fn(int fd, struct scoutfs_ioctl_quota_rule *irule, void *out_args)
-{
-	struct mod_ioctl_args *args = out_args;
-	int ret;
-
-	ret = ioctl(fd, args->cmd, irule);
-	if (ret < 0) {
-		ret = -errno;
-		printf("Failed to %s following rule:\n    ", args->which);
-		printf_rule(irule);
-		fprintf(stderr, "Error: %s (%d)\n", strerror(-ret), -ret);
-	}
-
-	return ret;
-}
-
-static int print_out_fn(int fd, struct scoutfs_ioctl_quota_rule *irule, void *out_args)
-{
-	printf_rule(irule);
-	return 0;
-}
-
-/* ---------------------------------------------- */
-
-static int parse_bulk_opt(int key, char *arg, struct argp_state *state)
-{
-	struct bulk_args *args = state->input;
-
-	switch (key) {
-	case 'p':
-		args->path = strdup_or_error(state, arg);
-		break;
-	case 'U':
-		args->unsorted = true;
-		break;
-	case ARGP_KEY_FINI:
-		if (!args->path)
-			argp_error(state, "must provide file path");
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-static struct argp_option bulk_options[] = {
-	{ "path", 'p', "PATH", 0, "Path to ScoutFS filesystem"},
-	{ "unsorted", 'U', NULL, 0, "Process rules in unsorted filesystem storage order"},
-	{ NULL }
-};
-
-static struct argp list_argp = {
-	bulk_options,
-	parse_bulk_opt,
-	"",
-	"List quota rules"
-};
-
-static int list_cmd(int argc, char **argv)
-{
-	struct scoutfs_ioctl_get_quota_rules gqr = {{0,}};
-	struct bulk_args args = {NULL};
-	int ret;
-
-	ret = argp_parse(&list_argp, argc, argv, 0, NULL, &args);
-	if (ret)
-		return ret;
-
-	return do_bulk(&args, get_ioctl_in_fn, &gqr, print_out_fn, NULL);
-}
-
-static void __attribute__((constructor)) list_ctor(void)
-{
-	cmd_register_argp("quota-list", &list_argp, GROUP_CORE, list_cmd);
-}
-
-/* ---------------------------------------------- */
-
-static struct argp wipe_argp = {
-	bulk_options,
-	parse_bulk_opt,
-	"",
-	"Delete all quota rules"
-};
-
-static int wipe_cmd(int argc, char **argv)
-{
-	struct bulk_args args = {NULL};
-	struct scoutfs_ioctl_get_quota_rules gqr = {{0,}};
-	struct mod_ioctl_args out_args = {
-		.cmd = SCOUTFS_IOC_DEL_QUOTA_RULE,
-		.which = "delete",
-	};
-	int ret;
-
-	ret = argp_parse(&wipe_argp, argc, argv, 0, NULL, &args);
-	if (ret)
-		return ret;
-
-	return do_bulk(&args, get_ioctl_in_fn, &gqr, mod_ioctl_out_fn, &out_args);
-}
-
-static void __attribute__((constructor)) wipe_ctor(void)
-{
-	cmd_register_argp("quota-wipe", &wipe_argp, GROUP_CORE, wipe_cmd);
-}
-
-/* ---------------------------------------------- */
-
-static struct argp restore_argp = {
-	bulk_options,
-	parse_bulk_opt,
-	"",
-	"Restore quota rules from list output on stdin"
-};
-
-static int restore_cmd(int argc, char **argv)
-{
-	struct bulk_args args = {NULL};
-	struct mod_ioctl_args out_args = {
-		.cmd = SCOUTFS_IOC_ADD_QUOTA_RULE,
-		.which = "add",
-	};
-	int ret;
-
-	ret = argp_parse(&restore_argp, argc, argv, 0, NULL, &args);
-	if (ret)
-		return ret;
-
-	return do_bulk(&args, parse_stdin_in_fn, NULL, mod_ioctl_out_fn, &out_args);
-}
-
-static void __attribute__((constructor)) restore_ctor(void)
-{
-	cmd_register_argp("quota-restore", &restore_argp, GROUP_CORE, restore_cmd);
-}

utils/src/read_xattr_index.c

@@ -1,186 +0,0 @@
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <argp.h>
-
-#include "sparse.h"
-#include "parse.h"
-#include "util.h"
-#include "format.h"
-#include "ioctl.h"
-#include "cmd.h"
-#include "cmp.h"
-
-#define ENTF	"%u.%llu.%llu"
-#define ENTA(e)	(e)->major, (e)->minor, (e)->ino
-
-struct xattr_args {
-	char *path;
-	char *first_entry;
-	char *last_entry;
-};
-
-static int compare_entries(struct scoutfs_ioctl_xattr_index_entry *a,
-			   struct scoutfs_ioctl_xattr_index_entry *b)
-{
-	return scoutfs_cmp(a->major, b->major) ?: scoutfs_cmp(a->minor, b->minor) ?:
-	       scoutfs_cmp(a->ino, b->ino);
-}
-
-static int parse_entry(struct scoutfs_ioctl_xattr_index_entry *ent, char *str)
-{
-	int major;
-	int ret;
-
-	ret = sscanf(str, "%i.%lli.%lli", &major, &ent->minor, &ent->ino);
-	if (ret != 3) {
-		fprintf(stderr, "bad index position entry argument '%s', it must be "
-				"in the form \"a.b.ino\" where each value can be prefixed by "
-				"'0' for octal or '0x' for hex\n", str);
-		return -EINVAL;
-	}
-
-	if (major < 0 || major > UCHAR_MAX) {
-		fprintf(stderr, "initial major index position '%d' must be between 0 and 255, "
-				"inclusive.\n", major);
-		return -EINVAL;
-	}
-
-	ent->major = major;
-
-	return 0;
-}
-
-#define NR_ENTRIES 1024
-
-static int do_read_xattr_index(struct xattr_args *args)
-{
-	struct scoutfs_ioctl_read_xattr_index rxi;
-	struct scoutfs_ioctl_xattr_index_entry *ents;
-	struct scoutfs_ioctl_xattr_index_entry *ent;
-	int fd = -1;
-	int ret;
-	int i;
-
-	ents = calloc(NR_ENTRIES, sizeof(struct scoutfs_ioctl_xattr_index_entry));
-	if (!ents) {
-		fprintf(stderr, "xattr index entry allocation failed\n");
-		ret = -ENOMEM;
-		goto out;
-	}
-
-	fd = get_path(args->path, O_RDONLY);
-	if (fd < 0)
-		return fd;
-
-	memset(&rxi, 0, sizeof(rxi));
-	memset(&rxi.last, 0xff, sizeof(rxi.last));
-	rxi.entries_ptr = (unsigned long)ents;
-	rxi.entries_nr = NR_ENTRIES;
-
-	ret = 0;
-	if (args->first_entry)
-		ret = parse_entry(&rxi.first, args->first_entry);
-	if (args->last_entry)
-		ret = parse_entry(&rxi.last, args->last_entry);
-	if (ret < 0)
-		goto out;
-
-	if (compare_entries(&rxi.first, &rxi.last) > 0) {
-		fprintf(stderr, "first index position "ENTF" must be less than last index position "ENTF"\n",
-			       ENTA(&rxi.first), ENTA(&rxi.last));
-		ret = -EINVAL;
-		goto out;
-	}
-
-	for (;;) {
-		ret = ioctl(fd, SCOUTFS_IOC_READ_XATTR_INDEX, &rxi);
-		if (ret == 0)
-			break;
-		if (ret < 0) {
-			ret = -errno;
-			fprintf(stderr, "read_xattr_index ioctl failed: "
-				"%s (%d)\n", strerror(errno), errno);
-			goto out;
-		}
-
-		for (i = 0; i < ret; i++) {
-			ent = &ents[i];
-			printf("%u.%llu = %llu\n",
-				ent->major, ent->minor, ent->ino);
-		}
-
-		rxi.first = *ent;
-
-		if ((++rxi.first.ino == 0 && ++rxi.first.minor == 0 && ++rxi.first.major == 0) ||
-		    compare_entries(&rxi.first, &rxi.last) > 0)
-			break;
-	}
-
-	ret = 0;
-out:
-	if (fd >= 0)
-		close(fd);
-	free(ents);
-
-	return ret;
-};
-
-static int parse_opt(int key, char *arg, struct argp_state *state)
-{
-	struct xattr_args *args = state->input;
-
-	switch (key) {
-	case 'p':
-		args->path = strdup_or_error(state, arg);
-		break;
-	case ARGP_KEY_ARG:
-		if (!args->first_entry)
-			args->first_entry = strdup_or_error(state, arg);
-		else if (!args->last_entry)
-			args->last_entry = strdup_or_error(state, arg);
-		else
-			argp_error(state, "more than two entry arguments given");
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-static struct argp_option options[] = {
-	{ "path", 'p', "PATH", 0, "Path to ScoutFS filesystem"},
-	{ NULL }
-};
-
-static struct argp argp = {
-	options,
-	parse_opt,
-	"FIRST-ENTRY LAST-ENTRY",
-	"Search and print inode numbers indexed by their .indx. xattrs"
-};
-
-static int read_xattr_index_cmd(int argc, char **argv)
-{
-
-	struct xattr_args xattr_args = {NULL};
-	int ret;
-
-	ret = argp_parse(&argp, argc, argv, 0, NULL, &xattr_args);
-	if (ret)
-		return ret;
-
-	return do_read_xattr_index(&xattr_args);
-}
-
-static void __attribute__((constructor)) read_xattr_index_ctor(void)
-{
-	cmd_register_argp("read-xattr-index", &argp, GROUP_INFO, read_xattr_index_cmd);
-}