2017-03-17 06:18:50 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
/*
|
|
|
|
* bcachefs journalling code, for btree insertions
|
|
|
|
*
|
|
|
|
* Copyright 2012 Google, Inc.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "bcachefs.h"
|
2018-10-06 04:46:55 +00:00
|
|
|
#include "alloc_foreground.h"
|
2017-03-17 06:18:50 +00:00
|
|
|
#include "bkey_methods.h"
|
|
|
|
#include "btree_gc.h"
|
2021-01-22 22:56:34 +00:00
|
|
|
#include "btree_update.h"
|
2017-03-17 06:18:50 +00:00
|
|
|
#include "buckets.h"
|
2021-04-03 20:24:13 +00:00
|
|
|
#include "error.h"
|
2017-03-17 06:18:50 +00:00
|
|
|
#include "journal.h"
|
|
|
|
#include "journal_io.h"
|
|
|
|
#include "journal_reclaim.h"
|
2022-03-10 21:43:52 +00:00
|
|
|
#include "journal_sb.h"
|
2017-03-17 06:18:50 +00:00
|
|
|
#include "journal_seq_blacklist.h"
|
|
|
|
#include "trace.h"
|
|
|
|
|
2022-03-15 01:48:42 +00:00
|
|
|
#define x(n) #n,
|
|
|
|
static const char * const bch2_journal_watermarks[] = {
|
|
|
|
JOURNAL_WATERMARKS()
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char * const bch2_journal_errors[] = {
|
|
|
|
JOURNAL_ERRORS()
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
#undef x
|
|
|
|
|
2020-11-14 21:04:30 +00:00
|
|
|
static inline bool journal_seq_unwritten(struct journal *j, u64 seq)
|
|
|
|
{
|
2022-02-28 21:35:42 +00:00
|
|
|
return seq > j->seq_ondisk;
|
2020-11-14 21:04:30 +00:00
|
|
|
}
|
2020-10-07 02:18:21 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
static bool __journal_entry_is_open(union journal_res_state state)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
2019-02-18 22:39:42 +00:00
|
|
|
return state.cur_entry_offset < JOURNAL_ENTRY_CLOSED_VAL;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2022-03-01 00:17:27 +00:00
|
|
|
static inline unsigned nr_unwritten_journal_entries(struct journal *j)
|
|
|
|
{
|
|
|
|
return atomic64_read(&j->seq) - j->seq_ondisk;
|
|
|
|
}
|
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
static bool journal_entry_is_open(struct journal *j)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
2019-02-18 22:39:42 +00:00
|
|
|
return __journal_entry_is_open(j->reservations);
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2020-11-14 21:04:30 +00:00
|
|
|
static inline struct journal_buf *
|
|
|
|
journal_seq_to_buf(struct journal *j, u64 seq)
|
|
|
|
{
|
|
|
|
struct journal_buf *buf = NULL;
|
|
|
|
|
|
|
|
EBUG_ON(seq > journal_cur_seq(j));
|
|
|
|
|
|
|
|
if (journal_seq_unwritten(j, seq)) {
|
2020-11-13 23:36:33 +00:00
|
|
|
buf = j->buf + (seq & JOURNAL_BUF_MASK);
|
2020-11-14 21:04:30 +00:00
|
|
|
EBUG_ON(le64_to_cpu(buf->data->seq) != seq);
|
|
|
|
}
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2021-04-01 01:44:55 +00:00
|
|
|
static void journal_pin_list_init(struct journal_entry_pin_list *p, int count)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
2021-04-01 01:44:55 +00:00
|
|
|
INIT_LIST_HEAD(&p->list);
|
|
|
|
INIT_LIST_HEAD(&p->key_cache_list);
|
|
|
|
INIT_LIST_HEAD(&p->flushed);
|
|
|
|
atomic_set(&p->count, count);
|
|
|
|
p->devs.nr = 0;
|
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
/* journal entry close/open: */
|
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
void __bch2_journal_buf_put(struct journal *j)
|
2019-02-18 22:39:42 +00:00
|
|
|
{
|
2021-05-22 21:37:25 +00:00
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
|
|
|
|
|
|
|
closure_call(&j->io, bch2_journal_write, c->io_complete_wq, NULL);
|
2019-02-18 22:39:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns true if journal entry is now closed:
|
2021-01-14 21:21:22 +00:00
|
|
|
*
|
|
|
|
* We don't close a journal_buf until the next journal_buf is finished writing,
|
|
|
|
* and can be opened again - this also initializes the next journal_buf:
|
2019-02-18 22:39:42 +00:00
|
|
|
*/
|
2022-02-28 23:48:33 +00:00
|
|
|
static void __journal_entry_close(struct journal *j, unsigned closed_val)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
2018-07-23 11:52:00 +00:00
|
|
|
struct journal_buf *buf = journal_cur_buf(j);
|
2017-03-17 06:18:50 +00:00
|
|
|
union journal_res_state old, new;
|
|
|
|
u64 v = atomic64_read(&j->reservations.counter);
|
2019-02-18 22:39:42 +00:00
|
|
|
unsigned sectors;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-02-28 23:48:33 +00:00
|
|
|
BUG_ON(closed_val != JOURNAL_ENTRY_CLOSED_VAL &&
|
|
|
|
closed_val != JOURNAL_ENTRY_ERROR_VAL);
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
lockdep_assert_held(&j->lock);
|
|
|
|
|
|
|
|
do {
|
|
|
|
old.v = new.v = v;
|
2022-02-28 23:48:33 +00:00
|
|
|
new.cur_entry_offset = closed_val;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-02-28 23:48:33 +00:00
|
|
|
if (old.cur_entry_offset == JOURNAL_ENTRY_ERROR_VAL ||
|
|
|
|
old.cur_entry_offset == new.cur_entry_offset)
|
2022-03-01 00:29:19 +00:00
|
|
|
return;
|
2017-03-17 06:18:50 +00:00
|
|
|
} while ((v = atomic64_cmpxchg(&j->reservations.counter,
|
|
|
|
old.v, new.v)) != old.v);
|
|
|
|
|
2022-02-28 23:48:33 +00:00
|
|
|
if (!__journal_entry_is_open(old))
|
|
|
|
return;
|
|
|
|
|
2021-01-14 21:21:22 +00:00
|
|
|
/* Close out old buffer: */
|
2017-03-17 06:18:50 +00:00
|
|
|
buf->data->u64s = cpu_to_le32(old.cur_entry_offset);
|
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
sectors = vstruct_blocks_plus(buf->data, c->block_bits,
|
|
|
|
buf->u64s_reserved) << c->block_bits;
|
|
|
|
BUG_ON(sectors > buf->sectors);
|
|
|
|
buf->sectors = sectors;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2018-07-17 16:19:14 +00:00
|
|
|
/*
|
|
|
|
* We have to set last_seq here, _before_ opening a new journal entry:
|
|
|
|
*
|
|
|
|
* A threads may replace an old pin with a new pin on their current
|
|
|
|
* journal reservation - the expectation being that the journal will
|
|
|
|
* contain either what the old pin protected or what the new pin
|
|
|
|
* protects.
|
|
|
|
*
|
|
|
|
* After the old pin is dropped journal_last_seq() won't include the old
|
|
|
|
* pin, so we can only write the updated last_seq on the entry that
|
|
|
|
* contains whatever the new pin protects.
|
|
|
|
*
|
|
|
|
* Restated, we can _not_ update last_seq for a given entry if there
|
|
|
|
* could be a newer entry open with reservations/pins that have been
|
|
|
|
* taken against it.
|
|
|
|
*
|
|
|
|
* Hence, we want update/set last_seq on the current journal entry right
|
|
|
|
* before we open a new one:
|
|
|
|
*/
|
2021-05-08 03:32:26 +00:00
|
|
|
buf->last_seq = journal_last_seq(j);
|
|
|
|
buf->data->last_seq = cpu_to_le64(buf->last_seq);
|
2022-03-01 00:17:27 +00:00
|
|
|
BUG_ON(buf->last_seq > le64_to_cpu(buf->data->seq));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
__bch2_journal_pin_put(j, le64_to_cpu(buf->data->seq));
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
cancel_delayed_work(&j->write_work);
|
|
|
|
|
2019-02-21 18:33:21 +00:00
|
|
|
bch2_journal_space_available(j);
|
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
bch2_journal_buf_put(j, old.idx);
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2022-02-28 23:48:33 +00:00
|
|
|
void bch2_journal_halt(struct journal *j)
|
|
|
|
{
|
|
|
|
spin_lock(&j->lock);
|
|
|
|
__journal_entry_close(j, JOURNAL_ENTRY_ERROR_VAL);
|
|
|
|
if (!j->err_seq)
|
|
|
|
j->err_seq = journal_cur_seq(j);
|
|
|
|
spin_unlock(&j->lock);
|
|
|
|
}
|
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
static bool journal_entry_want_write(struct journal *j)
|
|
|
|
{
|
2022-03-01 00:17:27 +00:00
|
|
|
bool ret = !journal_entry_is_open(j) ||
|
2022-03-01 00:29:19 +00:00
|
|
|
journal_cur_seq(j) == journal_last_unwritten_seq(j);
|
2022-02-25 15:28:20 +00:00
|
|
|
|
|
|
|
/* Don't close it yet if we already have a write in flight: */
|
2022-03-01 00:29:19 +00:00
|
|
|
if (ret)
|
2022-02-28 23:48:33 +00:00
|
|
|
__journal_entry_close(j, JOURNAL_ENTRY_CLOSED_VAL);
|
2022-03-01 00:29:19 +00:00
|
|
|
else if (nr_unwritten_journal_entries(j)) {
|
2022-03-01 00:17:27 +00:00
|
|
|
struct journal_buf *buf = journal_cur_buf(j);
|
|
|
|
|
|
|
|
if (!buf->flush_time) {
|
|
|
|
buf->flush_time = local_clock() ?: 1;
|
|
|
|
buf->expires = jiffies;
|
|
|
|
}
|
|
|
|
}
|
2020-11-13 23:36:33 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
static bool journal_entry_close(struct journal *j)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
2019-02-18 22:39:42 +00:00
|
|
|
bool ret;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
spin_lock(&j->lock);
|
2020-11-13 23:36:33 +00:00
|
|
|
ret = journal_entry_want_write(j);
|
2019-02-18 22:39:42 +00:00
|
|
|
spin_unlock(&j->lock);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
return ret;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* should _only_ called from journal_res_get() - when we actually want a
|
|
|
|
* journal reservation - journal entry is open means journal is dirty:
|
|
|
|
*/
|
|
|
|
static int journal_entry_open(struct journal *j)
|
|
|
|
{
|
2020-11-20 01:55:33 +00:00
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
2022-03-01 00:29:19 +00:00
|
|
|
struct journal_buf *buf = j->buf +
|
|
|
|
((journal_cur_seq(j) + 1) & JOURNAL_BUF_MASK);
|
2017-03-17 06:18:50 +00:00
|
|
|
union journal_res_state old, new;
|
2019-02-21 18:33:21 +00:00
|
|
|
int u64s;
|
2017-03-17 06:18:50 +00:00
|
|
|
u64 v;
|
|
|
|
|
|
|
|
lockdep_assert_held(&j->lock);
|
|
|
|
BUG_ON(journal_entry_is_open(j));
|
2022-03-01 00:29:19 +00:00
|
|
|
BUG_ON(BCH_SB_CLEAN(c->disk_sb.sb));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-14 23:38:52 +00:00
|
|
|
if (j->blocked)
|
2022-03-15 01:48:42 +00:00
|
|
|
return JOURNAL_ERR_blocked;
|
2019-02-14 23:38:52 +00:00
|
|
|
|
2019-02-21 18:33:21 +00:00
|
|
|
if (j->cur_entry_error)
|
|
|
|
return j->cur_entry_error;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-02-28 21:21:07 +00:00
|
|
|
if (bch2_journal_error(j))
|
2022-03-15 01:48:42 +00:00
|
|
|
return JOURNAL_ERR_insufficient_devices; /* -EROFS */
|
2022-02-28 21:21:07 +00:00
|
|
|
|
2022-02-28 21:35:42 +00:00
|
|
|
if (!fifo_free(&j->pin))
|
2022-03-15 01:48:42 +00:00
|
|
|
return JOURNAL_ERR_journal_pin_full;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-01 00:29:19 +00:00
|
|
|
if (nr_unwritten_journal_entries(j) == ARRAY_SIZE(j->buf))
|
2022-03-15 01:48:42 +00:00
|
|
|
return JOURNAL_ERR_max_in_flight;
|
2022-03-01 00:29:19 +00:00
|
|
|
|
2022-02-28 21:35:42 +00:00
|
|
|
BUG_ON(!j->cur_entry_sectors);
|
2022-02-28 20:51:24 +00:00
|
|
|
|
2022-02-28 21:35:42 +00:00
|
|
|
buf->expires =
|
|
|
|
(journal_cur_seq(j) == j->flushed_seq_ondisk
|
|
|
|
? jiffies
|
|
|
|
: j->last_flush_write) +
|
2022-02-25 15:28:20 +00:00
|
|
|
msecs_to_jiffies(c->opts.journal_flush_delay);
|
2022-02-28 21:35:42 +00:00
|
|
|
|
2019-01-24 21:50:48 +00:00
|
|
|
buf->u64s_reserved = j->entry_u64s_reserved;
|
2019-02-18 22:39:42 +00:00
|
|
|
buf->disk_sectors = j->cur_entry_sectors;
|
|
|
|
buf->sectors = min(buf->disk_sectors, buf->buf_size >> 9);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
u64s = (int) (buf->sectors << 9) / sizeof(u64) -
|
|
|
|
journal_entry_overhead(j);
|
2022-02-28 21:35:42 +00:00
|
|
|
u64s = clamp_t(int, u64s, 0, JOURNAL_ENTRY_CLOSED_VAL - 1);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-12-14 15:39:04 +00:00
|
|
|
if (u64s <= (ssize_t) j->early_journal_entries.nr)
|
2022-03-15 01:48:42 +00:00
|
|
|
return JOURNAL_ERR_journal_full;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-06 22:20:39 +00:00
|
|
|
if (fifo_empty(&j->pin) && j->reclaim_thread)
|
|
|
|
wake_up_process(j->reclaim_thread);
|
|
|
|
|
2022-02-28 21:35:42 +00:00
|
|
|
/*
|
|
|
|
* The fifo_push() needs to happen at the same time as j->seq is
|
|
|
|
* incremented for journal_last_seq() to be calculated correctly
|
|
|
|
*/
|
|
|
|
atomic64_inc(&j->seq);
|
|
|
|
journal_pin_list_init(fifo_push_ref(&j->pin), 1);
|
|
|
|
|
|
|
|
BUG_ON(j->buf + (journal_cur_seq(j) & JOURNAL_BUF_MASK) != buf);
|
|
|
|
|
|
|
|
bkey_extent_init(&buf->key);
|
|
|
|
buf->noflush = false;
|
|
|
|
buf->must_flush = false;
|
|
|
|
buf->separate_flush = false;
|
|
|
|
buf->flush_time = 0;
|
|
|
|
|
|
|
|
memset(buf->data, 0, sizeof(*buf->data));
|
|
|
|
buf->data->seq = cpu_to_le64(journal_cur_seq(j));
|
|
|
|
buf->data->u64s = 0;
|
|
|
|
|
2022-12-14 15:39:04 +00:00
|
|
|
if (j->early_journal_entries.nr) {
|
|
|
|
memcpy(buf->data->_data, j->early_journal_entries.data,
|
|
|
|
j->early_journal_entries.nr * sizeof(u64));
|
|
|
|
le32_add_cpu(&buf->data->u64s, j->early_journal_entries.nr);
|
|
|
|
}
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
/*
|
|
|
|
* Must be set before marking the journal entry as open:
|
|
|
|
*/
|
|
|
|
j->cur_entry_u64s = u64s;
|
|
|
|
|
|
|
|
v = atomic64_read(&j->reservations.counter);
|
|
|
|
do {
|
|
|
|
old.v = new.v = v;
|
|
|
|
|
2022-02-28 21:21:07 +00:00
|
|
|
BUG_ON(old.cur_entry_offset == JOURNAL_ENTRY_ERROR_VAL);
|
2022-03-01 00:29:19 +00:00
|
|
|
|
|
|
|
new.idx++;
|
2022-02-28 21:35:42 +00:00
|
|
|
BUG_ON(journal_state_count(new, new.idx));
|
2022-03-01 00:29:19 +00:00
|
|
|
BUG_ON(new.idx != (journal_cur_seq(j) & JOURNAL_BUF_MASK));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
journal_state_inc(&new);
|
2022-12-14 15:39:04 +00:00
|
|
|
|
|
|
|
/* Handle any already added entries */
|
|
|
|
new.cur_entry_offset = le32_to_cpu(buf->data->u64s);
|
2017-03-17 06:18:50 +00:00
|
|
|
} while ((v = atomic64_cmpxchg(&j->reservations.counter,
|
|
|
|
old.v, new.v)) != old.v);
|
|
|
|
|
|
|
|
if (j->res_get_blocked_start)
|
|
|
|
bch2_time_stats_update(j->blocked_time,
|
|
|
|
j->res_get_blocked_start);
|
|
|
|
j->res_get_blocked_start = 0;
|
|
|
|
|
2021-05-22 21:37:25 +00:00
|
|
|
mod_delayed_work(c->io_complete_wq,
|
2017-03-17 06:18:50 +00:00
|
|
|
&j->write_work,
|
2021-12-05 01:07:19 +00:00
|
|
|
msecs_to_jiffies(c->opts.journal_flush_delay));
|
2017-03-17 06:18:50 +00:00
|
|
|
journal_wake(j);
|
2022-12-14 15:39:04 +00:00
|
|
|
|
|
|
|
if (j->early_journal_entries.nr)
|
|
|
|
darray_exit(&j->early_journal_entries);
|
2019-02-18 22:39:42 +00:00
|
|
|
return 0;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2019-02-14 23:38:52 +00:00
|
|
|
static bool journal_quiesced(struct journal *j)
|
|
|
|
{
|
2022-02-28 23:48:33 +00:00
|
|
|
bool ret = atomic64_read(&j->seq) == j->seq_ondisk;
|
2019-02-14 23:38:52 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
if (!ret)
|
|
|
|
journal_entry_close(j);
|
2019-02-14 23:38:52 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void journal_quiesce(struct journal *j)
|
|
|
|
{
|
|
|
|
wait_event(j->wait, journal_quiesced(j));
|
|
|
|
}
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
static void journal_write_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct journal *j = container_of(work, struct journal, write_work.work);
|
2022-02-25 15:28:20 +00:00
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
|
|
|
long delta;
|
|
|
|
|
|
|
|
spin_lock(&j->lock);
|
2022-03-05 18:38:54 +00:00
|
|
|
if (!__journal_entry_is_open(j->reservations))
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
delta = journal_cur_buf(j)->expires - jiffies;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-02-25 15:28:20 +00:00
|
|
|
if (delta > 0)
|
|
|
|
mod_delayed_work(c->io_complete_wq, &j->write_work, delta);
|
|
|
|
else
|
2022-02-28 23:48:33 +00:00
|
|
|
__journal_entry_close(j, JOURNAL_ENTRY_CLOSED_VAL);
|
2022-03-05 18:38:54 +00:00
|
|
|
unlock:
|
2022-02-25 15:28:20 +00:00
|
|
|
spin_unlock(&j->lock);
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __journal_res_get(struct journal *j, struct journal_res *res,
|
2018-11-19 02:35:59 +00:00
|
|
|
unsigned flags)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
|
|
|
struct journal_buf *buf;
|
2019-03-03 23:39:07 +00:00
|
|
|
bool can_discard;
|
2017-03-17 06:18:50 +00:00
|
|
|
int ret;
|
|
|
|
retry:
|
2018-11-19 02:35:59 +00:00
|
|
|
if (journal_res_get_fast(j, res, flags))
|
|
|
|
return 0;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
if (bch2_journal_error(j))
|
2022-12-12 01:37:11 +00:00
|
|
|
return -BCH_ERR_erofs_journal_err;
|
2019-02-18 22:39:42 +00:00
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_lock(&j->lock);
|
2019-02-18 22:39:42 +00:00
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
/*
|
|
|
|
* Recheck after taking the lock, so we don't race with another thread
|
|
|
|
* that just did journal_entry_open() and call journal_entry_close()
|
|
|
|
* unnecessarily
|
|
|
|
*/
|
2018-11-19 02:35:59 +00:00
|
|
|
if (journal_res_get_fast(j, res, flags)) {
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_unlock(&j->lock);
|
2018-11-19 02:35:59 +00:00
|
|
|
return 0;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2022-03-15 01:48:42 +00:00
|
|
|
if ((flags & JOURNAL_WATERMARK_MASK) < j->watermark) {
|
2019-02-19 18:41:36 +00:00
|
|
|
/*
|
|
|
|
* Don't want to close current journal entry, just need to
|
|
|
|
* invoke reclaim:
|
|
|
|
*/
|
2022-03-15 01:48:42 +00:00
|
|
|
ret = JOURNAL_ERR_journal_full;
|
2019-02-19 18:41:36 +00:00
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
/*
|
|
|
|
* If we couldn't get a reservation because the current buf filled up,
|
|
|
|
* and we had room for a bigger entry on disk, signal that we want to
|
|
|
|
* realloc the journal bufs:
|
|
|
|
*/
|
|
|
|
buf = journal_cur_buf(j);
|
|
|
|
if (journal_entry_is_open(j) &&
|
2019-02-18 22:39:42 +00:00
|
|
|
buf->buf_size >> 9 < buf->disk_sectors &&
|
|
|
|
buf->buf_size < JOURNAL_ENTRY_SIZE_MAX)
|
|
|
|
j->buf_size_want = max(j->buf_size_want, buf->buf_size << 1);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-02-28 23:48:33 +00:00
|
|
|
__journal_entry_close(j, JOURNAL_ENTRY_CLOSED_VAL);
|
2022-03-01 00:29:19 +00:00
|
|
|
ret = journal_entry_open(j);
|
|
|
|
|
2022-03-15 01:48:42 +00:00
|
|
|
if (ret == JOURNAL_ERR_max_in_flight)
|
2022-08-27 16:48:36 +00:00
|
|
|
trace_and_count(c, journal_entry_full, c);
|
2019-02-19 18:41:36 +00:00
|
|
|
unlock:
|
2022-03-15 01:48:42 +00:00
|
|
|
if ((ret && ret != JOURNAL_ERR_insufficient_devices) &&
|
2020-11-18 18:21:59 +00:00
|
|
|
!j->res_get_blocked_start) {
|
2019-02-18 22:39:42 +00:00
|
|
|
j->res_get_blocked_start = local_clock() ?: 1;
|
2022-08-27 16:48:36 +00:00
|
|
|
trace_and_count(c, journal_full, c);
|
2020-11-18 18:21:59 +00:00
|
|
|
}
|
2019-02-18 22:39:42 +00:00
|
|
|
|
2019-03-03 23:39:07 +00:00
|
|
|
can_discard = j->can_discard;
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_unlock(&j->lock);
|
|
|
|
|
2019-02-18 22:39:42 +00:00
|
|
|
if (!ret)
|
2017-03-17 06:18:50 +00:00
|
|
|
goto retry;
|
2019-03-03 23:39:07 +00:00
|
|
|
|
2022-03-15 01:48:42 +00:00
|
|
|
if ((ret == JOURNAL_ERR_journal_full ||
|
|
|
|
ret == JOURNAL_ERR_journal_pin_full) &&
|
2021-04-03 20:24:13 +00:00
|
|
|
!can_discard &&
|
2022-03-01 00:17:27 +00:00
|
|
|
!nr_unwritten_journal_entries(j) &&
|
2022-03-15 01:48:42 +00:00
|
|
|
(flags & JOURNAL_WATERMARK_MASK) == JOURNAL_WATERMARK_reserved) {
|
2022-02-25 18:18:19 +00:00
|
|
|
struct printbuf buf = PRINTBUF;
|
2021-04-03 20:24:13 +00:00
|
|
|
|
2022-03-15 01:48:42 +00:00
|
|
|
bch_err(c, "Journal stuck! Hava a pre-reservation but journal full (ret %s)",
|
|
|
|
bch2_journal_errors[ret]);
|
2021-04-03 20:24:13 +00:00
|
|
|
|
2022-02-25 18:18:19 +00:00
|
|
|
bch2_journal_debug_to_text(&buf, j);
|
|
|
|
bch_err(c, "%s", buf.buf);
|
|
|
|
|
|
|
|
printbuf_reset(&buf);
|
|
|
|
bch2_journal_pins_to_text(&buf, j);
|
|
|
|
bch_err(c, "Journal pins:\n%s", buf.buf);
|
2021-04-03 20:24:13 +00:00
|
|
|
|
2022-02-25 18:18:19 +00:00
|
|
|
printbuf_exit(&buf);
|
2021-04-03 20:24:13 +00:00
|
|
|
bch2_fatal_error(c);
|
|
|
|
dump_stack();
|
|
|
|
}
|
|
|
|
|
2020-11-18 18:21:59 +00:00
|
|
|
/*
|
|
|
|
* Journal is full - can't rely on reclaim from work item due to
|
|
|
|
* freezing:
|
|
|
|
*/
|
2022-03-15 01:48:42 +00:00
|
|
|
if ((ret == JOURNAL_ERR_journal_full ||
|
|
|
|
ret == JOURNAL_ERR_journal_pin_full) &&
|
2020-11-18 18:21:59 +00:00
|
|
|
!(flags & JOURNAL_RES_GET_NONBLOCK)) {
|
|
|
|
if (can_discard) {
|
|
|
|
bch2_journal_do_discards(j);
|
|
|
|
goto retry;
|
2019-03-03 23:39:07 +00:00
|
|
|
}
|
|
|
|
|
2020-11-18 18:21:59 +00:00
|
|
|
if (mutex_trylock(&j->reclaim_lock)) {
|
|
|
|
bch2_journal_reclaim(j);
|
|
|
|
mutex_unlock(&j->reclaim_lock);
|
|
|
|
}
|
2019-02-18 22:39:42 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-12-13 20:17:40 +00:00
|
|
|
return ret == JOURNAL_ERR_insufficient_devices
|
|
|
|
? -EROFS
|
|
|
|
: -BCH_ERR_journal_res_get_blocked;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Essentially the entry function to the journaling code. When bcachefs is doing
|
|
|
|
* a btree insert, it calls this function to get the current journal write.
|
|
|
|
* Journal write is the structure used set up journal writes. The calling
|
|
|
|
* function will then add its keys to the structure, queuing them for the next
|
|
|
|
* write.
|
|
|
|
*
|
|
|
|
* To ensure forward progress, the current task must not be holding any
|
|
|
|
* btree node write locks.
|
|
|
|
*/
|
|
|
|
int bch2_journal_res_get_slowpath(struct journal *j, struct journal_res *res,
|
2018-11-19 02:35:59 +00:00
|
|
|
unsigned flags)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2019-02-21 18:33:21 +00:00
|
|
|
closure_wait_event(&j->async_wait,
|
2022-12-13 20:17:40 +00:00
|
|
|
(ret = __journal_res_get(j, res, flags)) !=
|
|
|
|
-BCH_ERR_journal_res_get_blocked||
|
2018-11-19 02:35:59 +00:00
|
|
|
(flags & JOURNAL_RES_GET_NONBLOCK));
|
|
|
|
return ret;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2019-02-19 18:41:36 +00:00
|
|
|
/* journal_preres: */
|
|
|
|
|
|
|
|
static bool journal_preres_available(struct journal *j,
|
|
|
|
struct journal_preres *res,
|
2020-06-10 00:54:36 +00:00
|
|
|
unsigned new_u64s,
|
|
|
|
unsigned flags)
|
2019-02-19 18:41:36 +00:00
|
|
|
{
|
2021-04-04 01:31:02 +00:00
|
|
|
bool ret = bch2_journal_preres_get_fast(j, res, new_u64s, flags, true);
|
2019-02-19 18:41:36 +00:00
|
|
|
|
2020-11-20 01:55:33 +00:00
|
|
|
if (!ret && mutex_trylock(&j->reclaim_lock)) {
|
|
|
|
bch2_journal_reclaim(j);
|
|
|
|
mutex_unlock(&j->reclaim_lock);
|
|
|
|
}
|
2019-02-19 18:41:36 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int __bch2_journal_preres_get(struct journal *j,
|
|
|
|
struct journal_preres *res,
|
2020-06-10 00:54:36 +00:00
|
|
|
unsigned new_u64s,
|
|
|
|
unsigned flags)
|
2019-02-19 18:41:36 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
closure_wait_event(&j->preres_wait,
|
|
|
|
(ret = bch2_journal_error(j)) ||
|
2020-06-10 00:54:36 +00:00
|
|
|
journal_preres_available(j, res, new_u64s, flags));
|
2019-02-19 18:41:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-01-24 21:50:48 +00:00
|
|
|
/* journal_entry_res: */
|
|
|
|
|
|
|
|
void bch2_journal_entry_res_resize(struct journal *j,
|
|
|
|
struct journal_entry_res *res,
|
|
|
|
unsigned new_u64s)
|
|
|
|
{
|
|
|
|
union journal_res_state state;
|
|
|
|
int d = new_u64s - res->u64s;
|
|
|
|
|
|
|
|
spin_lock(&j->lock);
|
|
|
|
|
|
|
|
j->entry_u64s_reserved += d;
|
|
|
|
if (d <= 0)
|
2019-02-18 22:39:42 +00:00
|
|
|
goto out;
|
2019-01-24 21:50:48 +00:00
|
|
|
|
2019-02-28 00:14:23 +00:00
|
|
|
j->cur_entry_u64s = max_t(int, 0, j->cur_entry_u64s - d);
|
2019-01-24 21:50:48 +00:00
|
|
|
smp_mb();
|
|
|
|
state = READ_ONCE(j->reservations);
|
|
|
|
|
|
|
|
if (state.cur_entry_offset < JOURNAL_ENTRY_CLOSED_VAL &&
|
|
|
|
state.cur_entry_offset > j->cur_entry_u64s) {
|
|
|
|
j->cur_entry_u64s += d;
|
|
|
|
/*
|
|
|
|
* Not enough room in current journal entry, have to flush it:
|
|
|
|
*/
|
2022-02-28 23:48:33 +00:00
|
|
|
__journal_entry_close(j, JOURNAL_ENTRY_CLOSED_VAL);
|
2019-02-18 22:39:42 +00:00
|
|
|
} else {
|
|
|
|
journal_cur_buf(j)->u64s_reserved += d;
|
2019-01-24 21:50:48 +00:00
|
|
|
}
|
|
|
|
out:
|
2019-02-18 22:39:42 +00:00
|
|
|
spin_unlock(&j->lock);
|
2019-01-24 21:50:48 +00:00
|
|
|
res->u64s += d;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* journal flushing: */
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
/**
|
|
|
|
* bch2_journal_flush_seq_async - wait for a journal entry to be written
|
|
|
|
*
|
|
|
|
* like bch2_journal_wait_on_seq, except that it triggers a write immediately if
|
|
|
|
* necessary
|
|
|
|
*/
|
2020-11-14 21:04:30 +00:00
|
|
|
int bch2_journal_flush_seq_async(struct journal *j, u64 seq,
|
2020-11-21 00:27:57 +00:00
|
|
|
struct closure *parent)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
|
|
|
struct journal_buf *buf;
|
2020-11-14 21:04:30 +00:00
|
|
|
int ret = 0;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
if (seq <= j->flushed_seq_ondisk)
|
2020-11-21 00:27:57 +00:00
|
|
|
return 1;
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_lock(&j->lock);
|
2020-11-21 00:27:57 +00:00
|
|
|
|
2021-11-13 22:53:55 +00:00
|
|
|
if (WARN_ONCE(seq > journal_cur_seq(j),
|
|
|
|
"requested to flush journal seq %llu, but currently at %llu",
|
|
|
|
seq, journal_cur_seq(j)))
|
|
|
|
goto out;
|
2021-02-10 18:39:48 +00:00
|
|
|
|
2020-11-21 00:27:57 +00:00
|
|
|
/* Recheck under lock: */
|
2020-12-02 20:33:12 +00:00
|
|
|
if (j->err_seq && seq >= j->err_seq) {
|
2020-11-14 21:04:30 +00:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
if (seq <= j->flushed_seq_ondisk) {
|
2020-11-14 21:04:30 +00:00
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
/* if seq was written, but not flushed - flush a newer one instead */
|
2022-03-01 00:17:27 +00:00
|
|
|
seq = max(seq, journal_last_unwritten_seq(j));
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
|
|
|
|
recheck_need_open:
|
2022-02-28 21:35:42 +00:00
|
|
|
if (seq > journal_cur_seq(j)) {
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
struct journal_res res = { 0 };
|
|
|
|
|
2022-02-28 21:35:42 +00:00
|
|
|
if (journal_entry_is_open(j))
|
2022-02-28 23:48:33 +00:00
|
|
|
__journal_entry_close(j, JOURNAL_ENTRY_CLOSED_VAL);
|
2022-02-28 21:35:42 +00:00
|
|
|
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
spin_unlock(&j->lock);
|
|
|
|
|
|
|
|
ret = bch2_journal_res_get(j, &res, jset_u64s(0), 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
seq = res.seq;
|
|
|
|
buf = j->buf + (seq & JOURNAL_BUF_MASK);
|
|
|
|
buf->must_flush = true;
|
2022-02-25 15:28:20 +00:00
|
|
|
|
|
|
|
if (!buf->flush_time) {
|
|
|
|
buf->flush_time = local_clock() ?: 1;
|
|
|
|
buf->expires = jiffies;
|
|
|
|
}
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
|
|
|
|
if (parent && !closure_wait(&buf->wait, parent))
|
2017-03-17 06:18:50 +00:00
|
|
|
BUG();
|
|
|
|
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
bch2_journal_res_put(j, &res);
|
|
|
|
|
|
|
|
spin_lock(&j->lock);
|
|
|
|
goto want_write;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if write was kicked off without a flush, flush the next sequence
|
|
|
|
* number instead
|
|
|
|
*/
|
|
|
|
buf = journal_seq_to_buf(j, seq);
|
|
|
|
if (buf->noflush) {
|
|
|
|
seq++;
|
|
|
|
goto recheck_need_open;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf->must_flush = true;
|
|
|
|
|
|
|
|
if (parent && !closure_wait(&buf->wait, parent))
|
|
|
|
BUG();
|
|
|
|
want_write:
|
2018-07-23 11:52:00 +00:00
|
|
|
if (seq == journal_cur_seq(j))
|
2020-11-13 23:36:33 +00:00
|
|
|
journal_entry_want_write(j);
|
2020-11-14 21:04:30 +00:00
|
|
|
out:
|
2019-02-18 22:39:42 +00:00
|
|
|
spin_unlock(&j->lock);
|
2017-03-17 06:18:50 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bch2_journal_flush_seq(struct journal *j, u64 seq)
|
|
|
|
{
|
|
|
|
u64 start_time = local_clock();
|
|
|
|
int ret, ret2;
|
|
|
|
|
2021-12-10 20:41:38 +00:00
|
|
|
/*
|
|
|
|
* Don't update time_stats when @seq is already flushed:
|
|
|
|
*/
|
|
|
|
if (seq <= j->flushed_seq_ondisk)
|
|
|
|
return 0;
|
|
|
|
|
2021-02-10 00:54:04 +00:00
|
|
|
ret = wait_event_interruptible(j->wait, (ret2 = bch2_journal_flush_seq_async(j, seq, NULL)));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2021-02-10 00:54:04 +00:00
|
|
|
if (!ret)
|
|
|
|
bch2_time_stats_update(j->flush_seq_time, start_time);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
return ret ?: ret2 < 0 ? ret2 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bch2_journal_flush_async - if there is an open journal entry, or a journal
|
|
|
|
* still being written, write it and wait for the write to complete
|
|
|
|
*/
|
|
|
|
void bch2_journal_flush_async(struct journal *j, struct closure *parent)
|
|
|
|
{
|
2022-02-28 21:35:42 +00:00
|
|
|
bch2_journal_flush_seq_async(j, atomic64_read(&j->seq), parent);
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int bch2_journal_flush(struct journal *j)
|
|
|
|
{
|
2022-02-28 21:35:42 +00:00
|
|
|
return bch2_journal_flush_seq(j, atomic64_read(&j->seq));
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2021-12-28 04:51:48 +00:00
|
|
|
/*
|
|
|
|
* bch2_journal_noflush_seq - tell the journal not to issue any flushes before
|
|
|
|
* @seq
|
|
|
|
*/
|
|
|
|
bool bch2_journal_noflush_seq(struct journal *j, u64 seq)
|
|
|
|
{
|
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
|
|
|
u64 unwritten_seq;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
if (!(c->sb.features & (1ULL << BCH_FEATURE_journal_no_flush)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (seq <= c->journal.flushed_seq_ondisk)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
spin_lock(&j->lock);
|
|
|
|
if (seq <= c->journal.flushed_seq_ondisk)
|
|
|
|
goto out;
|
|
|
|
|
2022-03-01 00:17:27 +00:00
|
|
|
for (unwritten_seq = journal_last_unwritten_seq(j);
|
2021-12-28 04:51:48 +00:00
|
|
|
unwritten_seq < seq;
|
|
|
|
unwritten_seq++) {
|
|
|
|
struct journal_buf *buf = journal_seq_to_buf(j, unwritten_seq);
|
|
|
|
|
|
|
|
/* journal write is already in flight, and was a flush write: */
|
2022-03-01 00:17:27 +00:00
|
|
|
if (unwritten_seq == journal_last_unwritten_seq(j) && !buf->noflush)
|
2021-12-28 04:51:48 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
buf->noflush = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
out:
|
|
|
|
spin_unlock(&j->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-10 19:25:16 +00:00
|
|
|
int bch2_journal_meta(struct journal *j)
|
|
|
|
{
|
|
|
|
struct journal_buf *buf;
|
|
|
|
struct journal_res res;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset(&res, 0, sizeof(res));
|
|
|
|
|
|
|
|
ret = bch2_journal_res_get(j, &res, jset_u64s(0), 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
buf = j->buf + (res.seq & JOURNAL_BUF_MASK);
|
|
|
|
buf->must_flush = true;
|
|
|
|
|
|
|
|
if (!buf->flush_time) {
|
|
|
|
buf->flush_time = local_clock() ?: 1;
|
|
|
|
buf->expires = jiffies;
|
|
|
|
}
|
|
|
|
|
|
|
|
bch2_journal_res_put(j, &res);
|
|
|
|
|
|
|
|
return bch2_journal_flush_seq(j, res.seq);
|
|
|
|
}
|
|
|
|
|
2019-02-14 23:38:52 +00:00
|
|
|
/* block/unlock the journal: */
|
|
|
|
|
|
|
|
void bch2_journal_unblock(struct journal *j)
|
|
|
|
{
|
|
|
|
spin_lock(&j->lock);
|
|
|
|
j->blocked--;
|
|
|
|
spin_unlock(&j->lock);
|
|
|
|
|
|
|
|
journal_wake(j);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bch2_journal_block(struct journal *j)
|
|
|
|
{
|
|
|
|
spin_lock(&j->lock);
|
|
|
|
j->blocked++;
|
|
|
|
spin_unlock(&j->lock);
|
|
|
|
|
|
|
|
journal_quiesce(j);
|
|
|
|
}
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
/* allocate journal on a device: */
|
|
|
|
|
|
|
|
static int __bch2_set_nr_journal_buckets(struct bch_dev *ca, unsigned nr,
|
|
|
|
bool new_fs, struct closure *cl)
|
|
|
|
{
|
|
|
|
struct bch_fs *c = ca->fs;
|
|
|
|
struct journal_device *ja = &ca->journal;
|
|
|
|
u64 *new_bucket_seq = NULL, *new_buckets = NULL;
|
2022-03-10 21:43:52 +00:00
|
|
|
struct open_bucket **ob = NULL;
|
|
|
|
long *bu = NULL;
|
|
|
|
unsigned i, nr_got = 0, nr_want = nr - ja->nr;
|
|
|
|
unsigned old_nr = ja->nr;
|
|
|
|
unsigned old_discard_idx = ja->discard_idx;
|
|
|
|
unsigned old_dirty_idx_ondisk = ja->dirty_idx_ondisk;
|
|
|
|
unsigned old_dirty_idx = ja->dirty_idx;
|
|
|
|
unsigned old_cur_idx = ja->cur_idx;
|
2017-03-17 06:18:50 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
if (c) {
|
|
|
|
bch2_journal_flush_all_pins(&c->journal);
|
|
|
|
bch2_journal_block(&c->journal);
|
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-10-19 22:31:33 +00:00
|
|
|
bu = kcalloc(nr_want, sizeof(*bu), GFP_KERNEL);
|
|
|
|
ob = kcalloc(nr_want, sizeof(*ob), GFP_KERNEL);
|
|
|
|
new_buckets = kcalloc(nr, sizeof(u64), GFP_KERNEL);
|
|
|
|
new_bucket_seq = kcalloc(nr, sizeof(u64), GFP_KERNEL);
|
2022-03-10 21:43:52 +00:00
|
|
|
if (!bu || !ob || !new_buckets || !new_bucket_seq) {
|
2020-11-20 21:12:39 +00:00
|
|
|
ret = -ENOMEM;
|
2022-03-10 21:43:52 +00:00
|
|
|
goto err_unblock;
|
2020-11-20 21:12:39 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
for (nr_got = 0; nr_got < nr_want; nr_got++) {
|
|
|
|
if (new_fs) {
|
|
|
|
bu[nr_got] = bch2_bucket_alloc_new_fs(ca);
|
|
|
|
if (bu[nr_got] < 0) {
|
2022-09-18 21:10:33 +00:00
|
|
|
ret = -BCH_ERR_ENOSPC_bucket_alloc;
|
2022-03-10 21:43:52 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ob[nr_got] = bch2_bucket_alloc(c, ca, RESERVE_none,
|
|
|
|
false, cl);
|
2022-12-13 20:17:40 +00:00
|
|
|
ret = PTR_ERR_OR_ZERO(ob[nr_got]);
|
|
|
|
if (ret)
|
2022-03-10 21:43:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
bu[nr_got] = ob[nr_got]->bucket;
|
|
|
|
}
|
2020-11-20 21:12:39 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
if (!nr_got)
|
|
|
|
goto err_unblock;
|
|
|
|
|
2018-07-21 02:08:17 +00:00
|
|
|
/*
|
|
|
|
* We may be called from the device add path, before the new device has
|
|
|
|
* actually been added to the running filesystem:
|
|
|
|
*/
|
2021-04-15 00:23:58 +00:00
|
|
|
if (!new_fs)
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_lock(&c->journal.lock);
|
|
|
|
|
|
|
|
memcpy(new_buckets, ja->buckets, ja->nr * sizeof(u64));
|
|
|
|
memcpy(new_bucket_seq, ja->bucket_seq, ja->nr * sizeof(u64));
|
|
|
|
swap(new_buckets, ja->buckets);
|
|
|
|
swap(new_bucket_seq, ja->bucket_seq);
|
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
for (i = 0; i < nr_got; i++) {
|
|
|
|
unsigned pos = ja->discard_idx ?: ja->nr;
|
|
|
|
long b = bu[i];
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-03-03 20:15:55 +00:00
|
|
|
__array_insert_item(ja->buckets, ja->nr, pos);
|
|
|
|
__array_insert_item(ja->bucket_seq, ja->nr, pos);
|
|
|
|
ja->nr++;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2021-04-15 00:23:58 +00:00
|
|
|
ja->buckets[pos] = b;
|
2019-03-03 20:15:55 +00:00
|
|
|
ja->bucket_seq[pos] = 0;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-03-03 20:15:55 +00:00
|
|
|
if (pos <= ja->discard_idx)
|
|
|
|
ja->discard_idx = (ja->discard_idx + 1) % ja->nr;
|
|
|
|
if (pos <= ja->dirty_idx_ondisk)
|
|
|
|
ja->dirty_idx_ondisk = (ja->dirty_idx_ondisk + 1) % ja->nr;
|
|
|
|
if (pos <= ja->dirty_idx)
|
|
|
|
ja->dirty_idx = (ja->dirty_idx + 1) % ja->nr;
|
|
|
|
if (pos <= ja->cur_idx)
|
|
|
|
ja->cur_idx = (ja->cur_idx + 1) % ja->nr;
|
2022-03-10 21:43:52 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
ret = bch2_journal_buckets_to_sb(c, ca);
|
|
|
|
if (ret) {
|
|
|
|
/* Revert: */
|
|
|
|
swap(new_buckets, ja->buckets);
|
|
|
|
swap(new_bucket_seq, ja->bucket_seq);
|
|
|
|
ja->nr = old_nr;
|
|
|
|
ja->discard_idx = old_discard_idx;
|
|
|
|
ja->dirty_idx_ondisk = old_dirty_idx_ondisk;
|
|
|
|
ja->dirty_idx = old_dirty_idx;
|
|
|
|
ja->cur_idx = old_cur_idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!new_fs)
|
|
|
|
spin_unlock(&c->journal.lock);
|
2021-05-17 03:46:08 +00:00
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
if (c)
|
|
|
|
bch2_journal_unblock(&c->journal);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
if (!new_fs) {
|
|
|
|
for (i = 0; i < nr_got; i++) {
|
2022-07-14 06:08:58 +00:00
|
|
|
ret = bch2_trans_run(c,
|
2021-04-15 00:25:33 +00:00
|
|
|
bch2_trans_mark_metadata_bucket(&trans, ca,
|
2022-03-10 21:43:52 +00:00
|
|
|
bu[i], BCH_DATA_journal,
|
2021-01-22 22:56:34 +00:00
|
|
|
ca->mi.bucket_size));
|
2022-03-10 21:43:52 +00:00
|
|
|
if (ret) {
|
|
|
|
bch2_fs_inconsistent(c, "error marking new journal buckets: %i", ret);
|
2021-04-15 00:23:58 +00:00
|
|
|
goto err;
|
2022-03-10 21:43:52 +00:00
|
|
|
}
|
2021-04-15 00:23:58 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
err:
|
2022-03-10 21:43:52 +00:00
|
|
|
if (ob && !new_fs)
|
|
|
|
for (i = 0; i < nr_got; i++)
|
|
|
|
bch2_open_bucket_put(c, ob[i]);
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
kfree(new_bucket_seq);
|
|
|
|
kfree(new_buckets);
|
2022-03-10 21:43:52 +00:00
|
|
|
kfree(ob);
|
|
|
|
kfree(bu);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
return ret;
|
2022-03-10 21:43:52 +00:00
|
|
|
err_unblock:
|
|
|
|
if (c)
|
|
|
|
bch2_journal_unblock(&c->journal);
|
|
|
|
goto err;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate more journal space at runtime - not currently making use if it, but
|
|
|
|
* the code works:
|
|
|
|
*/
|
|
|
|
int bch2_set_nr_journal_buckets(struct bch_fs *c, struct bch_dev *ca,
|
|
|
|
unsigned nr)
|
|
|
|
{
|
|
|
|
struct journal_device *ja = &ca->journal;
|
|
|
|
struct closure cl;
|
|
|
|
unsigned current_nr;
|
2022-03-10 21:43:52 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* don't handle reducing nr of buckets yet: */
|
|
|
|
if (nr < ja->nr)
|
|
|
|
return 0;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
closure_init_stack(&cl);
|
|
|
|
|
2022-12-13 20:17:40 +00:00
|
|
|
while (ja->nr != nr && (ret == 0 || ret == -BCH_ERR_bucket_alloc_blocked)) {
|
2017-03-17 06:18:50 +00:00
|
|
|
struct disk_reservation disk_res = { 0, 0 };
|
|
|
|
|
|
|
|
closure_sync(&cl);
|
|
|
|
|
|
|
|
mutex_lock(&c->sb_lock);
|
|
|
|
current_nr = ja->nr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* note: journal buckets aren't really counted as _sectors_ used yet, so
|
|
|
|
* we don't need the disk reservation to avoid the BUG_ON() in buckets.c
|
|
|
|
* when space used goes up without a reservation - but we do need the
|
|
|
|
* reservation to ensure we'll actually be able to allocate:
|
|
|
|
*/
|
|
|
|
|
2022-09-18 21:10:33 +00:00
|
|
|
ret = bch2_disk_reservation_get(c, &disk_res,
|
|
|
|
bucket_to_sector(ca, nr - ja->nr), 1, 0);
|
|
|
|
if (ret) {
|
2017-03-17 06:18:50 +00:00
|
|
|
mutex_unlock(&c->sb_lock);
|
2022-09-18 21:10:33 +00:00
|
|
|
return ret;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = __bch2_set_nr_journal_buckets(ca, nr, false, &cl);
|
|
|
|
|
|
|
|
bch2_disk_reservation_put(c, &disk_res);
|
|
|
|
|
|
|
|
if (ja->nr != current_nr)
|
|
|
|
bch2_write_super(c);
|
|
|
|
mutex_unlock(&c->sb_lock);
|
2022-03-10 21:43:52 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bch2_dev_journal_alloc(struct bch_dev *ca)
|
|
|
|
{
|
|
|
|
unsigned nr;
|
2022-03-10 21:43:52 +00:00
|
|
|
int ret;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
if (dynamic_fault("bcachefs:add:journal_alloc"))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2021-03-25 02:49:05 +00:00
|
|
|
/* 1/128th of the device by default: */
|
|
|
|
nr = ca->mi.nbuckets >> 7;
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
/*
|
2021-03-25 02:49:05 +00:00
|
|
|
* clamp journal size to 8192 buckets or 8GB (in sectors), whichever
|
2017-03-17 06:18:50 +00:00
|
|
|
* is smaller:
|
|
|
|
*/
|
2021-03-25 02:49:05 +00:00
|
|
|
nr = clamp_t(unsigned, nr,
|
2017-03-17 06:18:50 +00:00
|
|
|
BCH_JOURNAL_BUCKETS_MIN,
|
2021-03-25 02:49:05 +00:00
|
|
|
min(1 << 13,
|
|
|
|
(1 << 24) / ca->mi.bucket_size));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
if (ca->fs)
|
|
|
|
mutex_lock(&ca->fs->sb_lock);
|
|
|
|
|
|
|
|
ret = __bch2_set_nr_journal_buckets(ca, nr, true, NULL);
|
|
|
|
|
|
|
|
if (ca->fs)
|
|
|
|
mutex_unlock(&ca->fs->sb_lock);
|
|
|
|
|
|
|
|
return ret;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* startup/shutdown: */
|
|
|
|
|
|
|
|
static bool bch2_journal_writing_to_device(struct journal *j, unsigned dev_idx)
|
|
|
|
{
|
2020-11-13 23:36:33 +00:00
|
|
|
bool ret = false;
|
2022-03-01 00:17:27 +00:00
|
|
|
u64 seq;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
spin_lock(&j->lock);
|
2022-03-01 00:17:27 +00:00
|
|
|
for (seq = journal_last_unwritten_seq(j);
|
|
|
|
seq <= journal_cur_seq(j) && !ret;
|
|
|
|
seq++) {
|
|
|
|
struct journal_buf *buf = journal_seq_to_buf(j, seq);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-01 00:17:27 +00:00
|
|
|
if (bch2_bkey_has_device(bkey_i_to_s_c(&buf->key), dev_idx))
|
2020-11-13 23:36:33 +00:00
|
|
|
ret = true;
|
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_unlock(&j->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bch2_dev_journal_stop(struct journal *j, struct bch_dev *ca)
|
|
|
|
{
|
|
|
|
wait_event(j->wait, !bch2_journal_writing_to_device(j, ca->dev_idx));
|
|
|
|
}
|
|
|
|
|
|
|
|
void bch2_fs_journal_stop(struct journal *j)
|
|
|
|
{
|
2022-03-05 18:38:54 +00:00
|
|
|
bch2_journal_reclaim_stop(j);
|
2019-05-10 15:58:00 +00:00
|
|
|
bch2_journal_flush_all_pins(j);
|
|
|
|
|
2018-07-23 11:52:00 +00:00
|
|
|
wait_event(j->wait, journal_entry_close(j));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2020-10-25 05:08:28 +00:00
|
|
|
/*
|
|
|
|
* Always write a new journal entry, to make sure the clock hands are up
|
|
|
|
* to date (and match the superblock)
|
|
|
|
*/
|
|
|
|
bch2_journal_meta(j);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2019-02-14 23:38:52 +00:00
|
|
|
journal_quiesce(j);
|
2018-07-23 11:52:00 +00:00
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
BUG_ON(!bch2_journal_error(j) &&
|
2021-01-22 00:15:49 +00:00
|
|
|
test_bit(JOURNAL_REPLAY_DONE, &j->flags) &&
|
2022-02-28 21:35:42 +00:00
|
|
|
j->last_empty_seq != journal_cur_seq(j));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
cancel_delayed_work_sync(&j->write_work);
|
|
|
|
}
|
|
|
|
|
2022-03-21 04:15:53 +00:00
|
|
|
int bch2_fs_journal_start(struct journal *j, u64 cur_seq)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
2018-07-22 02:57:20 +00:00
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
2019-04-05 01:53:12 +00:00
|
|
|
struct journal_entry_pin_list *p;
|
2022-03-21 04:15:53 +00:00
|
|
|
struct journal_replay *i, **_i;
|
|
|
|
struct genradix_iter iter;
|
|
|
|
bool had_entries = false;
|
|
|
|
unsigned ptr;
|
2019-04-05 01:53:12 +00:00
|
|
|
u64 last_seq = cur_seq, nr, seq;
|
|
|
|
|
2022-03-21 04:15:53 +00:00
|
|
|
genradix_for_each_reverse(&c->journal_entries, iter, _i) {
|
|
|
|
i = *_i;
|
|
|
|
|
|
|
|
if (!i || i->ignore)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
last_seq = le64_to_cpu(i->j.last_seq);
|
|
|
|
break;
|
|
|
|
}
|
2019-04-05 01:53:12 +00:00
|
|
|
|
|
|
|
nr = cur_seq - last_seq;
|
|
|
|
|
|
|
|
if (nr + 1 > j->pin.size) {
|
|
|
|
free_fifo(&j->pin);
|
|
|
|
init_fifo(&j->pin, roundup_pow_of_two(nr + 1), GFP_KERNEL);
|
|
|
|
if (!j->pin.data) {
|
|
|
|
bch_err(c, "error reallocating journal fifo (%llu open entries)", nr);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-12 02:39:39 +00:00
|
|
|
j->replay_journal_seq = last_seq;
|
|
|
|
j->replay_journal_seq_end = cur_seq;
|
2019-04-05 01:53:12 +00:00
|
|
|
j->last_seq_ondisk = last_seq;
|
2021-12-20 21:55:49 +00:00
|
|
|
j->flushed_seq_ondisk = cur_seq - 1;
|
2022-03-01 00:17:27 +00:00
|
|
|
j->seq_ondisk = cur_seq - 1;
|
2019-04-05 01:53:12 +00:00
|
|
|
j->pin.front = last_seq;
|
|
|
|
j->pin.back = cur_seq;
|
|
|
|
atomic64_set(&j->seq, cur_seq - 1);
|
|
|
|
|
2021-04-01 01:44:55 +00:00
|
|
|
fifo_for_each_entry_ptr(p, &j->pin, seq)
|
|
|
|
journal_pin_list_init(p, 1);
|
2019-04-05 01:53:12 +00:00
|
|
|
|
2022-03-21 04:15:53 +00:00
|
|
|
genradix_for_each(&c->journal_entries, iter, _i) {
|
|
|
|
i = *_i;
|
|
|
|
|
|
|
|
if (!i || i->ignore)
|
|
|
|
continue;
|
2021-01-26 21:04:12 +00:00
|
|
|
|
2019-04-05 01:53:12 +00:00
|
|
|
seq = le64_to_cpu(i->j.seq);
|
2020-06-13 22:43:14 +00:00
|
|
|
BUG_ON(seq >= cur_seq);
|
2019-04-05 01:53:12 +00:00
|
|
|
|
2020-06-13 22:43:14 +00:00
|
|
|
if (seq < last_seq)
|
|
|
|
continue;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2021-12-20 21:55:49 +00:00
|
|
|
if (journal_entry_empty(&i->j))
|
|
|
|
j->last_empty_seq = le64_to_cpu(i->j.seq);
|
|
|
|
|
2021-01-26 21:04:12 +00:00
|
|
|
p = journal_seq_pin(j, seq);
|
|
|
|
|
|
|
|
p->devs.nr = 0;
|
|
|
|
for (ptr = 0; ptr < i->nr_ptrs; ptr++)
|
|
|
|
bch2_dev_list_add_dev(&p->devs, i->ptrs[ptr].dev);
|
2022-03-21 04:15:53 +00:00
|
|
|
|
|
|
|
had_entries = true;
|
2019-04-05 01:53:12 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-21 04:15:53 +00:00
|
|
|
if (!had_entries)
|
2021-12-20 21:55:49 +00:00
|
|
|
j->last_empty_seq = cur_seq;
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_lock(&j->lock);
|
|
|
|
|
|
|
|
set_bit(JOURNAL_STARTED, &j->flags);
|
bcachefs: Don't require flush/fua on every journal write
This patch adds a flag to journal entries which, if set, indicates that
they weren't done as flush/fua writes.
- non flush/fua journal writes don't update last_seq (i.e. they don't
free up space in the journal), thus the journal free space
calculations now check whether nonflush journal writes are currently
allowed (i.e. are we low on free space, or would doing a flush write
free up a lot of space in the journal)
- write_delay_ms, the user configurable option for when open journal
entries are automatically written, is now interpreted as the max
delay between flush journal writes (default 1 second).
- bch2_journal_flush_seq_async is changed to ensure a flush write >=
the requested sequence number has happened
- journal read/replay must now ignore, and blacklist, any journal
entries newer than the most recent flush entry in the journal. Also,
the way the read_entire_journal option is handled has been improved;
struct journal_replay now has an entry, 'ignore', for entries that
were read but should not be used.
- assorted refactoring and improvements related to journal read in
journal_io.c and recovery.c
Previously, we'd have to issue a flush/fua write every time we
accumulated a full journal entry - typically the bucket size. Now we
need to issue them much less frequently: when an fsync is requested, or
it's been more than write_delay_ms since the last flush, or when we need
to free up space in the journal. This is a significant performance
improvement on many write heavy workloads.
Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>
2020-11-14 14:59:58 +00:00
|
|
|
j->last_flush_write = jiffies;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-03-01 00:29:19 +00:00
|
|
|
j->reservations.idx = j->reservations.unwritten_idx = journal_cur_seq(j);
|
|
|
|
j->reservations.unwritten_idx++;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2018-07-22 02:57:20 +00:00
|
|
|
c->last_bucket_seq_cleanup = journal_cur_seq(j);
|
|
|
|
|
2019-02-21 18:33:21 +00:00
|
|
|
bch2_journal_space_available(j);
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_unlock(&j->lock);
|
|
|
|
|
2021-06-21 20:30:52 +00:00
|
|
|
return bch2_journal_reclaim_start(j);
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* init/exit: */
|
|
|
|
|
|
|
|
void bch2_dev_journal_exit(struct bch_dev *ca)
|
|
|
|
{
|
|
|
|
kfree(ca->journal.bio);
|
|
|
|
kfree(ca->journal.buckets);
|
|
|
|
kfree(ca->journal.bucket_seq);
|
|
|
|
|
|
|
|
ca->journal.bio = NULL;
|
|
|
|
ca->journal.buckets = NULL;
|
|
|
|
ca->journal.bucket_seq = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bch2_dev_journal_init(struct bch_dev *ca, struct bch_sb *sb)
|
|
|
|
{
|
|
|
|
struct journal_device *ja = &ca->journal;
|
|
|
|
struct bch_sb_field_journal *journal_buckets =
|
|
|
|
bch2_sb_get_journal(sb);
|
2022-03-10 21:43:52 +00:00
|
|
|
struct bch_sb_field_journal_v2 *journal_buckets_v2 =
|
|
|
|
bch2_sb_get_journal_v2(sb);
|
2017-03-17 06:18:50 +00:00
|
|
|
unsigned i, nr_bvecs;
|
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
ja->nr = 0;
|
|
|
|
|
|
|
|
if (journal_buckets_v2) {
|
|
|
|
unsigned nr = bch2_sb_field_journal_v2_nr_entries(journal_buckets_v2);
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++)
|
|
|
|
ja->nr += le64_to_cpu(journal_buckets_v2->d[i].nr);
|
|
|
|
} else if (journal_buckets) {
|
|
|
|
ja->nr = bch2_nr_journal_buckets(journal_buckets);
|
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
ja->bucket_seq = kcalloc(ja->nr, sizeof(u64), GFP_KERNEL);
|
|
|
|
if (!ja->bucket_seq)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
nr_bvecs = DIV_ROUND_UP(JOURNAL_ENTRY_SIZE_MAX, PAGE_SIZE);
|
|
|
|
|
|
|
|
ca->journal.bio = bio_kmalloc(nr_bvecs, GFP_KERNEL);
|
|
|
|
if (!ca->journal.bio)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
bio_init(ca->journal.bio, NULL, ca->journal.bio->bi_inline_vecs, nr_bvecs, 0);
|
|
|
|
|
|
|
|
ja->buckets = kcalloc(ja->nr, sizeof(u64), GFP_KERNEL);
|
|
|
|
if (!ja->buckets)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2022-03-10 21:43:52 +00:00
|
|
|
if (journal_buckets_v2) {
|
|
|
|
unsigned nr = bch2_sb_field_journal_v2_nr_entries(journal_buckets_v2);
|
|
|
|
unsigned j, dst = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++)
|
|
|
|
for (j = 0; j < le64_to_cpu(journal_buckets_v2->d[i].nr); j++)
|
|
|
|
ja->buckets[dst++] =
|
|
|
|
le64_to_cpu(journal_buckets_v2->d[i].start) + j;
|
|
|
|
} else if (journal_buckets) {
|
|
|
|
for (i = 0; i < ja->nr; i++)
|
|
|
|
ja->buckets[i] = le64_to_cpu(journal_buckets->buckets[i]);
|
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bch2_fs_journal_exit(struct journal *j)
|
|
|
|
{
|
2020-11-13 23:36:33 +00:00
|
|
|
unsigned i;
|
|
|
|
|
2022-12-14 15:39:04 +00:00
|
|
|
darray_exit(&j->early_journal_entries);
|
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(j->buf); i++)
|
|
|
|
kvpfree(j->buf[i].data, j->buf[i].buf_size);
|
2017-03-17 06:18:50 +00:00
|
|
|
free_fifo(&j->pin);
|
|
|
|
}
|
|
|
|
|
|
|
|
int bch2_fs_journal_init(struct journal *j)
|
|
|
|
{
|
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
|
|
|
static struct lock_class_key res_key;
|
2020-11-13 23:36:33 +00:00
|
|
|
unsigned i;
|
2017-03-17 06:18:50 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
pr_verbose_init(c->opts, "");
|
|
|
|
|
|
|
|
spin_lock_init(&j->lock);
|
|
|
|
spin_lock_init(&j->err_lock);
|
|
|
|
init_waitqueue_head(&j->wait);
|
|
|
|
INIT_DELAYED_WORK(&j->write_work, journal_write_work);
|
2021-03-31 21:52:52 +00:00
|
|
|
init_waitqueue_head(&j->reclaim_wait);
|
2018-07-17 16:19:14 +00:00
|
|
|
init_waitqueue_head(&j->pin_flush_wait);
|
2017-03-17 06:18:50 +00:00
|
|
|
mutex_init(&j->reclaim_lock);
|
2019-03-03 20:15:55 +00:00
|
|
|
mutex_init(&j->discard_lock);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
|
|
|
lockdep_init_map(&j->res_map, "journal res", &res_key, 0);
|
|
|
|
|
|
|
|
atomic64_set(&j->reservations.counter,
|
|
|
|
((union journal_res_state)
|
|
|
|
{ .cur_entry_offset = JOURNAL_ENTRY_CLOSED_VAL }).v);
|
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
if (!(init_fifo(&j->pin, JOURNAL_PIN, GFP_KERNEL))) {
|
2017-03-17 06:18:50 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(j->buf); i++) {
|
|
|
|
j->buf[i].buf_size = JOURNAL_ENTRY_SIZE_MIN;
|
|
|
|
j->buf[i].data = kvpmalloc(j->buf[i].buf_size, GFP_KERNEL);
|
|
|
|
if (!j->buf[i].data) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
j->pin.front = j->pin.back = 1;
|
|
|
|
out:
|
|
|
|
pr_verbose_init(c->opts, "ret %i", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* debug: */
|
|
|
|
|
2020-12-05 21:25:05 +00:00
|
|
|
void __bch2_journal_debug_to_text(struct printbuf *out, struct journal *j)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
|
|
|
struct bch_fs *c = container_of(j, struct bch_fs, journal);
|
2019-02-26 19:28:08 +00:00
|
|
|
union journal_res_state s;
|
2017-03-17 06:18:50 +00:00
|
|
|
struct bch_dev *ca;
|
2021-12-05 03:03:07 +00:00
|
|
|
unsigned long now = jiffies;
|
2022-03-01 00:17:27 +00:00
|
|
|
u64 seq;
|
2020-11-13 23:36:33 +00:00
|
|
|
unsigned i;
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
if (!out->nr_tabstops)
|
|
|
|
printbuf_tabstop_push(out, 24);
|
2022-02-25 18:18:19 +00:00
|
|
|
out->atomic++;
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
rcu_read_lock();
|
2019-02-26 19:28:08 +00:00
|
|
|
s = READ_ONCE(j->reservations);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-10-19 22:31:33 +00:00
|
|
|
prt_printf(out, "dirty journal entries:\t%llu/%llu\n", fifo_used(&j->pin), j->pin.size);
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "seq:\t\t\t%llu\n", journal_cur_seq(j));
|
|
|
|
prt_printf(out, "seq_ondisk:\t\t%llu\n", j->seq_ondisk);
|
|
|
|
prt_printf(out, "last_seq:\t\t%llu\n", journal_last_seq(j));
|
|
|
|
prt_printf(out, "last_seq_ondisk:\t%llu\n", j->last_seq_ondisk);
|
|
|
|
prt_printf(out, "flushed_seq_ondisk:\t%llu\n", j->flushed_seq_ondisk);
|
|
|
|
prt_printf(out, "prereserved:\t\t%u/%u\n", j->prereserved.reserved, j->prereserved.remaining);
|
|
|
|
prt_printf(out, "watermark:\t\t%s\n", bch2_journal_watermarks[j->watermark]);
|
|
|
|
prt_printf(out, "each entry reserved:\t%u\n", j->entry_u64s_reserved);
|
|
|
|
prt_printf(out, "nr flush writes:\t%llu\n", j->nr_flush_writes);
|
|
|
|
prt_printf(out, "nr noflush writes:\t%llu\n", j->nr_noflush_writes);
|
|
|
|
prt_printf(out, "nr direct reclaim:\t%llu\n", j->nr_direct_reclaim);
|
|
|
|
prt_printf(out, "nr background reclaim:\t%llu\n", j->nr_background_reclaim);
|
|
|
|
prt_printf(out, "reclaim kicked:\t\t%u\n", j->reclaim_kicked);
|
|
|
|
prt_printf(out, "reclaim runs in:\t%u ms\n", time_after(j->next_reclaim, now)
|
2021-12-05 03:03:07 +00:00
|
|
|
? jiffies_to_msecs(j->next_reclaim - jiffies) : 0);
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "current entry sectors:\t%u\n", j->cur_entry_sectors);
|
|
|
|
prt_printf(out, "current entry error:\t%s\n", bch2_journal_errors[j->cur_entry_error]);
|
|
|
|
prt_printf(out, "current entry:\t\t");
|
2019-02-26 19:28:08 +00:00
|
|
|
|
|
|
|
switch (s.cur_entry_offset) {
|
|
|
|
case JOURNAL_ENTRY_ERROR_VAL:
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "error");
|
2019-02-26 19:28:08 +00:00
|
|
|
break;
|
|
|
|
case JOURNAL_ENTRY_CLOSED_VAL:
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "closed");
|
2019-02-26 19:28:08 +00:00
|
|
|
break;
|
|
|
|
default:
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "%u/%u", s.cur_entry_offset, j->cur_entry_u64s);
|
2019-02-26 19:28:08 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_newline(out);
|
2020-11-13 23:36:33 +00:00
|
|
|
|
2022-03-01 00:17:27 +00:00
|
|
|
for (seq = journal_cur_seq(j);
|
|
|
|
seq >= journal_last_unwritten_seq(j);
|
|
|
|
--seq) {
|
|
|
|
i = seq & JOURNAL_BUF_MASK;
|
2020-11-13 23:36:33 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "unwritten entry:");
|
|
|
|
prt_tab(out);
|
|
|
|
prt_printf(out, "%llu", seq);
|
|
|
|
prt_newline(out);
|
|
|
|
printbuf_indent_add(out, 2);
|
2022-02-25 15:28:20 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "refcount:");
|
|
|
|
prt_tab(out);
|
|
|
|
prt_printf(out, "%u", journal_state_count(s, i));
|
|
|
|
prt_newline(out);
|
2022-02-25 15:28:20 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "sectors:");
|
|
|
|
prt_tab(out);
|
|
|
|
prt_printf(out, "%u", j->buf[i].sectors);
|
|
|
|
prt_newline(out);
|
2022-02-25 15:28:20 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "expires");
|
|
|
|
prt_tab(out);
|
|
|
|
prt_printf(out, "%li jiffies", j->buf[i].expires - jiffies);
|
|
|
|
prt_newline(out);
|
2022-02-25 15:28:20 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
printbuf_indent_sub(out, 2);
|
2020-11-13 23:36:33 +00:00
|
|
|
}
|
2019-02-26 19:28:08 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out,
|
2019-02-26 19:28:08 +00:00
|
|
|
"replay done:\t\t%i\n",
|
2018-11-09 06:24:07 +00:00
|
|
|
test_bit(JOURNAL_REPLAY_DONE, &j->flags));
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "space:\n");
|
|
|
|
prt_printf(out, "\tdiscarded\t%u:%u\n",
|
2020-11-14 17:29:21 +00:00
|
|
|
j->space[journal_space_discarded].next_entry,
|
|
|
|
j->space[journal_space_discarded].total);
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "\tclean ondisk\t%u:%u\n",
|
2020-11-14 17:29:21 +00:00
|
|
|
j->space[journal_space_clean_ondisk].next_entry,
|
|
|
|
j->space[journal_space_clean_ondisk].total);
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "\tclean\t\t%u:%u\n",
|
2020-11-14 17:29:21 +00:00
|
|
|
j->space[journal_space_clean].next_entry,
|
|
|
|
j->space[journal_space_clean].total);
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "\ttotal\t\t%u:%u\n",
|
2020-11-14 17:29:21 +00:00
|
|
|
j->space[journal_space_total].next_entry,
|
|
|
|
j->space[journal_space_total].total);
|
|
|
|
|
2020-11-13 23:36:33 +00:00
|
|
|
for_each_member_device_rcu(ca, c, i,
|
2020-07-09 22:28:11 +00:00
|
|
|
&c->rw_devs[BCH_DATA_journal]) {
|
2017-03-17 06:18:50 +00:00
|
|
|
struct journal_device *ja = &ca->journal;
|
|
|
|
|
2021-03-19 20:30:01 +00:00
|
|
|
if (!test_bit(ca->dev_idx, c->rw_devs[BCH_DATA_journal].d))
|
|
|
|
continue;
|
|
|
|
|
2017-03-17 06:18:50 +00:00
|
|
|
if (!ja->nr)
|
|
|
|
continue;
|
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "dev %u:\n", i);
|
|
|
|
prt_printf(out, "\tnr\t\t%u\n", ja->nr);
|
|
|
|
prt_printf(out, "\tbucket size\t%u\n", ca->mi.bucket_size);
|
|
|
|
prt_printf(out, "\tavailable\t%u:%u\n", bch2_journal_dev_buckets_available(j, ja, journal_space_discarded), ja->sectors_free);
|
|
|
|
prt_printf(out, "\tdiscard_idx\t%u\n", ja->discard_idx);
|
|
|
|
prt_printf(out, "\tdirty_ondisk\t%u (seq %llu)\n", ja->dirty_idx_ondisk, ja->bucket_seq[ja->dirty_idx_ondisk]);
|
|
|
|
prt_printf(out, "\tdirty_idx\t%u (seq %llu)\n", ja->dirty_idx, ja->bucket_seq[ja->dirty_idx]);
|
|
|
|
prt_printf(out, "\tcur_idx\t\t%u (seq %llu)\n", ja->cur_idx, ja->bucket_seq[ja->cur_idx]);
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
2022-02-25 18:18:19 +00:00
|
|
|
|
|
|
|
--out->atomic;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
|
|
|
|
2020-12-05 21:25:05 +00:00
|
|
|
void bch2_journal_debug_to_text(struct printbuf *out, struct journal *j)
|
|
|
|
{
|
|
|
|
spin_lock(&j->lock);
|
|
|
|
__bch2_journal_debug_to_text(out, j);
|
|
|
|
spin_unlock(&j->lock);
|
|
|
|
}
|
|
|
|
|
2022-02-26 16:48:34 +00:00
|
|
|
bool bch2_journal_seq_pins_to_text(struct printbuf *out, struct journal *j, u64 *seq)
|
2017-03-17 06:18:50 +00:00
|
|
|
{
|
|
|
|
struct journal_entry_pin_list *pin_list;
|
|
|
|
struct journal_entry_pin *pin;
|
|
|
|
|
|
|
|
spin_lock(&j->lock);
|
2022-02-26 16:48:34 +00:00
|
|
|
*seq = max(*seq, j->pin.front);
|
|
|
|
|
|
|
|
if (*seq >= j->pin.back) {
|
|
|
|
spin_unlock(&j->lock);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-02-25 18:18:19 +00:00
|
|
|
out->atomic++;
|
|
|
|
|
2022-02-26 16:48:34 +00:00
|
|
|
pin_list = journal_seq_pin(j, *seq);
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "%llu: count %u", *seq, atomic_read(&pin_list->count));
|
|
|
|
prt_newline(out);
|
|
|
|
printbuf_indent_add(out, 2);
|
2022-02-24 23:19:32 +00:00
|
|
|
|
2022-02-26 16:48:34 +00:00
|
|
|
list_for_each_entry(pin, &pin_list->list, list) {
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "\t%px %ps", pin, pin->flush);
|
|
|
|
prt_newline(out);
|
2022-02-26 16:48:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(pin, &pin_list->key_cache_list, list) {
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "\t%px %ps", pin, pin->flush);
|
|
|
|
prt_newline(out);
|
2022-02-26 16:48:34 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-02-26 16:48:34 +00:00
|
|
|
if (!list_empty(&pin_list->flushed)) {
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "flushed:");
|
|
|
|
prt_newline(out);
|
2022-02-26 16:48:34 +00:00
|
|
|
}
|
2017-03-17 06:18:50 +00:00
|
|
|
|
2022-02-26 16:48:34 +00:00
|
|
|
list_for_each_entry(pin, &pin_list->flushed, list) {
|
2023-02-04 02:01:40 +00:00
|
|
|
prt_printf(out, "\t%px %ps", pin, pin->flush);
|
|
|
|
prt_newline(out);
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|
2022-02-25 18:18:19 +00:00
|
|
|
|
2023-02-04 02:01:40 +00:00
|
|
|
printbuf_indent_sub(out, 2);
|
2022-02-26 16:48:34 +00:00
|
|
|
|
2022-02-25 18:18:19 +00:00
|
|
|
--out->atomic;
|
2017-03-17 06:18:50 +00:00
|
|
|
spin_unlock(&j->lock);
|
2022-02-26 16:48:34 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bch2_journal_pins_to_text(struct printbuf *out, struct journal *j)
|
|
|
|
{
|
|
|
|
u64 seq = 0;
|
|
|
|
|
|
|
|
while (!bch2_journal_seq_pins_to_text(out, j, &seq))
|
|
|
|
seq++;
|
2017-03-17 06:18:50 +00:00
|
|
|
}
|