scoutfs_item_create checks wrong lock mode

scoutfs_item_create() was checking that its lock had a read mode, when
it should have been checking for a write mode.  This worked out because
callers with write mode locks are also protecting reads.

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

kmod/src/Makefile

@@ -34,6 +34,7 @@ scoutfs-y +=			\
 	options.o		\
 	per_task.o		\
 	quorum.o		\
+	quota.o			\
 	recov.o			\
 	scoutfs_trace.o		\
 	server.o		\
@@ -42,10 +43,12 @@ scoutfs-y +=			\
 	srch.o			\
 	super.o			\
 	sysfs.o			\
+	totl.o			\
 	trans.o			\
 	triggers.o		\
 	tseq.o			\
 	volopt.o		\
+	wkic.o			\
 	xattr.o
 
 #

kmod/src/counters.h

@@ -199,10 +199,7 @@
 	EXPAND_COUNTER(srch_read_stale)				\
 	EXPAND_COUNTER(statfs)					\
 	EXPAND_COUNTER(totl_read_copied)			\
-	EXPAND_COUNTER(totl_read_finalized)			\
-	EXPAND_COUNTER(totl_read_fs)				\
 	EXPAND_COUNTER(totl_read_item)				\
-	EXPAND_COUNTER(totl_read_logged)			\
 	EXPAND_COUNTER(trans_commit_data_alloc_low)		\
 	EXPAND_COUNTER(trans_commit_dirty_meta_full)		\
 	EXPAND_COUNTER(trans_commit_fsync)			\

kmod/src/data.c

@@ -1104,6 +1104,10 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 
 	while(iblock <= last) {
 
+		ret = scoutfs_quota_check_data(sb, inode);
+		if (ret)
+			goto out_extent;
+
 		ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, false, true);
 		if (ret)
 			goto out_extent;
@@ -1807,37 +1811,6 @@ int scoutfs_data_wait_check_iov(struct inode *inode, const struct iovec *iov,
 	return ret;
 }
 
-int scoutfs_data_wait_check_iter(struct inode *inode, loff_t pos, struct iov_iter *iter,
-				 u8 sef, u8 op, struct scoutfs_data_wait *dw,
-				 struct scoutfs_lock *lock)
-{
-	size_t count = iov_iter_count(iter);
-	size_t off = iter->iov_offset;
-	const struct iovec *iov;
-	size_t len;
-	int ret = 0;
-
-	for (iov = iter->iov; count > 0; iov++) {
-		len = iov->iov_len - off;
-		if (len == 0)
-			continue;
-
-		/* aren't we waiting on too much data here ? */
-		ret = scoutfs_data_wait_check(inode, pos, len,
-					      sef, op, dw, lock);
-
-		if (ret != 0)
-			break;
-
-
-		pos += len;
-		count -= len;
-		off = 0;
-	}
-
-	return ret;
-}
-
 int scoutfs_data_wait(struct inode *inode, struct scoutfs_data_wait *dw)
 {
 	DECLARE_DATA_WAIT_ROOT(inode->i_sb, rt);

kmod/src/data.h

@@ -65,9 +65,6 @@ int scoutfs_data_wait_check_iov(struct inode *inode, const struct iovec *iov,
 				unsigned long nr_segs, loff_t pos, u8 sef,
 				u8 op, struct scoutfs_data_wait *ow,
 				struct scoutfs_lock *lock);
-int scoutfs_data_wait_check_iter(struct inode *inode, loff_t pos, struct iov_iter *iter,
-				 u8 sef, u8 op, struct scoutfs_data_wait *ow,
-				 struct scoutfs_lock *lock);
 bool scoutfs_data_wait_found(struct scoutfs_data_wait *ow);
 int scoutfs_data_wait(struct inode *inode,
 			      struct scoutfs_data_wait *ow);

kmod/src/dir.c

@@ -34,6 +34,7 @@
 #include "forest.h"
 #include "acl.h"
 #include "counters.h"
+#include "quota.h"
 #include "scoutfs_trace.h"
 
 /*
@@ -651,6 +652,10 @@ static struct inode *lock_hold_create(struct inode *dir, struct dentry *dentry,
 	if (ret)
 		goto out_unlock;
 
+	ret = scoutfs_quota_check_inode(sb, dir);
+	if (ret)
+		goto out_unlock;
+
 	if (orph_lock) {
 		ret = scoutfs_lock_orphan(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, ino, orph_lock);
 		if (ret < 0)
@@ -672,6 +677,8 @@ retry:
 	if (ret < 0)
 		goto out;
 
+	scoutfs_inode_set_proj(inode, scoutfs_inode_get_proj(dir));
+
 	ret = scoutfs_dirty_inode_item(dir, *dir_lock);
 out:
 	if (ret)

kmod/src/file.c

@@ -28,6 +28,7 @@
 #include "inode.h"
 #include "per_task.h"
 #include "omap.h"
+#include "quota.h"
 
 #ifdef KC_LINUX_HAVE_FOP_AIO_READ
 /*
@@ -122,6 +123,10 @@ retry:
 			goto out;
 	}
 
+	ret = scoutfs_quota_check_data(sb, inode);
+	if (ret)
+		goto out;
+
 	/* XXX: remove SUID bit */
 
 	ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
@@ -171,10 +176,8 @@ retry:
 		goto out;
 
 	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, scoutfs_inode_lock)) {
-		ret = scoutfs_data_wait_check_iter(inode, iocb->ki_pos, to,
-						   SEF_OFFLINE,
-						   SCOUTFS_IOC_DWO_READ,
-						   &dw, scoutfs_inode_lock);
+		ret = scoutfs_data_wait_check(inode, iocb->ki_pos, iov_iter_count(to), SEF_OFFLINE,
+					      SCOUTFS_IOC_DWO_READ, &dw, scoutfs_inode_lock);
 		if (ret != 0)
 			goto out;
 	} else {
@@ -205,8 +208,7 @@ ssize_t scoutfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 	struct scoutfs_lock *scoutfs_inode_lock = NULL;
 	SCOUTFS_DECLARE_PER_TASK_ENTRY(pt_ent);
 	DECLARE_DATA_WAIT(dw);
-	int ret;
-	int written;
+	ssize_t ret;
 
 retry:
 	inode_lock(inode);
@@ -223,19 +225,21 @@ retry:
 	if (ret)
 		goto out;
 
+	ret = scoutfs_quota_check_data(sb, inode);
+	if (ret)
+		goto out;
+
 	if (scoutfs_per_task_add_excl(&si->pt_data_lock, &pt_ent, scoutfs_inode_lock)) {
 		/* data_version is per inode, whole file must be online */
-		ret = scoutfs_data_wait_check_iter(inode, iocb->ki_pos, from,
-						   SEF_OFFLINE,
-						   SCOUTFS_IOC_DWO_WRITE,
-						   &dw, scoutfs_inode_lock);
+		ret = scoutfs_data_wait_check(inode, 0, i_size_read(inode), SEF_OFFLINE,
+					      SCOUTFS_IOC_DWO_WRITE, &dw, scoutfs_inode_lock);
 		if (ret != 0)
 			goto out;
 	}
 
 	/* XXX: remove SUID bit */
 
-	written = __generic_file_write_iter(iocb, from);
+	ret = __generic_file_write_iter(iocb, from);
 
 out:
 	scoutfs_per_task_del(&si->pt_data_lock, &pt_ent);
@@ -248,10 +252,10 @@ out:
 			goto retry;
 	}
 
-	if (ret > 0 || ret == -EIOCBQUEUED)
-		ret = generic_write_sync(iocb, written);
+	if (ret > 0)
+		ret = generic_write_sync(iocb, ret);
 
-	return written ? written : ret;
+	return ret;
 }
 #endif
 

kmod/src/forest.c

@@ -238,19 +238,16 @@ static int forest_read_items(struct super_block *sb, struct scoutfs_key *key, u6
  * We return -ESTALE if we hit stale blocks to give the caller a chance
  * to reset their state and retry with a newer version of the btrees.
  */
-int scoutfs_forest_read_items(struct super_block *sb,
-			      struct scoutfs_key *key,
-			      struct scoutfs_key *bloom_key,
-			      struct scoutfs_key *start,
-			      struct scoutfs_key *end,
-			      scoutfs_forest_item_cb cb, void *arg)
+int scoutfs_forest_read_items_roots(struct super_block *sb, struct scoutfs_net_roots *roots,
+				    struct scoutfs_key *key, struct scoutfs_key *bloom_key,
+				    struct scoutfs_key *start, struct scoutfs_key *end,
+				    scoutfs_forest_item_cb cb, void *arg)
 {
 	struct forest_read_items_data rid = {
 		.cb = cb,
 		.cb_arg = arg,
 	};
 	struct scoutfs_log_trees lt;
-	struct scoutfs_net_roots roots;
 	struct scoutfs_bloom_block *bb;
 	struct forest_bloom_nrs bloom;
 	SCOUTFS_BTREE_ITEM_REF(iref);
@@ -264,18 +261,14 @@ int scoutfs_forest_read_items(struct super_block *sb,
 	scoutfs_inc_counter(sb, forest_read_items);
 	calc_bloom_nrs(&bloom, bloom_key);
 
-	ret = scoutfs_client_get_roots(sb, &roots);
-	if (ret)
-		goto out;
-
-	trace_scoutfs_forest_using_roots(sb, &roots.fs_root, &roots.logs_root);
+	trace_scoutfs_forest_using_roots(sb, &roots->fs_root, &roots->logs_root);
 
 	*start = orig_start;
 	*end = orig_end;
 
 	/* start with fs root items */
 	rid.fic |= FIC_FS_ROOT;
-	ret = scoutfs_btree_read_items(sb, &roots.fs_root, key, start, end,
+	ret = scoutfs_btree_read_items(sb, &roots->fs_root, key, start, end,
 				       forest_read_items, &rid);
 	if (ret < 0)
 		goto out;
@@ -283,7 +276,7 @@ int scoutfs_forest_read_items(struct super_block *sb,
 
 	scoutfs_key_init_log_trees(&ltk, 0, 0);
 	for (;; scoutfs_key_inc(&ltk)) {
-		ret = scoutfs_btree_next(sb, &roots.logs_root, &ltk, &iref);
+		ret = scoutfs_btree_next(sb, &roots->logs_root, &ltk, &iref);
 		if (ret == 0) {
 			if (iref.val_len == sizeof(lt)) {
 				ltk = *iref.key;
@@ -340,6 +333,23 @@ out:
 	return ret;
 }
 
+int scoutfs_forest_read_items(struct super_block *sb,
+			      struct scoutfs_key *key,
+			      struct scoutfs_key *bloom_key,
+			      struct scoutfs_key *start,
+			      struct scoutfs_key *end,
+			      scoutfs_forest_item_cb cb, void *arg)
+{
+	struct scoutfs_net_roots roots;
+	int ret;
+
+	ret = scoutfs_client_get_roots(sb, &roots);
+	if (ret == 0)
+		ret = scoutfs_forest_read_items_roots(sb, &roots, key, bloom_key, start, end,
+						      cb, arg);
+	return ret;
+}
+
 /*
  * If the items are deltas then combine the src with the destination
  * value and store the result in the destination.

kmod/src/forest.h

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

kmod/src/format.h

@@ -5,11 +5,16 @@
  * The format version defines the format of structures on devices,
  * structures that are communicated over the wire, and the protocol
  * behind the structures.
+ *
+ * Builds can have unique pre-release formats that are incompatible with
+ * every other build.  This lets people experiment with formats without
+ * accidentally corrupting data with release builds.
  */
-#define SCOUTFS_FORMAT_VERSION_MIN		1
+#define SCOUTFS_FORMAT_VERSION_MIN		0x8cf3b46619eb9975ULL
 #define SCOUTFS_FORMAT_VERSION_MIN_STR	__stringify(SCOUTFS_FORMAT_VERSION_MIN)
-#define SCOUTFS_FORMAT_VERSION_MAX		1
+#define SCOUTFS_FORMAT_VERSION_MAX		0x8cf3b46619eb9975ULL
 #define SCOUTFS_FORMAT_VERSION_MAX_STR	__stringify(SCOUTFS_FORMAT_VERSION_MAX)
+#define SCOUTFS_FORMAT_VER_PREREL		0x8000000000000000ULL
 
 /* statfs(2) f_type */
 #define SCOUTFS_SUPER_MAGIC	0x554f4353		/* "SCOU" */
@@ -175,11 +180,20 @@ struct scoutfs_key {
 #define sko_rid		_sk_first
 #define sko_ino		_sk_second
 
+/* quota rules */
+#define skqr_hash	_sk_second
+#define skqr_coll_nr	_sk_third
+
 /* xattr totl */
 #define skxt_a		_sk_first
 #define skxt_b		_sk_second
 #define skxt_c		_sk_third
 
+/* xattr index */
+#define skxi_a		_sk_first
+#define skxi_b		_sk_second
+#define skxi_ino	_sk_third
+
 /* inode */
 #define ski_ino		_sk_first
 
@@ -585,7 +599,9 @@ struct scoutfs_log_merge_freeing {
  */
 #define SCOUTFS_INODE_INDEX_ZONE		4
 #define SCOUTFS_ORPHAN_ZONE			8
+#define SCOUTFS_QUOTA_ZONE			10
 #define SCOUTFS_XATTR_TOTL_ZONE			12
+#define SCOUTFS_XATTR_INDX_ZONE			14
 #define SCOUTFS_FS_ZONE				16
 #define SCOUTFS_LOCK_ZONE			20
 /* Items only stored in server btrees */
@@ -608,6 +624,9 @@ struct scoutfs_log_merge_freeing {
 /* orphan zone, redundant type used for clarity */
 #define SCOUTFS_ORPHAN_TYPE			4
 
+/* quota zone */
+#define SCOUTFS_QUOTA_RULE_TYPE			4
+
 /* fs zone */
 #define SCOUTFS_INODE_TYPE			4
 #define SCOUTFS_XATTR_TYPE			8
@@ -661,6 +680,34 @@ struct scoutfs_xattr_totl_val {
 	__le64 count;
 };
 
+#define SQ_RF_TOTL_COUNT	(1 << 0)
+#define SQ_RF__UNKNOWN	(~((1 << 1) - 1))
+
+#define SQ_NS_LITERAL		0
+#define SQ_NS_PROJ		1
+#define SQ_NS_UID		2
+#define SQ_NS_GID		3
+#define SQ_NS__NR		4
+#define SQ_NS__NR_SELECT	(SQ_NS__NR - 1) /* !literal */
+
+#define SQ_NF_SELECT	(1 << 0)
+#define SQ_NF__UNKNOWN	(~((1 << 1) - 1))
+
+#define SQ_OP_INODE	0
+#define SQ_OP_DATA	1
+#define SQ_OP__NR	2
+
+struct scoutfs_quota_rule_val {
+	__le64 name_val[3];
+	__le64 limit;
+	__u8 prio;
+	__u8 op;
+	__u8 rule_flags;
+	__u8 name_source[3];
+	__u8 name_flags[3];
+	__u8 _pad[7];
+};
+
 /* XXX does this exist upstream somewhere? */
 #define member_sizeof(TYPE, MEMBER) (sizeof(((TYPE *)0)->MEMBER))
 
@@ -849,6 +896,7 @@ struct scoutfs_inode {
 	__le64 next_readdir_pos;
 	__le64 next_xattr_id;
 	__le64 version;
+	__le64 proj;
 	__le32 nlink;
 	__le32 uid;
 	__le32 gid;

kmod/src/inode.c

@@ -275,6 +275,7 @@ static void load_inode(struct inode *inode, struct scoutfs_inode *cinode)
 	si->offline_blocks = le64_to_cpu(cinode->offline_blocks);
 	si->next_readdir_pos = le64_to_cpu(cinode->next_readdir_pos);
 	si->next_xattr_id = le64_to_cpu(cinode->next_xattr_id);
+	si->proj = le64_to_cpu(cinode->proj);
 	si->flags = le32_to_cpu(cinode->flags);
 	si->crtime.tv_sec = le64_to_cpu(cinode->crtime.sec);
 	si->crtime.tv_nsec = le32_to_cpu(cinode->crtime.nsec);
@@ -694,6 +695,31 @@ void scoutfs_inode_get_onoff(struct inode *inode, s64 *on, s64 *off)
 	} while (read_seqcount_retry(&si->seqcount, seq));
 }
 
+u64 scoutfs_inode_get_proj(struct inode *inode)
+{
+	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
+	unsigned int seq;
+	u64 proj;
+
+	do {
+		seq = read_seqcount_begin(&si->seqcount);
+		proj = si->proj;
+	} while (read_seqcount_retry(&si->seqcount, seq));
+
+	return proj;
+}
+
+void scoutfs_inode_set_proj(struct inode *inode, u64 proj)
+{
+	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
+
+	preempt_disable();
+	write_seqcount_begin(&si->seqcount);
+	si->proj = proj;
+	write_seqcount_end(&si->seqcount);
+	preempt_enable();
+}
+
 static int scoutfs_iget_test(struct inode *inode, void *arg)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
@@ -835,6 +861,7 @@ static void store_inode(struct scoutfs_inode *cinode, struct inode *inode)
 	cinode->offline_blocks = cpu_to_le64(offline_blocks);
 	cinode->next_readdir_pos = cpu_to_le64(si->next_readdir_pos);
 	cinode->next_xattr_id = cpu_to_le64(si->next_xattr_id);
+	cinode->proj = cpu_to_le64(si->proj);
 	cinode->flags = cpu_to_le32(si->flags);
 	cinode->crtime.sec = cpu_to_le64(si->crtime.tv_sec);
 	cinode->crtime.nsec = cpu_to_le32(si->crtime.tv_nsec);
@@ -1478,6 +1505,7 @@ int scoutfs_new_inode(struct super_block *sb, struct inode *dir, umode_t mode, d
 	si->offline_blocks = 0;
 	si->next_readdir_pos = SCOUTFS_DIRENT_FIRST_POS;
 	si->next_xattr_id = 0;
+	si->proj = 0;
 	si->have_item = false;
 	atomic64_set(&si->last_refreshed, lock->refresh_gen);
 	scoutfs_lock_add_coverage(sb, lock, &si->ino_lock_cov);

kmod/src/inode.h

@@ -21,6 +21,7 @@ struct scoutfs_inode_info {
 	u64 data_version;
 	u64 online_blocks;
 	u64 offline_blocks;
+	u64 proj;
 	u32 flags;
 	struct kc_timespec crtime;
 
@@ -120,6 +121,9 @@ u64 scoutfs_inode_meta_seq(struct inode *inode);
 u64 scoutfs_inode_data_seq(struct inode *inode);
 u64 scoutfs_inode_data_version(struct inode *inode);
 void scoutfs_inode_get_onoff(struct inode *inode, s64 *on, s64 *off);
+u64 scoutfs_inode_get_proj(struct inode *inode);
+void scoutfs_inode_set_proj(struct inode *inode, u64 proj);
+
 int scoutfs_complete_truncate(struct inode *inode, struct scoutfs_lock *lock);
 
 int scoutfs_inode_refresh(struct inode *inode, struct scoutfs_lock *lock);

kmod/src/ioctl.c

@@ -42,6 +42,9 @@
 #include "alloc.h"
 #include "server.h"
 #include "counters.h"
+#include "totl.h"
+#include "wkic.h"
+#include "quota.h"
 #include "scoutfs_trace.h"
 
 /*
@@ -1035,124 +1038,32 @@ out:
 	return ret;
 }
 
-struct xattr_total_entry {
-	struct rb_node node;
-	struct scoutfs_ioctl_xattr_total xt;
-	u64 fs_seq;
-	u64 fs_total;
-	u64 fs_count;
-	u64 fin_seq;
-	u64 fin_total;
-	s64 fin_count;
-	u64 log_seq;
-	u64 log_total;
-	s64 log_count;
+struct read_xattr_total_iter_cb_args {
+	struct scoutfs_ioctl_xattr_total *xt;
+	unsigned int copied;
+	unsigned int total;
 };
 
-static int cmp_xt_entry_name(const struct xattr_total_entry *a,
-			     const struct xattr_total_entry *b)
-
-{
-	return scoutfs_cmp_u64s(a->xt.name[0], b->xt.name[0]) ?:
-	       scoutfs_cmp_u64s(a->xt.name[1], b->xt.name[1]) ?:
-	       scoutfs_cmp_u64s(a->xt.name[2], b->xt.name[2]);
-}
-
 /*
- * Record the contribution of the three classes of logged items we can
- * see: the item in the fs_root, items from finalized log btrees, and
- * items from active log btrees.  Once we have the full set the caller
- * can decide which of the items contribute to the total it sends to the
- * user.
+ * This is called under an RCU read lock so it can't copy to userspace.
  */
-static int read_xattr_total_item(struct super_block *sb, struct scoutfs_key *key,
-				 u64 seq, u8 flags, void *val, int val_len, int fic, void *arg)
+static int read_xattr_total_iter_cb(struct scoutfs_key *key, void *val, unsigned int val_len,
+				    void *cb_arg)
 {
+	struct read_xattr_total_iter_cb_args *cba = cb_arg;
 	struct scoutfs_xattr_totl_val *tval = val;
-	struct xattr_total_entry *ent;
-	struct xattr_total_entry rd;
-	struct rb_root *root = arg;
-	struct rb_node *parent;
-	struct rb_node **node;
-	int cmp;
+	struct scoutfs_ioctl_xattr_total *xt = &cba->xt[cba->copied];
 
-	rd.xt.name[0] = le64_to_cpu(key->skxt_a);
-	rd.xt.name[1] = le64_to_cpu(key->skxt_b);
-	rd.xt.name[2] = le64_to_cpu(key->skxt_c);
+	xt->name[0] = le64_to_cpu(key->skxt_a);
+	xt->name[1] = le64_to_cpu(key->skxt_b);
+	xt->name[2] = le64_to_cpu(key->skxt_c);
+	xt->total = le64_to_cpu(tval->total);
+	xt->count = le64_to_cpu(tval->count);
 
-	/* find entry matching name */
-	node = &root->rb_node;
-	parent = NULL;
-	cmp = -1;
-	while (*node) {
-		parent = *node;
-		ent = container_of(*node, struct xattr_total_entry, node);
-
-		/* sort merge items by key then newest to oldest */
-		cmp = cmp_xt_entry_name(&rd, ent);
-		if (cmp < 0)
-			node = &(*node)->rb_left;
-		else if (cmp > 0)
-			node = &(*node)->rb_right;
-		else
-			break;
-	}
-
-	/* allocate and insert new node if we need to */
-	if (cmp != 0) {
-		ent = kzalloc(sizeof(*ent), GFP_KERNEL);
-		if (!ent)
-			return -ENOMEM;
-
-		memcpy(&ent->xt.name, &rd.xt.name, sizeof(ent->xt.name));
-
-		rb_link_node(&ent->node, parent, node);
-		rb_insert_color(&ent->node, root);
-	}
-
-	if (fic & FIC_FS_ROOT) {
-		ent->fs_seq = seq;
-		ent->fs_total = le64_to_cpu(tval->total);
-		ent->fs_count = le64_to_cpu(tval->count);
-	} else if (fic & FIC_FINALIZED) {
-		ent->fin_seq = seq;
-		ent->fin_total += le64_to_cpu(tval->total);
-		ent->fin_count += le64_to_cpu(tval->count);
-	} else {
-		ent->log_seq = seq;
-		ent->log_total += le64_to_cpu(tval->total);
-		ent->log_count += le64_to_cpu(tval->count);
-	}
-
-	scoutfs_inc_counter(sb, totl_read_item);
-
-	return 0;
-}
-
-/* these are always _safe, node stores next */
-#define for_each_xt_ent(ent, node, root)					\
-	for (node = rb_first(root);						\
-	     node && (ent = rb_entry(node, struct xattr_total_entry, node),	\
-		      node = rb_next(node), 1); )
-
-#define for_each_xt_ent_reverse(ent, node, root)				\
-	for (node = rb_last(root);						\
-	     node && (ent = rb_entry(node, struct xattr_total_entry, node),	\
-		      node = rb_prev(node), 1); )
-
-static void free_xt_ent(struct rb_root *root, struct xattr_total_entry *ent)
-{
-	rb_erase(&ent->node, root);
-	kfree(ent);
-}
-
-static void free_all_xt_ents(struct rb_root *root)
-{
-	struct xattr_total_entry *ent;
-	struct rb_node *node;
-
-	for_each_xt_ent(ent, node, root)
-		free_xt_ent(root, ent);
+	if (++cba->copied < cba->total)
+		return -EAGAIN;
+	else
+		return 0;
 }
 
 /*
@@ -1162,30 +1073,6 @@ static void free_all_xt_ents(struct rb_root *root)
  * have been committed.  It doesn't use locking to force commits and
  * block writers so it can be a little bit out of date with respect to
  * dirty xattrs in memory across the system.
- *
- * Our reader has to be careful because the log btree merging code can
- * write partial results to the fs_root.  This means that a reader can
- * see both cases where new finalized logs should be applied to the old
- * fs items and where old finalized logs have already been applied to
- * the partially merged fs items.  Currently active logged items are
- * always applied on top of all cases.
- *
- * These cases are differentiated with a combination of sequence numbers
- * in items, the count of contributing xattrs, and a flag
- * differentiating finalized and active logged items.  This lets us
- * recognize all cases, including when finalized logs were merged and
- * deleted the fs item.
- *
- * We're allocating a tracking struct for each totl name we see while
- * traversing the item btrees.  The forest reader is providing the items
- * it finds in leaf blocks that contain the search key.  In the worst
- * case all of these blocks are full and none of the items overlap.  At
- * most, figure order a thousand names per mount.  But in practice many
- * of these factors fall away: leaf blocks aren't fill, leaf items
- * overlap, there aren't finalized log btrees, and not all mounts are
- * actively changing totals.   We're much more likely to only read a
- * leaf block's worth of totals that have been long since merged into
- * the fs_root.
  */
 static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 {
@@ -1193,14 +1080,13 @@ static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 	struct scoutfs_ioctl_read_xattr_totals __user *urxt = (void __user *)arg;
 	struct scoutfs_ioctl_read_xattr_totals rxt;
 	struct scoutfs_ioctl_xattr_total __user *uxt;
-	struct xattr_total_entry *ent;
+	struct read_xattr_total_iter_cb_args cba = {NULL, };
+	struct scoutfs_key range_start;
+	struct scoutfs_key range_end;
 	struct scoutfs_key key;
-	struct scoutfs_key bloom_key;
-	struct scoutfs_key start;
-	struct scoutfs_key end;
-	struct rb_root root = RB_ROOT;
-	struct rb_node *node;
-	int count = 0;
+	unsigned int copied = 0;
+	unsigned int total;
+	unsigned int ready;
 	int ret;
 
 	if (!(file->f_mode & FMODE_READ)) {
@@ -1213,6 +1099,13 @@ static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 		goto out;
 	}
 
+	cba.xt = (void *)__get_free_page(GFP_KERNEL);
+	if (!cba.xt) {
+		ret = -ENOMEM;
+		goto out;
+	}
+	cba.total = PAGE_SIZE / sizeof(struct scoutfs_ioctl_xattr_total);
+
 	if (copy_from_user(&rxt, urxt, sizeof(rxt))) {
 		ret = -EFAULT;
 		goto out;
@@ -1225,101 +1118,40 @@ static long scoutfs_ioc_read_xattr_totals(struct file *file, unsigned long arg)
 		goto out;
 	}
 
-	scoutfs_key_set_zeros(&bloom_key);
-	bloom_key.sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
-	scoutfs_xattr_init_totl_key(&start, rxt.pos_name);
+	total = div_u64(min_t(u64, rxt.totals_bytes, INT_MAX),
+			sizeof(struct scoutfs_ioctl_xattr_total));
 
-	while (rxt.totals_bytes >= sizeof(struct scoutfs_ioctl_xattr_total)) {
+	scoutfs_totl_set_range(&range_start, &range_end);
+	scoutfs_xattr_init_totl_key(&key, rxt.pos_name);
 
-		scoutfs_key_set_ones(&end);
-		end.sk_zone = SCOUTFS_XATTR_TOTL_ZONE;
-		if (scoutfs_key_compare(&start, &end) > 0)
+	while (copied < total) {
+		cba.copied = 0;
+		ret = scoutfs_wkic_iterate(sb, &key, &range_end, &range_start, &range_end,
+					   read_xattr_total_iter_cb, &cba);
+		if (ret < 0)
+			goto out;
+
+		if (cba.copied == 0)
 			break;
 
-		key = start;
-		ret = scoutfs_forest_read_items(sb, &key, &bloom_key, &start, &end,
-						read_xattr_total_item, &root);
-		if (ret < 0) {
-			if (ret == -ESTALE) {
-				free_all_xt_ents(&root);
-				continue;
-			}
+		ready = min(total - copied, cba.copied);
+
+		if (copy_to_user(&uxt[copied], cba.xt, ready * sizeof(cba.xt[0]))) {
+			ret = -EFAULT;
 			goto out;
 		}
 
-		if (RB_EMPTY_ROOT(&root))
-			break;
-
-		/* trim totals that fall outside of the consistent range */
-		for_each_xt_ent(ent, node, &root) {
-			scoutfs_xattr_init_totl_key(&key, ent->xt.name);
-			if (scoutfs_key_compare(&key, &start) < 0) {
-				free_xt_ent(&root, ent);
-			} else {
-				break;
-			}
-		}
-		for_each_xt_ent_reverse(ent, node, &root) {
-			scoutfs_xattr_init_totl_key(&key, ent->xt.name);
-			if (scoutfs_key_compare(&key, &end) > 0) {
-				free_xt_ent(&root, ent);
-			} else {
-				break;
-			}
-		}
-
-		/* copy resulting unique non-zero totals to userspace */
-		for_each_xt_ent(ent, node, &root) {
-			if (rxt.totals_bytes < sizeof(ent->xt))
-				break;
-
-			/* start with the fs item if we have it */
-			if (ent->fs_seq != 0) {
-				ent->xt.total = ent->fs_total;
-				ent->xt.count = ent->fs_count;
-				scoutfs_inc_counter(sb, totl_read_fs);
-			}
-
-			/* apply finalized logs if they're newer or creating */
-			if (((ent->fs_seq != 0) && (ent->fin_seq > ent->fs_seq)) ||
-			    ((ent->fs_seq == 0) && (ent->fin_count > 0))) {
-				ent->xt.total += ent->fin_total;
-				ent->xt.count += ent->fin_count;
-				scoutfs_inc_counter(sb, totl_read_finalized);
-			}
-
-			/* always apply active logs which must be newer than fs and finalized */
-			if (ent->log_seq > 0) {
-				ent->xt.total += ent->log_total;
-				ent->xt.count += ent->log_count;
-				scoutfs_inc_counter(sb, totl_read_logged);
-			}
-
-			if (ent->xt.total != 0 || ent->xt.count != 0) {
-				if (copy_to_user(uxt, &ent->xt, sizeof(ent->xt))) {
-					ret = -EFAULT;
-					goto out;
-				}
-
-				uxt++;
-				rxt.totals_bytes -= sizeof(ent->xt);
-				count++;
-				scoutfs_inc_counter(sb, totl_read_copied);
-			}
-
-			free_xt_ent(&root, ent);
-		}
-
-		/* continue after the last possible key read */
-		start = end;
-		scoutfs_key_inc(&start);
+		scoutfs_xattr_init_totl_key(&key, cba.xt[ready - 1].name);
+		scoutfs_key_inc(&key);
+		copied += ready;
 	}
 
 	ret = 0;
 out:
-	free_all_xt_ents(&root);
+	if (cba.xt)
+		free_page((long)cba.xt);
 
-	return ret ?: count;
+	return ret ?: copied;
 }
 
 static long scoutfs_ioc_get_allocated_inos(struct file *file, unsigned long arg)
@@ -1504,6 +1336,254 @@ out:
 	return nr ?: ret;
 }
 
+static long scoutfs_ioc_get_project_id(struct file *file, unsigned long arg)
+{
+	struct inode *inode = file_inode(file);
+	struct super_block *sb = inode->i_sb;
+	u64 __user *uproj = (void __user *)arg;
+	struct scoutfs_lock *lock = NULL;
+	u64 proj;
+	int ret;
+
+	if (!capable(CAP_DAC_READ_SEARCH))
+		return -EPERM;
+
+	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_READ,
+				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
+	if (ret == 0) {
+		proj = scoutfs_inode_get_proj(inode);
+		scoutfs_unlock(sb, lock, SCOUTFS_LOCK_READ);
+	}
+
+	if (ret == 0 && __put_user(proj, uproj))
+		ret = -EFAULT;
+
+	return ret;
+}
+
+static long scoutfs_ioc_set_project_id(struct file *file, unsigned long arg)
+{
+	struct inode *inode = file_inode(file);
+	struct super_block *sb = inode->i_sb;
+	u64 __user *uproj = (void __user *)arg;
+	struct scoutfs_lock *lock = NULL;
+	LIST_HEAD(ind_locks);
+	u64 proj;
+	int ret;
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (get_user(proj, uproj))
+		return -EFAULT;
+
+	ret = scoutfs_lock_inode(sb, SCOUTFS_LOCK_WRITE,
+				 SCOUTFS_LKF_REFRESH_INODE, inode, &lock);
+	if (ret < 0)
+		return ret;
+
+	if (scoutfs_inode_get_proj(inode) == proj) {
+		ret = 0;
+		goto out_unlock;
+	}
+
+	ret = scoutfs_inode_index_lock_hold(inode, &ind_locks, false, false);
+	if (ret)
+		goto out_unlock;
+
+	ret = scoutfs_dirty_inode_item(inode, lock);
+	if (ret < 0)
+		goto out_release;
+
+	scoutfs_inode_set_proj(inode, proj);
+	scoutfs_update_inode_item(inode, lock, &ind_locks);
+
+	ret = 0;
+out_release:
+	scoutfs_release_trans(sb);
+	scoutfs_inode_index_unlock(sb, &ind_locks);
+out_unlock:
+	scoutfs_unlock(sb, lock, SCOUTFS_LOCK_WRITE);
+
+	return ret;
+}
+
+static long scoutfs_ioc_get_quota_rules(struct file *file, unsigned long arg)
+{
+	struct super_block *sb = file_inode(file)->i_sb;
+	struct scoutfs_ioctl_get_quota_rules __user *ugqr = (void __user *)arg;
+	struct scoutfs_ioctl_get_quota_rules gqr;
+	struct scoutfs_ioctl_quota_rule __user *uirules;
+	struct scoutfs_ioctl_quota_rule *irules;
+	struct page *page = NULL;
+	int copied = 0;
+	int nr;
+	int ret;
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (copy_from_user(&gqr, ugqr, sizeof(gqr)))
+		return -EFAULT;
+
+	if (gqr.rules_nr == 0)
+		return 0;
+
+	uirules = (void __user *)gqr.rules_ptr;
+	/* limit rules copied per call */
+	gqr.rules_nr = min_t(u64, gqr.rules_nr, INT_MAX);
+
+	page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+	if (!page) {
+		ret = -ENOMEM;
+		goto out;
+	}
+	irules = page_address(page);
+
+	while (copied < gqr.rules_nr) {
+		nr = min_t(u64, gqr.rules_nr - copied,
+				PAGE_SIZE / sizeof(struct scoutfs_ioctl_quota_rule));
+		ret = scoutfs_quota_get_rules(sb, gqr.iterator, page_address(page), nr);
+		if (ret <= 0)
+			goto out;
+
+		if (copy_to_user(&uirules[copied], irules, ret * sizeof(irules[0]))) {
+			ret = -EFAULT;
+			goto out;
+		}
+
+		copied += ret;
+	}
+
+	ret = 0;
+out:
+	if (page)
+		__free_page(page);
+
+	if (ret == 0 && copy_to_user(ugqr->iterator, gqr.iterator, sizeof(gqr.iterator)))
+		ret = -EFAULT;
+
+	return ret ?: copied;
+}
+
+static long scoutfs_ioc_mod_quota_rule(struct file *file, unsigned long arg, bool is_add)
+{
+	struct super_block *sb = file_inode(file)->i_sb;
+	struct scoutfs_ioctl_quota_rule __user *uirule = (void __user *)arg;
+	struct scoutfs_ioctl_quota_rule irule;
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (copy_from_user(&irule, uirule, sizeof(irule)))
+		return -EFAULT;
+
+	return scoutfs_quota_mod_rule(sb, is_add, &irule);
+}
+
+struct read_index_buf {
+	int nr;
+	int size;
+	struct scoutfs_ioctl_xattr_index_entry ents[0];
+};
+
+#define READ_INDEX_BUF_MAX_ENTS \
+	((PAGE_SIZE - sizeof(struct read_index_buf)) / \
+		sizeof(struct scoutfs_ioctl_xattr_index_entry))
+
+static int read_index_cb(struct scoutfs_key *key, void *val, unsigned int val_len, void *cb_arg)
+{
+	struct read_index_buf *rib = cb_arg;
+	struct scoutfs_ioctl_xattr_index_entry *ent = &rib->ents[rib->nr];
+
+	if (val_len != 0)
+		return -EIO;
+
+	ent->a = le64_to_cpu(key->skxi_a);
+	ent->b = le64_to_cpu(key->skxi_b);
+	ent->ino = le64_to_cpu(key->skxi_ino);
+
+	if (++rib->nr == rib->size)
+		return rib->nr;
+
+	return -EAGAIN;
+}
+
+static long scoutfs_ioc_read_xattr_index(struct file *file, unsigned long arg)
+{
+	struct super_block *sb = file_inode(file)->i_sb;
+	struct scoutfs_ioctl_read_xattr_index __user *urxi = (void __user *)arg;
+	struct scoutfs_ioctl_xattr_index_entry __user *uents;
+	struct scoutfs_ioctl_xattr_index_entry *ent;
+	struct scoutfs_ioctl_read_xattr_index rxi;
+	struct read_index_buf *rib;
+	struct page *page = NULL;
+	struct scoutfs_key first;
+	struct scoutfs_key last;
+	struct scoutfs_key start;
+	struct scoutfs_key end;
+	int copied = 0;
+	int ret;
+
+	if (!capable(CAP_SYS_ADMIN)) {
+		ret = -EPERM;
+		goto out;
+	}
+
+	if (copy_from_user(&rxi, urxi, sizeof(rxi))) {
+		ret = -EFAULT;
+		goto out;
+	}
+	uents = (void __user *)rxi.entries_ptr;
+	rxi.entries_nr = min_t(u64, rxi.entries_nr, INT_MAX);
+
+	page = alloc_page(GFP_KERNEL);
+	if (!page) {
+		ret = -ENOMEM;
+		goto out;
+	}
+	rib = page_address(page);
+
+	scoutfs_xattr_init_indx_key(&first, rxi.first.a, rxi.first.b, rxi.first.ino);
+	scoutfs_xattr_init_indx_key(&last, rxi.last.a, rxi.last.b, rxi.last.ino);
+	scoutfs_xattr_indx_get_range(&start, &end);
+
+	if (scoutfs_key_compare(&first, &last) > 0) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	while (copied < rxi.entries_nr) {
+		rib->nr = 0;
+		rib->size = min_t(u64, rxi.entries_nr - copied, READ_INDEX_BUF_MAX_ENTS);
+		ret = scoutfs_wkic_iterate(sb, &first, &last, &start, &end,
+					   read_index_cb, rib);
+		if (ret < 0)
+			goto out;
+		if (rib->nr == 0)
+			break;
+
+		if (copy_to_user(&uents[copied], rib->ents, rib->nr * sizeof(rib->ents[0]))) {
+			ret = -EFAULT;
+			goto out;
+		}
+
+		copied += rib->nr;
+
+		ent = &rib->ents[rib->nr - 1];
+		scoutfs_xattr_init_indx_key(&first, ent->a, ent->b, ent->ino);
+		scoutfs_key_inc(&first);
+	}
+
+	ret = copied;
+
+out:
+	if (page)
+		__free_page(page);
+
+	return ret;
+}
+
 long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	switch (cmd) {
@@ -1541,6 +1621,18 @@ long scoutfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 		return scoutfs_ioc_get_allocated_inos(file, arg);
 	case SCOUTFS_IOC_GET_REFERRING_ENTRIES:
 		return scoutfs_ioc_get_referring_entries(file, arg);
+	case SCOUTFS_IOC_GET_PROJECT_ID:
+		return scoutfs_ioc_get_project_id(file, arg);
+	case SCOUTFS_IOC_SET_PROJECT_ID:
+		return scoutfs_ioc_set_project_id(file, arg);
+	case SCOUTFS_IOC_GET_QUOTA_RULES:
+		return scoutfs_ioc_get_quota_rules(file, arg);
+	case SCOUTFS_IOC_ADD_QUOTA_RULE:
+		return scoutfs_ioc_mod_quota_rule(file, arg, true);
+	case SCOUTFS_IOC_DEL_QUOTA_RULE:
+		return scoutfs_ioc_mod_quota_rule(file, arg, false);
+	case SCOUTFS_IOC_READ_XATTR_INDEX:
+		return scoutfs_ioc_read_xattr_index(file, arg);
 	}
 
 	return -ENOTTY;

kmod/src/ioctl.h

@@ -673,4 +673,100 @@ struct scoutfs_ioctl_dirent {
 #define SCOUTFS_IOC_GET_REFERRING_ENTRIES \
 	_IOW(SCOUTFS_IOCTL_MAGIC, 17, struct scoutfs_ioctl_get_referring_entries)
 
+#define SCOUTFS_IOC_GET_PROJECT_ID \
+	_IOR(SCOUTFS_IOCTL_MAGIC, 18, __u64)
+#define SCOUTFS_IOC_SET_PROJECT_ID \
+	_IOW(SCOUTFS_IOCTL_MAGIC, 19, __u64)
+
+/*
+ * (These fields are documented in the order that they're displayed by
+ * the scoutfs cli utility which matches the sort order of the rules.)
+ *
+ * @prio: The priority of the rule.  Rules are sorted by their fields
+ * with prio at the highest magnitude.  When multiple rules match the
+ * rule with the highest sort order is enforced.  The priority field
+ * lets rules override the default field sort order.
+ *
+ * @name_val[3]: The three 64bit values that make up the name of the
+ * totl xattr whose total will be checked against the rule's limit to
+ * see if the quota rule has been exceeded.  The behavior of the values
+ * can be changed by their corresponding name_source and name_flags.
+ *
+ * @name_source[3]: The SQ_NS_ enums that control where the value comes
+ * from.  _LITERAL uses the value from name_val.  Inode attribute
+ * sources (_PROJ, _UID, _GID) are taken from the inode of the operation
+ * that is being checked against the rule.
+ *
+ * @name_flags[3]: The SQ_NF_ enums that alter the name values.  _SELECT
+ * makes the rule only match if the inode attribute of the operation
+ * matches the attribute value stored in name_val.  This lets rules
+ * match a specific value of an attribute rather than mapping all
+ * attribute values of to totl names.
+ *
+ * @op: The SQ_OP_ enums which specify the operation that can't exceed
+ * the rule's limit.  _INODE checks inode creation and the inode
+ * attributes are taken from the inode that would be created.  _DATA
+ * checks file data block allocation and the inode fields come from the
+ * inode that is allocating the blocks.
+ *
+ * @limit: The 64bit value that is checked against the totl value
+ * described by the rule.  If the totl value is greater than or equal to
+ * this value of the matching rule then the operation will return
+ * -EDQUOT.
+ *
+ * @rule_flags: SQ_RF_TOTL_COUNT indicates that the rule's limit should
+ * be checked against the number of xattrs contributing to a totl value
+ * instead of the sum of the xattrs.
+ */
+struct scoutfs_ioctl_quota_rule {
+	__u64 name_val[3];
+	__u64 limit;
+	__u8 prio;
+	__u8 op;
+	__u8 rule_flags;
+	__u8 name_source[3];
+	__u8 name_flags[3];
+	__u8 _pad[7];
+};
+
+struct scoutfs_ioctl_get_quota_rules {
+	__u64 iterator[2];
+	__u64 rules_ptr;
+	__u64 rules_nr;
+};
+
+/*
+ * Rules are uniquely identified by their non-padded fields.  Addition will fail
+ * with -EEXIST if the specified rule already exists and deletion must find a rule
+ * with all matching fields to delete.
+ */
+#define SCOUTFS_IOC_GET_QUOTA_RULES \
+	_IOR(SCOUTFS_IOCTL_MAGIC, 20, struct scoutfs_ioctl_get_quota_rules)
+#define SCOUTFS_IOC_ADD_QUOTA_RULE \
+	_IOW(SCOUTFS_IOCTL_MAGIC, 21, struct scoutfs_ioctl_quota_rule)
+#define SCOUTFS_IOC_DEL_QUOTA_RULE \
+	_IOW(SCOUTFS_IOCTL_MAGIC, 22, struct scoutfs_ioctl_quota_rule)
+
+/*
+ * Inodes can be indexed in a global key space at a position determined
+ * by a single scoutfs.hide.indx xattr per inode.  The xattr sets the
+ * two index position values, with a being higher significance.
+ */
+struct scoutfs_ioctl_xattr_index_entry {
+	__u64 a;
+	__u64 b;
+	__u64 ino;
+};
+
+struct scoutfs_ioctl_read_xattr_index {
+	__u64 flags;
+	struct scoutfs_ioctl_xattr_index_entry first;
+	struct scoutfs_ioctl_xattr_index_entry last;
+	__u64 entries_ptr;
+	__u64 entries_nr;
+};
+
+#define SCOUTFS_IOC_READ_XATTR_INDEX \
+	_IOR(SCOUTFS_IOCTL_MAGIC, 23, struct scoutfs_ioctl_read_xattr_index)
+
 #endif

kmod/src/item.c

@@ -24,6 +24,7 @@
 #include "item.h"
 #include "forest.h"
 #include "block.h"
+#include "msg.h"
 #include "trans.h"
 #include "counters.h"
 #include "scoutfs_trace.h"
@@ -1670,13 +1671,24 @@ out:
 	return ret;
 }
 
-static int lock_safe(struct scoutfs_lock *lock, struct scoutfs_key *key,
+static int lock_safe(struct super_block *sb, struct scoutfs_lock *lock, struct scoutfs_key *key,
 		     int mode)
 {
-	if (WARN_ON_ONCE(!scoutfs_lock_protected(lock, key, mode)))
+	bool prot = scoutfs_lock_protected(lock, key, mode);
+
+	if (!prot) {
+		static bool once = false;
+		if (!once) {
+			scoutfs_err(sb, "lock (start "SK_FMT" end "SK_FMT" mode 0x%x) does not protect operation (key "SK_FMT" mode 0x%x)",
+				    SK_ARG(&lock->start), SK_ARG(&lock->end), lock->mode,
+				    SK_ARG(key), mode);
+			dump_stack();
+			once = true;
+		}
 		return -EINVAL;
-	else
-		return 0;
+	}
+
+	return 0;
 }
 
 static int optional_lock_mode_match(struct scoutfs_lock *lock, int mode)
@@ -1718,7 +1730,7 @@ int scoutfs_item_lookup(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_lookup);
 
-	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_READ)))
+	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_READ)))
 		goto out;
 
 	ret = get_cached_page(sb, cinf, lock, key, false, false, 0, &pg);
@@ -1793,7 +1805,7 @@ int scoutfs_item_next(struct super_block *sb, struct scoutfs_key *key,
 		goto out;
 	}
 
-	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_READ)))
+	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_READ)))
 		goto out;
 
 	pos = *key;
@@ -1874,7 +1886,7 @@ int scoutfs_item_dirty(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_dirty);
 
-	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_WRITE)))
+	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_WRITE)))
 		goto out;
 
 	ret = scoutfs_forest_set_bloom_bits(sb, lock);
@@ -1920,7 +1932,7 @@ static int item_create(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_create);
 
-	if ((ret = lock_safe(lock, key, mode)) ||
+	if ((ret = lock_safe(sb, lock, key, mode)) ||
 	    (ret = optional_lock_mode_match(primary, SCOUTFS_LOCK_WRITE)))
 		goto out;
 
@@ -1963,7 +1975,7 @@ int scoutfs_item_create(struct super_block *sb, struct scoutfs_key *key,
 			void *val, int val_len, struct scoutfs_lock *lock)
 {
 	return item_create(sb, key, val, val_len, lock, NULL,
-			   SCOUTFS_LOCK_READ, false);
+			   SCOUTFS_LOCK_WRITE, false);
 }
 
 int scoutfs_item_create_force(struct super_block *sb, struct scoutfs_key *key,
@@ -1994,7 +2006,7 @@ int scoutfs_item_update(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_update);
 
-	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_WRITE)))
+	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_WRITE)))
 		goto out;
 
 	ret = scoutfs_forest_set_bloom_bits(sb, lock);
@@ -2062,7 +2074,7 @@ int scoutfs_item_delta(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_delta);
 
-	if ((ret = lock_safe(lock, key, SCOUTFS_LOCK_WRITE_ONLY)))
+	if ((ret = lock_safe(sb, lock, key, SCOUTFS_LOCK_WRITE_ONLY)))
 		goto out;
 
 	ret = scoutfs_forest_set_bloom_bits(sb, lock);
@@ -2135,7 +2147,7 @@ static int item_delete(struct super_block *sb, struct scoutfs_key *key,
 
 	scoutfs_inc_counter(sb, item_delete);
 
-	if ((ret = lock_safe(lock, key, mode)) ||
+	if ((ret = lock_safe(sb, lock, key, mode)) ||
 	    (ret = optional_lock_mode_match(primary, SCOUTFS_LOCK_WRITE)))
 		goto out;
 

kmod/src/lock.c

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

kmod/src/lock.h

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

kmod/src/quota.h

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

kmod/src/scoutfs_trace.h

@@ -37,6 +37,10 @@
 #include "net.h"
 #include "data.h"
 #include "ext.h"
+#include "quota.h"
+
+#include "trace/quota.h"
+#include "trace/wkic.h"
 
 struct lock_info;
 

kmod/src/super.c

@@ -49,6 +49,8 @@
 #include "volopt.h"
 #include "fence.h"
 #include "xattr.h"
+#include "wkic.h"
+#include "quota.h"
 #include "scoutfs_trace.h"
 
 static struct dentry *scoutfs_debugfs_root;
@@ -194,7 +196,9 @@ static void scoutfs_put_super(struct super_block *sb)
 	scoutfs_shutdown_trans(sb);
 	scoutfs_volopt_destroy(sb);
 	scoutfs_client_destroy(sb);
+	scoutfs_quota_destroy(sb);
 	scoutfs_inode_destroy(sb);
+	scoutfs_wkic_destroy(sb);
 	scoutfs_item_destroy(sb);
 	scoutfs_forest_destroy(sb);
 	scoutfs_data_destroy(sb);
@@ -326,7 +330,7 @@ static int scoutfs_read_super_from_bdev(struct super_block *sb,
 
 	if (le64_to_cpu(super->fmt_vers) < SCOUTFS_FORMAT_VERSION_MIN ||
 	    le64_to_cpu(super->fmt_vers) > SCOUTFS_FORMAT_VERSION_MAX) {
-		scoutfs_err(sb, "super block has format version %llu outside of supported version range %u-%u",
+		scoutfs_err(sb, "super block has format version %llu outside of supported version range %llu-%llu",
 			    le64_to_cpu(super->fmt_vers), SCOUTFS_FORMAT_VERSION_MIN,
 			    SCOUTFS_FORMAT_VERSION_MAX);
 		ret = -EINVAL;
@@ -544,7 +548,9 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 	      scoutfs_block_setup(sb) ?:
 	      scoutfs_forest_setup(sb) ?:
 	      scoutfs_item_setup(sb) ?:
+	      scoutfs_wkic_setup(sb) ?:
 	      scoutfs_inode_setup(sb) ?:
+	      scoutfs_quota_setup(sb) ?:
 	      scoutfs_data_setup(sb) ?:
 	      scoutfs_setup_trans(sb) ?:
 	      scoutfs_omap_setup(sb) ?:
@@ -663,6 +669,10 @@ static int __init scoutfs_module_init(void)
 	if (ret)
 		return ret;
 
+	if (SCOUTFS_FORMAT_VERSION_MIN & SCOUTFS_FORMAT_VER_PREREL) {
+		printk(KERN_INFO "scoutfs module using incompatible pre-release format version 0x%016llx.  This module can only mount volumes with this version, and volumes with this version will be incompatible with all other release builds.", SCOUTFS_FORMAT_VERSION_MIN);
+	}
+
 	scoutfs_debugfs_root = debugfs_create_dir("scoutfs", NULL);
 	if (!scoutfs_debugfs_root) {
 		ret = -ENOMEM;

kmod/src/super.h

@@ -30,6 +30,8 @@ struct recov_info;
 struct omap_info;
 struct volopt_info;
 struct fence_info;
+struct wkic_info;
+struct squota_info;
 
 struct scoutfs_sb_info {
 	struct super_block *sb;
@@ -55,6 +57,8 @@ struct scoutfs_sb_info {
 	struct omap_info *omap_info;
 	struct volopt_info *volopt_info;
 	struct item_cache_info *item_cache_info;
+	struct wkic_info *wkic_info;
+	struct squota_info *squota_info;
 	struct fence_info *fence_info;
 
 	/* tracks tasks waiting for data extents */

kmod/src/totl.c

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

kmod/src/totl.h

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

kmod/src/trace/quota.h

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

kmod/src/trace/wkic.h

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

kmod/src/wkic.h

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

kmod/src/xattr.c

@@ -82,6 +82,7 @@ static void init_xattr_key(struct scoutfs_key *key, u64 ino, u32 name_hash,
 #define SCOUTFS_XATTR_PREFIX_LEN	(sizeof(SCOUTFS_XATTR_PREFIX) - 1)
 
 #define HIDE_TAG	"hide."
+#define INDX_TAG	"indx."
 #define SRCH_TAG	"srch."
 #define TOTL_TAG	"totl."
 #define TAG_LEN		(sizeof(HIDE_TAG) - 1)
@@ -103,6 +104,9 @@ int scoutfs_xattr_parse_tags(const char *name, unsigned int name_len,
 		if (!strncmp(name, HIDE_TAG, TAG_LEN)) {
 			if (++tgs->hide == 0)
 				return -EINVAL;
+		} else if (!strncmp(name, INDX_TAG, TAG_LEN)) {
+			if (++tgs->indx == 0)
+				return -EINVAL;
 		} else if (!strncmp(name, SRCH_TAG, TAG_LEN)) {
 			if (++tgs->srch == 0)
 				return -EINVAL;
@@ -540,47 +544,57 @@ static int parse_totl_u64(const char *s, int len, u64 *res)
 }
 
 /*
- * non-destructive relatively quick parse of the last 3 dotted u64s that
- * make up the name of the xattr total.  -EINVAL is returned if there
- * are anything but 3 valid u64 encodings between single dots at the end
- * of the name.
+ * non-destructive relatively quick parse of final dotted u64s in an
+ * xattr name.  If the required number of values are found then we
+ * return the number of bytes in the name that are not the final dotted
+ * u64s with their dots.  -EINVAL is returned if we didn't find the
+ * required number of values.
  */
-static int parse_totl_key(struct scoutfs_key *key, const char *name, int name_len)
+static int parse_dotted_u64s(u64 *u64s, int nr, const char *name, int name_len)
 {
-	u64 tot_name[3];
 	int end = name_len;
-	int nr = 0;
 	int len;
 	int ret;
 	int i;
+	int u;
 
 	/* parse name elements in reserve order from end of xattr name string */
-	for (i = name_len - 1; i >= 0 && nr < ARRAY_SIZE(tot_name); i--) {
+	for (u = nr - 1, i = name_len - 1; u >= 0 && i >= 0; i--) {
 		if (name[i] != '.')
 			continue;
 
 		len = end - (i + 1);
-		ret = parse_totl_u64(&name[i + 1], len, &tot_name[nr]);
+		ret = parse_totl_u64(&name[i + 1], len, &u64s[u]);
 		if (ret < 0)
 			goto out;
 
 		end = i;
-		nr++;
+		u--;
 	}
 
-	if (nr == ARRAY_SIZE(tot_name)) {
-		/* swap to account for parsing in reverse */
-		swap(tot_name[0], tot_name[2]);
-		scoutfs_xattr_init_totl_key(key, tot_name);
-		ret = 0;
-	} else {
+	if (u == -1)
+		ret = end;
+	else
 		ret = -EINVAL;
-	}
 
 out:
 	return ret;
 }
 
+static int parse_totl_key(struct scoutfs_key *key, const char *name, int name_len)
+{
+	u64 u64s[3];
+	int ret;
+
+	ret = parse_dotted_u64s(u64s, ARRAY_SIZE(u64s), name, name_len);
+	if (ret >= 0) {
+		scoutfs_xattr_init_totl_key(key, u64s);
+		ret = 0;
+	}
+
+	return ret;
+}
+
 static int apply_totl_delta(struct super_block *sb, struct scoutfs_key *key,
 			    struct scoutfs_xattr_totl_val *tval, struct scoutfs_lock *lock)
 {
@@ -607,6 +621,47 @@ int scoutfs_xattr_combine_totl(void *dst, int dst_len, void *src, int src_len)
 	return SCOUTFS_DELTA_COMBINED;
 }
 
+void scoutfs_xattr_indx_get_range(struct scoutfs_key *start, struct scoutfs_key *end)
+{
+	scoutfs_key_set_zeros(start);
+	start->sk_zone = SCOUTFS_XATTR_INDX_ZONE;
+	scoutfs_key_set_ones(end);
+	end->sk_zone = SCOUTFS_XATTR_INDX_ZONE;
+}
+
+void scoutfs_xattr_init_indx_key(struct scoutfs_key *key, u64 a, u64 b, u64 ino)
+{
+	scoutfs_key_set_zeros(key);
+	key->sk_zone = SCOUTFS_XATTR_INDX_ZONE;
+	key->skxi_a = cpu_to_le64(a);
+	key->skxi_b = cpu_to_le64(b);
+	key->skxi_ino = cpu_to_le64(ino);
+}
+
+/*
+ * indx keys have a restricted name so that there can only be one xattr
+ * that places in inode at a given position.  This lets us emit index
+ * items under CW cluster locks without reading to see if they exist or
+ * not.
+ */
+#define REQUIRED_INDEX_PREFIX "scoutfs.hide.indx"
+
+static int parse_indx_key(struct scoutfs_key *key, const char *name, int name_len, u64 ino)
+{
+	u64 u64s[2];
+	int ret;
+
+	ret = parse_dotted_u64s(u64s, ARRAY_SIZE(u64s), name, name_len);
+	if (ret < 0)
+		return ret;
+
+	if (!xattr_names_equal(name, ret, REQUIRED_INDEX_PREFIX, sizeof(REQUIRED_INDEX_PREFIX) - 1))
+		return -EINVAL;
+
+	scoutfs_xattr_init_indx_key(key, u64s[0], u64s[1], ino);
+	return 0;
+}
+
 /*
  * The confusing swiss army knife of creating, modifying, and deleting
  * xattrs.
@@ -627,7 +682,7 @@ int scoutfs_xattr_combine_totl(void *dst, int dst_len, void *src, int src_len)
 int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_len,
 			     const void *value, size_t size, int flags,
 			     const struct scoutfs_xattr_prefix_tags *tgs,
-			     struct scoutfs_lock *lck, struct scoutfs_lock *totl_lock,
+			     struct scoutfs_lock *lck, struct scoutfs_lock *tag_lock,
 			     struct list_head *ind_locks)
 {
 	struct scoutfs_inode_info *si = SCOUTFS_I(inode);
@@ -635,10 +690,11 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	const u64 ino = scoutfs_ino(inode);
 	struct scoutfs_xattr_totl_val tval = {0,};
 	struct scoutfs_xattr *xat = NULL;
-	struct scoutfs_key totl_key;
+	struct scoutfs_key tag_key;
 	struct scoutfs_key key;
 	bool undo_srch = false;
 	bool undo_totl = false;
+	bool undo_indx = false;
 	u8 found_parts;
 	unsigned int xat_bytes_totl;
 	unsigned int xat_bytes;
@@ -651,7 +707,8 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 
 	trace_scoutfs_xattr_set(sb, name_len, value, size, flags);
 
-	if (WARN_ON_ONCE(tgs->totl && !totl_lock))
+	if (WARN_ON_ONCE(tgs->totl && tgs->indx) ||
+	    WARN_ON_ONCE((tgs->totl | tgs->indx) && !tag_lock))
 		return -EINVAL;
 
 	/* mirror the syscall's errors for large names and values */
@@ -664,10 +721,13 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	    (flags & ~(XATTR_CREATE | XATTR_REPLACE)))
 		return -EINVAL;
 
-	if ((tgs->hide | tgs->srch | tgs->totl) && !capable(CAP_SYS_ADMIN))
+	if ((tgs->hide | tgs->indx | tgs->srch | tgs->totl) && !capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
-	if (tgs->totl && ((ret = parse_totl_key(&totl_key, name, name_len)) != 0))
+	if (tgs->totl && ((ret = parse_totl_key(&tag_key, name, name_len)) != 0))
+		return ret;
+
+	if (tgs->indx && ((ret = parse_indx_key(&tag_key, name, name_len, ino)) != 0))
 		return ret;
 
 	/* allocate enough to always read an existing xattr's totl */
@@ -718,6 +778,23 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 		le64_add_cpu(&tval.total, -total);
 	}
 
+	/*
+	 * indx xattrs don't have a value.  After returning an error for
+	 * non-zero val length or short circuiting modifying with the
+	 * same 0 length, all we're left with is creating or deleting
+	 * the xattr.
+	 */
+	if (tgs->indx) {
+		if (size != 0) {
+			ret = -EINVAL;
+			goto out;
+		}
+		if (found_parts && value) {
+			ret = 0;
+			goto out;
+		}
+	}
+
 	/* prepare the xattr header, name, and start of value in first item */
 	if (value) {
 		if (found_parts)
@@ -741,6 +818,16 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 		le64_add_cpu(&tval.total, total);
 	}
 
+	if (tgs->indx) {
+		if (value)
+			ret = scoutfs_item_create_force(sb, &tag_key, NULL, 0, tag_lock, NULL);
+		else
+			ret = scoutfs_item_delete_force(sb, &tag_key, tag_lock, NULL);
+		if (ret < 0)
+			goto out;
+		undo_indx = true;
+	}
+
 	if (tgs->srch && !(found_parts && value)) {
 		if (found_parts)
 			id = le64_to_cpu(key.skx_id);
@@ -752,7 +839,7 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	}
 
 	if (tgs->totl) {
-		ret = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
+		ret = apply_totl_delta(sb, &tag_key, &tval, tag_lock);
 		if (ret < 0)
 			goto out;
 		undo_totl = true;
@@ -777,6 +864,13 @@ int scoutfs_xattr_set_locked(struct inode *inode, const char *name, size_t name_
 	ret = 0;
 
 out:
+	if (ret < 0 && undo_indx) {
+		if (value)
+			err = scoutfs_item_delete_force(sb, &tag_key, tag_lock, NULL);
+		else
+			err = scoutfs_item_create_force(sb, &tag_key, NULL, 0, tag_lock, NULL);
+		BUG_ON(err); /* inconsistent */
+	}
 	if (ret < 0 && undo_srch) {
 		err = scoutfs_forest_srch_add(sb, hash, ino, id);
 		BUG_ON(err);
@@ -785,7 +879,7 @@ out:
 		/* _delta() on dirty items shouldn't fail */
 		tval.total = cpu_to_le64(-le64_to_cpu(tval.total));
 		tval.count = cpu_to_le64(-le64_to_cpu(tval.count));
-		err = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
+		err = apply_totl_delta(sb, &tag_key, &tval, tag_lock);
 		BUG_ON(err);
 	}
 
@@ -801,7 +895,7 @@ static int scoutfs_xattr_set(struct dentry *dentry, const char *name, const void
 	struct inode *inode = dentry->d_inode;
 	struct super_block *sb = inode->i_sb;
 	struct scoutfs_xattr_prefix_tags tgs;
-	struct scoutfs_lock *totl_lock = NULL;
+	struct scoutfs_lock *tag_lock = NULL;
 	struct scoutfs_lock *lck = NULL;
 	size_t name_len = strlen(name);
 	LIST_HEAD(ind_locks);
@@ -816,8 +910,11 @@ static int scoutfs_xattr_set(struct dentry *dentry, const char *name, const void
 	if (ret)
 		goto unlock;
 
-	if (tgs.totl) {
-		ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &totl_lock);
+	if (tgs.totl || tgs.indx) {
+		if (tgs.totl)
+			ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &tag_lock);
+		else
+			ret = scoutfs_lock_xattr_indx(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &tag_lock);
 		if (ret)
 			goto unlock;
 	}
@@ -836,7 +933,7 @@ retry:
 		goto release;
 
 	ret = scoutfs_xattr_set_locked(dentry->d_inode, name, name_len, value, size, flags, &tgs,
-				       lck, totl_lock, &ind_locks);
+				       lck, tag_lock, &ind_locks);
 	if (ret == 0)
 		scoutfs_update_inode_item(inode, lck, &ind_locks);
 
@@ -845,7 +942,7 @@ release:
 	scoutfs_inode_index_unlock(sb, &ind_locks);
 unlock:
 	scoutfs_unlock(sb, lck, SCOUTFS_LOCK_WRITE);
-	scoutfs_unlock(sb, totl_lock, SCOUTFS_LOCK_WRITE_ONLY);
+	scoutfs_unlock(sb, tag_lock, SCOUTFS_LOCK_WRITE_ONLY);
 
 	return ret;
 }
@@ -1055,14 +1152,15 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 {
 	struct scoutfs_xattr_prefix_tags tgs;
 	struct scoutfs_xattr *xat = NULL;
-	struct scoutfs_lock *totl_lock = NULL;
+	struct scoutfs_lock *tag_lock = NULL;
 	struct scoutfs_xattr_totl_val tval;
-	struct scoutfs_key totl_key;
+	struct scoutfs_key tag_key;
 	struct scoutfs_key last;
 	struct scoutfs_key key;
 	bool release = false;
 	unsigned int bytes;
 	unsigned int val_len;
+	u8 locked_zone = 0;
 	void *value;
 	u64 total;
 	u64 hash;
@@ -1108,16 +1206,36 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 				goto out;
 			}
 
-			ret = parse_totl_key(&totl_key, xat->name, xat->name_len) ?:
+			ret = parse_totl_key(&tag_key, xat->name, xat->name_len) ?:
 			      parse_totl_u64(value, val_len, &total);
 			if (ret < 0)
 				break;
 		}
 
-		if (tgs.totl && totl_lock == NULL) {
-			ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0, &totl_lock);
+		if (tgs.indx) {
+			ret = parse_indx_key(&tag_key, xat->name, xat->name_len, ino);
+			if (ret < 0)
+				goto out;
+		}
+
+		if ((tgs.totl || tgs.indx) && locked_zone != tag_key.sk_zone) {
+			if (tag_lock) {
+				if (release) {
+					scoutfs_release_trans(sb);
+					release = false;
+				}
+				scoutfs_unlock(sb, tag_lock, SCOUTFS_LOCK_WRITE_ONLY);
+				tag_lock = NULL;
+			}
+			if (tgs.totl)
+				ret = scoutfs_lock_xattr_totl(sb, SCOUTFS_LOCK_WRITE_ONLY, 0,
+							      &tag_lock);
+			else
+				ret = scoutfs_lock_xattr_indx(sb, SCOUTFS_LOCK_WRITE_ONLY, 0,
+							      &tag_lock);
 			if (ret < 0)
 				break;
+			locked_zone = tag_key.sk_zone;
 		}
 
 		ret = scoutfs_hold_trans(sb, false);
@@ -1140,11 +1258,17 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 		if (tgs.totl) {
 			tval.total = cpu_to_le64(-total);
 			tval.count = cpu_to_le64(-1LL);
-			ret = apply_totl_delta(sb, &totl_key, &tval, totl_lock);
+			ret = apply_totl_delta(sb, &tag_key, &tval, tag_lock);
 			if (ret < 0)
 				break;
 		}
 
+		if (tgs.indx) {
+			ret = scoutfs_item_delete_force(sb, &tag_key, tag_lock, NULL);
+			if (ret < 0)
+				goto out;
+		}
+
 		scoutfs_release_trans(sb);
 		release = false;
 
@@ -1153,7 +1277,7 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino,
 
 	if (release)
 		scoutfs_release_trans(sb);
-	scoutfs_unlock(sb, totl_lock, SCOUTFS_LOCK_WRITE_ONLY);
+	scoutfs_unlock(sb, tag_lock, SCOUTFS_LOCK_WRITE_ONLY);
 	kfree(xat);
 out:
 	return ret;

kmod/src/xattr.h

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

tests/.gitignore

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

tests/Makefile

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

tests/funcs/filter.sh

@@ -147,6 +147,8 @@ t_filter_dmesg()
 	# ignore systemd-journal rotating
 	re="$re|systemd-journald.*"
 
+	re="$re|incompatible pre-release format version"
+
 	egrep -v "($re)" | \
 		ignore_harmless_unwind_kasan_stack_oob
 }

tests/golden/projects

@@ -0,0 +1,22 @@
+== default new files don't have project
+0
+== set new project on files and dirs
+/mnt/test.0/test/projects/file: 1
+/mnt/test.0/test/projects/dir: 1
+== can use interesting IDs
+2147483647
+2147483648
+4294967295
+9223372036854775807
+9223372036854775808
+18446744073709551615
+== created files and dirs inherit project id
+/mnt/test.0/test/projects/dir/file: 1
+/mnt/test.0/test/projects/dir/sub: 1
+== inheritance continues
+1
+== clearing project id stops inheritance
+/mnt/test.0/test/projects/dir/another-file: 0
+/mnt/test.0/test/projects/dir/another-sub: 0
+== o_tmpfile creations inherit dir
+1

tests/golden/quota

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

tests/sequence

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

tests/src/o_tmpfile_linkat.c

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

tests/tests/projects.sh

@@ -0,0 +1,40 @@
+
+echo "== default new files don't have project"
+touch "$T_D0/file"
+scoutfs project-id -g "$T_D0/file"
+
+echo "== set new project on files and dirs"
+mkdir "$T_D0/dir"
+scoutfs project-id -s 1 "$T_D0/file" "$T_D0/dir"
+scoutfs project-id -g "$T_D0/file" "$T_D0/dir"
+
+echo "== can use interesting IDs"
+touch "$T_D0/ids"
+for id in         0x7FFFFFFF         0x80000000         0xFFFFFFFF \
+          0x7FFFFFFFFFFFFFFF 0x8000000000000000 0xFFFFFFFFFFFFFFFF; do
+	scoutfs project-id -s $id "$T_D0/ids"
+	scoutfs project-id -g "$T_D0/ids"
+done
+
+echo "== created files and dirs inherit project id"
+touch "$T_D0/dir/file"
+mkdir "$T_D0/dir/sub"
+scoutfs project-id -g "$T_D0/dir/file" "$T_D0/dir/sub"
+
+echo "== inheritance continues"
+mkdir "$T_D0/dir/sub/more"
+scoutfs project-id -g "$T_D0/dir/sub/more"
+
+# .. just inherits 0 :) 
+echo "== clearing project id stops inheritance"
+scoutfs project-id -s 0 "$T_D0/dir"
+touch "$T_D0/dir/another-file"
+mkdir "$T_D0/dir/another-sub"
+scoutfs project-id -g "$T_D0/dir/another-file" "$T_D0/dir/another-sub"
+
+echo "== o_tmpfile creations inherit dir"
+scoutfs project-id -s 1 "$T_D0/dir"
+o_tmpfile_linkat "$T_D0/dir" "$T_D0/dir/tmpfile"
+scoutfs project-id -g "$T_D0/dir/tmpfile"
+
+t_pass

tests/tests/quota.sh

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

tests/tests/totl-xattr-tag.sh

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

utils/src/change_format_version.c

@@ -96,7 +96,7 @@ static int do_change_fmt_vers(struct change_fmt_vers_args *args)
 
 	if (le64_to_cpu(meta_super->fmt_vers) < SCOUTFS_FORMAT_VERSION_MIN ||
 	    le64_to_cpu(meta_super->fmt_vers) > SCOUTFS_FORMAT_VERSION_MAX) {
-		fprintf(stderr, "meta super block has format version %llu outside of supported version range %u-%u",
+		fprintf(stderr, "meta super block has format version %llu outside of supported version range %llu-%llu",
 			    le64_to_cpu(meta_super->fmt_vers), SCOUTFS_FORMAT_VERSION_MIN,
 			    SCOUTFS_FORMAT_VERSION_MAX);
 		ret = -EINVAL;
@@ -105,7 +105,7 @@ static int do_change_fmt_vers(struct change_fmt_vers_args *args)
 
 	if (le64_to_cpu(data_super->fmt_vers) < SCOUTFS_FORMAT_VERSION_MIN ||
 	    le64_to_cpu(data_super->fmt_vers) > SCOUTFS_FORMAT_VERSION_MAX) {
-		fprintf(stderr, "data super block has format version %llu outside of supported version range %u-%u",
+		fprintf(stderr, "data super block has format version %llu outside of supported version range %llu-%llu",
 			    le64_to_cpu(data_super->fmt_vers), SCOUTFS_FORMAT_VERSION_MIN,
 			    SCOUTFS_FORMAT_VERSION_MAX);
 		ret = -EINVAL;
@@ -186,7 +186,7 @@ static int parse_opt(int key, char *arg, struct argp_state *state)
 			return ret;
 		if (args->fmt_vers < SCOUTFS_FORMAT_VERSION_MIN ||
 		    args->fmt_vers > SCOUTFS_FORMAT_VERSION_MAX)
-			argp_error(state, "format-version %llu is outside supported range of %u-%u",
+			argp_error(state, "format-version %llu is outside supported range of %llu-%llu",
 				   args->fmt_vers, SCOUTFS_FORMAT_VERSION_MIN,
 				   SCOUTFS_FORMAT_VERSION_MAX);
 		break;

utils/src/cmd.c

@@ -70,7 +70,7 @@ static void usage(void)
 	fprintf(stderr, "Selected fs defaults to current working directory.\n");
 	fprintf(stderr, "See <command> --help for more details.\n");
 
-	fprintf(stderr, "\nSupported format version: %u-%u\n",
+	fprintf(stderr, "\nSupported format version: %llu-%llu\n",
 			SCOUTFS_FORMAT_VERSION_MIN, SCOUTFS_FORMAT_VERSION_MAX);
 
 	fprintf(stderr, "\nCore admin:\n");

utils/src/mkfs.c

@@ -386,6 +386,10 @@ static int do_mkfs(struct mkfs_args *args)
 	print_quorum_slots(super->qconf.slots, array_size(super->qconf.slots),
 			   "                          ");
 
+	if (SCOUTFS_FORMAT_VERSION_MIN & SCOUTFS_FORMAT_VER_PREREL)
+		printf("This volume was created with the incompatible pre-release format version 0x%016llx.  This volume will only be mountable by pre-release builds with this specific matching format version.\n",
+				SCOUTFS_FORMAT_VERSION_MIN);
+
 	ret = 0;
 out:
 	if (super)
@@ -456,7 +460,7 @@ static int parse_opt(int key, char *arg, struct argp_state *state)
 			return ret;
 		if (args->fmt_vers < SCOUTFS_FORMAT_VERSION_MIN ||
 		    args->fmt_vers > SCOUTFS_FORMAT_VERSION_MAX)
-			argp_error(state, "format-version %llu is outside supported range of %u-%u",
+			argp_error(state, "format-version %llu is outside supported range of %llu-%llu",
 				   args->fmt_vers, SCOUTFS_FORMAT_VERSION_MIN,
 				   SCOUTFS_FORMAT_VERSION_MAX);
 		break;

utils/src/print.c

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

utils/src/projects.c

@@ -0,0 +1,155 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <argp.h>
+
+#include "sparse.h"
+#include "parse.h"
+#include "util.h"
+#include "format.h"
+#include "ioctl.h"
+#include "cmd.h"
+#include "list.h"
+
+struct str_head {
+	struct list_head head;
+	char str[0];
+};
+
+struct proj_args {
+	struct list_head paths;
+	char *which;
+	u64 proj;
+	unsigned int cmd;
+	bool have_proj;
+};
+
+static bool single_entry(struct list_head *list)
+{
+	return list->next->next == list;
+}
+
+static int do_proj(struct proj_args *args)
+{
+	struct str_head *shead;
+	int fd = -1;
+	int ret;
+
+	list_for_each_entry(shead, &args->paths, head) {
+
+		if (fd >= 0)
+			close(fd);
+		fd = get_path(shead->str, O_RDONLY);
+		if (fd < 0) {
+			ret = fd;
+			goto out;
+		}
+
+		ret = ioctl(fd, args->cmd, &args->proj);
+		if (ret < 0) {
+			ret = -errno;
+			fprintf(stderr, "%s project ioctl failed: %s (%d)\n",
+				args->which, strerror(errno), errno);
+			goto out;
+		}
+
+		if (args->cmd == SCOUTFS_IOC_GET_PROJECT_ID) {
+			if (single_entry(&args->paths))
+				printf("%llu\n", args->proj);
+			else
+				printf("%s: %llu\n", shead->str, args->proj);
+		}
+	}
+
+	ret = 0;
+out:
+	if (fd >= 0)
+		close(fd);
+
+	return ret;
+}
+
+static bool add_strdup_head(struct list_head *list, char *str)
+{
+	struct str_head *shead;
+	size_t bytes;
+
+	bytes = strlen(str) + 1;
+	shead = malloc(offsetof(struct str_head, str[bytes]));
+	if (!shead)
+		return false;
+
+	memcpy(shead->str, str, bytes);
+	list_add_tail(&shead->head, list);
+	return true;
+}
+
+static int parse_proj_opt(int key, char *arg, struct argp_state *state)
+{
+	struct proj_args *args = state->input;
+	int ret;
+
+	switch (key) {
+	case 'g':
+		args->cmd = SCOUTFS_IOC_GET_PROJECT_ID;
+		args->which = "get";
+		break;
+	case 's':
+		ret = parse_u64(arg, &args->proj);
+		if (ret)
+			argp_error(state, "error parsing project ID");
+		args->cmd = SCOUTFS_IOC_SET_PROJECT_ID;
+		args->which = "set";
+		break;
+	case ARGP_KEY_ARG:
+		if (!add_strdup_head(&args->paths, arg))
+			argp_error(state, "error allocating memory for path");
+		break;
+	case ARGP_KEY_FINI:
+		if (!args->cmd)
+			argp_error(state, "must specify either -g (get) or -s (set)");
+		if (list_empty(&args->paths))
+			argp_error(state, "must final path arguments");
+		break;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static struct argp_option proj_opts[] = {
+	{ "get", 'g', NULL, 0, "Get and print existing project ID from inodes"},
+	{ "set", 's', "ID", 0, "Set unsigned 64bit project ID on inodes (0 clears)"},
+	{ NULL }
+};
+
+static struct argp proj_argp = {
+	proj_opts,
+	parse_proj_opt,
+	"",
+	"Manipulate Project ID on inodes"
+};
+
+static int proj_cmd(int argc, char **argv)
+{
+	struct proj_args args = {
+		.paths = LIST_HEAD_INIT(args.paths),
+		.have_proj = false,
+	};
+
+	return argp_parse(&proj_argp, argc, argv, 0, NULL, &args) ?:
+	       do_proj(&args);
+}
+
+static void __attribute__((constructor)) proj_ctor(void)
+{
+	cmd_register_argp("project-id", &proj_argp, GROUP_CORE, proj_cmd);
+}

utils/src/quota.c

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

utils/src/read_xattr_index.c

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