bcachefs: Rename btree_iter_peek_upto() -> btree_iter_peek_max()

We'll be introducing btree_iter_peek_prev_min(), so rename for
consistency.

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

diff --git a/fs/bcachefs/alloc_background.c b/fs/bcachefs/alloc_background.c
index c84a91572a1da88b4c5a1aff96a1b6f16ee03a6e..af791f4dab999c6d15e7fa151bc145fdf5dc30b4 100644 (file)
--- a/fs/bcachefs/alloc_background.c
+++ b/fs/bcachefs/alloc_background.c
@@ -1045,7 +1045,7 @@ static struct bkey_s_c bch2_get_key_or_hole(struct btree_iter *iter, struct bpos
                 * btree node min/max is a closed interval, upto takes a half
                 * open interval:
                 */
-               k = bch2_btree_iter_peek_upto(&iter2, end);
+               k = bch2_btree_iter_peek_max(&iter2, end);
                next = iter2.pos;
                bch2_trans_iter_exit(iter->trans, &iter2);
 
@@ -1886,7 +1886,7 @@ static void bch2_do_discards_work(struct work_struct *work)
         * successful commit:
         */
        ret = bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter,
+               for_each_btree_key_max(trans, iter,
                                   BTREE_ID_need_discard,
                                   POS(ca->dev_idx, 0),
                                   POS(ca->dev_idx, U64_MAX), 0, k,
@@ -2101,7 +2101,7 @@ static struct bkey_s_c next_lru_key(struct btree_trans *trans, struct btree_iter
 {
        struct bkey_s_c k;
 again:
-       k = bch2_btree_iter_peek_upto(iter, lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX));
+       k = bch2_btree_iter_peek_max(iter, lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX));
        if (!k.k && !*wrapped) {
                bch2_btree_iter_set_pos(iter, lru_pos(ca->dev_idx, 0, 0));
                *wrapped = true;

diff --git a/fs/bcachefs/btree_gc.c b/fs/bcachefs/btree_gc.c
index 833d743dee0cf30a163222eabdf3d1ae0d23335c..e45cf32a6403b1e55ba2d957d9a2c3e1a6db3603 100644 (file)
--- a/fs/bcachefs/btree_gc.c
+++ b/fs/bcachefs/btree_gc.c
@@ -904,7 +904,7 @@ static int bch2_gc_alloc_done(struct bch_fs *c)
 
        for_each_member_device(c, ca) {
                ret = bch2_trans_run(c,
-                       for_each_btree_key_upto_commit(trans, iter, BTREE_ID_alloc,
+                       for_each_btree_key_max_commit(trans, iter, BTREE_ID_alloc,
                                        POS(ca->dev_idx, ca->mi.first_bucket),
                                        POS(ca->dev_idx, ca->mi.nbuckets - 1),
                                        BTREE_ITER_slots|BTREE_ITER_prefetch, k,

diff --git a/fs/bcachefs/btree_iter.c b/fs/bcachefs/btree_iter.c
index 1efc77fc9abf719fc3aaf35cd8f9a3199569eab3..21cadc98bdae3f64e26df172877e373fea732110 100644 (file)
--- a/fs/bcachefs/btree_iter.c
+++ b/fs/bcachefs/btree_iter.c
@@ -2113,7 +2113,7 @@ static struct bkey_i *bch2_btree_journal_peek(struct btree_trans *trans,
 {
        struct btree_path *path = btree_iter_path(trans, iter);
 
-       return bch2_journal_keys_peek_upto(trans->c, iter->btree_id,
+       return bch2_journal_keys_peek_max(trans->c, iter->btree_id,
                                           path->level,
                                           path->pos,
                                           end_pos,
@@ -2291,14 +2291,14 @@ out:
 }
 
 /**
- * bch2_btree_iter_peek_upto() - returns first key greater than or equal to
+ * bch2_btree_iter_peek_max() - returns first key greater than or equal to
  * iterator's current position
  * @iter:      iterator to peek from
  * @end:       search limit: returns keys less than or equal to @end
  *
  * Returns:    key if found, or an error extractable with bkey_err().
  */
-struct bkey_s_c bch2_btree_iter_peek_upto(struct btree_iter *iter, struct bpos end)
+struct bkey_s_c bch2_btree_iter_peek_max(struct btree_iter *iter, struct bpos end)
 {
        struct btree_trans *trans = iter->trans;
        struct bpos search_key = btree_iter_search_key(iter);
@@ -2682,7 +2682,7 @@ struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *iter)
                        struct btree_iter iter2;
 
                        bch2_trans_copy_iter(&iter2, iter);
-                       k = bch2_btree_iter_peek_upto(&iter2, end);
+                       k = bch2_btree_iter_peek_max(&iter2, end);
 
                        if (k.k && !bkey_err(k)) {
                                swap(iter->key_cache_path, iter2.key_cache_path);
@@ -2693,7 +2693,7 @@ struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *iter)
                } else {
                        struct bpos pos = iter->pos;
 
-                       k = bch2_btree_iter_peek_upto(iter, end);
+                       k = bch2_btree_iter_peek_max(iter, end);
                        if (unlikely(bkey_err(k)))
                                bch2_btree_iter_set_pos(iter, pos);
                        else

diff --git a/fs/bcachefs/btree_iter.h b/fs/bcachefs/btree_iter.h
index 6b1c46e954328d4337cc72d59edc6147d725e130..cd9022ce15a5150a76028dfa897fb9ca9b47f58b 100644 (file)
--- a/fs/bcachefs/btree_iter.h
+++ b/fs/bcachefs/btree_iter.h
@@ -381,12 +381,12 @@ struct btree *bch2_btree_iter_peek_node(struct btree_iter *);
 struct btree *bch2_btree_iter_peek_node_and_restart(struct btree_iter *);
 struct btree *bch2_btree_iter_next_node(struct btree_iter *);
 
-struct bkey_s_c bch2_btree_iter_peek_upto(struct btree_iter *, struct bpos);
+struct bkey_s_c bch2_btree_iter_peek_max(struct btree_iter *, struct bpos);
 struct bkey_s_c bch2_btree_iter_next(struct btree_iter *);
 
 static inline struct bkey_s_c bch2_btree_iter_peek(struct btree_iter *iter)
 {
-       return bch2_btree_iter_peek_upto(iter, SPOS_MAX);
+       return bch2_btree_iter_peek_max(iter, SPOS_MAX);
 }
 
 struct bkey_s_c bch2_btree_iter_peek_prev(struct btree_iter *);
@@ -672,12 +672,12 @@ static inline struct bkey_s_c bch2_btree_iter_peek_type(struct btree_iter *iter,
                                                bch2_btree_iter_peek(iter);
 }
 
-static inline struct bkey_s_c bch2_btree_iter_peek_upto_type(struct btree_iter *iter,
+static inline struct bkey_s_c bch2_btree_iter_peek_max_type(struct btree_iter *iter,
                                                             struct bpos end,
                                                             unsigned flags)
 {
        if (!(flags & BTREE_ITER_slots))
-               return bch2_btree_iter_peek_upto(iter, end);
+               return bch2_btree_iter_peek_max(iter, end);
 
        if (bkey_gt(iter->pos, end))
                return bkey_s_c_null;
@@ -741,7 +741,7 @@ transaction_restart:                                                        \
        _ret2 ?: trans_was_restarted(_trans, _restart_count);           \
 })
 
-#define for_each_btree_key_upto_continue(_trans, _iter,                        \
+#define for_each_btree_key_max_continue(_trans, _iter,                 \
                                         _end, _flags, _k, _do)         \
 ({                                                                     \
        struct bkey_s_c _k;                                             \
@@ -749,7 +749,7 @@ transaction_restart:                                                        \
                                                                        \
        do {                                                            \
                _ret3 = lockrestart_do(_trans, ({                       \
-                       (_k) = bch2_btree_iter_peek_upto_type(&(_iter), \
+                       (_k) = bch2_btree_iter_peek_max_type(&(_iter),  \
                                                _end, (_flags));        \
                        if (!(_k).k)                                    \
                                break;                                  \
@@ -763,9 +763,9 @@ transaction_restart:                                                        \
 })
 
 #define for_each_btree_key_continue(_trans, _iter, _flags, _k, _do)    \
-       for_each_btree_key_upto_continue(_trans, _iter, SPOS_MAX, _flags, _k, _do)
+       for_each_btree_key_max_continue(_trans, _iter, SPOS_MAX, _flags, _k, _do)
 
-#define for_each_btree_key_upto(_trans, _iter, _btree_id,              \
+#define for_each_btree_key_max(_trans, _iter, _btree_id,               \
                                _start, _end, _flags, _k, _do)          \
 ({                                                                     \
        bch2_trans_begin(trans);                                        \
@@ -774,12 +774,12 @@ transaction_restart:                                                      \
        bch2_trans_iter_init((_trans), &(_iter), (_btree_id),           \
                             (_start), (_flags));                       \
                                                                        \
-       for_each_btree_key_upto_continue(_trans, _iter, _end, _flags, _k, _do);\
+       for_each_btree_key_max_continue(_trans, _iter, _end, _flags, _k, _do);\
 })
 
 #define for_each_btree_key(_trans, _iter, _btree_id,                   \
                           _start, _flags, _k, _do)                     \
-       for_each_btree_key_upto(_trans, _iter, _btree_id, _start,       \
+       for_each_btree_key_max(_trans, _iter, _btree_id, _start,        \
                                 SPOS_MAX, _flags, _k, _do)
 
 #define for_each_btree_key_reverse(_trans, _iter, _btree_id,           \
@@ -823,33 +823,33 @@ transaction_restart:                                                      \
                            (_do) ?: bch2_trans_commit(_trans, (_disk_res),\
                                        (_journal_seq), (_commit_flags)))
 
-#define for_each_btree_key_upto_commit(_trans, _iter, _btree_id,       \
+#define for_each_btree_key_max_commit(_trans, _iter, _btree_id,        \
                                  _start, _end, _iter_flags, _k,        \
                                  _disk_res, _journal_seq, _commit_flags,\
                                  _do)                                  \
-       for_each_btree_key_upto(_trans, _iter, _btree_id, _start, _end, _iter_flags, _k,\
+       for_each_btree_key_max(_trans, _iter, _btree_id, _start, _end, _iter_flags, _k,\
                            (_do) ?: bch2_trans_commit(_trans, (_disk_res),\
                                        (_journal_seq), (_commit_flags)))
 
 struct bkey_s_c bch2_btree_iter_peek_and_restart_outlined(struct btree_iter *);
 
-#define for_each_btree_key_upto_norestart(_trans, _iter, _btree_id,    \
+#define for_each_btree_key_max_norestart(_trans, _iter, _btree_id,     \
                           _start, _end, _flags, _k, _ret)              \
        for (bch2_trans_iter_init((_trans), &(_iter), (_btree_id),      \
                                  (_start), (_flags));                  \
-            (_k) = bch2_btree_iter_peek_upto_type(&(_iter), _end, _flags),\
+            (_k) = bch2_btree_iter_peek_max_type(&(_iter), _end, _flags),\
             !((_ret) = bkey_err(_k)) && (_k).k;                        \
             bch2_btree_iter_advance(&(_iter)))
 
-#define for_each_btree_key_upto_continue_norestart(_iter, _end, _flags, _k, _ret)\
+#define for_each_btree_key_max_continue_norestart(_iter, _end, _flags, _k, _ret)\
        for (;                                                                  \
-            (_k) = bch2_btree_iter_peek_upto_type(&(_iter), _end, _flags),     \
+            (_k) = bch2_btree_iter_peek_max_type(&(_iter), _end, _flags),      \
             !((_ret) = bkey_err(_k)) && (_k).k;                                \
             bch2_btree_iter_advance(&(_iter)))
 
 #define for_each_btree_key_norestart(_trans, _iter, _btree_id,         \
                           _start, _flags, _k, _ret)                    \
-       for_each_btree_key_upto_norestart(_trans, _iter, _btree_id, _start,\
+       for_each_btree_key_max_norestart(_trans, _iter, _btree_id, _start,\
                                          SPOS_MAX, _flags, _k, _ret)
 
 #define for_each_btree_key_reverse_norestart(_trans, _iter, _btree_id, \
@@ -861,7 +861,7 @@ struct bkey_s_c bch2_btree_iter_peek_and_restart_outlined(struct btree_iter *);
             bch2_btree_iter_rewind(&(_iter)))
 
 #define for_each_btree_key_continue_norestart(_iter, _flags, _k, _ret) \
-       for_each_btree_key_upto_continue_norestart(_iter, SPOS_MAX, _flags, _k, _ret)
+       for_each_btree_key_max_continue_norestart(_iter, SPOS_MAX, _flags, _k, _ret)
 
 /*
  * This should not be used in a fastpath, without first trying _do in

diff --git a/fs/bcachefs/btree_journal_iter.c b/fs/bcachefs/btree_journal_iter.c
index 924b5e3a4390608e9a5512c5517220ea08f294b9..c9dee4b4627aa4bb21fec007ee2214d4d49af1cc 100644 (file)
--- a/fs/bcachefs/btree_journal_iter.c
+++ b/fs/bcachefs/btree_journal_iter.c
@@ -61,7 +61,7 @@ static size_t bch2_journal_key_search(struct journal_keys *keys,
 }
 
 /* Returns first non-overwritten key >= search key: */
-struct bkey_i *bch2_journal_keys_peek_upto(struct bch_fs *c, enum btree_id btree_id,
+struct bkey_i *bch2_journal_keys_peek_max(struct bch_fs *c, enum btree_id btree_id,
                                           unsigned level, struct bpos pos,
                                           struct bpos end_pos, size_t *idx)
 {
@@ -112,7 +112,7 @@ struct bkey_i *bch2_journal_keys_peek_slot(struct bch_fs *c, enum btree_id btree
 {
        size_t idx = 0;
 
-       return bch2_journal_keys_peek_upto(c, btree_id, level, pos, pos, &idx);
+       return bch2_journal_keys_peek_max(c, btree_id, level, pos, pos, &idx);
 }
 
 static void journal_iter_verify(struct journal_iter *iter)

diff --git a/fs/bcachefs/btree_journal_iter.h b/fs/bcachefs/btree_journal_iter.h
index 1653de9d609bc71d75f50210a67aee14ede1cdda..754939f604d5a7fa788e8d2cdb6d1d9a5f5708df 100644 (file)
--- a/fs/bcachefs/btree_journal_iter.h
+++ b/fs/bcachefs/btree_journal_iter.h
@@ -43,7 +43,7 @@ static inline int journal_key_cmp(const struct journal_key *l, const struct jour
        return __journal_key_cmp(l->btree_id, l->level, l->k->k.p, r);
 }
 
-struct bkey_i *bch2_journal_keys_peek_upto(struct bch_fs *, enum btree_id,
+struct bkey_i *bch2_journal_keys_peek_max(struct bch_fs *, enum btree_id,
                                unsigned, struct bpos, struct bpos, size_t *);
 struct bkey_i *bch2_journal_keys_peek_slot(struct bch_fs *, enum btree_id,
                                           unsigned, struct bpos);

diff --git a/fs/bcachefs/btree_update.c b/fs/bcachefs/btree_update.c
index a9a29fba49025727407e1a779b17716c780b31ef..6afd77c68411fa61c00bddad83932dac064fd461 100644 (file)
--- a/fs/bcachefs/btree_update.c
+++ b/fs/bcachefs/btree_update.c
@@ -296,7 +296,7 @@ static int bch2_trans_update_extent(struct btree_trans *trans,
                             BTREE_ITER_intent|
                             BTREE_ITER_with_updates|
                             BTREE_ITER_not_extents);
-       k = bch2_btree_iter_peek_upto(&iter, POS(insert->k.p.inode, U64_MAX));
+       k = bch2_btree_iter_peek_max(&iter, POS(insert->k.p.inode, U64_MAX));
        if ((ret = bkey_err(k)))
                goto err;
        if (!k.k)
@@ -323,7 +323,7 @@ static int bch2_trans_update_extent(struct btree_trans *trans,
                        goto out;
 next:
                bch2_btree_iter_advance(&iter);
-               k = bch2_btree_iter_peek_upto(&iter, POS(insert->k.p.inode, U64_MAX));
+               k = bch2_btree_iter_peek_max(&iter, POS(insert->k.p.inode, U64_MAX));
                if ((ret = bkey_err(k)))
                        goto err;
                if (!k.k)
@@ -721,7 +721,7 @@ int bch2_btree_delete_range_trans(struct btree_trans *trans, enum btree_id id,
        int ret = 0;
 
        bch2_trans_iter_init(trans, &iter, id, start, BTREE_ITER_intent);
-       while ((k = bch2_btree_iter_peek_upto(&iter, end)).k) {
+       while ((k = bch2_btree_iter_peek_max(&iter, end)).k) {
                struct disk_reservation disk_res =
                        bch2_disk_reservation_init(trans->c, 0);
                struct bkey_i delete;

diff --git a/fs/bcachefs/dirent.c b/fs/bcachefs/dirent.c
index faffc98d5605355e596094b7fa238ea579745564..4c22f78b04847807abc0011fc745806d892dd33a 100644 (file)
--- a/fs/bcachefs/dirent.c
+++ b/fs/bcachefs/dirent.c
@@ -500,7 +500,7 @@ int bch2_empty_dir_snapshot(struct btree_trans *trans, u64 dir, u32 subvol, u32
        struct bkey_s_c k;
        int ret;
 
-       for_each_btree_key_upto_norestart(trans, iter, BTREE_ID_dirents,
+       for_each_btree_key_max_norestart(trans, iter, BTREE_ID_dirents,
                           SPOS(dir, 0, snapshot),
                           POS(dir, U64_MAX), 0, k, ret)
                if (k.k->type == KEY_TYPE_dirent) {
@@ -549,7 +549,7 @@ int bch2_readdir(struct bch_fs *c, subvol_inum inum, struct dir_context *ctx)
        bch2_bkey_buf_init(&sk);
 
        int ret = bch2_trans_run(c,
-               for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_dirents,
+               for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_dirents,
                                   POS(inum.inum, ctx->pos),
                                   POS(inum.inum, U64_MAX),
                                   inum.subvol, 0, k, ({

diff --git a/fs/bcachefs/ec.c b/fs/bcachefs/ec.c
index b46bf00c4a67440d6ad4ef24bb3de6ec61c7bed8..5c404f24bddc79681f2e8d6bb1ff05715bec14aa 100644 (file)
--- a/fs/bcachefs/ec.c
+++ b/fs/bcachefs/ec.c
@@ -2299,7 +2299,7 @@ err:
 int bch2_dev_remove_stripes(struct bch_fs *c, unsigned dev_idx)
 {
        return bch2_trans_run(c,
-               for_each_btree_key_upto_commit(trans, iter,
+               for_each_btree_key_max_commit(trans, iter,
                                  BTREE_ID_alloc, POS(dev_idx, 0), POS(dev_idx, U64_MAX),
                                  BTREE_ITER_intent, k,
                                  NULL, NULL, 0, ({

diff --git a/fs/bcachefs/extent_update.c b/fs/bcachefs/extent_update.c
index 5f4fecb358da03e0b64c95c12ce174bc29beb24b..45c87c019f6b752fee0a82d250f8df74b1aeb520 100644 (file)
--- a/fs/bcachefs/extent_update.c
+++ b/fs/bcachefs/extent_update.c
@@ -128,7 +128,7 @@ int bch2_extent_atomic_end(struct btree_trans *trans,
 
        bch2_trans_copy_iter(&copy, iter);
 
-       for_each_btree_key_upto_continue_norestart(copy, insert->k.p, 0, k, ret) {
+       for_each_btree_key_max_continue_norestart(copy, insert->k.p, 0, k, ret) {
                unsigned offset = 0;
 
                if (bkey_gt(bkey_start_pos(&insert->k), bkey_start_pos(k.k)))

diff --git a/fs/bcachefs/fs-io-pagecache.c b/fs/bcachefs/fs-io-pagecache.c
index 1d4910ea0f1d63f14c556cec39560897388b86a1..51a499c5a7b6467a443e1ace32c0b07a17c2fec1 100644 (file)
--- a/fs/bcachefs/fs-io-pagecache.c
+++ b/fs/bcachefs/fs-io-pagecache.c
@@ -199,7 +199,7 @@ int bch2_folio_set(struct bch_fs *c, subvol_inum inum,
        unsigned folio_idx = 0;
 
        return bch2_trans_run(c,
-               for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents,
+               for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents,
                                   POS(inum.inum, offset),
                                   POS(inum.inum, U64_MAX),
                                   inum.subvol, BTREE_ITER_slots, k, ({

diff --git a/fs/bcachefs/fs-io.c b/fs/bcachefs/fs-io.c
index 2456c41b215ee019bc359dab7d7b998a309219c9..0021db19148070865966701e71e8a0d6513c50ae 100644 (file)
--- a/fs/bcachefs/fs-io.c
+++ b/fs/bcachefs/fs-io.c
@@ -222,7 +222,7 @@ static inline int range_has_data(struct bch_fs *c, u32 subvol,
                                 struct bpos end)
 {
        return bch2_trans_run(c,
-               for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents, start, end,
+               for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents, start, end,
                                                    subvol, 0, k, ({
                        bkey_extent_is_data(k.k) && !bkey_extent_is_unwritten(k);
                })));
@@ -806,7 +806,7 @@ static int quota_reserve_range(struct bch_inode_info *inode,
        u64 sectors = end - start;
 
        int ret = bch2_trans_run(c,
-               for_each_btree_key_in_subvolume_upto(trans, iter,
+               for_each_btree_key_in_subvolume_max(trans, iter,
                                BTREE_ID_extents,
                                POS(inode->v.i_ino, start),
                                POS(inode->v.i_ino, end - 1),
@@ -922,7 +922,7 @@ static loff_t bch2_seek_data(struct file *file, u64 offset)
                return -ENXIO;
 
        int ret = bch2_trans_run(c,
-               for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents,
+               for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents,
                                   POS(inode->v.i_ino, offset >> 9),
                                   POS(inode->v.i_ino, U64_MAX),
                                   inum.subvol, 0, k, ({
@@ -958,7 +958,7 @@ static loff_t bch2_seek_hole(struct file *file, u64 offset)
                return -ENXIO;
 
        int ret = bch2_trans_run(c,
-               for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents,
+               for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_extents,
                                   POS(inode->v.i_ino, offset >> 9),
                                   POS(inode->v.i_ino, U64_MAX),
                                   inum.subvol, BTREE_ITER_slots, k, ({

diff --git a/fs/bcachefs/fs.c b/fs/bcachefs/fs.c
index e0ffe4648bb87777843e52a20272994629d16d80..91fce04272a139c900272447e0c7153a68ca91f9 100644 (file)
--- a/fs/bcachefs/fs.c
+++ b/fs/bcachefs/fs.c
@@ -1294,7 +1294,7 @@ static int bch2_fiemap(struct inode *vinode, struct fiemap_extent_info *info,
 
                bch2_btree_iter_set_snapshot(&iter, snapshot);
 
-               k = bch2_btree_iter_peek_upto(&iter, end);
+               k = bch2_btree_iter_peek_max(&iter, end);
                ret = bkey_err(k);
                if (ret)
                        continue;

diff --git a/fs/bcachefs/fsck.c b/fs/bcachefs/fsck.c
index c96025b8b65d89f55ba57d690f4cbd0612d277c3..2229f0dcc8603344cc407927998804d6ab983018 100644 (file)
--- a/fs/bcachefs/fsck.c
+++ b/fs/bcachefs/fsck.c
@@ -73,7 +73,7 @@ static s64 bch2_count_inode_sectors(struct btree_trans *trans, u64 inum,
 {
        u64 sectors = 0;
 
-       int ret = for_each_btree_key_upto(trans, iter, BTREE_ID_extents,
+       int ret = for_each_btree_key_max(trans, iter, BTREE_ID_extents,
                                SPOS(inum, 0, snapshot),
                                POS(inum, U64_MAX),
                                0, k, ({
@@ -90,7 +90,7 @@ static s64 bch2_count_subdirs(struct btree_trans *trans, u64 inum,
 {
        u64 subdirs = 0;
 
-       int ret = for_each_btree_key_upto(trans, iter, BTREE_ID_dirents,
+       int ret = for_each_btree_key_max(trans, iter, BTREE_ID_dirents,
                                    SPOS(inum, 0, snapshot),
                                    POS(inum, U64_MAX),
                                    0, k, ({
@@ -1751,7 +1751,7 @@ static int overlapping_extents_found(struct btree_trans *trans,
        bch2_trans_iter_init(trans, &iter1, btree, pos1,
                             BTREE_ITER_all_snapshots|
                             BTREE_ITER_not_extents);
-       k1 = bch2_btree_iter_peek_upto(&iter1, POS(pos1.inode, U64_MAX));
+       k1 = bch2_btree_iter_peek_max(&iter1, POS(pos1.inode, U64_MAX));
        ret = bkey_err(k1);
        if (ret)
                goto err;
@@ -1776,7 +1776,7 @@ static int overlapping_extents_found(struct btree_trans *trans,
        while (1) {
                bch2_btree_iter_advance(&iter2);
 
-               k2 = bch2_btree_iter_peek_upto(&iter2, POS(pos1.inode, U64_MAX));
+               k2 = bch2_btree_iter_peek_max(&iter2, POS(pos1.inode, U64_MAX));
                ret = bkey_err(k2);
                if (ret)
                        goto err;

diff --git a/fs/bcachefs/inode.c b/fs/bcachefs/inode.c
index 5dd9d3edae7774fa3e2d2167f07c6673bcd233f8..5c603ab66be0e6e50a64859ebc5052b50845cf48 100644 (file)
--- a/fs/bcachefs/inode.c
+++ b/fs/bcachefs/inode.c
@@ -618,7 +618,7 @@ bch2_bkey_get_iter_snapshot_parent(struct btree_trans *trans, struct btree_iter
        struct bkey_s_c k;
        int ret = 0;
 
-       for_each_btree_key_upto_norestart(trans, *iter, btree,
+       for_each_btree_key_max_norestart(trans, *iter, btree,
                                          bpos_successor(pos),
                                          SPOS(pos.inode, pos.offset, U32_MAX),
                                          flags|BTREE_ITER_all_snapshots, k, ret)
@@ -653,7 +653,7 @@ int __bch2_inode_has_child_snapshots(struct btree_trans *trans, struct bpos pos)
        struct bkey_s_c k;
        int ret = 0;
 
-       for_each_btree_key_upto_norestart(trans, iter,
+       for_each_btree_key_max_norestart(trans, iter,
                        BTREE_ID_inodes, POS(0, pos.offset), bpos_predecessor(pos),
                        BTREE_ITER_all_snapshots|
                        BTREE_ITER_with_updates, k, ret)
@@ -967,7 +967,7 @@ static int bch2_inode_delete_keys(struct btree_trans *trans,
 
                bch2_btree_iter_set_snapshot(&iter, snapshot);
 
-               k = bch2_btree_iter_peek_upto(&iter, end);
+               k = bch2_btree_iter_peek_max(&iter, end);
                ret = bkey_err(k);
                if (ret)
                        goto err;

diff --git a/fs/bcachefs/io_misc.c b/fs/bcachefs/io_misc.c
index e2acf21ac9b0fb21d486ff6680470c92b7f39509..ff661a072000debb89240965d54598a019b2864a 100644 (file)
--- a/fs/bcachefs/io_misc.c
+++ b/fs/bcachefs/io_misc.c
@@ -164,9 +164,9 @@ int bch2_fpunch_at(struct btree_trans *trans, struct btree_iter *iter,
                bch2_btree_iter_set_snapshot(iter, snapshot);
 
                /*
-                * peek_upto() doesn't have ideal semantics for extents:
+                * peek_max() doesn't have ideal semantics for extents:
                 */
-               k = bch2_btree_iter_peek_upto(iter, end_pos);
+               k = bch2_btree_iter_peek_max(iter, end_pos);
                if (!k.k)
                        break;
 
@@ -427,7 +427,7 @@ case LOGGED_OP_FINSERT_shift_extents:
 
                k = insert
                        ? bch2_btree_iter_peek_prev(&iter)
-                       : bch2_btree_iter_peek_upto(&iter, POS(inum.inum, U64_MAX));
+                       : bch2_btree_iter_peek_max(&iter, POS(inum.inum, U64_MAX));
                if ((ret = bkey_err(k)))
                        goto btree_err;
 

diff --git a/fs/bcachefs/io_write.c b/fs/bcachefs/io_write.c
index f2f69e5e0910c7495ee59072746b12df81a5549e..f11e11279f015be18c5159fc606a8a694a2c616b 100644 (file)
--- a/fs/bcachefs/io_write.c
+++ b/fs/bcachefs/io_write.c
@@ -164,7 +164,7 @@ int bch2_sum_sector_overwrites(struct btree_trans *trans,
 
        bch2_trans_copy_iter(&iter, extent_iter);
 
-       for_each_btree_key_upto_continue_norestart(iter,
+       for_each_btree_key_max_continue_norestart(iter,
                                new->k.p, BTREE_ITER_slots, old, ret) {
                s64 sectors = min(new->k.p.offset, old.k->p.offset) -
                        max(bkey_start_offset(&new->k),
@@ -1165,7 +1165,7 @@ static void bch2_nocow_write_convert_unwritten(struct bch_write_op *op)
        struct btree_trans *trans = bch2_trans_get(c);
 
        for_each_keylist_key(&op->insert_keys, orig) {
-               int ret = for_each_btree_key_upto_commit(trans, iter, BTREE_ID_extents,
+               int ret = for_each_btree_key_max_commit(trans, iter, BTREE_ID_extents,
                                     bkey_start_pos(&orig->k), orig->k.p,
                                     BTREE_ITER_intent, k,
                                     NULL, NULL, BCH_TRANS_COMMIT_no_enospc, ({

diff --git a/fs/bcachefs/movinggc.c b/fs/bcachefs/movinggc.c
index 725292d69fd6cad6a7bf4e9104e7c4559ef53219..85c361e78ba5313b65352e8e3274352d7c3c2fa5 100644 (file)
--- a/fs/bcachefs/movinggc.c
+++ b/fs/bcachefs/movinggc.c
@@ -167,7 +167,7 @@ static int bch2_copygc_get_buckets(struct moving_context *ctxt,
 
        bch2_trans_begin(trans);
 
-       ret = for_each_btree_key_upto(trans, iter, BTREE_ID_lru,
+       ret = for_each_btree_key_max(trans, iter, BTREE_ID_lru,
                                  lru_pos(BCH_LRU_FRAGMENTATION_START, 0, 0),
                                  lru_pos(BCH_LRU_FRAGMENTATION_START, U64_MAX, LRU_TIME_MAX),
                                  0, k, ({

diff --git a/fs/bcachefs/reflink.c b/fs/bcachefs/reflink.c
index 8a36ebd9dd9cf766b48edd6e83aed987bebfe7dc..96cf50f4705d294f1e73676cd21917df25708a69 100644 (file)
--- a/fs/bcachefs/reflink.c
+++ b/fs/bcachefs/reflink.c
@@ -409,7 +409,7 @@ static struct bkey_s_c get_next_src(struct btree_iter *iter, struct bpos end)
        struct bkey_s_c k;
        int ret;
 
-       for_each_btree_key_upto_continue_norestart(*iter, end, 0, k, ret) {
+       for_each_btree_key_max_continue_norestart(*iter, end, 0, k, ret) {
                if (bkey_extent_is_unwritten(k))
                        continue;
 

diff --git a/fs/bcachefs/str_hash.h b/fs/bcachefs/str_hash.h
index ec2b1feea5204c9fa2fc709c50282286f0e976fa..00c785055d22b971fd0c334fce13c0a44dba325b 100644 (file)
--- a/fs/bcachefs/str_hash.h
+++ b/fs/bcachefs/str_hash.h
@@ -160,7 +160,7 @@ bch2_hash_lookup_in_snapshot(struct btree_trans *trans,
        struct bkey_s_c k;
        int ret;
 
-       for_each_btree_key_upto_norestart(trans, *iter, desc.btree_id,
+       for_each_btree_key_max_norestart(trans, *iter, desc.btree_id,
                           SPOS(inum.inum, desc.hash_key(info, key), snapshot),
                           POS(inum.inum, U64_MAX),
                           BTREE_ITER_slots|flags, k, ret) {
@@ -210,7 +210,7 @@ bch2_hash_hole(struct btree_trans *trans,
        if (ret)
                return ret;
 
-       for_each_btree_key_upto_norestart(trans, *iter, desc.btree_id,
+       for_each_btree_key_max_norestart(trans, *iter, desc.btree_id,
                           SPOS(inum.inum, desc.hash_key(info, key), snapshot),
                           POS(inum.inum, U64_MAX),
                           BTREE_ITER_slots|BTREE_ITER_intent, k, ret)
@@ -265,7 +265,7 @@ struct bkey_s_c bch2_hash_set_or_get_in_snapshot(struct btree_trans *trans,
        bool found = false;
        int ret;
 
-       for_each_btree_key_upto_norestart(trans, *iter, desc.btree_id,
+       for_each_btree_key_max_norestart(trans, *iter, desc.btree_id,
                           SPOS(insert->k.p.inode,
                                desc.hash_bkey(info, bkey_i_to_s_c(insert)),
                                snapshot),

diff --git a/fs/bcachefs/subvolume.h b/fs/bcachefs/subvolume.h
index f897d106e14260f7da3df25ecce3ad9d207de1f1..07b23dc08614d3d84b28345010a2ccf15c51d554 100644 (file)
--- a/fs/bcachefs/subvolume.h
+++ b/fs/bcachefs/subvolume.h
@@ -34,7 +34,7 @@ int bch2_subvol_is_ro_trans(struct btree_trans *, u32);
 int bch2_subvol_is_ro(struct bch_fs *, u32);
 
 static inline struct bkey_s_c
-bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bpos end,
+bch2_btree_iter_peek_in_subvolume_max_type(struct btree_iter *iter, struct bpos end,
                                            u32 subvolid, unsigned flags)
 {
        u32 snapshot;
@@ -43,10 +43,10 @@ bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bpos
                return bkey_s_c_err(ret);
 
        bch2_btree_iter_set_snapshot(iter, snapshot);
-       return bch2_btree_iter_peek_upto_type(iter, end, flags);
+       return bch2_btree_iter_peek_max_type(iter, end, flags);
 }
 
-#define for_each_btree_key_in_subvolume_upto_continue(_trans, _iter,           \
+#define for_each_btree_key_in_subvolume_max_continue(_trans, _iter,            \
                                         _end, _subvolid, _flags, _k, _do)      \
 ({                                                                             \
        struct bkey_s_c _k;                                                     \
@@ -54,7 +54,7 @@ bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bpos
                                                                                \
        do {                                                                    \
                _ret3 = lockrestart_do(_trans, ({                               \
-                       (_k) = bch2_btree_iter_peek_in_subvolume_upto_type(&(_iter),    \
+                       (_k) = bch2_btree_iter_peek_in_subvolume_max_type(&(_iter),     \
                                                _end, _subvolid, (_flags));     \
                        if (!(_k).k)                                            \
                                break;                                          \
@@ -67,14 +67,14 @@ bch2_btree_iter_peek_in_subvolume_upto_type(struct btree_iter *iter, struct bpos
        _ret3;                                                                  \
 })
 
-#define for_each_btree_key_in_subvolume_upto(_trans, _iter, _btree_id,         \
+#define for_each_btree_key_in_subvolume_max(_trans, _iter, _btree_id,          \
                                _start, _end, _subvolid, _flags, _k, _do)       \
 ({                                                                             \
        struct btree_iter _iter;                                                \
        bch2_trans_iter_init((_trans), &(_iter), (_btree_id),                   \
                             (_start), (_flags));                               \
                                                                                \
-       for_each_btree_key_in_subvolume_upto_continue(_trans, _iter,            \
+       for_each_btree_key_in_subvolume_max_continue(_trans, _iter,             \
                                        _end, _subvolid, _flags, _k, _do);      \
 })
 

diff --git a/fs/bcachefs/tests.c b/fs/bcachefs/tests.c
index fb5c1543e52f096f4da7e43fb00c6aac9550bc59..6c64698146375a554c6a8896caa276df20793ce3 100644 (file)
--- a/fs/bcachefs/tests.c
+++ b/fs/bcachefs/tests.c
@@ -131,7 +131,7 @@ static int test_iterate(struct bch_fs *c, u64 nr)
        i = 0;
 
        ret = bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs,
+               for_each_btree_key_max(trans, iter, BTREE_ID_xattrs,
                                        SPOS(0, 0, U32_MAX), POS(0, U64_MAX),
                                        0, k, ({
                        BUG_ON(k.k->p.offset != i++);
@@ -186,7 +186,7 @@ static int test_iterate_extents(struct bch_fs *c, u64 nr)
        i = 0;
 
        ret = bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter, BTREE_ID_extents,
+               for_each_btree_key_max(trans, iter, BTREE_ID_extents,
                                        SPOS(0, 0, U32_MAX), POS(0, U64_MAX),
                                        0, k, ({
                        BUG_ON(bkey_start_offset(k.k) != i);
@@ -242,7 +242,7 @@ static int test_iterate_slots(struct bch_fs *c, u64 nr)
        i = 0;
 
        ret = bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs,
+               for_each_btree_key_max(trans, iter, BTREE_ID_xattrs,
                                          SPOS(0, 0, U32_MAX), POS(0, U64_MAX),
                                          0, k, ({
                        BUG_ON(k.k->p.offset != i);
@@ -259,7 +259,7 @@ static int test_iterate_slots(struct bch_fs *c, u64 nr)
        i = 0;
 
        ret = bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs,
+               for_each_btree_key_max(trans, iter, BTREE_ID_xattrs,
                                        SPOS(0, 0, U32_MAX), POS(0, U64_MAX),
                                        BTREE_ITER_slots, k, ({
                        if (i >= nr * 2)
@@ -302,7 +302,7 @@ static int test_iterate_slots_extents(struct bch_fs *c, u64 nr)
        i = 0;
 
        ret = bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter, BTREE_ID_extents,
+               for_each_btree_key_max(trans, iter, BTREE_ID_extents,
                                        SPOS(0, 0, U32_MAX), POS(0, U64_MAX),
                                        0, k, ({
                        BUG_ON(bkey_start_offset(k.k) != i + 8);
@@ -320,7 +320,7 @@ static int test_iterate_slots_extents(struct bch_fs *c, u64 nr)
        i = 0;
 
        ret = bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter, BTREE_ID_extents,
+               for_each_btree_key_max(trans, iter, BTREE_ID_extents,
                                        SPOS(0, 0, U32_MAX), POS(0, U64_MAX),
                                        BTREE_ITER_slots, k, ({
                        if (i == nr)
@@ -349,10 +349,10 @@ static int test_peek_end(struct bch_fs *c, u64 nr)
        bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs,
                             SPOS(0, 0, U32_MAX), 0);
 
-       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_upto(&iter, POS(0, U64_MAX))));
+       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(&iter, POS(0, U64_MAX))));
        BUG_ON(k.k);
 
-       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_upto(&iter, POS(0, U64_MAX))));
+       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(&iter, POS(0, U64_MAX))));
        BUG_ON(k.k);
 
        bch2_trans_iter_exit(trans, &iter);
@@ -369,10 +369,10 @@ static int test_peek_end_extents(struct bch_fs *c, u64 nr)
        bch2_trans_iter_init(trans, &iter, BTREE_ID_extents,
                             SPOS(0, 0, U32_MAX), 0);
 
-       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_upto(&iter, POS(0, U64_MAX))));
+       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(&iter, POS(0, U64_MAX))));
        BUG_ON(k.k);
 
-       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_upto(&iter, POS(0, U64_MAX))));
+       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(&iter, POS(0, U64_MAX))));
        BUG_ON(k.k);
 
        bch2_trans_iter_exit(trans, &iter);
@@ -488,7 +488,7 @@ static int test_snapshot_filter(struct bch_fs *c, u32 snapid_lo, u32 snapid_hi)
        trans = bch2_trans_get(c);
        bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs,
                             SPOS(0, 0, snapid_lo), 0);
-       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_upto(&iter, POS(0, U64_MAX))));
+       lockrestart_do(trans, bkey_err(k = bch2_btree_iter_peek_max(&iter, POS(0, U64_MAX))));
 
        BUG_ON(k.k->p.snapshot != U32_MAX);
 
@@ -672,7 +672,7 @@ static int __do_delete(struct btree_trans *trans, struct bpos pos)
 
        bch2_trans_iter_init(trans, &iter, BTREE_ID_xattrs, pos,
                             BTREE_ITER_intent);
-       k = bch2_btree_iter_peek_upto(&iter, POS(0, U64_MAX));
+       k = bch2_btree_iter_peek_max(&iter, POS(0, U64_MAX));
        ret = bkey_err(k);
        if (ret)
                goto err;
@@ -726,7 +726,7 @@ static int seq_insert(struct bch_fs *c, u64 nr)
 static int seq_lookup(struct bch_fs *c, u64 nr)
 {
        return bch2_trans_run(c,
-               for_each_btree_key_upto(trans, iter, BTREE_ID_xattrs,
+               for_each_btree_key_max(trans, iter, BTREE_ID_xattrs,
                                  SPOS(0, 0, U32_MAX), POS(0, U64_MAX),
                                  0, k,
                0));

diff --git a/fs/bcachefs/xattr.c b/fs/bcachefs/xattr.c
index ed418a747cddebabd17231c58c566a1b18ec0b29..820c1791545a11efd4725c75738a70a98122a360 100644 (file)
--- a/fs/bcachefs/xattr.c
+++ b/fs/bcachefs/xattr.c
@@ -309,7 +309,7 @@ ssize_t bch2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
        u64 offset = 0, inum = inode->ei_inode.bi_inum;
 
        int ret = bch2_trans_run(c,
-               for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_xattrs,
+               for_each_btree_key_in_subvolume_max(trans, iter, BTREE_ID_xattrs,
                                   POS(inum, offset),
                                   POS(inum, U64_MAX),
                                   inode->ei_inum.subvol, 0, k, ({