-fd381c355c92ad0e3abfc49c7675893ed355686f
+2115a2ffde28a51adbb8a62fd3c1a3e4dd1b6160
);
DECLARE_EVENT_CLASS(bkey,
- TP_PROTO(const struct bkey *k),
- TP_ARGS(k),
+ TP_PROTO(struct bch_fs *c, const char *k),
+ TP_ARGS(c, k),
TP_STRUCT__entry(
- __field(u64, inode )
- __field(u64, offset )
- __field(u32, size )
+ __string(k, k )
),
TP_fast_assign(
- __entry->inode = k->p.inode;
- __entry->offset = k->p.offset;
- __entry->size = k->size;
+ __assign_str(k, k);
),
- TP_printk("%llu:%llu len %u", __entry->inode,
- __entry->offset, __entry->size)
+ TP_printk("%s", __get_str(k))
);
DECLARE_EVENT_CLASS(btree_node,
/* Moving IO */
+TRACE_EVENT(bucket_evacuate,
+ TP_PROTO(struct bch_fs *c, struct bpos bucket),
+ TP_ARGS(c, bucket),
+
+ TP_STRUCT__entry(
+ __field(dev_t, dev )
+ __field(u32, dev_idx )
+ __field(u64, bucket )
+ ),
+
+ TP_fast_assign(
+ __entry->dev = c->dev;
+ __entry->dev_idx = bucket.inode;
+ __entry->bucket = bucket.offset;
+ ),
+
+ TP_printk("%d:%d %u:%llu",
+ MAJOR(__entry->dev), MINOR(__entry->dev),
+ __entry->dev_idx, __entry->bucket)
+);
+
+DEFINE_EVENT(bkey, move_extent,
+ TP_PROTO(struct bch_fs *c, const char *k),
+ TP_ARGS(c, k)
+);
+
DEFINE_EVENT(bkey, move_extent_read,
- TP_PROTO(const struct bkey *k),
- TP_ARGS(k)
+ TP_PROTO(struct bch_fs *c, const char *k),
+ TP_ARGS(c, k)
);
DEFINE_EVENT(bkey, move_extent_write,
- TP_PROTO(const struct bkey *k),
- TP_ARGS(k)
+ TP_PROTO(struct bch_fs *c, const char *k),
+ TP_ARGS(c, k)
);
DEFINE_EVENT(bkey, move_extent_finish,
- TP_PROTO(const struct bkey *k),
- TP_ARGS(k)
+ TP_PROTO(struct bch_fs *c, const char *k),
+ TP_ARGS(c, k)
);
TRACE_EVENT(move_extent_fail,
);
DEFINE_EVENT(bkey, move_extent_alloc_mem_fail,
- TP_PROTO(const struct bkey *k),
- TP_ARGS(k)
+ TP_PROTO(struct bch_fs *c, const char *k),
+ TP_ARGS(c, k)
);
TRACE_EVENT(move_data,
u64 start = bucket_gens_pos_to_alloc(k.k->p, 0).offset;
u64 end = bucket_gens_pos_to_alloc(bpos_nosnap_successor(k.k->p), 0).offset;
u64 b;
- bool need_update = false;
+ bool need_update = false, dev_exists;
struct printbuf buf = PRINTBUF;
int ret = 0;
BUG_ON(k.k->type != KEY_TYPE_bucket_gens);
bkey_reassemble(&g.k_i, k);
- if (fsck_err_on(!bch2_dev_exists2(c, k.k->p.inode), c,
- "bucket_gens key for invalid device:\n %s",
- (bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {
- ret = bch2_btree_delete_at(trans, iter, 0);
+ /* if no bch_dev, skip out whether we repair or not */
+ dev_exists = bch2_dev_exists2(c, k.k->p.inode);
+ if (!dev_exists) {
+ if (fsck_err_on(!dev_exists, c,
+ "bucket_gens key for invalid device:\n %s",
+ (bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {
+ ret = bch2_btree_delete_at(trans, iter, 0);
+ }
goto out;
}
return;
err:
set_btree_node_noevict(b);
- bch2_fs_fatal_error(c, "fatal error writing btree node");
+ if (!bch2_err_matches(ret, EROFS))
+ bch2_fs_fatal_error(c, "fatal error writing btree node");
goto out;
}
return ret;
}
+static void trace_move_extent_finish2(struct bch_fs *c, struct bkey_s_c k)
+{
+ if (trace_move_extent_finish_enabled()) {
+ struct printbuf buf = PRINTBUF;
+
+ bch2_bkey_val_to_text(&buf, c, k);
+ trace_move_extent_finish(c, buf.buf);
+ printbuf_exit(&buf);
+ }
+}
+
static void trace_move_extent_fail2(struct data_update *m,
struct bkey_s_c new,
struct bkey_s_c wrote,
bch2_btree_iter_set_pos(&iter, next_pos);
this_cpu_add(c->counters[BCH_COUNTER_move_extent_finish], new->k.size);
- trace_move_extent_finish(&new->k);
+ trace_move_extent_finish2(c, bkey_i_to_s_c(&new->k_i));
}
err:
if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
s->s[i].state = n;
}
+/* file offset (to folio offset) to bch_folio_sector index */
+static inline int folio_pos_to_s(struct folio *folio, loff_t pos)
+{
+ u64 f_offset = pos - folio_pos(folio);
+ BUG_ON(pos < folio_pos(folio) || pos >= folio_end_pos(folio));
+ return f_offset >> SECTOR_SHIFT;
+}
+
static inline struct bch_folio *__bch2_folio(struct folio *folio)
{
return folio_has_private(folio)
end_pos = folio_end_pos(folio);
if (inode->v.i_size > folio_pos(folio))
end_pos = min_t(u64, inode->v.i_size, end_pos);
- ret = s->s[(end_pos - folio_pos(folio) - 1) >> 9].state >= SECTOR_dirty;
+ ret = s->s[folio_pos_to_s(folio, end_pos - 1)].state >= SECTOR_dirty;
folio_zero_segment(folio, start_offset, end_offset);
/* fseek: */
-static int folio_data_offset(struct folio *folio, unsigned offset)
+static int folio_data_offset(struct folio *folio, loff_t pos)
{
struct bch_folio *s = bch2_folio(folio);
unsigned i, sectors = folio_sectors(folio);
if (s)
- for (i = offset >> 9; i < sectors; i++)
+ for (i = folio_pos_to_s(folio, pos); i < sectors; i++)
if (s->s[i].state >= SECTOR_dirty)
- return i << 9;
+ return i << SECTOR_SHIFT;
return -1;
}
folio_lock(folio);
offset = folio_data_offset(folio,
- max(folio_pos(folio), start_offset) -
- folio_pos(folio));
+ max(folio_pos(folio), start_offset));
if (offset >= 0) {
ret = clamp(folio_pos(folio) + offset,
start_offset, end_offset);
{
struct folio *folio;
struct bch_folio *s;
- unsigned i, sectors, f_offset;
+ unsigned i, sectors;
bool ret = true;
folio = filemap_lock_folio(mapping, *offset >> PAGE_SHIFT);
goto unlock;
sectors = folio_sectors(folio);
- f_offset = *offset - folio_pos(folio);
-
- for (i = f_offset >> 9; i < sectors; i++)
+ for (i = folio_pos_to_s(folio, *offset); i < sectors; i++)
if (s->s[i].state < SECTOR_dirty) {
- *offset = max(*offset, folio_pos(folio) + (i << 9));
+ *offset = max(*offset,
+ folio_pos(folio) + (i << SECTOR_SHIFT));
goto unlock;
}
#include <trace/events/bcachefs.h>
+static void trace_move_extent2(struct bch_fs *c, struct bkey_s_c k)
+{
+ if (trace_move_extent_enabled()) {
+ struct printbuf buf = PRINTBUF;
+
+ bch2_bkey_val_to_text(&buf, c, k);
+ trace_move_extent(c, buf.buf);
+ printbuf_exit(&buf);
+ }
+}
+
+static void trace_move_extent_read2(struct bch_fs *c, struct bkey_s_c k)
+{
+ if (trace_move_extent_read_enabled()) {
+ struct printbuf buf = PRINTBUF;
+
+ bch2_bkey_val_to_text(&buf, c, k);
+ trace_move_extent_read(c, buf.buf);
+ printbuf_exit(&buf);
+ }
+}
+
+static void trace_move_extent_alloc_mem_fail2(struct bch_fs *c, struct bkey_s_c k)
+{
+ if (trace_move_extent_alloc_mem_fail_enabled()) {
+ struct printbuf buf = PRINTBUF;
+
+ bch2_bkey_val_to_text(&buf, c, k);
+ trace_move_extent_alloc_mem_fail(c, buf.buf);
+ printbuf_exit(&buf);
+ }
+}
+
static void progress_list_add(struct bch_fs *c, struct bch_move_stats *stats)
{
mutex_lock(&c->data_progress_lock);
unsigned sectors = k.k->size, pages;
int ret = -ENOMEM;
+ trace_move_extent2(c, k);
+
bch2_data_update_opts_normalize(k, &data_opts);
if (!data_opts.rewrite_ptrs &&
this_cpu_add(c->counters[BCH_COUNTER_io_move], k.k->size);
this_cpu_add(c->counters[BCH_COUNTER_move_extent_read], k.k->size);
- trace_move_extent_read(k.k);
-
+ trace_move_extent_read2(c, k);
mutex_lock(&ctxt->lock);
atomic_add(io->read_sectors, &ctxt->read_sectors);
err_free:
kfree(io);
err:
- trace_and_count(c, move_extent_alloc_mem_fail, k.k);
+ this_cpu_inc(c->counters[BCH_COUNTER_move_extent_alloc_mem_fail]);
+ trace_move_extent_alloc_mem_fail2(c, k);
return ret;
}
return ret;
}
-void bch2_verify_bucket_evacuated(struct btree_trans *trans, struct bpos bucket, int gen)
-{
- struct bch_fs *c = trans->c;
- struct btree_iter iter;
- struct bkey_s_c k;
- struct printbuf buf = PRINTBUF;
- struct bch_backpointer bp;
- struct bpos bp_pos = POS_MIN;
- unsigned nr_bps = 0;
- int ret;
-
- bch2_trans_begin(trans);
-
- bch2_trans_iter_init(trans, &iter, BTREE_ID_alloc,
- bucket, BTREE_ITER_CACHED);
-again:
- ret = lockrestart_do(trans,
- bkey_err(k = bch2_btree_iter_peek_slot(&iter)));
-
- if (!ret && k.k->type == KEY_TYPE_alloc_v4) {
- struct bkey_s_c_alloc_v4 a = bkey_s_c_to_alloc_v4(k);
-
- if (a.v->gen == gen &&
- a.v->dirty_sectors) {
- if (a.v->data_type == BCH_DATA_btree) {
- bch2_trans_unlock(trans);
- if (bch2_btree_interior_updates_flush(c))
- goto again;
- goto failed_to_evacuate;
- }
- }
- }
-
- set_btree_iter_dontneed(&iter);
- bch2_trans_iter_exit(trans, &iter);
- return;
-failed_to_evacuate:
- bch2_trans_iter_exit(trans, &iter);
-
- if (test_bit(BCH_FS_EMERGENCY_RO, &c->flags))
- return;
-
- prt_printf(&buf, bch2_log_msg(c, "failed to evacuate bucket "));
- bch2_bkey_val_to_text(&buf, c, k);
-
- while (1) {
- bch2_trans_begin(trans);
-
- ret = bch2_get_next_backpointer(trans, bucket, gen,
- &bp_pos, &bp,
- BTREE_ITER_CACHED);
- if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
- continue;
- if (ret)
- break;
- if (bkey_eq(bp_pos, POS_MAX))
- break;
-
- k = bch2_backpointer_get_key(trans, &iter, bp_pos, bp, 0);
- ret = bkey_err(k);
- if (bch2_err_matches(ret, BCH_ERR_transaction_restart))
- continue;
- if (ret)
- break;
- if (!k.k)
- continue;
- prt_newline(&buf);
- bch2_bkey_val_to_text(&buf, c, k);
- bch2_trans_iter_exit(trans, &iter);
-
- if (++nr_bps > 10)
- break;
- bp_pos = bpos_nosnap_successor(bp_pos);
- }
-
- bch2_print_string_as_lines(KERN_ERR, buf.buf);
- printbuf_exit(&buf);
-}
-
int __bch2_evacuate_bucket(struct btree_trans *trans,
struct moving_context *ctxt,
struct move_bucket_in_flight *bucket_in_flight,
struct bpos bp_pos = POS_MIN;
int ret = 0;
+ trace_bucket_evacuate(c, bucket);
+
bch2_bkey_buf_init(&sk);
/*
wait_queue_head_t wait;
};
-void bch2_verify_bucket_evacuated(struct btree_trans *, struct bpos, int);
-
#define move_ctxt_wait_event(_ctxt, _trans, _cond) \
do { \
bool cond_finished = false; \
if (atomic_read(&i->count))
break;
- /*
- * moving_ctxt_exit calls bch2_write as it flushes pending
- * reads, which inits another btree_trans; this one must be
- * unlocked:
- */
- bch2_verify_bucket_evacuated(trans, i->bucket.k.bucket, i->bucket.k.gen);
-
list->first = i->next;
if (!list->first)
list->last = NULL;
bch2_btree_delete_range(c, BTREE_ID_backpointers, start, end,
BTREE_TRIGGER_NORUN, NULL) ?:
bch2_btree_delete_range(c, BTREE_ID_alloc, start, end,
+ BTREE_TRIGGER_NORUN, NULL) ?:
+ bch2_btree_delete_range(c, BTREE_ID_bucket_gens, start, end,
BTREE_TRIGGER_NORUN, NULL);
if (ret)
bch_err(c, "error removing dev alloc info: %s", bch2_err_str(ret));
projects / bcachefs-tools-debian / commitdiff