Commit when the main free queue has too many nodes

As mentioned in the previous commit message, generic/269 of xfstests
makes the main free queue unbalanced enough that insertions fail.
Clearing the free queue when the transaction starts is not enough to
prevent it, because the whole disaster can happen without a single
commit.

So, start forcing commits when the main queue has too many nodes. I
don't think there is a problem with being too strict here, because a
truly full main queue would be gigantic for most normal filesystems.
Just force a commit when we reach half the limit (rounded up). Of course
make an exception for filesystems with a single main fq node, since
those can't even become unbalanced in the first place and we don't want
to commit nonstop.

Signed-off-by: Ernesto A. Fernández <[email protected]>

Author: eafer

apfs.h

@@ -152,6 +152,7 @@ struct apfs_spaceman {
 	u32 sm_cib_count;		/* Number of chunk-info blocks */
 	u64 sm_free_count;		/* Number of free blocks */
 	u32 sm_addr_offset;		/* Offset of cib addresses in @sm_raw */
+	u64 sm_main_fq_nodes;		/* Number of nodes in the main fq */
 
 	/*
 	 * A range of freed blocks not yet put in the free queue. Extend this as

spaceman.c

@@ -600,6 +600,7 @@ static int apfs_flush_free_queue(struct super_block *sb, unsigned int qid)
 	struct apfs_spaceman_phys *sm_raw = sm->sm_raw;
 	struct apfs_spaceman_free_queue *fq = &sm_raw->sm_fq[qid];
 	struct apfs_node *fq_root;
+	struct apfs_btree_info *fq_info = NULL;
 	u64 oldest = le64_to_cpu(fq->sfq_oldest_xid);
 	int err;
 
@@ -640,6 +641,16 @@ static int apfs_flush_free_queue(struct super_block *sb, unsigned int qid)
 		fq->sfq_oldest_xid = cpu_to_le64(oldest);
 	}
 
+	if (qid == APFS_SFQ_MAIN) {
+		fq_info = (void *)fq_root->object.data + sb->s_blocksize - sizeof(*fq_info);
+		sm->sm_main_fq_nodes = le64_to_cpu(fq_info->bt_node_count);
+		if (sm->sm_main_fq_nodes != 1) {
+			apfs_alert(sb, "main queue wasn't flushed in full - bug!");
+			err = -EFSCORRUPTED;
+			goto fail;
+		}
+	}
+
 fail:
 	apfs_node_free(fq_root);
 	return err;
@@ -926,12 +937,11 @@ static int apfs_free_queue_try_insert(struct super_block *sb, u64 bno, u64 count
 	__le64 raw_val;
 	u64 node_count;
 	u16 node_limit;
+	unsigned int qid;
 	int err;
 
-	if (apfs_block_in_ip(sm, bno))
-		fq = &sm_raw->sm_fq[APFS_SFQ_IP];
-	else
-		fq = &sm_raw->sm_fq[APFS_SFQ_MAIN];
+	qid = apfs_block_in_ip(sm, bno) ? APFS_SFQ_IP : APFS_SFQ_MAIN;
+	fq = &sm_raw->sm_fq[qid];
 
 	fq_root = apfs_read_node(sb, le64_to_cpu(fq->sfq_tree_oid),
 				 APFS_OBJ_EPHEMERAL, true /* write */);
@@ -983,6 +993,9 @@ static int apfs_free_queue_try_insert(struct super_block *sb, u64 bno, u64 count
 		fq->sfq_oldest_xid = cpu_to_le64(nxi->nx_xid);
 	le64_add_cpu(&fq->sfq_count, count);
 
+	if (qid == APFS_SFQ_MAIN)
+		sm->sm_main_fq_nodes = le64_to_cpu(fq_info->bt_node_count);
+
 fail:
 	apfs_free_query(query);
 	apfs_node_free(fq_root);

transaction.c

@@ -827,6 +827,7 @@ static bool apfs_transaction_need_commit(struct super_block *sb)
 		int buffers_max = nxi->nx_trans_buffers_max;
 		int starts_max = APFS_TRANS_STARTS_MAX;
 		int mq_max = APFS_TRANS_MAIN_QUEUE_MAX;
+		int maxnodes;
 
 		/*
 		 * Try to avoid committing halfway through a data block write,
@@ -855,6 +856,18 @@ static bool apfs_transaction_need_commit(struct super_block *sb)
 		/* Don't let the main queue get too full either */
 		if (le64_to_cpu(fq_main->sfq_count) > mq_max)
 			return true;
+
+		/*
+		 * The main free queue can become unbalanced enough to reach
+		 * the node limit while being mostly empty. For now, the only
+		 * way I have to rebalance it is to flush it entirely with a
+		 * new transaction. We could wait longer to do it, but I don't
+		 * see the point.
+		 */
+		maxnodes = le16_to_cpu(fq_main->sfq_tree_node_limit);
+		maxnodes = (maxnodes + 1) >> 1;
+		if (sm->sm_main_fq_nodes > 1 && sm->sm_main_fq_nodes >= maxnodes)
+			return true;
 	}
 
 	return false;