Update bcachefs sources to 9f34144308 bcachefs: Refactor dio write code to reinit bch_write_op

6 files changed, 73 insertions, 69 deletions

diff --git a/libbcachefs/btree_types.h b/libbcachefs/btree_types.h
index ea25b04b..16c4d058 100644
--- a/libbcachefs/btree_types.h
+++ b/libbcachefs/btree_types.h
@@ -568,6 +568,16 @@ static inline bool btree_node_is_extents(struct btree *b)
 	return btree_node_type_is_extents(btree_node_type(b));
 }
 
+static inline enum btree_node_type btree_iter_key_type(struct btree_iter *iter)
+{
+	return __btree_node_type(iter->level, iter->btree_id);
+}
+
+static inline bool btree_iter_is_extents(struct btree_iter *iter)
+{
+	return btree_node_type_is_extents(btree_iter_key_type(iter));
+}
+
 #define BTREE_NODE_TYPE_HAS_TRIGGERS			\
 	((1U << BKEY_TYPE_EXTENTS)|			\
 	 (1U << BKEY_TYPE_ALLOC)|			\
diff --git a/libbcachefs/btree_update_leaf.c b/libbcachefs/btree_update_leaf.c
index e82d4df9..6e9688d0 100644
--- a/libbcachefs/btree_update_leaf.c
+++ b/libbcachefs/btree_update_leaf.c
@@ -281,7 +281,7 @@ btree_key_can_insert(struct btree_trans *trans,
 	if (unlikely(btree_node_old_extent_overwrite(b)))
 		return BTREE_INSERT_BTREE_NODE_FULL;
 
-	ret = !(iter->flags & BTREE_ITER_IS_EXTENTS)
+	ret = !btree_iter_is_extents(iter)
 		? BTREE_INSERT_OK
 		: bch2_extent_can_insert(trans, iter, insert);
 	if (ret)
diff --git a/libbcachefs/buckets.c b/libbcachefs/buckets.c
index 4c937199..0ec194b9 100644
--- a/libbcachefs/buckets.c
+++ b/libbcachefs/buckets.c
@@ -1367,8 +1367,8 @@ int bch2_mark_update(struct btree_trans *trans,
 		     unsigned flags)
 {
 	struct bch_fs		*c = trans->c;
-	struct btree		*b = iter->l[0].b;
-	struct btree_node_iter	node_iter = iter->l[0].iter;
+	struct btree		*b = iter_l(iter)->b;
+	struct btree_node_iter	node_iter = iter_l(iter)->iter;
 	struct bkey_packed	*_k;
 	int ret = 0;
 
@@ -1430,32 +1430,38 @@ void bch2_trans_fs_usage_apply(struct btree_trans *trans,
 		disk_res_sectors);
 
 	trans_for_each_update(trans, i) {
-		struct btree_iter	*iter = i->iter;
-		struct btree		*b = iter->l[0].b;
-		struct btree_node_iter	node_iter = iter->l[0].iter;
-		struct bkey_packed	*_k;
-
 		pr_err("while inserting");
 		bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(i->k));
 		pr_err("%s", buf);
 		pr_err("overlapping with");
 
-		node_iter = iter->l[0].iter;
-		while ((_k = bch2_btree_node_iter_peek(&node_iter, b))) {
-			struct bkey		unpacked;
-			struct bkey_s_c		k;
+		if (btree_iter_type(i->iter) != BTREE_ITER_CACHED) {
+			struct btree		*b = iter_l(i->iter)->b;
+			struct btree_node_iter	node_iter = iter_l(i->iter)->iter;
+			struct bkey_packed	*_k;
 
-			k = bkey_disassemble(b, _k, &unpacked);
+			while ((_k = bch2_btree_node_iter_peek(&node_iter, b))) {
+				struct bkey		unpacked;
+				struct bkey_s_c		k;
 
-			if (btree_node_is_extents(b)
-			    ? bkey_cmp(i->k->k.p, bkey_start_pos(k.k)) <= 0
-			    : bkey_cmp(i->k->k.p, k.k->p))
-				break;
+				pr_info("_k %px format %u", _k, _k->format);
+				k = bkey_disassemble(b, _k, &unpacked);
 
-			bch2_bkey_val_to_text(&PBUF(buf), c, k);
-			pr_err("%s", buf);
+				if (btree_node_is_extents(b)
+				    ? bkey_cmp(i->k->k.p, bkey_start_pos(k.k)) <= 0
+				    : bkey_cmp(i->k->k.p, k.k->p))
+					break;
+
+				bch2_bkey_val_to_text(&PBUF(buf), c, k);
+				pr_err("%s", buf);
 
-			bch2_btree_node_iter_advance(&node_iter, b);
+				bch2_btree_node_iter_advance(&node_iter, b);
+			}
+		} else {
+			struct bkey_cached *ck = (void *) i->iter->l[0].b;
+
+			bch2_bkey_val_to_text(&PBUF(buf), c, bkey_i_to_s_c(ck->k));
+			pr_err("%s", buf);
 		}
 	}
 }
@@ -1807,8 +1813,8 @@ int bch2_trans_mark_update(struct btree_trans *trans,
 			   struct bkey_i *insert,
 			   unsigned flags)
 {
-	struct btree		*b = iter->l[0].b;
-	struct btree_node_iter	node_iter = iter->l[0].iter;
+	struct btree		*b = iter_l(iter)->b;
+	struct btree_node_iter	node_iter = iter_l(iter)->iter;
 	struct bkey_packed	*_k;
 	int ret;
 
diff --git a/libbcachefs/fs-io.c b/libbcachefs/fs-io.c
index b53eaa82..162aa55d 100644
--- a/libbcachefs/fs-io.c
+++ b/libbcachefs/fs-io.c
@@ -54,6 +54,7 @@ struct dio_write {
 					sync:1,
 					free_iov:1;
 	struct quota_res		quota_res;
+	u64				written;
 
 	struct iov_iter			iter;
 	struct iovec			inline_vecs[2];
@@ -1796,18 +1797,19 @@ ssize_t bch2_read_iter(struct kiocb *iocb, struct iov_iter *iter)
 
 /* O_DIRECT writes */
 
+static void bch2_dio_write_loop_async(struct bch_write_op *);
+
 static long bch2_dio_write_loop(struct dio_write *dio)
 {
 	bool kthread = (current->flags & PF_KTHREAD) != 0;
-	struct bch_fs *c = dio->op.c;
 	struct kiocb *req = dio->req;
 	struct address_space *mapping = req->ki_filp->f_mapping;
 	struct bch_inode_info *inode = file_bch_inode(req->ki_filp);
+	struct bch_fs *c = inode->v.i_sb->s_fs_info;
 	struct bio *bio = &dio->op.wbio.bio;
 	struct bvec_iter_all iter;
 	struct bio_vec *bv;
 	unsigned unaligned;
-	u64 new_i_size;
 	bool sync = dio->sync;
 	long ret;
 
@@ -1854,8 +1856,24 @@ static long bch2_dio_write_loop(struct dio_write *dio)
 			goto err;
 		}
 
-		dio->op.pos = POS(inode->v.i_ino,
-				  (req->ki_pos >> 9) + dio->op.written);
+		bch2_write_op_init(&dio->op, c, io_opts(c, &inode->ei_inode));
+		dio->op.end_io		= bch2_dio_write_loop_async;
+		dio->op.target		= dio->op.opts.foreground_target;
+		op_journal_seq_set(&dio->op, &inode->ei_journal_seq);
+		dio->op.write_point	= writepoint_hashed((unsigned long) current);
+		dio->op.nr_replicas	= dio->op.opts.data_replicas;
+		dio->op.pos		= POS(inode->v.i_ino, (u64) req->ki_pos >> 9);
+
+		if ((req->ki_flags & IOCB_DSYNC) &&
+		    !c->opts.journal_flush_disabled)
+			dio->op.flags |= BCH_WRITE_FLUSH;
+
+		ret = bch2_disk_reservation_get(c, &dio->op.res, bio_sectors(bio),
+						dio->op.opts.data_replicas, 0);
+		if (unlikely(ret) &&
+		    !bch2_check_range_allocated(c, dio->op.pos,
+				bio_sectors(bio), dio->op.opts.data_replicas))
+			goto err;
 
 		task_io_account_write(bio->bi_iter.bi_size);
 
@@ -1887,13 +1905,12 @@ do_io:
 loop:
 		i_sectors_acct(c, inode, &dio->quota_res,
 			       dio->op.i_sectors_delta);
-		dio->op.i_sectors_delta = 0;
-
-		new_i_size = req->ki_pos + ((u64) dio->op.written << 9);
+		req->ki_pos += (u64) dio->op.written << 9;
+		dio->written += dio->op.written;
 
 		spin_lock(&inode->v.i_lock);
-		if (new_i_size > inode->v.i_size)
-			i_size_write(&inode->v, new_i_size);
+		if (req->ki_pos > inode->v.i_size)
+			i_size_write(&inode->v, req->ki_pos);
 		spin_unlock(&inode->v.i_lock);
 
 		bio_for_each_segment_all(bv, bio, iter)
@@ -1905,10 +1922,9 @@ loop:
 		reinit_completion(&dio->done);
 	}
 
-	ret = dio->op.error ?: ((long) dio->op.written << 9);
+	ret = dio->op.error ?: ((long) dio->written << 9);
 err:
 	bch2_pagecache_block_put(&inode->ei_pagecache_lock);
-	bch2_disk_reservation_put(c, &dio->op.res);
 	bch2_quota_reservation_put(c, inode, &dio->quota_res);
 
 	if (dio->free_iov)
@@ -1943,7 +1959,6 @@ ssize_t bch2_direct_write(struct kiocb *req, struct iov_iter *iter)
 	struct address_space *mapping = file->f_mapping;
 	struct bch_inode_info *inode = file_bch_inode(file);
 	struct bch_fs *c = inode->v.i_sb->s_fs_info;
-	struct bch_io_opts opts = io_opts(c, &inode->ei_inode);
 	struct dio_write *dio;
 	struct bio *bio;
 	bool locked = true, extending;
@@ -1991,35 +2006,14 @@ ssize_t bch2_direct_write(struct kiocb *req, struct iov_iter *iter)
 	dio->sync		= is_sync_kiocb(req) || extending;
 	dio->free_iov		= false;
 	dio->quota_res.sectors	= 0;
+	dio->written		= 0;
 	dio->iter		= *iter;
 
-	bch2_write_op_init(&dio->op, c, opts);
-	dio->op.end_io		= bch2_dio_write_loop_async;
-	dio->op.target		= opts.foreground_target;
-	op_journal_seq_set(&dio->op, &inode->ei_journal_seq);
-	dio->op.write_point	= writepoint_hashed((unsigned long) current);
-	dio->op.flags |= BCH_WRITE_NOPUT_RESERVATION;
-
-	if ((req->ki_flags & IOCB_DSYNC) &&
-	    !c->opts.journal_flush_disabled)
-		dio->op.flags |= BCH_WRITE_FLUSH;
-
 	ret = bch2_quota_reservation_add(c, inode, &dio->quota_res,
 					 iter->count >> 9, true);
 	if (unlikely(ret))
 		goto err_put_bio;
 
-	dio->op.nr_replicas	= dio->op.opts.data_replicas;
-
-	ret = bch2_disk_reservation_get(c, &dio->op.res, iter->count >> 9,
-					dio->op.opts.data_replicas, 0);
-	if (unlikely(ret) &&
-	    !bch2_check_range_allocated(c, POS(inode->v.i_ino,
-					       req->ki_pos >> 9),
-					iter->count >> 9,
-					dio->op.opts.data_replicas))
-		goto err_put_bio;
-
 	ret = write_invalidate_inode_pages_range(mapping,
 					req->ki_pos,
 					req->ki_pos + iter->count - 1);
@@ -2030,12 +2024,9 @@ ssize_t bch2_direct_write(struct kiocb *req, struct iov_iter *iter)
 err:
 	if (locked)
 		inode_unlock(&inode->v);
-	if (ret > 0)
-		req->ki_pos += ret;
 	return ret;
 err_put_bio:
 	bch2_pagecache_block_put(&inode->ei_pagecache_lock);
-	bch2_disk_reservation_put(c, &dio->op.res);
 	bch2_quota_reservation_put(c, inode, &dio->quota_res);
 	bio_put(bio);
 	inode_dio_end(&inode->v);
diff --git a/libbcachefs/io.c b/libbcachefs/io.c
index c309080c..8c441050 100644
--- a/libbcachefs/io.c
+++ b/libbcachefs/io.c
@@ -493,8 +493,7 @@ static void bch2_write_done(struct closure *cl)
 	if (!op->error && (op->flags & BCH_WRITE_FLUSH))
 		op->error = bch2_journal_error(&c->journal);
 
-	if (!(op->flags & BCH_WRITE_NOPUT_RESERVATION))
-		bch2_disk_reservation_put(c, &op->res);
+	bch2_disk_reservation_put(c, &op->res);
 	percpu_ref_put(&c->writes);
 	bch2_keylist_free(&op->insert_keys, op->inline_keys);
 
@@ -1281,8 +1280,7 @@ void bch2_write(struct closure *cl)
 	continue_at_nobarrier(cl, __bch2_write, NULL);
 	return;
 err:
-	if (!(op->flags & BCH_WRITE_NOPUT_RESERVATION))
-		bch2_disk_reservation_put(c, &op->res);
+	bch2_disk_reservation_put(c, &op->res);
 
 	if (op->end_io) {
 		EBUG_ON(cl->parent);
diff --git a/libbcachefs/io.h b/libbcachefs/io.h
index 8814a8fb..0ad293bd 100644
--- a/libbcachefs/io.h
+++ b/libbcachefs/io.h
@@ -30,14 +30,13 @@ enum bch_write_flags {
 	BCH_WRITE_PAGES_STABLE		= (1 << 4),
 	BCH_WRITE_PAGES_OWNED		= (1 << 5),
 	BCH_WRITE_ONLY_SPECIFIED_DEVS	= (1 << 6),
-	BCH_WRITE_NOPUT_RESERVATION	= (1 << 7),
-	BCH_WRITE_WROTE_DATA_INLINE	= (1 << 8),
-	BCH_WRITE_FROM_INTERNAL		= (1 << 9),
+	BCH_WRITE_WROTE_DATA_INLINE	= (1 << 7),
+	BCH_WRITE_FROM_INTERNAL		= (1 << 8),
 
 	/* Internal: */
-	BCH_WRITE_JOURNAL_SEQ_PTR	= (1 << 10),
-	BCH_WRITE_SKIP_CLOSURE_PUT	= (1 << 11),
-	BCH_WRITE_DONE			= (1 << 12),
+	BCH_WRITE_JOURNAL_SEQ_PTR	= (1 << 9),
+	BCH_WRITE_SKIP_CLOSURE_PUT	= (1 << 10),
+	BCH_WRITE_DONE			= (1 << 11),
 };
 
 static inline u64 *op_journal_seq(struct bch_write_op *op)