Update bcachefs sources to ac3ab6a511 bcachefs: Fix an uninitialized var

diff --git a/.bcachefs_revision b/.bcachefs_revision
index a3725b4a6a981ed7f8ef5aae2dc176a85f3eac25..8da505a4f642f843f74eed55010caea7c46bd16f 100644 (file)
--- a/.bcachefs_revision
+++ b/.bcachefs_revision
@@ -1 +1 @@
-0cd3e1d27a6252b6c0cc32f237c2b2414540e2e8
+ac3ab6a511717db1644ded49a6f417304abba048

diff --git a/libbcachefs/btree_update_interior.c b/libbcachefs/btree_update_interior.c
index b9e0ff97a41bb7a265c6db83bf8d9691a2f83075..bee7ee690cf15b3264ed7d6be214deacc23121a7 100644 (file)
--- a/libbcachefs/btree_update_interior.c
+++ b/libbcachefs/btree_update_interior.c
@@ -286,6 +286,7 @@ static struct btree *bch2_btree_node_alloc(struct btree_update *as, unsigned lev
 
        memset(&b->nr, 0, sizeof(b->nr));
        b->data->magic = cpu_to_le64(bset_magic(c));
+       memset(&b->data->_ptr, 0, sizeof(b->data->_ptr));
        b->data->flags = 0;
        SET_BTREE_NODE_ID(b->data, as->btree_id);
        SET_BTREE_NODE_LEVEL(b->data, level);

diff --git a/libbcachefs/btree_update_leaf.c b/libbcachefs/btree_update_leaf.c
index ac6a039b3fa45f867c5a7eeb04f4516611bc13f6..70d2186e509f230fa9321c7053d077961608804d 100644 (file)
--- a/libbcachefs/btree_update_leaf.c
+++ b/libbcachefs/btree_update_leaf.c
@@ -690,6 +690,7 @@ int bch2_trans_commit_error(struct btree_trans *trans,
                }
                break;
        case BTREE_INSERT_ENOSPC:
+               BUG_ON(flags & BTREE_INSERT_NOFAIL);
                ret = -ENOSPC;
                break;
        case BTREE_INSERT_NEED_MARK_REPLICAS:
@@ -743,6 +744,8 @@ int bch2_trans_commit_error(struct btree_trans *trans,
                break;
        }
 
+       BUG_ON(ret == -ENOSPC && (flags & BTREE_INSERT_NOFAIL));
+
        return ret;
 }
 
@@ -1099,9 +1102,30 @@ int bch2_trans_update(struct btree_trans *trans, struct btree_iter *iter,
                if (i < trans->updates + trans->nr_updates &&
                    i->btree_id == n.btree_id &&
                    bkey_cmp(n.k->k.p, bkey_start_pos(&i->k->k)) > 0) {
-                       /* We don't handle splitting extents here: */
-                       BUG_ON(bkey_cmp(bkey_start_pos(&n.k->k),
-                                       bkey_start_pos(&i->k->k)) > 0);
+                       if (bkey_cmp(bkey_start_pos(&n.k->k),
+                                    bkey_start_pos(&i->k->k)) > 0) {
+                               struct btree_insert_entry split = *i;
+                               int ret;
+
+                               BUG_ON(trans->nr_updates + 1 >= BTREE_ITER_MAX);
+
+                               split.k = bch2_trans_kmalloc(trans, bkey_bytes(&i->k->k));
+                               ret = PTR_ERR_OR_ZERO(split.k);
+                               if (ret)
+                                       return ret;
+
+                               bkey_copy(split.k, i->k);
+                               bch2_cut_back(bkey_start_pos(&n.k->k), split.k);
+
+                               split.iter = bch2_trans_get_iter(trans, split.btree_id,
+                                                                bkey_start_pos(&split.k->k),
+                                                                BTREE_ITER_INTENT);
+                               split.iter->flags |= BTREE_ITER_KEEP_UNTIL_COMMIT;
+                               bch2_trans_iter_put(trans, split.iter);
+                               array_insert_item(trans->updates, trans->nr_updates,
+                                                 i - trans->updates, split);
+                               i++;
+                       }
 
                        /*
                         * When we have an extent that overwrites the start of another

diff --git a/libbcachefs/buckets.c b/libbcachefs/buckets.c
index 151b9db32798b1987fd5e874a320514295d6d5c1..cbd295e494bd6c4d55da2897f037cffff2a9175b 100644 (file)
--- a/libbcachefs/buckets.c
+++ b/libbcachefs/buckets.c
@@ -257,18 +257,11 @@ void bch2_fs_usage_to_text(struct printbuf *out,
        }
 }
 
-#define RESERVE_FACTOR 6
-
 static u64 reserve_factor(u64 r)
 {
        return r + (round_up(r, (1 << RESERVE_FACTOR)) >> RESERVE_FACTOR);
 }
 
-static u64 avail_factor(u64 r)
-{
-       return div_u64(r << RESERVE_FACTOR, (1 << RESERVE_FACTOR) + 1);
-}
-
 u64 bch2_fs_sectors_used(struct bch_fs *c, struct bch_fs_usage_online *fs_usage)
 {
        return min(fs_usage->u.hidden +

diff --git a/libbcachefs/buckets.h b/libbcachefs/buckets.h
index 7463e6420b142d35268cc5548b936c9200c569d6..04a2a9310cdd9e9fc4d4ceb7a003d618540d7205 100644 (file)
--- a/libbcachefs/buckets.h
+++ b/libbcachefs/buckets.h
@@ -294,6 +294,13 @@ static inline int bch2_disk_reservation_get(struct bch_fs *c,
        return bch2_disk_reservation_add(c, res, sectors * nr_replicas, flags);
 }
 
+#define RESERVE_FACTOR 6
+
+static inline u64 avail_factor(u64 r)
+{
+       return div_u64(r << RESERVE_FACTOR, (1 << RESERVE_FACTOR) + 1);
+}
+
 int bch2_dev_buckets_resize(struct bch_fs *, struct bch_dev *, u64);
 void bch2_dev_buckets_free(struct bch_dev *);
 int bch2_dev_buckets_alloc(struct bch_fs *, struct bch_dev *);

diff --git a/libbcachefs/dirent.c b/libbcachefs/dirent.c
index ec4666143f23693419ffb90b6b153fcf064c7470..3bf6379cefe664b77f3d6ce16de28243ec44f974 100644 (file)
--- a/libbcachefs/dirent.c
+++ b/libbcachefs/dirent.c
@@ -210,6 +210,8 @@ int bch2_dirent_rename(struct btree_trans *trans,
 
        if (mode != BCH_RENAME)
                *dst_inum = le64_to_cpu(bkey_s_c_to_dirent(old_dst).v->d_inum);
+       if (mode != BCH_RENAME_EXCHANGE)
+               *src_offset = dst_iter->pos.offset;
 
        /* Lookup src: */
        src_iter = bch2_hash_lookup(trans, bch2_dirent_hash_desc,
@@ -290,7 +292,8 @@ int bch2_dirent_rename(struct btree_trans *trans,
        bch2_trans_update(trans, src_iter, &new_src->k_i, 0);
        bch2_trans_update(trans, dst_iter, &new_dst->k_i, 0);
 out_set_offset:
-       *src_offset = new_src->k.p.offset;
+       if (mode == BCH_RENAME_EXCHANGE)
+               *src_offset = new_src->k.p.offset;
        *dst_offset = new_dst->k.p.offset;
 out:
        bch2_trans_iter_put(trans, src_iter);

diff --git a/libbcachefs/fs-common.c b/libbcachefs/fs-common.c
index 34d69c3f6680bfe602506df57d988c0893498638..08c6af886df7b651c8346e855ba923655838b714 100644 (file)
--- a/libbcachefs/fs-common.c
+++ b/libbcachefs/fs-common.c
@@ -289,6 +289,13 @@ int bch2_rename_trans(struct btree_trans *trans,
                        dst_inode_u->bi_dir             = src_dir_u->bi_inum;
                        dst_inode_u->bi_dir_offset      = src_offset;
                }
+
+               if (mode == BCH_RENAME_OVERWRITE &&
+                   dst_inode_u->bi_dir         == dst_dir_u->bi_inum &&
+                   dst_inode_u->bi_dir_offset  == src_offset) {
+                       dst_inode_u->bi_dir             = 0;
+                       dst_inode_u->bi_dir_offset      = 0;
+               }
        }
 
        if (mode == BCH_RENAME_OVERWRITE) {

diff --git a/libbcachefs/fs-io.c b/libbcachefs/fs-io.c
index d707cabd75363acf30842a1f3801e99432cfa47e..dc7916c8b610e047979f9e11a9f7e4110aa50e1a 100644 (file)
--- a/libbcachefs/fs-io.c
+++ b/libbcachefs/fs-io.c
@@ -1018,6 +1018,8 @@ static void bch2_writepage_io_done(struct closure *cl)
        struct bio_vec *bvec;
        unsigned i;
 
+       up(&io->op.c->io_in_flight);
+
        if (io->op.error) {
                set_bit(EI_INODE_ERROR, &io->inode->ei_flags);
 
@@ -1080,6 +1082,8 @@ static void bch2_writepage_do_io(struct bch_writepage_state *w)
 {
        struct bch_writepage_io *io = w->io;
 
+       down(&io->op.c->io_in_flight);
+
        w->io = NULL;
        closure_call(&io->op.cl, bch2_write, NULL, &io->cl);
        continue_at(&io->cl, bch2_writepage_io_done, NULL);
@@ -1819,6 +1823,8 @@ static long bch2_dio_write_loop(struct dio_write *dio)
        if (dio->loop)
                goto loop;
 
+       down(&c->io_in_flight);
+
        while (1) {
                iter_count = dio->iter.count;
 
@@ -1883,6 +1889,7 @@ static long bch2_dio_write_loop(struct dio_write *dio)
                if ((req->ki_flags & IOCB_DSYNC) &&
                    !c->opts.journal_flush_disabled)
                        dio->op.flags |= BCH_WRITE_FLUSH;
+               dio->op.flags |= BCH_WRITE_CHECK_ENOSPC;
 
                ret = bch2_disk_reservation_get(c, &dio->op.res, bio_sectors(bio),
                                                dio->op.opts.data_replicas, 0);
@@ -1949,6 +1956,7 @@ loop:
 
        ret = dio->op.error ?: ((long) dio->written << 9);
 err:
+       up(&c->io_in_flight);
        bch2_pagecache_block_put(&inode->ei_pagecache_lock);
        bch2_quota_reservation_put(c, inode, &dio->quota_res);
 
@@ -2708,7 +2716,7 @@ static int __bchfs_fallocate(struct bch_inode_info *inode, int mode,
 
                ret = bch2_extent_update(&trans, iter, &reservation.k_i,
                                &disk_res, &inode->ei_journal_seq,
-                               0, &i_sectors_delta);
+                               0, &i_sectors_delta, true);
                i_sectors_acct(c, inode, &quota_res, i_sectors_delta);
 bkey_err:
                bch2_quota_reservation_put(c, inode, &quota_res);
@@ -2928,6 +2936,11 @@ loff_t bch2_remap_file_range(struct file *file_src, loff_t pos_src,
        if (pos_dst + ret > dst->v.i_size)
                i_size_write(&dst->v, pos_dst + ret);
        spin_unlock(&dst->v.i_lock);
+
+       if (((file_dst->f_flags & (__O_SYNC | O_DSYNC)) ||
+            IS_SYNC(file_inode(file_dst))) &&
+           !c->opts.journal_flush_disabled)
+               ret = bch2_journal_flush_seq(&c->journal, dst->ei_journal_seq);
 err:
        bch2_unlock_inodes(INODE_LOCK|INODE_PAGECACHE_BLOCK, src, dst);
 

diff --git a/libbcachefs/fs.c b/libbcachefs/fs.c
index 4c6568e04a67d4f76bf71ef6626f858e183d3b74..25a9fc14fd0a3e53e02212f26c9c9152356ac2c9 100644 (file)
--- a/libbcachefs/fs.c
+++ b/libbcachefs/fs.c
@@ -1261,8 +1261,8 @@ static int bch2_statfs(struct dentry *dentry, struct kstatfs *buf)
        buf->f_type     = BCACHEFS_STATFS_MAGIC;
        buf->f_bsize    = sb->s_blocksize;
        buf->f_blocks   = usage.capacity >> shift;
-       buf->f_bfree    = (usage.capacity - usage.used) >> shift;
-       buf->f_bavail   = buf->f_bfree;
+       buf->f_bfree    = usage.free >> shift;
+       buf->f_bavail   = avail_factor(usage.free) >> shift;
 
        buf->f_files    = usage.nr_inodes + avail_inodes;
        buf->f_ffree    = avail_inodes;

diff --git a/libbcachefs/fsck.c b/libbcachefs/fsck.c
index 726019e73b2ccad035498f6f4c41fabb7a0fb0aa..a40459d2b0f06b369d1baae25aad6cd59d33485e 100644 (file)
--- a/libbcachefs/fsck.c
+++ b/libbcachefs/fsck.c
@@ -442,7 +442,7 @@ static int check_inode(struct btree_trans *trans,
                 * just switch units to bytes and that issue goes away
                 */
                ret = bch2_btree_delete_range_trans(trans, BTREE_ID_extents,
-                               POS(u.bi_inum, round_up(u.bi_size, block_bytes(c))),
+                               POS(u.bi_inum, round_up(u.bi_size, block_bytes(c)) >> 9),
                                POS(u.bi_inum, U64_MAX),
                                NULL);
                if (ret) {
@@ -682,7 +682,7 @@ retry:
                                k.k->type, k.k->p.offset, k.k->p.inode, w.inode.bi_size)) {
                        bch2_fs_lazy_rw(c);
                        return bch2_btree_delete_range_trans(&trans, BTREE_ID_extents,
-                                       POS(k.k->p.inode, round_up(w.inode.bi_size, block_bytes(c))),
+                                       POS(k.k->p.inode, round_up(w.inode.bi_size, block_bytes(c)) >> 9),
                                        POS(k.k->p.inode, U64_MAX),
                                        NULL) ?: -EINTR;
                }

diff --git a/libbcachefs/io.c b/libbcachefs/io.c
index 677d354343b7a4bdbf15faaffa9474aebe2a64c9..9b6aece794f2c9cf3ec74fe633a69ac4a385696f 100644 (file)
--- a/libbcachefs/io.c
+++ b/libbcachefs/io.c
@@ -187,7 +187,7 @@ int bch2_sum_sector_overwrites(struct btree_trans *trans,
                               struct btree_iter *extent_iter,
                               struct bkey_i *new,
                               bool *maybe_extending,
-                              bool *should_check_enospc,
+                              bool *usage_increasing,
                               s64 *i_sectors_delta,
                               s64 *disk_sectors_delta)
 {
@@ -199,7 +199,7 @@ int bch2_sum_sector_overwrites(struct btree_trans *trans,
        int ret = 0;
 
        *maybe_extending        = true;
-       *should_check_enospc    = false;
+       *usage_increasing       = false;
        *i_sectors_delta        = 0;
        *disk_sectors_delta     = 0;
 
@@ -219,10 +219,10 @@ int bch2_sum_sector_overwrites(struct btree_trans *trans,
                        ? sectors * bch2_bkey_nr_ptrs_fully_allocated(old)
                        : 0;
 
-               if (!*should_check_enospc &&
+               if (!*usage_increasing &&
                    (new_replicas > bch2_bkey_replicas(c, old) ||
                     (!new_compressed && bch2_bkey_sectors_compressed(old))))
-                       *should_check_enospc = true;
+                       *usage_increasing = true;
 
                if (bkey_cmp(old.k->p, new->k.p) >= 0) {
                        /*
@@ -257,11 +257,12 @@ int bch2_extent_update(struct btree_trans *trans,
                       struct disk_reservation *disk_res,
                       u64 *journal_seq,
                       u64 new_i_size,
-                      s64 *i_sectors_delta_total)
+                      s64 *i_sectors_delta_total,
+                      bool check_enospc)
 {
        /* this must live until after bch2_trans_commit(): */
        struct bkey_inode_buf inode_p;
-       bool extending = false, should_check_enospc;
+       bool extending = false, usage_increasing;
        s64 i_sectors_delta = 0, disk_sectors_delta = 0;
        int ret;
 
@@ -271,17 +272,20 @@ int bch2_extent_update(struct btree_trans *trans,
 
        ret = bch2_sum_sector_overwrites(trans, iter, k,
                        &extending,
-                       &should_check_enospc,
+                       &usage_increasing,
                        &i_sectors_delta,
                        &disk_sectors_delta);
        if (ret)
                return ret;
 
+       if (!usage_increasing)
+               check_enospc = false;
+
        if (disk_res &&
            disk_sectors_delta > (s64) disk_res->sectors) {
                ret = bch2_disk_reservation_add(trans->c, disk_res,
                                        disk_sectors_delta - disk_res->sectors,
-                                       !should_check_enospc
+                                       !check_enospc
                                        ? BCH_DISK_RESERVATION_NOFAIL : 0);
                if (ret)
                        return ret;
@@ -332,11 +336,11 @@ int bch2_extent_update(struct btree_trans *trans,
                bch2_trans_iter_put(trans, inode_iter);
        }
 
-       bch2_trans_update(trans, iter, k, 0);
-
-       ret = bch2_trans_commit(trans, disk_res, journal_seq,
+       ret =   bch2_trans_update(trans, iter, k, 0) ?:
+               bch2_trans_commit(trans, disk_res, journal_seq,
                                BTREE_INSERT_NOCHECK_RW|
                                BTREE_INSERT_NOFAIL);
+       BUG_ON(ret == -ENOSPC);
        if (ret)
                return ret;
 
@@ -375,7 +379,7 @@ int bch2_fpunch_at(struct btree_trans *trans, struct btree_iter *iter,
 
                ret = bch2_extent_update(trans, iter, &delete,
                                &disk_res, journal_seq,
-                               0, i_sectors_delta);
+                               0, i_sectors_delta, false);
                bch2_disk_reservation_put(c, &disk_res);
 btree_err:
                if (ret == -EINTR) {
@@ -448,7 +452,8 @@ int bch2_write_index_default(struct bch_write_op *op)
 
                ret = bch2_extent_update(&trans, iter, sk.k,
                                         &op->res, op_journal_seq(op),
-                                        op->new_i_size, &op->i_sectors_delta);
+                                        op->new_i_size, &op->i_sectors_delta,
+                                        op->flags & BCH_WRITE_CHECK_ENOSPC);
                if (ret == -EINTR)
                        continue;
                if (ret)
@@ -537,9 +542,6 @@ static void bch2_write_done(struct closure *cl)
 
        bch2_time_stats_update(&c->times[BCH_TIME_data_write], op->start_time);
 
-       if (!(op->flags & BCH_WRITE_FROM_INTERNAL))
-               up(&c->io_in_flight);
-
        if (op->end_io) {
                EBUG_ON(cl->parent);
                closure_debug_destroy(cl);
@@ -1323,12 +1325,6 @@ void bch2_write(struct closure *cl)
                goto err;
        }
 
-       /*
-        * Can't ratelimit copygc - we'd deadlock:
-        */
-       if (!(op->flags & BCH_WRITE_FROM_INTERNAL))
-               down(&c->io_in_flight);
-
        bch2_increment_clock(c, bio_sectors(bio), WRITE);
 
        data_len = min_t(u64, bio->bi_iter.bi_size,

diff --git a/libbcachefs/io.h b/libbcachefs/io.h
index 2ac03c049c9236279cd5430a792058e295c84783..144dc9346c026c36371d483d6aac02b37a877639 100644 (file)
--- a/libbcachefs/io.h
+++ b/libbcachefs/io.h
@@ -34,11 +34,12 @@ enum bch_write_flags {
        BCH_WRITE_ONLY_SPECIFIED_DEVS   = (1 << 6),
        BCH_WRITE_WROTE_DATA_INLINE     = (1 << 7),
        BCH_WRITE_FROM_INTERNAL         = (1 << 8),
+       BCH_WRITE_CHECK_ENOSPC          = (1 << 9),
 
        /* Internal: */
-       BCH_WRITE_JOURNAL_SEQ_PTR       = (1 << 9),
-       BCH_WRITE_SKIP_CLOSURE_PUT      = (1 << 10),
-       BCH_WRITE_DONE                  = (1 << 11),
+       BCH_WRITE_JOURNAL_SEQ_PTR       = (1 << 10),
+       BCH_WRITE_SKIP_CLOSURE_PUT      = (1 << 11),
+       BCH_WRITE_DONE                  = (1 << 12),
 };
 
 static inline u64 *op_journal_seq(struct bch_write_op *op)
@@ -64,7 +65,7 @@ int bch2_sum_sector_overwrites(struct btree_trans *, struct btree_iter *,
                               struct bkey_i *, bool *, bool *, s64 *, s64 *);
 int bch2_extent_update(struct btree_trans *, struct btree_iter *,
                       struct bkey_i *, struct disk_reservation *,
-                      u64 *, u64, s64 *);
+                      u64 *, u64, s64 *, bool);
 int bch2_fpunch_at(struct btree_trans *, struct btree_iter *,
                   struct bpos, u64 *, s64 *);
 int bch2_fpunch(struct bch_fs *c, u64, u64, u64, u64 *, s64 *);

diff --git a/libbcachefs/quota.c b/libbcachefs/quota.c
index 3f78fe7d37f4b8c26a1d8dde39aacd2172478a43..35b409e0f366f66edd319c1c73bc28d8bd1d787c 100644 (file)
--- a/libbcachefs/quota.c
+++ b/libbcachefs/quota.c
@@ -742,7 +742,9 @@ static int bch2_set_quota_trans(struct btree_trans *trans,
        if (qdq->d_fieldmask & QC_INO_HARD)
                new_quota->v.c[Q_INO].hardlimit = cpu_to_le64(qdq->d_ino_hardlimit);
 
-       return bch2_trans_update(trans, iter, &new_quota->k_i, 0);
+       ret = bch2_trans_update(trans, iter, &new_quota->k_i, 0);
+       bch2_trans_iter_put(trans, iter);
+       return ret;
 }
 
 static int bch2_set_quota(struct super_block *sb, struct kqid qid,

diff --git a/libbcachefs/reflink.c b/libbcachefs/reflink.c
index 405a194d10e5db7e6b1d9446351013c5be3b1791..c624fabe1e1cd74380baeeb7aef4f0e41886c041 100644 (file)
--- a/libbcachefs/reflink.c
+++ b/libbcachefs/reflink.c
@@ -155,7 +155,9 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,
        *refcount       = 0;
        memcpy(refcount + 1, &orig->v, bkey_val_bytes(&orig->k));
 
-       bch2_trans_update(trans, reflink_iter, r_v, 0);
+       ret = bch2_trans_update(trans, reflink_iter, r_v, 0);
+       if (ret)
+               goto err;
 
        r_p = bch2_trans_kmalloc(trans, sizeof(*r_p));
        if (IS_ERR(r_p)) {
@@ -168,7 +170,7 @@ static int bch2_make_extent_indirect(struct btree_trans *trans,
        set_bkey_val_bytes(&r_p->k, sizeof(r_p->v));
        r_p->v.idx = cpu_to_le64(bkey_start_offset(&r_v->k));
 
-       bch2_trans_update(trans, extent_iter, &r_p->k_i, 0);
+       ret = bch2_trans_update(trans, extent_iter, &r_p->k_i, 0);
 err:
        if (!IS_ERR(reflink_iter))
                c->reflink_hint = reflink_iter->pos.offset;
@@ -291,7 +293,8 @@ s64 bch2_remap_range(struct bch_fs *c,
 
                ret = bch2_extent_update(&trans, dst_iter, new_dst.k,
                                         &disk_res, journal_seq,
-                                        new_i_size, i_sectors_delta);
+                                        new_i_size, i_sectors_delta,
+                                        true);
                bch2_disk_reservation_put(c, &disk_res);
                if (ret)
                        continue;