Drop a non-zero totl key if it has no contributing xattrs.

The expected case is when the last xattr with a totl key is removed that
the count and value both reach zero. In case of a mismatch or corrupted
value, we have several different failure modes:

- count zero, value non-zero
- value zero, count non-zero
- both non-zero

The first case is the easiest to resolve, which is what this patch does
- it drops it and prints an error.

The other cases are more difficult and need a manual method to erase the
stale key, and one would have to scan the entire namespace to make sure
that the xattrs are indeed all removed.

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

kmod/src/btree.c

@@ -2183,8 +2183,6 @@ static int merge_read_item(struct super_block *sb, struct scoutfs_key *key, u64
 		if (ret > 0) {
 			if (ret == SCOUTFS_DELTA_COMBINED) {
 				scoutfs_inc_counter(sb, btree_merge_delta_combined);
-				if (seq > found->seq)
-					found->seq = seq;
 			} else if (ret == SCOUTFS_DELTA_COMBINED_NULL) {
 				scoutfs_inc_counter(sb, btree_merge_delta_null);
 				free_mitem(rng, found);
@@ -2488,14 +2486,6 @@ int scoutfs_btree_merge(struct super_block *sb,
 			mitem = next_mitem(mitem);
 			free_mitem(&rng, tmp);
 		}
-
-		if (mitem && walk_val_len == 0 &&
-		    !(walk_flags & (BTW_INSERT | BTW_DELETE)) &&
-		    scoutfs_trigger(sb, LOG_MERGE_FORCE_PARTIAL)) {
-			ret = -ERANGE;
-			*next_ret = mitem->key;
-			goto out;
-		}
 	}
 
 	ret = 0;

kmod/src/data.c

@@ -384,12 +384,6 @@ static inline u64 ext_last(struct scoutfs_extent *ext)
  * This can waste a lot of space for small or sparse files but is
  * reasonable when a file population is known to be large and dense but
  * known to be written with non-streaming write patterns.
- *
- * In either strategy, preallocation ramps up proportionally with the
- * file's online block count rather than jumping to the full prealloc
- * size.  This avoids overallocation for small files in mixed-size
- * workloads while still allowing large files to benefit from full
- * preallocation.
  */
 static int alloc_block(struct super_block *sb, struct inode *inode,
 		       struct scoutfs_extent *ext, u64 iblock,
@@ -406,7 +400,6 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 	struct scoutfs_extent found;
 	struct scoutfs_extent pre = {0,};
 	bool undo_pre = false;
-	bool have_onoff = false;
 	u64 blkno = 0;
 	u64 online;
 	u64 offline;
@@ -452,7 +445,6 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 		 * blocks.
 		 */
 		scoutfs_inode_get_onoff(inode, &online, &offline);
-		have_onoff = true;
 		if (iblock > 1 && iblock == online) {
 			ret = scoutfs_ext_next(sb, &data_ext_ops, &args,
 					       iblock, 1, &found);
@@ -499,16 +491,6 @@ static int alloc_block(struct super_block *sb, struct inode *inode,
 	/* overall prealloc limit */
 	count = min_t(u64, count, opts.data_prealloc_blocks);
 
-	/*
-	 * Ramp preallocation up proportionally with the file's online
-	 * block count rather than jumping to the full prealloc size.
-	 */
-	if (!ext->len) {
-		if (!have_onoff)
-			scoutfs_inode_get_onoff(inode, &online, &offline);
-		count = max_t(u64, 1, min(count, online));
-	}
-
 	ret = scoutfs_alloc_data(sb, datinf->alloc, datinf->wri,
 				 &datinf->dalloc, count, &blkno, &count);
 	if (ret < 0)

kmod/src/forest.c

@@ -239,9 +239,9 @@ static int forest_read_items(struct super_block *sb, struct scoutfs_key *key, u6
  * 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,
-				    u64 merge_input_seq, 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_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,
@@ -317,17 +317,15 @@ int scoutfs_forest_read_items_roots(struct super_block *sb, struct scoutfs_net_r
 
 		scoutfs_inc_counter(sb, forest_bloom_pass);
 
-		if ((le64_to_cpu(lt.flags) & SCOUTFS_LOG_TREES_FINALIZED) &&
-		    (merge_input_seq == 0 ||
-		     le64_to_cpu(lt.finalize_seq) < merge_input_seq))
-			rid.fic |= FIC_MERGE_INPUT;
+		if ((le64_to_cpu(lt.flags) & SCOUTFS_LOG_TREES_FINALIZED))
+			rid.fic |= FIC_FINALIZED;
 
 		ret = scoutfs_btree_read_items(sb, &lt.item_root, key, start,
 					       end, forest_read_items, &rid);
 		if (ret < 0)
 			goto out;
 
-		rid.fic &= ~FIC_MERGE_INPUT;
+		rid.fic &= ~FIC_FINALIZED;
 	}
 
 	ret = 0;
@@ -347,7 +345,7 @@ int scoutfs_forest_read_items(struct super_block *sb,
 
 	ret = scoutfs_client_get_roots(sb, &roots);
 	if (ret == 0)
-		ret = scoutfs_forest_read_items_roots(sb, &roots, 0, key, bloom_key, start, end,
+		ret = scoutfs_forest_read_items_roots(sb, &roots, key, bloom_key, start, end,
 						      cb, arg);
 	return ret;
 }

kmod/src/forest.h

@@ -11,7 +11,7 @@ struct scoutfs_lock;
 /* caller gives an item to the callback */
 enum {
 	FIC_FS_ROOT = (1 << 0),
-	FIC_MERGE_INPUT = (1 << 1),
+	FIC_FINALIZED = (1 << 1),
 };
 typedef int (*scoutfs_forest_item_cb)(struct super_block *sb, struct scoutfs_key *key, u64 seq,
 				      u8 flags, void *val, int val_len, int fic, void *arg);
@@ -25,9 +25,9 @@ int scoutfs_forest_read_items(struct super_block *sb,
 			      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,
-				    u64 merge_input_seq, 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_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/quota.c

@@ -34,7 +34,6 @@
 #include "totl.h"
 #include "util.h"
 #include "quota.h"
-#include "trans.h"
 #include "counters.h"
 #include "scoutfs_trace.h"
 
@@ -1087,10 +1086,6 @@ int scoutfs_quota_mod_rule(struct super_block *sb, bool is_add,
 	if (ret < 0)
 		goto out;
 
-	ret = scoutfs_hold_trans(sb, true);
-	if (ret < 0)
-		goto out;
-
 	down_write(&qtinf->rwsem);
 
 	if (is_add) {
@@ -1100,30 +1095,28 @@ int scoutfs_quota_mod_rule(struct super_block *sb, bool is_add,
 		else if (ret == 0)
 			ret = -EEXIST;
 		if (ret < 0)
-			goto release;
+			goto unlock;
 
 		rule_to_rule_val(&rv, &rule);
 		ret = scoutfs_item_create(sb, &key, &rv, sizeof(rv), lock);
 		if (ret < 0)
-			goto release;
+			goto unlock;
 
 	} else {
 		ret = find_rule(sb, &rule, &key, lock) ?:
 		      scoutfs_item_delete(sb, &key, lock);
 		if (ret < 0)
-			goto release;
+			goto unlock;
 	}
 
 	scoutfs_quota_invalidate(sb);
 	ret = 0;
 
-release:
+unlock:
 	up_write(&qtinf->rwsem);
-	scoutfs_release_trans(sb);
-
-out:
 	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
 
+out:
 	if (is_add)
 		trace_scoutfs_quota_add_rule(sb, &rule, ret);
 	else

kmod/src/totl.c

@@ -30,11 +30,6 @@ void scoutfs_totl_merge_init(struct scoutfs_totl_merging *merg)
 	memset(merg, 0, sizeof(struct scoutfs_totl_merging));
 }
 
-/*
- * bin the incoming merge inputs so that we can resolve delta items
- * properly. Finalized logs that are merge inputs are kept separately
- * from those that are not.
- */
 void scoutfs_totl_merge_contribute(struct scoutfs_totl_merging *merg,
 				   u64 seq, u8 flags, void *val, int val_len, int fic)
 {
@@ -44,10 +39,10 @@ void scoutfs_totl_merge_contribute(struct scoutfs_totl_merging *merg,
 		merg->fs_seq = seq;
 		merg->fs_total = le64_to_cpu(tval->total);
 		merg->fs_count = le64_to_cpu(tval->count);
-	} else if (fic & FIC_MERGE_INPUT) {
-		merg->inp_seq = seq;
-		merg->inp_total += le64_to_cpu(tval->total);
-		merg->inp_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);
@@ -58,18 +53,15 @@ void scoutfs_totl_merge_contribute(struct scoutfs_totl_merging *merg,
 /*
  * .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 merge input deltas should be applied
- * to the old fs items and where they have already been applied to the
- * partially merged fs items.
- *
- * Only finalized log trees that are inputs to the current merge cycle
- * are tracked in the inp_ bucket.  Finalized trees that aren't merge
- * inputs and active log trees are always applied unconditionally since
- * they cannot be in fs_root.
+ * 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 and the count of contributing xattrs.  This lets us
- * recognize all cases, including when merge inputs were merged and
+ * 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)
@@ -83,14 +75,14 @@ void scoutfs_totl_merge_resolve(struct scoutfs_totl_merging *merg, __u64 *total,
 		*count = merg->fs_count;
 	}
 
-	/* apply merge input deltas if they're newer or creating */
-	if (((merg->fs_seq != 0) && (merg->inp_seq > merg->fs_seq)) ||
-	    ((merg->fs_seq == 0) && (merg->inp_count > 0))) {
-		*total += merg->inp_total;
-		*count += merg->inp_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 non-input finalized and active logs */
+	/* 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

@@ -7,9 +7,9 @@ struct scoutfs_totl_merging {
 	u64 fs_seq;
 	u64 fs_total;
 	u64 fs_count;
-	u64 inp_seq;
-	u64 inp_total;
-	s64 inp_count;
+	u64 fin_seq;
+	u64 fin_total;
+	s64 fin_count;
 	u64 log_seq;
 	u64 log_total;
 	s64 log_count;

kmod/src/triggers.c

@@ -46,7 +46,6 @@ static char *names[] = {
 	[SCOUTFS_TRIGGER_SRCH_MERGE_STOP_SAFE] = "srch_merge_stop_safe",
 	[SCOUTFS_TRIGGER_STATFS_LOCK_PURGE] = "statfs_lock_purge",
 	[SCOUTFS_TRIGGER_RECLAIM_SKIP_FINALIZE] = "reclaim_skip_finalize",
-	[SCOUTFS_TRIGGER_LOG_MERGE_FORCE_PARTIAL] = "log_merge_force_partial",
 };
 
 bool scoutfs_trigger_test_and_clear(struct super_block *sb, unsigned int t)

kmod/src/triggers.h

@@ -9,7 +9,6 @@ enum scoutfs_trigger {
 	SCOUTFS_TRIGGER_SRCH_MERGE_STOP_SAFE,
 	SCOUTFS_TRIGGER_STATFS_LOCK_PURGE,
 	SCOUTFS_TRIGGER_RECLAIM_SKIP_FINALIZE,
-	SCOUTFS_TRIGGER_LOG_MERGE_FORCE_PARTIAL,
 	SCOUTFS_TRIGGER_NR,
 };
 

kmod/src/wkic.c

@@ -30,6 +30,7 @@
 #include "counters.h"
 #include "scoutfs_trace.h"
 #include "wkic.h"
+#include "msg.h"
 
 /*
  * This weaker item cache differs from the core item cache in item.c:
@@ -95,7 +96,6 @@ struct wkic_info {
 	/* block reading slow path */
 	struct mutex roots_mutex;
 	struct scoutfs_net_roots roots;
-	u64 merge_input_seq;
 	u64 roots_read_seq;
 	ktime_t roots_expire;
 
@@ -747,6 +747,16 @@ static void fill_page_items(struct super_block *sb, struct wkic_page *wpage, str
 				rb_erase(&witem->node, root);
 				kfree(witem);
 				continue;
+			} else if (tval->count == 0) {
+				/*
+				 * BUG: there are no contributing items but count != 0,
+				 * which shouldn't happen - we've gone off kilt.
+				 */
+				scoutfs_err(sb, "non-zero value for zero count totl "SK_FMT", dropping item",
+					    SK_ARG(&witem->key));
+				rb_erase(&witem->node, root);
+				kfree(witem);
+				continue;
 			}
 		}
 
@@ -806,79 +816,29 @@ static void free_page_list(struct super_block *sb, struct list_head *list)
  * read_seq number so that we can compare the age of the items in cached
  * pages.  Only one request to refresh the roots is in progress at a
  * time.  This is the slow path that's only used when the cache isn't
- * populated and the roots aren't cached.
- *
- * We read roots directly from the on-disk superblock rather than
- * requesting them from the server so that we can also read the
- * log_merge btree from the same superblock.  The merge status item
- * seq tells us which finalized log trees are inputs to the current
- * merge, which is needed to correctly resolve totl delta items.
+ * populated and the roots aren't cached.  The root request is fast
+ * enough, especially compared to the resulting item reading IO, that we
+ * don't mind hiding it behind a trivial mutex.
  */
-static int refresh_roots(struct super_block *sb, struct wkic_info *winf)
-{
-	struct scoutfs_super_block *super;
-	struct scoutfs_log_merge_status *stat;
-	SCOUTFS_BTREE_ITEM_REF(iref);
-	struct scoutfs_key key;
-	int ret;
-
-	super = kmalloc(sizeof(*super), GFP_NOFS);
-	if (!super)
-		return -ENOMEM;
-
-	ret = scoutfs_read_super(sb, super);
-	if (ret < 0)
-		goto out;
-
-	winf->roots = (struct scoutfs_net_roots){
-		.fs_root = super->fs_root,
-		.logs_root = super->logs_root,
-		.srch_root = super->srch_root,
-	};
-
-	winf->merge_input_seq = 0;
-	if (super->log_merge.ref.blkno) {
-		scoutfs_key_set_zeros(&key);
-		key.sk_zone = SCOUTFS_LOG_MERGE_STATUS_ZONE;
-		ret = scoutfs_btree_lookup(sb, &super->log_merge, &key, &iref);
-		if (ret == 0) {
-			if (iref.val_len == sizeof(*stat)) {
-				stat = iref.val;
-				winf->merge_input_seq = le64_to_cpu(stat->seq);
-			} else {
-				ret = -EUCLEAN;
-			}
-			scoutfs_btree_put_iref(&iref);
-		} else if (ret == -ENOENT) {
-			ret = 0;
-		}
-		if (ret < 0)
-			goto out;
-	}
-
-	winf->roots_read_seq++;
-	winf->roots_expire = ktime_add_ms(ktime_get_raw(), WKIC_CACHE_LIFETIME_MS);
-out:
-	kfree(super);
-	return ret;
-}
-
 static int get_roots(struct super_block *sb, struct wkic_info *winf,
-		     struct scoutfs_net_roots *roots_ret, u64 *merge_input_seq,
-		     u64 *read_seq, bool force_new)
+		     struct scoutfs_net_roots *roots_ret, u64 *read_seq, bool force_new)
 {
+	struct scoutfs_net_roots roots;
 	int ret;
 
 	mutex_lock(&winf->roots_mutex);
 
 	if (force_new || ktime_before(winf->roots_expire, ktime_get_raw())) {
-		ret = refresh_roots(sb, winf);
+		ret = scoutfs_client_get_roots(sb, &roots);
 		if (ret < 0)
 			goto out;
+
+		winf->roots = roots;
+		winf->roots_read_seq++;
+		winf->roots_expire = ktime_add_ms(ktime_get_raw(), WKIC_CACHE_LIFETIME_MS);
 	}
 
 	*roots_ret = winf->roots;
-	*merge_input_seq = winf->merge_input_seq;
 	*read_seq = winf->roots_read_seq;
 	ret = 0;
 out:
@@ -921,30 +881,24 @@ static int insert_read_pages(struct super_block *sb, struct wkic_info *winf,
 	struct scoutfs_key end;
 	struct wkic_page *wpage;
 	LIST_HEAD(pages);
-	u64 merge_input_seq;
-	u64 read_seq = 0;
+	u64 read_seq;
 	int ret;
 
 	ret = 0;
 retry_stale:
-	ret = get_roots(sb, winf, &roots, &merge_input_seq, &read_seq, ret == -ESTALE);
+	ret = get_roots(sb, winf, &roots, &read_seq, ret == -ESTALE);
 	if (ret < 0)
-		goto check_stale;
+		goto out;
 
 	start = *range_start;
 	end = *range_end;
-	ret = scoutfs_forest_read_items_roots(sb, &roots, merge_input_seq, key, range_start,
-					      &start, &end, read_items_cb, &root);
+	ret = scoutfs_forest_read_items_roots(sb, &roots, key, range_start, &start, &end,
+					      read_items_cb, &root);
 	trace_scoutfs_wkic_read_items(sb, key, &start, &end);
-check_stale:
 	ret = scoutfs_block_check_stale(sb, ret, &saved, &roots.fs_root.ref, &roots.logs_root.ref);
 	if (ret < 0) {
-		if (ret == -ESTALE) {
-			/* not safe to retry due to delta items, must restart clean */
-			free_item_tree(&root);
-			root = RB_ROOT;
+		if (ret == -ESTALE)
 			goto retry_stale;
-		}
 		goto out;
 	}
 

kmod/src/xattr.c

@@ -1265,7 +1265,6 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 			ret = parse_indx_key(&tag_key, xat->name, xat->name_len, ino);
 			if (ret < 0)
 				goto out;
-			scoutfs_xattr_set_indx_key_xid(&tag_key, le64_to_cpu(key.skx_id));
 		}
 
 		if ((tgs.totl || tgs.indx) && locked_zone != tag_key.sk_zone) {

tests/funcs/filter.sh

@@ -20,6 +20,9 @@ t_filter_fs()
 # [ 2687.691366] BUG: KASAN: stack-out-of-bounds in get_reg+0x1bc/0x230
 # ...
 # [ 2687.706220] ==================================================================
+# [ 2687.707284] Disabling lock debugging due to kernel taint
+#
+# That final lock debugging message may not be included.
 #
 ignore_harmless_unwind_kasan_stack_oob()
 {
@@ -43,6 +46,10 @@ awk '
 		saved=""
         }
         ( in_soob == 2 && $0 ~ /==================================================================/ ) {
+                in_soob = 3
+                soob_nr = NR
+        }
+        ( in_soob == 3 && NR > soob_nr && $0 !~ /Disabling lock debugging/ ) {
                 in_soob = 0
         }
         ( !in_soob ) { print $0 }
@@ -54,58 +61,6 @@ awk '
 '
 }
 
-#
-# in el97+, XFS can generate a spurious lockdep circular dependency
-# warning about reclaim. Fixed upstream in e.g. v5.7-rc4-129-g6dcde60efd94
-#
-ignore_harmless_xfs_lockdep_warning()
-{
-awk '
-	BEGIN {
-		in_block = 0
-		block_nr = 0
-		buf = ""
-	}
-	( !in_block && $0 ~ /======================================================/ ) {
-		in_block = 1
-		block_nr = NR
-		buf = $0 "\n"
-		next
-	}
-	( in_block == 1 && NR == (block_nr + 1) ) {
-		if (match($0, /WARNING: possible circular locking dependency detected/) != 0) {
-			in_block = 2
-			buf = buf $0 "\n"
-		} else {
-			in_block = 0
-			printf "%s", buf
-			print $0
-			buf = ""
-		}
-		next
-	}
-	( in_block == 2 ) {
-		buf = buf $0 "\n"
-		if ($0 ~ /<\/TASK>/) {
-			if (buf ~ /xfs_(nondir_|dir_)?ilock_class/ && buf ~ /fs_reclaim/) {
-				# known xfs lockdep false positive, discard
-			} else {
-				printf "%s", buf
-			}
-			in_block = 0
-			buf = ""
-		}
-		next
-	}
-	{ print $0 }
-	END {
-		if (buf) {
-			printf "%s", buf
-		}
-	}
-'
-}
-
 #
 # Filter out expected messages.  Putting messages here implies that
 # tests aren't relying on messages to discover failures.. they're
@@ -221,10 +176,6 @@ t_filter_dmesg()
 	# creating block devices may trigger this
 	re="$re|block device autoloading is deprecated and will be removed."
 
-	# lockdep or kasan warnings can cause this
-	re="$re|Disabling lock debugging due to kernel taint"
-
 	egrep -v "($re)" | \
-		ignore_harmless_unwind_kasan_stack_oob | \
-		ignore_harmless_xfs_lockdep_warning
+		ignore_harmless_unwind_kasan_stack_oob
 }

tests/golden/basic-xattr-indx

@@ -1,54 +0,0 @@
-== testing invalid read-xattr-index arguments
-bad index position entry argument 'bad', it must be in the form "a.b.ino" where each value can be prefixed by '0' for octal or '0x' for hex
-scoutfs: read-xattr-index failed: Invalid argument (22)
-bad index position entry argument '1.2', it must be in the form "a.b.ino" where each value can be prefixed by '0' for octal or '0x' for hex
-scoutfs: read-xattr-index failed: Invalid argument (22)
-initial major index position '256' must be between 0 and 255, inclusive.
-scoutfs: read-xattr-index failed: Invalid argument (22)
-first index position 1.2.3 must be less than last index position 0.0.0
-scoutfs: read-xattr-index failed: Invalid argument (22)
-first index position 1.2.0 must be less than last index position 1.1.2
-scoutfs: read-xattr-index failed: Invalid argument (22)
-first index position 2.2.2 must be less than last index position 2.2.1
-scoutfs: read-xattr-index failed: Invalid argument (22)
-== testing invalid names
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/invalid: Numerical result out of range
-== testing boundary values
-0.0 found
-255.max found
-== indx xattr must have no value
-setfattr: /mnt/test/test/basic-xattr-indx/noval: Invalid argument
-setfattr: /mnt/test/test/basic-xattr-indx/noval: Invalid argument
-== set indx xattr and verify index entry
-found
-== setting same indx xattr again is a no-op
-found
-== removing non-existent indx xattr succeeds
-setfattr: /mnt/test/test/basic-xattr-indx/file: No such attribute
-still found
-== explicit xattr removal cleans up index entry
-== file deletion cleans up index entry
-found before delete
-== multiple indx xattrs on one file cleaned up by deletion
-entries before delete: 2
-entries after delete: 0
-== partial removal leaves other entries
-300 found
-== multiple files at same index position
-files at same position: 2
-surviving file found
-== cross-mount visibility
-found on mount 1
-== duplicate position deduplication
-entries for same position: 1

tests/golden/data-prealloc

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

tests/golden/totl-merge-read

@@ -1,3 +0,0 @@
-== setup
-expected 4681
-== cleanup

tests/run-tests.sh

@@ -694,8 +694,8 @@ for t in $tests; do
 		if [ "$sts" == "$T_PASS_STATUS" ]; then
 			dmesg | t_filter_dmesg > "$T_TMPDIR/dmesg.after"
 			diff --old-line-format="" --unchanged-line-format="" \
-				"$T_TMPDIR/dmesg.before" "$T_TMPDIR/dmesg.after" | \
-				grep -v '^$' > "$T_TMPDIR/dmesg.new"
+				"$T_TMPDIR/dmesg.before" "$T_TMPDIR/dmesg.after" > \
+				"$T_TMPDIR/dmesg.new"
 
 			if [ -s "$T_TMPDIR/dmesg.new" ]; then
 				message="unexpected messages in dmesg"

tests/sequence

@@ -26,9 +26,7 @@ srch-basic-functionality.sh
 simple-xattr-unit.sh
 retention-basic.sh
 totl-xattr-tag.sh
-basic-xattr-indx.sh
 quota.sh
-totl-merge-read.sh
 lock-refleak.sh
 lock-shrink-consistency.sh
 lock-shrink-read-race.sh

tests/tests/basic-xattr-indx.sh

@@ -1,143 +0,0 @@
-#
-# Test basic .indx. xattr tag functionality and index entry lifecycle
-#
-
-t_require_commands touch rm setfattr scoutfs stat
-t_require_mounts 2
-
-# query index from a specific mount, default mount 0
-read_xattr_index()
-{
-	local nr="${1:-0}"
-	local mnt="$(eval echo \$T_M$nr)"
-	shift
-
-	sync
-	echo 1 > $(t_debugfs_path $nr)/drop_weak_item_cache
-	scoutfs read-xattr-index -p "$mnt" "$@"
-}
-
-MAJOR=5
-MINOR=100
-
-echo "== testing invalid read-xattr-index arguments"
-scoutfs read-xattr-index -p "$T_M0" bad 2>&1
-scoutfs read-xattr-index -p "$T_M0" 1.2 2>&1
-scoutfs read-xattr-index -p "$T_M0" 1.2.3 256.0.0 2>&1
-scoutfs read-xattr-index -p "$T_M0" 1.2.3 0.0.0 2>&1
-scoutfs read-xattr-index -p "$T_M0" 1.2.0 1.1.2 2>&1
-scoutfs read-xattr-index -p "$T_M0" 2.2.2 2.2.1 2>&1
-
-echo "== testing invalid names"
-touch "$T_D0/invalid"
-setfattr -n scoutfs.hide.indx.test.$MAJOR "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.. "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test..$MINOR "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.$MAJOR. "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.256.$MINOR "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.abc.$MINOR "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.$MAJOR.abc "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.-1.$MINOR "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.$MAJOR.-1 "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.18446744073709551616.$MINOR "$T_D0/invalid" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.$(printf 'x%.0s' $(seq 1 240)).$MAJOR.$MINOR "$T_D0/invalid" 2>&1 | t_filter_fs
-rm -f "$T_D0/invalid"
-
-echo "== testing boundary values"
-touch "$T_D0/boundary"
-INO=$(stat -c "%i" "$T_D0/boundary")
-setfattr -n scoutfs.hide.indx.test.0.0 "$T_D0/boundary"
-read_xattr_index 0 0.0.0 0.0.-1 | awk '($3 == "'$INO'") {print "0.0 found"}'
-setfattr -x scoutfs.hide.indx.test.0.0 "$T_D0/boundary"
-setfattr -n scoutfs.hide.indx.test.255.18446744073709551615 "$T_D0/boundary"
-read_xattr_index 0 255.0.0 255.-1.-1 | awk '($3 == "'$INO'") {print "255.max found"}'
-setfattr -x scoutfs.hide.indx.test.255.18446744073709551615 "$T_D0/boundary"
-rm -f "$T_D0/boundary"
-
-echo "== indx xattr must have no value"
-touch "$T_D0/noval"
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR -v "" "$T_D0/noval" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR -v 0 "$T_D0/noval" 2>&1 | t_filter_fs
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR -v 1 "$T_D0/noval" 2>&1 | t_filter_fs
-rm -f "$T_D0/noval"
-
-echo "== set indx xattr and verify index entry"
-touch "$T_D0/file"
-INO=$(stat -c "%i" "$T_D0/file")
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR "$T_D0/file"
-read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "found"}'
-
-echo "== setting same indx xattr again is a no-op"
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR "$T_D0/file"
-read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "found"}'
-
-echo "== removing non-existent indx xattr succeeds"
-setfattr -x scoutfs.hide.indx.nonexistent.$MAJOR.999 "$T_D0/file" 2>&1 | t_filter_fs
-read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "still found"}'
-
-echo "== explicit xattr removal cleans up index entry"
-setfattr -x scoutfs.hide.indx.test.$MAJOR.$MINOR "$T_D0/file"
-read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "found orphan"}'
-rm -f "$T_D0/file"
-
-echo "== file deletion cleans up index entry"
-touch "$T_D0/file2"
-INO=$(stat -c "%i" "$T_D0/file2")
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR "$T_D0/file2"
-read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "found before delete"}'
-rm -f "$T_D0/file2"
-read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "found orphan after delete"}'
-
-echo "== multiple indx xattrs on one file cleaned up by deletion"
-touch "$T_D0/file3"
-INO=$(stat -c "%i" "$T_D0/file3")
-setfattr -n scoutfs.hide.indx.a.$MAJOR.200 "$T_D0/file3"
-setfattr -n scoutfs.hide.indx.b.$MAJOR.300 "$T_D0/file3"
-BEFORE=$(read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'")' | wc -l)
-echo "entries before delete: $BEFORE"
-rm -f "$T_D0/file3"
-AFTER=$(read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'")' | wc -l)
-echo "entries after delete: $AFTER"
-
-echo "== partial removal leaves other entries"
-touch "$T_D0/partial"
-INO=$(stat -c "%i" "$T_D0/partial")
-setfattr -n scoutfs.hide.indx.a.$MAJOR.200 "$T_D0/partial"
-setfattr -n scoutfs.hide.indx.b.$MAJOR.300 "$T_D0/partial"
-setfattr -x scoutfs.hide.indx.a.$MAJOR.200 "$T_D0/partial"
-read_xattr_index 0 $MAJOR.200.0 $MAJOR.200.-1 | awk '($3 == "'$INO'") {print "200 found"}'
-read_xattr_index 0 $MAJOR.300.0 $MAJOR.300.-1 | awk '($3 == "'$INO'") {print "300 found"}'
-rm -f "$T_D0/partial"
-
-echo "== multiple files at same index position"
-touch "$T_D0/multi_a" "$T_D0/multi_b"
-INO_A=$(stat -c "%i" "$T_D0/multi_a")
-INO_B=$(stat -c "%i" "$T_D0/multi_b")
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR "$T_D0/multi_a"
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR "$T_D0/multi_b"
-COUNT=$(read_xattr_index 0 $MAJOR.$MINOR.0 $MAJOR.$MINOR.-1 | wc -l)
-echo "files at same position: $COUNT"
-rm -f "$T_D0/multi_a"
-read_xattr_index 0 $MAJOR.$MINOR.0 $MAJOR.$MINOR.-1 | awk '($3 == "'$INO_A'") {print "deleted file still found"}'
-read_xattr_index 0 $MAJOR.$MINOR.0 $MAJOR.$MINOR.-1 | awk '($3 == "'$INO_B'") {print "surviving file found"}'
-rm -f "$T_D0/multi_b"
-
-echo "== cross-mount visibility"
-touch "$T_D0/file4"
-INO=$(stat -c "%i" "$T_D0/file4")
-setfattr -n scoutfs.hide.indx.test.$MAJOR.$MINOR "$T_D0/file4"
-read_xattr_index 1 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "found on mount 1"}'
-rm -f "$T_D0/file4"
-read_xattr_index 1 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'") {print "found orphan on mount 1"}'
-
-echo "== duplicate position deduplication"
-touch "$T_D0/file5"
-INO=$(stat -c "%i" "$T_D0/file5")
-setfattr -n scoutfs.hide.indx.aa.$MAJOR.$MINOR "$T_D0/file5"
-setfattr -n scoutfs.hide.indx.bb.$MAJOR.$MINOR "$T_D0/file5"
-COUNT=$(read_xattr_index 0 $MAJOR.0.0 $MAJOR.-1.-1 | awk '($3 == "'$INO'")' | wc -l)
-echo "entries for same position: $COUNT"
-rm -f "$T_D0/file5"
-
-t_pass

tests/tests/totl-merge-read.sh

@@ -1,50 +0,0 @@
-#
-# Test that merge_read_item() correctly updates the sequence number when
-# combining delta items from multiple finalized log trees.  Each mount
-# sets a totl value in its own 3-bit lane (powers of 8) so that any
-# double-counting overflows the lane and is caught by: or(v, exp) != exp.
-#
-
-t_require_commands setfattr scoutfs
-t_require_mounts 5
-
-echo "== setup"
-for nr in $(t_fs_nrs); do
-	d=$(eval echo \$T_D$nr)
-	for i in $(seq 1 2500); do : > "$d/f$nr$i"; done
-done
-sync
-t_force_log_merge
-
-vals=(1 8 64 512 4096)
-expected=4681
-n=0
-for nr in $(t_fs_nrs); do
-	d=$(eval echo \$T_D$nr)
-	v=${vals[$((n++))]}
-	for i in $(seq 1 2500); do
-		setfattr -n "scoutfs.totl.t.$i.0.0" -v $v "$d/f$nr$i"
-	done
-done
-
-t_trigger_arm_silent log_merge_force_partial $(t_server_nr)
-
-bad="$T_TMPDIR/bad"
-for nr in $(t_fs_nrs); do
-	( while true; do
-		echo 1 > "$(t_debugfs_path $nr)/drop_weak_item_cache"
-		scoutfs read-xattr-totals -p "$(eval echo \$T_M$nr)" | \
-			awk -F'[ =,]+' -v e=$expected 'or($2+0,e) != e'
-	done ) >> "$bad" &
-done
-
-echo "expected $expected"
-t_force_log_merge
-t_silent_kill $(jobs -p)
-test -s "$bad" && echo "double-counted:" && cat "$bad"
-
-echo "== cleanup"
-for nr in $(t_fs_nrs); do
-	find "$(eval echo \$T_D$nr)" -name "f$nr*" -delete
-done
-t_pass