Show last holder PID, inode in client_locks

Add last_user_pid[mode] and last_user_ino[mode] arrays to scoutfs_lock,
filled in at the granted-mode path alongside the existing counts.
The inode is passed by callers for all per-inode cases, and set to 0
for others. PID is from the current task.

The client_locks line is expanded with "ino: rd I wr I wo I pid: rd P
wr P wo P".  Existing users:/waiters: field positions are unchanged.

A simple test case demonstrates the functionality for the two simple
inode/non-inode case, and for a contended lock case (multiple rd/wr
lock holders).

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

ReleaseNotes.md

@@ -1,6 +1,21 @@
 Versity ScoutFS Release Notes
 =============================
 
+---
+v1.31
+\
+*May 5, 2026*
+
+Fix race between modifying quota rules and internal reading of the rules
+that tripped an assertion.
+
+Fix a bug that could skip merging totl items under specific heavy write
+loads.  This could lead to merged totl items incorrectly tracking the
+sum of all the contributing totl xattrs.
+
+Fix many small low risk bugs in error paths that were found with code
+analysis and testing.
+
 ---
 v1.30
 \

kmod/src/Makefile

@@ -60,11 +60,11 @@ scoutfs-y +=			\
 #
 .PHONY: $(src)/check_exported_types
 $(src)/check_exported_types:
-	@if grep -E '\<[us](8|16|32|64\>)' $(src)/format.h $(src)/ioctl.h; then \
+	@if egrep '\<[us](8|16|32|64\>)' $(src)/format.h $(src)/ioctl.h; then \
 		echo "no raw types in exported headers, preface with __";     \
 		exit 1;							      \
 	fi
-	@if grep -E '\<__packed\>' $(src)/format.h $(src)/ioctl.h; then \
+	@if egrep '\<__packed\>' $(src)/format.h $(src)/ioctl.h; then \
 		echo "no __packed allowed in exported headers";     \
 		exit 1;							      \
 	fi

kmod/src/Makefile.kernelcompat

@@ -496,131 +496,3 @@ endif
 ifneq (,$(shell grep 'struct posix_acl.*get_inode_acl' include/linux/fs.h))
 ccflags-y += -DKC_GET_INODE_ACL
 endif
-
-#
-# v6.1-rc5-2-ge9a688bcb193
-#
-# get_random_u32_below() implementation
-ifneq (,$(shell grep 'u32 get_random_u32_below' include/linux/random.h))
-ccflags-y += -DKC_HAVE_GET_RANDOM_U32_BELOW
-endif
-
-# v6.5-rc1-7-g9b6304c1d537
-#
-# ctime accessor methods
-ifneq (,$(shell grep 'timespec64 inode_set_ctime_current' include/linux/fs.h))
-ccflags-y += -DKC_FS_INODE_C_TIME_ACCESSOR
-endif
-
-#
-# v6.6-rc5-1-g077c212f0344
-#
-# Must use access methods from fs.h to get to inode ctime/mtime/atime
-ifneq (,$(shell grep 'inline time64_t inode_get_atime_sec' include/linux/fs.h))
-ccflags-y += -DKC_FS_INODE_AM_TIME_ACCESSOR
-endif
-
-#
-# v6.12-rc1-3-g5f60d5f6bbc1
-#
-# asm/unaligned.h replaced with linux/unaligned.h
-ifneq (,$(shell grep -s 'define __LINUX_UNALIGNED_H' include/linux/unaligned.h))
-ccflags-y += -DKC_HAVE__LINUX_UNALIGNED_H
-endif
-
-#
-# v6.9-rc4-29-g203c1ce0bb06
-#
-# RIP bd_inode. (note, struct moved between headers!)
-ifneq (,$(shell grep -s 'struct inode.*bd_inode' include/linux/blk_types.h include/linux/fs.h))
-ccflags-y += -DKC_HAVE_BD_INODE
-endif
-
-#
-# v6.8-9146-gc759e609030c
-#
-# Removes __assign_str_len() and removes the 2nd param of __assign_str().
-ifneq (,$(shell grep -s 'define __assign_str.dst, src' \
-				include/trace/trace_events.h \
-				include/trace/ftrace.h \
-				include/trace/stages/stage6_event_callback.h))
-ccflags-y += -DKC_HAVE_ASSIGN_STR_PARMS
-endif
-
-#
-# v6.5-113-g615e95831ec3
-#
-ifneq (,$(shell grep 'generic_fillattr..*,.u32,' include/linux/fs.h))
-ccflags-y += -DKC_GENERIC_FILLATTR_REQUEST_MASK
-endif
-
-#
-# v6.6-rc4-53-gc42d50aefd17
-#
-# el10 yet again modifies the shrinker API significantly, breaking our current
-# implementation.
-ifneq (,$(shell grep 'struct shrinker .shrinker_alloc' include/linux/shrinker.h))
-ccflags-y += -DKC_SHRINKER_ALLOC
-endif
-
-#
-# v6.9-rc4-8-gead083aeeed9
-#
-# set_blocksize() now has a struct file arg.
-ifneq (,$(shell grep -s 'int set_blocksize.struct file' include/linux/blkdev.h))
-ccflags-y += -DKC_BLKDEV_SET_BLOCKSIZE_FILE
-endif
-
-#
-# v5.1-rc3-29-gaa30f47cf666
-#
-# struct kobj_type now has member `default_groups`
-ifneq (,$(shell grep 'const struct attribute_group ..default_groups;' include/linux/kobject.h))
-ccflags-y += -DKC_KOBJECT_DEFAULT_GROUPS
-endif
-
-#
-# v5.19-rc3-395-g67235182a41c
-#
-# Adds buffer_migrate_folio(), similar to other fss. Quote willy: "If the filesystem
-# implements migrate_folio and writepages, there is no need for a writepage implementation."
-ifneq (,$(shell grep 'int buffer_migrate_folio.struct address_space' include/linux/buffer_head.h))
-ccflags-y += -DKC_HAVE_BUFFER_MIGRATE_FOLIO
-endif
-
-#
-# v6.7-rc4-307-g17bf23a981be
-#
-# block_write_full_page() is replaced with block_write_full_folio(),
-# but that isn't exported as it used to be (and the only users now
-# are builtin). However, the kernel will fall back to using the
-# .writepages method instead, so we can drop this method.
-ifneq (,$(shell grep 'int block_write_full_page.struct page' include/linux/buffer_head.h))
-ccflags-y += -DKC_HAVE_BLOCK_WRITE_FULL_PAGE
-endif
-
-#
-# v6.4-rc2-29-gc6585011bc1d
-#
-# generic_file_splice_read is removed. It can be replaced with filemap_splice_read
-# or copy_splice_read.
-ifneq (,$(shell grep 'ssize_t generic_file_splice_read.struct file' include/linux/fs.h))
-ccflags-y += -DKC_HAVE_GENERIC_FILE_SPLICE_READ
-endif
-
-#
-# v4.6-rc3-29-g6192269444eb
-#
-# Adds .iterate_shared readdir() iterator vfs method.
-ifneq (,$(shell grep 'iterate_shared...struct file.., struct dir_context' include/linux/fs.h))
-ccflags-y += -DKC_HAVE_ITERATE_SHARED
-endif
-
-#
-# v6.11-rc1-54-g9f04609f74ec
-#
-# Last of a series of changes that make block_write_begin/end take a folio instead of
-# a struct pagep.
-ifneq (,$(shell grep 'int __block_write_begin.struct.folio' include/linux/buffer_head.h))
-ccflags-y += -DKC_BLOCK_WRITE_BEGIN_FOLIO
-endif

kmod/src/acl.c

@@ -197,7 +197,7 @@ int scoutfs_set_acl_locked(struct inode *inode, struct posix_acl *acl, int type,
 		if (!value) {
 			/* can be setting an acl that only affects mode, didn't need xattr */
 			inode_inc_iversion(inode);
-			inode_set_ctime_current(inode);
+			inode->i_ctime = current_time(inode);
 		}
 	}
 

kmod/src/alloc.c

@@ -308,14 +308,14 @@ static bool invalid_extent(u64 start, u64 end, u64 first, u64 last)
 static bool invalid_meta_blkno(struct super_block *sb, u64 blkno)
 {
 	struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb);
-	u64 last_meta = (i_size_read(KC_BDEV_INODE(sbi->meta_bdev)) >> SCOUTFS_BLOCK_LG_SHIFT) - 1;
+	u64 last_meta = (i_size_read(sbi->meta_bdev->bd_inode) >> SCOUTFS_BLOCK_LG_SHIFT) - 1;
 
 	return invalid_extent(blkno, blkno, SCOUTFS_META_DEV_START_BLKNO, last_meta);
 }
 
 static bool invalid_data_extent(struct super_block *sb, u64 start, u64 len)
 {
-	u64 last_data = (i_size_read(KC_BDEV_INODE(sb->s_bdev)) >> SCOUTFS_BLOCK_SM_SHIFT) - 1;
+	u64 last_data = (i_size_read(sb->s_bdev->bd_inode) >> SCOUTFS_BLOCK_SM_SHIFT) - 1;
 
 	return invalid_extent(start, start + len - 1, SCOUTFS_DATA_DEV_START_BLKNO, last_data);
 }

kmod/src/attr_x.c

@@ -103,8 +103,8 @@ int scoutfs_get_attr_x(struct inode *inode, struct scoutfs_ioctl_inode_attr_x *i
 		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_get_ctime_sec(inode));
-	size = fill_attr(size, iax, SCOUTFS_IOC_IAX_CTIME, ctime_nsec, inode_get_ctime_nsec(inode));
+	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));
@@ -223,8 +223,10 @@ int scoutfs_set_attr_x(struct inode *inode, struct scoutfs_ioctl_inode_attr_x *i
 		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_set_ctime(inode, iax->ctime_sec, iax->ctime_nsec);
+	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;

kmod/src/block.c

@@ -218,6 +218,7 @@ static void block_free_work(struct work_struct *work)
 
 	llist_for_each_entry_safe(bp, tmp, deleted, free_node) {
 		block_free(sb, bp);
+		cond_resched();
 	}
 }
 
@@ -467,9 +468,6 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp,
 	sector_t sector;
 	int ret = 0;
 
-	if (scoutfs_forcing_unmount(sb))
-		return -ENOLINK;
-
 	sector = bp->bl.blkno << (SCOUTFS_BLOCK_LG_SHIFT - 9);
 
 	WARN_ON_ONCE(bp->bl.blkno == U64_MAX);
@@ -480,6 +478,17 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp,
 	set_bit(BLOCK_BIT_IO_BUSY, &bp->bits);
 	block_get(bp);
 
+	/*
+	 * A second thread may already be waiting on this block's completion
+	 * after this thread won the race to submit the block.  We exit through
+	 * the block_end_io error path which sets BLOCK_BIT_ERROR and assures
+	 * that other callers in the waitq get woken up.
+	 */
+	if (scoutfs_forcing_unmount(sb)) {
+		ret = -ENOLINK;
+		goto end_io;
+	}
+
 	blk_start_plug(&plug);
 
 	for (off = 0; off < SCOUTFS_BLOCK_LG_SIZE; off += PAGE_SIZE) {
@@ -517,6 +526,7 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp,
 
 	blk_finish_plug(&plug);
 
+end_io:
 	/* let racing end_io know we're done */
 	block_end_io(sb, opf, bp, ret);
 
@@ -884,7 +894,7 @@ int scoutfs_block_dirty_ref(struct super_block *sb, struct scoutfs_alloc *alloc,
 	hdr->magic = cpu_to_le32(magic);
 	hdr->fsid = cpu_to_le64(sbi->fsid);
 	hdr->blkno = cpu_to_le64(bl->blkno);
-	get_random_bytes(&hdr->seq, sizeof(hdr->seq));
+	prandom_bytes(&hdr->seq, sizeof(hdr->seq));
 
 	trace_scoutfs_block_dirty_ref(sb, le64_to_cpu(ref->blkno), le64_to_cpu(ref->seq),
 				      le64_to_cpu(hdr->blkno), le64_to_cpu(hdr->seq));
@@ -1229,12 +1239,7 @@ static int sm_block_io(struct super_block *sb, struct block_device *bdev, blk_op
 	kc_bio_set_sector(bio, blkno << (SCOUTFS_BLOCK_SM_SHIFT - 9));
 	bio->bi_end_io = sm_block_bio_end_io;
 	bio->bi_private = &sbc;
-	ret = bio_add_page(bio, page, SCOUTFS_BLOCK_SM_SIZE, 0);
-	if (ret != SCOUTFS_BLOCK_SM_SIZE) {
-		bio_put(bio);
-		ret = -EFAULT;
-		goto out;
-	}
+	bio_add_page(bio, page, SCOUTFS_BLOCK_SM_SIZE, 0);
 
 	init_completion(&sbc.comp);
 	sbc.err = 0;
@@ -1290,12 +1295,9 @@ int scoutfs_block_setup(struct super_block *sb)
 
 	binf->sb = sb;
 	init_waitqueue_head(&binf->waitq);
-	KC_SETUP_SHRINKER(binf->shrinker, binf, 0, block_count_objects,
-			  block_scan_objects, "scoutfs-block:" SCSBF, SCSB_ARGS(sb));
-	if (KC_SHRINKER_IS_NULL(binf->shrinker)) {
-		ret = -ENOMEM;
-		goto out;
-	}
+	KC_INIT_SHRINKER_FUNCS(&binf->shrinker, block_count_objects,
+			       block_scan_objects);
+	KC_REGISTER_SHRINKER(&binf->shrinker, "scoutfs-block:" SCSBF, SCSB_ARGS(sb));
 	INIT_WORK(&binf->free_work, block_free_work);
 	init_llist_head(&binf->free_llist);
 
@@ -1317,7 +1319,7 @@ void scoutfs_block_destroy(struct super_block *sb)
 	struct block_info *binf = SCOUTFS_SB(sb)->block_info;
 
 	if (binf) {
-		KC_UNREGISTER_SHRINKER(binf->shrinker);
+		KC_UNREGISTER_SHRINKER(&binf->shrinker);
 		block_shrink_all(sb);
 		flush_work(&binf->free_work);
 		rhashtable_destroy(&binf->ht);

kmod/src/btree.c

@@ -2042,7 +2042,7 @@ struct merged_item {
 	u64 seq;
 	u8 flags;
 	unsigned int val_len;
-	u8 val[];
+	u8 val[0];
 };
 
 static inline struct merged_item *mitem_container(struct rb_node *node)
@@ -2210,7 +2210,7 @@ static int merge_read_item(struct super_block *sb, struct scoutfs_key *key, u64
 	mitem->flags = flags;
 	mitem->val_len = val_len;
 	if (val_len)
-		memcpy(&mitem->val[0], val, val_len);
+		memcpy(mitem->val, val, val_len);
 
 	if (found) {
 		replace_mitem(rng, found, mitem);

kmod/src/btree.h

@@ -30,7 +30,7 @@ struct scoutfs_btree_item_list {
 	u64 seq;
 	u8 flags;
 	int val_len;
-	u8 val[];
+	u8 val[0];
 };
 
 int scoutfs_btree_lookup(struct super_block *sb,

kmod/src/counters.c

@@ -34,17 +34,6 @@ static struct attribute scoutfs_counter_attrs[] = {
 #define NR_ATTRS ARRAY_SIZE(scoutfs_counter_attrs)
 static struct attribute *scoutfs_counter_attr_ptrs[NR_ATTRS + 1];
 
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-static struct attribute_group scoutfs_counter_attr_group = {
-	.attrs = scoutfs_counter_attr_ptrs,
-};
-
-static const struct attribute_group *scoutfs_counter_attr_groups[] = {
-	&scoutfs_counter_attr_group,
-	NULL,
-};
-#endif
-
 static ssize_t scoutfs_counter_attr_show(struct kobject *kobj,
 				         struct attribute *attr, char *buf)
 {
@@ -56,6 +45,7 @@ static ssize_t scoutfs_counter_attr_show(struct kobject *kobj,
 	counters = container_of(kobj, struct scoutfs_counters, kobj);
 	index = attr - scoutfs_counter_attrs;
 	pcpu = &counters->FIRST_COUNTER + index;
+
 	return snprintf(buf, PAGE_SIZE, "%lld\n", percpu_counter_sum(pcpu));
 }
 
@@ -73,7 +63,7 @@ static const struct sysfs_ops scoutfs_counter_attr_ops = {
 };
 
 static struct kobj_type scoutfs_counters_ktype = {
-	.KC_KOBJ_DEFAULT_OP = KC_KOBJ_DEFAULT_PICK(scoutfs_counter_attr_groups, scoutfs_counter_attr_ptrs),
+	.default_attrs  = scoutfs_counter_attr_ptrs,
 	.sysfs_ops      = &scoutfs_counter_attr_ops,
 	.release        = scoutfs_counters_kobj_release,
 };

kmod/src/data.c

@@ -718,24 +718,24 @@ static int scoutfs_readpage(struct file *file, struct page *page)
 		return ret;
 	}
 
-	scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, inode_lock);
-
-	ret = scoutfs_data_wait_check(inode, page_offset(page),
-				      PAGE_SIZE, SEF_OFFLINE,
-				      SCOUTFS_IOC_DWO_READ, &dw,
-				      inode_lock);
-	if (ret != 0) {
-		unlock_page(page);
-		scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
-		scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
+	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, inode_lock)) {
+		ret = scoutfs_data_wait_check(inode, page_offset(page),
+					      PAGE_SIZE, SEF_OFFLINE,
+					      SCOUTFS_IOC_DWO_READ, &dw,
+					      inode_lock);
+		if (ret != 0) {
+			unlock_page(page);
+			scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
+			scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
+		}
+		if (ret > 0) {
+			ret = scoutfs_data_wait(inode, &dw);
+			if (ret == 0)
+				ret = AOP_TRUNCATED_PAGE;
+		}
+		if (ret != 0)
+			return ret;
 	}
-	if (ret > 0) {
-		ret = scoutfs_data_wait(inode, &dw);
-		if (ret == 0)
-			ret = AOP_TRUNCATED_PAGE;
-	}
-	if (ret != 0)
-		return ret;
 
 #ifdef KC_MPAGE_READ_FOLIO
 	ret = mpage_read_folio(folio, scoutfs_get_block_read);
@@ -743,8 +743,8 @@ static int scoutfs_readpage(struct file *file, struct page *page)
 	ret = mpage_readpage(page, scoutfs_get_block_read);
 #endif
 
-	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
 	scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
+	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
 
 	return ret;
 }
@@ -762,10 +762,8 @@ static int scoutfs_readpages(struct file *file, struct address_space *mapping,
 			     struct list_head *pages, unsigned nr_pages)
 {
 	struct inode *inode = file->f_inode;
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_lock *inode_lock = NULL;
-	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	struct page *page;
 	struct page *tmp;
 	int ret;
@@ -775,8 +773,6 @@ static int scoutfs_readpages(struct file *file, struct address_space *mapping,
 	if (ret)
 		goto out;
 
-	scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, inode_lock);
-
 	list_for_each_entry_safe(page, tmp, pages, lru) {
 		ret = scoutfs_data_wait_check(inode, page_offset(page),
 					      PAGE_SIZE, SEF_OFFLINE,
@@ -796,7 +792,6 @@ static int scoutfs_readpages(struct file *file, struct address_space *mapping,
 
 	ret = mpage_readpages(mapping, pages, nr_pages, scoutfs_get_block_read);
 out:
-	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
 	scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
 	BUG_ON(!list_empty(pages));
 	return ret;
@@ -805,10 +800,8 @@ out:
 static void scoutfs_readahead(struct readahead_control *rac)
 {
 	struct inode *inode = rac->file->f_inode;
-	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_lock *inode_lock = NULL;
-	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	int ret;
 
 	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ,
@@ -816,8 +809,6 @@ static void scoutfs_readahead(struct readahead_control *rac)
 	if (ret)
 		return;
 
-	scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, inode_lock);
-
 	ret = scoutfs_data_wait_check(inode, readahead_pos(rac),
 				      readahead_length(rac), SEF_OFFLINE,
 				      SCOUTFS_IOC_DWO_READ, NULL,
@@ -825,17 +816,14 @@ static void scoutfs_readahead(struct readahead_control *rac)
 	if (ret == 0)
 		mpage_readahead(rac, scoutfs_get_block_read);
 
-	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
 	scoutfs_unlock(sb, inode_lock, SCOUTFS_LOCK_READ);
 }
 #endif
 
-#ifdef KC_HAVE_BLOCK_WRITE_FULL_PAGE
 static int scoutfs_writepage(struct page *page, struct writeback_control *wbc)
 {
 	return block_write_full_page(page, scoutfs_get_block_write, wbc);
 }
-#endif
 
 static int scoutfs_writepages(struct address_space *mapping,
 			      struct writeback_control *wbc)
@@ -855,7 +843,7 @@ static int scoutfs_write_begin(struct file *file,
 #ifdef KC_BLOCK_WRITE_BEGIN_AOP_FLAGS
 			       unsigned flags,
 #endif
-			       KC_PAGE_OR_FOLIO(struct page **pagep, struct folio **folio), void **fsdata)
+			       struct page **pagep, void **fsdata)
 {
 	struct inode *inode = mapping->host;
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
@@ -900,7 +888,7 @@ retry:
 #ifdef KC_BLOCK_WRITE_BEGIN_AOP_FLAGS
 				flags,
 #endif
-				KC_PAGE_OR_FOLIO(pagep, folio), scoutfs_get_block_write);
+				pagep, scoutfs_get_block_write);
 	if (ret < 0) {
 		scoutfs_release_trans(sb);
 		scoutfs_inode_index_unlock(sb, &wbd->ind_locks);
@@ -933,8 +921,7 @@ static int writepages_sync_none(struct address_space *mapping, loff_t start,
 
 static int scoutfs_write_end(struct file *file, struct address_space *mapping,
 			     loff_t pos, unsigned len, unsigned copied,
-			     KC_PAGE_OR_FOLIO(struct page *pagep, struct folio *folio),
-			     void *fsdata)
+			     struct page *page, void *fsdata)
 {
 	struct inode *inode = mapping->host;
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
@@ -942,11 +929,10 @@ static int scoutfs_write_end(struct file *file, struct address_space *mapping,
 	struct write_begin_data *wbd = fsdata;
 	int ret;
 
-	trace_scoutfs_write_end(sb, scoutfs_ino(inode),
-				KC_PAGE_OR_FOLIO(pagep->index, folio_index(folio)),
-				(u64)pos, len, copied);
+	trace_scoutfs_write_end(sb, scoutfs_ino(inode), page->index, (u64)pos,
+				len, copied);
 
-	ret = generic_write_end(file, mapping, pos, len, copied, KC_PAGE_OR_FOLIO(pagep, folio), fsdata);
+	ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
 	if (ret > 0) {
 		if (!si->staging) {
 			scoutfs_inode_set_data_seq(inode);
@@ -1499,14 +1485,12 @@ int scoutfs_data_move_blocks(struct inode *from, u64 from_off,
 
 		cur_time = current_time(from);
 		if (!is_stage) {
-			inode_set_ctime_to_ts(to, cur_time);
-			inode_set_mtime_to_ts(to, cur_time);
+			to->i_ctime = to->i_mtime = cur_time;
 			inode_inc_iversion(to);
 			scoutfs_inode_inc_data_version(to);
 			scoutfs_inode_set_data_seq(to);
 		}
-		inode_set_ctime_to_ts(from, cur_time);
-		inode_set_mtime_to_ts(from, cur_time);
+		from->i_ctime = from->i_mtime = cur_time;
 		inode_inc_iversion(from);
 		scoutfs_inode_inc_data_version(from);
 		scoutfs_inode_set_data_seq(from);
@@ -2080,11 +2064,7 @@ static int scoutfs_data_page_mkwrite(struct vm_area_struct *vma,
 				     struct vm_fault *vmf)
 {
 #endif
-#ifdef KC_MPAGE_READ_FOLIO
-	struct folio *folio = page_folio(vmf->page);
-#else
 	struct page *page = vmf->page;
-#endif
 	struct file *file = vma->vm_file;
 	struct inode *inode = file_inode(file);
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
@@ -2152,50 +2132,27 @@ static int scoutfs_data_page_mkwrite(struct vm_area_struct *vma,
 
 	down_write(&si->extent_sem);
 
-#ifdef KC_MPAGE_READ_FOLIO
-	if (!folio_trylock(folio)) {
-#else
 	if (!trylock_page(page)) {
-#endif
 		ret = VM_FAULT_NOPAGE;
 		goto out_sem;
 	}
 	ret = VM_FAULT_LOCKED;
 
-#ifdef KC_MPAGE_READ_FOLIO
-	if ((folio->mapping != inode->i_mapping) ||
-	    (!folio_test_uptodate(folio)) ||
-	    (folio_pos(folio) > size)) {
-		folio_unlock(folio);
-#else
 	if ((page->mapping != inode->i_mapping) ||
 	    (!PageUptodate(page)) ||
-	    (page_offset(page) > size)) {
+	    (page_offset(page) > size))	 {
 		unlock_page(page);
-#endif
 		ret = VM_FAULT_NOPAGE;
 		goto out_sem;
 	}
 
-#ifdef KC_MPAGE_READ_FOLIO
-	if (folio_index(folio) == (size - 1) >> PAGE_SHIFT)
-#else
 	if (page->index == (size - 1) >> PAGE_SHIFT)
-#endif
 		len = ((size - 1) & ~PAGE_MASK) + 1;
 
-#ifdef KC_MPAGE_READ_FOLIO
-	err = __block_write_begin(KC_PAGE_OR_FOLIO(folio_page(folio, 0), folio), pos, PAGE_SIZE, scoutfs_get_block);
-#else
 	err = __block_write_begin(page, pos, PAGE_SIZE, scoutfs_get_block);
-#endif
 	if (err) {
 		ret = vmf_error(err);
-#ifdef KC_MPAGE_READ_FOLIO
-		folio_unlock(folio);
-#else
 		unlock_page(page);
-#endif
 		goto out_sem;
 	}
 	/* end scoutfs_write_begin */
@@ -2205,13 +2162,8 @@ static int scoutfs_data_page_mkwrite(struct vm_area_struct *vma,
 	 * progress, we are guaranteed that writeback during freezing will
 	 * see the dirty page and writeprotect it again.
 	 */
-#ifdef KC_MPAGE_READ_FOLIO
-	folio_mark_dirty(folio);
-	folio_wait_stable(folio);
-#else
 	set_page_dirty(page);
 	wait_for_stable_page(page);
-#endif
 
 	/* scoutfs_write_end */
 	scoutfs_inode_set_data_seq(inode);
@@ -2338,9 +2290,6 @@ const struct address_space_operations scoutfs_file_aops = {
 	.dirty_folio		= block_dirty_folio,
 	.invalidate_folio	= block_invalidate_folio,
 	.read_folio		= scoutfs_read_folio,
-#ifdef KC_HAVE_BUFFER_MIGRATE_FOLIO
-	.migrate_folio		= buffer_migrate_folio,
-#endif
 #else
 	.readpage		= scoutfs_readpage,
 #endif
@@ -2349,9 +2298,7 @@ const struct address_space_operations scoutfs_file_aops = {
 #else
 	.readahead		= scoutfs_readahead,
 #endif
-#ifdef KC_HAVE_BLOCK_WRITE_FULL_PAGE
 	.writepage		= scoutfs_writepage,
-#endif
 	.writepages		= scoutfs_writepages,
 	.write_begin		= scoutfs_write_begin,
 	.write_end		= scoutfs_write_end,
@@ -2366,12 +2313,8 @@ const struct file_operations scoutfs_file_fops = {
 #else
 	.read_iter	= scoutfs_file_read_iter,
 	.write_iter	= scoutfs_file_write_iter,
-	.splice_write	= iter_file_splice_write,
-#endif
-#ifdef KC_HAVE_GENERIC_FILE_SPLICE_READ
 	.splice_read	= generic_file_splice_read,
-#else
-	.splice_read	= copy_splice_read,
+	.splice_write	= iter_file_splice_write,
 #endif
 	.mmap		= scoutfs_file_mmap,
 	.unlocked_ioctl	= scoutfs_ioctl,

kmod/src/dir.c

@@ -761,7 +761,6 @@ static int scoutfs_mknod(KC_VFS_NS_DEF
 	struct scoutfs_lock *dir_lock = NULL;
 	struct scoutfs_lock *inode_lock = NULL;
 	struct scoutfs_inode_info *si;
-	struct kc_timespec cur_time;
 	LIST_HEAD(ind_locks);
 	u64 hash;
 	u64 pos;
@@ -793,13 +792,9 @@ static int scoutfs_mknod(KC_VFS_NS_DEF
 	set_dentry_fsdata(dentry, dir_lock);
 
 	i_size_write(dir, i_size_read(dir) + dentry->d_name.len);
-	cur_time = current_time(inode);
-	inode_set_mtime_to_ts(dir, cur_time);
-	inode_set_ctime_to_ts(dir, cur_time);
-	inode_set_mtime_to_ts(inode, cur_time);
-	inode_set_atime_to_ts(inode, cur_time);
-	inode_set_ctime_to_ts(inode, cur_time);
-	si->crtime = inode_get_mtime(inode);
+	dir->i_mtime = dir->i_ctime = current_time(inode);
+	inode->i_mtime = inode->i_atime = inode->i_ctime = dir->i_mtime;
+	si->crtime = inode->i_mtime;
 	inode_inc_iversion(dir);
 	inode_inc_iversion(inode);
 	scoutfs_forest_inc_inode_count(sb);
@@ -852,7 +847,6 @@ static int scoutfs_link(struct dentry *old_dentry,
 	struct scoutfs_lock *dir_lock;
 	struct scoutfs_lock *inode_lock = NULL;
 	struct scoutfs_lock *orph_lock = NULL;
-	struct kc_timespec cur_time;
 	LIST_HEAD(ind_locks);
 	bool del_orphan = false;
 	u64 dir_size;
@@ -927,10 +921,8 @@ retry:
 	set_dentry_fsdata(dentry, dir_lock);
 
 	i_size_write(dir, dir_size);
-	cur_time = current_time(inode);
-	inode_set_mtime_to_ts(dir, cur_time);
-	inode_set_ctime_to_ts(dir, cur_time);
-	inode_set_ctime_to_ts(inode, inode_get_mtime(dir));
+	dir->i_mtime = dir->i_ctime = current_time(inode);
+	inode->i_ctime = dir->i_mtime;
 	inc_nlink(inode);
 	inode_inc_iversion(dir);
 	inode_inc_iversion(inode);
@@ -1040,13 +1032,13 @@ retry:
 
 	set_dentry_fsdata(dentry, dir_lock);
 
-	inode_set_ctime_to_ts(dir, ts);
-	inode_set_mtime_to_ts(dir, ts);
+	dir->i_ctime = ts;
+	dir->i_mtime = ts;
 	i_size_write(dir, i_size_read(dir) - dentry->d_name.len);
 	inode_inc_iversion(dir);
 	inode_inc_iversion(inode);
 
-	inode_set_ctime_to_ts(inode, ts);
+	inode->i_ctime = ts;
 	drop_nlink(inode);
 	if (S_ISDIR(inode->i_mode)) {
 		drop_nlink(dir);
@@ -1249,7 +1241,6 @@ static int scoutfs_symlink(KC_VFS_NS_DEF
 	struct scoutfs_lock *dir_lock = NULL;
 	struct scoutfs_lock *inode_lock = NULL;
 	struct scoutfs_inode_info *si;
-	struct kc_timespec cur_time;
 	LIST_HEAD(ind_locks);
 	u64 hash;
 	u64 pos;
@@ -1289,13 +1280,11 @@ static int scoutfs_symlink(KC_VFS_NS_DEF
 	set_dentry_fsdata(dentry, dir_lock);
 
 	i_size_write(dir, i_size_read(dir) + dentry->d_name.len);
-	cur_time = current_time(inode);
-	inode_set_mtime_to_ts(dir, cur_time);
-	inode_set_ctime_to_ts(dir, cur_time);
+	dir->i_mtime = dir->i_ctime = current_time(inode);
 	inode_inc_iversion(dir);
 
-	inode_set_ctime_to_ts(inode, inode_get_mtime(dir));
-	si->crtime = inode_get_ctime(inode);
+	inode->i_ctime = dir->i_mtime;
+	si->crtime = inode->i_ctime;
 	i_size_write(inode, name_len);
 	inode_inc_iversion(inode);
 	scoutfs_forest_inc_inode_count(sb);
@@ -1817,15 +1806,15 @@ retry:
 	}
 
 	now = current_time(old_inode);
-	inode_set_ctime_to_ts(old_dir, now);
-	inode_set_mtime_to_ts(old_dir, now);
+	old_dir->i_ctime = now;
+	old_dir->i_mtime = now;
 	if (new_dir != old_dir) {
-		inode_set_ctime_to_ts(new_dir, now);
-		inode_set_mtime_to_ts(new_dir, now);
+		new_dir->i_ctime = now;
+		new_dir->i_mtime = now;
 	}
-	inode_set_ctime_to_ts(old_inode, now);
+	old_inode->i_ctime = now;
 	if (new_inode)
-		inode_set_ctime_to_ts(new_inode, now);
+		new_inode->i_ctime = now;
 
 	inode_inc_iversion(old_dir);
 	inode_inc_iversion(old_inode);
@@ -1952,7 +1941,6 @@ static int scoutfs_tmpfile(KC_VFS_NS_DEF
 	struct scoutfs_lock *inode_lock = NULL;
 	struct scoutfs_lock *orph_lock = NULL;
 	struct scoutfs_inode_info *si;
-	struct kc_timespec cur_time;
 	LIST_HEAD(ind_locks);
 	int ret;
 
@@ -1969,11 +1957,8 @@ static int scoutfs_tmpfile(KC_VFS_NS_DEF
 	if (ret < 0)
 		goto out; /* XXX returning error but items created */
 
-	cur_time = current_time(inode);
-	inode_set_mtime_to_ts(inode, cur_time);
-	inode_set_ctime_to_ts(inode, cur_time);
-	inode_set_atime_to_ts(inode, cur_time);
-	si->crtime = inode_get_mtime(inode);
+	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
+	si->crtime = inode->i_mtime;
 	insert_inode_hash(inode);
 	ihold(inode); /* need to update inode modifications in d_tmpfile */
 #ifdef KC_D_TMPFILE_DENTRY
@@ -2041,11 +2026,7 @@ const struct inode_operations scoutfs_symlink_iops = {
 };
 
 const struct file_operations scoutfs_dir_fops = {
-#ifdef KC_HAVE_ITERATE_SHARED
-	.iterate_shared	= scoutfs_readdir,
-#else
 	.iterate	= scoutfs_readdir,
-#endif
 #ifdef KC_FMODE_KABI_ITERATE
 	.open		= scoutfs_dir_open,
 #endif

kmod/src/fence.c

@@ -217,9 +217,6 @@ static struct attribute *fence_attrs[] = {
 	SCOUTFS_ATTR_PTR(rid),
 	NULL,
 };
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-ATTRIBUTE_GROUPS(fence);
-#endif
 
 #define FENCE_TIMEOUT_MS (MSEC_PER_SEC * 30)
 
@@ -258,8 +255,7 @@ int scoutfs_fence_start(struct super_block *sb, u64 rid, __be32 ipv4_addr, int r
 	fence->rid = rid;
 
 	ret = scoutfs_sysfs_create_attrs_parent(sb, &fi->kset->kobj,
-						&fence->ssa,
-						KC_KOBJ_DEFAULT(fence),
+						&fence->ssa, fence_attrs,
 						"%016llx", rid);
 	if (ret < 0) {
 		kfree(fence);

kmod/src/inode.c

@@ -275,9 +275,12 @@ static void load_inode(struct inode *inode, struct scoutfs_inode *cinode, int in
 	i_gid_write(inode, le32_to_cpu(cinode->gid));
 	inode->i_mode = le32_to_cpu(cinode->mode);
 	inode->i_rdev = le32_to_cpu(cinode->rdev);
-	inode_set_atime(inode, le64_to_cpu(cinode->atime.sec), le32_to_cpu(cinode->atime.nsec));
-	inode_set_mtime(inode, le64_to_cpu(cinode->mtime.sec), le32_to_cpu(cinode->mtime.nsec));
-	inode_set_ctime(inode, le64_to_cpu(cinode->ctime.sec), le32_to_cpu(cinode->ctime.nsec));
+	inode->i_atime.tv_sec = le64_to_cpu(cinode->atime.sec);
+	inode->i_atime.tv_nsec = le32_to_cpu(cinode->atime.nsec);
+	inode->i_mtime.tv_sec = le64_to_cpu(cinode->mtime.sec);
+	inode->i_mtime.tv_nsec = le32_to_cpu(cinode->mtime.nsec);
+	inode->i_ctime.tv_sec = le64_to_cpu(cinode->ctime.sec);
+	inode->i_ctime.tv_nsec = le32_to_cpu(cinode->ctime.nsec);
 
 	si->meta_seq = le64_to_cpu(cinode->meta_seq);
 	si->data_seq = le64_to_cpu(cinode->data_seq);
@@ -398,7 +401,6 @@ int scoutfs_getattr(KC_VFS_NS_DEF
 				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
 	if (ret == 0) {
 		generic_fillattr(KC_VFS_INIT_NS
-				 KC_FILLATTR_REQUEST_MASK
 				 inode, stat);
 		scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
 	}
@@ -410,7 +412,6 @@ static int set_inode_size(struct inode *inode, struct scoutfs_lock *lock,
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
 	struct super_block *sb = inode->i_sb;
-	struct kc_timespec cur_time;
 	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	LIST_HEAD(ind_locks);
 	int ret;
@@ -433,9 +434,7 @@ static int set_inode_size(struct inode *inode, struct scoutfs_lock *lock,
 		scoutfs_inode_inc_data_version(inode);
 
 	truncate_setsize(inode, new_size);
-	cur_time = current_time(inode);
-	inode_set_ctime_to_ts(inode, cur_time);
-	inode_set_mtime_to_ts(inode, cur_time);
+	inode->i_ctime = inode->i_mtime = current_time(inode);
 	if (truncate)
 		si->flags |= SCOUTFS_INO_FLAG_TRUNCATE;
 	scoutfs_inode_set_data_seq(inode);
@@ -550,6 +549,7 @@ retry:
 				goto out;
 			if (scoutfs_data_wait_found(&dw)) {
 				scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
+				lock = NULL;
 
 				/* XXX callee locks instead? */
 				inode_unlock(inode);
@@ -902,14 +902,14 @@ static void store_inode(struct scoutfs_inode *cinode, struct inode *inode, int i
 	cinode->gid = cpu_to_le32(i_gid_read(inode));
 	cinode->mode = cpu_to_le32(inode->i_mode);
 	cinode->rdev = cpu_to_le32(inode->i_rdev);
-	cinode->atime.sec = cpu_to_le64(inode_get_atime_sec(inode));
-	cinode->atime.nsec = cpu_to_le32(inode_get_atime_nsec(inode));
+	cinode->atime.sec = cpu_to_le64(inode->i_atime.tv_sec);
+	cinode->atime.nsec = cpu_to_le32(inode->i_atime.tv_nsec);
 	memset(cinode->atime.__pad, 0, sizeof(cinode->atime.__pad));
-	cinode->ctime.sec = cpu_to_le64(inode_get_ctime_sec(inode));
-	cinode->ctime.nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
+	cinode->ctime.sec = cpu_to_le64(inode->i_ctime.tv_sec);
+	cinode->ctime.nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
 	memset(cinode->ctime.__pad, 0, sizeof(cinode->ctime.__pad));
-	cinode->mtime.sec = cpu_to_le64(inode_get_mtime_sec(inode));
-	cinode->mtime.nsec = cpu_to_le32(inode_get_mtime_nsec(inode));
+	cinode->mtime.sec = cpu_to_le64(inode->i_mtime.tv_sec);
+	cinode->mtime.nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
 	memset(cinode->mtime.__pad, 0, sizeof(cinode->mtime.__pad));
 
 	cinode->meta_seq = cpu_to_le64(scoutfs_inode_meta_seq(inode));
@@ -1567,7 +1567,6 @@ int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, d
 	struct scoutfs_inode sinode;
 	struct scoutfs_key key;
 	struct inode *inode;
-	struct kc_timespec cur_time;
 	int inode_bytes;
 	int ret;
 
@@ -1597,10 +1596,7 @@ int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, d
 	inode_init_owner(KC_VFS_INIT_NS
 			 inode, dir, mode);
 	inode_set_bytes(inode, 0);
-	cur_time = current_time(inode);
-	inode_set_mtime_to_ts(inode, cur_time);
-	inode_set_atime_to_ts(inode, cur_time);
-	inode_set_ctime_to_ts(inode, cur_time);
+	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
 	inode->i_rdev = rdev;
 	set_inode_ops(inode);
 
@@ -2073,7 +2069,7 @@ void scoutfs_inode_schedule_orphan_dwork(struct super_block *sb)
 
 		low = (opts.orphan_scan_delay_ms * 80) / 100;
 		high = (opts.orphan_scan_delay_ms * 120) / 100;
-		delay = msecs_to_jiffies(low + get_random_u32_below(high - low)) ?: 1;
+		delay = msecs_to_jiffies(low + prandom_u32_max(high - low)) ?: 1;
 
 		mod_delayed_work(system_wq, &inf->orphan_scan_dwork, delay);
 	}

kmod/src/ioctl.c

@@ -1739,6 +1739,43 @@ out:
 	return ret;
 }
 
+static long scoutfs_ioc_inject_totl_delta(struct file *file, unsigned long arg)
+{
+	struct super_block *sb = file_inode(file)->i_sb;
+	struct scoutfs_ioctl_inject_totl_delta __user *uitd = (void __user *)arg;
+	struct scoutfs_ioctl_inject_totl_delta itd;
+	struct scoutfs_xattr_totl_val tval;
+	struct scoutfs_lock *lock = NULL;
+	struct scoutfs_key key;
+	int ret;
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (copy_from_user(&itd, uitd, sizeof(itd)))
+		return -EFAULT;
+
+	scoutfs_xattr_init_totl_key(&key, itd.name);
+	tval.total = cpu_to_le64((u64)itd.total);
+	tval.count = cpu_to_le64((u64)itd.count);
+
+	ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &lock);
+	if (ret < 0)
+		goto out;
+
+	ret = scoutfs_hold_trans(sb, true);
+	if (ret < 0)
+		goto unlock;
+
+	ret = scoutfs_item_delta(sb, &key, &tval, sizeof(tval), lock);
+
+	scoutfs_release_trans(sb);
+unlock:
+	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE_ONLY);
+out:
+	return ret;
+}
+
 long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	switch (cmd) {
@@ -1790,6 +1827,8 @@ long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 		return scoutfs_ioc_read_xattr_index(file, arg);
 	case SCOUTFS_IOC_PUNCH_OFFLINE:
 		return scoutfs_ioc_punch_offline(file, arg);
+	case SCOUTFS_IOC_INJECT_TOTL_DELTA:
+		return scoutfs_ioc_inject_totl_delta(file, arg);
 	}
 
 	return -ENOTTY;

kmod/src/ioctl.h

@@ -876,4 +876,17 @@ struct scoutfs_ioctl_punch_offline {
 #define SCOUTFS_IOC_PUNCH_OFFLINE \
 	_IOW(SCOUTFS_IOCTL_MAGIC, 24, struct scoutfs_ioctl_punch_offline)
 
+/*
+ * Inject a signed (total, count) delta at the totl key @name (a, b, c
+ * match the trailing dotted u64s of a totl xattr name).
+ */
+struct scoutfs_ioctl_inject_totl_delta {
+	__u64	name[SCOUTFS_IOCTL_XATTR_TOTAL_NAME_NR];
+	__s64	total;
+	__s64	count;
+};
+
+#define SCOUTFS_IOC_INJECT_TOTL_DELTA \
+	_IOW(SCOUTFS_IOCTL_MAGIC, 25, struct scoutfs_ioctl_inject_totl_delta)
+
 #endif

kmod/src/item.c

@@ -146,7 +146,7 @@ struct cached_item {
 	unsigned int val_len;
 	struct scoutfs_key key;
 	u64 seq;
-	char val[];
+	char val[0];
 };
 
 #define CACHED_ITEM_ALIGN 8
@@ -424,7 +424,7 @@ static struct cached_item *alloc_item(struct cached_page *pg,
 	item->seq = seq;
 
 	if (val_len)
-		memcpy(&item->val[0], val, val_len);
+		memcpy(item->val, val, val_len);
 
 	update_pg_max_seq(pg, item);
 
@@ -1999,7 +1999,7 @@ int scoutfs_item_update(struct super_block *sb, struct scoutfs_key *key,
 
 	if (val_len <= found->val_len) {
 		if (val_len)
-			memcpy(&found->val[0], val, val_len);
+			memcpy(found->val, val, val_len);
 		if (val_len < found->val_len)
 			pg->erased_bytes += item_val_bytes(found->val_len) -
 					    item_val_bytes(val_len);
@@ -2316,7 +2316,7 @@ int scoutfs_item_write_dirty(struct super_block *sb)
 			lst->seq = item->seq;
 			lst->flags = item->deletion ? SCOUTFS_ITEM_FLAG_DELETION : 0;
 			lst->val_len = item->val_len;
-			memcpy(&lst->val[0], item->val, item->val_len);
+			memcpy(lst->val, item->val, item->val_len);
 		}
 
 		spin_lock(&cinf->dirty_lock);
@@ -2626,10 +2626,10 @@ int scoutfs_item_setup(struct super_block *sb)
 
 	for_each_possible_cpu(cpu)
 		init_pcpu_pages(cinf, cpu);
-	KC_SETUP_SHRINKER(cinf->shrinker, cinf, 0, item_cache_count_objects,
-			  item_cache_scan_objects, "scoutfs-item:" SCSBF, SCSB_ARGS(sb));
-	if (KC_SHRINKER_IS_NULL(cinf->shrinker))
-		return -ENOMEM;
+
+	KC_INIT_SHRINKER_FUNCS(&cinf->shrinker, item_cache_count_objects,
+			       item_cache_scan_objects);
+	KC_REGISTER_SHRINKER(&cinf->shrinker, "scoutfs-item:" SCSBF, SCSB_ARGS(sb));
 #ifdef KC_CPU_NOTIFIER
         cinf->notifier.notifier_call = item_cpu_callback;
         register_hotcpu_notifier(&cinf->notifier);
@@ -2654,7 +2654,7 @@ void scoutfs_item_destroy(struct super_block *sb)
 #ifdef KC_CPU_NOTIFIER
 		unregister_hotcpu_notifier(&cinf->notifier);
 #endif
-		KC_UNREGISTER_SHRINKER(cinf->shrinker);
+		KC_UNREGISTER_SHRINKER(&cinf->shrinker);
 
 		for_each_possible_cpu(cpu)
 			drop_pcpu_pages(sb, cinf, cpu);

kmod/src/kernelcompat.c

@@ -147,13 +147,3 @@ unsigned long kc_list_lru_shrink_walk(struct list_lru *lru, struct shrink_contro
 }
 
 #endif
-
-#ifndef KC_FS_INODE_C_TIME_ACCESSOR
-struct timespec64 inode_set_ctime_current(struct inode *inode)
-{
-	struct timespec64 now = current_time(inode);
-
-	inode_set_ctime(inode, now.tv_sec, now.tv_nsec);
-	return now;
-}
-#endif

kmod/src/kernelcompat.h

@@ -142,54 +142,25 @@ struct timespec64 kc_current_time(struct inode *inode);
 #define kc_timespec timespec64
 #endif
 
-#ifdef KC_SHRINKER_ALLOC
-// el10+
-
-#define KC_DEFINE_SHRINKER(name) struct shrinker *(name)
-#define KC_SHRINKER_CONTAINER_OF(ptr, type) ptr->private_data
-#define KC_SETUP_SHRINKER(ptr, priv, flags, countfn, scanfn, fmt, args)	\
-do {								\
-	ptr = shrinker_alloc(flags, fmt, args);			\
-	if (ptr) {						\
-		ptr->private_data = (priv);			\
-		ptr->seeks = DEFAULT_SEEKS;			\
-		ptr->count_objects = countfn;			\
-		ptr->scan_objects = scanfn;			\
-		shrinker_register(ptr);				\
-	}							\
-} while (0)
-#define KC_UNREGISTER_SHRINKER(ptr) shrinker_free(ptr)
-#define KC_SHRINKER_FN(ptr) (ptr)
-#define KC_SHRINKER_IS_NULL(ptr) (!(ptr))
-
-#else /* KC_SHRINKER_ALLOC */
 #ifndef KC_SHRINKER_SHRINK
-// el9, el8
 
-#define KC_DEFINE_SHRINKER(name) struct shrinker (name)
+#define KC_DEFINE_SHRINKER(name) struct shrinker name
+#define KC_INIT_SHRINKER_FUNCS(name, countfn, scanfn) do {	\
+	__typeof__(name) _shrink = (name);			\
+	_shrink->count_objects = (countfn);			\
+	_shrink->scan_objects = (scanfn);			\
+	_shrink->seeks = DEFAULT_SEEKS;			\
+} while (0)
+
 #define KC_SHRINKER_CONTAINER_OF(ptr, type) container_of(ptr, type, shrinker)
 #ifdef KC_SHRINKER_NAME
-#define KC_SETUP_SHRINKER(ptr, priv, flags, countfn, scanfn, fmt, args)	\
-do {								\
-	(ptr).count_objects = (countfn);			\
-	(ptr).scan_objects = (scanfn);				\
-	(ptr).seeks = DEFAULT_SEEKS;				\
-	register_shrinker(&(ptr), fmt, args);			\
-} while (0)
+#define KC_REGISTER_SHRINKER register_shrinker
 #else
-#define KC_SETUP_SHRINKER(ptr, priv, flags, countfn, scanfn, fmt, args)	\
-do {								\
-	(ptr).count_objects = (countfn);			\
-	(ptr).scan_objects = (scanfn);				\
-	(ptr).seeks = DEFAULT_SEEKS;				\
-	register_shrinker(&(ptr));				\
-} while (0)
+#define KC_REGISTER_SHRINKER(ptr, fmt, ...) (register_shrinker(ptr))
 #endif /* KC_SHRINKER_NAME */
-#define KC_UNREGISTER_SHRINKER(ptr) (unregister_shrinker(&(ptr)))
-#define KC_SHRINKER_FN(ptr) (&ptr)
-
-#else /* KC_SHRINKER_SHRINK */
-// el7
+#define KC_UNREGISTER_SHRINKER(ptr) (unregister_shrinker(ptr))
+#define KC_SHRINKER_FN(ptr) (ptr)
+#else
 
 #include <linux/shrinker.h>
 #ifndef SHRINK_STOP
@@ -205,21 +176,19 @@ struct kc_shrinker_wrapper {
 };
 
 #define KC_DEFINE_SHRINKER(name) struct kc_shrinker_wrapper name;
-#define KC_SHRINKER_CONTAINER_OF(ptr, type) container_of(container_of(ptr, struct kc_shrinker_wrapper, shrink), type, shrinker)
-#define KC_SETUP_SHRINKER(ptr, priv, flags, countfn, scanfn, fmt, args)	\
-do {								\
-	(ptr).count_objects = (countfn);			\
-	(ptr).scan_objects = (scanfn);				\
-	(ptr).shrink.shrink = kc_shrink_wrapper_fn;		\
-	(ptr).shrink.seeks = DEFAULT_SEEKS;			\
-	register_shrinker(&(ptr).shrink);			\
+#define KC_INIT_SHRINKER_FUNCS(name, countfn, scanfn) do {	\
+	struct kc_shrinker_wrapper *_wrap = (name);		\
+	_wrap->count_objects = (countfn);			\
+	_wrap->scan_objects = (scanfn);				\
+	_wrap->shrink.shrink = kc_shrink_wrapper_fn;		\
+	_wrap->shrink.seeks = DEFAULT_SEEKS;			\
 } while (0)
-#define KC_UNREGISTER_SHRINKER(ptr) (unregister_shrinker(&(ptr).shrink))
-#define KC_SHRINKER_FN(ptr) (&(ptr).shrink)
+#define KC_SHRINKER_CONTAINER_OF(ptr, type) container_of(container_of(ptr, struct kc_shrinker_wrapper, shrink), type, shrinker)
+#define KC_REGISTER_SHRINKER(ptr, fmt, ...) (register_shrinker(ptr.shrink))
+#define KC_UNREGISTER_SHRINKER(ptr) (unregister_shrinker(ptr.shrink))
+#define KC_SHRINKER_FN(ptr) (ptr.shrink)
 
 #endif /* KC_SHRINKER_SHRINK */
-#define KC_SHRINKER_IS_NULL(ptr) (0)
-#endif /* KC_SHRINKER_ALLOC */
 
 #ifdef KC_KERNEL_GETSOCKNAME_ADDRLEN
 #include <linux/net.h>
@@ -310,12 +279,6 @@ typedef unsigned int blk_opf_t;
 #endif
 #endif /* KC_VFS_METHOD_MNT_IDMAP_ARG */
 
-#ifdef KC_GENERIC_FILLATTR_REQUEST_MASK
-#define KC_FILLATTR_REQUEST_MASK request_mask,
-#else
-#define KC_FILLATTR_REQUEST_MASK
-#endif
-
 #ifdef KC_BIO_ALLOC_DEV_OPF_ARGS
 #define kc_bio_alloc bio_alloc
 #else
@@ -489,7 +452,6 @@ unsigned long kc_list_lru_shrink_walk(struct list_lru *lru, struct shrink_contro
 				      kc_list_lru_walk_cb_t isolate, void *cb_arg);
 #else
 #define kc_list_lru_shrink_walk list_lru_shrink_walk
-#define kc_list_lru_walk list_lru_walk
 #endif
 
 #if defined(KC_LIST_LRU_WALK_CB_ITEM_LOCK)
@@ -527,133 +489,4 @@ static inline void stack_trace_print(unsigned long *entries, unsigned int nr_ent
 }
 #endif
 
-#ifndef KC_HAVE_GET_RANDOM_U32_BELOW
-#define get_random_u32_below prandom_u32_max
-#endif
-
-#ifndef KC_FS_INODE_C_TIME_ACCESSOR
-struct timespec64 inode_set_ctime_current(struct inode *inode);
-static inline struct timespec64 inode_set_ctime_to_ts(struct inode *inode,
-						      struct timespec64 ts)
-{
-	inode->i_ctime.tv_sec = ts.tv_sec;
-	inode->i_ctime.tv_nsec = ts.tv_nsec;
-	return ts;
-}
-
-static inline struct timespec64 inode_set_ctime(struct inode *inode,
-						time64_t sec, long nsec)
-{
-	struct timespec64 ts = { .tv_sec  = sec,
-				 .tv_nsec = nsec };
-
-	return inode_set_ctime_to_ts(inode, ts);
-}
-
-static inline struct timespec64 inode_get_ctime(const struct inode *inode)
-{
-	struct timespec64 ts = { .tv_sec  = inode->i_ctime.tv_sec,
-				 .tv_nsec = inode->i_ctime.tv_nsec };
-	return ts;
-}
-#endif
-
-#ifndef KC_FS_INODE_AM_TIME_ACCESSOR
-static inline struct timespec64 inode_get_mtime(const struct inode *inode)
-{
-	struct timespec64 ts = { .tv_sec  = inode->i_mtime.tv_sec,
-				 .tv_nsec = inode->i_mtime.tv_nsec };
-	return ts;
-}
-
-static inline struct timespec64 inode_set_mtime_to_ts(struct inode *inode,
-						      struct timespec64 ts)
-{
-	inode->i_mtime.tv_sec = ts.tv_sec;
-	inode->i_mtime.tv_nsec = ts.tv_nsec;
-	return ts;
-}
-
-static inline struct timespec64 inode_set_mtime(struct inode *inode,
-						time64_t sec, long nsec)
-{
-	struct timespec64 ts = { .tv_sec  = sec,
-				 .tv_nsec = nsec };
-
-	return inode_set_mtime_to_ts(inode, ts);
-}
-
-static inline struct timespec64 inode_set_atime_to_ts(struct inode *inode,
-						      struct timespec64 ts)
-{
-	inode->i_atime.tv_sec = ts.tv_sec;
-	inode->i_atime.tv_nsec = ts.tv_nsec;
-	return ts;
-}
-
-static inline struct timespec64 inode_set_atime(struct inode *inode,
-						time64_t sec, long nsec)
-{
-	struct timespec64 ts = { .tv_sec  = sec,
-				 .tv_nsec = nsec };
-
-	return inode_set_atime_to_ts(inode, ts);
-}
-
-static inline time64_t inode_get_ctime_sec(const struct inode *inode)
-{
-	return inode->i_ctime.tv_sec;
-}
-static inline long inode_get_ctime_nsec(const struct inode *inode)
-{
-	return inode->i_ctime.tv_nsec;
-}
-static inline time64_t inode_get_mtime_sec(const struct inode *inode)
-{
-	return inode->i_mtime.tv_sec;
-}
-static inline long inode_get_mtime_nsec(const struct inode *inode)
-{
-	return inode->i_mtime.tv_nsec;
-}
-static inline time64_t inode_get_atime_sec(const struct inode *inode)
-{
-	return inode->i_atime.tv_sec;
-}
-static inline long inode_get_atime_nsec(const struct inode *inode)
-{
-	return inode->i_atime.tv_nsec;
-}
-#endif
-
-#ifdef KC_HAVE_BD_INODE
-#define KC_BDEV_INODE(b) (b)->bd_inode
-#define KC_BDEV_MAPPING(b) (b)->bd_inode->i_mapping
-#else
-#define KC_BDEV_INODE(b) (b)->bd_mapping->host
-#define KC_BDEV_MAPPING(b) (b)->bd_mapping
-#endif
-
-#ifdef KC_HAVE_ASSIGN_STR_PARMS
-#define kc__assign_str(a, b) __assign_str(a, b)
-#else
-#define kc__assign_str(a, b) __assign_str(a)
-#endif
-
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-#define KC_KOBJ_DEFAULT_OP default_groups
-#define KC_KOBJ_DEFAULT(name) (name##_groups)
-#define KC_KOBJ_DEFAULT_PICK(group, attrs) (group)
-#else
-#define KC_KOBJ_DEFAULT_OP default_attrs
-#define KC_KOBJ_DEFAULT(name) (name##_attrs)
-#define KC_KOBJ_DEFAULT_PICK(group, attrs) (attrs)
-#endif
-
-#ifdef KC_BLOCK_WRITE_BEGIN_FOLIO
-#define KC_PAGE_OR_FOLIO(p, f) f
-#else
-#define KC_PAGE_OR_FOLIO(p, f) p
-#endif
-
 #endif

kmod/src/lock.c

@@ -813,6 +813,7 @@ int scoutfs_lock_invalidate_request(struct super_block *sb, u64 net_id,
 
 out:
 	if (!lock) {
+		kfree(ireq);
 		ret = scoutfs_client_lock_response(sb, net_id, nl);
 		BUG_ON(ret); /* lock server doesn't fence timed out client requests */
 	}
@@ -979,7 +980,7 @@ static bool lock_flags_invalid(int flags)
  */
 static int lock_key_range(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
 			  struct scoutfs_key *start, struct scoutfs_key *end,
-			  struct scoutfs_lock **ret_lock)
+			  u64 ino, struct scoutfs_lock **ret_lock)
 {
 	DECLARE_LOCK_INFO(sb, linfo);
 	struct scoutfs_lock *lock;
@@ -1027,6 +1028,8 @@ static int lock_key_range(struct super_block *sb, enum scoutfs_lock_mode mode, i
 		/* the fast path where we can use the granted mode */
 		if (lock_modes_match(lock->mode, mode)) {
 			lock_inc_count(lock->users, mode);
+			lock->last_user_pid[mode] = task_pid_nr(current);
+			lock->last_user_ino[mode] = ino;
 			*ret_lock = lock;
 			ret = 0;
 			break;
@@ -1107,7 +1110,7 @@ int scoutfs_lock_ino(struct super_block *sb, enum scoutfs_lock_mode mode, int fl
 	end.sk_zone = SCOUTFS_FS_ZONE;
 	end.ski_ino = cpu_to_le64(ino | SCOUTFS_LOCK_INODE_GROUP_MASK);
 
-	return lock_key_range(sb, mode, flags, &start, &end, ret_lock);
+	return lock_key_range(sb, mode, flags, &start, &end, ino, ret_lock);
 }
 
 /*
@@ -1237,7 +1240,7 @@ int scoutfs_lock_rename(struct super_block *sb, enum scoutfs_lock_mode mode, int
 		.sk_type = SCOUTFS_RENAME_TYPE,
 	};
 
-	return lock_key_range(sb, mode, flags, &key, &key, lock);
+	return lock_key_range(sb, mode, flags, &key, &key, 0, lock);
 }
 
 /*
@@ -1285,7 +1288,7 @@ int scoutfs_lock_inode_index(struct super_block *sb, enum scoutfs_lock_mode mode
 
 	scoutfs_lock_get_index_item_range(type, major, ino, &start, &end);
 
-	return lock_key_range(sb, mode, 0, &start, &end, ret_lock);
+	return lock_key_range(sb, mode, 0, &start, &end, ino, ret_lock);
 }
 
 /*
@@ -1312,7 +1315,7 @@ int scoutfs_lock_orphan(struct super_block *sb, enum scoutfs_lock_mode mode, int
 	end.sko_ino = cpu_to_le64(U64_MAX);
 	end.sk_type = SCOUTFS_ORPHAN_TYPE;
 
-	return lock_key_range(sb, mode, flags, &start, &end, lock);
+	return lock_key_range(sb, mode, flags, &start, &end, ino, lock);
 }
 
 int scoutfs_lock_xattr_totl(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
@@ -1323,7 +1326,7 @@ int scoutfs_lock_xattr_totl(struct super_block *sb, enum scoutfs_lock_mode mode,
 
 	scoutfs_totl_set_range(&start, &end);
 
-	return lock_key_range(sb, mode, flags, &start, &end, lock);
+	return lock_key_range(sb, mode, flags, &start, &end, 0, lock);
 }
 
 int scoutfs_lock_xattr_indx(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
@@ -1334,7 +1337,7 @@ int scoutfs_lock_xattr_indx(struct super_block *sb, enum scoutfs_lock_mode mode,
 
 	scoutfs_xattr_indx_get_range(&start, &end);
 
-	return lock_key_range(sb, mode, flags, &start, &end, lock);
+	return lock_key_range(sb, mode, flags, &start, &end, 0, lock);
 }
 
 int scoutfs_lock_quota(struct super_block *sb, enum scoutfs_lock_mode mode, int flags,
@@ -1345,7 +1348,7 @@ int scoutfs_lock_quota(struct super_block *sb, enum scoutfs_lock_mode mode, int
 
 	scoutfs_quota_get_lock_range(&start, &end);
 
-	return lock_key_range(sb, mode, flags, &start, &end, lock);
+	return lock_key_range(sb, mode, flags, &start, &end, 0, lock);
 }
 
 void scoutfs_unlock(struct super_block *sb, struct scoutfs_lock *lock, enum scoutfs_lock_mode mode)
@@ -1462,7 +1465,7 @@ static void lock_tseq_show(struct seq_file *m, struct scoutfs_tseq_entry *ent)
 	struct scoutfs_lock *lock =
 		container_of(ent, struct scoutfs_lock, tseq_entry);
 
-	seq_printf(m, "start "SK_FMT" end "SK_FMT" refresh_gen %llu mode %d waiters: rd %u wr %u wo %u users: rd %u wr %u wo %u\n",
+	seq_printf(m, "start "SK_FMT" end "SK_FMT" refresh_gen %llu mode %d waiters: rd %u wr %u wo %u users: rd %u wr %u wo %u ino: rd %llu wr %llu wo %llu pid: rd %d wr %d wo %d\n",
 			   SK_ARG(&lock->start), SK_ARG(&lock->end),
 			   lock->refresh_gen, lock->mode,
 			   lock->waiters[SCOUTFS_LOCK_READ],
@@ -1470,7 +1473,13 @@ static void lock_tseq_show(struct seq_file *m, struct scoutfs_tseq_entry *ent)
 			   lock->waiters[SCOUTFS_LOCK_WRITE_ONLY],
 			   lock->users[SCOUTFS_LOCK_READ],
 			   lock->users[SCOUTFS_LOCK_WRITE],
-			   lock->users[SCOUTFS_LOCK_WRITE_ONLY]);
+			   lock->users[SCOUTFS_LOCK_WRITE_ONLY],
+			   lock->last_user_ino[SCOUTFS_LOCK_READ],
+			   lock->last_user_ino[SCOUTFS_LOCK_WRITE],
+			   lock->last_user_ino[SCOUTFS_LOCK_WRITE_ONLY],
+			   lock->last_user_pid[SCOUTFS_LOCK_READ],
+			   lock->last_user_pid[SCOUTFS_LOCK_WRITE],
+			   lock->last_user_pid[SCOUTFS_LOCK_WRITE_ONLY]);
 }
 
 /*

kmod/src/lock.h

@@ -42,6 +42,8 @@ struct scoutfs_lock {
 	enum scoutfs_lock_mode invalidating_mode;
 	unsigned int waiters[SCOUTFS_LOCK_NR_MODES];
 	unsigned int users[SCOUTFS_LOCK_NR_MODES];
+	pid_t last_user_pid[SCOUTFS_LOCK_NR_MODES];
+	u64 last_user_ino[SCOUTFS_LOCK_NR_MODES];
 
 	struct scoutfs_tseq_entry tseq_entry;
 

kmod/src/net.c

@@ -525,7 +525,7 @@ static int process_response(struct scoutfs_net_connection *conn,
 	struct super_block *sb = conn->sb;
 	struct message_send *msend;
 	scoutfs_net_response_t resp_func = NULL;
-	void *resp_data;
+	void *resp_data = NULL;
 
 	spin_lock(&conn->lock);
 
@@ -804,7 +804,7 @@ static void scoutfs_net_recv_worker(struct work_struct *work)
 			if (invalid_message(conn, nh)) {
 				scoutfs_inc_counter(sb, net_recv_invalid_message);
 				ret = -EBADMSG;
-				break;
+				goto out;
 			}
 
 			data_len = le16_to_cpu(nh->data_len);

kmod/src/options.c

@@ -752,18 +752,13 @@ static struct attribute *options_attrs[] = {
 	SCOUTFS_ATTR_PTR(quorum_slot_nr),
 	NULL,
 };
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-ATTRIBUTE_GROUPS(options);
-#endif
 
 int scoutfs_options_setup(struct super_block *sb)
 {
 	DECLARE_OPTIONS_INFO(sb, optinf);
 	int ret;
 
-	ret = scoutfs_sysfs_create_attrs(sb, &optinf->sysfs_attrs,
-					 KC_KOBJ_DEFAULT_PICK(options_groups, options_attrs),
-					 "mount_options");
+	ret = scoutfs_sysfs_create_attrs(sb, &optinf->sysfs_attrs, options_attrs, "mount_options");
 	if (ret < 0)
 		scoutfs_options_destroy(sb);
 	return ret;

kmod/src/quorum.c

@@ -162,7 +162,7 @@ static void quorum_slot_sin(struct scoutfs_quorum_config *qconf, int i, struct s
 static ktime_t election_timeout(void)
 {
 	return ktime_add_ms(ktime_get(), SCOUTFS_QUORUM_ELECT_MIN_MS +
-				 get_random_u32_below(SCOUTFS_QUORUM_ELECT_VAR_MS));
+				 prandom_u32_max(SCOUTFS_QUORUM_ELECT_VAR_MS));
 }
 
 static ktime_t heartbeat_interval(void)
@@ -1192,9 +1192,6 @@ static struct attribute *quorum_attrs[] = {
 	SCOUTFS_ATTR_PTR(is_leader),
 	NULL,
 };
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-ATTRIBUTE_GROUPS(quorum);
-#endif
 
 static inline bool valid_ipv4_unicast(__be32 addr)
 {
@@ -1355,7 +1352,7 @@ int scoutfs_quorum_setup(struct super_block *sb)
 	if (ret < 0)
 		goto out;
 
-	ret = scoutfs_sysfs_create_attrs(sb, &qinf->ssa, KC_KOBJ_DEFAULT(quorum),
+	ret = scoutfs_sysfs_create_attrs(sb, &qinf->ssa, quorum_attrs,
 					 "quorum");
 	if (ret < 0)
 		goto out;

kmod/src/quota.c

@@ -205,7 +205,7 @@ static struct squota_check *lookup_random_check(struct rhashtable *rht)
 
 	tbl = rht_dereference_rcu(rht->tbl, rht);
 	do {
-		for (s = 0, i = get_random_u32_below(tbl->size);
+		for (s = 0, i = prandom_u32_max(tbl->size);
 		     s < tbl->size;
 		     s++, i = (i + 1) % tbl->size) {
 			rht_for_each_entry_rcu(chk, pos, tbl, i, head) {
@@ -270,7 +270,7 @@ static void shrink_all_cached_checks(struct squota_info *qtinf)
 {
 	struct shrink_control sc = { .nr_to_scan = LONG_MAX, };
 
-	scan_cached_checks(KC_SHRINKER_FN(qtinf->shrinker), &sc);
+	scan_cached_checks(KC_SHRINKER_FN(&qtinf->shrinker), &sc);
 }
 
 static u8 ns_is_attr(u8 ns)
@@ -1114,6 +1114,7 @@ int scoutfs_quota_mod_rule(struct super_block *sb, bool is_add,
 			goto release;
 	}
 
+	wait_event(qtinf->waitq, !ruleset_is_busy(qtinf));
 	scoutfs_quota_invalidate(sb);
 	ret = 0;
 
@@ -1142,12 +1143,17 @@ void scoutfs_quota_get_lock_range(struct scoutfs_key *start, struct scoutfs_key
 }
 
 /*
- * This is called during cluster lock invalidation to indicate that the
- * ruleset is no longer protected by cluster locking and might have been
- * modified.  We mark the ruleset invalid and free it once all readers
- * drain.  The next check will acquire the cluster lock and read the
- * rules.  Because this is called during invalidation this is serialized
- * with write holders of cluster locks so we can never see -EBUSY here.
+ * Mark the cached ruleset invalid and free the previous one once readers
+ * drain.  Called from cluster lock invalidation and from quota rule
+ * modification.
+ *
+ * Cluster lock invalidation runs only after the lock layer has drained
+ * local READ users.  Since EBUSY is set only while a reader holds READ,
+ * the reader has already published by the time we run.
+ *
+ * Quota rule modification waits on the waitq for any in-flight reader
+ * to publish before calling here, so the next check rebuilds against
+ * the newly written rules rather than the reader's stale result.
  */
 void scoutfs_quota_invalidate(struct super_block *sb)
 {
@@ -1161,13 +1167,10 @@ void scoutfs_quota_invalidate(struct super_block *sb)
 
 	spin_lock(&qtinf->lock);
 	rs = rcu_dereference_protected(qtinf->ruleset, lockdep_is_held(&qtinf->lock));
-	if (rs != ERR_PTR(-EINVAL))
+	if (rs == ERR_PTR(-ENOENT) || !IS_ERR(rs))
 		rcu_assign_pointer(qtinf->ruleset, ERR_PTR(-EINVAL));
 	spin_unlock(&qtinf->lock);
 
-	/* cluster locking should have prevented this */
-	BUG_ON(rs == ERR_PTR(-EBUSY));
-
 	if (!IS_ERR(rs))
 		call_rcu(&rs->rcu, free_ruleset_rcu);
 
@@ -1232,12 +1235,8 @@ int scoutfs_quota_setup(struct super_block *sb)
 	spin_lock_init(&qtinf->lock);
 	init_waitqueue_head(&qtinf->waitq);
 
-	KC_SETUP_SHRINKER(qtinf->shrinker, qtinf, 0, count_cached_checks,
-			  scan_cached_checks, "scoutfs-quota:" SCSBF, SCSB_ARGS(sb));
-	if (KC_SHRINKER_IS_NULL(qtinf->shrinker)) {
-		ret = -ENOMEM;
-		goto out;
-	}
+	KC_INIT_SHRINKER_FUNCS(&qtinf->shrinker, count_cached_checks, scan_cached_checks);
+	KC_REGISTER_SHRINKER(&qtinf->shrinker, "scoutfs-quota:" SCSBF, SCSB_ARGS(sb));
 
 	sbi->squota_info = qtinf;
 
@@ -1261,7 +1260,7 @@ void scoutfs_quota_destroy(struct super_block *sb)
 
 	if (qtinf) {
 		debugfs_remove(qtinf->drop_dentry);
-		KC_UNREGISTER_SHRINKER(qtinf->shrinker);
+		KC_UNREGISTER_SHRINKER(&qtinf->shrinker);
 
 		spin_lock(&qtinf->lock);
 		rs = rcu_dereference_protected(qtinf->ruleset, lockdep_is_held(&qtinf->lock));

kmod/src/scoutfs_trace.h

@@ -102,7 +102,7 @@ TRACE_EVENT(scoutfs_setattr,
 		SCSB_TRACE_ASSIGN(dentry->d_inode->i_sb);
 		__entry->ino = scoutfs_ino(dentry->d_inode);
 		__entry->d_len = dentry->d_name.len;
-		kc__assign_str(d_name, dentry->d_name.name);
+		__assign_str(d_name, dentry->d_name.name);
 		__entry->ia_valid = attr->ia_valid;
 		__entry->size_change = !!(attr->ia_valid & ATTR_SIZE);
 		__entry->ia_size = attr->ia_size;
@@ -1638,9 +1638,9 @@ TRACE_EVENT(scoutfs_rename,
 	TP_fast_assign(
 		SCSB_TRACE_ASSIGN(sb);
 		__entry->old_dir_ino = scoutfs_ino(old_dir);
-		kc__assign_str(old_name, old_dentry->d_name.name);
+		__assign_str(old_name, old_dentry->d_name.name)
 		__entry->new_dir_ino = scoutfs_ino(new_dir);
-		kc__assign_str(new_name, new_dentry->d_name.name);
+		__assign_str(new_name, new_dentry->d_name.name)
 		__entry->new_inode_ino = new_dentry->d_inode ?
 					 scoutfs_ino(new_dentry->d_inode) : 0;
 	),
@@ -1670,7 +1670,7 @@ TRACE_EVENT(scoutfs_d_revalidate,
 	TP_fast_assign(
 		SCSB_TRACE_ASSIGN(sb);
 		__entry->dentry = dentry;
-		kc__assign_str(name, dentry->d_name.name);
+		__assign_str(name, dentry->d_name.name)
 		__entry->ino = dentry->d_inode ? scoutfs_ino(dentry->d_inode) : 0;
 		__entry->dir_ino = dir_ino;
 		__entry->flags = flags;
@@ -1705,7 +1705,7 @@ TRACE_EVENT(scoutfs_validate_dentry,
 		SCSB_TRACE_ASSIGN(sb);
 		__entry->dentry = dentry;
 		__entry->dir_ino = dir_ino;
-		kc__assign_str(name, dentry->d_name.name);
+		__assign_str(name, dentry->d_name.name)
 		__entry->dentry_ino = dentry_ino;
 		__entry->dent_ino = dent_ino;
 		__entry->fsdata_gen = (unsigned long long)dentry->d_fsdata;
@@ -1827,7 +1827,7 @@ TRACE_EVENT(scoutfs_get_name,
 		SCSB_TRACE_ASSIGN(sb);
 		__entry->parent_ino = scoutfs_ino(parent);
 		__entry->child_ino = scoutfs_ino(child);
-		kc__assign_str(name, name);
+		__assign_str(name, name);
 	),
 
 	TP_printk(SCSBF" parent %llu child %llu name: %s",

kmod/src/server.c

@@ -20,6 +20,7 @@
 #include <net/sock.h>
 #include <net/tcp.h>
 #include <linux/log2.h>
+#include <asm/unaligned.h>
 
 #include "format.h"
 #include "counters.h"
@@ -1076,8 +1077,7 @@ static int next_log_merge_range(struct super_block *sb, struct scoutfs_btree_roo
 	struct scoutfs_key key;
 	int ret;
 
-	key = *start;
-	key.sk_zone = SCOUTFS_LOG_MERGE_RANGE_ZONE;
+	init_log_merge_key(&key, SCOUTFS_LOG_MERGE_RANGE_ZONE, 0, 0);
 	scoutfs_key_set_ones(&rng->start);
 
 	do {
@@ -3466,7 +3466,7 @@ out:
 
 static u64 device_blocks(struct block_device *bdev, int shift)
 {
-	return i_size_read(KC_BDEV_INODE(bdev)) >> shift;
+	return i_size_read(bdev->bd_inode) >> shift;
 }
 
 static int server_resize_devices(struct super_block *sb, struct scoutfs_net_connection *conn,

kmod/src/srch.c

@@ -18,11 +18,7 @@
 #include <linux/pagemap.h>
 #include <linux/vmalloc.h>
 #include <linux/sort.h>
-#ifdef KC_HAVE__LINUX_UNALIGNED_H
-#include <linux/unaligned.h>
-#else
 #include <asm/unaligned.h>
-#endif
 
 #include "super.h"
 #include "format.h"
@@ -2350,9 +2346,6 @@ static struct attribute *srch_attrs[] = {
 	SCOUTFS_ATTR_PTR(compact_delay_ms),
 	NULL,
 };
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-ATTRIBUTE_GROUPS(srch);
-#endif
 
 void scoutfs_srch_destroy(struct super_block *sb)
 {
@@ -2394,8 +2387,7 @@ int scoutfs_srch_setup(struct super_block *sb)
 
 	sbi->srch_info = srinf;
 
-	ret = scoutfs_sysfs_create_attrs(sb, &srinf->ssa, KC_KOBJ_DEFAULT(srch),
-					 "srch");
+	ret = scoutfs_sysfs_create_attrs(sb, &srinf->ssa, srch_attrs, "srch");
 	if (ret < 0)
 		goto out;
 

kmod/src/super.c

@@ -283,7 +283,7 @@ int scoutfs_write_super(struct super_block *sb,
 static bool small_bdev(struct super_block *sb, char *which, u64 blocks,
 		       struct block_device *bdev, int shift)
 {
-	u64 size = (u64)i_size_read(KC_BDEV_INODE(bdev));
+	u64 size = (u64)i_size_read(bdev->bd_inode);
 	u64 count = size >> shift;
 
 	if (blocks > count) {
@@ -508,7 +508,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	sb->s_time_gran = 1;
 
 	/* btree blocks use long lived bh->b_data refs */
-	mapping_set_gfp_mask(KC_BDEV_MAPPING(sb->s_bdev), GFP_NOFS);
+	mapping_set_gfp_mask(sb->s_bdev->bd_inode->i_mapping, GFP_NOFS);
 
 	sbi = kzalloc(sizeof(struct scoutfs_sb_info), GFP_KERNEL);
 	sb->s_fs_info = sbi;
@@ -552,7 +552,6 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	}
 	sbi->meta_bdev_file = meta_bdev_file;
 	sbi->meta_bdev = file_bdev(meta_bdev_file);
-
 #else
 #ifdef KC_BLKDEV_PUT_HOLDER_ARG
 	meta_bdev = blkdev_get_by_path(opts.metadev_path, SCOUTFS_META_BDEV_MODE, sb, NULL);
@@ -568,11 +567,7 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	sbi->meta_bdev = meta_bdev;
 #endif
 
-#ifdef KC_BLKDEV_SET_BLOCKSIZE_FILE
-	ret = set_blocksize(sbi->meta_bdev_file, SCOUTFS_BLOCK_SM_SIZE);
-#else
 	ret = set_blocksize(sbi->meta_bdev, SCOUTFS_BLOCK_SM_SIZE);
-#endif
 	if (ret != 0) {
 		scoutfs_err(sb, "failed to set metadev blocksize, returned %d",
 			    ret);

kmod/src/sysfs.c

@@ -103,11 +103,12 @@ static ssize_t attr_funcs_show(struct kobject *kobj, struct attribute *attr,
 	};								\
 									\
 	static struct kobj_type _name##_ktype = {			\
-		.KC_KOBJ_DEFAULT_OP = KC_KOBJ_DEFAULT(_name),		\
+		.default_attrs  = _name##_attrs,			\
 		.sysfs_ops      = &_name##_sysfs_ops,			\
 		.release        = _name##_release,			\
 	};
 
+
 static struct attribute *sb_id_attrs[] = {
 	&data_device_maj_min_attr_funcs.attr,
 	&format_version_attr_funcs.attr,
@@ -115,9 +116,6 @@ static struct attribute *sb_id_attrs[] = {
 	&rid_attr_funcs.attr,
 	NULL,
 };
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-ATTRIBUTE_GROUPS(sb_id);
-#endif
 KTYPE(sb_id);
 
 struct kobject *scoutfs_sysfs_sb_dir(struct super_block *sb)
@@ -157,12 +155,7 @@ void scoutfs_sysfs_init_attrs(struct super_block *sb,
 int scoutfs_sysfs_create_attrs_parent(struct super_block *sb,
 				      struct kobject *parent,
 				      struct scoutfs_sysfs_attrs *ssa,
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-				      const struct attribute_group **groups,
-#else
-				      struct attribute **attrs,
-#endif
-				      char *fmt, ...)
+				      struct attribute **attrs, char *fmt, ...)
 {
 	va_list args;
 	size_t name_len;
@@ -175,11 +168,7 @@ int scoutfs_sysfs_create_attrs_parent(struct super_block *sb,
 
 	ssa->sb = sb;
 	init_completion(&ssa->comp);
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-	ssa->ktype.default_groups = groups;
-#else
 	ssa->ktype.default_attrs = attrs;
-#endif
 	ssa->ktype.sysfs_ops = &kobj_sysfs_ops;
 	ssa->ktype.release = scoutfs_sysfs_release;
 

kmod/src/sysfs.h

@@ -39,15 +39,10 @@ void scoutfs_sysfs_init_attrs(struct super_block *sb,
 int scoutfs_sysfs_create_attrs_parent(struct super_block *sb,
 				      struct kobject *parent,
 				      struct scoutfs_sysfs_attrs *ssa,
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-				      const struct attribute_group **groups,
-#else
-				      struct attribute **attrs,
-#endif
-				      char *fmt, ...);
-#define scoutfs_sysfs_create_attrs(sb, ssa, group_or_attrs, fmt, args...)	\
+				      struct attribute **attrs, char *fmt, ...);
+#define scoutfs_sysfs_create_attrs(sb, ssa, attrs, fmt, args...)	\
 	scoutfs_sysfs_create_attrs_parent(sb, scoutfs_sysfs_sb_dir(sb),	\
-					  ssa, group_or_attrs, fmt, ##args)
+					  ssa, attrs, fmt, ##args)
 
 void scoutfs_sysfs_destroy_attrs(struct super_block *sb,
 				 struct scoutfs_sysfs_attrs *ssa);

kmod/src/volopt.c

@@ -52,15 +52,6 @@ static struct volopt_nr_name {
 /* initialized by setup, pointer array is null terminated */
 static struct kobj_attribute volopt_attrs[ARRAY_SIZE(volopt_table)];
 static struct attribute *volopt_attr_ptrs[ARRAY_SIZE(volopt_table) + 1];
-#ifdef KC_KOBJECT_DEFAULT_GROUPS
-static const struct attribute_group volopt_group = {
-	.attrs = volopt_attr_ptrs,
-};
-static const struct attribute_group *volopt_groups[] = {
-	&volopt_group,
-	NULL,
-};
-#endif
 
 static void get_opt_data(struct kobj_attribute *attr, struct scoutfs_volume_options *volopt,
 			 u64 *bit, __le64 **opt)
@@ -173,9 +164,7 @@ int scoutfs_volopt_setup(struct super_block *sb)
 	BUILD_BUG_ON(ARRAY_SIZE(volopt_table) != ARRAY_SIZE(volopt_attr_ptrs) - 1);
 	volopt_attr_ptrs[i] = NULL;
 
-	ret = scoutfs_sysfs_create_attrs(sb, &vinf->ssa,
-					 KC_KOBJ_DEFAULT_PICK(volopt_groups, volopt_attr_ptrs),
-					 "volume_options");
+	ret = scoutfs_sysfs_create_attrs(sb, &vinf->ssa, volopt_attr_ptrs, "volume_options");
 	if (ret < 0)
 		goto out;
 

kmod/src/wkic.c

@@ -172,7 +172,7 @@ struct wkic_item {
 	u64 seq;
 	unsigned int val_len;
 	u8 flags;
-	u8 val[] __aligned(ARCH_KMALLOC_MINALIGN); /* totls have native structs */
+	u8 val[0] __aligned(ARCH_KMALLOC_MINALIGN); /* totls have native structs */
 };
 
 static struct wkic_item *witem_container(struct rb_node *node)
@@ -764,7 +764,7 @@ static void fill_page_items(struct super_block *sb, struct wkic_page *wpage, str
 		pg_item->val_len = witem->val_len;
 		pg_item->flags = witem->flags;
 		if (witem->val_len)
-			memcpy(&pg_item->val[0], witem->val, witem->val_len);
+			memcpy(pg_item->val, witem->val, witem->val_len);
 
 		/* always inserting greatest item into page */
 		rb_link_node(&pg_item->node, parent, node);
@@ -1169,13 +1169,8 @@ int scoutfs_wkic_setup(struct super_block *sb)
 	}
 
 	winf->sb = sb;
-	KC_SETUP_SHRINKER(winf->shrinker, winf, 0, wkic_shrink_count,
-			  wkic_shrink_scan, "scoutfs-weak_item:" SCSBF, SCSB_ARGS(sb));
-	if (KC_SHRINKER_IS_NULL(winf->shrinker)) {
-		debugfs_remove(winf->drop_dentry);
-		kfree(winf);
-		return -ENOMEM;
-	}
+	KC_INIT_SHRINKER_FUNCS(&winf->shrinker, wkic_shrink_count, wkic_shrink_scan);
+	KC_REGISTER_SHRINKER(&winf->shrinker, "scoutfs-weak_item:" SCSBF, SCSB_ARGS(sb));
 
 	sbi->wkic_info = winf;
 	return 0;
@@ -1203,7 +1198,7 @@ void scoutfs_wkic_destroy(struct super_block *sb)
 
 	if (winf) {
 		debugfs_remove(winf->drop_dentry);
-		KC_UNREGISTER_SHRINKER(winf->shrinker);
+		KC_UNREGISTER_SHRINKER(&winf->shrinker);
 
 		/* trees are in sync so tearing down one frees all pages */
 		rbtree_postorder_for_each_entry_safe(wpage, tmp, &winf->wpage_roots[0], nodes[0]) {

kmod/src/xattr.c

@@ -907,7 +907,7 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 
 	/* XXX do these want i_mutex or anything? */
 	inode_inc_iversion(inode);
-	inode_set_ctime_to_ts(inode, current_time(inode));
+	inode->i_ctime = current_time(inode);
 	ret = 0;
 
 out:

tests/.gitignore

@@ -12,3 +12,4 @@ src/o_tmpfile_umask
 src/o_tmpfile_linkat
 src/mmap_stress
 src/mmap_validate
+src/totl-delta-inject

tests/Makefile

@@ -15,7 +15,8 @@ BIN := src/createmany			\
 	src/o_tmpfile_umask		\
 	src/o_tmpfile_linkat		\
 	src/mmap_stress			\
-	src/mmap_validate
+	src/mmap_validate		\
+	src/totl-delta-inject
 
 DEPS := $(wildcard src/*.d)
 

tests/funcs/filter.sh

@@ -3,8 +3,7 @@
 t_filter_fs()
 {
 	sed -e 's@mnt/test\.[0-9]*@mnt/test@g' \
-	    -e 's@Device: [a-fA-F0-9]*h/[0-9]*d@Device: 0h/0d@g' \
-	    -e 's@Device: [0-9]*,[0-9]*@Device: 0h/0d@g'
+	    -e 's@Device: [a-fA-F0-9]*h/[0-9]*d@Device: 0h/0d@g'
 }
 
 #
@@ -225,7 +224,7 @@ t_filter_dmesg()
 	# lockdep or kasan warnings can cause this
 	re="$re|Disabling lock debugging due to kernel taint"
 
-	grep -v -E "($re)" | \
+	egrep -v "($re)" | \
 		ignore_harmless_unwind_kasan_stack_oob | \
 		ignore_harmless_xfs_lockdep_warning
 }

tests/golden/basic-posix-consistency

@@ -47,7 +47,7 @@ four
 --- dir within dir
 --- overwrite file
 --- can't overwrite non-empty dir
-mv: cannot overwrite '/mnt/test/test/basic-posix-consistency/dir/a/dir': Directory not empty
+mv: cannot move '/mnt/test/test/basic-posix-consistency/dir/c/clobber' to '/mnt/test/test/basic-posix-consistency/dir/a/dir': Directory not empty
 --- can overwrite empty dir
 --- can rename into root
 == path resoluion

tests/golden/lock-pid-ino

@@ -0,0 +1,6 @@
+== set up file
+== exercise read, write, and write-only modes
+== verify FS-zone lock recorded read and write ino+pid
+== verify orphan-zone lock recorded write-only ino+pid
+== contend on a single inode with concurrent read and write loops
+== verify both rd and wr slots populated by concurrent contention

tests/golden/quota-invalidate-race

@@ -0,0 +1,6 @@
+== setup
+== concurrent quota mod and check across mounts
+== verify quota rules are consistent after race
+== verify file creation still works under quota
+file visible on mount 1
+== cleanup

tests/golden/totl-delta-inject

@@ -0,0 +1,10 @@
+== setup three files contributing to totl 8888.0.0
+== merge baseline into fs_root
+8888.0.0 = 42, 3
+== inject (+128, +2) unbalances totl 8888.0.0
+8888.0.0 = 170, 5
+== unlink f3 (value 32) produces a -32/-1 delta
+8888.0.0 = 138, 4
+== inject (-128, -2) restores accounting for the remaining files
+8888.0.0 = 10, 2
+== cleanup

tests/run-tests.sh

@@ -301,7 +301,7 @@ fi
 # include everything by default
 test -z "$T_INCLUDE" && T_INCLUDE="-e '.*'"
 # (quickly) exclude nothing by default
-test -z "$T_EXCLUDE" && T_EXCLUDE="-e '^$'"
+test -z "$T_EXCLUDE" && T_EXCLUDE="-e '\Zx'"
 
 # eval to strip re ticks but not expand
 tests=$(grep -v "^#" $T_SEQUENCE |

tests/sequence

@@ -29,7 +29,10 @@ totl-xattr-tag.sh
 basic-xattr-indx.sh
 quota.sh
 totl-merge-read.sh
+quota-invalidate-race.sh
+totl-delta-inject.sh
 lock-refleak.sh
+lock-pid-ino.sh
 lock-shrink-consistency.sh
 lock-shrink-read-race.sh
 lock-pr-cw-conflict.sh

tests/src/totl-delta-inject.c

@@ -0,0 +1,121 @@
+/*
+ * Test helper that calls SCOUTFS_IOC_INJECT_TOTL_DELTA to seed
+ * arbitrary totl deltas.
+ *
+ * Copyright (C) 2026 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.
+ */
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <linux/types.h>
+
+#include "ioctl.h"
+
+static void usage(const char *prog)
+{
+	fprintf(stderr,
+		"Usage: %s <mountpoint> <a>.<b>.<c> <total> <count>\n",
+		prog);
+	exit(2);
+}
+
+static int parse_s64(const char *s, int64_t *out)
+{
+	char *end;
+	int64_t v;
+
+	errno = 0;
+	v = strtoll(s, &end, 0);
+	if (errno || *end != '\0' || end == s)
+		return -1;
+	*out = v;
+	return 0;
+}
+
+/*
+ * Parse "<a>.<b>.<c>" into abc[0..2] (skxt_a, skxt_b, skxt_c).  Each
+ * component must be a non-empty unsigned base-0 integer.
+ */
+static int parse_dotted_name(const char *s, uint64_t abc[3])
+{
+	const char *p = s;
+	char *end;
+	int i;
+
+	for (i = 0; i < 3; i++) {
+		if (*p == '\0' || *p == '.')
+			return -1;
+		errno = 0;
+		abc[i] = strtoull(p, &end, 0);
+		if (errno || end == p)
+			return -1;
+
+		if (i < 2) {
+			if (*end != '.')
+				return -1;
+			p = end + 1;
+		} else {
+			if (*end != '\0')
+				return -1;
+		}
+	}
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	struct scoutfs_ioctl_inject_totl_delta itd = {{0,}};
+	uint64_t abc[3];
+	int64_t total, count;
+	int fd;
+	int ret;
+
+	if (argc != 5)
+		usage(argv[0]);
+
+	if (parse_dotted_name(argv[2], abc) ||
+	    parse_s64(argv[3], &total) ||
+	    parse_s64(argv[4], &count)) {
+		fprintf(stderr, "could not parse arguments\n");
+		usage(argv[0]);
+	}
+
+	itd.name[0] = abc[0];
+	itd.name[1] = abc[1];
+	itd.name[2] = abc[2];
+	itd.total = total;
+	itd.count = count;
+
+	fd = open(argv[1], O_RDONLY | O_DIRECTORY);
+	if (fd < 0) {
+		fprintf(stderr, "open(%s): %s\n", argv[1], strerror(errno));
+		return 1;
+	}
+
+	ret = ioctl(fd, SCOUTFS_IOC_INJECT_TOTL_DELTA, &itd);
+	if (ret < 0) {
+		fprintf(stderr,
+			"INJECT_TOTL_DELTA(%" PRIu64 ".%" PRIu64 ".%" PRIu64
+			", total=%" PRId64 ", count=%" PRId64 "): %s\n",
+			abc[0], abc[1], abc[2], total, count, strerror(errno));
+		close(fd);
+		return 1;
+	}
+
+	close(fd);
+	return 0;
+}

tests/tests/basic-posix-consistency.sh

@@ -138,9 +138,7 @@ echo "--- can't overwrite non-empty dir"
 mkdir "$T_D0/dir/a/dir"
 touch "$T_D0/dir/a/dir/nope"
 mkdir "$T_D1/dir/c/clobber"
-mv -T "$T_D1/dir/c/clobber" "$T_D1/dir/a/dir" 2>&1 | \
-		sed "s@mv: cannot move '.*' to '\(.*\)': Directory not empty@mv: cannot overwrite '\1': Directory not empty@g" | \
-		t_filter_fs
+mv -T "$T_D1/dir/c/clobber" "$T_D1/dir/a/dir" 2>&1 | t_filter_fs
 find "$T_D0/dir" -ls 2>&1 | t_filter_fs > "$T_TMP.0"
 find "$T_D1/dir" -ls 2>&1 | t_filter_fs > "$T_TMP.1"
 diff -u "$T_TMP.0" "$T_TMP.1"

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

@@ -11,8 +11,8 @@
 # format version.
 #
 
-# not supported on el8, or higher versions.
-if [ $(source /etc/os-release ; echo ${VERSION_ID} | cut -d. -f1) -gt 7 ]; then
+# not supported on el8 or higher
+if [ $(source /etc/os-release ; echo ${VERSION_ID:0:1}) -gt 7 ]; then
 	t_skip_permitted "Unsupported OS version"
 fi
 

tests/tests/lock-pid-ino.sh

@@ -0,0 +1,68 @@
+#
+# verify debugfs client_locks reports per-mode last-user PID and inode.
+#
+
+t_require_commands stat touch awk rm
+
+FILE="$T_D0/file"
+
+echo "== set up file"
+touch "$FILE"
+INO=$(stat -c %i "$FILE")
+GROUP_START=$(( INO & ~1023 ))
+
+echo "== exercise read, write, and write-only modes"
+t_quiet stat "$FILE"
+echo data > "$FILE"
+rm -f "$FILE"
+
+echo "== verify FS-zone lock recorded read and write ino+pid"
+ERR=$(awk -v group="$GROUP_START" -v ino="$INO" '
+	$2 == "16." group ".0.0.0.0" {
+		if ($25 != ino || $32 <= 0)
+			print "read mode: ino=" $25 " pid=" $32 " want ino=" ino " pid>0"
+		if ($27 != ino || $34 <= 0)
+			print "write mode: ino=" $27 " pid=" $34 " want ino=" ino " pid>0"
+		found = 1
+	}
+	END { if (!found) print "no FS-zone client_locks line for group " group }
+' < "$(t_debugfs_path)/client_locks")
+[ -n "$ERR" ] && t_fail "$ERR"
+
+echo "== verify orphan-zone lock recorded write-only ino+pid"
+ERR=$(awk -v ino="$INO" '
+	$2 == "8.0.4.0.0.0" {
+		if ($29 != ino || $36 <= 0)
+			print "write-only mode: ino=" $29 " pid=" $36 " want ino=" ino " pid>0"
+		found = 1
+	}
+	END { if (!found) print "no orphan-zone client_locks line" }
+' < "$(t_debugfs_path)/client_locks")
+[ -n "$ERR" ] && t_fail "$ERR"
+
+echo "== contend on a single inode with concurrent read and write loops"
+FILE2="$T_D0/file2"
+touch "$FILE2"
+INO2=$(stat -c %i "$FILE2")
+GROUP2=$(( INO2 & ~1023 ))
+
+for i in $(seq 1 5); do t_quiet stat "$FILE2"; done &
+RPID=$!
+for i in $(seq 1 5); do echo $i > "$FILE2"; done &
+WPID=$!
+wait $RPID $WPID
+
+echo "== verify both rd and wr slots populated by concurrent contention"
+ERR=$(awk -v group="$GROUP2" -v ino="$INO2" '
+	$2 == "16." group ".0.0.0.0" {
+		if ($25 != ino || $32 <= 0)
+			print "concurrent read: ino=" $25 " pid=" $32 " want ino=" ino " pid>0"
+		if ($27 != ino || $34 <= 0)
+			print "concurrent write: ino=" $27 " pid=" $34 " want ino=" ino " pid>0"
+		found = 1
+	}
+	END { if (!found) print "no FS-zone client_locks line for group " group }
+' < "$(t_debugfs_path)/client_locks")
+[ -n "$ERR" ] && t_fail "$ERR"
+
+t_pass

tests/tests/quota-invalidate-race.sh

@@ -0,0 +1,70 @@
+#
+# Regression for the BUG_ON in scoutfs_quota_invalidate when a concurrent
+# ruleset read on one mount races with a quota rule modification.
+#
+
+t_require_mounts 2
+
+TEST_UID=22222
+SET_UID="--ruid=$TEST_UID --euid=$TEST_UID"
+
+echo "== setup"
+mkdir -p "$T_D0/dir"
+chown --quiet $TEST_UID "$T_D0/dir"
+
+# totl xattr gives quota checks something to consult
+setfattr -n scoutfs.totl.test.1.1.1 -v 1 "$T_D0/dir"
+
+echo "== concurrent quota mod and check across mounts"
+
+(
+	for i in $(seq 1 20); do
+		scoutfs quota-add -p "$T_M0" \
+			-r "1 1,L,- 1,L,- $i,L,- I 999999 -" 2>/dev/null
+		scoutfs quota-del -p "$T_M0" \
+			-r "1 1,L,- 1,L,- $i,L,- I 999999 -" 2>/dev/null
+	done
+) &
+MOD_PID=$!
+
+# same mount as the mod: races local read against invalidate
+(
+	for i in $(seq 1 50); do
+		setpriv $SET_UID touch "$T_D0/dir/race0_$i" 2>/dev/null
+		rm -f "$T_D0/dir/race0_$i"
+	done
+) &
+CHECK0_PID=$!
+
+# other mount: drives cross-node lock traffic
+(
+	for i in $(seq 1 50); do
+		setpriv $SET_UID touch "$T_D1/dir/race1_$i" 2>/dev/null
+		rm -f "$T_D1/dir/race1_$i"
+	done
+) &
+CHECK1_PID=$!
+
+t_quiet wait $MOD_PID
+t_quiet wait $CHECK0_PID
+t_quiet wait $CHECK1_PID
+
+echo "== verify quota rules are consistent after race"
+scoutfs quota-wipe -p "$T_M0"
+scoutfs quota-list -p "$T_M0"
+
+echo "== verify file creation still works under quota"
+scoutfs quota-add -p "$T_M0" -r "1 1,L,- 1,L,- 1,L,- I 999999 -"
+sync
+echo 1 > $(t_debugfs_path)/drop_weak_item_cache
+echo 1 > $(t_debugfs_path)/drop_quota_check_cache
+setpriv $SET_UID touch "$T_D0/dir/verify_file"
+test -f "$T_D1/dir/verify_file" && echo "file visible on mount 1"
+rm -f "$T_D0/dir/verify_file"
+scoutfs quota-wipe -p "$T_M0"
+
+echo "== cleanup"
+setfattr -x scoutfs.totl.test.1.1.1 "$T_D0/dir"
+rm -rf "$T_D0/dir"
+
+t_pass

tests/tests/totl-delta-inject.sh

@@ -0,0 +1,43 @@
+#
+# Exercise the SCOUTFS_IOC_INJECT_TOTL_DELTA ioctl that injects totl
+# deltas directly via totl-delta-inject(1).
+#
+
+t_require_commands setfattr scoutfs sync rm touch totl-delta-inject
+
+# force a log merge then read-xattr-totals filtered to our own keys
+read_totals()
+{
+	t_force_log_merge
+	sync
+	echo 1 > $(t_debugfs_path)/drop_weak_item_cache
+	scoutfs read-xattr-totals -p "$T_M0" | \
+		grep -E '^8888\.' || true
+}
+
+echo "== setup three files contributing to totl 8888.0.0"
+touch "$T_D0/f1" "$T_D0/f2" "$T_D0/f3"
+setfattr -n scoutfs.totl.inj.8888.0.0 -v 2  "$T_D0/f1"
+setfattr -n scoutfs.totl.inj.8888.0.0 -v 8  "$T_D0/f2"
+setfattr -n scoutfs.totl.inj.8888.0.0 -v 32 "$T_D0/f3"
+
+echo "== merge baseline into fs_root"
+read_totals
+
+echo "== inject (+128, +2) unbalances totl 8888.0.0"
+totl-delta-inject "$T_M0" 8888.0.0 128 2
+read_totals
+
+echo "== unlink f3 (value 32) produces a -32/-1 delta"
+rm -f "$T_D0/f3"
+read_totals
+
+echo "== inject (-128, -2) restores accounting for the remaining files"
+totl-delta-inject "$T_M0" 8888.0.0 -128 -2
+read_totals
+
+echo "== cleanup"
+rm -f "$T_D0/f1" "$T_D0/f2"
+read_totals
+
+t_pass

utils/sparse.sh

@@ -71,7 +71,7 @@ else
 	m64=""
 fi
 
-sparse $m64 $include $search/include "$@" 2>&1 | grep -v -E "($RE)" | tee .sparse.output
+sparse $m64 $include $search/include "$@" 2>&1 | egrep -v "($RE)" | tee .sparse.output
 
 rm -f $defines